static int open(GtkWidget* parent_window, gboolean not_import) { GtkWidget* dialog; int val; const char* title; char* filter = file_ops_join_ext("*", dish_file_extension()); global_settings* settings = settings_get(); if (not_import) title = "Open bank"; else title = "Import bank"; dialog = gtk_file_chooser_dialog_new( title, GTK_WINDOW(parent_window), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); if (dish_file_has_state()) { const char* tmp = 0; tmp = dish_file_state_is_full() ? dish_file_state_parent_dir() : dish_file_state_bank_dir(); gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(dialog), tmp); } else gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), settings->last_bank_dir); file_chooser_add_filter(dialog, "Petri-Foo files", filter); file_chooser_add_filter(dialog, "All files", "*"); if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { char* name = (char*) gtk_file_chooser_get_filename( GTK_FILE_CHOOSER(dialog)); val = (not_import) ? dish_file_read(name) : dish_file_import(name); if (val < 0) { GtkWidget* msg = gtk_message_dialog_new(GTK_WINDOW(dialog), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Failed to read bank %s\n.", name); g_signal_connect_swapped(G_OBJECT(msg), "response", G_CALLBACK(gtk_widget_destroy), msg); gtk_widget_show (msg); } else { if (recent_manager && not_import) gtk_recent_manager_add_item(recent_manager, g_filename_to_uri(name, NULL, NULL)); if (settings->last_bank_dir) free(settings->last_bank_dir); settings->last_bank_dir = g_path_get_dirname(name); } } else { val = -1; } gtk_widget_destroy(dialog); free(filter); return val; }
/* 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; }
/* 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); 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 (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; }
bool wxGtkFileCtrl::Create( wxWindow *parent, wxWindowID id, const wxString& defaultDirectory, const wxString& defaultFileName, const wxString& wildCard, long style, const wxPoint& pos, const wxSize& size, const wxString& name ) { if ( !PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ) ) { wxFAIL_MSG( wxT( "wxGtkFileCtrl creation failed" ) ); return false; } GtkFileChooserAction gtkAction = GTK_FILE_CHOOSER_ACTION_OPEN; if ( style & wxFC_SAVE ) gtkAction = GTK_FILE_CHOOSER_ACTION_SAVE; m_widget = gtk_alignment_new ( 0, 0, 1, 1 ); g_object_ref(m_widget); m_fcWidget = GTK_FILE_CHOOSER( gtk_file_chooser_widget_new(gtkAction) ); gtk_widget_show ( GTK_WIDGET( m_fcWidget ) ); gtk_container_add ( GTK_CONTAINER ( m_widget ), GTK_WIDGET( m_fcWidget ) ); m_focusWidget = GTK_WIDGET( m_fcWidget ); g_signal_connect ( m_fcWidget, "file-activated", G_CALLBACK ( gtkfilechooserwidget_file_activated_callback ), this ); g_signal_connect ( m_fcWidget, "current-folder-changed", G_CALLBACK ( gtkfilechooserwidget_folder_changed_callback ), this ); g_signal_connect ( m_fcWidget, "selection-changed", G_CALLBACK ( gtkfilechooserwidget_selection_changed_callback ), this ); m_fc.SetWidget( m_fcWidget ); if ( style & wxFC_MULTIPLE ) gtk_file_chooser_set_select_multiple( m_fcWidget, true ); SetWildcard( wildCard ); // if defaultDir is specified it should contain the directory and // defaultFileName should contain the default name of the file, however if // directory is not given, defaultFileName contains both wxFileName fn; if ( defaultDirectory.empty() ) fn.Assign( defaultFileName ); else if ( !defaultFileName.empty() ) fn.Assign( defaultDirectory, defaultFileName ); else fn.AssignDir( defaultDirectory ); // set the initial file name and/or directory const wxString dir = fn.GetPath(); if ( !dir.empty() ) { gtk_file_chooser_set_current_folder( m_fcWidget, dir.fn_str() ); } const wxString fname = fn.GetFullName(); if ( style & wxFC_SAVE ) { if ( !fname.empty() ) { gtk_file_chooser_set_current_name( m_fcWidget, fname.fn_str() ); } } else // wxFC_OPEN { if ( !fname.empty() ) { gtk_file_chooser_set_filename( m_fcWidget, fn.GetFullPath().fn_str() ); } } m_parent->DoAddChild( this ); PostCreation( size ); return TRUE; }
JNIEXPORT jobject JNICALL Java_com_sun_glass_ui_gtk_GtkCommonDialogs__1showFileChooser (JNIEnv *env, jclass clazz, jlong parent, jstring folder, jstring name, jstring title, jint type, jboolean multiple, jobjectArray jFilters, jint default_filter_index) { jobjectArray jFileNames = NULL; char* filename; jstring jfilename; const char* chooser_folder; const char* chooser_filename; const char* chooser_title; const int chooser_type = type == 0 ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE; if (!jstring_to_utf_get(env, folder, &chooser_folder)) { return create_empty_result(); } if (!jstring_to_utf_get(env, title, &chooser_title)) { jstring_to_utf_release(env, folder, chooser_folder); return create_empty_result(); } if (!jstring_to_utf_get(env, name, &chooser_filename)) { jstring_to_utf_release(env, folder, chooser_folder); jstring_to_utf_release(env, title, chooser_title); return create_empty_result(); } GtkWidget* chooser = gtk_file_chooser_dialog_new(chooser_title, gdk_window_handle_to_gtk(parent), static_cast<GtkFileChooserAction>(chooser_type), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, (chooser_type == GTK_FILE_CHOOSER_ACTION_OPEN ? GTK_STOCK_OPEN : GTK_STOCK_SAVE), GTK_RESPONSE_ACCEPT, NULL); if (chooser_type == GTK_FILE_CHOOSER_ACTION_SAVE) { gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(chooser), chooser_filename); gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER (chooser), TRUE); } gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(chooser), (JNI_TRUE == multiple)); gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(chooser), chooser_folder); GSList* filters = setup_GtkFileFilters(GTK_FILE_CHOOSER(chooser), env, jFilters, default_filter_index); if (gtk_dialog_run(GTK_DIALOG(chooser)) == GTK_RESPONSE_ACCEPT) { GSList* fnames_gslist = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(chooser)); guint fnames_list_len = g_slist_length(fnames_gslist); LOG1("FileChooser selected files: %d\n", fnames_list_len) if (fnames_list_len > 0) { jFileNames = env->NewObjectArray((jsize)fnames_list_len, jStringCls, NULL); for (guint i = 0; i < fnames_list_len; i++) { filename = (char*)g_slist_nth(fnames_gslist, i)->data; LOG1("Add [%s] into returned filenames\n", filename) jfilename = env->NewStringUTF(filename); env->SetObjectArrayElement(jFileNames, (jsize)i, jfilename); } g_slist_foreach(fnames_gslist, (GFunc) free_fname, NULL); g_slist_free(fnames_gslist); } }
static void save_profile_to_file_cb(RoccatProfilePage *profile_page, gpointer user_data) { ArvoconfigWindow *window = ARVOCONFIG_WINDOW(user_data); ArvoconfigWindowPrivate *priv = window->priv; GtkWidget *dialog; gchar *filename, *path; gchar *temp_filename; GError *error = NULL; GtkFileFilter *windows_filter; GtkFileFilter *linux_filter; GtkFileFilter *all_filter; GtkFileFilter *filter; guint profile_index = roccat_config_window_get_page_index(ROCCAT_CONFIG_WINDOW(window), profile_page); ArvoRkp *rkp; rkp = arvoconfig_profile_page_get_rkp(ARVOCONFIG_PROFILE_PAGE(profile_page)); dialog = gtk_file_chooser_dialog_new(_("Save profile"), GTK_WINDOW(window), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); windows_filter = windows_file_filter_new(); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), windows_filter); linux_filter = linux_file_filter_new(); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), linux_filter); all_filter = all_file_filter_new(); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), all_filter); path = arvo_configuration_get_rkp_save_path(priv->config); gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), path); g_free(path); filename = arvo_create_filename_proposition(rkp, profile_index); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), filename); g_free(filename); if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(dialog)); filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); temp_filename = roccat_create_filename_with_extension(filename, ROCCAT_KEYBOARD_PROFILE_EXTENSION); g_free(filename); path = g_path_get_dirname(temp_filename); arvo_configuration_set_rkp_save_path(priv->config, path); g_free(path); if (filter != linux_filter) arvo_linux_rkp_to_windows(rkp); arvo_rkp_write_with_path(temp_filename, rkp, &error); g_free(temp_filename); if (error) { roccat_warning_dialog(GTK_WINDOW(dialog), _("Could not save profile"), error->message); g_error_free(error); } } gtk_widget_destroy(dialog); arvo_rkp_free(rkp); }
char * S9xOpenROMDialog () { GtkWidget *dialog; GtkFileFilter *filter; char *filename = NULL; gint result; const char *extensions[] = { "*.smc", "*.SMC", "*.fig", "*.FIG", "*.sfc", "*.SFC", "*.jma", "*.JMA", "*.zip", "*.ZIP", "*.gd3", "*.GD3", "*.swc", "*.SWC", "*.gz" , "*.GZ", "*.bs", "*.BS", NULL }; top_level->pause_from_focus_change (); dialog = gtk_file_chooser_dialog_new (_("Open SNES ROM Image"), top_level->get_window (), GTK_FILE_CHOOSER_ACTION_OPEN, "gtk-cancel", GTK_RESPONSE_CANCEL, "gtk-open", GTK_RESPONSE_ACCEPT, NULL); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("SNES ROM Images")); for (int i = 0; extensions[i]; i++) { gtk_file_filter_add_pattern (filter, extensions[i]); } gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("All Files")); gtk_file_filter_add_pattern (filter, "*.*"); gtk_file_filter_add_pattern (filter, "*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); if (!gui_config->last_directory.empty ()) { gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), gui_config->last_directory.c_str ()); } result = gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_hide (dialog); if (result == GTK_RESPONSE_ACCEPT) { char *directory; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); directory = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog)); if (directory) { gui_config->last_directory = directory; g_free (directory); } } else { filename = NULL; } gtk_widget_destroy (dialog); top_level->unpause_from_focus_change (); return filename; }
static void thunar_uca_editor_command_clicked (ThunarUcaEditor *uca_editor) { GtkFileFilter *filter; GtkWidget *chooser; gchar *filename; gchar **argv = NULL; gchar *s; gint argc; g_return_if_fail (THUNAR_UCA_IS_EDITOR (uca_editor)); chooser = gtk_file_chooser_dialog_new (_("Select an Application"), GTK_WINDOW (uca_editor), GTK_FILE_CHOOSER_ACTION_OPEN, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_Open"), GTK_RESPONSE_ACCEPT, NULL); gtk_dialog_set_default_response (GTK_DIALOG (chooser), GTK_RESPONSE_ACCEPT); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (chooser), TRUE); /* add file chooser 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 (chooser), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Executable Files")); gtk_file_filter_add_mime_type (filter, "application/x-csh"); gtk_file_filter_add_mime_type (filter, "application/x-executable"); gtk_file_filter_add_mime_type (filter, "application/x-perl"); gtk_file_filter_add_mime_type (filter, "application/x-python"); gtk_file_filter_add_mime_type (filter, "application/x-ruby"); gtk_file_filter_add_mime_type (filter, "application/x-shellscript"); gtk_file_filter_add_pattern (filter, "*.pl"); gtk_file_filter_add_pattern (filter, "*.py"); gtk_file_filter_add_pattern (filter, "*.rb"); gtk_file_filter_add_pattern (filter, "*.sh"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (chooser), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Perl Scripts")); gtk_file_filter_add_mime_type (filter, "application/x-perl"); gtk_file_filter_add_pattern (filter, "*.pl"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Python Scripts")); gtk_file_filter_add_mime_type (filter, "application/x-python"); gtk_file_filter_add_pattern (filter, "*.py"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Ruby Scripts")); gtk_file_filter_add_mime_type (filter, "application/x-ruby"); gtk_file_filter_add_pattern (filter, "*.rb"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Shell Scripts")); gtk_file_filter_add_mime_type (filter, "application/x-csh"); gtk_file_filter_add_mime_type (filter, "application/x-shellscript"); gtk_file_filter_add_pattern (filter, "*.sh"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter); /* use the bindir as default folder */ gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser), BINDIR); /* setup the currently selected file */ filename = gtk_editable_get_chars (GTK_EDITABLE (uca_editor->command_entry), 0, -1); if (G_LIKELY (filename != NULL)) { /* use only the first argument */ s = strchr (filename, ' '); if (G_UNLIKELY (s != NULL)) *s = '\0'; /* check if we have a file name */ if (G_LIKELY (*filename != '\0')) { /* check if the filename is not an absolute path */ if (G_LIKELY (!g_path_is_absolute (filename))) { /* try to lookup the filename in $PATH */ s = g_find_program_in_path (filename); if (G_LIKELY (s != NULL)) { /* use the absolute path instead */ g_free (filename); filename = s; } } /* check if we have an absolute path now */ if (G_LIKELY (g_path_is_absolute (filename))) gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (chooser), filename); } /* release the filename */ g_free (filename); } /* run the chooser dialog */ if (gtk_dialog_run (GTK_DIALOG (chooser)) == GTK_RESPONSE_ACCEPT) { /* determine the path to the selected file */ filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser)); /* check if we need to quote the filename */ if (!g_shell_parse_argv (filename, &argc, &argv, NULL) || argc > 1) { /* shell is unable to interpret properly without quoting */ s = g_shell_quote (filename); g_free (filename); filename = s; } g_strfreev (argv); /* append %f to filename, user may change that afterwards */ s = g_strconcat (filename, " %f", NULL); gtk_entry_set_text (GTK_ENTRY (uca_editor->command_entry), s); g_free (filename); g_free (s); } gtk_widget_destroy (chooser); }
/***************************************************************************** * 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); }
static void ui_choose_file_or_dir(gchar *title, const gchar *buttonName, gboolean saving, gboolean directory, fileChoosenCallback callback, const gchar *currentPath, const gchar *defaultFilename, const char *filterstring, const char *filtername, gpointer user_data) { GtkWidget *dialog; struct file_chooser_tuple *tuple; GtkWidget *button; gchar *path = NULL; g_assert (!(saving & directory)); g_assert (!(defaultFilename && !saving)); if (!currentPath) conf_get_str_value (ENCLOSURE_DOWNLOAD_PATH, &path); else path = g_strdup (currentPath); dialog = gtk_file_chooser_dialog_new (title, GTK_WINDOW (liferea_shell_get_window ()), (directory?GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER: (saving ? GTK_FILE_CHOOSER_ACTION_SAVE : GTK_FILE_CHOOSER_ACTION_OPEN)), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); if (saving) gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); tuple = g_new0 (struct file_chooser_tuple, 1); tuple->dialog = dialog; tuple->func = callback; tuple->user_data = user_data; button = gtk_dialog_add_button (GTK_DIALOG (dialog), buttonName, GTK_RESPONSE_ACCEPT); gtk_widget_set_can_default (button, TRUE); gtk_widget_grab_default (button); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (ui_choose_file_save_cb), tuple); if (path && g_file_test (path, G_FILE_TEST_EXISTS)) { if (directory || defaultFilename) gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), path); else gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dialog), path); } if (defaultFilename) gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), defaultFilename); if (filterstring && filtername) { GtkFileFilter *filter, *allfiles; filter = gtk_file_filter_new (); gtk_file_filter_add_pattern (filter, filterstring); gtk_file_filter_set_name (filter, filtername); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); allfiles = gtk_file_filter_new (); gtk_file_filter_add_pattern (allfiles, "*"); gtk_file_filter_set_name (allfiles, _("All Files")); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), allfiles); } gtk_widget_show_all (dialog); g_free (path); }
int main(int argc, char **argv) { struct arguments argument; struct arguments *pargument = &argument; //InitOpenAL(); // potential memory leak source = 0; pargument->first = 1; pargument->endless_check = 0; pargument->continue_count = 0; pargument->offset = 0; pargument->elapsed = g_timer_new(); GtkWidget *window, *hpaned, *pause_button, *bitrate_label, *chooser1, *chooser2, *chooser3, *vboxl, *vboxr, *check, *continue_check, *continue_label, *next_button, *button2, *spin_int, *progressbar, *button_hbox, *continue_hbox; GtkFileFilter *filter1, *filter2; gtk_init(&argc, &argv); //g_remove("list.txt"); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); pargument->adjust = (GtkAdjustment*)gtk_adjustment_new(0, 0, 100, 1, 1, 1); #if GTK3 progressbar = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, adjust); #endif progressbar = gtk_hscale_new(pargument->adjust); gtk_scale_set_draw_value ((GtkScale*)progressbar, FALSE); gtk_window_set_title(GTK_WINDOW(window), "lelele player"); pargument->label = gtk_label_new (""); pargument->title_label = gtk_label_new(""); pargument->album_label = gtk_label_new(""); pargument->artist_label = gtk_label_new(""); gtk_label_set_line_wrap((GtkLabel*)pargument->title_label, TRUE); gtk_label_set_line_wrap((GtkLabel*)pargument->artist_label, TRUE); gtk_label_set_line_wrap((GtkLabel*)pargument->album_label, TRUE); continue_label = gtk_label_new("Number of songs played\n -1 to go endless"); gtk_container_set_border_width(GTK_CONTAINER(window), 10); gtk_widget_set_size_request(window, 500, 250); hpaned = gtk_hpaned_new(); spin_int = gtk_spin_button_new_with_range(-1, 10000, 1); gtk_spin_button_set_value ((GtkSpinButton*)spin_int, 1); pause_button = gtk_button_new_with_mnemonic("_Play/Pause"); next_button = gtk_button_new_with_mnemonic("Next"); check = gtk_check_button_new_with_label ("Endless mode."); //continue_check = gtk_check_button_new_with_label("Play this number of songs."); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (destroy), NULL); g_signal_connect (G_OBJECT(pause_button), "clicked", G_CALLBACK(play), pargument); g_signal_connect (G_OBJECT(next_button), "clicked", G_CALLBACK(next), pargument); g_signal_connect (G_OBJECT(check), "toggled", G_CALLBACK(check_toggled), pargument); //g_signal_connect(G_OBJECT(continue_check), "toggled", G_CALLBACK(continue_check_toggled), spin_int); g_signal_connect(G_OBJECT(spin_int), "value-changed", G_CALLBACK(continue_spin_count), pargument); g_signal_connect(G_OBJECT(progressbar), "value-changed", G_CALLBACK(slider_changed), pargument); /* Create two buttons, one to select a folder and one to select a file. */ chooser1 = gtk_file_chooser_button_new ("Chooser a Folder", GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); chooser2 = gtk_file_chooser_button_new ("Chooser a Folder", GTK_FILE_CHOOSER_ACTION_OPEN); chooser3 = gtk_file_chooser_button_new ("Choose a folder for config (may take some time)", GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); /* Monitor when the selected folder or file are changed. */ g_signal_connect (G_OBJECT (chooser2), "selection_changed", G_CALLBACK (file_changed), pargument); g_signal_connect (G_OBJECT (chooser1), "selection_changed", G_CALLBACK(folder_changed), pargument); g_signal_connect (G_OBJECT (chooser3), "selection_changed", G_CALLBACK (config_folder_changed), pargument); /* Set both file chooser buttons to the location of the user's home directory. */ gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser2), g_get_home_dir()); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser1), g_get_home_dir()); /* Provide a filter to show all files and one to shown only 3 types of images. */ filter1 = gtk_file_filter_new (); filter2 = gtk_file_filter_new (); gtk_file_filter_set_name (filter1, "Audio Files"); gtk_file_filter_set_name (filter2, "All Files"); gtk_file_filter_add_pattern (filter1, "*.mp3"); gtk_file_filter_add_pattern (filter1, "*.flac"); gtk_file_filter_add_pattern (filter1, "*.aac"); gtk_file_filter_add_pattern (filter2, "*"); /* Add the both filters to the file chooser button that selects files. */ gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser2), filter1); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser2), filter2); //gtk_widget_set_sensitive(spin_int, FALSE); vboxl = gtk_vbox_new (TRUE, 5); vboxr = gtk_vbox_new (TRUE, 5); button_hbox = gtk_hbox_new (TRUE, 5); continue_hbox= gtk_hbox_new (TRUE, 5); gtk_box_set_homogeneous(GTK_BOX(vboxr), FALSE); gtk_box_set_homogeneous(GTK_BOX(continue_hbox), FALSE); gtk_box_pack_start_defaults (GTK_BOX (vboxl), chooser1); gtk_box_pack_start_defaults (GTK_BOX (vboxl), chooser2); // gtk_box_pack_start_defaults (GTK_BOX (vboxl), chooser3); //gtk_box_pack_start_defaults (GTK_BOX (vboxl), check); gtk_box_pack_start_defaults (GTK_BOX (vboxl), continue_hbox); gtk_box_pack_start_defaults (GTK_BOX(continue_hbox), continue_label); gtk_box_pack_start_defaults (GTK_BOX(continue_hbox), spin_int); gtk_box_pack_start_defaults (GTK_BOX (vboxl), button_hbox); gtk_box_pack_start_defaults (GTK_BOX (button_hbox), pause_button); gtk_box_pack_start_defaults (GTK_BOX(button_hbox), next_button); gtk_box_pack_start_defaults (GTK_BOX(vboxl), progressbar); gtk_box_pack_start(GTK_BOX (vboxr), pargument->label, FALSE, FALSE, 1); gtk_box_pack_start(GTK_BOX (vboxr), pargument->title_label, FALSE, FALSE, 1); gtk_box_pack_start(GTK_BOX (vboxr), pargument->album_label, FALSE, FALSE, 1); gtk_box_pack_start(GTK_BOX (vboxr), pargument->artist_label, FALSE, FALSE, 1); #ifdef GTK3 vboxl = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); vboxr = gtk_vboxr_new (GTK_ORIENTATION_VERTICAL, 5); gtk_box_pack_start (GTK_BOX (vboxl), chooser1, TRUE, TRUE, 3); gtk_box_pack_start (GTK_BOX (vboxl), chooser2, TRUE, TRUE, 3); gtk_box_pack_start (GTK_BOX (vboxl), pause_button, TRUE, TRUE, 3); gtk_box_pack_start (GTK_BOX(vboxl), next_button, TRUE, TRUE, 3); gtk_box_pack_start (GTK_BOX (vboxl), pargument->label, TRUE, TRUE, 3); gtk_box_pack_start (GTK_BOX (vboxl), check, TRUE, TRUE, 3); gtk_box_pack_start (GTK_BOX(vboxl), continue_check, TRUE, TRUE, 3); gtk_box_pack_start (GTK_BOX(vboxl), spin_int, TRUE, TRUE, 3); gtk_box_pack_start (GTK_BOX(vboxl), progressbar, TRUE, TRUE, 3); gtk_box_pack_start (GTK_BOX (vboxr), pargument->label, TRUE, TRUE, 3); gtk_box_pack_start_defaults (GTK_BOX (vboxr), pargument->title_label, TRUE, TRUE, 3); gtk_box_pack_start_defaults (GTK_BOX (vboxr), pargument->album_label, TRUE, TRUE, 3); gtk_box_pack_start_defaults (GTK_BOX (vboxr), pargument->artist_label, TRUE, TRUE, 3); #endif gtk_paned_pack1(GTK_PANED(hpaned), vboxl, FALSE, FALSE); gtk_paned_pack2(GTK_PANED(hpaned), vboxr, TRUE, FALSE); gtk_container_add (GTK_CONTAINER (window), hpaned); gtk_widget_show_all(window); gtk_main(); return 0; }
void sample_save_as_cb(GtkWidget * widget, gpointer data) { GtkWidget *dialog; gint win_width, win_height; sw_view * view = (sw_view *)data; sw_sample * sample; GtkWidget * save_options; GtkWidget * frame; GtkWidget * hbox; GtkWidget * label; GtkWidget * option_menu; GtkWidget * save_menu; struct stat statbuf; gchar *filename; gint retval; save_as_data * sd; char buf[512]; win_width = gdk_screen_width () / 2; win_height = gdk_screen_height () / 2; sample = view->sample; dialog = gtk_file_chooser_dialog_new (_("Sweep: Save file"), GTK_WINDOW(view->window), 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); attach_window_close_accel(GTK_WINDOW(dialog)); sweep_set_window_icon (GTK_WINDOW(dialog)); save_options = gtk_hbox_new (TRUE, 1); frame = gtk_frame_new (_("Save Options")); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN); gtk_box_pack_start (GTK_BOX (save_options), frame, TRUE, TRUE, 4); hbox = gtk_hbox_new (FALSE, 4); gtk_container_set_border_width (GTK_CONTAINER (hbox), 4); gtk_container_add (GTK_CONTAINER (frame), hbox); gtk_widget_show (hbox); label = gtk_label_new (_("Determine File Type:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); option_menu = gtk_option_menu_new (); gtk_box_pack_start (GTK_BOX (hbox), option_menu, TRUE, TRUE, 0); gtk_widget_show (option_menu); save_menu = create_save_menu (sample); gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), save_menu); gtk_widget_show (frame); /* pack the containing save_options hbox into the save-dialog */ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), save_options, FALSE, FALSE, 0); gtk_widget_show (save_options); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); gtk_widget_set_size_request (dialog, win_width, win_height); if (strcmp (g_path_get_dirname(sample->pathname), ".") == 0) { char last_save [512]; prefs_get_string (LAST_SAVE_KEY, last_save, sizeof (last_save), ""); if (last_save [0]) { gchar * last_save_dir = g_dirname (last_save); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog), last_save_dir); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(dialog), sample->pathname); g_free (last_save_dir); } } else { retval = gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(dialog), sample->pathname); /* FIXME: bug (local only?) causes gtk_file_chooser_set_filename to fail silently in some cases*/ filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); //printf("filename pre: %s\n", filename); //printf("sample->pathname: %s\n", sample->pathname); } retval = gtk_dialog_run (GTK_DIALOG (dialog)); filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); //printf("filename post: %s\n", filename); sample = view->sample; sd = g_malloc (sizeof (save_as_data)); sd->sample = sample; sd->pathname = filename; if (retval == GTK_RESPONSE_ACCEPT) { if (!sweep_dir_exists (filename)) { g_free (sd); g_free (filename); return; } if (stat (filename, &statbuf) == -1) { switch (errno) { case ENOENT: /* If it doesn't exist, it's ok to save as */ overwrite_ok_cb (NULL, sd); break; default: sweep_perror (errno, filename); break; } } else { /* file exists */ if (access(filename, W_OK) == -1) { sweep_perror (errno, _("You are not allowed to write to\n%s"), filename); } else { snprintf (buf, sizeof (buf), _("%s exists. Overwrite?"), filename); question_dialog_new (sample, _("File exists"), buf, _("Overwrite"), _("Don't overwrite"), G_CALLBACK (overwrite_ok_cb), sd, G_CALLBACK (overwrite_cancel_cb), sd, SWEEP_EDIT_MODE_META); } } /* FIXME: wrapped this due to the above gtk_file_chooser_set_filename problem */ } else if (sd->pathname != NULL) { gchar msg [1024]; snprintf (msg, sizeof (msg), _("Save as %s cancelled"), g_path_get_basename (sd->pathname)); sample_set_tmp_message (sd->sample, msg); } else { g_free (sd); g_free (filename); } gtk_widget_destroy (dialog); }
/* * Start the dialog that ask to the user where save the image * containing the screenshot. */ void start_save_image_dialog (GtkToolButton *toolbutton, GtkWindow *parent) { GtkWidget *preview = NULL; gint preview_width = 128; gint preview_height = 128; GdkPixbuf *preview_pixbuf = NULL; gchar *filename = ""; gchar *filename_copy = ""; gchar *supported_extension = ".pdf"; gint run_status = GTK_RESPONSE_NO; gboolean screenshot = FALSE; GdkPixbuf *buf = grab_screenshot (); GtkWidget *chooser = gtk_file_chooser_dialog_new (gettext ("Export as pdf"), parent, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE_AS, GTK_RESPONSE_ACCEPT, NULL); gtk_window_set_modal (GTK_WINDOW (chooser), TRUE); gtk_window_set_keep_above (GTK_WINDOW (chooser), TRUE); gtk_window_set_title (GTK_WINDOW (chooser), gettext ("Choose a file")); /* Save the preview in a buffer. */ preview = gtk_image_new (); preview_pixbuf = gdk_pixbuf_scale_simple (buf, preview_width, preview_height, GDK_INTERP_BILINEAR); gtk_image_set_from_pixbuf (GTK_IMAGE (preview), preview_pixbuf); gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (chooser), preview); g_object_unref (preview_pixbuf); preview_pixbuf = NULL; gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser), get_project_dir ()); filename = get_default_filename (); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (chooser), filename); start_virtual_keyboard (); run_status = gtk_dialog_run (GTK_DIALOG (chooser)); if (run_status == GTK_RESPONSE_ACCEPT) { g_free (filename); filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser)); filename_copy = g_strdup_printf ("%s", filename); screenshot = TRUE; supported_extension = ".png"; if (!g_str_has_suffix (filename, supported_extension)) { g_free (filename_copy); filename_copy = g_strdup_printf ("%s%s", filename, supported_extension); } g_free (filename); filename = filename_copy; if (file_exists (filename)) { gint result = show_override_dialog (GTK_WINDOW (chooser)); if ( result == GTK_RESPONSE_NO) { screenshot = FALSE; } } else { FILE *stream = g_fopen (filename, "w"); if (stream == NULL) { show_could_not_write_dialog (GTK_WINDOW (chooser)); } else { fclose (stream); } } } stop_virtual_keyboard (); gtk_widget_destroy (preview); preview = NULL; if (chooser != NULL) { gtk_widget_destroy (chooser); chooser = NULL; } if (screenshot) { /* Store the buffer on file. */ save_pixbuf_on_png_file (buf, filename); /* Add to the list of the artefacts created in the session. */ add_artifact (filename); } g_free (filename); filename = NULL; g_object_unref (buf); buf = NULL; }
static int basic_save_as(GtkWidget* parent_window, gboolean not_export) { GtkWidget *dialog; int val; const char* title; char* filter = file_ops_join_ext("*", dish_file_extension()); char* untitled_dish = file_ops_join_ext(untitled_name, dish_file_extension()); global_settings* settings = settings_get(); if (not_export) title = "Basic Save bank as"; else title = "Basic Export as"; dialog = gtk_file_chooser_dialog_new(title, GTK_WINDOW(parent_window), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE_AS, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_do_overwrite_confirmation( GTK_FILE_CHOOSER(dialog), TRUE); if (!dish_file_has_state()) { gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), settings->last_bank_dir); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), untitled_dish); } else { const char* tmp = 0; char* fn = 0; char* pdir = 0; /* parent of session dir */ if (dish_file_state_is_full()) { tmp = dish_file_state_parent_dir(); if (session_is_active() && (pdir = file_ops_parent_dir(tmp)) != 0) { tmp = pdir; } } else tmp = dish_file_state_bank_dir(); debug("tmp: '%s'\n", tmp); debug("parent: '%s'\n", dish_file_state_parent_dir()); debug("bank: '%s'\n", dish_file_state_bank_dir()); gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), tmp); fn = file_ops_join_ext( dish_file_state_bank_name(), dish_file_extension()); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), fn); free(fn); free(pdir); } file_chooser_add_filter(dialog, "Petri-Foo files", filter); file_chooser_add_filter(dialog, "All files", "*"); if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { char *name = (char *) gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); if ((val = dish_file_write_basic(name)) < 0) { GtkWidget* msg = gtk_message_dialog_new(GTK_WINDOW(dialog), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Failed to write file %s\n.", name); g_signal_connect_swapped(G_OBJECT(msg), "response", G_CALLBACK(gtk_widget_destroy), msg); gtk_widget_show (msg); } else { if (recent_manager && not_export) gtk_recent_manager_add_item (recent_manager, g_filename_to_uri(name, NULL, NULL)); } } else { val = -1; } gtk_widget_destroy(dialog); free(filter); return val; }
bool FileDialog::Create(wxWindow *parent, const wxString& message, const wxString& defaultDir, const wxString& defaultFileName, const wxString& wildCard, long style, const wxPoint& pos, const wxSize& sz, const wxString& name) { parent = GetParentForModalDialog(parent, style); if (!FileDialogBase::Create(parent, message, defaultDir, defaultFileName, wildCard, style, pos, sz, name)) { return false; } if (!PreCreation(parent, pos, wxDefaultSize) || !CreateBase(parent, wxID_ANY, pos, wxDefaultSize, style, wxDefaultValidator, wxT("filedialog"))) { wxFAIL_MSG( wxT("FileDialog creation failed") ); return false; } 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); g_object_ref(m_widget); GtkFileChooser* file_chooser = GTK_FILE_CHOOSER(m_widget); m_fc.SetWidget(file_chooser); gtk_dialog_set_default_response(GTK_DIALOG(m_widget), GTK_RESPONSE_ACCEPT); if ( style & wxFD_MULTIPLE ) gtk_file_chooser_set_select_multiple(file_chooser, 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 (m_widget, "response", G_CALLBACK (gtk_filedialog_response_callback), this); g_signal_connect (m_widget, "selection-changed", G_CALLBACK (gtk_filedialog_selchanged_callback), this); g_signal_connect (m_widget, "current-folder-changed", G_CALLBACK (gtk_filedialog_folderchanged_callback), this); g_signal_connect (m_widget, "notify::filter", G_CALLBACK (gtk_filedialog_filterchanged_callback), this); // deal with extensions/filters SetWildcard(wildCard); wxString defaultFileNameWithExt = defaultFileName; if ( !wildCard.empty() && !defaultFileName.empty() && !wxFileName(defaultFileName).HasExt() ) { // append the default extension, if any, to the initial file name: GTK // won't do it for us by default (unlike e.g. MSW) const wxFileName fnWC(m_fc.GetCurrentWildCard()); if ( fnWC.HasExt() ) { // Notice that we shouldn't append the extension if it's a wildcard // because this is not useful: the user would need to change it to use // some fixed extension anyhow. const wxString& ext = fnWC.GetExt(); if ( ext.find_first_of("?*") == wxString::npos ) defaultFileNameWithExt << "." << ext; } } // if defaultDir is specified it should contain the directory and // defaultFileName should contain the default name of the file, however if // directory is not given, defaultFileName contains both wxFileName fn; if ( defaultDir.empty() ) fn.Assign(defaultFileNameWithExt); else if ( !defaultFileNameWithExt.empty() ) fn.Assign(defaultDir, defaultFileNameWithExt); else fn.AssignDir(defaultDir); // set the initial file name and/or directory fn.MakeAbsolute(); // GTK+ needs absolute path const wxString dir = fn.GetPath(); if ( !dir.empty() ) { gtk_file_chooser_set_current_folder(file_chooser, wxGTK_CONV_FN(dir)); } const wxString fname = fn.GetFullName(); if ( style & wxFD_SAVE ) { if ( !fname.empty() ) { gtk_file_chooser_set_current_name(file_chooser, wxGTK_CONV_FN(fname)); } #if GTK_CHECK_VERSION(2,7,3) if ((style & wxFD_OVERWRITE_PROMPT) #ifndef __WXGTK3__ && gtk_check_version(2,7,3) == NULL #endif ) { gtk_file_chooser_set_do_overwrite_confirmation(file_chooser, true); } #endif } else // wxFD_OPEN { if ( !fname.empty() ) { gtk_file_chooser_set_filename(file_chooser, wxGTK_CONV_FN(fn.GetFullPath())); } } if ( style & wxFD_PREVIEW ) { GtkWidget *previewImage = gtk_image_new(); gtk_file_chooser_set_preview_widget(file_chooser, previewImage); g_signal_connect(m_widget, "update-preview", G_CALLBACK(gtk_filedialog_update_preview_callback), previewImage); } return true; }
/***************************************************************************** * 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); } }
/** * repository_ipod_init: * * Ask for the iPod model and mountpoint and then create the directory * structure on the iPod. * * @itdb: itdb from where to extract the mountpoint. After * initialisation the model number is set. */ gboolean repository_ipod_init(iTunesDB *itdb) { IpodInit *ii; gint response; gboolean result = FALSE; gchar *mountpoint, *new_mount, *name, *model; GError *error = NULL; gchar buf[PATH_MAX]; GtkComboBox *cb; const IpodInfo *info; GtkTreeIter iter; g_return_val_if_fail (itdb, FALSE); /* Create window */ ii = g_new0 (IpodInit, 1); ii->itdb = itdb; ii->builder = init_repository_builder(); ii->window = gtkpod_builder_xml_get_widget(ii->builder, "ipod_init_dialog"); g_return_val_if_fail (ii->window, FALSE); /* Set mountpoint */ mountpoint = get_itdb_prefs_string(itdb, KEY_MOUNTPOINT); if (mountpoint) { gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(GET_WIDGET (ii->builder, IID_MOUNTPOINT_CHOOSER)), mountpoint); } /* Setup model number combo */ cb = GTK_COMBO_BOX (GET_WIDGET (ii->builder, IID_MODEL_COMBO)); repository_init_model_number_combo(cb); /* If available set current model number, otherwise indicate that none is available */ info = itdb_device_get_ipod_info(itdb->device); if (info && (info->ipod_generation != ITDB_IPOD_GENERATION_UNKNOWN)) { g_snprintf(buf, PATH_MAX, "x%s", info->model_number); } else { model = get_itdb_prefs_string(itdb, KEY_IPOD_MODEL); if (model && (strlen(g_strstrip (model)) != 0)) { g_snprintf(buf, PATH_MAX, "%s", model); g_free(model); } else { g_snprintf(buf, PATH_MAX, "%s", gettext (SELECT_OR_ENTER_YOUR_MODEL)); } } /* Try and set buf as the active selection in the combo box */ _model_combo_set_active_iter(cb, buf); gtk_window_set_transient_for(GTK_WINDOW (ii->window), GTK_WINDOW (gtkpod_app)); response = gtk_dialog_run(GTK_DIALOG (ii->window)); switch (response) { case GTK_RESPONSE_OK: new_mount = g_strdup(gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(GET_WIDGET (ii->builder, IID_MOUNTPOINT_CHOOSER)))); if (!new_mount || (strlen(new_mount) == 0)) { gtkpod_statusbar_message("No mount point has been selected"); return FALSE; } if (!gtk_combo_box_get_has_entry(cb)) { gtkpod_statusbar_message("No model has been selected"); return FALSE; } /* remove trailing '/' in case it's present. */ if (mountpoint && (strlen(mountpoint) > 0)) { if (G_IS_DIR_SEPARATOR(mountpoint[strlen(mountpoint) - 1])) { mountpoint[strlen(mountpoint) - 1] = 0; } } if (new_mount && (strlen(new_mount) > 0)) { if (G_IS_DIR_SEPARATOR(new_mount[strlen(new_mount) - 1])) { new_mount[strlen(new_mount) - 1] = 0; } } if (!(mountpoint && new_mount && (strcmp(mountpoint, new_mount) == 0))) { /* mountpoint has changed */ g_free(mountpoint); mountpoint = new_mount; new_mount = NULL; set_itdb_prefs_string(itdb, KEY_MOUNTPOINT, mountpoint); call_script("gtkpod.load", mountpoint, NULL); itdb_set_mountpoint(itdb, mountpoint); } else { g_free(new_mount); new_mount = NULL; } g_return_val_if_fail(gtk_combo_box_get_active_iter(cb, &iter), FALSE); gtk_tree_model_get(gtk_combo_box_get_model(cb), &iter, COL_STRING, &model, -1); g_return_val_if_fail(model, FALSE); if ((strcmp(model, gettext(SELECT_OR_ENTER_YOUR_MODEL)) == 0) || (strlen(model) == 0)) { /* User didn't choose a model */ g_free(model); model = NULL; } /* Set model in the prefs system */ set_itdb_prefs_string(itdb, KEY_IPOD_MODEL, model); name = get_itdb_prefs_string(itdb, "name"); result = itdb_init_ipod(mountpoint, model, name, &error); /* Set the model in the sysinfo of the itdb */ itdb_device_set_sysinfo(itdb->device, "ModelNumStr", model); if (!result) { if (error) { gtkpod_warning(_("Error initialising iPod: %s\n"), error->message); g_error_free(error); error = NULL; } else { gtkpod_warning(_("Error initialising iPod, unknown error\n")); } } else { /* Should write the extended info file */ result = gp_create_extended_info(itdb); } g_free(name); g_free(model); break; default: /* canceled -- do nothing */ break; } gtk_widget_destroy(ii->window); g_free(mountpoint); g_free(ii); return result; }
/***************************************************************************** * 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); } }
char* get_save_filename( GtkWindow* parent, const char* cwd, char** type ) { char* file = NULL; GtkFileChooser* dlg = (GtkFileChooser*)gtk_file_chooser_dialog_new( NULL, parent, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL ); GSList* modules, *module; GtkFileFilter *filter; gtk_file_chooser_set_current_folder( dlg, cwd ); GtkWidget* img = gtk_image_new(); gtk_widget_set_size_request( img, 128, 128 ); gtk_file_chooser_set_preview_widget( dlg, img ); g_signal_connect( dlg, "update-preview", G_CALLBACK(on_update_preview), img ); g_signal_connect( dlg, "notify::filter", G_CALLBACK(on_file_save_filter_changed), NULL ); /* /// TODO: determine file type from file name filter = gtk_file_filter_new(); gtk_file_filter_set_name( filter, _("Determined by File Name") ); gtk_file_filter_add_pixbuf_formats( filter ); gtk_file_chooser_add_filter( dlg, filter ); */ modules = gdk_pixbuf_get_formats(); for( module = modules; module; module = module->next ) { char *name, *desc, *tmp; char **exts, **mimes, **mime; GdkPixbufFormat* format = (GdkPixbufFormat*)module->data; if( ! gdk_pixbuf_format_is_writable( format ) ) continue; filter = gtk_file_filter_new(); name = gdk_pixbuf_format_get_name( format ); desc = gdk_pixbuf_format_get_description( format ); exts = gdk_pixbuf_format_get_extensions( format ); mimes = gdk_pixbuf_format_get_mime_types( format ); tmp = g_strdup_printf( "%s (*.%s)", desc, exts[0], NULL ); g_object_set_data_full(G_OBJECT(filter), "type", name, (GDestroyNotify)g_free); g_strfreev(exts); g_free( desc ); gtk_file_filter_set_name( filter, tmp ); g_free( tmp ); for( mime = mimes; *mime ; ++mime ) gtk_file_filter_add_mime_type( filter, *mime ); g_strfreev( mimes ); gtk_file_chooser_add_filter( dlg, filter ); } g_slist_free( modules ); int initial_jpg_quality = pref.jpg_quality; int initial_png_compression = pref.png_compression; if( gtk_dialog_run( (GtkDialog*)dlg ) == GTK_RESPONSE_OK ) { filter = gtk_file_chooser_get_filter( dlg ); file = gtk_file_chooser_get_filename( dlg ); *type = g_object_steal_data(G_OBJECT(filter), "type"); if( !*type ) // auto detection { /// TODO: auto file type } else { /* TODO: append appropriate extension if needed. */ } } gtk_widget_destroy( (GtkWidget*)dlg ); if ((initial_jpg_quality != pref.jpg_quality) || (initial_png_compression != pref.png_compression)) save_preferences(); return file; }
GtkWindow* LLFilePickerBase::buildFilePicker(bool is_save, bool is_folder, std::string const& folder) { if (LLWindowSDL::ll_try_gtk_init()) { GtkWidget *win = NULL; GtkFileChooserAction pickertype = is_save? (is_folder? GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER : GTK_FILE_CHOOSER_ACTION_SAVE) : (is_folder? GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER : GTK_FILE_CHOOSER_ACTION_OPEN); win = gtk_file_chooser_dialog_new(NULL, NULL, pickertype, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, is_folder ? GTK_STOCK_APPLY : (is_save ? GTK_STOCK_SAVE : GTK_STOCK_OPEN), GTK_RESPONSE_ACCEPT, (gchar *)NULL); if (!folder.empty()) { PLS_DEBUGS << "Calling gtk_file_chooser_set_current_folder(\"" << folder << "\")." << PLS_ENDL; gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(win), folder.c_str()); } # if LL_X11 // Make GTK tell the window manager to associate this // dialog with our non-GTK raw X11 window, which should try // to keep it on top etc. if (mX11WindowID != None) { gtk_widget_realize(GTK_WIDGET(win)); // so we can get its gdkwin GdkWindow *gdkwin = gdk_window_foreign_new(mX11WindowID); gdk_window_set_transient_for(GTK_WIDGET(win)->window, gdkwin); } # endif //LL_X11 g_signal_connect (GTK_FILE_CHOOSER(win), "response", G_CALLBACK(LLFilePickerBase::chooser_responder), this); PLS_FLUSH; gtk_window_set_modal(GTK_WINDOW(win), TRUE); /* GTK 2.6: if (is_folder) gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(win), TRUE); */ return GTK_WINDOW(win); } else { return NULL; } }
void ConfigurePlugins() { if (!UseGui) { /* How do we get here if we're not running the GUI? */ /* Ryan: we're going to imagine that someday, there will be a way * to configure plugins from the commandline */ printf("ERROR: Plugins cannot be configured without the GUI."); return; } GtkWidget *widget; gchar *path; UpdatePluginsBIOS(); builder = gtk_builder_new(); if (!gtk_builder_add_from_resource(builder, "/org/pcsxr/gui/pcsxr.ui", NULL)) { g_warning("Error: interface could not be loaded!"); return; } UpdatePluginsBIOS_UpdateGUI(builder); ConfDlg = GTK_WIDGET(gtk_builder_get_object(builder, "ConfDlg")); gtk_window_set_title(GTK_WINDOW(ConfDlg), _("Configure PCSXR")); gtk_widget_show (ConfDlg); /* Set the paths in the file choosers to be based on the saved configurations */ widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkFileChooser_Bios")); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (widget), Config.BiosDir); widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkFileChooser_Plugin")); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (widget), Config.PluginsDir); if (strlen(Config.PluginsDir) == 0) { if((path = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (widget))) != NULL) { strcpy(Config.PluginsDir, path); g_free(path); } } widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_ConfGpu")); g_signal_connect_data(G_OBJECT(widget), "clicked", G_CALLBACK(on_configure_plugin), GINT_TO_POINTER(PSE_LT_GPU), NULL, G_CONNECT_AFTER); widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_ConfSpu")); g_signal_connect_data(G_OBJECT(widget), "clicked", G_CALLBACK(on_configure_plugin), GINT_TO_POINTER(PSE_LT_SPU), NULL, G_CONNECT_AFTER); /* ADB TODO Does pad 1 and 2 need to be different? */ widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_ConfPad1")); g_signal_connect_data(G_OBJECT(widget), "clicked", G_CALLBACK(OnConfConf_Pad1Conf), builder, NULL, G_CONNECT_AFTER); widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_ConfPad2")); g_signal_connect_data(G_OBJECT(widget), "clicked", G_CALLBACK(OnConfConf_Pad2Conf), builder, NULL, G_CONNECT_AFTER); widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_ConfCdr")); g_signal_connect_data(G_OBJECT(widget), "clicked", G_CALLBACK(on_configure_plugin), GINT_TO_POINTER(PSE_LT_CDR), NULL, G_CONNECT_AFTER); #ifdef ENABLE_SIO1API widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_ConfSio1")); g_signal_connect_data(G_OBJECT(widget), "clicked", G_CALLBACK(on_configure_plugin), (gpointer) PSE_LT_SIO1, NULL, G_CONNECT_AFTER); #else widget = GTK_WIDGET(gtk_builder_get_object(builder, "label18")); gtk_widget_set_sensitive(widget, FALSE); widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkCombo_Sio1")); gtk_widget_set_sensitive(widget, FALSE); widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_ConfSio1")); gtk_widget_set_sensitive(widget, FALSE); widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_AboutSio1")); gtk_widget_set_sensitive(widget, FALSE); #endif widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_AboutGpu")); g_signal_connect_data(G_OBJECT(widget), "clicked", G_CALLBACK(on_about_plugin), GINT_TO_POINTER(PSE_LT_GPU), NULL, G_CONNECT_AFTER); widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_AboutSpu")); g_signal_connect_data(G_OBJECT(widget), "clicked", G_CALLBACK(on_about_plugin), GINT_TO_POINTER(PSE_LT_SPU), NULL, G_CONNECT_AFTER); widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_AboutPad1")); g_signal_connect_data(G_OBJECT(widget), "clicked", G_CALLBACK(OnConfConf_Pad1About), builder, NULL, G_CONNECT_AFTER); widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_AboutPad2")); g_signal_connect_data(G_OBJECT(widget), "clicked", G_CALLBACK(OnConfConf_Pad2About), builder, NULL, G_CONNECT_AFTER); widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_AboutCdr")); g_signal_connect_data(G_OBJECT(widget), "clicked", G_CALLBACK(on_about_plugin), GINT_TO_POINTER(PSE_LT_CDR), NULL, G_CONNECT_AFTER); #ifdef ENABLE_SIO1API widget = GTK_WIDGET(gtk_builder_get_object(builder, "btn_AboutSio1")); g_signal_connect_data(G_OBJECT(widget), "clicked", G_CALLBACK(on_about_plugin), (gpointer) PSE_LT_SIO1, NULL, G_CONNECT_AFTER); #endif widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkFileChooser_Bios")); g_signal_connect_data(G_OBJECT(widget), "current_folder_changed", G_CALLBACK(OnBiosPath_Changed), builder, NULL, G_CONNECT_AFTER); widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkFileChooser_Plugin")); g_signal_connect_data(G_OBJECT(widget), "current_folder_changed", G_CALLBACK(OnPluginPath_Changed), builder, NULL, G_CONNECT_AFTER); g_signal_connect_data(G_OBJECT(ConfDlg), "response", G_CALLBACK(OnConf_Clicked), builder, (GClosureNotify)g_object_unref, G_CONNECT_AFTER); }
/*! \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); }
GtkWidget* gtr_torrent_options_dialog_new( GtkWindow * parent, TrCore * core, tr_ctor * ctor ) { int row; int col; const char * str; GtkWidget * w; GtkWidget * d; GtkWidget * t; GtkWidget * l; GtkWidget * grab; GtkWidget * source_chooser; struct OpenData * data; uint8_t flag; GSList * list; GSList * walk; /* make the dialog */ d = gtk_dialog_new_with_buttons( _( "Torrent Options" ), parent, GTK_DIALOG_DESTROY_WITH_PARENT, NULL ); gtk_dialog_add_button( GTK_DIALOG( d ), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL ); grab = gtk_dialog_add_button( GTK_DIALOG( d ), GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT ); 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 ); gtk_widget_grab_focus( grab ); return d; }
NedMidiImportDialog::NedMidiImportDialog(GtkWindow *parent, char **folder, char **filename) : m_with_triplets(true), m_tempo_change_density(20), m_volume_change_density(20), m_last_folder(folder), m_filename(filename) { GtkWidget *dialog; GtkWidget *tempo_sensity_frame; GtkWidget *volume_sensity_frame; GtkWidget *main_vbox; GtkWidget *main_hbox; GtkWidget *left_vbox; GtkWidget *right_vbox; dialog = gtk_dialog_new_with_buttons(_("MIDI import"), parent, (GtkDialogFlags) (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL); g_signal_connect(dialog, "response", G_CALLBACK (OnClose), (void *) this); m_file_chooser = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_OPEN); if (*m_last_folder != NULL) { gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(m_file_chooser), *m_last_folder); } if (*m_filename != NULL) { gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(m_file_chooser), *m_filename); } GtkFileFilter *file_filter1 = gtk_file_filter_new(); gtk_file_filter_set_name(file_filter1, ".mid,.midi (MIDI-Files)"); gtk_file_filter_add_pattern(file_filter1, "*.mid"); gtk_file_filter_add_pattern(file_filter1, "*.midi"); GtkFileFilter *file_filter2 = gtk_file_filter_new(); gtk_file_filter_set_name(file_filter2, "* (All Files)"); gtk_file_filter_add_pattern(file_filter2, "*"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(m_file_chooser), file_filter1); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(m_file_chooser), file_filter2); left_vbox = gtk_vbox_new(FALSE, 2); right_vbox = gtk_vbox_new(FALSE, 2); m_with_triplet_button = gtk_toggle_button_new_with_label(_("triplet recognition")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_with_triplet_button), TRUE); m_sort_instruments_button = gtk_toggle_button_new_with_label(_("sort instruments")); m_force_piano_button = gtk_toggle_button_new_with_label(_("force piano")); m_dont_split_button = gtk_toggle_button_new_with_label(_("don't split tracks")); g_signal_connect(m_force_piano_button, "toggled", G_CALLBACK (OnPianoForcePressed), (void *) this); g_signal_connect(m_dont_split_button, "toggled", G_CALLBACK (OnDontSplitPressed), (void *) this); gtk_container_add (GTK_CONTAINER(left_vbox), m_with_triplet_button); gtk_container_add (GTK_CONTAINER(left_vbox), m_sort_instruments_button); gtk_container_add (GTK_CONTAINER(left_vbox), m_force_piano_button); gtk_container_add (GTK_CONTAINER(left_vbox), m_dont_split_button); tempo_sensity_frame = gtk_frame_new(_("tempo density")); m_tempo_change_density_scale = gtk_hscale_new_with_range(0.0, 100.0, 1.0); gtk_range_set_value(GTK_RANGE(m_tempo_change_density_scale), 20.0); gtk_container_add (GTK_CONTAINER(tempo_sensity_frame), m_tempo_change_density_scale); volume_sensity_frame = gtk_frame_new(_("volume density")); m_volume_change_density_scale = gtk_hscale_new_with_range(0.0, 100.0, 1.0); gtk_range_set_value(GTK_RANGE(m_volume_change_density_scale), 20.0); gtk_container_add (GTK_CONTAINER(volume_sensity_frame), m_volume_change_density_scale); gtk_box_pack_start(GTK_BOX(right_vbox), tempo_sensity_frame, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(right_vbox), volume_sensity_frame, FALSE, TRUE, 0); main_hbox = gtk_hbox_new(FALSE, 2); gtk_box_pack_start(GTK_BOX(main_hbox), left_vbox, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(main_hbox), right_vbox, TRUE, TRUE, 0); main_vbox = gtk_vbox_new(FALSE, 2); gtk_box_pack_start (GTK_BOX(main_vbox), main_hbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(main_vbox), m_file_chooser, TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), main_vbox); gtk_window_set_default_size (GTK_WINDOW (dialog), MIDIIMPORT_DIALOG_WIDTH, MIDIIMPORT_DIALOG_HEIGHT); gtk_widget_show_all (dialog); gtk_dialog_run(GTK_DIALOG(dialog)); }
static int gtkFileDlgPopup(Ihandle* ih, int x, int y) { InativeHandle* parent = iupDialogGetNativeParent(ih); GtkWidget* dialog; GtkWidget* preview_canvas = NULL; GtkFileChooserAction action; IFnss file_cb; char* value; int response, filter_count = 0; iupAttribSetInt(ih, "_IUPDLG_X", x); /* used in iupDialogUpdatePosition */ iupAttribSetInt(ih, "_IUPDLG_Y", y); value = iupAttribGetStr(ih, "DIALOGTYPE"); if (iupStrEqualNoCase(value, "SAVE")) action = GTK_FILE_CHOOSER_ACTION_SAVE; else if (iupStrEqualNoCase(value, "DIR")) action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER; else action = GTK_FILE_CHOOSER_ACTION_OPEN; value = iupAttribGet(ih, "TITLE"); if (!value) { GtkStockItem item; if (action == GTK_FILE_CHOOSER_ACTION_SAVE) value = GTK_STOCK_SAVE_AS; else value = GTK_STOCK_OPEN; gtk_stock_lookup(value, &item); value = item.label; iupAttribStoreStr(ih, "TITLE", iupgtkStrConvertFromUTF8(value)); value = iupAttribGet(ih, "TITLE"); iupStrRemoveChar(value, '_'); } dialog = gtk_file_chooser_dialog_new(iupgtkStrConvertToUTF8(value), (GtkWindow*)parent, action, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); if (!dialog) return IUP_ERROR; if (action == GTK_FILE_CHOOSER_ACTION_SAVE) gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_SAVE, GTK_RESPONSE_OK); else if (action == GTK_FILE_CHOOSER_ACTION_OPEN) gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OPEN, GTK_RESPONSE_OK); else gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OK, GTK_RESPONSE_OK); if (IupGetCallback(ih, "HELP_CB")) gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_HELP, GTK_RESPONSE_HELP); #if GTK_CHECK_VERSION(2, 6, 0) if (iupAttribGetBoolean(ih, "SHOWHIDDEN")) gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(dialog), TRUE); #endif if (iupAttribGetBoolean(ih, "MULTIPLEFILES") && action == GTK_FILE_CHOOSER_ACTION_OPEN) gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE); #if GTK_CHECK_VERSION(2, 8, 0) if (!iupAttribGetBoolean(ih, "NOOVERWRITEPROMPT") && action == GTK_FILE_CHOOSER_ACTION_SAVE) gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE); #endif /* just check for the path inside FILE */ value = iupAttribGet(ih, "FILE"); if (value && (value[0] == '/' || value[1] == ':')) { char* dir = iupStrFileGetPath(value); int len = strlen(dir); iupAttribStoreStr(ih, "DIRECTORY", dir); free(dir); iupAttribStoreStr(ih, "FILE", value+len); } value = iupAttribGet(ih, "DIRECTORY"); if (value) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), iupgtkStrConvertToFilename(value)); value = iupAttribGet(ih, "FILE"); if (value) { if (action == GTK_FILE_CHOOSER_ACTION_SAVE) gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), iupgtkStrConvertToFilename(value)); else { if (iupdrvIsFile(value)) /* check if file exists */ gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), iupgtkStrConvertToFilename(value)); } } value = iupAttribGet(ih, "EXTFILTER"); if (value) { char *name, *pattern, *filters = iupStrDup(value), *p; char atrib[30]; int i; int filter_index = iupAttribGetInt(ih, "FILTERUSED"); if (!filter_index) filter_index = 1; filter_count = iupStrReplace(filters, '|', 0) / 2; p = filters; for (i=0; i<filter_count; i++) { GtkFileFilter *filter = gtk_file_filter_new(); gtkFileDlgGetNextFilter(&p, &name, &pattern); gtk_file_filter_set_name(filter, iupgtkStrConvertToUTF8(name)); gtk_file_filter_add_pattern(filter, pattern); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter); sprintf(atrib, "_IUPDLG_FILTER%d", i+1); iupAttribSetStr(ih, atrib, (char*)filter); if (i+1 == filter_index) gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter); } free(filters); } else { value = iupAttribGet(ih, "FILTER"); if (value) { GtkFileFilter *filter = gtk_file_filter_new(); char* info = iupAttribGet(ih, "FILTERINFO"); if (!info) info = value; gtk_file_filter_set_name(filter, iupgtkStrConvertToUTF8(info)); gtk_file_filter_add_pattern(filter, value); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter); } } file_cb = (IFnss)IupGetCallback(ih, "FILE_CB"); if (file_cb && action != GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER) { g_signal_connect(GTK_FILE_CHOOSER(dialog), "update-preview", G_CALLBACK(gtkFileDlgUpdatePreview), ih); g_signal_connect(dialog, "realize", G_CALLBACK(gtkFileDlgRealize), ih); if (iupAttribGetBoolean(ih, "SHOWPREVIEW")) { GtkWidget* frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN); gtk_widget_set_size_request(frame, 180, 150); preview_canvas = gtk_drawing_area_new(); gtk_widget_set_double_buffered(preview_canvas, FALSE); gtk_container_add(GTK_CONTAINER(frame), preview_canvas); gtk_widget_show(preview_canvas); g_signal_connect(preview_canvas, "configure-event", G_CALLBACK(gtkFileDlgPreviewConfigureEvent), ih); g_signal_connect(preview_canvas, "expose-event", G_CALLBACK(gtkFileDlgPreviewExposeEvent), ih); g_signal_connect(preview_canvas, "realize", G_CALLBACK(gtkFileDlgPreviewRealize), ih); iupAttribSetStr(ih, "_IUPDLG_FILE_CHOOSER", (char*)dialog); gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(dialog), frame); } } /* initialize the widget */ gtk_widget_realize(GTK_WIDGET(dialog)); ih->handle = GTK_WIDGET(dialog); iupDialogUpdatePosition(ih); ih->handle = NULL; /* reset handle */ do { response = gtk_dialog_run(GTK_DIALOG(dialog)); if (response == GTK_RESPONSE_HELP) { Icallback cb = IupGetCallback(ih, "HELP_CB"); if (cb && cb(ih) == IUP_CLOSE) response = GTK_RESPONSE_CANCEL; } else if (response == GTK_RESPONSE_OK) { char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); int file_exist = iupdrvIsFile(filename); int dir_exist = iupdrvIsDirectory(filename); g_free(filename); if (action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER) { if (!dir_exist) { iupStrMessageShowError(ih, "IUP_INVALIDDIR"); response = GTK_RESPONSE_HELP; /* to leave the dialog open */ continue; } } else if (!iupAttribGetBoolean(ih, "MULTIPLEFILES")) { if (dir_exist) { iupStrMessageShowError(ih, "IUP_FILEISDIR"); response = GTK_RESPONSE_HELP; /* to leave the dialog open */ continue; } if (!file_exist) /* if do not exist check ALLOWNEW */ { value = iupAttribGet(ih, "ALLOWNEW"); if (!value) { if (action == GTK_FILE_CHOOSER_ACTION_SAVE) value = "YES"; else value = "NO"; } if (!iupStrBoolean(value)) { iupStrMessageShowError(ih, "IUP_FILENOTEXIST"); response = GTK_RESPONSE_HELP; /* to leave the dialog open */ continue; } } if (file_cb) { char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); int ret = file_cb(ih, iupgtkStrConvertFromFilename(filename), "OK"); g_free(filename); if (ret == IUP_IGNORE) { response = GTK_RESPONSE_HELP; /* to leave the dialog open */ continue; } } } } } while (response == GTK_RESPONSE_HELP); if (file_cb) { if (iupAttribGetBoolean(ih, "SHOWPREVIEW")) iupgtkReleaseNativeGraphicsContext(preview_canvas, (void*)iupAttribGet(ih, "PREVIEWDC")); file_cb(ih, NULL, "FINISH"); } if (response == GTK_RESPONSE_OK) { int file_exist, dir_exist; if (filter_count) { int i; char atrib[30]; GtkFileFilter* filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(dialog)); for (i=0; i<filter_count; i++) { sprintf(atrib, "_IUPDLG_FILTER%d", i+1); if (filter == (GtkFileFilter*)iupAttribGet(ih, atrib)) iupAttribSetInt(ih, "FILTERUSED", i+1); } } if (iupAttribGetBoolean(ih, "MULTIPLEFILES")) { GSList* file_list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog)); if (file_list->next) /* if more than one file */ gtkFileDlgGetMultipleFiles(ih, file_list); else { char* filename = (char*)file_list->data; iupAttribStoreStr(ih, "VALUE", iupgtkStrConvertFromFilename(filename)); g_free(filename); /* store the DIRECTORY */ { char* dir = iupStrFileGetPath(iupAttribGet(ih, "VALUE")); iupAttribStoreStr(ih, "DIRECTORY", dir); free(dir); } } g_slist_free(file_list); file_exist = 1; dir_exist = 0; } else { char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); iupAttribStoreStr(ih, "VALUE", iupgtkStrConvertFromFilename(filename)); file_exist = iupdrvIsFile(filename); dir_exist = iupdrvIsDirectory(filename); if (file_exist) { char* dir = iupStrFileGetPath(filename); iupAttribStoreStr(ih, "DIRECTORY", dir); free(dir); } g_free(filename); } if (dir_exist) { iupAttribSetStr(ih, "FILEEXIST", NULL); iupAttribSetStr(ih, "STATUS", "0"); } else { if (file_exist) /* check if file exists */ { iupAttribSetStr(ih, "FILEEXIST", "YES"); iupAttribSetStr(ih, "STATUS", "0"); } else { iupAttribSetStr(ih, "FILEEXIST", "NO"); iupAttribSetStr(ih, "STATUS", "1"); } } if (action != GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER && !iupAttribGetBoolean(ih, "NOCHANGEDIR")) /* do change the current directory */ { /* GtkFileChooser does not change the current directory */ char* dir = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(dialog)); if (dir) { iupdrvSetCurrentDirectory(dir); g_free(dir); } } } else { iupAttribSetStr(ih, "FILTERUSED", NULL); iupAttribSetStr(ih, "VALUE", NULL); iupAttribSetStr(ih, "FILEEXIST", NULL); iupAttribSetStr(ih, "STATUS", "-1"); } gtk_widget_destroy(GTK_WIDGET(dialog)); return IUP_NOERROR; }
static void _lib_geotagging_gpx_callback(GtkWidget *widget, dt_lib_module_t *self) { dt_lib_geotagging_t *d = (dt_lib_geotagging_t*)self->data; /* bring a filechooser to select the gpx file to apply to selection */ GtkWidget *win = dt_ui_main_window(darktable.gui->ui); GtkWidget *filechooser = gtk_file_chooser_dialog_new(_("open GPX file"), GTK_WINDOW (win), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, (char *)NULL); char *last_directory = dt_conf_get_string("ui_last/gpx_last_directory"); if(last_directory != NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (filechooser), last_directory); GtkFileFilter *filter; filter = GTK_FILE_FILTER(gtk_file_filter_new()); gtk_file_filter_add_pattern(filter, "*.gpx"); gtk_file_filter_set_name(filter, _("GPS data exchange format")); 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); // add time zone selection GtkWidget *extra_box = gtk_hbox_new(FALSE, 5); GtkWidget *label = gtk_label_new(_("camera time zone")); g_object_set(G_OBJECT(label), "tooltip-text", _("most cameras don't store the time zone in EXIF. give the correct time zone so the GPX data can be correctly matched"), (char *)NULL); GtkWidget *tz_selection = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(tz_selection), "UTC"); gtk_combo_box_set_active(GTK_COMBO_BOX(tz_selection), 0); GList *iter = d->timezones; int i = 0; gchar *old_tz= dt_conf_get_string("plugins/lighttable/geotagging/tz"); if(iter) { do { i++; gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(tz_selection), (gchar*)iter->data); if(!strcmp((gchar*)iter->data, old_tz)) gtk_combo_box_set_active(GTK_COMBO_BOX(tz_selection), i); } while( (iter = g_list_next(iter)) != NULL); } gtk_box_pack_start(GTK_BOX(extra_box), label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(extra_box), tz_selection, FALSE, FALSE, 0); gtk_widget_show_all(extra_box); gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(filechooser), extra_box); if(gtk_dialog_run(GTK_DIALOG (filechooser)) == GTK_RESPONSE_ACCEPT) { dt_conf_set_string("ui_last/gpx_last_directory", gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (filechooser))); gchar *tz = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(tz_selection)); dt_conf_set_string("plugins/lighttable/geotagging/tz", tz); gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (filechooser)); dt_control_gpx_apply(filename, -1, tz); g_free(filename); g_free(tz); } gtk_widget_destroy(extra_box); gtk_widget_destroy(filechooser); // dt_control_queue_redraw_center(); }
/* 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; }
void crypt_dock_create_new_stash () { gboolean disgardStash = FALSE; CryptItem *pStashItem; cd_message ("%s enter to the function", __func__); pStashItem = g_new0 (CryptItem, 1); disgardStash = FALSE; for (int i=0; i < 4; i++) { switch (i) { case PHASE_ENTER_NEW_FOLDER: { GtkWidget* pFileChooserDialog = gtk_file_chooser_dialog_new ( _("(1/4) Select an new clean and/or empty folder (eg ~/.crypt)"), GTK_WINDOW (myContainer->pWidget), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (pFileChooserDialog), g_get_home_dir()); gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (pFileChooserDialog), FALSE); gtk_widget_show (pFileChooserDialog); int answer = gtk_dialog_run (GTK_DIALOG (pFileChooserDialog)); gboolean valid = FALSE; if (answer == GTK_RESPONSE_OK) { pStashItem->cCryptFolder = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (pFileChooserDialog)); valid = _cryptdock_stash_check_encfs_validity(pStashItem->cCryptFolder); } else { disgardStash = TRUE; } gtk_widget_destroy (pFileChooserDialog); if (valid == FALSE ) { cairo_dock_show_dialog_and_wait ( D_("The selected folder is not an EncFS encrypted folder"), myIcon, myContainer, NULL, NULL); disgardStash = TRUE; } } break; case PHASE_SELECT_MOUNT_FOLDER: { char *blah=NULL; char *last_slash; // Choose the name and location at which you want the EncFS folder to be mounted GtkWidget* pFileChooserDialog = gtk_file_chooser_dialog_new ( _("(2/4) Choose the name and location at which you want the EncFS folder to be mounted"), GTK_WINDOW (myContainer->pWidget), GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); blah = g_strdup(pStashItem->cCryptFolder); last_slash = strrchr (blah, '/'); if (last_slash) *last_slash = '\0'; gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (pFileChooserDialog), blah); gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (pFileChooserDialog), FALSE); gtk_widget_show (pFileChooserDialog); int answer = gtk_dialog_run (GTK_DIALOG (pFileChooserDialog)); if (answer == GTK_RESPONSE_OK) { pStashItem->cMountFolder = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (pFileChooserDialog)); } else { disgardStash = TRUE; cairo_dock_show_dialog_and_wait ( D_("You must enter a name"), myIcon, myContainer, NULL, NULL); } gtk_widget_destroy (pFileChooserDialog); } break; case PHASE_ENTER_NAME: { GtkWidget *editbox = gtk_entry_new(); int selection = cairo_dock_show_dialog_and_wait ( D_("(3/4) Enter name of stash (visible in list)"), myIcon, myContainer, NULL, editbox); if (selection == STASH_NAME_BUTTON_OK) { // user select Ok or check mark pStashItem->cVisibleName = g_strdup(gtk_entry_get_text(GTK_ENTRY(editbox))); } else { disgardStash = TRUE; } gtk_widget_destroy (editbox); } break; case PHASE_ENTER_PASSWORD: { GtkWidget *editbox = gtk_entry_new(); gtk_entry_set_visibility (GTK_ENTRY(editbox), FALSE); int selection = cairo_dock_show_dialog_and_wait ( D_("(4/4) Enter name of stash (visible in list)"), myIcon, myContainer, NULL, editbox); gchar * password=NULL; if (selection == STASH_NAME_BUTTON_OK) { // user select Ok or check mark password = g_strdup(gtk_entry_get_text(GTK_ENTRY(editbox))); if (password) { int done = encfs_stash_new (pStashItem->cCryptFolder, pStashItem->cMountFolder, password); g_free (password); if (done==0) { crypt_save_stash_to_settings(pStashItem); g_ptr_array_add (myData.pStashArray, pStashItem); crypt_show_notification_dialog (D_("New encfs mountpoint created.")); // passed } else { crypt_show_notification_dialog (D_("Unable to create new encfs mount.")); crypt_free_stashitem (pStashItem); // not passed ... } } } else { crypt_show_notification_dialog (D_("Unable to create new encfs mount.")); } gtk_widget_destroy (editbox); } break; } } return; }
/* 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; }
static void on_choosebutton_activate (GtkButton *button, gpointer user_data) { GSQL_TRACE_FUNC; GtkDialog *dialog; GtkWidget *target = user_data; static gchar *folder = NULL; GtkWidget *chooser; static gchar *uri = NULL; gchar *file = NULL; gint ret; chooser = gtk_file_chooser_dialog_new (N_("Target filename..."), 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(chooser), TRUE); if (folder) gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(chooser), folder); if (uri) g_free (uri); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (chooser), FALSE); uri = g_strdup(gtk_entry_get_text (GTK_ENTRY (target))); if (uri) { GSQL_DEBUG ("Export: [uri=%s]", uri); file = g_filename_display_basename (uri); if (gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(chooser), uri)) gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(chooser), file); g_free (file); file = NULL; } gtk_window_set_transient_for (GTK_WINDOW (chooser), GTK_WINDOW (gsql_window)); ret = gtk_dialog_run (GTK_DIALOG (chooser)); if (ret == GTK_RESPONSE_ACCEPT) { file = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser)); if (folder) g_free (folder); folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (chooser)); GSQL_DEBUG ("Export target: [file=%s]", file); if (file) { gtk_entry_set_text (GTK_ENTRY (target), file); g_free (file); } } gtk_widget_destroy (chooser); }