Utilisation de gtk_builder_add_from_file

**troumad** · 08/12/2013, 19h21

Bonjour

J'essaie de me référer à la source pour comprendre : https://developer.gnome.org/gnome-de...ubar.c.html.fr

Mon problème, c'est que j'ai l'impression de ne pas comprendre leur utilisation de gtk_builder_add_from_file à la ligne 282 du programme.
Soit le problème vient de moi, soit il y a un bug dans leur programme.
Dans le second cas, comment remonter cette erreur ?

**Tarnyko** · 08/12/2013, 21h16

Hello,

Le problème de ton exemple est qu'il n'indique pas clairement qu'il y a 3 fichiers :
un C, un XML et un UI.

Le mieux est de regarder la source de gtk3-widget-factory (très simple) pour comprendre.

Dans le C, tu as "add_from_file (..., "menubar.ui", ... )".
Le "menubar.ui" est spécifié dans le XML. C'est ici le nom du fichier UI, mais ça pourrait être n'importe quelle chaîne ; le XML indique quel est le fichier réel à associer à cette désignation.
Le UI contient l'interface dans un format spécifique.

Pour compiler ton exemple, il faut transformer le couple XML/UI en un autre C.
Tu dois utiliser "glib-compile-resources" de cette manière :

glib-compile-resources --generate-source --c-name <interface>.c <interface>.xml

Ca va créer un nouveau "<interface>.c". Tu compileras finalement avec :

gcc source.c interface.c -o executable ...

**troumad** · 08/12/2013, 21h49

Merci pour ta réponse.
Je regarderai plus en profondeur les sources que tu donnes. Leurs exemples manques d'explications à mon avis.
j'ai peur que quelque chose d'aussi complexe soit difficile à gérer avec code::blocks s'il faut deux compilations.

Par contre, ce n'est pas mon exemple, c'est celui du site gnome

Je suis arrivé à le faire marcher (de façon bancale*), mais sans fichier xml. Je me demande si tu ne fais pas une confusion quant au nombre des fichiers : le fichier ui est en xml. Ils disent qu'il faut aller chercher le fichier ui dans deux exemples en haut du fichier. C'est celui que j'ai pris.
Mais si tu es le Tarnyko de http://www.tarnyko.net/dl/gtk.htm , je ne pense pas que ce soit à moi de te dire comment ça marche ! J'ai plutôt à te remercier pour ton travail.

* : je ne vois pas pourquoi si j'efface l'erreur (g_free(error) ), j'ai un paquet de message d'erreur (ligne 288 de ma correction)
Ce qui me gène le plus, c'est qu'un programme d'exemple sur developer.gnome.org puisse avoir des erreurs !

Pour info, voici le programme corrigé que je propose :

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
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
#include <gtk/gtk.h>
#include <glib.h>
#include <glib/gprintf.h>
#include <errno.h>
 
 
 
/* Callback function for the "copy" action */
static void
copy_callback (GSimpleAction *simple,
            GVariant      *parameter,
            gpointer       user_data)
{
   g_print ("\"Copy\" activated\n");
}
 
 
 
/* Callback function for the "paste" action */
static void
paste_callback (GSimpleAction *simple,
            GVariant      *parameter,
            gpointer       user_data)
{
   g_print ("\"Paste\" activated\n");
}
 
 
 
/* Callback function for the "shape" action */
static void
shape_callback (GSimpleAction *simple,
            GVariant      *parameter,
            gpointer       user_data)
{
   /* We first gather the value of the GVariant instance with a string type.
    * The overall goal here is to see if shape is set to line, triangle, etc,
    * and put that value within the variable "answer".
    */
   const gchar *answer = g_variant_get_string (parameter, NULL);
   g_printf ("Shape is set to %s.\n", answer);
   /* Note that we set the state of the action */
   g_simple_action_set_state (simple, parameter);
}
 
 
 
/* Callback function in which closes the about_dialog created below */
static void
on_close (GtkDialog *dialog,
          gint       response_id,
          gpointer   user_data)
{
  gtk_widget_destroy (GTK_WIDGET (dialog));
}
 
 
 
/* Callback function for the about action (see aboutdialog.c example) */
static void
about_callback (GSimpleAction *simple,
            GVariant      *parameter,
            gpointer       user_data)
{
   GtkWidget *about_dialog;
 
   about_dialog = gtk_about_dialog_new ();
 
   const gchar *authors[] = {"GNOME Documentation Team", NULL};
   const gchar *documenters[] = {"GNOME Documentation Team", NULL};
 
   /* Fill in the about_dialog with the desired information */
   gtk_about_dialog_set_program_name (GTK_ABOUT_DIALOG (about_dialog), "AboutDialog Example");
   gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG (about_dialog), "Copyright \xc2\xa9 2012 GNOME Documentation Team");
   gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG (about_dialog), authors);
   gtk_about_dialog_set_documenters (GTK_ABOUT_DIALOG (about_dialog), documenters);
   gtk_about_dialog_set_website_label (GTK_ABOUT_DIALOG (about_dialog), "GNOME Developer Website");
   gtk_about_dialog_set_website (GTK_ABOUT_DIALOG (about_dialog), "http://developer.gnome.org");
 
   /* The "response" signal is emitted when the dialog receives a delete event,
    * therefore we connect that signal to the on_close callback function
    * created above.
    */
   g_signal_connect (GTK_DIALOG (about_dialog), "response",
                    G_CALLBACK (on_close), NULL);
 
   /* Show the about dialog */
   gtk_widget_show (about_dialog);
}
 
 
 
static void
activate (GtkApplication *app,
          gpointer        user_data)
{
  GtkWidget *window;
 
  GSimpleAction *copy_action;
  GSimpleAction *paste_action;
  GSimpleAction *shape_action;
  GSimpleAction *about_action;
 
  /* Create a window with a title and a default size */
  window = gtk_application_window_new (app);
  gtk_window_set_title (GTK_WINDOW (window), "MenuBar Example");
  gtk_window_set_default_size (GTK_WINDOW (window), 200, 200);
 
  /* Begin creating the "copy" action.
   * Note that it is an action without a state.
   */
  copy_action = g_simple_action_new ("copy", NULL);
  /* Connected to a callback function */
  g_signal_connect (copy_action, "activate", G_CALLBACK (copy_callback),
                    GTK_WINDOW (window));
  /* Added to the window */
  g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (copy_action));
 
  /* Begin creating the "paste" action.
   * Note that it is an action without a state.
   */
  paste_action = g_simple_action_new ("paste", NULL);
  /* Connect the action to a callback function */
  g_signal_connect (paste_action, "activate", G_CALLBACK (paste_callback),
                    GTK_WINDOW (window));
  /* Add it to the window */
  g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (paste_action));
 
  /* Begin creating the "shape" action.
   * Note that it is an action with a state.
   * First we state that the parameter type of the simple action is a string.
   * When using g_variant_type_new, it is appropriate to free the return value
   * once you're done with it.
   */
  GVariantType *type_string = g_variant_type_new ("s");
  /* parameters for the g_simple_action_new_stateful are: (name, parameter type,
   * initial state).
   */
  shape_action = g_simple_action_new_stateful ("shape", type_string,
                                               g_variant_new_string ("line"));
  /* Connect the action to a callback function */
  g_signal_connect (shape_action, "activate", G_CALLBACK (shape_callback),
                    GTK_WINDOW (window));
  /* Add it to the window */
  g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (shape_action));
  g_variant_type_free (type_string);
 
  /* Begin creating the "about" action.
   * Note that it is an action without a state.
   */
  about_action = g_simple_action_new ("about", NULL);
  /* Connect the action to a callback function */
  g_signal_connect (about_action, "activate", G_CALLBACK (about_callback),
                    GTK_WINDOW (window));
  /* Add it to the window */
  g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (about_action));
 
  gtk_widget_show_all (window);
}
 
 
 
/* Callback function for the "new" action */
static void
new_callback (GSimpleAction *simple,
         GVariant      *parameter,
         gpointer       user_data)
{
  g_print ("You clicked \"New\"\n");
}
 
 
 
/* Callback function for the "quit" action */
static void
quit_callback (GSimpleAction *simple,
         GVariant      *parameter,
         gpointer       user_data)
{
  GApplication *application = user_data;
 
  g_print ("You clicked \"Quit\"\n");
  g_application_quit (application);
}
 
 
 
/* Callback function for the "state" action */
static void
state_callback (GSimpleAction *simple,
         GVariant      *parameter,
         gpointer       user_data)
{
   /* The two possibilies in this case for the "answer" variable are either
    * "on" or "off".
    */
   const gchar *answer = g_variant_get_string (parameter, NULL);
   /* We print the information to the user */
   g_printf ("State is set to %s.\n", answer);
   /* Note that we set the state of the action */
   g_simple_action_set_state (simple, parameter);
}
 
 
 
/* Callback function for the "awesome" action */
static void
awesome_callback (GSimpleAction *simple,
         GVariant      *parameter,
         gpointer       user_data)
{
  GVariant *action_state = g_action_get_state (G_ACTION (simple));
  gboolean active = g_variant_get_boolean (action_state);
  GVariant *new_state = g_variant_new_boolean (!active);
  /* Set the new state for the action.
   * (Keeps track of whether it was last checked or unchecked).
   */
  g_simple_action_set_state (simple, new_state);
 
  if (active)
     g_print ("You unchecked \"Awesome\"\n");
  else
     g_print ("You checked \"Awesome\"\n");
}
 
 
 
/* Startup function for the menu we are creating in this sample */
static void
startup (GApplication *app,
         gpointer      user_data)
{
  /* Initialize variables */
  GSimpleAction *new_action;
  GSimpleAction *quit_action;
  GSimpleAction *state_action;
  GSimpleAction *awesome_action;
 
  GtkBuilder *builder;
 
  GError *error=NULL;
 
  /* Begin creating the "new" action.
   * Note that it is an action without a state.
   */
  new_action = g_simple_action_new ("new", NULL);
  g_signal_connect (new_action, "activate", G_CALLBACK (new_callback), app);
  /* It is added to the overall application */
  g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (new_action));
 
  /* Begin creating the "quit" action.
   * Note that it is an action without a state.
   */
  quit_action = g_simple_action_new ("quit", NULL);
  g_signal_connect (quit_action, "activate", G_CALLBACK (quit_callback), app);
  /* It is added to the overall application */
  g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (quit_action));
 
  /* Begin creating the "state" action.
   * Note that it is an action with a state.
   */
  GVariantType *type_string2 = g_variant_type_new ("s");
  state_action = g_simple_action_new_stateful ("state", type_string2,
                                               g_variant_new_string ("off"));
  g_signal_connect (state_action, "activate", G_CALLBACK (state_callback), app);
  /* It is added to the overall application */
  g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (state_action));
  g_variant_type_free (type_string2);
 
  /* Begin creating the "awesome" action.
   * Note that it is an action with a state.
   */
  awesome_action = g_simple_action_new_stateful ("awesome", NULL, g_variant_new_boolean (FALSE));
  g_signal_connect (awesome_action, "activate", G_CALLBACK (awesome_callback), app);
  /* It is added to the overall application */
  g_action_map_add_action (G_ACTION_MAP (app), G_ACTION (awesome_action));
 
  /* A builder to add the User Interface designed with GLADE to the grid: */
  builder = gtk_builder_new ();
  /* Get the file (if it is there):
   * Note: you must make sure that the file is in the current directory for
   * this to work. The function used here returns a value within our variable
   * "error", and it is equal to zero if an error is indeed found.
   */
  if( ! gtk_builder_add_from_file (builder, "menubar.ui", &error))
  {
        g_warning( "%s", error->message );
        //g_free( error );
        error=NULL;
        GApplication *application = user_data;
 
        g_application_quit (application);
        return;
  }
 
  /* Extract the menubar */
  GObject *menubar = gtk_builder_get_object (builder, "menubar");
  gtk_application_set_menubar (GTK_APPLICATION (app), G_MENU_MODEL (menubar));
 
  /* Extract the appmenu */
  GObject *appmenu = gtk_builder_get_object (builder, "appmenu");
  gtk_application_set_app_menu (GTK_APPLICATION (app), G_MENU_MODEL (appmenu));
}
 
 
 
/* Startup function for the application */
int
main (int argc, char **argv)
{
  GtkApplication *app;
  int status;
 
  app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
  g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
  g_signal_connect (app, "startup", G_CALLBACK (startup), app);
  status = g_application_run (G_APPLICATION (app), argc, argv);
  g_object_unref (app);
 
  return status;
}

nb : je n'ai pas encore tout compris.

**Tarnyko** · 09/12/2013, 05h47

Envoyé par troumad

Mais si tu es le Tarnyko de http://www.tarnyko.net/dl/gtk.htm , je ne pense pas que ce soit à moi de te dire comment ça marche ! J'ai plutôt à te remercier pour ton travail.

C'est bien moi (merci

!), mais ça ne m'empêche pas de me planter de temps en temps... et en l'occurence voilà, j'ai lu ton message trop vite ^^ !

Donc effectivement, on peut transformer un XML/UI en C comme je l'ai décris, mais dans cet exemple on le charge dynamiquement...

Et donc oui tu as raison, il y a bien une erreur dans la doc : la condition "error" est toujours vérifiée, donc le message s'affichera toujours ! Il faut bien faire comme dans ta correction.

Envoyé par troumad

* : je ne vois pas pourquoi si j'efface l'erreur (g_free(error) ), j'ai un paquet de message d'erreur (ligne 288 de ma correction)

Voir plus bas ; il ne faut pas utiliser "g_free()" mais "g_error_free()".

Envoyé par troumad

Ce qui me gène le plus, c'est qu'un programme d'exemple sur developer.gnome.org puisse avoir des erreurs !

Alors c'est vrai que cette partie n'est pas en wiki ; je viens de pousser une correction inspirée de ton message. Elle n'est pas encore visible sur le site mais le sera lors de la prochaine mise à jour.

PS : J'espère que tu ne m'en voudras pas de n'avoir repris qu'une partie de ton fix, mais comme il ajoutait une nouvelle partie, je suis resté simple et dans l'esprit du code d'origine.

PS2 : je ne t'ai pas mentionné en auteur du fix, mais je te promets de le faire la prochaine fois si tu me communiques par MP un mail qui pourra être affiché (je ne le fais pas la 1ère fois, car tout le monde ne veut pas/n'aime pas).

**troumad** · 09/12/2013, 06h48

Merci !
Mon but n'est pas de voir mon nom partout, mais d'aider le libre

Je pourrais toujours te passer un message la prochaine si c'est en français qu'il faut le faire. C'est pour être affiché où ?

**Tarnyko** · 09/12/2013, 09h45

Juste pour la ligne "Author" du patch (l'auteur peut être différent du committer ; ici moi, qui fait la modification). Ca n'apparaîtra pas sur le site, juste sur le dépôt de code. Après à toi de me dire si ça compte ou pas.

**liberforce** · 09/12/2013, 11h14

Envoyé par troumad

Ce qui me gène le plus, c'est qu'un programme d'exemple sur developer.gnome.org puisse avoir des erreurs !

C'est un projet collaboratif tu sais, donc tout le monde contribue à la hauteur de ses capacités. Et je sais qu'une bonne partie de ces exemples pour débutants a été rédigée par... des débutants. C'est regrettable qu'il y ait des erreurs, il y en a d'ailleurs sans doute d'autres, mais c'est justement en les remontant que l'on peut améliorer les choses. Ce sont souvent des choses simples, ça peut m'occuper dans des nuits d'insomnie

.

Si tu en trouves d'autres, il sont à déclarer sur http://bugzilla.gnome.org dans le produit gnome-devel-docs, composant platform-demos (comme indiqué dans la page d'amélioration des exemples). Voici en temps réel la liste des bugs des démos.

**troumad** · 09/12/2013, 17h07

je sais que ce sont des bénévoles. C'est pour ça que je cherche à corriger les erreurs quand j'en vois.
Je fais ça déjà dans d'autres projets : je profite du travail que font les autres et j'essaie d'aider en fonction de mes moyens et de mon temps.

**liberforce** · 10/12/2013, 10h26

Ce n'était pas un reproche, je sais que tu fais déjà plus que la plupart des gens

**troumad** · 12/12/2013, 15h30

Bonjour

À ce propos, j'aimerai faire une aide sur dvp.com avec ces nouveaux menus.
Je compte partir à partir de ce fichier, je pense que si je garde une licence gpl, c'est bon.
Je me pose des questions quant à l'écriture de ce fichier.

Je n'aime pas du tout sa façon d'être écrit
Je préfère mettre dans l'ordre les includes, les defines, les prototypes, le main et les fonctions après. Ça aide la lecture pour les petits programmes.
Je ne comprends pas l'intérêt de la forme du main
1. Pourquoi générer la fenêtre sur le signal activate ?
2. Pourquoi générer le menu sur le signal startup ?
  L'ordre contraire ferait que les menus arrivent nul part.
3. Pourquoi ne pas tout générer dans le main ? Ou générer le menu à la suite de la fenêtre dans le même appel ?

Étant autodidacte en C (mes profs enseignaient le Pascal et j'ai fini pas leur faire un programme en C), je ne suis pas au courant de toutes les bonnes pratiques, je me renseigne donc avant de donner des exemples. Surtout quand j'en vois qui ne ressemblent pas à ce que je ferais !

Pour ce qui est de faire une aide aussi pour le site gnome, je veux bien donner celle que je ferais (si j'y arrive), mais en français. Mon anglais est un gouffre.

**troumad** · 18/12/2013, 07h27

Je n'arrive pas à trouver où il a trouver les doc sur le document manubar.ui qu'il a généré !

**liberforce** · 18/12/2013, 15h38

Comment ça les docs ? Tu veux dire le source de menubar.ui ? Ou la manière dont il l'a créé ?

**troumad** · 18/12/2013, 18h04

J'aimerai savoir à partir de quels document il est arrivé à créer ce fichier.

**liberforce** · 19/12/2013, 10h51

Bin y a pas vraiment de document, le développeur a juste créé son menu avec Glade. Pour les GAction et leur nommage dans le.ui, ce n'est effectivement pas très clair... Je n'arrive pas à trouver qui met en place les préfixe win et app. On dirait que ce sont les noms de deux GActionGroup qui sont créés par défaut par GtkApplication, mais je ne suis pas sûr...

**troumad** · 19/12/2013, 11h33

On en est donc au même point !
Je pensais tester la génération de tels fichiers en passant par glade, mais ce qu'on a vient de glade, ça ne permettra rien de plus.

Peut-être que les programmeurs de glade ont plus d'infos. Je regarderai par là dès que j'ai du temps.