Translate

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

lunes, 6 de octubre de 2014

Cargar una imagen en el canvas


Ok, ok, no se si vale la pena la publicación. Pero voy igual. Se pueden cargar imagenes dentro del canvas incluso fotos. Cargar gifs es sencillo, aqui muestro un ejemplo bastante tonto con una ventana y un botón para cargar la imagen.

Copie el texto de abajo en un archivo y guárdelo como "cargar-imagen.lisp" o como prefiera llamarlo. También puede descargarlo desde aquí: cargar-imagen.lisp. Obviamente debe descargar la imagen a cargar: test.gif . 





Y es necesario descargarse ltk.lisp indefectiblemente.

;-------------------------------------------------------------------------------------------------------------------------
(use-package :ltk)



(with-ltk() ; Ventana principal ---------------------------------
  (let*
      ((canvas (make-instance 'canvas))
       (boton (make-instance 'button :text "Cargar Imagen")))
 


    ; Eventos ---------------------------------------------------
    (bind boton "<Button-1>" (lambda (evento) ;carga una imagen en el canvas al presionar el boton
          (setf imagen (make-image)) ;crear imagen...
  (image-load imagen "~/Descargas/test.gif")
  (create-image canvas 0 0 :image imagen)))


    ; Configuraciones de widgets --------------------------------
 
    (configure canvas :width 100) ;tamaño del canvas
    (configure canvas :height 100)
   
    (minsize *tk* 280 280) ;detalles de la ventana
    (maxsize *tk* 280 280)
    (wm-title *tk* "Cargar imagen")

    (place canvas 50 50) ;ubicaciones de los widgets
    (place boton 100 200)))

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

Para ejecutarlo se necesita cargar primero ltk.lisp; y luego nuestro precioso programita:

> (load "~/Descargas/ltk.lisp")
> (load "~/Descargas/cargar-imagen.lisp")

Se mostrará el programa:




 Ojala le sea de utilidad. No olvide comentar. Saludos.

lunes, 11 de agosto de 2014

Juego de Damas

Solicito colaboradores para el proyecto, pues por razones de tiempo se ha estancado hace rato ya :-( . La interfaz usa LTK, el archivo es Damas.lisp. Interesados/as envíen mail a renealejandrocoronel@gmail.com. 

De todos modos se lo puede descargar sin necesidad de colaborar. Ya estaba haciendo las respuestas del ordenador pero habían surgido algunos problemas con eso. Para ejecutarlo simplemente escriba desde su interprete lisp preferido: 

> (load "~/Escritorio/mis-programas/ltk.lisp") 
> (load "~/Escritorio/mis-programas/damas.lisp") 
> (damas:main) 

 Obviamente que debe cambiar el directorio. Escucho sugerencias. Saludos.

jueves, 13 de febrero de 2014

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


Generar un menú

Como este tema no lo encontré por ninguna parte. Voy a mostrar como generar menúes con LTK en Common-Lisp. La ventana principal es un "toplevel" a la que debe asociarse un menú que será el maestro.

(setf menu-maestro (make-instance 'menu)

(configure *tk* :menu menu-maestro)

Deben generarse los submenues, que son los que contienen los títulos de cada conjunto de botones de menú. Supongamos que tenemos que generar menúes para un juego:

(setf menu-juego (make-instance 'menu
                                            :text "Juego"
                                            :master menu-maestro))

(setf menu-ayuda (make-instance 'menu
                                            :text "Ayuda"
                                            :master menu-maestro))

Ya estan los titulos de cada menú, lo único que falta ahora son los botones para cada menú, vamos a generarlos:
Para el menu "Juego":

(setf boton-juego-nuevo (make-instance 'menubutton
                                           :text "Nuevo Juego"
                                           :master menu-juego
                                           :command (lambda()
                                                                 (do-msg "Aquí va una función para generar un nuevo juego"))))
                                                             
(setf boton-salir (make-intance 'menubutton
                                :text "Salir"
                                :master menu-juego
                                :command (lambda() (setf *exit-mainloop* t))))

Para el menú Ayuda:

(setf boton-about (make-instance 'menubutton
                                  :text "Acerca de...
                                  :master menu-ayuda
                                  :command (lambda() (do-msg "Mi juego - Copyleft Cachito 2014"))))


Vamos a ver el programa completo:

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

(defpackage :mi-juego
   (:use :common-lisp :ltk)
   (:export #:main))

(in-package :mi-juego)

(defun main ()
   (setf *debug-tk* nil)
   (with-ltk ()
(let* ((menu-maestro (make-instance 'menu))
         (menu-juego (make-instance 'menu :text "Juego" :master menu-maestro))
         (menu-ayuda (make-instance 'menu :text "Ayuda" :master menu-maestro))
         (boton-juego-nuevo (make-instance 'menubutton
    :text "Juego nuevo"
    :master menu-juego
    :command (lambda ()
                                                                 (do-msg "Aquí va una función para generar un nuevo juego"))))
         (boton-salir (make-instance 'menubutton
      :text "Salir"
      :master menu-juego
      :command (lambda () (setf *exit-mainloop* t))))
 
         (boton-about (make-instance 'menubutton
      :text "Acerca de..."
      :master menu-ayuda
      :command (lambda () (do-msg "Mi juego - Copyleft Cachito 2014")))))

           (configure *tk* :menu menu-maestro)
           (wm-title *tk* "Mi juego")
           (minsize *tk* 300 200)
           (maxsize *tk* 300 200))))

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

Guardamos el programa en un archivo .lisp. Cargamos el LTK y luego nuestro programa.

> (load "c:/Descargas/ltk-0.98/ltk.lisp")
> (load "c:/mi-programa.lisp")

Esta dentro del paquete mi-juego, para ejecutarlo hacemos:

> (mi-juego:main)


miércoles, 12 de febrero de 2014

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

Antes que nada, me gustaría recordar que para utilizar LTK es necesario tener instalado tcl/tk 8.5 o superior en tu ordenador. Para Windows o Mac OS X puedes descargarlo desde http://www.activestate.com/activetcl/downloads. En las plataformas linux suele venir instalado por defecto, aunque no siempre viene con la última versión disponible, por lo tanto se puede descargar desde la dirección antes citada o bien instalarlo desde el gestor de paquetes Synaptic o desde terminal usando comandos. En Debian/Ubuntu es:

> sudo apt-get install tcl8.5

Y luego:

> sudo apt-get install tk8.5

Es fundamental descargarse el LTK - The Lisp Toolkit desde http://www.peter-herth.de/ltk/ltk-0.98.tgz. Descomprimir el archivo y cargar el ltk.lisp desde nuestro interprete lisp:

> (load "c:/Descargas/ltk-0.98/ltk.lisp")

Para probar que todo funciona correctamente, tenemos que estar dentro del paquete ltk:

> (in-package :ltk)

> (ltktest)

Y nos muestra una ventana con varios widgets funcionando.


Configurar Aspectos de la Ventana

Se puede cambiar el titulo de la ventana, su tamaño mínimo y máximo por ejemplo, todo esto a través de las funciones de administración de ventanas. Aquí muestro algunas de ellas:


Función
Descripción
(wm-title toplevel titulo) Establece el título de la ventana
(minsize toplevel ancho alto) Establece el tamaño mínimo de la ventana en píxeles
(maxsize toplevel ancho alto) Establece el tamaño máximo de la ventana en píxeles
(on-close toplevel funcion) Establece la función que será llamada al presionar el botón cerrar en la ventana
(on-focus toplevel funcion) Llama a función cuando la ventana adquiere el foco.
"toplevel" es la ventana que puede crearse como una instancia. La ventana por defecto es *tk*, de este modo, si intentas cambiar el título de la ventana puedes usar la función:

(wm-title *tk* "Este es el nuevo título")

El resto de las funciones puede verse en el documento "ltkdoc.pdf" que se encuentra en el archivo ltk-0.98.tgz. 

Veamos un ejemplo concreto:

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

(load "ltk.lisp")

(use-package :ltk)

(defun ventana ()
   (with-ltk()
        (let*
             ((boton-1 (make-instance 'button
                                                    :text "Mensaje"
                                                    :command (lambda()
                                                                                (do-msg "Holaaaaaa....")))))

          (wm-title *tk* "Ventanita")
          (minsize *tk* 300 200)
          (maxsize *tk* 300 200)
          (place boton-1 50 50))))

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

Podemos guardarlo en un archivo "ventana.lisp" o el nombre que quieras. Lo cargas y lo ejecutas:

> (load "ventana.lisp")
> (ventana)

Nos mostrará la ventana:


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.