Manual PDF

Comenzando a trabajar con JFormsBuilder3.
Comenzando a trabajar con

JFormsBuilder 3.1
1
Comenzando a trabajar con JFormsBuilder3.1
Tabla de contenido
Introducción ............................................................................................................................. 5
Capitulo 1. ................................................................................................................................ 6
1.1. Conceptos básicos ...................................................................................................... 6
1.2. Familiaricémonos con la herramienta. ........................................................................ 6
1.2.1. Menú Principal. .................................................................................................. 7
1.2.2. El navegador de objetos...................................................................................... 8
1.2.3. El panel central. ................................................................................................ 11
1.2.4. El panel derecho. .............................................................................................. 11
1.3. Creemos una forma .................................................................................................. 12
1.3.1. Prerrequisitos. .................................................................................................. 12
1.3.2. Creación del proyecto ....................................................................................... 16
1.3.3. Creación de la forma ......................................................................................... 17
Creación del proyecto en Eclipse. ......................................................................................... 27
Generación de la forma y Ejecución desde Eclipse. ............................................................. 30
Capitulo 2. .............................................................................................................................. 33
2.1. Examinando una forma. ............................................................................................... 33
2.1.1. Propiedades. .......................................................................................................... 33
2.1.2. Eventos:................................................................................................................. 37
2.1.2.1. Al entrar en una forma. ...................................................................................... 37
2.1.2.2. Durante la ejecución de una forma. ..................................................................... 38
2.1.2.3. Al salir de una forma. .......................................................................................... 39
Capitulo 3. .............................................................................................................................. 41
3.1. Examinando un Data. ................................................................................................... 41
3.1.1. Propiedades:.......................................................................................................... 41
3.1.2. Eventos:................................................................................................................. 50
3.1.2.1. Eventos al navegar: ............................................................................................. 50
3.1.2.2. Eventos al interactuar con las fuentes de datos: ................................................... 53
3.1.2.2.1. Eventos al efectuar una consulta: ..................................................................... 53
3.1.2.2.2. Eventos al llamar al built-in “ Post” o “Commit”: ............................................... 55
2
Capitulo 4. .............................................................................................................................. 59
4.1. Propiedades: ................................................................................................................ 59
4.1.1. Propiedades dependiendo del tipo de componente: ........................................... 70
4.1.2 Propiedades De los RadioButtons: ....................................................................... 72
4.2. Eventos: ....................................................................................................................... 75
4.1.1. Eventos al navegar:................................................................................................ 75
Capitulo 5 ............................................................................................................................... 78
5.1. Tipos de Paneles: ..................................................................................................... 78
5.2. Propiedades comunes a todos los tipos de Paneles: .................................................. 79
5.3. Propiedades específicas para cada tipo de Panel: ..................................................... 81
5.3.1. Panel Principal:................................................................................................. 81
5.3.2. Panel apilado: .................................................................................................. 81
5.3.3. Panel Tipo Pestañas: ......................................................................................... 82
5.3.4. Páginas de pestañas: ........................................................................................ 83
5.3.5. Panel Barra de Herramientas ............................................................................ 84
5.3.6. Panel Tipo Grilla ............................................................................................... 85
Capitulo 6 ............................................................................................................................... 87
6.1. Tipos de Object Graphics ....................................................................................... 87
6.2. Propiedades comunes a los Object Graphics......................................................... 87
6.3. Propiedades específicas a los diferentes Object Graphics. ................................... 88
6.3.1. DFrame. ........................................................................................................... 88
6.3.2. Ellipse............................................................................................................... 89
6.3.3. Image............................................................................................................... 90
6.3.4. Line .................................................................................................................. 91
6.3.5. Rectangle ......................................................................................................... 91
6.3.6. Rounded Rectangle........................................................................................... 92
6.3.7. Text Graphic ..................................................................................................... 93
Capitulo 7 ............................................................................................................................... 94
7.1. Tipos de SQLStatement. ................................................................................................ 94
Capitulo 8 ............................................................................................................................. 100
8.1. Conceptos básicos de las lista de ayuda....................................................................... 100
3
8.1.1. Listas de Ayuda y Sentencias SQL. ......................................................................... 101

8.1.2. Valores de las sentencias SQL. .............................................................................. 102
8.1.3. Creando una lista de ayuda. ................................................................................. 102
Capitulo 9. ............................................................................................................................ 110
9.1. Propiedades de los métodos. ...................................................................................... 110
Capitulo 10. .......................................................................................................................... 112
10.1. Conceptos básicos. ................................................................................................. 112
10.2. Adjuntar una librería. ........................................................................................... 112
Capitulo 11. .......................................................................................................................... 113
11.1. Conceptos básicos..................................................................................................... 113
Capitulo 12. .......................................................................................................................... 115
Capitulo 13. .......................................................................................................................... 117
Capitulo 14. .......................................................................................................................... 118
Capitulo 15. .......................................................................................................................... 121
15.2. Propiedades. ............................................................................................................ 121
15.2.1. Propiedades en común de los frame de tipo Principal y Stacked. .......................... 121
15.2.2. Propiedades únicas de los frames tipo Stacked. ...................................................... 125
Anexo 1. ............................................................................................................................... 126
4
Introducción
JFormsBuilder es una IDE (Ambiente de Desarrollo Integrado por sus siglas en ingles) que
nos permite desarrollar aplicaciones web empresariales. Las aplicaciones construidas con
JFormsBuilder se ejecutan sobre cualquier servidor de aplicaciones que soporte el JRE
(Java Runtime Environment) versiones 5.0 o 6.0 y se visualizan sobre cualquier navegador
moderno. Pruebas con resultados positivos se han efectuado sobre Firefox, Safari, Opera e
Internet Explorer.
JFormsBuilder está diseñado para proveerle al desarrollador las siguientes características.
 Facilidad de aprendizaje: JFormsBuilder es una herramienta intuitiva de muy

fácil aprendizaje. Tiene una variedad de asistentes que le permiten automatizar el
desarrollo de muchos de los componentes que hacen parte de su aplicación, lo que
hace que el desarrollo sea guiado en cierta medida.
 Concentración en lógica de negocio: JFormsBuilder le permite concentrarse en

resolver la lógica de negocio de su aplicación, y de esta forma no preocuparse por
todos los componentes que hacen parte del desarrollo JEE y su integración.
JFormsBuilder realiza esta integración de componentes generando de forma
automática las clases de java requeridas para hacer de su aplicación, una solución
JEE.
 Desempeño: Las aplicaciones construidas con JFormsBuilder le permiten

construir aplicaciones que presentan muy buenos tiempos de respuesta en redes
de baja velocidad. Sin embargo no está de más de más aclarar que su aplicación
debe tener un balance entre funcionalidad y decoración, buscando siempre el
óptimo desempeño con la mejor apariencia posible.
5
Capitulo 1.
Creando una forma básica
Para poder crear una aplicación con JFormsBuilder, primero necesitamos definir algunos
conceptos básicos utilizados en cualquier aplicación creada con la herramienta.
1.1. Conceptos básicos
 Forma. Una forma es la representación visual de su aplicativo, le permite al usuario final

interactuar con su programa y así poder digitar, consultar y procesar información. Una
forma en JFormsBuilder contiene diferentes elementos visuales tales como ventanas
internas, paneles, cajillas de texto, botones, entre otros.
 Proyecto. Un proyecto es un conjunto de formas. Le permite agrupar a sus formas en

aquellas que tienen una finalidad en común. Si por ejemplo su aplicativo está organizado
por módulos, cada módulo podría ser representado por un proyecto dentro de
JFormsBuilder. Con los proyectos se pueden automatizar procesos como la generación del
código java o la compilación de todos los formularios de un proyecto.
1.2. Familiaricémonos con la herramienta.
Demos un vistazo a la ventana principal del JFormsBuilder, la cual se muestra en la figura 1.1
para definir sus componentes.
La herramienta está formada por un panel superior que contiene el menú principal y una
barra de herramientas. Debajo de dicho panel se encuentran tres paneles. El panel de la
derecha contiene el navegador de objetos, esta herramienta en forma de árbol permite
navegar por los diferentes proyectos, formas y los elementos constitutivos de estas. El panel
central no contiene nada inicialmente, pero puede contener uno o varios editores de código o
gráficos. El panel de la derecha inicialmente no contiene nada, pero cuando nos ubicamos
6
sobre un nodo del árbol, en este panel se muestran las propiedades del nodo seleccionado, y si
al nodo se le pueden asociar eventos, se mostrará una segunda pestaña con los eventos
asociables al nodo.
Figura 1.1. Componentes Principales.
1.2.1. Menú Principal.
El menú principal tiene las opciones que se muestran en la figura 1.2.
Figura 1.2. Menú Principal.
7
El menú archivo nos permite administrar los diferentes archivos asociados con
JFormsBuilder. Podemos crear un proyecto nuevo, un menú o una librería desde aquí. Así
como también abrir o guardar esos tipos de archivos.
El menú editar nos muestra las opciones estándar de edición como copiar, cortar y pegar,
deshacer y rehacer que funcionan tanto para los editores de código y gráficos, como para los
nodos del árbol del navegador de objetos.
El menú ver permite mostrar los editores y las paletas de propiedades en caso de que estén
ocultas y se quieran mostrar de nuevo.
El menú buscar permite realizar búsquedas de texto sobre las unidades de programa y
eventos de una o más formas. También permite buscar nodos en el árbol, esto es
especialmente útil cuando tenemos formas con muchos ítems y deseamos encontrarlos de
forma ágil.
El menú opciones permite definir preferencias, tales como datos de conexión a la base de
datos, ruta por defecto para diálogos de abrir o guardar archivos, rutas en la que se
encuentran formas, entre muchas otras que definiremos más adelante cuando entremos en
detalle en la definición de preferencias.
El menú diseñador permite ocultar o mostrar la regla del diseñador, la paleta de

componentes, o el panel principal.
1.2.2. El navegador de objetos
El navegador de objetos es una utilidad en forma de árbol que nos permite navegar por los
proyectos, menús, formas y librerías. Al ser en forma de árbol podemos expandir sus
componentes para explorar sus subcomponentes, hasta llegar a los nodos que no permiten
expansión.
Cuando expandimos una forma, nos muestra los diferentes elementos que pueden estar
contenidos en esta.
Detallemos en forma general estos elementos:
8
 Eventos: Los eventos a nivel de forma son aquellos se pueden definir para responder a
acciones generales sobre toda la forma. Un ejemplo de esto son los eventos como el
PreForm o el Init que se ejecutan justo cuando el usuario final abre la forma.
 Atributos: Los atributos son un conjunto de propiedades visuales que se definen y que
se pueden asignar al registro actual, al elemento actual o para los elementos no
seleccionados. Son muy útiles cuando se trata de uniformar al aplicativo con un look
and feel homogéneo.
 Editores: Los editores son ventanas de dialogo que permiten que el usuario digite
información sobre una cajilla de texto.
 Datas: Los datas son los contenedores lógicos de elementos. Son una agrupación de
elementos que tienen algo en común. Imaginémonos una tabla de empleados, que
tenga como campos el código del empleado y su nombre. Podemos crear un data
llamado empleado e incluirle dos elementos que representen el código y nombre del
empleado. Los datas pueden ser de dos tipos: Enlazados a datos y de control.
 Listas de ayuda: Las listas de ayuda son una poderosa herramienta para ayudar al
usuario final determinar qué datos puede digitar sobre un campo. Permiten realizar
filtros, así como validar que la información digitada corresponda a un registro de la
lista.
 SqlStatements: Los SqlStatements son normalmente comandos SQL, aunque pueden

venir de valores estáticos, y son usados para llenar listas de valores, o para mantener
datos que la forma puede utilizar para crear registros.
 Frames: Los frames son los contenedores de toda la interfaz visual de JFormsBuilder.
Una forma en su parte visual contiene físicamente al menos un frame y estos a su vez
contienen paneles (se definen a continuación). Los frames pueden ser de dos tipos,
principal y apilado (dialogo). Una forma debe tener un frame principal y 0 o más
frames tipo dialogo.
9
 Paneles: Los paneles son los contenedores de todos los elementos visuales. Pueden ser
de 4 tipos: Principal, Apilado, de Pestañas y Grilla. Cada ventana debe tener al menos
un panel principal. Sobre el panel principal se pueden agregar paneles apilados, de
pestañas, y grillas.
 Mensajes: Los mensajes son alertas que se le envían al usuario final para informarle de
un error, o para preguntarle la acción a seguir en un determinado proceso. Las alertas
tienen la particularidad de detener el hilo de proceso, para esperar la respuesta del
usuario.
 Métodos: Los métodos son algoritmos programados en el lenguaje de programación

java o PlSql y en ellos se debería concentrar parte de la lógica de negocios de su
aplicación.
 Librerías: Las librerías son un conjunto de funciones agrupadas en una clase de java
que pueden ser usadas por diferentes formas. En este nodo definimos cuales van a ser
las librerías que esta forma puede usar.
 Parámetros: Una forma puede llamar a otra forma. La forma que realiza el llamado, es
conocida como forma padre y la que se crea como consecuencia del llamado, se
conoce como forma hija. Los parámetros son elementos que obtienen su valor del
llamado realizado por su forma padre y pueden ser accedidas desde el código PlSql
como: parameter.NombreDelParametro.
 PopUpMenus: Los menús emergentes son aquellos que surgen a partir del uso del click
derecho del mouse. En este nodo le podemos asociar menús emergentes a la forma.
 Clases de propiedad: Las clases de propiedad son un conjunto de propiedades que se

pueden crear para asignárselas a los elementos y de esta forma garantizar que los
elementos tengan asignadas cada una de las propiedades definidas en estos
elementos.
10
 Imports: Si trabajamos con librerías de terceros programadas en java, podemos incluir

las clases de estas librerías en este nodo del árbol, para que se generen en el código
java generado por JFormsBuilder.
1.2.3. El panel central.
El panel central es un contenedor de los editores de código o gráficos que hayamos abierto
con JFormsBuilder. Cada vez que hacemos doble clic sobre un método o evento,
JFormsBuilder abre un nuevo editor en una nueva pestaña dentro de este panel. De acuerdo
con las preferencias establecidas en el menú de preferencias, este se abre en java o en PlSql.
También podemos mostrar en una nueva pestaña el editor gráfico de una forma determinada.
La figura 1.3 muestra el panel central con varias pestañas creadas y en la pestaña activa se
está mostrando un método en PlSql.
Figura 1.3.Panel Central.
1.2.4. El panel derecho.
El panel derecho es el contenedor de la paleta de propiedades. Cuando nos situamos sobre un

nodo sobre el árbol, o cuando seleccionamos un componente en el editor gráfico, en el panel
derecho se muestra la paleta de propiedades con las propiedades que corresponden a este
11
elemento. Con esta paleta podemos revisar y modificar las propiedades de un elemento. La
figura 1.4 muestra la paleta de propiedades correspondiente a un botón de una forma.
Figura 1.4.Panel Derecho.
1.3. Creemos una forma
1.3.1. Prerrequisitos.
Tabla Empleados
La forma que vamos a crear permite insertar, borrar, eliminar y consultar los registros
correspondientes de la tabla empleado en la que se guarda la información básica de un
empleado o trabajador. A continuación presentamos el script de la tabla empleados. Esta tabla
es un prerrequisito y debe estar creada en su base de datos. Es importante indicar que la tabla
tiene una llave primaria. Las llaves primarias en bases de datos que no soporten generación
12
de identificadores únicos, tales como el ROWID de Oracle, son fundamentales para que
JFormsBuilder identifique los registros de su data.
Nota Importante:
El script que proveemos en este manual está diseñado para correr en una base de datos
Oracle.
CREATE TABLE EMPLEADOS

(CEDULA NUMBER(20),
COD_EMPRESA NUMBER(20),
NOMBRES VARCHAR2(50) NOT NULL,
APELLIDOS VARCHAR2(50) NOT NULL,
CARGO VARCHAR2(30) NOT NULL,
DIRECCION VARCHAR2(60),
TELEFONO NUMBER(20),
CORREO VARCHAR2(80),
VERSION NUMBER(20) DEFAULT 0,
CONSTRAINT EMPLEADOS_KEY PRIMARY KEY (COD_EMPRESA,CEDULA)
)
/
Script 1. Script tabla Empleados
Insertemos datos de prueba en la anterior tabla para futuras pruebas.
Conexión a la base de datos.
El siguiente prerrequisito es establecer la conexión a la base de datos desde la herramienta. La

cual se hace de la siguiente manera. Seleccionamos la opción del menú
/Opciones/Preferencias. Luego nos aparece una ventana como se muestra en la figura 1.5.
13
Figura 1.5.Preferencias.
En el panel derecho se encuentra la opción Escoja el origen de datos nos aseguramos que
este seleccionado JDBC.
En el panel izquierdo seleccionamos Connection, y nos aparece la ventana como se muestra

en la figura 1.6.
En esta ventana debemos seleccionar la ruta en la cual se guarda el archivo jdbc.properties que
va a contener la información digitada en esta ventana y que su aplicativo usará en tiempo de
ejecución para conectarse a la base de datos.
A continuación detallaremos la información de cada campo en la ventana anterior.
 Tamaño de la página: Define el número de registros a traer por defecto cuando se

realiza una consulta sobre un data.
 Tipo de base de datos: Define el fabricante de la base de datos soportado por el

JFormsBuilder.
14
Figura 1.6.Connection.
 Versión de la base de datos: Cada base de datos incorpora funcionalidad diferente en

sus bases de datos. La versión de la base de datos es importante porque el framework
en tiempo de ejecución usará o no funciones de la base de datos dependiendo de esta
propiedad.
 Tipo de conexión: Algunos fabricantes de bases de datos tienen diferentes formas de

conectarse a la base de datos, algunas bases de datos como Oracle presentan
conexiones nativas OCI (Oracle Call interface) la cual requiere del cliente Oracle
instalado en el servidor de aplicaciones y conexiones livianas llamadas THIN.
 Ip del servidor: Define la dirección IP o el nombre de la maquina donde reside la base

de datos.
 Nombre de la base de datos: Define el nombre de la instancia de base de datos.
15
 Puerto del servidor: Define el puerto en que escucha el servidor de base de datos.
 Usuario: Usuario que se conecta a la base de datos. Normalmente usamos un usuario

que tenga permisos para ver el diccionario de datos de la base de datos.
 Password: Clave del usuario anterior. Al generar el jdbc.properties esta clave se genera
encriptada.
Luego de establecer los valores anteriores podemos probar la conexión con el botón Test
de conexión de la parte inferior.
1.3.2. Creación del proyecto
Toda forma en JFormsBuilder requiere estar contenida en un proyecto, lo que nos obliga a
crear un proyecto. Para crear un proyecto vamos al menú principal y seleccionamos
Archivo/Nuevo/Proyecto. Nos aparece la ventana mostrada en la figura 1.7.
Figura 1.7. Nuevo Proyecto.
16
Damos un nombre al proyecto y establecemos la ruta del directorio donde se almacenará

el proyecto. Seguidamente JFormsBuilder crea el proyecto y lo muestra como un nodo del
navegador de objetos.
1.3.3. Creación de la forma

Crear una forma es una labor bastante fácil. Hacemos clic contrario sobre el proyecto
donde queremos incluir la nueva forma. Luego aparece un menú emergente, sobre este
menú hacemos clic en la opción Nueva Forma tal como se muestra en la figura 1.8.
Figura 1.8. Nueva Forma.
Al hacer clic en nueva forma, se nos muestra el asistente para crear una nueva forma. El
asistente nos permite suministrar la siguiente información acerca de la forma:
Nombre del Formulario: Nombre que le queremos dar al formulario. Este también será
el nombre de la clase principal de java generada.
Ruta del directorio: La ruta en la que se almacenará la forma.
Paquete: Paquete de java en el cual va a contener las clases de java generadas.
Extiende: Si la forma extiende funcionalidad de otra forma, Aquí colocamos el nombre de

la clase de java de la cual se extiende la funcionalidad.
17
Figura 1.9.Estructura de la Nueva Forma.
La nueva forma tiene una estructura como la mostrada en la figura 1.9.
En el capitulo 1.2.2. se explican cada uno de los componentes que hacen parte de la estructura
de la forma.
Empecemos a trabajar con la nueva forma. Las formas pueden ser abstractas o no abstractas.
Las abstractas son aquellas que no se instancian, es decir aquellas que sirven como base para
nuevas formas. Las formas abstractas pueden ser formas plantillas que contienen
funcionalidad estándar común para varias formas. Las formas abstractas no requieren tener
una ventana principal o un panel principal.
Nuestra nueva forma va a ser del tipo no abstracta. Por defecto JForms crea formas del tipo no
abstractas. Toda forma no abstracta necesita de al menos una ventana (frame) principal. La
ventana principal es la ventana del navegador de Internet. Las demás ventanas son ventanas
emergentes que se muestran dentro del navegador. Creemos entonces la ventana principal.
Para crear cualquier ventana, hacemos clic contrario sobre el nodo Frames de nuestra forma,
como es usual, un menú emergente se nos muestra. Del menú emergente hacemos clic en
adicionar. Seguidamente el dialogo de crear nueva ventana aparece tal como se muestra en la
figura 1.10.
18
Figura 1.10.Dialogo Crear Ventana.
El dialogo de crear ventana nos pide que le suministremos el nombre de la ventana y el tipo de
ventana. Los tipos posibles son Principal y Stacked. Seleccionemos tipo de ventana principal.
Luego de haber creado nuestra ventana debemos crear un panel principal. Los paneles son los
contenedores de los cokmponentes. Existen los siguientes tipos de paneles: Principal, Stacked,
Tabbed, Grid y Toolbar. Todo panel debe estar contenido en una ventana.
Para crear el panel de nuestra forma, hacemos clic contrario sobre el nodo Panels de nuestra
forma. Seleccionamos adicionar. El dialogo de crear panel aparece tal como se muestra en la
figura 1.11.
Le damos un nombre a nuestro panel, seleccionamos su ventana contenedora, y el tipo de

panel a crear.
Figura 1.11.Dialogo Crear Panel.
19
Ya tenemos listos los contenedores básicos de nuestra forma. Ahora podemos proceder a
incluir elementos que den funcionalidad a nuestra forma.
Todos los componentes (Widgets) en JForms están incluidos en datas. Procedamos

entonces a crear un data. Hacemos clic en el nodo P_DATA de nuestra forma.
Seguidamente un dialogo nos da la opción de correr el asistente de creación de datas o
crear un data manualmente. Para nuestro caso, seleccionemos crear el data con un
asistente.
Al crear un data con el asistente, aparece un dialogo tal como se muestra en la figura 1.12.
Figura 1.12.Creación de un data con asistente.
Haciendo clic en el botón Tablas JDBC de la esquina superior derecha, podemos

seleccionar una tabla o vista a la cual va a estar enlazada nuestro data. Seleccionemos la
tabla Empleados de la lista de tablas que se nos muestra. Luego en el recuadro campos
disponibles se nos llena una grilla en la que nos muestra todos los campos de la tabla
Empleados. En esta grilla podemos seleccionar aquellos campos que van a hacer parte del
data. Los campos que hacen parte de la llave primaria de la tabla son obligatorios. Es decir,
estos campos deben hacer parte del data, aunque es opcional que el programador los
visualice en algún panel. La razón de esto es porque en bases de datos diferentes a Oracle
20
y Oracle versiones inferiores a 10g, las llaves primarias se usan para identificar un
registro en un data de forma única y de esta manera ejecutar internamente el comando
SQL para la manipulación de datos.
Para efectos de nuestro ejemplo, dejemos todos los campos como los muestra el asistente
y procedamos a hacer clic en siguiente. Al hacerlo nos muestra un dialogo en el que
concluye la creación del data. Podemos hacer clic en el botón Finalizar y concluimos con
la creación del data, o podemos continuar, haciendo clic en el botón Siguiente, con el
asistente para la ubicación de los elementos recién creados en el panel que contiene la
forma. Hagamos clic en Siguiente para ubicar los fields creados por el asistente en el panel
creado por nosotros previamente.
Figura 1.12.Seleccion del panel donde se muestran los elementos.
En el recuadro de la parte superior llamado Panel donde se desea mostrar los elementos
podemos seleccionar el panel contenedor de los elementos de nuestro data recién
creados. En el recuadro inferior Tipo de Forma podemos seleccionar si nuestro nuevo
data va a mostrar los elementos como un formulario (se muestran los campos en un solo
registro) o multi-registro (se muestra más de un registro).
21
Para efectos de nuestra forma seleccionemos el panel creado por nosotros anteriormente,
y seleccionamos Modo Formulario en el recuadro Tipo de Forma y hacemos clic en
siguiente.
Luego se nos muestran un dialogo como el mostrado en la figura 1.13.
Figura 1.13.Seleccion de campos a mostrar.
En este dialogo podemos seleccionar los campos que queremos visualizar de todos los
campos que se crearon con el data. Aquí también podemos cambiar las etiquetas de los
campos, el tipo de componente con el que queremos visualizar el campo, las coordenadas
x e y del campo, su ancho, su alto y el número de registros visualizados. Anteriormente
establecimos que nuestro data va a mostrarse como un formulario, es decir con un solo
registro Cuando seleccionamos mostrarse como formulario internamente el asistente
establece la propiedad número de elementos visualizados del data a 1. Si un data, es
mostrado como multi-registro, la propiedad número de elementos visualizados es
establecida con el número digitado por nosotros. Es posible establecer la propiedad
22
número de elementos visualizados para cada uno de los elementos del data. Podemos
establecerla a un número menor o igual que los registros de su data, pero NO es posible un
número mayor. Si colocamos un número mayor la forma no funcionara correctamente.
Luego de esto podemos hacer clic en siguiente y luego hacemos clic en finalizar.
Con esto concluimos la creación del data. Ahora podemos ver lo creado por el asistente. En
el árbol del navegador de objetos podemos ver que en el nodo P_DATA, existe un nodo
creado llamado EMPLEADOS. Si expandimos este nodo vemos que existen dentro de éste
tres nodos llamados: EVENTS, FIELDS Y RELATIONS. Podemos expandir FIELDS y
notamos que se crearon los campos seleccionados durante el asistente tal como lo
muestra la figura 1.14.
Figura 1.14.Data creado por el asistente.
Ahora procedamos a darle un poco de color a nuestra forma. Seleccionamos cualquier

nodo dentro de la forma y nos vamos al menú principal y seleccionamos la opción
Ver/Diseñador gráfico. El diseñador gráfico es una herramienta que nos permite de forma
gráfica modificar los elementos y contenedores de nuestra forma. El diseñador gráfico nos
permite diseñar por panel o por ventana. Si trabajamos por ventana, solo nos permite
modificar los paneles pertenecientes a una ventana. Si trabajamos por panel nos permite
modificar los elementos contenidos en el panel seleccionado.
23
El diseñador gráfico viene con herramientas para alinear elementos en diversas

posiciones, así como también, hacerlos del mismo tamaño. Podemos seleccionar un
elemento y arrástralo a cualquier ubicación dentro del panel, así como también cambiarle
su tamaño. Con el diseñador gráfico podemos incluir nuevos elementos y eliminar los ya
existentes. Podemos también incluir elementos gráficos que no pertenecen a ningún data,
pero que añaden organización y visualización a nuestra forma.
Para efectos de nuestra forma, cambiemos el color blanco de fondo por un color azul. En
el diseñador gráfico, seleccionamos el panel, para hacerlo hacemos clic dentro de
cualquier parte del panel asegurándonos de no estar seleccionando ningún elemento
diferente al panel. En la paleta de propiedades, seleccionamos la propiedad Color. Para
cambiar su valor, hacemos doble clic sobre la columna valor de la propiedad Color. Nos
aparece el dialogo Seleccione un color, hacemos clic en Definir colores personalizados y
se expande el dialogo para verse con el mostrado en la figura 1.15.
Figura 1.15.Selección del color.
Podemos seleccionar el color a través la combinación de colores Rojo, Verde o Azul,

seleccionarlo haciendo clic en cualquier lugar en el área de colores o seleccionarlo de los
colores básicos.
24
Para efectos de nuestra forma seleccionemos cualquier tonalidad de azul. Hacemos clic en
aceptar y el color de nuestro panel cambia al color seleccionado.
Luego de haber hecho lo anterior procedamos a cambiar las etiquetas de los diferentes
campos para colocarles una descripción más precisa del campo.
Para hacerlo, seleccionamos el campo y en la paleta de propiedades seleccionamos Prompt.

Hacemos doble clic en Prompt y un dialogo nos muestra el valor actual de la propiedad,
escribamos la descripción adecuada para cada campo y hacemos clic en Aceptar.
Hasta ahora tenemos un formulario con un data que está asociado a una tabla llamada
Empleados. Sin embargo existen campos de la tabla que no queremos visualizar en un panel,
tal como el campo version que se usa internamente para manejar la concurrencia. Para
removerlo seleccionamos el campo version desde el diseñador gráfico o desde el navegador
de objetos y usando la paleta de propiedades, le establecemos el valor null a la propiedad
Panel Container.
También podemos crearle una barra de herramientas a nuestro formulario. Para hacerlo
creamos un nuevo panel. Al mostrarse el dialogo Creando un nuevo Panel, seleccionamos
Toolbar como nuestro tipo de panel y la ventana principal como la ventana contenedora de
nuestro panel. Las barras de herramientas pueden ser horizontales o verticales. Por defecto
las barras de herramientas se crean horizontales. Esto quiere decir que se visualizan a lo largo
del borde superior de la ventana contenedora. Los verticales se visualizan a lo largo del borde
izquierdo de la ventana contendora.
Una vez creado nuestro panel tipo Toolbar, procedamos a incluirle elementos. Creemos un
nuevo data, esta vez sin el asistente porque no queremos enlazarlo a ninguna tabla, vista o
cualquier otra fuente de datos. Hacemos clic sobre el nodo P_DATA, pero esta vez
seleccionamos Crear un data manualmente. En el nombre del data escribimos TOOLBAR.
Como nuestra barra de herramientas es horizontal, el tamaño está definido por la altura que
establezcamos en las propiedades del panel y el ancho que tenga su ventana contenedora.
Seleccionemos entonces el panel y establezcamos una altura de unos 40 pixeles.
25
Para agregar elementos a nuestra barra de herramientas: Desde el diseñador gráfico,

seleccionemos, primero el panel que queremos modificar y luego el data al cual se agregan los
elementos, tal como se muestra en la figura 1.16.
Figura 1.16.Selección del panel y data.
Una vez seleccionado lo anterior, simplemente podemos colocar los elementos en el

correspondiente panel. Para hacerlo hacemos clic en el elemento que deseamos colocar y
luego dibujamos el elemento en la región del panel donde lo queramos ubicar. Al hacerlo, se
nos muestra un dialogo en el que se nos pide introducir un nombre para el nuevo elemento.
Para efectos de nuestro ejercicio, hagamos clic en un botón y luego dibujamos el botón en la
región del panel Toolbar donde lo deseamos ubicar. Nombremos nuestro nuevo botón como
Buscar. Para agregarle código a nuestro botón, lo seleccionamos y hacemos clic contrario
sobre él, para luego seleccionar el evento When_Button_Pressed. Al hacerlo se abre una
nueva pestaña sobre el panel central de JForms Builder. Esta nueva pestaña, muestra el
editor de código y sobre este editor podemos programar en PL/SQL o Java directamente.
Agreguemos el código PL/SQL mostrado en la figura 1.17.
26
Figura 1.17.Codigo para botón Buscar.
Procedamos a compilar el código anterior. Para hacerlo hacemos clic en la Barra de

Herramientas de JForms Builder.
Podemos generar el código Java de nuestra forma y ejecutarla en modo Cliente/Servidor

para efectos de pruebas. Antes debemos tener creado un proyecto en Eclipse o en
cualquier otra IDE de Java.
Creación del proyecto en Eclipse.
Eclipse, así como cualquier otra IDE de java, es un complemento para JFormsBuilder,
Podemos crear un proyecto en Eclipse y mapearlo a un proyecto de JFormsBuilder. Para
crear un proyecto en Eclipse, nos vamos al menú File/New /Java Project. Creamos el
proyecto nuevo. Podemos darle un nombre y dejar los valores por defecto. Luego
creamos dos carpetas de fuentes haciendo clic contrario sobre el proyecto y del menú
emergente seleccionamos la opción New/Source Folder. Por convenciones de
nomenclatura, creemos las carpetas src/main/java y src/main/resources.
Para poder ejecutar una forma o reporte desde Eclipse, debemos agregar las
correspondientes librerías. Una manera de agregar librerías es mediante el uso de
variables classpath. Una variable classpath es una referencia a una ubicación en disco, ya
sea archivo o carpeta. Estas variables hacen mucho más fácil compartir proyectos entre
un equipo de trabajo dado que los integrantes del equipo se ponen de acuerdo en que
nombre(s) de variables van a usar y la apuntan al lugar dentro de su disco en el que
están las librerías. De esta manera si tu proyecto lo usa otro desarrollador que maneja
una estructura de disco diferente a la tuya, cuando importe tu proyecto, no va a tener
ninguna dificultad.
En el menú principal de Eclipse hacemos clic en la opción Window/Preferences. Al
hacerlo un dialogo como el mostrado en la figura 1.18 se nos muestra. Del menú
mostrado en el panel izquierdo, seleccionamos la opción Java/BuildPath/Classpath
Variables. En el panel derecho se nos muestran tres botones New, Edit y Remove.
Hacemos clic en New y un nuevo dialogo se nos muestra en el que nos pide el nombre de
la variable y la ruta del archivo o carpeta a la cual vamos a apuntar nuestra nueva
variable. Creamos la variable librerias (preferiblemente sin la tilde) y la apuntamos a la
27
carpeta donde tenemos las librerías del JFormsBuilder. El instalador de JFormsBuilder

deja las librerías en la carpeta donde nosotros decidimos instalarlo o si es un
descomprimido, la ruta en la cual ubicamos las librerías.
Figura 1.18.Creación de las variables classpath.
Una vez creada la variable classpath librerías, podemos usarla para agregar las librerías
a nuestro proyecto. Nuevamente hacemos clic contrario sobre nuestro proyecto y
seleccionamos la opción Propiedades. Un dialogo se nos muestra a continuación como el
de la figura 1.19. Del menú mostrado en el panel izquierdo del dialogo seleccionamos
Java Build Path. En el panel de la derecha, se nos muestran unas pestañas.
Seleccionamos la pestaña librerías. De los botones mostrados en el panel de la derecha
hacemos clic en Add Variable.
28
Un dialogo como el mostrado en la figura 1.20 se nos muestra. En este dialogo se

visualiza la variable que acabamos de crear y podemos extenderla para tomar los
archivos de las librerías. Para realizar esto hacemos clic en el botón del extremo superior
derecho llamado Extends. Luego seleccionamos los archivos de librerías copiados
durante el proceso de instalación. Los archivos de librerías que se deben seleccionar son:
Principals.jar, Librerias_1.jar, Librerias_2.jar, ojdbc14.jar, commons_email-1.1.jar,
commons_fileupload.jar,
Figura 1.19.Propiedades del proyecto Eclipse.
commons_io-1.4.jar. Estos archivos contienen el framework y las librerías de terceros

usadas por el framework.
29
Figura 1.20. Adición de variables al proyecto.
Para que la forma se conecte a la base de datos, debemos generar incluir en la carpeta
src/main/resources una nueva carpeta llamada jdbc. Para crearla desde Eclipse,
hacemos clic derecho sobre la carpeta src/main/resources y del menú emergente
seleccionamos new / folder. Escribimos el nombre jdbc para nuestra nueva carpeta.
Dentro de esta carpeta se crea un archivo llamado jdbc.properties que debe ser generado
desde JFormsBuilder. Para crear el archivo nos vamos a las preferencias de
JFormsBuilder y seleccionamos conexión. En la ruta de JDBC seleccionamos la carpeta
jdbc que acabamos de crear. Si no hemos diligenciado los campos de la conexión lo
hacemos y damos clic en Exportar Archivo. Si lo desea puede probar la conexión en el
botón Test de Conexión.
Generación de la forma y Ejecución desde Eclipse.
Una sugerencia al momento de crear las formas y los proyectos en JFormsBuilder es

crearlos en la carpeta src/main/java de nuestro proyecto en Eclipse. De esta forma al
momento de generar el código java desde JFormsBuilder se crean los paquetes en esta
carpeta y el código Java generado se crea dentro de estos paquetes, lo que hace mucho
más fácil ejecutar y depurar el programa. Desde JFormsBuilder seleccionemos cualquier
30
nodo de nuestra forma. En el menú superior seleccionamos opciones/Generar y exportar

archivo Java con main. Un dialogo se muestra a continuación indicando las clases de Java
generadas. Las clases de Java generadas corresponden a dos clases iniciales en las que se
crean los objetos que contiene la forma. Una clase principal que contiene los métodos
definidos en la forma y una clase de Java por cada data que contenga la forma en la cual se
definen los eventos a nivel de data y a nivel de field de la forma.
Volvamos a Eclipse para examinar el código Java generado y ejecutar la forma. Sobre el
proyecto recién creado hacemos clic derecho y del menú emergente, seleccionamos la
opción refresh. Inmediatamente aparecen en la carpeta src/main/java los paquetes
generados y dentro de ellos las clases de Java que acabamos de generar. Si a la forma le
establecimos el nombre Documentacion, nos debe aparecer una clase de Java llamada
Documentacion.java acompañada por dos clases más llamadas
Documentacion_class1.java y Documentacion_class2.java. Además se debió generar un
sub-paquete que sigue la siguiente regla de nomenclatura: “paquete de la
forma”.data.”nombe del bloque”. En dicho paquete deben existir tantas clases de Java como
datas de la forma.
La clase principal de nuestra forma es Documentacion.java. Podemos ejecutarla haciendo

clic derecho sobre la clase y del menú emergente haciendo clic en Run as / Java
Application.
También podemos ejecutarla en modo de depuración haciendo clic derecho sobre la clase
y del menú emergente haciendo clic en Debug as / Java Application.
Una vez ejecutada y probada podemos desplegarla en cualquier servidor de aplicaciones y

visualizarla en modo Swing o Ajax. Para hacerlo debemos generar un archivo jar con
nuestro proyecto e incluirlo en el archivo war proveído por ASPSolutions S.A. Los
despliegues se explican adelante en el libro con más detalle.
El resultado de nuestra forma lo podemos apreciar en la figura 1.21.
31
Figura 1.21.Nuestra forma básica.
32
Capitulo 2.
Examinando las propiedades y eventos de una forma
En este capítulo, aprenderemos a identificar las propiedades de una forma, su definición y

funcionamiento, con el fin de adquirir habilidades para manipularlas de la mejor manera y
poder desarrollar aplicaciones fácilmente. También vamos a examinar los eventos
programables únicamente a nivel de forma y veremos cuando y bajo que circunstancia.
2.1. Examinando una forma.
Una forma es una colección de objetos y código que incluye frames, elementos de texto, casillas
de verificación, botones, disparadores y métodos.
Una forma tiene propiedades que la identifican y le proporcionan ciertas características y

comportamiento, y eventos que se disparan cuando el usuario interactúa con la forma.
2.1.1. Propiedades.
La figura 2.1 define muestra las propiedades de una forma:
33
Figura 2.1.Propiedades de una forma.
Veamos en detalle cada una de estas propiedades:
 Abstract:
Existen formas que vamos a crear como referencia para que otras formas extiendan de
ella, es decir, va a representar para nuestras aplicaciones una plantilla de la cual, las
demás formas de su aplicación heredarán ciertos atributos como color, forma, etc.,
además de ciertas funcionalidades.
Cuando establecemos el valor de esta propiedad a verdadero decimos que la forma es

abstracta y como consecuencia no podrá ser instanciada por sí misma, es decir, solo
cuando otra forma extienda de esta y su propiedad abstract este establecida a falso, se
podrá ver su funcionalidad.
A una forma abstracta no se le aplican restricciones que aplican para los otros tipos de
formas, tales como la existencia de al menos una ventana principal, un panel principal,
entre otras.
 Comments:
34
En esta propiedad se establecen comentarios que se deseen hacer sobre la forma. Es un

texto libre que se puede utilizar de manera informativa para describir la forma en
general.
 Console Frame:
En esta propiedad se determina cual es la ventana principal. Si hemos incluido varios

frames de tipo principal, esta propiedad determina cual es el frame de mayor
jerarquía dentro de los frames definidos en la forma.
 Default Menu:
Esta propiedad se utiliza cuando se desea utilizar el menú por defecto de

JFormsBuilder. El menú JFormsBuilder contiene funcionalidad muy útil para cualquier
forma, incluye opciones para guardar, limpiar, ejecutar consultas, borrar registros,
crear registros, entre otras.
 Extends Name:
En esta propiedad se define el nombre de la forma de la cual deseamos extender

funcionalidad. Aquí podemos establecer cualquier otra forma creada por
JFormsBuilder. Cuando creamos una forma que extiende su funcionalidad de una
plantilla, mediante el uso de esta propiedad podemos decirle a nuestra nueva forma
que tome la funcionalidad definida en la plantilla.
 First Navigation Data:
Mediante el uso de esta propiedad podemos establecer cuál va a ser nuestro primer
data navegable. Si esta propiedad no está establecida, el primer data navegable es el
primer data con elementos navegables que aparece en la lista de datas de nuestra
forma en el navegador de objetos. Cabe resaltar que pueden existir datas que no
contengan ningún elemento navegable y como consecuencia son considerados datas
no navegables.
 Menu Name:
35
Si hemos creado un menú con JFormsBuilder, mediante esta propiedad podemos

asociar este menú con nuestra forma.
 Name:
En esta propiedad podemos visualizar el nombre que le hemos dado a nuestra forma.
 Package:
Además de agrupar las formas en proyectos, las clases de java pueden estar agrupadas
en paquetes. Por ejemplo, si tenemos agrupados nuestras formas en proyectos que
representan módulos de nuestra aplicación, los paquetes podrían representar sub-
módulos.
 Package Extends:
En esta propiedad definimos el paquete en el cual está contenida la forma de la cual

estamos extendiendo.
 Package Menu:
En esta propiedad definimos el paquete en el cual está contenido el menú asociado a

nuestra forma.
 Route:
En esta propiedad podemos visualizar la ruta en la cual está guardada nuestra forma.
 Route of the bin folder:
En esta propiedad definimos la ruta en la cual se encuentran las clases compiladas de

java.
 Variables:
En esta propiedad definimos las variables a nivel de forma que queremos definir para
poderlas usar desde cualquier método o evento de nuestra forma. Estas variables se
crean como propiedades protegidas en la clase principal de Java generada.
36
2.1.2. Eventos:
Los eventos se pueden definir en distintos niveles dentro de JFormsBuilder. Por ejemplo,
podemos definir el evento WhenValidateField a un field de un data. Pero también se lo
pudimos agregar al data o inclusive a la forma. Cuando es momento de disparar un evento,
JForms examina el field que disparo el evento, si este responde a ese evento, ejecuta el código
asociado a nivel de field, sino examina su data contenedor y sino examina la forma.
También existen eventos que no aplican a fields, y existen otros que no aplican a fields ni a
datas. Más adelante veremos cada uno de los eventos y analizaremos el orden en que estos se
disparan y bajo que acción se disparan.
En este capítulo veremos solo los eventos que se disparan a nivel de formas. Los eventos están
agrupados en los eventos disparados al entrar en una forma, durante la ejecución de la forma
y al salir de la forma.
2.1.2.1. Al entrar en una forma.
Cuando abrimos una forma, JForms dispara los siguientes eventos.
 PreLogon:
Este evento se dispara justo antes de que JForms intente conseguir una sesión de base
de datos. También se dispara cuando el usuario hace uso del método logon().
 OnLogon:
Si el evento OnLogon está definido en la forma, este es disparado en vez de seguir con
la conexión por defecto a la base de datos de la forma. En este evento podríamos
“sobre-escribir” la manera en que JForms se conecta a la base de datos. El archivo de
conexión por defecto a la base de datos jdbc.properties, determina las propiedades
por defecto con las cuales la forma se conecta a la base de datos, durante la ejecución
de este evento podemos conectarnos a la base de datos con propiedades diferentes a
las establecidas en este archivo. El método logon() es usado muy de la mano con este
evento. También se dispara cuando el usuario hace uso del método logon().
 PostLogon:
37
Este evento se dispara después de que JForms intentó conseguir la sesión de base de
datos o su forma lo sobre-escribió a través del uso del evento OnLogon. También se
dispara cuando el usuario hace uso del método logon().
 PreForm:
Se dispara luego de que se ejecutaron los eventos anteriores y antes de que JForms
ejecute la navegación inicial, es decir, antes de que JForms determine cuál es el primer
field navegable.
 Init – WhenNewFormInstance:
Una vez ejecutada la navegación inicial y determinado el primer field navegable,
JForms ejecuta este evento. Si se han agregado eventos como el PreTextField , PreData
entre otros, estos se dispararán antes que el Init o WhenNewFormInstance porque
hacen parte de los eventos disparados durante la navegación inicial. Los eventos de
navegación se explican más adelante porque pueden aplicarse a datas o fields.
2.1.2.2. Durante la ejecución de una forma.
Durante la ejecución de una forma, una acción de un usuario puede dispara un evento
controlable por un método que responde a ese evento y que solo se puede definir a nivel de
Forma. Los eventos que se disparan solo a nivel de Forma son:
 WhenTabPageChange:
Si una forma tiene al menos un panel tipo pestañas, al cambiar de una pestaña a otra,
se dispara este evento. Para determinar la pestaña que cambió, hacemos uso de la
variable del sistema TabNewPage. Esta variable nos devuelve el nombre de la
siguiente forma panel.pestaña.
En PL/SQL, lo hacemos de la siguiente forma:

:System.Tab_New_Page;
En java, lo hacemos de la siguiente forma:

getTabNewPage ();
 WhenTimerExpired
38
Para explicar la ejecución de este evento, expliquemos primero que es un Timer. Un

Timer es un objeto que se crea dentro de cualquier método de la forma y que
asíncronamente cada determinado tiempo (intervalo) ejecuta el evento
WhenTimerExpired.
El WhenTimerExpired entonces se ejecuta cada vez que un Timer cumple con el
tiempo definido en su intervalo.
No es recomendable crear Timers al iniciar la forma.
 WhenWindowResized
Cuando un frame interno es cambiado de tamaño (ampliado o reducido) se ejecuta el
evento WhenWindowResized.
Para determinar cuál es la ventana que se modificó hacemos uso de la variable del
sistema Event_Window.
En PL/SQL, lo hacemos así:

:System.Event_Window;
En java, lo hacemos así:

getCurrentWindow ();
 WhenWindowClosed
Cuando cerramos una ventana se dispara este evento. De la misma manera, como lo
hicimos en el evento WhenWindowResized, podemos obtener la ventana que disparo
el evento.
2.1.2.3. Al salir de una forma.
Al salir de una forma se ejecutan varios eventos en los que el programador, dependiendo el
caso, puede realizar acciones para terminar de la mejor manera la ejecución de su forma. Los
eventos que se disparan al salir de una forma son los siguientes:
 PostForm:
39
Al salir de una forma, por código, o por presionar el botón salir de la ventana principal,
este evento es el primero que se dispara.
 OnRollback:
Justo después de disparar el PostForm, se dispara el OnRollback, en el cual podemos
sobre-escribir el rollback por defecto de JForms.
 PreLogout:
Luego de ejecutar el evento OnRollback, se ejecuta el evento PreLogout. Este evento se
dispara antes de que JForms libere la sesión de base de datos con el método logout().
 OnLogout:
El siguiente en la secuencia de eventos es el OnLogout. Si se ha definido este evento, se
dispara en vez de ejecutarse el método logout().
 PostLogout:
Luego de ejecutarse el evento anterior, por último se dispara el evento PostLogout.
40
Capitulo 3.
Examinando las propiedades y eventos de los datas
3.1. Examinando un Data.
Una data es una agrupación lógica de fields. Esta agrupación se hace con diferentes
objetivos.
1. Debido a que los datas pueden estar enlazados a fuentes de datos como tablas o vistas,
los fields pertenecientes a un data pueden estar enlazados a campos de dicha fuente
de datos. En un data no solamente se define la fuente de datos, sino también la
clausula where y order by
2. Los datas pueden gobernar el estilo de visualización de sus elementos. Por ejemplo,
podemos definir atributos visuales para que los elementos del data pertenecientes al
registro que mantiene el foco se visualicen de forma homogénea, o para que cualquier
elemento que mantenga el foco se visualice siempre igual.
3. Los datas pueden administrar los permisos de inserción, modificación, eliminación o
consulta de sus elementos.
4. Los datas también nos pueden permiten definir cuantos y a qué distancia se muestran
los registros dentro del data.
5. También podemos definir el estilo de navegación. Es decir cuando llegamos al último
field de un data cual es la acción a seguir: ir al primer field del data manteniéndose en
el mismo registro, hacer lo mismo pero cambiando de registro o navegar al primer
field del siguiente data navegable.
3.1.1. Propiedades:
El comportamiento anterior es definible a través de las siguientes propiedades:
 Alias:
41
Esta propiedad la establecemos cuando deseamos que JForms le agregue un alias a la fuente
de datos principal del data. El alias es especialmente útil si en la clausula where del data
estamos utilizando una consulta interna y la cruzamos con la fuente de datos asociada al
data.
 ClassName:
Cuando utilizamos TopLink o Hibernate como nuestro proveedor de datos aquí

establecemos la clase de Java que representa la fuente de datos. TopLink o Hibernate son
ORMs. Estos permiten realizar un mapeo objeto relacional, en la cual se establece un
relación de equivalencia entre una clase de Java y una fuente de datos relacional como
puede ser una tabla o vista.
 Comments:
Esta propiedad nos sirve para mantener comentarios sobre el data. Nos puede servir para
controlar fechas y autores de las diferentes modificaciones, así como para documentar el
objetivo del data.
 Current Field Visual Attribute:
Los atributos visuales son grupos de propiedades que definen como se visualiza un
elemento. El Current Field Visual Attribute define el atributo visual del field actual.
Cuando un field toma el foco, esta propiedad define como se visualiza dicho elemento. El
atributo visual puede hacer que tome un color de fondo, un tipo de letra y otros atributos
que modifiquen su forma.
 Current Record Visual Attribute:
En esta propiedad establecemos el atributo visual del registro actual. Cuando un registro
toma el foco, esta propiedad define como se visualizan todos los elementos de dicho
registro. El atributo visual puede hacer que dichos fields tomen un color de fondo, un tipo
de letra y otros atributos que modifiquen su forma.
 Database Data:
42
En esta propiedad establecemos si el data es un data enlazado a un objeto de la base de

datos. Si esta propiedad está definida se debe definir la fuente de datos y el tipo de fuente
de datos.
 Data Type:
Los datas pueden ser visualizables como árboles. Cuando un data es visualizable como árbol
presenta características y restricciones particulares. Entre otras están que sólo puede
contener un ítem y este único ítem debe ser de tipo árbol.
En esta propiedad establecemos si el data es visualizable como un árbol o como un data

normal.
 Data Source:
Cuando un data está enlazado a un objeto de la base de datos, en esta propiedad

establecemos el nombre de dicho objeto. Este objeto puede ser:
- Una tabla o vista
- Una consulta a la base de datos
- Un procedimiento almacenado que devuelva un conjunto de resultados.
 Delete Allowed:
En esta propiedad definimos si el usuario final puede o no eliminar registros del data. El
valor true(verdadero) indica que el usuario si está autorizado para eliminar registros.
 Distance Between Records:
Un data contiene elementos que pueden ser visualizados en varios registros. Cuando es así
el data es considerado multi-registro. La Figura 3.1 muestra un data multi-registros.
43
Figura 3.1 Distancia entre registros
Los registros generados se distancian unos de otros con el valor en pixeles establecido en
esta propiedad.
 Insert Allowed:
En esta propiedad definimos si el usuario final pude o no insertar registros del data. El valor
true(verdadero) indica que el usuario sí está autorizado para insertar registros.
 Java Name:
En esta propiedad se visualiza el nombre java que JFormsBuilder le va a dar al data. Cuando
se genera el código java, este objeto representante del data se crea con este nombre.
 Max Page Size:
En esta propiedad se define cual es el número máximo de registros por página. Cuando
llamamos al método executeQuery a la base de datos, esta consulta puede arrojar muchos
registros. El número de registros que le vamos pidiendo a la base de datos y enviando al
cliente es el definido en esta propiedad.
 Name:
Esta propiedad define el nombre con el que vamos a identificar este data. Este nombre lo
vamos a usar cuando referenciemos al bloque desde los diferentes métodos del
JFormsBuilder. Por ejemplo cuando naveguemos al data con el método goData (Nombre del
Data). También desde PL/SQL usamos este nombre cuando le asignemos el valor a un field
del data. :NombreDelData.NombreDelField.
44
 Next Navigation Data:
La secuencia de navegación dentro de la formas puede determinarse por el orden en que se

encuentran los datas creados en JFormsBuilder, también puede modificarse haciendo uso
de eventos en los cuales se llama a métodos de navegación (Por ejemplo: nextData() ) o
haciendo uso de esta propiedad. En esta propiedad se puede definir cuál es el siguiente data
navegable. Si esta propiedad se define, el siguiente data ya no es el siguiente en el árbol del
navegador de objetos, sino el definido en esta propiedad. Cabe aclarar que el programador
puede cambiar esta secuencia haciendo uso de los eventos de navegación entre datas.
 NonUpdatable Data:
Establecer el valor de esta propiedad a verdadero indica que el data solamente va ser usado
para consultas. Al establecer esta propiedad en verdadero no se verifica que exista un
campo versión.
 Number of records displayed:
El número de registros desplegados define el número de componentes que se van a

visualizar para cada uno de los elementos del data. Esta propiedad también es definible a
cada elemento del data en particular. Cuando el número de registros para cada elemento
esta en cero (0) el elemento toma el valor definido en el data. Si el valor de la propiedad
para el elemento es mayor a cero y menor que el definido en el data toma el definido para
el elemento.
 Previous Navigation Data:
Similar al Next Navigation Data, pero para el data anterior en vez del siguiente.
 Order by:
En datas basado en tablas, vistas o procedimientos de la base de datos podemos, mediante

esta propiedad, establecer cual (es) son los campos de la base de datos sobre los cuales
vamos a hacer ordenamientos ascendentes o descendentes.
 Query Allowed:
45
Esta propiedad indica si el data permite realizar consultas sobre su fuente de datos
definida. Un data puede permitir inserciones, pero no permitir consultas.
 Query DataSource Arguments:
En esta propiedad se definen los argumentos que recibe un procedimiento almacenado

cuando un data es basado en un procedimiento que devuelve un conjunto de datos. Para
definir los argumentos, hacemos doble clic en el valor de la propiedad y se muestra una
ventana emergente como la de la figura 3.2.
Figura 3.2 Query Data Source Arguments
La figura 3.2. muestra un ejemplo de argumentos para el llamado a un procedimiento de la

base de datos. Debemos establecer el nombre del argumento en el campo nombre. El modo
indica si el argumento es de entrada(0), entrada-salida(1) o salida(2). También
establecemos el tipo de argumento y el valor de donde es tomado el argumento.
 Query DataSource Columns:
Un data basado en tabla, procedimiento o consulta devuelve un conjunto de registros. Cada

registro tiene columnas. En esta propiedad definimos los nombre de las columnas que son
devueltas al ejecutar el built-in Execute_Query. Esta propiedad es especialmente útil cuando
46
nuestro data es basado en un procedimiento almacenado. Al hacer doble clic sobre el valor
de esta propiedad nos muestra un dialogo como el de la figura 3.3.
La figura 3.3. nos muestra una tabla con los nombres, tipos, y demás propiedades de las
columnas que hacen parte de los registros devueltos por un procedimiento almacenado en
particular.
Esta propiedad es fundamental cuando el data es basado en un procedimiento almacenado

debido a que JForms mapea las columnas definidas en esta propiedad con la fuente de datos
de los elementos que hacen parte de este data y que son basados en bases de datos.
Figura 3.2. Query Data Source Columns
 Query DataSource Type:
Como se ha mencionado anteriormente la fuente de datos de un data puede ser una tabla o
vista, un query, o un procedimiento almacenado que devuelve un conjunto de registros.
Aquí definimos cuál es el tipo de la fuente de datos de nuestro data. A continuación
describimos los diferentes tipos de fuentes de datos.
 Tabla o Vista:
47
Cuando es una tabla o vista, JForms efectúa las consultas basado en los elementos
del data que son basados en base de datos.
 From Clause Query:
Cuando es una consulta, JForms construye el from de la consulta a partir de la

consulta establecida en la propiedad Data Source.
 Procedimiento Almacenado:
Un procedimiento almacenado Oracle puede devolver un conjunto de registros.

Cuando un procedimiento es de ese tipo, podemos basar nuestro data en ese
procedimiento.
 Record Orientation:
Los registros por defecto están orientados verticalmente, es decir se muestran uno encima
del otro empezando de arriba hacia abajo. Pero también los podemos orientar
horizontalmente, es decir mostrarlos uno al lado del otro empezando de izquierda a
derecha.
 RecordVisual Attributes:
Cuando un registro no es el registro actual, sus elementos pueden tomar las características
gráficas del atributo visual definido en esta propiedad tales como color de fondo, fuente,
tamaño y color de las letras, entre otras.
 Scrollbar Active:
Esta propiedad indica si la barra de desplazamiento de registros se va a mostrar o no. Para

que esta propiedad tenga un efecto visible la barra de desplazamiento debe tener definidas
las siguientes propiedades: panel contenedor, alto, ancho y posiciones x e y visibles dentro
del panel contenedor.
 Scrollbar Height:
Esta propiedad indica el alto de la barra de desplazamiento medido en pixeles.
 Scrollbar Orientation:
48
Esta propiedad define si la barra de desplazamiento es vertical, es decir si se desplaza de

arriba abajo y viceversa, o si es horizontal y de desplaza de derecha a izquierda y viceversa.
 Scrollbar Panel:
Esta propiedad define cual es el panel contenedor de la barra de desplazamiento. Es decir

en cual panel se va a dibujar la barra de desplazamiento.
 Scrollbar Pos X y Pos Y:
Estas propiedades definen las coordenadas x e y del panel contenedor medidas en pixeles.
Estas propiedades determinan donde quedará ubicado el extremo superior izquierdo de la
barra, desde las cuales se empieza a dibujar la barra de desplazamiento.
 Single Record:
Esta propiedad indica si el data contiene un solo registro. Si esta propiedad se establece en
verdadero, JForms no permite que el data contenga más de un registro al tiempo.
 Navigation Style:
Esta propiedad define el estilo de navegación de los datas. Al momento de llegar al último
elemento navegable del data e intentar navegar mediante el teclado (tecla <tab> o <enter>)
al siguiente elemento navegable, JForms, dependiendo del valor de esta propiedad, puede
tomar uno de los siguientes caminos
 SameRecord:
JForms navega al primer elemento dentro del mismo registro del mismo data.
 NextRecord:
JForms navega al primer elemento del siguiente registro dentro del mismo data.
 NextData:
JForms navega al registro actual del siguiente data navegable.
49
Nota Importante:
El programador puede modificar la navegación en alguno de los eventos disparados,

tales como el post-text-item del último elemento navegable.
 Update Allowed:
En esta propiedad definimos si el usuario final pude o no actualizar registros del data. El
valor true(verdadero) indica que el usuario sí está autorizado para actualizar registros.
 Where:
En esta propiedad podemos establecer la clausula where mediante la cual filtramos los
registros obtenidos por la consulta. Esta clausula no aplica para data cuya fuente de datos
es un procedimientos almacenado.
3.1.2. Eventos:
Los eventos que analizaremos en este capítulo son aquellos a los que se puede responder a
nivel de data o forma. Los eventos tratables a nivel de field son analizados en el siguiente
capítulo.
Analicemos la secuencia de eventos cuando el cursor se ubica en algún elemento dentro del
data, es decir cuando entramos en algún data.
3.1.2.1. Eventos al navegar:
La figura 3.3.muestra el flujo de eventos que se disparan a nivel de data al entrar a un data
después de iniciar la forma, al navegar entre datas y al navegar entre registros de un mismo
data. La figura 3.3. no muestra los eventos que se disparan a nivel de field, ya que una gráfica
completa de todos los eventos se muestra en el capítulo siguiente:
Analicemos cada uno de los eventos mostrados en la figura 3.3.
50
Figura 3.3.Eventos al navegar
 Pre_Data:
51
Justo ANTES de entrar a un data nuevo, es decir cuando entramos en una forma nueva y se
navega al primer data navegable o cuando pasamos de un data a otro.
 Pre_Record:
Justo ANTES de entrar en un registro, ya sea porque entramos a una nueva forma y
navegamos a un registro de un data o porque pasamos de un registro a otro dentro del
mismo data o porque cambiamos de data, se dispara el evento Pre-Record. Si nos hemos
movido de un data a otro cuando se dispara este evento el data destino ya se ha
convertido en el data actual.
 When_new_data_instance:
DESPUES de entrar en un data nuevo se dispara el evento When_new_data_instance, es

decir cuando el data se ha convertido en el data actual de la forma.
 When_new_record _instance:
DESPUES de entrar en un registro se dispara el When_new_record_instance, es decir

cuando el registro se convirtió en el registro actual del Data.
NOTA IMPORTANTE:
Si mediante código (en eventos o métodos) se navega a diferentes datas, los eventos
when_new_data_instance y when_new_record_instance sólo se disparan para el
último data al que se navegó.
 When_validate_record:
Cuando se ha modificado algún elemento de un registro y nos intentamos mover hacia

otro registro ya sea en el mismo o en otro data se dispara el evento when_validate_record.
Durante la ejecución de este evento se mantiene el registro actual, es decir el registro
destino (al que se está intentando navegar) aún no se ha convertido en el registro actual.
 Post_record:
52
Antes de salir del registro y moverse hacia otro registro en el mismo o en otro data, se
dispara el evento Post_record. Es decir el registro destino aún NO se ha convertido en el
registro actual. Si en el evento se hace una referencia de la forma :data.field se está
haciendo referencia a un field del data del registro del cual se intenta salir.
 Post_Data:
Antes de moverse hacia otro data, se dispara el evento Post_data, es decir, cuando el data
destino aún NO se ha convertido en el data actual.
3.1.2.2. Eventos al interactuar con las fuentes de datos:
3.1.2.2.1. Eventos al efectuar una consulta:
Cuando ejecutamos una consulta sobre un data basado en una fuente de datos de la base de
datos se ejecutan eventos que nos pueden ser útiles para buscar información complementaria
o para modificar los patrones de búsqueda de la consulta. La figura 3.4 muestra en recuadros
verdes los eventos que se ejecutan al realizar una consulta.
53
Figura 3.4. Eventos al consultar
 Pre_Query:
Este es el primer evento que se dispara cuando hacemos uso del built-in execute_query.
Este evento durante su ejecución coloca la forma en modo Enter_Query lo que permite al
programador introducir nuevos criterios de búsqueda y de esta forma obtener un
resultado más preciso y/o confiable.
 Post_Select:
Este evento se dispara luego de que JForms construye la sentencia SQL y la ha enviado a la
base de datos, pero aún no ha empezado a llenar el data con los registros traídos por dicha
54
consulta. Este evento nos puede servir para obtener la sentencia SQL enviada a la base de
datos y almacenarla para algún uso futuro.
 Post_Query:
Este evento se dispara para cada registro que es traído por la consulta. Este evento es útil
cuando queremos efectuar operaciones sobre cada uno de los registros traídos por la
consulta.
Al terminar la consulta y ubicarse en el primer registro se disparan los eventos de

navegación correspondiente por el cambio de registro discutidos en el capítulo anterior.
3.1.2.2.2. Eventos al llamar al built-in “ Post” o “Commit”:
El built-in “Post” tiene la función de descargar en la base de datos las operaciones realizadas
sobre los registros de un data, pero NO efectúa la confirmación de esas operaciones (No
efectúa un Commit). En otras palabras, el método Post es el encargado de efectuar las
sentencias SQL correspondientes para enviar los cambios en los registros de los datas a la
base de datos sin hacer Commit.
El built-in “Commit” hace un llamado al built-in “Post” y luego confirma la transacción en la

base de datos.
55
Figura 3.5.Eventos al ejecutar un Post
 Pre_Commit:
Antes de empezar a realizar operaciones sobre los registros del data, JForms ejecuta el
evento Pre-Commit. Este evento se ejecuta una única vez independiente del número de
registros que tenga el data.
El bult-in “Post” recorre todos los registros de todos los datas y dependiendo del estado
del registro, realiza un borrado, una actualización, una inserción o simplemente no ejecuta
ninguna acción.
Cuando la operación a realizar es un borrado se ejecutan los siguientes eventos.
 Pre_Delete:
56
Se ejecuta justo antes de que JForms ejecute el comando para borrar el registro en la base
de datos.
 On_Delete:
Si se encuentra este evento implementado en la forma, JForms lanza este evento EN VEZ
DE efectuar el comando SQL de borrado por defecto sobre la base de datos.
 Post_Delete:
Se ejecuta luego de que se ha efectuado el comando SQL de borrado sobre la base de datos
o luego de haber llamado al evento On-Delete.
Cuando la operación a realizar es una inserción se ejecutan los siguientes eventos.
 Pre_Insert:
Se ejecuta justo antes de que JForms ejecute el comando para insertar el registro en la
base de datos.
 On_Insert:
DE efectuar el comando SQL de inserción por defecto sobre la base de datos.
 Post_Insert:
Se ejecuta luego de que se ha efectuado el comando SQL de inserción sobre la base de

datos o luego de haber llamado al evento On-Insert.
Cuando la operación a realizar es una actualización se ejecutan los siguientes eventos.
 Pre_Update:
Se ejecuta justo antes de que JForms ejecute el comando para actualizar el registro en la
base de datos.
57
 On_Update:
DE efectuar el comando SQL de actualización por defecto sobre la base de datos.
 Post_Update:
Se ejecuta luego de que se ha efectuado el comando SQL de actualización sobre la base de

datos o luego de haber llamado al evento On-Update.
 Post_Forms_Commit:
Una vez se han efectuado las operaciones respectivas sobre los registros del data y antes
de efectuar la confirmación de los datos se ejecuta el evento Post-Forms-Commit. Así
como el Pre-Commit, el evento Post_Forms_Commit se ejecuta una única vez.
58
Capitulo 4.
Examinando las propiedades y eventos de los Fields.
Después de crear datas, usted puede crear fields, los fields deben pertenecer a un data ya sea
de control o enlazado a datos, a sí mismo un field puede ser de control o estar enlazado a una
fuente de datos, Un data no es un contenedor físico de fields, es un contenedor lógico de fields.
Los fields pueden ser agregados y desplegados en un panel.
4.1. Propiedades:
 Automatic Skip:
Cuando esta propiedad esta en verdadero, se navega automáticamente hasta el siguiente
field cuando la longitud máxima del field es alcanzada. Esta propiedad aplica solamente
para fields del tipo text.
 Background:
Esta propiedad nos permite asignar un color de fondo a un Field, haciendo doble Click sobre
la propiedad se nos desplegara un dialogo donde podemos seleccionar el color deseado
(Figura 4.1).
Figura 4.1
59
 Border:
Esta propiedad nos permite asignar un estilo de borde a un field, haciendo doble Click sobre
la propiedad se nos desplegara un dialogo donde podemos seleccionar el estilo de borde
deseado (Figura 4.2).
Figura 4.2
 Calculation mode:
Esta propiedad especifica el método de cálculo de un field cuyo valor es calculado, los
posibles valores son:
 None:
Indica que el field no es un field calculado.
 Formula:
Indica que el valor del field será calculado como resultado de una formula escrita por
el usurario.
 Summary:
60
Indica que el valor del Field será calculado como resultado de una operación de suma
sobre un Field, esta operación es asignada en la propiedad summary function.
 Case insensitive query:

Esta propiedad determina cuando el operador puede realizar consultas a la base de datos
no sensibles a mayúsculas y minúsculas.
 Case restriction:
Esta propiedad especifica si el texto escrito en un field del tipo text, será escrito en
mayúsculas o minúsculas o si simplemente aparecerá como se escribe. Los valores
posibles para esta propiedad son los siguientes:
 Normal:
Indica que el texto aparecerá como es digitado.
 Upper:
Indica que el texto siempre será convertido a mayúsculas sin importar como fue
digitado.
 Lower:
Indica que el texto siempre será convertido a minúsculas sin importar como fue
digitado.
 Column name:
Cuando el field es de base de datos, Esta propiedad nos sirve para indicar el nombre de la
columna de una tabla, vista, query o procedimiento almacenado en la base de datos
 Comments:
Esta propiedad nos sirve para mantener comentarios sobre el field. Nos puede servir para
objetivo del field.
 Component type:
Esta propiedad especifica el tipo de componente que puede ser un field. Un field puede
ser de uno de los siguientes tipos:
61
 DButton
 DCheckBox
 DChart
 DComboBox
 DImage
 DLabel
 DRadioButton
 DSound
 DTextField
 DTextArea
 DTree
 Copy value from field:

Esta propiedad especifica la fuente de la cual JFormsBuilder obtiene el valor del field.
 Cursor style:
Esta propiedad es utilizada para especificar el estilo del cursor del Mouse cuando el
usuario ingresa a un field.
 Data Base Field:
Esta propiedad esta en verdadero indica que el field esta enlazado a datos y que no es un
field de control. Cuando un field esta enlazado a datos el data que lo contiene igualmente
debe estar enlazado a datos.
 Data Type:
Esta propiedad es utilizada para indicar el tipo de dato de un field, los valores posibles
son:
 Java.lang.String
 Java.lang.Integer
 Java.lang.Double
 Java.sql.Date
 Java.util.Date
62
 Date Type:
Esta propiedad es utilizada cuando el tipo de dato de un field es java.sql.Date, se utiliza para
indicar la forma como se almacena la fecha es decir si guarda hora minutos y segundos, si
guarda día, mes, año o si guarda todos estos datos.
Los posibles valores son:
 Date:
Únicamente guarda días, meses y años no guarda horas minutos y segundos.
 DateTime:
Guarda días, meses, años, horas, minutos y segundos.
 Time:
Únicamente guarda horas, minutos y segundos no guarda días, meses y años.
 Distance bewtween records:

Esta propiedad especifica la cantidad de espacio entre fields en un data multi-record. Un
data multi-record es un data que contiene un número mayor que 1 en la propiedad
number of records displayed.
 Echo char:
Esta propiedad se utiliza para ocultar los caracteres que el usuario digita en un field de
tipo texto. Normalmente es usado para protección de contraseñas.
 Editable:
Esta propiedad indica que el contenido de un field de tipo text no se puede editar, es
usado cuando solo queremos mostrar datos y no permitir que el usuario modifique los
datos.
 Enable:
Si el valor de esta propiedad es falso significa que no se podrá navegar hasta ese field y su
contenido no será modificable por el usuario final.
63
 Field Font:
Esta propiedad nos permite asignar una fuente, su estilo y tamaño a un field, haciendo
doble Click sobre la propiedad se nos desplegara un dialogo donde podemos seleccionar la
fuente, el estilo y tamaño deseado (Figura 4.3).
Figura 4.3
 Foreground:
Esta propiedad nos permite asignar un color de fuente a un Field, haciendo doble Click
sobre la propiedad se nos desplegara un dialogo donde podemos seleccionar el color
64
Figura 4.4
 Format Mask:
Esta propiedad nos permite especificar un formato de mascara para visualización y
digitación de datos en fields de tipo texto.
 Formula:
Esta propiedad es utilizada para indicar una expresión (Formula) sql que determina el
valor de un field.
 Height:
Esta propiedad nos sirve para especificar la altura de un field, la unidad de medida es el
píxel.
 Horizontal Alignment:
Esta propiedad sirve para indicar la alineación horizontal de un texto, los posibles valores
son:
 Alg_Left :
Alineación a la izquierda
 Alg_center:
Alineación al centro
 Alg_right:
Alineación a la derecha
 Help List Name:

Esta propiedad especifica el nombre de una lista de valores asociada a un field.
 Initial Value:
Especifica un valor por defecto que es asignado al field cuando un nuevo registro es
creado.
 Is Version:
Esta propiedad indica si el campo es utilizado para manejar la concurrencia, cuando se
consulta un registro de la base de datos este campo tiene un valor, si se desea actualizar
este campo se compara el valor que tiene el campo con el de la base de datos si son iguales
65
entonces se puede realizar la actualización en caso contrario no puede ejecutarse la

operación.
 Insert Allowed:
Determina cuando un usuario puede modificar el valor un field en un registro nuevo. Un
registro es nuevo cuando su estado es INSERT o NEW.
 Java Name:
Esta propiedad muestra el nombre que va a tener el archivo en el codigo fuente java.
 Keyboard navigable:
Si el valor de esta propiedad es false para un field no se puede navegar hasta este con la
navegación normal por teclado.
 Max size:
Esta propiedad es utilizada para controlar el número de caracteres que se pueden digitar
en un field de tipo texto.
 Name:
Esta propiedad es utilizada para especificar el nombre de un field, este nombre debe ser
único en el data que lo contiene. Es decir que puede haber un field con el mismo nombre
pero en otro data.
 Next Navigation Field:

Esta propiedad define el nombre del siguiente field navegable con respecto a este field,
Por defecto el siguiente field al cual se navega es el field navegable con la secuencia mas
alta que el field actual, este orden se puede cambiar colocando la propiedad next
navigation field.

Esta propiedad especifica el número máximo de registros que un data puede desplegar al
mismo tiempo, el número por defecto es 1, si este valor es mayor que 1 entonces
tendremos un data multiregistro.
 Panel container:
Especifica el panel en el cual el field será visualizado.
66
 Previous navigation field:

Esta propiedad define el nombre del anterior field navegable con respecto a este field, por
defecto el anterior field al cual se navega es el field navegable con la secuencia mas baja
que el field actual, este orden se puede cambiar colocando la propiedad previous
navigation field.
 Primary key:
Indica que el field pertenece aun data basado en una tabla de la base de datos y que hace
parte de la llave primaria de la tabla.
 Prompt:
Especifica el texto del label que será visualizada para este field.
 Prompt Background:
Específica el color de fondo del prompt, para que este color de fondo sea visible la
propiedad prompt opaque debe estar en verdadero.
 Prompt display style:

Especifica la forma como se visualizara el prompt, los posibles valores son:
 Hidden:
El prompt no será visualizado para este field.
 FirstRecord:
El prompt se desplegara solamente para el primer registro en un data multiregistro.
 AllRecords:
El prompt se desplegara para todos los registros en un data multiregistro.
 Prompt distance x:
Especifica la distancia en x desde el prompt hasta el field.
 Prompt distance y:
Especifica la distancia en y desde el prompt hasta el field.
 Prompt font:
67
Esta propiedad nos permite asignar una fuente, su estilo y tamaño a un prompt.
 Prompt foreground:
Esta propiedad nos permite asignar un color de fuente a un prompt.
 Prompt position:
Especifica como es alineado el prompt con respecto al field. Los posibles valores son:
 Top
 Left
 Right
 Bottom
 Prompt opaque:
Especifica si se visualiza el background del prompt o si este es transparente, si el valor de
esta propiedad es verdadero significa que el prompt no será transparente.
 Query allowed:
Indica si el field puede ser incluido en una consulta que se envié a la base de datos.
 Query only:
Indica que un field puede ser consultado y que no podrá ser incluido en ninguna sentencia
de inserción o actualización.
 Required:
Cuando el valor de esta propiedad es verdadero, indica que no se podrá salir de un
registro modificado o insertado sin antes colocar un valor en el field.
 Synchronize with field:

Especifica el nombre del field con el cual el field actual debe compartir su valor, es decir
que el valor de los dos fields estará sincronizado, en otras palabras si el valor de uno de
los fields cambia el valor del otro field cambiara automáticamente.
 Summarized data:
Especifica el nombre del data que contiene el field al cual se le aplicara una función para
calcular el valor para el field actual.
68
 Summarized field:
Especifica el nombre del field al cual se le aplicara una función para calcular el valor para
el field actual.
 Summary function:
Especifica el tipo de función que se aplicara al field asignado en la propiedad summarized
field, los valores para la función especificada serán obtenidos de todos los registros que
tenga su data contenedor, el resultado de aplicar la función será el valor de un field
calculado.
Las posibles funciones que se pueden aplicar son:
 Avg:
El valor calculado será el promedio aritmético.
 Count:
El valor calculado será el número de registros que contiene el data.
 Max:
El valor calculado será el valor máximo entre todos los valores.
 Min:
El valor calculado será el valor mínimo entre todos los valores.
 Sum:
El valor calculado será la suma de todos los valores.
 Tooltip:
Especifica el texto que aparecerá cuando el cursor del Mouse se posicione sobre el field.
 Update allowed:
Determina cuando el usuario puede modificar el valor de un field en un registro que ha
sido consultado.
 Update only if null:
69
Indica que el usuario puede modificar el valor del field solo si este es null.
 Validate on list:
Especifica cuando el valor digitado debe ser validado contra la lista de ayuda asociada a
este field.
 Visible:
Especifica si un field estará o no visible para el usuario final.
 Width:
Especifica el ancho de un field, el sistema de medidas utilizado es el píxel.
 X:
Especifica la posición x de un field, el sistema de medidas utilizado es el píxel.
 Y:
Especifica la posición y de un field, el sistema de medidas utilizado es el píxel.
4.1.1. Propiedades dependiendo del tipo de componente:

Existen algunas propiedades para los fields que no son comunes, estas propiedades varían de
acuerdo al tipo de componente.
 DCheckBox:
 CheckedValue:
Esta propiedad es utilizada para asignar el valor que tendrá el field cuando el checkbox
es chequeado.
 UncheckedValue:
Esta propiedad es utilizada para asignar el valor que tendrá el field cuando el checkbox
no está chequeado.
 Check box mapping of other values:
70
Esta propiedad es utilizada para indicar el estado que tomara el check box en caso de
que el valor del field no corresponda al valor de chequeo o valor de no chequeo.
 DComboBox:
 Combobox Values:
Esta propiedad es utilizada para almacenar los valores que contendrá la lista de
despliegue, para agregar o remover valores de la lista hacemos doble clic sobre la
ventana y nos desplegara un dialogo donde podremos modificar los valores (Figura
4.5).
Figura 4.5
 Mapping of other values:
Esta propiedad es utilizada para indicar el valor que estará seleccionado en el combo,
en caso de que el valor del field no corresponda a ninguno de los valores del combo.
 DLabel:
 Opaque:
71
Especifica si el se visualizara el color de fondo del label o si este será transparente, si el

valor de esta propiedad es verdadero significa que se visualizar el color de fondo del
label.
 DRadioButton:
 Mapping of other values:
Esta propiedad es utilizada para indicar el radio que estará seleccionado en el grupo
de radios, en caso de que el valor del field no corresponda a ninguno de los valores del
grupo de radio.
 Opaque:
Especifica si el se visualizara el color de fondo de los radios o si estos serán

transparentes, si el valor de esta propiedad es verdadero significa que se visualizar el
color de fondo de los radios.
4.1.2 Propiedades De los RadioButtons:
 Background:
Esta propiedad nos permite asignar un color de fondo a un radio button.
 Border:
Esta propiedad nos permite asignar un estilo de borde a un radiobutton.
 Comments:
Esta propiedad nos sirve para mantener comentarios sobre el un radiobutton. Nos puede
servir para controlar fechas y autores de las diferentes modificaciones, así como para
documentar el objetivo del radiobutton.
 Distance between records:

Esta propiedad especifica la cantidad de espacio entre radiobuttons en un data multi-
record. Un data multi-record es un data que contiene un numero mayor que 1 en la
propiedad number of records displayed.
72
 Enable:
Si el valor de esta propiedad es falso significa que no se podrá navegar hasta este
radiobutton y su contenido no será modificable por el usuario final.
 Font:
Esta propiedad nos permite asignar una fuente, su estilo y tamaño a un field,
 Foreground:
Esta propiedad nos permite asignar un color de fuente a un radiobutton.
 Height:
Esta propiedad nos sirve para especificar la altura de un radiobutton, la unidad de medida
utilizada es el píxel.
 Label:
Esta propiedad es utilizada para especificar el texto que desplegara el radiobutton.
 Name:
Esta propiedad es utilizada para especificar el nombre de un radiobutton, este nombre
debe ser único en el field.
 Opaque:
Especifica si el se visualizara el color de fondo de un radiobutton o si este será
transparente, si el valor de esta propiedad es verdadero significa que se visualizara el
color de fondo del radio.
 Prompt:
Especifica el texto del label que será visualizada para este radiobutton.
 Prompt Background:
Específica el color de fondo del prompt, para que este color de fondo sea visible la
propiedad prompt opaque debe estar en verdadero.
 Prompt display style:

Especifica la forma como se visualizara el prompt, los posibles valores son:
 Hidden: El prompt no será visualizado para este radiobutton.
73
 FirstRecord: El prompt se desplegara solamente para el primer registro en un data

multiregistro.
 AllRecords: El prompt se desplegara para todos los registros en un data multiregistro.
 Prompt distance x:
Especifica la distancia en x desde el prompt hasta el radiobutton.
 Prompt distance y:
Especifica la distancia en y desde el prompt hasta el radiobutton.
 Prompt font:
Esta propiedad nos permite asignar una fuente, su estilo y tamaño a un prompt.
 Prompt foreground:
Esta propiedad nos permite asignar un color de fuente a un prompt.
 Prompt position:
Especifica como es alineado el prompt con respecto al field. Los posibles valores son:
 Top
 Left
 Right
 Bottom
 Prompt opaque:
Especifica si se visualiza el background del prompt o si este es transparente, si el valor de
esta propiedad es verdadero significa que el prompt no será transparente.
 Radio button value:

Esta propiedad nos permite asignar el valor a un radiobutton, cuando se selecciona un
radiobutton el valor que toma el field es el valor que tiene el radio en esta propiedad.
 Tooltip:
Especifica el texto que aparecerá cuando el cursor del Mouse se posicione sobre el
radiobutton.
74
 Visible:
Especifica si un radiobutton estará visible para el usuario final.
 Width:
Especifica el ancho de un radiobutton, el sistema de medidas utilizado es el píxel.
 X:
Especifica la posición x de un radiobutton, el sistema de medidas utilizado es el píxel.
 Y:
Especifica la posición y de un radiobutton, el sistema de medidas utilizado es el píxel.
4.2. Eventos:
Los eventos que analizaremos en este capítulo son aquellos a los que se puede responder a
nivel de field, data o forma.
4.1.1. Eventos al navegar:
La figura 4.6. Muestra el flujo de eventos que se disparan a nivel de field al entrar a un data
después de iniciar la forma, al navegar de un field a otro field en un mismo data, al navegar de
un field a otro field en otro registro y al navegar de un field a otro field en un data diferente.
75
Figura 4.6
 Pre_Text_Field:
Este evento se ejecuta antes de entrar a un field, este evento puede ser utilizado para asignar
valores iniciales a un field, guardar el valor actual del field en una variable global para hacer
una comparación con el valor que se digito, en fin este evento puede ser utilizado para ejecutar
muchas acciones.
 When_New_Field_Instances:
Este evento se ejecuta después de navegar a un field, ya sea cambiando de data, de registro o
simplemente cambiando de field. Este evento al igual que los demás Eventos “when-new” se
dispara al final del proceso de ejecución de todos los eventos.
76
 Post_Text_Field:
Este evento se ejecuta cuando se está cambiando de un field a otro, ya sea cambiando de data,
registro o simplemente cambiando de field.
 Post_Change:
Este es uno de los eventos del proceso de validación de un field, este evento puede ocurrir
dadas las siguientes circunstancias:
 Que el proceso de validación determine que el field está marcado como cambiado y es
no nulo.
 El usuario retorna un valor seleccionado de una lista de ayuda y el valor no es nulo.
 Cuando realizamos una consulta, al momento de llenar los registros con la
información de la base de datos, el evento se ejecuta para todos los fields que tengan
asociado el evento y el valor obtenido de la base de datos es diferente de nulo.
 When_validate_field:
Este es uno de los eventos del proceso de validación de un field, este evento puede ocurrir
dadas las siguientes circunstancias:
 Que el proceso de validación determine que el field esta marcado como cambiado, en
este evento a diferencia del post-change no se tiene en cuenta si el valor del field es
nulo para ejecutarse.
 El usuario retorna un valor seleccionado de una lista de ayuda.
 Cuando realizamos una consulta, al momento de llenar los registros con la
información de la base de datos, el evento se ejecuta para todos los fields que tengan
asociado el evento y el valor obtenido de la base de datos es nulo.
77
Capitulo 5
Examinando las propiedades y eventos de los Paneles
Cuando construimos una forma, usamos Paneles para mostrarle al usuario final los elementos
visuales (campos de texto, imágenes, etc.). Una forma sencilla puede contener cualquier
cantidad de Paneles.
5.1. Tipos de Paneles:
JFormsBuilder provee cuatro tipos de Paneles. Un tipo de Panel define como

JFormsBuilder lo mostrara en el Frame al que está asignado. Al momento de adicional un
Panel nuevo a nuestra forma podemos elegir de qué tipo será:
Figura 4.1 Tipos de Paneles
Los tipos de Paneles son:
 Principal (Principal)
 Pestañas (Tabbed)
 Apilado (Stacked)
78
 Grilla (Grid)
 Barra de herramientas (Toolbar)
5.2. Propiedades comunes a todos los tipos de Paneles:
 Border :
Esta propiedad nos permite asignar un estilo de borde a un panel, haciendo doble Clic
sobre la propiedad se nos desplegara un dialogo donde podemos seleccionar el estilo de
borde deseado (Figura 4.2).
Figura 4.2 – Border
 Color:
Esta propiedad nos permite asignar un color de fondo a un Panel, haciendo doble Clic
sobre la propiedad se nos desplegara un dialogo donde podemos seleccionar el color
79
 Figura 4.3 – Color
 Comments:
Esta propiedad nos sirve para mantener comentarios sobre un panel. Nos puede servir
para controlar fechas y autores de las diferentes modificaciones, así como para
documentar el objetivo del Panel
 Frame Container:
Indica en que Frame va a desplegarse el panel seleccionado, pueden añadirse varios
paneles de diferentes tipos al mismo frame
 Height:
Esta propiedad especifica la altura de un panel, la unidad de medida es el píxel
 Java name:
Esta propiedad muestra el nombre que va a tener el panel en el codigo fuente java
 Name:
Esta propiedad es utilizada para especificar el nombre de un panel, este nombre debe
ser único
 SubClass information:
Esta propiedad la utilizamos asignarle o saber a qué elemento se encuentra asociado
el Panel. Con esta propiedad podemos decirle al panel que tome todas las propiedades
de un elemento creado en la forma o lo pueda tomar desde otro archivo creado con
JFormsBuilder. Para mayor información véase el capítulo de reutilización de código.
80
 Tooltip:
Especifica el texto que aparecerá cuando el cursor del Mouse se posicione sobre un
panel.
 Width:
Esta propiedad especifica el ancho de un panel, la unidad de medida es el pixel.
 X:
Especifica la posición con repecto al eje x en el cual estara ubicado el panel
 Y:
Especifica la posición con repecto al eje y en el cual estara ubicado el panel
5.3. Propiedades específicas para cada tipo de Panel:

5.3.1. Panel Principal:
Es el más común tipo de Panel (tipo por defecto). Un Panel principal es la ‘base’ que ocupa
todo el contenido del Frame en el cual es mostrado. Se debe definir un al menos Panel
principal para cada forma creada.
Este panel no tiene propiedades específicas.
5.3.2. Panel apilado:

Un Panel apilado es un panel que está colocado encima de un Panel principal el cual está
asociado al Frame. Los Paneles apilados oscurecen alguna parte del Panel principal y
generalmente estos se ocultan y se muestran mediante programación. Se pueden mostrar
más de un Panel apilado en un Frame al mismo tiempo.
Propiedades:
 Is toolbar:
Propiedad que indica si el panel es una barra de herramientas, sus opciones son false y
true. (Mas información, Paneles de Barra de herramientas)
 Panel type:
Esta propiedad especifica el tipo de panel, las opciones son: Principal (Principal),
Stacked (Apilado), Grid () y Tabbed (Pestañas)
 Show horizontal scrollbar / vertical scrollbar:
81
Esta propiedad nos permite establecer si deseamos mostrar una barra de

desplazamiento horizontal o vertical en caso tal de que el tamaño del panel sea mayor
al tamaño del frame que lo contiene. Sus opciones son False: no se muestra y True: se
muestra
 View port height / width:
Alto y ancho de la vista del panel apilado (Parte visible del panel apilado). Si la vista es
más pequeña que el tamaño del panel se puede recorrer mediante las barras de
desplazamiento (Hay que colocar las propiedades Show horizontal scrollbar y show
vertical scrollbar en true, dependiendo de que barra de desplazamiento se quiere
utilizar).
 Visible:
Establece si el panel va a mostrarse o no en tiempo de ejecución, sus opciones son
False: no muestra el panel en ejecución y True (Por defecto): el panel es visible en
tiempo de ejecución
5.3.3. Panel Tipo Pestañas:
Un Panel de pestañas, compuestas por una o más paginas de pestañas, te permite agrupar
gran cantidad de información relacionada en un solo objeto dinámico de JFormsBuilder.
Así como los Paneles apilados, los Paneles de pestañas se ubican sobre un Panel principal
ocultándolos un poco. Las páginas de pestañas muestran un subconjunto de información
del Panel de pestañas.
Propiedades:
 Panel type:
muestra
 Tab layout:
82
Esta propiedad establece la forma en la cual se mostraran las paginas de pestañas en

caso tal de que hayan muchas paginas de pestañas y estas no alcancen a mostrarse
debido al ancho del panel de pestañas. Las opciones son: Scroll layout (Por defecto):
Muestra una pequeña barra de desplazamiento que nos permite acceder a las pestañas
no visibles. Wrap layout: Muestra todas las pestañas visibles acomodándolas en filas
dependiendo del ancho del panel de pestañas.
 Tab placement:
Establece en que parte del panel de pestañas van a mostrarse las páginas de pestañas,
las opciones son Top (Por defecto): Muestra las páginas de pestañas en la parte de
arriba del panel de pestañas, Botton: Muestra las páginas de pestañas en la parte de
abajo del panel de pestañas, Left: Muestra las páginas de pestañas en la parte lateral
izquierda del panel de pestañas, Right: Muestra las páginas de pestañas en la parte
lateral derecha del panel de pestañas.
Alto y ancho de la vista del panel apilado (Parte visible del panel apilado). Si la vista es
más pequeña que el tamaño del panel se puede recorrer mediante las barras de
desplazamiento (Hay que colocar las propiedades Show horizontal scrollbar y show
vertical scrollbar en true, dependiendo de qué barra de desplazamiento se quiere
utilizar).
 Visible:
tiempo de ejecución
5.3.4. Páginas de pestañas:
Cada Panel de pestañas puede tener muchas páginas de pestañas, y debe tener por lo
menos una. Pensar en páginas de pestañas es como pensar en carpetas en un disco duro.
Cada página de pestaña individual (carpetas) tiene una etiqueta para que los
desarrolladores y usuarios finales hagan clic y accedan a la pestaña.
83
Cada página de pestañas ocupa el mismo espacio en el Panel de pestañas,

aproximadamente igual al tamaño del Panel de pestañas. Este conjunto de páginas de
pestañas te permiten mostrar más información en un solo Panel de pestañas.
Las páginas de pestañas son sub objetos de un Panel de pestañas. Como al Panel al que
están asignados, las páginas de pestañas tiene sus propiedades; de manera similar,
cualquier elemento que coloques en una página de pestañas tiene propiedades de Panel
como propiedades de pagina de pestañas. El orden de las páginas de pestañas que
coloques en el diseñador grafico será el orden que tendrán las pestañas en ejecución.
Propiedades:
 Enable:
Esta propiedad establece si la pagina de pestaña estara habilitada o no en tiempo de
ejecucion.
 Label:
Titulo de la pagina de pestaña, la cual utilizamos para identificarla en tiempo de
ejecucion.
 Visible:
Establece si la pagina de pestana va a mostrarse o no en tiempo de ejecución, sus
opciones son False: no muestra la pagina de pestaña en ejecución y True (Por defecto):
el panel es visible en tiempo de ejecución.
5.3.5. Panel Barra de Herramientas
Un Panel de barra de herramientas generalmente es usado para crear barras de

herramientas en diferentes Frames. Se pueden crear dos tipos de Paneles de barras de
herramientas: horizontal y vertical. Paneles de barras de herramientas horizontales son
mostrados en la parte superior del Frame, justo debajo de la barra de menús, mientras
que las verticales se sitúan a lo largo del borde izquierdo del Frame.
Propiedades:
 Is toolbar:
84
Propiedad que indica si el panel es una barra de herramientas, sus opciones son False:
indica que el panel no es de tipo barra de herramientas y puede ser de cualquiera de
los otros tipos de paneles, automáticamente las propiedades de este panel se
modifican como si se tratara de un panel de tipo apilado. True: indica que el panel es
de tipo barra de herramientas y despliega una nueva propiedad llamada Position
type (Definida a continuación)
 Position type:
Define la orientación de la barra de herramientas al ser mostrada en tiempo de
ejecución. Sus opciones son Vertical y Horizontal.
5.3.6. Panel Tipo Grilla

Un Panel de grilla es un panel multi registro que posee la propiedad al visualizarse en
Ajax/GWT puede ordenar el panel multi registro de manera ascendente o descendente de
acuerdo a la columna seleccionada
Propiedades:
 Data name:
Nombre del data que está asociado al Panel tipo Grilla
 Edit:
Permite editar las columnas que aparecerán en el panel.
 Header background:
Color de fondo que aparecerá en el encabezado del panel tipo grilla
 Header font:
Tipo de fuente que aparecerá en el encabezado del panel tipo grilla
 Header foreground:
Color de letra que aparecerá en el encabezado del panel tipo grilla
 Header height:
Alto del encabezado que aparecerá en el encabezado del panel tipo grilla
 Image path:
Ruta de la imagen que aparecerá en el encabezado del panel. Esta imagen se
redimensionará dependiendo el alto del encabezado.
 Is toolbar:
85
Propiedad que indica si el panel es una barra de herramientas, sus opciones son false y
true. (Mas información, Paneles de Barra de herramientas)
 Panel type:
 Records height:
Esta propiedad establece el alto de los registros que son visualizados en el panel.
muestra
 Title:
Titulo que se mostrara en el encabezado del panel tipo grilla
Alto y ancho de la vista del panel tipo grilla. Si la vista es más pequeña que el tamaño
del panel se puede recorrer mediante las barras de desplazamiento (Hay que colocar
las propiedades Show horizontal scrollbar y show vertical scrollbar en true,
dependiendo de qué barra de desplazamiento se quiere utilizar).
 Visible:
tiempo de ejecución.
86
Capitulo 6
Examinando las propiedades y eventos de los Object Graphics
Los objetos gráficos son elementos que nos permiten dibujar todo tipo de figuras en nuestras
formas, como complemento al diseño que hayamos establecido, son una ayuda visual a las
formas generadas en JFormsBuilder.
6.1. Tipos de Object Graphics
JFormsBuilder nos permite trabajar con 7 objetos gráficos, los cuales son:
 DFrame
 Elipse
 Image
 Line
 Rectangle
 RoundedRectangle
 TextGraphic
6.2. Propiedades comunes a los Object Graphics.
 Comments:
Esta propiedad nos sirve para mantener comentarios sobre un panel. Nos puede servir
para controlar fechas y autores de las diferentes modificaciones, así como para
documentar el objetivo del Panel.
 Graphic type:
Especifica el tipo de objeto grafico esta seleccionado.
 Java name:
87
Esta propiedad muestra el nombre que va a tener el objeto grafico en el codigo fuente
java
 Name:
Esta propiedad es utilizada para especificar el nombre de un panel, este nombre debe
ser único
Esta propiedad la utilizamos asignarle o saber a qué elemento se encuentra asociado
el objeto grafico. Con esta propiedad podemos decirle al objeto grafico que tome todas
las propiedades de un elemento creado en la forma o lo pueda tomar desde otro
archivo creado con JFormsBuilder. Para mayor información véase el capítulo de
reutilización de código.
 X:
Especifica la posición con repecto al eje x en el cual estara ubicado el panel
 Y:
Especifica la posición con repecto al eje y en el cual estara ubicado el panel
6.3. Propiedades específicas a los diferentes Object Graphics.
6.3.1. DFrame.
Un DFrame es un objeto grafico que se utiliza para agrupar otros objetos, que pueden ser
objetos gráficos o no.
Propiedades
 Bevel:
Establece el tipo de bisel que tendra el DFrame, puede ser Normal: no tiene ningun
bisel, Raised: el bisel esta enfocado hacia el exterior y Lowered: el bisel esta enfocado
hacia el interior.
 Border Color:
Color del borde del DFrame
 Fill Color:
Color de relleno del Dframe.
 Height:
Altura del DFrame, esta unidad de medida es en pixeles.
88
 Fill:
Indica si el objeto debe tener el color de relleno establecido en la propiedad Fill color,
sus opciones son False (por defecto): El color de relleno del objeto es blanco, o True: El
objeto grafico toma el color de relleno establecido en la propiedad Fill color.
 Title:
Titulo que lleva el DFrame. Este titulo permite identificar a que grupo pertenecen los
objetos que estan dentro de el.
 Title font:
Tipo de fuente del Titulo.
 Title foreground:
Color de letra del titulo
 Title offset:
Distancia desde el inicio del DFrame hasta el titulo. Los valores pueden ser positivos o
negativos, su unidad de medida son los pixeles.
 Title position:
Posicion del titulo en el DFrame, sus valores son Left ( Por defecto): Titulo ubicado a la
izquierda del DFrame, Center: Titulo ubicado al centro del DFrame y Right: Titulo
ubicado a la derecha del DFrame
 Width:
Ancho del DFrame, esta unidad de medida es en pixeles.
6.3.2. Ellipse.
Este objeto es semejante a un círculo, pero un poco más angosto.
Propiedades
 Border Color:
Color del borde de una Elipse
 Fill Color:
Color de relleno de una Elipse.
 Fill:
89
 Height:
Altura del Elipse, esta unidad de medida es en pixeles.
 Line Width:
Ancho de la linea exterior del Elipse
 Width:
Ancho del Elipse, esta unidad de medida es en pixeles.
6.3.3. Image
Este objeto grafico permite almacenar una imagen seleccionada para incluirla dentro de
nuestras aplicaciones.
Propiedades
 Bevel:
Establece el tipo de bisel que tendrá el Image, puede ser Normal: no tiene ningun bisel,
Raised: el bisel esta enfocado hacia el exterior y Lowered: el bisel esta enfocado hacia
el interior.
 Border Color:
Color del borde del Image.
 Height:
Altura del Image, esta unidad de medida es en pixeles.
 Image path:
Ruta donde esta ubicada la imagen.
 Line Width:
Ancho de la línea exterior del Image
 Width:
Ancho del Image, esta unidad de medida es en pixeles.
90
6.3.4. Line
Este objeto dibuja una línea en nuestras formas, dependiendo del ancho y el alto, así
nuestra línea tendrá su inclinación.
Propiedades
 Border Color:
Color del borde de una Line
 Height:
Altura del Line, esta unidad de medida es en pixeles.
 Line Width:
Ancho de la linea del Line
 Width:
Ancho del Line, esta unidad de medida es en pixeles.
6.3.5. Rectangle
Este objeto grafico es una figura geométrica de cuatro lados, semejante a un cuadrado,
pero dos de sus lados paralelos son las largos que sus otros dos.
Propiedades
 Bevel:
Establece el tipo de bisel que tendra el Rectangle, puede ser Normal: no tiene ningun
bisel, Raised: el bisel esta enfocado hacia el exterior y Lowered: el bisel esta enfocado
hacia el interior.
 Border Color:
Color del borde de un Rectangle
 Fill Color:
Color de relleno de un Rectangle
 Fill:
91
 Height:
Altura del Rectangle, esta unidad de medida es en pixeles.
 Line Width:
Ancho de la linea del Rectangle
 Width:
Ancho del rectángulo, esta unidad de medida es en pixeles.
6.3.6. Rounded Rectangle
Este objeto es muy parecido al Rectangle, solo que este posee las esquinas redondeadas.
Propiedades
 Border Color:
Color del borde de un RoundedRectangle
 Fill:
 Fill Color:
Color de relleno de un RoundedRectangle
 Height:
Altura del RoundedRectangle, esta unidad de medida es en pixeles.
 Line Width:
Ancho de la linea del RoundedRectangle
 X corner radious:
Establece el angulo con respecto al eje X
 Y corner radious:
Establece el angulo con respecto al eje Y
 Width:
92
Ancho del RoundedRectangle, esta unidad de medida es en pixeles.
6.3.7. Text Graphic
Este objeto grafico nos permite escribir texto y poder tomar ese texto que escribrimos
como si se tratara de una imagen.
Propiedades
 Background:
Establece el color de fondo del Text_graphic
 Foreground:
Establece el color de texto del Text_graphic
 Font:
Establece la fuente a utilizar en el Text_graphic.
 Horizontal alignment:
Establece el alineamiento del texto dentro del text_graphic, las opciones son Alg_left
(Por defecto): aliena el texto a la izquiera, Alg_Center: alinea el texto en el centro y
Alg_Right: alinea el texto a la derecha
 Fill:
Indica si el objeto debe tener el color de relleno establecido en la propiedad
Background, sus opciones son False (por defecto): El color de relleno del objeto es
blanco, o True: El objeto grafico toma el color de relleno establecido en la propiedad
Fill color.
 Label:
Nombre del texto que se visualiza en el text_graphic
93
Capitulo 7
Examinando las propiedades y eventos de los SQLStatements
Una Sentencia SQL es una estructura de datos con una vista de columnas/filas similar a una
tabla de una base de datos. Sin embargo, a diferencia de una tabla, las Sentencias SQL son
objetos independientes que pertenecen a una forma en la cual fueron definidas. Las
Sentencias SQL no están diseñadas para ser un remplazo de las tablas de bases de datos
mientras que la aplicación se encuentra en ejecución. Son óptimas al momento de buscar
algún valor en listas relativamente pequeñas o para estructuras de datos de tamaño mediano
en aplicaciones que guardan registros en cliente/servidor.
Sin embargo, una Sentencia SQL puede ser construida dinámicamente en tiempo de ejecución,
mientras que la estructura de las Sentencias SQL es determinada en el Editor de Diseño.
Mediante programación en código PL/SQL, Listas de Ayuda pueden ser usadas cuando la
funcionalidad de un arreglo de dos dimensiones con múltiples datos es requerida. Una
Sentencia SQL puede tener un número ilimitado de columnas de tipo numérico, cadena de
caracteres o de tipo dato.
Las Sentencias SQL basadas en una consulta SELECT pueden almacenar registros de una tabla
o varias tablas de una base de datos de forma parecida a una vista de base de datos, con la
ventaja que la Sentencia SQL es nativa de JFormsBuilder en vez de existir en la base de datos.
A demás, la consulta SELECT usada para crear y llenar una Sentencia SQL puede ser
construida dinámicamente en tiempo de ejecución.
7.1. Tipos de SQLStatement.
Existen dos tipos de Sentencias SQL, basadas en una consulta SELECT o en Sentencias SQL con
valores estáticos.
94
 Sentencias SQL basada en consulta SELECT. Es una Sentencia SQL la cual tiene
asociada una consulta SELECT. Las columnas en una Sentencia SQL basada en una
consulta toma los nombres por defecto, tipos y longitud de datos de las tablas de la
base de datos referenciadas en la sentencia SELECT. Los registros de una Sentencia
SQL son los registros traídos de la base de datos mediante la consulta SELECT
asociada a esta.
Las Sentencias SQL basadas en consulta SELECT pueden ser creadas y modificadas
mediante el asistente o en tiempo de ejecución.
 Sentencias SQL Estáticas. Una Sentencia SQL Estática es aquella que no contiene una
consulta asociada a ella, en cambio, se definen las filas y los valores de los registros en
el Diseñador Grafico y estas se mantienen en ejecución.
Las Sentencias SQL Estáticas solo pueden ser creadas y modificadas en el Diseñador
Grafico.
Podemos especificar qué tipo de Sentencia SQL queremos crear mediante el asistente
en el Diseñador Grafico (ver figura 7.1).
95
Figura 7.1. Tipos de Sentencias SQL
Las Sentencias SQL Estáticas solo pueden ser creadas y modificadas en el Diseñador
Grafico.
Crear una sentencia SQL
Para crear una Sentencia SQL basada en una consulta SELECT con el asistente debemos
seguir los siguientes pasos:
 Paso 1. En el navegador de objetos, al tener previamente su proyecto y su forma ya

abierta en JFormsBuilder, situarse sobre el nodo llamado SQLSTATEMENT (Sentencia
SQL).

 Figura 7.2. Creando una Sentencia SQL - Paso 1
 Paso 2. Clic derecho sobre el nodo SQLSTATEMENT y clic en Adicionar.
 Paso 3. En la ventana de dialogo ‘Creando un SqlStatement’, escribimos el nombre de

la nueva Sentencia SQL, por defecto será SQLSTATEMENT0, seleccionamos la opción
Query y hacemos clic en el botón Aceptar.
96
Figura 7.3. Creando una Sentencia SQL - Paso 3
 Paso 4. Escribimos la consulta SELECT discriminando cada uno de los campos. Puedes
incluir referencias a variables globales y parámetros de la forma dentro del WHERE de
la consulta.
Figura 7.4. Creando una Sentencia SQL – Paso 4
 Paso 5. Clic en siguiente y veremos las columnas que serán generadas en la Sentencia SQL.
97
Figura7.5. Creando una Sentencia SQL – Paso 5
 Paso 6. Clic en siguiente y en finalizar para salir del asistente de Sentencias SQL.
Figura7.6.. Creando una Sentencia SQL – Paso 6
Propiedades
 Column Specification:
98
Aplicable solo si el SqlStatement es de tipo estático. Esta propiedad especifica los

valores de las columnas que van a ser mostradas en la Lista de Ayuda asociada al
SqlStatement.
 Comments:
Esta propiedad nos sirve para mantener comentarios sobre un SqlStatement. Nos
puede servir para controlar fechas y autores de las diferentes modificaciones, así
como para documentar el objetivo del SqlStatement
 Java name:
Esta propiedad muestra el nombre que va a tener el SqlStatemet en el código fuente
java
 Name:
Esta propiedad es utilizada para especificar el nombre de un SqlStatement, este
nombre debe ser único
 SqlStatement type:
Esta propiedad especifica si un SqlStatement está basado en una consulta SELECT o en
valores estáticos, sus opciones son Query: está basado en una consulta o Static: esta
basado en valores estáticos, además aparece la propiedad Column Specification.
Esta propiedad la utilizamos asignarle o saber a qué elemento se encuentra asociado el
SqlStatement. Con esta propiedad podemos decirle al SqlStatement que tome todas las
propiedades de un elemento creado en la forma o lo pueda tomar desde otro archivo
creado con JFormsBuilder. Para mayor información véase el capítulo de reutilización
de código.
 Query:
Especifica la consulta SELECT asociada al SqlStatement.
99
Capitulo 8
Examinando las propiedades de las Listas de Ayuda
8.1. Conceptos básicos de las lista de ayuda.
Una Lista de Ayuda es una ventana emergente desplazable que provee al usuario final una
lista de selección simple o con múltiples columnas.
Las Listas de Ayuda ofrecen las siguientes funcionalidades:
 Las Listas de Ayuda pueden ser desplegadas por petición del usuario final (cuando hay
una Lista de Ayuda disponible), cuando el usuario navega a un campo de texto con una
Lista de Ayuda asociada, mediante programación, independientemente de un campo de
texto especifico.
 Las Listas de Ayuda permiten al usuario final localizar valores específicos.
 Los valores de una Lista de Ayuda que son seleccionados por el usuario final pueden ser
asignados a campos de la forma, de acuerdo a los valores de retorno que fueron asignados.
 En tiempo de diseño, una Lista de Ayuda puede ser asignada a uno o más campos de texto
de la forma.
 Las Listas de Ayuda son derivadas de las Sentencias SQL.
En tiempo de ejecución, JFormsBuilder muestra la palabra <Help List> en la barra de estado

cuando una Lista de Ayuda está disponible. Una vez invocada, mediante programación o por el
usuario final, las Listas de Ayuda aparecen en una ventana emergente, permitiendo al usuario
final seleccionar un valor individual.
Los usuarios finales pueden utilizar las características de auto reducción y búsqueda en una
Lista de Ayuda para facilitarles la localización de un valor especifico.
100
Para usar la característica de auto reducción, los usuarios finales deben escribir los caracteres
o las palabras en la Lista de Ayuda. A medida que ingresamos los caracteres JFormsBuilder se
encarga de reducir la lista de valores que coincidan con la cadena que has sido escrita. Al
mismo tiempo, si hacemos presionamos la tecla ‘Retroceder’ obtenemos los valores a medida
que los caracteres en la Lista de Ayuda.
Los usuarios finales pueden usar la característica de búsqueda para localizar un valor
específico. Para usar esta característica, el usuario final se sitúa sobre el campo de búsqueda
de la Lista de Ayuda y digite la palabra a buscar, haciendo clic sobre el botón Filtrar u
oprimiendo la tecla ENTER, JFormsBuilder acorta la lista para hacer que los resultados
aparezcan con los que coincidan con la búsqueda del usuario. Note que si la palabra a buscar
termina con el símbolo porcentaje ‘%’ JFormsBuilder traerá todos los valores de la Lista de
Ayuda.
8.1.1. Listas de Ayuda y Sentencias SQL.
Las Listas de Ayuda están derivadas de una estructura de datos interna llamada Sentencias
SQL. Cuando definimos una Lista de Ayuda, la asociamos a una Sentencia SQL.
Una Sentencia SQL es una estructura de columnas/filas que es similar a una tabla en la base de
datos. La Lista de Ayuda es la interface de objetos que ayuda a los usuarios finales a ver,
recorrer y seleccionar registros actualmente almacenados en la Sentencia SQL.
Una Sentencia SQL tiene un número ilimitado de columnas de tipo CHAR, LONG, NUMBER o
DATE.
Cuando se crea una Lista de Ayuda, se debe especificar que columnas de la Sentencia SQL van
a ser mostradas en la ventana de la Lista de Ayuda. Las columnas de la Sentencia SQL siempre
van a mostrarse en la ventana de la Lista de Ayuda en el mismo orden en que fueron
seleccionadas en la Sentencia SQL.
Debido a que las Listas de Ayuda y las Sentencias SQL son objetos separados, se pueden crear
múltiples Listas de Ayuda basadas en la misma Sentencia SQL. Por ejemplo, si quieres crear
101
dos Listas de Ayuda basadas en una misma Sentencia SQL de cuatro columnas, pero en cada
una de las Listas de Ayuda vas a mostrar columnas diferentes.
8.1.2. Valores de las sentencias SQL.
Los valores actuales de una Sentencia SQL provienen de dos fuentes:
 La ejecución de una consulta SELECT que asociamos a una Sentencia SQL
 Un arreglo de valores estáticos asociados a una Sentencia SQL
8.1.3. Creando una lista de ayuda.
Para crear una Lista de Ayuda con el asistente debemos seguir lo siguientes pasos:
 Paso 1: En el navegador de objetos, nos situamos sobre la forma deseada, hacemos

clic derecho sobre el nodo P_HELP_LIST y hacemos clic en adicionar.
Figura 8.1. Creando una Lista de Ayuda con el Asistente – Paso 1
 Paso 2: Seleccionamos ‘crear una lista de ayuda con el asistente’ y clic en aceptar.
102

 Paso 3: A continuación se inicia el asistente para la Lista de Ayuda, clic en siguiente.

 Paso 4: Seleccionamos la Sentencia SQL ‘SQLSTATEMENT0’ que creamos previamente,
clic en siguiente.
103

 Paso 5: Ahora vemos cada uno de los campos que son seleccionados desde la consulta
SELECT asociada a la Sentencia SQL, en este momento asociamos un campo de la Lista
de Ayuda a un campo de texto de la forma (Ver figura 8.5), podemos seleccionar que
valores van a estar en la Lista de Ayuda y que valores van a ser visibles. Clic en
siguiente.
Figura 8.5. Asociando valores a campos de la forma
104
 Paso 6: Personalizamos nuestra Lista de Ayuda, estableciendo las propiedades de

tamaño, posición, nombre, etc. Clic en siguiente.
105

 Paso 7: Clic en finalizar para terminar la creación de la Lista de Ayuda con el asistente.
Para crear una Lista de Ayuda manualmente, debemos seguir los siguientes pasos:
 Paso 1: En el paso dos, al crear una Lista de Ayuda, seleccionamos crear una ‘Lista de
ayuda manualmente’ (Ver figura 8.8) y hacemos clic en aceptar.
Figura 8.8. Creando una Lista de Ayuda manualmente – Paso 1

 Paso 2: Escribimos el nombre de la Lista de Ayuda, el nombre por defecto que
JFormsBuilder asigna es HELP_LIST0, Clic en aceptar.
106
Figura 8.9. Creando una Lista de Ayuda manualmente – Paso 2

 Paso 3: A continuación utilizamos la paleta de propiedades para asignar la Sentencia
SQL y luego asignarle los campos de retorno a los campos de la Lista de Ayuda.
Figura 8.10. Asignando las propiedades a una Lista de Ayuda creada manualmente
Figura 8.11. Asignando campos de retorno de una Lista de Ayuda
Propiedades:
 Automatic display:
Esta propiedad nos sirve para desplegar la lista de ayuda automaticamente cuando se
navega sobre un elemento de la que la tenga asociada.
 Comments:
107
Esta propiedad nos sirve para mantener comentarios sobre una Lista de ayuda. Nos
puede servir para controlar fechas y autores de las diferentes modificaciones, así
como para documentar el objetivo de la Lista de ayuda.
 Height:
Esta propiedad especifica la altura de una Lista de ayuda, la unidad de medida es el
píxel.
 Java name:
Esta propiedad muestra el nombre que va a tener la Lista de ayuda en el código fuente
java.
 Name:
Esta propiedad es utilizada para especificar el nombre de una Lista de ayuda, este
nombre debe ser único.
 Name field by validate:
Establece el nombre del Field contra el cual va a ejecutar la propiedad Validate List.
Numero de registros desplegados al ejecutar la sentencia sql asociada a la Lista de
ayuda
 SqlStatement:
Sentencia sql asociada a la Lista de Ayuda.
 SubClass Information:
Esta propiedad la utilizamos asignarle o saber a qué elemento se encuentra asociado a
la Lista de ayuda. Con esta propiedad podemos decirle a la Lista de ayuda que tome
todas las propiedades de un elemento creado en la forma o lo pueda tomar desde otro
archivo creado con JFormsBuilder. Para mayor información véase el capítulo de
reutilización de código.
Title:
Titulo que se mostrara en la barra de titulo en tiempo de ejecucion la Lista de ayuda.
 Width:
Esta propiedad especifica el ancho de una Lista de ayuda, la unidad de medida es el
píxel
 X:
Especifica la posición con respecto al eje x en el cual estará ubicada la Lista de ayuda
108
 Y:
Especifica la posición con respecto al eje y en el cual estará ubicada la Lista de ayuda
Propiedades de las columnas de una Lista de Ayuda
 Name:
Esta propiedad es utilizada para especificar el nombre de la columna. Este nombre
debe ser único.
 Label:
Etiqueta con la cual aparecerá en la columna al desplegar la lista de ayuda.
 Return value to:
Esta propiedad establece cual va a ser el Field al cual va a retornar el valor
seleccionado de la Lista de ayuda.
 Visible:
Establece si la columna va a ser visible o no en tiempo de ejecución.
 Width:
Establece el ancho de la columna, esta medida está dada en pixeles.
109
Capitulo 9.
Creación de métodos.
Con JFormsBuilder podemos crear métodos internos en una forma o librería que nos
permitan implementar la funcionalidad que es propia de la forma, tal como validaciones o
llamados a Enterprise Java Beans de sesión o procedimientos almacenados en una base de
datos que implementen la lógica de negocio de la aplicación.
Para crear un método en JFormsBuilder hacemos clic contrario sobre el nodo “METHODS” del
árbol del navegador de objetos, seguidamente se nos muestra un dialogo como el mostrado en
la figura 9 .1
Figura 9.1. Creación de un método.
El diálogo nos permite seleccionar entre un procedimiento, una función o un paquete. Al

hacerlo nos pide el nombre del método que vamos a crear.
Un método dentro de JFormsBuilder se puede programar en PL/SQL o en Java.
9.1. Propiedades de los métodos.
Así como cualquier otro tipo de elemento, a los métodos también se les pueden definir
propiedades. Las propiedades de los métodos son:
110
 Comments:
En esta propiedad definimos los comentarios de nuestro método. Cuando generamos las
clases de java, los comentarios se agregan como documentación java del método
(JavaDoc).
 Function Type:
Esta propiedad indica cuál es el tipo de dato que devuelve el método. Si el método es un
procedimiento, al no devolver nada el tipo de función se define como void.
 Name:
Esta propiedad indica el nombre del método.
 Method Type:
Esta propiedad indica si el método que estamos editando es un procedimiento, función o
paquete.
 Programming Type:
Esta propiedad indica el lenguaje de programación con el que se está editando el método.
Los valores posibles son PL/SQL y Java. Si cambiamos de PL/SQL a java, un mensaje de
advertencia es mostrado indicando que todo cambio en Java no será migrado
automáticamente a PL/SQL. Esto es debido a que Java es un lenguaje 3GL (propósito
general) y PL/SQL es un 4GL (propósito más específico).
111
Capitulo 10.
Adjuntar Librerías.
10.1. Conceptos básicos.
Las librerías son una agrupación de métodos que pueden ser llamados desde cualquier evento
o método de una forma que haya adjuntado dicha librería.
El nodo librerías muestra las librerías que se encuentran adjuntas a la forma y también nos
permite adjuntar nuevas librerías.
10.2. Adjuntar una librería.

Para adjuntar una nueva librería, hacemos clic contrario sobre el nodo librerías y del menú
emergente seleccionamos Adicionar tal como se muestra en la figura 10.1.
Figura 10.1. Creación de un método.
Al hacerlo se nos muestra un dialogo para seleccionar el archivo correspondiente a la librería.

Escogemos la librería que deseamos adjuntar y hacemos clic en el botón abrir. Luego de esto,
JFormsBuilder automáticamente adjunta la librería a la forma dejando a esta última lista para
desde cualquier evento o método podamos llamar a métodos definidos en la librería.
112
Capitulo 11.
Definiendo los object groups y sus propiedades.
Los object groups son contenedores de objetos los cuales utilizamos para almacenar
información que nos podría ser útil desde otra forma. Estos grupos de objetos nos permiten
tener agregados objetos que sean hijos de los objetos de la estructura principal de la forma a
excepción de unos. Los elementos permitidos son:
 Events.
 Data.
 Help_list.
 SqlStatement.
 Frame.
 Panel.
 Message.
 Method.
 Parameter.
 Property Class.
 Visual attributes.
Los object groups son utilizados para reutilización de código porque nos permite compartir
objetos con otras formas de manera referenciada para poder mantener el código desde una
sola ubicación de forma personalizada.
En estos object groups no tienen limite de objetos dentro de ellos, y pueden ser agregados y
eliminados los objetos dependiendo lo que se necesite. No pueden existir objetos del mismo
tipo que tengan el mismo nombre cuando se intenta hacer eso la herramienta no lo permitirá
y no sobrescribirá el elemento que se tiene ya agregado.
Los object groups pueden ser utilizados desde diferentes formas y cuando este objeto sea
agregado a la forma los objetos contenidos en el se agregaran a sus respectivos nodos
113
contenedores, en el caso de que el nodo que se desea agregar ya exista un objeto con el mismo
nombre este objeto no se agregara ni se sobrescribirá para no dañar el que ya se encuentra
funcionando en la aplicación, este objeto que no fue agregado quedara en la referencia del
object group y no quedara añadido a la forma hasta que el que se encuentra creado en la
forma sea eliminado.
Propiedades.
 Comments:
Esta propiedad nos sirve para mantener comentarios sobre el object group. Nos puede servir
para controlar fechas y autores de las diferentes modificaciones, así como para documentar el
objetivo del object group.
 Name:
Esta propiedad define el nombre con el que vamos a identificar el object group. Este nombre
lo vamos a usar cuando referenciemos el object group desde diferentes lugares
JFormsBuilder.
114
Capitulo 12.
Definiendo los property class y sus propiedades.
Los property classes son objetos utilizados para la reutilización de código. Estos objetos son
utilizados para poder controlar propiedades y eventos que tengan componentes asignados.
Un property class puede tener todas las propiedades que se puedan encontrar en el
JFormsBuilder, además de eso el property class también puede tener asociado los eventos que
estén disponibles en el JFormsBuilder.
Los property classes solo pueden tener asociados la propiedad una sola vez y para poder
agregarle propiedades se realiza a través del botón que se encuentra en la parte superior de
las propiedades el cual es Agregar propiedades y para eliminarlas se usa el botón
Eliminar propiedades que se encuentra al lado. Las propiedades que no se pueden

eliminar son Comments, Name, SubClassInformation estas propiedades son propias del
property class y no pueden ser eliminadas además de eso no pueden ser encontradas en la
lista de propiedades para agregar.
Los property classes pueden estar asociados a cualquier objeto en la herramienta, como
decíamos anteriormente estos objetos pueden tener todas las propiedades y al momento de
asociarlos a un objeto este solo pondrá las propiedades que corresponden a ese objeto, las
otras propiedades que no pertenezcan a ese objeto no serán visualizadas al momento de
asociarse y no afectaran el funcionamiento del objeto, de igual manera funcionan cuando el
property class tiene eventos asociados estos eventos no serán visualizados en los elementos
que no puedan llevar eventos.
Los property classes son asociados a los objetos a través de la propiedad

SubClassInformation los objetos que no tienen esa propiedad no pueden tener el property
class asociado.
Propiedades.
 Comments:
115
Esta propiedad nos sirve para mantener comentarios sobre el property class. Nos puede
documentar el objetivo del property class.
 Name:
Esta propiedad define el nombre con el que vamos a identificar el property class. Este
nombre lo vamos a usar cuando referenciemos el property class desde los diferentes
métodos del JFormsBuilder.
 SubClassInformation:
Esta propiedad la utilizamos asignarle o saber a qué elemento se encuentra asociado al

property class. Con esta propiedad podemos decirle al property class que tome todas las
propiedades de un objeto creado en la forma o lo pueda tomar desde otro archivo creado
con JFormsBuilder. Para mayor información véase el capítulo de reutilización de código.
116
Capitulo 13.
Definiendo los imports.
Los imports son utilizados para agregar librerías que no pertenecen al JAS las cuales pueden
ser incluidas por el usuario cuando se encuentra trabajando en java por medio del
JFormsBuilder. Al momento de implementar librerías nuevas que sirvan para hacer funciones
que no tenga el JAS se necesitan traer paquetes que pertenecen a esas librerías y en java se
realiza a través de imports entonces estos paquetes que son necesitados para la aplicación son
agregados a este nodo.
Al generar una forma nos damos cuenta que la herramienta le agrega en la clase java a la
forma los imports necesarios para que la aplicación pueda correr, es decir solo se agregan
cuando se genera a la clase java ya que si observamos en la herramienta el nodo imports se
encuentra vacio, a excepción de que nosotros hayamos agregado un import personal el cual
deseamos que sea agregado cuando generemos la forma.
La herramienta no tiene límite de imports y pueden ser agregados todos los que el
desarrollador necesite en su aplicación.
El nodo imports no tiene ninguna propiedad que pueda ser visualizada solo es un elemento
que se puede crear o eliminar dependiendo de la necesidad.
117
Capitulo 14.
Definiendo los visual attributes y sus propiedades.
14.1. Conceptos básicos
Los visual attributes son un conjunto de propiedades visuales que se definen por el usuario
las cuales son de fuente y de color. Estas propiedades pueden agregársele a los objetos de
Data o Fields dependiendo la necesidad del desarrollador.
Al asociarse este visual attribute a un objeto este puede alterar la visualización en ejecución
del elemento ya sea solo en el elemento seleccionado, en el registro seleccionado o en los
registros que no se encuentren seleccionados en esos momentos.
Los visual attributes son muy útiles cuando se trata de uniformar al aplicativo con una
apariencia homogénea de tal forma que sea agradable para el usuario.
Propiedades.
 Background:
Esta propiedad nos permite asignar un color de fondo a un objeto que tenga asociado un
visual attribute. Para modificar la propiedad hacemos doble Clic sobre esta se nos
desplegara un dialogo donde podemos seleccionar el color deseado.
118
 Comments:
Esta propiedad nos sirve para mantener comentarios sobre el property class. Nos puede
documentar el objetivo del property class.
 Font:
Esta propiedad nos permite asignar la fuente, su estilo y tamaño de la letra a un objeto
que tenga asociado el visual attribute. Para modificar la propiedad hacemos doble Clic
sobre esta se nos desplegara un dialogo donde podemos seleccionar la fuente, estilo y
tamaño de letra del visual attribute.
 Foreground:
119
Esta propiedad nos permite asignar un color de fuente a un objeto que tenga asociado un
visual attribute. Para modificar la propiedad hacemos doble Clic sobre esta se nos desplegara
un dialogo donde podemos seleccionar el color deseado.
 Java name:
En esta propiedad se visualiza el nombre java que JFormsBuilder le va a asignar al visual

attribute. Cuando se genera el código java el objeto correspondiente al visual attribute se
creara con este nombre.
 Name:
Esta propiedad define el nombre con el que vamos a identificar el property class. Este
nombre lo vamos a usar cuando referenciemos el property class desde los diferentes
métodos del JFormsBuilder.
 SubClassInformation:
Esta propiedad la utilizamos asignarle o saber a qué elemento se encuentra asociado al

property class. Con esta propiedad podemos decirle al property class que tome todas las
propiedades de un objeto creado en la forma o lo pueda tomar desde otro archivo creado
con JFormsBuilder. Para mayor información véase el capítulo de reutilización de código.
120
Capitulo 15.
Definiendo los frames y examinando sus propiedades.
Un frame es un contenedor de los panels los cuales contienen todos los objetos que se van a
visualizar en la forma. Una forma puede tener cualquier numero de frames no hay ningún
límite. Un frame puede ser agregado desde el navegador de objetos seleccionando el nodo
FRAMES y seleccionando la opción Adicionar.
Los frames pueden ser de dos tipos Principal, Stacked.
Frame de tipo Principal.
Una forma realizada por JFormsBuilder solo puede tener un frame de tipo principal, en el caso
de que la forma tenga varios frames definidos como principal se tiene que especificar en la
forma a través de la propiedad Console frame la cual se encuentra en las propiedades de la
forma, sino se especifica la propiedad la cual indica cual es el frame principal la forma
informara al usuario a través de un mensaje y el usuario tendrá que modificar las frames.
Frame de tipo Stacked.
Una forma realizada por JFormsBulder puede tener n frames de tipo stacked, estos son frame
apilados los cuales se utilizan para mostrar información y serán visualizados sobre el frame
principal. Los frame de tipo stacked tienen propiedades diferentes a las propiedades que
tienen asociados los frames de tipo principal.
15.2. Propiedades.
15.2.1. Propiedades en común de los frame de tipo Principal y Stacked.
 Background:
121
Esta propiedad nos permite asignar un color de fondo a un frame. Para modificar la
propiedad hacemos doble Clic sobre esta se nos desplegara un dialogo donde podemos
seleccionar el color deseado.
 Buffer size height:
Se utiliza para asignarle barras de desplazamiento vertical al frame. El valor que es

ingresado en ese campo debe ser mayor al alto del height para que las barras de
desplazamiento se puedan visualizar.
 Buffer size width:
Se utiliza para asignarle barras de desplazamiento horizontal al frame. El valor que es

ingresado en ese campo debe ser mayor al width del frame para que las barras de
desplazamiento se puedan visualizar.
 Close allowed:
Indica si el frame puede cerrarse cuando se presione en la cruz por defecto que le agrega
el sistema.
 Comments:
Esta propiedad nos sirve para mantener comentarios sobre el frame. Nos puede servir para
objetivo del frame.
122
 Frame type:
Nos permite indicarle al frame de que tipo va a ser. Los posibles valores son Principal y
Stacked.
 Height:
Indica la altura que va a tener el frame.
 Hide on exit:
Esta propiedad la utilizamos para decirle al frame que si un elemento que no esta
contenido dentro del frame es seleccionado este frame se esconderá hasta que vuelva a
hacerse visible a través de alguna propiedad o ubicándose en algún componente que este
agregado en el. Para que la propiedad quede activa hay que asignarle el valor true.
 Java name:
En esta propiedad se visualiza el nombre java que JFormsBuilder le va a asignar a frame.

Cuando se genera el código java el objeto correspondiente al frame se creara con este
nombre.
 Maximize allowed:
Indica si el frame puede ser maximizado.
 Minimize allowed:
Indica si el frame puede ser minimizado.
 Minimized title:
Es el título que se le va a visualizar al usuario en el momento que se encuentra

minimizado.
 Name:
Esta propiedad define el nombre con el que vamos a identificar al frame. Este nombre lo
vamos a usar cuando referenciemos al frame desde los diferentes métodos del
JFormsBuilder.
123
 Primary panel:
La utilizamos para indicarle al frame cual va a ser su panel principal, ya que muchos
panels pueden estar agregados en el pero solo uno puede ser el principal el cual va a
tomar el tamaño de este frame. No es necesario que el panel asociado a este frame sea de
tipo principal porque al momento de generarlo este panel agregado se convierte en un
panel de tipo principal.
 Resize allowed:
Indica si el usuario tiene permitido cambiarle el tamaño al frame en el momento que se

esté ejecutando la aplicación.
Esta propiedad la utilizamos asignarle o saber a qué elemento se encuentra asociado el

frame. Con esta propiedad podemos decirle al frame que tome todas las propiedades de
un elemento creado en la forma o lo pueda tomar desde otro archivo creado con
JFormsBuilder. Para mayor información véase el capítulo de reutilización de código.
 Title:
Es la información que va a desplegar en el marco del frame.
 Visible:
Indica si el frame va a ser visible en el momento que se ejecute la aplicación.
 Width:
Indica el ancho que va a tener el frame.
 X:
Especifica la posición con respecto al eje x en el cual estara ubicado el frame.
 Y:
Especifica la posición con respecto al eje y en el cual estara ubicado el frame.
124
15.2.2. Propiedades únicas de los frames tipo Stacked.
 Modal:
Esta propiedad bloquea todas las ventanas que están abiertas antes que ella haciendo que
el foco no salga de la ventana que se encuentra seleccionada hasta que se cierre.
 Move allowed:
Indica si el usuario puede mover la ventana hacia unas posiciones X y Y que el desee en
modo de ejecución.
125
Anexo 1.
Definiendo archivos de configuración.
Una vez tenemos nuestras aplicaciones listas para un ambiente productivo, debemos tener en
cuenta archivos de configuración para que nuestras formas funcionen adecuadamente.
Un archivo importante es el server.properties en el cuál se definen propiedades agrupadas
dentro de las siguientes categorías.
#Dao specification
name=Jdbc
readPool=3
poolSize=3
session=Session
Name: Indica el tipo de DAO (Database Access Object) a utilizar, Los valores posibles son
Jdbc, Toplink, Hibernate.
readPool: Indica el número de sesiones de base de datos solo de lectura creadas al

arrancar TopLink o Hibernate.
poolSize: Indica el número de sesiones totales de base de datos creadas al arrancar

TopLink o Hibernate.
session: Indica el nombre del archivo de sesión de Toplink o Hibernate. Este archivo
contiene la información para la conexión a la base de datos.
#Threads
threadsNumber=3
threadsNumber: Indica el número de hilos creados en el pool del aplicativo para atender
cada una de las peticiones. Inicialmente recomendamos un número igual al doble de usuarios
concurrentes.
#path by files
path=files/
path: Indica la ruta a partir de la cual se escriben los archivos
#path by images
path_images=images/
126
path_images: Indica la ruta a partir de la cual se escriben los archivos de imágenes.
clientServer=true
clientServer: Solo debe estar en verdadero cuando estamos ejecutando las formas en modo
de depuración desde alguna IDE de Java como Eclipse.
#key maps
KEY_COMMIT=F10
KEY_UP=UP
KEY_DOWN=DOWN
KEY_COMMIT: Indica la tecla con la que el usuario puede llamar al evento KEY_COMMIT .
KEY_UP: Indica la tecla con la que el usuario puede llamar al evento KEY_UP.
KEY_DOWN: Indica la tecla con la que el usuario puede llamar al evento KEY_DOWN.
#Puerto para la transferencia de archivos

socketPort=8088
socketPort:Indica el puerto por el cual se transfieren archivos entre el servidor y el cliente.
#Definición del lenguaje. Valores {SP (Español),EN (Ingles)}

languaje=SP
nls_date_format=DD/MM/YYYY
nls_territory=SPAIN
nls_date_languaje=SPANISH
languaje: Indica el idioma con él cual va a trabajar la sesión de base de datos.

nls_date_format: Indica el formato por defecto con el que se van a tratar a las fechas.
nls_territory: Indica el territorio. Del territorio se definen el manejo del separador decimal y
el separador de miles.
nls_date_languaje: Cuando una fecha se muestra en un formato que muestra las fechas en
palabras, este indica el lenguaje en que estas se muestran.
127

Manual PDF

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Manual PDF

Caricato da

Copyright:

Formati disponibili

Comenzando a trabajar con JFormsBuilder3.

Comenzando a trabajar con

8.1.1. Listas de Ayuda y Sentencias SQL. ......................................................................... 101

JFormsBuilder está diseñado para proveerle al desarrollador las siguientes características.

 Facilidad de aprendizaje: JFormsBuilder es una herramienta intuitiva de muy

 Concentración en lógica de negocio: JFormsBuilder le permite concentrarse en

 Desempeño: Las aplicaciones construidas con JFormsBuilder le permiten

Creando una forma básica

1.1. Conceptos básicos

 Forma. Una forma es la representación visual de su aplicativo, le permite al usuario final

 Proyecto. Un proyecto es un conjunto de formas. Le permite agrupar a sus formas en

1.2. Familiaricémonos con la herramienta.

Figura 1.1. Componentes Principales.

1.2.1. Menú Principal.

El menú principal tiene las opciones que se muestran en la figura 1.2.

Figura 1.2. Menú Principal.

El menú diseñador permite ocultar o mostrar la regla del diseñador, la paleta de

1.2.2. El navegador de objetos

Detallemos en forma general estos elementos:

 SqlStatements: Los SqlStatements son normalmente comandos SQL, aunque pueden

 Métodos: Los métodos son algoritmos programados en el lenguaje de programación

 Clases de propiedad: Las clases de propiedad son un conjunto de propiedades que se

 Imports: Si trabajamos con librerías de terceros programadas en java, podemos incluir

1.2.3. El panel central.

Figura 1.3.Panel Central.

1.2.4. El panel derecho.

El panel derecho es el contenedor de la paleta de propiedades. Cuando nos situamos sobre un

Figura 1.4.Panel Derecho.

1.3. Creemos una forma

CREATE TABLE EMPLEADOS

Script 1. Script tabla Empleados

Insertemos datos de prueba en la anterior tabla para futuras pruebas.

Conexión a la base de datos.

El siguiente prerrequisito es establecer la conexión a la base de datos desde la herramienta. La

En el panel izquierdo seleccionamos Connection, y nos aparece la ventana como se muestra

A continuación detallaremos la información de cada campo en la ventana anterior.

 Tamaño de la página: Define el número de registros a traer por defecto cuando se

 Tipo de base de datos: Define el fabricante de la base de datos soportado por el

 Versión de la base de datos: Cada base de datos incorpora funcionalidad diferente en

 Tipo de conexión: Algunos fabricantes de bases de datos tienen diferentes formas de

 Ip del servidor: Define la dirección IP o el nombre de la maquina donde reside la base

 Nombre de la base de datos: Define el nombre de la instancia de base de datos.

 Usuario: Usuario que se conecta a la base de datos. Normalmente usamos un usuario

1.3.2. Creación del proyecto

Figura 1.7. Nuevo Proyecto.

Damos un nombre al proyecto y establecemos la ruta del directorio donde se almacenará

1.3.3. Creación de la forma

Figura 1.8. Nueva Forma.

Ruta del directorio: La ruta en la que se almacenará la forma.

Paquete: Paquete de java en el cual va a contener las clases de java generadas.

Extiende: Si la forma extiende funcionalidad de otra forma, Aquí colocamos el nombre de

Figura 1.9.Estructura de la Nueva Forma.

La nueva forma tiene una estructura como la mostrada en la figura 1.9.

Figura 1.10.Dialogo Crear Ventana.

Le damos un nombre a nuestro panel, seleccionamos su ventana contenedora, y el tipo de

Figura 1.11.Dialogo Crear Panel.

Todos los componentes (Widgets) en JForms están incluidos en datas. Procedamos

Figura 1.12.Creación de un data con asistente.

Haciendo clic en el botón Tablas JDBC de la esquina superior derecha, podemos

Figura 1.12.Seleccion del panel donde se muestran los elementos.

Luego se nos muestran un dialogo como el mostrado en la figura 1.13.

Figura 1.13.Seleccion de campos a mostrar.

Figura 1.14.Data creado por el asistente.