TEXT

 

Il Text widget permette di editare testi multilinea. Supporta testi multicolori e multifont.
Supporta anche il cut & paste ed il doppio e triplo click per selezionare una parola ed un'intera linea.

Per creare un nuovo text widget possiamo usare la funzione:

GtkWidget *gtk_text_new( GtkAdjustment *hadj,
GtkAdjustment *vadj );

Come al solito se passiamo il valore NULL per gli adjustment questi saranno creati automaticamente.

Con la funzione che segue si possono cambiare gli adjustment in ogni momento.

void gtk_text_set_adjustments( GtkText *text,
GtkAdjustment *hadj,
GtkAdjustment *vadj );

Per aggiungere una scrollbar verticale al text possiamo usare il seguente codice:

vscrollbar = gtk_vscrollbar_new (GTK_TEXT(text)->vadj);
gtk_box_pack_start(GTK_BOX(hbox), vscrollbar, FALSE, FALSE, 0);
gtk_widget_show (vscrollbar);

Attenzione!! allo stato attuale il text widget non supporta lo scrolling orizzonatale.

Il testo può eseere reso editabile o no con la funzione:

void gtk_text_set_editable( GtkText *text,
gint editable );

cui passeremo come valore TRUE o FALSE.

Il text widgwt esegue il wrap sulle linee troppo lunghe. Possiamo settare il wrap in modo che avvenga sui singoli caratteri o solo sugli spazi vuoti tra le parole settando in questo caso a TRUE l'attributo relativo con la seguente funzione:

void gtk_text_set_word_wrap( GtkText *text,
gint word_wrap );

Il cursore di inserimento testo può essere settato in una posizione specifica con la funzione:

void gtk_text_set_point( GtkText *text,
guint index );

Dove index rappresenta la posizione in cui vogliamo sia messo.

Con la seguente funzione invece ricaviamo la posizione corrente in cui si trova il cursore:

guint gtk_text_get_point( GtkText *text );

La funzione che segue invece ci ritorna la lunghezza attuale del testo contenuto nel widget.

guint gtk_text_get_length( GtkText *text );

Per inserire del testo alla posizione corrente del cursore possiamo usare:

void gtk_text_insert( GtkText *text,
GdkFont *font,
GdkColor *fore,
GdkColor *back,
const char *chars,
gint length );

Come si vede la funzione ci permette anche di indicare il colore del testo, dello sfondo ed il font.
Se passiamo NULL a questi argomenti saranno usati i colori ed il font di default dell'attuale style del widget.
Se passiamo poi il valore -1 all'argomento length sara' inserito l'intero testo *chars.

Per evitare i fenomi di flicker quando inseriamo grosse porzioni di testo possiamo usare le due funzioni:

void gtk_text_freeze( GtkText *text );

void gtk_text_thaw( GtkText *text );

La prima congela il redraw e la seconda lo riattiva dopo che abbiamo concluso l'immissione.

Il testo puo' essere cancellato dal widget a partire dalla posizione corrente del cursore in avanti o indietro con le due funzioni:

gint gtk_text_backward_delete( GtkText *text,
guint nchars );

gint gtk_text_forward_delete ( GtkText *text,
guint nchars );

Dove nchars è il numero di caratteri da cancellare. Le funzioni ritornano TRUE o FALSE a seconda che l'operazione abbia avuto successo o meno.

Per ricavare blocchi di testo possiamo usare la funzione:

gchar *gtk_editable_get_chars( GtkEditable *editable,
gint start_pos,
gint end_pos );

se assegnamo 0 a start-pos e -1 a end_pos otterremo tutto il testo presente nel widget.

La funzione alloca memoria che andrà poi liberata con g_free una volta terminate le operazioni.

Il text widget ha un gran numero di scorciatoie da tastiera che si elencano qui di seguito:

Movimento
Ctrl-A Inizio linea
Ctrl-E Fine linea
Ctrl-N Linea successiva
Ctrl-P Linea precedente
Ctrl-B Indietro di un carattere
Ctrl-F Avanti di un carattere
Alt-B Indietro di una parola
Alt-F Avanti di una parola

Editing
Ctrl-H Cancella carattere precedente
Ctrl-D Cancella carattere successivo
Ctrl-W Cancella parola precedente
Alt-D Cancella parola successiva
Ctrl-K Cancella fino alla fine della linea
Ctrl-U Cancella tutta la linea

Selezione
Ctrl-X Taglia
Ctrl-C Copia
Ctrl-V Incolla

 

 

ESEMPIO

#include <stdio.h>
#include <gtk/gtk.h>

void text_toggle_editable (GtkWidget *checkbutton,
GtkWidget *text)
{
gtk_text_set_editable(GTK_TEXT(text),
GTK_TOGGLE_BUTTON(checkbutton)->active);
}

void text_toggle_word_wrap (GtkWidget *checkbutton,
GtkWidget *text)
{
gtk_text_set_word_wrap(GTK_TEXT(text),
GTK_TOGGLE_BUTTON(checkbutton)->active);
}

void close_application( GtkWidget *widget, gpointer data )
{
gtk_main_quit();
}

int main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *check;
GtkWidget *separator;
GtkWidget *table;
GtkWidget *vscrollbar;
GtkWidget *text;
GdkColormap *cmap;
GdkColor colour;
GdkFont *fixed_font;

FILE *infile;

gtk_init (&argc, &argv);

window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_usize (window, 600, 500);
gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(close_application),
NULL);
gtk_window_set_title (GTK_WINDOW (window), "Text Widget Example");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);


box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (box1);


box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);


table = gtk_table_new (2, 2, FALSE);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
gtk_widget_show (table);

/* Crea il GtkText widget */
text = gtk_text_new (NULL, NULL);
gtk_text_set_editable (GTK_TEXT (text), TRUE);
gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
GTK_EXPAND | GTK_SHRINK | GTK_FILL,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (text);

/* Aggiunge una scrollbar verticale */
vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (vscrollbar);

/* Alloca il colore rosso dalla colormap di sistema */
cmap = gdk_colormap_get_system();
colour.red = 0xffff;
colour.green = 0;
colour.blue = 0;
if (!gdk_color_alloc(cmap, &colour)) {
g_error("couldn't allocate colour");
}

/* Carica un fixed font */
fixed_font = gdk_font_load ("-misc-fixed-medium-r-*-*-*-140-*-*-*-*-*-*");

gtk_widget_realize (text);

/* Congela il text widget */
gtk_text_freeze (GTK_TEXT (text));

/* Inserisce del testo colorato */
gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
"Supports ", -1);
gtk_text_insert (GTK_TEXT (text), NULL, &colour, NULL,
"colored ", -1);
gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
"text and different ", -1);
gtk_text_insert (GTK_TEXT (text), fixed_font, &text->style->black, NULL,
"fonts\n\n", -1);

/* Carica questo file (text.c) nel text */

infile = fopen("text.c", "r");

if (infile) {
char buffer[1024];
int nchars;

while (1)
{
nchars = fread(buffer, 1, 1024, infile);
gtk_text_insert (GTK_TEXT (text), fixed_font, NULL,
NULL, buffer, nchars);

if (nchars < 1024)
break;
}

fclose (infile);
}

/* Scongela il text widget in modo da permettere l'aggiornamento del testo */
gtk_text_thaw (GTK_TEXT (text));

hbox = gtk_hbutton_box_new ();
gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);

check = gtk_check_button_new_with_label("Editable");
gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT(check), "toggled",
GTK_SIGNAL_FUNC(text_toggle_editable), text);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
gtk_widget_show (check);
check = gtk_check_button_new_with_label("Wrap Words");
gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT(check), "toggled",
GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), FALSE);
gtk_widget_show (check);

separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);

box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_show (box2);

button = gtk_button_new_with_label ("close");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(close_application),
NULL);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_widget_show (button);

gtk_widget_show (window);

gtk_main ();

return(0);
}