ecco un'altra memoria relativa a gtk:
in ogni applicazione gtk è presente almeno questa roba:
~ questa inclusione:
~ le funzioni che gestiscono gli eventi
~ il main, contenente tra le altre cose:
~ la funzione
che si occupa di inizializzare la libreria gtk; inoltre effettua il parsing dei seguenti parametri comuni a tutte le applicazioni gtk: --gtk-module, --g-fatal-warnings, --gtk-debug, --gtk-no-debug, --gdk-debug, --gdk-no-debug, --display, --sync, --name, --class. gtk_init() modifica poi argv e argc eliminando i parametri da lei processati.
~ il collegamento degli eventi e dei segnali alle funzioni di gestione (handler) definite dal programmatore
~ la chiamata
gtk_main ();
che mette il processo in attesa fino a quando non si verifica un evento (bottone premuto, ecc)
creazione degli oggetti
per creare un oggetto (come un bottone, una finestra, ecc) prima si dichiara il puntatore da utilizzare, di tipo GtkWidget
e poi gli si assegna l'indirizzo riportato dalla funzione di creazione, con un'istruzione del tipo, in questo caso per creare un bottone:
quando l'oggetto creato è pronto per essere mostrato, cioè quando sono state fatte tutte le operazioni necessarie su di esso (comprese le connessioni dei suoi eventi/segnali con gli handler), lo si annuncia a gtk in questo modo
il bottone in realtà sarà mostrato solo quando sarà mostrata la finestra che lo contiene.
tipi di dati
in genere con gtk si usano tipi di dati come gint al posto di int, gchar al posto di char, e così via. questi non sono altro che typedef fatte per aumentare la portabilità del codice.
connessione degli eventi e dei segnali con le funzioni di gestione.
gtk funziona per eventi. quando avviene un evento, la widget da cui proviene l'evento emette un segnale, che è possibile collegare ad una nostra funzione di gestione.
i segnali sono specifici per le widget, anche se ce ne sono alcuni ereditati da tutte le widget, tipo "destroy"
per collegare un segnale di una certa widget ad una funzione di gestione, si usa la funzione g_signal_connect, che ha il seguente prototipo:
dove: object è la widget sulla quale avviene l'evento, name è il nome del segnale da collegare con la funzione, func è il nome della funzione da collegare con l'evento, func_data è un puntatore ad eventuali parametri da passare alla funzione di gestione.
nota: la funzione restituisce un valore di tipo gulong, che è un intero lungo senza segno. questo valore identifica univocamente l'associazione appena fatta. questo valore, se salvato in una variabile, permette di rimuovere successivamente l'associazione fatta, tramite la funzione g_signal_handler_disconnect, che ha prototipo
la funzione func generalmente deve avere il seguente prototipo
dove a widget verrà assegnato (da gtk!) l'indirizzo della widget che ha emesso il segnale, mentre l'ultimo argomento, callback_data, punta ai dati puntati dall'argomento func_data della precedente funzione.
in alcuni casi invece che g_signal_connect è conveniente usare la funzione g_signal_connect_swapped, che è molto simile alla g_signal_connect:
l'unica differenza fra g_signal_connect_swapped e g_signal_connect sta nel fatto che la prima inverte il primo argomento con l'ultimo nella chiamata alla funzione func che quindi, usando questo modo per connettere il segnale con la funzione, avrà il prototipo così:
questo modo di connettere un segnale ad una funzione di gestione è utile quando la funzione di gestione a cui connettersi fa parte della libreria gtk e, come primo argomento, questa funzione prende la widget sulla quale deve agire e questa widget non è la stessa che ha emesso il segnale.
esempio:
questa funzione connette il click su un bottone con la funzione di distruzione della widget, che viene applicata all'intera finestra. in pratica, distrugge la finestra window. se invece che la versione _swapped si fosse usata la versione normale della funzione, avremmo distrutto il bottone button, oppure, per rimediare, avremmo dovuto creare una funzione di appoggio nella quale chiamare gtk_widget_destroy con parametro la finestra window.
le chiamate scritte in maiuscolo in genere sono delle macro che si occupano di fare i necessari cast ed i controlli sul tipo di dato, oltre ad aumentare la leggibilità del codice
è possibile collegare più funzioni di gestione con un singolo segnale di una widget. per farlo, è sufficiente scrivere altre chiamate alla funzione di connessione, indicando le varie funzioni di gestione. queste funzioni verranno chiamate da gtk nello stesso ordine in cui sono stati fatti i collegamenti con i segnali.
oltre agli eventi e segnali descritti sopra, ce n'è un insieme che riflette quelli del server X (comprende anche il drag-and-drop. vedere http://www.gtk.org/tutorial/x201.html per maggiori info.
alcuni eventi
l'evento "delete_event" si presenta quando il window manager comunica all'applicazione che deve terminare, ad esempio a seguito del click della x presente sulla finestra, nella barra del titolo.
se nella funzione che gestisce l'evento "delete_event" viene ritornato il valore TRUE l'applicazione continua a girare.
se invece viene ritornato il valore FALSE, causiamo l'emissione del segnale "destroy", che causa la chiamata della nostra funzione di gestione del segnale "destroy" (che, anche questa, sarà stata impostata con g_signal_connect).
alcune funzioni:
gtk_main_quit() causa l'uscita dall'applicazione
le seguenti quattro funzioni servono per abilitare / disabilitare temporaneamente la gestione dei segnali, sia per specifiche associazioni, sia per specifiche funzioni di gestione.
posizionamento degli oggetti.
il posizionamento degli oggetti in una finestra avviene grazie ad apposite widget per il posizionamento. queste widget sono invisibili. ad esempio le "box" permettono di contenere altre widget e disporle in senso verticale o in senso orizzontale sulla finestra, dall'alto verso il basso o da sinistra verso destra e viceversa. un altro modo per impacchettare le widget sono le "table".
BOX
Ad esempio per creare una box orizzontale si usa
per una box verticale invece
Per inserire delle widget in un box si usano le funzioni
e gtk_box_pack_end(), che prende gli stessi argomenti.
NB: l'argomento box deve essere passato facendo l'opportuno cast, usando la macro GTK_BOX().
la prima funzione posiziona le widget da sx a dx in una hbox e dall'alto al basso in una vbox, la seconda fa il contratrio.
nota: un oggeto può essere un container o una widget; molte widget sono anche dei container per altri oggetti. un esempio sono i button, che spesso contengono una label.
TABLE
anche con le tabelle si possono impacchettare le widget.
prima di tutto è necessario creare la widget table con questa funzione:
Le righe e le colonne sono numerate dall'angolo superiore sinistro, a partire da zero. ad ogni vertice (non ad ogni cella!!) corrisponde una coppia di numeri.
per piazzare una widget all'interno della tabella nella cella desiderata si usa questa funzione:
con xoptions ed yoptions si possono passare queste opzioni. per passarne + di una, si può usare l'OR bit a bit, cioè |
le opzioni possibili sono:
-GTK_FILL: la widget si espande fino ad occupare tutto lo spazio a disposizione nella cella
-GTK_SHRINK: la widget si riduce quando gli è allocato meno spazio del necessario. se non impostato, la widget non è visibile quando ha meno spazio del minimo. come funziona?!? boh!
-GTK_EXPAND: la table viene espansa fino ad occupare tutto lo spazio a disposizione nella finestra. non capisco perché questa opzione non venga impostata a livello globale... boh!
un modo + veloce per inserire una widget in una table, è con questa funzione che prende meno argomenti della precedente (gli argomenti hanno lo stesso significato)
usando questa funzione xoptions e yoptions sono impostati di default a GTK_FILL | GTK_EXPAND, mentre xpadding e ypadding sono impostati a zero.
per impostare lo spazio fra righe e colonne, si possono usare queste funzioni:
NOTA: per le colonne, lo spazio viene impostato a destra della colonna indicata, mentre per le righe viene impostato sotto la riga indicata.
per impostare globalmente lo spazio fra le righe e fra le colonne si usano queste due funzioni:
Nota: l'ultima riga e l'ultima colonna con queste due funzioni non ricevono spazi.
widget & casting
in generale quindi, per creare una widget in gtk si seguono questi passi:
con la funzione gtk_*_new() si crea la widget, poi si connettono in modo opportuno i segnali desiderati alle giuste funzioni di gestione, si impostano eventuali attributi alla widget, si impacchetta la widget in un contenitore ed infine la si mostra con gtk_widget_show().
gtk ha un suo sistema di type casting. i cast più frequenti sono questi:
G_OBJECT (object)
GTK_WIDGET (widget)
GTK_OBJECT (object)
GTK_SIGNAL_FUNC (function)
GTK_CONTAINER (container)
GTK_WINDOW (window)
GTK_BOX (box)
GTK_RADIO_BUTTON (widget)
ed in genere sono usati per fare il cast degli argomenti delle funzioni.
qui http://www.gtk.org/tutorial/x498.html è presente uno schema che riassume come sono "derivate" le varie widget e qui invece http://www.gtk.org/tutorial/x502.html elenca le widget senza finestra, per le quali per catturare gli eventi è necessario usare l'EventBox Widget
widget comuni:
* button
* toggle_button: sono bottoni che possono avere due stati. sono alla base dei radio_button e delle check_button, che derivano praticamente tutti i suoi metodi
la funzione
restituisce true o false a seconda se il button è giù (true) o su (false)
mentre
setta lo stato del button. di default prende false (bottone su).
* check_button: è derivata dal toggle_button e funziona allo stesso modo,cambia l'aspetto grafico
* radio_button: funzionano allo stesso modo dei toggle_button, solo che solo un di questi può essere selezionato in un certo istante. ci sono delle particolarità per la creazione: ecco alcune funzioni utili:
GtkWidget *gtk_radio_button_new( GSList *group );
GtkWidget *gtk_radio_button_new_from_widget( GtkRadioButton *group );
GtkWidget *gtk_radio_button_new_with_label( GSList *group, const gchar *label );
GtkWidget *gtk_radio_button_new_with_label_from_widget( GtkRadioButton *group, const gchar *label );
GtkWidget *gtk_radio_button_new_with_mnemonic( GSList *group, const gchar *label );
GtkWidget *gtk_radio_button_new_with_mnemonic_from_widget( GtkRadioButton *group, const gchar *label );
GSList *gtk_radio_button_get_group( GtkRadioButton *radio_button );
per creare il primo bottone, il gruppo da passargli non c'è, è NULL. una volta creato il primo bottone, ai successivi (per formare l'insieme), è necessario passargli il gruppo restituito dal primo bottone con l'ultima funzione riportata, oppure usare una delle varianti _from_widget e passare come argomento direttamente la widget (dalla quale viene estratto automaticamente il gruppo)
* adjustments: http://www.gtk.org/tutorial/c584.html
alcune funzioni utili ~ note su alcune widget
box = xpm_label_box ("info.xpm", "cool button");
xpm_label_box() serve per creare un box contenente un immagine e un'etichetta, da inserire in qualsiasi oggetto (come un bottone) che può essere un container.
La widget Button ha questi segnali:
* pressed - emitted when pointer button is pressed within Button widget
* released - emitted when pointer button is released within Button widget
* clicked - emitted when pointer button is pressed and then released within Button widget
* enter - emitted when pointer enters Button widget
* leave - emitted when pointer leaves Button widget
tobedone http://www.gtk.org/tutorial/c510.html
riferimenti: http://www.gtk.org/tutorial/index.html
in ogni applicazione gtk è presente almeno questa roba:
~ questa inclusione:
#include <gtk/gtk.h>
~ le funzioni che gestiscono gli eventi
~ il main, contenente tra le altre cose:
~ la funzione
gtk_init (&argc, &argv);
che si occupa di inizializzare la libreria gtk; inoltre effettua il parsing dei seguenti parametri comuni a tutte le applicazioni gtk: --gtk-module, --g-fatal-warnings, --gtk-debug, --gtk-no-debug, --gdk-debug, --gdk-no-debug, --display, --sync, --name, --class. gtk_init() modifica poi argv e argc eliminando i parametri da lei processati.
~ il collegamento degli eventi e dei segnali alle funzioni di gestione (handler) definite dal programmatore
~ la chiamata
gtk_main ();
che mette il processo in attesa fino a quando non si verifica un evento (bottone premuto, ecc)
creazione degli oggetti
per creare un oggetto (come un bottone, una finestra, ecc) prima si dichiara il puntatore da utilizzare, di tipo GtkWidget
GtkWidget* bottone;
e poi gli si assegna l'indirizzo riportato dalla funzione di creazione, con un'istruzione del tipo, in questo caso per creare un bottone:
bottone=gtk_button_new_with_label("Clicca qui");
quando l'oggetto creato è pronto per essere mostrato, cioè quando sono state fatte tutte le operazioni necessarie su di esso (comprese le connessioni dei suoi eventi/segnali con gli handler), lo si annuncia a gtk in questo modo
gtk_widget_show (button);
il bottone in realtà sarà mostrato solo quando sarà mostrata la finestra che lo contiene.
tipi di dati
in genere con gtk si usano tipi di dati come gint al posto di int, gchar al posto di char, e così via. questi non sono altro che typedef fatte per aumentare la portabilità del codice.
connessione degli eventi e dei segnali con le funzioni di gestione.
gtk funziona per eventi. quando avviene un evento, la widget da cui proviene l'evento emette un segnale, che è possibile collegare ad una nostra funzione di gestione.
i segnali sono specifici per le widget, anche se ce ne sono alcuni ereditati da tutte le widget, tipo "destroy"
per collegare un segnale di una certa widget ad una funzione di gestione, si usa la funzione g_signal_connect, che ha il seguente prototipo:
gulong g_signal_connect(
gpointer* object,
const gchar* name,
GCallback func,
gpointer func_data);
gpointer* object,
const gchar* name,
GCallback func,
gpointer func_data);
dove: object è la widget sulla quale avviene l'evento, name è il nome del segnale da collegare con la funzione, func è il nome della funzione da collegare con l'evento, func_data è un puntatore ad eventuali parametri da passare alla funzione di gestione.
nota: la funzione restituisce un valore di tipo gulong, che è un intero lungo senza segno. questo valore identifica univocamente l'associazione appena fatta. questo valore, se salvato in una variabile, permette di rimuovere successivamente l'associazione fatta, tramite la funzione g_signal_handler_disconnect, che ha prototipo
void g_signal_handler_disconnect(
gpointer object,
gulong id);
gpointer object,
gulong id);
la funzione func generalmente deve avere il seguente prototipo
void func(
GtkWidget* widget,
/* other signal arguments */
gpointer callback_data );
GtkWidget* widget,
/* other signal arguments */
gpointer callback_data );
dove a widget verrà assegnato (da gtk!) l'indirizzo della widget che ha emesso il segnale, mentre l'ultimo argomento, callback_data, punta ai dati puntati dall'argomento func_data della precedente funzione.
in alcuni casi invece che g_signal_connect è conveniente usare la funzione g_signal_connect_swapped, che è molto simile alla g_signal_connect:
gulong g_signal_connect_swapped(
gpointer* object,
const gchar* name,
GCallback func,
gpointer* callback_data );
gpointer* object,
const gchar* name,
GCallback func,
gpointer* callback_data );
l'unica differenza fra g_signal_connect_swapped e g_signal_connect sta nel fatto che la prima inverte il primo argomento con l'ultimo nella chiamata alla funzione func che quindi, usando questo modo per connettere il segnale con la funzione, avrà il prototipo così:
void func(
gpointer callback_data,
/* other signal arguments */
GtkWidget* widget);
gpointer callback_data,
/* other signal arguments */
GtkWidget* widget);
questo modo di connettere un segnale ad una funzione di gestione è utile quando la funzione di gestione a cui connettersi fa parte della libreria gtk e, come primo argomento, questa funzione prende la widget sulla quale deve agire e questa widget non è la stessa che ha emesso il segnale.
esempio:
g_signal_connect_swapped (G_OBJECT (button), "clicked", G_CALLBACK (gtk_widget_destroy), G_OBJECT (window));
questa funzione connette il click su un bottone con la funzione di distruzione della widget, che viene applicata all'intera finestra. in pratica, distrugge la finestra window. se invece che la versione _swapped si fosse usata la versione normale della funzione, avremmo distrutto il bottone button, oppure, per rimediare, avremmo dovuto creare una funzione di appoggio nella quale chiamare gtk_widget_destroy con parametro la finestra window.
le chiamate scritte in maiuscolo in genere sono delle macro che si occupano di fare i necessari cast ed i controlli sul tipo di dato, oltre ad aumentare la leggibilità del codice
è possibile collegare più funzioni di gestione con un singolo segnale di una widget. per farlo, è sufficiente scrivere altre chiamate alla funzione di connessione, indicando le varie funzioni di gestione. queste funzioni verranno chiamate da gtk nello stesso ordine in cui sono stati fatti i collegamenti con i segnali.
oltre agli eventi e segnali descritti sopra, ce n'è un insieme che riflette quelli del server X (comprende anche il drag-and-drop. vedere http://www.gtk.org/tutorial/x201.html per maggiori info.
alcuni eventi
l'evento "delete_event" si presenta quando il window manager comunica all'applicazione che deve terminare, ad esempio a seguito del click della x presente sulla finestra, nella barra del titolo.
se nella funzione che gestisce l'evento "delete_event" viene ritornato il valore TRUE l'applicazione continua a girare.
se invece viene ritornato il valore FALSE, causiamo l'emissione del segnale "destroy", che causa la chiamata della nostra funzione di gestione del segnale "destroy" (che, anche questa, sarà stata impostata con g_signal_connect).
alcune funzioni:
gtk_main_quit() causa l'uscita dall'applicazione
le seguenti quattro funzioni servono per abilitare / disabilitare temporaneamente la gestione dei segnali, sia per specifiche associazioni, sia per specifiche funzioni di gestione.
void g_signal_handler_block( gpointer object, gulong id );
void g_signal_handlers_block_by_func( gpointer object, GCallback func, gpointer data );
void g_signal_handler_unblock( gpointer object, gulong id );
void g_signal_handlers_unblock_by_func( gpointer object, GCallback func, gpointer data );
void g_signal_handlers_block_by_func( gpointer object, GCallback func, gpointer data );
void g_signal_handler_unblock( gpointer object, gulong id );
void g_signal_handlers_unblock_by_func( gpointer object, GCallback func, gpointer data );
posizionamento degli oggetti.
il posizionamento degli oggetti in una finestra avviene grazie ad apposite widget per il posizionamento. queste widget sono invisibili. ad esempio le "box" permettono di contenere altre widget e disporle in senso verticale o in senso orizzontale sulla finestra, dall'alto verso il basso o da sinistra verso destra e viceversa. un altro modo per impacchettare le widget sono le "table".
BOX
Ad esempio per creare una box orizzontale si usa
gtk_hbox_new(
gboolean homogeneous, //se true tutte le celle della box hanno la stessa dimensione.
gint spacing //è lo spazio presente fra una cella del box e l'altra
)
gboolean homogeneous, //se true tutte le celle della box hanno la stessa dimensione.
gint spacing //è lo spazio presente fra una cella del box e l'altra
)
per una box verticale invece
vertical boxes, gtk_vbox_new()
Per inserire delle widget in un box si usano le funzioni
gtk_box_pack_start(
GtkBox *box, //è il puntatore alla box in cui si impacchetta la widget
GtkWidget *child, //è la widget da impacchettare
gboolean expand, //se false, la cella del box viene ristretta fino ad avere le dimensioni minime consentite dalle widget che contiene; se true la cella del box ha le dimensioni massime consentite dal box
gboolean fill, //se expand è impostato a true: se fill è true, lo spazio extra delle celle è assegnato agli oggetti contenuti, altrimenti se false è lasciato vuoto, come padding. se expand è false questo parametro non ha effetto
guint padding //è lo spazio messo ai margini della widget
)
GtkBox *box, //è il puntatore alla box in cui si impacchetta la widget
GtkWidget *child, //è la widget da impacchettare
gboolean expand, //se false, la cella del box viene ristretta fino ad avere le dimensioni minime consentite dalle widget che contiene; se true la cella del box ha le dimensioni massime consentite dal box
gboolean fill, //se expand è impostato a true: se fill è true, lo spazio extra delle celle è assegnato agli oggetti contenuti, altrimenti se false è lasciato vuoto, come padding. se expand è false questo parametro non ha effetto
guint padding //è lo spazio messo ai margini della widget
)
e gtk_box_pack_end(), che prende gli stessi argomenti.
NB: l'argomento box deve essere passato facendo l'opportuno cast, usando la macro GTK_BOX().
la prima funzione posiziona le widget da sx a dx in una hbox e dall'alto al basso in una vbox, la seconda fa il contratrio.
nota: un oggeto può essere un container o una widget; molte widget sono anche dei container per altri oggetti. un esempio sono i button, che spesso contengono una label.
TABLE
anche con le tabelle si possono impacchettare le widget.
prima di tutto è necessario creare la widget table con questa funzione:
GtkWidget* gtk_table_new(
guint rows, //è il numero di righe della tabella
guint columns, //numero di colonne della tabella
gboolean homogeneous //se true tutte le celle della tabella hanno la stessa dimensione, che è quella della cella di dimensione maggiore. se false, ogni cella ha, in larghezza, la larghezza + elevata fra le celle della sua colonna, e in altezza l'altezza più elevata fra le celle della stessa riga.
)
guint rows, //è il numero di righe della tabella
guint columns, //numero di colonne della tabella
gboolean homogeneous //se true tutte le celle della tabella hanno la stessa dimensione, che è quella della cella di dimensione maggiore. se false, ogni cella ha, in larghezza, la larghezza + elevata fra le celle della sua colonna, e in altezza l'altezza più elevata fra le celle della stessa riga.
)
Le righe e le colonne sono numerate dall'angolo superiore sinistro, a partire da zero. ad ogni vertice (non ad ogni cella!!) corrisponde una coppia di numeri.
per piazzare una widget all'interno della tabella nella cella desiderata si usa questa funzione:
void gtk_table_attach(
GtkTable *table, //è il puntatore alla tabella in cui inserire la widget
GtkWidget *child, //è il puntatore alla widget da inserire nella cella
guint left_attach, //è l'indice del vertice sinistro della cella a partire dalla quale inserire la widget
guint right_attach, //è l'indice del vertice destro della cella fino alla quale inserire la widget
guint top_attach, //è l'indice del vertice superiore della cella a partire dalla quale inserire la widget
guint bottom_attach, //è l'indice del vertice inferiore della cella fino alla quale inserire la widget
GtkAttachOptions xoptions,
GtkAttachOptions yoptions,
guint xpadding, //il padding funziona come nelle box: lascia dello spazio vuoto fra la widget ed il bordo della cella, in orizzontale
guint ypadding //stessa cosa, in verticale
)
GtkTable *table, //è il puntatore alla tabella in cui inserire la widget
GtkWidget *child, //è il puntatore alla widget da inserire nella cella
guint left_attach, //è l'indice del vertice sinistro della cella a partire dalla quale inserire la widget
guint right_attach, //è l'indice del vertice destro della cella fino alla quale inserire la widget
guint top_attach, //è l'indice del vertice superiore della cella a partire dalla quale inserire la widget
guint bottom_attach, //è l'indice del vertice inferiore della cella fino alla quale inserire la widget
GtkAttachOptions xoptions,
GtkAttachOptions yoptions,
guint xpadding, //il padding funziona come nelle box: lascia dello spazio vuoto fra la widget ed il bordo della cella, in orizzontale
guint ypadding //stessa cosa, in verticale
)
con xoptions ed yoptions si possono passare queste opzioni. per passarne + di una, si può usare l'OR bit a bit, cioè |
le opzioni possibili sono:
-GTK_FILL: la widget si espande fino ad occupare tutto lo spazio a disposizione nella cella
-GTK_SHRINK: la widget si riduce quando gli è allocato meno spazio del necessario. se non impostato, la widget non è visibile quando ha meno spazio del minimo. come funziona?!? boh!
-GTK_EXPAND: la table viene espansa fino ad occupare tutto lo spazio a disposizione nella finestra. non capisco perché questa opzione non venga impostata a livello globale... boh!
un modo + veloce per inserire una widget in una table, è con questa funzione che prende meno argomenti della precedente (gli argomenti hanno lo stesso significato)
void gtk_table_attach_defaults(
GtkTable *table,
GtkWidget *widget,
guint left_attach,
guint right_attach,
guint top_attach,
guint bottom_attach
);
GtkTable *table,
GtkWidget *widget,
guint left_attach,
guint right_attach,
guint top_attach,
guint bottom_attach
);
usando questa funzione xoptions e yoptions sono impostati di default a GTK_FILL | GTK_EXPAND, mentre xpadding e ypadding sono impostati a zero.
per impostare lo spazio fra righe e colonne, si possono usare queste funzioni:
void gtk_table_set_row_spacing(
GtkTable *table,
guint row,
guint spacing
)
GtkTable *table,
guint row,
guint spacing
)
void gtk_table_set_col_spacing (
GtkTable *table,
guint column,
guint spacing
)
GtkTable *table,
guint column,
guint spacing
)
NOTA: per le colonne, lo spazio viene impostato a destra della colonna indicata, mentre per le righe viene impostato sotto la riga indicata.
per impostare globalmente lo spazio fra le righe e fra le colonne si usano queste due funzioni:
void gtk_table_set_row_spacings(
GtkTable *table,
guint spacing
)
GtkTable *table,
guint spacing
)
void gtk_table_set_col_spacings(
GtkTable *table,
guint spacing
)
GtkTable *table,
guint spacing
)
Nota: l'ultima riga e l'ultima colonna con queste due funzioni non ricevono spazi.
widget & casting
in generale quindi, per creare una widget in gtk si seguono questi passi:
con la funzione gtk_*_new() si crea la widget, poi si connettono in modo opportuno i segnali desiderati alle giuste funzioni di gestione, si impostano eventuali attributi alla widget, si impacchetta la widget in un contenitore ed infine la si mostra con gtk_widget_show().
gtk ha un suo sistema di type casting. i cast più frequenti sono questi:
G_OBJECT (object)
GTK_WIDGET (widget)
GTK_OBJECT (object)
GTK_SIGNAL_FUNC (function)
GTK_CONTAINER (container)
GTK_WINDOW (window)
GTK_BOX (box)
GTK_RADIO_BUTTON (widget)
ed in genere sono usati per fare il cast degli argomenti delle funzioni.
qui http://www.gtk.org/tutorial/x498.html è presente uno schema che riassume come sono "derivate" le varie widget e qui invece http://www.gtk.org/tutorial/x502.html elenca le widget senza finestra, per le quali per catturare gli eventi è necessario usare l'EventBox Widget
widget comuni:
* button
* toggle_button: sono bottoni che possono avere due stati. sono alla base dei radio_button e delle check_button, che derivano praticamente tutti i suoi metodi
la funzione
gboolean gtk_toggle_button_get_active (GtkToggleButton *toggle_button);
restituisce true o false a seconda se il button è giù (true) o su (false)
mentre
void gtk_toggle_button_set_active( GtkToggleButton *toggle_button, gboolean is_active );
setta lo stato del button. di default prende false (bottone su).
* check_button: è derivata dal toggle_button e funziona allo stesso modo,cambia l'aspetto grafico
* radio_button: funzionano allo stesso modo dei toggle_button, solo che solo un di questi può essere selezionato in un certo istante. ci sono delle particolarità per la creazione: ecco alcune funzioni utili:
GtkWidget *gtk_radio_button_new( GSList *group );
GtkWidget *gtk_radio_button_new_from_widget( GtkRadioButton *group );
GtkWidget *gtk_radio_button_new_with_label( GSList *group, const gchar *label );
GtkWidget *gtk_radio_button_new_with_label_from_widget( GtkRadioButton *group, const gchar *label );
GtkWidget *gtk_radio_button_new_with_mnemonic( GSList *group, const gchar *label );
GtkWidget *gtk_radio_button_new_with_mnemonic_from_widget( GtkRadioButton *group, const gchar *label );
GSList *gtk_radio_button_get_group( GtkRadioButton *radio_button );
per creare il primo bottone, il gruppo da passargli non c'è, è NULL. una volta creato il primo bottone, ai successivi (per formare l'insieme), è necessario passargli il gruppo restituito dal primo bottone con l'ultima funzione riportata, oppure usare una delle varianti _from_widget e passare come argomento direttamente la widget (dalla quale viene estratto automaticamente il gruppo)
* adjustments: http://www.gtk.org/tutorial/c584.html
alcune funzioni utili ~ note su alcune widget
box = xpm_label_box ("info.xpm", "cool button");
xpm_label_box() serve per creare un box contenente un immagine e un'etichetta, da inserire in qualsiasi oggetto (come un bottone) che può essere un container.
La widget Button ha questi segnali:
* pressed - emitted when pointer button is pressed within Button widget
* released - emitted when pointer button is released within Button widget
* clicked - emitted when pointer button is pressed and then released within Button widget
* enter - emitted when pointer enters Button widget
* leave - emitted when pointer leaves Button widget
tobedone http://www.gtk.org/tutorial/c510.html
riferimenti: http://www.gtk.org/tutorial/index.html
