[GObject] Enregistrement d'un nouveau type

Bonjour,

Je suis en train d'étudier le composant GtkBuilder et j'aurais voulu créer mon propre widget "buildable".

Le problème c'est que je suis obligé de créer un premier widget bidon pour que GObject prenne en compte mon nouvel objet sinon GtkBuilder ne le connaît pas.

Plus précisemment, c'est la fonction g_type_register_static qui est appelée dans la méthode get_type de la classe qui permet ceci (si le type n'existe pas encore).

Je n'ai pas trouvé comment GTK+ faisait (je m'attendais à un appel massif des différents get_type dans gtk_init).

Il n'y a pas une autre solution ?

En regardant l'API doc de GtkBuilder, ce passage me paraît intéressant

Citation:

Typically, the specific kind of object represented by an <object> element is specified by the "class" attribute. If the type has not been loaded yet, GTK+ tries to find the _get_type() from the class name by applying heuristics. This works in most cases, but if necessary, it is possible to specify the name of the _get_type() explictly with the "type-func" attribute.

Ie soit ton widget adopte la même technique de capitalisation que gtk+ (GtkFooBar => gtk_foo_bar_get_type () je pense), soit tu peux ajouter un attribut "type-func" qque part dans le fichier xml que tu utilises (je pense) pour filer le nom de ta fonction get_type().

Enfin j'ai jamais utilisé cette API, je dis peut être n'importe quoi :)

Citation:

Envoyé par teuf13

Enfin j'ai jamais utilisé cette API, je dis peut être n'importe quoi :)

C'est bien ça, mais c'est ce que j'ai fait. Voici le code complet :

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
#include <gtk/gtk.h>
 
#include "gtkled.h"
 
int main (int argc, char *argv[])
{
  GError *error = NULL;
  GtkBuilder *builder = NULL;
 
  gtk_init (&argc, &argv);
 
  g_object_unref (gtk_led_new ());
 
  builder = gtk_builder_new ();
  if (gtk_builder_add_from_file (builder, "ui.xml", &error) != 0)
  {
    GtkWidget *window = NULL;
 
    window = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
    gtk_builder_connect_signals (builder, NULL);
    gtk_widget_show_all (window);
    gtk_main ();
  }
  else
  {
    g_warning (error->message);
    g_error_free (error), error = NULL;
  }
  return 0;
}

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
#include "gtkled.h"
 
#define GTK_LED_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
                                GTK_TYPE_LED,                     \
                                GtkLedPrivate))
 
enum
{
  GTK_LED_SWITCH_STATE_SIGNAL,
  GTK_LED_LAST_SIGNALS
};
 
enum
{
  PROP_0,
  PROP_STATE
};
 
typedef struct _GtkLedPrivate GtkLedPrivate;
 
struct _GtkLedPrivate
{
  gboolean state;
  GdkColor on_color;
  GdkColor off_color;
};
 
static guint gtk_led_signals [GTK_LED_LAST_SIGNALS] = { 0 };
 
G_DEFINE_TYPE (GtkLed, gtk_led, GTK_TYPE_WIDGET)
 
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
                          | GDK_BUTTON_RELEASE_MASK
                          | GDK_BUTTON_PRESS_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_event (GtkWidget *widget, GdkEventExpose *event)
{
  GtkLed *led = GTK_LED (widget);
  GtkLedPrivate *priv = NULL;
  GdkGC *gc = NULL;
  gint x = 0;
  gint y = 0;
  gint width = 0;
  gint height = 0;
  gint size = 0;
 
  g_return_val_if_fail (led != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_LED (led), FALSE);
 
  priv = GTK_LED_GET_PRIVATE (led);
  width = widget->allocation.width;
  height = widget->allocation.height;
  size = (width > height) ? height : width;
  x = (width-size)/2;
  y = (height-size)/2;
 
  gdk_window_clear_area (widget->window, 0, 0, width, height);
 
  gc = gdk_gc_new (GDK_DRAWABLE (widget->window));
  if (priv->state == TRUE)
  {
    gdk_gc_set_foreground (gc, &priv->on_color);
  }
  else
  {
    gdk_gc_set_foreground (gc, &priv->off_color);
  }
  gdk_draw_arc (GDK_DRAWABLE (widget->window), gc, TRUE, x, y, size, size,
                0, 360 * 64);
 
  (void)event;
  return FALSE;
}
 
static gboolean gtk_led_button_release (GtkWidget *widget,
                                        GdkEventButton *event)
{
  GtkLed *led = GTK_LED (widget);
  GtkLedPrivate *priv = NULL;
 
  g_return_val_if_fail (led != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_LED (led), FALSE);
 
  priv = GTK_LED_GET_PRIVATE (led);
  priv->state = !priv->state;
  gtk_widget_queue_draw (widget);
  g_signal_emit (
    G_OBJECT (led),
    gtk_led_signals [GTK_LED_SWITCH_STATE_SIGNAL],
    0
  );
 
  (void)event;
  return TRUE;
}
 
static void   gtk_led_set_property (GObject *object, guint prop_id,
                                      const GValue *value, GParamSpec *pspec)
{
  GtkLed *led = GTK_LED (object);
 
  g_return_if_fail (led != NULL);
  g_return_if_fail (GTK_IS_LED (led));
 
  switch (prop_id)
  {
    case PROP_STATE:
      gtk_led_set_state (led, g_value_get_boolean (value));
    break;
    default:
    break;
  }
 
  (void)pspec;
}
 
static void   gtk_led_get_property (GObject *object, guint prop_id,
                                      GValue *value, GParamSpec *pspec)
{
  GtkLed *led = GTK_LED (object);
 
  g_return_if_fail (led != NULL);
  g_return_if_fail (GTK_IS_LED (led));
 
  switch (prop_id)
  {
    case PROP_STATE:
      g_value_set_boolean (value, gtk_led_get_state (led));
    break;
    default:
    break;
  }
 
  (void)pspec;
}
 
static void gtk_led_finalize (GObject *object)
{
  GtkLed *led = GTK_LED (object);
  GtkLedPrivate *priv = NULL;
 
  g_return_if_fail (led != NULL);
  g_return_if_fail (GTK_IS_LED (led));
 
  priv = GTK_LED_GET_PRIVATE (led);
  gdk_colormap_free_colors (gdk_colormap_get_system (), &priv->on_color, 1);
  gdk_colormap_free_colors (gdk_colormap_get_system (), &priv->off_color, 1);
}
 
static void gtk_led_class_init (GtkLedClass *klass)
{
  GtkWidgetClass *widget_class = NULL;
  GObjectClass *gobject_class = NULL;
 
  g_return_if_fail (klass != NULL);
 
  widget_class = GTK_WIDGET_CLASS (klass);
  widget_class->realize = gtk_led_realize;
  widget_class->expose_event = gtk_led_expose_event;
  widget_class->button_release_event = gtk_led_button_release;
 
  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->set_property = gtk_led_set_property;
  gobject_class->get_property = gtk_led_get_property;
  gobject_class->finalize = gtk_led_finalize;
 
  /* Signaux */
  gtk_led_signals [GTK_LED_SWITCH_STATE_SIGNAL] = g_signal_new (
    "switch-state",
    G_TYPE_FROM_CLASS (klass),
    G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
    G_STRUCT_OFFSET (GtkLedClass, switch_state),
    NULL, NULL,
    g_cclosure_marshal_VOID__VOID,
    G_TYPE_NONE,
    0
  );
 
  /* Properties */
  g_object_class_install_property (gobject_class,
                                   PROP_STATE,
                                   g_param_spec_boolean ("state",
                                                         "State",
                                                         "The led state",
                                                         FALSE,
                                                         G_PARAM_READABLE
                                                         | G_PARAM_WRITABLE));
 
  g_type_class_add_private (klass, sizeof (GtkLedPrivate));
}
 
static void gtk_led_init (GtkLed *led)
{
  GtkLedPrivate *priv = NULL;
 
  g_return_if_fail (led != NULL);
  g_return_if_fail (GTK_IS_LED (led));
 
  priv = GTK_LED_GET_PRIVATE (led);
  priv->state = FALSE;
 
  gdk_color_parse ("#00ff00", &priv->on_color);
  gdk_colormap_alloc_color (gdk_colormap_get_system (), &priv->on_color, FALSE,
                            TRUE);
  gdk_color_parse ("#ff0000", &priv->off_color);
  gdk_colormap_alloc_color (gdk_colormap_get_system (), &priv->off_color, FALSE,
                            TRUE);
 
   g_signal_connect (
      G_OBJECT (led),
      "button-release-event",
      G_CALLBACK (gtk_led_button_release),
      led
   );
}
 
GtkWidget *gtk_led_new (void)
{
  return GTK_WIDGET (g_object_new (GTK_TYPE_LED, NULL));
}
 
gboolean gtk_led_get_state (GtkLed *led)
{
  GtkLedPrivate *priv = NULL;
 
  g_return_val_if_fail (led != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_LED (led), FALSE);
 
  priv = GTK_LED_GET_PRIVATE (led);
  return priv->state;
}
 
void gtk_led_set_state (GtkLed *led, gboolean state)
{
  GtkLedPrivate *priv = NULL;
 
  g_return_if_fail (led != NULL);
  g_return_if_fail (GTK_IS_LED (led));
 
  priv = GTK_LED_GET_PRIVATE (led);
  priv->state = state;
  gtk_widget_queue_draw (GTK_WIDGET (led));
}

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
#ifndef __GTK_LED_H__
#define __GTK_LED_H__
 
#include <gtk/gtk.h>
#include <gtk/gtkwidget.h>
 
G_BEGIN_DECLS
 
#define GTK_TYPE_LED            (gtk_led_get_type ())
#define GTK_LED(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LED, GtkLed))
#define GTK_LED_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LED, GtkLedClass))
#define GTK_IS_LED(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LED))
#define GTK_IS_LED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_LED))
#define GTK_LED_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_LED, GtkLesClass))
 
typedef struct _GtkLed GtkLed;
typedef struct _GtkLedClass GtkLedClass;
 
struct _GtkLed
{
  GtkWidget widget;
};
 
struct _GtkLedClass
{
  GtkWidgetClass parent_class;
 
  void (*switch_state) (GtkLed * led);
};
 
GType gtk_led_get_type (void) G_GNUC_CONST;
 
GtkWidget *gtk_led_new (void);
gboolean gtk_led_get_state (GtkLed *);
void gtk_led_set_state (GtkLed *, gboolean);
 
G_END_DECLS
 
#endif /* not __GTK_LED_H__ */

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
<interface>
  <object class="GtkWindow" id="window">
    <property name="title">Test de GtkLed</property>
    <property name="window-position">GTK_WIN_POS_CENTER</property>
    <property name="width-request">250</property>
    <property name="height-request">50</property>
    <signal name="delete-event" handler="gtk_main_quit"/>
    <child>
      <object class="GtkHBox" id="hbox">
        <property name="border-width">5</property>
        <property name="homogeneous">FALSE</property>
        <property name="spacing">0</property>
        <child>
          <object class="GtkLabel" id="label">
            <property name="label">Switch led state</property>
          </object>
        </child>
        <child>
          <object class="GtkLed" id="led">
            <property name="state">TRUE</property>
          </object>
        </child>
      </object>
    </child>
  </object>
</interface>

Il suffit de supprimer, dans main.c :

Code:

g_object_unref (gtk_led_new ());

Pour obtenir :

Code:

1
2
Gtk-ERROR **: Invalid type: GtkLed
aborting...

Contrairement à ce que je pensais, un simple appel gtk_led_get_type ne résoud pas le problème :koi:

Ca semble marcher sans le g_object_unref en compilant avec
Code:

1 2 gcc $(pkg-config --cflags --libs gtk+-2.0 gmodule-2.0) gtkled.c main.c
Pas eu le temps de regarder tout ça en détail, j'ai l'impression que ça marche et je comptais aller dormir y a 45 minutes :p

Citation:
Envoyé par teuf13
Ca semble marcher sans le g_object_unref en compilant avec
Code:

1 2 gcc $(pkg-config --cflags --libs gtk+-2.0 gmodule-2.0) gtkled.c main.c
Effectivement il manquai l'option :

Code:

-Wl,--export-dynamic

Citation:

Envoyé par teuf13

Pas eu le temps de regarder tout ça en détail, j'ai l'impression que ça marche et je comptais aller dormir y a 45 minutes :p

Ah toi aussi :mouarf:

Merci pour ton aide ;)