自学教程：C++ GTK_SCALE函数代码示例

intmain (int argc, char *argv[]){  GstElement *bin;  GstElement *src, *capsfilter, *equalizer, *spectrum, *audioconvert, *sink;  GstCaps *caps;  GstBus *bus;  GtkWidget *appwindow, *vbox, *hbox, *widget;  int i;  gst_init (&argc, &argv);  gtk_init (&argc, &argv);  bin = gst_pipeline_new ("bin");  /* White noise */  src = gst_element_factory_make ("audiotestsrc", "src");  g_object_set (G_OBJECT (src), "wave", 5, "volume", 0.8, NULL);  /* Force float32 samples */  capsfilter = gst_element_factory_make ("capsfilter", "capsfilter");  caps =      gst_caps_new_simple ("audio/x-raw-float", "width", G_TYPE_INT, 32, NULL);  g_object_set (capsfilter, "caps", caps, NULL);  equalizer = gst_element_factory_make ("equalizer-nbands", "equalizer");  g_object_set (G_OBJECT (equalizer), "num-bands", NBANDS, NULL);  spectrum = gst_element_factory_make ("spectrum", "spectrum");  g_object_set (G_OBJECT (spectrum), "bands", spect_bands, "threshold", -80,      "message", TRUE, "interval", 500 * GST_MSECOND, NULL);  audioconvert = gst_element_factory_make ("audioconvert", "audioconvert");  sink = gst_element_factory_make ("autoaudiosink", "sink");  gst_bin_add_many (GST_BIN (bin), src, capsfilter, equalizer, spectrum,      audioconvert, sink, NULL);  if (!gst_element_link_many (src, capsfilter, equalizer, spectrum,          audioconvert, sink, NULL)) {    fprintf (stderr, "can't link elements/n");    exit (1);  }  bus = gst_element_get_bus (bin);  gst_bus_add_watch (bus, message_handler, NULL);  gst_object_unref (bus);  appwindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);  g_signal_connect (G_OBJECT (appwindow), "destroy",      G_CALLBACK (on_window_destroy), NULL);  vbox = gtk_vbox_new (FALSE, 6);  drawingarea = gtk_drawing_area_new ();  gtk_widget_set_size_request (drawingarea, spect_bands, spect_height);  g_signal_connect (G_OBJECT (drawingarea), "configure-event",      G_CALLBACK (on_configure_event), (gpointer) spectrum);  gtk_box_pack_start (GTK_BOX (vbox), drawingarea, TRUE, TRUE, 0);  hbox = gtk_hbox_new (FALSE, 20);  for (i = 0; i < NBANDS; i++) {    GstObject *band;    gdouble freq;    gdouble bw;    gdouble gain;    gchar *label;    GtkWidget *frame, *scales_hbox;    band = gst_child_proxy_get_child_by_index (GST_CHILD_PROXY (equalizer), i);    g_assert (band != NULL);    g_object_get (G_OBJECT (band), "freq", &freq, NULL);    g_object_get (G_OBJECT (band), "bandwidth", &bw, NULL);    g_object_get (G_OBJECT (band), "gain", &gain, NULL);    label = g_strdup_printf ("%d Hz", (int) (freq + 0.5));    frame = gtk_frame_new (label);    g_free (label);    scales_hbox = gtk_hbox_new (FALSE, 6);    widget = gtk_vscale_new_with_range (-24.0, 12.0, 0.5);    gtk_scale_set_draw_value (GTK_SCALE (widget), TRUE);    gtk_scale_set_value_pos (GTK_SCALE (widget), GTK_POS_TOP);    gtk_range_set_value (GTK_RANGE (widget), gain);    gtk_widget_set_size_request (widget, 25, 150);    g_signal_connect (G_OBJECT (widget), "value-changed",        G_CALLBACK (on_gain_changed), (gpointer) band);    gtk_box_pack_start (GTK_BOX (scales_hbox), widget, FALSE, FALSE, 0);    widget = gtk_vscale_new_with_range (0.0, 20000.0, 5.0);    gtk_scale_set_draw_value (GTK_SCALE (widget), TRUE);    gtk_scale_set_value_pos (GTK_SCALE (widget), GTK_POS_TOP);    gtk_range_set_value (GTK_RANGE (widget), bw);    gtk_widget_set_size_request (widget, 25, 150);    g_signal_connect (G_OBJECT (widget), "value-changed",        G_CALLBACK (on_bandwidth_changed), (gpointer) band);    gtk_box_pack_start (GTK_BOX (scales_hbox), widget, TRUE, TRUE, 0);    widget = gtk_vscale_new_with_range (20.0, 20000.0, 5.0);//.........这里部分代码省略.........

bool wxSlider::Create(wxWindow *parent, wxWindowID id,        int value, int minValue, int maxValue,        const wxPoint& pos, const wxSize& size,        long style, const wxValidator& validator, const wxString& name ){    m_acceptsFocus = true;    m_needParent = true;    if (!PreCreation( parent, pos, size ) ||        !CreateBase( parent, id, pos, size, style, validator, name ))    {        wxFAIL_MSG( wxT("wxSlider creation failed") );        return false;    }    m_oldPos = 0.0;    if (style & wxSL_VERTICAL)        m_widget = gtk_vscale_new( NULL );    else        m_widget = gtk_hscale_new( NULL );    if (style & wxSL_LABELS)    {        gtk_scale_set_draw_value( GTK_SCALE( m_widget ), TRUE );        gtk_scale_set_digits( GTK_SCALE( m_widget ), 0 );        /* labels need more space and too small window will           cause junk to appear on the dialog */        if (style & wxSL_VERTICAL)        {            wxSize sz( size );            if (sz.x < 35)            {                sz.x = 35;                SetSize( sz );            }        }        else        {            wxSize sz( size );            if (sz.y < 35)            {                sz.y = 35;                SetSize( sz );            }        }    }    else        gtk_scale_set_draw_value( GTK_SCALE( m_widget ), FALSE );    m_adjust = gtk_range_get_adjustment( GTK_RANGE(m_widget) );    GtkEnableEvents();    gtk_signal_connect( GTK_OBJECT(m_widget),                        "button_press_event",                        (GtkSignalFunc)gtk_slider_button_press_callback,                        (gpointer) this );    gtk_signal_connect( GTK_OBJECT(m_widget),                        "button_release_event",                        (GtkSignalFunc)gtk_slider_button_release_callback,                        (gpointer) this );    SetRange( minValue, maxValue );    SetValue( value );    m_parent->DoAddChild( this );    PostCreation(size);    return true;}

GtkWidget* ctk_scale_new(GtkAdjustment *gtk_adjustment,                         const gchar *label_text,                         CtkConfig *ctk_config,                         gint value_type){    GObject *object;    CtkScale *ctk_scale;    GtkWidget *label;    GtkWidget *frame;    GtkWidget *hbox;    g_return_val_if_fail(GTK_IS_ADJUSTMENT(gtk_adjustment), NULL);    g_return_val_if_fail(label_text != NULL, NULL);    /* create and initialize the object */    object = g_object_new(CTK_TYPE_SCALE, NULL);    ctk_scale = CTK_SCALE(object);    ctk_scale->gtk_adjustment = gtk_adjustment;    ctk_scale->label = label_text;    ctk_scale->ctk_config = ctk_config;    ctk_scale->value_type = value_type;    gtk_box_set_spacing (GTK_BOX (object), 2);    /* scale label */    label = gtk_label_new(ctk_scale->label);    gtk_box_pack_start(GTK_BOX (object), label, FALSE, FALSE, 0);    gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);    /* frame around slider and text box */    frame = gtk_frame_new(NULL);    gtk_box_pack_start(GTK_BOX(object), frame, TRUE, TRUE, 0);    ctk_scale->tooltip_widget = frame;    /* hbox to contain slider and text box */    hbox = gtk_hbox_new(FALSE, 0);    gtk_container_add(GTK_CONTAINER(ctk_scale->tooltip_widget), hbox);    /* text entry */    ctk_scale->text_entry = gtk_entry_new();    gtk_entry_set_max_length(GTK_ENTRY(ctk_scale->text_entry), 6);    gtk_entry_set_width_chars(GTK_ENTRY(ctk_scale->text_entry), 6);    /* text entry container */    ctk_scale->text_entry_container = gtk_frame_new(NULL);    gtk_frame_set_shadow_type(GTK_FRAME(ctk_scale->text_entry_container),                              GTK_SHADOW_NONE);    gtk_container_set_border_width        (GTK_CONTAINER(ctk_scale->text_entry_container), 0);    gtk_container_add(GTK_CONTAINER(ctk_scale->text_entry_container),                      ctk_scale->text_entry);    ctk_scale->text_entry_packed = TRUE;    g_object_ref(G_OBJECT(ctk_scale->text_entry));    gtk_box_pack_start(GTK_BOX(hbox),                       ctk_scale->text_entry_container, FALSE, FALSE, 0);    text_entry_toggled(ctk_scale->ctk_config, (gpointer) ctk_scale);    /* wire up the adjustment events */    adjustment_value_changed(ctk_scale->gtk_adjustment, G_OBJECT(ctk_scale));    g_signal_connect(G_OBJECT(ctk_scale->gtk_adjustment), "value_changed",                     G_CALLBACK(adjustment_value_changed),                     (gpointer) ctk_scale);    g_signal_connect(G_OBJECT(ctk_scale->text_entry), "activate",                     G_CALLBACK(text_entry_activate),                     (gpointer) ctk_scale);    g_signal_connect(G_OBJECT(ctk_config), "slider_text_entry_toggled",                     G_CALLBACK(text_entry_toggled),                     (gpointer) ctk_scale);    /* the slider */    ctk_scale->gtk_scale =        gtk_hscale_new(GTK_ADJUSTMENT(ctk_scale->gtk_adjustment));    gtk_scale_set_draw_value(GTK_SCALE(ctk_scale->gtk_scale), FALSE);    gtk_scale_set_digits(GTK_SCALE(ctk_scale->gtk_scale), 0);    gtk_box_pack_start(GTK_BOX(hbox), ctk_scale->gtk_scale, TRUE, TRUE, 3);    g_signal_connect(ctk_scale->gtk_scale, "key_press_event",                     G_CALLBACK(ctk_scale_key_event), G_OBJECT(ctk_scale));//.........这里部分代码省略.........

extern voidGTKShowRolls(const gint nDepth, evalcontext * pec, matchstate * pms){    GtkWidget *vbox, *hbox, *vb2;    GtkAdjustment *padj;    int n;    rollswidget *prw = (rollswidget *) g_malloc(sizeof(rollswidget));    prw->closing = FALSE;    prw->pDialog = GTKCreateDialog(_("Distribution of rolls"), DT_INFO, NULL, DIALOG_FLAG_MODAL, NULL, NULL);    n = (nDepth < 1) ? 1 : nDepth;    prw->pms = pms;    prw->pec = pec;    prw->nDepth = -1;           /* not yet calculated */    /* vbox to hold tree widget and buttons */    vbox = gtk_vbox_new(FALSE, 8);    gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);    gtk_container_add(GTK_CONTAINER(DialogArea(prw->pDialog, DA_MAIN)), vbox);    /* hook to free rollswidget on widget destruction */    g_object_set_data_full(G_OBJECT(vbox), "rollswidget", prw, g_free);    /* scrolled window to hold tree widget */    prw->psw = gtk_scrolled_window_new(NULL, NULL);    gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(prw->psw), GTK_SHADOW_ETCHED_IN);    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(prw->psw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);    gtk_box_pack_start(GTK_BOX(vbox), prw->psw, TRUE, TRUE, 0);    /* buttons */    gtk_box_pack_start(GTK_BOX(vbox), gtk_hseparator_new(), FALSE, FALSE, 0);    hbox = gtk_hbox_new(FALSE, 0);    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 4);    gtk_box_pack_start(GTK_BOX(hbox), gtk_label_new(_("Depth")), FALSE, FALSE, 4);    /* Set page size to 1 */    padj = GTK_ADJUSTMENT(gtk_adjustment_new(1., 1., 5., 1., 1., 0.));    prw->pScale = gtk_hscale_new(padj);    gtk_widget_set_size_request(prw->pScale, 100, -1);    gtk_box_pack_start(GTK_BOX(hbox), prw->pScale, FALSE, FALSE, 4);    gtk_scale_set_digits(GTK_SCALE(prw->pScale), 0);    gtk_scale_set_draw_value(GTK_SCALE(prw->pScale), TRUE);    /* Separate vbox to make button height correct */    vb2 = gtk_vbox_new(FALSE, 0);    gtk_box_pack_start(GTK_BOX(hbox), vb2, FALSE, FALSE, 4);    prw->pCancel = gtk_button_new_with_label(_("Cancel"));    gtk_widget_set_size_request(prw->pCancel, -1, 27);    gtk_widget_set_sensitive(prw->pCancel, FALSE);    g_signal_connect(G_OBJECT(prw->pCancel), "clicked", G_CALLBACK(CancelRolls), NULL);    gtk_box_pack_start(GTK_BOX(vb2), prw->pCancel, FALSE, FALSE, 4);    g_signal_connect(G_OBJECT(prw->pScale), "button-press-event", G_CALLBACK(DepthEvent), prw);    g_signal_connect(G_OBJECT(prw->pScale), "button-release-event", G_CALLBACK(DepthEvent), prw);    g_signal_connect(G_OBJECT(prw->pScale), "value-changed", G_CALLBACK(DepthChanged), prw);    /* tree  */    if ((prw->ptv = RollsTree(n, pec, pms)) != 0) {        gtk_container_add(GTK_CONTAINER(prw->psw), prw->ptv);        prw->nDepth = n;    }    gtk_window_set_default_size(GTK_WINDOW(prw->pDialog), 560, 400);    g_signal_connect(G_OBJECT(prw->pDialog), "delete_event", G_CALLBACK(RollsClose), prw);      /* In case closed mid calculation */    GTKRunDialog(prw->pDialog);}

GtkWidget *scale_create_widget (GtkWidget * dlg){  GtkWidget *w;  GtkAdjustment *adj;  gint page;  if (options.scale_data.min_value >= options.scale_data.max_value)    {      g_printerr (_("Maximum value must be greater than minimum value./n"));      return NULL;    }  /* check for initial value */  if (options.scale_data.have_value)    {      if (options.scale_data.value < options.scale_data.min_value)        {          g_printerr (_("Initial value less than minimal./n"));          options.scale_data.value = options.scale_data.min_value;        }      else if (options.scale_data.value > options.scale_data.max_value)        {          g_printerr (_("Initial value greater than maximum./n"));          options.scale_data.value = options.scale_data.max_value;        }    }  else    options.scale_data.value = options.scale_data.min_value;  page = options.scale_data.page == -1 ? options.scale_data.step * 10 : options.scale_data.page;  /* this type conversion needs only for gtk-2.0 */  adj = (GtkAdjustment *) gtk_adjustment_new ((double) options.scale_data.value,                                              (double) options.scale_data.min_value,                                              (double) options.scale_data.max_value,                                              (double) options.scale_data.step,                                              (double) page,                                              0.0);  if (options.common_data.vertical)    {#if GTK_CHECK_VERSION(3,0,0)      scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adj));#else      scale = gtk_vscale_new (GTK_ADJUSTMENT (adj));#endif      gtk_range_set_inverted (GTK_RANGE (scale), !options.scale_data.invert);    }  else    {#if GTK_CHECK_VERSION(3,0,0)      scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adj));#else      scale = gtk_hscale_new (GTK_ADJUSTMENT (adj));#endif      gtk_range_set_inverted (GTK_RANGE (scale), options.scale_data.invert);    }  gtk_widget_set_name (scale, "yad-scale-widget");  gtk_scale_set_digits (GTK_SCALE (scale), 0);  if (options.scale_data.hide_value)    gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);  /* add marks */  if (options.scale_data.marks)    {      GtkPositionType pos;      GSList *m = options.scale_data.marks;      pos = options.common_data.vertical ? GTK_POS_LEFT : GTK_POS_BOTTOM;      for (; m; m = m->next)        {          YadScaleMark *mark = (YadScaleMark *) m->data;          gtk_scale_add_mark (GTK_SCALE (scale), mark->value, pos, mark->name);        }    }  /* create container */  if (options.common_data.vertical)    {#if GTK_CHECK_VERSION(3,0,0)      w = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1);#else      w = gtk_vbox_new (FALSE, 1);#endif    }  else    {#if GTK_CHECK_VERSION(3,0,0)      w = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1);#else      w = gtk_hbox_new (FALSE, 1);#endif    }  /* create buttons */  if (options.scale_data.buttons)    {      minus_btn = gtk_button_new_with_label ("-");      gtk_button_set_relief (GTK_BUTTON (minus_btn), GTK_RELIEF_NONE);      g_signal_connect (G_OBJECT (minus_btn), "clicked", G_CALLBACK (vb_pressed), GINT_TO_POINTER (MINUS_BTN));//.........这里部分代码省略.........

gboolean show_mixer(GtkWidget *widget, GdkEvent  *event, gpointer user_data){  GtkWidget *win = gtk_window_new(GTK_WINDOW_TOPLEVEL);  gtk_window_set_title(GTK_WINDOW(win), "SIDE Mixer");  gtk_container_set_border_width(GTK_CONTAINER(win), 10);  gtk_window_resize(GTK_WINDOW(win), 150, 300);  GdkScreen *screen = gdk_screen_get_default();  fwin = win;  g_timeout_add(100, check_focus, win);  GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);  GtkWidget *dsc = gtk_label_new("master");  GtkAdjustment *adj = gtk_adjustment_new(50, 0, 100, 5, 0, 0);  g_signal_connect(G_OBJECT(adj), "value-changed", G_CALLBACK(set_volume), NULL);  GtkWidget     *scl = gtk_scale_new(GTK_ORIENTATION_VERTICAL, adj);  gtk_scale_set_draw_value(GTK_SCALE(scl), FALSE);  s_mute = gtk_toggle_button_new_with_label("mute");  g_signal_connect(G_OBJECT(s_mute), "toggled", G_CALLBACK(set_mute), (gpointer) adj);  gtk_box_pack_end(GTK_BOX(box), s_mute, FALSE, FALSE, 0);  gtk_container_add(GTK_CONTAINER(box), dsc);  gtk_box_pack_end(GTK_BOX(box), scl, TRUE, TRUE, 5);    int x, y;    gtk_window_get_size(GTK_WINDOW(win), &x, &y);    gtk_window_set_decorated(GTK_WINDOW(win), FALSE);    gtk_window_move(GTK_WINDOW(win), gdk_screen_get_width(screen), gdk_screen_get_height(screen) - (y+25));  gtk_container_add(GTK_CONTAINER(win), box);  gtk_widget_show_all(win);  snd_mixer_t *mix;  snd_mixer_selem_id_t *sid;  const char *card = "default";  const char *selem_name = "Master";  long val, max, min;  snd_mixer_open(&mix, 0);  snd_mixer_attach(mix, card);  snd_mixer_selem_register(mix, NULL, NULL);  snd_mixer_load(mix);  snd_mixer_selem_id_alloca(&sid);  snd_mixer_selem_id_set_index(sid, 0);  snd_mixer_selem_id_set_name(sid, selem_name);  snd_mixer_elem_t* elem = snd_mixer_find_selem(mix, sid);  snd_mixer_selem_get_playback_volume_range(elem, &min, &max);  snd_mixer_selem_get_playback_volume(elem, SND_MIXER_SCHN_MONO  , &val);  gtk_adjustment_set_value(adj, 100 - (int)  100 * val / max);  snd_mixer_close(mix);  return FALSE;}

GtkWidget*create_volume_window (void){	accel_group = gtk_accel_group_new ();	volume_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);	gtk_widget_set_size_request (volume_window, 60, 240);	gtk_container_set_border_width (GTK_CONTAINER (volume_window), 2);	gtk_window_set_resizable (GTK_WINDOW (volume_window), FALSE);	gtk_window_set_position (GTK_WINDOW (volume_window), GTK_WIN_POS_MOUSE);	gtk_window_set_decorated (GTK_WINDOW (volume_window), FALSE);	gtk_window_set_skip_taskbar_hint( GTK_WINDOW (volume_window), TRUE );	frame = gtk_frame_new (_("Volume"));	vbox1 = gtk_vbox_new (FALSE, 0);	gtk_widget_show (vbox1);	gtk_container_add (GTK_CONTAINER (frame), vbox1);	gtk_container_add (GTK_CONTAINER (volume_window), frame);	gtk_widget_show (frame);	vol_adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (1, 0, 100, 1, 10, 0));	/* get original adjustments */	get_current_levels();	hbox1 = gtk_hbox_new (FALSE, 0);	gtk_widget_show (hbox1);	gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, TRUE, 8);	/* ajustment, climb rate, digits */	spinbutton1 = gtk_spin_button_new (GTK_ADJUSTMENT (vol_adjustment), 1, 0);	gtk_widget_show (spinbutton1);	gtk_box_pack_start (GTK_BOX (hbox1), spinbutton1, TRUE, FALSE, 0);	gtk_widget_set_size_request (spinbutton1, -1, 22);	g_signal_connect ((gpointer) spinbutton1, "value_changed",			  G_CALLBACK (on_spinbutton1_button_release_event),			  NULL);	g_object_set_data_full(G_OBJECT (volume_window), "spinbutton1", 			       gtk_widget_ref (spinbutton1),			       (GDestroyNotify) gtk_widget_unref);	hbox3 = gtk_hbox_new (FALSE, 0);	gtk_widget_show (hbox3);	gtk_box_pack_start (GTK_BOX (vbox1), hbox3, TRUE, TRUE, 5);	vscale1 = gtk_vscale_new (GTK_ADJUSTMENT (vol_adjustment));	gtk_widget_show (vscale1);	gtk_range_set_inverted (GTK_RANGE (vscale1), TRUE);	gtk_box_pack_start (GTK_BOX (hbox3), vscale1, TRUE, TRUE, 0);	gtk_scale_set_draw_value (GTK_SCALE (vscale1), FALSE);	g_signal_connect ((gpointer) vscale1, "button_release_event",			  G_CALLBACK (on_vscale1_button_release_event),			  vol_adjustment);	g_object_set_data_full(G_OBJECT (volume_window), "vscale1",			       gtk_widget_ref (vscale1),			       (GDestroyNotify) gtk_widget_unref);	hbox4 = gtk_hbox_new (FALSE, 0);	gtk_widget_show (hbox4);	gtk_box_pack_start (GTK_BOX (vbox1), hbox4, FALSE, TRUE, 8);	g_signal_connect ((gpointer) volume_window, "destroy",			  G_CALLBACK (gtk_widget_destroy),			  NULL);	g_object_set_data (G_OBJECT (volume_window), "volume_window", volume_window);	g_object_set_data_full (G_OBJECT (volume_window), "frame",			        gtk_widget_ref (frame), 				(GDestroyNotify) gtk_widget_unref);	g_object_set_data_full (G_OBJECT (volume_window), "vbox1",			        gtk_widget_ref (vbox1), 				(GDestroyNotify) gtk_widget_unref);	g_object_set_data_full (G_OBJECT (volume_window), "hbox1",			        gtk_widget_ref (hbox1), 				(GDestroyNotify) gtk_widget_unref);	g_object_set_data_full (G_OBJECT (volume_window), "hbox3",			        gtk_widget_ref (hbox3), 				(GDestroyNotify) gtk_widget_unref);	g_object_set_data_full (G_OBJECT (volume_window), "hbox4",			        gtk_widget_ref (hbox4), 				(GDestroyNotify) gtk_widget_unref);	gtk_window_add_accel_group (GTK_WINDOW (volume_window), accel_group);	vol_spin = spinbutton1;	return volume_window;}

GtkWidget*create_dialog1 (void){  GtkWidget *dialog1;  GtkWidget *dialog_vbox1;  GtkWidget *vbox1;  GtkWidget *hbox1;  GtkWidget *frame1;  GtkWidget *table2;  GtkWidget *label4;  GtkWidget *label5;  GtkWidget *hscaleBrightness;  GtkWidget *hscaleSaturation;  GtkWidget *hscaleContrast;  GtkWidget *label3;  GtkWidget *label1;  GtkWidget *frame2;  GtkWidget *table3;  GtkWidget *label6;  GtkWidget *hscaleGamma;  GtkWidget *hscaleGammaR;  GtkWidget *label8;  GtkWidget *hscaleGammaG;  GtkWidget *label9;  GtkWidget *label10;  GtkWidget *label7;  GtkWidget *hscaleGammaB;  GtkWidget *hscaleGammaWeight;  GtkWidget *label2;  GtkWidget *hscale1;  GtkWidget *drawingarea1;  GtkWidget *dialog_action_area1;  GtkWidget *cancelbutton1;  GtkWidget *okbutton1;  dialog1 = gtk_dialog_new ();  gtk_container_set_border_width (GTK_CONTAINER (dialog1), 6);  gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("MPlayer eq2"));  gtk_window_set_resizable (GTK_WINDOW (dialog1), FALSE);  dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;  gtk_widget_show (dialog_vbox1);  vbox1 = gtk_vbox_new (FALSE, 0);  gtk_widget_show (vbox1);  gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);  hbox1 = gtk_hbox_new (FALSE, 0);  gtk_widget_show (hbox1);  gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 0);  frame1 = gtk_frame_new (NULL);  gtk_widget_show (frame1);  gtk_box_pack_start (GTK_BOX (hbox1), frame1, TRUE, TRUE, 0);  gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_NONE);  table2 = gtk_table_new (3, 2, FALSE);  gtk_widget_show (table2);  gtk_container_add (GTK_CONTAINER (frame1), table2);  gtk_container_set_border_width (GTK_CONTAINER (table2), 12);  gtk_table_set_row_spacings (GTK_TABLE (table2), 6);  gtk_table_set_col_spacings (GTK_TABLE (table2), 12);  label4 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Brigh_tness:"));  gtk_widget_show (label4);  gtk_table_attach (GTK_TABLE (table2), label4, 0, 1, 1, 2,                    (GtkAttachOptions) (GTK_FILL),                    (GtkAttachOptions) (0), 0, 0);  gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT);  gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);  label5 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Saturation:"));  gtk_widget_show (label5);  gtk_table_attach (GTK_TABLE (table2), label5, 0, 1, 2, 3,                    (GtkAttachOptions) (GTK_FILL),                    (GtkAttachOptions) (0), 0, 0);  gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_LEFT);  gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5);  hscaleBrightness = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, -1, 1, 0.05, 1, 0)));  gtk_widget_show (hscaleBrightness);  gtk_table_attach (GTK_TABLE (table2), hscaleBrightness, 1, 2, 1, 2,                    (GtkAttachOptions) (GTK_FILL),                    (GtkAttachOptions) (GTK_FILL), 0, 0);  gtk_widget_set_size_request (hscaleBrightness, 144, 0);  gtk_scale_set_value_pos (GTK_SCALE (hscaleBrightness), GTK_POS_RIGHT);  gtk_scale_set_digits (GTK_SCALE (hscaleBrightness), 2);  hscaleSaturation = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0, 3, 0.05, 1, 0)));  gtk_widget_show (hscaleSaturation);  gtk_table_attach (GTK_TABLE (table2), hscaleSaturation, 1, 2, 2, 3,                    (GtkAttachOptions) (GTK_FILL),                    (GtkAttachOptions) (GTK_FILL), 0, 0);  gtk_widget_set_size_request (hscaleSaturation, 144, 0);  gtk_scale_set_value_pos (GTK_SCALE (hscaleSaturation), GTK_POS_RIGHT);  gtk_scale_set_digits (GTK_SCALE (hscaleSaturation), 2);  hscaleContrast = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, -2, 2, 0.05, 1, 0)));  gtk_widget_show (hscaleContrast);  gtk_table_attach (GTK_TABLE (table2), hscaleContrast, 1, 2, 0, 1,//.........这里部分代码省略.........

GtkWidget*create_dialog1 (void){  GtkWidget *dialog1;  GtkWidget *dialog_vbox1;  GtkWidget *vbox1;  GtkWidget *hbox1;  GtkWidget *label1;  GtkObject *spinbutton1_adj;  GtkWidget *spinbutton1;  GtkWidget *hscale1;  GtkWidget *hbox2;  GtkWidget *drawingarea1;  GtkWidget *vscale1;  GtkWidget *dialog_action_area1;  GtkWidget *cancelbutton1;  GtkWidget *okbutton1;  dialog1 = gtk_dialog_new ();  gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("Subtitle Size and Position"));  gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG);  dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;  gtk_widget_show (dialog_vbox1);  vbox1 = gtk_vbox_new (FALSE, 0);  gtk_widget_show (vbox1);  gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);  hbox1 = gtk_hbox_new (FALSE, 0);  gtk_widget_show (hbox1);  gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 0);  label1 = gtk_label_new (QT_TR_NOOP("Font Size:"));  gtk_widget_show (label1);  gtk_box_pack_start (GTK_BOX (hbox1), label1, FALSE, FALSE, 0);  spinbutton1_adj = gtk_adjustment_new (1, 6, 99, 1, 10, 10);  spinbutton1 = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton1_adj), 1, 2);  gtk_widget_show (spinbutton1);  gtk_box_pack_start (GTK_BOX (hbox1), spinbutton1, FALSE, FALSE, 0);  gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton1), TRUE);  hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 99, 1, 1, 1)));  gtk_widget_show (hscale1);  gtk_box_pack_start (GTK_BOX (vbox1), hscale1, FALSE, FALSE, 0);  hbox2 = gtk_hbox_new (FALSE, 0);  gtk_widget_show (hbox2);  gtk_box_pack_start (GTK_BOX (vbox1), hbox2, TRUE, TRUE, 0);  drawingarea1 = gtk_drawing_area_new ();  gtk_widget_show (drawingarea1);  gtk_box_pack_start (GTK_BOX (hbox2), drawingarea1, TRUE, TRUE, 0);  vscale1 = gtk_vscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 100, 1, 1, 1, 1)));  gtk_widget_show (vscale1);  gtk_box_pack_start (GTK_BOX (hbox2), vscale1, FALSE, FALSE, 0);  gtk_scale_set_digits (GTK_SCALE (vscale1), 0);  dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;  gtk_widget_show (dialog_action_area1);  gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);  cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");  gtk_widget_show (cancelbutton1);  gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL);  GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);  okbutton1 = gtk_button_new_from_stock ("gtk-ok");  gtk_widget_show (okbutton1);  gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK);  GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);  /* Store pointers to all widgets, for use by lookup_widget(). */  GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1");  GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");  GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1");  GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1");  GLADE_HOOKUP_OBJECT (dialog1, label1, "label1");  GLADE_HOOKUP_OBJECT (dialog1, spinbutton1, "spinbutton1");  GLADE_HOOKUP_OBJECT (dialog1, hscale1, "hscale1");  GLADE_HOOKUP_OBJECT (dialog1, hbox2, "hbox2");  GLADE_HOOKUP_OBJECT (dialog1, drawingarea1, "drawingarea1");  GLADE_HOOKUP_OBJECT (dialog1, vscale1, "vscale1");  GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");  GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1");  GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");  return dialog1;}

//.........这里部分代码省略.........	gtk_widget_show(vbox3);	gtk_container_add(GTK_CONTAINER(Downsample_Frame), vbox3);	Sample_44 = gtk_radio_button_new_with_label(sample_group, "44 kHz");	sample_group = gtk_radio_button_group(GTK_RADIO_BUTTON(Sample_44));	gtk_object_set_data(GTK_OBJECT(xmp_conf_window),"Sample_44", Sample_44);	gtk_widget_show(Sample_44);	gtk_box_pack_start(GTK_BOX(vbox3), Sample_44, TRUE, TRUE, 0);	if (xmp_cfg.mixing_freq == FREQ_SAMPLE_44)		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(Sample_44),TRUE);	Sample_22 = gtk_radio_button_new_with_label(sample_group, "22 kHz");	sample_group = gtk_radio_button_group(GTK_RADIO_BUTTON(Sample_22));	gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "Sample_22",Sample_22);	gtk_widget_show(Sample_22);	gtk_box_pack_start(GTK_BOX(vbox3), Sample_22, TRUE, TRUE, 0);	if (xmp_cfg.mixing_freq == FREQ_SAMPLE_22)		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(Sample_22),TRUE);	Sample_11 = gtk_radio_button_new_with_label(sample_group, "11 kHz");	sample_group = gtk_radio_button_group(GTK_RADIO_BUTTON(Sample_11));	gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "Sample_11",Sample_11);	gtk_widget_show(Sample_11);	gtk_box_pack_start(GTK_BOX(vbox3), Sample_11, TRUE, TRUE, 0);	if (xmp_cfg.mixing_freq == FREQ_SAMPLE_11)		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(Sample_11),TRUE);	vbox6 = gtk_vbox_new(FALSE, 0);	gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "vbox6", vbox6);	gtk_widget_show(vbox6);	/* Options */#define OPTCHECK(w,l,o) {						/	w = gtk_check_button_new_with_label(l);				/	gtk_object_set_data(GTK_OBJECT(xmp_conf_window), #w, w);	/	gtk_widget_show(w);						/	gtk_box_pack_start(GTK_BOX(vbox6), w, TRUE, TRUE, 0);		/	if (xmp_cfg.o == 1)						/		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), TRUE); /}	OPTCHECK(Convert_Check, "Convert 16 bit samples to 8 bit", convert8bit);	OPTCHECK(Fixloops_Check, "Fix sample loops", fixloops);	OPTCHECK(Modrange_Check, "Force 3 octave range in standard MOD files",		modrange);	OPTCHECK(Interp_Check, "Enable 32-bit linear interpolation",		interpolation);	OPTCHECK(Filter_Check, "Enable IT filters", filter);	pansep_label = gtk_label_new("Pan amplitude (%)");	gtk_widget_show(pansep_label);	gtk_box_pack_start(GTK_BOX(vbox6), pansep_label, TRUE, TRUE, 0);	pansep_adj = gtk_adjustment_new(xmp_cfg.pan_amplitude,		0.0, 100.0, 1.0, 10.0, 1.0);	pansep_hscale = gtk_hscale_new(GTK_ADJUSTMENT(pansep_adj));	gtk_scale_set_digits(GTK_SCALE(pansep_hscale), 0);	gtk_scale_set_draw_value(GTK_SCALE(pansep_hscale), TRUE);	gtk_scale_set_value_pos(GTK_SCALE(pansep_hscale), GTK_POS_BOTTOM);	gtk_widget_show(pansep_hscale);	gtk_box_pack_start(GTK_BOX(vbox6), pansep_hscale, TRUE, TRUE, 0);	Quality_Label = gtk_label_new("Quality");	gtk_object_set_data(GTK_OBJECT(xmp_conf_window),		"Quality_Label", Quality_Label);	gtk_widget_show(Quality_Label);	gtk_notebook_append_page(GTK_NOTEBOOK(notebook1), vbox1, Quality_Label);	Options_Label = gtk_label_new("Options");	gtk_object_set_data(GTK_OBJECT(xmp_conf_window),		"Options_Label", Options_Label);	gtk_widget_show(Options_Label);	gtk_notebook_append_page(GTK_NOTEBOOK(notebook1), vbox6, Options_Label);	bbox = gtk_hbutton_box_new();	gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);	gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);	gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);	ok = gtk_button_new_with_label("Ok");	gtk_signal_connect(GTK_OBJECT(ok), "clicked",		GTK_SIGNAL_FUNC(config_ok), NULL);	GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);	gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0);	gtk_widget_show(ok);	gtk_widget_grab_default(ok);	cancel = gtk_button_new_with_label("Cancel");	gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked",		GTK_SIGNAL_FUNC(gtk_widget_destroy),		GTK_OBJECT(xmp_conf_window));	GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);	gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0);	gtk_widget_show(cancel);	gtk_widget_show(bbox);	gtk_widget_show(vbox);	gtk_widget_show(xmp_conf_window);}

GtkWidget*create_dialog1 (void){  GtkWidget *dialog1;  GtkWidget *dialog_vbox1;  GtkWidget *vbox1;  GtkWidget *accellabel1;  GtkWidget *hscale1;  GtkWidget *label1;  GtkWidget *hscale2;  GtkWidget *dialog_action_area1;  GtkWidget *hbox1;  GtkWidget *button_ok;  GtkWidget *button_ko;  GtkWidget *button_preview;  dialog1 = gtk_dialog_new ();  gtk_object_set_data (GTK_OBJECT (dialog1), "dialog1", dialog1);  gtk_window_set_title (GTK_WINDOW (dialog1), "Clean smoother");  gtk_window_set_policy (GTK_WINDOW (dialog1), TRUE, TRUE, FALSE);   gtk_window_set_modal(GTK_WINDOW(dialog1), TRUE);  dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;  gtk_object_set_data (GTK_OBJECT (dialog1), "dialog_vbox1", dialog_vbox1);  gtk_widget_show (dialog_vbox1);  vbox1 = gtk_vbox_new (FALSE, 0);  gtk_widget_ref (vbox1);  gtk_object_set_data_full (GTK_OBJECT (dialog1), "vbox1", vbox1,                            (GtkDestroyNotify) gtk_widget_unref);  gtk_widget_show (vbox1);  gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);  accellabel1 = gtk_accel_label_new ("Diameter");  gtk_widget_ref (accellabel1);  gtk_object_set_data_full (GTK_OBJECT (dialog1), "accellabel1", accellabel1,                            (GtkDestroyNotify) gtk_widget_unref);  gtk_widget_show (accellabel1);  gtk_box_pack_start (GTK_BOX (vbox1), accellabel1, FALSE, FALSE, 0);  radius_adj=gtk_adjustment_new (2, 2, 10, 1, 1, 1);  hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (radius_adj));  gtk_widget_ref (hscale1);  gtk_object_set_data_full (GTK_OBJECT (dialog1), "hscale1", hscale1,                            (GtkDestroyNotify) gtk_widget_unref);  gtk_widget_show (hscale1);  gtk_box_pack_start (GTK_BOX (vbox1), hscale1, TRUE, TRUE, 0);  gtk_scale_set_digits(GTK_SCALE(hscale1),0);  label1 = gtk_label_new ("Blend amount");  gtk_widget_ref (label1);  gtk_object_set_data_full (GTK_OBJECT (dialog1), "label1", label1,                            (GtkDestroyNotify) gtk_widget_unref);  gtk_widget_show (label1);  gtk_box_pack_start (GTK_BOX (vbox1), label1, FALSE, FALSE, 0);  blend_adj= gtk_adjustment_new (1, 1, 10, 1, 1, 1);  hscale2 = gtk_hscale_new (GTK_ADJUSTMENT (blend_adj));  gtk_widget_ref (hscale2);  gtk_object_set_data_full (GTK_OBJECT (dialog1), "hscale2", hscale2,                            (GtkDestroyNotify) gtk_widget_unref);   gtk_scale_set_digits(GTK_SCALE(hscale2),0);  gtk_widget_show (hscale2);  gtk_box_pack_start (GTK_BOX (vbox1), hscale2, TRUE, TRUE, 0);  dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;  gtk_object_set_data (GTK_OBJECT (dialog1), "dialog_action_area1", dialog_action_area1);  gtk_widget_show (dialog_action_area1);  gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area1), 10);  hbox1 = gtk_hbox_new (FALSE, 0);  gtk_widget_ref (hbox1);  gtk_object_set_data_full (GTK_OBJECT (dialog1), "hbox1", hbox1,                            (GtkDestroyNotify) gtk_widget_unref);  gtk_widget_show (hbox1);  gtk_box_pack_start (GTK_BOX (dialog_action_area1), hbox1, TRUE, TRUE, 0);  button_ok = gtk_button_new_with_label ("OK");  gtk_widget_ref (button_ok);  gtk_object_set_data_full (GTK_OBJECT (dialog1), "button_ok", button_ok,                            (GtkDestroyNotify) gtk_widget_unref);  gtk_widget_show (button_ok);  gtk_box_pack_start (GTK_BOX (hbox1), button_ok, FALSE, FALSE, 0);  button_ko = gtk_button_new_with_label ("Cancel");  gtk_widget_ref (button_ko);  gtk_object_set_data_full (GTK_OBJECT (dialog1), "button_ko", button_ko,                            (GtkDestroyNotify) gtk_widget_unref);  gtk_widget_show (button_ko);  gtk_box_pack_start (GTK_BOX (hbox1), button_ko, FALSE, FALSE, 0);  button_preview = gtk_button_new_with_label ("Preview");  gtk_widget_ref (button_preview);  gtk_object_set_data_full (GTK_OBJECT (dialog1), "button_preview", button_preview,                            (GtkDestroyNotify) gtk_widget_unref);  gtk_widget_show (button_preview);  gtk_box_pack_start (GTK_BOX (hbox1), button_preview, TRUE, FALSE, 0);//.........这里部分代码省略.........

spin_button_ctx_t *time_scrollbar_new(void){    GtkObject *adj_msec;    GtkObject *adj_sec;    GtkObject *adj_min;    GtkObject *adj_scale;    GtkWidget *scale;    GtkWidget *spin_msec;    GtkWidget *spin_sec;    GtkWidget *spin_min;    GtkWidget *hbox;    GtkWidget *vbox;    spin_button_ctx_t *sbctx;    sbctx = (spin_button_ctx_t *) calloc(1, sizeof(spin_button_ctx_t));    vbox = gtk_vbox_new(FALSE, 4);    sbctx->time_scrollbar = vbox;    hbox = gtk_hbox_new(FALSE, 4);    gtk_widget_show(hbox);    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);       adj_msec  = gtk_adjustment_new(0.0, -1.0, 1000.0, 1.0, 1.0, 1.0);    adj_sec   = gtk_adjustment_new(0.0, -1.0, 60.0,   1.0, 1.0, 1.0);    adj_min   = gtk_adjustment_new(0.0, 0.0,  99.0,   1.0, 1.0, 1.0);    adj_scale = gtk_adjustment_new(0.0, 0.0,  100.0*60*1000, 5.0, 5.0, 1.0);    spin_min = gtk_spin_button_new(GTK_ADJUSTMENT(adj_min), 1.0, 0);    gtk_widget_show(spin_min);    spin_sec = gtk_spin_button_new(GTK_ADJUSTMENT(adj_sec), 1.0, 0);    gtk_widget_show(spin_sec);    spin_msec = gtk_spin_button_new(GTK_ADJUSTMENT(adj_msec), 1.0, 0);    gtk_widget_show(spin_msec);        scale = gtk_hscale_new_with_range(0.0, 100.0, 1.0);    gtk_widget_show(scale);    gtk_range_set_adjustment(GTK_RANGE(scale), GTK_ADJUSTMENT(adj_scale));    gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_DELAYED);    gtk_scale_set_draw_value(GTK_SCALE(scale), FALSE);    gtk_box_pack_start(GTK_BOX(hbox), spin_min,  FALSE, TRUE, 2);    gtk_box_pack_start(GTK_BOX(hbox), spin_sec,  FALSE, TRUE, 2);    gtk_box_pack_start(GTK_BOX(hbox), spin_msec, FALSE, TRUE, 2);    gtk_box_pack_start(GTK_BOX(vbox), scale,     FALSE, TRUE, 2);    sbctx->spin_min  = GTK_SPIN_BUTTON(spin_min);    sbctx->spin_sec  = GTK_SPIN_BUTTON(spin_sec);    sbctx->spin_msec = GTK_SPIN_BUTTON(spin_msec);    sbctx->scale     = GTK_SCALE(scale);    sbctx->adj_min   = GTK_ADJUSTMENT(adj_min);    sbctx->adj_sec   = GTK_ADJUSTMENT(adj_sec);    sbctx->adj_msec  = GTK_ADJUSTMENT(adj_msec);    sbctx->adj_scale = GTK_ADJUSTMENT(adj_scale);    g_signal_connect(G_OBJECT(spin_msec), "value-changed",                      G_CALLBACK(cb_block_scale), sbctx);    sbctx->hmsec = g_signal_connect(G_OBJECT(spin_msec), "value-changed",                      G_CALLBACK(cb_spin_msec), sbctx);    g_signal_connect(G_OBJECT(spin_msec), "value-changed",                      G_CALLBACK(cb_unblock_scale), sbctx);    g_signal_connect(G_OBJECT(spin_sec), "value-changed",                      G_CALLBACK(cb_block_scale), sbctx);    sbctx->hsec = g_signal_connect(G_OBJECT(spin_sec), "value-changed",                      G_CALLBACK(cb_spin_sec), sbctx);    g_signal_connect(G_OBJECT(spin_sec), "value-changed",                      G_CALLBACK(cb_unblock_scale), sbctx);    g_signal_connect(G_OBJECT(spin_min), "value-changed",                      G_CALLBACK(cb_block_scale), sbctx);    sbctx->hmin = g_signal_connect(G_OBJECT(spin_min), "value-changed",                      G_CALLBACK(cb_spin_min), sbctx);    g_signal_connect(G_OBJECT(spin_min), "value-changed",                      G_CALLBACK(cb_unblock_scale), sbctx);    g_signal_connect(G_OBJECT(scale), "value-changed",                      G_CALLBACK(cb_block_spinners), sbctx);    sbctx->hscale = g_signal_connect(G_OBJECT(scale), "value-changed",                      G_CALLBACK(cb_scale), sbctx);    g_signal_connect(G_OBJECT(scale), "value-changed",                      G_CALLBACK(cb_unblock_spinners), sbctx);    return sbctx;}

GtkWidget*create_threshold_dialog (void){  GtkWidget *threshold_dialog;  GtkWidget *dialogVbox;  GtkWidget *allButButtonsVbox;  GtkWidget *settingsOuterHbox;  GtkWidget *settingsOuterVbox;  GtkWidget *minValueVbox;  GtkWidget *minValueLabel;  GtkWidget *minValueHbox;  GtkWidget *minValueSlider;  GtkObject *minValueSpinner_adj;  GtkWidget *minValueSpinner;  GtkWidget *maxValueVbox;  GtkWidget *maxValueLabel;  GtkWidget *maxValueHbox;  GtkWidget *maxValueSlider;  GtkObject *maxValueSpinner_adj;  GtkWidget *maxValueSpinner;  GtkWidget *outputValuesHbox;  GtkWidget *outputValuesLabel;  GtkWidget *outputValuesMenu;  GtkWidget *debugHbox;  GtkWidget *debugLabel;  GtkObject *debugSpinButton_adj;  GtkWidget *debugSpinButton;  GtkWidget *previewFrame;  GtkWidget *previewAlignment;  GtkWidget *previewVbox;  GtkWidget *previewControlHbox;  GtkWidget *previewOutputMenu;  GtkWidget *previewSlider;  GtkWidget *previewVideo;  GtkWidget *previewLabel;  GtkWidget *dialogButtonBox;  GtkWidget *cancelButton;  GtkWidget *okButton;  threshold_dialog = gtk_dialog_new ();  gtk_window_set_title (GTK_WINDOW (threshold_dialog), QT_TR_NOOP("Threshold"));  gtk_window_set_type_hint (GTK_WINDOW (threshold_dialog), GDK_WINDOW_TYPE_HINT_DIALOG);  dialogVbox = GTK_DIALOG (threshold_dialog)->vbox;  gtk_widget_show (dialogVbox);  allButButtonsVbox = gtk_vbox_new (FALSE, 12);  gtk_widget_show (allButButtonsVbox);  gtk_box_pack_start (GTK_BOX (dialogVbox), allButButtonsVbox, TRUE, TRUE, 0);  settingsOuterHbox = gtk_hbox_new (FALSE, 0);  gtk_widget_show (settingsOuterHbox);  gtk_box_pack_start (GTK_BOX (allButButtonsVbox), settingsOuterHbox, FALSE, TRUE, 0);  settingsOuterVbox = gtk_vbox_new (FALSE, 12);  gtk_widget_show (settingsOuterVbox);  gtk_box_pack_start (GTK_BOX (settingsOuterHbox), settingsOuterVbox, TRUE, TRUE, 0);  minValueVbox = gtk_vbox_new (FALSE, 0);  gtk_widget_show (minValueVbox);  gtk_box_pack_start (GTK_BOX (settingsOuterVbox), minValueVbox, FALSE, FALSE, 0);  minValueLabel = gtk_label_new (QT_TR_NOOP("Minimum value to be in-range:"));  gtk_widget_show (minValueLabel);  gtk_box_pack_start (GTK_BOX (minValueVbox), minValueLabel, FALSE, FALSE, 0);  gtk_misc_set_alignment (GTK_MISC (minValueLabel), 0.5, 1);  gtk_misc_set_padding (GTK_MISC (minValueLabel), 0, 8);  minValueHbox = gtk_hbox_new (FALSE, 5);  gtk_widget_show (minValueHbox);  gtk_box_pack_start (GTK_BOX (minValueVbox), minValueHbox, TRUE, TRUE, 0);#ifdef ORIGINAL_CODE_GENERATED_BY_GLADE  minValueSlider = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 255, 1, 1, 0)));#else  minValueSpinner_adj = gtk_adjustment_new (0, 0, 255, 1, 1, 0);  minValueSlider = gtk_hscale_new (GTK_ADJUSTMENT (minValueSpinner_adj));#endif  gtk_widget_show (minValueSlider);  gtk_box_pack_start (GTK_BOX (minValueHbox), minValueSlider, TRUE, TRUE, 0);  gtk_scale_set_draw_value (GTK_SCALE (minValueSlider), FALSE);  gtk_scale_set_value_pos (GTK_SCALE (minValueSlider), GTK_POS_LEFT);  gtk_scale_set_digits (GTK_SCALE (minValueSlider), 0);#ifdef ORIGINAL_CODE_GENERATED_BY_GLADE  minValueSpinner_adj = gtk_adjustment_new (0, 0, 255, 1, 10, 10);#endif  minValueSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (minValueSpinner_adj), 1, 0);  gtk_widget_show (minValueSpinner);  gtk_box_pack_start (GTK_BOX (minValueHbox), minValueSpinner, FALSE, TRUE, 0);  maxValueVbox = gtk_vbox_new (FALSE, 0);  gtk_widget_show (maxValueVbox);  gtk_box_pack_start (GTK_BOX (settingsOuterVbox), maxValueVbox, FALSE, FALSE, 0);  maxValueLabel = gtk_label_new (QT_TR_NOOP("Maximum value to be in-range:"));  gtk_widget_show (maxValueLabel);  gtk_box_pack_start (GTK_BOX (maxValueVbox), maxValueLabel, FALSE, FALSE, 0);  maxValueHbox = gtk_hbox_new (FALSE, 5);//.........这里部分代码省略.........

//.........这里部分代码省略.........                       PROP_TAG_CALLBACK_INT, gu_subscription_set_sensitivity,                       pd->playpause,                       PROP_TAG_COURIER, pc,                       NULL);    /* Next button */    pd->next = ti = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_NEXT);    gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1);    g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(next_clicked), pd);    pd->sub_canSkipForward =        prop_subscribe(0,                       PROP_TAG_NAME("global", "media", "current",                                     "canSkipForward"),                       PROP_TAG_CALLBACK_INT, gu_subscription_set_sensitivity,                       pd->next,                       PROP_TAG_COURIER, pc,                       NULL);    /* Separator */    ti = gtk_separator_tool_item_new();    gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1);    /* Subscribe to playstatus */    pd->sub_playstatus =        prop_subscribe(0,                       PROP_TAG_NAME("global", "media", "current", "playstatus"),                       PROP_TAG_CALLBACK, update_playstatus, pd,                       PROP_TAG_COURIER, pc,                       NULL);    /**     * Media position     */    pd->pos_adjust = gtk_adjustment_new(0, 0, 0, 0, 0, 0);    pd->pos_slider = gtk_hscale_new(GTK_ADJUSTMENT(pd->pos_adjust));    gtk_scale_set_value_pos (GTK_SCALE(pd->pos_slider), GTK_POS_LEFT);    g_signal_connect(G_OBJECT(pd->pos_slider), "grab-focus",                     G_CALLBACK(slider_grabbed), pd);    g_signal_connect(G_OBJECT(pd->pos_slider), "change-value",                     G_CALLBACK(slider_updated), pd);    g_signal_connect(G_OBJECT(pd->pos_slider), "format-value",                     G_CALLBACK(slider_value_callback), pd);    ti = gtk_tool_item_new();    gtk_tool_item_set_expand(ti, TRUE);    gtk_container_add(GTK_CONTAINER(ti), pd->pos_slider);    gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1);    /* Subscribe to current track position */    pd->sub_pos =        prop_subscribe(0,                       PROP_TAG_NAME("global", "media", "current", "currenttime"),                       PROP_TAG_CALLBACK_FLOAT, update_curtime, pd,                       PROP_TAG_COURIER, pc,                       NULL);    /* Subscribe to current track duration */    pd->sub_duration =        prop_subscribe(0,                       PROP_TAG_NAME("global", "media", "current",                                     "metadata", "duration"),                       PROP_TAG_CALLBACK_FLOAT, update_duration, pd,                       PROP_TAG_COURIER, pc,                       NULL);    /* Separator */    ti = gtk_separator_tool_item_new();    gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1);    gtk_widget_show_all(vbox);    /**     * Volume control     */    ti = gtk_tool_item_new();    pd->volume = gtk_volume_button_new();    gtk_container_add(GTK_CONTAINER(ti), pd->volume);    gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1);    g_signal_connect(G_OBJECT(pd->volume), "value-changed",                     G_CALLBACK(read_mastervol), pd);    pd->sub_volume =        prop_subscribe(0,                       PROP_TAG_NAME("global", "audio", "mastervolume"),                       PROP_TAG_CALLBACK_FLOAT, update_mastervol, pd,                       PROP_TAG_COURIER, pc,                       NULL);    gtk_widget_show_all(GTK_WIDGET(ti));    g_signal_connect(playdeck, "destroy", G_CALLBACK(playdeck_dtor), pd);    return playdeck;}

int main (int argc, char *argv[]){    GtkWidget *window;    GtkWidget *box;    GtkWidget *box1;    GtkWidget *box2;    GtkWidget *button;    GtkWidget *frame;    GtkWidget *scale;    const gchar *labels[3] = {        "<small>Left</small>",        "<small>Middle</small>",        "<small>Right</small>"    };    gdouble bath_marks[4] = { 0.0, 33.3, 66.6, 100.0 };    const gchar *bath_labels[4] = {        "<span color='blue' size='small'>Cold</span>",        "<span size='small'>Baby bath</span>",        "<span size='small'>Hot tub</span>",        "<span color='Red' size='small'>Hot</span>"    };    gdouble pos_marks[4] = { 0.0, 33.3, 66.6, 100.0 };    const gchar *pos_labels[4] = { "Left", "Right", "Top", "Bottom" };    gtk_init (&argc, &argv);    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);    gtk_window_set_title (GTK_WINDOW (window), "Ranges with marks");    box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);    flipbox = box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);    gtk_widget_set_hexpand (flipbox, TRUE);    gtk_widget_set_vexpand (flipbox, TRUE);    gtk_container_add (GTK_CONTAINER (box1), box);    gtk_container_add (GTK_CONTAINER (window), box1);    frame = gtk_frame_new ("No marks");    scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);    scales = g_slist_prepend (scales, scale);    gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);    gtk_container_add (GTK_CONTAINER (frame), scale);    gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);    frame = gtk_frame_new ("With fill level");    scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);    scales = g_slist_prepend (scales, scale);    gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);    gtk_range_set_show_fill_level (GTK_RANGE (scale), TRUE);    gtk_range_set_fill_level (GTK_RANGE (scale), 50);    gtk_container_add (GTK_CONTAINER (frame), scale);    gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);    frame = gtk_frame_new ("Simple marks");    extra_scale = scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);    scales = g_slist_prepend (scales, scale);    gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);    gtk_scale_add_mark (GTK_SCALE (scale), marks[0], GTK_POS_BOTTOM, NULL);    gtk_scale_add_mark (GTK_SCALE (scale), marks[1], GTK_POS_BOTTOM, NULL);    gtk_scale_add_mark (GTK_SCALE (scale), marks[2], GTK_POS_BOTTOM, NULL);    gtk_container_add (GTK_CONTAINER (frame), scale);    gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);    frame = gtk_frame_new ("Simple marks up");    scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);    scales = g_slist_prepend (scales, scale);    gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);    gtk_scale_add_mark (GTK_SCALE (scale), marks[0], GTK_POS_TOP, NULL);    gtk_scale_add_mark (GTK_SCALE (scale), marks[1], GTK_POS_TOP, NULL);    gtk_scale_add_mark (GTK_SCALE (scale), marks[2], GTK_POS_TOP, NULL);    gtk_container_add (GTK_CONTAINER (frame), scale);    gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);    frame = gtk_frame_new ("Labeled marks");    box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);    scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);    scales = g_slist_prepend (scales, scale);    gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);    gtk_scale_add_mark (GTK_SCALE (scale), marks[0], GTK_POS_BOTTOM, labels[0]);    gtk_scale_add_mark (GTK_SCALE (scale), marks[1], GTK_POS_BOTTOM, labels[1]);    gtk_scale_add_mark (GTK_SCALE (scale), marks[2], GTK_POS_BOTTOM, labels[2]);    gtk_container_add (GTK_CONTAINER (frame), scale);    gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);    frame = gtk_frame_new ("Some labels");    scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);    scales = g_slist_prepend (scales, scale);    gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);    gtk_scale_add_mark (GTK_SCALE (scale), marks[0], GTK_POS_TOP, labels[0]);    gtk_scale_add_mark (GTK_SCALE (scale), marks[1], GTK_POS_TOP, NULL);    gtk_scale_add_mark (GTK_SCALE (scale), marks[2], GTK_POS_TOP, labels[2]);    gtk_container_add (GTK_CONTAINER (frame), scale);    gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0);    frame = gtk_frame_new ("Above and below");    scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);    scales = g_slist_prepend (scales, scale);    gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);    gtk_scale_add_mark (GTK_SCALE (scale), bath_marks[0], GTK_POS_TOP, bath_labels[0]);//.........这里部分代码省略.........

static GtkWidget *pidgin_media_add_audio_widget(PidginMedia *gtkmedia,		PurpleMediaSessionType type){	GtkWidget *volume_widget, *progress_parent, *volume, *progress;	double value;	if (type & PURPLE_MEDIA_SEND_AUDIO) {		value = purple_prefs_get_int(			"/purple/media/audio/volume/input");	} else if (type & PURPLE_MEDIA_RECV_AUDIO) {		value = purple_prefs_get_int(			"/purple/media/audio/volume/output");	} else		g_return_val_if_reached(NULL);#if GTK_CHECK_VERSION(2,12,0)	/* Setup widget structure */	volume_widget = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);	progress_parent = gtk_vbox_new(FALSE, 0);	gtk_box_pack_start(GTK_BOX(volume_widget),			progress_parent, TRUE, TRUE, 0);	/* Volume button */	volume = gtk_volume_button_new();	gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume), value/100.0);	gtk_box_pack_end(GTK_BOX(volume_widget),			volume, FALSE, FALSE, 0);#else	/* Setup widget structure */	volume_widget = gtk_vbox_new(FALSE, 0);	progress_parent = volume_widget;	/* Volume slider */	volume = gtk_hscale_new_with_range(0.0, 100.0, 5.0);	gtk_range_set_increments(GTK_RANGE(volume), 5.0, 25.0);	gtk_range_set_value(GTK_RANGE(volume), value);	gtk_scale_set_draw_value(GTK_SCALE(volume), FALSE);	gtk_box_pack_end(GTK_BOX(volume_widget),			volume, TRUE, FALSE, 0);#endif	/* Volume level indicator */	progress = gtk_progress_bar_new();	gtk_widget_set_size_request(progress, 250, 10);	gtk_box_pack_end(GTK_BOX(progress_parent), progress, TRUE, FALSE, 0);	if (type & PURPLE_MEDIA_SEND_AUDIO) {		g_signal_connect (G_OBJECT(volume), "value-changed",				G_CALLBACK(pidgin_media_input_volume_changed),				gtkmedia->priv->media);		gtkmedia->priv->send_progress = progress;	} else if (type & PURPLE_MEDIA_RECV_AUDIO) {		g_signal_connect (G_OBJECT(volume), "value-changed",				G_CALLBACK(pidgin_media_output_volume_changed),				gtkmedia->priv->media);		gtkmedia->priv->recv_progress = progress;	}	gtk_widget_show_all(volume_widget);	return volume_widget;}

static void create_controls( void ){    GtkWidget *window;    GtkWidget *box1, *box3;    GtkWidget *setButton, *delButton;    GtkWidget *separator;    GtkObject *adj;    /* Standard window-creating stuff */    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);    g_signal_connect (window, "destroy", G_CALLBACK (controls_quit), NULL);    gtk_window_set_title (GTK_WINDOW (window), "loss rate controls");    box1 = gtk_vbox_new (FALSE, 0);    gtk_container_set_border_width (GTK_CONTAINER (box1), 10);    gtk_container_add (GTK_CONTAINER (window), box1);    gtk_widget_show (box1);    char currtext[100];    sprintf(currtext, "Current loss rate: %2.1f %%", previous_loss_rate);    text = gtk_label_new(currtext);    gtk_box_pack_start (GTK_BOX (box1), text, FALSE, FALSE, 5);    gtk_widget_show (text);    /* value, lower, upper, step_increment, page_increment, page_size */    /* Note that the page_size value only makes a difference for     * scrollbar widgets, and the highest value you'll get is actually     * (upper - page_size). */    adj = gtk_adjustment_new (0.0, 0.0, 16.0, 0.1, 1.0, 1.0);    box3 = gtk_vbox_new (FALSE, 10);    gtk_box_pack_start (GTK_BOX (box1), box3, TRUE, TRUE, 0);    gtk_widget_show (box3);    gtk_container_set_border_width (GTK_CONTAINER (box3), 10);    hscale = gtk_hscale_new (GTK_ADJUSTMENT (adj));    gtk_widget_set_size_request (GTK_WIDGET (hscale), 200, -1);    scale_set_default_values (GTK_SCALE (hscale));    gtk_box_pack_start (GTK_BOX (box3), hscale, TRUE, TRUE, 0);    gtk_widget_show (hscale);    setButton = gtk_button_new_with_label ("Set loss rate");    g_signal_connect(setButton, "clicked",                     G_CALLBACK (set_loss_rate),                     adj);    gtk_box_pack_start (GTK_BOX (box1), setButton, TRUE, TRUE, 2);    gtk_widget_set_can_default (setButton, TRUE);    gtk_widget_grab_default (setButton);    gtk_widget_show (setButton);    delButton = gtk_button_new_with_label ("Reset to 0");    g_signal_connect(delButton, "clicked",                     G_CALLBACK (reset_loss_rate),                     adj);    gtk_box_pack_start (GTK_BOX (box1), delButton, TRUE, TRUE, 2);    gtk_widget_set_can_default (delButton, TRUE);    gtk_widget_grab_default (delButton);    gtk_widget_show (delButton);    gtk_widget_show (window);}

//.........这里部分代码省略.........///   // data=table of 2 pointers;///   GUI_DATA_EVENT  = *(int*)data[0]    = TYP_EventMove or///                                         TYP_EventPress (left mousebutton)///                                         TYP_EventRelease ///   GUI_DATA_D1     = *(double*)data[1] = slider-value (only TYP_EventMove)///   GUI_OBJ_TYP(mo) = TYP_GUI_Slider////// Example without callback:/// wsl1 = GUI_Slider__ (&box1, 0, NULL, 0., 1., 0.5, "8");/// // query slider-value/// printf(" sliVal=%f/n",GUI_Slider_get(&wsl1));/// // change slider-value/// GUI_Slider_set (&wsl1, 0.75);////// Example with callback:/// wsl1 = GUI_Slider__ (&box1, 0, sl_CB, 0., 1., 0.5, "8");/// int sl_CB (MemObj *mo, void **data) {///   if(GUI_DATA_EVENT == TYP_EventMove) {///     printf("sl_CB %lf/n",GUI_DATA_D1);  // slider-value as double///   }/// }/// /endcode  int           pTyp;  GtkAdjustment *adj1;  // GtkObject     *adj1;  GtkWidget     *wsc1;  void          *w_par;  double        d1;  Obj_Slider    *go;  // get gtk-widget for parentBox from MemObj  w_par = GUI_obj_parent__ (&pTyp, o_par);  if(!w_par) return (UME_obj_invalid_set (-3));  // get address & memspc  GUI_obj_spc ((void**)&go, sizeof(Obj_Slider));  if(!go) return (UME_obj_invalid_set (-1));  // Adjustment (StartVal minVal maxVal incr pageIncr pageSize)  d1 = (valMax - valMin ) / 100.;  adj1 = gtk_adjustment_new((gdouble)valStart,                            (gdouble)valMin,                            (gdouble)valMax,                            (gdouble)d1,                            (gdouble)0.,                            (gdouble)0.);  // callback for moving the control  if(funcnam) {    g_signal_connect (adj1, "value_changed",                      G_CALLBACK(GUI_Slider_cb1),                      PTR_MEMOBJ(go->mem_obj));  }  wsc1 = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT(adj1));  if(funcnam) { // 2013-09-09    gtk_widget_add_events (GTK_WIDGET(wsc1),                           GDK_BUTTON_PRESS_MASK |                           GDK_BUTTON_RELEASE_MASK);    g_signal_connect (G_OBJECT(wsc1), "button_press_event",                      G_CALLBACK(GUI_Slider_cb2),                      PTR_MEMOBJ(go->mem_obj));    g_signal_connect (G_OBJECT(wsc1), "button_release_event",                      G_CALLBACK(GUI_Slider_cb2),                      PTR_MEMOBJ(go->mem_obj));  }  UI_act_wi = wsc1;              // GUI_Tip; 2013-09-09  // do not display actual value  gtk_scale_set_draw_value (GTK_SCALE(wsc1), FALSE);    // // GUI_packwn (w_par, wsc1, siz, 0);  // if(siz == 1) GUI_packwn (w_par, wsc1, 0, 1);  // else         GUI_packwn (w_par, wsc1, siz, 0);  GUI_w_pack1 (pTyp, w_par, wsc1, opts);  // fill obj  go->gio_typ  = TYP_GUI_Slider;  go->slider   = adj1; //wsc1;  go->uFunc    = funcnam;  return (((Obj_Unknown*)go)->mem_obj);}

static void layout(void){	int i;	GtkWidget *w;	GtkWidget *vbox, *bbox, *tbl, *frm;	vbox = create_vbox(win);	frm = gtk_frame_new("invert axis");	add_child(vbox, frm);	tbl = gtk_table_new(3, 4, FALSE);	add_child(frm, tbl);	gtk_table_set_row_spacings(GTK_TABLE(tbl), 2);	gtk_table_set_col_spacings(GTK_TABLE(tbl), 2);	gtk_table_attach_defaults(GTK_TABLE(tbl), gtk_label_new("X"), 1, 2, 0, 1);	gtk_table_attach_defaults(GTK_TABLE(tbl), gtk_label_new("Y"), 2, 3, 0, 1);	gtk_table_attach_defaults(GTK_TABLE(tbl), gtk_label_new("Z"), 3, 4, 0, 1);	gtk_table_attach_defaults(GTK_TABLE(tbl), gtk_label_new("translation"), 0, 1, 1, 2);	gtk_table_attach_defaults(GTK_TABLE(tbl), gtk_label_new("rotation"), 0, 1, 2, 3);	for(i=0; i<6; i++) {		int x = i % 3 + 1;		int y = i / 3 + 1;		w = gtk_check_button_new();		gtk_table_attach_defaults(GTK_TABLE(tbl), w, x, x + 1, y, y + 1);		g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(chk_handler), (void*)i);	}	/*hbox = create_hbox(vbox);*/	frm = gtk_frame_new("sensitivity");	add_child(vbox, frm);	w = gtk_hscale_new_with_range(0.0, 4.0, 0.1);	gtk_range_set_update_policy(GTK_RANGE(w), GTK_UPDATE_DELAYED);	gtk_range_set_value(GTK_RANGE(w), cfg.sensitivity);	gtk_scale_set_value_pos(GTK_SCALE(w), GTK_POS_RIGHT);	g_signal_connect(G_OBJECT(w), "value_changed", G_CALLBACK(slider_handler), 0);	add_child(frm, w);	frm = gtk_frame_new("X11 magellan API");	add_child(vbox, frm);	bbox = gtk_hbutton_box_new();	add_child(frm, bbox);	w = gtk_button_new_with_label("start");	g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(bn_handler), (void*)0);	add_child(bbox, w);	w = gtk_button_new_with_label("stop");	g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(bn_handler), (void*)1);	add_child(bbox, w);	w = gtk_button_new_with_label("check");	g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(bn_handler), (void*)2);	add_child(bbox, w);	/*	w = gtk_check_button_new_with_label("enable X11 magellan API");	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), query_x11());	g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(chk_handler), (void*)10);	add_child(frm, w);	*/	frm = gtk_frame_new("misc");	add_child(vbox, frm);	bbox = gtk_hbutton_box_new();	add_child(frm, bbox);	w = gtk_button_new_with_label("ping daemon");	g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(bn_handler), (void*)3);	add_child(bbox, w);	bbox = gtk_hbutton_box_new();	add_child(vbox, bbox);	/*w = gtk_button_new_from_stock(GTK_STOCK_APPLY);	g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(bn_handler), 0);	add_child(bbox, w);*/	w = gtk_button_new_from_stock(GTK_STOCK_CLOSE);	g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(gtk_main_quit), 0);	add_child(bbox, w);}

/** * Initialize components for gtk window */static Win* create_ui () {    Win* w = malloc(sizeof(Win));    /* create a new window */    w->main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);       /* area that will display our stream */    w->video_window = gtk_drawing_area_new ();    /* ===== framerate settings ===== */    w->framerate_field = gtk_entry_new();    /* connect button event to callback function */    w->framerate_send_button = gtk_button_new_with_label("Set FrameRate");    g_signal_connect (G_OBJECT (w->framerate_send_button), "clicked", G_CALLBACK (framerate_value_changed), w);    /* ===== exposure scale ===== */    w->exposure_label = gtk_label_new("Exposure:");    gdouble value;    g_object_get (G_OBJECT (p.source), "exposure", &value, NULL);    w->exposure_value_label = gtk_label_new("0.0");    /* the label should give enough space to not rezise */    gtk_label_set_width_chars (GTK_LABEL(w->exposure_value_label), 10);     /* the scale will have a range from 0 to 100 to use the percentage to implement a log scale */    double rmin = 0;    double rmax = 100;    double rangelen2 = log(rmax) - log(rmin);    double exposure_value = (ABSVAL_SLIDER_TICKS) / rangelen2 * ( log(value) - log(rmin) );        gdouble exposure_lower          = 0.0;       /* min value */    gdouble exposure_upper          = 100.0;     /* max value */    gdouble exposure_step_increment = 1.0;       /* step size */    gdouble exposure_page_increment = -10.0;     /* negatic value, to make page up increase value */    gdouble exposure_page_size      = 0.0;    GtkObject* wat = gtk_adjustment_new ( exposure_value,                                          exposure_lower,                                          exposure_upper,                                          exposure_step_increment,                                          exposure_page_increment,                                          exposure_page_size);    w->exposure_hscale = gtk_hscale_new (GTK_ADJUSTMENT(wat));    gtk_scale_set_draw_value(GTK_SCALE (w->exposure_hscale), FALSE);    gtk_widget_set_usize (GTK_WIDGET (w->exposure_hscale), 400, 30);    g_signal_connect (G_OBJECT(wat), "value-changed", G_CALLBACK (exposure_value_changed), w);    set_slider_label (GTK_LABEL(w->exposure_value_label), value);    /* ===== gain part ===== */    w->gain_label = gtk_label_new("Gain:");    double gain_value;    gdouble gain_lower; /* min value */    gdouble gain_upper; /* max value */        w->gain_value_label = gtk_label_new("0.0");    g_object_get (G_OBJECT (p.source), "gain", &gain_value, NULL);    arv_camera_get_gain_bounds (p.camera, &gain_lower, &gain_upper);    set_slider_label (GTK_LABEL(w->gain_value_label), gain_value);    gdouble gain_step_increment = 0.1;       /* step size */    gdouble gain_page_increment = -1.0;    gdouble gain_page_size      = 0.0;    GtkObject* range_gain = gtk_adjustment_new (gain_value,                                                gain_lower,                                                gain_upper,                                                gain_step_increment,                                                gain_page_increment,                                                gain_page_size);    w->gain_hscale = gtk_hscale_new (GTK_ADJUSTMENT(range_gain));    gtk_scale_set_draw_value(GTK_SCALE (w->gain_hscale), FALSE);    gtk_widget_set_usize (GTK_WIDGET (w->gain_hscale), 400, 50);    g_signal_connect (G_OBJECT(range_gain), "value-changed", G_CALLBACK (gain_value_changed), w);        GtkWidget* toggle;    toggle = gtk_button_new_with_label("Start/Stop");    g_signal_connect (G_OBJECT (toggle), "clicked", G_CALLBACK (togglePipelineState), NULL);    /* ===== organize everything and place in window ===== */    w->controls = gtk_hbox_new (FALSE, 0);    gtk_box_pack_start (GTK_BOX (w->controls), toggle, FALSE, FALSE, 2);    gtk_box_pack_start (GTK_BOX (w->controls), w->framerate_field, FALSE, FALSE, 2);//.........这里部分代码省略.........

static voidzoom_options_init (ZoomOptions *self){  ZoomOptionsPrivate *priv;  GtkWidget *w;  PangoAttrList *pango_attrs;  PangoAttribute *attr;  GError *err = NULL;  priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, ZOOM_TYPE_OPTIONS, ZoomOptionsPrivate);  priv->builder = gtk_builder_new ();  gtk_builder_set_translation_domain (priv->builder, GETTEXT_PACKAGE);  gtk_builder_add_from_file (priv->builder,                             SAGARMATHACC_UI_DIR "/zoom-options.ui",                             &err);  if (err)    {      g_warning ("Could not load interface file: %s", err->message);      g_error_free (err);      g_object_unref (priv->builder);      priv->builder = NULL;      return;    }  priv->settings = g_settings_new ("org.sagarmatha.desktop.a11y.magnifier");  priv->application_settings = g_settings_new ("org.sagarmatha.desktop.a11y.applications");  pango_attrs = pango_attr_list_new ();  attr = pango_attr_scale_new (FONT_SCALE);  pango_attr_list_insert (pango_attrs, attr);  /* Zoom switch */  g_settings_bind (priv->application_settings, "screen-magnifier-enabled",                   WID ("seeing_zoom_switch"), "active",                   G_SETTINGS_BIND_DEFAULT);  /* Magnification factor */  w = WID ("magFactorSpinButton");  g_settings_bind (priv->settings, "mag-factor",                   gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (w)),                   "value", G_SETTINGS_BIND_DEFAULT);  /* Screen position combo */  w = WID ("screen_position_combo_box");  screen_position_notify_cb (priv->settings, "screen-position", self);  g_signal_connect (G_OBJECT (priv->settings), "changed::screen-position",                    G_CALLBACK (screen_position_notify_cb), self);  g_signal_connect (G_OBJECT (w), "changed",                    G_CALLBACK (screen_position_combo_changed_cb), self);  /* Screen part section */  init_screen_part_section (priv, pango_attrs);  /* Cross hairs: show/hide ... */  w = WID ("xhairsEnabledSwitch");  g_settings_bind (priv->settings, "show-cross-hairs", w, "active",                   G_SETTINGS_BIND_DEFAULT);  /* ... Cross hairs: color and opacity */  w = WID ("xHairsPicker");  init_xhairs_color_opacity (GTK_COLOR_BUTTON (w), priv->settings);  g_signal_connect (G_OBJECT (priv->settings), "changed::cross-hairs-color",                    G_CALLBACK (xhairs_color_notify_cb), w);  g_signal_connect (G_OBJECT (priv->settings), "changed::cross-hairs-opacity",                    G_CALLBACK (xhairs_opacity_notify_cb), w);  g_signal_connect (G_OBJECT (w), "color-set",                    G_CALLBACK (xhairs_color_opacity_changed),                    priv);  /* ... Cross hairs: thickness ... */  w = WID ("xHairsThicknessSlider");  g_settings_bind (priv->settings, "cross-hairs-thickness",                   gtk_range_get_adjustment (GTK_RANGE (w)), "value",                   G_SETTINGS_BIND_DEFAULT);  /* ... Cross hairs: clip ... */  w = WID ("xHairsClipCheckbox");  scale_label (GTK_BIN(w), pango_attrs);  g_settings_bind (priv->settings, "cross-hairs-clip", w, "active",                   G_SETTINGS_BIND_INVERT_BOOLEAN);  /* ... Cross hairs: length ... */  w = WID ("xHairsLengthSlider");  xhairs_length_add_marks (GTK_SCALE (w));  g_settings_bind (priv->settings, "cross-hairs-length",                   gtk_range_get_adjustment (GTK_RANGE (w)), "value",                   G_SETTINGS_BIND_DEFAULT);  /* ... Color effects ... */  w = WID ("inverseEnabledSwitch");  g_settings_bind (priv->settings, "invert-lightness", w, "active",                   G_SETTINGS_BIND_DEFAULT);  w = WID ("brightnessSlider");  priv->brightness_slider = w;  init_effects_slider (GTK_RANGE(w), priv, brightness_keys,                       G_CALLBACK (brightness_slider_notify_cb));//.........这里部分代码省略.........

static void on_file_save_filter_changed(GObject* obj, GParamSpec* pspec, gpointer user_data){    GtkFileChooser* dlg = (GtkFileChooser*)obj;    GtkFileFilter* filter = gtk_file_chooser_get_filter( dlg );    const char* type = (const char*)g_object_get_data(G_OBJECT(filter), "type");    GtkWidget* extra = gtk_file_chooser_get_extra_widget(dlg);    if(extra)    {        gtk_file_chooser_set_extra_widget(dlg, NULL);        extra = NULL;    }    if( type )    {        GtkWidget* label, *label2;        GtkWidget* scale;        if( strcmp( type, "jpeg" ) == 0 )        {            extra = gtk_hbox_new(FALSE, 12);            label = gtk_label_new(_("JPEG Quality:"));            label2 = gtk_label_new(_("Lower quality values yield smaller file sizes,/nbut the image quality will be poorer."));            scale = gtk_hscale_new_with_range( 0, 100, 5 );            gtk_range_set_value(GTK_RANGE(scale), pref.jpg_quality);#if GTK_CHECK_VERSION(2, 24, 0) #else            gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_DISCONTINUOUS);#endif            g_signal_connect(G_OBJECT(scale), "value-changed", G_CALLBACK(on_int_val_changed), &pref.jpg_quality);            gtk_scale_set_draw_value(GTK_SCALE(scale), TRUE);            gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_RIGHT);            gtk_box_pack_start(GTK_BOX(extra), label, FALSE, TRUE, 0);            gtk_box_pack_start(GTK_BOX(extra), scale, TRUE, TRUE, 0);            gtk_box_pack_start(GTK_BOX(extra), label2, FALSE, TRUE, 0);        }        else if( strcmp( type, "png" ) == 0 )        {            extra = gtk_hbox_new(FALSE, 12);            label = gtk_label_new(_("PNG Compression Level:"));            label2 = gtk_label_new(_("Higher compression levels yield smaller file sizes,/nbut takes more time to do the compression."));            scale = gtk_hscale_new_with_range( 0, 9, 1 );            gtk_range_set_value(GTK_RANGE(scale), pref.png_compression);#if GTK_CHECK_VERSION(2, 24, 0)#else            gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_DISCONTINUOUS);#endif            g_signal_connect(G_OBJECT(scale), "value-changed", G_CALLBACK(on_int_val_changed), &pref.png_compression);            gtk_scale_set_draw_value(GTK_SCALE(scale), TRUE);            gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_RIGHT);            gtk_box_pack_start(GTK_BOX(extra), label, FALSE, TRUE, 0);            gtk_box_pack_start(GTK_BOX(extra), scale, TRUE, TRUE, 0);            gtk_box_pack_start(GTK_BOX(extra), label2, FALSE, TRUE, 0);        }        /* FIXME: provide "depth settings for *.ico files" */        if( extra )        {            gtk_widget_show_all(extra);            gtk_file_chooser_set_extra_widget(dlg, extra);        }    }}

static GtkObject *gimp_scale_entry_new_internal (gboolean     color_scale,                               GtkTable    *table,                               gint         column,                               gint         row,                               const gchar *text,                               gint         scale_width,                               gint         spinbutton_width,                               gdouble      value,                               gdouble      lower,                               gdouble      upper,                               gdouble      step_increment,                               gdouble      page_increment,                               guint        digits,                               gboolean     constrain,                               gdouble      unconstrained_lower,                               gdouble      unconstrained_upper,                               const gchar *tooltip,                               const gchar *help_id){  GtkWidget *label;  GtkWidget *scale;  GtkWidget *spinbutton;  GtkObject *adjustment;  GtkObject *return_adj;  label = gtk_label_new_with_mnemonic (text);  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);  gtk_table_attach (GTK_TABLE (table), label,                    column, column + 1, row, row + 1,                    GTK_FILL, GTK_FILL, 0, 0);  gtk_widget_show (label);  if (! constrain &&      unconstrained_lower <= lower &&      unconstrained_upper >= upper)    {      GtkObject *constrained_adj;      constrained_adj = gtk_adjustment_new (value, lower, upper,                                            step_increment, page_increment,                                            0.0);      spinbutton = gimp_spin_button_new (&adjustment, value,                                         unconstrained_lower,                                         unconstrained_upper,                                         step_increment, page_increment, 0.0,                                         1.0, digits);      g_signal_connect        (G_OBJECT (constrained_adj), "value-changed",         G_CALLBACK (gimp_scale_entry_unconstrained_adjustment_callback),         adjustment);      g_signal_connect        (G_OBJECT (adjustment), "value-changed",         G_CALLBACK (gimp_scale_entry_unconstrained_adjustment_callback),         constrained_adj);      return_adj = adjustment;      adjustment = constrained_adj;    }  else    {      spinbutton = gimp_spin_button_new (&adjustment, value, lower, upper,                                         step_increment, page_increment, 0.0,                                         1.0, digits);      return_adj = adjustment;    }  gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);  if (spinbutton_width > 0)    {      if (spinbutton_width < 17)        gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), spinbutton_width);      else        gtk_widget_set_size_request (spinbutton, spinbutton_width, -1);    }  if (color_scale)    {      scale = gimp_color_scale_new (GTK_ORIENTATION_HORIZONTAL,                                    GIMP_COLOR_SELECTOR_VALUE);      gtk_range_set_adjustment (GTK_RANGE (scale),                                GTK_ADJUSTMENT (adjustment));    }  else    {      scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL,                             GTK_ADJUSTMENT (adjustment));    }  if (scale_width > 0)    gtk_widget_set_size_request (scale, scale_width, -1);  gtk_scale_set_digits (GTK_SCALE (scale), digits);  gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);//.........这里部分代码省略.........

static voidcreate_scale_box (GvcBalanceBar *bar){#if GTK_CHECK_VERSION (3, 0, 0)        bar->priv->scale_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);        bar->priv->start_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);        bar->priv->end_box   = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);        bar->priv->scale     = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL,                                              bar->priv->adjustment);#if GTK_CHECK_VERSION (3, 4, 0)        /* Balance and fade scales do not have an origin */        if (bar->priv->btype != BALANCE_TYPE_LFE)                gtk_scale_set_has_origin (GTK_SCALE (bar->priv->scale), FALSE);#endif#else        bar->priv->scale_box = gtk_hbox_new (FALSE, 6);        bar->priv->start_box = gtk_hbox_new (FALSE, 6);        bar->priv->end_box   = gtk_hbox_new (FALSE, 6);        bar->priv->scale     = gtk_hscale_new (bar->priv->adjustment);        /* GTK2 way to remove the origin */        if (bar->priv->btype != BALANCE_TYPE_LFE) {                gtk_rc_parse_string (BALANCE_BAR_STYLE);                gtk_widget_set_name (bar->priv->scale, "balance-bar-scale");        }#endif        gtk_widget_set_size_request (bar->priv->scale, SCALE_SIZE, -1);        gtk_box_pack_start (GTK_BOX (bar->priv->scale_box),                            bar->priv->start_box,                            FALSE, FALSE, 0);        gtk_box_pack_start (GTK_BOX (bar->priv->start_box),                            bar->priv->label,                            FALSE, FALSE, 0);        gtk_box_pack_start (GTK_BOX (bar->priv->scale_box),                            bar->priv->scale,                            TRUE, TRUE, 0);        gtk_box_pack_start (GTK_BOX (bar->priv->scale_box),                            bar->priv->end_box,                            FALSE, FALSE, 0);        ca_gtk_widget_disable_sounds (bar->priv->scale, FALSE);        gtk_widget_add_events (bar->priv->scale, GDK_SCROLL_MASK);        g_signal_connect (G_OBJECT (bar->priv->scale),                          "scroll-event",                          G_CALLBACK (on_scale_scroll_event),                          bar);        if (bar->priv->size_group != NULL) {                gtk_size_group_add_widget (bar->priv->size_group,                                           bar->priv->start_box);                if (bar->priv->symmetric)                        gtk_size_group_add_widget (bar->priv->size_group,                                                   bar->priv->end_box);        }        gtk_scale_set_draw_value (GTK_SCALE (bar->priv->scale), FALSE);}

GtkWidget*create_dialog1 (void){  GtkWidget *dialog1;  GtkWidget *dialog_vbox1;  GtkWidget *vbox1;  GtkWidget *hbox1;  GtkWidget *vbox3;  GtkWidget *label1;  GtkWidget *hscaleContrast;  GtkWidget *label2;  GtkWidget *hscaleBright;  GtkWidget *vbox2;  GtkWidget *checkLuma;  GtkWidget *checkbuttonU;  GtkWidget *checkbuttonV;  GtkWidget *hscale1;  GtkWidget *drawingarea1;  GtkWidget *dialog_action_area1;  GtkWidget *cancelbutton1;  GtkWidget *okbutton1;  dialog1 = gtk_dialog_new ();  gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("Contrast"));  gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG);  dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;  gtk_widget_show (dialog_vbox1);  vbox1 = gtk_vbox_new (FALSE, 0);  gtk_widget_show (vbox1);  gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);  hbox1 = gtk_hbox_new (FALSE, 0);  gtk_widget_show (hbox1);  gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0);  vbox3 = gtk_vbox_new (FALSE, 0);  gtk_widget_show (vbox3);  gtk_box_pack_start (GTK_BOX (hbox1), vbox3, TRUE, TRUE, 0);  label1 = gtk_label_new (QT_TR_NOOP("Contrast"));  gtk_widget_show (label1);  gtk_box_pack_start (GTK_BOX (vbox3), label1, FALSE, FALSE, 0);  hscaleContrast = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.5, 1.5, 0.1, 0.1, 0)));  gtk_widget_show (hscaleContrast);  gtk_box_pack_start (GTK_BOX (vbox3), hscaleContrast, FALSE, TRUE, 0);  gtk_scale_set_value_pos (GTK_SCALE (hscaleContrast), GTK_POS_LEFT);  label2 = gtk_label_new (QT_TR_NOOP("Brightness"));  gtk_widget_show (label2);  gtk_box_pack_start (GTK_BOX (vbox3), label2, FALSE, FALSE, 0);  hscaleBright = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, -127, 127, 1, 1, 0)));  gtk_widget_show (hscaleBright);  gtk_box_pack_start (GTK_BOX (vbox3), hscaleBright, FALSE, TRUE, 0);  gtk_scale_set_value_pos (GTK_SCALE (hscaleBright), GTK_POS_LEFT);  gtk_scale_set_digits (GTK_SCALE (hscaleBright), 0);  vbox2 = gtk_vbox_new (FALSE, 0);  gtk_widget_show (vbox2);  gtk_box_pack_start (GTK_BOX (hbox1), vbox2, TRUE, TRUE, 0);  checkLuma = gtk_check_button_new_with_mnemonic (QT_TR_NOOP("Luma"));  gtk_widget_show (checkLuma);  gtk_box_pack_start (GTK_BOX (vbox2), checkLuma, FALSE, FALSE, 0);  checkbuttonU = gtk_check_button_new_with_mnemonic (QT_TR_NOOP("Chroma U"));  gtk_widget_show (checkbuttonU);  gtk_box_pack_start (GTK_BOX (vbox2), checkbuttonU, FALSE, FALSE, 0);  checkbuttonV = gtk_check_button_new_with_mnemonic (QT_TR_NOOP("Chroma v"));  gtk_widget_show (checkbuttonV);  gtk_box_pack_start (GTK_BOX (vbox2), checkbuttonV, FALSE, FALSE, 0);  hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 99, 1, 1, 0)));  gtk_widget_show (hscale1);  gtk_box_pack_start (GTK_BOX (vbox1), hscale1, TRUE, TRUE, 0);  drawingarea1 = gtk_drawing_area_new ();  gtk_widget_show (drawingarea1);  gtk_box_pack_start (GTK_BOX (vbox1), drawingarea1, TRUE, TRUE, 0);  gtk_widget_set_size_request (drawingarea1, -1, 300);  dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;  gtk_widget_show (dialog_action_area1);  gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);  cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");  gtk_widget_show (cancelbutton1);  gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL);  GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);  okbutton1 = gtk_button_new_from_stock ("gtk-ok");  gtk_widget_show (okbutton1);  gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK);  GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);  /* Store pointers to all widgets, for use by lookup_widget(). *///.........这里部分代码省略.........

//.........这里部分代码省略.........GtkObject *stpui_scale_entry_new(GtkTable    *table,		      gint         column,		      gint         row,		      const gchar *text,		      gint         scale_usize,		      gint         spinbutton_usize,		      gfloat       value,		      gfloat       lower,		      gfloat       upper,		      gfloat       step_increment,		      gfloat       page_increment,		      guint        digits,		      gboolean     constrain,		      gfloat       unconstrained_lower,		      gfloat       unconstrained_upper,		      const gchar *tooltip){  GtkWidget *label;  GtkWidget *scale;  GtkWidget *spinbutton;  GtkObject *adjustment;  GtkObject *return_adj;  label = gtk_label_new (text);  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);  gtk_table_attach (GTK_TABLE (table), label,                    column + 1, column + 2, row, row + 1,                    GTK_FILL, GTK_FILL, 0, 0);  gtk_widget_show (label);  if (! constrain &&      unconstrained_lower <= lower &&      unconstrained_upper >= upper)    {      GtkObject *constrained_adj;      constrained_adj = gtk_adjustment_new (value, lower, upper,					    step_increment, page_increment,					    0.0);      spinbutton = spin_button_new (&adjustment, value,				    unconstrained_lower,				    unconstrained_upper,				    step_increment, page_increment, 0.0,				    1.0, digits);      g_signal_connect	(G_OBJECT (constrained_adj), "value_changed",	 G_CALLBACK (scale_entry_unconstrained_adjustment_callback),	 adjustment);      g_signal_connect	(G_OBJECT (adjustment), "value_changed",	 G_CALLBACK (scale_entry_unconstrained_adjustment_callback),	 constrained_adj);      return_adj = adjustment;      adjustment = constrained_adj;    }  else    {      spinbutton = spin_button_new (&adjustment, value, lower, upper,				    step_increment, page_increment, 0.0,				    1.0, digits);      return_adj = adjustment;    }  if (spinbutton_usize > 0)    gtk_widget_set_usize (spinbutton, spinbutton_usize, -1);  scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));  if (scale_usize > 0)    gtk_widget_set_usize (scale, scale_usize, -1);  gtk_scale_set_digits (GTK_SCALE (scale), digits);  gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);  gtk_table_attach (GTK_TABLE (table), scale,		    column + 2, column + 3, row, row + 1,		    GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);  gtk_widget_show (scale);  gtk_table_attach (GTK_TABLE (table), spinbutton,		    column + 3, column + 4, row, row + 1,		    GTK_SHRINK, GTK_SHRINK, 0, 0);  gtk_widget_show (spinbutton);  if (tooltip)    {      stpui_set_help_data (scale, tooltip);      stpui_set_help_data (spinbutton, tooltip);    }  gtk_object_set_data (G_OBJECT (return_adj), "label", label);  gtk_object_set_data (G_OBJECT (return_adj), "scale", scale);  gtk_object_set_data (G_OBJECT (return_adj), "spinbutton", spinbutton);  return return_adj;}

		CVoxelView::CVoxelView(CVoxelDisplay& rVoxelDisplay) :			m_rVoxelDisplay(rVoxelDisplay),			m_pBuilderInterface(NULL),			m_pCubeButton(NULL),			m_pSphereButton(NULL),			m_pMinScaleFactorSpinButton(NULL),			m_pMaxScaleFactorSpinButton(NULL),			m_f64MinScaleFactor(1),			m_f64MaxScaleFactor(2),			m_pThresholdRangeAndOrLabel(NULL),			m_pMinDisplayThresholdBoundaryButton(NULL),			m_pMaxDisplayThresholdBoundaryButton(NULL),			m_pMinDisplayThresholdScale(NULL),			m_pMaxDisplayThresholdScale(NULL),			m_f64MinDisplayThreshold(0.25),			m_f64MaxDisplayThreshold(0.75)		{			//load the gtk builder interface			m_pBuilderInterface=gtk_builder_new(); // glade_xml_new(OpenViBE::Directories::getDataDir() + "/plugins/simple-visualisation/openvibe-simple-visualisation-VoxelDisplay.ui", NULL, NULL);			gtk_builder_add_from_file(m_pBuilderInterface, OpenViBE::Directories::getDataDir() + "/plugins/simple-visualisation/openvibe-simple-visualisation-VoxelDisplay.ui", NULL);			if(!m_pBuilderInterface)			{				g_warning("Couldn't load the interface!");				return;			}			gtk_builder_connect_signals(m_pBuilderInterface, NULL);			//toolbar			//-------			//voxel object buttons			m_pCubeButton = GTK_RADIO_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "CubeButton"));			m_pSphereButton = GTK_RADIO_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "SphereButton"));			g_signal_connect(G_OBJECT(m_pCubeButton), "toggled", G_CALLBACK(setVoxelObjectCallback), this);			g_signal_connect(G_OBJECT(m_pSphereButton), "toggled", G_CALLBACK(setVoxelObjectCallback), this);			g_signal_connect(G_OBJECT(gtk_builder_get_object(m_pBuilderInterface, "ModifyColorToolButton")), "toggled", G_CALLBACK(toggleColorModificationCallback), this);			g_signal_connect(G_OBJECT(gtk_builder_get_object(m_pBuilderInterface, "ModifyTransparencyToolButton")), "toggled", G_CALLBACK(toggleTransparencyModificationCallback), this);			g_signal_connect(G_OBJECT(gtk_builder_get_object(m_pBuilderInterface, "ModifySizeToolButton")), "toggled", G_CALLBACK(toggleSizeModificationCallback), this);			//min voxel scale factor			m_pMinScaleFactorSpinButton = GTK_SPIN_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "MinScaleFactorSpinButton"));			m_rVoxelDisplay.setMinScaleFactor(m_f64MinScaleFactor);			gtk_spin_button_configure(				m_pMinScaleFactorSpinButton,				GTK_ADJUSTMENT(gtk_adjustment_new(					m_f64MinScaleFactor, //initial value					0, //lower					5, //upper					0.1, //step increment					0.5, //page increment					0)), //page size - deprecated					0.1, //climb rate					1); //digits			g_signal_connect(G_OBJECT(m_pMinScaleFactorSpinButton), "value-changed", G_CALLBACK(setMinScaleFactorCallback), this);			//max voxel scale factor			m_pMaxScaleFactorSpinButton = GTK_SPIN_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "MaxScaleFactorSpinButton"));			m_rVoxelDisplay.setMaxScaleFactor(m_f64MaxScaleFactor);			gtk_spin_button_configure(				m_pMaxScaleFactorSpinButton,				GTK_ADJUSTMENT(gtk_adjustment_new(					m_f64MaxScaleFactor, //initial value					0, //lower					5, //upper					0.1, //step increment					0.5, //page increment					0)), //page size - deprecated					0.1, //climb rate					1); //digits			g_signal_connect(G_OBJECT(m_pMaxScaleFactorSpinButton), "value-changed", G_CALLBACK(setMaxScaleFactorCallback), this);			boolean l_bInclusiveDisplayThresholdBoundary = true;			m_rVoxelDisplay.setDisplayThresholdBoundaryType(l_bInclusiveDisplayThresholdBoundary);			//AND/OR label			m_pThresholdRangeAndOrLabel = GTK_LABEL(gtk_builder_get_object(m_pBuilderInterface, "ThresholdRangeAndOrLabel"));			gtk_label_set_label(m_pThresholdRangeAndOrLabel, l_bInclusiveDisplayThresholdBoundary? "AND" : "OR");			//min display threshold boundary type			m_pMinDisplayThresholdBoundaryButton = GTK_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "MinDisplayThresholdBoundaryButton"));			gtk_button_set_label(m_pMinDisplayThresholdBoundaryButton, l_bInclusiveDisplayThresholdBoundary ? ">" : "<");			g_signal_connect(G_OBJECT(m_pMinDisplayThresholdBoundaryButton), "clicked", G_CALLBACK(setMinDisplayThresholdBoundaryTypeCallback), this);			//max display threshold boundary type			m_pMaxDisplayThresholdBoundaryButton = GTK_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "MaxDisplayThresholdBoundaryButton"));			gtk_button_set_label(m_pMaxDisplayThresholdBoundaryButton, l_bInclusiveDisplayThresholdBoundary ? "<" : ">");			g_signal_connect(G_OBJECT(m_pMaxDisplayThresholdBoundaryButton), "clicked", G_CALLBACK(setMaxDisplayThresholdBoundaryTypeCallback), this);			//min display threshold slider			m_pMinDisplayThresholdScale = GTK_SCALE(gtk_hscale_new_with_range(0.0, 1.0, 0.01));			m_rVoxelDisplay.setMinDisplayThreshold(m_f64MinDisplayThreshold);			gtk_range_set_value(GTK_RANGE(m_pMinDisplayThresholdScale), m_f64MinDisplayThreshold);			gtk_scale_set_value_pos(m_pMinDisplayThresholdScale, GTK_POS_TOP);			gtk_range_set_update_policy(GTK_RANGE(m_pMinDisplayThresholdScale), GTK_UPDATE_CONTINUOUS);			gtk_widget_set_size_request(GTK_WIDGET(m_pMinDisplayThresholdScale), 100, -1);			gtk_widget_show_all(GTK_WIDGET(m_pMinDisplayThresholdScale));//.........这里部分代码省略.........

//.........这里部分代码省略.........		// Now specify how the current HF should be used		vbox2 = gtk_vbox_new(FALSE,0);	gtk_widget_show(GTK_WIDGET(vbox2));		frame2 = define_frame_with_hiding_arrows ("Use of current height field", vbox2, hfw->hf_options->tools_window, FALSE);	gtk_box_pack_start(GTK_BOX(vbox), frame2, FALSE, FALSE, 0.5*DEF_PAD);		// Vbox3: "USE AS GUIDE" dialog (for adding noise)		guide_box = gtk_vbox_new(FALSE,DEF_PAD);	gtk_widget_show(GTK_WIDGET(guide_box));		check_box = define_check_button_in_box ("Gener noise anyway?", guide_box, 0, 0, 0);	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_box),vs->gener_noise);	gtk_signal_connect (GTK_OBJECT(check_box), "toggled",		GTK_SIGNAL_FUNC(toggle_check_button_callb), (gpointer) &vs->gener_noise);		// Preview box	preview_box = gtk_hbox_new(FALSE,DEF_PAD);	gtk_widget_show(GTK_WIDGET(preview_box));		vds->noise_preview =		view_struct_new(NOISE_PREVIEW_SIZE,NOISE_PREVIEW_SIZE,(gpointer) compute_noise_preview,(gpointer)  hfw->hf_options->img);	gtk_box_pack_start(GTK_BOX(preview_box), vds->noise_preview->area, TRUE, TRUE, DEF_PAD *0.5);		vbox3 =  seed_dialog_new_lbl(hfw->hf_options->img, vs->noise_opt->seed, change_noise_seed, FALSE, VERTICAL_BOX );		adj = gtk_adjustment_new (0, -4, 4, 1, 1, 0.1);	    	scale = gtk_hscale_new (GTK_ADJUSTMENT (adj));	gtk_widget_set_usize(scale,75,0);	gtk_scale_set_digits (GTK_SCALE (scale), 0); 	gtk_box_pack_start (GTK_BOX (vbox3), scale, TRUE, TRUE, DEF_PAD*0.5); 	gtk_widget_show (scale);		gtk_signal_connect (GTK_OBJECT (adj), "value_changed",		GTK_SIGNAL_FUNC(gint_adj_callb), &vs->noise_opt->roughness);	gtk_signal_connect (GTK_OBJECT (adj), "value_changed",		GTK_SIGNAL_FUNC(draw_area_callb), vds->noise_preview);			gtk_box_pack_start(GTK_BOX(preview_box), vbox3, TRUE, TRUE, DEF_PAD*0.5);		gtk_box_pack_start(GTK_BOX(guide_box), preview_box, FALSE, FALSE, 0.5*DEF_PAD);		gtk_signal_connect (GTK_OBJECT (check_box), "toggled",	       (GtkSignalFunc) show_if_true, (gpointer) preview_box);	       		if (vs->gener_noise==FALSE)		gtk_widget_hide(GTK_WIDGET(preview_box));			// Scale for the noise level		hbox2 = gtk_hbox_new(FALSE,DEF_PAD);	gtk_widget_show(GTK_WIDGET(hbox2));	define_label_in_box("Noise level", hbox2, FALSE,TRUE, DEF_PAD); 	vds->adj_noise_level = gtk_adjustment_new (		vs->noise_level,0.0, 100.0, 1, 1, 0.0);	wdg = define_scale_in_box(vds->adj_noise_level,hbox2,0,DEF_PAD);	gtk_signal_connect (GTK_OBJECT (vds->adj_noise_level), "value_changed", GTK_SIGNAL_FUNC (gint_adj_callb), (gpointer) &vs->noise_level);	gtk_signal_connect (GTK_OBJECT (vds->adj_noise_level), "value_changed", GTK_SIGNAL_FUNC (gboolean_set_false), (gpointer) &hfw->if_calculated); 			gtk_signal_connect (GTK_OBJECT (check_box), "toggled",	       (GtkSignalFunc) show_if_true, (gpointer) hbox2);

//.........这里部分代码省略.........  vbox = gtk_vbox_new (FALSE, 6);  gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);  gtk_widget_show (vbox);  /* Page Size */  button = gtk_button_new_with_mnemonic (_("_Adjust Page Size "                                           "and Orientation"));  gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0);  g_signal_connect (G_OBJECT (button), "clicked",                    G_CALLBACK (page_setup_cb),                    info);  gtk_widget_show (button);  /* Center */  GtkWidget *combo;  const PrintCenterName *center;  hbox = gtk_hbox_new (FALSE, 6);  gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);  gtk_widget_show (hbox);  label = gtk_label_new_with_mnemonic (_("C_enter:"));  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);  gtk_widget_show (label);  combo = gtk_combo_box_new_text ();  for (center = center_modes; center->name; center++) {    gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _(center->name));  }  gtk_combo_box_set_active(GTK_COMBO_BOX(combo), VIK_PRINT_CENTER_BOTH);  gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0);  gtk_widget_show (combo);  gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);  g_signal_connect(combo, "changed",                   G_CALLBACK(center_changed_cb), info);  info->center_combo = combo;  /* ignore page margins */  button = gtk_check_button_new_with_mnemonic (_("Ignore Page _Margins"));  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),                                data->use_full_page);  gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0);  g_signal_connect (button, "toggled",                    G_CALLBACK (full_page_toggled_cb),                    info);  gtk_widget_show (button);  /* scale */  vbox = gtk_vbox_new (FALSE, 1);  gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);  gtk_widget_show (vbox);  hbox = gtk_hbox_new (FALSE, 6);  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);  gtk_widget_show (hbox);  label = gtk_label_new_with_mnemonic (_("Image S_ize:"));  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);  gtk_widget_show (label);  label = gtk_label_new (NULL);  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);  info->scale_label = label;  gtk_box_pack_start (GTK_BOX (hbox), info->scale_label, TRUE, TRUE, 0);  gtk_widget_show (info->scale_label);  info->scale = gtk_hscale_new_with_range(1, 100, 1);  gtk_box_pack_start (GTK_BOX (vbox), info->scale, TRUE, TRUE, 0);  gtk_scale_set_draw_value(GTK_SCALE(info->scale), FALSE);  gtk_widget_show (info->scale);  gtk_label_set_mnemonic_widget (GTK_LABEL (label), info->scale);  g_signal_connect(info->scale, "change_value",                   G_CALLBACK(scale_change_value_cb), info);  info->preview = vik_print_preview_new (setup, GDK_DRAWABLE(vik_viewport_get_pixmap(data->vvp)));  vik_print_preview_set_use_full_page (VIK_PRINT_PREVIEW(info->preview),                                        data->use_full_page);  gtk_box_pack_start (GTK_BOX (main_hbox), info->preview, TRUE, TRUE, 0);  gtk_widget_show (info->preview);  g_signal_connect (info->preview, "offsets-changed",                    G_CALLBACK (preview_offsets_changed_cb),                    info);  update_page_setup (info);  gdouble offset_x_max, offset_y_max;  get_max_offsets (info, &offset_x_max, &offset_y_max);  vik_print_preview_set_image_offsets_max (VIK_PRINT_PREVIEW (info->preview),                                            offset_x_max, offset_y_max);  set_scale_value(info);    return layout;}

static void wibuti_prefs_init(WibutiPrefs *self) {	GError *err = NULL;	char *markup = "";	GtkBox *main_box = GTK_BOX(gtk_vbox_new(FALSE, 5));	GtkNotebook *notebook = GTK_NOTEBOOK(gtk_notebook_new());	GtkButton *btn_close = GTK_BUTTON(gtk_button_new_from_stock(GTK_STOCK_CLOSE));	GtkButtonBox *btnbox = GTK_BUTTON_BOX(gtk_hbutton_box_new());	GtkLabel *label_layout_tip = GTK_LABEL(gtk_label_new(""));	self->builder = gtk_builder_new();#ifdef WIBUTI_WITH_BUTTONS	GtkAlignment *alignment_theme, *alignment_buttons;	GtkLabel *label_theme, *label_buttons;	gtk_builder_add_from_file(self->builder, WIBUTI_PATH_BUTTONS_UI, &err);	if (err != NULL) {		g_fprintf(stderr, "%s/n", err->message);		g_error_free(err);	} else {		alignment_theme = GTK_ALIGNMENT(gtk_builder_get_object(self->builder, "alignment_theme"));		alignment_buttons = GTK_ALIGNMENT(gtk_builder_get_object(self->builder, "alignment_buttons"));		self->combo_theme = GTK_COMBO_BOX(gtk_builder_get_object(self->builder, CFG_THEME));		self->chkb_hover_effect = GTK_TOGGLE_BUTTON(gtk_builder_get_object(self->builder, CFG_HOVER_EFFECT));		self->chkb_click_effect = GTK_TOGGLE_BUTTON(gtk_builder_get_object(self->builder, CFG_CLICK_EFFECT));		// fill themes combo		GtkListStore *list_store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);		GtkCellRenderer *renderer = gtk_cell_renderer_text_new();		gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(self->combo_theme), renderer, TRUE);		gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(self->combo_theme), renderer, "text", 0, NULL);		gtk_combo_box_set_model(self->combo_theme, GTK_TREE_MODEL(list_store));		const gchar *subdir;		GDir *dir = g_dir_open(WIBUTI_PATH_THEMES, 0, NULL);		while ((subdir = g_dir_read_name(dir)) != NULL) {			GtkTreeIter iter;			gtk_list_store_append(list_store, &iter);			gtk_list_store_set(list_store, &iter, 0, subdir, 1, 0, -1);		}		g_dir_close(dir);		// pack to notebook		label_theme = GTK_LABEL(gtk_label_new("Themes"));		gtk_notebook_append_page(notebook, GTK_WIDGET(alignment_theme), GTK_WIDGET(label_theme));		label_buttons = GTK_LABEL(gtk_label_new("Buttons"));		gtk_notebook_append_page(notebook, GTK_WIDGET(alignment_buttons), GTK_WIDGET(label_buttons));				markup = g_strconcat(markup, "<b>M</b> - ", "minimize", "/n<b>R</b> - ", "maximize/restore", 		                             "/n<b>X</b> - ", "close", "/n", NULL);	}#endif // WIBUTI_WITH_BUTTONS#ifdef WIBUTI_WITH_TITLE	GtkAlignment *alignment_title;	GtkLabel *label_title;	gtk_builder_add_from_file(self->builder, WIBUTI_PATH_TITLE_UI, &err);	if (err != NULL) {		g_fprintf(stderr, "%s/n", err->message);		g_error_free(err);	} else {		alignment_title = GTK_ALIGNMENT(gtk_builder_get_object(self->builder, "alignment_title"));				self->chkb_expand_title = GTK_TOGGLE_BUTTON(gtk_builder_get_object(self->builder, CFG_EXPAND_TITLE));		self->chkb_custom_style = GTK_TOGGLE_BUTTON(gtk_builder_get_object(self->builder, CFG_CUSTOM_STYLE));				self->btn_font_active = GTK_FONT_BUTTON(gtk_builder_get_object(self->builder, "btn_font_active"));		self->btn_font_inactive = GTK_FONT_BUTTON(gtk_builder_get_object(self->builder, "btn_font_inactive"));		self->btn_color_active = GTK_COLOR_BUTTON(gtk_builder_get_object(self->builder, "btn_color_active"));		self->btn_color_inactive = GTK_COLOR_BUTTON(gtk_builder_get_object(self->builder, "btn_color_inactive"));		self->scale_alignment = GTK_SCALE(gtk_builder_get_object(self->builder, "scale_alignment"));		// pack to notebook		label_title = GTK_LABEL(gtk_label_new("Title"));		gtk_notebook_append_page(notebook, GTK_WIDGET(alignment_title), GTK_WIDGET(label_title));				markup = g_strconcat(markup, "<b>I</b> - ", "icon", "/n<b>T</b> - ", "title", "/n", NULL);	}#endif // WIBUTI_WITH_TITLE		GtkAlignment *alignment_general;	GtkLabel *label_general;	gtk_builder_add_from_file(self->builder, WIBUTI_PATH_GENERAL_UI, &err);	if (err != NULL) {		g_fprintf(stderr, "%s/n", err->message);		g_error_free(err);	} else {		alignment_general = GTK_ALIGNMENT(gtk_builder_get_object(self->builder, "alignment_general"));		label_layout_tip = GTK_LABEL(gtk_builder_get_object(self->builder, "label_layout_tip"));		self->chkb_only_maximized = GTK_TOGGLE_BUTTON(gtk_builder_get_object(self->builder, CFG_ONLY_MAXIMIZED));		self->chkb_hide_unmaximized = GTK_TOGGLE_BUTTON(gtk_builder_get_object(self->builder, CFG_HIDE_ON_UNMAXIMIZED));		self->btn_reload_layout = GTK_BUTTON(gtk_builder_get_object(self->builder, "btn_reload_layout"));		self->entry_layout = GTK_ENTRY(gtk_builder_get_object(self->builder, "entry_layout"));				// pack to notebook//.........这里部分代码省略.........