]> www.fi.muni.cz Git - evince.git/blobdiff - shell/ev-window.c
Show progress information when loading/saving remote files. Fixes bug
[evince.git] / shell / ev-window.c
index b44b338472a22bd204ef05e346ba423d30e8d798..97858d7e37835d0f1bad7bd7a45f8e4faf07bc5b 100644 (file)
@@ -1,6 +1,7 @@
 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; c-indent-level: 8 -*- */
 /* this file is part of evince, a gnome document viewer
  *
 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; c-indent-level: 8 -*- */
 /* this file is part of evince, a gnome document viewer
  *
+ *  Copyright (C) 2008 Carlos Garcia Campos
  *  Copyright (C) 2004 Martin Kretzschmar
  *  Copyright (C) 2004 Red Hat, Inc.
  *  Copyright (C) 2000, 2001, 2002, 2003, 2004 Marco Pesenti Gritti
  *  Copyright (C) 2004 Martin Kretzschmar
  *  Copyright (C) 2004 Red Hat, Inc.
  *  Copyright (C) 2000, 2001, 2002, 2003, 2004 Marco Pesenti Gritti
 #include "config.h"
 #endif
 
 #include "config.h"
 #endif
 
-#include "ev-window.h"
-#include "ev-window-title.h"
-#include "ev-navigation-action.h"
-#include "ev-page-action.h"
-#include "ev-open-recent-action.h"
-#include "ev-sidebar.h"
-#include "ev-sidebar-links.h"
-#include "ev-sidebar-attachments.h"
-#include "ev-sidebar-thumbnails.h"
-#include "ev-view.h"
-#include "ev-password.h"
-#include "ev-password-view.h"
-#include "ev-properties-dialog.h"
-#include "ev-file-exporter.h"
-#include "ev-document-thumbnails.h"
-#include "ev-document-links.h"
-#include "ev-document-fonts.h"
-#include "ev-document-find.h"
-#include "ev-document-images.h"
-#include "ev-document-security.h"
-#include "ev-document-factory.h"
-#include "ev-job-queue.h"
-#include "ev-jobs.h"
-#include "ev-sidebar-page.h"
-#include "eggfindbar.h"
-#include "egg-toolbar-editor.h"
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <glib/gstdio.h>
+#include <glib/gi18n.h>
+#include <gio/gio.h>
+#include <gtk/gtk.h>
+#if GTK_CHECK_VERSION (2, 14, 0)
+#include <gtk/gtkunixprint.h>
+#else
+#include <gtk/gtkprintunixdialog.h>
+#endif
+#include <gconf/gconf-client.h>
+
 #include "egg-editable-toolbar.h"
 #include "egg-editable-toolbar.h"
+#include "egg-toolbar-editor.h"
 #include "egg-toolbars-model.h"
 #include "egg-toolbars-model.h"
-#include "ephy-zoom.h"
+
+#include "eggfindbar.h"
+
 #include "ephy-zoom-action.h"
 #include "ephy-zoom-action.h"
+#include "ephy-zoom.h"
+
 #include "ev-application.h"
 #include "ev-application.h"
-#include "ev-stock-icons.h"
-#include "ev-metadata-manager.h"
+#include "ev-document-factory.h"
+#include "ev-document-find.h"
+#include "ev-document-fonts.h"
+#include "ev-document-images.h"
+#include "ev-document-links.h"
+#include "ev-document-thumbnails.h"
+#include "ev-file-exporter.h"
 #include "ev-file-helpers.h"
 #include "ev-file-helpers.h"
-#include "ev-utils.h"
+#include "ev-file-monitor.h"
 #include "ev-history.h"
 #include "ev-image.h"
 #include "ev-history.h"
 #include "ev-image.h"
+#include "ev-job-scheduler.h"
+#include "ev-jobs.h"
 #include "ev-message-area.h"
 #include "ev-message-area.h"
+#include "ev-metadata-manager.h"
+#include "ev-mount-operation.h"
+#include "ev-navigation-action.h"
+#include "ev-open-recent-action.h"
+#include "ev-page-action.h"
+#include "ev-password-view.h"
+#include "ev-properties-dialog.h"
+#include "ev-sidebar-attachments.h"
+#include "ev-sidebar.h"
+#include "ev-sidebar-links.h"
+#include "ev-sidebar-page.h"
+#include "ev-sidebar-thumbnails.h"
+#include "ev-sidebar-layers.h"
+#include "ev-stock-icons.h"
+#include "ev-utils.h"
+#include "ev-keyring.h"
+#include "ev-view.h"
+#include "ev-window.h"
+#include "ev-window-title.h"
+#include "ev-print-operation.h"
+#include "ev-progress-message-area.h"
 
 
-#ifdef WITH_GNOME_PRINT
-#include "ev-print-job.h"
-#include <libgnomeprintui/gnome-print-dialog.h>
-#endif
-
-#ifdef WITH_GTK_PRINT
-#include <gtk/gtkprintunixdialog.h>
-#endif
+#ifdef ENABLE_DBUS
+#include "ev-media-player-keys.h"
+#endif /* ENABLE_DBUS */
 
 #ifdef ENABLE_PDF
 #include <poppler.h>
 #endif
 
 
 #ifdef ENABLE_PDF
 #include <poppler.h>
 #endif
 
-#include <glib/gstdio.h>
-#include <glib/gi18n.h>
-#include <gtk/gtk.h>
-#include <gio/gio.h>
-#include <gconf/gconf-client.h>
-
-#include <errno.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
 typedef enum {
        PAGE_MODE_DOCUMENT,
        PAGE_MODE_PASSWORD
 typedef enum {
        PAGE_MODE_DOCUMENT,
        PAGE_MODE_PASSWORD
@@ -107,6 +115,12 @@ typedef enum {
        EV_CHROME_NORMAL        = EV_CHROME_MENUBAR | EV_CHROME_TOOLBAR | EV_CHROME_SIDEBAR
 } EvChrome;
 
        EV_CHROME_NORMAL        = EV_CHROME_MENUBAR | EV_CHROME_TOOLBAR | EV_CHROME_SIDEBAR
 } EvChrome;
 
+typedef enum {
+       EV_SAVE_DOCUMENT,
+       EV_SAVE_ATTACHMENT,
+       EV_SAVE_IMAGE
+} EvSaveType;
+
 struct _EvWindowPrivate {
        /* UI */
        EvChrome chrome;
 struct _EvWindowPrivate {
        /* UI */
        EvChrome chrome;
@@ -125,13 +139,15 @@ struct _EvWindowPrivate {
        GtkWidget *sidebar_thumbs;
        GtkWidget *sidebar_links;
        GtkWidget *sidebar_attachments;
        GtkWidget *sidebar_thumbs;
        GtkWidget *sidebar_links;
        GtkWidget *sidebar_attachments;
+       GtkWidget *sidebar_layers;
+
+       /* Progress Messages */
+       guint progress_idle;
+       GCancellable *progress_cancellable;
 
        /* Dialogs */
        GtkWidget *properties;
 
        /* Dialogs */
        GtkWidget *properties;
-#ifdef WITH_PRINT
        GtkWidget *print_dialog;
        GtkWidget *print_dialog;
-#endif
-       GtkWidget *password_dialog;
 
        /* UI Builders */
        GtkActionGroup   *action_group;
 
        /* UI Builders */
        GtkActionGroup   *action_group;
@@ -163,10 +179,13 @@ struct _EvWindowPrivate {
 
        /* Document */
        char *uri;
 
        /* Document */
        char *uri;
+       glong uri_mtime;
        char *local_uri;
        EvLinkDest *dest;
        gboolean unlink_temp_file;
        gboolean in_reload;
        char *local_uri;
        EvLinkDest *dest;
        gboolean unlink_temp_file;
        gboolean in_reload;
+       EvFileMonitor *monitor;
+       guint setup_document_idle;
        
        EvDocument *document;
        EvHistory *history;
        
        EvDocument *document;
        EvHistory *history;
@@ -174,21 +193,18 @@ struct _EvWindowPrivate {
        EvWindowPageMode page_mode;
        EvWindowTitle *title;
 
        EvWindowPageMode page_mode;
        EvWindowTitle *title;
 
-       EvJob *load_job;
-       EvJob *thumbnail_job;
-       EvJob *save_job;
-#ifdef WITH_GNOME_PRINT
-       GnomePrintJob *print_job;
-#endif
+       EvJob            *load_job;
+       EvJob            *reload_job;
+       EvJob            *thumbnail_job;
+       EvJob            *save_job;
+       EvJob            *find_job;
 
 
-#ifdef WITH_GTK_PRINT
-       EvJob            *print_job;
-       gboolean          print_preview;
-       GtkPrintJob      *gtk_print_job;
+       /* Printing */
+       GQueue           *print_queue;
        GtkPrinter       *printer;
        GtkPrintSettings *print_settings;
        GtkPageSetup     *print_page_setup;
        GtkPrinter       *printer;
        GtkPrintSettings *print_settings;
        GtkPageSetup     *print_page_setup;
-#endif
+       gboolean          close_after_print;
 };
 
 #define EV_WINDOW_GET_PRIVATE(object) \
 };
 
 #define EV_WINDOW_GET_PRIVATE(object) \
@@ -208,8 +224,8 @@ struct _EvWindowPrivate {
 #define LINKS_SIDEBAR_ID "links"
 #define THUMBNAILS_SIDEBAR_ID "thumbnails"
 #define ATTACHMENTS_SIDEBAR_ID "attachments"
 #define LINKS_SIDEBAR_ID "links"
 #define THUMBNAILS_SIDEBAR_ID "thumbnails"
 #define ATTACHMENTS_SIDEBAR_ID "attachments"
+#define LAYERS_SIDEBAR_ID "layers"
 
 
-#ifdef WITH_GTK_PRINT
 static const gchar *document_print_settings[] = {
        GTK_PRINT_SETTINGS_N_COPIES,
        GTK_PRINT_SETTINGS_COLLATE,
 static const gchar *document_print_settings[] = {
        GTK_PRINT_SETTINGS_N_COPIES,
        GTK_PRINT_SETTINGS_COLLATE,
@@ -218,9 +234,9 @@ static const gchar *document_print_settings[] = {
        GTK_PRINT_SETTINGS_SCALE,
        GTK_PRINT_SETTINGS_PRINT_PAGES,
        GTK_PRINT_SETTINGS_PAGE_RANGES,
        GTK_PRINT_SETTINGS_SCALE,
        GTK_PRINT_SETTINGS_PRINT_PAGES,
        GTK_PRINT_SETTINGS_PAGE_RANGES,
-       GTK_PRINT_SETTINGS_PAGE_SET
+       GTK_PRINT_SETTINGS_PAGE_SET,
+       GTK_PRINT_SETTINGS_OUTPUT_URI
 };
 };
-#endif /* WITH_GTK_PRINT */
 
 static void    ev_window_update_actions                (EvWindow         *ev_window);
 static void     ev_window_sidebar_visibility_changed_cb (EvSidebar        *ev_sidebar,
 
 static void    ev_window_update_actions                (EvWindow         *ev_window);
 static void     ev_window_sidebar_visibility_changed_cb (EvSidebar        *ev_sidebar,
@@ -228,15 +244,14 @@ static void     ev_window_sidebar_visibility_changed_cb (EvSidebar        *ev_si
                                                         EvWindow         *ev_window);
 static void     ev_window_set_page_mode                 (EvWindow         *window,
                                                         EvWindowPageMode  page_mode);
                                                         EvWindow         *ev_window);
 static void     ev_window_set_page_mode                 (EvWindow         *window,
                                                         EvWindowPageMode  page_mode);
-static void    ev_window_load_job_cb                   (EvJobLoad        *job,
+static void    ev_window_load_job_cb                   (EvJob            *job,
                                                         gpointer          data);
                                                         gpointer          data);
+static void     ev_window_reload_document               (EvWindow         *window);
+static void     ev_window_reload_job_cb                 (EvJob            *job,
+                                                        EvWindow         *window);
 static void     ev_window_set_icon_from_thumbnail       (EvJobThumbnail   *job,
                                                         EvWindow         *ev_window);
 static void     ev_window_set_icon_from_thumbnail       (EvJobThumbnail   *job,
                                                         EvWindow         *ev_window);
-#ifdef WITH_GTK_PRINT
-static void     ev_window_print_job_cb                  (EvJobPrint       *job,
-                                                        EvWindow         *window);
-#endif
-static void     ev_window_save_job_cb                   (EvJobSave        *save,
+static void     ev_window_save_job_cb                   (EvJob            *save,
                                                         EvWindow         *window);
 static void     ev_window_sizing_mode_changed_cb        (EvView           *view,
                                                         GParamSpec       *pspec,
                                                         EvWindow         *window);
 static void     ev_window_sizing_mode_changed_cb        (EvView           *view,
                                                         GParamSpec       *pspec,
@@ -247,11 +262,13 @@ static void     ev_window_zoom_changed_cb                 (EvView           *view,
 static void     ev_window_add_recent                    (EvWindow         *window,
                                                         const char       *filename);
 static void     ev_window_run_fullscreen                (EvWindow         *window);
 static void     ev_window_add_recent                    (EvWindow         *window,
                                                         const char       *filename);
 static void     ev_window_run_fullscreen                (EvWindow         *window);
-static void     ev_window_stop_fullscreen               (EvWindow         *window);
+static void     ev_window_stop_fullscreen               (EvWindow         *window,
+                                                        gboolean          unfullscreen_window);
 static void     ev_window_cmd_view_fullscreen           (GtkAction        *action,
                                                         EvWindow         *window);
 static void     ev_window_run_presentation              (EvWindow         *window);
 static void     ev_window_cmd_view_fullscreen           (GtkAction        *action,
                                                         EvWindow         *window);
 static void     ev_window_run_presentation              (EvWindow         *window);
-static void     ev_window_stop_presentation             (EvWindow         *window);
+static void     ev_window_stop_presentation             (EvWindow         *window,
+                                                        gboolean          unfullscreen_window);
 static void     ev_window_cmd_view_presentation         (GtkAction        *action,
                                                         EvWindow         *window);
 static void     ev_window_run_preview                   (EvWindow         *window);
 static void     ev_window_cmd_view_presentation         (GtkAction        *action,
                                                         EvWindow         *window);
 static void     ev_window_run_preview                   (EvWindow         *window);
@@ -276,11 +293,19 @@ static void       ev_window_cmd_view_page_width           (GtkAction        *action,
 static void    view_handle_link_cb                     (EvView           *view, 
                                                         EvLink           *link, 
                                                         EvWindow         *window);
 static void    view_handle_link_cb                     (EvView           *view, 
                                                         EvLink           *link, 
                                                         EvWindow         *window);
+static void     ev_window_update_find_status_message    (EvWindow         *ev_window);
 static void     ev_window_cmd_edit_find                 (GtkAction        *action,
                                                         EvWindow         *ev_window);
 static void     find_bar_search_changed_cb              (EggFindBar       *find_bar,
                                                         GParamSpec       *param,
                                                         EvWindow         *ev_window);
 static void     ev_window_cmd_edit_find                 (GtkAction        *action,
                                                         EvWindow         *ev_window);
 static void     find_bar_search_changed_cb              (EggFindBar       *find_bar,
                                                         GParamSpec       *param,
                                                         EvWindow         *ev_window);
+static void     ev_window_do_preview_print              (EvWindow         *window);
+static void     ev_window_load_file_remote              (EvWindow         *ev_window,
+                                                        GFile            *source_file);
+static void     ev_window_media_player_key_pressed      (EvWindow         *window,
+                                                        const gchar      *key,
+                                                        gpointer          user_data);
+static void     ev_window_save_print_page_setup         (EvWindow         *window);
 
 G_DEFINE_TYPE (EvWindow, ev_window, GTK_TYPE_WINDOW)
 
 
 G_DEFINE_TYPE (EvWindow, ev_window, GTK_TYPE_WINDOW)
 
@@ -353,24 +378,13 @@ ev_window_setup_action_sensitivity (EvWindow *ev_window)
        if (gconf_client_get_bool (client, GCONF_LOCKDOWN_PRINT, NULL)) {
                ok_to_print = FALSE;
        }
        if (gconf_client_get_bool (client, GCONF_LOCKDOWN_PRINT, NULL)) {
                ok_to_print = FALSE;
        }
-#ifndef WITH_PRINT
-       ok_to_print = FALSE;
-#endif
-       g_object_unref (client);
 
 
+       g_object_unref (client);
 
        /* File menu */
        ev_window_set_action_sensitive (ev_window, "FileOpenCopy", has_document);
        ev_window_set_action_sensitive (ev_window, "FileSaveAs", has_document && ok_to_copy);
 
        /* File menu */
        ev_window_set_action_sensitive (ev_window, "FileOpenCopy", has_document);
        ev_window_set_action_sensitive (ev_window, "FileSaveAs", has_document && ok_to_copy);
-
-#ifdef WITH_GTK_PRINT
        ev_window_set_action_sensitive (ev_window, "FilePrintSetup", has_pages && ok_to_print);
        ev_window_set_action_sensitive (ev_window, "FilePrintSetup", has_pages && ok_to_print);
-#endif
-
-#ifdef WITH_GNOME_PRINT
-       ev_window_set_action_sensitive (ev_window, "FilePrintSetup", FALSE);
-#endif
-       
        ev_window_set_action_sensitive (ev_window, "FilePrint", has_pages && ok_to_print);
        ev_window_set_action_sensitive (ev_window, "FileProperties", has_document && has_properties);
 
        ev_window_set_action_sensitive (ev_window, "FilePrint", has_pages && ok_to_print);
        ev_window_set_action_sensitive (ev_window, "FileProperties", has_document && has_properties);
 
@@ -405,6 +419,7 @@ ev_window_update_actions (EvWindow *ev_window)
        int n_pages = 0, page = -1;
        gboolean has_pages = FALSE;
        gboolean presentation_mode;
        int n_pages = 0, page = -1;
        gboolean has_pages = FALSE;
        gboolean presentation_mode;
+       gboolean can_find_in_page = FALSE;
 
        if (ev_window->priv->document && ev_window->priv->page_cache) {
                page = ev_page_cache_get_current_page (ev_window->priv->page_cache);
 
        if (ev_window->priv->document && ev_window->priv->page_cache) {
                page = ev_page_cache_get_current_page (ev_window->priv->page_cache);
@@ -412,13 +427,16 @@ ev_window_update_actions (EvWindow *ev_window)
                has_pages = n_pages > 0;
        }
 
                has_pages = n_pages > 0;
        }
 
+       can_find_in_page = (ev_window->priv->find_job &&
+                           ev_job_find_has_results (EV_JOB_FIND (ev_window->priv->find_job)));
+
        ev_window_set_action_sensitive (ev_window, "EditCopy",
                                        has_pages &&
                                        ev_view_get_has_selection (view));
        ev_window_set_action_sensitive (ev_window, "EditFindNext",
        ev_window_set_action_sensitive (ev_window, "EditCopy",
                                        has_pages &&
                                        ev_view_get_has_selection (view));
        ev_window_set_action_sensitive (ev_window, "EditFindNext",
-                                       ev_view_can_find_next (view));
+                                       has_pages && can_find_in_page);
        ev_window_set_action_sensitive (ev_window, "EditFindPrevious",
        ev_window_set_action_sensitive (ev_window, "EditFindPrevious",
-                                       ev_view_can_find_previous (view));
+                                       has_pages && can_find_in_page);
 
        presentation_mode = ev_view_get_presentation (view);
        
 
        presentation_mode = ev_view_get_presentation (view);
        
@@ -646,39 +664,74 @@ ev_window_set_message_area (EvWindow  *window,
 }
 
 static void
 }
 
 static void
-ev_window_error_message_response_cb (EvMessageArea *area,
-                                    gint           response_id,
-                                    EvWindow      *window)
+ev_window_message_area_response_cb (EvMessageArea *area,
+                                   gint           response_id,
+                                   EvWindow      *window)
 {
        ev_window_set_message_area (window, NULL);
 }
 
 static void
 {
        ev_window_set_message_area (window, NULL);
 }
 
 static void
-ev_window_error_message (GtkWindow *window, const gchar *msg, GError *error)
+ev_window_error_message (EvWindow    *window,
+                        GError      *error,
+                        const gchar *format,
+                        ...)
 {
        GtkWidget *area;
 {
        GtkWidget *area;
+       va_list    args;
+       gchar     *msg = NULL;
 
 
-       if (EV_WINDOW (window)->priv->message_area)
+       if (window->priv->message_area)
                return;
 
                return;
 
+       va_start (args, format);
+       msg = g_strdup_vprintf (format, args);
+       va_end (args);
+       
        area = ev_message_area_new (GTK_MESSAGE_ERROR,
                                    msg,
                                    GTK_STOCK_CLOSE,
        area = ev_message_area_new (GTK_MESSAGE_ERROR,
                                    msg,
                                    GTK_STOCK_CLOSE,
-                                   GTK_RESPONSE_CANCEL,
+                                   GTK_RESPONSE_CLOSE,
                                    NULL);
                                    NULL);
+       g_free (msg);
+       
        if (error)
                ev_message_area_set_secondary_text (EV_MESSAGE_AREA (area), error->message);
        g_signal_connect (area, "response",
        if (error)
                ev_message_area_set_secondary_text (EV_MESSAGE_AREA (area), error->message);
        g_signal_connect (area, "response",
-                         G_CALLBACK (ev_window_error_message_response_cb),
+                         G_CALLBACK (ev_window_message_area_response_cb),
                          window);
        gtk_widget_show (area);
                          window);
        gtk_widget_show (area);
-       ev_window_set_message_area (EV_WINDOW (window), area);
+       ev_window_set_message_area (window, area);
 }
 
 static void
 }
 
 static void
-find_changed_cb (EvDocument *document, int page, EvWindow *ev_window)
+ev_window_warning_message (EvWindow    *window,
+                          const gchar *format,
+                          ...)
 {
 {
-       ev_window_update_actions (ev_window);
+       GtkWidget *area;
+       va_list    args;
+       gchar     *msg = NULL;
+
+       if (window->priv->message_area)
+               return;
+
+       va_start (args, format);
+       msg = g_strdup_vprintf (format, args);
+       va_end (args);
+
+       area = ev_message_area_new (GTK_MESSAGE_WARNING,
+                                   msg,
+                                   GTK_STOCK_CLOSE,
+                                   GTK_RESPONSE_CLOSE,
+                                   NULL);
+       g_free (msg);
+       
+       g_signal_connect (area, "response",
+                         G_CALLBACK (ev_window_message_area_response_cb),
+                         window);
+       gtk_widget_show (area);
+       ev_window_set_message_area (window, area);
 }
 
 static void
 }
 
 static void
@@ -687,7 +740,9 @@ page_changed_cb (EvPageCache *page_cache,
                 EvWindow    *ev_window)
 {
        ev_window_update_actions (ev_window);
                 EvWindow    *ev_window)
 {
        ev_window_update_actions (ev_window);
-       
+
+       ev_window_update_find_status_message (ev_window);
+
        if (!ev_window_is_empty (ev_window))
                ev_metadata_manager_set_int (ev_window->priv->uri, "page", page);
 }
        if (!ev_window_is_empty (ev_window))
                ev_metadata_manager_set_int (ev_window->priv->uri, "page", page);
 }
@@ -865,6 +920,7 @@ setup_sidebar_from_metadata (EvWindow *window, EvDocument *document)
        GtkWidget *links = window->priv->sidebar_links;
        GtkWidget *thumbs = window->priv->sidebar_thumbs;
        GtkWidget *attachments = window->priv->sidebar_attachments;
        GtkWidget *links = window->priv->sidebar_links;
        GtkWidget *thumbs = window->priv->sidebar_thumbs;
        GtkWidget *attachments = window->priv->sidebar_attachments;
+       GtkWidget *layers = window->priv->sidebar_layers;
        GValue sidebar_size = { 0, };
        GValue sidebar_page = { 0, };
        GValue sidebar_visibility = { 0, };
        GValue sidebar_size = { 0, };
        GValue sidebar_page = { 0, };
        GValue sidebar_visibility = { 0, };
@@ -875,19 +931,29 @@ setup_sidebar_from_metadata (EvWindow *window, EvDocument *document)
                g_value_unset(&sidebar_size);
        }
        
                g_value_unset(&sidebar_size);
        }
        
-       if (document && ev_metadata_manager_get (uri, "sidebar_page", &sidebar_page, FALSE)) {
+       if (document && ev_metadata_manager_get (uri, "sidebar_page", &sidebar_page, TRUE)) {
                const char *page_id = g_value_get_string (&sidebar_page);
                const char *page_id = g_value_get_string (&sidebar_page);
-               
+
                if (strcmp (page_id, LINKS_SIDEBAR_ID) == 0 && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (links), document)) {
                        ev_sidebar_set_page (EV_SIDEBAR (sidebar), links);
                if (strcmp (page_id, LINKS_SIDEBAR_ID) == 0 && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (links), document)) {
                        ev_sidebar_set_page (EV_SIDEBAR (sidebar), links);
-               } else if (strcmp (page_id, THUMBNAILS_SIDEBAR_ID) && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (thumbs), document)) {
+               } else if (strcmp (page_id, THUMBNAILS_SIDEBAR_ID) == 0 && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (thumbs), document)) {
                        ev_sidebar_set_page (EV_SIDEBAR (sidebar), thumbs);
                        ev_sidebar_set_page (EV_SIDEBAR (sidebar), thumbs);
-               } else if (strcmp (page_id, ATTACHMENTS_SIDEBAR_ID) && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (attachments), document)) {
+               } else if (strcmp (page_id, ATTACHMENTS_SIDEBAR_ID) == 0 && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (attachments), document)) {
                        ev_sidebar_set_page (EV_SIDEBAR (sidebar), attachments);
                        ev_sidebar_set_page (EV_SIDEBAR (sidebar), attachments);
+               } else if (strcmp (page_id, LAYERS_SIDEBAR_ID) == 0 && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (layers), document)) {
+                       ev_sidebar_set_page (EV_SIDEBAR (sidebar), layers);
                }
                g_value_unset (&sidebar_page);
                }
                g_value_unset (&sidebar_page);
-       } else if (document && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (links), document)) {
-               ev_sidebar_set_page (EV_SIDEBAR (sidebar), links);
+       } else if (document) {
+               if (ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (links), document)) {
+                       ev_sidebar_set_page (EV_SIDEBAR (sidebar), links);
+               } else if (ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (thumbs), document)) {
+                       ev_sidebar_set_page (EV_SIDEBAR (sidebar), thumbs);
+               } else if (ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (attachments), document)) {
+                       ev_sidebar_set_page (EV_SIDEBAR (sidebar), attachments);
+               } else if (ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (layers), document)) {
+                       ev_sidebar_set_page (EV_SIDEBAR (sidebar), layers);
+               }
        }
 
        if (ev_metadata_manager_get (uri, "sidebar_visibility", &sidebar_visibility, FALSE)) {
        }
 
        if (ev_metadata_manager_get (uri, "sidebar_visibility", &sidebar_visibility, FALSE)) {
@@ -912,6 +978,7 @@ setup_size_from_metadata (EvWindow *window)
        if (ev_metadata_manager_get (uri, "window_maximized", &maximized, FALSE)) {
                if (g_value_get_boolean (&maximized)) {
                        gtk_window_maximize (GTK_WINDOW (window));
        if (ev_metadata_manager_get (uri, "window_maximized", &maximized, FALSE)) {
                if (g_value_get_boolean (&maximized)) {
                        gtk_window_maximize (GTK_WINDOW (window));
+                       g_value_unset (&maximized);
                        return;
                } else {
                        gtk_window_unmaximize (GTK_WINDOW (window));
                        return;
                } else {
                        gtk_window_unmaximize (GTK_WINDOW (window));
@@ -1071,8 +1138,9 @@ static void
 ev_window_clear_thumbnail_job (EvWindow *ev_window)
 {
        if (ev_window->priv->thumbnail_job != NULL) {
 ev_window_clear_thumbnail_job (EvWindow *ev_window)
 {
        if (ev_window->priv->thumbnail_job != NULL) {
-               ev_job_queue_remove_job (ev_window->priv->thumbnail_job);
-
+               if (!ev_job_is_finished (ev_window->priv->thumbnail_job))
+                       ev_job_cancel (ev_window->priv->thumbnail_job);
+               
                g_signal_handlers_disconnect_by_func (ev_window->priv->thumbnail_job,
                                                      ev_window_set_icon_from_thumbnail,
                                                      ev_window);
                g_signal_handlers_disconnect_by_func (ev_window->priv->thumbnail_job,
                                                      ev_window_set_icon_from_thumbnail,
                                                      ev_window);
@@ -1096,13 +1164,12 @@ ev_window_set_icon_from_thumbnail (EvJobThumbnail *job,
 static void
 ev_window_refresh_window_thumbnail (EvWindow *ev_window, int rotation)
 {
 static void
 ev_window_refresh_window_thumbnail (EvWindow *ev_window, int rotation)
 {
-       
-       EvRenderContext *rc;
        gint page_width, page_height;
        gdouble scale;
        EvDocument *document = ev_window->priv->document;
        
        gint page_width, page_height;
        gdouble scale;
        EvDocument *document = ev_window->priv->document;
        
-       if (!EV_IS_DOCUMENT_THUMBNAILS (document)) {
+       if (!EV_IS_DOCUMENT_THUMBNAILS (document) ||
+           ev_page_cache_get_n_pages (ev_window->priv->page_cache) <= 0) {
                return;
        }
        
                return;
        }
        
@@ -1113,14 +1180,11 @@ ev_window_refresh_window_thumbnail (EvWindow *ev_window, int rotation)
                                &page_width, &page_height);
        scale = (gdouble)128 / (gdouble)page_width;
        
                                &page_width, &page_height);
        scale = (gdouble)128 / (gdouble)page_width;
        
-       rc = ev_render_context_new (rotation, 0, scale);
-       
-       ev_window->priv->thumbnail_job = ev_job_thumbnail_new (document, rc);
+       ev_window->priv->thumbnail_job = ev_job_thumbnail_new (document, 0, rotation, scale);
        g_signal_connect (ev_window->priv->thumbnail_job, "finished",
                          G_CALLBACK (ev_window_set_icon_from_thumbnail),
                          ev_window);
        g_signal_connect (ev_window->priv->thumbnail_job, "finished",
                          G_CALLBACK (ev_window_set_icon_from_thumbnail),
                          ev_window);
-       ev_job_queue_add_job (EV_JOB (ev_window->priv->thumbnail_job), EV_JOB_PRIORITY_LOW);
-       g_object_unref (rc);
+       ev_job_scheduler_push_job (ev_window->priv->thumbnail_job, EV_JOB_PRIORITY_NONE);
 }
 
 static gboolean
 }
 
 static gboolean
@@ -1130,13 +1194,8 @@ ev_window_setup_document (EvWindow *ev_window)
        EvDocument *document = ev_window->priv->document;
        EvSidebar *sidebar = EV_SIDEBAR (ev_window->priv->sidebar);
        GtkAction *action;
        EvDocument *document = ev_window->priv->document;
        EvSidebar *sidebar = EV_SIDEBAR (ev_window->priv->sidebar);
        GtkAction *action;
-       
-       if (EV_IS_DOCUMENT_FIND (document)) {
-               g_signal_connect_object (G_OBJECT (document),
-                                        "find_changed",
-                                        G_CALLBACK (find_changed_cb),  
-                                        ev_window, 0);
-       }
+
+       ev_window->priv->setup_document_idle = 0;
        
        ev_window_refresh_window_thumbnail (ev_window, 0);
 
        
        ev_window_refresh_window_thumbnail (ev_window, 0);
 
@@ -1158,6 +1217,7 @@ ev_window_setup_document (EvWindow *ev_window)
        
        if (ev_window->priv->properties) {
                ev_properties_dialog_set_document (EV_PROPERTIES_DIALOG (ev_window->priv->properties),
        
        if (ev_window->priv->properties) {
                ev_properties_dialog_set_document (EV_PROPERTIES_DIALOG (ev_window->priv->properties),
+                                                  ev_window->priv->uri,
                                                   ev_window->priv->document);
        }
        
                                                   ev_window->priv->document);
        }
        
@@ -1190,81 +1250,41 @@ ev_window_set_document (EvWindow *ev_window, EvDocument *document)
 
        if (ev_page_cache_get_n_pages (ev_window->priv->page_cache) > 0) {
                ev_view_set_document (view, document);
 
        if (ev_page_cache_get_n_pages (ev_window->priv->page_cache) > 0) {
                ev_view_set_document (view, document);
+       } else {
+               ev_window_warning_message (ev_window, "%s",
+                                          _("The document contains no pages"));
        }
 
        }
 
-       g_idle_add ((GSourceFunc)ev_window_setup_document, ev_window);
+       if (ev_window->priv->setup_document_idle > 0)
+               g_source_remove (ev_window->priv->setup_document_idle);
+       ev_window->priv->setup_document_idle = g_idle_add ((GSourceFunc)ev_window_setup_document, ev_window);
 }
 
 static void
 }
 
 static void
-password_dialog_response (GtkWidget *password_dialog,
-                         gint       response_id,
-                         EvWindow  *ev_window)
+ev_window_document_changed (EvWindow *ev_window,
+                           gpointer  user_data)
 {
 {
-       char *password;
-       
-       if (response_id == GTK_RESPONSE_OK) {
-
-               password = ev_password_dialog_get_password (EV_PASSWORD_DIALOG (password_dialog));
-               if (password) {
-                       ev_document_doc_mutex_lock ();
-                       ev_document_security_set_password (EV_DOCUMENT_SECURITY (ev_window->priv->load_job->document),
-                                                          password);
-                       ev_document_doc_mutex_unlock ();
-               }
-               g_free (password);
-
-               ev_password_dialog_save_password (EV_PASSWORD_DIALOG (password_dialog));
-
-               ev_window_title_set_type (ev_window->priv->title, EV_WINDOW_TITLE_DOCUMENT);
-               ev_job_queue_add_job (ev_window->priv->load_job, EV_JOB_PRIORITY_HIGH);
-               
-               gtk_widget_destroy (password_dialog);
-                       
-               return;
-       }
-
-       gtk_widget_set_sensitive (ev_window->priv->password_view, TRUE);
-       gtk_widget_destroy (password_dialog);
+       ev_window_reload_document (ev_window);
 }
 
 }
 
-/* Called either by ev_window_load_job_cb or by the "unlock" callback on the
- * password_view page.  It assumes that ev_window->priv->password_* has been set
- * correctly.  These are cleared by password_dialog_response() */
-
 static void
 static void
-ev_window_popup_password_dialog (EvWindow *ev_window)
+ev_window_password_view_unlock (EvWindow *ev_window)
 {
 {
+       const gchar *password;
+       
        g_assert (ev_window->priv->load_job);
 
        g_assert (ev_window->priv->load_job);
 
-       gtk_widget_set_sensitive (ev_window->priv->password_view, FALSE);
-
-       ev_window_title_set_uri (ev_window->priv->title, ev_window->priv->uri);
-       ev_window_title_set_type (ev_window->priv->title, EV_WINDOW_TITLE_PASSWORD);
-
-       if (ev_window->priv->password_dialog == NULL) {
-               ev_window->priv->password_dialog =
-                       g_object_new (EV_TYPE_PASSWORD_DIALOG, "uri", ev_window->priv->uri, NULL);
-               gtk_window_set_transient_for (GTK_WINDOW (ev_window->priv->password_dialog), GTK_WINDOW (ev_window));
-
-               g_object_add_weak_pointer (G_OBJECT (ev_window->priv->password_dialog),
-                                          (gpointer) &(ev_window->priv->password_dialog));
-               g_signal_connect (ev_window->priv->password_dialog,
-                                 "response",
-                                 G_CALLBACK (password_dialog_response),
-                                 ev_window);
-               gtk_widget_show (ev_window->priv->password_dialog);
-       } else {
-               ev_password_dialog_set_bad_pass (EV_PASSWORD_DIALOG (ev_window->priv->password_dialog));
-       }
+       password = ev_password_view_get_password (EV_PASSWORD_VIEW (ev_window->priv->password_view));
+       ev_job_load_set_password (EV_JOB_LOAD (ev_window->priv->load_job), password);
+       ev_job_scheduler_push_job (ev_window->priv->load_job, EV_JOB_PRIORITY_NONE);
 }
 
 static void
 ev_window_clear_load_job (EvWindow *ev_window)
 {
        if (ev_window->priv->load_job != NULL) {
 }
 
 static void
 ev_window_clear_load_job (EvWindow *ev_window)
 {
        if (ev_window->priv->load_job != NULL) {
-               
-               if (!ev_window->priv->load_job->finished)
-                       ev_job_queue_remove_job (ev_window->priv->load_job);
+               if (!ev_job_is_finished (ev_window->priv->load_job))
+                       ev_job_cancel (ev_window->priv->load_job);
                
                g_signal_handlers_disconnect_by_func (ev_window->priv->load_job, ev_window_load_job_cb, ev_window);
                g_object_unref (ev_window->priv->load_job);
                
                g_signal_handlers_disconnect_by_func (ev_window->priv->load_job, ev_window_load_job_cb, ev_window);
                g_object_unref (ev_window->priv->load_job);
@@ -1272,6 +1292,19 @@ ev_window_clear_load_job (EvWindow *ev_window)
        }
 }
 
        }
 }
 
+static void
+ev_window_clear_reload_job (EvWindow *ev_window)
+{
+       if (ev_window->priv->reload_job != NULL) {
+               if (!ev_job_is_finished (ev_window->priv->reload_job))
+                       ev_job_cancel (ev_window->priv->reload_job);
+               
+               g_signal_handlers_disconnect_by_func (ev_window->priv->reload_job, ev_window_reload_job_cb, ev_window);
+               g_object_unref (ev_window->priv->reload_job);
+               ev_window->priv->reload_job = NULL;
+       }
+}
+
 static void
 ev_window_clear_local_uri (EvWindow *ev_window)
 {
 static void
 ev_window_clear_local_uri (EvWindow *ev_window)
 {
@@ -1303,7 +1336,7 @@ ev_window_clear_temp_file (EvWindow *ev_window)
        file = g_file_new_for_uri (ev_window->priv->uri);
        tempdir = g_file_new_for_path (g_get_tmp_dir ());
 
        file = g_file_new_for_uri (ev_window->priv->uri);
        tempdir = g_file_new_for_path (g_get_tmp_dir ());
 
-       if (g_file_contains_file (tempdir, file)) {
+       if (g_file_has_prefix (file, tempdir)) {
                g_file_delete (file, NULL, NULL);
        }
 
                g_file_delete (file, NULL, NULL);
        }
 
@@ -1320,21 +1353,22 @@ ev_window_clear_temp_file (EvWindow *ev_window)
  * function should _not_ necessarily expect those to exist after being
  * called. */
 static void
  * function should _not_ necessarily expect those to exist after being
  * called. */
 static void
-ev_window_load_job_cb  (EvJobLoad *job,
-                       gpointer data)
+ev_window_load_job_cb (EvJob *job,
+                      gpointer data)
 {
        EvWindow *ev_window = EV_WINDOW (data);
        EvDocument *document = EV_JOB (job)->document;
 {
        EvWindow *ev_window = EV_WINDOW (data);
        EvDocument *document = EV_JOB (job)->document;
+       EvJobLoad *job_load = EV_JOB_LOAD (job);
+
+       g_assert (job_load->uri);
 
 
-       g_assert (job->uri);
-       
        ev_view_set_loading (EV_VIEW (ev_window->priv->view), FALSE);
 
        /* Success! */
        ev_view_set_loading (EV_VIEW (ev_window->priv->view), FALSE);
 
        /* Success! */
-       if (job->error == NULL) {
+       if (!ev_job_is_failed (job)) {
                ev_window_set_document (ev_window, document);
                
                ev_window_set_document (ev_window, document);
                
-               if (job->mode != EV_WINDOW_MODE_PREVIEW) {
+               if (job_load->mode != EV_WINDOW_MODE_PREVIEW) {
                        setup_view_from_metadata (ev_window);
                }
 
                        setup_view_from_metadata (ev_window);
                }
 
@@ -1342,17 +1376,29 @@ ev_window_load_job_cb  (EvJobLoad *job,
                        ev_window_add_recent (ev_window, ev_window->priv->uri);
                }
 
                        ev_window_add_recent (ev_window, ev_window->priv->uri);
                }
 
-               if (job->dest) {
+               ev_window_title_set_type (ev_window->priv->title,
+                                         EV_WINDOW_TITLE_DOCUMENT);
+               if (job_load->password) {
+                       GPasswordSave flags;
+
+                       flags = ev_password_view_get_password_save_flags (
+                               EV_PASSWORD_VIEW (ev_window->priv->password_view));
+                       ev_keyring_save_password (ev_window->priv->uri,
+                                                 job_load->password,
+                                                 flags);
+               }
+
+               if (job_load->dest) {
                        EvLink *link;
                        EvLinkAction *link_action;
        
                        EvLink *link;
                        EvLinkAction *link_action;
        
-                       link_action = ev_link_action_new_dest (g_object_ref (job->dest));
+                       link_action = ev_link_action_new_dest (g_object_ref (job_load->dest));
                        link = ev_link_new (NULL, link_action);
                        ev_view_handle_link (EV_VIEW (ev_window->priv->view), link);
                        g_object_unref (link);
                }
 
                        link = ev_link_new (NULL, link_action);
                        ev_view_handle_link (EV_VIEW (ev_window->priv->view), link);
                        g_object_unref (link);
                }
 
-               switch (job->mode) {
+               switch (job_load->mode) {
                        case EV_WINDOW_MODE_FULLSCREEN:
                                ev_window_run_fullscreen (ev_window);
                                break;
                        case EV_WINDOW_MODE_FULLSCREEN:
                                ev_window_run_fullscreen (ev_window);
                                break;
@@ -1366,51 +1412,88 @@ ev_window_load_job_cb  (EvJobLoad *job,
                                break;
                }
 
                                break;
                }
 
-               /* Restart the search after reloading */
-               if (ev_window->priv->in_reload) {
-                       GtkWidget *widget;
-                       
-                       widget = gtk_window_get_focus (GTK_WINDOW (ev_window));
-                       if (widget && gtk_widget_get_ancestor (widget, EGG_TYPE_FIND_BAR)) {
-                               find_bar_search_changed_cb (EGG_FIND_BAR (ev_window->priv->find_bar),
-                                                           NULL, ev_window);
-                       }
-               } else if (job->search_string && EV_IS_DOCUMENT_FIND (document)) {
+               if (job_load->search_string && EV_IS_DOCUMENT_FIND (document)) {
                        ev_window_cmd_edit_find (NULL, ev_window);
                        egg_find_bar_set_search_string (EGG_FIND_BAR (ev_window->priv->find_bar),
                        ev_window_cmd_edit_find (NULL, ev_window);
                        egg_find_bar_set_search_string (EGG_FIND_BAR (ev_window->priv->find_bar),
-                                                       job->search_string);
+                                                       job_load->search_string);
                }
 
                }
 
+               /* Create a monitor for the document */
+               ev_window->priv->monitor = ev_file_monitor_new (ev_window->priv->uri);
+               g_signal_connect_swapped (G_OBJECT (ev_window->priv->monitor), "changed",
+                                         G_CALLBACK (ev_window_document_changed),
+                                         ev_window);
+               
                ev_window_clear_load_job (ev_window);
                ev_window_clear_load_job (ev_window);
-               ev_window->priv->in_reload = FALSE;
                return;
        }
 
        if (job->error->domain == EV_DOCUMENT_ERROR &&
            job->error->code == EV_DOCUMENT_ERROR_ENCRYPTED) {
                return;
        }
 
        if (job->error->domain == EV_DOCUMENT_ERROR &&
            job->error->code == EV_DOCUMENT_ERROR_ENCRYPTED) {
-               GFile *file;
-               gchar *base_name;
-
+               gchar *password;
+               
                setup_view_from_metadata (ev_window);
                setup_view_from_metadata (ev_window);
+               
+               /* First look whether password is in keyring */
+               password = ev_keyring_lookup_password (ev_window->priv->uri);
+               if (password) {
+                       if (job_load->password && strcmp (password, job_load->password) == 0) {
+                               /* Password in kering is wrong */
+                               ev_job_load_set_password (job_load, NULL);
+                               /* FIXME: delete password from keyring? */
+                       } else {
+                               ev_job_load_set_password (job_load, password);
+                               ev_job_scheduler_push_job (job, EV_JOB_PRIORITY_NONE);
+                               g_free (password);
+                               return;
+                       }
+
+                       g_free (password);
+               }
+
+               /* We need to ask the user for a password */
+               ev_window_title_set_uri (ev_window->priv->title,
+                                        ev_window->priv->uri);
+               ev_window_title_set_type (ev_window->priv->title,
+                                         EV_WINDOW_TITLE_PASSWORD);
+
+               ev_password_view_set_uri (EV_PASSWORD_VIEW (ev_window->priv->password_view),
+                                         job_load->uri);
 
 
-               file = g_file_new_for_uri (job->uri);
-               base_name = g_file_get_basename (file);
-               ev_password_view_set_file_name (EV_PASSWORD_VIEW (ev_window->priv->password_view),
-                                               base_name);
-               g_object_unref (file);
-               g_free (base_name);
                ev_window_set_page_mode (ev_window, PAGE_MODE_PASSWORD);
                ev_window_set_page_mode (ev_window, PAGE_MODE_PASSWORD);
-               
-               ev_window_popup_password_dialog (ev_window);
+
+               ev_job_load_set_password (job_load, NULL);
+               ev_password_view_ask_password (EV_PASSWORD_VIEW (ev_window->priv->password_view));
        } else {
        } else {
-               ev_window_error_message (GTK_WINDOW (ev_window), 
-                                        _("Unable to open document"),
-                                        job->error);
+               ev_window_error_message (ev_window, job->error, 
+                                        "%s", _("Unable to open document"));
                ev_window_clear_load_job (ev_window);
                ev_window_clear_load_job (ev_window);
-               ev_window->priv->in_reload = FALSE;
        }       
        }       
+}
 
 
-       return;
+static void
+ev_window_reload_job_cb (EvJob    *job,
+                        EvWindow *ev_window)
+{
+       GtkWidget *widget;
+
+       if (ev_job_is_failed (job)) {
+               ev_window_clear_reload_job (ev_window);
+               ev_window->priv->in_reload = FALSE;
+               return;
+       }
+       
+       ev_window_set_document (ev_window, job->document);
+
+       /* Restart the search after reloading */
+       widget = gtk_window_get_focus (GTK_WINDOW (ev_window));
+       if (widget && gtk_widget_get_ancestor (widget, EGG_TYPE_FIND_BAR)) {
+               find_bar_search_changed_cb (EGG_FIND_BAR (ev_window->priv->find_bar),
+                                           NULL, ev_window);
+       }
+       
+       ev_window_clear_reload_job (ev_window);
+       ev_window->priv->in_reload = FALSE;
 }
 
 /**
 }
 
 /**
@@ -1437,21 +1520,9 @@ ev_window_get_uri (EvWindow *ev_window)
 static void
 ev_window_close_dialogs (EvWindow *ev_window)
 {
 static void
 ev_window_close_dialogs (EvWindow *ev_window)
 {
-       if (ev_window->priv->password_dialog)
-               gtk_widget_destroy (ev_window->priv->password_dialog);
-       ev_window->priv->password_dialog = NULL;
-       
-#ifdef WITH_PRINT
        if (ev_window->priv->print_dialog)
                gtk_widget_destroy (ev_window->priv->print_dialog);
        ev_window->priv->print_dialog = NULL;
        if (ev_window->priv->print_dialog)
                gtk_widget_destroy (ev_window->priv->print_dialog);
        ev_window->priv->print_dialog = NULL;
-#endif
-
-#ifdef WITH_GNOME_PRINT
-       if (ev_window->priv->print_job)
-               g_object_unref (ev_window->priv->print_job);
-       ev_window->priv->print_job = NULL;
-#endif
        
        if (ev_window->priv->properties)
                gtk_widget_destroy (ev_window->priv->properties);
        
        if (ev_window->priv->properties)
                gtk_widget_destroy (ev_window->priv->properties);
@@ -1459,86 +1530,466 @@ ev_window_close_dialogs (EvWindow *ev_window)
 }
 
 static void
 }
 
 static void
-window_open_file_copy_ready_cb (GFile        *source,
-                               GAsyncResult *async_result,
-                               EvWindow     *ev_window)
+ev_window_clear_progress_idle (EvWindow *ev_window)
 {
 {
-       g_file_copy_finish (source, async_result, NULL);
-       ev_job_queue_add_job (ev_window->priv->load_job, EV_JOB_PRIORITY_HIGH);
-       g_object_unref (source);
+       if (ev_window->priv->progress_idle > 0)
+               g_source_remove (ev_window->priv->progress_idle);
+       ev_window->priv->progress_idle = 0;
 }
 
 }
 
-void
-ev_window_open_uri (EvWindow       *ev_window,
-                   const char     *uri,
-                   EvLinkDest     *dest,
-                   EvWindowRunMode mode,
-                   const gchar    *search_string, 
-                   gboolean        unlink_temp_file,
-                   const gchar    *print_settings)
+static void
+reset_progress_idle (EvWindow *ev_window)
 {
 {
-       GFile *source_file;
-       GFile *target_file;
-
-       if (ev_window->priv->uri &&
-           g_ascii_strcasecmp (ev_window->priv->uri, uri) == 0) {
-               ev_window->priv->in_reload = TRUE;
-       }
-       
-       ev_window_close_dialogs (ev_window);
-       ev_window_clear_load_job (ev_window);
-       ev_window_clear_local_uri (ev_window);
-       ev_window_clear_print_settings_file (ev_window);
-       ev_view_set_loading (EV_VIEW (ev_window->priv->view), TRUE);
+       ev_window->priv->progress_idle = 0;
+}
 
 
-       ev_window->priv->unlink_temp_file = unlink_temp_file;
+static void
+ev_window_show_progress_message (EvWindow   *ev_window,
+                                guint       interval,
+                                GSourceFunc function)
+{
+       if (ev_window->priv->progress_idle > 0)
+               g_source_remove (ev_window->priv->progress_idle);
+       ev_window->priv->progress_idle =
+               g_timeout_add_seconds_full (G_PRIORITY_DEFAULT,
+                                           interval, function,
+                                           ev_window,
+                                           (GDestroyNotify)reset_progress_idle);
+}
 
 
-       if (mode == EV_WINDOW_MODE_PREVIEW) {
-               ev_window->priv->print_settings_file = print_settings ? 
-                       g_strdup (print_settings) : NULL;
-       }
+static void
+ev_window_reset_progress_cancellable (EvWindow *ev_window)
+{
+       if (ev_window->priv->progress_cancellable)
+               g_cancellable_reset (ev_window->priv->progress_cancellable);
+       else
+               ev_window->priv->progress_cancellable = g_cancellable_new ();
+}
 
 
-       if (ev_window->priv->uri)
-               g_free (ev_window->priv->uri);
-       ev_window->priv->uri = g_strdup (uri);
+static void
+ev_window_progress_response_cb (EvProgressMessageArea *area,
+                               gint                   response,
+                               EvWindow              *ev_window)
+{
+       if (response == GTK_RESPONSE_CANCEL)
+               g_cancellable_cancel (ev_window->priv->progress_cancellable);
+       ev_window_set_message_area (ev_window, NULL);
+}
 
 
-       setup_size_from_metadata (ev_window);
+static gboolean 
+show_loading_progress (EvWindow *ev_window)
+{
+       GtkWidget *area;
+       gchar     *text;
        
        
-       ev_window->priv->load_job = ev_job_load_new (uri, dest, mode, search_string);
-       g_signal_connect (ev_window->priv->load_job,
-                         "finished",
-                         G_CALLBACK (ev_window_load_job_cb),
+       if (ev_window->priv->message_area)
+               return FALSE;
+       
+       text = g_strdup_printf (_("Loading document from %s"),
+                               ev_window->priv->uri);
+       area = ev_progress_message_area_new (GTK_STOCK_OPEN,
+                                            text,
+                                            GTK_STOCK_CLOSE,
+                                            GTK_RESPONSE_CLOSE,
+                                            GTK_STOCK_CANCEL,
+                                            GTK_RESPONSE_CANCEL,
+                                            NULL);
+       g_signal_connect (area, "response",
+                         G_CALLBACK (ev_window_progress_response_cb),
                          ev_window);
                          ev_window);
+       gtk_widget_show (area);
+       ev_window_set_message_area (ev_window, area);
+       g_free (text);
 
 
-       source_file = g_file_new_for_uri (uri);
-       if (!g_file_is_native (source_file) && !ev_window->priv->local_uri) {
-               char *tmp_name;
-               char *base_name;
+       return FALSE;
+}
+
+static void
+ev_window_load_remote_failed (EvWindow *ev_window,
+                             GError   *error)
+{
+       ev_view_set_loading (EV_VIEW (ev_window->priv->view), FALSE);
+       ev_window->priv->in_reload = FALSE;
+       ev_window_error_message (ev_window, error, 
+                                "%s", _("Unable to open document"));
+       g_free (ev_window->priv->local_uri);
+       ev_window->priv->local_uri = NULL;
+       ev_window->priv->uri_mtime = 0;
+}
+
+static void
+set_uri_mtime (GFile        *source,
+              GAsyncResult *async_result,
+              EvWindow     *ev_window)
+{
+       GFileInfo *info;
+       GError *error = NULL;
+
+       info = g_file_query_info_finish (source, async_result, &error);
+
+       if (error) {
+               ev_window->priv->uri_mtime = 0;
+               g_error_free (error);
+       } else {
+               GTimeVal mtime;
+               
+               g_file_info_get_modification_time (info, &mtime);
+               ev_window->priv->uri_mtime = mtime.tv_sec;
+               g_object_unref (info);
+       }
+
+       g_object_unref (source);
+}
+
+static void
+mount_volume_ready_cb (GFile        *source,
+                      GAsyncResult *async_result,
+                      EvWindow     *ev_window)
+{
+       GError *error = NULL;
+
+       g_file_mount_enclosing_volume_finish (source, async_result, &error);
+
+       if (error) {
+               ev_window_load_remote_failed (ev_window, error);
+               g_object_unref (source);
+               g_error_free (error);
+       } else {
+               /* Volume successfully mounted,
+                  try opening the file again */
+               ev_window_load_file_remote (ev_window, source);
+       }
+}
+
+static void
+window_open_file_copy_ready_cb (GFile        *source,
+                               GAsyncResult *async_result,
+                               EvWindow     *ev_window)
+{
+       GError *error = NULL;
+
+       ev_window_clear_progress_idle (ev_window);
+       
+       g_file_copy_finish (source, async_result, &error);
+       if (!error) {
+               ev_job_scheduler_push_job (ev_window->priv->load_job, EV_JOB_PRIORITY_NONE);
+               g_file_query_info_async (source,
+                                        G_FILE_ATTRIBUTE_TIME_MODIFIED,
+                                        0, G_PRIORITY_DEFAULT,
+                                        NULL,
+                                        (GAsyncReadyCallback)set_uri_mtime,
+                                        ev_window);
+               return;
+       }
+
+       if (error->domain == G_IO_ERROR &&
+           error->code == G_IO_ERROR_NOT_MOUNTED) {
+               GMountOperation *operation;
+
+               operation = ev_mount_operation_new (GTK_WINDOW (ev_window));
+               g_file_mount_enclosing_volume (source,
+                                              G_MOUNT_MOUNT_NONE,
+                                              operation, NULL,
+                                              (GAsyncReadyCallback)mount_volume_ready_cb,
+                                              ev_window);
+               g_object_unref (operation);
+       } else if (error->domain == G_IO_ERROR &&
+                  error->code == G_IO_ERROR_CANCELLED) {
+               ev_window_clear_load_job (ev_window);
+               ev_window_clear_local_uri (ev_window);
+               ev_window_clear_print_settings_file (ev_window);
+               g_free (ev_window->priv->uri);
+               ev_window->priv->uri = NULL;
+               g_object_unref (source);
+               
+               ev_view_set_loading (EV_VIEW (ev_window->priv->view), FALSE);
+       } else {
+               ev_window_load_remote_failed (ev_window, error);
+               g_object_unref (source);
+       }
+       
+       g_error_free (error);
+}
+
+static void
+window_open_file_copy_progress_cb (goffset   n_bytes,
+                                  goffset   total_bytes,
+                                  EvWindow *ev_window)
+{
+       gchar *status;
+       gdouble fraction;
+       
+       if (!ev_window->priv->message_area)
+               return;
+       
+       fraction = n_bytes / (gdouble)total_bytes;
+       status = g_strdup_printf (_("Downloading document %d%%"),
+                                 (gint)(fraction * 100));
+       
+       ev_progress_message_area_set_status (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
+                                            status);
+       ev_progress_message_area_set_fraction (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
+                                              fraction);
+
+       g_free (status);
+}
+
+static void
+ev_window_load_file_remote (EvWindow *ev_window,
+                           GFile    *source_file)
+{
+       GFile *target_file;
+       
+       if (!ev_window->priv->local_uri) {
+               gchar *tmp_name;
+               gchar *base_name;
 
                /* We'd like to keep extension of source uri since
                 * it helps to resolve some mime types, say cbz */
 
                /* We'd like to keep extension of source uri since
                 * it helps to resolve some mime types, say cbz */
-
                tmp_name = ev_tmp_filename (NULL);
                base_name = g_file_get_basename (source_file);
                tmp_name = ev_tmp_filename (NULL);
                base_name = g_file_get_basename (source_file);
-               ev_window->priv->local_uri = g_strconcat ("file:", tmp_name, "-", base_name, NULL);
+               ev_window->priv->local_uri = g_strconcat ("file:", tmp_name, "-",
+                                                         base_name, NULL);
                ev_job_load_set_uri (EV_JOB_LOAD (ev_window->priv->load_job),
                                     ev_window->priv->local_uri);
                g_free (base_name);
                g_free (tmp_name);
                ev_job_load_set_uri (EV_JOB_LOAD (ev_window->priv->load_job),
                                     ev_window->priv->local_uri);
                g_free (base_name);
                g_free (tmp_name);
+       }
+
+       ev_window_reset_progress_cancellable (ev_window);
+       
+       target_file = g_file_new_for_uri (ev_window->priv->local_uri);
+       g_file_copy_async (source_file, target_file,
+                          0, G_PRIORITY_DEFAULT,
+                          ev_window->priv->progress_cancellable,
+                          (GFileProgressCallback)window_open_file_copy_progress_cb,
+                          ev_window, 
+                          (GAsyncReadyCallback)window_open_file_copy_ready_cb,
+                          ev_window);
+       g_object_unref (target_file);
+
+       ev_window_show_progress_message (ev_window, 1,
+                                        (GSourceFunc)show_loading_progress);
+}
+
+void
+ev_window_open_uri (EvWindow       *ev_window,
+                   const char     *uri,
+                   EvLinkDest     *dest,
+                   EvWindowRunMode mode,
+                   const gchar    *search_string, 
+                   gboolean        unlink_temp_file,
+                   const gchar    *print_settings)
+{
+       GFile *source_file;
+
+       ev_window->priv->in_reload = FALSE;
+       
+       if (ev_window->priv->uri &&
+           g_ascii_strcasecmp (ev_window->priv->uri, uri) == 0) {
+               ev_window_reload_document (ev_window);
+               return;
+       }
+
+       if (ev_window->priv->monitor) {
+               g_object_unref (ev_window->priv->monitor);
+               ev_window->priv->monitor = NULL;
+       }
+       
+       ev_window_close_dialogs (ev_window);
+       ev_window_clear_load_job (ev_window);
+       ev_window_clear_local_uri (ev_window);
+       ev_window_clear_print_settings_file (ev_window);
+       ev_view_set_loading (EV_VIEW (ev_window->priv->view), TRUE);
+
+       ev_window->priv->unlink_temp_file = unlink_temp_file;
+
+       if (mode == EV_WINDOW_MODE_PREVIEW) {
+               ev_window->priv->print_settings_file = print_settings ? 
+                       g_strdup (print_settings) : NULL;
+       }
+
+       if (ev_window->priv->uri)
+               g_free (ev_window->priv->uri);
+       ev_window->priv->uri = g_strdup (uri);
+
+       setup_size_from_metadata (ev_window);
+       
+       ev_window->priv->load_job = ev_job_load_new (uri, dest, mode, search_string);
+       g_signal_connect (ev_window->priv->load_job,
+                         "finished",
+                         G_CALLBACK (ev_window_load_job_cb),
+                         ev_window);
+
+       source_file = g_file_new_for_uri (uri);
+       if (!g_file_is_native (source_file) && !ev_window->priv->local_uri) {
+               ev_window_load_file_remote (ev_window, source_file);
+       } else {
+               g_object_unref (source_file);
+               ev_job_scheduler_push_job (ev_window->priv->load_job, EV_JOB_PRIORITY_NONE);
+       }
+}
+
+static void
+ev_window_reload_local (EvWindow *ev_window)
+{
+       const gchar *uri;
+       
+       uri = ev_window->priv->local_uri ? ev_window->priv->local_uri : ev_window->priv->uri;
+       ev_window->priv->reload_job = ev_job_load_new (uri, NULL, 0, NULL);
+       g_signal_connect (ev_window->priv->reload_job, "finished",
+                         G_CALLBACK (ev_window_reload_job_cb),
+                         ev_window);
+       ev_job_scheduler_push_job (ev_window->priv->reload_job, EV_JOB_PRIORITY_NONE);
+}
+
+static gboolean 
+show_reloading_progress (EvWindow *ev_window)
+{
+       GtkWidget *area;
+       gchar     *text;
+       
+       if (ev_window->priv->message_area)
+               return FALSE;
+       
+       text = g_strdup_printf (_("Reloading document from %s"),
+                               ev_window->priv->uri);
+       area = ev_progress_message_area_new (GTK_STOCK_REFRESH,
+                                            text,
+                                            GTK_STOCK_CLOSE,
+                                            GTK_RESPONSE_CLOSE,
+                                            GTK_STOCK_CANCEL,
+                                            GTK_RESPONSE_CANCEL,
+                                            NULL);
+       g_signal_connect (area, "response",
+                         G_CALLBACK (ev_window_progress_response_cb),
+                         ev_window);
+       gtk_widget_show (area);
+       ev_window_set_message_area (ev_window, area);
+       g_free (text);
+
+       return FALSE;
+}
+
+static void
+reload_remote_copy_ready_cb (GFile        *remote,
+                            GAsyncResult *async_result,
+                            EvWindow     *ev_window)
+{
+       GError *error = NULL;
+       
+       ev_window_clear_progress_idle (ev_window);
+       
+       g_file_copy_finish (remote, async_result, &error);
+       if (error) {
+               if (error->domain != G_IO_ERROR ||
+                   error->code != G_IO_ERROR_CANCELLED)
+                       ev_window_error_message (ev_window, error,
+                                                "%s", _("Failed to reaload document."));
+               g_error_free (error);
+       } else {
+               ev_window_reload_local (ev_window);
+       }
                
                
-               target_file = g_file_new_for_uri (ev_window->priv->local_uri);
+       g_object_unref (remote);
+}
+
+static void
+reload_remote_copy_progress_cb (goffset   n_bytes,
+                               goffset   total_bytes,
+                               EvWindow *ev_window)
+{
+       gchar *status;
+       gdouble fraction;
+       
+       if (!ev_window->priv->message_area)
+               return;
+       
+       fraction = n_bytes / (gdouble)total_bytes;
+       status = g_strdup_printf (_("Downloading document %d%%"),
+                                 (gint)(fraction * 100));
+       
+       ev_progress_message_area_set_status (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
+                                            status);
+       ev_progress_message_area_set_fraction (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
+                                              fraction);
 
 
-               g_file_copy_async (source_file, target_file,
-                                  0, G_PRIORITY_DEFAULT, NULL,
-                                  NULL, NULL, /* no progress callback */
-                                  (GAsyncReadyCallback) window_open_file_copy_ready_cb,
+       g_free (status);
+}
+
+static void
+query_remote_uri_mtime_cb (GFile        *remote,
+                          GAsyncResult *async_result,
+                          EvWindow     *ev_window)
+{
+       GFileInfo *info;
+       GTimeVal   mtime;
+       GError    *error = NULL;
+
+       info = g_file_query_info_finish (remote, async_result, &error);
+       if (error) {
+               g_error_free (error);
+               g_object_unref (remote);
+               ev_window_reload_local (ev_window);
+
+               return;
+       }
+       
+       g_file_info_get_modification_time (info, &mtime);
+       if (ev_window->priv->uri_mtime != mtime.tv_sec) {
+               GFile *target_file;
+                       
+               /* Remote file has changed */
+               ev_window->priv->uri_mtime = mtime.tv_sec;
+
+               ev_window_reset_progress_cancellable (ev_window);
+               
+               target_file = g_file_new_for_uri (ev_window->priv->local_uri);
+               g_file_copy_async (remote, target_file,
+                                  G_FILE_COPY_OVERWRITE,
+                                  G_PRIORITY_DEFAULT,
+                                  ev_window->priv->progress_cancellable,
+                                  (GFileProgressCallback)reload_remote_copy_progress_cb,
+                                  ev_window, 
+                                  (GAsyncReadyCallback)reload_remote_copy_ready_cb,
                                   ev_window);
                g_object_unref (target_file);
                                   ev_window);
                g_object_unref (target_file);
-               return;
+               ev_window_show_progress_message (ev_window, 1,
+                                                (GSourceFunc)show_reloading_progress);
+       } else {
+               g_object_unref (remote);
+               ev_window_reload_local (ev_window);
        }
        }
+       
+       g_object_unref (info);
+}
 
 
-       g_object_unref (source_file);
-       ev_job_queue_add_job (ev_window->priv->load_job, EV_JOB_PRIORITY_HIGH);
+static void
+ev_window_reload_remote (EvWindow *ev_window)
+{
+       GFile *remote;
+       
+       remote = g_file_new_for_uri (ev_window->priv->uri);
+       /* Reload the remote uri only if it has changed */
+       g_file_query_info_async (remote,
+                                G_FILE_ATTRIBUTE_TIME_MODIFIED,
+                                0, G_PRIORITY_DEFAULT,
+                                NULL,
+                                (GAsyncReadyCallback)query_remote_uri_mtime_cb,
+                                ev_window);
+}
+
+static void
+ev_window_reload_document (EvWindow *ev_window)
+{
+       ev_window_clear_reload_job (ev_window);
+       ev_window->priv->in_reload = TRUE;
+
+       if (ev_window->priv->local_uri) {
+               ev_window_reload_remote (ev_window);
+       } else {
+               ev_window_reload_local (ev_window);
+       }
 }
 
 static void
 }
 
 static void
@@ -1662,10 +2113,8 @@ ev_window_cmd_file_open_copy_at_dest (EvWindow *window, EvLinkDest *dest)
        new_filename = ev_window_create_tmp_symlink (old_filename, &error);
 
        if (error) {
        new_filename = ev_window_create_tmp_symlink (old_filename, &error);
 
        if (error) {
-               ev_window_error_message (GTK_WINDOW (window),
-                                        _("Cannot open a copy."),
-                                        error);
-
+               ev_window_error_message (window, error, 
+                                        "%s", _("Cannot open a copy."));
                g_error_free (error);
                g_free (old_filename);
                g_free (new_filename);
                g_error_free (error);
                g_free (old_filename);
                g_free (new_filename);
@@ -1886,61 +2335,158 @@ ev_window_setup_recent (EvWindow *ev_window)
        g_list_free (items);
 }
 
        g_list_free (items);
 }
 
+static gboolean 
+show_saving_progress (GFile *dst)
+{
+       EvWindow  *ev_window;
+       GtkWidget *area;
+       gchar     *text;
+       gchar     *uri;
+       EvSaveType save_type;
+
+       ev_window = EV_WINDOW (g_object_get_data (G_OBJECT (dst), "ev-window"));
+       ev_window->priv->progress_idle = 0;
+       
+       if (ev_window->priv->message_area)
+               return FALSE;
+
+       save_type = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dst), "save-type"));
+       uri = g_file_get_uri (dst);
+       switch (save_type) {
+       case EV_SAVE_DOCUMENT:
+               text = g_strdup_printf (_("Saving document to %s"), uri);
+               break;
+       case EV_SAVE_ATTACHMENT:
+               text = g_strdup_printf (_("Saving attachment to %s"), uri);
+               break;
+       case EV_SAVE_IMAGE:
+               text = g_strdup_printf (_("Saving image to %s"), uri);
+               break;
+       default:
+               g_assert_not_reached ();
+       }
+       g_free (uri);
+       area = ev_progress_message_area_new (GTK_STOCK_SAVE,
+                                            text,
+                                            GTK_STOCK_CLOSE,
+                                            GTK_RESPONSE_CLOSE,
+                                            GTK_STOCK_CANCEL,
+                                            GTK_RESPONSE_CANCEL,
+                                            NULL);
+       g_signal_connect (area, "response",
+                         G_CALLBACK (ev_window_progress_response_cb),
+                         ev_window);
+       gtk_widget_show (area);
+       ev_window_set_message_area (ev_window, area);
+       g_free (text);
+
+       return FALSE;
+}
+
 static void
 window_save_file_copy_ready_cb (GFile        *src,
                                GAsyncResult *async_result,
                                GFile        *dst)
 {
 static void
 window_save_file_copy_ready_cb (GFile        *src,
                                GAsyncResult *async_result,
                                GFile        *dst)
 {
-       EvWindow  *window;
-       GtkWidget *dialog;
-       gchar     *name;
-       GError    *error = NULL;
+       EvWindow *ev_window;
+       GError   *error = NULL;
 
 
+       ev_window = EV_WINDOW (g_object_get_data (G_OBJECT (dst), "ev-window"));
+       ev_window_clear_progress_idle (ev_window);
+       
        if (g_file_copy_finish (src, async_result, &error)) {
                ev_tmp_file_unlink (src);
                return;
        }
 
        if (g_file_copy_finish (src, async_result, &error)) {
                ev_tmp_file_unlink (src);
                return;
        }
 
-       window = g_object_get_data (G_OBJECT (dst), "ev-window");
-       name = g_file_get_basename (dst);
-       dialog = gtk_message_dialog_new (GTK_WINDOW (window),
-                                        GTK_DIALOG_DESTROY_WITH_PARENT,
-                                        GTK_MESSAGE_ERROR,
-                                        GTK_BUTTONS_CLOSE,
+       if (error->domain != G_IO_ERROR ||
+           error->code != G_IO_ERROR_CANCELLED) {
+               gchar *name;
+               
+               name = g_file_get_basename (dst);
+               ev_window_error_message (ev_window, error,
                                         _("The file could not be saved as “%s”."),
                                         name);
                                         _("The file could not be saved as “%s”."),
                                         name);
-       gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
-                                                 error->message);
-       g_signal_connect (dialog, "response",
-                         G_CALLBACK (gtk_widget_destroy),
-                         NULL);
-       gtk_widget_show (dialog);
+               g_free (name);
+       }
        ev_tmp_file_unlink (src);
        ev_tmp_file_unlink (src);
-
-       g_free (name);
        g_error_free (error);
 }
 
 static void
        g_error_free (error);
 }
 
 static void
-ev_window_save_remote (EvWindow *ev_window,
-                      GFile    *src,
-                      GFile    *dst)
+window_save_file_copy_progress_cb (goffset n_bytes,
+                                  goffset total_bytes,
+                                  GFile  *dst)
 {
 {
+       EvWindow  *ev_window;
+       EvSaveType save_type;
+       gchar     *status;
+       gdouble    fraction;
+
+       ev_window = EV_WINDOW (g_object_get_data (G_OBJECT (dst), "ev-window"));
+       
+       if (!ev_window->priv->message_area)
+               return;
+       
+       fraction = n_bytes / (gdouble)total_bytes;
+       save_type = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dst), "save-type"));
+
+       switch (save_type) {
+       case EV_SAVE_DOCUMENT:
+               status = g_strdup_printf (_("Uploading document %d%%"),
+                                         (gint)(fraction * 100));
+               break;
+       case EV_SAVE_ATTACHMENT:
+               status = g_strdup_printf (_("Uploading attachment %d%%"),
+                                         (gint)(fraction * 100));
+               break;
+       case EV_SAVE_IMAGE:
+               status = g_strdup_printf (_("Uploading image %d%%"),
+                                         (gint)(fraction * 100));
+               break;
+       default:
+               g_assert_not_reached ();
+       }
+       
+       ev_progress_message_area_set_status (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
+                                            status);
+       ev_progress_message_area_set_fraction (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
+                                              fraction);
+
+       g_free (status);
+}
+
+static void
+ev_window_save_remote (EvWindow  *ev_window,
+                      EvSaveType save_type,
+                      GFile     *src,
+                      GFile     *dst)
+{
+       ev_window_reset_progress_cancellable (ev_window);
        g_object_set_data (G_OBJECT (dst), "ev-window", ev_window);
        g_object_set_data (G_OBJECT (dst), "ev-window", ev_window);
+       g_object_set_data (G_OBJECT (dst), "save-type", GINT_TO_POINTER (save_type));
        g_file_copy_async (src, dst,
                           G_FILE_COPY_OVERWRITE,
        g_file_copy_async (src, dst,
                           G_FILE_COPY_OVERWRITE,
-                          G_PRIORITY_DEFAULT, NULL,
-                          NULL, NULL, /* no progress callback */
-                          (GAsyncReadyCallback) window_save_file_copy_ready_cb,
-                          dst);                
+                          G_PRIORITY_DEFAULT,
+                          ev_window->priv->progress_cancellable,
+                          (GFileProgressCallback)window_save_file_copy_progress_cb,
+                          dst,
+                          (GAsyncReadyCallback)window_save_file_copy_ready_cb,
+                          dst);
+       ev_window->priv->progress_idle =
+               g_timeout_add_seconds_full (G_PRIORITY_DEFAULT,
+                                           1,
+                                           (GSourceFunc)show_saving_progress,
+                                           dst,
+                                           NULL);
 }
 
 static void
 ev_window_clear_save_job (EvWindow *ev_window)
 {
        if (ev_window->priv->save_job != NULL) {
 }
 
 static void
 ev_window_clear_save_job (EvWindow *ev_window)
 {
        if (ev_window->priv->save_job != NULL) {
-               if (!ev_window->priv->save_job->finished)
-                       ev_job_queue_remove_job (ev_window->priv->save_job);
+               if (!ev_job_is_finished (ev_window->priv->save_job))
+                       ev_job_cancel (ev_window->priv->save_job);
                
                g_signal_handlers_disconnect_by_func (ev_window->priv->save_job,
                                                      ev_window_save_job_cb,
                
                g_signal_handlers_disconnect_by_func (ev_window->priv->save_job,
                                                      ev_window_save_job_cb,
@@ -1951,15 +2497,13 @@ ev_window_clear_save_job (EvWindow *ev_window)
 }
 
 static void
 }
 
 static void
-ev_window_save_job_cb (EvJobSave *job,
+ev_window_save_job_cb (EvJob     *job,
                       EvWindow  *window)
 {
                       EvWindow  *window)
 {
-       if (job->error) {
-               gchar *msg;
-               
-               msg = g_strdup_printf (_("The file could not be saved as “%s”."), job->uri);
-               ev_window_error_message (GTK_WINDOW (window), msg, job->error);
-               g_free (msg);
+       if (ev_job_is_failed (job)) {
+               ev_window_error_message (window, job->error,
+                                        _("The file could not be saved as “%s”."),
+                                        EV_JOB_SAVE (job)->uri);
        }
 
        ev_window_clear_save_job (window);
        }
 
        ev_window_clear_save_job (window);
@@ -1978,6 +2522,9 @@ file_save_dialog_response_cb (GtkWidget *fc,
        }
        
        uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (fc));
        }
        
        uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (fc));
+       /* FIXME: remote copy should be done here rather than in the save job, 
+        * so that we can track progress and cancel the operation
+        */
        
        ev_window_clear_save_job (ev_window);
        ev_window->priv->save_job = ev_job_save_new (ev_window->priv->document,
        
        ev_window_clear_save_job (ev_window);
        ev_window->priv->save_job = ev_job_save_new (ev_window->priv->document,
@@ -1986,10 +2533,9 @@ file_save_dialog_response_cb (GtkWidget *fc,
                          G_CALLBACK (ev_window_save_job_cb),
                          ev_window);
        /* The priority doesn't matter for this job */
                          G_CALLBACK (ev_window_save_job_cb),
                          ev_window);
        /* The priority doesn't matter for this job */
-       ev_job_queue_add_job (ev_window->priv->save_job, EV_JOB_PRIORITY_LOW);
+       ev_job_scheduler_push_job (ev_window->priv->save_job, EV_JOB_PRIORITY_NONE);
 
        g_free (uri);
 
        g_free (uri);
-
        gtk_widget_destroy (fc);
 }
 
        gtk_widget_destroy (fc);
 }
 
@@ -2031,55 +2577,6 @@ ev_window_cmd_save_as (GtkAction *action, EvWindow *ev_window)
        gtk_widget_show (fc);
 }
 
        gtk_widget_show (fc);
 }
 
-#ifdef WITH_GTK_PRINT
-static void
-ev_window_print_page_setup_done_cb (GtkPageSetup *page_setup,
-                                   EvWindow     *window)
-{
-       /* Dialog was canceled */
-       if (!page_setup)
-               return;
-
-       if (window->priv->print_page_setup)
-               g_object_unref (window->priv->print_page_setup);
-       window->priv->print_page_setup = g_object_ref (page_setup);
-}
-#endif /* WITH_GTK_PRINT */
-
-static void
-ev_window_cmd_file_print_setup (GtkAction *action, EvWindow *ev_window)
-{
-#ifdef WITH_GTK_PRINT
-       gtk_print_run_page_setup_dialog_async (
-               GTK_WINDOW (ev_window),
-               ev_window->priv->print_page_setup,
-               ev_window->priv->print_settings,
-               (GtkPageSetupDoneFunc) ev_window_print_page_setup_done_cb,
-               ev_window);
-#endif /* WITH_GTK_PRINT */
-}
-
-#ifdef WITH_GTK_PRINT
-static void
-ev_window_clear_print_job (EvWindow *window)
-{
-       if (window->priv->print_job) {
-               if (!window->priv->print_job->finished)
-                       ev_job_queue_remove_job (window->priv->print_job);
-
-               g_signal_handlers_disconnect_by_func (window->priv->print_job,
-                                                     ev_window_print_job_cb,
-                                                     window);
-               g_object_unref (window->priv->print_job);
-               window->priv->print_job = NULL;
-       }
-
-       if (window->priv->gtk_print_job) {
-               g_object_unref (window->priv->gtk_print_job);
-               window->priv->gtk_print_job = NULL;
-       }
-}
-
 static void
 ev_window_load_print_settings_from_metadata (EvWindow *window)
 {
 static void
 ev_window_load_print_settings_from_metadata (EvWindow *window)
 {
@@ -2095,6 +2592,8 @@ ev_window_load_print_settings_from_metadata (EvWindow *window)
                gtk_print_settings_set (window->priv->print_settings,
                                        document_print_settings[i],
                                        success ? g_value_get_string (&value) : NULL);
                gtk_print_settings_set (window->priv->print_settings,
                                        document_print_settings[i],
                                        success ? g_value_get_string (&value) : NULL);
+               if (success)
+                       g_value_unset (&value);
        }
 }
 
        }
 }
 
@@ -2115,286 +2614,326 @@ ev_window_save_print_settings (EvWindow *window)
 }
 
 static void
 }
 
 static void
-ev_window_print_finished (GtkPrintJob *print_job,
-                         EvWindow    *window,
-                         GError      *error)
+ev_window_save_print_page_setup (EvWindow *window)
 {
 {
-       ev_window_clear_print_job (window);
-       
-       if (error) {
-               GtkWidget *dialog;
-               
-               dialog = gtk_message_dialog_new (GTK_WINDOW (window),
-                                                GTK_DIALOG_MODAL,
-                                                GTK_MESSAGE_ERROR,
-                                                GTK_BUTTONS_OK,
-                                                _("Failed to print document"));
-               gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
-                                                         error->message);
+       gchar        *uri = window->priv->uri;
+       GtkPageSetup *page_setup = window->priv->print_page_setup;
 
 
-               gtk_dialog_run (GTK_DIALOG (dialog));
-               gtk_widget_destroy (dialog);
-       } else {
-               /* If printed successfully, save print settings */
-               ev_application_set_print_settings (EV_APP,
-                                                  window->priv->print_settings);
-               ev_window_save_print_settings (window);
-       }
+       /* Save page setup options that are specific to the document */
+       ev_metadata_manager_set_int (uri, "page-setup-orientation",
+                                    gtk_page_setup_get_orientation (page_setup));
+       ev_metadata_manager_set_double (uri, "page-setup-margin-top",
+                                       gtk_page_setup_get_top_margin (page_setup, GTK_UNIT_MM));
+       ev_metadata_manager_set_double (uri, "page-setup-margin-bottom",
+                                       gtk_page_setup_get_bottom_margin (page_setup, GTK_UNIT_MM));
+       ev_metadata_manager_set_double (uri, "page-setup-margin-left",
+                                       gtk_page_setup_get_left_margin (page_setup, GTK_UNIT_MM));
+       ev_metadata_manager_set_double (uri, "page-setup-margin-right",
+                                       gtk_page_setup_get_right_margin (page_setup, GTK_UNIT_MM));
 }
 
 static void
 }
 
 static void
-ev_window_print_send (EvWindow    *window,
-                     const gchar *filename)
+ev_window_load_print_page_setup_from_metadata (EvWindow *window)
 {
 {
-       GtkPrintSettings *settings;
-       EvFileExporterCapabilities capabilities;
+       gchar        *uri = window->priv->uri;
+       GtkPageSetup *page_setup = window->priv->print_page_setup;
+       GtkPaperSize *paper_size;
+       GValue        value = { 0, };
+
+       paper_size = gtk_page_setup_get_paper_size (page_setup);
        
        
-       /* Some printers take into account some print settings,
-        * and others don't. However we have exported the document
-        * to a ps or pdf file according to such print settings. So,
-        * we want to send the exported file to printer with those
-        * settings set to default values. 
-        */
-       settings = gtk_print_settings_copy (window->priv->print_settings);
-       capabilities = ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (window->priv->document));
-
-       gtk_print_settings_set_page_ranges (settings, NULL, 0);
-       gtk_print_settings_set_print_pages (settings, GTK_PRINT_PAGES_ALL);
-       if (capabilities & EV_FILE_EXPORTER_CAN_COPIES)
-               gtk_print_settings_set_n_copies (settings, 1);
-       if (capabilities & EV_FILE_EXPORTER_CAN_PAGE_SET)
-               gtk_print_settings_set_page_set (settings, GTK_PAGE_SET_ALL);
-       if (capabilities & EV_FILE_EXPORTER_CAN_SCALE)
-               gtk_print_settings_set_scale (settings, 1.0);
-       if (capabilities & EV_FILE_EXPORTER_CAN_COLLATE)
-               gtk_print_settings_set_collate (settings, FALSE);
-       if (capabilities & EV_FILE_EXPORTER_CAN_REVERSE)
-               gtk_print_settings_set_reverse (settings, FALSE);
-       if (capabilities & EV_FILE_EXPORTER_CAN_NUMBER_UP) {
-               gtk_print_settings_set_number_up (settings, 1);
-               gtk_print_settings_set_int (settings, "cups-"GTK_PRINT_SETTINGS_NUMBER_UP, 1);
-       }
-       
-       if (window->priv->print_preview) {
-               gchar *uri;
-               gchar *print_settings_file = NULL;
-
-               ev_application_set_print_settings (EV_APP,
-                                                  window->priv->print_settings);
-               
-#if GTK_CHECK_VERSION (2, 11, 0)
-               print_settings_file = ev_tmp_filename ("print-settings");
-               gtk_print_settings_to_file (settings, print_settings_file, NULL);
-#endif
-               uri = g_filename_to_uri (filename, NULL, NULL);
-               ev_application_open_uri_at_dest (EV_APP,
-                                                uri, 
-                                                gtk_window_get_screen (GTK_WINDOW (window)),
-                                                NULL,
-                                                EV_WINDOW_MODE_PREVIEW,
-                                                NULL, 
-                                                TRUE,
-                                                print_settings_file,
-                                                GDK_CURRENT_TIME);
-               g_free (print_settings_file);
-               g_free (uri);
+       /* Load page setup options that are specific to the document */
+       if (ev_metadata_manager_get (uri, "page-setup-orientation", &value, TRUE)) {
+               gtk_page_setup_set_orientation (page_setup, g_value_get_int (&value));
+               g_value_unset (&value);
        } else {
        } else {
-               GtkPrintJob *job;
-               GError      *error = NULL;
-       
-               job = gtk_print_job_new ("evince-print",
-                                        window->priv->printer,
-                                        settings,
-                                        window->priv->print_page_setup);
-
-               if (window->priv->gtk_print_job)
-                       g_object_unref (window->priv->gtk_print_job);
-               window->priv->gtk_print_job = job;
-
-               if (gtk_print_job_set_source_file (job, filename, &error)) {
-                       gtk_print_job_send (job,
-                                           (GtkPrintJobCompleteFunc)ev_window_print_finished,
-                                           window, NULL);
-               } else {
-                       ev_window_clear_print_job (window);
-                       g_warning (error->message);
-                       g_error_free (error);
-               }
+               gtk_page_setup_set_orientation (page_setup, GTK_PAGE_ORIENTATION_PORTRAIT);
        }
        }
+       
+       if (ev_metadata_manager_get (uri, "page-setup-margin-top", &value, TRUE)) {
+               gtk_page_setup_set_top_margin (page_setup, g_value_get_double (&value), GTK_UNIT_MM);
+               g_value_unset (&value);
+       } else {
+               gtk_page_setup_set_top_margin (page_setup,
+                                              gtk_paper_size_get_default_top_margin (paper_size, GTK_UNIT_MM),
+                                              GTK_UNIT_MM);
+       }
+
+       if (ev_metadata_manager_get (uri, "page-setup-margin-bottom", &value, TRUE)) {
+               gtk_page_setup_set_bottom_margin (page_setup, g_value_get_double (&value), GTK_UNIT_MM);
+               g_value_unset (&value);
+       } else {
+               gtk_page_setup_set_bottom_margin (page_setup,
+                                                 gtk_paper_size_get_default_bottom_margin (paper_size, GTK_UNIT_MM),
+                                                 GTK_UNIT_MM);
+       }
+
+       if (ev_metadata_manager_get (uri, "page-setup-margin-left", &value, TRUE)) {
+               gtk_page_setup_set_left_margin (page_setup, g_value_get_double (&value), GTK_UNIT_MM);
+               g_value_unset (&value);
+       } else {
+               gtk_page_setup_set_left_margin (page_setup,
+                                               gtk_paper_size_get_default_left_margin (paper_size, GTK_UNIT_MM),
+                                               GTK_UNIT_MM);
+       }       
 
 
-       g_object_unref (settings);
+       if (ev_metadata_manager_get (uri, "page-setup-margin-right", &value, TRUE)) {
+               gtk_page_setup_set_right_margin (page_setup, g_value_get_double (&value), GTK_UNIT_MM);
+               g_value_unset (&value);
+       } else {
+               gtk_page_setup_set_right_margin (page_setup,
+                                                gtk_paper_size_get_default_right_margin (paper_size, GTK_UNIT_MM),
+                                                GTK_UNIT_MM);
+       }       
 }
 
 static void
 }
 
 static void
-ev_window_print_job_cb (EvJobPrint *job,
-                       EvWindow   *window)
+ev_window_print_page_setup_done_cb (GtkPageSetup *page_setup,
+                                   EvWindow     *window)
 {
 {
-       if (job->error) {
-               g_warning (job->error->message);
-               ev_window_clear_print_job (window);
+       /* Dialog was canceled */
+       if (!page_setup)
                return;
                return;
-       }
 
 
-       g_assert (job->temp_file != NULL);
+       if (window->priv->print_page_setup != page_setup) {
+               if (window->priv->print_page_setup)
+                       g_object_unref (window->priv->print_page_setup);
+               window->priv->print_page_setup = g_object_ref (page_setup);
+       }
+       
+       ev_application_set_page_setup (EV_APP, page_setup);
+       ev_window_save_print_page_setup (window);
+}
 
 
-       ev_window_print_send (window, job->temp_file);
+static void
+ev_window_cmd_file_print_setup (GtkAction *action, EvWindow *ev_window)
+{
+       if (!ev_window->priv->print_page_setup) {
+               ev_window->priv->print_page_setup = gtk_page_setup_copy (
+                       ev_application_get_page_setup (EV_APP));
+               ev_window_load_print_page_setup_from_metadata (ev_window);
+       }
+       
+       gtk_print_run_page_setup_dialog_async (
+               GTK_WINDOW (ev_window),
+               ev_window->priv->print_page_setup,
+               ev_window->priv->print_settings,
+               (GtkPageSetupDoneFunc) ev_window_print_page_setup_done_cb,
+               ev_window);
 }
 
 }
 
-static gboolean
-ev_window_print_dialog_response_cb (GtkDialog *dialog,
-                                   gint       response,
-                                   EvWindow  *window)
+static void
+ev_window_print_cancel (EvWindow *ev_window)
 {
 {
-       EvPrintRange  *ranges = NULL;
-       EvPrintPageSet page_set;
-       gint           n_ranges = 0;
-       gint           copies;
-       gint           pages_per_sheet;
-       gboolean       collate;
-       gboolean       reverse;
-       gdouble        scale;
-       gint           current_page;
-       gdouble        width;
-       gdouble        height;
-       GtkPrintPages  print_pages;
-       const gchar   *file_format;
+       EvPrintOperation *op;
        
        
-       if (response == GTK_RESPONSE_CANCEL) {
-               gtk_widget_destroy (GTK_WIDGET (dialog));
-               window->priv->print_dialog = NULL;
+       if (!ev_window->priv->print_queue)
+               return;
 
 
-               return FALSE;
+       while ((op = g_queue_peek_tail (ev_window->priv->print_queue))) {
+               ev_print_operation_cancel (op);
        }
        }
+}
 
 
-       window->priv->print_preview = (response == GTK_RESPONSE_APPLY);
-
-       if (window->priv->printer)
-               g_object_unref (window->priv->printer);
-       if (window->priv->print_settings)
-               g_object_unref (window->priv->print_settings);
-       if (window->priv->print_page_setup)
-               g_object_unref (window->priv->print_page_setup);
+static void
+ev_window_print_update_pending_jobs_message (EvWindow *ev_window,
+                                            gint      n_jobs)
+{
+       gchar *text = NULL;
        
        
-       window->priv->printer = g_object_ref (
-               gtk_print_unix_dialog_get_selected_printer (GTK_PRINT_UNIX_DIALOG (dialog)));
-       window->priv->print_settings = g_object_ref (
-               gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (dialog)));
-       window->priv->print_page_setup = g_object_ref (
-               gtk_print_unix_dialog_get_page_setup (GTK_PRINT_UNIX_DIALOG (dialog)));
+       if (!EV_IS_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area) ||
+           !ev_window->priv->print_queue)
+               return;
 
 
-       file_format = gtk_print_settings_get (window->priv->print_settings,
-                                             GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT);
+       if (n_jobs == 0) {
+               ev_window_set_message_area (ev_window, NULL);
+               return;
+       }
        
        
-       if (!gtk_printer_accepts_ps (window->priv->printer)) {
-               GtkWidget *msgdialog;
-
-               msgdialog = gtk_message_dialog_new (GTK_WINDOW (dialog),
-                                                   GTK_DIALOG_MODAL,
-                                                   GTK_MESSAGE_ERROR,
-                                                   GTK_BUTTONS_OK,
-                                                   _("Printing is not supported on this printer."));
-               
-               gtk_dialog_run (GTK_DIALOG (msgdialog));
-               gtk_widget_destroy (msgdialog);
-
-               return FALSE;
+       if (n_jobs > 1) {
+               text = g_strdup_printf (ngettext ("%d pending job in queue",
+                                                 "%d pending jobs in queue",
+                                                 n_jobs - 1), n_jobs - 1);
        }
 
        }
 
-       ev_window_clear_print_job (window);
+       ev_message_area_set_secondary_text (EV_MESSAGE_AREA (ev_window->priv->message_area),
+                                           text);
+       g_free (text);
+}
+
+static gboolean
+destroy_window (GtkWidget *window)
+{
+       gtk_widget_destroy (window);
        
        
-       current_page = gtk_print_unix_dialog_get_current_page (GTK_PRINT_UNIX_DIALOG (dialog));
-       print_pages = gtk_print_settings_get_print_pages (window->priv->print_settings);
+       return FALSE;
+}
+
+static void
+ev_window_print_operation_done (EvPrintOperation       *op,
+                               GtkPrintOperationResult result,
+                               EvWindow               *ev_window)
+{
+       gint n_jobs;
        
        
-       switch (print_pages) {
-       case GTK_PRINT_PAGES_CURRENT:
-               ranges = g_new0 (EvPrintRange, 1);
+       switch (result) {
+       case GTK_PRINT_OPERATION_RESULT_APPLY: {
+               GtkPrintSettings *print_settings;
                
                
-               ranges->start = current_page;
-               ranges->end = current_page;
-               n_ranges = 1;
-                               
-               break;
-       case GTK_PRINT_PAGES_RANGES: {
-               GtkPageRange *page_range;
+               print_settings = ev_print_operation_get_print_settings (op);
+               if (ev_window->priv->print_settings != print_settings) {
+                       if (ev_window->priv->print_settings)
+                               g_object_unref (ev_window->priv->print_settings);
+                       ev_window->priv->print_settings = g_object_ref (print_settings);
+               }
                
                
-               page_range = gtk_print_settings_get_page_ranges (window->priv->print_settings,
-                                                                &n_ranges);
-               if (n_ranges > 0)
-                       ranges = g_memdup (page_range, n_ranges * sizeof (GtkPageRange));
+               ev_application_set_print_settings (EV_APP, print_settings);
+               ev_window_save_print_settings (ev_window);
        }
        }
+
                break;
                break;
-       case GTK_PRINT_PAGES_ALL: {
-               gint n_pages;
+       case GTK_PRINT_OPERATION_RESULT_ERROR: {
+               GtkWidget *dialog;
+               GError    *error = NULL;
 
 
-               n_pages = ev_page_cache_get_n_pages (ev_page_cache_get (window->priv->document));
-               
-               ranges = g_new0 (EvPrintRange, 1);
 
 
-               ranges->start = 0;
-               ranges->end = n_pages - 1;
-               n_ranges = 1;
+               ev_print_operation_get_error (op, &error);
+               
+               /* The message area is already used by
+                * the printing progress, so it's better to
+                * use a popup dialog in this case
+                */
+               dialog = gtk_message_dialog_new (GTK_WINDOW (ev_window),
+                                                GTK_DIALOG_DESTROY_WITH_PARENT,
+                                                GTK_MESSAGE_ERROR,
+                                                GTK_BUTTONS_CLOSE,
+                                                "%s", _("Failed to print document"));
+               gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
+                                                         "%s", error->message);
+               g_signal_connect (dialog, "response",
+                                 G_CALLBACK (gtk_widget_destroy),
+                                 NULL);
+               gtk_widget_show (dialog);
+               
+               g_error_free (error);
        }
                break;
        }
                break;
+       case GTK_PRINT_OPERATION_RESULT_CANCEL:
+       default:
+               break;
        }
 
        }
 
-       page_set = (EvPrintPageSet)gtk_print_settings_get_page_set (window->priv->print_settings);
+       g_queue_remove (ev_window->priv->print_queue, op);
+       g_object_unref (op);
+       n_jobs = g_queue_get_length (ev_window->priv->print_queue);
+       ev_window_print_update_pending_jobs_message (ev_window, n_jobs);
 
 
-       scale = gtk_print_settings_get_scale (window->priv->print_settings) * 0.01;
-       
-       width = gtk_page_setup_get_paper_width (window->priv->print_page_setup,
-                                               GTK_UNIT_POINTS);
-       height = gtk_page_setup_get_paper_height (window->priv->print_page_setup,
-                                                 GTK_UNIT_POINTS);
-       
-       if (scale != 1.0) {
-               width *= scale;
-               height *= scale;
+       if (n_jobs == 0 && ev_window->priv->close_after_print)
+               g_idle_add ((GSourceFunc)destroy_window,
+                           ev_window);
+}
+
+static void
+ev_window_print_progress_response_cb (EvProgressMessageArea *area,
+                                     gint                   response,
+                                     EvWindow              *ev_window)
+{
+       if (response == GTK_RESPONSE_CANCEL) {
+               EvPrintOperation *op;
+
+               op = g_queue_peek_tail (ev_window->priv->print_queue);
+               ev_print_operation_cancel (op);
+       } else {
+               gtk_widget_hide (GTK_WIDGET (area));
        }
        }
+}
 
 
-       pages_per_sheet = gtk_print_settings_get_number_up (window->priv->print_settings);
-       
-       copies = gtk_print_settings_get_n_copies (window->priv->print_settings);
-       collate = gtk_print_settings_get_collate (window->priv->print_settings);
-       reverse = gtk_print_settings_get_reverse (window->priv->print_settings);
-       
-       window->priv->print_job = ev_job_print_new (window->priv->document,
-                                                   file_format ? file_format : "ps",
-                                                   width, height,
-                                                   ranges, n_ranges,
-                                                   page_set,
-                                                   pages_per_sheet,
-                                                   copies, collate,
-                                                   reverse);
+static void
+ev_window_print_operation_status_changed (EvPrintOperation *op,
+                                         EvWindow         *ev_window)
+{
+       const gchar *status;
+       gdouble      fraction;
+
+       status = ev_print_operation_get_status (op);
+       fraction = ev_print_operation_get_progress (op);
        
        
-       g_signal_connect (window->priv->print_job, "finished",
-                         G_CALLBACK (ev_window_print_job_cb),
-                         window);
-       /* The priority doesn't matter for this job */
-       ev_job_queue_add_job (window->priv->print_job, EV_JOB_PRIORITY_LOW);
+       if (!ev_window->priv->message_area) {
+               GtkWidget   *area;
+               const gchar *job_name;
+               gchar       *text;
+
+               job_name = ev_print_operation_get_job_name (op);
+               text = g_strdup_printf (_("Printing job “%s”"), job_name);
+
+               area = ev_progress_message_area_new (GTK_STOCK_PRINT,
+                                                    text,
+                                                    GTK_STOCK_CLOSE,
+                                                    GTK_RESPONSE_CLOSE,
+                                                    GTK_STOCK_CANCEL,
+                                                    GTK_RESPONSE_CANCEL,
+                                                    NULL);
+               ev_window_print_update_pending_jobs_message (ev_window, 1);
+               g_signal_connect (area, "response",
+                                 G_CALLBACK (ev_window_print_progress_response_cb),
+                                 ev_window);
+               gtk_widget_show (area);
+               ev_window_set_message_area (ev_window, area);
+               g_free (text);
+       }
+
+       ev_progress_message_area_set_status (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
+                                            status);
+       ev_progress_message_area_set_fraction (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
+                                              fraction);
+}
+
+static void
+ev_window_print_operation_begin_print (EvPrintOperation *op,
+                                      EvWindow         *ev_window)
+{
+       GtkPrintSettings *print_settings;
        
        
-       gtk_widget_destroy (GTK_WIDGET (dialog));
-       window->priv->print_dialog = NULL;
+       if (!ev_window->priv->print_queue)
+               ev_window->priv->print_queue = g_queue_new ();
 
 
-       return TRUE;
+       g_queue_push_head (ev_window->priv->print_queue, op);
+       ev_window_print_update_pending_jobs_message (ev_window,
+                                                    g_queue_get_length (ev_window->priv->print_queue));
+       
+       if (ev_window->priv->print_settings)
+               g_object_unref (ev_window->priv->print_settings);
+       print_settings = ev_print_operation_get_print_settings (op);
+       ev_window->priv->print_settings = g_object_ref (print_settings);
 }
 
 void
 }
 
 void
-ev_window_print_range (EvWindow *ev_window, int first_page, int last_page)
+ev_window_print_range (EvWindow *ev_window,
+                      gint      first_page,
+                      gint      last_page)
 {
 {
-       GtkWidget           *dialog;
-       EvPageCache         *page_cache;
-       gint                 current_page;
-       gint                 document_last_page;
-       GtkPrintCapabilities capabilities;
+       EvPrintOperation *op;
+       EvPageCache      *page_cache;
+       gint              current_page;
+       gint              document_last_page;
 
        g_return_if_fail (EV_IS_WINDOW (ev_window));
        g_return_if_fail (ev_window->priv->document != NULL);
 
 
        g_return_if_fail (EV_IS_WINDOW (ev_window));
        g_return_if_fail (ev_window->priv->document != NULL);
 
-       if (ev_window->priv->print_dialog) {
-               gtk_window_present (GTK_WINDOW (ev_window->priv->print_dialog));
-               return;
-       }
-       
+       if (!ev_window->priv->print_queue)
+               ev_window->priv->print_queue = g_queue_new ();
+
+       op = ev_print_operation_new (ev_window->priv->document);
+       g_signal_connect (G_OBJECT (op), "begin_print",
+                         G_CALLBACK (ev_window_print_operation_begin_print),
+                         (gpointer)ev_window);
+       g_signal_connect (G_OBJECT (op), "status_changed",
+                         G_CALLBACK (ev_window_print_operation_status_changed),
+                         (gpointer)ev_window);
+       g_signal_connect (G_OBJECT (op), "done",
+                         G_CALLBACK (ev_window_print_operation_done),
+                         (gpointer)ev_window);
+
        page_cache = ev_page_cache_get (ev_window->priv->document);
        current_page = ev_page_cache_get_current_page (page_cache);
        document_last_page = ev_page_cache_get_n_pages (page_cache);
        page_cache = ev_page_cache_get (ev_window->priv->document);
        current_page = ev_page_cache_get_current_page (page_cache);
        document_last_page = ev_page_cache_get_n_pages (page_cache);
@@ -2416,150 +2955,16 @@ ev_window_print_range (EvWindow *ev_window, int first_page, int last_page)
                                                    GTK_PRINT_PAGES_RANGES);
                gtk_print_settings_set_page_ranges (ev_window->priv->print_settings,
                                                    &range, 1);
                                                    GTK_PRINT_PAGES_RANGES);
                gtk_print_settings_set_page_ranges (ev_window->priv->print_settings,
                                                    &range, 1);
-       }
-
-       dialog = gtk_print_unix_dialog_new (_("Print"), GTK_WINDOW (ev_window));
-       ev_window->priv->print_dialog = dialog;
-       
-       capabilities = GTK_PRINT_CAPABILITY_PREVIEW |
-               ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (ev_window->priv->document));
-       gtk_print_unix_dialog_set_manual_capabilities (GTK_PRINT_UNIX_DIALOG (dialog),
-                                                      capabilities);
-
-       gtk_print_unix_dialog_set_current_page (GTK_PRINT_UNIX_DIALOG (dialog),
-                                               current_page);
-       
-       gtk_print_unix_dialog_set_settings (GTK_PRINT_UNIX_DIALOG (dialog),
-                                           ev_window->priv->print_settings);
-       
-       if (ev_window->priv->print_page_setup)
-               gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (dialog),
-                                                     ev_window->priv->print_page_setup);
-       
-       g_signal_connect (G_OBJECT (dialog), "response",
-                         G_CALLBACK (ev_window_print_dialog_response_cb),
-                         ev_window);
-
-       gtk_widget_show (dialog);
-}
-#endif /* WITH_GTK_PRINT */
-
-#ifdef WITH_GNOME_PRINT
-static gboolean
-ev_window_print_dialog_response_cb (GtkDialog *print_dialog,
-                                   gint       response,
-                                   EvWindow  *ev_window)
-{
-       EvPrintJob *print_job;
-       GnomePrintConfig *config;
-    
-       if (response != GNOME_PRINT_DIALOG_RESPONSE_PRINT) {
-               gtk_widget_destroy (GTK_WIDGET (print_dialog));
-               ev_window->priv->print_dialog = NULL;
-               g_object_unref (ev_window->priv->print_job);
-               ev_window->priv->print_job = NULL;
-               
-               return FALSE;
-       }
-
-       config = gnome_print_dialog_get_config (GNOME_PRINT_DIALOG (print_dialog));
-
-       /* FIXME: Change this when we have the first backend
-        * that can print more than postscript
-        */
-       if (using_pdf_printer (config)) {
-               GtkWidget *dialog;
-               
-               dialog = gtk_message_dialog_new (GTK_WINDOW (print_dialog), GTK_DIALOG_MODAL,
-                                                GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
-                                                _("Generating PDF is not supported"));
-               gtk_dialog_run (GTK_DIALOG (dialog));
-               gtk_widget_destroy (dialog);
-               
-               return FALSE;
-       } else if (!using_postscript_printer (config)) {
-               GtkWidget *dialog;
-
-               dialog = gtk_message_dialog_new (GTK_WINDOW (print_dialog), GTK_DIALOG_MODAL,
-                                                GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
-                                                _("Printing is not supported on this printer."));
-               gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
-                                                         _("You were trying to print to a printer using the “%s” driver. "
-                                                           "This program requires a PostScript printer driver."),
-                                                         gnome_print_config_get (config, (guchar *)"Settings.Engine.Backend.Driver"));
-               gtk_dialog_run (GTK_DIALOG (dialog));
-               gtk_widget_destroy (dialog);
-               
-               return FALSE;
-       }
-
-       save_print_config_to_file (config);
-    
-       print_job = g_object_new (EV_TYPE_PRINT_JOB,
-                                 "gnome_print_job", ev_window->priv->print_job,
-                                 "document", ev_window->priv->document,
-                                 "print_dialog", print_dialog,
-                                 NULL);
-
-       if (print_job != NULL) {
-               ev_print_job_print (print_job, GTK_WINDOW (ev_window));
-               g_object_unref (print_job);
-       }
-
-       g_object_unref (config);
-
-       gtk_widget_destroy (GTK_WIDGET (print_dialog));
-       ev_window->priv->print_dialog = NULL;
-       g_object_unref (ev_window->priv->print_job);
-       ev_window->priv->print_job = NULL;
-
-       return FALSE;
-}
-
-void
-ev_window_print_range (EvWindow *ev_window, int first_page, int last_page)
-{
-       GnomePrintConfig *config;
-       gchar *pages_label;
+       }
 
 
-        g_return_if_fail (EV_IS_WINDOW (ev_window));
-       g_return_if_fail (ev_window->priv->document != NULL);
+       ev_print_operation_set_job_name (op, gtk_window_get_title (GTK_WINDOW (ev_window)));
+       ev_print_operation_set_current_page (op, current_page);
+       ev_print_operation_set_print_settings (op, ev_window->priv->print_settings);
+       if (ev_window->priv->print_page_setup)
+               ev_print_operation_set_default_page_setup (op, ev_window->priv->print_page_setup);
 
 
-       config = load_print_config_from_file ();
-
-       if (ev_window->priv->print_job == NULL)
-               ev_window->priv->print_job = gnome_print_job_new (config);
-       
-       if (ev_window->priv->print_dialog == NULL) {
-               ev_window->priv->print_dialog =
-                       gnome_print_dialog_new (ev_window->priv->print_job,
-                                               (guchar *) _("Print"),
-                                               (GNOME_PRINT_DIALOG_RANGE |
-                                                GNOME_PRINT_DIALOG_COPIES));
-       }
-       
-       gtk_window_set_transient_for (GTK_WINDOW (ev_window->priv->print_dialog),
-                                     GTK_WINDOW (ev_window));                                                          
-       g_object_unref (config);                                                                
-
-       pages_label = g_strconcat (_("Pages"), " ", NULL);
-       gnome_print_dialog_construct_range_page (GNOME_PRINT_DIALOG (ev_window->priv->print_dialog),
-                                                GNOME_PRINT_RANGE_ALL |
-                                                GNOME_PRINT_RANGE_RANGE,
-                                                first_page, last_page,
-                                                NULL, (const guchar *)pages_label);
-       g_free (pages_label);
-                                                
-       gtk_dialog_set_response_sensitive (GTK_DIALOG (ev_window->priv->print_dialog),
-                                          GNOME_PRINT_DIALOG_RESPONSE_PREVIEW,
-                                          FALSE);
-
-       g_signal_connect (G_OBJECT (ev_window->priv->print_dialog), "response",
-                         G_CALLBACK (ev_window_print_dialog_response_cb),
-                         ev_window);
-       gtk_widget_show (ev_window->priv->print_dialog);
+       ev_print_operation_run (op, GTK_WINDOW (ev_window));
 }
 }
-#endif /* WITH_GNOME_PRINT */
 
 static void
 ev_window_print (EvWindow *window)
 
 static void
 ev_window_print (EvWindow *window)
@@ -2570,9 +2975,7 @@ ev_window_print (EvWindow *window)
        page_cache = ev_page_cache_get (window->priv->document);
        last_page = ev_page_cache_get_n_pages (page_cache);
 
        page_cache = ev_page_cache_get (window->priv->document);
        last_page = ev_page_cache_get_n_pages (page_cache);
 
-#ifdef WITH_PRINT
        ev_window_print_range (window, 1, last_page);
        ev_window_print_range (window, 1, last_page);
-#endif
 }
 
 static void
 }
 
 static void
@@ -2587,6 +2990,7 @@ ev_window_cmd_file_properties (GtkAction *action, EvWindow *ev_window)
        if (ev_window->priv->properties == NULL) {
                ev_window->priv->properties = ev_properties_dialog_new ();
                ev_properties_dialog_set_document (EV_PROPERTIES_DIALOG (ev_window->priv->properties),
        if (ev_window->priv->properties == NULL) {
                ev_window->priv->properties = ev_properties_dialog_new ();
                ev_properties_dialog_set_document (EV_PROPERTIES_DIALOG (ev_window->priv->properties),
+                                                  ev_window->priv->uri,
                                                   ev_window->priv->document);
                g_object_add_weak_pointer (G_OBJECT (ev_window->priv->properties),
                                           (gpointer) &(ev_window->priv->properties));
                                                   ev_window->priv->document);
                g_object_add_weak_pointer (G_OBJECT (ev_window->priv->properties),
                                           (gpointer) &(ev_window->priv->properties));
@@ -2598,13 +3002,97 @@ ev_window_cmd_file_properties (GtkAction *action, EvWindow *ev_window)
        gtk_widget_show (ev_window->priv->properties);
        ev_document_fc_mutex_unlock ();
 }
        gtk_widget_show (ev_window->priv->properties);
        ev_document_fc_mutex_unlock ();
 }
-                                       
+
+static void
+print_jobs_confirmation_dialog_response (GtkDialog *dialog,
+                                        gint       response,
+                                        EvWindow  *ev_window)
+{
+       gtk_widget_destroy (GTK_WIDGET (dialog));       
+       
+       switch (response) {
+       case GTK_RESPONSE_YES:
+               if (!ev_window->priv->print_queue ||
+                   g_queue_is_empty (ev_window->priv->print_queue))
+                       gtk_widget_destroy (GTK_WIDGET (ev_window));
+               else
+                       ev_window->priv->close_after_print = TRUE;
+               break;
+       case GTK_RESPONSE_NO:
+               ev_window->priv->close_after_print = TRUE;
+               if (ev_window->priv->print_queue &&
+                   !g_queue_is_empty (ev_window->priv->print_queue)) {
+                       gtk_widget_set_sensitive (GTK_WIDGET (ev_window), FALSE);
+                       ev_window_print_cancel (ev_window);
+               } else {
+                       gtk_widget_destroy (GTK_WIDGET (ev_window));
+               }
+               break;
+       case GTK_RESPONSE_CANCEL:
+       default:
+               ev_window->priv->close_after_print = FALSE;
+       }
+}
+
 static void
 ev_window_cmd_file_close_window (GtkAction *action, EvWindow *ev_window)
 {
 static void
 ev_window_cmd_file_close_window (GtkAction *action, EvWindow *ev_window)
 {
-       g_return_if_fail (EV_IS_WINDOW (ev_window));
+       GtkWidget *dialog;
+       gchar     *text, *markup;
+       gint       n_print_jobs;
+
+       n_print_jobs = ev_window->priv->print_queue ?
+               g_queue_get_length (ev_window->priv->print_queue) : 0;
+       
+       if (n_print_jobs == 0) {
+               gtk_widget_destroy (GTK_WIDGET (ev_window));
+               return;
+       }
+
+       dialog = gtk_message_dialog_new (GTK_WINDOW (ev_window),
+                                        GTK_DIALOG_MODAL,
+                                        GTK_MESSAGE_QUESTION,
+                                        GTK_BUTTONS_NONE,
+                                        NULL);
+       if (n_print_jobs == 1) {
+               EvPrintOperation *op;
+               const gchar      *job_name;
+
+               op = g_queue_peek_tail (ev_window->priv->print_queue);
+               job_name = ev_print_operation_get_job_name (op);
+
+               text = g_strdup_printf (_("Wait until print job “%s” finishes before closing?"),
+                                       job_name);
+       } else {
+               text = g_strdup_printf (_("There are %d print jobs active. "
+                                         "Wait until print finishes before closing?"),
+                                       n_print_jobs);
+       }
+
+       markup = g_strdup_printf ("<b>%s</b>", text);
+       g_free (text);
+
+       gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), markup);
+       g_free (markup);
 
 
-       gtk_widget_destroy (GTK_WIDGET (ev_window));
+       gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s",
+                                                 _("If you close the window, pending print "
+                                                   "jobs will not be printed."));
+       
+       gtk_dialog_add_buttons (GTK_DIALOG (dialog),
+                               _("Cancel _print and Close"),
+                               GTK_RESPONSE_NO,
+                               GTK_STOCK_CANCEL,
+                               GTK_RESPONSE_CANCEL,
+                               _("Close after _Printing"),
+                               GTK_RESPONSE_YES,
+                               NULL);
+       gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES);
+
+       g_signal_connect (dialog, "response",
+                         G_CALLBACK (print_jobs_confirmation_dialog_response),
+                         ev_window);
+       gtk_widget_show (dialog);
 }
 
 static void
 }
 
 static void
@@ -2624,13 +3112,13 @@ ev_window_cmd_focus_page_selector (GtkAction *act, EvWindow *window)
 static void
 ev_window_cmd_scroll_forward (GtkAction *action, EvWindow *window)
 {
 static void
 ev_window_cmd_scroll_forward (GtkAction *action, EvWindow *window)
 {
-       ev_view_scroll (EV_VIEW (window->priv->view), EV_SCROLL_PAGE_FORWARD, FALSE);
+       ev_view_scroll (EV_VIEW (window->priv->view), GTK_SCROLL_PAGE_FORWARD, FALSE);
 }
 
 static void
 ev_window_cmd_scroll_backward (GtkAction *action, EvWindow *window)
 {
 }
 
 static void
 ev_window_cmd_scroll_backward (GtkAction *action, EvWindow *window)
 {
-       ev_view_scroll (EV_VIEW (window->priv->view), EV_SCROLL_PAGE_BACKWARD, FALSE);
+       ev_view_scroll (EV_VIEW (window->priv->view), GTK_SCROLL_PAGE_BACKWARD, FALSE);
 }
 
 static void
 }
 
 static void
@@ -2638,7 +3126,7 @@ ev_window_cmd_continuous (GtkAction *action, EvWindow *ev_window)
 {
        gboolean continuous;
 
 {
        gboolean continuous;
 
-       ev_window_stop_presentation (ev_window);
+       ev_window_stop_presentation (ev_window, TRUE);
        continuous = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
        g_object_set (G_OBJECT (ev_window->priv->view),
                      "continuous", continuous,
        continuous = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
        g_object_set (G_OBJECT (ev_window->priv->view),
                      "continuous", continuous,
@@ -2651,7 +3139,7 @@ ev_window_cmd_dual (GtkAction *action, EvWindow *ev_window)
 {
        gboolean dual_page;
 
 {
        gboolean dual_page;
 
-       ev_window_stop_presentation (ev_window);
+       ev_window_stop_presentation (ev_window, TRUE);
        dual_page = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
        g_object_set (G_OBJECT (ev_window->priv->view),
                      "dual-page", dual_page,
        dual_page = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
        g_object_set (G_OBJECT (ev_window->priv->view),
                      "dual-page", dual_page,
@@ -2662,7 +3150,7 @@ ev_window_cmd_dual (GtkAction *action, EvWindow *ev_window)
 static void
 ev_window_cmd_view_best_fit (GtkAction *action, EvWindow *ev_window)
 {
 static void
 ev_window_cmd_view_best_fit (GtkAction *action, EvWindow *ev_window)
 {
-       ev_window_stop_presentation (ev_window);
+       ev_window_stop_presentation (ev_window, TRUE);
 
        if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action))) {
                ev_view_set_sizing_mode (EV_VIEW (ev_window->priv->view), EV_SIZING_BEST_FIT);
 
        if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action))) {
                ev_view_set_sizing_mode (EV_VIEW (ev_window->priv->view), EV_SIZING_BEST_FIT);
@@ -2675,7 +3163,7 @@ ev_window_cmd_view_best_fit (GtkAction *action, EvWindow *ev_window)
 static void
 ev_window_cmd_view_page_width (GtkAction *action, EvWindow *ev_window)
 {
 static void
 ev_window_cmd_view_page_width (GtkAction *action, EvWindow *ev_window)
 {
-       ev_window_stop_presentation (ev_window);
+       ev_window_stop_presentation (ev_window, TRUE);
 
        if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action))) {
                ev_view_set_sizing_mode (EV_VIEW (ev_window->priv->view), EV_SIZING_FIT_WIDTH);
 
        if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action))) {
                ev_view_set_sizing_mode (EV_VIEW (ev_window->priv->view), EV_SIZING_FIT_WIDTH);
@@ -2804,6 +3292,12 @@ fullscreen_toolbar_remove_shadow (GtkWidget *toolbar)
 static void
 ev_window_run_fullscreen (EvWindow *window)
 {
 static void
 ev_window_run_fullscreen (EvWindow *window)
 {
+       EvView  *view = EV_VIEW (window->priv->view);
+       gboolean fullscreen_window = TRUE;
+
+       if (ev_view_get_fullscreen (view))
+               return;
+       
        if (!window->priv->fullscreen_toolbar) {
                window->priv->fullscreen_toolbar =
                        gtk_ui_manager_get_widget (window->priv->ui_manager,
        if (!window->priv->fullscreen_toolbar) {
                window->priv->fullscreen_toolbar =
                        gtk_ui_manager_get_widget (window->priv->ui_manager,
@@ -2821,11 +3315,16 @@ ev_window_run_fullscreen (EvWindow *window)
                                       window->priv->fullscreen_toolbar, 1);
        }
 
                                       window->priv->fullscreen_toolbar, 1);
        }
 
+       if (ev_view_get_presentation (view)) {
+               ev_window_stop_presentation (window, FALSE);
+               fullscreen_window = FALSE;
+       }
+
        g_object_set (G_OBJECT (window->priv->scrolled_window),
                      "shadow-type", GTK_SHADOW_NONE,
                      NULL);
 
        g_object_set (G_OBJECT (window->priv->scrolled_window),
                      "shadow-type", GTK_SHADOW_NONE,
                      NULL);
 
-       ev_view_set_fullscreen (EV_VIEW (window->priv->view), TRUE);
+       ev_view_set_fullscreen (view, TRUE);
        ev_window_update_fullscreen_action (window);
 
        /* If the user doesn't have the main toolbar he/she won't probably want
        ev_window_update_fullscreen_action (window);
 
        /* If the user doesn't have the main toolbar he/she won't probably want
@@ -2834,8 +3333,9 @@ ev_window_run_fullscreen (EvWindow *window)
        update_chrome_flag (window, EV_CHROME_FULLSCREEN_TOOLBAR,
                            (window->priv->chrome & EV_CHROME_TOOLBAR) != 0);
        update_chrome_visibility (window);
        update_chrome_flag (window, EV_CHROME_FULLSCREEN_TOOLBAR,
                            (window->priv->chrome & EV_CHROME_TOOLBAR) != 0);
        update_chrome_visibility (window);
-       
-       gtk_window_fullscreen (GTK_WINDOW (window));
+
+       if (fullscreen_window)
+               gtk_window_fullscreen (GTK_WINDOW (window));
        gtk_widget_grab_focus (window->priv->view);
 
        if (!ev_window_is_empty (window))
        gtk_widget_grab_focus (window->priv->view);
 
        if (!ev_window_is_empty (window))
@@ -2843,11 +3343,12 @@ ev_window_run_fullscreen (EvWindow *window)
 }
 
 static void
 }
 
 static void
-ev_window_stop_fullscreen (EvWindow *window)
+ev_window_stop_fullscreen (EvWindow *window,
+                          gboolean  unfullscreen_window)
 {
        EvView *view = EV_VIEW (window->priv->view);
 
 {
        EvView *view = EV_VIEW (window->priv->view);
 
-       if (!ev_view_get_fullscreen (EV_VIEW (view)))
+       if (!ev_view_get_fullscreen (view))
                return;
 
        g_object_set (G_OBJECT (window->priv->scrolled_window),
                return;
 
        g_object_set (G_OBJECT (window->priv->scrolled_window),
@@ -2858,7 +3359,8 @@ ev_window_stop_fullscreen (EvWindow *window)
        ev_window_update_fullscreen_action (window);
        update_chrome_flag (window, EV_CHROME_FULLSCREEN_TOOLBAR, FALSE);
        update_chrome_visibility (window);
        ev_window_update_fullscreen_action (window);
        update_chrome_flag (window, EV_CHROME_FULLSCREEN_TOOLBAR, FALSE);
        update_chrome_visibility (window);
-       gtk_window_unfullscreen (GTK_WINDOW (window));
+       if (unfullscreen_window)
+               gtk_window_unfullscreen (GTK_WINDOW (window));
 
        if (!ev_window_is_empty (window))
                ev_metadata_manager_set_boolean (window->priv->uri, "fullscreen", FALSE);
 
        if (!ev_window_is_empty (window))
                ev_metadata_manager_set_boolean (window->priv->uri, "fullscreen", FALSE);
@@ -2869,14 +3371,11 @@ ev_window_cmd_view_fullscreen (GtkAction *action, EvWindow *window)
 {
        gboolean fullscreen;
 
 {
        gboolean fullscreen;
 
-        g_return_if_fail (EV_IS_WINDOW (window));
-       ev_window_stop_presentation (window);
-
        fullscreen = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
        if (fullscreen) {
                ev_window_run_fullscreen (window);
        } else {
        fullscreen = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
        if (fullscreen) {
                ev_window_run_fullscreen (window);
        } else {
-               ev_window_stop_fullscreen (window);
+               ev_window_stop_fullscreen (window, TRUE);
        }
 }
 
        }
 }
 
@@ -2961,17 +3460,29 @@ ev_window_update_presentation_action (EvWindow *window)
 static void
 ev_window_run_presentation (EvWindow *window)
 {
 static void
 ev_window_run_presentation (EvWindow *window)
 {
+       EvView  *view = EV_VIEW (window->priv->view);
+       gboolean fullscreen_window = TRUE;
+
+       if (ev_view_get_presentation (view))
+               return;
+
+       if (ev_view_get_fullscreen (view)) {
+               ev_window_stop_fullscreen (window, FALSE);
+               fullscreen_window = FALSE;
+       }
+       
        g_object_set (G_OBJECT (window->priv->scrolled_window),
                      "shadow-type", GTK_SHADOW_NONE,
                      NULL);
 
        g_object_set (G_OBJECT (window->priv->scrolled_window),
                      "shadow-type", GTK_SHADOW_NONE,
                      NULL);
 
-       ev_view_set_presentation (EV_VIEW (window->priv->view), TRUE);
+       ev_view_set_presentation (view, TRUE);
        ev_window_update_presentation_action (window);
 
        update_chrome_visibility (window);
        
        gtk_widget_grab_focus (window->priv->view);
        ev_window_update_presentation_action (window);
 
        update_chrome_visibility (window);
        
        gtk_widget_grab_focus (window->priv->view);
-       gtk_window_fullscreen (GTK_WINDOW (window));
+       if (fullscreen_window)
+               gtk_window_fullscreen (GTK_WINDOW (window));
 
        g_signal_connect (window->priv->view,
                          "motion-notify-event",
 
        g_signal_connect (window->priv->view,
                          "motion-notify-event",
@@ -2990,9 +3501,12 @@ ev_window_run_presentation (EvWindow *window)
 }
 
 static void
 }
 
 static void
-ev_window_stop_presentation (EvWindow *window)
+ev_window_stop_presentation (EvWindow *window,
+                            gboolean  unfullscreen_window)
 {
 {
-       if (!ev_view_get_presentation (EV_VIEW (window->priv->view)))
+       EvView *view = EV_VIEW (window->priv->view);
+       
+       if (!ev_view_get_presentation (view))
                return;
 
        g_object_set (G_OBJECT (window->priv->scrolled_window),
                return;
 
        g_object_set (G_OBJECT (window->priv->scrolled_window),
@@ -3002,7 +3516,8 @@ ev_window_stop_presentation (EvWindow *window)
        ev_view_set_presentation (EV_VIEW (window->priv->view), FALSE);
        ev_window_update_presentation_action (window);
        update_chrome_visibility (window);
        ev_view_set_presentation (EV_VIEW (window->priv->view), FALSE);
        ev_window_update_presentation_action (window);
        update_chrome_visibility (window);
-       gtk_window_unfullscreen (GTK_WINDOW (window));
+       if (unfullscreen_window)
+               gtk_window_unfullscreen (GTK_WINDOW (window));
 
        g_signal_handlers_disconnect_by_func (window->priv->view,
                                              (gpointer) presentation_motion_notify_cb,
 
        g_signal_handlers_disconnect_by_func (window->priv->view,
                                              (gpointer) presentation_motion_notify_cb,
@@ -3023,14 +3538,9 @@ ev_window_cmd_view_presentation (GtkAction *action, EvWindow *window)
 {
        gboolean presentation;
 
 {
        gboolean presentation;
 
-       g_return_if_fail (EV_IS_WINDOW (window));
-       ev_window_stop_fullscreen (window);
-
        presentation = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
        if (presentation) {
                ev_window_run_presentation (window);
        presentation = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
        if (presentation) {
                ev_window_run_presentation (window);
-       } else {
-               ev_window_stop_presentation (window);
        }
 }
 
        }
 }
 
@@ -3061,11 +3571,7 @@ ev_window_run_preview (EvWindow *window)
        
        action = gtk_action_group_get_action (window->priv->action_group,
                                              "PreviewPrint");
        
        action = gtk_action_group_get_action (window->priv->action_group,
                                              "PreviewPrint");
-#if GTK_CHECK_VERSION (2, 11, 0)
        gtk_action_set_visible (action, TRUE);
        gtk_action_set_visible (action, TRUE);
-#else
-       gtk_action_set_visible (action, FALSE);
-#endif
 
        update_chrome_visibility (window);
 }
 
        update_chrome_visibility (window);
 }
@@ -3090,6 +3596,35 @@ ev_window_screen_changed (GtkWidget *widget,
        }
 }
 
        }
 }
 
+static gboolean
+ev_window_state_event (GtkWidget           *widget,
+                      GdkEventWindowState *event)
+{
+       EvWindow *window = EV_WINDOW (widget);
+       EvView   *view = EV_VIEW (window->priv->view);
+
+       if (GTK_WIDGET_CLASS (ev_window_parent_class)->window_state_event) {
+               GTK_WIDGET_CLASS (ev_window_parent_class)->window_state_event (widget, event);
+       }
+
+       if ((event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) == 0)
+               return FALSE;
+
+       if (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) {
+               if (ev_view_get_fullscreen (view) || ev_view_get_presentation (view))
+                       return FALSE;
+               
+               ev_window_run_fullscreen (window);
+       } else {
+               if (ev_view_get_fullscreen (view))
+                       ev_window_stop_fullscreen (window, FALSE);
+               else if (ev_view_get_presentation (view))
+                       ev_window_stop_presentation (window, FALSE);
+       }
+
+       return FALSE;
+}
+
 static void
 ev_window_set_page_mode (EvWindow         *window,
                         EvWindowPageMode  page_mode)
 static void
 ev_window_set_page_mode (EvWindow         *window,
                         EvWindowPageMode  page_mode)
@@ -3263,11 +3798,7 @@ ev_window_cmd_go_backward (GtkAction *action, EvWindow *ev_window)
 static void
 ev_window_cmd_view_reload (GtkAction *action, EvWindow *ev_window)
 {
 static void
 ev_window_cmd_view_reload (GtkAction *action, EvWindow *ev_window)
 {
-       gchar *uri;
-
-       uri = g_strdup (ev_window->priv->uri);
-       ev_window_open_uri (ev_window, uri, NULL, 0, NULL, FALSE, NULL);
-       g_free (uri);
+       ev_window_reload_document (ev_window);
 }
 
 static void
 }
 
 static void
@@ -3276,6 +3807,23 @@ ev_window_cmd_view_autoscroll (GtkAction *action, EvWindow *ev_window)
        ev_view_autoscroll_start (EV_VIEW (ev_window->priv->view));
 }
 
        ev_view_autoscroll_start (EV_VIEW (ev_window->priv->view));
 }
 
+#if GTK_CHECK_VERSION (2, 14, 0)
+static void
+ev_window_cmd_help_contents (GtkAction *action, EvWindow *ev_window)
+{
+       GError  *error = NULL;
+
+       gtk_show_uri (gtk_window_get_screen (GTK_WINDOW (ev_window)),
+                     "ghelp:evince",
+                     GDK_CURRENT_TIME,
+                     &error);
+       if (error) {
+               ev_window_error_message (ev_window, error, 
+                                        "%s", _("There was an error displaying help"));
+               g_error_free (error);
+       }
+}
+#else /* !GTK_CHECK_VERSION (2, 14, 0) */
 static void
 ev_window_cmd_help_contents (GtkAction *action, EvWindow *ev_window)
 {
 static void
 ev_window_cmd_help_contents (GtkAction *action, EvWindow *ev_window)
 {
@@ -3319,28 +3867,25 @@ ev_window_cmd_help_contents (GtkAction *action, EvWindow *ev_window)
        screen = gtk_widget_get_screen (GTK_WIDGET (ev_window));
        gdk_spawn_command_line_on_screen (screen, command, &error);
        if (error != NULL) {
        screen = gtk_widget_get_screen (GTK_WIDGET (ev_window));
        gdk_spawn_command_line_on_screen (screen, command, &error);
        if (error != NULL) {
-               g_warning (error->message);
+               g_warning ("%s", error->message);
                g_error_free (error);
        }
        g_free (command);
 }
                g_error_free (error);
        }
        g_free (command);
 }
+#endif /* GTK_CHECK_VERSION (2, 14, 0) */
 
 static void
 ev_window_cmd_leave_fullscreen (GtkAction *action, EvWindow *window)
 {
 
 static void
 ev_window_cmd_leave_fullscreen (GtkAction *action, EvWindow *window)
 {
-       ev_window_stop_fullscreen (window);
+       ev_window_stop_fullscreen (window, TRUE);
 }
 
 static void
 ev_window_cmd_start_presentation (GtkAction *action, EvWindow *window)
 {
 }
 
 static void
 ev_window_cmd_start_presentation (GtkAction *action, EvWindow *window)
 {
-       ev_window_stop_fullscreen (window);
        ev_window_run_presentation (window);
 }
 
        ev_window_run_presentation (window);
 }
 
-#ifdef WITH_GTK_PRINT
-static void ev_window_do_preview_print (EvWindow *window);
-
 static gboolean
 ev_window_enumerate_printer_cb (GtkPrinter *printer,
                                EvWindow   *window)
 static gboolean
 ev_window_enumerate_printer_cb (GtkPrinter *printer,
                                EvWindow   *window)
@@ -3371,18 +3916,8 @@ ev_window_preview_print_finished (GtkPrintJob *print_job,
                                  GError      *error)
 {
        if (error) {
                                  GError      *error)
 {
        if (error) {
-               GtkWidget *dialog;
-
-               dialog = gtk_message_dialog_new (GTK_WINDOW (window),
-                                                GTK_DIALOG_MODAL,
-                                                GTK_MESSAGE_ERROR,
-                                                GTK_BUTTONS_OK,
-                                                _("Failed to print document"));
-               gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
-                                                         error->message);
-
-               gtk_dialog_run (GTK_DIALOG (dialog));
-               gtk_widget_destroy (dialog);
+               ev_window_error_message (window, error,
+                                        "%s", _("Failed to print document"));
        }
 
        g_object_unref (print_job);
        }
 
        g_object_unref (print_job);
@@ -3393,7 +3928,6 @@ static void
 ev_window_do_preview_print (EvWindow *window)
 {
        EvWindowPrivate  *priv = window->priv;
 ev_window_do_preview_print (EvWindow *window)
 {
        EvWindowPrivate  *priv = window->priv;
-       GtkPageSetup     *page_setup;
        GtkPrintJob      *job;
        gchar            *filename;
        GError           *error = NULL;
        GtkPrintJob      *job;
        gchar            *filename;
        GError           *error = NULL;
@@ -3401,18 +3935,17 @@ ev_window_do_preview_print (EvWindow *window)
        g_assert (priv->print_settings != NULL);
        g_assert (priv->printer != NULL);
 
        g_assert (priv->print_settings != NULL);
        g_assert (priv->printer != NULL);
 
-       page_setup = gtk_page_setup_new ();
-
-       job = gtk_print_job_new ("evince-print",
+       job = gtk_print_job_new (gtk_window_get_title (GTK_WINDOW (window)),
                                 priv->printer,
                                 priv->print_settings,
                                 priv->printer,
                                 priv->print_settings,
-                                page_setup);
+                                priv->print_page_setup);
 
        g_object_unref (priv->print_settings);
        priv->print_settings = NULL;
 
        g_object_unref (priv->print_settings);
        priv->print_settings = NULL;
+       g_object_unref (priv->print_page_setup);
+       priv->print_page_setup = NULL;
        g_object_unref (priv->printer);
        priv->printer = NULL;
        g_object_unref (priv->printer);
        priv->printer = NULL;
-       g_object_unref (page_setup);
 
        filename = g_filename_from_uri (priv->local_uri ?
                                        priv->local_uri : priv->uri,
 
        filename = g_filename_from_uri (priv->local_uri ?
                                        priv->local_uri : priv->uri,
@@ -3423,7 +3956,7 @@ ev_window_do_preview_print (EvWindow *window)
                                    (GtkPrintJobCompleteFunc)ev_window_preview_print_finished,
                                    window, NULL);
        } else {
                                    (GtkPrintJobCompleteFunc)ev_window_preview_print_finished,
                                    window, NULL);
        } else {
-               g_warning (error->message);
+               g_warning ("%s", error->message);
                g_error_free (error);
        }
 
                g_error_free (error);
        }
 
@@ -3432,43 +3965,56 @@ ev_window_do_preview_print (EvWindow *window)
        gtk_widget_hide (GTK_WIDGET (window));
 }
 
        gtk_widget_hide (GTK_WIDGET (window));
 }
 
-#endif /* WITH_GTK_PRINT */
-
 static void
 ev_window_cmd_preview_print (GtkAction *action, EvWindow *window)
 {
 static void
 ev_window_cmd_preview_print (GtkAction *action, EvWindow *window)
 {
-#ifdef WITH_GTK_PRINT
-       EvWindowPrivate *priv = window->priv;
-       GtkPrintSettings *print_settings = NULL;
-#if GTK_CHECK_VERSION (2, 11, 0)
+       EvWindowPrivate  *priv = window->priv;
+       GtkPrintSettings *print_settings;
+       GtkPageSetup     *page_setup;
        const gchar      *print_settings_file = priv->print_settings_file;
 
        const gchar      *print_settings_file = priv->print_settings_file;
 
-       if (print_settings_file) {
-               if (g_file_test (print_settings_file, G_FILE_TEST_IS_REGULAR)) {
-                       GError *error = NULL;
-
-                       print_settings = gtk_print_settings_new_from_file (print_settings_file,
-                                                                          &error);
+       if (print_settings_file && g_file_test (print_settings_file, G_FILE_TEST_IS_REGULAR)) {
+               GKeyFile *key_file;
+               GError   *error = NULL;
+
+               key_file = g_key_file_new ();
+               g_key_file_load_from_file (key_file,
+                                          print_settings_file,
+                                          G_KEY_FILE_KEEP_COMMENTS |
+                                          G_KEY_FILE_KEEP_TRANSLATIONS,
+                                          &error);
+               if (!error) {
+                       print_settings =
+                               gtk_print_settings_new_from_key_file (key_file,
+                                                                     "Print Settings",
+                                                                     NULL);
+                       print_settings = print_settings ? print_settings : gtk_print_settings_new ();
                        
                        
-                       if (error) {
-                               g_warning (error->message);
-                               g_error_free (error);
-                               print_settings = NULL;
-                       }
+                       page_setup = gtk_page_setup_new_from_key_file (key_file,
+                                                                      "Page Setup",
+                                                                      NULL);
+                       page_setup = page_setup ? page_setup : gtk_page_setup_new ();
+               } else {
+                       print_settings = gtk_print_settings_new ();
+                       page_setup = gtk_page_setup_new ();
+                       g_error_free (error);
                }
                }
+
+               g_key_file_free (key_file);
+       } else {
+               print_settings = gtk_print_settings_new ();
+               page_setup = gtk_page_setup_new ();
        }
        }
-#endif /* GTK 2.11.0 */
        
        
-       if (!print_settings)
-               print_settings = gtk_print_settings_new ();
-
        if (priv->print_settings)
                g_object_unref (priv->print_settings);
        priv->print_settings = print_settings;
        if (priv->print_settings)
                g_object_unref (priv->print_settings);
        priv->print_settings = print_settings;
+       if (priv->print_page_setup)
+               g_object_unref (priv->print_page_setup);
+       priv->print_page_setup = page_setup;
 
        gtk_enumerate_printers ((GtkPrinterFunc) ev_window_enumerate_printer_cb,
                                window, NULL, FALSE);
 
        gtk_enumerate_printers ((GtkPrinterFunc) ev_window_enumerate_printer_cb,
                                window, NULL, FALSE);
-#endif /* WITH_GTK_PRINT */
 }
 
 static void
 }
 
 static void
@@ -3476,7 +4022,7 @@ ev_window_cmd_escape (GtkAction *action, EvWindow *window)
 {
        GtkWidget *widget;
 
 {
        GtkWidget *widget;
 
-       ev_view_autoscroll_stop (window->priv->view);
+       ev_view_autoscroll_stop (EV_VIEW (window->priv->view));
        
        widget = gtk_window_get_focus (GTK_WINDOW (window));
        if (widget && gtk_widget_get_ancestor (widget, EGG_TYPE_FIND_BAR)) {
        
        widget = gtk_window_get_focus (GTK_WINDOW (window));
        if (widget && gtk_widget_get_ancestor (widget, EGG_TYPE_FIND_BAR)) {
@@ -3493,9 +4039,9 @@ ev_window_cmd_escape (GtkAction *action, EvWindow *window)
                              NULL);
 
                if (fullscreen) {
                              NULL);
 
                if (fullscreen) {
-                       ev_window_stop_fullscreen (window);
+                       ev_window_stop_fullscreen (window, TRUE);
                } else if (presentation) {
                } else if (presentation) {
-                       ev_window_stop_presentation (window);
+                       ev_window_stop_presentation (window, TRUE);
                        gtk_widget_grab_focus (window->priv->view);
                } else {
                        gtk_widget_grab_focus (window->priv->view);
                        gtk_widget_grab_focus (window->priv->view);
                } else {
                        gtk_widget_grab_focus (window->priv->view);
@@ -3792,6 +4338,8 @@ ev_window_sidebar_current_page_changed_cb (EvSidebar  *ev_sidebar,
                id = THUMBNAILS_SIDEBAR_ID;
        } else if (current_page == ev_window->priv->sidebar_attachments) {
                id = ATTACHMENTS_SIDEBAR_ID;
                id = THUMBNAILS_SIDEBAR_ID;
        } else if (current_page == ev_window->priv->sidebar_attachments) {
                id = ATTACHMENTS_SIDEBAR_ID;
+       } else if (current_page == ev_window->priv->sidebar_layers) {
+               id = LAYERS_SIDEBAR_ID;
        } else {
                g_assert_not_reached();
        }
        } else {
                g_assert_not_reached();
        }
@@ -3946,15 +4494,73 @@ attachment_bar_menu_popup_cb (EvSidebarAttachments *attachbar,
 }
 
 static void
 }
 
 static void
-view_find_status_changed_cb (EvView     *view,
-                            GParamSpec *pspec,
-                            EvWindow   *ev_window)
+ev_window_update_find_status_message (EvWindow *ev_window)
+{
+       gchar *message;
+
+       if (!ev_window->priv->find_job)
+               return;
+       
+       if (ev_job_is_finished (ev_window->priv->find_job)) {
+               gint n_results;
+
+               n_results = ev_job_find_get_n_results (EV_JOB_FIND (ev_window->priv->find_job),
+                                                      ev_page_cache_get_current_page (ev_window->priv->page_cache));
+               /* TRANS: Sometimes this could be better translated as
+                                     "%d hit(s) on this page".  Therefore this string
+                                     contains plural cases. */
+               message = g_strdup_printf (ngettext ("%d found on this page",
+                                                    "%d found on this page",
+                                                    n_results),
+                                          n_results);
+       } else {
+               gdouble percent;
+
+               percent = ev_job_find_get_progress (EV_JOB_FIND (ev_window->priv->find_job));
+               message = g_strdup_printf (_("%3d%% remaining to search"),
+                                          (gint) ((1.0 - percent) * 100));
+       }
+       
+       egg_find_bar_set_status_text (EGG_FIND_BAR (ev_window->priv->find_bar), message);
+       g_free (message);
+}
+
+static void
+ev_window_find_job_finished_cb (EvJobFind *job,
+                               EvWindow  *ev_window)
+{
+       ev_window_update_find_status_message (ev_window);
+}
+
+static void
+ev_window_find_job_updated_cb (EvJobFind *job,
+                              gint       page,
+                              EvWindow  *ev_window)
+{
+       ev_window_update_actions (ev_window);
+       
+       ev_view_find_changed (EV_VIEW (ev_window->priv->view),
+                             ev_job_find_get_results (job),
+                             page);
+       ev_window_update_find_status_message (ev_window);
+}
+
+static void
+ev_window_clear_find_job (EvWindow *ev_window)
 {
 {
-       const char *text;
+       if (ev_window->priv->find_job != NULL) {
+               if (!ev_job_is_finished (ev_window->priv->find_job))
+                       ev_job_cancel (ev_window->priv->find_job);
 
 
-       text = ev_view_get_find_status (view);
-       egg_find_bar_set_status_text (EGG_FIND_BAR (ev_window->priv->find_bar),
-                                     text);
+               g_signal_handlers_disconnect_by_func (ev_window->priv->find_job,
+                                                     ev_window_find_job_finished_cb,
+                                                     ev_window);
+               g_signal_handlers_disconnect_by_func (ev_window->priv->find_job,
+                                                     ev_window_find_job_updated_cb,
+                                                     ev_window);
+               g_object_unref (ev_window->priv->find_job);
+               ev_window->priv->find_job = NULL;
+       }
 }
 
 static void
 }
 
 static void
@@ -3975,6 +4581,8 @@ static void
 find_bar_close_cb (EggFindBar *find_bar,
                   EvWindow   *ev_window)
 {
 find_bar_close_cb (EggFindBar *find_bar,
                   EvWindow   *ev_window)
 {
+       ev_view_find_cancel (EV_VIEW (ev_window->priv->view));
+       ev_window_clear_find_job (ev_window);
        update_chrome_flag (ev_window, EV_CHROME_FINDBAR, FALSE);
        update_chrome_visibility (ev_window);
 }
        update_chrome_flag (ev_window, EV_CHROME_FINDBAR, FALSE);
        update_chrome_visibility (ev_window);
 }
@@ -3987,39 +4595,42 @@ find_bar_search_changed_cb (EggFindBar *find_bar,
        gboolean case_sensitive;
        const char *search_string;
 
        gboolean case_sensitive;
        const char *search_string;
 
+       if (!ev_window->priv->document || !EV_IS_DOCUMENT_FIND (ev_window->priv->document))
+               return;
+       
        /* Either the string or case sensitivity could have changed. */
        /* Either the string or case sensitivity could have changed. */
-
        case_sensitive = egg_find_bar_get_case_sensitive (find_bar);
        search_string = egg_find_bar_get_search_string (find_bar);
 
        case_sensitive = egg_find_bar_get_case_sensitive (find_bar);
        search_string = egg_find_bar_get_search_string (find_bar);
 
-       ev_view_search_changed (EV_VIEW(ev_window->priv->view));
+       ev_view_find_search_changed (EV_VIEW (ev_window->priv->view));
 
 
-       if (ev_window->priv->document &&
-           EV_IS_DOCUMENT_FIND (ev_window->priv->document)) {
-               if (search_string && search_string[0]) {
-                       ev_document_doc_mutex_lock ();
-                       ev_document_find_begin (EV_DOCUMENT_FIND (ev_window->priv->document), 
-                                               ev_page_cache_get_current_page (ev_window->priv->page_cache),
-                                               search_string,
-                                               case_sensitive);
-                       ev_document_doc_mutex_unlock ();
-               } else {
-                       ev_document_doc_mutex_lock ();
-                       ev_document_find_cancel (EV_DOCUMENT_FIND (ev_window->priv->document));
-                       ev_document_doc_mutex_unlock ();
-
-                       ev_window_update_actions (ev_window);
-                       egg_find_bar_set_status_text (EGG_FIND_BAR (ev_window->priv->find_bar),
-                                                     NULL);
-                       gtk_widget_queue_draw (GTK_WIDGET (ev_window->priv->view));
-               }
+       ev_window_clear_find_job (ev_window);
+
+       if (search_string && search_string[0]) {
+               ev_window->priv->find_job = ev_job_find_new (ev_window->priv->document,
+                                                            ev_page_cache_get_current_page (ev_window->priv->page_cache),
+                                                            ev_page_cache_get_n_pages (ev_window->priv->page_cache),
+                                                            search_string,
+                                                            case_sensitive);
+               g_signal_connect (ev_window->priv->find_job, "finished",
+                                 G_CALLBACK (ev_window_find_job_finished_cb),
+                                 ev_window);
+               g_signal_connect (ev_window->priv->find_job, "updated",
+                                 G_CALLBACK (ev_window_find_job_updated_cb),
+                                 ev_window);
+               ev_job_scheduler_push_job (ev_window->priv->find_job, EV_JOB_PRIORITY_NONE);
+       } else {
+               ev_window_update_actions (ev_window);
+               egg_find_bar_set_status_text (EGG_FIND_BAR (ev_window->priv->find_bar),
+                                             NULL);
+               gtk_widget_queue_draw (GTK_WIDGET (ev_window->priv->view));
        }
 }
 
 static void
 find_bar_visibility_changed_cb (EggFindBar *find_bar,
        }
 }
 
 static void
 find_bar_visibility_changed_cb (EggFindBar *find_bar,
-                           GParamSpec *param,
-                           EvWindow   *ev_window)
+                               GParamSpec *param,
+                               EvWindow   *ev_window)
 {
        gboolean visible;
 
 {
        gboolean visible;
 
@@ -4027,19 +4638,23 @@ find_bar_visibility_changed_cb (EggFindBar *find_bar,
 
        if (ev_window->priv->document &&
            EV_IS_DOCUMENT_FIND (ev_window->priv->document)) {
 
        if (ev_window->priv->document &&
            EV_IS_DOCUMENT_FIND (ev_window->priv->document)) {
-               ev_view_set_highlight_search (EV_VIEW(ev_window->priv->view), visible);
-               ev_view_search_changed (EV_VIEW(ev_window->priv->view));
+               ev_view_find_set_highlight_search (EV_VIEW (ev_window->priv->view), visible);
+               ev_view_find_search_changed (EV_VIEW (ev_window->priv->view));
                ev_window_update_actions (ev_window);
 
                ev_window_update_actions (ev_window);
 
-               if (!visible)
+               if (visible)
+                       find_bar_search_changed_cb (find_bar, NULL, ev_window);
+               else
                        egg_find_bar_set_status_text (EGG_FIND_BAR (ev_window->priv->find_bar), NULL);
        }
 }
 
 static void
                        egg_find_bar_set_status_text (EGG_FIND_BAR (ev_window->priv->find_bar), NULL);
        }
 }
 
 static void
-find_bar_scroll(EggFindBar *find_bar, GtkScrollType scroll, EvWindow* ev_window)
+find_bar_scroll (EggFindBar   *find_bar,
+                GtkScrollType scroll,
+                EvWindow     *ev_window)
 {
 {
-       ev_view_scroll(EV_VIEW(ev_window->priv->view), scroll, FALSE);
+       ev_view_scroll (EV_VIEW (ev_window->priv->view), scroll, FALSE);
 }
 
 static void
 }
 
 static void
@@ -4087,7 +4702,24 @@ ev_window_dispose (GObject *object)
 {
        EvWindow *window = EV_WINDOW (object);
        EvWindowPrivate *priv = window->priv;
 {
        EvWindow *window = EV_WINDOW (object);
        EvWindowPrivate *priv = window->priv;
+       GObject *mpkeys = ev_application_get_media_keys (EV_APP);
 
 
+       if (mpkeys) {
+               g_signal_handlers_disconnect_by_func (mpkeys,
+                                                     ev_window_media_player_key_pressed,
+                                                     window);
+       }
+       
+       if (priv->setup_document_idle > 0) {
+               g_source_remove (priv->setup_document_idle);
+               priv->setup_document_idle = 0;
+       }
+       
+       if (priv->monitor) {
+               g_object_unref (priv->monitor);
+               priv->monitor = NULL;
+       }
+       
        if (priv->title) {
                ev_window_title_free (priv->title);
                priv->title = NULL;
        if (priv->title) {
                ev_window_title_free (priv->title);
                priv->title = NULL;
@@ -4151,6 +4783,10 @@ ev_window_dispose (GObject *object)
                ev_window_clear_load_job (window);
        }
 
                ev_window_clear_load_job (window);
        }
 
+       if (priv->reload_job) {
+               ev_window_clear_reload_job (window);
+       }
+
        if (priv->save_job) {
                ev_window_clear_save_job (window);
        }
        if (priv->save_job) {
                ev_window_clear_save_job (window);
        }
@@ -4158,22 +4794,24 @@ ev_window_dispose (GObject *object)
        if (priv->thumbnail_job) {
                ev_window_clear_thumbnail_job (window);
        }
        if (priv->thumbnail_job) {
                ev_window_clear_thumbnail_job (window);
        }
+
+       if (priv->find_job) {
+               ev_window_clear_find_job (window);
+       }
        
        if (priv->local_uri) {
                ev_window_clear_local_uri (window);
                priv->local_uri = NULL;
        }
        
        if (priv->local_uri) {
                ev_window_clear_local_uri (window);
                priv->local_uri = NULL;
        }
-       
-       ev_window_close_dialogs (window);
-
-#ifdef WITH_GTK_PRINT
-       ev_window_clear_print_job (window);
 
 
-       if (window->priv->gtk_print_job) {
-               g_object_unref (window->priv->gtk_print_job);
-               window->priv->gtk_print_job = NULL;
+       ev_window_clear_progress_idle (window);
+       if (priv->progress_cancellable) {
+               g_object_unref (priv->progress_cancellable);
+               priv->progress_cancellable = NULL;
        }
        
        }
        
+       ev_window_close_dialogs (window);
+
        if (window->priv->printer) {
                g_object_unref (window->priv->printer);
                window->priv->printer = NULL;
        if (window->priv->printer) {
                g_object_unref (window->priv->printer);
                window->priv->printer = NULL;
@@ -4188,7 +4826,6 @@ ev_window_dispose (GObject *object)
                g_object_unref (window->priv->print_page_setup);
                window->priv->print_page_setup = NULL;
        }
                g_object_unref (window->priv->print_page_setup);
                window->priv->print_page_setup = NULL;
        }
-#endif
 
        if (priv->link) {
                g_object_unref (priv->link);
 
        if (priv->link) {
                g_object_unref (priv->link);
@@ -4243,6 +4880,11 @@ ev_window_dispose (GObject *object)
                priv->presentation_timeout_id = 0;
        }
 
                priv->presentation_timeout_id = 0;
        }
 
+       if (priv->print_queue) {
+               g_queue_free (priv->print_queue);
+               priv->print_queue = NULL;
+       }
+
        G_OBJECT_CLASS (ev_window_parent_class)->dispose (object);
 }
 
        G_OBJECT_CLASS (ev_window_parent_class)->dispose (object);
 }
 
@@ -4256,6 +4898,7 @@ ev_window_class_init (EvWindowClass *ev_window_class)
        g_object_class->finalize = ev_window_finalize;
 
        widget_class->screen_changed = ev_window_screen_changed;
        g_object_class->finalize = ev_window_finalize;
 
        widget_class->screen_changed = ev_window_screen_changed;
+       widget_class->window_state_event = ev_window_state_event;
 
        g_type_class_add_private (g_object_class, sizeof (EvWindowPrivate));
 }
 
        g_type_class_add_private (g_object_class, sizeof (EvWindowPrivate));
 }
@@ -4272,7 +4915,7 @@ static const GtkActionEntry entries[] = {
        { "FileOpen", GTK_STOCK_OPEN, N_("_Open..."), "<control>O",
          N_("Open an existing document"),
          G_CALLBACK (ev_window_cmd_file_open) },
        { "FileOpen", GTK_STOCK_OPEN, N_("_Open..."), "<control>O",
          N_("Open an existing document"),
          G_CALLBACK (ev_window_cmd_file_open) },
-       { "FileOpenCopy", NULL, N_("Op_en a Copy"), NULL,
+       { "FileOpenCopy", NULL, N_("Op_en a Copy"), "<control>N",
          N_("Open a copy of the current document in a new window"),
          G_CALLBACK (ev_window_cmd_file_open_copy) },
                { "FileSaveAs", GTK_STOCK_SAVE_AS, N_("_Save a Copy..."), "<control>S",
          N_("Open a copy of the current document in a new window"),
          G_CALLBACK (ev_window_cmd_file_open_copy) },
                { "FileSaveAs", GTK_STOCK_SAVE_AS, N_("_Save a Copy..."), "<control>S",
@@ -4303,9 +4946,9 @@ static const GtkActionEntry entries[] = {
          G_CALLBACK (ev_window_cmd_edit_find_previous) },
         { "EditToolbar", NULL, N_("T_oolbar"), NULL, NULL,
           G_CALLBACK (ev_window_cmd_edit_toolbar) },
          G_CALLBACK (ev_window_cmd_edit_find_previous) },
         { "EditToolbar", NULL, N_("T_oolbar"), NULL, NULL,
           G_CALLBACK (ev_window_cmd_edit_toolbar) },
-       { "EditRotateLeft", EV_STOCK_ROTATE_LEFT, N_("Rotate _Left"), NULL, NULL,
+       { "EditRotateLeft", EV_STOCK_ROTATE_LEFT, N_("Rotate _Left"), "<alt>Left", NULL,
          G_CALLBACK (ev_window_cmd_edit_rotate_left) },
          G_CALLBACK (ev_window_cmd_edit_rotate_left) },
-       { "EditRotateRight", EV_STOCK_ROTATE_RIGHT, N_("Rotate _Right"), NULL, NULL,
+       { "EditRotateRight", EV_STOCK_ROTATE_RIGHT, N_("Rotate _Right"), "<alt>Right", NULL,
          G_CALLBACK (ev_window_cmd_edit_rotate_right) },
 
         /* View menu */
          G_CALLBACK (ev_window_cmd_edit_rotate_right) },
 
         /* View menu */
@@ -4397,6 +5040,8 @@ static const GtkActionEntry entries[] = {
           G_CALLBACK (ev_window_cmd_view_zoom_in) },
         { "CtrlKpMinus", GTK_STOCK_ZOOM_OUT, NULL, "<control>KP_Subtract", NULL,
           G_CALLBACK (ev_window_cmd_view_zoom_out) },
           G_CALLBACK (ev_window_cmd_view_zoom_in) },
         { "CtrlKpMinus", GTK_STOCK_ZOOM_OUT, NULL, "<control>KP_Subtract", NULL,
           G_CALLBACK (ev_window_cmd_view_zoom_out) },
+       { "CtrlInsert", GTK_STOCK_COPY, NULL, "<control>Insert", NULL,
+         G_CALLBACK (ev_window_cmd_edit_copy) },
 };
 
 /* Toggle items */
 };
 
 /* Toggle items */
@@ -4473,6 +5118,13 @@ navigation_action_activate_link_cb (EvNavigationAction *action, EvLink *link, Ev
        gtk_widget_grab_focus (window->priv->view);
 }
 
        gtk_widget_grab_focus (window->priv->view);
 }
 
+static void
+sidebar_layers_visibility_changed (EvSidebarLayers *layers,
+                                  EvWindow        *window)
+{
+       ev_view_reload (EV_VIEW (window->priv->view));
+}
+
 static void
 register_custom_actions (EvWindow *window, GtkActionGroup *group)
 {
 static void
 register_custom_actions (EvWindow *window, GtkActionGroup *group)
 {
@@ -4602,6 +5254,13 @@ sidebar_widget_model_set (EvSidebarLinks *ev_sidebar_links,
 static gboolean
 view_actions_focus_in_cb (GtkWidget *widget, GdkEventFocus *event, EvWindow *window)
 {
 static gboolean
 view_actions_focus_in_cb (GtkWidget *widget, GdkEventFocus *event, EvWindow *window)
 {
+#ifdef ENABLE_DBUS
+       GObject *keys;
+
+       keys = ev_application_get_media_keys (EV_APP);
+       ev_media_player_keys_focused (EV_MEDIA_PLAYER_KEYS (keys));
+#endif /* ENABLE_DBUS */
+
        update_chrome_flag (window, EV_CHROME_RAISE_TOOLBAR, FALSE);
        ev_window_set_action_sensitive (window, "ViewToolbar", TRUE);
 
        update_chrome_flag (window, EV_CHROME_RAISE_TOOLBAR, FALSE);
        ev_window_set_action_sensitive (window, "ViewToolbar", TRUE);
 
@@ -4693,12 +5352,12 @@ static void
 launch_action (EvWindow *window, EvLinkAction *action)
 {
        const char *filename = ev_link_action_get_filename (action);
 launch_action (EvWindow *window, EvLinkAction *action)
 {
        const char *filename = ev_link_action_get_filename (action);
-       const char *content_type;
        GAppInfo *app_info;
        GAppInfo *app_info;
-       GFileInfo *file_info;
        GFile *file;
        GFile *file;
-       GList *file_list = NULL;
-       
+       GList file_list = {NULL};
+       GAppLaunchContext *context = NULL;
+       GError *error = NULL;
+
        if (filename == NULL)
                return;
 
        if (filename == NULL)
                return;
 
@@ -4706,34 +5365,43 @@ launch_action (EvWindow *window, EvLinkAction *action)
                file = g_file_new_for_path (filename);
        } else {
                GFile *base_file;
                file = g_file_new_for_path (filename);
        } else {
                GFile *base_file;
+               gchar *dir;
+
+               dir = g_path_get_dirname (window->priv->uri);
+               base_file = g_file_new_for_uri (dir);
+               g_free (dir);
                
                
-               base_file = g_file_new_for_uri (window->priv->uri);
-               file = g_file_resolve_relative_path (base_file,
-                                                    filename);
-               
+               file = g_file_resolve_relative_path (base_file, filename);
                g_object_unref (base_file);
        }
                g_object_unref (base_file);
        }
-       
-       file_info = g_file_query_info (file,
-                                      G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
-                                      0, NULL, NULL);
-       if (file_info == NULL) {
+
+       app_info = g_file_query_default_handler (file, NULL, &error);
+       if (!app_info) {
+               ev_window_error_message (window, error,
+                                        "%s",
+                                        _("Unable to launch external application."));
                g_object_unref (file);
                g_object_unref (file);
+               g_error_free (error);
+
                return;
        }
                return;
        }
-       
-       content_type = g_file_info_get_content_type (file_info);
-       app_info = g_app_info_get_default_for_type (content_type, TRUE);
-       
-       file_list = g_list_append (file_list, file);
 
 
-       /* FIXME: should we use a GAppLaunchContext? */
-       g_app_info_launch (app_info, file_list,
-                          NULL, NULL);
+#if GTK_CHECK_VERSION (2, 14, 0)
+       context = G_APP_LAUNCH_CONTEXT (gdk_app_launch_context_new ());
+       gdk_app_launch_context_set_screen (GDK_APP_LAUNCH_CONTEXT (context),
+                                          gtk_window_get_screen (GTK_WINDOW (window)));
+       gdk_app_launch_context_set_timestamp (GDK_APP_LAUNCH_CONTEXT (context), GDK_CURRENT_TIME);
+#endif
+       
+       file_list.data = file;
+       if (!g_app_info_launch (app_info, &file_list, context, &error)) {
+               ev_window_error_message (window, error,
+                                        "%s",
+                                        _("Unable to launch external application."));
+               g_error_free (error);
+       }
        
        
-       g_list_free (file_list);
        g_object_unref (app_info);
        g_object_unref (app_info);
-       g_object_unref (file_info);
        g_object_unref (file);
 
        /* According to the PDF spec filename can be an executable. I'm not sure
        g_object_unref (file);
 
        /* According to the PDF spec filename can be an executable. I'm not sure
@@ -4744,47 +5412,37 @@ static void
 launch_external_uri (EvWindow *window, EvLinkAction *action)
 {
        const gchar *uri = ev_link_action_get_uri (action);
 launch_external_uri (EvWindow *window, EvLinkAction *action)
 {
        const gchar *uri = ev_link_action_get_uri (action);
-       const char *content_type;
-       GFile *file;
-       GFileInfo *file_info;
-       GAppInfo *app;
-       GList *file_list = NULL;
        GError *error = NULL;
        GError *error = NULL;
-       
-       file = g_file_new_for_uri (uri);
-       file_info = g_file_query_info (file,
-                                      G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
-                                      0, NULL, NULL);
-       if (file_info == NULL) {
-               g_object_unref (file);
-               return;
+       gboolean ret;
+#if GTK_CHECK_VERSION (2, 14, 0)
+       GAppLaunchContext *context = NULL;
+#endif
+
+#if GTK_CHECK_VERSION (2, 14, 0)
+       context = G_APP_LAUNCH_CONTEXT (gdk_app_launch_context_new ());
+       gdk_app_launch_context_set_screen (GDK_APP_LAUNCH_CONTEXT (context),
+                                          gtk_window_get_screen (GTK_WINDOW (window)));
+       gdk_app_launch_context_set_timestamp (GDK_APP_LAUNCH_CONTEXT (context),
+                                             GDK_CURRENT_TIME);
+#endif
+
+       if (!g_strstr_len (uri, strlen (uri), "://") &&
+           !g_str_has_prefix (uri, "mailto:")) {
+               gchar *http;
+               
+               /* Not a valid uri, assuming it's http */
+               http = g_strdup_printf ("http://%s", uri);
+               ret = g_app_info_launch_default_for_uri (http, NULL, &error);
+               g_free (http);
+       } else {
+               ret = g_app_info_launch_default_for_uri (uri, NULL, &error);
        }
        
        }
        
-       content_type = g_file_info_get_content_type (file_info);
-       app = g_app_info_get_default_for_type (content_type, TRUE);
-       g_object_unref (file_info);
-       
-       file_list = g_list_append (file_list, file);
-       
-       if (!g_app_info_launch (app, file_list, NULL, &error)) {
-               GtkWidget *dialog;
-       
-               dialog = gtk_message_dialog_new (GTK_WINDOW (window),
-                                                GTK_DIALOG_DESTROY_WITH_PARENT,
-                                                GTK_MESSAGE_ERROR,
-                                                GTK_BUTTONS_CLOSE,
-                                                _("Unable to open external link"));
-               gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
-                                                         error->message, uri);
-               g_signal_connect (dialog, "response",
-                                 G_CALLBACK (gtk_widget_destroy),
-                                 NULL);
-               gtk_widget_show (dialog);
+       if (ret == FALSE) {
+               ev_window_error_message (window, error, 
+                                        "%s", _("Unable to open external link"));
+               g_error_free (error);
        }
        }
-
-       g_object_unref (app);
-       g_object_unref (file);
-       g_list_free (file_list);
 }
 
 static void
 }
 
 static void
@@ -4895,19 +5553,14 @@ ev_view_popup_cmd_open_link_new_window (GtkAction *action, EvWindow *window)
 static void
 ev_view_popup_cmd_copy_link_address (GtkAction *action, EvWindow *window)
 {
 static void
 ev_view_popup_cmd_copy_link_address (GtkAction *action, EvWindow *window)
 {
-       GtkClipboard *clipboard;
        EvLinkAction *ev_action;
        EvLinkAction *ev_action;
-       const gchar *uri;
 
        ev_action = ev_link_get_action (window->priv->link);
        if (!ev_action)
                return;
 
 
        ev_action = ev_link_get_action (window->priv->link);
        if (!ev_action)
                return;
 
-       uri = ev_link_action_get_uri (ev_action);
-
-       clipboard = gtk_widget_get_clipboard (GTK_WIDGET (window),
-                                             GDK_SELECTION_CLIPBOARD);
-       gtk_clipboard_set_text (clipboard, uri, -1);
+       ev_view_copy_link_address (EV_VIEW (window->priv->view),
+                                  ev_action);
 }
 
 
 }
 
 
@@ -4921,7 +5574,6 @@ image_save_dialog_response_cb (GtkWidget *fc,
        GError          *error = NULL;
        GdkPixbuf       *pixbuf;
        gchar           *uri;
        GError          *error = NULL;
        GdkPixbuf       *pixbuf;
        gchar           *uri;
-       gchar           *uri_extension;
        gchar          **extensions;
        gchar           *filename;
        gchar           *file_format;
        gchar          **extensions;
        gchar           *filename;
        gchar           *file_format;
@@ -4942,9 +5594,9 @@ image_save_dialog_response_cb (GtkWidget *fc,
        }
 
        if (format == NULL) {
        }
 
        if (format == NULL) {
-               ev_window_error_message (GTK_WINDOW (ev_window),
-                                        _("Couldn't find appropriate format to save image"),
-                                        NULL);
+               ev_window_error_message (ev_window, NULL, 
+                                        "%s",
+                                        _("Couldn't find appropriate format to save image"));
                g_free (uri);
                gtk_widget_destroy (fc);
 
                g_free (uri);
                gtk_widget_destroy (fc);
 
@@ -4952,35 +5604,38 @@ image_save_dialog_response_cb (GtkWidget *fc,
        }
 
        extensions = gdk_pixbuf_format_get_extensions (format);
        }
 
        extensions = gdk_pixbuf_format_get_extensions (format);
-       uri_extension = g_strconcat (uri, ".", extensions[0], NULL);
-       g_strfreev(extensions);
-       file_format = gdk_pixbuf_format_get_name (format);
+       if (!g_str_has_suffix (uri, extensions[0])) {
+               gchar *uri_extension;
+               
+               uri_extension = g_strconcat (uri, ".", extensions[0], NULL);
+               target_file = g_file_new_for_uri (uri_extension);
+               g_free (uri_extension);
+       } else {
+               target_file = g_file_new_for_uri (uri);
+       }
+       g_strfreev (extensions);
+       g_free (uri);
        
        
-       target_file = g_file_new_for_uri (uri_extension);
        is_native = g_file_is_native (target_file);
        is_native = g_file_is_native (target_file);
-       
        if (is_native) {
                filename = g_file_get_path (target_file);
        } else {
                filename = ev_tmp_filename ("saveimage");
        }
        if (is_native) {
                filename = g_file_get_path (target_file);
        } else {
                filename = ev_tmp_filename ("saveimage");
        }
-       
-       g_free (uri);
-       g_free (uri_extension);
 
        ev_document_doc_mutex_lock ();
        pixbuf = ev_document_images_get_image (EV_DOCUMENT_IMAGES (ev_window->priv->document),
                                               ev_window->priv->image);
        ev_document_doc_mutex_unlock ();
 
        ev_document_doc_mutex_lock ();
        pixbuf = ev_document_images_get_image (EV_DOCUMENT_IMAGES (ev_window->priv->document),
                                               ev_window->priv->image);
        ev_document_doc_mutex_unlock ();
-       
+
+       file_format = gdk_pixbuf_format_get_name (format);
        gdk_pixbuf_save (pixbuf, filename, file_format, &error, NULL);
        g_free (file_format);
        g_object_unref (pixbuf);
        
        if (error) {
        gdk_pixbuf_save (pixbuf, filename, file_format, &error, NULL);
        g_free (file_format);
        g_object_unref (pixbuf);
        
        if (error) {
-               ev_window_error_message (GTK_WINDOW (ev_window),
-                                        _("The image could not be saved."),
-                                        error);
+               ev_window_error_message (ev_window, error, 
+                                        "%s", _("The image could not be saved."));
                g_error_free (error);
                g_free (filename);
                g_object_unref (target_file);
                g_error_free (error);
                g_free (filename);
                g_object_unref (target_file);
@@ -4992,9 +5647,10 @@ image_save_dialog_response_cb (GtkWidget *fc,
        if (!is_native) {
                GFile *source_file;
                
        if (!is_native) {
                GFile *source_file;
                
-               source_file = g_file_new_for_uri (filename);
+               source_file = g_file_new_for_path (filename);
                
                
-               ev_window_save_remote (ev_window, source_file, target_file);
+               ev_window_save_remote (ev_window, EV_SAVE_IMAGE,
+                                      source_file, target_file);
                g_object_unref (source_file);
        }
        
                g_object_unref (source_file);
        }
        
@@ -5055,23 +5711,25 @@ ev_view_popup_cmd_copy_image (GtkAction *action, EvWindow *window)
 static void
 ev_attachment_popup_cmd_open_attachment (GtkAction *action, EvWindow *window)
 {
 static void
 ev_attachment_popup_cmd_open_attachment (GtkAction *action, EvWindow *window)
 {
-       GList *l;
+       GList     *l;
+       GdkScreen *screen;
        
        if (!window->priv->attach_list)
                return;
 
        
        if (!window->priv->attach_list)
                return;
 
+       screen = gtk_window_get_screen (GTK_WINDOW (window));
+
        for (l = window->priv->attach_list; l && l->data; l = g_list_next (l)) {
                EvAttachment *attachment;
                GError       *error = NULL;
                
                attachment = (EvAttachment *) l->data;
                
        for (l = window->priv->attach_list; l && l->data; l = g_list_next (l)) {
                EvAttachment *attachment;
                GError       *error = NULL;
                
                attachment = (EvAttachment *) l->data;
                
-               ev_attachment_open (attachment, &error);
+               ev_attachment_open (attachment, screen, GDK_CURRENT_TIME, &error);
 
                if (error) {
 
                if (error) {
-                       ev_window_error_message (GTK_WINDOW (window),
-                                                _("Unable to open attachment"),
-                                                error);
+                       ev_window_error_message (window, error, 
+                                                "%s", _("Unable to open attachment"));
                        g_error_free (error);
                }
        }
                        g_error_free (error);
                }
        }
@@ -5121,9 +5779,8 @@ attachment_save_dialog_response_cb (GtkWidget *fc,
                ev_attachment_save (attachment, save_to, &error);
                
                if (error) {
                ev_attachment_save (attachment, save_to, &error);
                
                if (error) {
-                       ev_window_error_message (GTK_WINDOW (ev_window),
-                                                _("The attachment could not be saved."),
-                                                error);
+                       ev_window_error_message (ev_window, error, 
+                                                "%s", _("The attachment could not be saved."));
                        g_error_free (error);
                        g_object_unref (save_to);
 
                        g_error_free (error);
                        g_object_unref (save_to);
 
@@ -5140,7 +5797,8 @@ attachment_save_dialog_response_cb (GtkWidget *fc,
                                dest_file = g_object_ref (target_file);
                        }
 
                                dest_file = g_object_ref (target_file);
                        }
 
-                       ev_window_save_remote (ev_window, save_to, dest_file);
+                       ev_window_save_remote (ev_window, EV_SAVE_ATTACHMENT,
+                                              save_to, dest_file);
 
                        g_object_unref (dest_file);
                }
 
                        g_object_unref (dest_file);
                }
@@ -5190,6 +5848,35 @@ ev_attachment_popup_cmd_save_attachment_as (GtkAction *action, EvWindow *window)
        gtk_widget_show (fc);
 }
 
        gtk_widget_show (fc);
 }
 
+static void
+ev_window_media_player_key_pressed (EvWindow    *window,
+                                   const gchar *key,
+                                   gpointer     user_data)
+{
+       if (!gtk_window_is_active (GTK_WINDOW (window))) 
+               return;
+       
+       /* Note how Previous/Next only go to the
+        * next/previous page despite their icon telling you
+        * they should go to the beginning/end.
+        *
+        * There's very few keyboards with FFW/RWD though,
+        * so we stick the most useful keybinding on the most
+        * often seen keys
+        */
+       if (strcmp (key, "Play") == 0) {
+               ev_window_run_presentation (window);
+       } else if (strcmp (key, "Previous") == 0) {
+               ev_window_cmd_go_previous_page (NULL, window);
+       } else if (strcmp (key, "Next") == 0) {
+               ev_window_cmd_go_next_page (NULL, window);
+       } else if (strcmp (key, "FastForward") == 0) {
+               ev_window_cmd_go_last_page (NULL, window);
+       } else if (strcmp (key, "Rewind") == 0) {
+               ev_window_cmd_go_first_page (NULL, window);
+       }
+}
+
 static void
 ev_window_init (EvWindow *ev_window)
 {
 static void
 ev_window_init (EvWindow *ev_window)
 {
@@ -5197,6 +5884,7 @@ ev_window_init (EvWindow *ev_window)
        GtkAccelGroup *accel_group;
        GError *error = NULL;
        GtkWidget *sidebar_widget;
        GtkAccelGroup *accel_group;
        GError *error = NULL;
        GtkWidget *sidebar_widget;
+       GObject *mpkeys;
 
        g_signal_connect (ev_window, "configure_event",
                          G_CALLBACK (window_configure_event_cb), NULL);
 
        g_signal_connect (ev_window, "configure_event",
                          G_CALLBACK (window_configure_event_cb), NULL);
@@ -5258,13 +5946,7 @@ ev_window_init (EvWindow *ev_window)
                g_error_free (error);
        }
        
                g_error_free (error);
        }
        
-#if GTK_CHECK_VERSION(2,11,4)
        ev_window->priv->recent_manager = gtk_recent_manager_get_default ();
        ev_window->priv->recent_manager = gtk_recent_manager_get_default ();
-#else
-       /* It's fine to just use the one of the default screen here */
-       ev_window->priv->recent_manager = gtk_recent_manager_get_for_screen (
-               gdk_screen_get_default ());
-#endif
        ev_window->priv->recent_action_group = NULL;
        ev_window->priv->recent_ui_id = 0;
        g_signal_connect_swapped (ev_window->priv->recent_manager,
        ev_window->priv->recent_action_group = NULL;
        ev_window->priv->recent_ui_id = 0;
        g_signal_connect_swapped (ev_window->priv->recent_manager,
@@ -5348,6 +6030,16 @@ ev_window_init (EvWindow *ev_window)
        ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar),
                             sidebar_widget);
 
        ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar),
                             sidebar_widget);
 
+       sidebar_widget = ev_sidebar_layers_new ();
+       ev_window->priv->sidebar_layers = sidebar_widget;
+       g_signal_connect (sidebar_widget,
+                         "layers_visibility_changed",
+                         G_CALLBACK (sidebar_layers_visibility_changed),
+                         ev_window);
+       gtk_widget_show (sidebar_widget);
+       ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar),
+                            sidebar_widget);
+
        ev_window->priv->view_box = gtk_vbox_new (FALSE, 0);
        ev_window->priv->scrolled_window =
                GTK_WIDGET (g_object_new (GTK_TYPE_SCROLLED_WINDOW,
        ev_window->priv->view_box = gtk_vbox_new (FALSE, 0);
        ev_window->priv->scrolled_window =
                GTK_WIDGET (g_object_new (GTK_TYPE_SCROLLED_WINDOW,
@@ -5365,10 +6057,10 @@ ev_window_init (EvWindow *ev_window)
        ev_window->priv->view = ev_view_new ();
        ev_view_set_screen_dpi (EV_VIEW (ev_window->priv->view),
                                get_screen_dpi (GTK_WINDOW (ev_window)));
        ev_window->priv->view = ev_view_new ();
        ev_view_set_screen_dpi (EV_VIEW (ev_window->priv->view),
                                get_screen_dpi (GTK_WINDOW (ev_window)));
-       ev_window->priv->password_view = ev_password_view_new ();
+       ev_window->priv->password_view = ev_password_view_new (GTK_WINDOW (ev_window));
        g_signal_connect_swapped (ev_window->priv->password_view,
                                  "unlock",
        g_signal_connect_swapped (ev_window->priv->password_view,
                                  "unlock",
-                                 G_CALLBACK (ev_window_popup_password_dialog),
+                                 G_CALLBACK (ev_window_password_view_unlock),
                                  ev_window);
        g_signal_connect_object (ev_window->priv->view, "focus_in_event",
                                 G_CALLBACK (view_actions_focus_in_cb),
                                  ev_window);
        g_signal_connect_object (ev_window->priv->view, "focus_in_event",
                                 G_CALLBACK (view_actions_focus_in_cb),
@@ -5403,10 +6095,6 @@ ev_window_init (EvWindow *ev_window)
        gtk_container_add (GTK_CONTAINER (ev_window->priv->scrolled_window),
                           ev_window->priv->view);
 
        gtk_container_add (GTK_CONTAINER (ev_window->priv->scrolled_window),
                           ev_window->priv->view);
 
-       g_signal_connect (ev_window->priv->view,
-                         "notify::find-status",
-                         G_CALLBACK (view_find_status_changed_cb),
-                         ev_window);
        g_signal_connect (ev_window->priv->view,
                          "notify::sizing-mode",
                          G_CALLBACK (ev_window_sizing_mode_changed_cb),
        g_signal_connect (ev_window->priv->view,
                          "notify::sizing-mode",
                          G_CALLBACK (ev_window_sizing_mode_changed_cb),
@@ -5481,6 +6169,14 @@ ev_window_init (EvWindow *ev_window)
                                                                       "/AttachmentPopup");
        ev_window->priv->attach_list = NULL;
 
                                                                       "/AttachmentPopup");
        ev_window->priv->attach_list = NULL;
 
+       /* Media player keys */
+       mpkeys = ev_application_get_media_keys (EV_APP);
+       if (mpkeys) {
+               g_signal_connect_swapped (mpkeys, "key_pressed",
+                                         G_CALLBACK (ev_window_media_player_key_pressed),
+                                         ev_window);
+       }
+       
        /* Give focus to the document view */
        gtk_widget_grab_focus (ev_window->priv->view);
 
        /* Give focus to the document view */
        gtk_widget_grab_focus (ev_window->priv->view);