]> www.fi.muni.cz Git - evince.git/blob - shell/ev-sidebar-attachments.c
Add a new job to get the attachments in a thread with the document lock
[evince.git] / shell / ev-sidebar-attachments.c
1 /* ev-sidebar-attachments.c
2  *  this file is part of evince, a gnome document viewer
3  *
4  * Copyright (C) 2006 Carlos Garcia Campos
5  *
6  * Author:
7  *   Carlos Garcia Campos <carlosgc@gnome.org>
8  *
9  * Evince is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * Evince is distributed in the hope that it will be useful, but
15  * WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
22  */
23
24 #ifdef HAVE_CONFIG_H
25 #include "config.h"
26 #endif
27
28 #include <string.h>
29
30 #include <glib/gi18n.h>
31 #include <glib/gstdio.h>
32 #include <gtk/gtk.h>
33
34 #include "ev-jobs.h"
35 #include "ev-job-scheduler.h"
36 #include "ev-file-helpers.h"
37 #include "ev-sidebar-attachments.h"
38 #include "ev-sidebar-page.h"
39
40 enum {
41         COLUMN_ICON,
42         COLUMN_NAME,
43         COLUMN_DESCRIPTION,
44         COLUMN_ATTACHMENT,
45         N_COLS
46 };
47
48 enum {
49         PROP_0,
50         PROP_WIDGET,
51 };
52
53 enum {
54         SIGNAL_POPUP_MENU,
55         N_SIGNALS
56 };
57
58 static const GtkTargetEntry drag_targets[] = {
59         { "text/uri-list", 0, 0 }
60 };
61
62 static guint signals[N_SIGNALS];
63
64 struct _EvSidebarAttachmentsPrivate {
65         GtkWidget      *icon_view;
66         GtkListStore   *model;
67
68         /* Icons */
69         GtkIconTheme   *icon_theme;
70         GHashTable     *icon_cache;
71 };
72
73 static void ev_sidebar_attachments_page_iface_init (EvSidebarPageIface *iface);
74
75 G_DEFINE_TYPE_EXTENDED (EvSidebarAttachments,
76                         ev_sidebar_attachments,
77                         GTK_TYPE_VBOX,
78                         0, 
79                         G_IMPLEMENT_INTERFACE (EV_TYPE_SIDEBAR_PAGE, 
80                                                ev_sidebar_attachments_page_iface_init))
81
82 #define EV_SIDEBAR_ATTACHMENTS_GET_PRIVATE(object) \
83                 (G_TYPE_INSTANCE_GET_PRIVATE ((object), EV_TYPE_SIDEBAR_ATTACHMENTS, EvSidebarAttachmentsPrivate))
84
85 /* Icon cache */
86 static void
87 ev_sidebar_attachments_icon_cache_add (EvSidebarAttachments *ev_attachbar,
88                                        const gchar          *mime_type,
89                                        const GdkPixbuf      *pixbuf)
90 {
91         g_assert (mime_type != NULL);
92         g_assert (GDK_IS_PIXBUF (pixbuf));
93
94         g_hash_table_insert (ev_attachbar->priv->icon_cache,
95                              (gpointer)g_strdup (mime_type),
96                              (gpointer)pixbuf);
97                              
98 }
99
100 static GdkPixbuf *
101 icon_theme_get_pixbuf_from_mime_type (GtkIconTheme *icon_theme,
102                                       const gchar  *mime_type)
103 {
104         const char *separator;
105         GString *icon_name;
106         GdkPixbuf *pixbuf;
107
108         separator = strchr (mime_type, '/');
109         if (!separator)
110                 return NULL; /* maybe we should return a GError with "invalid MIME-type" */
111
112         icon_name = g_string_new ("gnome-mime-");
113         g_string_append_len (icon_name, mime_type, separator - mime_type);
114         g_string_append_c (icon_name, '-');
115         g_string_append (icon_name, separator + 1);
116         pixbuf = gtk_icon_theme_load_icon (icon_theme, icon_name->str, 48, 0, NULL);
117         g_string_free (icon_name, TRUE);
118         if (pixbuf)
119                 return pixbuf;
120         
121         icon_name = g_string_new ("gnome-mime-");
122         g_string_append_len (icon_name, mime_type, separator - mime_type);
123         pixbuf = gtk_icon_theme_load_icon (icon_theme, icon_name->str, 48, 0, NULL);
124         g_string_free (icon_name, TRUE);
125         
126         return pixbuf;
127 }
128
129 static GdkPixbuf *
130 ev_sidebar_attachments_icon_cache_get (EvSidebarAttachments *ev_attachbar,
131                                        const gchar          *mime_type)
132 {
133         GdkPixbuf *pixbuf = NULL;
134         
135         g_assert (mime_type != NULL);
136
137         pixbuf = g_hash_table_lookup (ev_attachbar->priv->icon_cache,
138                                       mime_type);
139
140         if (GDK_IS_PIXBUF (pixbuf))
141                 return pixbuf;
142
143         pixbuf = icon_theme_get_pixbuf_from_mime_type (ev_attachbar->priv->icon_theme,
144                                                        mime_type);
145
146         if (GDK_IS_PIXBUF (pixbuf))
147                 ev_sidebar_attachments_icon_cache_add (ev_attachbar,
148                                                        mime_type,
149                                                        pixbuf);
150
151         return pixbuf;
152 }
153
154 static gboolean
155 icon_cache_update_icon (gchar                *key,
156                         GdkPixbuf            *value,
157                         EvSidebarAttachments *ev_attachbar)
158 {
159         GdkPixbuf *pixbuf = NULL;
160
161         pixbuf = icon_theme_get_pixbuf_from_mime_type (ev_attachbar->priv->icon_theme,
162                                                        key);
163
164         ev_sidebar_attachments_icon_cache_add (ev_attachbar,
165                                                key,
166                                                pixbuf);
167         
168         return FALSE;
169 }
170
171 static void
172 ev_sidebar_attachments_icon_cache_refresh (EvSidebarAttachments *ev_attachbar)
173 {
174         g_hash_table_foreach_remove (ev_attachbar->priv->icon_cache,
175                                      (GHRFunc) icon_cache_update_icon,
176                                      ev_attachbar);
177 }
178
179 static EvAttachment *
180 ev_sidebar_attachments_get_attachment_at_pos (EvSidebarAttachments *ev_attachbar,
181                                               gint                  x,
182                                               gint                  y)
183 {
184         GtkTreePath  *path = NULL;
185         GtkTreeIter   iter;
186         EvAttachment *attachment = NULL;
187
188         path = gtk_icon_view_get_path_at_pos (GTK_ICON_VIEW (ev_attachbar->priv->icon_view),
189                                               x, y);
190         if (!path) {
191                 return NULL;
192         }
193
194         gtk_tree_model_get_iter (GTK_TREE_MODEL (ev_attachbar->priv->model),
195                                  &iter, path);
196         gtk_tree_model_get (GTK_TREE_MODEL (ev_attachbar->priv->model), &iter,
197                             COLUMN_ATTACHMENT, &attachment,
198                             -1);
199
200         gtk_icon_view_select_path (GTK_ICON_VIEW (ev_attachbar->priv->icon_view),
201                                    path);
202         
203         gtk_tree_path_free (path);
204
205         return attachment;
206 }
207
208 static gboolean
209 ev_sidebar_attachments_popup_menu_show (EvSidebarAttachments *ev_attachbar,
210                                         gint                  x,
211                                         gint                  y)
212 {
213         GtkIconView *icon_view;
214         GtkTreePath *path;
215         GList       *selected = NULL, *l;
216         GList       *attach_list = NULL;
217
218         icon_view = GTK_ICON_VIEW (ev_attachbar->priv->icon_view);
219         
220         path = gtk_icon_view_get_path_at_pos (icon_view, x, y);
221         if (!path)
222                 return FALSE;
223
224         if (!gtk_icon_view_path_is_selected (icon_view, path)) {
225                 gtk_icon_view_unselect_all (icon_view);
226                 gtk_icon_view_select_path (icon_view, path);
227         }
228
229         gtk_tree_path_free (path);
230         
231         selected = gtk_icon_view_get_selected_items (icon_view);
232         if (!selected)
233                 return FALSE;
234
235         for (l = selected; l && l->data; l = g_list_next (l)) {
236                 GtkTreeIter   iter;
237                 EvAttachment *attachment = NULL;
238
239                 path = (GtkTreePath *) l->data;
240
241                 gtk_tree_model_get_iter (GTK_TREE_MODEL (ev_attachbar->priv->model),
242                                          &iter, path);
243                 gtk_tree_model_get (GTK_TREE_MODEL (ev_attachbar->priv->model), &iter,
244                                     COLUMN_ATTACHMENT, &attachment,
245                                     -1);
246
247                 if (attachment)
248                         attach_list = g_list_prepend (attach_list, attachment);
249
250                 gtk_tree_path_free (path);
251         }
252
253         g_list_free (selected);
254
255         if (!attach_list)
256                 return FALSE;
257
258         g_signal_emit (ev_attachbar, signals[SIGNAL_POPUP_MENU], 0, attach_list);
259
260         return TRUE;
261 }
262
263 static gboolean
264 ev_sidebar_attachments_popup_menu (GtkWidget *widget)
265 {
266         EvSidebarAttachments *ev_attachbar = EV_SIDEBAR_ATTACHMENTS (widget);
267         gint                  x, y;
268
269         gtk_widget_get_pointer (widget, &x, &y);
270
271         return ev_sidebar_attachments_popup_menu_show (ev_attachbar, x, y);
272 }
273
274 static gboolean
275 ev_sidebar_attachments_button_press (EvSidebarAttachments *ev_attachbar,
276                                      GdkEventButton       *event,
277                                      GtkWidget            *icon_view)
278 {
279         if (!GTK_WIDGET_HAS_FOCUS (icon_view)) {
280                 gtk_widget_grab_focus (icon_view);
281         }
282         
283         if (event->button == 2)
284                 return FALSE;
285
286         switch (event->button) {
287                 case 1:
288                         if (event->type == GDK_2BUTTON_PRESS) {
289                                 GError *error = NULL;
290                                 EvAttachment *attachment;
291                                 
292                                 attachment = ev_sidebar_attachments_get_attachment_at_pos (ev_attachbar,
293                                                                                            event->x,
294                                                                                            event->y);
295                                 if (!attachment)
296                                         return FALSE;
297                                 
298                                 ev_attachment_open (attachment, &error);
299                                 
300                                 if (error) {
301                                         g_warning ("%s", error->message);
302                                         g_error_free (error);
303                                 }
304                                 
305                                 g_object_unref (attachment);
306                                 
307                                 return TRUE;
308                         }
309                         break;
310                 case 3: 
311                         return ev_sidebar_attachments_popup_menu_show (ev_attachbar, event->x, event->y);
312         }
313
314         return FALSE;
315 }
316
317 static void
318 ev_sidebar_attachments_update_icons (EvSidebarAttachments *ev_attachbar,
319                                      gpointer              user_data)
320 {
321         GtkTreeIter iter;
322         gboolean    valid;
323
324         ev_sidebar_attachments_icon_cache_refresh (ev_attachbar);
325         
326         valid = gtk_tree_model_get_iter_first (
327                 GTK_TREE_MODEL (ev_attachbar->priv->model),
328                 &iter);
329
330         while (valid) {
331                 EvAttachment *attachment = NULL;
332                 GdkPixbuf    *pixbuf = NULL;
333                 const gchar  *mime_type;
334
335                 gtk_tree_model_get (GTK_TREE_MODEL (ev_attachbar->priv->model), &iter,
336                                     COLUMN_ATTACHMENT, &attachment,
337                                     -1);
338
339                 mime_type = ev_attachment_get_mime_type (attachment);
340
341                 if (attachment)
342                         g_object_unref (attachment);
343
344                 pixbuf = ev_sidebar_attachments_icon_cache_get (ev_attachbar,
345                                                                 mime_type);
346
347                 gtk_list_store_set (ev_attachbar->priv->model, &iter,
348                                     COLUMN_ICON, pixbuf,
349                                     -1);
350
351                 valid = gtk_tree_model_iter_next (
352                         GTK_TREE_MODEL (ev_attachbar->priv->model),
353                         &iter);
354         }
355 }
356
357 static void
358 ev_sidebar_attachments_screen_changed (GtkWidget *widget,
359                                        GdkScreen *old_screen)
360 {
361         EvSidebarAttachments *ev_attachbar = EV_SIDEBAR_ATTACHMENTS (widget);
362         GdkScreen            *screen;
363
364         if (!ev_attachbar->priv->icon_theme)
365                 return;
366         
367         screen = gtk_widget_get_screen (widget);
368         if (screen == old_screen)
369                 return;
370
371         if (old_screen) {
372                 g_signal_handlers_disconnect_by_func (
373                         gtk_icon_theme_get_for_screen (old_screen),
374                         G_CALLBACK (ev_sidebar_attachments_update_icons),
375                         ev_attachbar);
376         }
377
378         ev_attachbar->priv->icon_theme = gtk_icon_theme_get_for_screen (screen);
379         g_signal_connect_swapped (ev_attachbar->priv->icon_theme,
380                                   "changed",
381                                   G_CALLBACK (ev_sidebar_attachments_update_icons),
382                                   (gpointer) ev_attachbar);
383
384         if (GTK_WIDGET_CLASS (ev_sidebar_attachments_parent_class)->screen_changed) {
385                 GTK_WIDGET_CLASS (ev_sidebar_attachments_parent_class)->screen_changed (widget, old_screen);
386         }
387 }
388
389 static void
390 ev_sidebar_attachments_drag_data_get (GtkWidget        *widget,
391                                       GdkDragContext   *drag_context,
392                                       GtkSelectionData *data,
393                                       guint             info,
394                                       guint             time,
395                                       gpointer          user_data)
396 {
397         EvSidebarAttachments *ev_attachbar = EV_SIDEBAR_ATTACHMENTS (user_data);
398         GString              *uri_list;
399         gchar                *uris = NULL;
400         GList                *selected = NULL, *l;
401
402         selected = gtk_icon_view_get_selected_items (GTK_ICON_VIEW (ev_attachbar->priv->icon_view));
403         if (!selected)
404                 return;
405
406         uri_list = g_string_new (NULL);
407         
408         for (l = selected; l && l->data; l = g_list_next (l)) {
409                 EvAttachment *attachment;
410                 GtkTreePath  *path;
411                 GtkTreeIter   iter;
412                 GFile        *file;
413                 gchar        *filename;
414                 GError       *error = NULL;
415                 
416                 path = (GtkTreePath *) l->data;
417
418                 gtk_tree_model_get_iter (GTK_TREE_MODEL (ev_attachbar->priv->model),
419                                          &iter, path);
420                 gtk_tree_model_get (GTK_TREE_MODEL (ev_attachbar->priv->model), &iter,
421                                     COLUMN_ATTACHMENT, &attachment,
422                                     -1);
423
424                 filename = g_build_filename (ev_tmp_dir (),
425                                              ev_attachment_get_name (attachment),
426                                              NULL);
427                 file = g_file_new_for_path (filename);
428                 g_free (filename);
429                 
430                 if (ev_attachment_save (attachment, file, &error)) {
431                         gchar *uri;
432
433                         uri = g_file_get_uri (file);
434                         g_string_append (uri_list, uri);
435                         g_string_append_c (uri_list, '\n');
436                         g_free (uri);
437                 }
438         
439                 if (error) {
440                         g_warning ("%s", error->message);
441                         g_error_free (error);
442                 }
443
444                 gtk_tree_path_free (path);
445                 g_object_unref (file);
446                 g_object_unref (attachment);
447         }
448
449         uris = g_string_free (uri_list, FALSE);
450
451         if (uris) {
452                 gtk_selection_data_set (data,
453                                         data->target,
454                                         8,
455                                         (guchar *)uris,
456                                         strlen (uris));
457         }
458
459         g_list_free (selected);
460 }
461
462 static void
463 ev_sidebar_attachments_get_property (GObject    *object,
464                                      guint       prop_id,
465                                      GValue     *value,
466                                      GParamSpec *pspec)
467 {
468         EvSidebarAttachments *ev_sidebar_attachments;
469   
470         ev_sidebar_attachments = EV_SIDEBAR_ATTACHMENTS (object);
471
472         switch (prop_id) {
473                 case PROP_WIDGET:
474                         g_value_set_object (value, ev_sidebar_attachments->priv->icon_view);
475                         break;
476                 default:
477                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
478                         break;
479         }
480 }
481
482 static void
483 ev_sidebar_attachments_destroy (GtkObject *object)
484 {
485         EvSidebarAttachments *ev_attachbar = EV_SIDEBAR_ATTACHMENTS (object);
486
487         if (ev_attachbar->priv->icon_theme) {
488                 g_signal_handlers_disconnect_by_func (
489                         ev_attachbar->priv->icon_theme, 
490                         G_CALLBACK (ev_sidebar_attachments_update_icons),
491                         ev_attachbar);
492                 ev_attachbar->priv->icon_theme = NULL;
493         }
494         
495         if (ev_attachbar->priv->model) {
496                 g_object_unref (ev_attachbar->priv->model);
497                 ev_attachbar->priv->model = NULL;
498         }
499
500         if (ev_attachbar->priv->icon_cache) {
501                 g_hash_table_destroy (ev_attachbar->priv->icon_cache);
502                 ev_attachbar->priv->icon_cache = NULL;
503         }
504
505         (* GTK_OBJECT_CLASS (ev_sidebar_attachments_parent_class)->destroy) (object);
506 }
507
508 static void
509 ev_sidebar_attachments_class_init (EvSidebarAttachmentsClass *ev_attachbar_class)
510 {
511         GObjectClass   *g_object_class;
512         GtkObjectClass *gtk_object_class;
513         GtkWidgetClass *gtk_widget_class;
514
515         g_object_class = G_OBJECT_CLASS (ev_attachbar_class);
516         gtk_object_class = GTK_OBJECT_CLASS (ev_attachbar_class);
517         gtk_widget_class = GTK_WIDGET_CLASS (ev_attachbar_class);
518
519         g_object_class->get_property = ev_sidebar_attachments_get_property;
520         gtk_object_class->destroy = ev_sidebar_attachments_destroy;
521         gtk_widget_class->popup_menu = ev_sidebar_attachments_popup_menu;
522         gtk_widget_class->screen_changed = ev_sidebar_attachments_screen_changed;
523
524         g_type_class_add_private (g_object_class, sizeof (EvSidebarAttachmentsPrivate));
525
526         /* Signals */
527         signals[SIGNAL_POPUP_MENU] =
528                 g_signal_new ("popup",
529                               G_TYPE_FROM_CLASS (g_object_class),
530                               G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
531                               G_STRUCT_OFFSET (EvSidebarAttachmentsClass, popup_menu),
532                               NULL, NULL,
533                               g_cclosure_marshal_VOID__POINTER,
534                               G_TYPE_NONE, 1,
535                               G_TYPE_POINTER);
536
537         g_object_class_override_property (g_object_class,
538                                           PROP_WIDGET,
539                                           "main-widget");
540 }
541
542 static void
543 ev_sidebar_attachments_init (EvSidebarAttachments *ev_attachbar)
544 {
545         GtkWidget *swindow;
546         
547         ev_attachbar->priv = EV_SIDEBAR_ATTACHMENTS_GET_PRIVATE (ev_attachbar);
548
549         swindow = gtk_scrolled_window_new (NULL, NULL);
550         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
551                                         GTK_POLICY_NEVER,
552                                         GTK_POLICY_AUTOMATIC);
553         gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swindow),
554                                              GTK_SHADOW_IN);
555         /* Data Model */
556         ev_attachbar->priv->model = gtk_list_store_new (N_COLS,
557                                                         GDK_TYPE_PIXBUF, 
558                                                         G_TYPE_STRING,  
559                                                         G_TYPE_STRING,
560                                                         EV_TYPE_ATTACHMENT);
561
562         /* Icon View */
563         ev_attachbar->priv->icon_view =
564                 gtk_icon_view_new_with_model (GTK_TREE_MODEL (ev_attachbar->priv->model));
565         gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (ev_attachbar->priv->icon_view),
566                                           GTK_SELECTION_MULTIPLE);
567         gtk_icon_view_set_columns (GTK_ICON_VIEW (ev_attachbar->priv->icon_view), -1);
568         g_object_set (G_OBJECT (ev_attachbar->priv->icon_view),
569                       "text-column", COLUMN_NAME,
570                       "pixbuf-column", COLUMN_ICON,
571                       NULL);
572         g_signal_connect_swapped (G_OBJECT (ev_attachbar->priv->icon_view),
573                                   "button-press-event",
574                                   G_CALLBACK (ev_sidebar_attachments_button_press),
575                                   (gpointer) ev_attachbar);
576
577         gtk_container_add (GTK_CONTAINER (swindow),
578                            ev_attachbar->priv->icon_view);
579
580         gtk_container_add (GTK_CONTAINER (ev_attachbar),
581                            swindow);
582         gtk_widget_show_all (GTK_WIDGET (ev_attachbar));
583
584         /* Icon Theme */
585         ev_attachbar->priv->icon_theme = NULL;
586
587         /* Icon Cache */
588         ev_attachbar->priv->icon_cache = g_hash_table_new_full (g_str_hash,
589                                                                 g_str_equal,
590                                                                 g_free,
591                                                                 g_object_unref);
592
593         /* Drag and Drop */
594         gtk_icon_view_enable_model_drag_source (
595                 GTK_ICON_VIEW (ev_attachbar->priv->icon_view),
596                 GDK_BUTTON1_MASK,
597                 drag_targets,
598                 G_N_ELEMENTS (drag_targets),
599                 GDK_ACTION_COPY);
600
601         g_signal_connect (G_OBJECT (ev_attachbar->priv->icon_view),
602                           "drag-data-get",
603                           G_CALLBACK (ev_sidebar_attachments_drag_data_get),
604                           (gpointer) ev_attachbar);     
605 }
606
607 GtkWidget *
608 ev_sidebar_attachments_new (void)
609 {
610         GtkWidget *ev_attachbar;
611
612         ev_attachbar = g_object_new (EV_TYPE_SIDEBAR_ATTACHMENTS, NULL);
613
614         return ev_attachbar;
615 }
616
617 static void
618 job_finished_callback (EvJobAttachments     *job,
619                        EvSidebarAttachments *ev_attachbar)
620 {
621         GList *l;
622         
623         for (l = job->attachments; l && l->data; l = g_list_next (l)) {
624                 EvAttachment *attachment;
625                 GtkTreeIter   iter;
626                 GdkPixbuf    *pixbuf = NULL;
627                 const gchar  *mime_type;
628
629                 attachment = EV_ATTACHMENT (l->data);
630
631                 mime_type = ev_attachment_get_mime_type (attachment);
632                 pixbuf = ev_sidebar_attachments_icon_cache_get (ev_attachbar,
633                                                                 mime_type);
634
635                 gtk_list_store_append (ev_attachbar->priv->model, &iter);
636                 gtk_list_store_set (ev_attachbar->priv->model, &iter,
637                                     COLUMN_NAME, ev_attachment_get_name (attachment),
638                                     COLUMN_ICON, pixbuf,
639                                     COLUMN_ATTACHMENT, attachment, 
640                                     -1);
641         }
642
643         g_object_unref (job);
644 }
645
646 static void
647 ev_sidebar_attachments_set_document (EvSidebarPage   *page,
648                                      EvDocument      *document)
649 {
650         EvSidebarAttachments *ev_attachbar = EV_SIDEBAR_ATTACHMENTS (page);
651         EvJob *job;
652         
653         if (!ev_document_has_attachments (document))
654                 return;
655
656         if (!ev_attachbar->priv->icon_theme) {
657                 GdkScreen *screen;
658
659                 screen = gtk_widget_get_screen (GTK_WIDGET (ev_attachbar));
660                 ev_attachbar->priv->icon_theme = gtk_icon_theme_get_for_screen (screen);
661                 g_signal_connect_swapped (G_OBJECT (ev_attachbar->priv->icon_theme),
662                                           "changed",
663                                           G_CALLBACK (ev_sidebar_attachments_update_icons),
664                                           (gpointer) ev_attachbar);
665         }
666                 
667         gtk_list_store_clear (ev_attachbar->priv->model);
668
669         job = ev_job_attachments_new (document);
670         g_signal_connect (job, "finished",
671                           G_CALLBACK (job_finished_callback),
672                           ev_attachbar);
673         g_signal_connect (job, "cancelled",
674                           G_CALLBACK (g_object_unref),
675                           NULL);
676         /* The priority doesn't matter for this job */
677         ev_job_scheduler_push_job (job, EV_JOB_PRIORITY_NONE);
678 }
679
680 static gboolean
681 ev_sidebar_attachments_support_document (EvSidebarPage   *sidebar_page,
682                                          EvDocument      *document)
683 {
684         return ev_document_has_attachments (document);
685 }
686
687 static const gchar*
688 ev_sidebar_attachments_get_label (EvSidebarPage *sidebar_page)
689 {
690         return _("Attachments");
691 }
692
693 static void
694 ev_sidebar_attachments_page_iface_init (EvSidebarPageIface *iface)
695 {
696         iface->support_document = ev_sidebar_attachments_support_document;
697         iface->set_document = ev_sidebar_attachments_set_document;
698         iface->get_label = ev_sidebar_attachments_get_label;
699 }
700