La seguente “guida” è valida per chrome perchè l’ho testato con questo tipo di browser.

AGGIUNTA POSTUMA: sembra che la versione “mobile” di wikipedia risponda ancora correttamente: http://it.m.wikipedia.org/wiki/Libert%C3%A0 senza alcun bisogno di modificare nulla. L’unico accorgimento è quello di mettere una “m.” dopo l’”it.” iniziale del link della pagina.

1) clickare sul menu e andare in opzioni, dopodichè aprire la pagina Roba da Smanettoni e Impostazioni contenuti…, e fare click  sull’opzione relativa al Javascript: Non consentire ad alcun sito di eseguire Javascript ( si potrebbe mettere l’eccezione a wikipedia per limitare il blocco di codice javascript solo ad una pagina e non influenzare le altre, per fare ciò seguire la nota 1 a fondo pagine ).

Questo eviterà il redirect.

2) Una volta sulla pagina il contenuto è nascosto, clickare col destro su un punto vuoto della pagina e selezionare l’opzione “Ispeziona Elemento”. A questo punto espandere ( clickando sul triangolino ) il tag <div id=”content”> ed clickare sul tag ( non sul triangolino ) <div id=”bodyContent”>.

A questo punto sulla destra ci sarà una lista, dove è presente l’attributo display: none, è sufficiente togliere la spunta clickando sul tick che compare andando col mouse sull’attributo e il contenuto sarà visibile.

NOTA: non è questa la soluzione per quel che sta accadendo. Bisogna fare qualcosa.

NOTA 1: per aggiungere un’eccezione lasciare javascript abilitato e clickare su Aggiungi eccezione, nel nome host scrivere it.wikipedia.org e come comportamento ‘blocca’.

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.

Neopatentato da 1 giorno, da ora in avanti chiudete in casa donne e bambini

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

Una volta ottenuta si possono settare alcune opzioni:

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

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

Iniziamo con i pulsanti normali, il nome delle funzioni è uguale a quella per i pulsanti normali, cambia solo categoria, quindi se prima per creare un pulsante si chiamava ad esempio la funzione gtk_button_new_from_stock () adesso si chiamerà gtk_tool_button_new_from_stock (). Altra differenza è che la variabile ritornata non è un GtkWidget * ma un GtkToolItem *.

Continuando con i toggle button, ovvero i pulsanti che una volta clickati rimangono premuti ( attivati ) e se riclickati ritornano allo stato originario ( disattivati ), abbiamo la stessa situazione che avevamo anche qui con i pulsanti toggle normali, cioè sono una sottocategoria dei pulsanti normali,  cambia categoria ( quindi gtk_toggle_tool_button_.. () ) e le azioni delle funzioni invece rimangono uguali. Anche qui il valore ritornato non è un GtkWidget * ma un GtkToolItem *.

Anche con i radio button ( chiamati radio_tool_button ) abbiamo le stesse identiche cose dei radio button normali con le identiche modifiche descritte per i due tipi di pulsanti più su.

I separati nelle toolbar si creano semplicemente con la funzione gtk_separator_tool_item_new () che non riceve argomenti e ritorna un GtkToolItem *.

Essendo, come avrete notato, tutti dei GtkToolItem * esistono delle funzioni per impostare degli attributi a questa classe, indipendentemente dal tipo specifico ( tutte queste funzioni che ora elencherò infatti ricevono come primo parametro un GtkToolItem * ):

• gtk_tool_item_set_expand (): il secondo parametro è un valore booleano per scegliere se permettere all’item passato di occupare lo spazio che potrebbe crearsi nella toolbar ( ad esempio durante il ridimensionamento potrebbe crearsi del vuoto sulla destra mentre se uno o più widget si espandono riempiono anche quello spazio ).
• gtk_tool_item_set_homogeneous (): l’item a cui viene applicata questa opzione ( secondo parametro è booleano ) avrà la larghezza uguale a quella del più largo degli oggetti inseriti nella toolbar.
• gtk_tool_item_set_tooltip_text (): il secondo parametro dovrà essere una stringa contenente il suggerimento che si vuol far visualizzare quando il mouse “riposa” sull’elemento passato come primo parametro.
• gtk_tool_item_set_tooltip_markup (): come la funzione precedente, solo che il testo del “tooltip” ( suggerimento ) potrà usare dei tag di markup.
• gtk_tool_item_set_visible_horizontal (): riceve come secondo parametro un valore booleano che indica se visualizzare l’elemento quando la toolbar è orientata orizzontalmente.
• gtk_tool_item_set_visible_vertical (): come la funzione precedente, solo che la visibilità dell’elemento riguarda quando la toolbar nella sua posizione verticale.

Ok abbiamo finito ma manca la cosa più importante, ovvero come inserire questi elementi che abbiamo creato nella toolbar. Niente di più semplice lo facciamo in un attimo con la funzione gtk_toolbar_insert () che riceve tre parametri, il primo la toolbar, il secondo l’elemento da inserire e come terzo il numero del posto in cui inserirlo ( parte da zero l’indice ).

Fine Ventiduesima Puntata
Come promesso, anche se ce l’ho fatta nel limite, ho fatto una nuova guida alle gtk+ questa settimana, per altre puntate non abbiate fretta perchè sono un po’ occupato dall’inizio di questo nuovo anno. Per altri argomenti in particolare comunque che volete guardare sempre inerenti alle gtk+ scriveteli pure nei commenti alle guide o nella pagina principale dove c’è il riassunto di tutte le puntate.
Ciauz

( Purtroppo per voi XD )

Grazie a tutti coloro che già me li hanno fatti gli auguri.

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

[...]

CONTESTATORI URLANO, PREMIER LI ZITTISCE – Silvio Berlusconi è stato brevemente interrotto da una decina di persone che contestavano mentre sta tenendo il suo discorso. Dai contestatori sono partite alcune grida tra cui ‘vergogna’. E la parola ‘vergogna’ é stata ripetuta tre volte dal premier per zittirli. Al grido di alcuni contestatori, presenti in Piazza Duomo a Milano dove si sta tenendo il comizio del presidente del Consiglio Silvio Berlusconi, di “buffone, buffone”, i sostenitori del Pdl hanno risposto urlando “Silvio, Silvio”, sovrastando così le contestazioni.

—

—

Emilio fede.. hahahahaha


Aggiornamento [19.40]: Nome dell’”aggressore”: Massimo Tartaglia

—

Hahahahahahahahahahahahahaha!

—

Dunque la prima funzione che andiamo a vedere serve per “staccare” un menu e visualizzarlo in una finestra separata. Vediamo prima il codice, poi l’immagine di esempio:

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

La seconda funzione servirà per creare degli elementi del menu “controllabili” ovvero che possono ricevere un “check”:

/* status: 'true'  elemento attivato
 *         'false' elemento disattivato
 */
GtkWidget *
menu_check_append (GtkMenu * menu, gboolean status, const char *label, GCallback func)
{
 GtkWidget *widget;
 
 widget = gtk_check_menu_item_new_with_label (label);
 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (widget), status);
 gtk_menu_shell_append (GTK_MENU_SHELL (menu), widget);
 gtk_widget_show (widget);
 
 if ( func )
      g_signal_connect (G_OBJECT (widget), "toggled",
                        G_CALLBACK (change_sections), NULL);
 
 return widget;
}

Come sotto elemento di questo tipo abbiamo anche quelli per scegliere un elemento specifico tra un gruppo di elementi ( i così detti “radio” ), vengono gestiti come, i già affrontati, radio button. Anche di questi vediamo il codice della funzione:

/* menu: il menu in cui inserire il widget
 * radio_group: l'indirizzo di un gruppo di elementi radio,
 *              l'elemento può essere inizializzato a NULL prima
 *              di essere passato per indirizzo automaticamente
 *              verrà poi impostato col gruppo dei vari elementi
 *              radio inseriti.
 * label: testo da visualizzare di fianco all'elemento radio
 * func: funzione da collegare quando viene "attivato" l'elemento
 * accel_group: gruppo di acceleratori
 * accel_id: tasto per l'acceleratore
 * mod_type: maschera per l'acceleratore
 * tooltip: eventuale suggerimento da visualizzare se il mouse
 *          rimane per qualche secondo sull'elemento.
 */
GtkWidget *
menu_radio_append (GtkMenu * menu, GSList **radio_group,
                        const char *label, GCallback func,
                        GtkAccelGroup *accel_group, unsigned int accel_id,
                        GdkModifierType mod_type, char *tooltip)
{
 GtkWidget *widget;
 
 widget = gtk_radio_menu_item_new_with_label (*radio_group, label);
 *radio_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (widget));
 gtk_menu_shell_append (GTK_MENU_SHELL (menu), widget);
 gtk_widget_show (widget);
 
 if (func)
   g_signal_connect (G_OBJECT (widget), "activate", func, NULL);
 
 if (accel_id && accel_group)
   gtk_widget_add_accelerator (widget, "activate", accel_group, accel_id, mod_type, GTK_ACCEL_VISIBLE);
 
 if (tooltip)
   gtk_widget_set_tooltip_text (widget, tooltip);
 
 return widget;
}

Fine Ventunesima Puntata
Ora che abbiamo finito con i menu, possiamo passare nelle prossime puntate alle toolbar.
Ciauz

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.

L’header aggiuntivo probabilmente richiesto sarà:
#include

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

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

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

Parametri:

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

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

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

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Quindi, dopo questa brutta esperienza, dopo l’impressione negativa che ho descritto in un altro post che mi ha dato la linea che seguirà ubuntu, * censured *, ho deciso di fare una cosa che avrei dovuto fare molto tempo fa..
Devo dire che mi dispiace un po’, perchè utilizzo ubuntu dalla 6.06, però ormai è diventato necessario. Passo a debian. L’avevo lasciata un annetto fa perchè non aveva le librerie e il software aggiornato che mi serviva e non avevo voglia di ricompilarmi tutto a manina o passare a sid\experimental tanto valeva andare su ubuntu che aveva un buon rapporto stabilità\software aggiornato, ora però che lenny è stata rilasciata e ci ritotroviamo da un po’ di tempo con squeeze ho visto che anche lì son passati a software più aggiornato o almeno quanto basta per me così da poter programmare in pace.

Utilizzatori di ubuntu non me ne vogliate
Utilizzatori di windows non spaventatevi

Bye

Ma alla fine cosa vuoi che importi? ..

Ogni utente una volta registrato potrà aggiungere e segnalare una feature o un bug, votare altri task, commentare e proporre soluzioni o altro ai bug.

Il tutto viene gestito dal software flyspray. Il sistema di tracciamente può essere trovato qui: http://www.hds619.net/bug-tracker

Bye

Good hosting

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

Per carità, sono il primo che è felice quando escono programmi con interfaccia grafica che ti evitano di usare il terminale, non sono un patito della tastiera ( a meno che non si tratta di programmazione ) e ben vengano click in più che aiutano i tendini della mia mano ad andare in crisi tra qualche anno. Ma ad un certo punto poi si esagera.

Soprattutto se devo ritrovarmi installazioni del genere che fanno tanto “Windows eXPerience”, della serie “Da oggi più sicuro, veloce e facile da usare!”.. Frasi che si commentano da sole e che sanno tanto da presa per il culo. Per il momento ho deciso che me ne sbatterò e farò l’upgrade alla prossima versione, ma se deve continuare così quest’utontontimento di ubuntu penso che ritornerò allegramente a Debian testing\sid.

E che cazz!

P.s.: Sembra una sfogo solo riguardante l’interfaccia grafica, ma in realtà questa è solo la punta dell’iceberg di tante piccole cose che si sono andate accumulando in questi anni.

…chi inquina e spamma sul web per fare domande su programmi o servizi la cui domanda si trova nelle prime 10 domande delle FAQ

…chi non prova nemmeno a cercare 2 secondi da solo la soluzione al proprio problema prima di chiedere

…chi chiede aiuto e dopo 10 minuti riesce a risolvere da solo

…chi chiede aiuto e non ascolta le risposte

…chi bolla un programma come “inutile” o “non funzionante” solo perchè deve fare un click in più per fare ciò che vuole

…chiunque sminuisca il lavoro degli altri, importante o inutile che sia

…chi non aiuta, non pensando che forse senza coloro che aiutano non saprebbe ciò che sa adesso

…i gruppi che si autocompiacciono del proprio lavoro e etichettano come incapace chiunque gli dia consigli per migliorarlo

…chi non dà soddisfazioni

…chi si lamenta se qualcosa in una comunità va male, ma è il primo a non fare nulla per migliorare la situazione

…chi fornisce la così detta “pappa pronta” togliendo ogni gusto di sperimentare

…chi si rassegna

…chi odia e forse odio anche me stesso, ma solamente odiando e incazzandosi contro qualcosa si riesce veramente a creare qualcosa di nuovo, a sconvolgere il normale equilibrio della vita quotidiana trasformato in monotonia e arrendevolezza.
Ammiro chi sa di combattere per una causa persa in partenza o in una battaglia senza fine ma sa anche che combattendola giorno per giorno forse, alla fin fine riesce veramente a migliorare le cose.

Per il resto non penso ci siano altre “controindicazioni”.

Ciauz

P.s.:  Applicato anche un nuovo tema, purtroppo a larghezza fissa ma molto più riposante per gli occhi.

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

Vacanze andate benissimo e ultimamente mi sto divertendo a configurare un eeepc 4G della Asus, ed a proposito di questo argomento devo dire che xandros è il sistema operativo più inutile, insensato, incoerente, inusabile e inefficiente della storia dell’informatica.

Tralasciando questo breve aggiornamento sulla mia vita informo che questo fine settimana dovrei riuscire a trovare il tempo per scrivere la nuova guida alle gtk+ e l’argomento per cui ho optato è stato quello dei menu.

Quindi a tra poco

Come altre novità c’è una nuova funzione per il disegno ( imel_draw_blend () )  che permette di disegnare una sfumatura orizzontale o verticale, una funzione per sommare\sottrarre o impostare tutti i livelli di un immagine ad una stessa cifra\per una stessa cifra ( imel_image_change_level () ) e una funzione per applicare matrici di convoluzione ( imel_image_apply_convolution () ).

Inoltre sono state inseriti tanti bei define che potete trovare descritti nella documentazione, precisamente in questa pagina, ed eliminati tutti i warning in fase di compilazione ( compilando con -Wall -ansi -pedantic ).

Byeee

Pacchetto: http://www.hds619.net/imel/imel-0.2.2.tar.bz2

La documentazione e i sorgenti “sfusi” sono sempre allo stesso link

P.s.: Nel pacchetto di questa versione trovate anche la libreria statica e dinamica pre-compilata, e poi non dite che non vi penso

Aggiornamento (22/07/2009): Pacchetto aggiornato inserendo la funzione imel_image_apply_convolution () e con i warning in fase di compilazione eliminati.

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