GtkWidget * create_jpeg_gui()
{
printf("creating jpeg gui\n");
GtkWidget *label;
GtkWidget *tab_box;
GtkWidget *jpeg_compress_check_button;
GtkWidget *jpeg_compress_hscale;
GtkObject *jpeg_compress_value;
GtkWidget *jpeg_threshold_hscale;
GtkObject *jpeg_threshold_value;
label = gtk_label_new ("Jpeg");
//so this is the page
tab_box = gtk_vbox_new (FALSE, 6);
gtk_container_border_width (GTK_CONTAINER (tab_box), 10);
gtk_widget_set_size_request (tab_box, 200, 150);
gtk_widget_show (tab_box);
//this is the button i want to add to the page
jpeg_compress_check_button = gtk_check_button_new_with_label ( "Find Jpeg Age");
gtk_widget_set_size_request (jpeg_compress_check_button, 200, 50);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(jpeg_compress_check_button), FALSE);
gtk_widget_show (jpeg_compress_check_button);
//i add the button to the page
gtk_container_add (GTK_CONTAINER (tab_box), jpeg_compress_check_button);
//then add the page to the notbook
jpeg_compress_value = gtk_adjustment_new (jpeg_compress, 0, 1.0, .01, .01, .01);
jpeg_compress_hscale = gtk_hscale_new (GTK_ADJUSTMENT (jpeg_compress_value));
gtk_scale_set_digits( GTK_SCALE(jpeg_compress_hscale), 3);
// gtk_range_set_update_policy (GtkRange *range, GtkUpdateType policy);
gtk_widget_set_size_request (jpeg_compress_hscale, 100, 50);
gtk_widget_show (jpeg_compress_hscale);
gtk_container_add (GTK_CONTAINER (tab_box), jpeg_compress_hscale);
jpeg_threshold_value = gtk_adjustment_new (jpeg_threshold, 0, 255, 1, 1, 1);
jpeg_threshold_hscale = gtk_hscale_new (GTK_ADJUSTMENT (jpeg_threshold_value));
gtk_scale_set_digits( GTK_SCALE(jpeg_threshold_hscale), 0);
// gtk_range_set_update_policy (GtkRange *range, GtkUpdateType policy);
gtk_widget_set_size_request (jpeg_threshold_hscale, 100, 50);
gtk_widget_show (jpeg_threshold_hscale);
gtk_container_add (GTK_CONTAINER (tab_box), jpeg_threshold_hscale);
g_signal_connect (jpeg_compress_check_button, "clicked", G_CALLBACK (cb_jpeg_compress_check_button), &jpeg_plugin.checked);
g_signal_connect (GTK_OBJECT (jpeg_compress_value), "value_changed", G_CALLBACK (gimp_float_adjustment_update), &jpeg_compress);
g_signal_connect (GTK_OBJECT (jpeg_threshold_value), "value_changed", G_CALLBACK (gimp_int_adjustment_update), &jpeg_threshold);
printf("jpeg compress gui created\n");
return tab_box;
}
static GtkWidget*
create_timing_note(void)
{
GtkWidget *main_widget;
struct {
GtkWidget *name_label;
GtkWidget *clock_scale;
GtkWidget *clock_label;
} waitclk[NELEMENTS(timing_waitclock_str)];
GtkWidget *realpal_label;
GtkWidget *realpal_scale;
int i;
main_widget = gtk_table_new(5, 5, FALSE);
gtk_widget_show(main_widget);
for (i = 0; i < NELEMENTS(timing_waitclock_str); i++) {
waitclk[i].name_label = gtk_label_new(timing_waitclock_str[i]);
gtk_widget_show(waitclk[i].name_label);
gtk_table_attach(GTK_TABLE(main_widget), waitclk[i].name_label,
0, 1, i, i + 1,
GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 10, 0);
timing_waitclock_adj[i] = gtk_adjustment_new(np2cfg.wait[i * 2], 0.0, 32.0, 1.0, 1.0, 0.0);
waitclk[i].clock_scale = gtk_hscale_new(GTK_ADJUSTMENT(timing_waitclock_adj[i]));
gtk_widget_show(waitclk[i].clock_scale);
gtk_scale_set_default_values(GTK_SCALE(waitclk[i].clock_scale));
gtk_scale_set_digits(GTK_SCALE(waitclk[i].clock_scale), 0);
gtk_table_attach_defaults(GTK_TABLE(main_widget),
waitclk[i].clock_scale, 1, 4, i, i + 1);
waitclk[i].clock_label = gtk_label_new("clock");
gtk_misc_set_alignment(GTK_MISC(waitclk[i].clock_label),
0.1, 0.5);
gtk_widget_show(waitclk[i].clock_label);
gtk_table_attach_defaults(GTK_TABLE(main_widget),
waitclk[i].clock_label, 4, 5, i, i + 1);
}
realpal_label = gtk_label_new("RealPalettes Adjust");
gtk_misc_set_alignment(GTK_MISC(realpal_label), 0.0, 1.0);
gtk_widget_show(realpal_label);
gtk_table_attach_defaults(GTK_TABLE(main_widget), realpal_label,
0, 5, 3, 4);
timing_realpal_adj = gtk_adjustment_new(np2cfg.realpal - 32,
-32.0, 32.0, 1.0, 1.0, 0.0);
realpal_scale = gtk_hscale_new(GTK_ADJUSTMENT(timing_realpal_adj));
gtk_widget_show(realpal_scale);
gtk_scale_set_default_values(GTK_SCALE(realpal_scale));
gtk_scale_set_digits(GTK_SCALE(realpal_scale), 0);
gtk_table_attach_defaults(GTK_TABLE(main_widget), realpal_scale,
1, 5, 4, 5);
return main_widget;
}
static void
AddWidgets(GtkWidget * window)
{
GtkWidget *table, *label, *scale;
table = gtk_table_new(5, 4, TRUE);
gtk_container_add(GTK_CONTAINER(window), table);
label = gtk_label_new(_("Ambient colour:"));
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
pcpAmbient = gtk_color_button_new();
g_signal_connect(G_OBJECT(pcpAmbient), "color-set", UpdateColourPreview, NULL);
gtk_table_attach_defaults(GTK_TABLE(table), pcpAmbient, 1, 2, 0, 1);
label = gtk_label_new(_("Diffuse colour:"));
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2);
pcpDiffuse = gtk_color_button_new();
g_signal_connect(G_OBJECT(pcpDiffuse), "color-set", UpdateColourPreview, NULL);
gtk_table_attach_defaults(GTK_TABLE(table), pcpDiffuse, 1, 2, 1, 2);
label = gtk_label_new(_("Specular colour:"));
gtk_table_attach_defaults(GTK_TABLE(table), label, 2, 3, 0, 1);
pcpSpecular = gtk_color_button_new();
g_signal_connect(G_OBJECT(pcpSpecular), "color-set", UpdateColourPreview, NULL);
gtk_table_attach_defaults(GTK_TABLE(table), pcpSpecular, 3, 4, 0, 1);
label = gtk_label_new(_("Shine:"));
gtk_table_attach_defaults(GTK_TABLE(table), label, 2, 3, 1, 2);
padjShine = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 128.0, 1.0, 10.0, 0.0));
g_signal_connect(G_OBJECT(padjShine), "value-changed", G_CALLBACK(UpdateColourPreview), NULL);
scale = gtk_hscale_new(padjShine);
gtk_scale_set_digits(GTK_SCALE(scale), 0);
gtk_table_attach_defaults(GTK_TABLE(table), scale, 3, 4, 1, 2);
pOpacitylabel = gtk_label_new(_("Opacity:"));
gtk_table_attach_defaults(GTK_TABLE(table), pOpacitylabel, 0, 1, 2, 3);
padjOpacity = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 1.0, 100.0, 1.0, 10.0, 0.0));
g_signal_connect(G_OBJECT(padjOpacity), "value-changed", G_CALLBACK(UpdateColourPreview), NULL);
psOpacity = gtk_hscale_new(padjOpacity);
gtk_scale_set_digits(GTK_SCALE(psOpacity), 0);
gtk_table_attach_defaults(GTK_TABLE(table), psOpacity, 1, 2, 2, 3);
pTexturelabel = gtk_label_new(_("Texture:"));
gtk_table_attach_defaults(GTK_TABLE(table), pTexturelabel, 2, 3, 2, 3);
textureComboBox = GTK_WIDGET(gtk_combo_box_text_new());
texture_set_active();
gtk_widget_set_sensitive(textureComboBox, FALSE);
g_signal_connect(textureComboBox, "changed", G_CALLBACK(TextureChange), NULL);
gtk_table_attach_defaults(GTK_TABLE(table), textureComboBox, 2, 4, 3, 4);
label = gtk_label_new(_("Preview:"));
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 3, 4);
pwPreview = CreateGLPreviewWidget(&col3d);
gtk_table_attach_defaults(GTK_TABLE(table), pwPreview, 0, 2, 4, 5);
}
static GtkWidget*
gimp_scale_entry_new (GtkWidget *parent_box,
gfloat value,
gfloat lower,
gfloat upper,
gfloat step_increment,
gfloat page_increment)
{
GtkWidget *hbox;
GtkWidget *scale;
GtkWidget *spinbutton;
GtkObject *adj;
adj = gtk_adjustment_new (value, lower, upper,
step_increment, page_increment,
0.0);
spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1.0, 0);
scale = gtk_hscale_new (GTK_ADJUSTMENT (adj));
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
gtk_widget_set_size_request (GTK_WIDGET (scale), SCALE_SIZE, -1);
hbox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (parent_box), hbox, TRUE, TRUE, 0);
gtk_widget_show_all (hbox);
return scale;
}
void
gui_subs_create_slider (GtkBox *destbox,
gui_subs_slider *s)
{
GtkWidget *thing, *box;
box = gtk_hbox_new(FALSE, 4);
gtk_widget_show(box);
gtk_box_pack_start(destbox, box, FALSE, TRUE, 0);
thing = gtk_label_new(s->title);
gtk_widget_show(thing);
gtk_box_pack_start(GTK_BOX(box), thing, FALSE, TRUE, 0);
s->adjustment1 = GTK_ADJUSTMENT(gtk_adjustment_new(s->min, s->min, s->max, 1, (s->max - s->min) / 10, 0));
s->slider = gtk_hscale_new(s->adjustment1);
gtk_scale_set_draw_value(GTK_SCALE(s->slider), FALSE);
gtk_widget_show(s->slider);
gtk_box_pack_start(GTK_BOX(box), s->slider, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT(s->adjustment1), "value_changed",
GTK_SIGNAL_FUNC(gui_subs_slider_update_1), s);
s->adjustment2 = GTK_ADJUSTMENT(gtk_adjustment_new(s->min, s->min, s->max, 1, (s->max - s->min) / 10, 0));
thing = gtk_spin_button_new(s->adjustment2, 0, 0);
gtk_box_pack_start(GTK_BOX(box), thing, FALSE, TRUE, 0);
gtk_widget_show(thing);
gtk_signal_connect(GTK_OBJECT(thing), "changed",
GTK_SIGNAL_FUNC(gui_subs_slider_update_2), s);
}
void gSlider::orientation(int w,int h)
{
GtkAdjustment *adj;
GType type;
type = (w < h) ? GTK_TYPE_VSCALE : GTK_TYPE_HSCALE;
if (type != G_OBJECT_TYPE(widget))
{
adj = gtk_range_get_adjustment(GTK_RANGE(widget));
g_object_ref(adj);
gtk_widget_destroy(widget);
if (type == GTK_TYPE_VSCALE)
widget = gtk_vscale_new(adj);
else
widget = gtk_hscale_new(adj);
gtk_container_add(GTK_CONTAINER(border), widget);
gtk_scale_set_draw_value(GTK_SCALE(widget), false);
gtk_widget_show(widget);
widgetSignals();
g_signal_connect(G_OBJECT(widget), "value-changed", G_CALLBACK(cb_change), (gpointer)this);
g_object_unref(adj);
init();
}
}
GtkWidget *uniform_dialog_new(gpointer hfo_ptr, gint default_value) {
GtkWidget *dialog, *wtmp, *vbox, *hbox;
GtkObject *adj;
hf_options_struct *hfo = (hf_options_struct *) hfo_ptr;
if (!hfo)
return gtk_label_new(_("No uniform dialog"));
dialog = options_frame_new("Uniform");
vbox = gtk_vbox_new(FALSE,DEF_PAD);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(dialog),vbox);
adj = gtk_adjustment_new (default_value, 0, MAX_HF_VALUE, 1, 1, 0.1);
wtmp = gtk_hscale_new (GTK_ADJUSTMENT (adj));
gtk_scale_set_digits (GTK_SCALE (wtmp), 0);
gtk_widget_show(GTK_WIDGET(wtmp));
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC(uniform_scale), hfo->hfw_ptr_ptr);
optimize_on_mouse_click (wtmp, hfo->hfw_ptr_ptr);
gtk_box_pack_start(GTK_BOX(vbox), wtmp, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE,0);
gtk_widget_show(hbox);
uniform_percent_buttons_new(hbox, (gpointer) adj);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
return dialog;
}
/* greebo: This adds a horizontal slider and connects it to the value of the given registryKey
*/
void Dialog::addSlider (GtkWidget* vbox, const std::string& name, const std::string& registryKey,
gboolean draw_value, double value, double lower, double upper,
double step_increment, double page_increment, double page_size)
{
// Create a new adjustment with the boundaries <lower> and <upper> and all the increments
GtkObject* adj = gtk_adjustment_new(value, lower, upper, step_increment, page_increment, page_size);
// Connect the registry key to this adjustment
_registryConnector.connectGtkObject(adj, registryKey);
// scale
GtkWidget* alignment = gtk_alignment_new(0.0, 0.5, 1.0, 0.0);
gtk_widget_show(alignment);
GtkWidget* scale = gtk_hscale_new(GTK_ADJUSTMENT(adj));
gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_LEFT);
gtk_widget_show(scale);
gtk_container_add(GTK_CONTAINER(alignment), scale);
gtk_scale_set_draw_value(GTK_SCALE (scale), draw_value);
int digits = (step_increment < 1.0f) ? 2 : 0;
gtk_scale_set_digits(GTK_SCALE (scale), digits);
GtkTable* row = DialogRow_new(name, alignment);
DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(row));
}
/* =================================
Filter Preview
================================= */
uint8_t DIA_filterPreview(const char *captionText, AVDMGenericVideoStream *videoStream, uint32_t frame)
{
ADM_assert(frame <= videoStream->getInfo()->nb_frames);
GtkWidget *hbuttonbox1, *buttonOk, *scale;
dialog = create_dialog1();
scale = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 110, 1, 10, 0)));
gtk_widget_show (scale);
gtk_box_pack_start (GTK_BOX(WID(vbox1)), scale, FALSE, TRUE, 0);
hbuttonbox1 = gtk_hbutton_box_new ();
gtk_widget_show (hbuttonbox1);
gtk_box_pack_start (GTK_BOX(WID(vbox1)), hbuttonbox1, FALSE, TRUE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX(hbuttonbox1), GTK_BUTTONBOX_END);
buttonOk = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show(buttonOk);
gtk_container_add (GTK_CONTAINER(hbuttonbox1), buttonOk);
GTK_WIDGET_SET_FLAGS (buttonOk, GTK_CAN_DEFAULT);
GLADE_HOOKUP_OBJECT (dialog, scale, "scale");
GLADE_HOOKUP_OBJECT(dialog, hbuttonbox1, "hbuttonbox1");
GLADE_HOOKUP_OBJECT(dialog, buttonOk, "buttonOk");
gtk_register_dialog(dialog);
if (captionText)
gtk_window_set_title(GTK_WINDOW(dialog), captionText);
uint32_t width, height;
width = videoStream->getInfo()->width;
height = videoStream->getInfo()->height;
gtk_signal_connect(GTK_OBJECT(WID(scale)), "value_changed", GTK_SIGNAL_FUNC(seekablePreview_frame_changed), NULL);
gtk_signal_connect(GTK_OBJECT(WID(drawingarea1)), "expose_event", GTK_SIGNAL_FUNC(seekablePreview_draw), NULL);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog), WID(buttonOk), GTK_RESPONSE_OK);
gtk_widget_show(dialog);
seekablePreview = new flySeekablePreview(width, height, videoStream, WID(drawingarea1), WID(scale));
seekablePreview->process();
seekablePreview->sliderSet(frame);
seekablePreview->sliderChanged();
int response;
while((response = gtk_dialog_run(GTK_DIALOG(dialog))) == GTK_RESPONSE_APPLY)
{
seekablePreview_draw();
}
gtk_unregister_dialog(dialog);
gtk_widget_destroy(dialog);
delete seekablePreview;
return (response == GTK_RESPONSE_OK);
}
GtkWidget* RenderThemeGtk::gtkHScale() const
{
if (m_gtkHScale)
return m_gtkHScale;
m_gtkHScale = gtk_hscale_new(0);
setupWidgetAndAddToContainer(m_gtkHScale, gtkContainer());
return m_gtkHScale;
}
static void configure(void)
{
GtkWidget *hbox, *label, *scale, *button, *bbox;
if (conf_dialog != NULL)
return;
conf_dialog = gtk_dialog_new();
g_signal_connect (conf_dialog, "destroy", (GCallback)
gtk_widget_destroyed, & conf_dialog);
gtk_window_set_title(GTK_WINDOW(conf_dialog), _("Configure Extra Stereo"));
label = gtk_label_new(_("Effect intensity:"));
gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area
((GtkDialog *) conf_dialog), label, TRUE, TRUE, 0);
gtk_widget_show(label);
hbox = gtk_hbox_new(FALSE, 10);
gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area
((GtkDialog *) conf_dialog), hbox, TRUE, TRUE, 10);
gtk_widget_show(hbox);
GtkAdjustment * adjustment = (GtkAdjustment *) gtk_adjustment_new
(value, 0, 15 + 1, 0.1, 1.0, 1.0);
scale = gtk_hscale_new(GTK_ADJUSTMENT(adjustment));
gtk_box_pack_start(GTK_BOX(hbox), scale, TRUE, TRUE, 10);
gtk_widget_show(scale);
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_box_pack_start ((GtkBox *) gtk_dialog_get_action_area ((GtkDialog *)
conf_dialog), bbox, TRUE, TRUE, 0);
button = gtk_button_new_with_label(_("Ok"));
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked", (GCallback) conf_ok_cb, adjustment);
gtk_widget_grab_default(button);
gtk_widget_show(button);
button = gtk_button_new_with_label(_("Cancel"));
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked", (GCallback) conf_cancel_cb, NULL);
gtk_widget_show(button);
button = gtk_button_new_with_label(_("Apply"));
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked", (GCallback) conf_apply_cb,
adjustment);
gtk_widget_show(button);
gtk_widget_show(bbox);
gtk_widget_show(conf_dialog);
}
GtkWidget *create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *hscale1;
GtkWidget *drawingarea1;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *okbutton1;
dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), _("Rotate"));
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);
adj_angle=gtk_adjustment_new (0.0, 0.0, 360.0, 90.0, 90.0, 90.0);
hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (adj_angle));
gtk_widget_show (hscale1);
gtk_box_pack_start (GTK_BOX (vbox1), hscale1, FALSE, TRUE, 0);
gtk_scale_set_digits (GTK_SCALE (hscale1), 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);
/* 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, 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;
}
void FullscreenVideoControllerGtk::createHud()
{
m_hudWindow = gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_gravity(GTK_WINDOW(m_hudWindow), GDK_GRAVITY_SOUTH_WEST);
gtk_window_set_type_hint(GTK_WINDOW(m_hudWindow), GDK_WINDOW_TYPE_HINT_NORMAL);
m_hudMotionNotifySignalId = g_signal_connect(m_hudWindow, "motion-notify-event", G_CALLBACK(onFullscreenGtkMotionNotifyEvent), this);
#ifdef GTK_API_VERSION_2
GtkWidget* hbox = gtk_hbox_new(FALSE, 4);
#else
GtkWidget* hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
#endif
gtk_container_add(GTK_CONTAINER(m_hudWindow), hbox);
m_playPauseAction = gtk_action_new("play", _("Play / Pause"), _("Play or pause the media"), PAUSE_ICON_NAME);
m_playActionActivateSignalId = g_signal_connect(m_playPauseAction, "activate", G_CALLBACK(togglePlayPauseActivated), this);
GtkWidget* item = gtk_action_create_tool_item(m_playPauseAction);
gtk_box_pack_start(GTK_BOX(hbox), item, FALSE, TRUE, 0);
GtkWidget* label = gtk_label_new(_("Time:"));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
GtkAdjustment* adjustment = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 100.0, 0.1, 1.0, 1.0));
#ifdef GTK_API_VERSION_2
m_timeHScale = gtk_hscale_new(adjustment);
#else
m_timeHScale = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, adjustment);
#endif
gtk_scale_set_draw_value(GTK_SCALE(m_timeHScale), FALSE);
gtk_range_set_show_fill_level(GTK_RANGE(m_timeHScale), TRUE);
m_timeScaleButtonPressedSignalId = g_signal_connect(m_timeHScale, "button-press-event", G_CALLBACK(timeScaleButtonPressed), this);
m_timeScaleButtonReleasedSignalId = g_signal_connect(m_timeHScale, "button-release-event", G_CALLBACK(timeScaleButtonReleased), this);
m_hscaleUpdateId = g_signal_connect(m_timeHScale, "value-changed", G_CALLBACK(timeScaleValueChanged), this);
gtk_box_pack_start(GTK_BOX(hbox), m_timeHScale, TRUE, TRUE, 0);
m_timeLabel = gtk_label_new("");
gtk_box_pack_start(GTK_BOX(hbox), m_timeLabel, FALSE, TRUE, 0);
// Volume button.
m_volumeButton = gtk_volume_button_new();
gtk_box_pack_start(GTK_BOX(hbox), m_volumeButton, FALSE, TRUE, 0);
gtk_scale_button_set_value(GTK_SCALE_BUTTON(m_volumeButton), m_player->volume());
m_volumeUpdateId = g_signal_connect(m_volumeButton, "value-changed", G_CALLBACK(volumeValueChanged), this);
m_exitFullscreenAction = gtk_action_new("exit", _("Exit Fullscreen"), _("Exit from fullscreen mode"), EXIT_FULLSCREEN_ICON_NAME);
m_exitFullcreenActionActivateSignalId = g_signal_connect(m_exitFullscreenAction, "activate", G_CALLBACK(exitFullscreenActivated), this);
g_object_set(m_exitFullscreenAction, "icon-name", EXIT_FULLSCREEN_ICON_NAME, NULL);
item = gtk_action_create_tool_item(m_exitFullscreenAction);
gtk_box_pack_start(GTK_BOX(hbox), item, FALSE, TRUE, 0);
m_progressBarUpdateId = g_timeout_add(PROGRESS_BAR_UPDATE_INTERVAL, reinterpret_cast<GSourceFunc>(progressBarUpdateCallback), this);
playStateChanged();
}
GtkWidget *
gtk_scale_new (GtkOrientation orientation,
GtkAdjustment *adjustment)
{
if (orientation == GTK_ORIENTATION_HORIZONTAL)
return gtk_hscale_new (adjustment);
else
return gtk_vscale_new (adjustment);
}
GtkWidget * AddHScaler( GtkAdjustment * adj,GtkWidget * parent,int digit )
{
GtkWidget * HS;
HS=gtk_hscale_new( adj );
gtk_widget_set_name( HS,"HS" );
gtk_widget_show( HS );
if ( parent ) gtk_box_pack_start( GTK_BOX( parent ),HS,TRUE,TRUE,0 );
gtk_scale_set_value_pos( GTK_SCALE( HS ),GTK_POS_RIGHT );
gtk_scale_set_digits( GTK_SCALE( HS ),digit );
return HS;
}
void pack_new(void)
{
GtkWidget *tmpbox;
pack1.id = 1;
pack1.hbox = gtk_hbox_new(FALSE, 0);
pack1.adj = gtk_adjustment_new(0.0, 0.0, 1.0, 0.01, 0.01, 0.0);
tmpbox = gtk_hbox_new(FALSE, 0);
pack1.hscale = gtk_hscale_new(GTK_ADJUSTMENT(pack1.adj));
g_signal_connect(G_OBJECT(pack1.adj), "value_changed",
G_CALLBACK(cfade_set), (void *) &pack1);
gtk_scale_set_digits(GTK_SCALE(pack1.hscale), 2);
gtk_box_pack_start(GTK_BOX(tmpbox), pack1.hscale, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), pack1.hbox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), tmpbox, FALSE, FALSE, 0);
pack2.id = 3;
pack2.hbox = gtk_hbox_new(FALSE, 0);
pack2.adj = gtk_adjustment_new(0.0, 0.0, 1.0, 0.01, 0.01, 0.0);
pack2.hscale = gtk_hscale_new(GTK_ADJUSTMENT(pack2.adj));
tmpbox = gtk_hbox_new(FALSE, 0);
g_signal_connect(G_OBJECT(pack2.adj), "value_changed",
G_CALLBACK(cfade_set), (void *) &pack2);
gtk_scale_set_digits(GTK_SCALE(pack2.hscale), 2);
gtk_box_pack_start(GTK_BOX(tmpbox), pack2.hscale, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), pack2.hbox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), tmpbox, FALSE, FALSE, 0);
pack3.id = 6;
pack3.hbox = gtk_hbox_new(FALSE, 0);
pack3.adj = gtk_adjustment_new(0.0, 0.0, 1.0, 0.01, 0.01, 0.0);
pack3.hscale = gtk_hscale_new(GTK_ADJUSTMENT(pack3.adj));
tmpbox = gtk_hbox_new(FALSE, 0);
g_signal_connect(G_OBJECT(pack3.adj), "value_changed",
G_CALLBACK(cfade_set), (void *) &pack3);
gtk_scale_set_digits(GTK_SCALE(pack3.hscale), 2);
gtk_box_pack_start(GTK_BOX(tmpbox), pack3.hscale, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), pack3.hbox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), tmpbox, FALSE, FALSE, 0);
}
GtkWidget *slider_int_new(char *label_str, int *data, int lower, int upper,
int vert)
{
Slider *slider;
GtkWidget *label;
slider = gtk_type_new(slider_get_type());
gtk_container_border_width(GTK_CONTAINER(slider), 1);
slider->type = SLIDER_TYPE_INT;
slider->data.iptr = data;
snprintf(slider->value_str, sizeof(slider->value_str), "%d",
*data);
slider->value_label = gtk_label_new(slider->value_str);
gtk_box_pack_start(GTK_BOX(slider), slider->value_label, FALSE,
TRUE, 0);
gtk_widget_show(slider->value_label);
slider->adj = gtk_adjustment_new((gfloat) (lower + upper - *data),
(gfloat) lower, (gfloat) upper,
1.0, 1.0, 0.0);
if (vert) {
slider->scale =
GTK_SCALE(gtk_vscale_new(GTK_ADJUSTMENT(slider->adj)));
/* gtk_widget_set_usize(GTK_WIDGET(slider->scale), 16, 120); */
} else {
slider->scale =
GTK_SCALE(gtk_hscale_new(GTK_ADJUSTMENT(slider->adj)));
/* gtk_widget_set_usize(GTK_WIDGET(slider->scale), 120, 16); */
}
gtk_box_pack_start(GTK_BOX(slider), GTK_WIDGET(slider->scale),
TRUE, TRUE, 0);
gtk_range_set_update_policy(GTK_RANGE(slider->scale),
GTK_UPDATE_CONTINUOUS);
/* draw number above scale */
gtk_scale_set_draw_value(GTK_SCALE(slider->scale), FALSE);
g_signal_connect(G_OBJECT(slider->adj), "value_changed",
G_CALLBACK(slider_cb), slider);
gtk_widget_show(GTK_WIDGET(slider->scale));
label = gtk_label_new(label_str);
gtk_box_pack_start(GTK_BOX(slider), label, FALSE, FALSE, 0);
gtk_widget_show(label);
return GTK_WIDGET(slider);
}
static GObject *
gam_slider_pan_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_params)
{
GObject *object;
GamSliderPan *gam_slider_pan;
GamSliderPanPrivate *priv;
object = (* G_OBJECT_CLASS (parent_class)->constructor) (type,
n_construct_properties,
construct_params);
gam_slider_pan = GAM_SLIDER_PAN (object);
priv = GAM_SLIDER_PAN_GET_PRIVATE (gam_slider_pan);
if (!snd_mixer_selem_is_playback_mono (gam_slider_get_elem (GAM_SLIDER (gam_slider_pan)))) {
priv->pan_adjustment = gtk_adjustment_new (gam_slider_pan_get_pan (gam_slider_pan), -100, 101, 1, 5, 1);
g_signal_connect (G_OBJECT (priv->pan_adjustment), "value-changed",
G_CALLBACK (gam_slider_pan_pan_value_changed_cb), gam_slider_pan);
priv->pan_slider = gtk_hscale_new (GTK_ADJUSTMENT (priv->pan_adjustment));
gtk_scale_set_draw_value (GTK_SCALE (priv->pan_slider), FALSE);
g_signal_connect (G_OBJECT (priv->pan_slider), "event",
G_CALLBACK (gam_slider_pan_pan_event_cb), gam_slider_pan);
} else
priv->pan_slider = gtk_label_new (NULL);
gtk_widget_show (priv->pan_slider);
gam_slider_add_pan_widget (GAM_SLIDER (gam_slider_pan), priv->pan_slider);
priv->vol_adjustment = gtk_adjustment_new (gam_slider_pan_get_volume (gam_slider_pan), 0, 101, 1, 5, 1);
g_signal_connect (G_OBJECT (priv->vol_adjustment), "value-changed",
G_CALLBACK (gam_slider_pan_volume_value_changed_cb), gam_slider_pan);
priv->vol_slider = gtk_vscale_new (GTK_ADJUSTMENT (priv->vol_adjustment));
gtk_widget_show (priv->vol_slider);
gtk_scale_set_draw_value (GTK_SCALE (priv->vol_slider), FALSE);
gam_slider_add_volume_widget (GAM_SLIDER (gam_slider_pan), priv->vol_slider);
gtk_label_set_mnemonic_widget (gam_slider_get_label_widget (GAM_SLIDER (gam_slider_pan)),
priv->vol_slider);
return object;
}
GtkWidget *
prefs_slideshow_page (void)
{
GtkWidget *main_vbox;
GtkWidget *frame1;
GtkWidget *vbox;
GtkWidget *frame2;
GtkObject *adjustment;
GtkWidget *hscale;
main_vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 10);
frame1 = gtk_frame_new (_(" Delay before image change: "));
gtk_box_pack_start (GTK_BOX (main_vbox), frame1, FALSE, FALSE, 0);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_container_add (GTK_CONTAINER (frame1), vbox);
frame2 = gtk_frame_new (NULL);
gtk_box_pack_start (GTK_BOX (vbox), frame2, FALSE, TRUE, 1);
gtk_widget_set_usize (frame2, -2, 30);
adjustment = gtk_adjustment_new (5.0, 0.0, (gfloat) nintervals,
1.0, 1.0, 1.0);
gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed",
GTK_SIGNAL_FUNC (cb_slideshow_interval_scale_changed),
NULL);
GTK_ADJUSTMENT (adjustment)->value =
(gfloat) slideshow_interval_get_index (conf.slideshow_interval);
hscale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
gtk_range_set_update_policy (GTK_RANGE (hscale), GTK_UPDATE_CONTINUOUS);
gtk_scale_set_digits (GTK_SCALE (hscale), 1);
gtk_container_add (GTK_CONTAINER (frame2), hscale);
gtk_scale_set_draw_value (GTK_SCALE (hscale), FALSE);
slideshow_interval_label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (vbox), slideshow_interval_label, FALSE,
FALSE, 3);
slideshow_interval_update (conf.slideshow_interval);
gtk_widget_show_all (frame1);
return main_vbox;
}
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_pos = 0;
m_scrollEventType = 0;
m_needThumbRelease = false;
if (style & wxSL_VERTICAL)
m_widget = gtk_vscale_new( (GtkAdjustment *) NULL );
else
m_widget = gtk_hscale_new( (GtkAdjustment *) NULL );
gtk_scale_set_draw_value(GTK_SCALE (m_widget), (style & wxSL_LABELS) != 0);
// Keep full precision in position value
gtk_scale_set_digits(GTK_SCALE (m_widget), -1);
if (style & wxSL_INVERSE)
gtk_range_set_inverted( GTK_RANGE(m_widget), TRUE );
g_signal_connect(m_widget, "button_press_event", G_CALLBACK(gtk_button_press_event), this);
g_signal_connect(m_widget, "button_release_event", G_CALLBACK(gtk_button_release_event), this);
g_signal_connect(m_widget, "move_slider", G_CALLBACK(gtk_move_slider), this);
g_signal_connect(m_widget, "format_value", G_CALLBACK(gtk_format_value), NULL);
g_signal_connect(m_widget, "value_changed", G_CALLBACK(gtk_value_changed), this);
gulong handler_id;
handler_id = g_signal_connect(
m_widget, "event_after", G_CALLBACK(gtk_event_after), this);
g_signal_handler_block(m_widget, handler_id);
SetRange( minValue, maxValue );
SetValue( value );
m_parent->DoAddChild( this );
PostCreation(size);
return true;
}
void diaElemGenericSlider<T>::setMe(void *dialog, void *opaque,uint32_t line)
{
GtkWidget *label = gtk_label_new_with_mnemonic (paramTitle);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_show(label);
gtk_table_attach (GTK_TABLE (opaque), label, 0, 2, line, line+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
T val=*(T *)param;
GtkAdjustment * adj = (GtkAdjustment *) gtk_adjustment_new (val, min, max, incr, incr, 0);
GtkWidget *spinner = gtk_spin_button_new (adj, 1, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON(spinner), TRUE);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON(spinner), digits);
GtkWidget *slider = gtk_hscale_new (adj);
gtk_scale_set_draw_value (GTK_SCALE (slider), FALSE);
gtk_scale_set_digits (GTK_SCALE (slider), digits);
GtkWidget *hbox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (hbox), slider, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, FALSE, 0);
gtk_table_attach (GTK_TABLE (opaque), hbox, 0, 2, line+1, line+2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL(label), hbox);
gtk_widget_show (hbox);
gtk_widget_show (spinner);
gtk_widget_show (slider);
myWidget=(void *)slider;
if(readOnly)
{
gtk_widget_set_sensitive(spinner,0);
gtk_widget_set_sensitive(slider,0);
}
if(tip)
{
GtkTooltips *tooltips= gtk_tooltips_new ();
gtk_tooltips_set_tip (tooltips, spinner, tip, NULL);
gtk_tooltips_set_tip (tooltips, slider, tip, NULL);
}
}
GtkWidget * create_grain_gui()
{
printf("creating grain gui\n");
GtkWidget *label;
GtkWidget *tab_box;
GtkWidget *grain_check_button;
GtkWidget *radius_hscale;
GtkObject *radius_value;
label = gtk_label_new ("Grain");
//so this is the page
tab_box = gtk_vbox_new (FALSE, 6);
gtk_container_border_width (GTK_CONTAINER (tab_box), 10);
gtk_widget_set_size_request (tab_box, 200, 75);
gtk_widget_show (tab_box);
//this is the button i want to add to the page
grain_check_button = gtk_check_button_new_with_label ( "Find image grain");
//this should make sure that it shows the correct status
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(grain_check_button), grain_plugin.checked);
gtk_widget_show (grain_check_button);
//i add the button to the page
gtk_container_add (GTK_CONTAINER (tab_box), grain_check_button);
//then add the page to the notbook
radius_value = gtk_adjustment_new (grain_radius, 0, 50, 1, 1, 1);
radius_hscale = gtk_hscale_new (GTK_ADJUSTMENT (radius_value));
gtk_scale_set_digits( GTK_SCALE(radius_hscale), 0);
// gtk_range_set_update_policy (GtkRange *range, GtkUpdateType policy);
gtk_widget_set_size_request (radius_hscale, 100, 40);
gtk_widget_show (radius_hscale);
g_signal_connect (grain_check_button, "clicked", G_CALLBACK (cb_grain_check_button), &grain_plugin.checked);
// gtk_signal_connect (GTK_OBJECT (radius_value), "value_changed", GTK_SIGNAL_FUNC (cb_radius_hscale), &grain_radius);
g_signal_connect (GTK_OBJECT (radius_value), "value_changed", G_CALLBACK (gimp_int_adjustment_update), &grain_radius);
gtk_container_add (GTK_CONTAINER (tab_box), radius_hscale);
printf("grain gui created\n");
return tab_box;
}
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE arg1, arg2, arg3;
GtkAdjustment *adj = NULL;
GtkWidget *widget;
rb_scan_args(argc, argv, "03", &arg1, &arg2, &arg3);
if (NIL_P(arg1) || RVAL2GTYPE(arg1) == GTK_TYPE_ADJUSTMENT){
if (!NIL_P(arg1)) adj = GTK_ADJUSTMENT(RVAL2GOBJ(arg1));
widget = gtk_hscale_new(adj);
} else {
widget = gtk_hscale_new_with_range(NUM2DBL(arg1),
NUM2DBL(arg2), NUM2DBL(arg3));
}
RBGTK_INITIALIZE(self, widget);
return Qnil;
}
int main(int argc, char **argv)
{
GtkWidget *window = NULL;
GtkWidget *scale = NULL;
m_pa_ml = pa_threaded_mainloop_new();
if (!m_pa_ml) {
printf("pa_threaded_mainloop_new() failed");
return -1;
}
m_pa_mlapi = pa_threaded_mainloop_get_api(m_pa_ml);
if (!m_pa_mlapi) {
printf("pa_threaded_mainloop_get_api() failed");
return -1;
}
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "PulseAudio Gtk Demo");
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(window), 400, 300);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(m_destroy), NULL);
m_adjust = gtk_adjustment_new(60000, 0, 100000, 1, 1, 0);
g_signal_connect(m_adjust, "value-changed", G_CALLBACK(m_value_changed), NULL);
scale = gtk_hscale_new(m_adjust);
gtk_container_add(GTK_CONTAINER(window), scale);
gtk_widget_show(scale);
gtk_widget_show(window);
pa_threaded_mainloop_start(m_pa_ml);
m_connect_to_pulse();
gtk_main();
return 0;
}
static GtkAdjustment *
create_levels_scale (gdouble value,
const gchar *left,
const gchar *right,
GtkWidget *table,
gint col)
{
GtkWidget *label;
GtkWidget *slider;
GtkWidget *spinbutton;
GtkAdjustment *adj;
label = gtk_label_new (left);
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, col, col + 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
spinbutton = gimp_spin_button_new ((GtkObject **) &adj,
value, -100.0, 100.0,
1.0, 10.0, 0.0, 1.0, 0);
slider = gtk_hscale_new (adj);
gtk_scale_set_draw_value (GTK_SCALE (slider), FALSE);
gtk_widget_set_size_request (slider, 100, -1);
gtk_table_attach_defaults (GTK_TABLE (table), slider, 1, 2, col, col + 1);
gtk_widget_show (slider);
label = gtk_label_new (right);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, col, col + 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), spinbutton, 3, 4, col, col + 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (spinbutton);
return adj;
}
void Dialog::addSlider(GtkWidget* vbox, const char* name, int& data, gboolean draw_value, const char* low, const char* high, double value, double lower, double upper, double step_increment, double page_increment)
{
#if 0
if(draw_value == FALSE)
{
GtkWidget* hbox2 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox2);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hbox2), FALSE, FALSE, 0);
{
GtkWidget* label = gtk_label_new (low);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
}
{
GtkWidget* label = gtk_label_new (high);
gtk_widget_show (label);
gtk_box_pack_end (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
}
}
#endif
// adjustment
GtkObject* adj = gtk_adjustment_new(value, lower, upper, step_increment, page_increment, 0);
AddIntAdjustmentData(*GTK_ADJUSTMENT(adj), IntImportCaller(data), IntExportCaller(data));
// scale
GtkWidget* alignment = gtk_alignment_new(0.0, 0.5, 1.0, 0.0);
gtk_widget_show(alignment);
GtkWidget* scale = gtk_hscale_new(GTK_ADJUSTMENT(adj));
gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_LEFT);
gtk_widget_show(scale);
gtk_container_add(GTK_CONTAINER(alignment), scale);
gtk_scale_set_draw_value(GTK_SCALE (scale), draw_value);
gtk_scale_set_digits(GTK_SCALE (scale), 0);
GtkTable* row = DialogRow_new(name, alignment);
DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(row));
}
//----------------------------
GtkWidget*
create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *table2;
GtkWidget *label1;
GtkWidget *label2;
GtkObject *spinbutton_width_adj;
GtkWidget *spinbutton_width;
GtkObject *spinbutton_height_adj;
GtkWidget *spinbutton_height;
GtkWidget *label5;
GtkWidget *label6;
GtkWidget *optionmenu_source;
GtkWidget *menu1;
GtkWidget *item1_1;
GtkWidget *_4_1;
GtkWidget *_16_1;
GtkWidget *optionmenu_dest;
GtkWidget *menu2;
GtkWidget *menuitem1;
GtkWidget *menuitem2;
GtkWidget *menuitem3;
GtkWidget *label3;
GtkWidget *label_errorx;
GtkWidget *label7;
GtkWidget *label_errory;
GtkWidget *checkbutton_16;
GtkWidget *optionmenu1;
GtkWidget *menu3;
GtkWidget *bilinear1;
GtkWidget *bicubic1;
GtkWidget *lanczos1;
GtkWidget *alignment1;
GtkWidget *fixed1;
GtkWidget *fixed2;
GtkWidget *hscale1;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *applybutton1;
GtkWidget *okbutton1;
dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("Resize"));
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);
table2 = gtk_table_new (4, 4, FALSE);
gtk_widget_show (table2);
gtk_box_pack_start (GTK_BOX (vbox1), table2, FALSE, FALSE, 0);
label1 = gtk_label_new (QT_TR_NOOP(" Width "));
gtk_widget_show (label1);
gtk_table_attach (GTK_TABLE (table2), label1, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5);
label2 = gtk_label_new (QT_TR_NOOP(" Height "));
gtk_widget_show (label2);
gtk_table_attach (GTK_TABLE (table2), label2, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5);
spinbutton_width_adj = gtk_adjustment_new (2, 0, 3000, 1, 10, 10);
spinbutton_width = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton_width_adj), 1, 0);
gtk_widget_show (spinbutton_width);
gtk_table_attach (GTK_TABLE (table2), spinbutton_width, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton_width), TRUE);
spinbutton_height_adj = gtk_adjustment_new (1, 0, 3000, 1, 10, 10);
spinbutton_height = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton_height_adj), 1, 0);
gtk_widget_show (spinbutton_height);
gtk_table_attach (GTK_TABLE (table2), spinbutton_height, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton_height), TRUE);
label5 = gtk_label_new (QT_TR_NOOP("Source :"));
gtk_widget_show (label5);
gtk_table_attach (GTK_TABLE (table2), label5, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label6 = gtk_label_new (QT_TR_NOOP("Destination"));
gtk_widget_show (label6);
gtk_table_attach (GTK_TABLE (table2), label6, 2, 3, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
optionmenu_source = gtk_option_menu_new ();
gtk_widget_show (optionmenu_source);
gtk_table_attach (GTK_TABLE (table2), optionmenu_source, 3, 4, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
menu1 = gtk_menu_new ();
item1_1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("1:1"));
gtk_widget_show (item1_1);
gtk_container_add (GTK_CONTAINER (menu1), item1_1);
_4_1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("4:3"));
gtk_widget_show (_4_1);
gtk_container_add (GTK_CONTAINER (menu1), _4_1);
_16_1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("16:9"));
gtk_widget_show (_16_1);
gtk_container_add (GTK_CONTAINER (menu1), _16_1);
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu_source), menu1);
optionmenu_dest = gtk_option_menu_new ();
gtk_widget_show (optionmenu_dest);
gtk_table_attach (GTK_TABLE (table2), optionmenu_dest, 3, 4, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
menu2 = gtk_menu_new ();
menuitem1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("1:1"));
gtk_widget_show (menuitem1);
gtk_container_add (GTK_CONTAINER (menu2), menuitem1);
menuitem2 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("4:3"));
gtk_widget_show (menuitem2);
gtk_container_add (GTK_CONTAINER (menu2), menuitem2);
menuitem3 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("16:9"));
gtk_widget_show (menuitem3);
gtk_container_add (GTK_CONTAINER (menu2), menuitem3);
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu_dest), menu2);
label3 = gtk_label_new (QT_TR_NOOP(" Error X:"));
gtk_widget_show (label3);
gtk_table_attach (GTK_TABLE (table2), label3, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5);
label_errorx = gtk_label_new (QT_TR_NOOP("0"));
gtk_widget_show (label_errorx);
gtk_table_attach (GTK_TABLE (table2), label_errorx, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_errorx), 0, 0.5);
label7 = gtk_label_new (QT_TR_NOOP(" Error Y:"));
gtk_widget_show (label7);
gtk_table_attach (GTK_TABLE (table2), label7, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5);
label_errory = gtk_label_new (QT_TR_NOOP("0"));
gtk_widget_show (label_errory);
gtk_table_attach (GTK_TABLE (table2), label_errory, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_errory), 0, 0.5);
checkbutton_16 = gtk_check_button_new_with_mnemonic (QT_TR_NOOP("16 round up"));
gtk_widget_show (checkbutton_16);
gtk_table_attach (GTK_TABLE (table2), checkbutton_16, 3, 4, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
optionmenu1 = gtk_option_menu_new ();
gtk_widget_show (optionmenu1);
gtk_table_attach (GTK_TABLE (table2), optionmenu1, 3, 4, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
menu3 = gtk_menu_new ();
bilinear1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("Bilinear"));
gtk_widget_show (bilinear1);
gtk_container_add (GTK_CONTAINER (menu3), bilinear1);
bicubic1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("Bicubic"));
gtk_widget_show (bicubic1);
gtk_container_add (GTK_CONTAINER (menu3), bicubic1);
lanczos1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("Lanczos3"));
gtk_widget_show (lanczos1);
gtk_container_add (GTK_CONTAINER (menu3), lanczos1);
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1), menu3);
alignment1 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment1);
gtk_table_attach (GTK_TABLE (table2), alignment1, 2, 3, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
fixed1 = gtk_fixed_new ();
gtk_widget_show (fixed1);
gtk_container_add (GTK_CONTAINER (alignment1), fixed1);
fixed2 = gtk_fixed_new ();
gtk_widget_show (fixed2);
gtk_table_attach (GTK_TABLE (table2), fixed2, 2, 3, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (100, 0, 100, 1, 1, 0)));
gtk_widget_show (hscale1);
gtk_box_pack_start (GTK_BOX (vbox1), hscale1, FALSE, FALSE, 0);
gtk_scale_set_digits (GTK_SCALE (hscale1), 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);
applybutton1 = gtk_button_new_from_stock ("gtk-apply");
gtk_widget_show (applybutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), applybutton1, GTK_RESPONSE_APPLY);
GTK_WIDGET_SET_FLAGS (applybutton1, 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);
/*
g_signal_connect ((gpointer) _4_1, "activate",
G_CALLBACK (on_4_1_activate),
NULL);
g_signal_connect ((gpointer) _16_1, "activate",
G_CALLBACK (on_16_1_activate),
NULL);
g_signal_connect ((gpointer) menuitem2, "activate",
G_CALLBACK (on_4_1_activate),
NULL);
g_signal_connect ((gpointer) menuitem3, "activate",
G_CALLBACK (on_16_1_activate),
NULL);
g_signal_connect ((gpointer) bilinear1, "activate",
G_CALLBACK (on_bilinear1_activate),
NULL);
g_signal_connect ((gpointer) bicubic1, "activate",
G_CALLBACK (on_bicubic1_activate),
NULL);
g_signal_connect ((gpointer) lanczos1, "activate",
G_CALLBACK (on_lanczos1_activate),
NULL);
*/
/* 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, table2, "table2");
GLADE_HOOKUP_OBJECT (dialog1, label1, "label1");
GLADE_HOOKUP_OBJECT (dialog1, label2, "label2");
GLADE_HOOKUP_OBJECT (dialog1, spinbutton_width, "spinbutton_width");
GLADE_HOOKUP_OBJECT (dialog1, spinbutton_height, "spinbutton_height");
GLADE_HOOKUP_OBJECT (dialog1, label5, "label5");
GLADE_HOOKUP_OBJECT (dialog1, label6, "label6");
GLADE_HOOKUP_OBJECT (dialog1, optionmenu_source, "optionmenu_source");
GLADE_HOOKUP_OBJECT (dialog1, menu1, "menu1");
GLADE_HOOKUP_OBJECT (dialog1, item1_1, "item1_1");
GLADE_HOOKUP_OBJECT (dialog1, _4_1, "_4_1");
GLADE_HOOKUP_OBJECT (dialog1, _16_1, "_16_1");
GLADE_HOOKUP_OBJECT (dialog1, optionmenu_dest, "optionmenu_dest");
GLADE_HOOKUP_OBJECT (dialog1, menu2, "menu2");
GLADE_HOOKUP_OBJECT (dialog1, menuitem1, "menuitem1");
GLADE_HOOKUP_OBJECT (dialog1, menuitem2, "menuitem2");
GLADE_HOOKUP_OBJECT (dialog1, menuitem3, "menuitem3");
GLADE_HOOKUP_OBJECT (dialog1, label3, "label3");
GLADE_HOOKUP_OBJECT (dialog1, label_errorx, "label_errorx");
GLADE_HOOKUP_OBJECT (dialog1, label7, "label7");
GLADE_HOOKUP_OBJECT (dialog1, label_errory, "label_errory");
GLADE_HOOKUP_OBJECT (dialog1, checkbutton_16, "checkbutton_16");
GLADE_HOOKUP_OBJECT (dialog1, optionmenu1, "optionmenu1");
GLADE_HOOKUP_OBJECT (dialog1, menu3, "menu3");
GLADE_HOOKUP_OBJECT (dialog1, bilinear1, "bilinear1");
GLADE_HOOKUP_OBJECT (dialog1, bicubic1, "bicubic1");
GLADE_HOOKUP_OBJECT (dialog1, lanczos1, "lanczos1");
GLADE_HOOKUP_OBJECT (dialog1, alignment1, "alignment1");
GLADE_HOOKUP_OBJECT (dialog1, fixed1, "fixed1");
GLADE_HOOKUP_OBJECT (dialog1, fixed2, "fixed2");
GLADE_HOOKUP_OBJECT (dialog1, hscale1, "hscale1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (dialog1, applybutton1, "applybutton1");
GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");
return dialog1;
}
void create_range_controls( void )
{
GtkWidget *window;
GtkWidget *box1, *box2, *box3;
GtkWidget *button;
GtkWidget *scrollbar;
GtkWidget *separator;
GtkWidget *opt, *menu, *item;
GtkWidget *label;
GtkWidget *scale;
GtkObject *adj1, *adj2;
/* Standard window-creating stuff */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_main_quit),
NULL);
gtk_window_set_title (GTK_WINDOW (window), "range controls");
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (box1);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
/* 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). */
adj1 = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
vscale = gtk_vscale_new (GTK_ADJUSTMENT (adj1));
scale_set_default_values (GTK_SCALE (vscale));
gtk_box_pack_start (GTK_BOX (box2), vscale, TRUE, TRUE, 0);
gtk_widget_show (vscale);
box3 = gtk_vbox_new (FALSE, 10);
gtk_box_pack_start (GTK_BOX (box2), box3, TRUE, TRUE, 0);
gtk_widget_show (box3);
/* Reuse the same adjustment */
hscale = gtk_hscale_new (GTK_ADJUSTMENT (adj1));
gtk_widget_set_usize (GTK_WIDGET (hscale), 200, 30);
scale_set_default_values (GTK_SCALE (hscale));
gtk_box_pack_start (GTK_BOX (box3), hscale, TRUE, TRUE, 0);
gtk_widget_show (hscale);
/* Reuse the same adjustment again */
scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adj1));
/* Notice how this causes the scales to always be updated
* continuously when the scrollbar is moved */
gtk_range_set_update_policy (GTK_RANGE (scrollbar),
GTK_UPDATE_CONTINUOUS);
gtk_box_pack_start (GTK_BOX (box3), scrollbar, TRUE, TRUE, 0);
gtk_widget_show (scrollbar);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
/* A checkbutton to control whether the value is displayed or not */
button = gtk_check_button_new_with_label("Display value on scale widgets");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_signal_connect (GTK_OBJECT (button), "toggled",
GTK_SIGNAL_FUNC(cb_draw_value), NULL);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_show (button);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
/* An option menu to change the position of the value */
label = gtk_label_new ("Scale Value Position:");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label);
opt = gtk_option_menu_new();
menu = gtk_menu_new();
item = make_menu_item ("Top",
GTK_SIGNAL_FUNC(cb_pos_menu_select),
GINT_TO_POINTER (GTK_POS_TOP));
gtk_menu_append (GTK_MENU (menu), item);
item = make_menu_item ("Bottom", GTK_SIGNAL_FUNC (cb_pos_menu_select),
GINT_TO_POINTER (GTK_POS_BOTTOM));
gtk_menu_append (GTK_MENU (menu), item);
item = make_menu_item ("Left", GTK_SIGNAL_FUNC (cb_pos_menu_select),
GINT_TO_POINTER (GTK_POS_LEFT));
gtk_menu_append (GTK_MENU (menu), item);
item = make_menu_item ("Right", GTK_SIGNAL_FUNC (cb_pos_menu_select),
GINT_TO_POINTER (GTK_POS_RIGHT));
gtk_menu_append (GTK_MENU (menu), item);
gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu);
gtk_box_pack_start (GTK_BOX (box2), opt, TRUE, TRUE, 0);
gtk_widget_show (opt);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
/* Yet another option menu, this time for the update policy of the
* scale widgets */
label = gtk_label_new ("Scale Update Policy:");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label);
opt = gtk_option_menu_new();
menu = gtk_menu_new();
item = make_menu_item ("Continuous",
GTK_SIGNAL_FUNC (cb_update_menu_select),
GINT_TO_POINTER (GTK_UPDATE_CONTINUOUS));
gtk_menu_append (GTK_MENU (menu), item);
item = make_menu_item ("Discontinuous",
GTK_SIGNAL_FUNC (cb_update_menu_select),
GINT_TO_POINTER (GTK_UPDATE_DISCONTINUOUS));
gtk_menu_append (GTK_MENU (menu), item);
item = make_menu_item ("Delayed",
GTK_SIGNAL_FUNC (cb_update_menu_select),
GINT_TO_POINTER (GTK_UPDATE_DELAYED));
gtk_menu_append (GTK_MENU (menu), item);
gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu);
gtk_box_pack_start (GTK_BOX (box2), opt, TRUE, TRUE, 0);
gtk_widget_show (opt);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
/* An HScale widget for adjusting the number of digits on the
* sample scales. */
label = gtk_label_new ("Scale Digits:");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label);
adj2 = gtk_adjustment_new (1.0, 0.0, 5.0, 1.0, 1.0, 0.0);
gtk_signal_connect (GTK_OBJECT (adj2), "value_changed",
GTK_SIGNAL_FUNC (cb_digits_scale), NULL);
scale = gtk_hscale_new (GTK_ADJUSTMENT (adj2));
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
/* And, one last HScale widget for adjusting the page size of the
* scrollbar. */
label = gtk_label_new ("Scrollbar Page Size:");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label);
adj2 = gtk_adjustment_new (1.0, 1.0, 101.0, 1.0, 1.0, 0.0);
gtk_signal_connect (GTK_OBJECT (adj2), "value_changed",
GTK_SIGNAL_FUNC (cb_page_size), adj1);
scale = gtk_hscale_new (GTK_ADJUSTMENT (adj2));
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_show (box2);
button = gtk_button_new_with_label ("Quit");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(gtk_main_quit),
NULL);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_widget_show (button);
gtk_widget_show (window);
}
GtkWidget*
create_ChromaShift (void)
{
GtkWidget *ChromaShift;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *table1;
GtkWidget *label1;
GtkWidget *label2;
GtkObject *spinbutton_U_adj;
GtkWidget *spinbutton_U;
GtkObject *spinbutton_V_adj;
GtkWidget *spinbutton_V;
GtkWidget *hscale;
GtkWidget *frame1;
GtkWidget *alignment1;
GtkWidget *drawingarea1;
GtkWidget *label3;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *applybutton1;
GtkWidget *okbutton1;
ChromaShift = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (ChromaShift), QT_TR_NOOP("ChromaShift"));
gtk_window_set_type_hint (GTK_WINDOW (ChromaShift), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = GTK_DIALOG (ChromaShift)->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);
table1 = gtk_table_new (2, 2, FALSE);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (vbox1), table1, FALSE, FALSE, 0);
label1 = gtk_label_new (QT_TR_NOOP("U Shift :"));
gtk_widget_show (label1);
gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5);
label2 = gtk_label_new (QT_TR_NOOP("V Shift :"));
gtk_widget_show (label2);
gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5);
spinbutton_U_adj = gtk_adjustment_new (0, -32, 32, 1, 10, 0);
spinbutton_U = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton_U_adj), 1, 0);
gtk_widget_show (spinbutton_U);
gtk_table_attach (GTK_TABLE (table1), spinbutton_U, 1, 2, 0, 1,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton_U), TRUE);
spinbutton_V_adj = gtk_adjustment_new (0, -32, 32, 1, 10, 0);
spinbutton_V = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton_V_adj), 1, 0);
gtk_widget_show (spinbutton_V);
gtk_table_attach (GTK_TABLE (table1), spinbutton_V, 1, 2, 1, 2,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton_V), TRUE);
hscale = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 100, 1, 1, 0)));
gtk_widget_show (hscale);
gtk_box_pack_start (GTK_BOX (vbox1), hscale, FALSE, FALSE, 0);
gtk_scale_set_digits (GTK_SCALE (hscale), 0);
frame1 = gtk_frame_new (NULL);
gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (vbox1), frame1, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_NONE);
alignment1 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment1);
gtk_container_add (GTK_CONTAINER (frame1), alignment1);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment1), 0, 0, 12, 0);
drawingarea1 = gtk_drawing_area_new ();
gtk_widget_show (drawingarea1);
gtk_container_add (GTK_CONTAINER (alignment1), drawingarea1);
label3 = gtk_label_new (QT_TR_NOOP("<b>Preview</b>"));
gtk_widget_show (label3);
gtk_frame_set_label_widget (GTK_FRAME (frame1), label3);
gtk_label_set_use_markup (GTK_LABEL (label3), TRUE);
dialog_action_area1 = GTK_DIALOG (ChromaShift)->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 (ChromaShift), cancelbutton1, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);
applybutton1 = gtk_button_new_from_stock ("gtk-apply");
gtk_widget_show (applybutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (ChromaShift), applybutton1, GTK_RESPONSE_APPLY);
GTK_WIDGET_SET_FLAGS (applybutton1, GTK_CAN_DEFAULT);
okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (ChromaShift), 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 (ChromaShift, ChromaShift, "ChromaShift");
GLADE_HOOKUP_OBJECT_NO_REF (ChromaShift, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (ChromaShift, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (ChromaShift, table1, "table1");
GLADE_HOOKUP_OBJECT (ChromaShift, label1, "label1");
GLADE_HOOKUP_OBJECT (ChromaShift, label2, "label2");
GLADE_HOOKUP_OBJECT (ChromaShift, spinbutton_U, "spinbutton_U");
GLADE_HOOKUP_OBJECT (ChromaShift, spinbutton_V, "spinbutton_V");
GLADE_HOOKUP_OBJECT (ChromaShift, hscale, "hscale");
GLADE_HOOKUP_OBJECT (ChromaShift, frame1, "frame1");
GLADE_HOOKUP_OBJECT (ChromaShift, alignment1, "alignment1");
GLADE_HOOKUP_OBJECT (ChromaShift, drawingarea1, "drawingarea1");
GLADE_HOOKUP_OBJECT (ChromaShift, label3, "label3");
GLADE_HOOKUP_OBJECT_NO_REF (ChromaShift, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (ChromaShift, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (ChromaShift, applybutton1, "applybutton1");
GLADE_HOOKUP_OBJECT (ChromaShift, okbutton1, "okbutton1");
return ChromaShift;
}
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;
}
