Gtk-CRITICAL erreur gtk_box

Gtk-CRITICAL erreur gtk_box_pack: assertion

Bonsoir,

j'ai un problème que je n'arrive pas à résoudre concernant une interface gtk+ (version 2.20.1).

Cette interface comporte 2 parties : en haut une drawing area où j'affiche le flux d'une webcam et en bas une partie dialogue où il y a des buttons et label.

Je crée une vbox pour les 2 parties verticales et dans la partie dialogue, j'uitlise une hbox contenant les 2 frames qui contiennent elles mêmes les buttons et label.

à l'exécution, ça semble bien marcher mais j'ai 2 erreurs GTK-CRITICAL de type :

Code:

1
2
3
(a.out:22450): Gtk-CRITICAL **: gtk_box_pack: assertion `child->parent == NULL' failed
 
(a.out:22450): Gtk-CRITICAL **: gtk_box_pack: assertion `child->parent == NULL' failed

Je sais qu'un widget ne peut avoir qu'un seul parent, c'est-à-dire son container. Après avoir examiné le code, je ne sais pas d'où vient l'erreur.

Si vous pouviez y jeter un oeil, voici la partie concernée :

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
 
int main( int argc, char *argv[] ) {
 
  /*********** GUI global variables ********************/
 
  GtkWidget *main_window;
  GtkWidget *frame_dialog_output;
  GtkWidget *frame_dialog_input;  
  GtkWidget *alignment1;  
  GtkWidget *alignment2;    
  GtkWidget *vbox;
  GtkWidget *dialog;  
  GtkWidget *dialog_output;
  GtkWidget *dialog_input;  
  GtkWidget *fixed_output_text;
  GtkWidget *fixed_output;
  GtkWidget *fixed_state_text;  
  GtkWidget *fixed_state;    
  GtkWidget *fixed_clock;      
  GtkWidget *fixed_light;        
  GtkWidget *fixed_noise;          
  GtkWidget *fixed_reset;        
  GtkWidget *label1;            
  GtkWidget *label2;              
 
  struct S_GtkWidget* ptr_struct_GtkWidget;
  ptr_struct_GtkWidget= (struct S_GtkWidget*) malloc(sizeof(struct S_GtkWidget));
 
  gint homogeneous = FALSE;
  gint spacing = 0;
  gint expand = FALSE;
  gint fill = FALSE;
  gint padding = 0;
  const char* char_current_state="Awake";
  const char* output_current="101";   
 
  /*****************************************************/
 
  gtk_init (&argc, &argv);
 
  capture = cvCaptureFromCAM( CV_CAP_ANY );
  opencvImage = cvQueryFrame( capture );
 
  /*********************** Main Window ********************************/   
 
  main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title( GTK_WINDOW( main_window ), "WEBCAM - FPGA Nexys 3");
 
  g_signal_connect( G_OBJECT( main_window ), "destroy", G_CALLBACK (gtk_main_quit), NULL);
 
  /********************************************************************/
 
  /*********************** Label Widget *******************************/
 
  ptr_struct_GtkWidget->output_text=gtk_label_new("Binary : ");
  gtk_widget_set_size_request(ptr_struct_GtkWidget->output_text,50,30);     
  ptr_struct_GtkWidget->output=gtk_label_new(output_current);
  gtk_widget_set_size_request(ptr_struct_GtkWidget->output,50,30);     
 
  ptr_struct_GtkWidget->label_state=gtk_label_new("State :");
  gtk_widget_set_size_request(ptr_struct_GtkWidget->label_state,50,30);     
  ptr_struct_GtkWidget->label_current_state=gtk_label_new(char_current_state);
  gtk_widget_set_size_request(ptr_struct_GtkWidget->label_current_state,110,30);   
 
  ptr_struct_GtkWidget->clock=gtk_button_new_with_label("Clock");
  ptr_struct_GtkWidget->reset=gtk_button_new_with_label("Reset");
  ptr_struct_GtkWidget->light=gtk_toggle_button_new_with_label("Light");
  ptr_struct_GtkWidget->noise=gtk_toggle_button_new_with_label("Noise");   
 
  /********************************************************************/
 
  // Create a Fixed Container 
  fixed_output_text = gtk_fixed_new();
  fixed_output = gtk_fixed_new();
  fixed_state_text = gtk_fixed_new();  
  fixed_state = gtk_fixed_new();    
  fixed_clock = gtk_fixed_new();      
  fixed_light = gtk_fixed_new();        
  fixed_noise = gtk_fixed_new();          
  fixed_reset = gtk_fixed_new();        
 
  /*********************** Webcam Widget ******************************/      
 
  ptr_struct_GtkWidget->drawing_area = gtk_drawing_area_new();
  gtk_widget_set_size_request( ptr_struct_GtkWidget->drawing_area, opencvImage->width, opencvImage->height );
 
  /********************************************************************/
 
  g_signal_connect( G_OBJECT( ptr_struct_GtkWidget->drawing_area), "expose_event", G_CALLBACK (expose_event_callback), NULL);
  g_timeout_add( 100, ( GSourceFunc )time_handler, ( gpointer ) ptr_struct_GtkWidget->drawing_area );
 
  // Add webcam window 
  vbox = gtk_vbox_new (FALSE, 5);
  gtk_box_pack_start (GTK_BOX (vbox), ptr_struct_GtkWidget->drawing_area, expand, fill, padding);     
 
  // Add dialog  
  dialog = gtk_hbox_new (FALSE,0);    
 
  // create frame _dialog_output
  frame_dialog_output = gtk_frame_new(NULL);
  gtk_container_set_border_width (GTK_CONTAINER (frame_dialog_output), 12);
  gtk_frame_set_label_align (GTK_FRAME (frame_dialog_output), 0.05, 0.41);
  gtk_frame_set_shadow_type (GTK_FRAME (frame_dialog_output), GTK_SHADOW_ETCHED_OUT);
 
  alignment1 = gtk_alignment_new (0.5, 0.5, 1, 1);
  gtk_widget_show (alignment1);
  gtk_container_add (GTK_CONTAINER (frame_dialog_output), alignment1);
  gtk_alignment_set_padding (GTK_ALIGNMENT (alignment1), 0, 0, 7, 0);
 
  label1 = gtk_label_new ("<b>Output : </b>");
  gtk_widget_show (label1);
  gtk_frame_set_label_widget (GTK_FRAME (frame_dialog_output), label1);
  gtk_label_set_use_markup (GTK_LABEL (label1), TRUE);
  gtk_misc_set_padding (GTK_MISC (label1), 10, 0);
 
  // Add dialog output  
  dialog_output = gtk_hbox_new (FALSE,2);    
 
  gtk_box_pack_start (GTK_BOX (dialog), frame_dialog_output, expand, fill, padding);
  gtk_container_add (GTK_CONTAINER (alignment1), dialog_output);
 
  // Position of and content of output labels
  gtk_fixed_put(GTK_FIXED (fixed_output_text), ptr_struct_GtkWidget->output_text, 3,5);
  gtk_widget_set_size_request(fixed_output_text, 40, 40);
  gtk_fixed_put(GTK_FIXED (fixed_output), ptr_struct_GtkWidget->output, 6,5);   
  gtk_widget_set_size_request(fixed_output, 40, 40);
 
  gtk_fixed_put (GTK_FIXED (fixed_state_text), ptr_struct_GtkWidget->label_state, 9,5);            
  gtk_widget_set_size_request(fixed_state_text, 40, 40);
  gtk_fixed_put (GTK_FIXED (fixed_state), ptr_struct_GtkWidget->label_current_state, 12,5);               
  gtk_widget_set_size_request(fixed_state, 127, 40);
 
  // Position and content of signals buttons
  gtk_fixed_put (GTK_FIXED (fixed_clock), ptr_struct_GtkWidget->clock, 30,0);
  gtk_fixed_put (GTK_FIXED (fixed_light), ptr_struct_GtkWidget->light, 31,0);   
  gtk_fixed_put (GTK_FIXED (fixed_noise), ptr_struct_GtkWidget->noise, 32,0);             
  gtk_fixed_put (GTK_FIXED (fixed_reset), ptr_struct_GtkWidget->reset, 33,0);                   
 
  gtk_container_add(GTK_CONTAINER( dialog_output), fixed_output_text);
  gtk_container_add(GTK_CONTAINER( dialog_output), fixed_output);
  gtk_container_add(GTK_CONTAINER( dialog_output), fixed_state_text);      
  gtk_container_add(GTK_CONTAINER( dialog_output), fixed_state);
 
  // Pack dialog_output to dialog hbox
  gtk_box_pack_start (GTK_BOX (dialog), dialog_output, expand, fill, padding);
 
  // Create frame _dialog_input
  frame_dialog_input = gtk_frame_new(NULL);
  gtk_container_set_border_width (GTK_CONTAINER (frame_dialog_input), 12);
  gtk_frame_set_label_align (GTK_FRAME (frame_dialog_input), 0.05, 0.41);
  gtk_frame_set_shadow_type (GTK_FRAME (frame_dialog_input), GTK_SHADOW_ETCHED_OUT);
 
  alignment2 = gtk_alignment_new (0.5, 0.5, 1, 1);
  gtk_widget_show (alignment2);
  gtk_container_add (GTK_CONTAINER (frame_dialog_input), alignment2);
  gtk_alignment_set_padding (GTK_ALIGNMENT (alignment2), 4, 0, 6, 8);
 
  label2 = gtk_label_new ("<b>Signals : </b>");
  gtk_widget_show (label2);
  gtk_frame_set_label_widget (GTK_FRAME (frame_dialog_input), label2);
  gtk_label_set_use_markup (GTK_LABEL (label2), TRUE);
  gtk_misc_set_padding (GTK_MISC (label2), 10, 0);
 
  // Add dialog output  
  dialog_input = gtk_hbox_new (FALSE,2);      
 
  gtk_box_pack_start (GTK_BOX (dialog), frame_dialog_input, expand, fill, padding);
  gtk_container_add (GTK_CONTAINER (alignment2), dialog_input);
 
  gtk_container_add(GTK_CONTAINER( dialog_input), fixed_clock);
  gtk_container_add(GTK_CONTAINER( dialog_input), fixed_light);
  gtk_container_add(GTK_CONTAINER( dialog_input), fixed_noise);
  gtk_container_add(GTK_CONTAINER( dialog_input), fixed_reset);
 
  // Pack dialog_input to dialog hbox 
  gtk_box_pack_start (GTK_BOX (dialog), dialog_input, expand, fill, padding);
 
  // Pack dialog hbox to main vbox 
  gtk_box_pack_start (GTK_BOX (vbox), dialog, expand, fill, padding);
 
  // Add dialog hbox to main window
  gtk_container_add( GTK_CONTAINER(main_window), vbox);      
 
  g_signal_connect(G_OBJECT(ptr_struct_GtkWidget->clock), "pressed",  G_CALLBACK(input_signal),char_clock);      
  g_signal_connect(G_OBJECT(ptr_struct_GtkWidget->clock), "released", G_CALLBACK(update_state),ptr_struct_GtkWidget);
  g_signal_connect(G_OBJECT(ptr_struct_GtkWidget->clock), "released", G_CALLBACK(toggle_input_off),ptr_struct_GtkWidget->light);                  
  g_signal_connect(G_OBJECT(ptr_struct_GtkWidget->clock), "released", G_CALLBACK(toggle_input_off),ptr_struct_GtkWidget->noise);                     
  g_signal_connect(G_OBJECT(ptr_struct_GtkWidget->reset), "pressed", G_CALLBACK(input_signal),char_reset);         
  g_signal_connect(G_OBJECT(ptr_struct_GtkWidget->reset), "released", G_CALLBACK(update_state),ptr_struct_GtkWidget);                  
  g_signal_connect(G_OBJECT(ptr_struct_GtkWidget->reset), "released", G_CALLBACK(toggle_input_off),ptr_struct_GtkWidget->light);                  
  g_signal_connect(G_OBJECT(ptr_struct_GtkWidget->reset), "released", G_CALLBACK(toggle_input_off),ptr_struct_GtkWidget->noise);                     
 
 
  g_signal_connect(G_OBJECT(ptr_struct_GtkWidget->light), "toggled", G_CALLBACK(toggle_button_callback),char_light);         
  g_signal_connect(G_OBJECT(ptr_struct_GtkWidget->noise), "toggled", G_CALLBACK(toggle_button_callback),char_noise);         
 
  gtk_widget_show_all( main_window );
  gtk_main();
  cvReleaseCapture( &capture );
 
  return 0;
}

Merci par avance pour votre aide

Bonjour,

déjà quand tu mets un exemple, ce serait gentil de faire en sorte qu'il compile. Il manque la moitié du code avec les définitions de callbacks, les en-têtes et les définitions de structure. Une fois ces problèmes contournés, j'ai ajouté des lignes de ce type un peu partout:

Code:

g_print ("%d\n", __LINE__);

Cela t'affichera la n° de ligne en cours d'exécution. Ainsi tu peux repérer rapidement entre quelles lignes se situe le problème. On voit alors rapidement que ligne 120 et 145 tu ajoutes le même widget dans deux parents différents. Même problème lignes 168 et 176.

Pour ce genre d'interface, une solution plus simple serait d'utiliser Glade.
Toutes les informations sur le positionnement sont dans un fichier XML.
Pas besoin de recompiler quand la géométrie change
D'autre part, il est fortement déconseillé d'utiliser les fixed dans Gtk.
A mon avis, il vaudrait mieux rendre la fenêtre principale non redimensionnable
Exemple dans Glade :
<property name="resizable">False</property>
Avec Gtk2.0, il faut utiliser Glade 3.8
Pour Windows et Gtk2.0, glade est disponible à cet endroit :
http://ftp.gnome.org/pub/GNOME/binar...n32/glade/3.8/

Tout à fait d'accord avec toi, sauf sur le fait de rendre la fenêtre non redimensionnable. Je pense qu'il est toujours préférable de permettre le redimensionnement. Il est très souvent réaliste d'avoir une fenêtre bien conçue, qui laisse les bons widgets s'agrandir (ou pas) pour bénéficier de l'espace supplémentaire.

Pour localiser l'endroit qui provoque un warning, on peut aussi lancer le programme avec un debogueur et l'option --g-fatal-warnings, ce qui fait planter le programme à cet endroit.
https://developer.gnome.org/gtk2/sta...k-running.html