Desenvolvimento Pessoal

Até o momento trabalhamos exclusivamente com entidades do componente que

definimos de maneira declarativa:
 plugs de inbound e outbound;
 links de navegação;
 associação de elementos de tela à estruturas do dicionário...

Veremos agora como trabalhar com os métodos dos controladores, utilizando a

programação ABAP, assim como a manipulação de elementos presentes no
contexto.

Para definirmos o código fonte a ser implementado no controlador temos saber

quais são seus métodos pré-definidos (hook methods) e em qual ordem os mesmos
são executados.

Métodos adicionais podem ser desenvolvidos de maneira a implementar a lógica

necessária.

Manipulação de eventos: defir, disparar e tratar.

Métodos do controlador

Cada controlador de um componente WebDympro é uma classe definida globalmente.

Os demais controladores presentes no componente (janelas, visões, etc) são classes

locais definidas na classe acima descrita.

Como encontrar estas classes:

1. SE24: CL_WDY_WB_NAMING_SERVICE
2. MÉTODO: GET_CLASSNAME_FOR_COMPONENT
3. Utilizar o parâmetro de retorno “p_classname” na se24
4. Procurar por “class” e depois “include”.

As definições destas são geradas automaticamente pelo WD quando criamos um novo

componente ou controlador

Cada controlador possui um conjunto de métodos pré-definidos, dependendo de seu

tipo.

No momento da criação estes métodos estão vazios.

Métodos do controlador

As definições destas são geradas automaticamente pelo WD quando criamos um novo
componente ou controlador.

Cada controlador possui um conjunto de métodos pré-definidos, dependendo de seu

tipo.

No momento da criação estes métodos estão vazios.

Além destes, podemos definir métodos adicionais:

 “normais”;
 tratadores de eventos;
 supply functions.

A classe será regerada a cada ativação.

Não podemos alterá-la diretamente, sendo o código inserido somente nos métodos, via
SE80.
Métodos do controlador
 Métodos do controlador

Hook Methods

Existem dois métodos que são comuns a todos os controladores:

wddoinit( ):

primeiro método a ser chamado no ciclo de vida do controlador;

chamado imediatamente após a inicialização;

somente executado uma única vez;

contém todo código referente a inicialização.

wddoexit( ):

último método a ser chamado no ciclo de vida do controlador;

somente executado uma única vez;

contempla códigos de limpeza.
Métodos do controlador
Hook Methods – Componente

wddobeforenavigation( ): Sempre que um evento é disparado pelo cliente, o método que

o trata é acionado. O wddobeforenavigation( ) é chamado após a execução do método da
ação e antes do processamento do evento na fila de navegação.

wddobeforenavigation( )
Métodos do controlador
Hook Methods – Componente

wddopostprocessing( ): é o último método a ser processado antes da UI ser enviada ao

cliente.

wddopostprocessing( )
Métodos do controlador

Hook Methods – Componente

wddoapplicationstatechange( ):
este método é chamado cada vez que o componente é suspenso ou retomado;
um componente é suspenso quando um plug de suspensão (suspend plugI) é
disparado;
isto pode ser utilizado para iniciarmos uma nova aplicação sem sair da aplicação
atual;
a aplicação suspensa é retomada automaticamente quando a nova aplicação é
encerrada;
neste momento o plug de retomada (resume plug) da janela é acionado.

Obs: Se um plug de suspensão é criado para uma janela, um plug de retomada deve ser
criado ( o WD não dá erro de ativação... )
Métodos do controlador
Hook Methods – Visões
wddobeforeaction( ):
Processado logo após o usuário ter disparado um evento (antes do handler).
Todas as visões de uma view assembly terão este método acionado.
Geralmente contém códigos de validação de entrada de dados.

wddobeforeaction( )
Métodos do controlador
wddoafteraction( ):

Processado após o action handler;

Todas as visões de uma view assembly terão este método acionado;

Podem ser usados para modularizar o código que trata a ação.

wddoafteraction( )
Métodos do controlador

wddomodifyview( ):

único método que permite o acesso à hierarquia dos elementos de UI.

possui dois parâmetros:

 VIEW: referência para a hierarquia de UI;
 FIRST_TIME: indica se o método já foi acionado durante o ciclo de vida.

é chamado pela primeira vez após o wddoinit( )

cada vez que a visão é revisitada, o método é chamado.

Métodos do controlador

Wddomodifyview()
 Métodos do controlador
wddooncontextmenu( ):

Processado sempre que o usuário clica com o botão direito em um elemento de UI.

Podemos instanciar menus estáticos, definidos no CONTEXT_MENU, ou criar
dinamicamente um menu.

Permite a customização do menu padrão.
Métodos do controlador
Hook Methods – Janelas

wddoonopen( ) : Processado se a janela for um popup, sendo executado

antes do poppup abrir.

wddoonclose( ) Processado se a janela for um popup, sendo executado

antes do poppup fechar.
Métodos do controlador
Métodos adicionais nos controladores.

Para todos os controladores podemos definir métodos adicionais.

Estes serão declarados através da aba métodos do controlador, escolhendo a opção

Method Type = Method.

Ao escolhermos Method Type = Event Handler, um método manipulador de eventos é

criado.

Associamos este método (event handler) a um evento qualquer disparado por um

controlador que esteja definido na aba propriedades.

Method Type = Supply: métodos que serão utilizados como supply functions para os nós
do contexto.
Métodos do controlador

Vale lembrar que não podemos chamar diretamente uma supply function,
somente o mecanismo de runtime do WD.

Todos os métodos criados são públicos dentro do componente.

Para tornar um método público a outro componente, temos que marcar o flag
interface do mesmo.

O código ABAP necessário para acessar um método em um conrolador pode

ser gerado através do wizard.
Atributos do controlador

Cada controlador é uma classe ABAP separada, conforme vimos, contendo métodos e
atributos pré-definidos.

Os atributos são visíveis a todos os métodos do controlador.

Existem dois atributos pré-definidos:

 WD_THIS: referência para o controlador em questão. -> verificar o uso do ME
 WD_CONTEXT: referência para o nó raiz do contexto.

Se o controlador do componente estiver declarado como utilizado, o atributo

WD_COMP_CONTROLLER é criado, sendo uma referência para o mesmo.

Podemos acessar os métodos do controlador através do comando

wd_comp_controller-><meth>
Atributos do controlador

Mesmo que outros controladores estejam declarados, não existirá uma referência
para os mesmos nos atributos.

Para referenciar um controlador definido como utilizado, devemos utilizar o

seguinte código:

DATA: lo_ctrl TYPE REF TO ig_<ctrl> .

lo_ctrl = wd_this->get_<ctrl>_ctr( ).

Podemos observar no código acima que, apesar de não existir um atributo como
referência, existe um método getter para o controlador.
Atributos do controlador

Podemos definir, na aba atributos, atributos adicionais ao controlador.

Estes serão visíveis a todos os métodos do mesmo.

Ao marcar o flag público, tornamos o mesmo acessível aos demais controladores

do componente.

Não podemos colocar um atributo na interface do componente, o que resulta que

estes são privados ao componente que pertencem.
Classes assistentes

Podemos definir uma única classe assistente para um componente.

Esta classe irá conter métodos e atributos que serão acessados por todos os
controladores do componente.

Define métodos que implementam lógicas não ligadas ao layout nem ao controle.

Podemos utilizá-la como um proxy para as classes “modelo” ou até mesmo como a
classe de modelo, para implementações simples.
Classes assistentes

Definida na SE24.

Deve herdar da classe CL_WD_COMPONENT_ASSISTANCE.

Um atributo WD_ASSIST, servindo de referência para a classe assistente, será criado

em cada controlador no momento da associação.

Pode ser utilizada para questões de internacionalização do conteúdo ou para textos

dinâmicos -> Exemplo
Acessando o contexto

Para acessar um elemento do contexto ou um atributo, precisamos
primeiramente de uma referência para o mesmo.

Devemos ter em mente o seguinte:

1. Para cada controlador (<ctrl>) uma interface local é gerada com o nome IF_<ctrl>.
2. Para cada nó (<node>) do contexto uma constante WDCTX_<node> é criada, contendo o
nome do nó em caixa alta.

O nó raiz pode ser acessado através do atributo WD_CONTEXT.

Os filhos do nó raiz podem ser acessados através do método get_child_node().

Acessando o contexto
Acessando o contexto
Acessando um elemento do nó

Após acessar o nó do contexto, o elemento referenciado pelo índice da seleção

conduzida (lead selection) pode ser obtido através do método get_element().

Este método retorna uma instância do tipo IF_WD_CONTEXT_ELEMENT.

O elemento de índice n pode ser obtido através do parâmetro index do método:

get_element( index= n )

O número de elementos em uma coleção pode ser obtido através do método

get_element_count( ).
Acessando o contexto
Acessando o contexto
Leitura e alteração de valores dos atributos

Acessando atributos de um elemento de nó.

Uma vez obtida a referência ao elemento do nó, existem duas maneiras para se obter
os valores dos atributos do mesmo:

1.Através do método get_attribute( ), tendo como parâmetro de esportação o nome do

atributo.
2.get_static_attributes( ): retorna todos os atributos definidos estaticamente como uma
estrutura no parâmetro de import.
Acessando o contexto
Através do método get_attribute(), selecionamos os
valores de um atributo específico de um elemento.
Acessando o contexto
Através do método get_static_attributes(),
selecionamos todos os atributos de um elemento.
Acessando o contexto
Através do método get_static_attributes_table( ), os
atributos de todos os elementos podem ser
recuperados para uma tabela interna.
Acessando o contexto

Para acessar um conjunto de dados relativos a uma seleção múltipla de linhas de
uma tabela, o método get_selected_elements() deve ser utilizado.

Este método retorna todos os elementos selecionados em uma tabela interna do

tipo WDR_CONTEXT_ELEMENT_SET.

Cada linha desta tabela interna contem uma referência para um elemento.
Acessando o contexto
Modificando os valores de um atributo

Uma vez obtida a referência para o atributos, podemos recuperar seu valor através
dos métodos getters discutidos anteriormente.

Além disto podemos alterar o valor dos mesmo, utilizando alguns métodos setters.

O método set_attribute() pode ser utilizado para alterar o valor de qualquer atributo
de um elemento.

Podemos alterar o valor de vários atributos, desde que definidos estaticamente,

através do método set_static_attributes( ).
Acessando o contexto
Acessando o contexto
Acessando o contexto
Criação dinâmica de elementos do contexto

Até agora manipulamos dados previamente existentes no contexto do

controlador.

A adição de um elemento a um nó segue dois passos:

1. Criação do elemento e definição dos valores de seus atributos.
2. Adição do novo elemento ao nó no contexto.

Este processo é semelhante ao da adição de uma work area a uma tabela interna...

1. Criação do elemento e definição dos valores de seus atributos.

Antes de criarmos um elemento, temos que obter a referência do nó ao qual o

mesmo vai pertencer.

Fazemos isto através do método get_child_node( ) do atributo WD_CONTEXT.

Acessando o contexto

Elemento já existente
Acessando o contexto

Uma vez obtida a referência, o método create_element( ) é usado para criar o novo
elemento.

Podemos utilizar os métodos set_attribute( ) or set_static_attributes( ) para definir

os valores dos atributos.

O elemento ainda não faz parte do nó…

Acessando o contexto
Acessando o contexto
Acessando o contexto
2. Adição do novo elemento ao nó no contexto.

Utilizamos então o método bind_element( ) para adicionar este novo elemento ao

nó.

Este método possui dois parâmetros importantes:

A referência ao elemento é enviada através do parâmetro new_item.

O parâmetro set_initial_elements:

• abap_false: o novo elemento é adicionado à coleção;

• abap_true: substitui todos os elementos da coleção pelo novo elemento.
Acessando o contexto
Acessando o contexto
Adicionando diretamente uma estrutura/tabela

Podemos adicionar uma estrutura ou até mesmo uma tabela a um nó de

uma maneira mais prática.

Ao invés de criar o elemento e valorar seus atributos, utilizamos uma

estrutura/tabela.

Os métodos bind_structure( ) ou bind_table( ) são então utilizado ao

nvés do bind_element( ).

Removendo elementos

O método remove_element( ) permite a exclusão de um elemento, tendo

como parâmetro de importação uma referência para o elemento a ser
excluído.
Acessando o contexto
Adicionando uma estrutura
Acessando o contexto
Adicionando uma tabela