Translate

Mostrando entradas con la etiqueta Interfaz. Mostrar todas las entradas
Mostrando entradas con la etiqueta Interfaz. Mostrar todas las entradas

viernes, 2 de noviembre de 2012

Crear Interfaces Gráficas en Lisp con LTK (cuarta parte)

Responder a Eventos

Para responder a eventos como ratón o teclado, etc. se puede usar bind, la sintaxis del comando es asi:

> (bind nombre-control "<nombre-evento>" (función))
Nota: En LTK los controles son llamados "widgets"

Los nombres de los eventos van encerrados siempre entre dobles comillas "" y los caracteres < y >. Por ejemplo, para cambiar de color una etiqueta cada vez que se entra con el puntero del ratón:

> (bind etiqueta "<Enter>" (lambda(x) (configure etiqueta :foreground "green")))

Si queremos que se produzca una acción, luego de haber presionado el botón izquierdo del ratón:

> (bind boton "<Button-1>" (lambda(x) (do-msg "te amo Maria")))

Que nos muestra un bonito mensaje, al presionar un botón
El siguiente ejemplo nos muestra algunos eventos comunes:

Para probarlo, copie el siguiente texto y guárdelo en un archivo "eventos.lisp" luego carguelo o ejecutelo con su lisp.

;;;----------------------------------------------------------------------------------------------------------------

(load "~/ltk-0.96/ltk.fas")           

(use-package :ltk)                       


(with-ltk()                           
    (let* ((entrada (make-instance 'entry :width 20))       
           (etiqueta (make-instance 'label :text "Gol de Messi"))
       (marco (make-instance 'frame))                 
       (boton (make-instance 'button :master marco :text "Aceptar"))) 
             

      (bind etiqueta "<Enter>" (lambda(x) (configure etiqueta :foreground "green")))   
      (bind etiqueta "<Leave>" (lambda(x) (configure etiqueta :foreground "red")))   
      (bind boton "<Button-1>" (lambda(x) (do-msg "te amo Maria")))              
      (bind etiqueta "<Double-Button-1>" (lambda(x) (do-msg "Doble click del ratón")))       
      (bind boton "<Button-3>" (lambda(x) (do-msg "Botón derecho del ratón")))   
      (bind boton "<Button-2>" (lambda(x) (do-msg "Botón central del ratón")))
      (bind entrada "<Key-a>" (lambda(x) (do-msg "Has presionado la tecla a")))            
      (bind entrada "<Key-t>" (lambda(x) (do-msg "Has presionado la tecla t"))) 
      (bind entrada "<Control-Key-t>" (lambda(x) (do-msg "Has presionado Ctrl + t")))
      (bind entrada "<Control-Alt-Key-m>" (lambda(x) (do-msg "Has presionado Ctrl + Alt + m")))
      (bind entrada "<Escape>" (lambda(x) (do-msg "Has presionado la tecla Escape")))

      (pack etiqueta)                       
      (pack entrada)                       
      (pack marco)                       
      (pack boton)                       
      (configure marco :borderwidth 3)               
      (configure marco :relief :raised)))           
  
;;;----------------------------------------------------------------------------------------------------------------
    



- Esto de los eventos, me da curiosidad...

La siguiente tabla muestra los eventos y sus modificadores:



Evento
Descripción
Modificadores
(los modificadores van separados entre guiones "-" )
ButtonPres, Button, B Se ha presionado uno de los botones del ratón. "<Button-1>": Se presiona el botón izquierdo del ratón
"<Button-2>" Se presiona el boto central del ratón
"<Button-3>" Se presiona el botón derecho del ratón
Double: Doble click con uno de los botones del ratón.
Ejemplo:
"<Double-Button-1>": Doble click con el botón izquierdo
Triple: Triple click con uno de los botones del ratón.
Buttonrelease Se ha dejado de presionar uno de los botones del ratón.

Configure El control ha cambiado de tamaño, posición, etc.

Destroy El control ha sido destruido

Enter El puntero del ratón ha entrado en el control

Leave El puntero del ratón ha abandonado el control

FocusIn El control ha tomado el foco.

FocusOut El control ha perdido el foco.

KeyPress, Key, K Se ha presionado una tecla. Va acompañado de la tecla que se presiona, por ejemplo:
"<Key-a>" "<Key-b>" "<Key-m>"
Los modificadores son: Control, Shift, Lock y Alt para las teclas: control, mayúsculas, bloqueo de mayúsculas y Alt, respectivamente. Ejemplos:
"<Control-Key-t>" Se ha presionado Control + t.
"<Shift-Key-b>" Se ha presionado Shift + b.
"<Control-Alt-Key-m>" Se ha presionado Control + Alt + m.
También existen unas teclas ya definidas, tales como:
"<Return>", "<Escape>", "<BackSpace>", "<Tab>", "<Up>", "<Down>", "<Left>", "<Right>", etc.
KeyRelease Se ha soltado la tecla presionada.

Motion El puntero del ratón se mueve sobre el control.

Map La ventana ha sido desplegada.

Unmap La ventana ha sido iconificada.


En este sitio hay un tutorial muy bueno sobre LTK de una universidad española:
 tutorial - capitulo 12

Saludos, comenten :-P

martes, 17 de julio de 2012

Crear Interfaces Graficas en Lisp con LTK (tercera parte)


Voy a mostrar un ejemplo de una aplicación con interfaz grafica:

cortar aqui
;----------------------------------------------------------------------------------------------------------------

(load "~/Descargas/ltk-0.96/ltk.fas")            ;cargo ltk desde la ruta donde lo guarde :)

(use-package :ltk)                        ;para usar los paquetes ltk


(with-ltk()                           
    (let* ((entrada (make-instance 'entry :width 20))        ;crea cuadro de entrada de ancho 20
           (etiqueta (make-instance 'label :text "Gol de Messi")) ;crea etiqueta
       (marco (make-instance 'frame))                  ;crea marco
       (boton (make-instance 'button :master marco :text "Aceptar"  ;crea boton dentro de marco
        :command (lambda() (do-msg "te amo Talia :-)")))))      ;al pulsar envia un mensaje


      (pack etiqueta)                     ;coloca la etiqueta dentro del form
      (pack entrada)                     ;coloca el cuadro de entrada
      (pack marco)                       ;coloca el marco
      (pack boton)                        ;coloca el boton
      (configure marco :borderwidth 3)                ;ajusta el ancho del borde del marco
      (configure marco :relief :raised)                ;ajusta el estilo del marco
        
      ))

;-------------------------------------------------------------------------------------------------------------

Se copia el texto de arriba en un archivo y se guarda como "ejemplo.lisp"
Para ejecutarlo (con clisp) se abre una terminal y se teclea:

> clisp ~/ejemplo.lisp



No debería ser muy distinto con otros sistemas Lisp. Obviamente se debe  colocar la ruta completa donde quedó guardado el archivo.
Mas adelante veremos como manejar eventos como hacer click con el mouse sobre un objeto, pasar con el raton por encima, presionar una tecla, etc.

martes, 10 de julio de 2012

Crear Interfaces Gráficas en Lisp con LTK (Segunda parte)

Voy a mostrar algunos ejemplos de interfaces graficas. Son ejemplos tontos que escribí hace ya algun tiempo experimentando con LTK. Es nada mas que para mostrar las funcionalidades.

Con el archivo ltk.fas previamente cargado y estando dentro del paquete ltk, cargamos el archivo hola.lisp.

Que podes descargarlo desde aca:  hola.lisp

1. Entra al Lisp:
> clisp
>

2. Ahora carga el ltk.fas:

> (load "~/Descargas/ltk.fas")

3. Tenes que estar dentro del paquete ltk:

> (in-package :ltk)

4. Carga el archivo hola.lisp que descargaste:

> (load "~/Descargas/hola.lisp")

5. Ya está. Listo para probar los ejemplos

> (hola-1)
-----------------------------------------
> (hola-2)
-----------------------------------------
> (test)
-----------------------------------------
> (test-2)
-----------------------------------------
> (test-3)
Y asi sucesivamente, hasta test-6 inclusive.
 
Dentro del archivo de texto "hola.lisp" podes ver el codigo de los ejemplos con cualquier editor de textos. Ok, :-) 
Aquí una guía en ingles para ltk, ltk.doc.

sábado, 7 de julio de 2012

Crear Interfaces Gráficas en Lisp con LTK (primera parte)

Como este tema esta ya muy bien explicado en http://lispinspain.blogspot.com.ar/2008/09/primeros-pasos-con-ltk-parte-1.html no voy a ahondar en muchos detalles. Sin embargo voy a explicar como descargar e instalar las librerías LTK de forma sencilla, debido al hecho de que la instalacion mediante asdf-install ha quedado obsoleta en la actualidad.
Estas librerías nos permitiran generar ventanas, crear botones, y todo tipo de controles.

a. Instala tcl/tk 8.5

Si tenes alguna distribución linux, hay que instalar primero los paquetes tcl8.5 y tk8.5. Voy a mostrar la instalación en ubuntu:

Abri una terminal y logueate como administrador:

> sudo su

Instala los paquetes con apt-get, o con algun gestor de paquetes.

> apt-get install tcl8.5

> apt-get install tk8.5

Si tu sistema operativo es Windows puedes descargar e instalar la última versión de ActiveTcl desde: https://www.activestate.com/activetcl/downloads
Asegurate de tener el sistema operativo actualizado, prueba ejecutar c:\ActiveTcl\bin\wish.exe y te aparecerá una ventana vacía. Si da error debes actualizar Universal C Runtime: https://support.microsoft.com/es-ar/help/2999226/update-for-universal-c-runtime-in-windows

b. Descarga las librerias LTK

Se puede descargar desde: http://beta.quicklisp.org/archive/ltk/2011-07-30/ltk-0.96.tgz

O desde mi cuenta de box: https://www.box.com/s/e2d42ef29fd4d3c34150

c. Descomprime los archivos


d. Compilar el archivo "ltk.lisp"

Entre los archivos que descomprimiste hay uno llamado "ltk.lisp", hay que compilarlo. Ejecuta tu lisp en una terminal y manos a la obra.

> (compile-file "~/Descargas/ltk-0.96/ltk.lisp")

e. Cargar "ltk.fas"
 

Luego de haberse compilado se genera el archivo "ltk.fas". Hay que cargarlo:

> (load "~/Descargas/ltk-0.96/ltk.fas")

f. Ingresar al paquete ltk

Hay que estar en el paquete ltk para cargar los programas:

> (in-package :ltk)

g. Probar que todo funciona

Para probar que todo funciona correctamente hay unos test:

> (ltk::ltk-eyes)

Debería mostrarnos una ventana con ojos que siguen al ratón.

> (ltktest)
Nos muestra una ventana con algunos controles.