shell/ev-window.c

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