Si intenta
cpan install Gtk2, estará obligado a tener instaladas antes las bibliotecas (código binario y código fuente) que necesita Gtk2 para compilarse (no es un módulo escrito en puro Perl). Necesitará Glib, Pango y Cairo, por lo menos. Y que tenga instalado un compilador de C, con un make, claro.
Es muchíiiisimo más cómodo usar el sistema de gestión de paquetes de su sistema operativo, que le ofrecerá una versión ya compilada de todo esto.
Por ejemplo: yo estoy ahora mismo en un OpenSuse v11.4 i586. Entonces...
1.- Arranco el panel de control YaST2 para la gestión de software (menú KDE, Máquina, Añadir/quitar programas).
2.- Me pide la contraseña de root. La pongo y sale el programa que gestiona todo el software en el sistema.
3.- En la cajita de búsqueda, pongo "Gtk2" y pulso en el botón
Buscar.
4.- En el montón de resultados que salen, aparece varios paquetes "perl-Gtk2". Selecciono el más básico, el que se llama solo "perl-Gtk2" (los demás añaden funcionalidades que ahora no necesito). Lo marco para instalar.
5.- Repito la búsqueda con la palabra "glade". Me sale un "glade3". Lo marco también para instalar.
6.- Al pulsar el botón de Instalar, el programa selecciona de forma automática los paquetes
libgladeui-1.9
perl-Cairo
perl-Glib
perl-Pango
perl-ExtUtils-Depends
perl-ExtUtils-PkgConfig
7.- Después de instalarlos, me falta un paquete importante: el Gtk2::GladeXML. Si fuera un módulo puro Perl, lo instalaría con el
cpanp (CPANPLUS), pero no lo es. Bueno, pues buscando un poco en el servicio Build de OpenSuse,
lo encuentro. Lo bajo y lo instalo.
Y ya está todo instalado. Falta por hacer alguna prueba. Entramos en /usr/share/doc/packages/perl-Gtk2-GladeXML/examples/, que es donde me ha dejado los ejemplos de Gtk2::GladeXML, y allí ejecuto los programas Perl que trae. Por ejemplo, el hello-world.pl:
Luego he arrancado el glade-3 y he diseñado un ejemplo muy sencillo, como el indicado en el manual en español, enlazado antes:
Lo guardo y me genera un archivo así:
Using xml Syntax Highlighting
<?xml version="1.0"?>
<glade-interface>
<!-- interface-requires gtk+ 2.20 -->
<!-- interface-naming-policy project-wide -->
<widget class="GtkWindow" id="ventana_principal">
<property name="title" translatable="yes">Mi primer programa</property>
<property name="resizable">False</property>
<property name="window_position">center</property>
<signal name="destroy" handler="on_ventana_principal_destroy"/>
<child>
<widget class="GtkVBox" id="vbox1">
<property name="visible">True</property>
<property name="orientation">vertical</property>
<property name="homogeneous">True</property>
<child>
<widget class="GtkLabel" id="label1">
<property name="visible">True</property>
<property name="label" translatable="yes">¡¡¡Hola Mundo!!!</property>
<property name="width_chars">20</property>
<property name="single_line_mode">True</property>
</widget>
<packing>
<property name="position">0</property>
</packing>
</child>
<child>
<widget class="GtkLabel" id="label2">
<property name="visible">True</property>
<property name="label" translatable="yes">Este es mi primer programa</property>
<property name="width_chars">20</property>
<property name="single_line_mode">True</property>
</widget>
<packing>
<property name="position">1</property>
</packing>
</child>
</widget>
</child>
</widget>
</glade-interface>
Coloreado en 0.002 segundos, usando
GeSHi 1.0.8.4
Ahora es cuando creamos el programa Perl, que he hecho copiando y pegando partes de dos ejemplos del manual:
Using perl Syntax Highlighting
#!/usr/bin/perl
use strict;
### Este modulo obtiene la información de la interfaz hecha en glade
### basándose en el archivo XML generado por este (le hace un parser).
### Los parámetros obtenidos se los pasa al módulo Gtk2.
use Gtk2::GladeXML;
### Módulo que recibe los parámetros obtenidos por Gtk2::GladeXML
### y genera las ventanas basándose en ellos.
use Gtk2 -init;
### Declaro las variables que usaré en el programa
### Si programas en Perl ya sabes a que me refiero ;-)
my($programa, $ventana_principal);
### Le estoy indicando la ruta (ubicación) donde se encuentra el archivo XML
### generado por Glade, del cual Gtk2::GladeXML analizará y extraerá
### los parámetros más importantes y se los facilitará al Gtk2. En base a esos
### parámetros se crea un objeto al que llamé "programa" el cual contendrá
### todos los widgets del programa e interactuará con este mediante los métodos
### predefinidos que contendrá cada widget.
$programa = Gtk2::GladeXML->new('hello.glade');
### Ahora estoy cargando la ventana principal al hacer esto
### esto se crea un objeto "ventana_principal" el cual nos permite
### interactuar con la ventana mediante métodos ya predefinidos.
$ventana_principal = $programa->get_widget('ventana_principal');
### Está línea lo que hace es levantar o permitir los manejadores
### de señales definidos en el XML generado por glade
$programa->signal_autoconnect_from_package('main');
### Por defecto (depende de la versión del módulo Gtk2::GladeXML
### tengas) no se muestra la ventana, se carga mas no se muestra
### Con el método show_all() hacemos que sea visible para el usuario
$ventana_principal->show_all();
### El loop del programa. Esto es para que el programa se
### quede abierto siempre esperando la interacción del usuario,
### ya sea cerrar la ventana, presionar un botón o cualquier acción.
Gtk2->main;
### Evento que se ejecuta cuando el usuario cierra la ventana
### Respondemos con un mensaje de cierre de toda la aplicación.
sub on_ventana_principal_destroy {
Gtk2->main_quit;
}
Coloreado en 0.003 segundos, usando
GeSHi 1.0.8.4
Y el resultado:
Y ya está...
Bueno... no es TAN sencillo... la primera vez que hice el programa, al cerrar la ventana, no terminaba el programa (por lo que entonces, la ventana no indicaba al programa que estaba siendo destruida, y porque el programa no sabía qué hacer en esa circunstancia).
Pero en el mismo manual, un poco más abajo, hablando de las señales, ya explica cómo hacerlo. En la captura anterior del glade-3 se observa dónde estoy definiendo el método Perl que hay que ejecutar cuando el objeto se destruya (on_ventana_principal_destroy). Y en el código Perl, debo activar la captura de las señales definidas en el fichero glade con los métodos definidos en el programa (con el método signal_autoconnect_from_package()). Ya solo queda definir el método on_ventana_principal_destroy() e indicar dentro de él, qué es lo que hay que hacer cuando el usuario cierre la ventana (en nuestro ejemplo, terminar el programa). (Todo esto es una gran diferencia con programar Glade con C, ya que allí no es necesario realizar esta operación de capturar señales y definir una subrutina, pues en C ya está definida, por defecto la subrutina gtk_main_quit(), por lo que la ventana cierra la aplicación de forma automática (esto es lo que se explica en el manual de Gtk2::GladeXML, junto con un pequeño truco para que programar en Perl sea casi lo mismo que en C)).
Lo dicho... hay que leer mucho... pero después las aplicaciones van saliendo rápidamente.