Rilasciata da qualche minuto la versione 0.2.7 di Imel.

Le novità di questa versione comprendono uno “snellimento” delle dipendenze, le uniche librerie richieste ora sono libfreetype6-dev e libfreeimage3-dev, un’aggiunta di nuovi formati in cui salvare ( XPM, PPM ( Ascii ), JP2, J2K ), un miglioramento nella lettura di quelli già presenti ( ora vengono salvati usando la libreria freeimage ) e una nuova modalità per salvarli ( al posto del nome può essere passato direttamente il puntatore a file ).

Inoltre:

• imel_image_apply_noise (): permette di applicare un disturbo all’immagine.
• imel_font_write_vstring () e imel_font_write_vstring_with_truetype_font (): permettono di scrivere direttamente in verticale.
• imel_font_write_string () e imel_font_write_string_with_truetype_font (): abilitato il supporto al carattere di newline.
• imel_image_apply_pattern (): consente ora di sommare o sottrarre i colori del pattern durante la sua applicazione.
• IMEL_EFFECT_COLOR_TO_ALPHA: nuovo effetto che consente di rendere trasparente le aree in cui c’era una tonalità di colore ( uguale al Color to alpha presente in GIMP )
• imel_image_perspective (): permette di inclinare i lati dell’immagine in modo simmetrico creando l’effetto “prospettiva”.

Ed altri bugfix..

Le informazioni dettagliate nel ChangeLog.

Link immancabile alla Documentazione ( HTML, PDF )

Link finale per scaricare il pacchetto della versione 0.2.7

Rilasciata la versione 0.2.6 di Imel la libreria grafica per la manipolazione di immagini che sto scrivendo.
Documentazione riscritta da zero e disponibile ora anche in pdf ( Ben 98 Pagine! )

Tra le novità la più importante è l’introduzione della libreria FreeImage per leggere le immagini quindi i formati supportati in lettura sono davvero tanti.

Ci sono numerosi bugfix più o meno importanti.

Altre novità che richiedono attenzione sono:

• Rotazione ora vera e propria di un angolo a piacere
• Abilitazione\Disabilitazione disegno con pennelli ( funzioni generiche )
• Maschera per pseudo-livello così da poter effettuare operazioni anche con essa ( + IMEL_MASK_LEVEL )
• Macro return_if_fail e return_var_if_fail ora non visualizzano più il messaggio di debug a meno imel non sia stata compilata con il debug abilitato
• Risolto un grosso memory leak nel salvataggio in PNG
• Categoria a parte per il riempimento, migliore della precedente che in alcuni casi risultava buggata

Per altre informazioni consultare il ChangeLog.

Pensavamo di pubblicare questa versione per l’anno nuovo, ma giorno dopo giorno le novità aumentavano e rischiava di diventare un rilascio obeso quindi per evitare difficoltà con tante novità ho deciso di pubblicare questa versione un po’ grassotta ma gestibile.

Prima di proseguire ringrazio Simone Scarinzi conosciuto come “Skary” per la partecipazione e la costanza che sta avendo nell’aiuto dello sviluppo di questa libreria, a lui si devono le nuove funzioni riguardo al disegno di questa versione e l’idea di rendere disponibili funzioni che prima erano private come ad esempio imel_point_get_from_line ().

Le novità in questi due mesi di sviluppo sono tantissime inizio ad elencarle per ordine:

Effetti

• IMEL_EFFECT_ANTIALIAS, IMEL_EFFECT_DIRECT_ANTIALIAS: Effetti per applicare l’antialias all’immagine in modo passivo o diretto ( guardare la documentazione per maggiori dettagli ).
• IMEL_EFFECT_IMAGE_ADD, IMEL_EFFECT_IMAGE_SUBTRACT: Sommano, o sottraggono, ad ogni pixel ( colori e livello ) dell’immagine a cui si sta applicando l’effetto i pixel ( colori e livello ) dell’immagine passata come parametro.

Tipi

• ImelRef: Serve a stabilire se prendere come riferimento il colore o il livello di un’immagine.
• ImelValue:
  Permette di capire a che tipo di misura si riferisce
  un eventuale parametro numerico passato dopo un elemento
  di questo tipo

  Permette di capire a che tipo di misura si riferisce il valore numerico passato dopo questo tipo.

Macro

• DEG_TO_RAD, RAD_TO_DEG: Converte da gradi a radianti e da radianti a gradi

Funzioni migliorate

• imel_draw_ellipse (): migliorata, prima i punti dell’ellisse non venivano uniti in ellissi molto grandi
• imel_draw_line (), imel_draw_dashed_line (), imel_draw_gradient_line (): Corretto un bug che disegnava a tratti la linea se i parametri riguardanti il punto iniziale e il punto finale erano di un certo tipo.
• imel_pixel_copy (): corretta una parte che rallentava di molto la funzione in molte chiamate consecutive.
• imel_image_apply_convolution (): corretto un bug nell’inizializzazione di una variabile locale alla funzione anche se errori dovuti a questa non inizializzazione non erano stati notati.
• imel_font_write_string_with_truetype_font (): corretto un grave errore nella resa del carattere, in più sono stati aggiunti degli attributi opzionali nel disegno ( guardare la documentazione per sapere quali sono e come usarli ). Compatibilità con vecchie versioni mantenuta.
• imel_draw_circle (): Prestazioni migliorate del 50%
• imel_image_new_with_background_color (): da ora si calcola anche il livello del pixel passato per creare l’immagine

Funzioni nuove

• imel_draw_filled_circle (): disegna un cerchio riempito internamente
• imel_draw_filled_ellipse (): disegna un ellissi riempita internamente
• imel_pixel_compare_level (): funzione simile alla vecchia imel_pixel_compare () solo che questa è appositamente per confrontare i livelli.
• imel_image_auto_cut (): Auto-ritaglia un’immagine il bordo da considerare in più è deciso dall’utente che può stabilire se basarsi o sul colore oppure sul livello ( sempre a sua discrezione il loro valore ).
• imel_color_get_number (): permette di ottenere il numero di colori unici presenti nell’immagine
• imel_draw_gradient_line (): consente di disegnare una linea che ha come colore una sfumatura che va da un colore iniziale ad uno finale
• imel_draw_gradient_curve (): come imel_draw_gradient_line () solo che disegna una curva.
• imel_color_sum (), imel_color_subtract (): sommano o sottragono un colore ad un altro sempre rimanendo nel range di valori usabili come color ( 0 – 255 )
• imel_image_shear (): inclina parte o tutta un’immagine verticalmente o orizzontalmente secondo il verso di una linea teorica ( guardare la documentazione per maggiori informazioni )
• imel_image_shift (): sposta l’immagine in alto, in basso, a destra o a sinistra di un numero di pixel a scelta.
• imel_image_new_from_raw (): funzione molto potente, permette di aprire un’immagine grezza ( raw ) di bits per pixel e bits per channel a scelta ( guardare la documentazione per maggiori informazioni ).
• imel_draw_reg_shape (): disegna un poligono regolare all’interno di una circonferenza con un numero di vertici e un’inclinazione a scelta
• imel_draw_partial_reg_shape (): come imel_draw_reg_shape () solo che disegna solo una parte di poligono
• imel_image_shift_lines (): come imel_image_shift () solo che lo spostamento può essere limitato solo ad alcune linee dell’immagine
• imel_point_get_from_line (): restituisce solo i punti e la lunghezza di una linea, i punti possono essere ottenuti tutti oppure solo una parte specificata in modo relativo tramite percentuale o in modo fisso tramite pixel.
• imel_point_get_from_reg_shape (): restituisce i punti riguardanti i vertici di un poligono regolare inscritto in una circonferenza.
• imel_value_convert (), imel_value_percentage_to_generic (), imel_value_pixel_to_percentage: varie funzioni di conversioni da un valore ad un altro.
• imel_draw_arch: disegna un arco
• imel_image_shift_bpc: permette di eseguire uno shift sui bit di uno o più canali di colore presenti in un’immagine, consente anche seguendo due shift opposti con gli stessi valori di ridurre i colori di un’immagine.
• imel_image_remove_noise (): elimina il disturbo che può presentare un’immagine con una soglia a scelta ( guardare la documentazione )

Tutte queste funzioni ( per quelle più complicate da capire e utilizzare l’ho detto già esplicitamente ) sono documentate nella documentazione online e interna al pacchetto scaricato. I link sono i seguenti:

http://www.hds619.net/imel-pkg/imel-0.2.5.tar.bz2 Pacchetto di quest’ultima versione

http://www.hds619.net/documentation/imel Documentazione online dell’ultima versione stabile

http://www.hds619.net/listing/imel Sorgenti “sfusi” dell’ultima versione stabile

Buona programmazione

A solo un mese dal rilascio della versione 0.2.3 procede a ritmo serrato lo sviluppo di imel giunto alla versione 0.2.4. Le novità al contrario di quanto si possa pensare. dato il poco tempo passato tra le due versioni, sono tante.

Tra le più importanti ritroviamo il supporto a pkg-config così da poter compilare staticamente senza dover scrivere manualmente tutte le librerie, possibilità di tracciare un ellisse e disegnare un cerchio, in più reso possibile il disegno di una linea o una curva con un’immagine così da poter realizzare l’effetto “pennello” presente in molti programmi di grafica e tante altre funzioni.

E novità più importante di tutte: aggiunto il supporto al formato BMP.

Il Changelog con tutte le modifiche dettagliate.

Colgo l’occasione per annunciare la partecipazione di una persona oltre a me a questo progetto: Simone “Skary” Scarinzi, per il momento ha aiutato nella creazione della funzione per il disegno di un ellisse ma per le prossime versioni ci regalerà altre funzioni riguardanti il disegno

Link pacchetto – Link documentazione

P.s.: Il servizio HImages è stato aggiornato per avere il supporto alle bmp.

Comunque programmando poco per volta è nata sotto le mie mani la nuova versione di Imel, tra le novità principali un supporto alla trasparenza migliorato generalmente e anche il suo supporto alle immagini png che ora vengono lette e salvate anche con la trasparenza. Altra novità importante è la riscrittura della funzione per disegnare una linea che non si basa più su quella per disegnare una curva ma utilizza un suo algoritmo molto più snello, semplice e veloce. Altre novità le potete leggere nel ChangeLog.

Link al pacchetto - Link Documentazione

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

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.

I tag oltre ad avere degli attributi ( cosa principale per un tag che più avanti vedremo come settare e quali sono ) hanno anche delle priorità, ovvero se noi abbiamo due tag che evidenziano e capita che vengano utilizzati tutti e due sappiamo che uno dei due sarà sotto l’altro nel caso si ritrovino nello stesso punto. Solitamente la priorità di tutti i tag è 0 quindi l’ultimo applicato copre l’altro. Ciò però si può cambiare tramite una funzione chiamata gtk_text_tag_set_priority () ( per ottenerla gtk_text_tag_get_priority () unico argomento il tag, ritorna l’int rappresentante la priorità ) che riceve come primo argomento il tag, e come secondo argomento la priorità ( da specificare come int ).

Voi ora vi chiederete ma come lo creo il tag? semplicissimamente con la funzione gtk_text_tag_new () che riceve come unico argomento il nome da dare al tag, e ritorna il tag creato ( GtkTextTag * ).

La parte “difficile” è quella del settaggio dei vari attributi che per farla dobbiamo ricorrere al tipo primitivo GObject e quindi alla relativa funzione g_object_set () che abbiamo già incontrato durante queste guide. Vi dò un codice di esempio:

1
2
3
4

 GtkTextTag *tag;
 
 tag = gtk_text_tag_new ("highlighting");
 g_object_set (G_OBJECT (tag), "foreground", "#ffffff", "background", "#000000", NULL);

Come vedete la funzione g_object_set () riceve come primo argomento il nostro tag convertito in GObject tramite la macro G_OBJECT  dopodichè ci sono in sequenza attributo, valore, attributo, valore, .. quando si termina l’impostazione dei vari attributi diamo NULL come parametro e abbiam finito. Gli attributi da poter dare non sto qui ad elencarli perchè sono veramente tanti, vi rimando quindi alla pagina delle api ufficiali delle gtk+ relativa ai tag.

Per finire rimane l’ultima questione: Ok, ho capito come creare e impostare il tag, ora però che me ne faccio se non so come applicarlo al testo? 

Boh! Scherzo diciamo che ci sono molti metodi per usare un tag relativi alla situazione in cui ci si ritrova, perchè ad esso fanno riferimenti molti widget di diversa natura. Elenco qualche funzione:

•  gtk_text_buffer_insert_with_tags (): primo argomento il buffer di testo, secondo argomento l’iter che individua la posizione in cui inserire il testo, terzo argomento il testo accompagnato dal quarto argomento che è la sua lunghezza ( o -1 se è NULL-terminated ), quinto argomento in poi i vari tag che verranno applicati al testo.. alla fine per terminare gli argomenti è necessario inserire il valore NULL.
• gtk_text_buffer_insert_with_tags_by_name (): ( gli autori delle gtk+ non si può dire che siano avari sulla lunghezza dei nomi delle funzioni ) come la funzione precedente solo che al posto di passare i tag veri e propri si può passare il nome del tag creato. Questo però aggiungendo prima il tag alla TagTable del buffer. Non ne ho parlato e non ne parlo per confondere le idee, vi basti sapere che la TagTable ( GtkTextTagTable ) del buffer la si prende tramite la funzione gtk_text_buffer_get_tag_table () che riceve come argomento il buffer e ritorna un puntatore a GtkTextTagTable. Dopodichè si può aggiungere il tag alla tabella tramite la funzione gtk_text_tag_table_add () che riceve come primo argomento la TagTable e come secondo argomento il tag da inserire.
• gtk_text_buffer_apply_tag (): primo argomento il buffer, secondo argomento il tag da applicare e i due parametri successivi sono il GtkTextIter iniziale e quello finale che delimitano lo spazio a cui il tag viene applicato.
• gtk_text_buffer_apply_tag_by_name (): come la funzione precedente, solo che il secondo parametro al posto di essere il tag vero e proprio sarà il nome del tag, e qui si torna al ragionamento fatto per la funzione gtk_text_buffer_insert_with_tags_by_name ().
• gtk_text_buffer_remove_tag (): Come la funzione gtk_text_buffer_apply_tag () solo che al posto di applicare il tag passato all’area compresa tra l’iter iniziale e quello finale, rimuove eventuali occorrenze dello stesso in quell’area.
• gtk_text_buffer_remove_tag_by_name (): Come la funzione precedente, il tag anche qui c’è la differenza che viene passato per nome e quindi si ritorna al discorso delle funzioni _by_name precedenti.
• gtk_text_buffer_remove_all_tags (): come la funzione gtk_text_buffer_remove_tag () solo che non c’è l’argomento per il tag dato che rimuove tutti i tag eventualmente applicati nell’area compresa tra l’iter iniziale e quello finale.

Ok, abbiam finito con la gestione di una textview, ho tralasciato alcune parti, nel caso però vi servissero fate pure domande nei commenti che risponderò come posso per affrontare quei lati che ho tralasciato.

Fine Diciottesima Puntata
Capite ora perchè me la son presa con calma per trattare i tag? XD va bien, alla prossima!

Ciauz

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 ).

Il punto iniziale e il punto finale sono memorizzati in un GtkTextIter che possiamo ottenere ricorrendo alle funzioni sempre del widget GtkTextBuffer relative ad esso ( il primo argomento sarà sempre il nostro buffer ):

•  gtk_text_buffer_get_iter_at_line (): il secondo argomento dovrà essere o un puntatore a GtkTextIter oppure l’indirizzo di un GtkTextIter, anche non inizializzato, e come terzo argomento il numero di linea del testo a cui posizionarlo.
• gtk_text_buffer_get_start_iter (): secondo argomento un puntatore a GtkTextIter, o come detto prima l’indirizzo di un GtkTextIter. Dopo questa funzione l’iter passato sarà posizionato all’inizio del testo contenuto nel buffer.
• gtk_text_buffer_get_end_iter (): come la funzione precedente. Dopo la sua chiamata l’iter passato sarà posizionato alla fine del testo contenuto nel buffer.
• gtk_text_buffer_get_bounds (): riceve due puntatori a GtkTextIter come secondo e terzo parametro. Dopo la sua chiamata il primo GtkTextIter passato sarà posizionato all’inizio del testo contenuto nel buffer, mentre il secondo alla fine.

Quindi per ottenere il testo possiamo scrivere un codice del genere:

1
2
3
4
5
6
7

char *foo (GtkTextBuffer *buffer)
{
 GtkTextIter start, end;
 
 gtk_text_buffer_get_bounds (buffer, &start, &end);
 return gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
}

- Inserire del testo:

Per inserire un testo sono anche qui presenti diverse funzioni, il primo argomento sarà anche in questo caso il nostro buffer ( GtkTextBuffer * ).

• gtk_text_buffer_insert (): il secondo argomento sarà il punto ( sempre l’iter ) in cui inserire il nuovo testo, il terzo argomento sarà per l’appunto il testo e come ultimo argomento la lunghezza del testo che si può omettere inserendo -1 nel caso la stringa di testo è null-terminated.
• gtk_text_buffer_insert_at_cursor (): secondo argomento il testo da inserire nel punto in cui è presente il cursore, terzo argomento la lunghezza del testo o -1 se la si vuol far calcolare alla funzione la lunghezza della stringa ( che deve essere null-terminated ).
• gtk_text_buffer_set_text (): i parametri sono identici alla funzione precedente. Questa funzione però imposta il testo dell’intero buffer con quello passato come parametro, eliminando eventuali testi inseriti.

- Eliminare del testo:

Per eliminare del testo abbiamo una sola funzione ( ok, chi conosce le gtk+ sa che è presente anche un’altra funzione ma io qui tratto quelle principali, se volete dare altri consigli potete farlo nei commenti ) ovvero gtk_text_buffer_delete ().  Questa funzione come primo parametro riceve sempre il nostro buffer, come secondo e terzo parametro invece riceve rispettivamente il punto iniziale e il punto finale del testo da eliminare. Si possono sempre usare le funzioni descritte prima nel paragrafo “Ottenere del testo” riguardo gli iter.

Per operare e modificare maggiormente gli iter esistono comunque le funzioni ad hoc per essi, non mi metto ad elencarle perché sono veramente tante e tutte sullo stesso livello di utilità, quindi vi lascio il link per guardarle dalla documentazione ufficiale.

Passiamo invece ora ai segnali del GtkTextBuffer che sono molto importanti a mio giudizio:

•  ”changed” – Viene emesso quando il testo è cambiato
•  ”insert-text” – Viene emesso quando è inserito del testo.

Elenco solo questi due perchè con gli altri andiamo a finire su altri argomenti che non voglio toccare ora. Per quanto riguarda il come strutturare le funzioni che vengono collegate a questi segnali andate come consigliato altre volte a guardare nella documentazione ufficiale che ci sono gli esempi di dichiarazione poi se avete domande chiedete pure nei commenti

Fine Diciassettesima Puntata
I tag sono un argomento relativamente semplice che preferisco affrontare, e quindi sprecare, ancora un’altra puntata. Non me ne vogliate se me la prendo con questa calma

Ciauz

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.

La creazione di una textview, con buffer, può avvenire in questo modo:

1
2
3
4
5

GtkWidget *textview;
GtkTextBuffer *buffer;
 
textview = gtk_text_view_new ();
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (textview));

Andiamo a vedere subito gli attributi che possiamo dare a questo widget:

•  Il come e quando andare a capo tramite la funzione gtk_text_view_set_wrap_mode () ( ricordatevi che il primo argomento in questi casi è sempre il widget a cui applicare l’effetto, nel nostro caso la textview convertita tramite la macro GTK_TEXT_VIEW () ) , ci sono quattro metodi disponibili:
  1. GTK_WRAP_NONE: non va mai a capo a meno che l’utente non prema invio, o noi inseriamo il carattere \n.
  2. GTK_WRAP_CHAR: va a capo appena il carattere supera la larghezza della textview
  3. GTK_WRAP_WORD: manda a capo l’ultima parola che non può essere visualizzata nella larghezza della textview.
  4. GTK_WRAP_WORD_CHAR: manda a capo l’ultima parola che non può essere visualizzata nella larghezza della textview, se possibile, altrimenti manda a capo l’ultimo carattere non visualizzabile. ( Ciò succede quando il testo è composto da un’unica parola troppo lunga per l’intera riga ).

  Ricordo comunque che l’”a capo” di cui parlo è un “a capo” visivo, nel buffer non verrà inserito il ‘\n’.

• Se lasciare l’opportunità all’utente di inserire del testo tramite la funzione gtk_text_view_set_editable () specificando nel secondo parametro TRUE nel caso si volesse far modificare il testo all’utente o FALSE per il contrario. Utile quando si utilizza una GtkTextView solo per riportare dei messaggi remoti ( ad esempio in una finestra di chat ).
• Se visualizzare il punto di inserimento ( di solito segnato col trattino lampeggiante ) con la funzione gtk_text_view_set_cursor_visible (), anche qui TRUE nel caso si volesse visualizzare, altrimenti FALSE.
• Se impostare il cursore nella modalità sovrascrittura ( di solito l’utente può attivarla o disattivarla premendo Ins ) con la funzione gtk_text_view_set_overwrite (), sempre il valore booleano come secondo argomento per specificare come impostare il cursore.
• Quanto spazio lasciare tra sopra ( above ) o sotto ( below ) alle righe in pixel tramite la funzione gtk_text_view_set_above\below_lines (). Come secondo parametro il numero di pixel da lasciare come margine.
• Quanto spazio lasciare tra le parole ( ovvero la larghezza in pixel dello spazio ) con la funzione gtk_text_view_set_pixels_inside_wrap (). Sempre come secondo argomento la misura specificata in pixel.
• Il tipo di giustificazione che deve avere il testo con la funzione gtk_text_view_set_justification () che richiede come secondo argomento uno dei seguenti valori:
  1. GTK_JUSTIFY_LEFT: allinea il testo a sinistra.
  2. GTK_JUSTIFY_RIGHT: allinea il testo a destra.
  3. GTK_JUSTIFY_CENTER: allinea il testo al centro.
  4. GTK_JUSTIFY_FILL: il testo viene distribuito in maniera uniforme su tutta la linea.
• I pixel di margine da quello destro e\o da quello sinistro con la funzione gtk_text_view_set_left\right_margin (). Secondo argomento il numero di pixel di margine.
• Se accettare i tab o meno con la funzione gtk_text_view_set_accepts_tab (). Valore booleano come secondo argomento per decidere l’azione.

Tutte queste funzioni naturalmente hanno la corrispondente che al posto di _set_ hanno _get_ per sapere quale valore è in quel momento in uso.

Andiamo a vedere un’ultima cosa su questo widget, ovvero i segnali principali

1. “backspace”: quando si inserisce, o l’utente esegue, un backspace.
2. “copy clipboard”, “cut clipboard” e “paste clipboard”: quando si copia o si taglia qualcosa dal testo della textview e quando si incolla qualcosa.
3. “move cursor”: quando il punto di inserimento viene spostato.
4. “select-all”: quando si seleziona tutto il testo
5. “insert-at-cursor”: quando l’utente scrive qualcosa.
6. “toggle-overwrite”: quando si cambia il cursore dalla modalità di sovrascrittura a quella di inserimento, o viceversa.

Fine Sedicesima Puntata
Per il momento mi fermo qua, sia perchè mi son stancato sia perchè vorrei trattare l’argomento dei tag e del buffer del testo con più calma in una puntata ad hoc.

Ciauz

Iniziamo

Caselle di testo ( GtkEntry )

Una casella di testo è quella che potete vedere come esempio a lato. La loro funzione è quella di ricevere l’input da parte dell’utente. Possono anche essere usate per ricevere password o altri dati da non visualizzare durante la scrittura. In questo caso esse visualizzeranno un “pallino” per ogni carattere.

La loro creazione può avvenire con due funzioni: gtk_entry_new (), che non riceve parametri e crea una semplice entry senza limitazioni riguardo la lunghezza del testo che è possibile inserire, e gtk_entry_new_with_max_length (), che riceve come unico parametro la lunghezza massima dei caratteri che l’utente potrà inserire. In ogni caso si può impostare la lunghezza massima a parte una volta creata con gtk_entry_new () richiamando la funzione gtk_entry_set_max_length ().

Prima di continuare volevo dirvi che questo widget fa parte dei GtkEditable e quindi si possono usare le funzioni di quel tipo per operare con questo. Ad esempio per selezionare il testo si può far così:

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

 #include <gtk/gtk.h>
 
int main (int argc, char *argv[])
{
 GtkWidget *window, *entry;
 int position;
 
 gtk_init (&argc, &argv);
 
 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 gtk_window_set_title (GTK_WINDOW (window), "Hello Entry");
 g_signal_connect (G_OBJECT (window), "delete_event",
                   G_CALLBACK (gtk_main_quit), NULL);
 
 entry = gtk_entry_new ();
 gtk_entry_set_text (GTK_ENTRY (entry), "Hello Entry World ;)");
 gtk_container_add (GTK_CONTAINER (window), entry);
 
 gtk_widget_show_all (window);
 gtk_editable_select_region (GTK_EDITABLE (entry), 6, 11);
 gtk_main ();
 
 return 0;
}

O per disabilitare l’inserimento del testo:

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

#include <gtk/gtk.h>
 
int main (int argc, char *argv[])
{
 GtkWidget *window, *entry;
 int position;
 
 gtk_init (&argc, &argv);
 
 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 gtk_window_set_title (GTK_WINDOW (window), "Hello Entry");
 g_signal_connect (G_OBJECT (window), "delete_event",
                   G_CALLBACK (gtk_main_quit), NULL);
 
 entry = gtk_entry_new ();
 gtk_editable_set_editable (GTK_EDITABLE (entry), FALSE);
 gtk_container_add (GTK_CONTAINER (window), entry);
 
 gtk_widget_show_all (window);
 gtk_main ();
 
 return 0;
}

Comunque dovevo dire una cosa all’inizio delle puntate che essendo tutti questi widget possono essere nascosti ( gtk_widget_hide () ) e mostrati ( gtk_widget_show () o per mostrare anche eventuali sotto elementi del widget gtk_widget_show_all () ), disabilitati o abilitati ( gtk_widget_set_sensitive () che accetta come primo argomento il  widget a cui applicare l’abilitazione o la disabilitazione e come secondo argomento TRUE per abilitarlo o FALSE per disbailitarlo ), ecc.. tutte le funzioni le trovate come già detto altre volte nelle api delle gtk+.

Ora ritornando all’argomento delle GtkEntry vediamo come rendere un testo “oscurato” facendo visualizzare i pallini al posto delle scritte e di come inserire una stringa in un punto qualsiasi dell’entry e dell’eventuale testo contenuto.

Per quanto riguarda i pallini si ricorre alla funzione gtk_entry_set_visibility () che riceve come primo argomento la GtkEntry e come secondo argomento TRUE nel caso si voglia visualizzare il testo e FALSE nel caso si voglia visualizzare un pallino al posto di ogni carattere.

Per inserire il testo invece, come dicevo, bisogna ricorrere al tipo GtkEditable e alla funzione gtk_editable_insert_text (). Mostro prima il codice e poi spiego che facciam prima.

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

#include <gtk/gtk.h>
 
int main (int argc, char *argv[])
{
 GtkWidget *window, *entry;
 int position;
 
 gtk_init (&argc, &argv);
 
 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 gtk_window_set_title (GTK_WINDOW (window), "Hello Entry");
 g_signal_connect (G_OBJECT (window), "delete_event",
                   G_CALLBACK (gtk_main_quit), NULL);
 
 entry = gtk_entry_new ();
 gtk_entry_set_text (GTK_ENTRY (entry), "Hello World ;)");
 position = 6;
 gtk_editable_insert_text (GTK_EDITABLE (entry), "Entry ", -1, &position);
 /* Visualizzerà alla fine la frase "Hello Entry World ;)" */
 gtk_container_add (GTK_CONTAINER (window), entry);
 
 gtk_widget_show_all (window);
 gtk_main ();
 
 return 0;
}

Come si può vedere i parametri della funzione sono in ordine:

1. La entry convertita in GtkEditable
2. Il testo da inserire
3. La lunghezza del testo ( o -1 per farlo calcolare alla funzione )
4. La posizione in cui inserire il nuovo testo

Per finire con le entry resta solo da capire come recuperare il testo inserito, come eliminare una parte del testo all’interno dell’entry e infine i segnali che possono essere collegati.

Per recuperare il testo si utilizza la funzione gtk_entry_get_text () che riceve come unico argomento l’entry da cui prelevare il testo. Restituisce un “const char *” ovvero una stringa non modificabile ( che all’uscita dovrà essere riconvertita tramite cast a “char *” per poterla assegnare a qualche variabile ) essa non ha bisogno di essere liberata in quanto è allocata staticamente dalla funzione. Non sarà mai nulla la stringa ritornata infatti per controllare che sia stato inserito qualcosa bisogna vedere se il primo elemento dell’array di char è uguale a 0 ( o ‘\0′ o 0×00 o chiamatelo un po’ come vi pare ).
Per finire in bellezza con le funzioni principali che riguardano il tipo GtkEntry parliamo di come si può eliminare una porzione di testo da quello inserito. E lo si fa con la funzione gtk_editable_delete_text () che riceve come primo argomento la entry convertita a GtkEditable, come secondo argomento la posizione iniziale da cui eliminare il testo e come terzo argomento il punto finale in cui terminare l’eliminazione.

E andiamo ora a vedere i segnali, faccio la descrizione dei tre principali relativi più che altro al tipo GtkEditable:

•  ”changed” – Viene inviato quando il testo all’interno dell’entry è cambiato, quindi quando: si inserisce un nuovo carattere, si elimina un carattere o una porzione di testo, si incolla e si taglia qualcosa.. in pratica ogni qualvolta venga cambiato.
• “delete-text” – Viene inviato solamente quando si cancella una parte del testo o un carattere.
• “insert-text” – Viene inviato solamente quando si inserisce qualcosa nel testo.

Fine Quindicesima Puntata
Bene, abbiam finito anche le entry così da poter iniziare a sviluppare i primi programmini grafici che prendono un input dall’utente. Buona programmazione

Ciauz

GtkImage – Immagini in Gtk+

Le funzioni per il caricamento di un’immagine in un programma con le gtk+, uniscono ( o richiedono ) operazioni con la libreria Gdk e GdkPixbuf.

Come per tutte le altre cose, io mi concentro unicamente sulle funzioni principali, tralasciando quelle specifiche per casi particolari, quindi iniziamo a vedere come caricare un’immagine da file e da stock. Per il primo c’è una funzione che fa tutto: gtk_image_new_from_file () che riceve come argomento il nome del file\immagine e ritorna, in tipo GtkWidget *, la nostra immagine se il caricamento è avvenuto con successo, altrimenti questa stock. Proprio per il fatto che questa funzione non ritorni mai NULL e non dia informazioni sul tipo di errore quando non è possibile caricare il file\immagine specificato si può ricorrere ad un altra funzione che esegue esattamente la stessa cosa ma che allunga, anche se di poco, il giro da fare per visualizzare l’immagine finale.

La funzione è gdk_pixbuf_new_from_file () che riceve come primo argomento sempre il nome del file\immagine da caricare, e come secondo  argomento l’indirizzo di una variabile GError *, che verrà impostata nel caso la funzione ritorni NULL ( ovvero nel caso sia occorso un qualche tipo di errore ). Questa funzione però ritorna un GdkPixbuf * che noi possiamo tranquillamente convertire nel nostro GtkWidget * da visualizzare tramite la funzione gtk_image_new_from_pixbuf (). Se non vi è chiaro ancora questo metodo un pochino più articolato faccio un codice di esempio:

1
2
3
4
5
6
7
8

GtkWidget *image;
GdkPixbuf *pixbuf;
GError *error = NULL;
 
pixbuf = gdk_pixbuf_new_from_file ("miofile.jpeg", &error);
if ( !pixbuf )
     g_critical ("(%d) %s\n", error->code, error->message);
image = gtk_image_new_from_pixbuf (pixbuf);

Per quanto riguarda il caricamento di un’immagine da stock il procedimento è semplicissimo, basta passare il nome della stock a gtk_image_new_from_stock ()  e poi specificare la grandezza della stock dipendentemente dal contesto in cui la si vuole utilizzare. Ritorna il GtkWidget * con l’immagine STOCK pronta ad essere visualizzata.

GtkStatusbar – Barra di stato

Per chi non avesse ancora capito quale è in un applicazione gtk+ la barra di stato posto un immagine molto autoesplicativa:

 La creazione è molto semplice, il widget è ottenibile richiamando unicamente la funzione gtk_statusbar_new ()  che non riceve argomenti. Di questo tipo però ci sarebbe da parlare più teoricamente che praticamente. Il suo funzionamento nella visualizzazione dei messaggi avviene tramite stack LIFO su canali sperati. Ovvero per i messaggi son presenti azioni di push e pop, e possono essere inviati su “context id” ( canali ) differenti. Se si vuole utilizzare in modo semplicissimo questa barra di stato è bene utilizzare il canale 0 ed eseguire ( dopo il primo push ) sempre un pop prima di nuovo push così da non lasciare in memoria vecchi messaggi che non servono più.

Codice di esempio:

1
2
3
4
5
6
7
8

GtkWidget *statusbar;
 
statusbar = gtk_statusbar_new ();
gtk_statusbar_push (GTK_STATUSBAR (statusbar), 0, "Starting GtkStatusbar :)");
 
/* successivamente per non lasciare in buffer nulla */
gtk_statusbar_pop (GTK_STATUSBAR (statusbar), 0);
gtk_statusbar_push (GTK_STATUSBAR (statusbar), 0, "Pop & Push!");

Per finire con la status bar, il triangolino per ridimensionare si può “eliminare” tramite la funzione gtk_statusbar_set_has_resize_grip () che riceve come primo argomento la statusbar e come secondo un valore booleano impostato a TRUE se si vuole mantenere il triangolino per il ridimensionamento altrimenti FALSE.

Fine Quattordicesima Puntata
Ok, abbiamo parlato un po’ e ci voleva dopo tanti giorni di silenzio. Spero che sia tutto chiaro, sono stato molto di più sulla teoria questa volta, alla fin fine star lì a descrivere ogni singola funzione non ha molto senso se non si conosce prima su cosa si sta operando.

Ciauz

Del testo con delle Gtk+.. ( GtkLabel )

Un label altro non è che un testo, o una stringa, che si può visualizzare all’interno di un’interfaccia grafica realizzata con le Gtk+.

Un label minimale, ovvero del testo senza alcun effetto è semplicissimo da creare:

1
2
3

GtkWidget *label;
 
label = gtk_label_new ("Salve, sono un label!");

Il codice mi sembra che sia abbastanza esplicito e non abbia bisogno di commenti, andiamo invece ora a vedere come si può creare un label più ricercato. Ovvero con un colore diverso e in grassetto.

1
2
3
4

GtkWidget *label;
 
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), "<span color=\"#990000\" weight=\"bold\">Ciao, io sono un label con markup!</span>");

Dunque il markup che abbiamo usato è molto simile all’html, ed è il così chiamato “Pango Text Attribute Markup Language” i cui tag possono essere trovati in questa pagina.

Passiamo ora un attimo agli attributi che può avere un label:

• Selezionabile: Un label può essere, o meno, selezionabile dall’utente. Per stabilire esplicitamente questa opzione si può ricorrere alla funzione gtk_label_set_selectable che riceve come primo argomento il label a cui impostare l’opzione, e come secondo TRUE o FALSE dipendentemente dall’attributo che gli si vuol dare.
• Giustificabile:Il testo di un label, se composto da più righe, può essere posto tutto a sinistra ( GTK_JUSTIFY_LEFT ), tutto al centro ( GTK_JUSTIFY_CENTER ), tutto a destra ( GTK_JUSTIFY_RIGHT ) o distribuito per tutta la linea ( GTK_JUSTIFY_FILL ).
  Quest’operazione può venire eseguita tramite la funzione gtk_label_set_justify che riceve come primo parametro il label a cui eseguire l’operazione e come secondo il tipo di giustificazione da dargli.
• Compresso: Ovvero, se il label ha una lunghezza superiore a quella del contenitore viene compattato aggiungendo tre puntini nel punto in cui è stato compresso. Questo non va a influire su quando il label viene copiato in quanto nella clipboard verrà inserito tutto il testo del label e non la sua versione compressa. La funzione per far ciò è gtk_label_set_ellipsize che riceve come primo argomento il label a cui applicare l’operazione e come secondo argomento il punto in cui fare la compressione che può avvenire: all’inizio ( PANGO_ELLIPSIZE_START ), al centro ( PANGO_ELLIPSIZE_MIDDLE ) e alla fine ( PANGO_ELLIPSIZE_END ).
• Spezzato: Se una riga di un label supera la lunghezza del contenitore può venire spezzato mandando a capo le parole, o i caratteri, che superano la lunghezza. La funzione in questo caso è gtk_label_set_line_wrap_mode per impostare il tipo di “spezzamento” e gtk_label_set_line_wrap per abilitarlo. Tutte e due le funzioni ricevono come primo parametro il label a cui applicare l’effetto, come secondo parametro invece la prima può ricevere i seguenti parametri: PANGO_WRAP_WORD ( per mandare a capo le parole in eccesso ), PANGO_WRAP_CHAR ( per mandare a capo i caratteri in eccesso ), PANGO_WRAP_WORD_CHAR ( per mandare a capo le parole in eccesso dove possibile, se non è possibile perchè una sola parola è troppo lunga manda a capo i caratteri in eccesso ). La seconda funzione riceve invece come secondo parametro TRUE se si vuol utilizzare il WRAP del testo, altrimenti FALSE.
• Ruotato: Si può anche dare un’inclinazione al label da 0° a 90°  tramite la funzione gtk_label_set_angle, che riceve come primo argomento il label a cui applicare la rotazione e come secondo argomento l’angolo di rotazione in double.

Esistono anche dei segnali collegabili ad un label e sono i seguenti, il più utile tra questi è “copy-clipboard” che viene inviato quando il testo di un label viene copiato ( associato di solito alla scorciatoia CTRL + C ).

Fine Tredicesima Puntata
Anche questa è fatta, a questo punto penso che ci siano le basi per iniziare a creare delle interfacce grafiche minimali per i vostri programmi. Alla prossima.

Ciauz

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

Pulsanti Classici ( Button )

Iniziamo con i pulsanti classici, ovvero i più comuni che possono contenere solo del testo o anche un’immagine al loro interno.

Si possono creare con tre funzioni:

• gtk_button_new () → Crea un pulsante vuoto, senza testo e senza immagine così da poter settare le varie caratteristiche in seguito.
• gtk_button_new_with_label () → Crea un pulsante con del testo, si può anche qui naturalmente aggiungere un’immagine in seguito.
• gtk_button_new_from_stock () → Crea un pulsante con immagine e testo predefinito di una “STOCK”. Una stock è un elemento interno alle Gtk+ che comprende un’icona e un testo standard, il testo delle stock ha il vantaggio di essere tradotto automaticamente nella lingua del sistema. Le Stock esistenti ed utilizzabili si possono esaminare in questa pagina.

Vediamo un esempio di pulsante creato “from stock”:

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

#include <gtk/gtk.h>
 
int main (int argc, char *argv[])
{
 GtkWidget *window, *button;
 
 gtk_init (&argc, &argv);
 
 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 gtk_window_set_title (GTK_WINDOW (window), "Stock Button");
 gtk_window_set_default_size (GTK_WINDOW (window), 250, 45);
 
 button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
 gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NORMAL);
 gtk_container_add (GTK_CONTAINER (window), button);
 
 gtk_widget_show_all (window);
 
 gtk_main ();
 
 return 0;
}

Come si può vedere però è presente il bordo del pulsante, cioè l’effetto rilievo che lo fa risultare come parte esterna al resto dell’applicazione ( prendete ad esempio la barra a comparsa che esce quando si cerca una parola in firefox, il pulsante per chiuderla non è in rilievo ).. per fare in modo che non sia in rilievo o per cambiare il tipo di rilievo si utilizza l’attributo “relief” tramite la funzione gtk_button_set_relief.

I segnali collegabili a questo tipo di pulsanti, che è il padre di tutti gli altri che tra poco vedremo, sono:

• “activated” – viene emesso quando il pulsante è premuto o rilasciato.
• “clicked” – viene emesso quando il pulsante è premuto e rilasciato
• “pressed” – viene emesso quando il pulsante è premuto
• “clicked” – viene emesso quando il pulsante è rilasciato

Pulsanti “Toggled” ( ToggledButton )

I pulsanti di tipo “toggled” sono quei pulsanti che una volta premuti rimangono premuti e non ritornano “su” finchè non vengono ripremuti. Non si possono creare “from stock” ma solo con testo o senza niente.

Per impostare il loro stato manualmente su “premuto\giù” o “rilasciato\su” si può usare la funzione gtk_toggle_button_set_active.

Il segnale aggiuntivo che ha questo tipo rispetto al precedente è quello “toggled” che viene emesso quando il pulsante cambia stato.

Pulsanti di Controllo ( CheckButton )

I “Pulsanti di Controllo” ( che vi prego di farmi chiamare col loro nome originario “CheckButton” perché questa italianizzazione non mi piace per niente ) sono molto importanti specialmente nelle “preferenze” di un programma.

Sono una sottocategoria dei Toggled e ne ereditano tutte le caratteristiche. Quindi non possono essere creati “from stock” ed hanno anch’essi il segnale aggiuntivo “toggled”.

Pulsanti per la selezione di un colore ( ColorButton )

Non è un pulsante comunissimo lo devo ammettere, ma comunque può tornare utile. Può essere creato vuoto, così da settare i vari attributi successivamente, oppure con un colore predefinito ( se non lo si setta viene messo il nero ) a scelta. Per farlo bisogna utilizzare un GdkColor in questo modo:

1
2
3
4
5
6
7

 
GtkWidget *color_button;
GdkColor color;
 
if ( gdk_color_parse ("#990000", &color) )
     color_button = gtk_color_button_new_with_color (&color);
else color_button = gtk_color_button_new ();

Per poi ottenere il colore si può utilizzare la funzione gtk_color_button_get_color.

 Pulsanti per la selezione di un font ( FontButton )

Questo pulsante è ancor meno comune del precedente, serve per far selezionare un font all’utente.. apre una finestra ( che in futuro ritroveremo ) dove selezionare il font preferito. La sua creazione può avvenire tramite gtk_font_button_new_with_font che ha come parametro il nome del font da inserire come predefinito, ad esempio con “Monospace 10″ avremo selezionato il font monospace a dimensione 10.

Pulsanti per link ( LinkButton )

Questi pulsanti si ritrovano spesso nei dialoghi di informazione per creare un collegamento al sito o alla pagina dedicata al programma. La parte più difficile nella gestione di questi pulsanti è l’apertura del link in questione, ma potete prendere spunto da questa funzione che avevo fatto per questi casi.

Pulsanti per il “volume” ( Volume Button )

Concludiamo questo tour tra i pulsanti con quelli per il “volume” ( anche se possono essere usati in molti altri casi ). Questo tipo di pulsanti comprende una sola funzione che consente la loro creazione, ovvero: gtk_volume_button_new.

Ciò avviene perchè questo tipo è un sottotipo del tipo “ScaleButton”, quindi le funzioni riferite al gruppo padre devono venir usate per operare con questo figlio.

Fine Dodicesima Puntata
Mi dispiace un po’ aver già finito, ci ho messo tanto a fare le finestre, i contenitori e tutto il resto del mondo e per i pulsanti che ritengo più interessanti c’è poco da dire, vabbè alla prossima .

Ciauz

Questo terzo capitolo sui contenitori è l’ultima tappa dopodichè passaremo come promesso ai pulsanti. Preparatevi che iniziamo!

Frame

 Un frame è un’area delimitata da un bordo e con un titolo, come si può benissimo vedere dall’immagine a lato.

 La sua creazione è molto semplice:

1

 gtk_frame_new ("Titolo Frame");

Il parametro, che rappresenta il testo che verrà visualizzato in alto, può anche essere omesso o risettato successivamente con la funzione gtk_frame_set_label. Non esistono altre operazioni con i frame importanti se non quella che permette di modificare lo stile del bordo che può essere:

• GTK_SHADOW_NONE – nessun bordo
• GTK_SHADOW_IN – il bordo è incassato all’interno
• GTK_SHADOW_OUT – il bordo è incassato all’esterno
• GTK_SHADOW_ETCHED_IN – il bordo è incassato verso l’interno con un aspetto 3D
• GTK_SHADOW_ETCHED_OUT – il bordo è incassato verso l’esterno con un aspetto 3D

Si lo so, le descrizioni non sono molto chiare degli ultrimi 4 tipi.. ho fatto un programma di test per vedere graficamente cosa cambiava e non vedo molte differenze. Vi lascio comunque lo screen:

Pannelli

I pannelli detti GtkPaned sono dei widget che permettono il ridimensionamento delle due “aree” ( o pannelli ) che ha al suo interno da parte dell’utente.

Possono essere di due tipi, intuibili dall’immagine superiore, ovvero: Orizzontali e verticali. La loro creazione avviene quindi con gtk_hpaned_new o gtk_vpaned_new. Queste due funzioni non ricevono argomenti e restituiscono il nostro GtkPaned.

 Ha solo due funzioni che ci servono e useremo quando opereremo con questo tipo: gtk_paned_add1 e gtk_paned_add2. Tutte e due ricevono come primo argomento il nostro GtkPaned e come secondo argomento il widget da inserirci ( gtk_paned_add1 riguarda la posizione a sinistra o in alto, gtk_paned_add2 quella a destra o in basso ).

Fine Undecesima Puntata
Sono andato abbastanza veloce eh? Beh non c’era molto da dire su questi due contenitori.. per problemi su questo argomento, come su qualunque altro nel corso delle puntate chiedete pure nei commenti.

Ciauz

Aprite il vostro editor e compilatore, preparate il vostro quadernetto con gli appunti che iniziamo!

Tabelle

Una tabella penso sappiate tutti cosa sia, un riquadro composto da un tot di righe e un tot di colonne. Questo tipo di contenitore è molto comodo nel caso si debbano allineare molti widget senza stare ad impazzire con 1000 box, ad esempio se si sta scrivendo una calcolatrice.

Bene l’utilizzo è molto semplice, non vi mostro la funzione “easy” per aggiungere i vari widget perché la maggiorparte delle volte crea solo obbrobri.. vi mostro invece la procedura con la funzione relativamente difficile che vi consiglio di usarel’80% delle volte.

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

#include <gtk/gtk.h>
 
int main (int argc, char *argv[])
{
 GtkWidget *window, *table, *button;
 int rows, cols;
 
 gtk_init (&argc, &argv);
 
 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 gtk_window_set_title (GTK_WINDOW (window), "Ciao Tabelle!");
 gtk_container_set_border_width (GTK_CONTAINER (window), 3);
 
 table = gtk_table_new (4, 3, TRUE);
 gtk_container_add (GTK_CONTAINER (window), table);
 
 for ( rows = 0; rows < 4; rows++ ) {
       for ( cols = 0; cols < 3; cols++ ) {
             button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
             gtk_table_attach (GTK_TABLE (table), button, cols, cols + 1,
                               rows, rows + 1, GTK_FILL | GTK_EXPAND,
                               GTK_FILL | GTK_EXPAND, 0, 0);
             g_signal_connect (G_OBJECT (button), "clicked",
                               G_CALLBACK (gtk_main_quit), NULL);
       }
 }
 
 gtk_widget_show_all (window);
 g_signal_connect (G_OBJECT (window), "delete_event",
                   G_CALLBACK (gtk_main_quit), NULL);
 
 gtk_main ();
 return 0;
}

Con questo codice abbiamo la seguente tabella:

Ok iniziamo a spiegare i vari punti:

1

 table = gtk_table_new (4, 3, TRUE);

Con questa funzione si crea una nuova tabella, i parametri sono in ordine: il numero di righe, il numero di colonne, se riservare a tutte le celle lo stesso spazio.

1
2
3

  gtk_table_attach (GTK_TABLE (table), button, cols, cols + 1,
                    rows, rows + 1, GTK_FILL | GTK_EXPAND,
                    GTK_FILL | GTK_EXPAND, 0, 0);

Questa era la funzione difficile di cui vi parlavo, quello che fa paura è il numero di parametri.. ma andiamo a vederli nello specifico

1. La tabella in cui inserire il widget
2. Il widget da inserire
3. Posizione della colonna di partenza
4. Posizione della colonna finale
5. Posizione della riga di partenza
6. Posizione della riga finale
7. Attributi dell’ancoraggio orizzontale
8. Attributi dell’ancoraggio verticale
9. Padding ( Ovvero spazio in pixel ) aggiuntivo da riservare orizzontalmente
10. Padding aggiuntivo da riservare verticalmente

Ok, scommetto che non vi sono chiari i punti dal 3 al 6 se vi sono chiari pazienza, spiego ugualmente.

Dovete immaginarvi la tabella in questo modo:

Il widget iniziale quindi partirà dalla colonna\riga 0 e finirà alla colonna\riga 1 indi x(0,1)\y(0,1), il secondo widget x(1,2)\y(0,1) e così via..

Ora ritornando ai parametri che richiede la funzione gtk_table_attach mi soffermerei due secondi sui punti 7 e 8. ovvero sugli attributi che possono essere dati. Bene gli attributi possono essere usati contemporaneamente unendoli tramite OR ( | ) e sono:

• GTK_FILL: Fa in modo che il widget sia “incollato” alla colonna precedente
• GTK_EXPAND: Dà la possibilità al widget di espandersi adattandosi alle dimensioni della cella.
• GTK_SHRINK: Richiede al widget di occupare il minor posto possibile all’interno della cella.

Abbiamo concluso con le tabelle, l’ultima cosa da sapere è che si può settare uno spazio di default tra le varie celle tramite le funzioni: gtk_table_set_row_spacings e gtk_table_set_col_spacings dando come primo parametro la tabella e come secondo lo spazio in pixel che si vuole impostare alle varie righe o colonne.

Fine Decima Puntata
OOooooook, vi aspetto nella prossima puntata così concludiamo veramente e definitivamente l’argomento Contenitori, e passiamo a cosa più stimolanti come i pulsanti!
Ciauz

Nell’ultima puntata, qualche secolo fa, avevo preannunciato che in questa avremmo iniziato a parlare dei contenitori.
Benissimo, non perdiamo altro tempo e iniziamo!

Box

Dunque il tipo box, o meglio, GtkBox, è uno dei tipi più semplici per “impacchettare” i widget. Vi chiederete forse “che vuol dire impacchettare? a che serve?”. Iniziamo a rispondere alla prima domanda, impacchettare vuol dire inserire uno o più widget dentro un altro; mentre per quanto riguarda lo scopo possiam dire che i vari contenitori servono per dare un aspetto migliore all’interfaccia, ovvero a posizionare per bene i widget.. ad esempio se si vuole fare un interfaccia con il titolo su una riga e sotto seguito da due bottoni uno di fianco all’altro.

Vediamo subito un esempio che rende tutto più chiaro:

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

#include <gtk/gtk.h>
 
int main (int argc, char *argv[])
{
 GtkWidget *window, *hbox, *vbox, *widget;
 
 gtk_init (&argc, &argv);
 
 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 gtk_window_set_title (GTK_WINDOW (window), "Test con i Box");
 gtk_window_set_default_size (GTK_WINDOW (window), 300, 100);
 gtk_container_set_border_width (GTK_CONTAINER (window), 3);
 
 vbox = gtk_vbox_new (FALSE, 2);
 gtk_container_add (GTK_CONTAINER (window), vbox);
 
 hbox = gtk_hbox_new (FALSE, 0);
 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
 
 widget = gtk_label_new ("Ciao BOX!");
 gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, FALSE, 0);
 
 hbox = gtk_hbox_new (FALSE, 0);
 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
 
 widget = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
 gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
 g_signal_connect (G_OBJECT (widget), "clicked", G_CALLBACK (gtk_main_quit), NULL);
 
 widget = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
 gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
 g_signal_connect (G_OBJECT (widget), "clicked", G_CALLBACK (gtk_main_quit), NULL);
 
 gtk_widget_show_all (window);
 gtk_main ();
 
 return 0;
}

Innanzitutto, prima di spiegare il codice, bisogna notare che esistono due tipi di box: orizzontali e verticali. La differenza tra i due si può immaginare: se vengono impacchettati widget in un box orizzontale saranno messi uno di fianco all’altro, mentre se si impacchettano widget in un box verticale verranno messi uno sotto ( o sopra ) l’altro.

In questo codice noi vediamo il box principale che è verticale, al cui interno abbiamo inserito dei box orizzontali. La funzione gtk_box_pack_start permette di inserire un widget in un box allineandolo all’inizio del box, riceve come parametri:

1.  il box in cui inserire il widget
2. il widget da inserire
3. TRUE se si vuole che il widget venga “espanso” occupando tutto lo spazio possibile, altrimenti FALSE
4. TRUE se si vuole che il widget venga “attaccato” all’inizio del box
5. Spazio aggiuntivo in pixel con i widget “vicini”, una specie di bordo.

Naturalmente esistono altre funzioni per impacchettare i widget e li potete trovare con relativa descrizione ( in inglese ) qui.

Lasciando stare ora l’impacchettamento,  guardiamo la creazione che è molto più veloce. Come si può vedere nel codice ho utilizzato due semplici funzioni per creare un box: gtk_hbox_new, gtk_vbox_new. Si può intuire che la prima sia per creare box orizzontali, mentre la seconda verticali. Ricevono entrambe come parametri:

1. TRUE se si vuole che i widget inseriti abbiano tutti lo stesso spazio nel box.
2. Distanza in pixel tra i vari widget inseriti.

Esiste però un altro tipo di box di cui non ho ancora parlato, ed è un box specifico per i pulsanti e il loro allineamento, il suo nome è GtkButtonBox. Anche lui può essere orizzontale e verticale.. vediamo un esempio:

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

#include <gtk/gtk.h>
 
int main (int argc, char *argv[])
{
  GtkWidget *window, *button, *button_box;
  int i = 0;
 
  gtk_init (&argc, &argv);
 
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_default_size (GTK_WINDOW (window), 400, -1);
 
  button_box = gtk_hbutton_box_new ();
  gtk_button_box_set_layout (GTK_BUTTON_BOX (button_box), GTK_BUTTONBOX_EDGE);
  gtk_container_add (GTK_CONTAINER (window), button_box);
 
  while ( i++ < 3 ) {
          button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
          gtk_box_pack_start_defaults (GTK_BOX (button_box), button);
          g_signal_connect (G_OBJECT (button), "clicked",
                            G_CALLBACK (gtk_main_quit), NULL);
  }
 
  gtk_widget_show_all (window);
 
  gtk_main ();
  return 0;
}

A differenza dei normali box, la creazione di un nuovo button box non richiede argomenti, ma richiede invece, eventualmente, il tipo di layout che dovranno avere i pulsanti inseriti al suo interno. I layout disponibili sono:

• GTK_BUTTONBOX_DEFAULT_STYLE -> Layout di default
• GTK_BUTTONBOX_SPREAD -> I pulsanti avranno tutti lo stesso spazio sia tra di loro sia riguardo i bordi.
• GTK_BUTTONBOX_EDGE -> Come per il layout SPREAD, solo che non c’è spazio ai bordi
• GTK_BUTTONBOX_START -> I pulsanti vengono allineati tutti all’inizio
• GTK_BUTTONBOX_END -> I pulsanti vengono allineati tutti alla fine
• GTK_BUTTONBOX_CENTER -> I pulsanti vengono allineati tutti al centro

Fine Nona Puntata
Bene, preferisco fermarmi qui, così la prossima volta potremmo affrontare con più calma le tabelle e tutto il resto sui contenitori.
Ciauz

Ed ecco qui, subito subito la funzione:

unsigned char get_value_from_binary_string (const char *s)
{
 short int i;
 unsigned char byte = 0;
 
 if ( !s || strlen (s) != ( sizeof (unsigned char) * 8 ) )
      return byte;
 
 for ( i = (sizeof (unsigned char) * 8) - 1; i > -1; i-- )
       byte = ( byte | (s[(sizeof (unsigned char) * 8) - ( 1 + i )] - '0') ) << ( i ? 1 : 0 );
 
 return byte;
}

Naturalmente qua si parla di una stringa contenente il valore di un byte, ma è facilmente utilizzabili con stringhe contenenti valori di 2, 4, 8, 16, 32 e 64 byte utilizzando le variabili appropriate.
Il fulcro della conversione comunque sta in quelle due righe di for. 2 righe e si fa quello che molti altri farebbero in minimo 20 in modo osceno.

Ciauz

In questa puntata vedremo i dialoghi di assistenza, conosciuti nelle gtk+ come GtkAssistant che sono molto utili nelle procedure guidate. Iniziamo.

Dialoghi di Assistenza

I dialoghi di assistenza sono dei dialoghi composti da tante pagine che possono essere cambiate tramite dei pulsanti in fondo al dialogo che possono essere: Avanti, Indietro, Ultimo, Applica, Annulla, Primo.
Proprio per questa particolarità quando operiamo con un dialogo di questo tipo ci dobbiamo un po’ incasinare la vita con le funzioni, ma sono semplicissime da gestire. Innanzitutto vediamo com’è composta la funzione principale per la creazione di questo dialogo.

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

void main_assistant (void)
{
 static GtkWidget *assistant = NULL;
 int i = 0;
 
 if ( !assistant ) {
      assistant = gtk_assistant_new ();
      gtk_window_set_default_size (GTK_WINDOW (assistant), 460, 235);
      gtk_window_set_modal (GTK_WINDOW (assistant), TRUE);
 
      g_signal_connect (G_OBJECT (assistant), "cancel", G_CALLBACK (on_assistant_close_cancel), NULL);
      g_signal_connect (G_OBJECT (assistant), "close",  G_CALLBACK (on_assistant_close_cancel), NULL);
      g_signal_connect (G_OBJECT (assistant), "apply",  G_CALLBACK (on_assistant_apply), assistant);
      g_signal_connect (G_OBJECT (assistant), "prepare", G_CALLBACK (on_assistant_prepare), NULL);
 
      make_page_one (GTK_ASSISTANT (assistant));
      make_page_two (GTK_ASSISTANT (assistant));
      /* Etc.. etc.. */
 }
 
 if ( !GTK_WIDGET_VISIBLE (assistant) )
      gtk_widget_show (assistant);
 else {
      gtk_widget_destroy (assistant);
      assistant = NULL;
 }
}

Dopodichè si possono creare le varie pagine.. e adesso vediamo come.

La creazione di una nuova pagina è molto semplice  innanzitutto si crea tutta la tabella o box nei quali inserire i vari widget ecc… cioè si crea il contenuto dopodichè si visualizza tutto con gtk_widget_show_all passato al widget superiore e infine si inserisce nel dialogo di assistenza in questo modo:

1
2
3
4
5
6
7

 gtk_assistant_insert_page (assistant, table, i);
 gtk_assistant_set_page_title (assistant, table, "Pagina di test");
 gtk_assistant_set_page_complete (assistant, table, TRUE);
 gtk_assistant_set_page_type (assistant, table, GTK_ASSISTANT_PAGE_CONTENT);
 pixbuf = gtk_widget_render_icon (GTK_WIDGET (assistant), GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG, NULL);
 gtk_assistant_set_page_header_image (assistant, table, pixbuf);
 g_object_unref (pixbuf);

Dunque andiamo per righe:

1. Abbiamo inserito nel posto “i“  il widget principale, in questo caso una tabella, nel nostro dialogo.
2. Abbiamo impostato alla pagina dell’assistent contenente come widget principale la tabella il titolo “Pagina di test”
3. Abbiamo impostato la pagina come completa, cioè si può andare avanti alla pagina successiva o fare applica, di solito una pagina è completa a priori quando contiene parametri facoltativi. La si può impostare in un secondo momento come attiva o non attiva tramite la funzione gtk_assistant_set_page_complete che riceve come parametri il nostro dialogo di assistenza, il widget che corrisponde alla pagina interessata e infine TRUE o FALSE per indicare se la pagina è completa o meno.
4. Abbiamo impostato il tipo di pagina, i tipi impostabili li si può trovare QUI.
5. Abbiamo creato una nuova immagine da inserire come “HEADER” ( intestazione ) della pagina.
6. L’abbiamo inserita.
7. Abbiamo liberato la memoria occupata da pixbuf.

Ora andiamo a vedere invece come usare tutte le funzioni collegate ai vari segnali che abbiamo visto prima.

La prima è on_assistant_close_cancel che viene chiamata quando il dialogo viene chiuso o annullato.

1
2
3
4
5

static void
on_assistant_close_cancel (GtkWidget *widget, gpointer data)
{
 gtk_widget_hide (widget);
}

In questo caso io ho semplicemente nascosto il dialogo di assistenza, perchè quando si richiama la funzione applica dopo aver recuperato i dati setto tutti i widget com’erano di default.

La seconda è  on_assistant_apply che è inutile vederla dato che dipende da caso a caso cosa andare a recuperare e cosa fare.. viene chiamata solo quando la procedura è finita quindi non ci son molte cose da fare col dialogo di assistenza.

La terza e ultima è on_assistant_prepare che come abbiamo detto viene chiamata quando si passa da una pagina ad un’altra. Queste funzioni naturalmente possono essere usate un po’ come si vuole, io questa qui l’ho usato per impostare il numero della fase corrente sulle fasi totali come titolo del dialogo.

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

static void
on_assistant_prepare (GtkWidget *widget, GtkWidget *page, gpointer data)
{
  gint current_page, n_pages;
  gchar *title;
 
  current_page = gtk_assistant_get_current_page (GTK_ASSISTANT (widget));
  n_pages = gtk_assistant_get_n_pages (GTK_ASSISTANT (widget));
 
  title = g_strdup_printf ("Inserimento Cliente (%d of %d)", current_page + 1, n_pages);
  gtk_window_set_title (GTK_WINDOW (widget), title);
  g_free (title);
}

E con questo è tutto. Abbiamo finito col GtkAssistant.

Fine Ottava Puntata
Ordunque, sembra venuta bene questa puntata.. pensavo peggio. Ora abbiamo finito di occuparci delle finestra, la prossima volta ci occuperemo dei contenitori.
Ciauz

Dov’eravamo rimasti? Ah si, i dialoghi di informazione. Bene Iniziamo subito e non perdiamoci in chiacchiere.

Dialoghi di Informazione

I dialoghi di informazione sono presenti nella maggior parte delle applicazioni gtk, essi servono a informare l’utente sul tipo di licenza con cui è rilasciato il programma, qual’è il sito web del progetto, il logo, la versione, chi sono gli sviluppatori o i grafici e così via..

Il tipo di widget riguardante questo dialogo è GtkAboutDialog, la sua creazione è molto semplice.. lo si può creare con un GtkWidget essendo il tipo su cui si basa quindi:

GtkWidget *about_dialog = gtk_about_dialog_new ();

Dopodiché si possono settare i vari attributi, essendo molti e trattandosi di semplici funzioni usabili molto semplicemente rimando al link ( GtkAboutDialog ) della documentazione ufficiale.
Una volta creato si potrà visualizzarlo con la funzione gtk_widget_show.

Fine Settima Puntata
E lo so, è troppo breve questa puntata, ma è una grande puntata perchè da ora in poi sarò costretto a scrivere “on the run” le varie puntate visto che la guida che avevo iniziato a scrivere è finita. Nella prossima puntata vedremo i Dialoghi di Assistenza ( Assistant Dialog ) e poi avremmo finito con le finestre e inizieremo con i pulsanti, poi le tabelle\box e poi vederemo. Bye

Dov’è che eravamo arrivati? Ah si, i dialoghi . Oggi vedremo le Finestre vere, quindi riprendete il vostro compilatore che stava ammuffendo, il vostro vim, geany, gedit, emacs, nano o quello che è e iniziamo.

Finestre

Una finestra è nella stragrande maggioranza dei casi, il widget di base in cui vengono inseriti altri widget. É un contenitore per un solo elemento, per questo più avanti troveremo le tabelle e i box che permettono di inserire, organizzare e tenere in ordine più widget. La loro creazione è molto semplice:

GtkWidget *window;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

Il parametro di gtk_window_new l’abbiamo già spiegato durante l’introduzione alle Gtk+ così come settare il titolo o la dimensione di default. Adesso vedremo come dare un’icona al programma. Ciò lo possiamo fare tramite la funzione gtk_window_set_icon_from_file nel seguente esempio vedremo come utilizzarla.

GtkWidget *window;
GError *error = NULL;
 
gboolean chk;window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
chk = gtk_window_set_icon_from_file (GTK_WINDOW(window), "myicon.png", &error);
 
if ( chk == FALSE ) {
     g_warning (error->message);
     g_error_free (error);
}

Abbiamo introdotto due nuovi tipi delle Glib: Gerror e gboolean. Il primo è una struttura organizzata in questo modo:

typedef struct {
     GQuark domain;
     gint code;
     gchar *message;
} GError;

In questo modo abbiamo in domain ( che è un GQuark, un tipo che equivale a unsigned long int ) l’indentificativo univoco del tipo di errore, in code il codice di errore, una sorta di variabile errno, e infine in message la stringa di errore “human-readable” ovvero visualizzabile direttamente come output.
Dopo aver caricato l’immagine, nell’if, troviamo la funzione g_warning sempre delle glib, ne esistono 5 di questo “tipo” con effetti diversi:

1. g_message -> riporta semplici messaggi.
2. g_warning -> riporta avvertimenti, ovvero errori non fatali per il proseguimento dell’applicazione.
3. g_critical -> riporta avvertimenti, fatali per il proseguimento di alcune operazioni.
4. g_error-> riporta errori, fatali per il proseguimento dell’applicazione. Dopo aver visualizzato il messaggio chiama la funzione abort () per terminare il programma.
5. g_debug -> funzione per riportare messaggi riguardanti il debug dell’applicazione.

Una volta capito questo piccolo esempio andiamo a vedere come si può fare a settare un’immagine come icona del programma nel caso essa non sia un file ma sia memorizzata in qualche variabile all’interno del programma. Per fare questa operazione abbiamo bisogno della libreria GdkPixbuf sempre all’interno delle Gtk+ come sotto categoria della libreria Gdk.
Il formato più comune e semplice da utilizzare all’interno dell’applicazione è XPM. Un’icona ad esempio di una pagina in XPM può essere creata così:

static const char * xpm_data[] = {
"16 16 3 1",
"       c None",
".      c #000000",
"X      c #FFFFFF",
"                ",
"   ......       ",
"   .XXX.X.      ",
"   .XXX.XX.     ",
"   .XXX.XXX.    ",
"   .XXX.....    ",
"   .XXXXXXX.    ",
"   .XXXXXXX.    ",
"   .XXXXXXX.    ",
"   .XXXXXXX.    ",
"   .XXXXXXX.    ",
"   .XXXXXXX.    ",
"   .XXXXXXX.    ",
"   .........    ",
"                ",
"                "};

L’immagine è composta nella maniera seguente:

•  Prima Riga:
  • Primo Numero: Larghezza
  • Secondo Numero: Altezza
  • Terzo Numero: Colori Immagine
  • Quarto Numero: Caratteri per Pixel
• Seconda Riga:
  • Inizia la dichiarazione di tutti i colori nel formato carattere       c colore
• Una volta finito di specificare i colori si può iniziare a disegnare

Alla fine della creazione dell’immagine, la si memorizza in una variabile GdkPixbuf * in questo modo:

GdkPixbuf *pixbuf = gdk_pixbuf_new_from_xpm_data (xmp_data);

E infine la si setta come icona tramite la funzione gtk_window_set_icon che riceve come primo parametro la finestra a cui settare l’icona e come secondo parametro il GdkPixbuf con l’immagine.
Ultima cosa da dire su quest’argomento delle icone è che se si volesse settare un’icona univoca per tutte le finestre e dialoghi creati nel programma bisognerà usare la funzione gtk_set_default_icon_from_file o gtk_set_default_icon che funzionano esattamente come le funzioni che abbiamo visto tranne per il fatto che non richiedono la finestra come primo parametro.

Per finire con le finestre invece, vediamo come rendere una finestra modale, ovvero che forza il controllo sull’ultima finestra aperta. Abbiamo bisogno di sole due funzioni: gtk_window_set_transient_for e gtk_window_set_modal. La prima funzione serve a rendere “parenti” la finestra corrente con quella principale, riceve infatti come primo parametro la finestra corrente e come secondo quella principale. La seconda funzione invece abilita o disabilita ( dipendentemente dal secondo parametro ) il controllo forzato sulla finestra passata come primo parametro, per forzare il controllo bisognerà passare come secondo parametro TRUE altrimenti FALSE.

Fine Sesta Puntata
Bene, abbiamo recuperato il tempo perso con questa puntatona. Abbiamo pure introdotto le immagini XPM e il tipo GdkPixbuf.. direi che nella prossima puntata vedremo i Dialoghi di Informazione e poi ho finito di scopiazzare la guida che avevo scritto e dovrò iniziare a scriverla direttamente qui e quindi si potrebbe pensare di andare a vedere il tipo di finestra GtkAssistant… chissà. Buona notte, data l’ora e ciauz

Ora ci occupiamo delle varie finestre anche perché senza di esse non si va da nessuna parte.

Ready? GO!

Dialoghi

Un dialogo è simile ad una finestra, che vedremo tra poco, viene usato principalmente per il riporto di piccoli messaggi o la richiesta di input semplici. Essendo del tipo finestra può essere utilizzato con la macro GTK_CONTAINER, GTK_WINDOW e GTK_DIALOG godendo di tutte le funzioni relative ad ognuno di questi tipi. Ci son due modi per creare un Dialogo, il primo lo si usa quando si vuole settare da 0 tutto come con una finestra e lo si fa tramite:

1
2
3

GtkWidget *dialog;
 
dialog = gtk_dialog_new ();

L’altro metodo invece permette di avere una finestra di dialogo già pronta, come quando ad esempio bisogna visualizzare una finestra di errore, di info o quando bisogna proporre una scelta a cui si può rispondere si o no..
Il metodo è il seguente:

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

GtkWidget *dialog, *dialog_area, *label;
 
dialog = gtk_dialog_new_with_buttons ("Titolo dialogo",
                                      finestra_principale,
                                      GTK_DIALOG_MODAL,
                                      GTK_STOCK_OK,
                                      GTK_RESPONSE_OK,
                                      NULL);
 
dialog_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
label = gtk_label_new ("Testo all'interno del dialogo");
gtk_container_add (GTK_CONTAINER (dialog_area), label);
 
gtk_dialog_run (GTK_DIALOG(dialog));

Dunque esaminando meglio i parametri vediamo che al primo posto è il titolo del dialogo ( o NULL se si vuole utilizzare il titolo di default delle finestre gtk ), come secondo parametro la finestra principale ( o NULL se non è presente ), come terzo i Flags del dialogo che possono essere:

• GTK_DIALOG_MODAL
• GTK_DIALOG_DESTROY_WITH_PARENT
• GTK_DIALOG_NO_SEPARATOR

La prima forza il controllo sul dialogo e quindi non permette di usare la finestra principale, la seconda fa sì che una volta chiuso il dialogo si chiuda anche la finestra a cui è collegata e infine l’ultima non inserisce una linea separatrisce tra il contenuto del dialogo ed eventuali bottoni inseriti.
Continuando gli argomenti dal quarto posto in poi sono facoltativi e finisce di aspettarsi argomenti quando trova il parametro NULL. I parametri facoltativi vanno di due in due, ovvero: STOCK_BUTTON – VALORE_DI_RITORNO. Nel nostro caso abbiamo il pulsante OK che ritorna il valore GTK_RESPONSE_OK. Il valore del pulsante premuto verrà restituito da dialog_run ( che restituisce un gint ).

Andando avanti nella creazione di questo dialogo, vediamo la funzione gtk_dialog_get_content che restituisce un GtkContainer sotto forma di GtkWidget dove poter inserire il contenuto del dialogo, nel nostro caso abbiamo inserito un semplicissimo label. Questo caso non l’ho fatto casualmente ma per un motivo ben preciso ovvero il poter introdurre il tipo GtkMessageDialog.

Esso altro non è che un’astrazione di GtkDialog fatta appositamente per creare dialoghi che riportano messaggi. Il suo prototipo è:

1
2
3
4
5
6

GtkWidget*          gtk_message_dialog_new     (GtkWindow *parent,
                                                GtkDialogFlags flags,
                                                GtkMessageType type,
                                                GtkButtonsType buttons,
                                                const gchar *message_format,
                                                ...);

Il primo parametro è la classica finestra principale, il secondo sono i flag del dialogo ( quei tre descritti poco fa ), il terzo il tipo di messaggio che può essere uno di questi:

• GTK_MESSAGE_INFO → Messaggio di informazione
• GTK_MESSAGE_WARNING → Messaggio di errore non fatale
• GTK_MESSAGE_QUESTION → Messaggio di domanda
• GTK_MESSAGE_ERROR → Messaggio di errore fatale
• GTK_MESSAGE_OTHER → Messaggio generico

Dopodichè ci sono i bottoni da visualizzare e abbiamo le seguenti scelte:

• GTK_BUTTONS_NONE → Nessun Pulsante
• GTK_BUTTONS_OK → Visualizza il pulsante OK
• GTK_BUTTONS_CLOSE → Visualizza il pulsante CHIUDI
• GTK_BUTTONS_CANCEL → Visualizza il pulsante ANNULLA
• GTK_BUTTONS_YES_NO → Visualizza i pulsanti SI E NO
• GTK_BUTTONS_OK_CANCEL → Visualizza i pulsanti OK e ANNULLA

Infine abbiamo la stringa del messaggio in modalità printf-like, quindi come quinto argomento potremmo scrivere qualcosa come “Ciao %s, sei sicuro di avere %d anni?”, nome, anni.
Se si vuole utilizzare il markup di pango c’è la funzione gtk_message_dialog_new_with_markup che riceve gli stessi parametri di gtk_message_dialog_new solo che converte ad esempio un testo “<b>ciao</b>” in grassetto.

Per finire, ricordo che i flags dei dialoghi possono essere uniti tramite l’operatore di unione bit-a-bit |.

Fine Quinta Puntata
E lo so, finisce troppo presto.. purtroppo non sono tipo da monologhi e pagine interminabili.
Comunque nella prossima puntata vedremo le finestre intese come GtkWindow promesso.

Mettetevi comodi, e iniziamo!

Ora che abbiamo spiegato un po’ le basi, vediamo come risolvere il problema di prima: il programma che non si chiude dopo aver clickato sul pulsante di chiusura, e giacché ci siamo miglioriamo un po’ l’hello world inserendo un pulsantino e collegandoci un evento

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

#include <gtk/gtk.h>
 
int i = 0;
 
static void
button_func (GtkWidget * widget)
{
  switch (i)
  {
    case 0:
      g_print ("E' la prima volta che clicki :)\n");
      break;
    case 1:
    case 2:
    case 3:
      g_print ("Ci prendi la mano a clickare eh?\n");
      break;
    default:
      g_print ("Ok, basta. Torna a studiar le gtk ;)\n");
      break;
  }
 
  i++;
}
 
int
main (int argc, char *argv[])
{
  GtkWidget *window, *button;
 
  gtk_init (&argc, &argv);
 
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_default_size (GTK_WINDOW (window), 250, 250);
  gtk_window_set_title (GTK_WINDOW (window), "Ciao Mondo delle Gtk+!");
  gtk_widget_show (window);
 
  button = gtk_button_new_with_label ("Clickami!");
  gtk_container_add (GTK_CONTAINER (window), button);
  gtk_widget_show (button);
 
  g_signal_connect (G_OBJECT (window), "delete_event",
                    G_CALLBACK (gtk_main_quit), NULL);
  g_signal_connect (G_OBJECT (button), "clicked",
                    G_CALLBACK (button_func), NULL);
 
  gtk_main ();
  return 0;
}

Dunque, analizziamo un attimo le nuove funzioni, quella più importante e una delle più usate in un programma che utilizza le Gtk+ è g_signal_connect il cui prototipo è:

gulong g_signal_connect (gpointer object, const gchar *signal_name,                                           
                   GCallback handler, gpointer data); 

Ovvero, riceve come primo parametro l’oggetto ( GObject ) a cui collegare il segnale, come secondo parametro il tipo di evento da intercettare ( gli eventi intercettabili cambiano da widget a widget ), come terzo la funzione da chiamare una volta che si verifica l’evento e infine un eventuale parametro da passarci, il parametro deve essere convertito in gpointer ( che equivale al void * ).
Una particolarità della funzione che verrà collegata è che può essere di qualunque tipo, accettare ciò che si vuole e ritornare ciò che vuole. Nel caso però si volesse ottenere nella funzione chiamata il parametro passato e il widget collegato solitamente si utilizza questo prototipo:

gpointer funzione_chiamata (GtkWidget *widget, gpointer data);

In widget sarà l’elemento a cui è collegata la funzione, e in data il parametro passato.

Andando avanti possiamo vedere oltre al classico bottone creato, una funzione particolare, gtk_container_add.

Le Gtk+ hanno una struttura di tipo gerarchico fatta ad esempio in questo modo:

Ora, questa gerarchia è messa un po’ così per far intuire meglio, quella vera delle Gtk+ la potete consultare qui.

Nel caso del nostro script noi abbiamo la finestra che oltre che una finestra è anche un contenitore e quindi al suo interno ci inseriamo direttamente il pulsante che, come si potrà vedere, si espanderà per tutta la dimensione del contenitore, per limitare la sua dimensione potevamo avvalerci o di una tabella o box, nel caso fossero stati presenti più elementi, oppure della funzione gtk_widget_set_usize che forza un widget ad avere esattamente la dimensione scelta. I parametri di quest’ultima funzione sono simili a quelli di gtk_window_set_default_size solo che il primo elemento al posto di essere una GtkWindow è un GtkWidget, quindi nella stragrande maggior parte dei casi non c’è bisogno di eseguire alcun cast.
Per finire quindi, abbiamo visto la funzione gtk_main_quit, che termina l’applicazione gtk ed esce dal programma.

Fine Quarta Putanta
Nella prossima puntata inizieremo ad andare più in profondità studiando i vari tipi di finestre, adesso abbiamo solo dato uno sguardo generale. Bye

E come si può salutare un mondo se non con un bellissimo Hello World ?

Iniziamo.

Hello Gtk+ World!

In questo primo capitolo vedremo come creare piccole e minimali interfacce grafiche, quali sono i widget più comuni e come utilizzarli e tante altre piccole cose che si approfondiranno poi nei capitoli seguenti.

In particolare vedremo come:

• Creare una finestra
• Inserirci dei widget
• Collegare delle funzioni a determinati eventi
• Funziona la logica delle Gtk+

Iniziamo subito con un piccolo codice di esempio:

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

#include <gtk/gtk.h>
 
int main(int argc, char *argv[])
{
 GtkWidget *window;
 
 gtk_init (&argc, &argv);
 
 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 gtk_window_set_default_size (GTK_WINDOW(window), 250, 250);
 gtk_window_set_title (GTK_WINDOW(window), "Ciao Mondo delle Gtk+!");
 gtk_widget_show (window);
 
 gtk_main ();
 return 0;
}

Questo codice come si potrà notare una volta compilato e lanciato produrrà una finestra di questo tipo:

Una cosa che si può notare fin da subito è che se si fa click sul pulsante per chiudere la finestra, l’applicazione resta ancora in esecuzione, ciò avviene perché ancora non gestiamo l’evento di chiusura della finestra, a breve lo vedremo. Prima di tutto però analizziamo il codice.

Nella prima riga troviamo la classica inclusione della libreria gtk, che a sua volta include le glib, pango e altre come sue sotto-librerie e in più include anche la libreria standard di input\output, stdio.h.
Dopodiché vediamo la funzione gtk_init che inizializza l’ambiente gtk ed esamina eventuali argomenti da riga di comando, ad esempio se si lancia l’applicazione con argomento –sync, esso verrà intercettato da gtk_init che provvederà a visualizzare eventuali errori ed eventi in modo sincronizzato con l’applicazione senza ritardi dovuti ad altre operazioni.
Proseguendo troviamo l’inizializzazione del widget ‘window’ che sarà appunto la nostra finestra.
Per crearlo abbiamo dovuto utilizzare la funzione gtk_window_new che riceve come parametro il tipo di finestra, nel nostro caso abbiamo utilizzato GTK_WINDOW_TOPLEVEL che posiziona la nuova finestra appena creata sopra tutte quelle precedenti. Oltre a questo stile però c’è anche GTK_WINDOW_POPUP che ignora il window manager e quindi non visualizza i bordi della finestra.

Dopo aver inizializzato la finestra, gli abbiamo dato le dimensioni, per far ciò abbiamo utilizzato la funzione gtk_window_set_default_size che riceve come primo argomento una GtkWindow, ma avendo noi un GtkWidget per trasformarla in GtkWindow utilizziamo la macro GTK_WINDOW che convertirà il tipo in quello desiderato, come secondo argomento invece riceve la larghezza e l’altezza. Subito dopo impostiamo il titolo e infine visualizziamo la finestra inizializzata.
Alla fine del programma troviamo gtk_main che evita di far chiudere il programma, senza di esso come viene visualizzata la finestra il programma si chiude e con esso si eliminano anche tutti i widget creati.

A questo punto possiamo iniziare a dare uno sguardo generale a come funziona un programma gtk, sono pochi punti:

1. Si inizializza l’ambiente
2. Si creano i widget
3. 1. Gli si stabiliscono i vari attributi
   2. Si visualizzano
4. Si aspetta un qualche evento senza uscire dal programma

Tutto qui

La parte che può ritornare difficile da capire invece è il nome delle funzioni, ma non è niente di particolarmente difficile, la stragrande maggior parte delle funzioni utilizza questa logica:

libreria_tipo_azione → gtk_window_set_title
→ gtk_widget_show
→ …

Fine Terza Parte
Per non riempire troppo la testa tutta in una volta, rimandiamo la vera fine alla prossima parte.

Oggi vedremo invece come si possono installare e come compilare un programma che ne fa uso una volta installate. Questa seconda parte sarà un po’ breve, mi rifarò con la prossima ( vedere la fine di quest’articolo per sapere cosa faremo )

Dove le ottengo?
Come le installo?

Su un sistema Debian si sa che apt semplifica il lavoro di installazione, quindi utilizzandolo può bastare un semplicissimo:

1
2

sudo apt-get update
sudo apt-get install libgtk2.0-0 libgtk2.0-dev

Se lo si volesse installare da sorgente invece i passi da seguire sono:

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

mkdir gtk-install
cd gtk-install
wget http://ftp.gnome.org/pub/gnome/sources/gtk+/2.14/gtk+-2.14.3.tar.bz2
wget http://ftp.gnome.org/pub/gnome/sources/pango/1.20/pango-1.20.5.tar.bz2
wget http://ftp.gnome.org/pub/gnome/sources/glib/2.18/glib-2.18.1.tar.bz2
 
tar -xjf gtk+-2.14.3.tar.bz2
tar -xjf pango-1.20.5.tar.bz2
tar -xjf glib-2.18.1.tar.bz2
 
sudo apt-get update
sudo apt-get install build-essential
 
./pango*/configure && make -C pango* && sudo make install -C pango*
./glib*/configure && make -C glib* && sudo make install -C glib*
./gtk*/configure && make -C gtk* && sudo make install -C gtk*

Se si volesse abilitare il debug, basta passare l’opzione –enable-debug al configure.
Per altre informazioni su come installarle su altre piattaforme rimando alla pagina di gtk.org dove spiega dettagliatamente, in inglese, tutti i passaggi da effettuare e contiene anche al suo interno i vari link per alcuni repository da cui si potranno scaricare gli archivi in diversi formati.
La pagina è: http://www.gtk.org/download.html
Una volta installato potrà essere richiamato tramite l’utily pkg-config che nei capitoli seguenti useremo come una sorta di parametro di GCC, ad esempio:

1

gcc main.c -o programma `pkg-config --cflags --libs gtk+-2.0`

pkg-config ritornerà a gcc le varie librerie da linkare e i vari percorsi in cui trovare i file di header, ad esempio nel mio sistema ho:

1
2
3
4
5
6
7
8
9

hds619@neckers:~$ pkg-config --cflags --libs gtk+-2.0
-I/usr/local/include/gtk-2.0 -I/usr/local/lib/gtk-2.0/include
-I/usr/local/include/atk-1.0 -I/usr/local/include/pango-1.0
-I/usr/local/include/glib-2.0 -I/usr/local/lib/glib-2.0/include
-I/usr/include/cairo -I/usr/include/pango-1.0 -I/usr/include/freetype2
-I/usr/include/libpng12 -I/usr/include/pixman-1 -L/usr/local/lib
-lgtk-x11-2.0 -lgdk-x11-2.0 -latk-1.0 -lgio-2.0 -lpangoft2-1.0
-lgdk_pixbuf-2.0 -lpangocairo-1.0 -lcairo -lpango-1.0 -lfreetype
-lz -lfontconfig -lgobject-2.0 -lgmodule-2.0 -lglib-2.0

Fine Seconda Parte
Nella prossima costruiremo i primi programmi Gtk+ di esempio per dare uno sguardo generale al toolkit

A questo punto ho deciso di pubblicare, in varie “puntate”, qui sul blog questa guida. E ora..

..Iniziamo!

A chi è rivolto questo “corso”?
Quali conoscenze bisogna avere?

Nonostante le Gtk+ siano multipiattaforma, questo “corso” le tratta su un sistema Debian ( e derivati ) con kernel Linux.
Non servono particolari requisiti anche se, secondo me, se si vuole sviluppare con le Gtk+ è consigliabile avere un ambiente desktop scritto con questo toolkit, come ad esempio gnome o xfce per una migliore integrazione.
Per quanto riguarda le conoscenze invece bisogna sapere almeno le basi del C e saper gestire un po’ i puntatori che, nelle Gtk+, sono tutto. Inoltre naturalmente bisogna sapere come compilare un programma, come lanciarlo, come utilizzare un po’ la shell in generale. In particolare con le gtk+ è consigliabile creare un mini-makefile dato che solitamente scrivere di volta in volta le dipendenze da dare a gcc risulta stancante.
Nella guida si partirà da zero zero fino ad arrivare a creare interfacce e programmini un po’ più complessi, ci sarà teoria ma anche alcuni programmini di esempio.

Storia delle Gtk+

Le Gtk+ sono nate nel 1996 come toolkit per GIMP, un programma di fotoritocco, e hanno raggiunto la loro prima fase stabile nell’Aprile del 1998. Le Gtk+ 1.0 contenevano al loro interno solo i widgets basilari usati da GIMP, nella successiva release ( 1.2 ) nel Febbraio del 1999 hanno iniziato ad avere nuovi widgets utilizzabili per sviluppare altre applicazioni più generiche senza essere più Gimp-centriche. La versione 1.2 è anche stata la
prima versione che creava, e divideva dal toolkit principale, la libreria GLib.
Dopo la versione 1.2 le Gtk+ sono entrate a far parte in un lungo ciclo di sviluppo durante il quale sono state apportate moltissime modifiche. Il rendering del testo è stato cambiato per far si che fosse eseguito utilizzando la libreria Pango, cercando come prima cosa di mantenere il supporto all’internazionalizzazione. La
gestione del sistema ad oggetti è stato generalizzato e spostato nelle Glib sotto il nome di Gobject. Un altra separazione è stata introdotta nelle GDK. Due nuovi randi widgets, la TextView e la TreeView, che sono stati scritti da zero. Entrambe le funzionalità di un’architettura ModelView.
Durante questo periodo di tre anni, gnome era in attesa impaziente per le Gtk+ 2.0, dato che gnome dipendeva da esse. Una delle lezioni che il team di sviluppatori delle Gtk+ ha appreso dal ciclo di rilascio delle 2.0 è quello di cercare di mantenersi tra i 9 e i 12 mesi di sviluppo per le versioni stabili.
I rilasci dopo la 2.0 hanno avuto un carattere incrementale. Le nuove principali funzionalità delle 2.2 è stato il supporto per la visualizzazione multipla, per il tradizionale X11 multischermo/multimonitor e Xinerama.

Fine Prima Parte
Nella prossima parte vedremo come installarle e come compilare un programma con le Gtk+

Allora non sapendo questa cosa da niubbo della situazione mi son messo a fare un test:

1
2
3
4
5
6
7
8
9
10
11

#include <stdio.h>
#include <string.h>
 
int main(int argc, char **argv)
{
 if ( argc < 3 ) return 1;
 
 printf("Diff: `%d'\n", strcmp(argv[1], argv[2]));
 
 return 0;
}

Benissimo lo vado ad avviare e mi restituisce solo 0 ( uguali ), 1 o -1 ( non uguali ).. dopo vari attimi di stupore da parte sua, va a provare lo stesso identico codice e le stesse identiche stringhe passate come parametro sul suo computer e la funzione lì restituiva davvero la differenza tra le due stringhe!

Ora mi domando cosa renda così variabile una funzione standard che dovrebbbe avere lo stesso funzionamento su tutti i computer del mondo. La versione delle libc comunque era uguale giusto per cronaca. Da notare comunque anche che ho provato la strcasecmp che non dovrebbe far parte del C Standard, e restituisce la famosa differenza tra le due!

? Mah..

P.s.: Altra cosa che mi fa incazzare, se si passa un parametro null alla strcmp, o all’atoi perchè cavolo mi deve compromettere tutto il programma? cosa gli costa a quelli che hanno scritto la gnu c library mettere due piccolissime macro del tipo:

1
2
3
4
5
6

#define return_if_fail(cond) if ( !(cond) ) { \
                                  return; \
                             }
#define return_val_if_fail(cond, val) if ( !(cond) ) { \
                                           return (val); \
                                      }

per controllare che i parametri non siano nulli? BAH!

Se il cambiamento di pagina viene gestito col segnale “switch-page” il segnale arriva prima del passaggio alla pagina successiva e quindi logicamente gtk_notebook_get_current_page restituisce la pagina che diventa precedente appena terminata la funzione collegata a quel segnale. Per risolvere questo problema però basta giocare con i parametri della funzione che colleghiamo, infatti se noi al posto del classico:

1

gpointer nostra_funzione(GtkWidget *widget, gpointer data)

Facciamo

1

gpointer nostra_funzione(GtkNotebook *notebook, GtkNotebookPage *page, gint page_num)

Ci ritroveremo in page_num la pagina in cui stiamo andando

Tutto è bene quel che finisce bene.

Ma vabbè a sto punto vado a fare un pò di prove nel gestire più schede e le informazioni sui vari byte e nella status bar, sorpresa non funzionano appena aggiungo una scheda! Ad esempio seleziono il byte 31 nella scheda 1 e non fa niente, vado nella scheda 2 o altre e mi dà le informazioni su quel byte, la stessa cosa con altre schede. Dopo del sano controllo di ogni singola variabile fino all’esaurimento nervoso scopro che la funzione gtk_notebook_get_current_page mi restituisce non la scheda corrente in cui sto ma quella precedente in cui stavo!

Da esaurimento.. con sto caldo poi.. meglio prendersi una pausa.