Upload
matias-gomez
View
730
Download
6
Embed Size (px)
Citation preview
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> ).