static void dlg_extract__common (FrWindow *window, GList *selected_files, char *base_dir_for_selection) { DialogData *data; data = g_new0 (DialogData, 1); data->settings = g_settings_new (FILE_ROLLER_SCHEMA_EXTRACT); data->window = window; data->selected_files = selected_files; data->base_dir_for_selection = base_dir_for_selection; data->extract_clicked = FALSE; data->dialog = gtk_file_chooser_dialog_new (C_("Window title", "Extract"), GTK_WINDOW (data->window), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, _GTK_LABEL_CANCEL, GTK_RESPONSE_CANCEL, _GTK_LABEL_EXTRACT, GTK_RESPONSE_OK, NULL); gtk_window_set_default_size (GTK_WINDOW (data->dialog), 530, 510); gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (data->dialog), FALSE); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (data->dialog), FALSE); gtk_file_chooser_set_create_folders (GTK_FILE_CHOOSER (data->dialog), TRUE); gtk_dialog_set_default_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_OK); data->builder = _gtk_builder_new_from_resource ("extract-dialog-options.ui"); if (data->builder == NULL) return; gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (data->dialog), GET_WIDGET ("extra_widget")); /* Set widgets data. */ gtk_file_chooser_set_current_folder_file (GTK_FILE_CHOOSER (data->dialog), fr_window_get_extract_default_dir (window), NULL); if (data->selected_files != NULL) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("selected_files_radiobutton")), TRUE); else { gtk_widget_set_sensitive (GET_WIDGET ("selected_files_radiobutton"), FALSE); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("all_files_radiobutton")), TRUE); } gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("keep_newer_checkbutton")), g_settings_get_boolean (data->settings, PREF_EXTRACT_SKIP_NEWER)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("keep_structure_checkbutton")), g_settings_get_boolean (data->settings, PREF_EXTRACT_RECREATE_FOLDERS)); /* Set the signals handlers. */ g_signal_connect (G_OBJECT (data->dialog), "destroy", G_CALLBACK (file_selector_destroy_cb), data); g_signal_connect (G_OBJECT (data->dialog), "response", G_CALLBACK (file_selector_response_cb), data); g_signal_connect (G_OBJECT (GET_WIDGET ("file_pattern_entry")), "changed", G_CALLBACK (files_entry_changed_cb), data); /* Run dialog. */ gtk_window_set_modal (GTK_WINDOW (data->dialog),TRUE); gtk_widget_show (data->dialog); }
bool wxFileDialog::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 (!wxFileDialogBase::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("wxFileDialog 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); // gtk_widget_hide_on_delete is used here to avoid that Gtk automatically // destroys the dialog when the user press ESC on the dialog: in that case // a second call to ShowModal() would result in a bunch of Gtk-CRITICAL // errors... g_signal_connect(m_widget, "delete_event", G_CALLBACK (gtk_widget_hide_on_delete), this); // 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); // 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; }
static void _lib_import_single_image_callback(GtkWidget *widget,gpointer user_data) { GtkWidget *win = dt_ui_main_window(darktable.gui->ui); GtkWidget *filechooser = gtk_file_chooser_dialog_new (_("import image"), GTK_WINDOW (win), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, (char *)NULL); gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), TRUE); char *last_directory = dt_conf_get_string("ui_last/import_last_directory"); if(last_directory != NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (filechooser), last_directory); char *cp, **extensions, ext[1024]; GtkFileFilter *filter; filter = GTK_FILE_FILTER(gtk_file_filter_new()); extensions = g_strsplit(dt_supported_extensions, ",", 100); for(char **i=extensions; *i!=NULL; i++) { snprintf(ext, 1024, "*.%s", *i); gtk_file_filter_add_pattern(filter, ext); gtk_file_filter_add_pattern(filter, cp=g_ascii_strup(ext, -1)); g_free(cp); } g_strfreev(extensions); gtk_file_filter_set_name(filter, _("supported images")); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter); filter = GTK_FILE_FILTER(gtk_file_filter_new()); gtk_file_filter_add_pattern(filter, "*"); gtk_file_filter_set_name(filter, _("all files")); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter); GtkWidget *preview = gtk_image_new(); gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(filechooser), preview); g_signal_connect(filechooser, "update-preview", G_CALLBACK (_lib_import_update_preview), preview); dt_lib_import_metadata_t metadata; gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filechooser), _lib_import_get_extra_widget(&metadata, FALSE)); if (gtk_dialog_run (GTK_DIALOG (filechooser)) == GTK_RESPONSE_ACCEPT) { dt_conf_set_string("ui_last/import_last_directory", gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (filechooser))); _lib_import_evaluate_extra_widget(&metadata, FALSE); char *filename = NULL; dt_film_t film; GSList *list = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (filechooser)); GSList *it = list; int id = 0; int filmid = 0; /* reset filter to display all images, otherwise view may remain empty */ dt_view_filter_reset_to_show_all(darktable.view_manager); while(it) { filename = (char *)it->data; gchar *directory = g_path_get_dirname((const gchar *)filename); filmid = dt_film_new(&film, directory); id = dt_image_import(filmid, filename, TRUE); if(!id) dt_control_log(_("error loading file `%s'"), filename); g_free (filename); g_free (directory); it = g_slist_next(it); } if(id) { dt_film_open(filmid); // make sure buffers are loaded (load full for testing) dt_mipmap_buffer_t buf; dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, id, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING); if(!buf.buf) { dt_control_log(_("file has unknown format!")); } else { dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf); DT_CTL_SET_GLOBAL(lib_image_mouse_over_id, id); dt_ctl_switch_mode_to(DT_DEVELOP); } } } gtk_widget_destroy(metadata.frame); gtk_widget_destroy (filechooser); gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui)); }
static int FileSelectionDialog(GtkWidget *parent, int type, char *stock) { struct nGetOpenFileData *data; GtkWidget *dlg, *rc; GtkFileFilter *filter; char *fname; data = &FileSelection; data->parent = (parent) ? parent : TopLevel; dlg = gtk_file_chooser_dialog_new(data->title, GTK_WINDOW(data->parent), type, _("_Cancel"), GTK_RESPONSE_CANCEL, stock, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(dlg), TRUE); rc = gtk_check_button_new_with_mnemonic(_("_Change current directory")); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dlg))), rc, FALSE, FALSE, 5); data->chdir_cb = rc; gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dlg), data->multi); data->widget = dlg; if (data->ext) { char *filter_str, *filter_name, *ext_name; filter_str = g_strdup_printf("*.%s", data->ext); ext_name = g_ascii_strup(data->ext, -1); filter_name = g_strdup_printf(_("%s file (*.%s)"), ext_name, data->ext); g_free(ext_name); filter = gtk_file_filter_new(); gtk_file_filter_add_pattern(filter, filter_str); gtk_file_filter_set_name(filter, filter_name); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dlg), filter); g_free(filter_str); g_free(filter_name); filter = gtk_file_filter_new(); gtk_file_filter_add_pattern(filter, "*"); gtk_file_filter_set_name(filter, _("All")); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dlg), filter); } if (data->init_dir && *(data->init_dir)) { gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dlg), *(data->init_dir)); } gtk_widget_show_all(dlg); if (data->changedir && data->init_dir) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->chdir_cb), data->chdir); } else { gtk_widget_hide(data->chdir_cb); } fname = get_filename_with_ext(data->init_file, data->ext); if (fname) { if (type == GTK_FILE_CHOOSER_ACTION_SAVE) { #ifdef WINDOWS char *tmp; tmp = g_locale_from_utf8(fname, -1, NULL, NULL, NULL); if (tmp) { file_dialog_set_current_neme(dlg, tmp); g_free(tmp); } #else /* WINDOWS */ file_dialog_set_current_neme(dlg, fname); #endif /* WINDOWS */ } else { gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dlg), fname); } g_free(fname); } data->ret = IDCANCEL; while (1) { if (ndialog_run(dlg) != GTK_RESPONSE_ACCEPT) break; fsok(dlg); if (data->ret == IDOK && type == GTK_FILE_CHOOSER_ACTION_SAVE) { file_dialog_set_current_neme(dlg, FileSelection.file[0]); if (! data->overwrite && check_overwrite(dlg, FileSelection.file[0])) { data->ret = IDCANCEL; continue; } } break; } gtk_widget_destroy(dlg); reset_event(); data->widget = NULL; return data->ret; }
static void _lib_import_folder_callback(GtkWidget *widget, gpointer user_data) { dt_lib_module_t* self= (dt_lib_module_t*) user_data; GtkWidget *win = dt_ui_main_window(darktable.gui->ui); GtkWidget *filechooser = gtk_file_chooser_dialog_new( _("import film"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, _("_cancel"), GTK_RESPONSE_CANCEL, _("_open"), GTK_RESPONSE_ACCEPT, (char *)NULL); gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), TRUE); char *last_directory = dt_conf_get_string("ui_last/import_last_directory"); if(last_directory != NULL) { gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filechooser), last_directory); g_free(last_directory); } dt_lib_import_metadata_t metadata; gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(filechooser), _lib_import_get_extra_widget(self,&metadata, TRUE)); // run the dialog if(gtk_dialog_run(GTK_DIALOG(filechooser)) == GTK_RESPONSE_ACCEPT) { gchar *folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(filechooser)); dt_conf_set_string("ui_last/import_last_directory", folder); g_free(folder); _lib_import_evaluate_extra_widget(&metadata, TRUE); char *filename = NULL, *first_filename = NULL; GSList *list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(filechooser)); GSList *it = list; /* reset filter so that view isn't empty */ dt_view_filter_reset(darktable.view_manager, TRUE); /* for each selected folder add import job */ while(it) { filename = (char *)it->data; dt_film_import(filename); if(!first_filename) { first_filename = g_strdup(filename); if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(metadata.recursive))) first_filename = dt_util_dstrcat(first_filename, "%%"); } g_free(filename); it = g_slist_next(it); } /* update collection to view import */ if(first_filename) { dt_conf_set_int("plugins/lighttable/collect/num_rules", 1); dt_conf_set_int("plugins/lighttable/collect/item0", 0); dt_conf_set_string("plugins/lighttable/collect/string0", first_filename); dt_collection_update_query(darktable.collection); g_free(first_filename); } g_slist_free(list); } #ifdef USE_LUA dt_lib_import_t *d = (dt_lib_import_t *)self->data; // remove the extra portion from the filechooser before destroying it GtkWidget * parent =gtk_widget_get_parent(d->extra_lua_widgets); gtk_container_remove(GTK_CONTAINER(parent),d->extra_lua_widgets); #endif gtk_widget_destroy(metadata.frame); gtk_widget_destroy(filechooser); gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui)); }
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); } 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); 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; }
void on_import_fb2k_preset_clicked (GtkButton *button, gpointer user_data) { GtkWidget *dlg = gtk_file_chooser_dialog_new (_("Import Foobar2000 EQ Preset..."), GTK_WINDOW (mainwin), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL); GtkFileFilter* flt; flt = gtk_file_filter_new (); gtk_file_filter_set_name (flt, _("Foobar2000 EQ presets (*.feq)")); gtk_file_filter_add_pattern (flt, "*.feq"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dlg), flt); gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dlg), FALSE); // restore folder deadbeef->conf_lock (); gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (dlg), deadbeef->conf_get_str_fast ("filechooser.lastdir", "")); deadbeef->conf_unlock (); int response = gtk_dialog_run (GTK_DIALOG (dlg)); // store folder gchar *folder = gtk_file_chooser_get_current_folder_uri (GTK_FILE_CHOOSER (dlg)); if (folder) { deadbeef->conf_set_str ("filechooser.lastdir", folder); g_free (folder); } if (response == GTK_RESPONSE_OK) { gchar *fname = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dlg)); if (fname) { FILE *fp = fopen (fname, "rt"); if (fp) { int vals[18]; // integer dBs int i = 0; while (i < 18) { char tmp[20]; char *out = fgets (tmp, sizeof (tmp), fp); if (!out) { break; } vals[i] = atoi (tmp); i++; } fclose (fp); if (i == 18) { // apply and save config ddb_dsp_context_t *eq = get_supereq (); if (eq) { set_param (eq, 0, 0); ddb_equalizer_set_preamp (DDB_EQUALIZER (eqwin), 0); for (int i = 0; i < 18; i++) { ddb_equalizer_set_band (DDB_EQUALIZER (eqwin), i, vals[i]); set_param (eq, i+1, vals[i]); } gtk_widget_queue_draw (eqwin); deadbeef->streamer_dsp_chain_save (); } } else { fprintf (stderr, "[eq] corrupted Foobar2000 preset file, discarded\n"); } } g_free (fname); } } gtk_widget_destroy (dlg); }
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; }
/* [nd_gtk thread] */ static gboolean create_gtk_file_dialog(gpointer data) { GTK_FILE_DIALOG_MESSAGE *msg = data; ALLEGRO_DISPLAY *display = msg->display; ALLEGRO_NATIVE_DIALOG *fd = msg->dialog; bool save = fd->flags & ALLEGRO_FILECHOOSER_SAVE; gint result; GtkWidget *window; window = gtk_file_chooser_dialog_new(al_cstr(fd->title), NULL, save ? GTK_FILE_CHOOSER_ACTION_SAVE : GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, save ? GTK_STOCK_SAVE : GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); _al_gtk_make_transient(display, window); if (fd->fc_initial_path) { gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(window), al_path_cstr(fd->fc_initial_path, ALLEGRO_NATIVE_PATH_SEP)); } if (fd->flags & ALLEGRO_FILECHOOSER_MULTIPLE) gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(window), true); /* FIXME: Move all this filter parsing stuff into a common file. */ if (al_ustr_size(fd->fc_patterns) > 0) { GtkFileFilter* filter = gtk_file_filter_new(); int start = 0; int end = 0; bool is_mime_type = false; while (true) { int32_t c = al_ustr_get(fd->fc_patterns, end); if (c < 0 || c == ';') { if (end - start > 0) { ALLEGRO_USTR* pattern = al_ustr_dup_substr(fd->fc_patterns, start, end); if (is_mime_type) { gtk_file_filter_add_mime_type(filter, al_cstr(pattern)); } else { gtk_file_filter_add_pattern(filter, al_cstr(pattern)); } al_ustr_free(pattern); } start = end + 1; is_mime_type = false; } if (c == '/') is_mime_type = true; if (c < 0) break; end += al_utf8_width(c); } gtk_file_filter_set_name(filter, "All supported files"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(window), filter); } result = gtk_dialog_run(GTK_DIALOG(window)); if (result == GTK_RESPONSE_ACCEPT) { GSList* filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(window)); int i; GSList* iter; fd->fc_path_count = g_slist_length(filenames); fd->fc_paths = al_malloc(fd->fc_path_count * sizeof(void *)); for (i = 0, iter = filenames; i < (int)fd->fc_path_count; i++, iter = g_slist_next(iter)) { fd->fc_paths[i] = al_create_path((const char*)iter->data); g_free(iter->data); } g_slist_free(filenames); } gtk_widget_destroy(window); ASSERT(fd->async_queue); g_async_queue_push(fd->async_queue, ACK_CLOSED); return FALSE; }
static void show_open_dialog_handler( GSimpleAction *action, GVariant *param, gpointer data ) { const gchar *pl_exts[] = PLAYLIST_EXTS; GmpvApplication *app = data; GmpvMainWindow *wnd = NULL; GSettings *main_config = NULL; GSettings *win_config = NULL; GtkFileChooser *file_chooser = NULL; GtkFileFilter *filter = NULL; GmpvFileChooser *open_dialog = NULL; gboolean last_folder_enable = FALSE; gboolean append = FALSE; g_variant_get(param, "b", &append); wnd = gmpv_application_get_main_window(app); open_dialog = gmpv_file_chooser_new( append? _("Add File to Playlist"): _("Open File"), GTK_WINDOW(wnd), GTK_FILE_CHOOSER_ACTION_OPEN, _("_Open"), _("_Cancel")); main_config = g_settings_new(CONFIG_ROOT); file_chooser = GTK_FILE_CHOOSER(open_dialog); last_folder_enable = g_settings_get_boolean (main_config, "last-folder-enable"); filter = gtk_file_filter_new(); gtk_file_filter_add_mime_type(filter, "video/*"); gtk_file_filter_add_mime_type(filter, "audio/*"); gtk_file_filter_add_mime_type(filter, "image/*"); for(gint i = 0; pl_exts[i]; i++) { gchar *pattern = g_strdup_printf("*.%s", pl_exts[i]); gtk_file_filter_add_pattern(filter, pattern); g_free(pattern); } gtk_file_chooser_set_filter(file_chooser, filter); if(last_folder_enable) { gchar *last_folder_uri; win_config = g_settings_new(CONFIG_WIN_STATE); last_folder_uri = g_settings_get_string (win_config, "last-folder-uri"); if(last_folder_uri && strlen(last_folder_uri) > 0) { gtk_file_chooser_set_current_folder_uri (file_chooser, last_folder_uri); } g_free(last_folder_uri); } gtk_file_chooser_set_select_multiple(file_chooser, TRUE); if(gmpv_file_chooser_run(open_dialog) == GTK_RESPONSE_ACCEPT) { GSList *uri_slist = gtk_file_chooser_get_filenames(file_chooser); GSList *uri = uri_slist; gsize uri_list_size = sizeof(gchar **)* (g_slist_length(uri_slist)+1); const gchar **uri_list = g_malloc(uri_list_size); gint i; for(i = 0; uri; i++) { uri_list[i] = uri->data; uri = g_slist_next(uri); } uri_list[i] = NULL; if(uri_slist) { GmpvMpvObj *mpv = gmpv_application_get_mpv_obj(app); gmpv_mpv_obj_load_list(mpv, uri_list, append, TRUE); } if(last_folder_enable) { gchar *last_folder_uri = gtk_file_chooser_get_current_folder_uri (file_chooser); g_settings_set_string( win_config, "last-folder-uri", last_folder_uri?:"" ); g_free(last_folder_uri); } g_free(uri_list); g_slist_free_full(uri_slist, g_free); }
/***************************************************************************** * create_session_load_dialog() *****************************************************************************/ void create_session_load_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_load_dialog == NULL) { /* create dialog */ session_load_dialog = gtk_file_chooser_dialog_new("PHASEX - Load Session", GTK_WINDOW(main_window), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_window_set_wmclass(GTK_WINDOW(session_load_dialog), "phasex", "phasex-load"); gtk_window_set_role(GTK_WINDOW(session_load_dialog), "session-load"); gtk_file_chooser_set_preview_widget_active (GTK_FILE_CHOOSER(session_load_dialog), FALSE); /* create spinbutton control for starting program number */ hbox = gtk_hbox_new(FALSE, 8); label = gtk_label_new("Load multiple sessions staring at 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_load_start_spin = gtk_spin_button_new(GTK_ADJUSTMENT(session_io_start_adj), 0, 0); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(session_load_start_spin), TRUE); gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(session_load_start_spin), GTK_UPDATE_IF_VALID); gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(session_load_start_spin), TRUE); gtk_adjustment_set_value(GTK_ADJUSTMENT(session_io_start_adj), (visible_sess_num + 1)); gtk_box_pack_start(GTK_BOX(hbox), session_load_start_spin, FALSE, FALSE, 8); if (new_adj) { g_signal_connect(GTK_OBJECT(session_load_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_load_dialog), hbox); /* realize the file chooser before telling it about files */ gtk_widget_realize(session_load_dialog); /* start in user session dir (usually ~/.phasex/user-sessions) */ gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_load_dialog), user_session_dir); /* allow selection of multiple sessions */ gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(session_load_dialog), TRUE); #if GTK_CHECK_VERSION(2, 6, 0) gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(session_load_dialog), TRUE); #endif /* add user session dirs as shortcut folder */ gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(session_load_dialog), user_session_dir, &error); if (error != NULL) { PHASEX_ERROR("Error %d: %s\n", error->code, error->message); g_error_free(error); } } }
GSList * totem_add_files (GtkWindow *parent, const char *path) { GtkWidget *fs; int response; GSList *filenames; char *mrl, *new_path; GSettings *settings; gboolean set_folder; fs = gtk_file_chooser_dialog_new (_("Select Movies or Playlists"), parent, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("Add Directory"), OPEN_DIRECTORY_RESPONSE, GTK_STOCK_ADD, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fs), filter_all); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fs), filter_supported); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fs), filter_audio); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fs), filter_video); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (fs), filter_supported); gtk_dialog_set_default_response (GTK_DIALOG (fs), GTK_RESPONSE_ACCEPT); gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (fs), TRUE); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (fs), FALSE); settings = g_settings_new (TOTEM_GSETTINGS_SCHEMA); set_folder = TRUE; if (path != NULL) { set_folder = gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (fs), path); } else { new_path = g_settings_get_string (settings, "open-uri"); if (*new_path != '\0') { set_folder = gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (fs), new_path); } g_free (new_path); } /* We didn't manage to change the directory */ if (set_folder == FALSE) { gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (fs), g_get_home_dir ()); } totem_add_default_dirs (GTK_FILE_CHOOSER (fs)); response = gtk_dialog_run (GTK_DIALOG (fs)); filenames = NULL; if (response == OPEN_DIRECTORY_RESPONSE || response == GTK_RESPONSE_ACCEPT) { filenames = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (fs)); } if (filenames == NULL) { gtk_widget_destroy (fs); g_object_unref (settings); return NULL; } gtk_widget_destroy (fs); mrl = filenames->data; if (mrl != NULL) { new_path = g_path_get_dirname (mrl); g_settings_set_string (settings, "open-uri", new_path); g_free (new_path); } g_object_unref (settings); return filenames; }
/* This creates all the GTK+ widgets that compose our application, and registers the callbacks */ static GtkWidget* create_player_ui (CustomData *data, guint decknumber) { GtkWidget *stop_button; /* Buttons */ GtkWidget *title; GtkWidget *myGrid; myGrid = gtk_grid_new(); data->playPauseButton = _create_media_button (GTK_STOCK_MEDIA_PAUSE); g_signal_connect (G_OBJECT (data->playPauseButton), "clicked", G_CALLBACK (playpause_cb), data); stop_button = _create_media_button (GTK_STOCK_MEDIA_STOP); g_signal_connect (G_OBJECT (stop_button), "clicked", G_CALLBACK (stop_cb), data); data->slider = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1); gtk_scale_set_draw_value (GTK_SCALE (data->slider), 0); data->slider_update_signal_id = g_signal_connect (G_OBJECT (data->slider), "value-changed", G_CALLBACK (slider_cb), data); g_signal_connect (G_OBJECT (data->slider), "move-slider", G_CALLBACK (slider_cb), data); data->timelabel = gtk_label_new (""); update_timelabel(data, "Time remaining"); data->taglabel = gtk_label_new ("Selected filename"); { data->filechooser = gtk_file_chooser_widget_new (GTK_FILE_CHOOSER_ACTION_OPEN); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (data->filechooser), TRUE); gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (data->filechooser), FALSE); gtk_file_chooser_set_use_preview_label (GTK_FILE_CHOOSER (data->filechooser), FALSE); if (NULL != data->last_folder_uri) { gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (data->filechooser), data->last_folder_uri); } else { gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (data->filechooser), g_get_home_dir()); } GtkFileFilter *filter = gtk_file_filter_new(); gtk_file_filter_add_mime_type (filter, "audio/*"); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (data->filechooser), filter); data->file_selection_signal_id = g_signal_connect (G_OBJECT (data->filechooser), "selection-changed", G_CALLBACK (file_selection_cb), data); /* block signal to prevent false selection on startup*/ g_signal_handler_block (data->filechooser, data->file_selection_signal_id); } { gchar *titlename = g_strdup_printf ("Deck %u\n", decknumber + 1); title = gtk_label_new (titlename); g_free (titlename); } /* arrange all elements into myGrid */ gtk_grid_attach (GTK_GRID (myGrid), data->filechooser, 0, 0, 1, 3); gtk_grid_attach_next_to (GTK_GRID (myGrid), title, data->filechooser, GTK_POS_TOP, 1, 3); gtk_grid_attach_next_to (GTK_GRID (myGrid), data->playPauseButton, data->filechooser, GTK_POS_RIGHT, 1, 1); gtk_grid_attach_next_to (GTK_GRID (myGrid), stop_button, data->playPauseButton, GTK_POS_BOTTOM, 1, 1); gtk_grid_attach_next_to (GTK_GRID (myGrid), data->taglabel, data->filechooser, GTK_POS_BOTTOM, 2, 1); gtk_grid_attach_next_to (GTK_GRID (myGrid), data->timelabel, data->taglabel, GTK_POS_BOTTOM, 2, 1); gtk_grid_attach_next_to (GTK_GRID (myGrid), data->slider, data->timelabel, GTK_POS_BOTTOM, 2, 1); /* allow at least one expanding child, so all uppper widgets will resize * when maximising the window */ gtk_widget_set_hexpand (data->filechooser, TRUE); gtk_widget_set_vexpand (data->filechooser, TRUE); gtk_label_set_line_wrap(GTK_LABEL (data->taglabel), TRUE); return myGrid; }
void get_files_to_play(GtkWidget *widget, gpointer user_data) { /** User single file selection. **/ #ifdef DEBUG DEBUG_FUNC_MARK #endif GtkWidget *file_chooser_dialog = gtk_file_chooser_dialog_new("Choose music files to listen.", NULL, GTK_FILE_CHOOSER_ACTION_OPEN, "Cancel", GTK_RESPONSE_CANCEL, "Open", GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser_dialog), current_folder.c_str() ) ; gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(file_chooser_dialog), FALSE) ; gtk_file_chooser_set_create_folders(GTK_FILE_CHOOSER(file_chooser_dialog), FALSE) ; gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(file_chooser_dialog), TRUE) ; gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(file_chooser_dialog), TRUE) ; GtkFileFilter *file_filter = gtk_file_filter_new() ; for (int c=0 ; c < static_cast<int>(extension_list.size()) ; c++) { gtk_file_filter_add_pattern(GTK_FILE_FILTER(file_filter), extension_list.at(c).c_str()) ; } gtk_file_filter_set_name(GTK_FILE_FILTER(file_filter), "Supported music filetypes") ; gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(file_chooser_dialog), GTK_FILE_FILTER(file_filter)) ; gtk_window_set_position(GTK_WINDOW(file_chooser_dialog), GTK_WIN_POS_CENTER_ALWAYS) ; gtk_widget_set_size_request(file_chooser_dialog,-1,-1) ; gtk_window_set_modal(GTK_WINDOW(file_chooser_dialog), TRUE) ; gtk_window_set_destroy_with_parent(GTK_WINDOW(file_chooser_dialog), TRUE) ; gtk_window_set_type_hint(GTK_WINDOW(file_chooser_dialog), GDK_WINDOW_TYPE_HINT_DIALOG) ; gtk_window_set_transient_for(GTK_WINDOW(file_chooser_dialog), GTK_WINDOW(gui->window)) ; GSList *filepath_list = NULL ; gint result = gtk_dialog_run (GTK_DIALOG (file_chooser_dialog)); switch (result) { case GTK_RESPONSE_CANCEL : gtk_widget_destroy(file_chooser_dialog); return ; case GTK_RESPONSE_ACCEPT : filepath_list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(file_chooser_dialog)) ; gtk_widget_destroy(file_chooser_dialog) ; break ; } if (filepath_list != NULL) { gchar *file_dirname = g_path_get_dirname((const gchar *) g_slist_nth_data(filepath_list, 0)) ; check_files(filepath_list) ; current_folder = file_dirname ; g_free(file_dirname) ; #ifdef DEBUG fprintf(stdout,"%s current_folder: %s\n", __func__, current_folder.c_str() ) ; #endif g_slist_free(filepath_list) ; } }
GtkWidget* _gwy_app_file_chooser_get(GtkFileChooserAction action) { GtkDialog *dialog; GwyAppFileChooser *chooser; GtkWidget **instance; const gchar *title; switch (action) { case GTK_FILE_CHOOSER_ACTION_OPEN: instance = &instance_open; title = _("Open File"); break; case GTK_FILE_CHOOSER_ACTION_SAVE: instance = &instance_save; title = _("Save File"); break; default: g_return_val_if_reached(NULL); break; } if (*instance) return *instance; ensure_gtk_recently_used(); chooser = g_object_new(GWY_TYPE_APP_FILE_CHOOSER, "title", title, "action", action, NULL); *instance = GTK_WIDGET(chooser); dialog = GTK_DIALOG(chooser); g_object_add_weak_pointer(G_OBJECT(chooser), (gpointer*)instance); gtk_dialog_add_button(dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); switch (action) { case GTK_FILE_CHOOSER_ACTION_OPEN: chooser->prefix = "/app/file/load"; gtk_dialog_add_button(dialog, GTK_STOCK_OPEN, GTK_RESPONSE_OK); gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(chooser), TRUE); break; case GTK_FILE_CHOOSER_ACTION_SAVE: chooser->prefix = "/app/file/save"; gtk_dialog_add_button(dialog, GTK_STOCK_SAVE, GTK_RESPONSE_OK); break; default: g_assert_not_reached(); break; } gwy_help_add_to_window(GTK_WINDOW(dialog), "managing-files", NULL, GWY_HELP_DEFAULT); gtk_dialog_set_default_response(dialog, GTK_RESPONSE_OK); gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(dialog), TRUE); gwy_app_file_chooser_setup_filter(chooser); gwy_app_file_chooser_add_type_list(chooser); gwy_app_file_chooser_add_preview(chooser); g_signal_connect(chooser, "response", G_CALLBACK(gwy_app_file_chooser_save_position), NULL); gwy_app_restore_window_position(GTK_WINDOW(chooser), chooser->prefix, TRUE); return *instance; }
void ags_menu_action_save_as_callback(GtkWidget *menu_item, gpointer data) { AgsApplicationContext *application_context; AgsWindow *window; GtkFileChooserDialog *file_chooser; gint response; application_context = ags_application_context_get_instance(); window = (AgsWindow *) ags_ui_provider_get_window(AGS_UI_PROVIDER(application_context)); file_chooser = (GtkFileChooserDialog *) gtk_file_chooser_dialog_new("save file as", (GtkWindow *) window, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(file_chooser), FALSE); gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(file_chooser), TRUE); gtk_widget_show_all((GtkWidget *) file_chooser); response = gtk_dialog_run(GTK_DIALOG(file_chooser)); if(response == GTK_RESPONSE_ACCEPT){ gchar *filename; gchar *str; GError *error; filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_chooser)); if(g_strcmp0(ags_config_get_value(AGS_APPLICATION_CONTEXT(application_context)->config, AGS_CONFIG_GENERIC, "simple-file"), "false")){ AgsSimpleFile *simple_file; simple_file = (AgsSimpleFile *) g_object_new(AGS_TYPE_SIMPLE_FILE, "application-context", application_context, "filename", filename, NULL); error = NULL; ags_simple_file_rw_open(simple_file, TRUE, &error); ags_simple_file_write(simple_file); ags_simple_file_close(simple_file); g_object_unref(G_OBJECT(simple_file)); }else{ AgsFile *file; file = (AgsFile *) g_object_new(AGS_TYPE_FILE, "application-context", application_context, "filename", filename, NULL); error = NULL; ags_file_rw_open(file, TRUE, &error); ags_file_write(file); ags_file_close(file); g_object_unref(G_OBJECT(file)); } if(window->name != NULL){ g_free(window->name); } window->name = g_strdup(filename); str = g_strconcat("GSequencer - ", window->name, NULL); gtk_window_set_title((GtkWindow *) window, str); g_free(str); } gtk_widget_destroy((GtkWidget *) file_chooser); }
static char *filedialog(GtkWindow *parent, GtkFileChooserAction mode, const gchar *confirm, char* filter, char* initpath) { GtkWidget *fcd; GtkFileChooser *fc; gint response; char *filename; fcd = gtk_file_chooser_dialog_new(NULL, parent, mode, "_Cancel", GTK_RESPONSE_CANCEL, confirm, GTK_RESPONSE_ACCEPT, NULL); fc = GTK_FILE_CHOOSER(fcd); // filters { gchar _filter[256]; gchar* fp = &_filter[0]; int s = 0; gchar* fname; for (int i = 0; i < 255; i++) { if (filter[i] == '|' || filter[i] == '\0') { _filter[i] = '\0'; if (s & 1) { GtkFileFilter* filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, fname); for (gchar* j = fp; ; j++) { if (*j == ';') { *j = '\0'; gtk_file_filter_add_pattern(filter, fp); fp = j+1; } else if (*j == '\0') { gtk_file_filter_add_pattern(filter, fp); break; } } gtk_file_chooser_add_filter(fc, filter); } else { fname = fp; } fp = &_filter[i+1]; s++; if (s >= 8) break; if (filter[i] == '\0') break; } else _filter[i] = filter[i]; } } gtk_file_chooser_set_local_only(fc, FALSE); gtk_file_chooser_set_select_multiple(fc, FALSE); gtk_file_chooser_set_show_hidden(fc, TRUE); gtk_file_chooser_set_do_overwrite_confirmation(fc, TRUE); gtk_file_chooser_set_create_folders(fc, TRUE); if (initpath && strlen(initpath)>0) gtk_file_chooser_set_current_folder(fc, initpath); response = gtk_dialog_run(GTK_DIALOG(fcd)); if (response != GTK_RESPONSE_ACCEPT) { gtk_widget_destroy(fcd); return NULL; } filename = uiUnixStrdupText(gtk_file_chooser_get_filename(fc)); gtk_widget_destroy(fcd); return filename; }
/* create the "add" dialog. */ void add_folder_cb (GtkWidget *widget, void *callback_data) { GtkWidget *file_sel; DialogData *data; GtkWidget *main_box; GtkWidget *vbox; GtkWidget *grid; GtkWidget *align; data = g_new0 (DialogData, 1); data->settings = g_settings_new (ENGRAMPA_SCHEMA_ADD); data->window = callback_data; data->dialog = file_sel = gtk_file_chooser_dialog_new (_("Add a Folder"), GTK_WINDOW (data->window), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, FR_STOCK_ADD_FOLDER, GTK_RESPONSE_OK, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL); gtk_window_set_default_size (GTK_WINDOW (data->dialog), 530, 510); gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (file_sel), FALSE); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (file_sel), FALSE); gtk_dialog_set_default_response (GTK_DIALOG (file_sel), GTK_RESPONSE_OK); data->add_if_newer_checkbutton = gtk_check_button_new_with_mnemonic (_("Add only if _newer")); data->include_subfold_checkbutton = gtk_check_button_new_with_mnemonic (_("_Include subfolders")); data->exclude_symlinks = gtk_check_button_new_with_mnemonic (_("Exclude folders that are symbolic lin_ks")); data->include_files_entry = gtk_entry_new (); gtk_widget_set_tooltip_text (data->include_files_entry, _("example: *.o; *.bak")); data->include_files_label = gtk_label_new_with_mnemonic (_("Include _files:")); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (data->include_files_label), 0.0); #else gtk_misc_set_alignment (GTK_MISC (data->include_files_label), 0.0, 0.5); #endif gtk_label_set_mnemonic_widget (GTK_LABEL (data->include_files_label), data->include_files_entry); data->exclude_files_entry = gtk_entry_new (); gtk_widget_set_tooltip_text (data->exclude_files_entry, _("example: *.o; *.bak")); data->exclude_files_label = gtk_label_new_with_mnemonic (_("E_xclude files:")); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (data->exclude_files_label), 0.0); #else gtk_misc_set_alignment (GTK_MISC (data->exclude_files_label), 0.0, 0.5); #endif gtk_label_set_mnemonic_widget (GTK_LABEL (data->exclude_files_label), data->exclude_files_entry); data->exclude_folders_entry = gtk_entry_new (); gtk_widget_set_tooltip_text (data->exclude_folders_entry, _("example: *.o; *.bak")); data->exclude_folders_label = gtk_label_new_with_mnemonic (_("_Exclude folders:")); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (data->exclude_folders_label), 0.0); #else gtk_misc_set_alignment (GTK_MISC (data->exclude_folders_label), 0.0, 0.5); #endif gtk_label_set_mnemonic_widget (GTK_LABEL (data->exclude_folders_label), data->exclude_folders_entry); data->load_button = gtk_button_new_with_mnemonic (_("_Load Options")); data->save_button = gtk_button_new_with_mnemonic (_("Sa_ve Options")); data->clear_button = gtk_button_new_with_mnemonic (_("_Reset Options")); main_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 20); gtk_container_set_border_width (GTK_CONTAINER (main_box), 0); gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (file_sel), main_box); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_set_border_width (GTK_CONTAINER (vbox), 0); gtk_box_pack_start (GTK_BOX (main_box), vbox, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), data->include_subfold_checkbutton, TRUE, TRUE, 0); align = gtk_alignment_new (0, 0, 0, 0); gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 0, 12, 0); gtk_container_add (GTK_CONTAINER (align), data->exclude_symlinks); gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), data->add_if_newer_checkbutton, TRUE, TRUE, 0); grid = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (grid), 6); gtk_grid_set_column_spacing (GTK_GRID (grid), 6); gtk_box_pack_start (GTK_BOX (vbox), grid, TRUE, TRUE, 0); gtk_grid_attach (GTK_GRID (grid), data->include_files_label, 0, 0, 1, 1); gtk_grid_attach (GTK_GRID (grid), data->include_files_entry, 1, 0, 3, 1); gtk_grid_attach (GTK_GRID (grid), data->exclude_files_label, 0, 1, 1, 1); gtk_grid_attach (GTK_GRID (grid), data->exclude_files_entry, 1, 1, 1, 1); gtk_grid_attach (GTK_GRID (grid), data->exclude_folders_label, 2, 1, 1, 1); gtk_grid_attach (GTK_GRID (grid), data->exclude_folders_entry, 3, 1, 1, 1); /**/ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); gtk_container_set_border_width (GTK_CONTAINER (vbox), 0); gtk_box_pack_start (GTK_BOX (main_box), vbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), data->load_button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), data->save_button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), data->clear_button, FALSE, FALSE, 0); gtk_widget_show_all (main_box); /* set data */ dlg_add_folder_load_last_options (data); /* signals */ g_signal_connect (G_OBJECT (file_sel), "destroy", G_CALLBACK (open_file_destroy_cb), data); g_signal_connect (G_OBJECT (file_sel), "response", G_CALLBACK (file_sel_response_cb), data); g_signal_connect (G_OBJECT (data->include_subfold_checkbutton), "toggled", G_CALLBACK (include_subfold_toggled_cb), data); g_signal_connect (G_OBJECT (data->load_button), "clicked", G_CALLBACK (load_options_cb), data); g_signal_connect (G_OBJECT (data->save_button), "clicked", G_CALLBACK (save_options_cb), data); g_signal_connect (G_OBJECT (data->clear_button), "clicked", G_CALLBACK (clear_options_cb), data); gtk_window_set_modal (GTK_WINDOW (file_sel),TRUE); gtk_widget_show (file_sel); }
void project_open(void) { const gchar *dir = local_prefs.project_file_path; #ifdef G_OS_WIN32 gchar *file; #else GtkWidget *dialog; GtkFileFilter *filter; gchar *locale_path; #endif if (! project_ask_close()) return; #ifdef G_OS_WIN32 file = win32_show_project_open_dialog(main_widgets.window, _("Open Project"), dir, FALSE, TRUE); if (file != NULL) { /* try to load the config */ if (! project_load_file_with_session(file)) { SHOW_ERR1(_("Project file \"%s\" could not be loaded."), file); } g_free(file); } #else dialog = gtk_file_chooser_dialog_new(_("Open Project"), GTK_WINDOW(main_widgets.window), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_widget_set_name(dialog, "GeanyDialogProject"); /* set default Open, so pressing enter can open multiple files */ gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT); gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE); gtk_window_set_skip_taskbar_hint(GTK_WINDOW(dialog), TRUE); gtk_window_set_type_hint(GTK_WINDOW(dialog), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window)); gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE); /* add FileFilters */ filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, _("All files")); gtk_file_filter_add_pattern(filter, "*"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter); filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, _("Project files")); gtk_file_filter_add_pattern(filter, "*." GEANY_PROJECT_EXT); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter); gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter); locale_path = utils_get_locale_from_utf8(dir); if (g_file_test(locale_path, G_FILE_TEST_EXISTS) && g_file_test(locale_path, G_FILE_TEST_IS_DIR)) { gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), locale_path); } g_free(locale_path); gtk_widget_show_all(dialog); run_open_dialog(GTK_DIALOG(dialog)); gtk_widget_destroy(GTK_WIDGET(dialog)); #endif }
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; }
static void remmina_ftp_client_action_upload(GObject *object, RemminaFTPClient *client) { RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*) client->priv; GtkListStore *store = GTK_LIST_STORE(priv->task_list_model); GtkTreeIter iter; GtkWidget *dialog; GtkWidget *upload_folder_check; gint type; GSList *files = NULL; GSList *element; gchar *path; gchar *dir, *name; struct stat st; dialog = gtk_file_chooser_dialog_new(_("Choose a file to upload"), GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(client))), GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, "_OK", GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE); if (priv->working_directory) { gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), priv->working_directory); } upload_folder_check = gtk_check_button_new_with_label(_("Upload folder")); gtk_widget_show(upload_folder_check); g_signal_connect(G_OBJECT(upload_folder_check), "toggled", G_CALLBACK(remmina_ftp_client_upload_folder_on_toggled), dialog); gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dialog), upload_folder_check); if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { g_free(priv->working_directory); priv->working_directory = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(dialog)); files = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog)); } type = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(upload_folder_check)) ? REMMINA_FTP_FILE_TYPE_DIR : REMMINA_FTP_FILE_TYPE_FILE; gtk_widget_destroy(dialog); if (!files) return; for (element = files; element; element = element->next) { path = (gchar*) element->data; if (g_stat(path, &st) < 0) continue; name = g_strrstr(path, "/"); if (name) { *name++ = '\0'; dir = path; } else { name = path; dir = NULL; } gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, REMMINA_FTP_TASK_COLUMN_TYPE, type, REMMINA_FTP_TASK_COLUMN_NAME, name, REMMINA_FTP_TASK_COLUMN_SIZE, (gfloat) st.st_size, REMMINA_FTP_TASK_COLUMN_TASKID, remmina_ftp_client_taskid++, REMMINA_FTP_TASK_COLUMN_TASKTYPE, REMMINA_FTP_TASK_TYPE_UPLOAD, REMMINA_FTP_TASK_COLUMN_REMOTEDIR, priv->current_directory, REMMINA_FTP_TASK_COLUMN_LOCALDIR, dir, REMMINA_FTP_TASK_COLUMN_STATUS, REMMINA_FTP_TASK_STATUS_WAIT, REMMINA_FTP_TASK_COLUMN_DONESIZE, 0.0, REMMINA_FTP_TASK_COLUMN_TOOLTIP, NULL, -1); g_free(path); } g_slist_free(files); g_signal_emit(G_OBJECT(client), remmina_ftp_client_signals[NEW_TASK_SIGNAL], 0); }
static void dlg_extract__common (FrWindow *window, GList *selected_files, char *base_dir_for_selection) { DialogData *data; GtkWidget *file_sel; data = g_new0 (DialogData, 1); data->settings = g_settings_new (EXRED_SCHEMA_EXTRACT); data->window = window; data->selected_files = selected_files; data->base_dir_for_selection = base_dir_for_selection; data->extract_clicked = FALSE; data->dialog = file_sel = gtk_file_chooser_dialog_new (_("Extract"), GTK_WINDOW (data->window), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, FR_STOCK_EXTRACT, GTK_RESPONSE_OK, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL); gtk_window_set_default_size (GTK_WINDOW (file_sel), 530, 510); gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (file_sel), FALSE); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (file_sel), FALSE); gtk_dialog_set_default_response (GTK_DIALOG (file_sel), GTK_RESPONSE_OK); gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (file_sel), create_extra_widget (data)); /* Set widgets data. */ gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (file_sel), fr_window_get_extract_default_dir (window)); if (data->selected_files != NULL) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_selected_radiobutton), TRUE); else { gtk_widget_set_sensitive (data->e_selected_radiobutton, FALSE); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_all_radiobutton), TRUE); } gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_overwrite_checkbutton), g_settings_get_boolean (data->settings, PREF_EXTRACT_OVERWRITE)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_not_newer_checkbutton), g_settings_get_boolean (data->settings, PREF_EXTRACT_SKIP_NEWER)); if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->e_overwrite_checkbutton))) { gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (data->e_not_newer_checkbutton), TRUE); gtk_widget_set_sensitive (data->e_not_newer_checkbutton, FALSE); } gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_recreate_dir_checkbutton), g_settings_get_boolean (data->settings, PREF_EXTRACT_RECREATE_FOLDERS)); /* Set the signals handlers. */ g_signal_connect (G_OBJECT (data->dialog), "destroy", G_CALLBACK (destroy_cb), data); g_signal_connect (G_OBJECT (file_sel), "response", G_CALLBACK (file_sel_response_cb), data); g_signal_connect (G_OBJECT (data->e_overwrite_checkbutton), "toggled", G_CALLBACK (overwrite_toggled_cb), data); g_signal_connect (G_OBJECT (data->e_files_entry), "changed", G_CALLBACK (files_entry_changed_cb), data); /* Run dialog. */ gtk_window_set_modal (GTK_WINDOW (file_sel),TRUE); gtk_widget_show (file_sel); }
void gtkutil_file_req (const char *title, void *callback, void *userdata, char *filter, char *extensions, int flags) { struct file_req *freq; GtkWidget *dialog; GtkFileFilter *filefilter; extern char *get_xdir_fs (void); char *token; char *tokenbuffer; #if 0 /* native file dialogs */ #ifdef WIN32 if (!(flags & FRF_WRITE)) { freq = malloc (sizeof (struct file_req)); freq->th = thread_new (); freq->flags = 0; freq->multiple = (flags & FRF_MULTIPLE); freq->callback = callback; freq->userdata = userdata; freq->title = g_locale_from_utf8 (title, -1, 0, 0, 0); if (!filter) { freq->filter = "All files\0*.*\0" "Executables\0*.exe\0" "ZIP files\0*.zip\0\0"; } else { freq->filter = filter; } thread_start (freq->th, win32_thread, freq); fe_input_add (freq->th->pipe_fd[0], FIA_FD|FIA_READ, win32_read_thread, freq); return; } else { freq = malloc (sizeof (struct file_req)); freq->th = thread_new (); freq->flags = 0; freq->multiple = (flags & FRF_MULTIPLE); freq->callback = callback; freq->userdata = userdata; freq->title = g_locale_from_utf8 (title, -1, 0, 0, 0); if (!filter) { freq->filter = "All files\0*.*\0\0"; } else { freq->filter = filter; } thread_start (freq->th, win32_thread2, freq); fe_input_add (freq->th->pipe_fd[0], FIA_FD|FIA_READ, win32_read_thread, freq); return; } #endif #endif if (flags & FRF_WRITE) { dialog = gtk_file_chooser_dialog_new (title, NULL, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); if (filter && filter[0]) /* filter becomes initial name when saving */ { char temp[1024]; path_part (filter, temp, sizeof (temp)); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), temp); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), file_part (filter)); } if (!(flags & FRF_NOASKOVERWRITE)) gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); } else dialog = gtk_file_chooser_dialog_new (title, NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); if (flags & FRF_MULTIPLE) gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE); if (last_dir[0]) gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), last_dir); if (flags & FRF_ADDFOLDER) gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog), get_xdir (), NULL); if (flags & FRF_CHOOSEFOLDER) { gtk_file_chooser_set_action (GTK_FILE_CHOOSER (dialog), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), filter); } else { if (filter && (flags & FRF_FILTERISINITIAL)) { gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), filter); } /* With DCC, we can't rely on filter as initial folder since filter already contains * the filename upon DCC RECV. Thus we have no better option than to check for the message * which will be the title of the window. For DCC it always contains the "offering" word. * This method is really ugly but it works so we'll stick with it for now. */ else if (strstr (title, "offering") != NULL) { gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), prefs.hex_dcc_dir); } /* by default, open the config folder */ else { gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), get_xdir ()); } } if (flags & FRF_EXTENSIONS && extensions != NULL) { filefilter = gtk_file_filter_new (); tokenbuffer = g_strdup (extensions); token = strtok (tokenbuffer, ";"); while (token != NULL) { gtk_file_filter_add_pattern (filefilter, token); token = strtok (NULL, ";"); } g_free (tokenbuffer); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filefilter); } freq = malloc (sizeof (struct file_req)); freq->dialog = dialog; freq->flags = flags; freq->callback = callback; freq->userdata = userdata; g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (gtkutil_file_req_response), freq); g_signal_connect (G_OBJECT (dialog), "destroy", G_CALLBACK (gtkutil_file_req_destroy), (gpointer) freq); gtk_widget_show (dialog); }
// Обработчик нажатия кнопки Открыть файл. void cMainWin::OnOpenFile(GtkWidget *widget, cMainWin *aMainWin) { GtkWidget *dialog; // Объявим новый виджет диалога выбора файла. // Теперь создадим его, как отдельное окно с заголовком Выберите файл и двумя кнопками Отмена и Открыть. // Нажатие на кнопку Отмена вызовет сигнал GTK_RESPONSE_CANCEL. // Нажатие на кнопку Открыть вызовет сигнал GTK_RESPONSE_ACCEPT. dialog = gtk_file_chooser_dialog_new ("Выберите файл", GTK_WINDOW(aMainWin->mwWindow), GTK_FILE_CHOOSER_ACTION_OPEN, ("_Cancel"), GTK_RESPONSE_CANCEL, ("_Open"), GTK_RESPONSE_ACCEPT, NULL); GtkFileFilter *filter = gtk_file_filter_new (); // Создадим новый фильтр для расширений файлов. gtk_file_filter_add_pattern (filter, "*.mp3"); // Добавим в фильтр шаблон файлов с расширением .mp3, gtk_file_filter_add_pattern (filter, "*.MP3"); // .MP3, gtk_file_filter_add_pattern (filter, "*.wav"); // .wav, gtk_file_filter_add_pattern (filter, "*.WAV"); // .WAV, gtk_file_filter_add_pattern (filter, "*.ogg"); // .ogg, gtk_file_filter_add_pattern (filter, "*.OGG"); // .OGG gtk_file_filter_set_name (filter, ".mp3, .wav, .ogg"); // и установим имя этого фильтра. gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter); // Добавим фильтр в диалог выбора файла. gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter); // Установим фильтр для диалога. //Нельзя выбирать несколько записей одновременно - приведёт к непредсказемой работе последующих методов. gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER(dialog), FALSE); // Запустим поток диалогового окна. Тут же вызовется функция отображения всех виджетов окна. // Поток будет выполняться до получения сигнала ответа или уничтожения диалогового окна. if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { // Извлекаем нужные URI из полученного. unsigned int slash; std::string source = (const char *)gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (dialog)); // Получаем абсолютный путь до файла. slash = source.rfind("/"); // Находим последний слэш. if(slash==std::string::npos) // Если слэш - последний символ в источнике, то нужно оповестить об ошибке, т.к. файл не выбран. { g_print("Ошибка при добавлении файла\n"); gtk_widget_destroy (dialog); aMainWin->PrintNotification("Ошибка при добавлении файла", eNotifTypeError); // Выводим диалоговое окно с ошибкой. return; } //Извелкаем URI для базы данных std::string asFullPatch = source; // Используя особенную функцию отсечения текста до последнего символа и функцию замены одного символа на другой получим короткий путь до файла. // Именно его и будем использовать в базе данных и при выводе в окне конвертера. std::string asShortPatch = aMainWin->FindLastNCopyAfter(asFullPatch, "/"); aMainWin->FindNReplace(asShortPatch, "/", ""); // Точно также выделим тип файла. std::string asTypeString = aMainWin->FindLastNCopyAfter(asFullPatch, "."); aMainWin->FindNReplace(asTypeString, ".", ""); // Теперь выделим имя папки с файлом с помощью другой функции, которая копирует текст сначала и по последнее упоминание символа. std::string asFolderName = aMainWin->FindLastNCopy(asFullPatch, "/"); // Отобразим в консоли все полученные пути для тестов. std::cout << "Информация о файле: " << std::endl; std::cout << "\tКороткий путь до файла: " << asShortPatch << std::endl; std::cout << "\tТип файла: " << asTypeString << std::endl; std::cout << "\tИмя папки с файлом: " << asFolderName << std::endl; // Теперь создадим новый трек с полученными параметрами и добавим его в базу данных. cTrack *aTrack = new cTrack(asFullPatch, asShortPatch, asTypeString, asFolderName); aMainWin->AddNewTrack(aTrack); } gtk_widget_destroy (dialog); // После использования окна, можем его уничтожить. }
void vinagre_cmd_remote_open (GtkAction *action, VinagreWindow *window) { GtkWidget *tab; VinagreConnection *conn; GtkWidget *dialog; GtkFileFilter *filter; GSList *files, *l; gchar *uri; gchar *error = NULL; GSList *errors = NULL; gint i = 0; GHashTable *protocols; GHashTableIter iter; VinagreProtocol *protocol; g_return_if_fail (VINAGRE_IS_WINDOW (window)); dialog = gtk_file_chooser_dialog_new (_("Choose the file"), GTK_WINDOW (window), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (dialog), FALSE); gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE); protocols = vinagre_plugins_engine_get_plugins_by_protocol (vinagre_plugins_engine_get_default ()); g_hash_table_iter_init (&iter, protocols); while (g_hash_table_iter_next (&iter, NULL, (gpointer *)&protocol)) { filter = vinagre_protocol_get_file_filter (protocol); if (filter) { gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); i++; } } if (i == 0) { vinagre_utils_show_error_dialog (_("There are no supported files"), _("None of the active plugins support this action. Activate some plugins and try again."), GTK_WINDOW (window)); goto finalize; } if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { files = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (dialog)); for (l = files; l; l = l->next) { uri = (gchar *)l->data; conn = vinagre_connection_new_from_file (uri, &error, FALSE); if (conn) { tab = vinagre_tab_new (conn, window); vinagre_notebook_add_tab (VINAGRE_NOTEBOOK (window->priv->notebook), VINAGRE_TAB (tab), -1); g_object_unref (conn); } else { errors = g_slist_append (errors, g_strdup_printf ("<i>%s</i>: %s", uri, error?error:_("Unknown error"))); g_free (error); } g_free (uri); } g_slist_free (files); } if (errors) { vinagre_utils_show_many_errors (ngettext ("The following file could not be opened:", "The following files could not be opened:", g_slist_length (errors)), errors, GTK_WINDOW (window)); g_slist_free_full (errors, g_free); } finalize: gtk_widget_destroy (dialog); }
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); } }
bool show(Display* parent) override { static std::string s_lastUsedDir; if (s_lastUsedDir.empty()) s_lastUsedDir = g_get_user_special_dir(G_USER_DIRECTORY_DESKTOP); const char* okLabel; GtkFileChooserAction action; switch (m_type) { case Type::OpenFile: case Type::OpenFiles: action = GTK_FILE_CHOOSER_ACTION_OPEN; okLabel = "_Open"; break; case Type::OpenFolder: action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER; okLabel = "_Open Folder"; break; case Type::SaveFile: action = GTK_FILE_CHOOSER_ACTION_SAVE; okLabel = "_Save"; break; } // GtkWindow* gtkParent = nullptr; GtkWidget* dialog = gtk_file_chooser_dialog_new( m_title.c_str(), nullptr, action, "_Cancel", GTK_RESPONSE_CANCEL, okLabel, GTK_RESPONSE_ACCEPT, nullptr); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); GtkFileChooser* chooser = GTK_FILE_CHOOSER(dialog); m_chooser = chooser; if (m_type == Type::SaveFile) gtk_file_chooser_set_do_overwrite_confirmation(chooser, TRUE); else if (m_type == Type::OpenFiles) gtk_file_chooser_set_select_multiple(chooser, true); if (m_type != Type::OpenFolder) { setupFilters(base::get_file_extension(m_filename)); setupPreview(); } if (m_initialDir.empty()) gtk_file_chooser_set_current_folder(chooser, s_lastUsedDir.c_str()); else gtk_file_chooser_set_current_folder(chooser, m_initialDir.c_str()); if (!m_filename.empty()) { std::string fn = m_filename; // Add default extension if (m_type == Type::SaveFile && base::get_file_extension(fn).empty()) { fn.push_back('.'); fn += m_defExtension; } gtk_file_chooser_set_current_name(chooser, fn.c_str()); } // Setup the "parent" display as the parent of the dialog (we've // to convert a X11 Window into a GdkWindow to do this). GdkWindow* gdkParentWindow = nullptr; if (parent) { GdkWindow* gdkWindow = gtk_widget_get_root_window(dialog); gdkParentWindow = gdk_x11_window_foreign_new_for_display( gdk_window_get_display(gdkWindow), (::Window)parent->nativeHandle()); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); gdk_window_set_transient_for(gdkWindow, gdkParentWindow); } else { gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER); } // Show the dialog gint res = gtk_dialog_run(GTK_DIALOG(dialog)); if (res == GTK_RESPONSE_ACCEPT) { s_lastUsedDir = gtk_file_chooser_get_current_folder(chooser); m_filename = gtk_file_chooser_get_filename(chooser); if (m_type == Type::OpenFiles) { GSList* list = gtk_file_chooser_get_filenames(chooser); g_slist_foreach( list, [](void* fn, void* userdata){ auto self = (FileDialogGTK*)userdata; self->m_filenames.push_back((char*)fn); g_free(fn); }, this); g_slist_free(list); } } gtk_widget_destroy(dialog); if (gdkParentWindow) g_object_unref(gdkParentWindow); // Pump gtk+ events to finally hide the dialog from the screen while (gtk_events_pending()) gtk_main_iteration(); return (res == GTK_RESPONSE_ACCEPT); }
/* 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; }
static void _lib_import_folder_callback(GtkWidget *widget,gpointer user_data) { GtkWidget *win = dt_ui_main_window(darktable.gui->ui); GtkWidget *filechooser = gtk_file_chooser_dialog_new (_("import film"), GTK_WINDOW (win), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, (char *)NULL); gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), TRUE); char *last_directory = dt_conf_get_string("ui_last/import_last_directory"); if(last_directory != NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (filechooser), last_directory); dt_lib_import_metadata_t metadata; gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filechooser), _lib_import_get_extra_widget(&metadata, TRUE)); // run the dialog if (gtk_dialog_run (GTK_DIALOG (filechooser)) == GTK_RESPONSE_ACCEPT) { dt_conf_set_string("ui_last/import_last_directory", gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (filechooser))); _lib_import_evaluate_extra_widget(&metadata, TRUE); char *filename = NULL, *first_filename = NULL; GSList *list = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (filechooser)); GSList *it = list; /* reset filter to display all images, otherwise view may remain empty */ dt_view_filter_reset_to_show_all(darktable.view_manager); /* for each selected folder add import job */ while(it) { filename = (char *)it->data; dt_film_import(filename); if (!first_filename) { first_filename = g_strdup(filename); if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (metadata.recursive))) first_filename = dt_util_dstrcat(first_filename, "%%"); } g_free (filename); it = g_slist_next(it); } /* update collection to view import */ if (first_filename) { dt_conf_set_int("plugins/lighttable/collect/num_rules", 1); dt_conf_set_int("plugins/lighttable/collect/item0", 0); dt_conf_set_string("plugins/lighttable/collect/string0",first_filename); dt_collection_update_query(darktable.collection); g_free(first_filename); } g_slist_free (list); } gtk_widget_destroy(metadata.frame); gtk_widget_destroy (filechooser); gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui)); }
bool ClientHandler::OnFileDialog(CefRefPtr<CefBrowser> browser, FileDialogMode mode, const CefString& title, const CefString& default_file_name, const std::vector<CefString>& accept_types, CefRefPtr<CefFileDialogCallback> callback) { std::vector<CefString> files; GtkFileChooserAction action; const gchar* accept_button; if (mode == FILE_DIALOG_OPEN || mode == FILE_DIALOG_OPEN_MULTIPLE) { action = GTK_FILE_CHOOSER_ACTION_OPEN; accept_button = GTK_STOCK_OPEN; } else if (mode == FILE_DIALOG_SAVE) { action = GTK_FILE_CHOOSER_ACTION_SAVE; accept_button = GTK_STOCK_SAVE; } else { NOTREACHED(); return false; } std::string base_name; if (!default_file_name.empty()) { base_name = basename(const_cast<char*>(default_file_name.ToString().c_str())); } std::string title_str; if (!title.empty()) { title_str = title; } else { switch (mode) { case FILE_DIALOG_OPEN: title_str = "Open File"; break; case FILE_DIALOG_OPEN_MULTIPLE: title_str = "Open Files"; break; case FILE_DIALOG_SAVE: title_str = "Save File"; break; default: break; } } GtkWidget* window = gtk_widget_get_ancestor( GTK_WIDGET(GetMainWindowHandle()), GTK_TYPE_WINDOW); GtkWidget* dialog = gtk_file_chooser_dialog_new( title_str.c_str(), GTK_WINDOW(window), action, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, accept_button, GTK_RESPONSE_ACCEPT, NULL); if (mode == FILE_DIALOG_OPEN_MULTIPLE) { gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE); } else if (mode == FILE_DIALOG_SAVE) { gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE); } if (mode == FILE_DIALOG_SAVE && !base_name.empty()) { gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), base_name.c_str()); } AddFiltersForAcceptTypes(GTK_FILE_CHOOSER(dialog), accept_types, true); bool success = false; if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { if (mode == FILE_DIALOG_OPEN || mode == FILE_DIALOG_SAVE) { char* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); files.push_back(std::string(filename)); success = true; } else if (mode == FILE_DIALOG_OPEN_MULTIPLE) { GSList* filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog)); if (filenames) { for (GSList* iter = filenames; iter != NULL; iter = g_slist_next(iter)) { std::string path(static_cast<char*>(iter->data)); g_free(iter->data); files.push_back(path); } g_slist_free(filenames); success = true; } } } gtk_widget_destroy(dialog); if (success) callback->Continue(files); else callback->Cancel(); return true; }