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