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.

Listas (cuarta parte): Diversas funciones utiles

¿Es una Lista...?

 Para saber si un objeto es una lista o no, usamos la función Listp. Los valores devueltos pueden ser T (verdadero) o nil (falso).

 > (setq una-lista '("hola" "estoy a 200 km de casa" "vacaciones"))
("hola" "estoy a 200 km de casa" "vacaciones")

> (listp una-lista)
T

> (setq valor 38)
38

> (listp valor)
NIL

> (setq valor "grados")
"grados"

> (listp valor)
NIL

Lista vacía

La función null nos dirá si una lista esta vacía, es decir, que no tiene elementos. null devuelte T si la lista está vacía, caso contrario devuelte NIL. 

> (set 'lista '("hola" "como" "estas")
("hola" "como" "estas")

> (null lista)
NIL

> (set 'lista nil)
NIL

> (null lista)
T

Longitud de una lista

La longitud de una lista se obtiene con la función length:

> (setq una-lista '("uno" "dos" 3 "cuatro" 5.0 6e00))
("uno" "dos" 3 "cuatro" 5.0 6.0)

> (length una-lista)
6

Obtención de parte de una lista

subseq es una función común que se usa para devolver parte de una lista. Toma al menos dos argumentos, una lista y un entero que indica la posición desde donde empezar. También toma un tercer argumento optativo, un entero que indica la posición donde detenerse. Observe que la posición indicada por este tercer argumento no se incluye en el la sub-lista devuelta:

> (setq una-lista '("uno" "dos" "tres" "cuatro" "cinco"))
("uno" "dos" "tres" "cuatro" "cinco")

> (setq otra-lista (subseq una-lista 1 3))
("dos" "tres")

> (setq otra-lista (subseq una-lista 0 2))
("uno" "dos")

> (setq otra-lista (subseq una-lista 1))
("dos" "tres" "cuatro" "cinco")

Unir varias listas en una sola

Las listas se pueden unir con append:

> (setq lista-uno '(1 2 3 4 5 6))
(1 2 3 4 5 6)

> (setq lista-dos '("esto" "es" "una" "lista"))
("esto" "es" "una" "lista")

> (setq lista-tres '("Maria" "te" "amo"))
("Maria" "te" "amo")

> (setq lista-unica (append lista-uno lista-dos lista-tres))
(1 2 3 4 5 6 "esto" "es" "una" "lista" "Maria" "te" "amo")

Ordenar listas

Las listas se ordenan con sort:

> (setq lista-valores '(23 15 33 789 3 102 18))
(23 15 33 789 3 102 18)

> (sort lista-valores #'<)
(3 15 18 23 33 102 789)

> (sort lista-valores #'>)
(789 102 33 23 18 15 3)

El resto de una lista

La función rest devuelve la misma lista pero sin el primer elemento, es decir, devolverá el resto de la lista, luego de extraer el primer elemento. Su valor deberá ser almacenado debido a que rest es no destructiva:

> (set 'primos '(2 3 5 7 11 13 17 19 23))
(2 3 5 7 11 13 17 19 23)

> (set 'resto (rest primos))
(3 5 7 11 13 17 19 23)

Listas (tercera parte): Remover y Agregar elementos

Para remover elementos de una lista se usa la función remove:

> (setq una-lista '(15 33 "edad" 7/8))
(15 33 "hoy es domingo" 7/8)

 > una-lista
(15 33 "hoy es domingo" 7/8)

>  (remove 33 una-lista)
(15 "hoy es domingo" 7/8)

Se ha removido 33 de la lista. Sin embargo la función remove es no destructiva, por lo que no se ha modificado una-lista.

> una-lista
(15 33 "hoy es domingo" 7/8)


Por lo tanto deberíamos guardar la lista devuelta por la función:

> (setq una-lista (remove 33 una-lista))
(15 "hoy es domingo" 7/8)

> una-lista
(15 "hoy es domingo" 7/8)

Para agregar elementos se puede usar la función cons:

> (setq una-lista (cons "mañana es lunes..." una-lista))
("mañana es lunes..." 15 "hoy es domingo" 7/8)

> una-lista
("mañana es lunes..." 15 "hoy es domingo" 7/8)

Otra manera de agregar elementos es usando push. Una lista se puede tratar como una estructura de pila LIFO. Antes de poner cualquier valor, la lista debe tener algún elemento o estar vacía (tener el valor nil). 

Primero me aseguro de crear una lista vacía:

> (setf una-lista nil) 
NIL

> (push "hola" una-lista)
("hola")

> (push 23 una-lista)
(23 "hola")

> (push () una-lista)
(NIL 23 "hola")

> (push "te amo Maria" una-lista)
("te amo Maria" NIL 23 "hola")

> (push 8.5 una-lista)
(8.5 "te amo Maria" NIL 23 "hola")

Para sacar usamos pop:

> (pop una-lista)
8.5

Pero los valores que quitamos se perderían de no ser asignados:

> (setq hermosa (pop una-lista))
"te amo Maria"

> hermosa
"te amo Maria"

Listas (segunda parte) Acceder a los elementos de una lista

Para acceder al primer elemento se usa first:

> (setq una-lista '("uno" "dos" "tres" "cuatro" "cinco"))
("uno" "dos" "tres" "cuatro" "cinco")

> (setq cadena (first una-lista))
"uno"

Accede al primer elemento de la lista una-lista y guarda el valor devuelto en el simbolo cadena.

> cadena
"uno"

Para acceder al segundo y al tercero, second y third, respectivamente:

> (setq cadena (second una-lista))
"dos"

> (setq cadena (third una-lista))
"tres"

Para obtener cualquier elemento de una lista, se puede usar nth:

> (setq cadena (nth 4 una-lista))
"cinco"

> (setq cadena (nth 0 una-lista))
"uno"

> (setq cadena (nth 2 una-lista))
"tres"

Al primer elemento se accede con 0 al segundo con 1, y asi sucesivamente.

Para acceder al ultimo elemento de una lista se puede usar last:

> (setq cadena (last una-lista))
"cinco"

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.

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.

Listas (primera parte) Crear una lista

Para crear una lista se puede asignar una lista a un simbolo nuevo:

> (setf mi-lista '(6 "esto es una lista" nil T))
(6 "esto es una lista" nil T)

Otra forma es usando la función list:

> (setf (lista (list 34 5 78))
(34 5 78)

> lista
(34 5 78)

Setf es la forma mas general de asignación (que yo conozca). Asigna a un símbolo el resultado de la función que le sucede a continuación o un valor de cualquier tipo. En el primer ejemplo, 6 es un entero, "esto es una lista" es una cadena de caracteres y los valores nil y T son los equivalentes lógicos en lisp para FALSO y VERDADERO respectivamente.

También podés crear una lista vacía:

> (setf una-lista nil)

NIL

> una-lista
NIL