void SludgeProjectManager::on_add_file_clicked() { GtkWidget *dialog; GtkFileFilter *filter, *slufilter, *sldfilter, *trafilter; dialog = gtk_file_chooser_dialog_new("Add file to SLUDGE project", NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, "SLU/SLD/TRA files"); gtk_file_filter_add_pattern(filter, "*.[sS][lL][uU]"); gtk_file_filter_add_pattern(filter, "*.[sS][lL][dD]"); gtk_file_filter_add_pattern(filter, "*.[tT][rR][aA]"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filter); slufilter = gtk_file_filter_new(); gtk_file_filter_set_name(slufilter, "SLUDGE scripts (*.slu)"); gtk_file_filter_add_pattern(slufilter, "*.[sS][lL][uU]"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), slufilter); sldfilter = gtk_file_filter_new(); gtk_file_filter_set_name(sldfilter, "SLUDGE constant definition files (*.sld)"); gtk_file_filter_add_pattern(sldfilter, "*.[sS][lL][dD]"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), sldfilter); trafilter = gtk_file_filter_new(); gtk_file_filter_set_name(trafilter, "SLUDGE translation files (*.tra)"); gtk_file_filter_add_pattern(trafilter, "*.[tT][rR][aA]"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), trafilter); gtk_file_chooser_set_filter(GTK_FILE_CHOOSER (dialog), filter); gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER (dialog), TRUE); 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) { GSList *filenames; char *filename; filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER (dialog)); for (int j = 0; j < g_slist_length(filenames); j++) { filename = (char *) g_slist_nth(filenames, j)->data; flipBackslashes(&filename); getSourceDirFromName(currentFilename); addFileToProject(filename, sourceDirectory, fileList, &fileListNum); setFileChanged(); g_free(filename); } g_slist_free(filenames); } gtk_widget_destroy(dialog); listChanged(FILE_TREEVIEW); }
/** * e_shell_run_save_dialog: * @shell: an #EShell * @title: file chooser dialog title * @suggestion: file name suggestion, or %NULL * @filters: Possible filters for dialog, or %NULL * @customize_func: optional dialog customization function * @customize_data: optional data to pass to @customize_func * * Runs a #GtkFileChooserDialog in save mode with the given title and * returns the selected #GFile. If @customize_func is provided, the * function is called just prior to running the dialog (the file chooser * is the first argument, @customize_data is the second). If the user * cancels the dialog the function will return %NULL. * * With non-%NULL @filters will be added also file filters to the dialog. * The string format is "pat1:mt1;pat2:mt2:...", where 'pat' is a pattern * and 'mt' is a MIME type for the pattern to be used. There can be more * than one MIME type, those are separated by comma. * * Returns: the #GFile to save to, or %NULL **/ GFile * e_shell_run_save_dialog (EShell *shell, const gchar *title, const gchar *suggestion, const gchar *filters, GtkCallback customize_func, gpointer customize_data) { GtkFileChooser *file_chooser; GFile *chosen_file = NULL; GtkWidget *dialog; GtkWindow *parent; g_return_val_if_fail (E_IS_SHELL (shell), NULL); parent = e_shell_get_active_window (shell); dialog = gtk_file_chooser_dialog_new ( title, parent, GTK_FILE_CHOOSER_ACTION_SAVE, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_Save"), GTK_RESPONSE_ACCEPT, NULL); file_chooser = GTK_FILE_CHOOSER (dialog); gtk_dialog_set_default_response ( GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT); gtk_file_chooser_set_local_only (file_chooser, FALSE); gtk_file_chooser_set_do_overwrite_confirmation (file_chooser, TRUE); if (suggestion != NULL) { gchar *current_name; current_name = g_strdup (suggestion); e_filename_make_safe (current_name); gtk_file_chooser_set_current_name (file_chooser, current_name); g_free (current_name); } if (filters != NULL) { gchar **flts = g_strsplit (filters, ";", -1); gint i; for (i = 0; flts && flts[i]; i++) { GtkFileFilter *filter = gtk_file_filter_new (); gchar *flt = flts[i]; gchar *delim = strchr (flt, ':'), *next = NULL; if (delim) { *delim = 0; next = strchr (delim + 1, ','); } gtk_file_filter_add_pattern (filter, flt); if (g_ascii_strcasecmp (flt, "*.mbox") == 0) gtk_file_filter_set_name ( filter, _("Berkeley Mailbox (mbox)")); else if (g_ascii_strcasecmp (flt, "*.vcf") == 0) gtk_file_filter_set_name ( filter, _("vCard (.vcf)")); else if (g_ascii_strcasecmp (flt, "*.ics") == 0) gtk_file_filter_set_name ( filter, _("iCalendar (.ics)")); else gtk_file_filter_set_name (filter, flt); while (delim) { delim++; if (next) *next = 0; gtk_file_filter_add_mime_type (filter, delim); delim = next; if (next) next = strchr (next + 1, ','); } gtk_file_chooser_add_filter (file_chooser, filter); } if (flts && flts[0]) { GtkFileFilter *filter = gtk_file_filter_new (); gtk_file_filter_add_pattern (filter, "*"); gtk_file_filter_set_name (filter, _("All Files (*)")); gtk_file_chooser_add_filter (file_chooser, filter); } g_strfreev (flts); } /* Allow further customizations before running the dialog. */ if (customize_func != NULL) customize_func (dialog, customize_data); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) chosen_file = gtk_file_chooser_get_file (file_chooser); gtk_widget_destroy (dialog); return chosen_file; }
static void xfburn_burn_image_dialog_init (XfburnBurnImageDialog * obj) { GtkBox *box = GTK_BOX (GTK_DIALOG (obj)->vbox); XfburnBurnImageDialogPrivate *priv = XFBURN_BURN_IMAGE_DIALOG_GET_PRIVATE (obj); GdkPixbuf *icon = NULL; GtkFileFilter *filter; GtkWidget *frame; GtkWidget *vbox; GtkWidget *button; XfburnDevice *device; gtk_window_set_title (GTK_WINDOW (obj), _("Burn image")); gtk_window_set_destroy_with_parent (GTK_WINDOW (obj), TRUE); icon = gtk_widget_render_icon (GTK_WIDGET (obj), XFBURN_STOCK_BURN_CD, GTK_ICON_SIZE_DIALOG, NULL); gtk_window_set_icon (GTK_WINDOW (obj), icon); g_object_unref (icon); /* file */ priv->chooser_image = gtk_file_chooser_button_new (_("Image to burn"), GTK_FILE_CHOOSER_ACTION_OPEN); gtk_widget_show (priv->chooser_image); 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(priv->chooser_image), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("ISO images")); gtk_file_filter_add_pattern (filter, "*.[iI][sS][oO]"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (priv->chooser_image), filter); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (priv->chooser_image), filter); if(xfburn_main_has_initial_dir ()) { gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (priv->chooser_image), xfburn_main_get_initial_dir ()); } if (last_file) { gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (priv->chooser_image), last_file); } frame = xfce_gtk_frame_box_new_with_content (_("Image to burn"), priv->chooser_image); gtk_widget_show (frame); gtk_box_pack_start (box, frame, FALSE, FALSE, BORDER); /* red label for image */ priv->image_label = gtk_label_new (""); gtk_widget_show (priv->image_label); gtk_box_pack_start (GTK_BOX (box), priv->image_label, FALSE, FALSE, 0); update_image_label (GTK_FILE_CHOOSER (priv->chooser_image), obj); g_signal_connect (G_OBJECT (priv->chooser_image), "selection-changed", G_CALLBACK (update_image_label), obj); /* devices list */ priv->device_box = xfburn_device_box_new (SHOW_CD_WRITERS | SHOW_CDRW_WRITERS | SHOW_DVD_WRITERS | SHOW_MODE_SELECTION | SHOW_SPEED_SELECTION); gtk_widget_show (priv->device_box); frame = xfce_gtk_frame_box_new_with_content (_("Burning device"), priv->device_box); gtk_widget_show (frame); gtk_box_pack_start (box, frame, FALSE, FALSE, BORDER); /* options */ vbox = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox); frame = xfce_gtk_frame_box_new_with_content (_("Options"), vbox); gtk_widget_show (frame); gtk_box_pack_start (box, frame, FALSE, FALSE, BORDER); priv->check_eject = gtk_check_button_new_with_mnemonic (_("E_ject disk")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->check_eject), TRUE); gtk_widget_show (priv->check_eject); gtk_box_pack_start (GTK_BOX (vbox), priv->check_eject, FALSE, FALSE, BORDER); priv->check_dummy = gtk_check_button_new_with_mnemonic (_("_Dummy write")); gtk_widget_show (priv->check_dummy); gtk_box_pack_start (GTK_BOX (vbox), priv->check_dummy, FALSE, FALSE, BORDER); priv->check_burnfree = gtk_check_button_new_with_mnemonic (_("Burn_Free")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->check_burnfree), TRUE); gtk_widget_show (priv->check_burnfree); gtk_box_pack_start (GTK_BOX (vbox), priv->check_burnfree, FALSE, FALSE, BORDER); priv->check_stream_recording = gtk_check_button_new_with_mnemonic (_("Stream _Recording")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->check_stream_recording), TRUE); gtk_widget_show (priv->check_stream_recording); gtk_box_pack_start (GTK_BOX (vbox), priv->check_stream_recording, FALSE, FALSE, BORDER); priv->check_quit = gtk_check_button_new_with_mnemonic (_("_Quit after success")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->check_quit), xfburn_settings_get_boolean("quit_after_success", FALSE)); gtk_widget_show (priv->check_quit); gtk_box_pack_start (GTK_BOX (vbox), priv->check_quit, FALSE, FALSE, BORDER); /* action buttons */ button = gtk_button_new_from_stock (GTK_STOCK_CANCEL); gtk_widget_show (button); gtk_dialog_add_action_widget (GTK_DIALOG (obj), button, GTK_RESPONSE_CANCEL); priv->burn_button = xfburn_gtk_button_new_mixed (XFBURN_STOCK_BURN_CD, _("_Burn image")); gtk_widget_show (priv->burn_button); g_signal_connect (G_OBJECT (priv->burn_button), "clicked", G_CALLBACK (cb_clicked_ok), obj); gtk_container_add (GTK_CONTAINER( GTK_DIALOG(obj)->action_area), priv->burn_button); //gtk_dialog_add_action_widget (GTK_DIALOG (obj), button, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (priv->burn_button, GTK_CAN_DEFAULT); gtk_widget_grab_focus (priv->burn_button); gtk_widget_grab_default (priv->burn_button); priv->devlist = xfburn_device_list_new (); priv->handler_volchange = g_signal_connect (G_OBJECT (priv->devlist), "volume-change-end", G_CALLBACK (cb_volume_change_end), obj); g_signal_connect (G_OBJECT (obj), "response", G_CALLBACK (cb_dialog_response), obj); device = xfburn_device_list_get_current_device (priv->devlist); if (device) cb_volume_change_end (priv->devlist, TRUE, device, obj); }
int main(int argc, char* argv[]) { regex_t fregex[2]; gtk_init(&argc,&argv); // check the correct BASS was loaded if (HIWORD(BASS_GetVersion())!=BASSVERSION) { Error("An incorrect version of BASS was loaded"); return 0; } // Initialize the output device with 3D support if (!BASS_Init(-1,44100,BASS_DEVICE_3D,NULL,NULL)) { Error("Can't initialize device"); return 0; } { BASS_INFO i; BASS_GetInfo(&i); if (i.speakers>2) { GtkWidget *dialog=gtk_message_dialog_new(NULL,0, GTK_MESSAGE_QUESTION,GTK_BUTTONS_YES_NO,"Multiple speakers were detected. Would you like to use them?"); if (gtk_dialog_run(GTK_DIALOG(dialog))==GTK_RESPONSE_NO) BASS_SetConfig(BASS_CONFIG_3DALGORITHM,BASS_3DALG_OFF); gtk_widget_destroy(dialog); } } // Use meters as distance unit, real world rolloff, real doppler effect BASS_Set3DFactors(1,1,1); // initialize GUI glade=glade_xml_new(GLADE_PATH"3dtest.glade",NULL,NULL); if (!glade) return 0; win=GetWidget("window1"); if (!win) return 0; glade_xml_signal_autoconnect(glade); g_signal_connect(gtk_tree_view_get_selection(GTK_TREE_VIEW(GetWidget("channels"))),"changed",G_CALLBACK(ListSelectionChange),NULL); { // setup list GtkTreeView *list=GTK_TREE_VIEW(GetWidget("channels")); GtkTreeViewColumn *col=gtk_tree_view_column_new(); gtk_tree_view_append_column(list,col); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col,renderer,TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", 0); GtkListStore *liststore=gtk_list_store_new(1,G_TYPE_STRING); gtk_tree_view_set_model(list,GTK_TREE_MODEL(liststore)); g_object_unref(liststore); } { // initialize file selector GtkFileFilter *filter; filesel=gtk_file_chooser_dialog_new("Open File",GTK_WINDOW(win),GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL,GTK_RESPONSE_CANCEL,GTK_STOCK_OPEN,GTK_RESPONSE_ACCEPT,NULL); filter=gtk_file_filter_new(); gtk_file_filter_set_name(filter,"Streamable files (wav/aif/mp3/mp2/mp1/ogg)"); regcomp(&fregex[0],"\\.(mp[1-3]|ogg|wav|aif)$",REG_ICASE|REG_NOSUB|REG_EXTENDED); gtk_file_filter_add_custom(filter,GTK_FILE_FILTER_FILENAME,FileExtensionFilter,&fregex[0],NULL); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filesel),filter); filter=gtk_file_filter_new(); gtk_file_filter_set_name(filter,"MOD music files (mo3/xm/mod/s3m/it/mtm/umx)"); regcomp(&fregex[1],"\\.(mo3|xm|mod|s3m|it|umx)$",REG_ICASE|REG_NOSUB|REG_EXTENDED); gtk_file_filter_add_custom(filter,GTK_FILE_FILTER_FILENAME,FileExtensionFilter,&fregex[1],NULL); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filesel),filter); filter=gtk_file_filter_new(); gtk_file_filter_set_name(filter,"All files"); gtk_file_filter_add_pattern(filter,"*"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filesel),filter); } g_timeout_add(TIMERPERIOD,Update,NULL); UpdateButtons(); gtk_main(); gtk_widget_destroy(filesel); regfree(&fregex[0]); regfree(&fregex[1]); BASS_Free(); // close output return 0; }
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 Picture_Save_Button_Clicked (GObject *object) { GtkWidget *FileSelectionWindow; GtkFileFilter *filter; GtkWindow *parent_window = NULL; static gchar *init_dir = NULL; GtkTreeSelection *selection; GList *selection_list = NULL; GList *l; GtkTreeModel *model; gint selection_nbr, selection_i = 1; g_return_if_fail (PictureEntryView != NULL); parent_window = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(object))); if (!gtk_widget_is_toplevel(GTK_WIDGET(parent_window))) { g_warning("Could not get parent window\n"); return; } model = gtk_tree_view_get_model(GTK_TREE_VIEW(PictureEntryView)); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView)); selection_list = gtk_tree_selection_get_selected_rows(selection, NULL); selection_nbr = gtk_tree_selection_count_selected_rows(GTK_TREE_SELECTION(selection)); for (l = selection_list; l != NULL; l = g_list_next (l)) { GtkTreePath *path = l->data; GtkTreeIter iter; Picture *pic; gchar *title; gboolean valid; gint response; // Get corresponding picture valid = gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, path); if (valid) gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, PICTURE_COLUMN_DATA, &pic, -1); title = g_strdup_printf (_("Save Image %d/%d"), selection_i++, selection_nbr); FileSelectionWindow = gtk_file_chooser_dialog_new(title, parent_window, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL); g_free(title); // Add files filters // "All files" filter filter = gtk_file_filter_new (); gtk_file_filter_set_name(GTK_FILE_FILTER(filter), _("All Files")); gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter), "*"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(FileSelectionWindow), GTK_FILE_FILTER(filter)); // "PNG and JPEG" filter filter = gtk_file_filter_new (); gtk_file_filter_set_name(GTK_FILE_FILTER(filter), _("PNG and JPEG")); gtk_file_filter_add_mime_type(GTK_FILE_FILTER(filter), "image/jpeg"); gtk_file_filter_add_mime_type(GTK_FILE_FILTER(filter), "image/png"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (FileSelectionWindow), GTK_FILE_FILTER(filter)); // Make this filter the default gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(FileSelectionWindow), GTK_FILE_FILTER(filter)); // Set the default folder if defined if (init_dir) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(FileSelectionWindow),init_dir); // Suggest a filename to the user if ( pic->description && strlen(pic->description) ) { gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(FileSelectionWindow), pic->description); //filename in UTF8 }else { gchar *image_name = NULL; switch (Picture_Format_From_Data(pic)) { case PICTURE_FORMAT_JPEG : image_name = g_strdup("image_name.jpg"); break; case PICTURE_FORMAT_PNG : image_name = g_strdup("image_name.png"); break; case PICTURE_FORMAT_UNKNOWN : image_name = g_strdup("image_name.ext"); break; } gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(FileSelectionWindow), image_name); //filename in UTF8 g_free(image_name); } gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (FileSelectionWindow), TRUE); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (FileSelectionWindow), FALSE); response = gtk_dialog_run(GTK_DIALOG(FileSelectionWindow)); if (response == GTK_RESPONSE_OK) { GFile *file; GError *error = NULL; // Save the directory selected for initialize next time g_free(init_dir); init_dir = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(FileSelectionWindow)); file = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (FileSelectionWindow)); if (!et_picture_save_file_data (pic, file, &error)) { Log_Print (LOG_ERROR, _("Image file not saved: %s"), error->message); g_error_free (error); } g_object_unref (file); } gtk_widget_destroy(FileSelectionWindow); } g_list_free_full (selection_list, (GDestroyNotify)gtk_tree_path_free); }
void gnc_file_log_replay (void) { char *selected_filename; char *default_dir; char read_buf[256]; char *read_retval; GtkFileFilter *filter; FILE *log_file; char * record_start_str = "===== START"; /* NOTE: This string must match src/engine/TransLog.cpp (sans newline) */ char * expected_header_orig = "mod\ttrans_guid\tsplit_guid\ttime_now\t" "date_entered\tdate_posted\tacc_guid\tacc_name\tnum\tdescription\t" "notes\tmemo\taction\treconciled\tamount\tvalue\tdate_reconciled"; static char *expected_header = NULL; /* Use g_strdup_printf so we don't get accidental tab -> space conversion */ if (!expected_header) expected_header = g_strdup(expected_header_orig); qof_log_set_level(GNC_MOD_IMPORT, QOF_LOG_DEBUG); ENTER(" "); /* Don't log the log replay. This would only result in redundant logs */ xaccLogDisable(); default_dir = gnc_get_default_directory(GCONF_SECTION); filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, "*.log"); gtk_file_filter_add_pattern(filter, "*.[Ll][Oo][Gg]"); selected_filename = gnc_file_dialog(_("Select a .log file to replay"), g_list_prepend(NULL, filter), default_dir, GNC_FILE_DIALOG_OPEN); g_free(default_dir); if (selected_filename != NULL) { /* Remember the directory as the default. */ default_dir = g_path_get_dirname(selected_filename); gnc_set_default_directory(GCONF_SECTION, default_dir); g_free(default_dir); /*strncpy(file,selected_filename, 255);*/ DEBUG("Filename found: %s", selected_filename); if (xaccFileIsCurrentLog(selected_filename)) { g_warning("Cannot open the current log file: %s", selected_filename); gnc_error_dialog(NULL, /* Translators: %s is the file name. */ _("Cannot open the current log file: %s"), selected_filename); } else { DEBUG("Opening selected file"); log_file = g_fopen(selected_filename, "r"); if (!log_file || ferror(log_file) != 0) { int err = errno; perror("File open failed"); gnc_error_dialog(NULL, /* Translation note: * First argument is the filename, * second argument is the error. */ _("Failed to open log file: %s: %s"), selected_filename, strerror(err)); } else { if ((read_retval = fgets(read_buf, sizeof(read_buf), log_file)) == NULL) { DEBUG("Read error or EOF"); gnc_info_dialog(NULL, "%s", _("The log file you selected was empty.")); } else { if (strncmp(expected_header, read_buf, strlen(expected_header)) != 0) { PERR("File header not recognised:\n%s", read_buf); PERR("Expected:\n%s", expected_header); gnc_error_dialog(NULL, "%s", _("The log file you selected cannot be read. " "The file header was not recognized.")); } else { do { read_retval = fgets(read_buf, sizeof(read_buf), log_file); /*DEBUG("Chunk read: %s",read_retval);*/ if (strncmp(record_start_str, read_buf, strlen(record_start_str)) == 0) /* If a record started */ { process_trans_record(log_file); } } while (feof(log_file) == 0); } } fclose(log_file); } } g_free(selected_filename); } /* Start logging again */ xaccLogEnable(); LEAVE(""); }
// sets up the file chooser dialog static void create_file_chooser_dialog() { GtkWidget *parent = get_widget_checked("ssv_main_window"); browse_widget = gtk_file_chooser_dialog_new( "Open Image File", GTK_WINDOW(parent), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, //Cancel button GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, //Open button NULL); // we need to extract the buttons, so we can connect them to our // button handlers, above GtkHButtonBox *box = (GtkHButtonBox*)(((GtkDialog*)browse_widget)->action_area); GList *buttons = box->button_box.box.children; GtkWidget *cancel_btn = ((GtkBoxChild*)buttons->data)->widget; GtkWidget *ok_btn = ((GtkBoxChild*)buttons->next->data)->widget; g_signal_connect((gpointer)cancel_btn, "clicked", G_CALLBACK(new_cancel_clicked), NULL); g_signal_connect((gpointer)ok_btn, "clicked", G_CALLBACK(new_ok_clicked), NULL); g_signal_connect(browse_widget, "destroy", G_CALLBACK(browse_widget_destroy), NULL); g_signal_connect(browse_widget, "destroy_event", G_CALLBACK(browse_widget_destroy), NULL); g_signal_connect(browse_widget, "delete_event", G_CALLBACK(browse_widget_destroy), NULL); // add the filters GtkFileFilter *D_filt = gtk_file_filter_new(); gtk_file_filter_set_name(D_filt, "CEOS Data Files (*.D)"); gtk_file_filter_add_pattern(D_filt, "*.D"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), D_filt); GtkFileFilter *alos2_filt = gtk_file_filter_new(); gtk_file_filter_set_name(alos2_filt, "ALOS Image Files (IMG-*)"); gtk_file_filter_add_pattern(alos2_filt, "IMG-*"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), alos2_filt); GtkFileFilter *img_filt = gtk_file_filter_new(); gtk_file_filter_set_name(img_filt, "ASF Internal Files (*.img)"); gtk_file_filter_add_pattern(img_filt, "*.img"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), img_filt); GtkFileFilter *airsar_filt = gtk_file_filter_new(); gtk_file_filter_set_name(airsar_filt, "AirSAR Files"); gtk_file_filter_add_pattern(airsar_filt, "*.vvi2"); gtk_file_filter_add_pattern(airsar_filt, "*.demi2"); gtk_file_filter_add_pattern(airsar_filt, "*.corgr"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), airsar_filt); GtkFileFilter *tiff_filt = gtk_file_filter_new(); gtk_file_filter_set_name(tiff_filt, "GeoTIFF Image Files (*.tif)"); gtk_file_filter_add_pattern(tiff_filt, "*.tif"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), tiff_filt); GtkFileFilter *tsx_filt = gtk_file_filter_new(); gtk_file_filter_set_name(tsx_filt, "TerraSAR-X Files (*.xml)"); gtk_file_filter_add_pattern(tsx_filt, "*.xml"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), tsx_filt); GtkFileFilter *jpg_filt = gtk_file_filter_new(); gtk_file_filter_set_name(jpg_filt, "JPEG Image Files (*.jpg)"); gtk_file_filter_add_pattern(jpg_filt, "*.jpg"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), jpg_filt); GtkFileFilter *png_filt = gtk_file_filter_new(); gtk_file_filter_set_name(png_filt, "PNG Image Files (*.png)"); gtk_file_filter_add_pattern(png_filt, "*.png"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), png_filt); GtkFileFilter *pgm_filt = gtk_file_filter_new(); gtk_file_filter_set_name(pgm_filt, "PGM Image Files (*.pgm)"); gtk_file_filter_add_pattern(pgm_filt, "*.pgm"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), pgm_filt); GtkFileFilter *envi_filt = gtk_file_filter_new(); gtk_file_filter_set_name(envi_filt, "ENVI Files (*.hdr)"); gtk_file_filter_add_pattern(envi_filt, "*.hdr"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), envi_filt); GtkFileFilter *roipac_filt = gtk_file_filter_new(); gtk_file_filter_set_name(roipac_filt, "ROI_PAC Files (*.rsc)"); gtk_file_filter_add_pattern(roipac_filt, "*.rsc"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), roipac_filt); //GtkFileFilter *ppm_filt = gtk_file_filter_new(); //gtk_file_filter_set_name(ppm_filt, "PPM Image Files (*.ppm)"); //gtk_file_filter_add_pattern(ppm_filt, "*.ppm"); //gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), ppm_filt); GtkFileFilter *all_filt = gtk_file_filter_new(); gtk_file_filter_set_name(all_filt, "All Files (*.*)"); gtk_file_filter_add_pattern(all_filt, "*"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(browse_widget), all_filt); // allow multi-select gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(browse_widget), TRUE); // we need to make these modal -- if the user opens multiple "open" // dialogs, we'll get confused on the callbacks gtk_window_set_modal(GTK_WINDOW(browse_widget), TRUE); gtk_window_set_destroy_with_parent(GTK_WINDOW(browse_widget), TRUE); gtk_dialog_set_default_response(GTK_DIALOG(browse_widget), GTK_RESPONSE_OK); }
/* * To add a picture in the list -> call a FileSelectionWindow */ void Picture_Add_Button_Clicked (GObject *object) { GtkWidget *FileSelectionWindow; GtkFileFilter *filter; GtkWindow *parent_window = NULL; static gchar *init_dir = NULL; gint response; g_return_if_fail (PictureEntryView != NULL); parent_window = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(object))); if (!gtk_widget_is_toplevel(GTK_WIDGET(parent_window))) { g_warning("Could not get parent window\n"); return; } FileSelectionWindow = gtk_file_chooser_dialog_new(_("Add Images"), parent_window, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL); // Add files filters // "All files" filter filter = gtk_file_filter_new (); gtk_file_filter_set_name(GTK_FILE_FILTER(filter), _("All Files")); gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter), "*"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(FileSelectionWindow), GTK_FILE_FILTER(filter)); // "PNG and JPEG" filter filter = gtk_file_filter_new (); gtk_file_filter_set_name(GTK_FILE_FILTER(filter), _("PNG and JPEG")); gtk_file_filter_add_mime_type(GTK_FILE_FILTER(filter), "image/jpeg"); // Using mime type avoid problem of case sensitive with extensions gtk_file_filter_add_mime_type(GTK_FILE_FILTER(filter), "image/png"); //gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter), "*.jpeg"); // Warning: *.JPEG or *.JpEg files will not be displayed //gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter), "*.jpg"); //gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter), "*.png"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (FileSelectionWindow), GTK_FILE_FILTER(filter)); // Make this filter the default gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(FileSelectionWindow), GTK_FILE_FILTER(filter)); // Behaviour following the tag type... switch (ETCore->ETFileDisplayed->ETFileDescription->TagType) { case MP4_TAG: { // Only one file can be selected gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(FileSelectionWindow), FALSE); break; } // Other tag types default: { gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(FileSelectionWindow), TRUE); break; } } gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (FileSelectionWindow), FALSE); // Starting directory (the same of the current file) if (ETCore->ETFileDisplayed) { gchar *cur_filename_utf8 = ((File_Name *)((GList *)ETCore->ETFileDisplayed->FileNameCur)->data)->value_utf8; init_dir = g_path_get_dirname(cur_filename_utf8); gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(FileSelectionWindow),init_dir); }else // Starting directory (the same than the previous one) if (init_dir) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(FileSelectionWindow),init_dir); response = gtk_dialog_run(GTK_DIALOG(FileSelectionWindow)); if (response == GTK_RESPONSE_OK) { GtkTreeSelection *selection; GSList *list; selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView)); gtk_tree_selection_unselect_all(selection); list = gtk_file_chooser_get_files (GTK_FILE_CHOOSER (FileSelectionWindow)); g_slist_foreach (list, (GFunc) et_picture_load_file, NULL); g_slist_free_full (list, g_object_unref); // Save the directory selected for initialize next time g_free(init_dir); init_dir = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(FileSelectionWindow)); } if (ETCore->ETFileDisplayed) { ET_Save_File_Data_From_UI (ETCore->ETFileDisplayed); ET_Display_File_Data_To_UI (ETCore->ETFileDisplayed); } gtk_widget_destroy(FileSelectionWindow); }
VectorsImportDialog * vectors_import_dialog_new (GimpImage *image, GtkWidget *parent, gboolean merge_vectors, gboolean scale_vectors) { VectorsImportDialog *dialog; GtkWidget *vbox; GtkWidget *button; GtkFileFilter *filter; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GTK_IS_WIDGET (parent), NULL); dialog = g_slice_new0 (VectorsImportDialog); dialog->image = image; dialog->merge_vectors = merge_vectors; dialog->scale_vectors = scale_vectors; dialog->dialog = gtk_file_chooser_dialog_new (_("Import Paths from SVG"), NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog->dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_window_set_screen (GTK_WINDOW (dialog->dialog), gtk_widget_get_screen (parent)); gtk_window_set_role (GTK_WINDOW (dialog->dialog), "gimp-vectors-import"); gtk_window_set_position (GTK_WINDOW (dialog->dialog), GTK_WIN_POS_MOUSE); gtk_dialog_set_default_response (GTK_DIALOG (dialog->dialog), GTK_RESPONSE_OK); g_object_weak_ref (G_OBJECT (dialog->dialog), (GWeakNotify) vectors_import_dialog_free, dialog); g_signal_connect_object (image, "disconnect", G_CALLBACK (gtk_widget_destroy), dialog->dialog, 0); g_signal_connect (dialog->dialog, "delete-event", G_CALLBACK (gtk_true), NULL); 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->dialog), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Scalable SVG image (*.svg)")); gtk_file_filter_add_pattern (filter, "*.[Ss][Vv][Gg]"); gtk_file_filter_add_mime_type (filter, "image/svg+xml"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog->dialog), filter); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog->dialog), filter); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog->dialog), vbox); gtk_widget_show (vbox); button = gtk_check_button_new_with_mnemonic (_("_Merge imported paths")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), dialog->merge_vectors); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &dialog->merge_vectors); button = gtk_check_button_new_with_mnemonic (_("_Scale imported paths " "to fit image")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), dialog->scale_vectors); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &dialog->scale_vectors); return dialog; }
static VALUE ffil_add_pattern(VALUE self, VALUE pattern) { gtk_file_filter_add_pattern(_SELF(self), RVAL2CSTR(pattern)); return self; }
static void test_folder_switch_and_filters (void) { gboolean passed; char *cwd; char *base_dir; GtkFilePath *cwd_path; GtkFilePath *base_dir_path; GtkWidget *dialog; GtkFileFilter *all_filter; GtkFileFilter *txt_filter; GtkFileChooserDefault *impl; passed = TRUE; cwd = g_get_current_dir (); base_dir = g_build_filename (cwd, "file-chooser-test-dir", NULL); dialog = gtk_file_chooser_dialog_new ("Test", NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); impl = get_impl_from_dialog (dialog); cwd_path = gtk_file_system_filename_to_path (impl->file_system, cwd); base_dir_path = gtk_file_system_filename_to_path (impl->file_system, base_dir); passed = passed && gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), base_dir); g_assert (passed); /* All files filter */ all_filter = gtk_file_filter_new (); gtk_file_filter_set_name (all_filter, "All files"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), all_filter); /* *.txt filter */ txt_filter = gtk_file_filter_new (); gtk_file_filter_set_name (all_filter, "*.txt"); gtk_file_filter_add_pattern (txt_filter, "*.txt"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), txt_filter); /* Test filter set */ gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), all_filter); passed = passed && (gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (dialog)) == all_filter); g_assert (passed); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), txt_filter); passed = passed && (gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (dialog)) == txt_filter); log_test (passed, "test_folder_switch_and_filters(): set and get filter"); g_assert (passed); gtk_widget_show (dialog); /* Test that filter is unchanged when we switch folders */ gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), cwd); sleep_in_main_loop (0.5); passed = passed && (gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (dialog)) == txt_filter); g_assert (passed); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), base_dir); sleep_in_main_loop (0.25); g_signal_emit_by_name (impl->browse_path_bar, "path-clicked", (GtkFilePath *) cwd_path, (GtkFilePath *) base_dir_path, FALSE); sleep_in_main_loop (0.25); passed = passed && (gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (dialog)) == txt_filter); log_test (passed, "test_folder_switch_and_filters(): filter after changing folder"); g_assert (passed); /* cleanups */ g_free (cwd); g_free (base_dir); gtk_file_path_free (cwd_path); gtk_file_path_free (base_dir_path); gtk_widget_destroy (dialog); log_test (passed, "test_folder_switch_and_filters(): all filter tests"); }
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 so that view isn't empty */ dt_view_filter_reset(darktable.view_manager, TRUE); 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_control_set_mouse_over_id(id); dt_ctl_switch_mode_to(DT_DEVELOP); } } } gtk_widget_destroy(metadata.frame); gtk_widget_destroy (filechooser); gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui)); }
static void gimp_file_dialog_add_filters (GimpFileDialog *dialog, Gimp *gimp, GSList *file_procs) { GtkFileFilter *all; GSList *list; all = gtk_file_filter_new (); gtk_file_filter_set_name (all, _("All files")); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), all); gtk_file_filter_add_pattern (all, "*"); all = gtk_file_filter_new (); gtk_file_filter_set_name (all, _("All images")); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), all); for (list = file_procs; list; list = g_slist_next (list)) { GimpPlugInProcedure *file_proc = list->data; if (file_proc->extensions_list) { GtkFileFilter *filter = gtk_file_filter_new (); GString *str; GSList *ext; gint i; str = g_string_new (gimp_plug_in_procedure_get_label (file_proc)); /* an arbitrary limit to keep the file dialog from becoming too wide */ #define MAX_EXTENSIONS 4 for (ext = file_proc->extensions_list, i = 0; ext; ext = g_slist_next (ext), i++) { const gchar *extension = ext->data; gchar *pattern; pattern = gimp_file_dialog_pattern_from_extension (extension); gtk_file_filter_add_pattern (filter, pattern); gtk_file_filter_add_pattern (all, pattern); g_free (pattern); if (i == 0) { g_string_append (str, " ("); } else if (i <= MAX_EXTENSIONS) { g_string_append (str, ", "); } if (i < MAX_EXTENSIONS) { g_string_append (str, "*."); g_string_append (str, extension); } else if (i == MAX_EXTENSIONS) { g_string_append (str, "..."); } if (! ext->next) { g_string_append (str, ")"); } } gtk_file_filter_set_name (filter, str->str); g_string_free (str, TRUE); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); } } gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), all); }