IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

GTK+ avec C & C++ Discussion :

Synchroniser 2 widgets


Sujet :

GTK+ avec C & C++

  1. #1
    Membre régulier
    Profil pro
    Inscrit en
    Mars 2008
    Messages
    147
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2008
    Messages : 147
    Points : 88
    Points
    88
    Par défaut Synchroniser 2 widgets
    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

  2. #2
    Expert confirmé
    Avatar de gerald3d
    Homme Profil pro
    Conducteur de train
    Inscrit en
    Février 2008
    Messages
    2 291
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Côte d'Or (Bourgogne)

    Informations professionnelles :
    Activité : Conducteur de train
    Secteur : Transports

    Informations forums :
    Inscription : Février 2008
    Messages : 2 291
    Points : 4 941
    Points
    4 941
    Billets dans le blog
    5
    Par défaut
    Bonjour.

    Dans le callback void cb_spin_button (GtkWidget *spin_button, gpointer range); tu tournes en rond .

    Tu récupères la valeur de scale pour l'affecter à spin_button. Le problème est que comme spin_button vaut 75 tu affectes directement cette valeur. Il faut plutôt faire l'inverse. Idem pour void cb_scale (GtkWidget *scale, gpointer spin_button);.

    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
    void cb_spin_button (GtkWidget *spin_button, gpointer scale)
    {
    	g_print(" j'appelle le callback du spin bouton pour changer le scale \n");
     
    	gtk_range_set_value (GTK_RANGE(scale), gtk_spin_button_get_value (GTK_SPIN_BUTTON(spin_button)));
    	/* 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_spin_button_set_value (GTK_SPIN_BUTTON(spin_button), gtk_range_get_value (GTK_RANGE(scale)));
    	/* gtk_range_set_value (GTK_RANGE(scale), gtk_spin_button_get_value (GTK_SPIN_BUTTON(spin_button))); */
    }

  3. #3
    Membre régulier
    Profil pro
    Inscrit en
    Mars 2008
    Messages
    147
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2008
    Messages : 147
    Points : 88
    Points
    88
    Par défaut
    hello gerald3d,

    Ton œil de lynx est sans pitié. Je me suis un peu énervé sur ce sujet. Néanmoins je ne m'attendais pas à une bêtise aussi simple.

    j'ai donc suivi tes conseils à la lettre et ca fonctionne maintenant. Voici le code de test à toute fin utile. Pour ceux qui pourraient en avoir besoin;

    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
    #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_range_set_value (GTK_RANGE(range), gtk_spin_button_get_value (GTK_SPIN_BUTTON(spin_button)));
    }
    void cb_scale (GtkWidget *scale, gpointer spin_button)
    {
    	g_print(" j'appelle le callback du scale pour changer le spin bouton  \n");
    	gtk_spin_button_set_value (GTK_SPIN_BUTTON(spin_button), gtk_range_get_value (GTK_RANGE(scale)));
    }
     
    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;
    }
    Un très grand merci

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Synchronisation de thread
    Par declencher dans le forum Langage
    Réponses: 2
    Dernier message: 07/01/2004, 11h28
  2. Probleme Synchronisation modem Sagem Fast 800
    Par -PiKo- dans le forum Matériel
    Réponses: 4
    Dernier message: 03/01/2004, 16h36
  3. [SWT]Eclipse Java : swt.widgets.Table
    Par watson dans le forum SWT/JFace
    Réponses: 3
    Dernier message: 01/10/2003, 10h07
  4. Synchronisation verticale
    Par hs_dino dans le forum OpenGL
    Réponses: 2
    Dernier message: 28/09/2003, 10h35
  5. Synchronisation de base de données locale/distante Internet
    Par StefC30 dans le forum Développement
    Réponses: 3
    Dernier message: 25/07/2003, 15h47

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo