static void reset_filter (GtkWidget *widget, GParamSpec *spec, gpointer user_data) { if (!gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (widget))) { g_signal_handlers_block_by_func (widget, reset_filter, user_data); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (widget), GTK_FILE_FILTER (user_data)); g_signal_handlers_unblock_by_func (widget, reset_filter, user_data); } }
void GtkToolkitFileChooser::SetDefaultFilter(int id) { GtkFileFilter* filter = GetFilterById(id); if (!filter) return; gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(m_dialog), filter); }
bool FileSelector::Execute(bool open, const char *title) { Ctrl::ReleaseCtrlCapture(); if(!title) title = open ? t_("Open") : t_("Save as"); Ctrl *w = Ctrl::GetActiveWindow(); GtkWidget *fc = gtk_file_chooser_dialog_new(title, w ? w->gtk() : NULL, open ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, open ? GTK_STOCK_OPEN : GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL); gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(fc), confirm); gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(fc), true); gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(fc), multi); gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(fc), hidden); if(IsFullPath(ipath)) { FindFile ff(ipath); if(ff) if(ff.IsFolder()) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fc), ipath); else gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(fc), ipath); else { gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fc), GetFileFolder(ipath)); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(fc), GetFileName(ipath)); } } else gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(fc), ipath); ipath.Clear(); for(int i = 0; i < type.GetCount(); i++) { GtkFileFilter *filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, type[i].a); gtk_file_filter_add_pattern(filter, type[i].b); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fc), filter); if(i == activetype) gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(fc), filter); } bool ret = false; path.Clear(); if(gtk_dialog_run(GTK_DIALOG(fc)) == GTK_RESPONSE_OK) { GSList *list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(fc)); if(list) { GSList *l; for(l = list; l; l = l->next) { path.Add((const char *)l->data); g_free(l->data); } g_slist_free (list); } ret = true; } gtk_widget_destroy(fc); return ret; }
int run_save_dialog() // returns 0 if user canceled { GtkWidget *file_chooser = gtk_file_chooser_dialog_new("Save Map", GTK_WINDOW(window), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); gtk_dialog_set_default_response (GTK_DIALOG (file_chooser), GTK_RESPONSE_ACCEPT); GtkFileFilter *filter; /* Filters */ filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, "All Emergence Maps"); gtk_file_filter_add_pattern (filter, "*.map"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (file_chooser), filter); /* Make this filter the default */ gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (file_chooser), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, "All Files"); gtk_file_filter_add_pattern (filter, "*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (file_chooser), filter); gchar *current_folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (file_chooser)); struct string_t *rel_filename = arb_abs2rel(map_filename->text, current_folder); if(rel_filename) gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (file_chooser), rel_filename->text); g_free(current_folder); free_string(rel_filename); int retval; if (gtk_dialog_run (GTK_DIALOG (file_chooser)) == GTK_RESPONSE_ACCEPT) { char *filename; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (file_chooser)); save_dialog_ok (filename); g_free (filename); retval = 1; } else retval = 0; gtk_widget_destroy (file_chooser); return retval; }
/* EDITOR: COLORMAP VIEWER * ======================= * Colormaps differ from lump files in the way that they don't start with a width | height header * Otherwise they are identical in how they refer to palette indexes for their color */ gint VID_EditorViewColormap(gpointer data) { int i; GtkWidget *dialog; GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN; gint res; loadedfile_t *pic; dialog = gtk_file_chooser_dialog_new ("NGUNIXEd - Open Colormap (.lmp) File", NULL, action, ("_Cancel"), GTK_RESPONSE_CANCEL, ("_Open"), GTK_RESPONSE_ACCEPT, NULL); // Set the dialog and the default path (current directory) GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog); char path[MAX_OSPATH]; sprintf(path, "file://%s", get_current_dir_name()); gtk_file_chooser_set_current_folder_uri(chooser, path); // Add the filter for .lmp files GtkFileFilter *filter = gtk_file_filter_new (); gtk_file_filter_add_pattern (filter, "*.lmp"); gtk_file_chooser_set_filter (chooser, filter); res = gtk_dialog_run (GTK_DIALOG (dialog)); if (res == GTK_RESPONSE_ACCEPT) { char *filename; filename = gtk_file_chooser_get_filename (chooser); pic = COM_LoadFile (filename, 2); if(pic) { Con_Printf("[EDITOR] Previewing Colormap %s\n", filename); ed_file = malloc(16385 + (sizeof(int) * 2)); ed_file->width = 256; ed_file->height = 64; for(i = 0; i < 256 * 64; i++) ed_file->data[i] = pic->data[i]; gtk_window_resize(ed_window, ed_file->width + ed_palfile->width, ed_file->height + ed_menubar->allocation.height); } g_free (filename); } gtk_widget_destroy (dialog); return 0; }
static GtkFileChooser * gui_image_chooser_new (gboolean is_save) { GtkFileChooser *fsel; fsel = GTK_FILE_CHOOSER (g_object_new (GTK_TYPE_FILE_CHOOSER_DIALOG, "action", is_save ? GTK_FILE_CHOOSER_ACTION_SAVE : GTK_FILE_CHOOSER_ACTION_OPEN, "local-only", FALSE, "use-preview-label", FALSE, NULL)); gtk_dialog_add_buttons (GTK_DIALOG (fsel), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, is_save ? GTK_STOCK_SAVE : GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (fsel), GTK_RESPONSE_OK); /* Filters */ { GtkFileFilter *filter; filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("All Files")); gtk_file_filter_add_pattern (filter, "*"); gtk_file_chooser_add_filter (fsel, filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Images")); gtk_file_filter_add_custom (filter, GTK_FILE_FILTER_MIME_TYPE, filter_images, NULL, NULL); gtk_file_chooser_add_filter (fsel, filter); /* Make this filter the default */ gtk_file_chooser_set_filter (fsel, filter); } /* Preview */ { GtkWidget *vbox = gtk_vbox_new (FALSE, 2); GtkWidget *preview_image = gtk_image_new (); GtkWidget *preview_label = gtk_label_new (""); g_object_set_data (G_OBJECT (fsel), "image-widget", preview_image); g_object_set_data (G_OBJECT (fsel), "label-widget", preview_label); gtk_widget_set_size_request (vbox, PREVIEW_HSIZE, -1); gtk_box_pack_start (GTK_BOX (vbox), preview_image, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), preview_label, FALSE, FALSE, 0); gtk_file_chooser_set_preview_widget (fsel, vbox); g_signal_connect (fsel, "update-preview", G_CALLBACK (update_preview_cb), NULL); update_preview_cb (fsel); } return fsel; }
// GTK >= 2.4 static const gchar* create_fsel_2(const gchar *dirname, const gchar *filename, const gchar *ext, gboolean save) { GtkWidget *dialog; GtkFileFilter *filter; gchar *path, *tmp; gchar **sarray; gint i; gchar *sfilename, *sext; // gtk_file_chooser_set_current_name and gtk_file_filter_add_pattern ALWAYS want UTF-8. sfilename = filename ? g_filename_to_utf8(filename,-1,NULL,NULL,NULL) : NULL; sext = ext ? g_filename_to_utf8(ext,-1,NULL,NULL,NULL) : NULL; // create box dialog = gtk_file_chooser_dialog_new ( save ? "Save File" : "Open File", NULL, save ? GTK_FILE_CHOOSER_ACTION_SAVE : GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); // set default folder tmp = g_strconcat(dirname, G_DIR_SEPARATOR_S, NULL); // add leading '/' otherwise get_dirname is confused path = g_path_get_dirname(tmp); g_free(tmp); gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), path); g_free(path); // set default name if(filename) gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), sfilename); // set wildcards filter = gtk_file_filter_new(); sarray = g_strsplit(sext, ";", -1); for(i = 0; sarray[i] != NULL; i++) gtk_file_filter_add_pattern (filter, sarray[i]); g_strfreev(sarray); gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter); // get result g_free(fname); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) fname = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); else fname = NULL; gtk_widget_destroy (dialog); g_free(sfilename); g_free(sext); return fname; }
static void pixbufEditor_init(PixbufEditor *e) { GtkFileFilter *filter; filter = gtk_file_filter_new(); gtk_file_filter_add_pixbuf_formats(filter); gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(e), filter); g_signal_connect(e, "file-set", G_CALLBACK(pixbufEditor_file_set), e); if (e->pixbuf == NULL) e->pixbuf = PIXBUF_EDITOR_GET_CLASS(e)->missing; }
bool FileDialogImpl::run() { //Init the dialog GtkWidget* fileDialog = gtk_file_chooser_dialog_new( m_title.c_str(), nullptr, m_action == FileDialog::Open ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE, _("_Cancel"), GTK_RESPONSE_CANCEL, m_action == FileDialog::Open ? _("_Open") : _("Save"), GTK_RESPONSE_ACCEPT, nullptr ); //Init the filters for(auto it = m_filters.cbegin(); it != m_filters.cend(); ++it) { GtkFileFilter* filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, it->name.c_str()); for(auto it2 = it->patterns.cbegin(); it2 != it->patterns.cend(); ++it2) gtk_file_filter_add_pattern(filter, (*it2).c_str()); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileDialog), filter); } //Set the default filter GSList* filtersList = gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(fileDialog)); if(m_selectedFilter < g_slist_length(filtersList)) gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(fileDialog), GTK_FILE_FILTER(g_slist_nth_data(filtersList, m_selectedFilter))); g_slist_free(filtersList); gtk_window_set_keep_above(GTK_WINDOW(fileDialog), TRUE); //Run it gint result = gtk_dialog_run(GTK_DIALOG(fileDialog)); if(result == GTK_RESPONSE_ACCEPT) { char* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fileDialog)); m_selectedFileName = std::string(filename); g_free(filename); } gtk_window_close(GTK_WINDOW(fileDialog)); gtk_widget_destroy(fileDialog); while (gtk_events_pending()) gtk_main_iteration_do(false); return result == GTK_RESPONSE_ACCEPT; }
void GTKFileDialog::AddFilters(const std::vector<const char *> &FileTypes, const std::vector<const char *> &FileTypeNames) { for (uint32_t i = 0; i < FileTypes.size(); i++) { Filter = gtk_file_filter_new(); gtk_file_filter_add_pattern(Filter, FileTypes[i]); gtk_file_filter_set_name(Filter, FileTypeNames[i]); gtk_file_chooser_add_filter(FileDialog, Filter); if (i == 0) gtk_file_chooser_set_filter(FileDialog, Filter); } }
/** * ev_document_factory_add_filters: * @chooser: a #GtkFileChooser * @document: a #EvDocument, or %NULL * * Adds some file filters to @chooser. * Always add a "All documents" format. * * If @document is not %NULL, adds a #GtkFileFilter for @document's MIME type. * * If @document is %NULL, adds a #GtkFileFilter for each document type that atril * can handle. */ void ev_document_factory_add_filters (GtkWidget *chooser, EvDocument *document) { GList *all_types; GtkFileFilter *filter; GtkFileFilter *default_filter; GtkFileFilter *document_filter; g_return_if_fail (GTK_IS_FILE_CHOOSER (chooser)); g_return_if_fail (document == NULL || EV_IS_DOCUMENT (document)); all_types = ev_backends_manager_get_all_types_info (); default_filter = document_filter = filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("All Documents")); g_list_foreach (all_types, (GFunc)file_filter_add_mime_types, filter); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter); if (document) { EvTypeInfo *info; info = ev_backends_manager_get_document_type_info (document); default_filter = filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, info->desc); file_filter_add_mime_types (info, filter); g_free (info); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter); } else { GList *l; for (l = all_types; l; l = g_list_next (l)){ EvTypeInfo *info; info = (EvTypeInfo *)l->data; default_filter = filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, info->desc); file_filter_add_mime_types (info, filter); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter); } } g_list_foreach (all_types, (GFunc)g_free, NULL); g_list_free (all_types); 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); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (chooser), document == NULL ? document_filter : default_filter); }
void GtkFileChooserDialog_::set_filter(Php::Parameters ¶meters) { GtkFileFilter *filter; if(parameters.size() > 0) { Php::Value object_filter = parameters[0]; GtkFileFilter_ *phpgtk_filter = (GtkFileFilter_ *)object_filter.implementation(); filter = GTK_FILE_FILTER(phpgtk_filter->get_instance()); } gtk_file_chooser_set_filter (GTK_FILE_CHOOSER(instance), filter); }
//static void on_browse(GtkWidget * widget, gpointer data) void ladish_run_load_project_dialog(ladish_room_proxy_handle room) { GtkFileFilter * filter; GtkWidget * dialog; char * filename; dialog = gtk_file_chooser_dialog_new( _("Load project"), NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_create_folders(GTK_FILE_CHOOSER(dialog), FALSE); filter = gtk_file_filter_new(); gtk_file_filter_add_custom(filter, GTK_FILE_FILTER_FILENAME, reject_filter, dialog, NULL); /* reject all files */ gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter); //g_signal_connect(G_OBJECT(dialog), "selection-changed", G_CALLBACK(on_dir_select), dialog); g_signal_connect(G_OBJECT(dialog), "current-folder-changed", G_CALLBACK(dir_changed), dialog); loop: if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); if (!is_project_dir(filename)) { GtkWidget * dialog; dialog = get_gtk_builder_widget("error_dialog"); gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), _("<b><big>Not a project dir</big></b>")); gtk_message_dialog_format_secondary_markup(GTK_MESSAGE_DIALOG(dialog), "%s", filename); gtk_widget_show(dialog); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_hide(dialog); goto loop; } //gtk_entry_set_text(GTK_ENTRY(get_gtk_builder_widget("load_project_path_entry")), filename); log_info("Loading project from '%s'", filename); if (!ladish_room_proxy_load_project(room, filename)) { log_error("ladish_room_proxy_load_project() failed."); } g_free(filename); //gtk_widget_activate(gtk_dialog_get_widget_for_response(GTK_DIALOG(data), GTK_RESPONSE_OK)); } gtk_widget_destroy(dialog); return; }
static void brasero_file_chooser_set_context (BraseroLayoutObject *object, BraseroLayoutType type) { BraseroFileChooser *self; self = BRASERO_FILE_CHOOSER (object); if (type == self->priv->type) return; if (type == BRASERO_LAYOUT_AUDIO) gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (self->priv->chooser), self->priv->filter_audio); else if (type == BRASERO_LAYOUT_VIDEO) gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (self->priv->chooser), self->priv->filter_video); else gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (self->priv->chooser), self->priv->filter_any); self->priv->type = type; }
static void add_common_filters_to_gtkchooser(GtkFileFilter *gfilter, GtkWindow *picker, std::string filtername) { gtk_file_filter_set_name(gfilter, filtername.c_str()); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(picker), gfilter); GtkFileFilter *allfilter = gtk_file_filter_new(); gtk_file_filter_add_pattern(allfilter, "*"); gtk_file_filter_set_name(allfilter, "All Files"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(picker), allfilter); gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(picker), gfilter); }
static void rejilla_file_chooser_set_context (RejillaLayoutObject *object, RejillaLayoutType type) { RejillaFileChooser *self; self = REJILLA_FILE_CHOOSER (object); if (type == self->priv->type) return; if (type == REJILLA_LAYOUT_AUDIO) gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (self->priv->chooser), self->priv->filter_audio); else if (type == REJILLA_LAYOUT_VIDEO) gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (self->priv->chooser), self->priv->filter_video); else gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (self->priv->chooser), self->priv->filter_any); self->priv->type = type; }
void SludgeProjectManager::postNew() { GtkWidget *dialog; GtkFileFilter *filter; gboolean success = FALSE; dialog = gtk_file_chooser_dialog_new("New SLUDGE Project", NULL, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER (dialog), TRUE); filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, getFilterName()); gtk_file_filter_add_pattern(filter, getFilterPattern()); gtk_file_chooser_set_filter(GTK_FILE_CHOOSER (dialog), filter); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), getUntitledFilename()); if (currentFolder[0] != 0) { gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), currentFolder); } if (gtk_dialog_run(GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { char *filename; filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (dialog)); flipBackslashes(&filename); doNewProject(filename, fileList, &fileListNum); listChanged(FILE_TREEVIEW); listChanged(RESOURCE_TREEVIEW); gtk_list_store_clear(errorsListStore); gtk_widget_set_sensitive(projectRunGameItem, FALSE); setFilename(filename); setFolderFromFilename(filename); g_free(filename); success = TRUE; } gtk_widget_destroy(dialog); if (success) on_project_settings(); setupButtons(); }
static void gtk_openavatarthread(void *UNUSED(args)) { void *dialog = gtk_file_chooser_dialog_new((const char *)S(SELECT_AVATAR_TITLE), NULL, GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, "_Open", GTK_RESPONSE_ACCEPT, NULL); void *filter = gtk_file_filter_new(); gtk_file_filter_add_mime_type(filter, "image/jpeg"); gtk_file_filter_add_mime_type(filter, "image/png"); gtk_file_filter_add_mime_type(filter, "image/bmp"); gtk_file_filter_add_mime_type(filter, "image/gif"); gtk_file_chooser_set_filter(dialog, filter); void *preview = gtk_image_new(); gtk_file_chooser_set_preview_widget(dialog, preview); g_signal_connect_data(dialog, "update-preview", update_image_preview, preview, NULL, 0); while (gtk_dialog_run(dialog) == GTK_RESPONSE_ACCEPT) { char *filename = gtk_file_chooser_get_filename(dialog); int size; int width, height, bpp; uint8_t *img = stbi_load(filename, &width, &height, &bpp, 0); uint8_t *file_data = stbi_write_png_to_mem(img, 0, width, height, bpp, &size); free(img); g_free_utox(filename); if (!file_data) { void *message_dialog = gtk_message_dialog_new(dialog, 0, 1, 2, (const char *)S(CANT_FIND_FILE_OR_EMPTY)); gtk_dialog_run(message_dialog); gtk_widget_destroy(message_dialog); } else if (size > UTOX_AVATAR_MAX_DATA_LENGTH) { free(file_data); char_t size_str[16]; int len = sprint_humanread_bytes(size_str, sizeof(size_str), UTOX_AVATAR_MAX_DATA_LENGTH); void *message_dialog = gtk_message_dialog_new(dialog, 0, 1, 2, "%s%.*s.", S(AVATAR_TOO_LARGE_MAX_SIZE_IS), len, size_str); gtk_dialog_run(message_dialog); gtk_widget_destroy(message_dialog); } else { postmessage(SELF_AVATAR_SET, size, 0, file_data); break; } } gtk_widget_destroy(dialog); while(gtk_events_pending()) { gtk_main_iteration(); } gtk_open = false; }
static GObject * gimp_profile_chooser_dialog_constructor (GType type, guint n_params, GObjectConstructParam *params) { GObject *object; GimpProfileChooserDialog *dialog; GtkFileFilter *filter; object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params); dialog = GIMP_PROFILE_CHOOSER_DIALOG (object); gtk_window_set_role (GTK_WINDOW (dialog), "gimp-profile-chooser-dialog"); gtk_dialog_add_buttons (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT); gimp_profile_chooser_dialog_add_shortcut (dialog); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("All files (*.*)")); gtk_file_filter_add_pattern (filter, "*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("ICC color profile (*.icc, *.icm)")); gtk_file_filter_add_pattern (filter, "*.[Ii][Cc][Cc]"); gtk_file_filter_add_pattern (filter, "*.[Ii][Cc][Mm]"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter); gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (dialog), gimp_profile_view_new (dialog->buffer)); g_signal_connect (dialog, "update-preview", G_CALLBACK (gimp_profile_chooser_dialog_update_preview), NULL); return object; }
static void exporter_display_chooser (GcrCertificateExporter *self) { GtkFileFilter* filter; GtkWidget *dialog; gchar *filename; g_assert (!self->pv->chooser_dialog); dialog = gtk_file_chooser_dialog_new (_("Export certificate"), NULL, GTK_FILE_CHOOSER_ACTION_SAVE, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_Save"), GTK_RESPONSE_ACCEPT, NULL); self->pv->chooser_dialog = g_object_ref_sink(dialog); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT); gtk_file_chooser_set_local_only (self->pv->chooser_dialog, FALSE); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Certificate files")); gtk_file_filter_add_mime_type (filter, "application/x-x509-ca-cert"); gtk_file_filter_add_mime_type (filter, "application/x-x509-user-cert"); gtk_file_filter_add_mime_type (filter, "application/pkix-cert"); gtk_file_filter_add_pattern (filter, "*.cer"); gtk_file_filter_add_pattern (filter, "*.crt"); g_object_set_data (G_OBJECT (filter), "prepare-data-func", prepare_data_for_der); gtk_file_chooser_add_filter (self->pv->chooser_dialog, filter); gtk_file_chooser_set_filter (self->pv->chooser_dialog, filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("PEM files")); gtk_file_filter_add_mime_type (filter, "text/plain"); gtk_file_filter_add_pattern (filter, "*.pem"); g_object_set_data (G_OBJECT (filter), "prepare-data-func", prepare_data_for_pem); gtk_file_chooser_add_filter (self->pv->chooser_dialog, filter); filename = g_strconcat (self->pv->label, ".crt", NULL); g_strdelimit (filename, BAD_FILENAME_CHARS, '_'); gtk_file_chooser_set_current_name (self->pv->chooser_dialog, filename); g_free (filename); g_signal_connect (self->pv->chooser_dialog, "response", G_CALLBACK (on_chooser_dialog_response), self); if (self->pv->cancellable) g_cancellable_connect (self->pv->cancellable, G_CALLBACK (on_cancel_chooser_dialog), self, NULL); gtk_widget_show (GTK_WIDGET (self->pv->chooser_dialog)); }
void on_style_add_clicked(GtkButton *button, I7App *app) { /* From gedit/dialogs/gedit-preferences-dialog.c */ GtkWidget *chooser = gtk_file_chooser_dialog_new(_("Add Color Scheme"), GTK_WINDOW(app->prefs->window), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_ADD, GTK_RESPONSE_ACCEPT, NULL); gtk_window_set_destroy_with_parent(GTK_WINDOW(chooser), TRUE); /* Filters */ GtkFileFilter *filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, _("Color Scheme Files")); gtk_file_filter_add_pattern(filter, "*.xml"); 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, _("All Files")); gtk_file_filter_add_pattern(filter, "*"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(chooser), filter); gtk_dialog_set_default_response(GTK_DIALOG(chooser), GTK_RESPONSE_ACCEPT); if(gtk_dialog_run(GTK_DIALOG(chooser)) != GTK_RESPONSE_ACCEPT) { gtk_widget_destroy(chooser); return; } GFile *file = gtk_file_chooser_get_file(GTK_FILE_CHOOSER(chooser)); if(!file) return; gtk_widget_destroy(chooser); const char *scheme_id = i7_app_install_color_scheme(app, file); g_object_unref(file); if(!scheme_id) { error_dialog(GTK_WINDOW(app->prefs->window), NULL, _("The selected color scheme cannot be installed.")); return; } populate_schemes_list(app->prefs->schemes_list); I7App *theapp = i7_app_get(); GSettings *prefs = i7_app_get_prefs(theapp); g_settings_set_string(prefs, PREFS_STYLE_SCHEME, scheme_id); }
static void setup_background_filechooser (GtkWidget *filechooser, TerminalProfile *profile) { GtkFileFilter *filter; const char *home_dir; filter = gtk_file_filter_new (); gtk_file_filter_add_pixbuf_formats (filter); gtk_file_filter_set_name (filter, _("Images")); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (filechooser), filter); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filechooser), TRUE); /* Start filechooser in $HOME instead of the current dir of the factory which is "/" */ home_dir = g_get_home_dir (); if (home_dir) gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filechooser), home_dir); #if 0 GtkWidget *image_preview; GdkPixbuf *pixbuf = NULL; image_preview = gtk_image_new (); /* FIXMchpe this is bogus */ pixbuf = create_preview_pixbuf (terminal_profile_get_property_string (profile, TERMINAL_PROFILE_BACKGROUND_IMAGE_FILE)); if (pixbuf != NULL) { gtk_image_set_from_pixbuf (GTK_IMAGE (image_preview), pixbuf); g_object_unref (pixbuf); } else { gtk_image_set_from_stock (GTK_IMAGE (image_preview), "gtk-dialog-question", GTK_ICON_SIZE_DIALOG); } gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (filechooser), image_preview); gtk_file_chooser_set_use_preview_label (GTK_FILE_CHOOSER (filechooser), FALSE); gtk_widget_set_size_request (image_preview, 128, -1); gtk_widget_show (image_preview); g_signal_connect (filechooser, "update-preview", G_CALLBACK (update_image_preview), NULL); #endif }
static void open_cb (GSimpleAction *action, GVariant *parameter, gpointer app) { GtkWidget *dialog; GtkWindow *win; const char *home_path; GFile *home; GtkFileFilter *filter_audio; GtkFileFilter *filter_all; gchar *uri = NULL; win = gtk_application_get_active_window (app); dialog = gtk_file_chooser_dialog_new ( _("Open Audio File"), win, GTK_FILE_CHOOSER_ACTION_OPEN, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_Open"), GTK_RESPONSE_ACCEPT, NULL); /* Set current folder to user's home directory */ home_path = g_get_home_dir (); home = g_file_new_for_path (home_path); gtk_file_chooser_set_current_folder_file (GTK_FILE_CHOOSER (dialog), home, NULL); filter_audio = gtk_file_filter_new (); filter_all = gtk_file_filter_new (); gtk_file_filter_set_name (filter_audio, _("Audio files")); gtk_file_filter_set_name (filter_all, _("All files")); gtk_file_filter_add_mime_type (filter_audio, "audio/*"); gtk_file_filter_add_pattern (filter_all, "*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_audio); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_all); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter_audio); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dialog)); } g_object_unref (home); gtk_widget_destroy (dialog); if (uri) { pt_window_open_file (PT_WINDOW (win), uri); g_free (uri); } }
static void gwy_app_file_chooser_filter_toggled(GwyAppFileChooser *chooser, GtkToggleButton *check) { gboolean active; gchar *key; active = gtk_toggle_button_get_active(check); gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(chooser), active ? chooser->filter : chooser->no_filter); key = g_strconcat(chooser->prefix, "/filter", NULL); gwy_container_set_boolean_by_name(gwy_app_settings_get(), key, active); g_free(key); gwy_app_file_chooser_update_expander(chooser); }
static void set_file_filter_loadplaylist(GtkFileChooser *dlg) { GtkFileFilter* flt; flt = gtk_file_filter_new (); gtk_file_filter_set_name (flt, _("Supported playlist formats")); gtk_file_filter_add_custom (flt, GTK_FILE_FILTER_FILENAME, playlist_filter_func, NULL, NULL); gtk_file_filter_add_pattern (flt, "*.dbpl"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dlg), flt); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dlg), flt); flt = gtk_file_filter_new (); gtk_file_filter_set_name (flt, _("Other files (*)")); gtk_file_filter_add_pattern (flt, "*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dlg), flt); }
int clip_GTK_FILECHOOSERSETFILTER(ClipMachine * ClipMachineMemory) { C_object *cchooser = _fetch_co_arg(ClipMachineMemory); C_object *cfilter = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2)); CHECKCOBJ(cchooser, GTK_IS_FILE_CHOOSER(cchooser->object)); CHECKCOBJ(cfilter, GTK_IS_FILE_FILTER(cfilter->object)); gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(cchooser->object), GTK_FILE_FILTER(cfilter->object)); return 0; err: return 1; }
ZLGtkOpenFileDialog::ZLGtkOpenFileDialog(const std::string &title, const std::string &directoryPath, const std::string &filePath, const Filter &filter) { myDialog = GTK_DIALOG(gtk_file_chooser_dialog_new( title.c_str(), 0, GTK_FILE_CHOOSER_ACTION_OPEN, gtkString(ZLDialogManager::buttonName(ZLDialogManager::CANCEL_BUTTON)).c_str(), GTK_RESPONSE_CANCEL, gtkString(ZLDialogManager::buttonName(ZLDialogManager::OK_BUTTON)).c_str(), GTK_RESPONSE_ACCEPT, 0 )); GtkFileChooser *chooser = GTK_FILE_CHOOSER(myDialog); gtk_file_chooser_set_current_folder(chooser, directoryPath.c_str()); gtk_file_chooser_set_filename(chooser, filePath.c_str()); GtkFileFilter *gtkFilter = gtk_file_filter_new(); gtk_file_filter_add_custom(gtkFilter, (GtkFileFilterFlags)(GTK_FILE_FILTER_FILENAME | GTK_FILE_FILTER_MIME_TYPE), filterHandler, (void*)&filter, 0); gtk_file_chooser_set_filter(chooser, gtkFilter); }
void gdb_on_printer_add (GtkButton *button, gpointer user_data) { PreferenceDialog *dlg = (PreferenceDialog *)user_data; GtkWidget *chooser; GtkFileFilter *filter; chooser = gtk_file_chooser_dialog_new (_("Select a pretty printer file"), GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (button))), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); filter = gtk_file_filter_new (); gtk_file_filter_add_mime_type (filter, "text/x-python"); gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (chooser), TRUE); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (chooser),filter); if (gtk_dialog_run (GTK_DIALOG (chooser)) == GTK_RESPONSE_ACCEPT) { GSList *filenames; GSList *item; filenames = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (chooser)); for (item = filenames; item != NULL; item = g_slist_next (item)) { GtkTreeIter iter; gchar *path = (gchar *)item->data; gchar *function; function = gdb_find_register_function (path); gtk_list_store_append (dlg->model, &iter); gtk_list_store_set (dlg->model, &iter, GDB_PP_ACTIVE_COLUMN, TRUE, GDB_PP_FILENAME_COLUMN, path, GDB_PP_REGISTER_COLUMN, function, -1); g_free (path); g_free (function); gdb_check_register_function (dlg, &iter); } g_slist_free (filenames); } gtk_widget_destroy (chooser); }
static GtkWidget * cdisplay_proof_file_chooser_dialog_new (void) { GtkWidget *dialog; GtkFileFilter *filter; dialog = gtk_file_chooser_dialog_new (_("Choose an ICC Color Profile"), NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT); #ifndef G_OS_WIN32 { const gchar folder[] = "/usr/share/color/icc"; if (g_file_test (folder, G_FILE_TEST_IS_DIR)) gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog), folder, NULL); } #endif filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("All files (*.*)")); gtk_file_filter_add_pattern (filter, "*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("ICC color profile (*.icc, *.icm)")); gtk_file_filter_add_pattern (filter, "*.[Ii][Cc][Cc]"); gtk_file_filter_add_pattern (filter, "*.[Ii][Cc][Mm]"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter); return dialog; }
void SludgeApplication::saveToFile() { GtkWidget *dialog; GtkFileFilter *filter; dialog = gtk_file_chooser_dialog_new ("Save File", NULL, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, getFilterName()); gtk_file_filter_add_pattern(filter, getFilterPattern()); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter); if (currentShortname[0] != 0) { gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), currentShortname); } if (currentFolder[0] != 0) { gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), currentFolder); } if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { char *filename; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); flipBackslashes(&filename); if (!saveFile (filename)) { errorBox ("Error", "Saving file failed."); } else { setFilename(filename); setFolderFromFilename(filename); } g_free (filename); } gtk_widget_destroy (dialog); }