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);
}
