ManualDElphi1 1 PDF

Universidad del Caribe
Contenido
INTRODUCCIÓN.................................................................................................................7
INTRODUCCIÓN A DELPHI ........................................................................................... 8

INTRODUCCIÓN A DELPHI.............................................................................................................. 9
CARACTERÍSTICAS DE DELPHI........................................................................................................9
VERSIONES DE DELPHI................................................................................................................. 9
La versión Standard.........................................................................................................9
La versión profesional....................................................................................................10
La versión Enterprise.....................................................................................................10
INICIALIZACIÓN DE DELPHI..........................................................................................................10
AMBIENTE DE DELPHI................................................................................................................ 10
Ventana Principal.......................................................................................................... 11
Menú de acceso directo..................................................................................................14
El Inspector de Objeto................................................................................................... 15
Diseñador de Formulario.............................................................................................. 16
Editor de Código...........................................................................................................17
Configuración del ambiente de trabajo......................................................................... 18
Instalación de herramientas...........................................................................................19
RESUMEN DE LOS ELEMENTOS DEL AMBIENTE................................................................................. 21
PROYECTOS, UNIDADES Y FORMULARIOS............................................................22
INTRODUCCIÓN A LOS PROYECTOS................................................................................................. 23
PARTES DE UN PROYECTO............................................................................................................23
Unidad............................................................................................................................23
Formulario.....................................................................................................................23
PROJECT MANAGER.....................................................................................................................25
Opciones para manejo de archivos (File)......................................................................26
OPCIONES DEL PROYECTO............................................................................................................27
Forms............................................................................................................................. 27
Application.....................................................................................................................28
Compiler.........................................................................................................................29
Linker............................................................................................................................. 29
Directories / Conditionals..............................................................................................30
Version Info....................................................................................................................31
Packages........................................................................................................................ 32
Compilación y Encadenamiento.................................................................................... 33
RESUMEN DE PROYECTOS, UNIDADES Y FORMULARIOS....................................................................35
DISEÑADOR DE FORMULARIO...................................................................................36
INTRODUCCIÓN ......................................................................................................................... 37
DISEÑO DE LA INTERFASE VISUAL DEL USUARIO.............................................................................. 37
CONFIGURACIÓN DEL DISEÑADOR DE FORMULARIO...........................................................................37
Autor: José Uribe Página 1
COMPONENTE............................................................................................................................38
TIPOS DE COMPONENTES..............................................................................................................38
Visibles ..........................................................................................................................39
No Visibles .................................................................................................................... 39
COLOCANDO COMPONENTES EN LA FORMA ...................................................................................39
MANIPULACIÓN DE COMPONENTES .............................................................................................. 40
Selección de componentes..............................................................................................40
Formas para seleccionar componentes......................................................................... 41
Moviendo los Componentes .......................................................................................... 41
Cambiándole el Tamaño a los Componentes ................................................................42
Borrando Componentes ................................................................................................ 43
CREACIÓN DE UN FORMULARIO SIMPLE.......................................................................................... 43
Colocación de los componentes en el formulario..........................................................43
USO DEL INSPECTOR DE OBJETO PARA CAMBIAR PROPIEDADES............................................................44
Propiedades....................................................................................................................44
Tipos de propiedades..................................................................................................... 44
LA PROPIEDAD NAME.................................................................................................................47
SINTAXIS PARA LA MANIPULACIÓN DE PROPIEDADES POR PROGRAMACIÓN............................................ 48
USO DEL INSPECTOR DE OBJETO PARA CAMBIAR PROPIEDADES............................................................48
PROGRAMACIÓN DE EVENTOS....................................................................................................... 50
Eventos...........................................................................................................................50
Tipos de eventos.............................................................................................................50
Manejadores de eventos.................................................................................................50
USO DEL INSPECTOR DE OBJETO PARA PROGRAMAR EVENTOS............................................................. 50
RESUMEN DEL DISEÑADOR DE FORMULARIOS..................................................................................53
INTERACTUANDO CON LOS COMPONENTES........................................................54
INTRODUCCIÓN AL DISEÑO DE FORMULARIO.................................................................................... 55
CREACIÓN DE BARRA DE HERRAMIENTAS Y BARRAS DE ESTADO......................................................... 55
COMPONENTE PAGECONTROL......................................................................................................56
Agregando paginas........................................................................................................ 56
Componente ScrollBox...................................................................................................57
COMPONENTES DE CAJA DE DIALOGO.............................................................................................58
Cambiando el tipo de letra y el color.............................................................................58
COMPONENTES DEL SISTEMA....................................................................................................... 59
USO DE LOS COMPONENTES SAMPLES............................................................................................60
Método............................................................................................................................61
RESUMEN DE INTERACTUANDO CON LOS COMPONENTES....................................................................63
CREACIÓN DE MENÚ..................................................................................................... 64
INTRODUCCIÓN A LA CREACIÓN DE MENÚS......................................................................................65
DISEÑADOR DE MENÚS................................................................................................................65
Como abrir el diseñador de menú..................................................................................66
Punto de Inserción......................................................................................................... 66
Como Crear un Separador.............................................................................................67

Submenu.........................................................................................................................68
Interruptores.................................................................................................................. 68
Teclas de acceso directo................................................................................................ 69
COMPONENTE MAINMENU .........................................................................................................69
COMPONENTE POPUPMENU........................................................................................................69
CONEXIÓN DE LOS MENÚS.......................................................................................................... 70
PRACTICA: CREACIÓN DE UN MENÚ PRINCIPAL................................................................................70
APERTURA DE UN FORMULARIO DESDE EL MENÚ..............................................................................74
Métodos para manipular formularios............................................................................74
La cláusula Uses............................................................................................................ 75
Apertura de un formulario de la lista Auto-Create forms .............................................76
Apertura de un formulario de la lista Available forms .................................................77
Método para destruir un formulario..............................................................................78
RESUMEN DE CREACIÓN DE MENÚS................................................................................................79
LENGUAJE OBJECT PASCAL.......................................................................................80
LENGUAJE PASCAL .........................................................................................................81
Breve Historia ...............................................................................................................81
ESTRUCTURA DE UN PROGRAMA EN OBJECT PASCAL....................................................................... 81
Encabezado del programa............................................................................................. 81
Sentencia........................................................................................................................ 81
El punto y coma, y el punto............................................................................................82
Operadores.....................................................................................................................83
Asignación vs. Igualdad.................................................................................................83
Operadores aritméticos..................................................................................................83
Operadores lógicos........................................................................................................84
Operadores relacionales................................................................................................84
Precedencia de operadores y orden de evaluación....................................................... 84
Bloque del programa......................................................................................................84
INTRODUCCIÓN A LAS UNIDADES...................................................................................................85
DECLARACIÓN DE CONSTANTES Y VARIABLES..................................................................................86
Tipos de datos................................................................................................................ 87
Identificadores................................................................................................................88
Conversión de tipos (cast)..............................................................................................89
ESTRUCTURAS DE CONTROL........................................................................................................ 89
IF ... THEN ... ELSE ......................................................................................................89
CASE <x> OF ...............................................................................................................90
Estructuras de Repetición.............................................................................................. 90
FOR ... DO..................................................................................................................... 90
WHILE ... DO.................................................................................................................91
REPEAT... UNTIL..........................................................................................................91
FUNCIONES Y PROCEDIMIENTOS.................................................................................................... 92
RESUMEN DEL LENGUAJE OBJECT PASCAL.................................................................................... 93
MANEJO DE ERRORES EN DELPHI............................................................................94

INTRODUCCIÓN AL MANEJO DE ERRORES EN TIEMPO DE EJECUCIÓN .................................................... 95
MANEJO DE ERRORES CON EXCEPCIONES........................................................................................ 95
SINTAXIS PARA LA CAPTURA DE EXCEPCIONES.................................................................................95
TRY ... FINALLY........................................................................................................................ 95
Protección de recursos...................................................................................................96
Operador de Encapsulación.......................................................................................... 97
TRY ... EXCEPT..........................................................................................................................98
FUNCIONAMIENTO DEL BLOQUE TRY.. EXCEPT ............................................................................... 99
RESUMEN DEL MANEJO DE ERRORES EN DELPHI.............................................................................. 99
BORLAND DATABASE ENGINE................................................................................. 100
INTRODUCCIÓN AL BORLAND DATABASE ENGINE......................................................................... 101
BDE ADMINISTRATOR.............................................................................................................101
ALIAS DE BASE DE DATOS.........................................................................................................103
CREACIÓN DE UN ALIAS............................................................................................................ 104
Configuración de los parámetros.................................................................................105
RESUMEN DEL BORLAND DATABASE ENGINE...............................................................................107
EL DATABASE DESKTOP............................................................................................108
INTRODUCCIÓN AL MANEJO DE BASE DE DATOS..............................................................................109
CONFIGURACIÓN DEL DATABASE DESKTOP................................................................................. 111
Configurando el directorio de trabajo.........................................................................111
Configurando el directorio privado.............................................................................111
CREACIÓN DE TABLAS...............................................................................................................112
TABLAS DBF.........................................................................................................................112
Opciones del Diseñador de tablas para dBase............................................................113
Creación de índices a la tabla..................................................................................... 114
MANIPULACIÓN DE LOS DATOS...................................................................................................115
Entrada y edición de datos...........................................................................................115
Vista de los datos......................................................................................................... 115
Fijación de Columna....................................................................................................116
PRACTICA: CREACIÓN DE TABLA UTILIZANDO EL DATABASE DESKTOP............................................ 117
RESUMEN DEL DATABASE DESKTOP.......................................................................................... 120
APLICACIONES CON BASE DE DATOS................................................................... 121
CONEXIÓN A BASE DE DATOS EN DELPHI..................................................................................... 122
CREACIÓN DE UN FORMULARIO SIMPLE UTILIZANDO BASE DE DATOS................................................. 122
Forma Manual............................................................................................................ 123
Drag and Drop.............................................................................................................129
CREACIÓN DE UN FORMULARIO MASTER / DETAIL........................................................................ 134
Componente DBGrid....................................................................................................136
RESUMEN DE APLICACIONES CON BASE DE DATOS......................................................................... 139

USO DEL FORM WIZARD PARA CREAR APLICACIONES CON BASE DE

DATOS...............................................................................................................................140
INTRODUCCIÓN AL FORM WIZARD ..............................................................................................141
USO DEL FORM WIZARD.......................................................................................................... 141
CREACIÓN DE UN FORMULARIO SIMPLE UTILIZANDO EL DATABASE FORM WIZARD.............................142
CREACIÓN DE UN FORMULARIO MAESTRO / DETALLE UTILIZANDO EL DATABASE FORM WIZARD.........148
TRABAJANDO CON LOS CAMPOS DE LA TABLA................................................158
INTRODUCCIÓN AL MANEJO DE CAMPOS........................................................................................159
TIPOS DE COMPONENTES TFIELD...............................................................................................159
USO DEL EDITOR DE CAMPOS..................................................................................................... 160
PROPIEDADES MAS COMUNES DE LOS COMPONENTES TFIELD ..........................................................163
EVENTOS DE LOS COMPONENTES TFIELD .................................................................................... 163
FORMATEANDO LOS CAMPOS CON LA PROPIEDAD EDITMASK...........................................................163
FORMAS DE ACCESO POR CÓDIGO DE PROGRAMACIÓN AL CAMPO DE UNA TABLA................................. 164
CREACIÓN DE UN CAMPO CALCULADO..........................................................................................165
CREACIÓN DE UN CAMPO LOOKUP............................................................................................... 166
PRACTICA: DE MANEJO DE CAMPO...............................................................................................167
Búsqueda de una descripción en otra tabla.................................................................167
Validación para que un programa no permita introducir una clave repetida............170
TÓPICOS AVANZADOS DE FORMULARIOS CON BASE DE DATOS................172
Introducción.................................................................................................................172
CONSTRUCCIÓN DE LAS TABLAS PARA NUESTRO TUTORIAL.............................................................. 172
BÚSQUEDA DE REGISTRO EN UNA TABLA...................................................................................... 176
Uso del evento OnExit del DBEdit para buscar un registro........................................176
Uso del evento OnCalcFields del Table para buscar un registro............................... 177
Uso del evento OnCalcFields del Table para hacer cálculos......................................178
CREACIÓN DE REPORTES UTILIZANDO QUICKREPORT................................180
INTRODUCCIÓN A LA CREACIÓN DE REPORTES UTILIZANDO QUICKREPORT......................................... 181
TIPOS DE BANDAS.................................................................................................................... 182
VENTANA DE CONFIGURACIÓN...................................................................................................183
FUENTE DE LOS DATOS.............................................................................................................184
INFORMACIONES FIJAS EN EL REPORTE..........................................................................................185
DATOS DEL REPORTE .............................................................................................................. 186
CAMPOS DE TOTALES GENERALES EN EL REPORTE..........................................................................188
USO DEL FORM WIZARD PARA CREAR APLICACIONES CON BASE DE
DATOS...............................................................................................................................189
INTRODUCCIÓN AL FORM WIZARD..............................................................................................190
USO DEL FORM WIZARD.......................................................................................................... 190
CREACIÓN DE UN FORMULARIO SIMPLE UTILIZANDO EL DATABASE FORM WIZARD.............................191
CREACIÓN DE UN FORMULARIO MAESTRO / DETALLE UTILIZANDO EL DATABASE FORM WIZARD.........197
TRABAJANDO CON LOS CAMPOS DE LA TABLA................................................207

INTRODUCCIÓN AL MANEJO DE CAMPOS........................................................................................208
TIPOS DE COMPONENTES TFIELD...............................................................................................208
USO DEL EDITOR DE CAMPOS..................................................................................................... 209
PROPIEDADES MAS COMUNES DE LOS COMPONENTES TFIELD ..........................................................212
EVENTOS DE LOS COMPONENTES TFIELD .................................................................................... 213
FORMATEANDO LOS CAMPOS CON LA PROPIEDAD EDITMASK...........................................................213
FORMAS DE ACCESO POR CÓDIGO DE PROGRAMACIÓN AL CAMPO DE UNA TABLA................................. 214
CREACIÓN DE UN CAMPO CALCULADO..........................................................................................215
CREACIÓN DE UN CAMPO LOOKUP............................................................................................... 216
PRACTICA: DE MANEJO DE CAMPO...............................................................................................217
Búsqueda de una descripción en otra tabla.................................................................217
Validación para que un programa no permita introducir una clave repetida............220
CREACIÓN DE REPORTES UTILIZANDO QUICKREPORT................................222
INTRODUCCIÓN A LA CREACIÓN DE REPORTES UTILIZANDO QUICKREPORT......................................... 223
TIPOS DE BANDAS.................................................................................................................... 224
VENTANA DE CONFIGURACIÓN...................................................................................................225
FUENTE DE LOS DATOS.............................................................................................................226
INFORMACIONES FIJAS EN EL REPORTE..........................................................................................227
DATOS DEL REPORTE .............................................................................................................. 228
CAMPOS DE TOTALES GENERALES EN EL REPORTE..........................................................................230
BIBLIOGRAFÍA...............................................................................................................231

Introducción
Delphi es la vía más poderosa para crear aplicaciones de propósito general bajo Windows.
Mientras que muchos piensan que es la mejor herramienta para crear aplicaciones cliente /
servidor, es también un magnifico ambiente para crear aplicaciones de propósito mas
general que no están basadas en base de datos. Usted puede crear un paquete de hoja de
calculo o un procesador de palabras.
Este material fue diseñado para que el estudiante aprenda los conceptos básicos, el
funcionamiento, las herramientas de esta poderosa herramienta de programación visual
como lo es Delphi. Para el máximo aprovechamiento de este curso el estudiante deberá
tener una mínima experiencia en programación, y que se esta familiarizado con conceptos
como ciclos, estructuras de decisión, el conocimiento del sistema operativo Windows.
Al finalizar el modulo el estudiante estará en capacidad de identificar todos los

componentes, configurar el ambiente de trabajo de Delphi, así como desarrollar cualquier
aplicación de propósito general o particular utilizando Delphi.

Introducción a Delphi
 Características de Delphi
 Versiones
 Ambiente o entorno de Trabajo
 Configuración del Ambiente
 Instalación de herramientas

Introducción a Delphi
Delphi es un entorno de Programación visual orientado a objetos para desarrollo rápido de

aplicaciones (RAD) de propósito general o particular para Windows. Mientras es
considerado como la mejor herramienta para crear aplicaciones cliente / servidor, también
es muy buena herramienta para crear aplicaciones más generales y que no utilizan base de
datos. Usted puede crear un paquete de hoja electrónica o un procesador de palabra en
Delphi. No existen limites de lo que usted puede hacer con Delphi, usted puede hasta crear
un ambiente de desarrollo en Delphi, pero ya Borland creo uno. Delphi esta construido en
el lenguaje de Delphi (Object Pascal), y el ambiente completo es una aplicación Delphi.
Características de Delphi
 El compilador más rápido.

 Ejecutables, que no necesitan librerías en tiempo de ejecución para distribuir
aplicaciones
 Totalmente orientado a objeto.
 Habilidad para crear componentes nativos dentro de Delphi
 Herramienta visual de doble vía
 Manejo de excepciones en el lenguaje
 Conexión a la base de datos a través del Borland Database Engine
 Un generador de reporte industrial con los datos reales en modo de diseño
 Portabilidad desde base de datos locales a cliente / servidor.
Versiones de Delphi
Existen tres versiones de Delphi: Estándar; Profesional y Enterprise.
La versión Standard
Incluye la mayoría de las características que discutiremos en este curso. Actualmente, el

producto es exactamente el mismo sin importar que versión usted utilice. La diferencia esta
en las herramientas y software adicionales que usted recibe en cada paquete. La versión
Standard incluye los siguientes software:
 Delphi IDE y el compilador (incluyendo un compilador de línea de comandos).

 Borland Database Engine, que incluye el soporte de dBase, Parados y ODBC.
 Visual Component Library (VCL con mas de 85 componentes).

La versión profesional
Borland diseñó la edición Profesional para programadores que necesitan mas funcionalidad
que la que viene en la edición Standard, pero que no necesitan todas las características
extras del paquete cliente / servidor. Esta versión viene con todo lo de la Standard Mas:
 Código fuente para la VCL

 InstallShield Express
 Local Interbase Server
La versión Enterprise
Incluye todo el software arriba mencionado las adiciones y mejoras siguientes:
 SQL links native drivers para Oracle, Sybase, Interbase, Informix, DB2
 SQL Database Explorer para manejar los datos del servidor
 Visual Query Builder
 Data Pump expert
 Interbase database server con 2 licencias
El ambiente de desarrollo es exactamente el mismo sin importar que versión usted tenga.
La diferencia esta en las herramientas y software que son provistos. De hecho, usted puede
comprar la versión Standard y después actualizarse a la versión Enterprise
Inicialización de Delphi
Una vez que Delphi ha sido instalado en el computador este crea un grupo de programa en
el menú de Windows. Para cargar Delphi solamente hay que hacer clic sobre el Menú Start
(Inicio) de Windows seleccionar la opción Programs (Programas) y buscar el grupo donde
fue instalado Delphi. El grupo normalmente se llama Borland Delphi x y hacer clic sobre el
icono de Delphi que normalmente esta seguido por el siguiente letrero Delphi x ; donde la x
significa la versión de Delphi, por ejemplo: si la versión de Delphi es la 5; entonces el
grupo se llamaría: Borland Delphi 5 y el icono u opción se llamaría Delphi 5.
Ambiente de Delphi
El ambiente o entorno de Delphi es lo que usted ve cuando usted carga Delphi. El ambiente
de Delphi esta constituido por las siguientes herramientas:
 Ventana principal
• Menú Principal
• Barra de acceso directo
• Paleta de Componentes
 Menú de acceso directo

 El Object Inspector
 Editor de Código
 Diseñador de formulario
Ventana Principal
La ventana principal se encuentra ubicada en la parte superior de la pantalla y esta

compuesta por el menú principal (Main Menú), la barra de acceso directo (Speed Bar) y la
paleta de componentes (Component Palette).
Menú principal
Se encuentra ubicado en la parte superior de la ventana principal e inmediatamente debajo

de la barra de título de la ventana principal, el menú principal contiene todos los comandos
que nos permiten desarrollar una aplicación en Delphi.
File Para manejo de Archivos y Proyectos.

Edit Edición de la ventana activa.
Search Para búsquedas de palabras.
View Para desplegar información de ventanas con relación al proyecto (Project
Manager, BreakPoints).
Project Para compilar el proyecto, opciones generales y globales del Proyecto.
Run Para ejecutar el Proyecto.
Component Para crear y modificar la paleta de componentes.
Database Para realizar consultas SQL y creación de formularios con el Form Wizard.
Tools Para diferentes herramientas (Object Repository, Database Desktop).
Help Ayuda.

Barra de Acceso Directo
Se encuentra ubicada en la parte izquierda de la ventana principal y esta compuesta por una
serie de barras las cuales son independientes cada una. Cada barra esta formada por botones
llamados Speed Button y que nos permiten acceder a las opciones más comunes del menú
principal de una forma más rápida.
Paleta de Componente
La paleta de componente se encuentra ubicada en la parte derecha de la ventana principal y

muestra todos los controles que pueden ser colocados en un formulario.
La paleta de componente de Delphi esta compuesta de una serie de pagina, donde cada
página selecciona una categoría diferente de componente y los componentes están
agrupados de acuerdo a su función. Además en la esquina superior derecha de la paleta de
componente se encuentran dos botones que sirven para mostrar las paginas de componentes
que se encuentran ocultas. Por otro lado se debe notar que también existen unas pequeñas
flechas al lado de los componentes, estas flechas sirven para mostrar los componentes que
se encuentran ocultos en una pagina.

Menú de acceso directo
Consiste en una ventana con un menú que aparece próximo al puntero del Mouse cuando
usted presiona el botón de la derecha del Mouse. El menú de acceso directo permite acceder
de una forma más rápida a los comandos del menú principal que aplican en el lugar donde
es invocado el menú de acceso directo. Es decir, las opciones que aparecen en el menú son
los comandos que aplican en ese lugar.
El menú de acceso directo permite ejecutar comandos de una forma mas rápida que desde
el menú principal, ya que no hay que buscar la opción, pues las opciones mostradas son
aquellas que aplican al lugar donde se invocó el menú de acceso directo.

El Inspector de Objeto
El inspector de objeto es una herramienta imprescindible en el desarrollo de las

aplicaciones en Delphi. Permite establecer las propiedades, y asignar los procedimientos
asociados a cada uno de los eventos de un componente, ya sea ventana, control, etc.
La parte superior de la ventana del inspector incluye un control de tipo combobox el cual
contiene todos los componentes que se encuentran en el formulario activo en el diseñador
de formularios (incluyendo al formulario mismo, ya que el formulario es un componente
también). Al seleccionar un componente, la parte inferior del inspector muestra las
propiedades o los eventos del mismo.
El inspector de objeto esta compuesto por dos pagina, una para las propiedades “Properties”
y otra para los eventos “Events”. Cada página esta dividida por una línea vertical que divide
cada página en un lado izquierdo y un lado derecho. En el lado izquierdo están los nombres
de las propiedades o de los eventos dependiendo de la página donde se encuentre; y del
lado derecho están los valores de las propiedades o los manejadores de eventos
dependiendo de la página en que se encuentre. Para cambiar de página solo hay que hacer
clic sobre la página deseada.
Cada objeto incluido en un formulario y por consecuente en el proyecto esta representado o

esta contenido (sus propiedades y eventos asociados a el), en el inspector de objeto,
cualquier atributo que se quiera cambiar se puede elegir en el mismo. Esto es valido para
las propiedades de los objetos que se pueden modificar en tiempo de diseño y no así en
tiempo de ejecución.
Algunas propiedades, están representados por mas de un valor (subpropiedades del

componente), las cuales están identificadas por un signo(+) del lado izquierdo del nombre
de la propiedad, para acceder a ella solo hay que hacer DOBLE-CLIC sobre el signo de
más.
Así mismo algunos valores de algunas de las propiedades, no dependen de un valor simple
(numero o cadena), sino de un conjunto de ellos o un valor más complejo (el icono esta
marcado por tres puntos, en algunos casos), los cuales se pueden acceder a través de un
CLIC sobre el botón determinado o haciendo doble-clic en el lado derecho del nombre de la
propiedad (donde se asignan los valores).
Diseñador de Formulario
El diseñador de formularios se encuentra ubicado debajo de la ventana principal en el

centro de pantalla, esta es la ventana más grande del ambiente de programación y sirve para
dibujar la interfase gráfica del usuario; aquí es donde se colocan los diferentes componentes
para crear un programa en Delphi.

Editor de Código
Esta ventana se encuentra ubicada detrás del diseñador de formulario. Este editor es la
herramienta con la que el programador escribe o modifica el código del programa. Tiene
todas las características de cualquier editor de programa y otras características muy
especiales que hacen que sea un buen editor de programa. Entre las otras características
podemos mencionar: Resaltado de sintaxis en color, posibilidad de deshacer ilimitadamente
cualquier acción Undo o Redo, copiado de secciones de texto, copiado entre líneas, manejo
de bloque, cambio de mayúsculas a minúsculas, entre otras.

Como podemos observar en la figura anterior la ventana del editor de código esta dividida
en paginas. Cada página corresponde a un archivo abierto. En la barra de título de la
ventana no indica el nombre del archivo que esta activo actualmente. Tiene una barra de
estado que indica la línea y columna donde se encuentra el cursor. El estado del archivo y el
modo de edición (Insert o Overwrite). En la esquina superior derecha podemos observar
unos botones de desplazamiento; que sirven para mostrar las paginas de archivos abiertos
que están ocultas. Una nueva característica del editor de código en esta versión de Delphi es
la ventana de exploración de código. Esta ventana facilita la navegación a través de las
unidades de código. En ella podemos ver detalladamente las partes de una unidad y
podemos movernos a cualquiera de ellas con solo hacer un Doble-clic.
Configuración del ambiente de trabajo
El ambiente de trabajo de Delphi y todas sus herramientas son configurables. La mayoría

de estas opciones están en una ventana que se encuentra dividida en paginas. Esta ventana
sirve para cambiar la forma en que las herramientas de Delphi funcionan. Para llamar esta
ventana solo hay que seleccionar la opción Tools | Environment Options del menú
principal.

Instalación de herramientas
Delphi es una ambiente de trabajo abierto, lo que quiere decir que Borland ha creado una
interfase para que los programadores puedan integrar sus productos y herramientas de
trabajo dentro de Delphi. De esta forma pueden ejecutar cualquier programa sin necesidad
de seguir los pasos tradicionales en el sistema operativo de Windows.
Para integrar una aplicación dentro de Delphi es bien fácil, solamente hay que ejecutar la
opción Tools | Configure Tools del menú principal y aparecerá la siguiente ventana:

Esta ventana le permite agregar cualquier herramienta que usted desee ejecutar desde el
ambiente de trabajo de Delphi. Para agregar una aplicación solamente haga clic sobre el
botón Add e introduzca las informaciones necesarias en la ventana que aparecerá al
presionar este botón. El botón Delete sirve para eliminar de la ventana de herramienta
cualquier aplicación que ya no se desee tener. El botón Edit permite cambiar las
informaciones de la aplicación. Los botones de flecha sirven para cambiar el orden de los
programas que ya se encuentran agregados en la ventana de herramienta. Los programas
que son agregados en la ventana de herramientas aparecen bajo el título Tools del menú
principal.

Resumen de los elementos del ambiente

Proyectos, Unidades y Formularios

 Concepto de proyecto
 Partes de un Proyecto
 Tipos de archivos utilizados por Delphi
 El Project Manager
 Opciones para manejo de archivos
 Opciones del proyecto

Introducción a los proyectos
Todo el desarrollo de aplicaciones en Delphi se centra en los proyectos; cuando usted crea
una aplicación en Delphi, usted esta creando un proyecto. El proyecto normalmente es
almacenado en un archivo con la extensión DPR (que significa Delphi Project). En la
arquitectura general de un programa en Delphi, el archivo de proyecto es el programa
principal de toda aplicación en Delphi. El archivo de proyecto corresponde a lo que era un
programa en Pascal de ahí es que viene que la primera línea del archivo de proyecto
comienza con la palabra clave program seguido del nombre del proyecto.
El proyecto es lo que se ejecuta (corre) y lo que se convierte en ejecutable (EXE) en

Delphi, para que una unidad o formulario pueda ejecutarse, debe pertenecer a un proyecto
ya que como acabamos de decir el proyecto es lo que se ejecuta. Cuando usted manda a
ejecutar un proyecto, todas las unidades son compiladas y convertidas en archivos objetos
los cuales son enlazados en el proyecto y convertido a ejecutable.
Partes de un proyecto
Un proyecto esta formado básicamente por unidades y formularios.
Unidad
El archivo de unidad PAS es una colección de tipos de datos, declaraciones de variables y

constantes, procedimientos y funciones que están relacionadas de una u otra forma. La
unidad contiene el código de programación. Las unidades son compiladas individualmente,
lo que hace que ellas sean mas modulares e incrementen el tiempo de compilación para el
proyecto. Cuando la unidad es compilada, se crea un archivo con el mismo nombre que el
archivo PAS pero con la extensión DCU (Delphi Compiled Unit). Estos archivos
corresponden a los antiguos archivos TPU o TPW en versiones anteriores de Pascal.
Formulario
El archivo del formulario DFM (Delphi Form) contiene la parte visual de la aplicación,
todos los objetos gráficos que son colocados en él en tiempo de diseño, además este
archivo contiene los valores de las propiedades de los objetos, el archivo del formulario es
un archivo binario lo que significa que no puede ser abierto con cualquier editor de texto.
Como acabamos de ver anteriormente un proyecto en Delphi esta compuesto por Unidades
y formularios; las unidades contienen el código fuente y los formularios contienen la parte
visual. En los proyectos existen ciertas reglas que detallaremos a continuación:

 Todos los formularios en un proyecto en Delphi pertenecen a una unidad; la razón

de esto es que en los formularios esta solamente la parte visual y el código de
programación resultante de la programación de eventos a los componentes que son
colocados en el formulario se debe guardar en algún lugar, y que mejor lugar que las
unidades ya que esta es la finalidad de las unidades, almacenar el código de
programación;
 Las unidades no necesariamente deben estar asociadas a un formulario, la razón de

esto es que como las unidades contienen declaraciones de tipos de datos, constantes,
variables, procedimientos y funciones; se puede dar el caso en un proyecto de
utilizar unidades como librería de programación. Una librería de programación no
es mas que un archivo que contendrá todo el código común, o mejor dicho todos los
procedimientos, funciones, variables, constantes y tipos de datos que serán
utilizados en mas de un lugar en toda la aplicación;
 En un proyecto en Delphi no puede haber un formulario con el mismo nombre que

el proyecto y viceversa;
 En un proyecto en Delphi no puede haber una unidad con el mismo nombre que el
proyecto y viceversa;
 En un proyecto en Delphi no puede haber un formulario con el mismo nombre que

una unidad y viceversa.
¿Qué ocurre cuando se graba un proyecto o una unidad en Delphi?
Cuando usted graba o salva un proyecto, Delphi crea un archivo en el disco duro con el
nombre que usted le puso al momento de grabarlo mas la extensión DPR; además de esto
Delphi crea otros archivos con el mismo nombre del proyecto con las siguientes
extensiones RES, DOF, DSK;
Cuando usted graba una unidad Delphi crea dos archivo en el disco duro con el nombre
que usted le puso al momento de grabar, uno con la extensión PAS y otro con la extensión
DFM – en el caso que la unidad tenga un formulario -, es decir que Delphi le pide grabar la
unidad, pero graba el archivo del formulario y la unidad con el nombre que usted le puso a
la unidad.
Anteriormente habíamos dicho que en un proyecto en Delphi no pueden repetirse los

nombres de las unidades, ni de los formularios dentro de un proyecto, lo que habría que
averiguar es de donde Delphi toma estos nombres.
El nombre del proyecto es tomado de la primera línea del archivo DPR, el nombre que
sigue a la palabra reservada program;

El nombre de la unidad es tomado de la primera línea del archivo PAS, el nombre que sigue
a la palabra reservada unit;
Y por ultimo el nombre del formulario es sacado de la propiedad name ya que el

formulario es un componente.
Project manager
Delphi tiene una herramienta muy poderosa para el manejo de proyectos, esta herramienta
recibe el nombre de project manager.
El project manager lista los nombres de todas las unidades, los formularios de las unidades
en caso que haya un formulario declarado en la unidad y la ruta o carpeta donde se
encuentra guardada la unidad. En Delphi 4 y Delphi 5 puede haber mas de un proyecto
abierto a la vez, para lo cual el project manager crea un projectgroup. El project manager
tiene una barra de botones en la parte superior:
 El ComboBox contiene una lista de todos los proyectos que se encuentran abierto;
 El botón New: sirve para agregar un nuevo proyecto;
 El botón Remove sirve para quitar cualquier archivo del project manager, esto no lo
eliminará físicamente de la carpeta.
El project manager en Delphi 5 tiene una nueva característica y esta es que se puede
arrastrar cualquier archivo desde el explorador de Windows para agregarlo a un proyecto en
particular, también se puede arrastrar cualquier unidad entre proyectos.

Opciones para manejo de archivos (File)

Esta opción sirve para abrir la ventana New Items, que contiene
New los objetos que están almacenados en el repositorio y además
contiene los asistentes (Wizards) para crear objetos.
New Application Sirve para crear un Nuevo proyecto con un formulario en blanco y
una unidad.
Crea un formulario en blanco y lo agrega al proyecto que este
New Form abierto o activo en ese momento.
New Frame Crea un frame en blanco y lo agrega al proyecto que este abierto o
activo en ese momento.
Esta opción despliega la ventana Open para cargar un proyecto
Open existente, formulario, unidad o archivo de texto en el editor de
código.
Esta opción despliega la ventana Open Project para cargar un
Open Project proyecto existente.
Reopen Despliega un Submenú que contiene un listado de los proyectos y
unidades que fueron abiertos recientemente.
Guarda un archivo.
Save
Save As Permite grabar un archivo con un Nuevo nombre.
Save Project As Permite grabar el proyecto con un Nuevo nombre.
Permite grabar todos los archivos abiertos, incluyendo proyectos y
Save All módulos.
Close Permite cerrar el proyecto actual y las unidades y formularios
asociadas al mismo.
Close All Permite cerrar todos los archivos abiertos.
Use Unit Permite seleccionar una unidad para agregarla a la cláusula uses
de la unidad activa.
Print Permite imprimir el archivo activo.
Exit Sirve para salir de Delphi.
Sirve para agregar una unidad al proyecto.
Add to Project
Sirve para remover o quitar una unidad al proyecto.
Remove from
Project
Sirve para ver un listado de todas las unidades del proyecto,
View Unit también se puede elegir para trabajar una unidad de la lista.
Sirve para ver un listado de todos los formularios del proyecto,
View Form también se puede elegir para trabajar un formulario de la lista.

Opciones del proyecto
En la opción Project del menú principal se encuentra la opción Options que sirve para
cargar la ventana Project Options que sirve para cambiar varios aspectos del proyecto. Es
una ventana que se encuentra dividida en diferentes secciones mediante el método de “Tab”
o pestañas. Las secciones en las cuales esta dividida son: Forms, Application, Compile,
Linker, Directories/Conditionals, Versión Info y Packages.
Forms
La página Forms de la ventana Project Options permite especificar algunas características

de cómo la aplicación manejara los formularios:
Esta ventana permite especificar cual formulario será el principal en la aplicación (en otras
palabras cual será el primer formulario que aparecerá cuando la aplicación se ejecute). La
lista que se encuentra en la parte izquierda (Auto-create forms) despliega todos los
formularios que pertenecen al proyecto. La lista que se encuentra en la parte derecha
(Available forms) permite especificar si el formulario será auto creado o no; cuando usted
tiene un formulario en la lista auto-create, el proyecto creara automáticamente la referencia
al formulario en tiempo de ejecución. Esta es la mejor opción si se sabe de antemano que
un formulario será utilizado en la aplicación. La otra opción es no dejar que Delphi cree
automáticamente el formulario lo que quiere decir que el usuario tendrá que crear la
referencia del formulario mediante código de programación para poder mostrar un
formulario. Esta es la mejor opción para los formularios que no serán utilizados cada vez
que la aplicación sea ejecutada. Cuando los formularios no son auto creados la aplicación
carga mas rápido y utiliza menos memoria.
Application
La página Application de la ventana Project Options permite cambiar las características de

la aplicación:
La caja de texto Title permite nombrar la aplicación con otro nombre que no sea el nombre
del archivo de proyecto. La ventana Application también permite especificar cual será el
archivo de ayuda asociado a la aplicación y además permite especificar un icono para la
aplicación.

Compiler
La página Compiler de la ventana Project Options permite configurar las opciones de

compilación:
Note que en este lugar se especifican la configuración de compilación para cada proyecto.
La configuración de compilación es mantenida al nivel de proyecto, lo contrario del nivel
del ambiente. Esto quiere decir que usted puede tener proyectos con diferentes
configuraciones de compilación sin tener que cambiar la configuración global cada vez que
trabaje en un proyecto.
Linker
La página Linker de la ventana Project Options permite configurar varias opciones de

memoria y compilación:

Estas opciones incluyen la especificación de un archivo Map, el cual es utilizado para fines
de depuración de errores. El uso del buffer de encadenamiento de memoria para mayor
rapidez, o el buffer de encadenamiento de disco para programas realmente grandes y cuya
información de encadenamiento no cabe en memoria.
Directories / Conditionals
La página Directories / Conditionals de la ventana Project Options permite especificar

directorios y condiciones:

Aquí se puede especificar los directorios de salida para todos los archivos del proyecto
generados por el sistema. Para algunas situaciones usted querrá mantener separados en
diferentes directorios los archivos fuente, objetos y ejecutables.
La configuración Search path permite incluir unidades en los proyectos que no se

encuentran el directorio del proyecto.
Version Info
La página Versión de la ventana Project Options permite habilitar y especificar las

informaciones de manejo de versiones del proyecto:

Packages
La página Packages de la ventana Project Options permite especificar los paquetes de

diseño y los paquetes de tiempo de ejecución utilizados por el proyecto:

Compilación y Encadenamiento
Para correr y distribuir la aplicación, se debe compilar. Nótese que no existe ningún
interprete de Pascal corriendo en el background, ósea que el código debe ser compilado
antes de ser ejecutado.
Compilación
Para compilar la aplicación usted puede seleccionar la opción Project | Compile del menú
principal. Usted puede solamente seleccionar Project | Syntax Check del menú para
compilarlo sin encadenarlo. De todos modos esta opción crea los archivos objetos (DCU si
usted esta compilando una unidad).
El comando Compile automáticamente compila solamente los archivos que necesitan ser
compilados. Es decir que Delphi solo compila los archivos fuentes que han sufrido cambios
y cualquier archivo que dependa de un archivo que usted haya modificado. Esta
compilación limitada aumentara el tiempo de compilación considerablemente. Delphi es lo
suficientemente inteligente para realizar solamente el trabajo que es necesario para
reconstruir el ejecutable.

Puede ser que haya situaciones en las cuales sea necesario o usted desee compilar todos los
módulos. Para realizar esto seleccione la opción Project | Build All Projects del menú.
Esto forzara al compilador a recompilar todos los archivos de todos los proyectos.
Encadenamiento
El encadenamiento en Delphi no podría ser más fácil, porque usted nunca tiene que hacerlo.
El encadenador es automáticamente invocado cuando usted le dice a Delphi que compile y
cree la aplicación. A diferencia de otros encadenadores, el encadenador de Delphi es tan
rápido que usted rara veces se da cuenta del proceso de encadenamiento.
Si usted desea ver el status del proceso de compilación y encadenamiento, coteje la opción
Show Compiler Progress en la ventana de Environment Options.

Resumen de Proyectos, Unidades y Formularios

Diseñador de Formulario
 Diseño de la interfase visual
 Configuración del diseñador de formulario
 Concepto de componente
 Tipos de componentes
 Como colocar los componentes en el formulario
 Manipulación de componente
 Como crear un formulario
 Concepto de propiedades
 Tipos de propiedades
 Sintaxis para cambiar el valor de las propiedades por código de programación
 Uso del inspector de objeto para cambiar propiedades
 Concepto de evento
 Use del inspector de objeto para programar eventos

Introducción
Una de las características más útil y poderosa de Delphi es el diseñador de formularios. El

diseñador de formularios es en lo que primero usted se enfoca en el desarrollo de
aplicaciones utilizando Delphi. Usted puede crear cualquier interfase fácil y rápidamente.
Diseño de la interfase visual del usuario
En los primeros días de la programación gráfica, las herramientas de diseño visual

usualmente permitían al desarrollador diseñar gráficamente en la pantalla la interfase del
usuario. La herramienta usaba este diseño para generar un archivo intermedio, que contenía
el código en el lenguaje nativo o en un lenguaje especializado. Estas herramientas redujeron
considerablemente el tiempo para desarrollar una interfase.
De cualquier manera, con estas herramientas no era posible cambiar el código generado y
ver los resultados reflejados en el diseño visual. Usted podía manipular la interfase con el
diseñador por un momento, pero una vez que se necesitaba manipular el código generado
usted era sacado del ambiente visual. Si hubo cualquier cambio en el código generado, el
diseñador rechazaría el cambio en el diseño.
Configuración del diseñador de formulario
El diseñador de formulario de Delphi es configurable y puede ser configurado por el

usuario a su entera comodidad. Hay una sección dentro de la ventana Environment Options
dedicada al diseñador de formularios:

Aquí se le puede decir si se van a desplegar los puntos de ubicación del formularios; si los
componentes que se coloquen en el formulario van a ser alineado a estos puntos; si se van a
mostrar los títulos de los componentes; si cada vez que se cree un formulario nuevo se va a
ver como texto; si los formularios nuevos que se creen van a ser agregados por defecto a la
lista Auto create forms del proyecto y por ultimo se pueden cambiar el tamaño horizontal y
vertical de los puntos de ubicación dentro del formulario.
Componente
Un componente es cualquiera de los elementos que podemos insertar en un formulario -

incluyendo al formulario mismo – y permiten construir una aplicación en Delphi. Los
componentes son el bloque de construcción de todas las aplicaciones en Delphi. Todos los
componentes están formados por propiedades, eventos y métodos.
Tipos de componentes
Delphi tiene dos tipos de componentes: visibles e invisibles. Usted lo utiliza de la misma
manera, colocándolos en la forma y cambiando sus propiedades, la diferencia la notara

cuando usted ejecute la aplicación.
Visibles
Cuando un componente puede ser visto por el usuario en tiempo de ejecución, el

componente es considerado un componente visible.
No Visibles
Algunos componentes aparecen en la forma cuando esta es diseñada, pero no pueden ser
vistos en tiempo de ejecución, los componentes no visibles proveen servicios para algunos
otros componentes o a una aplicación.
Colocando Componentes en la Forma
Delphi nos brinda diferentes maneras para colocar componentes en el formulario. Los
métodos mas conocidos para colocar un componente en el formulario son:
• Clic: Es el método más simple y consiste en hacer clic sobre el componente

deseado en la paleta de componente y luego hacer clic sobre el formulario en
el lugar donde usted desea colocar el componente. El componente aparecerá
con la esquina superior izquierda ubicada en el lugar donde usted hizo el
clic;
• Clic y Drag: El segundo método permite colocar el componente y al mismo

tiempo fijarle el tamaño deseado. Para realizar este método primero se hace
clic sobre el componente deseado en la paleta de componente, luego el
puntero del Mouse se lleva al lugar en el formulario donde se desea colocar
el componente, después que sabemos el lugar donde deseamos colocar el
componente presionamos el Botón del Mouse (Botón izquierdo
normalmente) y mientras lo mantenemos presionado arrastramos el Mouse
hacia la derecha y hacia abajo hasta darle el tamaño deseado al componente
(usted observara como que aparece un cuadro con líneas punteadas
indicándole el tamaño que le esta dando al componente), cuando haya
alcanzado el tamaño deseado para el componente suelte el botón del Mouse
y el componente estará creado;
• Doble-Clic: consiste en hacer Doble-clic sobre el componente deseado en la

paleta de componente. El componente aparecerá en el centro del formulario
y con el tamaño que tenga asignado por defecto;
• View | Component List: la ultima forma es seleccionando la opción View |

Component List del menú principal. Esto provoca que aparezca una
pequeña ventanita que permite buscar los componentes por su nombre y
agregarlo al formulario. Los componentes aparecen en el centro del
formulario y con un tamaño por defecto.
También usted puede colocar múltiples componentes del mismo tipo, para hacer esto
presione la tecla Shift y mientras la mantiene presionada haga clic sobre el componente que
desea colocar en el formulario, luego suelte la tecla Shift y proceda a colocar los
componentes en el formulario. Cada vez que usted haga clic en el formulario un
componente del tipo seleccionado aparecerá. Cuando usted termine, haga clic en el puntero
del Mouse en la paleta de componente para desactivarlo.
Manipulación de Componentes
Si por alguna razón usted no coloca los componentes en el lugar correcto, no se preocupe
usted puede modificarlo en el Diseñador de Formulario en cualquier momento.
Selección de componentes
Seleccionar un componente es hacerlo activo en el inspector de objeto. Los componentes se

deben seleccionar para poder cambiar el valor de sus propiedades, programarle algún
evento, moverlo, borrarlo o cambiarle el tamaño en el diseñador de formulario.
Cuando un componente es seleccionado aparece seleccionado en la lista de componentes en

el inspector de objeto (ComboBox); y aparece rodeado de unos pequeños cuadritos
llamados Handles (manejadores) en el diseñador de formulario.

Formas para seleccionar componentes
 Hacer clic sobre el componente en el diseñador de formulario
 Seleccionarlo en el ComboBox del inspector de objeto
 Para seleccionar mas de un componente hacer un Drag; esto es ubicar un punto de

origen, convenientemente cerca de donde esta el primer componente a seleccionar,
presionar el botón del Mouse y mientras esta presionado mover el puntero del
Mouse horizontalmente y verticalmente para abarcar todos los componentes que se
desean seleccionar (se vera un cuadro de línea punteada indicando el área que se
esta seleccionando) y luego soltar el botón del Mouse y se verán todos los
componentes con sus manejadores.
 Presionando la tecla Shift y mientras se mantiene presionada ir dando clic a todos

los componentes que se desean seleccionar.
Nota: Cuando hay mas de un componente seleccionado cada componente tendrá un total de
cuatro handle y el color del mismo será un color opaco (gris normalmente).
Moviendo los Componentes

Después de haber colocado los componentes en el formulario, puede ser que surja la
necesidad de cambiarlo de lugar. Para mover un componente solo hay que seleccionarlo y
arrastrarlo a la nueva ubicación. El proceso de arrastrarlo consiste en colocar el puntero del
Mouse encima del componente (nunca colocarlo encima de un handle, pues de esta forma
le cambiaria el tamaño en vez de moverlo que es lo que se desea) y presionar el botón del
Mouse y mientras se tiene presionado el botón del Mouse mover el puntero del Mouse al
lugar donde se desea poner el componente, luego solo hay que soltar el botón del Mouse.
Existen dos formas para mover un componente con el teclado, estas son:
 Ctrl. + Shift + Teclas de movimiento del cursor
 Ctrl. + Teclas de movimiento del cursor
 Vía las propiedades Left y Top
Los pasos para utilizar estos mecanismos son: seleccionar el componente y luego utilizar la
combinación de tecla correspondiente para moverlo. La diferencia entre ellas es que la
primera mueve el componente más rápido. Además la segunda forma permite mover de una
forma bien lenta el componente. Para el caso de las propiedades solo hay que seleccionar el
componente y cambiar los valores de estas propiedades en el Inspector de Objeto.
Cambiándole el Tamaño a los Componentes
Existen varias formas para reducir o aumentar el tamaño de los componentes colocados en
el diseñador de formulario, pero la más común y por cierto la más rápida es seleccionando
el componente y arrastrando uno de los handle que se encuentran en la dirección hacia
donde se desea cambiar el tamaño del componente. Nótese que cuando se coloca el puntero
del Mouse encima de un handle, el puntero del Mouse cambia y se convierte en una flecha
de doble vía, indicando que se puede mover en cualquiera de las direcciones. Para arrastrar
el handle no olvide que tiene que presionar el botón del Mouse y mientras lo mantiene
presionado debe mover el Mouse hacia la dirección en que desea cambiar el tamaño.
Otras formas para cambiarle el tamaño a un componente son:
 Vía las propiedades Height y Width
 Shift + Teclas de movimiento del cursor
Para el caso de las propiedades solo hay que seleccionar el componente y cambiar los
valores de estas propiedades en el inspector de objeto. En el caso de las teclas solo hay que
seleccionar el componente y utilizar la combinación de tecla, la combinación de teclas
permite cambiarle el tamaño de una forma más lenta.

Borrando Componentes
Borrar un componente es la operación más simple que existe, solo hay que seleccionar el
componente y presionar la tecla Delete (Suprimir), esta es la forma más sencilla.
Otras formas para borrar componentes son:
 Edit | Cut del menú principal
 Edit | Delete del menú principal
 Ctrl. + X
Creación de un formulario simple
A continuación vamos a realizar un formulario simple, este formulario no es útil, pero

servirá para mostrar los conceptos básicos del diseñador de formularios y los tipos de
componentes.
Colocación de los componentes en el formulario
Vamos a colocar algunos componentes en el formulario, algunos visibles y otros invisibles

y vamos a mostrarle como ponerlo a interactuar entre ellos. Lo primero que hay que hacer
es crear un proyecto nuevo con un formulario. Siempre hay que tener un proyecto activo
para diseñar formularios ya que el desarrollo en Delphi esta centralizado en los proyectos,
si no se tiene un proyecto activo usted podrá crear los formularios, pero no podrá
ejecutarlos. Para crear un nuevo proyecto seleccione la opción File | New Application del
menú principal.
Agregue estos componentes al formulario:
Un edit (de la página Standard)

Un group box (de la página Standard)
Dos button (de la página Standard)
Dos label (de la página Standard)
Un gauge (de la página Samples)
Un timer (de la página System)

El formulario debe quedar como la figura anterior.
Uso del inspector de objeto para cambiar propiedades
Propiedades
El termino propiedades se refiere a ciertos aspectos de un componente que puede ser

cambiado, ya sea en tiempo de diseño o en tiempo de ejecución. Pero esencialmente
propiedades son características o atributos que controlan como un componente luce, actúa y
funciona.
Tipos de propiedades
Los tipos de propiedades son: Simples, enumeradas, conjunto y propiedades tipo editor.
Simple
Propiedades simples son aquellas propiedades cuyo valor es digitado directamente en el

inspector de objeto. Las propiedades simples siempre toman un valor que usualmente
corresponde a los tipos de datos nativos de Pascal, por ejemplo: Integer, String, Etc., por
ejemplo:

Enumeradas
Son aquellas propiedades cuyos valores están predefinidos y el usuario debe seleccionar
solo uno de ellos. Estas propiedades se pueden identificar porque tienen un combobox en el
inspector de objeto del cual debemos seleccionar el valor.
Como ejemplo de propiedades enumeradas en la figura anterior tenemos la propiedad color.

Conjunto
Las propiedades tipo conjunto son propiedades que están formadas por propiedades. Este
tipo de propiedades esta estructurado para contener o permitir cambiar el valor de varias
propiedades. Estas propiedades la podemos identificar en el inspector de objeto porque
tienen un signo de mas (+) del lado izquierdo del nombre de la propiedad. Al hacer doble-
clic sobre el signo de mas la propiedad se expande mostrando todas las propiedades por las
cuales ella esta compuesta. Cuando la propiedad esta expandida presenta un signo de menos
(-) del lado izquierdo del nombre de la propiedad. Un ejemplo de esta propiedad es la
propiedad Font. Si nos fijamos en la figura anterior del inspector de objeto, podremos ver la
propiedad Anchors que es tipo conjunto y se encuentra expandida mostrando las
propiedades que contiene, si nos fijamos en la propiedad Font, podremos ver que esta
contraída, signo de mas del lado izquierdo.

Tipo editor
Son propiedades cuyos valores no son introducidos en el inspector de objeto, sino en otra
ventana que es invocada desde el inspector de objeto y que recibe el nombre de editor.
Estas propiedades las podemos identificar en el inspector de objeto porque tienen un botón
con tres puntos suspensivo (...) en el lado derecho de la propiedad en el inspector de objeto.
Este botón con los tres puntos recibe el nombre de ellipsis. Para llamar el editor solo hay
que hacer clic sobre el botón. Un ejemplo de esta propiedad es la propiedad Font.
La propiedad Name
Esta propiedad es común en todos los componentes, es decir, todos los componentes tienen
una propiedad name. Esta propiedad sirve para identificar a los componentes. A esta
propiedad no es obligatorio cambiarle el valor ya que Delphi le asigna un nombre a todos
los componentes, y además Delphi controla que dos componentes no tengan el mismo
nombre. La nomenclatura que Delphi utiliza para nombrar los componentes consiste en: el
tipo del componente mas un numero secuencial que es generado de acuerdo a la cantidad de
componentes de un mismo tipo que se hayan colocados en el formulario.
Aunque Delphi le asigna un nombre automáticamente a los componentes lo mas

recomendable es que se le asignen nombres mas significativos a los componentes, por
ejemplo: la sentencia Label_Nombre.Enabled := True es mas clara que: Label1.Enabled :=
True. En el primer ejemplo el usuario puede determinar rápidamente a que componente le
estamos cambiando el estado sin necesidad de tener que buscarlo en el inspector de objetos.
La nomenclatura de iniciar el nombre de un componente con el tipo del mismo, esto

permite identificar rápidamente el tipo del componente cuando se este revisando el código
mas tarde. Esta nomenclatura evita muchos problemas cuando se escriben los manejadores

de eventos. También como el inspector de objeto ordena alfabéticamente los componentes

que se encuentran en el formulario, los componentes de un mismo tipo se encontraran
juntos.
Sintaxis para la manipulación de propiedades por programación
Ya hemos visto como el cambio del valor de una propiedad impacta considerablemente en
el funcionamiento de un componente. Los valores de las propiedades pueden ser cambiados
en tiempo de diseño utilizando el inspector de objeto, pero la esencia de la programación
orientada a objeto consiste en todos los efectos que se pueden lograr con el mero hecho de
poder cambiar una propiedad en tiempo de ejecución (es decir mientras el programa se
encuentra en ejecución); para esto debemos conocer la forma en que podemos manipular
una propiedad por código de programación.
Sintaxis:
nombredelcomponente.nombredela propiedad;
Donde nombre del componente consiste en el valor que tenga la propiedad Name. Y
nombre de la propiedad es el nombre de la propiedad a la cual se desea hacer referencia por
código de programación. Nota el punto es parte de la sintaxis e indica que lo que se
encuentra a la derecha del punto pertenece al objeto que se encuentra a la izquierda del
punto. El punto sirve para denotar quien contiene a quien.
Ejemplos:
Label1.Caption := ‘Prueba’; Se esta cambiando el valor de una propiedad.
A := Label1.Caption; Se esta leyendo el valor de una propiedad.
Uso del inspector de objeto para cambiar propiedades
El inspector de objeto es la herramienta que proporciona Delphi para cambiar los valores de
las propiedades y programar los eventos de los diferentes componentes en tiempo de
diseño. Los nombres de las propiedades y los eventos se encuentran organizados en orden
alfabéticos ascendente.

En la parte superior del inspector de objeto, hay un combobox que indica a que componente
pertenece la lista de propiedades y eventos que están siendo desplegadas, además indica el
nombre y la clase a que pertenece el componente, por ejemplo: en la figura anterior
podemos notar que el componente seleccionado se llama Form1 y que pertenece a la clase
Tform.
Al principio la lista de propiedades y eventos puede ser confusa ya que usted desconoce el
significado o la función que desempeña cada una. Delphi proporciona una ayuda en línea
muy buena para sobrepasar esta barrera, para investigar que hace una propiedad o evento
simple y llanamente selecciónela y presione la tecla F1 para ver la ventana de ayuda de esa
propiedad o evento. El numero de propiedades puede aterrorizar a los nuevos
programadores, pero no hay porque temer, si usted comienza aprendiendo las propiedades
mas importante, el resto se aprenderá sobre la marcha, además habrá muchas de esas
propiedades que a lo mejor nunca la llegue a utilizar.
El inspector de objetos permite cambiarle el valor a un grupo de componentes a la vez.

Anteriormente mostramos como se pueden seleccionar varios componentes. Si hay un
grupo de componentes seleccionados el inspector de objetos solamente mostrara aquellas

propiedades que sean comunes a todos los componentes seleccionados. El mismo valor de
la propiedad será asignado a todos los componentes. Cuando hay mas de un componente
seleccionado el combobox del inspector de objetos se vera en blanco.
Programación de eventos
Eventos
Eventos son agrupaciones de código de programación que usted proporciona para

determinar que acciones será tomada en tiempo de ejecución para un mensaje o evento
dado del sistema operativo.
Tipos de eventos
Delphi ofrece dos tipos de eventos: del sistema y del usuario.
 Los eventos del usuarios son aquellos que ocurren en respuesta a una acción del
usuario, tales como la presión de una tecla, oprimir un botón del Mouse.
 Eventos del sistema no se disparan en respuesta a entradas del usuario, en lugar de

esto reaccionan a mensajes especiales del sistema operativo, tales como cuando se
navega de un control a otro, cuando se activa un componente, etc.
Manejadores de eventos
Son los procedimientos que se conectan a los eventos. Estos procedimientos contienen
código de programación en Object Pascal. Estos procedimientos se crean para darle una
respuesta particular a la ocurrencia de un evento.
Uso del inspector de objeto para programar eventos
La pestaña “Events” del inspector de objeto muestra todos los eventos asociados con el
componente que se encuentra actualmente seleccionado. La pestaña “Events” del inspector
de objeto luce como la figura siguiente:

En la figura de arriba podemos ver como el inspector de objeto muestra todos los eventos
asociados a un formulario. La mayoría de los nombres de eventos comienzan con la palabra
“On” para enfatizar la ocurrencia de una acción.
El inspector de objeto permite crear los manejadores de eventos de los eventos que usted
desee capturar. Si usted quiere escribir el código del manejador de evento de un evento de
un componente, lo primero que hay que hacer es seleccionar el componente en el diseñador
de formulario o en el combobox del inspector de objeto, luego seleccionar la pestaña
“Events” en el inspector de objeto y localizar el nombre del evento que usted desea
manejar. Después usted hace doble-clic en el combobox que se encuentra a la derecha del
nombre del componente, Delphi mostrara el editor de código con la definición del
manejador de evento, lo único que hará falta en este momento es que usted termine de
llenar en el espacio en blanco con el código necesario para completar el manejador de
eventos. A continuación un ejemplo del resultado de los pasos anteriores:

Si usted hace doble-clic sobre un componente en el diseñador de formulario, Delphi

llamaría el editor de código y asumiría que usted quiere crear un manejador de evento para
el evento por defecto del componente seleccionado. Delphi selecciona el evento por defecto
para cada componente basado en cual es el evento que mas se utiliza, en la figura anterior
podemos ver que el evento por defecto para el formulario es el “OnCreate”.
Si ya existe una rutina que usted quiere ejecutar en respuesta a un evento, solamente tiene
que hacer clic en el botón del combobox en el inspector de objeto y seleccionarlo de la lista.

Resumen del Diseñador de formularios

Interactuando con los componentes

En este capitulo:
 Crearemos barras de herramientas y barras de estado

 Veremos como mostrar mensajes en la barra de estado
 Utilizaremos el componente PageControl para hacer un formulario paginado
 Aprenderemos a utilizar el componente ScrollBox
 Manipularemos el componente RadioGroups
 Cambiaremos el tipo de letra y el color con los componentes invisibles “Dialogs”
 Crearemos una pantalla de selección de archivos
 Navegaremos a través del componente Calendar

Introducción al diseño de formulario
El objetivo de este capitulo es mostrarle el uso de algunos de los componentes. Para

afianzar el esquema de programación en Delphi. Aquí pondremos en practica los
conocimientos aprendidos en capítulos anteriores, así como la utilización de los diferentes
tipos de propiedades y la programación de eventos.
Creación de barra de herramientas y barras de estado
La barra de herramienta sirve para facilitar el trabajo en una aplicación Windows. Los
botones en una barra de herramienta pueden ser utilizados para cualquier propósito, desde
cargar una ventana hasta cerrar una aplicación. En este capitulo lo utilizaremos para
mostrar mensajes en la barra de estados. Una vez que usted aprende como asociar acciones
a ellos, no importa que usted quiera hacer con ellos, la forma de utilizarlos será la misma.
Comenzaremos nuestro trabajo con un nuevo proyecto. De la página Standard de la paleta

de componente, colocaremos un panel en el formulario, lo pondremos un poco mas
pequeño en altura y cambiaremos el valor de la propiedad Align a Top y por ultimo
borraremos el contenido de la propiedad Caption. El panel lo utilizaremos para construir la
barra de herramienta del formulario. En la página Additional de la paleta de componente se
encuentra el componente SpeedButton. Colocaremos tres sobre el panel.
Luego tomaremos el 2do y 3er botón y le asignaremos el mismo valor en la propiedad

GroupIndex – cualquier valor mayor que cero -. Esto hará que ellos trabajen en conjunto.
Luego cambiaremos a True el valor de la propiedad Down del 2do botón, esto hará que el
botón este presionado cuando el formulario se ejecute.
Después agregaremos un componente StatusBar al formulario, este componente se

encuentra en la página Win32 de la paleta de componente, automáticamente el se alineara
al pie del formulario. Ahora agregaremos dos paneles vía la propiedad Panels del
componente StatusBar, seleccione el editor de la misma. Aumentaremos el tamaño del
primer panel a 150 con la propiedad Width, para desplegar los mensajes mas largos, e
introduciremos el siguiente letrero “Botón Izquierdo abajo” en el segundo panel.
Ahora queremos que el primer panel muestre un mensaje cuando el usuario presione el
primer botón. Lograremos esto con el uso de los eventos OnMouseDown y OnMouseUp.
Cree el manejador de evento haciendo doble clic en el evento OnMouseDown. Pondremos
la siguiente línea de código:
StatusBar1.Panels.Items[0].Text := ‘Yo no estoy presionado’;

Debe notarse que el primer panel es referenciado con el índice cero. Ahora programe el
evento OnMouseUp para limpiar el panel, para esto asígnele una cadena de longitud cero al
panel.
En el evento OnClick del tercer botón, cambie el mensaje del segundo panel, para que le
informe al usuario que el botón de la derecha esta abajo. Haga lo mismo con el segundo
botón. Ejecute el proyecto y observe los mensajes en la barra de estado. A continuación una
figura del formulario hasta ahora:
Componente PageControl
Agregando paginas
Algunas veces se tiene tanta información relacionada que la que cabe en un formulario.
Delphi resuelve este problema con los componentes PageControl y TabSheet.
Utilizando el mismo formulario, vamos a colocar un componente PageControl de la página

Win32 de la paleta de componente y vamos a cambiar la propiedad Align a Client. Con el
puntero del Mouse sobre el componente pagecontrol, haga clic con el botón de la derecha
del Mouse para cargar el menú de acceso directo. Seleccione la opción New Page y cambie
su propiedad Caption para que diga “Regiones” . Agregando una nueva pagina, hemos
creado un componente TabSheet dentro del componente PageControl. Luego colocamos un

componente RadioGroup (página Standard) en la página que acabamos de crear. Verifique
el valor de la propiedad Items que es del tipo de datos TString. Aquí introduciremos el
nombre de cuatros regiones.
Los Items en la lista no son estáticos, usted puede manipular por código de programación
esta propiedad para agregar y quitar valores de la lista en tiempo de ejecución. Podemos
permitir que el usuario agregue items en vez de tenerlos todos predefinidos. Un
componente Edit puede proporcionar el mecanismo de entrada de datos. Coloque un botón
y un componente Edit debajo del RadioGroup. Vamos a limpiar la propiedad Text del Edit
para que el despliegue del componente en tiempo de ejecución sea en blanco. Ahora vamos
a hacer que cuando el usuario haga clic en el botón, el texto que se encuentre en el edit sea
agregado a la lista del RadioGroup. En el evento OnClick del botón, digite el siguiente
código:
If trim(Edit1.Text) <> ‘’ then

Radiogroup1.Items.Add(Edit1.Text);
Componente ScrollBox
Actualmente si el usuario le cambia el tamaño al formulario, habrá informaciones que se

ocultaran. Para evitar esto vamos a agregar un componente ScrollBox al formulario. Para
que esto funcione todos los componentes de la página deben estar dentro del componente
Scrollbox. Vamos a cortar (Ctrl. + X, Edit | Cut del menú principal) los tres componentes
que se encuentran colocados en la pagina, luego de la página Additional de la paleta de
componente vamos a colocar un componente ScrollBox en la página y vamos a cambiar la
propiedad Align del ScrollBox a Client, y vamos a pegar de nuevo los tres componentes
cortados. Ahora si el usuario le cambia el tamaño al formulario, una barra de
desplazamiento aparece en el formulario para un mejor control del ambiente. A
continuación una figura de nuestro formulario hasta el momento:

Componentes de caja de dialogo
La mayoría de las aplicaciones bajo Windows permiten configurarse, el mismo sistema

operativo permite cambiar los protectores de pantallas, el escritorio, así como personalizar
los colores de la pantalla. Usted puede incorporar este funcionamiento en sus aplicaciones
con el uso de los componentes de caja de dialogo que proporciona Delphi. Con los dos
componentes de caja de dialogo que veremos aquí, el usuario podrá cambiar el tipo de letra
y los colores.
Cambiando el tipo de letra y el color
Vamos a seguir trabajando en el mismo formulario, vamos a agregar otra página le

pondremos “Caja de dialogo” en la propiedad Caption. En esta página vamos a colocar dos
botones y un label. En el panel vamos a colocar los componentes FontDialog y
ColorDialog, en realidad no importa donde los coloquemos, pues ambos son invisibles y
cuando el formulario se ejecute ellos no se verán. El objetivo de esta página es cargar la
caja de dialogo Font o Color cuando el usuario presione el botón correspondiente, para que
el usuario pueda cambiar la apariencia del texto del label. Necesitaremos colocar dos líneas
de código en el evento OnClick de cada botón para cumplir con esta tarea:
procedure TForm1.Button2Click(Sender: TObject);

begin
FontDialog1.Execute;
Label1.Font := FontDialog1.Font;
end;
procedure TForm1.Button3Click(Sender: TObject);

begin
ColorDialog1.Execute;
Label1.Color := ColorDialog1.Color;
end;
A continuación un vistazo a nuestro trabajo:
Componentes del Sistema
Algunas aplicaciones necesitan la capacidad de permitirle al usuario abrir archivos. Delphi

tiene una serie de componentes del sistema que están diseñados para trabajar en conjunto.
Ellos permiten ver una lista de archivos, cambiar de unidad y de directorios y poner filtros
para la lista de archivos que cumplan con ciertos criterios.
Nosotros colocaremos cuatros de estos componentes en una tercera página de nuestro

formulario.
Cree una nueva página en el mismo formulario que hemos estado trabajando y póngale
“Manejador de Archivos” en la propiedad Caption. En esta página colocaremos un total de
cinco componentes: Edit, FileListBox, FilterComboBox, DirectoryListBox,
DriveComboBox. Como cada componente del sistema esta diseñado para trabajar con los
otros, cada uno de ellos tienen propiedades para referencial el tipo de componente
apropiado. Trabajando en orden inverso, al componente DriveComboBox lo ponemos a
referenciar el componente DirectoryListBox a través de la propiedad DirList; la propiedad
FileList de los componentes DirectoryListBox y FilterComboBox ponerlo a referenciar el
componente FileListBox; y por ultimo el componente Edit es referenciado por el
componente FileListBox mediante la propiedad FileEdit.
A continuación veremos como queda nuestro formulario después de las ultimas

operaciones:
Uso de los componentes Samples
Lo ultimo que nos falta por hacer es utilizar un componente de los que se encuentran en la
página Sample, para el caso será el componente Calendar. Agregaremos otra página y le
pondremos “Calendario” en la propiedad Caption del TabSheet. Colocaremos un
componente Calendar en la página y cuatros botones para navegar el calendario.
Utilizaremos los métodos que tiene el calendario para movernos entre meses y años
adelante y hacia atrás. En el evento OnClick de cada botón colocaremos una línea de
código de las que pondremos a continuación:
Calendar1.PrevYear;
Calendar1.PrevMonth;
Calendar1.NextMonth;
Calendar1.NextYear;
Antes de continuar con nuestro ejemplo vamos a ver el concepto del ultimo integrante de
un componente.
Método
Es una porción de código - procedimiento o función – que hace algo para el componente o
con el componente. En lugar de escribir el código que realice la función deseada, solo hay
que invocarlo ya que los métodos son partes que integran los componentes. Los métodos
varían de un componente a otro, así como la función que pueden realizar. Todas las líneas
de código que pusimos anteriormente corresponden a métodos del componente Calendar.
Estos métodos nos permiten movernos un mes o año hacia delante o hacia atrás.
La fecha actual del calendario la desplegaremos en la etiqueta y el código que realice esto
lo pondremos en el evento OnCreate del formulario. Cada vez que la fecha en el calendario
cambie la actualizaremos en el evento OnChange del calendario. Ambos manejadores de
eventos tendrán la misma codificación:
Label_SelectedDate.Caption := FormatDateTime('mmmm d, yyyy',

Calendar1.CalendarDate);
A continuación presentaremos una figura de nuestro formulario final:


Resumen de Interactuando con los componentes

Creación de Menú
En este capitulo:
 Concepto de menú
 Partes de un menú
 El diseñador de menú
 Componentes para crear menú
 Conexión de los menús con otros componentes

Introducción a la creación de menús
Un menú es una forma de proporcionar al usuario un conjunto de ordenes, lógicamente

relacionadas, agrupadas bajo un mismo título. El conjunto de todos los títulos
correspondientes a los menús diseñados aparecerá en la barra de menú situada debajo de la
barra de título del formulario.
Cuando el usuario hace clic en un título de un menú, se despliega automáticamente una lista
que visualiza las opciones de ese menú y si no contiene ningún elemento, se ejecuta el
evento asociado – si es que tiene alguno -. Las partes de un menú son: Opción, submenús y
separador.
Diseñador de menús
Es la herramienta que nos permite crear un menú en Delphi. El diseñador de menú permite
agregar, editar, borrar y reorganizar los elementos de los menús en tiempo de diseño,
además usted no tiene que ejecutar el programa para ver el resultado.
Para crear un menú existen dos formas: se puede comenzar a construir un menú desde la
nada; o se puede utilizar una de las plantillas de Delphi, las plantillas son modelos de
menús pre-construidos.

El diseñador de menú trabaja mas o menos igual que el diseñador de formularios. Ambas
herramientas permiten utilizar el inspector de objeto para configurar las propiedades de los
elementos que ellos contienen.
Como abrir el diseñador de menú
Para crear un menú principal (MainMenu) o menú de acceso directo (PopupMenu) primero
hay que colocar un componente MainMenu (para un menú principal) o un componente
PopupMenu (para un menú de acceso directo). Estos componentes se encuentran en la
página Standard de la paleta de componentes y sirven para crear los diferentes tipos de
menú que existen en Delphi.
Una vez que se ha colocado el componente en el formulario, para abrir el diseñador de

menú existen tres formas diferentes, que son:
 Doble-clic sobre el componente MainMenu o PopupMenu respectivamente;

 Seleccionando la propiedad Items en el Inspector de objetos y presionando la
ellipsis o haciendo doble clic sobre la palabra [Menú] en el valor de la propiedad;
 Y por ultimo haciendo clic con el botón de la derecha del Mouse sobre el
componente y seleccionando la opción Menú Designer del menú de acceso directo.
El diseñador de menú aparecerá con la primera opción seleccionada y la propiedad Caption

seleccionada en el inspector de objetos.
Punto de Inserción
El punto de inserción marca el lugar donde aparecerá la próxima opción cuando sea
introducida. Cuando se termina de introducir una opción, el punto de inserción se moverá
hacia abajo o hacia la derecha, para permitir insertar una nueva opción a la derecha – si se
están creando los títulos de los menús o un submenú - o hacia abajo – si se están agregando
opciones de un menú -.
Como Crear un Separador
Los separadores se utilizan para agrupar las opciones en función de su actividad. Delphi
permite crear diferentes tipos de separadores, entre estos tenemos la tradicional línea
horizontal, líneas verticales y multi-columnas sin líneas verticales. Para crear un separador
de línea horizontal solamente hay que poner un guión “-“ en la propiedad Caption de la
opción que se esta creando, no debe confundirse el guión “-“ con el signo de subrayado
“_”, es el guión el que debe utilizarse para crear el separador de línea horizontal.
Para crear los otros tipos de separadores debemos utilizar la propiedad Break de la opción,
los posibles valores que toma esta propiedad son:
 mbNone es el valor por defecto, y significa que no habrá ningún tipo de separador;
 mbBreak sirve para hacer un menú multi-columna sin líneas verticales entre las
columnas;
 mbBreakBar sirve para hacer un menú multi-columna con líneas verticales entre las
columnas.
Submenu
El submenú sirve para desplegar una nueva lista de opciones. Para crear un submenú lo
primero que hay que hacer es seleccionar la opción que contendrá el submenú y luego
utilizar una de las dos formas que existen para crear un submenú, estas formas son:
 Presionando la combinación de teclas Ctrl + tecla de flujo hacia la derecha

 Haciendo clic con el botón de la derecha del Mouse y seleccionando la opción
Create SubMenú del menú de acceso directo.
Una vez creado el submenú se vera un punto de inserción a la derecha de la opción que
contiene el submenú para agregar las opciones correspondientes.
Interruptores
Un interruptor en un menú no es mas que una opción que puede estar encendida o apagada
en un momento determinado. Normalmente estas opciones se construyen para activar o
desactivar una determinada función en la aplicación.
Existen dos tipos de interruptores que se pueden crear que son CheckItem y RadioItem.

Los CheckItem son aquellas opciones que pueden estar encendidas o apagadas. Cuando
están encendida tienen una marca de cotejo del lado izquierdo de la opción en caso
contrario no tienen nada. La figura anterior muestra un menú con opciones CheckItem.
Los radioItem permiten seleccionar una opción de entre varias. Usted solo puede
seleccionar una de todas las opciones. En este tipo de menú aparece un pequeño punto del
lado izquierdo de la opción cuando una opción esta seleccionada.
Teclas de acceso directo
La mayoría de las aplicaciones permiten ejecutar una opción de un menú mediante el

teclado. Esto facilita el trabajo del usuario en situaciones donde la interacción con la
aplicación se desempeña en la mayor parte del tiempo con el teclado en vez del Mouse. Las
opciones de los menús permiten definir combinaciones de teclas para permitir utilizar el
teclado. Estas combinaciones de teclas reciben el nombre de ShortCut o teclas de acceso
directo. Las teclas de acceso directo pueden ser definidas para cada opción en el inspector
de objeto mediante la propiedad ShortCut de la opción del menú.
Además de las combinaciones de teclas es posible acceder a un título de un menú mediante

la tecla Alt. Este tipo de Shortcut se puede crear también, para hacer esto solamente hay
que colocar un carácter & (Ampersand o I comercial) delante de la letra elegida para el
ShortCut.
Nota: nunca repita una misma letra para mas de una opción en el mismo nivel, esto no
producirá ningún error, pero solamente se ejecutara la opción que este en primer lugar.
Componente MainMenu
Este componente se encuentra ubicado en la paleta de componente Standard y sirve para

crear un menú principal como el menú principal de Delphi.
Componente PopUpMenu
Este componente se encuentra ubicado en la paleta de componente Standard y sirve para

crear un menú de acceso directo. Los menús de acceso directo son llamados al hacer clic
con el botón de la derecha del Mouse

El diseñador de menú funciona igual para cualquiera de estos componentes. La única

diferencia es el tipo de menú que hace cada uno.
Conexión de los Menús
Para que un menú funcione debe ser conectado a su respectivo componente.
El componente MainMenu solamente puede ser conectado a formularios, pues los menús
principales siempre van en la parte superior de un formulario. Para conectar un menú
principal con un formulario se utiliza la propiedad Menu del formulario, aquí aparecerá una
lista de todos los componentes MainMenu que están colocados en el formulario. También
es posible cambiar el menú de un formulario en tiempo de ejecución, para esto cambiamos
el valor de esta propiedad por código de programación. Normalmente el usuario no tiene
que conectar el menú principal con el formulario, pues tan pronto se coloca el componente
MainMenu en el formulario automáticamente es conectado con el mismo.
El componente PopupMenu a diferencia del componente MainMenu puede ser conectado a

la mayoría de componentes. Este es conectado con los demás componentes a través de la
propiedad PopupMenu. Este hay que conectarlo explícitamente, es decir, hay que ir a la
propiedad PopupMenu del componente al que se desea conectar y conectarlo, no ocurre
automáticamente como con el MainMenu.
Practica: Creación de un menú principal
En esta practica vamos a crear un menú con las siguientes opciones:
o Mantenimientos
 Clientes
 Vendedores
 Artículos
 Almacenes
 Unidades
o Procesos
 Facturación
 Devoluciones
 Cancelación de facturas
 Reimpresión de facturas
 Registro de inventario
o Consultas
 Ventas del día
 Ventas por vendedor
o Reportes
 Ventas
 Devoluciones
Cree un nuevo proyecto para esto seleccione la opción File | New Application del menú
principal de Delphi. Esto creara un nuevo proyecto y un nuevo formulario dentro del
proyecto. Cambie el nombre al formulario, para esto utilice la propiedad Name, póngale de
nombre Form_Menu; Cambie el título del formulario, para esto utilice la propiedad
Caption, póngale “Mini-Sistema de Punto de Venta – Menú Principal -”. Grabe el proyecto
y la unidad en el directorio de trabajo que creamos anteriormente (CSSDelphi), para esto
seleccione la opción File | Save Project As... del menú principal de Delphi, grabe la unidad
con el nombre UnitFormMenu y grabe el proyecto con el nombre de PtoVenta.
Coloque un componente MainMenu en el formulario, haga doble-clic sobre el componente

MainMenu – esto cargara el editor de menú – Digite “Mantenimientos” y presione la tecla
Enter – esto permitirá definir la primera opción del menú.
Ahora aparecen dos puntos de inserción uno al lado de Mantenimiento y otro debajo; el que
esta debajo esta seleccionado, si no lo esta selecciónelo para que construyamos el menú de
mantenimientos. Ahora digite “Clientes” y presione la tecla Enter, digite “Vendedores” y
presione la tecla Enter, digite “Articulos” y presione la tecla Enter, digite “Almacenes” y
presione la tecla Enter, digite “Unidades” y presione la tecla Enter. Cabe mencionar que
cada vez que se digita una opción y se presiona la tecla Enter, el editor de menú inserta la
opción digitada y un nuevo punto de inserción en blanco para que se continúen agregando
opciones al menú. Cada una de las opciones anteriores debe ser digitadas en un punto de
inserción en blanco, pues si lo hace sobre el mismo, lo que ocurrirá es que se irán
sobrescribiendo las opciones. Aunque si se sigue el procedimiento anterior no habrá ningún
inconveniente, se hace el comentario por si acaso usted se equivoca y selecciona una
opción ya introducida. Nuestro menú hasta ahora debe lucir como la figura siguiente:

Ahora vamos a continuar la construcción de nuestro menú, seleccione el punto de inserción

que se encuentra al lado del menú mantenimiento, y digite “Procesos” y presione la tecla
Enter, al igual que con el menú mantenimientos aparece el menú procesos, un punto de
inserción al lado y un punto de inserción debajo y seleccionado para introducir las opciones
del menú procesos. Digite “Facturación” y presione la tecla Enter, digite “Devoluciones” y
presione la tecla Enter, digite “Cancelación de facturas” y presione la tecla Enter, digite
“Reimpresión de facturas” y presione la tecla Enter, digite “Registro de inventario” y
presione la tecla Enter.
Seleccione el punto de inserción que se encuentra al lado del menú procesos, y digite
“Consultas” y presione la tecla Enter, al igual que con los menús anteriores aparece el
menú Consultas, un punto de inserción al lado y un punto de inserción debajo y
seleccionado para introducir las opciones del menú consultas. Digite “Ventas del día” y
presione la tecla Enter, digite “Ventas por vendedor” y presione la tecla Enter.
Seleccione el punto de inserción que se encuentra al lado del menú consultas, y digite
“Reportes” y presione la tecla Enter, al igual que con los menús anteriores aparece el menú
Reportes, un punto de inserción al lado y un punto de inserción debajo y seleccionado para
introducir las opciones del menú reportes. Digite “Ventas” y presione la tecla Enter, digite
“Devoluciones” y presione la tecla Enter. Hemos terminado de construir nuestro menú,
ahora nuestro menú debe lucir como la siguiente figura:
Cierre el editor de menú.
Grabe la unidad y el proyecto para que reflejen los nuevos cambios, ya que lo utilizaremos
en las practicas de los siguientes capítulos. Para grabar todos los cambios utilice la opción
File | Save All del menú principal de Delphi.
Ejecútelo y pruebe nuestro menú que acabamos de construir.
Por supuesto usted hace clic sobre las opciones y nuestro menú no hace nada, no desespere
mas adelante construiremos otros formularios que los llamaremos desde nuestro menú.

Apertura de un formulario desde el menú
Cada elemento del menú es un componente en sí – pues tiene propiedades, eventos y

métodos-. Cuando usted quiera ejecutar alguna orden, comando o código de algún proceso,
solamente tiene que programar un evento en la opción deseada del menú, normalmente esto
se realiza en el evento OnClick de la opción.
Métodos para manipular formularios
Los métodos para manipular o cargar un formulario son: Show y ShowModal.
El primero (Show) permite abrir un formulario no Modal, lo que significa que usted puede
acceder al formulario que lo cargó, sin necesidad de cerrar el formulario cargado, por
ejemplo: si usted tiene un formulario A y desde éste formulario usted cargó el formulario B
utilizando el método Show, usted puede acceder al formulario A sin necesidad de cerrar el
formulario B.
El último (ShowModal) permite abrir un formulario Modal, lo que significa que usted no
puede acceder al formulario que lo cargó hasta que cierre el formulario cargado, por
ejemplo: si usted tiene un formulario A y desde éste formulario usted cargó el formulario B
utilizando el método ShowModal, usted no podrá acceder al formulario A hasta que no
haya cerrado el formulario B.
La sintaxis para utilizar cualquiera de ellos es la misma utilizada para ejecutar cualquier
método de un componente, esto es:
Nombredelcomponente.nombredelmetodoaejecutar;
Por ejemplo: si tenemos un formulario que se llama frmClientes y lo queremos cargar desde
otro formulario, escribiríamos la siguiente línea de código:
frmClientes.Show;
o
frmClientes.ShowModal;
de acuerdo al modo como se desee utilizar.
Pues bien después de haber revisado los métodos utilizados para cargar un formulario,
vamos a cargar un formulario desde un menú, lo primero que debemos hacer es seleccionar
la opción del menú desde la cual llamaremos el formulario y hacemos clic sobre ella –esto
abrirá el editor de código- y ahí solamente tenemos que poner el código que cargue nuestro
formulario de acuerdo a lo discutido anteriormente.
La cláusula Uses
Sirve para identificar todas las unidades utilizadas por un programa, y significa que a partir
de esa línea se podrán utilizar todas las variables, tipos de datos, constantes,
procedimientos, funciones y componentes; siempre y cuando estos hayan sido declarados
públicos para las otras unidades. La cláusula uses permite que dos unidades puedan
compartir los recursos entre ellas.
Cuando usted intenta utilizar algunos de los elementos de una unidad (variables, tipos de
datos, funciones, etc), en otra unidad y usted no ha puesto en uso (Uses) la unidad que
contiene los elementos referenciados obtiene un mensaje de error o un mensaje de
información parecido al siguiente:
El mensaje se puede interpretar de la siguiente manera: “El formulario Form1 hace

referencia al formulario Form2 que se encuentra declarado en la unidad Unit2, la cual no
se encuentra en la lista de la cláusula Uses. ¿Desea agregarla?”. En este caso solamente hay
que contestar “Yes” y Delphi automáticamente agregará la unidad referida en el mensaje a
la cláusula Uses y el problema se habrá resuelto.
Por otro lado, en el caso que éste mensaje no aparezca y usted esté tratando de utilizar
algún elemento de otra unidad, usted debe agregar la unidad manualmente en la lista Uses.
También se debe prestar especial atención en el caso que se haya colocado en la lista Uses
el nombre de una unidad, y luego se haya grabado con otro nombre la unidad, Delphi
renombrara la unidad, pero no lo hará con las unidades que se encuentran en la lista Uses,
por ejemplo: Imagínese que usted esta construyendo una aplicación que constaría de dos
formularios, usted crea un formulario nuevo (la unidad se llamaría Unit1 y el formulario
Form1) y luego crea el segundo formulario (la unidad se llamaría Unit2 y el formulario
Form2). Ahora usted procede a llamar el segundo formulario (Form2) desde el primer
formulario (Form1), el código que usted colocó para llamar el segundo formulario fue
Form2.Show; apareció la ventana de información diciéndole que el form1 referencia el
form2..., usted respondió “Yes” y el Unit2 fue agregado a la lista Uses del Unit1.
Usted ejecuta su aplicación y todo funciona correctamente. Pero ahora usted decide grabar,
graba las unidades con los siguientes nombre: UPrincipal para el Unit1, USecundario para
el Unit2 y PUsesPrueba para el proyecto. Intenta correr la aplicación de nuevo y obtiene el

siguiente mensaje de error: [Error] File not found: 'Unit2.DFM'.
¿Pero qué pasó? ¿Qué es esto?.. Se preguntará usted, es sencillo usted tiene en uso la
unidad Unit2 en la lista Uses de la unidad UPrincipal (antes unit1) y si usted mal no
recuerda usted la grabó con otro nombre y como el archivo Unit2 no se encuentra en el
disco duro le da este mensaje de error. Como habíamos mencionado anteriormente, Delphi
no actualiza los nombres de las unidades en la lista Uses, usted tiene que hacerlo
manualmente. Así que vaya a la unidad UPrincipal, localice Unit2 y cámbielo por
USecundario y el problema estará resuelto.
Apertura de un formulario de la lista Auto-Create forms
Cuando usted desee cargar un formulario desde otro formulario y el formulario que se va a
cargar se encuentra colocado en la lista Auto-Create forms del proyecto, solamente hay que
llamar uno de los dos métodos para desplegar el formulario (Show o ShowModal).
¿Qué significa la lista Auto-Create forms del proyecto?
La lista Auto-Create forms del proyecto contiene todos los formularios que serán
automáticamente creados (colocados en memoria) por el proyecto (aplicación) cuando este
comience a ejecutarse. De esta forma se gana tiempo al momento de llamar los formularios,
pues no hay que cargarlos antes de llamarlos; pero la aplicación tarda mas tiempo en cargar,
ya que tiene que ir colocando en memoria cada uno de los formularios que se encuentran en
la lista Auto-Create forms del proyecto.
De esta forma cuando un formulario ha sido previamente cargado en memoria por Delphi,
solamente hay que llamar el formulario con uno de los dos métodos dependiendo del modo
como se desee desplegar, por ejemplo:
Form2.Show; Para desplegar un formulario no Modal
Apertura de un formulario de la lista Available forms
Cuando usted desee cargar un formulario desde otro formulario y el formulario que se va a
cargar se encuentra colocado en la lista Available forms del proyecto, usted debe cargar en
memoria el formulario antes de llamar uno de los dos métodos para desplegar el formulario
(Show o ShowModal).
¿Qué significa la lista Available forms del proyecto?
La lista Available forms del proyecto contiene todos los formularios que no serán
automáticamente creados (colocados en memoria) por el proyecto (aplicación) cuando este
comience a ejecutarse. De esta forma se gana tiempo al momento de cargar la aplicación

pues no tiene que colocar en memoria los formularios, pero antes de llamar un formulario el
usuario debe cargarlo en memoria o recibirá un mensaje de error como el siguiente:
Un mensaje de error de violación de memoria, este error ocurre cuando usted intenta
acceder a un objeto que aun no ha sido creado (colocado en memoria), no importa el objeto
que sea, así pues cada vez que este error le ocurra, verifique que haya creado con
anterioridad el objeto al que se hace referencia, esta referencia puede ser a una propiedad,
método o evento.
En Delphi existe una regla general que dice así: “Si Delphi lo crea, Delphi lo destruye; Si
usted lo crea, usted es responsable de destruirlo”.
Application.CreateForm(Tform2,Form2); Para crearlo en memoria.

Form2.Show; Para desplegar un formulario no Modal.
Con el código anterior, primero se crea en memoria el formulario y después es desplegado

con el método show. Cuando se utiliza este método para visualizar formularios, se debe
colocar el código para destruir el formulario (liberar la memoria), recuerde la regla de
Delphi ... si usted lo crea, usted es responsable de destruirlo. Si esta regla no se respecta,
cada vez que usted visualice el formulario, se volverá a crear en memoria, lo que puede
causar que se agote la memoria en la computadora.
Método para destruir un formulario
Destruir un objeto no es mas que liberar el espacio de memoria utilizado por el objeto. Para
destruir un formulario podemos utilizar el método Release del formulario. Para destruir un
formulario creado por usted (lista Available forms), programe el evento OnClose del
formulario y utilice el método release, por ejemplo:
Form2.Release; Libera la memoria utilizada por el formulario Form2.

Resumen de creación de menús

Lenguaje Object Pascal

En este capitulo:
 Breve historia del lenguaje Pascal

 Elementos fundamentales del lenguaje Object Pascal
 Tipos de datos disponibles

LENGUAJE PASCAL
Breve Historia
Pascal fue originalmente disecado por Nicklas Wirth a finales de los 60s, pero fue
considerado uno de los primeros lenguajes de los 70s. Wirth creo Pascal en respuesta a otro
lenguaje que fue desarrollado en ese tiempo, Algol 68. Ambos lenguajes estaban basados
en el lenguaje Algol 60, pero Algol 68 fue considerablemente más complejo. Wirth creo
Pascal para incorporar el funcionamiento opuesto de Algol 68. Él quería crear un lenguaje
pequeño, simple que pudiera combinar el poder con la simpleza. De hecho, Pascal fue
introducido y todavía es usado como uno de los primeros lenguajes para los estudiantes de
computadoras.
Pascal fue visto primeramente como un lenguaje académico hasta su lanzamiento al

mercado, en 1984, de Turbo Pascal de Borland. También hubo otras implementaciones de
Pascal en los computadores personales, la primera versión de Turbo Pascal fue
tecnológicamente superior a los otros, especialmente en velocidad de compilación (a esto se
debe el nombre Turbo). Borland continuo mejorando su producto, cambiando la
arquitectura básica del lenguaje en la versión 3 (con la introducción de las unidades) y la
versión 5.5 (con la introducción de objetos). Delphi es lo ultimo en la línea distinguida de
los compiladores Pascal de Borland. De hecho, Object Pascal, que es encontrado en Delphi
es un súper conjunto de la versión previa de Pascal, Borland Pascal con la versión de
objetos 7.1
Estructura de un programa en Object Pascal
En todo programa Object Pascal se encuentra dos partes: el encabezado y el bloque del
programa; este ultimo formado a su vez por una parte declarativa y otra ejecutable o
sentencia.
Encabezado del programa
El encabezado del programa, especifica el nombre y sus parámetros. El encabezado es

opcional y no tiene significado en el Object Pascal, por Ejemplos:
Program hola;
Program Reporte;
Sentencia

Los programas, procedimientos y funciones están todos compuestos por sentencias que no
es nada mas que cada una de las líneas ejecutables de código. Las sentencias pueden ser
simples y compuestas. Ejemplos de sentencias simples son asignaciones, llamadas de
procedimientos o funciones, por Ejemplos:
A:= 20;
Nombre:=’Jose’;
Inicializacion;
Se pueden tener sentencias compuestas en cualquier parte donde puede haber una sentencia
simple. Una sentencia compuesta es un grupo de sentencias tratadas como un bloque. El
inicio de una sentencia compuesta esta siempre delimitado por la palabra BEGIN y el final
de una sentencia compuesta esta delimitado por la palabra reservada END, por Ejemplo:
If A = 20 then
Begin
Showmessage(‘El Valor de A es: ‘ + IntToStr(A));
A:= 0
End;
El punto y coma, y el punto
El punto y coma tiene una sección aparte porque la mayoría de los programadores nuevos
en Object Pascal tienen problema con el. Si usted tiene experiencia de programación en un
Xbase o Basic, suena inusual poner un punto y coma después de cada línea de código. En
los Xbase un punto y coma sirve para continuar una línea de código en una próxima línea.
Note que, en Object Pascal, usted puede crear múltiples líneas de códigos que hagan una
sentencia simple. Para empeorar las cosas, hay situaciones en las que usted no puede poner
un punto y coma.
Bueno, esta es la regla: Todas las sentencias en un programa Pascal tienen que ser
separadas por un punto y coma. En este caso, note que sentencia se refiere a ambas,
sentencia simple y compuesta. Esta es la razón por la cual no hay punto y coma después del
BEGIN y el punto y coma antes del END es opcional. Por eso en el ejemplo de abajo, la
sentencia de asignación no tiene un punto y coma porque hay un END después. Pero el
END tiene que tener un punto y coma después porque es el final de una sentencia
compuesta.
If A = 0 then
Begin
Showmessage(‘A es igual a 0’);
A:=10
End;

Otro punto difícil es el uso de END que no tienen el BEGIN correspondiente. En la

mayoría de los casos, el par BEGIN .. END van juntos, hay excepciones donde usted tiene
END sin BEGIN las ocurrencias mas comunes son: la instrucción CASE; los bloques TRY
… FINALLY; la definición de registros, la definición de tipos de datos.
Una ultima nota sobre la puntuación en los programas en Object Pascal. El ultimo END del
programa termina en un punto, no en punto y coma. El punto indica al compilador que este
es el fin del programa. Afortunadamente, Delphi se encarga de este detalle.
Operadores
Un operador es un elemento del lenguaje, representado por un símbolo cuya finalidad es

generar un resultado manipulando uno o dos operando. Object Pascal en su mayoría
necesita dos operando. La combinación de operando y operadores da lugar a lo que se
denomina expresión.
Asignación vs. Igualdad
El Operador de asignación en Object Pascal es los dos puntos seguidos del signo
igual(‘:=’). Esto es diferente al operador igual (‘=’) que es utilizado para probar o comparar
la igualdad entre dos expresiones y para la definición de tipos.
Los operadores se clasifican en aritméticos, lógicos, relaciónales.
Operadores aritméticos
Los operadores aritméticos son aquellos que nos facilitan la realización de operaciones
aritméticas y son siempre binarios, actuando sobre dos operando.
Operador Función
+ Suma
- Resta
* Multiplicación
/ División
Div División entera
Mod Resto de división entera

Operadores lógicos
A los operadores lógicos también se les conoce como operadores "Boléanos", ya que
trabajan sobre valores de tipo boolean (true o false), Una expresión relacional simple
devolverá un tipo de dato booleano dependiendo de que la relación sea cierta o falsa
Operador Función
Not Negación a nivel de bit
And Y a nivel de bit
or O a nivel de bit
Xor O exclusivo a nivel de bit
Operadores relacionales
Los operadores relacionales nos permiten obtener una afirmación o negación de una
determinada relación entre dos operando.
Operador Función
= Igual
<> Diferente de
< Menor que
<= Menor o igual que
> Mayor que
>= Mayor o igual que
Precedencia de operadores y orden de evaluación
Tal como sucede en matemática, se debe saber cómo evaluar una expresión. Para ello se
necesita conocer en que orden se deben evaluar las diferentes partes de la expresión. Al
igual que en matemática, la precedencia de los operadores afecta los resultados del código,
como se puede ver en la siguiente tabla:
Operadores Precedencia
Not Primera
*, /, div, mod, and Segunda
+, -, or, xor Tercera
=, <> ,> ,< ,<=, >=, in, is Cuarta
Bloque del programa
Los bloques están formados por declaraciones y sentencias, los bloques no solo forman
parte de un programa sino también de un procedimiento, función o una unidad.

La parte declarativa, declara todos los identificadores (constantes, tipo, variable y

subrutina) a ser usados dentro de la parte de sentencias o ejecutable y de los otros bloques
dentro de el.
La parte ejecutable o de sentencias es la otra parte del bloque, la que es usada para describir
el algoritmo del bloque; esta parte esta formada por una sentencia compuesta.
Introducción a las unidades
Las unidades que son módulos residentes (previamente compilados), que se incorporan en
un programa, es una colección de constantes, tipos de datos, variables, procedimientos y
funciones.
Como en un programa Object Pascal, una unidad tiene la parte de encabezado y el cuerpo.
La parte de encabezado, es como el encabezado de un programa y solo difiere en la palabra
reservada unit.
Las unidades, son invocadas en los programas o en otras unidades, mediante la cláusula
uses, seguida de uno o más identificadores, lo que amplia la parte declarativa de un modulo.
El cuerpo de una unidad consta de la interface o parte publica, implementation o parte

privada, Initialization y finalization.
La parte que se inicia con la palabra reservada interface, es "visible" a cualquier aplicación
(inclusive a otra unidad); Aquí se encuentran las declaraciones de las constantes, tipos,
variables y los encabezados de los subprogramas que pueden ser accesados exteriormente.
La parte privada de una unidad, comienza con la palabra reservada implementation; y

define los subprogramas, cuyas declaraciones de encabezados aparecen en la sección
publica; además de constantes, tipos y otras declaraciones que serán "no visibles" a otros
módulos.
La sección de inicio y finalización, es una sentencia compuesta, en donde se inicializa y

finaliza la estructura de datos.
Ejemplo de una unidad en Object Pascal y particularmente en Delphi:
unit Hola;
interface
uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs;

type
Tform1 = class(TForm)
procedure FormShow(Sender: TObject);
private
{Private declarations}
public
{Public declarations}
end;
var
Forml: Tforml;
implementation
{$R *.DFM}
procedure TForml.FormShow(Sender: TObject);

begin
Label1.Caption := ‘Hola’;
end;
end.
Declaración de constantes y variables
En Object Pascal a diferencia de lo que ocurre en otros lenguajes como Visual Basic por
ejemplo, cualquier variable debe ser declarada antes de utilizarse.
Las constantes y variables se declaran en la parte de declaración de variables.
Una constante numérica o string es declarada mediante un identificador, por Ejemplos:
const
pi =3.14159;
alfa =2*pi;
mensaje= ‘Hola!!!’
Mediante la declaración una variable es creada y designado por su tipo. La forma de

utilizarlos es mediante la palabra reservada: var
var
contador, auxiliar : Integer;
cadena : String;
vector : Array[l...50] of word;
otra de las cosas fundamentales son los registros, conjuntos, matrices, etc.
Veamos unos ejemplos de declaraciones:
type TDtaSemana = (Lunes, Martes, Miércoles, Jueves, Viernes, Sábado, Domingo);

TMiRegistro = Record
Nombre: String;
Direccion: String;
Edad : Byte;
End;
var Matriz : Array [1..25] of Single;
Jose : TMIRegistro;
Conjunto : TDiaSemana
Las variables en un programa, se clasifican por su ámbito o alcance en: globales y locales.
Las variables que se encuentran declaradas fuera de un procedimiento o función son

globales, las declaradas dentro de un procedimiento o función son variables locales.
Tipos de datos
Object Pascal dispone de todos los tipos de datos necesarios para facilitar el trabajo con
números en distintas precisiones, cadenas de caracteres y direcciones de memoria. A partir
de estos tipos podemos definir tipos de datos adicionales, mas complejos que los ya
existentes, y adaptarlos a nuestras necesidades.
Tanto para declarar una variable como para utilizar una constante, es necesario el que
conozcamos los diferentes tipos de datos con los que se puede trabajar.
Estos tipos nos permitirán trabajar con números de diferentes precisiones, además de
caracteres, punteros, etc.
A continuación se enumeran los tipos de datos mas habituales:

Tipo Rango Bytes que ocupa

Byte [0, 255] 1 Byte
ShortInt [-128.127] 1 Byte
SmallInt [-32768, 32767] 2 Bytes
Word [0, 65535] 2 Bytes
Integer [-65536, 65535] 4 Bytes
LongInt (-2147483648, 2147483671 4Bytes
Cardinal [0, 2147483647] 4 Bytes
Boolean {True,False} 1 Byte
ByteBool {True, False} 1 Byte
WordBool {True, False} 2 Bytes
LongBool {True, False} 4 Bytes
Real [2.9 x 10-39, 1.7 x 1038] 6 Bytes
Single [1.5 x 10-45, 3.4 x 1038] 4 Bytes
Double [5.0 x 10-324, 1.7 x 10308] 8 Bytes
Extended (3.4 x 10-4932, 1.1 x 104932] 10 Bytes
Comp [-263+1, 263-1] 8 Bytes
Currency (-922337203685477.5808, 8 Bytes
922337203685477.5807]
String ASCII 1 Byte - 4 GBytes
Hay otros mas, pero estos son los más importantes.
Identificadores
Para poder dar nombre a una variable tendremos que crear un identificador o, lo que es lo
mismo, crear un nombre para dicha variable. Para ello primero debemos conocer las reglas
de nomenclatura que rigen el lenguaje Object Pascal, de tal forma que nuestros
identificadores se ajusten a ellos y sean validos.
El primer carácter de un identificador debe ser necesariamente una letra o un carácter de

subrayado, el resto del identificador estará compuesto indistintamente por letras, números y
caracteres de subrayado, sin importar el orden. Tenga en cuenta que en el conjunto de letras
no puede usar vocales acentuadas ni la letra ñ, Si intenta hacerlo obtendrá del compilador
un mensaje de error sintáctico. No es posible usar ningún carácter adicional a los
enumerados, por lo tanto no serán validos aquellos identificadores que utilicen guiones,
espacios u otros caracteres.
A pesar de que un identificador Object Pascal puede tener cualquier longitud, el compilador
tan solo tendrá en cuenta los primeros 63 caracteres, por lo que si existen dos
identificadores que a pesar de ser distintos coincide en sus primeros 63 caracteres, el
compilador creerá que se trata de un mismo identificador, generándose un error.

Además, Object Pascal no distingue entre mayúsculas y minúsculas, por lo que los
identificadores pueden declararse con una cierta combinación de mayúsculas y minúsculas
y después usarse otra distinta, ya que el compilador lo que tiene en cuenta es cuales
caracteres componen el identificador y en que orden.
No podrán existir dos identificadores iguales a no ser que estén en ámbitos diferentes. De
esta forma, los procedimientos diferentes podrán declarar variables con el mismo nombre
sin problema alguno (no es absurdo esto puesto que en algunos lenguajes no existe el
ámbito de las variables, y una variable es global y visible para todo el mundo, con lo que 2
variables con el mismo nombre no pueden coexistir).
Conversión de tipos (cast)
Object Pascal y particularmente Delphi incluye la conversión de un tipo de dato a otro, así
como la conversión de una variable de tipo fecha en una string, una variable real a un
entero, un string a un entero, etc.
Para la conversión de tipos, se siguen una serie de reglas como por ejemplo, una variable de
tipo real toma en cuenta 15 cifras significativas al convertir a un string, etc. Como ejemplo
podemos ver la conversión de una cadena de caracteres a un numero entero.
procedure TForml.ButtonlClick(Sender: TObject);

var
S : string;
I: Integer;
begin
S := ‘22467’;
I := StrToint(S);
Inc(I);
Label1.Text := IntToStr(I);
end;
Estructuras de Control
Las estructuras de control permiten tomar decisiones y realizar un proceso repetidas veces.
IF ... THEN ... ELSE ...
Permite tomar una decisión referente al camino a seguir o acción a ejecutar en un proceso
basándose en el resultado (verdadero o falso) de la evaluación de una expresión. Su sintaxis
es:
If expresión then sentencia1 [else sentencia2]

Donde expresión debe ser una expresión numérica, relacional o lógica. El resultado que se
obtiene al evaluar la expresión es verdadero (True) o falso (False).
Si la expresión es verdadera, se ejecuta la sentencia 1 y si la expresión es falsa se ejecuta la

sentencia 2; siempre y cuando se haya utilizado la cláusula else.
En cualquier caso, la ejecución continua con la siguiente sentencia ejecutable después del
if, por ejemplo:
If Delphi > C then

ShowMessage(‘Estas en lo cierto’)
else
ShowMessage('Esto nunca sucederá');
A:=A + 1;
CASE <x> OF
Esta instrucción permite ejecutar una de varias acciones en función del valor de una
expresión. Cuando lo que se necesita es comparar la misma expresión con diferentes
valores. Su sintaxis es:
case expresión of
lista 1: sentencia 1;
...
lista n: sentencia n;
else
sentencia
end;
ejemplo:
case numero of
1: Showmessage(‘El numero es el 1’);
2: ShowMessage('El numero es el 2');
end;
Estructuras de Repetición
FOR ... DO
Permite ejecutar una sentencia un numero determinado de veces. Su sintaxis es:
for variable control := valor inicial to valor final do sentencia

for variable control := valor inicial downto valor final do sentencia;
ejemplo:
for contador := 1 to 25 do
begin
ShowMessage('Hola Mundo');
end;
WHILE ... DO
Repite la ejecución una sentencia mientras una condición dada sea cierta. La condición se
verifica antes de ejecutarse la sentencia. Su sintaxis es:
while expresión do sentencia
Donde expresión es cualquier expresión numérica, relacional o lógica.
Ejemplo
Contador := 1;
while contador <25 do
begin
inc(contador);
end;
La ejecución del while sucede así:
1. Se evalúa la expresión
2. Si el resultado de la evaluación es falso, la sentencia que forma el cuerpo de while no se

ejecuta y se pasa el control a la siguiente sentencia.
3. Si el resultado de la evaluación es verdadero, se ejecuta la sentencia y el proceso

descrito se repite desde el punto 1.
REPEAT... UNTIL
Repite la ejecución de un conjunto de sentencias hasta que una condición dada sea cierta.
La condición se verifica después de ejecutarse el conjunto de sentencias. Su sintaxis es:

repeat
sentencia 1;
…;
sentencia n;
until expresión
donde expresión es cualquier expresión numérica, relacional o lógica.
Contador := 1;
repeat
inc(contador);
until contador> 25;
Funciones y procedimientos
Un programa en Object Pascal, esta compuesto de uno o más bloques y alguno de ellos
anidados; es decir conteniendo otro bloque. Los bloques son llamados subprogramas, y
pueden ser funciones y procedimientos.
La diferencia entre uno y otro tipo es que las funciones devuelven un valor y los
procedimientos no. Pero esto prácticamente ya lo sabe todo el mundo.
También es posible la diferenciación del paso de parámetros por valor o por referencia.
Veamos unos ejemplos:
procedure Muestramensaje(mensaje: string[25] );

begin
showMessage(mensaje);
end;
function intercambiarySumar(var x, y : integer) : integer;

var auxiliar:integer;
begin
auxiliar:=x;
x :=y;
y := auxihir;
Result :=x+y;
end;

Resumen del Lenguaje Object Pascal

Manejo de errores en Delphi

En este capitulo
 Manejo de errores con excepciones

 Sintaxis y uso del bloque Try..Finally
 Protección de recursos
 Sintaxis y uso del bloque Try..Except

Introducción al Manejo de errores en tiempo de ejecución
El manejo de errores es la forma de sobrevivir en el desarrollo de software, porque las

aplicaciones deben ejecutarse bajo una variedad de condiciones y situaciones inusuales, el
programador debe proporcionar una vía para manejar de una forma satisfactoria los errores
inevitables que ocurran en la ejecución de un programa.
Manejo de errores con excepciones
El manejo de excepciones estructuradas es una característica nueva del lenguaje Object

Pascal. Esta extensión del lenguaje tiene realmente dos aspectos: primero, garantiza que
cualquier recurso alocado en memoria o cambiado en la aplicación pueda ser restaurado
propiamente sin ningún problema, aun después de un error grave en tiempo de ejecución;
segundo, representa, una forma estructurada para lidiar con errores de todos los tipos en
tiempo de ejecución, aun aquellos que son fatales para la aplicación.
Sintaxis para la captura de excepciones
Como habíamos dicho anteriormente, el manejo de excepciones en Delphi tiene dos

aspectos diferentes, pero que son relacionados uno con el otro. Aun así ambas variedades
de manejo de excepciones comienzan con la misma instrucción Try..., aunque ambos
sirven para diferentes fines. Primero vamos a ver la sintaxis del manejo de excepciones
para la protección de recursos.
Try ... finally
La sintaxis para el bloque try ... finally es la siguiente:
Try
<sentencia>;
<sentencia>;
finally
<sentencia>;
<sentencia>;
end;
El bloque try ... finally comienza con la palabra reservada Try, seguido por una o más
líneas de código. Además debe notarse que esta es otra construcción Object Pascal que
inicializa un bloque de sentencia pero que no requiere de un begin aunque termina en end.

El cuerpo del bloque termina con la palabra reservada finally. A continuación del Finally
puede ir una o más líneas de código.
El bloque try ... finally garantiza que la porción de código que se encuentra después de
finally se ejecutará sin importar que ocurra. En otras palabras, si no hay error o ninguna
circunstancia inusual ocurre mientras el bloque try ... finally se esta ejecutando, el código
que se encuentra después de finally se ejecuta de forma normal, como si no existiera
ningún bloque try ... finally. Ahora bien, el poder de esta estructura es cuando una
condición de error ocurra durante la ejecución del código que se encuentra después de try,
bajo esta circunstancia, cualquier código que se encuentre después del finally se ejecutará
antes que el control de ejecución abandone el bloque de código. Aun cuando un error fatal
ocurra en la porción de código del try, el código en el finally siempre se ejecutará.
Protección de recursos
El comportamiento del bloque try ... finally es particularmente muy útil en un par de
situaciones diferentes. La primera es protección de recurso. Antes una breve introducción
acerca del manejo de los recursos en Windows. Windows se encarga de todos los recursos
que son alocados y usados por las aplicaciones. Cuando una aplicación necesita mas
recursos(memoria, manejadores de gráficos, etc.), la aplicación le pide a Windows que se la
proporcione, es entonces responsabilidad de la aplicación de liberar ese recurso cuando
termine de utilizarlo.
Cuando una aplicación en Windows ocupa recursos y nunca lo libera se dice que tiene
escape de recursos. Si la aplicación no libera los recursos, el recurso se encuentra ocupado
hasta que la aplicación termine, por ejemplo: si un programa le pide a Windows un
manejador de grafico (para dibujar algo en la pantalla) y nunca libera el manejador, el
numero disponible de manejadores de gráficos se reduce. Esta aplicación es considerada
como de pobre funcionamiento en Windows.
El bloque try ... finally es la solución perfecta para la protección de recursos en

aplicaciones Delphi. De hecho, la regla de Delphi es si usted lo crea, usted es responsable
de destruirlo. Esto incluye la reservación de memoria hecha cuando se llaman los
constructores de los objetos. Si usted explícitamente llama un constructor, usted es
responsable de ejecutar el destructor también. El bloque try ... finally proporciona una
forma eficaz para asegurarse que el destructor será ejecutado cuando usted termine con el
objeto.
Como ejemplo, la aplicación de ejemplo debe mostrar una ventana Acerca de... cuando el
usuario ejecute la opción Ayuda | Acerca de... del menú de la aplicación, como es un
desperdicio de memoria permitir que el formulario Acerca de... sea auto creado a través del
proyecto, es mejor alocar los recursos para el formulario (llamar su constructor) cuando lo
necesitemos para mostrar el formulario y llamar su destructor cuando terminemos. A
continuación el código para crear, mostrar y destruir el formulario:
Procedure TFMenu.AcercaClick(Sender: Tobject);

Begin
Facerca := Tfacerca.Create(Application);
Facerca.ShowModal;
Facerca.Free;
End;
Recuerde cada vez que usted llame un constructor, usted es responsable para llamar el
destructor lo cual es evidente en el código anterior. De cualquier manera, si ocurre un error
mientras el formulario se esta mostrando en la pantalla, su destructor no es llamado,
entonces todos los recursos alocados por este formulario(memoria y los recursos gráficos)
se perderán. Por supuesto, la forma de resolver este problema es a través del manejo de
excepciones para protección de recurso, a continuación los cambios necesarios para el
código anterior con el manejo de excepciones:
Procedure TFMenu.AcercaClick(Sender: Tobject);

Begin
Facerca := Tfacerca.Create(Application);
Try
Facerca.ShowModal;
finally
Facerca.Free;
End;
End;
Esta versión del código es mas segura y mas robusta. Ahora, no importa que pase mientras
el formulario este activo, Delphi asegurará que el destructor para el formulario se ejecute en
el tiempo apropiado.
Operador de Encapsulación
El uso del bloque try ... finally no es solamente para protección de recursos como el
anterior. En cualquier momento usted puede cambiar un recurso y desea asegurarse que el
recurso quede como estaba al final del bloque de código, el bloque try ... finally es la mejor
vía para manejarlo. Por ejemplo, si usted abre un archivo de texto dentro de un procedure
para leer alguna información, usted quiere asegurarse que el archivo sea cerrado cuando
usted salga de la rutina. El bloque try ... finally es una excelente forma para manejar la
situación
Var F: TextFile;
Línea: String;
begin
Assign(f, ‘C:\datos.dat’)
Reset(f);
Try
Readln(f,línea);
Finally
CloseFile(f);
End;
End;
Por esta razón el bloque try ... finally podría ser llamado el operador de encapsulación.
Note que usando el bloque try ... finally, usted garantiza que todos los procedimientos y
funciones( y cualquier otro bloque lógico de programa) ejecutara siempre cualquier código
final necesario para poner como estaban las cosas originalmente.
Try ... except
El bloque Try... except sirve para capturar los errores en tiempo de ejecución. La sintaxis
para el bloque Try.. except es similar al bloque Try.. finally:
Try
<sentencia>;
<sentencia>;
except
on ExceptionType1 do
<sentencia>;
on ExceptionType2 do
<sentencia>;
end;
A continuación un ejemplo que muestra como utilizar el bloque Try.. except para el manejo
de errores:
Try
a:= b/c
except
on EzeroDivide do
MessageDlg(‘Division entre Cero’, mtError, [mbOk],0);
on Eunderflow do
begin
MessageBeep(0);
MessageDlg(‘El numero esta por debado del soportado’,mtError, [mbOK],0);
end
end;
Al igual que el bloque Try.. finally, el bloque Try.. except termina con un end.
Funcionamiento del bloque Try.. except
Si durante la ejecución del código que se encuentra entre try y except se produce algún
error, el programa salta automáticamente desde la línea que produjo el error a ejecutar el
código que se encuentra entre except y end. Esto quiere decir que el código que esta
después de except solo se ejecuta cuando se produce algún error durante la ejecución del
código que esta después del try. A diferencia del bloque try.. finally que la parte del finally
siempre se ejecuta.
Resumen del manejo de errores en Delphi

Borland Database Engine

En este capitulo:
 Concepto del Borland Database Engine

 El BDE Administrator
 Concepto de Alias
 Creación de Alias

Introducción al Borland Database Engine
El Borland Database Engine (comúnmente llamado BDE) es una serie de drivers que
permiten que Delphi pueda comunicarse con una base de datos. Un driver no es nada mas
que un archivo que contiene informaciones sobre como interactuar con un hardware o con
un software.
Delphi utiliza los servicios BDE para acceder a una base de datos. El BDE trabaja de la
misma manera con bases de datos locales así como con base de datos Cliente / Servidor.
Hace muchos años, Borland confrontó un problema con el acceso de base de datos en sus
softwares. Todos los productos de Borland que eran utilizados para acceder a base de datos
tenían un método diferente para conectarse y utilizar los datos. Borland determinó que una
manera unificada para la conectividad con base de datos proporcionaría muchas ventajas y
resolveria el problema. Así que decidieron crear un software contendría todas las
funcionalidades de base de datos en un solo engranaje.
Años atrás, Borland vendía un motor de acceso a base de datos para paradox. Este consistía
en su mayor parte en la porción de acceso de datos del manejador de base de datos de
Paradox y el uso que se pretendía era utilizarlo en programas que necesitaban leer y escribir
a las tablas DB de Paradox. El BDE contiene este motor, pero con funciones agregadas
para conectarse a cualquier otro tipo de base de datos. El BDE incluye todo el poder del
motor viejo de Paradox, la capacidad para acceder a tablas dBase y la habilidad para escalar
de un sistema de base de datos local a un sistema de base de datos Cliente / Servidor.
BDE Administrator
El BDE Administrator es un utilitario que sirve para configurar el BDE. Este programa es
instalado durante el proceso de instalación de Delphi, el programa de instalación crea un
icono de acceso directo dentro del grupo Borland Delphi – en el menú de Windows -,
además se crea un icono de acceso directo dentro del grupo Control Panel de Windows.
Los archivos ejecutables así como los de configuración son colocados dentro de un
directorio que se llama BDE que normalmente se encuentra en la siguiente ruta:
C:\Program Files\Common Files\Borland Shared o C:\Archivos de Programas
\Archivos Comunes\Borland Shared de acuerdo al idioma de la versión del sistema
operativo que tenga instalado en su maquina. El BDE Administrator luce de la siguiente
manera:

El BDE Administrator como cualquier aplicación Windows consta de un menú principal,

una barra de acceso directo. Además de esto el cuerpo del utilitario se encuentra divido en
dos lados; el lado izquierdo esta dividido a su vez en dos paginas que son: Databases y
Configuration. Y por ultimo el lado derecho muestra y permite modificar los parámetros del
objeto que se encuentra seleccionado en el lado izquierdo.
En el lado Database se encuentran todos los alias que existen configurados en el BDE; el
lado configuration contiene todos los Drivers que hay instalados para conectarse a los
diferentes tipos de bases de datos, así como la configuración de cada uno de ellos; cabe
decir que estos drivers pueden ser Nativos o pueden ser drivers ODBC. Además de los
drivers, en el lado configuration se encuentra la configuración del sistema. A continuación
un vistazo a la página configuration; en ella podemos apreciar los drivers que hay instalado
así como los parámetros del sistema.

Hay que mencionar que la cantidad de driver varían de acuerdo a la versión de Delphi que
usted tenga instalado.
Alias de Base de datos
Los alias de base de datos permiten cambiar la forma como se trabaja con los datos de una
manera muy poderosa. En el mundo de las aplicaciones de negocio, las bases de datos son
cambiadas de lugar frecuentemente a medida que la organización adquiere nuevos
servidores de archivos y tiene que mover sus operaciones de base de datos a servidores de
base de datos dedicados. Algunos ambientes de desarrollo requieren que la aplicación sea
compilada de nuevo cada vez que se cambia la ubicación de la base de datos o para
construir un modelo abstracto adicional en el código.
Una alias no es nada mas que un nombre o identificador en el BDE que sirve para
identificar la ubicación de la base de datos. El alias es utilizados por los componentes de
Delphi para manejo de base de datos para conectarse a la base de datos.
El BDE automáticamente permite utilizar alias.
Creación de un alias
Seleccione la página Database en el BDE Administrator. Para crear un alias desde el BDE
Administrator, existen dos formas, que son:
 Seleccionando la opción Object | New desde el menú principal del BDE

Administrator;
 Presionando la combinación de teclas Ctrl. + N;
 Y haciendo clic con el botón de la derecha del Mouse y seleccionando la opción
New del menú de acceso directo que aparece.
Una vez que usted ejecuta cualquiera de las opciones anteriores para crear un alias, aparece
la ventana New databases alias:
Esta ventana sirve para escoger el driver de base de datos para el cual se va a crear el alias.
En el botón del combobox se debe hacer clic para seleccionar el driver, una vez
seleccionado el driver se procede a presionar el botón OK para aceptar lo que se ha
seleccionado.

Tan pronto como se ha seleccionado el driver y se acepta, el control es devuelto al BDE

administrator donde se debe proceder a ponerle un nombre al alias, el BDE Administrator
le asigna un nombre por defecto al alias; este nombre es formado a partir del driver de base
de datos y un numero secuencial, póngale de nombre “Venta”. Nótese además que se
activan dos botones en la barra de acceso directo, uno es para aplicar los cambios y el otro
es para cancelar.
El paso siguiente después de haberle asignado un nombre, hay que configurar los
parámetros que se encuentran en el lado derecho del BDE Administrator. Estos parámetros
varían de acuerdo al tipo de base de datos.
Configuración de los parámetros
El primer parámetro que vamos a configurar es DEFAULT DRIVER. Seleccione dBase en

el combobox del parámetro DEFAULT DRIVER.
El siguiente y ultimo parámetro es PATH. Aquí se puede digitar directamente el path o

ruta, también se puede llamar una ventana que permite buscar la ruta deseada, para buscar
la ruta presione el botón que aparece en el lado derecho del parámetro path. Asígnele la
siguiente ruta “C:\CSSDELPHI”.

Resumen del Borland Database Engine

El Database DeskTop
En este capitulo:
 Concepto del Database DeskTop

 Configuración del Database DeskTop
 Creación de Tablas de base de datos
 Manipulación de los Datos

Introducción al manejo de base de datos
A diferencia de herramientas como Foxpro, dBase y Access, la fortaleza de Delphi se basa

en el desarrollo de aplicaciones de propósito general, en lugar del desarrollo para base de
datos exclusivamente. Aunque Delphi es una muy buena herramienta para el desarrollo de
aplicaciones para base de datos, dentro de su ambiente de trabajo el no cuenta con ninguna
herramienta para crear o modificar tablas. Para resolver este pequeño inconveniente, Delphi
cuenta con un utilitario llamado: Database DeskTop.
El Database DeskTop(DBD) se instala en el mismo grupo del Menú Start (Inicio) de

Windows donde se encuentra instalado Delphi. Con el DBD usted puede crear tablas,
consultas (Query) e índice de una forma interactivo. A continuación vamos a conocer las
características esenciales del DBD.

En la figura anterior podemos ver como luce el Database DeskTop cuando se carga.

Configuración del Database DeskTop
En la opción File del menú principal del Database DeskTop, se puede cambiar el directorio
de trabajo como también el directorio privado.
Configurando el directorio de trabajo
Para configurar el directorio de trabajo seleccione la opción File | Working Directory del
menú principal del DBD, esto hará que aparezca la siguiente ventana:
El directorio de trabajo es el directorio o carpeta en el disco duro de la maquina que

contiene las tablas de base de datos que se utilizaran. Se debe notar que se puede escribir
directamente la ruta o buscarla mediante el botón Browse... que se observa, pero además se
puede utilizar un Alias, una vez hecho esto procedemos a presionar el botón OK para
aceptar los cambios..
Configurando el directorio privado
Cuando se trabaja en un ambiente multiusuario y los archivos de tablas de la base de datos

son leídos de un drive de la red, es necesario cambiar el directorio privado. El directorio
privado contiene archivos temporales que son utilizados por el DBD. Si todos los usuarios
en la red utilizan el mismo directorio, los archivos temporales tienden a crear conflicto con
los otros. Normalmente el directorio privado es configurado a un drive local para reducir la
carga en la red y para mejorar la velocidad de acceso.
Para cambiar el directorio privado seleccione la opción File | Private Directory del menú
principal del DBD. Esto hará que aparezca la siguiente ventana:

Se debe notar que se puede escribir directamente la ruta o buscarla mediante el botón
Browse... que se observa, una vez hecho esto procedemos a presionar el botón OK para
aceptar los cambios.
Creación de tablas
El desarrollo de aplicaciones de base de datos mediante Delphi implica el tener que crear
las tablas que van a guardar los datos. El DBD sirve para crear tablas DBF (dBase) y DB
(Paradox) así como cualquier tabla en servidores de base de datos, siempre y cuando usted
tenga los drivers instalados.
Para crear una tabla seleccione la opción File | New | Table... del menú principal del DBD.
Cuando usted selecciona esta opción, el DBD le pide seleccionar el formato de base de
datos que usted desea utilizar, a continuación una grafica de la ventana donde se debe
seleccionar el formato de base de datos:
En la grafica anterior cabe destacar que contiene un combobox que contiene todos los tipos
de tablas que se pueden crear. Para seleccionar otro tipo de tabla que no sea el que trae por
defecto presione el botón del combobox, una lista de los tipos de tabla aparecerá y usted
debe seleccionar el que desea. Una vez que se ha seleccionado el tipo de tabla solo hay que
presionar el botón OK.
Tablas DBF
Si el tipo de tabla que usted seleccionó es dBase, el DBD mostrara el diseñador de tabla
para dBase que luce como sigue:

La figura anterior muestra la creación de una tabla con un campo llamado “CÓDIGO” y de
tipo carácter con un tamaño de 8.
Opciones del Diseñador de tablas para dBase

Field Name Nombre del campo. El tamaño de un nombre de campo son 10 caracteres,
no puede tener caracteres especiales, el único carácter especial permitido
es el underscore “_“.
Type Tipo de dato del campo. Si se presiona la barra espaciadora o se hace clic
con el botón derecho del Mouse aparece una lista de los posibles tipos.
Size La cantidad de caracteres que el campo puede almacenar.
Dec Posiciones decimales, solo aplica para campos tipo Number.
Botón Define Sirve para definir los índices de la tabla
Botón Erase Sirve para eliminar los objetos creados en la tabla y que aparecen en la
lista que se encuentra encima del botón.
Record Lock Contiene información de los registros bloqueados por los usuarios en un
ambiente multiusuario.
Info Size Indica el tamaño del campo que contiene información de los registro
bloqueados
Botón Borrow Sirve para crear una tabla a partir de la estructura de otra tabla ya creada.
Solo se activa si no se ha introducido ningún campo.
Botón Save as Sirve para grabar la tabla por primera vez, o para renombrar una tabla si ya
ha sido grabada.
Cancel Sirve para cancelar los cambios.

Help Sirve para mostrar la ayuda sobre como utilizar el diseñador de tablas
Para comenzar a crear la tabla solo hay que comenzar a digitar el nombre del campo y
luego presionar la tecla TAB o Enter para pasar a la siguiente casilla, una vez terminados
de introducir todos los campos, tipos de datos de cada uno, el tamaño de cada campo y
crearle el índice a la tabla – si es necesario – se debe grabar la tabla.
Creación de índices a la tabla
Los índices en una tabla dBase son almacenados en un archivo aparte con el mismo nombre
de la tabla, con la extensión MDX – si es un índice mantenido – o con el nombre del índice
y la extensión NDX – si el índice no es mantenido -. Para crear un índice a un campo,
seleccione Indexes, en el combobox Table Properties y haga clic sobre el botón Define.
Cuando usted pulsa el botón Define aparece la ventana Define Index:
Aquí se pueden crear dos tipos de índices, que son: índice por un solo campo e índices por
una expresión. La expresiones permiten indexar la tabla por mas de un campo, por ejemplo
si usted desea crear un índice por dos campos: “NOMBRE” y “APELLIDO”, para crear un
índice combinado la sintaxis seria “NOMBRE + APELLIDO”. Esto ordenaría los registros
por nombre y luego por apellido.
El DBD creará los índices y actualizara el archivo de índice con el archivo abierto, pero el
DBD no deja ver los datos en el orden del índice, se necesita usar Delphi para hacer eso.

Opciones del Diseñador de Índice de dBase

Botón Expresión Index Sirve para crear índices por mas de un campo.
CheckBox Unique Indica que el índice no permite registros duplicados.
CheckBox Maintained Indica que todos los índices que se crearan en un solo archivo.
CheckBox Descending Indica que el orden del índice será descendiente.
Expression Index Aquí se construye la expresión para índices combinados
Subset Condition Sirve para especificar un criterio de selección de registro.
Manipulación de los datos
Normalmente tan pronto como se crea la tabla, se puede empezar a construir

inmediatamente los programas que se van a encargar de manipular las informaciones de
dicha tabla en nuestra aplicación, pero a veces es necesario introducir algunos datos de
prueba dentro de la tabla para probar la funcionalidad de nuestra aplicación. El DBD
permite agregar, editar y borrar los registros de una tabla.
Entrada y edición de datos
Para ver los datos de una tabla, lo primero que hay que hacer es abrir la tabla, la tabla se
puede abrir seleccionando la opción File | Open del menú principal del DBD o haciendo
clic sobre el speedbutton en la barra de acceso directo. Cuando la tabla es abierta,
automáticamente esta en modo Browse (Navegación), los datos no se pueden cambiar ni
introducirse en la tabla a no ser que se cambie al modo de edición.
Se puede cambiar de modo de trabajo seleccionando View Data o Edit Data de la opción
View del menú principal. Tan pronto usted cambia al modo Edit Data, se puede utilizar
cualquier opción del menú Record para insertar, bloquear, borrar, o hacer búsquedas en la
tabla. El DBD no permite interactuar con campos tipo Binary, OLE o Memo. Lo que se
vera es un letrero identificando el tipo de dato del campo. Para interactuar con cualquiera
de estos tipo de campo, se tiene que hacer vía nuestra aplicación en Delphi.
Vista de los datos
El DBD tiene unas características interesantes que permiten personalizar la forma de ver los
datos.
Reordenamiento de las columnas
Por defecto, todas las columnas de la tabla son desplegadas en el mismo orden en que
fueron creadas, ocasionalmente, usted podría cambiar el orden en que se ven las columnas,
tal vez para quitar de la vista los datos menos relevantes.

Si usted mueve el puntero del Mouse por encima de los encabezados de las columnas,
podrá notar que el puntero del Mouse cambia y se convierte en una pequeña cajita. Para
mover una columna de lugar, coloque el puntero del Mouse encima del encabezado de la
columna, cuando aparezca la pequeña cajita, presione el botón del Mouse y mientras
mantiene presionado el botón del Mouse, arrastre la columna a su nueva ubicación.
Nota: al cambiar de lugar la columna, no altera el orden de los campos en la estructura de la

tabla, aunque modifica la forma como se ve.
Fijación de Columna
Normalmente no podemos ver todas las columnas de datos de la tabla, porque son
demasiadas, algunas son muy grandes, etc. Y tenemos que navegar a través de ellas para
ver las informaciones, pero cuando navegamos para ver otra columna, se oculta la anterior.
Para resolver esta situación el DBD permite fijar una o varias columnas en pantalla, y de
esa manera estas columnas que han sido fijadas no se ocultan cuando navegamos a través
de las otras. Para fijar una columna debemos utilizar el control de bloqueo, el control de
bloqueo se encuentra ubicado en la esquina inferior izquierda de la ventana.
Para fijar una columna solo hay que arrastrar con el Mouse el control de bloqueo hacia la
derecha, cuando usted arrastra el control de bloqueo hacia la derecha, todas las columnas

que se encuentran a la izquierda del control de bloqueo son fijadas mientras que las que se
encuentran a la derecha permanecen movibles. El control de bloque cambia de una flecha a
dos cuando es fijada una o mas columnas.
Guardando la Vista
El DBD permite guardar la forma como se muestran las columnas en el Browser, la forma
como luce el Browser es almacenada en un archivo aparte del DBF. Otro punto es que si
usted cambia en algo la forma como se muestran los datos de la tabla, cuando usted cierra
la tabla el DBD pregunta si desea guardar la vista del Browser, si usted contesta que si
(Yes), es almacenada en un archivo con la extensión TVF (para DBF) o TV (para DB). La
próxima vez que usted abra la tabla, la tabla se mostrara con la nueva vista que fue grabada.
Para borrar una vista almacenada solamente hay que seleccionar la opción Table | Table
View Properties... | Delete del menú principal del DBD.
Practica: Creación de tabla utilizando el Database DeskTop
Vamos a crear un directorio en el drive C y lo vamos a llamar CSSDelphi, luego utilizando

el Database DeskTop, vamos a crear las siguientes tablas y las vamos a guardar en ese
direcotiro:
ALMACEN
CAMPO TIPO LONGITUD DECIMALES CLAVE
ALMACEN C 4 *
DESCRIPCIO C 40
ESTADO C 1
EMPLEADO
EMPLEADO N 4 *
NOMBRE C 40
APELLIDO C 40
CEDULA C 15
DIRECCION C 80
EMAIL C 40
TELEFONO C 13
CELULAR C 13
BEEPER C 13
COMISION N 5 2
ESTADO C 1
UNIDADES

UNIDAD C 4 *
NOMBRE C 40
SIGLA C 40
ESTADO C 1
ARTICULO
ARTICULO C 16 *
DESCRIPCIO C 40
UNIDAD C 4
COSTO N 10 2
REFERENCI C 40
ESTADO C 1
CLIENTES
CLIENTE N 4 *
NOMBRE C 40
APELLIDO C 40
CEDULA C 15
DIRECCION C 80
EMAIL C 40
TELEFONO C 13
CELULAR C 13
BEEPER C 13
NOMBREC C 40
APELLIDOC C 40
TELEFONOC C 13
EXTENSION C 4
ESTADO C 1
FACTURA
NUMERO N 8 *
FECHA D
CLIENTE N 4
EMPLEADO N 4
FLETE N 10 2
IMPUESTO N 10 2
DESCUENTO N 10 2
SUBTOTAL N 10 2
TOTAL N 10 2
IMPRESA C 1 2
ESTADO C 1
DFACTURA
NUMERO N 8 *
LINEA N 6 *
ALMACEN C 4
ARTICULO C 16
UNIDAD C 4
CANTIDAD N 6
IMPUESTO N 10 2
DESCUENTO N 10 2
COSTO N 10 2
PRECIO N 10 2
ARTALM
ALMACEN C 4 *
ARTICULO C 16 *
EXISTENCIA N 6
UNIDAD C 4
ORDENADA N 6
VENDIDA N 6
COSTO N 10 2
PRECIO N 10 2

Resumen del Database DeskTop

Aplicaciones con base de datos

 Modelo de acceso de base de datos de Delphi
 Componentes de acceso a base de datos
 Creación de formulario con base de datos

Conexión a base de datos en Delphi
Para conectar una aplicación en Delphi a una base de datos hay que utilizar tres tipos de
componentes, que son: Dataset, Datasource y los componentes Data-aware, mejor
conocidos como los DBControls. A continuación mostraremos como se relacionan estos
componentes:
Los objetos dataset: permiten conectar la aplicación con la base de datos (back end). Los
componentes Dataset proporcionan la interfase entre la base de datos y la aplicación
desarrollada en Delphi.
El datasource establece la interface entre el Dataset y los DBControls. Mediante el

componente DataSource es que los componentes DBControls pueden acceder a los campos
de la base de datos.
Los Controles Data-aware o DBControls proporcionan la interfase de usuarios para entrar,

editar y ver los datos de la base de datos.
Creación de un formulario simple utilizando base de datos
En esta parte vamos a ver como trabajan juntos los componentes DataSet, DataSource y
DBControls.

Forma Manual
Cree un nuevo proyecto para esto seleccione la opción File | New Application del menú
principal de Delphi. Esto creara un nuevo proyecto y un nuevo formulario dentro del
proyecto. Cambie el nombre al formulario, para esto utilice la propiedad Name, póngale de
nombre Form_Animales; Cambie el título del formulario, para esto utilice la propiedad
Caption, póngale “Información de los Animales”. Grabe el proyecto y la unidad, para esto
seleccione la opción File | Save Project As... del menú principal de Delphi, grabe la unidad
con el nombre UnitFormAnimales y grabe el proyecto con el nombre de ClaseBaseDato.
Coloque un componente Table en el formulario desde la página Data Access de la paleta de

componente. Cambie el nombre del Table a Table_Animales:
Conecte el componente Table con la ubicación de la base de datos para esto utilizaremos la
propiedad DataBaseName del componente Table, la ubicación de la base de datos puede
ser especificada mediante un alias o mediante una ruta (Path). La propiedad DatabaseName
proporciona un ComboBox que cuando usted hace clic en el botón aparece una lista que
contiene todos los alias definidos en el BDE. Seleccione el alias DBDemos. Cuando se va a
especificar una ruta, solamente hay que escribir la ruta en la propiedad DataBaseName,
pero este no es nuestro caso ahora.

Conecte el componente Table con la tabla de la base de datos con la cual se desea conectar
el componente Table. Para esto utilizaremos la propiedad TableName. La propiedad
TableName proporciona un ComboBox que cuando usted hace clic en el botón aparece una
lista que contiene todas las tablas. Seleccione la tabla Animals.DBF.
Coloque un componente DataSource en el formulario desde la página Data Access de la

paleta de componente. Cambie el nombre a DataSource_Animales.

Conecte el componente DataSource con el componente Table mediante la propiedad

Dataset:
Para que el usuario pueda ver y manipular los datos dentro de la tabla, debemos utilizar los
controles data-aware o DBControls. Coloque un componente DBEdit en el formulario
desde la página Data Controls de la paleta de componente. Póngale de nombre
DBEdit_Area.
Para que los componentes DBControls puedan mostrar o manipular los datos es necesario
conectarlo con un componente datasource. Conecte el Componente DBEdit con el
Componente DataSource correspondiente, para esto utilizaremos la propiedad DataSource
del DBEdit. La propiedad DataSource proporciona un ComboBox que cuando usted hace
clic en el botón aparece una lista que contiene todos los componentes DataSource que están
colocados en el formulario, de ahí se debe elegir con cual datasource se desea conectar el
DBEdit, por el momento nuestro formulario solo contiene un solo componente DataSource.
Seleccione el DataSource_Animales:

Conectar el Componente DBEdit con el campo de la tabla que se desea acceder a través de
la propiedad DataField del DbEdit. La propiedad DataField proporciona un ComboBox
que cuando usted hace clic en el botón aparece una lista que contiene todos los campos que
posee la tabla de la base de datos. Seleccione el campo AREA.
Coloque un Componente Label (desde la página Standard de la paleta de componente) al

lado del DBEdit para identificar la información que se mostrará o manipulará el
componente DBEdit. A continuación nuestro formulario hasta este momento:

Coloque tres componentes DBEdit mas, ponerles de nombre: DBEdit_Nombre,

DBEdit_Tamano y DBEdit_Peso respectivamente, como lo hicimos con el componente
DBEdit_Area. Conectarlos con el DataSource_Animales, y conectarlo con los campos:
NAME, SIZE, WEIGHT respectivamente, como lo hicimos con el componente
DBEdit_Area.
Coloque tres componentes Label mas, uno para cada DBEdit, ponerles de título en la
propiedad Caption: Nombre, Tamaño y Peso respectivamente, como lo hicimos con el
componente Label del DBEdit_Area. Después de todo esto el formulario debería lucir
como la figura siguiente:

En la tabla ANIMALS.DBF existe el campo BMP, este campo es especial, ya que contiene
la foto del animal. Un campo de datos tipo Memo o Binary no puede ser manipulado con un
componente DBEdit, ya que no puede presentar el contenido. Para poder manipular el
campo BMP en nuestro formulario vamos a necesitar otro DBControl llamado DBImage.
Coloque un componente DBImage en el formulario y conéctelo con el campo BMP. Las
propiedades para conectarlo son exactamente las misma que el DBEdit (ya que ambos son
controles data-aware), así que usted sabe ya como hacerlo.
Coloque un componente Label encima del DBImage y póngale de título “Foto”.
Coloque un componente DBNavigator (desde la página Data Controls de la paleta de

componente) en el formulario. El DBNavigator es un componente que implementa todas las
funcionalidades que se pueden realizar sobre los datos de una tabla de base de datos. El
Componente DBNavigator esta compuesto por una barra de botones, donde cada botón
permite realizar una operación diferente sobre la tabla. Las operaciones que permite realizar
el DBNavigator son: ir al primer registro, ir al registro anterior, ir al próximo registro, ir al
ultimo registro, insertar un registro en blanco, borrar un registro, editar un registro, cancelar
los cambios hechos sobre los datos, grabar los cambios y refrescar el conjunto de registro
que esta desplegando.

Conecte el componente DBNavigator con el componente DataSource correspondiente

mediante la propiedad DataSource del DBNavigator. El formulario ahora luce de la
siguiente forma:
Active el componente Table mediante la propiedad Active, seleccione el valor True del
combobox de la propiedad Active. Activamos la tabla para ver los datos en tiempo de
diseño.
Ejecute la aplicación para ver como funciona.
Ya sabemos como crear un formulario simple de base de datos de la forma manual. A

continuación vamos a ver una forma mas sencilla y rápida para crear un formulario simple.
Drag and Drop
Agregue un nuevo formulario al proyecto, para esto seleccione la opción File | New Form
del menú principal de Delphi. Esto agregará un nuevo formulario en blanco en el proyecto.
Cambie el nombre al formulario, para esto utilice la propiedad Name, póngale de nombre
Form_Clientes; Cambie el título del formulario, para esto utilice la propiedad Caption,
póngale “Información de los Clientes”. Grabe la unidad, para esto seleccione la opción File
| Save As... del menú principal de Delphi, grabe la unidad con el nombre
UnitFormClientes.

Coloque un componente Table en el formulario desde la página Data Access de la paleta de

componente. Cambie el nombre del Table a Table_Clientes.
Conecte el componente Table con la ubicación de la base de datos para esto utilizaremos la
propiedad DataBaseName del componente Table. Seleccione el alias DBDemos.
Conecte el componente Table con la tabla de la base de datos con la cual se desea conectar
el componente Table. Para esto utilizaremos la propiedad TableName. Seleccione la tabla
Clients.DBF.
Haga Doble-Clic sobre el componente Table (Table_Clientes); esto hará que aparezca la
ventana del editor de campos (Field Editor):
Ahora Haga Clic con el botón de la derecha del Mouse sobre el editor de campos; esto hará
que aparezca el menú de acceso directo (Speed Menú):

Seleccione la opción Add fields del menú de acceso directo para agregar los campos de la
base de datos en el editor de campos; esto mostrara la ventana Add Fields con todos los
campos de la tabla de base de datos. Aquí con la ayuda del Mouse y las teclas Shift y Ctrl
se deben seleccionar los campos que se desean agregar al editor de campos. Para nuestro
caso, vamos a agregar todos los campos y como por defecto vienen todos los campos
seleccionado, solamente hay que presionar el botón OK para aceptarlo.

Todos los campos son agregados al editor de campos:
Utilizar el Mouse y la tecla Shift o Ctrl para seleccionar los campos en el editor de campos
que se desean agregar en el formulario. Seleccione todos los campos.
Hacer la operación de Drag and Drop; para esto posicione el puntero del Mouse encima de
uno de los campos que se encuentran seleccionados, presione el botón del clic del Mouse y
mientras mantiene presionado el botón del Mouse mueva el puntero del Mouse hacia la
posición en el formulario donde desea colocar los componentes, luego suelte el botón del
Mouse.

Como se puede notar en la figura anterior, con el drag and drop se agrega automáticamente
el componente DataSource, todos los componentes data-aware control y los componentes
Label para todos los campos que fueron seleccionados. La Tarea siguiente es: organizar los
controles en el formulario, cambiar los nombres de los componentes que sean necesarios,
cambiar los títulos de los Labels de la forma deseada.
Coloque un componente DBNavigator (desde la página Data Controls de la paleta de

componente) en el formulario.
Conecte el componente DBNavigator con el componente DataSource correspondiente

mediante la propiedad DataSource del DBNavigator.
Active el componente Table mediante la propiedad Active, seleccione el valor True del
combobox de la propiedad Active.
Como habíamos dicho anteriormente es sumamente mas fácil hacer un formulario con el
Drag and Drop.

Creación de un formulario Master / Detail
Agregue un nuevo formulario al proyecto, para esto seleccione la opción File | New Form
del menú principal de Delphi. Esto agregará un nuevo formulario en blanco en el proyecto.
Cambie el nombre al formulario, para esto utilice la propiedad Name, póngale de nombre
Form_Ordenes; Cambie el título del formulario, para esto utilice la propiedad Caption,
póngale “Ordenes de Compra”. Grabe la unidad, para esto seleccione la opción File | Save
As... del menú principal de Delphi, grabe la unidad con el nombre UnitFormOrdenes.
Coloque dos componentes Table en el formulario desde la página Data Access de la paleta
de componente. Cambie el nombre de los Table: a uno póngale Table_Ordenes; y al otro
póngale Table_Items.
Conecte los componentes Table con la ubicación de la base de datos para esto utilizaremos
la propiedad DataBaseName de los componente Tables. Seleccione el alias DBDemos
para ambas tablas.
Conecte los componentes Table con la tabla de la base de datos con la cual se desea
conectar los componentes Table respectivamente. Para esto utilizaremos la propiedad
TableName. Seleccione la tabla Orders.db para el componente Table_Ordenes e Items.db
para el componente Table_Items.
Ahora con el componente Table_Ordenes vamos a hacer un drag and drop para crear la
interfase del Master (Maestro). Hasta ahora nuestro formulario luce de la siguiente forma:

Cámbiele el nombre al componente DataSource1. Póngale de nombre

DataSource_Ordenes.
Coloque otro componente DataSource en el formulario. Póngale de nombre

DataSource_Items. Este datasource permitirá acceder a la informaciones del detalle (items
de cada orden).
Vamos a crear la relación entre las dos tablas, para esto utilizaremos la propiedad
MasterSource y MasterFields del componente table. La relación se establece en el
componente Table que esta conectado a la tabla de Detalle, en nuestro caso el componente
Table_Items. Primero se especifica el DataSource de la tabla maestra en la propiedad
MasterSource de la tabla de detalle (Table_Items), presione el botón del combobox y
solamente aparecera el DataSource_Ordenes, selecciónelo; luego se presiona el botón
(ellipsis) en la propiedad MasterFields de la tabla de detalle (Table_Items) y aparece la
siguiente ventana:

Esta ventana sirve para establecer las relaciones entre la tabla maestra y la tabla de detalle.
El ComboBox Available Indexes ubicado en la parte superior de la ventana sirve para
seleccionar el índice por el cual se desea establecer la relación.
En la parte central de la ventana existen dos listas (Detail Fields y Master Fields) que
listan los campos por los cuales se pueden establecer relaciones, en una lista están los
campos de la tabla de detalle (Detail Fields) y en la otra (Master Fields) están los campos
de la tabla maestra. Para establecer la relación solo hay que hacer clic en el campo
correspondiente en la lista Detail Fields y Master Fields. Cuando se seleccionan los
campos a relacionar, se activa el botón Add que se encuentra entre las dos listas.
Una vez se haya presionado el botón Add los campos relacionados aparecerán en la parte
de abajo de la pantalla llamada Joined Fields, los campos aparecerán separados por ->. Si
se necesita establecer una relación por mas de un campo, solamente hay que seleccionar los
campos siguientes en la relación y presionar el botón Add estos pasos se deben estar
repitiendo hasta haber establecido la relación por todos los campos necesarios.
El Botón Delete sirve para borrar de la lista Joined Fields una relación, el botón Clear
sirve para limpiar todas las relaciones. Para terminar y aceptar los cambios realizados
presione el botón OK y para cancelar sin grabar los cambios presione el botón Cancel.
En el Field Link Designer, seleccionar en el Detail Fields el campo OrderNo y en

Master Fields el campo OrderNo, luego haga clic en el botón Add.
Componente DBGrid

El componente DBGrid es un componente data-aware, y por lo tanto permite manipular las

informaciones de tablas de base de datos. Este componente permite ver las informaciones
organizadas en filas y columnas, donde cada columna corresponde a un campo de la tabla
de base de datos; y las filas corresponden a los registros en la tabla. Este componente tiene
la ventaja que permite manipular todos los campos, y además permite manipular mas de un
registro a la vez. El componente DBGrid al igual que todos los DBControls se encuentra en
la página Data Controls de la paleta de componente y la única propiedad que hay que
configurar para acceder a la tabla es la propiedad DataSource donde se le indica el
componente DataSource de la tabla que el mostrara los datos.
Ahora que ya sabemos que es un DBGrid, para que sirve y como funciona. En la parte del
detalle necesitamos ver todos los registros del maestro, lo que quiere decir que
necesitaremos un componente DBGrid. Coloque un componente Dbgrid en el formulario y
conectarle con el componente DataSource de la tabla de detalle mediante la propiedad
Datasource del Dbgrid. Seleccione el componente DataSource_Items en la propiedad
DataSource del DBGrid y ya esta.
Coloque un componente DBNavigator.
Conecte el componente DBNavigator con el componente DataSource, Seleccione el

componente DataSource_Ordenes mediante la propiedad DataSource del DBNavigator.
Active los componentes Table mediante la propiedad Active, seleccione el valor True del
combobox de la propiedad Active.
A continuación una figura de nuestro formulario Master / Detail:


Resumen de Aplicaciones con base de datos

Uso del Form Wizard para crear aplicaciones con base de

datos

Introducción al Form Wizard
El Form Wizard es un utilitario de Delphi que facilita la creación de formularios de base de

datos. Esta herramienta le permite al programador crear formularios de entrada de datos sin
necesidad de escribir una sola línea de código de programación. Los formularios son
creados rápidamente y el usuario solo tiene que paso a paso diciéndole al Wizard como
desea el formulario. Una vez que el formulario es creado con el Form Wizard, el
programador puede hacerle todos los cambios necesarios que necesite el formulario para
satisfacer las necesidades de los usuarios.
Uso del Form Wizard
Para ejecutar el Form Wizard usted puede utilizar uno de los dos métodos existente que hay
para cargarlo, estos son:
Seleccionando la opción Database | Form Wizard... del menú principal de Delphi
Seleccionando la opción File New... del menú principal de Delphi, luego seleccione la
página Bussines de la ventana New Items que aparece:

Para iniciar el Form Wizard, seleccione el icono Database Form Wizard y pulse el botón
OK o simplemente haga doble-clic sobre el icono.
Cualquiera que fuere la forma que usted utilice para iniciar el Form Wizard, la pantalla
iniciar del Form Wizard será la misma:
la figura anterior muestra la ventana iniciar del Form Wizard, en esta pantalla el usuario
debe especificar que tipo de formulario desea crear.
Creación de un formulario simple utilizando el Database Form

Wizard
Para crear un formulario simple de base de datos con el Form Wizard, lo primero que
tenemos que hacer es cargar el Form Wizard, una vez cargado el Form Wizard en la
pantalla de inicio del Form Wizard procedemos a seleccionar el tipo de formulario que
deseamos crear, para esto debemos seleccionar una de las dos opciones que se encuentran
debajo del grupo Form Options, haga clic sobre la opción Create a simple form; luego
procedemos a seleccionar el tipo de componente DataSet que deseamos utilizar, para esto
debemos seleccionar una de las dos opciones que se encuentran debajo del grupo DataSet
Options, haga clic sobre la opción Create a form using TTable objects. Haga clic sobre el
botón Next, esto traerá la siguiente pantalla:

Esta pantalla del Form Wizard nos permite seleccionar la tabla de base de datos para la cual
vamos a crear el formulario. En esta pantalla podemos ver que existen varios controles para
seleccionar la tabla:
 Tenemos un Edit llamado Table Name que sirve para especificar el nombre de la
tabla de base de datos. Además este mismo Edit nos permite especificar un criterio
de búsqueda para especificar los tipos de archivos que andamos buscando cuando
las tablas la vamos a conectar vía una ruta y no un Alias.
 Inmediatamente debajo del Edit Table Name tenemos una lista que muestra todas
las tablas de base de datos u objetos de base de datos dependiendo del tipo de base
de datos (Local o Cliente / Servidor) y que cumplan con los criterios de filtros. De
esta lista podemos seleccionar la tabla a la que le vamos a construir el formulario.
Es importante notar que cuando usted hace clic sobre una tabla u objeto en esta lista,
el nombre del objeto seleccionado aparece en el Edit Table Name.
 Tenemos una lista llamada Directories que nos permite navegar a través de todos los
directorios del disco duro para seleccionar la ubicación de la tabla de base de datos.
Debemos mencionar que el contenido de la lista cambia de acuerdo al tipo de base
de datos, Local o Cliente / Servidor.
 Un ComboBox llamado List Files of Type que muestra los tipos de archivos que se
van a desplegar en la lista de las tablas si el tipo de base de datos es Local, o los
objetos de la base de datos si es Cliente / Servidor.

 Un ComboBox llamado Drive or Alias Name que sirve para seleccionar la unidad
de drive – si estamos buscando la tabla por directorios – o un alias de base de datos
– si vamos a seleccionar la tabla desde un alias.
Para nuestro ejemplo seleccione el alias DBDEMOS en el ComboBox Drive or Alias

Name. Aparecen todas las tablas en la lista de tablas y la lista Directories muestra el Path
del alias DBDEMOS. El Form Wizard debe lucir como la figura siguiente:
Seleccione la tabla animals.dbf y presione el botón Next. Cabe mencionar que el botón Next
solo se activa una vez que usted ha completado las informaciones necesaria para cada
pantalla. Ahora aparece la tercera pantalla del Form Wizard que debe lucir como la
siguiente figura:

En esta ventana debemos seleccionar los campos de la tabla que deseamos que aparezcan
en el formulario. Esta ventana cuenta con dos listas: Available Fields y Ordered Selected
Fields. La primera contiene todos los campos que están en la tabla y la segunda contiene los
campos y el orden en que van a aparecer en el formulario. Aquí la idea es pasar de una lista
a otra los campos, para esto se deben utilizar los botones que se encuentran entre las dos
listas o simplemente arrastrar de una lista a otra los campos. Los botones permiten mover
los campos en la dirección de la Flecha y los que tienen dos flechas mueven todos los
campos a la vez en la dirección que indica la flecha. Debajo de la lista Ordered Selected
Fields hay dos botones, estos botones sirven para intercambiar el orden de los campos.
Transfiera todos los campos a la lista Ordered Selected Fields, la ventana debe lucir como a
continuación:

Presione el botón Next para pasar a la siguiente pantalla:
En esta ventana se debe escoger la forma como aparecerán organizados los controles en el
formulario. Las opciones que nos proporcionan son: Horizontally, Vertically e In a grid.
Horizontally esta forma permitirá que los controles aparezcan colocado uno al lado del otro.
Vertically esta forma permitirá que los controles aparezcan uno debajo del otro. Y In a grid
hará que los campos sean manipulados desde un DBGrid. Es importante mencionar que
después de la primera ventana del Form Wizard el botón Back siempre esta activo y sirve
para devolverse a la ventana anterior en el Form Wizard. Seleccione Vertically y presione

el botón Next para pasar a la siguiente ventana:
Esta ventana solamente aparece cuando se selecciona la opción Vertically de la ventana

anterior. Esta ventana sirve para decirle al Form Wizard donde se van a colocar los Label
de los DBEdit. Las opciones disponibles son: Left a la izquierda de los DBEdit; y Top
encima de los DBEdit. Seleccione Left y presione el botón Next para pasar a la siguiente
pantalla:

Esta es la ultima pantalla del Form Wizard. Aquí podemos apreciar unos cuantos
parámetros:
 el CheckBox Generate a main form: sirve para indicarle al Form Wizard que el
formulario que se va a crear debe ser colocado como el main form del del proyecto
– el formulario que aparece cuando se manda a ejecutar el proyecto.
 Y el grupo Form Generation: aquí debemos indicarles al Form Wizard si vamos a

generar solamente el formulario (Form Only) o si además vamos a crear un
formulario y un modulo de dato (DataModule).
Una vez seleccionado los respectivos parámetros, solo hay que presionar el botón Finish
para que el Form Wizard cree nuestro formulario. Presione el botón Finish y vea el
resultado de nuestro trabajo.
Creación de un formulario Maestro / Detalle utilizando el Database

Form Wizard
Para crear un formulario maestro / detalle de base de datos con el Form Wizard, lo primero
que tenemos que hacer es cargar el Form Wizard, una vez cargado el Form Wizard en la
debajo del grupo Form Options, haga clic sobre la opción Create a Master/Detail form;
luego procedemos a seleccionar el tipo de componente DataSet que deseamos utilizar, para
esto debemos seleccionar una de las dos opciones que se encuentran debajo del grupo
DataSet Options, haga clic sobre la opción Create a form using TTable objects. Haga clic
sobre el botón Next, esto mostrará la siguiente pantalla:



En esta pantalla seleccionaremos la tabla de base de datos que será el maestro (master) en el
formulario, seleccione la tabla orders.db y presione el botón Next. Ahora aparece la
siguiente pantalla del Form Wizard que debe lucir como la siguiente figura:

en la parte maestra del formulario. Esta ventana cuenta con dos listas: Available Fields y
Ordered Selected Fields. La primera contiene todos los campos que están en la tabla y la
segunda contiene los campos y el orden en que van a aparecer en el formulario. Aquí la
idea es pasar de una lista a otra los campos, para esto se deben utilizar los botones que se
encuentran entre las dos listas o simplemente arrastrar de una lista a otra los campos. Los
botones permiten mover los campos en la dirección de la Flecha y los que tienen dos
flechas mueven todos los campos a la vez en la dirección que indica la flecha. Debajo de la
lista Ordered Selected Fields hay dos botones, estos botones sirven para intercambiar el
orden de los campos. Transfiera todos los campos a la lista Ordered Selected Fields, la
ventana debe lucir como a continuación:



encima de los DBEdit. Seleccione Top y presione el botón Next para pasar a la siguiente
pantalla:

En esta pantalla seleccionaremos la tabla de base de datos que será el detalle (detail) en el
formulario, seleccione la tabla items.db y presione el botón Next. Ahora aparece la
En esta ventana debemos seleccionar los campos de la tabla de detalle que deseamos que
aparezcan en la parte de detalle del formulario. Esta ventana cuenta con dos listas:
Available Fields y Ordered Selected Fields. La primera contiene todos los campos que
están en la tabla y la segunda contiene los campos y el orden en que van a aparecer en el
formulario. Aquí la idea es pasar de una lista a otra los campos, para esto se deben utilizar
los botones que se encuentran entre las dos listas o simplemente arrastrar de una lista a otra
los campos. Los botones permiten mover los campos en la dirección de la Flecha y los que
tienen dos flechas mueven todos los campos a la vez en la dirección que indica la flecha.
Debajo de la lista Ordered Selected Fields hay dos botones, estos botones sirven para
intercambiar el orden de los campos. Transfiera todos los campos a la lista Ordered
Selected Fields, la ventana debe lucir como a continuación:

hará que los campos sean manipulados desde un DBGrid. Se debe notar que por defecto

viene seleccionado la opción In a grid, ya que la parte del detalle estará formado por uno o
mas registros, presione el botón Next para pasar a la siguiente ventana:
En esta ventana se debe establecer las relaciones entre la tabla maestra y la tabla de detalle.
Seleccione en el Detail Fields el campo OrderNo y en Master Fields el campo OrderNo,

luego haga clic en el botón Add, presione el botón Next para pasar a la siguiente ventana:
parámetros:


Trabajando con los Campos de la Tabla

Introducción al manejo de campos
El acceso a los campos de una tabla de base de datos es quizás uno de los puntos
primordiales en la construcción de aplicaciones de base de datos. La necesidad por parte de
los programadores de interactuar y manipular las columnas de una tabla sin necesidad que
el usuario tenga que editarlo en pantalla. Los componentes de campos son componentes
invisibles que son creados por Delphi en tiempo de ejecución para el manejo de las
columnas de la tabla. Los componentes de campos son descendientes del objeto Tfield o
uno de sus subclases. Por defecto cada vez que usted coloca en la aplicación un
componente DataSet y lo abre, Delphi automáticamente asigna un descendiente del objeto
Tfield para cada campo de la tabla de base de datos.
Estos componentes que Delphi crea dinámicamente, son invisibles y tienen un tipo de datos
especifico para el tipo de datos que tiene definido el campo en la tabla. Los campos que
Delphi crea son almacenados en la propiedad Fields del componente Table y Querie, esta
propiedad es un arreglo.
Este funcionamiento por defecto de crear los campos cada vez que usted abre un
componente DataSet puede ser omitido en tiempo de diseño, para lograr esto solo hay que
crear campos persistentes. Para crear campos persistentes solo hay que crearlos en el editor
de campo.
Tipos de componentes TField
Los componentes de campos son creados a partir del objeto TField. Usted no puede crear
un componente de tipo TField, pero si existe una serie de componentes de campos que
corresponden a los tipos de campos dentro de una tabla de base de datos. A continuación
una lista de los componentes de campos:
Componente de Campo Propósito

TStringField Tipo texto con un rango de 255 caracteres
TIntegerField Números enteros con un rango de –2147483648 hasta 2147483647
TSmallIntField Números enteros con un rango de –32768 hasta 32767
TWordField Números enteros con un rango de 0 hasta 65535
TFloatField Números reales con un rango de 5.0 * 10–324 hasta 1.7 * 10308
TCurrencyField Números reales con un rango de 5.0 * 10–324 hasta 1.7 * 10308
TBCDField Números reales con un numero fijo de digitos después del punto
decimal, aproximadamente 18 digitos.
TBooleanField Valores lógicos, False o True
TDateTimeField Valores de fecha y hora
TDateField Valores de fecha
TTimeField Valores de hora

TBlobField Valor binario largo de un tamaño ilimitado
TBytesField Valor binario largo de un tamaño ilimitado
TVarBytesField Valor binario de un tamaño arbitrario de 65535 caracteres
TMemoField Valor tipo texto, con un tamaño aproximado a 2GB
TGraphicField Datos tipo imágenes graficas en tamaño ilimitado
Estos son los componentes de campos que son creados automáticamente por Delphi o que
son creados por usted en el diseñador de campos. La ventaja que existe en crearlo en
tiempo de diseño (campos persistentes) es que podemos manipular las propiedades y los
eventos de estos componentes a través del inspector de objeto. Existen otros tipos de
campos, pero estos son los mas utilizados.
Uso del editor de campos
El editor de campos es la herramienta que nos permite crear campos persistentes o mejor
dicho crear los campos en tiempo de diseño para omitir el funcionamiento por defecto que
tiene Delphi de crear los campos dinámicamente.
Para cargar o llamar el editor de campo existen dos formas:
 Hacer doble clic sobre el componente DataSet;
 Y hacer clic con el botón de la derecha del Mouse encima del componente DataSet
y seleccionar la opción Fields Editor... del menú de acceso directo que aparece.
A continuación una figura que muestra el editor de campos:

Para crear los campos solamente hay que hacer clic con el botón de la derecha del Mouse y
seleccionar la opción Add fields... del menú de acceso directo:
Cabe mencionar que solamente tenemos tres opciones disponibles en el menú, pues no
existe ningún campo creado en el editor de campo. Cuando seleccionamos la opción Add
fields... aparece una ventana con todos los campos del componente DataSet seleccionados:

Para crear todos los componentes de campos para todos ellos , haga clic en el botón OK.
Cuando usted desee dejar sin crear algún campo, utilice la combinación Ctrl. + clic del
Mouse para desmarcarlo, y esto evitara que sea creado. Una vez que los campos han sido
agregados el editor de campos luce como la siguiente figura:
Ahora podemos cambiar las propiedades y programar los eventos de los campos creados.
Se puede notar en la figura anterior que el campo seleccionado en el editor de campos, es el
componente que aparece seleccionado en el inspector de objeto.

Propiedades mas comunes de los componentes TField
Propiedad Descripción
Currency Esta propiedad es utilizada para controlar los valores de los campos
tipo TBCDField, TcurrencyField y TFloatField, cuando las
propiedades DisplayFormat y EditFormat no tienen ningún valor.
DisplayFormat Sirve para asignar una mascarilla. Esta mascarilla es utilizada
solamente para desplegar los datos.
DisplayLabel Permite cambiar el titulo de encabezado que es desplegado en la
columna del componente DBGrid.
DisplayWidth Permite cambiar la cantidad de caracteres que será desplegada para
el campo.
EditMask Sirve para asignar una mascarilla. Esta mascarilla es utilizada para
editar los datos.
ReadOnly Permite especificar si el campo será solo lectura o no
Required Esta propiedad sirve para controlar si el campo debe tener valor o
no.
Visible Permite desplegar o no un campo.
Eventos de los componentes TField
Como se puede notar los componentes TField solamente constan con cuatros eventos:
Evento Descripción
OnChange Este evento se dispara inmediatamente los datos han sido
introducido en el buffer del registro.
OnGetText Este evento se ejecuta cada vez que la propiedad DisplayText o Text
del campo son referenciada.
OnSetText Este evento se ejecuta cuando se le asigna un valor a la propiedad
Text del campo.
OnValidate Sirve para validar los datos que se introducen en el campo.
Formateando los campos con la propiedad EditMask
Una de las tareas mas comunes que debe acompañar la creación de formularios para entrada
de datos es determinar como se quiere formatear la información. Para modificar la forma
como la información es capturada se debe utilizar la propiedad EditMask para los datos tipo
String. Este método permite insertar caracteres que se convertirán en parte del campo, por
Ejemplo: guiones o paréntesis que son definidos como caracteres literales dentro de la
mascarilla, aparecerán como parte de los datos del campo en la tabla.
Para asignarle una mascarilla a la propiedad EditMask de un campo, seleccione el campo

en el editor de campos y haga doble clic en la parte derecha de la propiedad EditMask en el

inspector de objeto o haga clic sobre la ellipsis en el editor de campos. Cuando usted realice
uno de los dos métodos anteriores, aparecerá la ventana Input Mask Editor:
La ventana Input Mask Editor presenta una serie de mascarilla de ejemplo en la parte
derecha de la ventana. Para utilizar una de estas mascarillas, solamente hay que hacer
doble-clic sobre ella. La mascarilla puede ser probada para ver como trabaja en el cuadro
Test Input. Después de haber definido su mascarilla, usted puede introducir cadenas de
caracteres de prueba para ver si la mascarilla formatea el texto correctamente. El botón
Masks permite cargar archivos de mascarillas de otros países.
Formas de acceso por código de programación al campo de una

tabla
Existen varias formas para acceder a un campo por código de programación, entre la que
mencionaremos:
1. La propiedad Fields del componente DataSet, que permite acceder a un campo por
el orden en la tabla de base de datos y donde el primer campo de la tabla es el
elemento 0, por ejemplo:
Si tenemos un componente DataSet que se llama Table1, para acceder al primer

campo de la tabla escribiríamos el siguiente código:
Table1.Fields[0].Value;

2. El método FieldByName del componente DataSet que permite acceder a un campo

por el nombre del campo en la tabla de base de datos, por ejemplo:
Si tenemos un componente DataSet que se llama Table1, para acceder a un campo

que se llama “NUMERO” en la tabla escribiríamos el siguiente código:
Table1.FieldByName(‘NUMERO’).Value;
3. Y por ultimo mediante el componente persistente que es creado cuando agregamos

los campos en el editor de campos. Cuando se crea un campo persistente Delphi
emplea una notación para crear el componente, esta notación tiene la siguiente
sintaxis:
NombredelcomponentedatasetNombredelCampo
Por Ejemplo:

que se llama “NUMERO” y que ha sido creado en el editor de campos escribiríamos
el siguiente código:
Table1NUMERO.Value;
Cabe comentar aquí que las dos primeras formas funcionan con campos dinámicos como
con campos persistente, pero que el ultimo formato solamente funciona con campos
persistente.
Creación de un campo calculado
Un campo calculado es un campo cuyo valor es calculado en tiempo de ejecución en el

evento OnCalcFields del componente DataSet. El valor de un campo calculado es obtenido
del calculo de uno o varios campos de la base de datos, esto permite obtener valores
derivados de la tabla con los demás campos sin necesidad de ocupar espacio en la tabla de
base de datos, por Ejemplo: se necesitaría crear un campo string que despliegue los datos
concatenados de otros campos.
1. Para crear un campo calculado cargue el editor de campo y haga clic con el botón de
la derecha del Mouse y seleccione la opción New field... del menú de acceso
directo. Esto ocasionará que aparezca la ventana New Field:

2. Introduzca el nombre del campo en el edit box Name, este nombre debe ser
diferente de los que existen en la tabla de base de datos.
3. Seleccione el tipo de datos del campo del combobox Type.
4. Introduzca el tamaño del campo en el edit box Size, si aplica. El tamaño del campo
solamente aplica a campos de tipo: TstringField, TbytesField y TVarBytesField.
5. Seleccione la opción Calculated en el radio group Field type.
6. Haga clic en el botón OK. El nuevo campo calculado es agregado al final de la lista
de campos del editor de campos.
7. Programe el evento OnCalcFields del componente DataSet para calcular el valor del
campo calculado.
Nota: los campos calculados solamente se le puede asignar valor en el evento OnCalcFields
y el evento OnCalcField se programa en el componente DataSet donde se creó el campo
calculado.
Creación de un campo lookup
Un campo lookup es un campo de solo lectura que despliega valores en tiempo de

ejecución basado en un criterio de búsqueda que usted especifica. Los campos lookup
permiten colocar una lista en el grid que limitan al usuario a seleccionar un valor de la lista
de valores que vienen de un componente DataSet. Usted puede colocar el elementos de una
tabla dentro de una lista, esto permite que el usuario vea un conjunto de opciones para
seleccionar desde ahí, en vez de tener que digitarlo. Esto permite asegurar que los datos que
el usuario introduzca siempre serán validos, lo que le ahorrara al programador el tener que
usar una serie de validaciones.
1. Para crear un campo lookup cargue el editor de campo y haga clic con el botón de la
derecha del Mouse y seleccione la opción New field... del menú de acceso directo.
Esto ocasionará que aparezca la ventana New Field vista anteriormente
4. Seleccione la opción Lookup en el radio group Field type. Cuando usted selecciona
la opción Lookup se habilitan los combobox DataSet y Key Fields.
5. Seleccione en el combobox DataSet el componente dataset en el cual se va a buscar

el valor del campo. El componente DataSet en el que se va a hacer la búsqueda debe
ser diferente del componente DataSet donde se creo el campo Lookup, o un error en
tiempo de ejecución va a ocurrir. Cuando usted especifica el dataset donde se hara
la búsqueda, se habilitan los combobox Lookup Keys y Result Field.
6. Seleccione de la lista Key Fields el campo al cual se le va a asignar el valor. Para

asignarle valor a mas de un campo, digítelo directamente, pues no podrá
seleccionarlo de la lista, cuando son varios campos deben estar separados por punto
y coma “;”. Cuando se utilicen mas de un campo, se deben utilizar campos
persistentes.
7. Seleccione de la lista Lookup Keys el campo en el componente DataSet de

búsqueda cuyo valor se asignara al campo que se especificó en el paso 6. Recuerde
que si se especificó mas de un campo, usted debe especificar aquí la misma cantidad
aquí. Para especificar mas de un campo, digítelo directamente y sepárelo por punto
y coma.
8. Seleccione de la lista Result Field el campo de resultado en el componente DataSet

de búsqueda para el campo lookup que usted esta creando.
Practica: de manejo de campo
Búsqueda de una descripción en otra tabla

En esta practica vamos a crear un campo calculado para desplegar el nombre y apellido del
cliente.
Cree un formulario Maestro / Detalle con las tablas Factura y Detalle que fueron creadas
en el capitulo del Database DeskTop. El formulario debería lucir de la siguiente forma:
Cree un campo calculado en la tabla de factura, póngale de nombre NOMBRE_CLIENTE.
Agregue un componente Table al formulario y póngale de nombre Table_BusquedaCliente.

Conecte esta tabla con su respectivo alias o path, conéctelo con la tabla CLIENTE.
Utilizando la propiedad IndexFieldNames, seleccione el índice CLIENTE. Si la tabla no
esta indexada la búsqueda no funcionara.
Seleccione la tabla de factura y programe el evento OnCalcFields, escriba el código

siguiente:
if not Table_BusquedaCliente.Active then Table_BusquedaCliente.Open;

if Table_BusquedaCliente.FindKey([Table_FacturaCliente]) then
Table_FacturaNOMBRE_CLIENTE.AsString :=
Table_BusquedaCliente.FieldByname('nombre').AsString + ' ' +
Table_BusquedaCliente.FieldByname('apellido').AsString
else
Table_FacturaNOMBRE_CLIENTE.AsString := '';

Coloque un DBEdit al lado del DBEdit de cliente y conéctelo con el DataSource de factura
y con el campo calculado que creamos (NOMBRE_CLIENTE). A continuación un vistazo
a nuestro formulario:
Corra la aplicación, introduzca un código de cliente valido y debe desplegarse el nombre

completo del cliente al lado.

Validación para que un programa no permita introducir una clave repetida.
En esta practica vamos a utilizar el evento OnValidate para validar que un usuario no
digite dos veces el mismo código.
Cree un formulario simple con la tabla CLIENTE que fue creada en el capitulo del
Database DeskTop. El formulario debería lucir de la siguiente forma:

Conecte esta tabla con su respectivo alias o path, conéctelo con la tabla CLIENTE
también. Utilizando la propiedad IndexFieldNames, seleccione el índice CLIENTE. Si la
tabla no esta indexada la búsqueda no funcionara, esta componente accesa la misma tabla
de cliente, pero esta no esta conectada con el formulario, sino que la utilizaremos para que
cuando el usuario digite el código del cliente hacer una búsqueda en esta tabla para ver si
existe; si el código existe entonces desplegamos un mensaje indicándolo y evitando que sea
introducido este código de cliente.
Haga doble clic sobre el componente table_cliente, para cargar el editor de campos y
agregue todos los campos sino están agregados, seleccione el campo CLIENTE y vaya al
inspector de objeto y seleccione la pagina Events. Seleccione el evento OnValidate y haga
doble clic en la parte derecha, esto hará que aparezca el editor de código, escriba el
siguiente código:

if Table_BusquedaCliente.FindKey([Table_Cliente.FieldByName('Cliente')]) then
Raise Exception.Create('ERROR... ESTE CODIGO DE CLIENTE YA EXISTE!');
Ejecute la aplicación e introduzca un nuevo registro, introduzca el código de un cliente que

ya exista en la tabla para ver que sucede.

Tópicos avanzados de formularios con base de datos

Introducción
Cuando se esta desarrollando una aplicación en Delphi que interactúa con bases
de datos debemos tener en cuenta unos cuantos detalles, por ejemplo: en un
formulario de base de datos siempre existirá una tabla que es la tabla principal del
formulario – tabla principal quiere decir que en esa tabla es que el formulario
procesa toda las informaciones que se manejan en el formulario-.
Un formulario puede tener una o dos o tres... o n tablas principales dependiendo

del tipo de formulario que usted esté diseñando, por ejemplo: si es un formulario
sencillo, la tabla principal es una, pero si el formulario es un formulario
Master/Detail las tablas principales son dos en este caso.
Un formulario puede necesitar informaciones que se encuentran almacenadas en

otras tablas, estas tablas son consideradas como tablas secundarias, pues son
utilizadas para extraer informaciones de ellas para ser mostradas en el formulario
y en estas tablas no se realiza ningún tipo de procesamiento de información.
Por cada tabla que se vaya a acceder desde un formulario se necesita un

componente table para cada tabla de base de datos, por ejemplo: si tenemos un
formulario que procesa informaciones de una orden de compra, tendríamos que
acceder en dicho formulario mínimo a las siguientes tablas: maestro de la orden
de compra, detalle de la orden de compra, suplidores o proveedores, artículos,
etc., bajo esta condición necesitaríamos en el formulario cuatros componentes
table: uno para el maestro de ordenes, otro para el detalle, otro para articulo y un
ultimo para suplidores. Aquí podemos llegar a una conclusión muy importante, por
cada tabla o base de datos que se vaya a acceder desde un formulario se
necesita un componente table.
Construcción de las tablas para nuestro tutorial
En el Database DeskTop construya las siguientes tablas:
ARTICULO
ARTICULO C 16 *
DESCRIPCIO C 40
UNIDAD C 4
COSTO N 10 2
REFERENCI C 40
ESTADO C 1
ORDCOMP
NUMERO N 6 *
SUPLIDOR N 4
FECHA D
ESTADO C 1
OBSERVACIO C 250
TOTALORDE N 14 2
DETORDC
NUMERO N 6 *
LINEA N 4 *
ARTICULO C 16
CANTIDAD N 10 2
COSTO N 12 2
SUPLIDOR
SUPLIDOR N 4 *
NOMBRE C 60
DIRECCION C 80
EMAIL C 40
TELEFONO C 13
ESTADO C 1
Cree un nuevo proyecto en Delphi con la opción File | New Application del menú
principal de Delphi. En el formulario que trajo el proyecto cree un menú principal
con las siguientes opciones:
Mantenimiento
Artículos
Suplidor
Proceso
Ordenes de compra
Grave el proyecto y la unidad con los siguientes nombres: UmenuPrincipal para

la unidad y TutorialBDD para el proyecto.
Agregue un formulario en blanco y con la tabla de artículos, cree un formulario

para introducir las informaciones de los artículos, este formulario enlácelo con la
opción de artículos que se encuentra en el menú Mantenimiento. Haga lo mismo

con la tabla de suplidores. Y grave las unidades, Uarticulos y Usuplidores
respectivamente.
Ejecute la aplicación e introdúzcale diez artículos y 5 suplidores respectivamente.

Vuelva a tiempo de diseño, y agregue un formulario en blanco y construya un
formulario Master/Detail con las tabla ORDCOMP Y DETORDC. Enlace este
formulario con la opción en el menú de proceso.
A continuación una muestra de nuestro formulario de ordenes de compra:
Como se puede notar en este formulario procesaremos las informaciones

necesarias para crear una orden de compra. Note que este formulario tiene dos
tablas principales el maestro (ORDCOMP) y el detalle (DETORDC). Ya que
procesaremos informaciones en el maestro (Informaciones que no se repiten en la
orden) y en el detalle (las informaciones que se repiten por la orden, los artículos
que estamos ordenando).
Como se puede notar en la figura se necesita introducir el código del suplidor, pero
no se puede apreciar el nombre del suplidor, con lo cual el usuario no sabría de
quien es el código que esta utilizando.

Vamos a poner que en el formulario cuando el usuario digite el código del suplidor
muestre el nombre del suplidor.

Búsqueda de registro en una tabla
Para lograr que se visualice el nombre del suplidor en nuestra pantalla, debemos
programar un evento para que cuando introduzcan el código del suplidor se
busque este código en la tabla de suplidores y si existe lo muestre.
Lo primero que hay que hacer es colocar un componente table que se va a

conectar con la tabla de suplidores y que es la tabla donde se va a realizar la
búsqueda. Recuerde el comentario al principio del capitulo, por cada tabla que se
va a acceder en un formulario se necesita un componente table. Aquí como vamos
a acceder a la tabla de suplidores necesitamos un componente table.
Uso del evento OnExit del DBEdit para buscar un registro
La primera alternativa que vamos a utilizar para realizar nuestra búsqueda es el

evento OnExit del componente DBEdit.
En el formulario de ordenes de compra coloque un componente Edit al lado del

código del suplidor. A este edit le vamos a poner de nombre
edit_nombre_Suplidor (propiedad Name) y en el vamos a desplegar el nombre
del suplidor cuando el usuario introduzca el código, la pantalla de ordenes debería
lucir como sigue:

Vamos a proceder a programar el evento OnExit, seleccione el componente DBEDit donde

se captura el código del suplidor, vaya al inspector de objeto y seleccione la pagina
“Events” y busque el evento OnExit, haga doble-clic en la parte blanca del combobox que
aparece en el lado derecho del evento, aparece el editor de código, escriba el código a
continuación:
if tblSuplidores.FindKey([editsuplidor.Text]) then
edit_nombre_suplidor.Text := tblSuplidores.FieldByName('nombre').AsString
else
begin
edit_nombre_suplidor.Clear;
ShowMessage('ERROR... EL CODIGO DE SUPLIDOR NO EXISTE');
editsuplidor.SetFocus;
end;
Grave el formulario, corra el proyecto y pruebe. Es importante mencionar que si

los componentes en su formulario no tienen el mismo nombre que el que fue
empleado por nosotros en el código deben ser cambiados por los respectivos.
Todo funciona bien, eso es lo que usted piensa, agregue dos ordenes de compras
en el formulario y utilice los botones de navegación del formulario para moverse de
un registro a otro y observe lo que ocurre.
El nombre del suplidor no cambia, lo que sucede es que la búsqueda se realiza en

el evento OnExit del componente DBEdit del suplidor, y solamente cuando el
usuario se mueva desde este, hacia otro DBEdit se ejecuta el código, ¿Pero que
hacemos para solucionar el problema?. Solo hay que mandar a ejecutar este
evento desde el evento AfterScroll de la tabla de ordenes.
Seleccione el componente table de la tabla ORDCOMP y busque el evento

AfterScroll y programe el evento, coloque la siguiente línea de código:
EditSUPLIDORExit(EditSUPLIDOR);
Vuelva a ejecutar la aplicación y pruebe de nuevo, ahora si todo funciona bien.
Nota: Recuerde abrir la tabla de suplidores en el evento OnCreate del formulario,

porque de lo contrario ocurrirá un error cuando vaya a buscar el registro en el
Evento OnExit.
Uso del evento OnCalcFields del Table para buscar un registro
Vamos a utilizar el evento OncalcFields para hacer la búsqueda de la descripción

del articulo en el detalle. Cree un campo calculado en la tabla de detalle
(DETORDC), si no sabe como crearlo diríjase a la pagina 155 del material de

apoyo. Programe el evento OnCalcFields de la tabla de detalle para que haga la
búsqueda de la descripción en la tabla de artículos. Recuerde que debe colocar un
componente table para acceder a la tabla de artículos, como se hizo para el
suplidor.
El código para hacer la búsqueda en el evento OnCalcFields debe lucir mas o

menos:
if tblArticulos.FindKey([tblDetOrdC.FieldByName('articulo')]) then
tblDetOrdCdescripcion_articulo.AsString:=
tblArticulos.FieldByName('descripcio').AsString;
Uso del evento OnCalcFields del Table para hacer cálculos
En el detalle de la orden de compra, es necesario saber el Costo total de cada

artículos que estemos ordenando, para lograr esto solamente hay que multiplicar
la cantidad por el costo. Para realizar esto utilizaremos el evento OnCalcFields de
la tabla de detalle.
Cree un campo calculado que se llame total, para calcular el total de importe del
articulo, y coloque la siguiente línea de código para calcularlo:
tblDetOrdCtotal.AsFloat:= tblDetOrdCcantidad.AsFloat *
tblDetOrdCcosto.AsFloat;
El formulario de ordenes de compras como deben quedar


Creación de reportes utilizando QuickReport

Introducción a la creación de reportes utilizando QuickReport
Con la introducción de Delphi 2.0 vino la inclusión del grupo de componentes

QuickReport. QuickReport es un conjunto de clases, objetos, componentes visuales y sus
respectivas interfases con los cuales los desarrolladores pueden crear reportes impresos o
que se puedan ver por pantalla, desde el mismo Delphi.
QuickReport le proporciona al desarrollador la vía para incluir las capacidades de reportes

dentro del ejecutable de Delphi.
A continuación un vistazo a la paleta de componentes con la pagina QReport seleccionada:
El primer componente en la paleta es la clase TquickRep. El componente de esta clase

controla la forma de ver por pantalla o la impresión de los reportes creados dentro de un
formulario en Delphi. Después de colocar un componente QuickRep en el formulario, se
debe comenzar a colocar las diferentes bandas que representan las diferentes secciones de
un reporte.

En la figura anterior podemos ver un formulario con un componente QuickRep y este con
un componente QRBand en el. El componente QRBand representa las diferentes secciones
de un reporte, este componente tiene una propiedad BandType que especifica banda el
lugar y la frecuencia de impresión del mismo. El componente QRBand puede ser colocado
desde la paleta de componente o con la ventana de configuración de QuickReport. Cuando
se coloca un componente QRBand, el valor por defecto de la propiedad BandType es
rbTitle. Este tipo de banda se imprimirá solamente una vez al inicio del reporte.
Tipos de bandas
En la siguiente tabla mostraremos todos los tipos de bandas y el lugar y frecuencia de

impresión de cada una:
Tipo Ubicación
rbChild
rbColumnHeader Se imprime una vez por pagina y encima de cada columna del reporte.
rbDetail Se imprime una vez por cada registro del componente DataSet
rbGroupFooter Se imprime cada vez que el dato de la expresión cambia. Se imprime
debajo de la banda de detalle.
rbGroupHeader Se imprime cada vez que el dato de la expresión cambia. Se imprime
encima de la banda de detalle.
rbOverlay Una vez por página.
rbPageFooter Se imprime una vez en la parte inferior de la página.
rbPageHeader Se imprime una vez en la parte superior de la página.

rbSubDetail Se imprime por cada registro de la banda de detalle
rbSummary Se imprime al final del reporte
rbTitle Se imprime una vez al inicio del reporte.
Ventana de Configuración
La versión 3 de QuickReport viene con una ventana de configuración llamada Report

Settings, esta ventana facilita la forma de creación de reporte utilizando QuickReport, ya
que con unos cuantos clic, y el cambio de unos cuantos valores, usted puede crear un
reporte rápidamente.
Para llamar la ventana Report Settings de QuickReport solamente hay que hacer clic con el
botón de la derecha del mouse encima del componente QuickRep y seleccionar la opción
Report Settings del menú que aparece. Otra forma para llamar la ventana Report Settings
es haciendo doble clic sobre el componente QuickRep. Sea cual fuere la forma que usted
utilice para llamarla, la ventana Report Settings debe lucir como la figura siguiente:

En esta ventana se puede ajustar el tamaño del papel (Paper size), los margenes de la pagina
(Margins), el tipo de letra (Other), si la pagina va a tener un marco (Page frame) y lo mas
importante las bandas que va a tener el reporte(Bands). Como se puede apreciar la ventana
es bien facil de utilizar y como dijimos anteriormente, con unos cuantos clic podemos
definir nuestros reportes.
Nota: es muy importante mencionar que cualquiera de los métodos de llamar la ventana
Report Settings debe ser utilizado sobre el componente QuickRep, ya que si por
equivocación se selecciona el área de una banda, el resultado no será el esperado.
En este capitulo vamos a crear un reporte de clientes con la tabla Customer, el reporte
contendrá las siguientes columnas: Nombre, Dirección, Ciudad y Pais para los campos:
Company, Addr1, City y Country. Lo primero que vamos a necesitar es crear un nuevo
proyecto y formulario y agregar un componente QuickRep en él.
Luego vamos a llamar la ventana de configuración de reporte y vamos a seleccionar tres

bandas para el reporte: la primera banda es PageHeader; la segunda es ColumnHeader y la
tercera es la banda Detail. Hasta este momento nuestro reporte debe lucir como la siguiente
figura:
Fuente de los Datos
Normalmente las informaciones son almacenadas en archivos o base de datos. Sea cual
fuere el lugar donde se guardan las informaciones, al momento de crear nuestro reporte con
QuickReport, debemos decirle de donde el va a sacar los datos para generar el reporte.
Para especificar la fuente de los datos del reporte utilizaremos los componentes DataSet,
con los cuales ya usted esta familiarizado y que sirven para acceder a la información de la
base de datos vía el BDE. Al igual que con los formularios, el componente DataSet puede
residir localmente en el formulario o en un DataModule.
Coloque un componente Table en nuestro formulario y conéctelo con el alias DBDemos

vía la propiedad DataBaseName, y en la propiedad TableName seleccione la tabla
Customer.db.
El próximo paso consiste en decirle a QuickReport desde donde va a obtener los datos, esto
lo haremos utilizando la propiedad DataSet del componente QuickRep. Seleccione el
componente QuickRep y en la propiedad DataSet seleccione el componente Table
respectivamente. Ahora nuestro reporte debe parecerse a la siguiente figura:
Informaciones fijas en el reporte
El paso siguiente para la creación de nuestro reporte es poner los letreros y encabezados de
nuestro reporte. En el grupo de componentes de QuickReport se encuentra un componente
llamado QRLabel. Este componente sirve para poner letreros o informaciones fijas en
nuestro reporte. El funcionamiento de este componente es parecido al componente Label,
con la ligera diferencia que el Label no puede ser utilizado con QuickReport. Para utilizar
el componente QRLabel solamente hay que seleccionarlo y colocarlo en la banda deseada.
Para nuestro ejemplo vamos a crear cuatro columnas de encabezados utilizando el
componente QRLabel y lo vamos a colocar en banda ColumnHeader. Les pondremos de
nombre: QRLabelNombre, QRLabelDireccion, QRLabelCiudad, QRLabelPais
respectivamente. Y en la propiedad Caption le pondremos: Nombre, Dirección, Ciudad,
País respectivamente. Nuestro reporta ahora debe lucir como la figura siguiente:
Datos del Reporte
Después de haber terminado de construir los encabezados, el paso siguiente es colocar los
datos del reporte. Para colocar los datos de la base de datos en el reporte se utilizan los
componentes QRDB de QuickReport. estos componentes no son mas que todos los
comoponentes que comienzan con estas siglas y que denotan que son componentes de
QuickReport para base de datos. El componente que utilizaremos en nuestro ejemplo es el
QRDBText. Este componente sirve para mostrar información proveniente de la base de
datos, este componente tiene dos propiedades que sirven para conectarlo con la tabla de
base de datos y con el campo, esta propiedades son: DataSet y DataField respectivamente.
Para crear un componente QRDBText solamente haga clic en la paleta de componente y
colóquelo en la banda deseada del reporte. Para nuestro caso, crearemos cinco QRDBText
en la banda de detalle. Estos objetos corresponden a los QRLabel creados anteriormente en
la banda ColumnHeader y deben ir alineados con ellos.

Conecte los componentes QRDBText con el componente Table vía la propiedad DataSet
del componente QRDBText. Una vez se ha conectado el componente QRDBText con el
componente DataSet, se puede conectar el mismo con el campo de la tabla de base de datos
vía la propiedad DataField. Para conectar el componente QRDBText con el campo
solamente hay que seleccionar el campo de la lista de campos de la propiedad DataField.
Conecte los componentes QRDBText con los campos Company, Addr1, City y Country
respectivamente.
Vamos ahora a colocar un encabezado con el nombre del reporte y el numero de pagina en
la banda PageHeader. Coloque un componente QRLabel en la banda PageHeader y en la
propiedad Caption del QRLabel escriba “Reporte de Clientes”, centralice el letrero al
centro de la venta. Ahora vamos a colocar el numero de pagina del reporte, para colocar el
numero de pagina en el encabezado, necesitaremos un componente QRSysData: este
componente sirve para poner informaciones del sistema en el reporte. Coloque un
componente QRSysData en la esquina superior derecha de la banda PageHeader. Ahora en
la propiedad Data del componente QRSysdata seleccione el valor qrsPageNumber y en la
propiedad Text del mismo introduzca “Numero de Página: ”, este será el letrero que
aparecerá antes del numero de página. Nuestro reporte debe lucir ahora como la figura a
continuación:
Vamos a ver como luce nuestro reporte, pero primero debemos activar la tabla para que los
datos estén disponibles. Seleccione la tabla y en la propiedad Active de la tabla seleccione
el valor True, ahora haga clic con el botón de la derecha del mouse encima del componente
QuickRep y seleccione la opción Preview del menú de acceso directo o bien llame la
ventana Report Settings y haga clic sobre el botón preview.
Campos de totales generales en el reporte
Los campos de totales se construyen en la banda de total (rbSummary), por lo tanto cada
vez que deseemos calcular totales en nuestro reporte debemos agregar una banda de este
tipo. El próximo paso a seguir es crear el campo de total. En la página Qreport de la paleta
de componente hay un componente llamado QRExpr. Este componente sirve para crear
campos calculados.

Uso del Form Wizard para crear aplicaciones con base de

datos

Introducción al Form Wizard
El Form Wizard es un utilitario de Delphi que facilita la creación de formularios de base de

datos. Esta herramienta le permite al programador crear formularios de entrada de datos sin
necesidad de escribir una sola línea de código de programación. Los formularios son
creados rápidamente y el usuario solo tiene que paso a paso diciéndole al Wizard como
desea el formulario. Una vez que el formulario es creado con el Form Wizard, el
programador puede hacerle todos los cambios necesarios que necesite el formulario para
satisfacer las necesidades de los usuarios.
Uso del Form Wizard
Para ejecutar el Form Wizard usted puede utilizar uno de los dos métodos existente que hay
para cargarlo, estos son:
Seleccionando la opción Database | Form Wizard... del menú principal de Delphi
Seleccionando la opción File New... del menú principal de Delphi, luego seleccione la
página Bussines de la ventana New Items que aparece:

Para iniciar el Form Wizard, seleccione el icono Database Form Wizard y pulse el botón
OK o simplemente haga doble-clic sobre el icono.
Cualquiera que fuere la forma que usted utilice para iniciar el Form Wizard, la pantalla
iniciar del Form Wizard será la misma:
la figura anterior muestra la ventana iniciar del Form Wizard, en esta pantalla el usuario
debe especificar que tipo de formulario desea crear.
Creación de un formulario simple utilizando el Database Form

Wizard
Para crear un formulario simple de base de datos con el Form Wizard, lo primero que
tenemos que hacer es cargar el Form Wizard, una vez cargado el Form Wizard en la
debajo del grupo Form Options, haga clic sobre la opción Create a simple form; luego
procedemos a seleccionar el tipo de componente DataSet que deseamos utilizar, para esto
debemos seleccionar una de las dos opciones que se encuentran debajo del grupo DataSet
Options, haga clic sobre la opción Create a form using TTable objects. Haga clic sobre el
botón Next, esto traerá la siguiente pantalla:



Seleccione la tabla animals.dbf y presione el botón Next. Cabe mencionar que el botón Next
solo se activa una vez que usted ha completado las informaciones necesaria para cada
pantalla. Ahora aparece la tercera pantalla del Form Wizard que debe lucir como la
siguiente figura:

en el formulario. Esta ventana cuenta con dos listas: Available Fields y Ordered Selected
Fields. La primera contiene todos los campos que están en la tabla y la segunda contiene los
campos y el orden en que van a aparecer en el formulario. Aquí la idea es pasar de una lista
a otra los campos, para esto se deben utilizar los botones que se encuentran entre las dos
listas o simplemente arrastrar de una lista a otra los campos. Los botones permiten mover
los campos en la dirección de la Flecha y los que tienen dos flechas mueven todos los
campos a la vez en la dirección que indica la flecha. Debajo de la lista Ordered Selected
Fields hay dos botones, estos botones sirven para intercambiar el orden de los campos.
Transfiera todos los campos a la lista Ordered Selected Fields, la ventana debe lucir como a
continuación:



encima de los DBEdit. Seleccione Left y presione el botón Next para pasar a la siguiente
pantalla:

parámetros:

Creación de un formulario Maestro / Detalle utilizando el Database

Form Wizard
Para crear un formulario maestro / detalle de base de datos con el Form Wizard, lo primero
que tenemos que hacer es cargar el Form Wizard, una vez cargado el Form Wizard en la
debajo del grupo Form Options, haga clic sobre la opción Create a Master/Detail form;
luego procedemos a seleccionar el tipo de componente DataSet que deseamos utilizar, para
esto debemos seleccionar una de las dos opciones que se encuentran debajo del grupo
DataSet Options, haga clic sobre la opción Create a form using TTable objects. Haga clic
sobre el botón Next, esto mostrará la siguiente pantalla:



En esta pantalla seleccionaremos la tabla de base de datos que será el maestro (master) en el
formulario, seleccione la tabla orders.db y presione el botón Next. Ahora aparece la

en la parte maestra del formulario. Esta ventana cuenta con dos listas: Available Fields y
Ordered Selected Fields. La primera contiene todos los campos que están en la tabla y la
segunda contiene los campos y el orden en que van a aparecer en el formulario. Aquí la
idea es pasar de una lista a otra los campos, para esto se deben utilizar los botones que se
encuentran entre las dos listas o simplemente arrastrar de una lista a otra los campos. Los
botones permiten mover los campos en la dirección de la Flecha y los que tienen dos
flechas mueven todos los campos a la vez en la dirección que indica la flecha. Debajo de la
lista Ordered Selected Fields hay dos botones, estos botones sirven para intercambiar el
orden de los campos. Transfiera todos los campos a la lista Ordered Selected Fields, la
ventana debe lucir como a continuación:



encima de los DBEdit. Seleccione Top y presione el botón Next para pasar a la siguiente
pantalla:

En esta pantalla seleccionaremos la tabla de base de datos que será el detalle (detail) en el
formulario, seleccione la tabla items.db y presione el botón Next. Ahora aparece la
En esta ventana debemos seleccionar los campos de la tabla de detalle que deseamos que
aparezcan en la parte de detalle del formulario. Esta ventana cuenta con dos listas:
Available Fields y Ordered Selected Fields. La primera contiene todos los campos que
están en la tabla y la segunda contiene los campos y el orden en que van a aparecer en el
formulario. Aquí la idea es pasar de una lista a otra los campos, para esto se deben utilizar
los botones que se encuentran entre las dos listas o simplemente arrastrar de una lista a otra
los campos. Los botones permiten mover los campos en la dirección de la Flecha y los que
tienen dos flechas mueven todos los campos a la vez en la dirección que indica la flecha.
Debajo de la lista Ordered Selected Fields hay dos botones, estos botones sirven para
intercambiar el orden de los campos. Transfiera todos los campos a la lista Ordered
Selected Fields, la ventana debe lucir como a continuación:

hará que los campos sean manipulados desde un DBGrid. Se debe notar que por defecto

viene seleccionado la opción In a grid, ya que la parte del detalle estará formado por uno o
mas registros, presione el botón Next para pasar a la siguiente ventana:
En esta ventana se debe establecer las relaciones entre la tabla maestra y la tabla de detalle.
Seleccione en el Detail Fields el campo OrderNo y en Master Fields el campo OrderNo,

luego haga clic en el botón Add, presione el botón Next para pasar a la siguiente ventana:
parámetros:


Trabajando con los Campos de la Tabla

Introducción al manejo de campos
El acceso a los campos de una tabla de base de datos es quizás uno de los puntos
primordiales en la construcción de aplicaciones de base de datos. La necesidad por parte de
los programadores de interactuar y manipular las columnas de una tabla sin necesidad que
el usuario tenga que editarlo en pantalla. Los componentes de campos son componentes
invisibles que son creados por Delphi en tiempo de ejecución para el manejo de las
columnas de la tabla. Los componentes de campos son descendientes del objeto Tfield o
uno de sus subclases. Por defecto cada vez que usted coloca en la aplicación un
componente DataSet y lo abre, Delphi automáticamente asigna un descendiente del objeto
Tfield para cada campo de la tabla de base de datos.
Estos componentes que Delphi crea dinámicamente, son invisibles y tienen un tipo de datos
especifico para el tipo de datos que tiene definido el campo en la tabla. Los campos que
Delphi crea son almacenados en la propiedad Fields del componente Table y Querie, esta
propiedad es un arreglo.
Este funcionamiento por defecto de crear los campos cada vez que usted abre un
componente DataSet puede ser omitido en tiempo de diseño, para lograr esto solo hay que
crear campos persistentes. Para crear campos persistentes solo hay que crearlos en el editor
de campo.
Tipos de componentes TField
Los componentes de campos son creados a partir del objeto TField. Usted no puede crear
un componente de tipo TField, pero si existe una serie de componentes de campos que
corresponden a los tipos de campos dentro de una tabla de base de datos. A continuación
una lista de los componentes de campos:
Componente de Campo Propósito

TStringField Tipo texto con un rango de 255 caracteres
TIntegerField Números enteros con un rango de –2147483648 hasta 2147483647
TSmallIntField Números enteros con un rango de –32768 hasta 32767
TWordField Números enteros con un rango de 0 hasta 65535
TFloatField Números reales con un rango de 5.0 * 10–324 hasta 1.7 * 10308
TCurrencyField Números reales con un rango de 5.0 * 10–324 hasta 1.7 * 10308
TBCDField Números reales con un numero fijo de digitos después del punto
decimal, aproximadamente 18 digitos.
TBooleanField Valores lógicos, False o True
TDateTimeField Valores de fecha y hora
TDateField Valores de fecha
TTimeField Valores de hora

TBlobField Valor binario largo de un tamaño ilimitado
TBytesField Valor binario largo de un tamaño ilimitado
TVarBytesField Valor binario de un tamaño arbitrario de 65535 caracteres
TMemoField Valor tipo texto, con un tamaño aproximado a 2GB
TGraphicField Datos tipo imágenes graficas en tamaño ilimitado
Estos son los componentes de campos que son creados automáticamente por Delphi o que
son creados por usted en el diseñador de campos. La ventaja que existe en crearlo en
tiempo de diseño (campos persistentes) es que podemos manipular las propiedades y los
eventos de estos componentes a través del inspector de objeto. Existen otros tipos de
campos, pero estos son los mas utilizados.
Uso del editor de campos
El editor de campos es la herramienta que nos permite crear campos persistentes o mejor
dicho crear los campos en tiempo de diseño para omitir el funcionamiento por defecto que
tiene Delphi de crear los campos dinámicamente.
Para cargar o llamar el editor de campo existen dos formas:
 Hacer doble clic sobre el componente DataSet;
 Y hacer clic con el botón de la derecha del Mouse encima del componente DataSet
y seleccionar la opción Fields Editor... del menú de acceso directo que aparece.
A continuación una figura que muestra el editor de campos:

Para crear los campos solamente hay que hacer clic con el botón de la derecha del Mouse y
seleccionar la opción Add fields... del menú de acceso directo:
Cabe mencionar que solamente tenemos tres opciones disponibles en el menú, pues no
existe ningún campo creado en el editor de campo. Cuando seleccionamos la opción Add
fields... aparece una ventana con todos los campos del componente DataSet seleccionados:

Para crear todos los componentes de campos para todos ellos , haga clic en el botón OK.
Cuando usted desee dejar sin crear algún campo, utilice la combinación Ctrl. + clic del
Mouse para desmarcarlo, y esto evitara que sea creado. Una vez que los campos han sido
agregados el editor de campos luce como la siguiente figura:
Ahora podemos cambiar las propiedades y programar los eventos de los campos creados.
Se puede notar en la figura anterior que el campo seleccionado en el editor de campos, es el
componente que aparece seleccionado en el inspector de objeto.

Propiedades mas comunes de los componentes TField
Propiedad Descripción
Currency Esta propiedad es utilizada para controlar los valores de los campos
tipo TBCDField, TcurrencyField y TFloatField, cuando las
propiedades DisplayFormat y EditFormat no tienen ningún valor.
DisplayFormat Sirve para asignar una mascarilla. Esta mascarilla es utilizada
solamente para desplegar los datos.
DisplayLabel Permite cambiar el titulo de encabezado que es desplegado en la
columna del componente DBGrid.
DisplayWidth Permite cambiar la cantidad de caracteres que será desplegada para
el campo.
EditMask Sirve para asignar una mascarilla. Esta mascarilla es utilizada para
editar los datos.
ReadOnly Permite especificar si el campo será solo lectura o no
Required Esta propiedad sirve para controlar si el campo debe tener valor o
no.
Visible Permite desplegar o no un campo.

Eventos de los componentes TField
Como se puede notar los componentes TField solamente constan con cuatros eventos:
Evento Descripción
OnChange Este evento se dispara inmediatamente los datos han sido
introducido en el buffer del registro.
OnGetText Este evento se ejecuta cada vez que la propiedad DisplayText o Text
del campo son referenciada.
OnSetText Este evento se ejecuta cuando se le asigna un valor a la propiedad
Text del campo.
OnValidate Sirve para validar los datos que se introducen en el campo.
Formateando los campos con la propiedad EditMask
Una de las tareas mas comunes que debe acompañar la creación de formularios para entrada
de datos es determinar como se quiere formatear la información. Para modificar la forma
como la información es capturada se debe utilizar la propiedad EditMask para los datos tipo
String. Este método permite insertar caracteres que se convertirán en parte del campo, por
Ejemplo: guiones o paréntesis que son definidos como caracteres literales dentro de la
mascarilla, aparecerán como parte de los datos del campo en la tabla.
Para asignarle una mascarilla a la propiedad EditMask de un campo, seleccione el campo

en el editor de campos y haga doble clic en la parte derecha de la propiedad EditMask en el
inspector de objeto o haga clic sobre la ellipsis en el editor de campos. Cuando usted realice
uno de los dos métodos anteriores, aparecerá la ventana Input Mask Editor:

La ventana Input Mask Editor presenta una serie de mascarilla de ejemplo en la parte
derecha de la ventana. Para utilizar una de estas mascarillas, solamente hay que hacer
doble-clic sobre ella. La mascarilla puede ser probada para ver como trabaja en el cuadro
Test Input. Después de haber definido su mascarilla, usted puede introducir cadenas de
caracteres de prueba para ver si la mascarilla formatea el texto correctamente. El botón
Masks permite cargar archivos de mascarillas de otros países.
Formas de acceso por código de programación al campo de una

tabla
Existen varias formas para acceder a un campo por código de programación, entre la que
mencionaremos:
4. La propiedad Fields del componente DataSet, que permite acceder a un campo por
el orden en la tabla de base de datos y donde el primer campo de la tabla es el
elemento 0, por ejemplo:
Si tenemos un componente DataSet que se llama Table1, para acceder al primer

campo de la tabla escribiríamos el siguiente código:
Table1.Fields[0].Value;
5. El método FieldByName del componente DataSet que permite acceder a un campo

por el nombre del campo en la tabla de base de datos, por ejemplo:

que se llama “NUMERO” en la tabla escribiríamos el siguiente código:
Table1.FieldByName(‘NUMERO’).Value;
6. Y por ultimo mediante el componente persistente que es creado cuando agregamos

los campos en el editor de campos. Cuando se crea un campo persistente Delphi
emplea una notación para crear el componente, esta notación tiene la siguiente
sintaxis:
NombredelcomponentedatasetNombredelCampo
Por Ejemplo:

que se llama “NUMERO” y que ha sido creado en el editor de campos escribiríamos

el siguiente código:
Table1NUMERO.Value;
Cabe comentar aquí que las dos primeras formas funcionan con campos dinámicos como
con campos persistente, pero que el ultimo formato solamente funciona con campos
persistente.
Creación de un campo calculado
Un campo calculado es un campo cuyo valor es calculado en tiempo de ejecución en el

evento OnCalcFields del componente DataSet. El valor de un campo calculado es obtenido
del calculo de uno o varios campos de la base de datos, esto permite obtener valores
derivados de la tabla con los demás campos sin necesidad de ocupar espacio en la tabla de
base de datos, por Ejemplo: se necesitaría crear un campo string que despliegue los datos
concatenados de otros campos.
8. Para crear un campo calculado cargue el editor de campo y haga clic con el botón de
la derecha del Mouse y seleccione la opción New field... del menú de acceso
directo. Esto ocasionará que aparezca la ventana New Field:
9. Introduzca el nombre del campo en el edit box Name, este nombre debe ser
diferente de los que existen en la tabla de base de datos.

12. Seleccione la opción Calculated en el radio group Field type.
13. Haga clic en el botón OK. El nuevo campo calculado es agregado al final de la lista
de campos del editor de campos.
14. Programe el evento OnCalcFields del componente DataSet para calcular el valor del
campo calculado.
Nota: los campos calculados solamente se le puede asignar valor en el evento OnCalcFields
y el evento OnCalcField se programa en el componente DataSet donde se creó el campo
calculado.
Creación de un campo lookup
Un campo lookup es un campo de solo lectura que despliega valores en tiempo de

ejecución basado en un criterio de búsqueda que usted especifica. Los campos lookup
permiten colocar una lista en el grid que limitan al usuario a seleccionar un valor de la lista
de valores que vienen de un componente DataSet. Usted puede colocar el elementos de una
tabla dentro de una lista, esto permite que el usuario vea un conjunto de opciones para
seleccionar desde ahí, en vez de tener que digitarlo. Esto permite asegurar que los datos que
el usuario introduzca siempre serán validos, lo que le ahorrara al programador el tener que
usar una serie de validaciones.
9. Para crear un campo lookup cargue el editor de campo y haga clic con el botón de la
derecha del Mouse y seleccione la opción New field... del menú de acceso directo.
Esto ocasionará que aparezca la ventana New Field vista anteriormente
12. Seleccione la opción Lookup en el radio group Field type. Cuando usted selecciona
la opción Lookup se habilitan los combobox DataSet y Key Fields.
13. Seleccione en el combobox DataSet el componente dataset en el cual se va a buscar

el valor del campo. El componente DataSet en el que se va a hacer la búsqueda debe
ser diferente del componente DataSet donde se creo el campo Lookup, o un error en

tiempo de ejecución va a ocurrir. Cuando usted especifica el dataset donde se hara

la búsqueda, se habilitan los combobox Lookup Keys y Result Field.
14. Seleccione de la lista Key Fields el campo al cual se le va a asignar el valor. Para
asignarle valor a mas de un campo, digítelo directamente, pues no podrá
seleccionarlo de la lista, cuando son varios campos deben estar separados por punto
y coma “;”. Cuando se utilicen mas de un campo, se deben utilizar campos
persistentes.
15. Seleccione de la lista Lookup Keys el campo en el componente DataSet de

búsqueda cuyo valor se asignara al campo que se especificó en el paso 6. Recuerde
que si se especificó mas de un campo, usted debe especificar aquí la misma cantidad
aquí. Para especificar mas de un campo, digítelo directamente y sepárelo por punto
y coma.
16. Seleccione de la lista Result Field el campo de resultado en el componente DataSet

de búsqueda para el campo lookup que usted esta creando.
Practica: de manejo de campo

Búsqueda de una descripción en otra tabla
En esta practica vamos a crear un campo calculado para desplegar el nombre y apellido del
cliente.
Cree un formulario Maestro / Detalle con las tablas Factura y Detalle que fueron creadas
en el capitulo del Database DeskTop. El formulario debería lucir de la siguiente forma:

Cree un campo calculado en la tabla de factura, póngale de nombre NOMBRE_CLIENTE.

Conecte esta tabla con su respectivo alias o path, conéctelo con la tabla CLIENTE.
Utilizando la propiedad IndexFieldNames, seleccione el índice CLIENTE. Si la tabla no
esta indexada la búsqueda no funcionara.
Seleccione la tabla de factura y programe el evento OnCalcFields, escriba el código

siguiente:

if Table_BusquedaCliente.FindKey([Table_FacturaCliente]) then
Table_FacturaNOMBRE_CLIENTE.AsString :=
Table_BusquedaCliente.FieldByname('nombre').AsString + ' ' +
Table_BusquedaCliente.FieldByname('apellido').AsString
else
Table_FacturaNOMBRE_CLIENTE.AsString := '';
Coloque un DBEdit al lado del DBEdit de cliente y conéctelo con el DataSource de factura
y con el campo calculado que creamos (NOMBRE_CLIENTE). A continuación un vistazo
a nuestro formulario:

Corra la aplicación, introduzca un código de cliente valido y debe desplegarse el nombre

completo del cliente al lado.

Validación para que un programa no permita introducir una clave repetida.
En esta practica vamos a utilizar el evento OnValidate para validar que un usuario no
digite dos veces el mismo código.
Cree un formulario simple con la tabla CLIENTE que fue creada en el capitulo del
Database DeskTop. El formulario debería lucir de la siguiente forma:

Conecte esta tabla con su respectivo alias o path, conéctelo con la tabla CLIENTE
también. Utilizando la propiedad IndexFieldNames, seleccione el índice CLIENTE. Si la
tabla no esta indexada la búsqueda no funcionara, esta componente accesa la misma tabla
de cliente, pero esta no esta conectada con el formulario, sino que la utilizaremos para que
cuando el usuario digite el código del cliente hacer una búsqueda en esta tabla para ver si
existe; si el código existe entonces desplegamos un mensaje indicándolo y evitando que sea
introducido este código de cliente.
Cargue el editor de campos y agregue todos los campos sino están agregados, seleccione el
campo CLIENTE y vaya al inspector de objeto y seleccione la pagina Events. Seleccione el
evento OnValidate y haga doble clic en la parte derecha, esto hará que aparezca el editor
de código, escriba el siguiente código:


if Table_BusquedaCliente.FindKey([Table_Cliente.FieldByName('Cliente')]) then
Raise Exception.Create('ERROR... ESTE CODIGO DE CLIENTE YA EXISTE!');
Ejecute la aplicación e introduzca un nuevo registro, introduzca el código de un cliente que

ya exista en la tabla para ver que sucede.

Creación de reportes utilizando QuickReport

Introducción a la creación de reportes utilizando QuickReport
Con la introducción de Delphi 2.0 vino la inclusión del grupo de componentes

QuickReport. QuickReport es un conjunto de clases, objetos, componentes visuales y sus
respectivas interfases con los cuales los desarrolladores pueden crear reportes impresos o
que se puedan ver por pantalla, desde el mismo Delphi.
QuickReport le proporciona al desarrollador la vía para incluir las capacidades de reportes

dentro del ejecutable de Delphi.
A continuación un vistazo a la paleta de componentes con la pagina QReport seleccionada:
El primer componente en la paleta es la clase TquickRep. El componente de esta clase

controla la forma de ver por pantalla o la impresión de los reportes creados dentro de un
formulario en Delphi. Después de colocar un componente QuickRep en el formulario, se
debe comenzar a colocar las diferentes bandas que representan las diferentes secciones de
un reporte.

En la figura anterior podemos ver un formulario con un componente QuickRep y este con
un componente QRBand en el. El componente QRBand representa las diferentes secciones
de un reporte, este componente tiene una propiedad BandType que especifica banda el
lugar y la frecuencia de impresión del mismo. El componente QRBand puede ser colocado
desde la paleta de componente o con la ventana de configuración de QuickReport. Cuando
se coloca un componente QRBand, el valor por defecto de la propiedad BandType es
rbTitle. Este tipo de banda se imprimirá solamente una vez al inicio del reporte.
Tipos de bandas
En la siguiente tabla mostraremos todos los tipos de bandas y el lugar y frecuencia de

impresión de cada una:
Tipo Ubicación
rbChild
rbColumnHeader Se imprime una vez por pagina y encima de cada columna del reporte.
rbDetail Se imprime una vez por cada registro del componente DataSet
rbGroupFooter Se imprime cada vez que el dato de la expresión cambia. Se imprime
debajo de la banda de detalle.
rbGroupHeader Se imprime cada vez que el dato de la expresión cambia. Se imprime
encima de la banda de detalle.
rbOverlay Una vez por página.
rbPageFooter Se imprime una vez en la parte inferior de la página.
rbPageHeader Se imprime una vez en la parte superior de la página.

rbSubDetail Se imprime por cada registro de la banda de detalle
rbSummary Se imprime al final del reporte
rbTitle Se imprime una vez al inicio del reporte.
Ventana de Configuración
La versión 3 de QuickReport viene con una ventana de configuración llamada Report

Settings, esta ventana facilita la forma de creación de reporte utilizando QuickReport, ya
que con unos cuantos clic, y el cambio de unos cuantos valores, usted puede crear un
reporte rápidamente.
Para llamar la ventana Report Settings de QuickReport solamente hay que hacer clic con el
botón de la derecha del mouse encima del componente QuickRep y seleccionar la opción
Report Settings del menú que aparece. Otra forma para llamar la ventana Report Settings
es haciendo doble clic sobre el componente QuickRep. Sea cual fuere la forma que usted
utilice para llamarla, la ventana Report Settings debe lucir como la figura siguiente:

En esta ventana se puede ajustar el tamaño del papel (Paper size), los margenes de la pagina
(Margins), el tipo de letra (Other), si la pagina va a tener un marco (Page frame) y lo mas
importante las bandas que va a tener el reporte(Bands). Como se puede apreciar la ventana
es bien facil de utilizar y como dijimos anteriormente, con unos cuantos clic podemos
definir nuestros reportes.
Nota: es muy importante mencionar que cualquiera de los métodos de llamar la ventana
Report Settings debe ser utilizado sobre el componente QuickRep, ya que si por
equivocación se selecciona el área de una banda, el resultado no será el esperado.
En este capitulo vamos a crear un reporte de clientes con la tabla Customer, el reporte
contendrá las siguientes columnas: Nombre, Dirección, Ciudad y Pais para los campos:
Company, Addr1, City y Country. Lo primero que vamos a necesitar es crear un nuevo
proyecto y formulario y agregar un componente QuickRep en él.
Luego vamos a llamar la ventana de configuración de reporte y vamos a seleccionar tres

bandas para el reporte: la primera banda es PageHeader; la segunda es ColumnHeader y la
tercera es la banda Detail. Hasta este momento nuestro reporte debe lucir como la siguiente
figura:
Fuente de los Datos
Normalmente las informaciones son almacenadas en archivos o base de datos. Sea cual
fuere el lugar donde se guardan las informaciones, al momento de crear nuestro reporte con
QuickReport, debemos decirle de donde el va a sacar los datos para generar el reporte.
Para especificar la fuente de los datos del reporte utilizaremos los componentes DataSet,
con los cuales ya usted esta familiarizado y que sirven para acceder a la información de la
base de datos vía el BDE. Al igual que con los formularios, el componente DataSet puede
residir localmente en el formulario o en un DataModule.
Coloque un componente Table en nuestro formulario y conéctelo con el alias DBDemos

vía la propiedad DataBaseName, y en la propiedad TableName seleccione la tabla
Customer.db.
El próximo paso consiste en decirle a QuickReport desde donde va a obtener los datos, esto
lo haremos utilizando la propiedad DataSet del componente QuickRep. Seleccione el
componente QuickRep y en la propiedad DataSet seleccione el componente Table
respectivamente. Ahora nuestro reporte debe parecerse a la siguiente figura:
Informaciones fijas en el reporte
El paso siguiente para la creación de nuestro reporte es poner los letreros y encabezados de
nuestro reporte. En el grupo de componentes de QuickReport se encuentra un componente
llamado QRLabel. Este componente sirve para poner letreros o informaciones fijas en
nuestro reporte. El funcionamiento de este componente es parecido al componente Label,
con la ligera diferencia que el Label no puede ser utilizado con QuickReport. Para utilizar
el componente QRLabel solamente hay que seleccionarlo y colocarlo en la banda deseada.
Para nuestro ejemplo vamos a crear cuatro columnas de encabezados utilizando el
componente QRLabel y lo vamos a colocar en banda ColumnHeader. Les pondremos de
nombre: QRLabelNombre, QRLabelDireccion, QRLabelCiudad, QRLabelPais
respectivamente. Y en la propiedad Caption le pondremos: Nombre, Dirección, Ciudad,
País respectivamente. Nuestro reporta ahora debe lucir como la figura siguiente:
Datos del Reporte
Después de haber terminado de construir los encabezados, el paso siguiente es colocar los
datos del reporte. Para colocar los datos de la base de datos en el reporte se utilizan los
componentes QRDB de QuickReport. estos componentes no son mas que todos los
comoponentes que comienzan con estas siglas y que denotan que son componentes de
QuickReport para base de datos. El componente que utilizaremos en nuestro ejemplo es el
QRDBText. Este componente sirve para mostrar información proveniente de la base de
datos, este componente tiene dos propiedades que sirven para conectarlo con la tabla de
base de datos y con el campo, esta propiedades son: DataSet y DataField respectivamente.
Para crear un componente QRDBText solamente haga clic en la paleta de componente y
colóquelo en la banda deseada del reporte. Para nuestro caso, crearemos cinco QRDBText
en la banda de detalle. Estos objetos corresponden a los QRLabel creados anteriormente en
la banda ColumnHeader y deben ir alineados con ellos.

Conecte los componentes QRDBText con el componente Table vía la propiedad DataSet
del componente QRDBText. Una vez se ha conectado el componente QRDBText con el
componente DataSet, se puede conectar el mismo con el campo de la tabla de base de datos
vía la propiedad DataField. Para conectar el componente QRDBText con el campo
solamente hay que seleccionar el campo de la lista de campos de la propiedad DataField.
Conecte los componentes QRDBText con los campos Company, Addr1, City y Country
respectivamente.
Vamos ahora a colocar un encabezado con el nombre del reporte y el numero de pagina en
la banda PageHeader. Coloque un componente QRLabel en la banda PageHeader y en la
propiedad Caption del QRLabel escriba “Reporte de Clientes”, centralice el letrero al
centro de la venta. Ahora vamos a colocar el numero de pagina del reporte, para colocar el
numero de pagina en el encabezado, necesitaremos un componente QRSysData: este
componente sirve para poner informaciones del sistema en el reporte. Coloque un
componente QRSysData en la esquina superior derecha de la banda PageHeader. Ahora en
la propiedad Data del componente QRSysdata seleccione el valor qrsPageNumber y en la
propiedad Text del mismo introduzca “Numero de Página: ”, este será el letrero que
aparecerá antes del numero de página. Nuestro reporte debe lucir ahora como la figura a
continuación:
Vamos a ver como luce nuestro reporte, pero primero debemos activar la tabla para que los
datos estén disponibles. Seleccione la tabla y en la propiedad Active de la tabla seleccione
el valor True, ahora haga clic con el botón de la derecha del mouse encima del componente
QuickRep y seleccione la opción Preview del menú de acceso directo o bien llame la
ventana Report Settings y haga clic sobre el botón preview.
Campos de totales generales en el reporte
Los campos de totales se construyen en la banda de total (rbSummary), por lo tanto cada
vez que deseemos calcular totales en nuestro reporte debemos agregar una banda de este
tipo. El próximo paso a seguir es crear el campo de total. En la página Qreport de la paleta
de componente hay un componente llamado QRExpr. Este componente sirve para crear
campos calculados.

Bibliografía
 Joyanes, Luis: Borland Delphi Iniciación y Referencia, McGraw Hill,
México, 2da Edición,1998
 Cantú, Marco: Mastering Delphi 5, Sybex, San Francisco,3ra Edición,1999
 Calvert’s, Charlie: Delphi 4 Unleashed, Macmillan Publishing,USA,1ra

Edición, 1998
 Teixeira, Steve y Pacheco, Xavier: Delphi 5 Developer’s Guide, Macmillan

Publishing,USA, 3ra Edición,1999

ManualDElphi1 1 PDF

Cargado por

Información del documento

Descripción original:

Título original

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

ManualDElphi1 1 PDF

Cargado por

Copyright:

Formatos disponibles

Universidad del Caribe

INTRODUCCIÓN A DELPHI ........................................................................................... 8

Como Crear un Separador.............................................................................................67

MANEJO DE ERRORES EN DELPHI............................................................................94

Autor: José Uribe Página 4

USO DEL FORM WIZARD PARA CREAR APLICACIONES CON BASE DE

TRABAJANDO CON LOS CAMPOS DE LA TABLA................................................207

Autor: José Uribe Página 6

Al finalizar el modulo el estudiante estará en capacidad de identificar todos los

Autor: José Uribe Página 7

Autor: José Uribe Página 8

Delphi es un entorno de Programación visual orientado a objetos para desarrollo rápido de

 El compilador más rápido.

Existen tres versiones de Delphi: Estándar; Profesional y Enterprise.

Incluye la mayoría de las características que discutiremos en este curso. Actualmente, el

 Delphi IDE y el compilador (incluyendo un compilador de línea de comandos).

Autor: José Uribe Página 9

 Código fuente para la VCL

Incluye todo el software arriba mencionado las adiciones y mejoras siguientes:

 Menú de acceso directo

La ventana principal se encuentra ubicada en la parte superior de la pantalla y esta

Se encuentra ubicado en la parte superior de la ventana principal e inmediatamente debajo

File Para manejo de Archivos y Proyectos.

Autor: José Uribe Página 12

Barra de Acceso Directo

La paleta de componente se encuentra ubicada en la parte derecha de la ventana principal y

Autor: José Uribe Página 13

Menú de acceso directo

Autor: José Uribe Página 14

El inspector de objeto es una herramienta imprescindible en el desarrollo de las

Cada objeto incluido en un formulario y por consecuente en el proyecto esta representado o

Algunas propiedades, están representados por mas de un valor (subpropiedades del

El diseñador de formularios se encuentra ubicado debajo de la ventana principal en el

Autor: José Uribe Página 16

Autor: José Uribe Página 17

Configuración del ambiente de trabajo

El ambiente de trabajo de Delphi y todas sus herramientas son configurables. La mayoría

Autor: José Uribe Página 18

Autor: José Uribe Página 19

Autor: José Uribe Página 20

Resumen de los elementos del ambiente

Autor: José Uribe Página 21

Proyectos, Unidades y Formularios

Autor: José Uribe Página 22

Introducción a los proyectos

El proyecto es lo que se ejecuta (corre) y lo que se convierte en ejecutable (EXE) en

Un proyecto esta formado básicamente por unidades y formularios.

El archivo de unidad PAS es una colección de tipos de datos, declaraciones de variables y

Autor: José Uribe Página 23

 Todos los formularios en un proyecto en Delphi pertenecen a una unidad; la razón

 Las unidades no necesariamente deben estar asociadas a un formulario, la razón de

 En un proyecto en Delphi no puede haber un formulario con el mismo nombre que

 En un proyecto en Delphi no puede haber un formulario con el mismo nombre que

¿Qué ocurre cuando se graba un proyecto o una unidad en Delphi?

Anteriormente habíamos dicho que en un proyecto en Delphi no pueden repetirse los

Autor: José Uribe Página 24

Y por ultimo el nombre del formulario es sacado de la propiedad name ya que el

Autor: José Uribe Página 25

Opciones para manejo de archivos (File)

Autor: José Uribe Página 26

Opciones del proyecto

La página Forms de la ventana Project Options permite especificar algunas características