Desenvolvimento Código Aberto

Se você quiser reutilizar o mesmo conjunto de instruções mais de uma vez em um programa, você pode incluí-los em uma macro. Por exemplo, isso pode ser útil para cálculos longos ou declarações WRITE complexas. Você só pode usar uma macro dentro do programa em que está definida, e a Macro só pode ser chamada após a sua definição. Uma macro substitui os valores definidos para seus parâmetros por valores utilizados pelo código do usuário e os executam, existe um limite de definição de nove parâmetros para uma macro, exemplo:  &1, &2 … &9.

Macros – Abap

Exemplo:

Neste exemplo definimos três parâmetros para serem executados por uma macro.

Abap

*&---------------------------------------------------------------------*
*& Report  ZMACROS
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Macros
*&---------------------------------------------------------------------*

REPORT  ZMACROS.

* Declara variável
DATA: resultado TYPE i.

* Define Macro
DEFINE calculo.

  resultado = &1 &2 &3.
  Write : / 'Calculo: &1 &2 &3 = ', resultado.

END-OF-DEFINITION.

* Executa Macro
Write : / 'Efetua calculos a partir de Macros', / .

calculo 10 + 10.
calculo 15 - 10.
calculo 10 * 10.
calculo 10 /  2.

Para testar e checar seu programa ABAP você pode usar técnicas especiais que permitem que o desenvolvedor avalie a velocidade de execução de uma determinada rotina. Você pode medir uma rotina de seu programa criando um campo que retorna o tempo de execução de determinada expressão ou bloco de instruções usando o comando GET RUN TIME FIELD . Você pode também usar métodos estáticos da classe chamada CL_ABAP_RUNTIME para medir tempo de execução com alta precisão de tempo.

RUNTIME

Exemplo:

Neste exemplo usamos técnicas especiais para medir o tempo de execução de rotinas ABAP, você pode notar que usamos dois métodos diferentes para medida.

Abap

*&---------------------------------------------------------------------*
*& Report  ZRUNTIMECAMPO
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Medir tempo de execução de um programa ABAP
*&---------------------------------------------------------------------*

REPORT  ZRUNTIMECAMPO.

* Declara campos para runtime
DATA : objTempo TYPE REF TO IF_ABAP_RUNTIME,
       tempo1   TYPE i,
       tempo2   TYPE i,
       tempo3   TYPE i,
       tempo4   TYPE i.

* Declara campos para calculo
DATA : Numero    TYPE i VALUE 15000,
       calculo1  TYPE i VALUE 1000,
       calculo2  TYPE i VALUE 2,
       expressao TYPE i.

* Mostra titulo
Write : / 'Medida em Microsegundos'  COLOR 3.
SKIP 2.
Write : / 'Variável'  COLOR 5.
SKIP 1.

* Cria primeira medida de tempo de execução
DO Numero TIMES.
   GET RUN TIME FIELD TEMPO1.
ENDDO.

Write : / 'Tempo de execução do primeiro looping - vazio: ', TEMPO1 COLOR 4.

* Cria segunda medida de tempo de execução
Do Numero TIMES.
   GET RUN TIME FIELD TEMPO2.
   EXPRESSAO = NUMERO * CALCULO1 / CALCULO2.
ENDDO.

* Medida de tempo atravez de um objeto Abap
Write : / 'Tempo de execução do segundo looping - calculo: ', TEMPO2 COLOR 6.
SKIP 1.

* Cria objeto
OBJTEMPO = CL_ABAP_RUNTIME=>CREATE_HR_TIMER( ).

Write : / 'Objeto'  COLOR 5.
SKIP 1.

* Medida de tempo por objeto
DO Numero TIMES.
   TEMPO3 = OBJTEMPO->GET_RUNTIME( ).
ENDDO.

Write : / 'Objeto - tempo final de execução - vazio: ', TEMPO3 COLOR 4.

* Zera variavel
EXPRESSAO = 0.

* Medida de tempo por objeto
DO Numero TIMES.
   TEMPO4 = OBJTEMPO->GET_RUNTIME( ).
   EXPRESSAO = NUMERO * CALCULO1 / CALCULO2.
ENDDO.

Write : / 'Objeto - tempo final de execução - calculo: ', TEMPO3 COLOR 6.

Em ABAP existem técnicas especiais que permitem criar além de programas dinâmicos como vimos no post anterior como também sub-rotinas temporárias. Você pode usar a instrução GENERATE SUBROUTINE POOL para criar sub-rotinas temporárias.

Esta declaração cria um pool de sub-rotina na área de memória principal do programa em execução. Você passa o código fonte do pool de sub-rotina para a tabela interna. A instrução retorna o nome do pool de sub-rotina gerada em um campo <prog> que deve ter tipo C. Você usa o nome contido em <prog> para chamar as sub-rotinas externas definidas na tabela interna através de chamadas de sub-rotinas dinâmicas.

Código Dinâmico

Exemplo:

Neste exemplo criamos uma sub-rotina temporária na memoria do programa em execução.

Abap

*&---------------------------------------------------------------------*
*& Report  ZDINAMIC_INCLUDE
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Sub-rotinas Temporarias
*& Procedimento Dinamico - Tecnicas Especiais ABAP
*&---------------------------------------------------------------------*

REPORT  ZDINAMIC_INCLUDE.

* Cria variavel para rotina
DATA Codigo(72) OCCURS 11.

* cria variaveis para menssagem
DATA : Programa(16),
       Menssagem(150),
       Linha(3),
       Palavra(10),
       Desvio(3).

* Cria código dinamico
APPEND '* Desenvolvimento Aberto' TO CODIGO.
APPEND '* ----------------------' TO CODIGO.
APPEND '* ABAP Special Techniques ' TO CODIGO.
APPEND '*' TO CODIGO.
APPEND '* Subrotina temporaria' TO CODIGO.
APPEND '' TO CODIGO.
APPEND 'PROGRAM SUBROTINA.' TO CODIGO.
APPEND 'FORM MINHASUB.' TO CODIGO.
APPEND 'WRITE : / ''Está é minha subrotina temporaria'' COLOR 6.' TO CODIGO.
APPEND 'ENDFORM.' TO CODIGO.

* Gera subrotina
GENERATE SUBROUTINE POOL CODIGO
                    NAME PROGRAMA
                    MESSAGE MENSSAGEM
                    LINE LINHA
                    WORD PALAVRA
                    OFFSET DESVIO.

* Verifica retorno
IF SY-SUBRC <> 0.

* Se houver erro:
 WRITE: / 'ERRO na geração da linha', LINHA,
        / MENSSAGEM,
        / 'Word:', PALAVRA, 'at offset', DESVIO.
ELSE.

*  Se houver sucesso:
 WRITE: / 'Técnicas Especiais ABAP - Sub-rotinas temporarias'.
 SKIP 1.
 WRITE: / 'O nome da sub rotina é ' COLOR 3, PROGRAMA COLOR 5.
 SKIP 2.
 PERFORM MINHASUB IN PROGRAM (PROGRAMA).

ENDIF.

É possível utilizar técnicas especiais de programação para criar, modificar e executar programas e procedimentos ABAP em tempo de execução. Para criar um novo programa dinâmico em tempo de execução de um programa ABAP, é necessário utilizar uma tabela interna. Para esta finalidade, pode-se criar uma tabela interna com uma única coluna de tipo de caracteres e uma largura de linha de 72 caracteres.

Programa Dinâmico

Exemplo:

Neste exemplo criamos um programa no qual a partir dele criamos um programa dinâmico e o executamos usando o Abap Runtime.

Abap

*&---------------------------------------------------------------------*
*& Report  ZDINAMICO
*&
*&---------------------------------------------------------------------*
*& Desevolvimento Aberto
*& Programa Dinamico - Tecnicas Especiais
*&---------------------------------------------------------------------*

REPORT  ZDINAMICO.

* Cria tabela interna do tipo codigo fonte
Data Codigo TYPE TABLE OF rssource-LINE.

* Adiciona linhas do programa na tabela interna
APPEND '* Desenvolvimento Aberto' TO CODIGO.
APPEND '* Dinamic program' TO CODIGO.
APPEND '' TO CODIGO.
APPEND '* Este programa foi criado utilizando:' TO CODIGO.
APPEND '* Abap Special Techniques' TO CODIGO.
APPEND '' TO CODIGO.
APPEND 'REPORT ZMEUCODIGO.' TO CODIGO.
APPEND '' TO CODIGO.
APPEND 'WRITE : / ''Este código foi criado dinamicamente''.' TO CODIGO.
APPEND 'WRITE : / ''Este programa será inserido na bibilioteca de programas''.' TO CODIGO.

* Insere o programa na biblioteca
INSERT REPORT 'ZMEUCODIGO' FROM CODIGO.

* Executa programa em tempo de execução
SUBMIT ZMEUCODIGO.

Tooltip é um elemento comum de interface gráfica GUI, também conhecida como dica de contexto é aquela moldura pop up que abre quando você passa o mouse sobre um elemento da interface (normalmente uma palavra em um texto) e que contém uma explicação adicional sobre aquele elemento que recebeu o ponteiro do mouse sobre ele. É utilizado em conjunto com um cursor, normalmente um ponteiro do mouse. O usuário paira o cursor sobre um item, sem clicar nele, e uma pequena “caixa” irá aparece com informações complementares relativas a este item.

ToolTip – Screen Painter

ToolTip

Para utilizar o tooltip no Screen Painter basta preencher a propriedade do componente com a dica requerida.

cl_salv_tooltips

O objeto de dica de ferramenta contém as seguintes informações: o tipo de dica de objeto que é para qual elemento a dica pode ser processada, o indicador para o elemento e o texto que é apresentado como dica.

Para um exemplo desta classe utilize o programa de exemplo do Netweaver: BCALV_DEMO_TOOLTIP.

Mais informações sobre tooltips: http://help.sap.com/saphelp_nw70/helpdata/en/1f/6dee408a63732ae10000000a155106/content.htm?frameset=/en/1f/6dee408a63732ae10000000a155106/frameset.htm

Exemplo:

Neste exemplo usamos a propriedade tooltip do elemento PushButton do Screen Painter, para usar o programa abaixo crie uma tela, um evento PBO e o campo OK_CODE e preencha o campo function code para o botão como F_BTN1,  para exemplo da classe use o programa citado. acima.

Abap

*&---------------------------------------------------------------------*
*& Report  ZTOOLTIP
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& ToolTip
*&---------------------------------------------------------------------*

REPORT  ZTOOLTIP.

DATA: ok_code LIKE sy-ucomm,
      clique_ok LIKE sy-ucomm.

CALL SCREEN 100.

MODULE STATUS_0100 OUTPUT.
*  SET PF-STATUS 'xxxxxxxx'.
*  SET TITLEBAR 'xxx'.

* limpa evento
  clique_ok = ok_code.
  CLEAR ok_code.

* Eventos dos botões ou teclas
  CASE clique_ok.

    WHEN 'F_BTN1'.
      LEAVE PROGRAM.

  ENDCASE.

ENDMODULE.                 " STATUS_0100  OUTPUT

SAP Container é um controle que acomoda outros controles, como o SAP Tree,  o SAP Picture , 0 SAP TextEdit , e assim por diante. Ele gerencia esses controles logicamente em uma coleção, e fornece uma área física em que eles são exibidos. Existem cinco tipos de SAP Containers.

CL_GUI_SPLITTER_CONTAINER

Representa um controle que consiste de uma barra móvel que divide a área de exibição de um recipiente em dois painéis redimensionáveis​​. Permite exibir mais de um controle em uma determinada área, dividindo-o nas células.

CL_GUI_CONTAINER

Representa um painel que pode ser alocado dentro de uma célula de um container.

Sap Container

Screen Painter

Para usar o Sap Container no modo Splitter siga os seguintes passos:

1. Crie um programa chamado ZSPLITERCONTAINER na transação SE38.
2. Você pode criar um titulo e um menu para este programa na transação SE41 (Opcional).
3. Crie uma tela de numero 100 para este programa no Screen Painter na transação SE51.
4. Crie um evento PBO padrão para a variável Status 100 na aba Flow Logic.
5. Em Layout coloque um componente Custom Control na tela e o nomeie como MEUCONTAINER.
6. Ative a tela 100.
7. Abra seu programa  e utilize o código abaixo.

Exemplo:

Neste exemplo criamos uma tela  à partir de um componente visual Custom Control que possui um painel contendo duas células redimensionáveis, cada uma contendo um painel que contem um outro componente Custom instanciado de um objeto.

Abap

*&---------------------------------------------------------------------*
*& Report  ZSPLITERCONTAINER
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& SAP Container - Splitter
*&---------------------------------------------------------------------*

REPORT  ZSPLITERCONTAINER.

* Declara componentes
DATA: meucontainer TYPE REF TO cl_gui_custom_container,
      painel       TYPE REF TO CL_GUI_SPLITTER_CONTAINER,
      imagem       TYPE REF TO CL_GUI_PICTURE,
      editor       TYPE REF TO cl_gui_textedit,
      painel1      TYPE REF TO CL_GUI_CONTAINER,
      painel2      TYPE REF TO CL_GUI_CONTAINER.

* Declara tabela interna
DATA: linha(256),
      texto_tab LIKE STANDARD TABLE OF linha.
           
* Inicio do programa
START-OF-SELECTION.

* Adiciona texto na tabela interna
linha = 'O balonismo é um esporte aeronáutico praticado com um balão de ar quente.'.
APPEND linha TO texto_tab.
linha = 'Possui adeptos em todo o mundo. No Brasil, o esporte começou a se popularizar'.
APPEND linha TO texto_tab.
linha = 'a partir dos anos 90.'.
APPEND linha TO texto_tab.
linha = 'O balão é considerado uma aeronave assim como avião, helicópteros e outros.'.
APPEND linha TO texto_tab.
linha = 'Por esta razão o balão deve ter uma matricula (prefixo) registrado junto'.
APPEND linha TO texto_tab.
linha = 'à ANAC, seu piloto deve possuir uma licença (brevê) específico para a pratica'.
APPEND linha TO texto_tab.
linha = 'do balonismo também emitido pela ANAC.'.
APPEND linha TO texto_tab.

* Chama tela Screen Painter
CALL SCREEN 100.

* Modulo PBO
MODULE STATUS_0100 OUTPUT.
*  SET PF-STATUS 'xxxxxxxx'.
*  SET TITLEBAR 'xxx'.

* Cria componentes

* Cria componente Screen Painter Custom Container
  CREATE OBJECT MEUCONTAINER
    EXPORTING
      CONTAINER_NAME = 'MEUCONTAINER'
      LIFETIME       = MEUCONTAINER->LIFETIME_DYNPRO.

* Cria Splitter Container
  CREATE OBJECT PAINEL
    EXPORTING
      PARENT  = MEUCONTAINER
      ROWS    = 1
      COLUMNS = 2
      ALIGN   = 15.

* Exibe Painel 1
  CALL METHOD PAINEL->GET_CONTAINER
    EXPORTING
      ROW       = 1
      COLUMN    = 1
    RECEIVING
      CONTAINER = PAINEL1.

* Exibe Painel 2
  CALL METHOD PAINEL->GET_CONTAINER
    EXPORTING
      ROW       = 1
      COLUMN    = 2
    RECEIVING
      CONTAINER = PAINEL2.

* Cria imagem
  CREATE OBJECT IMAGEM
    EXPORTING
      LIFETIME = IMAGEM->LIFETIME_DYNPRO
      PARENT   = PAINEL1.

*Chama imagem da url
  CALL METHOD IMAGEM->load_picture_from_url
    EXPORTING
      url   = 'https://desenvolvimentoaberto.org/wp-content/uploads/2014/04/balonismo.jpg'
    EXCEPTIONS
      error = 1.

* Cria Editor
  CREATE OBJECT EDITOR
    EXPORTING
      PARENT = PAINEL2.

* Adiciona texto
  CALL METHOD editor->set_text_as_stream
    EXPORTING
      text = texto_tab.

ENDMODULE.                 " STATUS_0100  OUTPUT

Com a evolução dos meios de comunicação, a internet, a mobilidade de informação e novos dispositivos sendo criados, nos dias de hoje é essencial que uma linguagem de programação se adapte para continuar competitiva.  O Abap possui já há algum tempo uma integração com a poderosa e quase unanime linguagem de programação para web, o Javascript e apesar do Abap ainda não suportar as versões mais recentes da linguagem possui alguns recursos excelentes que ajudam na programação Abap Javascript, como por exemplo compilar uma linguagem que é interpretada, facilitando muito para o programador encontrar erros já que o Abap neste caso fica responsável pelas mensagens de erro desta compilação, que ao contrario dos Browsers, simplesmente ignoram uma instrução com erro deixando a cargo do programador descobrir o motivo que levou a não execução do script.

Abap JavaScript

JavaScript  

É uma linguagem leve, interpretada e baseada em objetos com funções de primeira classe, mais conhecida como a linguagem de script para páginas Web, mas usada também em vários outros ambientes sem browser como node.js ou Apache CouchDB. É uma linguagem de script multi paradigma,  baseada em protótipo que é dinâmica, e suporta estilos de programação orientado a objetos, imperativo e funcional.

ABAP JavaScript

Programas ABAP JavaScript permitem executar e também permitem a transferência de dados entre ABAP e JavaScript.  A classe CL_JAVA_SCRIPT implementa uma API que pode ser usada em programas ABAP como um motor JavaScript (JS), implementado no kernel do SAP. A classe encapsula a API JavaScript C Engine e fornece ao programador ABAP métodos e atributos que podem ser usados ​​para executar programas em JavaScript no servidor de aplicativos do sistema R/3 no modo normal ou depuração (Scripting do lado do servidor). O motor de JavaScript em uso suporta JavaScript Versão 1.5. Variáveis ​​do script pode ser ligado a objetos de dados do programa ABAP (Bind).

Get

Lê uma variável global do contexto JavaScript. A variável global pode ter sido criada anteriormente ou com o método SET ou executando um script do contexto. As propriedades de um objeto não pode ser acessados. A variável global deve ser uma propriedade do objeto raiz.

Set

Define uma variável global do contexto JavaScript para um valor. Se a variável ainda não está disponível, ela é criada com o nome especificado. A variável pode ser acessada enquanto todos os scripts compilados de um mesmo contexto estão sendo executados e com o método GET. Somente as propriedades do objeto raiz pode ser definida com SET.

Limitações

O Java Script é regulamentado pelo padrão ECMAScript. Desde 2012, todos os navegadores modernos possuem suporte total ao ECMAScript 5.1. Navegadores mais antigos suportam pelo menos ECMAScript 3. Existe uma 6ª versão do padrão sendo desenvolvida no momento. Sendo assim Abap JavaScript não suporta todos os recursos atuais como por exemplo alguns recursos de manipulação de arrays através do seu protótipo usando a instrução MAP incluída pelo ECMAScript 3, você encontra o seguinte erro:

Erro de execução de script: CL_JAVA_SCRIPT, Rcode: (   600 ), Type Error objeto.map is not a function.

Exemplo:

Neste exemplo criamos um objeto instanciado da classe cl_java_script e criamos um objeto Abap e um javascript em tempo execução e passamos e retornamos parâmetros para este script através do objeto Abap.

Abap

*&---------------------------------------------------------------------*
*& Report  ZJAVASCRIPT
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Abap integrado com JavaScript
*&---------------------------------------------------------------------*

REPORT  ZJAVASCRIPT.

* Declara objetos javascript e scripts
DATA:  Get_valor TYPE string,
       JS_Objeto TYPE REF TO CL_JAVA_SCRIPT,
       MeuScript TYPE String.

* Cria Script
CONCATENATE
' function quadrado(x) { return x * x}; '
' var resultado = quadrado(mapa) '
INTO MEUSCRIPT SEPARATED BY  CL_ABAP_CHAR_UTILITIES=>CR_LF.

* Cria objeto javascript
JS_OBJETO = CL_JAVA_SCRIPT=>CREATE( ).

* Compila objeto javascript
JS_OBJETO->COMPILE(
  exporting
    SCRIPT_NAME = 'script.js'
    SCRIPT      = MEUSCRIPT ).

* Verifica compilação
if JS_OBJETO->LAST_CONDITION_CODE <> 0.
  write: / 'Erro de compilação de script',
           JS_OBJETO->LAST_ERROR_MESSAGE.
else.
  write / 'foi compilado com sucesso'.
endif.

skip.

* Define um valor de variavel atravez do ABAP
JS_OBJETO->SET( NAME = 'mapa' VALUE = '5' ).

* Executa Javascript
JS_Objeto->EXECUTE(
              exporting SCRIPT_NAME = 'script.js' ).

* Verifica se script foi executado
if JS_OBJETO->LAST_CONDITION_CODE <> 0.
  write: / 'Erro na execução de script',
           JS_OBJETO->LAST_ERROR_MESSAGE.
else.
  write / 'JavaScript foi executado com sucesso'.
endif.

skip.

* Retorna valor de script

GET_VALOR = JS_OBJETO->GET( NAME = 'resultado' ).

* Verifica se o objeto retornou um valor
if JS_OBJETO->LAST_CONDITION_CODE <> 0.
  write: / 'Erro em recuperar objeto javascript',
           JS_OBJETO->LAST_ERROR_MESSAGE.
else.
  write: / 'Valor do objeto :', GET_VALOR.
endif.

skip.

O SAP List Viewer (ALV) é um elemento integrante do ambiente de programação ABAP Objects e este controle se divide basicamente em três partes, é composto de um cabeçalho de títulos, uma barra de ferramentas e uma grade de dados.Você pode usar o AVL para exibir os seguintes componentes:  tabelas simples e bidimensionais,  listas hierárquica sequenciais e estrutura em árvore.

A SAP recomenda usar o novo modelo de objeto unificado da classe cl_gui_alv_grid para a programação de todos os seus aplicativos ALV. Assim, mesmo se você planeja usar o ALV Grid Control, você pode usar a nova API simplificada.
A SAP não garante que os métodos, eventos e atributos desta classe que não são públicas permanecerão inalterados ou estará disponível em versões futuras. É por isso que você não deve derivar da classe para acessar objetos protegidos da classe. Usando esses objetos faz com que seja mais difícil para atualizar seus programas para versões posteriores da classe.

O modo mais simples de usar o ALV Grid Control para retornar dados de uma tabela é o seguinte:

Screen Painter

1. Crie um novo programa chamado ZALVGRIDNEW.
2. Crie uma Screen para este programa usando a transação SE51.
3. Coloque em sua tela um Text Control, um Push Button e um Custom Control.
4. Nomeie o componente Custom Control como ALVGRID.
5. Nomeie os outros componentes como desejar.
6. Para o Push Button preencha sua Function Code como F_SAIR.
7. Disponha os elementos na tela como na figura abaixo:
   

   Custom Control – Design

8. Na aba Flow Logic crie os módulos PBO  e PAI padrão.
9. Na aba Element List preencha OK_CODE para o campo tipo OK.
10. Use o código abaixo para o  seu programa, ative e teste.

ALV – Nova API

Exemplo:

Neste exemplo instanciamos um objeto da classe cl_gui_alv_grid e o vinculamos ao componente Custom Control do Screen Painter. A classe cl_gui_alv_grid faz parte da nova API da família de componentes SAP List View, você usar uma serie de métodos da classe para incrementar este exemplo.

Abap

*&---------------------------------------------------------------------*
*& Report  ZALVGRIDNEW
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& ALV Grid Control New API (Objetos)
*&---------------------------------------------------------------------*

REPORT  ZALVGRIDNEW.

* Declara componentes
DATA: grid TYPE REF TO cl_gui_alv_grid,
      g_custom_container TYPE REF TO cl_gui_custom_container,
      gt_spfli TYPE TABLE OF spfli,
      OK_CODE LIKE SY-UCOMM.

* Seleciona dados da tabela
SELECT * FROM spfli INTO TABLE gt_spfli.

* Chama tela 100
CALL SCREEN 100.

* Modulo PBO
MODULE STATUS_0100 OUTPUT.
*  SET PF-STATUS 'xxxxxxxx'.
*  SET TITLEBAR 'xxx'.

  IF g_custom_container IS INITIAL.

    " Cria controle custom
    CREATE OBJECT g_custom_container
      EXPORTING
        CONTAINER_NAME = 'ALVGRID'.

    " Cria ALV Grid
    CREATE OBJECT GRID
      EXPORTING
        I_PARENT = g_custom_container.

    " Popula dados da grid
    CALL METHOD GRID->SET_TABLE_FOR_FIRST_DISPLAY
      EXPORTING
        I_STRUCTURE_NAME = 'SPFLI'
      CHANGING
        IT_OUTTAB        = GT_SPFLI.

  ENDIF.

ENDMODULE.                 " STATUS_0100  OUTPUT

* Modulo PAI

MODULE USER_COMMAND_0100 INPUT.

  CALL METHOD cl_gui_cfw=>dispatch.

  CASE OK_CODE.

    WHEN 'F_SAIR'.
      LEAVE PROGRAM.
  ENDCASE.

  CLEAR OK_CODE.

ENDMODULE.                 " USER_COMMAND_0100  INPUT