moving from https://github.com/perberos/mate-desktop-environment

1 files changed, 751 insertions, 0 deletions

diff --git a/libcaja-private/caja-icon-info.c b/libcaja-private/caja-icon-info.c
new file mode 100644
index 00000000..63ed8792
--- /dev/null
+++ b/libcaja-private/caja-icon-info.c
@@ -0,0 +1,751 @@
+/* caja-icon-info.c
+ * Copyright (C) 2007  Red Hat, Inc.,  Alexander Larsson <[email protected]>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+#include <string.h>
+#include "caja-icon-info.h"
+#include "caja-default-file-icon.h"
+#include <gtk/gtk.h>
+#include <gio/gio.h>
+#include <eel/eel-gdk-pixbuf-extensions.h>
+
+struct _CajaIconInfo
+{
+    GObject parent;
+
+    gboolean sole_owner;
+    guint64 last_use_time;
+    GdkPixbuf *pixbuf;
+
+    gboolean got_embedded_rect;
+    GdkRectangle embedded_rect;
+    gint n_attach_points;
+    GdkPoint *attach_points;
+    char *display_name;
+    char *icon_name;
+};
+
+struct _CajaIconInfoClass
+{
+    GObjectClass parent_class;
+};
+
+static void schedule_reap_cache (void);
+
+G_DEFINE_TYPE (CajaIconInfo,
+               caja_icon_info,
+               G_TYPE_OBJECT);
+
+static void
+caja_icon_info_init (CajaIconInfo *icon)
+{
+    icon->last_use_time = g_thread_gettime ();
+    icon->sole_owner = TRUE;
+}
+
+gboolean
+caja_icon_info_is_fallback (CajaIconInfo  *icon)
+{
+    return icon->pixbuf == NULL;
+}
+
+static void
+pixbuf_toggle_notify (gpointer      info,
+                      GObject      *object,
+                      gboolean      is_last_ref)
+{
+    CajaIconInfo  *icon = info;
+
+    if (is_last_ref)
+    {
+        icon->sole_owner = TRUE;
+        g_object_remove_toggle_ref (object,
+                                    pixbuf_toggle_notify,
+                                    info);
+        icon->last_use_time = g_thread_gettime ();
+        schedule_reap_cache ();
+    }
+}
+
+static void
+caja_icon_info_finalize (GObject *object)
+{
+    CajaIconInfo *icon;
+
+    icon = CAJA_ICON_INFO (object);
+
+    if (!icon->sole_owner && icon->pixbuf)
+    {
+        g_object_remove_toggle_ref (G_OBJECT (icon->pixbuf),
+                                    pixbuf_toggle_notify,
+                                    icon);
+    }
+
+    if (icon->pixbuf)
+    {
+        g_object_unref (icon->pixbuf);
+    }
+    g_free (icon->attach_points);
+    g_free (icon->display_name);
+    g_free (icon->icon_name);
+
+    G_OBJECT_CLASS (caja_icon_info_parent_class)->finalize (object);
+}
+
+static void
+caja_icon_info_class_init (CajaIconInfoClass *icon_info_class)
+{
+    GObjectClass *gobject_class;
+
+    gobject_class = (GObjectClass *) icon_info_class;
+
+    gobject_class->finalize = caja_icon_info_finalize;
+
+}
+
+CajaIconInfo *
+caja_icon_info_new_for_pixbuf (GdkPixbuf *pixbuf)
+{
+    CajaIconInfo *icon;
+
+    icon = g_object_new (CAJA_TYPE_ICON_INFO, NULL);
+
+    if (pixbuf)
+    {
+        icon->pixbuf = g_object_ref (pixbuf);
+    }
+
+    return icon;
+}
+
+static CajaIconInfo *
+caja_icon_info_new_for_icon_info (GtkIconInfo *icon_info)
+{
+    CajaIconInfo *icon;
+    GdkPoint *points;
+    gint n_points;
+    const char *filename;
+    char *basename, *p;
+
+    icon = g_object_new (CAJA_TYPE_ICON_INFO, NULL);
+
+    icon->pixbuf = gtk_icon_info_load_icon (icon_info, NULL);
+
+    icon->got_embedded_rect = gtk_icon_info_get_embedded_rect (icon_info,
+                              &icon->embedded_rect);
+
+    if (gtk_icon_info_get_attach_points (icon_info, &points, &n_points))
+    {
+        icon->n_attach_points = n_points;
+        icon->attach_points = points;
+    }
+
+    icon->display_name = g_strdup (gtk_icon_info_get_display_name (icon_info));
+
+    filename = gtk_icon_info_get_filename (icon_info);
+    if (filename != NULL)
+    {
+        basename = g_path_get_basename (filename);
+        p = strrchr (basename, '.');
+        if (p)
+        {
+            *p = 0;
+        }
+        icon->icon_name = basename;
+    }
+
+    return icon;
+}
+
+
+typedef struct
+{
+    GIcon *icon;
+    int size;
+} LoadableIconKey;
+
+typedef struct
+{
+    char *filename;
+    int size;
+} ThemedIconKey;
+
+static GHashTable *loadable_icon_cache = NULL;
+static GHashTable *themed_icon_cache = NULL;
+static guint reap_cache_timeout = 0;
+
+#define NSEC_PER_SEC ((guint64)1000000000L)
+
+static guint time_now;
+
+static gboolean
+reap_old_icon (gpointer  key,
+               gpointer  value,
+               gpointer  user_info)
+{
+    CajaIconInfo *icon = value;
+    gboolean *reapable_icons_left = user_info;
+
+    if (icon->sole_owner)
+    {
+        if (time_now - icon->last_use_time > 30 * NSEC_PER_SEC)
+        {
+            /* This went unused 30 secs ago. reap */
+            return TRUE;
+        }
+        else
+        {
+            /* We can reap this soon */
+            *reapable_icons_left = TRUE;
+        }
+    }
+
+    return FALSE;
+}
+
+static gboolean
+reap_cache (gpointer data)
+{
+    gboolean reapable_icons_left;
+
+    reapable_icons_left = TRUE;
+
+    time_now = g_thread_gettime ();
+
+    if (loadable_icon_cache)
+    {
+        g_hash_table_foreach_remove (loadable_icon_cache,
+                                     reap_old_icon,
+                                     &reapable_icons_left);
+    }
+
+    if (themed_icon_cache)
+    {
+        g_hash_table_foreach_remove (themed_icon_cache,
+                                     reap_old_icon,
+                                     &reapable_icons_left);
+    }
+
+    if (reapable_icons_left)
+    {
+        return TRUE;
+    }
+    else
+    {
+        reap_cache_timeout = 0;
+        return FALSE;
+    }
+}
+
+static void
+schedule_reap_cache (void)
+{
+    if (reap_cache_timeout == 0)
+    {
+        reap_cache_timeout = g_timeout_add_seconds_full (0, 5,
+                             reap_cache,
+                             NULL, NULL);
+    }
+}
+
+void
+caja_icon_info_clear_caches (void)
+{
+    if (loadable_icon_cache)
+    {
+        g_hash_table_remove_all (loadable_icon_cache);
+    }
+
+    if (themed_icon_cache)
+    {
+        g_hash_table_remove_all (themed_icon_cache);
+    }
+}
+
+static guint
+loadable_icon_key_hash (LoadableIconKey *key)
+{
+    return g_icon_hash (key->icon) ^ key->size;
+}
+
+static gboolean
+loadable_icon_key_equal (const LoadableIconKey *a,
+                         const LoadableIconKey *b)
+{
+    return a->size == b->size &&
+           g_icon_equal (a->icon, b->icon);
+}
+
+static LoadableIconKey *
+loadable_icon_key_new (GIcon *icon, int size)
+{
+    LoadableIconKey *key;
+
+    key = g_slice_new (LoadableIconKey);
+    key->icon = g_object_ref (icon);
+    key->size = size;
+
+    return key;
+}
+
+static void
+loadable_icon_key_free (LoadableIconKey *key)
+{
+    g_object_unref (key->icon);
+    g_slice_free (LoadableIconKey, key);
+}
+
+static guint
+themed_icon_key_hash (ThemedIconKey *key)
+{
+    return g_str_hash (key->filename) ^ key->size;
+}
+
+static gboolean
+themed_icon_key_equal (const ThemedIconKey *a,
+                       const ThemedIconKey *b)
+{
+    return a->size == b->size &&
+           g_str_equal (a->filename, b->filename);
+}
+
+static ThemedIconKey *
+themed_icon_key_new (const char *filename, int size)
+{
+    ThemedIconKey *key;
+
+    key = g_slice_new (ThemedIconKey);
+    key->filename = g_strdup (filename);
+    key->size = size;
+
+    return key;
+}
+
+static void
+themed_icon_key_free (ThemedIconKey *key)
+{
+    g_free (key->filename);
+    g_slice_free (ThemedIconKey, key);
+}
+
+CajaIconInfo *
+caja_icon_info_lookup (GIcon *icon,
+                       int size)
+{
+    CajaIconInfo *icon_info;
+    GdkPixbuf *pixbuf;
+
+    if (G_IS_LOADABLE_ICON (icon))
+    {
+        LoadableIconKey lookup_key;
+        LoadableIconKey *key;
+        GInputStream *stream;
+
+        if (loadable_icon_cache == NULL)
+        {
+            loadable_icon_cache =
+                g_hash_table_new_full ((GHashFunc)loadable_icon_key_hash,
+                                       (GEqualFunc)loadable_icon_key_equal,
+                                       (GDestroyNotify) loadable_icon_key_free,
+                                       (GDestroyNotify) g_object_unref);
+        }
+
+        lookup_key.icon = icon;
+        lookup_key.size = size;
+
+        icon_info = g_hash_table_lookup (loadable_icon_cache, &lookup_key);
+        if (icon_info)
+        {
+            return g_object_ref (icon_info);
+        }
+
+        pixbuf = NULL;
+        stream = g_loadable_icon_load (G_LOADABLE_ICON (icon),
+                                       size,
+                                       NULL, NULL, NULL);
+        if (stream)
+        {
+            pixbuf = eel_gdk_pixbuf_load_from_stream_at_size (stream, size);
+            g_object_unref (stream);
+        }
+
+        icon_info = caja_icon_info_new_for_pixbuf (pixbuf);
+
+        key = loadable_icon_key_new (icon, size);
+        g_hash_table_insert (loadable_icon_cache, key, icon_info);
+
+        return g_object_ref (icon_info);
+    }
+    else if (G_IS_THEMED_ICON (icon))
+    {
+        const char * const *names;
+        ThemedIconKey lookup_key;
+        ThemedIconKey *key;
+        GtkIconTheme *icon_theme;
+        GtkIconInfo *gtkicon_info;
+        const char *filename;
+
+        if (themed_icon_cache == NULL)
+        {
+            themed_icon_cache =
+                g_hash_table_new_full ((GHashFunc)themed_icon_key_hash,
+                                       (GEqualFunc)themed_icon_key_equal,
+                                       (GDestroyNotify) themed_icon_key_free,
+                                       (GDestroyNotify) g_object_unref);
+        }
+
+        names = g_themed_icon_get_names (G_THEMED_ICON (icon));
+
+        icon_theme = gtk_icon_theme_get_default ();
+        gtkicon_info = gtk_icon_theme_choose_icon (icon_theme, (const char **)names, size, 0);
+
+        if (gtkicon_info == NULL)
+        {
+            return caja_icon_info_new_for_pixbuf (NULL);
+        }
+
+        filename = gtk_icon_info_get_filename (gtkicon_info);
+
+        lookup_key.filename = (char *)filename;
+        lookup_key.size = size;
+
+        icon_info = g_hash_table_lookup (themed_icon_cache, &lookup_key);
+        if (icon_info)
+        {
+            gtk_icon_info_free (gtkicon_info);
+            return g_object_ref (icon_info);
+        }
+
+        icon_info = caja_icon_info_new_for_icon_info (gtkicon_info);
+
+        key = themed_icon_key_new (filename, size);
+        g_hash_table_insert (themed_icon_cache, key, icon_info);
+
+        gtk_icon_info_free (gtkicon_info);
+
+        return g_object_ref (icon_info);
+    }
+    else
+    {
+        GdkPixbuf *pixbuf;
+        GtkIconInfo *gtk_icon_info;
+
+        gtk_icon_info = gtk_icon_theme_lookup_by_gicon (gtk_icon_theme_get_default (),
+                        icon,
+                        size,
+                        GTK_ICON_LOOKUP_GENERIC_FALLBACK);
+        if (gtk_icon_info != NULL)
+        {
+            pixbuf = gtk_icon_info_load_icon (gtk_icon_info, NULL);
+            gtk_icon_info_free (gtk_icon_info);
+        }
+        else
+        {
+            pixbuf = NULL;
+        }
+
+        return caja_icon_info_new_for_pixbuf (pixbuf);
+    }
+}
+
+CajaIconInfo *
+caja_icon_info_lookup_from_name (const char *name,
+                                 int size)
+{
+    GIcon *icon;
+    CajaIconInfo *info;
+
+    icon = g_themed_icon_new (name);
+    info = caja_icon_info_lookup (icon, size);
+    g_object_unref (icon);
+    return info;
+}
+
+CajaIconInfo *
+caja_icon_info_lookup_from_path (const char *path,
+                                 int size)
+{
+    GFile *icon_file;
+    GIcon *icon;
+    CajaIconInfo *info;
+
+    icon_file = g_file_new_for_path (path);
+    icon = g_file_icon_new (icon_file);
+    info = caja_icon_info_lookup (icon, size);
+    g_object_unref (icon);
+    g_object_unref (icon_file);
+    return info;
+}
+
+GdkPixbuf *
+caja_icon_info_get_pixbuf_nodefault (CajaIconInfo  *icon)
+{
+    GdkPixbuf *res;
+
+    if (icon->pixbuf == NULL)
+    {
+        res = NULL;
+    }
+    else
+    {
+        res = g_object_ref (icon->pixbuf);
+
+        if (icon->sole_owner)
+        {
+            icon->sole_owner = FALSE;
+            g_object_add_toggle_ref (G_OBJECT (res),
+                                     pixbuf_toggle_notify,
+                                     icon);
+        }
+    }
+
+    return res;
+}
+
+
+GdkPixbuf *
+caja_icon_info_get_pixbuf (CajaIconInfo *icon)
+{
+    GdkPixbuf *res;
+
+    res = caja_icon_info_get_pixbuf_nodefault (icon);
+    if (res == NULL)
+    {
+        res = gdk_pixbuf_new_from_data (caja_default_file_icon,
+                                        GDK_COLORSPACE_RGB,
+                                        TRUE,
+                                        8,
+                                        caja_default_file_icon_width,
+                                        caja_default_file_icon_height,
+                                        caja_default_file_icon_width * 4, /* stride */
+                                        NULL, /* don't destroy info */
+                                        NULL);
+    }
+
+    return res;
+}
+
+GdkPixbuf *
+caja_icon_info_get_pixbuf_nodefault_at_size (CajaIconInfo  *icon,
+        gsize              forced_size)
+{
+    GdkPixbuf *pixbuf, *scaled_pixbuf;
+    int w, h, s;
+    double scale;
+
+    pixbuf = caja_icon_info_get_pixbuf_nodefault (icon);
+
+    if (pixbuf == NULL)
+        return NULL;
+
+    w = gdk_pixbuf_get_width (pixbuf);
+    h = gdk_pixbuf_get_height (pixbuf);
+    s = MAX (w, h);
+    if (s == forced_size)
+    {
+        return pixbuf;
+    }
+
+    scale = (double)forced_size / s;
+    scaled_pixbuf = gdk_pixbuf_scale_simple (pixbuf,
+                    w * scale, h * scale,
+                    GDK_INTERP_BILINEAR);
+    g_object_unref (pixbuf);
+    return scaled_pixbuf;
+}
+
+
+GdkPixbuf *
+caja_icon_info_get_pixbuf_at_size (CajaIconInfo  *icon,
+                                   gsize              forced_size)
+{
+    GdkPixbuf *pixbuf, *scaled_pixbuf;
+    int w, h, s;
+    double scale;
+
+    pixbuf = caja_icon_info_get_pixbuf (icon);
+
+    w = gdk_pixbuf_get_width (pixbuf);
+    h = gdk_pixbuf_get_height (pixbuf);
+    s = MAX (w, h);
+    if (s == forced_size)
+    {
+        return pixbuf;
+    }
+
+    scale = (double)forced_size / s;
+    scaled_pixbuf = gdk_pixbuf_scale_simple (pixbuf,
+                    w * scale, h * scale,
+                    GDK_INTERP_BILINEAR);
+    g_object_unref (pixbuf);
+    return scaled_pixbuf;
+}
+
+gboolean
+caja_icon_info_get_embedded_rect (CajaIconInfo  *icon,
+                                  GdkRectangle      *rectangle)
+{
+    *rectangle = icon->embedded_rect;
+    return icon->got_embedded_rect;
+}
+
+gboolean
+caja_icon_info_get_attach_points (CajaIconInfo  *icon,
+                                  GdkPoint         **points,
+                                  gint              *n_points)
+{
+    *n_points = icon->n_attach_points;
+    *points = icon->attach_points;
+    return icon->n_attach_points != 0;
+}
+
+const char* caja_icon_info_get_display_name(CajaIconInfo* icon)
+{
+    return icon->display_name;
+}
+
+const char* caja_icon_info_get_used_name(CajaIconInfo* icon)
+{
+    return icon->icon_name;
+}
+
+/* Return nominal icon size for given zoom level.
+ * @zoom_level: zoom level for which to find matching icon size.
+ *
+ * Return value: icon size between CAJA_ICON_SIZE_SMALLEST and
+ * CAJA_ICON_SIZE_LARGEST, inclusive.
+ */
+guint
+caja_get_icon_size_for_zoom_level (CajaZoomLevel zoom_level)
+{
+    switch (zoom_level)
+    {
+    case CAJA_ZOOM_LEVEL_SMALLEST:
+        return CAJA_ICON_SIZE_SMALLEST;
+    case CAJA_ZOOM_LEVEL_SMALLER:
+        return CAJA_ICON_SIZE_SMALLER;
+    case CAJA_ZOOM_LEVEL_SMALL:
+        return CAJA_ICON_SIZE_SMALL;
+    case CAJA_ZOOM_LEVEL_STANDARD:
+        return CAJA_ICON_SIZE_STANDARD;
+    case CAJA_ZOOM_LEVEL_LARGE:
+        return CAJA_ICON_SIZE_LARGE;
+    case CAJA_ZOOM_LEVEL_LARGER:
+        return CAJA_ICON_SIZE_LARGER;
+    case CAJA_ZOOM_LEVEL_LARGEST:
+        return CAJA_ICON_SIZE_LARGEST;
+    }
+    g_return_val_if_reached (CAJA_ICON_SIZE_STANDARD);
+}
+
+float
+caja_get_relative_icon_size_for_zoom_level (CajaZoomLevel zoom_level)
+{
+    return (float)caja_get_icon_size_for_zoom_level (zoom_level) / CAJA_ICON_SIZE_STANDARD;
+}
+
+guint
+caja_icon_get_larger_icon_size (guint size)
+{
+    if (size < CAJA_ICON_SIZE_SMALLEST)
+    {
+        return CAJA_ICON_SIZE_SMALLEST;
+    }
+    if (size < CAJA_ICON_SIZE_SMALLER)
+    {
+        return CAJA_ICON_SIZE_SMALLER;
+    }
+    if (size < CAJA_ICON_SIZE_SMALL)
+    {
+        return CAJA_ICON_SIZE_SMALL;
+    }
+    if (size < CAJA_ICON_SIZE_STANDARD)
+    {
+        return CAJA_ICON_SIZE_STANDARD;
+    }
+    if (size < CAJA_ICON_SIZE_LARGE)
+    {
+        return CAJA_ICON_SIZE_LARGE;
+    }
+    if (size < CAJA_ICON_SIZE_LARGER)
+    {
+        return CAJA_ICON_SIZE_LARGER;
+    }
+    return CAJA_ICON_SIZE_LARGEST;
+}
+
+guint
+caja_icon_get_smaller_icon_size (guint size)
+{
+    if (size > CAJA_ICON_SIZE_LARGEST)
+    {
+        return CAJA_ICON_SIZE_LARGEST;
+    }
+    if (size > CAJA_ICON_SIZE_LARGER)
+    {
+        return CAJA_ICON_SIZE_LARGER;
+    }
+    if (size > CAJA_ICON_SIZE_LARGE)
+    {
+        return CAJA_ICON_SIZE_LARGE;
+    }
+    if (size > CAJA_ICON_SIZE_STANDARD)
+    {
+        return CAJA_ICON_SIZE_STANDARD;
+    }
+    if (size > CAJA_ICON_SIZE_SMALL)
+    {
+        return CAJA_ICON_SIZE_SMALL;
+    }
+    if (size > CAJA_ICON_SIZE_SMALLER)
+    {
+        return CAJA_ICON_SIZE_SMALLER;
+    }
+    return CAJA_ICON_SIZE_SMALLEST;
+}
+
+gint
+caja_get_icon_size_for_stock_size (GtkIconSize size)
+{
+    gint w, h;
+
+    if (gtk_icon_size_lookup (size, &w, &h))
+    {
+        return MAX (w, h);
+    }
+    return CAJA_ZOOM_LEVEL_STANDARD;
+}
+
+
+guint
+caja_icon_get_emblem_size_for_icon_size (guint size)
+{
+    if (size >= 96)
+        return 48;
+    if (size >= 64)
+        return 32;
+    if (size >= 48)
+        return 24;
+    if (size >= 24)
+        return 16;
+    if (size >= 16)
+        return 12;
+
+    return 0; /* no emblems for smaller sizes */
+}