]> www.fi.muni.cz Git - evince.git/blob - shell/ev-sidebar-links.c
Implements another history variant
[evince.git] / shell / ev-sidebar-links.c
1 /* this file is part of evince, a gnome document viewer
2  *
3  *  Copyright (C) 2004 Red Hat, Inc.
4  *
5  *  Author:
6  *    Jonathan Blandford <jrb@alum.mit.edu>
7  *
8  * Evince is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * Evince is distributed in the hope that it will be useful, but
14  * WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
21  */
22
23 #ifdef HAVE_CONFIG_H
24 #include "config.h"
25 #endif
26
27 #include <string.h>
28 #include <glib/gi18n.h>
29 #include <gtk/gtk.h>
30
31 #include "ev-sidebar-page.h"
32 #include "ev-sidebar-links.h"
33 #include "ev-job-queue.h"
34 #include "ev-document-links.h"
35 #include "ev-window.h"
36
37 struct _EvSidebarLinksPrivate {
38         GtkWidget *tree_view;
39
40         /* Keep these ids around for blocking */
41         guint selection_id;
42         guint page_changed_id;
43         guint row_activated_id;
44
45         EvJob *job;
46         GtkTreeModel *model;
47         EvDocument *document;
48         EvPageCache *page_cache;
49 };
50
51 enum {
52         PROP_0,
53         PROP_MODEL,
54         PROP_WIDGET,
55 };
56
57 enum {
58         LINK_ACTIVATED,
59         N_SIGNALS
60 };
61
62 static void update_page_callback                        (EvPageCache       *page_cache,
63                                                          gint               current_page,
64                                                          EvSidebarLinks    *sidebar_links);
65 static void row_activated_callback                      (GtkTreeView *treeview,
66                                                          GtkTreePath *arg1,
67                                                          GtkTreeViewColumn *arg2,
68                                                          gpointer user_data);
69 static void job_finished_callback                       (EvJobLinks     *job,
70                                                          EvSidebarLinks *sidebar_links);
71 static void ev_sidebar_links_page_iface_init            (EvSidebarPageIface *iface);
72 static void ev_sidebar_links_set_document               (EvSidebarPage  *sidebar_page,
73                                                          EvDocument     *document);
74 static gboolean ev_sidebar_links_support_document       (EvSidebarPage  *sidebar_page,
75                                                          EvDocument     *document);
76 static const gchar* ev_sidebar_links_get_label          (EvSidebarPage *sidebar_page);
77
78 static guint signals[N_SIGNALS];
79
80 G_DEFINE_TYPE_EXTENDED (EvSidebarLinks, 
81                         ev_sidebar_links, 
82                         GTK_TYPE_VBOX,
83                         0, 
84                         G_IMPLEMENT_INTERFACE (EV_TYPE_SIDEBAR_PAGE, 
85                                                ev_sidebar_links_page_iface_init))
86
87
88 #define EV_SIDEBAR_LINKS_GET_PRIVATE(object) \
89         (G_TYPE_INSTANCE_GET_PRIVATE ((object), EV_TYPE_SIDEBAR_LINKS, EvSidebarLinksPrivate))
90
91 static void
92 ev_sidebar_links_set_property (GObject      *object,
93                                guint         prop_id,
94                                const GValue *value,
95                                GParamSpec   *pspec)
96 {
97         EvSidebarLinks *ev_sidebar_links;
98         GtkTreeModel *model;
99   
100         ev_sidebar_links = EV_SIDEBAR_LINKS (object);
101
102         switch (prop_id)
103         {
104         case PROP_MODEL:
105                 model = ev_sidebar_links->priv->model;
106                 ev_sidebar_links->priv->model = GTK_TREE_MODEL (g_value_dup_object (value));
107                 if (model)
108                         g_object_unref (model);
109                 break;
110         default:
111                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
112                 break;
113         }
114 }
115
116 static void
117 ev_sidebar_links_get_property (GObject    *object,
118                                guint       prop_id,
119                                GValue     *value,
120                                GParamSpec *pspec)
121 {
122         EvSidebarLinks *ev_sidebar_links;
123   
124         ev_sidebar_links = EV_SIDEBAR_LINKS (object);
125
126         switch (prop_id)
127         {
128         case PROP_MODEL:
129                 g_value_set_object (value, ev_sidebar_links->priv->model);
130                 break;
131         case PROP_WIDGET:
132                 g_value_set_object (value, ev_sidebar_links->priv->tree_view);
133                 break;
134         default:
135                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
136                 break;
137         }
138 }
139
140 static void
141 ev_sidebar_links_dispose (GObject *object)
142 {
143         EvSidebarLinks *sidebar = EV_SIDEBAR_LINKS (object);
144
145         if (sidebar->priv->job) {
146                 g_signal_handlers_disconnect_by_func (sidebar->priv->job,
147                                                       job_finished_callback, sidebar);
148                 ev_job_queue_remove_job (sidebar->priv->job);                                                 
149                 g_object_unref (sidebar->priv->job);
150                 sidebar->priv->job = NULL;
151         }
152
153         if (sidebar->priv->model) {
154                 g_object_unref (sidebar->priv->model);
155                 sidebar->priv->model = NULL;
156         }
157
158         if (sidebar->priv->document) {
159                 g_object_unref (sidebar->priv->document);
160                 sidebar->priv->document = NULL;
161                 sidebar->priv->page_cache = NULL;
162         }
163
164         G_OBJECT_CLASS (ev_sidebar_links_parent_class)->dispose (object);
165 }
166
167 static void
168 ev_sidebar_links_map (GtkWidget *widget)
169 {
170         EvSidebarLinks *links;
171
172         links = EV_SIDEBAR_LINKS (widget);
173
174         GTK_WIDGET_CLASS (ev_sidebar_links_parent_class)->map (widget);
175
176         if (links->priv->model) {
177                 update_page_callback (links->priv->page_cache,
178                                       ev_page_cache_get_current_page (links->priv->page_cache),
179                                       links);
180         }
181 }
182
183 static void
184 ev_sidebar_links_class_init (EvSidebarLinksClass *ev_sidebar_links_class)
185 {
186         GObjectClass   *g_object_class;
187         GtkWidgetClass *widget_class;
188
189         g_object_class = G_OBJECT_CLASS (ev_sidebar_links_class);
190         widget_class = GTK_WIDGET_CLASS (ev_sidebar_links_class);
191
192         g_object_class->set_property = ev_sidebar_links_set_property;
193         g_object_class->get_property = ev_sidebar_links_get_property;
194         g_object_class->dispose = ev_sidebar_links_dispose;
195
196         widget_class->map = ev_sidebar_links_map;
197
198         signals[LINK_ACTIVATED] = g_signal_new ("link-activated",
199                          G_TYPE_FROM_CLASS (g_object_class),
200                          G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
201                          G_STRUCT_OFFSET (EvSidebarLinksClass, link_activated),
202                          NULL, NULL,
203                          g_cclosure_marshal_VOID__OBJECT,
204                          G_TYPE_NONE, 1, G_TYPE_OBJECT);
205
206         g_object_class_install_property (g_object_class,
207                                          PROP_MODEL,
208                                          g_param_spec_object ("model",
209                                                               "Model",
210                                                               "Current Model",
211                                                               GTK_TYPE_TREE_MODEL,
212                                                               G_PARAM_READWRITE));
213         g_object_class_override_property (g_object_class,
214                                           PROP_WIDGET,
215                                           "main-widget");
216
217         g_type_class_add_private (g_object_class, sizeof (EvSidebarLinksPrivate));
218 }
219
220 static void
221 selection_changed_callback (GtkTreeSelection   *selection,
222                             EvSidebarLinks     *ev_sidebar_links)
223 {
224         EvDocument *document;
225         GtkTreeModel *model;
226         GtkTreeIter iter;
227
228         document = EV_DOCUMENT (ev_sidebar_links->priv->document);
229         g_return_if_fail (ev_sidebar_links->priv->document != NULL);
230
231         if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
232                 EvLink *link;
233
234                 gtk_tree_model_get (model, &iter,
235                                     EV_DOCUMENT_LINKS_COLUMN_LINK, &link,
236                                     -1);
237                 
238                 if (link == NULL)
239                         return;
240
241                 g_signal_handler_block (ev_sidebar_links->priv->page_cache,
242                                         ev_sidebar_links->priv->page_changed_id);
243                 g_signal_emit (ev_sidebar_links, signals[LINK_ACTIVATED], 0, link);
244                 g_signal_handler_unblock (ev_sidebar_links->priv->page_cache,
245                                           ev_sidebar_links->priv->page_changed_id);
246
247                 g_object_unref (link);
248         }
249 }
250
251 static GtkTreeModel *
252 create_loading_model (void)
253 {
254         GtkTreeModel *retval;
255         GtkTreeIter iter;
256         gchar *markup;
257
258         /* Creates a fake model to indicate that we're loading */
259         retval = (GtkTreeModel *)gtk_list_store_new (EV_DOCUMENT_LINKS_COLUMN_NUM_COLUMNS,
260                                                      G_TYPE_STRING,
261                                                      G_TYPE_OBJECT,
262                                                      G_TYPE_BOOLEAN,
263                                                      G_TYPE_STRING);
264
265         gtk_list_store_append (GTK_LIST_STORE (retval), &iter);
266         markup = g_strdup_printf ("<span size=\"larger\" style=\"italic\">%s</span>", _("Loading..."));
267         gtk_list_store_set (GTK_LIST_STORE (retval), &iter,
268                             EV_DOCUMENT_LINKS_COLUMN_MARKUP, markup,
269                             EV_DOCUMENT_LINKS_COLUMN_EXPAND, FALSE,
270                             EV_DOCUMENT_LINKS_COLUMN_LINK, NULL,
271                             -1);
272         g_free (markup);
273
274         return retval;
275 }
276
277 static void
278 print_section_cb (GtkWidget *menuitem, EvSidebarLinks *sidebar)
279 {
280         GtkWidget *window;
281         GtkTreeSelection *selection;
282         GtkTreeModel *model;
283         GtkTreeIter iter;
284
285         selection = gtk_tree_view_get_selection
286                 (GTK_TREE_VIEW (sidebar->priv->tree_view));
287
288         if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
289                 EvLink *link;
290                 int first_page, last_page = -1;
291
292                 gtk_tree_model_get (model, &iter,
293                                     EV_DOCUMENT_LINKS_COLUMN_LINK, &link,
294                                     -1);
295
296                 if (!link)
297                         return;
298
299                 first_page = ev_link_get_page (link);
300                 if (first_page == -1) {
301                         g_object_unref (link);
302                         return;
303                 }
304                 
305                 first_page++;
306                 g_object_unref (link);
307
308                 if (gtk_tree_model_iter_next (model, &iter)) {
309                         gtk_tree_model_get (model, &iter,
310                                             EV_DOCUMENT_LINKS_COLUMN_LINK, &link,
311                                             -1);
312
313                         if (link) {
314                                 last_page = ev_link_get_page (link);
315                                 g_object_unref (link);
316                         }
317                 } else {
318                         last_page = ev_page_cache_get_n_pages (sidebar->priv->page_cache);
319                 }
320
321                 if (last_page == -1)
322                         last_page = ev_page_cache_get_n_pages (sidebar->priv->page_cache);
323         
324                 window = gtk_widget_get_toplevel (GTK_WIDGET (sidebar));
325                 if (EV_IS_WINDOW (window)) {
326 #ifdef WITH_PRINT
327                         ev_window_print_range (EV_WINDOW (window),
328                                                first_page, last_page);
329 #endif
330                 }
331         }
332 }
333
334 static GtkMenu *
335 build_popup_menu (EvSidebarLinks *sidebar)
336 {
337         GtkWidget *menu;
338         GtkWidget *item;
339
340         menu = gtk_menu_new ();
341         item = gtk_image_menu_item_new_from_stock (GTK_STOCK_PRINT, NULL);
342         gtk_label_set_label (GTK_LABEL (GTK_BIN (item)->child), _("Print..."));
343         gtk_widget_show (item);
344         gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
345         g_signal_connect (item, "activate",
346                           G_CALLBACK (print_section_cb), sidebar);
347
348         return GTK_MENU (menu);
349 }
350
351 static void
352 popup_menu_cb (GtkWidget *treeview, EvSidebarLinks *sidebar)
353 {
354         GtkMenu *menu = build_popup_menu (sidebar);
355
356         gtk_menu_popup (menu, NULL, NULL,
357                         ev_gui_menu_position_tree_selection,
358                         sidebar->priv->tree_view, 0,
359                         gtk_get_current_event_time ());
360         gtk_menu_shell_select_first (GTK_MENU_SHELL (menu), FALSE);
361 }
362
363 static gboolean
364 button_press_cb (GtkWidget *treeview,
365                  GdkEventButton *event,
366                  EvSidebarLinks *sidebar)
367 {
368         GtkTreePath *path = NULL;
369
370         if (event->button == 3) {
371                 if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (treeview),
372                                                    event->x,
373                                                    event->y,
374                                                    &path,
375                                                    NULL, NULL, NULL)) {
376                         gtk_tree_view_set_cursor (GTK_TREE_VIEW (treeview),
377                                                   path, NULL, FALSE);
378                         gtk_menu_popup (build_popup_menu (sidebar), NULL,
379                                         NULL, NULL, NULL, event->button,
380                                         gtk_get_current_event_time ());
381                         gtk_tree_path_free (path);
382
383                         return TRUE;
384                 }
385         }
386
387         return FALSE;
388 }
389
390
391 static void
392 ev_sidebar_links_construct (EvSidebarLinks *ev_sidebar_links)
393 {
394         EvSidebarLinksPrivate *priv;
395         GtkWidget *swindow;
396         GtkTreeViewColumn *column;
397         GtkCellRenderer *renderer;
398         GtkTreeSelection *selection;
399         GtkTreeModel *loading_model;
400
401         priv = ev_sidebar_links->priv;
402
403         swindow = gtk_scrolled_window_new (NULL, NULL);
404
405         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
406                                         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
407         gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swindow),
408                                              GTK_SHADOW_IN);
409
410         /* Create tree view */
411         loading_model = create_loading_model ();
412         priv->tree_view = gtk_tree_view_new_with_model (loading_model);
413         g_object_unref (loading_model);
414         
415         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree_view));
416         gtk_tree_selection_set_mode (selection, GTK_SELECTION_NONE);
417         gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->tree_view), FALSE);
418         gtk_container_add (GTK_CONTAINER (swindow), priv->tree_view);
419
420         gtk_box_pack_start (GTK_BOX (ev_sidebar_links), swindow, TRUE, TRUE, 0);
421         gtk_widget_show_all (GTK_WIDGET (ev_sidebar_links));
422
423         column = gtk_tree_view_column_new ();
424         gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
425         gtk_tree_view_append_column (GTK_TREE_VIEW (priv->tree_view), column);
426
427         renderer = (GtkCellRenderer*)
428                 g_object_new (GTK_TYPE_CELL_RENDERER_TEXT,
429                               "ellipsize", PANGO_ELLIPSIZE_END,
430                               NULL);
431         gtk_tree_view_column_pack_start (GTK_TREE_VIEW_COLUMN (column), renderer, TRUE);
432         gtk_tree_view_column_set_attributes (GTK_TREE_VIEW_COLUMN (column), renderer,
433                                              "markup", EV_DOCUMENT_LINKS_COLUMN_MARKUP,
434                                              NULL);
435
436         
437         renderer = gtk_cell_renderer_text_new ();
438         gtk_tree_view_column_pack_end (GTK_TREE_VIEW_COLUMN (column), renderer, FALSE);
439         gtk_tree_view_column_set_attributes (GTK_TREE_VIEW_COLUMN (column), renderer,
440                                              "markup", EV_DOCUMENT_LINKS_COLUMN_PAGE_LABEL,
441                                              NULL);
442
443         g_signal_connect (GTK_TREE_VIEW (priv->tree_view),
444                           "button_press_event",
445                           G_CALLBACK (button_press_cb),
446                           ev_sidebar_links);
447         g_signal_connect (GTK_TREE_VIEW (priv->tree_view),
448                           "popup_menu",
449                           G_CALLBACK (popup_menu_cb),
450                           ev_sidebar_links);
451 }
452
453 static void
454 ev_sidebar_links_init (EvSidebarLinks *ev_sidebar_links)
455 {
456         ev_sidebar_links->priv = EV_SIDEBAR_LINKS_GET_PRIVATE (ev_sidebar_links);
457
458         ev_sidebar_links_construct (ev_sidebar_links);
459 }
460
461 static gboolean
462 fill_page_labels (GtkTreeModel *tree_model,
463                   GtkTreePath *path,
464                   GtkTreeIter *iter,
465                   EvSidebarLinks    *sidebar_links)
466 {
467         EvLink *link;
468         gint page;
469         gchar *page_label;
470         gchar *page_string;
471
472
473         gtk_tree_model_get (tree_model, iter,
474                             EV_DOCUMENT_LINKS_COLUMN_LINK, &link,
475                             -1);
476
477         if (!link)
478                 return FALSE;
479
480         page = ev_link_get_page (link);
481
482         if (page < 0) 
483                 return FALSE;
484         
485         page_label = ev_page_cache_get_page_label (sidebar_links->priv->page_cache,
486                                                    page);
487         page_string = g_markup_printf_escaped ("<i>%s</i>", page_label);
488                 
489         gtk_tree_store_set (GTK_TREE_STORE (tree_model), iter,
490                             EV_DOCUMENT_LINKS_COLUMN_PAGE_LABEL, page_string, 
491                               -1);
492
493         g_free (page_label);
494         g_free (page_string);
495
496         g_object_unref (link);
497         return FALSE;
498 }
499
500 /* Public Functions */
501
502 GtkWidget *
503 ev_sidebar_links_new (void)
504 {
505         GtkWidget *ev_sidebar_links;
506
507         ev_sidebar_links = g_object_new (EV_TYPE_SIDEBAR_LINKS, NULL);
508
509         return ev_sidebar_links;
510 }
511
512 static gboolean
513 update_page_callback_foreach (GtkTreeModel *model,
514                               GtkTreePath  *path,
515                               GtkTreeIter  *iter,
516                               gpointer      data)
517 {
518         EvSidebarLinks *sidebar_links = (data);
519         EvLink *link;
520
521         gtk_tree_model_get (model, iter,
522                             EV_DOCUMENT_LINKS_COLUMN_LINK, &link,
523                             -1);
524
525         if (link) {
526                 int current_page;
527                 int dest_page;
528
529                 dest_page = ev_link_get_page (link);
530                 g_object_unref (link);
531                 
532                 current_page = ev_page_cache_get_current_page (sidebar_links->priv->page_cache);
533                          
534                 if (dest_page == current_page) {
535                         gtk_tree_view_expand_to_path (GTK_TREE_VIEW (sidebar_links->priv->tree_view),
536                                                       path);
537                         gtk_tree_view_set_cursor (GTK_TREE_VIEW (sidebar_links->priv->tree_view),
538                                                   path, NULL, FALSE);
539                         
540                         return TRUE;
541                 }
542         }
543
544         return FALSE;
545 }
546
547 static void
548 update_page_callback (EvPageCache    *page_cache,
549                       gint            current_page,
550                       EvSidebarLinks *sidebar_links)
551 {
552         GtkTreeSelection *selection;
553         GtkTreeModel *model;
554         GtkTreeIter iter;
555
556         /* Widget is not currently visible */
557         if (!GTK_WIDGET_MAPPED (sidebar_links))
558                 return;
559         
560         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (sidebar_links->priv->tree_view));
561
562         if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
563                 EvLink *link;
564
565                 gtk_tree_model_get (model, &iter,
566                                     EV_DOCUMENT_LINKS_COLUMN_LINK, &link,
567                                     -1);
568                 if (link) {
569                         gint dest_page;
570
571                         dest_page = ev_link_get_page (link);
572                         g_object_unref (link);
573                         
574                         if (dest_page == current_page)
575                                 return;
576                 }
577         }               
578
579         /* We go through the tree linearly looking for the first page that
580          * matches.  This is pretty inefficient.  We can do something neat with
581          * a GtkTreeModelSort here to make it faster, if it turns out to be
582          * slow.
583          */
584         g_signal_handler_block (selection, sidebar_links->priv->selection_id);
585         g_signal_handler_block (sidebar_links->priv->tree_view, sidebar_links->priv->row_activated_id);
586
587         gtk_tree_model_foreach (model,
588                                 update_page_callback_foreach,
589                                 sidebar_links);
590         
591         g_signal_handler_unblock (selection, sidebar_links->priv->selection_id);
592         g_signal_handler_unblock (sidebar_links->priv->tree_view, sidebar_links->priv->row_activated_id);
593 }
594
595 static void 
596 row_activated_callback (GtkTreeView       *treeview,
597                         GtkTreePath       *arg1,
598                         GtkTreeViewColumn *arg2,
599                         gpointer           user_data)
600 {       
601         if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (treeview), arg1)) {
602                 gtk_tree_view_collapse_row (GTK_TREE_VIEW (treeview), arg1);
603         } else {
604                 gtk_tree_view_expand_row (GTK_TREE_VIEW (treeview), arg1, FALSE);
605         }
606 }
607
608 static void
609 expand_open_links (GtkTreeView *tree_view, GtkTreeModel *model, GtkTreeIter *parent)
610 {
611         GtkTreeIter iter;
612         gboolean expand;
613
614         if (gtk_tree_model_iter_children (model, &iter, parent)) {
615                 do {
616                         gtk_tree_model_get (model, &iter,
617                                             EV_DOCUMENT_LINKS_COLUMN_EXPAND, &expand,
618                                             -1);
619                         if (expand) {
620                                 GtkTreePath *path;
621                                 
622                                 path = gtk_tree_model_get_path (model, &iter);
623                                 gtk_tree_view_expand_row (tree_view, path, FALSE);
624                                 gtk_tree_path_free (path);
625                         }
626
627                         expand_open_links (tree_view, model, &iter);
628                 } while (gtk_tree_model_iter_next (model, &iter));
629         }
630 }
631         
632 static void
633 job_finished_callback (EvJobLinks     *job,
634                        EvSidebarLinks *sidebar_links)
635 {
636         EvSidebarLinksPrivate *priv;
637         GtkTreeSelection *selection;
638
639         priv = sidebar_links->priv;
640         
641         priv->model = job->model;
642         g_object_notify (G_OBJECT (sidebar_links), "model");
643         
644         gtk_tree_model_foreach (priv->model, (GtkTreeModelForeachFunc)fill_page_labels, sidebar_links);
645
646         gtk_tree_view_set_model (GTK_TREE_VIEW (priv->tree_view), job->model);
647         
648         g_object_unref (job);
649         priv->job = NULL;
650
651         expand_open_links (GTK_TREE_VIEW (priv->tree_view), priv->model, NULL);
652
653         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree_view));
654         gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
655         priv->selection_id = g_signal_connect (selection, "changed",
656                                                G_CALLBACK (selection_changed_callback),
657                                                sidebar_links);
658         priv->page_changed_id = g_signal_connect (priv->page_cache, "page-changed",
659                                                   G_CALLBACK (update_page_callback),
660                                                   sidebar_links);
661         priv->row_activated_id = g_signal_connect (G_OBJECT (priv->tree_view), "row-activated",
662                                                     G_CALLBACK (row_activated_callback), sidebar_links);
663         update_page_callback (priv->page_cache,
664                               ev_page_cache_get_current_page (priv->page_cache),
665                               sidebar_links);
666
667 }
668
669 static void
670 ev_sidebar_links_set_document (EvSidebarPage  *sidebar_page,
671                                EvDocument     *document)
672 {
673         EvSidebarLinks *sidebar_links;
674         EvSidebarLinksPrivate *priv;
675
676         g_return_if_fail (EV_IS_SIDEBAR_PAGE (sidebar_page));
677         g_return_if_fail (EV_IS_DOCUMENT (document));
678         
679         sidebar_links = EV_SIDEBAR_LINKS (sidebar_page);
680
681         priv = sidebar_links->priv;
682
683         if (priv->document) {
684                 gtk_tree_view_set_model (GTK_TREE_VIEW (priv->tree_view), NULL);
685                 g_object_unref (priv->document);
686         }
687
688         priv->document = g_object_ref (document);
689         priv->page_cache = ev_page_cache_get (document);
690
691         if (priv->job) {
692                 g_signal_handlers_disconnect_by_func (priv->job,
693                                                       job_finished_callback,
694                                                       sidebar_links);
695                 g_object_unref (priv->job);
696         }
697
698         priv->job = ev_job_links_new (document);
699         g_signal_connect (priv->job,
700                           "finished",
701                           G_CALLBACK (job_finished_callback),
702                           sidebar_links);
703         /* The priority doesn't matter for this job */
704         ev_job_queue_add_job (priv->job, EV_JOB_PRIORITY_LOW);
705 }
706
707 static gboolean
708 ev_sidebar_links_support_document (EvSidebarPage  *sidebar_page,
709                                    EvDocument *document)
710 {
711         return (EV_IS_DOCUMENT_LINKS (document) &&
712                     ev_document_links_has_document_links (EV_DOCUMENT_LINKS (document)));
713 }
714
715 static const gchar*
716 ev_sidebar_links_get_label (EvSidebarPage *sidebar_page)
717 {
718     return _("Index");
719 }
720
721 static void
722 ev_sidebar_links_page_iface_init (EvSidebarPageIface *iface)
723 {
724         iface->support_document = ev_sidebar_links_support_document;
725         iface->set_document = ev_sidebar_links_set_document;
726         iface->get_label = ev_sidebar_links_get_label;
727 }
728