Discussion :

[Loenix]

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