Forms 6i Avanzado

DEVELOPER 2000

FORMS 6i

AVANZADO

Curso de Forms 6i Avanzado Pagina 1 de 28

INDICE 1. Menús ..................................................................................................................... 2

1.1. Creación de menús desde Form ...................................................................... 2 1.1.1. Componentes de los módulos de menú ................................................. 2 1.1.2. El editor de menú ................................................................................... 3 1.1.3. Creación de un menú ............................................................................. 4

1.2. Tipos de elementos en un menú ...................................................................... 5 1.3. Propiedades de los elementos de menú .......................................................... 5 1.4. Asociar código PL/SQL a un elemento de menú .............................................. 6 1.5. Asociar un menú a un form .............................................................................. 6

2. Menús desplegables ............................................................................................... 7 2.1. Menús desplegables asociados al botón derecho del ratón ............................. 7 2.2. ¿Dónde se puede definir un menú desplegable? ............................................. 7

3. Llamada a un módulo formulario desde otro módulo. .............................................. 8 3.1. Llamada a módulos formularios desde otro módulo. ........................................ 8 3.2. Parámetros y paso de parámetros entre forms ................................................ 9 3.3. Start-up Code .................................................................................................. 9

4. Bibliotecas de PL/SQL .......................................................................................... 11 4.1. ¿Qué es una biblioteca de PL/SQL? .............................................................. 11 4.2. Creación de una biblioteca PL/SQL ............................................................... 11 4.3. Bibliotecas de PL/SQL frente a unidades de programa definidas en forms .... 11 4.4. Incorporación de bibliotecas a un formulario .................................................. 12

5. Otros elementos de forms ..................................................................................... 13 5.1. Referencia...................................................................................................... 13 5.2. Clases y subclases ........................................................................................ 13 5.3. Clases de propiedades .................................................................................. 13 5.4. Atributos visuales ........................................................................................... 16

6. Bibliotecas de objetos reutilizables ........................................................................ 17 6.1. ¿Qué es una biblioteca de objetos reutilizables? ........................................... 17 6.2. Creación de una biblioteca y sus pestañas .................................................... 17 6.3. Añadir objetos a una biblioteca de objetos ..................................................... 17 6.4. Objeto de tipo SmartClass ............................................................................. 18 6.5. La biblioteca de objetos como sistema de reutilización de objetos,

estandarización, homogeneización de las aplicaciones y disminución del tamaño de las fuentes. ................................................................................... 18

6.6. Bibliotecas de objetos reutilizables frente a grupos de objetos. ...................... 19 6.7. Cómo se referencian los elementos de una biblioteca. Arrastra y usa. ........... 19

7. Depurador ............................................................................................................. 20 7.1. La Depuración ................................................................................................ 20 7.2. Acciones de Depuración ................................................................................ 20

7.2.1. Creación de acciones de Depuración ................................................... 21 8. Optimizar para funcionar mejor ............................................................................ 25

8.1. Consultar todos los registros cuando sea conveniente .................................. 25 8.2. Array DML (Disminuir los Round-Trips) ......................................................... 25 8.3. Tipos de fuentes de datos ............................................................................. 25

8.3.1. Tabla .................................................................................................... 25 8.3.2. Cláusula FROM de una consulta .......................................................... 25 8.3.3. Procedimientos almacenados .............................................................. 25 8.3.4. Disparador transaccional...................................................................... 26

9. Forms Server ........................................................................................................ 27 9.1. Arquitectura Cliente/Servidor ......................................................................... 27 9.2. Arquitectura basada en Web .......................................................................... 28


1. Menús

1.1. Creación de menús desde Form

1.1.1. Componentes de los módulos de menú

Un módulo de menú es un tipo de módulo de Oracle Forms que incluye los siguientes tipos de objetos: • El propio módulo de menú.

Es un módulo estructurado de forma jerárquica que proporciona un método rápido y sencillo para operar en la aplicación de Oracle Forms. Como el módulo formulario, el módulo de menú es uno de los componentes principales de una aplicación. Cada módulo de menú contiene uno o más menús.

• Menús Es una lista de opciones relacionadas. Cada opción realiza una acción diferente. Se pueden crear tres tipos de menús en Oracle Forms: - Menú principal

Es un menú que aparece de forma horizontal en la barra de menú. Contiene opciones que a su vez son menús individuales.

- Menú individual Un menú presentado verticalmente.

- Submenú Es un menú presentado verticalmente y a la derecha de la opción del menú que lo ha llamado.

Cada menú contiene uno o más items de menús.

• Items de menús (Elementos de menú) Es una opción que se puede elegir de un menú. Cada opción dispone de un comando asociado que permite a un usuario realizar una acción.

Existe un menú especial, denominado el menú por defecto, que está

incorporado en cada módulo de forma. El menú por defecto incluye comandos estándar para la edición, navegación y comunicación con la base de datos, como Action�Save. Al construir un módulo de forma, el menú por defecto se utiliza automáticamente. No obstante, se puede construir un módulo de menú personalizado y remplazar el menú por defecto.


1.1.2. El editor de menú

El editor de menús es una facilidad de diseño gráfico para presentar,

modificar y presentar módulos de menú y sus objetos. El editor de menú se utiliza para diseñar menús.

Hay dos modos de abrir el editor de menús: - Hacer doble clic sobre el icono de la izquierda del campo de entrada

para módulos de menú en el Navegador de Objetos. - Seleccionar Tools�Menu Editor.

El editor de menús posee una barra de herramientas, de las cuales muchas son conocidas, pero existen algunas específicas, como son:

- Display Menu (visualizar menú): Determina de qué menú se quieren

presentar las opciones de menú. Se selecciona entre todos los menús que proporciona el módulo de menús.

- Create Down (crear verticalmente): Crea una nueva opción de menú

debajo del menú activo.

- Create Right (crear horizontalmente): Crea una nueva opción de menú a la derecha del menú activo.


1.1.3. Creación de un menú

Los pasos para crear un menú son los que se detallan a continuación. Primero, se crea el módulo de menú. Para ello, hay varias formas: - Elegir File � New �Menu, ó - En el Navegador, seleccionar el nodo “Menus” y hacer clic sobre el

icono “Create” en la barra de herramientas.

El siguiente paso es crear los menús y los items de menús. Estos se pueden crear usando el Navegador, o en el Editor de menú.

a) Crear un menú principal

Este tipo de menú es visualizado como una barra de menú horizontal. Para crearlo se hace lo siguiente:

1. Se elige Tools � Menu Editor.

El editor de menú se abre mostrando un nuevo menú llamado MENU1, con un nuevo item etiquetado <New Item>.

2. Se escribe una etiqueta de menú para reemplazar la etiqueta por defecto del item anterior.

3. Se elige Menu �Create Right para añadir un nuevo item al menú principal, o se hace clic sobre el icono “Create Right”. Se crea un nuevo item que debe ser etiquetado.

Una vez que el menú principal está completo, se crean los menús

individuales, lo que significa crear los items de menú del menú. Para cada item padre del menú principal, se crea una lista de items de menú hijos relacionados.

b) Crear menús individuales

Estos son presentados verticalmente y se crean como se describe, a continuación:

1. En el menú principal se elige uno de sus items, por ejemplo, uno

llamado Action. 2. Se elige Menu �Create Down y se añade un nuevo item al menú

Action. Se crea un nuevo item de menú al que hay que colocar una etiqueta. Siguiendo estos pasos se crean los items de menú que se deseen. Los items de menú pueden llamar a submenús, que son visualizados a

la derecha del item de menú.

c) Creación de submenús

Para crear un submenú: 1. Se selecciona el menú individual.


2. Se elige Menu �Create Right para añadir el nuevo elemento al submenú. Se crea un item de submenú, <New Item>, al que hay que colocar una etiqueta significativa.

3. Luego, se elige Menu �Create Down para añadir un nuevo item. Esta operación se repite hasta que el submenú quede completado.

1.2. Tipos de elementos en un menú

En un menú, los items de menú pueden ser de varios tipos: • Normal (Plain)

Este es el tipo de elemento de menú por defecto.

• Comprobar (Check) Indica un elemento de menú de tipo Boolean, que es TRUE o FALSE, verificado o no verificado. Cuando el usuario selecciona un item de menú de este tipo cambia el estado de ese item y ejecuta el comando que tiene asociado, si tiene uno.

• Radio

Indica un elemento de menú de tipo Boolean, que es parte de un grupo de radio de menú. Un grupo contiene dos o más elementos de radio relacionados. Cada vez, un solo item de radio puede estar seleccionado en un grupo Para asignar un item de radio a un grupo, se introduce el nombre del grupo en la propiedad Menu Item Radio Group del elemento.

• Separador

Un separador es una línea u otro elemento visual. Son útiles para separar items de menú relacionados en un mismo menú. Un separador no puede ser seleccionado y, por tanto, no puede tener un comando asociado con él.

• Menú (Magic)

Este tipo de elementos de menú proporciona una manera de crear rápidamente items de menú para funciones típicas. Con estos items, se pueden definir los siguientes tipos de funciones: About, Copy, Clear, Cut, Paste, Help, Quit, Undo, and Window.

1.3. Propiedades de los elementos de menú

Algunas propiedades específicas de los items de menú son las siguientes: - Label (Etiqueta): Especifica el texto que aparece en el elemento de menú. - Menu Item Type (Tipo de opción de menú): Determina cómo se presenta

esta opción de menú. Se elige entre “Plain”, “Check”, “Radio”, “Separator” y “Magic”.

- Menu Item Radio Group (Opción de menú de grupo de radio): Determina a

qué grupo de radio pertenece el elemento de menú.

- Magic Item (Item mágico): Especifica cuál de las opciones de menú predefinidas se debe utilizar en los menús personalizados.


- Command Type (Tipo de comando): Determina el tipo de comando asociado a esta opción. Se opta entre “Null”, “PL/SQL” o “Menu”.

- Command Text (Texto de comando): Especifica el comando que invoca el

elemento de menú.

- Keyboard accelerator (Tecla de acceso): Determina qué tecla de función lógica está asociada con el item de menú.

- Icon In Menu (Icono en menú): Especifica si un icono debe ser presentado

en el menú además del elemento de menú. Si se selecciona “Yes”, la propiedad Icon Filename debe especificar el icono que se visualizará.

- Icon Filename (Nombre de icono): Especifica el nombre del icono que se

presenta en la opción de menú.

1.4. Asociar código PL/SQL a un elemento de menú

La mayoría de los ítems de menú ejecutan comandos PL/SQL. Para asignar comandos a un elemento de menú, se hace lo siguiente:

1. Se selecciona el ítem de menú deseado en el editor de menú. 2. En la paleta de propiedades, se comprueba que la propiedad Command

Type del ítem tenga el valor PL/SQL. 3. Se hace doble clic en la propiedad Command Text para visualizar el editor

de PL/SQL. 4. En el editor de PL/SQL, se escribe el código PL/SQL. 5. Se compila el código. 6. Se cierra el editor PL/SQL.

1.5. Asociar un menú a un form

Para asociar un módulo de menú a un formulario se debe generar el módulo de menú, establecer el valor de la propiedad Menu Module del formulario y generar el formulario.

En primer lugar, hay que hacer del módulo de menú el módulo actual y

guardarlo, ya sea en la base de datos o en un fichero. Esto se realiza mediante las opciones File �Save o File �Save As. Los módulos de menú se almacenan en un fichero de extensión (.MMB).

Una vez salvado el módulo, mediante la opción File�Administration�Compile

File, se genera el módulo de menú. Así, se crea un fichero ejecutable de extensión (.MMX), que se almacena en el sistema de ficheros.

A continuación, se selecciona el módulo formulario en el Navegador de Objetos

y, en su paleta de propiedades, se crea la propiedad del formulario Menu Module al nombre del fichero ejecutable que se generó anteriormente. Se comprueba, también, que la propiedad Use File sea TRUE.

Por último, con la opción File�Administration�Compile, se genera el fichero

ejecutable del módulo formulario. Este paso no hay que realizarlo explícitamente, pues este fichero ejecutable se genera automáticamente al ejecutar el formulario.


2. Menús desplegables

2.1. Menús desplegables asociados al botón derecho del ratón

Los menús desplegables son menús sensitivos al contexto qu permiten a los usuarios acceder rápidamente a funciones y comandos comunes. Son objetos de alto nivel en el Navegador de Objetos, similares a los bloques, alertas, canvases, etc., y que pertenecen al módulo formulario.

2.2. ¿Dónde se puede definir un menú desplegable?

Los menús desplegables se definen para ser atados a los items del formulario y

a los canvases. La relación entre menús deplegables y los items y canvases, es similar a la

relación entre los formularios y los menús de formularios: - Se puede atar un menú desplegable a uno o más canvas e items. - Cada canvas e item puede soportar un único menú desplegable.

El menú desplegable se visualiza cuando se coloca en foco de entrada sobre el

item o el canvas y se invoca según el estándar de su plataforma de ejecución. En Microsoft Windows, por ejemplo, se invoca haciendo clic con el botón derecho del ratón. La esquina superior izquierda del menú aparece en el punto del foco de entrada para que los usuarios puedan localizar y seleccionar los items del menú fácil y rápidamente.

Para crear un menú desplegable se hace lo siguiente:

1. En el Navegador de Objetos, se hace clic sobre el nodo “Popup Menus”, y clic

en el botón “Create” en la barra de herramientas. Así, se genera un menú desplegable y se le da el nombre por defecto MENU1.

2. En el Navegador de Objetos o en el Editor de Menús, se crea un menú desplegable principal, los submenús, si los hay, y los elementos del menú.

3. Se asignan los comandos a los elementos de menú. 4. Por último, se ata el menú desplegable a los items o los canvases adecuados.

Para ello: 1. En el Navegador de Objetos, bajo el nodo “Data Blocks” o “Canvases”, se

hace clic sobre el icono del objeto del item o del canvas correspondiente (o de ambos).

2. Se elige Tools� Property Palette. 3. En la paleta de propiedades, se selecciona una opción de la lista de menú

de la propiedad Popup Menu.

Nota: Para atar simultáneamente el mismo menú desplegable a varios items y canvases, se seleccionan todos a la vez, antes de visualizar la paleta de propiedades.


3. Llamada a un módulo formulario desde otro módulo .

3.1. Llamada a módulos formularios desde otro módulo.

Se puede llamar a un módulo formulario desde un módulo distinto, mediante los subprogramas incorporados CALL_FORM y OPEN_FORM.

a) El procedimiento CALL_FORM

Este procedimiento ejecuta el formulario indicado mientras desactiva el formulario que lo llama. Cuando se finaliza en el formulario llamado, el proceso se reanuda en el formulario que lo llamó, en el punto donde se inició la llamada a CALL_FORM.

La sintaxis del procedimiento es:

CALL_FORM (‘form_name’, display, switch_menu, query_mode, paramlist) Los argumentos específicos de CALL_FORM son:

� form_name: Se trata del fichero que contiene el módulo ejecutable

(sin el .FMX). Se utiliza el nombre de la ruta que Oracle Forms proporciona por defecto para su sistema, al menos que se proporcione otro como parte de esta cadena de caracteres.

� display: Toma los valores HIDE (por defecto) o NO_HIDE.

Determina si se debe ocultar el formulario que efectúa la llamada, mientras que el formulario llamado se está ejecutando.

� switch_menu: Toma los valores NO_REPLACE (por defecto) o

DO_REPLACE. Determina si el módulo de menú actual debe ser reemplazado con el menú por defecto del formulario llamado.

� query_mode: Toma los valores NO_QUERY_ONLY (por defecto) o

QUERY_ONLY. Determina si el módulo formulario llamado sólo se debe ejecutar en modo "Query Only".

� paramlist: Se trata del nombre, entre comillas, de una lista de

parámetros. Este argumento es opcional y permite pasar los contenidos de una lista de parámetros específica al formulario que se está abriendo.

b) El procedimiento OPEN_FORM

Se puede utilizar OPEN_FORM para vincular los módulos formularios de una aplicación y así permitir que un usuario trabaje en varios formularios simultáneamente. Este procedimiento no se puede llamar en modo “Enter Query”. Su sintaxis es:

OPEN_FORM (‘form_name’, activate_mode, session_mode,

paramlist)


Sus argumentos son:

� form_name: Se trata del fichero que contiene el módulo ejecutable

(sin el .FMX). Se utiliza el nombre de la ruta que Oracle Forms proporciona por defecto para su sistema, al menos que se proporcione otro como parte de esta cadena de caracteres.

� activate_mode: ACTIVATE (por defecto), o NO_ACTIVATE

� session_mode: SESSION (por defecto), o NO_SESSION.

� paramlist: Se trata del nombre, entre comillas, de una lista de

parámetros. Este argumento es opcional y permite pasar los contenidos de una lista de parámetros específica al formulario que se está abriendo.

3.2. Parámetros y paso de parámetros entre forms

Los parámetros proporcionan un mecanismo simple para definir y crear los

valores de entrada que son requeridos por un formulario cuando comienza a ejecutarse. Los parámetros son variables de tipo CHAR, NUMBER, o DATE que se definen en tiempo de diseño.

Cuando se crea un parámetro, se especifica su nombre, tipo de dato,

longitud y valor por defecto. Se crea del siguiente modo: 1. Se selecciona el nodo “Parameters” en el Navegador y después se elige

Navigator �Create. 2. En la paleta de propiedades, se detallan las siguientes propiedades:

- Name (Nombre): Es el nombre interno del parámetro. - Parameter Data Type (Tipo de Dato): Indica el tipo de datos del

parámetro. Puede ser CHAR, NUMBER, o DATE.

- Parameter Initial Value (Valor inicial del parámetro): Indica el valor por defecto del parámetro. Debe ser compatible con el tipo del parámetro especificado en la propiedad Parameter Data Type y su longitud.

- Length (Longitud): Indica el número máximo de caracteres que el

parámetro puede almacenar, en caso de que el parámetro sea de tipo CHAR.

Los parámetros se pueden pasar entre módulos utilizando procedimientos

incorporados como CALL_FORM y OPEN_FORM.

3.3. Start-up Code

El código Start-Up de un menú se ejecuta cuando un menú está siendo grabado en la memoria, al comenzar la ejecución del formulario o como resultado


de llamar a procedimientos incorporados como CALL_FORM. El código es opcional y puede ser usado para realizar las siguientes tareas:

- Inicializar parámetros de sustitución y variables globales. - Programáticamente, crear el estado de presentación de los ítems de menú.

Por ejemplo, habilitar o deshabilitar un ítem de menú o seleccionar un elemento de menú de tipo Radio o Comprobar.

Para escribir el código Start-Up para un menú: 1. En el editor de Menú o en el Navegador, se selecciona el módulo de menú

correspondiente. 2. En la paleta de propiedades, seleccionar la propiedad Startup Code para

invocar el editor PL/SQL. 3. Introducir y compilar el código PL/SQL que se pretende ejecutar.

Escribir el código Start-Up es similar a escribir un trigger, y puede incluir

bloques anónimos y llamadas a subprogramas incorporados.


4. Bibliotecas de PL/SQL

4.1. ¿Qué es una biblioteca de PL/SQL?

Una biblioteca de PL/SQL es una colección de subprogramas, que incluye procedimientos, funciones y paquetes definidos por el usuario. Proporcionan un buen modo de almacenar unidades de programa y de compartirlas entre múltiples aplicaciones.

Una vez que se crea la biblioteca, se puede asociar a cualquier módulo, ya sea formulario, menú u otra biblioteca. Después, se pueden llamar sus unidades de programa desde triggers o comandos de elementos de menú. La misma biblioteca puede ser asociada a múltiples formularios y módulos. Igualmente, un único formulario o menú puede tener asociada más de una biblioteca.

También, las bibliotecas pueden ser atadas a otras bibliotecas. Cuando esto ocurre, las unidades de programa en la primera biblioteca pueden hacer referencia a las unidades de programa de la biblioteca asociada. 4.2. Creación de una biblioteca PL/SQL

Estos son los pasos que hay que seguir para crear una biblioteca PL/SQL:

1. Para crear el módulo, se elige File�New� PL/SQL Library, o, en el Navegador, se selecciona el nodo “PL/SQL Libraries” y, a continuación, se elige Navigator�Create.

2. Para crear una unidad de programa, se expande el nodo de la biblioteca deseada, se selecciona el nodo “Program Units”, y después se elige Navigator�Create. Así, aparecerá la ventana de diálogo “New Program Unit”.

3. Se especifica el nombre de la unidad de programa y su tipo (Procedure, Function, Package Spec, or Package Body). Luego, se elige OK y aparece el editor PL/SQL.

4. En el editor PL/SQL, se define la unidad de programa y se elige “Compile” para compilar y aplicar las modificaciones. Para terminar, se cierra el editor eligiendo “Close”. Si se selecciona Program�Compile�All para compilar todas las unidades de programa de la biblioteca.

5. Por último, se selecciona File->Save para guardar el módulo biblioteca que se ha creado en un fichero o en la base de datos. El fichero que se genera al guardar un módulo biblioteca tiene la extensión (.PLL). A partir de éste, se genera el fichero ejecutable con extensión (.PLX).

4.3. Bibliotecas de PL/SQL frente a las unidades de programas definidas en forms

Una vez que se crea una biblioteca y se une al módulo deseado, se pueden llamar las unidades de programa de la biblioteca desde ese módulo usando la misma sintaxis que se utilizaría si la unidad de programa estuviera definida localmente.

Cuando Oracle Forms encuentra una llamada a una unidad de programa, primero la busca en el módulo actual, y después en las bibliotecas asociadas. Cuando un módulo se une con más de una biblioteca, se puede especificar el


orden de búsqueda por defecto mediante el orden de colocación de las bibliotecas en el Navegador de Objetos. 4.4. Incorporación de bibliotecas a un formulario

Después de almacenar un módulo biblioteca en un fichero del sistema o en la base de datos, se puede atar a cualquier módulo, ya sea de tipo formulario, menú o biblioteca. Para asociar una biblioteca a un módulo, se hace lo siguiente:

1. En el Navegador, se abre el módulo deseado, formulario, menú o biblioteca. 2. Se expande el nodo del módulo, se selecciona el nodo “Attached Libraries”

y, seguidamente, se elige la opción Navigator�Create. Entonces, aparece el diálogo “Attach Libraries”

3. En él, se especifica el nombre de la biblioteca que se va a asociar. 4. Se pregunta si se debe guardar el path de la biblioteca. Es mejor decir que

no, ya que si se cambia de directorio la biblioteca, el form dejará de funcionar.

5. Para incorporar la asociación de la biblioteca al módulo en la definición de éste, se almacenan los cambios hechos en el módulo.

Las bibliotecas atadas son de sólo-lectura, no se puede editar una biblioteca atada; únicamente se puede hacer referencia a las unidades de programa dentro de ella. Para editar un módulo biblioteca, éste se debe abrir en el Navegador y usar el editor PL/SQL para modificar las unidades de programa.


5. Otros elementos de forms

5.1. Referencia

Referenciar te permite crear objetos que heredan su funcionalidad y apariencia de otros objetos. Es similar a copiarlo, excepto que el objeto de referencia resultante mantiene un enlace con su objeto fuente. Es una manera rápida de propagar un único cambio de diseño a múltiples objetos. Cuando se cambia la definición de un objeto fuente, cualquier objeto referenciado que hereda de él, es actualizado automáticamente cuando se regenera el módulo en el que reside. Cuando se referencia un objeto, también se referencia cualquier objeto propiedad del primero. Por ejemplo, si se referencia un bloque, el nuevo bloque incluye cualquier ítem que pertenezca al bloque fuente, y cualquier disparador que estuviera atado al bloque fuente o sus ítems. Si se copia un objeto referenciado, el objeto resultante es también un objeto referenciado.

5.2. Clases y subclases

Una subclase es el objeto que se crea cuando se referencia un objeto. Para crear una subclase se hace lo siguiente:

1. Se abren los dos módulos, el que contiene el objeto fuente y el módulo en el que se va a crear la subclase.

2. En el Navegador, se arrastra el objeto, al que se va a hacer referencia, desde el módulo fuente al nodo apropiado en el otro módulo.

3. Aparece una alerta en la que se debe especificar si se desea copiar o crear una subclase. Se elige “Subclass”.

Las subclases se visualizan en el Navegador con un icono especial indicando su estado.

5.3. Clases de propiedades

Una clase de propiedades es un objeto nombrado que contiene una lista de propiedades y sus valores.

Una vez creada la clase de propiedades, se pueden basar otros objetos en ella.

Un objeto basado en ella puede heredar los valores de cualquier propiedad en la clase que tenga sentido para el objeto.


Puede haber cualquier número de propiedades en una clase de propiedades, y las propiedades en la clase pueden aplicarse a diferentes tipos de objetos. Por ejemplo, una clase de propiedades puede contener algunas propiedades que son comunes a todos los tipos de elementos, otras que sólo se aplican a los elementos de texto y otras aplicadas únicamente a las casillas de selección (Check Box).

Las clases de propiedades se utilizan para aumentar la productividad de una

aplicación. Se trata de definir valores estándar o valores utilizados con frecuencia para propiedades típicas, y asociarlas con varios objetos de Oracle Forms. Las clases de propiedades permiten definir propiedades estándar no sólo para un objeto específico, sino para varios objetos a la vez. Esto aumenta la productividad, porque elimina el tiempo que se dedica a definir propiedades idénticas para varios objetos.

Para crear una clase de propiedades se cuenta con todas las propiedades de todos los objetos de Oracle Forms. Es el usuario quien elige las propiedades y los valores de una clase de propiedades. Para crear una clase de propiedades, se puede:

• Utilizar el icono "Create" del Navegador de Objetos, o • Utilizar el icono "Create Property Class" (crear Clase de propiedades) de la

paleta de propiedades. a) Crear una clase de propiedades en el Navegador de Objetos

1. Hacer clic sobre el nodo "Property Class" (Clase de propiedades). 2. Hacer clic sobre el icono "Create". Aparecerá un nuevo campo de

entrada para la clase de propiedades.


3. Añadir las propiedades requeridas y sus valores, utilizando el icono "Add Property" (añadir propiedad).

b) Crear una clase de propiedades en la paleta de propiedades

1. Se hace clic sobre el objeto cuyas propiedades se quieren copiar a una

clase de propiedades en el Navegador de Objetos. 2. Se abre la paleta de propiedades y se hace clic sobre el icono "Create

Property Class". Aparecerá una alerta de información. 3. Se utiliza el Navegador de Objetos para localizar la clase de

propiedades, y cambiar su nombre.

Una vez que se ha creado una clase de propiedades, se puede añadir una nueva propiedad haciendo clic sobre el icono "Add Property" y eligiendo una propiedad de la lista. A continuación, se define un valor para la propiedad utilizando la paleta de propiedades.

Las propiedades de una clase de propiedades se pueden borrar con el icono

"Delete Property " (borrar propiedad). Después que se ha creado una clase de propiedades y se le han añadido sus

propiedades, se puede utilizar haciendo que un objeto la ‘herede’, tomando las propiedades de la clase de propiedades.

Para heredar los valores de las propiedades de una clase de propiedad, los

pasos son:

1. Hacer clic sobre el objeto que va a tomar las propiedades de la clase de propiedades.

2. Hacer doble clic sobre la propiedad Subclass Information en la paleta de propiedades.

3. En el diálogo que aparece, elegir a opción “Property Class”. 4. En el campo Property Class Name, elegir la clase de propiedad deseada. El

objeto tomará los valores de aquellas propiedades que existan en la clase de propiedades y tengan sentido para él.

Una propiedad heredada es una propiedad que toma su valor de una clase de propiedades que está asociada a un objeto. Una propiedad heredada aparecerá con un símbolo de flecha delante de ellas.


Una propiedad variante es una propiedad que no toma su valor de una clase de

propiedades asociada a un objeto. Las propiedades variantes se presentan con una cruz roja, además de la flecha.

Una propiedad variante se puede convertir en una propiedad heredada,

haciendo clic sobre el icono "Inherit Property" (heredar propiedad) en la paleta de propiedades. Una propiedad heredada se puede convertir en una propiedad variante, sencillamente, definiendo un nuevo valor para la propiedad y anulando el valor.

5.4. Atributos visuales

Los atributos visuales son propiedades de fuente, color y patrón que se crean para los objetos de los formularios y los menús que aparecen en la interfaz de una aplicación. Incluye los siguientes tipos de propiedades: - Propiedades de Fuente: Font Name (Nombre de letra), Font Size (Tamaño de

letra), Font Style (Estilo de letra), Font Width (Anchura de letra) y Font Weight (Peso de letra).

- Propiedades de Color y Patrón: Foreground Color (Color de primer plano),

Background Color (Color de Fondo), Fill Pattern (Patrón de relleno), White on Black (Blanco sobre negro).

Cada objeto de la interfaz tiene la propiedad Visual Attribute Group que determina cómo se derivan los valores de los atributos visuales individuales de los objetos. Esta propiedad puede ser establecida en:

� Default: Especifica que el objeto debe ser presentado con los valores de color, fuente y patrón por defecto del sistema actual.

� El nombre de un atributo visual nombrado, definido en el mismo módulo.

Indica que el objeto debe usar los valores de atributos definidos para el atributo visual nombrado.

Un atributo visual nombrado es un objeto independiente que define un conjunto

de valores de atributos visuales. Se pueden crear atributos visuales nombrados en módulos formulario y de menú, y después aplicarlos a los objetos en esos módulos. Cuando se aplica un atributo visual a un objeto, sólo aquellos atributos que tienen sentido para ese objeto tienen efecto.


6. Bibliotecas de objetos reutilizables

6.1. ¿Qué es una biblioteca de objetos reutilizables?

Una biblioteca de objetos reutilizables es una colección de objetos que pueden usarse para desarrollar aplicaciones. Su uso es la manera más importante de estandarización disponible.

6.2. Creación de una biblioteca y sus pestañas

Para crear una nueva biblioteca de objetos se elige la opción File � New � Object Library.

Una biblioteca de objetos está dividida en pestañas. Para crear una de estás

pestañas, en el Navegador de Objetos, se hace clic en nodo “Library Tabs” para la biblioteca de objetos deseada, se selecciona el botón “Create” en la barra de herramientas y, por último, se especifica el nombre de la nueva pestaña.

Para visualizar una biblioteca de objetos se elige la opción Tools � Object

Library.

Un módulo del tipo Biblioteca de Objetos se almacena en un fichero con extensión (.OLB). 6.3. Añadir objetos a una biblioteca de objetos

Sobre las pestañas de la biblioteca de objetos se crean los objetos reusables de la biblioteca. Para crear un objeto reutilizable en una biblioteca de objetos, una vez seleccionada la biblioteca deseada, en el Navegador de Objetos, se elige el elemento deseado y se arrastra sobre la pestaña de la biblioteca en la que se va a colocar.


6.4. Objeto de tipo SmartClass

Un SmartClass es un objeto especial que se crea en una biblioteca de objetos. Cuando se define un objeto como un SmartClass, se pueden crear objetos basados en éste arrastrándolo al Navegador de Objetos, o se puede aplicar el SmartClass a un objeto existente eligiendo SmartClasses en el menú desplegable del elemento. Cuando se utiliza el segundo método el nuevo objeto creado es una subclase, que hereda la funcionalidad y la apariencia del SmartClass. Para crear un SmartClass, se elige la opción Tools�Object Library para visualizar la biblioteca de objetos. En ella, se elige el objeto deseado y se selecciona la opción de menú Object � SmartClass. 6.5. La biblioteca de objetos como sistema de reutilización de objetos,

estandarización, homogeneización de las aplicaciones y disminución del tamaño de los fuentes.

En cualquier entorno de desarrollo, siempre habrá estándares y objetos

comunes que se quiera poder reusarlos. La biblioteca de objetos proporciona un método fácil de reusar los objetos y estándares obligados en la organización del desarrollo completo.

La biblioteca de objetos se puede utilizar para: - Crear, almacenar, mantener y distribuir estándares y objetos reutilizables. - Crear rápidamente aplicaciones arrastrando y soltando objetos predefinidos

al formulario.

Hay varias ventajas en la utilización de bibliotecas de objetos en el desarrollo de aplicaciones:

- Las bibliotecas de objetos son automáticamente abiertas al comenzar Oracle Forms, haciendo inmediatamente a los objetos reusables accesibles.

- Se pueden asociar múltiples bibliotecas de objetos con una aplicación.

- Otra ventaja de las bibliotecas son las SmartClasses, que se usan para

convertir un objeto en objeto subclase de otro. Antes de crear los estándares, se deben considerar las siguientes cuestiones:

- Antes de crear estándares propios, considera el uso de los estándares de la interfaz de usuario de Forms Developer.

- Usa la Biblioteca de Objetos como principal mecanismo para crear y reusar los objetos estándares.

- Tener cuidado al borrar los objetos fuentes; al borrar el objeto fuente se

rompe el enlace con los objetos basados en él.

Cuando se van a crear estándares, se siguen los siguientes pasos: 1. Se definen los estándares.


2. Se crean los objetos que conformarán los estándares. 3. Se almacenan los objetos estándares en la biblioteca de objetos. 4. Se distribuyen los estándares, a través de un módulo de tipo biblioteca de

objetos, cuyo fichero tiene extensión (.OLB).

6.6. Bibliotecas de objetos reutilizables frente a grupos de objetos.

Un grupo de objetos es un contenedor de objetos. Se definen cuando se desea empaquetar un conjunto de objetos relacionados para que se pueda hacer una copia o una subclase de ellos en otro módulo. Los grupos de objetos proporcionan una forma de atar objetos dentro de bloques de construcción de alto nivel, que pueden ser usados en otras partes de la aplicación y en proyectos de desarrollo posteriores.

Se crean grupos de objetos en módulos formularios y de menú. Una vez que se crea un grupo de objetos, se le pueden añadir y borrar objetos como se desee. 6.7. Cómo se referencian los elementos de una biblioteca. Arrastrar y usar.

Para utilizar un objeto de una biblioteca de objetos, se siguen los pasos siguientes:

1. En la biblioteca de objetos, se hace clic en el objeto deseado. 2. Se presiona Ctrl y se arrastra el objeto al módulo y al nodo deseado. Se

visualiza una ventana de diálogo en la que se pregunta si se desea copiar el objeto o crear una subclase basado en él.

3. Se hace clic en “Subclass”.


7. Depurador

7.1. La Depuración

La depuración de una aplicación es un proceso iterativo en el que se identifican y corrigen los errores de una aplicación, durante su ejecución.

Identificar y localizar rápidamente el código que falla, es esencial para depurar con éxito una aplicación. Si no se puede localizar el código erróneo, se ejecuta la aplicación con mensajes de depuración. Al hacerlo, una alerta aparece cuando ocurre un evento que provoca que un trigger se ejecute.

Cuando se ejecuta un formulario en modo depuración, el Depurador aparece

inicialmente, permitiendo crear acciones de depuración. Después que se cierra, se activará cuando se interrumpa la ejecución o cuando se seleccione Help->Debug del menú.

Una sesión típica del depurador se centra en el Navegador. Usándolo, se

pueden inspeccionar y modificar las unidades de programa, los valores de los campos de formularios, etc.

7.2. Acciones de Depuración

Se puede depurar el código de un formulario creando acciones de depuración que permiten monitorizar e interrumpir la ejecución de unidades de programa PL/SQL. Hay dos tipos de acciones de depuración: breakpoints y triggers de depuración.

El tipo de acción de depuración más común es el breakpoint. Los breakpoints suspenden la ejecución antes de alcanzar una línea de código específica de una unidad de programa, pasando el control al Depurador. En este punto, en el Depurador, se inspecciona y modifica el estado del programa. Una vez realizado, se reanuda la ejecución con los comandos GO o STEP o se puede abortar la ejecución con un RESET.

Un trigger de depuración asocia un bloque de código PL/SQL con una línea de

código específica dentro de una unidad de programa. Por ejemplo, el trigger de depuración que se muestra abajo establece un beakpoint condicional sobre la línea 10 de un procedimiento, que será alcanzado si la variable local NUMBER ‘my_sal’ excede de 5000:

PL/SQL>line 10 is +> IF Debug.Getn('my_sal') > 5000 THEN +> Raise Debug.Break;


+> END IF;

7.2.1. Creación de acciones de Depuración

Oracle Forms permite crear acciones de depuración de tres maneras:

- Usando las opciones del menú Break y Trigger - Insertando acciones de depuración en el área del Navegador - Introduciendo comandos en el área del Intérprete.

Cuando se crea una acción de depuración, se debe atar un breakpoint o un

trigger a una línea código de una unidad de programa que sea “ejecutable”. Una línea de código es considerada ejecutable si contiene uno o más instrucciones para las cuales el compilador PL/SQL genera código. Por ejemplo, líneas de código que contienen instrucciones de asignación y llamadas a procedimientos son ejecutables, mientras que las líneas de código que contienen comentarios, líneas en blancos, declaraciones o instrucciones NULL no lo son.

a) Crear un breakpoint

Se puede crear un breakpoint para suspender la ejecución en una línea de

código específica de una unidad de programa, un trigger o un comando de ítem de menú. Cuando se encuentra un breakpoint, el control se pasa al Depurador.

Para crear un breakpoint, se hace lo siguiente:


1. En el Navegador, se selecciona la unidad de programa, trigger o

comando de elemento de menú deseado. El Depurador presenta tu selección en el área Source.

2. En él, se selecciona la línea a la que el breakpoint será atado. 3. Se elige Debug->Break para invocar el diálogo Breakpoint. 4. Se selecciona la línea deseada y después se elige OK para crear un

breakpoint en la línea seleccionada.

5. Cuando se cierra la ventana inicial del depurador, se avanza a la ejecución del form, hasta que se llegue (si se llega) al punto donde se haya definido el breakpoint. Se muestran los datos del form en ejecución, pudiéndose ejecutar paso a paso, continuar hasta el siguiente breakpoint, etcétera.


b) Crear un trigger de depuración

Los triggers de depuración permiten asociar código PL/SQL a líneas de código fuente, durante la ejecución en modo depuración. Este código se ejecuta cada vez que se pasa por la línea asociada al trigger.

Los pasos para crear un trigger de depuración son: 1. En el Navegador, se selecciona la unidad de programa, trigger o

comando de ítem de menú deseado. El Depurador presenta tu selección en el área Source.

2. En él, se selecciona la línea a la que el trigger de depuración será atado.

3. Se elige Debug->Trigger para invocar el diálogo “New Trigger”. 4. Se especifica el cuerpo del trigger. Por ejemplo, para crear un trigger de

depuración que interrumpa la ejecución de un programa, si la variable ‘my_sal’ excede de 5000, introducir el siguiente cuerpo de trigger:

IF Debug.Getn('my_sal') > 5000 THEN

raise Debug.Break; END IF;

Nota: Se debe levantar la excepción DEBUG.BREAK desde el paquete DEBUG, si se quiere que el Depurador aparezca cuando la línea es ejecutada. En otro caso, Oracle Forms ejecuta el código, pero el Depurador no aparece.


5. Se elige OK para crear el trigger de depuración para la línea seleccionada.


8. Optimizar para funcionar mejor

8.1. Consultar todos los registros cuando sea conveniente Cuando se ejecuta una consulta, si todos los registros que se emparejan con el criterio de esa consulta deben ser extraídos dentro de los datos de bloque, se establecerá la propiedad Query All Records en el valor “Yes”.

8.2. Array DML (Disminuir los Round-Trips)

El procesamiento de array es una opción que altera la manera en que los registros son procesados. El comportamiento por defecto es procesar los registros uno cada vez. Permitiendo el procesamiento de arrays, se pueden procesar grupos de registros a la vez, reduciendo el tráfico de la red e incrementando el rendimiento. Con el procesamiento de array, una estructura (array), que contiene múltiples registros, es enviada y devuelta al servidor para su procesamiento. El procesamiento de array está disponible para las consultas y las operaciones de DML para bloques basados en tablas, vistas, procedimientos y subconsultas, pero no para bloques basados en triggers transaccionales.

La propiedad DML Array Size especifica el número de registros en el array para

el procesamiento de array para las operaciones DML. (INSERT, UPDATE, DELETE) y la propiedad Query Array Size para el caso de las consultas.

8.3. Tipos de fuentes de datos

Los bloques basados en la base de datos pueden estar basados en las siguientes fuentes de datos: una tabla, una vista, una cláusula FROM de una consulta, un procedimiento, un disparador transaccional.

8.3.1. Tabla

Una tabla es la fuente de datos de bloque más usada comúnmente. Es la mejor elección para un bloque de datos. También reduce el tráfico en la red mediante el procesamiento de array. 8.3.2. Cláusula FROM de una consulta

Una cláusula FROM puede ser usada como fuente de una bloque de datos. Es una característica de Oracle8 Server que permite anidar una instrucción SELECT en la cláusula FROM de una instrucción SELECT.

Es una fuente de datos de bloque de consulta válida, pero no una fuente

de datos de bloque DML válida. El valor devuelto por la cláusula FROM es un subconjunto de registros de la consulta original. Son usadas para ejecutar uniones, búsquedas y cálculos sin tener que crear vistas. Pueden ser usadas como vistas prototipos y para incrementar el rendimiento. 8.3.3. Procedimientos almacenados

Usando un procedimiento almacenado como fuente de datos de un bloque es una opción más avanzada. Se utiliza para: incrementar el control y la


seguridad, consultar y actualizar múltiples tablas, ejecutar cálculos complejos, etc.

Un procedimiento almacenado devuelve datos a un bloque de datos

usando un cursor REF o una tabla de registros

8.3.4. Disparador transaccional

Un disparador transaccional puede ser usado para proporcionar datos a un bloque de datos. Se usan normalmente cuando se trabaja sobre fuente de datos no ORACLE.

Una fuente de datos de este tipo puede usarse tanto para consultas como

para operaciones DML. El procesamiento de arrray no es soportado cuando el bloque de datos está basado en un disparador transaccional.


9. Forms Server

9.1. Arquitectura Cliente / Servidor

En la arquitectura cliente/servidor, el entorno de ejecución (runtime) de Oracle Forms está totalmente contenido en el cliente. Se trata de un programa o grupo de programas que se encargan de la presentación gráfica (la interfaz de usuario), el procesamiento de los triggers y procedimientos no almacenados en base de datos (la lógica de la aplicación), y la conexión con el servidor de base de datos mediante Net8.

Algunos inconvenientes de esta arquitectura son :

• El runtime de Forms requiere bastantes recursos de cada ordenador en que está instalado;

• Es un programa que hay que instalar y configurar individualmente en cada ordenador;

• Es un programa que hay que mantener y actualizar individualmente en cada ordenador;

• Es un programa específico del sistema operativo, lo que limita la elección del sistema operativo del cliente a los soportados por Oracle;

• Hay que dar acceso en cada ordenador a los ejecutables (FMX) de Oracle Forms. Si se copian localmente, se plantean problemas de sincronización de los fuentes, en caso de actualizaciones.


9.2. Arquitectura basada en Web

En la arquitectura de Forms basada en Web, aparece un nuevo sujeto: el

servidor de aplicaciones. El cliente pasa parte de sus funciones al servidor de aplicaciones, quedándose únicamente con el procesamiento de la interfaz de usuario y la conexión con el servidor de aplicaciones. El servidor de aplicaciones se especializa en el procesamiento de la lógica de la aplicación y la conexión con el servidor de base de datos mediante Net8, y proporciona estos servicios a numerosos clientes.

Esta arquitectura resuelve, entre otros, los inconvenientes indicados de la arquitectura cliente / servidor:

• El runtime de Forms en el cliente requiere menos recursos de cada ordenador en que está instalado;

• Está basado en Java y TCP/IP, que son recursos ya instalados en la mayoría de los sistemas operativos, lo que resuelve la mayoría de problemas de instalación, configuración y mantenimiento, además de proporcionar mayor independencia de la plataforma;

• Sólo es necesario dar acceso a los ejecutables (FMX) de Oracle Forms en los servidores de aplicaciones: se evitan los problemas de sincronización de ficheros en múltiples equipos.

Forms 6i Avanzado

Documents

Transcript of Forms 6i Avanzado