Main logo La Página de DriverOp

Tutorial Delphi - Primer programa

Temas.

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:

Soltando un componente desde la paleta de componentes

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:

El Inspector de Objetos mostrando los eventos a 
  los que responde un Button

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:

procedure TForm1.Button1Click(Sender: TObject);
begin
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í:

procedure TForm1.Button1Click(Sender: TObject);
begin
  ShowMessage('Hola Mundo!');
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:

Ejecución de Hola Mundo!

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:

Efecto de ShowMessage

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:

El menú Project

Fig. 5 - El menú Project.

Y en la ventana Editor de Código verás el código fuente del proyecto:

program Project1;
uses
  Forms,
  Unit1 in 'Unit1.pas' {Form1}
{$R *.res}
begin
  Application.Initialize;
  Application.CreateForm(TForm1, Form1);
  Application.Run;
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:

Paletas del Editor de Código

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 .cfg contiene información de cómo estaba configurado el compilador interno del IDE para ese proyecto en particular.

El archivo .dsk contiene la configuración del IDE para ese proyecto en particular.

Finalmentes puedes encontrar .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.

Diego Romero -