======Sviluppare con Libglade======

Autore: **//Fabio Di Matteo//** \\ Ultima revisione: **//20/04/2007//**

Lib glade permette di caricare una interfaccia grafica con le librerie gtk++ a partire da un file xml, consente quindi di non ricompilare tutto il programma per una semplice modifica apportata all'interfaccia. In più non è necessario un programmatore per disegnare l'interfaccia e quindi il lavoro può essere distribuito tra più persone. 
La creazione del file xml esula dal compito di questo articolo, a breve comunque sarà disponibile un tutorial su glade.

Cominciamo adesso con una serie di esempi commentati, riguardanti tutti i principali linguaggi di programmazione. 


====C====
<code C>

#include <gtk/gtk.h>                                                //includo le librerie gtk e glade.
#include <glade/glade.h>

GladeXML  *xml;                                                 //questo è il puntatore al file xml che contiene l'interfaccia  
GtkWidget *widget;                                              //questa variabile serve per recuperare di volta in volta il  
                                                                //  widget (ovvero l'oggetto ) che vogliamo usare

void
on_button1_clicked (GtkWidget *widget, gpointer user_data)      //questa è una callback ovvero una funzione associata ad un evento
{                                                               // per esempio la pressione di un pulsante 
      	
	widget = glade_xml_get_widget (xml, "entry1");//scrivo qualcosa nella entry
	gtk_entry_set_text (widget, "Ciao");
	    
	GtkWidget *window;
    	window = gtk_dialog_new (); //crea una finestra di dialogo vuota
	GtkWidget *label = gtk_label_new ("Esempio di dialogo");//Crea una label
    	gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),label, TRUE,
                        TRUE, 0); 	//assegna la label alla finestra di dialogo
    	
	gtk_widget_show (window); //mostra la finestra di dialogo 
	gtk_widget_show (label);  //mostra la label che sta sulla finestra
}

void on_window1_delete_event(GtkWidget *widget, gpointer user_data)        //altra callback associata alla chiusura della 
{                                                                         // finestra "window1"
    gtk_main_quit();
}

	 

int
main (int argc, char *argv[])
{
  	gtk_init (&argc, &argv);

      	/* Carica l'interfaccia dal file di glade */
      	xml = glade_xml_new ("interfaccia.glade", NULL, NULL);

      	/* connette tutti gli eventi dei widget alle rispettive funzioni */
   	 glade_xml_signal_autoconnect(xml);
	
      	/* Avvia il ciclo principale delle gtAvvia il ciclo principale delle gtk*/ 
	gtk_main ();

  return 0;

}

/*
Da compilare con:

 cc -o main main.c `pkg-config --cflags --libs libglade-2.0` -export-dynamic

*/
</code>
==Compilazione==
Adesso è possibile compilare il file tramite

'' cc -o main main.c `pkg-config --cflags --libs libglade-2.0` -export-dynamic''

 I flags per compilare il file vengono generati "al volo" dal programma pkg-config  grazie al comando `pkg-config --cflags --libs libglade-2.0`, invece l'opzione -export-dynamic serve ad autoconnetere i vari componenti dell'interfaccia (bottoni, etichette etc...) alla relativa callbacks che porta quasi lo stesso nome es: on_[nome widget]_[tipo di evento] (GtkWidget *widget, gpointer user_data) .  


====Python====
In Python si usa il pacchetto pygtk che contiene tutto quello che ci serve, anche i bindings per libglade.
Nel codice di seguito importerò alcuni moduli che in realtà non servono per far funzionare lo script python, ma sono utili nel caso in cui si voglia creare  un pacchetto indipendente compilato in bytecode con con "cx freeze", in modo tale che lo script funzioni pure nelle macchine in cui non sia installato python e le pygtk.
<code python>
#!/usr/bin/env python

import pygtk  		#solo per creare il pacchetto indipendente
import gtk
import gtk.glade
import atk  		#solo per creare il pacchetto indipendente
import gtk._gtk  	#solo per creare il pacchetto indipendente
import pango  		#solo per creare il pacchetto indipendente

class Application: 							 #crea la classe del mio programma
    
    def __init__(self): 						 # e' il costruttore della classe
        self.widgetTree = gtk.glade.XML('interfaccia/interfaccia.glade') #file xml con il disegno della gui
        self.widgetTree.signal_autoconnect(self)			 #connette i segnali di click etc..
    
    def on_frmMain_delete_event(self, widget, *args):			#funzione per la chiusura della finestra
        gtk.main_quit()
    
    def on_cmdUno_clicked(self, widget, *args):				#scrive ciao ciao C++ sulla textbox
        testo = self.widgetTree.get_widget('txtTesto')
        testo.set_text('Ciao ciao C++')

    def on_cmdDue_clicked(self, widget, *args):				#scrive Ciao ciao Freepascal sulla textbox
        testo = self.widgetTree.get_widget('txtTesto')
	testo.set_text('Ciao ciao FreePascal + Lazarus')

Application()								# usa la classe sopra creata
gtk.main()								# avvia le gtk 
</code>


====Perl====

<code perl>
#!/usr/bin/perl -w

use Glib qw(TRUE FALSE);
use Gtk2 '-init';    # '-init' significa che Gtk2->init viene richiamato all'inizio
use Gtk2::GladeXML;


use strict;
use vars qw($main_window);

sub ok_button_clicked
{
  my (undef, undef) = @_;  
  print "Hello world!.\n";

  Gtk2->main_quit;
}


sub gtk_main_quit
{
  Gtk2->main_quit;
  return TRUE;
}

  # Inizializziamo le gtk
  #Gtk2->init;

  # carichiamo l'interfaccia dal file glade
  $main_window = Gtk2::GladeXML->new('interfaccia.glade');

  
  #Connettiamo i segnali dell'interfaccia (o eventi) alle callbacks
  $main_window->signal_autoconnect_from_package('main');

  # avviamo il ciclo principale delle gtk
  Gtk2->main;

</code>


====C++ e gtkmm====
Un altro modo di usare libglade è quello di usare il c++ con una una libreria chiamata gtkmm, in questo modo si può creare un programma orientato ad oggetti in C++ .
<code c++> 
#include <gtkmm.h>
#include <libglademm/xml.h>
#include <iostream>

using namespace std;

void
ok_button_clicked()
{
  cout << "Hai cliccato." << endl;
  Gtk::Main::quit();
}

int
main (int argc, char *argv[])
{
  Glib::RefPtr<Gnome::Glade::Xml> main_window;
  Gtk::Main kit(argc, argv);

  // carico l'interfaccia
  main_window = Gnome::Glade::Xml::create("interfaccia.glade");

  // connetto i segnali all'interfaccia
  Gtk::Button& ok_button = 
    dynamic_cast<Gtk::Button&>( *main_window->get_widget("OKButton") );
  ok_button.signal_clicked().connect( sigc::ptr_fun(&ok_button_clicked) );

  // Avvia il ciclo principale ed esce quando chiudo la finestra
  Gtk::Dialog& dialog =
    dynamic_cast<Gtk::Dialog&>( *main_window->get_widget("MainWindow") );
  //dialog.signal_delete_event().connect( sigc::ptr_fun(&Gtk::Main::quit) );

  Gtk::Main::run( dialog );
  //Gtk::Main::run( );

  return 0;
}
</code>