GtkLed en GTK+ pb sur widget

bonjour à tous les gtk-iste

Je m'investis sur Gtk+ en version 3 actuellement avec ubuntu 14 trusty j'ai la 3.10.8.

je suis en train de convertir un widget personnalisé dans le but de comprendre les mécanismes de customization en GTK3 gtkled
http://franckh.developpez.com/tutori...widget/http://

il était écrit en gtk 2

voici l'avancement de mes travaux
le fichier main ne m'a pas posé de problème de conversion particulier ....

Code:

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
#include <stdio.h>
#include <stdlib.h>
#include <gtk/gtk.h>
 
#include "gtkled.h"
 
 
static void cb_switch (GtkWidget * widget, gpointer data)
{
   GtkWidget * led = (GtkWidget *) data;
   gtk_led_set_state (GTK_LED (led), ! gtk_led_get_state (GTK_LED (led)));
   (void)widget;
}
 
 
int main (int argc, char ** argv)
{
   GtkWidget * window;
   GtkWidget * btn;
   GtkWidget * led;
 
 
   gtk_init (& argc, & argv);
 
 
   /*
    * Creation de la fenetre principale et ajout d'un container.
    */
   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title (GTK_WINDOW (window), "Test de GtkLed");
   gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
   gtk_window_set_default_size (GTK_WINDOW (window), 250, 50);
 
   g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit),NULL);
   GtkWidget *hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
   gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
   gtk_container_add (GTK_CONTAINER (window), hbox);
 
 
   /*
    * Creation d'un bouton et d'un GtkLed.
    */
   btn = gtk_button_new_with_label ("Switch led state");
   gtk_box_pack_start (GTK_BOX (hbox), btn, TRUE, TRUE, 0);
 
   led = gtk_led_new ("led_on.png", "led_off.png", TRUE);
 
   if (led == NULL) 
   {
      printf ("Impossible de créer le widget GtkLed !\n");
   } 
   else 
   {
      gtk_box_pack_start (GTK_BOX (hbox), led, TRUE, TRUE, 0);
      g_signal_connect (btn, "clicked", G_CALLBACK (cb_switch), (gpointer) led);
   }
   gtk_widget_show_all (window);
   gtk_main ();
 
 
   return EXIT_SUCCESS;
}

le fichier gtkled.h par contre a nécessité de convertir avec les nouveaux symboles

Code:

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
/* gtkled.h */
 
#ifndef __GTK_LED_H
#define __GTK_LED_H
 
#include <gtk/gtk.h>
#include <glib.h>
#include <gtk/gtkwidget.h>
 
 
G_BEGIN_DECLS
 
 
#define GTK_LED(obj) G_TYPE_CHECK_INSTANCE_CAST(obj, gtk_led_get_type (), GtkLed)
#define GTK_LED_CLASS(klass) G_TYPE_CHECK_CLASS_CAST(klass, gtk_led_get_type (), GtkLedClass)
#define GTK_IS_LED(obj) G_TYPE_CHECK(obj, gtk_led_get_type ())
 
 
 
typedef struct _GtkLed GtkLed;
typedef struct _GtkLedClass GtkLedClass;
 
 
struct _GtkLed {
   GtkWidget widget;
 
   const gchar * on_image;
   const gchar * off_image;
 
   GdkPixbuf * on_pixbuf;
   GdkPixbuf * off_pixbuf;
 
   gint width;
   gint height;
 
   gboolean state;
};
 
struct _GtkLedClass {
   GtkWidgetClass parent_class;
};
 
 
GType gtk_led_get_type (void);
gboolean gtk_led_get_state (GtkLed * led);
void gtk_led_set_state (GtkLed * led, gboolean state);
GtkWidget * gtk_led_new (const gchar * on_image,
                         const gchar * off_image,
                         gboolean state);
 
 
G_END_DECLS
 
#endif /* __GTK_LED_H */

une fois qu'on a découvert que les macros GTK_CHECK_CAST deviennent G_TYPE_CHECK_INSTANCE_CAST cela devient un peu plus clair
enfin j'arrive au dernier morceau le plus compliqué à traiter
gtkled.c

Code:

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
/* gtkled.c */
#include <glib.h>
#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 (GObject * object);
 
 
GType gtk_led_get_type (void)
{
	static GType gtk_led_type = 0;
 
 
	if (! gtk_led_type) 
	{
		// struct GTypeInfo
		//struct GTypeInfo {
		/* interface types, classed types, instantiated types */
		/**guint16                class_size;
  
                GBaseInitFunc          base_init;
                GBaseFinalizeFunc      base_finalize;**/
 
		/* interface types, classed types, instantiated types */
		/**GClassInitFunc         class_init;
                GClassFinalizeFunc     class_finalize;
                gconstpointer          class_data;**/
 
		/* instantiated types */
		/**guint16                instance_size;
                guint16                n_preallocs;
                GInstanceInitFunc      instance_init;**/
 
		/* value handling */
		/**const GTypeValueTable *value_table;
                };**/
		static const GTypeInfo gtk_led_info = 
		{
			sizeof (GtkLedClass),
			NULL,
			NULL,
			(GClassInitFunc) gtk_led_class_init,
			NULL,
			NULL,
			sizeof (GtkLed),
			0,
			(GInstanceInitFunc) gtk_led_init,
			NULL
		};
		gtk_led_type = g_type_register_static (GTK_TYPE_WIDGET,"GtkLed", &gtk_led_info,0);
   }
 
 
   return gtk_led_type;
}
 
gboolean gtk_led_get_state (GtkLed * led)
{
   return led->state;
}
 
 
void gtk_led_set_state (GtkLed * led, gboolean state)
{
   led->state = state;
   gtk_led_paint (GTK_WIDGET (led));
}
 
/** old forme a garder pour les histoire de pouvoir initialiser direct avec les fichiere
GtkWidget *gtk_led_new (const gchar * on_image, const gchar * off_image,  gboolean state)
{
        GtkLed * led = NULL;
 
        if (on_image != NULL && off_image != NULL) 
        {
                led = g_type_new (gtk_led_get_type ());
 
                if (led != NULL) 
                {
                        led->on_image = on_image;
                        led->off_image = off_image;
                        led->state = state;
 
                        gtk_led_load_image (led);
                }
        }
        return GTK_WIDGET (led);
}**/
GtkWidget *gtk_led_new (const gchar * on_image, const gchar * off_image,  gboolean state)
{
	// attention je ne traite pas les variables ici donc pas marcher !!!!!!!!!
	return GTK_WIDGET (g_object_new(gtk_led_get_type(), NULL));
	(void)on_image;
	(void)off_image; /** c'est du provisoire **/
	(void)state;
}
 
static void gtk_led_class_init (GtkLedClass * klass)
{
   GtkWidgetClass * widget_class;
   GObjectClass * object_class;
 
 
   widget_class = (GtkWidgetClass *) klass;
   object_class = (GObjectClass *) klass;
 
   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->on_pixbuf = NULL;
   led->off_pixbuf = NULL;
   led->width = 0;
   led->height = 0;
   led->state = FALSE;
}
 
 
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->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_get_realized (widget)) 
	{
		gdk_window_move_resize (
         widget->window,
         allocation->x, allocation->y,
         allocation->width, allocation->height);
	}*/
	gtk_widget_get_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));
 
   /** old GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED); */
   gtk_widget_set_realized (widget, TRUE);
 
   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);
   GtkStyleContext (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)
		pixbuf = GTK_LED (widget)->on_pixbuf;
	else
		pixbuf = GTK_LED (widget)->off_pixbuf;
 
	/** if If your Gtk version is < 2.22 **/
	/*gdk_draw_pixbuf (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);*/
	/** Version GTk 3 onwards you will have to make use of cairo something on next **/
	cairo_t *cairo;
    cairo = gdk_cairo_create (gtk_widget_get_window(widget));
    //    cairo = gdk_cairo_create (da->window);
    gdk_cairo_set_source_pixbuf(cairo, pixbuf,center_x, center_y);
    cairo_paint(cairo);
    //    cairo_fill (cairo);
    cairo_destroy (cairo);
    //    return FALSE;
}
 
 
static void gtk_led_destroy (GObject * 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) 
	{
		g_object_unref (led->on_pixbuf);
		g_object_unref (led->off_pixbuf);
 
		led->on_pixbuf = NULL;
	led->off_pixbuf = NULL;
	}
 
 
	klass = g_type_class (gtk_widget_get_type ());
 
	if (GTK_OBJECT_CLASS (klass)->destroy) 
	{
      (* GTK_OBJECT_CLASS (klass)->destroy) (object);
	}
}

puis le makefile converti en gtk3

Code:

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
#
# Variables:
#
CC = gcc
BIN = gtk_led
SRC = main.c gtkled.c
OBJ = main.o gtkled.o
 
 
#
# Flags du preprocesseur:
#
CPPFLAGS =-Wall -W  `pkg-config --cflags gtk+-3.0`
 
#
# Flags pour l'editeur de liens:
#
LDFLAGS = `pkg-config --libs gtk+-3.0`
 
#
# Construction du programme:
#
all: $(BIN)
 
$(BIN): $(SRC)
	$(CC) $(CPPFLAGS) -c $(SRC)
	$(CC) $(LDFLAGS) -o $(BIN) $(OBJ)
 
 
#
# Nettoyage:
#
clean:
	rm -f *.o *~ core $(BIN)

il me reste une série d'erreur de compilation que je ne peut expliquer et donc pas résoudre
les voici

Code:

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
gtkled.c: In function ‘gtk_led_class_init’:
gtkled.c:116:16: error: ‘GtkWidgetClass’ has no member named ‘size_request’
    widget_class->size_request = gtk_led_size_request;
                ^
gtkled.c:118:16: error: ‘GtkWidgetClass’ has no member named ‘expose_event’
    widget_class->expose_event = gtk_led_expose;
                ^
gtkled.c:120:16: error: ‘GObjectClass’ has no member named ‘destroy’
    object_class->destroy = gtk_led_destroy;
                ^
gtkled.c: In function ‘gtk_led_size_request’:
gtkled.c:148:4: warning: implicit declaration of function ‘G_TYPE_CHECK’ [-Wimplicit-function-declaration]
    g_return_if_fail (GTK_IS_LED (widget));
    ^
gtkled.c: In function ‘gtk_led_size_allocate’:
gtkled.c:162:8: error: ‘GtkWidget’ has no member named ‘allocation’
  widget->allocation = *allocation;
        ^
gtkled.c:173:16: error: ‘GtkWidget’ has no member named ‘window’
          widget->window,
                ^
gtkled.c: In function ‘gtk_led_realize’:
gtkled.c:191:25: error: ‘GtkWidget’ has no member named ‘allocation’
    attributes.x = widget->allocation.x;
                         ^
gtkled.c:192:25: error: ‘GtkWidget’ has no member named ‘allocation’
    attributes.y = widget->allocation.y;
                         ^
gtkled.c:193:29: error: ‘GtkWidget’ has no member named ‘allocation’
    attributes.width = widget->allocation.width;
                             ^
gtkled.c:194:30: error: ‘GtkWidget’ has no member named ‘allocation’
    attributes.height = widget->allocation.height;
                              ^
gtkled.c:200:10: error: ‘GtkWidget’ has no member named ‘window’
    widget->window = gdk_window_new (
          ^
gtkled.c:205:36: error: ‘GtkWidget’ has no member named ‘window’
    gdk_window_set_user_data (widget->window, widget);
                                    ^
gtkled.c:207:10: error: ‘GtkWidget’ has no member named ‘style’
    widget->style = gtk_style_attach (widget->style, widget->window);
          ^
gtkled.c:207:4: warning: ‘gtk_style_attach’ is deprecated (declared at /usr/include/gtk-3.0/gtk/deprecated/gtkstyle.h:376): Use 'GtkStyleContext' instead [-Wdeprecated-declarations]
    widget->style = gtk_style_attach (widget->style, widget->window);
    ^
gtkled.c:207:44: error: ‘GtkWidget’ has no member named ‘style’
    widget->style = gtk_style_attach (widget->style, widget->window);
                                            ^
gtkled.c:207:59: error: ‘GtkWidget’ has no member named ‘window’
    widget->style = gtk_style_attach (widget->style, widget->window);
                                                           ^
gtkled.c:208:27: error: expected ‘)’ before ‘->’ token
    GtkStyleContext (widget->style, widget->window, GTK_STATE_NORMAL);
                           ^
gtkled.c: In function ‘gtk_led_paint’:
gtkled.c:233:2: warning: implicit declaration of function ‘gdk_window_clear_area’ [-Wimplicit-function-declaration]
  gdk_window_clear_area ( widget->window, 0, 0, widget->allocation.width,widget->allocation.height );
  ^
gtkled.c:233:32: error: ‘GtkWidget’ has no member named ‘window’
  gdk_window_clear_area ( widget->window, 0, 0, widget->allocation.width,widget->allocation.height );
                                ^
gtkled.c:233:54: error: ‘GtkWidget’ has no member named ‘allocation’
  gdk_window_clear_area ( widget->window, 0, 0, widget->allocation.width,widget->allocation.height );
                                                      ^
gtkled.c:233:79: error: ‘GtkWidget’ has no member named ‘allocation’
  gdk_window_clear_area ( widget->window, 0, 0, widget->allocation.width,widget->allocation.height );
                                                                               ^
gtkled.c:235:20: error: ‘GtkWidget’ has no member named ‘allocation’
  center_x = (widget->allocation.width / 2) - (GTK_LED (widget)->width / 2);
                    ^
gtkled.c:236:20: error: ‘GtkWidget’ has no member named ‘allocation’
  center_y = (widget->allocation.height / 2) - (GTK_LED (widget)->height / 2);
                    ^
gtkled.c: In function ‘gtk_led_destroy’:
gtkled.c:280:2: warning: implicit declaration of function ‘g_type_class’ [-Wimplicit-function-declaration]
  klass = g_type_class (gtk_widget_get_type ());
  ^
gtkled.c:280:8: warning: assignment makes pointer from integer without a cast [enabled by default]
  klass = g_type_class (gtk_widget_get_type ());
        ^
gtkled.c:282:2: warning: implicit declaration of function ‘GTK_OBJECT_CLASS’ [-Wimplicit-function-declaration]
  if (GTK_OBJECT_CLASS (klass)->destroy) 
  ^
gtkled.c:282:30: error: invalid type argument of ‘->’ (have ‘int’)
  if (GTK_OBJECT_CLASS (klass)->destroy) 
                              ^
gtkled.c:284:34: error: invalid type argument of ‘->’ (have ‘int’)
       (* GTK_OBJECT_CLASS (klass)->destroy) (object);
                                  ^
gtkled.c: At top level:
gtkled.c:136:13: warning: ‘gtk_led_load_image’ defined but not used [-Wunused-function]
 static void gtk_led_load_image (GtkLed * led)

parmi ce beau lot de point à traiter ce qui me gêne le plus c'est la série de
error: ‘GtkWidget’ has no member named ‘allocation’
error: ‘GtkWidget’ has no member named ‘window’
error: ‘GtkWidgetClass’ has no member named ‘expose_event’

error: ‘GtkWidget’ has no member named ‘machin'

tout porte à croire que les liens ne fonctionnent pas comme prévu sur le site http://franckh.developpez.com/tutori...eation-widget/ il y a en gtk2
L'intégration d'un GtkWidget, au début de la structure _GtkLed, permet clairement d'identifier le widget comme parent type de GtkWidget. A ce propos, il est une chose essentielle à noter.

En effet, chaque structure de widget doit commencer par le type du parent qui contiendra la même adresse que notre GtkLed. Cette pratique permet simplement de faire pointer chaque objet parent dans la hiérarchie sur la même adresse donc, un pointeur GtkLed pourra être considéré comme un GtkWidget, .......

pourtant les liens semblent être établi avec ce qui suit en gras dans les structures gtkled.h

struct _GtkLed {
GtkWidget widget;

const gchar * on_image;
const gchar * off_image;

GdkPixbuf * on_pixbuf;
GdkPixbuf * off_pixbuf;

gint width;
gint height;

gboolean state;
};

struct _GtkLedClass {
GtkWidgetClass parent_class;
};

je suis allé fouillé dans les entrailles de gtk dans gtkwidget.c et j'y ai trouvé des éléments très interesant
vu la taille du monstre le site n'en veut pas car il est trop gros mais allez y c'est ENORME on y retrouve des éléments connus
cela voudrait le coup en faire un tuto d'autopsie

dois-je utiliser directement gtk_widget_set_usize_internal en
refabriquant localement du code dans mon widget customisé

du genre
dans la class init de gtkled
je remplace
widget_class->size_request = gtk_led_size_request;
par
widget_class->machin = gtk_led_size_request;

et dans la fonction gtk_led_size_request je replace un code pour reconstituer un équivalent de gtk_widget_set_size_request

une autre piste serait de passer par
gtk_widget_set_property avec PROP_WIDTH_REQUEST et PROP_HEIGHT_REQUEST qui utilise gtk_widget_set_usize_internal
case PROP_WIDTH_REQUEST:
gtk_widget_set_usize_internal (widget, g_value_get_int (value), -2);
break;
case PROP_HEIGHT_REQUEST:
gtk_widget_set_usize_internal (widget, -2, g_value_get_int (value));
break;

avez-vous une idée de la solution la plus simple ?