Entorno visual (LCL). Segundo apunte.

Fuente: http://www.aprendeaprogramar.com/mod/resource/index.php?id=16
Listas y cuadros de texto
Ya sabemos lo básico sobre cómo escribir textos estáticos
empleando etiquetas (TLabel), como permitir que el usuario
teclee datos, con las casillas de introducción de texto (TEdit), y
como poner tareas en marcha pulsando un botón (TButton).
Ahora añadiremos un elemento de tipo "TListBox" y otro de
tipo "TComboBox". El primero será la lista estática en la que
iremos insertando textos. El segundo es una lista desplegable,
que en este ejemplo usaremos para almacenar textos
predefinidos.
Para que luego nos resulte más fácil ampliar o modificar el
programa, vamos a dar nombres significativos a cada elemento.
Por ejemplo, el "ListBox" que va a mostrar los resultados podría
llamarse "lstResultados", en vez de ListBox1, y el "ComboBox"
que contiene textos predefinidos debería ser algo como
"cbPredefinidos", en lugar de ComboBox1.
Ahora rellenamos los valores prefijados de nuestro
ComboBox. Los valores que almacena una lista se encuentran
en un componente llamado "Items", que a su vez está formado
por varias cadenas (Strings). Para hacerlo desde el inspector de
objetos, hacemos doble clic en "Items" de nuestro
"cbPredefinidos" y aparece una ventana en la que podemos
escribir los textos que nos interese:
Principio de Computadoras I - 2011
Podríamos hacer algo así:
procedure TForm1.btAnadirClick(Sender: TObject);
begin
lstResultados.Items.add(edAMedida.Text);
end;
(es decir, añadimos a los "Items" de "lstResultados" el texto
que contiene la casilla de edición "edAMedida")
Si miramos el inspector de objetos, la pestaña de "Eventos"
ahora debería ser algo parecido a:
Vemos que hay muchos eventos que todavía no hemos
usado. Por ejemplo, podríamos comprobar cuando el ratón pasa
por encima del botón (OnMouseEnter) o cuando sale
(OnMouseLeave), cuando se pulsa una tecla (OnKeyPress) o
cuando se deja de pulsar (OnKeyUp), cuando se llega al botón
desde otro punto de la ventana (por ejemplo, al pulsar el
tabulador, OnEnter) y otros tantos, que iremos empleando
cuando nos resulten útiles.
Por su parte, para el ComboBox, queremos que se añada su
texto al ListBox cuando el usuario elija una opción. Para lograrlo,
seleccionamos nuestro "cbPredefinidos", vamos al inspector de
objetos, en la pestaña de "Eventos", y hacemos doble clic en su
evento "OnSelect":
Si queremos añadir elementos desde el programa, usaríamos
el método Add, como veremos enseguida.
Para completar la parte visual de nuestro programa, nos
queda incluir una casilla de edición de texto para poder escribir
mensaje "a medida" (que podríamos llamar "edAMedida"), un
botón encargado de añadir lo que hayamos tecleado (podría ser
"btAnadir", hay que recordar que los identificadores no deben
contener caracteres que no sean parte del alfabeto inglés), y
alguna etiqueta de texto:
Sólo queda decir a qué eventos (sucesos) debe responder
nuestro programa:
Cuando se pulse el botón, habrá que añadir el texto de
nuestro TEDit a nuestro TListBox. Para conseguirlo, hacemos
doble clic en nuestro botón, con lo que aparece el hueco para
rellenar el código fuente que corresponde a su suceso "OnClick".
El código que incluiremos en este caso es muy parecido al de
antes:
procedure
TForm1.cbPredefinidosSelect(Sender:
TObject);
begin
lstResultados.Items.add(cbPredefinidos.Text);
end;
Y el resultado de nuestro programa en funcionamiento,
después de escribir algún que otro texto y escoger también algún
valor del ComboBox, debería ser algo como:
Página 1 de 4
Fuente: http://www.aprendeaprogramar.com/mod/resource/index.php?id=16
Principio de Computadoras I - 2011
Para añadir nuevos elementos, lo hacemos señalando con el
botón derecho de ratón algunos de los "items" de nuestro menú:
(Vemos que el ListBox tiene un tamaño prefijado en pantalla,
pero si añadimos muchos datos, aparece automáticamente una
barra de desplazamiento).
Menús desplegables y contextuales
Introducción a Delphi y Lazarus, por Nacho Cabanes
Cuando un programa tiene que elegir entre múltiples opciones,
no es razonable llenar la pantalla de botones. En ese caso, es
más práctico usar menús. Y podemos elegir entre dos clases de
menús: el menú principal, desplegable, que suele aparecer en la
parte superior de la pantalla, y el menú contextual, que aparece
al pulsar el botón secundario del ratón (el derecho,
normalmente), y que muestra opciones relacionadas con lo que
estemos haciendo en ese momento.
Vemos que también tenemos opciones que no vamos a usar en
este ejemplo básico, pero que son muy habituales en "el mundo
real",
como
la
de
crear
un
submenú.
Ahora añadimos la etiqueta a nuestro formulario.
Casi está listo. Sólo queda decir a nuestro formulario cual es su
menú contextual. Hacemos clic en el fondo del formulario, y en el
inspector de objetos, cambiamos el valor de "PopUpMenu"
En nuestro caso, vamos a hacer un programa sencillo, que
sólo tenga una etiqueta y dos menús. Las opciones del menú se
limitarán a cambiar el texto que aparezca en la etiqueta.
En primer lugar, para añadir menús, los tenemos disponibles
en la barra de herramientas:
Comenzaremos por el menú contextual, que nos mostrará todas
las ideas básicas pero es algo más sencillo:
Para editar sus elementos ("items"), hacemos doble clic en el
icono que representa al menú:
Si ahora miramos el inspector de objetos, veremos que ahí
está la opción de cambiar el nombre visible (caption) de esa
opción del menú, además de otras que todavía no nos interesan,
como la de asociar una imagen a ese elemento, hacer que no
sea visible o hacer que aparezca "marcado" (checked):
Para indicar qué debe hacer nuestro programa cuando se escoja
cada opción del menú, hacemos doble clic sobre ellas, como
hacíamos con los botones, y aparece inmediatamente el "hueco"
para que rellenemos el código del suceso "onClick", que podría
ser algo así:
procedure TForm1.MenuItem1Click(Sender:
TObject);
begin
label1.caption := 'Hola';
end;
procedure TForm1.MenuItem2Click(Sender:
TObject);
begin
label1.caption := 'Adios';
end;
Con todo esto, nuestro programa ya debería funcionar.
Por otra parte, los menús principales son básicamente iguales,
salvo que se puede añadir elementos hacia la derecha
Página 2 de 4
Fuente: http://www.aprendeaprogramar.com/mod/resource/index.php?id=16
Principio de Computadoras I - 2011
("después").
La apariencia de un mini-programa que los utilizase podría ser:
Por cierto, si queremos indicar teclas rápidas, por ejemplo Alt+A
para entrar al menú Archivo, se indica la tecla rápida
precediéndola con &: El "caption" del primer elemento debería
ser "&Archivo", y "&Edición" el del segundo.
Las teclas rápidas como F1 o Ctrl+G se indican desde cada
opción del menú, en el inspector de objetos, cambiando la
propiedad "Shortcut":
En cuanto al uso "en la práctica" de las casillas de selección, lo
más importante será saber si el usuario de nuestro programa ha
activado o no una cierta opción. Para eso se usa la
propiedad "Checked", tanto en los CkeckButtons como en los
RadioBoxes, que nos devuelve un valor de tipo Boolean (TRUE
si la opción está activada, FALSE si no está activada):
if RadioButton2.checked then ...
Diálogos estándar del sistema
Introducción a Delphi y Lazarus, por Nacho Cabanes
Dentro de la pestaña "Additional" de la barra de componentes
tenemos botones para acceder a ciertas ventanas estándar de
Windows, como la de "Abrir", la de "Guardar", la de elegir tipo de
letra, etc. Los iconos que las representan son los siguientes:
OpenDialog es la ventana de diálogo estándar para "Abrir" un
archivo.
SaveDialog es la ventana de diálogo estándar para "Guardar" un
archivo.
FontDialog es la ventana de diálogo estándar para escoger un
tipo de letra.
ColorDialog es la ventana de diálogo estándar para escoger un
cierto color.
Casillas de selección
En Windows hay dos tipos de casillas de selección, como ya
debería saber quien haya llegado hasta aquí, por eso de que
estamos suponiendo un cierto conocimiento sobre Windows...
En los "CheckBox" se pueden seleccionar varias opciones a
la vez (por ejemplo, ser hombre y estar casado).
Para mostrar cualquiera de estas ventanas estándar se usa su
método Execute (realmente se trata de una función, que
devuelve un valor boolean: FALSE si se cancela la ventana o
TRUE si se acepta). Por ejemplo, podríamos crear un miniprograma que permitiese acceder a estas cuatro ventanas,
pulsando ciertos botones.
En los "RadioButton" sólo se puede seleccionar una de las
opciones a la vez, se trata de opciones excluyentes. Por ejemplo,
ser hombre o mujer: o se es hombre o se es mujer... bueno, es
un decir.
Estamos hablando de que la diferencia entre CheckBox y
RadioButton es que se puedan escoger varias opciones (o no se
pueda) de entre un grupo de varias opciones posibles. Por tanto,
debe existir alguna forma de indicarle a nuestro programa que
esas "varias opciones" van juntas formando un grupo. Esa forma
son los "GroupBox": primero podremos un "GroupBox" en
nuestro formulario y después dentro de él insertaremos los
RadioButtons
y/o
CheckBoxes
que
nos
interesen.
Y hay una variante de los GroupBox, cuyo nombre de por sí ya
nos da una pista de su cometido: los "RadioGroup". Tenemos
incluso otro para varios CheckBox:
La respuesta a la pulsación de cada una de estas teclas sería
simplemente así:
Procedure TForm1.btAbrirClick(Sender: TObject);
begin
OpenDialog1.Execute;
end;
procedure TForm1.btColorClick(Sender: TObject);
begin
ColorDialog1.Execute;
end;
procedure TForm1.btFuenteClick(Sender: TObject);
begin
FontDialog1.Execute;
end;
Página 3 de 4
Fuente: http://www.aprendeaprogramar.com/mod/resource/index.php?id=16
procedure TForm1.btGuardarClick(Sender:
TObject);
begin
SaveDialog1.Execute;
end;
Al pulsar el primero de los botones aparecería la ventana de
"Abrir" habitual en Windows:
(Nota: convendría que escribiésemos, desde el Inspector de
Objetos, en la propiedad "FileName" de nuestro "OpenDialog" el
valor "*.*", para que en la lista se nos muestren todos los
ficheros; también podríamos cambiar la lista de tipo de archivos
permitidos, con la popiedad "Filter").
Si queremos leer el nombre del fichero que se ha elegido (o
tecleado) en esta ventana, usaríamos construcciones como:
nombreFichero := OpenDialog1.Filename;
De formas similares podríamos leer la fuente (Font) que se ha
escogido en un FontDialog o el color de un ColorDialog.
Pero hay otro tipo de ventanas que son también muy
frecuentes en Windows. Son las ventanas de aviso,
información, etc., que muestran un mensaje y uno o varios
botones.
La más sencilla es simplemente una ventana que muestra un
texto, y en cuya barra de título aparece el nombre de nuestra
aplicación. Se accede a ella con "ShowMessage".
procedure TForm1.btSaludarClick(Sender:
TObject);
begin
ShowMessage( 'Hola!');
end;
y el resultado sería:
Principio de Computadoras I - 2011
• El primer texto es el que queremos que aparezca en la
ventana
• mtConfirmation es el tipo de ventana: una ventana que
pide confirmación y que muestra la palabra "Confirm" en
su barra de título y el dibujo. Otros ejemplos de valores
posibles son: mtWarning, mtError y mtInformation.
• mbYes, mbNo y mbCancel son los botones que
queremos que aparezcan. Se indica entre corchetes
porque se trata de un conjunto (set) de valores. Otros
ejemplos de valores posibles son mbOk, mbAbort,
mbRetry, mbIgnore, mbHelp o mbAll.
• Nos devuelve un valor, que podemos contrastar con
ciertas constantes predefinidas, como mrYes, mrNo,
mrCancel, mrOK, mrAbort, mrRetry, mrClose,
mrHelp.
Esta ventana quedaría así:
Eso sí, para los que hablamos español y hacemos programas
en español, esta ventana tiene un claro problema: tanto el título
como los botones están en inglés. Se debe a que son funciones
creadas por Delphi/Lazarus. Para que aparezcan en el idioma
que tengamos configurado en Windows, deberíamos emplear la
función del API de Windows llamada MessageBox. Un ejemplo
de su uso es:
resultado := Application.MessageBox('Confirme
que desea cambiar el color', 'Confirmación',
MB_OkCancel + MB_IconQuestion);
que devuelve un valor como IDOK o IDCANCEL, pero es más
incómoda de manejar, porque se trata de una función
inicialmente diseñada para ser usada desde lenguaje C, y los
parámetros de texto no son "strings" de Pascal, sino "pChar" (los
punteros a carácter típicos del lenguaje C), así que no daré más
detalles por ahora. Quien quiera saber más, puede consultar la
ayuda que incluye Delphi sobre el API de Windows (en Lazarus
hay mucha menos ayuda en línea, y además en la versión 0.9.22
de Lazarus este cuadro de mensaje también aparece en inglés).
Aun así, en Lazarus existe la posibilidad de traducir nosotros
mismos los textos que aparecen en los botones. Dichos textos se
encuentran (al menos en la versión 0.9.22) en el fichero
"lclstrconsts.pas", que está en la carpeta "lcl".
Otras ventanas algo más desarrolladas son las que aparecen
en Windows con una cierta frecuencia, mostrando un texto junto
con una admiración, un símbolo de stop, etc. Se accede a ellas
con MessageDlg. Un ejemplo de su uso sería el siguiente
código:
procedure TForm1.btPreguntarClick(Sender:
TObject);
var
Respuesta: integer;
begin
Respuesta := MessageDlg('¿Guardar los
cambios?', mtConfirmation,
[mbYes, mbNo, mbCancel], 0);
case Respuesta of
mrYes: (*GuardarCambios*);
mrNo: (*SalirSinGuardar*);
mrCancel: (*NoSalir*);
end;
end;
donde:
Página 4 de 4