Sem dúvida, uma das atividades mais realizadas por um programador ABAP é a emissão de relatórios.

Como não estamos na era dos dinossauros, “não conhecemos” o relatório “write” e vamos direto aos “ALV’s”.

Este post tem como objetivo exemplificar algumas funcionalidades de um ALV OO (Orientado a Objetos),  são elas:

• Exclusão de botões do toolbar de um ALV OO
• Inclusão de botões no toolbar do ALV
• Utilização de eventos
• Como desabilitar um botão (ele aparece, mas não é possível clicar)
• Geração de um ALV sem necessidade de criação de um container

Veja também:

• Como encontrar ícones
• Utilização de interfaces

A modelagem utilizada, foi construída de forma a permitir a utilização dos pontos acima citados.

Especificação

Na tela de seleção, o usuário poderá determinar uma ou mais cias aéreas.  Deve ser gerado um relatório ALV com os dados desta(s) cia(s), a serem extraídos da tabela SCARR.

Neste relatório, ao selecionar uma determinada cia, deve haver um botão que gere um segundo ALV, desta vez exibindo as informações dos vôos (conexões) referentes à seleção realizada (dados a serem extraídos da tabela SPFLI).

E então, vamos ao que interessa!?

No programa principal, devemos criar a tela de seleção e um include, onde codificaremos nossas classes.

Tela de seleção:

Declara-se o select-options para possibilitar a determinação do range das cias aéreas:

include: z_classes.
 
tables: scarr,
        spfli.
 
data: wa_scarr type scarr.
 
data: r_companies type ref to lcl_companies.
 
selection-screen begin of block filter with frame title text-001.
select-options s_carrid for wa_scarr-carrid.
selection-screen end of block filter.

Selection Screen

Vamos criar também, duas telas (as quais nomeei de “0100″ e “0200″, que serão utilizadas na exibição dos ALV’s.

Screens

No include criado, segue declaração da interface:

interface: zif_data_reader.
  types: ty_scarr type range of scarr-carrid.
 
  methods: read_data
              importing
                im_scarr type ty_scarr,
 
           generate_alv
              importing
                im_structure  type char30.
 
endinterface.             "zif_data_reader

Observe que temos os métodos read_data e generate_alv, que foram declarados na interface, porque serão utilizados em ambos os relatórios.

Agora vamos à definição da classe lcl_companies, que será responsável pela leitura dos dados das cias aéreas.

*----------------------------------------------------------------------*
*       CLASS lcl_companies DEFINITION
*----------------------------------------------------------------------*
*
*----------------------------------------------------------------------*
class lcl_companies definition.
  public section.
    interfaces zif_data_reader.
 
    methods: constructor,
 
             set_toolbar
                for event toolbar of cl_gui_alv_grid
                importing e_object,
 
             get_ucomm
                for event user_command of cl_gui_alv_grid
                importing e_ucomm,
 
             refresh_table
                for event after_user_command
                of cl_gui_alv_grid.
 
  private section.
    data: r_grid        type ref to cl_gui_alv_grid,
          r_connections type ref to lcl_connections.
 
    data: gt_scarr      type table of scarr,
          gt_exc_button type ui_functions.
 
endclass.                                "lcl_companies DEFINITION

Observe que a classe tem como atributos privados:

• Objeto r_grid (para criação do grid do alv)
• Objeto r_connections para referência e criação dos objetos referentes aos vôos (conexões)
• Tabela gt_scarr, contendo as informações da(s) cia(s) aérea;
• Tabela de botões a serem excluídos

Através da keyword “INTERFACES”, declaramos a utilização da interface zif_data_reader, com isso, na classe lcl_companies devemos implementar todos os métodos contemplados na interface.

Seguem Implementações:

• Constructor: será responsável pela criação do grid do alv, registrar os eventos a serem utilizados e determinar os botões a serem excluídos.

method: constructor.
    create object r_grid
      exporting
        i_parent          = cl_gui_container=>screen0
      exceptions
        error_cntl_create = 1
        error_cntl_init   = 2
        error_cntl_link   = 3
        error_dp_create   = 4
        others            = 5.
 
    if sy-subrc ne 0.
      message id sy-msgid type sy-msgty number sy-msgno
                 with sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
    endif.
 
*--------------------------------------------------------------------*
* Registra os eventos a serem utilizados
*--------------------------------------------------------------------*
    set handler get_ucomm     for r_grid.
    set handler set_toolbar   for r_grid.
    set handler refresh_table for r_grid.
*--------------------------------------------------------------------*
* Informa os botões a serem excluídos
*--------------------------------------------------------------------*
    append cl_gui_alv_grid=>mc_fc_graph to gt_exc_button.
 
  endmethod.                              "constructor

Nota: quando informamos “cl_gui_container=>screen0″ no parâmetro “i_parent” não temos a necessidade de declarar um container (recomenda-se gerar o ALV sem container apenas em casos de real necessidade, pois esteticamente o programa será prejudicado, visto que o ALV ocupará a tela inteira).

Para entender melhor, vá até a transação SE24, na classe CL_GUI_ALV_GRID.

Na aba “métodos” você encontrará o “constructor”, clique em “Parâmetros” e verá que o parâmetro “i_parent” é do tipo “CL_GUI_CONTAINER”.

Parameter - "I_PARENT"

Clicando em CL_GUI_CONTAINER, na aba atributos, você encontrará “Screen0″.

Attribute - Screen0

Ou seja, o atributo “Screen0″ utiliza a tela como nosso container.

Entendendo a exclusão de botões

Novamente na transação SE24, consulte o método “SET_TABLE_FOR_FIRST_DISPLAY”.

Ao clicar em “parâmetros” você encontrará o “IT_TOOLBAR_EXCLUDING”, de tipo “UI_FUNCTIONS”.

Parameter - toolbar_excluding

Vamos agora para a aba de atributos da classe, onde encontraremos os botões.

CL_GUI_ALV_GRID - Botões

Desta forma, basta inserirmos os botões a serem excluídos na tabela declarada, e informá-la no momento em que chamarmos o método “SET_TABLE_FOR_FIRST_DISPLAY” (neste exercício, excluí apenas o botão utilizado para geração de gráficos).

O próximo passo é selecionarmos os dados da tabela SCARR conforme dados da tela de seleção.

• zif_data_reader~read_data

Observe que quando implementamos um método de uma interface, este é denominado: nome_da_interface~nome_ do_ método.

method: zif_data_reader~read_data.
 
      clear gt_scarr.
    refresh gt_scarr.
 
    select *
      from scarr
      into table gt_scarr
      where carrid in im_scarr[].
 
    if sy-subrc ne 0.
      message: text-002 type 'E'.
 
    else.
      call method me->zif_data_reader~generate_alv
        exporting
          im_structure = 'SCARR'.
    endif.
  endmethod.                               "zif_data_reader~read_data

Neste método, selecionamos os dados conforme critérios informados na tela de seleção.

Quando sy-subrc não é “0″ (valores não encontrados), exibimos uma mensagem de erro, caso contrário, chamamos o  método “zif_data_reader~generate_alv”, vide implementação abaixo:

method: zif_data_reader~generate_alv.
 
    call method r_grid->set_table_for_first_display
      exporting
        i_structure_name              = im_structure
        it_toolbar_excluding          = gt_exc_button
      changing
        it_outtab                     = gt_scarr
      exceptions
        invalid_parameter_combination = 1
        program_error                 = 2
        too_many_lines                = 3
        others                        = 4.
 
    if sy-subrc NE 0.
      message id sy-msgid type sy-msgty number sy-msgno
                 with sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
    endif.
 
    call screen 100.
  endmethod.                               "zif_data_reader~generate_alv

Com os dados selecionados e exibidos na tela, precisamos incluir o botão para visualizarmos as conexões das cias aéreas.

• set_toolbar - será chamado cada vez que o evento “TOOLBAR” (registrado no constructor!) for disparado pela classe CL_GUI_ALV_GRID.

Consultando os parâmetros deste evento, na transação SE24, podemos verificar que ele exporta o parâmetro “E_OBJECT”, de tipo  “CL_ALV_EVENT_TOOLBAR_SET”.

Nos atributos desta classe, encontraremos o “MT_TOOLBAR”, de tipo “TTB_BUTTON”, finalmente tipo “STB_BUTTON”, onde estão as informações que precisamos.

Veja a implementação do método “set_toolbar”:

method: set_toolbar.
    data: wa_toolbar type stb_button.
    case sy-dynnr.
      when '1000'.
 
        clear wa_toolbar.
        wa_toolbar-butn_type = 3.               "Separador
        append wa_toolbar to e_object->mt_toolbar.
 
        clear wa_toolbar.
        wa_toolbar-function  = '100_CONN'.
        wa_toolbar-icon      = icon_object_folder.
        wa_toolbar-quickinfo = 'Visualiza Conexões'.
        wa_toolbar-butn_type = 0.              "Botão Normal
        wa_toolbar-text      = 'Visualizar Conexões'.
        append wa_toolbar to e_object->mt_toolbar.
 
      when '0100'.
        clear wa_toolbar.
        wa_toolbar-butn_type = 3.              "Separador
        append wa_toolbar to e_object->mt_toolbar.
 
        clear wa_toolbar.
        wa_toolbar-function    = '100_CONN'.
        wa_toolbar-icon        = icon_object_folder.
        wa_toolbar-quickinfo   = 'Visualiza Conexões'.
        wa_toolbar-butn_type   = 0.              "Botão normal
        wa_toolbar-text        = 'Visualizar Conexões'.
        if sy-ucomm            = 'BACK'.
          wa_toolbar-disabled  = ' '.
        else.
          wa_toolbar-disabled  = 'X'.
        endif.
        append wa_toolbar to e_object->mt_toolbar.
      when others.
    endcase.
 
  endmethod.                                 "set_toolbar

Observe que temos duas tratativa diferentes para o botão: quando estamos na tela 1000 (chamando a tela 0100, que contém os dados das cias aéreas), quando deve estar habilitado, e quando estamos na tela 0100 (chamando a tela 0200, que conterá os dados das conexões), quando o botão deve estar desabilitado.

Para melhor compreensão, faça este exercício, coloque um BREAK-POINT no método e debugue! Assim você entenderá os momentos em que ele é chamado e sua tratativa!

Dica: lembre-se de utilizar text-symbols. Na implementação acima, escrevi as informações diretamente no código para facilitar o entendimento!

Nota: informamos o ícone: icon_object_folder, este nome é encontrado na tabela “ICON”, porém, algumas vezes precisamos do parâmetro “internal” quando trabalhamos com ícones. Este pode ser encontrado no programa “SHOWICON”.

• get_ucomm – é através deste que nosso botão funcionará:

method: get_ucomm.
    data: lv_row   type lvc_s_row,
          wa_scarr like line of gt_scarr.
 
    data: r_cias  type range of scarr-carrid,
          wa_cias like line of r_cias.
 
    if e_ucomm eq '100_CONN'.
      call method r_grid->get_current_cell
        importing
          es_row_id = lv_row.
 
*--------------------------------------------------------------------*
      if lv_row is initial.
        message: text-003 type 'I'.
*--------------------------------------------------------------------*
      else.
        read table gt_scarr into wa_scarr index lv_row-index.
 
        clear wa_cias.
        wa_cias-sign    = 'I'.
        wa_cias-option  = 'EQ'.
        wa_cias-low     = wa_scarr-carrid.
*        wa_cias-high   = ' ' .
        append wa_cias to r_cias.
 
        create object r_connections
          exporting
            im_grid = r_grid.
 
        call method r_connections->zif_data_reader~read_data
          exporting
            im_scarr = r_cias.
*--------------------------------------------------------------------*
      endif.
    endif.
  endmethod.                             "get_ucomm

Lembrando que este método será chamado cada vez que o evento “user_command” for disparado (conforme sua declaração), devemos verificar se o “sy-ucomm” é “100_CONN”, ou seja, se nosso botão foi “clicado”.

Com isso, chamamos o método get_current_cel para verificarmos qual foi a linha selecionada.

Verificamos em nossa tabela qual é  cia aérea referente a linha selecionada, para então criarmos o objeto referente à classe das conexões e ler seus dados.

Observe que utilizamos o range r_cias para informar a cia aérea. O range é como se fosse o select-options, por isso precisamos informar:

• sign      = “I” (Include)
• Option = “EQ” (Equal, porque informaremos uma única cia aérea.
• Low      = wa_scarr-carrid (cia aérea da linha selecionada).
• High    = Não precisamos informar, pois utilizamos “option = EQ”.

Para a classe lcl_companies, ainda precisamos implementar o método:

• refresh_table:

method refresh_table.
 
    check sy-dynnr = 100 and
          sy-ucomm = 'BACK'.
 
    call method me->zif_data_reader~generate_alv
      exporting
        im_structure = 'SCARR'.
 
  endmethod.                              "refresh_table

Este método será chamado após o user_command.

É necessário para atualizar as informações do grid quando voltamos da tela 200 para a tela 100. Sem ele, os dados das conexões permanecem na tela.

Para melhor compreensão, debugue!

Finalmente, vamos à declaração da classe “lcl_connections”.

*----------------------------------------------------------------------*
*       CLASS lcl_connections DEFINITION
*----------------------------------------------------------------------*
*
*----------------------------------------------------------------------*
class lcl_connections definition.
  public section.
    interfaces: zif_data_reader.
 
    methods: constructor
                importing
                  im_grid type ref to cl_gui_alv_grid.
 
  private section.
    data: gt_spfli       type standard table of spfli,
          gt_exc_button  type ui_functions,
          gv_carrid      type scarr-carrid.
 
    data: r_grid_conn type ref to cl_gui_alv_grid.
 
endclass.                              "lcl_connections DEFINITION

Como podem ver, esta é uma classe bem simples. Verifiquem sua implementação:

class lcl_connections implementation.
  method: constructor.
    r_grid_conn = im_grid.
  endmethod.                              "constructor
 
  method: zif_data_reader~read_data.
    clear   gt_spfli.
    refresh gt_spfli.
 
    select *
      from spfli
      into table gt_spfli
      where carrid in im_scarr.
 
    if sy-subrc = 0.
      call method me->zif_data_reader~generate_alv
        exporting
          im_structure = 'SPFLI'.
    else.
      message: text-004 type 'I'.
    endif.
 
  endmethod.                    "zif_data_reader~read_data
 
  method: zif_data_reader~generate_alv.
    data: wa_exclude like line of gt_exc_button.
 
    call method r_grid_conn->set_table_for_first_display
      exporting
        i_structure_name              = im_structure
      changing
        it_outtab                     = gt_spfli
      exceptions
        invalid_parameter_combination = 1
        program_error                 = 2
        too_many_lines                = 3
        others                        = 4.
 
    call screen 200.
 
  endmethod.                    "zif_data_reader~generate_alv
 
endclass.

Observe que o constructor é responsável apenas por “importar” o grid gerado na classe lcl_companies.

Vejam abaixo o resultado do nosso exercício:

Tela 0100 - Cias aéreas

Tela 0100, com os as informações das cias aéreas e botão habilitado.

Observe que não há o botão responsável pela geração de gráficos.

Tela 0200 - Conexões

Tela 0200, com informações das conexões e botão desabilitado.

E então, gostaram? baixe o código (Z_ALV_OO ), estude e nos envie suas dúvidas e sugestões!

Veja neste post como utilizar o arquivo.

É 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.