El entorno de desarrollo Lazarus.

SimSEE pág. 1 / 14
SimSEE por dentro 002
El entorno de desarrollo Lazarus.
------------------------Proyecto: SimSEE v2.47
Archivo: SimSEE_pordentro002_Lazarus.odt
Autor: Ruben Chaer.
Fecha creación: 28/11/2009 10:52:21
Fecha última revisión: 30/11/2009 08:27:57 PM
Institución: IIE – Montevideo – Uruguay.
En este capítulo se introduce el entorno de programación Lazarus y cómo desarrollar
aplicaciones con el.
La sección 1 contiene una breve introducción al desarrollo de aplicaciones más que nada
para establecer el lenguaje de uso común como qué es codigo fuente compilador, linker etc.
Si usted tiene experiencia en el uso de compiladores puede saltear dicha sección.
En la sección 2 se muestra cómo instalar el entorno de desarrollo Lazarus y cómo crear una
aplicación sencilla.
1 Introducción al desarrollo de aplicaciones.
Código Fuente y Ejecutable.
Por PROGRAMA entendemos un código ejecutable. Por FUENTE o FUENTES de un
PROGRAMA entendemos el conjunto de archivos de texto que especifican qué es lo que
hace el PROGRAMA.
Lenguaje de Programación.
Los FUENTES están escritos en un LENGUAJE DE PROGRAMACION de alto nivel
como puede ser BASIC, PASCAL, FORTRAN, C, C++, etc.
Compiladores y Linkers
Para pasar del LENGUAJE DE PROGRAMACION al código binario ejecutable por el
microprocesador, es necesario utilizar dos programas, un COMPILADOR y un LINKER.
El Compilador es específico del lenguaje de programación. Técnicamente el compilador
hace una traducción de cada uno de los archivos fuentes del lenguaje de programación a
archivos con los códigos binario que representan las instrucciones entendibles por el
microprocesador. Nosotros trabajaremos con un compilador Pascal.
El programa LINKER (o enlazador si lo traducimos crudamente al español) se encarga de
enlazar los bloques de código creados por el compilador con los bloques de códigos propios
del sistema operativo para el que se está creando el programa ejecutable y con todos esos
bloques enlazados correctamente crea el archivo binario ejecutable.
El Proyecto, MAKE, Construir y Construir Todo
SimSEE pág. 2 / 14
Cuando trabajamos en la creación de un PROGRAMA, a partir de determinado nivel de
complejidad se hace necesario partir el FUENTE en varios archivos para darles una
organización lógica y además esto permite reutilizar parte de los FUENTES en otros
programas. A esta agrupación "de las cosas necesarias para editar y compilar un programa"
la llamamos PROYECTO. Cada PROYECTO maneja por lo tanto lo necesario para generar
un PROGRAMA.
En el caso de SimSEE, los programa más usados son el "Editor", el "Simulador" y el
"Procesador de resultados". Como veremos hay tres PROYECTOS, uno para cada uno de
estos PROGRAMAS.
Las herramientas utilizadas para desarrollar un programa pueden incluir funciones especiales
para manejo de los proyectos o no.
De las primeras herramientas que aparecieron para compilar un conjunto de fuentes y linkear
los resultados en un ejecutable fue el programa "make" conocido como "El maker". Este
programa toma como entrada un archivo de texto que especifica el conjunto de archivos
fuentes a compilar (llamando al compilador) y luego el conjunto de archivos con código
binario a linear (llamando al linker).
Cuando ejecutamos el programa make desde una línea de comando, éste busca en la carpeta
actual un archivo con el nombre Makefile.cfg, si existe lo considera como un archivo de
descripción de un proyecto e intenta ejecutar las órdenes contenidas den el Makefile. Estas
ordenes indican el compilador a usar, el linker a usar y las dependenicas entre los archivos
de forma que se puedan compilar. No vamos a entrar en el detalle de cómo escribir un
Makefile pues como veremos no es algo que sea necesario y hoy todo esto se hace en forma
automática. Lo nombramos aquí solamente por completar el conocimiento y para que se
entienda porqué hablamos de hacer MAKE.
Generalmente, el Makefile se organiza de forma que si cambiamos un solo fuente y lo
llamamos (hacemos MAKE) se compile solamente ese fuente y quienes puedan depender de
él. Es decir que no se recompilan todos los fuentes sino solamente aquellos cuyo resultado
de la última compilación tiene fecha anterior a la fecha del archivo fuente. Es decir que
hacer un MAKE recompila (o construye) sólo lo que cambió desde la última compilación.
Esto ahorra mucho tiempo. Hay ocaciones en que queremos que se recompile todo sin
importar las fechas. Eso se logra pasando una opción al make que le indica que ignore las
fechas y reconstruya todo.
En algunas plataformas se le llama MAKE a la acción de Contruir lo necesario de acuerdo a
las fechas y BUILT a la acción de Costruir Todo sin importar las fechas.
El DEBUGGER.
La palabra DEBUGGER viene de BUG (bicho en inglés) y significa el quitador de bichos.
El DEBUGGER es un programa que nos permite correr nuestra aplicación (el programa que
está siendo debuggeado) paso a paso e ir inspeccionando las variables. Es una herramienta
muy útil y que facilita mucho la detección y corrección de errores.
Entornos de Desarrollo Integrados ( IDE )
Los archivos fuente son simples archivos de texto y se pueden editar con cualquier programa
editor de textos.
SimSEE pág. 3 / 14
Luego se puede llamar el compilador para compilar cada archivo fuente y luego el linker
para unirlos y crear el ejecutable.
El trabajo de esta forma es algo tedioso y se han creado entornos de desarrollo que permiten
manejar con facilidad todos los archivos de un proyecto, permitiendo editar los fuentes con
ayudas como resaltado con colores de las palabras claves, autocompletado de texto,
chequeador de sintaxis en tiempo real etc. Además estos entornos facilitan las llamadas al
compilador y al linker desde el propio entorno y en caso de saltar un error nos posicionan
con facilidad en la parte del código fuente que produce el error.
Los IDE integran también funciones de DEBUGGER que nos permiten ejecutar el programa
siguiendo paso a paso su ejecución sobre el código fuente y revisar los valores de las
variables.
Entornos RAD (Rapid Application Development)
En la antigüedad (lo digo bromeando pues la mayoría de nosotros vivimos esta etapa) nos
comunicábamos con la computadora mediante una consola de texto, sin Mouse y sin interfaz
gráfica. Los programas recibían los datos generalmente en archivos de textos y para editar
esos archivos no había más remedio que usar editores de texto de comando diseñados para
funcionar en las consolas de texto. De esa época hasta ahora toda ha evolucionado mucho,
han mejorado muchísimo los monitores aumentando su definición, agregando color y
bajando mucho de precio. Esto llevó a un desarrollo explosivo de las interfaces gráficas y
por supuesto que los usuarios se volvieron cada vez más exigentes.
El desarrollo de las interfaces gráficas con las antiguas herramientas de desarrollo era
realmente tedioso (yo llegué a hacer alguna). Por suerte, parecieron los entornos RAD (de
Rapid Application Development) que permiten "armar" la interfaz y programar su
comportamiento en forma muy sencilla. Los entornos RAD más conocidos son el Visual
Basic (de Microsoft) y el Delphi (de Borland). También los hay para Java y C++.
El entorno Visual Basic es por lejos el más popular pues al utilizar BASIC le resulta sencillo
de usar a un grupo importante de gente.
El entorno Delphi es similar a Visual Basic, pero utiliza lenguaje PASCAL en lugar de
BASIC.
Para describir en palabras lo que significa RAD, utilizando este entorno el diseño de la
aplicación se realiza en base a un formulario (aparece un panel que es lo que verá el usuario)
y una barra de herramientas que podemos seleccionar y arrastrar al formulario. Por ejemplo,
elegimos un botón y lo arrastramos al formulario, luego hacemos doble-click sobre el botón
y se abre una ventana donde podemos escribir el tramo de programa con la acción a ejecutar
cuando se presiona el botón.
Podríamos decir que los editores de texto+compilador+link desde la línea de comando
constituyen la primera generación de herramientas, los entornos IDE la segunda y los
entornos RAD la tercera.
El desarrollo de SimSEE se realizó con el entorno RAD Delphi. Como este entorno es un
programa de uso comercial y dado que se busca que la plataforma SimSEE sea utilizada con
SimSEE pág. 4 / 14
fines didácticos se ha migrado el desarrollo (con poco esfuerzo) para que se pueda continuar
el desarrollo utilizando el entorno RAD Lazarus que es de uso libre.
Otra razón para utilizar Lazarus es que se dispone de esta herramienta tanto en Windows
como en Linux.
2 El entorno de desarrollo Lazarus.
El entorno de desarrollo que utilizaremos es LAZARUS. Es de uso gratuito y puede bajarse
de la dirección: http://lazarus.freepascal.org/
LAZARUS es un RAD Pascal. La misma instalación incluye el compilador FREEPASCAL.
Al momento de escribir este texto, la ultima versión para windows de Lazarus es la que
corresponde al archivo "lazarus-0.9.28-fpc-2.2.4-win32.exe"
Una vez bajado ese archivo (o uno más reciente si lo hay) al ejecutarlo se instala el entorno
como cualquier aplicación de windows.
Una vez instalado ya estamos en condiciones armar nuestra primer aplicación.
Al ejecutar Lazarus, se abre el ambiente de desarrollo. En este ambiente todo gira alrededor
de la idea de PROYECTO. Lo que estamos editando es un PROYECTO y podemos editar
los diferentes fuentes del PROYECTO.
La siguiente figura muestra la parte de la ventana del menú y barras herramienta principal.
Ilustración 1: Menú Principal y Barras de Herramientas de Lazarus.
Lo primero para iniciar una aplicación es crear un Proyecto. En el menú seleccionar
Proyecto y se abrirá un submenú como el que se muestra en la siguiente figura.
SimSEE pág. 5 / 14
Ilustración 2: Menú Proyecto
Seleccionar "Nuevo Proyecto" y se abrirá otro menú (ver figura siguiente) en el que se debe
seleccionar el tipo de proyecto.
Ilustración 3: Selección del tipo de proyecto.
De todas las opciones la primer "Aplicación" es la que debemos elegir para crear un
proyecto de un programa con interfaz gráfica. La segunda "Programa" es la opción para
crear un programa que funcione en una consola en modo texto (por ejemplo una terminal
Linux). El resto de las opciones no son de interés en nuestras aplicaciones.
Bien, al presionar el botón ACEPTAR se creará el nuevo PROYECTO y automáticamente
se creará un archivo con código fuente para manejo de un FORMULARIO (pantalla del
SimSEE pág. 6 / 14
usuario). Se abrirán unas cuantas ventanas, un poco desordenadas y superpuestas pero
después de trabajar un poco son manejables.
Si alguna de las ventas no está visible o si la cerramos y queremos volver a verla hay que
buscar en el menú principal el comando que la mostrará nuevamente.
Las ventas que se abren son:
2.1 Ventana Principal.
La ventana principal del IDE Lazarus es la que contiene el Menú y las herramientas.
Ilustración 4: Ventana Principal del IDE - Lazarus
Si cerramos esta venta se cierran todas y saldremos de Lazarus.
2.2 Ventana Editor de código Fuente.
La de "Editor de código fuente". Donde inicialmente aparece desplegado el archivo "Unit1"
con el código Pascal creado en forma automática para manejo del primer formulario.
El "*" al inicio de la palabra "Unit1" indica que ese archivo está sin guardar. Por cada
archivo que tengamos abierto en edición aparecerá una orejita (como Unit1) y según la que
esté activa veremos el código fuente en la parte central de la ventana.
Ilustración 5: Ventana Editor de código fuente
Si cerramos esta venta (o ya está cerrada) podemos volver a abrir clickeando sobre "Editor
código fuente" en el menú "Ver".
SimSEE pág. 7 / 14
Si el archivo en la oreja activa en el editor de código corresponde a una unidad que tienen un
formulario asociado (ver siguiente ventana) podemos cambiar el foco entre la ventana de
edición del código fuente y el formulario presionando F12 o haciendo click sobre el botón
de la barra de botones de la venta principal.
2.3 Ventana del formulario.
La ventana con el formulario nos muestra lo que será la interfaz gráfica del usuario. Este
formulario es un "contenedor" en el que colocaremos los elementos gráficos (botónes,
etiquetas, cuadros de texto, etc.) que verá el usuario.
Ilustración 6: Ventana del Formulario
de la barra de botones de la venta principal o presionando F12
Presionando el botón
cambiamos el foco (o sea la ventana activa) entre el formulario y la ventana de edición del
código con el archivo fuente asociado al formulario.
2.4 Ventana Inspector de Objetos.
La ventana "Inspector de Objetos" nos
permite modificar las propiedades de un
objeto incrustado en el formulario (o del
propio formulario). En la Ilustración 7, se
muestra en la parte superior el árbol de
objetos. En este caso como el único objeto
es el formulario "Form1" del tipo "Tform1"
el árbol tiene solo ese elemento. Si
agregamos un botón en el formulario,
veríamos que el mismo aparece en ese árbol
como dependiendo de "Form1". En la parte
de abajo de la ventana tenemos las
propiedades editables en tiempo de diseño
(o sea ahora, dentro del entorno de
desarrollo, no en tiempo de ejecución).
Las oreja "Propiedaes" contiene campos con
sus valores. Por ejemplo el campo
Ilustración 7: Ventana Inspector de Objetos
"Caption" tiene en la figura el valor
"Form1" y corresponde al título de la
ventana.
SimSEE pág. 8 / 14
Supongamos que queremos que nuestra ventana al abrirse diga en la parte superior "Mi
primer aplicación". Es tan fácil como hacer click en la fina "Caption" sobre "Form1" y
cambiar el valor al deseado.
La oreja "Eventos" nos permite especificar cómo responde el objeto a determinados Eventos.
Veremos en el ejemplo más adelante cómo usar esta característica.
Las orejas "Favoritos" y "Restriguido" no son de nuestro interés por ahora.
2.5 Inspector de Proyecto
Esta ventana (Ilustración 8) nos permite ver el conjunto de archivos que utiliza el proyecto.
Es como un navegador de archivos.
Presionando el botón "+" podemos
agregar un archivo al proyecto y con el
"-" podemos quitarlo. En la figura,
vemos el árbol de "Archivos" que en
este caso muestra que el proyecto bajo
edición tiene un archivo que se llama
"project1.lpr" y otro que se llama
"unit1.pas". Estos dos archivos son el
principal del proyecto (el que tienen el
programa principal) y el que tiene el
código de definición y manejo del
Ilustración 8: Ventana Inspector de Proyecto
formulario respectivamente. El árbol
"Paquetes Requeridos" hacer referencia
a los paquetes instalados junto al entorno de desarrollo (o agregados posteriormente) que
utiliza este proyecto. El paquete LCL es el que contiene los elementos gráficos de Lazarus
usables en formularios.
2.6 Ventana de Mensajes.
En esta ventana aparecen los mensajes del compilador y del linker. También aparecen en
esta ventana los resultados de búsquedas si usamos alguna de las funciones en varios
archivos del proyecto.
Ilustración 9: Ventana de mensajes
2.7 Nuestra primer aplicación.
Continuando con el ejemplo, antes que nada guardemos el nuevo proyecto y especifiquemos
un nombre adecuado tanto para el módulo "Unit1.pas" como par el proyecto en si. Para eso
vamos al menú "Archivo" y hacemos "Guardar". Como los archivos tienen los nombres por
defecto, nos dará la opción de cambiar los nombres antes de guardar. Elegir la carpeta
destino del proyecto y especificar un nombre para los dos archivos.
Es aconsejable usar una carpeta para cada proyecto. Por ejemplo si el proyecto se va a llamar
"ejemplo1" creamos una carpeta que se llama así "ejemplo1" y guardamos la "unit1.pas" con
el nombre "uejemplo1.pas" y el proyecto como "ejemplo1.lpi".
SimSEE pág. 9 / 14
Es aconsejable usar siempre minúsculas para los nombres de archivos y no poner ni espacios
ni eñes ni caracteres raros. Esto es así pues si necesitamos compilar en Linux vamos a tener
problemas si mezclamos minúsculas y mayúsculas o si usamos caracteres raros.
Una vez salvado el proyecto, probemos "correr" la aplicación. Para eso podemos presionar el
botón
. Al presionar ese botón, Lazarus procede a Compilar, Linkeditar y Ejecutar la
aplicación. Si hay errores, se interrumpe el proceso y aparecen los mismos en la ventana de
mensajes.
En este caso, que aún no hicimos nada en el formulario ni en el código fuente debiera
funcionar sin errores. Aparecerán mensajes del compilador del linker y un mensaje de
indicando "el proyecto se ha construido correctamente :)" y se abrirá una ventana con el
formulario vació pues no le pusimos nada. El título de la ventana dirá "Form1" si no
cambiamos la propiedad "Caption" o lo que hayamos puesto en su lugar.
En la opción del menú "Ejectuar" se encuentra la posibilidad de "Construir", "Construir
Todo" y "Ejecutar" ver Ilustración 10. La opción "Construir" significa compilar solamente
aquellos archivos que hayan sido modificados desde la última vez que se compilo. La opción
"Construir Todo" es volver a compilar todo sin importar las fechas de modificación y
"Ejecutar" es equivalente a "Construir", linkear y correr.
Por comodidad, hay definidos "atajos de teclado" que
nos permiten hacer determinadas acciones sin la
necesidad de levantar los dedos del teclado. Estos
atajos aparecen en las ventanas de los menúes. Por
ejemplo, observar en la misma Ilustración 10 que "CtrF9" (Control F9 presionadas juntas) es el atajo para
"Construir" y "F9" equivale a "Ejecutar".
Bueno ahora introduzcamos algún error para ver qué
pasa. Vamos a intentar que al cargarse el formulario,
cambie el "Caption" (o sea el título de la ventana) a
"Hola que tal!".
Activemos la ventana del formulario. Y en el inspector
de objetos, despleguemos las propiedades del
formulario, seleccionemos la solapa "Eventos". Una
vez abierta esa solapa, hagamos click en la segunda
columna de la fila correspondiente al evento
Ilustración 10: Menú Ejecutar
"OnCreate". La idea es que vamos a definir el
comportamiento del formulario frente al evento
"OnCreate". Este evento se dispara al crear el formulario y es una oportunidad que tenemos
en tiempo de ejecución para inicializar parámetros.
Nos tiene que aparecer algo similar algo similar a lo que se despliega en la Ilustración 11.
Al hacer click sobre el botón "…" que aparece a la derecha del cuadro blanco, se creará
automáticamente en el editor de código fuente una función pascal que se ejecutará al crearse
el formulario.
SimSEE pág. 10 / 14
Es dentro de esa función que debemos introducir lo que queremos que el formulario haga al
crearse.
En nuestro caso la idea es asignarle a la propiedad
"Caption" del formulario otro valor al momento de
crearse.
Pero primero introduzcamos un error para ver cómo
funciona el tema de la detección y corrección de
errores.
La Ilustración 13 muestra el procedimiento
"TForm1.FormCreate" creado automáticamente por
Lazarus y en el que le escribí en el cuerpo del
procedimiento (entre el begin y el end) un código
que intenta asignar a una variable "titulo" el valor ".
La sentencia pascal agregada es:
Seguramente Lazarus no tiene ni idea de quíen es
"titulo". Intentemos compilar (Ctrl-F9).
Y observemos la ventana de mensajes. En la
Ilustración 13 vemos la ventana de mensaje
resultante. Indica que en el archivo vuente unit1.pas
Ilustración 11: Evento OnCreate
en la líne31, carácter 9 encontró un error y no pudo
seguir compilando. Además indica que el error fue
que no encontró el identificador "titulo".
Automáticamente Lazarus debe de haber activado la ventana de editor de fuentes y debe
haber posicionado el cursor sobre el error. Si no lo hizo pude hacer CLICK sobre el error en
la venta de errores e irá al error correspondiente.
Ilustración 12: Error, Identifier not found
Bien ahora corrijamos el error, nuestra intención era cambiar el "Caption" del formulario.
Nosotros ya sabemos que los formularios tienen esa propiedad porque ya la vimos en el
"Inspector de Objetos".
No todas las propiedades de un objeto gráfico aparecen en el "Inspector de Objetos". El tipo
de objeto gráfico que puede usarse en tiempo de diseño en el entorno Lazarus se llama
COMPONENTE. Los componentes también se crean con Lazarus y se pueden agregar
nuevos componentes a la barra de herramientas. Al momento de diseño de un componente se
elige cuales propiedades son publicadas para que sean modificables en tiempo de diseño con
el inspector de objetos.
SimSEE pág. 11 / 14
Bien, ahora cerremos la aplicación (click en la cruz del formulario) y agreguemos algo más
interesante a la misma.
Ilustración 13: Escribiendo la respuesta a OnCreate
Si ejecutamos la aplicación veremos que se abre una ventana y que el título dice
"Hola que tal!", tal como lo programamos.
2.8 Estructura de una UNIDAD PASCAL.
Una aplicación se desarrolla escribiendo el código fuente organizado en diferentes módulos.
Cada módulo se escribe en un archivo aparte. La idea es que cada módulo agrupa un
conjunto de definiciones e implementaciones que tienen alguna característica que hace que
sea natural agruparlas. Por ejemplo veremos que entre las librerías (o módulos) usados en
SimSEE tenemos uno en el que se define lo necesario para manejar matrices, otro para
polinomios, etc.
El módulo tiene dos secciones fundamentales. La INTERFACE y la IMPLEMANTATION.
En la sección INTERFACE se colocan todas las definiciones (tipos, funciones, variables,
clases, etc.) que son públicadas por el módulo. Esto significa que son visibles desde otros
módulos.
En la sección IMPLEMANTATION se escribe el código que implementa las diferentes
funciones y/o procedimientos definidos en la INTERFACE más aquellos que sean
necesarios dentro de la IMPLEMENTATION.
SimSEE pág. 12 / 14
A modo de ejemplo, supongamos un módulo que exporta una función "Producto" para
multiplicar dos números. Un código mínimo para tal módulo sería:
(para visualizar los números de línea en Lazarus hay que habilitar la opción en el menú
Entorno-Opciones-Editor-General-Visualizar-y marcar Mostrar números de línea. )
En la línea 1, tenemos la declaración del nombre de la unidad. En este caso "uproducto". Si
bien el nombre de la unidad puede tener minúsculas y mayúsculas como este nombre
coincide con el nombre con que se guarda el archivo, es aconsejable usar solamente
minúsculas para evitar problemas si el sistema operativo distingue entre minúsculas y
mayúsculas.
Con la palabra reservada "interfce" (línea 3 en el ejemplo) comienza la sección
INTERFACE del módulo y se extiende hasta la palabra reservada "implementation".
En este caso en la INTERFACE hemos definido la función "Producto" (línea 5) para que
desde fuera del módulo sea visible dicha función. Ha este tipo de encabezado de una
función, que lo que hace es declarar el nombre, la lista de parámetros y sus tipos y el tipo de
resultado de la función es lo que se llama un "prototipo" o "declaración" de una función.
Esto es nos dice lo necesario para llamar la función pero no nos dice cómo está
implementada la función.
La sección IMPLEMENTATION del módulo comienza con la palabra reservada
"implementation" (línea 7) y va hasta el final del módulo.
El final de todo archivo fuente Pascal es un "END." (la palabra END seguida por un punto).
El compilador Pascal, cuando procesa los archivos lee el contendio hasta encontrar "END." e
ignora cualquier cosa que esté escrita después de esa palabra.
Para continuar con el ejemplo, hagamos que el formulario tenga lugar para ingresar dos
números y un botón que al presoinarlo calcule el producto de los números usando la función
Producto antes definida y que guarde el resultado en otro casillero del formulario puesto
para ese propósito.
Comencemos por crear un nuevo proyecto del tipo Aplicación para que nos cree un
formulario vacío. Definamos en la UNIT la función Producto como la desarrollamos en los
párrafos anteriores.
SimSEE pág. 13 / 14
A continuación hagamos activa ventana del formulario para comenzar a incluir los
componentes y diseñar el aspecto del formulario. En la siguiente figura se muestran los
componentes que utilizaremos. Ellos son de izquierda a derenca: Botón, Etiqueta (para poner
los textos visibles fijos) y Editables (para poner los casilleros en los que ingresar los
números y en el que poner el resultado).
Botón
Etiqueta
Editable
Bueno haciendo click sobre el compoente Editable y luego Click en el fomulario colocamos
3 componentes de este tipo. Como veremos automáticamente Lazaurs les pondrá nombres
Edit1, Edit2 y Edit3 respectivamente. Si queremos que en lugar de esos nombres tengan
otros más significativos podemos seleccionar cada uno y cambiar la propiedad "Name" en el
Inspector de Objetos. Por ejemplo los podemos renombrar a "eDato_a", "eDato_b" y
"eResultado". El texto que aparece en el casillero es el que está en la propiedad "Text".
Pongamos por ejemplo inicialmente 0 (cero) en todos los campos "Text" de los Editables
para que el formulario tenga valores coherentes.
Paso seguido, pongamos tres Etiquetas a la derecha de los Editables para ponerle texto que
indique al usuario el objetivo de cada campo y un botón. Editar la propiedad "Caption" del
botón para que diga algo como "Calcular". El aspecto del formulario tiene que ser algo así
como lo que se muestra a continuación:
Ahora, debemos hacer que al hacer Click sobre el botón "Calcular" se calcule el producto de
los parámetros "a" por "b" y el resultado sea colocado en "Resultado".
Para ello, hagamos un click sobre el botón (para seleccionarlo) y en el inspector de objetos
activemos la oreja "Eventos". En el panel de los eventos posible debemos activiar el que dice
"OnClick". Haciendo Click sobre el botón con "..." que aparece a la derecha del casillero
blanco, Lazarus creará un procedimiento vacío en el editor y posicionará el cursor pronto
para que escribamos lo que corresponde hacer en ese lugar.
SimSEE pág. 14 / 14
La Ilustración 14 se muestra la ventana correspondiente del inspector de objetos.
Observar en la misma ilustración el árbol de los componetes que hemos incluído en el
formulario hasta el momento.
En el código fuente debemos ahora escribir lo que
queremos hacer cuando el usuario haga click.
Lo primero es convertir los textos que están en los campos
editables a números reales, luego llamar a la función
"Producto" para calcular el resultado y luego convertir el
número real resultante a string para cargarlo en el casillero
resultado.
Para la conversión de String a Número Real y a la inversa
usaremos la funciones "StrToFloat" y "FloatToStr"
respectivamente. Estas funciones están definidas en el
módulo "SysUtils" que viene con Lazarus.
En el sitio web http://freepascal.org podemos ver la
documentación on-line del módulo SysUtils (y de los
Ilustración 14: Evento
demás módulos que bienen con Freepascal).
En particular el acceso directo a las funciones de Sysutils OnClick
está en:
http://community.freepascal.org:10000/docs-html/rtl/sysutils/index-5.html
El código a escribir sería:
procedure TForm1.Button1Click(Sender: TObject);
var
a, b, res: double;
begin
a:= strToFloat( eDato_a.Text);
b:= strToFloat( eDato_b.Text);
res:= Producto( a, b );
eResultado.Text:= FloatToStr( res );
end;