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);
}
