shell/ev-window.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; c-indent-level: 8 -*- */
   2 /* this file is part of evince, a gnome document viewer
   3  *
   4  *  Copyright (C) 2004 Martin Kretzschmar
   5  *  Copyright (C) 2004 Red Hat, Inc.
   6  *  Copyright (C) 2000, 2001, 2002, 2003, 2004 Marco Pesenti Gritti
   7  *  Copyright (C) 2003, 2004, 2005 Christian Persch
   8  *
   9  *  Author:
  10  *    Martin Kretzschmar <martink@gnome.org>
  11  *
  12  * Evince is free software; you can redistribute it and/or modify it
  13  * under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * Evince is distributed in the hope that it will be useful, but
  18  * WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  25  */
  26
  27 #ifdef HAVE_CONFIG_H
  28 #include "config.h"
  29 #endif
  30
  31 #include "ev-window.h"
  32 #include "ev-window-title.h"
  33 #include "ev-navigation-action.h"
  34 #include "ev-page-action.h"
  35 #include "ev-open-recent-action.h"
  36 #include "ev-sidebar.h"
  37 #include "ev-sidebar-links.h"
  38 #include "ev-sidebar-attachments.h"
  39 #include "ev-sidebar-thumbnails.h"
  40 #include "ev-view.h"
  41 #include "ev-password.h"
  42 #include "ev-password-view.h"
  43 #include "ev-properties-dialog.h"
  44 #include "ev-file-exporter.h"
  45 #include "ev-document-thumbnails.h"
  46 #include "ev-document-links.h"
  47 #include "ev-document-fonts.h"
  48 #include "ev-document-find.h"
  49 #include "ev-document-images.h"
  50 #include "ev-document-security.h"
  51 #include "ev-document-factory.h"
  52 #include "ev-job-queue.h"
  53 #include "ev-jobs.h"
  54 #include "ev-sidebar-page.h"
  55 #include "eggfindbar.h"
  56 #include "egg-toolbar-editor.h"
  57 #include "egg-editable-toolbar.h"
  58 #include "egg-toolbars-model.h"
  59 #include "ephy-zoom.h"
  60 #include "ephy-zoom-action.h"
  61 #include "ev-application.h"
  62 #include "ev-stock-icons.h"
  63 #include "ev-metadata-manager.h"
  64 #include "ev-file-helpers.h"
  65 #include "ev-utils.h"
  66 #include "ev-history.h"
  67 #include "ev-image.h"
  68 #include "ev-message-area.h"
  69
  70 #ifdef WITH_GNOME_PRINT
  71 #include "ev-print-job.h"
  72 #include <libgnomeprintui/gnome-print-dialog.h>
  73 #endif
  74
  75 #ifdef WITH_GTK_PRINT
  76 #include <gtk/gtkprintunixdialog.h>
  77 #endif
  78
  79 #ifdef ENABLE_PDF
  80 #include <poppler.h>
  81 #endif
  82
  83 #include <glib/gstdio.h>
  84 #include <glib/gi18n.h>
  85 #include <gtk/gtk.h>
  86 #include <libgnomevfs/gnome-vfs-utils.h>
  87 #include <libgnomevfs/gnome-vfs-async-ops.h>
  88 #include <libgnomevfs/gnome-vfs-ops.h>
  89 #include <gconf/gconf-client.h>
  90
  91 #include <errno.h>
  92 #include <stdlib.h>
  93 #include <string.h>
  94 #include <unistd.h>
  95
  96 #if !GLIB_CHECK_VERSION (2, 13, 3)
  97 char *xdg_user_dir_lookup (char *type);
  98 #endif
  99
 100 typedef enum {
 101         PAGE_MODE_DOCUMENT,
 102         PAGE_MODE_PASSWORD
 103 } EvWindowPageMode;
 104
 105 typedef enum {
 106         EV_CHROME_MENUBAR       = 1 << 0,
 107         EV_CHROME_TOOLBAR       = 1 << 1,
 108         EV_CHROME_FINDBAR       = 1 << 2,
 109         EV_CHROME_RAISE_TOOLBAR = 1 << 3,
 110         EV_CHROME_FULLSCREEN_TOOLBAR    = 1 << 4,
 111         EV_CHROME_SIDEBAR       = 1 << 5,
 112         EV_CHROME_PREVIEW_TOOLBAR       = 1 << 6,
 113         EV_CHROME_NORMAL        = EV_CHROME_MENUBAR | EV_CHROME_TOOLBAR | EV_CHROME_SIDEBAR
 114 } EvChrome;
 115
 116 struct _EvWindowPrivate {
 117         /* UI */
 118         EvChrome chrome;
 119
 120         GtkWidget *main_box;
 121         GtkWidget *menubar;
 122         GtkWidget *toolbar;
 123         GtkWidget *hpaned;
 124         GtkWidget *view_box;
 125         GtkWidget *sidebar;
 126         GtkWidget *find_bar;
 127         GtkWidget *scrolled_window;
 128         GtkWidget *view;
 129         GtkWidget *message_area;
 130         GtkWidget *password_view;
 131         GtkWidget *sidebar_thumbs;
 132         GtkWidget *sidebar_links;
 133         GtkWidget *sidebar_attachments;
 134
 135         /* Dialogs */
 136         GtkWidget *properties;
 137 #ifdef WITH_PRINT
 138         GtkWidget *print_dialog;
 139 #endif
 140         GtkWidget *password_dialog;
 141
 142         /* UI Builders */
 143         GtkActionGroup   *action_group;
 144         GtkActionGroup   *view_popup_action_group;
 145         GtkActionGroup   *attachment_popup_action_group;
 146         GtkRecentManager *recent_manager;
 147         GtkActionGroup   *recent_action_group;
 148         guint             recent_ui_id;
 149         GtkUIManager     *ui_manager;
 150
 151         /* Fullscreen mode */
 152         GtkWidget *fullscreen_toolbar;
 153
 154         /* Presentation mode */
 155         guint      presentation_timeout_id;
 156
 157         /* Preview mode */
 158         GtkWidget *preview_toolbar;
 159         gchar     *print_settings_file;
 160
 161         /* Popup view */
 162         GtkWidget *view_popup;
 163         EvLink    *link;
 164         EvImage   *image;
 165
 166         /* Popup attachment */
 167         GtkWidget    *attachment_popup;
 168         GList        *attach_list;
 169
 170         /* Document */
 171         char *uri;
 172         char *local_uri;
 173         EvLinkDest *dest;
 174         gboolean unlink_temp_file;
 175         gboolean in_reload;
 176
 177         EvDocument *document;
 178         EvHistory *history;
 179         EvPageCache *page_cache;
 180         EvWindowPageMode page_mode;
 181         EvWindowTitle *title;
 182
 183         EvJob *load_job;
 184         EvJob *thumbnail_job;
 185         EvJob *save_job;
 186 #ifdef WITH_GNOME_PRINT
 187         GnomePrintJob *print_job;
 188 #endif
 189
 190 #ifdef WITH_GTK_PRINT
 191         EvJob            *print_job;
 192         gboolean          print_preview;
 193         GtkPrintJob      *gtk_print_job;
 194         GtkPrinter       *printer;
 195         GtkPrintSettings *print_settings;
 196         GtkPageSetup     *print_page_setup;
 197 #endif
 198 };
 199
 200 #define EV_WINDOW_GET_PRIVATE(object) \
 201         (G_TYPE_INSTANCE_GET_PRIVATE ((object), EV_TYPE_WINDOW, EvWindowPrivate))
 202
 203 #define PAGE_SELECTOR_ACTION    "PageSelector"
 204 #define ZOOM_CONTROL_ACTION     "ViewZoom"
 205 #define NAVIGATION_ACTION       "Navigation"
 206
 207 #define GCONF_OVERRIDE_RESTRICTIONS "/apps/evince/override_restrictions"
 208 #define GCONF_LOCKDOWN_SAVE         "/desktop/gnome/lockdown/disable_save_to_disk"
 209 #define GCONF_LOCKDOWN_PRINT        "/desktop/gnome/lockdown/disable_printing"
 210
 211 #define PRESENTATION_TIMEOUT 5
 212
 213 #define SIDEBAR_DEFAULT_SIZE    132
 214 #define LINKS_SIDEBAR_ID "links"
 215 #define THUMBNAILS_SIDEBAR_ID "thumbnails"
 216 #define ATTACHMENTS_SIDEBAR_ID "attachments"
 217
 218 #ifdef WITH_GTK_PRINT
 219 static const gchar *document_print_settings[] = {
 220         GTK_PRINT_SETTINGS_N_COPIES,
 221         GTK_PRINT_SETTINGS_COLLATE,
 222         GTK_PRINT_SETTINGS_REVERSE,
 223         GTK_PRINT_SETTINGS_NUMBER_UP,
 224         GTK_PRINT_SETTINGS_SCALE,
 225         GTK_PRINT_SETTINGS_PRINT_PAGES,
 226         GTK_PRINT_SETTINGS_PAGE_RANGES,
 227         GTK_PRINT_SETTINGS_PAGE_SET
 228 };
 229 #endif /* WITH_GTK_PRINT */
 230
 231 static void     ev_window_update_actions                (EvWindow         *ev_window);
 232 static void     ev_window_sidebar_visibility_changed_cb (EvSidebar        *ev_sidebar,
 233                                                          GParamSpec       *pspec,
 234                                                          EvWindow         *ev_window);
 235 static void     ev_window_set_page_mode                 (EvWindow         *window,
 236                                                          EvWindowPageMode  page_mode);
 237 static void     ev_window_load_job_cb                   (EvJobLoad        *job,
 238                                                          gpointer          data);
 239 static void     ev_window_set_icon_from_thumbnail       (EvJobThumbnail   *job,
 240                                                          EvWindow         *ev_window);
 241 #ifdef WITH_GTK_PRINT
 242 static void     ev_window_print_job_cb                  (EvJobPrint       *job,
 243                                                          EvWindow         *window);
 244 #endif
 245 static void     ev_window_save_job_cb                   (EvJobSave        *save,
 246                                                          EvWindow         *window);
 247 static void     ev_window_sizing_mode_changed_cb        (EvView           *view,
 248                                                          GParamSpec       *pspec,
 249                                                          EvWindow         *ev_window);
 250 static void     ev_window_zoom_changed_cb               (EvView           *view,
 251                                                          GParamSpec       *pspec,
 252                                                          EvWindow         *ev_window);
 253 static void     ev_window_add_recent                    (EvWindow         *window,
 254                                                          const char       *filename);
 255 static void     ev_window_run_fullscreen                (EvWindow         *window);
 256 static void     ev_window_stop_fullscreen               (EvWindow         *window);
 257 static void     ev_window_cmd_view_fullscreen           (GtkAction        *action,
 258                                                          EvWindow         *window);
 259 static void     ev_window_run_presentation              (EvWindow         *window);
 260 static void     ev_window_stop_presentation             (EvWindow         *window);
 261 static void     ev_window_cmd_view_presentation         (GtkAction        *action,
 262                                                          EvWindow         *window);
 263 static void     ev_window_run_preview                   (EvWindow         *window);
 264 static void     ev_view_popup_cmd_open_link             (GtkAction        *action,
 265                                                          EvWindow         *window);
 266 static void     ev_view_popup_cmd_open_link_new_window  (GtkAction        *action,
 267                                                          EvWindow         *window);
 268 static void     ev_view_popup_cmd_copy_link_address     (GtkAction        *action,
 269                                                          EvWindow         *window);
 270 static void     ev_view_popup_cmd_save_image_as         (GtkAction        *action,
 271                                                          EvWindow         *window);
 272 static void     ev_view_popup_cmd_copy_image            (GtkAction        *action,
 273                                                          EvWindow         *window);
 274 static void     ev_attachment_popup_cmd_open_attachment (GtkAction        *action,
 275                                                          EvWindow         *window);
 276 static void     ev_attachment_popup_cmd_save_attachment_as (GtkAction     *action,
 277                                                          EvWindow         *window);
 278 static void     ev_window_cmd_view_best_fit             (GtkAction        *action,
 279                                                          EvWindow         *ev_window);
 280 static void     ev_window_cmd_view_page_width           (GtkAction        *action,
 281                                                          EvWindow         *ev_window);
 282 static void     view_handle_link_cb                     (EvView           *view,
 283                                                          EvLink           *link,
 284                                                          EvWindow         *window);
 285 static void     ev_window_cmd_edit_find                 (GtkAction        *action,
 286                                                          EvWindow         *ev_window);
 287 static void     find_bar_search_changed_cb              (EggFindBar       *find_bar,
 288                                                          GParamSpec       *param,
 289                                                          EvWindow         *ev_window);
 290
 291 G_DEFINE_TYPE (EvWindow, ev_window, GTK_TYPE_WINDOW)
 292
 293 static void
 294 ev_window_set_action_sensitive (EvWindow   *ev_window,
 295                                 const char *name,
 296                                 gboolean    sensitive)
 297 {
 298         GtkAction *action = gtk_action_group_get_action (ev_window->priv->action_group,
 299                                                          name);
 300         gtk_action_set_sensitive (action, sensitive);
 301 }
 302
 303
 304 static void
 305 ev_window_setup_action_sensitivity (EvWindow *ev_window)
 306 {
 307         EvDocument *document = ev_window->priv->document;
 308         const EvDocumentInfo *info = NULL;
 309
 310         gboolean has_document = FALSE;
 311         gboolean ok_to_print = TRUE;
 312         gboolean ok_to_copy = TRUE;
 313         gboolean has_properties = TRUE;
 314         gboolean override_restrictions = TRUE;
 315         gboolean can_get_text = FALSE;
 316         gboolean has_pages = FALSE;
 317         gboolean can_find = FALSE;
 318
 319         GConfClient *client;
 320
 321         if (document) {
 322                 has_document = TRUE;
 323                 info = ev_page_cache_get_info (ev_window->priv->page_cache);
 324         }
 325
 326         if (has_document && ev_window->priv->page_cache) {
 327                 has_pages = ev_page_cache_get_n_pages (ev_window->priv->page_cache) > 0;
 328         }
 329
 330         if (!info || info->fields_mask == 0) {
 331                 has_properties = FALSE;
 332         }
 333
 334         if (has_document && EV_IS_SELECTION (document)) {
 335                 can_get_text = TRUE;
 336         }
 337
 338         if (has_pages && EV_IS_DOCUMENT_FIND (document)) {
 339                 can_find = TRUE;
 340         }
 341
 342         client = gconf_client_get_default ();
 343         override_restrictions = gconf_client_get_bool (client,
 344                                                        GCONF_OVERRIDE_RESTRICTIONS,
 345                                                        NULL);
 346         if (!override_restrictions && info && info->fields_mask & EV_DOCUMENT_INFO_PERMISSIONS) {
 347                 ok_to_print = (info->permissions & EV_DOCUMENT_PERMISSIONS_OK_TO_PRINT);
 348                 ok_to_copy = (info->permissions & EV_DOCUMENT_PERMISSIONS_OK_TO_COPY);
 349         }
 350
 351         if (has_document && !EV_IS_FILE_EXPORTER(document))
 352                 ok_to_print = FALSE;
 353
 354
 355         if (gconf_client_get_bool (client, GCONF_LOCKDOWN_SAVE, NULL)) {
 356                 ok_to_copy = FALSE;
 357         }
 358
 359         if (gconf_client_get_bool (client, GCONF_LOCKDOWN_PRINT, NULL)) {
 360                 ok_to_print = FALSE;
 361         }
 362 #ifndef WITH_PRINT
 363         ok_to_print = FALSE;
 364 #endif
 365         g_object_unref (client);
 366
 367
 368         /* File menu */
 369         ev_window_set_action_sensitive (ev_window, "FileOpenCopy", has_document);
 370         ev_window_set_action_sensitive (ev_window, "FileSaveAs", has_document && ok_to_copy);
 371
 372 #ifdef WITH_GTK_PRINT
 373         ev_window_set_action_sensitive (ev_window, "FilePrintSetup", has_pages && ok_to_print);
 374 #endif
 375
 376 #ifdef WITH_GNOME_PRINT
 377         ev_window_set_action_sensitive (ev_window, "FilePrintSetup", FALSE);
 378 #endif
 379
 380         ev_window_set_action_sensitive (ev_window, "FilePrint", has_pages && ok_to_print);
 381         ev_window_set_action_sensitive (ev_window, "FileProperties", has_document && has_properties);
 382
 383         /* Edit menu */
 384         ev_window_set_action_sensitive (ev_window, "EditSelectAll", has_pages && can_get_text);
 385         ev_window_set_action_sensitive (ev_window, "EditFind", can_find);
 386         ev_window_set_action_sensitive (ev_window, "Slash", can_find);
 387         ev_window_set_action_sensitive (ev_window, "EditRotateLeft", has_pages);
 388         ev_window_set_action_sensitive (ev_window, "EditRotateRight", has_pages);
 389
 390         /* View menu */
 391         ev_window_set_action_sensitive (ev_window, "ViewContinuous", has_pages);
 392         ev_window_set_action_sensitive (ev_window, "ViewDual", has_pages);
 393         ev_window_set_action_sensitive (ev_window, "ViewBestFit", has_pages);
 394         ev_window_set_action_sensitive (ev_window, "ViewPageWidth", has_pages);
 395         ev_window_set_action_sensitive (ev_window, "ViewReload", has_pages);
 396         ev_window_set_action_sensitive (ev_window, "ViewAutoscroll", has_pages);
 397
 398         /* Toolbar-specific actions: */
 399         ev_window_set_action_sensitive (ev_window, PAGE_SELECTOR_ACTION, has_pages);
 400         ev_window_set_action_sensitive (ev_window, ZOOM_CONTROL_ACTION,  has_pages);
 401         ev_window_set_action_sensitive (ev_window, NAVIGATION_ACTION,  FALSE);
 402         ev_window_set_action_sensitive (ev_window, "PreviewPrint", has_pages && ok_to_print);
 403
 404         ev_window_update_actions (ev_window);
 405 }
 406
 407 static void
 408 ev_window_update_actions (EvWindow *ev_window)
 409 {
 410         EvView *view = EV_VIEW (ev_window->priv->view);
 411         int n_pages = 0, page = -1;
 412         gboolean has_pages = FALSE;
 413         gboolean presentation_mode;
 414
 415         if (ev_window->priv->document && ev_window->priv->page_cache) {
 416                 page = ev_page_cache_get_current_page (ev_window->priv->page_cache);
 417                 n_pages = ev_page_cache_get_n_pages (ev_window->priv->page_cache);
 418                 has_pages = n_pages > 0;
 419         }
 420
 421         ev_window_set_action_sensitive (ev_window, "EditCopy",
 422                                         has_pages &&
 423                                         ev_view_get_has_selection (view));
 424         ev_window_set_action_sensitive (ev_window, "EditFindNext",
 425                                         ev_view_can_find_next (view));
 426         ev_window_set_action_sensitive (ev_window, "EditFindPrevious",
 427                                         ev_view_can_find_previous (view));
 428
 429         presentation_mode = ev_view_get_presentation (view);
 430
 431         ev_window_set_action_sensitive (ev_window, "ViewZoomIn",
 432                                         has_pages &&
 433                                         ev_view_can_zoom_in (view) &&
 434                                         !presentation_mode);
 435         ev_window_set_action_sensitive (ev_window, "ViewZoomOut",
 436                                         has_pages &&
 437                                         ev_view_can_zoom_out (view) &&
 438                                         !presentation_mode);
 439
 440         /* Go menu */
 441         if (has_pages) {
 442                 ev_window_set_action_sensitive (ev_window, "GoPreviousPage", page > 0);
 443                 ev_window_set_action_sensitive (ev_window, "GoNextPage", page < n_pages - 1);
 444                 ev_window_set_action_sensitive (ev_window, "GoFirstPage", page > 0);
 445                 ev_window_set_action_sensitive (ev_window, "GoLastPage", page < n_pages - 1);
 446         } else {
 447                 ev_window_set_action_sensitive (ev_window, "GoFirstPage", FALSE);
 448                 ev_window_set_action_sensitive (ev_window, "GoPreviousPage", FALSE);
 449                 ev_window_set_action_sensitive (ev_window, "GoNextPage", FALSE);
 450                 ev_window_set_action_sensitive (ev_window, "GoLastPage", FALSE);
 451         }
 452
 453         if (has_pages &&
 454             ev_view_get_sizing_mode (view) != EV_SIZING_FIT_WIDTH &&
 455             ev_view_get_sizing_mode (view) != EV_SIZING_BEST_FIT) {
 456                 GtkAction *action;
 457                 float      zoom;
 458                 float      real_zoom;
 459
 460                 action = gtk_action_group_get_action (ev_window->priv->action_group,
 461                                                       ZOOM_CONTROL_ACTION);
 462
 463                 real_zoom = ev_view_get_zoom (EV_VIEW (ev_window->priv->view));
 464                 real_zoom *= 72.0 / get_screen_dpi (GTK_WINDOW (ev_window));
 465                 zoom = ephy_zoom_get_nearest_zoom_level (real_zoom);
 466
 467                 ephy_zoom_action_set_zoom_level (EPHY_ZOOM_ACTION (action), zoom);
 468         }
 469 }
 470
 471 static void
 472 ev_window_set_view_accels_sensitivity (EvWindow *window, gboolean sensitive)
 473 {
 474         gboolean can_find;
 475
 476         can_find = window->priv->document &&
 477             EV_IS_DOCUMENT_FIND (window->priv->document);
 478
 479         if (window->priv->action_group) {
 480                 ev_window_set_action_sensitive (window, "PageDown", sensitive);
 481                 ev_window_set_action_sensitive (window, "PageUp", sensitive);
 482                 ev_window_set_action_sensitive (window, "Space", sensitive);
 483                 ev_window_set_action_sensitive (window, "ShiftSpace", sensitive);
 484                 ev_window_set_action_sensitive (window, "BackSpace", sensitive);
 485                 ev_window_set_action_sensitive (window, "ShiftBackSpace", sensitive);
 486                 ev_window_set_action_sensitive (window, "Return", sensitive);
 487                 ev_window_set_action_sensitive (window, "ShiftReturn", sensitive);
 488                 ev_window_set_action_sensitive (window, "Plus", sensitive);
 489                 ev_window_set_action_sensitive (window, "Minus", sensitive);
 490                 ev_window_set_action_sensitive (window, "KpPlus", sensitive);
 491                 ev_window_set_action_sensitive (window, "KpMinus", sensitive);
 492                 ev_window_set_action_sensitive (window, "Equal", sensitive);
 493
 494                 ev_window_set_action_sensitive (window, "Slash", sensitive && can_find);
 495         }
 496 }
 497
 498 static void
 499 set_widget_visibility (GtkWidget *widget, gboolean visible)
 500 {
 501         g_assert (GTK_IS_WIDGET (widget));
 502
 503         if (visible)
 504                 gtk_widget_show (widget);
 505         else
 506                 gtk_widget_hide (widget);
 507 }
 508
 509 static void
 510 update_chrome_visibility (EvWindow *window)
 511 {
 512         EvWindowPrivate *priv = window->priv;
 513         gboolean menubar, toolbar, findbar, fullscreen_toolbar, sidebar;
 514         gboolean fullscreen_mode, presentation, fullscreen;
 515         gboolean preview_toolbar;
 516
 517         presentation = ev_view_get_presentation (EV_VIEW (priv->view));
 518         fullscreen = ev_view_get_fullscreen (EV_VIEW (priv->view));
 519         fullscreen_mode = fullscreen || presentation;
 520
 521         menubar = (priv->chrome & EV_CHROME_MENUBAR) != 0 && !fullscreen_mode;
 522         toolbar = ((priv->chrome & EV_CHROME_TOOLBAR) != 0  ||
 523                    (priv->chrome & EV_CHROME_RAISE_TOOLBAR) != 0) && !fullscreen_mode;
 524         fullscreen_toolbar = ((priv->chrome & EV_CHROME_FULLSCREEN_TOOLBAR) != 0 ||
 525                               (priv->chrome & EV_CHROME_RAISE_TOOLBAR) != 0) && fullscreen;
 526         findbar = (priv->chrome & EV_CHROME_FINDBAR) != 0;
 527         sidebar = (priv->chrome & EV_CHROME_SIDEBAR) != 0 && !presentation;
 528         preview_toolbar = (priv->chrome& EV_CHROME_PREVIEW_TOOLBAR);
 529
 530         set_widget_visibility (priv->menubar, menubar);
 531         set_widget_visibility (priv->toolbar, toolbar);
 532         set_widget_visibility (priv->find_bar, findbar);
 533         set_widget_visibility (priv->sidebar, sidebar);
 534
 535         if (priv->preview_toolbar)
 536                 set_widget_visibility (priv->preview_toolbar, preview_toolbar);
 537
 538         ev_window_set_action_sensitive (window, "EditToolbar", toolbar);
 539         gtk_widget_set_sensitive (priv->menubar, menubar);
 540
 541         if (priv->fullscreen_toolbar != NULL) {
 542                 set_widget_visibility (priv->fullscreen_toolbar, fullscreen_toolbar);
 543         }
 544 }
 545
 546 static void
 547 update_chrome_flag (EvWindow *window, EvChrome flag, gboolean active)
 548 {
 549         EvWindowPrivate *priv = window->priv;
 550
 551         if (active) {
 552                 priv->chrome |= flag;
 553         } else {
 554                 priv->chrome &= ~flag;
 555         }
 556 }
 557
 558 static void
 559 update_sizing_buttons (EvWindow *window)
 560 {
 561         GtkActionGroup *action_group = window->priv->action_group;
 562         GtkAction *action;
 563         gboolean best_fit, page_width;
 564         EvSizingMode sizing_mode;
 565
 566         if (window->priv->view == NULL)
 567                 return;
 568
 569         g_object_get (window->priv->view,
 570                       "sizing_mode", &sizing_mode,
 571                       NULL);
 572
 573         switch (sizing_mode) {
 574                 case EV_SIZING_BEST_FIT:
 575                         best_fit = TRUE;
 576                         page_width = FALSE;
 577                         break;
 578                 case EV_SIZING_FIT_WIDTH:
 579                         best_fit = FALSE;
 580                         page_width = TRUE;
 581                         break;
 582                 default:
 583                         best_fit = page_width = FALSE;
 584                         break;
 585         }
 586
 587         action = gtk_action_group_get_action (action_group, "ViewBestFit");
 588         g_signal_handlers_block_by_func
 589                 (action, G_CALLBACK (ev_window_cmd_view_best_fit), window);
 590         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), best_fit);
 591         g_signal_handlers_unblock_by_func
 592                 (action, G_CALLBACK (ev_window_cmd_view_best_fit), window);
 593
 594         action = gtk_action_group_get_action (action_group, "ViewPageWidth");
 595         g_signal_handlers_block_by_func
 596                 (action, G_CALLBACK (ev_window_cmd_view_page_width), window);
 597         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), page_width);
 598         g_signal_handlers_unblock_by_func
 599                 (action, G_CALLBACK (ev_window_cmd_view_page_width), window);
 600
 601         action = gtk_action_group_get_action (window->priv->action_group,
 602                                               ZOOM_CONTROL_ACTION);
 603         if (best_fit) {
 604                 ephy_zoom_action_set_zoom_level (EPHY_ZOOM_ACTION (action),
 605                                                  EPHY_ZOOM_BEST_FIT);
 606         } else if (page_width) {
 607                 ephy_zoom_action_set_zoom_level (EPHY_ZOOM_ACTION (action),
 608                                                  EPHY_ZOOM_FIT_WIDTH);
 609         }
 610 }
 611
 612 /**
 613  * ev_window_is_empty:
 614  * @ev_window: The instance of the #EvWindow.
 615  *
 616  * It does look if there is any document loaded or if there is any job to load
 617  * a document.
 618  *
 619  * Returns: %TRUE if there isn't any document loaded or any any documente to be
 620  *          loaded, %FALSE in other case.
 621  */
 622 gboolean
 623 ev_window_is_empty (const EvWindow *ev_window)
 624 {
 625         g_return_val_if_fail (EV_IS_WINDOW (ev_window), FALSE);
 626
 627         return (ev_window->priv->document == NULL) &&
 628                 (ev_window->priv->load_job == NULL);
 629 }
 630
 631 static void
 632 ev_window_set_message_area (EvWindow  *window,
 633                             GtkWidget *area)
 634 {
 635         if (window->priv->message_area == area)
 636                 return;
 637
 638         if (window->priv->message_area)
 639                 gtk_widget_destroy (window->priv->message_area);
 640         window->priv->message_area = area;
 641
 642         if (!area)
 643                 return;
 644
 645         gtk_box_pack_start (GTK_BOX (window->priv->view_box),
 646                             window->priv->message_area,
 647                             FALSE, FALSE, 0);
 648         gtk_box_reorder_child (GTK_BOX (window->priv->view_box),
 649                                window->priv->message_area, 0);
 650         g_object_add_weak_pointer (G_OBJECT (window->priv->message_area),
 651                                    (gpointer) &(window->priv->message_area));
 652 }
 653
 654 static void
 655 ev_window_error_message_response_cb (EvMessageArea *area,
 656                                      gint           response_id,
 657                                      EvWindow      *window)
 658 {
 659         ev_window_set_message_area (window, NULL);
 660 }
 661
 662 static void
 663 ev_window_error_message (GtkWindow *window, const gchar *msg, GError *error)
 664 {
 665         GtkWidget *area;
 666
 667         if (EV_WINDOW (window)->priv->message_area)
 668                 return;
 669
 670         area = ev_message_area_new (GTK_MESSAGE_ERROR,
 671                                     msg,
 672                                     GTK_STOCK_CLOSE,
 673                                     GTK_RESPONSE_CANCEL,
 674                                     NULL);
 675         if (error)
 676                 ev_message_area_set_secondary_text (EV_MESSAGE_AREA (area), error->message);
 677         g_signal_connect (area, "response",
 678                           G_CALLBACK (ev_window_error_message_response_cb),
 679                           window);
 680         gtk_widget_show (area);
 681         ev_window_set_message_area (EV_WINDOW (window), area);
 682 }
 683
 684 static void
 685 find_changed_cb (EvDocument *document, int page, EvWindow *ev_window)
 686 {
 687         ev_window_update_actions (ev_window);
 688 }
 689
 690 static void
 691 page_changed_cb (EvPageCache *page_cache,
 692                  gint         page,
 693                  EvWindow    *ev_window)
 694 {
 695         ev_window_update_actions (ev_window);
 696
 697         if (!ev_window_is_empty (ev_window))
 698                 ev_metadata_manager_set_int (ev_window->priv->uri, "page", page);
 699 }
 700
 701 typedef struct _FindTask {
 702         const gchar *page_label;
 703         gchar *chapter;
 704 } FindTask;
 705
 706 static gboolean
 707 ev_window_find_chapter (GtkTreeModel *tree_model,
 708                         GtkTreePath  *path,
 709                         GtkTreeIter  *iter,
 710                         gpointer      data)
 711 {
 712         FindTask *task = (FindTask *)data;
 713         gchar *page_string;
 714
 715         gtk_tree_model_get (tree_model, iter,
 716                             EV_DOCUMENT_LINKS_COLUMN_PAGE_LABEL, &page_string,
 717                             -1);
 718
 719         if (!page_string)
 720                 return FALSE;
 721
 722         if (!strcmp (page_string, task->page_label)) {
 723                 gtk_tree_model_get (tree_model, iter,
 724                                     EV_DOCUMENT_LINKS_COLUMN_MARKUP, &task->chapter,
 725                                     -1);
 726                 g_free (page_string);
 727                 return TRUE;
 728         }
 729
 730         g_free (page_string);
 731         return FALSE;
 732 }
 733
 734 static void
 735 ev_window_add_history (EvWindow *window, gint page, EvLink *link)
 736 {
 737         gchar *page_label = NULL;
 738         gchar *link_title;
 739         FindTask find_task;
 740         EvLink *real_link;
 741         EvLinkAction *action;
 742         EvLinkDest *dest;
 743
 744         if (window->priv->history == NULL)
 745                 return;
 746
 747         if (!EV_IS_DOCUMENT_LINKS (window->priv->document))
 748                 return;
 749
 750         if (link) {
 751                 action = g_object_ref (ev_link_get_action (link));
 752                 dest = ev_link_action_get_dest (action);
 753                 page = ev_link_dest_get_page (dest);
 754                 page_label = ev_view_page_label_from_dest (EV_VIEW (window->priv->view), dest);
 755         } else {
 756                 dest = ev_link_dest_new_page (page);
 757                 action = ev_link_action_new_dest (dest);
 758                 page_label = ev_page_cache_get_page_label (window->priv->page_cache, page);
 759         }
 760
 761         if (!page_label)
 762                 return;
 763
 764         find_task.page_label = page_label;
 765         find_task.chapter = NULL;
 766
 767         if (ev_document_links_has_document_links (EV_DOCUMENT_LINKS (window->priv->document))) {
 768                 GtkTreeModel *model;
 769
 770                 g_object_get (G_OBJECT (window->priv->sidebar_links), "model", &model, NULL);
 771
 772                 if (model) {
 773                         gtk_tree_model_foreach (model,
 774                                                 ev_window_find_chapter,
 775                                                 &find_task);
 776
 777                         g_object_unref (model);
 778                 }
 779         }
 780
 781         if (find_task.chapter)
 782                 link_title = g_strdup_printf (_("Page %s - %s"), page_label, find_task.chapter);
 783         else
 784                 link_title = g_strdup_printf (_("Page %s"), page_label);
 785
 786         real_link = ev_link_new (link_title, action);
 787
 788         ev_history_add_link (window->priv->history, real_link);
 789
 790         g_free (find_task.chapter);
 791         g_free (link_title);
 792         g_free (page_label);
 793         g_object_unref (real_link);
 794 }
 795
 796 static void
 797 view_handle_link_cb (EvView *view, EvLink *link, EvWindow *window)
 798 {
 799         int current_page = ev_page_cache_get_current_page (window->priv->page_cache);
 800
 801         ev_window_add_history (window, 0, link);
 802         ev_window_add_history (window, current_page, NULL);
 803 }
 804
 805 static void
 806 history_changed_cb (EvPageCache *page_cache,
 807                     gint         page,
 808                     EvWindow    *window)
 809 {
 810         int current_page = ev_page_cache_get_current_page (window->priv->page_cache);
 811
 812         ev_window_add_history (window, page, NULL);
 813         ev_window_add_history (window, current_page, NULL);
 814
 815         return;
 816 }
 817
 818 static void
 819 update_document_mode (EvWindow *window, EvDocumentMode mode)
 820 {
 821         if (mode == EV_DOCUMENT_MODE_PRESENTATION) {
 822                 ev_window_run_presentation (window);
 823         }
 824         else if (mode == EV_DOCUMENT_MODE_FULL_SCREEN) {
 825                 ev_window_run_fullscreen (window);
 826         }
 827 }
 828
 829 static void
 830 setup_document_from_metadata (EvWindow *window)
 831 {
 832         char *uri = window->priv->uri;
 833         GValue page = { 0, };
 834         gint n_pages;
 835         gint new_page;
 836
 837         /* View the previously shown page, but make sure to not open a document on
 838          * the last page, since closing it on the last page most likely means the
 839          * user was finished reading the document. In that case, reopening should
 840          * show the first page. */
 841         if (uri && ev_metadata_manager_get (uri, "page", &page, TRUE)) {
 842                 n_pages = ev_page_cache_get_n_pages (window->priv->page_cache);
 843                 new_page = CLAMP (g_value_get_int (&page), 0, n_pages - 1);
 844                 if (!window->priv->in_reload && new_page == n_pages - 1)
 845                         new_page = 0;
 846                 ev_page_cache_set_current_page (window->priv->page_cache,
 847                                                 new_page);
 848                 g_value_unset (&page);
 849         }
 850 }
 851
 852 static void
 853 setup_chrome_from_metadata (EvWindow *window)
 854 {
 855         EvChrome chrome = EV_CHROME_NORMAL;
 856         GValue show_toolbar = { 0, };
 857
 858         if (ev_metadata_manager_get (NULL, "show_toolbar", &show_toolbar, FALSE)) {
 859                 if (!g_value_get_boolean (&show_toolbar))
 860                         chrome &= ~EV_CHROME_TOOLBAR;
 861                 g_value_unset (&show_toolbar);
 862         }
 863         window->priv->chrome = chrome;
 864 }
 865
 866 static void
 867 setup_sidebar_from_metadata (EvWindow *window, EvDocument *document)
 868 {
 869         char *uri = window->priv->uri;
 870         GtkWidget *sidebar = window->priv->sidebar;
 871         GtkWidget *links = window->priv->sidebar_links;
 872         GtkWidget *thumbs = window->priv->sidebar_thumbs;
 873         GtkWidget *attachments = window->priv->sidebar_attachments;
 874         GValue sidebar_size = { 0, };
 875         GValue sidebar_page = { 0, };
 876         GValue sidebar_visibility = { 0, };
 877
 878         if (ev_metadata_manager_get (uri, "sidebar_size", &sidebar_size, FALSE)) {
 879                 gtk_paned_set_position (GTK_PANED (window->priv->hpaned),
 880                                         g_value_get_int (&sidebar_size));
 881                 g_value_unset(&sidebar_size);
 882         }
 883
 884         if (document && ev_metadata_manager_get (uri, "sidebar_page", &sidebar_page, FALSE)) {
 885                 const char *page_id = g_value_get_string (&sidebar_page);
 886
 887                 if (strcmp (page_id, LINKS_SIDEBAR_ID) == 0 && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (links), document)) {
 888                         ev_sidebar_set_page (EV_SIDEBAR (sidebar), links);
 889                 } else if (strcmp (page_id, THUMBNAILS_SIDEBAR_ID) && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (thumbs), document)) {
 890                         ev_sidebar_set_page (EV_SIDEBAR (sidebar), thumbs);
 891                 } else if (strcmp (page_id, ATTACHMENTS_SIDEBAR_ID) && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (attachments), document)) {
 892                         ev_sidebar_set_page (EV_SIDEBAR (sidebar), attachments);
 893                 }
 894                 g_value_unset (&sidebar_page);
 895         } else if (document && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (links), document)) {
 896                 ev_sidebar_set_page (EV_SIDEBAR (sidebar), links);
 897         }
 898
 899         if (ev_metadata_manager_get (uri, "sidebar_visibility", &sidebar_visibility, FALSE)) {
 900                 update_chrome_flag (window, EV_CHROME_SIDEBAR, g_value_get_boolean (&sidebar_visibility));
 901                 g_value_unset (&sidebar_visibility);
 902                 update_chrome_visibility (window);
 903         }
 904 }
 905
 906 static void
 907 setup_size_from_metadata (EvWindow *window)
 908 {
 909         char *uri = window->priv->uri;
 910         GValue width = { 0, };
 911         GValue height = { 0, };
 912         GValue width_ratio = { 0, };
 913         GValue height_ratio = { 0, };
 914         GValue maximized = { 0, };
 915         GValue x = { 0, };
 916         GValue y = { 0, };
 917
 918         if (ev_metadata_manager_get (uri, "window_maximized", &maximized, FALSE)) {
 919                 if (g_value_get_boolean (&maximized)) {
 920                         gtk_window_maximize (GTK_WINDOW (window));
 921                         return;
 922                 } else {
 923                         gtk_window_unmaximize (GTK_WINDOW (window));
 924                 }
 925                 g_value_unset (&maximized);
 926         }
 927
 928         if (ev_metadata_manager_get (uri, "window_x", &x, TRUE) &&
 929             ev_metadata_manager_get (uri, "window_y", &y, TRUE)) {
 930                 gtk_window_move (GTK_WINDOW (window), g_value_get_int (&x),
 931                                  g_value_get_int (&y));
 932                 g_value_unset (&x);
 933                 g_value_unset (&y);
 934         }
 935
 936         if (ev_metadata_manager_get (uri, "window_width", &width, TRUE) &&
 937             ev_metadata_manager_get (uri, "window_height", &height, TRUE)) {
 938                 gtk_window_resize (GTK_WINDOW (window),
 939                                    g_value_get_int (&width),
 940                                    g_value_get_int (&height));
 941                 g_value_unset (&width);
 942                 g_value_unset (&height);
 943                 return;
 944         }
 945
 946         if (window->priv->page_cache &&
 947             ev_metadata_manager_get (uri, "window_width_ratio", &width_ratio, FALSE) &&
 948             ev_metadata_manager_get (uri, "window_height_ratio", &height_ratio, FALSE)) {
 949
 950                 gint document_width;
 951                 gint document_height;
 952
 953                 GdkScreen *screen;
 954
 955                 gint request_width;
 956                 gint request_height;
 957
 958                 ev_page_cache_get_max_width (window->priv->page_cache,
 959                                              0, 1.0,
 960                                              &document_width);
 961                 ev_page_cache_get_max_height (window->priv->page_cache,
 962                                              0, 1.0,
 963                                              &document_height);
 964
 965                 request_width = g_value_get_double (&width_ratio) * document_width;
 966                 request_height = g_value_get_double (&height_ratio) * document_height;
 967
 968                 screen = gtk_window_get_screen (GTK_WINDOW (window));
 969
 970                 if (screen) {
 971                         request_width = MIN (request_width, gdk_screen_get_width (screen));
 972                         request_height = MIN (request_width, gdk_screen_get_height (screen));
 973                 }
 974
 975                 gtk_window_resize (GTK_WINDOW (window),
 976                                    request_width,
 977                                    request_height);
 978                 g_value_unset (&width_ratio);
 979                 g_value_unset (&height_ratio);
 980         }
 981 }
 982
 983 static void
 984 setup_view_from_metadata (EvWindow *window)
 985 {
 986         EvView *view = EV_VIEW (window->priv->view);
 987         char *uri = window->priv->uri;
 988         GEnumValue *enum_value;
 989         GValue sizing_mode = { 0, };
 990         GValue zoom = { 0, };
 991         GValue continuous = { 0, };
 992         GValue dual_page = { 0, };
 993         GValue presentation = { 0, };
 994         GValue fullscreen = { 0, };
 995         GValue rotation = { 0, };
 996         GValue maximized = { 0, };
 997
 998         /* Maximized */
 999         if (ev_metadata_manager_get (uri, "window_maximized", &maximized, FALSE)) {
1000                 if (g_value_get_boolean (&maximized)) {
1001                         gtk_window_maximize (GTK_WINDOW (window));
1002                 } else {
1003                         gtk_window_unmaximize (GTK_WINDOW (window));
1004                 }
1005                 g_value_unset (&maximized);
1006         }
1007
1008         /* Sizing mode */
1009         if (ev_metadata_manager_get (uri, "sizing_mode", &sizing_mode, FALSE)) {
1010                 enum_value = g_enum_get_value_by_nick
1011                         (EV_SIZING_MODE_CLASS, g_value_get_string (&sizing_mode));
1012                 g_value_unset (&sizing_mode);
1013                 ev_view_set_sizing_mode (view, enum_value->value);
1014         }
1015
1016         /* Zoom */
1017         if (ev_metadata_manager_get (uri, "zoom", &zoom, FALSE) &&
1018             ev_view_get_sizing_mode (view) == EV_SIZING_FREE) {
1019                 gdouble zoom_value;
1020
1021                 zoom_value = g_value_get_double (&zoom);
1022                 zoom_value *= get_screen_dpi (GTK_WINDOW (window)) / 72.0;
1023                 ev_view_set_zoom (view, zoom_value, FALSE);
1024                 g_value_unset (&zoom);
1025         }
1026
1027         /* Continuous */
1028         if (ev_metadata_manager_get (uri, "continuous", &continuous, FALSE)) {
1029                 ev_view_set_continuous (view, g_value_get_boolean (&continuous));
1030                 g_value_unset (&continuous);
1031         }
1032
1033         /* Dual page */
1034         if (ev_metadata_manager_get (uri, "dual-page", &dual_page, FALSE)) {
1035                 ev_view_set_dual_page (view, g_value_get_boolean (&dual_page));
1036                 g_value_unset (&dual_page);
1037         }
1038
1039         /* Presentation */
1040         if (ev_metadata_manager_get (uri, "presentation", &presentation, FALSE)) {
1041                 if (g_value_get_boolean (&presentation) && uri) {
1042                         ev_window_run_presentation (window);
1043                 }
1044                 g_value_unset (&presentation);
1045         }
1046
1047         /* Fullscreen */
1048         if (ev_metadata_manager_get (uri, "fullscreen", &fullscreen, FALSE)) {
1049                 if (g_value_get_boolean (&fullscreen) && uri) {
1050                         ev_window_run_fullscreen (window);
1051                 }
1052                 g_value_unset (&fullscreen);
1053         }
1054
1055         /* Rotation */
1056         if (ev_metadata_manager_get (uri, "rotation", &rotation, TRUE)) {
1057                 if (g_value_get_int (&rotation)) {
1058                         switch (g_value_get_int (&rotation)) {
1059                                 case 90:
1060                                         ev_view_set_rotation (view, 90);
1061                                         break;
1062                                 case 180:
1063                                         ev_view_set_rotation (view, 180);
1064                                         break;
1065                                 case 270:
1066                                         ev_view_set_rotation (view, 270);
1067                                         break;
1068                                 default:
1069                                         break;
1070                         }
1071                 }
1072                 g_value_unset (&rotation);
1073         }
1074 }
1075
1076 static void
1077 ev_window_clear_thumbnail_job (EvWindow *ev_window)
1078 {
1079         if (ev_window->priv->thumbnail_job != NULL) {
1080                 ev_job_queue_remove_job (ev_window->priv->thumbnail_job);
1081
1082                 g_signal_handlers_disconnect_by_func (ev_window->priv->thumbnail_job,
1083                                                       ev_window_set_icon_from_thumbnail,
1084                                                       ev_window);
1085                 g_object_unref (ev_window->priv->thumbnail_job);
1086                 ev_window->priv->thumbnail_job = NULL;
1087         }
1088 }
1089
1090 static void
1091 ev_window_set_icon_from_thumbnail (EvJobThumbnail *job,
1092                                    EvWindow       *ev_window)
1093 {
1094         if (job->thumbnail) {
1095                 gtk_window_set_icon (GTK_WINDOW (ev_window),
1096                                      job->thumbnail);
1097         }
1098
1099         ev_window_clear_thumbnail_job (ev_window);
1100 }
1101
1102 static void
1103 ev_window_refresh_window_thumbnail (EvWindow *ev_window, int rotation)
1104 {
1105
1106         EvRenderContext *rc;
1107         gint page_width, page_height;
1108         gdouble scale;
1109         EvDocument *document = ev_window->priv->document;
1110
1111         if (!EV_IS_DOCUMENT_THUMBNAILS (document)) {
1112                 return;
1113         }
1114
1115         ev_window_clear_thumbnail_job (ev_window);
1116
1117         ev_page_cache_get_size (ev_window->priv->page_cache,
1118                                 0, 0, 1.0,
1119                                 &page_width, &page_height);
1120         scale = (gdouble)128 / (gdouble)page_width;
1121
1122         rc = ev_render_context_new (rotation, 0, scale);
1123
1124         ev_window->priv->thumbnail_job = ev_job_thumbnail_new (document, rc);
1125         g_signal_connect (ev_window->priv->thumbnail_job, "finished",
1126                           G_CALLBACK (ev_window_set_icon_from_thumbnail),
1127                           ev_window);
1128         ev_job_queue_add_job (EV_JOB (ev_window->priv->thumbnail_job), EV_JOB_PRIORITY_LOW);
1129         g_object_unref (rc);
1130 }
1131
1132 static gboolean
1133 ev_window_setup_document (EvWindow *ev_window)
1134 {
1135         const EvDocumentInfo *info;
1136         EvDocument *document = ev_window->priv->document;
1137         EvSidebar *sidebar = EV_SIDEBAR (ev_window->priv->sidebar);
1138         GtkAction *action;
1139
1140         if (EV_IS_DOCUMENT_FIND (document)) {
1141                 g_signal_connect_object (G_OBJECT (document),
1142                                          "find_changed",
1143                                          G_CALLBACK (find_changed_cb),
1144                                          ev_window, 0);
1145         }
1146
1147         ev_window_refresh_window_thumbnail (ev_window, 0);
1148
1149         ev_window_set_page_mode (ev_window, PAGE_MODE_DOCUMENT);
1150         ev_window_title_set_document (ev_window->priv->title, document);
1151         ev_window_title_set_uri (ev_window->priv->title, ev_window->priv->uri);
1152
1153         ev_sidebar_set_document (sidebar, document);
1154
1155         action = gtk_action_group_get_action (ev_window->priv->action_group, PAGE_SELECTOR_ACTION);
1156         ev_page_action_set_document (EV_PAGE_ACTION (action), document);
1157         ev_window_setup_action_sensitivity (ev_window);
1158
1159         if (ev_window->priv->history)
1160                 g_object_unref (ev_window->priv->history);
1161         ev_window->priv->history = ev_history_new ();
1162         action = gtk_action_group_get_action (ev_window->priv->action_group, NAVIGATION_ACTION);
1163         ev_navigation_action_set_history (EV_NAVIGATION_ACTION (action), ev_window->priv->history);
1164
1165         if (ev_window->priv->properties) {
1166                 ev_properties_dialog_set_document (EV_PROPERTIES_DIALOG (ev_window->priv->properties),
1167                                                    ev_window->priv->document);
1168         }
1169
1170         info = ev_page_cache_get_info (ev_window->priv->page_cache);
1171         update_document_mode (ev_window, info->mode);
1172
1173         return FALSE;
1174 }
1175
1176 static void
1177 ev_window_set_document (EvWindow *ev_window, EvDocument *document)
1178 {
1179         EvView *view = EV_VIEW (ev_window->priv->view);
1180
1181         if (ev_window->priv->document)
1182                 g_object_unref (ev_window->priv->document);
1183         ev_window->priv->document = g_object_ref (document);
1184
1185         ev_window_set_message_area (ev_window, NULL);
1186
1187         ev_window->priv->page_cache = ev_page_cache_get (ev_window->priv->document);
1188         g_signal_connect (ev_window->priv->page_cache, "page-changed",
1189                           G_CALLBACK (page_changed_cb), ev_window);
1190         g_signal_connect (ev_window->priv->page_cache, "history-changed",
1191                           G_CALLBACK (history_changed_cb), ev_window);
1192
1193         setup_size_from_metadata (ev_window);
1194         setup_sidebar_from_metadata (ev_window, document);
1195         setup_document_from_metadata (ev_window);
1196
1197         if (ev_page_cache_get_n_pages (ev_window->priv->page_cache) > 0) {
1198                 ev_view_set_document (view, document);
1199         }
1200
1201         g_idle_add ((GSourceFunc)ev_window_setup_document, ev_window);
1202 }
1203
1204 static void
1205 password_dialog_response (GtkWidget *password_dialog,
1206                           gint       response_id,
1207                           EvWindow  *ev_window)
1208 {
1209         char *password;
1210
1211         if (response_id == GTK_RESPONSE_OK) {
1212
1213                 password = ev_password_dialog_get_password (EV_PASSWORD_DIALOG (password_dialog));
1214                 if (password) {
1215                         ev_document_doc_mutex_lock ();
1216                         ev_document_security_set_password (EV_DOCUMENT_SECURITY (ev_window->priv->load_job->document),
1217                                                            password);
1218                         ev_document_doc_mutex_unlock ();
1219                 }
1220                 g_free (password);
1221
1222                 ev_password_dialog_save_password (EV_PASSWORD_DIALOG (password_dialog));
1223
1224                 ev_window_title_set_type (ev_window->priv->title, EV_WINDOW_TITLE_DOCUMENT);
1225                 ev_job_queue_add_job (ev_window->priv->load_job, EV_JOB_PRIORITY_HIGH);
1226
1227                 gtk_widget_destroy (password_dialog);
1228
1229                 return;
1230         }
1231
1232         gtk_widget_set_sensitive (ev_window->priv->password_view, TRUE);
1233         gtk_widget_destroy (password_dialog);
1234 }
1235
1236 /* Called either by ev_window_load_job_cb or by the "unlock" callback on the
1237  * password_view page.  It assumes that ev_window->priv->password_* has been set
1238  * correctly.  These are cleared by password_dialog_response() */
1239
1240 static void
1241 ev_window_popup_password_dialog (EvWindow *ev_window)
1242 {
1243         g_assert (ev_window->priv->load_job);
1244
1245         gtk_widget_set_sensitive (ev_window->priv->password_view, FALSE);
1246
1247         ev_window_title_set_uri (ev_window->priv->title, ev_window->priv->uri);
1248         ev_window_title_set_type (ev_window->priv->title, EV_WINDOW_TITLE_PASSWORD);
1249
1250         if (ev_window->priv->password_dialog == NULL) {
1251                 ev_window->priv->password_dialog =
1252                         g_object_new (EV_TYPE_PASSWORD_DIALOG, "uri", ev_window->priv->uri, NULL);
1253                 gtk_window_set_transient_for (GTK_WINDOW (ev_window->priv->password_dialog), GTK_WINDOW (ev_window));
1254
1255                 g_object_add_weak_pointer (G_OBJECT (ev_window->priv->password_dialog),
1256                                            (gpointer) &(ev_window->priv->password_dialog));
1257                 g_signal_connect (ev_window->priv->password_dialog,
1258                                   "response",
1259                                   G_CALLBACK (password_dialog_response),
1260                                   ev_window);
1261                 gtk_widget_show (ev_window->priv->password_dialog);
1262         } else {
1263                 ev_password_dialog_set_bad_pass (EV_PASSWORD_DIALOG (ev_window->priv->password_dialog));
1264         }
1265 }
1266
1267 static void
1268 ev_window_clear_load_job (EvWindow *ev_window)
1269 {
1270         if (ev_window->priv->load_job != NULL) {
1271
1272                 if (!ev_window->priv->load_job->finished)
1273                         ev_job_queue_remove_job (ev_window->priv->load_job);
1274
1275                 g_signal_handlers_disconnect_by_func (ev_window->priv->load_job, ev_window_load_job_cb, ev_window);
1276                 g_object_unref (ev_window->priv->load_job);
1277                 ev_window->priv->load_job = NULL;
1278         }
1279 }
1280
1281 static void
1282 ev_window_clear_local_uri (EvWindow *ev_window)
1283 {
1284         if (ev_window->priv->local_uri) {
1285                 ev_tmp_uri_unlink (ev_window->priv->local_uri);
1286                 g_free (ev_window->priv->local_uri);
1287                 ev_window->priv->local_uri = NULL;
1288         }
1289 }
1290
1291 static void
1292 ev_window_clear_print_settings_file (EvWindow *ev_window)
1293 {
1294         if (ev_window->priv->print_settings_file) {
1295                 g_unlink (ev_window->priv->print_settings_file);
1296                 g_free (ev_window->priv->print_settings_file);
1297                 ev_window->priv->print_settings_file = NULL;
1298         }
1299 }
1300
1301 static void
1302 ev_window_clear_temp_file (EvWindow *ev_window)
1303 {
1304         GnomeVFSURI *uri;
1305         gchar       *filename;
1306         const gchar *tempdir;
1307
1308         if (!ev_window->priv->uri)
1309                 return;
1310
1311         uri = gnome_vfs_uri_new (ev_window->priv->uri);
1312         if (!gnome_vfs_uri_is_local (uri)) {
1313                 gnome_vfs_uri_unref (uri);
1314                 return;
1315         }
1316         gnome_vfs_uri_unref (uri);
1317
1318         filename = g_filename_from_uri (ev_window->priv->uri, NULL, NULL);
1319         if (!filename)
1320                 return;
1321
1322         tempdir = g_get_tmp_dir ();
1323         if (g_ascii_strncasecmp (filename, tempdir, strlen (tempdir)) == 0) {
1324                 g_unlink (filename);
1325         }
1326
1327         g_free (filename);
1328 }
1329
1330 /* This callback will executed when load job will be finished.
1331  *
1332  * Since the flow of the error dialog is very confusing, we assume that both
1333  * document and uri will go away after this function is called, and thus we need
1334  * to ref/dup them.  Additionally, it needs to clear
1335  * ev_window->priv->password_{uri,document}, and thus people who call this
1336  * function should _not_ necessarily expect those to exist after being
1337  * called. */
1338 static void
1339 ev_window_load_job_cb  (EvJobLoad *job,
1340                         gpointer data)
1341 {
1342         EvWindow *ev_window = EV_WINDOW (data);
1343         EvDocument *document = EV_JOB (job)->document;
1344
1345         g_assert (job->uri);
1346
1347         ev_view_set_loading (EV_VIEW (ev_window->priv->view), FALSE);
1348
1349         /* Success! */
1350         if (job->error == NULL) {
1351                 ev_window_set_document (ev_window, document);
1352
1353                 if (job->mode != EV_WINDOW_MODE_PREVIEW) {
1354                         setup_view_from_metadata (ev_window);
1355                 }
1356
1357                 if (!ev_window->priv->unlink_temp_file) {
1358                         ev_window_add_recent (ev_window, ev_window->priv->uri);
1359                 }
1360
1361                 if (job->dest) {
1362                         EvLink *link;
1363                         EvLinkAction *link_action;
1364
1365                         link_action = ev_link_action_new_dest (g_object_ref (job->dest));
1366                         link = ev_link_new (NULL, link_action);
1367                         ev_view_handle_link (EV_VIEW (ev_window->priv->view), link);
1368                         g_object_unref (link);
1369                 }
1370
1371                 switch (job->mode) {
1372                         case EV_WINDOW_MODE_FULLSCREEN:
1373                                 ev_window_run_fullscreen (ev_window);
1374                                 break;
1375                         case EV_WINDOW_MODE_PRESENTATION:
1376                                 ev_window_run_presentation (ev_window);
1377                                 break;
1378                         case EV_WINDOW_MODE_PREVIEW:
1379                                 ev_window_run_preview (ev_window);
1380                                 break;
1381                         default:
1382                                 break;
1383                 }
1384
1385                 /* Restart the search after reloading */
1386                 if (ev_window->priv->in_reload) {
1387                         GtkWidget *widget;
1388
1389                         widget = gtk_window_get_focus (GTK_WINDOW (ev_window));
1390                         if (widget && gtk_widget_get_ancestor (widget, EGG_TYPE_FIND_BAR)) {
1391                                 find_bar_search_changed_cb (EGG_FIND_BAR (ev_window->priv->find_bar),
1392                                                             NULL, ev_window);
1393                         }
1394                 } else if (job->search_string && EV_IS_DOCUMENT_FIND (document)) {
1395                         ev_window_cmd_edit_find (NULL, ev_window);
1396                         egg_find_bar_set_search_string (EGG_FIND_BAR (ev_window->priv->find_bar),
1397                                                         job->search_string);
1398                 }
1399
1400                 ev_window_clear_load_job (ev_window);
1401                 ev_window->priv->in_reload = FALSE;
1402                 return;
1403         }
1404
1405         if (job->error->domain == EV_DOCUMENT_ERROR &&
1406             job->error->code == EV_DOCUMENT_ERROR_ENCRYPTED) {
1407                 gchar *base_name, *file_name;
1408
1409                 setup_view_from_metadata (ev_window);
1410
1411                 file_name = gnome_vfs_format_uri_for_display (job->uri);
1412                 base_name = g_path_get_basename (file_name);
1413                 ev_password_view_set_file_name (EV_PASSWORD_VIEW (ev_window->priv->password_view),
1414                                                 base_name);
1415                 g_free (file_name);
1416                 g_free (base_name);
1417                 ev_window_set_page_mode (ev_window, PAGE_MODE_PASSWORD);
1418
1419                 ev_window_popup_password_dialog (ev_window);
1420         } else {
1421                 ev_window_error_message (GTK_WINDOW (ev_window),
1422                                          _("Unable to open document"),
1423                                          job->error);
1424                 ev_window_clear_load_job (ev_window);
1425                 ev_window->priv->in_reload = FALSE;
1426         }
1427
1428         return;
1429 }
1430
1431 /**
1432  * ev_window_get_uri:
1433  * @ev_window: The instance of the #EvWindow.
1434  *
1435  * It returns the uri of the document showed in the #EvWindow.
1436  *
1437  * Returns: the uri of the document showed in the #EvWindow.
1438  */
1439 const char *
1440 ev_window_get_uri (EvWindow *ev_window)
1441 {
1442         return ev_window->priv->uri;
1443 }
1444
1445 /**
1446  * ev_window_close_dialogs:
1447  * @ev_window: The window where dialogs will be closed.
1448  *
1449  * It looks for password, print and properties dialogs and closes them and
1450  * frees them from memory. If there is any print job it does free it too.
1451  */
1452 static void
1453 ev_window_close_dialogs (EvWindow *ev_window)
1454 {
1455         if (ev_window->priv->password_dialog)
1456                 gtk_widget_destroy (ev_window->priv->password_dialog);
1457         ev_window->priv->password_dialog = NULL;
1458
1459 #ifdef WITH_PRINT
1460         if (ev_window->priv->print_dialog)
1461                 gtk_widget_destroy (ev_window->priv->print_dialog);
1462         ev_window->priv->print_dialog = NULL;
1463 #endif
1464
1465 #ifdef WITH_GNOME_PRINT
1466         if (ev_window->priv->print_job)
1467                 g_object_unref (ev_window->priv->print_job);
1468         ev_window->priv->print_job = NULL;
1469 #endif
1470
1471         if (ev_window->priv->properties)
1472                 gtk_widget_destroy (ev_window->priv->properties);
1473         ev_window->priv->properties = NULL;
1474 }
1475
1476 static gint
1477 open_xfer_update_progress_callback (GnomeVFSAsyncHandle      *handle,
1478                                     GnomeVFSXferProgressInfo *info,
1479                                     EvWindow                 *ev_window)
1480 {
1481         switch (info->status) {
1482                 case GNOME_VFS_XFER_PROGRESS_STATUS_OK:
1483                         if (info->phase == GNOME_VFS_XFER_PHASE_COMPLETED) {
1484                                 ev_job_queue_add_job (ev_window->priv->load_job, EV_JOB_PRIORITY_HIGH);
1485                         }
1486
1487                         return 1;
1488                 case GNOME_VFS_XFER_PROGRESS_STATUS_VFSERROR:
1489                 case GNOME_VFS_XFER_PROGRESS_STATUS_OVERWRITE:
1490                 case GNOME_VFS_XFER_PROGRESS_STATUS_DUPLICATE:
1491                         return 1;
1492                 default:
1493                         g_assert_not_reached ();
1494         }
1495
1496         return 0;
1497 }
1498
1499 void
1500 ev_window_open_uri (EvWindow       *ev_window,
1501                     const char     *uri,
1502                     EvLinkDest     *dest,
1503                     EvWindowRunMode mode,
1504                     const gchar    *search_string,
1505                     gboolean        unlink_temp_file,
1506                     const gchar    *print_settings)
1507 {
1508         GnomeVFSURI *source_uri;
1509         GnomeVFSURI *target_uri;
1510
1511         if (ev_window->priv->uri &&
1512             g_ascii_strcasecmp (ev_window->priv->uri, uri) == 0) {
1513                 ev_window->priv->in_reload = TRUE;
1514         }
1515
1516         ev_window_close_dialogs (ev_window);
1517         ev_window_clear_load_job (ev_window);
1518         ev_window_clear_local_uri (ev_window);
1519         ev_window_clear_print_settings_file (ev_window);
1520         ev_view_set_loading (EV_VIEW (ev_window->priv->view), TRUE);
1521
1522         ev_window->priv->unlink_temp_file = unlink_temp_file;
1523
1524         if (mode == EV_WINDOW_MODE_PREVIEW) {
1525                 ev_window->priv->print_settings_file = print_settings ?
1526                         g_strdup (print_settings) : NULL;
1527         }
1528
1529         if (ev_window->priv->uri)
1530                 g_free (ev_window->priv->uri);
1531         ev_window->priv->uri = g_strdup (uri);
1532
1533         setup_size_from_metadata (ev_window);
1534
1535         ev_window->priv->load_job = ev_job_load_new (uri, dest, mode, search_string);
1536         g_signal_connect (ev_window->priv->load_job,
1537                           "finished",
1538                           G_CALLBACK (ev_window_load_job_cb),
1539                           ev_window);
1540
1541         source_uri = gnome_vfs_uri_new (uri);
1542         if (!gnome_vfs_uri_is_local (source_uri) && !ev_window->priv->local_uri) {
1543                 GnomeVFSAsyncHandle *handle;
1544                 GList               *slist = NULL;
1545                 GList               *tlist = NULL;
1546                 char                *tmp_name;
1547                 char                *base_name;
1548
1549                 /* We'd like to keep extension of source uri since
1550                  * it helps to resolve some mime types, say cbz */
1551
1552                 tmp_name = ev_tmp_filename (NULL);
1553                 base_name = gnome_vfs_uri_extract_short_name (source_uri);
1554                 ev_window->priv->local_uri = g_strconcat ("file:", tmp_name, "-", base_name, NULL);
1555                 ev_job_load_set_uri (EV_JOB_LOAD (ev_window->priv->load_job),
1556                                      ev_window->priv->local_uri);
1557                 g_free (base_name);
1558                 g_free (tmp_name);
1559
1560                 target_uri = gnome_vfs_uri_new (ev_window->priv->local_uri);
1561
1562                 slist = g_list_prepend (slist, source_uri);
1563                 tlist = g_list_prepend (tlist, target_uri);
1564                 gnome_vfs_async_xfer (&handle, slist, tlist,
1565                                       GNOME_VFS_XFER_DEFAULT | GNOME_VFS_XFER_FOLLOW_LINKS,
1566                                       GNOME_VFS_XFER_ERROR_MODE_ABORT,
1567                                       GNOME_VFS_XFER_OVERWRITE_MODE_REPLACE,
1568                                       GNOME_VFS_PRIORITY_DEFAULT,
1569                                       (GnomeVFSAsyncXferProgressCallback)
1570                                       open_xfer_update_progress_callback,
1571                                       ev_window,
1572                                       NULL, NULL);
1573
1574                 g_list_free (slist);
1575                 g_list_free (tlist);
1576                 gnome_vfs_uri_unref (target_uri);
1577                 gnome_vfs_uri_unref (source_uri);
1578
1579                 return;
1580         }
1581
1582         gnome_vfs_uri_unref (source_uri);
1583         ev_job_queue_add_job (ev_window->priv->load_job, EV_JOB_PRIORITY_HIGH);
1584 }
1585
1586 static void
1587 file_open_dialog_response_cb (GtkWidget *chooser,
1588                               gint       response_id,
1589                               EvWindow  *ev_window)
1590 {
1591         gchar *uri;
1592
1593         if (response_id == GTK_RESPONSE_OK) {
1594                 GSList *uris;
1595
1596                 uris = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (chooser));
1597
1598                 ev_application_open_uri_list (EV_APP, uris,
1599                                               gtk_window_get_screen (GTK_WINDOW (ev_window)),
1600                                               GDK_CURRENT_TIME);
1601
1602                 g_slist_foreach (uris, (GFunc)g_free, NULL);
1603                 g_slist_free (uris);
1604         }
1605
1606         uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (chooser));
1607         ev_application_set_chooser_uri (EV_APP, uri);
1608         g_free (uri);
1609
1610         gtk_widget_destroy (chooser);
1611 }
1612
1613 static void
1614 ev_window_cmd_file_open (GtkAction *action, EvWindow *window)
1615 {
1616         GtkWidget *chooser;
1617
1618         chooser = gtk_file_chooser_dialog_new (_("Open Document"),
1619                                                GTK_WINDOW (window),
1620                                                GTK_FILE_CHOOSER_ACTION_OPEN,
1621                                                GTK_STOCK_CANCEL,
1622                                                GTK_RESPONSE_CANCEL,
1623                                                GTK_STOCK_OPEN, GTK_RESPONSE_OK,
1624                                                NULL);
1625
1626         ev_document_factory_add_filters (chooser, NULL);
1627         gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (chooser), TRUE);
1628         gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (chooser), FALSE);
1629         if (ev_application_get_chooser_uri (EV_APP) != NULL) {
1630                 gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (chooser),
1631                                           ev_application_get_chooser_uri (EV_APP));
1632         } else if (window->priv->uri != NULL) {
1633                 gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (chooser),
1634                                           window->priv->uri);
1635         } else {
1636 #if GLIB_CHECK_VERSION (2, 13, 3)
1637                 const gchar *folder;
1638
1639                 folder = g_get_user_special_dir (G_USER_DIRECTORY_DOCUMENTS);
1640                 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser),
1641                                                      folder ? folder : g_get_home_dir ());
1642 #else
1643                 char *folder;
1644
1645                 folder = xdg_user_dir_lookup ("DOCUMENTS");
1646                 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser),
1647                                                      folder);
1648                 free (folder);
1649 #endif
1650         }
1651
1652         g_signal_connect (chooser, "response",
1653                           G_CALLBACK (file_open_dialog_response_cb),
1654                           window);
1655
1656         gtk_widget_show (chooser);
1657 }
1658
1659 static gchar *
1660 ev_window_create_tmp_symlink (const gchar *filename, GError **error)
1661 {
1662         gchar *tmp_filename = NULL;
1663         gchar *name;
1664         gint   res;
1665         guint  i = 0;
1666
1667         name = g_path_get_basename (filename);
1668
1669         do {
1670                 gchar *basename;
1671
1672                 if (tmp_filename)
1673                         g_free (tmp_filename);
1674
1675                 basename = g_strdup_printf ("%s-%d", name, i++);
1676                 tmp_filename = g_build_filename (ev_tmp_dir (),
1677                                                  basename, NULL);
1678
1679                 g_free (basename);
1680         } while ((res = symlink (filename, tmp_filename)) != 0 && errno == EEXIST);
1681
1682         g_free (name);
1683
1684         if (res != 0 && errno != EEXIST) {
1685                 if (error) {
1686                         *error = g_error_new (G_FILE_ERROR,
1687                                               g_file_error_from_errno (errno),
1688                                               _("Couldn't create symlink “%s”: %s"),
1689                                               tmp_filename, strerror (errno));
1690                 }
1691
1692                 g_free (tmp_filename);
1693
1694                 return NULL;
1695         }
1696
1697         return tmp_filename;
1698 }
1699
1700 static void
1701 ev_window_cmd_file_open_copy_at_dest (EvWindow *window, EvLinkDest *dest)
1702 {
1703         GError      *error = NULL;
1704         gchar       *symlink_uri;
1705         gchar       *old_filename;
1706         gchar       *new_filename;
1707         const gchar *uri_unc;
1708
1709         uri_unc = g_object_get_data (G_OBJECT (window->priv->document),
1710                                      "uri-uncompressed");
1711         old_filename = g_filename_from_uri (uri_unc ? uri_unc : window->priv->uri,
1712                                             NULL, NULL);
1713         new_filename = ev_window_create_tmp_symlink (old_filename, &error);
1714
1715         if (error) {
1716                 ev_window_error_message (GTK_WINDOW (window),
1717                                          _("Cannot open a copy."),
1718                                          error);
1719
1720                 g_error_free (error);
1721                 g_free (old_filename);
1722                 g_free (new_filename);
1723
1724                 return;
1725         }
1726
1727         g_free (old_filename);
1728
1729         symlink_uri = g_filename_to_uri (new_filename, NULL, NULL);
1730         g_free (new_filename);
1731
1732         ev_application_open_uri_at_dest (EV_APP,
1733                                          symlink_uri,
1734                                          gtk_window_get_screen (GTK_WINDOW (window)),
1735                                          dest,
1736                                          0,
1737                                          NULL,
1738                                          TRUE,
1739                                          NULL,
1740                                          GDK_CURRENT_TIME);
1741         g_free (symlink_uri);
1742 }
1743
1744 static void
1745 ev_window_cmd_file_open_copy (GtkAction *action, EvWindow *window)
1746 {
1747         EvPageCache *page_cache;
1748         EvLinkDest  *dest;
1749         gint         current_page;
1750
1751         page_cache = ev_page_cache_get (window->priv->document);
1752         current_page = ev_page_cache_get_current_page (page_cache);
1753
1754         dest = ev_link_dest_new_page (current_page);
1755         ev_window_cmd_file_open_copy_at_dest (window, dest);
1756         g_object_unref (dest);
1757 }
1758
1759 static void
1760 ev_window_cmd_recent_file_activate (GtkAction *action,
1761                                     EvWindow  *window)
1762 {
1763         GtkRecentInfo *info;
1764         const gchar   *uri;
1765
1766         info = g_object_get_data (G_OBJECT (action), "gtk-recent-info");
1767         g_assert (info != NULL);
1768
1769         uri = gtk_recent_info_get_uri (info);
1770
1771         ev_application_open_uri_at_dest (EV_APP, uri,
1772                                          gtk_window_get_screen (GTK_WINDOW (window)),
1773                                          NULL, 0, NULL, FALSE, NULL,
1774                                          GDK_CURRENT_TIME);
1775 }
1776
1777 static void
1778 ev_window_open_recent_action_item_activated (EvOpenRecentAction *action,
1779                                              const gchar        *uri,
1780                                              EvWindow           *window)
1781 {
1782         ev_application_open_uri_at_dest (EV_APP, uri,
1783                                          gtk_window_get_screen (GTK_WINDOW (window)),
1784                                          NULL, 0, NULL, FALSE, NULL,
1785                                          GDK_CURRENT_TIME);
1786 }
1787
1788 static void
1789 ev_window_add_recent (EvWindow *window, const char *filename)
1790 {
1791         gtk_recent_manager_add_item (window->priv->recent_manager, filename);
1792 }
1793
1794 static gint
1795 compare_recent_items (GtkRecentInfo *a, GtkRecentInfo *b)
1796 {
1797         gboolean     has_ev_a, has_ev_b;
1798         const gchar *evince = g_get_application_name ();
1799
1800         has_ev_a = gtk_recent_info_has_application (a, evince);
1801         has_ev_b = gtk_recent_info_has_application (b, evince);
1802
1803         if (has_ev_a && has_ev_b) {
1804                 time_t time_a, time_b;
1805
1806                 time_a = gtk_recent_info_get_modified (a);
1807                 time_b = gtk_recent_info_get_modified (b);
1808
1809                 return (time_b - time_a);
1810         } else if (has_ev_a) {
1811                 return -1;
1812         } else if (has_ev_b) {
1813                 return 1;
1814         }
1815
1816         return 0;
1817 }
1818
1819 /*
1820  * Doubles underscore to avoid spurious menu accels.
1821  */
1822 static gchar *
1823 ev_window_get_recent_file_label (gint index, const gchar *filename)
1824 {
1825         GString *str;
1826         gint length;
1827         const gchar *p;
1828         const gchar *end;
1829         gboolean is_rtl;
1830
1831         is_rtl = (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL);
1832
1833         g_return_val_if_fail (filename != NULL, NULL);
1834
1835         length = strlen (filename);
1836         str = g_string_sized_new (length + 10);
1837         g_string_printf (str, "%s_%d.  ", is_rtl ? "\xE2\x80\x8F" : "", index);
1838
1839         p = filename;
1840         end = filename + length;
1841
1842         while (p != end) {
1843                 const gchar *next;
1844                 next = g_utf8_next_char (p);
1845
1846                 switch (*p) {
1847                         case '_':
1848                                 g_string_append (str, "__");
1849                                 break;
1850                         default:
1851                                 g_string_append_len (str, p, next - p);
1852                                 break;
1853                 }
1854
1855                 p = next;
1856         }
1857
1858         return g_string_free (str, FALSE);
1859 }
1860
1861 static void
1862 ev_window_setup_recent (EvWindow *ev_window)
1863 {
1864         GList        *items, *l;
1865         guint         n_items = 0;
1866         const gchar  *evince = g_get_application_name ();
1867         static guint  i = 0;
1868
1869         if (ev_window->priv->recent_ui_id > 0) {
1870                 gtk_ui_manager_remove_ui (ev_window->priv->ui_manager,
1871                                           ev_window->priv->recent_ui_id);
1872                 gtk_ui_manager_ensure_update (ev_window->priv->ui_manager);
1873         }
1874         ev_window->priv->recent_ui_id = gtk_ui_manager_new_merge_id (ev_window->priv->ui_manager);
1875
1876         if (ev_window->priv->recent_action_group) {
1877                 gtk_ui_manager_remove_action_group (ev_window->priv->ui_manager,
1878                                                     ev_window->priv->recent_action_group);
1879                 g_object_unref (ev_window->priv->recent_action_group);
1880         }
1881         ev_window->priv->recent_action_group = gtk_action_group_new ("RecentFilesActions");
1882         gtk_ui_manager_insert_action_group (ev_window->priv->ui_manager,
1883                                             ev_window->priv->recent_action_group, 0);
1884
1885         items = gtk_recent_manager_get_items (ev_window->priv->recent_manager);
1886         items = g_list_sort (items, (GCompareFunc) compare_recent_items);
1887
1888         for (l = items; l && l->data; l = g_list_next (l)) {
1889                 GtkRecentInfo *info;
1890                 GtkAction     *action;
1891                 gchar         *action_name;
1892                 gchar         *label;
1893
1894                 info = (GtkRecentInfo *) l->data;
1895
1896                 if (!gtk_recent_info_has_application (info, evince) ||
1897                     (gtk_recent_info_is_local (info) && !gtk_recent_info_exists (info)))
1898                         continue;
1899
1900                 action_name = g_strdup_printf ("RecentFile%u", i++);
1901                 label = ev_window_get_recent_file_label (
1902                         n_items + 1, gtk_recent_info_get_display_name (info));
1903
1904                 action = g_object_new (GTK_TYPE_ACTION,
1905                                        "name", action_name,
1906                                        "label", label,
1907                                        NULL);
1908
1909                 g_object_set_data_full (G_OBJECT (action),
1910                                         "gtk-recent-info",
1911                                         gtk_recent_info_ref (info),
1912                                         (GDestroyNotify) gtk_recent_info_unref);
1913
1914                 g_signal_connect (G_OBJECT (action), "activate",
1915                                   G_CALLBACK (ev_window_cmd_recent_file_activate),
1916                                   (gpointer) ev_window);
1917
1918                 gtk_action_group_add_action (ev_window->priv->recent_action_group,
1919                                              action);
1920                 g_object_unref (action);
1921
1922                 gtk_ui_manager_add_ui (ev_window->priv->ui_manager,
1923                                        ev_window->priv->recent_ui_id,
1924                                        "/MainMenu/FileMenu/RecentFilesMenu",
1925                                        label,
1926                                        action_name,
1927                                        GTK_UI_MANAGER_MENUITEM,
1928                                        FALSE);
1929                 g_free (action_name);
1930                 g_free (label);
1931
1932                 if (++n_items == 5)
1933                         break;
1934         }
1935
1936         g_list_foreach (items, (GFunc) gtk_recent_info_unref, NULL);
1937         g_list_free (items);
1938 }
1939
1940 static gint
1941 save_xfer_update_progress_callback (GnomeVFSAsyncHandle      *handle,
1942                                     GnomeVFSXferProgressInfo *info,
1943                                     GnomeVFSURI              *tmp_uri)
1944 {
1945         switch (info->status) {
1946                 case GNOME_VFS_XFER_PROGRESS_STATUS_OK:
1947                         if (info->phase == GNOME_VFS_XFER_PHASE_COMPLETED) {
1948                                 gchar *uri;
1949
1950                                 uri = gnome_vfs_uri_to_string (tmp_uri, 0);
1951                                 ev_tmp_uri_unlink (uri);
1952                                 g_free (uri);
1953                                 gnome_vfs_uri_unref (tmp_uri);
1954                         }
1955                         return 1;
1956                 case GNOME_VFS_XFER_PROGRESS_STATUS_VFSERROR:
1957                         if (info->vfs_status != GNOME_VFS_OK) {
1958                                 GtkWidget *dialog;
1959                                 gchar     *uri;
1960
1961                                 dialog = gtk_message_dialog_new (NULL,
1962                                                                  GTK_DIALOG_DESTROY_WITH_PARENT,
1963                                                                  GTK_MESSAGE_ERROR,
1964                                                                  GTK_BUTTONS_CLOSE,
1965                                                                  _("The file could not be saved as “%s”."),
1966                                                                  info->target_name);
1967                                 gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
1968                                                                           gnome_vfs_result_to_string (info->vfs_status));
1969
1970                                 g_signal_connect (dialog, "response",
1971                                                   G_CALLBACK (gtk_widget_destroy),
1972                                                   NULL);
1973                                 gtk_widget_show (dialog);
1974
1975                                 uri = gnome_vfs_uri_to_string (tmp_uri, 0);
1976                                 ev_tmp_uri_unlink (uri);
1977                                 g_free (uri);
1978                                 gnome_vfs_uri_unref (tmp_uri);
1979                         }
1980                         return 1;
1981                 case GNOME_VFS_XFER_PROGRESS_STATUS_OVERWRITE:
1982                 case GNOME_VFS_XFER_PROGRESS_STATUS_DUPLICATE:
1983                         return 1;
1984                 default:
1985                         g_assert_not_reached ();
1986         }
1987
1988         return 0;
1989 }
1990
1991 static void
1992 ev_window_save_remote (EvWindow    *ev_window,
1993                        GnomeVFSURI *src,
1994                        GnomeVFSURI *dst)
1995 {
1996         GnomeVFSAsyncHandle *handle;
1997         GList               *slist = NULL;
1998         GList               *tlist = NULL;
1999
2000         slist = g_list_prepend (slist, src);
2001         tlist = g_list_prepend (tlist, dst);
2002         gnome_vfs_async_xfer (&handle, slist, tlist,
2003                               GNOME_VFS_XFER_DEFAULT | GNOME_VFS_XFER_FOLLOW_LINKS,
2004                               GNOME_VFS_XFER_ERROR_MODE_ABORT,
2005                               GNOME_VFS_XFER_OVERWRITE_MODE_REPLACE,
2006                               GNOME_VFS_PRIORITY_DEFAULT,
2007                               (GnomeVFSAsyncXferProgressCallback)
2008                               save_xfer_update_progress_callback,
2009                               gnome_vfs_uri_ref (src),
2010                               NULL, NULL);
2011         g_list_free (slist);
2012         g_list_free (tlist);
2013 }
2014
2015 static void
2016 ev_window_clear_save_job (EvWindow *ev_window)
2017 {
2018         if (ev_window->priv->save_job != NULL) {
2019                 if (!ev_window->priv->save_job->finished)
2020                         ev_job_queue_remove_job (ev_window->priv->save_job);
2021
2022                 g_signal_handlers_disconnect_by_func (ev_window->priv->save_job,
2023                                                       ev_window_save_job_cb,
2024                                                       ev_window);
2025                 g_object_unref (ev_window->priv->save_job);
2026                 ev_window->priv->save_job = NULL;
2027         }
2028 }
2029
2030 static void
2031 ev_window_save_job_cb (EvJobSave *job,
2032                        EvWindow  *window)
2033 {
2034         if (job->error) {
2035                 gchar *msg;
2036
2037                 msg = g_strdup_printf (_("The file could not be saved as “%s”."), job->uri);
2038                 ev_window_error_message (GTK_WINDOW (window), msg, job->error);
2039                 g_free (msg);
2040         }
2041
2042         ev_window_clear_save_job (window);
2043 }
2044
2045 static void
2046 file_save_dialog_response_cb (GtkWidget *fc,
2047                               gint       response_id,
2048                               EvWindow  *ev_window)
2049 {
2050         gchar *uri;
2051
2052         if (response_id != GTK_RESPONSE_OK) {
2053                 gtk_widget_destroy (fc);
2054                 return;
2055         }
2056
2057         uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (fc));
2058
2059         ev_window_clear_save_job (ev_window);
2060         ev_window->priv->save_job = ev_job_save_new (ev_window->priv->document,
2061                                                      uri, ev_window->priv->uri);
2062         g_signal_connect (ev_window->priv->save_job, "finished",
2063                           G_CALLBACK (ev_window_save_job_cb),
2064                           ev_window);
2065         /* The priority doesn't matter for this job */
2066         ev_job_queue_add_job (ev_window->priv->save_job, EV_JOB_PRIORITY_LOW);
2067
2068         g_free (uri);
2069
2070         gtk_widget_destroy (fc);
2071 }
2072
2073 static void
2074 ev_window_cmd_save_as (GtkAction *action, EvWindow *ev_window)
2075 {
2076         GtkWidget *fc;
2077         gchar *base_name;
2078         gchar *file_name;
2079 #if GLIB_CHECK_VERSION (2, 13, 3)
2080         const gchar *folder;
2081 #else
2082         gchar *folder;
2083 #endif
2084
2085         fc = gtk_file_chooser_dialog_new (
2086                 _("Save a Copy"),
2087                 GTK_WINDOW (ev_window), GTK_FILE_CHOOSER_ACTION_SAVE,
2088                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
2089                 GTK_STOCK_SAVE, GTK_RESPONSE_OK,
2090                 NULL);
2091
2092         ev_document_factory_add_filters (fc, ev_window->priv->document);
2093         gtk_dialog_set_default_response (GTK_DIALOG (fc), GTK_RESPONSE_OK);
2094
2095         gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (fc), FALSE);
2096         gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (fc), TRUE);
2097         file_name = gnome_vfs_format_uri_for_display (ev_window->priv->uri);
2098         base_name = g_path_get_basename (file_name);
2099         gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (fc), base_name);
2100
2101 #if GLIB_CHECK_VERSION (2, 13, 3)
2102         folder = g_get_user_special_dir (G_USER_DIRECTORY_DOCUMENTS);
2103         gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (fc),
2104                                              folder ? folder : g_get_home_dir ());
2105 #else
2106         folder = xdg_user_dir_lookup ("DOCUMENTS");
2107         gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (fc), folder);
2108         free (folder);
2109 #endif
2110
2111         g_free (file_name);
2112         g_free (base_name);
2113
2114         g_signal_connect (fc, "response",
2115                           G_CALLBACK (file_save_dialog_response_cb),
2116                           ev_window);
2117
2118         gtk_widget_show (fc);
2119 }
2120
2121 #ifdef WITH_GTK_PRINT
2122 static void
2123 ev_window_print_page_setup_done_cb (GtkPageSetup *page_setup,
2124                                     EvWindow     *window)
2125 {
2126         /* Dialog was canceled */
2127         if (!page_setup)
2128                 return;
2129
2130         if (window->priv->print_page_setup)
2131                 g_object_unref (window->priv->print_page_setup);
2132         window->priv->print_page_setup = g_object_ref (page_setup);
2133 }
2134 #endif /* WITH_GTK_PRINT */
2135
2136 static void
2137 ev_window_cmd_file_print_setup (GtkAction *action, EvWindow *ev_window)
2138 {
2139 #ifdef WITH_GTK_PRINT
2140         gtk_print_run_page_setup_dialog_async (
2141                 GTK_WINDOW (ev_window),
2142                 ev_window->priv->print_page_setup,
2143                 ev_window->priv->print_settings,
2144                 (GtkPageSetupDoneFunc) ev_window_print_page_setup_done_cb,
2145                 ev_window);
2146 #endif /* WITH_GTK_PRINT */
2147 }
2148
2149 #ifdef WITH_GTK_PRINT
2150 static void
2151 ev_window_clear_print_job (EvWindow *window)
2152 {
2153         if (window->priv->print_job) {
2154                 if (!window->priv->print_job->finished)
2155                         ev_job_queue_remove_job (window->priv->print_job);
2156
2157                 g_signal_handlers_disconnect_by_func (window->priv->print_job,
2158                                                       ev_window_print_job_cb,
2159                                                       window);
2160                 g_object_unref (window->priv->print_job);
2161                 window->priv->print_job = NULL;
2162         }
2163
2164         if (window->priv->gtk_print_job) {
2165                 g_object_unref (window->priv->gtk_print_job);
2166                 window->priv->gtk_print_job = NULL;
2167         }
2168 }
2169
2170 static void
2171 ev_window_load_print_settings_from_metadata (EvWindow *window)
2172 {
2173         gchar *uri = window->priv->uri;
2174         gint   i;
2175
2176         /* Load print setting that are specific to the document */
2177         for (i = 0; i < G_N_ELEMENTS (document_print_settings); i++) {
2178                 GValue   value = { 0, };
2179                 gboolean success;
2180
2181                 success = ev_metadata_manager_get (uri, document_print_settings[i], &value, TRUE);
2182                 gtk_print_settings_set (window->priv->print_settings,
2183                                         document_print_settings[i],
2184                                         success ? g_value_get_string (&value) : NULL);
2185         }
2186 }
2187
2188 static void
2189 ev_window_save_print_settings (EvWindow *window)
2190 {
2191         gchar *uri = window->priv->uri;
2192         gint   i;
2193
2194         /* Save print settings that are specific to the document */
2195         for (i = 0; i < G_N_ELEMENTS (document_print_settings); i++) {
2196                 const gchar *value;
2197
2198                 value = gtk_print_settings_get (window->priv->print_settings,
2199                                                 document_print_settings[i]);
2200                 ev_metadata_manager_set_string (uri, document_print_settings[i], value);
2201         }
2202 }
2203
2204 static void
2205 ev_window_print_finished (GtkPrintJob *print_job,
2206                           EvWindow    *window,
2207                           GError      *error)
2208 {
2209         ev_window_clear_print_job (window);
2210
2211         if (error) {
2212                 GtkWidget *dialog;
2213
2214                 dialog = gtk_message_dialog_new (GTK_WINDOW (window),
2215                                                  GTK_DIALOG_MODAL,
2216                                                  GTK_MESSAGE_ERROR,
2217                                                  GTK_BUTTONS_OK,
2218                                                  _("Failed to print document"));
2219                 gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
2220                                                           error->message);
2221
2222                 gtk_dialog_run (GTK_DIALOG (dialog));
2223                 gtk_widget_destroy (dialog);
2224         } else {
2225                 /* If printed successfully, save print settings */
2226                 ev_application_set_print_settings (EV_APP,
2227                                                    window->priv->print_settings);
2228                 ev_window_save_print_settings (window);
2229         }
2230 }
2231
2232 static void
2233 ev_window_print_send (EvWindow    *window,
2234                       const gchar *filename)
2235 {
2236         GtkPrintSettings *settings;
2237         EvFileExporterCapabilities capabilities;
2238
2239         /* Some printers take into account some print settings,
2240          * and others don't. However we have exported the document
2241          * to a ps or pdf file according to such print settings. So,
2242          * we want to send the exported file to printer with those
2243          * settings set to default values.
2244          */
2245         settings = gtk_print_settings_copy (window->priv->print_settings);
2246         capabilities = ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (window->priv->document));
2247
2248         gtk_print_settings_set_page_ranges (settings, NULL, 0);
2249         gtk_print_settings_set_print_pages (settings, GTK_PRINT_PAGES_ALL);
2250         if (capabilities & EV_FILE_EXPORTER_CAN_COPIES)
2251                 gtk_print_settings_set_n_copies (settings, 1);
2252         if (capabilities & EV_FILE_EXPORTER_CAN_PAGE_SET)
2253                 gtk_print_settings_set_page_set (settings, GTK_PAGE_SET_ALL);
2254         if (capabilities & EV_FILE_EXPORTER_CAN_SCALE)
2255                 gtk_print_settings_set_scale (settings, 1.0);
2256         if (capabilities & EV_FILE_EXPORTER_CAN_COLLATE)
2257                 gtk_print_settings_set_collate (settings, FALSE);
2258         if (capabilities & EV_FILE_EXPORTER_CAN_REVERSE)
2259                 gtk_print_settings_set_reverse (settings, FALSE);
2260         if (capabilities & EV_FILE_EXPORTER_CAN_NUMBER_UP) {
2261                 gtk_print_settings_set_number_up (settings, 1);
2262                 gtk_print_settings_set_int (settings, "cups-"GTK_PRINT_SETTINGS_NUMBER_UP, 1);
2263         }
2264
2265         if (window->priv->print_preview) {
2266                 gchar *uri;
2267                 gchar *print_settings_file = NULL;
2268
2269                 ev_application_set_print_settings (EV_APP,
2270                                                    window->priv->print_settings);
2271
2272 #if GTK_CHECK_VERSION (2, 11, 0)
2273                 print_settings_file = ev_tmp_filename ("print-settings");
2274                 gtk_print_settings_to_file (settings, print_settings_file, NULL);
2275 #endif
2276                 uri = g_filename_to_uri (filename, NULL, NULL);
2277                 ev_application_open_uri_at_dest (EV_APP,
2278                                                  uri,
2279                                                  gtk_window_get_screen (GTK_WINDOW (window)),
2280                                                  NULL,
2281                                                  EV_WINDOW_MODE_PREVIEW,
2282                                                  NULL,
2283                                                  TRUE,
2284                                                  print_settings_file,
2285                                                  GDK_CURRENT_TIME);
2286                 g_free (print_settings_file);
2287                 g_free (uri);
2288         } else {
2289                 GtkPrintJob *job;
2290                 GError      *error = NULL;
2291
2292                 job = gtk_print_job_new ("evince-print",
2293                                          window->priv->printer,
2294                                          settings,
2295                                          window->priv->print_page_setup);
2296
2297                 if (window->priv->gtk_print_job)
2298                         g_object_unref (window->priv->gtk_print_job);
2299                 window->priv->gtk_print_job = job;
2300
2301                 if (gtk_print_job_set_source_file (job, filename, &error)) {
2302                         gtk_print_job_send (job,
2303                                             (GtkPrintJobCompleteFunc)ev_window_print_finished,
2304                                             window, NULL);
2305                 } else {
2306                         ev_window_clear_print_job (window);
2307                         g_warning (error->message);
2308                         g_error_free (error);
2309                 }
2310         }
2311
2312         g_object_unref (settings);
2313 }
2314
2315 static void
2316 ev_window_print_job_cb (EvJobPrint *job,
2317                         EvWindow   *window)
2318 {
2319         if (job->error) {
2320                 g_warning (job->error->message);
2321                 ev_window_clear_print_job (window);
2322                 return;
2323         }
2324
2325         g_assert (job->temp_file != NULL);
2326
2327         ev_window_print_send (window, job->temp_file);
2328 }
2329
2330 static gboolean
2331 ev_window_print_dialog_response_cb (GtkDialog *dialog,
2332                                     gint       response,
2333                                     EvWindow  *window)
2334 {
2335         EvPrintRange  *ranges = NULL;
2336         EvPrintPageSet page_set;
2337         gint           n_ranges = 0;
2338         gint           copies;
2339         gint           pages_per_sheet;
2340         gboolean       collate;
2341         gboolean       reverse;
2342         gdouble        scale;
2343         gint           current_page;
2344         gdouble        width;
2345         gdouble        height;
2346         GtkPrintPages  print_pages;
2347         const gchar   *file_format;
2348
2349         if (response == GTK_RESPONSE_CANCEL) {
2350                 gtk_widget_destroy (GTK_WIDGET (dialog));
2351                 window->priv->print_dialog = NULL;
2352
2353                 return FALSE;
2354         }
2355
2356         window->priv->print_preview = (response == GTK_RESPONSE_APPLY);
2357
2358         if (window->priv->printer)
2359                 g_object_unref (window->priv->printer);
2360         if (window->priv->print_settings)
2361                 g_object_unref (window->priv->print_settings);
2362         if (window->priv->print_page_setup)
2363                 g_object_unref (window->priv->print_page_setup);
2364
2365         window->priv->printer = g_object_ref (
2366                 gtk_print_unix_dialog_get_selected_printer (GTK_PRINT_UNIX_DIALOG (dialog)));
2367         window->priv->print_settings = g_object_ref (
2368                 gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (dialog)));
2369         window->priv->print_page_setup = g_object_ref (
2370                 gtk_print_unix_dialog_get_page_setup (GTK_PRINT_UNIX_DIALOG (dialog)));
2371
2372         file_format = gtk_print_settings_get (window->priv->print_settings,
2373                                               GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT);
2374
2375         if (!gtk_printer_accepts_ps (window->priv->printer)) {
2376                 GtkWidget *msgdialog;
2377
2378                 msgdialog = gtk_message_dialog_new (GTK_WINDOW (dialog),
2379                                                     GTK_DIALOG_MODAL,
2380                                                     GTK_MESSAGE_ERROR,
2381                                                     GTK_BUTTONS_OK,
2382                                                     _("Printing is not supported on this printer."));
2383
2384                 gtk_dialog_run (GTK_DIALOG (msgdialog));
2385                 gtk_widget_destroy (msgdialog);
2386
2387                 return FALSE;
2388         }
2389
2390         ev_window_clear_print_job (window);
2391
2392         current_page = gtk_print_unix_dialog_get_current_page (GTK_PRINT_UNIX_DIALOG (dialog));
2393         print_pages = gtk_print_settings_get_print_pages (window->priv->print_settings);
2394
2395         switch (print_pages) {
2396         case GTK_PRINT_PAGES_CURRENT:
2397                 ranges = g_new0 (EvPrintRange, 1);
2398
2399                 ranges->start = current_page;
2400                 ranges->end = current_page;
2401                 n_ranges = 1;
2402
2403                 break;
2404         case GTK_PRINT_PAGES_RANGES: {
2405                 GtkPageRange *page_range;
2406
2407                 page_range = gtk_print_settings_get_page_ranges (window->priv->print_settings,
2408                                                                  &n_ranges);
2409                 if (n_ranges > 0)
2410                         ranges = g_memdup (page_range, n_ranges * sizeof (GtkPageRange));
2411         }
2412                 break;
2413         case GTK_PRINT_PAGES_ALL: {
2414                 gint n_pages;
2415
2416                 n_pages = ev_page_cache_get_n_pages (ev_page_cache_get (window->priv->document));
2417
2418                 ranges = g_new0 (EvPrintRange, 1);
2419
2420                 ranges->start = 0;
2421                 ranges->end = n_pages - 1;
2422                 n_ranges = 1;
2423         }
2424                 break;
2425         }
2426
2427         page_set = (EvPrintPageSet)gtk_print_settings_get_page_set (window->priv->print_settings);
2428
2429         scale = gtk_print_settings_get_scale (window->priv->print_settings) * 0.01;
2430
2431         width = gtk_page_setup_get_paper_width (window->priv->print_page_setup,
2432                                                 GTK_UNIT_POINTS);
2433         height = gtk_page_setup_get_paper_height (window->priv->print_page_setup,
2434                                                   GTK_UNIT_POINTS);
2435
2436         if (scale != 1.0) {
2437                 width *= scale;
2438                 height *= scale;
2439         }
2440
2441         pages_per_sheet = gtk_print_settings_get_number_up (window->priv->print_settings);
2442
2443         copies = gtk_print_settings_get_n_copies (window->priv->print_settings);
2444         collate = gtk_print_settings_get_collate (window->priv->print_settings);
2445         reverse = gtk_print_settings_get_reverse (window->priv->print_settings);
2446
2447         window->priv->print_job = ev_job_print_new (window->priv->document,
2448                                                     file_format ? file_format : "ps",
2449                                                     width, height,
2450                                                     ranges, n_ranges,
2451                                                     page_set,
2452                                                     pages_per_sheet,
2453                                                     copies, collate,
2454                                                     reverse);
2455
2456         g_signal_connect (window->priv->print_job, "finished",
2457                           G_CALLBACK (ev_window_print_job_cb),
2458                           window);
2459         /* The priority doesn't matter for this job */
2460         ev_job_queue_add_job (window->priv->print_job, EV_JOB_PRIORITY_LOW);
2461
2462         gtk_widget_destroy (GTK_WIDGET (dialog));
2463         window->priv->print_dialog = NULL;
2464
2465         return TRUE;
2466 }
2467
2468 void
2469 ev_window_print_range (EvWindow *ev_window, int first_page, int last_page)
2470 {
2471         GtkWidget           *dialog;
2472         EvPageCache         *page_cache;
2473         gint                 current_page;
2474         gint                 document_last_page;
2475         GtkPrintCapabilities capabilities;
2476
2477         g_return_if_fail (EV_IS_WINDOW (ev_window));
2478         g_return_if_fail (ev_window->priv->document != NULL);
2479
2480         if (ev_window->priv->print_dialog) {
2481                 gtk_window_present (GTK_WINDOW (ev_window->priv->print_dialog));
2482                 return;
2483         }
2484
2485         page_cache = ev_page_cache_get (ev_window->priv->document);
2486         current_page = ev_page_cache_get_current_page (page_cache);
2487         document_last_page = ev_page_cache_get_n_pages (page_cache);
2488
2489         if (!ev_window->priv->print_settings) {
2490                 ev_window->priv->print_settings = gtk_print_settings_copy (
2491                         ev_application_get_print_settings (EV_APP));
2492                 ev_window_load_print_settings_from_metadata (ev_window);
2493         }
2494
2495         if (first_page != 1 || last_page != document_last_page) {
2496                 GtkPageRange range;
2497
2498                 /* Ranges in GtkPrint are 0 - N */
2499                 range.start = first_page - 1;
2500                 range.end = last_page - 1;
2501
2502                 gtk_print_settings_set_print_pages (ev_window->priv->print_settings,
2503                                                     GTK_PRINT_PAGES_RANGES);
2504                 gtk_print_settings_set_page_ranges (ev_window->priv->print_settings,
2505                                                     &range, 1);
2506         }
2507
2508         dialog = gtk_print_unix_dialog_new (_("Print"), GTK_WINDOW (ev_window));
2509         ev_window->priv->print_dialog = dialog;
2510
2511         capabilities = GTK_PRINT_CAPABILITY_PREVIEW |
2512                 ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (ev_window->priv->document));
2513         gtk_print_unix_dialog_set_manual_capabilities (GTK_PRINT_UNIX_DIALOG (dialog),
2514                                                        capabilities);
2515
2516         gtk_print_unix_dialog_set_current_page (GTK_PRINT_UNIX_DIALOG (dialog),
2517                                                 current_page);
2518
2519         gtk_print_unix_dialog_set_settings (GTK_PRINT_UNIX_DIALOG (dialog),
2520                                             ev_window->priv->print_settings);
2521
2522         if (ev_window->priv->print_page_setup)
2523                 gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (dialog),
2524                                                       ev_window->priv->print_page_setup);
2525
2526         g_signal_connect (G_OBJECT (dialog), "response",
2527                           G_CALLBACK (ev_window_print_dialog_response_cb),
2528                           ev_window);
2529
2530         gtk_widget_show (dialog);
2531 }
2532 #endif /* WITH_GTK_PRINT */
2533
2534 #ifdef WITH_GNOME_PRINT
2535 static gboolean
2536 ev_window_print_dialog_response_cb (GtkDialog *print_dialog,
2537                                     gint       response,
2538                                     EvWindow  *ev_window)
2539 {
2540         EvPrintJob *print_job;
2541         GnomePrintConfig *config;
2542
2543         if (response != GNOME_PRINT_DIALOG_RESPONSE_PRINT) {
2544                 gtk_widget_destroy (GTK_WIDGET (print_dialog));
2545                 ev_window->priv->print_dialog = NULL;
2546                 g_object_unref (ev_window->priv->print_job);
2547                 ev_window->priv->print_job = NULL;
2548
2549                 return FALSE;
2550         }
2551
2552         config = gnome_print_dialog_get_config (GNOME_PRINT_DIALOG (print_dialog));
2553
2554         /* FIXME: Change this when we have the first backend
2555          * that can print more than postscript
2556          */
2557         if (using_pdf_printer (config)) {
2558                 GtkWidget *dialog;
2559
2560                 dialog = gtk_message_dialog_new (GTK_WINDOW (print_dialog), GTK_DIALOG_MODAL,
2561                                                  GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
2562                                                  _("Generating PDF is not supported"));
2563                 gtk_dialog_run (GTK_DIALOG (dialog));
2564                 gtk_widget_destroy (dialog);
2565
2566                 return FALSE;
2567         } else if (!using_postscript_printer (config)) {
2568                 GtkWidget *dialog;
2569
2570                 dialog = gtk_message_dialog_new (GTK_WINDOW (print_dialog), GTK_DIALOG_MODAL,
2571                                                  GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
2572                                                  _("Printing is not supported on this printer."));
2573                 gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
2574                                                           _("You were trying to print to a printer using the “%s” driver. "
2575                                                             "This program requires a PostScript printer driver."),
2576                                                           gnome_print_config_get (config, (guchar *)"Settings.Engine.Backend.Driver"));
2577                 gtk_dialog_run (GTK_DIALOG (dialog));
2578                 gtk_widget_destroy (dialog);
2579
2580                 return FALSE;
2581         }
2582
2583         save_print_config_to_file (config);
2584
2585         print_job = g_object_new (EV_TYPE_PRINT_JOB,
2586                                   "gnome_print_job", ev_window->priv->print_job,
2587                                   "document", ev_window->priv->document,
2588                                   "print_dialog", print_dialog,
2589                                   NULL);
2590
2591         if (print_job != NULL) {
2592                 ev_print_job_print (print_job, GTK_WINDOW (ev_window));
2593                 g_object_unref (print_job);
2594         }
2595
2596         g_object_unref (config);
2597
2598         gtk_widget_destroy (GTK_WIDGET (print_dialog));
2599         ev_window->priv->print_dialog = NULL;
2600         g_object_unref (ev_window->priv->print_job);
2601         ev_window->priv->print_job = NULL;
2602
2603         return FALSE;
2604 }
2605
2606 void
2607 ev_window_print_range (EvWindow *ev_window, int first_page, int last_page)
2608 {
2609         GnomePrintConfig *config;
2610         gchar *pages_label;
2611
2612         g_return_if_fail (EV_IS_WINDOW (ev_window));
2613         g_return_if_fail (ev_window->priv->document != NULL);
2614
2615         config = load_print_config_from_file ();
2616
2617         if (ev_window->priv->print_job == NULL)
2618                 ev_window->priv->print_job = gnome_print_job_new (config);
2619
2620         if (ev_window->priv->print_dialog == NULL) {
2621                 ev_window->priv->print_dialog =
2622                         gnome_print_dialog_new (ev_window->priv->print_job,
2623                                                 (guchar *) _("Print"),
2624                                                 (GNOME_PRINT_DIALOG_RANGE |
2625                                                  GNOME_PRINT_DIALOG_COPIES));
2626         }
2627
2628         gtk_window_set_transient_for (GTK_WINDOW (ev_window->priv->print_dialog),
2629                                       GTK_WINDOW (ev_window));
2630         g_object_unref (config);
2631
2632         pages_label = g_strconcat (_("Pages"), " ", NULL);
2633         gnome_print_dialog_construct_range_page (GNOME_PRINT_DIALOG (ev_window->priv->print_dialog),
2634                                                  GNOME_PRINT_RANGE_ALL |
2635                                                  GNOME_PRINT_RANGE_RANGE,
2636                                                  first_page, last_page,
2637                                                  NULL, (const guchar *)pages_label);
2638         g_free (pages_label);
2639
2640         gtk_dialog_set_response_sensitive (GTK_DIALOG (ev_window->priv->print_dialog),
2641                                            GNOME_PRINT_DIALOG_RESPONSE_PREVIEW,
2642                                            FALSE);
2643
2644         g_signal_connect (G_OBJECT (ev_window->priv->print_dialog), "response",
2645                           G_CALLBACK (ev_window_print_dialog_response_cb),
2646                           ev_window);
2647         gtk_widget_show (ev_window->priv->print_dialog);
2648 }
2649 #endif /* WITH_GNOME_PRINT */
2650
2651 static void
2652 ev_window_print (EvWindow *window)
2653 {
2654         EvPageCache *page_cache;
2655         gint         last_page;
2656
2657         page_cache = ev_page_cache_get (window->priv->document);
2658         last_page = ev_page_cache_get_n_pages (page_cache);
2659
2660 #ifdef WITH_PRINT
2661         ev_window_print_range (window, 1, last_page);
2662 #endif
2663 }
2664
2665 static void
2666 ev_window_cmd_file_print (GtkAction *action, EvWindow *ev_window)
2667 {
2668         ev_window_print (ev_window);
2669 }
2670
2671 static void
2672 ev_window_cmd_file_properties (GtkAction *action, EvWindow *ev_window)
2673 {
2674         if (ev_window->priv->properties == NULL) {
2675                 ev_window->priv->properties = ev_properties_dialog_new ();
2676                 ev_properties_dialog_set_document (EV_PROPERTIES_DIALOG (ev_window->priv->properties),
2677                                                    ev_window->priv->document);
2678                 g_object_add_weak_pointer (G_OBJECT (ev_window->priv->properties),
2679                                            (gpointer) &(ev_window->priv->properties));
2680                 gtk_window_set_transient_for (GTK_WINDOW (ev_window->priv->properties),
2681                                               GTK_WINDOW (ev_window));
2682         }
2683
2684         ev_document_fc_mutex_lock ();
2685         gtk_widget_show (ev_window->priv->properties);
2686         ev_document_fc_mutex_unlock ();
2687 }
2688
2689 static void
2690 ev_window_cmd_file_close_window (GtkAction *action, EvWindow *ev_window)
2691 {
2692         g_return_if_fail (EV_IS_WINDOW (ev_window));
2693
2694         gtk_widget_destroy (GTK_WIDGET (ev_window));
2695 }
2696
2697 static void
2698 ev_window_cmd_focus_page_selector (GtkAction *act, EvWindow *window)
2699 {
2700         GtkAction *action;
2701
2702         update_chrome_flag (window, EV_CHROME_RAISE_TOOLBAR, TRUE);
2703         ev_window_set_action_sensitive (window, "ViewToolbar", FALSE);
2704         update_chrome_visibility (window);
2705
2706         action = gtk_action_group_get_action (window->priv->action_group,
2707                                               PAGE_SELECTOR_ACTION);
2708         ev_page_action_grab_focus (EV_PAGE_ACTION (action));
2709 }
2710
2711 static void
2712 ev_window_cmd_scroll_forward (GtkAction *action, EvWindow *window)
2713 {
2714         ev_view_scroll (EV_VIEW (window->priv->view), EV_SCROLL_PAGE_FORWARD, FALSE);
2715 }
2716
2717 static void
2718 ev_window_cmd_scroll_backward (GtkAction *action, EvWindow *window)
2719 {
2720         ev_view_scroll (EV_VIEW (window->priv->view), EV_SCROLL_PAGE_BACKWARD, FALSE);
2721 }
2722
2723 static void
2724 ev_window_cmd_continuous (GtkAction *action, EvWindow *ev_window)
2725 {
2726         gboolean continuous;
2727
2728         ev_window_stop_presentation (ev_window);
2729         continuous = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
2730         g_object_set (G_OBJECT (ev_window->priv->view),
2731                       "continuous", continuous,
2732                       NULL);
2733         ev_window_update_actions (ev_window);
2734 }
2735
2736 static void
2737 ev_window_cmd_dual (GtkAction *action, EvWindow *ev_window)
2738 {
2739         gboolean dual_page;
2740
2741         ev_window_stop_presentation (ev_window);
2742         dual_page = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
2743         g_object_set (G_OBJECT (ev_window->priv->view),
2744                       "dual-page", dual_page,
2745                       NULL);
2746         ev_window_update_actions (ev_window);
2747 }
2748
2749 static void
2750 ev_window_cmd_view_best_fit (GtkAction *action, EvWindow *ev_window)
2751 {
2752         ev_window_stop_presentation (ev_window);
2753
2754         if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action))) {
2755                 ev_view_set_sizing_mode (EV_VIEW (ev_window->priv->view), EV_SIZING_BEST_FIT);
2756         } else {
2757                 ev_view_set_sizing_mode (EV_VIEW (ev_window->priv->view), EV_SIZING_FREE);
2758         }
2759         ev_window_update_actions (ev_window);
2760 }
2761
2762 static void
2763 ev_window_cmd_view_page_width (GtkAction *action, EvWindow *ev_window)
2764 {
2765         ev_window_stop_presentation (ev_window);
2766
2767         if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action))) {
2768                 ev_view_set_sizing_mode (EV_VIEW (ev_window->priv->view), EV_SIZING_FIT_WIDTH);
2769         } else {
2770                 ev_view_set_sizing_mode (EV_VIEW (ev_window->priv->view), EV_SIZING_FREE);
2771         }
2772         ev_window_update_actions (ev_window);
2773 }
2774
2775
2776 static void
2777 ev_window_cmd_edit_select_all (GtkAction *action, EvWindow *ev_window)
2778 {
2779         g_return_if_fail (EV_IS_WINDOW (ev_window));
2780
2781         ev_view_select_all (EV_VIEW (ev_window->priv->view));
2782 }
2783
2784 static void
2785 ev_window_cmd_edit_find (GtkAction *action, EvWindow *ev_window)
2786 {
2787         g_return_if_fail (EV_IS_WINDOW (ev_window));
2788
2789         if (ev_window->priv->document == NULL || !EV_IS_DOCUMENT_FIND (ev_window->priv->document)) {
2790                 g_error ("Find action should be insensitive since document doesn't support find");
2791                 return;
2792         }
2793
2794         update_chrome_flag (ev_window, EV_CHROME_FINDBAR, TRUE);
2795         update_chrome_visibility (ev_window);
2796         gtk_widget_grab_focus (ev_window->priv->find_bar);
2797 }
2798
2799 static void
2800 ev_window_cmd_edit_find_next (GtkAction *action, EvWindow *ev_window)
2801 {
2802         g_return_if_fail (EV_IS_WINDOW (ev_window));
2803
2804         update_chrome_flag (ev_window, EV_CHROME_FINDBAR, TRUE);
2805         update_chrome_visibility (ev_window);
2806         gtk_widget_grab_focus (ev_window->priv->find_bar);
2807         ev_view_find_next (EV_VIEW (ev_window->priv->view));
2808 }
2809
2810 static void
2811 ev_window_cmd_edit_find_previous (GtkAction *action, EvWindow *ev_window)
2812 {
2813         g_return_if_fail (EV_IS_WINDOW (ev_window));
2814
2815         update_chrome_flag (ev_window, EV_CHROME_FINDBAR, TRUE);
2816         update_chrome_visibility (ev_window);
2817         gtk_widget_grab_focus (ev_window->priv->find_bar);
2818         ev_view_find_previous (EV_VIEW (ev_window->priv->view));
2819 }
2820
2821 static void
2822 ev_window_cmd_edit_copy (GtkAction *action, EvWindow *ev_window)
2823 {
2824         g_return_if_fail (EV_IS_WINDOW (ev_window));
2825
2826         ev_view_copy (EV_VIEW (ev_window->priv->view));
2827 }
2828
2829 static void
2830 ev_window_sidebar_position_change_cb (GObject *object, GParamSpec *pspec,
2831                                       EvWindow *ev_window)
2832 {
2833         if (!ev_window_is_empty (ev_window))
2834                 ev_metadata_manager_set_int (ev_window->priv->uri, "sidebar_size",
2835                                              gtk_paned_get_position (GTK_PANED (object)));
2836 }
2837
2838 static void
2839 ev_window_update_fullscreen_action (EvWindow *window)
2840 {
2841         GtkAction *action;
2842
2843         action = gtk_action_group_get_action (window->priv->action_group, "ViewFullscreen");
2844         g_signal_handlers_block_by_func
2845                 (action, G_CALLBACK (ev_window_cmd_view_fullscreen), window);
2846         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
2847                                       ev_view_get_fullscreen (EV_VIEW (window->priv->view)));
2848         g_signal_handlers_unblock_by_func
2849                 (action, G_CALLBACK (ev_window_cmd_view_fullscreen), window);
2850 }
2851
2852 static void
2853 fullscreen_toolbar_setup_item_properties (GtkUIManager *ui_manager)
2854 {
2855         GtkWidget *item;
2856
2857         item = gtk_ui_manager_get_widget (ui_manager, "/FullscreenToolbar/GoPreviousPage");
2858         g_object_set (item, "is-important", FALSE, NULL);
2859
2860         item = gtk_ui_manager_get_widget (ui_manager, "/FullscreenToolbar/GoNextPage");
2861         g_object_set (item, "is-important", FALSE, NULL);
2862
2863         item = gtk_ui_manager_get_widget (ui_manager, "/FullscreenToolbar/StartPresentation");
2864         g_object_set (item, "is-important", TRUE, NULL);
2865
2866         item = gtk_ui_manager_get_widget (ui_manager, "/FullscreenToolbar/LeaveFullscreen");
2867         g_object_set (item, "is-important", TRUE, NULL);
2868 }
2869
2870 static void
2871 fullscreen_toolbar_remove_shadow (GtkWidget *toolbar)
2872 {
2873         static gboolean done = FALSE;
2874
2875         if (!done) {
2876                 gtk_rc_parse_string (
2877                         "\n"
2878                         "   style \"fullscreen-toolbar-style\"\n"
2879                         "   {\n"
2880                         "      GtkToolbar::shadow-type=GTK_SHADOW_NONE\n"
2881                         "   }\n"
2882                         "\n"
2883                         "    widget \"*.fullscreen-toolbar\" style \"fullscreen-toolbar-style\"\n"
2884                         "\n");
2885                 done = TRUE;
2886         }
2887
2888         gtk_widget_set_name (toolbar, "fullscreen-toolbar");
2889 }
2890
2891 static void
2892 ev_window_run_fullscreen (EvWindow *window)
2893 {
2894         if (!window->priv->fullscreen_toolbar) {
2895                 window->priv->fullscreen_toolbar =
2896                         gtk_ui_manager_get_widget (window->priv->ui_manager,
2897                                                    "/FullscreenToolbar");
2898
2899                 gtk_toolbar_set_style (GTK_TOOLBAR (window->priv->fullscreen_toolbar),
2900                                        GTK_TOOLBAR_BOTH_HORIZ);
2901                 fullscreen_toolbar_remove_shadow (window->priv->fullscreen_toolbar);
2902                 fullscreen_toolbar_setup_item_properties (window->priv->ui_manager);
2903
2904                 gtk_box_pack_start (GTK_BOX (window->priv->main_box),
2905                                     window->priv->fullscreen_toolbar,
2906                                     FALSE, FALSE, 0);
2907                 gtk_box_reorder_child (GTK_BOX (window->priv->main_box),
2908                                        window->priv->fullscreen_toolbar, 1);
2909         }
2910
2911         g_object_set (G_OBJECT (window->priv->scrolled_window),
2912                       "shadow-type", GTK_SHADOW_NONE,
2913                       NULL);
2914
2915         ev_view_set_fullscreen (EV_VIEW (window->priv->view), TRUE);
2916         ev_window_update_fullscreen_action (window);
2917
2918         /* If the user doesn't have the main toolbar he/she won't probably want
2919          * the toolbar in fullscreen mode. See bug #483048
2920          */
2921         update_chrome_flag (window, EV_CHROME_FULLSCREEN_TOOLBAR,
2922                             (window->priv->chrome & EV_CHROME_TOOLBAR) != 0);
2923         update_chrome_visibility (window);
2924
2925         gtk_window_fullscreen (GTK_WINDOW (window));
2926         gtk_widget_grab_focus (window->priv->view);
2927
2928         if (!ev_window_is_empty (window))
2929                 ev_metadata_manager_set_boolean (window->priv->uri, "fullscreen", TRUE);
2930 }
2931
2932 static void
2933 ev_window_stop_fullscreen (EvWindow *window)
2934 {
2935         EvView *view = EV_VIEW (window->priv->view);
2936
2937         if (!ev_view_get_fullscreen (EV_VIEW (view)))
2938                 return;
2939
2940         g_object_set (G_OBJECT (window->priv->scrolled_window),
2941                       "shadow-type", GTK_SHADOW_IN,
2942                       NULL);
2943
2944         ev_view_set_fullscreen (view, FALSE);
2945         ev_window_update_fullscreen_action (window);
2946         update_chrome_flag (window, EV_CHROME_FULLSCREEN_TOOLBAR, FALSE);
2947         update_chrome_visibility (window);
2948         gtk_window_unfullscreen (GTK_WINDOW (window));
2949
2950         if (!ev_window_is_empty (window))
2951                 ev_metadata_manager_set_boolean (window->priv->uri, "fullscreen", FALSE);
2952 }
2953
2954 static void
2955 ev_window_cmd_view_fullscreen (GtkAction *action, EvWindow *window)
2956 {
2957         gboolean fullscreen;
2958
2959         g_return_if_fail (EV_IS_WINDOW (window));
2960         ev_window_stop_presentation (window);
2961
2962         fullscreen = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
2963         if (fullscreen) {
2964                 ev_window_run_fullscreen (window);
2965         } else {
2966                 ev_window_stop_fullscreen (window);
2967         }
2968 }
2969
2970 static gboolean
2971 presentation_timeout_cb (EvWindow *window)
2972 {
2973         EvView *view = EV_VIEW (window->priv->view);
2974
2975         if (!view || !ev_view_get_presentation (EV_VIEW (view)))
2976                 return FALSE;
2977
2978         ev_view_hide_cursor (EV_VIEW (window->priv->view));
2979         window->priv->presentation_timeout_id = 0;
2980
2981         return FALSE;
2982 }
2983
2984 static void
2985 presentation_set_timeout (EvWindow *window)
2986 {
2987         if (window->priv->presentation_timeout_id > 0) {
2988                 g_source_remove (window->priv->presentation_timeout_id);
2989         }
2990
2991 #if GLIB_CHECK_VERSION (2, 13, 0)
2992         window->priv->presentation_timeout_id =
2993                 g_timeout_add_seconds (PRESENTATION_TIMEOUT,
2994                                        (GSourceFunc)presentation_timeout_cb, window);
2995 #else
2996         window->priv->presentation_timeout_id =
2997             g_timeout_add (PRESENTATION_TIMEOUT * 1000,
2998                            (GSourceFunc)presentation_timeout_cb, window);
2999 #endif
3000
3001         ev_view_show_cursor (EV_VIEW (window->priv->view));
3002 }
3003
3004 static void
3005 presentation_clear_timeout (EvWindow *window)
3006 {
3007         if (window->priv->presentation_timeout_id > 0) {
3008                 g_source_remove (window->priv->presentation_timeout_id);
3009         }
3010
3011         window->priv->presentation_timeout_id = 0;
3012
3013         ev_view_show_cursor (EV_VIEW (window->priv->view));
3014 }
3015
3016 static gboolean
3017 presentation_motion_notify_cb (GtkWidget *widget,
3018                                GdkEventMotion *event,
3019                                gpointer user_data)
3020 {
3021         EvWindow *window = EV_WINDOW (user_data);
3022
3023         presentation_set_timeout (window);
3024
3025         return FALSE;
3026 }
3027
3028 static gboolean
3029 presentation_leave_notify_cb (GtkWidget *widget,
3030                               GdkEventCrossing *event,
3031                               gpointer user_data)
3032 {
3033         EvWindow *window = EV_WINDOW (user_data);
3034
3035         presentation_clear_timeout (window);
3036
3037         return FALSE;
3038 }
3039
3040 static void
3041 ev_window_update_presentation_action (EvWindow *window)
3042 {
3043         GtkAction *action;
3044
3045         action = gtk_action_group_get_action (window->priv->action_group, "ViewPresentation");
3046         g_signal_handlers_block_by_func
3047                 (action, G_CALLBACK (ev_window_cmd_view_presentation), window);
3048         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
3049                                       ev_view_get_presentation (EV_VIEW (window->priv->view)));
3050         g_signal_handlers_unblock_by_func
3051                 (action, G_CALLBACK (ev_window_cmd_view_presentation), window);
3052 }
3053
3054 static void
3055 ev_window_run_presentation (EvWindow *window)
3056 {
3057         g_object_set (G_OBJECT (window->priv->scrolled_window),
3058                       "shadow-type", GTK_SHADOW_NONE,
3059                       NULL);
3060
3061         ev_view_set_presentation (EV_VIEW (window->priv->view), TRUE);
3062         ev_window_update_presentation_action (window);
3063
3064         update_chrome_visibility (window);
3065
3066         gtk_widget_grab_focus (window->priv->view);
3067         gtk_window_fullscreen (GTK_WINDOW (window));
3068
3069         g_signal_connect (window->priv->view,
3070                           "motion-notify-event",
3071                           G_CALLBACK (presentation_motion_notify_cb),
3072                           window);
3073         g_signal_connect (window->priv->view,
3074                           "leave-notify-event",
3075                           G_CALLBACK (presentation_leave_notify_cb),
3076                           window);
3077         presentation_set_timeout (window);
3078
3079         ev_application_screensaver_disable (EV_APP);
3080
3081         if (!ev_window_is_empty (window))
3082                 ev_metadata_manager_set_boolean (window->priv->uri, "presentation", TRUE);
3083 }
3084
3085 static void
3086 ev_window_stop_presentation (EvWindow *window)
3087 {
3088         if (!ev_view_get_presentation (EV_VIEW (window->priv->view)))
3089                 return;
3090
3091         g_object_set (G_OBJECT (window->priv->scrolled_window),
3092                       "shadow-type", GTK_SHADOW_IN,
3093                       NULL);
3094
3095         ev_view_set_presentation (EV_VIEW (window->priv->view), FALSE);
3096         ev_window_update_presentation_action (window);
3097         update_chrome_visibility (window);
3098         gtk_window_unfullscreen (GTK_WINDOW (window));
3099
3100         g_signal_handlers_disconnect_by_func (window->priv->view,
3101                                               (gpointer) presentation_motion_notify_cb,
3102                                               window);
3103         g_signal_handlers_disconnect_by_func (window->priv->view,
3104                                               (gpointer) presentation_leave_notify_cb,
3105                                               window);
3106         presentation_clear_timeout (window);
3107
3108         ev_application_screensaver_enable (EV_APP);
3109
3110         if (!ev_window_is_empty (window))
3111                 ev_metadata_manager_set_boolean (window->priv->uri, "presentation", FALSE);
3112 }
3113
3114 static void
3115 ev_window_cmd_view_presentation (GtkAction *action, EvWindow *window)
3116 {
3117         gboolean presentation;
3118
3119         g_return_if_fail (EV_IS_WINDOW (window));
3120         ev_window_stop_fullscreen (window);
3121
3122         presentation = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
3123         if (presentation) {
3124                 ev_window_run_presentation (window);
3125         } else {
3126                 ev_window_stop_presentation (window);
3127         }
3128 }
3129
3130 static void
3131 ev_window_run_preview (EvWindow *window)
3132 {
3133         GtkAction *action;
3134
3135         if (!window->priv->preview_toolbar) {
3136                 window->priv->preview_toolbar =
3137                         gtk_ui_manager_get_widget (window->priv->ui_manager,
3138                                                    "/PreviewToolbar");
3139
3140                 gtk_box_pack_start (GTK_BOX (window->priv->main_box),
3141                                     window->priv->preview_toolbar,
3142                                     FALSE, FALSE, 0);
3143                 gtk_box_reorder_child (GTK_BOX (window->priv->main_box),
3144                                        window->priv->preview_toolbar, 1);
3145         }
3146
3147         ev_view_set_continuous (EV_VIEW (window->priv->view), FALSE);
3148
3149         update_chrome_flag (window, EV_CHROME_TOOLBAR, FALSE);
3150         update_chrome_flag (window, EV_CHROME_MENUBAR, FALSE);
3151         update_chrome_flag (window, EV_CHROME_SIDEBAR, FALSE);
3152
3153         update_chrome_flag (window, EV_CHROME_PREVIEW_TOOLBAR, TRUE);
3154
3155         action = gtk_action_group_get_action (window->priv->action_group,
3156                                               "PreviewPrint");
3157 #if GTK_CHECK_VERSION (2, 11, 0)
3158         gtk_action_set_visible (action, TRUE);
3159 #else
3160         gtk_action_set_visible (action, FALSE);
3161 #endif
3162
3163         update_chrome_visibility (window);
3164 }
3165
3166 static void
3167 ev_window_screen_changed (GtkWidget *widget,
3168                           GdkScreen *old_screen)
3169 {
3170         EvWindow *window = EV_WINDOW (widget);
3171         EvWindowPrivate *priv = window->priv;
3172         GdkScreen *screen;
3173
3174         screen = gtk_widget_get_screen (widget);
3175         if (screen == old_screen)
3176                 return;
3177
3178         ev_view_set_screen_dpi (EV_VIEW (priv->view),
3179                                 get_screen_dpi (GTK_WINDOW (window)));
3180
3181         if (GTK_WIDGET_CLASS (ev_window_parent_class)->screen_changed) {
3182                 GTK_WIDGET_CLASS (ev_window_parent_class)->screen_changed (widget, old_screen);
3183         }
3184 }
3185
3186 static void
3187 ev_window_set_page_mode (EvWindow         *window,
3188                          EvWindowPageMode  page_mode)
3189 {
3190         GtkWidget *child = NULL;
3191         GtkWidget *real_child;
3192
3193         if (window->priv->page_mode == page_mode)
3194                 return;
3195
3196         window->priv->page_mode = page_mode;
3197
3198         switch (page_mode) {
3199                 case PAGE_MODE_DOCUMENT:
3200                         child = window->priv->view;
3201                         break;
3202                 case PAGE_MODE_PASSWORD:
3203                         child = window->priv->password_view;
3204                         break;
3205                 default:
3206                         g_assert_not_reached ();
3207         }
3208
3209         real_child = gtk_bin_get_child (GTK_BIN (window->priv->scrolled_window));
3210         if (child != real_child) {
3211                 gtk_container_remove (GTK_CONTAINER (window->priv->scrolled_window),
3212                                       real_child);
3213                 gtk_container_add (GTK_CONTAINER (window->priv->scrolled_window),
3214                                    child);
3215         }
3216         ev_window_update_actions (window);
3217 }
3218
3219
3220 static void
3221 ev_window_cmd_edit_rotate_left (GtkAction *action, EvWindow *ev_window)
3222 {
3223         ev_view_rotate_left (EV_VIEW (ev_window->priv->view));
3224 }
3225
3226 static void
3227 ev_window_cmd_edit_rotate_right (GtkAction *action, EvWindow *ev_window)
3228 {
3229         ev_view_rotate_right (EV_VIEW (ev_window->priv->view));
3230 }
3231
3232 static void
3233 ev_window_cmd_edit_toolbar_cb (GtkDialog *dialog, gint response, gpointer data)
3234 {
3235         EvWindow *ev_window = EV_WINDOW (data);
3236         egg_editable_toolbar_set_edit_mode
3237                         (EGG_EDITABLE_TOOLBAR (ev_window->priv->toolbar), FALSE);
3238         ev_application_save_toolbars_model (EV_APP);
3239         gtk_widget_destroy (GTK_WIDGET (dialog));
3240 }
3241
3242 static void
3243 ev_window_cmd_edit_toolbar (GtkAction *action, EvWindow *ev_window)
3244 {
3245         GtkWidget *dialog;
3246         GtkWidget *editor;
3247
3248         dialog = gtk_dialog_new_with_buttons (_("Toolbar Editor"),
3249                                               GTK_WINDOW (ev_window),
3250                                               GTK_DIALOG_DESTROY_WITH_PARENT,
3251                                               GTK_STOCK_CLOSE,
3252                                               GTK_RESPONSE_CLOSE,
3253                                               NULL);
3254         gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);
3255         gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)), 5);
3256         gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 2);
3257         gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
3258         gtk_window_set_default_size (GTK_WINDOW (dialog), 500, 400);
3259
3260         editor = egg_toolbar_editor_new (ev_window->priv->ui_manager,
3261                                          ev_application_get_toolbars_model (EV_APP));
3262         gtk_container_set_border_width (GTK_CONTAINER (editor), 5);
3263         gtk_box_set_spacing (GTK_BOX (EGG_TOOLBAR_EDITOR (editor)), 5);
3264
3265         gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), editor);
3266
3267         egg_editable_toolbar_set_edit_mode
3268                 (EGG_EDITABLE_TOOLBAR (ev_window->priv->toolbar), TRUE);
3269
3270         g_signal_connect (dialog, "response",
3271                           G_CALLBACK (ev_window_cmd_edit_toolbar_cb),
3272                           ev_window);
3273         gtk_widget_show_all (dialog);
3274 }
3275
3276 static void
3277 ev_window_cmd_view_zoom_in (GtkAction *action, EvWindow *ev_window)
3278 {
3279         g_return_if_fail (EV_IS_WINDOW (ev_window));
3280
3281         ev_view_set_sizing_mode (EV_VIEW (ev_window->priv->view), EV_SIZING_FREE);
3282         ev_view_zoom_in (EV_VIEW (ev_window->priv->view));
3283 }
3284
3285 static void
3286 ev_window_cmd_view_zoom_out (GtkAction *action, EvWindow *ev_window)
3287 {
3288         g_return_if_fail (EV_IS_WINDOW (ev_window));
3289
3290         ev_view_set_sizing_mode (EV_VIEW (ev_window->priv->view), EV_SIZING_FREE);
3291         ev_view_zoom_out (EV_VIEW (ev_window->priv->view));
3292 }
3293
3294 static void
3295 ev_window_cmd_go_previous_page (GtkAction *action, EvWindow *ev_window)
3296 {
3297         g_return_if_fail (EV_IS_WINDOW (ev_window));
3298
3299         ev_view_previous_page (EV_VIEW (ev_window->priv->view));
3300 }
3301
3302 static void
3303 ev_window_cmd_go_next_page (GtkAction *action, EvWindow *ev_window)
3304 {
3305         g_return_if_fail (EV_IS_WINDOW (ev_window));
3306
3307         ev_view_next_page (EV_VIEW (ev_window->priv->view));
3308 }
3309
3310 static void
3311 ev_window_cmd_go_first_page (GtkAction *action, EvWindow *ev_window)
3312 {
3313         g_return_if_fail (EV_IS_WINDOW (ev_window));
3314
3315         ev_page_cache_set_current_page (ev_window->priv->page_cache, 0);
3316 }
3317
3318 static void
3319 ev_window_cmd_go_last_page (GtkAction *action, EvWindow *ev_window)
3320 {
3321         int n_pages;
3322
3323         g_return_if_fail (EV_IS_WINDOW (ev_window));
3324
3325         n_pages = ev_page_cache_get_n_pages (ev_window->priv->page_cache);
3326         ev_page_cache_set_current_page (ev_window->priv->page_cache, n_pages - 1);
3327 }
3328
3329 static void
3330 ev_window_cmd_go_forward (GtkAction *action, EvWindow *ev_window)
3331 {
3332         int n_pages, current_page;
3333
3334         g_return_if_fail (EV_IS_WINDOW (ev_window));
3335
3336         n_pages = ev_page_cache_get_n_pages (ev_window->priv->page_cache);
3337         current_page = ev_page_cache_get_current_page (ev_window->priv->page_cache);
3338
3339         if (current_page + 10 < n_pages)
3340                 ev_page_cache_set_current_page (ev_window->priv->page_cache, current_page + 10);
3341 }
3342
3343 static void
3344 ev_window_cmd_go_backward (GtkAction *action, EvWindow *ev_window)
3345 {
3346         int current_page;
3347
3348         g_return_if_fail (EV_IS_WINDOW (ev_window));
3349
3350         current_page = ev_page_cache_get_current_page (ev_window->priv->page_cache);
3351
3352         if (current_page - 10 >= 0)
3353                 ev_page_cache_set_current_page (ev_window->priv->page_cache, current_page - 10);
3354 }
3355
3356 static void
3357 ev_window_cmd_view_reload (GtkAction *action, EvWindow *ev_window)
3358 {
3359         gchar *uri;
3360
3361         uri = g_strdup (ev_window->priv->uri);
3362         ev_window_open_uri (ev_window, uri, NULL, 0, NULL, FALSE, NULL);
3363         g_free (uri);
3364 }
3365
3366 static void
3367 ev_window_cmd_view_autoscroll (GtkAction *action, EvWindow *ev_window)
3368 {
3369         ev_view_autoscroll (EV_VIEW (ev_window->priv->view));
3370 }
3371
3372 static void
3373 ev_window_cmd_help_contents (GtkAction *action, EvWindow *ev_window)
3374 {
3375         GError *error = NULL;
3376         GdkScreen *screen;
3377         char *command;
3378         const char *lang;
3379         char *uri = NULL;
3380
3381         int i;
3382
3383         const char * const * langs = g_get_language_names ();
3384
3385         for (i = 0; langs[i]; i++) {
3386                 lang = langs[i];
3387                 if (strchr (lang, '.')) {
3388                         continue;
3389                 }
3390
3391                 uri = g_build_filename(GNOMEDATADIR,
3392                                        "/gnome/help/" PACKAGE,
3393                                        lang,
3394                                        "/evince.xml",
3395                                        NULL);
3396
3397                 if (g_file_test (uri, G_FILE_TEST_EXISTS)) {
3398                         break;
3399                 }
3400                 g_free (uri);
3401                 uri = NULL;
3402         }
3403
3404         if (uri == NULL) {
3405                 g_warning ("Cannot find help");
3406                 return;
3407         }
3408
3409         command = g_strconcat ("gnome-help ghelp://", uri,  NULL);
3410         g_free (uri);
3411
3412         screen = gtk_widget_get_screen (GTK_WIDGET (ev_window));
3413         gdk_spawn_command_line_on_screen (screen, command, &error);
3414         if (error != NULL) {
3415                 g_warning (error->message);
3416                 g_error_free (error);
3417         }
3418         g_free (command);
3419 }
3420
3421 static void
3422 ev_window_cmd_leave_fullscreen (GtkAction *action, EvWindow *window)
3423 {
3424         ev_window_stop_fullscreen (window);
3425 }
3426
3427 static void
3428 ev_window_cmd_start_presentation (GtkAction *action, EvWindow *window)
3429 {
3430         ev_window_stop_fullscreen (window);
3431         ev_window_run_presentation (window);
3432 }
3433
3434 #ifdef WITH_GTK_PRINT
3435 static void ev_window_do_preview_print (EvWindow *window);
3436
3437 static gboolean
3438 ev_window_enumerate_printer_cb (GtkPrinter *printer,
3439                                 EvWindow   *window)
3440 {
3441         EvWindowPrivate *priv = window->priv;
3442         const gchar *printer_name;
3443
3444         printer_name = gtk_print_settings_get_printer (priv->print_settings);
3445         if ((printer_name
3446              && strcmp (printer_name, gtk_printer_get_name (printer)) == 0) ||
3447             (!printer_name && gtk_printer_is_default (printer))) {
3448                 if (priv->printer)
3449                         g_object_unref (priv->printer);
3450                 priv->printer = g_object_ref (printer);
3451
3452                 /* Now that we have the printer, we'll start the print */
3453                 ev_window_do_preview_print (window);
3454
3455                 return TRUE; /* we're done */
3456         }
3457
3458         return FALSE; /* continue the enumeration */
3459 }
3460
3461 static void
3462 ev_window_preview_print_finished (GtkPrintJob *print_job,
3463                                   EvWindow    *window,
3464                                   GError      *error)
3465 {
3466         if (error) {
3467                 GtkWidget *dialog;
3468
3469                 dialog = gtk_message_dialog_new (GTK_WINDOW (window),
3470                                                  GTK_DIALOG_MODAL,
3471                                                  GTK_MESSAGE_ERROR,
3472                                                  GTK_BUTTONS_OK,
3473                                                  _("Failed to print document"));
3474                 gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
3475                                                           error->message);
3476
3477                 gtk_dialog_run (GTK_DIALOG (dialog));
3478                 gtk_widget_destroy (dialog);
3479         }
3480
3481         g_object_unref (print_job);
3482         gtk_widget_destroy (GTK_WIDGET (window));
3483 }
3484
3485 static void
3486 ev_window_do_preview_print (EvWindow *window)
3487 {
3488         EvWindowPrivate  *priv = window->priv;
3489         GtkPageSetup     *page_setup;
3490         GtkPrintJob      *job;
3491         gchar            *filename;
3492         GError           *error = NULL;
3493
3494         g_assert (priv->print_settings != NULL);
3495         g_assert (priv->printer != NULL);
3496
3497         page_setup = gtk_page_setup_new ();
3498
3499         job = gtk_print_job_new ("evince-print",
3500                                  priv->printer,
3501                                  priv->print_settings,
3502                                  page_setup);
3503
3504         g_object_unref (priv->print_settings);
3505         priv->print_settings = NULL;
3506         g_object_unref (priv->printer);
3507         priv->printer = NULL;
3508         g_object_unref (page_setup);
3509
3510         filename = g_filename_from_uri (priv->local_uri ?
3511                                         priv->local_uri : priv->uri,
3512                                         NULL, NULL);
3513
3514         if (gtk_print_job_set_source_file (job, filename, &error)) {
3515                 gtk_print_job_send (job,
3516                                     (GtkPrintJobCompleteFunc)ev_window_preview_print_finished,
3517                                     window, NULL);
3518         } else {
3519                 g_warning (error->message);
3520                 g_error_free (error);
3521         }
3522
3523         g_free (filename);
3524
3525         gtk_widget_hide (GTK_WIDGET (window));
3526 }
3527
3528 #endif /* WITH_GTK_PRINT */
3529
3530 static void
3531 ev_window_cmd_preview_print (GtkAction *action, EvWindow *window)
3532 {
3533 #ifdef WITH_GTK_PRINT
3534         EvWindowPrivate *priv = window->priv;
3535         GtkPrintSettings *print_settings = NULL;
3536 #if GTK_CHECK_VERSION (2, 11, 0)
3537         const gchar      *print_settings_file = priv->print_settings_file;
3538
3539         if (print_settings_file) {
3540                 if (g_file_test (print_settings_file, G_FILE_TEST_IS_REGULAR)) {
3541                         GError *error = NULL;
3542
3543                         print_settings = gtk_print_settings_new_from_file (print_settings_file,
3544                                                                            &error);
3545
3546                         if (error) {
3547                                 g_warning (error->message);
3548                                 g_error_free (error);
3549                                 print_settings = NULL;
3550                         }
3551                 }
3552         }
3553 #endif /* GTK 2.11.0 */
3554
3555         if (!print_settings)
3556                 print_settings = gtk_print_settings_new ();
3557
3558         if (priv->print_settings)
3559                 g_object_unref (priv->print_settings);
3560         priv->print_settings = print_settings;
3561
3562         gtk_enumerate_printers ((GtkPrinterFunc) ev_window_enumerate_printer_cb,
3563                                 window, NULL, FALSE);
3564 #endif /* WITH_GTK_PRINT */
3565 }
3566
3567 static void
3568 ev_window_cmd_escape (GtkAction *action, EvWindow *window)
3569 {
3570         GtkWidget *widget;
3571
3572         widget = gtk_window_get_focus (GTK_WINDOW (window));
3573         if (widget && gtk_widget_get_ancestor (widget, EGG_TYPE_FIND_BAR)) {
3574                 update_chrome_flag (window, EV_CHROME_FINDBAR, FALSE);
3575                 update_chrome_visibility (window);
3576                 gtk_widget_grab_focus (window->priv->view);
3577         } else {
3578                 gboolean fullscreen;
3579                 gboolean presentation;
3580
3581                 g_object_get (window->priv->view,
3582                               "fullscreen", &fullscreen,
3583                               "presentation", &presentation,
3584                               NULL);
3585
3586                 if (fullscreen) {
3587                         ev_window_stop_fullscreen (window);
3588                 } else if (presentation) {
3589                         ev_window_stop_presentation (window);
3590                         gtk_widget_grab_focus (window->priv->view);
3591                 } else {
3592                         gtk_widget_grab_focus (window->priv->view);
3593                 }
3594
3595                 if (fullscreen && presentation)
3596                         g_warning ("Both fullscreen and presentation set somehow");
3597         }
3598 }
3599
3600 static void
3601 save_sizing_mode (EvWindow *window)
3602 {
3603         EvSizingMode mode;
3604         GEnumValue *enum_value;
3605
3606         mode = ev_view_get_sizing_mode (EV_VIEW (window->priv->view));
3607         enum_value = g_enum_get_value (EV_SIZING_MODE_CLASS, mode);
3608
3609         if (!ev_window_is_empty (window))
3610                 ev_metadata_manager_set_string (window->priv->uri, "sizing_mode",
3611                                                 enum_value->value_nick);
3612 }
3613
3614 static void
3615 ev_window_sizing_mode_changed_cb (EvView *view, GParamSpec *pspec,
3616                                   EvWindow   *ev_window)
3617 {
3618         GtkWidget *scrolled_window;
3619         EvSizingMode sizing_mode;
3620
3621         g_object_get (ev_window->priv->view,
3622                       "sizing-mode", &sizing_mode,
3623                       NULL);
3624
3625         scrolled_window = ev_window->priv->scrolled_window;
3626
3627         g_signal_handlers_disconnect_by_func (ev_window->priv->view, ev_view_update_view_size, scrolled_window);
3628
3629         if (sizing_mode != EV_SIZING_FREE)
3630                 ev_view_update_view_size (EV_VIEW (ev_window->priv->view),
3631                                           GTK_SCROLLED_WINDOW (scrolled_window));
3632
3633         switch (sizing_mode) {
3634                 case EV_SIZING_BEST_FIT:
3635                         g_object_set (G_OBJECT (scrolled_window),
3636                                       "hscrollbar-policy", GTK_POLICY_NEVER,
3637                                       "vscrollbar-policy", GTK_POLICY_AUTOMATIC,
3638                                       NULL);
3639                         g_signal_connect (ev_window->priv->view, "zoom_invalid",
3640                                           G_CALLBACK (ev_view_update_view_size),
3641                                           scrolled_window);
3642                         break;
3643                 case EV_SIZING_FIT_WIDTH:
3644                         g_object_set (G_OBJECT (scrolled_window),
3645                                       "hscrollbar-policy", GTK_POLICY_NEVER,
3646                                       "vscrollbar-policy", GTK_POLICY_AUTOMATIC,
3647                                       NULL);
3648                         g_signal_connect (ev_window->priv->view, "zoom_invalid",
3649                                           G_CALLBACK (ev_view_update_view_size),
3650                                           scrolled_window);
3651                         break;
3652                 case EV_SIZING_FREE:
3653                         g_object_set (G_OBJECT (scrolled_window),
3654                                       "hscrollbar-policy", GTK_POLICY_AUTOMATIC,
3655                                       "vscrollbar-policy", GTK_POLICY_AUTOMATIC,
3656                                       NULL);
3657                         break;
3658         }
3659
3660         update_sizing_buttons (ev_window);
3661         save_sizing_mode (ev_window);
3662 }
3663
3664 static void
3665 ev_window_zoom_changed_cb (EvView *view, GParamSpec *pspec, EvWindow *ev_window)
3666 {
3667         ev_window_update_actions (ev_window);
3668
3669         if (ev_view_get_sizing_mode (view) == EV_SIZING_FREE && !ev_window_is_empty (ev_window)) {
3670                 gdouble zoom;
3671
3672                 zoom = ev_view_get_zoom (view);
3673                 zoom *= 72.0 / get_screen_dpi (GTK_WINDOW(ev_window));
3674                 ev_metadata_manager_set_double (ev_window->priv->uri, "zoom", zoom);
3675         }
3676 }
3677
3678 static void
3679 ev_window_update_continuous_action (EvWindow *window)
3680 {
3681         GtkAction *action;
3682
3683         action = gtk_action_group_get_action (window->priv->action_group, "ViewContinuous");
3684         g_signal_handlers_block_by_func
3685                 (action, G_CALLBACK (ev_window_cmd_continuous), window);
3686         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
3687                                       ev_view_get_continuous (EV_VIEW (window->priv->view)));
3688         g_signal_handlers_unblock_by_func
3689                 (action, G_CALLBACK (ev_window_cmd_continuous), window);
3690 }
3691
3692 static void
3693 ev_window_update_dual_page_action (EvWindow *window)
3694 {
3695         GtkAction *action;
3696
3697         action = gtk_action_group_get_action (window->priv->action_group, "ViewDual");
3698         g_signal_handlers_block_by_func
3699                 (action, G_CALLBACK (ev_window_cmd_dual), window);
3700         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
3701                                       ev_view_get_dual_page (EV_VIEW (window->priv->view)));
3702         g_signal_handlers_unblock_by_func
3703                 (action, G_CALLBACK (ev_window_cmd_dual), window);
3704 }
3705
3706 static void
3707 ev_window_continuous_changed_cb (EvView *view, GParamSpec *pspec, EvWindow *ev_window)
3708 {
3709         ev_window_update_continuous_action (ev_window);
3710
3711         if (!ev_window_is_empty (ev_window))
3712                 ev_metadata_manager_set_boolean (ev_window->priv->uri, "continuous",
3713                                                  ev_view_get_continuous (EV_VIEW (ev_window->priv->view)));
3714 }
3715
3716 static void
3717 ev_window_rotation_changed_cb (EvView *view, GParamSpec *pspec, EvWindow *window)
3718 {
3719         int rotation;
3720
3721         rotation = ev_view_get_rotation (EV_VIEW (window->priv->view));
3722
3723         if (!ev_window_is_empty (window))
3724                 ev_metadata_manager_set_int (window->priv->uri, "rotation",
3725                                              rotation);
3726
3727         ev_sidebar_thumbnails_refresh (EV_SIDEBAR_THUMBNAILS (window->priv->sidebar_thumbs),
3728                                        rotation);
3729         ev_window_refresh_window_thumbnail (window, rotation);
3730 }
3731
3732 static void
3733 ev_window_has_selection_changed_cb (EvView *view, GParamSpec *pspec, EvWindow *window)
3734 {
3735         ev_window_update_actions (window);
3736 }
3737
3738 static void
3739 ev_window_dual_mode_changed_cb (EvView *view, GParamSpec *pspec, EvWindow *ev_window)
3740 {
3741         ev_window_update_dual_page_action (ev_window);
3742
3743         if (!ev_window_is_empty (ev_window))
3744                 ev_metadata_manager_set_boolean (ev_window->priv->uri, "dual-page",
3745                                                  ev_view_get_dual_page (EV_VIEW (ev_window->priv->view)));
3746 }
3747
3748 static char *
3749 build_comments_string (void)
3750 {
3751 #ifdef ENABLE_PDF
3752         PopplerBackend backend;
3753         const char *backend_name;
3754         const char *version;
3755
3756         backend = poppler_get_backend ();
3757         version = poppler_get_version ();
3758         switch (backend) {
3759                 case POPPLER_BACKEND_CAIRO:
3760                         backend_name = "cairo";
3761                         break;
3762                 case POPPLER_BACKEND_SPLASH:
3763                         backend_name = "splash";
3764                         break;
3765                 default:
3766                         backend_name = "unknown";
3767                         break;
3768         }
3769
3770         return g_strdup_printf (_("Document Viewer.\n"
3771                                   "Using poppler %s (%s)"),
3772                                 version, backend_name);
3773 #else
3774         return g_strdup_printf (_("Document Viewer"));
3775 #endif
3776 }
3777
3778 static void
3779 ev_window_cmd_help_about (GtkAction *action, EvWindow *ev_window)
3780 {
3781         const char *authors[] = {
3782                 "Martin Kretzschmar <m_kretzschmar@gmx.net>",
3783                 "Jonathan Blandford <jrb@gnome.org>",
3784                 "Marco Pesenti Gritti <marco@gnome.org>",
3785                 "Nickolay V. Shmyrev <nshmyrev@yandex.ru>",
3786                 "Bryan Clark <clarkbw@gnome.org>",
3787                 "Carlos Garcia Campos <carlosgc@gnome.org>",
3788                 "Wouter Bolsterlee <wbolster@gnome.org>",
3789                 NULL
3790         };
3791
3792         const char *documenters[] = {
3793                 "Nickolay V. Shmyrev <nshmyrev@yandex.ru>",
3794                 NULL
3795         };
3796
3797         const char *license[] = {
3798                 N_("Evince is free software; you can redistribute it and/or modify "
3799                    "it under the terms of the GNU General Public License as published by "
3800                    "the Free Software Foundation; either version 2 of the License, or "
3801                    "(at your option) any later version.\n"),
3802                 N_("Evince is distributed in the hope that it will be useful, "
3803                    "but WITHOUT ANY WARRANTY; without even the implied warranty of "
3804                    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the "
3805                    "GNU General Public License for more details.\n"),
3806                 N_("You should have received a copy of the GNU General Public License "
3807                    "along with Evince; if not, write to the Free Software Foundation, Inc., "
3808                    "59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n")
3809         };
3810
3811         char *license_trans;
3812         char *comments;
3813
3814 #ifdef ENABLE_NLS
3815         const char **p;
3816
3817         for (p = authors; *p; ++p)
3818                 *p = _(*p);
3819
3820         for (p = documenters; *p; ++p)
3821                 *p = _(*p);
3822 #endif
3823
3824         license_trans = g_strconcat (_(license[0]), "\n", _(license[1]), "\n",
3825                                      _(license[2]), "\n", NULL);
3826         comments = build_comments_string ();
3827
3828         gtk_show_about_dialog (
3829                 GTK_WINDOW (ev_window),
3830                 "name", _("Evince"),
3831                 "version", VERSION,
3832                 "copyright",
3833                 _("\xc2\xa9 1996-2007 The Evince authors"),
3834                 "license", license_trans,
3835                 "website", "http://www.gnome.org/projects/evince",
3836                 "comments", comments,
3837                 "authors", authors,
3838                 "documenters", documenters,
3839                 "translator-credits", _("translator-credits"),
3840                 "logo-icon-name", "evince",
3841                 "wrap-license", TRUE,
3842                 NULL);
3843
3844         g_free (comments);
3845         g_free (license_trans);
3846 }
3847
3848 static void
3849 ev_window_view_toolbar_cb (GtkAction *action, EvWindow *ev_window)
3850 {
3851         gboolean active;
3852
3853         active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
3854         update_chrome_flag (ev_window, EV_CHROME_TOOLBAR, active);
3855         update_chrome_visibility (ev_window);
3856         ev_metadata_manager_set_boolean (NULL, "show_toolbar", active);
3857 }
3858
3859 static void
3860 ev_window_view_sidebar_cb (GtkAction *action, EvWindow *ev_window)
3861 {
3862         if (ev_view_get_presentation (EV_VIEW (ev_window->priv->view)))
3863                 return;
3864
3865         update_chrome_flag (ev_window, EV_CHROME_SIDEBAR,
3866                             gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)));
3867         update_chrome_visibility (ev_window);
3868 }
3869
3870 static void
3871 ev_window_sidebar_current_page_changed_cb (EvSidebar  *ev_sidebar,
3872                                            GParamSpec *pspec,
3873                                            EvWindow   *ev_window)
3874 {
3875         GtkWidget *current_page;
3876         const char *id;
3877
3878         g_object_get (G_OBJECT (ev_sidebar), "current_page", &current_page, NULL);
3879
3880         if (current_page == ev_window->priv->sidebar_links) {
3881                 id = LINKS_SIDEBAR_ID;
3882         } else if (current_page == ev_window->priv->sidebar_thumbs) {
3883                 id = THUMBNAILS_SIDEBAR_ID;
3884         } else if (current_page == ev_window->priv->sidebar_attachments) {
3885                 id = ATTACHMENTS_SIDEBAR_ID;
3886         } else {
3887                 g_assert_not_reached();
3888         }
3889
3890         g_object_unref (current_page);
3891
3892         if (!ev_window_is_empty (ev_window))
3893                 ev_metadata_manager_set_string (ev_window->priv->uri, "sidebar_page", id);
3894 }
3895
3896 static void
3897 ev_window_sidebar_visibility_changed_cb (EvSidebar  *ev_sidebar,
3898                                          GParamSpec *pspec,
3899                                          EvWindow   *ev_window)
3900 {
3901         EvView *view = EV_VIEW (ev_window->priv->view);
3902         GtkAction *action;
3903
3904         action = gtk_action_group_get_action (ev_window->priv->action_group, "ViewSidebar");
3905
3906         if (!ev_view_get_presentation (view)) {
3907                 gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
3908                                               GTK_WIDGET_VISIBLE (ev_sidebar));
3909
3910                 ev_metadata_manager_set_boolean (ev_window->priv->uri, "sidebar_visibility",
3911                                                  GTK_WIDGET_VISIBLE (ev_sidebar));
3912         }
3913 }
3914
3915 static void
3916 view_menu_link_popup (EvWindow *ev_window,
3917                       EvLink   *link)
3918 {
3919         gboolean   show_external = FALSE;
3920         gboolean   show_internal = FALSE;
3921         GtkAction *action;
3922
3923         if (ev_window->priv->link)
3924                 g_object_unref (ev_window->priv->link);
3925
3926         if (link)
3927                 ev_window->priv->link = g_object_ref (link);
3928         else
3929                 ev_window->priv->link = NULL;
3930
3931         if (ev_window->priv->link) {
3932                 EvLinkAction *ev_action;
3933
3934                 ev_action = ev_link_get_action (link);
3935                 if (ev_action) {
3936                         switch (ev_link_action_get_action_type (ev_action)) {
3937                                 case EV_LINK_ACTION_TYPE_GOTO_DEST:
3938                                 case EV_LINK_ACTION_TYPE_GOTO_REMOTE:
3939                                         show_internal = TRUE;
3940                                         break;
3941                                 case EV_LINK_ACTION_TYPE_EXTERNAL_URI:
3942                                 case EV_LINK_ACTION_TYPE_LAUNCH:
3943                                         show_external = TRUE;
3944                                         break;
3945                                 default:
3946                                         break;
3947                         }
3948                 }
3949         }
3950
3951         action = gtk_action_group_get_action (ev_window->priv->view_popup_action_group,
3952                                               "OpenLink");
3953         gtk_action_set_visible (action, show_external);
3954
3955         action = gtk_action_group_get_action (ev_window->priv->view_popup_action_group,
3956                                               "CopyLinkAddress");
3957         gtk_action_set_visible (action, show_external);
3958
3959         action = gtk_action_group_get_action (ev_window->priv->view_popup_action_group,
3960                                               "GoLink");
3961         gtk_action_set_visible (action, show_internal);
3962
3963         action = gtk_action_group_get_action (ev_window->priv->view_popup_action_group,
3964                                               "OpenLinkNewWindow");
3965         gtk_action_set_visible (action, show_internal);
3966 }
3967
3968 static void
3969 view_menu_image_popup (EvWindow  *ev_window,
3970                        EvImage   *image)
3971 {
3972         GtkAction *action;
3973         gboolean   show_image = FALSE;
3974
3975         if (ev_window->priv->image)
3976                 g_object_unref (ev_window->priv->image);
3977
3978         if (image)
3979                 ev_window->priv->image = g_object_ref (image);
3980         else
3981                 ev_window->priv->image = NULL;
3982
3983         show_image = (ev_window->priv->image != NULL);
3984
3985         action = gtk_action_group_get_action (ev_window->priv->view_popup_action_group,
3986                                               "SaveImageAs");
3987         gtk_action_set_visible (action, show_image);
3988
3989         action = gtk_action_group_get_action (ev_window->priv->view_popup_action_group,
3990                                               "CopyImage");
3991         gtk_action_set_visible (action, show_image);
3992 }
3993
3994 static gboolean
3995 view_menu_popup_cb (EvView   *view,
3996                     GObject  *object,
3997                     EvWindow *ev_window)
3998 {
3999         if (ev_view_get_presentation (EV_VIEW (ev_window->priv->view)))
4000                 return FALSE;
4001
4002         view_menu_link_popup (ev_window,
4003                               EV_IS_LINK (object) ? EV_LINK (object) : NULL);
4004         view_menu_image_popup (ev_window,
4005                                EV_IS_IMAGE (object) ? EV_IMAGE (object) : NULL);
4006
4007         gtk_menu_popup (GTK_MENU (ev_window->priv->view_popup),
4008                         NULL, NULL, NULL, NULL,
4009                         3, gtk_get_current_event_time ());
4010         return TRUE;
4011 }
4012
4013 static gboolean
4014 attachment_bar_menu_popup_cb (EvSidebarAttachments *attachbar,
4015                               GList           *attach_list,
4016                               EvWindow        *ev_window)
4017 {
4018         GtkWidget *popup;
4019
4020         g_assert (attach_list != NULL);
4021
4022         if (ev_window->priv->attach_list) {
4023                 g_list_foreach (ev_window->priv->attach_list,
4024                                 (GFunc) g_object_unref, NULL);
4025                 g_list_free (ev_window->priv->attach_list);
4026         }
4027
4028         ev_window->priv->attach_list = attach_list;
4029
4030         popup = ev_window->priv->attachment_popup;
4031
4032         gtk_menu_popup (GTK_MENU (popup), NULL, NULL,
4033                         NULL, NULL,
4034                         3, gtk_get_current_event_time ());
4035
4036         return TRUE;
4037 }
4038
4039 static void
4040 view_find_status_changed_cb (EvView     *view,
4041                              GParamSpec *pspec,
4042                              EvWindow   *ev_window)
4043 {
4044         const char *text;
4045
4046         text = ev_view_get_find_status (view);
4047         egg_find_bar_set_status_text (EGG_FIND_BAR (ev_window->priv->find_bar),
4048                                       text);
4049 }
4050
4051 static void
4052 find_bar_previous_cb (EggFindBar *find_bar,
4053                       EvWindow   *ev_window)
4054 {
4055         ev_view_find_previous (EV_VIEW (ev_window->priv->view));
4056 }
4057
4058 static void
4059 find_bar_next_cb (EggFindBar *find_bar,
4060                   EvWindow   *ev_window)
4061 {
4062         ev_view_find_next (EV_VIEW (ev_window->priv->view));
4063 }
4064
4065 static void
4066 find_bar_close_cb (EggFindBar *find_bar,
4067                    EvWindow   *ev_window)
4068 {
4069         update_chrome_flag (ev_window, EV_CHROME_FINDBAR, FALSE);
4070         update_chrome_visibility (ev_window);
4071 }
4072
4073 static void
4074 find_bar_search_changed_cb (EggFindBar *find_bar,
4075                             GParamSpec *param,
4076                             EvWindow   *ev_window)
4077 {
4078         gboolean case_sensitive;
4079         const char *search_string;
4080
4081         /* Either the string or case sensitivity could have changed. */
4082
4083         case_sensitive = egg_find_bar_get_case_sensitive (find_bar);
4084         search_string = egg_find_bar_get_search_string (find_bar);
4085
4086         ev_view_search_changed (EV_VIEW(ev_window->priv->view));
4087
4088         if (ev_window->priv->document &&
4089             EV_IS_DOCUMENT_FIND (ev_window->priv->document)) {
4090                 if (search_string && search_string[0]) {
4091                         ev_document_doc_mutex_lock ();
4092                         ev_document_find_begin (EV_DOCUMENT_FIND (ev_window->priv->document),
4093                                                 ev_page_cache_get_current_page (ev_window->priv->page_cache),
4094                                                 search_string,
4095                                                 case_sensitive);
4096                         ev_document_doc_mutex_unlock ();
4097                 } else {
4098                         ev_document_doc_mutex_lock ();
4099                         ev_document_find_cancel (EV_DOCUMENT_FIND (ev_window->priv->document));
4100                         ev_document_doc_mutex_unlock ();
4101
4102                         ev_window_update_actions (ev_window);
4103                         egg_find_bar_set_status_text (EGG_FIND_BAR (ev_window->priv->find_bar),
4104                                                       NULL);
4105                         gtk_widget_queue_draw (GTK_WIDGET (ev_window->priv->view));
4106                 }
4107         }
4108 }
4109
4110 static void
4111 find_bar_visibility_changed_cb (EggFindBar *find_bar,
4112                             GParamSpec *param,
4113                             EvWindow   *ev_window)
4114 {
4115         gboolean visible;
4116
4117         visible = GTK_WIDGET_VISIBLE (find_bar);
4118
4119         if (ev_window->priv->document &&
4120             EV_IS_DOCUMENT_FIND (ev_window->priv->document)) {
4121                 ev_view_set_highlight_search (EV_VIEW(ev_window->priv->view), visible);
4122                 ev_view_search_changed (EV_VIEW(ev_window->priv->view));
4123                 ev_window_update_actions (ev_window);
4124
4125                 if (!visible)
4126                         egg_find_bar_set_status_text (EGG_FIND_BAR (ev_window->priv->find_bar), NULL);
4127         }
4128 }
4129
4130 static void
4131 find_bar_scroll(EggFindBar *find_bar, GtkScrollType scroll, EvWindow* ev_window)
4132 {
4133         ev_view_scroll(EV_VIEW(ev_window->priv->view), scroll, FALSE);
4134 }
4135
4136 static void
4137 zoom_control_changed_cb (EphyZoomAction *action,
4138                          float           zoom,
4139                          EvWindow       *ev_window)
4140 {
4141         EvSizingMode mode;
4142
4143         g_return_if_fail (EV_IS_WINDOW (ev_window));
4144
4145         if (zoom == EPHY_ZOOM_BEST_FIT) {
4146                 mode = EV_SIZING_BEST_FIT;
4147         } else if (zoom == EPHY_ZOOM_FIT_WIDTH) {
4148                 mode = EV_SIZING_FIT_WIDTH;
4149         } else {
4150                 mode = EV_SIZING_FREE;
4151         }
4152
4153         ev_view_set_sizing_mode (EV_VIEW (ev_window->priv->view), mode);
4154
4155         if (mode == EV_SIZING_FREE) {
4156                 ev_view_set_zoom (EV_VIEW (ev_window->priv->view),
4157                                   zoom * get_screen_dpi (GTK_WINDOW (ev_window)) / 72.0,
4158                                   FALSE);
4159         }
4160 }
4161
4162 static void
4163 ev_window_finalize (GObject *object)
4164 {
4165         GList *windows = ev_application_get_windows (EV_APP);
4166
4167         if (windows == NULL) {
4168                 ev_application_shutdown (EV_APP);
4169         } else {
4170                 g_list_free (windows);
4171         }
4172
4173         G_OBJECT_CLASS (ev_window_parent_class)->finalize (object);
4174 }
4175
4176 static void
4177 ev_window_dispose (GObject *object)
4178 {
4179         EvWindow *window = EV_WINDOW (object);
4180         EvWindowPrivate *priv = window->priv;
4181
4182         if (priv->title) {
4183                 ev_window_title_free (priv->title);
4184                 priv->title = NULL;
4185         }
4186
4187         if (priv->ui_manager) {
4188                 g_object_unref (priv->ui_manager);
4189                 priv->ui_manager = NULL;
4190         }
4191
4192         if (priv->action_group) {
4193                 g_object_unref (priv->action_group);
4194                 priv->action_group = NULL;
4195         }
4196
4197         if (priv->view_popup_action_group) {
4198                 g_object_unref (priv->view_popup_action_group);
4199                 priv->view_popup_action_group = NULL;
4200         }
4201
4202         if (priv->attachment_popup_action_group) {
4203                 g_object_unref (priv->attachment_popup_action_group);
4204                 priv->attachment_popup_action_group = NULL;
4205         }
4206
4207         if (priv->recent_action_group) {
4208                 g_object_unref (priv->recent_action_group);
4209                 priv->recent_action_group = NULL;
4210         }
4211
4212         if (priv->recent_manager) {
4213                 g_signal_handlers_disconnect_by_func (priv->recent_manager,
4214                                                       ev_window_setup_recent,
4215                                                       window);
4216                 priv->recent_manager = NULL;
4217         }
4218
4219         priv->recent_ui_id = 0;
4220
4221         if (priv->page_cache) {
4222                 g_signal_handlers_disconnect_by_func (priv->page_cache, page_changed_cb, window);
4223                 priv->page_cache = NULL;
4224         }
4225
4226         if (priv->document) {
4227                 g_object_unref (priv->document);
4228                 priv->document = NULL;
4229         }
4230
4231         if (priv->view) {
4232                 g_object_unref (priv->view);
4233                 priv->view = NULL;
4234         }
4235
4236         if (priv->password_view) {
4237                 g_object_unref (priv->password_view);
4238                 priv->password_view = NULL;
4239         }
4240
4241         if (priv->load_job) {
4242                 ev_window_clear_load_job (window);
4243         }
4244
4245         if (priv->save_job) {
4246                 ev_window_clear_save_job (window);
4247         }
4248
4249         if (priv->thumbnail_job) {
4250                 ev_window_clear_thumbnail_job (window);
4251         }
4252
4253         if (priv->local_uri) {
4254                 ev_window_clear_local_uri (window);
4255                 priv->local_uri = NULL;
4256         }
4257
4258         ev_window_close_dialogs (window);
4259
4260 #ifdef WITH_GTK_PRINT
4261         ev_window_clear_print_job (window);
4262
4263         if (window->priv->gtk_print_job) {
4264                 g_object_unref (window->priv->gtk_print_job);
4265                 window->priv->gtk_print_job = NULL;
4266         }
4267
4268         if (window->priv->printer) {
4269                 g_object_unref (window->priv->printer);
4270                 window->priv->printer = NULL;
4271         }
4272
4273         if (window->priv->print_settings) {
4274                 g_object_unref (window->priv->print_settings);
4275                 window->priv->print_settings = NULL;
4276         }
4277
4278         if (window->priv->print_page_setup) {
4279                 g_object_unref (window->priv->print_page_setup);
4280                 window->priv->print_page_setup = NULL;
4281         }
4282 #endif
4283
4284         if (priv->link) {
4285                 g_object_unref (priv->link);
4286                 priv->link = NULL;
4287         }
4288
4289         if (priv->image) {
4290                 g_object_unref (priv->image);
4291                 priv->image = NULL;
4292         }
4293
4294         if (priv->attach_list) {
4295                 g_list_foreach (priv->attach_list,
4296                                 (GFunc) g_object_unref,
4297                                 NULL);
4298                 g_list_free (priv->attach_list);
4299                 priv->attach_list = NULL;
4300         }
4301
4302         if (priv->find_bar) {
4303                 g_signal_handlers_disconnect_by_func
4304                         (window->priv->find_bar,
4305                          G_CALLBACK (find_bar_close_cb),
4306                          window);
4307                 priv->find_bar = NULL;
4308         }
4309
4310         if (priv->uri) {
4311                 if (priv->unlink_temp_file)
4312                         ev_window_clear_temp_file (window);
4313                 g_free (priv->uri);
4314                 priv->uri = NULL;
4315         }
4316
4317         if (priv->dest) {
4318                 g_object_unref (priv->dest);
4319                 priv->dest = NULL;
4320         }
4321
4322         if (priv->history) {
4323                 g_object_unref (priv->history);
4324                 priv->history = NULL;
4325         }
4326
4327         if (priv->print_settings_file) {
4328                 ev_window_clear_print_settings_file (window);
4329                 priv->print_settings_file = NULL;
4330         }
4331
4332         if (priv->presentation_timeout_id > 0) {
4333                 g_source_remove (priv->presentation_timeout_id);
4334                 priv->presentation_timeout_id = 0;
4335         }
4336
4337         G_OBJECT_CLASS (ev_window_parent_class)->dispose (object);
4338 }
4339
4340 static void
4341 ev_window_class_init (EvWindowClass *ev_window_class)
4342 {
4343         GObjectClass *g_object_class = G_OBJECT_CLASS (ev_window_class);
4344         GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (ev_window_class);
4345
4346         g_object_class->dispose = ev_window_dispose;
4347         g_object_class->finalize = ev_window_finalize;
4348
4349         widget_class->screen_changed = ev_window_screen_changed;
4350
4351         g_type_class_add_private (g_object_class, sizeof (EvWindowPrivate));
4352 }
4353
4354 /* Normal items */
4355 static const GtkActionEntry entries[] = {
4356         { "File", NULL, N_("_File") },
4357         { "Edit", NULL, N_("_Edit") },
4358         { "View", NULL, N_("_View") },
4359         { "Go", NULL, N_("_Go") },
4360         { "Help", NULL, N_("_Help") },
4361
4362         /* File menu */
4363         { "FileOpen", GTK_STOCK_OPEN, N_("_Open..."), "<control>O",
4364           N_("Open an existing document"),
4365           G_CALLBACK (ev_window_cmd_file_open) },
4366         { "FileOpenCopy", NULL, N_("Op_en a Copy"), NULL,
4367           N_("Open a copy of the current document in a new window"),
4368           G_CALLBACK (ev_window_cmd_file_open_copy) },
4369         { "FileSaveAs", GTK_STOCK_SAVE_AS, N_("_Save a Copy..."), "<control>S",
4370           N_("Save a copy of the current document"),
4371           G_CALLBACK (ev_window_cmd_save_as) },
4372         { "FilePrintSetup", NULL, N_("Print Set_up..."), NULL,
4373           N_("Setup the page settings for printing"),
4374           G_CALLBACK (ev_window_cmd_file_print_setup) },
4375         { "FilePrint", GTK_STOCK_PRINT, N_("_Print..."), "<control>P",
4376           N_("Print this document"),
4377           G_CALLBACK (ev_window_cmd_file_print) },
4378         { "FileProperties", GTK_STOCK_PROPERTIES, N_("P_roperties"), "<alt>Return", NULL,
4379           G_CALLBACK (ev_window_cmd_file_properties) },
4380         { "FileCloseWindow", GTK_STOCK_CLOSE, NULL, "<control>W", NULL,
4381           G_CALLBACK (ev_window_cmd_file_close_window) },
4382
4383         /* Edit menu */
4384         { "EditCopy", GTK_STOCK_COPY, NULL, "<control>C", NULL,
4385           G_CALLBACK (ev_window_cmd_edit_copy) },
4386         { "EditSelectAll", GTK_STOCK_SELECT_ALL, N_("Select _All"), "<control>A", NULL,
4387           G_CALLBACK (ev_window_cmd_edit_select_all) },
4388         { "EditFind", GTK_STOCK_FIND, N_("_Find..."), "<control>F",
4389           N_("Find a word or phrase in the document"),
4390           G_CALLBACK (ev_window_cmd_edit_find) },
4391         { "EditFindNext", NULL, N_("Find Ne_xt"), "<control>G", NULL,
4392           G_CALLBACK (ev_window_cmd_edit_find_next) },
4393         { "EditFindPrevious", NULL, N_("Find Pre_vious"), "<shift><control>G", NULL,
4394           G_CALLBACK (ev_window_cmd_edit_find_previous) },
4395         { "EditToolbar", NULL, N_("T_oolbar"), NULL, NULL,
4396           G_CALLBACK (ev_window_cmd_edit_toolbar) },
4397         { "EditRotateLeft", EV_STOCK_ROTATE_LEFT, N_("Rotate _Left"), NULL, NULL,
4398           G_CALLBACK (ev_window_cmd_edit_rotate_left) },
4399         { "EditRotateRight", EV_STOCK_ROTATE_RIGHT, N_("Rotate _Right"), NULL, NULL,
4400           G_CALLBACK (ev_window_cmd_edit_rotate_right) },
4401
4402         /* View menu */
4403         { "ViewZoomIn", GTK_STOCK_ZOOM_IN, NULL, "<control>plus",
4404           N_("Enlarge the document"),
4405           G_CALLBACK (ev_window_cmd_view_zoom_in) },
4406         { "ViewZoomOut", GTK_STOCK_ZOOM_OUT, NULL, "<control>minus",
4407           N_("Shrink the document"),
4408           G_CALLBACK (ev_window_cmd_view_zoom_out) },
4409         { "ViewReload", GTK_STOCK_REFRESH, N_("_Reload"), "<control>R",
4410           N_("Reload the document"),
4411           G_CALLBACK (ev_window_cmd_view_reload) },
4412
4413         { "ViewAutoscroll", GTK_STOCK_MEDIA_PLAY, N_("Auto_scroll"), NULL, NULL,
4414           G_CALLBACK (ev_window_cmd_view_autoscroll) },
4415
4416         /* Go menu */
4417         { "GoPreviousPage", GTK_STOCK_GO_UP, N_("_Previous Page"), "<control>Page_Up",
4418           N_("Go to the previous page"),
4419           G_CALLBACK (ev_window_cmd_go_previous_page) },
4420         { "GoNextPage", GTK_STOCK_GO_DOWN, N_("_Next Page"), "<control>Page_Down",
4421           N_("Go to the next page"),
4422           G_CALLBACK (ev_window_cmd_go_next_page) },
4423         { "GoFirstPage", GTK_STOCK_GOTO_TOP, N_("_First Page"), "<control>Home",
4424           N_("Go to the first page"),
4425           G_CALLBACK (ev_window_cmd_go_first_page) },
4426         { "GoLastPage", GTK_STOCK_GOTO_BOTTOM, N_("_Last Page"), "<control>End",
4427           N_("Go to the last page"),
4428           G_CALLBACK (ev_window_cmd_go_last_page) },
4429
4430         /* Help menu */
4431         { "HelpContents", GTK_STOCK_HELP, N_("_Contents"), "F1", NULL,
4432           G_CALLBACK (ev_window_cmd_help_contents) },
4433
4434         { "HelpAbout", GTK_STOCK_ABOUT, N_("_About"), NULL, NULL,
4435           G_CALLBACK (ev_window_cmd_help_about) },
4436
4437         /* Toolbar-only */
4438         { "LeaveFullscreen", GTK_STOCK_LEAVE_FULLSCREEN, N_("Leave Fullscreen"), NULL,
4439           N_("Leave fullscreen mode"),
4440           G_CALLBACK (ev_window_cmd_leave_fullscreen) },
4441         { "StartPresentation", EV_STOCK_RUN_PRESENTATION, N_("Start Presentation"), NULL,
4442           N_("Start a presentation"),
4443           G_CALLBACK (ev_window_cmd_start_presentation) },
4444         { "PreviewPrint", GTK_STOCK_PRINT, N_("Print"), NULL,
4445           N_("Print this document"),
4446           G_CALLBACK (ev_window_cmd_preview_print) },
4447
4448         /* Accellerators */
4449         { "Escape", NULL, "", "Escape", "",
4450           G_CALLBACK (ev_window_cmd_escape) },
4451         { "Slash", GTK_STOCK_FIND, NULL, "slash", NULL,
4452           G_CALLBACK (ev_window_cmd_edit_find) },
4453         { "PageDown", NULL, "", "Page_Down", NULL,
4454           G_CALLBACK (ev_window_cmd_scroll_forward) },
4455         { "PageUp", NULL, "", "Page_Up", NULL,
4456           G_CALLBACK (ev_window_cmd_scroll_backward) },
4457         { "Space", NULL, "", "space", NULL,
4458           G_CALLBACK (ev_window_cmd_scroll_forward) },
4459         { "ShiftSpace", NULL, "", "<shift>space", NULL,
4460           G_CALLBACK (ev_window_cmd_scroll_backward) },
4461         { "BackSpace", NULL, "", "BackSpace", NULL,
4462           G_CALLBACK (ev_window_cmd_scroll_backward) },
4463         { "ShiftBackSpace", NULL, "", "<shift>BackSpace", NULL,
4464           G_CALLBACK (ev_window_cmd_scroll_forward) },
4465         { "Return", NULL, "", "Return", NULL,
4466           G_CALLBACK (ev_window_cmd_scroll_forward) },
4467         { "ShiftReturn", NULL, "", "<shift>Return", NULL,
4468           G_CALLBACK (ev_window_cmd_scroll_backward) },
4469         { "Plus", GTK_STOCK_ZOOM_IN, NULL, "plus", NULL,
4470           G_CALLBACK (ev_window_cmd_view_zoom_in) },
4471         { "CtrlEqual", GTK_STOCK_ZOOM_IN, NULL, "<control>equal", NULL,
4472           G_CALLBACK (ev_window_cmd_view_zoom_in) },
4473         { "Equal", GTK_STOCK_ZOOM_IN, NULL, "equal", NULL,
4474           G_CALLBACK (ev_window_cmd_view_zoom_in) },
4475         { "Minus", GTK_STOCK_ZOOM_OUT, NULL, "minus", NULL,
4476           G_CALLBACK (ev_window_cmd_view_zoom_out) },
4477         { "FocusPageSelector", NULL, "", "<control>l", NULL,
4478           G_CALLBACK (ev_window_cmd_focus_page_selector) },
4479         { "GoBackwardFast", NULL, "", "<shift>Page_Up", NULL,
4480           G_CALLBACK (ev_window_cmd_go_backward) },
4481         { "GoForwardFast", NULL, "", "<shift>Page_Down", NULL,
4482           G_CALLBACK (ev_window_cmd_go_forward) },
4483         { "KpPlus", GTK_STOCK_ZOOM_IN, NULL, "KP_Add", NULL,
4484           G_CALLBACK (ev_window_cmd_view_zoom_in) },
4485         { "KpMinus", GTK_STOCK_ZOOM_OUT, NULL, "KP_Subtract", NULL,
4486           G_CALLBACK (ev_window_cmd_view_zoom_out) },
4487         { "CtrlKpPlus", GTK_STOCK_ZOOM_IN, NULL, "<control>KP_Add", NULL,
4488           G_CALLBACK (ev_window_cmd_view_zoom_in) },
4489         { "CtrlKpMinus", GTK_STOCK_ZOOM_OUT, NULL, "<control>KP_Subtract", NULL,
4490           G_CALLBACK (ev_window_cmd_view_zoom_out) },
4491 };
4492
4493 /* Toggle items */
4494 static const GtkToggleActionEntry toggle_entries[] = {
4495         /* View Menu */
4496         { "ViewToolbar", NULL, N_("_Toolbar"), NULL,
4497           N_("Show or hide the toolbar"),
4498           G_CALLBACK (ev_window_view_toolbar_cb), TRUE },
4499         { "ViewSidebar", GTK_STOCK_INDEX, N_("Side _Pane"), "F9",
4500           N_("Show or hide the side pane"),
4501           G_CALLBACK (ev_window_view_sidebar_cb), TRUE },
4502         { "ViewContinuous", EV_STOCK_VIEW_CONTINUOUS, N_("_Continuous"), NULL,
4503           N_("Show the entire document"),
4504           G_CALLBACK (ev_window_cmd_continuous), TRUE },
4505         { "ViewDual", EV_STOCK_VIEW_DUAL, N_("_Dual"), NULL,
4506           N_("Show two pages at once"),
4507           G_CALLBACK (ev_window_cmd_dual), FALSE },
4508         { "ViewFullscreen", GTK_STOCK_FULLSCREEN, N_("_Fullscreen"), "F11",
4509           N_("Expand the window to fill the screen"),
4510           G_CALLBACK (ev_window_cmd_view_fullscreen) },
4511         { "ViewPresentation", EV_STOCK_RUN_PRESENTATION, N_("Pre_sentation"), "F5",
4512           N_("Run document as a presentation"),
4513           G_CALLBACK (ev_window_cmd_view_presentation) },
4514         { "ViewBestFit", EV_STOCK_ZOOM_PAGE, N_("_Best Fit"), NULL,
4515           N_("Make the current document fill the window"),
4516           G_CALLBACK (ev_window_cmd_view_best_fit) },
4517         { "ViewPageWidth", EV_STOCK_ZOOM_WIDTH, N_("Fit Page _Width"), NULL,
4518           N_("Make the current document fill the window width"),
4519           G_CALLBACK (ev_window_cmd_view_page_width) },
4520 };
4521
4522 /* Popups specific items */
4523 static const GtkActionEntry view_popup_entries [] = {
4524         /* Links */
4525         { "OpenLink", GTK_STOCK_OPEN, N_("_Open Link"), NULL,
4526           NULL, G_CALLBACK (ev_view_popup_cmd_open_link) },
4527         { "GoLink", GTK_STOCK_GO_FORWARD, N_("_Go To"), NULL,
4528           NULL, G_CALLBACK (ev_view_popup_cmd_open_link) },
4529         { "OpenLinkNewWindow", NULL, N_("Open in New _Window"), NULL,
4530           NULL, G_CALLBACK (ev_view_popup_cmd_open_link_new_window) },
4531         { "CopyLinkAddress", NULL, N_("_Copy Link Address"), NULL,
4532           NULL, G_CALLBACK (ev_view_popup_cmd_copy_link_address) },
4533         { "SaveImageAs", NULL, N_("_Save Image As..."), NULL,
4534           NULL, G_CALLBACK (ev_view_popup_cmd_save_image_as) },
4535         { "CopyImage", NULL, N_("Copy _Image"), NULL,
4536           NULL, G_CALLBACK (ev_view_popup_cmd_copy_image) },
4537 };
4538
4539 static const GtkActionEntry attachment_popup_entries [] = {
4540         { "OpenAttachment", GTK_STOCK_OPEN, N_("_Open..."), NULL,
4541           NULL, G_CALLBACK (ev_attachment_popup_cmd_open_attachment) },
4542         { "SaveAttachmentAs", GTK_STOCK_SAVE_AS, N_("_Save a Copy..."), NULL,
4543           NULL, G_CALLBACK (ev_attachment_popup_cmd_save_attachment_as) },
4544 };
4545
4546 static void
4547 sidebar_links_link_activated_cb (EvSidebarLinks *sidebar_links, EvLink *link, EvWindow *window)
4548 {
4549         ev_view_handle_link (EV_VIEW (window->priv->view), link);
4550 }
4551
4552 static void
4553 activate_link_cb (EvPageAction *page_action, EvLink *link, EvWindow *window)
4554 {
4555         ev_view_handle_link (EV_VIEW (window->priv->view), link);
4556         gtk_widget_grab_focus (window->priv->view);
4557 }
4558
4559 static void
4560 navigation_action_activate_link_cb (EvNavigationAction *action, EvLink *link, EvWindow *window)
4561 {
4562
4563         ev_view_handle_link (EV_VIEW (window->priv->view), link);
4564         gtk_widget_grab_focus (window->priv->view);
4565 }
4566
4567 static void
4568 register_custom_actions (EvWindow *window, GtkActionGroup *group)
4569 {
4570         GtkAction *action;
4571
4572         action = g_object_new (EV_TYPE_PAGE_ACTION,
4573                                "name", PAGE_SELECTOR_ACTION,
4574                                "label", _("Page"),
4575                                "tooltip", _("Select Page"),
4576                                "icon_name", "text-x-generic",
4577                                "visible_overflown", FALSE,
4578                                NULL);
4579         g_signal_connect (action, "activate_link",
4580                           G_CALLBACK (activate_link_cb), window);
4581         gtk_action_group_add_action (group, action);
4582         g_object_unref (action);
4583
4584         action = g_object_new (EPHY_TYPE_ZOOM_ACTION,
4585                                "name", ZOOM_CONTROL_ACTION,
4586                                "label", _("Zoom"),
4587                                "stock_id", EV_STOCK_ZOOM,
4588                                "tooltip", _("Adjust the zoom level"),
4589                                "zoom", 1.0,
4590                                NULL);
4591         g_signal_connect (action, "zoom_to_level",
4592                           G_CALLBACK (zoom_control_changed_cb), window);
4593         gtk_action_group_add_action (group, action);
4594         g_object_unref (action);
4595
4596         action = g_object_new (EV_TYPE_NAVIGATION_ACTION,
4597                                "name", NAVIGATION_ACTION,
4598                                "label", _("Navigation"),
4599                                "is_important", TRUE,
4600                                "short_label", _("Back"),
4601                                "stock_id", GTK_STOCK_GO_DOWN,
4602                                /*translators: this is the history action*/
4603                                "tooltip", _("Move across visited pages"),
4604                                NULL);
4605         g_signal_connect (action, "activate_link",
4606                           G_CALLBACK (navigation_action_activate_link_cb), window);
4607         gtk_action_group_add_action (group, action);
4608         g_object_unref (action);
4609
4610         action = g_object_new (EV_TYPE_OPEN_RECENT_ACTION,
4611                                "name", "FileOpenRecent",
4612                                "label", _("_Open..."),
4613                                "tooltip", _("Open an existing document"),
4614                                "stock_id", GTK_STOCK_OPEN,
4615                                NULL);
4616         g_signal_connect (action, "activate",
4617                           G_CALLBACK (ev_window_cmd_file_open), window);
4618         g_signal_connect (action, "item_activated",
4619                           G_CALLBACK (ev_window_open_recent_action_item_activated),
4620                           window);
4621         gtk_action_group_add_action (group, action);
4622         g_object_unref (action);
4623 }
4624
4625 static void
4626 set_action_properties (GtkActionGroup *action_group)
4627 {
4628         GtkAction *action;
4629
4630         action = gtk_action_group_get_action (action_group, "GoPreviousPage");
4631         g_object_set (action, "is-important", TRUE, NULL);
4632         /*translators: this is the label for toolbar button*/
4633         g_object_set (action, "short_label", _("Previous"), NULL);
4634
4635         action = gtk_action_group_get_action (action_group, "GoNextPage");
4636         g_object_set (action, "is-important", TRUE, NULL);
4637         /*translators: this is the label for toolbar button*/
4638         g_object_set (action, "short_label", _("Next"), NULL);
4639
4640         action = gtk_action_group_get_action (action_group, "ViewZoomIn");
4641         /*translators: this is the label for toolbar button*/
4642         g_object_set (action, "short_label", _("Zoom In"), NULL);
4643
4644         action = gtk_action_group_get_action (action_group, "ViewZoomOut");
4645         /*translators: this is the label for toolbar button*/
4646         g_object_set (action, "short_label", _("Zoom Out"), NULL);
4647
4648         action = gtk_action_group_get_action (action_group, "ViewBestFit");
4649         /*translators: this is the label for toolbar button*/
4650         g_object_set (action, "short_label", _("Best Fit"), NULL);
4651
4652         action = gtk_action_group_get_action (action_group, "ViewPageWidth");
4653         /*translators: this is the label for toolbar button*/
4654         g_object_set (action, "short_label", _("Fit Width"), NULL);
4655
4656         action = gtk_action_group_get_action (action_group, "LeaveFullscreen");
4657         g_object_set (action, "is-important", TRUE, NULL);
4658 }
4659
4660 static void
4661 set_chrome_actions (EvWindow *window)
4662 {
4663         EvWindowPrivate *priv = window->priv;
4664         GtkActionGroup *action_group = priv->action_group;
4665         GtkAction *action;
4666
4667         action= gtk_action_group_get_action (action_group, "ViewToolbar");
4668         g_signal_handlers_block_by_func
4669                 (action, G_CALLBACK (ev_window_view_toolbar_cb), window);
4670         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
4671                                       (priv->chrome & EV_CHROME_TOOLBAR) != 0);
4672         g_signal_handlers_unblock_by_func
4673                 (action, G_CALLBACK (ev_window_view_toolbar_cb), window);
4674 }
4675
4676 static void
4677 sidebar_widget_model_set (EvSidebarLinks *ev_sidebar_links,
4678                           GParamSpec     *pspec,
4679                           EvWindow       *ev_window)
4680 {
4681         GtkTreeModel *model;
4682         GtkAction *action;
4683
4684         g_object_get (G_OBJECT (ev_sidebar_links),
4685                       "model", &model,
4686                       NULL);
4687
4688         action = gtk_action_group_get_action (ev_window->priv->action_group, PAGE_SELECTOR_ACTION);
4689         ev_page_action_set_model (EV_PAGE_ACTION (action), model);
4690         g_object_unref (model);
4691 }
4692
4693 static gboolean
4694 view_actions_focus_in_cb (GtkWidget *widget, GdkEventFocus *event, EvWindow *window)
4695 {
4696         update_chrome_flag (window, EV_CHROME_RAISE_TOOLBAR, FALSE);
4697         ev_window_set_action_sensitive (window, "ViewToolbar", TRUE);
4698
4699         ev_window_set_view_accels_sensitivity (window, TRUE);
4700
4701         update_chrome_visibility (window);
4702
4703         return FALSE;
4704 }
4705
4706 static gboolean
4707 view_actions_focus_out_cb (GtkWidget *widget, GdkEventFocus *event, EvWindow *window)
4708 {
4709         ev_window_set_view_accels_sensitivity (window, FALSE);
4710
4711         return FALSE;
4712 }
4713
4714 static void
4715 sidebar_page_main_widget_update_cb (GObject *ev_sidebar_page,
4716                                     GParamSpec         *pspec,
4717                                     EvWindow           *ev_window)
4718 {
4719         GtkWidget *widget;
4720
4721         g_object_get (ev_sidebar_page, "main_widget", &widget, NULL);
4722
4723         if (widget != NULL) {
4724                 g_signal_connect_object (widget, "focus_in_event",
4725                                          G_CALLBACK (view_actions_focus_in_cb),
4726                                          ev_window, 0);
4727                 g_signal_connect_object (widget, "focus_out_event",
4728                                          G_CALLBACK (view_actions_focus_out_cb),
4729                                          ev_window, 0);
4730                 g_object_unref (widget);
4731         }
4732 }
4733
4734 static gboolean
4735 window_state_event_cb (EvWindow *window, GdkEventWindowState *event, gpointer dummy)
4736 {
4737         if (!(event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN)) {
4738                 gboolean maximized;
4739
4740                 maximized = event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED;
4741                 if (!ev_window_is_empty (window))
4742                         ev_metadata_manager_set_boolean (window->priv->uri, "window_maximized", maximized);
4743         }
4744
4745         return FALSE;
4746 }
4747
4748 static gboolean
4749 window_configure_event_cb (EvWindow *window, GdkEventConfigure *event, gpointer dummy)
4750 {
4751         char *uri = window->priv->uri;
4752         GdkWindowState state;
4753         int x, y, width, height, document_width, document_height;
4754
4755         state = gdk_window_get_state (GTK_WIDGET (window)->window);
4756
4757         if (!(state & GDK_WINDOW_STATE_FULLSCREEN)) {
4758                 gtk_window_get_position (GTK_WINDOW (window), &x, &y);
4759                 gtk_window_get_size (GTK_WINDOW (window), &width, &height);
4760
4761                 if (!ev_window_is_empty (window) && window->priv->page_cache) {
4762                         ev_page_cache_get_max_width (window->priv->page_cache,
4763                                                      0, 1.0,
4764                                                      &document_width);
4765                         ev_page_cache_get_max_height (window->priv->page_cache,
4766                                                       0, 1.0,
4767                                                       &document_height);
4768                         ev_metadata_manager_set_double (uri, "window_width_ratio",
4769                                                         (double)width / document_width);
4770                         ev_metadata_manager_set_double (uri, "window_height_ratio",
4771                                                         (double)height / document_height);
4772
4773                         ev_metadata_manager_set_int (uri, "window_x", x);
4774                         ev_metadata_manager_set_int (uri, "window_y", y);
4775                         ev_metadata_manager_set_int (uri, "window_width", width);
4776                         ev_metadata_manager_set_int (uri, "window_height", height);
4777                 }
4778         }
4779
4780         return FALSE;
4781 }
4782
4783 static void
4784 launch_action (EvWindow *window, EvLinkAction *action)
4785 {
4786         const char *filename = ev_link_action_get_filename (action);
4787         char *uri = NULL;
4788
4789         if (filename  && g_path_is_absolute (filename)) {
4790                 uri = gnome_vfs_get_uri_from_local_path (filename);
4791         } else {
4792                 GnomeVFSURI *base_uri, *resolved_uri;
4793
4794                 base_uri = gnome_vfs_uri_new (window->priv->uri);
4795                 if (base_uri && filename) {
4796                         resolved_uri = gnome_vfs_uri_resolve_relative (base_uri, filename);
4797                         if (resolved_uri) {
4798                                 uri = gnome_vfs_uri_to_string (resolved_uri, GNOME_VFS_URI_HIDE_NONE);
4799                                 gnome_vfs_uri_unref (resolved_uri);
4800                         }
4801                         gnome_vfs_uri_unref (base_uri);
4802                 }
4803         }
4804
4805         if (uri) {
4806                 gnome_vfs_url_show (uri);
4807         } else {
4808                 gnome_vfs_url_show (filename);
4809         }
4810
4811         g_free (uri);
4812
4813         /* According to the PDF spec filename can be an executable. I'm not sure
4814            allowing to launch executables is a good idea though. -- marco */
4815 }
4816
4817 static void
4818 launch_external_uri (EvWindow *window, EvLinkAction *action)
4819 {
4820         const gchar *uri = ev_link_action_get_uri (action);
4821         GnomeVFSResult result = gnome_vfs_url_show (uri);
4822         GtkWidget *dialog;
4823         gchar* message = NULL;
4824
4825         switch(result) {
4826                 case GNOME_VFS_OK:
4827                         break;
4828                 case GNOME_VFS_ERROR_BAD_PARAMETERS:
4829                         message = _("Invalid URI: “%s”");
4830                         break;
4831                 case GNOME_VFS_ERROR_NOT_SUPPORTED:
4832                         message = _("Unsupported URI: “%s”");
4833                         break;
4834                 default:
4835                         message = _("Unknown error");
4836         }
4837         if(message) {
4838                 dialog = gtk_message_dialog_new (GTK_WINDOW (window),
4839                                                  GTK_DIALOG_DESTROY_WITH_PARENT,
4840                                                  GTK_MESSAGE_ERROR,
4841                                                  GTK_BUTTONS_CLOSE,
4842                                                  _("Unable to open external link"));
4843                 gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
4844                                                           message, uri);
4845                 g_signal_connect (dialog, "response",
4846                                   G_CALLBACK (gtk_widget_destroy),
4847                                   NULL);
4848                 gtk_widget_show (dialog);
4849
4850         }
4851         return;
4852 }
4853
4854 static void
4855 open_remote_link (EvWindow *window, EvLinkAction *action)
4856 {
4857         gchar *uri;
4858         gchar *dir;
4859
4860         dir = g_path_get_dirname (window->priv->uri);
4861
4862         uri = g_build_filename (dir, ev_link_action_get_filename (action),
4863                                 NULL);
4864         g_free (dir);
4865
4866         ev_application_open_uri_at_dest (EV_APP, uri,
4867                                          gtk_window_get_screen (GTK_WINDOW (window)),
4868                                          ev_link_action_get_dest (action),
4869                                          0,
4870                                          NULL,
4871                                          FALSE,
4872                                          NULL,
4873                                          GDK_CURRENT_TIME);
4874
4875         g_free (uri);
4876 }
4877
4878 static void
4879 do_action_named (EvWindow *window, EvLinkAction *action)
4880 {
4881         const gchar *name = ev_link_action_get_name (action);
4882
4883         if (g_ascii_strcasecmp (name, "FirstPage") == 0) {
4884                 ev_window_cmd_go_first_page (NULL, window);
4885         } else if (g_ascii_strcasecmp (name, "PrevPage") == 0) {
4886                 ev_window_cmd_go_previous_page (NULL, window);
4887         } else if (g_ascii_strcasecmp (name, "NextPage") == 0) {
4888                 ev_window_cmd_go_next_page (NULL, window);
4889         } else if (g_ascii_strcasecmp (name, "LastPage") == 0) {
4890                 ev_window_cmd_go_last_page (NULL, window);
4891         } else if (g_ascii_strcasecmp (name, "GoToPage") == 0) {
4892                 ev_window_cmd_focus_page_selector (NULL, window);
4893         } else if (g_ascii_strcasecmp (name, "Find") == 0) {
4894                 ev_window_cmd_edit_find (NULL, window);
4895         } else if (g_ascii_strcasecmp (name, "Close") == 0) {
4896                 ev_window_cmd_file_close_window (NULL, window);
4897         } else {
4898                 g_warning ("Unimplemented named action: %s, please post a "
4899                            "bug report in Evince bugzilla "
4900                            "(http://bugzilla.gnome.org) with a testcase.",
4901                            name);
4902         }
4903 }
4904
4905 static void
4906 view_external_link_cb (EvView *view, EvLinkAction *action, EvWindow *window)
4907 {
4908         switch (ev_link_action_get_action_type (action)) {
4909                 case EV_LINK_ACTION_TYPE_GOTO_DEST: {
4910                         EvLinkDest *dest;
4911
4912                         dest = ev_link_action_get_dest (action);
4913                         if (!dest)
4914                                 return;
4915
4916                         ev_window_cmd_file_open_copy_at_dest (window, dest);
4917                 }
4918                         break;
4919                 case EV_LINK_ACTION_TYPE_EXTERNAL_URI:
4920                         launch_external_uri (window, action);
4921                         break;
4922                 case EV_LINK_ACTION_TYPE_LAUNCH:
4923                         launch_action (window, action);
4924                         break;
4925                 case EV_LINK_ACTION_TYPE_GOTO_REMOTE:
4926                         open_remote_link (window, action);
4927                         break;
4928                 case EV_LINK_ACTION_TYPE_NAMED:
4929                         do_action_named (window, action);
4930                         break;
4931                 default:
4932                         g_assert_not_reached ();
4933         }
4934 }
4935
4936 static void
4937 ev_view_popup_cmd_open_link (GtkAction *action, EvWindow *window)
4938 {
4939         ev_view_handle_link (EV_VIEW (window->priv->view), window->priv->link);
4940 }
4941
4942 static void
4943 ev_view_popup_cmd_open_link_new_window (GtkAction *action, EvWindow *window)
4944 {
4945         EvLinkAction *ev_action = NULL;
4946         EvLinkDest   *dest;
4947
4948         ev_action = ev_link_get_action (window->priv->link);
4949         if (!ev_action)
4950                 return;
4951
4952         dest = ev_link_action_get_dest (ev_action);
4953         if (!dest)
4954                 return;
4955
4956         ev_window_cmd_file_open_copy_at_dest (window, dest);
4957 }
4958
4959 static void
4960 ev_view_popup_cmd_copy_link_address (GtkAction *action, EvWindow *window)
4961 {
4962         GtkClipboard *clipboard;
4963         EvLinkAction *ev_action;
4964         const gchar *uri;
4965
4966         ev_action = ev_link_get_action (window->priv->link);
4967         if (!ev_action)
4968                 return;
4969
4970         uri = ev_link_action_get_uri (ev_action);
4971
4972         clipboard = gtk_widget_get_clipboard (GTK_WIDGET (window),
4973                                               GDK_SELECTION_CLIPBOARD);
4974         gtk_clipboard_set_text (clipboard, uri, -1);
4975 }
4976
4977
4978 static void
4979 image_save_dialog_response_cb (GtkWidget *fc,
4980                                gint       response_id,
4981                                EvWindow  *ev_window)
4982 {
4983         GnomeVFSURI     *target_uri;
4984         gboolean         is_local;
4985         GError          *error = NULL;
4986         GdkPixbuf       *pixbuf;
4987         gchar           *uri;
4988         gchar           *uri_extension;
4989         gchar          **extensions;
4990         gchar           *filename;
4991         gchar           *file_format;
4992         GdkPixbufFormat *format;
4993         GtkFileFilter   *filter;
4994
4995         if (response_id != GTK_RESPONSE_OK) {
4996                 gtk_widget_destroy (fc);
4997                 return;
4998         }
4999
5000         uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (fc));
5001         filter = gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (fc));
5002         format = g_object_get_data (G_OBJECT (filter), "pixbuf-format");
5003
5004         if (format == NULL) {
5005                 format = get_gdk_pixbuf_format_by_extension (uri);
5006         }
5007
5008         if (format == NULL) {
5009                 ev_window_error_message (GTK_WINDOW (ev_window),
5010                                          _("Couldn't find appropriate format to save image"),
5011                                          NULL);
5012                 g_free (uri);
5013                 gtk_widget_destroy (fc);
5014
5015                 return;
5016         }
5017
5018         extensions = gdk_pixbuf_format_get_extensions (format);
5019         uri_extension = g_strconcat (uri, ".", extensions[0], NULL);
5020         g_strfreev(extensions);
5021         file_format = gdk_pixbuf_format_get_name (format);
5022
5023         target_uri = gnome_vfs_uri_new (uri_extension);
5024         is_local = gnome_vfs_uri_is_local (target_uri);
5025
5026         if (is_local) {
5027                 filename = g_filename_from_uri (uri_extension, NULL, NULL);
5028         } else {
5029                 filename = ev_tmp_filename ("saveimage");
5030         }
5031
5032         g_free (uri);
5033         g_free (uri_extension);
5034
5035         ev_document_doc_mutex_lock ();
5036         pixbuf = ev_document_images_get_image (EV_DOCUMENT_IMAGES (ev_window->priv->document),
5037                                                ev_window->priv->image);
5038         ev_document_doc_mutex_unlock ();
5039
5040         gdk_pixbuf_save (pixbuf, filename, file_format, &error, NULL);
5041         g_object_unref (pixbuf);
5042
5043         if (error) {
5044                 ev_window_error_message (GTK_WINDOW (ev_window),
5045                                          _("The image could not be saved."),
5046                                          error);
5047                 g_error_free (error);
5048                 g_free (filename);
5049                 gnome_vfs_uri_unref (target_uri);
5050                 gtk_widget_destroy (fc);
5051
5052                 return;
5053         }
5054
5055         if (!is_local) {
5056                 GnomeVFSURI *source_uri;
5057                 gchar       *local_uri;
5058
5059                 local_uri = g_filename_to_uri (filename, NULL, NULL);
5060                 source_uri = gnome_vfs_uri_new (local_uri);
5061                 g_free (local_uri);
5062                 ev_window_save_remote (ev_window, source_uri, target_uri);
5063                 gnome_vfs_uri_unref (source_uri);
5064         }
5065
5066         g_free (filename);
5067         gnome_vfs_uri_unref (target_uri);
5068         gtk_widget_destroy (fc);
5069 }
5070
5071 static void
5072 ev_view_popup_cmd_save_image_as (GtkAction *action, EvWindow *window)
5073 {
5074         GtkWidget *fc;
5075
5076         if (!window->priv->image)
5077                 return;
5078
5079         fc = gtk_file_chooser_dialog_new (_("Save Image"),
5080                                           GTK_WINDOW (window),
5081                                           GTK_FILE_CHOOSER_ACTION_SAVE,
5082                                           GTK_STOCK_CANCEL,
5083                                           GTK_RESPONSE_CANCEL,
5084                                           GTK_STOCK_SAVE, GTK_RESPONSE_OK,
5085                                           NULL);
5086
5087         gtk_dialog_set_default_response (GTK_DIALOG (fc), GTK_RESPONSE_OK);
5088         gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (fc), FALSE);
5089         gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (fc), TRUE);
5090
5091         file_chooser_dialog_add_writable_pixbuf_formats (GTK_FILE_CHOOSER (fc));
5092
5093         g_signal_connect (fc, "response",
5094                           G_CALLBACK (image_save_dialog_response_cb),
5095                           window);
5096
5097         gtk_widget_show (fc);
5098 }
5099
5100 static void
5101 ev_view_popup_cmd_copy_image (GtkAction *action, EvWindow *window)
5102 {
5103         GtkClipboard *clipboard;
5104         GdkPixbuf    *pixbuf;
5105
5106         if (!window->priv->image)
5107                 return;
5108
5109         clipboard = gtk_widget_get_clipboard (GTK_WIDGET (window),
5110                                               GDK_SELECTION_CLIPBOARD);
5111         ev_document_doc_mutex_lock ();
5112         pixbuf = ev_document_images_get_image (EV_DOCUMENT_IMAGES (window->priv->document),
5113                                                window->priv->image);
5114         ev_document_doc_mutex_unlock ();
5115
5116         gtk_clipboard_set_image (clipboard, pixbuf);
5117         g_object_unref (pixbuf);
5118 }
5119
5120 static void
5121 ev_attachment_popup_cmd_open_attachment (GtkAction *action, EvWindow *window)
5122 {
5123         GList *l;
5124
5125         if (!window->priv->attach_list)
5126                 return;
5127
5128         for (l = window->priv->attach_list; l && l->data; l = g_list_next (l)) {
5129                 EvAttachment *attachment;
5130                 GError       *error = NULL;
5131
5132                 attachment = (EvAttachment *) l->data;
5133
5134                 ev_attachment_open (attachment, &error);
5135
5136                 if (error) {
5137                         ev_window_error_message (GTK_WINDOW (window),
5138                                                  _("Unable to open attachment"),
5139                                                  error);
5140                         g_error_free (error);
5141                 }
5142         }
5143 }
5144
5145 static void
5146 attachment_save_dialog_response_cb (GtkWidget *fc,
5147                                     gint       response_id,
5148                                     EvWindow  *ev_window)
5149 {
5150         GnomeVFSURI          *target_uri;
5151         gchar                *uri;
5152         GList                *l;
5153         GtkFileChooserAction  fc_action;
5154         gboolean              is_dir;
5155         gboolean              is_local;
5156
5157         if (response_id != GTK_RESPONSE_OK) {
5158                 gtk_widget_destroy (fc);
5159                 return;
5160         }
5161
5162         uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (fc));
5163         target_uri = gnome_vfs_uri_new (uri);
5164         g_object_get (G_OBJECT (fc), "action", &fc_action, NULL);
5165         is_dir = (fc_action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
5166         is_local = gnome_vfs_uri_is_local (target_uri);
5167
5168         for (l = ev_window->priv->attach_list; l && l->data; l = g_list_next (l)) {
5169                 EvAttachment *attachment;
5170                 gchar        *filename;
5171                 GError       *error = NULL;
5172
5173                 attachment = (EvAttachment *) l->data;
5174
5175                 if (is_local) {
5176                         if (is_dir) {
5177                                 filename = g_strjoin ("/", uri,
5178                                                       ev_attachment_get_name (attachment),
5179                                                       NULL);
5180                         } else {
5181                                 filename = g_strdup (uri);
5182                         }
5183                 } else {
5184                         filename = ev_tmp_filename ("saveattachment");
5185                 }
5186
5187                 ev_attachment_save (attachment, filename, &error);
5188
5189                 if (error) {
5190                         ev_window_error_message (GTK_WINDOW (ev_window),
5191                                                  _("The attachment could not be saved."),
5192                                                  error);
5193                         g_error_free (error);
5194                         g_free (filename);
5195
5196                         continue;
5197                 }
5198
5199                 if (!is_local) {
5200                         GnomeVFSURI *src_uri;
5201                         GnomeVFSURI *dest_uri;
5202                         gchar       *local_uri;
5203
5204                         if (is_dir) {
5205                                 const gchar *name = ev_attachment_get_name (attachment);
5206
5207                                 dest_uri = gnome_vfs_uri_append_file_name (target_uri,
5208                                                                            name);
5209                         } else {
5210                                 dest_uri = gnome_vfs_uri_ref (target_uri);
5211                         }
5212
5213                         local_uri = g_filename_to_uri (filename, NULL, NULL);
5214                         src_uri = gnome_vfs_uri_new (local_uri);
5215                         g_free (local_uri);
5216                         ev_window_save_remote (ev_window, src_uri, dest_uri);
5217                         gnome_vfs_uri_unref (src_uri);
5218                         gnome_vfs_uri_unref (dest_uri);
5219                 }
5220
5221                 g_free (filename);
5222         }
5223
5224         g_free (uri);
5225         gnome_vfs_uri_unref (target_uri);
5226
5227         gtk_widget_destroy (fc);
5228 }
5229
5230 static void
5231 ev_attachment_popup_cmd_save_attachment_as (GtkAction *action, EvWindow *window)
5232 {
5233         GtkWidget    *fc;
5234         EvAttachment *attachment = NULL;
5235
5236         if (!window->priv->attach_list)
5237                 return;
5238
5239         if (g_list_length (window->priv->attach_list) == 1)
5240                 attachment = (EvAttachment *) window->priv->attach_list->data;
5241
5242         fc = gtk_file_chooser_dialog_new (
5243                 _("Save Attachment"),
5244                 GTK_WINDOW (window),
5245                 attachment ? GTK_FILE_CHOOSER_ACTION_SAVE : GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
5246                 GTK_STOCK_CANCEL,
5247                 GTK_RESPONSE_CANCEL,
5248                 GTK_STOCK_SAVE, GTK_RESPONSE_OK,
5249                 NULL);
5250
5251         gtk_dialog_set_default_response (GTK_DIALOG (fc), GTK_RESPONSE_OK);
5252         gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (fc), TRUE);
5253         gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (fc), FALSE);
5254
5255         if (attachment)
5256                 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (fc),
5257                                                    ev_attachment_get_name (attachment));
5258
5259         g_signal_connect (fc, "response",
5260                           G_CALLBACK (attachment_save_dialog_response_cb),
5261                           window);
5262
5263         gtk_widget_show (fc);
5264 }
5265
5266 static void
5267 ev_window_init (EvWindow *ev_window)
5268 {
5269         GtkActionGroup *action_group;
5270         GtkAccelGroup *accel_group;
5271         GError *error = NULL;
5272         GtkWidget *sidebar_widget;
5273
5274         g_signal_connect (ev_window, "configure_event",
5275                           G_CALLBACK (window_configure_event_cb), NULL);
5276         g_signal_connect (ev_window, "window_state_event",
5277                           G_CALLBACK (window_state_event_cb), NULL);
5278
5279         ev_window->priv = EV_WINDOW_GET_PRIVATE (ev_window);
5280
5281         ev_window->priv->page_mode = PAGE_MODE_DOCUMENT;
5282         ev_window->priv->title = ev_window_title_new (ev_window);
5283
5284         ev_window->priv->main_box = gtk_vbox_new (FALSE, 0);
5285         gtk_container_add (GTK_CONTAINER (ev_window), ev_window->priv->main_box);
5286         gtk_widget_show (ev_window->priv->main_box);
5287
5288         action_group = gtk_action_group_new ("MenuActions");
5289         ev_window->priv->action_group = action_group;
5290         gtk_action_group_set_translation_domain (action_group, NULL);
5291         gtk_action_group_add_actions (action_group, entries,
5292                                       G_N_ELEMENTS (entries), ev_window);
5293         gtk_action_group_add_toggle_actions (action_group, toggle_entries,
5294                                              G_N_ELEMENTS (toggle_entries),
5295                                              ev_window);
5296         set_action_properties (action_group);
5297         register_custom_actions (ev_window, action_group);
5298
5299         ev_window->priv->ui_manager = gtk_ui_manager_new ();
5300         gtk_ui_manager_insert_action_group (ev_window->priv->ui_manager,
5301                                             action_group, 0);
5302
5303         accel_group =
5304                 gtk_ui_manager_get_accel_group (ev_window->priv->ui_manager);
5305         gtk_window_add_accel_group (GTK_WINDOW (ev_window), accel_group);
5306
5307         ev_window_set_view_accels_sensitivity (ev_window, FALSE);
5308
5309         action_group = gtk_action_group_new ("ViewPopupActions");
5310         ev_window->priv->view_popup_action_group = action_group;
5311         gtk_action_group_set_translation_domain (action_group, NULL);
5312         gtk_action_group_add_actions (action_group, view_popup_entries,
5313                                       G_N_ELEMENTS (view_popup_entries),
5314                                       ev_window);
5315         gtk_ui_manager_insert_action_group (ev_window->priv->ui_manager,
5316                                             action_group, 0);
5317
5318         action_group = gtk_action_group_new ("AttachmentPopupActions");
5319         ev_window->priv->attachment_popup_action_group = action_group;
5320         gtk_action_group_set_translation_domain (action_group, NULL);
5321         gtk_action_group_add_actions (action_group, attachment_popup_entries,
5322                                       G_N_ELEMENTS (attachment_popup_entries),
5323                                       ev_window);
5324         gtk_ui_manager_insert_action_group (ev_window->priv->ui_manager,
5325                                             action_group, 0);
5326
5327         if (!gtk_ui_manager_add_ui_from_file (ev_window->priv->ui_manager,
5328                                               DATADIR"/evince-ui.xml",
5329                                               &error)) {
5330                 g_warning ("building menus failed: %s", error->message);
5331                 g_error_free (error);
5332         }
5333
5334 #if GTK_CHECK_VERSION(2,11,4)
5335         ev_window->priv->recent_manager = gtk_recent_manager_get_default ();
5336 #else
5337         /* It's fine to just use the one of the default screen here */
5338         ev_window->priv->recent_manager = gtk_recent_manager_get_for_screen (
5339                 gdk_screen_get_default ());
5340 #endif
5341         ev_window->priv->recent_action_group = NULL;
5342         ev_window->priv->recent_ui_id = 0;
5343         g_signal_connect_swapped (ev_window->priv->recent_manager,
5344                                   "changed",
5345                                   G_CALLBACK (ev_window_setup_recent),
5346                                   ev_window);
5347
5348         ev_window->priv->menubar =
5349                  gtk_ui_manager_get_widget (ev_window->priv->ui_manager,
5350                                             "/MainMenu");
5351         gtk_box_pack_start (GTK_BOX (ev_window->priv->main_box),
5352                             ev_window->priv->menubar,
5353                             FALSE, FALSE, 0);
5354
5355         ev_window->priv->toolbar = GTK_WIDGET
5356           (g_object_new (EGG_TYPE_EDITABLE_TOOLBAR,
5357                          "ui-manager", ev_window->priv->ui_manager,
5358                          "popup-path", "/ToolbarPopup",
5359                          "model", ev_application_get_toolbars_model (EV_APP),
5360                          NULL));
5361
5362         egg_editable_toolbar_show (EGG_EDITABLE_TOOLBAR (ev_window->priv->toolbar),
5363                                    "DefaultToolBar");
5364         gtk_box_pack_start (GTK_BOX (ev_window->priv->main_box),
5365                             ev_window->priv->toolbar,
5366                             FALSE, FALSE, 0);
5367         gtk_widget_show (ev_window->priv->toolbar);
5368
5369         /* Add the main area */
5370         ev_window->priv->hpaned = gtk_hpaned_new ();
5371         g_signal_connect (ev_window->priv->hpaned,
5372                           "notify::position",
5373                           G_CALLBACK (ev_window_sidebar_position_change_cb),
5374                           ev_window);
5375
5376         gtk_paned_set_position (GTK_PANED (ev_window->priv->hpaned), SIDEBAR_DEFAULT_SIZE);
5377         gtk_box_pack_start (GTK_BOX (ev_window->priv->main_box), ev_window->priv->hpaned,
5378                             TRUE, TRUE, 0);
5379         gtk_widget_show (ev_window->priv->hpaned);
5380
5381         ev_window->priv->sidebar = ev_sidebar_new ();
5382         gtk_paned_pack1 (GTK_PANED (ev_window->priv->hpaned),
5383                          ev_window->priv->sidebar, FALSE, FALSE);
5384         gtk_widget_show (ev_window->priv->sidebar);
5385
5386         /* Stub sidebar, for now */
5387
5388         sidebar_widget = ev_sidebar_thumbnails_new ();
5389         ev_window->priv->sidebar_thumbs = sidebar_widget;
5390         g_signal_connect (sidebar_widget,
5391                           "notify::main-widget",
5392                           G_CALLBACK (sidebar_page_main_widget_update_cb),
5393                           ev_window);
5394         sidebar_page_main_widget_update_cb (G_OBJECT (sidebar_widget), NULL, ev_window);
5395         gtk_widget_show (sidebar_widget);
5396         ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar),
5397                              sidebar_widget);
5398
5399         sidebar_widget = ev_sidebar_links_new ();
5400         ev_window->priv->sidebar_links = sidebar_widget;
5401         g_signal_connect (sidebar_widget,
5402                           "notify::model",
5403                           G_CALLBACK (sidebar_widget_model_set),
5404                           ev_window);
5405         g_signal_connect (sidebar_widget,
5406                           "link_activated",
5407                           G_CALLBACK (sidebar_links_link_activated_cb),
5408                           ev_window);
5409         sidebar_page_main_widget_update_cb (G_OBJECT (sidebar_widget), NULL, ev_window);
5410         gtk_widget_show (sidebar_widget);
5411         ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar),
5412                              sidebar_widget);
5413
5414         sidebar_widget = ev_sidebar_attachments_new ();
5415         ev_window->priv->sidebar_attachments = sidebar_widget;
5416         g_signal_connect_object (sidebar_widget,
5417                                  "popup",
5418                                  G_CALLBACK (attachment_bar_menu_popup_cb),
5419                                  ev_window, 0);
5420         gtk_widget_show (sidebar_widget);
5421         ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar),
5422                              sidebar_widget);
5423
5424         ev_window->priv->view_box = gtk_vbox_new (FALSE, 0);
5425         ev_window->priv->scrolled_window =
5426                 GTK_WIDGET (g_object_new (GTK_TYPE_SCROLLED_WINDOW,
5427                                           "shadow-type", GTK_SHADOW_IN,
5428                                           NULL));
5429         gtk_box_pack_start (GTK_BOX (ev_window->priv->view_box),
5430                             ev_window->priv->scrolled_window,
5431                             TRUE, TRUE, 0);
5432         gtk_widget_show (ev_window->priv->scrolled_window);
5433
5434         gtk_paned_add2 (GTK_PANED (ev_window->priv->hpaned),
5435                         ev_window->priv->view_box);
5436         gtk_widget_show (ev_window->priv->view_box);
5437
5438         ev_window->priv->view = ev_view_new ();
5439         ev_view_set_screen_dpi (EV_VIEW (ev_window->priv->view),
5440                                 get_screen_dpi (GTK_WINDOW (ev_window)));
5441         ev_window->priv->password_view = ev_password_view_new ();
5442         g_signal_connect_swapped (ev_window->priv->password_view,
5443                                   "unlock",
5444                                   G_CALLBACK (ev_window_popup_password_dialog),
5445                                   ev_window);
5446         g_signal_connect_object (ev_window->priv->view, "focus_in_event",
5447                                  G_CALLBACK (view_actions_focus_in_cb),
5448                                  ev_window, 0);
5449         g_signal_connect_object (ev_window->priv->view, "focus_out_event",
5450                                  G_CALLBACK (view_actions_focus_out_cb),
5451                                  ev_window, 0);
5452         g_signal_connect_object (ev_window->priv->view, "external-link",
5453                                  G_CALLBACK (view_external_link_cb),
5454                                  ev_window, 0);
5455         g_signal_connect_object (ev_window->priv->view, "handle-link",
5456                                  G_CALLBACK (view_handle_link_cb),
5457                                  ev_window, 0);
5458
5459         g_signal_connect_object (ev_window->priv->view,
5460                                  "popup",
5461                                  G_CALLBACK (view_menu_popup_cb),
5462                                  ev_window, 0);
5463         gtk_widget_show (ev_window->priv->view);
5464         gtk_widget_show (ev_window->priv->password_view);
5465
5466         /* Find Bar */
5467         ev_window->priv->find_bar = egg_find_bar_new ();
5468         gtk_box_pack_end (GTK_BOX (ev_window->priv->main_box),
5469                           ev_window->priv->find_bar,
5470                           FALSE, TRUE, 0);
5471
5472         /* We own a ref on these widgets, as we can swap them in and out */
5473         g_object_ref (ev_window->priv->view);
5474         g_object_ref (ev_window->priv->password_view);
5475
5476         gtk_container_add (GTK_CONTAINER (ev_window->priv->scrolled_window),
5477                            ev_window->priv->view);
5478
5479         g_signal_connect (ev_window->priv->view,
5480                           "notify::find-status",
5481                           G_CALLBACK (view_find_status_changed_cb),
5482                           ev_window);
5483         g_signal_connect (ev_window->priv->view,
5484                           "notify::sizing-mode",
5485                           G_CALLBACK (ev_window_sizing_mode_changed_cb),
5486                           ev_window);
5487         g_signal_connect (ev_window->priv->view,
5488                           "notify::zoom",
5489                           G_CALLBACK (ev_window_zoom_changed_cb),
5490                           ev_window);
5491         g_signal_connect (ev_window->priv->view,
5492                           "notify::dual-page",
5493                           G_CALLBACK (ev_window_dual_mode_changed_cb),
5494                           ev_window);
5495         g_signal_connect (ev_window->priv->view,
5496                           "notify::continuous",
5497                           G_CALLBACK (ev_window_continuous_changed_cb),
5498                           ev_window);
5499         g_signal_connect (ev_window->priv->view,
5500                           "notify::rotation",
5501                           G_CALLBACK (ev_window_rotation_changed_cb),
5502                           ev_window);
5503         g_signal_connect (ev_window->priv->view,
5504                           "notify::has-selection",
5505                           G_CALLBACK (ev_window_has_selection_changed_cb),
5506                           ev_window);
5507
5508         /* Connect sidebar signals */
5509         g_signal_connect (ev_window->priv->sidebar,
5510                           "notify::visible",
5511                           G_CALLBACK (ev_window_sidebar_visibility_changed_cb),
5512                           ev_window);
5513         g_signal_connect (ev_window->priv->sidebar,
5514                           "notify::current-page",
5515                           G_CALLBACK (ev_window_sidebar_current_page_changed_cb),
5516                           ev_window);
5517
5518         /* Connect to find bar signals */
5519         g_signal_connect (ev_window->priv->find_bar,
5520                           "previous",
5521                           G_CALLBACK (find_bar_previous_cb),
5522                           ev_window);
5523         g_signal_connect (ev_window->priv->find_bar,
5524                           "next",
5525                           G_CALLBACK (find_bar_next_cb),
5526                           ev_window);
5527         g_signal_connect (ev_window->priv->find_bar,
5528                           "close",
5529                           G_CALLBACK (find_bar_close_cb),
5530                           ev_window);
5531         g_signal_connect (ev_window->priv->find_bar,
5532                           "notify::search-string",
5533                           G_CALLBACK (find_bar_search_changed_cb),
5534                           ev_window);
5535         g_signal_connect (ev_window->priv->find_bar,
5536                           "notify::case-sensitive",
5537                           G_CALLBACK (find_bar_search_changed_cb),
5538                           ev_window);
5539         g_signal_connect (ev_window->priv->find_bar,
5540                           "notify::visible",
5541                           G_CALLBACK (find_bar_visibility_changed_cb),
5542                           ev_window);
5543         g_signal_connect (ev_window->priv->find_bar,
5544                           "scroll",
5545                           G_CALLBACK (find_bar_scroll),
5546                           ev_window);
5547
5548         /* Popups */
5549         ev_window->priv->view_popup = gtk_ui_manager_get_widget (ev_window->priv->ui_manager,
5550                                                                  "/DocumentPopup");
5551         ev_window->priv->link = NULL;
5552
5553         ev_window->priv->attachment_popup = gtk_ui_manager_get_widget (ev_window->priv->ui_manager,
5554                                                                        "/AttachmentPopup");
5555         ev_window->priv->attach_list = NULL;
5556
5557         /* Give focus to the document view */
5558         gtk_widget_grab_focus (ev_window->priv->view);
5559
5560         /* Set it user interface params */
5561         ev_window_setup_recent (ev_window);
5562
5563         setup_chrome_from_metadata (ev_window);
5564         set_chrome_actions (ev_window);
5565         update_chrome_visibility (ev_window);
5566
5567         gtk_window_set_default_size (GTK_WINDOW (ev_window), 600, 600);
5568
5569         setup_view_from_metadata (ev_window);
5570         setup_sidebar_from_metadata (ev_window, NULL);
5571
5572         ev_window_sizing_mode_changed_cb (EV_VIEW (ev_window->priv->view), NULL, ev_window);
5573         ev_window_setup_action_sensitivity (ev_window);
5574 }
5575
5576 /**
5577  * ev_window_new:
5578  *
5579  * Creates a #GtkWidget that represents the window.
5580  *
5581  * Returns: the #GtkWidget that represents the window.
5582  */
5583 GtkWidget *
5584 ev_window_new (void)
5585 {
5586         GtkWidget *ev_window;
5587
5588         ev_window = GTK_WIDGET (g_object_new (EV_TYPE_WINDOW,
5589                                               "type", GTK_WINDOW_TOPLEVEL,
5590                                               NULL));
5591
5592         return ev_window;
5593 }