Hello la team Gtk

je voudrais synchroniser 2 widgets voici le code de mon test

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
 
#include <gtk/gtk.h>
 
//gtk-sync-sample_moi.c
/*  Compile with:
 * 
 *  gcc -std=c11 -Wall -fmax-errors=10 -Wextra gtk-sync-sample_moi.c -o gtk-sync-sample_moi `pkg-config --cflags --libs gtk+-3.0`
 */
 
void cb_quit (GtkWidget *widget, gpointer user_data)
{
	gtk_main_quit();
	/* parametres inutilises */
	(void)widget;
	(void)user_data;
}
void cb_spin_button (GtkWidget *spin_button, gpointer range)
{
	g_print(" j'appelle le callback du spin bouton pour changer le scale \n");
	gtk_spin_button_set_value (GTK_SPIN_BUTTON(spin_button), gtk_range_get_value (GTK_RANGE(range)));
}
void cb_scale (GtkWidget *scale, gpointer spin_button)
{
	g_print(" j'appelle le callback du scale pour changer le spin bouton  \n");
	gtk_range_set_value (GTK_RANGE(scale), gtk_spin_button_get_value (GTK_SPIN_BUTTON(spin_button)));
}
 
static void do_activate (GtkApplication *app, gpointer data)
{
	/* Create a window with a title, and a default size */
	GtkWidget *window = gtk_application_window_new (app);
 
	/* Creation du conteneur principal */
	GtkWidget *main_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
	gtk_container_add (GTK_CONTAINER (window), main_box);
 
	/* taille minimum */
	gtk_window_set_default_size  (GTK_WINDOW (window), 500, 200);
 
	/*création d'une bordure interne à la fenêtre window*/ 
	gtk_container_set_border_width (GTK_CONTAINER (window), 10);
	gtk_window_set_title (GTK_WINDOW (window),"test de synchro entre 2 widgets");
 
	g_signal_connect (window, "delete_event",G_CALLBACK (cb_quit), NULL);
 
	GtkWidget * spin_button = gtk_spin_button_new_with_range(1, 130,2);
 
	GtkWidget * scale = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL,0,130,2);
	int expand = TRUE ;
	int fill = TRUE;
	int padding =1;
 
	gtk_box_pack_start (GTK_BOX (main_box), spin_button, !expand, fill, padding);
	GtkWidget * Separator = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
	gtk_box_pack_start (GTK_BOX (main_box), Separator, FALSE, FALSE, 0);
	gtk_box_pack_start (GTK_BOX (main_box), scale, expand, fill, padding);
 
	gint value = 75;
	GtkAdjustment * adjustement_scale = gtk_adjustment_new ( value,1, 130,2,0,0);
	GtkAdjustment * adjustement_button = gtk_adjustment_new ( value,1, 130,2,0,0);
 
	gtk_range_set_adjustment (GTK_RANGE(scale),adjustement_scale);
	gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON(spin_button), adjustement_button);
 
	g_signal_connect (scale, "value-changed", G_CALLBACK (cb_scale), spin_button);
	g_signal_connect (spin_button, "value-changed", G_CALLBACK (cb_spin_button), scale);
 
	/* Affichage de la fenetre principale */
	gtk_widget_show_all (window);
	/* parametres inutilises */
	(void)data;
}
 
int main (int argc, char **argv)
{
    GtkApplication *app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
    g_signal_connect (app, "activate", G_CALLBACK (do_activate), NULL);
 
    int status = g_application_run (G_APPLICATION (app), argc, argv);
    g_object_unref (app);
	return status;
}
A l’exécution du code les 2 widgets se synchronisent sur la valeur 75, c'est normal mais en fait ils sont verrouillés l'un sur l'autre. Le signal value-changed semble capté par les 2 widgets. Impossible de changer la valeur en bougeant les widgets.

En Vala et gtk il existe un exemple que j'ai voulu transposer en 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
using Gtk;
// valac --pkg gtk+-3.0 gtk-sync-sample.vala
 
// pour compiler en C valac --pkg gtk+-3.0 -C gtk-sync-sample.vala
 
public class SyncSample : Window {
 
    private SpinButton spin_box;
    private Scale slider;
 
    public SyncSample () {
        this.title = "Enter your age";
        this.window_position = WindowPosition.CENTER;
        this.destroy.connect (Gtk.main_quit);
        set_default_size (300, 20);
 
        spin_box = new SpinButton.with_range (0, 130, 1);
        slider = new Scale.with_range (Orientation.HORIZONTAL, 0, 130, 1);
        spin_box.adjustment.value_changed.connect (() => {
            slider.adjustment.value = spin_box.adjustment.value;
        });
        slider.adjustment.value_changed.connect (() => {
            spin_box.adjustment.value = slider.adjustment.value;
        });
        spin_box.adjustment.value = 35;
 
        var hbox = new Box (Orientation.HORIZONTAL, 5);
        hbox.homogeneous = true;
        hbox.add (spin_box);
        hbox.add (slider);
        add (hbox);
    }
 
    public static int main (string[] args) {
        Gtk.init (ref args);
 
        var window = new SyncSample ();
        window.show_all ();
 
        Gtk.main ();
        return 0;
    }
}
une compilation du code vala en C intermédiaire ne m'éclaire pas plus cf ci dessous

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
/* gtk-sync-sample.c generated by valac 0.40.8, the Vala compiler
 * generated from gtk-sync-sample.vala, do not modify */
 
 
 
#include <glib.h>
#include <glib-object.h>
#include <gtk/gtk.h>
#include <float.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
 
 
#define TYPE_SYNC_SAMPLE (sync_sample_get_type ())
#define SYNC_SAMPLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SYNC_SAMPLE, SyncSample))
#define SYNC_SAMPLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SYNC_SAMPLE, SyncSampleClass))
#define IS_SYNC_SAMPLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SYNC_SAMPLE))
#define IS_SYNC_SAMPLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SYNC_SAMPLE))
#define SYNC_SAMPLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SYNC_SAMPLE, SyncSampleClass))
 
typedef struct _SyncSample SyncSample;
typedef struct _SyncSampleClass SyncSampleClass;
typedef struct _SyncSamplePrivate SyncSamplePrivate;
enum  {
	SYNC_SAMPLE_0_PROPERTY,
	SYNC_SAMPLE_NUM_PROPERTIES
};
static GParamSpec* sync_sample_properties[SYNC_SAMPLE_NUM_PROPERTIES];
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
struct _SyncSample {
	GtkWindow parent_instance;
	SyncSamplePrivate * priv;
};
 
struct _SyncSampleClass {
	GtkWindowClass parent_class;
};
 
struct _SyncSamplePrivate {
	GtkSpinButton* spin_box;
	GtkScale* slider;
};
 
 
static gpointer sync_sample_parent_class = NULL;
 
GType sync_sample_get_type (void) G_GNUC_CONST;
#define SYNC_SAMPLE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_SYNC_SAMPLE, SyncSamplePrivate))
SyncSample* sync_sample_new (void);
SyncSample* sync_sample_construct (GType object_type);
static void _gtk_main_quit_gtk_widget_destroy (GtkWidget* _sender,
                                        gpointer self);
static void __lambda4_ (SyncSample* self);
static void ___lambda4__gtk_adjustment_value_changed (GtkAdjustment* _sender,
                                               gpointer self);
static void __lambda5_ (SyncSample* self);
static void ___lambda5__gtk_adjustment_value_changed (GtkAdjustment* _sender,
                                               gpointer self);
gint sync_sample_main (gchar** args,
                       int args_length1);
static void sync_sample_finalize (GObject * obj);
 
 
static void
_gtk_main_quit_gtk_widget_destroy (GtkWidget* _sender,
                                   gpointer self)
{
	gtk_main_quit ();
}
 
 
static void
__lambda4_ (SyncSample* self)
{
	GtkScale* _tmp0_;
	GtkAdjustment* _tmp1_;
	GtkAdjustment* _tmp2_;
	GtkSpinButton* _tmp3_;
	GtkAdjustment* _tmp4_;
	GtkAdjustment* _tmp5_;
	gdouble _tmp6_;
	gdouble _tmp7_;
	_tmp0_ = self->priv->slider;
	_tmp1_ = gtk_range_get_adjustment ((GtkRange*) _tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = self->priv->spin_box;
	_tmp4_ = gtk_spin_button_get_adjustment (_tmp3_);
	_tmp5_ = _tmp4_;
	_tmp6_ = gtk_adjustment_get_value (_tmp5_);
	_tmp7_ = _tmp6_;
	gtk_adjustment_set_value (_tmp2_, _tmp7_);
}
 
 
static void
___lambda4__gtk_adjustment_value_changed (GtkAdjustment* _sender,
                                          gpointer self)
{
	__lambda4_ ((SyncSample*) self);
}
 
 
static void
__lambda5_ (SyncSample* self)
{
	GtkSpinButton* _tmp0_;
	GtkAdjustment* _tmp1_;
	GtkAdjustment* _tmp2_;
	GtkScale* _tmp3_;
	GtkAdjustment* _tmp4_;
	GtkAdjustment* _tmp5_;
	gdouble _tmp6_;
	gdouble _tmp7_;
	_tmp0_ = self->priv->spin_box;
	_tmp1_ = gtk_spin_button_get_adjustment (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = self->priv->slider;
	_tmp4_ = gtk_range_get_adjustment ((GtkRange*) _tmp3_);
	_tmp5_ = _tmp4_;
	_tmp6_ = gtk_adjustment_get_value (_tmp5_);
	_tmp7_ = _tmp6_;
	gtk_adjustment_set_value (_tmp2_, _tmp7_);
}
 
 
static void
___lambda5__gtk_adjustment_value_changed (GtkAdjustment* _sender,
                                          gpointer self)
{
	__lambda5_ ((SyncSample*) self);
}
 
 
SyncSample*
sync_sample_construct (GType object_type)
{
	SyncSample * self = NULL;
	GtkSpinButton* _tmp0_;
	GtkScale* _tmp1_;
	GtkSpinButton* _tmp2_;
	GtkAdjustment* _tmp3_;
	GtkAdjustment* _tmp4_;
	GtkScale* _tmp5_;
	GtkAdjustment* _tmp6_;
	GtkAdjustment* _tmp7_;
	GtkSpinButton* _tmp8_;
	GtkAdjustment* _tmp9_;
	GtkAdjustment* _tmp10_;
	GtkBox* hbox = NULL;
	GtkBox* _tmp11_;
	GtkSpinButton* _tmp12_;
	GtkScale* _tmp13_;
	self = (SyncSample*) g_object_new (object_type, NULL);
	gtk_window_set_title ((GtkWindow*) self, "Enter your age");
	g_object_set ((GtkWindow*) self, "window-position", GTK_WIN_POS_CENTER, NULL);
	g_signal_connect ((GtkWidget*) self, "destroy", (GCallback) _gtk_main_quit_gtk_widget_destroy, NULL);
	gtk_window_set_default_size ((GtkWindow*) self, 300, 20);
	_tmp0_ = (GtkSpinButton*) gtk_spin_button_new_with_range ((gdouble) 0, (gdouble) 130, (gdouble) 1);
	g_object_ref_sink (_tmp0_);
	_g_object_unref0 (self->priv->spin_box);
	self->priv->spin_box = _tmp0_;
	_tmp1_ = (GtkScale*) gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, (gdouble) 0, (gdouble) 130, (gdouble) 1);
	g_object_ref_sink (_tmp1_);
	_g_object_unref0 (self->priv->slider);
	self->priv->slider = _tmp1_;
	_tmp2_ = self->priv->spin_box;
	_tmp3_ = gtk_spin_button_get_adjustment (_tmp2_);
	_tmp4_ = _tmp3_;
	g_signal_connect_object (_tmp4_, "value-changed", (GCallback) ___lambda4__gtk_adjustment_value_changed, self, 0);
	_tmp5_ = self->priv->slider;
	_tmp6_ = gtk_range_get_adjustment ((GtkRange*) _tmp5_);
	_tmp7_ = _tmp6_;
	g_signal_connect_object (_tmp7_, "value-changed", (GCallback) ___lambda5__gtk_adjustment_value_changed, self, 0);
	_tmp8_ = self->priv->spin_box;
	_tmp9_ = gtk_spin_button_get_adjustment (_tmp8_);
	_tmp10_ = _tmp9_;
	gtk_adjustment_set_value (_tmp10_, (gdouble) 35);
	_tmp11_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
	g_object_ref_sink (_tmp11_);
	hbox = _tmp11_;
	gtk_box_set_homogeneous (hbox, TRUE);
	_tmp12_ = self->priv->spin_box;
	gtk_container_add ((GtkContainer*) hbox, (GtkWidget*) _tmp12_);
	_tmp13_ = self->priv->slider;
	gtk_container_add ((GtkContainer*) hbox, (GtkWidget*) _tmp13_);
	gtk_container_add ((GtkContainer*) self, (GtkWidget*) hbox);
	_g_object_unref0 (hbox);
	return self;
}
 
 
SyncSample*
sync_sample_new (void)
{
	return sync_sample_construct (TYPE_SYNC_SAMPLE);
}
 
 
gint
sync_sample_main (gchar** args,
                  int args_length1)
{
	gint result = 0;
	SyncSample* window = NULL;
	SyncSample* _tmp0_;
	gtk_init (&args_length1, &args);
	_tmp0_ = sync_sample_new ();
	g_object_ref_sink (_tmp0_);
	window = _tmp0_;
	gtk_widget_show_all ((GtkWidget*) window);
	gtk_main ();
	result = 0;
	_g_object_unref0 (window);
	return result;
}
 
 
int
main (int argc,
      char ** argv)
{
	return sync_sample_main (argv, argc);
}
 
 
static void
sync_sample_class_init (SyncSampleClass * klass)
{
	sync_sample_parent_class = g_type_class_peek_parent (klass);
	g_type_class_add_private (klass, sizeof (SyncSamplePrivate));
	G_OBJECT_CLASS (klass)->finalize = sync_sample_finalize;
}
 
 
static void
sync_sample_instance_init (SyncSample * self)
{
	self->priv = SYNC_SAMPLE_GET_PRIVATE (self);
}
 
 
static void
sync_sample_finalize (GObject * obj)
{
	SyncSample * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_SYNC_SAMPLE, SyncSample);
	_g_object_unref0 (self->priv->spin_box);
	_g_object_unref0 (self->priv->slider);
	G_OBJECT_CLASS (sync_sample_parent_class)->finalize (obj);
}
 
 
GType
sync_sample_get_type (void)
{
	static volatile gsize sync_sample_type_id__volatile = 0;
	if (g_once_init_enter (&sync_sample_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (SyncSampleClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) sync_sample_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SyncSample), 0, (GInstanceInitFunc) sync_sample_instance_init, NULL };
		GType sync_sample_type_id;
		sync_sample_type_id = g_type_register_static (gtk_window_get_type (), "SyncSample", &g_define_type_info, 0);
		g_once_init_leave (&sync_sample_type_id__volatile, sync_sample_type_id);
	}
	return sync_sample_type_id__volatile;
}
Quel est le piège dans le lequel je suis tombé ?
merci de votre aide