/**
* @brief Spectrum low changed
*
* @param spinButton
* @param data
*/
void spectrumLowChanged(GtkSpinButton* spinButton,gpointer data) {
spectrumMIN=gtk_spin_button_get_value(spinButton);
}
bool RunLinuxDialog()
{
GtkWidget *dialog;
GtkWidget *main_box, *central_box, *advance_box, *res_box, *hw_box, *sw_box, *shader_box;
GtkWidget *native_box, *fsaa_box, *resxy_box, *renderer_box, *interlace_box, *threads_box, *filter_box;
GtkWidget *hw_table, *shader_table, *res_frame, *hw_frame, *sw_frame, *shader_frame;
GtkWidget *interlace_combo_box, *threads_spin;
GtkWidget *interlace_label, *threads_label, *native_label, *fsaa_label, *rexy_label, *render_label, *filter_label;
GtkWidget *fsaa_combo_box, *render_combo_box, *filter_combo_box;
GtkWidget *shader, *shader_conf, *shader_label, *shader_conf_label;
GtkWidget *shadeboost_check, *paltex_check, *fba_check, *aa_check, *native_res_check, *fxaa_check, *shaderfx_check;
GtkWidget *sb_contrast, *sb_brightness, *sb_saturation;
GtkWidget *resx_spin, *resy_spin;
GtkWidget *hack_table, *hack_skipdraw_label, *hack_box, *hack_frame;
GtkWidget *hack_alpha_check, *hack_date_check, *hack_offset_check, *hack_skipdraw_spin, *hack_msaa_check, *hack_sprite_check, * hack_wild_check, *hack_enble_check, *hack_logz_check;
GtkWidget *hack_tco_label, *hack_tco_entry;
GtkWidget *gl_box, *gl_frame, *gl_table;
GtkWidget *notebook, *page_label[2];
int return_value;
GdkPixbuf* logo_pixmap;
GtkWidget *logo_image;
/* Create the widgets */
dialog = gtk_dialog_new_with_buttons (
"GSdx Config",
NULL, /* parent window*/
(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
"OK", GTK_RESPONSE_ACCEPT,
"Cancel", GTK_RESPONSE_REJECT,
NULL);
// The main area for the whole dialog box.
main_box = gtk_vbox_new(false, 5);
central_box = gtk_vbox_new(false, 5);
advance_box = gtk_vbox_new(false, 5);
// The Internal resolution frame and container.
res_box = gtk_vbox_new(false, 5);
res_frame = gtk_frame_new ("OpenGL Internal Resolution (can cause glitches)");
gtk_container_add(GTK_CONTAINER(res_frame), res_box);
// The extra shader setting frame/container/table
shader_box = gtk_vbox_new(false, 5);
shader_frame = gtk_frame_new("Custom Shader Settings");
gtk_container_add(GTK_CONTAINER(shader_frame), shader_box);
shader_table = gtk_table_new(8,2, false);
gtk_container_add(GTK_CONTAINER(shader_box), shader_table);
// The hardware mode frame, container, and table.
hw_box = gtk_vbox_new(false, 5);
hw_frame = gtk_frame_new ("Hardware Mode Settings");
gtk_container_add(GTK_CONTAINER(hw_frame), hw_box);
hw_table = gtk_table_new(5,2, false);
gtk_container_add(GTK_CONTAINER(hw_box), hw_table);
// The software mode frame and container. (It doesn't have enough in it for a table.)
sw_box = gtk_vbox_new(false, 5);
sw_frame = gtk_frame_new ("Software Mode Settings");
gtk_container_add(GTK_CONTAINER(sw_frame), sw_box);
// The hack frame and container.
hack_box = gtk_hbox_new(false, 5);
hack_frame = gtk_frame_new ("Hacks");
gtk_container_add(GTK_CONTAINER(hack_frame), hack_box);
hack_table = gtk_table_new(3,3, false);
gtk_container_add(GTK_CONTAINER(hack_box), hack_table);
// Grab a logo, to make things look nice.
logo_pixmap = gdk_pixbuf_from_pixdata(&gsdx_ogl_logo, false, NULL);
logo_image = gtk_image_new_from_pixbuf(logo_pixmap);
gtk_box_pack_start(GTK_BOX(main_box), logo_image, true, true, 0);
// Create the renderer combo box and label, and stash them in a box.
render_label = gtk_label_new ("Renderer:");
render_combo_box = CreateRenderComboBox();
renderer_box = gtk_hbox_new(false, 5);
// Use gtk_box_pack_start instead of gtk_container_add so it lines up nicely.
gtk_box_pack_start(GTK_BOX(renderer_box), render_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(renderer_box), render_combo_box, false, false, 5);
// Create the interlace combo box and label, and stash them in a box.
interlace_label = gtk_label_new ("Interlacing (F5):");
interlace_combo_box = CreateInterlaceComboBox();
interlace_box = gtk_hbox_new(false, 5);
gtk_box_pack_start(GTK_BOX(interlace_box), interlace_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(interlace_box), interlace_combo_box, false, false, 5);
// Create the filter combo box.
filter_label = gtk_label_new ("Texture Filtering:");
filter_combo_box = CreateFilterComboBox();
filter_box = gtk_hbox_new(false, 5);
gtk_box_pack_start(GTK_BOX(filter_box), filter_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(filter_box), filter_combo_box, false, false, 0);
// Create the threading spin box and label, and stash them in a box. (Yes, we do a lot of that.)
threads_label = gtk_label_new("Extra rendering threads:");
threads_spin = gtk_spin_button_new_with_range(0,100,1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(threads_spin), theApp.GetConfig("extrathreads", 0));
threads_box = gtk_hbox_new(false, 0);
gtk_box_pack_start(GTK_BOX(threads_box), threads_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(threads_box), threads_spin, false, false, 5);
// A bit of funkiness for the resolution box.
native_label = gtk_label_new("Original PS2 Resolution: ");
native_res_check = gtk_check_button_new_with_label("Native");
native_box = gtk_hbox_new(false, 5);
gtk_box_pack_start(GTK_BOX(native_box), native_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(native_box), native_res_check, false, false, 5);
fsaa_label = gtk_label_new("Or Use Scaling:");
fsaa_combo_box = CreateMsaaComboBox();
fsaa_box = gtk_hbox_new(false, 5);
gtk_box_pack_start(GTK_BOX(fsaa_box), fsaa_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(fsaa_box), fsaa_combo_box, false, false, 5);
rexy_label = gtk_label_new("Custom Resolution:");
resx_spin = gtk_spin_button_new_with_range(256,8192,1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(resx_spin), theApp.GetConfig("resx", 1024));
resy_spin = gtk_spin_button_new_with_range(256,8192,1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(resy_spin), theApp.GetConfig("resy", 1024));
resxy_box = gtk_hbox_new(false, 5);
gtk_box_pack_start(GTK_BOX(resxy_box), rexy_label, false, false, 5);
gtk_box_pack_start(GTK_BOX(resxy_box), resx_spin, false, false, 5);
gtk_box_pack_start(GTK_BOX(resxy_box), resy_spin, false, false, 5);
// shader fx entry
shader = gtk_file_chooser_button_new("Select an external shader", GTK_FILE_CHOOSER_ACTION_OPEN);
shader_conf = gtk_file_chooser_button_new("Then select a config", GTK_FILE_CHOOSER_ACTION_OPEN);
shader_label = gtk_label_new("External shader glsl");
shader_conf_label = gtk_label_new("External shader conf");
// Create our hack settings.
hack_alpha_check = gtk_check_button_new_with_label("Alpha Hack");
hack_date_check = gtk_check_button_new_with_label("Date Hack");
hack_offset_check = gtk_check_button_new_with_label("Offset Hack");
hack_skipdraw_label = gtk_label_new("Skipdraw:");
hack_skipdraw_spin = gtk_spin_button_new_with_range(0,1000,1);
hack_enble_check = gtk_check_button_new_with_label("Enable User Hacks");
hack_wild_check = gtk_check_button_new_with_label("Wild arm Hack");
hack_sprite_check = gtk_check_button_new_with_label("Sprite Hack");
hack_msaa_check = gtk_check_button_new_with_label("Msaa Hack");
hack_tco_label = gtk_label_new("Texture Offset: 0x");
hack_tco_entry = gtk_entry_new();
hack_logz_check = gtk_check_button_new_with_label("Log Depth Hack");
gtk_spin_button_set_value(GTK_SPIN_BUTTON(hack_skipdraw_spin), theApp.GetConfig("UserHacks_SkipDraw", 0));
set_hex_entry(hack_tco_entry, theApp.GetConfig("UserHacks_TCOffset", 0));
// Tables are strange. The numbers are for their position: left, right, top, bottom.
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_alpha_check, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_offset_check, 1, 2, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_sprite_check, 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_wild_check, 1, 2, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_logz_check, 0, 1, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_date_check, 1, 2, 2, 3);
// Note: MSAA is not implemented yet. I disable it to make the table square
//gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_msaa_check, 2, 3, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_skipdraw_label, 0, 1, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_skipdraw_spin, 1, 2, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_tco_label, 0, 1, 4, 5);
gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_tco_entry, 1, 2, 4, 5);
// Create our checkboxes.
shadeboost_check = gtk_check_button_new_with_label("Shade boost");
paltex_check = gtk_check_button_new_with_label("Allow 8 bits textures");
fba_check = gtk_check_button_new_with_label("Alpha correction (FBA)");
aa_check = gtk_check_button_new_with_label("Edge anti-aliasing (AA1)");
fxaa_check = gtk_check_button_new_with_label("Fxaa shader");
shaderfx_check = gtk_check_button_new_with_label("External shader");
// Set the checkboxes.
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(shadeboost_check), theApp.GetConfig("shadeboost", 1));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(paltex_check), theApp.GetConfig("paltex", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fba_check), theApp.GetConfig("fba", 1));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(aa_check), theApp.GetConfig("aa1", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fxaa_check), theApp.GetConfig("fxaa", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(shaderfx_check), theApp.GetConfig("shaderfx", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(native_res_check), theApp.GetConfig("nativeres", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_alpha_check), theApp.GetConfig("UserHacks_AlphaHack", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_offset_check), theApp.GetConfig("UserHacks_HalfPixelOffset", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_date_check), theApp.GetConfig("UserHacks_DateGL4", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_enble_check), theApp.GetConfig("UserHacks", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_msaa_check), theApp.GetConfig("UserHacks_MSAA", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_wild_check), theApp.GetConfig("UserHacks_WildHack", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_sprite_check), theApp.GetConfig("UserHacks_SpriteHack", 0));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hack_logz_check), theApp.GetConfig("logz", 1));
// Shadeboost scale
#if GTK_MAJOR_VERSION < 3
sb_brightness = gtk_hscale_new_with_range(0, 200, 10);
#else
sb_brightness = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, 0, 200, 10);
#endif
GtkWidget* sb_brightness_label = gtk_label_new("Shade Boost Brightness");
gtk_scale_set_value_pos(GTK_SCALE(sb_brightness), GTK_POS_RIGHT);
gtk_range_set_value(GTK_RANGE(sb_brightness), theApp.GetConfig("ShadeBoost_Brightness", 50));
#if GTK_MAJOR_VERSION < 3
sb_contrast = gtk_hscale_new_with_range(0, 200, 10);
#else
sb_contrast = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, 0, 200, 10);
#endif
GtkWidget* sb_contrast_label = gtk_label_new("Shade Boost Contrast");
gtk_scale_set_value_pos(GTK_SCALE(sb_contrast), GTK_POS_RIGHT);
gtk_range_set_value(GTK_RANGE(sb_contrast), theApp.GetConfig("ShadeBoost_Contrast", 50));
#if GTK_MAJOR_VERSION < 3
sb_saturation = gtk_hscale_new_with_range(0, 200, 10);
#else
sb_saturation = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, 0, 200, 10);
#endif
GtkWidget* sb_saturation_label = gtk_label_new("Shade Boost Saturation");
gtk_scale_set_value_pos(GTK_SCALE(sb_saturation), GTK_POS_RIGHT);
gtk_range_set_value(GTK_RANGE(sb_saturation), theApp.GetConfig("ShadeBoost_Saturation", 50));
// external shader entry
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(shader), theApp.GetConfig("shaderfx_glsl", "dummy.glsl").c_str());
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(shader_conf), theApp.GetConfig("shaderfx_conf", "dummy.ini").c_str());
// Populate all those boxes we created earlier with widgets.
gtk_container_add(GTK_CONTAINER(res_box), native_box);
gtk_container_add(GTK_CONTAINER(res_box), fsaa_box);
gtk_container_add(GTK_CONTAINER(res_box), resxy_box);
gtk_container_add(GTK_CONTAINER(sw_box), threads_box);
gtk_container_add(GTK_CONTAINER(sw_box), aa_check);
// Tables are strange. The numbers are for their position: left, right, top, bottom.
gtk_table_attach_defaults(GTK_TABLE(shader_table), fxaa_check, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(shader_table), shadeboost_check, 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(shader_table), sb_brightness_label, 0, 1, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(shader_table), sb_brightness, 1, 2, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(shader_table), sb_contrast_label, 0, 1, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(shader_table), sb_contrast, 1, 2, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(shader_table), sb_saturation_label, 0, 1, 4, 5);
gtk_table_attach_defaults(GTK_TABLE(shader_table), sb_saturation, 1, 2, 4, 5);
gtk_table_attach_defaults(GTK_TABLE(shader_table), shaderfx_check, 0, 1, 5, 6);
gtk_table_attach_defaults(GTK_TABLE(shader_table), shader_label, 0, 1, 6, 7);
gtk_table_attach_defaults(GTK_TABLE(shader_table), shader, 1, 2, 6, 7);
gtk_table_attach_defaults(GTK_TABLE(shader_table), shader_conf_label, 0, 1, 7, 8);
gtk_table_attach_defaults(GTK_TABLE(shader_table), shader_conf, 1, 2, 7, 8);
// Tables are strange. The numbers are for their position: left, right, top, bottom.
gtk_table_attach_defaults(GTK_TABLE(hw_table), filter_box, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(hw_table), paltex_check, 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(hw_table), fba_check, 1, 2, 1, 2);
// The GL advance options
gl_box = gtk_vbox_new(false, 5);
gl_frame = gtk_frame_new ("OpenGL Very Advanced Custom Settings");
gtk_container_add(GTK_CONTAINER(gl_frame), gl_box);
gl_table = gtk_table_new(10, 2, false);
gtk_container_add(GTK_CONTAINER(gl_box), gl_table);
GtkWidget* gl_bs_label = gtk_label_new("Buffer Storage:");
GtkWidget* gl_bs_combo = CreateGlComboBox("override_GL_ARB_buffer_storage");
GtkWidget* gl_bt_label = gtk_label_new("Bindless Texture:");
GtkWidget* gl_bt_combo = CreateGlComboBox("override_GL_ARB_bindless_texture");
GtkWidget* gl_sso_label = gtk_label_new("Separate Shader:");
GtkWidget* gl_sso_combo = CreateGlComboBox("override_GL_ARB_separate_shader_objects");
GtkWidget* gl_ss_label = gtk_label_new("Shader Subroutine:");
GtkWidget* gl_ss_combo = CreateGlComboBox("override_GL_ARB_shader_subroutine");
GtkWidget* gl_gs_label = gtk_label_new("Geometry Shader:");
GtkWidget* gl_gs_combo = CreateGlComboBox("override_geometry_shader");
GtkWidget* gl_ils_label = gtk_label_new("Image Load Store:");
GtkWidget* gl_ils_combo = CreateGlComboBox("override_GL_ARB_shader_image_load_store");
GtkWidget* gl_cc_label = gtk_label_new("Clip Control (depth accuracy):");
GtkWidget* gl_cc_combo = CreateGlComboBox("override_GL_ARB_clip_control");
GtkWidget* gl_ct_label = gtk_label_new("Clear Texture:");
GtkWidget* gl_ct_combo = CreateGlComboBox("override_GL_ARB_clear_texture");
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_gs_label, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_gs_combo, 1, 2, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_bs_label, 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_bs_combo, 1, 2, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_bt_label, 0, 1, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_bt_combo, 1, 2, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_sso_label, 0, 1, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_sso_combo, 1, 2, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_ss_label, 0, 1, 4, 5);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_ss_combo, 1, 2, 4, 5);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_ils_label, 0, 1, 5, 6);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_ils_combo, 1, 2, 5, 6);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_cc_label, 0, 1, 6, 7);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_cc_combo, 1, 2, 6, 7);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_ct_label, 0, 1, 7, 8);
gtk_table_attach_defaults(GTK_TABLE(gl_table), gl_ct_combo, 1, 2, 7, 8);
// those one are properly detected so no need a gui
#if 0
override_GL_ARB_copy_image = -1
override_GL_ARB_explicit_uniform_location = -1
override_GL_ARB_gpu_shader5 = -1
override_GL_ARB_shading_language_420pack = -1
#endif
// Handle some nice tab
notebook = gtk_notebook_new();
page_label[0] = gtk_label_new("Global Setting");
page_label[1] = gtk_label_new("Advance Setting");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), central_box, page_label[0]);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), advance_box, page_label[1]);
// Put everything in the big box.
gtk_container_add(GTK_CONTAINER(main_box), renderer_box);
gtk_container_add(GTK_CONTAINER(main_box), interlace_box);
gtk_container_add(GTK_CONTAINER(main_box), notebook);
gtk_container_add(GTK_CONTAINER(central_box), res_frame);
gtk_container_add(GTK_CONTAINER(central_box), shader_frame);
gtk_container_add(GTK_CONTAINER(central_box), hw_frame);
gtk_container_add(GTK_CONTAINER(central_box), sw_frame);
gtk_container_add(GTK_CONTAINER(advance_box), hack_frame);
gtk_container_add(GTK_CONTAINER(advance_box), gl_frame);
// Put the box in the dialog and show it to the world.
gtk_container_add (GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), main_box);
gtk_widget_show_all (dialog);
return_value = gtk_dialog_run (GTK_DIALOG (dialog));
if (return_value == GTK_RESPONSE_ACCEPT)
{
int mode_height = 0, mode_width = 0;
mode_width = theApp.GetConfig("ModeWidth", 640);
mode_height = theApp.GetConfig("ModeHeight", 480);
theApp.SetConfig("ModeHeight", mode_height);
theApp.SetConfig("ModeWidth", mode_width);
// Get all the settings from the dialog box.
if (gtk_combo_box_get_active(GTK_COMBO_BOX(render_combo_box)) != -1) {
// Note the value are based on m_gs_renderers vector on GSdx.cpp
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(render_combo_box))) {
case 0: theApp.SetConfig("renderer", 10); break;
case 1: theApp.SetConfig("renderer", 16); break;
case 2: theApp.SetConfig("renderer", 11); break;
case 3: theApp.SetConfig("renderer", 12); break;
case 4: theApp.SetConfig("renderer", 13); break;
case 5: theApp.SetConfig("renderer", 17); break;
// Fallback to SW opengl
default: theApp.SetConfig("renderer", 13); break;
}
}
if (gtk_combo_box_get_active(GTK_COMBO_BOX(interlace_combo_box)) != -1)
theApp.SetConfig( "interlace", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(interlace_combo_box)));
theApp.SetConfig("extrathreads", (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(threads_spin)));
theApp.SetConfig("filter", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(filter_combo_box)));
theApp.SetConfig("shadeboost", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(shadeboost_check)));
theApp.SetConfig("paltex", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(paltex_check)));
theApp.SetConfig("fba", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(fba_check)));
theApp.SetConfig("aa1", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(aa_check)));
theApp.SetConfig("fxaa", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(fxaa_check)));
theApp.SetConfig("shaderfx", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(shaderfx_check)));
theApp.SetConfig("nativeres", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(native_res_check)));
theApp.SetConfig("shaderfx_glsl", gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(shader)));
theApp.SetConfig("shaderfx_conf", gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(shader_conf)));
theApp.SetConfig("ShadeBoost_Saturation", (int)gtk_range_get_value(GTK_RANGE(sb_saturation)));
theApp.SetConfig("ShadeBoost_Brightness", (int)gtk_range_get_value(GTK_RANGE(sb_brightness)));
theApp.SetConfig("ShadeBoost_Contrast", (int)gtk_range_get_value(GTK_RANGE(sb_contrast)));
theApp.SetConfig("upscale_multiplier", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(fsaa_combo_box))+1);
theApp.SetConfig("resx", (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(resx_spin)));
theApp.SetConfig("resy", (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(resy_spin)));
theApp.SetConfig("UserHacks_SkipDraw", (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(hack_skipdraw_spin)));
theApp.SetConfig("UserHacks_HalfPixelOffset", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_offset_check)));
theApp.SetConfig("UserHacks_AlphaHack", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_alpha_check)));
theApp.SetConfig("logz", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_logz_check)));
theApp.SetConfig("UserHacks_DateGL4", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_date_check)));
theApp.SetConfig("UserHacks_MSAA", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_msaa_check)));
theApp.SetConfig("UserHacks_WildHack", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_wild_check)));
theApp.SetConfig("UserHacks_SpriteHack", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_sprite_check)));
theApp.SetConfig("UserHacks", (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hack_enble_check)));
theApp.SetConfig("UserHacks_TCOffset", get_hex_entry(hack_tco_entry));
theApp.SetConfig("override_GL_ARB_clear_texture", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_ct_combo)) - 1);
theApp.SetConfig("override_GL_ARB_bindless_texture", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_bt_combo)) - 1);
theApp.SetConfig("override_GL_ARB_buffer_storage", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_bs_combo)) - 1);
theApp.SetConfig("override_GL_ARB_separate_shader_objects", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_sso_combo)) - 1);
theApp.SetConfig("override_GL_ARB_shader_subroutine", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_ss_combo)) - 1);
theApp.SetConfig("override_geometry_shader", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_gs_combo)) - 1);
theApp.SetConfig("override_GL_ARB_shader_image_load_store", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_ils_combo)) - 1);
theApp.SetConfig("override_GL_ARB_clip_control", (int)gtk_combo_box_get_active(GTK_COMBO_BOX(gl_cc_combo)) - 1);
// NOT supported yet
theApp.SetConfig("msaa", 0);
// Let's just be windowed for the moment.
theApp.SetConfig("windowed", 1);
gtk_widget_destroy (dialog);
return true;
}
gtk_widget_destroy (dialog);
return false;
}
static void
_capture_button_clicked(GtkWidget *widget, gpointer user_data)
{
dt_lib_camera_t *lib=(dt_lib_camera_t *)user_data;
uint32_t delay = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->gui.tb1))==TRUE?(uint32_t)gtk_spin_button_get_value(GTK_SPIN_BUTTON(lib->gui.sb1)):0;
uint32_t count = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->gui.tb2))==TRUE?(uint32_t)gtk_spin_button_get_value(GTK_SPIN_BUTTON(lib->gui.sb2)):1;
uint32_t brackets = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->gui.tb3))==TRUE?(uint32_t)gtk_spin_button_get_value(GTK_SPIN_BUTTON(lib->gui.sb3)):0;
uint32_t steps = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->gui.tb3))==TRUE?(uint32_t)gtk_spin_button_get_value(GTK_SPIN_BUTTON(lib->gui.sb4)):0;
dt_job_t j;
int32_t filmid = dt_view_tethering_get_film_id(darktable.view_manager);
if (filmid)
{
dt_camera_capture_job_init(&j,filmid,delay,count,brackets,steps);
dt_control_add_job(darktable.control, &j);
}
else
g_warning("failed to get filmid from tethering view...");
}
static void
search_results_cb (GPtrArray *results,
GError *error,
gpointer userdata)
{
IdolTrackerWidgetPrivate *priv;
SearchResultsData *srd;
gchar *str;
guint i, next_page, total_pages;
srd = userdata;
priv = srd->widget->priv;
gtk_widget_set_sensitive (priv->search_entry, TRUE);
if (error) {
g_warning ("Error getting the search results for '%s': %s",
srd->search_text,
error->message ? error->message : "No reason");
gtk_label_set_text (GTK_LABEL (priv->status_label), _("Could not connect to Tracker"));
search_results_free (srd);
return;
}
if (!results || results->len < 1) {
gtk_label_set_text (GTK_LABEL (priv->status_label), _("No results"));
search_results_free (srd);
return;
}
for (i = 0; i < results->len; i++) {
GStrv details;
details = g_ptr_array_index (results, i);
search_results_populate (srd->widget, details[0]);
}
next_page = (priv->current_result_page + 1) * IDOL_TRACKER_MAX_RESULTS_SIZE;
total_pages = priv->total_result_count / IDOL_TRACKER_MAX_RESULTS_SIZE + 1;
/* Set the new range on the page selector's adjustment and ensure the current page is correct */
gtk_spin_button_set_range (GTK_SPIN_BUTTON (priv->page_selector), 1, total_pages);
priv->current_result_page = gtk_spin_button_get_value (GTK_SPIN_BUTTON (priv->page_selector)) - 1;
/* Translators:
* This is used to show which items are listed in the list view, for example:
* Showing 10-20 of 128 matches
* This is similar to what web searches use, eg. Google on the top-right of their search results page show:
* Personalized Results 1 - 10 of about 4,130,000 for foobar */
str = g_strdup_printf (ngettext ("Showing %i - %i of %i match", "Showing %i - %i of %i matches", priv->total_result_count),
priv->current_result_page * IDOL_TRACKER_MAX_RESULTS_SIZE,
next_page > priv->total_result_count ? priv->total_result_count : next_page,
priv->total_result_count);
gtk_label_set_text (GTK_LABEL (priv->status_label), str);
g_free (str);
/* Enable or disable the pager buttons */
if (priv->current_result_page < priv->total_result_count / IDOL_TRACKER_MAX_RESULTS_SIZE) {
gtk_widget_set_sensitive (GTK_WIDGET (priv->page_selector), TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (priv->next_button), TRUE);
}
if (priv->current_result_page > 0) {
gtk_widget_set_sensitive (GTK_WIDGET (priv->page_selector), TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (priv->previous_button), TRUE);
}
if (priv->current_result_page >= total_pages - 1) {
gtk_widget_set_sensitive (GTK_WIDGET (priv->next_button), FALSE);
}
g_signal_handlers_unblock_by_func (priv->page_selector, page_selector_value_changed_cb, srd->widget);
search_results_free (srd);
}
static void spin_value_changed_int(GtkSpinButton *button, int *value)
{
*value = (int)gtk_spin_button_get_value(button);
}
static double get_gui_tx_sampling_freq(void)
{
return gtk_spin_button_get_value(GTK_SPIN_BUTTON(tx_widgets[tx_sample_freq].widget));
}
uint8_t DIA_animated(ANIMATED_PARAM *param)
{
uint8_t ret=0;
GtkWidget *dialog;
const char *entries[MAX_VIGNETTE]={"spinbuttonTC0","spinbuttonTC1","spinbuttonTC2",
"spinbuttonTC3","spinbuttonTC4","spinbuttonTC5" };
dialog=create_dialog1();
gtk_register_dialog(dialog);
CHECK_SET(checkbuttonStd,isNTSC);
SPIN_SET(spinbuttonvignetteW,vignetteW);
SPIN_SET(spinbuttonvignetteH,vignetteH);
if(param->backgroundImg)
ENTRY_SET(entryBgd,param->backgroundImg);
for(int i=0;i<MAX_VIGNETTE;i++)
{
gtk_spin_button_set_value(GTK_SPIN_BUTTON(lookup_widget(dialog,entries[i])),
(gfloat)param->timecode[i]) ;
}
ASSOCIATE(button1,LOAD_BGD);
//gtk_widget_show(dialog);
int action;
while(1)
{
action=gtk_dialog_run(GTK_DIALOG(dialog));
if(action==LOAD_BGD)
{
char *nw;
GUI_FileSelRead(_("Select background picture"), &nw);
if(nw)
{
ENTRY_SET(entryBgd,nw);
ADM_dealloc(nw);
}
continue;
}
break;
}
if(action==GTK_RESPONSE_OK)
{
CHECK_GET(checkbuttonStd,isNTSC);
SPIN_GET(spinbuttonvignetteW,vignetteW);
SPIN_GET(spinbuttonvignetteH,vignetteH);
if(param->backgroundImg) ADM_dealloc(param->backgroundImg);
param->backgroundImg=NULL;
ENTRY_GET(entryBgd,param->backgroundImg);
for(int i=0;i<MAX_VIGNETTE;i++)
{
param->timecode[i]=(uint32_t)gtk_spin_button_get_value(GTK_SPIN_BUTTON(lookup_widget(dialog,entries[i]))) ;
}
ret=1;
}
gtk_unregister_dialog(dialog);
gtk_widget_destroy(dialog);
return ret;
}
void bandscopeSmoothingChanged(GtkSpinButton* spinButton,gpointer data) {
bandscopeAverageSmoothing=gtk_spin_button_get_value(spinButton);
}
gint game_buildings_get_num_buildings(GameBuildings * gb, gint type)
{
return gtk_spin_button_get_value(gb->num_buildings[type]);
}
/**
* @brief Bandscope low changed
*
* @param spinButton
* @param data
*/
void bandscopeLowChanged(GtkSpinButton* spinButton,gpointer data) {
bandscopeMIN=gtk_spin_button_get_value(spinButton);
}
void spectrumSmoothingChanged(GtkSpinButton* spinButton,gpointer data) {
spectrumAverageSmoothing=gtk_spin_button_get_value(spinButton);
}
/**
* @brief Waterfall low changed
*
* @param spinButton
* @param data
*/
void waterfallLowChanged(GtkSpinButton* spinButton,gpointer data) {
waterfallLowThreshold=gtk_spin_button_get_value(spinButton);
}
/**
* @brief Spectrum rate changed
*
* @param spinButton
* @param data
*/
void spectrumRateChanged(GtkSpinButton* spinButton,gpointer data) {
setSpectrumUpdateRate(gtk_spin_button_get_value(spinButton));
}
/**
* @brief Spectrum step changed
*
* @param spinButton
* @param data
*/
void spectrumStepChanged(GtkSpinButton* spinButton,gpointer data) {
spectrumSTEP=gtk_spin_button_get_value(spinButton);
}
/* todo: less on this side, like add track */
gchar *a_dialog_waypoint ( GtkWindow *parent, gchar *default_name, VikTrwLayer *vtl, VikWaypoint *wp, VikCoordMode coord_mode, gboolean is_new, gboolean *updated )
{
GtkWidget *dialog = gtk_dialog_new_with_buttons (_("Waypoint Properties"),
parent,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL);
struct LatLon ll;
GtkWidget *latlabel, *lonlabel, *namelabel, *latentry, *lonentry, *altentry, *altlabel, *nameentry=NULL;
GtkWidget *commentlabel, *commententry, *descriptionlabel, *descriptionentry, *imagelabel, *imageentry, *symbollabel, *symbolentry;
GtkWidget *sourcelabel = NULL, *sourceentry = NULL;
GtkWidget *typelabel = NULL, *typeentry = NULL;
GtkWidget *timelabel = NULL;
GtkWidget *timevaluebutton = NULL;
GtkWidget *hasGeotagCB = NULL;
GtkWidget *consistentGeotagCB = NULL;
GtkWidget *direction_sb = NULL;
GtkWidget *direction_hb = NULL;
GtkListStore *store;
gchar *lat, *lon, *alt;
vik_coord_to_latlon ( &(wp->coord), &ll );
lat = g_strdup_printf ( "%f", ll.lat );
lon = g_strdup_printf ( "%f", ll.lon );
vik_units_height_t height_units = a_vik_get_units_height ();
switch (height_units) {
case VIK_UNITS_HEIGHT_METRES:
alt = g_strdup_printf ( "%f", wp->altitude );
break;
case VIK_UNITS_HEIGHT_FEET:
alt = g_strdup_printf ( "%f", VIK_METERS_TO_FEET(wp->altitude) );
break;
default:
alt = g_strdup_printf ( "%f", wp->altitude );
g_critical("Houston, we've had a problem. height=%d", height_units);
}
*updated = FALSE;
namelabel = gtk_label_new (_("Name:"));
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), namelabel, FALSE, FALSE, 0);
// Name is now always changeable
nameentry = gtk_entry_new ();
if ( default_name )
gtk_entry_set_text( GTK_ENTRY(nameentry), default_name );
g_signal_connect_swapped ( nameentry, "activate", G_CALLBACK(a_dialog_response_accept), GTK_DIALOG(dialog) );
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), nameentry, FALSE, FALSE, 0);
latlabel = gtk_label_new (_("Latitude:"));
latentry = gtk_entry_new ();
gtk_entry_set_text ( GTK_ENTRY(latentry), lat );
g_free ( lat );
lonlabel = gtk_label_new (_("Longitude:"));
lonentry = gtk_entry_new ();
gtk_entry_set_text ( GTK_ENTRY(lonentry), lon );
g_free ( lon );
altlabel = gtk_label_new (_("Altitude:"));
altentry = gtk_entry_new ();
gtk_entry_set_text ( GTK_ENTRY(altentry), alt );
g_free ( alt );
if ( wp->comment && !strncmp(wp->comment, "http", 4) )
commentlabel = gtk_link_button_new_with_label (wp->comment, _("Comment:") );
else
commentlabel = gtk_label_new (_("Comment:"));
commententry = gtk_entry_new ();
gchar *cmt = NULL;
// Auto put in some kind of 'name' as a comment if one previously 'goto'ed this exact location
cmt = a_vik_goto_get_search_string_for_this_place(VIK_WINDOW(parent));
if (cmt)
gtk_entry_set_text(GTK_ENTRY(commententry), cmt);
if ( wp->description && !strncmp(wp->description, "http", 4) )
descriptionlabel = gtk_link_button_new_with_label (wp->description, _("Description:") );
else
descriptionlabel = gtk_label_new (_("Description:"));
descriptionentry = gtk_entry_new ();
sourcelabel = gtk_label_new (_("Source:"));
if ( wp->source ) {
sourceentry = gtk_entry_new ();
gtk_entry_set_text(GTK_ENTRY(sourceentry), wp->source);
}
typelabel = gtk_label_new (_("Type:"));
if ( wp->type ) {
typeentry = gtk_entry_new ();
gtk_entry_set_text(GTK_ENTRY(typeentry), wp->type);
}
imagelabel = gtk_label_new (_("Image:"));
imageentry = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_OPEN, VF_FILTER_IMAGE, NULL, NULL);
{
GtkCellRenderer *r;
symbollabel = gtk_label_new (_("Symbol:"));
GtkTreeIter iter;
store = gtk_list_store_new(3, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING);
symbolentry = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(symbolentry), 6);
g_signal_connect(symbolentry, "changed", G_CALLBACK(symbol_entry_changed_cb), store);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, NULL, 1, NULL, 2, _("(none)"), -1);
a_populate_sym_list(store);
r = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (symbolentry), r, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (symbolentry), r, "pixbuf", 1, NULL);
r = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (symbolentry), r, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (symbolentry), r, "text", 2, NULL);
if ( !is_new && wp->symbol ) {
gboolean ok;
gchar *sym;
for (ok = gtk_tree_model_get_iter_first ( GTK_TREE_MODEL(store), &iter ); ok; ok = gtk_tree_model_iter_next ( GTK_TREE_MODEL(store), &iter)) {
gtk_tree_model_get ( GTK_TREE_MODEL(store), &iter, 0, (void *)&sym, -1 );
if (sym && !strcmp(sym, wp->symbol)) {
g_free(sym);
break;
} else {
g_free(sym);
}
}
// Ensure is it a valid symbol in the given symbol set (large vs small)
// Not all symbols are available in both
// The check prevents a Gtk Critical message
if ( iter.stamp )
gtk_combo_box_set_active_iter(GTK_COMBO_BOX(symbolentry), &iter);
}
}
if ( !is_new && wp->comment )
gtk_entry_set_text ( GTK_ENTRY(commententry), wp->comment );
if ( !is_new && wp->description )
gtk_entry_set_text ( GTK_ENTRY(descriptionentry), wp->description );
if ( !edit_wp )
edit_wp = vik_waypoint_new ();
edit_wp = vik_waypoint_copy ( wp );
if ( !is_new && wp->image ) {
vik_file_entry_set_filename ( VIK_FILE_ENTRY(imageentry), wp->image );
#ifdef VIK_CONFIG_GEOTAG
// Geotag Info [readonly]
hasGeotagCB = gtk_check_button_new_with_label ( _("Has Geotag") );
gtk_widget_set_sensitive ( hasGeotagCB, FALSE );
gboolean hasGeotag;
gchar *ignore = a_geotag_get_exif_date_from_file ( wp->image, &hasGeotag );
g_free ( ignore );
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON(hasGeotagCB), hasGeotag );
consistentGeotagCB = gtk_check_button_new_with_label ( _("Consistent Position") );
gtk_widget_set_sensitive ( consistentGeotagCB, FALSE );
if ( hasGeotag ) {
struct LatLon ll = a_geotag_get_position ( wp->image );
VikCoord coord;
vik_coord_load_from_latlon ( &coord, coord_mode, &ll );
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON(consistentGeotagCB), vik_coord_equalish(&coord, &wp->coord) );
}
// ATM the direction value box is always shown, even when there is no information.
// It would be nice to be able to hide it until the 'Add' has been performed,
// however I've not been able to achieve this.
// Thus simply sensistizing it instead.
GtkWidget *direction_label = gtk_label_new ( _("Image Direction:") );
direction_hb = gtk_hbox_new ( FALSE, 0 );
gtk_box_pack_start (GTK_BOX(direction_hb), direction_label, FALSE, FALSE, 0);
direction_sb = gtk_spin_button_new ( (GtkAdjustment*)gtk_adjustment_new (0, 0.0, 359.9, 5.0, 1, 0 ), 1, 1 );
if ( !is_new && !isnan(wp->image_direction) ) {
GtkWidget *direction_ref = gtk_label_new ( NULL );
if ( wp->image_direction_ref == WP_IMAGE_DIRECTION_REF_MAGNETIC )
gtk_label_set_label ( GTK_LABEL(direction_ref), _("Magnetic") );
else
gtk_label_set_label ( GTK_LABEL(direction_ref), _("True") );
gtk_box_pack_start (GTK_BOX(direction_hb), direction_ref, TRUE, FALSE, 0);
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(direction_sb), wp->image_direction );
}
else {
GtkWidget *direction_ref_button = gtk_button_new ();
gtk_button_set_relief ( GTK_BUTTON(direction_ref_button), GTK_RELIEF_NONE );
GtkWidget *img = gtk_image_new_from_stock ( GTK_STOCK_ADD, GTK_ICON_SIZE_MENU );
gtk_button_set_image ( GTK_BUTTON(direction_ref_button), img );
gtk_box_pack_start (GTK_BOX(direction_hb), direction_ref_button, TRUE, FALSE, 0);
gtk_widget_set_sensitive ( direction_sb, FALSE );
direction_signal_id = g_signal_connect ( G_OBJECT(direction_ref_button), "button-release-event", G_CALLBACK(direction_add_click), direction_sb );
}
#endif
}
timelabel = gtk_label_new ( _("Time:") );
timevaluebutton = gtk_button_new();
gtk_button_set_relief ( GTK_BUTTON(timevaluebutton), GTK_RELIEF_NONE );
// TODO: Consider if there should be a remove time button...
if ( !is_new && wp->has_timestamp ) {
update_time ( timevaluebutton, wp );
}
else {
GtkWidget *img = gtk_image_new_from_stock ( GTK_STOCK_ADD, GTK_ICON_SIZE_MENU );
gtk_button_set_image ( GTK_BUTTON(timevaluebutton), img );
// Initially use current time or otherwise whatever the last value used was
if ( edit_wp->timestamp == 0 ) {
time ( &edit_wp->timestamp );
}
}
g_signal_connect ( G_OBJECT(timevaluebutton), "button-release-event", G_CALLBACK(time_edit_click), edit_wp );
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), latlabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), latentry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), lonlabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), lonentry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), timelabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), timevaluebutton, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), altlabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), altentry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), commentlabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), commententry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), descriptionlabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), descriptionentry, FALSE, FALSE, 0);
if ( wp->source ) {
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), sourcelabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), sourceentry, FALSE, FALSE, 0);
}
if ( wp->type ) {
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), typelabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), typeentry, FALSE, FALSE, 0);
}
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), imagelabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), imageentry, FALSE, FALSE, 0);
if ( hasGeotagCB ) {
GtkWidget *hbox = gtk_hbox_new ( FALSE, 0 );
gtk_box_pack_start (GTK_BOX(hbox), hasGeotagCB, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(hbox), consistentGeotagCB, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), hbox, FALSE, FALSE, 0);
}
if ( direction_hb )
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), direction_hb, FALSE, FALSE, 0);
if ( direction_sb )
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), direction_sb, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), symbollabel, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), GTK_WIDGET(symbolentry), FALSE, FALSE, 0);
gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
gtk_widget_show_all ( gtk_dialog_get_content_area(GTK_DIALOG(dialog)) );
if ( !is_new ) {
// Shift left<->right to try not to obscure the waypoint.
trw_layer_dialog_shift ( vtl, GTK_WINDOW(dialog), &(wp->coord), FALSE );
}
while ( gtk_dialog_run ( GTK_DIALOG(dialog) ) == GTK_RESPONSE_ACCEPT )
{
if ( strlen((gchar*)gtk_entry_get_text ( GTK_ENTRY(nameentry) )) == 0 ) /* TODO: other checks (isalpha or whatever ) */
a_dialog_info_msg ( parent, _("Please enter a name for the waypoint.") );
else {
// NB: No check for unique names - this allows generation of same named entries.
gchar *entered_name = g_strdup ( (gchar*)gtk_entry_get_text ( GTK_ENTRY(nameentry) ) );
/* Do It */
ll.lat = convert_dms_to_dec ( gtk_entry_get_text ( GTK_ENTRY(latentry) ) );
ll.lon = convert_dms_to_dec ( gtk_entry_get_text ( GTK_ENTRY(lonentry) ) );
vik_coord_load_from_latlon ( &(wp->coord), coord_mode, &ll );
// Always store in metres
switch (height_units) {
case VIK_UNITS_HEIGHT_METRES:
wp->altitude = atof ( gtk_entry_get_text ( GTK_ENTRY(altentry) ) );
break;
case VIK_UNITS_HEIGHT_FEET:
wp->altitude = VIK_FEET_TO_METERS(atof ( gtk_entry_get_text ( GTK_ENTRY(altentry) ) ));
break;
default:
wp->altitude = atof ( gtk_entry_get_text ( GTK_ENTRY(altentry) ) );
g_critical("Houston, we've had a problem. height=%d", height_units);
}
if ( g_strcmp0 ( wp->comment, gtk_entry_get_text ( GTK_ENTRY(commententry) ) ) )
vik_waypoint_set_comment ( wp, gtk_entry_get_text ( GTK_ENTRY(commententry) ) );
if ( g_strcmp0 ( wp->description, gtk_entry_get_text ( GTK_ENTRY(descriptionentry) ) ) )
vik_waypoint_set_description ( wp, gtk_entry_get_text ( GTK_ENTRY(descriptionentry) ) );
if ( g_strcmp0 ( wp->image, vik_file_entry_get_filename ( VIK_FILE_ENTRY(imageentry) ) ) )
vik_waypoint_set_image ( wp, vik_file_entry_get_filename ( VIK_FILE_ENTRY(imageentry) ) );
if ( sourceentry && g_strcmp0 ( wp->source, gtk_entry_get_text ( GTK_ENTRY(sourceentry) ) ) )
vik_waypoint_set_source ( wp, gtk_entry_get_text ( GTK_ENTRY(sourceentry) ) );
if ( typeentry && g_strcmp0 ( wp->type, gtk_entry_get_text ( GTK_ENTRY(typeentry) ) ) )
vik_waypoint_set_type ( wp, gtk_entry_get_text ( GTK_ENTRY(typeentry) ) );
if ( wp->image && *(wp->image) && (!a_thumbnails_exists(wp->image)) )
a_thumbnails_create ( wp->image );
if ( edit_wp->timestamp ) {
wp->timestamp = edit_wp->timestamp;
wp->has_timestamp = TRUE;
}
if ( direction_sb ) {
if ( gtk_widget_get_sensitive (direction_sb) ) {
wp->image_direction = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(direction_sb) );
if ( wp->image_direction != edit_wp->image_direction )
a_geotag_write_exif_gps ( wp->image, wp->coord, wp->altitude, wp->image_direction, wp->image_direction_ref, TRUE );
}
}
GtkTreeIter iter, first;
gtk_tree_model_get_iter_first ( GTK_TREE_MODEL(store), &first );
if ( !gtk_combo_box_get_active_iter ( GTK_COMBO_BOX(symbolentry), &iter ) || !memcmp(&iter, &first, sizeof(GtkTreeIter)) ) {
vik_waypoint_set_symbol ( wp, NULL );
} else {
gchar *sym;
gtk_tree_model_get ( GTK_TREE_MODEL(store), &iter, 0, (void *)&sym, -1 );
vik_waypoint_set_symbol ( wp, sym );
g_free(sym);
}
gtk_widget_destroy ( dialog );
if ( is_new )
return entered_name;
else {
*updated = TRUE;
// See if name has been changed
if ( g_strcmp0 (default_name, entered_name ) )
return entered_name;
else
return NULL;
}
}
}
gtk_widget_destroy ( dialog );
return NULL;
}
void SpinOptionView::_onAccept() const {
((ZLSpinOptionEntry&)*myOption).onAccept((int)gtk_spin_button_get_value(mySpinBox));
}
void set_distance(GtkSpinButton *button, gpointer data)
{
((NEW_DATA*) data)->newrun->distance =
gtk_spin_button_get_value(GTK_SPIN_BUTTON(button));
}
void CB_SpinButton(GtkSpinButton *spin, gpointer user_data)
{
theApp.SetConfig((char*)user_data, (int)gtk_spin_button_get_value(spin));
}
static void
range_wrapper (GtkSpinButton *spinbutton,
gpointer user_data)
{
G_PASTE_CALLBACK (GPasteRangeCallback) (gtk_spin_button_get_value (spinbutton), data->custom_data);
}
void on_checkbuttonDateEngine_toggled(GtkButton *button, struct _properties *properties)
{
//g_print("on_checkbuttonDateEngine_toggled():\n");
if( properties->GtkInfo.checkbuttonDateEngineIgnore == true )
{
g_print("checkbuttonDateEngineIgnored\n");
properties->GtkInfo.checkbuttonDateEngineIgnore = false;
return;
}
if( option_algorithms[properties->modeltype].supportTime2 == 1 )
{
return;
}
if( option_algorithms[properties->modeltype].perpetual )
{
return;
}
if( properties->decimalorcalendar == DECIMALS )
{
// switch to calendar dated...
//g_print("Calendar Dated\n");
properties->decimalorcalendar = CALENDAR;
if( option_algorithms[properties->modeltype].assetClass )
{
properties->format = CALENDAR_FUTURE;
} else
{
properties->format = CALENDAR_OPTIONS3;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(properties->GtkInfo.radiobutton1),true); // CALENDAR_OPTIONS3
if( option_algorithms[properties->modeltype].supportStrikes )
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(properties->GtkInfo.radiobutton2),false);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(properties->GtkInfo.radiobutton3),false);
}
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(properties->GtkInfo.radiobutton4),false);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(properties->GtkInfo.radiobutton5),false);
gtk_widget_hide(properties->GtkInfo.spinbuttonCustomStrike);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(properties->GtkInfo.checkbuttonSpreads),0);
gtk_widget_hide(properties->GtkInfo.checkbuttonSpreads);
if( option_algorithms[properties->modeltype].supportStrikes && strike_control[properties->strikestoogle].incrementor != 0 )
{
gtk_button_set_label(GTK_BUTTON(properties->GtkInfo.scaleStrikes),"Strike Adjuster");
gtk_widget_show(properties->GtkInfo.scaleStrikes);
} else
{
gtk_widget_hide(properties->GtkInfo.scaleStrikes);
}
gtk_button_set_label(GTK_BUTTON(properties->GtkInfo.scaleMonths),"Month Adjuster");
gtk_widget_show(properties->GtkInfo.scaleMonths);
}
//properties->format = CALENDAR_OPTIONS4;
//properties->format = CALENDAR_OPTIONS5;
//properties->format = CALENDAR_OPTIONS6;
//properties->format = CALENDAR_CUSTOM;
gtk_widget_hide(properties->GtkInfo.checkbuttonRealTime);
gtk_widget_hide(properties->GtkInfo.buttonCalendar);
gtk_widget_hide(properties->GtkInfo.spinbuttonTime);
gtk_widget_hide(properties->GtkInfo.label1);
gtk_widget_hide(properties->GtkInfo.labelDaysToExpr);
gtk_widget_hide(properties->GtkInfo.spinbuttonDaysToExpr);
gtk_widget_hide(properties->GtkInfo.labelTime1);
if( !option_algorithms[properties->modeltype].assetClass )
{
gtk_widget_show(properties->GtkInfo.labelCycle);
gtk_widget_show(properties->GtkInfo.comboboxCycle);
gtk_widget_show(properties->GtkInfo.radiobutton1);
if( option_algorithms[properties->modeltype].supportStrikes )
{
gtk_widget_show(properties->GtkInfo.radiobutton2);
gtk_widget_show(properties->GtkInfo.radiobutton3);
}
gtk_widget_show(properties->GtkInfo.radiobutton4);
gtk_widget_show(properties->GtkInfo.radiobutton5);
gtk_widget_show(properties->GtkInfo.labelDisplayFormats);
}
show_label_expirations(properties);
gtk_widget_show(properties->GtkInfo.scaleMonths);
gtk_widget_show(properties->GtkInfo.buttonProperties);
gtk_widget_show(properties->GtkInfo.checkbuttonSpreads);
} else
{
// switch to decimal dated...
//g_print("Decimal Dated\n");
properties->decimalorcalendar = DECIMALS;
if( option_algorithms[properties->modeltype].assetClass )
{
properties->format = DECIMAL_FUTURE;
} else
{
properties->format = DECIMAL_GREEKS;
if( option_algorithms[properties->modeltype].supportStrikes )
{
gtk_widget_show(properties->GtkInfo.comboboxStrikes);
gtk_widget_show(properties->GtkInfo.scaleStrikes);
gtk_label_set_text(GTK_LABEL(properties->GtkInfo.labelStrikes),"Strikes");
gtk_widget_show(properties->GtkInfo.labelStrikes);
} else
{
gtk_widget_hide(properties->GtkInfo.comboboxStrikes);
gtk_widget_hide(properties->GtkInfo.scaleStrikes);
gtk_widget_hide(properties->GtkInfo.labelStrikes);
}
}
gtk_widget_show(properties->GtkInfo.checkbuttonRealTime);
gtk_widget_show(properties->GtkInfo.buttonCalendar);
gtk_widget_show(properties->GtkInfo.spinbuttonTime);
gtk_widget_show(properties->GtkInfo.label1);
gtk_widget_show(properties->GtkInfo.labelDaysToExpr);
gtk_widget_show(properties->GtkInfo.spinbuttonDaysToExpr);
gtk_widget_show(properties->GtkInfo.labelTime1);
gtk_widget_hide(properties->GtkInfo.labelCycle);
gtk_widget_hide(properties->GtkInfo.comboboxCycle);
gtk_widget_hide(properties->GtkInfo.labelExpirations);
gtk_widget_hide(properties->GtkInfo.scaleMonths);
gtk_widget_hide(properties->GtkInfo.buttonProperties);
gtk_widget_hide(properties->GtkInfo.radiobutton1);
gtk_widget_hide(properties->GtkInfo.radiobutton2);
gtk_widget_hide(properties->GtkInfo.radiobutton3);
gtk_widget_hide(properties->GtkInfo.radiobutton4);
gtk_widget_hide(properties->GtkInfo.radiobutton5);
gtk_widget_hide(properties->GtkInfo.labelDisplayFormats);
gtk_widget_hide(properties->GtkInfo.labelStrikes2);
gtk_widget_hide(properties->GtkInfo.spinbuttonCustomStrike);
gtk_widget_hide(properties->GtkInfo.spinbuttonCustomStrike2);
gtk_widget_hide(properties->GtkInfo.checkbuttonSpreads);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(properties->GtkInfo.checkbuttonSpreads),0);
properties->data.t[0] = gtk_spin_button_get_value(GTK_SPIN_BUTTON(properties->GtkInfo.spinbuttonTime));
if( strike_control[properties->strikestoogle].incrementor == 0 )
{
gtk_widget_show(properties->GtkInfo.spinbuttonCustomStrike2);
gtk_label_set_text(GTK_LABEL(properties->GtkInfo.labelStrikes2),"Strike");
gtk_widget_show(properties->GtkInfo.labelStrikes2);
gtk_widget_hide(properties->GtkInfo.scaleStrikes);
}
else
{
gtk_widget_hide(properties->GtkInfo.spinbuttonCustomStrike2);
gtk_label_set_text(GTK_LABEL(properties->GtkInfo.labelStrikes2),"StrikeLeg2");
gtk_widget_hide(properties->GtkInfo.labelStrikes2);
gtk_widget_show(properties->GtkInfo.scaleStrikes);
}
}
setup_tree_view(properties);
show_title(properties);
}
void MoveZChanged(GtkSpinButton *spinbutton, gpointer data)
{ // Y velocity
float value=gtk_spin_button_get_value(GTK_SPIN_BUTTON(GetWidget("movez")));
if (fabs(chans[chan].vel.z)!=value) chans[chan].vel.z=value;
}
static void control_changed (GtkSpinButton * spin, float * value)
{
pthread_mutex_lock (& mutex);
* value = gtk_spin_button_get_value (spin);
pthread_mutex_unlock (& mutex);
}
static void
page_selector_value_changed_cb (GtkSpinButton *self, IdolTrackerWidget *widget)
{
widget->priv->current_result_page = gtk_spin_button_get_value (self) - 1;
do_search (widget);
}
static void
height_changed (GtkSpinButton *spin, gpointer user_data)
{
int value = gtk_spin_button_get_value(spin);
dt_conf_set_int ("plugins/lighttable/export/height", value);
}
static void prefs_dialog_timeout_changed(GtkSpinButton *button,
PrefsDialog *prefs_dialog) {
gint value;
value = (gint)(gtk_spin_button_get_value(button) * 1000);
g_settings_set_int (prefs_dialog->sensors_applet->settings, TIMEOUT, value);
}
static void
pgd_images_page_selector_value_changed (GtkSpinButton *spinbutton,
PgdImagesDemo *demo)
{
demo->page = (gint)gtk_spin_button_get_value (spinbutton) - 1;
}
void
ags_export_window_export_callback(GtkWidget *toggle_button,
AgsExportWindow *export_window)
{
AgsAudioLoop *audio_loop;
AgsWindow *window;
AgsMachine *machine;
GList *machines_start;
gboolean success;
window = AGS_MAIN(export_window->ags_main)->window;
audio_loop = AGS_AUDIO_LOOP(AGS_MAIN(window->ags_main)->main_loop);
machines_start = NULL;
if(gtk_toggle_button_get_active(toggle_button)){
AgsExportOutput *export_output;
AgsExportThread *export_thread;
GList *machines;
gchar *filename;
gboolean live_performance;
export_thread = audio_loop->export_thread;
filename = gtk_entry_get_text(export_window->filename);
if(filename == NULL ||
strlen(filename) == 0){
return;
}
live_performance = gtk_toggle_button_get_active(export_window->live_export);
machines_start =
machines = gtk_container_get_children(GTK_CONTAINER(window->machines));
success = FALSE;
while(machines != NULL){
machine = AGS_MACHINE(machines->data);
if((AGS_MACHINE_IS_SEQUENCER & (machine->flags)) != 0 ||
(AGS_MACHINE_IS_SYNTHESIZER & (machine->flags)) != 0){
printf("found machine to play!\n\0");
ags_machine_set_run(machine,
TRUE);
success = TRUE;
}
machines = machines->next;
}
/* create start task */
if(success){
guint tic;
gdouble delay;
delay = (1.0 / window->devout->frequency / window->devout->buffer_size) * (60.0 / AGS_DEVOUT_DEFAULT_BPM);
tic = (gtk_spin_button_get_value(export_window->tact) + 1) * delay;
export_output = ags_export_output_new(export_thread,
window->devout,
filename,
tic,
live_performance);
g_signal_connect(export_thread, "stop\0",
G_CALLBACK(ags_export_window_stop_callback), export_window);
/* append AgsStartDevout */
ags_task_thread_append_task(AGS_TASK_THREAD(audio_loop->task_thread),
export_output);
ags_navigation_set_seeking_sensitive(window->navigation,
FALSE);
}
}else{
GList *machines;
machines_start =
machines = gtk_container_get_children(GTK_CONTAINER(window->machines));
while(machines != NULL){
machine = AGS_MACHINE(machines->data);
if((AGS_MACHINE_IS_SEQUENCER & (machine->flags)) !=0 ||
(AGS_MACHINE_IS_SYNTHESIZER & (machine->flags)) != 0){
printf("found machine to stop!\n\0");
ags_machine_set_run(machine,
FALSE);
success = TRUE;
}
machines = machines->next;
}
if(success){
ags_navigation_set_seeking_sensitive(window->navigation,
TRUE);
}
}
g_list_free(machines_start);
}
int
DialogSpinEntry(GtkWidget *parent, const char *title, const char *caption, double min, double max, double inc, double *r, int *x, int *y)
{
GtkWidget *dlg, *spin;
GtkBox *vbox;
int data, n;
gint res_id;
double prec;
dlg = gtk_dialog_new_with_buttons(title,
GTK_WINDOW(parent),
#if GTK_CHECK_VERSION(3, 12, 0) && USE_HEADER_BAR
GTK_DIALOG_USE_HEADER_BAR |
#endif
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_OK"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dlg), GTK_RESPONSE_OK);
gtk_window_set_resizable(GTK_WINDOW(dlg), FALSE);
vbox = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dlg)));
if (caption) {
GtkWidget *label;
label = gtk_label_new(caption);
gtk_box_pack_start(vbox, label, FALSE, FALSE, 5);
}
if (inc == 0)
inc = 1;
spin = gtk_spin_button_new_with_range(min, max, inc);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin), TRUE);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), *r);
gtk_box_pack_start(vbox, spin, FALSE, FALSE, 2);
gtk_entry_set_activates_default(GTK_ENTRY(spin), TRUE);
prec = log10(fabs(inc));
if (prec < 0) {
n = ceil(- prec);
} else {
n = 0;
}
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), n);
set_dialog_position(dlg, x, y);
gtk_widget_show_all(dlg);
res_id = ndialog_run(dlg);
switch (res_id) {
case GTK_RESPONSE_OK:
*r = gtk_spin_button_get_value(GTK_SPIN_BUTTON(spin));
data = IDOK;
break;
default:
data = IDCANCEL;
break;
}
get_dialog_position(dlg, x, y);
gtk_widget_destroy(dlg);
reset_event();
return data;
}
static void zoom_increment_cb(GtkWidget *spin, gpointer data)
{
zoom_increment_c = (gint)(gtk_spin_button_get_value(GTK_SPIN_BUTTON(spin)) * 10.0 + 0.01);
}
static void
change_delay_spinbutton_value_changed_cb (GtkSpinButton *spinbutton,
BrowserData *data)
{
g_settings_set_double (data->settings, PREF_SLIDESHOW_CHANGE_DELAY, gtk_spin_button_get_value (spinbutton));
}
