PDF de programación - Programando la interfaz gráfica con XPCE/Prolog

Ampliación de Lógica

Programando la interfaz gráfica con:

XPCE/Prolog



Pau Sánchez Campello
4rto Ingenieria en Informatica.


1.- Cargando la librería PCE


Para poder usar predicados para trabajar con gráficos bajo Prolog deberemos cargar
la librería PCE. Para cargar dicha librería pondremos la siguiente linea en cualquier parte
del archivo (preferiblemente al principio del mismo):



:- use_module(library(pce)).



Esta línea lo que hace es decirle a Prolog que cargue la librería una vez ha
terminado de compilar, antes de que desde el prompt de Prolog se nos deje hacer ninguna
consulta.


Una vez cargada esta librería, ya disponemos de una serie de predicados para poder

crear ventanas, botones, ... y una gran variedad de objetos.


2.- Creando objetos e interactuando con ellos


Con la librería PCE se trabaja con un esquema orientado a objetos, donde podremos
crear clases y trabajar con diferentes objetos, pudiendo llamar a métodos de dichos objetos
(pasándoles los correspondientes parámetros) o llamar a métodos que nos devuelvan algún
valor, y obviamente si creamos objetos, también podremos destruirlos.


Así pues principalmente existen 4 predicados con los que se puede trabajar con
XPCE/Prolog. Estos predicados sirven para crear objetos, enviar mensajes a objetos, recibir
mensajes de objetos y liberar la memoria de los objetos. Estos 4 predicados son:


?? new(?Reference, +NewTerm): Este predicado recoge dos parámetros, el
primero recogería la referencia que se le asigna al nuevo objeto, ya que new se
usa para crear objetos. El segundo parámetro le indicaría el objeto que se quiere
crear.


?? send(?Receiver, +Selector(...Args...)): El primer parámetro del predicado es una
referencia al objeto al que deseemos enviarle un mensaje. El segundo parámetro
indicará el método al que queremos invocar, lo cual indicaremos junto a los
argumentos que queremos enviarle al método.


?? get(?Receiver, +Selector(+Argument...), -Result): Los dos primeros parámetros
tienen el mismo significado que para send, sin embargo el último parámetro
sirve para recoger el valor que nos devuelva el método que hallamos invocado.


?? free(?Reference): libera la memoria asociada al objeto que se le indica en el

primer parámetro.


Las referencias se usan para saber a que objeto nos referimos, así pues cada objeto
que creemos deberá tener su propia referencia, ya que después toda memoria que
reservemos con new, será conveniente liberarla con free.


Prolog usa principalmente dos tipos de referencias, una que seria mediante las
variables típicas de prolog (una cadena que empiece por mayúscula, como Variable, Pepe,
....), y la otra forma es definir referencias con nombre, las cuales una vez definidas no
podremos volver a crear otra referencia para dicho nombre, ya que nos dará error en
ejecución. Estas últimas referencias resultan interesantes para acceder de forma global a un
mismo objeto, sin tener que pasar ningún tipo de parámetro. Estas variables se crean usando
el operador especial @ así pues, cualquier nombre que empiece por @ será una variable
asociada a ese nombre que le demos (por ejemplo, @pepe, @variable).


Cuando usemos las variables con nombre deberemos llevar especial cuidado ya que
deberemos liberarlas usando free antes de que finalice la evaluación del predicado, ya que
si volvemos a realizar la misma consulta, y volvemos a crear objetos usando esas mismas
variables, dará error y no dejará ejecutar.



Por ejemplo, para crear un dialogo que contenga un botón y que al pulsar sobre el

mismo cierre esa ventana:



ejemplo :-
/*
* Crea el objeto dialogo en la variable D
*/
new(D, dialog(‘Nombre del Dialogo’)),

/*
* Crea el objeto boton almacenandolo en la variable @boton de tal forma
* que al pulsar sobre el boton libere la memoria y cierre la ventana)
*/
new(@boton, button(‘Cerrar Dialogo’,

and(



message(D, destroy),
message(D, free),
message(@boton, free)))),



/*
* Inserta el botón en el diálogo
*/
send(D, append(@boton)),

/*
* Le envia el mensaje open al dialogo para que cree y muestre la ventana.
*/
send(D, open).


En este ejemplo podemos ver como se usan los predicados new, free y send, así
como podemos ver que aparecen otros como append, open y quit, que son métodos de la
clase dialog (de la cual hemos creado una instancia en la variable D usando el predicado
new).

Cuando pasamos parámetros en la creación o en la llamada a un método de un

objeto, estos métodos pueden tener dos tipos de parámetros, pueden tener parámetros
obligatorios y parámetros opcionales. La diferencia está en que si no indicamos
explícitamente un parámetro obligatorio XPCE generará un error, mientras que si no
definimos un parámetro opcional, entonces XPCE pondrá en su lugar la constante @default
cuyo valor ya es el que tenga definido por defecto ese método.


3.- Enviando mensajes


Como se puede observar, el primer parámetro indica quien es el receptor, en cuyo
caso, en el ejemplo anterior será siempre un objeto que previamente hemos creado con new.
El selector (el segundo parámetro), indicaría el nombre del método o la función o el
predicado al que se desea llamar, y los posteriores parámetros son los argumentos de esa
función.

Como nota importante cabe destacar que en esos parámetros únicamente pueden ir
objetos declarados en el XPCE, es decir, que no podemos poner una lista como tercer o
cuarto parámetro y esperar que se le pase esa lista a la función cuando sea llamada (al
menos en principio).


En el campo del receptor básicamente podemos especificar una variable que
hallamos inicializado con new, teniendo entonces que invocar necesariamente a un método
de ese objeto, o por el contrario, también se permite invocar a un predicado con sus
correspondientes parámetros (exceptuando listas y tipos no básicos que implemente el
XPCE), pero en este caso en el campo de receptor deberemos poner @prolog y en el
segundo parámetro el nombre del predicado y seguir rellenando con los argumentos.


Con ánimo de mostrar y entender mejor como funciona se puede ver el siguiente

Como hemos visto en el ejemplo,

determinados objetos pueden ejecutar
determinadas acciones, como puede ser el caso del objeto button, así pues, cuando
pulsamos en el botón, podemos hacer que se ejecuten una o mas acciones, en este caso que
se evaluen uno o más predicados.


Si únicamente queremos evaluar 1 predicado, podemos hacer uso del predicado:


message(receiver=object|function, selector=name|function, argument=any|function ...)



ejemplo:







% Crea un boton que llama al predicado mostrar_mensaje
new(B, button(‘Mostrar en Consola’,

message(@prolog, mostrar_mensaje, ‘Este es el valor que tendra la variable P’))),


% Crea un boton para cerrar el dialogo
new(@boton, button(‘Cerrar Dialogo’,

and(



message(D, destroy),
message(D, free),
message(D, free),
message(@boton, free)))),

% Inserta los botones en el diálogo
send(D, append(@boton)),
send(D, append(B)),

ejemplo_mensajes :-

% Crea el objeto dialogo en la variable D
new(D, dialog(‘Nombre del Dialogo’)),

% Muestre la ventana.
send(D, open).



% Muestra un mensaje en la consola.
mostrar_mensaje(P) :-


write(‘La variable P vale ’), write(P), nl.



4.- Creando elementos en el entorno grafico


Una vez explicados los conceptos básicos ya podemos crear objetos en el entorno
gráfico, tales como diálogos, textos, etiquetas, recuadros para dibujar, botones, etc...
además seguramente en este apartado se entenderá mejor el uso de todo lo anterior.


continuación enumeraré algunos de estos objetos y algunos de sus métodos.


Como hemos dicho anteriormente, podemos crear varios tipos de objetos, a

OBJETO

DESCRIPCION

dialog

button

cursor

figure

image

bitmap

pixmap

label

menu

Sirve para crear un cuadro de dialogo

Sirve para crear un boton

Sirve para modificar la imagen del cursor

Sirve para poner imágenes en pantalla

Sirve para cargar imágenes
Para convertir una imagen en un elemento gráfico
(basicamente hace de puente para pasar de image a figure)
Es practicamente equivalente a image
Para escribir una etiqueta por pantalla (puede servir para
mostrar un texto)
Para crear un menu

menu_bar

Para crear una barra de menus

menu_item

Para embeder elementos dentro de un menu

point

popup

slider

window

Para crear un punto con 2 cordenadas

Para crear un popup en una ventana.

Para crear un desplazador

Para crear una ventana donde se pueden dibujar otra serie de
objetos, como imágenes, etc...

De las clases citadas, únicamente describiré el constructor y algunos métodos de



algunas de ellas, y como usarlas o interaccionar con las demás clases.

DIALOG


Esta es la clase básica para crear dialogos.


Constructor:

dialog(label=[name], size=[size], display=[display])

name: indica el titulo a la ventana
size: es de tipo size y sirve para indicar el tamaño de la ventana
display: indica donde queremos que se visualize (mejor no tocar este parametro si

no sabemos que estamos haciendo)


Podemos observar que todos los parametros son opcionales, aunque siempre es

bueno ponerle un titulo a la ventana


Así, como ejemplo crearemos un dialogo con titulo ‘Titulo del dialogo’ y de tamaño

new(D, dialog(‘Titulo del Dialogo’, size(440, 320)) ),

440 x 320.