Enero

Tutorial Delphi - Primer programa 2004

Bienvenidos a este tutorial de Delphi, el entorno de desarrollo para Object Pascal de
la casa Borland. Durante las siguientes lecciones trataré de introducir al lector en este
entorno de desarrollo y posibilitarle dar sus primeros pasos en la programación en
Object Pascal según la filosofía de este excelente producto para desarrollo de
aplicaciones Windows.
Propósito del Tutorial.
A lo largo de mucho tiempo recibo correos de personas que quieren iniciarse en
Delphi pero se quejan de la falta de información para principiantes especialmente en
castellano (español), haciéndome eco de tales quejas he decidido afrontar el problema
por mi mismo y escribir este tutorial que está dirigido a los principiantes por lo que si
eres un usuario programador con alguna experiencia en Delphi no encontrarás nada que
no sepas ya, por el contrario si eres una de esas inquietas personas que desean comenzar
a programar usando Delphi estoy casi seguro que este es el tutorial para tí.
Durante el desarrollo de este tutorial aprenderás a identificar las diferentes partes del
entorno de desarrollo Delphi, me basaré en la versión que tengo en mi máquina la cual
es Delphi Enterprise versión 6.0 con Update 2.0 aunque también te será válido para las
versiones 5.0 y 7.0, si algo no te resulta en tu versión de Delphi, o tienes alguna
pregunta sobre este tutorial, o quieres comentarme algo no dudes de comunícarmelo.
Prerrequisitos.
En este tutorial asumo que el lector tiene alguna experiencia en programación en
general, no pretende ser un curso de programación sino introducirte en Delphi
exclusivamente, no es necesario que sepas Pascal (aunque es deseable) pues tocaré
algunas cosas básicas sobre este lenguaje; no explicaré por ejemplo qué es una variable
o qué es una sentencia así como tampoco pretende ser un curso sobre el uso de
Windows, asumo también que el lector sabe manejarse con soltura en este sistema
operativo y sabe reconocer qué es un menú descolgable o qué es un botón.
Convenciones usadas.
Para hacer más claras mis explicaciones usaré algunas convenciones que es necesario
recordar. Debido a que voy a utilizar fragmentos de código durante este tutorial y quizás
el lector quiera copiar y pegar en el editor de Delphi esos fragmentos los cuales estarán
con la tipografía Courier New que es la misma tipografía estandar que usa el editor
de código de Delphi.
Así mismo haré referencia a ciertas combinaciones de tecla que como se verá acelera
algunas funciones comunes durante la escritura, compilación, edición y ejecución de un
programa hecho en Delphi, usaré la notación conocida por todos, por ejemplo: Crtl+F9
indica que se debe presionar la tecla Control y mientras se mantiene presionada ésta,
presionar a su vez la tecla F9.
Índice.
• Introducción. (estas aquí ahora).
• Arranque de Delphi y vista general del IDE.
• Primer programa
• Estructura de un programa
• La VCL nuestra de cada día
Guía para usar este tutorial.
 El índice en el apartado anterior te lleva directamente a un tema en particular tratado
aquí, siempre puedes acceder a él haciendo click en el logo de Delphi que aparece en la
esquina superior izquierda de esta página o al pie de cada tema en el link "Regresar al
indice". Así mismo los links "Anterior" y "Siguiente" te llevan al tema anterior y
siguiente respectivamente al tema tratado en una página en particular.
Derechos de autor.
Este tutorial es de libre uso y copia, puedes hacer con él lo que quieras, copiarlo,
modificarlo, quitarle cosas o agregarle las tuyas propias siempre y cuando tengas la
deferencia de citarme como autor así como a este sito web el cual es el oficial del
mismo. Lo que no puedes hacer es lucrar con él y/o atribuirte la autoría del mismo. Así
también el autor deslinda toda responsabilidad por el uso, abuso o mal uso del mismo,
en otras palabras usa lo que aquí se dice bajo tu cuenta y riesgo.

Temas.
• El IDE.
• La Ventana de Menús y Herramientas.
• Ventana Inspector de Objeto.
• Ventana Editor de Código.
• Ventana Diseñador de Formulario.
• Cómo moverse en el IDE usando el teclado.
El IDE.
Para comenzar supondré que ya tienes instalado correctamente el Delphi, por lo que
deberías tener un icono en el escritorio de Windows parecido al que figura en la esquina
superior izquierda de esta página. Haciendo doble click en él se ejecutará el IDE de
Delphi, IDE significa Integrated Developement Environment, es decir, Entorno
Integrado de Desarrollo. Luego de la pantalla de bienvenida deberías tener algo muy
parecido a la figura que aparece a continuación.
 Fig. 1 - El Entorno Integrado de Desarrollo de Delphi 6.0.
Si en tu caso no es exactamente igual a la figura se debe a que el IDE puede ser
configurado según las preferencias del usuario del mismo pero siempre verás cuatro
ventanas principales. Si has programado en Visual Basic de Microsoft lo primero que te
resultará extraño es que puedes ver "através" del IDE, se debe a que el IDE del Delphi
tiene sus herramientas separadas en ventanas distintas, las cuales, como cualquier
ventana de Windows, pueden ser minimizadas, maximizadas y restauradas, dandole un
poco más de flexibilidad al entorno de desarrollo. Vamos a dar una ligera descripción a
cada parte del IDE señalando sus funciones. No te preocupes si no entiendes
exactamente para qué sirve, solo ten en mente que cada cosa descripta te será de suma
importancia cuando desarrolles tus propios programas. En definitiva, de ahora en más
esta será tu "casa", por lo que deberás saberte mover en ella con soltura.
La ventana de menús y herramientas.
En la siguiente figura se puede ver la ventana que está arriba de la pantalla, y que se
llama la ventana de menús y herramientas.
 Fig. 2 - Ventana de menús y barras de herramientas.
Como su nombre indica en esta ventana se encuentra la barra de menú principal del
IDE y una serie de barras de botones al estilo del Microsoft Office, al igual que sucede
en este programa cada barra puede ser movida de lugar y cambiar de tamaño para
ajustarde al resto del entorno, incluso pueden hacerse estas barra "flotantes" en ventanas
separadas, simplemente toma con el puntero del mouse cada barra en el lugar donde
aparece un doble separador a la izquierda de cada una.
Cada botón en las barras de herramientas se corresponden con una opción de la barra
de menú, no creo que a esta altura represente problema identificar algunos de estos
botones, excepto tal vez la barra de componentes, que es la gran barra que ocupa toda la
parte baja de la figura 2, está dividida en fichas, cada una con un título tal como
"Standard", "Additional", "Win32", etc..., esta barra es particularmente especial pues en
ella están los objetos visuales con los cuales programaremos, en el mundo Delphi estos
objetos se llamas "componentes", que pueden ser seleccionados individualmente para
luego ser soltado en la ventana de formulario. También aquí aparecerán los
componentes de terceros o los que crees tú mismo usando Delphi. Los que puedes ver
en el IDE de Delphi recientemente instalados son los componentes "de fabrica", pero
como ya he mencionado pueden agregarse más en el futuro. Hablaremos de la paleta de
componentes más adelante en este tutorial.
Debajo de esta ventana podemos ver otras tres.
Ventana Inspector de Objeto.
Esta ventana es la que se muestra en la figura a continuación:
 Fig. 3 - El Inspector de Objeto.
Se trata de la ventana Inspector de Objeto (Object Inspector en su barra de título), en
esta ventana se muestran las propiedades y los eventos expuestos por un objeto visual o
componente. En la parte de arriba, justo debajo de la barra de título de esta ventana,
puedes ver un combo descolgable, en él puedes seleccionar individualmente cada uno
de los componentes que están contenidos en el formulario de nuestro projecto de
aplicación, al seleccionar uno en el resto de la ventana se muestran las propiedades
correspondientes a ese componente en particular. Notarás también que hay dos fichas
con título "Properties" y "Events". La ficha Properties está separada en dos, a la
izquierda puedes ver el nombre de la propiedad, y a la derecha su valor que puedes
modificar. Luego en la ficha "Event", que también está separada en dos puedes ver a la
izquierda el nombre del evento al que responde el componente y a la derecha aparecerá
el procedimiento asociado a ese evento. No te preocupes si no entiendes esto ahora, lo
explicaré con más detalle más adelante.
Ventana Editor de Código.
Ocupando el espacio por debajo de la ventana de menús y herramientas, y a la
derecha de la ventana inspector de objeto puedes ver dos ventanas superpuestas, en la
figura 1 puedes ver que tiene el foco la ventana en cuya barra de título dice "Unit1.pas",
esta ventana se llama Editor de Código, la siguiente figura la muestra en detalle:
 Fig. 4 - Ventana Editor de Código.
Esta ventana está dividida en dos, a la izquierda puedes ver un panel que contiene
una estructura de arbol, el cual se llama "Code Explorer" o Explorador de Código, con
él puedes desplazarte a cada parte o sección del código Object Pascal que aparece a la
derecha de la ventana. La parte derecha de esta ventana no es más que un editor de texto
adaptado para escribir código Object Pascal. Al comenzar un projecto nuevo, tal como
puedes ver en la figura 4, el IDE de Delphi automáticamente genera un código esqueleto
para que el programador no tenga que escribirlo, este código esqueleto es lo mínimo
indispensable para que un programa Object Pascal asociado a un formulario Windows
funcione, luego tú, como programador, puedes modificarlo o agregarle cosas que le
darán la funcionalidad a dicho formulario.
Ventana Diseñador de Formulario.
Finalmente tenemos la cuarta ventana, es la ventana Diseñador de Formulario.
Cuando se comienza un nuevo proyecto Delphi esta ventana aparece vacia:
 Esta ventana parece no contener nada pero eso no es lo importante, lo importante que
la propia ventana es parte del proyecto Delphi, puedes redimencionarla, maximizarla,
minimizarla y restaurarla pero al hacerlo solo estarás modificando visualmente (en
tiempo de diseño) las propiedades de la ventana que resultará de ejecutar el programa
que estás creando. En cierta forma diseñar el aspecto visual de tu programa es
programar también. Si modificas el tamaño de esta ventana tomando con el mouse la
esquina inferior derecha y si tienes a la vista la ventana Inspector de Objeto (Object
Inspector) observa las propiedades Width y Height (Ancho y Alto respectivamente)
verás que sus valores a la derecha se modifican dinámicamente; así mismo, si modificas
manualmente esos valores en el Object Inspector verás que el tamaño de la ventana
Diseñador de Formulario se modifica también.
También puedes hacer esta prueba. Ubica la propiedad Left en el Object Inspector (las
propiedades están ordenadas alfabeticamente) y ve cambiando su valor en 10 en 10,
verás que la ventana Diseñador de Formulario se corre a la derecha o a la izquierda
conforme aumentas o disminuyes ese valor. Sucede que tanto el tamaño de una ventana
Windows (y el Diseñador de Formulario lo es) como su posición (Left significa
"izquierda") son propiedades de esa ventana. Aquí hemos introducido un concepto
básico y muy importante: los objetos visuales tienen propiedades visuales que pueden
ser modificadas por el programador.
Otra cosa que te resultará "extraña" en esta ventana es que está cubierta con pequeños
puntos en toda su superficie, esto tiene el doble propósito de servirte de guía cuando
sueltes otros objetos sobre ella y para indicar que esta ventana está en tiempo de diseño
y no en ejecusión, vale decir, no es un programa "andando" sino que es parte del IDE de
Delphi. Esos puntos no aparecen en el programa una vez ejecutado.
Cómo moverse en el IDE usando el teclado.
Cierto es que usar el mouse es una ventaja con respecto a los Sistemas Operativos de
"solo teclado", pero también es cierto que en algunos casos es más rápido y cómodo si
se pudiera llegar a alguna parte de la pantalla mediante el teclado. El IDE de Delphi no
es ajeno a esto, de hecho Delphi tiene infinidad de atajos de teclado para realizar toda
clase de acciones sin usar el mouse. Y lo primero que uno debe de aprender es cómo
moverse entre estas cuatro ventanas que acabamos de describir pues son las que más se
usan durante el desarrollo de una aplicación visual Windows. Estos atajos son:
• F10: Trae al frente o pone en foco la Ventana de Menús y Barras de
Heramientas.
• F11: Rota entre las ventanas Inspector de Objeto, Diseñador de Formulario y
Editor de Código.
• F12: Rota entre las ventanas Diseñador de Formulario y Editor de Código.
Estas dos últimas teclas, F11 y F12, son las que usarás más a menudo, practica con
ellas para que te acostumbres a los efectos que produce.
En el siguiente capítulo de este tutorial haremos nuestro primer programa y
explicaremos en qué consiste un projecto Delphi y cual es la filosofía detrás de la
programación para Windows.

Temas.
• Diseñando el formulario.
• Eventos.
• Compilación.
• ¿Qué ha ocurrido realmente?
• Los archivos de un proyecto Delphi.
Diseñando el formulario.
Pongamonos manos a la obra y hagamos nuestro primer programa en Delphi. Es una
vieja costumbre en el mundo de la programación hacer, como primer programa uno que
muestre un mensaje que diga "Hola Mundo!" y así lo haremos nosotros.
Lo que haremos será traer al frente el Diseñador de Formulario (usa F12), luego en
la paleta de componentes que está en la Ventana de menús y herramientas que había
comentado en el capítulo anterior nos aseguraremos que la paleta visible es la
"Standard", luego seleccionaremos con un click el botón cuyo ícono es a su vez un
pequeño botón que dice "Ok", ese componente se llama Button, como lo indica la
pequeña ayuda emergente (hint) de color amarillo que aparece al apoyar el puntero del
mouse encima de él. Una vez seleccionado este componente de la paleta, haremos un
click en cualquier lugar de la ventana Diseñador de Formulario. Los pasos están
indicados en la siguiente figura:
 Fig. 1 - Soltando un componente desde la paleta de componentes.
1. Nos aseguramos que la paleta de componentes activa sea la "Standard".
2. Seleccionamos el "Button".
3. Hacemos click en el Diseñador de Formulario.
Cuando terminemos de hacer esto tendremos un Button en nuestro formulario tal y
como aparece en la imágen. Verás que este componente no es más que uno de esos
botones de Windows que estamos tan acostumbrados a ver en casi todos los programas
que usamos. Los pequeños cuadritos negros en las esquinas, a la derecha, izquierda,
arriba y abajo sirven para redimensionar el botón con el mouse, también podemos
moverlo de lugar con el mouse arrastrandolo y soltandolo. Verás que el funcionamiento
del Diseñador de Formulario es muy parecido a un programa de dibujo solo que aquí
estás "dibujando" componentes comunes de Windows. Los usuarios acostumbrados a
Visual Basic notarán algunas diferencias de comportamiento en este diseñador, a
diferencia de VB en Delphi no es necesario desplazar el mouse para indicar el tamaño
por omisión de un botón (lo mismo sucede con el resto de los componentes) pues
Delphi ya tiene unas medidas por omisión de los mismos. Igualmente, como había
señalado en el capítulo anterior con respecto al formulario en sí, si observas el Inspector
de Objetos verás las propiedades de este botón, si no es así selecciona el componente
"Button1 TButton" desde el combo descolgable en la parte alta de la ventana Object
Inspector o simplemente vuelve a seleccionar el botón en el Diseñador de Formulario
haciendo un click en él. Puedes modificar los valores de las propiedades Width y
Height (Ancho y Alto respectivamente) para hacer un "ajuste fino" de esas
dimensiones, también puedes modificar los valores de Left y Top (Izquierda, Arriba)
para mover el botón de lugar, esas cuatro propiedades están expresadas en pixels de
pantalla. Las propiedades Left y Top son relativas a la esquina superior izquierda del
formulario (a su vez esas mismas propiedades del formulario son relativas a la misma
esquina pero de la pantalla).
Eventos.
 Cuando un usuario hace click en un botón de Windows sucede algo ¿cierto?, pues
bién. También puedes verlo de esta manera, cuando el botón recibe un click reacciona
ejecutando una acción determinada. A esto en programación bajo Windows se le
denomina evento. Los eventos pueden ocurrir en cualquier momento y pueden ser
provocados tanto por el usuario del sistema operativo (por ejemplo cuando se hace click
en algún objeto tal como un botón) como por dispositivos conectados a la computadora
(un modem cuando arriban datos) o por el propio sistema operativo (cada vez que el
reloj de la computadora cambia de segundo se produce un evento), esto significa que el
sistema operativo, y las aplicaciones ejecutandose sobre él, no tienen linealidad, es
decir, no siguen un orden estricto y predeterminado que guian al usuario a través de un
plan preestablecido, sino que en cualquier momento se pueden ejecutar cuaquier clase
de acciones. Los lenguajes diseñados para el sistema operativo Windows deben ser
concientes de esto, por eso se definen como lenguajes de programación conducidos por
eventos, porque tienen la habilidad de responder a esos eventos según vayan
manifestándose, en contraposición de los lenguajes llamados lineales como aquellos
usados con el sistema operativo DOS. Nosotros como programadores debemos
ajustarnos a este paradigma y Delphi nos facilita lograrlo.
Nuestra responsabilidad es programar lo que sucederá cuando un evento ocurra, en
nuestro programa haremos lo siguente: cuando el evento de hacer click en el botón que
acabamos de soltar en el formulario ocurra, le mostraremos al usuario de nuestro
programa un mensaje que diga "Hola Mundo!". Pon atención a la ventana Object
Inspector, selecciona el button que acabamos de soltar en el formulario, cámbiate a la
paleta "Events" en el inspector de objetos, deberías ver algo como esto:

Fig. 2 - El Inspector de Objetos mostrando los eventos a los que responde un Button.
A la derecha se muestran los eventos a los cuales el button es capaz de responder, no
es necesario escribir código para todos ellos, si no hay código ejecutable asociado a un
evento en particular pues simplemente el button no hará nada cuando ese evento ocurra.
En Delphi los eventos se identifican precedidos con la silaba "On", así, el evento que
nos interesa es el Click, o sea OnClick. Verás que a la derecha de OnClick no aparece
nada, esto es así porque aún no hemos asociado ningún código a ese evento pero lo
haremos ahora mismo: haz doble click en la parte en blanco a la derecha de OnClick en
el inspector de objetos, inmediatamente verás que ocurren dos cosas. La primera, el
Editor de Código viene al frente mostrandonos una porción de código tal como ésta:
view source

print?
1.procedure TForm1.Button1Click(Sender: TObject);
2.begin
3.
4.end;
La segunda cosa es que en el lugar que antes estaba vacío en el Inspector de Objeto
ahora aparece lo siguiente: Button1Click.
Lo que ha ocurrido es que hemos asociado el procedimiento TForm1.Button1Click al
evento OnClick del button que habíamos soltado en el formulario. Esto significa que
cuando se haga click en el botón (es decir, ocurra el evento de pulsar el botón izquierdo
del mouse encima del botón) se ejecutará todo lo que escribamos entre las palabras
begin y end; debajo del procedimiento TForm1.Button1Click. Begin significa
"comenzar" y end significa "fin". ¿Pero qué es lo que escribiremos para lograr mostrar
un mensaje tal y como nos habíamos propuesto al principio?
Trae al frente el Editor de Código si no lo tienes ya y luego escribe entre las palabras
Begin y End lo siguiente:
ShowMessage('Hola Mundo!');
De modo que al final te debe quedar algo así:
view source

print?
1.procedure TForm1.Button1Click(Sender: TObject);
2.begin
3. ShowMessage('Hola Mundo!');
4.end;
ShowMessage significa "Mostrar mensaje", ¿cuál mensaje?, el que está entre los
parentesis a continuación y encerrado entre comillas simples. Los que tengan
experiencia en programación no verán nada nuevo con esto.
Nada más por ahora, solo resta probar nuestra "obra de arte" :).
Compilación.
Object Pascal es un lenguaje compilado, esto significa que hay un programa que lee
el texto del código fuente, lo reconoce como código Object Pascal y lo procesa de forma
tal hasta obtener código ejecutable del mismo, vale decir un archivo .exe.
Delphi logra esto al presionar nosotros la tecla F9. Con F9 también se ejecuta el
programa luego de ser compilado exitósamente. Y cuando digo exitósamente quiero
decir que el programa no contiene errores de sintaxis. Presiona F9 ahora y verás
ejecutarse tu primer programa hecho en Delphi, la primera vez que lo hagas el IDE te
pedirá guardar dos archivos, Unit1.pas y Project1.dpr, acepta estos nombres por el
momento:
 Fig. 3 - Ejecución de Hola Mundo!
En la figura 3 podemos ver la ejecución de nuestro programa Hola Mundo!, haz click
en el botón que tiene por título (para hablar con propiedad, se llama Caption del
Button) "Button1", y verás algo como esto:

Fig. 4 - Efecto de ShowMessage.

Ese es el efecto que tiene al ejecutarse la línea ShowMessage.
Para terminar el programa haz click en el botón X en la esquina superior derecha o
bién presiona Alt+F4, ¡vámos, como se cierra cualquier programa de Windows! :). Esto
nos regresará al IDE de Delphi.
Seguramente muchas preguntas te han asaltado ya, por ejemplo que el botón tenga
por título, Caption es el nombre de ello, diga "Button1" no es bonito. Ningún problema,
selecciona el Button en el Diseñador de Formulario, o bién desde el combo descolgable
en el Inspector de Objeto y busca la propiedad Caption (en la paleta "Properties") y
reemplaza su valor al que desees aparezca como título en el botón. También querrás
hacer otro tanto con el Caption del propio formulario, solo tienes que seleccionar Form1
en el combo descolgable en el Inspector de Objeto o bién haciendo click en cualquier
parte del Diseñador de Formulario que no esté ocupado por el propio botón.
¿Qué ha ocurrido realmente?
También te preguntarás cómo sabe nuestro programa qué parte de nuestro código
ejecutar y hasta dónde. O peor aún, cómo sabe Windows que el usuario hizo click en
nuestro botón y no en otra parte. En lo más profundo de Windows existe un programa
que está continuamente ejecutandose, aunque en apariencia la computadora no hace
nada, este pequeño demonio está totalmente abocado a la tarea de "pezcar" eventos,
rastreando todos los posibles productores de eventos, como ser el propio mouse, el
teclado, el reloj interno de la computadora, la placa de red, incluso otros programas
ejecutándose sobre el sistema operativo, etc..., cuando detecta un evento lo anota en una
cola, llamada la cola de mensajes de Windows, donde marchan en fila india, por decirlo
de alguna manera, todos los mensajes que puede recolectar junto con sus respectivos
parámetros. En el caso del click con el mouse, este programa genera un mensaje
especial (WM_LBUTTONDOWN) cuyo parámetro es la posición del mouse en la
pantalla, este mensaje es recogido por otro programa del sistema operativo que lo saca
de la cola y se lo entrega al objeto que está en la posición indicada en la pantalla:
nuestro botón. Si este objeto es capaz de entender el mensaje y procesarlo, es decir,
tiene algo qué hacer cuando le llega este mensaje, ejecuta ese código, si no tiene código
asociado para ese mensaje no hace nada. Como había mencionado antes, cuando dimos
doble click en el evento OnClick del Button lo que hicimos fue indicarle al button que
cuando le llegue el mensaje Click ejecute el procedimiento TForm1.Button1Click,
desde begin hasta end.
Pero hay más que eso en nuestro programa. Por ejemplo cuando se cierra nuestra
aplicación al hacer click en el botón de la esquina superior derecha (el de la X) también
se genera un evento ¿dónde está el código que se ejecuta como resultado de este?.
Nosotros no lo hemos escrito, lo ha hecho Delphi por nosotros. Mas aún, aunque si
miras todo el código que hay en el Editor de Código incluyendo el que el propio Delphi
ya ha puesto ahí (el código esqueleto) no es nada comparado con el código ejecutable
que finalmente va a parar al archivo ejecutable .exe. Por ejemplo, no es necesario que
nosotros modifiquemos manualmente (esto significa, escribir código específico para la
ocasión) las propiedades Left y Top para posibilitarle al usuario mover por toda la
pantalla nuestra ventana arrastrándola por su barra de título. Eso ya lo ha hecho Delphi
sin que nosotros se lo digamos (aunque este comportamiento también puede ser
controlado como veremos más adelante). En resumen, el beneficio de contar con un IDE
es quitarle al programador el trabajo pesado y dejarle las cosas listas para que se
concentre únicamente en lo que es relevante para la aplicación. Es decir que el
programador sea el responsable de programar aquellos eventos que le interesan y que
servirán para disparar la funcionalidad de la aplicación que le interesa, como en nuestro
ejemplo, lo que nos interesa es que algo ocurra cuando el usuario hace click en el botón
que le hemos puesto.
Los archivos de un proyecto Delphi.
Ahora es importante señalar cuales son los archivos que Delphi genera cuando
creamos un proyecto Delphi. Por si no te has dado cuenta un proyecto Delphi equivale a
una aplicación Windows, nuestra aplicación "Hola Mundo!" que acabamos de hacer es
una aplicación. Es importante señalar cuál es la diferencia entre "programa" y
"aplicación". Un programa es una unidad de código que puede o no depender de otros
programas de una misma aplicación, mientras que una aplicación es el conjunto de
programas que cooperan entre sí para lograr un comentido. Por supuesto, nuestra
aplicación "Hola Mundo!" es sumamente sencilla pues solo cuenta con un programa.
Ahora bién, Delphi separa cada programa en un archivo .pas (por pascal) y sabe qué
programas conforma un proyecto a partir de un archivo con extensión .dpr (por Delphi
Project). Si usas el Explorador de Windows y te diriges a la carpeta "Archivos de
Programa\Borland\Delphi\Projects" verás que allí se encuentran dos archivos con
nombres Unit1.pas y Project1.dpr que es el único programa que hemos escrito y el
correspondiente archivo de proyecto. Ambos archivos son archivos de texto ASCII, si
editas el archivo .pas verás que es lo mismo que se vé desde el Editor de Código. El
archivo .dpr también es un archivo de texto y también contiene código editable por
nosotros, incluso puedes editarlo con el IDE de Delphi aunque no lo muestre por
omisión, para hacerlo selecciona el menú "Project" de la barra de menú y luego "View
Source" como se muestra en la siguiente figura:
 Fig. 5 - El menú Project.
Y en la ventana Editor de Código verás el código fuente del proyecto:
view source

print?
01.program Project1;
02.uses
03. Forms,
04. Unit1 in 'Unit1.pas' {Form1}
05.
06.{$R *.res}
07.
08.begin
09. Application.Initialize;
10. Application.CreateForm(TForm1, Form1);
11. Application.Run;
12.end.
Casi nunca es necesario hacer modificaciones en este código pero luego veremos que
en ciertas ocasiones nos es muy útil echarle una mirada y meterle un poco la mano, por
el momento solo debes saber que el IDE de Delphi se encarga automáticamente de
escribir en él lo que haga falta.
Al mostrar el fuente del archivo .dpr verás que el Editor de Código ha agregado una
paleta más a su ventana:
 Fig. 6 - Paletas del Editor de Código.
El título de cada paleta se corresponde con el nombre del archivo que está
visualizando, puedes cambiar de paleta haciendo click en la que prefieras o bién
presionando las teclas Ctrl+Tab. También si haces click derecho en una de las paletas
aparecerá un menú contextual, una de las opciones es "Close" para cerrar esa paleta en
particular.
Pero estos dos archivos no son los únicos que forman un proyecto Delphi, existe otro
archivo más que es importante. Cuando un programa tiene una ventana asociada, y
nuestro programa lo tiene, Delphi almacena los datos de inicialización de esa ventana en
el archivo con el mismo nombre que el programa (en nuestro caso Unit1) y extención
.dfm (por Delphi Form), este archivo a partir de la versión 5.0 de Delphi está en texto
ASCII (antes era binario), en él, si lo editas con el block de notas (notepad) verás que se
parece mucho a los datos que se ven en el Inspector de Objeto. En este archivo están
almacenados los valores en tiempo de diseño del formulario y todos los objetos
contenidos en él; en nuestro caso serán los datos del formulario y de su único botón.
Resumiendo, los archivos que componen un projecto Delphi son:
• .dpr: es el archivo de proyecto el cual agrupa todos los programas que lo
componen.
• .pas: son los archivos donde está el código fuente de cada programa.
• .dfm: son los que almacenan los datos de los objetos visuales (y no visuales) en
tiempo de diseño para aquellos programas que tienen una ventana (formulario)
asociada.
Si estás observando la carpeta "Projects" en el Explorador de Windows notarás que
hay más archivos que estos tres. Esos archivos no son importantes y se generan cuando
se compila un proyecto. Ellos son:
Los que en su extensión están precedidos por el caracter circunflejo (~) son copias de
respaldo creadas automáticamente al momento de compilar y/o ejecutar un programa, es
decir contienen una versión anterior de los programas y el archivo de projecto. Suelen
ser útiles en ciertos casos en los que "metemos la pata".
Los .dcu (Delphi Compiled Unit) son una versión precompilada de los archivos .pas,
están en binario y no son editables. Suelen servir para distribuir una versión funcional
pero no editable de los archivos .pas.
El archivo <nombre de proyecto>.cfg contiene información de cómo estaba
configurado el compilador interno del IDE para ese proyecto en particular.
El archivo <nombre de proyecto>.dsk contiene la configuración del IDE para ese
proyecto en particular.
Finalmentes puedes encontrar <nombre de proyecto>.exe que no es más ni menos
que nuestra aplicación lista para ser ejecutada como si fuera una aplicación más de
Windows.
 Pero solo los tres primeros son los que nos interesan a nosotros y son los que
deberías entregar a una tercera persona que quiera compilar él mismo un proyecto que
hemos realizado.
En el próximo capítulo de este tutorial nos concentraremos de lleno en el lenguaje
Object Pascal según la implementación de Delphi.

Temas.
• Estructura del código fuente
• Estructura de una unidad Pascal
• Exportando variables, tipos, procedimientos y funciones.
• Llamada circular y conflicto de identificadores.
Estructura del código fuente.
En Pascal existen dos tipos de código fuente: el programa principal, que en nuestro
caso es el que se almacena en el archivo .dpr y que a su vez toma el nombre del
ejecutable que estamos creando; y luego tenemos los programas de biblioteca[1] que son
anexos al programa principal, que Delphi los nombra con la extensión .pas. Estos
últimos no son impresindibles, quiero decir, puede existir un .dpr que no tenga .pas
asociados. En efecto, con Delphi es posible crear ejecutables Windows que no tengan
ninguna ventana asociada, o sea que simplemente trabajen con la interface de línea de
comandos (el famoso Simbolo de Sistema).
Para el caso de los .dpr la estructura interna de su código fuente es como sigue:
Todos comienzan con la palabra reservada program seguida del nombre del
programa, aunque no es obligatoria conviene usarla para tener un control de qué
programa se trata.
A continuación tenemos la palabra reservada uses luego de la cual se listan los
nombres de los programas de biblioteca .pas, si no vamos a usar ninguna no es
necesario usar esta cláusula aunque como veremos más adelante es extremadamente
raro que presidamos de, al menos, una biblioteca.
Le sigue la palabra reservada const luego de la cual se declaran las constantes
absolutas del programa, no es obligaroria
Luego tenemos la cláusula type, donde se declaran los tipos definidos por el usuario,
tampoco es obligatoria.
A continuación la cláusula var luego de la cual se declaran las variables globales, es
decir, las que son visibles a todo el programa.
Luego se declaran los procedimientos (procedure) y funciones (function) en el
orden que se deseen.
Finalmente tenemos el bloque del programa principal comenzando por la palabra
reservada begin y terminado con la palabra reservada end. (presta atención al punto).
Ambos son obligatorios.
Entonces la estructura general es:
view source

print?
01.program nombre_del_programa;
02.uses Unit1, Unit2, Unit3... etc...
03.
04.const
05.
06.type
07.
08.var
09.
10.procedure ejemplo1;
11.begin
12.
13.end;
14.
15.function ejemplo2: tipo_de_retorno;
16.begin
17.
18.end;
19.
20.begin
21.{ desarrollo del programa }
22.end.
Tomemos por ejemplo nuestro .dpr de la aplicación Hola Mundo! visto en el capítulo
anterior de este tutorial, el cual es este:
view source

print?
01.program Project1;
02.uses
03. Forms,
04. Unit1 in 'Unit1.pas' {Form1};
05.{$R *.res}
06.begin
07. Application.Initialize;
08. Application.CreateForm(TForm1, Form1);
09. Application.Run;
10.end.
Como verás aquí faltan algunas de las cláusulas enumeradas antes pero eso es
perfectamente válido pues no todas son obligatorias, lo que aquí vemos es lo mínimo
necesario para formar una aplicación Windows de una sola ventana.
Hay varias cosas para explicar. Primero salta a la vista la presencia de la declaración
Forms en la cláusula uses, Forms es una biblioteca que ya está predefinida en Delphi
por lo que no tiene un .pas correspondiente en la carpeta de nuestro proyecto (en
realidad el código fuente de la unidad Forms reside en otro lugar que está compartido a
todos los proyectos creados con Delphi), luego tenemos esto: Unit1 in 'Unit1.pas'
{Form1}; Unit1 no es más que el .pas que hemos modificado pero en este caso Delphi
aclara que es el que está en Unit1.pas en la carpeta actual, lo que sigue entre llaves es un
comentario que agrega el IDE de Delphi para hacernos saber que en esa unidad reside la
declaración de la ventana Form1.
 Luego notarás este comentario entre llaves {$R *.res} este no es un comentario
normal, es una directiva de compilación como se denota por la combinación de los
caracteres {$ seguida de una letra, en este caso la R, esta directiva de compilación le
indica al compilador que tome en cuenta un archivo .res, los archivos .res se usan para
almacenar recursos visuales o de audio para nuestra aplicación que luego copiará dentro
del .exe final. En nuestro ejemplo no usamos ninguna de estas cosas, no hemos creado
ningún archivo de recursos explícitamente, el IDE de Delphi lo ha hecho por nosotros
(aunque podemos modificarlo para agregarle cosas este tema no será tratado en este
tutorial), específicamente allí ha almacenado el ícono por omisión de nuestra aplicación.
Más adelante explicaré cómo cambiar el ícono por omisión. En la directiva de
compilación está indicado *.res, ese asterico no significa lo que normalmente significa
en Windows (es decir "todos los archivos .res") sino que quiere decir que el archivo de
recursos tiene el mismo nombre que el .dpr; ¿por qué no poner el mismo nombre
entonces?, porque si cambiamos el nombre al .dpr externamente o cuando salvamos el
proyecto desde el IDE, deberíamos tomarnos la molestia de cambiar el mismo en la
directiva de compilación.
Ahora concentrémonos en lo que está entre begin y end. del .dpr
El objeto Application es un objeto predefinido en todos los programas Delphi el
cual hace referencia a la propia aplicación (nuestro programa Hola Mundo!), el método
Initialize le indica al compilador que allí deben ejecutarse todos los procedimientos de
inicialización requeridos por Windows para una aplicación. Luego sigue la llamada a la
creación de la ventana, nuestra ventana. Y luego el método Run es la indicación de que
debe ponerse en espera de eventos, lo que en Windows equivale a que la aplicación se
está ejecutando. Estos tres pasos son los mínimos requeridos para una aplicación de al
menos una ventana.
Si tenemos más de una ventana en nuestra aplicación, el IDE de Delphi agregará una
llamada Application.CreateForm(); por cada una de ellas, pero es importante recordar
que la primera llamada a CreateForm establece que esa ventana es la principal de la
aplicación, esto significa que cuando se cierra (con Alt+F4 o haciendo click en el botón
X de la esquina superior derecha) la ventana principal, se abandona el método Run y
concluye la aplicación.
La estructura de una unidad Pascal.
Pasemos ahora al código fuente de las bibliotecas, desde ahora las llamaré unidades.
La estructura general es como sigue:
view source

print?
01.unit Unit1;
02.
03.interface
04.uses { Lista de unidades }
05.type
06. { Lista de tipos definidos por el usuario }
07.
08.{ Luego encabezado de los procedimientos y funciones visibles desde
afuera }
09.
10.var
11.{ variables visibles desde afuera }
12.implementation
13.uses { lista de unidades usadas localmente }
14.var
15.{ variables visibles solo localmente }
16.
17.{ Luego implementación de los procedimientos y funciones declaradas
en interface más otras }
18.
19.initialization
20. { código de inicialización }
21.finalization
22. { código de finalización }
23.end.
Igual que en el caso de los .dpr no todas las cláusulas son obligatorias, en especial
initialization y finalization que sirve para colocar código que se ejecutará antes de que
se cargue la unidad y luego cuando esta termine de usarse.
Las que sí son obligatorias son unit seguido del nombre de la unidad que DEBE SER
IGUAL AL NOMBRE FÍSICO DEL ARCHIVO .pas, interface, implementation y end.
El resto de las cláusulas no son obligatorias.
Como verás una unidad tiene sus propias cláusulas uses, esto significa que una
unidad puede usar a su vez otras unidades, ya sean predefinidas por Delphi o hechas por
nosotros.
Todo lo que está declarado a continuación de la cláusulas interface hasta
implementation es lo que puede "verse" desde otras partes de la aplicación. Para
entender esto veamos el código fuente de la unidad Unit1 de nuestra aplicación Hola
Mundo1! del capítulo anterior la cual, con nuestras reformas incluidas, debería verse
más o menos así:
view source

print?
01.unit Unit1;
02.interface
03.uses
04. Windows, Messages, SysUtils, Variants, Classes, Graphics,
Controls, Forms,
05. Dialogs, StdCtrls;
06.type
07. TForm1 = class(TForm)
08. Button1: TButton;
09. procedure Button1Click(Sender: TObject);
10. private>
11. { Private declarations }
12. public
13. { Public declarations }
14. end
15.var
16. Form1: TForm1;
17.implementation
18.{$R *.dfm}
19.procedure TForm1.Button1Click(Sender: TObject);
20.begin
21. ShowMessage('Hola Mundo!');
22.end;
23.end.
Lo que haremos será mover las dos líneas "var Form1: TForm1" y ponerlas justo
debajo de la palabra reservada implementation, de modo que esa parte del código
quede como sigue:
view source

print?
1.implementation
2.var
3. Form1: TForm1;
4.{$R *.dfm}
Ahora compilaremos de nuevo el programa, pero solo lo compilaremos sin
ejecutarlo, esto se consigue presionando las teclas Ctrl+F9. Inmediatamente
obtendermos un error de compilación, la siguiente figura lo muestra:

Fig. 1 - Error de compilación.

El IDE de Delphi nos trae en la ventana Editor de Código el código de nuestro .dpr
resaltando la línea donde encontró el error y debajo aparece una nueva ventana con el
mensaje de error, el cual es: [Error] Project1.dpr(11): Undeclared identifier: 'Form1', el cual
quiere decir que la variable Form1 no está declarada o no está visible para el .dpr al
compilar la línea 11 ¿por qué?, porque en la unidad Unit1 nosotros dejamos de hacer
visible desde fuera de la unidad la variable Form1. Para reparar esto solo es necesario
volver a hacer visible esa variable trayéndola de nuevo a la sección interface de la
unidad Unit1. Restaura las lineas que movimos a su lugar y vuelve a compilar el
proyecto con Ctrl+F9.
Esto me lleva a decir que las unidades Pascal sirven para no redundar código, es
decir, no declarar más de una vez una misma variable o procedimiento, el uso de las
unidades sirve para concentrar el código en común a toda la aplicación en un solo
código fuente, bastando solamente compartir lo que nos interesa que sea visible desde
otros lugares de la aplicación. Pero también para hacer uso de ella es necesario agregar
el nombre de la unidad donde reside tal declaración a la cláusula uses de la unidad
donde se necesite.
 Esto último es evidente tanto en el .dpr de nuestro proyecto como en la propia unidad
Unit1. Si miras ambas cláusulas uses verás que están listadas un montón de unidades,
en especial la cláusula uses de la unidad Unit1 contiene 10 llamadas a unidades
externas, ninguna de las cuales las hemos hecho nosotros mismos sino que están
predefinidas por Delphi. Esas unidades se llaman unidades estandar, en ellas están,
entre otras cosas, declarado el procedimiento ShowMessage que usamos en el evento
OnClick del Button, concretamente en la unidad Dialogs. Podemos hacer este
experimento. Encierra con llaves a modo de comentario la llamada a Dialogs en la lista
de uses de la unidad Unit1 de modo que toda la declaración quede asi:
view source

print?
1.uses
2. Windows, Messages, SysUtils, Variants, Classes, Graphics,
Controls, Forms,
3. { Dialogs, } StdCtrls;
Compila con Ctrl+F9 y verás que obtienes un error en la llamada a ShowMessage,
esto se debe a casi lo opuesto del error que vimos antes, aquí lo que el compilador no
encuentra es dónde está declarado el procedimiento ShowMessage entonces asume,
como en el caso anterior que se trata de un identificador desconocido.
Exportando variables, tipos, procedimientos y funciones.
Los usos de las unidades de biblioteca (units) de Pascal sirven para hacer visibles
variables globales, tipos definidos por el usuario, procedimientos y funciones. Me voy a
concentrar en estos dos últimos ya que me parece que el tema de las variables globales
quedará más claro de esta forma mientras que de los tipos nos ocuparemos más adelante
en este tutorial.
Los procedimientos son pequeños algoritmos dentro del gran algoritmo que es una
unidad Pascal. Es la implementación de la filosofía de programación top-down, también
llamada programación descendente en donde el problema mayor se divide en problemas
menores que se resuelven por separado. Cada procedimiento o función es un programa
en sí mismo, más o menos independiente del resto y que a su vez puede llamar a otros
procedimientos y funciones dentro de la misma unidad o en otra unidad como ya hemos
visto.
La estructura general de un procedimiento Pascal es como sigue:
view source

print?
1.procedure Nombre_del_procedimiento(parametro: tipo);
2.const { lista de constantes }
3.
4.var { lista de variables locales al procedimiento }
5.
6.begin
7.{ desarrollo del procedimiento }
8.end;
Como verás se parece bastante al código que está en el .dpr. Solo son obligatorias las
palabras reservadas procedure, begin y end, var y const se usan solo si se necesitan.
 En el caso de usar var la declaración de variables solo tienen ámbito en ese
procedimiento, es decir, esas variables son de caracter local al procedimiento. Pueden
ser de un tipo declarado en la type de la unidad. Los procedimientos pueden hacer uso
de otros procedimientos dentro de la misma unidad o los que estén exportados en las
unidades de la cláusula uses de esa unidad. La única forma de comunicar resultados
fuera del procedimieto es atravez de sus parámetros o bién mediante el uso de variables
globales pero esto no es recomendable como veremos más adelante.
La declaración general de una función es como sigue:
view source

print?
1.function Nombre_de_la_funcion(parametro: tipo): tipo;
2.const { lista de constantes }
3.
4.var { lista de variables locales a la función }
5.
6.begin
7.{ desarrollo de la función }
8.end;
Es muy parecida la procedure pero difiere en su comportamiento, las functions
SIEMPRE devuelven un valor que será del tipo indicado al final de su encabezado. En
Object Pascal (y por ende en Delphi) todas las functions tienen una variable
implícitamente definida llamada Result que sirve para enviar el valor de retorno al lugar
desde donde es llamada la función. En algun lugar dentro de begin ... end esta variable
se le debe asignar un valor y puede ser usado como si fuera una variable local más.
Veremos con más detalles algunos aspectos particulares de los procedimientos y
funciones más adelante en este tutorial.
Llamada circular y conflicto de identificadores.
Hay algunos problemas que debemos evitar, uno de ellos es las llamadas circulares
entre unidades. Supongamos que hemos escrito una unidad con nombre A y otra unidad
llamada B, y en la cláusula uses de la unidad A hacemos referencia a la unidad B pues
nos interesa usar sus variables, tipos o procedimientos visibles en su cláusula interface,
pero también en la unidad B nos interesa usar un procedimiento que es visible (está en
la cláusula interface) en la unidad A. O sea, A llama a B y B llama a A, esto es una
llamada circular lo cual es un error y el compilador se quejará ¿por qué?, porque el
compilador cuando hace su trabajo comienza a compilar primero las unidades que están
listadas en la cláusula uses del .dpr en el mismo orden en el que están listadas, allí
encontrará primero la unidad A que procede a compilar encontrándose en su cláusula
uses una llamada a la unidad B la cual procede a compilar pero allí encuentra una
llamada a A que todavía no ha terminado de compilar pues apenas va por su cláusula
uses por lo que no puede determinar cuál es el contenido completo de esa unidad y así
ponerla disponible para la unidad B. ¿Cómo se soluciona esto?. Recurriendo a la
cláusula uses que está en la implementation en una de las dos unidades, en nuestro
hipotético ejemplo nos conviene quitar la llamada a A en la unidad B de su cláusula
uses en la interfase y declararla en la uses de su implementation, de forma tal que el
compilador no se vea forzado a compilar la unidad A antes que a la B.
El segundo problema que podemos encontrar es el conflicto de identificadores. El
escenario es el siguente, supongamos que tenemos tres unidades A, B, C. A necesita de
B y de C pero tanto B como C comparten al resto de la aplicación un procedimiento que
se llama igual en ambas unidades, por ejemplo EsMayor(); cuando en A hagamos uso
de ese procedimiento al estar declarado con el mismo identificador el compilador no
sabrá a cuál de los dos estamos haciendo referencia lo que resultará en un error. Para
solucionar esto en la llamada en A debemos calificar la llamada con el siguiente
formato:
view source

print?
1.B.EsMayor(par1, par2); // aquí estoy usando el procedimiento en B
2.C.EsMayor(par1, par2); // y aquí el que está en C
De esta forma no hay ambigüedades.
Temas.
• La biblioteca de componentes visuales.
• Los componentes más comunmente usados.
○ Label (TLabel).
○ Edit (TEdit).
○ Memo (TMemo).
○ BitButton (TBitBtn).
○ SpeedButton (TSpeedButton).
○ Image (TImage).
○ Timer (TTimer).
• Un cronómetro sencillo.
• En resumen.
La biblioteca de componentes visuales.
Hasta ahora hemos visto más o menos cómo está organizada una aplicación Object
Pascal y cómo administra esto el IDE de Delphi. Pero no es todo lo que hay para saber
acerca de esta herramienta de programación. Quizás lo mejor de Delphi, el gran acierto
de Borland al proporcionarnos esta herramienta sea la VCL. VCL son las iniciales en
inglés de Visual Components Library, o sea, la Biblioteca de Componentes Visuales. Se
trata de un conjunto de bibliotecas (units) donde están declarados todos los tipos,
procedimientos y funciones estandar de Windows en lenguaje Object Pascal pero,
además, contienen las especificaciones de los componentes más comunes de Windows
tal como botones, cajas de listas, combos descolgables, etiquetas visuales y formularios
(ventanas). Si bién esto último es muy útil la VCL tiene la propiedad de expandirse para
adoptar nuevos componentes visuales hechos por terceros programadores y aquí es
donde reside la utilidad final de la VCL. En Internet se encuentran cientos sino miles de
componentes hechos especialmente para Delphi usando las herramientas de Delphi que
pueden agregarse a la VCL de nuestra copia de Delphi y usarse como si fuera un
componente más de los que ya trae Delphi "de fábrica".
Para comenzar a explorar la paleta de componentes VCL de Delphi crearemos un
nuevo proyecto. Haciendo click en el menú "File", luego "New", luego "Application",
guardaremos los cambios en el proyecto anterior si lo tenías abierto. Entonces tenemos
un nuevo proyecto en blanco (el cual llamaré Project2) listo para ser completado por
nosotros.
Los componentes más comunmente usados.
Veremos a continuación ocho componentes, siete de los cuales son visuales, esto
quiere decir que el usuario de nuestra aplicación los podrá ver y usar, es decir,
interactuar con él ya sea con el mouse o con el teclado o ambos, algunos de ellos solo
sirven para presentar información visual. Y veremos un componente no visual el cual,
como su nombre lo indica, no es visible para el usuario pero es útil para el programador
ya que simplifica su tarea de alguna manera.
Primero taeremos al frente la paleta "Standard".

Fig. 1 - La paleta Standard.

Label (TLabel).
Este componente sirve principalmente para sobreimprimir texto estático no
seleccionable por el usuario, es muy útil para indicarle cosas al usuario o para describir
la función de otros componentes en nuesta aplicación. Selecciona este componente y
suéltalo en el Diseñador de Formulario tal como hicimos con el Button en el capítulo 2
de este tutorial. Observa en el Inspector de Objetos todas sus propiedades, presiona F11
para traer la ventana Inspector de Objeto si no la tienes visible en el IDE.
La principal propiedad de este componente es Caption, en la cual puedes escribir el
texto que aparecerá en el componente. Reemplaza la cadena "Label1" por "Ingrese
texto", mientras lo haces ese texto se modifica automáticamente en el Diseñador de
Formulario. Como hicimos con el Button en el capítulo dos puedes reubicar el Label en
cualquier parte del formulario arrastrandolo con el mouse o bién modificando las
propiedades Top y Left del mismo. También puedes redimensionarlo usando los
pequeños cuadros negros que rodean el componente en el Diseñador de Formulario. Al
hacer esto notarás un comportamiento extraño al principio. Estira el componente hacia
la derecha y hacia abajo, luego vuelve a modificar la propiedad Caption usando el
Inspector de Objetos, verás que el componente se redimensiona solo hasta encerrar el
texto escrito, incluso si no pones ningún texto el componente se comprime hasta casi
desaparecer. Esto se debe a que por omisión su propiedad AutoSize está en True
(verdadero), modifica esa propiedad y ponla en False (falso), entonces sí podrás dejar el
componente al tamaño que quieras. Otra propiedad interesante de este componente es
Alignment (alineación) que se refiere a cómo el texto aparecerá, en el Inspector de
Objeto verás en esta propiedad tres valores posibles: taCenter, significa que el texto
estará centrado, taRightJustify, el texto se alineará a la derecha y taLeftJustify el texto
lo hará a la izquierda.
Por lo pronto deja taRightJustify para la propiedad Alignment, escribe "Ingrese
texto" en Caption y pon AutoSize en true.
Otras propiedades son evidentes (si sabes algo de inglés), por ejemplo Color (color),
Font (fuente), Height (altura), Width (ancho), etc... pero hay una de especial interés
que todos los componentes comparten sin distinción la cual es Name, si no la has
modificado aún deberá ser para nuestro caso "Label1". La propiedad Name es el nombre
con el cual nos referiremos en el código fuente del formulario (la unidad asociada) por
eso es muy importante que una vez puesto el nombre lo mantengamos si no deseamos
cambiar luego todas las referencias a ese componente en el código de nuestro programa.
Por lo pronto lo dejaremos como está.
 Edit (TEdit).
Este componente sirve especialmente para que el usuario ingrese texto a nuestra
aplicación y funciona como si fuera un editor de texto de una sola línea. Suelta un Edit
en el formulario y colócalo justo a continuación del Label que ya tenemos allí. La
propiedad principal del Edit es Text, que por omisión tiene la cadena de caracteres igual
al nombre del componente, elimínalo para limpiar el texto que aparece en el
componente en el Diseñador de Formulario. Si estudias el resto de las propiedades del
Edit verás que comparte algunos con el componente Edit (¡pero no tiene Alignment!...
se puede solucionar) y funcionan de la misma manera solo que aplicado a este
componente.
Compila y ejecuta el programa tal como está ahora con F9 y experimenta cambiando
las propiedades de ambos componentes. Algunas propiedades clave son:
Enabled: establece si el componente responde al usuario o a otros eventos.
Visible: el componente es visible al usuario.
Color: el color del componente, en el caso del TEdit es el color del fondo.
MaxLength: la cantidad máxima de caracteres que admite el componente, cero para
infinito.
ReadOnly: el componete es de solo lectura. A diferencia de Enabled esta propiedad
hace que el componente responda a los eventos excepto que su contenido no es
modificable por el usuario.
TabStop/TabOrder: estas propiedades indican si el componente recibirá el foco
cuando el usuario presione la tecla Tab y en qué orden lo hará con respecto al resto de
los componentes con la misma capacidad de recibir el foco (Buttons, CheckBoxes,
Memos, etc...)

Memo (TMemo).
Este componente es un mini editor de texto donde el usuario puede escribir texto en
varias líneas. Su principal propiedad es Lines el cual es un TStrings (hablaremos más
tarde de esto). El texto puede ser ingresado tanto por el usuario como por el
programador por medio de código.
Pasemos a la paleta de componentes "Additional":

Fig. 2 - La paleta "Additional"

Esta paleta contiene más componetes comunes a Windows, de aquí describiré solo
tres.

BitButton (TBitBtn).
Este componentes es casi identico al TButton visto en nuestro primer programa con
la gran diferencia que permite que junto con el Caption se le pueda agregar una imágen
como decorado o icono. Para ello se usa la propiedad Glyph, la imágen debe ser de tipo
BMP y debe coincidir en tamaño con el botón.
 Hay una particularidad con respecto a las imágenes insertadas en un BitButton. El
pixel inferior izquierdo de la imágen se establece como el pixel transparente. Esto
significa que si el pixel de la esquina inferior izquierda es negro todo lo que es negro en
la imágen del Glyph se vuelve transparente. A tener en cuenta para lograr efectos
interesantes. La propiedad Layout controla en qué lugar del BitButton estará la imágen
(derecha, izquierda, arriba o abajo). Luego el BitButton es similar al Button en otros
aspectos.

SpeedButton (TSpeedButton).
Este es un button especial que acepta imágenes igual que el BitButton pero tiene un
mayor control del mismo, es para hacer botones "artísticos", además de Layout el
SpeedButton tiene otras propiedades para ajustar la imágen y el Caption (Spacing, si es
que tiene) así como ajustar la distancia entre la imágen y el borde elegido con Layout,
Margin, donde el valor -1 indica centrado, cero indica 0 pixels entre el borde y la
imágen y así. También tiene otra propiedad interesante, Flat, con esta puedes hacer que
el borde del SpeedButton desaparezca pero solo aparezca cuando el puntero del mouse
pasa por encima de él, al estilo de los botones del Internet Explorer (este efecto es
apreciable en tiempo de ejecusión, no en tiempo de diseño). Por último tienes la
propiedad Down que hace que el botón permanezca hundido una vez se hace click en él,
debes cambiar la propiedad GroupIndex a un valor distinto de cero para que esta
propiedad tenga efecto.

Image (TImage).
Este componente permite visualizar imágenes BMP, sirve tanto para decorar el
formulario o como visualizador de este tipo de archivo (para ver imágenes JPEG debes
agregar manualmente la unidad jpeg a la "uses" de la Units donde está el TImage) para
ello se usa la propiedad Picture. Para estirar la imágen de forma tal que ocupe el misma
ancho y alto del componente se usa la propiedad Stretch en True.
Por último vamos a ver un componente no visual en de la paleta "System":

Fig. 3 - La Paleta "System".

Timer (TTimer).
El TTimer es un componente no visual, esto quiere decir que el usuario no lo ve
cuando la aplicación se ejecuta, solo es visible al programador en tiempo de diseño por
lo que no importa dónde lo coloques en el formulario, este no se verá. Su función es
muy útil, se trata de un cronómetro que dispara un evento OnTimer cuando se vence un
plazo de tiempo en milisegundos (1000=1 Segundo), propiedad Interval. Cuando su
propiedad Enabled está en true se dispara el cronometro y cuando este es igual o mayor
a Interval se ejecuta lo que esté en el evento OnTimer del TTimer, el cronómetro interno
entonces vuelve a cero y se repite el proceso hasta que la aplicación termina o bién la
propiedad Enabled se pone en falso, una aplicación obvia de este componente es la de
un reloj.
Vamos a hacer una aplicación cronómetro para probar este componente y de paso ver
cómo se trabaja por código las propiedades de los componentes.
Un cronómetro sencillo.
Comienza una aplicación nueva. En el formulario suelta dos Buttons y un Label de la
paleta Standard, y de la paleta System un Timer. Pon la propiedad Enabled del Timer en
false para prevenir que se dispare cuando la aplicación arranque. Limpia la propiedad
Caption del Label. A uno de los Button cambia su Caption a "Comenzar" y al otro
cambia su Caption a "Reset", el pimero será para arrancar o detener el cronómetro y el
segundo para volver a cero la cuenta. Luego de estas modificaciones tienes que tener un
formulario que se vea más o menos así:

Fig. 4 - Vista parcial del formulario en tiempo de diseño.

Ahora cámbiate al Editor de Código y llega hasta la declaración del formulario, debe
verse así:
view source

print?
01.type
02. TForm1 = class(TForm)
03. Timer1: TTimer;
04. Label1: TLabel;
05. Button1: TButton;
06. Button2: TButton;
07. private
08. { Private declarations }
09. public
10. { Public declarations }
11. end;
Agregaremos una variable de clase a la clase TForm1 en la sección public la cual
llamaremos Segundos y será de tipo integer, así:
view source

print?
01.type
02. TForm1 = class(TForm)
03. Timer1: TTimer;
04. Label1: TLabel;
05. Button1: TButton;
06. Button2: TButton;
07. private
08. { Private declarations }
09. public
10. { Public declarations }
11. Segundos: integer;
12. end;
La cual tendremos que inicializar en cero. El mejor momento de hacerlo es cuando el
formulario se carga, esto es en el evento OnCreate, así que usa el Inspector de Objetos,
selecciona el Form1 y haz doble click en el evento OnCreate. Luego modifica el código
de ese evento de forma tal que se vea así:
view source

print?
1.procedure TForm1.FormCreate(Sender: TObject);
2.begin
3. Segundos:=0;
4.end;
Es decir asignarle cero a la variable Segundos, esto ocurrirá una sola vez cuando de
comienzo a nuestra aplicación.
Nota: de nada sirve que escribas el procedimiento OnCreate manualmente sin usar el
Inspector de Objeto ya que no se realiza la asociación entre ese procedimiento y el
evento OnCreate del Form1.
Ahora selecciona el objeto Timer1 y modifica el evento OnTimer desde el Inspector
de Objeto de forma que se vea así:
view source

print?
1.procedure TForm1.Timer1Timer(Sender: TObject);
2.begin
3. Segundos:=Segundos+1;
4. Label1.Caption:=IntToStr(Segundos);
5.end;
Como había mencionado, este evento se ejecuta cada vez que el cronómetro interno
del TTimer es igual o mayor a la propiedad Interval del mismo que por omisión vale
1000 milisegundos, es decir, 1 segundo, no lo modificaremos pues es justo lo que
queremos. Lo que se hace aquí es sumar 1 a la variable de clase Segundos y luego
mostrarla en el Label1 pero para ello tenemos que hacer una conversión de tipos ya que
la propiedad Caption del Label es de tipo TCaption y Segundos es de tipo Integer, para
lograr esto usamos una función predefinida llamada IntToStr que convierte cualquier
tipo entero, tal como Integer, a un String, es decir a texto, TCaption es compatible con
String.
Ahora modifica la propiedad OnClick del Button1 (el que tiene el Caption
"Comenzar") de modo que se vea así:
view source

print?
01.procedure TForm1.Button1Click(Sender: TObject);
02.begin
03. if Timer1.Enabled = true then // si el timer está corriendo...
04. begin
05. Timer1.Enabled:= false; // detenerlo
06. Button1.Caption:='Comenzar'; // y cambiar el caption del
button
07. end // (aquí no se escribe punto y coma)
08. else // sino ...
09. begin
10. Timer1.Enabled:= true; // disparar el timer
11. Button1.Caption:='Detener'; // y cambiar el caption del
button.
12. end;
13.end;
La lógica aquí es, preguntamos si el timer está corriendo, es decir su propiedad
Enabled está en true, si lo está lo paramos poniendo en false esa propiedad y
modificamos el Caption del Button para reflejar ese estado, si no está corriendo lo
ponemos a correr y cambiamos el estado del Caption también. Nota que en el End antes
del Else no se escribe punto y coma pues allí no termina la sentencia If.
Solo nos falta que el usuario tenga la posibilidad de poner en cero la variable
Segundo. Para eso hemos puesto el otro Button, cuyo código en su evento OnClick debe
ser este:
view source

print?
1.procedure TForm1.Button2Click(Sender: TObject);
2.begin
3. Segundos:=0;
4. Label1.Caption:=IntToStr(Segundos);
5.end;
No necesita mucha explicación, ¿cierto?. Compilamos y ejecutamos, si todo marcha
bién deberías tener un cronómetro que marca los segundos. No creo que necesites
instrucciones de cómo funciona el programa ¿eh? :).
En resumen.
Hemos dado un vistazo a los componente más comunmente usados en una aplicación
Windows, hemos visto también alguna de sus propiedades así como ejemplo de su uso y
una aplicación práctica de alguno de ellos. Espero que esto despierte tu imaginación y
explores por tí mismo todas las posibilidades que te ofrece la VCL. En el próximo
capítulo veremos algo más en profundidad lo que es el lenguaje Object Pascal.