void update_preview_cb(GtkFileChooser * file_chooser, gpointer data) { gchar * filename; filename = gtk_file_chooser_get_preview_filename(file_chooser); update_preview(file_chooser,filename,GTK_IMAGE(data)); g_free(filename); }
static void gtk_filedialog_selchanged_callback(GtkFileChooser *chooser, wxFileDialog *dialog) { wxGtkString filename(gtk_file_chooser_get_preview_filename(chooser)); dialog->GTKSelectionChanged(wxString::FromUTF8(filename)); }
static void gimp_color_profile_chooser_dialog_update_preview (GimpColorProfileChooserDialog *dialog) { GimpColorProfile profile; gchar *filename; GError *error = NULL; filename = gtk_file_chooser_get_preview_filename (GTK_FILE_CHOOSER (dialog)); if (! filename) { gimp_color_profile_view_set_profile (dialog->priv->profile_view, NULL); return; } profile = gimp_lcms_profile_open_from_file (filename, &error); if (! profile) { gimp_color_profile_view_set_error (dialog->priv->profile_view, error->message); g_clear_error (&error); } else { gimp_color_profile_view_set_profile (dialog->priv->profile_view, profile); cmsCloseProfile (profile); } g_free (filename); }
static void update_preview_cb (GtkFileChooser *file_chooser, gpointer data) { GtkWidget *preview; gchar *filename, *file_contents = NULL; GdkPixbuf *pixbuf = NULL; gboolean have_preview; gsize length = 0; preview = GTK_WIDGET (data); filename = gtk_file_chooser_get_preview_filename (file_chooser); have_preview = filename && prepare_image (filename, &file_contents, &length, &pixbuf, FALSE); if (have_preview) { g_free (file_contents); have_preview = pixbuf != NULL; } g_free (filename); gtk_image_set_from_pixbuf (GTK_IMAGE (preview), pixbuf); if (pixbuf) g_object_unref (pixbuf); gtk_file_chooser_set_preview_widget_active (file_chooser, have_preview); }
static void avatar_chooser_update_preview_cb (GtkFileChooser *file_chooser, EmpathyAvatarChooser *chooser) { gchar *filename; filename = gtk_file_chooser_get_preview_filename (file_chooser); if (filename) { GtkWidget *image; GdkPixbuf *pixbuf = NULL; GdkPixbuf *scaled_pixbuf; pixbuf = gdk_pixbuf_new_from_file (filename, NULL); image = gtk_file_chooser_get_preview_widget (file_chooser); if (pixbuf) { scaled_pixbuf = empathy_pixbuf_scale_down_if_necessary (pixbuf, AVATAR_SIZE_SAVE); gtk_image_set_from_pixbuf (GTK_IMAGE (image), scaled_pixbuf); g_object_unref (scaled_pixbuf); g_object_unref (pixbuf); } else { gtk_image_set_from_stock (GTK_IMAGE (image), "gtk-dialog-question", GTK_ICON_SIZE_DIALOG); } g_free (filename); } gtk_file_chooser_set_preview_widget_active (file_chooser, TRUE); }
gboolean images_set_file_chooser_preview_image(GtkImage *preview_image, GtkFileChooser *file_chooser){ gchar *filename=gtk_file_chooser_get_preview_filename(file_chooser); if(G_STR_EMPTY(filename)){ if(filename) uber_free(filename); filename=gtk_file_chooser_get_filename(file_chooser); if(G_STR_EMPTY(filename)){ if(filename) uber_free(filename); return FALSE; } } GdkPixbuf *pixbuf=gdk_pixbuf_new_from_file_at_size(filename, 128, 128, NULL); uber_free(filename); if(!pixbuf) return FALSE; gtk_image_set_from_pixbuf(preview_image, pixbuf); uber_object_unref(pixbuf); gtk_file_chooser_set_preview_widget_active(file_chooser, TRUE); return TRUE; }/*images_set_file_chooser_preview_image(preview_image, file_chooser);*/
static void panel_properties_dialog_chooser_preview_update (GtkFileChooser *file_chooser, gpointer data) { GtkWidget *preview; char *filename; GdkPixbuf *pixbuf; gboolean have_preview; preview = GTK_WIDGET (data); filename = gtk_file_chooser_get_preview_filename (file_chooser); if (filename == NULL) return; pixbuf = gdk_pixbuf_new_from_file_at_size (filename, 128, 128, NULL); have_preview = (pixbuf != NULL); g_free (filename); gtk_image_set_from_pixbuf (GTK_IMAGE (preview), pixbuf); if (pixbuf) g_object_unref (pixbuf); gtk_file_chooser_set_preview_widget_active (file_chooser, have_preview); }
JNIEXPORT jstring JNICALL Java_org_gnome_gtk_GtkFileChooser_gtk_1file_1chooser_1get_1preview_1filename ( JNIEnv* env, jclass cls, jlong _self ) { char* result; jstring _result; GtkFileChooser* self; // convert parameter self self = (GtkFileChooser*) _self; // call function result = gtk_file_chooser_get_preview_filename(self); // cleanup parameter self // translate return value to JNI type _result = (jstring) bindings_java_newString(env, result); // cleanup return value if (result != NULL) { g_free(result); } // and finally return _result; }
static gboolean gimp_profile_view_query (GimpProfileChooserDialog *dialog) { gchar *filename; filename = gtk_file_chooser_get_preview_filename (GTK_FILE_CHOOSER (dialog)); if (filename) { gchar *name = NULL; gchar *desc = NULL; gchar *info = NULL; if (plug_in_icc_profile_file_info (dialog->gimp, gimp_get_user_context (dialog->gimp), NULL, filename, &name, &desc, &info, NULL)) { gsize info_len = info ? strlen (info) : 0; gsize name_len = strlen (filename); /* lcms tends to adds the filename at the end of the info string. * Since this is redundant information here, we remove it. */ if (info_len > name_len && strcmp (info + info_len - name_len, filename) == 0) { info_len -= name_len; } gtk_text_buffer_set_text (dialog->buffer, info ? info : "", info_len); if (desc) { dialog->desc = desc; desc = NULL; } else if (name) { dialog->desc = name; name = NULL; } dialog->filename = filename; filename = NULL; g_free (name); g_free (desc); g_free (info); } g_free (filename); } return FALSE; }
static void gwy_app_file_chooser_update_preview(GwyAppFileChooser *chooser) { GtkFileChooser *fchooser; GtkTreeModel *model; GdkPixbuf *pixbuf; GtkTreeIter iter; gchar *filename_sys; gwy_app_file_chooser_free_preview(chooser); model = gtk_icon_view_get_model(GTK_ICON_VIEW(chooser->preview)); gtk_list_store_clear(GTK_LIST_STORE(model)); fchooser = GTK_FILE_CHOOSER(chooser); filename_sys = gtk_file_chooser_get_preview_filename(fchooser); /* It should be UTF-8, but don't convert it just for gwy_debug() */ gwy_debug("%s", filename_sys); /* Make directories fail gracefully */ if (filename_sys && g_file_test(filename_sys, G_FILE_TEST_IS_DIR)) { g_free(filename_sys); filename_sys = NULL; } /* Never set the preview inactive. Gtk+ can do all kinds of silly things * if you do. */ if (!filename_sys) return; pixbuf = _gwy_app_recent_file_try_thumbnail(filename_sys); g_free(filename_sys); if (!pixbuf) { pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 1, 1); gdk_pixbuf_fill(pixbuf, 0x00000000); chooser->make_thumbnail = TRUE; } else chooser->make_thumbnail = FALSE; g_object_set(chooser->renderer_fileinfo, "ellipsize", PANGO_ELLIPSIZE_NONE, "wrap-width", TMS_NORMAL_THUMB_SIZE, NULL); gtk_list_store_insert_with_values(GTK_LIST_STORE(model), &iter, -1, COLUMN_PIXBUF, pixbuf, COLUMN_FILEINFO, _("…"), -1); g_object_unref(pixbuf); chooser->full_preview_id = g_timeout_add_full(G_PRIORITY_LOW, 250, gwy_app_file_chooser_do_full_preview, chooser, NULL); }
static void update_preview_cb (GtkFileChooser *chooser) { gchar *filename = gtk_file_chooser_get_preview_filename (chooser); gboolean have_preview = FALSE; if (filename) { GdkPixbuf *pixbuf; GError *error = NULL; pixbuf = my_new_from_file_at_size (filename, 128, 128, &error); if (pixbuf) { gtk_image_set_from_pixbuf (GTK_IMAGE (preview_image), pixbuf); g_object_unref (pixbuf); gtk_widget_show (preview_image); gtk_widget_hide (preview_label); have_preview = TRUE; } else { struct stat buf; if (g_stat (filename, &buf) == 0) { gchar *preview_text; gchar *size_str; gchar *modified_time; size_str = format_size (buf.st_size); modified_time = format_time (buf.st_mtime); preview_text = g_strdup_printf ("<i>Modified:</i>\t%s\n" "<i>Size:</i>\t%s\n", modified_time, size_str); gtk_label_set_markup (GTK_LABEL (preview_label), preview_text); g_free (modified_time); g_free (size_str); g_free (preview_text); gtk_widget_hide (preview_image); gtk_widget_show (preview_label); have_preview = TRUE; } } g_free (filename); } gtk_file_chooser_set_preview_widget_active (chooser, have_preview); }
static void update_preview_cb (GtkFileChooser *chooser) { gchar *filename = gtk_file_chooser_get_preview_filename (chooser); GtkWidget *label = g_object_get_data (G_OBJECT (chooser), "label-widget"); GtkWidget *image = g_object_get_data (G_OBJECT (chooser), "image-widget"); if (filename == NULL) { gtk_widget_hide (image); gtk_widget_hide (label); } else if (g_file_test (filename, G_FILE_TEST_IS_DIR)) { /* Not quite sure what to do here. */ gtk_widget_hide (image); gtk_widget_hide (label); } else { GdkPixbuf *buf; gboolean dummy; buf = gdk_pixbuf_new_from_file (filename, NULL); if (buf) { dummy = FALSE; } else { GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (chooser)); buf = gtk_icon_theme_load_icon (gtk_icon_theme_get_for_screen (screen), "unknown_image", 100, 100, NULL); dummy = buf != NULL; } if (buf) { GdkPixbuf *pixbuf = go_pixbuf_intelligent_scale (buf, PREVIEW_HSIZE, PREVIEW_VSIZE); gtk_image_set_from_pixbuf (GTK_IMAGE (image), pixbuf); g_object_unref (pixbuf); gtk_widget_show (image); if (dummy) gtk_label_set_text (GTK_LABEL (label), ""); else { int w = gdk_pixbuf_get_width (buf); int h = gdk_pixbuf_get_height (buf); char *size = g_strdup_printf (_("%d x %d"), w, h); gtk_label_set_text (GTK_LABEL (label), size); g_free (size); } gtk_widget_show (label); g_object_unref (buf); } g_free (filename); } }
int clip_GTK_FILECHOOSERGETPREVIEWFILENAME(ClipMachine * ClipMachineMemory) { C_object *cchooser = _fetch_co_arg(ClipMachineMemory); CHECKCOBJ(cchooser, GTK_IS_FILE_CHOOSER(cchooser->object)); _clip_retc(ClipMachineMemory, gtk_file_chooser_get_preview_filename(GTK_FILE_CHOOSER(cchooser->object))); return 0; err: return 1; }
static void gtkFileDlgUpdatePreview(GtkFileChooser *file_chooser, Ihandle* ih) { char *filename = gtk_file_chooser_get_preview_filename(file_chooser); IFnss cb = (IFnss)IupGetCallback(ih, "FILE_CB"); if (iupdrvIsFile(filename)) cb(ih, iupgtkStrConvertFromFilename(filename), "SELECT"); else cb(ih, iupgtkStrConvertFromFilename(filename), "OTHER"); g_free (filename); gtk_file_chooser_set_preview_widget_active(file_chooser, TRUE); }
static void on_update_preview( GtkFileChooser *chooser, GtkImage* img ) { char* file = gtk_file_chooser_get_preview_filename( chooser ); GdkPixbuf* pix = NULL; if( file ) { pix = gdk_pixbuf_new_from_file_at_scale( file, 128, 128, TRUE, NULL ); g_free( file ); } if( pix ) { gtk_image_set_from_pixbuf( img, pix ); g_object_unref( pix ); } }
static void update_preview_cb (GtkFileChooser *file_chooser, gpointer data) { GtkImage *preview = GTK_IMAGE (data); g_autofree char *filename = gtk_file_chooser_get_preview_filename (file_chooser); gint preview_width = 0; gint preview_height = 0; struct g_stat st_buf; g_autoptr(GdkPixbuf) pixbuf = NULL; GdkPixbufFormat *preview_format = gdk_pixbuf_get_file_info (filename, &preview_width, &preview_height); if (!filename || g_stat (filename, &st_buf) || (!S_ISREG (st_buf.st_mode))) { gtk_file_chooser_set_preview_widget_active (file_chooser, FALSE); return; // stat failed or file is not regular } if (!preview_format || preview_width <= 0 || preview_height <= 0 || preview_width > MAX_PREVIEW_SOURCE_SIZE || preview_height > MAX_PREVIEW_SOURCE_SIZE) { gtk_file_chooser_set_preview_widget_active (file_chooser, FALSE); return; // unpreviewable, 0px, or unsafely large } if (preview_width > MAX_PREVIEW_SIZE || preview_height > MAX_PREVIEW_SIZE) { pixbuf = gdk_pixbuf_new_from_file_at_size (filename, MAX_PREVIEW_SIZE, MAX_PREVIEW_SIZE, NULL); } else { pixbuf = gdk_pixbuf_new_from_file (filename, NULL); } pixbuf = gdk_pixbuf_apply_embedded_orientation (pixbuf); gtk_widget_set_size_request (GTK_WIDGET (preview), gdk_pixbuf_get_width (pixbuf) + 6, gdk_pixbuf_get_height (pixbuf) + 6); gtk_image_set_from_pixbuf (preview, pixbuf); gtk_file_chooser_set_preview_widget_active (file_chooser, pixbuf != NULL); }
static gboolean gtkFileDlgPreviewExposeEvent(GtkWidget *widget, GdkEventExpose *evt, Ihandle *ih) { GtkFileChooser *file_chooser = (GtkFileChooser*)iupAttribGet(ih, "_IUPDLG_FILE_CHOOSER"); char *filename = gtk_file_chooser_get_preview_filename(file_chooser); IFnss cb = (IFnss)IupGetCallback(ih, "FILE_CB"); if (iupdrvIsFile(filename)) cb(ih, iupgtkStrConvertFromFilename(filename), "PAINT"); else cb(ih, NULL, "PAINT"); g_free (filename); (void)evt; (void)widget; return TRUE; /* stop other handlers */ }
static void update_preview_cb(GtkFileChooser *file_chooser, GtkWidget *preview) { gboolean have_preview = FALSE; if (auto filename = gtk_file_chooser_get_preview_filename(file_chooser)) { GError* error = nullptr; auto pixbuf = gdk_pixbuf_new_from_file_at_size (filename, 128, 128, &error); if (!error) { gtk_image_set_from_pixbuf(GTK_IMAGE(preview), pixbuf); g_object_unref(pixbuf); have_preview = TRUE; } else { // nothing to do, the file is probably not a picture } g_free (filename); } gtk_file_chooser_set_preview_widget_active(file_chooser, have_preview); }
static void gtk_filedialog_update_preview_callback(GtkFileChooser *chooser, gpointer user_data) { GtkWidget *preview = GTK_WIDGET(user_data); wxGtkString filename(gtk_file_chooser_get_preview_filename(chooser)); if ( !filename ) return; GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file_at_size(filename, 128, 128, NULL); gboolean have_preview = pixbuf != NULL; gtk_image_set_from_pixbuf(GTK_IMAGE(preview), pixbuf); if ( pixbuf ) g_object_unref (pixbuf); gtk_file_chooser_set_preview_widget_active(chooser, have_preview); }
void XojOpenDlg::updatePreviewCallback(GtkFileChooser* fileChooser, void* userData) { gchar* filename = gtk_file_chooser_get_preview_filename(fileChooser); if (!filename) { gtk_file_chooser_set_preview_widget_active(fileChooser, false); return; } string filepath = filename; g_free(filename); filename = NULL; if (filepath.size() <= 4 || filepath.substr(filepath.size() - 4) != ".xoj") { gtk_file_chooser_set_preview_widget_active(fileChooser, false); return; } XojPreviewExtractor extractor; PreviewExtractResult result = extractor.readFile(filepath); if (result != PREVIEW_RESULT_IMAGE_READ) { gtk_file_chooser_set_preview_widget_active(fileChooser, false); return; } GError* error = NULL; GInputStream* in = g_memory_input_stream_new_from_data(extractor.getData().c_str(), extractor.getData().length(), NULL); GdkPixbuf* pixbuf = gdk_pixbuf_new_from_stream(in, NULL, &error); g_input_stream_close(in, NULL, &error); if (pixbuf) { GtkWidget * image = gtk_file_chooser_get_preview_widget(fileChooser); gtk_image_set_from_pixbuf(GTK_IMAGE(image), pixbuf); g_object_unref(pixbuf); gtk_file_chooser_set_preview_widget_active(fileChooser, true); } }
/*! \brief Updates the preview when the selection changes. * \par Function Description * This is the callback function connected to the 'update-preview' * signal of the <B>GtkFileChooser</B>. * * It updates the preview widget with the name of the newly selected * file. * * \param [in] chooser The file chooser to add the preview to. * \param [in] user_data A pointer on the preview widget. */ static void x_fileselect_callback_update_preview (GtkFileChooser *chooser, gpointer user_data) { Preview *preview = PREVIEW (user_data); gchar *filename, *preview_filename = NULL; filename = gtk_file_chooser_get_preview_filename (chooser); if (filename != NULL && !g_file_test (filename, G_FILE_TEST_IS_DIR)) { preview_filename = filename; } /* update preview */ g_object_set (preview, "filename", preview_filename, "active", (preview_filename != NULL), NULL); g_free (filename); }
void ImageOpenDlg::updatePreviewCallback(GtkFileChooser * fileChooser, void * userData) { gchar * filename = gtk_file_chooser_get_preview_filename(fileChooser); if (filename) { GdkPixbuf * pixbuf = gdk_pixbuf_new_from_file(filename, NULL); GtkWidget * image = gtk_file_chooser_get_preview_widget(fileChooser); if (pixbuf) { GdkPixbuf * scaled_pixbuf = pixbufScaleDownIfNecessary(pixbuf, 256); gtk_image_set_from_pixbuf(GTK_IMAGE(image), scaled_pixbuf); g_object_unref(scaled_pixbuf); g_object_unref(pixbuf); } else { gtk_image_set_from_stock(GTK_IMAGE(image), "gtk-dialog-question", GTK_ICON_SIZE_DIALOG); } g_free(filename); } gtk_file_chooser_set_preview_widget_active(fileChooser, true); }
static void UpdateFilePreviewWidget(GtkFileChooser *file_chooser, gpointer preview_widget_voidptr) { GtkImage *preview_widget = GTK_IMAGE(preview_widget_voidptr); char *image_filename = gtk_file_chooser_get_preview_filename(file_chooser); if (!image_filename) { gtk_file_chooser_set_preview_widget_active(file_chooser, FALSE); return; } // We do this so GTK scales down images that are too big, but not scale up images that are too small GdkPixbuf *preview_pixbuf = gdk_pixbuf_new_from_file(image_filename, NULL); if (!preview_pixbuf) { g_free(image_filename); gtk_file_chooser_set_preview_widget_active(file_chooser, FALSE); return; } if (gdk_pixbuf_get_width(preview_pixbuf) > MAX_PREVIEW_SIZE || gdk_pixbuf_get_height(preview_pixbuf) > MAX_PREVIEW_SIZE) { g_object_unref(preview_pixbuf); preview_pixbuf = gdk_pixbuf_new_from_file_at_size(image_filename, MAX_PREVIEW_SIZE, MAX_PREVIEW_SIZE, NULL); } g_free(image_filename); if (!preview_pixbuf) { gtk_file_chooser_set_preview_widget_active(file_chooser, FALSE); return; } // This is the easiest way to do center alignment without worrying about containers // Minimum 3px padding each side (hence the 6) just to make things nice gint x_padding = (MAX_PREVIEW_SIZE + 6 - gdk_pixbuf_get_width(preview_pixbuf)) / 2; gtk_misc_set_padding(GTK_MISC(preview_widget), x_padding, 0); gtk_image_set_from_pixbuf(preview_widget, preview_pixbuf); g_object_unref(preview_pixbuf); gtk_file_chooser_set_preview_widget_active(file_chooser, TRUE); }
static void cb_gimmix_covers_plugin_cover_file_preview (GtkFileChooser *file_chooser, gpointer data) { GtkWidget *preview = NULL; char *filename = NULL; GdkPixbuf *pixbuf = NULL; gboolean have_preview; preview = GTK_WIDGET (data); filename = gtk_file_chooser_get_preview_filename (file_chooser); pixbuf = gdk_pixbuf_new_from_file_at_size (filename, 128, 128, NULL); have_preview = (pixbuf != NULL); g_free (filename); gtk_image_set_from_pixbuf (GTK_IMAGE (preview), pixbuf); if (pixbuf != NULL) { g_object_unref (pixbuf); } gtk_file_chooser_set_preview_widget_active (file_chooser, have_preview); return; }
static void update_image_preview(void *filechooser, void *image) { #define MAX_PREVIEW_SIZE 256 char *filename = gtk_file_chooser_get_preview_filename(filechooser); if (!filename) return; // load preview void *pixbuf = gdk_pixbuf_new_from_file(filename, NULL); if (!pixbuf) { g_free_utox(filename); gtk_file_chooser_set_preview_widget_active(filechooser, false); return; } // if preview too big load smaller if (gdk_pixbuf_get_width(pixbuf) > MAX_PREVIEW_SIZE || gdk_pixbuf_get_height(pixbuf) > MAX_PREVIEW_SIZE) { g_object_unref(pixbuf); pixbuf = gdk_pixbuf_new_from_file_at_size(filename, MAX_PREVIEW_SIZE, MAX_PREVIEW_SIZE, NULL); } g_free_utox(filename); if (!pixbuf) { gtk_file_chooser_set_preview_widget_active(filechooser, false); return; } // pad to MAX_PREVIEW_SIZE + 3px margins int margin = (MAX_PREVIEW_SIZE + 6 - gdk_pixbuf_get_width(pixbuf)) / 2; gtk_widget_set_margin_left(image, margin); gtk_widget_set_margin_right(image, margin); // set preview gtk_image_set_from_pixbuf(image, pixbuf); g_object_unref(pixbuf); gtk_file_chooser_set_preview_widget_active(filechooser, true); }
/** * update the preview of the log file chooser * * \param file_chooser * \param preview * * \return FALSE * */ static gboolean preferences_view_update_preview_logo ( GtkFileChooser *file_chooser, GtkWidget *preview ) { char *filename; GdkPixbuf *pixbuf; gboolean have_preview; filename = gtk_file_chooser_get_preview_filename (file_chooser); if (!filename) return FALSE; pixbuf = gdk_pixbuf_new_from_file_at_size ( filename, LOGO_WIDTH, LOGO_HEIGHT, NULL ); have_preview = ( pixbuf != NULL ); g_free (filename); gtk_image_set_from_pixbuf ( GTK_IMAGE ( preview ), pixbuf ); if ( pixbuf ) g_object_unref ( pixbuf ); gtk_file_chooser_set_preview_widget_active ( file_chooser, have_preview ); return FALSE; }
static gboolean gwy_app_file_chooser_do_full_preview(gpointer user_data) { GtkFileChooser *fchooser; GtkTreeModel *model; GtkListStore *store; GwyAppFileChooser *chooser; GSList *channel_ids, *l; GdkPixbuf *pixbuf; GtkTreeIter iter; GString *str; gint id; chooser = GWY_APP_FILE_CHOOSER(user_data); chooser->full_preview_id = 0; /* Always no-op here? */ gwy_app_file_chooser_free_preview(chooser); fchooser = GTK_FILE_CHOOSER(chooser); chooser->preview_name_sys = gtk_file_chooser_get_preview_filename(fchooser); /* We should not be called when gtk_file_chooser_get_preview_filename() * returns NULL preview file name */ if (!chooser->preview_name_sys) { g_warning("Full preview invoked with NULL preview file name"); return FALSE; } model = gtk_icon_view_get_model(GTK_ICON_VIEW(chooser->preview)); store = GTK_LIST_STORE(model); chooser->preview_data = gwy_file_load(chooser->preview_name_sys, GWY_RUN_NONINTERACTIVE, NULL); if (!chooser->preview_data) { gwy_app_file_chooser_free_preview(chooser); gtk_tree_model_get_iter_first(model, &iter); gtk_list_store_set(store, &iter, COLUMN_FILEINFO, _("Cannot preview"), -1); return FALSE; } channel_ids = NULL; gwy_container_foreach(chooser->preview_data, NULL, add_channel_id, &channel_ids); channel_ids = g_slist_sort(channel_ids, compare_ids); if (!channel_ids) { gwy_app_file_chooser_free_preview(chooser); return FALSE; } g_object_set(chooser->renderer_fileinfo, "ellipsize", PANGO_ELLIPSIZE_END, "wrap-width", -1, NULL); gtk_list_store_clear(store); str = g_string_new(NULL); for (l = channel_ids; l; l = g_slist_next(l)) { id = GPOINTER_TO_INT(l->data); pixbuf = gwy_app_get_channel_thumbnail(chooser->preview_data, id, TMS_NORMAL_THUMB_SIZE, TMS_NORMAL_THUMB_SIZE); if (!pixbuf) { g_warning("Cannot make a pixbuf of channel %d", id); continue; } if (chooser->make_thumbnail) { _gwy_app_recent_file_write_thumbnail(chooser->preview_name_sys, chooser->preview_data, id, pixbuf); chooser->make_thumbnail = FALSE; } gwy_app_file_chooser_describe_channel(chooser->preview_data, id, str); gtk_list_store_insert_with_values(store, &iter, -1, COLUMN_PIXBUF, pixbuf, COLUMN_FILEINFO, str->str, -1); g_object_unref(pixbuf); } g_string_free(str, TRUE); return FALSE; }
//================================================================ int GUI_Dialog_run (char *dnam, int dnSiz, char *fnam, int fnSiz, GtkWidget *gtkDlg) { //================================================================ // GUI_Dialog_run INTERNAL for gtk_dialog_run // start waiting; does not return until user clicks button. int i1, iRes; char *p1, *filename; iRes = gtk_dialog_run (GTK_DIALOG(gtkDlg)); // wait (modal) ! printf(" iRes=%d\n",iRes); // -6=cancel, -3=ACCEPT if (iRes == GTK_RESPONSE_ACCEPT) { filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (gtkDlg)); if(!filename) filename = gtk_file_chooser_get_preview_filename (GTK_FILE_CHOOSER (gtkDlg)); printf(" GTK_RESPONSE_ACCEPT |%s|\n",filename); if(!filename) { TX_Print ("**** ERROR GUI_Dialog_run ****"); iRes = -3; goto L_exit; } // find p1 = last delimiter #ifdef _MSC_VER p1 = strrchr(filename, '\\'); #else p1 = strrchr(filename, '/'); #endif // copy out directory if(p1) { i1 = p1 - filename; if(i1 >= dnSiz) {iRes = -2; goto L_exit; } // printf(" i1=%d\n",i1); strncpy(dnam, filename, i1); dnam[i1] = '\0'; } else { // no '/' in filename TX_Print ("**** ERROR GUI_Dialog_run - E001 ****"); iRes = -3; goto L_exit; } // copy out filename ++p1; if(strlen(p1) >= fnSiz) {iRes = -2; goto L_exit; } strcpy(fnam, p1); g_free (filename); iRes = 0; } else { iRes = -1; } L_exit: if(gtkDlg) { // not yet killed from DIR-SYM gtk_widget_destroy (gtkDlg); gtkDlg = NULL; // 2013-05-13 } return iRes; }
Php::Value GtkFileChooserDialog_::get_uri() { std::string ret = gtk_file_chooser_get_preview_filename (GTK_FILE_CHOOSER(instance)); return ret; }
// maybe this should be (partly) in common/imageio.[c|h]? static void _lib_import_update_preview(GtkFileChooser *file_chooser, gpointer data) { GtkWidget *preview; char *filename; GdkPixbuf *pixbuf = NULL; gboolean have_preview = FALSE, no_preview_fallback = FALSE; preview = GTK_WIDGET(data); filename = gtk_file_chooser_get_preview_filename(file_chooser); if(!g_file_test(filename, G_FILE_TEST_IS_REGULAR)) { no_preview_fallback = TRUE; } else { // don't create dng thumbnails to avoid crashes in libtiff when these are hdr: char *c = filename + strlen(filename); while(c > filename && *c != '.') c--; if(!strcasecmp(c, ".dng")) no_preview_fallback = TRUE; } // unfortunately we can not use following, because frequently it uses wrong orientation // pixbuf = gdk_pixbuf_new_from_file_at_size(filename, 128, 128, NULL); have_preview = (pixbuf != NULL); if(!have_preview && !no_preview_fallback) { uint8_t *buffer = NULL; size_t size; char *mime_type = NULL; if(!dt_exif_get_thumbnail(filename, &buffer, &size, &mime_type)) { // Scale the image to the correct size GdkPixbuf *tmp; GdkPixbufLoader *loader = gdk_pixbuf_loader_new(); if (!gdk_pixbuf_loader_write(loader, buffer, size, NULL)) goto cleanup; if (!(tmp = gdk_pixbuf_loader_get_pixbuf(loader))) goto cleanup; float ratio = 1.0 * gdk_pixbuf_get_height(tmp) / gdk_pixbuf_get_width(tmp); int width = 128, height = 128 * ratio; pixbuf = gdk_pixbuf_scale_simple(tmp, width, height, GDK_INTERP_BILINEAR); have_preview = TRUE; cleanup: gdk_pixbuf_loader_close(loader, NULL); free(mime_type); free(buffer); g_object_unref(loader); // This should clean up tmp as well } } if(have_preview && !no_preview_fallback) { // get image orientation dt_image_t img = { 0 }; (void)dt_exif_read(&img, filename); // Rotate the image to the correct orientation GdkPixbuf *tmp = pixbuf; if(img.orientation == ORIENTATION_ROTATE_CCW_90_DEG) { tmp = gdk_pixbuf_rotate_simple(pixbuf, GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE); } else if(img.orientation == ORIENTATION_ROTATE_CW_90_DEG) { tmp = gdk_pixbuf_rotate_simple(pixbuf, GDK_PIXBUF_ROTATE_CLOCKWISE); } else if(img.orientation == ORIENTATION_ROTATE_180_DEG) { tmp = gdk_pixbuf_rotate_simple(pixbuf, GDK_PIXBUF_ROTATE_UPSIDEDOWN); } if(pixbuf != tmp) { g_object_unref(pixbuf); pixbuf = tmp; } } if(no_preview_fallback || !have_preview) { guint8 *image_buffer = NULL; /* load the dt logo as a brackground */ char filename[PATH_MAX] = { 0 }; char datadir[PATH_MAX] = { 0 }; char *logo; dt_logo_season_t season = get_logo_season(); if(season != DT_LOGO_SEASON_NONE) logo = g_strdup_printf("%%s/pixmaps/idbutton-%d.svg", (int)season); else logo = g_strdup("%s/pixmaps/idbutton.svg"); dt_loc_get_datadir(datadir, sizeof(datadir)); snprintf(filename, sizeof(filename), logo, datadir); g_free(logo); RsvgHandle *svg = rsvg_handle_new_from_file(filename, NULL); if(svg) { cairo_surface_t *surface; cairo_t *cr; RsvgDimensionData dimension; rsvg_handle_get_dimensions(svg, &dimension); float svg_size = MAX(dimension.width, dimension.height); float final_size = 128; float factor = final_size / svg_size; float final_width = dimension.width * factor * darktable.gui->ppd, final_height = dimension.height * factor * darktable.gui->ppd; int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, final_width); image_buffer = (guint8 *)calloc(stride * final_height, sizeof(guint8)); surface = dt_cairo_image_surface_create_for_data(image_buffer, CAIRO_FORMAT_ARGB32, final_width, final_height, stride); if(cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) { free(image_buffer); image_buffer = NULL; } else { cr = cairo_create(surface); cairo_scale(cr, factor, factor); rsvg_handle_render_cairo(svg, cr); cairo_surface_flush(surface); pixbuf = gdk_pixbuf_get_from_surface(surface, 0, 0, final_width / darktable.gui->ppd, final_height / darktable.gui->ppd); } g_object_unref(svg); } have_preview = TRUE; } if(have_preview) gtk_image_set_from_pixbuf(GTK_IMAGE(preview), pixbuf); if(pixbuf) g_object_unref(pixbuf); g_free(filename); gtk_file_chooser_set_preview_widget_active(file_chooser, have_preview); }