Whole document tree

20. Scribble, Un semplice esempio di Programma di Disegno

20.1 Panoramica

In questa sezione, creeremo un semplice programma di disegno. Durante questo processo, esamineremo come gestire gli eventi generati dal mouse, come disegnare all'interno di una finestra e come disegnare in modo migliore usando una pixmap di supporto. Dopo averlo creato, lo amplieremo aggiungendo il supporto per i dispositivi XInput, per esempio le tavolette grafiche. Il GTK fornisce delle routine di supporto grazie alle quali risulta piuttosto semplice ottenere informazioni estese, come la pressione o l'inclinazione.

20.2 Gestione degli Eventi

I segnali di GTK che abbiamo discusso finora si riferivano ad azioni di alto livello, ad esempio la selezione di un elemento di un menù. Però, a volte è utile sapere qualcosa su cose che si svolgono a livello più basso livello, come possono essere il movimento del mouse o la pressione di un tasto. Ci sono segnali di GTK anche per questi eventi di basso livello. I gestori di questo tipo di segnali hanno un parametro caratteristico in più, che è il puntatore ad una struttura che contiene informazioni riguardo all'evento. Per esempio, ai gestori di eventi che riguardano dei movimenti, si passa un puntatore ad una struttura GdkEventMotion, che è fatta (in parte) così:

struct _GdkEventMotion
{
  GdkEventType type;
  GdkWindow *window;
  guint32 time;
  gdouble x;
  gdouble y;
  ...
  guint state;
  ...
};

type avrà il valore del tipo di evento, in questo caso GDK_MOTION_NOTIFY, window rappresenta la finestra in cui l'evento si è verificato. x e y forniscono le coordinate dell'evento e state specifica lo stato dei modificatori nel momento in cui l'evento si è verificato (cioè, specifica quali tasti modificatori e tasti del mouse erano premuti in quel momento). E' un OR bit per bit dei seguenti valori:

GDK_SHIFT_MASK  
GDK_LOCK_MASK   
GDK_CONTROL_MASK
GDK_MOD1_MASK   
GDK_MOD2_MASK   
GDK_MOD3_MASK   
GDK_MOD4_MASK   
GDK_MOD5_MASK   
GDK_BUTTON1_MASK
GDK_BUTTON2_MASK
GDK_BUTTON3_MASK
GDK_BUTTON4_MASK
GDK_BUTTON5_MASK

Come succede per gli altri segnali, per determinare cosa deve accadere in corrispondenza di un evento, si chiama gtk_signal_connect(). Ma è anche necessario far sì che GTK sappia di quali eventi vogliamo essere informati. A questo fine, chiamiamo la funzione:

void  gtk_widget_set_events (GtkWidget *widget, gint events);

Il secondo campo specifica gli eventi che ci interessano. Si tratta dell'OR bit per bit delle costanti che identificano i diversi tipi di eventi. La lista dei tipi di eventi è la seguente:

GDK_EXPOSURE_MASK
GDK_POINTER_MOTION_MASK
GDK_POINTER_MOTION_HINT_MASK
GDK_BUTTON_MOTION_MASK     
GDK_BUTTON1_MOTION_MASK    
GDK_BUTTON2_MOTION_MASK    
GDK_BUTTON3_MOTION_MASK    
GDK_BUTTON_PRESS_MASK      
GDK_BUTTON_RELEASE_MASK    
GDK_KEY_PRESS_MASK         
GDK_KEY_RELEASE_MASK       
GDK_ENTER_NOTIFY_MASK      
GDK_LEAVE_NOTIFY_MASK      
GDK_FOCUS_CHANGE_MASK      
GDK_STRUCTURE_MASK         
GDK_PROPERTY_CHANGE_MASK   
GDK_PROXIMITY_IN_MASK      
GDK_PROXIMITY_OUT_MASK     

Per chiamare gtk_widget_set_events(), si devono fare alcune osservazioni sottili. In primo luogo, la si deve chiamare prima che sia stata creata la finestra X per il widget GTK. In pratica, ciò significa che la si deve chiamare subito dopo aver creato il widget. In secondo luogo, il widget deve avere una finestra X associata. Molti widget, per ragioni di efficienza, non hanno una propria finetra, e vengono mostrati nella finestra madre. Questi widget sono:

GtkAlignment
GtkArrow
GtkBin
GtkBox
GtkImage
GtkItem
GtkLabel
GtkPixmap
GtkScrolledWindow
GtkSeparator
GtkTable
GtkAspectFrame
GtkFrame
GtkVBox
GtkHBox
GtkVSeparator
GtkHSeparator

Per catturare degli eventi per questo tipo di widget, si deve fare uso del widget EventBox. Si veda a questo proposito la sezione su The EventBox Widget.

Per il nostro programma di disegno, vogliamo sapere quando il pulsante del mouse è premuto e quando viene mosso, quindi specificheremo GDK_POINTER_MOTION_MASK e GDK_BUTTON_PRESS_MASK. Vogliamo anche essere informati su quando è necessario ridisegnare la nostra finestra, quindi specifichiamo GDK_EXPOSURE_MASK. Anche se vogliamo essere avvertiti con un evento ``Configure'' se la dimensione della nostra finestra cambia, non è necessario specificare il flag GDK_STRUCTURE_MASK, dal momento che questo viene specificato automaticamente per tutte le finestre.

Risulta, conunque, che specificando semplicemente GDK_POINTER_MOTION_MASK si crea un problema. Ciò infatti fa sì che il server aggiunga nella coda un un nuovo evento di movimento ogni volta che l'utente muovoe il mouse. Immaginate che ci vogliano 0.1 secondi per gestire uno di questi eventi, e che il server X metta in coda un nuovo evento ogni 0.05 secondi. Rimarremo ben presto indietro rispetto al disegno dell'utente. Se l'utente disegna per 5 secondi, ci metteremmo altri 5 secondi prima di finire dopo che l'utente ha rilasciato il pulsante del mouse! Vorremmo quindi che venga notificato un solo evento di movimento per ogni evento che processiamo. Il modo per farlo è di specificare GDK_POINTER_MOTION_HINT_MASK.

Quando specifichiamo GDK_POINTER_MOTION_HINT_MASK, il server ci notifica un evento di movimento la prima volta che il puntatore si muove dopo essere entrato nella nostra finestra, oppure dopo ogni rilascio di un pulsante del mouse. Gli altri eventi di movimento verranno soppressi finché non richiediamo esplicitamente la posizione del puntatore con la funzione:

GdkWindow*    gdk_window_get_pointer     (GdkWindow       *window,
                                          gint            *x,
                                          gint            *y,
                                          GdkModifierType *mask);

(c'è anche un'altra funzione, gtk_widget_get_pointer(), che ha un'interfaccia più semplice, ma che non risulta molto utile dal momento che restituisce solo la posizione del puntatore, senza dettagli sullo sato dei pulsanti.)

Quindi, il codice per assegnare gli eventi per la nostra finestra, avrà l'aspetto:

  gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
                      (GtkSignalFunc) expose_event, NULL);
  gtk_signal_connect (GTK_OBJECT(drawing_area),"configure_event",
                      (GtkSignalFunc) configure_event, NULL);
  gtk_signal_connect (GTK_OBJECT (drawing_area), "motion_notify_event",
                      (GtkSignalFunc) motion_notify_event, NULL);
  gtk_signal_connect (GTK_OBJECT (drawing_area), "button_press_event",
                      (GtkSignalFunc) button_press_event, NULL);

  gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK
                         | GDK_LEAVE_NOTIFY_MASK
                         | GDK_BUTTON_PRESS_MASK
                         | GDK_POINTER_MOTION_MASK
                         | GDK_POINTER_MOTION_HINT_MASK);

Teniamo per dopo i gestori di ``expose_event'' e ``configure_event''. Quelli di ``motion_notify_event'' e ``button_press_event'' sono piuttosto semplici:

static gint
button_press_event (GtkWidget *widget, GdkEventButton *event)
{
  if (event->button == 1 && pixmap != NULL)
      draw_brush (widget, event->x, event->y);

  return TRUE;
}

static gint
motion_notify_event (GtkWidget *widget, GdkEventMotion *event)
{
  int x, y;
  GdkModifierType state;

  if (event->is_hint)
    gdk_window_get_pointer (event->window, &x, &y, &state);
  else
    {
      x = event->x;
      y = event->y;
      state = event->state;
    }
    
  if (state & GDK_BUTTON1_MASK && pixmap != NULL)
    draw_brush (widget, x, y);
  
  return TRUE;
}

20.3 Il widget Area di Disegno (DrawingArea) e il procedimento per Disegnare

Vediamo ora il procedimento per disegnare sullo schermo. Il widget da usare è l'Area di Disegno (DrawingArea). Essenzialmente si tratta di una finestra X e nient'altro. E' una tela bianca su cui possimo disegnare tutto quello che vogliamo. Per crearne una usiamo la chiamata:

GtkWidget* gtk_drawing_area_new        (void);

Per specificare una dimensione predefinita, si puo fare:

void       gtk_drawing_area_size       (GtkDrawingArea      *darea,
                                        gint                 width,
                                        gint                 height);

Come è vero per tutti i widget, si può modificare questa dimensione predefinita, tramite la chamata a gtk_widget_set_usize(), e questa a sua volta può essere modificata dall'utente ridimensionando manualmente la finestra che contiene l'area di disegno.

Si deve notare che nel momento in cui creiamo un widget DrawingArea, siamo completamente responsabili di disegnarne il contenuto. Se ad esempio la nostra finestra viene prima nascosta e poi dinuovo portata in primo piano, otteniamo un evento di ``esposizione'' e doppiamo ridisegnare ciò che era stato precedente nascosto.

Dover ricordare tutto quello che era disegnato sulla finestra in modo da poterlo ridisegnare successivamente, può essere, come minimo, noioso. In più, può essere spiacevole dal punto di vista visivo, se delle porzioni dello schermo vengono prima cancellate e poi ridisegnate passo per passo. La soluzione per questo problema è di usare una pixmap di supporto. Invece di disegnare direttamente sullo schermo, disegnamo su un'iimagine conservata nella memoria del server ma che non viene mostrata; quindi, quando l'immagine cambia o ne vengono mostrate nuove porzioni, copiamo sullo schermo le parti corrispondenti.

Per creare una ppixmap fuori dallo schermo, usiamo la funzione:

GdkPixmap* gdk_pixmap_new               (GdkWindow  *window,
                                         gint        width,
                                         gint        height,
                                         gint        depth);

Il parametro windowspecifica una finestra GDK dalla quale questa pixmap prende alcune delle sue proprietà. width e height specificano le dimensioni della pixmap. depth specifica la profondità di colore, cioè il numero di bit per ogni pixel, per la nuova pixmap. Se alla profondità è assegnato il valore -1, questa verrà posta identica a quella di window.

Creiamo la pixmap all'interno del gestore di ``configure_event''. Questo evento è generato ogni volta che la finestra cambia di dimensione, compreso il momento in cui viene creata per la prima volta.

/* Pixmap di supporto per l'area di disegno */
static GdkPixmap *pixmap = NULL;

/* Creare una pixmap della dimensione appropriata */
static gint
configure_event (GtkWidget *widget, GdkEventConfigure *event)
{
  if (pixmap)
    {
      gdk_pixmap_destroy(pixmap);
    }
  pixmap = gdk_pixmap_new(widget->window,
                          widget->allocation.width,
                          widget->allocation.height,
                          -1);
  gdk_draw_rectangle (pixmap,
                      widget->style->white_gc,
                      TRUE,
                      0, 0,
                      widget->allocation.width,
                      widget->allocation.height);

  return TRUE;
}

La chiamata a gdk_draw_rectangle() inizialmente rende bianca l'intera pixmap. Fra un momento ne riparleremo.

Il gestore dell'evento ``esposizione'', copia quindi la porzione appropriata della pixmap sullo schermo (determiniamo qual è l'area da ridisegnare usando il campo event->area dell'evento di esposizione):

/* Ridisegna sullo schermo a partire dalla pixmap di supporto */
static gint
expose_event (GtkWidget *widget, GdkEventExpose *event)
{
  gdk_draw_pixmap(widget->window,
                  widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
                  pixmap,
                  event->area.x, event->area.y,
                  event->area.x, event->area.y,
                  event->area.width, event->area.height);

  return FALSE;
}

Abbiamo quindi visto come tenete aggiornato lo schermo con la nostra pixmap, ma come facciamo per disegnare delle cose interessanti sulla pixmap? Ci sono un bel po' di funzioni nella libreria GDK di GTK che servono per disegnare su superfici disegnabili. Una superficie disegnabile è semplicemente qualcosa su cui si può disegnare un'immagine. Può essere una finestra, una pixmap o una bitmap (un'immagine in bianco e nero). Abbiamo già visto sopra due di chiamate, gdk_draw_rectangle() and gdk_draw_pixmap(). La lista completa è la seguente:

gdk_draw_line ()
gdk_draw_rectangle ()
gdk_draw_arc ()
gdk_draw_polygon ()
gdk_draw_string ()
gdk_draw_text ()
gdk_draw_pixmap ()
gdk_draw_bitmap ()
gdk_draw_image ()
gdk_draw_points ()
gdk_draw_segments ()

Per ulteriori dettagli su queste funzioni, vedete la documentazione di riferimento nei file header <gdk/gdk.h>. Tutte queste funzioni hanno i medesimi primi due argomenti. Il primo è la superficie disegnabili su cui disegnare, il secondo è un contesto grafico (GC).

Un contesto grafico incapsula delle informazioni riguardo a cose come il colore di sfondo e di primo piano e lo spessore della linea. GDK ha un ampio insieme di funzioni per crare e modificare contesti grafici, ma per tenere le cose semplici useremo solo dei contesti grafici predefiniti. Ogni widget ha uno stile associato (che può essere modificato agendo su un file gtkrc). Questo, fra le altre cose, contiene un certo numero di contesti grafici. Alcuni esempi di come accedere a questi contesti grafici sono i seguenti:

widget->style->white_gc
widget->style->black_gc
widget->style->fg_gc[GTK_STATE_NORMAL]
widget->style->bg_gc[GTK_WIDGET_STATE(widget)]

I campi fg_gc, bg_gc, dark_gc, e light_gc sono indicizzati tramite un parametri di tipo GtkStateType, che può assumere i valori:

GTK_STATE_NORMAL,
GTK_STATE_ACTIVE,
GTK_STATE_PRELIGHT,
GTK_STATE_SELECTED,
GTK_STATE_INSENSITIVE

Per esempio, per GTK_STATE_SELECTED il colore di sfondo predefinito è blu scuro e quello di primo piano bianco.

La nostra funzione draw_brush(), che efettivamente disegna sullo schermo, diventa quindi:

/* Disegna un rettangolo sullo schermo */
static void
draw_brush (GtkWidget *widget, gdouble x, gdouble y)
{
  GdkRectangle update_rect;

  update_rect.x = x - 5;
  update_rect.y = y - 5;
  update_rect.width = 10;
  update_rect.height = 10;
  gdk_draw_rectangle (pixmap,
                      widget->style->black_gc,
                      TRUE,
                      update_rect.x, update_rect.y,
                      update_rect.width, update_rect.height);
  gtk_widget_draw (widget, &update_rect);
}

Dopo aver disegnato il rettangolo sulla pixmap, chiamiamo la funzione:

void       gtk_widget_draw                (GtkWidget           *widget,
                                           GdkRectangle        *area);

che notifica a X che l'area data dal parametro area deve essere aggiornata. X poi genererà un evento di esposizione (che può essere combinato con le aree passate da diverse chiamate a gtk_widget_draw()) che farà sì che il nostro gestore dell'evento di esposizione, copi le porzioni rilevanti sullo schermo.

Abbiamo a questo punto creato tutto il programma di disegno, tranne che per qualche dettaglio irrilevante come la creazione della finestra principale. Il codice sorgente completo è reperibile dove avete ottenuto questo tutorial, oppure da:

http://www.msc.cornell.edu/~otaylor/gtk-gimp/tutorial

20.4 Aggiungere il supporto per XInput

Al giorno d'oggi è possibile acquistare dei dispositivi abbastanza a buon mercato, come tavolette grafice, che permettono di disegnare con una espressività artistica molto semplificata rispetto ad un mouse. Il modo più semplice per usare questi dispositivi è di sostituirli semplicemente al mouse, ma in questo modo si perdono molti dei loro vantaggi, come:

• Sensibilità alla pressione
• Sensibilità all'inclinazione
• Posizionamento infra-pixel
• Ingressi multipli (per esempio, uno stilo che contiene sia una ``matita'' sia una ``gomma'')

Per ulteriori informazioni sulle estensioni XInput, vedere l' XInput-HOWTO.

Se esaminiamo, per esempio, la definizione completa della struttura GdkEventMotion, possiamo vedere che contiene dei campi per il supporto delle informazioni estese dai dispositivi.

struct _GdkEventMotion
{
  GdkEventType type;
  GdkWindow *window;
  guint32 time;
  gdouble x;
  gdouble y;
  gdouble pressure;
  gdouble xtilt;
  gdouble ytilt;
  guint state;
  gint16 is_hint;
  GdkInputSource source;
  guint32 deviceid;
};

pressure fornisce la pressione sotto forma di un numero decimale compreso fra 0 e 1. xtilt e ytilt possono assumere valori compresi fra -1 e 1, corrispondenti al grado di inclinazione in ciascuna direzione. source e deviceid specificano il dispositivo per il quale si è verificato l'evento in due modi distinti. source da alcune semplici informazioni sul tipo di dispositivo, e può assumere i valori:

GDK_SOURCE_MOUSE
GDK_SOURCE_PEN
GDK_SOURCE_ERASER
GDK_SOURCE_CURSOR

deviceid specifica invece un identificativo numerico univoco per il dispositivo. Questo può essere a sua volta utilizzato per avere ulteriori informazioni sul dispositivo tramite la chiamata a gdk_input_list_devices() (vedi sotto). Il valore speciale GDK_CORE_POINTER viene usato per identificare il dispositivo di puntamento principale (di solito il mouse).

Abilitare le informazioni estese

Per far sì che GTK sappia che ci interessano le informazioni estese dai dispositivi, basta aggiungere un'unica linea al nostro programma:

gtk_widget_set_extension_events (drawing_area, GDK_EXTENSION_EVENTS_CURSOR);

Dando il valore GDK_EXTENSION_EVENTS_CURSOR, diciamo che ci interessano gli eventi relativi alle estensioni, ma solo se non dobbiamo disegnare da noi il nostro cursore. Si veda più sotto alla sezione Ulteriori Sofisticazioni per ulteriori informazioni sul modo si disegnare i cursori. Potremmo anche dare i valori GDK_EXTENSION_EVENTS_ALL se vogliamo disegnare il nostro cursore o GDK_EXTENSION_EVENTS_NONE se vogliamo tornare alle condizioni predefinite.

Comunque, non finisce tutto qui. Non ci sono estensioni abilitate per difetto. Abbiamo bisogno di un meccanismo per permettere agli utenti l'abilitazione e la configurazione delle estensioni dei loro dispositivi, GTK fornisce il widget InputDialog per automatizzare questo processo. La seguente procedura mostra come gestire un widget InputDialog. Crea la finestra di dialogo nel caso non sia presente, mentre la porta in primo piano in caso contrario.

void
input_dialog_destroy (GtkWidget *w, gpointer data)
{
  *((GtkWidget **)data) = NULL;
}

void
create_input_dialog ()
{
  static GtkWidget *inputd = NULL;

  if (!inputd)
    {
      inputd = gtk_input_dialog_new();

      gtk_signal_connect (GTK_OBJECT(inputd), "destroy",
                          (GtkSignalFunc)input_dialog_destroy, &inputd);
      gtk_signal_connect_object (GTK_OBJECT(GTK_INPUT_DIALOG(inputd)->close_button),
                                 "clicked",
                                 (GtkSignalFunc)gtk_widget_hide,
                                 GTK_OBJECT(inputd));
      gtk_widget_hide ( GTK_INPUT_DIALOG(inputd)->save_button);

      gtk_widget_show (inputd);
    }
  else
    {
      if (!GTK_WIDGET_MAPPED(inputd))
        gtk_widget_show(inputd);
      else
        gdk_window_raise(inputd->window);
    }
}

(Notate come gestiamo questo dialogo. Con la connessione del segnale ``destroy'' ci assicuriamo di non tenerci in giro il puntatore al dialogo dopo che lo abbiamo distrutto, cosa che potrebbe portare ad un errore di segmentazione.)

L'InputDialog ha due pulsanti, ``Close'' e ``Save'', i quali non hanno alcuna azione predefinita assegnata ad essi. Nella funzione precedente, abbiamo fatto in modo che ``Close'' nasconda la finestra di dialogo, e abbiamo nascosto il pulsante ``Save'' dal momento che in questo programma non implementiamo il salvataggio delle opzioni di XInput.

Usare le informazioni estese

Una volta abilitato il dipositivo, possiamo usare le informazioni estese che si trovano nei corrispondenti campi delle strutture che descrivono gli eventi. A dire il vero, l'utilizzo di questi campi è sempre sicuro, perché sono tutti posti per difetto a valori ragionevoli ancje quando la gestione degli eventi estesi non è abilitata.

Un cambiamento che dobbiamo fare è di chiamare gdk_input_window_get_pointer() invece di gdk_window_get_pointer. Ciò si rende necessario perché gdk_window_get_pointer non restituisce le informazioni esetese.

void gdk_input_window_get_pointer     (GdkWindow       *window,
                                       guint32         deviceid,
                                       gdouble         *x,
                                       gdouble         *y,
                                       gdouble         *pressure,
                                       gdouble         *xtilt,
                                       gdouble         *ytilt,
                                       GdkModifierType *mask);

Quando chiamiamo questa funzione, dobbiamo specificare l'identificativo del dispositivo e la finestra. Normalmente questo identificativo lo si ottiene dal campo deviceid della struttura dell'evento. Questa funzione restituirà valori ragionevoli nel caso che la gestione degli eventi estesi non sia attivata (in questo caso, event->deviceid avrà il valore GDK_CORE_POINTER).

Quindi, la struttura di base dei gestori degli eventi relativi alla pressione di bottoni e ai movomenti non cambia molto - abbiamo solo bisogno di aggiungere il codice necessario per tenere conto delle informazioni estese.

static gint
button_press_event (GtkWidget *widget, GdkEventButton *event)
{
  print_button_press (event->deviceid);
  
  if (event->button == 1 && pixmap != NULL)
    draw_brush (widget, event->source, event->x, event->y, event->pressure);

  return TRUE;
}

static gint
motion_notify_event (GtkWidget *widget, GdkEventMotion *event)
{
  gdouble x, y;
  gdouble pressure;
  GdkModifierType state;

  if (event->is_hint)
    gdk_input_window_get_pointer (event->window, event->deviceid,
                                  &x, &y, &pressure, NULL, NULL, &state);
  else
    {
      x = event->x;
      y = event->y;
      pressure = event->pressure;
      state = event->state;
    }
    
  if (state & GDK_BUTTON1_MASK && pixmap != NULL)
    draw_brush (widget, event->source, x, y, pressure);
  
  return TRUE;
}

Avremo anche bisogno di fare qualcosa con queste nuove informazioni. La nostra nuova funzione draw_brush disegna con un colore diverso per ogni event->source e cambia la dimensione della linea in funzione della pressione.

/* Disegna un rettangolo sullo schermo, con la dimensione dipendente
   dalla pressione e il colore dipendente dal tipo di dispositivo */
static void
draw_brush (GtkWidget *widget, GdkInputSource source,
            gdouble x, gdouble y, gdouble pressure)
{
  GdkGC *gc;
  GdkRectangle update_rect;

  switch (source)
    {
    case GDK_SOURCE_MOUSE:
      gc = widget->style->dark_gc[GTK_WIDGET_STATE (widget)];
      break;
    case GDK_SOURCE_PEN:
      gc = widget->style->black_gc;
      break;
    case GDK_SOURCE_ERASER:
      gc = widget->style->white_gc;
      break;
    default:
      gc = widget->style->light_gc[GTK_WIDGET_STATE (widget)];
    }

  update_rect.x = x - 10 * pressure;
  update_rect.y = y - 10 * pressure;
  update_rect.width = 20 * pressure;
  update_rect.height = 20 * pressure;
  gdk_draw_rectangle (pixmap, gc, TRUE,
                      update_rect.x, update_rect.y,
                      update_rect.width, update_rect.height);
  gtk_widget_draw (widget, &update_rect);
}

Trovare ulteriori informazioni su di un dispositivo

Come esempio del modo di trovare altre informazioni su di un dispositivo, il nostro programma stamperà il nome di ogni dispositivo che genera un evento di pressione di un pulsante. Per avere il nome di un dispositivo, chiamiamo la funzione

GList *gdk_input_list_devices               (void);

che restituisce una GList (un tipo di lista collegata che si trova nella libreria glib) di strutture di tipo GdkDeviceInfo. La definizione di GdkDeviceInfo è la seguente:

struct _GdkDeviceInfo
{
  guint32 deviceid;
  gchar *name;
  GdkInputSource source;
  GdkInputMode mode;
  gint has_cursor;
  gint num_axes;
  GdkAxisUse *axes;
  gint num_keys;
  GdkDeviceKey *keys;
};

La maggior parte di questi campi rappresentano informazioni di configurazione che potete ignorare a meno che non implementiate il salvataggio della configurazione di un XInput. Quelle che ci interessano sono name, che è semplicemente il nome che X assegna al dispositivo, e has_cursor. Anche has_cursor non è informazione di configurazione, e indica, nel caso abbia valore ``falso'', che dobbiamo disegnare da soli il nostro cursore. Ma dal momento che abbiamo specificato GDK_EXTENSION_EVENTS_CURSOR, possiamo anche non preoccuparcene.

La nostra funzione print_button_press() scorre semplicemente la lista che è stata restituita finché non trova il valore corretto, e poi stampa il nome del dispositivo.

static void
print_button_press (guint32 deviceid)
{
  GList *tmp_list;

  /* gdk_input_list_devices restituisce una lista interna, così poi
     non dobbiamo liberarla */
  tmp_list = gdk_input_list_devices();

  while (tmp_list)
    {
      GdkDeviceInfo *info = (GdkDeviceInfo *)tmp_list->data;

      if (info->deviceid == deviceid)
        {
          printf("Button press on device '%s'\n", info->name);
          return;
        }

      tmp_list = tmp_list->next;
    }
}

http://www.msc.cornell.edu/~otaylor/gtk-gimp/tutorial

Ulteriori sofisticazioni

Anche se ora il nostro programma supporta XInput pittosto bene, gli mancano alcune caratteristiche che probabilmente vorremmo mettere in una applicazione completa. In primo luogo, probabilmente all'utente non farà piacere dover configurare i propri dispositivi ogni volta che lanciano il programma, per cui dovremmo dare la possibilità di salvare la configurazione dei dispositivi. Ciò può essere fatto scorrendo la lista restituita da gdk_input_list_devices() e scrivendo la configurazione su di un file.

Per tornare allo stato salvato la prossima volta che il programma viene eseguito, GDK mette a disposizione delle funzioni per cambiare la configurazione dei dispositivi:

gdk_input_set_extension_events()
gdk_input_set_source()
gdk_input_set_mode()
gdk_input_set_axes()
gdk_input_set_key()

(La lista restituita da gdk_input_list_devices() non dovrebbe essere modificata direttamente.) Un esempio di come fare può essere trovato nel programma di disegno gsumi (disponibile da http://www.msc.cornell.edu/~otaylor/gsumi/). Sarebbe bello avere alla fine un modo standard di recuperare le informazioni per tutte le applicazioni. Questo probabilmente appartiene ad un livello un po' più elevato ripetto a GTK, forse alla libreria GNOME.

Un'altra notevole omissione a cui abbiamo accennato precedentemente è il fatto di non disegnare il cursore direttamente. Piattaforme diverse da XFree86 non permettono in questo momento di usare contemporaneamente un dispositivo sia come puntatore principale sia direttamente da una applicazione. Vedere XInput-HOWTO per ulteriori informazioni. Ciò significa che le applicazioni che vogliono rivolgersi al pubblico più ampio dovranno prevedere di disegnare esse stesse il proprio cursore.

Un'applicazione che voglia disegnare il proprio cursore dovrà fare due cose: determinare se il dispositivo corrente necessita che venga disegnato un cursore, e determinare se il dispositivo corrente è in prossimità. (Se il dispositivo è una tavoletta grafica, un tocco di finezza è fare sparire il puntatore quando lo stilo viene sollevato dalla tavoletta. Quando c'è contatto fra lo stilo e la tavoletta, si dice che il dispositivo è ``in prossimità".) La prima cosa viene fatta scorrendo la lista dei dispositivi, come abbiamo fatto per trovare il nome del dispositivo. La seconda cosa viene ottenuta selezionando gli eventi ``proximity_out''. Un esempio di disegno del proprio cursore si trova nel programma 'testinput' incluso nella distribuzione di GTK.