static void choose_picture(AvatarManipulation *self) { AvatarManipulationPrivate *priv = AVATAR_MANIPULATION_GET_PRIVATE(self); GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN; GtkFileFilter *filter = gtk_file_filter_new (); gint res; auto preview = gtk_image_new(); GtkWidget *ring_main_window = gtk_widget_get_toplevel(GTK_WIDGET(self)); auto dialog = gtk_file_chooser_dialog_new (_("Open Avatar Image"), GTK_WINDOW(ring_main_window), action, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_Open"), GTK_RESPONSE_ACCEPT, NULL); /* add filters */ gtk_file_filter_add_pattern (filter,"*.png"); gtk_file_filter_add_pattern (filter,"*.jpg"); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER(dialog),filter); /* add an image preview inside the file choose */ gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER(dialog), preview); g_signal_connect (GTK_FILE_CHOOSER(dialog), "update-preview", G_CALLBACK (update_preview_cb), preview); /* start the file chooser */ res = gtk_dialog_run (GTK_DIALOG(dialog)); /* blocks until the dialog is closed */ if (res == GTK_RESPONSE_ACCEPT) { if(auto filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (dialog))) { GError* error = nullptr; /* initialising to null avoid trouble... */ auto picture = gdk_pixbuf_new_from_file_at_size (filename, VIDEO_WIDTH, VIDEO_HEIGHT, &error); if (!error) { /* reset crop area */ if (priv->crop_area) gtk_container_remove(GTK_CONTAINER(priv->vbox_crop_area), priv->crop_area); priv->crop_area = cc_crop_area_new(); gtk_widget_show(priv->crop_area); gtk_box_pack_start(GTK_BOX(priv->vbox_crop_area), priv->crop_area, TRUE, TRUE, 0); cc_crop_area_set_picture(CC_CROP_AREA(priv->crop_area), picture); g_object_unref(picture); set_state(self, AVATAR_MANIPULATION_STATE_EDIT); } else { g_warning("(choose_picture) failed to load pixbuf from file: %s", error->message); g_error_free(error); } g_free(filename); } else { g_warning("(choose_picture) filename empty"); } } gtk_widget_destroy(dialog); }
/** * A button hit in the Export Dialog */ static void file_export_response_callback(GtkWidget *fs, gint response, gpointer user_data) { char *filename; Diagram *dia; DiaExportFilter *ef; struct stat statbuf; dia = g_object_get_data (G_OBJECT (fs), "user_data"); g_assert (dia); if (response == GTK_RESPONSE_ACCEPT) { gint index; diagram_update_extents(dia); filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fs)); if (g_stat(filename, &statbuf) == 0) { GtkWidget *dialog = NULL; dialog = gtk_message_dialog_new (GTK_WINDOW(fs), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, _("File already exists")); gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog), _("The file '%s' already exists.\n" "Do you want to overwrite it?"), dia_message_filename(filename)); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES); if (gtk_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_YES) { /* if not overwrite allow to select another filename */ gtk_widget_destroy(dialog); g_free (filename); return; } gtk_widget_destroy(dialog); } index = gtk_combo_box_get_active (GTK_COMBO_BOX(user_data)); if (index >= 0) persistence_set_integer ("export-filter", index); ef = efilter_by_index (index - 1, NULL); if (!ef) ef = filter_guess_export_filter(filename); if (ef) { DiaContext *ctx = dia_context_new (_("Export")); g_object_ref(dia->data); dia_context_set_filename (ctx, filename); ef->export_func(dia->data, ctx, filename, dia->filename, ef->user_data); g_object_unref(dia->data); dia_context_release (ctx); } else message_error(_("Could not determine which export filter\n" "to use to save '%s'"), dia_message_filename(filename)); g_free (filename); } g_object_unref (dia); /* drop our diagram reference */ gtk_widget_destroy(exportdlg); }
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; }
void GtkToolkitFileChooser::OpenDialog(X11Types::Window parent, ToolkitFileChooserListener* result_listener) { gtk_widget_show(m_dialog); XSetTransientForHint(GDK_WINDOW_XDISPLAY(gtk_widget_get_window(m_dialog)), GDK_WINDOW_XID(gtk_widget_get_window(m_dialog)), parent); if (m_action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER) GtkUtils::SetResourceName(m_dialog, "directorychooserdialog"); else GtkUtils::SetResourceName(m_dialog, "filechooserdialog"); int response_id; while(1) { m_open_dialog = true; response_id = gtk_dialog_run(GTK_DIALOG(m_dialog)); m_open_dialog = false; if (response_id == GTK_RESPONSE_ACCEPT) { m_selected_filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(m_dialog)); m_active_directory = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(m_dialog)); if (m_action == GTK_FILE_CHOOSER_ACTION_SAVE) { // BIG FAT TEST for saving. The file selector (or at least some versions of it) // allows users entering an existing directory and accepts this as a valid filename // Do not allow that as we have code that can call OpFile::Delete(TRUE) before saving // the file. See DSK-318398 if (!VerifySaveFiles()) { GtkWidget* dialog = m_dialog; m_dialog = 0; ResetData(); m_dialog = dialog; continue; } } } break; } /* Note that gtk sends GTK_RESPONSE_DELETE_EVENT if the dialog is * closed, including if the user presses the Escape button. */ if (response_id == GTK_RESPONSE_ACCEPT || response_id == GTK_RESPONSE_CANCEL || response_id == GTK_RESPONSE_DELETE_EVENT) { m_can_destroy = false; result_listener->OnChoosingDone(this); m_can_destroy = true; if (m_request_destroy) { delete this; // Calls ResetData() in destructor return; } } ResetData(); GtkUtils::ProcessEvents(); if (response_id == RESPONSE_KILL_DIALOG) delete this; }
/** * Respond to a button press (also destroy) in the save as dialog. */ static void file_save_as_response_callback(GtkWidget *fs, gint response, gpointer user_data) { char *filename; Diagram *dia; struct stat stat_struct; if (response == GTK_RESPONSE_ACCEPT) { dia = g_object_get_data (G_OBJECT(fs), "user_data"); filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fs)); if (!filename) { /* Not getting a filename looks like a contract violation in Gtk+ to me. * Still Dia would be crashing (bug #651949) - instead simply go back to the dialog. */ gtk_window_present (GTK_WINDOW (fs)); return; } if (g_stat(filename, &stat_struct) == 0) { GtkWidget *dialog = NULL; char *utf8filename = NULL; if (!g_utf8_validate(filename, -1, NULL)) { utf8filename = g_filename_to_utf8(filename, -1, NULL, NULL, NULL); if (utf8filename == NULL) { message_warning(_("Some characters in the filename are neither UTF-8\n" "nor your local encoding.\nSome things will break.")); } } if (utf8filename == NULL) utf8filename = g_strdup(filename); dialog = gtk_message_dialog_new (GTK_WINDOW(fs), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, _("File already exists")); gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog), _("The file '%s' already exists.\n" "Do you want to overwrite it?"), utf8filename); g_free(utf8filename); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES); if (gtk_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_YES) { /* don't hide/destroy the dialog, but simply go back to it */ gtk_window_present (GTK_WINDOW (fs)); gtk_widget_destroy(dialog); g_free (filename); return; } gtk_widget_destroy(dialog); } dia->data->is_compressed = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(user_data)); diagram_update_extents(dia); { DiaContext *ctx = dia_context_new (_("Save as")); diagram_set_filename(dia, filename); dia_context_set_filename (ctx, filename); if (diagram_save(dia, filename, ctx)) recent_file_history_add(filename); dia_context_release (ctx); } g_free (filename); } /* if we have our own reference, drop it before destroy */ if ((dia = g_object_get_data (G_OBJECT(fs), "user_data")) != NULL) { g_object_set_data (G_OBJECT(fs), "user_data", NULL); g_object_unref (dia); } /* if we destroy it gtk_dialog_run wont give the response */ if (!g_object_get_data (G_OBJECT(fs), "dont-destroy")) gtk_widget_destroy(GTK_WIDGET(fs)); }
int main (int argc, char *argv[]) { signal_user_data_t *ud; GValue *preset; GError *error = NULL; GOptionContext *context; #ifdef ENABLE_NLS bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); #endif if (!g_thread_supported()) g_thread_init(NULL); context = g_option_context_new ("- Transcode media formats"); g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE); g_option_context_add_group (context, gtk_get_option_group (TRUE)); #if defined(_ENABLE_GST) g_option_context_add_group (context, gst_init_get_option_group ()); #endif g_option_context_parse (context, &argc, &argv, &error); g_option_context_free(context); if (argc > 1 && dvd_device == NULL && argv[1][0] != '-') { dvd_device = argv[1]; } gtk_init (&argc, &argv); gtk_rc_parse_string(hud_rcstyle); g_type_class_unref(g_type_class_ref(GTK_TYPE_BUTTON)); g_object_set(gtk_settings_get_default(), "gtk-button-images", TRUE, NULL); #if !defined(_WIN32) notify_init("HandBrake"); #endif ghb_register_transforms(); ghb_resource_init(); ghb_load_icons(); #if !defined(_WIN32) dbus_g_thread_init(); #endif ghb_udev_init(); ghb_write_pid_file(); ud = g_malloc0(sizeof(signal_user_data_t)); ud->debug = ghb_debug; g_log_set_handler (NULL, G_LOG_LEVEL_DEBUG, debug_log_handler, ud); g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, warn_log_handler, ud); //g_log_set_handler ("Gtk", G_LOG_LEVEL_CRITICAL, warn_log_handler, ud); ud->settings = ghb_settings_new(); ud->builder = create_builder_or_die (BUILDER_NAME); // Enable events that alert us to media change events watch_volumes (ud); //GtkWidget *widget = GHB_WIDGET(ud->builder, "PictureDetelecineCustom"); //gtk_entry_set_inner_border(widget, 2); // Since GtkBuilder no longer assigns object ids to widget names // Assign a few that are necessary for style overrides to work GtkWidget *widget; #if defined(_NO_UPDATE_CHECK) widget = GHB_WIDGET(ud->builder, "check_updates_box"); gtk_widget_hide(widget); #endif widget = GHB_WIDGET(ud->builder, "preview_hud"); gtk_widget_set_name(widget, "preview_hud"); widget = GHB_WIDGET(ud->builder, "preview_window"); gtk_widget_set_name(widget, "preview_window"); // Set up the "hud" control overlay for the preview window GtkWidget *draw, *hud, *blender, *align; align = GHB_WIDGET(ud->builder, "preview_window_alignment"); draw = GHB_WIDGET(ud->builder, "preview_image_align"); hud = GHB_WIDGET(ud->builder, "preview_hud"); // Set up compositing for hud blender = ghb_compositor_new(); gtk_container_add(GTK_CONTAINER(align), blender); ghb_compositor_zlist_insert(GHB_COMPOSITOR(blender), draw, 1, 1); ghb_compositor_zlist_insert(GHB_COMPOSITOR(blender), hud, 2, .85); gtk_widget_show(blender); // Redirect stderr to the activity window ghb_preview_init(ud); IoRedirect(ud); ghb_log( "%s - %s - %s", HB_PROJECT_TITLE, HB_PROJECT_BUILD_TITLE, HB_PROJECT_URL_WEBSITE ); ghb_init_dep_map(); // Need to connect x264_options textview buffer to the changed signal // since it can't be done automatically GtkTextView *textview; GtkTextBuffer *buffer; textview = GTK_TEXT_VIEW(GHB_WIDGET (ud->builder, "x264Option")); buffer = gtk_text_view_get_buffer (textview); g_signal_connect(buffer, "changed", (GCallback)x264_entry_changed_cb, ud); ghb_combo_init(ud); g_debug("ud %p\n", ud); g_debug("ud->builder %p\n", ud->builder); bind_audio_tree_model(ud); bind_subtitle_tree_model(ud); bind_presets_tree_model(ud); bind_queue_tree_model(ud); bind_chapter_tree_model(ud); // Connect up the signals to their callbacks // I wrote my own connector so that I could pass user data // to the callbacks. Builder's standard autoconnect doesn't all this. gtk_builder_connect_signals_full (ud->builder, MyConnect, ud); // Load all internal settings ghb_settings_init(ud); // Load the presets files ghb_presets_load(ud); ghb_prefs_load(ud); ghb_prefs_to_ui(ud); gint logLevel; logLevel = ghb_settings_get_int(ud->settings, "LoggingLevel"); ghb_backend_init(logLevel); if (ghb_settings_get_boolean(ud->settings, "hbfd")) { ghb_hbfd(ud, TRUE); } gchar *source = ghb_settings_get_string(ud->settings, "default_source"); ghb_dvd_set_current(source, ud); g_free(source); // Parsing x264 options "" initializes x264 widgets to proper defaults ghb_x264_parse_options(ud, ""); // Populate the presets tree view ghb_presets_list_init(ud, NULL, 0); // Get the first preset name if (arg_preset != NULL) { preset = ghb_parse_preset_path(arg_preset); if (preset) { ghb_select_preset(ud->builder, preset); ghb_value_free(preset); } } else { ghb_select_default_preset(ud->builder); } // Grey out widgets that are dependent on a disabled feature ghb_check_all_depencencies (ud); if (dvd_device != NULL) { // Source overridden from command line option ghb_settings_set_string(ud->settings, "scan_source", dvd_device); g_idle_add((GSourceFunc)ghb_idle_scan, ud); } // Reload and check status of the last saved queue g_idle_add((GSourceFunc)ghb_reload_queue, ud); // Start timer for monitoring libhb status, 500ms g_timeout_add (500, ghb_timer_cb, (gpointer)ud); // Add dvd devices to File menu ghb_volname_cache_init(); g_thread_create((GThreadFunc)ghb_cache_volnames, ud, FALSE, NULL); #if defined(_USE_APP_IND) GtkUIManager * uim = GTK_UI_MANAGER(GHB_OBJECT(ud->builder, "uimanager1")); GtkMenu *ai_menu = GTK_MENU(gtk_ui_manager_get_widget(uim, "/ui/tray_menu")); ud->ai = app_indicator_new("HandBrake", "hb-icon", APP_INDICATOR_CATEGORY_APPLICATION_STATUS); app_indicator_set_menu( ud->ai, ai_menu ); app_indicator_set_label( ud->ai, "", "99.99%"); if (ghb_settings_get_boolean(ud->settings, "show_status")) { app_indicator_set_status( ud->ai, APP_INDICATOR_STATUS_ACTIVE ); } else { app_indicator_set_status( ud->ai, APP_INDICATOR_STATUS_PASSIVE ); } GtkStatusIcon *si; si = GTK_STATUS_ICON(GHB_OBJECT(ud->builder, "hb_status")); gtk_status_icon_set_visible(si, FALSE ); #else GtkStatusIcon *si; si = GTK_STATUS_ICON(GHB_OBJECT(ud->builder, "hb_status")); gtk_status_icon_set_visible(si, ghb_settings_get_boolean(ud->settings, "show_status")); #if GTK_CHECK_VERSION(2, 16, 0) gtk_status_icon_set_has_tooltip(si, TRUE); g_signal_connect(si, "query-tooltip", status_icon_query_tooltip_cb, ud); #else gtk_status_icon_set_tooltip(si, "HandBrake"); #endif #endif // Ugly hack to keep subtitle table from bouncing around as I change // which set of controls are visible GtkRequisition req; gint width, height; widget = GHB_WIDGET(ud->builder, "SrtCodeset"); gtk_widget_size_request( widget, &req ); height = req.height; widget = GHB_WIDGET(ud->builder, "srt_code_label"); gtk_widget_size_request( widget, &req ); height += req.height; widget = GHB_WIDGET(ud->builder, "subtitle_table"); gtk_widget_set_size_request(widget, -1, height); widget = GHB_WIDGET (ud->builder, "hb_window"); GdkGeometry geo = { -1, -1, 1024, 768, -1, -1, 10, 10, 0, 0, GDK_GRAVITY_NORTH_WEST }; GdkWindowHints geo_mask; geo_mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE | GDK_HINT_BASE_SIZE; gtk_window_set_geometry_hints( GTK_WINDOW(widget), widget, &geo, geo_mask); width = ghb_settings_get_int(ud->settings, "window_width"); height = ghb_settings_get_int(ud->settings, "window_height"); gtk_window_resize(GTK_WINDOW(widget), width, height); gtk_widget_show(widget); /* * Filter objects in GtkBuilder xml * Unfortunately, GtkFilter is poorly supported by GtkBuilder, * so a lot of the setup must happen in code. SourceFilterAll SourceFilterVideo SourceFilterTS SourceFilterMPG SourceFilterEVO SourceFilterVOB SourceFilterMKV SourceFilterMP4 SourceFilterAVI SourceFilterMOV SourceFilterOGG SourceFilterFLV SourceFilterWMV */ // Add filters to source chooser GtkFileFilter *filter; GtkFileChooser *chooser; chooser = GTK_FILE_CHOOSER(GHB_WIDGET(ud->builder, "source_dialog")); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAll")); gtk_file_filter_set_name(filter, "All"); gtk_file_filter_add_pattern(filter, "*"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterVideo")); gtk_file_filter_set_name(filter, "Video"); gtk_file_filter_add_mime_type(filter, "video/*"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterTS")); gtk_file_filter_set_name(filter, "TS"); gtk_file_filter_add_pattern(filter, "*.ts"); gtk_file_filter_add_pattern(filter, "*.TS"); gtk_file_filter_add_pattern(filter, "*.m2ts"); gtk_file_filter_add_pattern(filter, "*.M2TS"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMPG")); gtk_file_filter_set_name(filter, "MPG"); gtk_file_filter_add_pattern(filter, "*.mpg"); gtk_file_filter_add_pattern(filter, "*.MPG"); gtk_file_filter_add_pattern(filter, "*.mepg"); gtk_file_filter_add_pattern(filter, "*.MEPG"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterEVO")); gtk_file_filter_set_name(filter, "EVO"); gtk_file_filter_add_pattern(filter, "*.evo"); gtk_file_filter_add_pattern(filter, "*.EVO"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterVOB")); gtk_file_filter_set_name(filter, "VOB"); gtk_file_filter_add_pattern(filter, "*.vob"); gtk_file_filter_add_pattern(filter, "*.VOB"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMKV")); gtk_file_filter_set_name(filter, "MKV"); gtk_file_filter_add_pattern(filter, "*.mkv"); gtk_file_filter_add_pattern(filter, "*.MKV"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMP4")); gtk_file_filter_set_name(filter, "MP4"); gtk_file_filter_add_pattern(filter, "*.mp4"); gtk_file_filter_add_pattern(filter, "*.MP4"); gtk_file_filter_add_pattern(filter, "*.m4v"); gtk_file_filter_add_pattern(filter, "*.M4V"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMOV")); gtk_file_filter_set_name(filter, "MOV"); gtk_file_filter_add_pattern(filter, "*.mov"); gtk_file_filter_add_pattern(filter, "*.MOV"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAVI")); gtk_file_filter_set_name(filter, "AVI"); gtk_file_filter_add_pattern(filter, "*.avi"); gtk_file_filter_add_pattern(filter, "*.AVI"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterOGG")); gtk_file_filter_set_name(filter, "OGG"); gtk_file_filter_add_pattern(filter, "*.ogg"); gtk_file_filter_add_pattern(filter, "*.OGG"); gtk_file_filter_add_pattern(filter, "*.ogv"); gtk_file_filter_add_pattern(filter, "*.OGV"); gtk_file_filter_add_pattern(filter, "*.ogm"); gtk_file_filter_add_pattern(filter, "*.OGM"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterFLV")); gtk_file_filter_set_name(filter, "FLV"); gtk_file_filter_add_pattern(filter, "*.flv"); gtk_file_filter_add_pattern(filter, "*.FLV"); gtk_file_chooser_add_filter(chooser, filter); filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterWMV")); gtk_file_filter_set_name(filter, "WMV"); gtk_file_filter_add_pattern(filter, "*.wmv"); gtk_file_filter_add_pattern(filter, "*.WMV"); gtk_file_chooser_add_filter(chooser, filter); // Gtk has a really stupid bug. If the file chooser is showing // hidden files AND there is no filter set, it will not select // the filename when gtk_file_chooser_set_filename is called. // So add a completely unnessary filter to prevent this behavior. filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAll")); gtk_file_chooser_set_filter(chooser, filter); PangoFontDescription *font_desc; font_desc = pango_font_description_from_string ("monospace 10"); textview = GTK_TEXT_VIEW(GHB_WIDGET (ud->builder, "activity_view")); gtk_widget_modify_font(GTK_WIDGET(textview), font_desc); pango_font_description_free (font_desc); // Everything should be go-to-go. Lets rock! gtk_main (); gtk_status_icon_set_visible(si, FALSE); ghb_backend_close(); if (ud->queue) ghb_value_free(ud->queue); ghb_value_free(ud->settings); g_io_channel_unref(ud->activity_log); ghb_settings_close(); #if !defined(_WIN32) notify_uninit(); #endif g_free(ud); return 0; }
void sendMail(GtkWidget* widget,struct GUI *gui){ char addr[16]; int sockfd; int n,i; /* Reset Statu Label */ for(i=0;i<8;i++){ gtk_label_set_text(GTK_LABEL(gui->statu[i]),"-"); } /* Get host and port */ gui->host = (char *)gtk_entry_get_text(GTK_ENTRY(gui->iptHost)); gui->port = (char *)gtk_entry_get_text(GTK_ENTRY(gui->iptPort)); /* Get From */ gui->from = (char *)gtk_entry_get_text(GTK_ENTRY(gui->iptFrom)); /* Get To */ for(i=0;i<gui->c_to;i++){ gui->to[i] = (char *)gtk_entry_get_text(GTK_ENTRY(gui->iptTo[i])); } /* Get Cc */ for(i=0;i<gui->c_cc;i++){ gui->cc[i] = (char *)gtk_entry_get_text(GTK_ENTRY(gui->iptCc[i])); } /* Get Bcc */ for(i=0;i<gui->c_bcc;i++){ gui->bcc[i] = (char *)gtk_entry_get_text(GTK_ENTRY(gui->iptBcc[i])); } /* Get Subject */ gui->subject = (char *)gtk_entry_get_text(GTK_ENTRY(gui->iptSubject)); /* Get Mailbody file */ gui->mailbody = (char *)gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(gui->btnOpenmail)); /* Get Attachment files */ for(i=0;i<gui->c_file;i++){ gui->file[i] = (char *)gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(gui->btnOpenfile[i])); } if(strcmp(gui->host,"")==0||strcmp(gui->port,"")==0){ gtk_label_set_text(GTK_LABEL(gui->statu[0]),"X"); gtk_widget_show_all(gui->window); printf("host or port is (are) null string\n"); return; } /* Connect to mail server */ sockfd = connectToHost(gui->host,gui->port,addr); if(sockfd==-1){ /* Connect Fail */ printf("Connect to host %s:%s fail\n",gui->host,gui->port); gtk_label_set_text(GTK_LABEL(gui->statu[0]),"X"); gtk_widget_show_all(gui->window); return; }else{ printf("Connect to host %s(%s):%s\n",gui->host,addr,gui->port); n = HELO(sockfd); if(n==-1){ close(sockfd); printf("Close SimpleMail.\n"); gtk_label_set_text(GTK_LABEL(gui->statu[0]),"X"); gtk_widget_show_all(gui->window); return; } gtk_label_set_text(GTK_LABEL(gui->statu[0]),"O"); gtk_widget_show_all(gui->window); n = MAIL(sockfd,gui->from); if(n==-1){ close(sockfd); printf("Close SimpleMail.\n"); gtk_label_set_text(GTK_LABEL(gui->statu[1]),"X"); gtk_widget_show_all(gui->window); return; } gtk_label_set_text(GTK_LABEL(gui->statu[1]),"O"); gtk_widget_show_all(gui->window); n = RCPT(sockfd,gui->to,gui->c_to,gui->cc,gui->c_cc,gui->bcc,gui->c_bcc); switch(n){ case -1: close(sockfd); printf("Close SimpleMail.\n"); gtk_label_set_text(GTK_LABEL(gui->statu[2]),"X"); gtk_widget_show_all(gui->window); return; case -2: close(sockfd); printf("Close SimpleMail.\n"); gtk_label_set_text(GTK_LABEL(gui->statu[2]),"O"); gtk_label_set_text(GTK_LABEL(gui->statu[3]),"X"); gtk_widget_show_all(gui->window); return; case -3: close(sockfd); printf("Close SimpleMail.\n"); gtk_label_set_text(GTK_LABEL(gui->statu[2]),"O"); gtk_label_set_text(GTK_LABEL(gui->statu[3]),"O"); gtk_label_set_text(GTK_LABEL(gui->statu[4]),"X"); gtk_widget_show_all(gui->window); return; } gtk_label_set_text(GTK_LABEL(gui->statu[2]),"O"); gtk_label_set_text(GTK_LABEL(gui->statu[3]),"O"); gtk_label_set_text(GTK_LABEL(gui->statu[4]),"O"); gtk_widget_show_all(gui->window); n = MAIL_Headr(sockfd,gui->from,gui->to,gui->c_to,gui->cc,gui->c_cc,gui->bcc,gui->c_bcc,gui->subject,gui->c_file); if(n==-1){ close(sockfd); printf("Close SimpleMail.\n"); gtk_label_set_text(GTK_LABEL(gui->statu[5]),"X"); gtk_widget_show_all(gui->window); return; } gtk_label_set_text(GTK_LABEL(gui->statu[5]),"O"); gtk_widget_show_all(gui->window); MAIL_body(sockfd,gui->mailbody,gui->c_file); Attachment(sockfd,gui->file,gui->c_file); gtk_label_set_text(GTK_LABEL(gui->statu[6]),"O"); n = EOM(sockfd,gui->c_file); if(n==-1){ close(sockfd); printf("Close SimpleMail.\n"); gtk_label_set_text(GTK_LABEL(gui->statu[7]),"X"); gtk_widget_show_all(gui->window); return; } gtk_label_set_text(GTK_LABEL(gui->statu[7]),"O"); gtk_widget_show_all(gui->window); n = QUIT(sockfd); if(n==-1){ close(sockfd); printf("Close SimpleMail.\n"); return; } printf("Send mail.\n"); close(sockfd); } }
static size_t write_fru(char *eeprom) { gint result; const char *serial, *file; char *ser_num, *filename; time_t frutime; FILE *fp = NULL; size_t i; time_t tmp; struct tm *tmp2; char buf[256]; int j, n; struct dirent **namelist; GtkListStore *store; n = scandir(FRU_FILES, &namelist, 0, alphasort); /* No fru files, don't bother */ if (n < 0) { printf("didn't find FRU_Files in %s at %s(%s)\n", FRU_FILES, __FILE__, __func__); return 0; } g_object_set(dialogs.serial_num, "secondary_text", eeprom, NULL); filename = g_malloc(PATH_MAX); ser_num = malloc(128); memset(ser_num, 0, 128); fp = fopen(".serialnum", "r"); if (fp) { i = fread(ser_num, 1, 128, fp); if (!ferror(fp) && (i == 128 || feof(fp))) gtk_entry_set_text(GTK_ENTRY(serial_num), (const gchar*)&ser_num[1]); fclose(fp); } store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(fru_file_list))); gtk_list_store_clear(store); for (j = 0; j < n; j++) { if (namelist[j]->d_type == DT_REG && str_endswith(namelist[j]->d_name, ".bin")) gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(fru_file_list), namelist[j]->d_name); free(namelist[j]); } free(namelist); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(fru_file_list), "Other..."); gtk_combo_box_set_active(GTK_COMBO_BOX(fru_file_list), ser_num[0]); free(ser_num); frutime = mins_since_jan_1_1996(); tmp = min2date(frutime); tmp2 = gmtime(&tmp); strftime(buf, sizeof(buf), "%a %b %d %H:%M %Y", tmp2); gtk_entry_set_text(GTK_ENTRY(fru_date), buf); get_serial_and_file: result = gtk_dialog_run(GTK_DIALOG(dialogs.serial_num)); i = 0; switch (result) { case GTK_RESPONSE_OK: serial = gtk_entry_get_text(GTK_ENTRY(serial_num)); if (strlen(serial) == 0) { create_blocking_popup(GTK_MESSAGE_INFO, GTK_BUTTONS_OK, "", "Serial number required"); goto get_serial_and_file; } file = gtk_combo_box_get_active_text(GTK_COMBO_BOX(fru_file_list)); if (strncmp(file, "Other...", 8) != 0) { snprintf(filename, PATH_MAX, FRU_FILES "%s", file); } else { /* manually choose fru file */ GtkWidget *dialog; dialog = gtk_file_chooser_dialog_new("Select FRU file", GTK_WINDOW(dialogs.serial_num), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); } gtk_widget_destroy(dialog); } if (filename) { fflush(NULL); sprintf(buf, "fru-dump -i %s -o %s -s %s -d %d 2>&1", filename, eeprom, serial, (unsigned int)frutime); #if DEBUG printf("%s\n", buf); #else fp = popen(buf, "r"); #endif if (!fp) { printf("can't execute \"%s\"\n", buf); } else { i = 0; while(fgets(buf, sizeof(buf), fp) != NULL){ /* fru-dump not installed */ if (strstr(buf, "not found")) printf("no fru-tools installed\n"); if (strstr(buf, "wrote") && strstr(buf, "bytes to") && strstr(buf, eeprom)) i = 1; } pclose(fp); } fp = fopen(".serialnum", "w"); if (fp) { fprintf(fp, "%c%s", gtk_combo_box_get_active(GTK_COMBO_BOX(fru_file_list)), serial); fclose(fp); } } break; case GTK_RESPONSE_DELETE_EVENT: break; default: printf("unknown response %d in %s\n", result, __func__); break; } gtk_widget_hide(GTK_WIDGET(dialogs.serial_num)); g_free(filename); return i; }
/*! \brief Creates the add image dialog * \par Function Description * This function creates the add image dialog and loads the selected picture. */ void picture_selection_dialog (GschemToplevel *w_current) { TOPLEVEL *toplevel = gschem_toplevel_get_toplevel (w_current); gchar *filename; GdkPixbuf *pixbuf; GError *error = NULL; w_current->pfswindow = gtk_file_chooser_dialog_new (_("Select a picture file..."), GTK_WINDOW(w_current->main_window), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); /* Set the alternative button order (ok, cancel, help) for other systems */ gtk_dialog_set_alternative_button_order(GTK_DIALOG(w_current->pfswindow), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1); if (w_current->pixbuf_filename) gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(w_current->pfswindow), w_current->pixbuf_filename); if (gtk_dialog_run (GTK_DIALOG (w_current->pfswindow)) == GTK_RESPONSE_ACCEPT) { filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w_current->pfswindow)); gtk_widget_destroy(w_current->pfswindow); w_current->pfswindow=NULL; pixbuf = gdk_pixbuf_new_from_file (filename, &error); if (!pixbuf) { GtkWidget *dialog; dialog = gtk_message_dialog_new (GTK_WINDOW (w_current->main_window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, _("Failed to load picture: %s"), error->message); /* Wait for any user response */ gtk_dialog_run (GTK_DIALOG (dialog)); g_error_free (error); gtk_widget_destroy(dialog); } else { #if DEBUG printf("Picture loaded succesfully.\n"); #endif o_invalidate_rubber(w_current); i_update_middle_button(w_current, i_callback_add_picture, _("Picture")); w_current->inside_action = 0; o_picture_set_pixbuf(w_current, pixbuf, filename); gschem_toplevel_page_content_changed (w_current, toplevel->page_current); i_set_state(w_current, DRAWPICTURE); } g_free (filename); } i_update_toolbar(w_current); if (w_current->pfswindow) { gtk_widget_destroy(w_current->pfswindow); w_current->pfswindow=NULL; } }
static void _lib_import_single_image_callback(GtkWidget *widget,gpointer user_data) { GtkWidget *win = dt_ui_main_window(darktable.gui->ui); GtkWidget *filechooser = gtk_file_chooser_dialog_new (_("import image"), GTK_WINDOW (win), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, (char *)NULL); gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), TRUE); char *last_directory = dt_conf_get_string("ui_last/import_last_directory"); if(last_directory != NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (filechooser), last_directory); char *cp, **extensions, ext[1024]; GtkFileFilter *filter; filter = GTK_FILE_FILTER(gtk_file_filter_new()); extensions = g_strsplit(dt_supported_extensions, ",", 100); for(char **i=extensions; *i!=NULL; i++) { snprintf(ext, 1024, "*.%s", *i); gtk_file_filter_add_pattern(filter, ext); gtk_file_filter_add_pattern(filter, cp=g_ascii_strup(ext, -1)); g_free(cp); } g_strfreev(extensions); gtk_file_filter_set_name(filter, _("supported images")); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter); filter = GTK_FILE_FILTER(gtk_file_filter_new()); gtk_file_filter_add_pattern(filter, "*"); gtk_file_filter_set_name(filter, _("all files")); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter); GtkWidget *preview = gtk_image_new(); gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(filechooser), preview); g_signal_connect(filechooser, "update-preview", G_CALLBACK (_lib_import_update_preview), preview); dt_lib_import_metadata_t metadata; gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filechooser), _lib_import_get_extra_widget(&metadata, FALSE)); if (gtk_dialog_run (GTK_DIALOG (filechooser)) == GTK_RESPONSE_ACCEPT) { dt_conf_set_string("ui_last/import_last_directory", gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (filechooser))); _lib_import_evaluate_extra_widget(&metadata, FALSE); char *filename = NULL; dt_film_t film; GSList *list = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (filechooser)); GSList *it = list; int id = 0; int filmid = 0; /* reset filter to display all images, otherwise view may remain empty */ dt_view_filter_reset_to_show_all(darktable.view_manager); while(it) { filename = (char *)it->data; gchar *directory = g_path_get_dirname((const gchar *)filename); filmid = dt_film_new(&film, directory); id = dt_image_import(filmid, filename, TRUE); if(!id) dt_control_log(_("error loading file `%s'"), filename); g_free (filename); g_free (directory); it = g_slist_next(it); } if(id) { dt_film_open(filmid); // make sure buffers are loaded (load full for testing) dt_mipmap_buffer_t buf; dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, id, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING); if(!buf.buf) { dt_control_log(_("file has unknown format!")); } else { dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf); DT_CTL_SET_GLOBAL(lib_image_mouse_over_id, id); dt_ctl_switch_mode_to(DT_DEVELOP); } } } gtk_widget_destroy(metadata.frame); gtk_widget_destroy (filechooser); gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui)); }
static void _lib_import_folder_callback(GtkWidget *widget,gpointer user_data) { GtkWidget *win = dt_ui_main_window(darktable.gui->ui); GtkWidget *filechooser = gtk_file_chooser_dialog_new (_("import film"), GTK_WINDOW (win), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, (char *)NULL); gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), TRUE); char *last_directory = dt_conf_get_string("ui_last/import_last_directory"); if(last_directory != NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (filechooser), last_directory); dt_lib_import_metadata_t metadata; gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filechooser), _lib_import_get_extra_widget(&metadata, TRUE)); // run the dialog if (gtk_dialog_run (GTK_DIALOG (filechooser)) == GTK_RESPONSE_ACCEPT) { dt_conf_set_string("ui_last/import_last_directory", gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (filechooser))); _lib_import_evaluate_extra_widget(&metadata, TRUE); char *filename = NULL, *first_filename = NULL; GSList *list = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (filechooser)); GSList *it = list; /* reset filter to display all images, otherwise view may remain empty */ dt_view_filter_reset_to_show_all(darktable.view_manager); /* for each selected folder add import job */ while(it) { filename = (char *)it->data; dt_film_import(filename); if (!first_filename) { first_filename = g_strdup(filename); if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (metadata.recursive))) first_filename = dt_util_dstrcat(first_filename, "%%"); } g_free (filename); it = g_slist_next(it); } /* update collection to view import */ if (first_filename) { dt_conf_set_int("plugins/lighttable/collect/num_rules", 1); dt_conf_set_int("plugins/lighttable/collect/item0", 0); dt_conf_set_string("plugins/lighttable/collect/string0",first_filename); dt_collection_update_query(darktable.collection); g_free(first_filename); } g_slist_free (list); } gtk_widget_destroy(metadata.frame); gtk_widget_destroy (filechooser); gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui)); }
bool show(Display* parent) override { static std::string s_lastUsedDir; if (s_lastUsedDir.empty()) s_lastUsedDir = g_get_user_special_dir(G_USER_DIRECTORY_DESKTOP); const char* okLabel; GtkFileChooserAction action; switch (m_type) { case Type::OpenFile: case Type::OpenFiles: action = GTK_FILE_CHOOSER_ACTION_OPEN; okLabel = "_Open"; break; case Type::OpenFolder: action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER; okLabel = "_Open Folder"; break; case Type::SaveFile: action = GTK_FILE_CHOOSER_ACTION_SAVE; okLabel = "_Save"; break; } // GtkWindow* gtkParent = nullptr; GtkWidget* dialog = gtk_file_chooser_dialog_new( m_title.c_str(), nullptr, action, "_Cancel", GTK_RESPONSE_CANCEL, okLabel, GTK_RESPONSE_ACCEPT, nullptr); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); GtkFileChooser* chooser = GTK_FILE_CHOOSER(dialog); m_chooser = chooser; if (m_type == Type::SaveFile) gtk_file_chooser_set_do_overwrite_confirmation(chooser, TRUE); else if (m_type == Type::OpenFiles) gtk_file_chooser_set_select_multiple(chooser, true); if (m_type != Type::OpenFolder) { setupFilters(base::get_file_extension(m_filename)); setupPreview(); } if (m_initialDir.empty()) gtk_file_chooser_set_current_folder(chooser, s_lastUsedDir.c_str()); else gtk_file_chooser_set_current_folder(chooser, m_initialDir.c_str()); if (!m_filename.empty()) { std::string fn = m_filename; // Add default extension if (m_type == Type::SaveFile && base::get_file_extension(fn).empty()) { fn.push_back('.'); fn += m_defExtension; } gtk_file_chooser_set_current_name(chooser, fn.c_str()); } // Setup the "parent" display as the parent of the dialog (we've // to convert a X11 Window into a GdkWindow to do this). GdkWindow* gdkParentWindow = nullptr; if (parent) { GdkWindow* gdkWindow = gtk_widget_get_root_window(dialog); gdkParentWindow = gdk_x11_window_foreign_new_for_display( gdk_window_get_display(gdkWindow), (::Window)parent->nativeHandle()); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); gdk_window_set_transient_for(gdkWindow, gdkParentWindow); } else { gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER); } // Show the dialog gint res = gtk_dialog_run(GTK_DIALOG(dialog)); if (res == GTK_RESPONSE_ACCEPT) { s_lastUsedDir = gtk_file_chooser_get_current_folder(chooser); m_filename = gtk_file_chooser_get_filename(chooser); if (m_type == Type::OpenFiles) { GSList* list = gtk_file_chooser_get_filenames(chooser); g_slist_foreach( list, [](void* fn, void* userdata){ auto self = (FileDialogGTK*)userdata; self->m_filenames.push_back((char*)fn); g_free(fn); }, this); g_slist_free(list); } } gtk_widget_destroy(dialog); if (gdkParentWindow) g_object_unref(gdkParentWindow); // Pump gtk+ events to finally hide the dialog from the screen while (gtk_events_pending()) gtk_main_iteration(); return (res == GTK_RESPONSE_ACCEPT); }
void ags_machine_open_extended_response_callback(GtkWidget *widget, gint response, AgsMachine *machine) { GtkFileChooserDialog *file_chooser; AgsFileSelection *file_selection; GtkCheckButton *overwrite; GtkCheckButton *create; GSList *filenames; gchar *current_folder; GError *error; file_chooser = (GtkFileChooserDialog *) gtk_widget_get_toplevel(widget); if(response == GTK_RESPONSE_ACCEPT){ filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(file_chooser)); overwrite = g_object_get_data((GObject *) widget, "overwrite\0"); create = g_object_get_data((GObject *) widget, "create\0"); current_folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(file_chooser)); //TODO:JK: you need to check against recently used //TODO:JK: add more file types to AgsFileSelection /* check for supported packed audio files */ file_selection = (AgsFileSelection *) gtk_file_chooser_get_extra_widget(GTK_FILE_CHOOSER(file_chooser)); if(file_selection != NULL && g_strcmp0(file_selection->directory, current_folder)){ gtk_widget_destroy(GTK_WIDGET(file_selection)); file_selection = NULL; } if(file_selection == NULL || (AGS_FILE_SELECTION_COMPLETED & (file_selection->flags)) == 0){ if((AGS_MACHINE_ACCEPT_SOUNDFONT2 & (machine->file_input_flags)) != 0){ GDir *current_directory; GList *new_entry, *old_entry; GSList *slist; gchar *current_filename; slist = filenames; new_entry = NULL; while(slist != NULL){ if(g_str_has_suffix(slist->data, ".sf2\0")){ AgsFileSelectionEntry *entry; entry = ags_file_selection_entry_alloc(); entry->filename = slist->data; new_entry = g_list_prepend(new_entry, entry); } slist = slist->next; } old_entry = NULL; if(file_selection == NULL){ if(new_entry != NULL){ file_selection = ags_file_selection_new(); gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(file_chooser), GTK_WIDGET(file_selection)); ags_file_selection_set_entry(file_selection, new_entry); ags_connectable_connect(AGS_CONNECTABLE(file_selection)); gtk_widget_show_all(GTK_WIDGET(file_selection)); return; } }else if(AGS_IS_FILE_SELECTION(file_selection)){ GList *really_new_entry; GList *list; old_entry = file_selection->entry; list = new_entry; really_new_entry = NULL; /* check against existing entries */ if(new_entry != NULL){ while(list != NULL){ if(g_list_find(old_entry, list->data) == NULL){ really_new_entry = g_list_prepend(really_new_entry, list->data); }else{ free(list->data); } list = list->next; } g_list_free(new_entry); } ags_file_selection_set_entry(file_selection, really_new_entry); /* adding lost files */ //TODO:JK: figure out if you need to copy the GSList of filenames gtk_file_chooser_select_all(GTK_FILE_CHOOSER(file_chooser)); current_directory = g_dir_open(current_folder, 0, &error); while((current_filename = (gchar *) g_dir_read_name(current_directory)) != NULL){ if(!g_strcmp0(".\0", current_filename) || !g_strcmp0("..\0", current_filename)) continue; if(!ags_file_selection_contains_file(file_selection, current_filename) && g_slist_find(filenames, current_filename) == NULL){ gtk_file_chooser_unselect_filename(GTK_FILE_CHOOSER(file_chooser), current_filename); } } g_dir_close(current_directory); return; } } } //TODO:JK: fix GSList filenames memory leak ags_machine_open_files(machine, filenames, overwrite->toggle_button.active, create->toggle_button.active); } }
static void save_dialog_response_cb (GtkDialog * dialog, gint response_id, GtrWindow * window) { GError *error = NULL; GtrPo *po; GtrTab *tab; gchar *filename; GFile *location; GtrStatusbar *status; tab = GTR_TAB (g_object_get_data (G_OBJECT (dialog), GTR_TAB_SAVE_AS)); g_return_if_fail (GTK_IS_FILE_CHOOSER (dialog)); po = gtr_tab_get_po (tab); if (response_id != GTK_RESPONSE_ACCEPT) { gtk_widget_destroy (GTK_WIDGET (dialog)); return; } filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); g_return_if_fail (filename != NULL); location = g_file_new_for_path (filename); g_free (filename); gtk_widget_destroy (GTK_WIDGET (dialog)); if (po != NULL) { gtr_po_set_location (po, location); g_object_unref (location); gtr_po_save_file (po, &error); if (error) { GtkWidget *dialog; dialog = gtk_message_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, "%s", error->message); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); g_clear_error (&error); return; } /* We have to change the state of the tab */ gtr_po_set_state (po, GTR_PO_STATE_SAVED); /* Flash a message */ status = GTR_STATUSBAR (gtr_window_get_statusbar (window)); gtr_statusbar_flash_message (status, 0, _("File saved.")); } g_object_unref (location); }
static void impl_constructed (GObject *object) { RBImportDialog *dialog; RhythmDBQuery *query; GtkBuilder *builder; GSettings *settings; char **locations; RB_CHAIN_GOBJECT_METHOD (rb_import_dialog_parent_class, constructed, object); dialog = RB_IMPORT_DIALOG (object); g_object_get (dialog->priv->shell, "db", &dialog->priv->db, "shell-player", &dialog->priv->shell_player, NULL); /* create entry types */ dialog->priv->entry_type = g_object_new (rb_import_dialog_entry_type_get_type (), "db", dialog->priv->db, "name", "import-dialog", NULL); dialog->priv->ignore_type = g_object_new (rb_import_dialog_ignore_type_get_type (), "db", dialog->priv->db, "name", "import-dialog-ignore", NULL); rhythmdb_register_entry_type (dialog->priv->db, dialog->priv->entry_type); rhythmdb_register_entry_type (dialog->priv->db, dialog->priv->ignore_type); builder = rb_builder_load ("import-dialog.ui", NULL); dialog->priv->import_button = GTK_WIDGET (gtk_builder_get_object (builder, "import-button")); g_signal_connect_object (dialog->priv->import_button, "clicked", G_CALLBACK (import_clicked_cb), dialog, 0); gtk_widget_set_sensitive (dialog->priv->import_button, FALSE); dialog->priv->copy_check = GTK_WIDGET (gtk_builder_get_object (builder, "copy-check")); g_signal_connect (gtk_builder_get_object (builder, "close-button"), "clicked", G_CALLBACK (close_clicked_cb), dialog); dialog->priv->file_chooser = GTK_WIDGET (gtk_builder_get_object (builder, "file-chooser-button")); /* select the first library location, since the default may be * the user's home dir or / or something that will take forever to scan. */ settings = g_settings_new ("org.gnome.rhythmbox.rhythmdb"); locations = g_settings_get_strv (settings, "locations"); if (locations[0] != NULL) { dialog->priv->current_uri = g_strdup (locations[0]); } else { dialog->priv->current_uri = g_filename_to_uri (rb_music_dir (), NULL, NULL); } gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (dialog->priv->file_chooser), dialog->priv->current_uri); g_strfreev (locations); g_object_unref (settings); g_signal_connect_object (dialog->priv->file_chooser, "selection-changed", G_CALLBACK (current_folder_changed_cb), dialog, 0); /* not sure why we have to set this, it should be the default */ gtk_widget_set_vexpand (gtk_widget_get_parent (dialog->priv->file_chooser), FALSE); dialog->priv->info_bar_container = GTK_WIDGET (gtk_builder_get_object (builder, "info-bar-container")); /* set up entry view */ dialog->priv->entry_view = rb_entry_view_new (dialog->priv->db, G_OBJECT (dialog->priv->shell_player), TRUE, FALSE); g_signal_connect (dialog->priv->entry_view, "entry-activated", G_CALLBACK (entry_activated_cb), dialog); g_signal_connect (dialog->priv->entry_view, "selection-changed", G_CALLBACK (selection_changed_cb), dialog); rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_TRACK_NUMBER, FALSE); rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_TITLE, TRUE); rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_GENRE, FALSE); rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_ARTIST, FALSE); rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_ALBUM, FALSE); rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_YEAR, FALSE); rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_DURATION, FALSE); rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_QUALITY, FALSE); rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_PLAY_COUNT, FALSE); rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_BPM, FALSE); rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_COMMENT, FALSE); rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_LOCATION, FALSE); settings = g_settings_new ("org.gnome.rhythmbox.sources"); g_settings_bind (settings, "visible-columns", dialog->priv->entry_view, "visible-columns", G_SETTINGS_BIND_DEFAULT); g_object_unref (settings); g_signal_connect (dialog->priv->entry_view, "notify::sort-order", G_CALLBACK (sort_changed_cb), dialog); rb_entry_view_set_sorting_order (dialog->priv->entry_view, "Album", GTK_SORT_ASCENDING); gtk_container_add (GTK_CONTAINER (gtk_builder_get_object (builder, "entry-view-container")), GTK_WIDGET (dialog->priv->entry_view)); dialog->priv->query_model = rhythmdb_query_model_new_empty (dialog->priv->db); rb_entry_view_set_model (dialog->priv->entry_view, dialog->priv->query_model); query = rhythmdb_query_parse (dialog->priv->db, RHYTHMDB_QUERY_PROP_EQUALS, RHYTHMDB_PROP_TYPE, dialog->priv->entry_type, RHYTHMDB_QUERY_END); rhythmdb_do_full_query_async_parsed (dialog->priv->db, RHYTHMDB_QUERY_RESULTS (dialog->priv->query_model), query); rhythmdb_query_free (query); g_signal_connect (dialog->priv->query_model, "post-entry-delete", G_CALLBACK (entry_deleted_cb), dialog); g_signal_connect (dialog->priv->query_model, "row-inserted", G_CALLBACK (entry_inserted_cb), dialog); gtk_container_add (GTK_CONTAINER (dialog), GTK_WIDGET (gtk_builder_get_object (builder, "import-dialog"))); gtk_widget_show_all (GTK_WIDGET (dialog)); g_object_unref (builder); }
/*! \brief Create dialog to exchange picture objects * \par Function Description * This function opens a file chooser and replaces all pictures of the selections * with the new picture. * * \todo Maybe merge this dialog function with picture_selection_dialog() */ void picture_change_filename_dialog (GschemToplevel *w_current) { TOPLEVEL *toplevel = gschem_toplevel_get_toplevel (w_current); gchar *filename; gboolean result; GError *error = NULL; w_current->pfswindow = gtk_file_chooser_dialog_new (_("Select a picture file..."), GTK_WINDOW(w_current->main_window), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); /* Set the alternative button order (ok, cancel, help) for other systems */ gtk_dialog_set_alternative_button_order(GTK_DIALOG(w_current->pfswindow), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1); if (w_current->pixbuf_filename) gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(w_current->pfswindow), w_current->pixbuf_filename); if (gtk_dialog_run (GTK_DIALOG (w_current->pfswindow)) == GTK_RESPONSE_ACCEPT) { filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w_current->pfswindow)); gtk_widget_destroy(w_current->pfswindow); w_current->pfswindow=NULL; /* Actually update the pictures */ result = o_picture_exchange (w_current, filename, &error); if (!result) { GtkWidget *dialog; dialog = gtk_message_dialog_new (GTK_WINDOW (w_current->main_window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, _("Failed to replace pictures: %s"), error->message); /* Wait for any user response */ gtk_dialog_run (GTK_DIALOG (dialog)); g_error_free (error); gtk_widget_destroy(dialog); } else { gschem_toplevel_page_content_changed (w_current, toplevel->page_current); } g_free (filename); } i_update_toolbar(w_current); if (w_current->pfswindow) { gtk_widget_destroy(w_current->pfswindow); w_current->pfswindow=NULL; } }
void gtkutil_file_req (const char *title, void *callback, void *userdata, char *filter, char *extensions, int flags) { struct file_req *freq; GtkWidget *dialog; GtkFileFilter *filefilter; extern char *get_xdir_fs (void); char *token; char *tokenbuffer; #ifdef WIN32 if (!(flags & FRF_WRITE)) { freq = malloc (sizeof (struct file_req)); freq->th = thread_new (); freq->flags = 0; freq->multiple = (flags & FRF_MULTIPLE); freq->callback = callback; freq->userdata = userdata; freq->title = g_locale_from_utf8 (title, -1, 0, 0, 0); if (!filter) { freq->filter = "All files\0*.*\0" "Executables\0*.exe\0" "ZIP files\0*.zip\0\0"; } else { freq->filter = filter; } thread_start (freq->th, win32_thread, freq); fe_input_add (freq->th->pipe_fd[0], FIA_FD|FIA_READ, win32_read_thread, freq); return; } else { freq = malloc (sizeof (struct file_req)); freq->th = thread_new (); freq->flags = 0; freq->multiple = (flags & FRF_MULTIPLE); freq->callback = callback; freq->userdata = userdata; freq->title = g_locale_from_utf8 (title, -1, 0, 0, 0); if (!filter) { freq->filter = "All files\0*.*\0\0"; } else { freq->filter = filter; } thread_start (freq->th, win32_thread2, freq); fe_input_add (freq->th->pipe_fd[0], FIA_FD|FIA_READ, win32_read_thread, freq); return; } #endif if (flags & FRF_WRITE) { dialog = gtk_file_chooser_dialog_new (title, NULL, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); if (filter && filter[0]) /* filter becomes initial name when saving */ { char temp[1024]; path_part (filter, temp, sizeof (temp)); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), temp); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), file_part (filter)); } if (!(flags & FRF_NOASKOVERWRITE)) gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); } else dialog = gtk_file_chooser_dialog_new (title, NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); if (flags & FRF_MULTIPLE) gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE); if (last_dir[0]) gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), last_dir); if (flags & FRF_ADDFOLDER) gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog), get_xdir_fs (), NULL); if (flags & FRF_CHOOSEFOLDER) { gtk_file_chooser_set_action (GTK_FILE_CHOOSER (dialog), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), filter); } else { if (filter && (flags & FRF_FILTERISINITIAL)) gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), filter); } if (flags & FRF_EXTENSIONS && extensions != NULL) { filefilter = gtk_file_filter_new (); tokenbuffer = g_strdup (extensions); token = strtok (tokenbuffer, ";"); while (token != NULL) { gtk_file_filter_add_pattern (filefilter, token); token = strtok (NULL, ";"); } g_free (tokenbuffer); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filefilter); } freq = malloc (sizeof (struct file_req)); freq->dialog = dialog; freq->flags = flags; freq->callback = callback; freq->userdata = userdata; g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (gtkutil_file_req_response), freq); g_signal_connect (G_OBJECT (dialog), "destroy", G_CALLBACK (gtkutil_file_req_destroy), (gpointer) freq); gtk_widget_show (dialog); }
GtkWidget* gtr_torrent_options_dialog_new (GtkWindow * parent, TrCore * core, tr_ctor * ctor) { const char * str; GtkWidget * w; GtkWidget * d; GtkGrid * grid; int row; GtkWidget * l; GtkWidget * source_chooser; struct OpenData * data; bool flag; GSList * list; GSList * walk; /* make the dialog */ d = gtk_dialog_new_with_buttons (_("Torrent Options"), parent, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_ACCEPT); gtk_dialog_set_alternative_button_order (GTK_DIALOG (d), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1); if (tr_ctorGetDownloadDir (ctor, TR_FORCE, &str)) g_assert_not_reached (); g_assert (str); data = g_new0 (struct OpenData, 1); data->core = core; data->ctor = ctor; data->filename = g_strdup (tr_ctorGetSourceFile (ctor)); data->downloadDir = g_strdup (str); data->file_list = gtr_file_list_new (core, 0); str = _("Mo_ve .torrent file to the trash"); data->trash_check = gtk_check_button_new_with_mnemonic (str); str = _("_Start when added"); data->run_check = gtk_check_button_new_with_mnemonic (str); w = data->priority_combo = gtr_priority_combo_new (); gtr_priority_combo_set_value (GTK_COMBO_BOX (w), TR_PRI_NORMAL); g_signal_connect (G_OBJECT (d), "response", G_CALLBACK (addResponseCB), data); row = 0; grid = GTK_GRID (gtk_grid_new ()); gtk_container_set_border_width (GTK_CONTAINER (grid), GUI_PAD_BIG); gtk_grid_set_row_spacing (grid, GUI_PAD); gtk_grid_set_column_spacing (grid, GUI_PAD_BIG); /* "torrent file" row */ l = gtk_label_new_with_mnemonic (_("_Torrent file:")); gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f); gtk_grid_attach (grid, l, 0, row, 1, 1); w = gtk_file_chooser_button_new (_("Select Source File"), GTK_FILE_CHOOSER_ACTION_OPEN); source_chooser = w; gtk_widget_set_hexpand (w, TRUE); gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1); gtk_label_set_mnemonic_widget (GTK_LABEL (l), w); addTorrentFilters (GTK_FILE_CHOOSER (w)); g_signal_connect (w, "selection-changed", G_CALLBACK (sourceChanged), data); /* "destination folder" row */ row++; l = gtk_label_new_with_mnemonic (_("_Destination folder:")); gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f); gtk_grid_attach (grid, l, 0, row, 1, 1); w = gtk_file_chooser_button_new (_("Select Destination Folder"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); if (!gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (w), data->downloadDir)) g_warning ("couldn't select '%s'", data->downloadDir); list = get_recent_destinations (); for (walk = list; walk; walk = walk->next) gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (w), walk->data, NULL); g_slist_free (list); gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1); gtk_label_set_mnemonic_widget (GTK_LABEL (l), w); g_signal_connect (w, "selection-changed", G_CALLBACK (downloadDirChanged), data); row++; l = data->freespace_label = gtr_freespace_label_new (core, data->downloadDir); gtk_widget_set_margin_bottom (l, GUI_PAD_BIG); gtk_misc_set_alignment (GTK_MISC (l), 1.0f, 0.5f); gtk_grid_attach (grid, l, 0, row, 2, 1); /* file list row */ row++; w = data->file_list; gtk_widget_set_vexpand (w, TRUE); gtk_widget_set_size_request (w, 466u, 300u); gtk_grid_attach (grid, w, 0, row, 2, 1); /* torrent priority row */ row++; l = gtk_label_new_with_mnemonic (_("Torrent _priority:")); gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f); gtk_grid_attach (grid, l, 0, row, 1, 1); w = data->priority_combo; gtk_label_set_mnemonic_widget (GTK_LABEL (l), w); gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1); /* torrent priority row */ row++; w = data->run_check; if (tr_ctorGetPaused (ctor, TR_FORCE, &flag)) g_assert_not_reached (); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), !flag); gtk_grid_attach (grid, w, 0, row, 2, 1); /* "trash .torrent file" row */ row++; w = data->trash_check; if (tr_ctorGetDeleteSource (ctor, &flag)) g_assert_not_reached (); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), flag); gtk_grid_attach (grid, w, 0, row, 2, 1); /* trigger sourceChanged, either directly or indirectly, * so that it creates the tor/gtor objects */ w = source_chooser; if (data->filename) gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (w), data->filename); else sourceChanged (GTK_FILE_CHOOSER_BUTTON (w), data); gtr_dialog_set_content (GTK_DIALOG (d), GTK_WIDGET (grid)); w = gtk_dialog_get_widget_for_response (GTK_DIALOG (d), GTK_RESPONSE_ACCEPT); gtk_widget_grab_focus (w); return d; }
static void save_avatar_menu_activate_cb (GtkWidget *widget, EmpathyContactWidget *information) { GtkWidget *dialog; EmpathyAvatar *avatar; gchar *ext = NULL, *filename; dialog = gtk_file_chooser_dialog_new (_("Save Avatar"), NULL, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); /* look for the avatar extension */ avatar = empathy_contact_get_avatar (information->contact); if (avatar->format != NULL) { gchar **splitted; splitted = g_strsplit (avatar->format, "/", 2); if (splitted[0] != NULL && splitted[1] != NULL) ext = g_strdup (splitted[1]); g_strfreev (splitted); } else { /* Avatar was loaded from the cache so was converted to PNG */ ext = g_strdup ("png"); } if (ext != NULL) { gchar *id; id = tp_escape_as_identifier (empathy_contact_get_id ( information->contact)); filename = g_strdup_printf ("%s.%s", id, ext); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), filename); g_free (id); g_free (ext); g_free (filename); } if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { GError *error = NULL; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); if (!empathy_avatar_save_to_file (avatar, filename, &error)) { /* Save error */ GtkWidget *error_dialog; error_dialog = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, _("Unable to save avatar")); gtk_message_dialog_format_secondary_text ( GTK_MESSAGE_DIALOG (error_dialog), "%s", error->message); g_signal_connect (error_dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); gtk_window_present (GTK_WINDOW (error_dialog)); g_clear_error (&error); } g_free (filename); } gtk_widget_destroy (dialog); }
static void avatar_chooser_clicked_cb (GtkWidget *button, EmpathyAvatarChooser *chooser) { GtkFileChooser *chooser_dialog; GtkWidget *image; gchar *saved_dir = NULL; const gchar *default_dir = DEFAULT_DIR; const gchar *pics_dir; GtkFileFilter *filter; EmpathyAvatarChooserPriv *priv = GET_PRIV (chooser); if (priv->chooser_dialog) { gtk_window_present (GTK_WINDOW (priv->chooser_dialog)); return; } priv->chooser_dialog = GTK_FILE_CHOOSER ( gtk_file_chooser_dialog_new (_("Select Your Avatar Image"), empathy_get_toplevel_window (GTK_WIDGET (chooser)), GTK_FILE_CHOOSER_ACTION_OPEN, _("No Image"), GTK_RESPONSE_NO, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL)); chooser_dialog = priv->chooser_dialog; gtk_window_set_destroy_with_parent (GTK_WINDOW (chooser_dialog), TRUE); /* Get special dirs */ empathy_conf_get_string (empathy_conf_get (), EMPATHY_PREFS_UI_AVATAR_DIRECTORY, &saved_dir); if (saved_dir && !g_file_test (saved_dir, G_FILE_TEST_IS_DIR)) { g_free (saved_dir); saved_dir = NULL; } if (!g_file_test (default_dir, G_FILE_TEST_IS_DIR)) { default_dir = NULL; } pics_dir = g_get_user_special_dir (G_USER_DIRECTORY_PICTURES); if (pics_dir && !g_file_test (pics_dir, G_FILE_TEST_IS_DIR)) { pics_dir = NULL; } /* Set current dir to the last one or to DEFAULT_DIR or to home */ if (saved_dir) { gtk_file_chooser_set_current_folder (chooser_dialog, saved_dir); } else if (pics_dir) { gtk_file_chooser_set_current_folder (chooser_dialog, pics_dir); } else if (default_dir) { gtk_file_chooser_set_current_folder (chooser_dialog, default_dir); } else { gtk_file_chooser_set_current_folder (chooser_dialog, g_get_home_dir ()); } /* Add shortcuts to special dirs */ if (saved_dir) { gtk_file_chooser_add_shortcut_folder (chooser_dialog, saved_dir, NULL); } else if (pics_dir) { gtk_file_chooser_add_shortcut_folder (chooser_dialog, pics_dir, NULL); } if (default_dir) { gtk_file_chooser_add_shortcut_folder (chooser_dialog, default_dir, NULL); } /* Setup preview image */ image = gtk_image_new (); gtk_file_chooser_set_preview_widget (chooser_dialog, image); gtk_widget_set_size_request (image, AVATAR_SIZE_SAVE, AVATAR_SIZE_SAVE); gtk_widget_show (image); gtk_file_chooser_set_use_preview_label (chooser_dialog, FALSE); g_signal_connect (chooser_dialog, "update-preview", G_CALLBACK (avatar_chooser_update_preview_cb), chooser); /* Setup filers */ filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Images")); gtk_file_filter_add_pixbuf_formats (filter); gtk_file_chooser_add_filter (chooser_dialog, filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("All Files")); gtk_file_filter_add_pattern (filter, "*"); gtk_file_chooser_add_filter (chooser_dialog, filter); /* Setup response */ gtk_dialog_set_default_response (GTK_DIALOG (chooser_dialog), GTK_RESPONSE_OK); g_signal_connect (chooser_dialog, "response", G_CALLBACK (avatar_chooser_response_cb), chooser); gtk_widget_show (GTK_WIDGET (chooser_dialog)); g_free (saved_dir); }
void GtkToolkitFileChooser::ShowHiddenFiles(bool show_hidden) { gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(m_dialog), show_hidden); }
int main(int argc, char* argv[]) { regex_t fregex[2]; gtk_init(&argc,&argv); // check the correct BASS was loaded if (HIWORD(BASS_GetVersion())!=BASSVERSION) { Error("An incorrect version of BASS was loaded"); return 0; } // Initialize the output device with 3D support if (!BASS_Init(-1,44100,BASS_DEVICE_3D,NULL,NULL)) { Error("Can't initialize device"); return 0; } { BASS_INFO i; BASS_GetInfo(&i); if (i.speakers>2) { GtkWidget *dialog=gtk_message_dialog_new(NULL,0, GTK_MESSAGE_QUESTION,GTK_BUTTONS_YES_NO,"Multiple speakers were detected. Would you like to use them?"); if (gtk_dialog_run(GTK_DIALOG(dialog))==GTK_RESPONSE_NO) BASS_SetConfig(BASS_CONFIG_3DALGORITHM,BASS_3DALG_OFF); gtk_widget_destroy(dialog); } } // Use meters as distance unit, real world rolloff, real doppler effect BASS_Set3DFactors(1,1,1); // initialize GUI glade=glade_xml_new(GLADE_PATH"3dtest.glade",NULL,NULL); if (!glade) return 0; win=GetWidget("window1"); if (!win) return 0; glade_xml_signal_autoconnect(glade); g_signal_connect(gtk_tree_view_get_selection(GTK_TREE_VIEW(GetWidget("channels"))),"changed",G_CALLBACK(ListSelectionChange),NULL); { // setup list GtkTreeView *list=GTK_TREE_VIEW(GetWidget("channels")); GtkTreeViewColumn *col=gtk_tree_view_column_new(); gtk_tree_view_append_column(list,col); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col,renderer,TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", 0); GtkListStore *liststore=gtk_list_store_new(1,G_TYPE_STRING); gtk_tree_view_set_model(list,GTK_TREE_MODEL(liststore)); g_object_unref(liststore); } { // initialize file selector GtkFileFilter *filter; filesel=gtk_file_chooser_dialog_new("Open File",GTK_WINDOW(win),GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL,GTK_RESPONSE_CANCEL,GTK_STOCK_OPEN,GTK_RESPONSE_ACCEPT,NULL); filter=gtk_file_filter_new(); gtk_file_filter_set_name(filter,"Streamable files (wav/aif/mp3/mp2/mp1/ogg)"); regcomp(&fregex[0],"\\.(mp[1-3]|ogg|wav|aif)$",REG_ICASE|REG_NOSUB|REG_EXTENDED); gtk_file_filter_add_custom(filter,GTK_FILE_FILTER_FILENAME,FileExtensionFilter,&fregex[0],NULL); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filesel),filter); filter=gtk_file_filter_new(); gtk_file_filter_set_name(filter,"MOD music files (mo3/xm/mod/s3m/it/mtm/umx)"); regcomp(&fregex[1],"\\.(mo3|xm|mod|s3m|it|umx)$",REG_ICASE|REG_NOSUB|REG_EXTENDED); gtk_file_filter_add_custom(filter,GTK_FILE_FILTER_FILENAME,FileExtensionFilter,&fregex[1],NULL); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filesel),filter); filter=gtk_file_filter_new(); gtk_file_filter_set_name(filter,"All files"); gtk_file_filter_add_pattern(filter,"*"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filesel),filter); } g_timeout_add(TIMERPERIOD,Update,NULL); UpdateButtons(); gtk_main(); gtk_widget_destroy(filesel); regfree(&fregex[0]); regfree(&fregex[1]); BASS_Free(); // close output return 0; }
/** * Handle menu click File/Open * * This is either with or without diagram */ void file_open_callback(GtkAction *action) { if (!opendlg) { DDisplay *ddisp; Diagram *dia = NULL; GtkWindow *parent_window; gchar *filename = NULL; /* FIXME: we should not use ddisp_active but instead get the current diagram * from caller. Thus we could offer the option to "load into" if invoked by * <Display/File/Open. It wouldn't make any sense if invoked by * <Toolbox>/File/Open ... */ ddisp = ddisplay_active(); if (ddisp) { dia = ddisp->diagram; parent_window = GTK_WINDOW(ddisp->shell); } else { parent_window = GTK_WINDOW(interface_get_toolbox_shell()); } persistence_register_integer ("import-filter", 0); opendlg = gtk_file_chooser_dialog_new(_("Open Diagram"), parent_window, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); /* is activating gvfs really that easy - at least it works for samba shares*/ gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER(opendlg), FALSE); gtk_dialog_set_default_response(GTK_DIALOG(opendlg), GTK_RESPONSE_ACCEPT); gtk_window_set_role(GTK_WINDOW(opendlg), "open_diagram"); if (dia && dia->filename) filename = g_filename_from_utf8(dia->filename, -1, NULL, NULL, NULL); if (filename != NULL) { char* fnabs = dia_get_absolute_filename (filename); if (fnabs) gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(opendlg), fnabs); g_free(fnabs); g_free(filename); } g_signal_connect(G_OBJECT(opendlg), "destroy", G_CALLBACK(gtk_widget_destroyed), &opendlg); } else { gtk_widget_set_sensitive(opendlg, TRUE); #if GTK_CHECK_VERSION(2,20,0) if (gtk_widget_get_visible(opendlg)) #else if (GTK_WIDGET_VISIBLE(opendlg)) #endif return; } if (!gtk_file_chooser_get_extra_widget(GTK_FILE_CHOOSER(opendlg))) { GtkWidget *hbox, *label, *omenu, *options; GtkFileFilter* filter; options = gtk_frame_new(_("Open Options")); gtk_frame_set_shadow_type(GTK_FRAME(options), GTK_SHADOW_ETCHED_IN); hbox = gtk_hbox_new(FALSE, 1); gtk_container_set_border_width(GTK_CONTAINER(hbox), 5); gtk_container_add(GTK_CONTAINER(options), hbox); gtk_widget_show(hbox); label = gtk_label_new (_("Determine file type:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); omenu = create_open_menu(); gtk_box_pack_start(GTK_BOX(hbox), omenu, TRUE, TRUE, 0); gtk_widget_show(omenu); gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(opendlg), options); gtk_widget_show(options); g_signal_connect(G_OBJECT(opendlg), "response", G_CALLBACK(file_open_response_callback), omenu); /* set up the gtk file (name) filters */ /* 0 = by extension */ gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (opendlg), build_gtk_file_filter_from_index (0)); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("All Files")); gtk_file_filter_add_pattern (filter, "*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (opendlg), filter); gtk_combo_box_set_active (GTK_COMBO_BOX (omenu), persistence_get_integer ("import-filter")); } gtk_widget_show(opendlg); }
nsresult HeaderSniffer::PerformSave (const GulCString &defaultFileName) { EmbedPersistFlags flags; PRBool askDownloadDest; flags = galeon_embed_persist_get_flags (mEmbedPersist); askDownloadDest = (flags & EMBED_PERSIST_ASK_DESTINATION) || eel_gconf_get_boolean (CONF_DOWNLOADING_ASK_DIR); /* Validate the file name to ensure legality. */ char *default_name = g_strdup (defaultFileName.get()); default_name = g_strdelimit (default_name, ":/", ' '); char *filename; filename = gnome_vfs_unescape_string (default_name, NULL); if (!g_utf8_validate (filename, -1, NULL)) { g_free (filename); filename = g_strdup (default_name); } g_free (default_name); GtkWidget *parent; parent = galeon_embed_persist_get_fc_parent (mEmbedPersist); if (!askDownloadDest) { nsCOMPtr<nsILocalFile> destFile; nsresult rv = BuildDownloadPath (filename, parent, getter_AddRefs (destFile)); if (NS_SUCCEEDED (rv)) { g_free (filename); return InitiateDownload (destFile); } } GulFileChooser *dialog; const char *title; title = galeon_embed_persist_get_fc_title (mEmbedPersist); dialog = gul_file_chooser_new (title ? title: _("Save"), GTK_WIDGET (parent), GTK_FILE_CHOOSER_ACTION_SAVE, CONF_STATE_LAST_DOWNLOAD_DIR); if (mDocument && (flags & EMBED_PERSIST_SAVE_CONTENT)) { /* Reset the flags to turn off content, the user toggles * if they want to turn it on */ GtkWidget *toggle; int f = flags & ~EMBED_PERSIST_SAVE_CONTENT; flags = (EmbedPersistFlags) f; galeon_embed_persist_set_flags (mEmbedPersist, flags); toggle = gtk_check_button_new_with_mnemonic (_("Save _with content")); gtk_widget_show (toggle); gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog), toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (content_toggled_cb), mEmbedPersist); } gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), filename); NS_ADDREF (this); /* add a ref to this object, so it doesn't dissappear */ g_signal_connect (dialog, "response", G_CALLBACK (filechooser_response_cb), this); guint32 user_time; g_object_get (mEmbedPersist, "user_time", &user_time, NULL); if (!user_time) { g_warning ("No user time specified in embed persist for file save" ); } gul_x11_window_update_user_time (GTK_WIDGET (dialog), user_time); gtk_widget_show (GTK_WIDGET (dialog)); g_free (filename); return NS_OK; }
static GtkWidget * file_save_as_dialog_prepare (Diagram *dia, DDisplay *ddisp) { gchar *filename = NULL; if (!savedlg) { GtkWidget *compressbutton; savedlg = gtk_file_chooser_dialog_new(_("Save Diagram"), GTK_WINDOW(ddisp->shell), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); /* vfs saving is as easy - if you see 'bad file descriptor' there is * something wrong with the permissions of the share ;) */ gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER(savedlg), FALSE); gtk_dialog_set_default_response(GTK_DIALOG(savedlg), GTK_RESPONSE_ACCEPT); gtk_window_set_role(GTK_WINDOW(savedlg), "save_diagram"); /* Need better way to make it a reasonable size. Isn't there some*/ /* standard look for them (or is that just Gnome?)*/ compressbutton = gtk_check_button_new_with_label(_("Compress diagram files")); gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(savedlg), compressbutton); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compressbutton), dia->data->is_compressed); g_signal_connect(G_OBJECT(compressbutton), "toggled", G_CALLBACK(toggle_compress_callback), NULL); gtk_widget_show(compressbutton); gtk_widget_set_tooltip_text (compressbutton, _("Compression reduces file size to less than 1/10th " "size and speeds up loading and saving. Some text " "programs cannot manipulate compressed files.")); g_signal_connect (GTK_FILE_CHOOSER(savedlg), "response", G_CALLBACK(file_save_as_response_callback), compressbutton); g_signal_connect(G_OBJECT(savedlg), "destroy", G_CALLBACK(gtk_widget_destroyed), &savedlg); } else { GtkWidget *compressbutton = gtk_file_chooser_get_extra_widget(GTK_FILE_CHOOSER(savedlg)); gtk_widget_set_sensitive(savedlg, TRUE); g_signal_handlers_block_by_func(G_OBJECT(compressbutton), toggle_compress_callback, NULL); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compressbutton), dia->data->is_compressed); g_signal_handlers_unblock_by_func(G_OBJECT(compressbutton), toggle_compress_callback, NULL); if (g_object_get_data (G_OBJECT (savedlg), "user_data") != NULL) g_object_unref (g_object_get_data (G_OBJECT (savedlg), "user_data")); #if GTK_CHECK_VERSION(2,20,0) if (gtk_widget_get_visible(savedlg)) { #else if (GTK_WIDGET_VISIBLE(savedlg)) { #endif /* keep a refernce to the diagram */ g_object_ref(dia); g_object_set_data (G_OBJECT (savedlg), "user_data", dia); gtk_window_present (GTK_WINDOW(savedlg)); return savedlg; } } if (dia && dia->filename) filename = g_filename_from_utf8(dia->filename, -1, NULL, NULL, NULL); if (filename != NULL) { char* fnabs = dia_get_absolute_filename (filename); if (fnabs) { gchar *base = g_path_get_basename(dia->filename); gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(savedlg), fnabs); /* FileChooser api insist on exiting files for set_filename */ /* ... and does not use filename encoding on this one. */ gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(savedlg), base); g_free(base); } g_free(fnabs); g_free(filename); } g_object_ref(dia); g_object_set_data (G_OBJECT (savedlg), "user_data", dia); return savedlg; } /** * Respond to the File/Save menu entry. * * Delegates to Save As if there is no filename set yet. */ void file_save_callback(GtkAction *action) { Diagram *diagram; diagram = ddisplay_active_diagram(); if (!diagram) return; if (diagram->unsaved) { file_save_as_callback(action); } else { gchar *filename = g_filename_from_utf8(diagram->filename, -1, NULL, NULL, NULL); DiaContext *ctx = dia_context_new (_("Save")); diagram_update_extents(diagram); if (diagram_save(diagram, filename, ctx)) recent_file_history_add(filename); g_free (filename); dia_context_release (ctx); } }
/*! \brief General purpose handler to hide/show Sensor calibrate window \param widget is a pointer to the widget clicked \param data is unused \returns TRUE */ G_MODULE_EXPORT gboolean show_ms2_therm_table_generator_window(GtkWidget *widget, gpointer data) { static GtkWidget *window = NULL; static GtkWidget *chooser = NULL; GtkWidget *item = NULL; GladeXML *main_xml = NULL; GladeXML *xml = NULL; Firmware_Details *firmware = NULL; ENTER(); firmware = (Firmware_Details *)DATA_GET(global_data,"firmware"); main_xml = (GladeXML *)DATA_GET(global_data,"main_xml"); g_return_val_if_fail(firmware,FALSE); g_return_val_if_fail(main_xml,FALSE); if (DATA_GET(global_data,"leaving")) { EXIT(); return TRUE; } if (!GTK_IS_WIDGET(window)) { xml = glade_xml_new(main_xml->filename,"table_generator_window",NULL); window = glade_xml_get_widget(xml,"table_generator_window"); glade_xml_signal_autoconnect(xml); /* Default to params not a file */ chooser = glade_xml_get_widget(xml,"import_filechooser_button"); register_widget_f("import_filechooser_button",chooser); item = glade_xml_get_widget(xml,"use_params_rbutton"); register_widget_f("use_params_rbutton",item); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(item),TRUE); g_signal_emit_by_name(item,"toggled",NULL); item = glade_xml_get_widget(xml,"sensor_combo"); gtk_combo_box_set_active(GTK_COMBO_BOX(item),0); register_widget_f("thermister_sensor_combo",item); item = glade_xml_get_widget(xml,"temp_label"); register_widget_f("temp_label",item); if (firmware->capabilities & PIS) gtk_widget_destroy(glade_xml_get_widget(xml,"bias_resistor_table")); else { item = glade_xml_get_widget(xml,"bias_entry"); register_widget_f("bias_entry",item); OBJ_SET_FULL(item,"raw_lower",g_strdup("0"),g_free); OBJ_SET_FULL(item,"raw_upper",g_strdup("100000"),g_free); OBJ_SET(item,"precision",GINT_TO_POINTER(1)); } item = glade_xml_get_widget(xml,"temp1_entry"); register_widget_f("temp1_entry",item); OBJ_SET_FULL(item,"raw_lower",g_strdup("-40"),g_free); OBJ_SET_FULL(item,"raw_upper",g_strdup("300"),g_free); OBJ_SET(item,"precision",GINT_TO_POINTER(1)); item = glade_xml_get_widget(xml,"temp2_entry"); register_widget_f("temp2_entry",item); OBJ_SET_FULL(item,"raw_lower",g_strdup("-40"),g_free); OBJ_SET_FULL(item,"raw_upper",g_strdup("300"),g_free); OBJ_SET(item,"precision",GINT_TO_POINTER(1)); item = glade_xml_get_widget(xml,"temp3_entry"); register_widget_f("temp3_entry",item); OBJ_SET_FULL(item,"raw_lower",g_strdup("-40"),g_free); OBJ_SET_FULL(item,"raw_upper",g_strdup("300"),g_free); OBJ_SET(item,"precision",GINT_TO_POINTER(1)); item = glade_xml_get_widget(xml,"resistance1_entry"); register_widget_f("resistance1_entry",item); OBJ_SET_FULL(item,"raw_lower",g_strdup("0"),g_free); OBJ_SET_FULL(item,"raw_upper",g_strdup("500000"),g_free); OBJ_SET(item,"precision",GINT_TO_POINTER(1)); item = glade_xml_get_widget(xml,"resistance2_entry"); register_widget_f("resistance2_entry",item); OBJ_SET_FULL(item,"raw_lower",g_strdup("0"),g_free); OBJ_SET_FULL(item,"raw_upper",g_strdup("500000"),g_free); OBJ_SET(item,"precision",GINT_TO_POINTER(1)); item = glade_xml_get_widget(xml,"resistance3_entry"); register_widget_f("resistance3_entry",item); OBJ_SET_FULL(item,"raw_lower",g_strdup("0"),g_free); OBJ_SET_FULL(item,"raw_upper",g_strdup("500000"),g_free); OBJ_SET(item,"precision",GINT_TO_POINTER(1)); item = glade_xml_get_widget(xml,"celsius_rbutton"); OBJ_SET_FULL(item,"temp_label",g_strdup("Temperature(\302\260 C)"),g_free); register_widget_f("thermister_celsius_rbutton",item); item = glade_xml_get_widget(xml,"fahrenheit_rbutton"); OBJ_SET_FULL(item,"temp_label",g_strdup("Temperature(\302\260 F)"),g_free); register_widget_f("thermister_fahrenheit_rbutton",item); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(item),TRUE); g_signal_emit_by_name(item,"toggled",NULL); item = glade_xml_get_widget(xml,"kelvin_rbutton"); OBJ_SET_FULL(item,"temp_label",g_strdup("Temperature(\302\260 K)"),g_free); register_widget_f("thermister_kelvin_rbutton",item); gtk_window_set_transient_for(GTK_WINDOW(window),GTK_WINDOW(lookup_widget_f("main_window"))); gtk_widget_show(GTK_WIDGET(window)); EXIT(); return TRUE; } #if GTK_MINOR_VERSION >= 18 if (gtk_widget_get_visible(GTK_WIDGET(window))) #else if (GTK_WIDGET_VISIBLE(GTK_WIDGET(window))) #endif gtk_widget_hide(GTK_WIDGET(window)); else { gtk_file_chooser_unselect_all(GTK_FILE_CHOOSER(chooser)); gtk_widget_show(GTK_WIDGET(window)); } EXIT(); return TRUE; }
/** * React to <Display>/File/Export */ void file_export_callback(GtkAction *action) { DDisplay *ddisp; Diagram *dia; gchar *filename = NULL; ddisp = ddisplay_active(); if (!ddisp) return; dia = ddisp->diagram; if (!confirm_export_size (dia, GTK_WINDOW(ddisp->shell), CONFIRM_MEMORY|CONFIRM_PAGES)) return; if (!exportdlg) { persistence_register_integer ("export-filter", 0); exportdlg = gtk_file_chooser_dialog_new(_("Export Diagram"), GTK_WINDOW(ddisp->shell), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); /* export via vfs gives: Permission denied - but only if you do not * have write permissions ;) */ gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER(exportdlg), FALSE); gtk_dialog_set_default_response(GTK_DIALOG(exportdlg), GTK_RESPONSE_ACCEPT); gtk_window_set_role(GTK_WINDOW(exportdlg), "export_diagram"); g_signal_connect(G_OBJECT(exportdlg), "destroy", G_CALLBACK(gtk_widget_destroyed), &exportdlg); } if (!gtk_file_chooser_get_extra_widget(GTK_FILE_CHOOSER(exportdlg))) { GtkWidget *hbox, *label, *omenu, *options; GtkFileFilter* filter; options = gtk_frame_new(_("Export Options")); gtk_frame_set_shadow_type(GTK_FRAME(options), GTK_SHADOW_ETCHED_IN); hbox = gtk_hbox_new(FALSE, 1); gtk_container_set_border_width(GTK_CONTAINER(hbox), 5); gtk_container_add(GTK_CONTAINER(options), hbox); gtk_widget_show(hbox); label = gtk_label_new (_("Determine file type:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); omenu = create_export_menu(); gtk_box_pack_start(GTK_BOX(hbox), omenu, TRUE, TRUE, 0); gtk_widget_show(omenu); g_object_set_data(G_OBJECT(exportdlg), "export-menu", omenu); gtk_widget_show(options); gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(exportdlg), options); /* set up file filters */ filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("All Files")); gtk_file_filter_add_pattern (filter, "*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (exportdlg), filter); /* match the other selections extension */ filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Supported Formats")); gtk_file_filter_add_custom (filter, GTK_FILE_FILTER_FILENAME, matching_extensions_filter, filter_guess_export_filter, NULL); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (exportdlg), filter); gtk_combo_box_set_active (GTK_COMBO_BOX (omenu), persistence_get_integer ("export-filter")); g_signal_connect(GTK_FILE_CHOOSER(exportdlg), "response", G_CALLBACK(file_export_response_callback), omenu); } if (g_object_get_data (G_OBJECT(exportdlg), "user_data")) g_object_unref (g_object_get_data (G_OBJECT(exportdlg), "user_data")); g_object_ref(dia); g_object_set_data (G_OBJECT (exportdlg), "user_data", dia); gtk_widget_set_sensitive(exportdlg, TRUE); if (dia && dia->filename) filename = g_filename_from_utf8(dia->filename, -1, NULL, NULL, NULL); if (filename != NULL) { char* fnabs = dia_get_absolute_filename (filename); if (fnabs) { char *folder = g_path_get_dirname (fnabs); char *basename = g_path_get_basename (fnabs); /* can't use gtk_file_chooser_set_filename for various reasons, see e.g. bug #305850 */ gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(exportdlg), folder); export_adapt_extension (basename, persistence_get_integer ("export-filter") - 1); g_free (folder); g_free (basename); } g_free(fnabs); g_free(filename); } gtk_widget_show(exportdlg); }
FileDialog::FileDialog(wxWindow *parent, const wxString& message, const wxString& defaultDir, const wxString& defaultFileName, const wxString& wildCard, long style, const wxPoint& pos) : wxGenericFileDialog(parent, message, defaultDir, defaultFileName, wildCard, style, pos, #if wxCHECK_VERSION(2,8,0) wxDefaultSize, wxFileDialogNameStr, #endif true ) { #if defined(__WXGTK24__) && (!defined(__WXGPE__)) if (!gtk_check_version(2,4,0)) { wxASSERT_MSG( !( (style & wxFD_SAVE) && (style & wxFD_MULTIPLE) ), wxT("FileDialog - wxFD_MULTIPLE used on a save dialog" ) ); m_needParent = false; m_destroyed_by_delete = false; if (!PreCreation(parent, pos, wxDefaultSize) || !CreateBase(parent, wxID_ANY, pos, wxDefaultSize, style, wxDefaultValidator, wxT("filedialog"))) { wxFAIL_MSG( wxT("FileDialog creation failed") ); return; } GtkFileChooserAction gtk_action; GtkWindow* gtk_parent = NULL; if (parent) gtk_parent = GTK_WINDOW( gtk_widget_get_toplevel(parent->m_widget) ); const gchar* ok_btn_stock; if ( style & wxFD_SAVE ) { gtk_action = GTK_FILE_CHOOSER_ACTION_SAVE; ok_btn_stock = GTK_STOCK_SAVE; } else { gtk_action = GTK_FILE_CHOOSER_ACTION_OPEN; ok_btn_stock = GTK_STOCK_OPEN; } m_widget = gtk_file_chooser_dialog_new( wxGTK_CONV(m_message), gtk_parent, gtk_action, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, ok_btn_stock, GTK_RESPONSE_ACCEPT, NULL); // Allow pressing "Enter" key for default action gtk_dialog_set_default_response(GTK_DIALOG(m_widget), GTK_RESPONSE_ACCEPT); if ( style & wxFD_MULTIPLE ) gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(m_widget), true); // local-only property could be set to false to allow non-local files to be loaded. // In that case get/set_uri(s) should be used instead of get/set_filename(s) everywhere // and the GtkFileChooserDialog should probably also be created with a backend, // e.g "gnome-vfs", "default", ... (gtk_file_chooser_dialog_new_with_backend). // Currently local-only is kept as the default - true: // gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(m_widget), true); g_signal_connect(G_OBJECT(m_widget), "response", GTK_SIGNAL_FUNC(gtk_filedialog_response_callback), (gpointer)this); g_signal_connect(G_OBJECT(m_widget), "show", GTK_SIGNAL_FUNC(gtk_filedialog_show_callback), (gpointer)this); SetWildcard(wildCard); if ( style & wxFD_SAVE ) { if ( !defaultDir.empty() ) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(m_widget), wxConvFileName->cWX2MB(defaultDir)); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(m_widget), wxConvFileName->cWX2MB(defaultFileName)); #if GTK_CHECK_VERSION(2,7,3) if (!gtk_check_version(2,7,3)) gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(m_widget), FALSE); #endif } else { if ( !defaultFileName.empty() ) { wxString dir; if ( defaultDir.empty() ) dir = ::wxGetCwd(); else dir = defaultDir; gtk_file_chooser_set_filename( GTK_FILE_CHOOSER(m_widget), wxConvFileName->cWX2MB( wxFileName(dir, defaultFileName).GetFullPath() ) ); } else if ( !defaultDir.empty() ) gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER(m_widget), wxConvFileName->cWX2MB(defaultDir) ); } } else #endif wxGenericFileDialog::Create( parent, message, defaultDir, defaultFileName, wildCard, style, pos ); }
void gradients_save_as_pov_ray_cmd_callback (GtkAction *action, gpointer data) { GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data); GimpContext *context; GimpGradient *gradient; GtkFileChooser *chooser; gchar *title; context = gimp_container_view_get_context (editor->view); gradient = gimp_context_get_gradient (context); if (! gradient) return; title = g_strdup_printf (_("Save '%s' as POV-Ray"), gimp_object_get_name (gradient)); chooser = GTK_FILE_CHOOSER (gtk_file_chooser_dialog_new (title, NULL, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL)); gtk_dialog_set_alternative_button_order (GTK_DIALOG (chooser), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_object_set_data (G_OBJECT (chooser), "gimp", context->gimp); g_free (title); gtk_window_set_screen (GTK_WINDOW (chooser), gtk_widget_get_screen (GTK_WIDGET (editor))); gtk_window_set_role (GTK_WINDOW (chooser), "gimp-gradient-save-pov"); gtk_window_set_position (GTK_WINDOW (chooser), GTK_WIN_POS_MOUSE); gtk_dialog_set_default_response (GTK_DIALOG (chooser), GTK_RESPONSE_OK); gtk_file_chooser_set_do_overwrite_confirmation (chooser, TRUE); g_signal_connect (chooser, "response", G_CALLBACK (gradients_save_as_pov_ray_response), gradient); g_signal_connect (chooser, "delete-event", G_CALLBACK (gtk_true), NULL); g_object_ref (gradient); g_signal_connect_object (chooser, "destroy", G_CALLBACK (g_object_unref), gradient, G_CONNECT_SWAPPED); gimp_help_connect (GTK_WIDGET (chooser), gimp_standard_help_func, GIMP_HELP_GRADIENT_SAVE_AS_POV, NULL); gtk_widget_show (GTK_WIDGET (chooser)); }
/** * Print the file selected by a file chooser dialog. * @param dialog file chooser dialog to print information about */ void mk_print_GtkFileChooserDialog_info(GtkFileChooserDialog* dialog) { mk_print_GtkFileChooser_info(GTK_FILE_CHOOSER(dialog)); }