Création de signaux pour vos widgets GTK+

Date de publication : 27/09/2006

Par Franck.H (Mon blog) (retour aux articles)
 

I. Introduction

Dans le cours précédent  Créer son widget GTK+ en Langage C (qu'il convient de lire avant de suivre ce tutoriel), nous avons créé un widget à partir de rien ; en fait plus ou moins car on part tout de même d'un GtkWidget.

Si vous avez des questions concernant GTK+ l'équipe de developpez.com sera ravie de vous aider, rendez-vous sur le  Forum GTK+ de developpez.com

II. Pré-requis

• Avoir suivi le cours  Créer son widget GTK+ en Langage C
• Posséder l'archive GtkLed.zip

III. Les signaux

III-A. Un bref rappel

gulong g_signal_connect(gpointer *object, const gchar *name, GCallback func, gpointer func_data );

III-B. Plan de route de notre signal

IV. Modification du code source

IV-A. Le fichier gtkled.h

struct _GtkLedClass {
   GtkWidgetClass parent_class;

   /* Signal personnel. */
   void (* switch_state) (GtkLed * led);
};

IV-B. Le fichier gtkled.c

static gboolean gtk_led_button_release (GtkWidget * widget,
                                        GdkEventButton * event);

enum {
   GTKLED_SWITCH_STATE_SIGNAL,
   GTKLED_NB_SIGNALS
};

static guint gtkled_signals [GTKLED_NB_SIGNALS] = { 0 };

static gboolean
gtk_led_button_release (GtkWidget * widget,
                        GdkEventButton * event)
{
   GTK_LED (widget)->state = !GTK_LED (widget)->state;
   gtk_led_paint (GTK_WIDGET (widget));

   g_signal_emit (
      G_OBJECT (widget),
      gtkled_signals [GTKLED_SWITCH_STATE_SIGNAL],
      0
   );


   return FALSE;
}

gtkled_signals [GTKLED_SWITCH_STATE_SIGNAL] = g_signal_new (
   "switch-state",
   G_TYPE_FROM_CLASS (klass),
   G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
   G_STRUCT_OFFSET (GtkLedClass, switch_state),
   NULL, NULL,
   g_cclosure_marshal_VOID__VOID,
   G_TYPE_NONE,
   0
);

guint g_signal_new (const gchar *signal_name,
                    GType itype,
                    GSignalFlags signal_flags,
                    guint class_offset,
                    GSignalAccumulator accumulator,
                    gpointer accu_data,
                    GSignalCMarshaller c_marshaller,
                    GType return_type,
                    guint n_params,
                    ...);

• Le premier argument n'est autre que le nom du signal tel que nous l'appellerons avec la fonction g_signal_connect.
  
  
• Le second argument est le numéro unique du widget qui lui est attribué lors de son enregistrement auprès de GTK+.
  
  
• L'argument signal_flags sert à déterminer si le gestionnaire par défaut doit être lancé avant ou après celui de l'utilisateur. Il faut au minimum indiquer le drapeau G_SIGNAL_RUN_FIRST ou G_SIGNAL_RUN_LAST qui sont les constantes généralement utilisées.  Les autres constantes possible
  
  
  Cet argument sert à déterminer en partie, le moment où sera appelé le gestionnaire de l'utilisateur (notre fonction dans la structure _GtkLedClass) que nous attachons à notre widget avec l'argument suivant (class_offset) !
  
  
• L'argument guint class_offset n'est autre que l'adresse du pointeur de fonction pour notre signal dans la structure de classe de notre widget. La fonction utilisée: G_STRUCT_OFFSET prend pour argument le nom de la structure de classe puis le nom du pointeur de fonction de notre signal.
  
  
• L'argument GSignalAccumulator accumulator est en fait une fonction callback spéciale qui permet de collecter des valeurs de retour d'autres callback du même widget pendant une émission de signaux, nous laissons cette argument à NULL.
  
  
• L'argument qui suit n'est autre qu'un pointeur sur des données utilisateur tout comme les autres fonctions de rappel dans GTK+. Vu que nous n'utilisons pas de fonction d'accumulation nous laissons cet argument à NULL.
  
  
• L'argument GSignalCMarshaller c_marshaller permet de spécifier la signature de la fonction interne à GTK+ qui s'occupe de lancer le signal lorsque nous appelons g_signal_emit. Dans notre cas, g_cclosure_marshal_VOID__VOID dit à GTK+ que nous utilisons une fonction qui ne prend pas d'argument supplémentaires que ceux par défaut (nous verrons la signature de notre fonction de rappel plus loin) et ne renvoie pas de résultat.
  
  
• L'argument GType return_type est simplement le type de retour de notre signal, ici void donc nous utilisons la constante G_TYPE_NONE. Il existe d'autres constantes utilisables, les voici:
  
  
  • G_TYPE_INVALID
  • G_TYPE_NONE
  • G_TYPE_INTERFACE
  • G_TYPE_CHAR
  • G_TYPE_UCHAR
  • G_TYPE_BOOLEAN
  • G_TYPE_INT
  • G_TYPE_UINT
  • G_TYPE_LONG
  • G_TYPE_ULONG
  • G_TYPE_INT64
  • G_TYPE_UINT64
  • G_TYPE_ENUM
  • G_TYPE_FLAGS
  • G_TYPE_FLOAT
  • G_TYPE_DOUBLE
  • G_TYPE_STRING
  • G_TYPE_POINTER
  • G_TYPE_BOXED
  • G_TYPE_PARAM
  • G_TYPE_OBJECT


• Le dernier argument permet de spécifier la liste des arguments supplémentaires à rajouter à notre signal, ici nous n'avons pas besoin de signaux en plus, ceux par défaut qui sont définis explicitement par GTK+ à savoir, le widget qui récupère le signal et les données utilisateurs, nous suffisent.

static void
gtk_led_init (GtkLed * led)
{
   led->on_image = NULL;
   led->off_image = NULL;
   led->on_pixbuf = NULL;
   led->off_pixbuf = NULL;
   led->width = 0;
   led->height = 0;
   led->state = FALSE;


   g_signal_connect (
      G_OBJECT (led),
      "button-release-event",
      G_CALLBACK (gtk_led_button_release),
      led
   );
}

attributes.event_mask = gtk_widget_get_events (widget) |
   GDK_EXPOSURE_MASK | GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK;

IV-C. Signature de notre callback

void user_function (GtkWidget * widget, gpointer data);

V. Conclusion

VI. Code source complet

VII. Remerciements