int main (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); 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), freq); gtk_widget_set_size_request (widget, 25, 150); g_signal_connect (G_OBJECT (widget), "value-changed", G_CALLBACK (on_freq_changed), (gpointer) band); gtk_box_pack_start (GTK_BOX (scales_hbox), widget, TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (frame), scales_hbox); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); } gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (appwindow), vbox); gtk_widget_show_all (appwindow); gst_element_set_state (bin, GST_STATE_PLAYING); gtk_main (); gst_element_set_state (bin, GST_STATE_NULL); gst_object_unref (bin); return 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)); return GTK_WIDGET (object); } /* ctk_scale_new() */
extern void GTKShowRolls(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)); gtk_widget_set_sensitive (minus_btn, (options.scale_data.value > options.scale_data.min_value)); plus_btn = gtk_button_new_with_label ("+"); gtk_button_set_relief (GTK_BUTTON (plus_btn), GTK_RELIEF_NONE); g_signal_connect (G_OBJECT (plus_btn), "clicked", G_CALLBACK (vb_pressed), GINT_TO_POINTER (PLUS_BTN)); gtk_widget_set_sensitive (plus_btn, (options.scale_data.value < options.scale_data.max_value)); } /* create complex widget */ if (options.scale_data.buttons) gtk_box_pack_start (GTK_BOX (w), options.common_data.vertical ? plus_btn : minus_btn, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (w), scale, TRUE, TRUE, 2); if (options.scale_data.buttons) gtk_box_pack_start (GTK_BOX (w), options.common_data.vertical ? minus_btn : plus_btn, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (scale), "value-changed", G_CALLBACK (value_changed_cb), NULL); gtk_widget_grab_focus (scale); return w; }
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, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleContrast, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleContrast), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleContrast), 2); label3 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Contrast:")); gtk_widget_show (label3); gtk_table_attach (GTK_TABLE (table2), label3, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5); label1 = gtk_label_new (""); gtk_widget_show (label1); gtk_frame_set_label_widget (GTK_FRAME (frame1), label1); gtk_label_set_use_markup (GTK_LABEL (label1), TRUE); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); frame2 = gtk_frame_new (NULL); gtk_widget_show (frame2); gtk_box_pack_start (GTK_BOX (hbox1), frame2, TRUE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_NONE); table3 = gtk_table_new (5, 2, FALSE); gtk_widget_show (table3); gtk_container_add (GTK_CONTAINER (frame2), table3); gtk_container_set_border_width (GTK_CONTAINER (table3), 12); gtk_table_set_row_spacings (GTK_TABLE (table3), 6); gtk_table_set_col_spacings (GTK_TABLE (table3), 12); label6 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Initial:")); gtk_widget_show (label6); gtk_table_attach (GTK_TABLE (table3), label6, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5); hscaleGamma = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0))); gtk_widget_show (hscaleGamma); gtk_table_attach (GTK_TABLE (table3), hscaleGamma, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleGamma, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleGamma), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleGamma), 2); hscaleGammaR = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0))); gtk_widget_show (hscaleGammaR); gtk_table_attach (GTK_TABLE (table3), hscaleGammaR, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleGammaR, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaR), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleGammaR), 2); label8 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Red:")); gtk_widget_show (label8); gtk_table_attach (GTK_TABLE (table3), label8, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label8), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5); hscaleGammaG = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0))); gtk_widget_show (hscaleGammaG); gtk_table_attach (GTK_TABLE (table3), hscaleGammaG, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleGammaG, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaG), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleGammaG), 2); label9 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Green:")); gtk_widget_show (label9); gtk_table_attach (GTK_TABLE (table3), label9, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label9), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label9), 0, 0.5); label10 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Blue:")); gtk_widget_show (label10); gtk_table_attach (GTK_TABLE (table3), label10, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label10), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label10), 0, 0.5); label7 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Weight:")); gtk_widget_show (label7); gtk_table_attach (GTK_TABLE (table3), label7, 0, 1, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label7), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5); hscaleGammaB = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0))); gtk_widget_show (hscaleGammaB); gtk_table_attach (GTK_TABLE (table3), hscaleGammaB, 1, 2, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleGammaB, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaB), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleGammaB), 2); hscaleGammaWeight = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0, 1, 0.05, 1, 0))); gtk_widget_show (hscaleGammaWeight); gtk_table_attach (GTK_TABLE (table3), hscaleGammaWeight, 1, 2, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleGammaWeight, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaWeight), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleGammaWeight), 2); label2 = gtk_label_new (QT_TR_NOOP("<b>Gamma</b>")); gtk_widget_show (label2); gtk_frame_set_label_widget (GTK_FRAME (frame2), label2); gtk_label_set_use_markup (GTK_LABEL (label2), TRUE); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 100, 1, 1, 0))); gtk_widget_show (hscale1); gtk_box_pack_start (GTK_BOX (vbox1), hscale1, FALSE, FALSE, 0); drawingarea1 = gtk_drawing_area_new (); gtk_widget_show (drawingarea1); gtk_box_pack_start (GTK_BOX (vbox1), drawingarea1, TRUE, TRUE, 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); gtk_label_set_mnemonic_widget (GTK_LABEL (label4), hscaleBrightness); gtk_label_set_mnemonic_widget (GTK_LABEL (label5), hscaleSaturation); gtk_label_set_mnemonic_widget (GTK_LABEL (label3), hscaleContrast); gtk_label_set_mnemonic_widget (GTK_LABEL (label6), hscaleGamma); gtk_label_set_mnemonic_widget (GTK_LABEL (label8), hscaleGammaR); gtk_label_set_mnemonic_widget (GTK_LABEL (label9), hscaleGammaG); gtk_label_set_mnemonic_widget (GTK_LABEL (label10), hscaleGammaB); gtk_label_set_mnemonic_widget (GTK_LABEL (label7), hscaleGammaWeight); /* 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, frame1, "frame1"); GLADE_HOOKUP_OBJECT (dialog1, table2, "table2"); GLADE_HOOKUP_OBJECT (dialog1, label4, "label4"); GLADE_HOOKUP_OBJECT (dialog1, label5, "label5"); GLADE_HOOKUP_OBJECT (dialog1, hscaleBrightness, "hscaleBrightness"); GLADE_HOOKUP_OBJECT (dialog1, hscaleSaturation, "hscaleSaturation"); GLADE_HOOKUP_OBJECT (dialog1, hscaleContrast, "hscaleContrast"); GLADE_HOOKUP_OBJECT (dialog1, label3, "label3"); GLADE_HOOKUP_OBJECT (dialog1, label1, "label1"); GLADE_HOOKUP_OBJECT (dialog1, frame2, "frame2"); GLADE_HOOKUP_OBJECT (dialog1, table3, "table3"); GLADE_HOOKUP_OBJECT (dialog1, label6, "label6"); GLADE_HOOKUP_OBJECT (dialog1, hscaleGamma, "hscaleGamma"); GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaR, "hscaleGammaR"); GLADE_HOOKUP_OBJECT (dialog1, label8, "label8"); GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaG, "hscaleGammaG"); GLADE_HOOKUP_OBJECT (dialog1, label9, "label9"); GLADE_HOOKUP_OBJECT (dialog1, label10, "label10"); GLADE_HOOKUP_OBJECT (dialog1, label7, "label7"); GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaB, "hscaleGammaB"); GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaWeight, "hscaleGammaWeight"); GLADE_HOOKUP_OBJECT (dialog1, label2, "label2"); GLADE_HOOKUP_OBJECT (dialog1, hscale1, "hscale1"); GLADE_HOOKUP_OBJECT (dialog1, drawingarea1, "drawingarea1"); 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; }
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; }
static void configure() { GtkWidget *notebook1; GtkWidget *vbox; GtkWidget *vbox1; GtkWidget *hbox1; GtkWidget *Resolution_Frame; GtkWidget *vbox4; GSList *resolution_group = NULL; GtkWidget *Channels_Frame; GtkWidget *vbox5; GSList *vbox5_group = NULL; GtkWidget *Downsample_Frame; GtkWidget *vbox3; GSList *sample_group = NULL; GtkWidget *vbox6; GtkWidget *Quality_Label; GtkWidget *Options_Label; GtkWidget *pansep_label, *pansep_hscale; GtkWidget *bbox; GtkWidget *ok; GtkWidget *cancel; if (xmp_conf_window) { gdk_window_raise(xmp_conf_window->window); return; } xmp_conf_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "xmp_conf_window", xmp_conf_window); gtk_window_set_title(GTK_WINDOW(xmp_conf_window), "XMP Configuration"); gtk_window_set_policy(GTK_WINDOW(xmp_conf_window), FALSE, FALSE, FALSE); gtk_window_set_position(GTK_WINDOW(xmp_conf_window), GTK_WIN_POS_MOUSE); gtk_signal_connect(GTK_OBJECT(xmp_conf_window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed),&xmp_conf_window); gtk_container_border_width(GTK_CONTAINER(xmp_conf_window), 10); vbox = gtk_vbox_new(FALSE, 10); gtk_container_add(GTK_CONTAINER(xmp_conf_window), vbox); notebook1 = gtk_notebook_new(); gtk_object_set_data(GTK_OBJECT(xmp_conf_window),"notebook1", notebook1); gtk_widget_show(notebook1); gtk_box_pack_start(GTK_BOX(vbox), notebook1, TRUE, TRUE, 0); gtk_container_border_width(GTK_CONTAINER(notebook1), 3); vbox1 = gtk_vbox_new(FALSE, 0); gtk_object_set_data(GTK_OBJECT(xmp_conf_window),"vbox1", vbox1); gtk_widget_show(vbox1); hbox1 = gtk_hbox_new(FALSE, 0); gtk_object_set_data(GTK_OBJECT(xmp_conf_window),"hbox1", hbox1); gtk_widget_show(hbox1); gtk_box_pack_start(GTK_BOX(vbox1), hbox1, TRUE, TRUE, 0); Resolution_Frame = gtk_frame_new("Resolution"); gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "Resolution_Frame", Resolution_Frame); gtk_widget_show(Resolution_Frame); gtk_box_pack_start(GTK_BOX(hbox1), Resolution_Frame, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER (Resolution_Frame), 5); vbox4 = gtk_vbox_new(FALSE, 0); gtk_object_set_data(GTK_OBJECT(xmp_conf_window),"vbox4", vbox4); gtk_widget_show(vbox4); gtk_container_add(GTK_CONTAINER(Resolution_Frame), vbox4); Res_16 = gtk_radio_button_new_with_label(resolution_group, "16 bit"); resolution_group = gtk_radio_button_group(GTK_RADIO_BUTTON(Res_16)); gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "Res_16", Res_16); gtk_widget_show(Res_16); gtk_box_pack_start(GTK_BOX(vbox4), Res_16, TRUE, TRUE, 0); if (xmp_cfg.force8bit == 0) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(Res_16), TRUE); Res_8 = gtk_radio_button_new_with_label(resolution_group, "8 bit"); resolution_group = gtk_radio_button_group(GTK_RADIO_BUTTON(Res_8)); gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "Res_8", Res_8); gtk_widget_show(Res_8); gtk_box_pack_start(GTK_BOX(vbox4), Res_8, TRUE, TRUE, 0); if (xmp_cfg.force8bit == 1) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(Res_8), TRUE); Channels_Frame = gtk_frame_new("Channels"); gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "Channels_Frame", Channels_Frame); gtk_widget_show(Channels_Frame); gtk_box_pack_start(GTK_BOX(hbox1), Channels_Frame, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(Channels_Frame), 5); vbox5 = gtk_vbox_new(FALSE, 0); gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "vbox5", vbox5); gtk_widget_show(vbox5); gtk_container_add(GTK_CONTAINER(Channels_Frame), vbox5); Chan_ST = gtk_radio_button_new_with_label(vbox5_group, "Stereo"); vbox5_group = gtk_radio_button_group(GTK_RADIO_BUTTON(Chan_ST)); gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "Chan_ST", Chan_ST); gtk_widget_show(Chan_ST); gtk_box_pack_start(GTK_BOX(vbox5), Chan_ST, TRUE, TRUE, 0); if (xmp_cfg.force_mono == 0) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(Chan_ST), TRUE); Chan_MO = gtk_radio_button_new_with_label(vbox5_group, "Mono"); vbox5_group = gtk_radio_button_group(GTK_RADIO_BUTTON(Chan_MO)); gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "Chan_MO", Chan_MO); gtk_widget_show(Chan_MO); gtk_box_pack_start(GTK_BOX(vbox5), Chan_MO, TRUE, TRUE, 0); if (xmp_cfg.force_mono == 1) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(Chan_MO), TRUE); Downsample_Frame = gtk_frame_new("Sampling rate"); gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "Downsample_Frame", Downsample_Frame); gtk_widget_show(Downsample_Frame); gtk_box_pack_start(GTK_BOX(vbox1), Downsample_Frame, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(Downsample_Frame), 5); vbox3 = gtk_vbox_new(FALSE, 0); gtk_object_set_data(GTK_OBJECT(xmp_conf_window), "vbox3", vbox3); 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); gtk_signal_connect (GTK_OBJECT (button_ok), "clicked", GTK_SIGNAL_FUNC (gui_ok), (void *)1); gtk_signal_connect (GTK_OBJECT (button_ko), "clicked", GTK_SIGNAL_FUNC (gui_ok), (void *)0); return dialog1; }
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); gtk_widget_show (maxValueHbox); gtk_box_pack_start (GTK_BOX (maxValueVbox), maxValueHbox, TRUE, TRUE, 0); #ifdef ORIGINAL_CODE_GENERATED_BY_GLADE maxValueSlider = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (255, 0, 255, 1, 1, 0))); #else maxValueSpinner_adj = gtk_adjustment_new (255, 0, 255, 1, 1, 0); maxValueSlider = gtk_hscale_new (GTK_ADJUSTMENT (maxValueSpinner_adj)); #endif gtk_widget_show (maxValueSlider); gtk_box_pack_start (GTK_BOX (maxValueHbox), maxValueSlider, TRUE, TRUE, 0); gtk_scale_set_draw_value (GTK_SCALE (maxValueSlider), FALSE); gtk_scale_set_value_pos (GTK_SCALE (maxValueSlider), GTK_POS_LEFT); gtk_scale_set_digits (GTK_SCALE (maxValueSlider), 0); #ifdef ORIGINAL_CODE_GENERATED_BY_GLADE maxValueSpinner_adj = gtk_adjustment_new (255, 0, 255, 1, 10, 10); #endif maxValueSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (maxValueSpinner_adj), 1, 0); gtk_widget_show (maxValueSpinner); gtk_box_pack_start (GTK_BOX (maxValueHbox), maxValueSpinner, FALSE, TRUE, 0); outputValuesHbox = gtk_hbox_new (FALSE, 0); gtk_widget_show (outputValuesHbox); gtk_box_pack_start (GTK_BOX (settingsOuterVbox), outputValuesHbox, TRUE, TRUE, 0); outputValuesLabel = gtk_label_new (QT_TR_NOOP("Output values: ")); gtk_widget_show (outputValuesLabel); gtk_box_pack_start (GTK_BOX (outputValuesHbox), outputValuesLabel, FALSE, FALSE, 0); outputValuesMenu = gtk_combo_box_new_text (); gtk_widget_show (outputValuesMenu); gtk_box_pack_start (GTK_BOX (outputValuesHbox), outputValuesMenu, TRUE, TRUE, 0); gtk_combo_box_append_text (GTK_COMBO_BOX (outputValuesMenu), QT_TR_NOOP("In-range values go black, out-of-range values go white")); gtk_combo_box_append_text (GTK_COMBO_BOX (outputValuesMenu), QT_TR_NOOP("In-range values go white, out-of-range values go black")); debugHbox = gtk_hbox_new (FALSE, 0); gtk_widget_show (debugHbox); gtk_box_pack_start (GTK_BOX (settingsOuterVbox), debugHbox, TRUE, TRUE, 0); debugLabel = gtk_label_new (QT_TR_NOOP("Debugging settings (bits): ")); gtk_widget_show (debugLabel); gtk_box_pack_start (GTK_BOX (debugHbox), debugLabel, FALSE, FALSE, 0); debugSpinButton_adj = gtk_adjustment_new (0, 0, 16777215, 1, 10, 10); debugSpinButton = gtk_spin_button_new (GTK_ADJUSTMENT (debugSpinButton_adj), 1, 0); gtk_widget_show (debugSpinButton); gtk_box_pack_start (GTK_BOX (debugHbox), debugSpinButton, TRUE, TRUE, 0); previewFrame = gtk_frame_new (NULL); gtk_widget_show (previewFrame); gtk_box_pack_start (GTK_BOX (allButButtonsVbox), previewFrame, TRUE, TRUE, 0); previewAlignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (previewAlignment); gtk_container_add (GTK_CONTAINER (previewFrame), previewAlignment); gtk_alignment_set_padding (GTK_ALIGNMENT (previewAlignment), 0, 8, 6, 8); previewVbox = gtk_vbox_new (FALSE, 5); gtk_widget_show (previewVbox); gtk_container_add (GTK_CONTAINER (previewAlignment), previewVbox); previewControlHbox = gtk_hbox_new (FALSE, 5); gtk_widget_show (previewControlHbox); gtk_box_pack_start (GTK_BOX (previewVbox), previewControlHbox, TRUE, TRUE, 0); previewOutputMenu = gtk_combo_box_new_text (); gtk_widget_show (previewOutputMenu); gtk_box_pack_start (GTK_BOX (previewControlHbox), previewOutputMenu, FALSE, TRUE, 0); previewSlider = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 99, 1, 1, 1))); gtk_widget_show (previewSlider); gtk_box_pack_start (GTK_BOX (previewControlHbox), previewSlider, TRUE, TRUE, 0); gtk_scale_set_digits (GTK_SCALE (previewSlider), 0); previewVideo = gtk_drawing_area_new (); gtk_widget_show (previewVideo); gtk_box_pack_start (GTK_BOX (previewVbox), previewVideo, TRUE, TRUE, 0); gtk_widget_set_size_request (previewVideo, 30, 30); gtk_widget_set_events (previewVideo, GDK_BUTTON1_MOTION_MASK | GDK_BUTTON_PRESS_MASK); previewLabel = gtk_label_new (QT_TR_NOOP("Preview")); gtk_widget_show (previewLabel); gtk_frame_set_label_widget (GTK_FRAME (previewFrame), previewLabel); dialogButtonBox = GTK_DIALOG (threshold_dialog)->action_area; gtk_widget_show (dialogButtonBox); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialogButtonBox), GTK_BUTTONBOX_END); cancelButton = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelButton); gtk_dialog_add_action_widget (GTK_DIALOG (threshold_dialog), cancelButton, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelButton, GTK_CAN_DEFAULT); okButton = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okButton); gtk_dialog_add_action_widget (GTK_DIALOG (threshold_dialog), okButton, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okButton, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (threshold_dialog, threshold_dialog, "threshold_dialog"); GLADE_HOOKUP_OBJECT_NO_REF (threshold_dialog, dialogVbox, "dialogVbox"); GLADE_HOOKUP_OBJECT (threshold_dialog, allButButtonsVbox, "allButButtonsVbox"); GLADE_HOOKUP_OBJECT (threshold_dialog, settingsOuterHbox, "settingsOuterHbox"); GLADE_HOOKUP_OBJECT (threshold_dialog, settingsOuterVbox, "settingsOuterVbox"); GLADE_HOOKUP_OBJECT (threshold_dialog, minValueVbox, "minValueVbox"); GLADE_HOOKUP_OBJECT (threshold_dialog, minValueLabel, "minValueLabel"); GLADE_HOOKUP_OBJECT (threshold_dialog, minValueHbox, "minValueHbox"); GLADE_HOOKUP_OBJECT (threshold_dialog, minValueSlider, "minValueSlider"); GLADE_HOOKUP_OBJECT (threshold_dialog, minValueSpinner, "minValueSpinner"); GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueVbox, "maxValueVbox"); GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueLabel, "maxValueLabel"); GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueHbox, "maxValueHbox"); GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueSlider, "maxValueSlider"); GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueSpinner, "maxValueSpinner"); GLADE_HOOKUP_OBJECT (threshold_dialog, outputValuesHbox, "outputValuesHbox"); GLADE_HOOKUP_OBJECT (threshold_dialog, outputValuesLabel, "outputValuesLabel"); GLADE_HOOKUP_OBJECT (threshold_dialog, outputValuesMenu, "outputValuesMenu"); GLADE_HOOKUP_OBJECT (threshold_dialog, debugHbox, "debugHbox"); GLADE_HOOKUP_OBJECT (threshold_dialog, debugLabel, "debugLabel"); GLADE_HOOKUP_OBJECT (threshold_dialog, debugSpinButton, "debugSpinButton"); GLADE_HOOKUP_OBJECT (threshold_dialog, previewFrame, "previewFrame"); GLADE_HOOKUP_OBJECT (threshold_dialog, previewAlignment, "previewAlignment"); GLADE_HOOKUP_OBJECT (threshold_dialog, previewVbox, "previewVbox"); GLADE_HOOKUP_OBJECT (threshold_dialog, previewControlHbox, "previewControlHbox"); GLADE_HOOKUP_OBJECT (threshold_dialog, previewOutputMenu, "previewOutputMenu"); GLADE_HOOKUP_OBJECT (threshold_dialog, previewSlider, "previewSlider"); GLADE_HOOKUP_OBJECT (threshold_dialog, previewVideo, "previewVideo"); GLADE_HOOKUP_OBJECT (threshold_dialog, previewLabel, "previewLabel"); GLADE_HOOKUP_OBJECT_NO_REF (threshold_dialog, dialogButtonBox, "dialogButtonBox"); GLADE_HOOKUP_OBJECT (threshold_dialog, cancelButton, "cancelButton"); GLADE_HOOKUP_OBJECT (threshold_dialog, okButton, "okButton"); return threshold_dialog; }
GtkWidget * gu_playdeck_add(gu_window_t *gw, GtkWidget *parent) { GtkToolItem *ti; GtkWidget *w; GtkWidget *l; GtkWidget *vbox; GtkWidget *playdeck; playdeck_t *pd = calloc(1, sizeof(playdeck_t)); prop_courier_t *pc = gw->gw_gu->gu_pc; playdeck = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(parent), playdeck, FALSE, TRUE, 0); w = gtk_hseparator_new(); gtk_widget_show(w); gtk_box_pack_start(GTK_BOX(playdeck), w, FALSE, TRUE, 0); pd->root = gtk_hbox_new(FALSE, 1); gtk_widget_show(pd->root); gtk_box_pack_start(GTK_BOX(playdeck), pd->root, FALSE, TRUE, 0); /* Playdeck album art */ w = gtk_image_new(); gtk_widget_show(w); gtk_misc_set_alignment(GTK_MISC(w), 0, 1); gtk_box_pack_start(GTK_BOX(pd->root), w, FALSE, TRUE, 0); pd->sub_album_art = prop_subscribe(0, PROP_TAG_NAME("global", "media", "current", "metadata", "album_art"), PROP_TAG_CALLBACK_STRING, pd_set_albumart, w, PROP_TAG_COURIER, pc, NULL); /* Middle vbox */ vbox = gtk_vbox_new(FALSE, 1); gtk_box_pack_start(GTK_BOX(pd->root), vbox, TRUE, TRUE, 0); /* Title of current track */ l = gtk_label_new(""); gtk_misc_set_alignment(GTK_MISC(l), 0, 0); gtk_box_pack_start(GTK_BOX(vbox), l, TRUE, TRUE, 0); g_object_set(G_OBJECT(l), "ellipsize", PANGO_ELLIPSIZE_END, NULL); pd->sub_title = prop_subscribe(0, PROP_TAG_NAME("global", "media", "current", "metadata", "title"), PROP_TAG_CALLBACK_STRING, set_current_title, l, PROP_TAG_COURIER, pc, NULL); /* Title of current track */ pd->trackextra = gtk_label_new(""); g_object_set(G_OBJECT(pd->trackextra), "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_misc_set_alignment(GTK_MISC(pd->trackextra), 0, 0); gtk_box_pack_start(GTK_BOX(vbox), pd->trackextra, TRUE, TRUE, 0); pd->sub_album = prop_subscribe(0, PROP_TAG_NAME("global", "media", "current", "metadata", "album"), PROP_TAG_CALLBACK_STRING, set_current_album, pd, PROP_TAG_COURIER, pc, NULL); pd->sub_artist = prop_subscribe(0, PROP_TAG_NAME("global", "media", "current", "metadata", "artist"), PROP_TAG_CALLBACK_STRING, set_current_artist, pd, PROP_TAG_COURIER, pc, NULL); /* The toolbar */ pd->tbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(pd->tbar), GTK_TOOLBAR_ICONS); gtk_box_pack_start(GTK_BOX(vbox), pd->tbar, FALSE, TRUE, 0); /* Prev button */ pd->prev = ti = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_PREVIOUS); gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1); g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(prev_clicked), pd); pd->sub_canSkipBackward = prop_subscribe(0, PROP_TAG_NAME("global", "media", "current", "canSkipBackward"), PROP_TAG_CALLBACK_INT, gu_subscription_set_sensitivity, pd->prev, PROP_TAG_COURIER, pc, NULL); /* Play / Pause */ pd->playpause = ti = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_PLAY); gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1); g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(playpause_clicked), pd); pd->sub_canPause = prop_subscribe(0, PROP_TAG_NAME("global", "media", "current", "canPause"), 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]); gtk_scale_add_mark (GTK_SCALE (scale), bath_marks[1], GTK_POS_BOTTOM, bath_labels[1]); gtk_scale_add_mark (GTK_SCALE (scale), bath_marks[2], GTK_POS_BOTTOM, bath_labels[2]); gtk_scale_add_mark (GTK_SCALE (scale), bath_marks[3], GTK_POS_TOP, bath_labels[3]); gtk_container_add (GTK_CONTAINER (frame), scale); gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0); frame = gtk_frame_new ("Positions"); 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), pos_marks[0], GTK_POS_LEFT, pos_labels[0]); gtk_scale_add_mark (GTK_SCALE (scale), pos_marks[1], GTK_POS_RIGHT, pos_labels[1]); gtk_scale_add_mark (GTK_SCALE (scale), pos_marks[2], GTK_POS_TOP, pos_labels[2]); gtk_scale_add_mark (GTK_SCALE (scale), pos_marks[3], GTK_POS_BOTTOM, pos_labels[3]); gtk_container_add (GTK_CONTAINER (frame), scale); gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0); box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_container_add (GTK_CONTAINER (box1), box2); button = gtk_button_new_with_label ("Flip"); g_signal_connect (button, "clicked", G_CALLBACK (flip), NULL); gtk_container_add (GTK_CONTAINER (box2), button); button = gtk_button_new_with_label ("Invert"); g_signal_connect (button, "clicked", G_CALLBACK (invert), NULL); gtk_container_add (GTK_CONTAINER (box2), button); button = gtk_toggle_button_new_with_label ("Trough"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); g_signal_connect (button, "toggled", G_CALLBACK (trough), NULL); gtk_container_add (GTK_CONTAINER (box2), button); gtk_widget_show_all (window); button = gtk_toggle_button_new_with_label ("Extra"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE); g_signal_connect (button, "toggled", G_CALLBACK (extra), NULL); gtk_container_add (GTK_CONTAINER (box2), button); gtk_widget_show_all (window); gtk_main (); return 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); }
//=================================================================== MemObj GUI_Slider__ (MemObj *o_par, int typ, void *funcnam, double valMin, double valMax, double valStart, char *opts) { //=================================================================== /// \code /// GUI_Slider__ Slider = AdjustmentControl /// /// Input: /// parent parentBox /// typ 0=horizontal, 1=vertical. /// funcnam callBack-function for moving the slider; NULL = no callback. /// opts options; (HorSiz,VertSiz) /// HorSiz,VertSiz: size in characters; default is automatic size. /// 'e' = expand widget; default is fixed size. /// Examples: "" or "10" or "10e,e" /// "10e,e" horiz. size 10 chars, hor. and vert. expandable. /// /// funcnam prototyp: /// int funcnam (MemObj *mo, void **data); /// // 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); gtk_box_pack_start (GTK_BOX (w->controls), w->framerate_send_button, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (w->controls), w->exposure_label, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (w->controls), w->exposure_value_label, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (w->controls), w->exposure_hscale, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (w->controls), w->gain_label, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (w->controls), w->gain_value_label, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (w->controls), w->gain_hscale, FALSE, FALSE, 2); w->main_hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (w->main_hbox), w->video_window, TRUE, TRUE, 0); w->main_box = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (w->main_box), w->main_hbox, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (w->main_box), w->controls, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (w->main_window), w->main_box); gtk_window_set_default_size (GTK_WINDOW (w->main_window), HEIGHT, WIDTH); /* show all widgets we just added to out main window */ gtk_widget_show_all (w->main_window); return w; }
static void zoom_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)); w = WID ("contrastSlider"); priv->contrast_slider = w; init_effects_slider (GTK_RANGE(w), priv, contrast_keys, G_CALLBACK (contrast_slider_notify_cb)); w = WID ("grayscale_slider"); g_settings_bind (priv->settings, "color-saturation", gtk_range_get_adjustment (GTK_RANGE (w)), "value", G_SETTINGS_BIND_DEFAULT); gtk_scale_add_mark (GTK_SCALE(w), 1.0, GTK_POS_BOTTOM, NULL); /* ... Window itself ... */ priv->dialog = WID ("magPrefsDialog"); w = WID ("closeButton"); g_signal_connect (G_OBJECT (w), "clicked", G_CALLBACK (zoom_option_close_dialog_cb), priv); g_signal_connect (G_OBJECT (priv->dialog), "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL); pango_attr_list_unref (pango_attrs); }
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); gtk_table_attach (GTK_TABLE (table), scale, column + 1, column + 2, row, row + 1, GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0); gtk_widget_show (scale); gtk_table_attach (GTK_TABLE (table), spinbutton, column + 2, column + 3, row, row + 1, GTK_FILL | GTK_SHRINK, GTK_SHRINK, 0, 0); gtk_widget_show (spinbutton); if (tooltip || help_id) { gimp_help_set_help_data (label, tooltip, help_id); gimp_help_set_help_data (scale, tooltip, help_id); gimp_help_set_help_data (spinbutton, tooltip, help_id); } g_object_set_data (G_OBJECT (return_adj), "label", label); g_object_set_data (G_OBJECT (return_adj), "scale", scale); g_object_set_data (G_OBJECT (return_adj), "spinbutton", spinbutton); return return_adj; }
static void create_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(). */ 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, vbox3, "vbox3"); GLADE_HOOKUP_OBJECT (dialog1, label1, "label1"); GLADE_HOOKUP_OBJECT (dialog1, hscaleContrast, "hscaleContrast"); GLADE_HOOKUP_OBJECT (dialog1, label2, "label2"); GLADE_HOOKUP_OBJECT (dialog1, hscaleBright, "hscaleBright"); GLADE_HOOKUP_OBJECT (dialog1, vbox2, "vbox2"); GLADE_HOOKUP_OBJECT (dialog1, checkLuma, "checkLuma"); GLADE_HOOKUP_OBJECT (dialog1, checkbuttonU, "checkbuttonU"); GLADE_HOOKUP_OBJECT (dialog1, checkbuttonV, "checkbuttonV"); GLADE_HOOKUP_OBJECT (dialog1, hscale1, "hscale1"); GLADE_HOOKUP_OBJECT (dialog1, drawingarea1, "drawingarea1"); 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; }
/** * scale_entry_new: * @table: The #GtkTable the widgets will be attached to. * @column: The column to start with. * @row: The row to attach the widgets. * @text: The text for the #GtkLabel which will appear * left of the #GtkHScale. * @scale_usize: The minimum horizontal size of the #GtkHScale. * @spinbutton_usize: The minimum horizontal size of the #GtkSpinButton. * @value: The initial value. * @lower: The lower boundary. * @upper: The upper boundary. * @step_increment: The step increment. * @page_increment: The page increment. * @digits: The number of decimal digits. * @constrain: #TRUE if the range of possible values of the * #GtkSpinButton should be the same as of the #GtkHScale. * @unconstrained_lower: The spinbutton's lower boundary * if @constrain == #FALSE. * @unconstrained_upper: The spinbutton's upper boundary * if @constrain == #FALSE. * @tooltip: A tooltip message for the scale and the spinbutton. * * This function creates a #GtkLabel, a #GtkHScale and a #GtkSpinButton and * attaches them to a 3-column #GtkTable. * * Returns: The #GtkSpinButton's #GtkAdjustment. **/ 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)); g_signal_connect(G_OBJECT(m_pMinDisplayThresholdScale), "value_changed", G_CALLBACK(setMinDisplayThresholdCallback), this); //replace existing scale (which somehow can't be used) with the newly created one GtkWidget* l_pOldMinScale = GTK_WIDGET(gtk_builder_get_object(m_pBuilderInterface, "MinDisplayThresholdScale")); GtkWidget* l_pMinScaleParent = gtk_widget_get_parent(l_pOldMinScale); if(l_pMinScaleParent != NULL && GTK_IS_CONTAINER(l_pMinScaleParent)) { gtk_container_remove(GTK_CONTAINER(l_pMinScaleParent), l_pOldMinScale); if(GTK_IS_BOX(l_pMinScaleParent)) { gtk_box_pack_start(GTK_BOX(l_pMinScaleParent), GTK_WIDGET(m_pMinDisplayThresholdScale), TRUE, TRUE, 0); gtk_box_reorder_child(GTK_BOX(l_pMinScaleParent), GTK_WIDGET(m_pMinDisplayThresholdScale), 1); } } //max display threshold slider m_pMaxDisplayThresholdScale = GTK_SCALE(gtk_hscale_new_with_range(0.0, 1.0, 0.01)); m_rVoxelDisplay.setMaxDisplayThreshold(m_f64MaxDisplayThreshold); gtk_range_set_value(GTK_RANGE(m_pMaxDisplayThresholdScale), m_f64MaxDisplayThreshold); gtk_scale_set_value_pos(m_pMaxDisplayThresholdScale, GTK_POS_TOP); gtk_range_set_update_policy(GTK_RANGE(m_pMaxDisplayThresholdScale), GTK_UPDATE_CONTINUOUS); gtk_widget_set_size_request(GTK_WIDGET(m_pMaxDisplayThresholdScale), 100, -1); gtk_widget_show_all(GTK_WIDGET(m_pMaxDisplayThresholdScale)); g_signal_connect(G_OBJECT(m_pMaxDisplayThresholdScale), "value_changed", G_CALLBACK(setMaxDisplayThresholdCallback), this); //replace existing scale (which somehow can't be used) with the newly created one GtkWidget* l_pOldMaxScale = GTK_WIDGET(gtk_builder_get_object(m_pBuilderInterface, "MaxDisplayThresholdScale")); GtkWidget* l_pMaxScaleParent = gtk_widget_get_parent(l_pOldMaxScale); if(l_pMaxScaleParent != NULL && GTK_IS_CONTAINER(l_pMaxScaleParent)) { gtk_container_remove(GTK_CONTAINER(l_pMaxScaleParent), l_pOldMaxScale); if(GTK_IS_BOX(l_pMaxScaleParent)) { gtk_box_pack_start(GTK_BOX(l_pMaxScaleParent), GTK_WIDGET(m_pMaxDisplayThresholdScale), TRUE, TRUE, 0); gtk_box_reorder_child(GTK_BOX(l_pMaxScaleParent), GTK_WIDGET(m_pMaxDisplayThresholdScale), 1); } } //skull opacity slider GtkWidget* l_pSkullOpacityScale = gtk_hscale_new_with_range(0.0, 1.0, 0.05); float64 l_f64SkullOpacity = 0.07; gtk_range_set_value(GTK_RANGE(l_pSkullOpacityScale), l_f64SkullOpacity); m_rVoxelDisplay.setSkullOpacity(l_f64SkullOpacity); gtk_scale_set_value_pos(GTK_SCALE(l_pSkullOpacityScale), GTK_POS_TOP); gtk_range_set_update_policy(GTK_RANGE(l_pSkullOpacityScale), GTK_UPDATE_CONTINUOUS); gtk_widget_set_size_request(l_pSkullOpacityScale, 100, -1); gtk_widget_show_all(l_pSkullOpacityScale); g_signal_connect(G_OBJECT(l_pSkullOpacityScale), "value_changed", G_CALLBACK(setSkullOpacityCallback), this); //replace existing scale (which somehow can't be used) with the newly created one GtkWidget* l_pOldScale = GTK_WIDGET(gtk_builder_get_object(m_pBuilderInterface, "SkullOpacityScale")); GtkWidget* l_pScaleParent = gtk_widget_get_parent(l_pOldScale); if(l_pScaleParent != NULL && GTK_IS_CONTAINER(l_pScaleParent)) { gtk_container_remove(GTK_CONTAINER(l_pScaleParent), l_pOldScale); if(GTK_IS_BOX(l_pScaleParent)) { gtk_box_pack_start(GTK_BOX(l_pScaleParent), l_pSkullOpacityScale, TRUE, TRUE, 0); gtk_box_reorder_child(GTK_BOX(l_pScaleParent), l_pSkullOpacityScale, 0); } } //camera animation button GtkToggleToolButton* l_pAnimateCameraButton = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "AnimateCameraButton")); g_signal_connect(G_OBJECT(l_pAnimateCameraButton), "toggled", G_CALLBACK(toggleAnimateCameraCallback), this); //reposition camera g_signal_connect(G_OBJECT(gtk_builder_get_object(m_pBuilderInterface, "RepositionCamera")), "clicked", G_CALLBACK(repositionCameraCallback), this); this->toggleColorModificationCB(gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "ModifyColorToolButton")))?true:false); this->toggleTransparencyModificationCB(gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "ModifyTransparencyToolButton")))?true:false); this->toggleSizeModificationCB(gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "ModifySizeToolButton")))?true:false); this->enableAutoCameraMovementCB(gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "AnimateCameraButton")))?true:false); }
GtkWidget *voronoi_dialog_new (gpointer data) { GtkWidget *vbox, *vbox2, *vbox3, *guide_box, *hbox, *hbox1, *hbox2, *frame, *frame2, *button, *wdg, *check_box, *lblmax, *lblwidth, *button_uniform, *preview_box, *scale; GtkObject *adj; GSList *group = NULL, *group1 = NULL, *group2 = NULL, *group3 = NULL; voronoi_struct *vs; voronoi_dialog_struct *vds; hf_wrapper_struct *hfw; hfw = (hf_wrapper_struct *) * (hf_wrapper_struct **) data; vs = hfw->hf_options->img->voronoi; vds = hfw->hf_options->img->voronoi_dialog; frame = options_frame_new("Cracks network"); vbox = gtk_vbox_new(FALSE,DEF_PAD); gtk_widget_show(GTK_WIDGET(vbox)); hbox = gtk_hbox_new(FALSE,DEF_PAD); gtk_widget_show(GTK_WIDGET(hbox)); define_label_in_box("Average cell size", hbox, FALSE,TRUE, DEF_PAD); vds->adj_cell_size = gtk_adjustment_new ( vs->cell_size,0.0, 50.0, 0.1, 0.1, 0.0); define_scale_in_box(vds->adj_cell_size,hbox,1,DEF_PAD); gtk_signal_connect (GTK_OBJECT (vds->adj_cell_size), "value_changed", GTK_SIGNAL_FUNC (gdouble_adj_callb), (gpointer) &vs->cell_size); gtk_signal_connect (GTK_OBJECT (vds->adj_cell_size), "value_changed", GTK_SIGNAL_FUNC (gboolean_set_false), (gpointer) &hfw->if_calculated); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), seed_dialog_new(data, vs->seed, change_voronoi_seed), TRUE, TRUE, 0); // ******** Distribution of cells // Box for radio buttons vbox2 = gtk_vbox_new(FALSE,0); gtk_widget_show(GTK_WIDGET(vbox2)); frame2 = define_frame_with_hiding_arrows ("Cell distribution", vbox2, hfw->hf_options->tools_window, FALSE); gtk_box_pack_start(GTK_BOX(vbox), frame2, TRUE, TRUE, 0); // We need a scale for the REGULAR option, for controlling the perturbation hbox = gtk_hbox_new(FALSE,DEF_PAD); gtk_widget_show(GTK_WIDGET(hbox)); define_label_in_box("Random variation", hbox, FALSE,TRUE, DEF_PAD); vds->adj_random_variation = gtk_adjustment_new ( vs->random_variation,0.0, 100.0, 1, 1, 0.0); wdg = define_scale_in_box(vds->adj_random_variation,hbox,0,DEF_PAD); gtk_signal_connect (GTK_OBJECT (vds->adj_random_variation), "value_changed", GTK_SIGNAL_FUNC (gint_adj_callb), (gpointer) &vs->random_variation); gtk_signal_connect (GTK_OBJECT (vds->adj_random_variation), "value_changed", GTK_SIGNAL_FUNC (gboolean_set_false), (gpointer) &hfw->if_calculated); // We need a row of buttons for controlling the scale (multiple or not) hbox1 = gtk_hbox_new(FALSE,DEF_PAD); define_label_in_box("Scale", hbox1, FALSE,TRUE, DEF_PAD); gtk_widget_show(GTK_WIDGET(hbox1)); define_radio_button_in_box_with_data (hbox1, &group1, "1X", set_scale_1x, &vs->scale, (vs->scale==SCALE_1X)) ; define_radio_button_in_box_with_data (hbox1, &group1, "1X+2X", set_scale_1x_2x, &vs->scale, (vs->scale==SCALE_1X_2X)) ; define_radio_button_in_box_with_data (hbox1, &group1, "1X+2X+4X", set_scale_1x_2x_4x, &vs->scale, (vs->scale==SCALE_1X_2X_4X)) ; button = define_radio_button_in_box_with_data (vbox2, &group, "Uniform / random", set_uniform_distrib, &vs->distribution_type, (vs->distribution_type==UNIFORM)) ; gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) hide_if_true, (gpointer) hbox); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) show_if_true, (gpointer) hbox1); button = define_radio_button_in_box_with_data (vbox2, &group, "Centered / random", set_centered_distrib, &vs->distribution_type, (vs->distribution_type==CENTERED)) ; gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) hide_if_true, (gpointer) hbox); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) show_if_true, (gpointer) hbox1); button = define_radio_button_in_box_with_data (vbox2, &group, "Regular / perturbated", set_regular_distrib, &vs->distribution_type, (vs->distribution_type==REGULAR)) ; gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) show_if_true, (gpointer) hbox); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) hide_if_true, (gpointer) hbox1); // At the end, We add the random variation scale for REGULAR // and the radio buttons for the multiple scale control gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), hbox1, FALSE, FALSE, 0); if (vs->distribution_type!=REGULAR) gtk_widget_hide(GTK_WIDGET(hbox)); else gtk_widget_hide(GTK_WIDGET(hbox1)); /*****************************************************/ // 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); // hbox for NOISE vs GUIDE radio buttons hbox = gtk_hbox_new(FALSE,0); gtk_widget_show(GTK_WIDGET(hbox)); button = define_radio_button_in_box_with_data (hbox, &group2, "As noise", set_use_as_noise, &vs->hf_use, (vs->hf_use==USE_AS_NOISE)) ; gtk_signal_connect (GTK_OBJECT (button), "toggled", (GtkSignalFunc) hide_if_true, (gpointer) check_box); // Always show the noise scale in that case gtk_signal_connect_object(GTK_OBJECT(button), "toggled", GTK_SIGNAL_FUNC(gtk_widget_show), (gpointer) wdg); button = define_radio_button_in_box_with_data (hbox, &group2, "As guide", set_use_as_guide, &vs->hf_use, (vs->hf_use==USE_AS_GUIDE)) ; gtk_signal_connect (GTK_OBJECT (button), "toggled", (GtkSignalFunc) show_if_true, (gpointer) guide_box); if (vs->hf_use==USE_AS_NOISE) gtk_widget_hide(GTK_WIDGET(guide_box)); gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), guide_box, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0); /*********************** Crack width **************************/ vbox2 = gtk_vbox_new(FALSE,0); gtk_widget_show(GTK_WIDGET(vbox2)); frame2 = define_frame_with_hiding_arrows ("Crack width", vbox2, hfw->hf_options->tools_window, FALSE); gtk_box_pack_start(GTK_BOX(vbox), frame2, FALSE, FALSE, 0.5*DEF_PAD); hbox = gtk_hbox_new(FALSE,DEF_PAD); gtk_widget_show(GTK_WIDGET(hbox)); button_uniform = define_radio_button_in_box_with_data (hbox, &group3, "Uniform", set_fixed_width, &vs->crack_width_type, vs->crack_width_type==FIXED_WIDTH) ; button = define_radio_button_in_box_with_data (hbox, &group3, "From distance",set_from_distance, &vs->crack_width_type, vs->crack_width_type==FROM_DISTANCE) ; gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0); // Width: in pixels for "Uniform", relative for "Varies with distance" hbox = gtk_hbox_new(FALSE,DEF_PAD); gtk_widget_show(GTK_WIDGET(hbox)); define_label_in_box("Min", hbox, FALSE,TRUE, DEF_PAD); vds->adj_min_width = gtk_adjustment_new ( vs->min_width,0.0, 10.0, 1, 1, 0.0); wdg = define_scale_in_box(vds->adj_min_width,hbox,0,DEF_PAD); gtk_signal_connect (GTK_OBJECT (vds->adj_min_width), "value_changed", GTK_SIGNAL_FUNC (gint_adj_callb), (gpointer) &vs->min_width); gtk_signal_connect (GTK_OBJECT (vds->adj_min_width), "value_changed", GTK_SIGNAL_FUNC (gboolean_set_false), (gpointer) &hfw->if_calculated); gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0); gtk_signal_connect (GTK_OBJECT (button_uniform), "toggled", (GtkSignalFunc) hide_if_true, (gpointer) hbox); if (vs->crack_width_type==FIXED_WIDTH) gtk_widget_hide(GTK_WIDGET(hbox)); hbox = gtk_hbox_new(FALSE,DEF_PAD); gtk_widget_show(GTK_WIDGET(hbox)); lblmax = define_label_in_box("Max", hbox, FALSE,TRUE, DEF_PAD); lblwidth = define_label_in_box("Width", hbox, FALSE,TRUE, DEF_PAD); vds->adj_max_width = gtk_adjustment_new ( vs->max_width,0.0, 10.0, 1, 1, 0.0); wdg = define_scale_in_box(vds->adj_max_width,hbox,0,DEF_PAD); gtk_signal_connect (GTK_OBJECT (vds->adj_max_width), "value_changed", GTK_SIGNAL_FUNC (gint_adj_callb), (gpointer) &vs->max_width); gtk_signal_connect (GTK_OBJECT (vds->adj_max_width), "value_changed", GTK_SIGNAL_FUNC (gboolean_set_false), (gpointer) &hfw->if_calculated); // Consistency controls (min should be <= max) gtk_signal_connect (GTK_OBJECT (vds->adj_min_width), "value_changed", GTK_SIGNAL_FUNC (check_max_width), (gpointer) hfw->hf_options->img); gtk_signal_connect (GTK_OBJECT (vds->adj_max_width), "value_changed", GTK_SIGNAL_FUNC (check_min_width), (gpointer) hfw->hf_options->img); gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0); gtk_signal_connect (GTK_OBJECT (button_uniform), "toggled", (GtkSignalFunc) hide_if_true, (gpointer) lblmax); gtk_signal_connect (GTK_OBJECT (button_uniform), "toggled", (GtkSignalFunc) show_if_true, (gpointer) lblwidth); if (vs->crack_width_type==FIXED_WIDTH) gtk_widget_hide(GTK_WIDGET(lblmax)); button = gtk_button_new_with_label (_("Apply")); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) apply_voronoi_callb, data); gtk_widget_show(button); gtk_box_pack_start(GTK_BOX(vbox), align_widget(button,0.5,0.5), FALSE, FALSE, DEF_PAD); /************************ Edge level control ************************/ hbox = gtk_hbox_new(FALSE,DEF_PAD); gtk_widget_show(GTK_WIDGET(hbox)); define_label_in_box("Edge raising", hbox, FALSE,TRUE, DEF_PAD); vds->adj_edges_level = gtk_adjustment_new ( vs->edges_level,0.0, 100.0, 1, 1, 0.0); vds->wdg_edges_level = define_scale_in_box(vds->adj_edges_level,hbox,0,DEF_PAD); gtk_signal_connect (GTK_OBJECT (vds->adj_edges_level), "value_changed", GTK_SIGNAL_FUNC (gint_adj_callb), (gpointer) &vs->edges_level); gtk_signal_connect (GTK_OBJECT (vds->adj_edges_level), "value_changed", GTK_SIGNAL_FUNC (edges_level_callb), data); gtk_signal_connect (GTK_OBJECT (vds->adj_edges_level), "value_changed", GTK_SIGNAL_FUNC (gboolean_set_false), (gpointer) &hfw->if_calculated); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); // We activate when apply is clicked gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) set_sensitive_callb, (gpointer) vds->wdg_edges_level); gtk_widget_set_sensitive (GTK_WIDGET(vds->wdg_edges_level),FALSE); // Controls gtk_box_pack_start (GTK_BOX (vbox), reset_accept_buttons_new (data, &vds->accept), FALSE, FALSE, DEF_PAD); gtk_container_add(GTK_CONTAINER(frame), vbox); return frame; }
static GtkWidget *create_custom_widget_cb(GtkPrintOperation *operation, PrintData *data) { GtkWidget *layout; GtkWidget *main_hbox; GtkWidget *main_vbox; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *button; GtkWidget *label; GtkPageSetup *setup; CustomWidgetInfo *info = g_malloc0(sizeof(CustomWidgetInfo)); g_signal_connect_swapped (data->operation, _("done"), G_CALLBACK (custom_widgets_cleanup), info); info->data = data; setup = gtk_print_operation_get_default_page_setup (data->operation); if (! setup) { setup = gtk_page_setup_new (); gtk_print_operation_set_default_page_setup (data->operation, setup); } layout = gtk_vbox_new (FALSE, 6); gtk_container_set_border_width (GTK_CONTAINER (layout), 12); /* main hbox */ main_hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (layout), main_hbox, TRUE, TRUE, 0); gtk_widget_show (main_hbox); /* main vbox */ main_vbox = gtk_vbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (main_hbox), main_vbox, FALSE, FALSE, 0); gtk_widget_show (main_vbox); 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 label_general = GTK_LABEL(gtk_label_new("General")); gtk_notebook_append_page(notebook, GTK_WIDGET(alignment_general), GTK_WIDGET(label_general)); } // gui appearance gtk_notebook_set_current_page(notebook, 0); gtk_button_box_set_layout(btnbox, GTK_BUTTONBOX_END); gtk_label_set_markup(label_layout_tip, markup); g_free(markup); g_object_set(GTK_WINDOW(self), "window-position", GTK_WIN_POS_CENTER_ALWAYS, NULL); g_object_set(GTK_WINDOW(self), "border-width", 3, NULL); // pack gui gtk_box_pack_start(GTK_BOX(btnbox), GTK_WIDGET(btn_close), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(main_box), GTK_WIDGET(notebook), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(main_box), GTK_WIDGET(btnbox), FALSE, TRUE, 0); gtk_container_add(GTK_CONTAINER(self), GTK_WIDGET(main_box)); // connect signals g_signal_connect(btn_close, "clicked", G_CALLBACK(wibuti_prefs_close_cb), self); g_signal_connect(self, "delete-event", G_CALLBACK(wibuti_prefs_delete_cb), self); }