Tutorial Delphi - Primer programa Enero 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.begin3.  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.begin3.  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.uses03.  Forms, 04.  Unit1 in 'Unit1.pas' {Form1}

05.  06.{$R *.res}07.  08.begin09.  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.const05.  06.type07.  08.var09.  10.procedure ejemplo1; 11.begin12.  13.end; 14.  15.function ejemplo2: tipo_de_retorno; 16.begin17.  18.end; 19.  

20.begin21.{ 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.uses03.  Forms, 04.  Unit1 in 'Unit1.pas' {Form1}; 05.{$R *.res}06.begin07.  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.interface04.uses { Lista de unidades }05.type06.   { Lista de tipos definidos por el usuario }07.  08.{ Luego encabezado de los procedimientos y funciones visibles desde afuera }09.  10.var11.{ variables visibles desde afuera }12.implementation13.uses { lista de unidades usadas localmente }14.var15.{ variables visibles solo localmente }16.     17.{ Luego implementación de los procedimientos y funciones declaradas en interface más otras }18.     19.initialization20.   { código de inicialización }21.finalization22.   { 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.interface03.uses04.   Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, 05.   Dialogs, StdCtrls; 06.type07.   TForm1 = class(TForm) 08.   Button1: TButton; 09.   procedure Button1Click(Sender: TObject); 10.   private> 11.   { Private declarations }12.   public13.   { Public declarations }14.   end15.var16.   Form1: TForm1; 17.implementation18.{$R *.dfm}19.procedure TForm1.Button1Click(Sender: TObject); 20.begin21.   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.implementation2.var3.   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.uses2.   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.begin7.{ 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.begin7.{ 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.

o Label (TLabel). o Edit (TEdit). o Memo (TMemo). o BitButton (TBitBtn). o SpeedButton (TSpeedButton). o Image (TImage). o 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.type02.   TForm1 = class(TForm) 03.     Timer1: TTimer; 04.     Label1: TLabel; 05.     Button1: TButton; 06.     Button2: TButton; 07.   private08.     { Private declarations }09.   public10.     { 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.type02.   TForm1 = class(TForm) 03.     Timer1: TTimer; 04.     Label1: TLabel; 05.     Button1: TButton; 06.     Button2: TButton; 07.   private08.     { Private declarations }09.   public10.     { 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.begin3.  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.begin3.  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.begin03.  if Timer1.Enabled = true then  // si el timer está corriendo... 04.    begin05.      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.    begin10.      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.begin3.  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.