inicial

1 files changed, 509 insertions, 0 deletions

diff --git a/src/eom-thumbnail.c b/src/eom-thumbnail.c
new file mode 100644
index 0000000..d84cb24
--- /dev/null
+++ b/src/eom-thumbnail.c
@@ -0,0 +1,509 @@
+/* Eye Of Mate - Thumbnailing functions
+ *
+ * Copyright (C) 2000-2008 The Free Software Foundation
+ *
+ * Author: Lucas Rocha <[email protected]>
+ *
+ * Based on eel code (eel/eel-graphic-effects.c) by:
+ * 	- Andy Hertzfeld <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/* We must define MATE_DESKTOP_USE_UNSTABLE_API to be able
+   to use MateDesktopThumbnail */
+#ifndef MATE_DESKTOP_USE_UNSTABLE_API
+#define MATE_DESKTOP_USE_UNSTABLE_API
+#endif
+#include <libmateui/mate-desktop-thumbnail.h>
+
+#include "eom-thumbnail.h"
+#include "eom-list-store.h"
+#include "eom-debug.h"
+
+#define EOM_THUMB_ERROR eom_thumb_error_quark ()
+
+static MateDesktopThumbnailFactory *factory = NULL;
+static GdkPixbuf *frame = NULL;
+
+typedef enum {
+	EOM_THUMB_ERROR_VFS,
+	EOM_THUMB_ERROR_GENERIC,
+	EOM_THUMB_ERROR_UNKNOWN
+} EomThumbError;
+
+typedef struct {
+	char    *uri_str;
+	char    *thumb_path;
+	time_t   mtime;
+	char    *mime_type;
+	gboolean thumb_exists;
+	gboolean failed_thumb_exists;
+	gboolean can_read;
+} EomThumbData;
+
+static GQuark
+eom_thumb_error_quark (void)
+{
+	static GQuark q = 0;
+	if (q == 0)
+		q = g_quark_from_static_string ("eom-thumb-error-quark");
+
+	return q;
+}
+
+static void
+set_vfs_error (GError **error, GError *ioerror)
+{
+	g_set_error (error,
+		     EOM_THUMB_ERROR,
+		     EOM_THUMB_ERROR_VFS,
+		     "%s", ioerror ? ioerror->message : "VFS error making a thumbnail");
+}
+
+static void
+set_thumb_error (GError **error, int error_id, const char *string)
+{
+	g_set_error (error,
+		     EOM_THUMB_ERROR,
+		     error_id,
+		     "%s", string);
+}
+
+static GdkPixbuf*
+get_valid_thumbnail (EomThumbData *data, GError **error)
+{
+	GdkPixbuf *thumb = NULL;
+
+	g_return_val_if_fail (data != NULL, NULL);
+
+	/* does a thumbnail under the path exists? */
+	if (data->thumb_exists) {
+		thumb = gdk_pixbuf_new_from_file (data->thumb_path, error);
+
+		/* is this thumbnail file up to date? */
+		if (thumb != NULL && !mate_desktop_thumbnail_is_valid (thumb, data->uri_str, data->mtime)) {
+			g_object_unref (thumb);
+			thumb = NULL;
+		}
+	}
+
+	return thumb;
+}
+
+static GdkPixbuf *
+create_thumbnail_from_pixbuf (EomThumbData *data,
+			      GdkPixbuf *pixbuf,
+			      GError **error)
+{
+	GdkPixbuf *thumb;
+	gint width, height;
+	gfloat perc;
+
+	g_assert (factory != NULL);
+
+	width = gdk_pixbuf_get_width (pixbuf);
+	height = gdk_pixbuf_get_height (pixbuf);
+
+	perc = CLAMP (128.0/(MAX (width, height)), 0, 1);
+
+	thumb = mate_desktop_thumbnail_scale_down_pixbuf (pixbuf,
+							   width*perc,
+							   height*perc);
+
+	return thumb;
+}
+
+static void
+eom_thumb_data_free (EomThumbData *data)
+{
+	if (data == NULL)
+		return;
+
+	g_free (data->thumb_path);
+	g_free (data->mime_type);
+	g_free (data->uri_str);
+
+	g_slice_free (EomThumbData, data);
+}
+
+static EomThumbData*
+eom_thumb_data_new (GFile *file, GError **error)
+{
+	EomThumbData *data;
+	GFileInfo *file_info;
+	GError *ioerror = NULL;
+
+	g_return_val_if_fail (file != NULL, NULL);
+	g_return_val_if_fail (error != NULL && *error == NULL, NULL);
+
+	data = g_slice_new0 (EomThumbData);
+
+	data->uri_str    = g_file_get_uri (file);
+	data->thumb_path = mate_desktop_thumbnail_path_for_uri (data->uri_str, MATE_DESKTOP_THUMBNAIL_SIZE_NORMAL);
+
+	file_info = g_file_query_info (file,
+				       G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE ","
+				       G_FILE_ATTRIBUTE_TIME_MODIFIED ","
+				       G_FILE_ATTRIBUTE_THUMBNAIL_PATH ","
+				       G_FILE_ATTRIBUTE_THUMBNAILING_FAILED ","
+				       G_FILE_ATTRIBUTE_ACCESS_CAN_READ,
+				       0, NULL, &ioerror);
+	if (file_info == NULL)
+	{
+		set_vfs_error (error, ioerror);
+		g_clear_error (&ioerror);
+	}
+
+	if (*error == NULL) {
+		/* if available, copy data */
+		data->mtime = g_file_info_get_attribute_uint64 (file_info,
+								G_FILE_ATTRIBUTE_TIME_MODIFIED);
+		data->mime_type = g_strdup (g_file_info_get_content_type (file_info));
+
+		data->thumb_exists = (g_file_info_get_attribute_byte_string (file_info,
+					                                     G_FILE_ATTRIBUTE_THUMBNAIL_PATH) != NULL);
+		data->failed_thumb_exists = g_file_info_get_attribute_boolean (file_info,
+									       G_FILE_ATTRIBUTE_THUMBNAILING_FAILED);
+		data->can_read = TRUE;
+		if (g_file_info_has_attribute (file_info, G_FILE_ATTRIBUTE_ACCESS_CAN_READ)) {
+			data->can_read = g_file_info_get_attribute_boolean (file_info,
+									    G_FILE_ATTRIBUTE_ACCESS_CAN_READ);
+		}
+	}
+	else {
+		eom_thumb_data_free (data);
+		data = NULL;
+		g_clear_error (&ioerror);
+	}
+
+	g_object_unref (file_info);
+
+	return data;
+}
+
+static void
+draw_frame_row (GdkPixbuf *frame_image,
+		gint target_width,
+		gint source_width,
+		gint source_v_position,
+		gint dest_v_position,
+		GdkPixbuf *result_pixbuf,
+		gint left_offset,
+		gint height)
+{
+	gint remaining_width, h_offset, slab_width;
+
+	remaining_width = target_width;
+	h_offset = 0;
+
+	while (remaining_width > 0) {
+		slab_width = remaining_width > source_width ?
+			     source_width : remaining_width;
+
+		gdk_pixbuf_copy_area (frame_image,
+				      left_offset,
+				      source_v_position,
+				      slab_width,
+				      height,
+				      result_pixbuf,
+				      left_offset + h_offset,
+				      dest_v_position);
+
+		remaining_width -= slab_width;
+		h_offset += slab_width;
+	}
+}
+
+static void
+draw_frame_column (GdkPixbuf *frame_image,
+		   gint target_height,
+		   gint source_height,
+		   gint source_h_position,
+		   gint dest_h_position,
+		   GdkPixbuf *result_pixbuf,
+		   gint top_offset,
+		   gint width)
+{
+	gint remaining_height, v_offset, slab_height;
+
+	remaining_height = target_height;
+	v_offset = 0;
+
+	while (remaining_height > 0) {
+		slab_height = remaining_height > source_height ?
+			      source_height : remaining_height;
+
+		gdk_pixbuf_copy_area (frame_image,
+				      source_h_position,
+				      top_offset,
+				      width,
+				      slab_height,
+				      result_pixbuf,
+				      dest_h_position,
+				      top_offset + v_offset);
+
+		remaining_height -= slab_height;
+		v_offset += slab_height;
+	}
+}
+
+static GdkPixbuf *
+eom_thumbnail_stretch_frame_image (GdkPixbuf *frame_image,
+				   gint left_offset,
+				   gint top_offset,
+				   gint right_offset,
+				   gint bottom_offset,
+                                   gint dest_width,
+				   gint dest_height,
+				   gboolean fill_flag)
+{
+        GdkPixbuf *result_pixbuf;
+        gint frame_width, frame_height;
+        gint target_width, target_frame_width;
+        gint target_height, target_frame_height;
+
+        frame_width  = gdk_pixbuf_get_width  (frame_image);
+        frame_height = gdk_pixbuf_get_height (frame_image);
+
+        if (fill_flag) {
+		result_pixbuf = gdk_pixbuf_scale_simple (frame_image,
+							 dest_width,
+							 dest_height,
+							 GDK_INTERP_NEAREST);
+        } else {
+                result_pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
+						TRUE,
+						8,
+						dest_width,
+						dest_height);
+
+		/* Clear pixbuf to fully opaque white */
+		gdk_pixbuf_fill (result_pixbuf, 0xffffffff);
+        }
+
+        target_width  = dest_width - left_offset - right_offset;
+        target_frame_width = frame_width - left_offset - right_offset;
+
+        target_height  = dest_height - top_offset - bottom_offset;
+        target_frame_height = frame_height - top_offset - bottom_offset;
+
+        /* Draw the left top corner  and top row */
+        gdk_pixbuf_copy_area (frame_image,
+			      0, 0,
+			      left_offset,
+			      top_offset,
+			      result_pixbuf,
+			      0, 0);
+
+        draw_frame_row (frame_image,
+			target_width,
+			target_frame_width,
+			0, 0,
+			result_pixbuf,
+			left_offset,
+			top_offset);
+
+        /* Draw the right top corner and left column */
+        gdk_pixbuf_copy_area (frame_image,
+			      frame_width - right_offset,
+			      0,
+			      right_offset,
+			      top_offset,
+			      result_pixbuf,
+			      dest_width - right_offset,
+			      0);
+
+        draw_frame_column (frame_image,
+			   target_height,
+			   target_frame_height,
+			   0, 0,
+			   result_pixbuf,
+			   top_offset,
+			   left_offset);
+
+        /* Draw the bottom right corner and bottom row */
+        gdk_pixbuf_copy_area (frame_image,
+			      frame_width - right_offset,
+			      frame_height - bottom_offset,
+			      right_offset,
+			      bottom_offset,
+			      result_pixbuf,
+			      dest_width - right_offset,
+			      dest_height - bottom_offset);
+
+        draw_frame_row (frame_image,
+			target_width,
+			target_frame_width,
+			frame_height - bottom_offset,
+			dest_height - bottom_offset,
+			result_pixbuf,
+			left_offset, bottom_offset);
+
+        /* Draw the bottom left corner and the right column */
+        gdk_pixbuf_copy_area (frame_image,
+			      0,
+			      frame_height - bottom_offset,
+			      left_offset,
+			      bottom_offset,
+			      result_pixbuf,
+			      0,
+			      dest_height - bottom_offset);
+
+        draw_frame_column (frame_image,
+			   target_height,
+			   target_frame_height,
+			   frame_width - right_offset,
+			   dest_width - right_offset,
+			   result_pixbuf, top_offset,
+			   right_offset);
+
+        return result_pixbuf;
+}
+
+GdkPixbuf *
+eom_thumbnail_add_frame (GdkPixbuf *thumbnail)
+{
+	GdkPixbuf *result_pixbuf;
+	gint source_width, source_height;
+	gint dest_width, dest_height;
+
+	source_width  = gdk_pixbuf_get_width  (thumbnail);
+	source_height = gdk_pixbuf_get_height (thumbnail);
+
+	dest_width  = source_width  + 9;
+	dest_height = source_height + 9;
+
+	result_pixbuf = eom_thumbnail_stretch_frame_image (frame,
+							   3, 3, 6, 6,
+	                                	           dest_width,
+							   dest_height,
+							   FALSE);
+
+	gdk_pixbuf_copy_area (thumbnail,
+			      0, 0,
+			      source_width,
+			      source_height,
+			      result_pixbuf,
+			      3, 3);
+
+	return result_pixbuf;
+}
+
+GdkPixbuf *
+eom_thumbnail_fit_to_size (GdkPixbuf *thumbnail, gint dimension)
+{
+	gint width, height;
+
+	width = gdk_pixbuf_get_width (thumbnail);
+	height = gdk_pixbuf_get_height (thumbnail);
+
+	if (width > dimension || height > dimension) {
+		GdkPixbuf *result_pixbuf;
+		gfloat factor;
+
+		if (width > height) {
+			factor = (gfloat) dimension / (gfloat) width;
+		} else {
+			factor = (gfloat) dimension / (gfloat) height;
+		}
+
+		width  = MAX (width  * factor, 1);
+		height = MAX (height * factor, 1);
+
+		result_pixbuf = mate_desktop_thumbnail_scale_down_pixbuf (thumbnail, width, height);
+
+		return result_pixbuf;
+	}
+	return gdk_pixbuf_copy (thumbnail);
+}
+
+GdkPixbuf*
+eom_thumbnail_load (EomImage *image, GError **error)
+{
+	GdkPixbuf *thumb = NULL;
+	GFile *file;
+	EomThumbData *data;
+	GdkPixbuf *pixbuf;
+
+	g_return_val_if_fail (image != NULL, NULL);
+	g_return_val_if_fail (error != NULL && *error == NULL, NULL);
+
+	file = eom_image_get_file (image);
+	data = eom_thumb_data_new (file, error);
+	g_object_unref (file);
+
+	if (data == NULL)
+		return NULL;
+
+	if (!data->can_read ||
+	    (data->failed_thumb_exists && mate_desktop_thumbnail_factory_has_valid_failed_thumbnail (factory, data->uri_str, data->mtime))) {
+		eom_debug_message (DEBUG_THUMBNAIL, "%s: bad permissions or valid failed thumbnail present",data->uri_str);
+		set_thumb_error (error, EOM_THUMB_ERROR_GENERIC, "Thumbnail creation failed");
+		return NULL;
+	}
+
+	/* check if there is already a valid cached thumbnail */
+	thumb = get_valid_thumbnail (data, error);
+
+	if (thumb != NULL) {
+		eom_debug_message (DEBUG_THUMBNAIL, "%s: loaded from cache",data->uri_str);
+	} else if (mate_desktop_thumbnail_factory_can_thumbnail (factory, data->uri_str, data->mime_type, data->mtime)) {
+		pixbuf = eom_image_get_pixbuf (image);
+
+		if (pixbuf != NULL) {
+			/* generate a thumbnail from the in-memory image,
+			   if we have already loaded the image */
+			eom_debug_message (DEBUG_THUMBNAIL, "%s: creating from pixbuf",data->uri_str);
+			thumb = create_thumbnail_from_pixbuf (data, pixbuf, error);
+			g_object_unref (pixbuf);
+		} else {
+			/* generate a thumbnail from the file */
+			eom_debug_message (DEBUG_THUMBNAIL, "%s: creating from file",data->uri_str);
+			thumb = mate_desktop_thumbnail_factory_generate_thumbnail (factory, data->uri_str, data->mime_type);
+		}
+
+		if (thumb != NULL) {
+			/* Save the new thumbnail */
+			mate_desktop_thumbnail_factory_save_thumbnail (factory, thumb, data->uri_str, data->mtime);
+			eom_debug_message (DEBUG_THUMBNAIL, "%s: normal thumbnail saved",data->uri_str);
+		} else {
+			/* Save a failed thumbnail, to stop further thumbnail attempts */
+			mate_desktop_thumbnail_factory_create_failed_thumbnail (factory, data->uri_str, data->mtime);
+			eom_debug_message (DEBUG_THUMBNAIL, "%s: failed thumbnail saved",data->uri_str);
+			set_thumb_error (error, EOM_THUMB_ERROR_GENERIC, "Thumbnail creation failed");
+		}
+	}
+
+	eom_thumb_data_free (data);
+
+	return thumb;
+}
+
+void
+eom_thumbnail_init (void)
+{
+	if (factory == NULL) {
+		factory = mate_desktop_thumbnail_factory_new (MATE_DESKTOP_THUMBNAIL_SIZE_NORMAL);
+	}
+
+	if (frame == NULL) {
+		frame = gdk_pixbuf_new_from_file (EOM_DATA_DIR "/pixmaps/thumbnail-frame.png", NULL);
+	}
+}