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: