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

**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...

**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

**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

Création de widgets

GTK+ avec C & C++

Vue hybride

Discussions similaires

Partager

Partager