É com grande prazer que trago para vocês o post de nossa aluna da Academia ABAP, Claudia Andressa Inacio Estevão. Esse foi um dos exercícios propostos como desafio para a sala e a Claudia conseguiu fazer e fez bonito.

Vendo a solução dela propomos que ela escrevesse um post explicando a sua solução. Abaixo o que vocês lerão é o texto enviado por ela. Tenham uma ótima leitura, pois a vale a pena entender como ela resolver o problema.

Aproveito para estender o convite a outros leitores, caso queiram submeter algum texto, entrem em contato conosco.

Parabéns a Claudia que batalhou, sofreu e suou a camisa para conseguir fazer todo esse trabalho.  Tenho certeza que ela aprendeu muito com a experiência, inclusive descrevendo a sua solução para um post do nosso site.

Ainda em tempo, tudo dentro do prazo proposto!

Abraços e bons estudos!

Quem acompanha este blog e conhece um pouco sobre os autores sabe que ambos são instrutores de uma academia de ABAP. Pois bem, meu nome é Claudia e estou entre seus alunos das aulas aos SÁBADOS (afinal, se queremos conseguir algo na vida, fazer um “sacrifício” é “quase” importante, não é?). E foi durante o curso que recebemos um desafio: Criar um programa que leia os dados das tabelas SCARR, SPFLI, SFLIGHT e SBOOK e mostre seus dados em um ALV na tela inteira.

O programa deve mostrar os dados da tabela escolhida na tela de seleção (SCARR, SPFLI, SFLIGHT e SBOOK).

Os campos da tela devem estar habilitados somente quando fizerem parte da chave da tabela selecionada.

Tela de Seleção

Parece simples, para você? Não se for um “quase júnior”!

O Flávio e o Fábio me convidaram para explicar a minha solução para este programa, e obviamente aceitei. Desta forma, vou tentar mostrá-lo de modo simples e espero poder ajudar os novatos na área, como eu!

Primeiramente, criei a tela de seleção, conforme o código abaixo:

No Block “Filter” ao invés de utilizarmos select options com as funções “NO-EXTENSION NO INTERVALS” é mais indicado utilizarmos um parameter (utilizei o select options para entender seu comportamento no debug).

Seguem os valores inseridos nos text-symbols:

text-f01: Filter

text-f02: Display data from table

text-c01 (02, 03 e 04) Os nomes das respectivas tabelas.

Para alterar os nomes exibidos na tela clique no menu: Goto->Text Elements->Selection Texts e insira o texto desejado.

Como criar os textos para a tela de seleção.

Com a tela de seleção finalizada, vamos criar a segunda tela, onde o ALV será exibido.

No Screen Painter da nova tela, insira um objeto Custom Control e atribua um nome. No meu caso ‘CONTAINER1’, conforme figura abaixo:

Screen Painter

Não devemos nos esquecer de programar os botões ‘Back’ e ‘Cancel’, que não colocarei os códigos aqui por serem simples e não serem nosso objetivo.

Para gerar o ALV, precisamos criar os objetos: Container (associado ao container que geramos no Screen Painter) e Grid, vide códigos abaixo.

Declaração das referências aos objetos.

Como aprendemos que devemos usar orientação a objetos sempre que possível (e confesso que preciso estudar isso um “pouco” mais), em um novo include, criei classes para popular o grid do ALV de acordo com as tabelas selecionadas na tela.

Abaixo, a classe que popula o grid quando a tabela SCARR é selecionada.

Classe LCL_ALV_SCARR - Definition

O Tipo so_car_ty foi criado porque precisamos receber da tela de seleção o que foi inserido no select options (scarr-carrid). Como sabemos, o select options é uma tabela com header line, e a estrutura acima simula tal tabela.

No método constructor, apenas receberemos a referência ao objeto grid, que criamos no programa principal, e o atribuiremos à variável privada r_grid para utilizarmos na implementação do método popula_alv_scarr.

O método popula_alv_scarr, por sua vez, realizará o select conforme parâmetros recebidos e populará a tabela do objeto grid. Segue implementação:

Classe LCL_ALV_SCARR - Implementation

Outras três classes devem ser criadas, para cada uma das tabelas.

Todas elas são semelhantes, alterando apenas os parâmetros recebidos. Veja a classe referente à tabela SBOOK, a mais complexa (que recebe parâmetros de todos os select options).

Classe LCL_ALV_SBOOK - Definition

Classe LCL_ALV_SBOOK - Implementation

De volta ao programa principal, vamos criar os objetos com referência às classes codificadas (no “INITIALIZATION”, assim como os objetos grid e container).

Observe que passamos a mesma referência do objeto grid para todas as classes codificadas, visto que só temos um objeto container na tela criada.

Agora, precisamos chamar os métodos popula_alv das classes criadas (o que deve ser feito no PAI da tela de seleção, ou seja, em “AT SELECTION-SCREEN”).

Relembro que os parâmetros exportados são os select-options. Caso não recebam nenhum valor, o select será realizado em toda a tabela.

Para habilitar / desabilitar os campos da tela, utilizei os métodos set_input e commit_screen da classe lcl_dynpro_handler, sujerida aqui mesmo no blog:

Conclusões

Bom, esta é a minha solução. Espero ter contribuído de alguma forma!

Abaixo, seguem algumas melhorias sugeridas pelo Fábio e Flávio:

• Da forma como foram implementadas as classes, poderíamos utilizar Interfaces, com os conceitos de herança e polimorfismo;
• Poderíamos utilizar “RANGE OF” ou “ rseloption” para importar os valores dos select-options nas classes (ao invés de criar o tipo so_car_ty).

Seguem alguns links sobre tratamento de tela:

Classe Para Tratamento de Tela de Seleção

ScreenBreaker

ScreenBreaker no Code Exchange

Para quem quiser praticar mais, fica a sugestão de estudar as dicas acima e melhorar o código!

Segue o NUGG file com toda a solução: NUGG_Z_ALV_BLOG.nugg. Veja aqui como abrir esse arquivo.

Olá caros!

No post “Faça parte da SDN“, tratamos brevemento sobre o que é a SDN e qual o seu intuito.

Outro dia ao necessitar fazer um ALV editável, descobri através do help e da comunidade que esta “simples” funcionalidade não é atendida pela classe de ALV mais moderna, a CL_SALV_TABLE.

No entanto, achei um post no fórum nomeado “cl_salv_table – needs editable functionality – SAP please provide this” que tem a intenção de servir como um abaixo-assinado pedindo que a SAP incorpore essa funcionalidade o mais breve possível nas classes CL_SALV_*.

E essa requisição da comunidade tem fundamento. Ora, quantos programas não possuem ao menos um ALV? Quantos desenvolvedores concordam que as classes CL_SALV_* facilitam o desenvolvimento e ajudam a garantir um programa entregue mais rapidamente? E quais são as chances de um programa com ALV utilizando tais classes precisar ser alterado para incorportar a funcionalidade de edição?

Para todas essas perguntas há uma única resposta: “O suficiente”. O suficiente para saber que o retrabalho necessário caso haja uma simples mudança de requisito é considerável.

Por isso, divulgo esse abaixo-assinado para todos aqueles que já precisaram e precisarão criar um ALV com tal característica. Basta responder o fórum na SDN com um “agree”.

Abraços!

Problema

Criar uma cópia do relatório ZSALV_ALV_FIELDCAT implementado nesse post, para que seja monstrado uma mensagem quando o usuário der um duplo clique. Nessa mensagem, deve ser apresentado “Você deu duplo clique na coluna & e linha &.”, onde & deverá ser substituído pelo nome da coluna e linha onde ocorreu o duplo clique.

Solução

Passo 1: Criar um novo include no programa principal. Para isso, colocar a instrução INCLUDE na seguinte posição:

…
DATA: it_sflight TYPE TABLE OF ty_flight,
wa_sflight LIKE LINE OF it_sflight.

INCLUDE zsalv_alv_event_incl.

DATA: r_event_handler TYPE REF TO lcl_event_handler.
START-OF-SELECTION.
…

Dar um duplo clique no nome do include e confirmar a criação do novo objeto. Garanta que o novo objeto seja do tipo include:

Passo 2: Criar uma classe local para receber e manipular o evento double_click do ALV:

*----------------------------------------------------------------------*
*       CLASS lcl_event_handler DEFINITION
*----------------------------------------------------------------------*
*
*----------------------------------------------------------------------*
CLASS lcl_event_handler DEFINITION.
  PUBLIC SECTION.
    METHODS: on_user_command FOR EVENT double_click
             OF cl_salv_events_table
              IMPORTING row column.
ENDCLASS.                    "lcl_event_handler DEFINITION

*----------------------------------------------------------------------*
*       CLASS lcl_event_handler IMPLEMENTATION
*----------------------------------------------------------------------*
*
*----------------------------------------------------------------------*
CLASS lcl_event_handler IMPLEMENTATION.
  METHOD on_user_command.
    MESSAGE i001(00) WITH
                'Você deu duplo clique na coluna' column 'e linha ' row.
  ENDMETHOD.                    "on_user_command
ENDCLASS.                    "lcl_event_handler IMPLEMENTATION</font>

Passo 3: Criar um objeto e registrar o evento:

…
* Set event handling
r_events = r_table->get_event( ).
CREATE OBJECT r_event_handler.
SET HANDLER r_event_handler->on_user_command FOR r_events.
…

Agora você pode ativar o seu programa e testar.

Execução e Teste

Para executar e testar o programa, apenas pressione F8 ou :

Dar um duplo clique em qualque linha e aí uma mensagem deverá ser apresentada:

Discussão

Os eventos para a CL_SALV_TABLE são um puco diferentes da CL_GUI_ALV_GRID. Já comentei que a classe CL_SALV_TABLE encapsula as funcionalidades do CL_GUI_ALV_GRID, incluindo os eventos.

Quando trabalhamos com eventos com a técnica “pura”, temos que registrar os eventos e implementar os métodos para tratar esses eventos diretamente da CL_GUI_ALV_GRID. Com as classes “salv” temos uma classe que encapsula os eventos do grid, chamada CL_SALV_EVENTS_TABLE.

O evento que uso nesse problema é o DOUBLE_CLICK que é disparado da classe CL_SALV_EVENTS_TABLE. Veja que no evento DOUBLE_CLICK temos os parâmetros COLUMN, nome da coluna onde ocorreu o evento e ROW, que é o número da linha onde ocorreu o evento evento. Com esses dois parêmetros conseguimos identificar a coluna e a linha em que o usuário deu o duplo clique (usando o READ TABLE … index ROW na tabela de dados do ALV).

Anexos

ZSALV_ALV_EVENT.txt
ZSALV_ALV_EVENT_INCL.txt

Veja Também

ABAP Control Exemples
ALV at SAP Help
Introdução ao ALV – Série Especial
ALV com Evento – Usando a Técnica “Pura”

Problema

Implementar um relatório ALV, para mostrar todos os dados e todos os campos da tabela SFLIGHT. Também é requerido um novo campo chamado Taxa de Ocupação, onde é mostrado a relação entre capacidade máxima de  passageiros e ocupação atual do vôo.

Solução

Passo 1: Criar um programa executável, sem TOP include, ZSALV_ALV_FIELDCAT.

Passo 2: Criar as referências para os objetos do grid:

DATA: r_table     TYPE REF TO cl_salv_table,
r_columns   TYPE REF TO cl_salv_columns_table,
r_column    TYPE REF TO cl_salv_column,
r_functions TYPE REF TO cl_salv_functions.

Passo 3: Criar uma tabela interna sem header line, fazer a seleção de todos os dados da tablea SFLIGHT e fazer o cálculo da taxa de ocupação.

TYPES: BEGIN OF ty_flight.
INCLUDE TYPE sflight.
TYPES: txocc TYPE p DECIMALS 2,
END OF ty_flight.

DATA: r_table     TYPE REF TO cl_salv_table,
r_columns   TYPE REF TO cl_salv_columns_table,
r_column    TYPE REF TO cl_salv_column,
r_functions TYPE REF TO cl_salv_functions.

DATA: it_sflight TYPE TABLE OF ty_flight,
wa_sflight LIKE LINE OF it_sflight.

….

SELECT * FROM sflight INTO TABLE it_sflight.

LOOP AT it_sflight INTO wa_sflight.
wa_sflight-txocc =
( wa_sflight-seatsocc / wa_sflight-seatsmax ) * 100.
MODIFY it_sflight FROM wa_sflight.
ENDLOOP.

Passo 4: Criar a referência com o método FACTORY para o objeto ALV:

TRY.
cl_salv_table=>factory(
IMPORTING
r_salv_table = r_table
CHANGING
t_table      = it_sflight ).
CATCH cx_salv_msg .
ENDTRY.

Passo 5: Ajustar os dados para a nova coluna:

r_columns = r_table->get_columns( ).
r_columns->set_optimize( abap_true ).

r_column = r_columns->get_column( ‘TXOCC’ ).
r_column->set_short_text( ‘Tx. Occ.’ ).
r_columns->set_column_position( columnname = ‘TXOCC’ position = 10 ).

Passo 5: Chamar o método DISPLAY para mostrar os grid:

r_table->display( ).

Agora você pode ativar o seu programa e testar.

Execução e Teste

Para executar e testar o programa, apenas pressione F8 ou :

Discussão

Na versão Netweaver 04, a SAP introduziu a família de classes CL_SALV*, que basicamente encapsula as operações que fizemos no post ALV Simples – Usando a Técnica “Pura”. Podemos dizer que essa família de classes veio para substituir as técnicas baseadas nas Function Modules da família REUSE*.

As classes SALV tornam a manipulação do ALV extremamente simples. No exemplo de ALV simples não fica tão claro, mas nesse exemplo vemos claramente que o ALV com as classes SALV ficam muito mais “orientado a objetos”.

Quando estiver trabalhando com elas, você deve pensar o ALV como um objeto, mas composto por diversos outros objetos, como por exemplo, colunas.

Ou seja, após criar o objeto CL_SALV_TABLE com o método FACTORY, você só precisa usar métodos GET… para obter as referências aos objetos agregados, como colunas, coluna individual e funções do grid.

Adicionando Nova Coluna ao Grid

Diferentemente do método “puro”, você não precisa criar uma tabela interna para ajustar o field catalog, mas apenas trabalhar com os atributos do objeto CL_SALV_COLUMN. Muito mais simples e intuitivo.

r_columns = r_table->get_columns( ).

Com o método get_columns( ), você obtém a referência para o objeto CL_SALV_COLUMNS_TABLE, que são as colunas do grid. Lembre-se que ela não contém os valores das colunas, apenas metadados (informações das colunas em si).

r_columns->set_optimize( abap_true ).

O método set_optimize( ) você pode definir que a largura das colunas serão otimizadas de acordo com o contéudo da coluna.

r_column = r_columns->get_column( ‘TXOCC’ ).

Com o método get_column( ) você retorna a referência a uma data coluna, de acordo com o nome técnico do campo que você passou no parâmetro. No caso acima, o nome do nosso campo que queremos alterar as características é o TXOCC.

r_column->set_short_text( ‘Tx. Occ.’ ).

Esse método, set_short_text( ) define o texto curto para a coluna.

r_columns->set_column_position( columnname = ‘TXOCC’ position = 10 ).

Finalmente, com o método set_column_position( ), você define a posição de uma coluna.

Anexos

ZSALV_ALV_FIELDCAT.txt

Veja Também

ALV Output Display
Introdução ao ALV – Série Especial
ALV com Field Catalog – Usando a Técnica “Pura”

Problema

Implementar um relatório ALV, para mostrar todos os dados e todos os campos da tabela SFLIGHT.

Solução

Passo 1: Criar um programa executável, sem TOP include, ZSALV_ALV_SIMPLE.

Passo 2: Criar as referências para os objetos do grid:

DATA: r_table     TYPE REF TO cl_salv_table,
r_functions TYPE REF TO cl_salv_functions.

Passo 3: Criar uma tabela interna sem header line e fazer a seleção de todos os dados da tablea SFLIGHT.

DATA: it_sflight TYPE TABLE OF sflight.

START-OF-SELECTION.

  SELECT * FROM sflight INTO TABLE it_sflight.

Passo 4: Criar a referência com o método FACTORY para o objeto ALV:

CALL METHOD cl_salv_table=>factory
IMPORTING
r_salv_table = r_table
CHANGING
t_table = it_sflight.

Passo 5: Chamar o método DISPLAY para mostrar os grid:

CALL METHOD r_table->display.

Agora você pode ativar o seu programa e testar.

Execução e Teste

Para executar e testar o programa, apenas pressione F8 ou :

Discussão

Na versão Netweaver 04, a SAP introduziu a família de classes CL_SALV*, que basicamente encapsula as operações que fizemos no post ALV Simples – Usando a Técnica “Pura”. Podemos dizer que essa família de classes veio para substituir as técnicas baseadas nas Function Modules da família REUSE*.

Esse exemplo que usei é muito simples. Apenas criei a referência do grida (classe CL_SALV_TABLE) e chamei o método DISPLAY para mostrar o grid. Hoje, é a maneira mais fácil de se criar um ALV Grid.

Anexos

ZSALV_ALV_SIMPLE

Veja Também

ALV Output Display
Introdução ao ALV – Série Especial

Problema

Alterar o relatório ZPURE_ALV_FIELDCAT implementado nesse post, para que seja monstrado uma mensagem quando o usuário der um duplo clique.

Nessa mensagem, deve ser apresentado “Você deu duplo clique na coluna & e linha &.”, onde & deverá ser substituído pelo nome da coluna e linha onde ocorreu o duplo clique.

Solução

Passo 1: Criar um novo include no programa principal. Para isso, colocar a instrução INCLUDE na seguinte posição:

Dar um duplo clique no nome do include e confirmar a criação do novo objeto. Garanta que o novo objeto seja to tipo include:

Passo 2: Criar uma classe local para receber e manipular o evento double_click do ALV:

Passo 3: Criar um objeto e registrar o evento no module PBO:

Agora você pode ativar o seu programa e testar.

Execução e Teste

Para executar e testar o programa, apenas pressione F8 ou :

Dar um duplo clique em qualque linha e aí uma mensagem deverá ser apresentada:

Discussão

Introdução a Eventos

Para eventos sempre temos dois objetos envolvidos, um sender e outro handler. Ou seja, um objeto que dispara o evento e outro que recebe o evento.

A principal característica é que o objeto que envia/dispara o evento não sabe quem é que receberá esse evento. Essa é a grande diferênça entre eventos e chamada de métodos. Quando chamamos um método temos que necessariamente saber de qual objeto estamos invocando aquele método.

Um bom exemplo do conceito de eventos é o caso dos passageiros no avião. No avião temos um botão em nossa poltrona que chama o comissário ou comissária para nos atender em alguma solicitação.

Quando apertamos o botão (disparamos um evento) um aviso é dado na “sala de comissários”, e um dos deles virá lhe atender. Repare que você não sabe qual comissário (classe) irá lhe atender, até que o comissário apareça (objeto).

Implementando Eventos

Para implementar um evento, precisamos de 4 passos:

Na classe Sender:

i – Declarar o nome do evento, usando a declaração EVENTS na DEFINITION da classe sender.
ii – Disparar o evento no método onde o evento deve ser disparado, usando o comando RAISE EVENT .

Na classe Handler:

iii – Definir qual método irá responder ao evento, adicionando a cláusula … FOR EVENT FOR .
iv – Registrar o evento, com o comando SET HANDLER.

O registro do evento é responsável por ativar e desativar o evento em tempo de execução (run time).

Voltando ao nosso exemplo do avião, há determinados momentos que os comissários não atenderão a nenhuma solicitação, como por exemplo nas decolagens e aterrisagens. Ou seja, o evento continua sendo disparado (passageiro apertando o botão de chamado) e o sinal continua sendo tocado na “sala de comissários”. No entanto, os comissários não lhe atenderão.

O registro de um evento também pode ser seletivo quando a qual objeto o evento será registrado. Por isso temos FOR ALL INSTANCES no comando SET HANDLER. Nesse ponto, podemos definir para qual objeto queremos registrar o evento.

Isso é vital para os casos que temos mais de um grid na tela e queremos responder ao evento de apenas um deles.

Implementando o Evento no ALV

No programa implementado acima, os passos i e ii já foram implementados pela classe standard CL_GUI_ALV_GRID e não precisamos nos preocupar com isso.

Precisamos apenas definir qual classe e método irá responder ao evento. Além disso devemos registrar o evento.

Para isso, devemos identificar o evento e parâmetros que esse evento usará:

Com o evento selecionado, clicar em para acessar os parâmetros do evento:

Anexos

NUGG_ZPURE_ALV_EVENT.nugg

Veja Também

ALV at SAP Help
Introdução ao ALV – Série Especial
ALV Simples – Usando a Técnica “Pura”
ALV com Field Catalog – Usando a Técnica “Pura”

Problema

Implementar um relatório ALV, para mostrar todos os dados e todos os campos da tabela SFLIGHT. Também é requerido um novo campo chamado Taxa de Ocupação, onde é mostrado a relação entre capacidade máxima de passageiros e ocupação atual do vôo.

Solução

Passo 1: Criar um programa executável, sem TOP include, ZPURE_ALV_FIELDCAT.
Passo 2: Criar as referências para os objetos do grid:

Passo 3: Criar uma tabela interna com todos os campos da tabela transparente SFLIGHT e mais um campo do tipo package, com 2 casas decimais, para guardar o valor calculado da taxa de ocupação.

Criar um tipo local para a nova estrutura contendo o cálculo da taxa de ocupação.

Com o tipo criado, criar os data objects (tabela interna e work area).

Fazer a seleção dos dados da SFLIGHT, logo no início do evento START-OF-SELECTION:

Após fazer a seleção dos dados é necessário efetuar o cálculo da taxa de ocupação e atualizar a tabela interna com esse valor:

Passo 4: Criar uma tabela interna e work area para a tabela de field catalog:

Passo 5: Criar e chamar uma tela onde o ALV será apresentado. Para criar a tela, dar um duplo clique no número da tela, confirmar a criação do objeto e entrar com uma descrição:

Importante: a tela precisa ser classificada como “Normal”

Nessa nova tela, é necessário criar um componente chamado “Custom Control” , pelo screen painter onde ALV será apresentado, ou seja, o ALV ficará limitado a essa área. Além disso, atentar para o nome desse componente, pois será utilizado nos próximos passos.

Terminado de desenhar onde o ALV será mostrado, é necessário programar o PBO e PAI da screen. Para isso entre na tab Flow Logic, descomente a linha MODULE STATUS_0100, dê um duplo clique na palavra STATUS_0100 e confirme a criação do novo includ. É importante escolher um bom nome para o include, pois todos os MODULES serão escritos nele:

Confirme a inclusão da instrução INCLUDE no programa princial.

No MODULE STATUS_0100, criar o comando SET PF-STATUS ‘PF0100′.

Dar um duplo clique no ‘PF0100′ para criar o GUI STATUS. Definir a descrição para o STATUS GUI como Normal Screen:

Na criação do Status Gui, definir uma Function Key para o botão BACK:

Também precisamos programar o PAI para o botão BACK. Para isso, descomentar  MODULE USER_COMMAND_0100 no flow logic da screen. Dar um duplo clique nesse comando, confirmar a criação de um novo MODULE no mesmo include criado para o module PBO:

Inserir o seguinte código no MODULE USER_COMMAND_0100.

Ao final do passo 5, já podemos fazer a primeira ativação do nosso programa para verificar se tudo está correto.

Passo 6: Criar os objetos para o ALV:

No PBO, criar a linha MODULE CREATE_ALV e dar um duplo clique para criar o MODULE. Escolher o mesmo include que já estamos usando para colocar os outros modules:

Nesse module, será colocado os comandos para criação dos objetos para o grid.

Também precisamos montar a tabela interna com o field catalog.

Por último, chamar o método para mostrar o grid:

Agora você pode ativar o seu programa e testar.

Execução e Teste

Para executar e testar o programa, apenas pressione F8 ou :

Discussão

Esse programa é muito parecido com o desse post. Mas para esse programa precisamo criar um field catalog para definir as características do novo campo.

Conceituando o Field Catalog do ALV

De uma maneira bem sumarizada podemos dizer que o field catalog é o que define as características das colunas do ALV. Para cada campo do ALV, temos uma linha no field catalog. O field catalog é uma tabela interna, do tipo LVC_T_FCAT (ou também LVC_S_FCAT para estruturas), onde definimos uma séria de características para cada coluna.

Nesse tipo LVC_T_FCAT, temos um campo chamado FIELDNAME, onde é feito o link com a it_outtab, veja novamente como a tabela it_fcat foi preenchida:

CLEAR wa_fcat.
wa_fcat-fieldname = ‘TXOCC’.
wa_fcat-col_pos = 10.
wa_fcat-coltext = ‘Tx. Occ.’.
APPEND wa_fcat TO it_fcat.

Ou seja, o campo FIELDNAME precisa ser o mesmo nome técnico que está na it_outtab. Veja o detalhe que está em maísculo ‘TXOCC’, caso contrário a classe grid não reconhecerá o campo.

Campos de Referência no Field Catalog

Quando chamamos o método SET_TABLE_FOR_FIRST_DISPLAY passamos o parâmetro I_STRUCTURE_NAME = ‘SFLIGHT’, onde usamos as informações semânticas (labels, documentação etc.) que estão no dicionário. Mas se o campo extra não está presente na SFLIGHT, mas está em outra tabela do dicionário (não é o caso da taxa de ocupação)?

Temos dois campos no field catalog que podemos indicar referência a outro campo e tabela do dicionário, REF_FIELD e REF_TABLE. Se o nosso campo tem a mesma referência técnia e semântica de algúm campo de outra tabela, podemos usar REF_FIELD para indicar o campo e REF_TABLE para indicar a tabela.

Lembrando que podemos sobrescrever qualquer característica usando os outros campos da tabela do field catalog.

Vamos supor que queremos incluir um campo para o telefone no nosso field catalog. O campo da it_outtab é TELEPHONE, e o campo PHONE da tabela SCUSTOM possui as mesmas características e queremos usá-la. A entrada na IT_FCAT ficaria assim:

CLEAR wa_fcat.
wa_fcat-fieldname = ‘TELEPHONE’.
wa_fcat-ref_table = ‘SCUSTOM’.
wa_fcat-ref_field = ‘PHONE’.
APPEND wa_fcat TO it_fcat.

Outro detalhe interessante seria se no exemplo acima o campo na it_outtab fosse PHONE ao invés de TELEPHONE, como na tabela SCUSTOM, eu não precisaria preencher o campo REF_FIELD no field catalog. Veja como ficaria:

CLEAR wa_fcat.
wa_fcat-fieldname = ‘PHONE’.
wa_fcat-ref_table = ‘SCUSTOM’.
APPEND wa_fcat TO it_fcat.

Detalhes na Chamada do Método SET_TABLE_FOR_FIRST_DISPLAY

Preenchido o field catalog, precisamos passá-lo na chamada do método SET_TABLE_FOR_FIRST_DISPLAY:

CALL METHOD r_grid->set_table_for_first_display
EXPORTING
i_structure_name = ‘SFLIGHT’
CHANGING
it_outtab = it_sflight
it_fieldcatalog = it_fcat.

Repare que foi usado tanto o it_outtab quanto o i_structure_name. Isso porque parte das refências vêm da definição da tabela transparente SFLIGHT e parte da tabela interna do field catalog.

Ou seja, não precisamos preencher todos os campos do field catalog, mas somente os novos campos e os campos que queremos sobre escrever as características que foram referenciadas do dicionário (i_structure_name).

Anexos

NUGG_ZPURE_ALV_FIELDCAT.nugg

Veja Também

ABAP Control Exemples

ALV at SAP Help

Problema

Implementar um relatório ALV, para mostrar todos os dados e todos os campos da tabela SFLIGHT.

 

Solução

Passo 1: Criar um programa executável, sem TOP include, ZPURE_ALV_SIMPLE.

 

Passo 2: Criar as referências para os objetos do grid.

Passo 3: Criar uma tabela interna sem header line e fazer a seleção de todos os dados da tablea SFLIGHT.

<span style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; font-size: 13px; line-height: 19px; white-space: normal;"><strong>Passo 4</strong>: Criar e chamar uma tela onde o ALV será apresentado. Para criar a tela, dar um duplo clique no número da tela, confirmar a criação do objeto e entrar com uma descrição. Importante: a tela precisa ser classificada como "Normal":</span>

<span style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; font-size: 13px; line-height: 19px; white-space: normal;"><img style="max-width: 800px;" src="http://wp3.abap101.com/wp-content/uploads/2009/08/screen-23.jpg" alt="" /></span>

Nessa nova tela, é necessário criar um componente chamado “Custom Control” , pelo screen painter onde ALV será apresentado, ou seja, o ALV ficará limitado a essa área. Além disso, atentar para o nome desse componente, pois será utilizado nos próximos passos.

Terminado de desenhar onde o ALV será mostrado, é necessário programar o PBO e PAI da screen. Para isso entre na tab Flow Logic, descomente a linha MODULE STATUS_0100, dê um duplo clique na palavra STATUS_0100 e confirme a criação do novo includ. É importante escolher um bom nome para o include, pois todos os MODULES serão escritos nele.

Confirme a inclusão da instrução INCLUDE no programa princial:

No MODULE STATUS_0100, criar o comando SET PF-STATUS ‘PF0100′.

<span style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; font-size: 13px; line-height: 19px; white-space: normal;">Dar um duplo clique no 'PF0100' para criar o GUI STATUS. Definir a descrição para o STATUS GUI como Normal Screen:</span>

Na criação do Status Gui, definir uma Function Key para o botão BACK:

Também precisamo programas o PAI para o botão BACK. Para isso, descomentar  MODULE USER_COMMAND_0100 no flow logic da screen. Dar um duplo clique nesse comando, confirmar a criação de um novo MODULE no mesmo include criado para o module PBO:

Inserir o seguinte código no MODULE USER_COMMAND_0100.

<span style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; font-size: 13px; line-height: 19px; white-space: normal;">Ao final do passo 4, já podemos fazer a primeira ativação do nosso programa para verificar se tudo está correto.</span>

Passo 5: Criar os objetos para o ALV:

No PBO, criar a linha MODULE CREATE_ALV e dar um duplo clique para criar o MODULE. Escolher o mesmo include que já estamos usando para colocar os outros modules:

Nesse module, será colocado os comandos para criação dos objetos para o grid:

<span style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; font-size: 13px; line-height: 19px; white-space: normal;">Agora você pode ativar o seu programa e testar.</span>

Execução e Teste

Para executar e testar o programa, apenas pressione F8 ou :

Discussão

A vantagem de se usar as classes dos Controls diretamente é que é possível total liberdade para contruir o seu programa da forma que você desejar. Certo que você também precisa se preocupar com todos os detalhes das telas, respostas do usuário etc., mas para atender a solicitações complexas dos usuários é sempre uma boa idéia saber “escovar um pouco de bits”.

Control Frameworks

As classes CL_GUI_CUSTOM_CONTAINER e CL_GUI_ALV_GRID fazem parte do Controls Frameworks. Esse framework fornece um conjunto de classes que são utilizados para mostrar dados para o usuário. Temos vários outros Controls, como Tree, HTML, Text Edit etc.

Todos esses controles possuem comportamentos e interações comuns, daí a classe CL_GUI_CUSTOM_CONTAINER. Essa classe fornece a base dos principais recursos para duplo clique, drag-drop etc.

Então temos uma tela e nessa tela definimo o tamanho do nosso grid, usando o screen painter. Nesse espaço será onde o grid será renderizado. Para isso, devemos criar o objeto container e associá-lo a essa área. É esse o papel do parâmetro “container_name”, onde associamos o nome “CONTAINER1″, definido no screen painter.

Após isso, associamos o objeto grid ao container, usando o parâmetro “i_parent” passando a referência do objeto grid. Com isso, temos toda a estrutura montada para o nosso ALV.

Mostrando o ALV

Após toda a estrutura montada, precisamos chamar o método responsável
por apresentar o ALV na tela, SET_TABLE_FOR_FIRST_DISPLAY. É nesse
método que passamos os principais componentes que impactarão a
renderização do grid na tela.

Nesse exemplo muito simples, somente utilizamos o básico, “i_structure_name”, para passar a estrutura do grid e “it_outtab” que contém os dados do grid.

Em exemplos futuros vou mostrar os outros parâmetros e como eles impactam no grid.

Anexos

NUGG_ZPURE_ALV_SIMPLE.nugg

Veja Também

ABAP Control Exemples
ALV at SAP Help
Introdução ao ALV – Série Especial

No decorrer dos anos a SAP vem evoluindo em vários sentidos. Vem aumentando a sua experiência na área de negócios, application server e também na parte visual.

Nesse sentido, ela evoluiu da tela verde dos terminais mainframe do R/2 para as listas (usando comandos WRITE), passando pelo ALV e agora pelo WebDynpro (WD).

O WebDynpro é a evolução natural para os browsers, levando a camada de apresentação para os browsers, saindo de cena o famoso Sapgui.

No entando, WD ainda tem muito chão para substituir por completo o Sapgui. Ainda há uma infinidade de programas que precisam ser migrados e isso levará muito tempo.

Enquanto isso, os programas baseados em dynpros (telas) tradicionais ainda ocuparão boa parte do seu tempo programando em ABAP. Por isso, apresento uma série de posts sobre ALV e como programar usando essa tecnologia.

ALV significa ABAP List Viewer. Como o próprio nome diz, é um gerado de listas, onde os dados são apresentados na seguinte forma:

Os dados são apresentados de forma tabular, como uma planilha Excel.

O ALV faz parte de um framework da SAP chamado Control Framework. Nele encontramos uma série de elementos visuais que podemos usar em nossos programas. A idéia aqui é ter uma clara separação da parte visual da parte de negócio. Ou seja, o programador precisa se preocupar com as regras de negócio, como seleção de dados, tratamento de dados etc., e o Control Framework é responsável pela apresentação dos dados.

Perceba que nesse ALV acima temos uma série de botões que já vieram pré-definidos. Nesses botões encontramos funções como ordenação, sumarização, busca, exportação etc. Tudo já está pronto, testado e aprovado. É só saber usar.

A mesma coisa para as colunas com os dados. Somente precisamos informar o conteúdo. O ALV faz o resto, como controlar layout, largura de colunas, ordem das colunas etc. É realmente muito interessante, tanto do ponto de vista de programação quanto para o usuário, que recebe um produto final com ótima usabilidade (já que seu funcionamento é muito parecido com o Excel) e muito bonito.

Podemos encontrar vários outros tipos de Controls. Para uma boa lista, você pode acessar vários exemplos da própria SE80 (ABAP Workbench).

Formas de Implementar ALV

O ALV é entregue pela SAP através de uma classe global, chamada CL_GUI_ALV_GRID e basicamente temos 3 formas de se implementar essa classe.

A primeira e mais conhecida é usando a function module REUSE_ALV_LIST_DISPLAY e seus vários outros serviços do package SLIS. A SAP encapsulou a implementação da classe CL_GUI_ALV_GRID nessa FM, tornando o trabalho do programador muito simples.

Atualmente, a SAP entrega uma série de outras classes, que fazem parte do pacote SALV, que fazem um serviço similar ao feito pela FM, mas usando chamadas de métodos.

E por último, vem a forma que eu chamo de “pura”, pois não usamos nenhuma classe ou FM para chamar a classe do ALV, mas sim a chamamos diretamente. A princípio dá mais trabalho, mas isso nos dá total controle sobre a nossa aplicação.

Quando Usar Cada Implementação

Depende. Se for necessário fazer uma aplicação com varios controles na tela, interagindo entre si, com drag-drop, eventos etc., sugiro usar a forma pura.

Agora, se a intenção é apenas um relatório simples a FM e principalmente as classes SALV são as mais aconselhadas, pois você não precisa se preocupar com uma série de coisas que a forma pura precisa fazer.

Próximos Capítulos

Nos próximos posts, vou mostrar várias formas de implementar programas usando ALV. Vou começar pela forma pura, depois passo para o uso das classes SALV e por último exemplos usando as FM REUSE.

Usarei o formato de receita de Receita ABAP, onde mostrarei 3 tipos de problemas, usando as 3 diferentes técnias.

Após essa série de posts, posso afirmar que teremos um conjunto de receitas ABAP, que cubrirão cerca de 70-80% dos problemas de ALV.

Progresso

Você pode seguir o progresso dos posts, acompanhando os links abaixo, onde eu coloquei as técnicas e os três tipos de problemas.

ALV Puro:

• Programa simples usando ALV
• Uso do field catalog
• Uso de eventos

SALV

• Programa simples usando SALV
• Uso do field catalog
• Uso de eventos

REUSE

• Programa simples usando ALV
• Uso do field catalog
• Uso de eventos

UPDATE: Por alguma razão, eu apaguei esse post e perdi os comentários. Esse texto foi recuperado do cache do Google.

Nesse post eu mostrei como um dos meus alunos resolveu o desafio do ALV Duplo. Atendendo a pedidos, eis a minha solução.

zbc401_00_alv2

zbc401_00_alv2_inc

zbc401_00_alv2_event

 

ABAP101 – ALV Duplo – Solução Flávio Furlan from Flavio Furlan on Vimeo.