/* Add shortcut for default ICC profile location */ static void gimp_profile_chooser_dialog_add_shortcut (GimpProfileChooserDialog *dialog) { #ifdef G_OS_WIN32 { const gchar *prefix = g_getenv ("SystemRoot"); gchar *folder; if (! prefix) prefix = "c:\\windows"; folder = g_strconcat (prefix, "\\system32\\spool\\drivers\\color", NULL); if (g_file_test (folder, G_FILE_TEST_IS_DIR)) gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog), folder, NULL); g_free (folder); } #else { const gchar folder[] = "/usr/share/color/icc"; if (g_file_test (folder, G_FILE_TEST_IS_DIR)) gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog), folder, NULL); } #endif }
void wp_create_filechooser (AppearanceData *data) { const char *start_dir, *pictures = NULL; GtkFileFilter *filter; data->wp_filesel = GTK_FILE_CHOOSER ( gtk_file_chooser_dialog_new (_("Add Wallpaper"), GTK_WINDOW (appearance_capplet_get_widget (data, "appearance_window")), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL)); gtk_dialog_set_default_response (GTK_DIALOG (data->wp_filesel), GTK_RESPONSE_OK); gtk_file_chooser_set_select_multiple (data->wp_filesel, TRUE); gtk_file_chooser_set_use_preview_label (data->wp_filesel, FALSE); start_dir = g_get_home_dir (); if (g_file_test ("/usr/share/backgrounds", G_FILE_TEST_IS_DIR)) { gtk_file_chooser_add_shortcut_folder (data->wp_filesel, "/usr/share/backgrounds", NULL); start_dir = "/usr/share/backgrounds"; } pictures = g_get_user_special_dir (G_USER_DIRECTORY_PICTURES); if (pictures != NULL && g_file_test (pictures, G_FILE_TEST_IS_DIR)) { gtk_file_chooser_add_shortcut_folder (data->wp_filesel, pictures, NULL); start_dir = pictures; } gtk_file_chooser_set_current_folder (data->wp_filesel, start_dir); filter = gtk_file_filter_new (); gtk_file_filter_add_pixbuf_formats (filter); gtk_file_filter_set_name (filter, _("Images")); gtk_file_chooser_add_filter (data->wp_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 (data->wp_filesel, filter); data->wp_image = gtk_image_new (); gtk_file_chooser_set_preview_widget (data->wp_filesel, data->wp_image); gtk_widget_set_size_request (data->wp_image, 128, -1); gtk_widget_show (data->wp_image); g_signal_connect (data->wp_filesel, "update-preview", (GCallback) wp_update_preview, data); }
static void browse_button_cb (GtkWidget *widget, gpointer data) { GtkWindow *parent = GTK_WINDOW (data); GtkFileFilter *filter; GtkWidget *file_dialog; file_dialog = gtk_file_chooser_dialog_new (_("Select User Image"), parent, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_show_hidden (GTK_FILE_CHOOSER (file_dialog), FALSE); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (file_dialog), TRUE); gtk_file_chooser_set_use_preview_label (GTK_FILE_CHOOSER (file_dialog), FALSE); if (facedir && g_file_test (facedir, G_FILE_TEST_IS_DIR)) { gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (file_dialog), facedir); gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (file_dialog), facedir, NULL); } else { gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (file_dialog), DATADIR "/pixmaps"); gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (file_dialog), DATADIR "/pixmaps", NULL); } filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Images")); gtk_file_filter_add_pixbuf_formats (filter); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (file_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 (GTK_FILE_CHOOSER (file_dialog), filter); if (imagename != NULL) { gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (file_dialog), imagename); } add_preview_widget (file_dialog); g_signal_connect (G_OBJECT (file_dialog), "response", G_CALLBACK (install_response), NULL); gtk_widget_show (file_dialog); }
static void add_new_filechooser_button (const gchar *mnemonic, const gchar *chooser_title, GtkFileChooserAction action, GtkWidget *group_box, GtkSizeGroup *label_group) { GtkWidget *hbox, *label, *chooser, *button; hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (group_box), hbox); label = gtk_label_new_with_mnemonic (mnemonic); gtk_size_group_add_widget (GTK_SIZE_GROUP (label_group), label); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_box_pack_start (GTK_BOX (hbox), label); chooser = gtk_file_chooser_button_new (g_strconcat(chooser_title, " - testfilechooserbutton", NULL), action); gtk_widget_set_hexpand (chooser, TRUE); gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL); gtk_file_chooser_remove_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL); gtk_label_set_mnemonic_widget (GTK_LABEL (label), chooser); g_signal_connect (chooser, "current-folder-changed", G_CALLBACK (chooser_current_folder_changed_cb), NULL); g_signal_connect (chooser, "selection-changed", G_CALLBACK (chooser_selection_changed_cb), NULL); g_signal_connect (chooser, "file-activated", G_CALLBACK (chooser_file_activated_cb), NULL); g_signal_connect (chooser, "update-preview", G_CALLBACK (chooser_update_preview_cb), NULL); gtk_box_pack_start (GTK_BOX (hbox), chooser); button = gtk_button_new_with_label ("Tests"); g_signal_connect (button, "clicked", G_CALLBACK (tests_button_clicked_cb), chooser); gtk_box_pack_start (GTK_BOX (hbox), button); }
/* Caller must g_free() the returned filename. */ gchar * ghid_dialog_file_select_save (gchar * title, gchar ** path, gchar * file, gchar * shortcuts) { GtkWidget *dialog; gchar *result = NULL, *folder, *seed; GHidPort *out = &ghid_port; dialog = gtk_file_chooser_dialog_new (title, GTK_WINDOW (out->top_window), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); if (path && *path && **path) gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), *path); if (file && *file) { gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), g_path_get_basename(file)); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), g_path_get_dirname (file)); } if (shortcuts && *shortcuts) { folder = g_strdup (shortcuts); seed = folder; while ((folder = strtok (seed, ":")) != NULL) { gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog), folder, NULL); seed = NULL; } g_free (folder); } if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) { result = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog)); if (folder && path) { dup_string (path, folder); g_free (folder); } } gtk_widget_destroy (dialog); return result; }
void sj_add_default_dirs (GtkFileChooser *dialog) { const char *dir; dir = g_get_user_special_dir (G_USER_DIRECTORY_MUSIC); if (dir) { gtk_file_chooser_add_shortcut_folder (dialog, dir, NULL); } }
static void totem_add_default_dirs (GtkFileChooser *dialog) { guint i; for (i = 0; i < G_N_ELEMENTS (dir_types); i++) { const char *dir; dir = g_get_user_special_dir (dir_types[i]); if (dir == NULL) continue; gtk_file_chooser_add_shortcut_folder (dialog, dir, NULL); } }
static GtkWidget * impl_get_config_widget (RBDisplayPage *page, RBShellPreferences *prefs) { RBPodcastMainSource *source = RB_PODCAST_MAIN_SOURCE (page); RBPodcastManager *podcast_mgr; GtkBuilder *builder; GtkWidget *update_interval; GtkWidget *btn_file; GSettings *settings; char *download_dir; if (source->priv->config_widget) return source->priv->config_widget; builder = rb_builder_load ("podcast-prefs.ui", source); source->priv->config_widget = GTK_WIDGET (gtk_builder_get_object (builder, "podcast_vbox")); btn_file = GTK_WIDGET (gtk_builder_get_object (builder, "location_chooser")); gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (btn_file), rb_music_dir (), NULL); g_object_get (source, "podcast-manager", &podcast_mgr, NULL); download_dir = rb_podcast_manager_get_podcast_dir (podcast_mgr); gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (btn_file), download_dir); g_object_unref (podcast_mgr); g_free (download_dir); g_signal_connect_object (btn_file, "selection-changed", G_CALLBACK (rb_podcast_main_source_btn_file_change_cb), source, 0); update_interval = GTK_WIDGET (gtk_builder_get_object (builder, "update_interval")); g_object_set (update_interval, "id-column", 1, NULL); settings = g_settings_new (PODCAST_SETTINGS_SCHEMA); g_settings_bind (settings, PODCAST_DOWNLOAD_INTERVAL, update_interval, "active-id", G_SETTINGS_BIND_DEFAULT); g_object_unref (settings); return source->priv->config_widget; }
static GtkWidget * cdisplay_proof_file_chooser_dialog_new (void) { GtkWidget *dialog; GtkFileFilter *filter; dialog = gtk_file_chooser_dialog_new (_("Choose an ICC Color Profile"), NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT); #ifndef G_OS_WIN32 { const gchar folder[] = "/usr/share/color/icc"; if (g_file_test (folder, G_FILE_TEST_IS_DIR)) gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog), folder, NULL); } #endif 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 (dialog), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("ICC color profile (*.icc, *.icm)")); gtk_file_filter_add_pattern (filter, "*.[Ii][Cc][Cc]"); gtk_file_filter_add_pattern (filter, "*.[Ii][Cc][Mm]"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter); return dialog; }
static void add_pwds_parent_as_shortcut_clicked_cb (GtkWidget *button, gpointer user_data) { GError *err = NULL; if (!gtk_file_chooser_add_shortcut_folder (user_data, gtk_src_dir, &err)) { g_message ("Couldn't add `%s' as shortcut folder: %s", gtk_src_dir, err->message); g_error_free (err); } else { g_message ("Added `%s' as shortcut folder.", gtk_src_dir); } }
JNIEXPORT jboolean JNICALL Java_org_gnome_gtk_GtkFileChooser_gtk_1file_1chooser_1add_1shortcut_1folder ( JNIEnv* env, jclass cls, jlong _self, jstring _folder ) { gboolean result; jboolean _result; GtkFileChooser* self; const char* folder; GError* error = NULL; // convert parameter self self = (GtkFileChooser*) _self; // convert parameter folder folder = (const char*) bindings_java_getString(env, _folder); if (folder == NULL) { return JNI_FALSE; // Java Exception already thrown } // call function result = gtk_file_chooser_add_shortcut_folder(self, folder, &error); // cleanup parameter self // cleanup parameter folder bindings_java_releaseString(folder); // check for error if (error) { bindings_java_throwGlibException(env, error); return JNI_FALSE; } // translate return value to JNI type _result = (jboolean) result; // and finally return _result; }
static GtkWidget * impl_get_config_widget (RBSource *asource, RBShellPreferences *prefs) { RBPodcastMainSource *source = RB_PODCAST_MAIN_SOURCE (asource); RBPodcastManager *podcast_mgr; GtkBuilder *builder; GtkWidget *cb_update_interval; GtkWidget *btn_file; char *download_dir; if (source->priv->config_widget) return source->priv->config_widget; builder = rb_builder_load ("podcast-prefs.ui", source); source->priv->config_widget = GTK_WIDGET (gtk_builder_get_object (builder, "podcast_vbox")); btn_file = GTK_WIDGET (gtk_builder_get_object (builder, "location_chooser")); gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (btn_file), rb_music_dir (), NULL); g_object_get (source, "podcast-manager", &podcast_mgr, NULL); download_dir = rb_podcast_manager_get_podcast_dir (podcast_mgr); g_object_unref (podcast_mgr); gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (btn_file), download_dir); g_free (download_dir); g_signal_connect (btn_file, "selection-changed", G_CALLBACK (rb_podcast_main_source_btn_file_change_cb), CONF_STATE_PODCAST_DOWNLOAD_DIR); cb_update_interval = GTK_WIDGET (gtk_builder_get_object (builder, "cb_update_interval")); gtk_combo_box_set_active (GTK_COMBO_BOX (cb_update_interval), eel_gconf_get_integer (CONF_STATE_PODCAST_DOWNLOAD_INTERVAL)); g_signal_connect (cb_update_interval, "changed", G_CALLBACK (rb_podcast_main_source_cb_interval_changed_cb), source); return source->priv->config_widget; }
int clip_GTK_FILECHOOSERADDSHORTCUTFOLDER(ClipMachine * ClipMachineMemory) { C_object *cchooser = _fetch_co_arg(ClipMachineMemory); gchar *name = _clip_parc(ClipMachineMemory, 2); GError *error; CHECKCOBJ(cchooser, GTK_IS_FILE_CHOOSER(cchooser->object)); CHECKARG(2, CHARACTER_type_of_ClipVarType); LOCALE_TO_UTF(name); _clip_retl(ClipMachineMemory, gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(cchooser->object), name, &error)); FREE_TEXT(name); return 0; err: return 1; }
GtkWidget* gtr_torrent_options_dialog_new( GtkWindow * parent, TrCore * core, tr_ctor * ctor ) { guint row; guint col; const char * str; GtkWidget * w; GtkWidget * d; GtkWidget * t; 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 ); t = gtk_table_new( 6, 2, FALSE ); gtk_container_set_border_width( GTK_CONTAINER( t ), GUI_PAD_BIG ); gtk_table_set_row_spacings( GTK_TABLE( t ), GUI_PAD ); gtk_table_set_col_spacings( GTK_TABLE( t ), GUI_PAD_BIG ); row = col = 0; l = gtk_label_new_with_mnemonic( _( "_Torrent file:" ) ); gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f ); gtk_table_attach( GTK_TABLE( t ), l, col, col + 1, row, row + 1, GTK_FILL, 0, 0, 0 ); ++col; w = gtk_file_chooser_button_new( _( "Select Source File" ), GTK_FILE_CHOOSER_ACTION_OPEN ); source_chooser = w; gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 ); gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w ); addTorrentFilters( GTK_FILE_CHOOSER( w ) ); g_signal_connect( w, "selection-changed", G_CALLBACK( sourceChanged ), data ); ++row; col = 0; l = gtk_label_new_with_mnemonic( _( "_Destination folder:" ) ); gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f ); gtk_table_attach( GTK_TABLE( t ), l, col, col + 1, row, row + 1, GTK_FILL, 0, 0, 0 ); ++col; 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_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 ); gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w ); g_signal_connect( w, "selection-changed", G_CALLBACK( downloadDirChanged ), data ); ++row; col = 0; w = data->file_list; gtk_widget_set_size_request ( w, 466u, 300u ); gtk_table_attach_defaults( GTK_TABLE( t ), w, col, col + 2, row, row + 1 ); ++row; col = 0; w = gtk_label_new_with_mnemonic( _( "Torrent _priority:" ) ); gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.5f ); gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 ); ++col; gtk_table_attach( GTK_TABLE( t ), data->priority_combo, col, col + 1, row, row + 1, ~0, 0, 0, 0 ); gtk_label_set_mnemonic_widget( GTK_LABEL( w ), data->priority_combo ); ++row; col = 0; 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_table_attach( GTK_TABLE( t ), w, col, col + 2, row, row + 1, GTK_FILL, 0, 0, 0 ); ++row; col = 0; w = data->trash_check; if( tr_ctorGetDeleteSource( ctor, &flag ) ) g_assert_not_reached( ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), flag ); gtk_table_attach( GTK_TABLE( t ), w, col, col + 2, row, row + 1, GTK_FILL, 0, 0, 0 ); /* 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 ), t ); w = gtk_dialog_get_widget_for_response( GTK_DIALOG( d ), GTK_RESPONSE_ACCEPT ); gtk_widget_grab_focus( w ); return d; }
/* Caller must g_free() the returned filename.*/ gchar * ghid_dialog_file_select_open (gchar * title, gchar ** path, gchar * shortcuts) { GtkWidget *dialog; gchar *result = NULL, *folder, *seed; GHidPort *out = &ghid_port; GtkFileFilter *no_filter; dialog = gtk_file_chooser_dialog_new (title, GTK_WINDOW (out->top_window), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); /* add a default filter for not filtering files */ no_filter = gtk_file_filter_new (); gtk_file_filter_set_name (no_filter, "all"); gtk_file_filter_add_pattern (no_filter, "*.*"); gtk_file_filter_add_pattern (no_filter, "*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), no_filter); /* in case we have a dialog for loading a footprint file */ if (strcmp (title, _("Load element to buffer")) == 0) { /* add a filter for footprint files */ GtkFileFilter *fp_filter; fp_filter = gtk_file_filter_new (); gtk_file_filter_set_name (fp_filter, "fp"); gtk_file_filter_add_mime_type (fp_filter, "application/x-pcb-footprint"); gtk_file_filter_add_pattern (fp_filter, "*.fp"); gtk_file_filter_add_pattern (fp_filter, "*.FP"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), fp_filter); } /* in case we have a dialog for loading a layout file */ if ((strcmp (title, _("Load layout file")) == 0) || (strcmp (title, _("Load layout file to buffer")) == 0)) { /* add a filter for layout files */ GtkFileFilter *pcb_filter; pcb_filter = gtk_file_filter_new (); gtk_file_filter_set_name (pcb_filter, "pcb"); gtk_file_filter_add_mime_type (pcb_filter, "application/x-pcb-layout"); gtk_file_filter_add_pattern (pcb_filter, "*.pcb"); gtk_file_filter_add_pattern (pcb_filter, "*.PCB"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), pcb_filter); } /* in case we have a dialog for loading a netlist file */ if (strcmp (title, _("Load netlist file")) == 0) { /* add a filter for netlist files */ GtkFileFilter *net_filter; net_filter = gtk_file_filter_new (); gtk_file_filter_set_name (net_filter, "netlist"); gtk_file_filter_add_mime_type (net_filter, "application/x-pcb-netlist"); gtk_file_filter_add_pattern (net_filter, "*.net"); gtk_file_filter_add_pattern (net_filter, "*.NET"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), net_filter); } if (path && *path) gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), *path); else { gchar *default_path; default_path = g_get_current_dir(); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), default_path); g_free(default_path); } if (shortcuts && *shortcuts) { folder = g_strdup (shortcuts); seed = folder; while ((folder = strtok (seed, ":")) != NULL) { gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog), folder, NULL); seed = NULL; } g_free (folder); } if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) { result = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog)); if (folder && path) { dup_string (path, folder); g_free (folder); } } gtk_widget_destroy (dialog); return result; }
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; 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 (!(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 (filter && filter[0] && (flags & FRF_FILTERISINITIAL)) { if (flags & FRF_WRITE) { 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)); } else gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), filter); } else if (!(flags & FRF_RECENTLYUSED)) gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), get_xdir ()); if (flags & FRF_MULTIPLE) gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE); if (flags & FRF_CHOOSEFOLDER) gtk_file_chooser_set_action (GTK_FILE_CHOOSER (dialog), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); if ((flags & FRF_EXTENSIONS || flags & FRF_MIMETYPES) && extensions != NULL) { filefilter = gtk_file_filter_new (); tokenbuffer = g_strdup (extensions); token = strtok (tokenbuffer, ";"); while (token != NULL) { if (flags & FRF_EXTENSIONS) gtk_file_filter_add_pattern (filefilter, token); else gtk_file_filter_add_mime_type (filefilter, token); token = strtok (NULL, ";"); } g_free (tokenbuffer); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filefilter); } gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog), get_xdir (), NULL); 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); }
PreferencesPageDCC * preferences_page_dcc_new (gpointer prefs_dialog, GtkBuilder *xml) { PreferencesPageDCC *page = g_object_new (PREFERENCES_PAGE_DCC_TYPE, NULL); PreferencesDialog *p = (PreferencesDialog *) prefs_dialog; #define GW(name) GtkWidget *name = GTK_WIDGET (gtk_builder_get_object (xml, #name)) GW(download_dir_button); GW(completed_dir_button); GW(convert_spaces); GW(save_nicknames_dcc); GW(autoaccept_dcc_chat); GW(autoaccept_dcc_file); GW(get_dcc_ip_from_server); GW(use_specified_dcc_ip); GW(special_ip_address); GW(individual_send_throttle); GW(global_send_throttle); GW(individual_receive_throttle); GW(global_receive_throttle); #undef GW page->special_ip_address = special_ip_address; gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER (download_dir_button), get_default_download_dir(), NULL); gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (download_dir_button), prefs.dccdir); if (strlen (prefs.dcc_completed_dir) == 0) { gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (completed_dir_button), prefs.dccdir); } else { gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER (completed_dir_button), get_default_download_dir(), NULL); gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (completed_dir_button), prefs.dcc_completed_dir); } gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (convert_spaces), prefs.dcc_send_fillspaces); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (save_nicknames_dcc), prefs.dccwithnick); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (autoaccept_dcc_chat), prefs.autodccchat); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (autoaccept_dcc_file), prefs.autodccsend); if (prefs.ip_from_server) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (get_dcc_ip_from_server), TRUE); gtk_widget_set_sensitive (special_ip_address, FALSE); } else { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (use_specified_dcc_ip), TRUE); gtk_entry_set_text (GTK_ENTRY (special_ip_address), prefs.dcc_ip_str); gtk_widget_set_sensitive (special_ip_address, FALSE); } gtk_spin_button_set_value (GTK_SPIN_BUTTON (individual_send_throttle), (gdouble) prefs.dcc_max_send_cps); gtk_spin_button_set_value (GTK_SPIN_BUTTON (global_send_throttle), (gdouble) prefs.dcc_global_max_send_cps); gtk_spin_button_set_value (GTK_SPIN_BUTTON (individual_receive_throttle), (gdouble) prefs.dcc_max_get_cps); gtk_spin_button_set_value (GTK_SPIN_BUTTON (global_receive_throttle), (gdouble) prefs.dcc_global_max_get_cps); g_signal_connect (G_OBJECT (download_dir_button), "selection-changed", G_CALLBACK (path_changed), prefs.dccdir); g_signal_connect (G_OBJECT (completed_dir_button), "selection-changed", G_CALLBACK (path_changed), prefs.dcc_completed_dir); g_signal_connect (G_OBJECT (convert_spaces), "toggled", G_CALLBACK (toggle_changed), &prefs.dcc_send_fillspaces); g_signal_connect (G_OBJECT (save_nicknames_dcc), "toggled", G_CALLBACK (toggle_changed), &prefs.dccwithnick); g_signal_connect (G_OBJECT (autoaccept_dcc_chat), "toggled", G_CALLBACK (toggle_changed), &prefs.autodccchat); g_signal_connect (G_OBJECT (autoaccept_dcc_file), "toggled", G_CALLBACK (toggle_changed), &prefs.autodccsend); g_signal_connect (G_OBJECT (get_dcc_ip_from_server), "toggled", G_CALLBACK (get_ip_from_server_changed), page); g_signal_connect (G_OBJECT (special_ip_address), "changed", G_CALLBACK (special_ip_changed), NULL); g_signal_connect (G_OBJECT (individual_send_throttle), "value-changed", G_CALLBACK (spin_changed), &prefs.dcc_max_send_cps); g_signal_connect (G_OBJECT (global_send_throttle), "value-changed", G_CALLBACK (spin_changed), &prefs.dcc_global_max_send_cps); g_signal_connect (G_OBJECT (individual_receive_throttle), "value-changed", G_CALLBACK (spin_changed), &prefs.dcc_max_get_cps); g_signal_connect (G_OBJECT (global_receive_throttle), "value-changed", G_CALLBACK (spin_changed), &prefs.dcc_global_max_get_cps); GtkIconTheme *theme = gtk_icon_theme_get_default (); PREFERENCES_PAGE (page)->icon = gtk_icon_theme_load_icon (theme, "xchat-gnome-dcc", 16, 0, NULL); GtkTreeIter iter; gtk_list_store_append (p->page_store, &iter); gtk_list_store_set (p->page_store, &iter, 0, PREFERENCES_PAGE (page)->icon, 1, _("File Transfers & DCC"), 2, 3, -1); return page; }
/***************************************************************************** * run_session_load_dialog() * * Callback for running the 'Load Session' dialog from the main menu. *****************************************************************************/ void run_session_load_dialog(GtkWidget *UNUSED(widget), gpointer UNUSED(data)) { SESSION *session = get_current_session(); PATCH *patch; DIR_LIST *pdir = session_dir_list; char *directory; GSList *file_list; GSList *cur; GError *error; unsigned int sess_num = session_io_start; unsigned int part_num; /* create dialog if needed */ if (session_load_dialog == NULL) { create_session_load_dialog(); } gtk_widget_show(session_load_dialog); /* add all session directories to shortcuts */ while (pdir != NULL) { if (!pdir->load_shortcut) { error = NULL; gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(session_load_dialog), pdir->name, &error); if (error != NULL) { PHASEX_ERROR("Error %d: %s\n", error->code, error->message); g_error_free(error); } pdir->load_shortcut = 1; } pdir = pdir->next; } /* set filename and current directory */ if ((session->directory != NULL) && (* (session->directory) != '\0')) { gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(session_load_dialog), session->directory); } else if ((session->parent_dir != NULL) && (* (session->parent_dir) != '\0')) { gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_load_dialog), session->parent_dir); } else { gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_load_dialog), user_session_dir); } /* set position in patch bank to start loading patches */ session_io_start = visible_sess_num; gtk_adjustment_set_value(GTK_ADJUSTMENT(session_io_start_adj), (session_io_start + 1)); /* run the dialog and load if necessary */ if (gtk_dialog_run(GTK_DIALOG(session_load_dialog)) == GTK_RESPONSE_ACCEPT) { /* get list of selected files from chooser */ file_list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(session_load_dialog)); if (file_list != NULL) { session_io_start = (unsigned int) gtk_adjustment_get_value(GTK_ADJUSTMENT(session_io_start_adj)) - 1; /* read in each session and increment session bank slot number */ sess_num = session_io_start; session_load_in_progress = 1; cur = file_list; while (cur != NULL) { directory = (char *) cur->data; if (load_session(directory, sess_num) == 0) { if (sess_num == visible_sess_num) { for (part_num = 0; part_num < MAX_PARTS; part_num++) { visible_prog_num[part_num] = 0; patch = set_active_patch(visible_sess_num, part_num, 0); init_patch_state(patch); if (part_num == visible_part_num) { update_gui_patch(patch, 0); } } } sess_num++; } if (sess_num >= SESSION_BANK_SIZE) { break; } cur = g_slist_next(cur); } session_load_in_progress = 0; g_slist_free(file_list); update_gui_patch_name(); update_gui_session_name(); save_session_bank(); } } /* save this widget for next time */ gtk_widget_hide(session_load_dialog); }
/*! \brief pops up a Filechooser dialog to select a file \param data is a pointer to a MtxFileIO structure which contains important bits like the path to start, the filter, default filename and so on \see MtxFileIO \returns the path to the file or NULL if cancelled */ gchar * choose_file(MtxFileIO *data) { GtkWidget *dialog = NULL; GtkFileFilter *filter = NULL; gchar * path = NULL; gchar * defdir = NULL; gchar *filename = NULL; gchar *tmpbuf = NULL; gchar **vector = NULL; gint response = 0; gboolean res = FALSE; guint i = 0; if (!GTK_IS_WINDOW(data->parent)) data->parent = NULL; /* printf("choose_file\n"); printf("filter %s\n",data->filter); printf("filename %s\n",data->filename); printf("default_path %s\n",data->default_path); printf("title %s\n",data->title); */ if (!data->project) data->project = DEFAULT_PROJECT; if (!data->title) data->title = g_strdup("Open File"); if ((data->action == GTK_FILE_CHOOSER_ACTION_OPEN) || (data->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)) { dialog = gtk_file_chooser_dialog_new(data->title, GTK_WINDOW(data->parent), data->action, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); if ((data->on_top) && (GTK_IS_WIDGET(data->parent))) gtk_window_set_transient_for(GTK_WINDOW(gtk_widget_get_toplevel(dialog)),GTK_WINDOW(data->parent)); if ((data->absolute_path) && (!data->default_path)) gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog),data->absolute_path); else if (data->default_path) { path = g_build_filename(MTXSYSDATA,data->default_path,NULL); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog),path); g_free(path); } } else if (data->action == GTK_FILE_CHOOSER_ACTION_SAVE) { dialog = gtk_file_chooser_dialog_new(data->title, GTK_WINDOW(data->parent), data->action, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); if ((data->on_top) && (GTK_IS_WIDGET(data->parent))) gtk_window_set_transient_for(GTK_WINDOW(gtk_widget_get_toplevel(dialog)),GTK_WINDOW(data->parent)); defdir = g_build_filename(HOME(),"mtx",data->project,data->default_path, NULL); if (!g_file_test(defdir,G_FILE_TEST_IS_DIR)) g_mkdir(defdir,0755); /* If filename passed check/adj path */ if (data->filename) { #ifdef __WIN32__ /* Disallows modifying distributed files */ if (g_strrstr(data->filename,"dist") != NULL) #else if (g_strrstr(data->filename,DATA_DIR) != NULL) #endif { vector = g_strsplit(data->filename,PSEP,-1); tmpbuf = g_strconcat(defdir,PSEP,vector[g_strv_length(vector)-1],NULL); gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),defdir); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),vector[g_strv_length(vector)-1]); g_strfreev(vector); g_free(tmpbuf); } else gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),data->filename); } else { gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),defdir); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), data->default_filename ); } g_free(defdir); } else return NULL; /* Add shortcut folders... */ if (data->shortcut_folders) { vector = g_strsplit(data->shortcut_folders,",",-1); for (i=0;i<g_strv_length(vector);i++) { path = g_build_filename(MTXSYSDATA,vector[i],NULL); gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(dialog),path,NULL); g_free(path); path = g_build_filename(HOME(),"mtx",data->project,vector[i],NULL); gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(dialog),path,NULL); g_free(path); } g_strfreev(vector); } /* If default path switch to that place */ if ((data->external_path) && (!(data->default_path))) { path = g_build_filename(HOME(),"mtx",data->project,data->external_path,NULL); if (!g_file_test(path,G_FILE_TEST_IS_DIR)) g_mkdir(path,0755); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog),path); g_free(path); } /* If filters, assign them */ if (data->filter) { vector = g_strsplit(data->filter,",",-1); if (g_strv_length(vector)%2 > 0) goto afterfilter; for (i=0;i<g_strv_length(vector);i+=2) { filter = gtk_file_filter_new(); gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter),vector[i]); gtk_file_filter_set_name(GTK_FILE_FILTER(filter),vector[i+1]); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog),filter); } gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog),filter); g_strfreev(vector); } afterfilter: /* Turn on overwriteconfirmation */ gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); g_signal_connect(G_OBJECT(dialog),"confirm-overwrite", G_CALLBACK (confirm_overwrite_callback), NULL); if (data->action == GTK_FILE_CHOOSER_ACTION_OPEN) if (data->default_filename) gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(dialog),data->default_filename); response = gtk_dialog_run (GTK_DIALOG (dialog)); if (response == GTK_RESPONSE_ACCEPT) { tmpbuf = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); if ((data->action == GTK_FILE_CHOOSER_ACTION_SAVE) && (data->default_extension)) { if(!g_str_has_suffix (tmpbuf,data->default_extension)) filename = g_strjoin(".",tmpbuf,data->default_extension,NULL); else filename = g_strdup(tmpbuf); } else filename = g_strdup(tmpbuf); g_free(tmpbuf); } gtk_widget_destroy (dialog); return (filename); }
/***************************************************************************** * create_session_save_dialog() *****************************************************************************/ void create_session_save_dialog(void) { GError *error = NULL; GtkWidget *hbox; GtkWidget *label; int new_adj = (session_io_start_adj == NULL); /* this should only need to happen once */ if (session_save_dialog == NULL) { /* create dialog */ session_save_dialog = gtk_file_chooser_dialog_new("PHASEX - Save Session", GTK_WINDOW(main_window), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); gtk_window_set_wmclass(GTK_WINDOW(session_save_dialog), "phasex", "phasex-save"); gtk_window_set_role(GTK_WINDOW(session_save_dialog), "session-save"); gtk_file_chooser_set_preview_widget_active (GTK_FILE_CHOOSER(session_save_dialog), FALSE); /* create spinbutton control of session number */ hbox = gtk_hbox_new(FALSE, 8); label = gtk_label_new("Save into session #:"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 8); if (new_adj) { session_io_start_adj = gtk_adjustment_new(0, 1, PATCH_BANK_SIZE, 1, 8, 0); } session_save_start_spin = gtk_spin_button_new(GTK_ADJUSTMENT(session_io_start_adj), 0, 0); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(session_save_start_spin), TRUE); gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(session_save_start_spin), GTK_UPDATE_IF_VALID); gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(session_save_start_spin), TRUE); gtk_adjustment_set_value(GTK_ADJUSTMENT(session_io_start_adj), (session_io_start + 1)); gtk_box_pack_start(GTK_BOX(hbox), session_save_start_spin, FALSE, FALSE, 8); if (new_adj) { g_signal_connect(GTK_OBJECT(session_save_start_spin), "value_changed", GTK_SIGNAL_FUNC(set_session_io_start), (gpointer) session_io_start_adj); } gtk_widget_show_all(hbox); gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(session_save_dialog), hbox); /* realize the file chooser before telling it about files */ gtk_widget_realize(session_save_dialog); #if GTK_CHECK_VERSION(2, 8, 0) /* this can go away once manual overwrite checks are proven to work properly */ gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER(session_save_dialog), TRUE); #endif #if GTK_CHECK_VERSION(2, 6, 0) gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(session_save_dialog), TRUE); #endif /* add user session dir as shortcut folder (user cannot write to sys) */ gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(session_save_dialog), user_session_dir, &error); if (error != NULL) { PHASEX_ERROR("Error %d: %s\n", error->code, error->message); g_error_free(error); } /* start in user session dir (usually ~/.phasex/user-sessions) */ gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_save_dialog), user_session_dir); } }
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; #if 0 /* native file dialogs */ #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 #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 (), 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); } /* With DCC, we can't rely on filter as initial folder since filter already contains * the filename upon DCC RECV. Thus we have no better option than to check for the message * which will be the title of the window. For DCC it always contains the "offering" word. * This method is really ugly but it works so we'll stick with it for now. */ else if (strstr (title, "offering") != NULL) { gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), prefs.hex_dcc_dir); } /* by default, open the config folder */ else { gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), get_xdir ()); } } 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); }
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); }
int main (int argc, char *argv[]) { GtkWidget *win, *vbox, *frame, *alignment, *group_box; GtkWidget *hbox, *label, *chooser, *button; GtkSizeGroup *label_group; GOptionContext *context; gchar *cwd; context = g_option_context_new ("- test GtkFileChooserButton widget"); g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE); g_option_context_add_group (context, gtk_get_option_group (TRUE)); g_option_context_parse (context, &argc, &argv, NULL); g_option_context_free (context); gtk_init (&argc, &argv); /* to test rtl layout, use "--right-to-left" */ if (rtl) gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL); cwd = g_get_current_dir(); gtk_src_dir = g_path_get_dirname (cwd); g_free (cwd); win = gtk_dialog_new_with_buttons ("TestFileChooserButton", NULL, 0, "_Quit", GTK_RESPONSE_CLOSE, NULL); g_signal_connect (win, "response", G_CALLBACK (gtk_main_quit), NULL); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18); g_object_set (vbox, "margin", 6, NULL); gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (win))), vbox); frame = gtk_frame_new ("<b>GtkFileChooserButton</b>"); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); gtk_label_set_use_markup (GTK_LABEL (gtk_frame_get_label_widget (GTK_FRAME (frame))), TRUE); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); alignment = gtk_alignment_new (0.0, 0.0, 1.0, 1.0); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 6, 0, 12, 0); gtk_container_add (GTK_CONTAINER (frame), alignment); label_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); group_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (alignment), group_box); /* OPEN */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (group_box), hbox, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic ("_Open:"); gtk_size_group_add_widget (GTK_SIZE_GROUP (label_group), label); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); chooser = gtk_file_chooser_button_new ("Select A File - testfilechooserbutton", GTK_FILE_CHOOSER_ACTION_OPEN); gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL); gtk_file_chooser_remove_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL); gtk_label_set_mnemonic_widget (GTK_LABEL (label), chooser); g_signal_connect (chooser, "current-folder-changed", G_CALLBACK (chooser_current_folder_changed_cb), NULL); g_signal_connect (chooser, "selection-changed", G_CALLBACK (chooser_selection_changed_cb), NULL); g_signal_connect (chooser, "file-activated", G_CALLBACK (chooser_file_activated_cb), NULL); g_signal_connect (chooser, "update-preview", G_CALLBACK (chooser_update_preview_cb), NULL); gtk_box_pack_start (GTK_BOX (hbox), chooser, TRUE, TRUE, 0); button = gtk_button_new_with_label ("Properties"); g_signal_connect (button, "clicked", G_CALLBACK (properties_button_clicked_cb), chooser); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); button = gtk_button_new_with_label ("Tests"); g_signal_connect (button, "clicked", G_CALLBACK (tests_button_clicked_cb), chooser); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); /* SELECT_FOLDER */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (group_box), hbox, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic ("Select _Folder:"); gtk_size_group_add_widget (GTK_SIZE_GROUP (label_group), label); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); chooser = gtk_file_chooser_button_new ("Select A Folder - testfilechooserbutton", GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL); gtk_file_chooser_remove_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL); gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL); gtk_label_set_mnemonic_widget (GTK_LABEL (label), chooser); g_signal_connect (chooser, "current-folder-changed", G_CALLBACK (chooser_current_folder_changed_cb), NULL); g_signal_connect (chooser, "selection-changed", G_CALLBACK (chooser_selection_changed_cb), NULL); g_signal_connect (chooser, "file-activated", G_CALLBACK (chooser_file_activated_cb), NULL); g_signal_connect (chooser, "update-preview", G_CALLBACK (chooser_update_preview_cb), NULL); gtk_box_pack_start (GTK_BOX (hbox), chooser, TRUE, TRUE, 0); button = gtk_button_new_with_label ("Properties"); g_signal_connect (button, "clicked", G_CALLBACK (properties_button_clicked_cb), chooser); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); button = gtk_button_new_with_label ("Tests"); g_signal_connect (button, "clicked", G_CALLBACK (tests_button_clicked_cb), chooser); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); g_object_unref (label_group); gtk_widget_show_all (win); gtk_window_present (GTK_WINDOW (win)); gtk_main (); return 0; }
/***************************************************************************** * run_session_save_as_dialog() *****************************************************************************/ void run_session_save_as_dialog(GtkWidget *UNUSED(widget), gpointer data) { SESSION *session = get_current_session(); char *directory = (char *) data; char *session_dir; DIR_LIST *pdir = session_dir_list; GError *error; /* create dialog if needed */ if (session_save_dialog == NULL) { create_session_save_dialog(); } /* add all session dirs as shortcut folders */ while (pdir != NULL) { if ((!pdir->save_shortcut)) { error = NULL; gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(session_save_dialog), pdir->name, &error); if (error != NULL) { PHASEX_ERROR("Error %d: %s\n", error->code, error->message); g_error_free(error); } pdir->save_shortcut = 1; } pdir = pdir->next; } /* set filename and current directory */ if ((directory == NULL) || (*directory == '\0')) { directory = session->directory; } /* if we have a directory, and it's not the sessiondump, set and select it */ if ((directory != NULL) && (strcmp(directory, user_session_dump_dir) != 0)) { gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(session_save_dialog), directory); } /* if there is no filename, try to set the current directory */ else if ((session->parent_dir != NULL) && (* (session->parent_dir) != '\0')) { gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_save_dialog), session->parent_dir); } else { gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_save_dialog), user_session_dir); } /* set position in session bank to save session */ /* session_io_start should already be set properly at this point. */ gtk_spin_button_set_value(GTK_SPIN_BUTTON(session_save_start_spin), (session_io_start + 1)); /* run the dialog and save if necessary */ if (gtk_dialog_run(GTK_DIALOG(session_save_dialog)) == GTK_RESPONSE_ACCEPT) { session_dir = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(session_save_dialog)); session_io_start = (unsigned int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(session_save_start_spin)) - 1; /* hide dialog and save session */ gtk_widget_hide(session_save_dialog); switch (setting_bank_mem_mode) { case BANK_MEM_AUTOSAVE: /* save session without overwrite protection */ if (save_session(session_dir, session_io_start) == 0) { update_gui_session_name(); save_session_bank(); } break; case BANK_MEM_WARN: case BANK_MEM_PROTECT: /* save session with overwrite protection */ if (!check_session_overwrite(session_dir)) { if (save_session(session_dir, session_io_start) == 0) { update_gui_session_name(); save_session_bank(); } } break; } g_free(session_dir); } else { /* save this widget for next time */ gtk_widget_hide(session_save_dialog); } }
/*! \brief pops up a Filechooser dialog to select a file \param data is a pointer to a MtxFileIO structure which contains important bits like the path to start, the filter, default filename and so on \see MtxFileIO \returns the path to the file or NULL if cancelled */ gchar * choose_file(MtxFileIO *data) { GtkWidget *dialog = NULL; GtkFileFilter *filter = NULL; GSList *filters = NULL; gchar *path = NULL; gchar *defdir = NULL; gchar *filename = NULL; gchar *tmpbuf = NULL; gchar **vector = NULL; const gchar *project = NULL; gint response = 0; gboolean res = FALSE; guint i = 0; ENTER(); if (!GTK_IS_WINDOW(data->parent)) data->parent = NULL; /* printf("choose_file\n"); printf("parent %p\n",(void *)data->parent); printf("on_top %s\n",data->on_top? "TRUE":"FALSE"); printf("filter %s\n",data->filter); printf("filename %s\n",data->filename); printf("default_filename %s\n",data->default_filename); printf("default_extension %s\n",data->default_extension); printf("absolute_path %s\n",data->absolute_path); printf("default_path %s\n",data->default_path); printf("external_path %s\n",data->external_path); printf("shortcut_folders %s\n",data->shortcut_folders); printf("project %s\n",data->project); printf("title %s\n",data->title); */ if (data->project) project = data->project; else project = DEFAULT_PROJECT; if (!data->title) data->title = g_strdup("Open File"); if ((data->action == GTK_FILE_CHOOSER_ACTION_OPEN) || (data->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)) { /*printf("ACTION_OPEN before gtk_file_chooser_dialog_new\n");*/ dialog = gtk_file_chooser_dialog_new(data->title, /*GTK_WINDOW(data->parent), */ 0, data->action, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); /*printf("after gtk_file_chooser_dialog_new\n");*/ if ((data->on_top) && (GTK_IS_WIDGET(data->parent))) gtk_window_set_transient_for(GTK_WINDOW(gtk_widget_get_toplevel(dialog)),GTK_WINDOW(data->parent)); if ((data->absolute_path) && (!data->default_path)) gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog),data->absolute_path); else if (data->default_path) { /*printf("should be using system path + %s\n",data->default_path);*/ path = g_build_filename(MTXSYSDATA,data->default_path,NULL); if (!g_file_test(path,G_FILE_TEST_IS_DIR)) { g_free(path); path = g_build_filename(HOME(),"mtx",data->project,data->default_path, NULL); /*printf("System path is not found, falling back to user path %s\n",path);*/ } gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog),path); g_free(path); } } else if (data->action == GTK_FILE_CHOOSER_ACTION_SAVE) { /*printf("ACTION_SAVE calling gtk_file_chooser_dialog_new\n");*/ dialog = gtk_file_chooser_dialog_new(data->title, /*GTK_WINDOW(data->parent), */ 0, data->action, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); /*printf("after gtk_file_chooser_dialog_new\n");*/ /* if ((data->on_top) && (GTK_IS_WIDGET(data->parent))) gtk_window_set_transient_for(GTK_WINDOW(gtk_widget_get_toplevel(dialog)),GTK_WINDOW(data->parent)); */ if (data->default_path) { defdir = g_build_filename(HOME(),"mtx",data->project,data->default_path, NULL); if (!g_file_test(defdir,G_FILE_TEST_IS_DIR)) g_mkdir(defdir,0755); } else defdir = g_build_filename(HOME(),"mtx",data->project, NULL); /* If filename passed check/adj path */ if (data->filename) { if (g_strrstr(data->filename,DATA_DIR) != NULL) { vector = g_strsplit(data->filename,PSEP,-1); tmpbuf = g_strconcat(defdir,PSEP,vector[g_strv_length(vector)-1],NULL); gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),defdir); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),vector[g_strv_length(vector)-1]); g_strfreev(vector); g_free(tmpbuf); } else gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),data->filename); } else { gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),defdir); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), data->default_filename ); } g_free(defdir); } else { EXIT(); return NULL; } /* Add shortcut folders... */ if (data->shortcut_folders) { vector = g_strsplit(data->shortcut_folders,",",-1); for (i=0;i<g_strv_length(vector);i++) { path = g_build_filename(MTXSYSDATA,vector[i],NULL); gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(dialog),path,NULL); g_free(path); path = g_build_filename(HOME(),"mtx",data->project,vector[i],NULL); gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(dialog),path,NULL); g_free(path); } g_strfreev(vector); } /* If default path switch to that place */ if ((data->external_path) && (!(data->default_path))) { /*printf("external path with no default path\n");*/ path = g_build_filename(HOME(),"mtx",data->project,data->external_path,NULL); if (!g_file_test(path,G_FILE_TEST_IS_DIR)) g_mkdir(path,0755); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog),path); g_free(path); } /* If filters, assign them CAUSES SEGFAULTS??? */ /* if (data->filter) { printf("data->filter is set to \"%s\"\n",data->filter); vector = g_strsplit(data->filter,",",-1); if (g_strv_length(vector)%2 > 0) goto afterfilter; for (i=0;i<g_strv_length(vector);i+=2) { filter = gtk_file_filter_new(); gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter),vector[i]); printf("Filter glob is set to \"%s\"\n",vector[i]); gtk_file_filter_set_name(GTK_FILE_FILTER(filter),vector[i+1]); printf("Filter name is set to \"%s\"\n",vector[i+1]); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog),filter); } gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog),filter); g_strfreev(vector); } */ afterfilter: /* Turn on overwriteconfirmation */ gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); g_signal_connect(G_OBJECT(dialog),"confirm-overwrite", G_CALLBACK (confirm_overwrite_callback), NULL); if (data->action == GTK_FILE_CHOOSER_ACTION_OPEN) { if (data->default_filename) { /*printf("data->default_filename is set to \"%s\"\n",data->default_filename);*/ gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(dialog),data->default_filename); } } /*printf("initiating dialog to run\n");*/ response = gtk_dialog_run (GTK_DIALOG (dialog)); /*printf("it returned \n");*/ if (response == GTK_RESPONSE_ACCEPT) { tmpbuf = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); if ((data->action == GTK_FILE_CHOOSER_ACTION_SAVE) && (data->default_extension)) { if(!g_str_has_suffix (tmpbuf,data->default_extension)) filename = g_strjoin(".",tmpbuf,data->default_extension,NULL); else filename = g_strdup(tmpbuf); } else filename = g_strdup(tmpbuf); g_free(tmpbuf); } filters = gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(dialog)); if (filters) { g_slist_foreach(filters, remove_filter ,dialog); g_slist_free(filters); } gtk_widget_destroy (dialog); EXIT(); return (filename); }
GtkFileChooser * ephy_create_file_chooser (const char *title, GtkWidget *parent, GtkFileChooserAction action, EphyFileFilterDefault default_filter) { GtkFileChooser *dialog; GtkFileFilter *filter[EPHY_FILE_FILTER_LAST]; g_autofree char *downloads_dir = NULL; GtkWidget *preview = gtk_image_new (); g_assert (GTK_IS_WINDOW (parent)); g_assert (default_filter >= 0 && default_filter <= EPHY_FILE_FILTER_LAST); dialog = GTK_FILE_CHOOSER (gtk_file_chooser_native_new (title, GTK_WINDOW (parent), action, NULL, _("_Cancel"))); gtk_native_dialog_set_modal (GTK_NATIVE_DIALOG (dialog), TRUE); downloads_dir = ephy_file_get_downloads_dir (); gtk_file_chooser_add_shortcut_folder (dialog, downloads_dir, NULL); if (action == GTK_FILE_CHOOSER_ACTION_OPEN || action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER || action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER) { gtk_file_chooser_native_set_accept_label (GTK_FILE_CHOOSER_NATIVE (dialog), _("_Open")); } else if (action == GTK_FILE_CHOOSER_ACTION_SAVE) { gtk_file_chooser_native_set_accept_label (GTK_FILE_CHOOSER_NATIVE (dialog), _("_Save")); } gtk_file_chooser_set_preview_widget (dialog, preview); gtk_file_chooser_set_use_preview_label (dialog, FALSE); g_signal_connect (dialog, "update-preview", G_CALLBACK (update_preview_cb), preview); if (default_filter != EPHY_FILE_FILTER_NONE) { filter[EPHY_FILE_FILTER_ALL_SUPPORTED] = ephy_file_chooser_add_mime_filter (dialog, _("All supported types"), "text/html", "application/xhtml+xml", "text/xml", "message/rfc822", /* MHTML */ "multipart/related", /* MHTML */ "application/x-mimearchive", /* MHTML */ "image/png", "image/jpeg", "image/gif", "image/webp", NULL); filter[EPHY_FILE_FILTER_WEBPAGES] = ephy_file_chooser_add_mime_filter (dialog, _("Web pages"), "text/html", "application/xhtml+xml", "text/xml", "message/rfc822", /* MHTML */ "multipart/related", /* MHTML */ "application/x-mimearchive", /* MHTML */ NULL); filter[EPHY_FILE_FILTER_IMAGES] = ephy_file_chooser_add_mime_filter (dialog, _("Images"), "image/png", "image/jpeg", "image/gif", "image/webp", NULL); filter[EPHY_FILE_FILTER_ALL] = ephy_file_chooser_add_pattern_filter (dialog, _("All files"), "*", NULL); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter[default_filter]); } return dialog; }
/* Caller must g_slist_free() the returned list .*/ GSList * ghid_dialog_file_select_multiple(gchar * title, gchar ** path, gchar * shortcuts) { GtkWidget *dialog; GSList *result = NULL; gchar *folder, *seed; GHidPort *out = &ghid_port; GtkFileFilter *no_filter; dialog = gtk_file_chooser_dialog_new (title, GTK_WINDOW (out->top_window), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER (dialog), TRUE); /* add a default filter for not filtering files */ no_filter = gtk_file_filter_new (); gtk_file_filter_set_name (no_filter, "all"); gtk_file_filter_add_pattern (no_filter, "*.*"); gtk_file_filter_add_pattern (no_filter, "*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), no_filter); /* in case we have a dialog for loading schematic files */ if (strcmp (title, _("Load schematics")) == 0) { /* add a filter for schematic files */ GtkFileFilter *sch_filter; sch_filter = gtk_file_filter_new (); gtk_file_filter_set_name (sch_filter, "sch"); gtk_file_filter_add_mime_type (sch_filter, "application/x-geda-schematic"); gtk_file_filter_add_pattern (sch_filter, "*.sch"); gtk_file_filter_add_pattern (sch_filter, "*.SCH"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), sch_filter); } if (path && *path) gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), *path); else { gchar *default_path; default_path = g_get_current_dir(); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), default_path); g_free(default_path); } if (shortcuts && *shortcuts) { folder = g_strdup (shortcuts); seed = folder; while ((folder = strtok (seed, ":")) != NULL) { gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog), folder, NULL); seed = NULL; } g_free (folder); } if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) { result = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (dialog)); folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog)); if (folder && path) { dup_string (path, folder); g_free (folder); } } gtk_widget_destroy (dialog); return result; }
/* Caller must g_free() the returned filename. */ gchar * ghid_fileselect (const char *title, const char *descr, char *default_file, char *default_ext, const char *history_tag, int flags) { GtkWidget *dialog; gchar *result = NULL; GHidPort *out = &ghid_port; gchar *path = NULL, *base = NULL; int history_pool = -1; int i; if (history_tag && *history_tag) { /* * I used a simple linear search here because the number of * entries in the array is likely to be quite small (5, maybe 10 at * the absolute most) and this function is used when pulling up * a file dialog box instead of something called over and over * again as part of moving elements or autorouting. So, keep it * simple.... */ history_pool = 0; while (history_pool < n_recent_dirs && strcmp (recent_dirs[history_pool].id, history_tag) != 0) { history_pool++; } /* * If we counted all the way to n_recent_dirs, that means we * didn't find our entry */ if (history_pool >= n_recent_dirs) { n_recent_dirs++; recent_dirs = (ghid_file_history *)realloc (recent_dirs, n_recent_dirs * sizeof (ghid_file_history)); if (recent_dirs == NULL) { fprintf (stderr, "%s(): realloc failed\n", __FUNCTION__); exit (1); } recent_dirs[history_pool].id = strdup (history_tag); /* Initialize the entries in our history list to all be NULL */ for (i = 0; i < NHIST; i++) { recent_dirs[history_pool].history[i] = NULL; } } } if (default_file && *default_file) { path = g_path_get_dirname (default_file); base = g_path_get_basename (default_file); } dialog = gtk_file_chooser_dialog_new (title, GTK_WINDOW (out->top_window), (flags & HID_FILESELECT_READ) ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); if (path && *path ) { gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), path); g_free (path); } else { gchar *default_path; default_path = g_get_current_dir(); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), default_path); g_free(default_path); } if (base && *base) { /* default file is only supposed to be for writing, not reading */ if (!(flags & HID_FILESELECT_READ)) { gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), base); } g_free (base); } for (i = 0; i < NHIST && recent_dirs[history_pool].history[i] != NULL ; i++) { gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog), recent_dirs[history_pool].history[i], NULL); } if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) { result = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); if (result != NULL) path = g_path_get_dirname (result); else path = NULL; /* update the history list */ if (path != NULL) { char *tmps, *tmps2; int k = 0; /* * Put this at the top of the list and bump everything else * down but skip any old entry of this directory * */ while ( k < NHIST && recent_dirs[history_pool].history[k] != NULL && strcmp ( recent_dirs[history_pool].history[k], path) == 0) { k++; } tmps = recent_dirs[history_pool].history[k]; recent_dirs[history_pool].history[0] = path; for (i = 1 ; i < NHIST ; i++) { /* store our current entry, but skip duplicates */ while (i + k < NHIST && recent_dirs[history_pool].history[i + k] != NULL && strcmp ( recent_dirs[history_pool].history[i + k], path) == 0) { k++; } if (i + k < NHIST) tmps2 = recent_dirs[history_pool].history[i + k]; else tmps2 = NULL; /* move down the one we stored last time */ recent_dirs[history_pool].history[i] = tmps; /* and remember the displace entry */ tmps = tmps2; } /* * the last one has fallen off the end of the history list * so we need to free() it. */ if (tmps) { free (tmps); } } #ifdef DEBUG printf ("\n\n-----\n\n"); for (i = 0 ; i < NHIST ; i++) { printf ("After update recent_dirs[%d].history[%d] = \"%s\"\n", history_pool, i, recent_dirs[history_pool].history[i] != NULL ? recent_dirs[history_pool].history[i] : "NULL"); } #endif } gtk_widget_destroy (dialog); return result; }
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; #if 0 /* native file dialogs */ #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 #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 * gimp_file_dialog_new (Gimp *gimp, GtkFileChooserAction action, const gchar *title, const gchar *role, const gchar *stock_id, const gchar *help_id) { GimpFileDialog *dialog; GSList *file_procs; const gchar *automatic; const gchar *automatic_help_id; const gchar *pictures; gboolean local_only; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); g_return_val_if_fail (title != NULL, NULL); g_return_val_if_fail (role != NULL, NULL); g_return_val_if_fail (stock_id != NULL, NULL); g_return_val_if_fail (help_id != NULL, NULL); switch (action) { case GTK_FILE_CHOOSER_ACTION_OPEN: file_procs = gimp->plug_in_manager->load_procs; automatic = _("Automatically Detected"); automatic_help_id = GIMP_HELP_FILE_OPEN_BY_EXTENSION; /* FIXME */ local_only = (gimp_pdb_lookup_procedure (gimp->pdb, "file-uri-load") == NULL); break; case GTK_FILE_CHOOSER_ACTION_SAVE: file_procs = gimp->plug_in_manager->save_procs; automatic = _("By Extension"); automatic_help_id = GIMP_HELP_FILE_SAVE_BY_EXTENSION; /* FIXME */ local_only = (gimp_pdb_lookup_procedure (gimp->pdb, "file-uri-save") == NULL); break; default: g_return_val_if_reached (NULL); return NULL; } dialog = g_object_new (GIMP_TYPE_FILE_DIALOG, "title", title, "role", role, "action", action, "local-only", local_only, "do-overwrite-confirmation", TRUE, NULL); gtk_dialog_add_buttons (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, stock_id, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_help_connect (GTK_WIDGET (dialog), gimp_file_dialog_help_func, help_id, dialog); if (GIMP_GUI_CONFIG (gimp->config)->show_help_button && help_id) { GtkWidget *action_area = GTK_DIALOG (dialog)->action_area; GtkWidget *button = gtk_button_new_from_stock (GTK_STOCK_HELP); gtk_box_pack_end (GTK_BOX (action_area), button, FALSE, TRUE, 0); gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (action_area), button, TRUE); gtk_widget_show (button); g_object_set_data_full (G_OBJECT (dialog), "gimp-dialog-help-id", g_strdup (help_id), (GDestroyNotify) g_free); g_signal_connect (button, "clicked", G_CALLBACK (gimp_file_dialog_help_clicked), dialog); g_object_set_data (G_OBJECT (dialog), "gimp-dialog-help-button", button); } pictures = gimp_user_directory (GIMP_USER_DIRECTORY_PICTURES); if (pictures) gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog), pictures, NULL); gimp_file_dialog_add_preview (dialog, gimp); gimp_file_dialog_add_filters (dialog, gimp, file_procs); gimp_file_dialog_add_proc_selection (dialog, gimp, file_procs, automatic, automatic_help_id); dialog->progress = gimp_progress_box_new (); gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dialog)->vbox), dialog->progress, FALSE, FALSE, 0); return GTK_WIDGET (dialog); }