]> www.fi.muni.cz Git - evince.git/blob - shell/ev-sidebar-attachments.c
Add support for external links to EvViewPresentation
[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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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-document-attachments.h"
35 #include "ev-jobs.h"
36 #include "ev-job-scheduler.h"
37 #include "ev-file-helpers.h"
38 #include "ev-sidebar-attachments.h"
39 #include "ev-sidebar-page.h"
40
41 enum {
42         COLUMN_ICON,
43         COLUMN_NAME,
44         COLUMN_DESCRIPTION,
45         COLUMN_ATTACHMENT,
46         N_COLS
47 };
48
49 enum {
50         PROP_0,
51         PROP_WIDGET,
52 };
53
54 enum {
55         SIGNAL_POPUP_MENU,
56         N_SIGNALS
57 };
58
59 static guint signals[N_SIGNALS];
60
61 struct _EvSidebarAttachmentsPrivate {
62         GtkWidget      *icon_view;
63         GtkListStore   *model;
64
65         /* Icons */
66         GtkIconTheme   *icon_theme;
67         GHashTable     *icon_cache;
68 };
69
70 static void ev_sidebar_attachments_page_iface_init (EvSidebarPageInterface *iface);
71
72 G_DEFINE_TYPE_EXTENDED (EvSidebarAttachments,
73                         ev_sidebar_attachments,
74                         GTK_TYPE_VBOX,
75                         0, 
76                         G_IMPLEMENT_INTERFACE (EV_TYPE_SIDEBAR_PAGE, 
77                                                ev_sidebar_attachments_page_iface_init))
78
79 #define EV_SIDEBAR_ATTACHMENTS_GET_PRIVATE(object) \
80                 (G_TYPE_INSTANCE_GET_PRIVATE ((object), EV_TYPE_SIDEBAR_ATTACHMENTS, EvSidebarAttachmentsPrivate))
81
82 /* Icon cache */
83 static void
84 ev_sidebar_attachments_icon_cache_add (EvSidebarAttachments *ev_attachbar,
85                                        const gchar          *mime_type,
86                                        const GdkPixbuf      *pixbuf)
87 {
88         g_assert (mime_type != NULL);
89         g_assert (GDK_IS_PIXBUF (pixbuf));
90
91         g_hash_table_insert (ev_attachbar->priv->icon_cache,
92                              (gpointer)g_strdup (mime_type),
93                              (gpointer)pixbuf);
94                              
95 }
96
97 static GdkPixbuf *
98 icon_theme_get_pixbuf_from_mime_type (GtkIconTheme *icon_theme,
99                                       const gchar  *mime_type)
100 {
101         const char *separator;
102         GString *icon_name;
103         GdkPixbuf *pixbuf;
104
105         separator = strchr (mime_type, '/');
106         if (!separator)
107                 return NULL; /* maybe we should return a GError with "invalid MIME-type" */
108
109         icon_name = g_string_new ("gnome-mime-");
110         g_string_append_len (icon_name, mime_type, separator - mime_type);
111         g_string_append_c (icon_name, '-');
112         g_string_append (icon_name, separator + 1);
113         pixbuf = gtk_icon_theme_load_icon (icon_theme, icon_name->str, 48, 0, NULL);
114         g_string_free (icon_name, TRUE);
115         if (pixbuf)
116                 return pixbuf;
117         
118         icon_name = g_string_new ("gnome-mime-");
119         g_string_append_len (icon_name, mime_type, separator - mime_type);
120         pixbuf = gtk_icon_theme_load_icon (icon_theme, icon_name->str, 48, 0, NULL);
121         g_string_free (icon_name, TRUE);
122         
123         return pixbuf;
124 }
125
126 static GdkPixbuf *
127 ev_sidebar_attachments_icon_cache_get (EvSidebarAttachments *ev_attachbar,
128                                        const gchar          *mime_type)
129 {
130         GdkPixbuf *pixbuf = NULL;
131         
132         g_assert (mime_type != NULL);
133
134         pixbuf = g_hash_table_lookup (ev_attachbar->priv->icon_cache,
135                                       mime_type);
136
137         if (GDK_IS_PIXBUF (pixbuf))
138                 return pixbuf;
139
140         pixbuf = icon_theme_get_pixbuf_from_mime_type (ev_attachbar->priv->icon_theme,
141                                                        mime_type);
142
143         if (GDK_IS_PIXBUF (pixbuf))
144                 ev_sidebar_attachments_icon_cache_add (ev_attachbar,
145                                                        mime_type,
146                                                        pixbuf);
147
148         return pixbuf;
149 }
150
151 static gboolean
152 icon_cache_update_icon (gchar                *key,
153                         GdkPixbuf            *value,
154                         EvSidebarAttachments *ev_attachbar)
155 {
156         GdkPixbuf *pixbuf = NULL;
157
158         pixbuf = icon_theme_get_pixbuf_from_mime_type (ev_attachbar->priv->icon_theme,
159                                                        key);
160
161         ev_sidebar_attachments_icon_cache_add (ev_attachbar,
162                                                key,
163                                                pixbuf);
164         
165         return FALSE;
166 }
167
168 static void
169 ev_sidebar_attachments_icon_cache_refresh (EvSidebarAttachments *ev_attachbar)
170 {
171         g_hash_table_foreach_remove (ev_attachbar->priv->icon_cache,
172                                      (GHRFunc) icon_cache_update_icon,
173                                      ev_attachbar);
174 }
175
176 static EvAttachment *
177 ev_sidebar_attachments_get_attachment_at_pos (EvSidebarAttachments *ev_attachbar,
178                                               gint                  x,
179                                               gint                  y)
180 {
181         GtkTreePath  *path = NULL;
182         GtkTreeIter   iter;
183         EvAttachment *attachment = NULL;
184
185         path = gtk_icon_view_get_path_at_pos (GTK_ICON_VIEW (ev_attachbar->priv->icon_view),
186                                               x, y);
187         if (!path) {
188                 return NULL;
189         }
190
191         gtk_tree_model_get_iter (GTK_TREE_MODEL (ev_attachbar->priv->model),
192                                  &iter, path);
193         gtk_tree_model_get (GTK_TREE_MODEL (ev_attachbar->priv->model), &iter,
194                             COLUMN_ATTACHMENT, &attachment,
195                             -1);
196
197         gtk_icon_view_select_path (GTK_ICON_VIEW (ev_attachbar->priv->icon_view),
198                                    path);
199         
200         gtk_tree_path_free (path);
201
202         return attachment;
203 }
204
205 static gboolean
206 ev_sidebar_attachments_popup_menu_show (EvSidebarAttachments *ev_attachbar,
207                                         gint                  x,
208                                         gint                  y)
209 {
210         GtkIconView *icon_view;
211         GtkTreePath *path;
212         GList       *selected = NULL, *l;
213         GList       *attach_list = NULL;
214
215         icon_view = GTK_ICON_VIEW (ev_attachbar->priv->icon_view);
216         
217         path = gtk_icon_view_get_path_at_pos (icon_view, x, y);
218         if (!path)
219                 return FALSE;
220
221         if (!gtk_icon_view_path_is_selected (icon_view, path)) {
222                 gtk_icon_view_unselect_all (icon_view);
223                 gtk_icon_view_select_path (icon_view, path);
224         }
225
226         gtk_tree_path_free (path);
227         
228         selected = gtk_icon_view_get_selected_items (icon_view);
229         if (!selected)
230                 return FALSE;
231
232         for (l = selected; l && l->data; l = g_list_next (l)) {
233                 GtkTreeIter   iter;
234                 EvAttachment *attachment = NULL;
235
236                 path = (GtkTreePath *) l->data;
237
238                 gtk_tree_model_get_iter (GTK_TREE_MODEL (ev_attachbar->priv->model),
239                                          &iter, path);
240                 gtk_tree_model_get (GTK_TREE_MODEL (ev_attachbar->priv->model), &iter,
241                                     COLUMN_ATTACHMENT, &attachment,
242                                     -1);
243
244                 if (attachment)
245                         attach_list = g_list_prepend (attach_list, attachment);
246
247                 gtk_tree_path_free (path);
248         }
249
250         g_list_free (selected);
251
252         if (!attach_list)
253                 return FALSE;
254
255         g_signal_emit (ev_attachbar, signals[SIGNAL_POPUP_MENU], 0, attach_list);
256
257         return TRUE;
258 }
259
260 static gboolean
261 ev_sidebar_attachments_popup_menu (GtkWidget *widget)
262 {
263         EvSidebarAttachments *ev_attachbar = EV_SIDEBAR_ATTACHMENTS (widget);
264         gint                  x, y;
265
266         gtk_widget_get_pointer (widget, &x, &y);
267
268         return ev_sidebar_attachments_popup_menu_show (ev_attachbar, x, y);
269 }
270
271 static gboolean
272 ev_sidebar_attachments_button_press (EvSidebarAttachments *ev_attachbar,
273                                      GdkEventButton       *event,
274                                      GtkWidget            *icon_view)
275 {
276         if (!gtk_widget_has_focus (icon_view)) {
277                 gtk_widget_grab_focus (icon_view);
278         }
279         
280         if (event->button == 2)
281                 return FALSE;
282
283         switch (event->button) {
284                 case 1:
285                         if (event->type == GDK_2BUTTON_PRESS) {
286                                 GError *error = NULL;
287                                 EvAttachment *attachment;
288                                 
289                                 attachment = ev_sidebar_attachments_get_attachment_at_pos (ev_attachbar,
290                                                                                            event->x,
291                                                                                            event->y);
292                                 if (!attachment)
293                                         return FALSE;
294                                 
295                                 ev_attachment_open (attachment,
296                                                     gtk_widget_get_screen (GTK_WIDGET (ev_attachbar)),
297                                                     event->time,
298                                                     &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         GList                *selected = NULL, *l;
399         GPtrArray            *uris;
400         char                **uri_list;
401
402         selected = gtk_icon_view_get_selected_items (GTK_ICON_VIEW (ev_attachbar->priv->icon_view));
403         if (!selected)
404                 return;
405
406         uris = g_ptr_array_new ();
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        *template;
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                 /* FIXMEchpe: convert to filename encoding first! */
425                 template = g_strdup_printf ("%s.XXXXXX", ev_attachment_get_name (attachment));
426                 file = ev_mkstemp_file (template, &error);
427                 g_free (template);
428                 
429                 if (file != NULL && ev_attachment_save (attachment, file, &error)) {
430                         gchar *uri;
431
432                         uri = g_file_get_uri (file);
433                         g_ptr_array_add (uris, uri);
434                 }
435         
436                 if (error) {
437                         g_warning ("%s", error->message);
438                         g_error_free (error);
439                 }
440
441                 gtk_tree_path_free (path);
442                 g_object_unref (file);
443                 g_object_unref (attachment);
444         }
445
446         g_ptr_array_add (uris, NULL); /* NULL-terminate */
447         uri_list = (char **) g_ptr_array_free (uris, FALSE);
448         gtk_selection_data_set_uris (data, uri_list);
449         g_strfreev (uri_list);
450
451         g_list_free (selected);
452 }
453
454 static void
455 ev_sidebar_attachments_get_property (GObject    *object,
456                                      guint       prop_id,
457                                      GValue     *value,
458                                      GParamSpec *pspec)
459 {
460         EvSidebarAttachments *ev_sidebar_attachments;
461   
462         ev_sidebar_attachments = EV_SIDEBAR_ATTACHMENTS (object);
463
464         switch (prop_id) {
465                 case PROP_WIDGET:
466                         g_value_set_object (value, ev_sidebar_attachments->priv->icon_view);
467                         break;
468                 default:
469                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
470                         break;
471         }
472 }
473
474 static void
475 ev_sidebar_attachments_dispose (GObject *object)
476 {
477         EvSidebarAttachments *ev_attachbar = EV_SIDEBAR_ATTACHMENTS (object);
478
479         if (ev_attachbar->priv->icon_theme) {
480                 g_signal_handlers_disconnect_by_func (
481                         ev_attachbar->priv->icon_theme, 
482                         G_CALLBACK (ev_sidebar_attachments_update_icons),
483                         ev_attachbar);
484                 ev_attachbar->priv->icon_theme = NULL;
485         }
486         
487         if (ev_attachbar->priv->model) {
488                 g_object_unref (ev_attachbar->priv->model);
489                 ev_attachbar->priv->model = NULL;
490         }
491
492         if (ev_attachbar->priv->icon_cache) {
493                 g_hash_table_destroy (ev_attachbar->priv->icon_cache);
494                 ev_attachbar->priv->icon_cache = NULL;
495         }
496
497         G_OBJECT_CLASS (ev_sidebar_attachments_parent_class)->dispose (object);
498 }
499
500 static void
501 ev_sidebar_attachments_class_init (EvSidebarAttachmentsClass *ev_attachbar_class)
502 {
503         GObjectClass   *g_object_class;
504         GtkWidgetClass *gtk_widget_class;
505
506         g_object_class = G_OBJECT_CLASS (ev_attachbar_class);
507         gtk_widget_class = GTK_WIDGET_CLASS (ev_attachbar_class);
508
509         g_object_class->get_property = ev_sidebar_attachments_get_property;
510         g_object_class->dispose = ev_sidebar_attachments_dispose;
511         gtk_widget_class->popup_menu = ev_sidebar_attachments_popup_menu;
512         gtk_widget_class->screen_changed = ev_sidebar_attachments_screen_changed;
513
514         g_type_class_add_private (g_object_class, sizeof (EvSidebarAttachmentsPrivate));
515
516         /* Signals */
517         signals[SIGNAL_POPUP_MENU] =
518                 g_signal_new ("popup",
519                               G_TYPE_FROM_CLASS (g_object_class),
520                               G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
521                               G_STRUCT_OFFSET (EvSidebarAttachmentsClass, popup_menu),
522                               NULL, NULL,
523                               g_cclosure_marshal_VOID__POINTER,
524                               G_TYPE_NONE, 1,
525                               G_TYPE_POINTER);
526
527         g_object_class_override_property (g_object_class,
528                                           PROP_WIDGET,
529                                           "main-widget");
530 }
531
532 static void
533 ev_sidebar_attachments_init (EvSidebarAttachments *ev_attachbar)
534 {
535         GtkWidget *swindow;
536         
537         ev_attachbar->priv = EV_SIDEBAR_ATTACHMENTS_GET_PRIVATE (ev_attachbar);
538
539         swindow = gtk_scrolled_window_new (NULL, NULL);
540         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
541                                         GTK_POLICY_NEVER,
542                                         GTK_POLICY_AUTOMATIC);
543         gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swindow),
544                                              GTK_SHADOW_IN);
545         /* Data Model */
546         ev_attachbar->priv->model = gtk_list_store_new (N_COLS,
547                                                         GDK_TYPE_PIXBUF, 
548                                                         G_TYPE_STRING,  
549                                                         G_TYPE_STRING,
550                                                         EV_TYPE_ATTACHMENT);
551
552         /* Icon View */
553         ev_attachbar->priv->icon_view =
554                 gtk_icon_view_new_with_model (GTK_TREE_MODEL (ev_attachbar->priv->model));
555         gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (ev_attachbar->priv->icon_view),
556                                           GTK_SELECTION_MULTIPLE);
557         gtk_icon_view_set_columns (GTK_ICON_VIEW (ev_attachbar->priv->icon_view), -1);
558         g_object_set (G_OBJECT (ev_attachbar->priv->icon_view),
559                       "text-column", COLUMN_NAME,
560                       "pixbuf-column", COLUMN_ICON,
561                       NULL);
562         g_signal_connect_swapped (ev_attachbar->priv->icon_view,
563                                   "button-press-event",
564                                   G_CALLBACK (ev_sidebar_attachments_button_press),
565                                   (gpointer) ev_attachbar);
566
567         gtk_container_add (GTK_CONTAINER (swindow),
568                            ev_attachbar->priv->icon_view);
569
570         gtk_container_add (GTK_CONTAINER (ev_attachbar),
571                            swindow);
572         gtk_widget_show_all (GTK_WIDGET (ev_attachbar));
573
574         /* Icon Theme */
575         ev_attachbar->priv->icon_theme = NULL;
576
577         /* Icon Cache */
578         ev_attachbar->priv->icon_cache = g_hash_table_new_full (g_str_hash,
579                                                                 g_str_equal,
580                                                                 g_free,
581                                                                 g_object_unref);
582
583         /* Drag and Drop */
584         gtk_icon_view_enable_model_drag_source (
585                 GTK_ICON_VIEW (ev_attachbar->priv->icon_view),
586                 GDK_BUTTON1_MASK,
587                 NULL, 0,
588                 GDK_ACTION_COPY);
589         gtk_drag_source_add_uri_targets (ev_attachbar->priv->icon_view);
590
591         g_signal_connect (ev_attachbar->priv->icon_view,
592                           "drag-data-get",
593                           G_CALLBACK (ev_sidebar_attachments_drag_data_get),
594                           (gpointer) ev_attachbar);     
595 }
596
597 GtkWidget *
598 ev_sidebar_attachments_new (void)
599 {
600         GtkWidget *ev_attachbar;
601
602         ev_attachbar = g_object_new (EV_TYPE_SIDEBAR_ATTACHMENTS, NULL);
603
604         return ev_attachbar;
605 }
606
607 static void
608 job_finished_callback (EvJobAttachments     *job,
609                        EvSidebarAttachments *ev_attachbar)
610 {
611         GList *l;
612         
613         for (l = job->attachments; l && l->data; l = g_list_next (l)) {
614                 EvAttachment *attachment;
615                 GtkTreeIter   iter;
616                 GdkPixbuf    *pixbuf = NULL;
617                 const gchar  *mime_type;
618
619                 attachment = EV_ATTACHMENT (l->data);
620
621                 mime_type = ev_attachment_get_mime_type (attachment);
622                 pixbuf = ev_sidebar_attachments_icon_cache_get (ev_attachbar,
623                                                                 mime_type);
624
625                 gtk_list_store_append (ev_attachbar->priv->model, &iter);
626                 gtk_list_store_set (ev_attachbar->priv->model, &iter,
627                                     COLUMN_NAME, ev_attachment_get_name (attachment),
628                                     COLUMN_ICON, pixbuf,
629                                     COLUMN_ATTACHMENT, attachment, 
630                                     -1);
631         }
632
633         g_object_unref (job);
634 }
635
636
637 static void
638 ev_sidebar_attachments_document_changed_cb (EvDocumentModel      *model,
639                                             GParamSpec           *pspec,
640                                             EvSidebarAttachments *ev_attachbar)
641 {
642         EvDocument *document = ev_document_model_get_document (model);
643         EvJob *job;
644
645         if (!EV_IS_DOCUMENT_ATTACHMENTS (document))
646                 return;
647
648         if (!ev_document_attachments_has_attachments (EV_DOCUMENT_ATTACHMENTS (document)))
649                 return;
650
651         if (!ev_attachbar->priv->icon_theme) {
652                 GdkScreen *screen;
653
654                 screen = gtk_widget_get_screen (GTK_WIDGET (ev_attachbar));
655                 ev_attachbar->priv->icon_theme = gtk_icon_theme_get_for_screen (screen);
656                 g_signal_connect_swapped (ev_attachbar->priv->icon_theme,
657                                           "changed",
658                                           G_CALLBACK (ev_sidebar_attachments_update_icons),
659                                           (gpointer) ev_attachbar);
660         }
661                 
662         gtk_list_store_clear (ev_attachbar->priv->model);
663
664         job = ev_job_attachments_new (document);
665         g_signal_connect (job, "finished",
666                           G_CALLBACK (job_finished_callback),
667                           ev_attachbar);
668         g_signal_connect (job, "cancelled",
669                           G_CALLBACK (g_object_unref),
670                           NULL);
671         /* The priority doesn't matter for this job */
672         ev_job_scheduler_push_job (job, EV_JOB_PRIORITY_NONE);
673 }
674
675 static void
676 ev_sidebar_attachments_set_model (EvSidebarPage   *page,
677                                   EvDocumentModel *model)
678 {
679         g_signal_connect (model, "notify::document",
680                           G_CALLBACK (ev_sidebar_attachments_document_changed_cb),
681                           page);
682 }
683
684 static gboolean
685 ev_sidebar_attachments_support_document (EvSidebarPage   *sidebar_page,
686                                          EvDocument      *document)
687 {
688         return (EV_IS_DOCUMENT_ATTACHMENTS (document) &&
689                 ev_document_attachments_has_attachments (EV_DOCUMENT_ATTACHMENTS (document)));
690 }
691
692 static const gchar*
693 ev_sidebar_attachments_get_label (EvSidebarPage *sidebar_page)
694 {
695         return _("Attachments");
696 }
697
698 static void
699 ev_sidebar_attachments_page_iface_init (EvSidebarPageInterface *iface)
700 {
701         iface->support_document = ev_sidebar_attachments_support_document;
702         iface->set_model = ev_sidebar_attachments_set_model;
703         iface->get_label = ev_sidebar_attachments_get_label;
704 }
705