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
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
| #include "gtkled.h"
/* gtkled.c */
/* Private data structure */
struct _GtkLedPrivate
{
const gchar * on_image;
const gchar * off_image;
GdkPixbuf * on_pixbuf;
GdkPixbuf * off_pixbuf;
gint width;
gint height;
gboolean state;
GdkWindow *window;
};
enum {
PROP_0,
PROP_IMAGE_ON,
PROP_IMAGE_OFF,
PROP_STATE
};
/* Internal API */
static void gtk_led_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
static void gtk_led_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
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_get_preferred_height (GtkWidget *widget, gint *minimal_height, gint *natural_height);
static void gtk_led_get_preferred_width (GtkWidget *widget, gint *minimal_width, gint *natural_width);
static void gtk_led_size_allocate (GtkWidget * widget, GtkAllocation * allocation);
static void gtk_led_realize (GtkWidget * widget);
static void gtk_led_paint (GtkWidget * widget);
static void gtk_led_finalize (GObject * object);
/* Define variable GTK_TYPE_LED in order to represent GType fonction */
#define GTK_TYPE_LED gtk_led_get_type()
/* Define type */
G_DEFINE_TYPE(GtkLed, gtk_led, GTK_TYPE_WIDGET)
/** signification des paramètres pour G_DEFINE_TYPE(GtkLed, gtk_led, GTK_TYPE_WIDGET)
* le même préfixe GtkLed que pour la classe GtkLedClass
* implementation de la fonction gtk_led_get_type avec un protocole standard
* define a parent class pointer accessible from the whole .c file
**/
/* Initialization */
static void gtk_led_class_init (GtkLedClass * klass)
{
GtkWidgetClass * widget_class;
GObjectClass * object_class;
GParamSpec *pspec;
#ifdef CB_TEST
g_print ("gtk_led_class_init\n");
#endif
widget_class = (GtkWidgetClass *) klass;
object_class = (GObjectClass *) klass;
/* Override widget class methods */
object_class->set_property = gtk_led_set_property;
object_class->get_property = gtk_led_get_property;
widget_class->realize = gtk_led_realize;
widget_class->get_preferred_width = gtk_led_get_preferred_width;
widget_class->get_preferred_height = gtk_led_get_preferred_height;
widget_class->size_allocate = gtk_led_size_allocate;
object_class->finalize = gtk_led_finalize;
/************************/
pspec = g_param_spec_boolean ("state",
"State",
"True when the led is switched_on",
FALSE,
G_PARAM_READWRITE);
g_object_class_install_property (object_class, PROP_STATE, pspec);
/************************/
pspec = g_param_spec_string ("on-image",
"On-Image",
"Path for the led on image file",
"",
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
g_object_class_install_property (object_class, PROP_IMAGE_ON, pspec);
/************************/
pspec = g_param_spec_string ("off-image",
"Off-Image",
"Path for the led off image file",
"",
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
g_object_class_install_property (object_class, PROP_IMAGE_OFF, pspec);
g_type_class_add_private (klass, sizeof(GtkLedPrivate));
g_print ("\n gtk_led_class_init ligne SUCCESS %d\n", __LINE__);
}
static void gtk_led_init (GtkLed * led)
{
#ifdef CB_TEST
g_print ("gtk_led_init\n");
#endif
GtkLedPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE(led, GTK_TYPE_LED, GtkLedPrivate);
gtk_widget_set_has_window(GTK_WIDGET(led), TRUE);
priv->on_image = NULL;
priv->off_image = NULL;
priv->on_pixbuf = NULL;
priv->off_pixbuf = NULL;
priv->width = 0;
priv->height =0;
priv->state = FALSE;
g_print ("dans gtk_led_init les tailles sont %d et %d \n",priv->width,priv->height);
/* Create cache for faster access */
led->priv = priv;
g_print ("\n gtk_led_init ligne SUCCESS %d\n", __LINE__);
}
static void gtk_led_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
#ifdef CB_TEST
g_print ("gtk_led_set_property\n");
#endif
GtkLed * led = GTK_LED (object);;
switch (prop_id) {
case PROP_STATE:
gtk_led_set_state (led, g_value_get_boolean(value));
break;
case PROP_IMAGE_ON:
g_free (led->priv->on_image);
led->priv->on_image = g_value_dup_string (value);
break;
case PROP_IMAGE_OFF:
g_free (led->priv->off_image);
led->priv->off_image = g_value_dup_string (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void gtk_led_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
#ifdef CB_TEST
g_print ("gtk_led_get_property\n");
#endif
GtkLed * led = GTK_LED (object);
switch (prop_id) {
case PROP_STATE:
g_value_set_boolean (value, led->priv->state);
break;
case PROP_IMAGE_ON:
g_value_set_string (value, led->priv->on_image);
break;
case PROP_IMAGE_OFF:
g_value_set_string (value, led->priv->off_image);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
gboolean gtk_led_get_state (GtkLed * led)
{
g_return_val_if_fail(GTK_LED(led), 0);
#ifdef CB_TEST
g_print ("gtk_led_get_state\n");
#endif
g_print ("gtk_led_get_state Etat=%d (1 = ON 0=OFF)\n",led->priv->state);
g_print ("\n gtk_led_get_state ligne ok %d\n", __LINE__);
return (led->priv->state);
}
void gtk_led_set_state (GtkLed * led, gboolean state)
{
#ifdef CB_TEST
g_print ("gtk_led_set_state\n");
#endif
led->priv->state = state;
gtk_led_paint (GTK_WIDGET (led));
g_print ("\n gtk_led_set_state ligne ok %d\n", __LINE__);
}
GtkWidget * gtk_led_new (const gchar * on_image,
const gchar * off_image,
gboolean state)
{
GtkLed * led = NULL;
#ifdef CB_TEST
g_print ("gtk_led_new\n");
#endif
if (on_image != NULL && off_image != NULL)
{
// la taille de la zone led n'est pas allouée donc il manque quelque chose
led = g_object_new (GTK_TYPE_LED,
"state", state,
"on-image", on_image,
"off-image", off_image,
NULL);
gtk_led_load_image (led);
g_print ("\n gtk_led_new ligne SUCCESS %d\n", __LINE__);
return GTK_WIDGET (led);
}
g_print ("\n gtk_led_new ligne FATAL ERROR %d\n", __LINE__);
return GTK_WIDGET (led);
}
static void gtk_led_get_preferred_width (GtkWidget *widget, gint *minimal_width, gint *natural_width)
{
/** la fonction établit une largeur compatible avec le fichier image **/
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_LED (widget));
#ifdef CB_TEST
g_print ("gtk_led_get_preferred_width\n");
#endif
GtkRequisition requisition;
gtk_led_size_request (widget, &requisition);
*minimal_width = *natural_width = requisition.width;
g_print ("dans gtk_led_get_preferred_width les tailles sont %d \n",requisition.width);
g_print ("\n gtk_led_get_preferred_width ligne ok %d\n", __LINE__);
}
static void gtk_led_get_preferred_height (GtkWidget *widget, gint *minimal_height, gint *natural_height)
{
/** la fonction établit une hauteur compatible avec le fichier image**/
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_LED (widget));
#ifdef CB_TEST
g_print ("gtk_led_get_preferred_height\n");
#endif
GtkRequisition requisition;
gtk_led_size_request (widget, &requisition);
*minimal_height = *natural_height = requisition.height;
g_print ("dans gtk_led_get_preferred_height les tailles sont %d \n",requisition.height);
g_print ("\n gtk_led_get_preferred_height ligne ok %d\n", __LINE__);
}
static void gtk_led_size_request (GtkWidget * widget, GtkRequisition * requisition)
{
/** nous stockons la taille préférée de notre widget, cette fonction ne sert qu'a cela
* mais requisition sera par la suite consulté **/
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_LED (widget));
#ifdef CB_TEST
g_print ("gtk_led_size_request\n");
#endif
GtkLedPrivate *priv = GTK_LED(widget)->priv;
requisition->width = priv->width;
requisition->height = priv->height;
g_print ("dans gtk_led_size_request les tailles sont %d et %d \n",priv->width,priv->height);
g_print ("\n gtk_led_size_request ligne ok %d\n", __LINE__);
}
void gtk_led_load_image (GtkLed * led)
{
#ifdef CB_TEST
g_print ("gtk_led_load_image\n");
#endif
GtkLedPrivate *priv = led->priv;
priv->on_pixbuf = gdk_pixbuf_new_from_file (priv->on_image, NULL);
priv->off_pixbuf = gdk_pixbuf_new_from_file (priv->off_image, NULL);
/** c'est ici que ces paramètres son initialisé avec la taille des pixbuf **/
priv->width = gdk_pixbuf_get_width (priv->on_pixbuf);
priv->height = gdk_pixbuf_get_height (priv->on_pixbuf);
g_print ("dans gtk_led_load_image les tailles sont %d et %d \n",priv->width,priv->height);
g_print ("\n gtk_led_load_image ligne ok %d\n", __LINE__);
}
static void gtk_led_size_allocate (GtkWidget * widget, GtkAllocation * allocation)
{
/** Cette fonction sera appelée par le conteneur dans lequel se trouvera notre widget,
* une fois que les contraintes qui sont imposées au conteneur sont fixées,
* ça permet au conteneur de redimensionner au mieux notre widget gtkled,
* d'après le résultat obtenu dans le second argument de la fonction avec
* gtk_widget_set_allocation(widget, allocation);
* puis nous lançons la demande de déplacement, et re-dimensionnement,
* avec l'appel à gdk_window_move_resize.
* C'est un protocole qu'on retrouve dans les divers exemples **/
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_LED (widget));
#ifdef CB_TEST
g_print ("gtk_led_size_allocate\n");
#endif
GtkLedPrivate *priv = GTK_LED(widget)->priv;
gtk_widget_set_allocation(widget, allocation);
if (gtk_widget_get_realized(widget))
{
g_print ("\n gtk_led_size_allocate ligne GOOOOOOOOOOOOOD %d\n", __LINE__);
g_print ("dans gtk_led_size_allocate les tailles private sont %d et %d \n",priv->width,priv->height);
g_print ("dans gtk_led_size_allocate les tailles allocation sont %d et %d \n",allocation->width,allocation->height);
gdk_window_move_resize (priv->window,
allocation->x,
allocation->y,
priv->width, priv->height);
}
else
g_print ("\n gtk_led_size_allocate ligne BAAAAAAD %d\n", __LINE__);
g_print ("\n gtk_led_size_allocate ligne ok %d\n", __LINE__);
}
static void gtk_led_realize (GtkWidget * widget)
{
/** cette fonction est au coeur du dispositif c'est ici que la fenêtre est créé
* avec les bonnes dimensions
**/
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_LED (widget));
#ifdef CB_TEST
g_print ("gtk_led_realize\n");
#endif
GtkLedPrivate *priv = GTK_LED(widget)->priv;
GdkWindowAttr attributes;
guint attributes_mask;
GtkAllocation allocation;
gtk_widget_set_realized(widget, TRUE);
gtk_widget_get_allocation(widget, &allocation);
attributes.window_type = GDK_WINDOW_CHILD;
attributes.x = allocation.x;
attributes.y = allocation.y;
attributes.width = allocation.width;
attributes.height = 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;
priv->window = gdk_window_new (
gtk_widget_get_parent_window (widget),
& attributes, attributes_mask);
gdk_window_set_user_data (priv->window, widget);
gtk_widget_set_window(widget, priv->window);
g_print ("\n gtk_led_realize ligne ok %d\n", __LINE__);
}
static void gtk_led_paint (GtkWidget * widget)
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_LED (widget));
GdkPixbuf * pixbuf = NULL;
gint center_x = 0;
gint center_y = 0;
GtkAllocation allocation;
gtk_widget_get_allocation(widget, &allocation);
GtkLedPrivate *priv = GTK_LED(widget)->priv;
if (gtk_widget_get_realized (widget))
{
center_x = (allocation.width / 2) - (priv->width / 2);
center_y = (allocation.height / 2) - (priv->height / 2);
if (priv->state)
pixbuf = priv->on_pixbuf;
else
pixbuf = priv->off_pixbuf;
cairo_t *cr = gdk_cairo_create (priv->window);
gdk_cairo_set_source_pixbuf (cr, pixbuf, center_x, center_y);
cairo_paint (cr);
cairo_destroy (cr);
}
}
static void gtk_led_finalize (GObject * object)
{
// Destruction des données privées si nécessaire
GtkLed * led;
GtkLedPrivate *priv;
#ifdef CB_TEST
g_print ("gtk_led_finalize\n");
#endif
led = GTK_LED (object);
priv = G_TYPE_INSTANCE_GET_PRIVATE(led, GTK_TYPE_LED, GtkLedPrivate);
if (priv->on_pixbuf != NULL && priv->off_pixbuf != NULL)
{
g_object_unref (priv->on_pixbuf);
g_object_unref (priv->off_pixbuf);
priv->on_pixbuf = NULL;
priv->off_pixbuf = NULL;
}
g_print ("\n gtk_led_finalize ligne ok %d\n", __LINE__);
} |
Gtk_led modernisé customisation Gtk
Répondre avec citation
:
. Mais ca ne l'empêche pas de fonctionner.
:
Partager