gtk_tut_it-7.html

gtk是linux一款强大的夸平台的图形化开发工具

<H2><A NAME="ss7.6">7.6 Righelli</A>
</H2>

<P>I widget righello vengono usati per indicare la posizione del pontatore del
mouse in una certa finestra. Una finestra pu&ograve; cio&eacute; avere un
righello orizzontale che si estende per tutta la sua ampiezza e un righello verticale
che ne comprende l'altezza. Un piccolo triangolo sui rghelli indica la posizione
esatta del puntatore relativamente ai righelli.
<P>I righelli devono essere in primo luogo creati. I righlli orizzontali e verticali vengono
creati usando
<P>
<BLOCKQUOTE><CODE>
<PRE>
GtkWidget *gtk_hruler_new(void);    /* horizontal ruler */
GtkWidget *gtk_vruler_new(void);    /* vertical ruler   */
</PRE>
</CODE></BLOCKQUOTE>
<P>Una volta che che si &egrave; creato il righello, si pu&ograve; l'unit&agrave; di
misura. Le unit&agrave; di misura possono essere GTK_PIXELS,
GTK_INCHES oppure GTK_CENTIMETERS. Ci&ograve; viene stabilito usando
<P>
<BLOCKQUOTE><CODE>
<PRE>
void gtk_ruler_set_metric( GtkRuler        *ruler,
                           GtkMetricType   metric );
</PRE>
</CODE></BLOCKQUOTE>
<P>La misura predefinita &egrave;  GTK_PIXELS.
<P>
<BLOCKQUOTE><CODE>
<PRE>
gtk_ruler_set_metric( GTK_RULER(ruler), GTK_PIXELS );
</PRE>
</CODE></BLOCKQUOTE>
<P>Altre caratteritiche importanti di un righello sono il modo in cui vengono segnate
le tacche delle unit&agrave; di misura e dove viene posto inizialmente l'indicatore
di posizione. Questi vengono stabiliti usando
<P>
<BLOCKQUOTE><CODE>
<PRE>
void  gtk_ruler_set_range  (GtkRuler       *ruler,
                            gfloat          lower,
                            gfloat          upper,
                            gfloat          position,
                            gfloat          max_size);
</PRE>
</CODE></BLOCKQUOTE>
<P>Gli argomenti lower e upper definiscono l'estensione del righello, e
max_size rappresenta il numero massimo che verr&agrave; mostrato.
Position definisce l posizione iniziale dell'indicatore del puntatore 
all'interno del righello.
<P>Quindi, un righello che pu&ograve; stare su una finestra di 800 pixel sar&agrave;:
<P>
<BLOCKQUOTE><CODE>
<PRE>
gtk_ruler_set_range( GTK_RULER(vruler), 0, 800, 0, 800);
</PRE>
</CODE></BLOCKQUOTE>
<P>Sul righello saranno presenti dei segni da 0 a 800, con un numero ogni 100 pixel.
Se avessimo invece voluto che il righello fosse andato da 7 a 16, avremmo scritto:
<P>
<BLOCKQUOTE><CODE>
<PRE>
gtk_ruler_set_range( GTK_RULER(vruler), 7, 16, 0, 20);
</PRE>
</CODE></BLOCKQUOTE>
<P>L'indicatore sul righello &egrave; un piccolo segno triangolare che indica
la posizione del puntatore rispetto al righello. Se il righello viene usato
per seguire il movimento del mouse, il segnale di motion_notify_event
dovrebbe venir connesso al metodo motion_notify_event del righello.
Per seguire tutti i movimenti del mouse all'interno dell'area di una finestra,
useremmo:
<P>
<BLOCKQUOTE><CODE>
<PRE>
#define EVENT_METHOD(i, x) GTK_WIDGET_CLASS(GTK_OBJECT(i)->klass)->x

gtk_signal_connect_object( GTK_OBJECT(area), "motion_notify_event",
         (GtkSignalFunc)EVENT_METHOD(ruler, motion_notify_event),
         GTK_OBJECT(ruler) );
</PRE>
</CODE></BLOCKQUOTE>
<P>L'esempio seguente crea un'area di disegno con un reghello orizzontale nella
parte superiore e un righello verticale nella parte sinistra. Le dimensioni
di questa area di disegno sono di 600 e 400 pixel risettivamente per la larghezza
e per l'altezza. Il righello orizzontale va da 7 a 13 con una tacca ogni 100 pixel,
mentre quello verticale va da 0 a 400, ancora con una tacca ogni 100 pixel.
La sistemazione dell'area di disegno e dei righelli viene fatta usando una tabella.
<P>
<BLOCKQUOTE><CODE>
<PRE>
/* rulers.c */

#include &lt;gtk/gtk.h>

#define EVENT_METHOD(i, x) GTK_WIDGET_CLASS(GTK_OBJECT(i)->klass)->x

#define XSIZE  600
#define YSIZE  400

/* il controllo raggiunge questa routine quando si preme il bottone close 
 */
void close_application( GtkWidget *widget, gpointer data ) {
    gtk_main_quit();
}

/* la routine principale
 */
int main( int argc, char *argv[] ) {
    GtkWidget *window, *table, *area, *hrule, *vrule;

    /* inizializziamo gtk e creiamo la finestra principale */
    gtk_init( &amp;argc, &amp;argv );

    window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
            GTK_SIGNAL_FUNC( close_application ), NULL);
    gtk_container_border_width (GTK_CONTAINER (window), 10);

    /* creiamo una tabella in cui mettere righelli e area di disegno */
    table = gtk_table_new( 3, 2, FALSE );
    gtk_container_add( GTK_CONTAINER(window), table );

    area = gtk_drawing_area_new();
    gtk_drawing_area_size( (GtkDrawingArea *)area, XSIZE, YSIZE );
    gtk_table_attach( GTK_TABLE(table), area, 1, 2, 1, 2,
                      GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0 );
    gtk_widget_set_events( area, GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK );

    /* Il righello orizzontale va nella parte superiore. Quando il mouse si muove
     * nell'area di disegno, si passa un motion_notify_event al gestore appropriato
     * per il righello. */

    hrule = gtk_hruler_new();
    gtk_ruler_set_metric( GTK_RULER(hrule), GTK_PIXELS );
    gtk_ruler_set_range( GTK_RULER(hrule), 7, 13, 0, 20 );
    gtk_signal_connect_object( GTK_OBJECT(area), "motion_notify_event",
                               (GtkSignalFunc)EVENT_METHOD(hrule, motion_notify_event),
                               GTK_OBJECT(hrule) );
    /*  GTK_WIDGET_CLASS(GTK_OBJECT(hrule)->klass)->motion_notify_event, */
    gtk_table_attach( GTK_TABLE(table), hrule, 1, 2, 0, 1,
                      GTK_EXPAND|GTK_SHRINK|GTK_FILL, GTK_FILL, 0, 0 );
    
    /* Il righello verticale va nella parte sinistra.  Quando il mouse si muove
     * nell'area di disegno, si passa un motion_notify_event al gestore appropriato
     * per il righello. */

    vrule = gtk_vruler_new();
    gtk_ruler_set_metric( GTK_RULER(vrule), GTK_PIXELS );
    gtk_ruler_set_range( GTK_RULER(vrule), 0, YSIZE, 10, YSIZE );
    gtk_signal_connect_object( GTK_OBJECT(area), "motion_notify_event",
                               (GtkSignalFunc)
                                  GTK_WIDGET_CLASS(GTK_OBJECT(vrule)->klass)-motion_notify_event,
                               GTK_OBJECT(vrule) );
    gtk_table_attach( GTK_TABLE(table), vrule, 0, 1, 1, 2,
                      GTK_FILL, GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0 );

    /* ora mostriamo tutto quanto */
    gtk_widget_show( area );
    gtk_widget_show( hrule );
    gtk_widget_show( vrule );
    gtk_widget_show( table );
    gtk_widget_show( window );
    gtk_main();

    return 0;
}
</PRE>
</CODE></BLOCKQUOTE>
<P>
<H2><A NAME="ss7.7">7.7 Barre di Stato (Statusbar)</A>
</H2>

<P>Le barre di stato sono dei semplici widget usati per mostrare messaggi di test.
Hanno la caratteristica di mantenere uno stack dei messggi che vi vengono
mostrati, cosicche&eacute; rimuovendo il messaggio corrente fa s&igrave; che
torni ad essere mostrato il messaggio precedente..
<P>Per permettere a parti diverse di una stessa applicazione di usare la stessa barra di
stato per mostrare messaggi, questo widget emette degli 'Identificatori di Contesto'
che vengono usati per identificare i diversi 'utenti'. Quello che viene mostrato
&egrave; sempre il messaggio che si trova in cima allo stack, a prescindere in
quale contesto si trovi. I messaggi vengono immagazzinati secondo l'ordine
LIFO, e non secondo l'ordine stabilito dal contesto.
<P>Una barra di stato viene creata con una chiamata a:
<BLOCKQUOTE><CODE>
<PRE>
GtkWidget* gtk_statusbar_new (void);
</PRE>
</CODE></BLOCKQUOTE>
<P>Per richiedere un nuovo identificatore di contesto, si usa una chiamata alla seguente
funzione con una breve descrizione testuale:
<BLOCKQUOTE><CODE>
<PRE>
guint gtk_statusbar_get_context_id (GtkStatusbar *statusbar,
                                    const gchar  *context_description);
</PRE>
</CODE></BLOCKQUOTE>
<P>Le seguenti sono tre funzioni che possono operare sulle barre di stato:
<BLOCKQUOTE><CODE>
<PRE>
guint       gtk_statusbar_push           (GtkStatusbar *statusbar,
                                         guint          context_id,
                                         gchar         *text);

void       gtk_statusbar_pop            (GtkStatusbar *statusbar)
                                         guint         context_id);
void       gtk_statusbar_remove         (GtkStatusbar *statusbar,
                                         guint         context_id,
                                         guint         message_id); 
</PRE>
</CODE></BLOCKQUOTE>
<P>La prima, gtk_statusbar_push, viene usata per aggiungere un nuovo messaggio
alla barra di stato. Questa restituisce un identificatore di messaggio, che pu&ograve;
essere passato successivamente alla funzione gtk_statusbar_remove per rimuovere
dallo stack il messggio con identificatore di messaggio e di contesto dati.
<P>La funzione gtk_statusbar_pop rimuove il messaggio che si trova in cima allo stack
avente un dato identificatore di contesto.
<P>Nel seguente esempio si crea una barra di stato e due bottoni, uno per mettere
elementi sulla barra di stato e l'altro per riuovere l'ultimo elemento..
<P>
<BLOCKQUOTE><CODE>
<PRE>
/* statusbar.c */

#include &lt;gtk/gtk.h>
#include &lt;glib.h>

GtkWidget *status_bar;
 
void push_item (GtkWidget *widget, gpointer data)
{
  static int count = 1;
  char buff[20];

  g_snprintf(buff, 20, "Item %d", count++);
  gtk_statusbar_push( GTK_STATUSBAR(status_bar), (guint) &amp;data, buff);

  return;
}

void pop_item (GtkWidget *widget, gpointer data)
{
  gtk_statusbar_pop( GTK_STATUSBAR(status_bar), (guint) &amp;data );
  return;
}

int main (int argc, char *argv[])
{

    GtkWidget *window;
    GtkWidget *vbox;
    GtkWidget *button;

    int context_id;

    gtk_init (&amp;argc, &amp;argv);

    /* creazione di una nuova finestra */
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_widget_set_usize( GTK_WIDGET (window), 200, 100);
    gtk_window_set_title(GTK_WINDOW (window), "GTK Statusbar Example");
    gtk_signal_connect(GTK_OBJECT (window), "delete_event",
                       (GtkSignalFunc) gtk_exit, NULL);
 
    vbox = gtk_vbox_new(FALSE, 1);
    gtk_container_add(GTK_CONTAINER(window), vbox);
    gtk_widget_show(vbox);
          
    status_bar = gtk_statusbar_new();      
    gtk_box_pack_start (GTK_BOX (vbox), status_bar, TRUE, TRUE, 0);
    gtk_widget_show (status_bar);

    context_id = gtk_statusbar_get_context_id( GTK_STATUSBAR(status_bar), "Statusbar example");

    button = gtk_button_new_with_label("push item");
    gtk_signal_connect(GTK_OBJECT(button), "clicked",
        GTK_SIGNAL_FUNC (push_item), &amp;context_id);
    gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 2);
    gtk_widget_show(button);              

    button = gtk_button_new_with_label("pop last item");
    gtk_signal_connect(GTK_OBJECT(button), "clicked",
        GTK_SIGNAL_FUNC (pop_item), &amp;context_id);
    gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 2);
    gtk_widget_show(button);              

    /* la finestra va sempre mostrata come ultimo passo, in modo che venga
     * sullo schermo tutta in una volta. */
    gtk_widget_show(window);

    gtk_main ();

    return 0;
}
</PRE>
</CODE></BLOCKQUOTE>
<P>
<H2><A NAME="ss7.8">7.8 Inserimento di testo</A>
</H2>

<P>Questo widget permette diinserire e mostrare del testo in una casella contenente una
sola linea. Il testo pu&ograve; essere assegnato con chiamate di funzione che
permettono a nuovo testo di sostituire, seguire o precedere il contenuto corrente
del widget di inserimento testo.
<P>Per la creazione di un inserimento di testo, sono disponibili due funzioni:
<BLOCKQUOTE><CODE>
<PRE>
GtkWidget* gtk_entry_new (void);

GtkWidget* gtk_entry_new_with_max_length (guint16 max);
</PRE>
</CODE></BLOCKQUOTE>
<P>La prima crea solamente un inserimento di testo, mentre la seconda lo crea
imponendo un limite alla lunghezza del testo inseribile..
<P>Per cambiaere il testo che si trova correntemente nel widget, sono disponibili diverse
funzioni.
<BLOCKQUOTE><CODE>
<PRE>
void gtk_entry_set_text       (GtkEntry    *entry,
                               const gchar *text);
void gtk_entry_append_text    (GtkEntry    *entry,
                               const gchar *text);
void gtk_entry_prepend_text   (GtkEntry    *entry,
                               const gchar *text);
</PRE>
</CODE></BLOCKQUOTE>
<P>La funzione gtk_entry_set_text assegna il contenuto del widget di inserimento,
sostituendo il contenuto corrente. Le funzioni gtk_entry_append_text e gtk_entry_prepend_text
permettono di antemporre o posporre un testo al testo corrente..
<P>La prossima funzione permette di stabilire il punto di inserimento.
<BLOCKQUOTE><CODE>
<PRE>
void gtk_entry_set_position   (GtkEntry *entry,
                               gint     position);
</PRE>
</CODE></BLOCKQUOTE>
<P>Usando la seguente funzione, &egrave; possibile estrarre il contenuto di un widget di inserimento.
Ci&ograve; pu&ograve; essere utile nelle funzioni di ritorno come descritto pi&ugrave; sotto.
<BLOCKQUOTE><CODE>
<PRE>
gchar* gtk_entry_get_text (GtkEntry *entry);
</PRE>
</CODE></BLOCKQUOTE>
<P>Se non si vuole che qualcuno possa cambiare il contenuto di una entry sovrascrivendola,
ne possiamo cambiare lo stato di "editabilit&agrave;"..
<BLOCKQUOTE><CODE>
<PRE>
void gtk_entry_set_editable (GtkEntry *entry,
                             gboolean editable);
</PRE>
</CODE></BLOCKQUOTE>
<P>Questa funzine ci permette di far passare un widget di inserimento dallo sato di editabile a
quello di non editabile passando con l'argomento editable i valori TRUE o FALSE.
<P>Se stiamo usando l'entry in un punto in cui non vogliamo che il testo sia visibile, per
esempio quando si digita una password, possiamo usare la seguente funzione, che
accetta un parametro booleano..
<BLOCKQUOTE><CODE>
<PRE>
void gtk_entry_set_visibility (GtkEntry *entry,
                               gboolean visible);
</PRE>
</CODE></BLOCKQUOTE>
<P>Si pu&ograve; stabilire che una parte del testo  risulti selezionata usado la seguente funzione.
Si user&agrave; di solito questa possibilit&agrave; dopo aver inserito nel widget un
qualche valore predefinito, in modo che per l'utente sia semplice sostituirlo. 
<P>
<BLOCKQUOTE><CODE>
<PRE>
void gtk_entry_select_region (GtkEntry *entry,
                              gint     start,
                              gint     end);
</PRE>
</CODE></BLOCKQUOTE>
<P>Se vogliamo accorgerci del momento in cui l'utente ha inserito del testo, possiamo connettere
il segnale <CODE>activate</CODE> o <CODE>changed</CODE>. <CODE>activate</CODE> viene reso attivo quando
l'utente preme il tasto Enter mentre si trova nel widget. <CODE>changed</CODE> viene invece emesso ogni volta che
il testo cambia, per esempio ogni volta che viene inserito o rimosso un carattere.
<P>Il seguente codice mostra un esempio di utilizzo del widget di inserimento.
.
<BLOCKQUOTE><CODE>
<PRE>
/* entry.c */

#include &lt;gtk/gtk.h>

void enter_callback(GtkWidget *widget, GtkWidget *entry)
{
  gchar *entry_text;
  entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
  printf("Entry contents: %s\n", entry_text);
}

void entry_toggle_editable (GtkWidget *checkbutton,
                                   GtkWidget *entry)
{
  gtk_entry_set_editable(GTK_ENTRY(entry),
                         GTK_TOGGLE_BUTTON(checkbutton)->active);
}

void entry_toggle_visibility (GtkWidget *checkbutton,
                                   GtkWidget *entry)
{
  gtk_entry_set_visibility(GTK_ENTRY(entry),
                         GTK_TOGGLE_BUTTON(checkbutton)->active);
}

int main (int argc, char *argv[])
{

    GtkWidget *window;
    GtkWidget *vbox, *hbox;