Auto-Formación WINDEV 21

Introducción |1
WINDEV 21
Documentación Versión 21 (2) -1215
Visite regularmente la página web www.pcsoft.fr, espacio actualizado para ver si hay actualizaciones disponibles.
Dirección de Soporte técnico gratuito:

supportgratuit@pcsoft.fr
Consejo: Para recibir directamente las actualizaciones provisionales y consejos de uso, abónese a LST (revista
trimestral + DVD), en francés.
Esta documentación no es contractual. PC SOFT se reserva el derecho de modificar o borrar cualquier tema tratado en
este documento.
Todos los nombres de productos y otras marcas mencionadas aquí son marcas comerciales registradas por sus
respectivos propietarios.© PC SOFT 2015: Queda prohibida la reproducción total o parcial de este material en
cualquier formato que pueda llevarse a cabo sin el permiso expreso del PC SOFT.
Introducción |2
Contenido
Dirección de Soporte técnico gratuito: supportgratuit@pcsoft.fr .............................................................................. 2
Introducción ....................................................................................................................................................... 14
Preliminares .................................................................................................................................................... 14
Presentación del curso de auto-formación ......................................................................................................... 14
¿Cómo acceder a la ayuda en línea? ................................................................................................................. 14
Leyenda de los símbolos .................................................................................................................................. 16
Si ya conoce WINDEV 20 … .............................................................................................................................. 16
¿Qué puedo hacer con WINDEV? ...................................................................................................................... 17
Lección 1.1. Descubra WINDEV............................................................................................................................ 19
Lo que va a aprender en esta lección… ............................................................................................................. 19
Presentación ................................................................................................................................................... 20
Lanzamiento de WINDEV ................................................................................................................................. 20
Entorno de desarrollo ....................................................................................................................................... 20
El editor ....................................................................................................................................................... 20
La barra de menú (cinta) en detalle ............................................................................................................... 21
Lección 1.2. Mi primera ventana .......................................................................................................................... 23
Presentación ................................................................................................................................................... 24
Apertura del proyecto ................................................................................................................................... 24
Mi primera ventana: Introducir y mostrar los datos ............................................................................................ 24
Presentación ................................................................................................................................................ 24
Creación de la ventana ................................................................................................................................. 25
Introducir y mostrar el valor introducido ........................................................................................................ 26
Mejoras en la ventana .................................................................................................................................. 29
Lección 1.3. Ventanas más evolucionadas............................................................................................................. 31
Presentación ................................................................................................................................................... 32
Gestionar la introducción de un numérico para hacer un cálculo ......................................................................... 32
Dar formato ................................................................................................................................................. 32
Prueba de la ventana .................................................................................................................................... 33
Uso de un campo Combo para proponer varias posibilidades........................................................................... 33
Creación y uso de un procedimiento. ............................................................................................................. 36
Mostrar la fecha y la hora en tiempo real .......................................................................................................... 36
Presentación ................................................................................................................................................ 36
Creación de la ventana ................................................................................................................................. 36
Establecimiento del timer .............................................................................................................................. 39
Creación de un botón para abandonar la ventana. .......................................................................................... 40
Creación de una ventana con un menú ............................................................................................................. 41
Describir el menú ......................................................................................................................................... 41
Introducción |3
Asociar un código a las opciones del menú .................................................................................................... 43
WINDEV: Conceptos básicos y terminología ...................................................................................................... 44
Conceptos básicos ........................................................................................................................................ 44
Terminología ................................................................................................................................................ 45
Lección 1.4. Bases de programación..................................................................................................................... 47
Introducción .................................................................................................................................................... 48
Declaración de distintos tipos de variables......................................................................................................... 48
Distintos tipos de variables ........................................................................................................................... 48
Declaración de variables y su alcance ............................................................................................................ 48
Instrucciones básicas de WLangage .................................................................................................................. 48
Instrucciones condicionales ........................................................................................................................... 49
Instrucciones de bucle .................................................................................................................................. 50
Comentarios ................................................................................................................................................ 51
Operadores básicos de WLangage .................................................................................................................... 51
Operadores lógicos ....................................................................................................................................... 51
Operadores de comparación.......................................................................................................................... 52
Operadores de indirección ............................................................................................................................ 52
Procedimientos y funciones .............................................................................................................................. 53
Definición .................................................................................................................................................... 53
Procedimiento local ...................................................................................................................................... 53
Procedimiento global y colección de procedimientos. ...................................................................................... 53
¿Cómo elegir si un procedimiento es global o local?........................................................................................ 54
A propósito del paso de parámetros .............................................................................................................. 54
Llamada de un procedimiento ....................................................................................................................... 54
Creación de un procedimiento ....................................................................................................................... 54
¿Un ejercicio de aplicación? Su turno! ............................................................................................................ 55
Tratamientos de las cadenas ............................................................................................................................ 55
Ejemplo práctico .......................................................................................................................................... 55
Principales manipulaciones sobre una cadena de caracteres. ........................................................................... 55
Tratamientos de los numéricos ......................................................................................................................... 57
Principales manipulaciones sobre los numéricos ............................................................................................. 57
Tratamiento de los monetarios ......................................................................................................................... 58
Detalles ....................................................................................................................................................... 59
Mezcla de cadenas y numéricos..................................................................................................................... 59
Tratamiento de las fechas y de las horas ........................................................................................................... 60
Las fechas ....................................................................................................................................................... 60
Introducción |4
Máscara de introducción y valor devuelto ....................................................................................................... 60
¿En qué día estamos? ................................................................................................................................... 62
¿En qué día estamos, pero el día y el mes en letras? ...................................................................................... 62
¿Cuál es el número de días entre dos fechas? ................................................................................................ 62
¿Qué día de la semana es una fecha concreta? .............................................................................................. 63
Pequeño ejercicio práctico ............................................................................................................................ 63
Manipulación de las variables de tipo Fecha ................................................................................................... 63
Las horas ........................................................................................................................................................ 64
¿Qué hora es? .............................................................................................................................................. 65
¿Cuánto tiempo ha transcurrido entre dos horas? ........................................................................................... 65
Cálculos con las fechas y las horas.................................................................................................................... 66
Lección 1.5. Preguntas/Respuestas ...................................................................................................................... 67
Preguntas/Respuestas ...................................................................................................................................... 68
Lección 2.1. Presentación .................................................................................................................................... 72
Presentación del proyecto realizado en este capítulo .......................................................................................... 73
Lección 2.2. WINDEV y las bases de datos ........................................................................................................... 74
Presentación ................................................................................................................................................... 75
HFSQL ............................................................................................................................................................ 75
Distintos modos de acceso a las bases de datos ................................................................................................ 75
Acceso nativo ............................................................................................................................................... 75
Acceso ODBC Directo .................................................................................................................................... 76
Acceso OLE DB............................................................................................................................................. 76
Acceso ODBC a través de OLE DB ................................................................................................................. 76
Lección 2.3. Proyecto y análisis ............................................................................................................................ 77
Presentación ................................................................................................................................................... 78
Creación del proyecto ...................................................................................................................................... 78
Creación del análisis ........................................................................................................................................ 79
Creación de la descripción del fichero de datos .................................................................................................. 80
Creación de un fichero de datos: Uso de un fichero predefinido. ..................................................................... 80
Creación de un fichero de datos: creación del fichero y sus rúbricas ................................................................ 82
Importación de un fichero CSV ...................................................................................................................... 85
Importación directa de ficheros de datos existentes ....................................................................................... 88
Creación de las relaciones ................................................................................................................................ 88
Introducción |5
Generación del análisis ..................................................................................................................................... 93
Lección 2.4. El RAD completo .............................................................................................................................. 95
¿Qué es el RAD? .............................................................................................................................................. 96
Generación del RAD ......................................................................................................................................... 96
Prueba de la aplicación .................................................................................................................................... 99
Lección 3.1. Presentación .................................................................................................................................. 102
Lo que va a aprender en esta lección… ........................................................................................................... 102
Presentación de la aplicación realizada en este capítulo ................................................................................... 103
Proyectos proporcionados .............................................................................................................................. 103
Proyecto ejemplo ....................................................................................................................................... 103
Proyectos corregidos .................................................................................................................................. 104
Lección 3.2. Ventanas adición y modificación ...................................................................................................... 105
Presentación ................................................................................................................................................. 106
Creación de una ventana que liste los productos.............................................................................................. 106
Creación de la ventana ............................................................................................................................... 106
Creación de los campos .............................................................................................................................. 107
Prueba de la ventana .................................................................................................................................. 109
Creación de una ventana “Ficha Producto” ...................................................................................................... 111
Creación de los campos de entrada ............................................................................................................. 112
Creación de los botones .............................................................................................................................. 113
Mejoras del interface de la ventana. ............................................................................................................ 114
Mostrar la ficha desde la lista de productos .................................................................................................. 117
Gestión de la modificación de un producto ...................................................................................................... 118
Modificar la imagen del producto ................................................................................................................. 118
Validación de las modificaciones del producto .............................................................................................. 119
Probar la modificación de un producto ......................................................................................................... 120
Creación de un nuevo producto ...................................................................................................................... 120
Añadir un botón ......................................................................................................................................... 121
Añadir en el fichero de datos....................................................................................................................... 121
Probar la adición de un producto. ................................................................................................................ 122
Visualizar los registros introducidos ............................................................................................................. 123
Lección 3.3. Búsqueda simple y recorrido por los registros .................................................................................. 125
Presentación ................................................................................................................................................. 126
Modificación de la ventana. Uso de un campo Pestaña ..................................................................................... 126
Creación del campo Pestaña ....................................................................................................................... 126
Modificaciones del campo Pestaña ............................................................................................................... 128
Implementación de la búsqueda ..................................................................................................................... 130
Introducción |6
Zona de visualización de las informaciones encontradas ............................................................................... 130
Búsqueda idéntica ...................................................................................................................................... 131
Búsqueda genérica ..................................................................................................................................... 135
Recorrido de las fichas ................................................................................................................................ 136
Prueba de la ventana .................................................................................................................................. 138
Lección 3.4. Búsqueda multi-criterio ................................................................................................................... 139
Presentación ................................................................................................................................................. 140
Creación de la consulta para buscar los pedidos .............................................................................................. 140
Creación de la consulta ............................................................................................................................... 140
Prueba de la consulta ................................................................................................................................. 143
Uso de parámetros en la consulta................................................................................................................ 143
Prueba de la consulta parametrizada ........................................................................................................... 146
Creación del interface para realizar una búsqueda multi-criterio ....................................................................... 146
Modificaciones del campo pestaña ............................................................................................................... 146
Creación de los campos de parametrización de los criterios y mostrar el resultado ......................................... 147
Lección 3.5. Imprimir el contenido de un campo Tabla ........................................................................................ 157
Presentación ................................................................................................................................................. 158
Impresión del contenido de un campo Tabla ................................................................................................... 158
Impresión directa mediante la FAA (Funcionalidades Automáticas de la Aplicación) ........................................ 158
Creación de un informe automático sobre un campo Tabla ........................................................................... 160
Lección 3.6. Imprimir un pedido......................................................................................................................... 162
Presentación ................................................................................................................................................. 163
Creación del informe “Bono de pedido” ........................................................................................................... 163
Creación de la consulta ............................................................................................................................... 163
Creación del informe basado en una consulta............................................................................................... 165
Modificación del informe “Bono de pedido” .................................................................................................. 171
Mostrar el informe impreso desde una opción de menú .................................................................................... 173
Creación del menú contextual ..................................................................................................................... 173
Asociación del menú contextual al campo Tabla ........................................................................................... 174
Prueba de impresión ................................................................................................................................... 174
Lección 3.7. Imprimir una lista de clientes .......................................................................................................... 176
Presentación ................................................................................................................................................. 177
Creación del informe ...................................................................................................................................... 177
Lanzamiento de la impresión de un informe por programación ......................................................................... 183
Lección 3.8. Estadísticas: Campos Gráfico y Tablero Cruzado Dinámico ................................................................ 185
Presentación ................................................................................................................................................. 186
Introducción |7
Mostrar los datos en un campo Gráfico ........................................................................................................... 186
Selección de datos a mostrar en el campo Gráfico ........................................................................................ 186
Creación del campo Gráfico......................................................................................................................... 188
Creación de tableros de síntesis mediante el campo Tablero Cruzado Dinámico ................................................. 192
Creación del campo Tablero Cruzado Dinámico ............................................................................................ 192
Prueba del Tablero Cruzado Dinámico ......................................................................................................... 194
Lección 3.9. Enviar un email .............................................................................................................................. 197
Presentación ................................................................................................................................................. 198
Una ventana para enviar los emails................................................................................................................. 199
Creación de los campos de parametrización del envío ................................................................................... 199
Creación de los campos que permitirán introducir las características del email ............................................... 200
Envío del email ........................................................................................................................................... 202
Mejoras en la ventana .................................................................................................................................... 203
Cierre de la ventana ................................................................................................................................... 203
Dar forma a la ventana ............................................................................................................................... 203
Apertura no modal de la ventana. ............................................................................................................... 204
Lección 3.10. Identificar al usuario: el Groupware Usuario ................................................................................... 206
Presentación ................................................................................................................................................. 207
Integrar el groupware usuario ........................................................................................................................ 207
Configurar el groupware usuario ..................................................................................................................... 209
Creación de los usuarios y los grupos. ......................................................................................................... 210
Definición de los derechos. ......................................................................................................................... 212
Prueba de la aplicación ............................................................................................................................... 214
Desmarcar la gestión del groupware usuario ................................................................................................... 215
Lección 3.11. Reutilización del código mediante los componentes externos ........................................................... 216
Presentación ................................................................................................................................................. 217
Trabajo en equipo ...................................................................................................................................... 217
Los proyectos voluminosos ......................................................................................................................... 217
Las bases de datos accedidas por varios proyectos ....................................................................................... 217
Tratamientos utilizados en varios proyectos ................................................................................................. 217
La posibilidad de difundir una funcionalidad o un conjunto de funcionalidades ............................................... 218
Componente externo multi-productos .......................................................................................................... 218
Paso a paso................................................................................................................................................... 218
Paso 1: Creación de un componente externo ............................................................................................... 218
Paso 2: Uso del componente externo ........................................................................................................... 222
Distribución de un componente externo. ......................................................................................................... 225
Distribución simple ..................................................................................................................................... 225
Introducción |8
Distribución profesional .............................................................................................................................. 225
Lección 3.12. Consumir un WEBSERVICE ............................................................................................................ 226
Presentación ................................................................................................................................................. 227
Ejemplo práctico ........................................................................................................................................ 227
Importación de un WebService ....................................................................................................................... 227
Consumo de un WebService ........................................................................................................................... 229
Lección 3.13. Siga la evolución de sus aplicaciones ............................................................................................. 231
Presentación ................................................................................................................................................. 232
El tablero de a bordo ..................................................................................................................................... 232
Pruebas automáticas ...................................................................................................................................... 232
Lección 3.14. Desplegar la aplicación ................................................................................................................. 236
Presentación ................................................................................................................................................. 237
Creación del ejecutable .................................................................................................................................. 237
Creación de la instalación .............................................................................................................................. 240
Instalación de una aplicación .......................................................................................................................... 243
Los distintos tipos de despliegue..................................................................................................................... 244
Presentación .............................................................................................................................................. 244
Instalación con actualización de red. ........................................................................................................... 245
Instalación con actualización por internet..................................................................................................... 245
Instalación Multi-sitio .................................................................................................................................. 246
Lección 3.15. Difundir “Informes y Consultas” con sus aplicaciones ...................................................................... 247
Presentación del software “Informes & Consultas” ........................................................................................... 248
Lanzamiento del software “Informes & Consultas” ........................................................................................... 248
Difundir el software “Informes & Consultas” con su aplicación .......................................................................... 248
Parametrización del proyecto ...................................................................................................................... 248
Parametrización del análisis ........................................................................................................................ 249
Parametrización de los informes .................................................................................................................. 250
Parametrización de las consultas ................................................................................................................. 250
Creación del ejecutable y difusión de la aplicación ........................................................................................ 251
Instalar y utilizar el software “Informes y Consultas”........................................................................................ 252
Instalación de la aplicación ......................................................................................................................... 252
Prueba de la aplicación ............................................................................................................................... 253
Conclusión .................................................................................................................................................... 255
Lección 3.16. Gestionar el multi-lenguaje ........................................................................................................... 256
¿Qué es una aplicación multi-lenguaje? ........................................................................................................... 257
Seleccione los idiomas del proyecto ................................................................................................................ 257
Introducción |9
Internalización del análisis .............................................................................................................................. 258
Internalización de los elementos del proyecto .................................................................................................. 260
Internalización de una imagen .................................................................................................................... 261
Internacionalización de los campos. ............................................................................................................. 262
Internacionalización de un mensaje de programación ................................................................................... 262
Internacionalización de los menús ............................................................................................................... 263
Las herramientas de traducción ...................................................................................................................... 264
Entrada directa de las traducciones ............................................................................................................. 264
Traducción con WDMSG y WDTRAD ............................................................................................................ 264
Otros elementos para traducir: los mensajes de framework .......................................................................... 265
Programación del cambio de lenguaje ............................................................................................................. 265
Añadir una opción de menú ........................................................................................................................ 265
Programación ............................................................................................................................................. 266
Prueba del proyecto ................................................................................................................................... 266
Lección 3.17. GDS ............................................................................................................................................. 269
Introducción .................................................................................................................................................. 270
GDS (Gestor de fuentes) ................................................................................................................................ 270
Principio del GDS ........................................................................................................................................ 270
Creación de la base de fuentes.................................................................................................................... 271
Integración de un proyecto en el GDS ............................................................................................................. 271
Añadir el proyecto en el GDS....................................................................................................................... 271
Apertura del proyecto desde el GDS ............................................................................................................ 274
Configuración del GDS ................................................................................................................................ 275
Manipulación del proyecto mediante el GDS .................................................................................................... 276
Modificación de un parámetro del proyecto .................................................................................................. 276
Modificar una ventana del proyecto. ............................................................................................................... 278
Reintegración del elemento extraído ............................................................................................................ 279
Sincronización del proyecto ......................................................................................................................... 280
Modo desconectado (o nómada) ................................................................................................................. 280
Administrador del GDS ................................................................................................................................ 281
Desconexión del GDS.................................................................................................................................. 281
Conclusión .................................................................................................................................................... 282
Lección 4.1. Introducción .................................................................................................................................. 285
Presentación ................................................................................................................................................. 286
¿Para qué pasar un sitio a modo HFSQL Cliente/Servidor? ................................................................................ 286
Lección 4.2. Establecimiento de una base de datos Cliente/Servidor ..................................................................... 287
Presentación ................................................................................................................................................. 288
Instalación de un servidor HFSQL local............................................................................................................ 288
Introducción |10
Creación de una aplicación utilizando una base de datos HFSQL Cliente/Servidor............................................... 288
Adaptación de un sitio para utilizar una base de datos HFSQL Cliente/Servidor .................................................. 289
Presentación .............................................................................................................................................. 289
Adaptación del ejemplo .............................................................................................................................. 289
Funcionalidades disponibles en modo HFSQL Cliente/Servidor .......................................................................... 292
Lección 4.3. Administrar una base de datos Cliente/Servidor ................................................................................ 293
Presentación ................................................................................................................................................. 294
Configuración de los puestos .......................................................................................................................... 294
El Centro de Control HFSQL ............................................................................................................................ 294
Crear una cuenta usuario en el Centro de Control HFSQL ................................................................................. 295
Copia de seguridad de la base de datos .......................................................................................................... 299
Conclusión .................................................................................................................................................... 300
Lección 4.4. Instalación de cliente ...................................................................................................................... 301
Presentación ................................................................................................................................................. 302
Lanzamiento del asistente de creación de instalación ....................................................................................... 302
Presentación ................................................................................................................................................. 305
Apertura del proyecto ................................................................................................................................. 305
Lección 5.2. Auditorías del proyecto ................................................................................................................... 306
¿Qué es una auditoría? .................................................................................................................................. 307
Auditoría estática. .......................................................................................................................................... 307
Procedimiento no ejecutado ........................................................................................................................ 308
Elemento huérfano ..................................................................................................................................... 309
Consulta a optimizar ................................................................................................................................... 310
Limpieza del proyecto ................................................................................................................................. 311
Auditoría dinámica. ........................................................................................................................................ 311
Lección 5.3. Analizador de actuaciones ............................................................................................................... 314
Presentación ................................................................................................................................................. 315
Lanzar el analizador de actuaciones ................................................................................................................ 315
Análisis del resultado ..................................................................................................................................... 316
Lección 5.4. Depuración de un proyecto ............................................................................................................. 320
Presentación ................................................................................................................................................. 321
Utilizar el depurador ...................................................................................................................................... 321
Introducción |11
Presentación ................................................................................................................................................. 327
Lección 6.2. Gestión automática de errores ........................................................................................................ 328
Presentación ................................................................................................................................................. 329
Funcionamiento.......................................................................................................................................... 329
Establecimiento .......................................................................................................................................... 329
Tipo de errores a los que concierne ............................................................................................................. 329
Gestión automática de los errores: un ejemplo didáctico .................................................................................. 330
Lección 6.3. Manipular ficheros externos ............................................................................................................ 334
Presentación ................................................................................................................................................. 335
Manipulación de los fichero texto o CSV .......................................................................................................... 335
Presentación .............................................................................................................................................. 335
Manipulación de los directorios ....................................................................................................................... 336
Manipulación de los ficheros XML .................................................................................................................... 336
Presentación .............................................................................................................................................. 336
Manipulación de los ficheros XLS .................................................................................................................... 338
Ejemplos prácticos ..................................................................................................................................... 338
Lección 6.4. Compilación dinámica ..................................................................................................................... 340
Presentación ................................................................................................................................................. 341
Ejemplo ........................................................................................................................................................ 341
Lección 6.5. Eventos Windows ........................................................................................................................... 343
Introducción .................................................................................................................................................. 344
Tratamientos opcionales propuestos por WINDEV ............................................................................................ 344
Eventos de Windows ...................................................................................................................................... 345
Ejercicio: Detectar el clic sobre una lista ...................................................................................................... 345
Lección 6.6. Los hilos ........................................................................................................................................ 348
Definición ...................................................................................................................................................... 349
Ejemplo ........................................................................................................................................................ 349
Lección 6.7. Los sockets .................................................................................................................................... 350
Presentación ................................................................................................................................................. 351
Aplicación Servidor: caso de un servidor simplificado ....................................................................................... 351
Introducción |12
Creación del socket .................................................................................................................................... 351
Intercambio de datos ................................................................................................................................. 351
Cierre del socket ........................................................................................................................................ 351
Aplicación Cliente........................................................................................................................................... 352
Conexión al servidor ................................................................................................................................... 352
Intercambio de datos ................................................................................................................................. 352
Fin de comunicación ................................................................................................................................... 352
Ejemplo práctico ............................................................................................................................................ 352
Prueba del ejemplo .................................................................................................................................... 352
Análisis del código utilizado ......................................................................................................................... 352
Lección 6.8. El FTP ............................................................................................................................................ 354
Presentación ................................................................................................................................................. 355
Conectarse a un servidor FTP ......................................................................................................................... 355
Enviar un fichero ........................................................................................................................................... 356
Listar los ficheros presentes en un servidor FTP............................................................................................... 356
Recuperar un fichero ..................................................................................................................................... 357
Desconectarse de un servidor FTP .................................................................................................................. 357
Lección 6.9. La POO (Programación Orientada a Objetos).................................................................................... 358
Conceptos ..................................................................................................................................................... 359
Las clases .................................................................................................................................................. 359
Los objetos ................................................................................................................................................ 359
Los miembros ............................................................................................................................................ 359
Los métodos .............................................................................................................................................. 359
Noción de herencia ..................................................................................................................................... 359
Constructor y Destructor ............................................................................................................................. 359
Encapsulación de datos .............................................................................................................................. 359
Ejemplo ..................................................................................................................................................... 359
Crear un programa orientado a objeto ......................................................................................................... 360
Ejemplo simple .............................................................................................................................................. 360
Declarar una clase ...................................................................................................................................... 360
Describir los métodos ................................................................................................................................. 361
Describir los métodos ................................................................................................................................. 361
Diagrama UML ............................................................................................................................................... 362
Conclusión ........................................................................................................................................................ 364
Introducción |13
Introducción
Preliminares
Atención: Este manual es un curso de auto-formación. Es aconsejable consulta la ayuda en línea cuando utiliza
WINDEV.
El manual del curso de auto-formación tiene por objetivo hacerle descubrir WINDEV, de familiarizarle con los editores
y aprender los conceptos de WINDEV.
Este manual NO ES EXHAUSTIVO de las posibilidades de WINDEV.
Dedique al menos algunas horas para seguir este curso y para aprender WINDEV: Las rentabilizará rápidamente.
Si intenta arrancar el desarrollo de una aplicación sin haber seguido este curso, perderá su tempo, mucho más que
las horas que pueda pasar en este curso de auto-formación.
Este curso se ha concebido para poder seguirlo de dos maneras:
 Seguir todos los ejercicios detallados en las lecciones del curso (método aconsejado).
 Si tiene prisa y ya tiene una experiencia significativa, puede simplemente leerlo sin ejecutar los ejercicios
(todas las manipulaciones están ilustradas). A pesar de todo, para que los conceptos sean asimilados más
rápidamente, es preferible ejecutar las manipulaciones.
WINDEV está en permanente evolución y las imágenes de las ventanas que ilustran el curso, pueden diferir de las
ventanas mostradas por el producto durante las distintas manipulaciones.
Presentación del curso de auto-formación

El curso de auto-formación está concebido para que aprenda progresivamente a utilizar WINDEV. Siguiendo este
curso:
 Por un lado, descubrirá los conceptos más importantes explicados de modo informal; efectivamente, en este
caso se trata de conceptos a adquirir y a comprender.
 Por otro lado, se divertirá efectuando las manipulaciones para ilustrar los conceptos se le acaban de explicar.
Al hilo de la lectura del curso, si desea profundizar un concepto, o si desea tener más detalles sobre una función de
programación, consulte la ayuda en línea (accesible directamente desde los editores o en la guía).
El tamaño de una lección, no es necesariamente proporcional a su interés …
No olvide estudiar a continuación los ejemplos proporcionados con WINDEV: son muy
didácticos!
Desde la impresión de este documento, el curso de auto-formación puede haber evolucionado. No
dude en consultar la versión electrónica del curso de auto-formación (fichero PDF accesible
Notas
directamente en el menú de WINDEV: en el panel “Inicio”, en el grupo “Ayuda en línea”, despliegue

“Guía de Auto-formación” y seleccione la opción “Guía de Auto-formación (PDF)”.
¿Cómo acceder a la ayuda en línea?

La ayuda en línea de WINDEV permite consultar las informaciones detalladas concernientes a las 2500 funciones de
WLangage. Contiene también la ayuda de los editores, de los campos, de las astucias, …
La ayuda en línea está disponible en cualquier momento en WINDEV:
 En el editor de código, una ayuda específica es accesible directamente para el nombre de cada función
seleccionada, usando la tecla [F1].
 Cada ventana de diálogo mostrada por WINDEV tiene un botón permitiendo acceder a la página de ayuda
correspondiente.
 El menú de ayuda de los editores (opción “Ayuda” disponible en el panel “Inicio”, en el grupo “Ayuda en línea” del
menú de WINDEV) permite lanzar la ayuda en línea.
Introducción |14
 La ayuda puede mostrarse:
 En un “navegador de ayuda” específico:
 En un navegador Internet, si tiene acceso a Internet:
Introducción |15
La ayuda en línea de WINDEV, WEBDEV y WINDEV Mobile en Internet es accesible desde cualquier
puesto que disponga de un acceso a Internet, sin que el producto esté necesariamente instalado.
Esta ayuda se actualiza regularmente.
Notas
Cada internauta puede añadir comentarios en las páginas de documentación: explicaciones

personales, ejemplos, enlaces, …
Para lanzar directamente la ayuda en línea de Internet desde el producto:

1. En el panel “Inicio”, en el grupo “Entorno”, despliegue “Opciones” y seleccione la opción “Opciones generales
de WINDEV”.
2. En la pestaña “Ayuda”, seleccione:
 El modo de acceso a la base de la ayuda.
 El contenido de la ayuda: ayuda común a WINDEV, WEBDEV y WINDEV Mobile o ayuda del producto en
curso de utilización.
Leyenda de los símbolos

Este símbolo indica la duración de la lección y sus ejercicios. Atención: el tiempo puede variar según su
experiencia.
Hay disponible un ejemplo para completar el curso. Los ejemplos están disponibles a través de la ventana
de inicio de WINDEV.
Este símbolo presenta una “Astucia”: la lectura del texto asociado está vivamente aconsejada.
Este símbolo presenta una “Advertencia”: la lectura del texto es primordial.
Este símbolo presenta una “Nota”: la lectura del texto es aconsejable.
Si ya conoce WINDEV 20 …
Si conoce ya WINDEV 20, el seguir este curso solo le reportará beneficios: será una buena ocasión de “revisar” las
posibilidades de WINDEV!
Introducción |16
¿Qué puedo hacer con WINDEV?
WINDEV es un AGL (Atelier de Génie Logiciel – Taller de Ingeniería de Software). Le permitirá desarrollar aplicaciones
en todos los campos:
 Gestión de stocks, inventario, trazabilidad de las mercancías.
 Regulación y seguimiento de máquinas en una cadena de producción.
 Toma de pedidos para el tratamiento rápido de venta pública (feria, escuela, stand, …)
 Fichas de clientes
 Herramientas de ayuda a la toma de decisiones de urgencia en un teléfono portátil
 Verificación de la identidad de los visitantes de un evento: salón, presentación de productos, …
 Medicina o veterinaria en movimiento
 Toma de información en la vía pública: salón profesional, callejeo para un sondeo, estadio, …
WINDEV es un entorno completo de desarrollo que integra todas las herramientas necesarias para el ciclo de
realización de una aplicación.
Al contrario que otros lenguajes de desarrollo tradicionales, no se necesitará buscar y reunir los módulos para poder
concebir, probar e instalar una aplicación.
El L5G (Lenguaje de 5ª generación) de WINDEV, el WLangage, le sorprenderá por su simplicidad: unas pocas horas
serán suficientes para aprender el lenguaje, una semana será suficiente para mostrar toda su potencia!.
Al estar en francés, WLangage (disponible también en inglés) le hará ganar tiempo!.
Introducción |17
CAPÍTULO 1
Descubriendo
WINDEV
Capítulo 1 – Descubriendo WINDEV |18

Lección 1.1. Descubra WINDEV
Lo que va a aprender en esta lección…
 Lanzamiento de WINDEV
Tiempo estimado: 5 min

Presentación
WINDEV es un AGL (Atelier de Génie Logiciel – Taller de Ingeniería de Software) completo que le permite desarrollar
aplicaciones Windows (y Linux) en numerosos campos: gestión, industria, medicina, … Las aplicaciones desarrolladas
pueden incluir acceso a las informaciones almacenadas en las bases de datos.
A lo largo de este curso de auto-formación, aprenderá a crear sus aplicaciones (con o sin bases de datos) y a
enriquecerlas utilizando las numerosas funcionalidades propuestas por WINDEV.
Lanzamiento de WINDEV
 Lance WINDEV 21 (si no lo había hecho ya).
 Si no había lanzado nunca WINDEV 21, se abrirá un asistente de bienvenida:
o Si posee una versión antigua de WINDEV, este asistente le permitirá recuperar las configuraciones
existentes.
o Si es un nuevo usuario, este asistente le permitirá parametrizar su entorno. Podrá así elegir la
configuración de su entorno. Podrá así la configuración de pantalla a utilizar y parametrizar los Centros de
Control. Para más detalles, consulte la ayuda en línea.
 Si ya ha lanzado WINDEV 21, identifíquese si fuera necesario. Se abre el entorno de desarrollo. Aparece la
ventana de bienvenida. Esta ventana de bienvenida permite:
o Crear un proyecto
o Abrir un proyecto existente
o Abrir un ejemplo
o Abrir uno de los proyectos del curso de auto-formación.
 Detengámonos un instante en el entorno de desarrollo de WINDEV. Para ello, desde la ventana de bienvenida:
o Clique sobre “Curso de auto-formación”.
o Clique sobre “Aplicación completa (con ventanas)”.
o El proyecto correspondiente se abrirá en el editor.
Entorno de desarrollo
El editor
En entorno de desarrollo de WINDEV está formado por un interface específico y de varios editores que permiten crear
los distintos elementos de sus aplicaciones.
Así, el editor de ventanas permite crear las ventanas, el editor de informes permite crear informes, …
Todos los editores tienen el mismo entorno:

1. Menú del editor, mostrado en forma de cinta (vamos a ver su manipulación en el párrafo siguiente).
2. Editor en curso (aquí el editor de ventanas). Este espacio permite visualizar de forma WY-SIWYG (What
You See Is What You Get – Lo que ve es lo que obtienes) el elemento que se está creando o modificando.
3. Paneles. El interface de WINDEV tiene varios paneles (horizontales y verticales) que permiten acceder
rápidamente a distintos tipos de informaciones. Por ejemplo:
 El panel “Explorador del proyecto” (aquí, mostrado a la derecha) permite listar todos los elementos del
proyecto por categorías.
 El panel de búsqueda (aquí mostrado bajo) permite realizar búsquedas en todo el proyecto y sus elementos.
Si fuera necesario, estos paneles pueden ocultarse rápidamente utilizando la combinación de teclas [CTRL] +
[W].
4. Barra de elementos abiertos. Esta barra permite visualizar rápidamente todos los elementos abiertos. Un
simple clic en el botón correspondiente al elemento hará que se muestre en su propio editor.
La barra de menú (cinta) en detalle
La barra de menú de WINDEV se presenta en forma de cinta. Esta cinta está formada por paneles en los que se
agrupan las distintas opciones de los editores.
Vamos a detallar aquí los distintos elementos importantes de la cinta, así como la manera en que los manipularemos
en este curso.
Los distintos elementos de la cinta

La cinta está formada por tres zonas:
 La zona de los botones, a la izquierda (1).
 La zona de los paneles arriba (2)
 La zona de las opciones (3).
Veamos estas zonas en detalle.

La zona de los botones
La zona de los botones agrupa principalmente los botones de acceso rápido. Estos botones
permiten efectuar las operaciones más corrientes, generalmente comunes a todos los
editores: Guardar, Crear, Abrir, …
Los tres logos arriba de esta zona son igualmente específicos:
 El logo del producto permite mostrar la ventana “A propósito”, los perso-menús (menús
personalizados) y los menús desplegables del antiguo interface de los editores (versión
17 y anteriores).
 Los dos siguientes logos permiten reencontrar las barras de herramientas y los menús
desplegables del antiguo interface de los editores (versión 17 y anteriores).
La zona de los paneles
Los distintos paneles de la cinta permiten acceder a las opciones de los distintos editores para el proyecto en curso.
Varios tipos de paneles están disponibles:
 El panel en curso: La pestaña del panel aparece en blanco y un trazo naranja pálido se muestra arriba de la
pestaña.
 Los paneles contextuales, específicos al elemento en curso: el nombre del panel aparece en azul.
 Los paneles disponibles: su nombre aparece en negro.
La zona de las opciones
En función del panel seleccionado, las opciones que se muestran en la cinta cambian. Hay disponibles varios tipos de
opciones:
 Opciones a marcar
 Botones a clicar
 Botones con flecha que permiten desplegar opciones. Hay dos tipos de botones de flecha:
o Botones de flecha que permiten simplemente desplegar un menú
o Botones de flecha que permiten desplegar un menú (clic sobre la flecha) o efectuar una acción por
defecto (clic sobre el icono del botón).
Las opciones están reunidas por grupos. Cada grupo de opciones tiene un nombre y puede tener un botón de
agrupación . Este botón permite efectuar una acción específica según el grupo en curso: mostrar la descripción
del elemento en curso, mostrar la ayuda, …
En este curso, para designar una opción de menú, hablaremos de paneles y de grupos.
Por ejemplo:
Para mostrar la ayuda, en el panel “Inicio”, dentro del grupo “Ayuda en línea”, clique sobre “Ayuda”.

Lección 1.2. Mi primera ventana
 Como crear una ventana
 Como introducir un texto y mostrarlo

Presentación
Para comenzar a utilizar WINDEV, vamos simplemente a crear algunas ventanas.
Las ventanas permiten mostrar o introducir las informaciones en la pantalla. El usuario puede actuar
Notas
directamente en las ventanas mediante los campos, los botones, …
Algunos ejemplos le permitirán conocer las bases de la programación en WINDEV y le permitirán a continuación
abordar sujetos más completos.
Las lecciones de este primer capítulo le permitirán:
 Crear ventanas sencillas
 Manipular cadenas, numéricos y monetarios
 Manipular fechas y horas.
Apertura del proyecto
 Lance WINDEV 21 (si no lo había hecho ya). Si es necesario, muestre la ventana de bienvenida de WINDEV:
Utilice la combinación de teclas [CTRL]+[>]
 Abra el proyecto “WD Mis Primeras Ventanas”
Para ello, en la ventana de bienvenida, clique sobre “Curso de Auto-formación” y seleccione el primer proyecto
“Mis primeras ventanas (Ejercicio)”.
Astucia: Si la ventana de bienvenida no es visible, en el panel “Inicio”; dentro del grupo “Ayuda en línea”,
despliegue “Guía de Auto-formación” y luego seleccione la opción “Mis primeras ventanas (Ejercicio)”.
En este capítulo, nos concentraremos en la creación de ventanas simples. El proyecto “WD Mis
Importante
Primeras Ventanas” es un proyecto vacío, ya creado. La creación de un proyecto, se abordará en una

próxima lección.
Hay disponible un proyecto corregido. Este proyecto contiene las distintas ventanas creadas en esta
lección. Para abrir el proyecto corregido:
 En la ventana de bienvenida, clique sobre “Curso de auto-formación” y selecciones el proyecto
Corregido
“Mis Primeras Ventanas (Corregido)”.

 En el panel “Inicio”, en el grupo “Ayuda en línea”, despliegue “Guía de auto-formación” y luego
selecciones “Mis primeras ventanas (Corregido).
Mi primera ventana: Introducir y mostrar los datos

Presentación
Esta es la ventana que tendrá que crear:
Esta ventana permitirá al usuario introducir su nombre y mostrar un mensaje de bienvenida con el botón “Mostrar”.
Podrá tener la tentación de decir que esto es muy sencillo, muy básico, pero le aconsejamos que realice esta ventana.
Se arriesga a sorprenderse por la facilidad y la intuitividad del editor de WINDEV. Además esta ventana le permitirá
descubrir los conceptos fundamentales para el seguimiento de este curso.

Creación de la ventana
 Para crear la ventana:
1. Clique sobre en los botones de acceso rápido del menú de WINDEV
2. Aparece la ventana de creación de un nuevo elemento. Esta ventana permite crear todos los elementos que
pueden asociarse a un proyecto.
3. Clique sobre “Ventana”, luego sobre “Ventana”. Aparece el asistente de creación de ventanas.
4. Seleccione “En blanco” en la lista de ventanas “estándar” mostrada a la izquierda. En la lista de plantillas
presentes a la derecha, la plantilla “Elegante” está seleccionada por defecto. Puede elegir cualquier plantilla
de las propuestas en la lista.
En este capítulo, nos concentraremos en la creación de ventanas simples. El proyecto “WD Mis
Primeras Ventanas” es un proyecto vacío, ya creado. La creación de un proyecto, se abordará en una
Nota
próxima lección.
5. Valide. La ventana se crea automáticamente en el editor.
 Vamos a definir las características básicas de la ventana: su nombre y el título que se mostrará en la barra de
título.
Haga doble clic sobre la ventana que acaba de crearse. La ventana de descripción se muestra en la pestaña
“General”. El nombre propuesto por defecto para la ventana es “WIN_SinNombre1”.
Observe bien el nombre de la ventana que WINDEV le propone por defecto: este nombre empieza
por las letras “WIN_”. Este prefijo se añade automáticamente porque el proyecto utiliza una carta de
programación.
La carta de programación permite definir un prefijo para cada tipo de objeto y así identificar
rápidamente el elemento manipulado:
Nota
 Una ventana empieza por “WIN_”

 Un botón empieza por “BTN_”
 Etc.
Si no quiere utilizar esta carta, basta con desmarcarla: En el panel “Proyecto”, en el grupo “Otras
acciones”, despliegue “Carta” y desmarque la opción “Utilizar la carta”.
 Introduzca las siguientes informaciones:
1. El nombre “lógico” de la ventana: sustituya “WIN_SinNombre1” por “WIN_Introducción”.

Este será el nombre con el que se guardará la ventana en el disco (con la extensión .WDW) en el directorio
de fuentes del proyecto. Este nombre se utilizará igualmente en la programación para manipular la ventana.
2. Valide (botón verde). El título aparece en la barra de título de la ventana.
 Guarde la ventana clicando sobre en los botones de acceso rápido. Por defecto:
o El título del elemento corresponde al título que hemos introducido.
o El nombre del elemento corresponde al nombre lógico de la ventana.
o El emplazamiento propuesto corresponde al directorio del proyecto, en el que se agruparán todos los
elementos del proyecto.
 Valide clicando sobre el botón verde.

Introducir y mostrar el valor introducido
Para gestionar la introducción y la visualización del valor introducido, deberá crear:
 Un campo en el que el usuario introducirá su nombre. Este tipo de campo será entonces un “campo de edición”.
 Un botón que permita mostrar el nombre introducido.
 Para crear el campo de edición:
1. En el panel “Creación”, dentro del grupo “Campos habituales”, despliegue “Entrada” (clique sobre la flecha):
Se muestra la lista de campos de entrada propuestos por defecto.

2. Clique sobre “Texto Simple” en la lista de campos. El campo en creación, seguirá entonces el movimiento del
ratón.
3. Desplace el ratón en la ventana hacia la posición donde deberá crearse el campo (por ejemplo, arriba de la
ventana). Para poner el campo en la ventana, basta con hacer un nuevo clic izquierdo del ratón.
4. Haga un clic derecho del ratón sobre el campo que acaba de crear. Se mostrará el menú contextual del
campo. En el menú contextual mostrado, seleccione la opción “Descripción”. La ventana de descripción del
campo de edición se mostrará.
5. Modifique las características del campo introduciendo las siguientes informaciones:

 El campo tiene por nombre “EDT_Nombre” (1).
 El campo tiene como etiqueta “Nombre” (2).
 El campo es de tipo “Texto” (3).
6. Valide la ventana de descripción del campo (botón verde). El campo aparecerá en el editor de ventanas.
 La etiqueta del campo aparecerá truncada en el editor. Para mostrar el campo correctamente:
1. Seleccione el campo (hay que clicar sobre él con el ratón).
2. En el menú contextual (clic derecho), seleccione la opción “Adaptar el tamaño”.
3. El campo se agranda inmediatamente y la etiqueta aparecerá entera.
Observación: también puede agrandarse la zona de entrada del campo:
1. Seleccione el campo.
2. Posicione el cursor del ratón debajo de uno de los puntos situados a la derecha del campo (cuadrado
pequeño). El cursor del ratón se transforma en una flecha.
3. Clique con el botón izquierdo del ratón y mantenga presionado el botón durante el desplazamiento
permitiendo agrandar el campo.
4. Cuando el campo tenga el tamaño deseado, deje de presionar el botón del ratón.
 Para crear el botón “Mostrar”:
1. En el panel “Creación”, dentro del grupo “Campos habituales”, clique sobre .
2. Posicione el campo en la ventana. Clique en el emplazamiento de creación del botón (por ejemplo, a la
derecha del campo de edición).
3. Clique sobre el botón que acaba de crear. El texto mostrado en el botón pasa a modo edición. Introduzca el
texto “Mostrar”. El nombre del botón cambia automáticamente a “BTN_Mostrar”.
4. Podrá ver el nombre del botón:
 En la burbuja de ayuda que aparece cuando se pasa sobre el campo:
 En la barra de mensajes del editor:

 Vamos a mostrar el texto introducido en una caja de diálogo (una mini-ventana propuesta por el sistema). Para
ello, vamos a utilizar nuestra primera función WLangage: la función info.
WLangage es un lenguaje de programación suministrado con WINDEV. Es un lenguaje de quinta

Nota
generación (L5G), que posee órdenes evolucionadas.
1. Seleccione con la ayuda del ratón el botón “Mostrar”.

2. Muestre el menú contextual del campo (clic derecho del ratón).
3. Seleccione la opción “Código”. Esta opción abre el editor de código de WINDEV. Este editor permite introducir
todas las instrucciones WLangage.
El editor de código propone distintos tratamientos para cada tipo de campo. Estos tratamientos
corresponden a los eventos relacionados con el campo.
Así, para el campo “Botón”, se muestran dos tratamientos:
Nota
 Inicialización
 Clic sobre el botón, que se ejecuta cuando el usuario clica en el botón.
Observación: Algunos tratamientos suplementarios pueden añadirse si fuera necesario.
4. En el tratamiento “Clic sobre BTN_Mostrar”, introduzca el siguiente código (no olvide el espacio después de
“días”, porque si no, el nombre aparecerá pegado al texto:
Info (“Buenos días “ + EDT_Nombre)
Observación sobre la ayuda a la introducción: Cuando introduce los dos primeros caracteres, WINDEV propone
todas las palabras del vocabulario WLangage que contienen estos caracteres. La asistencia al desarrollador es muy
potente. No puede equivocarse introduciendo el nombre de un elemento: los errores de sintaxis se minimizan. Basta
con seleccionar la palabra deseada y validar con la tecla [ENTER]. De este modo, podrá concentrarse solo en el
algoritmo.
Es por ello que la carta de programación es muy importante. Todos los elementos manipulados en el
código de la aplicación utilizan el mismo nombre y así pueden ser fácilmente encontrados cuando se
Nota
introduce el código.
Cuando introduce el código en el editor de código, observará que los distintos elementos
introducidos utilizan distintos colores. Esta es la coloración sintáctica. El editor de códigos permite de
este modo identificar rápidamente los distintos elementos manipulados por el código:
Nota
 Las funciones de WLangage aparecen en azul

 Las cadenas de caracteres (entre comillas) aparecen en violeta
 Los nombres de los campos aparecen en cyan
La función Info muestra el mensaje pasado en parámetro. Nuestro mensaje está construido a partir del texto
“Buenos días “ y el valor del campo “EDT_Nombre”. El signo “+” indica una operación llamada “concatenación” entre
dos cadenas.
En este ejemplo, el texto introducido se muestra en una ventana del sistema, pero también se puede
Nota
mostrar en una ventana creada con WINDEV.
 Vamos a guardar la ventana y probarla:

1. Guarde las modificaciones clicando sobre en los botones de acceso rápido (a la izquierda de la cinta) o
con la combinación de teclas [CTRL]+[S].
2. Clique sobre en los botones de acceso rápido (o utilice la tecla [F9].

3. La ventana que acaba de crear se ejecutará. Introduzca su nombre.
4. Clique sobre el botón “Mostrar”.
5. Valide la ventana del sistema que se muestra (clique sobre el botón “OK”).
Todo desarrollador sabe que probar un programa es muy largo, incluso fastidioso. Con WINDEV, en UN CLIC, probará
la ventana, el informe o el procedimiento que está realizando. Es a la vez sencillo y rápido!
 Cierre la ventana de prueba: clique sobre el botón de cierre del sistema (botón “X” situado en la barra de título).
 El editor de WINDEV volverá a aparecer. Cierre el editor de código: en el panel “Inicio”, en el grupo “General”,
clique sobre “Cerrar”.
Mejoras en la ventana
Con esta primera prueba, habrá observado que:
 Su ventana es muy grande.
 Su ventana puede redimensionarse pese a que solo contiene dos campos.
 El nombre introducido se mostrará con el estilo de mayúsculas que se introdujo. Vamos a forzar el uso de una
mayúscula al principio de la palabra.
Vamos a revisar rápidamente el interface de esta ventana.
 Para reducir el tamaño de la ventana en el editor:
1. Clique sobre la ventana: unos punteros aparecen alrededor de la ventana (según la plantilla utilizada, el color
de estos punteros puede ser distinto).
2. Clique sobre el puntero situado bajo a la derecha y reduzca el tamaño de la ventana manteniendo presionado
el botón izquierdo del ratón.
 Para que la ventana no pueda redimensionarse en ejecución:
1. Doble clic sobre la ventana. La ventana de descripción se muestra.
2. En la pestaña “IHM”, desmarque la opción “Redimensionable” (hay que clicar sobre la opción).-
3. Valide.
Profundizaremos en los consejos de interface y de ergonomía en un próximo capítulo de este curso.

Nota
 Para visualizar el resultado en ejecución, vuelva a lanzar la prueba de esta ventana.

 Regrese al editor cerrando la ventana de prueba.
 Vamos ahora a forzar el uso de una mayúscula en la introducción y la visualización del nombre.
Por defecto, los caracteres se introducirán en mayúsculas o minúsculas según la posición de la tecla
[CAPSLOCK] del teclado. Este tipo de introducción puede generar problemas en una búsqueda, por
ejemplo.
Nota
WINDEV propone la gestión de una máscara de introducción para un campo. La máscara de

introducción permite dar formato al valor introducido, automáticamente y sin ninguna línea de
código.
 Para modificar la máscara de entrada:

1. Doble clic sobre el campo “Nombre”. Se muestra la ventana de descripción del campo.
2. En la pestaña “General”, despliegue la lista “Máscara de entrada” y seleccione “Primera letra en mayúscula”.

3. Valide la ventana de descripción del campo.
4. En el editor, el nombre de la máscara aparecerá inmediatamente en el campo.
 Vuelva a lanzar la prueba de esta ventana para visualizar el resultado en ejecución.
Acaba de crear rápidamente y con éxito su primera ventana. Siguiendo el curso vamos a descubrir nuevos conceptos
de WINDEV.
 Valide el mensaje y cierre la ventana de prueba (clique sobre el aspa arriba a la derecha de la ventana). El editor
reaparecerá.
 Cierre la ventana “WIN_Entrada” mostrada en el editor: en el panel “Inicio”, dentro del grupo “General”, clique
sobre “Cerrar”.
Un ejemplo para cada tipo de campos.

En esta lección, hemos utilizado dos tipos de campos: un campo de edición y un botón.
WINDEV propone más de una cuarentena de campos. Para descubrir el uso de cada tipo de campo,
hay a su disposición dos ejemplos unitarios.
 Para abrir un ejemplo unitario:
1. Muestre la ventana de bienvenida de WINDEV (teclas [CTRL]+[<].
2. Clique si es necesario sobre “Abrir un ejemplo”.
Nota
3. La lista de ejemplos completos, didácticos y unitarios se muestra.

4. En la categoría “Ejemplos unitarios”, seleccione el ejemplo deseado (por ejemplo “El campo
Árbol) y haga doble clic sobre su nombre: la ventana correspondiente se abre en el editor.
Observación: Para simplificar, todos los ejemplos unitarios correspondientes a los campos
empiezan por las palabras “El campo “. Puede introducir estas palabras en el campo de búsqueda de
la ventana de bienvenida.
 Cierre el proyecto: En el panel “Inicio”, dentro del grupo “General”, despliegue “Cerrar” y seleccione “Cerrar el
proyecto”.

Lección 1.3. Ventanas más evolucionadas
 Como realizar un cálculo
 Como crear una ventana mostrando la fecha y la hora en tiempo real
 Crear una ventana con menú

Presentación
En la lección anterior, hemos visto ya como introducir y mostrar un texto.
En esta lección, vamos a crear las siguientes ventanas:
 Una ventana de cálculo
 Una ventana que muestra la fecha y la hora en tiempo real.
 Un menú para reunir las ventanas creadas previamente.
Estas ventanas se crearán en el proyecto “WD Mis Primeras Ventanas” que ya hemos manipulado en la lección
anterior.
 Abra nuevamente el proyecto “WD Mis Primeras Ventanas”.
Para ello, en la ventana de bienvenida, clique sobre “Curso de auto-formación” y seleccione el primer proyecto
“Mis primeras ventanas (Ejercicio)”.
Astucia: si la ventana de bienvenida no se ha mostrado, en el panel “Inicio”, dentro del grupo “Ayuda en línea”,
despliegue “Guía de Auto-formación” y luego seleccione la opción “Mis primeras ventanas (Ejercicio)”.
Hay disponible un ejemplo corregido. Este proyecto contiene las distintas ventanas creadas en esta
lección. Para abrir el proyecto corregido:
Corregido
 En la ventana de bienvenida, clique sobre “Curso de auto-formación” y seleccione el proyecto

“Mis primeras ventanas (Corregido)”.
 En el panel “Inicio”, dentro del grupo “Ayuda en línea”, despliegue “Guía de Auto-formación” y
luego seleccione “Mis primeras ventanas (Corregido)”.
Gestionar la introducción de un numérico para hacer un cálculo

En esta nueva ventana, vamos a continuación a:
 Crear dos campos de entrada numéricos.
 Calcular y mostrar el valor TTC del importe HT introducido.
El resultado del campo se mostrará en el campo “Precio TTC”.
Esta ventana es la siguiente:
Dar formato
 Cree una nueva ventana en blanco:
1. Clique sobre en los botones de acceso rápido. La ventana de creación de un nuevo elemento se mostrará:
Clique sobre “Ventana” y luego sobre “Ventana”. Se mostrará el asistente de creación de ventanas.
2. Seleccione en “En blanco” y la plantilla “Elegante”.
3. Valide. La ventana se creará automáticamente en el editor.
4. Haga un clic sobre el botón derecho en la ventana y seleccione la opción “Descripción”.
5. Seleccione la pestaña “General”. Indique el nombre de la ventana “WIN_Calculo” y el título “Ejemplo de
cálculo”. Valide la ventana de descripción.
6. Guarde la ventana: Clique sobre en los botones acceso rápido.
7. Valide las informaciones mostradas en la ventana para guardar clicando sobre el botón verde.

Es muy importante guardar la ventana en su creación
Guardar la ventana permite para la continuación de WINDEV:
Nota
o Proponer el nombre de los campos automáticamente en el código.

o Proponer renombrar automáticamente los campos en el código.
 Para crear el campo de edición correspondiente al precio HT:

1. En el panel “Creación”, dentro del grupo “Campos habituales”, despliegue “Introducción” (clique sobre la
flecha). Se muestra la lista de los distintos campos de introducción disponibles. Seleccione el campo
“Monetario” y posicione el campo en la ventana.
2. Haga un clic derecho sobre el campo y seleccione la opción “Descripción”.
3. En la ventana de descripción:
o Introduzca el nombre del campo “EDT_PrecioHT”.
o Introduzca el texto “Precio HT”.
o Seleccione el tipo “Monetario + Euro”.
4. Valide.
5. Guarde la ventana.
El cálculo del importe TTC se efectuará a cada modificación del campo que contiene el importe libre de tasas.
 Para realizar el cálculo del importe TTC:
1. Muestre el código del campo “EDT_PrecioHT” (Opción “Código” del menú contextual del campo). Los distintos
tratamientos asociados por defecto al campo de edición aparecerán:
o Inicialización: ejecutado al abrir la ventana
o Entrada en el campo: ejecutado cuando entra el cursor de introducción en el campo.
o Salida del campo: ejecutado cuando se cambia de campo (tecla [TAB], cambio de campo por el ratón, …)
o A cada modificación del campo: Ejecutado cuando cambia el contenido del campo (entrada o pulsación de
una letra, por ejemplo).
2. En el tratamiento “A cada modificación “, introduzca el siguiente código:
// TVA fijado a 20% para el ejemplo
// Esto podría ser una variable cualquiera proveniente de una base de datos
EDT_PrecioTTC = EDT_PrecioHT + 1.20
3. Cierre la ventana de código (cruz de cierre de la ventana de código).
Prueba de la ventana
 Probar la ventana:
1. Clique sobre en los botones de acceso rápido.

2. Introduzca un valor en el campo “Precio HT”. El resultado aparece inmediatamente en el campo “Precio TTC”
3. Cierre la ventana de texto.

Uso de un campo Combo para proponer varias posibilidades
En la ventana que acabamos de crear, el cálculo tiene en cuenta una tasa fija de TVA.
Para complicar un poco nuestro ejemplo, vamos a ofrecer la posibilidad de seleccionar la tasa de TAV en una lista
desplegable (llamada “combo”).

 Para crear el campo Combo de selección de TVA:
1. En el panel “Creación”, dentro del grupo “Campos habituales”, clique sobre “Combo” y luego clique en la
ventana, en la posición donde deberá crearse el campo (al lado del campo “Precio HT”).
2. Se muestra el asistente de creación de un campo Combo. Este asistente permite definir sencillamente las
principales características del campo.
3. Seleccione la opción “Rellenar el combo por programación o introducir directamente una lista de valores”.
4. Muestre la pantalla siguiente.

5. Conserve las opciones propuestas por defecto. Muestre la pantalla siguiente.
6. En la pantalla titulada “Contenido inicial”, introduzca la lista de posibles valores de TVA:
 5.5
 Pulse la tecla [ENTER]
 10
 Pulse la tecla [ENTER]
 20
7. Muestre la siguiente pantalla y dele un nombre al campo (COMBO_TVA) y un texto (TVA).

8. Valide.
9. Modifique si hace falta el tamaño de la ventana para que el campo Combo aparezca al lado del campo de
edición que pide el precio HT.
Vamos ahora a cambiar el código del campo “Precio HT” para tener en cuenta el importe de TVA seleccionado en el
campo Combo.
 Para tener en cuenta el importe de TVA seleccionado:
1. Seleccione el campo “Precio HT”.
2. Muestre el código del campo “Precio HT” (opción “Código” del menú contextual).
3. Modifique el código de la forma siguiente:
EDT_PrecioTTC = EDT_PrecioHT * (1+Val(Combo_TVA..DisplayedValue)/100
Este código calcula el importe TTC utilizando el valor seleccionado en el campo Combo (dato conseguido con
la propiedad ..DisplayedValue). Al ser el contenido del campo combo una cadena de caracteres, la función
Val permite obtener un valor numérico para calcular el importe TTC.
WLangage está formado por funciones y propiedades. Las funciones pueden esperar parámetros y
devolver los resultados. Las propiedades se aplican directamente a los campos con la sintaxis:
<Nombre del campo>..<Nombre de la propiedad>
Nota
En nuestro ejemplo, la propiedad ..DisplayedValue del campo Combo_TVA es la que se utiiza.

En cualquier momento, se puede consultar la ayuda en línea de una función con la tecla [F1]. Para
más detalles sobre la ayuda en línea, consulte “¿Cómo acceder a la ayuda en línea?”.
4. Pruebe su ventana ( en los botones de acceso rápido):

 Introduzca un valor en el campo “Precio HT”.
 El resultado aparece inmediatamente en el campo “Precio TTC” en función del TVA seleccionado.
 No obstante, si cambia la tasa de TVA, el valor del campo “Precio TTC” no se modifica. Vamos a corregir ese
problema.
5. Cierre la ventana de prueba. Se muestra nuevamente el editor de código.
 Para tener en cuenta el importe de TVA cuando se cambia el valor del TVA en el combo, hay que copiar el código
del tratamiento “A cada modificación” del “Precio HT” en el tratamiento “Selección de una línea” del combo
“Combo_TVA”:
1. Muestre el código del campo “Precio HT” (opción “Código” del menú contextual por ejemplo).
2. Seleccione el código que hay en el tratamiento “A cada modificación de EDT_PrecioHT”.
3. Utilice las teclas [CTGRL]+[C].
4. Muestre el código del campo “Combo_TVA”.
5. Posiciónese en el tratamiento “Selección de una línea” y utilice las teclas [CTRL]+[V].
6. Pruebe su ventana ( en los botones de acceso rápido) y seleccione los distintos valores en el campo
Combo.

Ahora nuestra ventana ya funciona correctamente. Pero el mismo código se utiliza en dos sitios distintos! ¿Cómo
gestionar las modificaciones y su información? Lo más sencillo es utilizar un procedimiento y es lo que vamos a
realizar ahora.
 Cierre la ventana de prueba para volver al editor de código.
Creación y uso de un procedimiento.
La creación de un procedimiento a partir de un código existente, es muy sencilla con WINDEV: una opción del menú
se encarga de todo.
 Para crear un procedimiento de cálculo del TVA:
1. Seleccione el código que hay en el tratamiento “Selección de una línea” del “Combo_TVA”.
2. Muestre el menú contextual del código seleccionado (clic derecho del ratón).
3. Seleccione la opción “Nuevo .. Crear un procedimiento local que contenga el código seleccionado”.
4. Proporcione un nombre al procedimiento a crear: CalculoTVA. Valide.
5. El procedimiento local “CalculoTVA” se ha creado automáticamente con el código seleccionado. Su código se
ha sustituido por una llamada al procedimiento “CalculoTVA()”.
6. Para finalizar, hay que sustituir el segundo código de cálculo de TVA (está en el tratamiento “A cada
modificación” del campo “Precio HT”) para que llame al procedimiento “CalculoTVA()”.
7. Ahora sí que está terminado. Puede guardar y probar su ventana para verificar que todo funcione
correctamente.
Mostrar la fecha y la hora en tiempo real

Presentación
Vamos a realizar la siguiente ventana:
Esta ventana muestra la fecha y la hora. Sencillo! No obstante, la hora se actualiza en tiempo real. Para ello, WINDEV
pone a su disposición los “Timers”.
Un timer permite ejecutar en paralelo una tarea que deberá lanzarse periódicamente (adquisición de datos en tarea
de fondo, refresco automático de datos, lanzamiento de un programa a una hora determinada, …).
Pero empecemos por crear nuestra ventana!
 Cree una nueva ventana en blanco:
1. Clique sobre en los botones de acceso rápido. Se abre la ventana de creación de un nuevo elemento:
clique sobre “Ventana” y luego sobre “Ventana”. Aparece el asistente de creación de ventanas.
2. Seleccione “En blanco” en la lista de ventanas “estándar” mostradas a la izquierda. En la lista de plantillas que
hay a la derecha, está propuesta automáticamente la plantilla “Elegante”.
3. Valide. La ventana se crea automáticamente en el editor.
 Guarde la ventana clicando sobre en los botones de acceso rápido. En la ventana que aparece, introduzca:
 El título del elemento: “Actualización de la hora con el timer”
 El nombre del elemento: “WIN_Timer”.
Valide (botón verde). La ventana se guarda y el título aparecerá en la barra de título.

Ahora vamos a añadir un campo de tipo Date en nuestra ventana para mostrar la fecha del día.
 Para crear el campo de edición de tipo Date:
1. En el panel “Creación”, dentro del grupo “Campos habituales”, despliegue “Entrada” (clique sobre la flecha).
La lista de los distintos campos de entrada disponibles aparecerá.
2. Seleccione el campo “Fecha” (sin el pequeño calendario) y posicione el campo en la ventana.
3. Haga un clic derecho sobre el campo y seleccione la opción “Descripción” en el menú contextual.
4. En la pestaña “General” de la ventana de descripción:
 Introduzca el nombre del campo “EDT_Dia” (1).

 Introduzca el texto “Hoy estamos a: “ (2)
 Este campo es de tipo “Date”: este campo permite mostrar e introducir una fecha (3).
 Vamos a definir las distintas máscaras asociadas a este campo (4).
Hay disponibles dos tipos de máscaras:

 Máscara de visualización: Corresponde al formato utilizado cuando se muestra el valor en el
campo.
Nota
 Máscara de introducción: Corresponde al formato utilizado cuando el usuario introduce el

valor en el campo.

1. Conserve la máscara de introducción seleccionada (“Fecha definida por el proyecto”).
Por defecto, la máscara de entrada del campo corresponde a la máscara numérica definida por el
proyecto. Esta información se selecciona en la pestaña “Idiomas” de la descripción del proyecto. Para
mostrar la descripción del proyecto, en el panel “Proyecto”, dentro del grupo “Proyecto”, clique sobre
“Descripción”.
Nota
De este modo, la misma máscara se utiliza automáticamente en todos los campos numéricos de la
aplicación. Esta funcionalidad es muy útil en las aplicaciones multi-lenguaje.
2. Seleccione la máscara de visualización “DDDD DD MMMMM AAAA”. Esta máscara de visualización permite
mostrar la fecha en una forma literal “Martes, 16 Julio 2015”.
3. Este campo permite solamente mostrar la fecha. No se podrá efectuar ninguna entrada. Para ello, bastará con
indicar que el campo está en modo “Solo visualización” en la pestaña “IHM” de la ventana de descripción del
campo.
4. Valide.
 La máscara que hemos elegido permite mostrar la fecha con todas las letras. Para evitar mostrar una fecha
truncada, vamos a agrandar la anchura del campo:
1. Seleccione el campo de edición.
2. Agrande el campo en anchura con la ayuda de las trazadas de redimensionamiento.
Para mostrar la fecha del día en el campo de tipo Data, hay que inicializarlo con esta fecha. Esta operación se realiza
por programación.
 Muestre el código asociado al campo que acaba de crear:
1. Seleccione el campo de edición: hay que clicar bajo con el ratón.
2. Muestre el menú contextual (clic derecho del ratón) y seleccione la opción “Código”. Aparecerá el editor de
código.
3. En el tratamiento “Inicialización de EDT_Dia”, introduzca el siguiente código:
MySelf = Today()
Examinemos el código de inicialización:
 MySelf es una palabra clave que representa el nombre del campo en curso. MySelf permite introducir un
código local (tratamiento de un campo, …) o global (procedimiento global, clase, …) independiente del campo
en curso.
 Today es una función WLangage que permite (como su nombre indica) obtener la fecha del día.
 El signo “=” permite afectar el campo en curso con el resultado de la función WLangage Today.
 Guarde la ventana y pruébela (clicando sobre y luego sobre en los botones de acceso rápido).
El campo de edición está correctamente inicializado con la fecha del día.

Vamos ahora a añadir un nuevo campo de edición que permite mostrar una hora en tiempo real.
 Para crear el campo de edición de tipo hora:
1. En el panel “Creación”, en el grupo “Campos habituales”, despliegue “Entrada” (clique sobre la flecha). Se
mostrará la lista de los distintos campos de entrada disponibles.
Seleccione el campo “Hora” y posicione el campo en la ventana.
2. Haga un clic derecho sobre el campo y seleccione la opción “Descripción”.
3. En la pestaña “General” de la ventana de descripción:
 Introduzca el nombre del campo “EDT_Hora”.
 Introduzca el texto “Son las:”.
 La máscara de visualización seleccionada por defecto, muestra las horas, los minutos y los segundos. No
vamos a tocarla.

4. Como para el campo Date, este campo permitirá solamente mostrar la hora. Seleccione la opción “Solo
visualización” en la pestaña “IHM” de la ventana de descripción del campo.
5. Valide.
 Al igual que para el campo Date, vamos a inicializar el campo Hora con la hora actual.
1. Muestre el código asociado al campo que acabamos de crear:
 Muestre el menú contextual del campo (clic derecho).
 Seleccione la opción “Código”.
Para mostrar los tratamientos asociados a un campo, también se puede:

1. Seleccionar el campo.
Nota
2. Utilizar la tecla [F2].
3. En el tratamiento “Inicialización de EDT_Hora”, introduzca el siguiente código:

MySelf = Now()
La función Now es una función WLangage que permite (como su nombre indica), obtener la hora actual.
 Guarde la ventana y pruébela (clicando sobre y luego sobre en los botones de acceso rápido). La fecha y
la hora se muestran. Ahora vamos a actualizar la hora en el transcurso del tiempo.
Establecimiento del timer
Para actualizar el campo Hora, vamos a llamar cada segundo a un procedimiento que modificará el campo Hora con la
hora actual. Este procedimiento será local de la ventana: en efecto, este procedimiento solo será llamado en esta
ventana.
En la ventana de cálculo, ya hemos creado un procedimiento a partir de un código existente. Ahora, vamos a detallar
los distintos pasos de creación de un procedimiento.
Observación: Siguiendo este curso, veremos en detalle los distintos tipos de procedimientos.
 Para crear un procedimiento local:
1. Seleccione en el panel “Explorador del proyecto” el nombre de la ventana “WIN_Timer”.
2. Clique sobre l flecha a la izquierda para mostrar los distintos elementos.
3. Clique sobre “Procedimientos locales”. Se seleccona la carpeta.
4. En el menú contextual de “Procedimientos locales” (clic derecho), seleccione la opción “Nuevo procedimiento
local”.
5. En la ventana que aparece, indique el nombre del procedimiento “PonerEnHora” y clique sobre el botón
“Añadir”.
6. El procedimiento aparece en el editor de código. Introduzca el siguiente código:
EDT_Hora = Now ()

7. Este código permite actualizar el campo mostrando la hora. Ahora vamos a llamarla cada segundo utilziando
el timer.
 Para establecer el timer:
1. Regrese a la ventana “WIN_Timer”. Podrá por ejemplo clicar sobre el botón “WIN_Timer” debajo.
2. Clique en la ventana de inicio de la ventana (fondo gris). Muestre el menú contextual (clic derecho) y
seleccione la opción “Código”.
3. Se muestran los distintos tratamientos asociados a la ventana.
4. En el tratamiento “Fin de inicialización de WIN_Timer”, introduzca el siguiente código:
TimerSys (PonerEnHora, 100, 1)
5. Este código permite indicar que el procedimiento “PonerEnHora” se llamará todos los segundos(100
representa las centésimas de segundo).
 Guarde la ventana y pruébela (clicando sobre sobre y luego sobre en los botones de acceso rápido).
Hemos visto aquí la creación de un timer por programación. También puede crearse un timer
automáticamente desde el editor de código. Para más detalles, consulte la ayuda en línea (palabra
Nota
clave: Procedimientos automáticos).
 Cierre la ventana de prueba para volver al editor.

Creación de un botón para abandonar la ventana.
En una ventana siempre hay un botón o una opción para abandonar la ventana. Desde luego, si no añade ningún
botón u opción, siempre tiene la posibilidad de cerrar la ventana clicando sobre el icono “X” de la barra de título, pero
esto no es muy fácil de utilizar.
 Para crear el botón de cierre:
1. En el panel “Creación”, dentro del grupo “Campos habituales”, despliegue “Botón” (clique sobre la flecha). Se
mostrará la lista de botones predefinidos.
2. Clique sobre el botón de tipo “Cerrar”:
3. Clique en la ventana en la posición donde se creará el botón (por ejemplo, bajo a la derecha).
 Verifiquemos la descripción del botón creado:
1. Muestre la descripción del campo (opción “Descripción” del menú contextual o doble clic en el botón).
2. En la pestaña “General”:
 El nombre del botón respecto a la carta de programación.
 Una acción está asociada al botón: esta acción permite cerrar la ventana.
 Las imágenes correspondientes a la plantilla utilizada se asociarán automáticamente al botón.
3. En la pestaña “IHM”, el botón es de tipo “Abandonar”. El código del botón se ejecutará cuando se utilice la
tecla [ESC].
WINDEV propone varios tipos para los botones: Ayuda, Normal, Validación, Interrupción y
Abandonar.
Para más detalles sobre los distintos tipos de botones:
Nota
 Consulte la ayuda en línea (palabra clave: Campo botón, Tipo de botón).

 Consulte el ejemplo unitario: El campo botón.
4. Cierre la ventana de descripción del botón.

 Puede desplazar fácilmente el botón de cierre:
1. Clique sobre el botón de cierre con el botón izquierdo del ratón.
2. Manteniendo pulsado el botón del ratón, haga desplazarse el ratón (y el campo) al emplazamiento deseado.
 Nuestra ventana está finalizada.
Vuelva a lanzar la prueba de la ventana para visualizar el resultado en ejecución.
Creación de una ventana con un menú

Hasta ahora, hemos realizado algunas ventanas. Vamos ahora a crear la ventana principal de este ejemplo. Esta
ventana tendrá el menú que organizará el acceso a las distintas ventanas de la aplicación.
WINDEV permite crear menús desplegables.

Un menú siempre está asociado a una ventana. Así, para crear un menú, primero hay que crear la ventana que
mostrará este menú.
Describir el menú
 Para crear una ventana que tiene un menú:
1. Clique sobre en los botones de acceso rápido para crear una nueva ventana.
2. La ventana de creación de un nuevo elemento se muestra: clique sobre “Ventana” y luego sobre “Ventana”.
3. En el asistente que se muestra, seleccione “En blanco” y valide.
4. De un nombre y un título a esta ventana. Esta ventana tendrá por nombre “WIN_Menu” y como título “Menú
principal”.
6. En el panel “Ventana”, dentro del grupo “Barras y menús”, despliegue “Menú principal” y seleccione la opción
“Añadir el menú principal”.
7. Un menú se inserta en la ventana bajo la barra del título. Este menú solo contiene una opción que se llama
“Menú”.
Observación: Cada opción del menú se introduce directamente en el menú. Cada opción comporta una letra de
llamada. Esta letra de llamada permite acceder directamente a la opción con la combinación de teclas [ALT] + letra.
El carácter “&” deberá entonces preceder a la letra de llamada (Por ejemplo “&Ventanas”; la letra de llamada será la
“V”).
 Para crear una opción de menú y para modificarla, hay que utilizar el menú contextual del menú o de la opción
del menú. Para mostrar el menú contextual del menú:
1. Seleccione el menú.
2. Clique con el botón derecho del ratón.
3. Se muestra el siguiente menú contextual:

Varias elecciones pueden realizarse. Las principales opciones de gestión de menú son:
 “Descripción de la opción” para modificar el texto de la opción y la letra de llamada.
 “Código” para introducir el código fuente correspondiente al tratamiento a ejecutar cuando se realiza un clic
sobre esta opción.
 “Añadir después” para añadir una opción al menú después de la opción actual.
 “Añadir antes” para añadir una opción al menú anterior a la opción actual.
 “Transformar para desplegar un sub-menú” para añadir en la opción un sub-menú (arborescencia).
 Vamos a realizar el siguiente menú:
 Para el menú “Fichero .. Salir”:

1. Muestre la opción “Menú” insertada por defecto y cambie el texto a “Fiche&ro”. Valide la ventana de
descripción.
WINDEV propone varios tipos para los botones: Ayuda, Normal, Validación, Interrupción y
Abandonar.
Para más detalles sobre los distintos tipos de botones:
Nota
 Consulte la ayuda en línea (palabra clave: Campo botón, Tipo de botón).

 Consulte el ejemplo unitario: El campo botón.
2. En el menú contextual de la opción “Fichero”, seleccione la opción “Transformar para desplegar un sub-
menú” e introduzca “Salir”.
 Para el menú “Ventanas”:
1. Seleccione la opción “Fichero”.
2. En el menú contextual de la opción “Fichero”, seleccione la opción “Añadir después” e introduzca
“&Ventanas”.
3. En el menú contextual de la opción “Ventanas”, seleccione “Transformar para desplegar un sub-menú” e
introduzca “&Entrada de un texto”.
4. En el menú contextual de la opción “Entrada de un texto” seleccione “Añadir después” e introduzca “&Hora en
tiempo real”.

5. En el menú contextual de la opción “Hora en tiempo real”, seleccione “Añadir después” e introduzca “Cálculo
del &TVA”.
 Ahora, añadiremos el atajo “[ALT]+[F4] para la opción “Salir”.
1. Seleccione la opción “Salir”
2. Muestre la descripción de la opción (opción “Descripción de la opción” del menú contextual).
3. En la zona “Atajo teclado”, despliegue el combo, recorra los elementos y seleccione “F4”. Luego, marque la
tecla “[ALT]”.
4. Valide
Cuando se han introducido todas las opciones del menú, visualice la ventana: clique sobre “Vista previa” en la pestaña
“Modificación” o utilice la combinación de teclas [SHIFT]+[F9].
Este modo de visualización permite ver el aspecto final del menú sin ejecutar el código. Para cerrar esta ventana,
utilice el botón “Cerrar” de la vista previa.
En sus aplicaciones, le aconsejamos que siga el estándar de los menús de Windows. Asegúrese en
particular de los siguientes puntos:
 Cada opción del menú principal deberá proponer al menos una sub-opción.
 La primera letra de cada opción deberá estar en mayúscula, lo mismo cuando no sea la letra
de llamada. La letra de llamada deberá estar subrayada (utilice el carácter “&”).
 Si una opción del menú llama a una ventana con parametrización antes de ejecutar la opción
Nota
elegida, termine el texto con tres puntos (…).

 La opción “Salir” deberá ser la última sub-opción de la primera opción de la barra de menú
(ejemplo: “Fichero .. Salir”).
 Si hay una opción de ayuda, deberá encontrarse al final de la primera línea de menú (la
opción más a la derecha).
Asociar un código a las opciones del menú
Cada opción terminal del menú deberá tener un tratamiento asociado. Clásicamente, este tratamiento abre una
ventana, pero no importa qué tipo de tratamiento pueda ser ejecutado.
 Vamos a introducir el código de las distintas opciones:
1. Seleccione la opción “Salir”. Esta opción permitirá salir de la aplicación. En el menú contextual, seleccione la
opción “Código”. En la ventana de código que se abre, introduzca el siguiente código:
2. Cierre a continuación la ventana de código. Aparecerá la ventana en curso de edición.

3. En la ventana, seleccione la opción de menú “Entrada de un texto”. Esta opción permitirá abrir la ventana
“WIN_Entrada”. En el menú contextual, seleccione la opción “Código”. En la ventana de código que se abre,
introduzca el siguiente código:
4. Cierre la ventana de código.

5. Repita esta operación para la opción “Hora en tiempo real” e introduzca el siguiente código:
6. Repita esta operación para la opción “Cálculo del TVA” e introduzca el siguiente código:
Ya lo habrá deducido: la función Open permite abrir una ventana para efectuar una introducción. La función Close
en cuanto a ella, cierra la ventana en curso.

Si la ventana que contiene el menú es la primera ventana mostrada por la aplicación, el cierre de la ventana que
contiene el menú (por la opción “Fichero .. Salir” en nuestro ejemplo) equivale a cerrar la aplicación.
En este código, las funciones WLangage utilizadas son en francés. Si está más familiarizado con la
lengua de Shakespeare, puede visualizar e introducir el código en versión inglesa: en el panel
Nota
“Código”, dentro del grupo “Lenguas”, despliegue “Convertir el código” y seleccione “Convertir al
inglés”.
 Guarde y pruebe la ventana. Cuando la pruebe:

 Seleccione una de las opciones del menú. Cierre la ventana que se abre.
 Clique sobre la opción “Fichero .. Salir” para cerrar el programa.
Manipular las opciones de menú por programación

WLangage ofrece distintas funciones y propiedades que permiten manipular las opciones del menú.
Así se pueden añadir por programación menús, opciones de menú, separadores, o incluso clonar una
Nota
opción de menú.
Las propiedades permiten conocer si una opción está o no visible, marcada o no, …
Para más detalles, consulte la ayuda en línea (Palabra clave: “Menú”).
WINDEV: Conceptos básicos y terminología

Después de la práctica, retomemos un poco de teoría para abordar los conceptos básicos de WINDEV y la
terminología específica de WINDEV.
Conceptos básicos
WINDEV permite crear sencillamente una aplicación. Pero ¿qué cubre exactamente el término Aplicación?
Una aplicación es una herramienta que permite realizar tareas, acciones automáticamente. Una aplicación está
formada por un programa ejecutable (o un conjunto de programas ejecutables), de librerías, de ficheros de datos, …
Un programa ejecutable es un fichero compuesto de elementos directamente manipulables por el usuario (ventanas,
informes impresos, …). Esto es lo que lanza el usuario final de una aplicación.
Para crear un ejecutable, WINDEV propone crear un proyecto. Un proyecto interconecta entre ellos los distintos
elementos del programa y los organiza. Es a partir del proyecto desde donde podrá crearse el programa ejecutable.
Si su aplicación manipula datos, WINDEV permite definir la estructura de la base de datos mediante el análisis. El
análisis WINDEV contiene la descripción de los ficheros (llamados comúnmente “Tablas” en numerosas bases de
datos). Estos ficheros contendrán los datos de las aplicaciones.
La descripción de los ficheros de datos en el análisis no implica su creación. Los ficheros de datos
Nota
solamente se crean físicamente cuando se ejecuta la aplicación.
Uno o varios proyectos WINDEV pueden estar relacionados con el mismo análisis. En este caso, se habla de análisis
compartido. Por ejemplo, una aplicación de gestión comercial puede estar dividida en varios módulos ejecutables.
Cada módulo utiliza el mismo análisis (y en ejecución, cada ejecutable puede igualmente utilizar los mismos ficheros
de datos).

Terminología
Como acabamos de ver, un proyecto WINDEV (relacionado si es necesario con un análisis) permite crear una
aplicación. Antes de comenzar realmente a trabajar con WINDEV, recordemos los términos utilizados en WINDEV. En
efecto, si ha trabajado ya con otras herramientas, numerosos términos son específicos de WINDEV y no cubren todos
la misma realidad que en otros softwares.
En el análisis, los términos utilizados son los siguientes:
 Fichero: El análisis permite describir la estructura de los ficheros de la base de datos. El término “Fichero”
corresponde en algunas bases de datos a “una tabla”.
En WINDEV, el término “Tabla” se reserva para designar a un objeto gráfico que permite visualizar el contenido
de un fichero de datos en forma de tablero, y/o introducir las líneas. Por ejemplo, una tabla puede permitir la
introducción del detalle de un pedido.
 Registro: Un registro en ocasiones también se llama línea. El registro de un fichero de datos corresponde al
conjunto de las rúbricas definidas por el fichero.
 Rúbrica: en el análisis, el término rúbrica designa una zona de un fichero de datos. El conjunto de las rúbricas
de un fichero de datos permite definir la estructura de un registro.
 Clave/Índice: Con WINDEV y su base de datos HFSQL, la noción de índice está relacionada con la noción de
clave. La noción de clave forma parte de las características de una rúbrica. Las claves permiten acelerar los
accesos a los datos o facilitar el recorrido de los ficheros de datos. En WINDEV, si un fichero de datos HFSQL
tiene varias rúbricas clave, en ejecución, solo se creará un fichero índice.
En las ventanas y los informes, los términos utilizados son los siguientes:
 Ventana: Las ventanas permiten mostrar o introducir por pantalla las informaciones. Las ventanas son también
llamadas “pantallas” o “Cajas de diálogo”. El usuario puede interactuar directamente en las ventanas por medio
de campos, botones, …
 Informe: Los informes permiten obtener una vista personalizada de informaciones. Estas informaciones pueden
provenir de la base de datos, de fichero texto, de campos existentes en las ventanas, … Los informes se pueden
visualizar en la pantalla, imprimirse en papel, generarse en PDF o HTML, …

 Campo: La palabra “Campo” es el término utilizado para definir los distintos objetos gráficos mostrados en una
ventana o en un informe.
 Plantilla: La plantilla permite definir el aspecto de la aplicación: apariencia visual de las ventanas, de los
botones, de los campos, …
 Estilo: El estilo agrupa las características gráficas de un elemento: imagen de fondo, borde, fuente, … Los
estilos de los distintos elementos que constituyen el interface de una aplicación WINDEV se agrupan en una hoja
de estilos.
En una aplicación, la entidad “NombreCliente” puede corresponder:

 Al nombre de un campo de una ventana.
Importante
 Al nombre de un campo de un informe.

 A la rúbrica de un fichero de datos.
 A una variable definida por el programador.

Lección 1.4. Bases de programación
 Los distintos tipos de variables.
 Instrucciones básicas de WLangage.
 Operadores básicos de WLangage.
 Procedimientos y funciones.
 Tratamiento de cadenas, numéricos y monetarios
 Tratamiento de fechas y horas
Tiempo estimado: 1 hora

Introducción
En la lección anterior, hemos manipulado un poco el editor de código de WINDEV y su lenguaje, el WLangage. Esta
lección nos permitirá volver sobre las bases de la programación en WLangage, presentando los siguientes sujetos:
 Declaración de los distintos tipos de variables
 Instrucciones básicas de WLangage
 Procedimientos y funciones
 Tratamiento de cadenas
 Tratamiento de numéricos
 Tratamiento de fechas y horas
Declaración de distintos tipos de variables

Distintos tipos de variables
WINDEV propone una gran variedad de tipos de variables (booleanas, enteros, reales, monetarios, cadenas, fecha,
hora, duración, fechahora, variante, tablero, estructura, …).
La sintaxis a utilizar para declarar una variable es muy sencilla: hay que indicar el nombre de la variable y su tipo:
NombreVariable is TipoVariable
Algunos ejemplos:
Indice is integer
NombreProveedor is string
TablaPrecios is array [10] currency
I, J, K are integer
Contador is integer = 120
B1 is Boolean = False
Para más información de todos los tipos de variables disponibles (tipos simples, tipos avanzados, …), consulte la
ayuda en línea (palabra clave: “Tipos de datos”).
Declaración de variables y su alcance

WLangage permite manipular dos tipos de variables:
 Variables globales
Variables localesLas variables globales pueden ser globales al proyecto o a una ventana. Basta con declarar
estas variables:
 En el código de inicialización del proyecto, para declarar las variables globales al proyecto. Estas variables
podrán utilizarse en todos los tratamientos del proyecto y los elementos del proyecto (ventanas, informes, …).
 En el código de declaraciones globales de la ventana, para declarar las variables globales de la ventana. Estas
variables pueden ser utilizadas en todos los tratamientos de la ventana y sus elementos.
Todas las restantes variables declaradas, son locales.
La mayoría de desarrolladores están tentados a declarar todas sus variables en “global” dentro de un
proyecto. Este tipo de programación es efectivamente fácil. Las variables son todas globales y pueden
manipularse desde no importa que tratamiento.
Pero este tipo de programación es a menudo la causa de “machacar” las variables y otros efectos
Atención!
secundarios indeseados.
Es pues preferible declarar un número limitado de variables locales y luego declarar las variables
locales.
Si desea compartir valores entre dos ventanas, es vivamente aconsejable utilizar el método de “paso
de parámetros”, método que veremos un poco más tarde.
Instrucciones básicas de WLangage

WLangage es un L5G enriquecido, compuesto de:
 Funciones WLangage.

 Propiedades WLangage.
 Palabras clave WLangage.
 Instrucciones WLangage.
A su tiempo, y a medida de su formación, descubrirá las instrucciones necesarias.
En esta lección, simplemente vamos a presentarle las instrucciones básicas, que permiten realizar las condiciones y
los bucles, o simplemente introducir comentarios.
Ejemplo práctico
 Para comprender un concepto, nada mejor que su manipulación. El proyecto “WW_Bases_Programacion” contiene
ejemplos para cada concepto presentado.
1. Arranque WINDEV 21 si no lo había hecho previamente.
2. Cierre si es necesario el proyecto en curso: En el panel “Inicio”, dentro del grupo “General”, despliegue
“Cerrar” y seleccione la opción “Cerrar el proyecto”.
3. En la ventana de bienvenida, clique sobre la opción “Curso de Auto-formación” y seleccione el proyecto
“Bases de la programación”.
Astucia: también puede en el panel “Inicio”, dentro del grupo “Ayuda en línea”, desplegar “Guía de Auto-
formación” y luego seleccionar la opción “Bases de la programación”.
Instrucciones condicionales
WLangage permite gestionar instrucciones condicionales del tipo:
 IF, ELSE, END para verificar una condición.
 SWITCH, CASE, END para ejecutar una o varias acciones según los distintos resultados del valor de una
condición
Algunos ejemplos:
IF EDT_Maximo > Random (1.999) THEN
Info (“Bravo, ha ganado usted”)
ELSE
Info (“Lo siento, ha perdido”)
END
SWITCH dia
CASE “Lunes”
// primer día de la semana
CASE “Miércoles”
// Tercer día de la semana
CASE “Viernes”
// Quinto día de la semana
CASE “Sábado”, “Domingo”
// Es fin de semana
OTHER CASE
// Es otro día
END
Ejemplo práctico
Después de haber presentado las principales instrucciones condicionales, hagamos una pequeña prueba real!.
 Abra la ventana “WIN_Code.wdw”: en el panel “Explorador del proyecto”, dentro de la carpeta “Ventanas”, doble
clic sobre el nombre de la ventana. Esta ventana presenta distintos ejemplos.
Para buscar rápidamente una ventana en el proyecto en curso, utilice la combinación de teclas
[CTRL]+[E]. Se abrirá una ventana que permitirá realizar una búsqueda de todas las ventanas que
Astucia
contengan las letras introducidas en el campo de búsqueda. Hay que seleccionar la ventana deseada y
validarla para que esta ventana se abra en el editor.
 Lance la prueba de esta página ( en los botones de acceso rápido)

1. Clique sobre la pestaña “IF/ELSE”.
2. Pruebe los distintos ejemplos. El código ejecutado se muestra en la ventana.

3. Cierre la ventana y regrese al editor..
Instrucciones de bucle
WLangage propone varias posibilidades para gestionar los bucles:
 FOR, END para un número de iteraciones determinado.
 WHILE, END para un número de iteraciones indeterminado y donde la condición de salida del bucle se
comprueba al principio del bucle.
 LOOP, END para un número de iteraciones indeterminado y donde la condición de salida del bucle se
comprueba en el bucle. La instrucción EXIT permite salir de este bucle.
WLangage propone también los bucles del tipo FOR ALL, END permitiendo recorrer los elementos
de un campo, las cadenas de caracteres, los registros de un fichero de datos, … Estos bucles
Notas
avanzados, se estudiarán en la continuación de este curso de auto-formación.
Algunos ejemplos:
FOR I = 1 TO 100 // Aquí no es necesario declarar I
Cuenta ++ // Equivalente a Cuenta = Cuenta + 1
END
I is int = 0
WHILE I <EDT_Maximo
I++ // Equivalente a I = I + 1
END
I is int = 0
LOOP
I++ // equivalente a I = I +1
IF I >EDT_Maximo THEN EXIT
END
Ejemplo práctico:
Después de haber presentado las principales instrucciones de bucle, verifiquemos el funcionamiento en ejecución.
 Abra la ventana “WIN_Code.wdw”: En el panel “Explorador del proyecto”, en la carpeta “Ventanas”, doble clic
sobre el nombre de la ventana. Esta ventana presenta varios ejemplos.
 Lance la prueba de la ventana ( en los botones de acceso rápido).

1. Clique sobre la pestaña “Bucle”.
2. Pruebe los distintos ejemplos. El código ejecutado se muestra en la ventana.

3. Cierre la ventana y regrese al editor.
Comentarios
Para introducir comentarios en el código, hay que empezar el código por // (dos caracteres “/”).
Ejemplo:
// Esta es una línea de comentario
Puede poner como comentarios varias líneas seleccionando con el teclado (o el ratón) las líneas
a poner en comentario y luego pulsar las teclas [CTRL]+[/] (del teclado numérico).
Astucia
Puede realizar la operación inversa (quitar los comentarios) seleccionando con el teclado (o el
ratón) las líneas a las que se van a quitar los comentarios y luego pulsando las teclas
[CTRL]+[SHIFT]+[/] (del teclado numérico).
Operadores básicos de WLangage

WLangage dispone de varios tipos de operadores:
 Operadores lógicos (AND, OR, NOT, …).
 Operadores aritméticos que permiten sumar, restar, …
 Operadores de comparación que permiten comparar valores. Hemos visto algunos en el párrafo anterior (>,
<, =, …).
 Operadores binarios que permiten efectuar operaciones sobre los valores binarios.
 Operadores de afectación y de intercambio (=, <=>).
 Operadores de indirección que permiten construir el nombre de un campo a partir de una expresión.
 Operadores para las cadenas de caracteres (que veremos en el párrafo “Tratamiento de cadenas”).
 …
Vamos aquí a detallar el uso de operadores lógicos, operadores de comparación y operadores de indirección. Veremos
los restantes tipos de operadores al hilo de nuestras necesidades en este curso. Para más detalles sobre un tipo de
operador, consulte la ayuda en línea (palabra clave: “Operadores”).
Operadores lógicos
WLangage dispone de 5 operadores lógicos que permiten efectuar las operaciones lógicas y construir las condiciones:
 AND y AND que corresponden a la multiplicación lógica.
 OR y OR que corresponden a la suma lógica.
 NOT que corresponde a la negación lógica.
Ejemplo práctico:
Nada mejor que un buen ejemplo para comprender las sutilezas de estos operadores.
 En el proyecto “WD Bases Programacion”, abra la ventana WIN_Operador”.
 Lance la prueba de esta ventana ( en los botones de acceso rápido) y pruebe los operadores lógicos.
Operadores de comparación
WLangage tiene numerosos operadores de comparación que permiten realizar numerosos tratamientos.
 Operadores de igualdad: igualdad (=), igualdad flexible (~=) o igualdad muy flexible (~~).
 Operadores de comparación: distinto (<>), inferior y superior (<, <=, >, >=), o empieza por ([=, [=~,
[=~~).
Ejemplo práctico
Una página de ejemplo está disponible para probar algunos casos de utilización de los distintos operadores de
comparación.
 En el proyecto “WD Bases Programación”, abra la ventana “WIN_Operador”.
 Lance la prueba de esta ventana ( en los botones de acceso rápido) y pruebe los operadores de comparación.
Operadores de indirección
El mecanismo de la “indirección” permite construir el nombre de un campo, de una rúbrica del fichero o el nombre de
una variable a partir de una expresión de tipo cadena.
Esto permite por ejemplo, crear tratamientos genéricos independientes de los nombres de los campos, variables,
campos del fichero, …
La indirección se realiza con la ayuda de los operadores { }.
Para optimizar la velocidad de sus aplicaciones, es aconsejable precisar con el uso de la sintaxis de indirección, el tipo
del elemento manipulado.
Así, si manipula un campo, el tipo correspondiente será IndControl.
He aquí algunos ejemplos de indirección:
 Ejemplo de indirecciones simples:
{“NOM”, IndControl} = NomCli
// es equivalente a NOM=NomCli
{“NOM”,IndControl} = {“CL.NOMCLI”}
// es equivalente a NOM=CL.NOMCLI
{“PAGE_CLI.NOM”, IndControl = NomCli
// es equivalente a PAGE_CLI.NOM=NomCli
{“PAGE_CLI”+”.NOM”, IndControl} = NomCli
// es equivalente a PAGE_CLI.NOM = NomCli
 Ejemplo de indirección con un procedimiento:
NombreCampo is string
NombreCampo = “INTRODUCIR1” //INTRODUCIR1 es el nombre del campo
// llamada a un procedimiento que vuelve un campo invisible
PROCEDURE INVISIBLE (NombreDelCampo)
{NombreDelCampo, IndControl}..Visible = False
Para más detalles sobre el uso de las indirecciones, consulte el ejemplo unitario “Uso de las
Ejemplo
indirecciones” (ejemplo unitario) proporcionado estándar con WINDEV. Este ejemplo es accesible
desde la ventana de bienvenida de WINDEV ([CTRL]+[<]).

Procedimientos y funciones
Definición
Como hemos visto en la lección anterior, cuando un tratamiento se llama varias veces en un proyecto o en una
ventana, es bastante interesante crear un procedimiento que contenga este tratamiento. Bastará con llamar el
procedimiento cada vez que sea necesario.
Junto a la programación, existen los procedimientos y las funciones:
 Las funciones devuelven un resultado.
 Los procedimientos sirven para ejecutar un tratamiento específico.
WINDEV permite gestionar simplemente los dos tipos de tratamiento de la misma forma. En WLangage no hay
diferencia entre un tratamiento y una función. Por eso, en el seguimiento de este curso, utilizaremos solamente el
término “procedimiento”.
Existe la posibilidad de crear procedimientos “locales” y procedimientos “globales”.
Procedimiento local
Un procedimiento “local” está enlazado a una ventana y solamente a esta ventana.
Un procedimiento, cuando es local, puede utilizarse solamente en los tratamientos de la ventana y los campos de la
ventana en la que está declarado. Forma parte de la ventana.
Procedimiento global y colección de procedimientos.

Los procedimientos “globales” están contenidos en las “colecciones de procedimientos”. Cada “Colección de
procedimientos” es un fichero que contiene todos los procedimientos globales que tiene asociados. Este fichero tiene
la extensión “.WDG”. Por ejemplo, una colección permite agrupar los procedimientos según un tema: CálculosIVA,
CálculosLibresDePortes, …
Puede crear tantas colecciones de procedimientos como desee, dentro de un proyecto.
Una colección de procedimientos permite:
 Compartir procedimientos globales entre varios desarrolladores, para un mismo proyecto.
 Compartir procedimientos globales entre varios proyectos. En efecto, una misma colección de procedimientos
puede utilizarse en varios proyectos.
 Para crear una colección de procedimientos:
1. Seleccione la pestaña “Explorador del proyecto”.
2. Selecciones “Procedimientos”.
3. En el menú contextual (clic derecho), seleccione la opción “Nueva colección de procedimientos”.
4. En la ventana que aparece, indique el nombre de la colección de procedimientos (servidor o navegador) y

valide.

5. Los tratamientos asociados a la colección de procedimientos aparecen en el editor de código.
Es posible entonces crear procedimientos globales (esta creación se detallará a continuación en esta misma lección).
¿Cómo elegir si un procedimiento es global o local?
Para elegir si un procedimiento deberá ser global o local, pregúntese lo siguiente:”¿El procedimiento va a utilizarse
solamente en esta ventana, o podrá ser llamado desde otra ventana?”.
 Si la respuesta es “llamado solamente desde esta ventana”, el procedimiento puede ser “local”.
 Si el procedimiento puede ser llamado “desde varias ventanas”, el procedimiento deberá ser “global”.
A propósito del paso de parámetros
En el proyecto “WD Mis Primeras Ventanas”, pudo ver que un procedimiento puede gestionar los parámetros. Los
parámetros pueden ser obligatorios u opcionales.
Los parámetros “obligatorios” se definen siempre antes que los parámetros “opcionales”. La declaración de un
parámetro “opcional”, se efectúa afectando un valor por defecto cuando se declara el parámetro. Por ejemplo:
PROCEDURE MiProcedimiento (Param1, ParamOpciones = “Valor por defecto”
Una ventana puede igualmente enviar un valor al tratamiento que la ha llamado. Para más detalles, consulte la ayuda
en línea de la propiedad ..ReturnedValue.
Llamada de un procedimiento
Para llamar a un procedimiento en un tratamiento, basta con escribir su nombre en el editor de código y si es
necesario, indicar los parámetros.
WINDEV obviamente, sabe gestionar las llamadas de los procedimientos anidados.
En el editor de código, cuando está posicionado sobre un nombre de procedimiento, el pulsar la

tecla [F2] permite visualizar el código de este procedimiento.
Astucia
Pulsar simultáneamente las teclas [CTRL]+[F2] permite regresar al código anterior en el nombre
del procedimiento.
Creación de un procedimiento
Un procedimiento puede crearse directamente desde el editor principal de WINDEV. Basta con utilizar la pestaña
“Explorador del proyecto”.
 Para crear un procedimiento local:
1. En la pestaña “Explorador del proyecto”, seleccione el nombre de la ventana asociada al procedimiento local.
2. Clique sobre la flecha a la izquierda para mostrar los distintos elementos.
3. Seleccione “Procedimientos locales”.
4. En el menú contextual de “Procedimientos locales”, seleccione la opción “Nuevo procedimiento local” . En la
ventana que aparece, indique el nombre del procedimiento y valide.
5. El procedimiento aparece en el editor de código. Introduzca el código del procedimiento.
 Para crear un procedimiento global:

1. Seleccione la pestaña “Explorador del proyecto”.
2. Seleccione “Procedimientos”.
3. Cree si hiciera falta, la colección de procedimientos en la que el procedimiento global deberá crearse. Si la
colección ya existe, selecciónela.
4. En el menú contextual, seleccione la opción “Nuevo procedimiento global”.
5. En la ventana que aparece, indique el nombre del procedimiento y valide.
6. El procedimiento aparece en el editor de código. Introduzca el código del procedimiento.
7.
Recuerde: También se puede crear directamente un procedimiento a partir del código seleccionado en el editor de
código (opción “Nuevo .. Crear un procedimiento global que contenga el código seleccionado” del menú contextual).m
Esto es lo que hemos hecho en la lección anterior.

¿Cuándo utilizar los procedimientos?
 Cuando el tratamiento se utiliza varias veces en la misma ventana, es aconsejable utilizar un
Astucia
procedimiento local en la ventana que contenga este tratamiento.

 Cuando un tratamiento se utiliza varias veces en un conjunto de ventanas, es aconsejable
utilizar un procedimiento global al proyecto que contenga este tratamiento.
Ejemplo práctico
Después de haber visto la teoría, un poco de práctica!
 En el proyecto “WD Bases Programacion”, abra la ventana “WIN_Code” (doble clic sobre su nombre en el
explorador del proyecto). Esta ventana presenta distintos ejemplos.
 Lance la prueba de la ventana ( en los botones de acceso rápido).

1. Clique sobre la pestaña “Función” para probar el funcionamiento de una función.
2. Clique sobre la pestaña “Procedimiento” para probar el funcionamiento de un procedimiento.
3. Cierre la ventana.
4. Consulte la lista de los distintos procedimientos locales (accesible desde el panel “Explorador del proyecto”).
Haciendo doble clic sobre el nombre del procedimiento, el código de este procedimiento se mostrará en el
editor de código.
¿Un ejercicio de aplicación? Su turno!

Para poner en aplicación las distintas funcionalidades de este capítulo, le proponemos un pequeño ejercicio:
 En el proyecto “WD Bases Programacion”, abra la ventana “WIN_Code”: doble clic sobre su nombre en el
explorador del proyecto.
 Muestre la pestaña “Su turno”.
 En el botón “Su turno”, escriba un procedimiento que permita mostrar todas las cifras pares de 10 a 1
(cuenta atrás) en el campo de edición EDT_SuResultado.
 Pruebe la ventana para probar su código.
Corrección: El botón “Corrección” contiene la solución.
Tratamientos de las cadenas

Dentro de las funcionalidades básicas de un lenguaje de programación, la manipulación de las cadenas de caracteres
es una de las funcionalidades más importantes.
WLangage ofrece una variedad impresionante de posibilidades para manipular las cadenas de caracteres: funciones
WLangage, operadores de extracción, de concatenación, …
Presentaremos aquí las funciones más corrientes para manipular las cadenas de caracteres.
Para más detalles, consulte la ayuda en línea (palabra clave: “Cadena de caracteres”).
Ejemplo práctico
 Abra si fuera necesario el proyecto “WD Bases Programacion.WDP”:
1. Cierre si es necesario el proyecto en curso.
2. En la ventana de bienvenida, clique sobre la opción “Curso de Auto-formación” y seleccione el proyecto
“Bases de programación”.
 Abra la ventana “WIN_Cadena.WDW”: doble clic sobre su nombre en el explorador del proyecto. Esta ventana
ilustra las distintas manipulaciones que explicaremos en esta lección.
 Pruebe la ventana ( en los botones de acceso rápido).
Principales manipulaciones sobre una cadena de caracteres.

Inicialización
Un campo de tipo texto (por ejemplo un campo Etiqueta o un campo de edición) puede inicializarse por alguno de los
siguientes métodos:

 En la pestaña “Contenido” de la ventana de descripción del campo:
 Por programación afectando directamente la cadena al nombre del campo:

EDT_Texto = “WinDev es una herramienta formidable”
 Por programación, utilizando una variable de tipo cadena:
Ch is string
Ch = “WinDev es una herramienta formidable”
EDT_Texto = Ch
Concatenación
Una cadena puede construirse a partir de varias otras cadenas. Se habla entonces de concatenación de cadenas.
Para concatenar dos cadenas, basta con utilizar el operador “+”.
// La función info permite mostrar el resultado en la pantalla
Info (EDT_Texto1 + EDT_Texto2)
Extracción de partes de una cadena
La extracción de partes de una cadena puede realizarse con:
 Los operadores [[ y ]] (atención, no hace falta poner espacio entre los corchetes [[ y ]]).
Info (EDT_Texto[[1 a 6]]) // Muestra “WinDev”
 La función ExtractString, que extrae una sub-cadena desde una cadena:
Info (ExtractString (EDT_Texto,1,” “)) // Muestra “WinDev”
 La función Middle, que extrae un trozo de cadena desde una cadena:
Info (Middle(EDT_Texto,4,2)) // Muestra “De”
 La función Left, que devuelve la parte izquierda de una cadena:
Info (Left (EDT_Texto, 6)) // Muestra “WinDev”
 La función Right, que devuelve la parte derecha de una cadena:
Info (Right (EDT_Texto, 3)) // Muestra “ble”
Manipulaciones diversas
El tamaño de una cadena puede conocerse con la función Size
Info (Size (EDT_Texto) // Muestra 36
Una cadena puede transformarse en mayúsculas con la función Upper o en minúsculas con la función Lower:
Info (Upper (EDT_Texto)
Info (Lower (EDT_Texto)
Una cadena puede ser buscada dentro de otra cadena con la función Position:
CadenaABuscar is string = “WinDev”
Pos is int
Pos = Position (EDT_Texto, CadenaABuscar)
IF Pos = 0 THEN
InfoBuild (“%1 no se encuentra en el texto”, CadenaABuscar)
ELSE
InfoBuild (“%1 encontrado en el texto”, CadenaABuscar)
END
Igualmente puede efectuar la búsqueda de la posición de una cadena de caracteres en otra sin tener en cuenta
mayúsculas o minúsculas. Basta con añadir a la función Position la constante IgnoreCase:
Pos = Position (EDT_Texto, CadenaABuscar, 1, IgnoreCase)
Para conocer el nombre de ocurrencias de una cadena de caracteres determinada en otra cadena de caracteres,
utilice la función StringCount:
NbOcurrencias is int
NbOcurrencias = StringCount (“anastasia”, “a”) // Devuelve 4
También puede buscar una cadena y reemplazarla en una única operación con la función Replace:
Replace (EDT_Texto, “WinDev”, “WinDev Mobile”)
Para construir una cadena a partir de una cadena y del resultado de una función se aconseja
utilizar la función InfoBuild. Esta función permite construir el texto mostrado en función de
parámetros (%1, %2, …):
InfoBuild (%1 no se encuentra en el texto”, CadenaABuscar)
Por supuesto, también se puede utilizar la concatenación simple:
Info (CadenaABuscar + “ no se encuentra en el texto”)
Astucia
El uso de la función InfoBuild presenta varias ventajas:

 La legibilidad del código: Una cadena más sencilla de leer.
 La traducción: Una cadena puede traducirse en su totalidad. Es posible invertir las
palabras y los parámetros. El traductor solo tiene una obligación: poner el %1, %2 y
%3.
Siguiendo el mismo principio, WLangage propone las funciones StringBuild, ErrorBuild, …

Para implementar las distintas funcionalidades de este capítulo le proponemos un pequeño ejercicio:
 En el proyecto “WD Bases Programacion”, abra la ventana “WIN_Cadena” si es necesario: doble clic sobre su
nombre en el explorador del proyecto.
 En la zona “Su turno”, se le propone un ejercicio:
 En el botón “Su código”, escriba un código permitiendo mostrar la quinta palabra del texto manipulada en
mayúsculas así como el tamaño de esta palabra.
 Pruebe la página para probar su código.
Corrección:El botón “Código corregido” contiene la solución.
Tratamientos de los numéricos

Los cálculos sobre los numéricos pueden efectuarse a partir de los campos de entrada de tipo numérico o
directamente manipulando las variables introducidas (entero, real, numérico, monetario, …).
Ejemplo práctico
 Abra si es necesario el proyecto “WD Bases Programacion.WDP”:
2. En la ventana de bienvenida, clique sobre la opción “Curso de auto-formación” y seleccione el proyecto
“Bases de programación”.
 Abra la ventana “WIN_Numerico.WDW”: doble clic sobre el nombre de la ventana en el panel “Exploración del
proyecto”.
 Pruebe la ventana. Esta ventana presenta una vista de las manipulaciones sobre los “numéricos”.
Principales manipulaciones sobre los numéricos

Inicialización
Un campo de edición de tipo numérico puede inicializarse mediante uno de los siguientes métodos:
 La pestaña “Contenido” de la ventana de descripción del campo.
 Por programación, afectando directamente el valor numérico al nombre del campo:
EDT_ValorInicial = 3.14
 Por programación utilizando una variable de tipo numérico:
Ent1 is integer
Ent1 = 1234
EDT_ValorInicial = Ent1
Se puede concatenar una cadena y un numérico con el operador “+”:
Info (“El campo EDT_ValorInicial contiene el valor: “ + EDT_ValorInicial)
Si ejecuta el siguiente código:
Info (“Un cálculo: “ + 1 + 2)
La caja de diálogo mostrará “Un cálculo: 12”.
Astucia
Si lo que desea es mostrar el resultado del cálculo, hace falta utilizar el siguiente código:
Info (“Un cálculo: “ + (1 + 2))
La caja de diálogo mostrará “Un cálculo: 3”.
Manipulaciones diversas
Algunos ejemplos de manipulaciones de numéricos realizadas en WLangage:
 La parte entera de un número se averigua por la función IntegerPart, la parte decimal por la función
DecimalPart:
InfoBuild (“Parte entera de %1: %2” + CR + “Parte decimal de %1: %3”, …
EDT_RealConSigno, IntegerPart (EDT_RealConSigno), DecimalPart (EDT_RealConSigno))
 El valor absoluto de un número lo devuelve la función Abs:
InfoBuild (Valor absoluto de %1: %2”, EDT_RealConSigno, Abs(EDT_RealConSigno))
 El valor redondeado de un número lo devuelve la función Round:
InfoBuild (Redondeo de %1: %2”, EDT_RealConSigno, Round (EDT_RealConSigno))
 La función Root permite calcular la raíz enésima de un número:
InfoBuild (“Raíz cuadrada de %1: %2”, EDT_Referencia_Raiz, Root (EDT_Referencia_Raiz, 2))
 La función Power permite elevar un número a la potencia N:
InfoBuild (Potencia 2 de %1: %2”, EDT_Referencia_Potencia, …
Power (EDT_Referencia_Potencia, 2))
Observación: El tipo de los campos de entrada numéricos
Cuando un campo se define como numérico, no se conoce a priori su tipo (entero, real, real doble, …). Su tipo se
define automáticamente en función de la máscara seleccionada para el campo.
Para forzar el tipo de un campo, basta con utilizar una variable introducida. Por ejemplo:
Val1 is integer
Val1 = 123456789
EDT_Num1 = Val1 // Afectación del campo
Val1 = EDT_Num1 // Recuperación del campo

Para implementar las distintas funcionalidades de este capítulo le proponemos un pequeño ejercicio:
 En el proyecto “WD Bases Programacion”, abra la ventana “WIN_Numerico” si hiciera falta: doble clic sobre su
nombre en el explorador del proyecto.
 En el botón “Su código”, escriba el código que permite mostrar el resultado de la resta de los campos
“Importe 1” e “Importe 2” redondeado a 1 decimal.
Corrección:El botón “Código corregido” contiene la solución.
Tratamiento de los monetarios

Ejemplo práctico
 Abra la ventana “WIN_RealMonetario.wdw” (doble clic sobre su nombre en el panel “Explorador del proyecto”.
 Pruebe la ventana. Esta ventana permite probar los distintos códigos presentados en este párrafo.
Detalles
Los reales permiten manipular por programación los números decimales.
Los monetarios permiten gestionar igualmente estos números decimales pero de manera más precisa.
En efecto, con los reales, los redondeos se realizan por sistema y estos redondeos pueden inducir a errores de
cálculo.
Por ejemplo:
// Con una variable de tipo Real Doble, el cálculo es falso
MiReal is real
MiReal =18.6 – 8.6 – 10
Error (“18.6 – 8.6 – 10 = “ + MiReal)
 Para probar este código, clique sobre el botón “Resta de reales” en la ventana de prueba.
Con las variables de tipo monetario, el cálculo lo realiza WLangage.

WLangage garantiza 23 cifras significativas lo que permite tener cálculos correctos en todas las circunstancias.
Con el siguiente código, el cálculo es correcto:
// Con una variable de tipo monetario, el cálculo es correcto
MiMonetario is currency
MiMonetario = 18.6 – 8.6 – 10
Info (“18.6 – 8.6 – 10 = “ + MiMonetario)
 Para probar este código, clique sobre el botón “Resta de Monetarios” en la ventana de prueba.
Para efectuar las divisiones con los monetarios, es aconsejable pasar por variables intermedias de tipo “Monetario”.
Monetario1, Monetario2 are currency
// Atribuir un número a las dos variables monetarias
Monetario1 = “12 345 678 901 234 567,123456”
Monetario2 = “12 345 678 901 234 567,123456”
// División de Monetario1 por Monetario2
Monetario1 = Monetario1 / Monetario2
// Mostrar el resultado de la división
Info (“12 345 678 901 234 567,123456”, “ dividido por “, …
12 345 678 901 234 567,123456 “, “ = “ + Monetario1
Para probar este código, clique en el botón “División de monetarios” en la ventana de prueba.
Para hacer cálculos avanzados, WLangage pone a su disposición el tipo Numeric. Por defecto, el
tipo Numeric corresponde a 32 cifras para la parte entera y 6 cifras para la parte decimal (como
Observación
el tipo monetario).
Pero la ventaja del tipo Numeric es que se puede configurar el número de cifras a utilizar para la
parte entera y el número de cifras a utilizar para la parte decimal.
Para más detalles, consulte la ayuda en línea (Palabra clave: “Numeric”).
Mezcla de cadenas y numéricos

WINDEV es muy flexible con las afectaciones de variables. Así, se puede afectar una cadena de cifras en una variable
numérica y a la inversa. Por ejemplo:

I is int
C is string
I = 123
C=I // La variable C contiene la cadena “123”
C = “456”
I=C // La variable I contiene el valor 456
Si desea transformar un número en una cadena de caracteres respetando un formato bien precisado, basta con
utilizar la función NumToString. Por ejemplo:
NumToString (1234.567, “012,3f” ) // devuelve “00001234,567”
A cada vez que deba utilizar la función NumToString y no sepa exactamente que parámetros tiene que utilizar,
utilice el asistente de código propuesto por WINDEV: este asistente le dará la sintaxis a utilizar en función del
resultado deseado.
En el editor de código, cuando se introduce el nombre de una función seguido del paréntesis
abierto, aparecen varias informaciones en una lista:
Notas
 El nombre del asistente correspondiente a la función. Si selecciona esta opción se lanza un

asistente. Con algunas simples preguntas, este asistente escribirá automáticamente el código
deseado.
 El nombre de un ejemplo que utiliza esta función. Si selecciona esta opción, el ejemplo se
abre automáticamente en el editor.
La función “inversa” de NumToString es la función Val. Esta función permite convertir una cadena en numérico.
Tratamiento de las fechas y de las horas

Para gestionar simplemente las fechas y las horas en sus aplicaciones, WINDEV pone a su disposición:
 Un campo de edición de tipo Fecha, Hora o Duración. Con este campo, no hay ningún problema para
introducir una fecha o una hora válida.
 Un campo etiqueta de tipo Fecha, Hora o Duración. Con este campo, no hay ningún problema para mostrar
una fecha o una hora con formato válido.
 Variables de tipo Fecha, Hora, FechaHora y Duración.Estas variables simplifican la manipulación de fechas
y horas por programación y permiten múltiples cálculos.
Las fechas
Ejemplo práctico
 Abra la ventana “WIN_Date.WDW”. Esta ventana ilustra las explicaciones dadas en esta lección.
Máscara de introducción y valor devuelto

Las fechas (como las horas), son cadenas que tienen un formato predefinido.
En un campo de edición de tipo “Fecha” (o de tipo “Hora”), hay que distinguir:
 Máscara de introducción: es el formato en el que se introducirán la fecha y la hora.
 Máscara de visualización: es el formato con el que se mostrarán la fecha y la hora.
 Valor devuelto (o memorizado): es el valor devuelto por el campo hacia el programa.
Estas informaciones se introducen en la ventana de descripción del campo de edición.

 En la ventana “WIN_Date”, muestre la ventana de descripción del campo “Introduzca una fecha” (opción
“Descripción” del menú contextual del campo). Muestre la pestaña “General”. Las informaciones mostradas son
las siguientes:
Por ejemplo, para un campo de tipo “Fecha”:

 La máscara de entrada será “DD/MM/AAAA”. La fecha introducida por el usuario será en la forma: “01/11/2013”.
 La máscara de visualización será “DDDD DD MMMM AAAA”. La fecha que se mostrará en el campo será de la
forma “Jueves 18 Julio 2013”.
 El valor devuelto será por defecto “AAAAMMDD” (Ejemplo: el valor introducido en la forma “23/04/2013”
devolverá al programa “20130423”).
Existe la posibilidad de elegir una máscara de entrada de tipo “Fecha Sistema”. En este caso, el
formato mostrado será el definido en los “Parámetros regionales del panel de configuración de
Notas
Windows” de la máquina donde se va a ejecutar.
Para comprender la importancia y las relaciones entre la máscara de entrada y el valor devuelto, observemos los
siguientes ejemplos:
 Si la máscara de entrada de un campo fecha es “DD/MM/AA” y el valor devuelto es “AAAAMMDD”:
EDT_DateJ = “20131225” // Muestra la fecha de la forma “25/12/13”
EDT_DateJ = “131225” // Muestra la fecha de una forma incorrecta
La fecha mostrada será incorrecta.
 Si la máscara de entrada de un campo fecha es “MM/DD/AAAA” y el valor devuelto es “MMAADD”:
EDT_DateJ = “131225” // Muestra la fecha de la forma “12/25/2013”
EDT_DateJ = “20131225” // Muestra la fecha de una forma incorrecta
La fecha mostrada será incorrecta.
Por lo tanto, deberemos prestar mucha atención al formato del valor devuelto en un campo de tipo
fecha u hora.
Las funciones WLangage que manipulan:
 Las fechas utilizan el formato “AAAAMMDD”.
 Las horas utilizan el formato “HHMMSSCC” (algunas utilizan el formato “HHMMSSCCC”, para la gestión de los
milisegundos).
Recuerde: Por defecto, el formato (máscara de introducción) del campo corresponde a la

máscara fecha definida en la pestaña “Idiomas” de la ventana de descripción del proyecto (en la
pestaña “Proyecto”, dentro del grupo “Proyecto”, clique sobre “Descripción”). Así la misma
Notas
máscara se utilizará automáticamente en todos los campos de tipo Fecha del proyecto.
Esta funcionalidad es igualmente muy útil en los sitios multi-lenguaje.
 Vamos ahora a ver como gestionar las fechas por programación.

1. Cierre si es necesario la ventana de descripción del campo.
2. Pruebe la ventana WIN_Date” ( en los botones de acceso rápido).

¿En qué día estamos?
Para conocer la fecha del día, basta con utilizar la función Today (o DateSys). La función Today devuelve la fecha
del sistema de su ordenador en forma de una cadena de caracteres con formato “AAAAMMDD”. Ejemplo:
Info (“Hoy estamos a “ + Today ())
 Para probar esta funcionalidad en nuestro ejemplo, clique sobre el botón “FechaDelDia”.
Como podrá constatar, la fecha se muestra en formato “AAAAMMDD”.
Para mostrar la fecha en un formato más explícito, hay que utilizar la función DateToString:
Info (Hoy estamos a “+ DateToString (Today (), MaskSystemDate))
La función DateToString transforma una cadena con formato “AAAAMMDD” al formato elegido. La constante
“MaskSystemDate permite utilizar el formato de fecha definido en la pestaña “Lenguas” de las características del
proyecto.
Recuerde: Para mostrar las características del proyecto, en la pestaña “Proyecto”, dentro del grupo “Proyecto”, clique
sobre “Descripción”.
 Para probar esta funcionalidad en nuestro ejemplo, clique sobre el botón “FechaACadena”.
¿En qué día estamos, pero el día y el mes en letras?
Para mostrar la fecha en todas las letras, hay que utilizar la función DateToString utilizando un formato de fecha
específico:
Info (“Estamos a “+ DateToString (Today (), “DDDD DD MMMM AAAA”))
En este código:
 La cadena “DDDD DD” permite obtener el día en todas sus letras. Por ejemplo: Martes 17.
 La cadena “MMMM” permite obtener el mes en todas sus letras. Por ejemplo: “Septiembre”.
 La cadena “AAAA” permite obtener el año. Por ejemplo: 2013.
 Para probar esta funcionalidad en nuestro ejemplo, clique sobre el botón “En letras”.
¿Cuál es el número de días entre dos fechas?

¿Desea saber cuántos días han transcurrido entre dos fechas? Es muy sencillo: utilice la función DateDifference:
NumeroDias is int

NumeroDias = DateDifference (“20100101”, Today ())
InfoBuild (“Número de días entre el %1 y el %2: %3”, …
DateToString (“20100101”, MaskSystemDate), …
DateTiString (Today (), MaskSystemDate), NumeroDias)
 Para probar esta funcionalidad en nuestro ejemplo, clique sobre el botón “DiferenciaFechas”.
También es posible obtener la duración entre la fecha del día y una fecha específica en forma de
un texto claro (hay dos días, en tres semanas, …). Basta con utilizar:
 Una máscara de visualización del tipo “Duración relativa”.
Observación
 La función DateToString con la constante maskDateRelativeDuration.

Por ejemplo:
// Si la fecha del día es 22/01/2013
Res = DateToString (“20130101”, maskDateRelativeDuration)
// devuelve: hay 3 semanas
¿Qué día de la semana es una fecha concreta?

Siempre tan sencillo, puede conocerse el día de no importa que fecha con la función DateToDayInAlpha:
J is string
J = DateToDayInAlpha (“17890714”)
Info (“El 14 de Julio de 1789 era un “+ J)
 Para probar esta funcionalidad en nuestro ejemplo, clique sobre el botón “Fechaadiaenletra”.
Pequeño ejercicio práctico

Ahora que conoce las fechas, una pregunta: ¿Qué hace el siguiente código?
DateToString (Today(), “DDDD DD MMM AAAA”)
Manipulación de las variables de tipo Fecha

WLangage propone tipos de variables específicos para los valores de tipo Fecha, FechaHora o Duración.
Estas variables son asimilables a las “cadenas”. Cada una contiene un valor según el cuadro siguiente:
Tipo Formato por defecto

Date AAAAMMDD
DateTime AAAAMMDDHHMMSSCC
Duration AAAAMMDDHHMMSSCC
El tipo “Date” permite gestionar las fechas comprendidas entre el “01/01/0001” y el “31/12/9999” ( Se puede estar
tranquilo por una buena temporada).
Más en serio, para manipular el valor de estas variables, puede utilizar las sintaxis siguientes:
MiFecha is Date = “20121021”
Info (DateToString (MiFecha)) // Muestra “21/10/2012”
MiFecha..Year = MiFecha..Year + 1
MiFecha..Month = MiFecha..Month + 1
MiFecha..Day = MiFecha..Day + 1
Info (DateToString (MiFecha)) // Muestra “22/11/2013”
En este código, Year, Month y Day son propiedades WLangage

 En la ventana “WIN_Date”, el botón “Ejemplo de código” permite calcular la fecha del próximo 1 de enero
utilizando una variable de tipo Date.
El código utilizado es el siguiente:
MiFecha is Date
// MiFecha se inicializa automáticamente a la fecha del día
// Cálculo de la fecha del próximo 1 de Enero
NuevoAnyo is Date
NuevoAnyo..Year++
NuevoAnyo..Day = 1
NuevoAnyo..Month = 1
MiDuracion is Duration = NuevoAnyo – MiFecha
Info (StringBuild ( Quedan %1 días antes que llegue el primer día del año”, …
“el %2. “, MiDuracion..InDays, DateToString (NuevoAnyo))
Para implementar las distintas manipulaciones de las fechas le proponemos un pequeño ejercicio:
 En el proyecto “WD Bases Programación”, abra la ventana “WIN_Date” si es necesario (doble clic sobre su
nombre en el explorador del proyecto).
 En el botón “Su código”, escriba el código que permita calcular la fecha que será dentro de 180 días y
muestre el resultado en letras.
Corrección: El botón “Código corregido” contiene la solución.
Las horas
Ejemplo práctico
 Abra si es necesario el proyecto “WD Bases Programacion.WDP”.
“Bases de programación.
 Abra la ventana “WIN_Hora.WDW”. Esta ventana ilustra las explicaciones ofrecidas en esta lección.
 Pruebe esta ventana.

¿Qué hora es?
Para conocer la hora, hay que utilizar la función Now (o TimeSys). La función Now devuelve la hora actual de su
sistema bajo la forma de una cadena de caracteres con formato “HHMMSSCC”:
Info (Son las “ + Now())
 Para probar esta funcionalidad en nuestro ejemplo, clique sobre el botón “Ahora”.
 ¿Desea mostrar la hora en formato estándar “HH:MM:SS:CC”? el código es el siguiente:
Info (“Ahora son las “+ TimeToString (Now ()))
La función TimeToString transforma una hora con formato “HHMMSSCC” en una cadena con formato
“HH:MM:SS:CC”.
 Para probar esta funcionalidad en nuestro ejemplo, clique sobre el botón “HoraACadena”.
Para no mostrar las centésimas de segundo, el código es:

Info (“Ahora son las “ + TimeToString (Now (), “HH:MM:SS”))
Basta con precisar el formato de visualización de la hora con la función TimeToString.
 Para probar esta funcionalidad en nuestro ejemplo, clique sobre el botón “Sin las centésimas”.
¿Cuánto tiempo ha transcurrido entre dos horas?
Ahora son las 17:25. ¿Cuánto tiempo ha pasado desde las 12:15? El código es el siguiente:
// muestra el tiempo transcurrido desde las 12:15
Diff is int = TimeDifference (“1215”, Now ())
Resultado_Tiempo is Time = IntegerToTime (Abs (Diff))
IF Diff < 0 THEN

InfoBuild (“Tiempo transcurrido antes de las 12:15 -> %1 h %2 min %3 s”, …
Resultado_Tiempo.. Hour, Resultado_Tiempo..Minute, …
Resultado_Tiempo..Second)
ELSE
InfoBuild (“Tiempo transcurrido desde las 12:15-> %1 h %2 min %3 s”, …
Resultado_Tiempo.. Hour, Resultado_Tiempo..Minute, …
Resultado_Tiempo..Second)
END
La función IntegerToTime transforma un entero (que corresponde al número de centésimas de segundo
transcurridas desde la medianoche (o 00:00)) hacia una hora bajo el formato “HHMMSSCC”.
La función TimeToInteger realiza la operación inversa.
 No ponga ningún “:” en la hora pasada como parámetro a la función TimeToString, ya que
Atención!
falseará el resultado.
 Para calcular las duraciones de más de 24 horas, utilice los tipos Fecha, Hora, …
 Para probar esta funcionalidad en nuestro ejemplo, clique sobre el botón “Primer ejemplo”.
El mismo cálculo puede efectuarse utilizando las variables de tipo Time o Duration.
WLangage propone tipos de variables específicas para los valores de tipo Date, Time, DateTime o Duration. Estas
variables son asimilables a las “cadenas”. Cada una contiene un valor según el cuadro siguiente:
Tipo Formato por defecto

Time HHMMSSCC
Duration AAAAMMDDHHMMSSCC

El código puede ser:
En12H is Time
En12H..Hour +=12
En12H..Minute += 30
InfoBuild (“En 12 horas y 30 minutos, serán %1”, TimeToString (En12Hm “HH:MM”))
 Para probar esta funcionalidad en nuestro ejemplo, clique sobre el botón “Segundo ejemplo”.

Para implementar las distintas manipulaciones de las fechas le proponemos un pequeño ejercicio:
 En el proyecto “WD Bases Programacion”, abra la ventana “WIN_Hora” si es necesario” (doble clic sobre su
 En el botón “Su código”, escriba el código que permita mostrar el tiempo que falta hasta las 23:59 con
formato “HH:MM”.
Cálculos con las fechas y las horas

WLangage posee numerosas funciones para gestionar las fechas y las horas y efectuar los distintos cálculos.
Para más detalles, consulte la ayuda en línea (palabra clave: “Fecha, Funciones WLangage”).

Lección 1.5. Preguntas/Respuestas
 Preguntas / Respuestas

Preguntas/Respuestas
Pregunta ¿Cómo visualizar el elemento al que pertenece el tratamiento en curso?
Para visualizar el elemento correspondiente al tratamiento en curso, en el panel “Código”, en el grupo “Navegación”,
clique sobre “Ir al objeto” ([CTRL]+[ALT]+[F2]). Se muestra la página que contiene el elemento deseado.
Pregunta ¿Cómo imprimir el código fuente?
El código fuente en curso puede imprimirse directamente clicando sobre el icono en el panel “Inicio” o con la
combinación de teclas [CTRL]+[P].
Pregunta ¿Cómo hacer una búsqueda y/o reemplazar?
Las funciones de búsqueda o de reemplazamiento (en el código, el interface, …) son accesibles desde el panel
“Inicio”, en el grupo “Buscar” o en la pestaña “Buscar – Reemplazar” ([CTRL]+[F]):
Podrá a continuación las distintas características de la búsqueda a efectuar.
Pregunta ¿Qué significan los signos “+” o “-“ en el editor de código?
El editor de código permite colapsar o desplegar el código WLangage. Esta funcionalidad es muy útil si sus
tratamientos utilizan numerosas instrucciones estructuradas (bucles, condiciones, recorridos, …).
Para replegar el código, en el panel “Visualización”, despliegue “Replegar” y seleccione la opción de menú “Replegar
todo” (o el atajo [CTRL]+[SHIFT]+[*] (del teclado numérico)).
Solo los comentarios quedarán visibles. Pasando sobre cada línea de comentario permite visualizar el código asociado
dentro de una burbuja:
La combinación de teclas [CTGRL]+[*] (del teclado numérico) permite desplegar todo el código. El clic sobre los
símbolos “-“ o “+” permite plegar o desplegar solamente la parte de código correspondiente.

Pregunta ¿Se puede identificar a la persona que ha escrito una línea de código?
Pulsando la tecla [F6] se pueden mostrar las informaciones (nombre y fecha de la creación/modificación) de cada
línea de código.
Pregunta ¿Se puede conocer el número de una línea de código?
En el editor de código, para activar (o no) la numeración de las líneas de código, en el panel “Visualizar”, dentro del
grupo “Ayuda a la edición”, clique sobre “Mostrar los números de línea”.
Pregunta ¿Hay un medio de conseguir fácilmente la sintaxis o la ayuda sobre una función?
Al escribir una función se muestra la sintaxis de la función:

 En una burbuja de ayuda debajo de la línea en curso de introducción. Para cada parámetro (incluyendo el
resultado de la función), se muestra una burbuja explicativa.
Si hay varias sintaxis disponibles, se puede pasar de una sintaxis a otra con las teclas [CTRL]+[ALT]+ flecha
derecha o flecha izquierda.
 En la barra de mensajes del editor.
En la ayuda mostrada, los parámetros encerrados entre [ y ] son opcionales.
Para las funciones que utilizan los nombres de ficheros de datos, campos, páginas o informes, la entrada asistida
permite mostrar la lista de los elementos del proyecto correspondientes al parámetro de la función en curso de
introducción.
Ejemplo de entrada asistida para la función HReadFirst: La opción <Asistente> permite lanzar un asistente del
código. Este asistente plantea distintas cuestiones para el uso de la función y genera automáticamente el código
correspondiente.
Todas las funciones y las propiedades de WLangage tienen una ayuda asociada. Esta ayuda es accesible directamente
desde el editor pulsando la tecla [F1] sobre el nombre de la función o la propiedad deseada.
Pregunta ¿Cuáles son los atajos del teclado a conocer en el editor de código?
 [F2] sobre el nombre de un campo, de un método de una clase, de un procedimiento o de un bloque de

informe, muestra el tratamiento de este objeto.
 [CTRL]+[F2] permite volver al tratamiento inicial.
Pulsando repetidamente la Tecla [F2] podrá desplazarse de un tratamiento a otro. Para volver al tratamiento
inicial, hay que pulsar a la vez las teclas [CTRL]+[F2].
 [CTRL]+[L] Elimina la línea en curso.
 [CTRL]+[D] duplica la línea en curso (o las líneas seleccionadas) en la línea siguiente.
 [TAB] y [SHIFT]+[TAB] permiten gestionar la sangria del conjunto de las líneas seleccionadas.
 [CTRL]+[/] pone como comentario las líneas seleccionadas. [CTRL]+[SHIFT]+[/] elimina los comentarios
(Atención: tecla [/] del teclado numérico.
 • [CTRL]+[R] permite aplicar automáticamente la sangría al código mostrado.
Pregunta ¿Cómo dialogar con el usuario?
Hay que utilizar una caja de diálogo avanzada. Estas cajas de diálogo permiten gestionar:
 La interrogación directiva (función Dialog): el usuario responde a una pregunta utilizando los botones que
contienen el texto de la acción a efectuar.
 La entrada inmediata (función Input), proponiendo al usuario introducir directamente en la caja de diálogo el
valor deseado.
Para más detalles sobre estas funciones, consulte la ayuda en línea (palabra clave: “Dialog” e “Input”).
 Para probar los distintos métodos de diálogo con el usuario:
1. Abra si es necesario el proyecto “WD Bases Programacion.WDP”: en el panel “Inicio”, en el grupo “Ayuda en
línea”, despliegue “Guía de Auto-formación” y luego seleccione “Bases de programación”.
2. Abra la ventana “WIN_Dialogo.WDW”. Esta ventana ilustra los distintos modos de diálogo posibles.
3. Pruebe esta ventana (botón “GO”).
4. Clique sobre los distintos botones para probar los distintos modos de diálogo.
5. Detenga la prueba de esta ventana y vuelva al editor de código para estudiar el código de cada botón.
 Para aplicar las distintas manipulaciones en las cajas de diálogos, le proponemos un pequeño ejercicio:
1. En el proyecto “WD Bases Programación”, abra la ventana “WIN_Dialogo” si es necesario (doble clic sobre su
2. En la zona “Su turno”, se le propone un ejercicio:
o En el botón “Su código”, escriba el código que permite pedir al usuario su nombre. Muestre este nombre
en la barra de mensaje y en una caja de información. Si el usuario anula la entrada del nombre, muestre
un texto para indicar esta anulación.
o Pruebe la ventana para probar su código.

CAPÍTULO 2
Mi primera base
de datos
Capítulo 2 –Mi primera base de datos |71

Lección 2.1. Presentación
 Presentación del proyecto realizado en este capítulo

Presentación del proyecto realizado en este capítulo
En este capítulo vamos a crear un proyecto asociado a una base de datos HFSQL.
De esta manera podrá descubrir elementos claves en la concepción de una aplicación:
 Creación de un proyecto WINDEV
 Descripción de los ficheros de datos manipulados por la aplicación.
En un próximo capítulo, nos concentraremos en el desarrollo de los elementos (ventanas, informes, …) de una
aplicación con datos, que desarrollaremos de principio a fin, desde la creación del interface hasta la distribución final.
Verá así todos los puntos importantes de una aplicación.
En este capítulo, la base de datos que crearemos juntos es una gestión de pedidos.
Esta mismo tipo de base de datos será más adelante utilizado en el capítulo 3 de este curso para desarrollar una
aplicación completa. La base de datos utilizada es HFSQL Clásico, la base de datos gratuita proporcionada con
WINDEV. Más adelante en este curso, estudiaremos la base de datos HFSQL Cliente/Servidor.

Lección 2.2. WINDEV y las bases de datos
 Vocabulario utilizado.
 Distintos modos de acceso a las bases de datos.

Presentación
Cuando se concibe una aplicación, puede sentirse llevado a manipular los datos. Para almacenarlos, deberá constituir
lo que se llama “una base de datos”.
En WINDEV, cuando se crea un proyecto que manipule datos, deberá primero que nada crear un “análisis”.
Un “análisis” contiene la descripción de los ficheros de datos (o tablas) que contienen los datos de la aplicación.
Es solamente cuando se ejecuta la aplicación cuando las descripciones se utilizan para crear la base de datos y/o los
ficheros de datos. Es en esta base de datos o en los ficheros de datos donde se almacenarán las informaciones.
Con WINDEV, se proporcionan en estándar varias herramientas de mantenimiento de bases de

Notas
datos HFSQL. Son accesibles desde el Centro de Control HFSQL.
WINDEV sabe gestionar los distintos formatos de base de datos (por no decir todas). Los formatos más habituales
son:
 HFSQL, sistema de base de datos integrado con WINDEV y proporcionado en estándar. La base de datos
HFSQL está disponible en modo clásico o Cliente/Servidor.
 AS/400, Access, Sybase, Informix, …
 Oracle, SQL Server, MySQL, xBase, …
 Todas las bases accesibles en lenguaje SQL bajo Windows.
 Texto (Ficheros ASCII).
Para acceder a los datos, hay distintas técnicas:
 Acceso nativo.
 Acceso OLE DB.
 Acceso ODBC directo.
 Acceso ODBC a través de OLE DB.
HFSQL
HFSQL es una base de datos a la vez muy potente, muy rápida y muy robusta.
HFSQL funciona bajo Windows y Linux, en móviles (iOS, Android, Windows CE, Windows RT), en redes de cualquier
tipo y tamaño, y gestiona automáticamente varios centenares de accesos simultáneos.
La difusión de HFSQL es libre y gratuita con sus aplicaciones WINDEV.
HFSQL propone todas las funcionalidades de una base de datos, principalmente:
 El diario
 Las transacciones
 La replicación
 Los triggers
Para más detalles sobre el establecimiento de estas funcionalidades, consulte la ayuda en línea.
En las distintas partes de este curso de auto-formación, vamos a manipular una base de datos HFSQL clásico y luego
una base HFSQL Cliente/Servidor.
Distintos modos de acceso a las bases de datos

Acceso nativo
Un acceso nativo manipula directa y exclusivamente un formato de base de datos. Este tipo de acceso optimizado
está desarrollado especialmente para cada formato de base de datos.
Dentro de WINDEV, hay un acceso nativo para las bases de tipo:
 HFSQL Clásico o Cliente/Servidor (en estándar).
 xBase (en estándar).
 Access (en estándar).
 XML (en estándar).
 SQLite (en estándar).
 Oracle (opcional).
 AS/400 (opcional).
 SQL Server (opcional).
 Sybase (opcional).
 Informix (opcional).
 DB2 (opcional).
 Progress (opcional).
 MySQL (opional y gratuito).
 PostgreSQL (opcional y gratuito).
 MariaDB (opcional y gratuito).
Otros accesos nativos podrían estar también disponibles; contacte con nuestro servicio comercial.
Las funciones WLangage SQL* y HRead son utilizables con estos tipos de acceso. El código es totalmente portable
e independiente de la base de datos.
Acceso ODBC Directo

Un acceso a través de ODBC directo utiliza un estándar de acceso multi-bases. Deberá instalar la capa ODBC 32 bits
en su máquina. Esta capa generalmente ya está instalada en las versiones más recientes de Windows. Puede
verificarlo en el panel de configuración de Windows eligiendo la opción “Administrador ODBC”.
Atención: No todas las bases de datos son obligatoriamente accesibles a través de este método. Si desea utilizar este
tipo de acceso, verifique que existe un driver ODBC e instale este driver si hiciera falta.
Solo las funciones WLangage SQL* son utilizables con este tipo de acceso.
Acceso OLE DB
Un acceso a través de OLE DB es un acceso que utiliza un estándar de acceso multi-bases. Este tipo de acceso setá
basado en el MDAC (Microsoft Data Access Component) de Microsoft.
Si utiliza un acceso OLE DB, deberá instalar obligatoriamente el MDAC en los puestos usuarios
Atención!
(versión 2.6 mínimo).
Todas las bases de datos no son obligatoriamente accesibles a través de este método. Si desea utilizar este tipo de
acceso, verifique que existe un driver OLE DB.
Las funciones WLangage SQL* y HRead pueden utilizarse en este tipo de acceso.
Acceso ODBC a través de OLE DB

Resumiendo, se trata de una “mezcla” de OLE DB y de ODBC. Esta técnica es la más “pesada” y la menos eficaz en
tema de realizaciones. Se desaconseja utilizarlo en las bases de pequeño tamaño.
Las funciones WLangage SQL* y HRead pueden utilizarse en este tipo de acceso.

Lección 2.3. Proyecto y análisis
 Creación de un proyecto
 Creación de un análisis

Presentación
Para crear una aplicación con una base de datos, hay que:
 Crear el proyecto enlazado al sitio. Este proyecto agrupará todos los elementos la aplicación (ventanas, códigos,
consultas, informes, …).
 Crear el análisis enlazado al proyecto. El análisis permite describir todos los ficheros de datos manipulables por el
sitio.
Creación del proyecto

Para crear el proyecto:
1. Lance WINDEV si no lo había hecho antes. Si es necesario, cierre el proyecto en curso.
2. En la ventana de inicio, clique en el botón “Crear un proyecto”, y luego sobre la opción “Aplicación Windows o
Linux”. Se abrirá el asistente para la creación de un proyecto. Las distintas pantallas del asistente le ayudarán
a crear su proyecto. Todas las informaciones indicadas en este asistente, podrán modificarse posteriormente.
Astucia: Para crear un proyecto, también puede:

Notas
1. Clicar sobre en los botones de acceso rápido.

2. Se abre la ventana de creación de un nuevo elemento: clique en “Proyecto”.
3. La primera pantalla del asistente permite introducir el nombre del proyecto, su emplazamiento y su
descripción. En nuestro caso, el proyecto se va a llamar simplemente “WD Mi Primera Base de Datos”. Por
defecto, WINDEV propone crear este proyecto en el directorio “\Mis Proyectos\WD Mi Primera Base de
Datos”. Puede conservar este emplazamiento o modificarlo con el botón […]. Para el resumen del proyecto,
introduzca “El proyecto tiene como objetivo gestionar los clientes y sus pedidos.
4. Los distintos apartados del asistente se muestran a la izquierda del asistente. Estos apartados son
directamente accesibles con un clic. Los otros apartados de la parte “Descripción” no son fundamentales,
clique directamente en “Cartas”.
5. Este apartado permite definir la carta de programación utilizada. No modifique las opciones propuestas. Pase
al apartado siguiente con la ayuda de la flecha “siguiente” situada bajo.
6. Este paso permite definir la carta gráfica. Seleccione “Elegante”. Pase a la etapa siguiente con la ayuda de las
páginas situadas bajo.

7. Clique en el paso “Sabía usted”. Esta pantalla permite mostrar una ventana del tipo “Sabía usted”.
No mostraremos esta ventana. Seleccione la opción “No mostrar la ventana ‘Sabía usted’ al lanzar la
aplicación”. Avance al paso siguiente.
8. Ahora, vamos a darle las informaciones concernientes a la base de datos.
9. Seleccione la opción “Si, Crear una nueva base de datos” y valide. El asistente de creación de análisis se
lanza.
Para seguir las distintas lecciones de este capítulo y optimizar su aprendizaje de WINDEV, es
aconsejable crear el proyecto “WD Mi Primera Base de Datos”.
Un ejemplo corregido está disponible en cualquier momento para validar las operaciones
Notas
efectuadas.
Para abrir el proyecto corregido, en el panel “Inicio”, en el grupo “Ayuda en línea”, despliegue
“Guia de auto-formación” y luego seleccione “Mi primera base de datos (Corrregido)”.
Creación del análisis

 Las etapas del asistente de creación del análisis son los siguientes:
1. Indique el nombre y el directorio del análisis. Por defecto, el nombre del análisis corresponde al nombre del
proyecto y el directorio del análisis es un directorio “.ana” en el directorio del proyecto.
Vamos a conservar estos parámetros por defecto. Pase a la etapa siguiente del asistente.

2. A continuación podrá elegir el o los tipos de bases de datos manipuladas por el proyecto. Seleccione HFSQL
clásico (la base de datos propuesta por defecto con WINDEV).
Pase a la siguiente etapa del asistente.

3. Valide. El asistente de creación de un fichero de datos se lanzará automáticamente.
Creación de la descripción del fichero de datos

Nuestra aplicación de gestión de clientes y pedidos estará asociada al siguiente análisis. Este análisis tiene cinco
ficheros de datos (tablas) distintos:
 Cliente
 Pedido
 ModoLiquidacion
 LineaPedido
 Producto
Para crear los distintos ficheros de este análisis, vamos a utilizar distintos métodos disponibles en WINDEV.
Creación de un fichero de datos: Uso de un fichero predefinido.

 Las etapas del asistente de creación de un fichero de datos son las siguientes:
1. En el asistente, seleccione la opción “Seleccionar una descripción entre los ficheros de datos predefinidos”.
Avance al paso siguiente del asistente (flecha bajo del asistente).

2. Se muestra la lista de ficheros de datos predefinidos. Vamos a crear el fichero “Cliente”. En la lista de ficheros
de datos, seleccione “Cliente”. Pase a la etapa siguiente.
3. El asistente propone una lista de las rúbricas a integrar en el fichero Cliente. Esta lista es impresionante por lo
que permite gestionar numerosos tipos de ficheros Cliente.
4. Marque solamente las siguientes rúbricas: IDCliente, Sociedad, Nombre, Apellidos, Direccion, CodigoPostal,
Poblacion, EstadoDepartamento, Pais, Telefono, Movil, Email.
5. Valide el asistente.
6. El fichero “Cliente” se crea automáticamente en el editor de análisis.

7. Se muestra la ventana de creación de un nuevo elemento. Vamos ahora a crear el fichero de datos que
contendrá los pedidos.
Creación de un fichero de datos: creación del fichero y sus rúbricas
 Para crear un fichero de datos desde la ventana de creación de un nuevo elemento:
1. Clique sobre “Datos” y luego sobre “Fichero de datos”.
También puede crear un fichero de datos directamente desde el editor de análisis: en el panel
Notas
“Análisis”, dentro del grupo “Creación”, clique sobre “Nuevo fichero”.
2. Se lanzará el asistente de creación de un nuevo fichero.

3. En el asistente, seleccione la opción “Crear una nueva descripción de un fichero de datos”.
4. Pase a la etapa siguiente del asistente.

5. Vamos a crear el fichero “Pedido”. Introduzca su nombre, ”Pedido”, en el asistente. Este nombre se utilizará:
 Para manipular el fichero de datos en programación. La variable asociada al fichero será “Pedido”.
 Para construir el nombre del fichero de datos físico asociado (fichero “Pedido.fic”).
Automáticamente, aparecerán el texto y la descripción de los elementos representados por los registros del
fichero de datos.
En el asistente, el campo “Un registro representa” permite tener un texto claro de la descripción
de los enlaces entre los ficheros de datos. Automáticamente, un texto se propone a partir del
Notas
nombre del fichero.

En nuestro caso, introduzca “Un pedido”.

6. En la zona “Identificador automático”, conserve la opción “identificador automático de 8 octetos”. Si se define
un identificador automático en el fichero de datos, esto significará que el fichero de datos tendrá una clave
única, gestionada automáticamente por WINDEV.
Para crear el identificador (un identificador es una clave única), puede crear un campo numérico
de tipo “Identificador automático”.
Este identificador es gestionado automáticamente por WINDEV. Cada vez que se añade un
Notas
registro al fichero de datos, WINDEV afecta automáticamente un valor al identificador del

fichero. Este valor es único.
7. Pase a la etapa siguiente y seleccione el tipo de la base asociada al fichero de datos. Vamos a trabajar sobre
ficheros de datos HFSQL Clásico. Pase a la etapa siguiente.
8. Clique sobre el botón verde para validar. El fichero de datos se crea automáticamente en el análisis. Se abre a
continuación la ventana de descripción de los campos.
Vamos a introducir las rúbricas del fichero “Pedido”. En la ventana de descripción del fichero de datos, puede
observar que ya se ha creado una rúbrica automáticamente: “IDPedido”. Esta rúbrica corresponde al identificador
automático del fichero de datos. Esta rúbrica se compone con las letras “ID” y el nombre del fichero.
Vamos a crear las restantes rúbricas del fichero de datos.
 En primer lugar, vamos a crear la rúbrica “Fecha”. Esta rúbrica contendrá la fecha del pedido.
1. En la ventana de descripción de las rúbricas, doble clic sobre la columna “Nombre” de la primera línea vacía.
Esta columna pasa automáticamente a modo introducción. Introduzca “Fecha”.
2. Clique en la columna “Texto”. Automáticamente aparece el nombre de la rúbrica. Vamos a modificar el texto
del campo clicando debajo: introduzca “Fecha del pedido”. En la columna “Tipo”, aparecerá seleccionado de
modo automático el tipo “Texto”. Despliegue la lista y seleccione el tipo “Fecha”.

3. Esta rúbrica será una clave (índice) de nuestro fichero de datos. Las claves permite acelerar el acceso y las
clasificaciones.
 En el caso de una base de datos con formato SQL, el motor utiliza mejor los índices.
 En el caso de un recorrido secuencial en un fichero de datos, hay que indicar el índice para el recorrido (es
decir, la clave).
La noción de clave es una de las características de una rúbrica. En efecto, cuando se crea
unarúbrica, puede indicar si se trata de:
 No es clave
 Clave única: El valor de esta clave será único en el conjunto del fichero de datos (es
Notas
decir, en todos los registros del fichero de datos).

 Clave con duplicados: El valor de esta clave, podrá estar presente varias veces en el
fichero de datos.
4. La definición de clave se realiza de la siguiente manera: Re-seleccione la línea de la rúbrica “Fecha” para
activar los campos de descripción presentes a la derecha de la pantalla. Hay que especificar entonces el tipo
de clave utilizado. En nuestro caso, la fecha es una clave con duplicados.
5. También es igualmente necesario definir el sentido del recorrido de la clave. El sentido del recorrido permite
definir la clasificación por defecto de esta rúbrica. En nuestro caso, para efectuar el recorrido sobre esta
clave, la clasificación por defecto será “ascendiente”.
 Ahora vamos a crear la rúbrica “Estado” que permite conocer el estado del pedido.
1. Posiciónese sobre una nueva línea de la tabla e introduzca:
 El nombre: Estado
 El texto: Estado del pedido
 El tipo: Selector, Lista, Combo. En la ventana que se abre, puede seleccionar el tipo de campo creado por
defecto para este campo. Aquí, será un selector. Valide la ventana.
2. En la parte inferior de la pantalla, clique sobre la doble flecha para mostrar los parámetros del campo
enlazados con la rúbrica seleccionada.
Las informaciones que se introduzcan aquí se utilizarán automáticamente cuando se creen las ventanas
enlazadas al fichero de datos. Aquí encontrará el tipo de campo y el texto.
Vamos a introducir las distintas opciones correspondientes al estado del pedido en la pestaña “Contenido”:
 Clique en la pestaña “Contenido”.
 Clique sobre el botón “+” para añadir la primera opción
 La opción 1 corresponderá a “En espera”. Introduzca “En Espera” en el campo de edición a derecha del
selector.
 Clique sobre el botón “+” para añadir la segunda opción.
 Introduzca “Validado” en lugar de “Opción 2”.
 Clique de nuevo sobre el botón “+”.
 Introduzca “Anulado” en lugar de “Opción 3”.
3. Clique nuevamente sobre la doble flecha.
4. De la misma manera:
 Posiciónese sobre una nueva línea de la tabla y cree la rúbrica “TotalHT”. Este campo es de tipo “Monetario”.
 Posiciónese sobre una nueva línea de la tabla y cree la rúbrica “TotalTTC”: Este campo es de tipo
“Monetario”.
5. Listo, la descripción del fichero “Pedido” ha finalizado. Valide la ventana de descripción de las rúbricas.
6. El fichero “Pedido” aparecerá sobre el editor de análisis. Se puede agrandar el fichero mostrado. Hay que
clicar sobre el fichero, seleccionar el recuadro negro bajo del fichero y desplazar el ratón hacia abajo.
Importación de un fichero CSV

Para crear el fichero “ModoLiquidacion”, que contiene las características de la liquidación, vamos a utilizar otro
método: Importación de un fichero CSV.
Un fichero CSV es un fichero de texto que utiliza un formato específico. Este fichero contiene
datos para cada línea. Estos datos están separados por un carácter de separación (generalmente
Notas
una coma, un punto y coma o una tabulación).
A partir del fichero CSV que contiene los datos, WINDEB creará:
 La descripción del fichero de datos en el análisis.
 El fichero de datos HFSQL con los datos existentes en el fichero CSV.
 Para importar un fichero CSV en el análisis:
1. En el panel “Análisis”, en el grupo “Creación”, despliegue “Importar” y seleccione “Importar descripciones de
ficheros/tablas”.

Para importar un fichero (CSV u otro) en el análisis, también se puede realizar directamente un
“Drag and Drop” del fichero CSV (existente en el explorador de ficheros de Windows) hacia el
Astucia
editor de análisis. Esto lo veremos en el párrafo siguiente.
2. Se abre el asistente de importación de un fichero.

3. Pase a la etapa siguiente.
4. Seleccione el formato del fichero a importar. Aquí, seleccione “Fichero Texto”. Pase a la etapa siguiente del
asistente.
5. Indique la ruta del fichero a importar: “\Autoformacion\Ejercicios\WD Mi Primera Base de

Datos\ModoLiquidacion.csv” que está en el directorio de instalación de WINDEV.
6. Pase a la etapa siguiente del asistente.
7. Indique los siguientes parámetros de importación:
 Registros delimitados por “<Retorno de carro/Salto de línea>”
 Columnas delimitadas por “<Punto y coma>”
 Cadenas delimitadas por “<Ninguno>”
 Separador decimal: “<Automático: punto o coma>”
8. No olvide marcar la opción “La primera línea contiene los nombres de las columnas”.

10. Aparecerá la estructura del fichero de datos que se va a crear. Conserve las opciones por defecto y pase a la
etapa siguiente.
11. El contenido del fichero CSV se convertirá automáticamente al formato HFSQL. El asistente propondrá crear el
fichero HFSQL en el directorio del proyecto. Conserve las opciones propuestas y pase a la etapa siguiente.
12. Valide el asistente. WINDEV creará el fichero de datos.
 Examinemos la descripción del fichero de datos importado:

1. Seleccione el fichero “ModoLiquidacion”.
2. En el menú contextual (clic derecho), seleccione la opción “Descripción del fichero de datos”.
3. En la ventana que se muestra, modifique la etiqueta del fichero: suprima “(Importado)”.
4. Clique sobre el icono para mostrar la descripción de las rúbricas del fichero de datos.
5. Este fichero de datos no contiene identificador automático ni clave única. Vamos a poner el campo “Codigo”
como clave única:
 Posicione la cinta de selección si es necesario en la rúbrica Código.
 En la parte derecha de la pantalla, clique sobre “Clave única”.
6. Obtendremos los datos siguientes:

7. Valide la ventana de descripción de los campos y luego la ventana de descripción del fichero.
Importación directa de ficheros de datos existentes
El último método que vamos a ver para crear ficheros de datos es la simple importación de ficheros de datos HFSQL
que ya existen. Vamos a utilizar este método para crear el fichero “Producto”.
 Para importar los ficheros de datos HFSQL:
1. En el explorador de ficheros de Windows, abra el subdirectorio siguiente de WINDEV:
“\Autoformacion\Ejercicios\WD Mi Primera Base de Datos”.
2. Seleccione el fichero “Producto.fic”.
3. Efectúe un “Drag and Drop” del fichero “Producto” hacia el editor de análisis WINDEV.
4. Se lanza el asistente de importación. Valide las distintas pantallas. El fichero de datos aparecerá en el editor
de análisis.
Todos los ficheros de datos necesarios, ya están presentes en el editor de análisis.
Hemos importado solamente la descripción del fichero “Producto” en el análisis de nuestro

proyecto. Los datos contenidos en el fichero “Producto” no se han importado a nuestro proyecto.
Para manipular los datos del fichero que acabamos de importar, copie en el explorador de
ficheros, los ficheros “Producto.fic”, “Producto.mmo” y “Producto.ndx” (que están en el directorio
Atención!
“\Autoformacion\Ejercicios\WD Mi Primera Base de Datos”) hacia el subdirectorio EXE del

directorio de su proyecto.
Observación: Para abrir directamente el explorador de ficheros en el directorio de su proyecto,
en el panel “Inicio”, en el grupo “General, clique sobre
Creación de las relaciones

Hemos creado todas las descripciones de ficheros necesarios para la aplicación de la gestión de los productos.
Ahora vamos a crear las relaciones entre los ficheros de datos. Una relación permite definir las constantes de
integridad (cardinalidades) entre dos ficheros de datos.

 Crearemos a continuación la relación entre el fichero “Cliente” y el fichero “Pedido”: un cliente puede tener uno o
varios pedidos, y cada pedido está relacionado con un cliente.
1. En el panel “Análisis” (existente en la cinta), en el grupo “Creación”, clique sobre “Nueva relación”. El cursor
del ratón se transforma en lápiz.
2. Clique sobre el fichero “Cliente” y luego sobre el fichero “Pedido”.
3. Se lanza el asistente de creación de relación.
4. Responda a las cuestiones planteadas por el asistente:
 Cada cliente tiene al menos un pedido: No

 Cada cliente puede tener varios pedidos: Si
 Cada pedido tiene al menos un cliente: Si
 Cada pedido puede tener varios clientes: No
Igualmente, puede introducir directamente las cardinalidades de la relación en el asistente.

Notas
5. Pase a la etapa siguiente. El asistente propone automáticamente la clave utilizada para la relación (IDCliente).
6. Muestre la pantalla siguiente del asistente. El asistente propone crear la clave “IDCliente” en el fichero Pedido
para almacenar el cliente correspondiente al pedido.

7. Acepte esta opción pasando a la pantalla siguiente.
8. Esta pantalla permite definir las reglas de integridad que se aplicarán automáticamente.
En nuestro caso, podrá elegir el comportamiento que desee cuando se elimina un cliente, así como el
comportamiento cuando se modifica el identificador del cliente.
9. Valide las reglas de integridad pasando a la pantalla siguiente.
10. Clique sobre la flecha verde. La relación se crea automáticamente en el editor de análisis.
 De la misma manera, cree una relación entre los fichero “ModoLiquidacion” y “Pedido”. Estos dos ficheros se
relacionan de la forma siguiente:
 Un pedido deberá tener un modo de liquidación
 Un modo de liquidación puede utilizarse por varios pedidos.
En el asistente:
 Las cardinalidades son las siguientes: ModoLiquidacion(0,n), Pedido (1,1)
 La clave de la relación corresponde a la rúbrica “Codigo”.
 Vamos ahora a crear una relación entre los ficheros “Pedido” y “Producto”. Esta relación nos permitirá crear un
fichero de relación, el fichero de líneas de pedido.
1. Cree de la misma forma la relación entre los ficheros.
2. Responda a las cuestiones planteadas por el asistente:
 Cada pedido tiene al menos un producto: No
 Cada pedido puede tener varios productos: Si
 Cada producto tiene al menos un pedido: No
 Cada producto puede tener varios pedidos: Si
3. Pase a la etapa siguiente. El asistente propone crear un fichero de relación. Conserve la opción “Crear
automáticamente el fichero de relación” y avance a la etapa siguiente.
4. El asistente propone la clave única del fichero Producto a utilizar. Seleccione “Referencia”. Pase a la siguiente
etapa.
5. Valide la creación de la clave pasando a la etapa siguiente.
6. Conserve las opciones por defecto concernientes a las reglas de integridad y pase a la siguiente etapa.
7. El asistente propone la clave única del fichero Pedido a utilizar. Seleccione “IDPedido”. Pase a la etapa
siguiente.
8. Valide la creación de la clave pasando a la etapa siguiente.
9. Conserve las opciones por defecto, concernientes a las reglas de integridad y pase a la siguiente etapa.
10. Clique sobre la flecha verde. El fichero de relación se crea automáticamente en el editor de análisis.
Ahora vamos a modificar el fichero de relación que ha creado WINDEV. En efecto este fichero contendrá las líneas del
pedido.
Vamos a:
 Modificar el nombre del fichero.
 Modificar el nombre de sus rúbricas.
 Añadir campos para conocer la cantidad de productos pedidos y el total de la línea de pedido.
 Primero vamos a renombrar el fichero. Ya hemos hecho una manipulación semejante cuando hemos cambiado el
texto del fichero importado. Pero aquí, no solo vamos a modificar el texto: vamos también a renombrar el fichero
físico enlazado con la descripción del fichero.
1. Seleccione el fichero “Pedido_Producto”.
2. En el menú contextual (clic derecho), seleccione la opción “Descripción del fichero de datos”.
3. En la ventana que se muestra, modifique:
 El nombre del fichero: “LineaPedido”.
 El nombre en el disco: “LineaPedido”.
 Ahora vamos a modificar las rúbricas de este fichero de relación

1. Clique sobre el icono para mostrar la descripción de las rúbricas del fichero de datos.

2. Este fichero tiene 3 rúbricas. Posicione la cinta de selección en el campo “IDPedido_Referencia”. Este campo
es una clave compuesta.
Una clave compuesta es un conjunto de campos que forman un índice.

Este tipo de clave permite recorrer el fichero de datos con criterios complejos o hacer búsquedas
Notas
sobre varios campos simultáneamente.
3. Para renombrar este campo:

 Clique sobre la columna “Nombre”.
 Sustituya “IDPedido_Referencia” por “IDLineaPedido”.
 Clique en la columna “Etiqueta”.
 Sustituya la etiqueta actual por “Identificador de LineaPedido”.
 A continuación, añadiremos 3 nuevas rúbricas a este fichero de relación: Cantidad, TotalTTC y TotalHT.
1. Posiciónese sobre una nueva línea y cree la rúbrica “Cantidad”. Esta rúbrica es de tipo “Numérico”.
2. Posiciónese sobre una nueve línea y cree la rúbrica “TotalTTC”. Esta rúbrica es de tipo “Monetario”.
3. Se muestra una ventana que indica que la rúbrica ya existe en el análisis y propone recoger sus
características:
Conserve las opciones seleccionadas por defecto y valide (botón verde).

4. Posiciónese sobre una nueva línea de la tabla y cree la rúbrica “TotalHT”. Esta rúbrica es de tipo “Monetario”.
Una vez más, acepte la descripción existente.
5. La descripción de las rúbricas “LineaPedido” es la siguiente:

6. Valide la descripción de los campo (botón verde bajo de la pantalla) y la del fichero.
El análisis es ahora el siguiente:
Generación del análisis

La generación del análisis consiste en validar las modificaciones del análisis (creación de ficheros de datos, adición o
supresión de rúbricas, …) y propagarlos en todo el proyecto (páginas, campos relacionados, informes, …).
La generación se propone automáticamente cada vez que se cierra el editor de análisis y se han efectuado
modificaciones.
También es posible generar el análisis manualmente. Es lo que vamos a hacer ahora:
 Para generar el análisis:
1. En el editor de análisis, en el panel “Análisis”, dentro del grupo “Análisis”, clique en “Generación”.
2. La generación del análisis se lanzará automáticamente.
Hemos modificado las descripciones de ficheros de datos existentes en el análisis.

Para actualizar los ficheros de datos de la aplicación, WINDEV lanza automáticamente el procedimiento de
modificación de los ficheros de datos (ficheros “.fic”) en función de su descripción en el análisis.
 Se lanza el asistente de modificación automática. Valide las distintas pantallas hasta que la pantalla le muestre los
ficheros a tener en cuenta.
 WINDEV detecta que el fichero ModoLiquidacion necesita una actualización. Conserve este fichero
seleccionado y pase a la etapa siguiente.

 El asistente propone realizar una copia de seguridad de los ficheros de datos existentes. No cambie nada y
pase a la etapa siguiente.
 El asistente propone introducir las contraseñas de protección de los ficheros de datos modificados por la
modificación automática. Conserve las opciones por defecto y pase la etapa siguiente.
 La lista de ficheros de datos a modificar aparecerá. Valide el asistente.
 Se ha realizado la actualización de los ficheros de datos.
 Cierre el editor de análisis.
Acaba de descubrir los principales pasos para la creación de un análisis.

Cuando su análisis esté descrito y generado, ya podrá:
 Crear un sitio completo mediante el RAD (Rapid Application Developpement). Crearemos la aplicación
correspondiente al análisis de esta manera en la siguiente lección.
 Crear una aplicación completa totalmente personalizada. Este método se utilizará para desarrollar una
aplicación completa basada en una base de datos en el capítulo 3 de este curso de auto-formación. Esta
aplicación se basará en un análisis correspondiente al que acabamos de crear en este capítulo.

Lección 2.4. El RAD completo
 ¿Qué es el RAD?
 Generación del RAD
 Prueba del proyecto

¿Qué es el RAD?
R.A.D. son las iniciales de “Rapid Application Developpement” (Desarrollo rápido de aplicación).
RAD permite construir automáticamente una aplicación, es decir, construir todas las ventanas, los informes y las
consultas necesarias.
Como ya hemos visto antes, para desarrollar una aplicación en WINDEV, hay que comenzar por crear un proyecto, y
eventualmente, un análisis. El análisis contiene la definición de las estructuras de los ficheros de datos manipulados
en los tratamientos.
El módulo RAD de WINDEV se apoya en este análisis. El módulo RAD está formado por un asistente, en el que podrá
elegir el modelo de aplicación a generar (el patrón RAD) y las principales opciones de funcionamiento de su apliación.
WINDEV proporciona distintos “Patrones RAD” que permiten generar varios modelos de
aplicación. Puede también crear sus propios patrones RAD.
Notas
Para más detalles, consulte la ayuda en línea (palabra clave: “Patrón RAD”).
Todas las ventanas, informes, consultas y código generados por RAD, son totalmente personalizables. También tiene
la posibilidad de modificar los tipos de campos, los valores por defecto, …
RAD permite igualmente generar ventanas de varios tipos, es el RAD Ventana. RAD Ventana está disponible cuando
crea una nueva ventana en su aplicación.
Aquí vamos a descubrir como utilizar el módulo RAD Proyecto.
RID (Rapid graphical Interface Design) (Diseño rápido del interface gráfico)
WINDEV permite también generar ventanas que contienen solamente los campos enlazados con
las rúbricas del análisis. Todo el código necesario para el funcionamiento de estas ventanas
Notas
queda a cargo del desarrollador.

Para más detalles, consulte la ayuda en línea (palabra clave: “RID”).
Generación del RAD

 Para lanzar la generación del RAD:
1. En el panel “Proyecto”, dentro del grupo “Generación”, clique sobre “RAD Aplicación completa”.
Se lanza el asistente de generación de aplicación RAD.

2. Seleccione el modelo a utilizar para la generación del RAD: por ejemplo: “RAD Simple”. Pase a la etapa
siguiente del asistente.
3. Todos los ficheros de datos del análisis se tendrán en cuenta:
4. Muestre la siguiente pantalla.

5. Los puntos de entrada de la aplicación corresponden a las entradas disponibles en el menú.
Conserve solamente los ficheros Cliente, Pedido, ModoLiquidacion y Producto. Muestre la siguiente pantalla.
6. Indique si los campos Tabla generados en las ventanas de la aplicación deberán permitir la entrada o no. En
nuestro ejemplo, los campos Tabla permitirán al usuario introducir las nuevas informaciones. Seleccione “Si:
Autorizar la entrada en los campos Table”. Muestre la siguiente pantalla.
7. Indique si debe utilizarse el groupware usuario en la aplicación. El groupware usuario lo veremos más
adelante en una próxima parte del curso. Seleccione la opción “No: No integrar la gestión de groupware
usuario”. Pase a la etapa siguiente.

8. Indique si el menú automático deberá integrarse en la aplicación. Responda “Si: Integrar el menú ‘?’”.
9. Avance a la etapa siguiente. Finaliza el asistente de generación del RAD y se abre el asistente de generación
del menú automático.
El menú automático es un menú de ayuda adaptado a sus aplicaciones. Este menú permitirá a
Notas
los usuarios de sus aplicaciones acceder directamente a varias funcionalidades.
 Las distintas opciones propuestas por el asistente de generación del menú automático son las siguientes:

1. Conserve la opción “Ayuda de las FAA (Funcionalidades Automáticas de la Aplicación)”.
2. Finalice el asistente.
Cuando se crea el menú “?”, la opción “? .. Ayuda de las FAA (Funcionalidades Automáticas de la
Aplicación)” añade automáticamente en su aplicación:
 El componente “CCMenu”. En efecto, esta opción utiliza un procedimiento de este
Notas
componente para su funcionamiento.

 El fichero “WinDev FAA 21.PDF”. Este fichero se abrirá automáticamente cuando se
utilice esta opción del menú
La aplicación está generada y puede probarse.
Algunos errores de IHM pueden aparecer en el panel de los errores de compilación. Estos errores
señalan los problemas de interface especialmente en los informes (textos muy largos, por
Notas
ejemplo). Para corregir estos errores, es necesario modificar los informes.
Prueba de la aplicación
Probemos inmediatamente la aplicación generada.
 Para lanzar la prueba de la aplicación:
1. Clique sobre en los botones de acceso rápido. Se lanza la aplicación.

2. En el menú, seleccione la opción “Clientes/Prospectos .. Lista de Clientes/Prospectos”.
3. Se muestra la lista de clientes.
4. Para añadir una nueva persona, clique sobre el botón “Nuevo”. Aparecerá un formulario de entrada.

5. Introduzca las informaciones concernientes a un cliente y valide.
6. Cierre la lista de personas.
7. En el menú, seleccione la opción “Producto .. Lista de productos”. Aparecerá la lista de productos.
8. Cierre la ventana de pruebas. El editor de WinDev reaparecerá.

CAPÍTULO 3
Aplicación completa
con datos
Capítulo 3 – Aplicación completa con datos |101

 Presentación de la aplicación realizada en este capítulo

Presentación de la aplicación realizada en este capítulo
En este capítulo, vamos a realizar una aplicación manipulando los ficheros de datos con el formato HFSQL Clásico.
Esta aplicación de gestión de pedidos permitirá:
 Visualizar, introducir y modificar los productos.
 Imprimir los informes.
 Mostrar las estadísticas.
 Gestionar los niveles de uso.
 Enviar emails.
 …
El desarrollo de esta aplicación nos permitirá también abordar el despliegue y la difusión de la aplicación entre los
clientes finales.
Verá así todos los puntos importantes del desarrollo de una aplicación
Proyectos proporcionados
Proyecto ejemplo
Ya hemos visto en el capítulo anterior como crear un proyecto y un análisis. No volveremos a ello. Vamos a trabajar
en un proyecto que contiene ya un análisis y ficheros de datos previamente rellenos. El análisis de la aplicación es una
versión mejorada del análisis que había creado en el capítulo anterior.
 Para abrir este proyecto en WINDEV:
1. Si es necesario, cierre el proyecto en curso para hacer aparecer la ventana de bienvenida.
2. En la ventana de bienvenida, clique sobre “Curso de auto-formación” y seleccione el proyecto “Aplicación
completa (Ejercicio)”.
Antes de comenzar a desarrollar la aplicación, detengámonos un instante en el análisis asociados al proyecto “WD
Aplicación completa”.
 Para mostrar el análisis enlazado al proyecto, clique sobre en los botones de acceso rápido. Se muestra el
editor de análisis:
Este análisis contiene la descripción de 5 ficheros de datos:

 Cliente
 Pedido
 LineaPedido
 Producto
 ModoLiquidacion
Este análisis es voluntariamente simple y permite gestionar un caso clásico de gestión de pedidos.

 Cierre el editor de análisis (clique sobre el aspa arriba a la derecha del menú).
Proyectos corregidos
¿Tiene dudas sobre el resultado a conseguir? ¿O no tiene tiempo de realizar todas las manipulaciones? Hay disponible
un proyecto corregido de la aplicación.
La aplicación que vamos a realizar conjuntamente es relativamente larga (es una aplicación completa que nos va a
permitir descubrir las principales funcionalidades de WINDEV), por lo que le proponemos dos proyectos corregidos:
 Un proyecto corregido correspondiente a las lecciones 3.2 a 3.4. Este proyecto contiene todas las ventanas
realizadas en estas lecciones.
Para utilizar este proyecto corregido:
completa (Con ventanas)”.
 Un proyecto corregido correspondiente a las lecciones 3.5 a 3.9. Este proyecto contiene la totalidad de la
aplicación propuesta.
Para utilizar este proyecto corregido:
completa (Corregido)”.

Lección 3.2. Ventanas adición y modificación
 Creación de una ventana de menú que lista los productos
 Creación de una ficha de producto
 Gestión de la adición y la modificación de un producto

Presentación
Vamos a crear las distintas ventanas que permitan listar, añadir y modificar los productos. Estas manipulaciones le
harán descubrir varios aspectos de la gestión de ficheros de datos y le harán igualmente utilizar ciertas
funcionalidades muy útiles de WINDEV.
 Si no ha abierto el proyecto “WD Aplicación Completa” en la lección anterior:
completa (Ejercicio)”.
Astucia: Si la ventana de bienvenida no se ha mostrado, en el panel “Inicio”, dentro del grupo “Ayuda en
línea”, despliegue “Guía de auto-formación” y luego seleccione la opción “Aplicación completa (Ejercicio)”.
Hay disponible un proyecto corregido. Este proyecto contiene las distintas ventanas creadas en
esta lección. Para abrir el proyecto corregido, en el panel “Inicio”, dentro del grupo “Ayuda en
Corregido
línea”, despliegue “Guía de Auto-formación” y luego seleccione “Aplicación completa (Con

ventanas)”.
Creación de una ventana que liste los productos

Para crear la ventana que liste los productos, primero que nada vamos a crear una ventana en blanco y luego
añadiremos todos los campos: veremos así todos los pasos necesarios para la creación de tales ventanas.
 Para crear una nueva ventana que liste los productos:
1. Cree una nueva ventana en blanco.
 Clique sobre en los botones de acceso rápido (o utilice el atajo [CTRL]+[N]).

 Se muestra la ventana de creación de un nuevo elemento: clique sobre “Ventana” y luego sobre “Ventana”.
 En el asistente, clique sobre la pestaña “Basada en un modelo” y elija “Utilizar: WINMOD_Modelo”. Valide.
Los modelos de ventanas

Un modelo de ventanas permite dar un aspecto homogéneo a las distintas ventanas de una
aplicación.
Un modelo de ventanas contiene todos los elementos gráficos comunes al conjunto de ventanas
de la aplicación. Un modelo de ventanas puede también contener código. En este caso, este
Notas
código será igualmente común a todas las ventanas de la aplicación.

Para este ejemplo, hemos creado el modelo de ventanas WINMOD_Modelo. Este modelo
contiene un logo que aparecerá en todas las ventanas:
2. La nueva ventana aparecerá en el editor.

3. Guarde la ventana: Clique sobre en los botones de acceso rápido.
4. En la ventana que aparece, indique el título de la ventana “Menú”.

5. El nombre de la ventana (que se utilizará por ejemplo en programación) se deduce automáticamente del
título de la ventana. Si este nombre no le conviene, se puede modificar y especificar un título distinto del
nombre de la ventana.
6. Valide.
Hemos llamado a esta ventana “Menú” porque esta ventana es la ventana principal de nuestra
Notas
aplicación. Servirá de menú, pero también para mostrar las informaciones.
Creación de los campos

Para crear la lista de productos, vamos a utilizar un campo Tabla. Este campo estará enlazado con el fichero de datos
“Producto”.
¿Qué es un campo Tabla?

No hay que confundir “Tabla” y “Campo Tabla”.
Se habla de Tabla para una base de datos de tipo SQL.
Se habla de Campo Tabla para visualizar en un tablero los datos (o “navegador” o incluso “hoja
de datos”). En este caso, los datos pueden estar introducidos o provenir de un fichero de datos
(o de una tabla).
El campo Tabla de WINDEV permite visualizar o modificar los datos:
Notas
 En memoria: se habla entonces de campo Tabla memoria o Campo Tabla relleno por
programación.
 Proveniente de ficheros de datos o de consultas: Se habla entonces de campo Tabla
Fichero.
 Proveniente de variables WLangage: se habla entonces de tabla sobre fuente
 Para crear el campo Tabla:

1. En el panel “Creación”, dentro del grupo “Datos”, despliegue “Tabla y lista” y seleccione “Tabla (vertical)”. El
campo en creación sigue entonces el movimiento del ratón.
2. Clique dentro de la ventana: el asistente de creación del campo Tabla se lanzará.
3. El campo Tabla que estamos creando deberá mostrar los registros del fichero de datos “Producto”. En el
asistente, seleccione l opción “Mostrar los datos de un fichero o de una consulta existente”. Pase a la etapa
siguiente clicando sobre la flecha del asistente.
4. La siguiente pantalla del asistente propone los distintos ficheros de datos y las consultas presentes en el
proyecto en curso. Despliegue “Análisis” si hace falta y seleccione el fichero “Producto”. Pase a la etapa
siguiente.

5. El asistente propone la lista de las rúbricas presentes en el fichero “Producto”. Por defecto, todas las rúbricas
están marcadas para mostrarse en el campo Tabla. En nuestro caso, vamos a mostrar todas las rúbricas
EXCEPTO el identificador “IDProducto”, que corresponde al identificador automático del fichero de datos.
Desmarque IDProducto y pase a la etapa siguiente.

6. El asistente propone a continuación seleccionar la rúbrica de clasificación. Esta rúbrica se utilizará para
clasificar los datos mostrados en el campo Tabla. Las rúbricas propuestas en el asistente se corresponden con
las rúbricas definidas como claves dentro del análisis. Vamos a clasificar los productos según su etiqueta.
Clique sobre la línea “Etiqueta” y pase a la etapa siguiente.

7. Las siguientes pantallas corresponden a los parámetros suplementarios. Conserve las opciones por defecto
hasta el fin del asistente y luego, valide el asistente.
8. El campo Tabla se crea automáticamente en la ventana. El campo se posiciona automáticamente y se
agranda para ocupar todo el espacio disponible en la ventana.

Detengámonos un instante sobre el campo que acabamos de crear: los datos se muestran en el campo, incluso en el
editor. Este es el concepto del “Live Data”: el contenido de los ficheros de datos existentes en el puesto de desarrollo
se utilizan en las ventanas o en los informes manipulados en el editor. Esta funcionalidad es muy interesante por
ejemplo para definir el tamaño de los campos presentes en una ventana.
 Vamos a continuación a probar la ventana que acabamos de crear.

2. La ventana aparece automáticamente con sus datos en ejecución.
3. Puede hacer desfilar los productos gracias al ascensor (o con la ayuda de las flechas del teclado).
 Pongámonos unos instantes en el sitio del usuario final para ver las posibilidades del campo Tabla en ejecución.

Algunas observaciones.
 En primer lugar, en ejecución el campo Tabla tiene el mismo aspecto que en el editor: es la noción de
WYSIWYG (“What You See Is What You Get”): Lo que ve es lo que se obtiene.
 Dos pequeños pictogramas aparecen arriba de las columnas:
o La doble flecha indica que la columna puede clasificarse (Columna “Referencia” o “Etiqueta” por
ejemplo).
Por ejemplo, clique dos veces sucesivamente en la columna “Etiqueta”: los datos mostrados se clasifican de
forma distinta. Una flecha a la izquierda de la columna indica que la columna está clasificada, así como el
sentido de clasificación.
 La lupa indica que puede realizarse directamente una búsqueda en la columna.
Por ejemplo, clique sobre la lupa de la columna “Referencia”. Aparecerá una zona de introducción que
permitirá introducir la referencia buscada. Introduzca “REF-010”. Automáticamente, el producto
correspondiente a esta referencia se mostrará.

 Un menú contextual está disponible en el campo Tabla y en cada una de sus columnas. Este menú contextual
puede mostrarse:
o Con un clic derecho sobre la columna del campo Tabla.
o Con un clic sobre la flecha situada a la extremidad de las cabeceras de las columnas.
Este menú contextual permite entre otras cosas, exportar el contenido del campo Tabla al formato Excel,
imprmirlo, …
En algunos minutos, acabamos de ver y probar algunas funcionalidades que están incluidas automáticamente con el
campo Tabla. No tiene que programar nada para proponer estas funcionalidades a sus usuarios. Estas funcionalidades
se llaman “FAA (Funcionalidades Automáticas de la Aplicación).
Numerosos campos proponen las FAA por defecto. Si estas funcionalidades no deben proponerse
(por razones de seguridad o de confidencialidad), es posible desactivarlas en el editor o por
Notas
programación. Para más detalles, consulte la ayuda en línea (palabra clave: “Funcionalidades
automáticas de la aplicación”).
Tener la lista de los productos, está muy bien, pero poder modificar un producto, es mejor. Ahora vamos a crear una
ventana que muestre el detalle del producto para poder modificarlo.
 Cierre la ventana que se está probando con el aspa situada arriba de la pantalla. El editor de WINDEV
reaparecerá.
Creación de una ventana “Ficha Producto”

 Para crear una ventana que muestre el detalle de un producto:
1. Abra si es necesario el proyecto “WD Aplicación completa”.
 Clique sobre en los botones de acceso rápido.

 La ventana de creación de un nuevo elemento se mostrará: clique sobre “Ventana” y luego sobre “Ventana”.
 Se lanzará el asistente de creación de ventanas.
 En la pestaña “Basada en un modelo”, elija “Utilizar: WINMOD_Modelo” y valide el asistente.
3. Guarde la ventana ( o [CTRL]+[S]). Esta ventana tiene como título “Ficha del producto” y su nombre
“WIN_Ficha_del_producto” se propone automáticamente. Valide la ventana de salvaguarda.
Creación de los campos de entrada

La ventana que vamos a crear está destinada a mostrar las características del producto seleccionado en el campo
Tabla. Este tipo de ventana se llama una “Ficha” simplemente porque corresponde a una ficha descriptiva del
elemento deseado.
En nuestro caso, esta ventana va a mostrar el contenido de las distintas rúbricas del fichero de datos “Producto”.
 Para crear los campos en la ventana:
1. Muestre si es necesario el panel “Análisis”: en el panel “Inicio”, dentro del grupo “Entorno”, despliegue
“Pestañas” y seleccione “Análisis”. Los distintos ficheros de datos descritos en el análisis “WD Aplicación
completa” aparecen en el panel.
2. Clique sobre el icono a la izquierda del fichero “Producto”: las rúbricas del fichero de datos se listan.
3. Seleccione con la ayuda del ratón el conjunto de las rúbricas mostradas en el panel (excepto la rúbrica
“IDProducto”). Puede por ejemplo utilizar la multi-selección manteniendo la tecla [CTRL] presionada.
4. Efectúe un “Drag and Drop” (deslizar/desplazar) de estas rúbricas hacia la ventana que acaba de crear.
5. Distintos campos se crean automáticamente en la ventana. Estos campos se enlazan a la rúbrica

correspondiente en el fichero de datos. Para verificarlo:
 Seleccione por ejemplo el campo “Referencia”.
 Muestre el menú contextual (clic derecho) y seleccione la opción “Descripción”.
 Muestre la pestaña “Enlace” de la ventana de descripción:
Esta pestaña permite ver que el campo de edición está enlazado a la rúbrica “Referencia” del fichero de datos
“Producto”.
6. Cierre la ventana de descripción.
 Reposicione los campos en la ventana y redimensione la ventana para obtener el siguiente interface:
Creación de los botones

La ventana “WIN_Ficha_del_producto” permitirá añadir un nuevo producto o modificar un producto existente en la
lista.
Vamos a continuación a añadir un botón de validación y un botón de anulación.
 Para crear el botón “Validar”.
1. En el panel “Creación”, en el grupo “Campos habituales”, despliegue “Botón” (clique sobre la flecha situada
bajo de ).
2. Se muestra la lista de botones predefinidos.
3. Clique sobre “Validar”: la forma del botón aparecerá bajo del ratón.
4. Clique a continuación a la derecha de los campos de entrada para crear el botón.
 Añada el botón “Anular” utilizando el mismo principio.

1. En el panel “Creación”, en el grupo “Campos habituales”, despliegue “Botón” (clique sobre la flecha situada
bajo de ).
2. En la lista de botones predefinidos clique sobre “Anular”: la forma del botón aparece bajo el ratón.
3. Clique a continuación bajo del botón “Validar” para crear el botón.
Mejoras del interface de la ventana.

Esta ventana es una ventana relativamente simple, intentaremos mejorar su interface. De numerosos pequeños
detalles pueden convertirse rápidamente en molestias para el usuario, entonces es mejor tratarlos desde el principio.
Alineación de los campos
 Una de las primeras optimizaciones de realizar consiste en alinear los campos y darles el mismo tamaño:
1. Seleccione el campo “Etiqueta” y luego los restantes campos de la ventana (por ejemplo, manteniendo
pulsada la tecla [CTRL] y clicando sobre los distintos campos). El primer campo seleccionado servirá de
referencia para el tamaño de los otros campos.
2. En la cinta, muestre el panel “Alineamiento” de WINDEV. Este panel contiene todas las opciones posibles de
alineamiento disponibles para los campos.
3. Queremos que los bordes externos e internos de los campos estén alineados. Clique sobre la opción
“Justificar (Int. Y Ext.)”.
Si no sabe que alineamiento elegir, pase por encima de las distintas opciones propuestas por el
panel “Alineamiento” de WINDEV. Cuando pasa con el ratón sobre una de las opciones, los
campos seleccionados en la ventana se posicionan y/o redimensionan en función de la opción
sobre la que se pasa.
Notas
Si el posicionamiento le conviene, bastará con clicar sobre la opción.

Si el posicionamiento no le conviene, bastará con clicar en la ventana: los campos son devueltos
a la posición original.

Gestión de los anclajes
 Veamos ahora el aspecto visual de nuestra ventana:
1. En el panel “Modificación”, dentro del grupo “Vista previa”, clique sobre “Vista previa”. Este modo de
ejecución permite mostrar únicamente el interface de la ventana. Los distintos códigos no se ejecutan.
2. Agrande la ventana con la ayuda del cuadro de redimensionamiento bajo de la ventana. La posición de los
campos no se modifica y la ventana muestra una gran zona vacía. Para remediar este problema, hay dos
posibilidades:
 Prohibir el redimensionamiento de la ventana.
 Gestionar los anclajes, es decir gestionar el comportamiento de los campos cuando se redimensiona la
ventana. Esto es lo que vamos a hacer.
3. Cierre la vista previa: clique en el botón “Cerrar” de la vista previa, o en el aspa arriba a la derecha de la
ventana.
¿Cómo gestionar los anclajes de una ventana?

Para gestionar los anclajes:
1. En el editor, reduzca la ventana a su tamaño mínimo. Todos los bordes exteriores de la
Notas
ventana deberán estar “pegados” a un campo.

2. Revise uno a uno los campos y pregúntese “¿Cómo debe reaccionar el campo cuando se
haga más grande la ventana?”. Aplique entonces el anclaje correspondiente.
 Para esta ventana, vamos a definir los anclajes conjuntamente:

1. Los botones “Validar” y “Anular” deberán estar siempre pegados a la derecha.
 Seleccione estos dos campos.
 Muestre el menú contextual (clic derecho) y seleccione la opción “Anclaje”.
 En la ventana de descripción de anclajes, seleccione la opción “Derecho” y valide.

 Dos pequeñas flechas rojas aparecen en el editor indicando que los campos se anclan a la derecha.
2. Los campos de entrada deberán agrandarse en anchura:
 Seleccione los cuatro campos de entrada.
 Muestre el menú contextual (clic derecho) y seleccione la opción “Anclaje”.
 En la ventana de definición de los anclajes, seleccione la opción “Anchura” ( ).
 Valide.
3. Vamos a probar nuevamente el funcionamiento de esta ventana en vista previa:

 En el panel “Modificación”, dentro del grupo “Vista previa”, clique sobre “Vista previa”.
 Agrande la ventana: los campos deberán agrandarse también en anchura.
 Ahora, solo queda definir el funcionamiento cuando se agranda en altura.
4. El campo “Descripción” puede contener una descripción más o menos importante. Este es el campo más
importante de la ventana: es necesario que ocupe el máximo espacio disponible. Aplique un anclaje en altura
y anchura ( ).
5. El campo “Precio HT” se queda automáticamente encuadrado en rojo: el editor de ventanas indica un
problema de anclaje. En efecto, si el campo “Descripción” se estira hacia abajo, el campo “Precio HT” deberá
también desplazarse del mismo modo hacia abajo.
6. Abra la ventana de anclajes del campo “Precio HT”. El anclaje ideal se propone automáticamente: “Anchura y
hacia abajo” (hay presente una marca verde). Seleccione el anclaje propuesto y valide.
7. Vamos nuevamente a probar el funcionamiento de esta ventana en vista previa:
 En el panel “Modificación”, dentro del grupo “Vista previa”, clique sobre “Vista previa”.
 Agrande la ventana: los siguientes campos deberán agrandarse en anchura y en altura.

8. Cierre la vista previa de la ventana para regresar al editor.
9. Guarde la ventana ( o [CTRL]+[S]).
Mostrar la ficha desde la lista de productos

Ahora veamos como mostrar la ficha del producto seleccionado en la lista de productos. El principio es muy sencillo:
el usuario seleccionará el producto en el campo tabla y mostrará el detalle pulsando un botón.
 Vamos primero a modificar la ventana “WIN_Menu” para crear un botón de modificación:
1. Sitúese sobre la ventana “Menu”: clique sobre el botón “WIN_Menu” en la barra de botones:
2. Actualmente, el campo Tabla ocupa la totalidad de la ventana. Agrande el tamaño de la ventana hacia la
derecha. El campo Tabla se agrande también, por el mecanismo del anclaje.
3. Disminuya el tamaño del campo Tabla para que se muestren todas las ventanas.
 Seleccione el campo con ayuda del ratón: unos punteros aparecen alrededor del campo.
 Seleccione el puntero a la derecha del campo con el ratón para disminuir el tamaño del campo.
4. Ahora ya tenemos sitio a la derecha de la tabla para crear el botón de visualización del producto.
 Para crear el botón de visualización del producto:
1. En el panel “Creación”, en el grupo “Campos habituales”, despliegue “Botón” (clique en la flecha situada bajo
).
2. En la lista de botones predefinidos, clique sobre “Modificar”. La forma del botón aparecerá bajo el ratón.
Clique a continuación a la derecha del campo Tabla para crear el botón.
3. Haga un clic derecho sobre el botón y en el menú que se muestra, seleccione la opción “Código”.
4. En la ventana de código que aparece, introduzca el siguiente código en el tratamiento “Clic sobre”:
Open (WIN_Ficha_del_producto)
Déjese guiar por el asistente para la introducción del código (también llamado “Completar”):
desde el momento que teclea el paréntesis abierto “(“, se abre una lista desplegable
proponiendo el nombre de todas las ventanas existentes en el proyecto. Bastará con seleccionar
Notas
la ventana con el teclado o con el ratón.

Si no encuentra el nombre de la ventana que busca en la lista, es que no se ha guardado
previamente.
5. Examinemos este código: la función Open permite abrir la ventana “WIN_Ficha_del_producto”. Ya hemos
visto esta función en el primer capítulo de este curso.
6. Guarde las modificaciones clicando sobre en los botones de acceso rápido.
7. Cierre la ventana de código (clique sobre el aspa arriba a la derecha del editor de código).
Vamos ahora a modificar la ventana “WIN_Ficha_del_producto” para mostrar el producto seleccionado en el campo
Tabla.
 Muestre la ventana “WIN_Ficha_del_producto” en el editor: clique sobre el botón correspondiente en la barra de
botones.
 Para mostrar los datos del producto:
1. Muestre los tratamientos asociados a la ventana.
 En la zona al lado de la ventana (llamada “zona de inicio”), haga un clic derecho del ratón.
 En el menú contextual que se muestra, seleccione “Código”.
 Aparecerá el editor de código.
2. En el tratamiento “Fin de inicialización de WIN_Ficha_del_producto”, introduzca el siguiente código:
// Afectar el contenido de las rúbricas en los campos
FileToScreen ()
 Muestre la ventana “WIN_Menu” en el editor: clique sobre el botón correspondiente en la barra de botones.
 Pruebe la ventana ( en los botones de acceso rápido).

 En la lista de productos, clique sobre uno de los productos con el ratón.
 Clique sobre el botón “Modificar el elemento”.
 Se muestra la ventana de detalle del producto.
 Cierre las ventanas utilizando el aspa (X) arriba a la derecha de las ventanas.
Gestión de la modificación de un producto

Vamos ahora a modificar la ventana “WIN_Ficha_del_producto” para gestionar la modificación de un producto.
Vamos a:
 Permitir al usuario modificar la imagen del producto.
 Añadir los botones para guardar o anular las modificaciones efectuadas en la ficha.
Modificar la imagen del producto
El usuario podrá modificar la imagen del producto en la ficha Producto. Para ello, vamos a proponerle un botón
“Modificar” situado debajo de la imagen del producto. Este botón abrirá un selector de imágenes, que permitirá
seleccionar la imagen a utilizar.
 Primero, muestre si es necesario la ventana “WIN_Ficha_del_producto” en el editor: clique sobre el botón
correspondiente en la barra de botones.
 Para crear el botón de modificación:
1. En el panel “Creación”, dentro del grupo “Campos habituales”, despliegue “Botón”: la lista de los botones
predefinidos se muestra. Clique en “Modificar”.
2. La forma del botón aparecerá bajo el ratón. Clique a continuación en la ventana, bajo de la imagen del
producto.
3. Redimensione, si hiciera falta, el botón (con la ayuda de los punteros) para que el botón tenga la misma
anchura que el campo imagen.
Cuando se redimensiona el campo, un efecto de magnetismo automático simplifica el

Notas
alineamiento del botón con el campo imagen.
4. Haga un clic derecho sobre el botón. En el menú que se muestra, seleccione la opción “Código”.
5. En la ventana de código que se muestra, introduzca el siguiente código en el tratamiento “Clic sobre”:
fImageSelect (

6. El editor de código propone un asistente de código.
 Clique sobre “Asistente de la función fImageSelect”.
 Se lanza el asistente de código.
WINDEV propone numerosos asistentes de código que con la ayuda de preguntas sencillas van
escribiendo la o las líneas de código correspondiente. No dude en utilizarlos, así evitará muchos
Notas
errores de sintaxis.
7. Conserve todas las opciones por defecto del asistente y valide. El código correspondiente se inserta
automáticamente:
sFichero is string
// Abre el selector de imágenes
sFichero = fImageSelect (“”,””,”Seleccione una imagen …”)
8. Añada el siguiente código:
// Si se ha seleccionado un fichero
IF sFichero <> “” THEN
// Afecte la imagen al campo Imagen
IMG_Visual = sFichero
END
Este código permite mostrar el fichero seleccionado al campo Imagen existente en la ventana.
9. Cierre el editor de código (clique sobre el aspa arriba a la derecha del editor de código).
Probaremos esta funcionalidad cuando la gestión de las modificaciones efectuadas en la ficha se haya finalizado.
Validación de las modificaciones del producto
Ya hemos creado 2 botones en la ventana “WIN_Ficha_del_producto”:
 Un botón “Validar” para gestionar la validación de las modificaciones.
 Un botón “Anular” para gestionar el retorno a la lista de productos.
Vamos ahora a introducir el código WLangage necesario para su funcionamiento.
 Primero, muestre si hiciera falta la ventana “WIN_Ficha_del_producto” en el editor: clique en el botón
correspondiente en la barra de botones.
 Vamos ahora a introducir el código del botón “Validar”.
1. Haga un clic derecho sobre el botón y luego seleccione la opción “Código” en el menú contextual.
2. En el tratamiento “Clic sobre”, introduzca el siguiente código:
ScreenToFile ()
HModify (Producto)
Close ()
Examinemos este código:
 La función ScreenToFile permite inicializar las rúbricas con los valores de los campos enlazados, para el
registro en curso. Esta función es equivalente a las siguientes líneas:
Producto.Referencia = EDT_Referencia
Producto.Etiqueta = EDT_Etiqueta
Producto.Descripcion = EDT_Descripcion
…
Nuestra ventana utiliza menos de 10 campos y ya se nota la ventaja; piense simplemente con las ventanas que
contienen varias decenas de campos: una sola línea de código realiza todas las afectaciones!
 La función HModify permite actualizar los datos del fichero de datos para el registro actual.

 Las modificaciones realizadas en la ventana “Ficha del producto” deberán ser tenidas en cuenta en el campo
Tabla listando los productos. Para ello, simplemente vamos a modificar el código del botón “Modificar” en la
ventana “WIN_Menu”.
1. Muestre la ventana “WIN_Menu” en el editor: clique sobre el botón correspondiente en la barra de botones.
2. Seleccione el botón “Modificar” y muestre el editor de código (opción “Código” del menú contextual del
botón).
3. Modifique el tratamiento “Clic sobre” de la siguiente forma:
TableDisplay (TABLA_Producto, taCurrentSelection)
 La función TableDisplay permite actualizar el campo Tabla.
 La constante taCurrentSelection permite especificar que el campo Tabla deberá actualizarse a partir de la
posición de la cinta de selección.
Probar la modificación de un producto
 Para probar la modificación de un producto:
1. Lance la prueba del proyecto ( en los botones de acceso rápido).
2. WINDEV pide seleccionar la primera ventana del proyecto. En nuestro caso, esta ventana corresponderá a
“WIN_Menu”. Seleccione esta ventana y valide.
La primera ventana del proyecto corresponde a la primera ventana que se abre cuando se lanza
la aplicación.
La primera ventana puede definirse:
 Cuando se crea el proyecto.
 Cuando se crea el ejecutable.
Notas
 En el explorador del proyecto: hay que seleccionar la ventana deseada, mostrar el menú
contextual y seleccionar la opción “Primera ventana del proyecto”.
Cuando se ha definido la primera ventana del proyecto, un pequeño 1 rojo aparece delante del
nombre de la ventana en el explorador del proyecto.
3. En la lista de productos, seleccione un producto en el campo Tabla (por ejemplo, el primero) y clique sobre el
botón “Modificar”.
4. El detalle del producto seleccionado aparece en la ventana ficha.
5. Modifique el precio de 100,23 euros e introduzca 200,00 y luego clique sobre el botón “Validar”.
6. Al volver a la lista de productos, podrá constatar que el precio de este artículo se ha actualizado.
7. Muestre de nuevo el detalle del producto.
8. Clique sobre el botón “Modificar” debajo de la imagen. Se mostrará el selector de imágenes. Seleccione una
imagen y valide. La imagen aparece en la ficha.
9. Clique sobre el botón “Anular”. La modificación de la imagen no se tiene en cuenta en el fichero de datos.
10. Cierre la aplicación clicando sobre el aspa.
Creación de un nuevo producto

El principio de la creación de un producto será el siguiente:
 En la ventana de la lista de productos, vamos a añadir un botón “Nuevo” que permitirá abrir la ventana “Ficha
del producto”.

 Modificaremos a continuación el código de la ventana “Ficha del producto” para gestionar la adición dentro
del fichero de datos Producto.
Añadir un botón
 Para añadir un botón “Nuevo” en la ventana “WIN_Menu”:
1. Muestre la ventana “WIN_Menu” en el editor: clique sobre el botón correspondiente en la barra de botones.
2. En el panel “Creación”, dentro del grupo “Campos habituales”, despliegue “Botón” y selecciones “Nuevo”.
3. La forma del botón aparecerá bajo el ratón. Clique a continuación dentro de la ventana. El botón se ha
creado.
4. Posicione el botón debajo del botón “Modificar” (si es necesario, modifique la posición del botón “Modificar”).
5. Modifique el código de este botón:

 Haga un clic derecho sobre el botón y luego seleccione la opción “Código” en el menú contextual.
 En el tratamiento “Clic sobre”, introduzca el siguiente código:
HRESET (producto)
TableDisplay (TABLE_Producto, taCurrentRecord)
 La función HRESET inicializa las variables de las rúbricas del fichero “Producto” con los valores por defecto
para gestionar un nuevo registro.
 La función Open permite abrir la ficha del producto para introducir el nuevo registro.
 La función TableDisplay permite volver a mostrar el campo Tabla. En este código, la constante
taCurrentRecord se utiliza: el campo Tabla se vuelve a mostrar a partir del registro actual.
Añadir en el fichero de datos
 Ahora, vamos a modificar la ventana del código del producto para gestionar la adición de un nuevo registro.
1. Muestre la ventana “WIN_Ficha_del_producto” en el editor.
2. Vamos a modificar el código del botón de Validación:
 Haga un clic derecho sobre el botón “Validar” y luego seleccione la opción “Código” en el menú contextual.
 En el tratamiento “Clic sobre”, sustituya el código por el siguiente:
ScreenToFile ()
IF producto..NewRecord THEN
HAdd (Producto)
ELSE
HModify (Producto)
END
Close ()
 La propiedad ..NewRecord permite conocer si el registro en curso deberá crearse.
 Si la función HRESET se ha llamado previamente, la propiedad devuelve True (caso de clic sobre “Nuevo
Producto”) y el registro deberá crearse por la función HAdd.
 En el caso contrario, el registro en curso ya existe, y deberá modificarse por la función HModify.
 La función HAdd añade el registro en el fichero de datos. Esta función toma los valores en memoria y escribe
le contenido de las rúbricas del fichero en el fichero de datos. Los índices se actualizan inmediata y
automáticamente. Aquí se sobreentiende que el fichero es “Producto”.

El código de texto de un nuevo registro, puede sustituirse por la función HSave. Esta función
permite probar si el registro ya existe en el fichero de datos y según el caso, permite bien
añadir, o bien modificar. El código se convierte entonces en:
Notas
ScreenToFile ()
HSave (Producto)
Close()

4. Cierre la ventana de código (clique en el aspa arriba a la derecha del editor de código).
Probar la adición de un producto.
 Para probar la adición de un producto:
1. Lance la prueba del producto ( en los botones de acceso rápido).

2. En la lista de productos, clique sobre el botón “Nuevo”.
3. Introduzca un nuevo producto con las siguientes características:
 Referencia: REF-337
 Etiqueta: SurfWD
 Descripción: Surf con los colores de WinDev
 Precio: 150
4. Valide. El nuevo producto aparecerá en la lista de productos.

5. Clique nuevamente en el botón “Nuevo”
6. Introduzca un nuevo producto con las siguientes características:
 Referencia: REF-337
 Etiqueta: SurfWB
 Descripción: Surf con los colores de WebDev
 Precio: 150
7. Valide. Aparecerá una ventana específica:

Esta ventana indica al usuario que existe un duplicado: efectivamente, la referencia (que es una clave única)
es idéntica para dos productos. Esta ventana permite modificar el valor de la referencia: introduzca por
ejemplo “REF-338”.
Esta ventana es una de las ventanas de gestión automática de errores HFSQL, disponible en estándar.
Cuando se añade o se modifica un registro, varios tipos de errores pueden surgir: error de
duplicados, error de integridad, error de contraseña, …
WINDEV propone varios modos de gestión de estos errores:
 Modo automático: Para cada error encontrado en la gestión de registros de la base de
datos, una ventana específica se mostrará al usuario. Esta ventana permitirá al usuario
modificar directamente los datos.
Notas
 Modo programado avanzado: Para cada error encontrado en la gestión de los registros
de la base de datos, se llamará a un procedimiento o una ventana personalizada de gestión
de errores.
El ejemplo didáctico “Detección de errores”, proporcionado con WINDEV permite probar estos
modos de gestión de los errores. Este ejemplo puede abrirse por la ventana de inicio de WINDEV
([CTRL]+[>], a través de la opción “Abrir un ejemplo”.
Visualizar los registros introducidos

Los nuevos registros que hemos introducido pueden visualizarse inmediatamente en el campo Tabla de la ventana
“WIN_Menu”.
Pero en algunos casos, durante las pruebas por ejemplo, puede ser necesario ver directamente el contenido de los
ficheros de datos.
WINDEV propone un herramienta sencilla que permite ver el contenido de los ficheros de datos durante el desarrollo
de la aplicación (cuando por ejemplo, las ventanas de visualización no se han creado todavía).
Esta utilidad se llama WDMAP. Vamos a utilizarla para ver el contenido del fichero Producto.
 Para lanzar WDMAP:
1. En el panel “Utilidades”, dentro del grupo “Base de datos”, clique en “WDMAP”.
2. Seleccione el fichero “Producto”. Se mostrará el fichero de datos.

3. Clasificando los elementos por referencia (clique sobre la cabecera de la columna “Referencia”), aparecerán
los dos nuevos registros que hemos añadido.

Lección 3.3. Búsqueda simple y recorrido por
los registros
 Gestión de la búsqueda de registros
 Recorrido sobre los registros

Presentación
Hemos gestionado la adición y la modificación de registros. Está muy bien. Pero será mucho mejor poder buscar un
registro (para modificarlos, por ejemplo). Esto es lo que vamos a hacer ahora.
Vamos a modificar la ventana principal de la aplicación “WD Aplicación Completa” para utilizar las pestañas del panel.
El primer panel permitirá mostrar la lista de los productos y gestionar la adición y la modificación de los productos (las
manipulaciones las hemos realizado en las lecciones anteriores).
El segundo panel propondrá la búsqueda de un cliente según su nombre. La ficha del cliente se mostrará en el panel.
Vamos a configurar dos modos de búsqueda:
 Una búsqueda idéntica.
 Una búsqueda genérica.
A continuación, se podrán recorrer los registros existentes en el fichero de datos a partir del cliente mostrado.
Corregido

ventanas)”.
Modificación de la ventana. Uso de un campo Pestaña

En este ejemplo, la búsqueda no se efectuará en una nueva ventana. Vamos a utilizar la ventana WIN_Menu. En la
actualidad, esta ventana muestra la lista de los productos.
Para mostrar varios datos distintos en esta ventana, vamos a utilizar las pestañas.
Las pestañas permiten reagrupar las informaciones por temas. El usuario puede acceder directamente a un tema
clicando sobre la “pestaña” deseada.
Este sistema es el que se utiliza en todas las ventanas de descripción de WINDEV.
Creación del campo Pestaña

 Para mostrar los datos de la ventana “WIN_Menu” en una pestaña:
1. Muestre si es necesario la ventana “WIN_Menu”:

 O desde la barra de los botones.
 O haciendo doble clic en el nombre en el explorador del proyecto.
2. Seleccione los campos de la ventana y desplácelos a la zona de bienvenida de la ventana.
Esta manipulación puede parecer “bizarra”, pero así será más sencillo trabajar sobre el campo Pestaña y
luego asociar los campos en la pestaña deseada.
3. Cree un campo Pestaña en la ventana:

 En el panel “Creación”, en el grupo “Contenedores”, despliegue “Pestañas y asociados” y seleccione
“Pestaña”.
 Clique en la ventana para crear el campo Pestaña.
 Posicione el campo Pestaña arriba a la izquierda de la ventana.
 Por defecto, un campo Pestaña se crea con dos paneles. El campo Pestaña ocupa todo el sitio disponible en la
ventana.
4. Seleccione los campos presentes en el campo de bienvenida de la ventana y desplácelos hacia la pestaña 1.
5. Un cuadro verde aparece cuando sobrevuela los campos en el campo Pestaña. Este cuadro indica que los
campos posicionados en la pestaña se asociarán automáticamente al panel.
6. Agrande si hiciera falta la ventana y el campo Pestaña para mostrar el campo Tabla y los botones en el
campo Pestaña.
Manipulación de los campos en un campo Pestaña:

 Para verificar que todos los campos están correctamente asociados al panel de la pestaña en
curso, clique sobre otro panel: todos los campos asociados al panel desaparecen.
Notas
 Para redimensionar el campo Pestaña sin que se tenga en cuenta el anclaje de los campos
existentes en el panel, utilice la tecla [SHIFT] durante el redimensionamiento.

Modificaciones del campo Pestaña
 Modifique el nombre del campo Pestaña:
1. Doble clic sobre el campo Pestaña que acaba de crear: la ventana de descripción del campo se mostrará.
2. Modifique el nombre del campo. El campo tendrá por nombre “TAB_Visualización”.
 Se crean dos paneles por defecto. Vamos a modificar su etiqueta directamente:
1. Seleccione el campo Pestaña.
2. Clique sobre “Panel 1”. El panel pasa a modo edición: introduzca el texto “Lista de productos”. Valide con la
tecla [ENTER].
3. Clique sobre “Panel 2”. Se muestra el panel. Clique de nuevo sobre “Panel 2”. Introduzca el texto “Búsqueda
de clientes. Valide con la tecla [ENTER].
 Vamos a asociar una imagen a cada panel. Para ello:

1. Muestre la ventana de descripción del campo Pestaña (doble clic sobre el campo, por ejemplo). La pestaña
“General” de la ventana de descripción permitirá configurar las características de cada panel. La lista de los
paneles se muestra a la izquierda. Para cada panel seleccionado, sus características podrán modificarse en la
parte derecha de la ventana.
2. En la ventana de descripción, seleccione el panel “Lista de productos”.

3. Se mostrarán las características del panel.
4. Vamos a asociar una imagen al panel utilizando el catálogo de imágenes de WINDEV.
Desde el momento en que una imagen puede mostrarse en un campo o en una ventana,
WINDEV propone utilizar el catálogo de imágenes con el botón “Catalogo”. Este catálogo
Notas
contiene varios miles de imágenes, cliparts, …
5. Clique sobre el botón “Catálogo”. Aparecerá la ventana del catálogo de imágenes.

6. Seleccione el tema “Flat Soft” en el combo “Tema” y luego seleccione “Producto” en la zona de búsqueda.
Lance la búsqueda clicando sobre la lupa.
7. Seleccione la imagen y valide (botón verde).

8. Aparecerá una pantalla para parametrizar la imagen generada. Esta pantalla permite modificar las
características de la imagen a generar: tamaño, luminosidad, … Guarde las opciones por defecto y valide.
9. La imagen se genera en el directorio del proyecto y el fichero correspondiente se asocia automáticamente al
elemento en curso.
10. En la ventana de descripción, clique sobre “Búsqueda de clientes” en la lista de paneles estáticos.
11. En la zona derecha de la ventana, clique sobre el botón “Catálogo”. Aparecerá la ventana del catálogo de
imágenes.
12. En la zona de búsqueda, indique “Personas” (el tema “Flat Soft” utilizado en nuestra última búsqueda está
seleccionado por defecto). Lance la búsqueda clicando sobre la lupa.
13. Entre las imágenes propuestas, seleccione el icono que presenta a dos personas ( ) y valide.
14. Guarde las opciones de la ventana de parametrización de la imagen generada y valide.
15. Valide la ventana de descripción del campo Pestaña.

 Acabamos de crear un nuevo campo: Es necesario encargarnos de su anclaje en la ventana. Cuando la ventana
se agrande, es necesario que el campo Pestaña se agrande igualmente para ocupar todo el espacio disponible. El
campo deberá estirarse hacia la derecha y hacia abajo.
1. Seleccione el campo Pestaña.
2. Muestre el menú contextual (clic derecho) y seleccione la opción “Anclaje”.
3. En la ventana de definición del anclaje, seleccione la opción y valide.

4. Guarde la ventana clicando sobre en los botones de acceso rápido.
Implementación de la búsqueda
Hemos acabado de preparar la ventana “WIN_Menu”. Podremos ahora concentrarnos en el contenido del panel de
búsqueda de clientes.
Este panel estará dividido en varias zonas:
 Una zona de entrada de los elementos a buscar.
 Una zona de visualización de las informaciones encontradas.
 Una zona que contenga los botones de recorrido.
Zona de visualización de las informaciones encontradas
Primero vamos a crear los distintos campos que mostrarán las informaciones del cliente encontrado.
Para crear los campos de edición en la ventana, vamos a proceder del mismo modo que para la ventana de la ficha
del producto: un simple “Drag and Drop” desde el panle “Análisis”.
 Para crear los distintos campos que muestran las informaciones sobre el cliente:
1. Muestre la ventana WIN_Menu en el editor y clique sobre la pestaña “Búsqueda de clientes”. Aparecerá el
panel vacío.
2. Muestre si es preciso el panel “Análisis”: en el panel “Inicio”, dentro del grupo “Entorno”, despliegue
“Paneles” y seleccione “Análisis”. Los distintos ficheros de datos descritos en el análisis aparecerán en el
panel.
3. Clique sobre el icono a la izquierda del fichero “Cliente”: los campos del fichero de datos se listarán.
4. Seleccione con la ayuda del ratón la totalidad de las rúbricas mostradas en el panel. Puede por ejemplo
utilizar la multi-selección manteniendo pulsada la tecla [CTRL].
5. Haga un “Drag and Drop” (Deslizar/Desplazar) estas rúbricas hacia la pestaña “Búsqueda de clientes”.
6. Los campos se crearán automáticamente en la pestaña. Estos campos se enlazan automáticamente con las
rúbricas correspondientes en el fichero de datos.

 Vamos a alinear los campos y a ponerles el mismo tamaño:

1. Seleccione el campo “Ciudad” y luego los restantes campos de edición de la ventana (por ejemplo,
manteniendo pulsada la tecla [CTRL] y clicando sobre los distintos campos.
2. En el panel “Alineación”, en el grupo “Interna y externa”, clique sobre la opción “Justificar (Int. y Ext.).
 Pruebe la ventana ( en los botones de acceso rápido). Clique sobre la pestaña del panel “Búsqueda de
clientes”. La ventana aparecerá con todos los campos vacíos.
Búsqueda idéntica
Para realizar la búsqueda idéntica, vamos a seleccionar el nombre del cliente en un campo Combo. El botón “Buscar”
permitirá mostrar la ficha de la persona correspondiente. Solo una persona corresponderá al nombre seleccionado.
 El campo combo se colocará debajo de los campos que acabamos de crear. Si los campos están muy encima de
la pestaña, habrá que desplazarlos hacia abajo. Para ello:
1. Seleccione el conjunto de campos existentes en la pestaña:
 Utilice la combinación de teclas [CTRL]+[A]: Todos los campos de la ventana y del panel en curso se
seleccionarán.
 Pulse sobre la tecla [CTRL].
 Clique sobre la pestaña. Solo los campos del panel se seleccionarán.
2. Desplace los campos seleccionados hacia abajo con la ayuda del ratón.
3. Todos los campos se desplazarán hacia abajo.

 Para crear el campo de búsqueda:
1. Cree un campo de tipo Combo: En el panel “Creación”, en el grupo “Campos habituales”, clique sobre
“Combo”.
2. Clique a continuación en el panle “Búsqueda de cliente”, en la zona entre la pestañas y el campo
“Identificador del cliente”.

3. Se mostrará el asistente de creación de combos. Vamos a crear un combo basado en el fichero de datos
“Cliente”.
4. Seleccione la opción “Mostrar los datos de un fichero o de una consulta existente”. Avance al paso siguiente
del asistente.
5. Seleccione el fichero de datos “Cliente”. Avance al paso siguiente.
6. Vamos a mostrar el apellido y el nombre de la persona.
 Quite la selección a la rúbrica “IDCliente”.

 Seleccione la rúbrica “NombreCompleto”.
Avance al paso siguiente.
7. La rúbrica “NombreCompleto” se utilizará también para clasificar la lista de los clientes mostrados en el campo
Combo. Seleccione la rúbrica “NombreCompleto”. Avance al paso siguiente.

8. El valor devuelto por el campo Combo será el identificador “IDCliente”. Este será el valor que se buscará en el
fichero Cliente. Seleccione la rúbrica “IDCliente” y avance al paso siguiente.
9. El campo Combo no se enlazará con ninguna rúbrica. Guarde la opción “No” y avance al paso siguiente.
10. Valide la siguiente pantalla con la flecha amarilla.
11. Proporcione un nombre al campo (por ejemplo “COMBO_Cliente”) y un texto (por ejemplo “Cliente Buscado”).
12. Valide. Posicione el campo Combo en la ventana (por ejemplo, arriba a la izquierda).
13. Seleccione el campo Combo y con la ayuda de las asas, modifique su tamaño para poder ver el nombre
completo del cliente cuando se muestre.

 Para crear el botón de búsqueda:
1. Cree un botón: en el panel “Creación”, dentro del grupo “Campos habituales”, clique sobre .
2. Posicione el botón junto al combo que acaba de crear.
3. Este campo tiene como nombre “BTN_BuscaIdentica” y como texto “Búsqueda Idéntica”.
4. Si fuera necesario, adapte el tamaño del botón para que el texto aparezca correctamente en el mismo.
5. Introduzca el siguiente código:
// Búsqueda del cliente por su identificador
HReadSeekFirst (Cliente, IDCliente, COMBO_Cliente)
IF HFound (Cliente) THEN
// Muestra los datos del cliente
FileToScreen()
END
6. Examinemosestecódigo:
 La función HReadSeekFirst permite realizar una búsqueda idéntica. En este ejemplo, la búsqueda se realiza
en el fichero Cliente y sobre el campo “IDCliente”. El valor buscado corresponde al último parámetro de la
función. Aquí, el valor buscado corresponde al último parámetro de la función. Este valor es el conseguido al
utilizar directamente el nombre del combo (COMBO_Cliente).
 La función HFound permite comprobar el resultado de la búsqueda. Si la función HFound devuelve
TRUE, se ha encontrado un valor, y si la función HFound devuelve FALSE, no se ha encontrado ningún
valor. Cuando se encuentra un registro, este registro se lee: se convierte en el registro actual del fichero
de datos.
 En este código, si se ha encontrado el registro, se muestra mediante la función FileToScreen.
La función FileToScreen realiza la operación inversa a la función ScreenToFile: los datos

Notas
existentes en las rúbricas del fichero de datos, se muestran en los campos correspondientes.
7. Cierre el editor de código.

 Hagamos una prueba de la ventana:
1. Lance la prueba de la ventana ( en los botones de acceso rápido).

2. Clique si hace falta en la pestaña “Búsqueda de clientes”.
3. Seleccione un valor en el combo y clique sobre el botón de búsqueda.

4. El resultado es inmediato.
5. Cierre la ventana para volver al editor.
Búsqueda genérica
Ahora vamos a efectuar una búsqueda genérica. En vez de buscar exactamente el valor introducido, vamos a buscar
todos los elementos que empiecen por el valor introducido.
Para efectuar esta búsqueda, vamos a crear un campo de edición para introducir el nombre buscado y un botón para
lanzar la búsqueda.
 Para crear el campo de búsqueda:
1. Muestre si hiciera falta la pestaña “Búsqueda de clientes” en la ventana “WIN_Menu” en el editor.
2. Cree un campo de edición: en el panel “Creación”, dentro del grupo “Campos habituales”, clique sobre .
3. Clique en la ventana bajo el campo Combo “Cliente a buscar”. El campo de edición se ha creado.
4. El campo tiene como nombre “EDT_Nombre_Buscado” y como texto “Nombre buscado”.
 Para crear el botón de búsqueda:
1. Cree un botón: en el panel “Creación”, dentro del grupo “Campos habituales”, clique sobre .
2. Posicione el botón la lado del campo de edición que acaba de crearse.
3. Este campo tiene como nombre “BTN_BusquedaGenerica” y como texto “Búsqueda Genérica”.
4. Si hiciera falta, adapte el tamaño del botón para que el texto aparezca correctamente en el botón.
// Buscar un cliente por su nombre
HReadSeek (Cliente, NombreCompleto, EDT_Nombre_Buscado)
IF HFound (Cliente) THEN
FileToScreen()
ELSE
Error (“No se corresponde con ningún cliente”)
END
La función HReadSeek permite realizar una búsqueda genérica. En este ejemplo, se realiza en el fichero
“Cliente” y sobre la rúbrica “NombreCompleto”. El valor buscado corresponde al valor introducido en el campo
“EDT_Nombre_Busqueda”. Este valor se obtiene utilizando directamente el nombre del campo.
También se puede realizar una búsqueda idéntica con la función HReadSeek: para ello hay que
Notas
utilizar la constante hIdentical.


2. Clique si hiciera falta sobre la pestaña “Búsqueda de clientes”.
3. Introduzca un valor en el campo de edición (Por ejemplo “BEEF”) y clique sobre el botón de búsqueda.
4. El resultado es inmediato. Sin embargo, si existieran varios registros, solo se mostraría el primero.
5. Detenga la prueba y regrese al editor.
Recorrido de las fichas
Ahora vamos a añadir 4 botones que permitan recorrer los distintos registros del fichero “Cliente”. Estos botones son
del tipo “botones magneto”.
Están formados por un único icono y permiten mostrar:

 El primer registro.
 El registro anterior.
 El siguiente registro.
 El último registro.
 Para crear el botón que muestra el primer registro del fichero de datos:
1. Si fuera preciso, muestre la pestaña “Búsqueda de clientes” en el editor.
2. En el panel “Creación”, en el grupo “Campos habituales”, clique sobre .
3. La forma del botón aparecerá bajo el ratón. Clique a continuación en la pestaña, bajo el campo “Búsqueda
genérica”. El botón se creará automáticamente.
 Para uniformizar el interface de las ventanas, utilizamos una plantilla. Esta plantilla define el estilo de todos los
campos de las ventanas. Para cada botón magneto, hay definido un estilo específico. Para aplicar este estilo:
1. Seleccione si hiciera falte el botón.
2. Muestre el menú contextual (clic derecho) y seleccione “Elegir un estilo”.
3. En la ventana que aparece, aparecen todos los estilos definidos para los botones. Seleccione el estilo
“BTN_Primero”.
4. Valide
 Modifique el nombre del campo Botón.
1. Muestre la ventana de descripción del campo:
 Seleccione el campo Botón.
 Muestre el menú contextual (clic derecho) y seleccione la opción “Descripción”.
2. Este campo tiene como nombre “BTN_Primero”.
3. Valide la ventana de descripción.
 Ahora introduciremos el código WLangage asociado a este campo:
1. Haga un clic derecho en el campo. En el menú que aparece, seleccione la opción “Código”.
2. En la ventana de código que aparece, introduzca el siguiente código en el tratamiento “Clic sobre”:
// Leer el primer cliente
HReadFirst (Cliente)
IF HOut (Cliente) = True THEN
// No hay clientes
Info (“No hay ninguna ficha a visualizar.”)
ELSE
// Mostrar los datos del cliente
FileToScreen()

END
La función HReadFirst permite leer el primer registro del fichero de datos, según la clave utilizada por la última
búsqueda (en nuestro caso NombreCompleto).
 El modo idéntico, cree 3 nuevos botones.
 Estos botones tendrán por nombre: “BTN_Anterior”, “BTN_Siguiente” y “BTN_Ultimo”.
 Estos botones se asociarán respectivamente con los estilos: “BTN_Anterior”, “BTN_Siguiente” y “BTN_Ultimo”.
 Él código del “BTN_Anterior” será el siguiente:
// Lee el cliente anterior
HReadPrevious (Cliente)
// Si se sobrepasa el inicio del fichero
Info (“Se ha llegado al principio del fichero”)
ELSE
FileToScreen ()
END
 El código del botón “BTN_Siguiente” es el siguiente:
// Lee el siguiente cliente
HReadNext (Cliente)
// Si se sobrepasa el final del fichero
Info (“Se ha llegado al final del fichero”)
ELSE
FileToScreen ()
END
 El código del botón “BTN_Ultimo” es el siguiente:
// Lee el último cliente
HReadLast (Cliente)
// Ningún cliente
Info (“No hay ninguna ficha a visualizar.”)
ELSE
FileToScreen()
END
En los distintos códigos:
 La función HReadLast permite leer el último registro del fichero de datos, según la clave utilizada en la
última búsqueda.
 La función HReadNext permite leer el registro con la clave inmediatamente superior a la del registro actual.
 La función HReadPrevious permite leer el registro con la clave inmediatamente inferior a la del registro
actual.
En todos los casos:
 La función HOut permite conocer si el fichero de datos está vacío.
 La función FileToScreen permite mostrar el registro en la pantalla.
 Guarde la ventana clicando sobre en los botones de acceso rápido.

2. Clique si hiciera falta sobre la pestaña “Búsqueda de clientes”.
3. Busque un cliente (por ejemplo, una búsqueda genérica de “BEEF”).
4. Recorra el fichero de datos clicando sobre cada uno de los botones de recorrido.
5. Detenga la prueba para regresar al editor.

Lección 3.4. Búsqueda multi-criterio
 Creación de una consulta parametrizada.
 Creación del interface de selección de criterios de búsqueda.
 Paso de parámetros a una consulta.
 Mostrar el resultado de una consulta en un campo Tabla

Presentación
Habíamos visto en la lección anterior como realizar una búsqueda son un solo criterio (el nombre del cliente). En esta
lección, vamos a permitir al usuario realizar una búsqueda multi-criterio.
En nuestro ejemplo, esta búsqueda se realizará sobre el fichero “Pedido”. El usuario podrá seleccionar:
 El estado del pedido.
 Su modo de liquidación.
 Las fechas de los pedidos tenidos en cuenta.
El interface de la ventana “WIN_Menu” será el siguiente:
Este interface está formado por:

 Campos que permiten seleccionar los criterios de búsqueda.
 Campos que permiten lanzar la búsqueda o imprimir el resultado.
 Un campo Tabla que permite mostrar el resultado de la búsqueda. Este campo Tabla está basado en una
consulta. Esta consulta permitirá seleccionar los registros a mostrar. El campo Tabla listará el resultado de la
búsqueda.
La primera etapa, consistirá en crear la consulta de selección de los registros.
¿Qué es una consulta de selección?

Una consulta de selección es una consulta que va a “elegir” solamente los registros
correspondientes a los criterios especificados.
Notas
Este tipo de consulta se llama consulta de selección porque en lenguaje SQL utiliza la orden
SELECT.
Corregido

ventanas)”.
Creación de la consulta para buscar los pedidos

Creación de la consulta

 Para crear la consulta, utilizaremos el editor de consultas.
1. Clique sobre en los botones de acceso rápido. Se mostrará la ventana de creación de un nuevo elemento:
Clique sobre “Consulta”. Se abre el asistente de creación de una consulta.
2. Selección la opción “Selección (SELECT)”.
En efecto, la consulta que vamos a crear nos permitirá seleccionar los registros. Avance al paso siguiente.
3. La ventana de descripción de la consulta aparecerá. Vamos a construir la consulta seleccionando los
elementos que deseamos en el resultado.
4. Haga doble clic sobre las rúbricas existentes en el análisis a la izquierda de la ventana de descripción. Las
rúbricas tomadas en cuenta aparecerán entonces en el centro de la pantalla.
Observación: Para hacer aparecer las rúbricas de los distintos ficheros de datos, hay que clicar sobre la “+”
que hay delante del nombre del fichero.
Deseamos mostrar:
o Las informaciones concernientes al pedido. Despliegue el fichero “Pedido” (clic sobre la “+”) y luego doble
clic sobre las rúbricas: “IDPedido”, “Fecha”, “Estado” y “TotalHT”.
o Las informaciones concernientes al cliente que ha pasado el pedido. Despliegue el fichero “Cliente” (clic
sobre la “+”) y luego doble clic sobre la rúbrica “NombreCompleto”.
o Las informaciones concernientes al modo de liquidación del pedido. Despliegue el fichero
“ModoLiquidacion” (clic sobre la “+”) y luego doble clic sobre la rúbrica “Texto”.
La ventana de descripción de la consulta es la siguiente:
5. Vamos a clasificar los datos por fecha.

 En la lista de elementos de la consulta, seleccione la rúbrica “Pedido.Fecha”, luego clique sobre el botón
“Clasificar” y seleccione la opción “Clasificar sobre la rúbrica seleccionada”.

 En la ventana que se muestre, indique una clasificación creciente sobre la rúbrica y valide.
6. Una flecha roja con el número 01 aparecerá a la derecha de la rúbrica “Pedido.Fecha”. Esta flecha indica que
se va a realizar una clasificación creciente sobre esta rúbrica. La cifra “01”, indica que esta será la primera
clasificación en realizarse.
7. Dele un nombre a la consulta: Introduzca “REQ_BusquedaPedidos” en vez de “REQ_SinNombre1” en la zona

“nombre de la consulta”:
8. Valide la ventana de descripción de la consulta (botón verde bajo de la pantalla).

9. La representación gráfica de la consulta se mostrará:
10. Guarde la consulta clicando sobre en los botones de acceso rápido.

11. Valide si hiciera falta la ventana para guardar la consulta.
Prueba de la consulta
Como todos los elementos de un proyecto WINDEV, se puede probar inmediatamente la consulta que acabamos de
crear:
1. Clique sobre .
2. El resultado se muestra en una ventana:
El resultado mostrado lista TODOS los pedidos.

En nuestro caso, solamente deseamos mostrar los pedidos correspondientes a los criterios de búsqueda. Para
ello, es necesario utilizar una consulta parametrizada.
Si hace un clic derecho sobre el resultado de la consulta, aparecerá un menú contextual. Tendrá
entonces la posibilidad de exportar el resultado hacia:
 Un fichero XLS (Excel)
 Un fichero Word u OpenOffice
Notas
 Un fichero XML (eXtensible Markup Language)

 Un fichero texto.
 Un fichero HFSQL
3. Cierre la ventana
Uso de parámetros en la consulta
En nuestro ejemplo, el usuario podrá seleccionar un valor para los siguientes criterios de selección:
 Estado del pedido.
 Modo de liquidación del pedido.
 Fecha del pedido.
Hemos de modificar la consulta para que los criterios de búsqueda correspondan a los parámetros de la consulta.
 Para definir los parámetros de la consulta, muestre la ventana de descripción de la consulta: doble clic sobre el
fondo de la representación gráfica de la consulta ( o bien, en el menú contextual, utilice la opción “Descripción de
la consulta”).

 Para gestionar el parámetro “Estado del pedido”:
1. Seleccione en el centro de la pantalla la rúbrica Pedido.Estado
2. Despliegue el botón “Condición de selección” y seleccione “Nueva condición”.
3. En la ventana que aparece, vamos a indicar que la selección corresponde a un parámetro:
 Seleccione “Es igual a”.

 Seleccione “al parámetro”.
 Indique el nombre del parámetro “pEstado”.
Le aconsejamos que prefije los parámetros de las consultas por “p”. Así será más sencillo
encontrarlas en el editor de código.
Notas
Si busca un parámetro de la consulta, introduzca simplemente “p” y el completado del editor de

código le propondrá todos los parámetros.
4. Valide la ventana de descripción de la condición. La cifra “1” aparecerá a la derecha de la rúbrica

“Pedido.estado”, indicando que se ha definido una condición de selección.
 Ahora vamos a definir una condición sobre el modo de liquidación. Esta rúbrica no está presente en el
resultado de la consulta, pero de todas formas queremos aplicarle una condición. Para ello, vamos a integrar
la rúbrica en el resultado de la consulta y hacerla invisible para que no aparezca en el resultado.
1. En la parte izquierda de la ventana de descripción de la consulta, en el fichero “pedido”, doble clic sobre la
rúbrica “IDModoLiquidacion”. La rúbrica “IDModoLiquidacion” aparecerá en la lista de elementos de la
consulta.
2. Para no mostrar la rúbrica en el resultado:
 Clique sobre el icono que hay a la derecha de la rúbrica.

 En el menú que aparece, seleccione “No mostrar”.
3. Para definir una condición de selección sobre la rúbrica “Pedido.IDModoLiquidacion”:
 Seleccione en el centro de la pantalla la rúbrica “Pedido.IDModoLiquidacion”.
 Despliegue el botón “Condición de selección” y seleccione “Nueva condición”.
 En la ventana que aparece, indique que la condición de selección corresponde a un parámetro:
o Seleccione “Es igual a”.
 Seleccione “al parámetro”.
o Indique el nombre del parámetro “pIDModoLiquidacion”.
4. Valide la definición de la condición de selección.
 La última condición de selección a definir concierne a la fecha del pedido. Esta fecha deberá estar comprendida
entre dos fechas introducidas por el usuario.
1. Seleccione en la lista de los elementos de la consulta la rúbrica “Pedido.Fecha”.
2. Clique sobre el botón “Entre dos fechas …”. Este botón permitirá definir directamente una condición de
selección.
3. En la ventana que aparece:
 La condición de selección es “Está comprendido entre”.
 Clique sobre “al parámetro”.
 Indique el nombre del parámetro “pInicioPeriodo”.
 Clique sobre el segundo “al parámetro”.
 Indique el nombre del parámetro “pFinPeriodo”.
4. Valide la definición de la condición de selección.
5. Valide la ventana de descripción de la consulta. El gráfico de la consulta se ha modificado para tener en
cuenta las condiciones de selección que acabamos de definir.
6. Guarde la consulta clicando sobre en los botones de acceso rápido.

Prueba de la consulta parametrizada
 Para probar la consulta parametrizada:
1. Clique sobre .
2. Se abrirá una ventana que permitirá introducir los distintos parámetros de la consulta.
3. Introduzca los siguientes datos:
 Desmarque el parámetro pEstado.
 Seleccione el parámetro pInicioPeriodo. En la parte inferior de la pantalla introduzca “01/01/2013”.
 Seleccione el parámetro pFinPeriodo. En la parte inferior de la pantalla introduzca “31/03/2013”.
 Seleccione el parámetro pIDModoLiquidacion. En la parte inferior de la pantalla introduzca “1”.
4. Valide la ventana. El resultado de la consulta correspondiente a los parámetros especificados se mostrará.

5. Cierre la ventana.
Creación del interface para realizar una búsqueda multi-criterio

Modificaciones del campo pestaña
Vamos a añadir un panel pestaña en la ventana “WIN_Menu” para mostrar el resultado de la búsqueda multi-criterio.
 Para añadir un panel pestaña:
1. Muestre si es necesario la ventana “WIN_Menu” en el editor.
2. Seleccione el campo Pestaña
3. Muestre la ventana de descripción del campo (opción “Descripción” del menú contextual).
4. En la pestaña “General” de la ventana de descripción, clique sobre el botón “Nuevo”. Aparecerá una tercer
panel pestaña.
5. Clique sobre “Panel 3”.
6. En la parte “Descripción de un panel estático”, introduzca el texto del panel: “Búsqueda de pedidos”.

7. Vamos a asociar una imagen a la pestaña utilizando el catálogo de imágenes de WINDEV. Clique sobre el
botón “Catálogo”. Aparecerá la ventana del catálogo de imágenes.
8. En la zona de búsqueda, indique “Búsqueda” y seleccione si hiciera falta el tema “Flat Soft”. Lance la
búsqueda clicando sobre la lupa.
9. Entre las imágenes propuestas, seleccione el icono que representa los binoculares y valide.
10. Conserve las opciones de la pantalla de parámetros de la imagen generada y valide.
11. Valide la ventana de descripción del campo Pestaña
Creación de los campos de parametrización de los criterios y mostrar el resultado

Pasemos ahora a mostrar el resultado de nuestra búsqueda multi-criterio.
En primer lugar vamos a crear un campo Tabla basado en la consulta y luego crear los distintos campos que van a
permitir al usuario seleccionar los criterios de búsqueda.
Creación del campo Tabla
 Para crear el campo Tabla que mostrará el resultado de la búsqueda:
1. En la ventana “WIN_Menu”, clique sobre el panel “Búsqueda de pedidos”. El panel pestaña se mostrará vacío.
2. Cree un campo Tabla: En el panel “Creación”, dentro del grupo “Datos”, despliegue “Tabla y lista” y
seleccione “Tabla (Vertical)”.
3. Clique en el panel pestaña: Se lanzará el asistente de creación de un campo Tabla.
4. El campo Tabla estará basado en la consulta “REQ_BusquedaPedidos” (que habíamos creado previamente).
Seleccione la opción “Mostrar los datos de un fichero o de una consulta existente”. Avance al paso siguiente
del asistente.
5. Seleccione la consulta que será la fuente de datos del campo Tabla:
 Despliegue si es necesario el grupo “Consultas”.
 Seleccione la consulta “REQ_BusquedaPedidos”.

 Avance al paso siguiente del asistente.
6. Seleccione si es necesario, todas las rúbricas propuestas.
7. Avance al paso siguiente del asistente.

8. Conserve las opciones por defecto en las distintas pantallas del asistente y valide la creación del campo Tabla.
9. El campo Tabla se crea automáticamente en la pestaña “Búsqueda de pedidos”.
10. Si es necesario, modifique la posición del campo Tabla para que aparezca totalmente en el panel pestaña.
 Para una mejor lectura, vamos a renombrar las cabeceras de las columnas del campo Tabla.
1. Muestre la descripción del campo Tabla (doble clic sobre el campo).

La ventana de descripción de un campo Tabla está formada por dos zonas:
 La zona superior que presenta el nombre del campo, las columnas y su tipo.
 La zona inferior, compuesta por las distintas pestañas de descripción.
Notas
Si se ha seleccionado el nombre del campo Tabla, la parte inferior presenta las características del
campo tabla.
Si se ha seleccionado una columna, la parte inferior presenta las características de las columnas.
2. Clique sobre la columna “COL_IDPedido”. El título de la columna aparecerá en la parte inferior de la pantalla.
Reemplace el texto “Identificador del pedido” por “ID”.
3. Clique sobre la columna “COL_NombreCompleto”. Sustituya el texto “Nombre Completo” por “Cliente”.
4. Clique sobre la columna “COL_Texto”. Sustituya el texto “Texto” por “Modo de Liquidación”.
5. Valide la ventana de descripción del campo Tabla. El campo se actualiza automáticamente con los cambios
efectuados.
6. Agrande el tamaño de las columnas ID, Fecha y Estado del campo Tabla, con la ayuda de los punteros de
redimensionamiento de las columnas.
7. Reduzca el tamaño de la columna “Modo de liquidación” para que todas las columnas aparezcan en el campo
Tabla.
8. Guarde la ventana clicando sobre en los botones de acceso rápido. Vamos a verificar los tamaños de las
columnas ejecutando la ventana.
Live Data y campos basados en consultas

El Live Data no se muestra en los campos que utilizan una consulta como fuente de datos por la
Notas
siguiente razón: Los datos mostrados dependen del resultado de la consulta y solo pueden
conocerse en ejecución.
 Vamos a realizar una primera prueba de esta ventana:

2. Clique en la pestaña “Búsqueda de pedidos”. Solo se mostrarán 22 pedidos, como cuando se realizó la última
prueba de la consulta en el editor, porque no hemos especificado los parámetros en la ventana de prueba de
la consulta.
3. Cierre la ventana de prueba para volver al editor.
 Observemos los tratamientos asociados al campo Tabla:

1. Seleccione el campo Tabla.
2. Muestre el menú contextual (clic derecho) y seleccione la opción “Código”.
3. El tratamiento “Inicialización de TABLE_REQ_BusquedaPedidos” contiene el siguiente código:
// Parámetros de la consulta “REQ_BusquedaPedidos”
// MySource.pEstado= <Valor del parámetro pEstado>
MySource.pIDModoLiquidacion = “1”
MySource.pInicioPeriodo = “20130101”
MySource.pFinPeriodo = “20130331”
Los parámetros de la prueba se han recuperado como parámetros por defecto para la ejecución. Vamos ahora a
modificar la ventana para que el usuario introduzca los parámetros utilizando campos.
4. Cierre el editor de código (utilice el aspa arriba a la derecha del editor).
Ahora vamos a crear en nuestra ventana los distintos campos que permitirán al usuario seleccionar los distintos
parámetros de la consulta. Estos campos se colocarán sobre el campo Tabla.
 Si fuera necesario, desplace el campo Tabla en la ventana y reduzca su altura para crear espacio suficiente para
los distintos campos de selección de criterios.
Primer parámetro: Estado del pedido
Un pedido puede tener 3 estados:
 En espera
 Pagado
 Anulado
En nuestro análisis, el estado del pedido se guarda en la rúbrica “Estado” que hay en el fichero de datos “Pedido”.
Esta rúbrica es de tipo Selector.
Para permitir al usuario seleccionar una de estos tres estados, vamos a utilizar el campo Selector asociado a la rúbrica
“Estado” del fichero de datos “Pedido”.
Los selectores de opciones también se llaman “cajas de opción”. Permiten seleccionar una opción
y solo una de entre las propuestas.
¿Cómo distinguir entre selector e interruptor?
Notas
El selector también se llama “Botón Radio”. Un método mnemotécnico muy sencillo: piense en
las radios antiguas: el botón permitía seleccionar una sola frecuencia!
El selector permite seleccionar una única opción.
 Para crear el campo Selector:

1. Muestre si hiciera falta el panel “Análisis”: En el panel “Inicio”, en el grupo “Entorno”, despliegue “Paneles” y
seleccione “Análisis”. Los distintos ficheros de datos descritos en el análisis “WD Aplicación Completa”
aparecerán en el panel.
2. Clique sobre el icono a la izquierda del fichero “Pedido”: las rúbricas del fichero de datos se listarán.
3. Seleccione la rúbrica “Estado” que hay en el fichero Pedido y haga un “Drag and Drop” de esta rúbrica hacia
la ventana “WIN_Menu”.
4. El campo Selector se creará automáticamente. Posicione este campo arriba del campo Tabla.
 Ahora vamos a utilizar el valor seleccionado en el campo Selector como parámetro de la consulta:
1. Muestre los tratamientos asociados al campo Tabla:
 Seleccione el campo Tabla.
 Muestre el menú contextual (clic derecho) y seleccione la opción “Código”.
2. En el tratamiento de inicialización del campo Tabla, sustituya la línea:

MySource.pEstado= <Valor del parámetro pEstado>
Por el siguiente código
MySource.pEstado= SEL_Estado
En este código, SEL_Estado es el nombre del campo Selector que acabamos de crear. El valor de este campo está
asociado al parámetro pEstadoesperado por la consulta.
3. Cierre el editor de código
 Antes de probar, vamos a crear un botón para volver a mostrar el contenido del campo Tabla en función del valor
seleccionado en el campo Selector:
1. Cree un campo Botón:
 En el panel “Creación”, en el grupo “Campos habituales”, clique sobre .
 Clique a continuación en el panel pestaña arriba a la derecha.
2. Seleccione el campo y luego pulse la tecla [ENTER] del teclado. El texto del botón pasará a modo edición.
Introduzca “Buscar” y pulse la tecla [ENTER] del teclado.
3. Cambie el estilo del campo:
 Muestre el menú contextual del campo (clic derecho) y seleccione la opción “Elegir un estilo”.
 En la ventana que se muestra, utilice la combinación de teclas [CTRL]+[F]. En el campo de búsqueda
introduzca “BTN_Busqueda”.
 El estilo se seleccionará automáticamente. Valide.
4. Redimensione el campo si hiciera falta.
5. Muestre el código asociado a este campo: pulse la tecla [F2].
6. En el tratamiento “Clic sobre …”, introduzca el siguiente código:
// Actualizar la visualización del campo Tabla
TableDisplay (TABLE_REQ_BusquedaPedidos, taInit)
En este código, la constante taInit permite re-ejecutar el tratamiento de inicialización del campo Tabla (el
tratamiento en el que se pasan los parámetros a la consulta).
 Vamos a probar el paso del primer parámetro:

3. Seleccione si hiciera falta la pestaña “Búsqueda de pedidos”.
4. Cambie el estado de los pedidos con el selector, y luego clique sobre el botón “Buscar”. El contenido del
campo Tabla se modificará.
5. Cierre la ventana de prueba.
Segundo parámetro: Modo de liquidación.

Un pedido puede liquidarse de varias maneras: especies, cheques, … Los distintos modos de liquidación posibles
están guardados en el fichero de datos “ModoLiquidacion”.
Vamos a utilizar un campo Combo basado en este fichero de datos para permitir al usuario seleccionar el modo de
liquidación deseado.
El campo Combo permite mostrar una lista de elementos y seleccionar un elemento de esta lista.
A diferencia de una lista, un combo no aparece desplegado: se despliega cuando se pide, o
cuando se posiciona el cursor en la lista.
Los elementos que aparecen en el combo pueden determinarse cuando se crea el campo en el
Notas
editor. Estos elementos pueden:

 Determinarse por programación.
 Provenir de un fichero de datos o de una consulta.
 Para crear un campo Combo:

1. En el panel “Creación”, dentro del grupo “Campos habituales”, clique sobre “Combo”.
2. Clique en la ventana en el emplazamiento donde el campo deberá crearse (por ejemplo, junto al selector que
ya se ha creado).
3. Se lanza el asistente de creación del campo Combo.
4. Seleccione la opción “Mostrar los datos de un fichero o de una consulta existente” y avance al paso siguiente.
5. Seleccione el fichero de datos “ModoLiquidacion” y avance al paso siguiente.
6. La rúbrica a mostrar en el campo Combo es “Texto”. Desmarque IDModoLiquidacion” y marque “Texto”.
7. Seleccione la rúbrica de clasificación “Texto”. Avance al paso siguiente.
8. Seleccione el valor de retorno “IDModoLiquidacion”. Este valor de retorno es muy importante, porque será el
que se pase como parámetro a la consulta. Avance al paso siguiente.
9. Conserve las opciones por defecto en las distintas pantallas del asistente, y valide la creación del campo
Combo.
10. El campo Combo se creará automáticamente en la ventana.
 Vamos a modificar algunas características del campo Combo:

1. Seleccione el campo Combo y muestre la ventana de descripción del campo (opción “Descripción” del menú
contextual).
2. En la pestaña “General”, modifique el texto del campo: sustituya “Combo ModoLiquidacion” por “Modo de
liquidación”.
3. En la pestaña “Contenido”, especifique el valor inicial mostrado por el campo Combo (campo “Valor inicial”
en la parte inferior de la ventana de descripción). En nuestro caso, introduzca “1”. Este valor corresponde al
pago en especias.
 Cambie el aspecto del campo: Para ocupar menos espacio, vamos a seleccionar un estilo mostrando el texto bajo
del campo.
1. Seleccione el campo Combo.
2. En el menú contextual (clic derecho), selección la opción “Elegir un estilo”.
3. En la ventana que aparece, seleccione el estilo “COMBO_Interno” y valide.
4. Reduzca el tamaño del campo.
 Ahora, utilizaremos el valor seleccionado por el campo Combo como parámetro de la consulta.
 Seleccione el campo Tabla.
2. En el tratamiento de inicialización del campo Tabla, sustituya la línea:
MySource.pIDModoLiquidacion = “1”
Por el código:
MySource.pIDModoLiqudiacion = COMBO_ModoLiquidacion
En este código, COMBO_ModoLiquidacion es el nombre del campo Combo que acabamos de crear. El valor de
retorno de este campo, se asociará al parámetro pIDModoLiquidacion esperado por la consulta.

 Ahora probaremos el paso de los dos primeros parámetros:

3. Cambie el estado de los pedidos mediante el selector y modifique el modo de liquidación utilizando el campo
Combo; a continuación clique sobre el botón “Buscar”. El contenido del campo Tabla se modificará.

Último parámetro: Fecha del pedido
El último parámetro de la consulta corresponde a la fecha de los pedidos tomados en cuenta. A nivel del interface, el
usuario deberá poder introducir un intervalo de fechas. Vamos a utilizar para ello un modelo de campos.
Un modelo de campos es una ventana específica que contiene distintos campos. En esta
ventana, podrá poner cualquier tipo de campos. Un modelo de campos es un fichero de
extensión “WDT”.
El principal interés de un modelo de campos es la re-utilizabilidad. Un modelo de campos que
Notas
exista en un proyecto, puede reutilizarse desde cualquier ventana del proyecto.

Además, los modelos de campos pueden sobrecargarse: puede añadirse nuevo código sobre
ellos, los campos pueden desplazarse en la ventana utilizando el modelo de campos. Los campos
también pueden modificarse.
 Para gestionar la fecha del pedido.

1. En el explorador del proyecto, despliegue la carpeta “Modelo de campos”.
2. Seleccione el modelo de campos “MDLC_ElegirPeriodo” en el explorador del proyecto y realice un “Drag and
Drop” hacia la ventana “WIN_Menu” (junto al campo “Modo de Liquidación”).

3. Seleccione el modelo de campos creado y muestre su descripción (opción “Descripción” del menú contextual).
4. En la ventana de descripción, renombre el modelo de campos. El nuevo nombre es “CMOD_ElegirPeriodo”.
6. Reposicione y alinee los campos si fuera necesario.
 Ahora, utilizaremos las fechas seleccionadas como parámetro de la consulta:

 Seleccione el campo Tabla
2. En el tratamiento de inicialización del campo Tabla, sustituya las líneas:
MySource.pInicioPeriodo = “20130101”
MySource.pFinPeriodo = “20130331”
Por
MySource.pInicioPeriodo = EDT_FechaInicio
MySource.pFinPeriodo = EDT_FechaFin
En este código, EDT_FechaInicio y EDT_FechaFin son los nombres de los dos campos de edición que hay en el
modelo de campos. Sus valores se asocian a los parámetros pInicioPeriodo y pFinPeriodo esperados por la
consulta.
 Probaremos el paso de todos los parámetros:

3. Defina los distintos parámetros de la búsqueda:
 Estado de los pedidos
 Modo de liquidación
 Horquilla de las fechas a contemplar.
4. Clique sobre el botón “Buscar”. El contenido del campo Tabla se modificará.


Lección 3.5. Imprimir el contenido de un
campo Tabla
 Imprimir el contenido de un campo Tabla
 Imprimir un bono de pedido.

Presentación
WINDEV permite imprimir sus datos:
 Directamente por programación.
 A través de informes. Un informe es el nombre que se da a la representación gráfica de una edición. Un
informe se crea mediante el editor de informes.
WINDEV propone numerosos tipos de informes:
 En blanco
 Ficha
 Etiqueta
 Tabla
 Tabla cruzada
 Tabla jerárquica
 Informe multi-columna
 Correo
 Formulario
 Compuesto
 Agenda o Planning
 Diagrama de Gantt.
Vamos ahora a descubrir como crear los distintos tipos de informes en la aplicación “WD Aplicación Completa”.
Si no ha creado las ventanas de las lecciones anteriores, puede seguir esta lección abriendo un
proyecto corregido: En el panel “Inicio”, dentro del grupo “Ayuda en línea”, despliegue “Guía de
auto-formación” y luego seleccione “Aplicación completa (Con ventanas)”.
Corregido
También está disponible en la aplicación un proyecto completo corregido: en el panel “Inicio”,

dentro del grupo “Ayuda en línea”, despliegue “Guía de auto-formación” y luego seleccione
“Aplicación completa (Corregida)”. En este caso, para seguir la continuación de este curso,
seleccione la configuración “Ejecutable Windows 32 bits” en el explorador del proyecto.
Impresión del contenido de un campo Tabla

En la lección anterior, hemos creado un campo Tabla que permite mostrar el resultado de una búsqueda multi-
criterio. Vamos a estudiar ahora las distintas posibilidades para imprimir el contenido del campo Tabla.
Impresión directa mediante la FAA (Funcionalidades Automáticas de la Aplicación)
En lecciones anteriores, hemos visto ya como WINDEV propone numerosas funcionalidades automáticas (llamadas
FAA). Para imprimir un campo tabla, también existe una FAA.
La lista completa de las FAA (Funcionalidades Automáticas de la Aplicación) está disponible en el

fichero WinDEv FAA 21.PDF. Este fichero se integra automáticamente en su aplicación si elige la
Nota
opción “Ayuda de las FAA” cuando se crea el menú automático.
 Hagamos una prueba rápida:

1. Muestre si hiciera falta la ventana “WIN_Menu” en el editor de ventanas.

3. Seleccione si hace falta la pestaña “Búsqueda de pedidos”.
4. Defina los distintos parámetros de la búsqueda:
 Estado de los pedidos.
 Modo de liquidación.
 Horquilla de fechas a tener en cuenta.
5. Clique sobre el botón “Buscar”.
6. Cuando los datos se muestran en el campo Tabla, muestre el menú contextual del campo (icono arriba a
la derecha o clic derecho sobre el campo).
7. Clique sobre la opción “Imprimir”.

8. Si hiciera falta, elija el modo de imprimir en modo “Horizontal” el contenido del campo Tabla. El informe
correspondiente al campo se muestra en una ventana de vista previa.

En modo prueba, el contenido del campo Tabla se imprime directamente.
En ejecución, el usuario final tiene la posibilidad de imprimir directamente o de lanzar el software
Nota
“Informes y Consultas” para crear el informe correspondiente. Para más detalles sobre el
software Informes y Consultas, consulte “Difunda ‘Informes y Consultas’ con sus aplicaciones”.
9. Cierre la ventana de vista previa y detenga la prueba de la aplicación.

¿Quiere personalizar el informe propuesto por defecto? Bastará con crear un informe automático sobre el campo
Tabla. Este informe (si existe), se utilizará automáticamente por la opción de impresión del campo Tabla.
Creación de un informe automático sobre un campo Tabla
Para crear un informe que imprima los datos de un campo Tabla, bastará con crear un “Informe sobre campo Tabla”:
El informe correspondiente a la tabla se crea automáticamente.
 Para crear un “Informe sobre campo Tabla”:
1. Si hiciera falta, en el editor de ventanas muestre la pestaña “Búsqueda de pedidos” (clicando debajo).
2. En el panel “Creación”, dentro del grupo “Datos”, despliegue “Tabla y lista” y seleccione “Informe sobre
campo Tabla”.
3. Nuestra ventana contiene dos campos tabla sobre dos pestañas distintas. WINDEV pide seleccionar el campo
Tabla deseado. En nuestro caso, seleccione “TABLA_REQ_BusquedaPedidos” y valide.
4. La forma de un botón aparecerá bajo el cursor del ratón. Este botón se crea automáticamente y contiene el
código que permite lanzar la impresión del contenido del campo Tabla. Clique en la ventana en la posición
donde se vaya a crear el botón (por ejemplo, debajo del botón “Buscar” en la pestaña “Búsqueda de
pedidos”).
5. El informe se crea inmediatamente.
6. Se muestra una ventana solicitando añadir el informe al proyecto. Valide.
7. Aparece automáticamente el editor de informes con el informe que se ha creado automáticamente.
8. Guarde el informe clicando sobre en los botones de acceso rápido.

9. En este informe, encontrará los títulos de las columnas del campo Tabla que hay en la ventana. Vamos a
realizar una pequeña modificación en este informe: vamos a modificar el título:
 Seleccione el campo correspondiente al título del informe “Tabla REQ_BúsquedaPedidos” se muestra en el
campo) haciendo doble clic sobre el campo.
 En la ventana de descripción, modifique el texto e introduzca “Pedidos Buscados”.
 Valide.
11. Regrese a la ventana “WIN_Menu” (por ejemplo, clicando sobre el botón “WIN_Menu” que hay en la barra de
elementos abiertos de WINDEV).
12. Modifique si hiciera falta el tamaño y la posición del botón “Imprimir” (para que tenga el mismo tamaño que
el botón “Buscar”).
14. Pruebe la ventana: clique sobre en los botones de acceso rápido.

 Seleccione si es necesario, la pestaña “Búsqueda de pedidos”.
 Defina los distintos parámetros de la búsqueda:
o Estado de los pedidos.
o Modo de liquidación
o Horquilla de fechas a considerar.
 Clique sobre el botón “Buscar”.
15. Cuando los datos se muestran en el campo Tabla, utilice el botón de impresión o la opción “imprimir” del
menú contextual del campo Tabla: el informe que acaba de crear se utilizará en ambos casos.

Lección 3.6. Imprimir un pedido
 Crear un informe basado en una consulta
 Lanzar la impresión de un informe basado en una consulta parametrizada

Presentación
Vamos ahora a dar la posibilidad al usuario para que pueda imprimir el detalle del pedido buscado. El informe podrá
imprimirse directamente desde el menú contextual del campo Tabla.
Corregido

“Aplicación completa (Corregida)”. En este caso, para seguir la continuación de este curso,
seleccione la configuración “Ejecutable Windows 32 bits” en el explorador del proyecto.
Creación del informe “Bono de pedido”

Vamos primero a listar las informaciones que deberán aparecer en el informe:
 Las características del pedido: Fecha y número del pedido.
 Los datos del cliente: Nombre, domicilio, código postal, ciudad y país.
 Las características de las líneas del pedido:
o Cantidad pedida
o Referencia del producto
o Descripción del producto
o Total HT
o Total TTC
Para crear simplemente este informe, vamos a agrupar todos los datos a imprimir en una consulta. Esta consulta
podrá utilizarse por el informe o por cualquier otro elemento del proyecto WINDEV (campo Tabla, Campo Zona de
repetición, …).
WINDEV propone crear los informes a partir de numerosas fuentes de datos: ficheros de datos,
consultas, campos, ficheros de texto, …
En la mayoría de ocasiones, es aconsejable agrupar los datos a imprimir en una consulta, y luego
crear un informe sobre esta consulta. Si una información deberá añadirse en el informe, habrá
Nota
que añadir la rúbrica correspondiente en la consulta.

Los informes realizados directamente sobre los ficheros de datos deberán reservarse a los
informes simples, es decir, los que muestran los datos que provienen de un único fichero de
datos.
Creación de la consulta
 Para crear la consulta base del informe, vamos a utilizar el editor de consultas.
1. Clique sobre en los botones de acceso rápido. Se muestra la ventana de creación de un nuevo elemento:
clique sobre “Consulta”. Se lanzará el asistente de creación de consultas.
2. Seleccione la opción “Selección (SELECT)”.
Efectivamente, la consulta que vamos a crear nos permitirá seleccionar los registros que se imprimirán en el
informe. Avance al paso siguiente.
3. La ventana de descripción de la consulta aparecerá. Vamos a construir la consulta seleccionando los
elementos que queremos en el resultado.
4. Doble clic sobre las rúbricas presentes en el análisis a la izquierda de la ventana de descripción. Las rúbricas
consideradas aparecerán entonces en el centro de la pantalla. Queremos imprimir en el informe:
 Las informaciones referidas al cliente. En el fichero “Cliente”, doble clic sobre las rúbricas NombreCompleto,
Dirección, CodigoPostal, Ciudad y Pais.
 Las informaciones referidas al pedido. En el fichero “Pedido”, doble clic sobre las rúbricas IDPedido y Fecha.
 Las informaciones correspondientes al producto. En el fichero “Producto” , doble clic sobre las rúbricas
Referencia, Etiqueta y precioHT.
 Las informaciones correspondientes a la línea de pedido. En el fichero “LineaPedido” doble clic sobre las
rúbricas Cantidad y TotalHT.

 Las informaciones sobre el precio total del pedido. En el fichero “Pedido”, doble clic sobre los campos TotalHT
y TotalTTC.
El orden en el que se insertan las rúbricas en la consulta es muy importante. Este orden es el
que se utilizará para mostrar los datos en el informe. Si el orden está definido correctamente, la
Nota
creación del informe correspondiente será aún más sencilla.
La ventana de descripción de la consulta es la siguiente:
En este estado, esta consulta permite seleccionar todos los pedidos y las líneas de pedido correspondientes.
Queremos seleccionar los datos correspondientes a un solo pedido cuyo identificador conocemos. Vamos pues a
definir como parámetro el número de pedido.
 Para gestionar el parámetro “Identificador del pedido”:
1. Seleccione en el centro de la pantalla la rúbrica Pedido.IDPedido.
2. Despliegue el botón “Condición de selección” y seleccione “Nueva condición”.
3. En la ventana que aparece, vamos a indicar que la condición de selección corresponde a un parámetro:

Efectúe las siguientes operaciones:
 Seleccione “Es igual a”-
 Marque “al parámetro”.
 Indique el nombre del parámetro “pIDPedido”.
4. Valide la ventana de descripción de la condición. La cifra “1” aparecerá a la derecha de la rúbrica
Pedido.IDPedido, indicando que se ha definido una condición de selección.
5. Dele un nombre a la consulta: introduzca “REQ_BonoDePedido” en vez de “REQ_SinNombre1” en la zona
“Nombre de la consulta”.
6. Valide la ventana de descripción de la consulta (botón verde bajo de la pantalla).

7. Se mostrará la representación gráfica de la consulta:
8. Guarde la consulta clicando sobre en los botones de acceso rápido. Valide si hiciera falta las
informaciones para guardarla.
Creación del informe basado en una consulta.
 Para crear un informe:
1. Clique sobre el botón en los botones de acceso rápido.

2. Se abre la ventana de creación de un nuevo elemento: clique sobre “Informe” y luego sobre “Informe”. Se
lanzará el asistente de creación de informes.
3. El asistente de creación de informes propone varios tipos de informes:

4. Seleccione “Tablero”. Avance al paso siguiente.
5. Seleccione la fuente de datos del informe. El informe estará basado en la consulta que acaba de crear.
Seleccione “De un fichero de datos o de una consulta existente”. Avance al paso siguiente.
6. En la lista de ficheros de datos y de consultas, seleccione la consulta “REQ_BonoDePedido”. Avance al paso

siguiente.
7. El asistente pide indicar si hay una rotura. En este informe no vamos a utilizar ninguna rotura. Veremos este
concepto más adelante en este curso. Responde “No”. Avance al paso siguiente.
8. A continuación vamos a indicar cuál será el orden en que se imprimirán las rúbricas y su reparto en los
distintos bloques. En el asistente, las rúbricas se listan en el orden definido en la consulta.
 Las rúbricas referidas al cliente deberán mostrarse en el bloque “Cabecera de página”. En efecto, estas
informaciones no deberán repetirse para cada línea del pedido.
Para las rúbricas NombreCompleto, Dirección, CodigoPostal, Ciudad y Pais, clique sobre la línea
correspondiente a la rúbrica. En la columna “Bloque”, despliegue el combo y seleccione “Cabecera de página”.

 Las rúbricas referidas al pedido también deberán mostrarse en el bloque “Cabecera de página”. Estas
informaciones no se tienen que repetir para cada línea del pedido. Para las rúbricas IDPedido y Fecha, clique
sobre la línea correspondiente a la rúbrica. En la columna “Bloque”, despliegue el combo y seleccione
“Cabecera de página”.
 Además, vamos a aprovechar para modificar el texto de la rúbrica “IDPedido”.
o Seleccione la línea que contiene la rúbrica IDPedido.
o Clique en la columna Texto e introduzca “N. Pedido”.
 Las rúbricas referidas a las líneas de pedido deberán quedarse en el cuerpo del informe. Estas rúbricas se
mostrarán para todas las líneas de pedidos del pedido.
 Las rúbricas referidas a los totales del pedido se mostrarán en el pie de la página. Estas informaciones no
deberán repetirse para cada línea del pedido. Para las rúbricas TotalHT_Co y TotalTTC, clique sobre la línea
correspondiente a la rúbrica. Dentro de la columna “Bloque”, despliegue el combo y seleccione “Pie de
página”.
La siguiente tabla proporciona las distintas afectaciones de las rúbricas en el orden presentado por el asistente:

Rúbrica Bloque
NombreCompleto Cabecera de página
Dirección Cabecera de página
CodigoPostal Cabecera de página
Ciudad Cabecera de página
Pais Cabecera de página
IDPedido Cabecera de página
Fecha Cabecera de página
Referencia Cuerpo
Referencia Cuerpo
Etiqueta Cuerpo
PrecioHT Cuerpo
Cantidad Cuerpo
TotalHT_Co Pie de página
TotalTTC Pie de página
9. Avance al paso siguiente.
10. El asistente propone crear un contador, una suma o una media sobre las rúbricas numéricas presentes en el
informe. En este informe, los cálculos los realiza la consulta. Clique sobre el botón “Ningún cálculo”. Avance al
paso siguiente.
11. Esta pantalla permite definir la disposición del informe.
Guardaremos los valores por defecto con la orientación “Vertical”.

Márgenes de impresión
Cuando elija los márgenes de impresión, no olvide tener en cuenta los márgenes físicos de las
Nota
impresoras. Los márgenes físicos son aquellos reservados por las impresoras donde no se puede
imprimir. Además los márgenes físicos difieren en función de los modelos de impresoras.

13. Esta pantalla permite seleccionar la plantilla utilizada por el informe. Se aconseja utilizar la misma plantilla
que para las ventanas. En nuestro caso, seleccione por ejemplo la plantilla “Gensteel” y avance al paso
siguiente.
14. Solo queda proporcionar un nombre y un título al informe:
 Introduzca el título “Bono de pedido”.
 Se propone también el nombre “INF_Bono_de_Pedido”.

15. Valide.
16. Si el informe es demasiado grande para imprimirlo en modo Vertical, el editor de informes propone utilizar el
modo horizontal, reducir el tablero o imprimir el tablero en varias páginas. En nuestro caso, acepte el modo
horizontal.
17. Si fuera necesario, acepte también reducir el tablero .
18. El informe aparecerá en edición en el editor de informes.
19. Las distintas líneas del pedido se agrupan en forma de tablero.

20. Guarde el informe clicando sobre en los botones de acceso rápido. Valide si es necesario las
informaciones para guardarla.
 Ejecute este informe clicando sobre en los botones de acceso rápido.

1. El editor de informes pide el destino de la impresión. El destino de la impresión puede elegirse entre:

Elija “Vista previa antes de imprimir” y valide.
2. El editor de informes pide los parámetros de la consulta utilizada por el informe. Recuerde que utilizaremos
un parámetro para especificar el número del pedido a imprimir. Por ejemplo, introduzca el valor de prueba
“1”.
Valide.
3. La ejecución del informe se muestra en la pantalla.

Ahora podrá:
 Imprimir directamente la página en curso o la totalidad del documento clicando sobre la impresora.
 Crear un duplicado.
 Seleccionar un nivel de zoom más o menos importante.
 Guardar el informe con formato de un documento Word (formato RTF).
 Guardar el informe con formato HTML.
 Guardar el informe con formato PDF.
 Guardar el informe con formato XML.
 Crear un email con el informe en formato HTML en el cuerpo del mensaje.
 Crear un email con el informe en formato PDF con el documento enlazado.
 Anotar el documento.
 Realizar una búsqueda dentro del documento.
 Añadir filigranas
 Cierre la vista previa antes de la impresión.
Modificación del informe “Bono de pedido”
Vamos a efectuar algunas modificaciones en la disposición del informe que acabamos de crear.
 Elimine el número de páginas que se muestra en el informe:
1. Seleccione el campo [NUMPAGE]/[NBPAGES].
2. Pulse la tecla [SUPR] del teclado.
 Vamos ahora a ubicar las informaciones del cliente y del pedido en la cabecera de la página:
1. Elimine el texto “Bono de pedido” que hay en la cabecera de la página.
2. Elimine los textos de delante de las informaciones del cliente (Nombre completo, …).
3. Posicione la rúbrica que contiene la ciudad junto al código postal.
4. Seleccione todas las informaciones del cliente y desplácelos con la ayuda del ratón hacia la derecha del
informe.
5. Suba el número de pedido y la fecha del pedido (arriba del bloque “Cabecera de página”).
 Vamos a posicionar los totales correctamente en el pie de la página:

1. Seleccione los campos (textos y rúbricas) correspondientes a los totales que hay en el pie de página.

2. Posicione los campos con la ayuda del ratón, bajo a la derecha del tablero.
 Modifique las opciones de impresión del bloque “Pie de página”.

1. Muestre la ventana de descripción del bloque “Pie de página”:
 Clique en el bloque “Pie de página”.
 Muestre el menú contextual (clic derecho) y seleccione “Descripción del bloque”.
2. En la pestaña “General”, marque las siguientes opciones:
 Imprimir el bloque “Fin del documento” DESPUES del bloque “Pie de página” en la última página.
 El bloque “Pie de página” no se imprime bajo de la página, se pega a los bloques anteriores.

4. El informe se muestra en el editor de informes:
Nuestro informe Bono de pedido ya está finalizado.

Mostrar el informe impreso desde una opción de menú
En nuestra aplicación, el informe “INF_Bono_de_pedido” se imprimirá desde una opción del menú contextual del
campo Tabla que lista los pedidos buscados.
Por defecto, ya hemos visto que el campo tabla propone un menú automático. Queremos conservar las opciones de
este menú automático y añadir una opción que permitirá imprimir el bono de pedido seleccionado.
El principio utilizado es el siguiente:
1. Vamos a crear un nuevo menú contextual. Este menú contendrá el código WLangage que permitirá lanzar la
impresión del informe.
2. Vamos a enlazar este menú contextual al campo Tabla e indicar que el menú contextual por defecto vendrá a
continuación del menú contextual definido para el campo Tabla.
Creación del menú contextual
 Para crear un menú contextual en la ventana “WIN_Menu”:
1. Abra si fuera necesario la ventana “WIN_Menu” en el editor (doble clic en su nombre en el explorador del
proyecto por ejemplo).
2. En el panel “Ventana”, dentro del grupo “Barras y menús”, despliegue “Menús contextuales” y selecciones
“Nuevo menú contextual”.
3. Un nuevo menú contextual aparecerá en el editor. Este menú solo tiene una opción “Opción de menú”.
4. Muestre la descripción del menú contextual:

 Seleccione “Opción de menú”.
 Muestre el menú contextual (clic derecho).
 Seleccione la opción “Descripción del menú contextual”.
5. De un nombre al menú contextual “Menu_Pedido” y valide.
Menús contextuales y ventanas

Un menú contextual está asociado a una ventana. Si una ventana tiene varios menús
Nota
contextuales (menú contextual de la ventana, menús contextuales de los campos, …), todos
estos menús se guardarán con la ventana.
 Vamos ahora a definir el texto de la opción y su código.

1. Seleccione la opción “Opción de manú”.
2. Pulse la tecla [ESPACIO] del teclado: El texto pasará a modo edición. Introduzca el nuevo texto “Imprimir el
bono de pedido” y valide.
3. Muestre el código asociado a la opción:
 Seleccione la opción.
// Vista previa antes de la impresión
iPreview ()
// Inicializar la consulta del informe
iInitReportQuery (INF_Bono_de_pedido, …
TABLE_REQ_BusquedaPedidos.COL_IDPedido)

// Lanza la impresión del informe
iPrintReport (INF_Bono_de_pedido)
En este código:
 La función iPreview permite indicar que la impresión del informe se realizará en vista previa de impresión.
 La función iInitReportQuery permite especificar los parámetros esperados por la consulta asociada al
informe. En nuestro caso, la consulta espera como parámetro el número de pedido. Este número de pedido
está en la columna COL_IDPedido del campo Tabla TABLE_REQ_BusquedaPedidos para la línea en curso.
 La función iPrintReport permite lanzar la impresión del informe especificado (aquí, el informe
INF_Bono_de_pedido).
5. Cierre la ventana código y la ventana que contiene el menú contextual.
6. Guarde la ventana “WIN_Menu”.
Asociación del menú contextual al campo Tabla
 Última etapa: Vamos a enlazar el menú contextual al campo Tabla.
1. En la ventana “WIN_Menu”, muestre la pestaña “Búsqueda de pedidos”.
2. Seleccione el campo Tabla y muestre su descripción (opción “Descripción” del menú contextual del campo).
3. En la pestaña “IHM”, despliegue el combo “Menu Ctx.).
4. Marque la opción “Añadir un menú contextual”, seleccione el menú “Menu_Pedido” y seleccione la opción “Al
principio” para indicar que el menú está situado antes del menú sistema.
5. Valide.
Prueba de impresión
 Ya solo queda efectuar una prueba en real:
1. Lance la prueba de la ventana “WIN_Menu”.
2. Seleccione el panel pestaña “Búsqueda de pedidos”.
3. Especifique los criterios y lance una búsqueda.
4. Seleccione uno de los pedidos mostrados en el campo Tabla.
5. Imprima el pedido mediante el menú contextual

6. Cierre la vista previa antes de la impresión y la ventana de prueba.

Lección 3.7. Imprimir una lista de clientes
 Crear un informe con roturas
 Lanzar la impresión de un informe

Presentación
Esta lección permite imprimir una lista de clientes, agrupados por país y por departamento o provincia.
Para ello, vamos a utilizar un informe de tipo tablero, que permite representar claramente una lista de datos.
Corregido

“Aplicación completa (Corregida)”.
Creación del informe

 Para crear un informe:
1. Clique sobre el botón en los botones de acceso rápido.

2. Se mostrará la ventana de creación de un nuevo elemento: clique sobre “Informe” y luego en “Informe”. Se
lanza el asistente de creación de informes. El asistente de creación de informes propone varios tipos de
informes:
3. Seleccione “Tablero”. Avance al paso siguiente.

4. Seleccione la fuente de datos del informe. El informe estará basado en el fichero Cliente. Seleccione “De un
fichero de datos o de una consulta existente”. Avance al paso siguiente.

5. En la lista de ficheros de datos y de consultas, seleccione el fichero “Cliente”. Avance al paso siguiente.
6. Defina la clave de recorrido del fichero. En nuestro caso, vamos a recorrer el fichero cliente según el nombre
completo del cliente. Seleccione la clave de recorrido “NombreCompleto”. Avance al paso siguiente.
7. Vamos ahora a definir las opciones de clasificación de los datos en el informe. Por defecto, el asistente
propone la rúbrica utilizada como clave de recorrido del fichero de datos. Como queremos hacer un informe
que liste los clientes por país y por departamento, vamos a añadir una clasificación sobre estas rúbricas.
8. Para añadir una clasificación por país:
 Clique sobre el botón “+” para añadir una rúbrica de clasificación.
 En la ventana que se muestra, seleccione la rúbrica Cliente.Pais.

 Valide.
9. Para añadir una clasificación por departamento:
 Clique sobre el botón “+” para añadir una rúbrica de clasificación.
 En la ventana que se muestra, seleccione la rúbrica Cliente.EstadoProvinciaRegion.
 Valide.
10. Modifique el orden de las rúbricas de clasificación. Los clientes deberán clasificarse por país, región y luego
por orden alfabético.
 La rúbrica “Cliente.Pais” aparece como segunda rúbrica de clasificación. Seleccione esta rúbrica y desplácela
como primera rúbrica de clasificación con la ayuda de los botones flecha.
 La rúbrica “Cliente.EstadoProvinciaRegion” aparece como tercera rúbrica de clasificación. Seleccione esta
rúbrica y desplácela como segunda rúbrica de clasificación con la ayuda de los botones flecha.

11. El asistente pide que se le indique si hay una rotura.
¿Qué es una rotura?

Una rotura es una operación que consiste en agrupar los registros (o líneas) siguiendo uno o
varios criterios. Atención, los registros (o líneas) son por supuesto impresos.
Una rotura está OBLIGATORIAMENTE enlazada a una clasificación.
Note la presencia de una cabecera de rotura y de un fin de rotura.
Nota
Las informaciones comunes a las distintas líneas están presentes en la cabecera de la rotura.
Los totales, contadores, … están en el fin de rotura.
Esta rotura permite agrupar una serie de registros de acuerdo con un mismo criterio. En nuestro
ejemplo, la rotura concierne al país y permite agrupar todos los clientes de un mismo país.

12. Responda “Si”. Avance al paso siguiente.
13. Indique sobre qué rúbrica de clasificación deberá efectuarse la rotura. En nuestro caso, vamos a utilizar varias
roturas:
 La primera rotura se efectuará sobre el país
 La segunda rotura se efectuará sobre la provincia.
Desmarque la rúbrica “Cliente.NombreCompleto”.

15. Ahora vamos a indicar el orden en que se imprimirán las rúbricas y su reparto en los distintos bloques. En
nuestro ejemplo:
 Solo el país estará solo en el bloque “Inicio de rotura 1”. La rúbrica “Pais” está asociada automáticamente al
“Inicio de rotura 1”.
 Solo el estado estará en el bloque “Inicio de rotura 2”. La rúbrica “EstadoProvinciaRegion” está asociada
automáticamente al “Inicio de rotura 2”.

 Solo las rúbricas NombreCompleto, Direccion, CodigoPostal, Ciudad, EstadoProvinciaRegion y Pais se
mostrarán en el informe.
Desmarque las rúbricas IDCliente, Complemento, Teléfono, Movil y Email. Avance al paso siguiente.
16. Esta pantalla permite definir la configuración del informe.
Guardaremos los valores por defecto con la orientación “Vertical”.
Márgenes de impresión
Cuando elija los márgenes de impresión, no olvide tener en cuenta los márgenes físicos de las
Nota
impresoras. Los márgenes físicos son los márgenes reservados por la impresora en los que no es
posible imprimir. Además, los márgenes físicos difieren en función de los modelos de impresora.

18. Esta pantalla permite seleccionar la plantilla utilizada por el informe. Es aconsejable utilizar la misma plantilla
que para las ventanas. En nuestro caso, seleccione por ejemplo la plantilla “Gensteel” y avance al paso
siguiente.
19. Ya solo queda dar un nombre y un texto al informe y guardarlo.
 Introduzca el título “Lista de clientes”.
 Conserve el nombre propuesto por defecto: “INF_Lista_de_Clientes”.
20. Valide.
21. Acepte pasar a modo horizontal y valide.
22. Acepte reducir el informe y valide.
23. El informe aparece en el editor de informes. Guarde el informe.
El informe está finalizado. Vamos a probarlo inmediatamente para ver el resultado.
 Ejecute este informe clicando sobre en los botones de acceso rápido.

Puede elegirse el destino de la impresión:
 Elija “Vista previa antes de impresión” y valide.

La ejecución del informe se muestra en la ventana.

Puede imprimir directamente la página en curso o la totalidad del documento clicando sobre la impresora (Panel
“Imprimir”).
Lanzamiento de la impresión de un informe por programación

Nuestro informe está finalizado y vamos a crear un menú en nuestra ventana “WIN_Menu” para lanzar directamente
la impresión de este informe.
 Para insertar un menú en la ventana “WIN_Menu”:
1. Muestre la ventana “WIN_Menu” en el editor (doble clic en su nombre en el panel “Explorador” por ejemplo).
2. En el panel “Ventana”, dentro del grupo “Barras y menús”, despliegue “Menú principal” y seleccione la opción
“Añadir el menú principal”.
3. Se inserta un menú en la ventana bajo la barra de título. Este menú contiene por defecto una opción que se
llama “Menú”.
4. Seleccione la opción “Menú”:
 Seleccione la opción “Añadir después”.
5. En la zona de edición, introduzca “Informes”.
6. Seleccione la opción “Informes”:

 Seleccione la opción “Transformar para desplegar un submenú”.
7. En la zona de edición que se muestra, introduzca “Lista de clientes”. Valide con la tecla [ENTER].

 Para introducir el código de la opción “Lista de clientes”:
1. Seleccione la opción “Lista de clientes” en el editor.
2. Muestre el menú contextual (clic derecho).
3. Seleccione la opción “Código”. Aparecerá el editor de código.
4. En el tratamiento “Selección del menú”, introduzca el siguiente código:
// La impresión se hace en una vista previa
iPreview()
// Imprime el informe
iPrintReport (INF_Lista_de_clientes)
 La función iPreview (o iDestination) permite parametrizar el destino de la impresión; así por ejemplo, se
puede imprimir:
o En un fichero texto
o Con formato HTML
o Con formato PCL
o Con formato PDF, RTF, XLS, XML
o En un fax
En nuestro caso, la impresión se realizará en la ventana de vista previa de impresión.
 La función iPrintReport (como su nombre indica), permite imprimir el informe.
 Pruebe la ventana y sus opciones clicando sobre en los botones de acceso rápido.
 Ahora vamos a finalizar este menú añadiendo una opción para cerrar la aplicación.
1. En el editor, seleccione la opción “Menú”.
2. En el menú contextual (clic derecho), seleccione la opción “Transformar para desplegar un sub-menu”.
3. En la zona de edición que se muestra, introduzca “Cerrar”.
4. Vamos a asociar esta opción de menú al atajo del teclado “[ALT]+[F4]”:
 Seleccione la opción de menú “Cerrar”.
 En el menú contextual (clic derecho), seleccione la opción “Descripción de la opción”.
 En la pestaña “General”, en la zona “Atajo del teclado”, seleccione “F4” y marque “ALT”.
 Valide
5. Muestre el código de la opción, y en el tratamiento “Selección de menú”, introduzca el siguiente código:
// Pregunta al usuario si realmente desea cerrar la aplicación
IF YesNo (No, “¿Cerrar la aplicación?”) = Yes THEN
// Fin de la aplicación
EndProgram ()
END

 La función YesNo permite dialogar con el usuario proponiéndole una pregunta. El usuario puede responder a
la pregunta con la ayuda de dos botones: Si o No.
 La función EndProgram (llamada si el usuario clica sobre “Si”) permite finalizar la aplicación.
 Pruebe la ventana clicando sobre en los botones de acceso rápido.
Lección 3.8. Estadísticas: Campos Gráfico y

Tablero Cruzado Dinámico
 Mostrar los datos en forma de gráfico
 Realizar los tableros de síntesis utilizando el Tablero Cruzado Dinámico

Presentación
En una aplicación de gestión, la presentación de estadísticas o de cuadros recapitulativos es frecuentemente
necesaria. Este tipo de presentación puede utilizarse por ejemplo para seguir:
 La evolución de los pedidos en el tiempo
 La evolución de la cifra de negocios
 La evolución de los stocks
 …
Todo tomador de decisiones pide estas informaciones.
Para incluir rápida y sencillamente estas informaciones en sus aplicaciones, WINDEV propone numerosos campos. En
esta lección, vamos a utilizar dos campos específicos:
 El campo Gráfico
 El campo Tablero Cruzado Dinámico.
Corregido

“Aplicación completa (Corregida)”.
Mostrar los datos en un campo Gráfico

Para manipular el campo Gráfico en condiciones reales, vamos a realizar en la aplicación “WD Aplicación Completa” un
campo Gráfico presentando el informe de las ventas.
Vamos primero a realizar una consulta para seleccionar los datos a mostrar en el campo Gráfico, y luego crearemos el
campo Gráfico.
Selección de datos a mostrar en el campo Gráfico
Para realizar nuestro gráfico, queremos la suma de los pedidos efectuados por fecha.
Vamos a crear una consulta que realice una suma. En efecto, vamos a hacer el acumulado del montante total de los
pedidos (rúbrica TotalTTC en el fichero de datos Pedido).
Vamos a calcular el total de todos los pedidos por fecha (la Cifra de Negocios por fecha).
 Cree una nueva consulta:

2. La ventana de creación de un nuevo elemento se muestra: clique sobre “Consulta”.
3. Vamos a realizar una consulta de selección. Seleccione la opción “Selección (SELECT)”. Avance al paso
siguiente.
4. Aparecerá la ventana de descripción de la consulta.
5. Añada las rúbricas Pedido.Fecha y Pedido.TotalTTC a la consulta:
 En la izquierda, despliegue el fichero “Pedido”.
 Doble clic sobre la rúbrica Fecha y luego sobre la rúbrica TotalTTC.
 Las dos rúbricas aparecerán en el centro de la pantalla (en la zona “Lista de elementos de su consulta”).
 Para efectuar la suma de los valores de “Pedido.TotalTTC”:
1. Seleccione la rúbrica “Pedido.TotalTTC” al centro.
2. En las “Acciones”, a la derecha, clique sobre “Suma”.

3. Valide la descripción de la suma. La suma de “TotalTTC” ha sido añadida a la lista del resultado de la
consulta.
Al tiempo y a medida que se va creando la consulta, el editor de consultas de WINDEV crea las
consultas en lenguaje natural (e igualmente en SQL).
Nota
De esta forma puede verificar que no está equivocándose para conseguir el objetivo de su
consulta.
 Ahora vamos a reagrupar los datos por año y clasificarlos:

1. Seleccione la rúbrica “Pedido.Fecha” en el centro.
2. En las “Acciones”, a la derecha, clique sobre “Año, departamento” y seleccione “Año”.
3. Valide la ventana que aparece.

4. La rúbrica “Año” se muestra en el centro de la descripción de la consulta.
5. Seleccione la rúbrica “Año” y defina su clasificación:
 Muestre el menú contextual de la rúbrica “Año”.
 Seleccione la opción “Clasificar la rúbrica .. Clasificar en orden creciente”.
 Una flecha que indica la clasificación aparecerá en la descripción de la consulta.
 La consulta se ha creado. Ahora vamos a darle un nombre y guardarla.
1. Arriba de la pantalla, introduzca el nombre “REQ_EvolucionVentas”.
2. Introduzca el texto “Suma de pedidos por fecha”.
3. Valide
4. La representación gráfica de la consulta es la siguiente:
5. Clique sobre para guardar la consulta. Ya solo queda probarla.
6. Clique sobre para probar la consulta.

Creación del campo Gráfico
Vamos a integrar el campo Gráfico en una nueva pestaña de la ventana WIN_Menu.
 Para crear una nueva pestaña en la ventana “WIN_Menu”:
1. Muestre si es necesario la ventana “WIN_Menu” en el editor de ventanas.
2. Doble clic en el campo Pestaña: aparecerá la descripción del campo.
3. En la pestaña “General”, seleccione el panel pestaña “Búsqueda de pedidos” y clique sobre el botón “Nuevo”.
Aparecerá un nuevo panel.
4. Seleccione el nuevo panel (tiene por nombre “Panel 4”).
5. En la parte derecha de la pantalla, introduzca el texto del panel pantalla: “Gráfico”.
6. En la parte derecha de la pantalla, seleccione una imagen en el catálogo de imágenes:
 Clique sobre el botón “Catálogo”.
 En el campo de búsqueda introduzca “Gráfico”.
 Seleccione el tema “Flat Soft” y valide.
 Seleccione el segundo icono propuesto y valide las distintas pantallas.
8. La nueva pestaña aparece en la ventana.
 Para crear el campo Gráfico:

1. En la ventana “WIN_Menu”, seleccione la pestaña “Gráfico” si hiciera falta.

2. En el panel “Creación”, dentro del grupo “Campos gráficos”, clique sobre “Gráfico”. El campo aparecerá bajo
el cursor del ratón.
3. Clique en la pestaña “Gráfico”. Se lanzará el asistente de creación de un campo gráfico.
4. En el asistente, seleccione un gráfico de tipo “Histograma”. Avance al paso siguiente del asistente.
5. Introduzca los parámetros del gráfico:
 El título del gráfico: “Evolución de las ventas”.
 La leyenda: el gráfico no tiene leyendas.
 Las etiquetas deberán mostrarse.

6. Introduzca los parámetros de los ejes:
 Título del eje X: Año
 Título del eje Y: CA
Conserve las opciones por defecto y avance al paso siguiente.
7. Vamos ahora a definir la fuente de los datos.
 Para las etiquetas (valores mostrados bajo del gráfico, en nuestro ejemplo, son los años):
o La fuente corresponde a “Recorrido de un fichero o una consulta”.
o Los datos corresponden a la rúbrica “Año” en la consulta REQ_EvolucionVentas.
 Para las series (valores mostrados en el campo Gráfico): el campo gráfico mostrará una única serie
correspondiente al total TTC calculado por la consulta REQ_EvolucionVentas.
o Doble clic en el tablero “Fuentes de series”.
o Introduzca el texto “Serie 1”.
o La fuente corresponde a: Recorrido de un fichero o de una consulta.
o Los datos corresponden a la rúbrica “La_suma_TotalTTC” en la consulta “REQ_Evolucion_Ventas”.

8. No vamos a asociar ninguna imagen de fondo al campo gráfico. Avance al paso siguiente.
9. De un nombre al campo Gráfico: “GRF_EvolucionVentas” y valide el asistente.
10. El campo Gráfico se crea automáticamente en el editor.
11. Clique sobre para guardar la ventana y luego sobre para probar la ventana.
12. Clique sobre la pestaña “Gráfico” para visualizar el gráfico.

Funcionalidades automáticas del campo Gráfico (FAA)
Como el campo Tabla, el campo Gráfico propone varias funcionalidades automáticas accesibles a
través de su menú contextual.
Nota
Es posible, por ejemplo:

 Cambiar el tipo de gráfico
 Guardar el gráfico
 Imprimir el gráfico, …
13. Finalice la prueba y vuelva al editor.
Para controlar el uso de un campo Gráfico, no dude en repasar los ejemplos proporcionados con
WINDEV:
Ejemplo
 Ejemplo unitario: Campo Gráfico

 Ejemplo didáctico: WD Gráfico
Estos ejemplos están disponibles desde la ventana inicial de WINDEV ([CTRL]+[>]).

Creación de tableros de síntesis mediante el campo Tablero Cruzado
Dinámico
Para manipular el campo Tablero cruzado dinámico en condiciones reales, vamos a realizar un campo Tablero cruzado
dinámico que permitirá visualizar las ventas de productos por país y por año en cantidad y en cifras de negocio.
Como para el campo Gráfico, vamos a crear el campo Tablero cruzado dinámico en una nueva pestaña de la ventana
WIN_Menu.
 Para crear una nueva pestaña en la ventana “WIN_Menu”:
1. Muestre si es necesario la ventana “WIN_Menu” en el editor de ventanas.
2. Doble clic sobre el campo Pestaña: la ventana de descripción del campo se mostrará.
3. En la pestaña “General”, seleccione el panel pestaña “Gráfico” y clique sobre el botón “Nuevo”. Una nueva
pestaña aparecerá.
4. Seleccione la nueva pestaña (con nombre “Panel 5”).
5. En la parte derecha de la pantalla, introduzca el texto del panel pestaña: “Tablero Cruzado Dinámico”.
6. En la parte derecha de la pantalla, seleccione una imagen en el catálogo de imágenes:
 Clique en el botón “Catálogo”.
 En el campo de búsqueda introduzca “Tablero”.
 Seleccione el tema “Flat Soft” y valide.
 Seleccione el segundo icono propuesto y valide las distintas pantallas.
8. La nueva pestaña aparecerá en la ventana.
Creación del campo Tablero Cruzado Dinámico
 Para crear un campo Tablero Cruzado Dinámico:
1. En la ventana “WIN_Menu”, seleccione la pestaña “Tablero Cruzado Dinámico” si hiciera falta.
2. En el panel “Creación”, en el grupo “Datos”, despliegue “Tabla y lista” y seleccione “Tablero Cruzado
Dinámico (TCD)”. El campo aparecerá bajo el cursor del ratón.
3. Clique en la pestaña “Tablero cruzado dinámico”. Se lanzará el asistente de creación de un campo Tablero
cruzado dinámico.

5. En las celdas, vamos a mostrar dos informaciones:
 El total de ventas
 La cantidad vendida
En el asistente, vamos primero que nada a seleccionar el fichero fuente: LineaPedido.
Para la primera información, seleccione:
 Mostrar: “La suma de “.
 Fuente: “TotalTTC”.
Clique sobre el botón “Añadir un valor suplementario”.
Para la segunda información, seleccione:
 Mostrar: “La suma de”
 Fuente: “Cantidad”.

6. En las cabeceras de las columnas, queremos mostrar los años. En la parte izquierda, despliegue el fichero
Pedidos” y haga doble clic sobre la rúbrica Fecha.
Avance al paso siguiente

7. El asistente propone un enlace para acceder al fichero Pedidos y propone mostrar en la cabecera tres niveles
de información: Los años, los trimestres y los meses.

8. Valide y avance al paso siguiente.
9. En las cabeceras de las líneas, queremos mostrar los productos agrupados por país. En la parte izquierda:
 Despliegue el fichero Cliente y haga doble clic sobre la rúbrica País.
 Despliegue el fichero Producto y haga doble-clic sobre la rúbrica Etiqueta.

10. El asistente propone un enlace para cada cabecera de línea (Cliente.Pais y Producto.Etiqueta). Valide cada
enlace y avance al paso siguiente.
11. Proporcione un nombre al campo Tablero Cruzado Dinámico: TCD_Ventas.
13. El campo Tablero Cruzado Dinámico se crea automáticamente en la ventana, así como un botón “Calcular”.
Este botón permitirá al usuario lanzar el cálculo de los datos a mostrar en el Tablero Cruzado Dinámico. Este
botón puede estar colocado en cualquier sitio de la ventana.
14. Guarde la ventana ( en los botones de acceso rápido).
Prueba del Tablero Cruzado Dinámico
 Pruebe la ventana ( en los botones de acceso rápido). Clique sobre la pestaña “Tablero Cruzado Dinámico” y
luego sobre el botón “Calcular”.
ATENCION: Según el tamaño de la base de datos y el número de cabeceras de líneas y de

columnas, el tiempo de cálculo puede ser más o menos largo.
Nota
Puede guardar el resultado del tablero cruzado dinámico para evitar el recálculo a cada consulta.
Clique sobre las “+” para desplegar las distintas columnas y líneas.
 Detenga la prueba. Vamos a hacer una pequeña mejora en este tablero cruzado dinámico. Efectivamente, nada
indica que una de las cifras en las celdas corresponde a una cantidad. Vamos a utilizar una máscara de
visualización específica para este valor.
 Para poner una máscara de visualización en una celda:
1. Muestre la descripción del campo Tablero Cruzado Dinámico (doble clic sobre el campo).
2. En la pestaña “Contenido”, clique sobre “VAL_SinNombre2”. La descripción de los valores mostrados en las
celdas aparecerá.
3. En la zona “Máscara”, añada el prefijo “Cant: “.

5. Vuelva a lanzar la prueba de la ventana.

Lección 3.9. Enviar un email
 Como enviar un email desde una aplicación WINDEV
 Como integrar un supercampo a una ventana
 Como definir el orden de navegación en una ventana
 Como abrir una ventana no modal

Presentación
WLangage posee todas las funciones necesarias para gestionar el envío y la recepción de emails. Puede también
acceder a todas las características de un emal:
 Remitente, destinatarios.
 Fecha de envío, sujeto, mensaje
Piezas adjuntas, …WINDEV permite gestionar los emails gracias a varios métodos:
 Gestión a través de Lotus Notes, Outloook o MSExchange:
o Software de mensajería Lotus Notes u Outlook: mediante este software, se pueden enviar y
recibir emails.
o API “Simple Mail API” (también llamado SMAPI o Simple MAPI): este modo de gestión de los
emails es utilizado por la mayor parte de las aplicaciones Microsoft y principalmente Microsoft
Exchange.
 Gestión a través de los protocolos POP3, IMAP y SMTP
o El protocolo POP3: Este protocolo de recepción de emails lo reconocen todos los proveedores de
servicios. Permite dialogar directamente con el servidor, disponible en casa de su proveedor de
acceso. Este protocolo permite listar los mensajes recibidos y leerlos.
o El protocolo IMAP: Este protocolo de recepción de emails permite dejar los emails en el servidor para
que puedan ser consultados por los distintos clientes de mensajería o webmail.
o El protocolo SMTP: Este protocolo de envío de correos lo reconocen todos los proveedores de
servicio.
En esta lección, vamos a crear una ventana que permitirá al usuario enviar un email desde la aplicación “WD
Aplicación Completa”. Esta ventana es la siguiente:
Para ello, vamos a utilizar el protocolo SMTP. Este es el modo más utilizado actualmente en el mundo.
Para más detalles sobre otros métodos, consulte la ayuda en línea.
Si no ha creado las páginas de las lecciones anteriores, puede seguir esta lección abriendo un
Corregido
También hay disponible un proyecto corregido: En el panel “Inicio”, dentro del grupo “Ayuda en
línea”, despliegue “Guía de auto-formación” y luego seleccione “Aplicación completa
(Corregida)”.

Para más detalles sobre la gestión de los emails, consulte el “WD Mail” (ejemplo completo)
Ejemplo
proporcionado en estándar con WINDEV. Este ejemplo es accesible desde la ventana de

bienvenida de WINDEV ([CTRL]+[>]).
Una ventana para enviar los emails

La ventana que vamos a crear contendrá todos los campos que permitirán al usuario introducir los distintos elementos
del email. Un botón “enviar” reagrupará todos los tratamientos que permitirán el envío del email.
 Cree una nueva ventana:
1. Abra si hiciera falta el proyecto “WD Aplicación Completa”.
 Clique sobre en los botones de acceso rápico.

 Se muestra la ventana de creación de un nuevo elemento: clique sobre “Ventana” y luego sobre “Ventana”.
 Se lanza el asistente de creación de ventanas.
 En la pestaña “Basada en un modelo”, seleccione “Utilizar: WINMOD_Modelo” y valide el asistente.
3. Guarde la ventana ( o [CTRL]+[S]). Esta ventana tiene como título “Envío de un email”, su nombre
“WIN_Envio_de_un_email” se propone automáticamente. Valide las informaciones propuestas.
Creación de los campos de parametrización del envío
Vamos en una primera parte a crear todos los campos que permiten parametrizar el servidor SMTP utilizado para el
envío de los mensajes. Son necesarios cuatro campos de edición:
 Servidor SMTP.
 Puerto del servidor SMTP.
 Nombre del usuario.
 Contraseña del usuario.
 Para crear el campo de edición correspondiente al nombre del servidor SMTP:
2. La forma del campo aparecerá bajo el cursor del ratón.
3. Clique arriba a la izquierda de la ventana: El campo de edición se crea automáticamente.
4. Seleccione el campo y utilice la tecla [ENTER] del teclado. El texto pasa a modo edición. Introduzca “Servidor
SMTP” y valide.
 Para crear el campo de edición correspondiente al puerto:
1. En el panel “Creación”, dentro del grupo “Campos habituales”, despliegue “Edición”.
2. Seleccione un campo de edición predefinido de tipo Entero.
4. Clique bajo el campo “Servidor SMTP”: el campo de edición se crea automáticamente.
5. Seleccione el campo y utilice la tecla [ENTER] del teclado. El texto pasa a modo edición. Introduzca “Puerto” y
valide.
 Para crear el campo de edición correspondiente al nombre de usuario:
1. En el panel “Creación”, dentro del grupo “Campos habituales, clique sobre .
3. Clique bajo el campo “Puerto”: el campo de edición se crea automáticamente.
4. Seleccione el campo y utilice la tecla [ENTER] del teclado. El texto pasa a modo edición. Introduzca “Usuario”
y valide.
 Para crear el campo de edición correspondiente a la contraseña del usuario:
1. En el panel “Creación”, dentro del grupo “Campos habituales”, despliegue “Edición”.
2. Seleccione un campo de edición predefinido “Contraseña”.
4. Clique bajo el campo “Usuario”: el campo de edición se crea automáticamente.

El campo de edición “Contraseña” aparecerá en el editor con un asterisco y un ojo.
En ejecución, cuando el usuario introduzca su contraseña, los caracteres serán reemplazados por
asteriscos. Un clic sobre el ojo, permitirá ver la contraseña introducida y ver claramente el dato
Astucia
introducido. El usuario podrá así verificar su contraseña.

Si se desea, esta funcionalidad puede desactivarse por programación. Para más detalles,
consulte la ayuda en línea.
 Alinee los campos que acaba de crear:

1. Seleccione los cuatro campos.
2. En el panel “Alineamiento”, dentro del grupo “Interno y externo”, clique sobre “Justificar (Int. y Ext.).

Creación de los campos que permitirán introducir las características del email
Para escribir un email, el usuario deberá tener a su disposición:
 Un campo que permita introducir la dirección del remitente.
 Un campo que permita introducir o seleccionar la dirección del destinatario.
 Un campo que permite introducir el sujeto del email.
 Un campo que permita introducir el texto del email. El usuario deberá tener la posibilidad de poner formato al
texto del email.
 Un campo que permita añadir datos adjuntos.
Vamos a añadir todos estos campos en algunos clics en nuestra ventana.
 Para crear el campo de edición correspondiente a la dirección del remitente:
1. En el panel “Creación”, dentro del grupo “Campos usuales”, despliegue “Edición”.
2. Seleccione el campo de edición predefinido “E-Mail”.
4. Clique bajo del campo “Contraseña”: el campo de edición se crea automáticamente.
5. Seleccione el campo y utilice la tecla [ENTER] del teclado. El texto pasa a modo edición. Introduzca
“Remitente” y valide.
 El campo que permitirá la entrada de la dirección del destinatario será un campo que propondrá las direcciones
de los clientes que hay en la base de datos pero también permitirá al usuario introducir una dirección distinta.
Para ello, vamos a utilizar un campo de tipo “Combo con entrada”, enlazado al fichero de datos Cliente.
1. En el panel “Creación”, dentro del grupo “Campos habituales”, clique sobre “Combo”.
3. Clique bajo el campo “Remitente”: El asistente de creación del campo Combo se lanza automáticamente.
4. Seleccione la opción “Mostrar los datos de un fichero o de una consulta existente”. Avance al paso siguiente.
5. Seleccione el fichero “Cliente”. Avance al paso siguiente.
6. Queremos mostrar en el campo las direcciones email de los clientes:
 Desmarque la rúbrica “IDCliente”.
 Marque la rúbrica “Email”.
7. La rúbrica de clasificación es la rúbrica “Email”. Avance al paso siguiente.
8. El valor de retorno es también la rúbrica “Email”. Avance al paso siguiente.
9. Conserve las opciones por defecto. Avance al paso siguiente.
10. En la pantalla “Parámetros suplementarios”, marque la opción “Autorizar la entrada”. De este modo, el
usuario podrá introducir una nueva dirección email. Avance al paso siguiente.
11. Modifique el nombre y el texto del campo Combo:
 El nombre del campo es “COMBO_Destinatario”.
 El texto del campo es “Destinatario”.
12. Valide el asistente. El campo se crea automáticamente en la ventana.
 Para crear el campo de edición correspondiente al sujeto del email:

2. La forma del campo aparecerá debajo del cursor del ratón.
3. Clique bajo el campo “Destinatario”: el campo de edición se crea automáticamente.
4. Seleccione el campo y pulse la tecla [ENTER] del teclado. El texto pasa a modo edición. Introduzca “Sujeto” y
valide.
 Para el cuerpo del mensaje, vamos a utilizar un campo de edición HTML: el usuario podrá así dar forma
fácilmente el texto del email mediante una barra de utilidades específica.
1. En el panel “Creación”, en el grupo “Campos habituales”, despliegue “Edición”.
2. Seleccione un campo de edición predefinido “Texto HTML”.
4. Clique bajo el campo “Sujeto”: El campo de edición se crea automáticamente.
5. Agrande el campo para que puedan visualizarse varias líneas.
6. Muestre la ventana de descripción del campo (doble clic sobre el campo).
 En la pestaña “General”, modifique el modo de visualización de la barra de utilidades HTML. Esta barra de
utilidades deberá estar siempre visible.
 Valide la ventana de descripción del campo.
7. Si hiciera falta, reposicione el campo para que se muestre correctamente la barra de utilidades.
 Para que el usuario pueda añadir un dato adjunto, vamos a proponerle un selector de ficheros. Pero en vez de
crear todas las piezas, vamos a utilizar un campo de edición pre-definido de tipo fichero. Mediante el menú
contextual del campo (opción “Recorrer”), el usuario podrá seleccionar el fichero a adjuntar.
1. En el panel “Creación”, dentro del grupo “Campos habituales”, despliegue “Edición”. Se mostrará la lista de
los campos predefinidos disponibles por defecto.
2. Seleccione el campo “Fichero” y haga un “Drag and Drop” hacia la ventana “WIN_Envio_de_un_email”: deje
el campo bajo el campo “Texto HTML”. El selector de ficheros se crea inmediatamente.
 Alinee los distintos campos existentes en la ventana.

Vamos ahora a crear el botón que permita enviar los emails.
Envío del email
 Para crear el botón de envío:
2. Clique en el emplazamiento de creación del botón (por ejemplo, bajo de la ventana).
3. Seleccione el botón y modifique su texto (por ejemplo, utilizando la tecla [ENTER]). El nuevo texto es
“Enviar”.
4. Edite el código de este botón: en el menú contextual del botón (clic derecho), seleccione la opción “Código”.
5. Introduzca los distintos códigos siguientes en el tratamiento servidor de “Clic sobre”:
 El código de conexión y de apertura de la sesión SMTP.
MiSesion is EmailSMTPSession
MiSesion..Name = EDT_Usuario
MiSesion..Password = EDT_Contraseña
MiSesion..ServerAddress = EDT_Servidor_SMTP
MiSesion..Port = EDT_Puerto
// Abrir la sesión SMTP
IF NOT EmailStartSession (MiSesion) THEN
Error (“Imposible conectar al servidor SMTP.”, ErrorInfo ())
RETURN
END
Este código utiliza una variable avanzada de tipo EmailSMTPSession. Las distintas propiedades de esta variable
permiten definir las características de la sesión SMTP. La función EmailStartSession utilizada junto a esta
variable, permite abrir la sesión.
 Código de preparación del email:
MiMensaje is Email
MiMensaje..Sender = EDT_Remitente
MiMensaje..Subjec t= EDT_Sujeto
MiMensaje..HTML = EDT_Texto_HTML
MiMensaje..Message = HTMLToText (EDT_Texto_HTML)
// Añadir un destinatario
Add (MiMensaje..Recipient, COMBO_Destinatario..DisplayedValue)
// Añadir el dato adjunto si se desea
IF EDT_Fichero <> “” THEN
EmailLoadAttachment (MiMensaje, EDT_Fichero)
END
Este código utiliza una variable de tipo Email. Las distintas propiedades de esta variable permiten definir las
características del email a enviar. Este código asocia pues el contenido de los distintos campos de la ventana
a las propiedades de la variable de tipo Email.
 Código del envío del email:
// Envío del email
IF EmailSendMessage (MiSesion, MiMensaje) = False THEN
Error (“Error de envío”, ErrorInfo ())
ELSE
ToastDisplay (“Mensaje enviado”, toastShort, vaMiddle, haCenter)
END
El envío del email se realiza sencillamente con la función EmailSendMessage. Hay que pasarle como
parámetro la variable que contiene las características de la sesión SMTP y la variable que contiene las
características del email a enviar.
Si se envía el email, se muestra un mensaje de tipo Toast indicando que el email se ha enviado. Un mensaje
de tipo Toast corresponde a un mensaje furtivo.
 Código de cierre de la sesión SMTP
// Cierre de la sesión SMTP
EmailCloseSession (MiSesion)
Este código cierra la sesión utilizando la función EmailCloseSession.
 Guarde la página y su código ( o [CTRL]+[S]).
Mejoras en la ventana
Vamos a aportar algunas mejoras a nuestra página PopUp:
 Añadir un botón de cierre.
 Mejorar la forma de la ventana con la gestión de los anclajes y el orden de navegación.
 Lanzar la ventana desde la ventana “WIN_Menu”.
Cierre de la ventana
 Para añadir un botón que permita cerrar la ventana:
1. En el panel “Creación”, dentro del grupo “Campos habituales”, despliegue “Botón”: la lista de los botones
predefinidos se mostrará.
2. Clique sobre el botón “Cerrar”.
3. Clique en la ventana, en la posición donde se deberá crear el botón (por ejemplo, bajo, a la derecha del
botón “Enviar”).
Dar forma a la ventana
 Para definir los anclajes:
 Seleccione los campos “Remitente”, “Destinatario” y “Sujeto”: estos campos deberán anclarse en anchura.
 Seleccione el campo “Texto HTML”: este campo deberá anclarse en anchura y en altura.
 Seleccione los botones: estos campo deberán anclarse a la derecha y bajo.
 Seleccione el campo de selección de fichero: este campo deberá anclarse en anchura y bajo.
 Para definir el orden de navegación:

El orden de navegación de los campos es el orden en el que el usuario podrá introducir los
valores en los distintos campos de la ventana. El paso de un campo a otro se realizará cuando se
pulse la tecla [TAB] durante la ejecución.
Por defecto, el orden de entrada corresponderá al orden de creación de los campos. Puede
Notas
modificarse:
 Proporcionando un orden de entrada automático: el primero será el campo situado más
arriba a la izquierda, el segundo, el situado a su derecha o inmediatamente debajo, …
 Especificando un orden de entrada por selección.
1. Muestre el orden de navegación con la tecla [F5].

2. Defina el orden de navegación automático: en el panel “Ventana”, dentro del grupo “Orden”, despliegue
“Navegación” y seleccione “Definir automático”.
3. Los números se modifican y aparecerán en el nuevo orden.
4. Pulse de nuevo sobre la tecla [F5] para hacer desaparecer los números.
Apertura no modal de la ventana.

La ventana de gestión de emails se abrirá directamente desde la ventana “WIN_Menu”. Su modo de apertura se
especificará para que esta ventana no bloquee la consulta de las distintas informaciones mostradas en la ventana
“WIN_Menu”.
 Para abrir la ventana “WIN_Envio_de_un_email” desde la ventana “WIN_Menu”:
1. Muestre la ventana “WIN_Menu” en el editor (doble clic sobre su nombre en el panel “Explorador” por
ejemplo).
2. En el editor, despliegue la opción “Menú” y seleccione la opción “Cerrar”.
3. Muestre el menú contextual de la opción “Cerrar” (clic derecho) y seleccione “Añadir delante”.
4. Introduzca el texto de la opción “Enviar un email” y valide.
5. Seleccione nuevamente la opción “Cerrar”.
6. Muestre el menú contextual de la opción “Cerrar” (clic derecho) y seleccione “Insertar un separador”.
7. Muestre el menú contextual de la opción “Enviar un email” (clic derecho) y seleccione “Código”.
// Abre la ventana de envío del email
OpenChild (WIN_Envio_de_un_email)
En este código, la función OpenChild permite realizar una apertura “no modal” de la ventana: El usuario podrá a
la vez escribir un email y consultar las informaciones de la ventana principal.
 Guarde la ventana y su código ( o [CTRL]+[S]).
 Lance la prueba del proyecto ( en los botones de acceso rápido) y la apertura de la ventana de envío de
emails.

Lección 3.10. Identificar al usuario: el
Groupware Usuario
 ¿Qué es el groupware usuario?
 Integrar el groupware usuario
 Configurar el groupware usuario
 Probar el groupware usuario

Presentación
Una aplicación puede utilizarse por diferentes intervinientes, teniendo todos ellos perfiles distintos. A menudo es
necesario prever los niveles de acceso con las funciones del usuario.
Tomemos un ejemplo sencillo: cuando se configura una gestión comercial, la aplicación propone las siguientes
funcionalidades:
 Consulta de tarifa
 Modificación de tarifa
 Introducir pedidos
Gestión de clientesSegún el usuario, los posibles accesos son distintos. Algunos ejemplos:
 Las secretarias pueden consultar las tarifas y crear los pedidos.
 Los comerciales pueden consultar la tarifa y establecer los pedidos, generar nuevos clientes.
 Los directores comerciales tienen acceso a todas las opciones.
WINDEV permite gestionar estos distintos niveles de acceso con algunos clics en sus aplicaciones por medio del
groupware usuario.
Vamos a integrar el groupware usuario en nuestra aplicación “WD Aplicación Completa” y configurarlo.
Corregido
auto-formación” y luego seleccione “Aplicación Completa (Corregida)”.
Integrar el groupware usuario

 Para integrar el groupware usuario en el proyecto “WD Aplicación completa”:
1. En el panel proyecto, dentro del grupo “Proyecto”, clique sobre “Groupware Usuario”. Se muestra la ventana
de parametrización del groupware usuario.
2. En el panel “Integración” hay disponibles dos modos de integración:

 Groupware de usuario automático: todos los elementos del groupware usuario se integran directamente
en su aplicación. Aprovecha así automáticamente todas las evoluciones del groupware. Además, es posible
aplicar la plantilla del proyecto a las ventanas del groupware.
 Groupware usuario personalizado: Todos los elementos del groupware se integran en su aplicación a
través de un componente interno. Es posible personalizar los distintos elementos del groupware usuario. No
obstante, las evoluciones no se tendrán en cuenta.
3. Seleccione la opción “Groupware usuario automático”.
4. Seleccione la pestaña “Ejecución”. Dos modos de arrancarlo están disponibles:
 Lanzamiento automático: El groupware se lanza desde el arranque de la aplicación.
 Lanzamiento manual: El groupware se lanzará por programación.

5. Conserve la opción “Lanzamiento automático”.
6. Seleccione la pestaña “Ficheros”. Esta pestaña permite definir el formato y el emplazamiento de los ficheros
de datos del groupware usuario. En nuestro caso, utilizaremos los ficheros de datos HFSQL Clásico, en el
emplazamiento especificado por defecto.
Si usted utiliza (o si el usuario final utiliza) Windows Vista (o un sistema operativo más reciente),
Notas
es aconsejable utilizar el directorio de datos.
7. En la pestaña “Ficheros”, seleccione la opción “Activar el histórico de las conexiones”. Esta opción permite al
supervisor saber quién está conectado, cuando y a qué hora.
8. Seleccione la pestaña “Opciones”. Esta pestaña permite definir el modo de identificación del usuario:
 Gestión para el groupware usuario.
 Uso de un anuario LDAP. En este caso, cuando se instala la aplicación, el usuario podrá introducir los
parámetros de su anuario LDAP.
 Uso de la autentificación Windows.
9. Valide. Aparecerá un mensaje indicando que por defecto, se ha creado un usuario Supervisor.
Por defecto, solo existe un usuario, el supervisor. La primera vez que se lanza la aplicación,
conéctese utilizando el nombre “Supervisor”. Podrá entonces definir la contraseña utilizada por el
supervisor.
Notas
10. Valide este mensaje. El Groupware usuario está integrado en el proyecto.
 A continuación, vamos a probar nuestra aplicación:
1. Lance la prueba del proyecto ( en los botones de acceso rápido). Una ventana de login aparecerá.
2. Conéctese como supervisor.
3. Defina su contraseña y de su confirmación. Valide.
4. Aparecerá un nuevo menú, permitiendo probar su aplicación o configurarla.
5. Elija la opción “Configurar el Groupware”.
Configurar el groupware usuario

La configuración del groupware usuario consiste en definir los distintos usuarios y sus derechos sobre las distintas
páginas y campos de la aplicación.

La configuración de los usuarios podrá realizarse:
 Cuando se desarrolla la aplicación. Los ficheros de datos necesarios (usuarios y sus
Notas
derechos) podrán instalarse con la aplicación.

 Cuando la aplicación está instalada, por el administrador de la aplicación.
Creación de los usuarios y los grupos.

 Para configurar el groupware usuario, vamos primero a crear un usuario “Prueba_1” y asociarlo al grupo
“Pruebas”. Vamos enseguida a configurar la gestión de los derechos del grupo.
 Para crear un usuario:

1. Clique sobre el botón “Nuevo” bajo de la zona “Usuarios”. La pantalla de introducción de un nuevo usuario
aparecerá.
2. Introduzca las siguientes informaciones:
 Login: Prueba_1
 Nombre: Prueba_1
 Contraseña: Prueba_1
Por defecto, la contraseña aparece enmascarada cuando se introduce. Para verificar la

contraseña introducida, clique sobre el icono en forma de ojo: la contraseña aparecerá visible
Notas
siempre que el botón del ratón esté pulsado.

3. Clique sobre el botón “Guardar”: El usuario “Prueba_1” aparecerá en la lista de los usuarios definidos por le
groupware usuario.
 Para crear un nuevo grupo de usuarios:
1. Clique sobre el botón “Nuevo” debajo de la zona “Grupos”. La pantalla de entrada de un nuevo grupo
aparecerá.
2. Introduzca el nombre del grupo “Pruebas”.
3. Clique sobre el botón “Guardar”. El grupo “Pruebas” aparecerá en la lista de los grupos definidos por el
groupware usuario.
 Para asociar el usuario al grupo:
1. Seleccione el usuario “Prueba_1” en la ventana.
2. Realice un Drag and Drop del usuario “Prueba_1 hacia el grupo “Pruebas”.

3. La asociación se ha realizado.
Definición de los derechos.
Ahora vamos a definir los derechos para el grupo de usuarios “Pruebas”. Estos derechos se aplicarán a todos los
usuarios del grupo. En nuestro ejemplo, los usuarios del grupo “Pruebas” no podrán:
 Mostrar la ventana de envío de emails.
 Crear o modificar un producto.
 Para definir los derechos:
1. Clique sobre la opción “Gestión de los derechos” a la izquierda de la ventana.
2. Seleccione el grupo “Pruebas”.
3. Clique sobre “Siguiente”.
4. La ventana que se muestra permite seleccionar cada ventana o informe de la aplicación.
 Para cada ventana o informe, se puede especificar si el elemento será o no accesible para el grupo.
 Para cada ventana, es posible indicar si los campos de la ventana seguirán el comportamiento de la aplicación
(por defecto), o serán inactivos, invisibles o grisados.
 Para prohibir el acceso a la ventana “WIN_Envio_de_un_email”:
1. Seleccione la ventana en la lista.
2. Clique sobre el botón “Prohibir el acceso”.

3. La ventana quedará prohibida.
 Defina los derechos sobre la ventana “WIN_Menu”. Esta ventana contiene una opción de menú permitiendo
mostrar la ventana de gestión de los emails así como los botones “Nuevo” y “Modificar”.
1. Seleccione la ventana “WIN_Menu”.
2. Clique sobre el botón “Siguiente”.
3. La ventana de configuración de los derechos sobre los campos de la ventana a parecerá.
4. Ponga en “Gris” los campos “BTN_Modificar” y “BTN_Nuevo”:
5. Pase a invisible la opción de menú “Enviar un email”:

6. Clique sobre el botón “Guardar”.
7. Cierre la ventana de configuración.
8. Se muestra el editor de WINDEV.
 Vamos ahora a probar la aplicación utilizando el login “Prueba_1”.
1. Lance la prueba del proyecto ( en los botones de acceso rápido). Una ventana de login aparecerá.
2. Conéctese como usuario “Prueba_1” con la contraseña “Prueba_1”. Valide.
3. Se lanza la aplicación. Podrá observar que los botones “Nuevo” y “Modificar” están “grisados” y que la opción
“Enviar un Email” es invisible.
4. Cierre la aplicación y regrese al editor.

Desmarcar la gestión del groupware usuario
En el seguimiento de este curso, no utilizaremos más el groupware usuario. Puede pues, desactivarlo directamente:
1. En el panel “Proyecto”, dentro del grupo “Proyecto”, clique sobre “Groupware Usuario”.
2. En la ventana que aparece, en la pestaña “Integración”, seleccione “No Groupware Usuario”.
3. Valide.
Si efectúa pruebas automáticas en su aplicación, será necesario configurar el groupware usuario

para no utilizar la ventana de login. Solo tiene que rellenar la opción “Login automático en modo
Notas
prueba” en la pestaña “Ejecución” de la ventana de parametrización del groupware.

Lección 3.11. Reutilización del código
mediante los componentes externos
 ¿Qué es un componente externo?
 Paso a paso, la creación de un componente externo.
 Difusión de un componente externo.

Presentación
Un componente externo WINDEV es un bloque de
la aplicación que puede ser reutilizado en un
número ilimitado de proyectos ( y también
ejecutables).
Un componente externo permite tener un
tratamiento idéntico con un código fuente único
para realizar una operación determinada también si
este tratamiento deberá realizarse por varios
proyectos.
Los proyectos que utilizan un componente externo
son accedidos en el editor WINDEV con el nombre
de los objetos, procedimientos o métodos hechos
visibles por del concebidor del componente. Los
proyectos no puede ver o modificar el código
fuente. La confidencialidad y la estabilidad del
código están garantizados.
La realización de un componente externo es muy sencilla.
¿Cómo hacerlo? Hágalo como habitualmente, cree sus ventanas, procedimientos, clases. Luego, cuando haya
terminado, en vez de elegir la opción de creación de un ejecutable, elija la opción de creación de un componente;
esto es todo!
Un componente puede contener código, ventanas, análisis, ficheros de datos, etc.
Para compartir el “código”, hay cinco métodos principales con WINDEV:

1. Las colecciones de procedimientos.
2. Las clases
Notas
3. Los supercampos (mediante el uso de un diccionario)

4. Los componentes externos
5. Los componentes internos
He aquí varios casos en los que los componentes pueden ser interesantes.
Trabajo en equipo
Un desarrollador crea y mantiene un componente externo que pone a disposición de los otros desarrolladores. No hay
riesgo de hacer modificaciones hechas “por error”!
Los proyectos voluminosos

Los componentes externos permiten tener proyectos distintos de tamaños reducidos y tener un proyecto central en el
que los elementos de otros proyectos son visibles. El usos de componentes externos es mucho mejor que las
bibliotecas (ficheros WDL).
Las bases de datos accedidas por varios proyectos
Cuando una misma base de datos es accedida por varios proyectos, es frecuente tener incoherencias en la base de
datos debidos a códigos fuentes modificados o muy viejos. Reagrupando las operaciones de acceso (en escritura al
menos) a la base de datos en un componente externo, lo que permitirá tener un único código a verificar/mantener y
por lo tanto limitar el riesgo de incoherencias en la base de datos.
Además, el uso de componentes evita recompilar la aplicación cuando hay una modificación en el análisis.
Tratamientos utilizados en varios proyectos

Es frecuente tener tratamientos más o menos complejos utilizados en varios proyectos. Se pueden reutilizar estos
tratamientos mediante las “colecciones de procedimientos” o de “clases”. En este caso existe un riesgo de
modificaciones no reportadas entre los distintos proyectos, que pueden resultar incompatibles entre ellos. El uso de
componentes externos permite evitar las modificaciones intempestivas y permite conservar los proyectos compatibles
permitiendo aportar sencillamente una modificación común.
Además con el posible uso de la palabra clave “PRIVADO”, podrá asegurar la confidencialidad de su código a todos los
niveles del componente externo. Cuando se reutiliza su componente externo en otro proyecto WINDEV, la llamada de
un procedimiento PRIVADO no se permitirá, pero la documentación concerniente al uso del procedimiento se
mostrará!
La posibilidad de difundir una funcionalidad o un conjunto de funcionalidades

Los componentes externos permiten realizar una funcionalidad o un conjunto de funcionalidades. Otros
desarrolladores WINDEV podrán integrar estas funcionalidades en sus propios proyectos. Los desarrolladores que
utilizan un componente externo pueden ver los elementos del componente que son visibles. Sin embargo, no podrá
verse ni modificarse el código fuente.
Puede difundir gratuitamente o comercializar los componentes externos!
Componente externo multi-productos

Un componente externo puede estar preparado para funcionar en:
 Una aplicación WINDEV
 Una aplicación WEBDEV
 Una aplicación WINDEV Mobile
O en los tres tipos de aplicacionesEn el último caso, WINDEV permite:
 Integrar los elementos que provienen de distintos productos (WEBDEV y/o WINDEV Mobile) en un mismo
componente externo.
 Indicar para cada plataforma de ejecución el código WLangage correspondiente (por ejemplo, la visualización
de una ventana se realiza con la función Open en WINDEV y la visualización de una página se realiza con la
función PageDisplay en WEBDEV).
Paso a paso
Paso 1: Creación de un componente externo
Vamos a crear un componente externo a partir del proyecto “WD Aplicación Completa”. Este proyecto permite
gestionar pedidos, productos y clientes. El componente externo que vamos a crear, nos permitirá conocer
instantáneamente desde otra aplicación, los clientes correspondientes a una ciudad determinada.
Cuando se llame al componente externo, podrá:
 Pasar una ciudad en parámetro
 Recuperar una cadena que contenga el nombre del cliente y el importe total de sus pedidos.
Para no tener que desarrollar el código necesario para el funcionamiento del componente, el proyecto “WD Aplicación
Completa” contiene todos los elementos necesarios.
Corregido
(Corregida)”.
 Para las necesidades del componente, el proyecto contiene:

 Una consulta “REQ_PedidosPorCiudad”. Esta consulta es una consulta parametrizada que permite obtener
para una ciudad determinada, los clientes correspondientes, así como el importe total de sus pedidos.
 Una colección de procedimientos “COL_Componentes”. Esta colección de procedimientos contiene:
o El procedimiento “DatoPedidosPorCiudad” que reenvía para la ciudad pasada en parámetros una
cadena que contiene el nombre del cliente y el importe total de sus pedidos.
o El procedimiento “LocalizacionDatos” que permite localizar los datos utilizados por el componente.
 Un análisis que permite declarar los ficheros de datos que almacenan la información.
 Vamos ahora a crear nuestro componente. Para ello, hemos de crear una configuración de proyecto.

Las configuraciones del proyecto permitirá crear a partir de un mismo proyecto varios
“ejecutables” distintos:
 Una aplicación 32 bits
 Una aplicación 64 bits
Notas
 Un componente
 …
En cualquier momento, puede elegir la configuración sobre la que va a trabajar y generar en una
única operación todos los elementos para todas las configuraciones de un proyecto.
 Para crear una configuración de proyecto de tipo “Componente”.

1. En el panel “Proyecto”, en el grupo “Configuración del proyecto”, despliegue “Nueva configuración” y
seleccione “Componente Externo (WDK)”.
2. El asistente de creación de una configuración de proyecto se lanza. WINDEV propone crear una configuración
de proyecto de tipo “Componente”. Avance al paso siguiente.
3. De un nombre a su configuración de proyecto: por ejemplo, “CompoPedidosPorCiudad”. Avance al paso
siguiente.
4. Conserve las opciones propuestas por defecto. Avance al paso siguiente.
5. Seleccione los elementos que constituyen la configuración del proyecto. En este ejemplo, estos elementos
también estarán en el componente.
 Clique sobre el botón “Ninguno”.
 Seleccione los elementos “REQ_PedidosPorCiudad” y “COL_Componentes”.
6. Avance al paso siguiente y valide la creación de la configuración.

7. La nueva configuración se convierte automáticamente en la configuración en curso.

Notas Para conocer y modificar la configuración en curso, utilice el panel “Explorador del proyecto”.
La configuración en negrilla corresponde a la configuración actual.

Para cambiar la configuración actual, doble clic sobre el nombre de la configuración a activar.
 Vamos ahora a generar nuestro componente.

1. En el panel “Proyecto”, dentro del grupo “Generación”, clique sobre “Generar”.
2. El asistente de generación del componente se lanzará. Avance al paso siguiente del asistente. WINDEV lista
los elementos a integrar en el componente (elementos especificados en la configuración y el análisis).
3. Seleccione todos los elementos (Botón “Todos”) y avance al paso siguiente.

4. El asistente le pide seleccionar los elementos del componente que serán accesibles desde la aplicación cliente.
En nuestro ejemplo, solo la colección de procedimientos “COL_Componentes” será utilizada.

6. WINDEV propone autorizar la traducción del componente. Esta funcionalidad es interesante sobre todo si su
componente deberá utilizarse para aplicaciones multi-lenguaje.
Si la opción “Autorizar la traducción del componente” está marcada, será posible traducir a partir de la aplicación
utilizando el componente los elementos especificados del componente.
Esta traducción será realizada con la ayuda de WDMSG, módulo independiente que permite extraer y reintegrar
los mensajes a traducir de un proyecto.
En este ejemplo, no marque esta opción. Avance al paso siguiente.
7. Elija las lenguas del componente. Nuestro ejemplo solo contiene el francés. Avance al paso siguiente.
8. El asistente propone a continuación gestionar las distintas versiones del componente. En nuestro ejemplo, el
componente acaba de ser creado
Conserve las opciones por defecto. Avance al paso siguiente.
9. Introduzca las distintas informaciones concernientes al componente:
 Propietario
 Texto, Copyright, …
11. Podrá asociar una imagen a su componente. Los usuarios del componente podrán identificarlos rápidamente
en el panel “Catálogo de ejemplos”. Avance al paso siguiente.
12. Especifique la presentación general del componente. Esta presentación permitirá al usuario del componente
conocer su finalidad. Introduzca por ejemplo:
13. Avance al paso siguiente. El asistente efectuará ahora la generación automática de la documentación del
componente. Esta documentación podrá estar basada en los comentarios insertados en su código.

14. Avance al paso siguiente. Tiene la posibilidad de modificar la documentación generada. No vamos a tocar
nada. Avance al paso siguiente.
15. Tiene la posibilidad de crear un fichero de ayuda asociado a su componente (formato CHM). Este fichero de
ayuda se proporcionará junto con el componente. Los clientes podrán acceder pulsando [F1] a partir del
código del componente.
No vamos a generar ningún fichero de ayuda. Avance al paso siguiente.
16. Tampoco vamos a registrar el componente en el GDS. Avance al paso siguiente.
17. Ya solo queda proporcionar un nombre físico a nuestro componente.
 Valide. Ya está, su primer componente ya está creado y listo para utilizarlo!

Paso 2: Uso del componente externo
Una vez creado, su componente está disponible para utilizarlo en cualquier otro proyecto WINDEV. Vamos ahora a ver
como reutilizar este componente.
 Para ello, vamos a crear un nuevo proyecto e importar nuestro componente en este proyecto.
1. Cierre el proyecto actual: en el panel “Inicio”, dentro del grupo “General”, despliegue “Cerrar” y seleccione
“Cerrar el proyecto”.
2. Valide el cierre del proyecto, y si fuera necesario, guarde las modificaciones.
3. Aparecerá la ventana inicial.
4. Cree un nuevo proyecto: clique sobre “Crear un proyecto” en la ventana de bienvenida.
 Este proyecto es una aplicación “Windows”.
 Este proyecto se llama “CompoUtilizacion” y no tiene análisis.
5. En el panel “Proyecto”, dentro del grupo “Proyecto”, despliegue “Importar” y seleccione la opción “Un
componente Externo .. A partir de un fichero”.
6. En el directorio del proyecto “WD Aplicación Completa”, seleccione el subdirectorio
“EXE\CompoPedidosPorCiudad.wdi”. El proyecto “WD Aplicación Completa” está disponible en el subdirectorio
“Autoformacion\Ejercicios\WD Aplicación Completa”.
Si creó el componente a partir del ejemplo “WD Aplicación Completa (con ventanas)”, seleccione
el subdirectorio “EXE\CompoPedidosPorCiudad”, y luego el fichero
“CompoPedidosPorCiudad.wdi”. El proeycto “WD Aplicación Completa (Con ventanas)” está
Notas
disponible en el subdirectorio “Autoformacion\Ejercicios\WD Aplicación Completa (Con

ventanas)”.
7. Después de haber clicado sobre “Abrir”, la descripción de nuestro componente se mostrará. Esta descripción
contiene:
 En la pestaña “General”, los elementos introducidos cuando se creó el componente, así como su
emplazamiento.

 En la pestaña “Detalle”, la descripción del componente, así como la ayuda generada automáticamente. Así
es posible conocer los elementos utilizables del componente.
Se puede acceder en cualquier momento a la descripción del componente. Basta con seleccionar
el componente en el explorador del proyecto y seleccionar la opción “Descripción” del menú
Notas
contextual. En este caso, también puede definirse el modo de carga del componente.
8. Valide (botón “Cerrar”). El componente estará integrado en su proyecto.
 Vamos ahora a crear una nueva ventana en blanco para utilizar el componente.
1. Cree una ventana en blanco.
 La ventana tiene como título “Clientes por ciudad”.
 El nombre de la ventana es “WIN_Clientes_por_ciudad”.
 Valide.
3. Muestre el código asociado a la ventana (opción “Código” del menú contextual”).
4. En el tratamiento “Fin de inicialización”, vamos a llamar la función “LocalizacionDatos” del componente. Esta
función espera como parámetro el camino que permita acceder a los ficheros de datos manipulados por el
componente. Introduzca el camino a los datos del ejemplo “WD Aplicación Completa”.
COL_Componentes.LocalizacionDatos (…
“C:\WINDEV\Autoformacion\Autoformacion\Ejercicios\” + …
“WD Aplicación Completa\Exe\CompoPedidosPorCiudad”)
// Indique el camino de SUS datos
6. En la ventana, añada los campos siguientes:
 Un campo de edición con el texto “Ciudad” y por nombre “EDT_Ciudad”.
 Un campo Tabla “TABLE_Resultado”, relleno mediante programación y compuesto por dos columnas:
o Una columna “Nombre” de tipo Texto.
o Una columna “Total Ventas” de tipo Numérico.
 Un botón con texto “Buscar” y por nombre “BTN_Buscar”.

 Edite ahora el código del botón “BTN_Buscar”. Con el clic sobre este botón, vamos a realizar el procedimiento de
búsqueda que hay en el componente. Este procedimiento:
 Espera como parámetro el nombre de la ciudad.
 Devuelve una cadena con la forma : Nombre Cliente 1 + TAB + Total Ventas 1 + CR + Nombre Cliente 2 +
TAB + Total Ventas 2 + CR + …
El código del botón “BTN_Buscar” deberá entonces:
 Llamar al procedimiento DatoPedidosPorCiudad del componente y pasarle como parámetro el contenido del
campo EDT_Ciudad.
 Tratar la cadena obtenida para añadirla a la tabla.
Introduzca el siguiente código:
sListaResultado is string
// Recupera la lista de los clientes y sus pedidos
// para la ciudad introducida
sListaResultado = COL_Componentes-DatoPedidosPorCiudad (EDT_Ciudad)
// Si la lista no está vacía
IF sListaResultado <> “” THEN
// Vacía la tabla
TableDeleteAll (TABLE_Resultado)
//Recorre los resultados
FOR ALL STRING sUnCliente OF sLIstaResultado SEPARATED BY CR
// Añade este cliente a la table
TableAdd (TABLE_Resultado, sUnCliente)
END
ELSE
// Si la lista está vacía
InfoBuild (“No se ha encontrado ningún clientes para la ciudad “”%1”””, EDT_Ciudad
END
 Guarde su ventana.
 Pruebe la ventana clicando sobre el botón en los botones de acceso rápido. En el campo de edición,
introduzca “París” (Respetando la mayúscula) y luego clique sobre el botón “Buscar”. Se mostrará la lista de
clientes.
 Y ya está finalizado! Sencillo, ¿verdad?

A partir de ahora, ya sabe crear un componente y reutilizarlo en sus aplicaciones. Pero podrá decidir igualmente
gestionar los procedimientos de instalación de sus componentes para, por ejemplo, distribuirlos separadamente de
sus aplicaciones.
Distribución de un componente externo.

Hay dos formas posibles para distribuir un componente:
1. Proporcionar los ficheros necesarios “manualmente”, es una distribución “simple”.
2. Crear una distribución más “profesional”, con el editor de instalación de WINDEV, WDInst.
Distribución simple
En este caso, deberá proporcionar todos los ficheros necesarios para el buen funcionamiento de su componente.
Estos ficheros se crean cuando se genera el componente (ficheros WDI, WDK, WDO, imágenes, otros documentos,
…). Estos ficheros se copiarán manualmente desde su directorio original hacia el directorio de destino. Los proyectos
WINDEV que utilizarán estos componentes, irán a buscar los ficheros dependientes a este directorio de destion.
Lista de ficheros a proporcionar para una distribución simple:
 Ficheros generados automáticamente por WINDEV (WDK, WDI, …).
 Ficheros de dependencias.
 Si el componente utiliza estos ficheros de dependencias, hará que proporcionar el fichero WDO. Este fichero
contiene las referencias a los distintos ficheros externos utilizados por el componente.
Distribución profesional
La difusión de los componentes con la ayuda de un procedimiento de instalación, consiste en proporcionar a los
usuarios del componente de WINDEV, un programa de instalación. Este programa instala todos los ficheros necesarios
para el uso del componente en el directorio especificado por el usuario.
Este modo de instalación permite gestionar automáticamente:
 El fichero WDO y la instalación de los ficheros suplementarios utilizados por el componente.
 La instalación automática de las herramientas necesarias (MDAC, Driver ODBC para HFSQL, …).
 La actualización automática de los ficheros de datos utilizados por el componente (si fuera necesaria).
 La desinstalación del componente.
 Cierre el proyecto”CompoUtilizacion”: En el panel “Inicio”, dentro del grupo “General”, despliegue “Cerrar” y
seleccione “Cerrar el proyecto”.
 Abra el proyecto “WD Aplicación Completa”. Seleccione si es necesario la configuración del proyecto
correspondiente al componente en el explorador del proyecto.
 Para crear la instalación, en el panel “Proyecto”, clique sobre “Procedimiento de instalación”. Se lanzará el
asistente de creación de un componente.
No vamos a detallar los distintos modos de instalación de un componente. Siga las instrucciones del asistente. Si
necesitara obtener más detalles relativos a la instalación de componentes, consulte la ayuda en línea (palabra clave:
“Componente externo, Distribuir un componente”).

Lección 3.12. Consumir un WEBSERVICE
 Presentación
 Importación y consumo de un WebService

Presentación
Un servicio Web se define generalmente como una aplicación accesible a través de los protocolos internet estándar.
Los servicios Web permiten notablemente la interactividad entre varios ordenadores conectados a través de Internet.
A través de los servicios Web, es posible hacer ejecutar los procedimientos y los tratamientos en un servidor Web
(.NET o J2EE) a distancia desde un puesto cliente.
Con WINDEV, estos servicios son utilizables como cliente, mediante el protocolo SOAP sobre HTTP (el protocolo
estándar de internet para la transferencia de páginas HTML), mediante las funciones SOAPxx, DotNetxx y J2EExx.
Cualquiera que sea la plataforma del servidor Web (.NET, J2EE, …) un servicio Web es accesible mediante el uso de
SOAP.
Con WINDEV, no es necesario masterizar estas informaciones. Un asistente se encarga de

Notas
(“casi”) todo!
Ejemplo práctico
Para probar y manipular un WebService, ponemos a su disposición un WebService específico para el Curso de Auto-
Formación.
Integrado con el proyecto “WD Aplicación Completa”, este WebService permite interrogar una base proveedor para
verificar la disponibilidad (stock) de un producto a partir de su referencia.
En primer lugar vamos a importar el WebService en el proyecto “WD Aplicación Completa”, y luego utilizarlo en la
aplicación para verificar a partir de una ficha Producto, la disponibilidad del producto visualizado.
Importación de un WebService
 Cierre si es necesario el proyecto en curso. Aparecerá la ventana de bienvenida.
 En la ventana de bienvenida, clique sobre “Curso de Auto-formación” y seleccione el proyecto “Aplicación
completa (Ejercicio)”. Se cargará el proyecto.
Astucia: Si no se muestra la ventana de bienvenida, en el panel “Inicio”, dentro del grupo “Ayuda en línea”,
despliegue “Guía de Auto-formación” y luego seleccione la opción “Aplicación Completa (Ejercicio)”.
Corregido
(Corregida)”.
 Si fuera preciso, situese bajo la configuración del proyecto “Ejecutable Windows 32 bits”: en el explorador del
proyecto, en la carpeta “Configuraciones”, doble clic sobre “Ejecutable Windows 32 bits”.
 Para importar un WebService en el proyecto:
1. En el panel “Proyecto”, dentro del grupo “Proyecto”, despliegue “Importar” y seleccione “Un WebService”.
2. Se lanza el asistente de importación. Avance al paso siguiente.
3. Indique la dirección a la que la descripción WSDL del WebService deberá importarse:
http://exemples.webdev.info/WSAUTOFORMATION_WEB/awws/WSAutoformation.awws?wsdl
Recuerde: este WebService permite interrogar una base proveedor para verificar la disponibilidad (stock) de
un producto a partir de su referencia.

4. Avance al paso siguiente. La importación del WebService se ha realizado.
5. Valide la ventana de información. El WebService importado está presente en la carpeta “WebServices” del
explorador del proyecto.
Detengámonos un instante sobre las informaciones mostradas en el explorador del proyecto:

La estructura está formada por:
 El nombre del WebService (WSAutoformation en este ejemplo).
 El nombre de cada función (ProductoEnStock en este ejemplo).
 El nombre de una estructura que contiene los parámetros de llamada (ProductoEnStock en este ejemplo), o
los valores de retorno (ProductoEnStockRespuesta en este ejemplo).
 El nombre de cada variable de la estructura (sReferenciaProducto en este ejemplo).
En nuestro ejemplo, el WebServicio importado se llama: WSAutoformation. Contiene una función: ProductoEnStock.
La función ProductoEnStock contiene 2 estructuras:
 ProductoEnStock
 ProductoEnStockRespuesta
La estructura ProductoEnStock contiene una variable sReferenciaProducto correspondiente al valor a pasar como
parámetro para la llamada a la función ProductoEnStock.
La estructura ProductoEnStockRespuesta contiene una variable (ProductoEnStockResultado) correspondiente al valor
de retorno de la función.
Consumo de un WebService
En nuestro ejemplo “WD Aplicación Completa”, vamos a integrar la llamada al WebService en la pestaña que permite
ver la lista de productos. Un botón “En stock? “ permitirá verificar la disponibilidad del producto mostrado a través del
WebService.
 Para utilizar el WebService:
1. Abra en el editor la ventana “WIN_Menu” (doble clic sobre su nombre en el explorador del proyecto, por
ejemplo).
2. En el panel pestaña “Lista de productos”, añada un botón:
 En el panel “Creación”, dentro del grupo “Campos habituales”, clique sobre .
 Clique en la ventana bajo el botón “Modificar”.
 El botón se crea automáticamente.
3. Modifique las características del botón (opción “Descripción” del menú contextual). Este campo tiene como
nombre “BTN_EnStock” y por texto “En Stok?”.

4. Muestre los tratamientos asociados al botón (opción “Código” del menú contextual).
5. En el tratamiento “Clic sobre BTN_EnStock” introduzca el código siguiente:
// Mostrar la respuesta del WebService
InfoBuild (“Número de productos “ “%2”” en stock : “ %2”,
COL_Referencia, ProductoEnStock(Col_Referencia))
 Se ha llamado a la función del WebService ProductoEnStock.
 La respuesta con formato se ha mostrado.
6. Cierre el editor de código y guarde la ventana ( o [CTRL]+[S]).
 Ahora vamos a probar el funcionamiento del WebService:

2. Clique si hiciera falta en la pestaña “Lista de productos”.
3. Seleccione un producto al azar en el campo Tabla y clique sobre el botón “En stok?”.
4. Valide la ventana de información y cierre la aplicación.

Lección 3.13. Siga la evolución de sus
aplicaciones
 ¿Qué es el tablero de a bordo?
 Pruebas automáticas

Presentación
El tablero de a bordo de un proyecto es un elemento indispensable para la gestión de proyectos WINDEV. El tablero
de a bordo permite tener una visión global y sintética del estado de avance de un proyecto.
El tablero de a bordo está formado por distintos elementos (Widgets) que permiten ver de una sola mirada el estado
de un proyecto.
En este capítulo, nos limitaremos a la manipulación de los distintos elementos del tablero de a bordo, a la gestión de
las pruebas automáticas y a la optimización de las consultas.
Corregido
(Corregida)”.
 Para mostrar el tablero de a bordo de un proyecto (si no lo ha hecho ya), en el panel “Proyecto”, en el grupo
“Proyecto”, clique sobre el icono .
El tablero de a bordo
El tablero de a bordo del proyecto está formado por distintos Widgets. Cada Widget muestra una o varias
informaciones relativas al proyecto.
Por ejemplo, el Widget “Realizaciones” permite lanzar directamente el analizador de realizaciones o de abrir el último
informe de realizaciones efectuado.
El Widget “Auditoría estática y Compilación”, permite ver rápidamente si el proyecto contiene errores de compilación.
En cualquier momento, se puede activar o desactivar un Widget, añadirlo o eliminarlo.
Pruebas automáticas
Una de las funcionalidades más interesantes del tablero de a bordo es informar sobre las pruebas que han de
realizarse sobre la aplicación.
Hemos realizado ya numerosas pruebas de utilización, a medida que realizábamos nuestra aplicación.
Las pruebas automáticas son una categoría de pruebas específicas. Las pruebas automáticas permiten automatizar
algunas manipulaciones de sus ventanas. Estas pruebas se guardan en forma de escenarios WLangage, fácilmente
modificables en el editor de código. Una vez guardada, la prueba automática puede ser reejecutada tantas veces
como se desee, para probar, por ejemplo el impacto de una modificación sobre una ventana, un procedimiento, …
Hagamos inmediatamente un ensayo! Vamos a crear una prueba automática en la ventana de introducción que
hemos creado al principio de esta lección.
Las pruebas automáticas pueden realizarse sobre ventanas, procedimientos y clases.

Notas
 Para crear una prueba automática sobre una ventana, basta con probar la ventana:
1. Abra la ventana “WIN_Menu” en el editor.
2. En el panel “Pruebas automáticas”, en el grupo “Pruebas”, despliegue “Nuevo” y seleccione “Guardar una
nueva prueba”.
3. En la ventana que aparece, clique sobre “Empezar el registro”.
4. Se lanza la prueba de la ventana.
5. Clique sobre la pestaña “Búsqueda de pedidos”,.
6. Seleccione el modo de liquidación “Carta bancaria”.
7. Clique sobre el botón “Buscar”.
8. Cierre la ventana por el menú “Menu .. Cerrar” y confirme el fin de la aplicación.
Si no ha seguido el curso completo, esta opción puede no existir. En este caso, cierre la ventana
Notas
utilizando el aspa.
9. La prueba ha finalizado
10. El editor de pruebas propone registrar una descripción para la prueba. La prueba se llama “Prueba de
búsqueda de pedidos”. Valide.
11. El código de la prueba en WLangage aparecerá en el editor de código. Cierre esta ventana de código.
Las funciones WLangage que permiten realizar las pruebas automáticas son las funciones
Notas
PiloteXXX (EMULATEXXX).
12. Aparecerá el editor de pruebas:

La prueba actualmente disponible no se ha pasado.
13. La prueba puede lanzarse en cualquier momento. El editor de pruebas nos indica que la prueba no se la
pasado nunca. Clique sobre el enlace “Lanzar la prueba”.
14. La prueba se ejecuta automáticamente y el editor de pruebas muestra el resultado (la prueba se ha pasado
con éxito en nuestro caso).
15. Cierre el editor de pruebas y guarde la prueba si fuera necesario.
 Vamos ahora a hacer una modificación en nuestra ventana, y luego repasar la prueba. La modificación se
realizará en el botón “Buscar”. Vamos a ponerlo en gris.
1. Muestre si es necesario la ventana “WIN_Menu”.
2. En el editor, clique sobre la pestaña “Búsqueda de pedidos” y seleccione el botón “Buscar”.
3. Muestre la descripción del botón “Buscar” (opción “Descripción” del menú contextual).
4. En la pestaña “IHM”, seleccione la opción “Grisado”.
7. Pase la prueba asociada a la ventana: En el panel “Pruebas automáticas”, despliegue “Ejecutar” y seleccione
la opción “Lanzar las pruebas”.
8. La prueba muestra ahora un errore.
9. Muestre la descripción del botón “Buscar” (opción “Descripción” del menú contextual).
10. En la pestaña “IHM”, seleccione la opción “Activo”.
12. Vuelva a lanzar la prueba. La prueba ahora pasa correctamente.
Otra posibilidad del editor de pruebas es la posibilidad de modificar o añadir código WLangage en los escenarios de
las pruebas. Vamos por ejemplo a añadir algunas líneas de código para verificar que el campo Tabla contiene al
menos un registro.
1. Muestre el editor de pruebas (por ejemplo, doble clic sobre “TEST_Menu” en el explorador del proyecto).
2. Muestre el código de la prueba (Opción “Código” del menú contextual de la “Prueba de búsqueda de
pedidos”).
3. Añada el siguiente código ates de la línea “PiloteMenu(“Menu”,”OPT_Salir”):

// Si el campo tabla no contiene ningún registro
IF WIN_Menu.TABLE_REQ_BusquedaPedidos..Occurrence = 0 THEN
// hay que enviar un error
TestWriteREsult(twrError, “El campo TABLA está vacío después de la búsqueda”
END

4. Guarde la prueba y cierre el editor de código.
5. Clique sobre el enlace “Lanzar la prueba” (o clique sobre el icono ). La prueba pasa con éxito.
 La posibilidad de utilizar un juego de valores de prueba.
 La definición de parámetros de entrada y de salida de la prueba.
 La posibilidad de crear una biblioteca de pruebas para probar un ejecutable por ejemplo sobre una máquina
distinta del puesto de desarrollo.
Par más detalles sobre las pruebas automáticas, le aconsejamos consultar la ayuda en línea (palabra clave: “Prueba
automática”).
 Cierre el editor de pruebas automáticas.

Lección 3.14. Desplegar la aplicación
 Creación del ejecutable
 Ayuda de las novedades
 Creación de la instalación

Presentación
Hemos creado una aplicación completa y descubierto numerosas funcionalidades de WINDEV. Ahora hay que generar
el ejecutable e instalar la aplicación en casa de los usuarios. Esto es lo que vamos a hacer para finalizar este capítulo.
De este modo habremos visto la mayoría de puntos importantes cuando se desarrolla una aplicación WINDEV.
Si no ha realizado las manipulaciones de las lecciones anteriores, puede seguir esta lección
Corregido
abriendo un proyecto corregido: En el panel “Inicio”, dentro del grupo “Ayuda en línea”,
despliegue “Guía de auto-formación” y luego seleccione “Aplicación completa (Corregida)”.
Creación del ejecutable

La creación del ejecutable es una operación muy sencilla: bastan una aplicación de menú y unos cuantos clics.
Le proponemos aquí detallar todos los pasos de la creación del ejecutable para conocer todas las posibilidades de
WINDEV. En cualquier momento podrá clicar sobre el botón verde para validar la totalidad de las pantallas del
asistente.
 Para crear el ejecutable:
1. En la zona de los botones de acceso rápido de la cinta, despliegue la rueda y seleccioen la opción “Generar el
ejecutable Windows 32 bits (.exe)”.
Si no ha seguido el curso completo, esta opción puede no existir. En este caso, cierre la ventana
Notas
utilizando el aspa.
2. Se lanza el asistente de creación del ejecutable.

3. Describa las opciones generales del ejecutable:
 El nombre del ejecutable: Vamos a conservar el nombre por defecto.
 El nombre del icono asociado al ejecutable: puede seleccionar un icono en el catálogo de imágenes.
 La imagen de introducción: Varios tipos de pantalla splash están disponibles. Por defecto, se selecciona una
pantalla splash con texto animado. El botón “Opciones” permite configurarlo.

Elija “No pantalla Splash” y avance al paso siguiente.
4. Para el funcionamiento del ejecutable, guardaremos las opciones por defecto. Avance al paso siguiente.
5. Puede personalizar el mensaje de error de la aplicación. Guardaremos el mensaje propuesto por defecto.
6. El asistente propone activar la telemetría en la aplicación. No utilizaremos esta funcionalidad. Avance al paso
siguiente.
La telemetría permite obtener estadísticas detalladas sobre el uso de su aplicación por los
usuarios finales. Gracias a la telemetría, conocerá todo sobre sus aplicaciones desplegadas y
podrá mejorarlas.
Notas
Para más información sobre el formato y la configuración de la telemetría, consulte la ayuda en

línea.
7. Esta pantalla permitirá indicar si el ejecutable tendrá en cuenta los parches.
Cuando se modifica una aplicación, para evitar el librar todo el ejecutable, se pueden librar
recursos complementarios (ventanas, informes, …) en forma de parches. Estos parches son de
hecho bibliotecas añadidas.
Notas
Si el ejecutable se crea con la opción “Si, el ejecutable tendrá en cuenta las actualizaciones por
parches”, cuando se lanza la aplicación, los elementos existentes en el parche sustituirán a los
elementos existentes en la biblioteca de la aplicación.
Guardaremos las opciones por defecto. Avance al paso siguiente.

8. Esta pantalla permite gestionar los idiomas del ejecutable. Abordaremos el sujeto del multilenguaje en una
próxima lección. Guardaremos las opciones por defecto. Avance al paso siguiente.
9. Esta pantalla recapitula todos los ficheros que se integrarán en la biblioteca del ejecutable. Estos son todos
los elementos de su proyecto que pueden ser manipulados por el usuario final. Guardaremos las opciones por
defecto. Avance al paso siguiente.
10. La siguiente pantalla concierne al directorio de los ficheros de datos.

La opción “Directorio de datos de la aplicación” está marcada por defecto. Efectivamente, en Windows Vista y
superiores, los ficheros de datos deberán estar instalados en el directorio de datos de la aplicación.
Aquí vamos a probar el ejecutable después de su generación. Para que los datos se muestren
Notas
durante la prueba, será preciso marcar la opción “Directorio de la aplicación o directorio actual”.
11. Seleccione la opción “Directorio de la aplicación o directorio actual”. Avance al paso siguiente.
12. Ahora vamos a introducir las informaciones del ejecutable. Estas informaciones se muestran en el explorador
de Windows cuando se seleccionan las propiedades del fichero.
Introduzca por ejemplo las siguientes informaciones:
Esta pantalla permite también firmar si hiciera fala el ejecutable.

Avance a la pantalla siguiente.
13. La pantalla siguiente concierne al número de versión del ejecutable. Se puede ejecutar:
 Un formato compatible con las versiones precedentes de WINDEV.
 Un formato estándar de Windows. Seleccione esta opción.
14. La pantalla siguiente concierne al framework WINDEV.
El framework corresponde a las distintas librerías necesarias para el funcionamiento del

Notas
ejecutable.
La opción “Dll del framework junto al ejecutable” permite utilizar solamente las librerías necesarias. Estas Dll se
copian en el directorio del ejecutable.
La opción “Framework integrado en el ejecutable” permite difundir únicamente el ejecutable (las Dll están presentes
en el ejecutable).
La opción “Framework común” permite utilizar el framework común a todas las aplicaciones WINDEV instaladas en el
puesto. Con esta opción, el framework se instala solamente una vez en el puesto (es posible descargarlo por Internet)

y es utilizado por todas las aplicaciones WINDEV. Seleccione esta opción y elija “Framework WINDEV común”. Avance
al paso siguiente.
15. Una pantalla relativa a Windows Vista (y superiores) aparecerá. Esta pantalla permite integrar un manifiesto
para un uso en Windows Vista (y superiores).
Para nuestro ejemplo, marque la opción “No integrar el manifiesto para Windows Vista y superiores”. Avance
al paso siguiente.
16. WINDEV propone realizar una copia de seguridad del proyecto. En nuestro caso, seleccione la opción “No: No
hacer copia de seguridad del proyecto” y valide el asistente.
17. El ejecutable se ha creado. Es posible lanzarlo inmediatamente, para verificar su funcionamiento. Para ello,
clique sobre el botón “Lanzar el ejecutable”.
Ya está. La creación del ejecutable está finalizada. Muchas opciones a rellenar, pero después de una primera
configuración seleccionada por usted, podrá validar desde el principio todos los pasos del asistente.
También es posible clicar directamente sobre las etapas indicadas en el asistente para acceder
directamente a una pantalla del asistente. Las opciones por defecto de las otras pantallas serán
Notas
validadas automáticamente.
Creación de la instalación
La creación de la instalación es una operación muy sencilla. Un asistente le permite definir las selecciones principales.
Si las opciones propuestas por el asistente no bastan, se puede utilizar el editor de instalación. No detallaremos su
uso en esta lección. Para más detalles, consulte la ayuda en línea.
Le proponemos aquí detallar todos los pasos de la creación del programa de instalación para conocer todas las
posibilidades de WINDEV. En cualquier momento podrá clicar sobre el botón verde para validar la totalidad de
pantallas del asistente.
 Para crear el programa de instalación:
1. En el panel “Proyecto”, en el grupo “Generación”, despliegue “Procedimiento de instalación” y seleccione la
opción “Crear el procedimiento de instalación”. El asistente de creación del ejecutable y de instalación se
lanzará.
2. Ya habíamos creado el ejecutable: las opciones elegidas están memorizadas. Solo tendremos que modificar el
directorio de instalación de los ficheros de datos:
 En el apartado “Ejecutable” del asistente (en el menú a la izquierda), clique sobre “Datos y Groupware”.
 Seleccione la opción “Directorio de datos de la aplicación”. Esta opción permite utilizar la norma Windows
para la instalación de los ficheros de la aplicación.
3. Clique en el asistente sobre el título “Complementos” del apartado “Ejecutable”.
4. El asistente propone realizar una copia de seguridad del proyecto. Seleccione la opción “No: No hacer copia
de seguridad del proyecto” y avance al paso siguiente.
5. El asistente propone crear la página de novedades.

Esta opción permite crear un fichero de ayuda para presentar al usuario final las novedades de la versión. Cuando
se trate de una primera instalación, este fichero puede corresponder a la ayuda del software.
Seleccione la opción “Crear una documentación de las novedades” y avance al paso siguiente.
6. Puede definir los elementos que se integrarán automáticamente al fichero de ayuda. Conserve las opciones
por defecto y avance al paso siguiente.
Si la aplicación tiene ya un sistema de ayuda, es posible utilizarlo para completarlo con una
Notas
página de novedades.
7. Valide el mensaje. El ejecutable se crea automáticamente (con las opciones que hemos definido durante la
creación del ejecutable) y el sistema de ayuda se ha creado. Puede introducir las informaciones específicas en
el sistema de ayuda. Para el ejemplo, introduzca las informaciones creadas por defecto. Para retomar la
creación del programa de instalación, clique sobre la opción “Continuar con la creación del procedimiento de
instalación”.
La ayuda está compilada automáticamente.

8. Pasamos ahora a la parte “Instalación” del asistente. En esta primera pantalla, elija el modo de instalación:
 Instalación individual para una aplicación independiente, instalada y lanzada en cada puesto. Vamos a
seleccionar esta opción.
 Instalación con actualización automática, para una instalación en un puesto servidor. Las aplicaciones se
instalarán a partir del servidor. En caso de actualización, solo se necesitará una actualización en el servidor.
Las aplicaciones instaladas se actualizarán automáticamente. Avance al paso siguiente.
9. Elija una instalación estándar. Avance al paso siguiente.
10. No cambiaremos el directorio de instalación por defecto. Avance al paso siguiente.
11. En la lista de ficheros instalados, conserve los ficheros propuestos. Por defecto, WINDEV propone el fichero
Ejecutable y el fichero de ayuda (creado para la ayuda de las novedades). Vamos a añadir los ficheros de
datos:
 Clique sobre el botón “Añadir”. El explorador de Windows muestra el contenido del directorio de generación
de la aplicación.
 Seleccione los ficheros de datos Cliente, Pedido, LineaPedido, ModoLiquidacion y Producto (ficheros con
extensión “.fic”, “.ndx” y “.mmo”).
 Valide. Los ficheros se posicionarán automáticamente en el directorio común de los datos.

13. En los parámetros de la base de datos, desmarque todas las opciones. Avance al paso siguiente.
14. En los módulos complementarios, conserve las opciones siguientes:

Vamos a elegir las utilidades opcionales a instalar e incluir el desinstalador. Gracias al desinstalador, los usuarios
podrán desinstalar la aplicación desde el administrador de programas de Windows. Avance al paso siguiente.
15. Vamos a seleccionar WDOptimizador. Esta utilidad permite optimizar regularmente los ficheros de datos de la
aplicación.
16. Clique sobre la opción “Soporte” a la izquierda del asistente. Vamos a generar la instalación en un directorio
único. Por defecto, el programa de instalación se crea en el subdirectorio “Install” del proyecto. Se puede:
 Especificar una contraseña para la instalación. Solo el usuario que conozca la contraseña podrá lanzar la
instalación de la aplicación.
 Firmar la aplicación con un certificado. Esta opción permite garantizar la integridad del paquete de instalación.
17. Valide. El programa de instalación se ha creado automáticamente.
18. Una pantalla aparecerá permitiendo probar la instalación o de abrir el directorio de generación.
Instalación de una aplicación

En la ventana de fin de creación de la instalación, clique sobre el botón “Probar”. Si tiene cerrada esta ventana, lance
directamente el programa “Instal.exe” que hay en el directorio del programa de instalación. Se lanzará la instalación
de la aplicación.
 Vamos a seguir los distintos pasos del programa de instalación de la aplicación “WD Aplicación Completa”.
1. Si utiliza un sistema operativo correspondiente a Windows Vista o superior, se mostrará una ventana pidiendo
la autorización de ejecutar el programa. Valide esta ventana.
2. Elija el lenguaje del programa de instalación y clique sobre “OK”.

3. Se lanza el asistente de instalación. Hay disponibles dos modos de instalación:
 Instalación rápida: La instalación se realiza directamente con los parámetros especificados por el proveedor
de la aplicación.
 Instalación personalizada: el asistente pide al usuario los parámetros de instalación de la aplicación.
4. Elija “Instalación personalizada”. El asistente pide el directorio de instalación de la aplicación.
5. Valide el directorio de instalación de la aplicación.

6. Avance al paso siguiente y termine la instalación de la aplicación.
7. Se lanza la instalación de la aplicación.
Los distintos tipos de despliegue

Venimos de realizar el despliegue de una aplicación sencilla. En el asistente de creación de instalación, WINDEV
propone igualmente instalaciones con actualizaciones automáticas.
Presentación
WINDEV propone por defecto varios modos de instalación para una aplicación WINDEV
 Instalación autónoma:
Este tipo de instalación permite crear un único programa de instalación. Este programa de instalación será
ejecutado por el usuario final, directamente en su puesto.
Para actualizar la aplicación, habrá que volver a crear una instalación de la aplicación. El usuario final deberá
instalar el nuevo programa.
Este es el tipo de instalación que acabamos de realizar.
 Instalación con actualización automática:
Este tipo de instalación permite detectar automáticamente las actualizaciones cuando se lanza la aplicación. Si
hay disponible una actualización, el usuario puede actualizarla inmediatamente.
Este tipo de instalación está disponible también a través de la red o de la Web. También se puede realizar una
instalación multi-sitio.
Vamos a detallar un poco más el funcionamiento de una instalación con actualización.
Instalación con actualización de red.
La creación del programa de instalación se realiza con el asistente de creación del programa de instalación (Opción
“Procedimiento de instalación” en el panel “Proyecto”).
El programa de instalación obtenido al final del asistente está conformado por dos instalaciones:
 La instalación de la aplicación de referencia. La aplicación de referencia deberá estar instalada en la red (por
ejemplo en un directorio compartido o sobre un servidor), accesible para todos los usuarios finales de la
aplicación.
 La instalación de la aplicación propiamente dicha. Esta instalación está englobada en la aplicación de referencia.
No es accesible hasta que no está instalada la aplicación de referencia.
El siguiente esquema presenta el modo de instalación de una aplicación utilizando una base HFSQL Clásico en local,
con una actualización de red.
A cada lanzamiento de la aplicación por el usuario final, la verificación de la aplicación de referencia se realiza
automáticamente. Si esta versión ha sido modificada (por ejemplo si se ha realizado una actualización de la versión de
referencia), se propone automáticamente una actualización de la aplicación final.
Instalación con actualización por internet

La instalación con actualización por Internet utiliza el mismo principio.
La creación del programa de instalación se realiza mediante el asistente de creación del programa de instalación
(opción “Procedimiento de instalación” en el panel “Proyecto”).
El programa de instalación obtenido al final del asistente está conformado por:
 La instalación de la aplicación de referencia y la página Web que permite descargar la instalación cliente.
Estos elementos deberán estar instalados en un servidor HTTP.
 La propia instalación de la aplicación. Esta instalación está englobada en la aplicación de referencia. No es
accesible hasta que la aplicación de referencia esté instalada, por la página Web de descarga.

El siguiente esquema muestra el modo de instalación de una aplicación utilizando una base HFSQL Cliente/Servidor,
con una actualización por Internet.
Recuerde: Este tipo de instalación puede igualmente efectuarse a través del CLOUD PCS (si dispone de una cuenta).
Instalación Multi-sitio
La instalación multi-sitio es la combinación de:
 Una instalación de red de referencia desplegada en una red local.
 Una instalación HTTP utilizada para la actualización de la instalación de referencia en la red local.

Lección 3.15. Difundir “Informes y Consultas”
con sus aplicaciones
 ¿Para qué sirve el software “Informes & Consultas”.
 Como difundir el software “Informes & Consultas”.
 Como utilizar el software “Informes & Consultas”.

Presentación del software “Informes & Consultas”
El software “Informes & Consultas” permite a los usuarios modificar y crear a su conveniencia los informes y las
consultas de sus aplicaciones.
¿Un usuario encuentra que le falta una información en el informe proporcionado en estándar? Con el software
“Informes & Consultas”, puede añadir la información directamente desde la vista previa de impresión. ¿Esta
modificación puede ser interesante para otros usuarios? El informe puede quedar a disposición de todos los usuarios
utilizando la aplicación en red. Lo mismo para las consultas.
El software “Informes & Consultas” es gratuito y de libre distribución con sus aplicaciones
creadas con WINDEV. Consulte la licencia para más detalles sobre las condiciones de
Notas
redistribución.
Lanzamiento del software “Informes & Consultas”

Para que los usuarios finales personalicen los informes de su aplicación o crean sus propios informes y sus propias
consultas, basta con lanzar el software “Informes & Consultas”.
Para permitir a sus usuarios finales lanzar el software “Informes & Consultas”:
 Puede mostrar sus informes en vista previa antes de impresión. Los usuarios finales podrán lanzar el software
“Informes & Consultas” clicando sobre el icono .

 Puede añadir el menú de ayuda automática “?” en la ventana principal de su aplicación:
En el panel “Ventana”, dentro del grupo “Barras y menús”, despliegue “Menú principal” y seleccione la opción
“Añadir el menú ‘?’”.
En el asistente de creación de este menú, marque las opciones “Crear, modificar un informe” y “Crear,
modificar una consulta”.
 Puede utilizar la función RunReportsAndQuerys en su aplicación.
Difundir el software “Informes & Consultas” con su aplicación

Para difundir software “Informes & Consultas” con su propia aplicación WINDEV, es necesario:
 Indicar el nivel del proyecto que la aplicación autoriza el lanzamiento del software “Informes & Consultas”.
 Definir si es necesario el nivel de análisis los ficheros y rúbricas que serán utilizados con el software “Informes
& Consultas”.
 Definir los informes y las consultas modificables con el software “Informes & Consultas”.
 Crear el ejecutable y el programa de instalación que integran el software “Informes & Consultas”.
Vamos a detallar las distintas etapas manipulando el proyecto “WD Aplicación Completa”.
Corregido
despliegue “Guía de auto-formación” y luego seleccione “Aplicación completa (Corregida)”.
Parametrización del proyecto

 Para utilizar el software “Informes & Consultas” a partir de su aplicación, es necesario configurar el proyecto
asociado a su aplicación.
1. Si es necesario, abra el proyecto ejemplo “WD Aplicación Completa”: en el panel “Inicio”, dentro del grupo
“Ayuda en línea”, despliegue “Guía de auto-formación” y luego seleccione la opción “WD Aplicación Completa
(Ejercicio”. Se carga el proyecto.

Si no ha realizado los informes en la aplicación “WD Aplicación Completa”, abra el proyecto
corregido de la aplicación: en el panel “Inicio”, dentro del grupo “Ayuda en línea”, despliegue
Notas
“Guía de auto-formación” y luego seleccione la opción “WD Aplicación Completa (Corregida)”.
2. Muestre la descripción del proyecto.

Recuerde: para mostrar la descripción del proyecto, en el panel “Proyecto”, en el grupo “Proyecto”, clique
sobre “Descripción.
3. En la pestaña “Avance”, marque la opción “Autorizar el lanzamiento de ‘Informes & Consultas’”.
4. Valide.
Parametrización del análisis
Vamos ahora a abrir el análisis para parametrizar los ficheros y las rúbricas utilizables en el software “Informes &
Consultas”.
 Abra el análisis de su proyecto: clique sobre en los botones de acceso rápido del menú de WINDEV.
Por defecto, todos los ficheros de datos y todas sus rúbricas son visibles y manipulables con el software “Informes
& Consultas”. Si su aplicación contiene informaciones sensibles(contraseñas, …) puede poner estos ficheros de
datos o estas rúbricas invisibles para el software “Informes & Consultas”.
A partir del software “Informes & Consultas”, el usuario no puede añadir, modificar o eliminar
registros (las funciones HAdd, HModify, y HDelete están prohibidas). Tampoco es posible
Notas
crear o volver a crear ficheros de datos (las funciones HCreation y HCreationIfNotFound

también están prohibidas).
 Para definir un fichero invisible para el software “Informes & Consultas”:

1. En el editor de análisis, seleccione el fichero de datos deseado.
2. Muestre la ventana de descripción del fichero (opción “Descripción del fichero de datos” del menú contextual).
3. En la pestaña “Informes & Consultas”, desmarque la opción “Visible para el usuario final, en el software
‘Informes & Consultas’”.
4. Valide.
 Para definir una rúbrica invisible en el software “Informes & Consultas”:

1. En el editor de análisis, seleccione el fichero de datos deseado.
2. Muestre la ventana de descripción del fichero (opción “Descripción de las rúbricas” del menú contextual”).
3. Seleccione en la tabla la rúbrica deseada.

4. En la pestaña “Informes & Consultas”, desmarque la opción “Visible para el usuario final, en el software
‘Informes & Consultas’”.
5. Valide.
 Para tener en cuenta las modificaciones efectuadas en el análisis, es necesario regenerar el análisis (opción
“Generación” en el panel “Análisis”). Una modificación automática de los ficheros de datos está propuesta para
tener en cuenta las modificaciones efectuadas.
Parametrización de los informes
Cuando se crea un informe, es posible especificar si este informe es modificable en el software “Informes &
Consultas”.
 Para poner el informe “INF_TABLA_REQ_BusquedaPedidos” presente en el proyecto “WD Aplicación Compoleta”
modificable para el software “Informes & Consultas”:
1. Abra el informe “INF_TABLA_REQ_BusquedaPedidos” en el editor de informes.
2. Muestre la descripción del informe (opción “Descripción del informe” del menú contextual).
3. En la pestaña “Opciones”, marque “Informe modificable por Informes & Consultas”.
4. Marque:
 La opción “Interface modificable solamente” para que solamente el interface del informe pueda modificarse
con Informes & Consultas.
 La opción “Todo modificable (interface y código)” para que todo el informe sea modificable por Informes &
Consultas.
5. Valide y guarde el informe.

Parametrización de las consultas
Por defecto, una consulta es modificable por el software “Informes & Consultas”.
 Para hacer una consulta de su aplicación modificable para el software “Informes & Consultas”:
1. Abra la consulta en el editor de consultas.
2. Muestre la descripción de la consulta (opción “Descripción de la consulta” del menú contextual del gráfico de
la consulta).
3. Clique en el botón “Avanzado” (presente en las “Acciones”).
4. En la pestaña “Informes & Consultas”, marque “Visible para Informes & Consultas”.
5. Valide y guarde la consulta.
Creación del ejecutable y difusión de la aplicación
La creación y la difusión de una aplicación utilizando el software “Informes & Consultas” se hace igual que para una
aplicación clásica. Puede indicar los parámetros específicos del software “Informes & Consultas” cuando se crea el
procedimiento de instalación.
 Para crear el programa de instalación de su aplicación WD Aplicación Completa:
1. En el panel “Proyecto”, en el grupo “Generación”, clique sobre “Procedimiento de instalación”. Se crea el
asistente de creación. Clique sobre el enlace “Instalación” a la derecha del asistente.
2. Seleccione “Crear el ejecutable ahora”. La creación del ejecutable está realizada.
Si el asistente propone la creación del fichero de ayuda, valide los distintos mensajes.
Notas
3. El asistente de creación de instalación se lanza.

4. Elija una “Instalación Individual”. Avance al paso siguiente.
5. Elija una “Instalación estándar”. Avance al paso siguiente.
6. Valide el directorio de instalación propuesto y avance al paso siguiente.
7. En la pantalla “Ficheros instalados”, seleccione si fuera necesario los ficheros de datos (.fic, .mmo y .ndx) que
hay en el directorio del ejecutable. Para ello, clique sobre “Añadir” y seleccione estos ficheros.
Si la aplicación realizada deber instalarse sobre Windows Vista o superior con el UAC activo, es
necesario configurar la aplicación y su instalación para instalar y utilizar los ficheros de datos en
el directorio de datos de la aplicación. En este caso:
 Cuando se crea el ejecutable, en el paso “Directorio de ficheros de datos” seleccione la
Notas
opción “Directorio de datos de la aplicación”.

 Cuando se crea la instalación, en el paso “Ficheros instalados”, especifique el directorio
de instalación en las propiedades de cada fichero (directorio común de los datos).
8. Clique a la izquierda sobre el enlace “Complementos”.

9. En la pantalla “Módulos complementarios”, verifique que la opción “Integrar la instalación de Informes &
Consultas” está marcada.
10. En la pantalla titulada “Informes & Consultas”:
 Especifique si desea incorporar la instalación de “Informes & Consultas” en su programa de instalación.
En este caso, se buscará el paquete de instalación del software “Informes & Consultas. Por defecto, este
paquete de instalación está en el subdirectorio “Informes y Consultas” del directorio de instalación de
WINDEV.
Atención: Incorporar el software “Informes & Consultas” aumenta el tamaño de su instalación de forma nada
despreciable (alrededor de 250 Mb).

 Especifique si es necesario los directorios correspondientes a los informes y consultas modificados o creados
por el usuario final.
 El directorio de los informes y consultas personales corresponde al directorio de los informesy consultas
visibles solamente por el usuario que los ha creado.
El directorio de informes y consultas compartidos corresponde al directorio de los informes y consultas visibles
para todos los usuarios de la aplicación.
Estos directorios pueden estar modificados cuando se instala la aplicación: basta con marcar la opción
“Autorizar la modificación de estos directorios durante la instalación”.
11. Clique en la opción “Soporte” a la izquierda del asistente.
12. Valide el asistente. El programa de instalación está generado. No cierre la ventana que indica el fin de la
creación de la instalación.
Instalar y utilizar el software “Informes y Consultas”

Instalación de la aplicación
Para probar la instalación y el uso del software “Informes & Consultas”, vamos a instalar la aplicación “WD Aplicación
Completa”.
Siguiendo los pasos del párrafo anterior, ha generado el programa de instalación de esta aplicación. El programa de
instalación se ha creado en el subdirectorio “Install” del proyecto actual.
 En la ventana de fin de creación de la instalación, clique sobre el botón “Probar”. Si ha cerrado esta ventana,
lance directamente el programa “Install.exe” que hay en el directorio del programa de instalación. Se lanzará la
instalación de la aplicación.
 Vamos a seguir los diferentes pasos del programa de instalación de la aplicación “WD Aplicación Completa”.
1. Si utiliza un sistema operativo correspondiente a Windows Vista o superior, se mostrará una ventana
solicitando la autorización para ejecutar este programa. Valide esta ventana.
2. Elija el idioma del programa de instalación y clique sobre “OK”.
3. Se lanza el asistente de instalación. Hay disponibles dos modos de instalación:
 Instalación rápida: La instalación se realiza directamente con los parámetros especificados por el proveedor
de la aplicación
 Instalación personalizada: El asistente pide al usuario los parámetros de instalación de la aplicación.
4. Elija “Instalación personalizada”. El asistente pide el directorio de instalación de la aplicación.
5. Valide el directorio de instalación de la aplicación.
6. La pantalla “Informes & Consultas” permite instalar el software “Informes & Consultas” (solamente si el
programa no está ya instalado en el puesto en curso).

8. La siguiente pantalla permite definir los directorios utilizados para el registro de los informes y las consultas.
9. Avance al paso siguiente y finalice la instalación de la aplicación.

10. La instalación de la aplicación y luego la instalación del software “Informes & Consultas” se lanzan.
Vamos ahora a situarnos en la piel del usuario final de su aplicación (no es evidente, pero ¿porqué no?
 Para probar la aplicación:
1. Lance la aplicación “WD Aplicación Compoleta”.
2. Seleccione la opción “Informes .. Lista de clientes”. El informe aparece en modo “Vista previa de impresión”.

3. En esta pantalla aparecen dos nuevos iconos:
Permite modificar el informe en curso en la vista previa de impresión
Permite crear un nuevo informe.

 Vamos a modificar este informe:
1. Clique sobre el icono .

2. El informe aparecerá en edición en el software “Informes & Consultas”.
3. El usuario puede entonces hacer las modificaciones que necesita:

 En el estilo de las informaciones mostradas (por ejemplo, cambiar el color de un campo).
 En el contenido del informe (por ejemplo, añadir un campo, …). Si el informe está ligado a una consulta,
el usuario puede modificar esta consulta.
Si el informe está ligado a una consulta integrada, la modificación se realiza directamente en el informe.
Si el informe está ligado a una consulta independiente, la consulta también se modifica. La modificación
solamente se tendrá en cuenta en el cuadro de ejecución del informe (si una ventana utiliza también esta
consulta, la modificación no se tendrá en cuenta para la ventana).
 En este ejemplo, vamos a poner la fecha en rojo. Para ello:
1. Seleccione el campo fecha en el inicio del documento.

2. En el panel “Modificación”, dentro del grupo “Edición rápida”, clique sobre el icono “Color” y seleccione el
color rojo.
3. Guarde su informe. Por defecto, el directorio propuesto es el directorio de instalación de su aplicación.
4. Cierre el software “Informes & Consultas”.
5. Seleccione la opción “Informes .. Lista de clientes” en la aplicación. El informe aparecerá en modo “Vista
previa de impresión” y la modificación realizada ya es efectiva.
En este ejemplo, el informe que ha modificado está disponible para usted solo. En el caso de una aplicación de red, el
usuario tiene la posibilidad de poner a disposición de todos los usuarios un informe modificado.
Hemos finalizado nuestro descubrimiento del software “Informes & Consultas”. Para más detalles, consulte la ayuda
en línea (palabra clave: Informes y Consultas).
Conclusión
Toda la fase de desarrollo de nuestra aplicación ha terminado. Las dos próximas lecciones le permitirán descubrir:
 Como transformar su aplicación en una aplicación multi-línea.
 Como integrar su aplicación en el Gestionario de fuentes (GDS).

Lección 3.16. Gestionar el multi-lenguaje
 ¿Qué es una aplicación multi-lenguaje?
 Paso a paso, creación de una aplicación multi-lenguaje.

¿Qué es una aplicación multi-lenguaje?
Una aplicación multi-lenguaje es una aplicación que puede ejecutarse en inglés, francés, alemán o cualquier otra
lengua.
Una misma aplicación puede entonces utilizarse en varios idiomas. Pero, ¿Cómo es posible?
Esto es lo que vamos a ver en esta lección.
Vamos a manipular un proyecto para que pueda ejecutarse en francés o en inglés, según la elección del usuario.
Los principales pasos de una aplicación multilingüe son:
 Elegir los idiomas del proyecto.
 La internacionalización del análisis.
 La internacionalización de los elementos del proyecto (ventanas, informes, campos, …)
 La internalización de los mensajes del código.
 Programación del cambio de idioma en la aplicación.
Vamos a aplicar las distintas etapas al proyecto “WD Aplicación Completa”. Este proyecto, disponible en francés, va a
ser traducido al inglés.
Corregido
despliegue “Guía de auto-formación” y luego seleccione “Aplicación Completa (Corregida)”.
Seleccione los idiomas del proyecto

 La primera operación consiste en elegir los idiomas del proyecto.
1. Muestre la descripción del proyecto: en el panel “Proyecto”, dentro del grupo “Proyecto”, clique sobre
“Descripción”.
2. Clique sobre la pestaña “Idiomas”. Nuestro proyecto gestionará Francés e Inglés.
3. Clique sobre el botón “Añadir”. La ventana de selección de idiomas aparecerá.
4. Clique sobre “Inglés”. Una marca aparecerá a la derecha del idioma.

5. Valide. El idioma “Inglés” aparecerá en la lista de los idiomas del proyecto.

 La pestaña “Lenguas” permite también parametrizar las opciones lingüisticas referidas a los nombres, las
monedas, las fechas, … para el idioma seleccionado. Veamos un ejemplo:
1. Clique sobre el idioma “Inglés”.
2. Seleccione la pestaña “Fecha”.
3. Por defecto, se utilizan las opciones lingüísticas de Windows. Si selecciona la opción “Utilizar los parámetros
siguientes”, se puede definir el formato de fecha utilizado, así como la traducción de los días y los meses
4. Conserve la opción “Utilizar los parámetros definidos en las opciones lingüísticas del sistema operativo”.
En las opciones lingüísticas, se puede escoger el sentido de la escritura del idioma (pestaña
“Varios”, opción “Sentido de la escritura”). Así se puede crear los interfaces con un idioma que
Notas
se escribe de derecha a izquierda.
 Valide. Un mensaje propone sincronizar los distintos elementos del proyecto. Responda “Si”. Todos los elementos
del proyecto abiertos en el editor (ventanas, informes, …) se cerrarán y el o los idiomas suplementarios, se
añadirán a todos los elementos.
Internalización del análisis

Por defecto, un análisis se crea en un idioma y no puede traducirse.
No obstante, algunas informaciones pueden introducirse en varios idiomas (notas de la carpeta, informaciones
compartidas, …).
Si su aplicación utiliza el módulo Informes & Consultas, también es posible traducir los nombre de ficheros y los
nombres de las rúbricas. Esta traducción puede realizarse en la pestaña “Informes & Consultas” (de la descripción de
ficheros o de rúbricas).
Los campos creados a partir de rúbricas del análisis tienen por defecto el texto de la rúbrica especificada en el
análisis. Si se ha especificado un texto en las informaciones compartidas de la rúbrica, este texto se utilizará cuando
se cree el campo.
Durante la carga del idioma del proyecto ligado al análisis, este cambio no se reporta automáticamente en el análisis.
En efecto, un análisis puede estar compartido entre varios proyectos.
 Para gestionar varias lenguas en un análisis:
1. Muestre el editor de análisis.: Clique sobre en los botones de acceso rápido del menú de WINDEV.
2. En la descripción del análisis (opción “Descripción del análisis” del menú contextual), seleccione la pestaña
“Internacional”.
3. La lista de los distintos idiomas gestionados por el análisis se mostrará. El inglés no está gestionado:
 Clique sobre el botón “Añadir”.
 Seleccione “Inglés”.
 Valide la ventana de adición de las lenguas.

4. Valide la ventana de descripción del análisis.
Para tener en cuenta todas las lenguas del proyecto ligado al análisis en curso, también es
Notas
posible clicar en el botón “Sincronizar con el proyecto”.
 Para introducir las informaciones compartidas en los distintos idiomas, examinemos un caso sencillo: la entrada
de texto del campo ligado a la rúbrica “Dirección” del fichero “Cliente”:
1. Seleccione el fichero Cliente.
2. Muestre la descripción de las rúbricas de un fichero de datos (opción “Descripción de las rúbricas” del menú
contextual del fichero).
3. Seleccione la rúbrica “Dirección” y muestre los parámetros del campo enlazado con la rúbrica seleccionada
(informaciones compartidas). Para ello, clique sobre la doble flecha bajo de la pantalla

4. En la zona “Texto”, introduzca el texto para el idioma inglés “Address”.
5. Valide.
La traducción de las informaciones compartidas en el análisis puede hacerse:

 Al mismo tiempo que se crea el análisis.
 En cualquier momento mediante el editor.
Notas
 En cualquier momento con las utilidades WDMSG y WDTRAD, dos utilidades que
permiten extraer, traducir y reintegrar los elementos a traducir.
 Para tener en cuenta las modificaciones realizadas en el análisis, es necesario generar el análisis: en el panel
“Análisis”, dentro del grupo “Análisis”, clique sobre “Generación”.
Internalización de los elementos del proyecto

Todos los elementos del proyecto pueden ser multi-lenguaje: ventanas, informes, ayuda, …
Vamos a modificar algunos elementos de la ventana “WIN_Menu”” para ver los distintos métodos a utilizar.
Vamos así a modificar:
 La imagen del logo utilizada en la ventana WIN_Menu.
 Los textos de los campos de la ventana WIN_Menu.
 Las opciones del menú
 Elmensaje mostrado por el código WLangage cuando se cierra la aplicación.
 Abra la ventana “WIN_Menu” en el editor (doble clic sobre su nombre en el panel “Explorador del proyecto”, por
ejemplo).
 Verificamos a continuación que la vetnana WIN_Menu está bien asociada a los distintos idiomas definidos en el
proyecto:
1. Muestre la descripción de la ventana (opción “Descripción” del menú contextual de la ventana).
2. Seleccione la pestaña “Idioma”: los dos idiomas seleccionados en el proyecto aparecerán.
3. Seleccione la pestaña “General”: es necesario traducir el título de la ventana.
4. Introduzca “Menú” en la zona del inglés.

5. Valide la ventana.
Internalización de una imagen

 Para cambiar la imagen del logo utilizado en la ventana WIN_Menu según el idioma de ejecución:
1. Abra la ventana “WIN_Menu.WDW”.
2. La imagen del logo está contenida en el modelo asociado a la ventana. Se necesitará pues, abrir el modelo de
ventanas asociado:
 Clique sobre el campo “WD Aplicación Completa” y muestre el menú contextual.
 Seleccione la opción “Abrir el modelo”.
 El modelo de ventanas aparecerá, rodeado de un cuadro naranja.

3. Muestre la ventana de descripción del logo:
 Seleccione el campo “WD Aplicación Completa” y muestre el menú contextual.
 Seleccione la opción “Descripción”.
4. En la zona “Imagen”, clique sobre el botón .

5. Aparecerá la ventana de gestión de las imágenes multi-lenguaje. Se puede utilizar una imagen distinta para
cada idioma. Esta funcionalidad será muy útil en el caso de que las imágenes contenga texto.
6. Para nuestro ejemplo, en la zona “Inglés”, seleccione el fichero “header-us.png”.

7. Valide. El texto “<Valores multi-lenguajes” aparecerá desde entonces en la zona “Imagen” de la ventana de
descripción.
9. Guarde el modelo de ventanas ( o [CTRL]+[S]).
10. Actualice las ventanas que utilizan el modelo de ventanas clicando en el icono en la cinta naranja. Valide
la ventana de actualización.
11. Cierre el modelo de ventanas mostrado en el editor.
Internacionalización de los campos.

Un campo puede mostrar numerosas informaciones al usuario:
 Un texto
 Un mensaje de ayuda
 Una imagen, …
Todas estas informaciones deberán traducirse. Estas informaciones son accesibles en las distintas pestañas de la
ventana de descripción del campo.
 Para nuestro ejemplo, vamos a traducir el primer panel del campo Pestaña.
1. Doble clic en el campo Pestaña para mostrar su ventana de descripción.
2. En la pestaña “General” de la ventana de descripción, seleccione la primera pestaña “Lista de productos”.
3. En la parte “Descripción de un panel estático”, se puede:
 Introducir la traducción del texto del panel: “List of products”.
 Definir una imagen específica para el panel pestaña por idioma (como habíamos hecho previamente).
 Definir un globo de ayuda por idioma.
4. Cierre la ventana de descripción del campo.
Internacionalización de un mensaje de programación
Todos los mensajes de su programa pueden igualmente estar mostrados en distintos idiomas. En nuestro ejemplo, la
selección del menú “Cerrar” muestra el mensaje “Cerrar la aplicación ?”. Vamos a traducir este mensaje.
 Para traducir el mensaje de la opción de menú:
1. Muestre el código de la opción de menú:
 En el editor despliegue el menú.
 Seleccione la opción “Cerrar”.
 Muestre el menú contextual (clic derecho) y selecciones la opción “Código”.

2. Para traducir este tipo de mensaje, posicione el cursor en la cadena “Cerrar la aplicación ?” y utilice la
combinación de teclas [CTRL]+[T]. También se puede, en el panel “Código”, dentro del grupo “Idiomas”,
desplegar “Traducir cadenas” y seleccionar “Traducción de mensajes”.
3. Aparecerá la siguiente información:
4. Esta ventana permite introducir todos los mensajes de su programa en todos los idiomas del proyecto.
5. En la zona “Inglés”, introduzca “Exit from the application?” y valide.
6. El icono así como una cifra aparecerán en el editor de código.
Internacionalización de los menús

La traducción de las opciones de un menú puede realizarse como para los otros campos mediante la ventana de
descripción de la opción, o directamente desde el editor de páginas.
 Para traducir el menú de la ventana “WIN_Menu”:
1. En el panel “Mostrar”, dentro del grupo “Opciones”, despliegue “Lengua mostrada” y seleccione el idioma a
visualizar en el editor (inglés en nuestro caso).
2. Se muestran las opciones de menú en la lengua seleccionada. Si no hay ninguna traducción correspondiente a
la lengua seleccionada, las opciones del menú se muestran en francés.

3. Despliegue la opción “Menu”.
4. Seleccione la opción “Enviar un email”.
5. Pulse la tecla [ESPACE] del teclado: el texto pasa a edición.
6. Introduzca el texto en inglés: “Send and email” y valide.
7. Vuelva a mostrar la lengua mostrada en francés: en el panel “Mostrar”, dentro del grupo “Opciones”,
despliegue “Lengua mostrada” y seleccione “francés”.
Las herramientas de traducción

Acabamos de traducir manualmente algunos elementos de nuestra aplicación.
Para traducir estas informaciones, WINDEV pone a su disposición varios medios:
 Una traducción directa de los mensajes en los distintos editores. Esta traducción puede eventualmente utilizar
una herramienta de traducción, Google Traducción (sujeto a la posesión de una licencia), …
 Una traducción “industrializada” realizada mediante una utilidad externa (WDMSG y WDTRAD).
Entrada directa de las traducciones

Las traducciones son directamente introducidas en el interface del producto. Por ejemplo, el texto del botón “Nuevo”,
se convierte en “New” en inglés. Es suficiente con abrir la ventana de descripción del campo e introducir en el
lenguaje deseado la traducción correspondiente.
Si dispone de un software de traducción o de un sitio de traducción, puede configurar WINDEV para utilizar este
software:
1. En el panel “Inicio”, dentro del grupo “Entorno”, despliegue “Opciones” y seleccione “Opciones generales de
WINDEV”.
2. Muestre la pestaña “Traducción”.
3. Especifique:
 Si los parámetros regionales deberán estar automáticamente activados según el idioma en curso de
introducción. En este caso, si el idioma necesita un alfabeto específico, este alfabeto se seleccionará
automáticamente.
 El software o el sitio a utilizar para la traducción. Es posible utilizar WDDixio, diccionario de traducción
proporcionado con WDMSG (ver página siguiente), un software o un sitio de traducción específico, o Google
Traducción (para más detalles, consulte la ayuda en línea).
 Los idiomas gestionados.
4. Cuando se han definido los parámetros de traducción, se puede utilizar el botón presente en las
distintas ventanas de descripción de los elementos del proyecto: este botón permitirá utilizar el software
definido para la traducción.
Traducción con WDMSG y WDTRAD

Existe también una herramienta opcional WDMSG (que no se proporciona en estándar con WINDEV) que permite:
 Extraer todos los mensajes de un proyecto (texto de los campos, mensajes de código, títulos de las ventanas, …)
para traducirlos.
 Reintegrar los mensajes traducidos.
Los mensajes a traducir se extraen:
 En un formato texto que puede configurarse para poder ser utilizado por la mayoría de software de traducción.
 Con formato HFSQL.
WDMSG también se suministra con una herramienta de ayuda a la traducción WDTRAD. WDTRAD permite introducir
sencillamente todas las traducciones de las informaciones multi-lenguaje de un proyecto.
Para obtener más informaciones sobre WDMSG y WDTRAD, contacte con el servicio comercial de PC SFOFT.
Otros elementos para traducir: los mensajes de framework

Numerosas informaciones y mensajes están presentes en el framework WINDEV. Por ejemplo, los nombres de los
días y de los meses utilizados por las funciones de gestión de las fechas provenientes del framework WINDEV. Para
traducir una o más librerías de este framework, es necesario utilizar WDINT (No se proporciona en estándar con
WINDEV).
Este software permite obtener un fichero de extensión WDM. Para utilizar este fichero en su aplicación:
 Puede utilizar la función LoadError.
 Puede integrar el fichero a la descripción del proyecto en la pestaña “Idiomas”. Hay que seleccionar el idioma
deseado y seleccionar la pestaña “Varios”.
Para obtener más información sobre WDINT, contacte con el servicio comercial de PC SOFT.
Programación del cambio de lenguaje

Por defecto, el proyecto se ejecuta en el idioma de ejecución definido por el proyecto, en la pestaña “Lenguajes” de la
descripción del proyecto (opción “Descripción”, en la pestaña “Proyecto”).
En una aplicación, la selección del idioma puede efectuarse mediante una opción de menú. La función Nation
utilizada en el tratamiento asociado a la opción del menú permite cambiar el idioma de la aplicación que se está
ejecutando.
Añadir una opción de menú

 Para añadir una opción de menú:
1. Abra si hiciera falta la ventana “WIN_Menu” en el editor (doble clic sobre su nombre en el explorador del
proyecto).
2. Clique en la opción “Menú” de la ventana. Se desplegará el menú.
3. Seleccione la opción “Enviar un email”.
4. Muestre el menú contextual (clic derecho). Seleccione la opción “Añadir después”. Introduzca el texto
“Idiomas” y valide.
5. Seleccione la opción “Idiomas” que acaba de crear.
6. Muestre el menú contextual (clic derecho) y seleccione la opción “Transformar para desplegar un sub-menú”.
7. Introduzca el texto de la primera sub-opción “Francés”.
8. Pulse sobre la tecla [ENTER] dos veces e introduzca el texto de la segunda opción “Inglés”.
Ahora vamos a introducir el código WLangage necesario para la carga del idioma.
Programación
 Para introducir el código de gestión de idiomas:
1. Seleccione la opción “Menú .. Lenguas .. Francés” en el editor.
2. Muestre el menú contextual (clic derecho). Seleccione la opción “Código”.
3. Introduzca el siguiente código en el código servidor de la opción de menú:
Nation (nationFrench)
5. Seleccione la opción “Menú .. Lenguas .. Inglés” en el editor.
6. Muestre el menú contextual (clic derecho). Seleccione la opción “Código”.
Nation(nationEnglish)
La función Nation permite cambiar el idioma de ejecución de la aplicación. Las constantes pasadas como
parámetro permite especificar el idioma a utilizar.
El cambio de idioma efectuado por la función Nation es efectivo de forma inmediata.
Prueba del proyecto
Hemos traducido algunos elementos de la aplicación y ahora vamos a probar el cambio del idioma.
 Para probar la aplicación:
1. Lance la prueba del proyecto ( en los botones de acceso rápido). La ventana se mostrará en modo de
prueba en francés.
2. Seleccione la opción “Idiomas .. Inglés”.
3. Los distintos elementos que hemos traducido aparecerán en inglés:

4. Finalice la prueba y regrese al editor.

Lección 3.17. GDS
 Presentación
 El gestor de fuentes
 Uso del gestor de fuentes

Introducción
Un desarrollo informático importante necesita la participación de varios desarrolladores. Estos desarrolladores deben
trabajar en un proyecto WINDEV único, y compartir los distintos recursos (ventanas, clases, …) manipulados.
WINDEV propone en estándar un gestor de fuentes llamado “GDS” que permite compartir los fuentes de distintos
proyectos entre los desarrolladores y conocer el historial completo de las modificaciones realizadas (en el código,
interfaces, …).
GDS (Gestor de fuentes)

Principio del GDS
El gestor de fuentes permite almacenar y compartir proyectos y todos sus elementos.
El principio es el siguiente:
 Una versión de referencia de cada uno de sus proyectos está presente en un servidor. El conjunto de estas
versiones se llama “Base de fuentes”.
 Cada desarrollador tiene en su puesto una copia local de los distintos proyectos sobre los que ha trabajado.
 Cuando un desarrollador quiere modificar un elemento de un proyecto (una ventana, un informe, una
consulta, …), le indica al GDS que se adueñará temporalmente de este elemento. Para ello, el desarrollador
extraerá este elemento de la base de fuentes.
 Este desarrollador obtiene entonces los derechos exclusivos sobre este elemento: puede hacer todas las
modificaciones deseadas sobre este elemento.
 Los restantes desarrolladores continúan con la copia de la versión de referencia de este elemento (existente
en la base de fuentes).
 Cuando el desarrollador finaliza sus modificaciones, devuelve el elemento extraído a la base de fuentes.
 Los restantes desarrolladores son avisados de esta devolución. Pueden entonces actualizar su copia local.

El GDS gestiona entonces el trabajo colaborativo y permite conocer el historial de todas las modificaciones realizadas.
El GDS permite también administrar y reglamentar los elementos compartidos entre varios proyectos.
Creación de la base de fuentes

Para compartir un proyecto con el gestor de fuentes, se necesita crear una base de fuentes. Esta base de fuentes
deberá crearse una sola vez en un puesto servidor.
Esta base de fuentes puede crearse en varios momentos:
 Cuando se instala WINDEV
 Cuando se crea un proyecto utilizando el GDS
 Cuando se importa un proyecto en el GDS
 Cuando se desee, directamente desde WINDEV o desde el administrador de GDS.
La base de fuentes puede instalarse en modo:
 HFSQL Clásico
 HFSQL Cliente/Servidor
 Cloud. El modo Cloud permite tener acceso a los fuentes de los proyectos sin importar desde donde ni
cuándo. Para más detalles, consulte el sitio www.pcscloud.net.
 En la siguiente lección, crearemos nuestra base de fuentes cuando se importe un proyecto en el GDS.
Es aconsejable hacer regularmente copias de seguridad de la base de fuentes del GDS. Para ello,
hay que conectarse como administrador en la herramienta de administración del GDS y
Notas
seleccionar la opción “Herramientas .. Administración .. Copia completa de la base”.
Integración de un proyecto en el GDS

Añadir el proyecto en el GDS
Para utilizar un proyecto existente con el gestor de fuentes, hay que integrar el proyecto en la base de fuentes del
GDS.

Si no ha realizado las manipulaciones de las lecciones precedentes, puede seguir esta lección
Corregido
abriendo un proyecto corregido: En el panel “Inicio”, en el grupo “Ayuda en línea”, despliegue

“Guía de auto-formación” y luego seleccione “Aplicación completa (Corregida)”.
 Vamos a integrar el proyecto WD Aplicación Completa.WDP” en la base de fuentes del GDS:

1. En el panel “GDS”, dentro del grupo “Proyecto”, clique sobre “Añadir el proyecto”. Se lanza el asistente para
añadir el proyecto dentro del GDS se lanzará:
Aún no habíamos creado la base de fuentes. Vamos pues a crear una.

Observación: Vamos a crear una base de fuentes “local” (en el puesto de desarrollo). El funcionamiento será
similar para una base de fuentes en red.
2. Clique sobre el botón “Crear una base”.
3. La pantalla que permite la creación de la base se muestra:

La base de fuentes puede estar en formato HFSQL clásico (local o red) o en formato HFSQL Cliente/Servidor.
Vamos a crear una base de fuentes en formato HFSQL Clásico.
El uso de una base de fuentes con formato HFSQL Cliente/Servidor permite utilizar esta base de
Notas
fuentes a la distancia.
4. Seleccione la opción “Creación de una base en modo compartido en red” e indique el directorio de esta base
de fuentes (“C:\Mis Proyectos\GDS Base de fuentes local” por ejemplo).
5. Valide la creación de la base de fuentes (botón “Crear la base”).
6. La base de fuentes se crea ahora. Vamos a poder integrar nuestro proyecto en esta base de fuentes.
8. El asistente nos propone situar el proyecto en el sub-directorio “Proyectos WinDev” de la base de fuentes.
Vamos a aceptar este emplazamiento. Avance al paso siguiente.

9. El asistente pide seleccionar los distintos elementos del proyecto a añadir en la base de fuentes.
Queremos que todos los elementos del proyecto se añadan. Avance al paso siguiente.

10. El asistente nos pide seleccionar las distintas dependencias del proyecto a añadir en la base de fuentes. Estas
dependencias corresponden a todos los elementos externos necesarios para el proyecto (imágenes, hojas de
estilos, …)
Queremos que todas las dependencias del proyecto se añadan. Avance al paso siguiente.
11. Valide la integración del proyecto en GDS. Nuestro proyecto y todos sus elementos estarán desde entonces
añadidos a nuestra base de fuentes.
Aparece una ventana de ayuda en la barra de herramientas de utilización del GDS. Lea y valide esta ventana.
Compartición de los elementos del proyecto
Con la integración en el GDS de proyectos que comparten los mismos recursos (el mismo
análisis, las mismas ventanas, …) los elementos concernientes pueden ser compartidos entre los
Notas
distintos proyectos. Así, el mismo elementos solo se integra una vez en el GDS y las
modificaciones se reportan automáticamente en los otros proyectos.
Apertura del proyecto desde el GDS

En nuestro ejemplo, el proyecto está integrado en el GDS y puede manipularlo directamente.
En un caso real, para que otros desarrolladores trabajen sobre un proyecto existente en el gestor de
fuentes, deberán recuperar, en local, una copia de este proyecto.
Para ello, las manipulaciones a efectuar son las siguientes:
1. Abrir el proyecto desde el gestor de fuentes: En el panel “Inicio”, dentro del grupo “General”, desplegar
“Abrir” y seleccionar “Abrir un proyecto desde el GDS”.
2. Indicar los parámetros de localización de la base de fuentes y validar (este paso solo será necesario si el
proyecto en curso en el editor no pertenece al GDS):
3. En la pantalla que se muestra, indique si es necesaria la conexión y el directorio local:

Observación: Si tiene ya abierto el proyecto desde el GDS, el GDS le propone abrir el proyecto normalmente o
borrar el contenido (para recuperar el proyecto completo).
Esta operación deberá efectuarse solamente una vez para cada desarrollador que utilice el proyecto.
El desarrollador que ha añadido el proyecto en el gestor de fuentes (en este caso es usted) no tiene que efectuar
ninguna manipulación.
Las próximas aperturas de un proyecto gestionado por el GDS son idénticas a las aperturas de
un proyecto no gestionado por el GDS: hay que abrir el proyecto (fichero “.WWP”)
Notas
correspondiente a la copia local.
Configuración del GDS

Antes de empezar a trabajar sobre los elementos del proyecto presentes en el GDS, es importante configurar el modo
de extracción de los elementos del proyecto.
Cuando se trabaja sobre los elementos de un proyecto presente en el GDS, es necesario extraer el elemento de la
base de fuentes antes de comenzar a modificarlo, y luego reintegrarlo una vez que se han efectuado las
modificaciones. El elemento modificado queda así disponible para todos los usuarios del GDS.
WINDEV propone dos modos de extracción de los elementos del proyecto:
 El modo clásico: Si muestra un elemento del GDS no extraído, un panel indica que este elemento deberá
extraerse para poder modificarse. Puede extraerlo inmediatamente (botón de extracción presente en el
panel).
 El modo automático: Si intenta modificar un elemento del GDS que no ha sido extraído, GDS propone
automáticamente extraer el elemento. Luego de la validación de la extracción, el elemento podrá modificarse.
Observación: este modo es desaconsejable cuando se utiliza una conexión a Internet lenta.
En este curso, vamos a utilizar la extracción automática.
 Para verificar que la extración automática está bien desactivada, en el panel “Inicio”, en el grupo “Entorno”,
despliegue “Opciones” y seleccione la opción “Opciones generales de WINDEV”. En la pestaña “General”, marque
si hiciera falta la opción “Extracción de los elementos a la primera modificación”.

Manipulación del proyecto mediante el GDS
Vamos ahora a empezar a trabajar con el GDS en condiciones reales realizando las siguientes manipulaciones:
 Modificar un parámetro del proyecto.
 Modificar una ventana del proyecto.
Modificación de un parámetro del proyecto
 Vamos a modificar el proyecto pidiendo que muestre la plantilla en las ventanas sistema:
1. Muestre la descripción del proyecto: En el panel “Proyecto”, dentro del grupo “Proyecto”, clique sobre
“Descripción”.
2. Clique sobre la pestaña “Estilo”.
3. Marque la opción “Aplicar el tema de la plantilla en las ventanas sistema”.
4. Valide la ventana de descripción del proyecto.
 Aparecen varias ventanas del GDS:

1. Primeramente se muestra la ventana de extracción automática del proyecto. En efecto, modificaremos una
característica del proyecto, y es necesario extraer el proyecto.
2. Valide esta ventana.

3. WINDEV propone recompilar el proyecto. Acepte la recompilación completa del proyecto.
4. Aparecerá una nueva ventana. Esta ventana permite añadir elementos y sus dependencias en el proyecto
presente en la base del GDS. En efecto, la opción que hemos seleccionado añade varias páginas en el
proyecto:

6. Una nueva ventana para añadir ventanas aparecerá: valide de nuevo
7. Una ventana de reintegración del proyecto aparecerá. En efecto, hay modificaciones del proyecto que han
sido modificadas y el proyecto se reintegra.

Modificar una ventana del proyecto.
Vamos ahora a modificar la ventana “WIN_Ficha_del_Producto”: El clic sobre la imagen deberá permitir modificar la
imagen (igual que el botón “Modificar”).
La modificación de un elemento extraido (IHM, Código, …) se realiza como en un proyecto no gestionado por el GDS.
No obstante, todas las modificaciones realizadas en un elemento extraído, no son visibles para los otros
desarrolladores.
Si otro desarrollador ejecuta el elemento extraído, el elemento que se encuentra actualmente en la base de fuentes
es el que se utilizará.
Así es posible hacer evolucionar una aplicación guardando siempre una versión estable en la base de fuentes.
 Para modificar la ventana “WIN_Ficha_del_producto”:
1. Seleccione la ventana “WIN_Ficha_del_producto” en el explorador del proyecto y doble clic sobre ele
elemento para abrirlo en el editor de ventanas.
2. La extracción automática se activa a la primera modificación. Basta con desplazar un campo para extraer el
elemento.También puede utilizar el icono “Extraer” que está en la cinta ( ).
3. Aparecerá la ventana de extracción:

4. El GDS propone tres modos de extracción:
 Exclusivo (modo aconsejado): Nadie podrá extraer el elemento hasta su reintegración. El elemento solo
podrá extraerse para pruebas.
 Para pruebas: El elemento podrá modificarse, pero las modificaciones no podrán ser reintegradas.
 Múltiple: El elemento podrá ser extraído por otros usuarios. En este caso, cuando se reintegre, podrán
visualizarse las diferencias entre las diferentes versiones del elemento. Este modo se reserva para casos
de utilizaciones específicas a desarrolladores avanzados.
5. Vamos a extraer la ventana en modo exclusivo. Conserve la opción “Exclusivo” marcada.
6. Introduzca un comentario (“Modificación de la imagen”, por ejemplo). Este comentario será útil para los
restantes desarrolladores.
7. Valide la extracción.La ventana está extraída.
8. Muestre la ventana de descripción del campo Imagen (opción “Descripción” del menú contextual).
9. En la pestaña “IHM”, modifique el cursor utilizado: seleccione el cursor “Main Sistema”.
11. Muestre el código del campo Imagen: Seleccione el campo Imagen y utilice por ejemplo la tecla [F2]
12. Introduzca el siguiente código en el tratamiento “Clic sobre …”:
// Ejecuta el código clic del botón que modifica la imagen
ExecuteProcess (BTN_Modificar, trtClick)
13. Guarde la ventana de código
14. Guarde su ventana ([CTRL]+[S]).
 Pruebe sus modificaciones.

2. Seleccione un producto y clique sobre “Modificar”.
3. En la ficha que aparece, clique sobre la imagen del producto: el selector de ficheros se abre para modificar la
imagen del producto. Este es el funcionamiento esperado.
4. Cierre la ventana de la prueba.
Reintegración del elemento extraído
Ahora que las modificaciones se han realizado y se han probado, vamos a reintegrar la ventana en la base de fuentes.
Sus modificaciones serán entonces accesibles para los restantes desarrolladores.
 En el panel “GDS”, en el grupo “Elemento en curso”, clique sobre el botón “Reintegrar”. Se muestra la siguiente
pantalla:
Esta pantalla permite:

 Conocer las modificaciones efectuadas comparando el elemento de la base de fuentes con el elemento
extraído (botón “Mis Modificaciones”).

Fusión de código
Puede comparar un elemento con una de sus versiones anteriores. Entonces se
Notas
puede comparar el código para recuperar un código “perdido” o eliminado por error
por otro desarrollador, por ejemplo.
 Acceder al historial del elemento en la base de fuentes (botón “Propiedades”).

 Introducir un comentario sobre las modificaciones realizadas. Por defecto, WINDEV propone introducir los
comentarios durante la extracción.
 Enviar un mensaje a los otros desarrolladores.
 Reintegrar las modificaciones efectuadas en el elemento, pudiendo conservar el elemento extraído(opción
“Guardar el elemento extraído”).
Si utiliza los Centros de Control, también puede terminar la tarea en curso con la reintegración
del elemento en el Gestor de fuentes. Esta funcionalidad es especialmente útil para asegurar el
Notas
seguimiento de las tareas, la corrección de los bugs, …
1. Valide la reintegración.
2. La página aparecerá entonces en el editor, con la cinta naranja indicando que el elemento no está extraído.
Sincronización del proyecto
Varias opciones permiten configurar un proyecto manipulado con el GDS. Estas opciones están reagrupadas en la
pestaña “GDS” de la descripción del proyecto (mostrado con un clic sobre “Descripción” en la pestaña “Proyecto”).
Estas opciones son las siguientes:

 Proponer la recuperación de la última versión de los elementos a la apertura del proyecto.
Esta opción permite cuando se abre un proyecto presente en el GDS, proponer la recuperación de la última
versión de los distintos elementos del proyecto.
 Proponer la reintegración de los elementos al cierre del proyecto.
Esta opción permite mostrar al cierre del proyecto la lista de todos los elementos extraídos actualmente, para
reintegrar algunos o todos estos elementos. Por defecto, al cierre del proyecto, no se reintegran los
elementos extraídos.
 Extraer/Reintegrar automáticamente el proyecto.
Esta opción permite extraer o reintegrar automáticamente el proyecto cuando se manipula un elemento.
Esta opción está seleccionada por defecto.
Modo desconectado (o nómada)
El GDS permite trabajar muy fácilmente en modo desconectado o nómada.

Este modo permite por ejemplo a un desarrollador que utiliza un portátil continuar trabajando sobre un proyecto
existente en la base de fuentes incluso estando desconectado.
El principio es simple:
 Antes de la desconexión, en el panel “GDS”, dentro del grupo “Otras acciones”, despliegue “Trabajo a
distancia” y seleccione la opción “Desconectarse para una utilización nómada”.
 Al volver a conectarse, en el panel “GDS”, dentro del grupo “Otras acciones”, despliegue “Trabajo a distancia”
y seleccione la opción “Reconectarse y sincronizar”. Bastará entonces con reintegrar los elementos
modificados.
En modo nómada, se ofrecen dos soluciones relativas a la extracción de los elementos:
 No realizar ninguna extracción de elementos del GDS. De esta forma, durante el período nómada, otros
desarrolladores podrán trabajar sobre el o los mismos elementos. A la vuelta y a la reconexión al GDS, será
necesario realizar las fusiones entre las modificaciones realizadas y las efectuadas por otros desarrolladores.
 Hacer una extracción exclusiva sobre el o los elementos a modificar. Se reserva así el elemento durante todo
el período nómada.
Administrador del GDS
El administrador del GDS permite manipular directamente los distintos proyectos incluso dentro del gestor de fuentes.
Por ejemplo, puede:
 Gestionar las bases de fuentes (creación, conexión a una base de fuentes).
 Gestionar los ficheros y los directorios existentes en un proyecto de la base de fuentes (añadir, eliminar,
renombrar, … los ficheros y los directorios).
 Gestionar los distintos ficheros de la base de fuentes (extracción, reintegración, compartición, …).
 Lanzar algunas herramientas (opciones, mantenimientos, …).
 Visualizar el historial de un elemento.
 Visualizar la situación de los elementos.
 Realizar copias de seguridad.
 Conceder derechos a los distintos usuarios del GDS.
 Listar los proyectos en los que participa, para poder disociarse (si lo desea).
 Lance el administrador del GDS: en el panel “GDS”, dentro del grupo “Base GDS”, clique sobre el botón
“Gestionar”. Todos los elementos del proyecto se listarán en el administrador.
Para más información sobre el GDS, consulte la ayuda en línea de WINDEV (palabra clave: “GDS”).
Desconexión del GDS
En el seguimiento de este curso, vamos nuevamente a manipular la aplicación “WD Aplicación Completa”. Para
simplificar las manipulaciones, le aconsejamos desconectarse del GDS.
1. Muestre la ventana de descripción del proyecto: en el panel “Proyecto”, dentro del grupo “Proyecto”, clique
sobre “Descripción”.
2. En la pestaña “GDS”, seleccione la opción “Sin Groupware de desarrollador ni GDS”.
3. Valide la ventana de descripción del proyecto.
Conclusión
Hemos visto todas las principales fases del desarrollo de una aplicación.
WINDEV propone igualmente distintas herramientas para optimizar sus aplicaciones. Para más detalles, consulte la
lección “Auditorías del proyecto”.

CAPÍTULO 4
Administrar una
base HFSQL
Cliente/Servidor
Capítulo 4 – Administrar una base HFSQL Cliente/Servidor |283

Lección 4.1. Introducción
 Principio de Cliente/Servidor
 ¿Porqué pasar una aplicación en HFSQL Cliente/Servidor?

Presentación
WINDEV permite crear aplicaciones accediendo a las bases de datos HFSQL Cliente/Servidor.
Una base de datos en modo Cliente/Servidor permite dejar la o las bases de datos en un puesto servidor.
Este modo de funcionamiento:
 Aumenta la seguridad de sus datos.
 Permite gestionar más fácilmente el modo multi-usuario.
 Facilita el mantenimiento, ….
WNDEV permite:
 Crear un sitio utilizando una base de datos HFSQL Cliente/Servidor
 Modificar un sitio que utiliza una base HFSQL Clásico para que utilice una base de datos HFSQL Cliente/Servidor.
¿Para qué pasar un sitio a modo HFSQL Cliente/Servidor?

Las principales ventajas de un sitio en modo HFSQL Cliente/Servidor con respecto a un sitio en modo HFSQL Clásico
son las siguientes:
 El uso de HFSQL es más seguro (utiliza un login, una contraseña y definiciones de derechos a los usuarios).
 No hay gestión de directorios: todos los ficheros de la base de datos están agrupados en el mismo lugar.
 Los clientes finales no ven los ficheros en su explorador y no pueden acceder a ellos directamente.
 Las bases de datos en modo Cliente/Servidor pueden utilizarse para una conexión Internet.
 Una gestión del modo multi-usuario nativo: las realizaciones en modo multi-usuario son optimizadas.

Lección 4.2. Establecimiento de una base de
datos Cliente/Servidor
 Instalación de un servidor HFSQL local
 Creación de una aplicación utilizando una base de datos HFSQL Cliente/Servidor
 Adaptación de una aplicación para gestionar una base de datos HFSQL Cliente/Servidor
 Funcionalidades disponibles en modo Cliente/Servidor
Tiempo estimado: 10 min.

Presentación
En esta lección, vamos a efectuar todas las operaciones necesarias al desarrollo y al despliegue de una aplicación
utilizando una base de datos HFSQL Cliente/Servidor.
Instalación de un servidor HFSQL local

La primera operación a realizar antes de empezar a desarrollar consiste en instalar un servidor HFSQL.
En el puesto de desarrollo, este servidor puede instalarse en local (es lo que vamos a hacer). En el despliegue, este
servidor puede instalarse en un puesto específico.
El programa de instalación del servidor HFSQL está disponible en el CD de WINDEV. Si no tiene este CD, la instalación
del servidor HFSQL está también disponible en el sitio de PC SOFT (www.pcsoft.fr).
Para instalar el servidor HFSQL en local:
1. Lance el programa de instalación de WINDEV.
2. Elija la opción “Instalación del servidor HFSQL C/S”.
3. Seleccione a continuación la opción “Instalar un servidor HFSQL Cliente/Servidor”.
4. Acepte la licencia.
5. Elija la plataforma (opción “Para Windows sobre esta máquina”).
6. Si ya tiene servidores HFSQL instalados en el puesto actual, elija la opción “Instalar un nuevo servidor”.
7. Seleccione el directorio de instalación e indique el nombre del servidor y el puerto. Por defecto, el puerto
utilizado es 4900.
Piense en abrir este puerto en el firewall para conectarse al servidor HFSQL desde otra máquina.
Notas
8. Instale el Centro de Control HFSQL si no existe o no es accesible desde su sitio.

Atención!
El Centro de Control HFSQL es necesario para la gestión de la base HFSQL Cliente/Servidor.
9. La instalación ya se ha realizado. Por defecto, para conectarse al servidor en modo administrador, hay que
utilizar “admin” sin contraseña.
Por razones evidentes de seguridad, piense en cambiar la contraseña del administrador.

Notas
Creación de unaaplicación utilizando una base de datos HFSQL

Cliente/Servidor
La creación de una aplicación WINDEV que utiliza una base de datos Cliente/Servidor se realiza muy sencillamente. Es
necesario:
1. Crear el proyecto que pide crear una nueva base de datos.
2. Crear el análisis especificando que las bases de datos utilizadas por el proyecto serán de tipo “HFSQL
Cliente/Servidor”.
3. Indicar las características de la conexión al servidor HFSQL Cliente/Servidor a utilizar.
4. Cuando se cree un fichero en el análisis, indique que este fichero es en modo Cliente/Servidor y especifique la
conexión utilizada.
Puede también describir la conexión al servidor por programación. Para más detalles, consulte la
Notas
ayuda en línea: “HDescribeConnection”
Adaptación de un sitio para utilizar una base de datos HFSQL

Cliente/Servidor
Presentación
El paso de una base de datos HFSQL Clásico a modo Cliente/Servidor es la operación más corriente.
WINDEV propone varias soluciones para realizar este paso:
 Realizar esta adaptación en el editor de análisis.
 Realizar esta adaptación desde el Centro de Control HFSQL.
Para comprender mejor las distintas fases, vamos a pasar a modo Cliente/Servidor la aplicación que hemos realizado
en el capítulo 3 de este libro, utilizando el primer método, el editor de análisis.
Adaptación del ejemplo
Si no ha realizado las manipulaciones de las lecciones precedentes, puede seguir esta lección
Corregido
abriendo un proyecto corregido: En el panel “Inicio”, en el grupo “Ayuda en línea”, despliegue

“Guía de auto-formación” y luego seleccione “Aplicación completa (Corregida)”.
 Para adaptar el proyecto:

1. Abra si hiciera falta el proyecto “WD Aplicación Completa”.
2. En el explorador del proyecto, seleccione si fuera necesario, la configuración del proyecto “Ejecutable
Windows 32 bits”.
3. Cargue el análisis de su proyecto en el editor de análisis: Clique sobre en los botones de acceso rápido. Se
mostrará el editor de análisis.
4. En el panel “Análisis”, en el grupo “Conexión”, clique sobre “Nueva conexión”. Se abrirá un asistente que
permitirá la creación de una conexión.
5. Seleccione el tipo de conexión a crear “HFSQL Cliente/Servidor”.
6. Avance al paso siguiente

7. Indique en los siguientes planos:

 El nombre del servidor (nombre de su máquina por ejemplo) y el número de puerto. Avance a la pantalla
siguiente.
 El nombre del usuario y su contraseña (deje estas informaciones vacías para utilizar el administrador.
Pase a la pantalla siguiente.
 El nombre de la base de datos (“WD Aplicación Completa” en nuestro ejemplo). Pase a la pantalla
siguiente.
8. Introduzca el nombre de la conexión (conserve el nombre propuesto).
9. Avance a la etapa siguiente y valide. La conexión a la base de datos se creará automáticamente.
El asistente propone asociar los distintos ficheros de datos existentes en el análisis a la conexión que acaba
de crearse.
10. Clique sobre “Si”.

11. En la pantalla siguiente, seleccione todos los ficheros propuestos:

Avance a la etapa siguiente.
12. El asistente propone a continuación copiar los ficheros de datos en el servidor. Valide (opción “Copiar ahora”).
13. Seleccione los ficheros de datos del análisis a copiar en el servidor: en nuestro caso son todos los ficheros de
datos del directorio EXE.
14. Avance a la etapa siguiente y valide.

15. Los ficheros de datos del análisis se transforman automáticamente en ficheros de datos HFSQL
Cliente/Servidor y asociados a la conexión elegida.

16. Genere el análisis: En el panel “Análisis”, en el grupo “Análisis”, clique sobre “Generación”. Los ficheros de
datos se modificarán automáticamente. Si todos los ficheros de datos están actualizados, puede anular la
modificación automática de los ficheros de datos.
Paso a modo Cliente/Servidor: algunos consejos

 Verifique el código de su proyecto: en modo HFSQL Cliente/Servidor, las instrucciones como
HSubstDir, … son inútiles.
 Según los parámetros indicados durante la creación de la conexión, es posible modificar la
Notas
conexión definida en el análisis gracias a las funciones HOpenConnection y

HChangeConnection.
 La función HOpenConnection permite siempre cambiar a modo HFSQL Clásico: Hay que
indicarle el camino del directorio que contiene los ficheros de datos HFSQL Clásico.
17. Ya ha adaptado el proyecto de desarrollo. Puede ser necesario también adaptar la aplicación desplegada (por
ejemplo si la aplicación desplegada utiliza ficheros HFSQL Clásico). Esta operación se parametriza durante la
creación del programa de instalación de la aplicación.
Funcionalidades disponibles en modo HFSQL Cliente/Servidor

HFSQL Cliente/Servidor propone numerosas funcionalidades:
 Transacciones
 Diarios
 Procedimientos almacenados
 Triggers
 Modificación automática de los datos en caliente
 Reindexación en caliente
 Copias de seguridad planificadas
 Copias de seguridad incrementales
 Replicación multi-sitios.
No vamos a detallar aquí estas funcionalidades (algunas ya se abordaron en este curso en modo HFSQL Clásico). Le
aconsejamos que consulte la ayuda en línea para más detalles sobre estos sujetos.

Lección 4.3. Administrar una base de datos
Cliente/Servidor
 El Centro de Control HFSQL.
 Crear un usuario en el Centro de Control HFSQL.
 Guardar la base de datos.

Presentación
Ahora que sabemos crear/adaptar una adaptación para que funcione en modo HFSQL Cliente/Servidor, vamos a ver
como administrar la base de datos asociada.
En efecto, una base de datos Cliente/Servidor necesita:
 Una configuración específica de los puestos (instalación de un servidor HFSQL, …).
 Una administración realizada por el Centro de Control HFSQL.
Configuración de los puestos

Para utilizar una base HFSQL Cliente/Servidor, es necesario instalar un servidor HFSQL en el puesto servidor. Es
posible utilizar varios servidores HFSQL en el mismo sitio, utilizando puertos distintos.En cada servidor pueden estar
instaladas una o varias bases de datos.
Por ejemplo, se pueden instalar en el mismo puesto un servidor HFSQL de pruebas, con una base de datos de
pruebas y un servidor HFSQL de producción, utilizando un puerto distinto.
El Centro de Control HFSQL

El Centro de Control HFSQL permite realizar todas las operaciones de administración de los servidores y de las bases
de datos HFSQL Cliente/Servidor.
Vamos a ver las funcionalidades más importantes.
Vamos primero a lanzar el Centro de Control HFSQL desde el proyecto WINDEV.
 Para lanzar el Centro de Control HFSQL y acceder a los datos:
1. En el menú de WINDEV, en el panel “Utilidades”, en el grupo “Base de datos”, clique sobre “HFSQL”.
Aparecerá el Centro de Control HFSQL.
2. Se muestra la ventana de bienvenida del Centro de Control HFSQL. El análisis del proyecto en curso se
selecciona automáticamente.
3. Valide la pantalla. Aparecerá el Centro de Control HFSQL. Este modo de lanzamiento permite ver los distintos
ficheros relacionados con el análisis del proyecto en curso.
4. Clique si es necesario en el panel vertical “HFSQL C/S”. La lista de ficheros de datos en formato HFSQL
Cliente/Servidor se mostrará.

El Centro de Control lista aquí los ficheros de datos Cliente/Servidor encontrados en el análisis enlazado al
proyecto en curso. No se ha realizado ninguna conexión: los ficheros aparecen grisáceos.
5. Para visualizar los datos de los ficheros haga doble clic sobre uno de los ficheros de datos en la lista a la
izquierda (por ejemplo “Pedido”). Si el Centro de Control HFSQL no conoce todos los parámetros de la
conexión, una ventana de conexión permite realizar la conexión efectiva al servidor HFSQL Cliente/Servidor
utilizado. Si esta ventana se muestra, indique la contraseña y valide.
6. Las distintas informaciones del fichero de datos seleccionado y que utilizan esta conexión se muestran en una
nueva pestaña:
 La pestaña “Descripción” presenta las informaciones de los ficheros de datos (rúbricas del fichero, …).
 La pestaña “Contenido” muestra los registros existentes en el fichero de datos.
Desde el Centro de Control HFSQL, se puede administrar toda la base de datos HFSQL Cliente/Servidor.
Crear una cuenta usuario en el Centro de Control HFSQL

Hemos visto que durante la instalación de un servidor HFSQL y durante la creación de una base de datos, solo se crea
una cuenta de usuario: la cuenta de administrador (login “Admin” sin contraseña).
La utilización de la cuenta de usuario permite securizar el acceso a los datos. En efecto, todos los usuarios de la
aplicación no son administradores. A cada usuario (o grupo de usuarios), se le pueden asociar derechos.

Los derechos de los usuarios especificados en el Centro de Control HFSQL son los derechos de la
base de datos y no los derechos de acceso a la aplicación.
Atención!
No hay que confundir la gestión de los derechos de las bases de datos Cliente/Servidor con el
groupware usuario.
Algunos usuarios pueden por ejemplo, no tener derechos de escritura en algunos ficheros.
Para hacer una prueba simple, vamos a crear un usuario y se le permitirá consultar los registros del fichero Cliente.
 Para conectar directamente a la base de datos existente en el servidor:
1. Despliegue el menú situado arriba a la izquierda del Centro de Control HFSQL y seleccione la opción
“Conectarse a un servidor HFSQL”.
2. Se muestra la ventana de bienvenida en el Centro de Control HFSQL.
3. La opción “Conectarse a un servidor HFSQL” está seleccionada por defecto. Indique las características del
servidor instalado en la lección anterior y luego valide.
4. Las características del servidor HFSQL se muestran:
 En el panel de la izquierda, aparece el nombre del servidor HFSQL así como la lista de las bases
existentes en el servidor.
 En la parte derecha de la pantalla, una nueva pestaña se muestra permitiendo ver las características del
servidor HFSQL.
5. En la parte derecha de la pantalla, seleccione el panel “Usuarios”. Este panel permite gestionar los usuarios
del servidor.
6. De momento, solo existe el usuario “Admin”.

7. Para crear un nuevo usuario, en la cinta, en el grupo “Usuarios”, clique sobre el botón “Nuevo”. Aparece la
pantalla que permitirá definir las características del usuario.
8. Introduzca por ejemplo las siguientes informaciones:
(utilice por ejemplo “Test” igualmente como contraseña).

Varias características pueden ser destacadas:
 Super Usuario: Los usuarios designados como “Super Usuario” están autorizados a efectuar
todas las acciones en el servidor, las bases de datos y en todos los ficheros.
 Cuenta activa: Si esta opción no está marcada, el usuario existe, pero no está activo (caso
Notas
de los usuarios abandonados por ejemplo).

 Expiración de la contraseña: Es posible tener una contraseña válida solamente para un
número de días determinado (parametrizable).
9. Valide la creación del usuario. Por defecto, este usuario no tiene ningún derecho.
Vamos ahora a atribuir los derechos al usuario: el usuario “Test” puede conectarse a la base de datos y consultar el
fichero Cliente.
 Para conceder el derecho de conexión a la base de datos:
1. En el Centro de Control HFSQL, doble clic en la base de datos “WD Aplicación Completa”.
2. En la pestaña “WD Aplicación Completa”, en el grupo “Derechos”, clique sobre “Gestión de derechos”.
3. Seleccione el usuario “Test” en la lista de usuarios.
4. En la lista de los derechos, para la acción “Derecho de conectarse al servidor (conexión encriptada y no
encriptada), clique en la columna “Derecho definido” y seleccione la marca verde.
5. Clique sobre el botón “Aplicar” que hay a la derecha de la lista de derechos. El derecho se vuelve efectivo.
6. Cierre la ventana de gestión de los derechos.
 Para permitir la lectura del fichero Cliente:

1. En el Centro de Control HFSQL, despliegue la base de datos “WD Aplicación Completa”, y luego doble clic
sobre el fichero Cliente (a la izquierda de la pantalla).
2. En el panel “Cliente”, dentro del grupo “Derechos”, clique sobre “Gestión de derechos”.
3. Seleccione al usuario “Test” en la lista de usuarios.
4. En la lista de derechos, para la acción “Derecho a leer los registros de un fichero”, clique en la columna
“Derecho definido” y seleccione la marca verde.

5. Clique sobre el botón “Aplicar” que hay en la parte inferior de la ventana (flecha azul). El derecho se volverá
efectivo.
6. Cierre la ventana de gestión de los derechos.
De esta manera, se pueden definir los derechos:

 Sobre el servidor HFSQL.
 Sobre la base de datos.
 Sobre los ficheros de la base de datos.
En nuestro ejemplo, el usuario “Test” podrá solamente recorrer los registros del fichero Cliente. Si este usuario intenta
otra acción, se mostrará un mensaje: “El usuario Test no tiene los derechos suficientes para XXXX” (donde XXXX
corresponde a la acción intentada).
Una vez se ha creado la cuenta, puede utilizarse mediante la conexión de la aplicación al servidor (cuando se utiliza la
función HOpenConnection).
La gestión de los usuarios y sus derechos, puede también efectuarse por programación a través
Notas
de las funciones WLangage. Para más detalles, consulte la ayuda en línea.
Copia de seguridad de la base de datos

Para guardar la base de datos:
1. Posiciónese sobre la pestaña correspondiente a la base “WD Aplicación Completa”.
2. Seleccione el panel vertical “Copia de seguridad.
3. En el menú, dentro del grupo “Copias de seguridad”, despliegue “Nueva copia” y seleccione “Nueva copia en
caliente”.
Observación: Este botón es accesible en el grupo “Copias de seguridad”:
 En la pestaña correspondiente al servidor HFSQL
 En la pestaña correspondiente a la base de datos.

Observación: El asistente permite igualmente realizar una copia de seguridad de una selección de ficheros.
Conclusión
El Centro de Control HFSQL es una herramienta completa de administración de base de datos, permitiendo entre
otras cosas:
 Detener o re-arrancar un servidor en caso de problemas.
 Gestionar los usuarios y sus derechos.
 Reindexar los ficheros de datos si hiciera falta.
 Hacer copias de seguridad de la base
El Centro de Control HFSQL es una herramienta redistribuible que puede instalarse en los clientes que
tengan las bases de datos HFSQL Cliente/Servidor. El Centro de Control deberá ser utilizado por la
persona que administre la base de datos.

Lección 4.4. Instalación de cliente
 ¿Cómo instalar una aplicación Cliente/Servidor en el cliente?

Presentación
La instalación de una aplicación Cliente/Servidor necesita varias opciones específicas. Estas opciones están apoyadas
sobre el asistente de instalación de WINDEV.
Vamos a crear el procedimiento de instalación de nuestra aplicación “WD Aplicación Completa”.
Lanzamiento del asistente de creación de instalación

Para lanzar el procedimiento de instalación de una aplicación HFSQL Cliente/Servidor:
1. En el panel “Proyecto”, en el grupo “Generación”, clique sobre “Procedimiento de instalación”.
2. Cree el ejecutable y valide la creación de la ayuda.
3. Vaya hasta la pantalla “Parámetros de las bases de datos”. En este plan, es posible:
 Integrar la instalación de un servidor HFSQL
 Parametrizar las conexiones HFSQL Cliente/Servidor
 Desplegar los ficheros HFSQL Cliente/Servidor
Si estas opciones están marcadas, las siguientes pantallas permiten parametrizar los distintos elementos a considerar
para la instalación en cliente.
Para más detalles consulte la ayuda en línea.

CAPÍTULO 5
Optimizar y
depurar un
proyecto
Capítulo 5 – Optimizar y depurar un proyecto |303

 Porqué optimizar una aplicación
 Proyecto ejemplo

Presentación
Su aplicación está terminada. Funciona, ha creado distintas pruebas automáticas para evitar problemas. Desea
desplegarla en sus clientes.
¿Ha pensado en utilizar las herramientas de WINDEV para optimizar su aplicación? WINDEV propone una serie de
herramientas y funcionalidades que permiten optimizar rápidamente su aplicación y evitar sencillamente “bugs”
groseros.
Este capítulo presenta en detalla estas herramientas y su utilización.
Para manipular mejor estas funcionalidades, hemos preparado un proyecto para optimizar!
Apertura del proyecto
 Lance WINDEV 21 (si no lo ha hecho ya). Si es necesario, cierre el proyecto en curso para hacer aparecer la
ventana de bienvenida.
 Abra el proyecto “WD Optimización”.
Para ello, en la ventana de bienvenida, clique sobre “Curso de autoformación” y seleccione “Optimizar un
proyecto”.
Astucia: si la ventana de bienvenida no se muestre, en el panel “Inicio”, dentro del grupo “Ayuda en línea”,
despliegue “Guía de Auto-formación” y luego seleccione la opción “Optimizar un proyecto”.

Lección 5.2. Auditorías del proyecto
 ¿Qué es una auditoría y para qué sirve?
 Lanzar y analizar la auditoría estática.
 Lanzar y analizar la auditoría dinámica.

¿Qué es una auditoría?
Las auditorías aportan una serie de funcionalidades que permiten mejorar automáticamente la calidad y las
realizaciones de un proyecto y seguir con más precisión sus condiciones de puesta en marcha.
Hay disponibles dos tipos de auditorías:
 Auditoría estática: La auditoría estática consiste en un análisis detallado de un proyecto y sus elementos. Esta
auditoría se realiza directamente desde el editor del proyecto.
 Auditoría dinámica: La auditoría dinámica es un análisis del comportamiento de un proyecto durante su
ejecución. Esta auditoría puede realizarse en modo prueba o directamente en el entorno de producción.
Vamos a continuación a probar estas auditorías en el proyecto WD_Optimización”.
Auditoría estática.
La auditoría estática es una funcionalidad del entorno que permite analizar las fuentes de un proyecto para detectar
distintos problemas y proponer mejoras.
 Para lanzar la auditoría estática en el proyecto “WD_Optimizacion”:
1. En el panel “Proyecto”, en el grupo “Auditoria y realizaciones”, despliegue “Auditoría de edición” y seleccione
“Desencadenar la auditoría de edición”.
La auditoría estática del proyecto puede igualmente lanzarse desde el tablero de control del
proyecto a través del widget “Auditoría estática y compilación”.
Hay que:
 Activar el Widget si fuera necesario (clique sobre el enlace “Clique aquí para reactivar”).
 Clique sobre la flecha.
Notas
2. Se lanza el asistente. Vamos a definir el objetivo de la auditoría estática.

3. Seleccione la opción “Lanzar la auditoría estática sobre el proyecto completo”.
5. Se muestra el informe de la auditoría:
La auditoría estática se compone de:

 Auditoría estática del proyecto.
 Auditoría del contenido de la biblioteca de la aplicación.
 Auditoría del contenido de la instalación.
 Examinemos con atención los puntos presentes en este informe.

Procedimiento no ejecutado
En nuestro proyecto, la auditoría nos indica que un procedimiento no se va a ejecutar jamás.
Ocurre frecuentemente en los proyectos importantes, que se crea uno o varios procedimientos para realizar un
tratamiento, y luego debido a una reorganización del código, el procedimiento no se vuelve a utilizar jamás en el
proyecto.
La presencia de procedimientos no utilizados, hace más pesados inútilmente los recursos distribuidos a los usuarios
finales.
 Para tratar este problema:
1. Clique sobre el botón “[…] para obtener más informaciones. La ventana que muestra los códigos “muertos”
aparecerá:

2. El procedimiento “ProcedimientoObsoleto” no será llamado nunca. Esta ventana permite:
 Especificar que el procedimiento todavía se utiliza (botón “Marcar como utilizado”).
En este caso, el procedimiento no se tendrá en cuenta cuando se audite.
 Suprimir el procedimiento si realmente es inútil (botón “Suprimir”).
 Ver el procedimiento (botón “Ver”).
 Buscar los casos en los que se usa dentro de las cadenas por ejemplo (botón “buscar”).
3. En nuestro caso, este procedimiento es realmente inservible, clique sobre “Suprimir”.
4. Se muestra una ventana pidiendo la confirmación de la eliminación. Confirme la eliminación clicando sobre el
botón “Suprimir”.
5. Cierre la ventana del código muerto (utilice el aspa arriba a la derecha).
 En la ventana de la auditoría estática, clique sobre el botón “Refrescar” para actualizar el informe de auditoría.
Elemento huérfano
La auditoría nos indica que nuestro proyecto contiene un elemento huérfano.
Al igual que los procedimientos ejecutados, también es frecuente crear ventanas, informes para realizar una prueba
rápida, guardarlos y olvidarlos. La presencia de elementos huérfanos en el ejecutable, hace más pesados los recursos
distribuidos a los usuarios finales.

1. Clique en el botón […] para obtener más información. La ventana que lista los elementos huérfanos
aparecerá:

2. La ventana “FEN_FenetreInutilisee” no se ha llamado jamás. La ventana que lista los elementos huérfanos
permite:
 Especificar que el elemento todavía puede utilizarse (botón “Marcar como utilizado”). En este caso, la página
de nuestro ejemplo no se tendrá en cuenta cuando se audite. Esta opción puede ser interesante por ejemplo,
en el caso de una página de prueba específica al desarrollo.
 Eliminar la página si realmente está inutilizada (botón “Suprimir”).
 Ver la página (botón “Ver”).
 Buscar los casos en los que se usa dentro de las cadenas por ejemplo (botón “Buscar”).
3. En nuestro caso, laventana “FEN_FenetreInutilisee” es realmente inservible, clique sobre “Suprimir”.
4. Cierre la ventana de los elementos huérfanos (utilice el aspa arriba a la derecha).
 En la ventana de la auditoría estática, clique sobre el botón “Refrescar” para actualizar el informe de auditoría.
Consulta a optimizar
La auditoría nos indica que nuestro proyecto contiene una consulta a optimizar.
Esta optimización permite mejorar la velocidad de ejecución de una consulta. La optimización de una consulta
descansa sobre el siguiente principio: un asistente determina las claves compuestas a modificar y/o añadir en el
análisis asociado al proyecto.
 Para optimizar la consulta:

1. Clique sobre el botón […] para obtener más informaciones. La ventana que lista las modificaciones a realizar
en el análisis aparecerá.

2. El asistente propone modificar una rúbrica del análisis transformándolo en una clave con duplicados.
3. Vamos a aplicar el cambio propuesto: clique en el botón “Aplicar esta modificación en el análisis”.
4. Una ventana se muestra pidiendo la confirmación de la modificación del análisis. Valide esta ventana.
5. El editor de análisis está abierto y se ha efectuado la modificación. Un mensaje indica que se necesita la
generación del análisis. Confirme la generación del análisis clicando sobre “Si”.
6. La aplicación utiliza los datos, es necesaria una modificación automática de los ficheros de datos. Valide las
distintas pantallas del asistente de modificación de los datos (conservando las opciones por defecto).
7. La ventana de la auditoría estática se refresca automáticamente.
Limpieza del proyecto

Nuestro proyecto contiene varios ficheros inutilizados. Es posible limpiar el proyecto para conservar solamente los
elementos necesarios. El ejecutable de instalación cliente no se hará más pesado con las imágenes, ficheros externos,
… no utilizados.

1. Clique sobre el botón […] para conseguir más información.
2. El asistente de limpieza del proyecto se lanza. Este asistente indica los ficheros inutilizados que pueden ser
suprimidos.
4. Indique el tipo de limpieza a realizar. Se puede:
 Crear un fichero zip con los ficheros inútiles.
 Mover los ficheros inútiles a un directorio específico.
5. Valide la opción propuesta por defecto y pase a la etapa siguiente.
6. Finalice el asistente.
Hemos optimizado nuestro proyecto siguiendo todos los consejos de la auditoría estática.
La auditoría estática permite tener un informe general sobre las fuentes de su proyecto. Nuestro consejo: láncela con
regularidad.
Y ahora, veamos que sucede en ejecución lanzando la auditoría dinámica.
Auditoría dinámica.
La auditoría dinámica permite analizar la ejecución de la aplicación. La auditoría permitirá detectar algunos problemas
como:
 Consumo excesivo de memoria.
 Lentitud de los algoritmos utilizados.
 Errores “enmascarados” cuando se ejecuta.
 …
Una auditoría dinámica puede efectuarse en un entorno de pruebas o en una aplicación en producción.
El proyecto “WD_Optimizacion” contiene una página específica que provoca errores que pueden ser detectados por la
auditoría dinámica.
Vamos a lanzar la auditoría dinámica al mismo tiempo que la prueba del proyecto.
 Para lanzar la auditoría dinámica sobre el proyecto “WD_Optimizacion”:

1. En el panel “Proyecto”, en el grupo “Modo prueba”, despliegue “Modo prueba” y seleccione “Depurar el
proyecto con la auditoría activada”. Se lanza la prueba del proyecto.
La auditoría dinámica del proyecto puede igualmente lanzarse desde el cuadro de mandos del
proyecto a través del Widget “Auditoría dinámica”. Hay que:
 Activar el Widget si hiciera falta (clique sobre el enlace “Clique aquí para reactivar”).
 Desplegar la flecha y seleccione “Go minucioso del proyecto”.
Notas
Observación: a cada lanzamiento de la aplicación por un GO del proyecto, se lanza

automáticamente la auditoría dinámica. Se muestra automáticamente un informe en el Cuadro
de mando.
2. Clique sobre el botón “Página de prueba de la auditoría dinámica”.

 Clique sobre los distintos botones presentes en la página.Al fin de cada tratamiento, un mensaje en forma de
tostada se muestra para indicar que ha finalizado el tratamiento.Para la opción “Aserción y Excepción”, se
muestra una aserción: clique “Continuar” para ver aparecer el siguiente mensaje en forma de tostada.
3. Detenga la prueba de la aplicación.
4. Se muestra automáticamente la ventana del informe de la auditoría dinámica.

 Examinemos esta ventana:
 La parte superior de esta ventana permite elegir el modo de visualización de los datos. Se puede:
o Elegir una visualización cronológica (respetando el orden de llegada de los eventos) o una
visualización sintética, que permita reagrupar los distintos tipos de problemas. En este caso, la línea
del tiempo permite ver la posición y la importancia de los problemas.
o Elegir el tipo de problemas a mostrar (error, aserción, …). Así es posible, por ejemplo, concentrarse
solamente sobre los errores graves, …
 La parte inferior de esta ventana muestre los distintos eventos sobrevenidos que pueden dar problemas en la
aplicación.
 En este ejemplo, la auditoría dinámica detecta varios problemas:
 Un texto demasiado largo afectado por programación.
 Una instrucción SWITCH donde no se ejecuta ningún CASE.
 Una aserción desencadenada en lugar de una excepción.
 La apertura de un fichero que no existe.
 La afectación de un fichero imagen que no existe en un campo imagen.
Para cada problema, un botón “…” permite acceder al detalle del evento registrado.
Si el evento está relacionado con una línea de código en particular, el botón permite abrir directamente el editor
de código en el sitio correspondiente a fin de poder corregir el problema.
 Cierre la ventana de auditoría dinámica.

La auditoría dinámica del proyecto puede igualmente efectuarse cuando la aplicación está
desplegada en los puestos clientes.
Se puede:
 Modificar la aplicación y utilizar dbgEnableAudit para lanzar la auditoría.
 Utilizar un fichero texto en el directorio de la aplicación. Esta solución no permite modificar el
ejecutable. Hay que crear en el mismo directorio que el ejecutable un fichero con el mismo
Notas
nombre que el ejecutable y la extensión “.WX”.

La auditoría genera un fichero “.wdaudit”; este fichero deberá ser cargado en el entorno de
desarrollo para analizar el resultado.
Para más detalles, consulte la ayuda en línea (palabra clave: “Audit dynamique”).
Lección 5.3. Analizador de actuaciones

 Presentación
 Lanzar el analizador de actuaciones.
 Analizar el resultado

Presentación
El analizador de actuaciones (llamado también Profiler) es una herramienta que permite verificar y optimizar el tiempo
de ejecución de los tratamientos de su sitio.
Su principio es simple:
 Pruebe su sitio.
 Durante esta prueba, el analizador de actuaciones recapitula todas las acciones efectuadas y guarda los tiempos
de ejecución de cada uno de los tratamientos ejecutados.
Al final de la prueba, el analizador de actuaciones presenta:
 Las 10 actuaciones que han tardado más tiempo.
 La duración y el número de llamadas de todos los tratamientos ejecutados.
El proyecto “WD_Optimizacion” contiene una ventana específica que permite visualizar los resultados interesantes con
el analizador de actuaciones.
Lanzar el analizador de actuaciones

El analizador de actuaciones puede ser lanzado:
 Directamente desde el editor de WINDEV:
En este caso, el proyecto se ejecuta automáticamente en modo prueba. Puede manipular su aplicación y lanzar
los tratamientos de su elección.
Para volver al editor de WINDEV, basta con cerrar su aplicación.
El analizador de actuaciones muestra entonces el resultado del análisis. Este resultado queda guardado en forma
de un fichero WPF.
 Desde uno de sus tratamientos en WLangage, por medio de las siguientes funciones:
ProfilerStart Lanza la “colecta de informaciones” para el analizador de actuaciones.

ProfilerEnd Detiene la “colecta de informaciones” para el analizador de actuaciones.
En este caso, solo el código presente entre las funciones ProfilerStart y ProfilerEnd se analizará. El resultado se
guardará en un fichero WPF.
 En nuestro ejemplo, vamos a utilizar el primer método. Para lanzar el analizador de actuaciones en el proyecto
“WD_Optimizacion”:
1. En el panel “Proyecto”, dentro del grupo “Auditoría y actuaciones”, despliegue “Analizar las actuaciones” y
seleccione “Analizar las actuaciones”.
El analizador de actuaciones puede también lanzarse desde el cuadro de mandos del proyecto a
través del Widget “Actuaciones”. Hay que:
 Activar el Widget si es necesario (clique sobre el enlace “Clicar aquí para reactivar”).
 Clicar sobre la flecha y seleccionar “Analizar las actuaciones”.
Notas
2. Se lanza la prueba del proyecto.

3. Clique sobre el botón “Ventana de prueba del analizador de actuaciones”.
4. Clique sobre el botón “Tratamiento a analizar”.

5. Valide la ventana de información y detenga la prueba del proyecto. La ventana de resultados del analizador
de actuaciones aparecerá.
Análisis del resultado

 Examinemos la ventana del informe del analizador de actuaciones. Los resultados se muestran en varias
pestañas:
 La pestaña “Síntesis” presenta los 10 tratamientos que han tardado más tiempo.
 La pestaña “Cartografía” presenta una visión gráfica de los tratamientos más importantes.
 La pestaña “Detalle” presenta todos los tratamientos lanzados durante la prueba de la aplicación (clases de
más largas a más rápidas).
 La pestaña “Llamadas” permite visualizar el detalle de las operaciones realizadas en el tratamiento.
 Detallemos las diferentes pestañas en el caso de nuestro ejemplo.

 La pestaña “Síntesis” presenta los diez tratamientos más consumidores de tiempo. En nuestro ejemplo,
podemos ver que el procedimiento local “ActualizarProductosEnStock” tarda más de 3 segundos en
ejecutarse.
 La pestaña “Cartografía” permite identificar de manera visual cual ha tomado más tiempo. En nuestro caso,
es una llamada a la función Ping:

 La pestaña “Detalles” presenta todos los tratamientos llamados, desde el más largo al más rápido.
Para cada tratamiento, se muestran las siguientes informaciones:

o Función: Función, tratamiento o procedimiento ejecutado.
o Tiempo total: Tiempo de ejecución de la función.
o Tiempo interno: Tiempo de ejecución del motor.
o N. Llamadas: Número de llamadas efectuadas a la función (procedimiento o tratamiento).
o Tiempo 1 llamada: Tiempo de ejecución de una llamada a la función (procedimiento o tratamiento).
o % Código: Porcentaje del tiempo pasado en el tratamiento de la función o del procedimiento (código
del desarrollador que puede ser optimizado).
o Padre: Elemento que contiene el tratamiento.
En nuestro caso, la pestaña “Detalle” permite encontrar la llamada a la función Ping en los elementos que
toman más tiempo.
Seleccione esta línea. Vamos a ver en el código si hay algún problema que pueda explicar este
ralentizamiento.
o Clicando sobre el botón “Llamadas”, aparece el detalle de las llamadas del procedimiento
ActualizarProductosEnStock. Seleccionando la línea “Ping” y clicando sobre el botón “Código”, la
línea de código correspondiente se muestra en el editor de código.
o Cierre el analizador de actuaciones.

o La línea de código ejecutado es la siguiente:
Ping (“dir-proveedor”)
La ralentización viene del hecho de que la dirección especificada por la función Ping es inaccesible.
 Probemos rápidamente el funcionamiento de la aplicación optimizando el código

1. Sustituya la línea de código que contiene la función Ping por la línea de código siguiente:
// Verificar la accesibilidad del servidor proveedor
Ping (www.google.fr)
2. Guarde el código ([CTRL]+[S]).
 Vamos ahora a relanzar el analizador de actuaciones:

1. En el panel “Proyecto”, dentro del grupo “Auditoría y actuaciones”, despliegue “Analizar las actuaciones” y
seleccione “Analizar las actuaciones”.
2. Se lanza la prueba del proyecto.
3. Clique sobre el botón “Página de prueba del analizador de actuaciones”.
4. Clique sobre el botón “Tratamiento a analizar”.
5. Valide la ventana de información y detenga la prueba del proyecto. Aparecerá la ventana del informe del
analizador de actuaciones.
6. En la pestaña “Cartografía”, la función Ping ya no aparece con la misma importancia.

 Cierre la ventana de informe del analizador de actuaciones.

Lección 5.4. Depuración de un proyecto
 Presentación
 Utilizar el depurador

Presentación
Detengámonos un momento en el depurador suministrado en estándar con WEBDEV.
¿Qué es el depurador?
El depurador es una potente herramienta que permite seguir paso a paso el desarrollo de un código o de una
aplicación. Poner a punto un tratamiento o una aplicación, se convierte en un juego de niños.
Vamos a utilizar el depurador en el tratamiento largo que hay en la ventana “WIN_Analizador-Actuaciones”.
Utilizar el depurador
 Para depurar la ventana WIN_Analizador-Actuaciones:
1. Abra la ventana “WIN_Analizador-Actuaciones” en el editor de ventanas (doble clic en su nombre en el
explorador del proyecto).
2. Lance la prueba de la ventana “WIN_Analizador-Actuaciones” ( en los botones de acceso rápido).

3. Lance el depurador utilizando uno de los siguientes métodos:
 Utilice la combinación de teclas [CTRL]+[Pausa]: el depurador se lanzará automáticamente en la próxima
acción del usuario en la ventana probada.
 Vuelva sobre el editor WINDEV y sitúe un punto de interrupción en el código del botón “Tratamiento a
analizar”(clique delante de la primera línea del código de tratamiento de clico utilice el atajo [CTRL]+[B];
aparecerá un punto rojo). Cuando se llegue a la ejecución de la línea de código precedida del punto de
detención, se lanzará el depurador.
Hay muchos métodos que permiten lanzar el depurador; para más detalles, consulte la ayuda en
Notas
línea (palabra clave: “Depurador, lanzar una prueba”).
4. Clique en el botón “Tratamiento a analizar”. Se abre el depurador. La línea actual, está precedida de una
pequeña flecha.
En la parte inferior de la pantalla, aparecerá el panel “Depurador”. Este panel muestra dos zonas distintas:

 La pila de las llamadas: esta zona permite conocer la jerarquía de los tratamientos mostrados en el
depurador. En nuestro ejemplo, por el momento, estamos empezando a depurar el tratamiento de clic sobre
el botón BTN_TratamientoLargo.
 La lista de expresiones a evaluar. Por defecto, las principales variables utilizadas en el código se muestran en
esta zona. También se pueden añadir variables para seguir su evolución (veremos esta funcionalidad más
adelante).
Vamos a efectuar algunas manipulaciones en el depurador para poder descubrir sus posibilidades.
 Primero, vamos a ejecutar paso a paso las distintas instrucciones y veremos el contenido de las variables:
1. Pulse la tecla [F8] (o sobre el botón “Paso a paso” que hay en la cinta). La línea siguiente a la línea en curso
se ejecuta automáticamente. Si lo necesita, los valores de las variables pueden modificarse en el panel
“Depurador” (mostrado por defecto en la parte inferior de la pantalla.
2. Cuando el cursor en forma de flecha llegue a la línea “JAUGE_Progression..BorneMax = …”, pase con el ratón
sobre “JAUGE_Progression”. Una bolsa de ayuda se muestra con el valor de la expresión:
3. El valor “JAUGE_Progression..BorneMax” se muestra en una bolsa de ayuda. Este valor corresponde a 100
porque la línea de código no se ha ejecutado todavía.
4. Utilice la tecla [F8] para ejecutar la línea.
5. Pase de nuevo sobre “JAUGE_Progression..BorneMax”. El valor de “JAUGE_Progression..BorneMax” mostrado
en la bolsa de ayuda corresponde desde ahora al resultado de la función “HNbEnr(Producto).
 Continuemos con nuestras manipulaciones en el depurador. Vamos ahora a ejecutar paso a paso el procedimiento
ActualizarStockProductos en el depurador.
1. Para ejecutar este procedimiento paso a paso, utilice la tecla [F7] (o clique sobre el botón “Paso a paso
detallado” en la cinta).
2. El código del procedimiento se muestra en el depurador.
 Ahora vamos a añadir una expresión para monitorizar la evolución de su valor en el panel “Depurador”. Esta
expresión puede ser de cualquier tipo: variable, función, operación sobre variables, … El resultado de la expresión
se calcula y se muestra.
Esta expresión permite efectuar una depuración personalizada. Por ejemplo, se puede conocer el contenido de
una variable al tiempo y a medida de su uso en la aplicación.
1. Utilice la tecla [F7] para ejecutar las distintas líneas del procedimiento ActualizarStockProductos hasta la
línea:
JAUGE_Progression++
2. Pase sobre “JAUGE_Progression”. El valor mostrado en la bolsa es 0.
3. Seleccione “JAUGE_Progression” en el editor de código en el depurador y muestre el menú contextual (clic
derecho). Seleccione la opción “Añadir la expresión en el depurador”.
4. La expresión se añade automáticamente en el panel del depurador bajo de la pantalla.

 El depurador también permite ejecutar un conjunto de líneas de código:
1. Avance con la tecla [F8] hasta la línea:
Hmodify (Producto)
El uso de la tecla [F8] permite ejecutar el código del procedimiento InterrogeBaseFournisseur sin desplegar
paso a paso en el depurador.
2. Clique con el ratón en la siguiente línea (ojo: clique en la línea, no delante de la línea):
IF HExecuteQuery (REC_CantidadPedida) THEN
3. Utilice la tecla [F6] (o el botón “Ejecutar hasta el cursor” que hay en la cinta).
4. La flecha que indica la línea en curso, se desplaza hasta la línea de código donde está posicionado el cursor.
Las líneas que hay hasta el cursor se ejecutan automáticamente.
 Ahora vamos a poner un punto de detención y ejecutar el código hasta el siguiente paso sobre el punto de
detención:
1. Clique con el ratón sobre la zona tramada, delante de la función HModify. Un punto de detención (de color
rojo) aparecerá.
2. Utilice la tecla [F5] (o clique sobre el botón “Continuar” que hay en la cinta). El código se ejecuta hasta el
punto de detención. La flecha que permite identificar la línea en curso se desplaza hasta el punto de
detención.
3. Quite el punto de detención, clicando directamente sobre el mismo.
 Para acabar la prueba, vamos a utilizar una expresión “Autostop”. Una expresión “Autostop” permite lanzar el
depurador hasta que se verifica una condición o hasta que se modfique el valor de una variable. En nuestro
ejemplo, vamos a lanzar el depurador hasta que el valor del medidor sea igual a 50%:
1. En el panel “Depurador”, seleccione la expresión “JAUGE_Progression” que hemos añadido previamente.
2. Clique sobre el círculo verde.
3. Pulse la tecla [F5] para continuar la prueba.
4. Se muestra un mensaje indicando que el valor de la expresión “JAUGE_Progression” ha cambiado.

5. Valide.
6. En el panel “Depurador”, seleccione la expresión “JAUGE_Progression”. Clique una segunda vez sobre la
expresión: La columna “Expresión” pasa a edición. En la zona “Expresión”, añada “=50”. Obtendrá
“JAUGE_Progression = 50”.
7. Pulse la tecla [F5]. El programa continúa ejecutándose. El depurador se lanza nuevamente hasta que la
variable “JAUGE_Progression” tenga un valor de 50.
 Y ya está, hemos terminado nuestra visita al depurador. Para detener la prueba del depurador, clique en
“Terminar la prueba” en la cinta.

CAPÍTULO 6
Programación
avanzada
Capítulo 6 – Programación avanzada |325

 Presentación
 Como abrir un ejemplo didáctico
 Como abrir un ejemplo unitario

Presentación
Este capítulo presenta varias funcionalidades avanzadas. Su lectura no es indispensable para el conocimiento de
WINDEV, pero le permitirá conocer algunas de las posibilidades de WINDEV.
Las distintas lecciones de este capítulo se apoyan sobre ejemplos proporcionados en estándar con WINDEV.
WINDEV Propone distintos ejemplos:

 Ejemplos completos: estos ejemplos corresponden a una aplicación completa que utilizan una o varias
funcionalidades.
 Ejemplos didácticos: estos ejemplos corresponden a una pequeña aplicación que permite descubrir una
funcionalidad.
 Ejemplos unitarios: estos ejemplos corresponden a una ventana que permite probar rápidamente el uso de
una función.
Ejemplo práctico
Para simplificar la presentación de distintas funcionalidades, puede manipular los ejemplos unitarios o los ejemplos
didácticos, proporcionados en estándar con WINDEV.
 Para abrir un ejemplo completo, didáctico o unitario desde la ventana de bienvenida:

1. Muestre la ventana de bienvenida ([CTRL]+[>]).
2. En la ventana de bienvenida, clique sobre “Abrir un ejemplo”. Aparece la lista de ejemplos completos,
didácticos y unitarios proporcionados con WINDEV. Estos ejemplos están agrupados por tipos de ejemplo
(completo, didáctico, …).
3. En la zona de búsqueda, puede introducir una palabra clave (por ejemplo, introduzca “Error”). Solo los
ejemplos que contienen esta palabra se listarán:
4. Para abrir un ejemplo, hay que clicar sobre el enlace existente en la ventana.
5. Para los ejemplos completos y didácticos, el proyecto en curso se cierra automáticamente cuando se abre el
proyecto ejemplo.
6. Para los ejemplos unitarios, la ventana asociada se abre en el proyecto en curso.

Lección 6.2. Gestión automática de errores
 ¿Qué es la gestión automática de errores?
 Uso de la gestión automática de errores.

Presentación
WINDEV puede gestionar automáticamente los errores. Esta funcionalidad permita a la vez reducir considerablemente
el código de un proyecto, uniformando y centralizando la gestión de los errores.
El uso de esta funcionalidad permite hacer el código más legible.
Funcionamiento
Cuando una función WLangage encuentra un error, se realizan dos operaciones:
 La función reenvía un valor de retorno de error (por ejemplo, la función fOpen reenvía el valor “-1” si el
fichero especificado no se ha podido abrir).
 El error es detectado por WLangage (la variable ErrorOccurred corresponde a True) y se pueden recuperar
las informaciones sobre este error utilizando la función ErrorInfo.
Es esta segunda operación la que puede estar gestionada automáticamente por la gestión de errores de WINDEV.
Establecimiento
La parametrización de la gestión automática de los errores puede efectuarse:
 Directamente en el editor de código: basta con clicar en el enlace “Si error: Por programa” en el editor de
código:
 Por programación, con la función ErrorChangeParameter.
Tipo de errores a los que concierne

En WLangage puede encontrar dos tipos de errores:
 Los errores “No fatales” (llamados también errores de ejecución): estos errores son generalmente
gestionados en el código y no provocan la detención de la aplicación. Por ejemplo, abrir un fichero inaccesible
o un archivo inexistente.
 Los errores “fatales” (llamados también errores de programación): estos errores están generalmente ligados a
un fallo de concepción (acceso a un fichero no declarado, uso de campos inexistentes, …). Un error “fatal”
puede también llegar a continuación de un error “no fatal” mal gestionado. En este caso, la aplicación se
detendrá.
El mecanismo de gestión de los errores permite generar de forma bien distinta estos dos tipos de errores para poder
especificar los comportamientos adaptados a los errores encontrados.
Gestión automática de los errores: un ejemplo didáctico
 Para comprender los distintos casos de errores y su gestión, le proponemos manipular un ejemplo didáctico
librado en estándar con WINDEV.
1. Cierre si es necesario el proyecto en curso. Aparecerá la ventana de bienvenida.
2. En la ventana de bienvenida, clique sobre “Abrir un ejemplo”. La lista de los ejemplos completos, didácticos y
unitarios proporcionada con WINDEV aparecerá.
3. En la zona de búsqueda, introduzca “Error”. Solo los ejemplos que contengan esta palabra se listarán ahora.
4. Seleccione el proyecto “WD Gestión Auto Errores”. Se carga el proyecto.
 Este proyecto presenta la gestión:

 De un error no fatal (abrir un archivo inexistente).
 De un error fatal (división de un entero por 0).
 De un error en varios niveles.
 Pruebe el proyecto clicando sobre en los botones de acceso rápido.

1. Clique sobre la elección “Gestión de un error no fatal”.
2. La siguiente ventana se muestra.

3. Clique sobre el botón “Probar esta gestión de error”.
4. Cuando se ejecuta la línea de código que genera el error, se muestra un mensaje de error y propone al
usuario reintentar la operación, anular la operación o detener la aplicación.
La opción “Depurar” se utilizará:
 En modo prueba, para depurar directamente la aplicación.
 En modo ejecutable, para realizar la depuración de un ejecutable directamente desde WINDEV.
5. Clique la opción “Anular la operación” y cierre la ventana.
 Clique sobre la elección “Gestión de un error fatal”.

1. La siguiente ventana se mostrará. Esta ventana permite probar el error en el caso de la división de un entero
por 0.

2. Clique sobre el botón “Probar esta gestión de error”.
3. Cuando se ejecuta la línea de código que genera el error, un procedimiento se llama automáticamente. Este
procedimiento permite mostrar el mensaje de error y detener el tratamiento en curso.
4. Clique sobre “OK” y cierre la ventana.
 Clique sobre la selección “Gestión de un error en varios niveles”.

1. La siguiente ventana se mostrará. Esta ventana permite probar un error en varios niveles (tratamiento que
llama un procedimiento que abre un archivo inexistente).

2. Clique sobre el botón “Probar esta gestión del error”.
3. Cuando se ejecuta la línea de código que genera el error:
- El procedimiento devuelve “Falso” al tratamiento que le llama.
- El tratamiento que lo llama muestra un mensaje de error y detiene el tratamiento.
4. Clique sobre el botón “Anular la operación”.
 Detenga la prueba de la aplicación.
WINDEV propone igualmente una gestión automática de los errores HFSQL. Para más detalles,
Ejemplo
consulte el ejemplo “WD Detección errores HFSQL” (ejemplo didáctico), proporcionado en

estándar con WINDEV. Este ejemplo es accesible desde la ventana de bienvenida de WINDEV.

Lección 6.3. Manipular ficheros externos
 Manipular ficheros texto (CSV, …)
 Manipular directorios
 Manipular ficheros XML
 Manipular ficheros XLS

Presentación
WINDEV permite manipular sencillamente los formatos más corrientes de datos:
 Ficheros texto (ficheros INI, CSV, …)
 Ficheros XML
 Ficheros XLS, …
Numerosas familias de funciones WLangage permiten tanto leer estos ficheros como crear estos ficheros. Puede así
leer fácilmente en sus aplicaciones WINDEV datos generados por otros softwares o incluso crear ficheros que
necesitan un formateo particular.
Además, WLangage propone también una familia de funciones que permiten manipular los directorios donde están los
ficheros.
En este capítulo, nos dedicaremos más particularmente:
 A los ficheros Texto (ficheros texto, ficheros INI y ficheros CSV)
 A los ficheros XML
 A los ficheros XLS
 A la gestión de los directorios.
Manipulación de los fichero texto o CSV

Presentación
Los ficheros externos son comúnmente llamados ficheros de texto o incluso ficheros de acceso directo. Este tipo de
fichero contiene generalmente texto, pero igualmente puede contener informaciones binarias como imágenes,
sonidos, …
En esta lección como en toda la documentación de WINDEV, hablaremos de ficheros externos.
WINDEV permite manipular en programación los ficheros externos. Las funciones de WLangage permite crear, leer, …
los ficheros externos. Todas las funciones pueden identificarse fácilmente: todas ellas empiezan por la letra “f”.
En un fichero externo, no existe necesariamente la noción “de registro”. Para poder manipular un fichero externo,
hace falta conocer su estructura, es decir, conocer la disposición de los datos que se encuentran al interior del
fichero.
Los ficheros CSV son simplemente ficheros de texto que utilizan una estructura específica. Son manipulables como los
restantes ficheros de texto.
Los ficheros .INI son igualmente ficheros de texto que utilizan una estructura específica. Para manipularlos, WINDEV
dispone de dos funciones específicas: INIRead e INIWrite.
Ejemplo práctico
 Abra el ejemplo unitario “Manipulación de ficheros de texto”. Una pequeña ventana azul indica que la ventana no
está integrada en el proyecto.
 Clique sobre el botón “Añadir al proyecto”.
 Valide la adición al proyecto clicando sobre el botón “Copiar en el directorio del producto”.
 Pruebe la ventana “WIN_Fichero_Texto”. Esta ventana reagrupa numerosas manipulaciones posibles en los
ficheros externos con WINDEV.

Las distintas pestañas de la ventana proponen:
 La creación de un fichero texto.
 La lectura y escritura dentro de un fichero texto.
 Manipulaciones de ficheros existentes (copia, supresión, lectura de informaciones, …).
 La copia de un fichero de texto.
Para más detalles sobre las funciones de gestión de los ficheros externos, consulte la ayuda en línea (palabra clave:
“Fichero externo).
Manipulación de los directorios

Para manipular directorios y sus ficheros, WLangage propone numerosas funciones.
Ejemplo práctico
 Abra si es necesario el ejemplo unitario “Manipulación de los directorios” y pruebe la ventana correspondiente.
 Esta ventana agrupa las manipulaciones posibles en los discos y los directorios:
 Crear un directorio
 Conocer el directorio en curso
 Probar la existencia de un directorio
 Listar los directorios
 Copiar y eliminar un directorio, …
Para más detalles sobre las funciones de gestión de los directorios, consulte la ayuda en línea (palabra clave: “Fichero
externo”).
Manipulación de los ficheros XML

Presentación
XML (Extensible Markup Language, o Lenguaje Extensible de Marcado) es el lenguaje destinado a suceder a HTML en
el World Wide Web. Como HTML (Hypertext Markup Language), el XML es un lenguaje de marcado, es decir un
lenguaje que presenta la información encuadrada por las marcas. Pero al contrario que HTML, que presenta un juego
limitado de marcas, XML es un metalenguaje, que permite inventar nuevas marcas para abarcar todas las
informaciones elementales que puede contener una página Web.
XML permite estructurar un documento que contiene datos. Un fichero de datos HFSQL contiene varias rúbricas y
registros puede, por ejemplo, ser exportado en un fichero XML (funciones XML*).
WINDEV gestiona en estándar:

 Los ficheros con formato XML, a través de un acceso nativo proporcionado con WINDEV. Para más detalles,
consulte la ayuda en línea.
 Las exportaciones hacia XML (funciones TableToXml, TextToXml, HExportXML)
 Importación de datos XML (función HImportXML).
 La manipulación de un documento XML gracias al tipo avanzado xmlDocumenty a las funciones WLangage
que empiezan por XML.
También es posible manipular directamente el fichero XML en el editor de código. Basta con:
1. “Desplazar” el fichero XML desde el explorador de ficheros hacia el explorador del proyecto, carpeta
“Descripciones XML y XSD”.
2. “Desplazar” el fichero XML del explorador del proyecto hacia el editor de código. La variable de tipo
xmlDocumentse crea automáticamente de la forma siguiente:
<Nombre de la variable> is xmlDocument, description = <Nombre del documento>
3. Puede ahora acceder directamente a los nudos de la variable para sus nombres. Estos nombres se proponen
automáticamente por el mecanismo de completación automática del editor de código.
Ejemplo práctico
 Abra el ejemplo unitario “Lectura y escritura con formato XML”.
 Una pequeña ventana azul indica que la ventana no está integrada en el proyecto.
 Valide si es necesario la adición al proyecto clicando sobre el botón “Copiar en el directorio del proyecto”.
 Pruebe la ventana “WIN_ManipulacionXML”. Esta ventana permite:

 Crear un fichero XML. Este fichero está creado mediante las funciones XML.

 Leer un fichero XML.
 Consulte el código asociado a cada botón.
No vamos a detallar aquí todas las funcionalidades propuestas por las funciones XML. Para más
Notas
detalles, consulte la ayuda en línea.
Manipulación de los ficheros XLS

Para manipular los ficheros Excel, WINDEV pone a su disposición:
 Las funciones xlsXXX. Estas funciones permiten leer los datos que hay en las distintas hojas de un fichero
Excel.
 Las variables avanzadas de tipo xlsDocument, xlsRow, xlsColumn, xlsCell.
Ejemplos prácticos
¿Una prueba rápida de estas funciones?
 Para probar el uso de las funciones xlsXXX, abra el ejemplo unitario “Funciones Excel”.
 Una pequeña ventana azul indica que la ventana no está integrada en el proyecto
 Clique en el botón “Añadir al proyecto”.
 Valide si hiciera falta la adición al proyecto clicando en el botón “Copiar en el directorio del proyecto”.
 Pruebe la ventana “WIN_FuncionXLS”. Esta ventana permite:
 Importar los datos provenientes de una hoja Excel.
 Exportar los datos de un campo Tabla hacia Excel.
Regrese al editor para consultar el código de los distintos botones.
 Para probar el uso de las variables avanzadas, abra el ejemplo unitario “Tipo xls”.
 Clique en el botón “Añadir al proyecto”.
 Valide si hiciera falta la adición al proyecto clicando en el botón “Copiar en el directorio del proyecto”.
 Pruebe la ventana “WIN_Tipo_xls”.
 Regrese al editor para consultar el código de los distintos botones.
No vamos a detallar aquí todas las funcionalidades propuestas por las funciones XLS y los tipos
Notas
avanzados. Para más detalles, consulte la ayuda en línea.

Lección 6.4. Compilación dinámica
 Presentación
 Trazar una curva en compilación dinámica

Presentación
La compilación dinámica permite compilar un código sin importar el momento de la aplicación. ¿Un ejemplo de uso
corriente? Su aplicación contiene una fórmula parametrizable. Para cambiar los parámetros, no es necesario volver a
liberar el ejecutable: basta con la modificación de un fichero texto.
Ejemplo
Hemos elegido presentarle la compilación dinámica mediante el ejemplo unitario “Compilación dinámica”.
La ventana “Compilación dinámica” muestra como compilar dinámicamente el código WLangage (almacenado en
forma de cadena), ejecutar el procedimiento generado dinámicamente y tratar los eventuales errores de ejecución.
 Para probar esta ventana:

1. Abra el ejemplo unitario “Compilación dinámica”.
2. Una pequeña ventana azul indica que la ventana no está integrada en el proyecto.
3. Lance la prueba de la ventana “WIN_COMPILACION_DINAMICA”.
4. Clique en los distintos botones “Ejecutar” para ver los distintos casos propuestos.
5. Detenga la prueba.
 Volvamos al editor de código para estudiar el código del primer botón “Ejecutar”.
1. Muestre el código del botón “Ejecutar” (clic derecho sobre el botón, opción “Código”). Este código llama al
procedimiento CompileCodiDynamique.
2. Posicione el cursor del ratón sobre el nombre del procedimiento y utilice la tecla [F2]. El código del
procedimiento aparecerá automáticamente en el editor de código.
El código de este procedimiento puede estar descompuesto en varias partes:
a. Inicialización de variables.
b. Compilación del código.
sResultadoCompilacion = Compile (PROCEDURE_DYNAMIQUE, EDT_CODE_COMPIL)
Este código contiene varios puntos a destacar:
 La compilación de la función se efectúa con la función WLangage Compile. Desde que esta función se
utiliza (y si no se reenvía ningún error), la función compilada dinámicamente se vuelve utilizable.

 Esta función admite dos parámetros: el nombre del procedimiento compilado (aquí
“PROCEDURE_DYNAMIQUE”) y el código a compilar. Aquí, el código a compilar está contenido dentro del
campo de edición EDT_CODE_COMPIL.
 El resultado de la compilación afectará a una cadena sResultadoCompilacion.
3. Verificación del resultado de la compilación.

4. Utilice la combinación de teclas [CTRL]+[F2]. El código clic del botón “Ejecutar” reaparece en el editor del código.
En la continuación de este código, podrá ver que la función compilada dinámicamente se ejecuta con la función
Execute.

Lección 6.5. Eventos Windows
 Programación de los eventos de Windows

Introducción
Cualquier acción efectuada por Windows corresponde a un evento Windows. Distintos tipos de eventos pueden
encontrarse, por ejemplo:
 Sobrevolar una ventana con el ratón
 Una parada del sistema
 Mostrar una caja de diálogo
 Un error lógico
 Etc.
Cuando se producen estos eventos, se pueden interceptar para preparar o ejecutar un tratamiento específico.
Por defecto, WINDEV propone la gestión automática de los eventos más utilizados. Por ejemplo, los siguientes
eventos se proponen para un campo de edición:
 Inicialización del campo.
 Entrada en el campo.
 Modificación del campo.
 Salida del campo.
Para gestionar los eventos suplementarios, se puede:

 Utilizar los tratamientos opcionales propuestos por WINDEV.
 Utilizar los eventos de Windows.
Ejemplo práctico
Hemos elegido presentar la gestión de los eventos con el ejemplo unitario “Función Eventos”.
 Abra el ejemplo unitario “Función Eventos”.
 Clique sobre el botón “Añadir al proyecto”
Tratamientos opcionales propuestos por WINDEV

Para cada elementos (ventana, campo, …) WINDEV propone numerosos tratamientos opcionales.
 Para añadir un tratamiento opcional:
1. Muestre los tratamientos ligados al campo Lista que hay en la ventana del ejemplo unitario:
 Seleccione el campo Lista.
 Pulse la tecla [F2].
 El editor de código se muestra.
2. Una barra de herramientas está disponible bajo de la ventana de código:
Esta barra de herramientas presenta los principales tratamientos opcionales disponibles. Para identificar los
tratamientos, pase por encima de los distintos iconos.
3. Para añadir un tratamiento, clique sobre el icono correspondiente. El tratamiento correspondiente se muestra
automáticamente en el editor de código.
4. Para mostrar la lista completa de los tratamientos opcionales disponibles, hay que clicar sobre “…”.

5. Para añadir un tratamiento, hay que marcar la caja correspondiente y validar la ventana. Por ejemplo, añada
el evento “Tecla Pulsada”.
Eventos de Windows
Para la gestión de eventos más “específicos”, existe la función WLangage Event. La función Event permite asociar
un procedimiento WLangage a un evento Windows.
Para utilizar la función Event, hay que dominar la programación Windows y sobre todo los
Notas
eventos Windows.
Para conocer la lista (no exhaustiva) de los eventos de Windows, consulte la ayuda en línea de WINDEV (palabra
clave: “Valor de las constantes del API de Windows”).
Ejercicio: Detectar el clic sobre una lista
 Lance la prueba de la ventana “WIN_Funcion_Eventos”. Esta ventana detecta si la lista está manipulada con el
ratón o con el teclado.
1. Clique sobre el campo Lista con el ratón.
2. Utilice el ratón para desplazar la banda de selección.
3. Un mensaje aparece indicando si se ha utilizado el ratón o el teclado.

4. Detenga la prueba y regrese al editor.
 Observemos el código utilizado:
1. Clique en la ventana.
2. Muestre los tratamientos de la ventana (pulse sobre la tecla [F2]).
3. Examinemos el código de la declaración de las globales de la ventana WIN_Funcion_Eventos”.
 Primero la línea de código:
EXTERNE“WINCONST.WL”
Esta línea de código permite integrar el contenido del fichero WINCONST.WL en el código de la aplicación
mediante la palabra clave EXTERNE. Este fichero contiene la declaración y los valores de las constantes Windows.
En la compilación, todo el código contenido en el fichero WINCONST.WL será integrado automáticamente al
código de la aplicación.
 A continuación, los distintos elementos gestionados se declararán:
// Eventos sobre el campo LISTA_Mes
// Presión de una tecla del teclado
Event (“RatonOTeclado”, LISTA_Mes..NombreCompleto, WM_KEYDOWN)
// Clic izquierdo del ratón
Event (“RatonOTeclado”, LISTA_Mes..NombreCompleto, WMLBUTTONDOWN)
El procedimiento RatonOTeclado se llama cuando se utiliza el teclado sobre la lista (evento Windows
correspondiente: WM_KEYDOWN ) o cuando se utiliza el clic izquierdo del ratón sobre la lista (eventos Windows
correspondiente: WM_LBUTTONDOWN).
4. Muestre el código del procedimiento:
 Ponga el cursor del ratón sobre “RatonOTeclado”.
 Utilice la tecla [F2].
5. El código del procedimiento es muy sencillo:
 Si se utiliza el teclado, el texto mostrado en el campo Lista contiene “Seleccionado con el teclado”.
 Si se utiliza el ratón, el texto mostrado en el campo Lista contiene “Seleccionado con el ratón”.
PROCEDURE RatonOTeclado ()
// La variable _EVE.wMessage contiene el número del mensaje
SWITCH _EVE.wMessage
// este es el teclado
CASE WM_KEYDOWN
//Mensaje que indica el uso del teclado
LIB_TipoSeleccion = “Seleccionado con el teclado”
LIB_TipoSeleccion..Color = LightRed
// este es el ratón
CASE WM_LBUTTONDOWN
// Mensaje que indica el uso del ratón
LIB_TipoSeleccion = “Seleccionado con el ratón”
LIB_TipoSeleccion..Color = LightBlue
END

Lección 6.6. Los hilos
 ¿Qué son los hilos?

Definición
Los hilos permiten ejecutar código (o tratamientos) en paralelo a la aplicación principal. De este modo pueden
ejecutarse tratamientos distintos que pueden ser muy largos como tareas de fondo, sin bloquear la aplicación
principal (llamada también “Hilo principal”).
Los hilos sustituyen a algunos tipos de timer.
Generalmente, un hilo secundario se utiliza para detectar un evento, por ejemplo, una acción del usuario, la recepción
de un email, la recepción de una llamada telefónica, …
Algunos ejemplos de uso de los hilos:
 Recuperación de emails en tareas de fondo, durante la introducción de un nuevo correo.
 Aplicación de comunicación: gestión de las llamadas telefónicas, comunicación por socket, …
Con WINDEV, tiene la posibilidad de:
 Gestionar fácilmente los hilos (funciones Thread*).
 Utilizar las “señales” para sincronizar varios hilos (funciones Signal*)
 Utilizar los hilos con “semáforos” para gestionar los accesos a las recursos compartidos por los distintos hilos
(funciones Semaphore*)
Ejemplo
WINDEV se proporciona en estándar con varios ejemplos unitarios que permiten comprender el
interés y el uso de los hilos:
Ejemplo
 Creación de un Pool de Hilos

 Los hilos
Para más detalles en la gestión de los hilos con WINDEV, consulte la ayuda en línea (palabra clave: “Thread”).

Lección 6.7. Los sockets
 Presentación
 Aplicación Servidor
 Aplicación Cliente

Presentación
WINDEV pone a su disposición funciones que permiten realizar una gestión avanzada de los sockets.
Un socket es un recurso de comunicación utilizado por las aplicaciones para comunicar una máquina con otra sin
preocuparse del tipo de red.
Este modo de comunicación se utiliza para hacer comunicar dos aplicaciones situadas en puestos distintos (enlazados
por Internet o por una misma red local) o en un mismo puesto.
Una aplicación WINDEV puede gestionar los sockets de distintas formas:
 Aplicación WINDEV Cliente: La aplicación se conecta con un servidor cualquiera y cambia los datos por un
socket.
 Aplicación WINDEV, WEBDEV o WINDEV Mobile “Servidor”: La aplicación WINDEV (o WEBDEV o WINDEV
Mobile) es un servidor, cambiando las informaciones por sockets con muchos puestos cliente cualquiera. Para
gestionar varias conexiones simultáneas, es necesario utilizar los hilos.
WINDEV se proporciona en estándar con un ejemplo didáctico que permite comprender el uso de
Ejemplo
los sockets: “Utilización de los sockets”. Este ejemplo es accesible desde la ventana de
bienvenida de WINDEV ([CTRL]+[>]).
Aplicación Servidor: caso de un servidor simplificado

WINDEV ofrece la posibilidad de crear un servidor de sockets simplificado. Este servidor permite comunicar son un
solo puesto cliente simultáneamente. Este tipo de aplicación es muy útil cuando dos aplicaciones distantes tienen la
necesidad de comunicarse.
Los pasos para crear un servidor simplificado son los siguientes:
1. Creación del socket.
2. Intercambio de datos.
3. Cierre del socket.
Creación del socket
Para crear el socket, el puesto servidor utiliza la función SocketCreate. Un socket se asocia a un puerto específico.
Para simplificar la manipulación del socket por programación en el puesto servidor, especifique el nombre del socket.
El puesto cliente se conectará a través de este socket para intercambiar los datos. La conexión entre los dos puestos
será efectivamente realizada en el primer intercambio de datos entre los dos puestos (es decir, a la primera lectura de
informaciones por el puesto servidor).
La conexión se establece al primer éxito de la función SocketRead en el servidor.
Intercambio de datos
Cuando dos puestos utilizan el mismo socket, se establece un flujo de comunicación entre los dos puestos. Entonces
será posible para los dos puestos leer y escribir las cadenas de caracteres en el socket.
Observación: Para no bloquear las aplicaciones, la gestión de recepción de los mensajes se gestiona habitualmente
mediante un hilo específico.
Para leer y escribir en el socket, la aplicación servidor WINDEV debe utilizar las funciones SocketRead y
SocketWrite.
Atención: para realizar una lectura, deberá haberse realizado una escritura.
1. El puesto cliente escribe en el socket: envía una consulta al puesto servidor.
2. El puesto servidor efectúa una lectura en el socket dentro de un hilo. Cuando se recibe un mensaje, el
mensaje es tratado por el puesto servidor.
3. Si se necesita una respuesta al mensaje, el puesto servidor identifica el puesto cliente (función
SocketClientInfo) y le envía una respuesta.
Cierre del socket
Para finalizar la comunicación, el servidor puede cerrar el socket con la función SocketClose.
Observación: el socket también puede cerrarse desde el puesto cliente.

Aplicación Cliente
Una aplicación cliente de un servidor de sockets se conecta a un servidor cualquiera para intercambiar informaciones
con la intermediación de un socket.
Ejemplo: Una aplicación WINDEV puede conectarse a un servidor de noticias estándar en Internet.
Los pasos para crear una aplicación cliente son los siguientes:
1. Conexión al servidor.
2. Intercambio de datos.
3. Fin de comunicación.
Conexión al servidor
Para conectarse a un socket del servidor, hay que utilizar la función SocketConnect. Esta función permite efectuar
una solicitud de conexión al servidor.
El socket se identifica por su puerto y por su dirección.
Intercambio de datos
Cuando dos puestos utilizan el mismo socket, un flujo de comunicación se establece entre estos dos puestos.
Entonces es posible para los dos puestos leer y escribir las cadenas de caracteres en el socket.
Observación: Para no bloquear las aplicaciones, la gestión de recepción de mensajes es generalmente gestionada por
un hilo específico.
Para leer y escribir el socket, la aplicación cliente WINDEV deberá utilizar las funciones SocketRead y
SocketWrite.
Fin de comunicación
Para acabar la comunicación, hay que cerrar el socket desde el puesto cliente con la función SocketClose.
Observación: También es posible finalizar la comunicación desde el puesto servidor.
Ejemplo práctico
Hemos elegido presentarle un caso real de la programación de sockets gracias al ejemplo unitario “Utilización de los
Sockets”.
Prueba del ejemplo
 Abra el ejemplo unitario “Utilización de los sockets”.
 Lance la prueba de la ventana “WIN_Sockets”. Vamos a enviar un mensaje del puesto B al puesto A. El puesto A
es la aplicación Servidor y el puesto B es la aplicación Cliente.
1. En el puesto A, cree el socket clicando sobre el botón “Crear”.
2. El puesto B puede entonces conectarse al socket creado por el puesto A. Bastará con clicar sobre el botón
“Conectar” (en la parte del puesto B).
3. El puesto B envía un mensaje al puesto A:
 Introduzca el mensaje a enviar en la zona “Frase a enviar al puesto A”.
 Clique sobre el botón “Enviar” que hay en la zona “Puesto B”.
4. Para recuperar el mensaje en el puesto A, clique en el botón “Recuperar” en la zona “Puesto A”.
5. Desconecte los dos puestos clicando sobre los botones “Desconectar”.
 Detenga la prueba de la ventana para regresar al editor.
Análisis del código utilizado

 Estudiemos el código de los distintos botones que hemos utilizado.
 Primero vamos a estudiar los tratamientos realizados por el servidor de sockets (puesto A).
1. Muestre el código del botón “Crear” en el puesto A:
 Seleccione el botón “Crear”.
 Muestre los tratamientos pulsando la tecla [F2].
2. En el tratamiento “Clic sobre”, encontraremos la función SocketCreate que permite crear el socket. Cierre el
editor de código.
3. Muestre el código del botón “Recuperar” en la zona del puesto A:
 Seleccione el botón “Recuperar”.
 Muestre los tratamientos pulsando la tecla [F2].
4. En el tratamiento “Clic sobre”, el código utilizado es el siguiente:
EDT_FraseRecogidaDelPuestoB = SocketRead (“PuestoA”, False, 2000)
IF EDT_FraseRecogidaDelPuestoB <> “” THEN
Info (“Mensaje recibido de la dirección I.P. Nº “ + …
SocketClientInfo (“PuestoA”, SocketAddress))
END
Encontramos la función SocketRead que permite leer el socket creado previamente. El mensaje leído es
mostrado inmediatamente en el campo “EDT_FraseRecogidaDelPuestoB”. Cierre el editor de código.
 Estudiemos ahora los tratamientos realizados por el cliente (el puesto B).
1. Muestre el código del botón “Conectar” en la zona Puesto B:
 Seleccione el botón “Conectar”.
 Muestre los tratamientos mediante la tecla [F2].
2. En el tratamiento “Clic sobre”, encontramos la función SocketConnect que permite conectarse en el socket
creado por el puesto A. Cierre el editor de código.
3. Muestre el código del botón “Enviar” en la zona Puesto B:
 Seleccione el botón “Enviar”.
 Muestre los tratamientos mediante la tecla [F2].
4. En el tratamiento “Clic sobre”, el código utilizado es el siguiente:
IF NOT SocketWrite (“ParaPuestoA”, …
EDT_FraseAEnviarAlPuestoA) THEN
Error (ErrorInfo(errMessage))
RETURN
END
Encontramos la función SocketWrite que permite enviar un mensaje al socket sobre el que está conectado el
puesto B. Cierre el editor de código.
Observación: En esta lección, hemos visto una comunicación “simple” entre un servidor y un puesto cliente: el cliente
envía mensajes y el servidor trata los mensajes. Está claro que es posible realizar aplicaciones mucho más elaboradas.
Es posible realizar una comunicación entre dos aplicaciones, a la vez cliente y servidor. En este caso, la gestión de los
hilos se convierte en primordial para gestionar los envíos y las respuestas de las aplicaciones.

Lección 6.8. El FTP
 Presentación de las funciones FTP de WINDEV

Presentación
El FTP (File Transfer Protocol) es un protocolo estándar que permite efectuar la transferencia de ficheros de una
máquina hacia otra máquina. Una de las dos máquinas deberá ser un servidor FTP.
WLangage tiene los comandos de programación necesarios para efectuar las transferencias de ficheros utilizando este
protocolo con un servidor. Estas funciones de programación comienzan todas por “FTP”.
WINDEV solo propone las funciones “clientes” para el FTP. Es necesario utilizar un servidor FTP estándar.
Hemos elegido presentarle un caso real de la manipulación de ficheros en un servidor FTP, utilizando el ejemplo
unitario “Las funciones FTP”.
 Abra el ejemplo unitario “Las funciones FTP”. Este ejemplo presenta las principales funcionalidades utilizables en
un servidor FTP.
Conectarse a un servidor FTP

La función FTPConnect permite conectarse a un servidor FTP. Deberá previamente tener una cuenta FTP (Nombre
de usuario y contraseña) para acceder a un servidor FTP.
 En la ventana “WIN_FTP”, muestre el código del botón “Conexión”:

1. Seleccione el botón “Conexión”.
2. Utilice la tecla [F2] para mostrar el código asociado:
// 1 – Dirección FTP: Corresponde al sitio FTP
// donde la aplicación deberá conectarse. Ex: 192.108.10.2
sDireccionFTP is string = ftp.pcsoft.fr
// 2 – Nombre del usuario: si este nombre no se utiliza,
// se utilizará una conexión de tipo “anonymous”.
sNombreUsuario is string = “”
// 3- Contraseña del usuario:
// utilizada solamente si la conexión no es anónima
sMDPUsuario is string = “”
// Conexión al servidor FTP
gnIdConexion = FTPConnect (sDireccionFTP, sNombreUsuario, sMDPUsuario)
IF ErrorOccurred THEN
// Se ha encontrado un error durante la conexión
Error (“La conexión al servidor FTP: “ + sDireccionFTP +” ha fallado “, ErrorInfo ())
RETURN
END
// Se ha establecido la conexión
Info (“La conexión al servidor FTP se ha establecido”, …
“ Identificador de la conexión: “ + gnIDConexion)
Observación: También es posible precisar el número de puerto de la conexión del servidor FTP (por defecto “21”) así
como el modo de conexión (“Verdadero” para una conexión llamada “Pasiva”, “Falso” para una conexión llamada
“activa”). Para más detalles, consulte la ayuda en línea (palabra clave: “FTP, Funciones”).
Enviar un fichero
Para enviar un fichero hacia un servidor FTP, basta con utilizar la función FTPSend.
Este es un ejemplo del código que puede utilizarse:
// Al realizar la conexión al servidor mediante FTPConnect, hemos

// recuperado el número de la conexión en la variable gnIdConexion
// Transferencia del fichero “C:\MisDocumentos\Fichero.DOC” hacia
// el directorio “Temp” que es encuentra en el servidor.
bResultado is boolean = FTPSend (gnIdConexion,”C:\MisDocumentos\Fichero.DOC”, “/Temp”
Preste mucha atención a la escritura (minúsculas, mayúsculas) del nombre de los directorios en
el servidor. En efecto, algunos servidores FTP son máquinas bajo UNIX y son “case-sensitives”,
es decir, que son sensibles a mayúsculas/minúsculas del nombre de los ficheros y los directorios.
Atención ¡
Por ejemplo, en el servidor FTP se encuentra un directorio llamado “MiDirectorio”. Si intenta

acceder al directorio “midirectorio”, el servidor FTP podrá devolver un error de tipo “Camino
inexistente” porque las mayúsculas/minúsculas no son las correctas.
Listar los ficheros presentes en un servidor FTP

La función FTPListFile permite listar los ficheros existentes en un servidor FTP. Esta función utiliza un procedimiento
del tipo “callback”. Para cada fichero o directorio encontrado, se ejecuta el procedimiento.
 En la ventana “WIN_FTP”, muestre el código del botón “Listar”:
1. Seleccione el botón “Listar”.
FTPListFile (gnIdConexion, “*.*”, “CallBackFTPListFile”, ftpFile + ftpDirectory)

// Verificación de la ejecución de la función
Error (“Error buscando los ficheros existentes en el servidor TFP”, ErrorInfo())
RETURN
END
3. En este ejemplo, el procedimiento llamado permite mostrar en una ventana de trace los ficheros encontrados:
PROCEDURE CallBackFTPListFile (sNombreFichero, nTamañoFichero <útil>, sAtributo, sFechaModif <útil>,

sHoraModif <útil>)
// Es un fichero o un directorio
IF sAtributo = “D” THEN
// Directorio o subdirectorio
Trace (“Directorio: “ + sNombreFichero)
ELSE
// Fichero
Trace (“Fichero: “ + sNombreFichero)
END
// Continua buscando ficheros

RETURN True

Recuperar un fichero
Para recuperar un fichero desde un servidor FTP en su máquina, basta con utilizar la función FTPGet-
Este es un ejemplo del código que puede utilizarse:
// Al realizar la conexión al servidor mediante FTPConnect, hemos recuperado el número

// de la conexión en la variable gnIdConexion
// Recuperación del fichero FTP hacia el directorio “d:\Temp” en el puesto en curso
bRes is boolean = “FTPGet (gnIdConexion, “/Document/Fichero.DOC”, “D:\Temp”)
Desconectarse de un servidor FTP

Para desconectarse de un servidor FTP, utilice la función FTPDisconnect.
 En la ventana “WIN_FTP”, muestre el código del botón “Desconexión”:
1. Seleccione el botón “Desconexión”.
IF YesNo (No, “Desea cortar la conexión al servidor FTP?”) = Yes THEN

// Desconexión del servidor FTP
FTPDisconnect (gnIdConexion)
// Error al cerrar la conexión
Error (“Imposible cerrar la conexión FTP”, ErrorInfom())
RETURN
END
// Ha finalizado la conexión
Info (“Ha finalizado la conexión con el servidor FTP”)
END
También hay otras funciones FTP que no vamos a detallar en este curso; con ellas se puede:
 Crear, suprimir, modificar los directorios en el servidor FTP
 Crear, suprimir, modificar los ficheros en el servidor FTP
 Recuperar informaciones de un directorio y/o de un fichero
 …
Para más detalles, consulte la ayuda en línea (palabra clave: “FTP, Funciones”).

Lección 6.9. La POO (Programación Orientada
a Objetos)
 Conceptos de la programación orientada a objetos.
 Ejemplos de declaración de objeto.
 Modelo UML asociado

Conceptos
La Programación Orientada a Objetos (P.O.O.) tiene por objetivo una mejor reutilización del código. Los programas
desarrollados en POO están estructurados: se descomponen en módulos gestionando cada uno una funcionalidad del
software. Los módulos desarrollados pueden ser fácilmente reutilizados en otros softwares. Van a agrupar un
conjunto de procedimientos (llamados métodos) y encapsular la estructura de datos sobre la que van a actuar los
métodos.
Para programar “en objeto”, hay que declarar las clases, los miembros y los métodos asociados.
Las clases
Una clase reúne la descripción de una estructura de datos (los miembros) y los procedimientos (métodos) que
manipulan a los miembros.
Una clase define pues un tipo de datos y su comportamiento.
Los objetos
Una clase permite crear objetos. Cada objeto creado posee miembros descritos en su clase y puede manipularse
mediante los métodos de su clase. Se dice que un objeto es una instancia de la clase.
Cuando se declara la clase, basta con asociar un objeto a una clase para que el objeto pueda manipularse por todos
los métodos de esta clase.
Los miembros
Un miembro es un dato (o parámetro) del objeto
Los métodos
Un método permite actuar sobre el objeto, para modificar sus miembros, por ejemplo.
Un método es un procedimiento. Su funcionamiento es idéntico al de los procedimientos clásicos de WLangage.
Noción de herencia
La herencia permite incluir características de una clase existente (clase de base) en una nueva clase (clase derivada).
La herencia permite crear un nuevo tipo de datos a partir de un tipo conocido, con el objetivo de añadirle sus
funcionalidades o modificar el comportamiento. La clase de base no se modificará. Una clase puede heredar de una
clase y se convierte en sub-clase.
Una clase derivada permite a sus objetos acceder a todos los métodos, a todos los miembros y a todas las
propiedades de sus clases ancestro; es como si los métodos, los miembros y las propiedades de las clases ancestro
formasen parte de la clase derivada.
Constructor y Destructor
La noción de Constructor y Destructor es importante porque permite una llamada automática de métodos de
iniciación durante la creación de un objeto y durante su destrucción.
El método Constructor asociado a una clase se llama automáticamente con la declaración de un objeto de la clase.
El método Destructor asociado a una clase se llama automáticamente cuando se suprime el objeto (salida del
procedimiento en el que el objeto se ha declarado).
Encapsulación de datos
La encapsulación de datos permite garantizar que los datos miembro del objeto no serán modificados erróneamente
por funciones (métodos) exteriores al objeto.
Así se puede prohibir al usuario de un objeto el acceso a algunos o a todos sus miembros. Los miembro que tienen el
acceso prohibido se llaman miembros privados.
No es posible acceder a los miembros privados más que a partir de métodos previos a este efecto en la clase.
Ejemplo
Tomemos un ejemplo sencillo para aplicar los conceptos que acabamos de ver:
 Consideremos la clase PERSONA
 Florencio es una instancia de la clase PERSONA
 El nombre, el apellido, y la fecha de nacimiento pueden ser miembros de la clase PERSONA.
 El método Edad() puede ser un método de la clase PERSONA. Calculará la edad basándose en el miembro
“fecha de nacimiento” y la fecha del día (reenviada por la función DateSys).
 Herencia: Un contacto puede ser una persona o una empresa.
o PERSONA podría ser una clase derivada de CONTACTO
o EMPRESA podría ser una clase derivada de CONTACTO
Crear un programa orientado a objeto
Para crear un programa en objeto en WLangage, hay que:
1. Describir la clase y los miembros de la clase.
2. Dar todos los métodos de la clase.
3. Declarar los objetos asociándolos a una clase (“Instanciar un clase”).
Ejemplo simple
 Para ilustrar los conceptos que acabamos de presentar, vamos a manipular el ejemplo didáctico “WD POO
Simple”.
1. Abra el ejemplo didáctico “WD POO Simple”.
2. Pruebe este ejemplo.
3. Clique sobre los distintos botones correspondientes a los animales para añadir los animales.
4. Detenga la prueba del ejemplo para volver al editor.
Observación: No vamos a detallar aquí la sintaxis de la P.O.O., únicamente presentaremos un ejemplo simple de un
programa orientado al objeto. Para tener más detalles sobre la sintaxis P.O.O., consulte la ayuda en línea (palabra
clave: “POO, Clase”).
Declarar una clase
 WINDEV permite declarar las clases muy sencillamente desde el explorador del proyecto. Para crear una clase:
1. En el explorador del proyecto, seleccione la carpeta “Clases”.
2. Muestre el menú contextual de esta carpeta (clic derecho del ratón) y seleccione la opción “Nueva Clase”.
3. En la ventana que se muestra, indique el nombre de la clase (por ejemplo TestGAF) y valide.
4. El código de la clase se muestra en el editor de código.
 Consulte el código de la clase cSavane utilizada en el ejemplo.

1. En el explorador del proyecto, seleccione la carpeta “Clases”.
2. Abra la carpeta “Clases” (clicando en la flecha que hay delante del nombre de la carpeta).
3. Doble clic sobre la clase cSavane.
4. El código de la clase se muestra en el editor de código. El código de declaración de la clase es de la forma:
cSavane is class
PRIVATE
// Nombre del campo Imagen utilizado para el dibujo
m_sNombreCampoImagenParaDibujo is string
// Lista de los animales de la sabana
m_tabLosAnimales is array de cAnimal dynamique
END
“cSavane” es el nombre de la clase

“m_sNombreCampoImagenParaDibujo” y “m_tabLosAnimales” son los miembros de la clase.
La palabra clave “PRIVATE” permite indicar que estos miembros solo podrán manipularse desde un código de la
propia clase o de una clase derivada.
Describir los métodos
 WINDEV permite declarar las clases muy sencillamente desde el explorador del proyecto. Para crear un método:
1. Clique con el botón derecho del ratón en su clase presente en el explorador del proyecto.
2. Elija “Nuevo método” en el menú contextual.
3. En la ventana que se muestra, indique el nombre del método y valide.
4. Introduzca el código del método en el editor de código.
 Para mostrar el método AñadeAnimal de la clase cSavane:

1. Clique co el ratón sobre su clase presente en el explorador del proyecto.
2. Clique sobre la pequeña flecha delante del nombre de la clase: los distintos métodos de la clase se mostrarán.
3. Doble clic sobre el nombre del método:
PROCEDURE AñadeAnimal (pcclUnAnimal is cAnimal dynamique)

// no más de 5 animales
IF m_tabLosAnimales..Occurrence = 5 THEN
Error (“No más de 5 animales!”)
RETURN False
END
// Añade el animal a la lista

Add (m_tabLosAnimales, pclUnAnimal)
// Dibuja la sabana
DibujaSabana()
RETURN True
Describir los métodos

En los tratamientos de la ventana, un objeto se declara al mismo tiempo que las otras variables:
// Declaraciones globales de WIN_POO

PROCEDURE WIN_POO ()
// Objeto savane
gclLaSavane is cSavane (IMG_Landscape..FullName)
Para referenciar a un miembro del objeto “cSavane”, hay que utilizar la sintaxis:
<NombreObjeto>.<Nombre del miembro>
 En nuestro ejemplo, el objeto se manipula:

 Cuando se inicializa la ventana, para construir la sabana.
// Dibuja la sabana
gclLaSavane.DibujaSabana()
 Cuando se crea un animal para colocarlo en la sabana
// Declara un nuevo elefante
clElefante is cElefante (“Elefante “ + GetIdentifier (), 13)
// Añade el elefante en la sabana (esta acción provoca el refresco del dibujo)
IF gclLaSavane.AñadeAnimal (clElefante) THEN
// Mensaje de fin
ToastDisplay (“Animal añadido”, toastShort, vaMiddle, haCenter)
END
No vamos a detenernos más en la presentación de la POO en este curso.
Diagrama UML
El ejemplo “WD POO Simple” está asociado a un diagrama UML.
 Para mostrar el diagrama UML enlazado al proyecto:
1. Doble clic sobre “ModeloUML” en el explorador del proyecto:
2. Se mostrará el diagrama UML (diagrama de clases) ligado al proyecto.
3. En este diagrama, encontraremos las distintas clases utilizadas por el proyecto “WD POO Simple”.

WINDEV permite crear los 9 tipos de diagramas UML.
Para crear un diagrama UML:
1. En el panel “Inicio”, dentro del grupo “General”, clique en “Nuevo”.
2. Se muestra la ventana de creación de un nuevo elemento: clique sobre “Arquitectura” y
luego sobre “UML”.
3. El asistente de creación de un modelo UML se lanza, permitiendo elegir el modelo a
crear:
Notas
No vamos a detallar más sobre el uso del lenguaje UML con WINDEV. Consulte la ayuda en línea para más
información (palabra clave: “UML”).

Conclusión
El curso ha terminado!
Este curso ha abordado un conjunto de sujetos, pero no la totalidad de funcionalidades de WINDEV, nada más lejos!
Usted está ahora familiarizado con los principales conceptos.
Explore igualmente los ejemplos suministrados con WINDEV: Algunos son sencillos y no tratan más que un sujeto,
otros son más completos. Estos ejemplos le mostrarán las distintas facetas de WINDEV. La lectura del código fuente
será igualmente instructiva en general.
Por falta de sitio, no hemos podido abordar todos los sujetos (hay centenares, incluso millares!). WINDEV ofrece
numerosas posibilidades no abordadas o no profundizadas en este curso:
 Funciones HTTP, telefonía
 Creación de plantillas, …
 Informes anidados, consultas parametrizadas,
 Compilación dinámica, llamadas de DLL, lenguajes externos, …
Para más detalles sobre todas estas posibilidades, no dude en consultar la ayuda en línea.
Recuerde: para recibir directamente las actualizaciones intermedias y consejos de uso, abónese a la LST (Revista
trimestral + DVD) en francés.
Le deseamos felices desarrollos, con WINDEV 21, AGL nº 1 en Francia!

Auto-Formación WINDEV 21

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Auto-Formación WINDEV 21

Cargado por

Copyright:

Formatos disponibles

Introducción |1

Dirección de Soporte técnico gratuito:

Presentación del curso de auto-formación

directamente en el menú de WINDEV: en el panel “Inicio”, en el grupo “Ayuda en línea”, despliegue

¿Cómo acceder a la ayuda en línea?

 En un navegador Internet, si tiene acceso a Internet:

Cada internauta puede añadir comentarios en las páginas de documentación: explicaciones

Para lanzar directamente la ayuda en línea de Internet desde el producto:

Leyenda de los símbolos

Este símbolo presenta una “Advertencia”: la lectura del texto es primordial.

Este símbolo presenta una “Nota”: la lectura del texto es aconsejable.

Capítulo 1 – Descubriendo WINDEV |18

Tiempo estimado: 5 min

Capítulo 1 – Descubriendo WINDEV |19

Capítulo 1 – Descubriendo WINDEV |20

Los distintos elementos de la cinta

Capítulo 1 – Descubriendo WINDEV |21

La zona de los paneles

La zona de las opciones

Capítulo 1 – Descubriendo WINDEV |22

Tiempo estimado: 30 min

Capítulo 1 – Descubriendo WINDEV |23

directamente en las ventanas mediante los campos, los botones, …

Primeras Ventanas” es un proyecto vacío, ya creado. La creación de un proyecto, se abordará en una

“Mis Primeras Ventanas (Corregido)”.

Mi primera ventana: Introducir y mostrar los datos

Capítulo 1 – Descubriendo WINDEV |24

1. Clique sobre en los botones de acceso rápido del menú de WINDEV

5. Valide. La ventana se crea automáticamente en el editor.

 Una ventana empieza por “WIN_”

 Introduzca las siguientes informaciones:

1. El nombre “lógico” de la ventana: sustituya “WIN_SinNombre1” por “WIN_Introducción”.

 Valide clicando sobre el botón verde.

Se muestra la lista de campos de entrada propuestos por defecto.

Capítulo 1 – Descubriendo WINDEV |26

 En la barra de mensajes del editor:

Capítulo 1 – Descubriendo WINDEV |27

WLangage es un lenguaje de programación suministrado con WINDEV. Es un lenguaje de quinta

generación (L5G), que posee órdenes evolucionadas.

1. Seleccione con la ayuda del ratón el botón “Mostrar”.

 Las funciones de WLangage aparecen en azul

mostrar en una ventana creada con WINDEV.

 Vamos a guardar la ventana y probarla:

Capítulo 1 – Descubriendo WINDEV |28

2. Clique sobre en los botones de acceso rápido (o utilice la tecla [F9].

Profundizaremos en los consejos de interface y de ergonomía en un próximo capítulo de este curso.

 Para visualizar el resultado en ejecución, vuelva a lanzar la prueba de esta ventana.

WINDEV propone la gestión de una máscara de introducción para un campo. La máscara de

 Para modificar la máscara de entrada:

Capítulo 1 – Descubriendo WINDEV |29

Un ejemplo para cada tipo de campos.

3. La lista de ejemplos completos, didácticos y unitarios se muestra.

Capítulo 1 – Descubriendo WINDEV |30

Tiempo estimado: 30 min

Capítulo 1 – Descubriendo WINDEV |31

 En la ventana de bienvenida, clique sobre “Curso de auto-formación” y seleccione el proyecto

Gestionar la introducción de un numérico para hacer un cálculo

Capítulo 1 – Descubriendo WINDEV |32

o Proponer el nombre de los campos automáticamente en el código.

 Para crear el campo de edición correspondiente al precio HT:

1. Clique sobre en los botones de acceso rápido.

3. Cierre la ventana de texto.

Capítulo 1 – Descubriendo WINDEV |33

4. Muestre la pantalla siguiente.