hds619.net » Blog

Salve a tutti, continuiamo finalmente dopo tanto tempo con la guida alle gtk+ parlando delle preannunciate toolbar. Gestirle è molto molto semplice.

La creazione avviene tramite la funzione gtk_toolbar_new () che non riceve argomenti e ritorna un puntatore a GtkWidget che altro non è che la toolbar.

Una volta ottenuta si possono settare alcune opzioni:

• gtk_toolbar_set_show_arrow (): questa funzione riceve come argomenti la toolbar e un valore booleano ( TRUE o FALSE, FALSE è l’attributo predefinito ) che permette di visualizzare una freccia nel caso gli elementi inseriti nella toolbar non siano visualizzabili ( ad esempio quando viene ridimensionata la finestra ). Se questo attributo non è presente la finestra non potrà essere ridimensionata meno della larghezza della toolbar.
• gtk_toolbar_set_orientation (): anch’essa riceve due argomenti come la precedente, il primo è sempre la toolbar mentre il secondo è l’orientamento che vogliamo abbia. I valori disponibili son soltanto due: GTK_ORIENTATION_HORIZONTAL  e GTK_ORIENTATION_VERTICAL ( il predefinito è GTK_ORIENTATION_HORIZONTAL ).
• gtk_toolbar_set_icon_size (): con questa funzione possiamo stabilire la dimensione predefinita delle icone degli elementi della toolbar. I valori disponibili sono GTK_ICON_SIZE_INVALID, GTK_ICON_SIZE_MENU, GTK_ICON_SIZE_SMALL_TOOLBAR, GTK_ICON_SIZE_LARGE_TOOLBAR, GTK_ICON_SIZE_DND, GTK_ICON_SIZE_DIALOG.
• gtk_toolbar_set_style (): permette di stabilire lo stile della toolbar passata come primo parametro. Gli stili disponibili sono:
  • GTK_TOOLBAR_ICONS: visualizza solo le icone nella toolbar.
  • GTK_TOOLBAR_TEXT: visualizza solo il testo nella toolbar.
  • GTK_TOOLBAR_BOTH: visualizza il testo e le icone nella toolbar ( il testo sarà sotto le icone ).
  • GTK_TOOLBAR_BOTH_HORIZ: visualizza il testo e le icone nella toolbar ( il testo sarà a fianco le icone ).

Una volta impostati gli attributi alla toolbar possiamo procedere all’inserimento degli elementi. Come elementi abbiamo i pulsanti normali, i toggled, i separatori, ecc..

Prosegui la lettura…

Bene continuiamo con i menu e le gtk+, come detto l’ultima volta, in questa puntata vediamo un po’ di funzioni che ho creato tempo fa e una tecnica che uso per aggiungere un po’ di elementi ai vari menu in modo semplice.

L’header aggiuntivo probabilmente richiesto sarà:
#include

La prima che andiamo a vedere serve per inserire un menu con l’icona e il testo di una GTK_STOCK:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

GtkWidget *
menu_stock_append (GtkMenu * menu, const char *stock_id, GCallback func,
                   GtkAccelGroup * accel_group, unsigned int accel_id,
                   GdkModifierType mod_type, char *tooltip)
{
  GtkWidget *widget;
 
  widget = gtk_image_menu_item_new_from_stock (stock_id, accel_group);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), widget);
  gtk_widget_show (widget);
 
  if (func)
    g_signal_connect (G_OBJECT (widget), "activate", func, NULL);
 
  if (accel_id && accel_group)
    gtk_widget_add_accelerator (widget, "activate", accel_group, accel_id, mod_type, GTK_ACCEL_VISIBLE);
 
  if (tooltip)
    gtk_widget_set_tooltip_text (widget, tooltip);
 
  return widget;
}

Parametri:

1. GtkMenu *menu: il widget riguardante il menu in cui inserire l’elemento convertito in GtkMenu tramite la macro GTK_MENU
2. const char *stock_id: la GTK_STOCK scelta da inserire nel menu
3. GCallback func: la funzione da collegare al click sull’elemento ( oppure NULL ) convertita tramite la macro G_CALLBACK
4. GtkAccelGroup * accel_group: il gruppo di acceleratori ( scorciatoie da tastiere ) in cui varranno inserite le scorciatoie di questo elemento ( ne riparliamo meglio dopo ) o NULL se non si vuole usare nessuna scorciatoia.
5. unsigned int accel_id: il tasto da assegnare alla scorciatoia ( tipo la lettera R, anche di questo ne riparliamo meglio dopo )
6. GdkModifierType mod_type: il tipo di “maschera” da associare alla lettera per la scorciatoia, ad esempio si può scegliere il CTRL come maschera e per richiamare la scorciatoia da tastiera con i due esempi sopra riportati dobbiamo premere CTRL + R
7. char *tooltip: Il suggerimento da visualizzare nel caso il mouse si fermi più di un tot di secondi sull’elemento o NULL se non lo si vuole inserire.

Questa funzione ritorna l’elemento che la funzione ha inserito nel menu può essere usato per disabilitare\abilitare quell’elemento, se non si deve eseguire nessuna operazione la variabile ritornata può anche essere ignorata.

La funzione che segue è anch’essa molto simile a quella appena mostrata, tranne per il fatto che della GTK_STOCK passata usa solo l’immagine mentre il testo può essere deciso e impostato a piacimento.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

GtkWidget *
menu_label_with_stock_append (GtkMenu * menu, const char *label,
                              const char *stock_id, GCallback func,
                              GtkAccelGroup * accel_group,
                              unsigned int accel_id, GdkModifierType mod_type, char *tooltip)
{
  GtkWidget *widget, *image;
 
  image = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_MENU);
  gtk_widget_show (image);
 
  widget = gtk_image_menu_item_new_with_label (label);
  gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (widget), image);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), widget);
  gtk_widget_show (widget);
 
  if (func)
    g_signal_connect (G_OBJECT (widget), "activate", func, NULL);
 
  if (accel_id && accel_group)
    gtk_widget_add_accelerator (widget, "activate", accel_group, accel_id, mod_type, GTK_ACCEL_VISIBLE);
 
  if (tooltip)
    gtk_widget_set_tooltip_text (widget, tooltip);
 
  return widget;
}

Come si può notare riceve gli stessi i parametri, ne presenta solo uno in più tra il primo e il secondo parametro della funzione precedente. Il parametro in più richiesto è proprio quello riguardante il testo da usare per l’elemento.

Terza funzione che andiamo a vedere è quella per inserire un separatore di voci ( una semplice linea ) per ad esempio suddividere gruppi di elementi che fanno azioni diverse nello stesso menu.

1
2
3
4
5
6
7
8
9
10
11

GtkWidget *
menu_separator_append (GtkMenu * menu)
{
  GtkWidget *widget;
 
  widget = gtk_separator_menu_item_new ();
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), widget);
  gtk_widget_show (widget);
 
  return widget;
}

L’unico parametro che ricevere è come si può intuire il menu in cui inserire il separatore convertito con la macro GTK_MENU.

Ultima funzione è quella per aggiungere un menu alla barra dei menu.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

GtkWidget *
menu_append (GtkMenuBar * bar, GtkWidget * menu, const char *name, char *tooltip)
{
  GtkWidget *widget;
 
  widget = gtk_menu_item_new_with_label (name);
  gtk_widget_show (widget);
 
  gtk_menu_item_set_submenu (GTK_MENU_ITEM (widget), menu);
  gtk_menu_shell_append (GTK_MENU_SHELL (bar), widget);
 
  if (tooltip)
    gtk_widget_set_tooltip_text (widget, tooltip);
 
  return widget;
}

Il primo parametro è la barra dei menu in cui inserirlo, il secondo è il menu, il terzo il nome da dare al menu e come ultimo, opzionale, il suggerimento da dare quando il mouse si ferma sul menu oppure NULL.

Prima di andare a vedere come utilizzare bene queste funzioni, faccio una piccola spiegazione delle scorciatoie da tastiera.

Bene, innanzitutto nel mondo Gtk+ le scorciatoie vengono chiamate acceleratori così da poterle chiamare in modo giusto. Questi acceleratori vengono inseriti in uno o più gruppi chiamati GtkAccelGroup, questi gruppi sono utili ad esempio per abilitare o disabilitare acceleratori in massa, ad esempio si può avere un gruppo di acceleratori riguardanti certe voci che vanno in contrasto con gli acceleratori di un altro gruppo e quindi effettuare le verifichè per far sì che quando uno dei due è abilitato l’altro sia disattivato.

Gli acceleratori son composti principalmente da due parti, il tasto da premere per attivarlo e la maschera da utilizzare per intercettarlo.. esempio pratico come detto più su:

• TASTO: GDK_R
• MASK: GDK_CONTROL_MASK
• COMBINAZIONE PER ATTIVARE LA SCORCIATOIA: Ctrl + R

L’elenco dei nomi per le costanti che definiscono i tasti potete trovarli qui: http://www.koders.com/c/fidD9E5E78FD91FE6ABDD6D3F78DA5E4A0FADE79933.aspx ( comunque alcuni caratteri possono essere inseriti tramite il loro valore ascii, ad esempio GDK_A è uguale ad ‘A’ )

Principali maschere utilizzabili: GDK_SHIFT_MASK ( Shift), GDK_CONTROL_MASK ( Control ), GDK_MOD1_MASK ( Alt ), GDK_SUPER_MASK ( Il tastino su cui purtroppo c’è il simbolo di windows, o di una casetta sugli eeepc ). Per altre vi rimando al link del tipo GtkModifierType: http://library.gnome.org/devel/gdk/unstable/gdk-Windows.html#GdkModifierType

Bene dopo questa premessa sugli acceleratori passiamo alla tecnica per utilizzare queste funzioni in modo semplice.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include "funzioni_sopra_elencate.h"
 
/* window sarà il widget della finestra in cui inserire i menu
 * mentre container sarà il widget contenitore in cui 
 * andremo ad inserire il menu, dovrà essere passato
 * usando la macro GTK_CONTAINER
 */
void menu_new (GtkWindow *window, GtkContainer *container)
{
 GtkAccelGroup *group;
 GtkWidget *main_menu, *file_list, *edit_list;
 
 /* Creo la barra dei menu */
 main_menu = gtk_menu_bar_new ();
 
 /* Creo il gruppo di acceleratori */
 group = gtk_accel_group_new ();
 gtk_window_add_accel_group (window, group);
 
 /* Creo il menu File */
 file_list = gtk_menu_new ();
   /* -- */
 menu_stock_append (GTK_MENU (file_list), GTK_STOCK_NEW, NULL, group,
                    GDK_N, GDK_CONTROL_MASK, "Crea un nuovo file");
 menu_stock_append (GTK_MENU (file_list), GTK_STOCK_OPEN, NULL, group,
                    GDK_O, GDK_CONTROL_MASK, "Apri un file");
 menu_stock_append (GTK_MENU (file_list), GTK_STOCK_SAVE, NULL, group,
                    GDK_S, GDK_CONTROL_MASK, "Salva il file");
 
 menu_separator_append (GTK_MENU (file_list));
 
 menu_label_with_stock_append (GTK_MENU (file_list), "Stampa Documento",
                               GTK_STOCK_PRINT, NULL, group, GDK_P, 
                               GDK_CONTROL_MASK, "Stampa il file");
 
 menu_separator_append (GTK_MENU (file_list));
 
 menu_stock_append (GTK_MENU (file_list), GTK_STOCK_QUIT, NULL, group,
                    GDK_Q, GDK_CONTROL_MASK, "Esci dal programma");
   /* -- */ 
 menu_append (GTK_MENU_BAR (main_menu), file_list, "File", NULL);
 
 /* Creo il menu Modifica */
 edit_list = gtk_menu_new ();
   /* -- */
 menu_stock_append (GTK_MENU (edit_list), GTK_STOCK_COPY, NULL, group,
                    GDK_C, GDK_CONTROL_MASK, "Copia testo");
 menu_stock_append (GTK_MENU (edit_list), GTK_STOCK_CUT, NULL, group,
                    GDK_X, GDK_CONTROL_MASK, "Taglia testo");
 menu_stock_append (GTK_MENU (edit_list), GTK_STOCK_PASTE, NULL, group,
                    GDK_V, GDK_CONTROL_MASK, "Incolla testo");
   /* -- */
 menu_append (GTK_MENU_BAR (main_menu), edit_list, "Modifica", NULL);
 
 /* Inseriamo la barra comprensiva di menu all'interno del contenitore passato */
 gtk_container_add (container, main_menu);
}
 
/* Così è molto più immediato creare menu di grosse dimensioni anche
 * se nei casi più specifici si può migliorare ancora il codice e la sua
 * gestione 
 */

Fine Ventesima Puntata
Abbiam quasi finito con i menu, c’è ancora qualche funzione da descrivere ma siamo già a buon punto. Questa puntata è importante in quanto ho finalmente affrontato anche l’argomento degli acceleratori. Alla prossima, spero non tardi.
Ciauz

Come promesso qualche giorno fa ecco la guida alle gtk+ riguardante i menu, questa lezione sarà un po’ diversa in quanto invece di spiegare solamente le singole funzioni o eventuali particolari che tralascerò mi concentrerò sul spiegare passo passo la creazione di un menu facendo riferimento allo stile che adotto io per crearli ( una volta poi studiate e capite le funzioni ognuno sarà libero di creare un proprio stile con cui si trova meglio ).

Costruiamo un semplice menu 

Prima di iniziare con menu più articolati vorrei iniziare con un piccolissimo menu giusto per vedere le funzioni principali. Per iniziare abbiamo bisogno dei seguenti widget:

1
2
3

 GtkWidget *window;
 GtkWidget *bar;
 GtkWidget *file, *view, *help;

Dunque, innanzitutto bisogna creare la barra in cui memorizzare i singoli menu, l’unica funzione utilizzabile è gtk_menu_bar_new ()  che non riceve argomenti e restituisce il widget che punta alla nuova barra di menu. Una barra di menu può avere come attributo il tipo di ordinamento dei vari widget che può essere uno dei seguenti:

• GTK_PACK_DIRECTION_LTR -> Le varie voci del menu saranno messe da sinistra verso destra ( quando non si imposta nessuna di queste opzioni questo è il comportamento predefinito ).
• GTK_PACK_DIRECTION_RTL -> Le voci saranno orientate da destra verso sinistra.
• GTK_PACK_DIRECTION_TTB -> Le voci saranno orientate dall’alto verso il basso.
• GTK_PACK_DIRECTION_BTT -> Le voci saranno orientate dal basso verso l’alto.

Una volta scelto il tipo di orientamento che si vuol dare agli elementi si può utilizzare la funzione gtk_menu_bar_set_pack_direction () nel seguente modo:

1
2

 bar = gtk_menu_bar_new ();
 gtk_menu_bar_set_pack_direction (GTK_MENU_BAR (bar), GTK_PACK_DIRECTION_BTT);

Siamo ancora all’inizio del lavoro, perchè ora dovremo creare: i menu grafici principali ( quelli che si vedono nella barra dei menu ) e i menu astratti ognuno dei quali bisognerà collegarlo a un menu grafico principale così da poter inserire gli elementi ( o meglio le operazioni ) di ogni singolo menu. Dunque partiamo con solo una barra di menu con i menu grafici senza sotto-menu:

1
2
3
4
5
6
7
8

 file = gtk_menu_item_new_with_label ("File");
 gtk_menu_shell_append (GTK_MENU_SHELL (bar), file);
 
 view = gtk_menu_item_new_with_label ("Visualizza");
 gtk_menu_shell_append (GTK_MENU_SHELL (bar), view);
 
 help = gtk_menu_item_new_with_label ("Aiuto");
 gtk_menu_shell_append (GTK_MENU_SHELL (bar), help);

I menu principali della barra solitamente si crea con solo il testo, senza utilizzare checkbutton, radiobutton o icone associate come invece succede per le voci del menu, per fare ciò si utilizza come si può vedere la funzione gtk_menu_item_new_with_label () che riceve come argomento il label da utilizzare e ritorna il widget riguardante il menu principale da inserire nella barra dei menu.Un menu principale si può anche allineare a destra ( mentre l’azione predefinita che eseguono le gtk+ è quella di allinearli a sinistra ) tramite la funzione gtk_menu_item_set_right_justified ().Continuando, per inserire poi il menu nella barra si utilizza la funzione gtk_menu_shell_append () per inserire il nuovo menu in coda agli altri, gtk_menu_shell_prepend () per inserirlo prima degli altri o in alternativa gtk_menu_shell_insert () per impostare manualmente il punto in cui inserirlo, questa funzione come si può immagine oltre ai primi due parametri ( GtkMenuShell che sarà la nostra barra convertita con la macro GTK_MENU_SHELL () e il GtkWidget rappresentate il nostro menu principale ) anche un intero che rappresenta la posizione in cui inserire il menu che va da 0 ( inizio ) a N-1 ( dove N è il numero dei menu inseriti ).Per velocizzare le operazioni di inserimento delle voci dei vari menu nella prossima puntata creeremo delle funzioni apposite perchè come potete immaginare richiamare tante funzioni per ogni singola operazione rende il lavoro di creazione lungo, stancante e poco mantenibile.

Fine Diciannovesima Puntata
Preferisco fermarmi qui per ora perchè inserire le voci sarà abbastanza lungo da spiegare.
Ciauz

Si continua a parlare di gtk+, vedo che durante queste guide ho iniziato ad affascinare molte ( rispetto a quanto mi aspettavo all’inizio ) persone e ne son contento

Dopo la mia piccola riflessione iniziale di autoapprezzamento, possiamo continuare l’argomento textview affrontando velocemente l’ultimo argomento per poi poter finalmente passare ad altro.

GtkTextTag

I tag forse qualcuno di voi può già intuire cosa siano, per chi non lo sapesse lo spiego non preoccupatevi. Sono delle “entità” astratte che permettono di applicare degli effetti al testo come ad esempio il grassetto, evidenziazione, colore, ecc.. Non sono così particolari come utilità, mi è capitato più volte di aver bisogno ad esempio della possibilità di evidenziare del testo per far risaltare ad esempio le parole durante una ricerca di qualche parola cosa non fattibile nel caso i tag non esistessero.

Prosegui la lettura…

Ok, continuiamo a parlare di textview occupandoci questa volta del buffer chiamato GtkTextBuffer.

Iniziamo guardando le due azioni principali che di solito si eseguono: ottenere il testo inserito, inserire del nuovo testo ed eliminare parti di testo.

- Ottenere del testo:
In questo caso ci viene in aiuto la funzione gtk_text_buffer_get_text () che richiede il buffer del testo, il punto iniziale, il punto finale e se ottenere anche i “caratteri invisibili”  ( sono presenti quando si inserisce un’immagine o un widget o altre cose all’interno della textview cose che noi tralasceremo ).
Prosegui la lettura…

20 giorni di silenzio.. son tanti. L’estate, intesa come periodo di relax, per me deve ancora iniziare purtroppo.

Vabbè, non ho molta voglia di parlare a quest’ora. Occupiamoci di questa puntata alle Gtk+. Oggi parliamo del widget “GtkTextView” ovvero il widget che permette di ottenere dall’utente interi testi ( diciamo che si può considerare grosso modo un GtkEntry multilinea ).

Vista Testuale ( GtkTextView )

Una GtkTextView è il widget che potete vedere nell’immagine a fianco. Molto utile quando si deve richiedere all’utente non una stringa ma un intero testo su più linee. La sua creazione è molto semplice e ci dà l’opportunità di creare anche dei tag, ovvero creare degli effetti al testocome l’evidenziazione di alcune parole quando si cerca una stringa, delle stringhe sottolineate o in grassetto o in corsivo e così via..

Per completezza bisogna dire che questo widget sostituisce il vecchio GtkText ormai deprecato e ne sconsiglio vivamente l’utilizzo in quanto è molto, ma molto lento e poco gestibile. Questo nuovo widget è composto da due parti, la parte “grafica” chiamata GtkTextView e la parte del buffer del testo preso in input chiamata GtkTextBuffer che è quella che noi utilizzeremo di più per le operazioni “pratiche”.

Ma non corriamo troppo, concentriamoci sul widget GtkTextView prima di tutto però premetto che non tratterò tutte le funzioni ma solo quelle principali e basilari, perchè è un tipo di widget che lavora insieme ad altri widget che rendono il tutto molto grande e lungo da affrontare in queste guide a puntate.

Prosegui la lettura…

Continuiamo a parlare di gtk+, data la richiesta da parte di luky oggi parleremo dell’input da parte dell’utente tramite caselle di testo ( Entry → GtkEntry ) e ho inserito anche un po’ di funzioni da conoscere sui widget di cui non avevo parlato.

Iniziamo

Prosegui la lettura…

Come promesso, dopo la fine degli esami, una nuova guida alle Gtk+. In questa puntata affronteremo due argomenti differenti il primo riguardante la visualizzazione di un’immagine all’interno di un’applicazione in gtk+, il secondo come creare una barra di stato ( quella barra piccola che si vede nella maggior parte delle applicazioni, con a sinistra un messaggio e a destra il triangolino per ridimensionare la finestra.

Prosegui la lettura…

Dopo un lungo momento di silenzio a causa della scrittura della documentazione per Imel, continuiamo la nostra guida alle Gtk+. In questa puntata vedremo i label, loro uso e “consumo”
Prosegui la lettura…

Ok, le puntate continuano e gli argomenti avanzano. Adesso siamo arrivati all’argomento pulsanti ( o bottoni che dir si voglia ) molto utili e quasi indispensabili per un’applicazione in Gtk+.

Questo argomento non è complicatissimo e conto di finire tutti i tipi di pulsanti esistenti in questa puntata. Quindi.. Relax

Prosegui la lettura…