Web dynpro ABAP: Manejo del contexto

Cualquier controlador tiene por lo menos dos atributos estándar generados automáticamente:

WD_THIS: Es una referencia a la interface del propio controlador. Debe utilizarse en

lugar de ME. También te da acceso a funcionalidad estándar como validación.

WD_CONTEXT: Es una referencia al nodo raíz del contexto del controlador. Cualquier

acceso a los datos del contexto empezará con esta referencia.

Si el Component Controller es declarado como Controlador utilizado en la pestaña de

Propiedades se crea un atributo adicional:

WD_COMP_CONTROLLER: Es una referencia al Component Controller del webdynpro.

Utilizando esta referencia podemos acceder a los métodos y atributos públicos del

mismo.

Cualquier otro controlador declarado en la pestaña de Propiedades no tendrá una referencia

creada automáticamente. Si queremos acceder a la parte pública de este controlador

utilizaremos la siguiente sentencia:

DATA: lo_ctrl TYPE REF TO ig_<ctrl>.

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

Además el programador puede declarar atributos y métodos adicionales, a los que

accederemos mediante WD_THIS. El flag de Public permite que el atributo sea visible para

otros controladores.

Acceso a los nodos y elementos de contexto

Acceder a un atributo o a un elemento de contexto requiere que tengas una referencia al

nodo correspondiente. Podemos obtener una referencia de cualquier nodo de contexto

mediante la siguiente sentencia:

DATA: lo_nd_<contexto> TYPE REF TO if_wd_context_node.

lo_nd_<contexto> = wd_context->get_child_node( name =

‘<NODO_CONTEXTO>’ ).

El nombre del nodo tiene que estar en mayúsculas. Por cada nodo se genera una constante

llamada wdctx_<nombre_nodo> que contiene el nombre del nodo es aconsejable utilizar esta

constante en lugar de poner el nombre del nodo directamente: lo_nd_<contexto> =

wd_this->wdctx_<nombre_nodo> o lo_nd_<contexto> =

if_<nodo_contexto>=>wdctx_<nombre_nodo>.

Get_child_node() devuelve una referencia de tipo IF_WD_CONTEXT_NODE, para su utilización

requiere el nombre del nodo y opcionalmente el índice del elemento del nodo padre al que

pertenece el elemento deseado.

Después de obtener la referencia al nodo podemos acceder al elemento al que apunta el Lead

Selection llamando al método get_element(). Este método devuelve una referencia de tipo

IF_WD_CONTEXT_ELEMENT. El elemento n del nodo puede ser accedido si en la llamada del

método ponemos index = n. El número de elementos en una colección puede obtenerse

mediante get_element_count( ).

DATA lo_nd_<nodo> TYPE REF TO if_wd_context_node.

DATA lo_el_<nodo> TYPE REF TO if_wd_context_element.

lo_nd_<nodo> = wd_context->get_child_node( name = wd_this-

>wdctx_<nodo_contexto> ).

*Obtenemos el elemento al que apunta el LEAD SELECTION

Lo_el_<nodo> = lo_nd_<nodo>->get_element( ).

*Si LEAD SELECTION no está asignado devuelve INITIAL

IF( lo_el_<nodo> is INITIAL).

…

ENDIF.

Sumario: Acceso a nodos de contexto y a elementos de contexto

Acción Método

Referencia al nodo <nodo> del controlador <ctrl>

lo_nd_<nodo> = wd_context->get_child_node( name = wd_this-> wdctx_<nodo> ).

Referencia al elemento en el Lead Selection

lo_el_<nodo> = lo_nd_<nodo>->get_element( ).

Referencia al elemento con índice n

lo_el_<nodo> = lo_nd_<nodo>->get_element( index = n ).

Obtener el número de elementos en la colección

n = lo_nd_<nodo>->get_element_cout( ).

Leer y modificar atributos

Acceder a atributos de un elemento de contexto:

Una vez que has obtenido la referencia al elemento de contexto hay dos formas de acceder al

valor de uno de sus atributos:

1. Acceso mediante el método get_attribute( ). En el EXPORT va el nombre del atributo y

en el IMPORT el valor que contiene.

2. Si el atributo es estático se puede acceder mediante get_static_attributes( ). Con este

método obtenemos una estructura en el parámetro IMPORT.

En este ámbito es importante conocer que:

Para cada <nodo> del contexto de un controlador se genera implícitamente una

estructura element_<nodo> en la interfaz IF_<ctrl> que corresponde a los atributos

que tiene el nodo. Este tipo puede usarse para generar una variable que contenga el

resultado de los métodos anteriores.

Además, por cada <nodo> existe un tipo de tabla estándar llamado elements_<nodo>

generada en la interfaz IF_<nodo>. Cada línea de ese tipo es un element_<nodo>. Este

tipo puede usarse para generar tablas que contengan datos de más de un elemento de

contexto.

Acceder a los atributos de todos los elementos de un nodo

Utilizaremos el método get_static_attributes_table( ) y obtenemos todos los atributos de los

elementos en una tabla interna.

Modificar valores de atributo de un Elemento

Una vez que obtenemos la referencia a una elemento de un nodo de contexto no solo es

posible leer sus atributos con los métodos get apropiados si no que también podemos

modificarlos utilizando los métodos set apropiados.

El método set_attribute( ) puede utilizarse para modificar cualquier atributo y el método

set_static_attributes( ) para cambiar varios atributos simultáneamente si están definidos

estáticamente.

Ejemplo de cambio de un único atributo:

Ejemplo de cambio de múltiples atributos:

Sumario de lectura y modificación de atributos en el nodo <nodo> del controlador <ctrl>

Acción Método

Lectura del valor del atributo <attr>

DATA: lv_attr TYPE wd_this->element_<nodo>-<attr>. lo_el_<nodo>->get_attribute( EXPORTING name = ‘<attr>’ IMPORTING value = lv_<attr> ).

Leer el valor de múltiples atributos definidos estáticamente

DATA : ls_<nodo> TYPE wd_this->element_<nodo>. lo_el_<nodo>->get_static_attributes( IMPORTING static_attributes = ls_<nodo> ).

Leer el valor de todos los atributos estáticos de todos los elementos del nodo

DATA : lt_<nodo> TYPE wd_this->elements_<nodo>. lo_nd_<nodo>->get_static_attributes_table( IMPORTING table = lt_<nodo> ).

Cambiar el valor de un atributo <attr>

DATA : lv_<attr> TYPE wd_this->element_<nodo>-<attr>. lv_<attr> = ….. lo_el_<nodo>->set_attribute( EXPORTING Name = ‘<attr>’ Value = ‘lv_<attr>’ ).

Cambio de múltiples atributos de un elemento

DATA: ls_<nodo> TYPE wd_this->element_<nodo>. ls_<nodo>-<attr1> = …. …… lo_el_<nodo>->set_static_attributes( EXPORTING static_attributes = ls_<nodo> ).

Añadir nuevos elementos a un nodo de contexto

Para añadir un nuevo elemento hay que hacer dos pasos. El primer paso es crear un elemento

que pueda ser añadido al nodo que nos interesa más tarde. Después de haber definido todos

los valores de los atributos del elemento procederemos a insertarlo en el nodo.

Crear un nuevo elemento

Para crear un nuevo elemento primero tenemos que determinar una referencia al nodo de

contexto apropiado utilizando WD_CONTEXT->get_child_node( name = wd_this-

>wdctx_<nodo> ).

Una vez que tenemos la referencia al nodo utilizamos el método create_element( ) para

generar un nuevo elemento vacío. Con el parámetro static_attribute_values podemos asignar

una serie de valores a los atributos del elemento a crear. Con el método set_attribute( ) o

set_static_attributes( ) podemos ir dándole valores a los atributos.

Añadir un elemento al nodo de contexto

Un elemento que no es parte del nodo puede añadirse utilizando el método bind_element( ).

Este método tiene dos parámetros importantes:

New_item lleva una referencia al elemento a añadir.

Set_initial_elements puede ser abap_false para que el elemento se añada a la

colección del nodo o abap_true para que elimine todos elementos del nodo y añada el

nuevo.

Vincular una estructura a un nodo de contexto

En los programas ABAP los conjuntos de datos se suministran en estructuras, pero para poder

visualizar una estructura en la Interfaz Gráfica (UI) el contenido de la estructura tiene que estar

copiado en un elemento de contexto. Esto implica crear un nuevo elemento, asignarle valores

y vincularlo al nodo de contexto adecuado.

Una forma más fácil de tratar esto es utilizar el método bind_structure( ) en lugar de

bind_element( ).

Vincular una tabla interna a un nodo de contexto

De la misma forma que ocurre con las estructuras también tenemos un método que nos agiliza

añadir elementos a un nodo de contexto a partir de una tabla interna, el método bind_table( ).

Borrar elementos de un nodo de contexto

Para eliminar un elemento de un nodo de contexto utilizamos el método remove_element( ). A

este método le suministramos la referencia al elemento utilizando el parámetro element.

Sumario: Añadir y eliminar elementos de un nodo de contexto

Acción Método

Crear un elemento nuevo lo_el_<nodo> = lo_nd_<nodo>->create_element( ).

Añadir un elemento a una colección lo_nd_<nodo>->bind_element( new_item = lo_el_<nodo> set_initial_elements = abap_false ).

Añadir la estructura ls_<nodo> a una colección

DATA: ls_<nodo> TYPE wd_this->element_<nodo>. …. lo_nd_<nodo>->bind_structure( new_item = ls_<nodo> set_initial_elements = abap_false ).

Añadir la tabla interna lt_<nodo> a la colección

DATA: lt_<nodo> TYPE wd_this->elements_<nodo>. …. lo_nd_<nodo>->bind_table( new_items = lt_<nodo> set_initial_elements = abap_false ).

Eliminar un elemento de la colección lo_nd_<nodo>->remove_element( element = lo_el_<nodo> ).