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.

Listas de propiedades

Las listas de propiedades son parecidas a los registros en otros lenguajes. Lo que se llama "campos" para otros lenguajes en common lisp son propiedades.

Veamos unos ejemplos:

> (setf pelota '(:color "blanco" :diametro 25 :material "cuero"))

Pelota tiene distintas propiedades como color diámetro y material. Veamos otro:

> (setf mi-moto '(:marca "Zanella" :modelo "Custom Patagonian Eagle" :cilindrada 150 :kilometros 4000 :precio 12000))
(:MARCA "Zanella" :MODELO "Custom Patagonian Eagle" :CILINDRADA 150 :KM 4000 :PRECIO 12000)

Para obtener el valor de una propiedad, usamos la función getf:

> (getf mi-moto :modelo)
"Custom Patagonian Eagle"

La función getf nos devuelve el valor de la propiedad, para ser utilizadas como argumento de otra función o almacenarse en un símbolo (de todas formas, al almacenarse termina usándose como argumento de otra función: "setf")

> (setf modelo (getf mi-moto :modelo))

En modelo queda el valor "Custom Patagonian Eagle".

Para modificar un valor de la lista de propiedades usamos "setf" con "getf" a la vez. Supongamos que queremos modificar el precio de "mi-moto":

> (setf (getf mi-moto :precio) 13000)
13000

Ok! :-P Si consultamos ahora nuestra lista de propiedades, veremos:

> mi-moto
(:MARCA "Zanella" :MODELO "Custom eagle" :CILINDRADA 150 :KM 4000 :PRECIO 13000)

Se puede guardar cada lista de propiedades en una lista, para tener una base de datos sencilla, que podría guardarse en un archivo, y tener funciones para búsqueda y filtros, etc. Las posibilidades son infinitas.

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.

La Completa Guía para Idiotas sobre Paquetes de Common Lisp

Traduje este documento que a pesar de su título, trata sobre algunos de los fundamentos de Common Lisp. El documento explica de forma sencilla y rápida lo que es fundamental conocer sobre paquetes y la utilidad que ofrecen estos. Saludos :-)

Aquí dejo la guía para descargar: paquetes.pdf

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)

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: