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) 2009 Juanjo Marín <juanj.marin@juntadeandalucia.es>
   5  *  Copyright (C) 2008 Carlos Garcia Campos
   6  *  Copyright (C) 2004 Martin Kretzschmar
   7  *  Copyright (C) 2004 Red Hat, Inc.
   8  *  Copyright (C) 2000, 2001, 2002, 2003, 2004 Marco Pesenti Gritti
   9  *  Copyright © 2003, 2004, 2005, 2009 Christian Persch
  10  *
  11  *  Author:
  12  *    Martin Kretzschmar <martink@gnome.org>
  13  *
  14  * Evince is free software; you can redistribute it and/or modify it
  15  * under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * Evince is distributed in the hope that it will be useful, but
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22  * General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with this program; if not, write to the Free Software
  26  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  27  */
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include "config.h"
  31 #endif
  32
  33 #include <errno.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <unistd.h>
  37
  38 #include <glib/gstdio.h>
  39 #include <glib/gi18n.h>
  40 #include <gio/gio.h>
  41 #include <gtk/gtk.h>
  42
  43 #ifdef WITH_GCONF
  44 #include <gconf/gconf-client.h>
  45 #endif
  46
  47 #include "egg-editable-toolbar.h"
  48 #include "egg-toolbar-editor.h"
  49 #include "egg-toolbars-model.h"
  50
  51 #include "eggfindbar.h"
  52
  53 #include "ephy-zoom-action.h"
  54 #include "ephy-zoom.h"
  55
  56 #include "ev-application.h"
  57 #include "ev-document-factory.h"
  58 #include "ev-document-find.h"
  59 #include "ev-document-fonts.h"
  60 #include "ev-document-images.h"
  61 #include "ev-document-links.h"
  62 #include "ev-document-thumbnails.h"
  63 #include "ev-document-annotations.h"
  64 #include "ev-document-type-builtins.h"
  65 #include "ev-file-exporter.h"
  66 #include "ev-file-helpers.h"
  67 #include "ev-file-monitor.h"
  68 #include "ev-history.h"
  69 #include "ev-image.h"
  70 #include "ev-job-scheduler.h"
  71 #include "ev-jobs.h"
  72 #include "ev-message-area.h"
  73 #include "ev-metadata.h"
  74 #include "ev-navigation-action.h"
  75 #include "ev-open-recent-action.h"
  76 #include "ev-page-action.h"
  77 #include "ev-password-view.h"
  78 #include "ev-properties-dialog.h"
  79 #include "ev-sidebar-attachments.h"
  80 #include "ev-sidebar.h"
  81 #include "ev-sidebar-links.h"
  82 #include "ev-sidebar-page.h"
  83 #include "ev-sidebar-thumbnails.h"
  84 #include "ev-sidebar-layers.h"
  85 #include "ev-stock-icons.h"
  86 #include "ev-utils.h"
  87 #include "ev-keyring.h"
  88 #include "ev-view.h"
  89 #include "ev-view-presentation.h"
  90 #include "ev-view-type-builtins.h"
  91 #include "ev-window.h"
  92 #include "ev-window-title.h"
  93 #include "ev-print-operation.h"
  94 #include "ev-progress-message-area.h"
  95
  96 #ifdef ENABLE_DBUS
  97 #include "ev-media-player-keys.h"
  98 #endif /* ENABLE_DBUS */
  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_NORMAL        = EV_CHROME_MENUBAR | EV_CHROME_TOOLBAR | EV_CHROME_SIDEBAR
 113 } EvChrome;
 114
 115 typedef enum {
 116         EV_SAVE_DOCUMENT,
 117         EV_SAVE_ATTACHMENT,
 118         EV_SAVE_IMAGE
 119 } EvSaveType;
 120
 121 struct _EvWindowPrivate {
 122         /* UI */
 123         EvChrome chrome;
 124
 125         GtkWidget *main_box;
 126         GtkWidget *menubar;
 127         GtkWidget *toolbar;
 128         GtkWidget *hpaned;
 129         GtkWidget *view_box;
 130         GtkWidget *sidebar;
 131         GtkWidget *find_bar;
 132         GtkWidget *scrolled_window;
 133         GtkWidget *view;
 134         GtkWidget *presentation_view;
 135         GtkWidget *message_area;
 136         GtkWidget *password_view;
 137         GtkWidget *sidebar_thumbs;
 138         GtkWidget *sidebar_links;
 139         GtkWidget *sidebar_attachments;
 140         GtkWidget *sidebar_layers;
 141
 142         /* Menubar accels */
 143         guint           menubar_accel_keyval;
 144         GdkModifierType menubar_accel_modifier;
 145
 146         /* Progress Messages */
 147         guint progress_idle;
 148         GCancellable *progress_cancellable;
 149
 150         /* Dialogs */
 151         GtkWidget *properties;
 152         GtkWidget *print_dialog;
 153
 154         /* UI Builders */
 155         GtkActionGroup   *action_group;
 156         GtkActionGroup   *view_popup_action_group;
 157         GtkActionGroup   *attachment_popup_action_group;
 158         GtkRecentManager *recent_manager;
 159         GtkActionGroup   *recent_action_group;
 160         guint             recent_ui_id;
 161         GtkUIManager     *ui_manager;
 162
 163         /* Fullscreen mode */
 164         GtkWidget *fullscreen_toolbar;
 165
 166         /* Popup view */
 167         GtkWidget *view_popup;
 168         EvLink    *link;
 169         EvImage   *image;
 170
 171         /* Popup attachment */
 172         GtkWidget    *attachment_popup;
 173         GList        *attach_list;
 174
 175         /* Document */
 176         EvDocumentModel *model;
 177         char *uri;
 178         glong uri_mtime;
 179         char *local_uri;
 180         gboolean in_reload;
 181         EvFileMonitor *monitor;
 182         guint setup_document_idle;
 183
 184         EvDocument *document;
 185         EvHistory *history;
 186         EvWindowPageMode page_mode;
 187         EvWindowTitle *title;
 188         EvMetadata *metadata;
 189
 190         /* Load params */
 191         EvLinkDest       *dest;
 192         gchar            *search_string;
 193         EvWindowRunMode   window_mode;
 194
 195         EvJob            *load_job;
 196         EvJob            *reload_job;
 197         EvJob            *thumbnail_job;
 198         EvJob            *save_job;
 199         EvJob            *find_job;
 200
 201         /* Printing */
 202         GQueue           *print_queue;
 203         GtkPrintSettings *print_settings;
 204         GtkPageSetup     *print_page_setup;
 205         gboolean          close_after_print;
 206 #ifdef WITH_GCONF
 207         GConfClient *gconf_client;
 208 #endif
 209 };
 210
 211 #define EV_WINDOW_GET_PRIVATE(object) \
 212         (G_TYPE_INSTANCE_GET_PRIVATE ((object), EV_TYPE_WINDOW, EvWindowPrivate))
 213
 214 #define EV_WINDOW_IS_PRESENTATION(w) (w->priv->presentation_view != NULL)
 215
 216 #define PAGE_SELECTOR_ACTION    "PageSelector"
 217 #define ZOOM_CONTROL_ACTION     "ViewZoom"
 218 #define NAVIGATION_ACTION       "Navigation"
 219
 220 #define GCONF_LOCKDOWN_DIR          "/desktop/gnome/lockdown"
 221 #define GCONF_OVERRIDE_RESTRICTIONS "/apps/evince/override_restrictions"
 222 #define GCONF_LOCKDOWN_SAVE         "/desktop/gnome/lockdown/disable_save_to_disk"
 223 #define GCONF_LOCKDOWN_PRINT        "/desktop/gnome/lockdown/disable_printing"
 224 #define GCONF_LOCKDOWN_PRINT_SETUP  "/desktop/gnome/lockdown/disable_print_setup"
 225
 226 #define SIDEBAR_DEFAULT_SIZE    132
 227 #define LINKS_SIDEBAR_ID "links"
 228 #define THUMBNAILS_SIDEBAR_ID "thumbnails"
 229 #define ATTACHMENTS_SIDEBAR_ID "attachments"
 230 #define LAYERS_SIDEBAR_ID "layers"
 231
 232 #define EV_PRINT_SETTINGS_FILE  "print-settings"
 233 #define EV_PRINT_SETTINGS_GROUP "Print Settings"
 234 #define EV_PAGE_SETUP_GROUP     "Page Setup"
 235
 236 #define EV_TOOLBARS_FILENAME "evince-toolbar.xml"
 237
 238 #define MIN_SCALE 0.05409
 239 #define MAX_SCALE 4.0
 240
 241 static const gchar *document_print_settings[] = {
 242         GTK_PRINT_SETTINGS_N_COPIES,
 243         GTK_PRINT_SETTINGS_COLLATE,
 244         GTK_PRINT_SETTINGS_REVERSE,
 245         GTK_PRINT_SETTINGS_NUMBER_UP,
 246         GTK_PRINT_SETTINGS_SCALE,
 247         GTK_PRINT_SETTINGS_PRINT_PAGES,
 248         GTK_PRINT_SETTINGS_PAGE_RANGES,
 249         GTK_PRINT_SETTINGS_PAGE_SET,
 250         GTK_PRINT_SETTINGS_OUTPUT_URI
 251 };
 252
 253 static void     ev_window_update_actions                (EvWindow         *ev_window);
 254 static void     ev_window_sidebar_visibility_changed_cb (EvSidebar        *ev_sidebar,
 255                                                          GParamSpec       *pspec,
 256                                                          EvWindow         *ev_window);
 257 static void     ev_window_set_page_mode                 (EvWindow         *window,
 258                                                          EvWindowPageMode  page_mode);
 259 static void     ev_window_load_job_cb                   (EvJob            *job,
 260                                                          gpointer          data);
 261 static void     ev_window_reload_document               (EvWindow         *window,
 262                                                          EvLinkDest *dest);
 263 static void     ev_window_reload_job_cb                 (EvJob            *job,
 264                                                          EvWindow         *window);
 265 static void     ev_window_set_icon_from_thumbnail       (EvJobThumbnail   *job,
 266                                                          EvWindow         *ev_window);
 267 static void     ev_window_save_job_cb                   (EvJob            *save,
 268                                                          EvWindow         *window);
 269 static void     ev_window_sizing_mode_changed_cb        (EvDocumentModel  *model,
 270                                                          GParamSpec       *pspec,
 271                                                          EvWindow         *ev_window);
 272 static void     ev_window_zoom_changed_cb               (EvDocumentModel  *model,
 273                                                          GParamSpec       *pspec,
 274                                                          EvWindow         *ev_window);
 275 static void     ev_window_add_recent                    (EvWindow         *window,
 276                                                          const char       *filename);
 277 static void     ev_window_run_fullscreen                (EvWindow         *window);
 278 static void     ev_window_stop_fullscreen               (EvWindow         *window,
 279                                                          gboolean          unfullscreen_window);
 280 static void     ev_window_cmd_view_fullscreen           (GtkAction        *action,
 281                                                          EvWindow         *window);
 282 static void     ev_window_run_presentation              (EvWindow         *window);
 283 static void     ev_window_stop_presentation             (EvWindow         *window,
 284                                                          gboolean          unfullscreen_window);
 285 static void     ev_window_cmd_view_presentation         (GtkAction        *action,
 286                                                          EvWindow         *window);
 287 static void     ev_view_popup_cmd_open_link             (GtkAction        *action,
 288                                                          EvWindow         *window);
 289 static void     ev_view_popup_cmd_open_link_new_window  (GtkAction        *action,
 290                                                          EvWindow         *window);
 291 static void     ev_view_popup_cmd_copy_link_address     (GtkAction        *action,
 292                                                          EvWindow         *window);
 293 static void     ev_view_popup_cmd_save_image_as         (GtkAction        *action,
 294                                                          EvWindow         *window);
 295 static void     ev_view_popup_cmd_copy_image            (GtkAction        *action,
 296                                                          EvWindow         *window);
 297 static void     ev_attachment_popup_cmd_open_attachment (GtkAction        *action,
 298                                                          EvWindow         *window);
 299 static void     ev_attachment_popup_cmd_save_attachment_as (GtkAction     *action,
 300                                                          EvWindow         *window);
 301 static void     ev_window_cmd_view_best_fit             (GtkAction        *action,
 302                                                          EvWindow         *ev_window);
 303 static void     ev_window_cmd_view_page_width           (GtkAction        *action,
 304                                                          EvWindow         *ev_window);
 305 static void     view_handle_link_cb                     (EvView           *view,
 306                                                          EvLink           *link,
 307                                                          EvWindow         *window);
 308 static void     ev_window_update_find_status_message    (EvWindow         *ev_window);
 309 static void     ev_window_cmd_edit_find                 (GtkAction        *action,
 310                                                          EvWindow         *ev_window);
 311 static void     find_bar_search_changed_cb              (EggFindBar       *find_bar,
 312                                                          GParamSpec       *param,
 313                                                          EvWindow         *ev_window);
 314 static void     ev_window_load_file_remote              (EvWindow         *ev_window,
 315                                                          GFile            *source_file);
 316 static void     ev_window_media_player_key_pressed      (EvWindow         *window,
 317                                                          const gchar      *key,
 318                                                          gpointer          user_data);
 319
 320 static guint ev_window_n_copies = 0;
 321
 322 G_DEFINE_TYPE (EvWindow, ev_window, GTK_TYPE_WINDOW)
 323
 324 static void
 325 ev_window_set_action_sensitive (EvWindow   *ev_window,
 326                                 const char *name,
 327                                 gboolean    sensitive)
 328 {
 329         GtkAction *action = gtk_action_group_get_action (ev_window->priv->action_group,
 330                                                          name);
 331         gtk_action_set_sensitive (action, sensitive);
 332 }
 333
 334
 335 static void
 336 ev_window_setup_action_sensitivity (EvWindow *ev_window)
 337 {
 338         EvDocument *document = ev_window->priv->document;
 339         const EvDocumentInfo *info = NULL;
 340         gboolean has_document = FALSE;
 341         gboolean ok_to_print = TRUE;
 342         gboolean ok_to_print_setup = TRUE;
 343         gboolean ok_to_copy = TRUE;
 344         gboolean has_properties = TRUE;
 345         gboolean override_restrictions = TRUE;
 346         gboolean can_get_text = FALSE;
 347         gboolean has_pages = FALSE;
 348         gboolean can_find = FALSE;
 349
 350         if (document) {
 351                 has_document = TRUE;
 352                 has_pages = ev_document_get_n_pages (document) > 0;
 353                 info = ev_document_get_info (document);
 354         }
 355
 356         if (!info || info->fields_mask == 0) {
 357                 has_properties = FALSE;
 358         }
 359
 360         if (has_document && EV_IS_SELECTION (document)) {
 361                 can_get_text = TRUE;
 362         }
 363
 364         if (has_pages && EV_IS_DOCUMENT_FIND (document)) {
 365                 can_find = TRUE;
 366         }
 367
 368 #ifdef WITH_GCONF
 369         if (has_document)
 370                 override_restrictions = gconf_client_get_bool (ev_window->priv->gconf_client,
 371                                                                GCONF_OVERRIDE_RESTRICTIONS,
 372                                                                NULL);
 373 #endif
 374         if (!override_restrictions && info && info->fields_mask & EV_DOCUMENT_INFO_PERMISSIONS) {
 375                 ok_to_print = (info->permissions & EV_DOCUMENT_PERMISSIONS_OK_TO_PRINT);
 376                 ok_to_copy = (info->permissions & EV_DOCUMENT_PERMISSIONS_OK_TO_COPY);
 377         }
 378
 379         if (has_document && !ev_print_operation_exists_for_document(document))
 380                 ok_to_print = FALSE;
 381
 382 #ifdef WITH_GCONF
 383         if (has_document &&
 384             gconf_client_get_bool (ev_window->priv->gconf_client, GCONF_LOCKDOWN_SAVE, NULL)) {
 385                 ok_to_copy = FALSE;
 386         }
 387
 388         if (has_document &&
 389             gconf_client_get_bool (ev_window->priv->gconf_client, GCONF_LOCKDOWN_PRINT, NULL)) {
 390                 ok_to_print = FALSE;
 391         }
 392
 393         if (has_document &&
 394             gconf_client_get_bool (ev_window->priv->gconf_client, GCONF_LOCKDOWN_PRINT_SETUP, NULL)) {
 395                 ok_to_print_setup = FALSE;
 396         }
 397 #endif
 398
 399         /* File menu */
 400         ev_window_set_action_sensitive (ev_window, "FileOpenCopy", has_document);
 401         ev_window_set_action_sensitive (ev_window, "FileSaveAs", has_document && ok_to_copy);
 402 #if !GTK_CHECK_VERSION (2, 17, 4)
 403         ev_window_set_action_sensitive (ev_window, "FilePageSetup", has_pages && ok_to_print && ok_to_print_setup);
 404 #endif
 405         ev_window_set_action_sensitive (ev_window, "FilePrint", has_pages && ok_to_print);
 406         ev_window_set_action_sensitive (ev_window, "FileProperties", has_document && has_properties);
 407
 408         /* Edit menu */
 409         ev_window_set_action_sensitive (ev_window, "EditSelectAll", has_pages && can_get_text);
 410         ev_window_set_action_sensitive (ev_window, "EditFind", can_find);
 411         ev_window_set_action_sensitive (ev_window, "Slash", can_find);
 412         ev_window_set_action_sensitive (ev_window, "EditRotateLeft", has_pages);
 413         ev_window_set_action_sensitive (ev_window, "EditRotateRight", has_pages);
 414
 415         /* View menu */
 416         ev_window_set_action_sensitive (ev_window, "ViewContinuous", has_pages);
 417         ev_window_set_action_sensitive (ev_window, "ViewDual", has_pages);
 418         ev_window_set_action_sensitive (ev_window, "ViewBestFit", has_pages);
 419         ev_window_set_action_sensitive (ev_window, "ViewPageWidth", has_pages);
 420         ev_window_set_action_sensitive (ev_window, "ViewReload", has_pages);
 421         ev_window_set_action_sensitive (ev_window, "ViewAutoscroll", has_pages);
 422         ev_window_set_action_sensitive (ev_window, "ViewInvertedColors", has_pages);
 423
 424         /* Toolbar-specific actions: */
 425         ev_window_set_action_sensitive (ev_window, PAGE_SELECTOR_ACTION, has_pages);
 426         ev_window_set_action_sensitive (ev_window, ZOOM_CONTROL_ACTION,  has_pages);
 427         ev_window_set_action_sensitive (ev_window, NAVIGATION_ACTION,  FALSE);
 428
 429         /* Help menu */
 430 #ifdef G_OS_WIN32
 431         ev_window_set_action_sensitive (ev_window, "HelpContents", FALSE);
 432 #endif
 433
 434         ev_window_update_actions (ev_window);
 435 }
 436
 437 static void
 438 ev_window_update_actions (EvWindow *ev_window)
 439 {
 440         EvView *view = EV_VIEW (ev_window->priv->view);
 441         int n_pages = 0, page = -1;
 442         gboolean has_pages = FALSE;
 443         gboolean presentation_mode;
 444         gboolean can_find_in_page = FALSE;
 445         EvSizingMode sizing_mode;
 446
 447         if (ev_window->priv->document) {
 448                 page = ev_document_model_get_page (ev_window->priv->model);
 449                 n_pages = ev_document_get_n_pages (ev_window->priv->document);
 450                 has_pages = n_pages > 0;
 451         }
 452
 453         can_find_in_page = (ev_window->priv->find_job &&
 454                             ev_job_find_has_results (EV_JOB_FIND (ev_window->priv->find_job)));
 455
 456         ev_window_set_action_sensitive (ev_window, "EditCopy",
 457                                         has_pages &&
 458                                         ev_view_get_has_selection (view));
 459         ev_window_set_action_sensitive (ev_window, "EditFindNext",
 460                                         has_pages && can_find_in_page);
 461         ev_window_set_action_sensitive (ev_window, "EditFindPrevious",
 462                                         has_pages && can_find_in_page);
 463         ev_window_set_action_sensitive (ev_window, "F3",
 464                                         has_pages && can_find_in_page);
 465
 466         presentation_mode = EV_WINDOW_IS_PRESENTATION (ev_window);
 467
 468         ev_window_set_action_sensitive (ev_window, "ViewZoomIn",
 469                                         has_pages &&
 470                                         ev_view_can_zoom_in (view) &&
 471                                         !presentation_mode);
 472         ev_window_set_action_sensitive (ev_window, "ViewZoomOut",
 473                                         has_pages &&
 474                                         ev_view_can_zoom_out (view) &&
 475                                         !presentation_mode);
 476
 477         /* Go menu */
 478         if (has_pages) {
 479                 ev_window_set_action_sensitive (ev_window, "GoPreviousPage", page > 0);
 480                 ev_window_set_action_sensitive (ev_window, "GoNextPage", page < n_pages - 1);
 481                 ev_window_set_action_sensitive (ev_window, "GoFirstPage", page > 0);
 482                 ev_window_set_action_sensitive (ev_window, "GoLastPage", page < n_pages - 1);
 483         } else {
 484                 ev_window_set_action_sensitive (ev_window, "GoFirstPage", FALSE);
 485                 ev_window_set_action_sensitive (ev_window, "GoPreviousPage", FALSE);
 486                 ev_window_set_action_sensitive (ev_window, "GoNextPage", FALSE);
 487                 ev_window_set_action_sensitive (ev_window, "GoLastPage", FALSE);
 488         }
 489
 490         sizing_mode = ev_document_model_get_sizing_mode (ev_window->priv->model);
 491         if (has_pages && sizing_mode != EV_SIZING_FIT_WIDTH && sizing_mode != EV_SIZING_BEST_FIT) {
 492                 GtkAction *action;
 493                 float      zoom;
 494                 float      real_zoom;
 495
 496                 action = gtk_action_group_get_action (ev_window->priv->action_group,
 497                                                       ZOOM_CONTROL_ACTION);
 498
 499                 real_zoom = ev_document_model_get_scale (ev_window->priv->model);
 500                 real_zoom *= 72.0 / get_screen_dpi (GTK_WINDOW (ev_window));
 501                 zoom = ephy_zoom_get_nearest_zoom_level (real_zoom);
 502
 503                 ephy_zoom_action_set_zoom_level (EPHY_ZOOM_ACTION (action), zoom);
 504         }
 505 }
 506
 507 static void
 508 ev_window_set_view_accels_sensitivity (EvWindow *window, gboolean sensitive)
 509 {
 510         gboolean can_find;
 511
 512         can_find = window->priv->document &&
 513             EV_IS_DOCUMENT_FIND (window->priv->document);
 514
 515         if (window->priv->action_group) {
 516                 ev_window_set_action_sensitive (window, "PageDown", sensitive);
 517                 ev_window_set_action_sensitive (window, "PageUp", sensitive);
 518                 ev_window_set_action_sensitive (window, "Space", sensitive);
 519                 ev_window_set_action_sensitive (window, "ShiftSpace", sensitive);
 520                 ev_window_set_action_sensitive (window, "BackSpace", sensitive);
 521                 ev_window_set_action_sensitive (window, "ShiftBackSpace", sensitive);
 522                 ev_window_set_action_sensitive (window, "Return", sensitive);
 523                 ev_window_set_action_sensitive (window, "ShiftReturn", sensitive);
 524                 ev_window_set_action_sensitive (window, "Plus", sensitive);
 525                 ev_window_set_action_sensitive (window, "Minus", sensitive);
 526                 ev_window_set_action_sensitive (window, "KpPlus", sensitive);
 527                 ev_window_set_action_sensitive (window, "KpMinus", sensitive);
 528                 ev_window_set_action_sensitive (window, "Equal", sensitive);
 529                 ev_window_set_action_sensitive (window, "p", sensitive);
 530                 ev_window_set_action_sensitive (window, "n", sensitive);
 531
 532                 ev_window_set_action_sensitive (window, "Slash", sensitive && can_find);
 533         }
 534 }
 535
 536 static void
 537 set_widget_visibility (GtkWidget *widget, gboolean visible)
 538 {
 539         g_assert (GTK_IS_WIDGET (widget));
 540
 541         if (visible)
 542                 gtk_widget_show (widget);
 543         else
 544                 gtk_widget_hide (widget);
 545 }
 546
 547 static void
 548 update_chrome_visibility (EvWindow *window)
 549 {
 550         EvWindowPrivate *priv = window->priv;
 551         gboolean menubar, toolbar, findbar, fullscreen_toolbar, sidebar;
 552         gboolean fullscreen_mode, presentation, fullscreen;
 553
 554         presentation = EV_WINDOW_IS_PRESENTATION (window);
 555         fullscreen = ev_document_model_get_fullscreen (priv->model);
 556         fullscreen_mode = fullscreen || presentation;
 557
 558         menubar = (priv->chrome & EV_CHROME_MENUBAR) != 0 && !fullscreen_mode;
 559         toolbar = ((priv->chrome & EV_CHROME_TOOLBAR) != 0  ||
 560                    (priv->chrome & EV_CHROME_RAISE_TOOLBAR) != 0) && !fullscreen_mode;
 561         fullscreen_toolbar = ((priv->chrome & EV_CHROME_FULLSCREEN_TOOLBAR) != 0 ||
 562                               (priv->chrome & EV_CHROME_RAISE_TOOLBAR) != 0) && fullscreen;
 563         findbar = (priv->chrome & EV_CHROME_FINDBAR) != 0;
 564         sidebar = (priv->chrome & EV_CHROME_SIDEBAR) != 0 && !presentation;
 565
 566         set_widget_visibility (priv->menubar, menubar);
 567         set_widget_visibility (priv->toolbar, toolbar);
 568         set_widget_visibility (priv->find_bar, findbar);
 569         set_widget_visibility (priv->sidebar, sidebar);
 570
 571         ev_window_set_action_sensitive (window, "EditToolbar", toolbar);
 572
 573         if (priv->fullscreen_toolbar != NULL) {
 574                 set_widget_visibility (priv->fullscreen_toolbar, fullscreen_toolbar);
 575         }
 576 }
 577
 578 static void
 579 update_chrome_flag (EvWindow *window, EvChrome flag, gboolean active)
 580 {
 581         EvWindowPrivate *priv = window->priv;
 582
 583         if (active) {
 584                 priv->chrome |= flag;
 585         } else {
 586                 priv->chrome &= ~flag;
 587         }
 588 }
 589
 590 static void
 591 update_sizing_buttons (EvWindow *window)
 592 {
 593         GtkActionGroup *action_group = window->priv->action_group;
 594         GtkAction *action;
 595         gboolean best_fit, page_width;
 596
 597         switch (ev_document_model_get_sizing_mode (window->priv->model)) {
 598                 case EV_SIZING_BEST_FIT:
 599                         best_fit = TRUE;
 600                         page_width = FALSE;
 601                         break;
 602                 case EV_SIZING_FIT_WIDTH:
 603                         best_fit = FALSE;
 604                         page_width = TRUE;
 605                         break;
 606                 default:
 607                         best_fit = page_width = FALSE;
 608                         break;
 609         }
 610
 611         action = gtk_action_group_get_action (action_group, "ViewBestFit");
 612         g_signal_handlers_block_by_func
 613                 (action, G_CALLBACK (ev_window_cmd_view_best_fit), window);
 614         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), best_fit);
 615         g_signal_handlers_unblock_by_func
 616                 (action, G_CALLBACK (ev_window_cmd_view_best_fit), window);
 617
 618         action = gtk_action_group_get_action (action_group, "ViewPageWidth");
 619         g_signal_handlers_block_by_func
 620                 (action, G_CALLBACK (ev_window_cmd_view_page_width), window);
 621         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), page_width);
 622         g_signal_handlers_unblock_by_func
 623                 (action, G_CALLBACK (ev_window_cmd_view_page_width), window);
 624
 625         action = gtk_action_group_get_action (window->priv->action_group,
 626                                               ZOOM_CONTROL_ACTION);
 627         if (best_fit) {
 628                 ephy_zoom_action_set_zoom_level (EPHY_ZOOM_ACTION (action),
 629                                                  EPHY_ZOOM_BEST_FIT);
 630         } else if (page_width) {
 631                 ephy_zoom_action_set_zoom_level (EPHY_ZOOM_ACTION (action),
 632                                                  EPHY_ZOOM_FIT_WIDTH);
 633         }
 634 }
 635
 636 /**
 637  * ev_window_is_empty:
 638  * @ev_window: The instance of the #EvWindow.
 639  *
 640  * It does look if there is any document loaded or if there is any job to load
 641  * a document.
 642  *
 643  * Returns: %TRUE if there isn't any document loaded or any any documente to be
 644  *          loaded, %FALSE in other case.
 645  */
 646 gboolean
 647 ev_window_is_empty (const EvWindow *ev_window)
 648 {
 649         g_return_val_if_fail (EV_IS_WINDOW (ev_window), FALSE);
 650
 651         return (ev_window->priv->document == NULL) &&
 652                 (ev_window->priv->load_job == NULL);
 653 }
 654
 655 static void
 656 ev_window_set_message_area (EvWindow  *window,
 657                             GtkWidget *area)
 658 {
 659         if (window->priv->message_area == area)
 660                 return;
 661
 662         if (window->priv->message_area)
 663                 gtk_widget_destroy (window->priv->message_area);
 664         window->priv->message_area = area;
 665
 666         if (!area)
 667                 return;
 668
 669         gtk_box_pack_start (GTK_BOX (window->priv->view_box),
 670                             window->priv->message_area,
 671                             FALSE, FALSE, 0);
 672         gtk_box_reorder_child (GTK_BOX (window->priv->view_box),
 673                                window->priv->message_area, 0);
 674         g_object_add_weak_pointer (G_OBJECT (window->priv->message_area),
 675                                    (gpointer) &(window->priv->message_area));
 676 }
 677
 678 static void
 679 ev_window_message_area_response_cb (EvMessageArea *area,
 680                                     gint           response_id,
 681                                     EvWindow      *window)
 682 {
 683         ev_window_set_message_area (window, NULL);
 684 }
 685
 686 static void
 687 ev_window_error_message (EvWindow    *window,
 688                          GError      *error,
 689                          const gchar *format,
 690                          ...)
 691 {
 692         GtkWidget *area;
 693         va_list    args;
 694         gchar     *msg = NULL;
 695
 696         if (window->priv->message_area)
 697                 return;
 698
 699         va_start (args, format);
 700         msg = g_strdup_vprintf (format, args);
 701         va_end (args);
 702
 703         area = ev_message_area_new (GTK_MESSAGE_ERROR,
 704                                     msg,
 705                                     GTK_STOCK_CLOSE,
 706                                     GTK_RESPONSE_CLOSE,
 707                                     NULL);
 708         g_free (msg);
 709
 710         if (error)
 711                 ev_message_area_set_secondary_text (EV_MESSAGE_AREA (area), error->message);
 712         g_signal_connect (area, "response",
 713                           G_CALLBACK (ev_window_message_area_response_cb),
 714                           window);
 715         gtk_widget_show (area);
 716         ev_window_set_message_area (window, area);
 717 }
 718
 719 static void
 720 ev_window_warning_message (EvWindow    *window,
 721                            const gchar *format,
 722                            ...)
 723 {
 724         GtkWidget *area;
 725         va_list    args;
 726         gchar     *msg = NULL;
 727
 728         if (window->priv->message_area)
 729                 return;
 730
 731         va_start (args, format);
 732         msg = g_strdup_vprintf (format, args);
 733         va_end (args);
 734
 735         area = ev_message_area_new (GTK_MESSAGE_WARNING,
 736                                     msg,
 737                                     GTK_STOCK_CLOSE,
 738                                     GTK_RESPONSE_CLOSE,
 739                                     NULL);
 740         g_free (msg);
 741
 742         g_signal_connect (area, "response",
 743                           G_CALLBACK (ev_window_message_area_response_cb),
 744                           window);
 745         gtk_widget_show (area);
 746         ev_window_set_message_area (window, area);
 747 }
 748
 749 typedef struct _FindTask {
 750         const gchar *page_label;
 751         gchar *chapter;
 752 } FindTask;
 753
 754 static gboolean
 755 ev_window_find_chapter (GtkTreeModel *tree_model,
 756                         GtkTreePath  *path,
 757                         GtkTreeIter  *iter,
 758                         gpointer      data)
 759 {
 760         FindTask *task = (FindTask *)data;
 761         gchar *page_string;
 762
 763         gtk_tree_model_get (tree_model, iter,
 764                             EV_DOCUMENT_LINKS_COLUMN_PAGE_LABEL, &page_string,
 765                             -1);
 766
 767         if (!page_string)
 768                 return FALSE;
 769
 770         if (!strcmp (page_string, task->page_label)) {
 771                 gtk_tree_model_get (tree_model, iter,
 772                                     EV_DOCUMENT_LINKS_COLUMN_MARKUP, &task->chapter,
 773                                     -1);
 774                 g_free (page_string);
 775                 return TRUE;
 776         }
 777
 778         g_free (page_string);
 779         return FALSE;
 780 }
 781
 782 static void
 783 ev_window_add_history (EvWindow *window, gint page, EvLink *link)
 784 {
 785         gchar *page_label = NULL;
 786         gchar *link_title;
 787         FindTask find_task;
 788         EvLink *real_link;
 789         EvLinkAction *action;
 790         EvLinkDest *dest;
 791
 792         if (window->priv->history == NULL)
 793                 return;
 794
 795         if (!EV_IS_DOCUMENT_LINKS (window->priv->document))
 796                 return;
 797
 798         if (link) {
 799                 action = g_object_ref (ev_link_get_action (link));
 800                 dest = ev_link_action_get_dest (action);
 801                 page_label = ev_document_links_get_dest_page_label (EV_DOCUMENT_LINKS (window->priv->document), dest);
 802         } else {
 803                 dest = ev_link_dest_new_page (page);
 804                 action = ev_link_action_new_dest (dest);
 805                 page_label = ev_document_get_page_label (window->priv->document, page);
 806         }
 807
 808         if (!page_label)
 809                 return;
 810
 811         find_task.page_label = page_label;
 812         find_task.chapter = NULL;
 813
 814         if (ev_document_links_has_document_links (EV_DOCUMENT_LINKS (window->priv->document))) {
 815                 GtkTreeModel *model;
 816
 817                 g_object_get (G_OBJECT (window->priv->sidebar_links), "model", &model, NULL);
 818
 819                 if (model) {
 820                         gtk_tree_model_foreach (model,
 821                                                 ev_window_find_chapter,
 822                                                 &find_task);
 823
 824                         g_object_unref (model);
 825                 }
 826         }
 827
 828         if (find_task.chapter)
 829                 link_title = g_strdup_printf (_("Page %s — %s"), page_label, find_task.chapter);
 830         else
 831                 link_title = g_strdup_printf (_("Page %s"), page_label);
 832
 833         real_link = ev_link_new (link_title, action);
 834
 835         ev_history_add_link (window->priv->history, real_link);
 836
 837         g_free (find_task.chapter);
 838         g_free (link_title);
 839         g_free (page_label);
 840         g_object_unref (real_link);
 841 }
 842
 843 static void
 844 view_handle_link_cb (EvView *view, EvLink *link, EvWindow *window)
 845 {
 846         int current_page = ev_document_model_get_page (window->priv->model);
 847
 848         ev_window_add_history (window, 0, link);
 849         ev_window_add_history (window, current_page, NULL);
 850 }
 851
 852 static void
 853 view_selection_changed_cb (EvView   *view,
 854                            EvWindow *window)
 855 {
 856         ev_window_set_action_sensitive (window, "EditCopy",
 857                                         ev_view_get_has_selection (view));
 858 }
 859
 860 static void
 861 ev_window_page_changed_cb (EvWindow        *ev_window,
 862                            gint             old_page,
 863                            gint             new_page,
 864                            EvDocumentModel *model)
 865 {
 866         ev_window_update_actions (ev_window);
 867
 868         ev_window_update_find_status_message (ev_window);
 869
 870         if (abs (new_page - old_page) > 1) {
 871                 ev_window_add_history (ev_window, new_page, NULL);
 872                 ev_window_add_history (ev_window, old_page, NULL);
 873         }
 874
 875         if (ev_window->priv->metadata && !ev_window_is_empty (ev_window))
 876                 ev_metadata_set_int (ev_window->priv->metadata, "page", new_page);
 877 }
 878
 879 static void
 880 update_document_mode (EvWindow *window, EvDocumentMode mode)
 881 {
 882         if (mode == EV_DOCUMENT_MODE_PRESENTATION) {
 883                 ev_window_run_presentation (window);
 884         }
 885         else if (mode == EV_DOCUMENT_MODE_FULL_SCREEN) {
 886                 ev_window_run_fullscreen (window);
 887         }
 888 }
 889
 890 static void
 891 setup_chrome_from_metadata (EvWindow *window)
 892 {
 893         EvChrome chrome = EV_CHROME_NORMAL;
 894         gboolean show_toolbar;
 895
 896         if (window->priv->metadata &&
 897             ev_metadata_get_boolean (window->priv->metadata, "show_toolbar", &show_toolbar)) {
 898                 if (!show_toolbar)
 899                         chrome &= ~EV_CHROME_TOOLBAR;
 900         }
 901         window->priv->chrome = chrome;
 902 }
 903
 904 static void
 905 setup_sidebar_from_metadata (EvWindow *window)
 906 {
 907         EvDocument *document = window->priv->document;
 908         GtkWidget  *sidebar = window->priv->sidebar;
 909         GtkWidget  *links = window->priv->sidebar_links;
 910         GtkWidget  *thumbs = window->priv->sidebar_thumbs;
 911         GtkWidget  *attachments = window->priv->sidebar_attachments;
 912         GtkWidget  *layers = window->priv->sidebar_layers;
 913         gchar      *page_id;
 914         gint        sidebar_size;
 915         gboolean    sidebar_visibility;
 916
 917         if (!window->priv->metadata)
 918                 return;
 919
 920         if (ev_metadata_get_int (window->priv->metadata, "sidebar_size", &sidebar_size)) {
 921                 gtk_paned_set_position (GTK_PANED (window->priv->hpaned), sidebar_size);
 922         }
 923
 924         if (document && ev_metadata_get_string (window->priv->metadata, "sidebar_page", &page_id)) {
 925                 if (strcmp (page_id, LINKS_SIDEBAR_ID) == 0 && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (links), document)) {
 926                         ev_sidebar_set_page (EV_SIDEBAR (sidebar), links);
 927                 } else if (strcmp (page_id, THUMBNAILS_SIDEBAR_ID) == 0 && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (thumbs), document)) {
 928                         ev_sidebar_set_page (EV_SIDEBAR (sidebar), thumbs);
 929                 } else if (strcmp (page_id, ATTACHMENTS_SIDEBAR_ID) == 0 && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (attachments), document)) {
 930                         ev_sidebar_set_page (EV_SIDEBAR (sidebar), attachments);
 931                 } else if (strcmp (page_id, LAYERS_SIDEBAR_ID) == 0 && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (layers), document)) {
 932                         ev_sidebar_set_page (EV_SIDEBAR (sidebar), layers);
 933                 }
 934         } else if (document) {
 935                 if (ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (links), document)) {
 936                         ev_sidebar_set_page (EV_SIDEBAR (sidebar), links);
 937                 } else if (ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (thumbs), document)) {
 938                         ev_sidebar_set_page (EV_SIDEBAR (sidebar), thumbs);
 939                 } else if (ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (attachments), document)) {
 940                         ev_sidebar_set_page (EV_SIDEBAR (sidebar), attachments);
 941                 } else if (ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (layers), document)) {
 942                         ev_sidebar_set_page (EV_SIDEBAR (sidebar), layers);
 943                 }
 944         }
 945
 946         if (ev_metadata_get_boolean (window->priv->metadata, "sidebar_visibility", &sidebar_visibility)) {
 947                 update_chrome_flag (window, EV_CHROME_SIDEBAR, sidebar_visibility);
 948                 update_chrome_visibility (window);
 949         }
 950 }
 951
 952 static void
 953 setup_model_from_metadata (EvWindow *window)
 954 {
 955         gint     page;
 956         gchar   *sizing_mode;
 957         gdouble  zoom;
 958         gint     rotation;
 959         gboolean inverted_colors = FALSE;
 960         gboolean continuous = FALSE;
 961         gboolean dual_page = FALSE;
 962         gboolean fullscreen = FALSE;
 963
 964         if (!window->priv->metadata)
 965                 return;
 966
 967         /* Current page */
 968         if (!window->priv->dest &&
 969             ev_metadata_get_int (window->priv->metadata, "page", &page)) {
 970                 ev_document_model_set_page (window->priv->model, page);
 971         }
 972
 973         /* Sizing mode */
 974         if (ev_metadata_get_string (window->priv->metadata, "sizing_mode", &sizing_mode)) {
 975                 GEnumValue *enum_value;
 976
 977                 enum_value = g_enum_get_value_by_nick
 978                         (g_type_class_peek (EV_TYPE_SIZING_MODE), sizing_mode);
 979                 ev_document_model_set_sizing_mode (window->priv->model, enum_value->value);
 980         }
 981
 982         /* Zoom */
 983         if (ev_document_model_get_sizing_mode (window->priv->model) == EV_SIZING_FREE &&
 984             ev_metadata_get_double (window->priv->metadata, "zoom", &zoom)) {
 985                 zoom *= get_screen_dpi (GTK_WINDOW (window)) / 72.0;
 986                 ev_document_model_set_scale (window->priv->model, zoom);
 987         }
 988
 989         /* Rotation */
 990         if (ev_metadata_get_int (window->priv->metadata, "rotation", &rotation)) {
 991                 switch (rotation) {
 992                 case 90:
 993                         rotation = 90;
 994                         break;
 995                 case 180:
 996                         rotation = 180;
 997                         break;
 998                 case 270:
 999                         rotation = 270;
1000                         break;
1001                 default:
1002                         rotation = 0;
1003                         break;
1004                 }
1005                 ev_document_model_set_rotation (window->priv->model, rotation);
1006         }
1007
1008         /* Inverted Colors */
1009         if (ev_metadata_get_boolean (window->priv->metadata, "inverted-colors", &inverted_colors))
1010                 ev_document_model_set_inverted_colors (window->priv->model, inverted_colors);
1011
1012         /* Continuous */
1013         if (ev_metadata_get_boolean (window->priv->metadata, "continuous", &continuous)) {
1014                 ev_document_model_set_continuous (window->priv->model, continuous);
1015         }
1016
1017         /* Dual page */
1018         if (ev_metadata_get_boolean (window->priv->metadata, "dual-page", &dual_page)) {
1019                 ev_document_model_set_dual_page (window->priv->model, dual_page);
1020         }
1021
1022         /* Fullscreen */
1023         if (ev_metadata_get_boolean (window->priv->metadata, "fullscreen", &fullscreen)) {
1024                 if (fullscreen) {
1025                         ev_window_run_fullscreen (window);
1026                 }
1027         }
1028 }
1029
1030 static void
1031 setup_document_from_metadata (EvWindow *window)
1032 {
1033         gint    page, n_pages;
1034         gint    width;
1035         gint    height;
1036         gdouble width_ratio;
1037         gdouble height_ratio;
1038
1039         if (!window->priv->metadata)
1040                 return;
1041
1042         /* Make sure to not open a document on the last page,
1043          * since closing it on the last page most likely means the
1044          * user was finished reading the document. In that case, reopening should
1045          * show the first page. */
1046         page = ev_document_model_get_page (window->priv->model);
1047         n_pages = ev_document_get_n_pages (window->priv->document);
1048         if (page == n_pages - 1)
1049                 ev_document_model_set_page (window->priv->model, 0);
1050
1051         setup_sidebar_from_metadata (window);
1052
1053         if (ev_metadata_get_int (window->priv->metadata, "window_width", &width) &&
1054             ev_metadata_get_int (window->priv->metadata, "window_height", &height))
1055                 return; /* size was already set in setup_size_from_metadata */
1056
1057         if (ev_metadata_get_double (window->priv->metadata, "window_width_ratio", &width_ratio) &&
1058             ev_metadata_get_double (window->priv->metadata, "window_height_ratio", &height_ratio)) {
1059                 gdouble    document_width;
1060                 gdouble    document_height;
1061                 GdkScreen *screen;
1062                 gint       request_width;
1063                 gint       request_height;
1064
1065                 ev_document_get_max_page_size (window->priv->document,
1066                                                &document_width, &document_height);
1067
1068                 request_width = (gint)(width_ratio * document_width + 0.5);
1069                 request_height = (gint)(height_ratio * document_height + 0.5);
1070
1071                 screen = gtk_window_get_screen (GTK_WINDOW (window));
1072                 if (screen) {
1073                         request_width = MIN (request_width, gdk_screen_get_width (screen));
1074                         request_height = MIN (request_width, gdk_screen_get_height (screen));
1075                 }
1076
1077                 if (request_width > 0 && request_height > 0) {
1078                         gtk_window_resize (GTK_WINDOW (window),
1079                                            request_width,
1080                                            request_height);
1081                 }
1082         }
1083 }
1084
1085 static void
1086 setup_size_from_metadata (EvWindow *window)
1087 {
1088         gint     width;
1089         gint     height;
1090         gboolean maximized;
1091         gint     x;
1092         gint     y;
1093
1094         if (!window->priv->metadata)
1095                 return;
1096
1097         if (ev_metadata_get_boolean (window->priv->metadata, "window_maximized", &maximized)) {
1098                 if (maximized) {
1099                         gtk_window_maximize (GTK_WINDOW (window));
1100                         return;
1101                 } else {
1102                         gtk_window_unmaximize (GTK_WINDOW (window));
1103                 }
1104         }
1105
1106         if (ev_metadata_get_int (window->priv->metadata, "window_x", &x) &&
1107             ev_metadata_get_int (window->priv->metadata, "window_y", &y)) {
1108                 gtk_window_move (GTK_WINDOW (window), x, y);
1109         }
1110
1111         if (ev_metadata_get_int (window->priv->metadata, "window_width", &width) &&
1112             ev_metadata_get_int (window->priv->metadata, "window_height", &height)) {
1113                 gtk_window_resize (GTK_WINDOW (window), width, height);
1114         }
1115 }
1116
1117 static void
1118 setup_view_from_metadata (EvWindow *window)
1119 {
1120         gboolean presentation;
1121
1122         if (!window->priv->metadata)
1123                 return;
1124
1125         /* Presentation */
1126         if (ev_metadata_get_boolean (window->priv->metadata, "presentation", &presentation)) {
1127                 if (presentation) {
1128                         ev_window_run_presentation (window);
1129                 }
1130         }
1131 }
1132
1133 static void
1134 ev_window_clear_thumbnail_job (EvWindow *ev_window)
1135 {
1136         if (ev_window->priv->thumbnail_job != NULL) {
1137                 if (!ev_job_is_finished (ev_window->priv->thumbnail_job))
1138                         ev_job_cancel (ev_window->priv->thumbnail_job);
1139
1140                 g_signal_handlers_disconnect_by_func (ev_window->priv->thumbnail_job,
1141                                                       ev_window_set_icon_from_thumbnail,
1142                                                       ev_window);
1143                 g_object_unref (ev_window->priv->thumbnail_job);
1144                 ev_window->priv->thumbnail_job = NULL;
1145         }
1146 }
1147
1148 static void
1149 ev_window_set_icon_from_thumbnail (EvJobThumbnail *job,
1150                                    EvWindow       *ev_window)
1151 {
1152         if (job->thumbnail) {
1153                 if (ev_document_model_get_inverted_colors (ev_window->priv->model))
1154                         ev_document_misc_invert_pixbuf (job->thumbnail);
1155                 gtk_window_set_icon (GTK_WINDOW (ev_window),
1156                                      job->thumbnail);
1157         }
1158
1159         ev_window_clear_thumbnail_job (ev_window);
1160 }
1161
1162 static void
1163 ev_window_refresh_window_thumbnail (EvWindow *ev_window)
1164 {
1165         gdouble page_width;
1166         gdouble scale;
1167         gint rotation;
1168         EvDocument *document = ev_window->priv->document;
1169
1170         if (!EV_IS_DOCUMENT_THUMBNAILS (document) ||
1171             ev_document_get_n_pages (document) <= 0 ||
1172             !ev_document_check_dimensions (document)) {
1173                 return;
1174         }
1175
1176         ev_window_clear_thumbnail_job (ev_window);
1177
1178         ev_document_get_page_size (document, 0, &page_width, NULL);
1179         scale = 128. / page_width;
1180         rotation = ev_document_model_get_rotation (ev_window->priv->model);
1181
1182         ev_window->priv->thumbnail_job = ev_job_thumbnail_new (document, 0, rotation, scale);
1183         g_signal_connect (ev_window->priv->thumbnail_job, "finished",
1184                           G_CALLBACK (ev_window_set_icon_from_thumbnail),
1185                           ev_window);
1186         ev_job_scheduler_push_job (ev_window->priv->thumbnail_job, EV_JOB_PRIORITY_NONE);
1187 }
1188
1189 #ifdef WITH_GCONF
1190 static void
1191 lockdown_changed (GConfClient *client,
1192                   guint        cnxn_id,
1193                   GConfEntry  *entry,
1194                   EvWindow    *ev_window)
1195 {
1196         ev_window_setup_action_sensitivity (ev_window);
1197 }
1198 #endif /* WITH_GCONF */
1199
1200 static gboolean
1201 ev_window_setup_document (EvWindow *ev_window)
1202 {
1203         const EvDocumentInfo *info;
1204         EvDocument *document = ev_window->priv->document;
1205         GtkAction *action;
1206
1207         ev_window->priv->setup_document_idle = 0;
1208
1209         ev_window_refresh_window_thumbnail (ev_window);
1210
1211         ev_window_set_page_mode (ev_window, PAGE_MODE_DOCUMENT);
1212         ev_window_title_set_document (ev_window->priv->title, document);
1213         ev_window_title_set_uri (ev_window->priv->title, ev_window->priv->uri);
1214
1215 #ifdef WITH_GCONF
1216         if (!ev_window->priv->gconf_client)
1217                 ev_window->priv->gconf_client = gconf_client_get_default ();
1218         gconf_client_add_dir (ev_window->priv->gconf_client,
1219                               GCONF_LOCKDOWN_DIR,
1220                               GCONF_CLIENT_PRELOAD_ONELEVEL,
1221                               NULL);
1222         gconf_client_add_dir (ev_window->priv->gconf_client,
1223                               GCONF_OVERRIDE_RESTRICTIONS,
1224                               GCONF_CLIENT_PRELOAD_NONE,
1225                               NULL);
1226         gconf_client_notify_add (ev_window->priv->gconf_client,
1227                                  GCONF_LOCKDOWN_DIR,
1228                                  (GConfClientNotifyFunc)lockdown_changed,
1229                                  ev_window, NULL, NULL);
1230         gconf_client_notify_add (ev_window->priv->gconf_client,
1231                                  GCONF_OVERRIDE_RESTRICTIONS,
1232                                  (GConfClientNotifyFunc)lockdown_changed,
1233                                  ev_window, NULL, NULL);
1234 #endif /* WITH_GCONF */
1235
1236         ev_window_setup_action_sensitivity (ev_window);
1237
1238         if (ev_window->priv->history)
1239                 g_object_unref (ev_window->priv->history);
1240         ev_window->priv->history = ev_history_new ();
1241         action = gtk_action_group_get_action (ev_window->priv->action_group, NAVIGATION_ACTION);
1242         ev_navigation_action_set_history (EV_NAVIGATION_ACTION (action), ev_window->priv->history);
1243
1244         if (ev_window->priv->properties) {
1245                 ev_properties_dialog_set_document (EV_PROPERTIES_DIALOG (ev_window->priv->properties),
1246                                                    ev_window->priv->uri,
1247                                                    ev_window->priv->document);
1248         }
1249
1250         info = ev_document_get_info (document);
1251         update_document_mode (ev_window, info->mode);
1252
1253         if (EV_WINDOW_IS_PRESENTATION (ev_window))
1254                 gtk_widget_grab_focus (ev_window->priv->presentation_view);
1255         else
1256                 gtk_widget_grab_focus (ev_window->priv->view);
1257
1258         return FALSE;
1259 }
1260
1261 static void
1262 ev_window_set_document (EvWindow *ev_window, EvDocument *document)
1263 {
1264         if (ev_window->priv->document == document)
1265                 return;
1266
1267         if (ev_window->priv->document)
1268                 g_object_unref (ev_window->priv->document);
1269         ev_window->priv->document = g_object_ref (document);
1270
1271         ev_window_set_message_area (ev_window, NULL);
1272
1273         if (ev_document_get_n_pages (document) <= 0) {
1274                 ev_window_warning_message (ev_window, "%s",
1275                                            _("The document contains no pages"));
1276         } else if (!ev_document_check_dimensions (document)) {
1277                 ev_window_warning_message (ev_window, "%s",
1278                                            _("The document contains only empty pages"));
1279         }
1280
1281         if (ev_window->priv->setup_document_idle > 0)
1282                 g_source_remove (ev_window->priv->setup_document_idle);
1283
1284         ev_window->priv->setup_document_idle = g_idle_add ((GSourceFunc)ev_window_setup_document, ev_window);
1285 }
1286
1287 static void
1288 ev_window_document_changed (EvWindow *ev_window,
1289                             gpointer  user_data)
1290 {
1291         ev_window_reload_document (ev_window, NULL);
1292 }
1293
1294 static void
1295 ev_window_password_view_unlock (EvWindow *ev_window)
1296 {
1297         const gchar *password;
1298
1299         g_assert (ev_window->priv->load_job);
1300
1301         password = ev_password_view_get_password (EV_PASSWORD_VIEW (ev_window->priv->password_view));
1302         ev_job_load_set_password (EV_JOB_LOAD (ev_window->priv->load_job), password);
1303         ev_job_scheduler_push_job (ev_window->priv->load_job, EV_JOB_PRIORITY_NONE);
1304 }
1305
1306 static void
1307 ev_window_clear_load_job (EvWindow *ev_window)
1308 {
1309         if (ev_window->priv->load_job != NULL) {
1310                 if (!ev_job_is_finished (ev_window->priv->load_job))
1311                         ev_job_cancel (ev_window->priv->load_job);
1312
1313                 g_signal_handlers_disconnect_by_func (ev_window->priv->load_job, ev_window_load_job_cb, ev_window);
1314                 g_object_unref (ev_window->priv->load_job);
1315                 ev_window->priv->load_job = NULL;
1316         }
1317 }
1318
1319 static void
1320 ev_window_clear_reload_job (EvWindow *ev_window)
1321 {
1322         if (ev_window->priv->reload_job != NULL) {
1323                 if (!ev_job_is_finished (ev_window->priv->reload_job))
1324                         ev_job_cancel (ev_window->priv->reload_job);
1325
1326                 g_signal_handlers_disconnect_by_func (ev_window->priv->reload_job, ev_window_reload_job_cb, ev_window);
1327                 g_object_unref (ev_window->priv->reload_job);
1328                 ev_window->priv->reload_job = NULL;
1329         }
1330 }
1331
1332 static void
1333 ev_window_clear_local_uri (EvWindow *ev_window)
1334 {
1335         if (ev_window->priv->local_uri) {
1336                 ev_tmp_uri_unlink (ev_window->priv->local_uri);
1337                 g_free (ev_window->priv->local_uri);
1338                 ev_window->priv->local_uri = NULL;
1339         }
1340 }
1341
1342 static void
1343 ev_window_handle_link (EvWindow *ev_window,
1344                        EvLinkDest *dest)
1345 {
1346         if (dest) {
1347                 EvLink *link;
1348                 EvLinkAction *link_action;
1349
1350                 link_action = ev_link_action_new_dest (dest);
1351                 link = ev_link_new (NULL, link_action);
1352                 ev_view_handle_link (EV_VIEW (ev_window->priv->view), link);
1353                 g_object_unref (link);
1354         }
1355 }
1356
1357 /* This callback will executed when load job will be finished.
1358  *
1359  * Since the flow of the error dialog is very confusing, we assume that both
1360  * document and uri will go away after this function is called, and thus we need
1361  * to ref/dup them.  Additionally, it needs to clear
1362  * ev_window->priv->password_{uri,document}, and thus people who call this
1363  * function should _not_ necessarily expect those to exist after being
1364  * called. */
1365 static void
1366 ev_window_load_job_cb (EvJob *job,
1367                        gpointer data)
1368 {
1369         EvWindow *ev_window = EV_WINDOW (data);
1370         EvDocument *document = EV_JOB (job)->document;
1371         EvJobLoad *job_load = EV_JOB_LOAD (job);
1372
1373         g_assert (job_load->uri);
1374
1375         ev_view_set_loading (EV_VIEW (ev_window->priv->view), FALSE);
1376
1377         /* Success! */
1378         if (!ev_job_is_failed (job)) {
1379                 ev_document_model_set_document (ev_window->priv->model, document);
1380
1381                 setup_document_from_metadata (ev_window);
1382                 setup_view_from_metadata (ev_window);
1383
1384                 ev_window_add_recent (ev_window, ev_window->priv->uri);
1385
1386                 ev_window_title_set_type (ev_window->priv->title,
1387                                           EV_WINDOW_TITLE_DOCUMENT);
1388                 if (job_load->password) {
1389                         GPasswordSave flags;
1390
1391                         flags = ev_password_view_get_password_save_flags (
1392                                 EV_PASSWORD_VIEW (ev_window->priv->password_view));
1393                         ev_keyring_save_password (ev_window->priv->uri,
1394                                                   job_load->password,
1395                                                   flags);
1396                 }
1397
1398                 ev_window_handle_link (ev_window, ev_window->priv->dest);
1399                 /* Already unrefed by ev_link_action
1400                  * FIXME: link action should inc dest ref counting
1401                  * or not unref it at all
1402                  */
1403                 ev_window->priv->dest = NULL;
1404
1405                 switch (ev_window->priv->window_mode) {
1406                         case EV_WINDOW_MODE_FULLSCREEN:
1407                                 ev_window_run_fullscreen (ev_window);
1408                                 break;
1409                         case EV_WINDOW_MODE_PRESENTATION:
1410                                 ev_window_run_presentation (ev_window);
1411                                 break;
1412                         default:
1413                                 break;
1414                 }
1415
1416                 if (ev_window->priv->search_string && EV_IS_DOCUMENT_FIND (document)) {
1417                         ev_window_cmd_edit_find (NULL, ev_window);
1418                         egg_find_bar_set_search_string (EGG_FIND_BAR (ev_window->priv->find_bar),
1419                                                         ev_window->priv->search_string);
1420                 }
1421
1422                 g_free (ev_window->priv->search_string);
1423                 ev_window->priv->search_string = NULL;
1424
1425                 /* Create a monitor for the document */
1426                 ev_window->priv->monitor = ev_file_monitor_new (ev_window->priv->uri);
1427                 g_signal_connect_swapped (ev_window->priv->monitor, "changed",
1428                                           G_CALLBACK (ev_window_document_changed),
1429                                           ev_window);
1430
1431                 ev_window_clear_load_job (ev_window);
1432                 return;
1433         }
1434
1435         if (g_error_matches (job->error, EV_DOCUMENT_ERROR, EV_DOCUMENT_ERROR_ENCRYPTED)) {
1436                 gchar *password;
1437
1438                 setup_view_from_metadata (ev_window);
1439
1440                 /* First look whether password is in keyring */
1441                 password = ev_keyring_lookup_password (ev_window->priv->uri);
1442                 if (password) {
1443                         if (job_load->password && strcmp (password, job_load->password) == 0) {
1444                                 /* Password in kering is wrong */
1445                                 ev_job_load_set_password (job_load, NULL);
1446                                 /* FIXME: delete password from keyring? */
1447                         } else {
1448                                 ev_job_load_set_password (job_load, password);
1449                                 ev_job_scheduler_push_job (job, EV_JOB_PRIORITY_NONE);
1450                                 g_free (password);
1451                                 return;
1452                         }
1453
1454                         g_free (password);
1455                 }
1456
1457                 /* We need to ask the user for a password */
1458                 ev_window_title_set_uri (ev_window->priv->title,
1459                                          ev_window->priv->uri);
1460                 ev_window_title_set_type (ev_window->priv->title,
1461                                           EV_WINDOW_TITLE_PASSWORD);
1462
1463                 ev_password_view_set_uri (EV_PASSWORD_VIEW (ev_window->priv->password_view),
1464                                           job_load->uri);
1465
1466                 ev_window_set_page_mode (ev_window, PAGE_MODE_PASSWORD);
1467
1468                 ev_job_load_set_password (job_load, NULL);
1469                 ev_password_view_ask_password (EV_PASSWORD_VIEW (ev_window->priv->password_view));
1470         } else {
1471                 ev_window_error_message (ev_window, job->error,
1472                                          "%s", _("Unable to open document"));
1473                 ev_window_clear_load_job (ev_window);
1474         }
1475 }
1476
1477 static void
1478 ev_window_reload_job_cb (EvJob    *job,
1479                          EvWindow *ev_window)
1480 {
1481         GtkWidget *widget;
1482
1483         if (ev_job_is_failed (job)) {
1484                 ev_window_clear_reload_job (ev_window);
1485                 ev_window->priv->in_reload = FALSE;
1486                 if (ev_window->priv->dest) {
1487                         g_object_unref (ev_window->priv->dest);
1488                         ev_window->priv->dest = NULL;
1489                 }
1490
1491                 return;
1492         }
1493
1494         ev_document_model_set_document (ev_window->priv->model,
1495                                         job->document);
1496         if (ev_window->priv->dest) {
1497                 ev_window_handle_link (ev_window, ev_window->priv->dest);
1498                 /* Already unrefed by ev_link_action
1499                  * FIXME: link action should inc dest ref counting
1500                  * or not unref it at all
1501                  */
1502                 ev_window->priv->dest = NULL;
1503         }
1504
1505         /* Restart the search after reloading */
1506         widget = gtk_window_get_focus (GTK_WINDOW (ev_window));
1507         if (widget && gtk_widget_get_ancestor (widget, EGG_TYPE_FIND_BAR)) {
1508                 find_bar_search_changed_cb (EGG_FIND_BAR (ev_window->priv->find_bar),
1509                                             NULL, ev_window);
1510         }
1511
1512         ev_window_clear_reload_job (ev_window);
1513         ev_window->priv->in_reload = FALSE;
1514 }
1515
1516 /**
1517  * ev_window_get_uri:
1518  * @ev_window: The instance of the #EvWindow.
1519  *
1520  * It returns the uri of the document showed in the #EvWindow.
1521  *
1522  * Returns: the uri of the document showed in the #EvWindow.
1523  */
1524 const char *
1525 ev_window_get_uri (EvWindow *ev_window)
1526 {
1527         return ev_window->priv->uri;
1528 }
1529
1530 /**
1531  * ev_window_close_dialogs:
1532  * @ev_window: The window where dialogs will be closed.
1533  *
1534  * It looks for password, print and properties dialogs and closes them and
1535  * frees them from memory. If there is any print job it does free it too.
1536  */
1537 static void
1538 ev_window_close_dialogs (EvWindow *ev_window)
1539 {
1540         if (ev_window->priv->print_dialog)
1541                 gtk_widget_destroy (ev_window->priv->print_dialog);
1542         ev_window->priv->print_dialog = NULL;
1543
1544         if (ev_window->priv->properties)
1545                 gtk_widget_destroy (ev_window->priv->properties);
1546         ev_window->priv->properties = NULL;
1547 }
1548
1549 static void
1550 ev_window_clear_progress_idle (EvWindow *ev_window)
1551 {
1552         if (ev_window->priv->progress_idle > 0)
1553                 g_source_remove (ev_window->priv->progress_idle);
1554         ev_window->priv->progress_idle = 0;
1555 }
1556
1557 static void
1558 reset_progress_idle (EvWindow *ev_window)
1559 {
1560         ev_window->priv->progress_idle = 0;
1561 }
1562
1563 static void
1564 ev_window_show_progress_message (EvWindow   *ev_window,
1565                                  guint       interval,
1566                                  GSourceFunc function)
1567 {
1568         if (ev_window->priv->progress_idle > 0)
1569                 g_source_remove (ev_window->priv->progress_idle);
1570         ev_window->priv->progress_idle =
1571                 g_timeout_add_seconds_full (G_PRIORITY_DEFAULT,
1572                                             interval, function,
1573                                             ev_window,
1574                                             (GDestroyNotify)reset_progress_idle);
1575 }
1576
1577 static void
1578 ev_window_reset_progress_cancellable (EvWindow *ev_window)
1579 {
1580         if (ev_window->priv->progress_cancellable)
1581                 g_cancellable_reset (ev_window->priv->progress_cancellable);
1582         else
1583                 ev_window->priv->progress_cancellable = g_cancellable_new ();
1584 }
1585
1586 static void
1587 ev_window_progress_response_cb (EvProgressMessageArea *area,
1588                                 gint                   response,
1589                                 EvWindow              *ev_window)
1590 {
1591         if (response == GTK_RESPONSE_CANCEL)
1592                 g_cancellable_cancel (ev_window->priv->progress_cancellable);
1593         ev_window_set_message_area (ev_window, NULL);
1594 }
1595
1596 static gboolean
1597 show_loading_progress (EvWindow *ev_window)
1598 {
1599         GtkWidget *area;
1600         gchar     *text;
1601         gchar     *display_name;
1602
1603         if (ev_window->priv->message_area)
1604                 return FALSE;
1605
1606         text = g_uri_unescape_string (ev_window->priv->uri, NULL);
1607         display_name = g_markup_escape_text (text, -1);
1608         g_free (text);
1609         text = g_strdup_printf (_("Loading document from “%s”"),
1610                                 display_name);
1611
1612         area = ev_progress_message_area_new (GTK_STOCK_OPEN,
1613                                              text,
1614                                              GTK_STOCK_CLOSE,
1615                                              GTK_RESPONSE_CLOSE,
1616                                              GTK_STOCK_CANCEL,
1617                                              GTK_RESPONSE_CANCEL,
1618                                              NULL);
1619         g_signal_connect (area, "response",
1620                           G_CALLBACK (ev_window_progress_response_cb),
1621                           ev_window);
1622         gtk_widget_show (area);
1623         ev_window_set_message_area (ev_window, area);
1624
1625         g_free (text);
1626         g_free (display_name);
1627
1628         return FALSE;
1629 }
1630
1631 static void
1632 ev_window_load_remote_failed (EvWindow *ev_window,
1633                               GError   *error)
1634 {
1635         ev_view_set_loading (EV_VIEW (ev_window->priv->view), FALSE);
1636         ev_window->priv->in_reload = FALSE;
1637         ev_window_error_message (ev_window, error,
1638                                  "%s", _("Unable to open document"));
1639         g_free (ev_window->priv->local_uri);
1640         ev_window->priv->local_uri = NULL;
1641         ev_window->priv->uri_mtime = 0;
1642 }
1643
1644 static void
1645 set_uri_mtime (GFile        *source,
1646                GAsyncResult *async_result,
1647                EvWindow     *ev_window)
1648 {
1649         GFileInfo *info;
1650         GError *error = NULL;
1651
1652         info = g_file_query_info_finish (source, async_result, &error);
1653
1654         if (error) {
1655                 ev_window->priv->uri_mtime = 0;
1656                 g_error_free (error);
1657         } else {
1658                 GTimeVal mtime;
1659
1660                 g_file_info_get_modification_time (info, &mtime);
1661                 ev_window->priv->uri_mtime = mtime.tv_sec;
1662                 g_object_unref (info);
1663         }
1664
1665         g_object_unref (source);
1666 }
1667
1668 static void
1669 mount_volume_ready_cb (GFile        *source,
1670                        GAsyncResult *async_result,
1671                        EvWindow     *ev_window)
1672 {
1673         GError *error = NULL;
1674
1675         g_file_mount_enclosing_volume_finish (source, async_result, &error);
1676
1677         if (error) {
1678                 ev_window_load_remote_failed (ev_window, error);
1679                 g_object_unref (source);
1680                 g_error_free (error);
1681         } else {
1682                 /* Volume successfully mounted,
1683                    try opening the file again */
1684                 ev_window_load_file_remote (ev_window, source);
1685         }
1686 }
1687
1688 static void
1689 window_open_file_copy_ready_cb (GFile        *source,
1690                                 GAsyncResult *async_result,
1691                                 EvWindow     *ev_window)
1692 {
1693         GError *error = NULL;
1694
1695         ev_window_clear_progress_idle (ev_window);
1696         ev_window_set_message_area (ev_window, NULL);
1697
1698         g_file_copy_finish (source, async_result, &error);
1699         if (!error) {
1700                 ev_job_scheduler_push_job (ev_window->priv->load_job, EV_JOB_PRIORITY_NONE);
1701                 g_file_query_info_async (source,
1702                                          G_FILE_ATTRIBUTE_TIME_MODIFIED,
1703                                          0, G_PRIORITY_DEFAULT,
1704                                          NULL,
1705                                          (GAsyncReadyCallback)set_uri_mtime,
1706                                          ev_window);
1707                 return;
1708         }
1709
1710         if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_MOUNTED)) {
1711                 GMountOperation *operation;
1712
1713                 operation = gtk_mount_operation_new (GTK_WINDOW (ev_window));
1714                 g_file_mount_enclosing_volume (source,
1715                                                G_MOUNT_MOUNT_NONE,
1716                                                operation, NULL,
1717                                                (GAsyncReadyCallback)mount_volume_ready_cb,
1718                                                ev_window);
1719                 g_object_unref (operation);
1720         } else if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
1721                 ev_window_clear_load_job (ev_window);
1722                 ev_window_clear_local_uri (ev_window);
1723                 g_free (ev_window->priv->uri);
1724                 ev_window->priv->uri = NULL;
1725                 g_object_unref (source);
1726
1727                 ev_view_set_loading (EV_VIEW (ev_window->priv->view), FALSE);
1728         } else {
1729                 ev_window_load_remote_failed (ev_window, error);
1730                 g_object_unref (source);
1731         }
1732
1733         g_error_free (error);
1734 }
1735
1736 static void
1737 window_open_file_copy_progress_cb (goffset   n_bytes,
1738                                    goffset   total_bytes,
1739                                    EvWindow *ev_window)
1740 {
1741         gchar *status;
1742         gdouble fraction;
1743
1744         if (!ev_window->priv->message_area)
1745                 return;
1746
1747         if (total_bytes <= 0)
1748                 return;
1749
1750         fraction = n_bytes / (gdouble)total_bytes;
1751         status = g_strdup_printf (_("Downloading document (%d%%)"),
1752                                   (gint)(fraction * 100));
1753
1754         ev_progress_message_area_set_status (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
1755                                              status);
1756         ev_progress_message_area_set_fraction (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
1757                                                fraction);
1758
1759         g_free (status);
1760 }
1761
1762 static void
1763 ev_window_load_file_remote (EvWindow *ev_window,
1764                             GFile    *source_file)
1765 {
1766         GFile *target_file;
1767
1768         if (!ev_window->priv->local_uri) {
1769                 char *base_name, *template;
1770                 GFile *tmp_file;
1771                 GError *err = NULL;
1772
1773                 /* We'd like to keep extension of source uri since
1774                  * it helps to resolve some mime types, say cbz.
1775                  */
1776                 base_name = g_file_get_basename (source_file);
1777                 template = g_strdup_printf ("document.XXXXXX-%s", base_name);
1778                 g_free (base_name);
1779
1780                 tmp_file = ev_mkstemp_file (template, &err);
1781                 g_free (template);
1782                 if (tmp_file == NULL) {
1783                         ev_window_error_message (ev_window, err,
1784                                                  "%s", _("Failed to load remote file."));
1785                         g_error_free (err);
1786                         return;
1787                 }
1788
1789                 ev_window->priv->local_uri = g_file_get_uri (tmp_file);
1790                 g_object_unref (tmp_file);
1791
1792                 ev_job_load_set_uri (EV_JOB_LOAD (ev_window->priv->load_job),
1793                                      ev_window->priv->local_uri);
1794         }
1795
1796         ev_window_reset_progress_cancellable (ev_window);
1797
1798         target_file = g_file_new_for_uri (ev_window->priv->local_uri);
1799         g_file_copy_async (source_file, target_file,
1800                            G_FILE_COPY_OVERWRITE,
1801                            G_PRIORITY_DEFAULT,
1802                            ev_window->priv->progress_cancellable,
1803                            (GFileProgressCallback)window_open_file_copy_progress_cb,
1804                            ev_window,
1805                            (GAsyncReadyCallback)window_open_file_copy_ready_cb,
1806                            ev_window);
1807         g_object_unref (target_file);
1808
1809         ev_window_show_progress_message (ev_window, 1,
1810                                          (GSourceFunc)show_loading_progress);
1811 }
1812
1813 void
1814 ev_window_open_uri (EvWindow       *ev_window,
1815                     const char     *uri,
1816                     EvLinkDest     *dest,
1817                     EvWindowRunMode mode,
1818                     const gchar    *search_string)
1819 {
1820         GFile *source_file;
1821
1822         ev_window->priv->in_reload = FALSE;
1823
1824         if (ev_window->priv->uri &&
1825             g_ascii_strcasecmp (ev_window->priv->uri, uri) == 0) {
1826                 ev_window_reload_document (ev_window, dest);
1827                 return;
1828         }
1829
1830         if (ev_window->priv->monitor) {
1831                 g_object_unref (ev_window->priv->monitor);
1832                 ev_window->priv->monitor = NULL;
1833         }
1834
1835         ev_window_close_dialogs (ev_window);
1836         ev_window_clear_load_job (ev_window);
1837         ev_window_clear_local_uri (ev_window);
1838         ev_view_set_loading (EV_VIEW (ev_window->priv->view), TRUE);
1839
1840         ev_window->priv->window_mode = mode;
1841
1842         if (ev_window->priv->uri)
1843                 g_free (ev_window->priv->uri);
1844         ev_window->priv->uri = g_strdup (uri);
1845
1846         if (ev_window->priv->metadata)
1847                 g_object_unref (ev_window->priv->metadata);
1848
1849         source_file = g_file_new_for_uri (uri);
1850         if (ev_is_metadata_supported_for_file (source_file))
1851                 ev_window->priv->metadata = ev_metadata_new (source_file);
1852         else
1853                 ev_window->priv->metadata = NULL;
1854
1855         if (ev_window->priv->search_string)
1856                 g_free (ev_window->priv->search_string);
1857         ev_window->priv->search_string = search_string ?
1858                 g_strdup (search_string) : NULL;
1859
1860         if (ev_window->priv->dest)
1861                 g_object_unref (ev_window->priv->dest);
1862         ev_window->priv->dest = dest ? g_object_ref (dest) : NULL;
1863
1864         setup_size_from_metadata (ev_window);
1865         setup_model_from_metadata (ev_window);
1866
1867         ev_window->priv->load_job = ev_job_load_new (uri);
1868         g_signal_connect (ev_window->priv->load_job,
1869                           "finished",
1870                           G_CALLBACK (ev_window_load_job_cb),
1871                           ev_window);
1872
1873         if (!g_file_is_native (source_file) && !ev_window->priv->local_uri) {
1874                 ev_window_load_file_remote (ev_window, source_file);
1875         } else {
1876                 g_object_unref (source_file);
1877                 ev_job_scheduler_push_job (ev_window->priv->load_job, EV_JOB_PRIORITY_NONE);
1878         }
1879 }
1880
1881 void
1882 ev_window_open_document (EvWindow       *ev_window,
1883                          EvDocument     *document,
1884                          EvLinkDest     *dest,
1885                          EvWindowRunMode mode,
1886                          const gchar    *search_string)
1887 {
1888         if (document == ev_window->priv->document)
1889                 return;
1890
1891         ev_window_close_dialogs (ev_window);
1892         ev_window_clear_load_job (ev_window);
1893         ev_window_clear_local_uri (ev_window);
1894
1895         if (ev_window->priv->monitor) {
1896                 g_object_unref (ev_window->priv->monitor);
1897                 ev_window->priv->monitor = NULL;
1898         }
1899
1900         if (ev_window->priv->uri)
1901                 g_free (ev_window->priv->uri);
1902         ev_window->priv->uri = g_strdup (ev_document_get_uri (document));
1903
1904         setup_size_from_metadata (ev_window);
1905         setup_model_from_metadata (ev_window);
1906
1907         ev_document_model_set_document (ev_window->priv->model, document);
1908
1909         setup_document_from_metadata (ev_window);
1910         setup_view_from_metadata (ev_window);
1911
1912         if (dest) {
1913                 EvLink *link;
1914                 EvLinkAction *link_action;
1915
1916                 link_action = ev_link_action_new_dest (dest);
1917                 link = ev_link_new (NULL, link_action);
1918                 ev_view_handle_link (EV_VIEW (ev_window->priv->view), link);
1919                 /* FIXME: link action should inc dest ref counting
1920                  * or not unref it at all
1921                  */
1922                 g_object_ref (dest);
1923                 g_object_unref (link);
1924         }
1925
1926         switch (mode) {
1927         case EV_WINDOW_MODE_FULLSCREEN:
1928                 ev_window_run_fullscreen (ev_window);
1929                 break;
1930         case EV_WINDOW_MODE_PRESENTATION:
1931                 ev_window_run_presentation (ev_window);
1932                 break;
1933         default:
1934                 break;
1935         }
1936
1937         if (search_string && EV_IS_DOCUMENT_FIND (document)) {
1938                 ev_window_cmd_edit_find (NULL, ev_window);
1939                 egg_find_bar_set_search_string (EGG_FIND_BAR (ev_window->priv->find_bar),
1940                                                 search_string);
1941         }
1942
1943         /* Create a monitor for the document */
1944         ev_window->priv->monitor = ev_file_monitor_new (ev_window->priv->uri);
1945         g_signal_connect_swapped (ev_window->priv->monitor, "changed",
1946                                   G_CALLBACK (ev_window_document_changed),
1947                                   ev_window);
1948 }
1949
1950 static void
1951 ev_window_reload_local (EvWindow *ev_window)
1952 {
1953         const gchar *uri;
1954
1955         uri = ev_window->priv->local_uri ? ev_window->priv->local_uri : ev_window->priv->uri;
1956         ev_window->priv->reload_job = ev_job_load_new (uri);
1957         g_signal_connect (ev_window->priv->reload_job, "finished",
1958                           G_CALLBACK (ev_window_reload_job_cb),
1959                           ev_window);
1960         ev_job_scheduler_push_job (ev_window->priv->reload_job, EV_JOB_PRIORITY_NONE);
1961 }
1962
1963 static gboolean
1964 show_reloading_progress (EvWindow *ev_window)
1965 {
1966         GtkWidget *area;
1967         gchar     *text;
1968
1969         if (ev_window->priv->message_area)
1970                 return FALSE;
1971
1972         text = g_strdup_printf (_("Reloading document from %s"),
1973                                 ev_window->priv->uri);
1974         area = ev_progress_message_area_new (GTK_STOCK_REFRESH,
1975                                              text,
1976                                              GTK_STOCK_CLOSE,
1977                                              GTK_RESPONSE_CLOSE,
1978                                              GTK_STOCK_CANCEL,
1979                                              GTK_RESPONSE_CANCEL,
1980                                              NULL);
1981         g_signal_connect (area, "response",
1982                           G_CALLBACK (ev_window_progress_response_cb),
1983                           ev_window);
1984         gtk_widget_show (area);
1985         ev_window_set_message_area (ev_window, area);
1986         g_free (text);
1987
1988         return FALSE;
1989 }
1990
1991 static void
1992 reload_remote_copy_ready_cb (GFile        *remote,
1993                              GAsyncResult *async_result,
1994                              EvWindow     *ev_window)
1995 {
1996         GError *error = NULL;
1997
1998         ev_window_clear_progress_idle (ev_window);
1999
2000         g_file_copy_finish (remote, async_result, &error);
2001         if (error) {
2002                 if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
2003                         ev_window_error_message (ev_window, error,
2004                                                  "%s", _("Failed to reload document."));
2005                 g_error_free (error);
2006         } else {
2007                 ev_window_reload_local (ev_window);
2008         }
2009
2010         g_object_unref (remote);
2011 }
2012
2013 static void
2014 reload_remote_copy_progress_cb (goffset   n_bytes,
2015                                 goffset   total_bytes,
2016                                 EvWindow *ev_window)
2017 {
2018         gchar *status;
2019         gdouble fraction;
2020
2021         if (!ev_window->priv->message_area)
2022                 return;
2023
2024         if (total_bytes <= 0)
2025                 return;
2026
2027         fraction = n_bytes / (gdouble)total_bytes;
2028         status = g_strdup_printf (_("Downloading document (%d%%)"),
2029                                   (gint)(fraction * 100));
2030
2031         ev_progress_message_area_set_status (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
2032                                              status);
2033         ev_progress_message_area_set_fraction (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
2034                                                fraction);
2035
2036         g_free (status);
2037 }
2038
2039 static void
2040 query_remote_uri_mtime_cb (GFile        *remote,
2041                            GAsyncResult *async_result,
2042                            EvWindow     *ev_window)
2043 {
2044         GFileInfo *info;
2045         GTimeVal   mtime;
2046         GError    *error = NULL;
2047
2048         info = g_file_query_info_finish (remote, async_result, &error);
2049         if (error) {
2050                 g_error_free (error);
2051                 g_object_unref (remote);
2052                 ev_window_reload_local (ev_window);
2053
2054                 return;
2055         }
2056
2057         g_file_info_get_modification_time (info, &mtime);
2058         if (ev_window->priv->uri_mtime != mtime.tv_sec) {
2059                 GFile *target_file;
2060
2061                 /* Remote file has changed */
2062                 ev_window->priv->uri_mtime = mtime.tv_sec;
2063
2064                 ev_window_reset_progress_cancellable (ev_window);
2065
2066                 target_file = g_file_new_for_uri (ev_window->priv->local_uri);
2067                 g_file_copy_async (remote, target_file,
2068                                    G_FILE_COPY_OVERWRITE,
2069                                    G_PRIORITY_DEFAULT,
2070                                    ev_window->priv->progress_cancellable,
2071                                    (GFileProgressCallback)reload_remote_copy_progress_cb,
2072                                    ev_window,
2073                                    (GAsyncReadyCallback)reload_remote_copy_ready_cb,
2074                                    ev_window);
2075                 g_object_unref (target_file);
2076                 ev_window_show_progress_message (ev_window, 1,
2077                                                  (GSourceFunc)show_reloading_progress);
2078         } else {
2079                 g_object_unref (remote);
2080                 ev_window_reload_local (ev_window);
2081         }
2082
2083         g_object_unref (info);
2084 }
2085
2086 static void
2087 ev_window_reload_remote (EvWindow *ev_window)
2088 {
2089         GFile *remote;
2090
2091         remote = g_file_new_for_uri (ev_window->priv->uri);
2092         /* Reload the remote uri only if it has changed */
2093         g_file_query_info_async (remote,
2094                                  G_FILE_ATTRIBUTE_TIME_MODIFIED,
2095                                  0, G_PRIORITY_DEFAULT,
2096                                  NULL,
2097                                  (GAsyncReadyCallback)query_remote_uri_mtime_cb,
2098                                  ev_window);
2099 }
2100
2101 static void
2102 ev_window_reload_document (EvWindow *ev_window,
2103                            EvLinkDest *dest)
2104 {
2105         gint page;
2106
2107
2108         ev_window_clear_reload_job (ev_window);
2109         ev_window->priv->in_reload = TRUE;
2110
2111         page = ev_document_model_get_page (ev_window->priv->model);
2112
2113         if (ev_window->priv->dest)
2114                 g_object_unref (ev_window->priv->dest);
2115         ev_window->priv->dest = dest ? g_object_ref (dest) : NULL;
2116
2117         if (ev_window->priv->local_uri) {
2118                 ev_window_reload_remote (ev_window);
2119         } else {
2120                 ev_window_reload_local (ev_window);
2121         }
2122 }
2123
2124 static void
2125 file_open_dialog_response_cb (GtkWidget *chooser,
2126                               gint       response_id,
2127                               EvWindow  *ev_window)
2128 {
2129         if (response_id == GTK_RESPONSE_OK) {
2130                 GSList *uris;
2131                 gchar  *uri;
2132
2133                 uris = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (chooser));
2134
2135                 ev_application_open_uri_list (EV_APP, uris,
2136                                               gtk_window_get_screen (GTK_WINDOW (ev_window)),
2137                                               gtk_get_current_event_time ());
2138
2139                 g_slist_foreach (uris, (GFunc)g_free, NULL);
2140                 g_slist_free (uris);
2141
2142                 uri = gtk_file_chooser_get_current_folder_uri (GTK_FILE_CHOOSER (chooser));
2143                 ev_application_set_filechooser_uri (EV_APP,
2144                                                     GTK_FILE_CHOOSER_ACTION_OPEN,
2145                                                     uri);
2146                 g_free (uri);
2147         }
2148
2149         gtk_widget_destroy (chooser);
2150 }
2151
2152 static void
2153 ev_window_cmd_file_open (GtkAction *action, EvWindow *window)
2154 {
2155         GtkWidget   *chooser;
2156         const gchar *default_uri;
2157         gchar       *parent_uri = NULL;
2158
2159         chooser = gtk_file_chooser_dialog_new (_("Open Document"),
2160                                                GTK_WINDOW (window),
2161                                                GTK_FILE_CHOOSER_ACTION_OPEN,
2162                                                GTK_STOCK_CANCEL,
2163                                                GTK_RESPONSE_CANCEL,
2164                                                GTK_STOCK_OPEN, GTK_RESPONSE_OK,
2165                                                NULL);
2166
2167         ev_document_factory_add_filters (chooser, NULL);
2168         gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (chooser), TRUE);
2169         gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (chooser), FALSE);
2170
2171         default_uri = ev_application_get_filechooser_uri (EV_APP, GTK_FILE_CHOOSER_ACTION_OPEN);
2172         if (!default_uri && window->priv->uri) {
2173                 GFile *file, *parent;
2174
2175                 file = g_file_new_for_uri (window->priv->uri);
2176                 parent = g_file_get_parent (file);
2177                 if (parent) {
2178                         parent_uri = g_file_get_uri (parent);
2179                         default_uri = parent_uri;
2180                         g_object_unref (parent);
2181                 }
2182                 g_object_unref (file);
2183         }
2184
2185         if (default_uri) {
2186                 gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (chooser), default_uri);
2187         } else {
2188                 const gchar *folder;
2189
2190                 folder = g_get_user_special_dir (G_USER_DIRECTORY_DOCUMENTS);
2191                 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser),
2192                                                      folder ? folder : g_get_home_dir ());
2193         }
2194         g_free (parent_uri);
2195
2196         g_signal_connect (chooser, "response",
2197                           G_CALLBACK (file_open_dialog_response_cb),
2198                           window);
2199
2200         gtk_widget_show (chooser);
2201 }
2202
2203 static void
2204 ev_window_open_copy_at_dest (EvWindow   *window,
2205                              EvLinkDest *dest)
2206 {
2207         EvWindow *new_window = EV_WINDOW (ev_window_new ());
2208
2209         ev_window_n_copies++;
2210
2211         if (window->priv->metadata)
2212                 new_window->priv->metadata = g_object_ref (window->priv->metadata);
2213         ev_window_open_document (new_window,
2214                                  window->priv->document,
2215                                  dest, 0, NULL);
2216         gtk_window_present (GTK_WINDOW (new_window));
2217 }
2218
2219 static void
2220 ev_window_cmd_file_open_copy (GtkAction *action, EvWindow *window)
2221 {
2222         ev_window_open_copy_at_dest (window, NULL);
2223 }
2224
2225 static void
2226 ev_window_cmd_recent_file_activate (GtkAction *action,
2227                                     EvWindow  *window)
2228 {
2229         GtkRecentInfo *info;
2230         const gchar   *uri;
2231
2232         info = g_object_get_data (G_OBJECT (action), "gtk-recent-info");
2233         g_assert (info != NULL);
2234
2235         uri = gtk_recent_info_get_uri (info);
2236
2237         ev_application_open_uri_at_dest (EV_APP, uri,
2238                                          gtk_window_get_screen (GTK_WINDOW (window)),
2239                                          NULL, 0, NULL, gtk_get_current_event_time ());
2240 }
2241
2242 static void
2243 ev_window_open_recent_action_item_activated (EvOpenRecentAction *action,
2244                                              const gchar        *uri,
2245                                              EvWindow           *window)
2246 {
2247         ev_application_open_uri_at_dest (EV_APP, uri,
2248                                          gtk_window_get_screen (GTK_WINDOW (window)),
2249                                          NULL, 0, NULL, gtk_get_current_event_time ());
2250 }
2251
2252 static void
2253 ev_window_add_recent (EvWindow *window, const char *filename)
2254 {
2255         gtk_recent_manager_add_item (window->priv->recent_manager, filename);
2256 }
2257
2258 static gint
2259 compare_recent_items (GtkRecentInfo *a, GtkRecentInfo *b)
2260 {
2261         gboolean     has_ev_a, has_ev_b;
2262         const gchar *evince = g_get_application_name ();
2263
2264         has_ev_a = gtk_recent_info_has_application (a, evince);
2265         has_ev_b = gtk_recent_info_has_application (b, evince);
2266
2267         if (has_ev_a && has_ev_b) {
2268                 time_t time_a, time_b;
2269
2270                 time_a = gtk_recent_info_get_modified (a);
2271                 time_b = gtk_recent_info_get_modified (b);
2272
2273                 return (time_b - time_a);
2274         } else if (has_ev_a) {
2275                 return -1;
2276         } else if (has_ev_b) {
2277                 return 1;
2278         }
2279
2280         return 0;
2281 }
2282
2283 /*
2284  * Doubles underscore to avoid spurious menu accels.
2285  */
2286 static gchar *
2287 ev_window_get_recent_file_label (gint index, const gchar *filename)
2288 {
2289         GString *str;
2290         gint length;
2291         const gchar *p;
2292         const gchar *end;
2293         gboolean is_rtl;
2294
2295         is_rtl = (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL);
2296
2297         g_return_val_if_fail (filename != NULL, NULL);
2298
2299         length = strlen (filename);
2300         str = g_string_sized_new (length + 10);
2301         g_string_printf (str, "%s_%d.  ", is_rtl ? "\xE2\x80\x8F" : "", index);
2302
2303         p = filename;
2304         end = filename + length;
2305
2306         while (p != end) {
2307                 const gchar *next;
2308                 next = g_utf8_next_char (p);
2309
2310                 switch (*p) {
2311                         case '_':
2312                                 g_string_append (str, "__");
2313                                 break;
2314                         default:
2315                                 g_string_append_len (str, p, next - p);
2316                                 break;
2317                 }
2318
2319                 p = next;
2320         }
2321
2322         return g_string_free (str, FALSE);
2323 }
2324
2325 static void
2326 ev_window_setup_recent (EvWindow *ev_window)
2327 {
2328         GList        *items, *l;
2329         guint         n_items = 0;
2330         const gchar  *evince = g_get_application_name ();
2331         static guint  i = 0;
2332
2333         if (ev_window->priv->recent_ui_id > 0) {
2334                 gtk_ui_manager_remove_ui (ev_window->priv->ui_manager,
2335                                           ev_window->priv->recent_ui_id);
2336                 gtk_ui_manager_ensure_update (ev_window->priv->ui_manager);
2337         }
2338         ev_window->priv->recent_ui_id = gtk_ui_manager_new_merge_id (ev_window->priv->ui_manager);
2339
2340         if (ev_window->priv->recent_action_group) {
2341                 gtk_ui_manager_remove_action_group (ev_window->priv->ui_manager,
2342                                                     ev_window->priv->recent_action_group);
2343                 g_object_unref (ev_window->priv->recent_action_group);
2344         }
2345         ev_window->priv->recent_action_group = gtk_action_group_new ("RecentFilesActions");
2346         gtk_ui_manager_insert_action_group (ev_window->priv->ui_manager,
2347                                             ev_window->priv->recent_action_group, 0);
2348
2349         items = gtk_recent_manager_get_items (ev_window->priv->recent_manager);
2350         items = g_list_sort (items, (GCompareFunc) compare_recent_items);
2351
2352         for (l = items; l && l->data; l = g_list_next (l)) {
2353                 GtkRecentInfo *info;
2354                 GtkAction     *action;
2355                 gchar         *action_name;
2356                 gchar         *label;
2357
2358                 info = (GtkRecentInfo *) l->data;
2359
2360                 if (!gtk_recent_info_has_application (info, evince) ||
2361                     (gtk_recent_info_is_local (info) && !gtk_recent_info_exists (info)))
2362                         continue;
2363
2364                 action_name = g_strdup_printf ("RecentFile%u", i++);
2365                 label = ev_window_get_recent_file_label (
2366                         n_items + 1, gtk_recent_info_get_display_name (info));
2367
2368                 action = g_object_new (GTK_TYPE_ACTION,
2369                                        "name", action_name,
2370                                        "label", label,
2371                                        NULL);
2372
2373                 g_object_set_data_full (G_OBJECT (action),
2374                                         "gtk-recent-info",
2375                                         gtk_recent_info_ref (info),
2376                                         (GDestroyNotify) gtk_recent_info_unref);
2377
2378                 g_signal_connect (action, "activate",
2379                                   G_CALLBACK (ev_window_cmd_recent_file_activate),
2380                                   (gpointer) ev_window);
2381
2382                 gtk_action_group_add_action (ev_window->priv->recent_action_group,
2383                                              action);
2384                 g_object_unref (action);
2385
2386                 gtk_ui_manager_add_ui (ev_window->priv->ui_manager,
2387                                        ev_window->priv->recent_ui_id,
2388                                        "/MainMenu/FileMenu/RecentFilesMenu",
2389                                        label,
2390                                        action_name,
2391                                        GTK_UI_MANAGER_MENUITEM,
2392                                        FALSE);
2393                 g_free (action_name);
2394                 g_free (label);
2395
2396                 if (++n_items == 5)
2397                         break;
2398         }
2399
2400         g_list_foreach (items, (GFunc) gtk_recent_info_unref, NULL);
2401         g_list_free (items);
2402 }
2403
2404 static gboolean
2405 show_saving_progress (GFile *dst)
2406 {
2407         EvWindow  *ev_window;
2408         GtkWidget *area;
2409         gchar     *text;
2410         gchar     *uri;
2411         EvSaveType save_type;
2412
2413         ev_window = EV_WINDOW (g_object_get_data (G_OBJECT (dst), "ev-window"));
2414         ev_window->priv->progress_idle = 0;
2415
2416         if (ev_window->priv->message_area)
2417                 return FALSE;
2418
2419         save_type = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dst), "save-type"));
2420         uri = g_file_get_uri (dst);
2421         switch (save_type) {
2422         case EV_SAVE_DOCUMENT:
2423                 text = g_strdup_printf (_("Saving document to %s"), uri);
2424                 break;
2425         case EV_SAVE_ATTACHMENT:
2426                 text = g_strdup_printf (_("Saving attachment to %s"), uri);
2427                 break;
2428         case EV_SAVE_IMAGE:
2429                 text = g_strdup_printf (_("Saving image to %s"), uri);
2430                 break;
2431         default:
2432                 g_assert_not_reached ();
2433         }
2434         g_free (uri);
2435         area = ev_progress_message_area_new (GTK_STOCK_SAVE,
2436                                              text,
2437                                              GTK_STOCK_CLOSE,
2438                                              GTK_RESPONSE_CLOSE,
2439                                              GTK_STOCK_CANCEL,
2440                                              GTK_RESPONSE_CANCEL,
2441                                              NULL);
2442         g_signal_connect (area, "response",
2443                           G_CALLBACK (ev_window_progress_response_cb),
2444                           ev_window);
2445         gtk_widget_show (area);
2446         ev_window_set_message_area (ev_window, area);
2447         g_free (text);
2448
2449         return FALSE;
2450 }
2451
2452 static void
2453 window_save_file_copy_ready_cb (GFile        *src,
2454                                 GAsyncResult *async_result,
2455                                 GFile        *dst)
2456 {
2457         EvWindow *ev_window;
2458         GError   *error = NULL;
2459
2460         ev_window = EV_WINDOW (g_object_get_data (G_OBJECT (dst), "ev-window"));
2461         ev_window_clear_progress_idle (ev_window);
2462
2463         if (g_file_copy_finish (src, async_result, &error)) {
2464                 ev_tmp_file_unlink (src);
2465                 return;
2466         }
2467
2468         if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
2469                 gchar *name;
2470
2471                 name = g_file_get_basename (dst);
2472                 ev_window_error_message (ev_window, error,
2473                                          _("The file could not be saved as “%s”."),
2474                                          name);
2475                 g_free (name);
2476         }
2477         ev_tmp_file_unlink (src);
2478         g_error_free (error);
2479 }
2480
2481 static void
2482 window_save_file_copy_progress_cb (goffset n_bytes,
2483                                    goffset total_bytes,
2484                                    GFile  *dst)
2485 {
2486         EvWindow  *ev_window;
2487         EvSaveType save_type;
2488         gchar     *status;
2489         gdouble    fraction;
2490
2491         ev_window = EV_WINDOW (g_object_get_data (G_OBJECT (dst), "ev-window"));
2492
2493         if (!ev_window->priv->message_area)
2494                 return;
2495
2496         if (total_bytes <= 0)
2497                 return;
2498
2499         fraction = n_bytes / (gdouble)total_bytes;
2500         save_type = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dst), "save-type"));
2501
2502         switch (save_type) {
2503         case EV_SAVE_DOCUMENT:
2504                 status = g_strdup_printf (_("Uploading document (%d%%)"),
2505                                           (gint)(fraction * 100));
2506                 break;
2507         case EV_SAVE_ATTACHMENT:
2508                 status = g_strdup_printf (_("Uploading attachment (%d%%)"),
2509                                           (gint)(fraction * 100));
2510                 break;
2511         case EV_SAVE_IMAGE:
2512                 status = g_strdup_printf (_("Uploading image (%d%%)"),
2513                                           (gint)(fraction * 100));
2514                 break;
2515         default:
2516                 g_assert_not_reached ();
2517         }
2518
2519         ev_progress_message_area_set_status (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
2520                                              status);
2521         ev_progress_message_area_set_fraction (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
2522                                                fraction);
2523
2524         g_free (status);
2525 }
2526
2527 static void
2528 ev_window_save_remote (EvWindow  *ev_window,
2529                        EvSaveType save_type,
2530                        GFile     *src,
2531                        GFile     *dst)
2532 {
2533         ev_window_reset_progress_cancellable (ev_window);
2534         g_object_set_data (G_OBJECT (dst), "ev-window", ev_window);
2535         g_object_set_data (G_OBJECT (dst), "save-type", GINT_TO_POINTER (save_type));
2536         g_file_copy_async (src, dst,
2537                            G_FILE_COPY_OVERWRITE,
2538                            G_PRIORITY_DEFAULT,
2539                            ev_window->priv->progress_cancellable,
2540                            (GFileProgressCallback)window_save_file_copy_progress_cb,
2541                            dst,
2542                            (GAsyncReadyCallback)window_save_file_copy_ready_cb,
2543                            dst);
2544         ev_window->priv->progress_idle =
2545                 g_timeout_add_seconds_full (G_PRIORITY_DEFAULT,
2546                                             1,
2547                                             (GSourceFunc)show_saving_progress,
2548                                             dst,
2549                                             NULL);
2550 }
2551
2552 static void
2553 ev_window_clear_save_job (EvWindow *ev_window)
2554 {
2555         if (ev_window->priv->save_job != NULL) {
2556                 if (!ev_job_is_finished (ev_window->priv->save_job))
2557                         ev_job_cancel (ev_window->priv->save_job);
2558
2559                 g_signal_handlers_disconnect_by_func (ev_window->priv->save_job,
2560                                                       ev_window_save_job_cb,
2561                                                       ev_window);
2562                 g_object_unref (ev_window->priv->save_job);
2563                 ev_window->priv->save_job = NULL;
2564         }
2565 }
2566
2567 static void
2568 ev_window_save_job_cb (EvJob     *job,
2569                        EvWindow  *window)
2570 {
2571         if (ev_job_is_failed (job)) {
2572                 ev_window_error_message (window, job->error,
2573                                          _("The file could not be saved as “%s”."),
2574                                          EV_JOB_SAVE (job)->uri);
2575         }
2576
2577         ev_window_clear_save_job (window);
2578 }
2579
2580 static void
2581 file_save_dialog_response_cb (GtkWidget *fc,
2582                               gint       response_id,
2583                               EvWindow  *ev_window)
2584 {
2585         gchar *uri;
2586         GFile *file, *parent;
2587
2588         if (response_id != GTK_RESPONSE_OK) {
2589                 gtk_widget_destroy (fc);
2590                 return;
2591         }
2592
2593         uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (fc));
2594         file = g_file_new_for_uri (uri);
2595         parent = g_file_get_parent (file);
2596         g_object_unref (file);
2597         if (parent) {
2598                 gchar *folder_uri;
2599
2600                 folder_uri = g_file_get_uri (parent);
2601                 ev_application_set_filechooser_uri (EV_APP,
2602                                                     GTK_FILE_CHOOSER_ACTION_SAVE,
2603                                                     folder_uri);
2604                 g_free (folder_uri);
2605                 g_object_unref (parent);
2606         }
2607
2608         /* FIXME: remote copy should be done here rather than in the save job,
2609          * so that we can track progress and cancel the operation
2610          */
2611
2612         ev_window_clear_save_job (ev_window);
2613         ev_window->priv->save_job = ev_job_save_new (ev_window->priv->document,
2614                                                      uri, ev_window->priv->uri);
2615         g_signal_connect (ev_window->priv->save_job, "finished",
2616                           G_CALLBACK (ev_window_save_job_cb),
2617                           ev_window);
2618         /* The priority doesn't matter for this job */
2619         ev_job_scheduler_push_job (ev_window->priv->save_job, EV_JOB_PRIORITY_NONE);
2620
2621         g_free (uri);
2622         gtk_widget_destroy (fc);
2623 }
2624
2625 static void
2626 ev_window_cmd_save_as (GtkAction *action, EvWindow *ev_window)
2627 {
2628         GtkWidget *fc;
2629         gchar *base_name;
2630         GFile *file;
2631         const gchar *default_uri;
2632
2633         fc = gtk_file_chooser_dialog_new (
2634                 _("Save a Copy"),
2635                 GTK_WINDOW (ev_window), GTK_FILE_CHOOSER_ACTION_SAVE,
2636                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
2637                 GTK_STOCK_SAVE, GTK_RESPONSE_OK,
2638                 NULL);
2639
2640         ev_document_factory_add_filters (fc, ev_window->priv->document);
2641         gtk_dialog_set_default_response (GTK_DIALOG (fc), GTK_RESPONSE_OK);
2642         gtk_dialog_set_alternative_button_order (GTK_DIALOG (fc),
2643                                                 GTK_RESPONSE_OK,
2644                                                 GTK_RESPONSE_CANCEL,
2645                                                 -1);
2646
2647         gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (fc), FALSE);
2648         gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (fc), TRUE);
2649         file = g_file_new_for_uri (ev_window->priv->uri);
2650         base_name = g_file_get_basename (file);
2651         gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (fc), base_name);
2652
2653         default_uri = ev_application_get_filechooser_uri (EV_APP, GTK_FILE_CHOOSER_ACTION_SAVE);
2654         if (default_uri) {
2655                 gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (fc), default_uri);
2656         } else {
2657                 const gchar *folder;
2658
2659                 folder = g_get_user_special_dir (G_USER_DIRECTORY_DOCUMENTS);
2660                 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (fc),
2661                                                      folder ? folder : g_get_home_dir ());
2662         }
2663
2664         g_object_unref (file);
2665         g_free (base_name);
2666
2667         g_signal_connect (fc, "response",
2668                           G_CALLBACK (file_save_dialog_response_cb),
2669                           ev_window);
2670
2671         gtk_widget_show (fc);
2672 }
2673
2674 static GKeyFile *
2675 get_print_settings_file (void)
2676 {
2677         GKeyFile *print_settings_file;
2678         gchar    *filename;
2679         GError *error = NULL;
2680
2681         print_settings_file = g_key_file_new ();
2682
2683         filename = g_build_filename (ev_application_get_dot_dir (EV_APP, FALSE),
2684                                      EV_PRINT_SETTINGS_FILE, NULL);
2685         if (!g_key_file_load_from_file (print_settings_file,
2686                                         filename,
2687                                         G_KEY_FILE_KEEP_COMMENTS |
2688                                         G_KEY_FILE_KEEP_TRANSLATIONS,
2689                                         &error)) {
2690
2691                 /* Don't warn if the file simply doesn't exist */
2692                 if (!g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NOENT))
2693                         g_warning ("%s", error->message);
2694
2695                 g_error_free (error);
2696         }
2697
2698         g_free (filename);
2699
2700         return print_settings_file;
2701 }
2702
2703 static void
2704 save_print_setting_file (GKeyFile *key_file)
2705 {
2706         gchar  *filename;
2707         gchar  *data;
2708         gsize  data_length;
2709         GError *error = NULL;
2710
2711         filename = g_build_filename (ev_application_get_dot_dir (EV_APP, TRUE),
2712                                      EV_PRINT_SETTINGS_FILE, NULL);
2713         data = g_key_file_to_data (key_file, &data_length, NULL);
2714         g_file_set_contents (filename, data, data_length, &error);
2715         if (error) {
2716                 g_warning ("Failed to save print settings: %s", error->message);
2717                 g_error_free (error);
2718         }
2719         g_free (data);
2720         g_free (filename);
2721 }
2722
2723 static void
2724 ev_window_save_print_settings (EvWindow         *window,
2725                                GtkPrintSettings *print_settings)
2726 {
2727         GKeyFile *key_file;
2728         gint      i;
2729
2730         key_file = get_print_settings_file ();
2731         gtk_print_settings_to_key_file (print_settings, key_file, EV_PRINT_SETTINGS_GROUP);
2732         save_print_setting_file (key_file);
2733         g_key_file_free (key_file);
2734
2735         if (!window->priv->metadata)
2736                 return;
2737
2738         /* Save print settings that are specific to the document */
2739         for (i = 0; i < G_N_ELEMENTS (document_print_settings); i++) {
2740                 const gchar *value;
2741
2742                 value = gtk_print_settings_get (print_settings,
2743                                                 document_print_settings[i]);
2744                 ev_metadata_set_string (window->priv->metadata,
2745                                         document_print_settings[i], value);
2746         }
2747 }
2748
2749 static void
2750 ev_window_save_print_page_setup (EvWindow     *window,
2751                                  GtkPageSetup *page_setup)
2752 {
2753         GKeyFile *key_file;
2754
2755         key_file = get_print_settings_file ();
2756         gtk_page_setup_to_key_file (page_setup, key_file, EV_PAGE_SETUP_GROUP);
2757         save_print_setting_file (key_file);
2758         g_key_file_free (key_file);
2759
2760         if (!window->priv->metadata)
2761                 return;
2762
2763         /* Save page setup options that are specific to the document */
2764         ev_metadata_set_int (window->priv->metadata, "page-setup-orientation",
2765                              gtk_page_setup_get_orientation (page_setup));
2766         ev_metadata_set_double (window->priv->metadata, "page-setup-margin-top",
2767                                 gtk_page_setup_get_top_margin (page_setup, GTK_UNIT_MM));
2768         ev_metadata_set_double (window->priv->metadata, "page-setup-margin-bottom",
2769                                 gtk_page_setup_get_bottom_margin (page_setup, GTK_UNIT_MM));
2770         ev_metadata_set_double (window->priv->metadata, "page-setup-margin-left",
2771                                 gtk_page_setup_get_left_margin (page_setup, GTK_UNIT_MM));
2772         ev_metadata_set_double (window->priv->metadata, "page-setup-margin-right",
2773                                 gtk_page_setup_get_right_margin (page_setup, GTK_UNIT_MM));
2774 }
2775
2776 static void
2777 ev_window_load_print_settings_from_metadata (EvWindow         *window,
2778                                              GtkPrintSettings *print_settings)
2779 {
2780         gint i;
2781
2782         if (!window->priv->metadata)
2783                 return;
2784
2785         /* Load print setting that are specific to the document */
2786         for (i = 0; i < G_N_ELEMENTS (document_print_settings); i++) {
2787                 gchar *value = NULL;
2788
2789                 ev_metadata_get_string (window->priv->metadata,
2790                                         document_print_settings[i], &value);
2791                 gtk_print_settings_set (print_settings,
2792                                         document_print_settings[i], value);
2793         }
2794 }
2795
2796 static void
2797 ev_window_load_print_page_setup_from_metadata (EvWindow     *window,
2798                                                GtkPageSetup *page_setup)
2799 {
2800         gint          int_value;
2801         gdouble       double_value;
2802         GtkPaperSize *paper_size = gtk_page_setup_get_paper_size (page_setup);
2803
2804         /* Load page setup options that are specific to the document */
2805         if (window->priv->metadata &&
2806             ev_metadata_get_int (window->priv->metadata, "page-setup-orientation", &int_value)) {
2807                 gtk_page_setup_set_orientation (page_setup, int_value);
2808         } else {
2809                 gtk_page_setup_set_orientation (page_setup, GTK_PAGE_ORIENTATION_PORTRAIT);
2810         }
2811
2812         if (window->priv->metadata &&
2813             ev_metadata_get_double (window->priv->metadata, "page-setup-margin-top", &double_value)) {
2814                 gtk_page_setup_set_top_margin (page_setup, double_value, GTK_UNIT_MM);
2815         } else {
2816                 gtk_page_setup_set_top_margin (page_setup,
2817                                                gtk_paper_size_get_default_top_margin (paper_size, GTK_UNIT_MM),
2818                                                GTK_UNIT_MM);
2819         }
2820
2821         if (window->priv->metadata &&
2822             ev_metadata_get_double (window->priv->metadata, "page-setup-margin-bottom", &double_value)) {
2823                 gtk_page_setup_set_bottom_margin (page_setup, double_value, GTK_UNIT_MM);
2824         } else {
2825                 gtk_page_setup_set_bottom_margin (page_setup,
2826                                                   gtk_paper_size_get_default_bottom_margin (paper_size, GTK_UNIT_MM),
2827                                                   GTK_UNIT_MM);
2828         }
2829
2830         if (window->priv->metadata &&
2831             ev_metadata_get_double (window->priv->metadata, "page-setup-margin-left", &double_value)) {
2832                 gtk_page_setup_set_left_margin (page_setup, double_value, GTK_UNIT_MM);
2833         } else {
2834                 gtk_page_setup_set_left_margin (page_setup,
2835                                                 gtk_paper_size_get_default_left_margin (paper_size, GTK_UNIT_MM),
2836                                                 GTK_UNIT_MM);
2837         }
2838
2839         if (window->priv->metadata &&
2840             ev_metadata_get_double (window->priv->metadata, "page-setup-margin-right", &double_value)) {
2841                 gtk_page_setup_set_right_margin (page_setup, double_value, GTK_UNIT_MM);
2842         } else {
2843                 gtk_page_setup_set_right_margin (page_setup,
2844                                                  gtk_paper_size_get_default_right_margin (paper_size, GTK_UNIT_MM),
2845                                                  GTK_UNIT_MM);
2846         }
2847 }
2848
2849 static GtkPrintSettings *
2850 get_print_settings (GKeyFile *key_file)
2851 {
2852         GtkPrintSettings *print_settings;
2853
2854         print_settings = g_key_file_has_group (key_file, EV_PRINT_SETTINGS_GROUP) ?
2855                 gtk_print_settings_new_from_key_file (key_file, EV_PRINT_SETTINGS_GROUP, NULL) :
2856                 gtk_print_settings_new ();
2857
2858         return print_settings ? print_settings : gtk_print_settings_new ();
2859 }
2860
2861 static GtkPageSetup *
2862 get_print_page_setup (GKeyFile *key_file)
2863 {
2864         GtkPageSetup *page_setup;
2865
2866         page_setup = g_key_file_has_group (key_file, EV_PAGE_SETUP_GROUP) ?
2867                 gtk_page_setup_new_from_key_file (key_file, EV_PAGE_SETUP_GROUP, NULL) :
2868                 gtk_page_setup_new ();
2869
2870         return page_setup ? page_setup : gtk_page_setup_new ();
2871 }
2872
2873 static void
2874 ev_window_print_page_setup_done_cb (GtkPageSetup *page_setup,
2875                                     EvWindow     *window)
2876 {
2877         /* Dialog was canceled */
2878         if (!page_setup)
2879                 return;
2880
2881         ev_window_save_print_page_setup (window, page_setup);
2882 }
2883
2884 static void
2885 ev_window_cmd_file_print_setup (GtkAction *action,
2886                                 EvWindow  *ev_window)
2887 {
2888         GKeyFile         *print_settings_file;
2889         GtkPrintSettings *print_settings;
2890         GtkPageSetup     *print_page_setup;
2891
2892         print_settings_file = get_print_settings_file ();
2893
2894         print_settings = get_print_settings (print_settings_file);
2895         ev_window_load_print_settings_from_metadata (ev_window, print_settings);
2896
2897         print_page_setup = get_print_page_setup (print_settings_file);
2898         ev_window_load_print_page_setup_from_metadata (ev_window, print_page_setup);
2899
2900         gtk_print_run_page_setup_dialog_async (GTK_WINDOW (ev_window),
2901                                                print_page_setup,
2902                                                print_settings,
2903                                                (GtkPageSetupDoneFunc)ev_window_print_page_setup_done_cb,
2904                                                ev_window);
2905         g_object_unref (print_settings);
2906         g_object_unref (print_page_setup);
2907         g_key_file_free (print_settings_file);
2908 }
2909
2910 static void
2911 ev_window_print_cancel (EvWindow *ev_window)
2912 {
2913         EvPrintOperation *op;
2914
2915         if (!ev_window->priv->print_queue)
2916                 return;
2917
2918         while ((op = g_queue_peek_tail (ev_window->priv->print_queue))) {
2919                 ev_print_operation_cancel (op);
2920         }
2921 }
2922
2923 static void
2924 ev_window_print_update_pending_jobs_message (EvWindow *ev_window,
2925                                              gint      n_jobs)
2926 {
2927         gchar *text = NULL;
2928
2929         if (!EV_IS_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area) ||
2930             !ev_window->priv->print_queue)
2931                 return;
2932
2933         if (n_jobs == 0) {
2934                 ev_window_set_message_area (ev_window, NULL);
2935                 return;
2936         }
2937
2938         if (n_jobs > 1) {
2939                 text = g_strdup_printf (ngettext ("%d pending job in queue",
2940                                                   "%d pending jobs in queue",
2941                                                   n_jobs - 1), n_jobs - 1);
2942         }
2943
2944         ev_message_area_set_secondary_text (EV_MESSAGE_AREA (ev_window->priv->message_area),
2945                                             text);
2946         g_free (text);
2947 }
2948
2949 static gboolean
2950 destroy_window (GtkWidget *window)
2951 {
2952         gtk_widget_destroy (window);
2953
2954         return FALSE;
2955 }
2956
2957 static void
2958 ev_window_print_operation_done (EvPrintOperation       *op,
2959                                 GtkPrintOperationResult result,
2960                                 EvWindow               *ev_window)
2961 {
2962         gint n_jobs;
2963
2964         switch (result) {
2965         case GTK_PRINT_OPERATION_RESULT_APPLY: {
2966                 GtkPrintSettings *print_settings;
2967
2968                 print_settings = ev_print_operation_get_print_settings (op);
2969                 ev_window_save_print_settings (ev_window, print_settings);
2970
2971                 if (ev_print_operation_get_embed_page_setup (op)) {
2972                         GtkPageSetup *page_setup;
2973
2974                         page_setup = ev_print_operation_get_default_page_setup (op);
2975                         ev_window_save_print_page_setup (ev_window, page_setup);
2976                 }
2977         }
2978
2979                 break;
2980         case GTK_PRINT_OPERATION_RESULT_ERROR: {
2981                 GtkWidget *dialog;
2982                 GError    *error = NULL;
2983
2984
2985                 ev_print_operation_get_error (op, &error);
2986
2987                 /* The message area is already used by
2988                  * the printing progress, so it's better to
2989                  * use a popup dialog in this case
2990                  */
2991                 dialog = gtk_message_dialog_new (GTK_WINDOW (ev_window),
2992                                                  GTK_DIALOG_DESTROY_WITH_PARENT,
2993                                                  GTK_MESSAGE_ERROR,
2994                                                  GTK_BUTTONS_CLOSE,
2995                                                  "%s", _("Failed to print document"));
2996                 gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
2997                                                           "%s", error->message);
2998                 g_signal_connect (dialog, "response",
2999                                   G_CALLBACK (gtk_widget_destroy),
3000                                   NULL);
3001                 gtk_widget_show (dialog);
3002
3003                 g_error_free (error);
3004         }
3005                 break;
3006         case GTK_PRINT_OPERATION_RESULT_CANCEL:
3007         default:
3008                 break;
3009         }
3010
3011         g_queue_remove (ev_window->priv->print_queue, op);
3012         g_object_unref (op);
3013         n_jobs = g_queue_get_length (ev_window->priv->print_queue);
3014         ev_window_print_update_pending_jobs_message (ev_window, n_jobs);
3015
3016         if (n_jobs == 0 && ev_window->priv->close_after_print)
3017                 g_idle_add ((GSourceFunc)destroy_window,
3018                             ev_window);
3019 }
3020
3021 static void
3022 ev_window_print_progress_response_cb (EvProgressMessageArea *area,
3023                                       gint                   response,
3024                                       EvWindow              *ev_window)
3025 {
3026         if (response == GTK_RESPONSE_CANCEL) {
3027                 EvPrintOperation *op;
3028
3029                 op = g_queue_peek_tail (ev_window->priv->print_queue);
3030                 ev_print_operation_cancel (op);
3031         } else {
3032                 gtk_widget_hide (GTK_WIDGET (area));
3033         }
3034 }
3035
3036 static void
3037 ev_window_print_operation_status_changed (EvPrintOperation *op,
3038                                           EvWindow         *ev_window)
3039 {
3040         const gchar *status;
3041         gdouble      fraction;
3042
3043         status = ev_print_operation_get_status (op);
3044         fraction = ev_print_operation_get_progress (op);
3045
3046         if (!ev_window->priv->message_area) {
3047                 GtkWidget   *area;
3048                 const gchar *job_name;
3049                 gchar       *text;
3050
3051                 job_name = ev_print_operation_get_job_name (op);
3052                 text = g_strdup_printf (_("Printing job “%s”"), job_name);
3053
3054                 area = ev_progress_message_area_new (GTK_STOCK_PRINT,
3055                                                      text,
3056                                                      GTK_STOCK_CLOSE,
3057                                                      GTK_RESPONSE_CLOSE,
3058                                                      GTK_STOCK_CANCEL,
3059                                                      GTK_RESPONSE_CANCEL,
3060                                                      NULL);
3061                 ev_window_print_update_pending_jobs_message (ev_window, 1);
3062                 g_signal_connect (area, "response",
3063                                   G_CALLBACK (ev_window_print_progress_response_cb),
3064                                   ev_window);
3065                 gtk_widget_show (area);
3066                 ev_window_set_message_area (ev_window, area);
3067                 g_free (text);
3068         }
3069
3070         ev_progress_message_area_set_status (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
3071                                              status);
3072         ev_progress_message_area_set_fraction (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
3073                                                fraction);
3074 }
3075
3076 static void
3077 ev_window_print_operation_begin_print (EvPrintOperation *op,
3078                                        EvWindow         *ev_window)
3079 {
3080         if (!ev_window->priv->print_queue)
3081                 ev_window->priv->print_queue = g_queue_new ();
3082
3083         g_queue_push_head (ev_window->priv->print_queue, op);
3084         ev_window_print_update_pending_jobs_message (ev_window,
3085                                                      g_queue_get_length (ev_window->priv->print_queue));
3086 }
3087
3088 void
3089 ev_window_print_range (EvWindow *ev_window,
3090                        gint      first_page,
3091                        gint      last_page)
3092 {
3093         EvPrintOperation *op;
3094         GKeyFile         *print_settings_file;
3095         GtkPrintSettings *print_settings;
3096         GtkPageSetup     *print_page_setup;
3097         gint              current_page;
3098         gint              document_last_page;
3099
3100         g_return_if_fail (EV_IS_WINDOW (ev_window));
3101         g_return_if_fail (ev_window->priv->document != NULL);
3102
3103         if (!ev_window->priv->print_queue)
3104                 ev_window->priv->print_queue = g_queue_new ();
3105
3106         op = ev_print_operation_new (ev_window->priv->document);
3107         if (!op) {
3108                 g_warning ("%s", "Printing is not supported for document\n");
3109                 return;
3110         }
3111
3112         g_signal_connect (op, "begin_print",
3113                           G_CALLBACK (ev_window_print_operation_begin_print),
3114                           (gpointer)ev_window);
3115         g_signal_connect (op, "status_changed",
3116                           G_CALLBACK (ev_window_print_operation_status_changed),
3117                           (gpointer)ev_window);
3118         g_signal_connect (op, "done",
3119                           G_CALLBACK (ev_window_print_operation_done),
3120                           (gpointer)ev_window);
3121
3122         current_page = ev_document_model_get_page (ev_window->priv->model);
3123         document_last_page = ev_document_get_n_pages (ev_window->priv->document);
3124
3125         print_settings_file = get_print_settings_file ();
3126
3127         print_settings = get_print_settings (print_settings_file);
3128         ev_window_load_print_settings_from_metadata (ev_window, print_settings);
3129
3130         print_page_setup = get_print_page_setup (print_settings_file);
3131         ev_window_load_print_page_setup_from_metadata (ev_window, print_page_setup);
3132
3133         if (first_page != 1 || last_page != document_last_page) {
3134                 GtkPageRange range;
3135
3136                 /* Ranges in GtkPrint are 0 - N */
3137                 range.start = first_page - 1;
3138                 range.end = last_page - 1;
3139
3140                 gtk_print_settings_set_print_pages (print_settings,
3141                                                     GTK_PRINT_PAGES_RANGES);
3142                 gtk_print_settings_set_page_ranges (print_settings,
3143                                                     &range, 1);
3144         }
3145
3146         ev_print_operation_set_job_name (op, gtk_window_get_title (GTK_WINDOW (ev_window)));
3147         ev_print_operation_set_current_page (op, current_page);
3148         ev_print_operation_set_print_settings (op, print_settings);
3149         ev_print_operation_set_default_page_setup (op, print_page_setup);
3150 #ifdef WITH_GCONF
3151         ev_print_operation_set_embed_page_setup (op, !gconf_client_get_bool (ev_window->priv->gconf_client,
3152                                                                              GCONF_LOCKDOWN_PRINT_SETUP,
3153                                                                              NULL));
3154 #else
3155         ev_print_operation_set_embed_page_setup (op, TRUE);
3156 #endif
3157
3158         g_object_unref (print_settings);
3159         g_object_unref (print_page_setup);
3160         g_key_file_free (print_settings_file);
3161
3162         ev_print_operation_run (op, GTK_WINDOW (ev_window));
3163 }
3164
3165 static void
3166 ev_window_print (EvWindow *window)
3167 {
3168         ev_window_print_range (window, 1,
3169                                ev_document_get_n_pages (window->priv->document));
3170 }
3171
3172 static void
3173 ev_window_cmd_file_print (GtkAction *action, EvWindow *ev_window)
3174 {
3175         ev_window_print (ev_window);
3176 }
3177
3178 static void
3179 ev_window_cmd_file_properties (GtkAction *action, EvWindow *ev_window)
3180 {
3181         if (ev_window->priv->properties == NULL) {
3182                 ev_window->priv->properties = ev_properties_dialog_new ();
3183                 ev_properties_dialog_set_document (EV_PROPERTIES_DIALOG (ev_window->priv->properties),
3184                                                    ev_window->priv->uri,
3185                                                    ev_window->priv->document);
3186                 g_object_add_weak_pointer (G_OBJECT (ev_window->priv->properties),
3187                                            (gpointer) &(ev_window->priv->properties));
3188                 gtk_window_set_transient_for (GTK_WINDOW (ev_window->priv->properties),
3189                                               GTK_WINDOW (ev_window));
3190         }
3191
3192         ev_document_fc_mutex_lock ();
3193         gtk_widget_show (ev_window->priv->properties);
3194         ev_document_fc_mutex_unlock ();
3195 }
3196
3197 static void
3198 print_jobs_confirmation_dialog_response (GtkDialog *dialog,
3199                                          gint       response,
3200                                          EvWindow  *ev_window)
3201 {
3202         gtk_widget_destroy (GTK_WIDGET (dialog));
3203
3204         switch (response) {
3205         case GTK_RESPONSE_YES:
3206                 if (!ev_window->priv->print_queue ||
3207                     g_queue_is_empty (ev_window->priv->print_queue))
3208                         gtk_widget_destroy (GTK_WIDGET (ev_window));
3209                 else
3210                         ev_window->priv->close_after_print = TRUE;
3211                 break;
3212         case GTK_RESPONSE_NO:
3213                 ev_window->priv->close_after_print = TRUE;
3214                 if (ev_window->priv->print_queue &&
3215                     !g_queue_is_empty (ev_window->priv->print_queue)) {
3216                         gtk_widget_set_sensitive (GTK_WIDGET (ev_window), FALSE);
3217                         ev_window_print_cancel (ev_window);
3218                 } else {
3219                         gtk_widget_destroy (GTK_WIDGET (ev_window));
3220                 }
3221                 break;
3222         case GTK_RESPONSE_CANCEL:
3223         default:
3224                 ev_window->priv->close_after_print = FALSE;
3225         }
3226 }
3227
3228 static void
3229 ev_window_cmd_file_close_window (GtkAction *action, EvWindow *ev_window)
3230 {
3231         GtkWidget *dialog;
3232         gchar     *text, *markup;
3233         gint       n_print_jobs;
3234
3235         n_print_jobs = ev_window->priv->print_queue ?
3236                 g_queue_get_length (ev_window->priv->print_queue) : 0;
3237
3238         if (n_print_jobs == 0) {
3239                 gtk_widget_destroy (GTK_WIDGET (ev_window));
3240                 return;
3241         }
3242
3243         dialog = gtk_message_dialog_new (GTK_WINDOW (ev_window),
3244                                          GTK_DIALOG_MODAL,
3245                                          GTK_MESSAGE_QUESTION,
3246                                          GTK_BUTTONS_NONE,
3247                                          NULL);
3248         if (n_print_jobs == 1) {
3249                 EvPrintOperation *op;
3250                 const gchar      *job_name;
3251
3252                 op = g_queue_peek_tail (ev_window->priv->print_queue);
3253                 job_name = ev_print_operation_get_job_name (op);
3254
3255                 text = g_strdup_printf (_("Wait until print job “%s” finishes before closing?"),
3256                                         job_name);
3257         } else {
3258                 text = g_strdup_printf (_("There are %d print jobs active. "
3259                                           "Wait until print finishes before closing?"),
3260                                         n_print_jobs);
3261         }
3262
3263         markup = g_strdup_printf ("<b>%s</b>", text);
3264         g_free (text);
3265
3266         gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), markup);
3267         g_free (markup);
3268
3269         gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s",
3270                                                   _("If you close the window, pending print "
3271                                                     "jobs will not be printed."));
3272
3273         gtk_dialog_add_buttons (GTK_DIALOG (dialog),
3274                                 _("Cancel _print and Close"),
3275                                 GTK_RESPONSE_NO,
3276                                 GTK_STOCK_CANCEL,
3277                                 GTK_RESPONSE_CANCEL,
3278                                 _("Close _after Printing"),
3279                                 GTK_RESPONSE_YES,
3280                                 NULL);
3281         gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES);
3282         gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
3283                                                  GTK_RESPONSE_YES,
3284                                                  GTK_RESPONSE_NO,
3285                                                  GTK_RESPONSE_CANCEL,
3286                                                  -1);
3287
3288         g_signal_connect (dialog, "response",
3289                           G_CALLBACK (print_jobs_confirmation_dialog_response),
3290                           ev_window);
3291         gtk_widget_show (dialog);
3292 }
3293
3294 static void
3295 ev_window_cmd_focus_page_selector (GtkAction *act, EvWindow *window)
3296 {
3297         GtkAction *action;
3298
3299         update_chrome_flag (window, EV_CHROME_RAISE_TOOLBAR, TRUE);
3300         ev_window_set_action_sensitive (window, "ViewToolbar", FALSE);
3301         update_chrome_visibility (window);
3302
3303         action = gtk_action_group_get_action (window->priv->action_group,
3304                                               PAGE_SELECTOR_ACTION);
3305         ev_page_action_grab_focus (EV_PAGE_ACTION (action));
3306 }
3307
3308 static void
3309 ev_window_cmd_scroll_forward (GtkAction *action, EvWindow *window)
3310 {
3311         ev_view_scroll (EV_VIEW (window->priv->view), GTK_SCROLL_PAGE_FORWARD, FALSE);
3312 }
3313
3314 static void
3315 ev_window_cmd_scroll_backward (GtkAction *action, EvWindow *window)
3316 {
3317         ev_view_scroll (EV_VIEW (window->priv->view), GTK_SCROLL_PAGE_BACKWARD, FALSE);
3318 }
3319
3320 static void
3321 ev_window_cmd_continuous (GtkAction *action, EvWindow *ev_window)
3322 {
3323         gboolean continuous;
3324
3325         ev_window_stop_presentation (ev_window, TRUE);
3326         continuous = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
3327         ev_document_model_set_continuous (ev_window->priv->model, continuous);
3328 }
3329
3330 static void
3331 ev_window_cmd_dual (GtkAction *action, EvWindow *ev_window)
3332 {
3333         gboolean dual_page;
3334
3335         ev_window_stop_presentation (ev_window, TRUE);
3336         dual_page = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
3337         ev_document_model_set_dual_page (ev_window->priv->model, dual_page);
3338 }
3339
3340 static void
3341 ev_window_cmd_view_best_fit (GtkAction *action, EvWindow *ev_window)
3342 {
3343         ev_window_stop_presentation (ev_window, TRUE);
3344
3345         if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action))) {
3346                 ev_document_model_set_sizing_mode (ev_window->priv->model, EV_SIZING_BEST_FIT);
3347         } else {
3348                 ev_document_model_set_sizing_mode (ev_window->priv->model, EV_SIZING_FREE);
3349         }
3350         ev_window_update_actions (ev_window);
3351 }
3352
3353 static void
3354 ev_window_cmd_view_page_width (GtkAction *action, EvWindow *ev_window)
3355 {
3356         ev_window_stop_presentation (ev_window, TRUE);
3357
3358         if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action))) {
3359                 ev_document_model_set_sizing_mode (ev_window->priv->model, EV_SIZING_FIT_WIDTH);
3360         } else {
3361                 ev_document_model_set_sizing_mode (ev_window->priv->model, EV_SIZING_FREE);
3362         }
3363         ev_window_update_actions (ev_window);
3364 }
3365
3366
3367 static void
3368 ev_window_cmd_edit_select_all (GtkAction *action, EvWindow *ev_window)
3369 {
3370         g_return_if_fail (EV_IS_WINDOW (ev_window));
3371
3372         ev_view_select_all (EV_VIEW (ev_window->priv->view));
3373 }
3374
3375 static void
3376 ev_window_cmd_edit_find (GtkAction *action, EvWindow *ev_window)
3377 {
3378         g_return_if_fail (EV_IS_WINDOW (ev_window));
3379
3380         if (ev_window->priv->document == NULL || !EV_IS_DOCUMENT_FIND (ev_window->priv->document)) {
3381                 g_error ("Find action should be insensitive since document doesn't support find");
3382                 return;
3383         }
3384
3385         update_chrome_flag (ev_window, EV_CHROME_FINDBAR, TRUE);
3386         update_chrome_visibility (ev_window);
3387         gtk_widget_grab_focus (ev_window->priv->find_bar);
3388 }
3389
3390 static void
3391 ev_window_cmd_edit_find_next (GtkAction *action, EvWindow *ev_window)
3392 {
3393         g_return_if_fail (EV_IS_WINDOW (ev_window));
3394
3395         update_chrome_flag (ev_window, EV_CHROME_FINDBAR, TRUE);
3396         update_chrome_visibility (ev_window);
3397         gtk_widget_grab_focus (ev_window->priv->find_bar);
3398         ev_view_find_next (EV_VIEW (ev_window->priv->view));
3399 }
3400
3401 static void
3402 ev_window_cmd_edit_find_previous (GtkAction *action, EvWindow *ev_window)
3403 {
3404         g_return_if_fail (EV_IS_WINDOW (ev_window));
3405
3406         update_chrome_flag (ev_window, EV_CHROME_FINDBAR, TRUE);
3407         update_chrome_visibility (ev_window);
3408         gtk_widget_grab_focus (ev_window->priv->find_bar);
3409         ev_view_find_previous (EV_VIEW (ev_window->priv->view));
3410 }
3411
3412 static void
3413 ev_window_cmd_edit_copy (GtkAction *action, EvWindow *ev_window)
3414 {
3415         g_return_if_fail (EV_IS_WINDOW (ev_window));
3416
3417         ev_view_copy (EV_VIEW (ev_window->priv->view));
3418 }
3419
3420 static void
3421 ev_window_sidebar_position_change_cb (GObject    *object,
3422                                       GParamSpec *pspec,
3423                                       EvWindow   *ev_window)
3424 {
3425         if (ev_window->priv->metadata && !ev_window_is_empty (ev_window))
3426                 ev_metadata_set_int (ev_window->priv->metadata, "sidebar_size",
3427                                      gtk_paned_get_position (GTK_PANED (object)));
3428 }
3429
3430 static void
3431 ev_window_update_fullscreen_action (EvWindow *window)
3432 {
3433         GtkAction *action;
3434
3435         action = gtk_action_group_get_action (window->priv->action_group, "ViewFullscreen");
3436         g_signal_handlers_block_by_func
3437                 (action, G_CALLBACK (ev_window_cmd_view_fullscreen), window);
3438         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
3439                                       ev_document_model_get_fullscreen (window->priv->model));
3440         g_signal_handlers_unblock_by_func
3441                 (action, G_CALLBACK (ev_window_cmd_view_fullscreen), window);
3442 }
3443
3444 static void
3445 fullscreen_toolbar_setup_item_properties (GtkUIManager *ui_manager)
3446 {
3447         GtkWidget *item;
3448
3449         item = gtk_ui_manager_get_widget (ui_manager, "/FullscreenToolbar/GoPreviousPage");
3450         g_object_set (item, "is-important", FALSE, NULL);
3451
3452         item = gtk_ui_manager_get_widget (ui_manager, "/FullscreenToolbar/GoNextPage");
3453         g_object_set (item, "is-important", FALSE, NULL);
3454
3455         item = gtk_ui_manager_get_widget (ui_manager, "/FullscreenToolbar/StartPresentation");
3456         g_object_set (item, "is-important", TRUE, NULL);
3457
3458         item = gtk_ui_manager_get_widget (ui_manager, "/FullscreenToolbar/LeaveFullscreen");
3459         g_object_set (item, "is-important", TRUE, NULL);
3460 }
3461
3462 static void
3463 fullscreen_toolbar_remove_shadow (GtkWidget *toolbar)
3464 {
3465         static gboolean done = FALSE;
3466
3467         if (!done) {
3468                 gtk_rc_parse_string (
3469                         "\n"
3470                         "   style \"fullscreen-toolbar-style\"\n"
3471                         "   {\n"
3472                         "      GtkToolbar::shadow-type=GTK_SHADOW_NONE\n"
3473                         "   }\n"
3474                         "\n"
3475                         "    widget \"*.fullscreen-toolbar\" style \"fullscreen-toolbar-style\"\n"
3476                         "\n");
3477                 done = TRUE;
3478         }
3479
3480         gtk_widget_set_name (toolbar, "fullscreen-toolbar");
3481 }
3482
3483 static void
3484 ev_window_run_fullscreen (EvWindow *window)
3485 {
3486         gboolean fullscreen_window = TRUE;
3487
3488         if (ev_document_model_get_fullscreen (window->priv->model))
3489                 return;
3490
3491         if (!window->priv->fullscreen_toolbar) {
3492                 window->priv->fullscreen_toolbar =
3493                         gtk_ui_manager_get_widget (window->priv->ui_manager,
3494                                                    "/FullscreenToolbar");
3495
3496                 gtk_toolbar_set_style (GTK_TOOLBAR (window->priv->fullscreen_toolbar),
3497                                        GTK_TOOLBAR_BOTH_HORIZ);
3498                 fullscreen_toolbar_remove_shadow (window->priv->fullscreen_toolbar);
3499                 fullscreen_toolbar_setup_item_properties (window->priv->ui_manager);
3500
3501                 gtk_box_pack_start (GTK_BOX (window->priv->main_box),
3502                                     window->priv->fullscreen_toolbar,
3503                                     FALSE, FALSE, 0);
3504                 gtk_box_reorder_child (GTK_BOX (window->priv->main_box),
3505                                        window->priv->fullscreen_toolbar, 1);
3506         }
3507
3508         if (EV_WINDOW_IS_PRESENTATION (window)) {
3509                 ev_window_stop_presentation (window, FALSE);
3510                 fullscreen_window = FALSE;
3511         }
3512
3513         g_object_set (G_OBJECT (window->priv->scrolled_window),
3514                       "shadow-type", GTK_SHADOW_NONE,
3515                       NULL);
3516
3517         ev_document_model_set_fullscreen (window->priv->model, TRUE);
3518         ev_window_update_fullscreen_action (window);
3519
3520         /* If the user doesn't have the main toolbar he/she won't probably want
3521          * the toolbar in fullscreen mode. See bug #483048
3522          */
3523         update_chrome_flag (window, EV_CHROME_FULLSCREEN_TOOLBAR,
3524                             (window->priv->chrome & EV_CHROME_TOOLBAR) != 0);
3525         update_chrome_visibility (window);
3526
3527         if (fullscreen_window)
3528                 gtk_window_fullscreen (GTK_WINDOW (window));
3529         gtk_widget_grab_focus (window->priv->view);
3530
3531         if (window->priv->metadata && !ev_window_is_empty (window))
3532                 ev_metadata_set_boolean (window->priv->metadata, "fullscreen", TRUE);
3533 }
3534
3535 static void
3536 ev_window_stop_fullscreen (EvWindow *window,
3537                            gboolean  unfullscreen_window)
3538 {
3539         if (!ev_document_model_get_fullscreen (window->priv->model))
3540                 return;
3541
3542         g_object_set (G_OBJECT (window->priv->scrolled_window),
3543                       "shadow-type", GTK_SHADOW_IN,
3544                       NULL);
3545
3546         ev_document_model_set_fullscreen (window->priv->model, FALSE);
3547         ev_window_update_fullscreen_action (window);
3548         update_chrome_flag (window, EV_CHROME_FULLSCREEN_TOOLBAR, FALSE);
3549         update_chrome_visibility (window);
3550         if (unfullscreen_window)
3551                 gtk_window_unfullscreen (GTK_WINDOW (window));
3552
3553         if (window->priv->metadata && !ev_window_is_empty (window))
3554                 ev_metadata_set_boolean (window->priv->metadata, "fullscreen", FALSE);
3555 }
3556
3557 static void
3558 ev_window_cmd_view_fullscreen (GtkAction *action, EvWindow *window)
3559 {
3560         gboolean fullscreen;
3561
3562         fullscreen = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
3563         if (fullscreen) {
3564                 ev_window_run_fullscreen (window);
3565         } else {
3566                 ev_window_stop_fullscreen (window, TRUE);
3567         }
3568 }
3569
3570 static void
3571 ev_window_update_presentation_action (EvWindow *window)
3572 {
3573         GtkAction *action;
3574
3575         action = gtk_action_group_get_action (window->priv->action_group, "ViewPresentation");
3576         g_signal_handlers_block_by_func
3577                 (action, G_CALLBACK (ev_window_cmd_view_presentation), window);
3578         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
3579                                       EV_WINDOW_IS_PRESENTATION (window));
3580         g_signal_handlers_unblock_by_func
3581                 (action, G_CALLBACK (ev_window_cmd_view_presentation), window);
3582 }
3583
3584 static void
3585 ev_window_view_presentation_finished (EvWindow *window)
3586 {
3587         ev_window_stop_presentation (window, TRUE);
3588 }
3589
3590 static void
3591 ev_window_run_presentation (EvWindow *window)
3592 {
3593         gboolean fullscreen_window = TRUE;
3594         guint    current_page;
3595         guint    rotation;
3596
3597         if (EV_WINDOW_IS_PRESENTATION (window))
3598                 return;
3599
3600         if (ev_document_model_get_fullscreen (window->priv->model)) {
3601                 ev_window_stop_fullscreen (window, FALSE);
3602                 fullscreen_window = FALSE;
3603         }
3604
3605         current_page = ev_document_model_get_page (window->priv->model);
3606         rotation = ev_document_model_get_rotation (window->priv->model);
3607         window->priv->presentation_view =
3608                 ev_view_presentation_new (window->priv->document, current_page, rotation);
3609         g_signal_connect_swapped (window->priv->presentation_view, "finished",
3610                                   G_CALLBACK (ev_window_view_presentation_finished),
3611                                   window);
3612
3613         gtk_box_pack_start (GTK_BOX (window->priv->main_box),
3614                             window->priv->presentation_view,
3615                             FALSE, FALSE, 0);
3616         gtk_widget_show (window->priv->presentation_view);
3617
3618         ev_window_update_presentation_action (window);
3619         update_chrome_visibility (window);
3620
3621         gtk_widget_grab_focus (window->priv->presentation_view);
3622         if (fullscreen_window)
3623                 gtk_window_fullscreen (GTK_WINDOW (window));
3624
3625         ev_application_screensaver_disable (EV_APP);
3626
3627         if (window->priv->metadata && !ev_window_is_empty (window))
3628                 ev_metadata_set_boolean (window->priv->metadata, "presentation", TRUE);
3629 }
3630
3631 static void
3632 ev_window_stop_presentation (EvWindow *window,
3633                              gboolean  unfullscreen_window)
3634 {
3635         guint current_page;
3636
3637         if (!EV_WINDOW_IS_PRESENTATION (window))
3638                 return;
3639
3640         current_page = ev_view_presentation_get_current_page (EV_VIEW_PRESENTATION (window->priv->presentation_view));
3641         ev_document_model_set_page (window->priv->model, current_page);
3642
3643         gtk_container_remove (GTK_CONTAINER (window->priv->main_box),
3644                               window->priv->presentation_view);
3645         window->priv->presentation_view = NULL;
3646
3647         ev_window_update_presentation_action (window);
3648         update_chrome_visibility (window);
3649         if (unfullscreen_window)
3650                 gtk_window_unfullscreen (GTK_WINDOW (window));
3651
3652         gtk_widget_grab_focus (window->priv->view);
3653
3654         ev_application_screensaver_enable (EV_APP);
3655
3656         if (window->priv->metadata && !ev_window_is_empty (window))
3657                 ev_metadata_set_boolean (window->priv->metadata, "presentation", FALSE);
3658 }
3659
3660 static void
3661 ev_window_cmd_view_presentation (GtkAction *action, EvWindow *window)
3662 {
3663         gboolean presentation;
3664
3665         presentation = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
3666         if (presentation) {
3667                 ev_window_run_presentation (window);
3668         }
3669 }
3670
3671 static void
3672 ev_window_setup_gtk_settings (EvWindow *window)
3673 {
3674         GtkSettings *settings;
3675         GdkScreen   *screen;
3676         gchar       *menubar_accel_accel;
3677
3678         screen = gtk_window_get_screen (GTK_WINDOW (window));
3679         settings = gtk_settings_get_for_screen (screen);
3680
3681         g_object_get (settings,
3682                       "gtk-menu-bar-accel", &menubar_accel_accel,
3683                       NULL);
3684         if (menubar_accel_accel != NULL && menubar_accel_accel[0] != '\0') {
3685                 gtk_accelerator_parse (menubar_accel_accel,
3686                                        &window->priv->menubar_accel_keyval,
3687                                        &window->priv->menubar_accel_modifier);
3688                 if (window->priv->menubar_accel_keyval == 0) {
3689                         g_warning ("Failed to parse menu bar accelerator '%s'\n",
3690                                    menubar_accel_accel);
3691                 }
3692         } else {
3693                 window->priv->menubar_accel_keyval = 0;
3694                 window->priv->menubar_accel_modifier = 0;
3695         }
3696
3697         g_free (menubar_accel_accel);
3698 }
3699
3700 static void
3701 ev_window_screen_changed (GtkWidget *widget,
3702                           GdkScreen *old_screen)
3703 {
3704         EvWindow *window = EV_WINDOW (widget);
3705         EvWindowPrivate *priv = window->priv;
3706         GdkScreen *screen;
3707         gdouble dpi;
3708
3709         screen = gtk_widget_get_screen (widget);
3710         if (screen == old_screen)
3711                 return;
3712
3713         ev_window_setup_gtk_settings (window);
3714         dpi = get_screen_dpi (GTK_WINDOW (window));
3715         ev_document_model_set_min_scale (priv->model, MIN_SCALE * dpi / 72.0);
3716         ev_document_model_set_max_scale (priv->model, MAX_SCALE * dpi / 72.0);
3717
3718         if (GTK_WIDGET_CLASS (ev_window_parent_class)->screen_changed) {
3719                 GTK_WIDGET_CLASS (ev_window_parent_class)->screen_changed (widget, old_screen);
3720         }
3721 }
3722
3723 static gboolean
3724 ev_window_state_event (GtkWidget           *widget,
3725                        GdkEventWindowState *event)
3726 {
3727         EvWindow *window = EV_WINDOW (widget);
3728
3729         if (GTK_WIDGET_CLASS (ev_window_parent_class)->window_state_event) {
3730                 GTK_WIDGET_CLASS (ev_window_parent_class)->window_state_event (widget, event);
3731         }
3732
3733         if ((event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) == 0)
3734                 return FALSE;
3735
3736         if (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) {
3737                 if (ev_document_model_get_fullscreen (window->priv->model) || EV_WINDOW_IS_PRESENTATION (window))
3738                         return FALSE;
3739
3740                 ev_window_run_fullscreen (window);
3741         } else {
3742                 if (ev_document_model_get_fullscreen (window->priv->model))
3743                         ev_window_stop_fullscreen (window, FALSE);
3744                 else if (EV_WINDOW_IS_PRESENTATION (window))
3745                         ev_window_stop_presentation (window, FALSE);
3746         }
3747
3748         return FALSE;
3749 }
3750
3751 static void
3752 ev_window_set_page_mode (EvWindow         *window,
3753                          EvWindowPageMode  page_mode)
3754 {
3755         GtkWidget *child = NULL;
3756         GtkWidget *real_child;
3757
3758         if (window->priv->page_mode == page_mode)
3759                 return;
3760
3761         window->priv->page_mode = page_mode;
3762
3763         switch (page_mode) {
3764                 case PAGE_MODE_DOCUMENT:
3765                         child = window->priv->view;
3766                         break;
3767                 case PAGE_MODE_PASSWORD:
3768                         child = window->priv->password_view;
3769                         break;
3770                 default:
3771                         g_assert_not_reached ();
3772         }
3773
3774         real_child = gtk_bin_get_child (GTK_BIN (window->priv->scrolled_window));
3775         if (child != real_child) {
3776                 gtk_container_remove (GTK_CONTAINER (window->priv->scrolled_window),
3777                                       real_child);
3778                 gtk_container_add (GTK_CONTAINER (window->priv->scrolled_window),
3779                                    child);
3780         }
3781         ev_window_update_actions (window);
3782 }
3783
3784
3785 static void
3786 ev_window_cmd_edit_rotate_left (GtkAction *action, EvWindow *ev_window)
3787 {
3788         gint rotation = ev_document_model_get_rotation (ev_window->priv->model);
3789
3790         ev_document_model_set_rotation (ev_window->priv->model, rotation - 90);
3791 }
3792
3793 static void
3794 ev_window_cmd_edit_rotate_right (GtkAction *action, EvWindow *ev_window)
3795 {
3796         gint rotation = ev_document_model_get_rotation (ev_window->priv->model);
3797
3798         ev_document_model_set_rotation (ev_window->priv->model, rotation + 90);
3799 }
3800
3801 static void
3802 ev_window_cmd_view_inverted_colors (GtkAction *action, EvWindow *ev_window)
3803 {
3804         gboolean inverted_colors = ev_document_model_get_inverted_colors (ev_window->priv->model);
3805
3806         ev_document_model_set_inverted_colors (ev_window->priv->model, !inverted_colors);
3807 }
3808
3809 static void
3810 ev_window_cmd_edit_toolbar_cb (GtkDialog *dialog,
3811                                gint       response,
3812                                EvWindow  *ev_window)
3813 {
3814         EggEditableToolbar *toolbar;
3815         gchar              *toolbars_file;
3816
3817         toolbar = EGG_EDITABLE_TOOLBAR (ev_window->priv->toolbar);
3818         egg_editable_toolbar_set_edit_mode (toolbar, FALSE);
3819
3820         toolbars_file = g_build_filename (ev_application_get_dot_dir (EV_APP, TRUE),
3821                                           "evince_toolbar.xml", NULL);
3822         egg_toolbars_model_save_toolbars (egg_editable_toolbar_get_model (toolbar),
3823                                           toolbars_file, "1.0");
3824         g_free (toolbars_file);
3825
3826         gtk_widget_destroy (GTK_WIDGET (dialog));
3827 }
3828
3829 static void
3830 ev_window_cmd_edit_toolbar (GtkAction *action, EvWindow *ev_window)
3831 {
3832         GtkWidget          *dialog;
3833         GtkWidget          *editor;
3834         EggEditableToolbar *toolbar;
3835
3836         dialog = gtk_dialog_new_with_buttons (_("Toolbar Editor"),
3837                                               GTK_WINDOW (ev_window),
3838                                               GTK_DIALOG_DESTROY_WITH_PARENT,
3839                                               GTK_STOCK_CLOSE,
3840                                               GTK_RESPONSE_CLOSE,
3841                                               NULL);
3842         gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);
3843         gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)), 5);
3844         gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 2);
3845         gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
3846         gtk_window_set_default_size (GTK_WINDOW (dialog), 500, 400);
3847
3848         toolbar = EGG_EDITABLE_TOOLBAR (ev_window->priv->toolbar);
3849         editor = egg_toolbar_editor_new (ev_window->priv->ui_manager,
3850                                          egg_editable_toolbar_get_model (toolbar));
3851
3852         gtk_container_set_border_width (GTK_CONTAINER (editor), 5);
3853         gtk_box_set_spacing (GTK_BOX (EGG_TOOLBAR_EDITOR (editor)), 5);
3854
3855         gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), editor);
3856
3857         egg_editable_toolbar_set_edit_mode (toolbar, TRUE);
3858
3859         g_signal_connect (dialog, "response",
3860                           G_CALLBACK (ev_window_cmd_edit_toolbar_cb),
3861                           ev_window);
3862         gtk_widget_show_all (dialog);
3863 }
3864
3865 static void
3866 ev_window_cmd_view_zoom_in (GtkAction *action, EvWindow *ev_window)
3867 {
3868         g_return_if_fail (EV_IS_WINDOW (ev_window));
3869
3870         ev_document_model_set_sizing_mode (ev_window->priv->model, EV_SIZING_FREE);
3871         ev_view_zoom_in (EV_VIEW (ev_window->priv->view));
3872 }
3873
3874 static void
3875 ev_window_cmd_view_zoom_out (GtkAction *action, EvWindow *ev_window)
3876 {
3877         g_return_if_fail (EV_IS_WINDOW (ev_window));
3878
3879         ev_document_model_set_sizing_mode (ev_window->priv->model, EV_SIZING_FREE);
3880         ev_view_zoom_out (EV_VIEW (ev_window->priv->view));
3881 }
3882
3883 static void
3884 ev_window_cmd_go_previous_page (GtkAction *action, EvWindow *ev_window)
3885 {
3886         g_return_if_fail (EV_IS_WINDOW (ev_window));
3887
3888         ev_view_previous_page (EV_VIEW (ev_window->priv->view));
3889 }
3890
3891 static void
3892 ev_window_cmd_go_next_page (GtkAction *action, EvWindow *ev_window)
3893 {
3894         g_return_if_fail (EV_IS_WINDOW (ev_window));
3895
3896         ev_view_next_page (EV_VIEW (ev_window->priv->view));
3897 }
3898
3899 static void
3900 ev_window_cmd_go_first_page (GtkAction *action, EvWindow *ev_window)
3901 {
3902         g_return_if_fail (EV_IS_WINDOW (ev_window));
3903
3904         ev_document_model_set_page (ev_window->priv->model, 0);
3905 }
3906
3907 static void
3908 ev_window_cmd_go_last_page (GtkAction *action, EvWindow *ev_window)
3909 {
3910         g_return_if_fail (EV_IS_WINDOW (ev_window));
3911
3912         ev_document_model_set_page (ev_window->priv->model,
3913                                     ev_document_get_n_pages (ev_window->priv->document) - 1);
3914 }
3915
3916 static void
3917 ev_window_cmd_go_forward (GtkAction *action, EvWindow *ev_window)
3918 {
3919         int n_pages, current_page;
3920
3921         g_return_if_fail (EV_IS_WINDOW (ev_window));
3922
3923         n_pages = ev_document_get_n_pages (ev_window->priv->document);
3924         current_page = ev_document_model_get_page (ev_window->priv->model);
3925
3926         if (current_page + 10 < n_pages) {
3927                 ev_document_model_set_page (ev_window->priv->model, current_page + 10);
3928         }
3929 }
3930
3931 static void
3932 ev_window_cmd_go_backward (GtkAction *action, EvWindow *ev_window)
3933 {
3934         int current_page;
3935
3936         g_return_if_fail (EV_IS_WINDOW (ev_window));
3937
3938         current_page = ev_document_model_get_page (ev_window->priv->model);
3939
3940         if (current_page - 10 >= 0) {
3941                 ev_document_model_set_page (ev_window->priv->model, current_page - 10);
3942         }
3943 }
3944
3945 static void
3946 ev_window_cmd_view_reload (GtkAction *action, EvWindow *ev_window)
3947 {
3948         ev_window_reload_document (ev_window, NULL);
3949 }
3950
3951 static void
3952 ev_window_cmd_view_autoscroll (GtkAction *action, EvWindow *ev_window)
3953 {
3954         ev_view_autoscroll_start (EV_VIEW (ev_window->priv->view));
3955 }
3956
3957 static void
3958 ev_window_cmd_help_contents (GtkAction *action, EvWindow *ev_window)
3959 {
3960         GError  *error = NULL;
3961
3962         gtk_show_uri (gtk_window_get_screen (GTK_WINDOW (ev_window)),
3963                       "ghelp:evince",
3964                       gtk_get_current_event_time (),
3965                       &error);
3966         if (error) {
3967                 ev_window_error_message (ev_window, error,
3968                                          "%s", _("There was an error displaying help"));
3969                 g_error_free (error);
3970         }
3971 }
3972
3973 static void
3974 ev_window_cmd_leave_fullscreen (GtkAction *action, EvWindow *window)
3975 {
3976         ev_window_stop_fullscreen (window, TRUE);
3977 }
3978
3979 static void
3980 ev_window_cmd_start_presentation (GtkAction *action, EvWindow *window)
3981 {
3982         ev_window_run_presentation (window);
3983 }
3984
3985 static void
3986 ev_window_cmd_escape (GtkAction *action, EvWindow *window)
3987 {
3988         GtkWidget *widget;
3989
3990         ev_view_autoscroll_stop (EV_VIEW (window->priv->view));
3991
3992         widget = gtk_window_get_focus (GTK_WINDOW (window));
3993         if (widget && gtk_widget_get_ancestor (widget, EGG_TYPE_FIND_BAR)) {
3994                 update_chrome_flag (window, EV_CHROME_FINDBAR, FALSE);
3995                 update_chrome_visibility (window);
3996                 gtk_widget_grab_focus (window->priv->view);
3997         } else {
3998                 gboolean fullscreen;
3999
4000                 fullscreen = ev_document_model_get_fullscreen (window->priv->model);
4001
4002                 if (fullscreen) {
4003                         ev_window_stop_fullscreen (window, TRUE);
4004                 } else if (EV_WINDOW_IS_PRESENTATION (window)) {
4005                         ev_window_stop_presentation (window, TRUE);
4006                         gtk_widget_grab_focus (window->priv->view);
4007                 } else {
4008                         gtk_widget_grab_focus (window->priv->view);
4009                 }
4010
4011                 if (fullscreen && EV_WINDOW_IS_PRESENTATION (window))
4012                         g_warning ("Both fullscreen and presentation set somehow");
4013         }
4014 }
4015
4016 static void
4017 save_sizing_mode (EvWindow *window)
4018 {
4019         EvSizingMode mode;
4020         GEnumValue *enum_value;
4021
4022         if (!window->priv->metadata || ev_window_is_empty (window))
4023                 return;
4024
4025         mode = ev_document_model_get_sizing_mode (window->priv->model);
4026         enum_value = g_enum_get_value (g_type_class_peek (EV_TYPE_SIZING_MODE), mode);
4027         ev_metadata_set_string (window->priv->metadata, "sizing_mode",
4028                                 enum_value->value_nick);
4029 }
4030
4031 static void
4032 ev_window_document_changed_cb (EvDocumentModel *model,
4033                                GParamSpec      *pspec,
4034                                EvWindow        *ev_window)
4035 {
4036         ev_window_set_document (ev_window,
4037                                 ev_document_model_get_document (model));
4038 }
4039
4040 static void
4041 ev_window_sizing_mode_changed_cb (EvDocumentModel *model,
4042                                   GParamSpec      *pspec,
4043                                   EvWindow        *ev_window)
4044 {
4045         EvSizingMode sizing_mode = ev_document_model_get_sizing_mode (model);
4046
4047         g_object_set (ev_window->priv->scrolled_window,
4048                       "hscrollbar-policy",
4049                       sizing_mode == EV_SIZING_FREE ?
4050                       GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER,
4051                       "vscrollbar-policy", GTK_POLICY_AUTOMATIC,
4052                       NULL);
4053
4054         update_sizing_buttons (ev_window);
4055         save_sizing_mode (ev_window);
4056 }
4057
4058 static void
4059 ev_window_zoom_changed_cb (EvDocumentModel *model, GParamSpec *pspec, EvWindow *ev_window)
4060 {
4061         ev_window_update_actions (ev_window);
4062
4063         if (!ev_window->priv->metadata)
4064                 return;
4065
4066         if (ev_document_model_get_sizing_mode (model) == EV_SIZING_FREE && !ev_window_is_empty (ev_window)) {
4067                 gdouble zoom;
4068
4069                 zoom = ev_document_model_get_scale (model);
4070                 zoom *= 72.0 / get_screen_dpi (GTK_WINDOW (ev_window));
4071                 ev_metadata_set_double (ev_window->priv->metadata, "zoom", zoom);
4072         }
4073 }
4074
4075 static void
4076 ev_window_update_continuous_action (EvWindow *window)
4077 {
4078         GtkAction *action;
4079
4080         action = gtk_action_group_get_action (window->priv->action_group, "ViewContinuous");
4081         g_signal_handlers_block_by_func
4082                 (action, G_CALLBACK (ev_window_cmd_continuous), window);
4083         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
4084                                       ev_document_model_get_continuous (window->priv->model));
4085         g_signal_handlers_unblock_by_func
4086                 (action, G_CALLBACK (ev_window_cmd_continuous), window);
4087 }
4088
4089 static void
4090 ev_window_update_dual_page_action (EvWindow *window)
4091 {
4092         GtkAction *action;
4093
4094         action = gtk_action_group_get_action (window->priv->action_group, "ViewDual");
4095         g_signal_handlers_block_by_func
4096                 (action, G_CALLBACK (ev_window_cmd_dual), window);
4097         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
4098                                       ev_document_model_get_dual_page (window->priv->model));
4099         g_signal_handlers_unblock_by_func
4100                 (action, G_CALLBACK (ev_window_cmd_dual), window);
4101 }
4102
4103 static void
4104 ev_window_continuous_changed_cb (EvDocumentModel *model,
4105                                  GParamSpec      *pspec,
4106                                  EvWindow        *ev_window)
4107 {
4108         ev_window_update_continuous_action (ev_window);
4109
4110         if (ev_window->priv->metadata && !ev_window_is_empty (ev_window))
4111                 ev_metadata_set_boolean (ev_window->priv->metadata, "continuous",
4112                                          ev_document_model_get_continuous (model));
4113 }
4114
4115 static void
4116 ev_window_rotation_changed_cb (EvDocumentModel *model,
4117                                GParamSpec      *pspec,
4118                                EvWindow        *window)
4119 {
4120         gint rotation = ev_document_model_get_rotation (model);
4121
4122         if (window->priv->metadata && !ev_window_is_empty (window))
4123                 ev_metadata_set_int (window->priv->metadata, "rotation",
4124                                      rotation);
4125
4126         ev_window_refresh_window_thumbnail (window);
4127 }
4128
4129 static void
4130 ev_window_update_inverted_colors_action (EvWindow *window)
4131 {
4132         GtkAction *action;
4133
4134         action = gtk_action_group_get_action (window->priv->action_group, "ViewInvertedColors");
4135         g_signal_handlers_block_by_func
4136                 (action, G_CALLBACK (ev_window_cmd_view_inverted_colors), window);
4137         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
4138                                       ev_document_model_get_inverted_colors (window->priv->model));
4139         g_signal_handlers_unblock_by_func
4140                 (action, G_CALLBACK (ev_window_cmd_view_inverted_colors), window);
4141 }
4142
4143 static void
4144 ev_window_inverted_colors_changed_cb (EvDocumentModel *model,
4145                                       GParamSpec      *pspec,
4146                                       EvWindow        *window)
4147 {
4148         gboolean inverted_colors = ev_document_model_get_inverted_colors (model);
4149
4150         ev_window_update_inverted_colors_action (window);
4151
4152         if (window->priv->metadata && !ev_window_is_empty (window))
4153                 ev_metadata_set_boolean (window->priv->metadata, "inverted-colors",
4154                                          inverted_colors);
4155
4156         ev_window_refresh_window_thumbnail (window);
4157 }
4158
4159 static void
4160 ev_window_dual_mode_changed_cb (EvDocumentModel *model,
4161                                 GParamSpec      *pspec,
4162                                 EvWindow        *ev_window)
4163 {
4164         ev_window_update_dual_page_action (ev_window);
4165
4166         if (ev_window->priv->metadata && !ev_window_is_empty (ev_window))
4167                 ev_metadata_set_boolean (ev_window->priv->metadata, "dual-page",
4168                                          ev_document_model_get_dual_page (model));
4169 }
4170
4171 static char *
4172 build_comments_string (EvDocument *document)
4173 {
4174         gchar *comments = NULL;
4175         EvDocumentBackendInfo info;
4176
4177         if (document && ev_document_get_backend_info (document, &info)) {
4178                 comments = g_strdup_printf (
4179                         _("Document Viewer\nUsing %s (%s)"),
4180                         info.name, info.version);
4181         } else {
4182                 comments = g_strdup_printf (
4183                         _("Document Viewer"));
4184         }
4185
4186         return comments;
4187 }
4188
4189 static void
4190 ev_window_cmd_help_about (GtkAction *action, EvWindow *ev_window)
4191 {
4192         const char *authors[] = {
4193                 "Martin Kretzschmar <m_kretzschmar@gmx.net>",
4194                 "Jonathan Blandford <jrb@gnome.org>",
4195                 "Marco Pesenti Gritti <marco@gnome.org>",
4196                 "Nickolay V. Shmyrev <nshmyrev@yandex.ru>",
4197                 "Bryan Clark <clarkbw@gnome.org>",
4198                 "Carlos Garcia Campos <carlosgc@gnome.org>",
4199                 "Wouter Bolsterlee <wbolster@gnome.org>",
4200                 "Christian Persch <chpe" "\100" "gnome.org>",
4201                 NULL
4202         };
4203
4204         const char *documenters[] = {
4205                 "Nickolay V. Shmyrev <nshmyrev@yandex.ru>",
4206                 NULL
4207         };
4208
4209         const char *license[] = {
4210                 N_("Evince is free software; you can redistribute it and/or modify "
4211                    "it under the terms of the GNU General Public License as published by "
4212                    "the Free Software Foundation; either version 2 of the License, or "
4213                    "(at your option) any later version.\n"),
4214                 N_("Evince is distributed in the hope that it will be useful, "
4215                    "but WITHOUT ANY WARRANTY; without even the implied warranty of "
4216                    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the "
4217                    "GNU General Public License for more details.\n"),
4218                 N_("You should have received a copy of the GNU General Public License "
4219                    "along with Evince; if not, write to the Free Software Foundation, Inc., "
4220                    "59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n")
4221         };
4222
4223         char *license_trans;
4224         char *comments;
4225
4226 #ifdef ENABLE_NLS
4227         const char **p;
4228
4229         for (p = authors; *p; ++p)
4230                 *p = _(*p);
4231
4232         for (p = documenters; *p; ++p)
4233                 *p = _(*p);
4234 #endif
4235
4236         license_trans = g_strconcat (_(license[0]), "\n", _(license[1]), "\n",
4237                                      _(license[2]), "\n", NULL);
4238
4239         comments = build_comments_string (ev_window->priv->document);
4240
4241         gtk_show_about_dialog (
4242                 GTK_WINDOW (ev_window),
4243                 "name", _("Evince"),
4244                 "version", VERSION,
4245                 "copyright",
4246                 _("© 1996–2009 The Evince authors"),
4247                 "license", license_trans,
4248                 "website", "http://www.gnome.org/projects/evince",
4249                 "comments", comments,
4250                 "authors", authors,
4251                 "documenters", documenters,
4252                 "translator-credits", _("translator-credits"),
4253                 "logo-icon-name", "evince",
4254                 "wrap-license", TRUE,
4255                 NULL);
4256
4257         g_free (comments);
4258         g_free (license_trans);
4259 }
4260
4261 static void
4262 ev_window_view_toolbar_cb (GtkAction *action, EvWindow *ev_window)
4263 {
4264         gboolean active;
4265
4266         active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
4267         update_chrome_flag (ev_window, EV_CHROME_TOOLBAR, active);
4268         update_chrome_visibility (ev_window);
4269         if (ev_window->priv->metadata)
4270                 ev_metadata_set_boolean (ev_window->priv->metadata, "show_toolbar", active);
4271 }
4272
4273 static void
4274 ev_window_view_sidebar_cb (GtkAction *action, EvWindow *ev_window)
4275 {
4276         if (EV_WINDOW_IS_PRESENTATION (ev_window))
4277                 return;
4278
4279         update_chrome_flag (ev_window, EV_CHROME_SIDEBAR,
4280                             gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)));
4281         update_chrome_visibility (ev_window);
4282 }
4283
4284 static void
4285 ev_window_sidebar_current_page_changed_cb (EvSidebar  *ev_sidebar,
4286                                            GParamSpec *pspec,
4287                                            EvWindow   *ev_window)
4288 {
4289         GtkWidget *current_page;
4290         const char *id;
4291
4292         g_object_get (G_OBJECT (ev_sidebar), "current_page", &current_page, NULL);
4293
4294         if (current_page == ev_window->priv->sidebar_links) {
4295                 id = LINKS_SIDEBAR_ID;
4296         } else if (current_page == ev_window->priv->sidebar_thumbs) {
4297                 id = THUMBNAILS_SIDEBAR_ID;
4298         } else if (current_page == ev_window->priv->sidebar_attachments) {
4299                 id = ATTACHMENTS_SIDEBAR_ID;
4300         } else if (current_page == ev_window->priv->sidebar_layers) {
4301                 id = LAYERS_SIDEBAR_ID;
4302         } else {
4303                 g_assert_not_reached();
4304         }
4305
4306         g_object_unref (current_page);
4307
4308         if (ev_window->priv->metadata && !ev_window_is_empty (ev_window))
4309                 ev_metadata_set_string (ev_window->priv->metadata, "sidebar_page", id);
4310 }
4311
4312 static void
4313 ev_window_sidebar_visibility_changed_cb (EvSidebar  *ev_sidebar,
4314                                          GParamSpec *pspec,
4315                                          EvWindow   *ev_window)
4316 {
4317         GtkAction *action;
4318
4319         action = gtk_action_group_get_action (ev_window->priv->action_group, "ViewSidebar");
4320
4321         if (!EV_WINDOW_IS_PRESENTATION (ev_window)) {
4322                 gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
4323                                               GTK_WIDGET_VISIBLE (ev_sidebar));
4324
4325                 if (ev_window->priv->metadata)
4326                         ev_metadata_set_boolean (ev_window->priv->metadata, "sidebar_visibility",
4327                                                  GTK_WIDGET_VISIBLE (ev_sidebar));
4328         }
4329 }
4330
4331 static void
4332 view_menu_link_popup (EvWindow *ev_window,
4333                       EvLink   *link)
4334 {
4335         gboolean   show_external = FALSE;
4336         gboolean   show_internal = FALSE;
4337         GtkAction *action;
4338
4339         if (ev_window->priv->link)
4340                 g_object_unref (ev_window->priv->link);
4341
4342         if (link)
4343                 ev_window->priv->link = g_object_ref (link);
4344         else
4345                 ev_window->priv->link = NULL;
4346
4347         if (ev_window->priv->link) {
4348                 EvLinkAction *ev_action;
4349
4350                 ev_action = ev_link_get_action (link);
4351                 if (ev_action) {
4352                         switch (ev_link_action_get_action_type (ev_action)) {
4353                                 case EV_LINK_ACTION_TYPE_GOTO_DEST:
4354                                 case EV_LINK_ACTION_TYPE_GOTO_REMOTE:
4355                                         show_internal = TRUE;
4356                                         break;
4357                                 case EV_LINK_ACTION_TYPE_EXTERNAL_URI:
4358                                 case EV_LINK_ACTION_TYPE_LAUNCH:
4359                                         show_external = TRUE;
4360                                         break;
4361                                 default:
4362                                         break;
4363                         }
4364                 }
4365         }
4366
4367         action = gtk_action_group_get_action (ev_window->priv->view_popup_action_group,
4368                                               "OpenLink");
4369         gtk_action_set_visible (action, show_external);
4370
4371         action = gtk_action_group_get_action (ev_window->priv->view_popup_action_group,
4372                                               "CopyLinkAddress");
4373         gtk_action_set_visible (action, show_external);
4374
4375         action = gtk_action_group_get_action (ev_window->priv->view_popup_action_group,
4376                                               "GoLink");
4377         gtk_action_set_visible (action, show_internal);
4378
4379         action = gtk_action_group_get_action (ev_window->priv->view_popup_action_group,
4380                                               "OpenLinkNewWindow");
4381         gtk_action_set_visible (action, show_internal);
4382 }
4383
4384 static void
4385 view_menu_image_popup (EvWindow  *ev_window,
4386                        EvImage   *image)
4387 {
4388         GtkAction *action;
4389         gboolean   show_image = FALSE;
4390
4391         if (ev_window->priv->image)
4392                 g_object_unref (ev_window->priv->image);
4393
4394         if (image)
4395                 ev_window->priv->image = g_object_ref (image);
4396         else
4397                 ev_window->priv->image = NULL;
4398
4399         show_image = (ev_window->priv->image != NULL);
4400
4401         action = gtk_action_group_get_action (ev_window->priv->view_popup_action_group,
4402                                               "SaveImageAs");
4403         gtk_action_set_visible (action, show_image);
4404
4405         action = gtk_action_group_get_action (ev_window->priv->view_popup_action_group,
4406                                               "CopyImage");
4407         gtk_action_set_visible (action, show_image);
4408 }
4409
4410 static void
4411 view_menu_annot_popup (EvWindow     *ev_window,
4412                        EvAnnotation *annot)
4413 {
4414         GtkAction *action;
4415         gboolean   show_annot = FALSE;
4416
4417         if (annot && EV_IS_ANNOTATION_ATTACHMENT (annot)) {
4418                 EvAttachment *attachment = EV_ANNOTATION_ATTACHMENT (annot)->attachment;
4419
4420                 if (attachment) {
4421                         show_annot = TRUE;
4422                         if (ev_window->priv->attach_list) {
4423                                 g_list_foreach (ev_window->priv->attach_list,
4424                                                 (GFunc) g_object_unref, NULL);
4425                                 g_list_free (ev_window->priv->attach_list);
4426                                 ev_window->priv->attach_list = NULL;
4427                         }
4428                         ev_window->priv->attach_list =
4429                                 g_list_prepend (ev_window->priv->attach_list,
4430                                                 g_object_ref (attachment));
4431                 }
4432         }
4433
4434         action = gtk_action_group_get_action (ev_window->priv->attachment_popup_action_group,
4435                                               "OpenAttachment");
4436         gtk_action_set_visible (action, show_annot);
4437
4438         action = gtk_action_group_get_action (ev_window->priv->attachment_popup_action_group,
4439                                               "SaveAttachmentAs");
4440         gtk_action_set_visible (action, show_annot);
4441 }
4442
4443 static gboolean
4444 view_menu_popup_cb (EvView   *view,
4445                     GObject  *object,
4446                     EvWindow *ev_window)
4447 {
4448         view_menu_link_popup (ev_window,
4449                               EV_IS_LINK (object) ? EV_LINK (object) : NULL);
4450         view_menu_image_popup (ev_window,
4451                                EV_IS_IMAGE (object) ? EV_IMAGE (object) : NULL);
4452         view_menu_annot_popup (ev_window,
4453                                EV_IS_ANNOTATION (object) ? EV_ANNOTATION (object) : NULL);
4454
4455         gtk_menu_popup (GTK_MENU (ev_window->priv->view_popup),
4456                         NULL, NULL, NULL, NULL,
4457                         3, gtk_get_current_event_time ());
4458         return TRUE;
4459 }
4460
4461 static gboolean
4462 attachment_bar_menu_popup_cb (EvSidebarAttachments *attachbar,
4463                               GList           *attach_list,
4464                               EvWindow        *ev_window)
4465 {
4466         GtkWidget *popup;
4467
4468         g_assert (attach_list != NULL);
4469
4470         if (ev_window->priv->attach_list) {
4471                 g_list_foreach (ev_window->priv->attach_list,
4472                                 (GFunc) g_object_unref, NULL);
4473                 g_list_free (ev_window->priv->attach_list);
4474         }
4475
4476         ev_window->priv->attach_list = attach_list;
4477
4478         popup = ev_window->priv->attachment_popup;
4479
4480         gtk_menu_popup (GTK_MENU (popup), NULL, NULL,
4481                         NULL, NULL,
4482                         3, gtk_get_current_event_time ());
4483
4484         return TRUE;
4485 }
4486
4487 static void
4488 ev_window_update_find_status_message (EvWindow *ev_window)
4489 {
4490         gchar *message;
4491
4492         if (!ev_window->priv->find_job)
4493                 return;
4494
4495         if (ev_job_is_finished (ev_window->priv->find_job)) {
4496                 gint n_results;
4497
4498                 n_results = ev_job_find_get_n_results (EV_JOB_FIND (ev_window->priv->find_job),
4499                                                        ev_document_model_get_page (ev_window->priv->model));
4500                 /* TRANS: Sometimes this could be better translated as
4501                                       "%d hit(s) on this page".  Therefore this string
4502                                       contains plural cases. */
4503                 message = g_strdup_printf (ngettext ("%d found on this page",
4504                                                      "%d found on this page",
4505                                                      n_results),
4506                                            n_results);
4507         } else {
4508                 gdouble percent;
4509
4510                 percent = ev_job_find_get_progress (EV_JOB_FIND (ev_window->priv->find_job));
4511                 message = g_strdup_printf (_("%3d%% remaining to search"),
4512                                            (gint) ((1.0 - percent) * 100));
4513         }
4514
4515         egg_find_bar_set_status_text (EGG_FIND_BAR (ev_window->priv->find_bar), message);
4516         g_free (message);
4517 }
4518
4519 static void
4520 ev_window_find_job_finished_cb (EvJobFind *job,
4521                                 EvWindow  *ev_window)
4522 {
4523         ev_window_update_find_status_message (ev_window);
4524 }
4525
4526 static void
4527 ev_window_find_job_updated_cb (EvJobFind *job,
4528                                gint       page,
4529                                EvWindow  *ev_window)
4530 {
4531         ev_window_update_actions (ev_window);
4532
4533         ev_view_find_changed (EV_VIEW (ev_window->priv->view),
4534                               ev_job_find_get_results (job),
4535                               page);
4536         ev_window_update_find_status_message (ev_window);
4537 }
4538
4539 static void
4540 ev_window_clear_find_job (EvWindow *ev_window)
4541 {
4542         if (ev_window->priv->find_job != NULL) {
4543                 if (!ev_job_is_finished (ev_window->priv->find_job))
4544                         ev_job_cancel (ev_window->priv->find_job);
4545
4546                 g_signal_handlers_disconnect_by_func (ev_window->priv->find_job,
4547                                                       ev_window_find_job_finished_cb,
4548                                                       ev_window);
4549                 g_signal_handlers_disconnect_by_func (ev_window->priv->find_job,
4550                                                       ev_window_find_job_updated_cb,
4551                                                       ev_window);
4552                 g_object_unref (ev_window->priv->find_job);
4553                 ev_window->priv->find_job = NULL;
4554         }
4555 }
4556
4557 static void
4558 find_bar_previous_cb (EggFindBar *find_bar,
4559                       EvWindow   *ev_window)
4560 {
4561         ev_view_find_previous (EV_VIEW (ev_window->priv->view));
4562 }
4563
4564 static void
4565 find_bar_next_cb (EggFindBar *find_bar,
4566                   EvWindow   *ev_window)
4567 {
4568         ev_view_find_next (EV_VIEW (ev_window->priv->view));
4569 }
4570
4571 static void
4572 find_bar_close_cb (EggFindBar *find_bar,
4573                    EvWindow   *ev_window)
4574 {
4575         ev_view_find_cancel (EV_VIEW (ev_window->priv->view));
4576         ev_window_clear_find_job (ev_window);
4577         update_chrome_flag (ev_window, EV_CHROME_FINDBAR, FALSE);
4578         update_chrome_visibility (ev_window);
4579 }
4580
4581 static void
4582 find_bar_search_changed_cb (EggFindBar *find_bar,
4583                             GParamSpec *param,
4584                             EvWindow   *ev_window)
4585 {
4586         gboolean case_sensitive;
4587         const char *search_string;
4588
4589         if (!ev_window->priv->document || !EV_IS_DOCUMENT_FIND (ev_window->priv->document))
4590                 return;
4591
4592         /* Either the string or case sensitivity could have changed. */
4593         case_sensitive = egg_find_bar_get_case_sensitive (find_bar);
4594         search_string = egg_find_bar_get_search_string (find_bar);
4595
4596         ev_view_find_search_changed (EV_VIEW (ev_window->priv->view));
4597
4598         ev_window_clear_find_job (ev_window);
4599
4600         if (search_string && search_string[0]) {
4601                 ev_window->priv->find_job = ev_job_find_new (ev_window->priv->document,
4602                                                              ev_document_model_get_page (ev_window->priv->model),
4603                                                              ev_document_get_n_pages (ev_window->priv->document),
4604                                                              search_string,
4605                                                              case_sensitive);
4606                 g_signal_connect (ev_window->priv->find_job, "finished",
4607                                   G_CALLBACK (ev_window_find_job_finished_cb),
4608                                   ev_window);
4609                 g_signal_connect (ev_window->priv->find_job, "updated",
4610                                   G_CALLBACK (ev_window_find_job_updated_cb),
4611                                   ev_window);
4612                 ev_job_scheduler_push_job (ev_window->priv->find_job, EV_JOB_PRIORITY_NONE);
4613         } else {
4614                 ev_window_update_actions (ev_window);
4615                 egg_find_bar_set_status_text (EGG_FIND_BAR (ev_window->priv->find_bar),
4616                                               NULL);
4617                 gtk_widget_queue_draw (GTK_WIDGET (ev_window->priv->view));
4618         }
4619 }
4620
4621 static void
4622 find_bar_visibility_changed_cb (EggFindBar *find_bar,
4623                                 GParamSpec *param,
4624                                 EvWindow   *ev_window)
4625 {
4626         gboolean visible;
4627
4628         visible = GTK_WIDGET_VISIBLE (find_bar);
4629
4630         if (ev_window->priv->document &&
4631             EV_IS_DOCUMENT_FIND (ev_window->priv->document)) {
4632                 ev_view_find_set_highlight_search (EV_VIEW (ev_window->priv->view), visible);
4633                 ev_view_find_search_changed (EV_VIEW (ev_window->priv->view));
4634                 ev_window_update_actions (ev_window);
4635
4636                 if (visible)
4637                         find_bar_search_changed_cb (find_bar, NULL, ev_window);
4638                 else
4639                         egg_find_bar_set_status_text (EGG_FIND_BAR (ev_window->priv->find_bar), NULL);
4640         }
4641 }
4642
4643 static void
4644 find_bar_scroll (EggFindBar   *find_bar,
4645                  GtkScrollType scroll,
4646                  EvWindow     *ev_window)
4647 {
4648         ev_view_scroll (EV_VIEW (ev_window->priv->view), scroll, FALSE);
4649 }
4650
4651 static void
4652 zoom_control_changed_cb (EphyZoomAction *action,
4653                          float           zoom,
4654                          EvWindow       *ev_window)
4655 {
4656         EvSizingMode mode;
4657
4658         if (zoom == EPHY_ZOOM_BEST_FIT) {
4659                 mode = EV_SIZING_BEST_FIT;
4660         } else if (zoom == EPHY_ZOOM_FIT_WIDTH) {
4661                 mode = EV_SIZING_FIT_WIDTH;
4662         } else {
4663                 mode = EV_SIZING_FREE;
4664         }
4665
4666         ev_document_model_set_sizing_mode (ev_window->priv->model, mode);
4667
4668         if (mode == EV_SIZING_FREE) {
4669                 ev_document_model_set_scale (ev_window->priv->model,
4670                                              zoom * get_screen_dpi (GTK_WINDOW (ev_window)) / 72.0);
4671         }
4672 }
4673
4674 static void
4675 ev_window_drag_data_received (GtkWidget        *widget,
4676                               GdkDragContext   *context,
4677                               gint              x,
4678                               gint              y,
4679                               GtkSelectionData *selection_data,
4680                               guint             info,
4681                               guint             time)
4682
4683 {
4684         EvWindow  *window = EV_WINDOW (widget);
4685         gchar    **uris;
4686         gint       i = 0;
4687         GSList    *uri_list = NULL;
4688         GtkWidget *source;
4689
4690         source = gtk_drag_get_source_widget (context);
4691         if (source && widget == gtk_widget_get_toplevel (source)) {
4692                 gtk_drag_finish (context, FALSE, FALSE, time);
4693                 return;
4694         }
4695
4696         uris = gtk_selection_data_get_uris (selection_data);
4697         if (!uris) {
4698                 gtk_drag_finish (context, FALSE, FALSE, time);
4699                 return;
4700         }
4701
4702         for (i = 0; uris[i]; i++) {
4703                 uri_list = g_slist_prepend (uri_list, (gpointer) uris[i]);
4704         }
4705
4706         ev_application_open_uri_list (EV_APP, uri_list,
4707                                       gtk_window_get_screen (GTK_WINDOW (window)),
4708                                       0);
4709         gtk_drag_finish (context, TRUE, FALSE, time);
4710
4711         g_strfreev (uris);
4712         g_slist_free (uri_list);
4713 }
4714
4715 static void
4716 ev_window_finalize (GObject *object)
4717 {
4718         G_OBJECT_CLASS (ev_window_parent_class)->finalize (object);
4719
4720         if (ev_window_n_copies == 0) {
4721                 ev_application_shutdown (EV_APP);
4722         } else {
4723                 ev_window_n_copies--;
4724         }
4725 }
4726
4727 static void
4728 ev_window_dispose (GObject *object)
4729 {
4730         EvWindow *window = EV_WINDOW (object);
4731         EvWindowPrivate *priv = window->priv;
4732         GObject *mpkeys = ev_application_get_media_keys (EV_APP);
4733
4734         if (mpkeys) {
4735                 g_signal_handlers_disconnect_by_func (mpkeys,
4736                                                       ev_window_media_player_key_pressed,
4737                                                       window);
4738         }
4739
4740         if (priv->metadata) {
4741                 g_object_unref (priv->metadata);
4742                 priv->metadata = NULL;
4743         }
4744
4745         if (priv->setup_document_idle > 0) {
4746                 g_source_remove (priv->setup_document_idle);
4747                 priv->setup_document_idle = 0;
4748         }
4749
4750 #ifdef WITH_GCONF
4751         if (priv->gconf_client) {
4752                 g_object_unref (priv->gconf_client);
4753                 priv->gconf_client = NULL;
4754         }
4755 #endif
4756
4757         if (priv->monitor) {
4758                 g_object_unref (priv->monitor);
4759                 priv->monitor = NULL;
4760         }
4761
4762         if (priv->title) {
4763                 ev_window_title_free (priv->title);
4764                 priv->title = NULL;
4765         }
4766
4767         if (priv->ui_manager) {
4768                 g_object_unref (priv->ui_manager);
4769                 priv->ui_manager = NULL;
4770         }
4771
4772         if (priv->action_group) {
4773                 g_object_unref (priv->action_group);
4774                 priv->action_group = NULL;
4775         }
4776
4777         if (priv->view_popup_action_group) {
4778                 g_object_unref (priv->view_popup_action_group);
4779                 priv->view_popup_action_group = NULL;
4780         }
4781
4782         if (priv->attachment_popup_action_group) {
4783                 g_object_unref (priv->attachment_popup_action_group);
4784                 priv->attachment_popup_action_group = NULL;
4785         }
4786
4787         if (priv->recent_action_group) {
4788                 g_object_unref (priv->recent_action_group);
4789                 priv->recent_action_group = NULL;
4790         }
4791
4792         if (priv->recent_manager) {
4793                 g_signal_handlers_disconnect_by_func (priv->recent_manager,
4794                                                       ev_window_setup_recent,
4795                                                       window);
4796                 priv->recent_manager = NULL;
4797         }
4798
4799         priv->recent_ui_id = 0;
4800
4801         if (priv->model) {
4802                 g_signal_handlers_disconnect_by_func (priv->model,
4803                                                       ev_window_page_changed_cb,
4804                                                       window);
4805                 g_object_unref (priv->model);
4806                 priv->model = NULL;
4807         }
4808
4809         if (priv->document) {
4810                 g_object_unref (priv->document);
4811                 priv->document = NULL;
4812         }
4813
4814         if (priv->view) {
4815                 g_object_unref (priv->view);
4816                 priv->view = NULL;
4817         }
4818
4819         if (priv->password_view) {
4820                 g_object_unref (priv->password_view);
4821                 priv->password_view = NULL;
4822         }
4823
4824         if (priv->load_job) {
4825                 ev_window_clear_load_job (window);
4826         }
4827
4828         if (priv->reload_job) {
4829                 ev_window_clear_reload_job (window);
4830         }
4831
4832         if (priv->save_job) {
4833                 ev_window_clear_save_job (window);
4834         }
4835
4836         if (priv->thumbnail_job) {
4837                 ev_window_clear_thumbnail_job (window);
4838         }
4839
4840         if (priv->find_job) {
4841                 ev_window_clear_find_job (window);
4842         }
4843
4844         if (priv->local_uri) {
4845                 ev_window_clear_local_uri (window);
4846                 priv->local_uri = NULL;
4847         }
4848
4849         ev_window_clear_progress_idle (window);
4850         if (priv->progress_cancellable) {
4851                 g_object_unref (priv->progress_cancellable);
4852                 priv->progress_cancellable = NULL;
4853         }
4854
4855         ev_window_close_dialogs (window);
4856
4857         if (priv->link) {
4858                 g_object_unref (priv->link);
4859                 priv->link = NULL;
4860         }
4861
4862         if (priv->image) {
4863                 g_object_unref (priv->image);
4864                 priv->image = NULL;
4865         }
4866
4867         if (priv->attach_list) {
4868                 g_list_foreach (priv->attach_list,
4869                                 (GFunc) g_object_unref,
4870                                 NULL);
4871                 g_list_free (priv->attach_list);
4872                 priv->attach_list = NULL;
4873         }
4874
4875         if (priv->find_bar) {
4876                 g_signal_handlers_disconnect_by_func
4877                         (window->priv->find_bar,
4878                          G_CALLBACK (find_bar_close_cb),
4879                          window);
4880                 priv->find_bar = NULL;
4881         }
4882
4883         if (priv->uri) {
4884                 g_free (priv->uri);
4885                 priv->uri = NULL;
4886         }
4887
4888         if (priv->search_string) {
4889                 g_free (priv->search_string);
4890                 priv->search_string = NULL;
4891         }
4892
4893         if (priv->dest) {
4894                 g_object_unref (priv->dest);
4895                 priv->dest = NULL;
4896         }
4897
4898         if (priv->history) {
4899                 g_object_unref (priv->history);
4900                 priv->history = NULL;
4901         }
4902
4903         if (priv->print_queue) {
4904                 g_queue_free (priv->print_queue);
4905                 priv->print_queue = NULL;
4906         }
4907
4908         G_OBJECT_CLASS (ev_window_parent_class)->dispose (object);
4909 }
4910
4911 static void
4912 menubar_deactivate_cb (GtkWidget *menubar,
4913                        EvWindow  *window)
4914 {
4915         g_signal_handlers_disconnect_by_func (menubar,
4916                                               G_CALLBACK (menubar_deactivate_cb),
4917                                               window);
4918
4919         gtk_menu_shell_deselect (GTK_MENU_SHELL (menubar));
4920
4921         update_chrome_visibility (window);
4922 }
4923
4924 static gboolean
4925 ev_window_key_press_event (GtkWidget   *widget,
4926                            GdkEventKey *event)
4927 {
4928         EvWindow        *ev_window = EV_WINDOW (widget);
4929         EvWindowPrivate *priv = ev_window->priv;
4930         gboolean         handled = FALSE;
4931
4932         /* Propagate the event to the view first
4933          * It's needed to be able to type in
4934          * annot popups windows
4935          */
4936         if (priv->view) {
4937                 g_object_ref (priv->view);
4938                 if (GTK_WIDGET_IS_SENSITIVE (priv->view))
4939                         handled = gtk_widget_event (priv->view, (GdkEvent*) event);
4940                 g_object_unref (priv->view);
4941         }
4942
4943         if (!handled && !EV_WINDOW_IS_PRESENTATION (ev_window)) {
4944                 guint modifier = event->state & gtk_accelerator_get_default_mod_mask ();
4945
4946                 if (priv->menubar_accel_keyval != 0 &&
4947                     event->keyval == priv->menubar_accel_keyval &&
4948                     modifier == priv->menubar_accel_modifier) {
4949                         if (!GTK_WIDGET_VISIBLE (priv->menubar)) {
4950                                 g_signal_connect (priv->menubar, "deactivate",
4951                                                   G_CALLBACK (menubar_deactivate_cb),
4952                                                   ev_window);
4953
4954                                 gtk_widget_show (priv->menubar);
4955                                 gtk_menu_shell_select_first (GTK_MENU_SHELL (priv->menubar),
4956                                                              FALSE);
4957
4958                                 handled = TRUE;
4959                         }
4960                 }
4961         }
4962
4963         if (!handled)
4964                 handled = GTK_WIDGET_CLASS (ev_window_parent_class)->key_press_event (widget, event);
4965
4966         return handled;
4967 }
4968
4969 static void
4970 ev_window_class_init (EvWindowClass *ev_window_class)
4971 {
4972         GObjectClass *g_object_class = G_OBJECT_CLASS (ev_window_class);
4973         GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (ev_window_class);
4974
4975         g_object_class->dispose = ev_window_dispose;
4976         g_object_class->finalize = ev_window_finalize;
4977
4978         widget_class->key_press_event = ev_window_key_press_event;
4979         widget_class->screen_changed = ev_window_screen_changed;
4980         widget_class->window_state_event = ev_window_state_event;
4981         widget_class->drag_data_received = ev_window_drag_data_received;
4982
4983         g_type_class_add_private (g_object_class, sizeof (EvWindowPrivate));
4984 }
4985
4986 /* Normal items */
4987 static const GtkActionEntry entries[] = {
4988         { "File", NULL, N_("_File") },
4989         { "Edit", NULL, N_("_Edit") },
4990         { "View", NULL, N_("_View") },
4991         { "Go", NULL, N_("_Go") },
4992         { "Help", NULL, N_("_Help") },
4993
4994         /* File menu */
4995         { "FileOpen", GTK_STOCK_OPEN, N_("_Open…"), "<control>O",
4996           N_("Open an existing document"),
4997           G_CALLBACK (ev_window_cmd_file_open) },
4998         { "FileOpenCopy", NULL, N_("Op_en a Copy"), "<control>N",
4999           N_("Open a copy of the current document in a new window"),
5000           G_CALLBACK (ev_window_cmd_file_open_copy) },
5001         { "FileSaveAs", GTK_STOCK_SAVE_AS, N_("_Save a Copy…"), "<control>S",
5002           N_("Save a copy of the current document"),
5003           G_CALLBACK (ev_window_cmd_save_as) },
5004         { "FilePageSetup", GTK_STOCK_PAGE_SETUP, N_("Page Set_up…"), NULL,
5005           N_("Set up the page settings for printing"),
5006           G_CALLBACK (ev_window_cmd_file_print_setup) },
5007         { "FilePrint", GTK_STOCK_PRINT, N_("_Print…"), "<control>P",
5008           N_("Print this document"),
5009           G_CALLBACK (ev_window_cmd_file_print) },
5010         { "FileProperties", GTK_STOCK_PROPERTIES, N_("P_roperties"), "<alt>Return", NULL,
5011           G_CALLBACK (ev_window_cmd_file_properties) },
5012         { "FileCloseWindow", GTK_STOCK_CLOSE, NULL, "<control>W", NULL,
5013           G_CALLBACK (ev_window_cmd_file_close_window) },
5014
5015         /* Edit menu */
5016         { "EditCopy", GTK_STOCK_COPY, NULL, "<control>C", NULL,
5017           G_CALLBACK (ev_window_cmd_edit_copy) },
5018         { "EditSelectAll", GTK_STOCK_SELECT_ALL, N_("Select _All"), "<control>A", NULL,
5019           G_CALLBACK (ev_window_cmd_edit_select_all) },
5020         { "EditFind", GTK_STOCK_FIND, N_("_Find…"), "<control>F",
5021           N_("Find a word or phrase in the document"),
5022           G_CALLBACK (ev_window_cmd_edit_find) },
5023         { "EditFindNext", NULL, N_("Find Ne_xt"), "<control>G", NULL,
5024           G_CALLBACK (ev_window_cmd_edit_find_next) },
5025         { "EditFindPrevious", NULL, N_("Find Pre_vious"), "<shift><control>G", NULL,
5026           G_CALLBACK (ev_window_cmd_edit_find_previous) },
5027         { "EditToolbar", NULL, N_("T_oolbar"), NULL, NULL,
5028           G_CALLBACK (ev_window_cmd_edit_toolbar) },
5029         { "EditRotateLeft", EV_STOCK_ROTATE_LEFT, N_("Rotate _Left"), "<control>Left", NULL,
5030           G_CALLBACK (ev_window_cmd_edit_rotate_left) },
5031         { "EditRotateRight", EV_STOCK_ROTATE_RIGHT, N_("Rotate _Right"), "<control>Right", NULL,
5032           G_CALLBACK (ev_window_cmd_edit_rotate_right) },
5033
5034
5035         /* View menu */
5036         { "ViewZoomIn", GTK_STOCK_ZOOM_IN, NULL, "<control>plus",
5037           N_("Enlarge the document"),
5038           G_CALLBACK (ev_window_cmd_view_zoom_in) },
5039         { "ViewZoomOut", GTK_STOCK_ZOOM_OUT, NULL, "<control>minus",
5040           N_("Shrink the document"),
5041           G_CALLBACK (ev_window_cmd_view_zoom_out) },
5042         { "ViewReload", GTK_STOCK_REFRESH, N_("_Reload"), "<control>R",
5043           N_("Reload the document"),
5044           G_CALLBACK (ev_window_cmd_view_reload) },
5045
5046         { "ViewAutoscroll", GTK_STOCK_MEDIA_PLAY, N_("Auto_scroll"), NULL, NULL,
5047           G_CALLBACK (ev_window_cmd_view_autoscroll) },
5048
5049         /* Go menu */
5050         { "GoPreviousPage", GTK_STOCK_GO_UP, N_("_Previous Page"), "<control>Page_Up",
5051           N_("Go to the previous page"),
5052           G_CALLBACK (ev_window_cmd_go_previous_page) },
5053         { "GoNextPage", GTK_STOCK_GO_DOWN, N_("_Next Page"), "<control>Page_Down",
5054           N_("Go to the next page"),
5055           G_CALLBACK (ev_window_cmd_go_next_page) },
5056         { "GoFirstPage", GTK_STOCK_GOTO_TOP, N_("_First Page"), "<control>Home",
5057           N_("Go to the first page"),
5058           G_CALLBACK (ev_window_cmd_go_first_page) },
5059         { "GoLastPage", GTK_STOCK_GOTO_BOTTOM, N_("_Last Page"), "<control>End",
5060           N_("Go to the last page"),
5061           G_CALLBACK (ev_window_cmd_go_last_page) },
5062
5063         /* Help menu */
5064         { "HelpContents", GTK_STOCK_HELP, N_("_Contents"), "F1", NULL,
5065           G_CALLBACK (ev_window_cmd_help_contents) },
5066
5067         { "HelpAbout", GTK_STOCK_ABOUT, N_("_About"), NULL, NULL,
5068           G_CALLBACK (ev_window_cmd_help_about) },
5069
5070         /* Toolbar-only */
5071         { "LeaveFullscreen", GTK_STOCK_LEAVE_FULLSCREEN, N_("Leave Fullscreen"), NULL,
5072           N_("Leave fullscreen mode"),
5073           G_CALLBACK (ev_window_cmd_leave_fullscreen) },
5074         { "StartPresentation", EV_STOCK_RUN_PRESENTATION, N_("Start Presentation"), NULL,
5075           N_("Start a presentation"),
5076           G_CALLBACK (ev_window_cmd_start_presentation) },
5077
5078         /* Accellerators */
5079         { "Escape", NULL, "", "Escape", "",
5080           G_CALLBACK (ev_window_cmd_escape) },
5081         { "Slash", GTK_STOCK_FIND, NULL, "slash", NULL,
5082           G_CALLBACK (ev_window_cmd_edit_find) },
5083         { "F3", NULL, "", "F3", NULL,
5084           G_CALLBACK (ev_window_cmd_edit_find_next) },
5085         { "PageDown", NULL, "", "Page_Down", NULL,
5086           G_CALLBACK (ev_window_cmd_scroll_forward) },
5087         { "PageUp", NULL, "", "Page_Up", NULL,
5088           G_CALLBACK (ev_window_cmd_scroll_backward) },
5089         { "Space", NULL, "", "space", NULL,
5090           G_CALLBACK (ev_window_cmd_scroll_forward) },
5091         { "ShiftSpace", NULL, "", "<shift>space", NULL,
5092           G_CALLBACK (ev_window_cmd_scroll_backward) },
5093         { "BackSpace", NULL, "", "BackSpace", NULL,
5094           G_CALLBACK (ev_window_cmd_scroll_backward) },
5095         { "ShiftBackSpace", NULL, "", "<shift>BackSpace", NULL,
5096           G_CALLBACK (ev_window_cmd_scroll_forward) },
5097         { "Return", NULL, "", "Return", NULL,
5098           G_CALLBACK (ev_window_cmd_scroll_forward) },
5099         { "ShiftReturn", NULL, "", "<shift>Return", NULL,
5100           G_CALLBACK (ev_window_cmd_scroll_backward) },
5101         { "p", GTK_STOCK_GO_UP, "", "p", NULL,
5102           G_CALLBACK (ev_window_cmd_go_previous_page) },
5103         { "n", GTK_STOCK_GO_DOWN, "", "n", NULL,
5104           G_CALLBACK (ev_window_cmd_go_next_page) },
5105         { "Plus", GTK_STOCK_ZOOM_IN, NULL, "plus", NULL,
5106           G_CALLBACK (ev_window_cmd_view_zoom_in) },
5107         { "CtrlEqual", GTK_STOCK_ZOOM_IN, NULL, "<control>equal", NULL,
5108           G_CALLBACK (ev_window_cmd_view_zoom_in) },
5109         { "Equal", GTK_STOCK_ZOOM_IN, NULL, "equal", NULL,
5110           G_CALLBACK (ev_window_cmd_view_zoom_in) },
5111         { "Minus", GTK_STOCK_ZOOM_OUT, NULL, "minus", NULL,
5112           G_CALLBACK (ev_window_cmd_view_zoom_out) },
5113         { "FocusPageSelector", NULL, "", "<control>l", NULL,
5114           G_CALLBACK (ev_window_cmd_focus_page_selector) },
5115         { "GoBackwardFast", NULL, "", "<shift>Page_Up", NULL,
5116           G_CALLBACK (ev_window_cmd_go_backward) },
5117         { "GoForwardFast", NULL, "", "<shift>Page_Down", NULL,
5118           G_CALLBACK (ev_window_cmd_go_forward) },
5119         { "KpPlus", GTK_STOCK_ZOOM_IN, NULL, "KP_Add", NULL,
5120           G_CALLBACK (ev_window_cmd_view_zoom_in) },
5121         { "KpMinus", GTK_STOCK_ZOOM_OUT, NULL, "KP_Subtract", NULL,
5122           G_CALLBACK (ev_window_cmd_view_zoom_out) },
5123         { "CtrlKpPlus", GTK_STOCK_ZOOM_IN, NULL, "<control>KP_Add", NULL,
5124           G_CALLBACK (ev_window_cmd_view_zoom_in) },
5125         { "CtrlKpMinus", GTK_STOCK_ZOOM_OUT, NULL, "<control>KP_Subtract", NULL,
5126           G_CALLBACK (ev_window_cmd_view_zoom_out) },
5127         { "CtrlInsert", GTK_STOCK_COPY, NULL, "<control>Insert", NULL,
5128           G_CALLBACK (ev_window_cmd_edit_copy) },
5129 };
5130
5131 /* Toggle items */
5132 static const GtkToggleActionEntry toggle_entries[] = {
5133         /* View Menu */
5134         { "ViewToolbar", NULL, N_("_Toolbar"), NULL,
5135           N_("Show or hide the toolbar"),
5136           G_CALLBACK (ev_window_view_toolbar_cb), TRUE },
5137         { "ViewSidebar", GTK_STOCK_INDEX, N_("Side _Pane"), "F9",
5138           N_("Show or hide the side pane"),
5139           G_CALLBACK (ev_window_view_sidebar_cb), TRUE },
5140         { "ViewContinuous", EV_STOCK_VIEW_CONTINUOUS, N_("_Continuous"), NULL,
5141           N_("Show the entire document"),
5142           G_CALLBACK (ev_window_cmd_continuous), TRUE },
5143         { "ViewDual", EV_STOCK_VIEW_DUAL, N_("_Dual"), NULL,
5144           N_("Show two pages at once"),
5145           G_CALLBACK (ev_window_cmd_dual), FALSE },
5146         { "ViewFullscreen", GTK_STOCK_FULLSCREEN, N_("_Fullscreen"), "F11",
5147           N_("Expand the window to fill the screen"),
5148           G_CALLBACK (ev_window_cmd_view_fullscreen) },
5149         { "ViewPresentation", EV_STOCK_RUN_PRESENTATION, N_("Pre_sentation"), "F5",
5150           N_("Run document as a presentation"),
5151           G_CALLBACK (ev_window_cmd_view_presentation) },
5152         { "ViewBestFit", EV_STOCK_ZOOM_PAGE, N_("_Best Fit"), NULL,
5153           N_("Make the current document fill the window"),
5154           G_CALLBACK (ev_window_cmd_view_best_fit) },
5155         { "ViewPageWidth", EV_STOCK_ZOOM_WIDTH, N_("Fit Page _Width"), NULL,
5156           N_("Make the current document fill the window width"),
5157           G_CALLBACK (ev_window_cmd_view_page_width) },
5158         { "ViewInvertedColors", EV_STOCK_INVERTED_COLORS, N_("_Inverted Colors"), "<control>I",
5159           N_("Show page contents with the colors inverted"),
5160           G_CALLBACK (ev_window_cmd_view_inverted_colors) },
5161
5162 };
5163
5164 /* Popups specific items */
5165 static const GtkActionEntry view_popup_entries [] = {
5166         /* Links */
5167         { "OpenLink", GTK_STOCK_OPEN, N_("_Open Link"), NULL,
5168           NULL, G_CALLBACK (ev_view_popup_cmd_open_link) },
5169         { "GoLink", GTK_STOCK_GO_FORWARD, N_("_Go To"), NULL,
5170           NULL, G_CALLBACK (ev_view_popup_cmd_open_link) },
5171         { "OpenLinkNewWindow", NULL, N_("Open in New _Window"), NULL,
5172           NULL, G_CALLBACK (ev_view_popup_cmd_open_link_new_window) },
5173         { "CopyLinkAddress", NULL, N_("_Copy Link Address"), NULL,
5174           NULL, G_CALLBACK (ev_view_popup_cmd_copy_link_address) },
5175         { "SaveImageAs", NULL, N_("_Save Image As…"), NULL,
5176           NULL, G_CALLBACK (ev_view_popup_cmd_save_image_as) },
5177         { "CopyImage", NULL, N_("Copy _Image"), NULL,
5178           NULL, G_CALLBACK (ev_view_popup_cmd_copy_image) },
5179 };
5180
5181 static const GtkActionEntry attachment_popup_entries [] = {
5182         { "OpenAttachment", GTK_STOCK_OPEN, N_("_Open Attachment"), NULL,
5183           NULL, G_CALLBACK (ev_attachment_popup_cmd_open_attachment) },
5184         { "SaveAttachmentAs", GTK_STOCK_SAVE_AS, N_("_Save Attachment As…"), NULL,
5185           NULL, G_CALLBACK (ev_attachment_popup_cmd_save_attachment_as) },
5186 };
5187
5188 static void
5189 sidebar_links_link_activated_cb (EvSidebarLinks *sidebar_links, EvLink *link, EvWindow *window)
5190 {
5191         ev_view_handle_link (EV_VIEW (window->priv->view), link);
5192 }
5193
5194 static void
5195 activate_link_cb (EvPageAction *page_action, EvLink *link, EvWindow *window)
5196 {
5197         ev_view_handle_link (EV_VIEW (window->priv->view), link);
5198         gtk_widget_grab_focus (window->priv->view);
5199 }
5200
5201 static void
5202 navigation_action_activate_link_cb (EvNavigationAction *action, EvLink *link, EvWindow *window)
5203 {
5204
5205         ev_view_handle_link (EV_VIEW (window->priv->view), link);
5206         gtk_widget_grab_focus (window->priv->view);
5207 }
5208
5209 static void
5210 sidebar_layers_visibility_changed (EvSidebarLayers *layers,
5211                                    EvWindow        *window)
5212 {
5213         ev_view_reload (EV_VIEW (window->priv->view));
5214 }
5215
5216 static void
5217 register_custom_actions (EvWindow *window, GtkActionGroup *group)
5218 {
5219         GtkAction *action;
5220
5221         action = g_object_new (EV_TYPE_PAGE_ACTION,
5222                                "name", PAGE_SELECTOR_ACTION,
5223                                "label", _("Page"),
5224                                "tooltip", _("Select Page"),
5225                                "icon_name", "text-x-generic",
5226                                "visible_overflown", FALSE,
5227                                NULL);
5228         ev_page_action_set_model (EV_PAGE_ACTION (action),
5229                                   window->priv->model);
5230         g_signal_connect (action, "activate_link",
5231                           G_CALLBACK (activate_link_cb), window);
5232         gtk_action_group_add_action (group, action);
5233         g_object_unref (action);
5234
5235         action = g_object_new (EPHY_TYPE_ZOOM_ACTION,
5236                                "name", ZOOM_CONTROL_ACTION,
5237                                "label", _("Zoom"),
5238                                "stock_id", EV_STOCK_ZOOM,
5239                                "tooltip", _("Adjust the zoom level"),
5240                                "zoom", 1.0,
5241                                NULL);
5242         g_signal_connect (action, "zoom_to_level",
5243                           G_CALLBACK (zoom_control_changed_cb), window);
5244         gtk_action_group_add_action (group, action);
5245         g_object_unref (action);
5246
5247         action = g_object_new (EV_TYPE_NAVIGATION_ACTION,
5248                                "name", NAVIGATION_ACTION,
5249                                "label", _("Navigation"),
5250                                "is_important", TRUE,
5251                                "short_label", _("Back"),
5252                                "stock_id", GTK_STOCK_GO_DOWN,
5253                                /*translators: this is the history action*/
5254                                "tooltip", _("Move across visited pages"),
5255                                NULL);
5256         g_signal_connect (action, "activate_link",
5257                           G_CALLBACK (navigation_action_activate_link_cb), window);
5258         gtk_action_group_add_action (group, action);
5259         g_object_unref (action);
5260
5261         action = g_object_new (EV_TYPE_OPEN_RECENT_ACTION,
5262                                "name", "FileOpenRecent",
5263                                "label", _("_Open…"),
5264                                "tooltip", _("Open an existing document"),
5265                                "stock_id", GTK_STOCK_OPEN,
5266                                NULL);
5267         g_signal_connect (action, "activate",
5268                           G_CALLBACK (ev_window_cmd_file_open), window);
5269         g_signal_connect (action, "item_activated",
5270                           G_CALLBACK (ev_window_open_recent_action_item_activated),
5271                           window);
5272         gtk_action_group_add_action (group, action);
5273         g_object_unref (action);
5274 }
5275
5276 static void
5277 set_action_properties (GtkActionGroup *action_group)
5278 {
5279         GtkAction *action;
5280
5281         action = gtk_action_group_get_action (action_group, "GoPreviousPage");
5282         g_object_set (action, "is-important", TRUE, NULL);
5283         /*translators: this is the label for toolbar button*/
5284         g_object_set (action, "short_label", _("Previous"), NULL);
5285
5286         action = gtk_action_group_get_action (action_group, "GoNextPage");
5287         g_object_set (action, "is-important", TRUE, NULL);
5288         /*translators: this is the label for toolbar button*/
5289         g_object_set (action, "short_label", _("Next"), NULL);
5290
5291         action = gtk_action_group_get_action (action_group, "ViewZoomIn");
5292         /*translators: this is the label for toolbar button*/
5293         g_object_set (action, "short_label", _("Zoom In"), NULL);
5294
5295         action = gtk_action_group_get_action (action_group, "ViewZoomOut");
5296         /*translators: this is the label for toolbar button*/
5297         g_object_set (action, "short_label", _("Zoom Out"), NULL);
5298
5299         action = gtk_action_group_get_action (action_group, "ViewBestFit");
5300         /*translators: this is the label for toolbar button*/
5301         g_object_set (action, "short_label", _("Best Fit"), NULL);
5302
5303         action = gtk_action_group_get_action (action_group, "ViewPageWidth");
5304         /*translators: this is the label for toolbar button*/
5305         g_object_set (action, "short_label", _("Fit Width"), NULL);
5306
5307         action = gtk_action_group_get_action (action_group, "LeaveFullscreen");
5308         g_object_set (action, "is-important", TRUE, NULL);
5309 }
5310
5311 static void
5312 set_chrome_actions (EvWindow *window)
5313 {
5314         EvWindowPrivate *priv = window->priv;
5315         GtkActionGroup *action_group = priv->action_group;
5316         GtkAction *action;
5317
5318         action= gtk_action_group_get_action (action_group, "ViewToolbar");
5319         g_signal_handlers_block_by_func
5320                 (action, G_CALLBACK (ev_window_view_toolbar_cb), window);
5321         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
5322                                       (priv->chrome & EV_CHROME_TOOLBAR) != 0);
5323         g_signal_handlers_unblock_by_func
5324                 (action, G_CALLBACK (ev_window_view_toolbar_cb), window);
5325 }
5326
5327 static void
5328 sidebar_widget_model_set (EvSidebarLinks *ev_sidebar_links,
5329                           GParamSpec     *pspec,
5330                           EvWindow       *ev_window)
5331 {
5332         GtkTreeModel *model;
5333         GtkAction *action;
5334
5335         g_object_get (G_OBJECT (ev_sidebar_links),
5336                       "model", &model,
5337                       NULL);
5338
5339         action = gtk_action_group_get_action (ev_window->priv->action_group, PAGE_SELECTOR_ACTION);
5340         ev_page_action_set_links_model (EV_PAGE_ACTION (action), model);
5341         g_object_unref (model);
5342 }
5343
5344 static gboolean
5345 view_actions_focus_in_cb (GtkWidget *widget, GdkEventFocus *event, EvWindow *window)
5346 {
5347 #ifdef ENABLE_DBUS
5348         GObject *keys;
5349
5350         keys = ev_application_get_media_keys (EV_APP);
5351         ev_media_player_keys_focused (EV_MEDIA_PLAYER_KEYS (keys));
5352 #endif /* ENABLE_DBUS */
5353
5354         update_chrome_flag (window, EV_CHROME_RAISE_TOOLBAR, FALSE);
5355         ev_window_set_action_sensitive (window, "ViewToolbar", TRUE);
5356
5357         ev_window_set_view_accels_sensitivity (window, TRUE);
5358
5359         update_chrome_visibility (window);
5360
5361         return FALSE;
5362 }
5363
5364 static gboolean
5365 view_actions_focus_out_cb (GtkWidget *widget, GdkEventFocus *event, EvWindow *window)
5366 {
5367         ev_window_set_view_accels_sensitivity (window, FALSE);
5368
5369         return FALSE;
5370 }
5371
5372 static void
5373 sidebar_page_main_widget_update_cb (GObject *ev_sidebar_page,
5374                                     GParamSpec         *pspec,
5375                                     EvWindow           *ev_window)
5376 {
5377         GtkWidget *widget;
5378
5379         g_object_get (ev_sidebar_page, "main_widget", &widget, NULL);
5380
5381         if (widget != NULL) {
5382                 g_signal_connect_object (widget, "focus_in_event",
5383                                          G_CALLBACK (view_actions_focus_in_cb),
5384                                          ev_window, 0);
5385                 g_signal_connect_object (widget, "focus_out_event",
5386                                          G_CALLBACK (view_actions_focus_out_cb),
5387                                          ev_window, 0);
5388                 g_object_unref (widget);
5389         }
5390 }
5391
5392 static gboolean
5393 window_state_event_cb (EvWindow *window, GdkEventWindowState *event, gpointer dummy)
5394 {
5395         if (!(event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN)) {
5396                 gboolean maximized;
5397
5398                 maximized = event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED;
5399                 if (window->priv->metadata && !ev_window_is_empty (window))
5400                         ev_metadata_set_boolean (window->priv->metadata, "window_maximized", maximized);
5401         }
5402
5403         return FALSE;
5404 }
5405
5406 static gboolean
5407 window_configure_event_cb (EvWindow *window, GdkEventConfigure *event, gpointer dummy)
5408 {
5409         GdkWindowState state;
5410         gdouble document_width, document_height;
5411
5412         if (!window->priv->metadata)
5413                 return FALSE;
5414
5415         state = gdk_window_get_state (GTK_WIDGET (window)->window);
5416
5417         if (!(state & GDK_WINDOW_STATE_FULLSCREEN)) {
5418                 if (!ev_window_is_empty (window) && window->priv->document) {
5419                         ev_document_get_max_page_size (window->priv->document,
5420                                                        &document_width, &document_height);
5421                         ev_metadata_set_double (window->priv->metadata, "window_width_ratio",
5422                                                 (double)event->width / document_width);
5423                         ev_metadata_set_double (window->priv->metadata, "window_height_ratio",
5424                                                 (double)event->height / document_height);
5425                         ev_metadata_set_int (window->priv->metadata, "window_x", event->x);
5426                         ev_metadata_set_int (window->priv->metadata, "window_y", event->y);
5427                         ev_metadata_set_int (window->priv->metadata, "window_width", event->width);
5428                         ev_metadata_set_int (window->priv->metadata, "window_height", event->height);
5429                 }
5430         }
5431
5432         return FALSE;
5433 }
5434
5435 static void
5436 launch_action (EvWindow *window, EvLinkAction *action)
5437 {
5438         const char *filename = ev_link_action_get_filename (action);
5439         GAppInfo *app_info;
5440         GFile *file;
5441         GList file_list = {NULL};
5442         GAppLaunchContext *context;
5443         GError *error = NULL;
5444
5445         if (filename == NULL)
5446                 return;
5447
5448         if (g_path_is_absolute (filename)) {
5449                 file = g_file_new_for_path (filename);
5450         } else {
5451                 GFile *base_file;
5452                 gchar *dir;
5453
5454                 dir = g_path_get_dirname (window->priv->uri);
5455                 base_file = g_file_new_for_uri (dir);
5456                 g_free (dir);
5457
5458                 file = g_file_resolve_relative_path (base_file, filename);
5459                 g_object_unref (base_file);
5460         }
5461
5462         app_info = g_file_query_default_handler (file, NULL, &error);
5463         if (!app_info) {
5464                 ev_window_error_message (window, error,
5465                                          "%s",
5466                                          _("Unable to launch external application."));
5467                 g_object_unref (file);
5468                 g_error_free (error);
5469
5470                 return;
5471         }
5472
5473         context = G_APP_LAUNCH_CONTEXT (gdk_app_launch_context_new ());
5474         gdk_app_launch_context_set_screen (GDK_APP_LAUNCH_CONTEXT (context),
5475                                            gtk_window_get_screen (GTK_WINDOW (window)));
5476         gdk_app_launch_context_set_timestamp (GDK_APP_LAUNCH_CONTEXT (context),
5477                                               gtk_get_current_event_time ());
5478
5479         file_list.data = file;
5480         if (!g_app_info_launch (app_info, &file_list, context, &error)) {
5481                 ev_window_error_message (window, error,
5482                                          "%s",
5483                                          _("Unable to launch external application."));
5484                 g_error_free (error);
5485         }
5486
5487         g_object_unref (app_info);
5488         g_object_unref (file);
5489         /* FIXMEchpe: unref launch context? */
5490
5491         /* According to the PDF spec filename can be an executable. I'm not sure
5492            allowing to launch executables is a good idea though. -- marco */
5493 }
5494
5495 static void
5496 launch_external_uri (EvWindow *window, EvLinkAction *action)
5497 {
5498         const gchar *uri = ev_link_action_get_uri (action);
5499         GError *error = NULL;
5500         gboolean ret;
5501         GAppLaunchContext *context;
5502
5503         context = G_APP_LAUNCH_CONTEXT (gdk_app_launch_context_new ());
5504         gdk_app_launch_context_set_screen (GDK_APP_LAUNCH_CONTEXT (context),
5505                                            gtk_window_get_screen (GTK_WINDOW (window)));
5506         gdk_app_launch_context_set_timestamp (GDK_APP_LAUNCH_CONTEXT (context),
5507                                               gtk_get_current_event_time ());
5508
5509         if (!g_strstr_len (uri, strlen (uri), "://") &&
5510             !g_str_has_prefix (uri, "mailto:")) {
5511                 gchar *new_uri;
5512
5513                 /* Not a valid uri, assume http if it starts with www */
5514                 if (g_str_has_prefix (uri, "www.")) {
5515                         new_uri = g_strdup_printf ("http://%s", uri);
5516                 } else {
5517                         GFile *file, *parent;
5518
5519                         file = g_file_new_for_uri (window->priv->uri);
5520                         parent = g_file_get_parent (file);
5521                         g_object_unref (file);
5522                         if (parent) {
5523                                 gchar *parent_uri = g_file_get_uri (parent);
5524
5525                                 new_uri = g_build_filename (parent_uri, uri, NULL);
5526                                 g_free (parent_uri);
5527                                 g_object_unref (parent);
5528                         } else {
5529                                 new_uri = g_strdup_printf ("file:///%s", uri);
5530                         }
5531                 }
5532                 ret = g_app_info_launch_default_for_uri (new_uri, context, &error);
5533                 g_free (new_uri);
5534         } else {
5535                 ret = g_app_info_launch_default_for_uri (uri, context, &error);
5536         }
5537
5538         if (ret == FALSE) {
5539                 ev_window_error_message (window, error,
5540                                          "%s", _("Unable to open external link"));
5541                 g_error_free (error);
5542         }
5543
5544         /* FIXMEchpe: unref launch context? */
5545 }
5546
5547 static void
5548 open_remote_link (EvWindow *window, EvLinkAction *action)
5549 {
5550         gchar *uri;
5551         gchar *dir;
5552
5553         dir = g_path_get_dirname (window->priv->uri);
5554
5555         uri = g_build_filename (dir, ev_link_action_get_filename (action),
5556                                 NULL);
5557         g_free (dir);
5558
5559         ev_application_open_uri_at_dest (EV_APP, uri,
5560                                          gtk_window_get_screen (GTK_WINDOW (window)),
5561                                          ev_link_action_get_dest (action),
5562                                          0,
5563                                          NULL,
5564                                          gtk_get_current_event_time ());
5565
5566         g_free (uri);
5567 }
5568
5569 static void
5570 do_action_named (EvWindow *window, EvLinkAction *action)
5571 {
5572         const gchar *name = ev_link_action_get_name (action);
5573
5574         if (g_ascii_strcasecmp (name, "FirstPage") == 0) {
5575                 ev_window_cmd_go_first_page (NULL, window);
5576         } else if (g_ascii_strcasecmp (name, "PrevPage") == 0) {
5577                 ev_window_cmd_go_previous_page (NULL, window);
5578         } else if (g_ascii_strcasecmp (name, "NextPage") == 0) {
5579                 ev_window_cmd_go_next_page (NULL, window);
5580         } else if (g_ascii_strcasecmp (name, "LastPage") == 0) {
5581                 ev_window_cmd_go_last_page (NULL, window);
5582         } else if (g_ascii_strcasecmp (name, "GoToPage") == 0) {
5583                 ev_window_cmd_focus_page_selector (NULL, window);
5584         } else if (g_ascii_strcasecmp (name, "Find") == 0) {
5585                 ev_window_cmd_edit_find (NULL, window);
5586         } else if (g_ascii_strcasecmp (name, "Close") == 0) {
5587                 ev_window_cmd_file_close_window (NULL, window);
5588         } else if (g_ascii_strcasecmp (name, "Print") == 0) {
5589                 ev_window_cmd_file_print (NULL, window);
5590         } else {
5591                 g_warning ("Unimplemented named action: %s, please post a "
5592                            "bug report in Evince bugzilla "
5593                            "(http://bugzilla.gnome.org) with a testcase.",
5594                            name);
5595         }
5596 }
5597
5598 static void
5599 view_external_link_cb (EvView *view, EvLinkAction *action, EvWindow *window)
5600 {
5601         switch (ev_link_action_get_action_type (action)) {
5602                 case EV_LINK_ACTION_TYPE_GOTO_DEST: {
5603                         EvLinkDest *dest;
5604
5605                         dest = ev_link_action_get_dest (action);
5606                         if (!dest)
5607                                 return;
5608
5609                         ev_window_open_copy_at_dest (window, dest);
5610                 }
5611                         break;
5612                 case EV_LINK_ACTION_TYPE_EXTERNAL_URI:
5613                         launch_external_uri (window, action);
5614                         break;
5615                 case EV_LINK_ACTION_TYPE_LAUNCH:
5616                         launch_action (window, action);
5617                         break;
5618                 case EV_LINK_ACTION_TYPE_GOTO_REMOTE:
5619                         open_remote_link (window, action);
5620                         break;
5621                 case EV_LINK_ACTION_TYPE_NAMED:
5622                         do_action_named (window, action);
5623                         break;
5624                 default:
5625                         g_assert_not_reached ();
5626         }
5627 }
5628
5629 static void
5630 ev_view_popup_cmd_open_link (GtkAction *action, EvWindow *window)
5631 {
5632         ev_view_handle_link (EV_VIEW (window->priv->view), window->priv->link);
5633 }
5634
5635 static void
5636 ev_view_popup_cmd_open_link_new_window (GtkAction *action, EvWindow *window)
5637 {
5638         EvLinkAction *ev_action = NULL;
5639         EvLinkDest   *dest;
5640
5641         ev_action = ev_link_get_action (window->priv->link);
5642         if (!ev_action)
5643                 return;
5644
5645         dest = ev_link_action_get_dest (ev_action);
5646         if (!dest)
5647                 return;
5648
5649         ev_window_open_copy_at_dest (window, dest);
5650 }
5651
5652 static void
5653 ev_view_popup_cmd_copy_link_address (GtkAction *action, EvWindow *window)
5654 {
5655         EvLinkAction *ev_action;
5656
5657         ev_action = ev_link_get_action (window->priv->link);
5658         if (!ev_action)
5659                 return;
5660
5661         ev_view_copy_link_address (EV_VIEW (window->priv->view),
5662                                    ev_action);
5663 }
5664
5665
5666 static void
5667 image_save_dialog_response_cb (GtkWidget *fc,
5668                                gint       response_id,
5669                                EvWindow  *ev_window)
5670 {
5671         GFile           *target_file;
5672         gboolean         is_native;
5673         GError          *error = NULL;
5674         GdkPixbuf       *pixbuf;
5675         gchar           *uri;
5676         gchar          **extensions;
5677         gchar           *filename;
5678         gchar           *file_format;
5679         GdkPixbufFormat *format;
5680         GtkFileFilter   *filter;
5681
5682         if (response_id != GTK_RESPONSE_OK) {
5683                 gtk_widget_destroy (fc);
5684                 return;
5685         }
5686
5687         uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (fc));
5688         filter = gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (fc));
5689         format = g_object_get_data (G_OBJECT (filter), "pixbuf-format");
5690
5691         if (format == NULL) {
5692                 format = get_gdk_pixbuf_format_by_extension (uri);
5693         }
5694
5695         if (format == NULL && g_strrstr (uri, ".") == NULL) {
5696                 /* no extension found and no extension provided within uri */
5697                 format = get_gdk_pixbuf_format_by_extension (".png");
5698                 if (format == NULL) {
5699                         /* no .png support, try .jpeg */
5700                         format = get_gdk_pixbuf_format_by_extension (".jpeg");
5701                 }
5702         }
5703
5704         if (format == NULL) {
5705                 ev_window_error_message (ev_window, NULL,
5706                                          "%s",
5707                                          _("Couldn't find appropriate format to save image"));
5708                 g_free (uri);
5709                 gtk_widget_destroy (fc);
5710
5711                 return;
5712         }
5713
5714         extensions = gdk_pixbuf_format_get_extensions (format);
5715         if (!g_str_has_suffix (uri, extensions[0])) {
5716                 gchar *uri_extension;
5717
5718                 uri_extension = g_strconcat (uri, ".", extensions[0], NULL);
5719                 target_file = g_file_new_for_uri (uri_extension);
5720                 g_free (uri_extension);
5721         } else {
5722                 target_file = g_file_new_for_uri (uri);
5723         }
5724         g_strfreev (extensions);
5725         g_free (uri);
5726
5727         is_native = g_file_is_native (target_file);
5728         if (is_native) {
5729                 filename = g_file_get_path (target_file);
5730         } else {
5731                 /* Create a temporary local file to save to */
5732                 if (ev_mkstemp ("saveimage.XXXXXX", &filename, &error) == -1)
5733                         goto has_error;
5734         }
5735
5736         ev_document_doc_mutex_lock ();
5737         pixbuf = ev_document_images_get_image (EV_DOCUMENT_IMAGES (ev_window->priv->document),
5738                                                ev_window->priv->image);
5739         ev_document_doc_mutex_unlock ();
5740
5741         file_format = gdk_pixbuf_format_get_name (format);
5742         gdk_pixbuf_save (pixbuf, filename, file_format, &error, NULL);
5743         g_free (file_format);
5744         g_object_unref (pixbuf);
5745
5746     has_error:
5747         if (error) {
5748                 ev_window_error_message (ev_window, error,
5749                                          "%s", _("The image could not be saved."));
5750                 g_error_free (error);
5751                 g_free (filename);
5752                 g_object_unref (target_file);
5753                 gtk_widget_destroy (fc);
5754
5755                 return;
5756         }
5757
5758         if (!is_native) {
5759                 GFile *source_file;
5760
5761                 source_file = g_file_new_for_path (filename);
5762
5763                 ev_window_save_remote (ev_window, EV_SAVE_IMAGE,
5764                                        source_file, target_file);
5765                 g_object_unref (source_file);
5766         }
5767
5768         g_free (filename);
5769         g_object_unref (target_file);
5770         gtk_widget_destroy (fc);
5771 }
5772
5773 static void
5774 ev_view_popup_cmd_save_image_as (GtkAction *action, EvWindow *window)
5775 {
5776         GtkWidget *fc;
5777
5778         if (!window->priv->image)
5779                 return;
5780
5781         fc = gtk_file_chooser_dialog_new (_("Save Image"),
5782                                           GTK_WINDOW (window),
5783                                           GTK_FILE_CHOOSER_ACTION_SAVE,
5784                                           GTK_STOCK_CANCEL,
5785                                           GTK_RESPONSE_CANCEL,
5786                                           GTK_STOCK_SAVE, GTK_RESPONSE_OK,
5787                                           NULL);
5788
5789         gtk_dialog_set_default_response (GTK_DIALOG (fc), GTK_RESPONSE_OK);
5790         gtk_dialog_set_alternative_button_order (GTK_DIALOG (fc),
5791                                                  GTK_RESPONSE_OK,
5792                                                  GTK_RESPONSE_CANCEL,
5793                                                  -1);
5794
5795         gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (fc), FALSE);
5796         gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (fc), TRUE);
5797
5798         file_chooser_dialog_add_writable_pixbuf_formats (GTK_FILE_CHOOSER (fc));
5799
5800         g_signal_connect (fc, "response",
5801                           G_CALLBACK (image_save_dialog_response_cb),
5802                           window);
5803
5804         gtk_widget_show (fc);
5805 }
5806
5807 static void
5808 ev_view_popup_cmd_copy_image (GtkAction *action, EvWindow *window)
5809 {
5810         GtkClipboard *clipboard;
5811         GdkPixbuf    *pixbuf;
5812
5813         if (!window->priv->image)
5814                 return;
5815
5816         clipboard = gtk_widget_get_clipboard (GTK_WIDGET (window),
5817                                               GDK_SELECTION_CLIPBOARD);
5818         ev_document_doc_mutex_lock ();
5819         pixbuf = ev_document_images_get_image (EV_DOCUMENT_IMAGES (window->priv->document),
5820                                                window->priv->image);
5821         ev_document_doc_mutex_unlock ();
5822
5823         gtk_clipboard_set_image (clipboard, pixbuf);
5824         g_object_unref (pixbuf);
5825 }
5826
5827 static void
5828 ev_attachment_popup_cmd_open_attachment (GtkAction *action, EvWindow *window)
5829 {
5830         GList     *l;
5831         GdkScreen *screen;
5832
5833         if (!window->priv->attach_list)
5834                 return;
5835
5836         screen = gtk_window_get_screen (GTK_WINDOW (window));
5837
5838         for (l = window->priv->attach_list; l && l->data; l = g_list_next (l)) {
5839                 EvAttachment *attachment;
5840                 GError       *error = NULL;
5841
5842                 attachment = (EvAttachment *) l->data;
5843
5844                 ev_attachment_open (attachment, screen, gtk_get_current_event_time (), &error);
5845
5846                 if (error) {
5847                         ev_window_error_message (window, error,
5848                                                  "%s", _("Unable to open attachment"));
5849                         g_error_free (error);
5850                 }
5851         }
5852 }
5853
5854 static void
5855 attachment_save_dialog_response_cb (GtkWidget *fc,
5856                                     gint       response_id,
5857                                     EvWindow  *ev_window)
5858 {
5859         GFile                *target_file;
5860         gchar                *uri;
5861         GList                *l;
5862         GtkFileChooserAction  fc_action;
5863         gboolean              is_dir;
5864         gboolean              is_native;
5865
5866         if (response_id != GTK_RESPONSE_OK) {
5867                 gtk_widget_destroy (fc);
5868                 return;
5869         }
5870
5871         uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (fc));
5872         target_file = g_file_new_for_uri (uri);
5873         g_object_get (G_OBJECT (fc), "action", &fc_action, NULL);
5874         is_dir = (fc_action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
5875         is_native = g_file_is_native (target_file);
5876
5877         for (l = ev_window->priv->attach_list; l && l->data; l = g_list_next (l)) {
5878                 EvAttachment *attachment;
5879                 GFile        *save_to = NULL;
5880                 GError       *error = NULL;
5881
5882                 attachment = (EvAttachment *) l->data;
5883
5884                 if (is_native) {
5885                         if (is_dir) {
5886                                 save_to = g_file_get_child (target_file,
5887                                     /* FIXMEchpe: file name encoding! */
5888                                                             ev_attachment_get_name (attachment));
5889                         } else {
5890                                 save_to = g_object_ref (target_file);
5891                         }
5892                 } else {
5893                         save_to = ev_mkstemp_file ("saveattachment.XXXXXX", &error);
5894                 }
5895
5896                 if (save_to)
5897                         ev_attachment_save (attachment, save_to, &error);
5898
5899                 if (error) {
5900                         ev_window_error_message (ev_window, error,
5901                                                  "%s", _("The attachment could not be saved."));
5902                         g_error_free (error);
5903                         g_object_unref (save_to);
5904
5905                         continue;
5906                 }
5907
5908                 if (!is_native) {
5909                         GFile *dest_file;
5910
5911                         if (is_dir) {
5912                                 dest_file = g_file_get_child (target_file,
5913                                                               ev_attachment_get_name (attachment));
5914                         } else {
5915                                 dest_file = g_object_ref (target_file);
5916                         }
5917
5918                         ev_window_save_remote (ev_window, EV_SAVE_ATTACHMENT,
5919                                                save_to, dest_file);
5920
5921                         g_object_unref (dest_file);
5922                 }
5923
5924                 g_object_unref (save_to);
5925         }
5926
5927         g_free (uri);
5928         g_object_unref (target_file);
5929
5930         gtk_widget_destroy (fc);
5931 }
5932
5933 static void
5934 ev_attachment_popup_cmd_save_attachment_as (GtkAction *action, EvWindow *window)
5935 {
5936         GtkWidget    *fc;
5937         EvAttachment *attachment = NULL;
5938
5939         if (!window->priv->attach_list)
5940                 return;
5941
5942         if (g_list_length (window->priv->attach_list) == 1)
5943                 attachment = (EvAttachment *) window->priv->attach_list->data;
5944
5945         fc = gtk_file_chooser_dialog_new (
5946                 _("Save Attachment"),
5947                 GTK_WINDOW (window),
5948                 attachment ? GTK_FILE_CHOOSER_ACTION_SAVE : GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
5949                 GTK_STOCK_CANCEL,
5950                 GTK_RESPONSE_CANCEL,
5951                 GTK_STOCK_SAVE, GTK_RESPONSE_OK,
5952                 NULL);
5953
5954         gtk_dialog_set_default_response (GTK_DIALOG (fc), GTK_RESPONSE_OK);
5955         gtk_dialog_set_alternative_button_order (GTK_DIALOG (fc),
5956                                                  GTK_RESPONSE_OK,
5957                                                  GTK_RESPONSE_CANCEL,
5958                                                  -1);
5959
5960         gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (fc), TRUE);
5961         gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (fc), FALSE);
5962
5963         if (attachment)
5964                 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (fc),
5965                                                    ev_attachment_get_name (attachment));
5966
5967         g_signal_connect (fc, "response",
5968                           G_CALLBACK (attachment_save_dialog_response_cb),
5969                           window);
5970
5971         gtk_widget_show (fc);
5972 }
5973
5974 static void
5975 ev_window_media_player_key_pressed (EvWindow    *window,
5976                                     const gchar *key,
5977                                     gpointer     user_data)
5978 {
5979         if (!gtk_window_is_active (GTK_WINDOW (window)))
5980                 return;
5981
5982         /* Note how Previous/Next only go to the
5983          * next/previous page despite their icon telling you
5984          * they should go to the beginning/end.
5985          *
5986          * There's very few keyboards with FFW/RWD though,
5987          * so we stick the most useful keybinding on the most
5988          * often seen keys
5989          */
5990         if (strcmp (key, "Play") == 0) {
5991                 ev_window_run_presentation (window);
5992         } else if (strcmp (key, "Previous") == 0) {
5993                 ev_window_cmd_go_previous_page (NULL, window);
5994         } else if (strcmp (key, "Next") == 0) {
5995                 ev_window_cmd_go_next_page (NULL, window);
5996         } else if (strcmp (key, "FastForward") == 0) {
5997                 ev_window_cmd_go_last_page (NULL, window);
5998         } else if (strcmp (key, "Rewind") == 0) {
5999                 ev_window_cmd_go_first_page (NULL, window);
6000         }
6001 }
6002
6003 static EggToolbarsModel *
6004 get_toolbars_model (void)
6005 {
6006         EggToolbarsModel *toolbars_model;
6007         gchar            *toolbars_file;
6008         gchar            *toolbars_path;
6009         gint              i;
6010
6011         toolbars_model = egg_toolbars_model_new ();
6012
6013         toolbars_file = g_build_filename (ev_application_get_dot_dir (EV_APP, FALSE),
6014                                           "evince_toolbar.xml", NULL);
6015         toolbars_path = g_build_filename (ev_application_get_data_dir (EV_APP),
6016                                          "evince-toolbar.xml", NULL);
6017         egg_toolbars_model_load_names (toolbars_model, toolbars_path);
6018
6019         if (!egg_toolbars_model_load_toolbars (toolbars_model, toolbars_file)) {
6020                 egg_toolbars_model_load_toolbars (toolbars_model, toolbars_path);
6021                 goto skip_conversion;
6022         }
6023
6024         /* Open item doesn't exist anymore,
6025          * convert it to OpenRecent for compatibility
6026          */
6027         for (i = 0; i < egg_toolbars_model_n_items (toolbars_model, 0); i++) {
6028                 const gchar *item;
6029
6030                 item = egg_toolbars_model_item_nth (toolbars_model, 0, i);
6031                 if (g_ascii_strcasecmp (item, "FileOpen") == 0) {
6032                         egg_toolbars_model_remove_item (toolbars_model, 0, i);
6033                         egg_toolbars_model_add_item (toolbars_model, 0, i,
6034                                                      "FileOpenRecent");
6035                         egg_toolbars_model_save_toolbars (toolbars_model, toolbars_file, "1.0");
6036                         break;
6037                 }
6038         }
6039
6040     skip_conversion:
6041         g_free (toolbars_file);
6042         g_free (toolbars_path);
6043
6044         egg_toolbars_model_set_flags (toolbars_model, 0, EGG_TB_MODEL_NOT_REMOVABLE);
6045
6046         return toolbars_model;
6047 }
6048
6049 static void
6050 ev_window_init (EvWindow *ev_window)
6051 {
6052         GtkActionGroup *action_group;
6053         GtkAccelGroup *accel_group;
6054         GError *error = NULL;
6055         GtkWidget *sidebar_widget;
6056         GtkWidget *menuitem;
6057         EggToolbarsModel *toolbars_model;
6058         GObject *mpkeys;
6059         gchar *ui_path;
6060         gdouble dpi;
6061
6062         g_signal_connect (ev_window, "configure_event",
6063                           G_CALLBACK (window_configure_event_cb), NULL);
6064         g_signal_connect (ev_window, "window_state_event",
6065                           G_CALLBACK (window_state_event_cb), NULL);
6066
6067         ev_window->priv = EV_WINDOW_GET_PRIVATE (ev_window);
6068
6069         ev_window->priv->model = ev_document_model_new ();
6070
6071         ev_window->priv->page_mode = PAGE_MODE_DOCUMENT;
6072         ev_window->priv->title = ev_window_title_new (ev_window);
6073
6074         ev_window->priv->main_box = gtk_vbox_new (FALSE, 0);
6075         gtk_container_add (GTK_CONTAINER (ev_window), ev_window->priv->main_box);
6076         gtk_widget_show (ev_window->priv->main_box);
6077
6078         action_group = gtk_action_group_new ("MenuActions");
6079         ev_window->priv->action_group = action_group;
6080         gtk_action_group_set_translation_domain (action_group, NULL);
6081         gtk_action_group_add_actions (action_group, entries,
6082                                       G_N_ELEMENTS (entries), ev_window);
6083         gtk_action_group_add_toggle_actions (action_group, toggle_entries,
6084                                              G_N_ELEMENTS (toggle_entries),
6085                                              ev_window);
6086         set_action_properties (action_group);
6087         register_custom_actions (ev_window, action_group);
6088
6089         ev_window->priv->ui_manager = gtk_ui_manager_new ();
6090         gtk_ui_manager_insert_action_group (ev_window->priv->ui_manager,
6091                                             action_group, 0);
6092
6093         accel_group =
6094                 gtk_ui_manager_get_accel_group (ev_window->priv->ui_manager);
6095         gtk_window_add_accel_group (GTK_WINDOW (ev_window), accel_group);
6096
6097         ev_window_set_view_accels_sensitivity (ev_window, FALSE);
6098
6099         action_group = gtk_action_group_new ("ViewPopupActions");
6100         ev_window->priv->view_popup_action_group = action_group;
6101         gtk_action_group_set_translation_domain (action_group, NULL);
6102         gtk_action_group_add_actions (action_group, view_popup_entries,
6103                                       G_N_ELEMENTS (view_popup_entries),
6104                                       ev_window);
6105         gtk_ui_manager_insert_action_group (ev_window->priv->ui_manager,
6106                                             action_group, 0);
6107
6108         action_group = gtk_action_group_new ("AttachmentPopupActions");
6109         ev_window->priv->attachment_popup_action_group = action_group;
6110         gtk_action_group_set_translation_domain (action_group, NULL);
6111         gtk_action_group_add_actions (action_group, attachment_popup_entries,
6112                                       G_N_ELEMENTS (attachment_popup_entries),
6113                                       ev_window);
6114         gtk_ui_manager_insert_action_group (ev_window->priv->ui_manager,
6115                                             action_group, 0);
6116
6117         ui_path = g_build_filename (ev_application_get_data_dir (EV_APP),
6118                                     "evince-ui.xml", NULL);
6119         if (!gtk_ui_manager_add_ui_from_file (
6120                 ev_window->priv->ui_manager, ui_path, &error))
6121         {
6122                 g_warning ("building menus failed: %s", error->message);
6123                 g_error_free (error);
6124         }
6125         g_free (ui_path);
6126
6127 #if GTK_CHECK_VERSION (2, 17, 4)
6128         {
6129                 GtkAction *action;
6130
6131                 action = gtk_action_group_get_action (ev_window->priv->action_group,
6132                                                       "FilePageSetup");
6133                 g_object_set (action, "visible", FALSE, "sensitive", FALSE, NULL);
6134         }
6135 #endif
6136
6137         ev_window->priv->recent_manager = gtk_recent_manager_get_default ();
6138         ev_window->priv->recent_action_group = NULL;
6139         ev_window->priv->recent_ui_id = 0;
6140         g_signal_connect_swapped (ev_window->priv->recent_manager,
6141                                   "changed",
6142                                   G_CALLBACK (ev_window_setup_recent),
6143                                   ev_window);
6144
6145         ev_window->priv->menubar =
6146                  gtk_ui_manager_get_widget (ev_window->priv->ui_manager,
6147                                             "/MainMenu");
6148         gtk_box_pack_start (GTK_BOX (ev_window->priv->main_box),
6149                             ev_window->priv->menubar,
6150                             FALSE, FALSE, 0);
6151         menuitem = gtk_ui_manager_get_widget (ev_window->priv->ui_manager,
6152                                               "/MainMenu/EditMenu/EditRotateLeftMenu");
6153         gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (menuitem), TRUE);
6154         menuitem = gtk_ui_manager_get_widget (ev_window->priv->ui_manager,
6155                                               "/MainMenu/EditMenu/EditRotateRightMenu");
6156         gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (menuitem), TRUE);
6157
6158         toolbars_model = get_toolbars_model ();
6159         ev_window->priv->toolbar = GTK_WIDGET
6160                 (g_object_new (EGG_TYPE_EDITABLE_TOOLBAR,
6161                                "ui-manager", ev_window->priv->ui_manager,
6162                                "popup-path", "/ToolbarPopup",
6163                                "model", toolbars_model,
6164                                NULL));
6165         g_object_unref (toolbars_model);
6166
6167         egg_editable_toolbar_show (EGG_EDITABLE_TOOLBAR (ev_window->priv->toolbar),
6168                                    "DefaultToolBar");
6169         gtk_box_pack_start (GTK_BOX (ev_window->priv->main_box),
6170                             ev_window->priv->toolbar,
6171                             FALSE, FALSE, 0);
6172         gtk_widget_show (ev_window->priv->toolbar);
6173
6174         /* Add the main area */
6175         ev_window->priv->hpaned = gtk_hpaned_new ();
6176         g_signal_connect (ev_window->priv->hpaned,
6177                           "notify::position",
6178                           G_CALLBACK (ev_window_sidebar_position_change_cb),
6179                           ev_window);
6180
6181         gtk_paned_set_position (GTK_PANED (ev_window->priv->hpaned), SIDEBAR_DEFAULT_SIZE);
6182         gtk_box_pack_start (GTK_BOX (ev_window->priv->main_box), ev_window->priv->hpaned,
6183                             TRUE, TRUE, 0);
6184         gtk_widget_show (ev_window->priv->hpaned);
6185
6186         ev_window->priv->sidebar = ev_sidebar_new ();
6187         ev_sidebar_set_model (EV_SIDEBAR (ev_window->priv->sidebar),
6188                               ev_window->priv->model);
6189         gtk_paned_pack1 (GTK_PANED (ev_window->priv->hpaned),
6190                          ev_window->priv->sidebar, FALSE, FALSE);
6191         gtk_widget_show (ev_window->priv->sidebar);
6192
6193         /* Stub sidebar, for now */
6194
6195         sidebar_widget = ev_sidebar_thumbnails_new ();
6196         ev_window->priv->sidebar_thumbs = sidebar_widget;
6197         g_signal_connect (sidebar_widget,
6198                           "notify::main-widget",
6199                           G_CALLBACK (sidebar_page_main_widget_update_cb),
6200                           ev_window);
6201         sidebar_page_main_widget_update_cb (G_OBJECT (sidebar_widget), NULL, ev_window);
6202         gtk_widget_show (sidebar_widget);
6203         ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar),
6204                              sidebar_widget);
6205
6206         sidebar_widget = ev_sidebar_links_new ();
6207         ev_window->priv->sidebar_links = sidebar_widget;
6208         g_signal_connect (sidebar_widget,
6209                           "notify::model",
6210                           G_CALLBACK (sidebar_widget_model_set),
6211                           ev_window);
6212         g_signal_connect (sidebar_widget,
6213                           "link_activated",
6214                           G_CALLBACK (sidebar_links_link_activated_cb),
6215                           ev_window);
6216         sidebar_page_main_widget_update_cb (G_OBJECT (sidebar_widget), NULL, ev_window);
6217         gtk_widget_show (sidebar_widget);
6218         ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar),
6219                              sidebar_widget);
6220
6221         sidebar_widget = ev_sidebar_attachments_new ();
6222         ev_window->priv->sidebar_attachments = sidebar_widget;
6223         g_signal_connect_object (sidebar_widget,
6224                                  "popup",
6225                                  G_CALLBACK (attachment_bar_menu_popup_cb),
6226                                  ev_window, 0);
6227         gtk_widget_show (sidebar_widget);
6228         ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar),
6229                              sidebar_widget);
6230
6231         sidebar_widget = ev_sidebar_layers_new ();
6232         ev_window->priv->sidebar_layers = sidebar_widget;
6233         g_signal_connect (sidebar_widget,
6234                           "layers_visibility_changed",
6235                           G_CALLBACK (sidebar_layers_visibility_changed),
6236                           ev_window);
6237         gtk_widget_show (sidebar_widget);
6238         ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar),
6239                              sidebar_widget);
6240
6241         ev_window->priv->view_box = gtk_vbox_new (FALSE, 0);
6242         ev_window->priv->scrolled_window =
6243                 GTK_WIDGET (g_object_new (GTK_TYPE_SCROLLED_WINDOW,
6244                                           "shadow-type", GTK_SHADOW_IN,
6245                                           NULL));
6246         gtk_box_pack_start (GTK_BOX (ev_window->priv->view_box),
6247                             ev_window->priv->scrolled_window,
6248                             TRUE, TRUE, 0);
6249         gtk_widget_show (ev_window->priv->scrolled_window);
6250
6251         gtk_paned_add2 (GTK_PANED (ev_window->priv->hpaned),
6252                         ev_window->priv->view_box);
6253         gtk_widget_show (ev_window->priv->view_box);
6254
6255         ev_window->priv->view = ev_view_new ();
6256         ev_view_set_model (EV_VIEW (ev_window->priv->view), ev_window->priv->model);
6257         dpi = get_screen_dpi (GTK_WINDOW (ev_window));
6258         ev_document_model_set_min_scale (ev_window->priv->model, MIN_SCALE * dpi / 72.0);
6259         ev_document_model_set_max_scale (ev_window->priv->model, MAX_SCALE * dpi / 72.0);
6260         ev_window->priv->password_view = ev_password_view_new (GTK_WINDOW (ev_window));
6261         g_signal_connect_swapped (ev_window->priv->password_view,
6262                                   "unlock",
6263                                   G_CALLBACK (ev_window_password_view_unlock),
6264                                   ev_window);
6265         g_signal_connect_object (ev_window->priv->view, "focus_in_event",
6266                                  G_CALLBACK (view_actions_focus_in_cb),
6267                                  ev_window, 0);
6268         g_signal_connect_object (ev_window->priv->view, "focus_out_event",
6269                                  G_CALLBACK (view_actions_focus_out_cb),
6270                                  ev_window, 0);
6271         g_signal_connect_object (ev_window->priv->view, "external-link",
6272                                  G_CALLBACK (view_external_link_cb),
6273                                  ev_window, 0);
6274         g_signal_connect_object (ev_window->priv->view, "handle-link",
6275                                  G_CALLBACK (view_handle_link_cb),
6276                                  ev_window, 0);
6277         g_signal_connect_object (ev_window->priv->view, "popup",
6278                                  G_CALLBACK (view_menu_popup_cb),
6279                                  ev_window, 0);
6280         g_signal_connect_object (ev_window->priv->view, "selection-changed",
6281                                  G_CALLBACK (view_selection_changed_cb),
6282                                  ev_window, 0);
6283         gtk_widget_show (ev_window->priv->view);
6284         gtk_widget_show (ev_window->priv->password_view);
6285
6286         /* Find Bar */
6287         ev_window->priv->find_bar = egg_find_bar_new ();
6288         gtk_box_pack_end (GTK_BOX (ev_window->priv->main_box),
6289                           ev_window->priv->find_bar,
6290                           FALSE, TRUE, 0);
6291
6292         /* We own a ref on these widgets, as we can swap them in and out */
6293         g_object_ref (ev_window->priv->view);
6294         g_object_ref (ev_window->priv->password_view);
6295
6296         gtk_container_add (GTK_CONTAINER (ev_window->priv->scrolled_window),
6297                            ev_window->priv->view);
6298
6299         /* Connect to model signals */
6300         g_signal_connect_swapped (ev_window->priv->model,
6301                                   "page-changed",
6302                                   G_CALLBACK (ev_window_page_changed_cb),
6303                                   ev_window);
6304         g_signal_connect (ev_window->priv->model,
6305                           "notify::document",
6306                           G_CALLBACK (ev_window_document_changed_cb),
6307                           ev_window);
6308         g_signal_connect (ev_window->priv->model,
6309                           "notify::scale",
6310                           G_CALLBACK (ev_window_zoom_changed_cb),
6311                           ev_window);
6312         g_signal_connect (ev_window->priv->model,
6313                           "notify::sizing-mode",
6314                           G_CALLBACK (ev_window_sizing_mode_changed_cb),
6315                           ev_window);
6316         g_signal_connect (ev_window->priv->model,
6317                           "notify::rotation",
6318                           G_CALLBACK (ev_window_rotation_changed_cb),
6319                           ev_window);
6320         g_signal_connect (ev_window->priv->model,
6321                           "notify::continuous",
6322                           G_CALLBACK (ev_window_continuous_changed_cb),
6323                           ev_window);
6324         g_signal_connect (ev_window->priv->model,
6325                           "notify::dual-page",
6326                           G_CALLBACK (ev_window_dual_mode_changed_cb),
6327                           ev_window);
6328         g_signal_connect (ev_window->priv->model,
6329                           "notify::inverted-colors",
6330                           G_CALLBACK (ev_window_inverted_colors_changed_cb),
6331                           ev_window);
6332
6333         /* Connect sidebar signals */
6334         g_signal_connect (ev_window->priv->sidebar,
6335                           "notify::visible",
6336                           G_CALLBACK (ev_window_sidebar_visibility_changed_cb),
6337                           ev_window);
6338         g_signal_connect (ev_window->priv->sidebar,
6339                           "notify::current-page",
6340                           G_CALLBACK (ev_window_sidebar_current_page_changed_cb),
6341                           ev_window);
6342
6343         /* Connect to find bar signals */
6344         g_signal_connect (ev_window->priv->find_bar,
6345                           "previous",
6346                           G_CALLBACK (find_bar_previous_cb),
6347                           ev_window);
6348         g_signal_connect (ev_window->priv->find_bar,
6349                           "next",
6350                           G_CALLBACK (find_bar_next_cb),
6351                           ev_window);
6352         g_signal_connect (ev_window->priv->find_bar,
6353                           "close",
6354                           G_CALLBACK (find_bar_close_cb),
6355                           ev_window);
6356         g_signal_connect (ev_window->priv->find_bar,
6357                           "notify::search-string",
6358                           G_CALLBACK (find_bar_search_changed_cb),
6359                           ev_window);
6360         g_signal_connect (ev_window->priv->find_bar,
6361                           "notify::case-sensitive",
6362                           G_CALLBACK (find_bar_search_changed_cb),
6363                           ev_window);
6364         g_signal_connect (ev_window->priv->find_bar,
6365                           "notify::visible",
6366                           G_CALLBACK (find_bar_visibility_changed_cb),
6367                           ev_window);
6368         g_signal_connect (ev_window->priv->find_bar,
6369                           "scroll",
6370                           G_CALLBACK (find_bar_scroll),
6371                           ev_window);
6372
6373         /* Popups */
6374         ev_window->priv->view_popup = gtk_ui_manager_get_widget (ev_window->priv->ui_manager,
6375                                                                  "/DocumentPopup");
6376         ev_window->priv->link = NULL;
6377
6378         ev_window->priv->attachment_popup = gtk_ui_manager_get_widget (ev_window->priv->ui_manager,
6379                                                                        "/AttachmentPopup");
6380         ev_window->priv->attach_list = NULL;
6381
6382         /* Media player keys */
6383         mpkeys = ev_application_get_media_keys (EV_APP);
6384         if (mpkeys) {
6385                 g_signal_connect_swapped (mpkeys, "key_pressed",
6386                                           G_CALLBACK (ev_window_media_player_key_pressed),
6387                                           ev_window);
6388         }
6389
6390         /* Give focus to the document view */
6391         gtk_widget_grab_focus (ev_window->priv->view);
6392
6393         /* Set it user interface params */
6394         ev_window_setup_recent (ev_window);
6395
6396         ev_window_setup_gtk_settings (ev_window);
6397
6398         setup_chrome_from_metadata (ev_window);
6399         set_chrome_actions (ev_window);
6400         update_chrome_visibility (ev_window);
6401
6402         gtk_window_set_default_size (GTK_WINDOW (ev_window), 600, 600);
6403
6404         setup_view_from_metadata (ev_window);
6405         setup_sidebar_from_metadata (ev_window);
6406
6407         ev_window_sizing_mode_changed_cb (ev_window->priv->model, NULL, ev_window);
6408         ev_window_setup_action_sensitivity (ev_window);
6409
6410         /* Drag and Drop */
6411         gtk_drag_dest_set (GTK_WIDGET (ev_window),
6412                            GTK_DEST_DEFAULT_ALL,
6413                            NULL, 0,
6414                            GDK_ACTION_COPY);
6415         gtk_drag_dest_add_uri_targets (GTK_WIDGET (ev_window));
6416 }
6417
6418 /**
6419  * ev_window_new:
6420  *
6421  * Creates a #GtkWidget that represents the window.
6422  *
6423  * Returns: the #GtkWidget that represents the window.
6424  */
6425 GtkWidget *
6426 ev_window_new (void)
6427 {
6428         GtkWidget *ev_window;
6429
6430         ev_window = GTK_WIDGET (g_object_new (EV_TYPE_WINDOW,
6431                                               "type", GTK_WINDOW_TOPLEVEL,
6432                                               NULL));
6433
6434         return ev_window;
6435 }