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