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