gtkmm

Da Wikipedia, l'enciclopedia libera.
gtkmm
Finestra di esempio

Finestra di esempio
Sviluppatore The gtkmm Development Team
Ultima versione 2.10.10 (1 maggio, 2007)
Sistema operativo Multipiattaforma
Linguaggio C++
Genere Integrated development environment
Licenza LGPL
(Licenza libera)
Sito web www.gtkmm.org

gtkmm è l'interfaccia C++ ufficiale del popolare toolkit grafico GTK+. Include le typesafe callback e un completo set di widget facilmente estendibili grazie all'ereditarietà. Inoltre è possibile scrivere l'interfaccia di un programma con Glade, usando la libreria libglademm.

gtkmm è software libero, infatti è distribuito sotto la GNU Lesser General Public License (LGPL).

Nel 2007 è stato deciso che un'applicazione di GNOME può richiedere come dipendenza le gtkmm.[1]

Linguaggio[modifica | modifica sorgente]

gtkmm usa il linguaggio C++ e, al contrario del toolkit GTK+ scritto in C, permette di poter scrivere codice nativamente orientato agli oggetti. L'architettura infatti è disegnata per mezzo di classi, ogni widget è rappresentato da una classe che deriva da una classe soprastante. Ad esempio le finestre di dialogo (generiche) sono rappresentate dalla classe Gtk::Dialog che deriva dalla classe Gtk::Window (che a sua volta deriva da altre classi). Tutte le classi derivano dalla generica Gtk::Widget che pone la basi per la costruzione di tutte le rappresentazioni grafiche.

Inoltre il codice scritto risulta portabile per qualsiasi piattaforma senza che ciò comporti modifiche sostanziali.

Le gtkmm, al contrario del popolare toolkit Qt che usa una versione estesa del linguaggio C++ (una sorta di dialetto), predilige un uso standard del linguaggio. Ad esempio esistono delle strutture che sono ispirate alla STL.

Vantaggi rispetto alle GTK+[modifica | modifica sorgente]

I vantaggi rispetto al toolkit originale sono da attribuire alle innovazioni del C++ rispetto al C, infatti lavorando con le gtkmm si possono sfruttare le maggiori caratteristiche del linguaggio. Ad esempio i namespace, le già citate classi, gli iteratori, i template e la gestione delle eccezioni.

Il codice scritto per le gtkmm risulta più espressivo e meno complesso del puro codice per le GTK+. Di seguito è riportato un esempio che serve a definire il testo incluso in una label. Il primo è C, il secondo è C++:

gtk_label_set_text(GTK_LABEL(label), "ciao mondo"); /* stile GTK+ */
label.set_text("ciao mondo"); /* stile gtkmm */

Gestione degli eventi[modifica | modifica sorgente]

Gli eventi (come un click su un bottone o la pressione di un tasto) vengono gestiti mediante callback. gtkmm nativamente non li gestisce da sé, ma sfrutta la libreria libsigc++.

La gestione tipica di un segnale segue questo schema:

<widget>.<segnale>.connect(sigc::<tipo di funzione>(<indirizzo funzione>));

I tipi di funzione sostanzialmente sono due: le funzioni membro di una classe (mem_fun) o una funzione classica (ptr_fun). Inoltre è possibile gestire il valore di ritorno di una funzione, passare diversi argomenti alla stessa ed anche comporre (mediante sigc::compose) diverse funzioni. Un esempio reale potrebbe essere il seguente:

button.signal_clicked().connect(sigc::mem_fun(*this, &Window::on_button_clicked));

La funzione membro Window::on_button_clicked() verrà invocata ogni volta che il bottone "button" verrà premuto. (Ovviamente diamo per scontato che button sia l'instanziamento di una classe Gtk::Button o derivata).

Notare inoltre che se la funzione è un metodo, bisogna specificare l'oggetto su cui applicarla.

Esempio[modifica | modifica sorgente]

Un esempio più dettagliato è il seguente, il quale disegnerà sullo schermo una finestra con all'interno un pulsante con su scritto "Hello, World!" e ad ogni pressione dello stesso stamperà sul terminale la medesima scritta.

// Includiamo gli header relativi ai widget che dobbiamo utilizzare:
#include <gtkmm/button.h>
#include <gtkmm/window.h>
#include <gtkmm/main.h>
 
// Definiamo la nostra nuova classe Window che deriva da quella di default
class Window : public Gtk::Window {
public:
        Window();
        virtual ~Window() { }
 
protected:
        virtual void on_button_clicked(); // callback
 
        Gtk::Button     button;
};
 
// Costruttore della finestra:
Window::Window()
{
        set_title("Hello!");
        set_border_width(10); // bordo della finestra
        set_resizable(false);
 
        button.set_label("Hello, World!");
 
        // Gestiamo il segnale relativo al click su "button":
        button.signal_clicked().connect(sigc::mem_fun(*this, &Window::on_button_clicked));
 
        // Aggiungiamo il bottone alla finestra:
        add(button);
 
        // Adesso possiamo disegnare la nostra finestra con il pulsante all'interno:
        show_all();
}
 
// Metodo che risponderà al segnale di click. Stampa sul terminale "Hello, World!" e va a capo.
void Window::on_button_clicked()
{
                g_print("Hello, World!\n");
}
 
int main (int argc, char *argv[])
{
        // Creiamo un oggetto Main. Il costruttore di questo oggetto inizializza una sessione gtkmm e controlla 
        // gli argomenti passati al programma. Questa operazione è necessaria in ogni applicazione gtkmm
        Gtk::Main kit(argc, argv); 
 
        Window win; // Instanzia la nostra classe Window 
        kit.run(win); // Fa partire il gtkmm main loop. Esso terminerà alla chiusura della finestra
}

Il programma è compilabile sui sistemi unix-like con il seguente comando:

c++ `pkg-config --cflags --libs gtkmm-2.4` hello.cpp -o hello

Dipendenze[modifica | modifica sorgente]

Le gtkmm oltre a dipendere dalle GTK+ hanno bisogno di altre librerie di supporto. Infatti le GTK+ non gestiscono indipendentemente tutti gli aspetti di un'interfaccia grafica. Di seguito sono riportate le dipendenze delle gtkmm e indicate quelle indirette (cioè le librerie che fanno da base per i vari wrapper).

  • sigc++ - come abbiamo già visto, è la libreria che gestisce i segnali.
  • gdkmm - Libreria che gestisce gli aspetti più a basso livello (wrapper per le gdk)
  • glibmm - Aggiunge diverse funzioni e caratteristiche (come il supporto alle stringhe UTF-8, thread, puntatori intelligenti ecc.) (wrapper per le GLib)
  • pangomm - Si occupa della formattazione delle stringe (wrapper per Pango)
  • cairomm - Fornisce un'interfaccia di programmazione per la grafica vettoriale (wrapper per cairo)
  • atkmm - Permette di implementare caratteristiche utili all'accessibilità (wrapper per le ATK)

Inoltre è molto utile avere installato pkg-config, un software che fornisce un'interfaccia unificata per invocare le corrette librerie all'atto della compilazione del programma.

Altre librerie opzionali:

  • gnomemm
  • glademm

Nome[modifica | modifica sorgente]

Il nome gtkmm deriva da gtk minus minus. Secondo i canoni del C++, la libreria si sarebbe dovuta chiamare gtk++ ma essendo già presente un "+" nel nome del toolkit di base si è preferito usare gtk--. In seguito si decise di cambiare il nome in gtkmm in modo da risultare più rintracciabile sui motori di ricerca (infatti il "--" verrebbe ignorato).

Alcuni software basati sulle gtkmm[modifica | modifica sorgente]

Voci correlate[modifica | modifica sorgente]

Note[modifica | modifica sorgente]

  1. ^ (EN) Annuncio sulla mailing-list di GNOME per quanto riguarda l'uso di gtkmm come dipendenza

Collegamenti esterni[modifica | modifica sorgente]