Création de widgets

**Loenix** · 01/02/2011, 19h33

Bonjour,

Après des heures sur le tuto de Franck.H : http://franckh.developpez.com/tutori...eation-widget/ il m'est toujours impossible d'arriver à modifier ce code...

Le principe est très simple, pour être sur d'avoir tout bien compris (et c'est la que je me suis heurté à un problème) j'ai voulu reproduire exactement ce même script mais en souhaitant que cette LED ne soit pas un GtkWidget mais un GtkButton, j'ai besoin que cette led hérite des propriétés : enter, leave... afin de créer un nouveau widget révolutionnaire !!! =P

Bref, c'est désespéré que je m'adresse à vous...

VOici les modifications que j'ai apporté :

gtkled.h :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#ifndef __GTK_LED_H
#define __GTK_LED_H
#include <gtk/gtk.h>
#include <gtk/gtkbutton.h>
 
G_BEGIN_DECLS
 
#define GTK_LED(obj) \
   GTK_CHECK_CAST(obj, gtk_led_get_type (), GtkLed)
#define GTK_LED_CLASS(klass) \
   GTK_CHECK_CLASS_CAST(klass, gtk_led_get_type (), GtkLedClass)
#define GTK_IS_LED(obj) \
   GTK_CHECK_TYPE(obj, gtk_led_get_type ())
 
typedef struct _GtkLed GtkLed;
typedef struct _GtkLedClass GtkLedClass;
 
struct _GtkLed
{
   GtkButton widget;
 
   const gchar * on_image;
   const gchar * off_image;
   const gchar * clic_image;
 
   GdkPixbuf * on_pixbuf;
   GdkPixbuf * off_pixbuf;
   GdkPixbuf * clic_pixbuf;
 
   gint width;
   gint height;
 
   gboolean state;
};
 
struct _GtkLedClass
{
   GtkButtonClass parent_class;
};
 
GtkType gtk_led_get_type (void);
gboolean gtk_led_get_state (GtkLed * led);
void gtk_led_set_state (GtkLed * led, gboolean state);
GtkButton * gtk_led_new (const gchar * off_image, const gchar * on_image, const gchar * clic_image);
 
G_END_DECLS
 
#endif

gtkled.c :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
#include "gtkled.h"
 
static void gtk_led_class_init (GtkLedClass * klass);
static void gtk_led_init (GtkLed * led);
static void gtk_led_load_image (GtkLed * led);
static void gtk_led_size_request (GtkWidget * widget, GtkRequisition * requisition);
static void gtk_led_size_allocate (GtkWidget * widget, GtkAllocation * allocation);
static void gtk_led_realize (GtkWidget * widget);
static gboolean gtk_led_expose (GtkWidget * widget, GdkEventExpose * event);
static void gtk_led_paint (GtkWidget * widget);
static void gtk_led_destroy (GtkObject * object);
 
static void test (GtkButton * widget)
{
       printf("okokokok");
}
 
GtkType gtk_led_get_type (void)
{
   static GtkType gtk_led_type = 0;
   if (! gtk_led_type)
   {
      static const GtkTypeInfo gtk_led_info = {
         "GtkLed",
         sizeof (GtkLed),
         sizeof (GtkLedClass),
         (GtkClassInitFunc) gtk_led_class_init,
         (GtkObjectInitFunc) gtk_led_init,
         NULL,
         NULL,
         (GtkClassInitFunc) NULL
      };
      gtk_led_type = gtk_type_unique (GTK_TYPE_WIDGET, &gtk_led_info);
   }
   return gtk_led_type;
}
 
int gtk_led_get_state (GtkLed * led)
{
   return led->state;
}
 
void gtk_led_set_state (GtkLed * led, int state)
{
   led->state = state;
   gtk_led_paint (GTK_WIDGET (led));
}
 
GtkButton * gtk_led_new (const gchar * off_image, const gchar * on_image, const gchar * clic_image)
{
   GtkLed * led = NULL;
   if (off_image != NULL && on_image != NULL && clic_image != NULL)
   {
      led = gtk_type_new (gtk_led_get_type ());
      if (led != NULL)
      {
         led->off_image = off_image;
         led->on_image = on_image;
         led->clic_image = clic_image;
         led->state = 0;
         gtk_led_load_image (led);
      }
   }
   return GTK_BUTTON (led);
}
 
static void gtk_led_class_init (GtkLedClass * klass)
{
   GtkButtonClass * button_class;
   GtkWidgetClass * widget_class;
   GtkObjectClass * object_class;
   button_class = (GtkButtonClass *) klass;
   widget_class = (GtkWidgetClass *) klass;
   object_class = (GtkObjectClass *) klass;
   button_class->enter = test;
   widget_class->realize = gtk_led_realize;
   widget_class->size_request = gtk_led_size_request;
   widget_class->size_allocate = gtk_led_size_allocate;
   widget_class->expose_event = gtk_led_expose;
   object_class->destroy = gtk_led_destroy;
}
 
static void gtk_led_init (GtkLed * led)
{
   led->on_image = NULL;
   led->off_image = NULL;
   led->clic_image = NULL;
   led->on_pixbuf = NULL;
   led->off_pixbuf = NULL;
   led->clic_pixbuf = NULL;
   led->width = 0;
   led->height = 0;
   led->state = 0;
}
 
static void gtk_led_load_image (GtkLed * led)
{
   led->on_pixbuf = gdk_pixbuf_new_from_file (led->on_image, NULL);
   led->off_pixbuf = gdk_pixbuf_new_from_file (led->off_image, NULL);
   led->clic_pixbuf = gdk_pixbuf_new_from_file (led->clic_image, NULL);
   led->width = gdk_pixbuf_get_width (led->on_pixbuf);
   led->height = gdk_pixbuf_get_height (led->on_pixbuf);
}
 
static void gtk_led_size_request (GtkWidget * widget, GtkRequisition * requisition)
{
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_LED (widget));
   g_return_if_fail (requisition != NULL);
   requisition->width = GTK_LED (widget)->width;
   requisition->height = GTK_LED (widget)->height;
}
 
static void gtk_led_size_allocate (GtkWidget * widget, GtkAllocation * allocation)
{
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_LED (widget));
   g_return_if_fail (allocation != NULL);
   widget->allocation = *allocation;
   if (GTK_WIDGET_REALIZED (widget))
   {
      gdk_window_move_resize (
         widget->window,
         allocation->x, allocation->y,
         allocation->width, allocation->height
      );
   }
}
 
static void gtk_led_realize (GtkWidget * widget)
{
   GdkWindowAttr attributes;
   guint attributes_mask;
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_LED (widget));
   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
   attributes.window_type = GDK_WINDOW_CHILD;
   attributes.x = widget->allocation.x;
   attributes.y = widget->allocation.y;
   attributes.width = widget->allocation.width;
   attributes.height = widget->allocation.height;
   attributes.wclass = GDK_INPUT_OUTPUT;
   attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
   attributes_mask = GDK_WA_X | GDK_WA_Y;
   widget->window = gdk_window_new (
      gtk_widget_get_parent_window (widget),
      & attributes, attributes_mask
   );
   gdk_window_set_user_data (widget->window, widget);
   widget->style = gtk_style_attach (widget->style, widget->window);
   gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
}
 
static gboolean gtk_led_expose (GtkWidget * widget, GdkEventExpose * event)
{
   g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_LED (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
   gtk_led_paint (widget);
   return FALSE;
}
 
static void gtk_led_paint (GtkWidget * widget)
{
   GdkPixbuf * pixbuf = NULL;
   gint center_x = 0;
   gint center_y = 0;
   gdk_window_clear_area (
      widget->window,
      0, 0,
      widget->allocation.width,
      widget->allocation.height
   );
   center_x = (widget->allocation.width / 2) - (GTK_LED (widget)->width / 2);
   center_y = (widget->allocation.height / 2) - (GTK_LED (widget)->height / 2);
   if (GTK_LED (widget)->state ==  0)
      pixbuf = GTK_LED (widget)->off_pixbuf;
   else if (GTK_LED (widget)->state == 1)
      pixbuf = GTK_LED (widget)->on_pixbuf;
   else
      pixbuf = GTK_LED (widget)->clic_pixbuf;
   gdk_pixbuf_render_to_drawable (
      pixbuf,
      GDK_DRAWABLE (widget->window),
      NULL,
      0, 0, center_x, center_y,
      GTK_LED (widget)->width, GTK_LED (widget)->height,
      GDK_RGB_DITHER_NORMAL, 1, 1
   );
}
 
static void gtk_led_destroy (GtkObject * object)
{
   GtkLed * led;
   GtkLedClass * klass;
   g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_LED (object));
   led = GTK_LED (object);
   if (led->on_pixbuf != NULL && led->off_pixbuf != NULL && led->clic_pixbuf != NULL)
   {
      gdk_pixbuf_unref (led->on_pixbuf);
      gdk_pixbuf_unref (led->off_pixbuf);
      gdk_pixbuf_unref (led->clic_pixbuf);
 
      led->on_pixbuf = NULL;
      led->off_pixbuf = NULL;
      led->clic_pixbuf = NULL;
   }
   klass = gtk_type_class (gtk_widget_get_type ());
   if (GTK_OBJECT_CLASS (klass)->destroy)
   {
      (* GTK_OBJECT_CLASS (klass)->destroy) (object);
   }
}

Le main est resté inchangé...

SI vous avez besoin d'infos n'hésitez pas...

Merci d'avance a tous...

Mickael

**Gamall** · 01/02/2011, 20h16

Le problème c'est que ce tutoriel est obsolète, il faudrait penser à le réécrire

**Loenix** · 02/02/2011, 08h47

Bonjour,

Je vous remercie de votre réponse, en effet si le tuto est obsolète c'est pas très utile ^.^

Quoi qu'il en soit, je vais potasser votre lien et je vous tiendrai au courant lorsque cela sera terminé...

J'en profiterai si j'ai tout bien compris pour réécrire le tutoriel sur developpez...

Merci beaucoup.

Mickael

**Loenix** · 02/02/2011, 10h09

Re-Bonjour,

Rien de très concluant...
Le code trouvé sur le site ne fonctionne pas :s
Après avoir dépouillé les recherches de Google... toutes les personnes qui ont créé de nouveaux widgets en Gtk+ ont pris pour parent : GtkWidget... Mais je veux juste créer un enfant du bouton, à moins qu'il y est une autre méthode pour faire dépendre à un GtkImage les signaux : enter, leave...

Merci de votre aide par avance...

Mickael

**gerald3d** · 02/02/2011, 10h28

Peut être un GtkEventBox dans lequel tu insères ton GtkImage.

**Loenix** · 02/02/2011, 10h39

Bonjour,

Malheureusement GtkEventBox ne possède aucun signal

Impossible d'y relier les signaux de bouton ...

Merci en tout cas à tous de m'aider

Mickael

**Franck.H** · 02/02/2011, 10h57

Envoyé par artificier59

Le problème c'est que ce tutoriel est obsolète, il faudrait penser à le réécrire

Ouais c'est clair c'est dépassé, y'a une nouvelle façon d'écrire des widgets... enfin deux à vrai dire, la seconde c'est avec le langage Vala

**Loenix** · 02/02/2011, 12h51

Bonjour,

Qu'il soit obsolète ou non, je vous avoue que jusque la c'est le seul qui est bien marché, d'ailleurs sur internet on ne retrouve que votre tutoriel, et tous les scriptes que j'ai trouvé ont été basé sur le votre... Ne pourriez vous me donner un petit coup de pousse

Je suis repartie sur la base de votre code mais à chaque fois que je tente de remplacer le GtkWidget en GtkButton apres j'ai un problème de pointer me disant que c'est plus compatible

Merci d'avance à tous...

Mickael

**liberforce** · 02/02/2011, 14h37

Ce tutoriel devrait faire l'affaire, même s'il date de 2005:
http://gnomejournal.org/article/34/w...airo-and-gtk28

Je pense qu'il te suffit de dériver de GtkButton plutôt que GtkDrawingArea...

**liberforce** · 02/02/2011, 14h55

Envoyé par Franck.H

enfin deux à vrai dire, la seconde c'est avec le langage Vala

Tu as une syntaxe par langage, m'enfin la méthode est la même...

**gege2061** · 03/02/2011, 10h18

Bonjour,

Envoyé par Apocalypses

Malheureusement GtkEventBox ne possède aucun signal

Impossible d'y relier les signaux de bouton ...

Si, il hérite de tous les signaux de ses parents, en particulier ceux de GtkWidget. Mais il me semble que tu te complique, un GtkButton doit proposer tout ce dont tu as besoin.

Envoyé par liberforce

Tu as une syntaxe par langage, m'enfin la méthode est la même...

Sauf que tu peux demander au compilateur de garder les fichiers C générer pour les analyser

**Loenix** · 03/02/2011, 11h54

Bonjour,

il hérite de tous les signaux de ses parents, en particulier ceux de GtkWidget.

Je m'etais compris, le widget en lui même n'a pas de signaux en plus par rapport au GtkWidget qui ne répond pas non plus à mes attentes...

Pourquoi je veux hériter des signaux du GtkButton ?

Je souhaiterai créer une nouvelle forme de bouton, jusque la nous avons des boutons qui lorsque l'on passe dessus un thème peu commode et dans de nombreux projets, j'utilisais les boutons pour mettre des images.

Je souhaiterai donc créer un "IButton", c'est comme un bouton sauf que c'est une image qui lorsque l'on passe sur le bouton et l'on clic dessus, l'image se change en fonction de ce que l'utilisateur a choisis sans pour autant avoir le vieux rectangle des boutons (une simple image qui se change), cela permettrait facilement de créer de joli boutons avec 3 images

btn = gtk_ibutton_new("normal.png","actif.png","clic.png");

Le principe est vraiment bete, il faut juste relier le widget (image) au signal : enter, leave, pressed... et modifier l'image affiché.

Si vous avez une autre solution pour réaliser cela, n'hésitez pas...

Merci à tous en tout cas...

Mickael

Ps :

Ce tutoriel devrait faire l'affaire, même s'il date de 2005:
http://gnomejournal.org/article/34/w...airo-and-gtk28

Je n'ai pas réussis à obtenir ce que je voulai

mal expliqué et ne marche pas super bien...

**gege2061** · 03/02/2011, 17h14

Envoyé par Apocalypses

Je m'etais compris, le widget en lui même n'a pas de signaux en plus par rapport au GtkWidget qui ne répond pas non plus à mes attentes...

enter-notify-event, leave-notify-event ce n'est pas ce que tu cherche ?

Envoyé par Apocalypses

Pourquoi je veux hériter des signaux du GtkButton ?

Je souhaiterai créer une nouvelle forme de bouton, jusque la nous avons des boutons qui lorsque l'on passe dessus un thème peu commode et dans de nombreux projets, j'utilisais les boutons pour mettre des images.

Je souhaiterai donc créer un "IButton", c'est comme un bouton sauf que c'est une image qui lorsque l'on passe sur le bouton et l'on clic dessus, l'image se change en fonction de ce que l'utilisateur a choisis sans pour autant avoir le vieux rectangle des boutons (une simple image qui se change), cela permettrait facilement de créer de joli boutons avec 3 images

btn = gtk_ibutton_new("normal.png","actif.png","clic.png");

Le principe est vraiment bete, il faut juste relier le widget (image) au signal : enter, leave, pressed... et modifier l'image affiché.

Si vous avez une autre solution pour réaliser cela, n'hésitez pas...

Merci à tous en tout cas...

Voilà ce que ça donne en vala :

Code vala :

Sélectionner tout - Visualiser dans une fenêtre à part

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
class iButton : Gtk.Button
{
  private new Gtk.Image image;
 
  public string normal {get; construct;}
  public string actif {get; construct;}
  public string clic {get; construct;}
 
  public iButton (string normal, string actif, string clic)
  {
    Object (normal: normal, actif: actif, clic: clic);
  }
 
  construct
  {
    this.set_relief (Gtk.ReliefStyle.NONE);
 
    this.image = new Gtk.Image.from_stock (this.normal, Gtk.IconSize.BUTTON);
    this.add (this.image);
 
    this.enter_notify_event.connect (() => {
      this.image.set_from_stock (this.actif, Gtk.IconSize.BUTTON);
    });
    this.leave_notify_event.connect (() => {
      this.image.set_from_stock (this.normal, Gtk.IconSize.BUTTON);
    });
 
    this.button_press_event.connect (() => {
      this.image.set_from_stock (this.clic, Gtk.IconSize.BUTTON);
    });
    this.button_release_event.connect (() => {
      this.image.set_from_stock (this.normal, Gtk.IconSize.BUTTON);
    });
  }
}
 
class Window : Gtk.Window
{
  construct
  {
    this.destroy.connect (Gtk.main_quit);
    this.add (new iButton (Gtk.STOCK_FILE, Gtk.STOCK_NEW, Gtk.STOCK_QUIT));
  }
}
 
void main (string[] args)
{
  Gtk.init (ref args);
  new Window ().show_all ();
  Gtk.main ();
}

**Loenix** · 03/02/2011, 18h12

Bonjour,

enter-notify-event, leave-notify-event

Je vous avoue que je n'avais pas testé ceux la... Mais après reflexion il me faudra quand même toutes les fonctions d'un bouton puisque je voudrai le renommer IButton ^^ (il faut qu'il capte le clic de souris)...

Pour ce qui est de votre code... Je dois avoir la pouasse, des erreurs partout, c'est bien du C ? (j'ai surement l'air bete mais je ne connais pas le C++). Quoi qu'il en soit à chaque ligne une erreur :

"syntax error before "iButton""

Merci je vais quand même regardé cela de plus pret

Mickael

**liberforce** · 04/02/2011, 00h22

Son exemple de code est en Vala.

**Loenix** · 04/02/2011, 19h17

Bonsoir,

En effet je n'avais pas remarqué l'annotation "Code : Vala"... Mais du coup je ne sais pas trop quoi en faire, il me le faudrait en C pour pouvoir vraiment l'utiliser...

Merci à tous pour votre soutient

Mickael

**gege2061** · 07/02/2011, 09h50

Envoyé par Apocalypses

En effet je n'avais pas remarqué l'annotation "Code : Vala"... Mais du coup je ne sais pas trop quoi en faire, il me le faudrait en C pour pouvoir vraiment l'utiliser...

Comme je l'ai dit, tu peux demander au compilateur de te donner du code C, voilà le résultat :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
/* main.c generated by valac, the Vala compiler
 * generated from main.vala, do not modify */
 
 
#include <glib.h>
#include <glib-object.h>
#include <gtk/gtk.h>
#include <stdlib.h>
#include <string.h>
#include <gdk/gdk.h>
 
 
#define TYPE_IBUTTON (ibutton_get_type ())
#define IBUTTON(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_IBUTTON, iButton))
#define IBUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_IBUTTON, iButtonClass))
#define IS_IBUTTON(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_IBUTTON))
#define IS_IBUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_IBUTTON))
#define IBUTTON_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_IBUTTON, iButtonClass))
 
typedef struct _iButton iButton;
typedef struct _iButtonClass iButtonClass;
typedef struct _iButtonPrivate iButtonPrivate;
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
#define _g_free0(var) (var = (g_free (var), NULL))
 
#define TYPE_WINDOW (window_get_type ())
#define WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_WINDOW, Window))
#define WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_WINDOW, WindowClass))
#define IS_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_WINDOW))
#define IS_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_WINDOW))
#define WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_WINDOW, WindowClass))
 
typedef struct _Window Window;
typedef struct _WindowClass WindowClass;
typedef struct _WindowPrivate WindowPrivate;
 
struct _iButton {
	GtkButton parent_instance;
	iButtonPrivate * priv;
};
 
struct _iButtonClass {
	GtkButtonClass parent_class;
};
 
struct _iButtonPrivate {
	GtkImage* image;
	char* _normal;
	char* _actif;
	char* _clic;
};
 
struct _Window {
	GtkWindow parent_instance;
	WindowPrivate * priv;
};
 
struct _WindowClass {
	GtkWindowClass parent_class;
};
 
 
static gpointer ibutton_parent_class = NULL;
static gpointer window_parent_class = NULL;
 
GType ibutton_get_type (void);
#define IBUTTON_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_IBUTTON, iButtonPrivate))
enum  {
	IBUTTON_DUMMY_PROPERTY,
	IBUTTON_NORMAL,
	IBUTTON_ACTIF,
	IBUTTON_CLIC
};
iButton* ibutton_new (const char* normal, const char* actif, const char* clic);
iButton* ibutton_construct (GType object_type, const char* normal, const char* actif, const char* clic);
const char* ibutton_get_normal (iButton* self);
static void ibutton_set_normal (iButton* self, const char* value);
const char* ibutton_get_actif (iButton* self);
static void ibutton_set_actif (iButton* self, const char* value);
const char* ibutton_get_clic (iButton* self);
static void ibutton_set_clic (iButton* self, const char* value);
static gboolean _lambda0_ (iButton* self);
static gboolean __lambda0__gtk_widget_enter_notify_event (GtkWidget* _sender, GdkEventCrossing* event, gpointer self);
static gboolean _lambda1_ (iButton* self);
static gboolean __lambda1__gtk_widget_leave_notify_event (GtkWidget* _sender, GdkEventCrossing* event, gpointer self);
static gboolean _lambda2_ (iButton* self);
static gboolean __lambda2__gtk_widget_button_press_event (GtkWidget* _sender, GdkEventButton* event, gpointer self);
static gboolean _lambda3_ (iButton* self);
static gboolean __lambda3__gtk_widget_button_release_event (GtkWidget* _sender, GdkEventButton* event, gpointer self);
static GObject * ibutton_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties);
static void ibutton_finalize (GObject* obj);
static void ibutton_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
static void ibutton_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
GType window_get_type (void);
enum  {
	WINDOW_DUMMY_PROPERTY
};
Window* window_new (void);
Window* window_construct (GType object_type);
static void _gtk_main_quit_gtk_object_destroy (GtkObject* _sender, gpointer self);
static GObject * window_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties);
void _vala_main (char** args, int args_length1);
 
 
 
iButton* ibutton_construct (GType object_type, const char* normal, const char* actif, const char* clic) {
	iButton * self;
	g_return_val_if_fail (normal != NULL, NULL);
	g_return_val_if_fail (actif != NULL, NULL);
	g_return_val_if_fail (clic != NULL, NULL);
	self = (iButton*) g_object_new (object_type, "normal", normal, "actif", actif, "clic", clic, NULL);
	return self;
}
 
 
iButton* ibutton_new (const char* normal, const char* actif, const char* clic) {
	return ibutton_construct (TYPE_IBUTTON, normal, actif, clic);
}
 
 
const char* ibutton_get_normal (iButton* self) {
	const char* result;
	g_return_val_if_fail (self != NULL, NULL);
	result = self->priv->_normal;
	return result;
}
 
 
static void ibutton_set_normal (iButton* self, const char* value) {
	char* _tmp0_;
	g_return_if_fail (self != NULL);
	self->priv->_normal = (_tmp0_ = g_strdup (value), _g_free0 (self->priv->_normal), _tmp0_);
	g_object_notify ((GObject *) self, "normal");
}
 
 
const char* ibutton_get_actif (iButton* self) {
	const char* result;
	g_return_val_if_fail (self != NULL, NULL);
	result = self->priv->_actif;
	return result;
}
 
 
static void ibutton_set_actif (iButton* self, const char* value) {
	char* _tmp0_;
	g_return_if_fail (self != NULL);
	self->priv->_actif = (_tmp0_ = g_strdup (value), _g_free0 (self->priv->_actif), _tmp0_);
	g_object_notify ((GObject *) self, "actif");
}
 
 
const char* ibutton_get_clic (iButton* self) {
	const char* result;
	g_return_val_if_fail (self != NULL, NULL);
	result = self->priv->_clic;
	return result;
}
 
 
static void ibutton_set_clic (iButton* self, const char* value) {
	char* _tmp0_;
	g_return_if_fail (self != NULL);
	self->priv->_clic = (_tmp0_ = g_strdup (value), _g_free0 (self->priv->_clic), _tmp0_);
	g_object_notify ((GObject *) self, "clic");
}
 
 
static gboolean _lambda0_ (iButton* self) {
	gboolean result = FALSE;
	gtk_image_set_from_stock (self->priv->image, self->priv->_actif, GTK_ICON_SIZE_BUTTON);
}
 
 
static gboolean __lambda0__gtk_widget_enter_notify_event (GtkWidget* _sender, GdkEventCrossing* event, gpointer self) {
	return _lambda0_ (self);
}
 
 
static gboolean _lambda1_ (iButton* self) {
	gboolean result = FALSE;
	gtk_image_set_from_stock (self->priv->image, self->priv->_normal, GTK_ICON_SIZE_BUTTON);
}
 
 
static gboolean __lambda1__gtk_widget_leave_notify_event (GtkWidget* _sender, GdkEventCrossing* event, gpointer self) {
	return _lambda1_ (self);
}
 
 
static gboolean _lambda2_ (iButton* self) {
	gboolean result = FALSE;
	gtk_image_set_from_stock (self->priv->image, self->priv->_clic, GTK_ICON_SIZE_BUTTON);
}
 
 
static gboolean __lambda2__gtk_widget_button_press_event (GtkWidget* _sender, GdkEventButton* event, gpointer self) {
	return _lambda2_ (self);
}
 
 
static gboolean _lambda3_ (iButton* self) {
	gboolean result = FALSE;
	gtk_image_set_from_stock (self->priv->image, self->priv->_normal, GTK_ICON_SIZE_BUTTON);
}
 
 
static gboolean __lambda3__gtk_widget_button_release_event (GtkWidget* _sender, GdkEventButton* event, gpointer self) {
	return _lambda3_ (self);
}
 
 
static GObject * ibutton_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
	GObject * obj;
	GObjectClass * parent_class;
	iButton * self;
	parent_class = G_OBJECT_CLASS (ibutton_parent_class);
	obj = parent_class->constructor (type, n_construct_properties, construct_properties);
	self = IBUTTON (obj);
	{
		GtkImage* _tmp0_;
		gtk_button_set_relief ((GtkButton*) self, GTK_RELIEF_NONE);
		self->priv->image = (_tmp0_ = g_object_ref_sink ((GtkImage*) gtk_image_new_from_stock (self->priv->_normal, GTK_ICON_SIZE_BUTTON)), _g_object_unref0 (self->priv->image), _tmp0_);
		gtk_container_add ((GtkContainer*) self, (GtkWidget*) self->priv->image);
		g_signal_connect_object ((GtkWidget*) self, "enter-notify-event", (GCallback) __lambda0__gtk_widget_enter_notify_event, self, 0);
		g_signal_connect_object ((GtkWidget*) self, "leave-notify-event", (GCallback) __lambda1__gtk_widget_leave_notify_event, self, 0);
		g_signal_connect_object ((GtkWidget*) self, "button-press-event", (GCallback) __lambda2__gtk_widget_button_press_event, self, 0);
		g_signal_connect_object ((GtkWidget*) self, "button-release-event", (GCallback) __lambda3__gtk_widget_button_release_event, self, 0);
	}
	return obj;
}
 
 
static void ibutton_class_init (iButtonClass * klass) {
	ibutton_parent_class = g_type_class_peek_parent (klass);
	g_type_class_add_private (klass, sizeof (iButtonPrivate));
	G_OBJECT_CLASS (klass)->get_property = ibutton_get_property;
	G_OBJECT_CLASS (klass)->set_property = ibutton_set_property;
	G_OBJECT_CLASS (klass)->constructor = ibutton_constructor;
	G_OBJECT_CLASS (klass)->finalize = ibutton_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), IBUTTON_NORMAL, g_param_spec_string ("normal", "normal", "normal", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
	g_object_class_install_property (G_OBJECT_CLASS (klass), IBUTTON_ACTIF, g_param_spec_string ("actif", "actif", "actif", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
	g_object_class_install_property (G_OBJECT_CLASS (klass), IBUTTON_CLIC, g_param_spec_string ("clic", "clic", "clic", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
}
 
 
static void ibutton_instance_init (iButton * self) {
	self->priv = IBUTTON_GET_PRIVATE (self);
}
 
 
static void ibutton_finalize (GObject* obj) {
	iButton * self;
	self = IBUTTON (obj);
	_g_object_unref0 (self->priv->image);
	_g_free0 (self->priv->_normal);
	_g_free0 (self->priv->_actif);
	_g_free0 (self->priv->_clic);
	G_OBJECT_CLASS (ibutton_parent_class)->finalize (obj);
}
 
 
GType ibutton_get_type (void) {
	static volatile gsize ibutton_type_id__volatile = 0;
	if (g_once_init_enter (&ibutton_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (iButtonClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ibutton_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (iButton), 0, (GInstanceInitFunc) ibutton_instance_init, NULL };
		GType ibutton_type_id;
		ibutton_type_id = g_type_register_static (GTK_TYPE_BUTTON, "iButton", &g_define_type_info, 0);
		g_once_init_leave (&ibutton_type_id__volatile, ibutton_type_id);
	}
	return ibutton_type_id__volatile;
}
 
 
static void ibutton_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
	iButton * self;
	self = IBUTTON (object);
	switch (property_id) {
		case IBUTTON_NORMAL:
		g_value_set_string (value, ibutton_get_normal (self));
		break;
		case IBUTTON_ACTIF:
		g_value_set_string (value, ibutton_get_actif (self));
		break;
		case IBUTTON_CLIC:
		g_value_set_string (value, ibutton_get_clic (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}
 
 
static void ibutton_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
	iButton * self;
	self = IBUTTON (object);
	switch (property_id) {
		case IBUTTON_NORMAL:
		ibutton_set_normal (self, g_value_get_string (value));
		break;
		case IBUTTON_ACTIF:
		ibutton_set_actif (self, g_value_get_string (value));
		break;
		case IBUTTON_CLIC:
		ibutton_set_clic (self, g_value_get_string (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}
 
 
Window* window_construct (GType object_type) {
	Window * self;
	self = g_object_newv (object_type, 0, NULL);
	return self;
}
 
 
Window* window_new (void) {
	return window_construct (TYPE_WINDOW);
}
 
 
static void _gtk_main_quit_gtk_object_destroy (GtkObject* _sender, gpointer self) {
	gtk_main_quit ();
}
 
 
static GObject * window_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
	GObject * obj;
	GObjectClass * parent_class;
	Window * self;
	parent_class = G_OBJECT_CLASS (window_parent_class);
	obj = parent_class->constructor (type, n_construct_properties, construct_properties);
	self = WINDOW (obj);
	{
		iButton* _tmp1_;
		g_signal_connect ((GtkObject*) self, "destroy", (GCallback) _gtk_main_quit_gtk_object_destroy, NULL);
		gtk_container_add ((GtkContainer*) self, (GtkWidget*) (_tmp1_ = g_object_ref_sink (ibutton_new (GTK_STOCK_FILE, GTK_STOCK_NEW, GTK_STOCK_QUIT))));
		_g_object_unref0 (_tmp1_);
	}
	return obj;
}
 
 
static void window_class_init (WindowClass * klass) {
	window_parent_class = g_type_class_peek_parent (klass);
	G_OBJECT_CLASS (klass)->constructor = window_constructor;
}
 
 
static void window_instance_init (Window * self) {
}
 
 
GType window_get_type (void) {
	static volatile gsize window_type_id__volatile = 0;
	if (g_once_init_enter (&window_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (WindowClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) window_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Window), 0, (GInstanceInitFunc) window_instance_init, NULL };
		GType window_type_id;
		window_type_id = g_type_register_static (GTK_TYPE_WINDOW, "Window", &g_define_type_info, 0);
		g_once_init_leave (&window_type_id__volatile, window_type_id);
	}
	return window_type_id__volatile;
}
 
 
void _vala_main (char** args, int args_length1) {
	Window* _tmp0_;
	gtk_init (&args_length1, &args);
	gtk_widget_show_all ((GtkWidget*) (_tmp0_ = g_object_ref_sink (window_new ())));
	_g_object_unref0 (_tmp0_);
	gtk_main ();
}
 
 
int main (int argc, char ** argv) {
	g_type_init ();
	_vala_main (argv, argc);
	return 0;
}

La première version me semblais plus claire pour t'expliquer comment faire à partir d'un GtkButton.

**Loenix** · 07/02/2011, 14h02

Bonjour,

Je vous remercie, je vais regarder sa dès que possible, je vous tiendrai au courant

Mickael

Création de widgets

GTK+ avec C & C++

Discussions similaires

Partager

Partager