← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gimp/jaunty-security

« back to all changes in this revision

Viewing changes to app/widgets/gimpviewrendererimagefile.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2008-10-06 13:30:41 UTC
  • mto: This revision was merged to the branch mainline in revision 35.
  • Revision ID: james.westby@ubuntu.com-20081006133041-3panbkcanaymfsmp
Tags: upstream-2.6.0
Import upstream version 2.6.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
app/widgets/gimpviewrendererimagefile.c
35
35
#include "gimpviewrendererimagefile.h"
36
36
#include "gimpviewrenderer-frame.h"
37
37
 
38
 
#ifdef ENABLE_FILE_SYSTEM_ICONS
39
 
#define GTK_FILE_SYSTEM_ENABLE_UNSUPPORTED
40
 
#include <gtk/gtkfilesystem.h>
41
 
#endif
42
 
 
43
 
 
44
 
static void   gimp_view_renderer_imagefile_render (GimpViewRenderer *renderer,
45
 
                                                   GtkWidget        *widget);
 
38
 
 
39
static void        gimp_view_renderer_imagefile_render   (GimpViewRenderer *renderer,
 
40
                                                          GtkWidget        *widget);
 
41
 
 
42
static GdkPixbuf * gimp_view_renderer_imagefile_get_icon (GimpImagefile    *imagefile,
 
43
                                                          GtkWidget        *widget,
 
44
                                                          gint              size);
46
45
 
47
46
 
48
47
G_DEFINE_TYPE (GimpViewRendererImagefile, gimp_view_renderer_imagefile,
62
61
static void
63
62
gimp_view_renderer_imagefile_init (GimpViewRendererImagefile *renderer)
64
63
{
65
 
#ifdef ENABLE_FILE_SYSTEM_ICONS
66
 
  renderer->file_system = NULL;
67
 
#endif
68
64
}
69
65
 
70
66
static void
75
71
                                                           renderer->width,
76
72
                                                           renderer->height);
77
73
 
78
 
#ifdef ENABLE_FILE_SYSTEM_ICONS
79
 
  if (! pixbuf &&
80
 
      GIMP_VIEW_RENDERER_IMAGEFILE (renderer)->file_system)
 
74
  if (! pixbuf)
81
75
    {
82
 
      const gchar *uri;
83
 
 
84
 
      uri = gimp_object_get_name (GIMP_OBJECT (renderer->viewable));
85
 
      if (uri)
86
 
        {
87
 
          GtkFileSystem *file_system;
88
 
          GtkFilePath   *path;
89
 
 
90
 
          file_system = GIMP_VIEW_RENDERER_IMAGEFILE (renderer)->file_system;
91
 
 
92
 
          path = gtk_file_system_uri_to_path (file_system, uri);
93
 
 
94
 
          pixbuf = gtk_file_system_render_icon (file_system, path, widget,
95
 
                                                MIN (renderer->width,
96
 
                                                     renderer->height),
97
 
                                                NULL);
98
 
          gtk_file_path_free (path);
99
 
        }
 
76
      GimpImagefile *imagefile = GIMP_IMAGEFILE (renderer->viewable);
 
77
 
 
78
      pixbuf = gimp_view_renderer_imagefile_get_icon (imagefile,
 
79
                                                      widget,
 
80
                                                      MIN (renderer->width,
 
81
                                                           renderer->height));
100
82
    }
101
 
#endif /* ENABLE_FILE_SYSTEM_ICONS */
102
83
 
103
84
  if (pixbuf)
104
85
    {
112
93
      gimp_view_renderer_default_render_stock (renderer, widget, stock_id);
113
94
    }
114
95
}
 
96
 
 
97
 
 
98
/* The code to get an icon for a mime-type is lifted from GtkRecentManager. */
 
99
 
 
100
static GdkPixbuf *
 
101
get_icon_for_mime_type (const char *mime_type,
 
102
                        gint        pixel_size)
 
103
{
 
104
  GtkIconTheme *icon_theme;
 
105
  const gchar  *separator;
 
106
  GString      *icon_name;
 
107
  GdkPixbuf    *pixbuf;
 
108
 
 
109
  separator = strchr (mime_type, '/');
 
110
  if (! separator)
 
111
    return NULL;
 
112
 
 
113
  icon_theme = gtk_icon_theme_get_default ();
 
114
 
 
115
  /* try with the three icon name variants for MIME types */
 
116
 
 
117
  /* canonicalize MIME type: foo/x-bar -> foo-x-bar */
 
118
  icon_name = g_string_new (NULL);
 
119
  g_string_append_len (icon_name, mime_type, separator - mime_type);
 
120
  g_string_append_c (icon_name, '-');
 
121
  g_string_append (icon_name, separator + 1);
 
122
  pixbuf = gtk_icon_theme_load_icon (icon_theme, icon_name->str,
 
123
                                     pixel_size,
 
124
                                     0,
 
125
                                     NULL);
 
126
  g_string_free (icon_name, TRUE);
 
127
  if (pixbuf)
 
128
    return pixbuf;
 
129
 
 
130
  /* canonicalize MIME type, and prepend "gnome-mime-" */
 
131
  icon_name = g_string_new ("gnome-mime-");
 
132
  g_string_append_len (icon_name, mime_type, separator - mime_type);
 
133
  g_string_append_c (icon_name, '-');
 
134
  g_string_append (icon_name, separator + 1);
 
135
  pixbuf = gtk_icon_theme_load_icon (icon_theme, icon_name->str,
 
136
                                     pixel_size,
 
137
                                     0,
 
138
                                     NULL);
 
139
  g_string_free (icon_name, TRUE);
 
140
  if (pixbuf)
 
141
    return pixbuf;
 
142
 
 
143
  /* try the MIME family icon */
 
144
  icon_name = g_string_new ("gnome-mime-");
 
145
  g_string_append_len (icon_name, mime_type, separator - mime_type);
 
146
  pixbuf = gtk_icon_theme_load_icon (icon_theme, icon_name->str,
 
147
                                     pixel_size,
 
148
                                     0,
 
149
                                     NULL);
 
150
  g_string_free (icon_name, TRUE);
 
151
 
 
152
  return pixbuf;
 
153
}
 
154
 
 
155
static GdkPixbuf *
 
156
gimp_view_renderer_imagefile_get_icon (GimpImagefile *imagefile,
 
157
                                       GtkWidget     *widget,
 
158
                                       gint           size)
 
159
{
 
160
  GdkScreen    *screen     = gtk_widget_get_screen (widget);
 
161
  GtkIconTheme *icon_theme = gtk_icon_theme_get_for_screen (screen);
 
162
  GdkPixbuf    *pixbuf     = NULL;
 
163
 
 
164
  if (! gimp_object_get_name (GIMP_OBJECT (imagefile)))
 
165
    return NULL;
 
166
 
 
167
#if GTK_CHECK_VERSION (2, 13, 4)
 
168
  if (! pixbuf)
 
169
    {
 
170
      GFile       *file;
 
171
      GFileInfo   *file_info;
 
172
      GtkIconInfo *info;
 
173
 
 
174
      file = g_file_new_for_uri (gimp_object_get_name (GIMP_OBJECT (imagefile)));
 
175
      file_info = g_file_query_info (file, "standard::icon", 0, NULL, NULL);
 
176
 
 
177
      if (file_info)
 
178
        {
 
179
          GIcon *icon;
 
180
 
 
181
          icon = g_file_info_get_icon (file_info);
 
182
 
 
183
          info = gtk_icon_theme_lookup_by_gicon (icon_theme, icon, size, 0);
 
184
          pixbuf = gtk_icon_info_load_icon (info, NULL);
 
185
 
 
186
          g_object_unref (file_info);
 
187
        }
 
188
 
 
189
      g_object_unref (file);
 
190
    }
 
191
#endif
 
192
 
 
193
  if (! pixbuf && imagefile->thumbnail->image_mimetype)
 
194
    {
 
195
      pixbuf = get_icon_for_mime_type (imagefile->thumbnail->image_mimetype,
 
196
                                       size);
 
197
    }
 
198
 
 
199
  if (! pixbuf)
 
200
    {
 
201
      const gchar *icon_name = GTK_STOCK_FILE;
 
202
 
 
203
      if (imagefile->thumbnail->image_state == GIMP_THUMB_STATE_FOLDER)
 
204
        icon_name = GTK_STOCK_DIRECTORY;
 
205
 
 
206
      pixbuf = gtk_icon_theme_load_icon (icon_theme,
 
207
                                         icon_name, size,
 
208
                                         GTK_ICON_LOOKUP_USE_BUILTIN,
 
209
                                         NULL);
 
210
    }
 
211
 
 
212
  return pixbuf;
 
213
}