Added. Returns whether the animation has everything necessary to run. Do

[evince.git] / shell / ev-window.c

diff --git a/shell/ev-window.c b/shell/ev-window.c
index 341907b7b57597bdb643562881ffdacab1c322fd..4c3fcf2397ab7ce4eb64ceb77e5b7b4f72bec9d9 100644 (file)
--- a/shell/ev-window.c
+++ b/shell/ev-window.c
@@ -32,6 +32,7 @@
 #include "ev-window-title.h"
 #include "ev-navigation-action.h"
 #include "ev-page-action.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.h"
 #include "ev-sidebar-links.h"
 #include "ev-sidebar-attachments.h"


@@ -45,19 +46,13 @@
 #include "ev-document-links.h"
 #include "ev-document-fonts.h"
 #include "ev-document-find.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 "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"

-
-#ifndef HAVE_GTK_RECENT
-#include "egg-recent-view-uimanager.h"
-#include "egg-recent-view.h"
-#include "egg-recent-model.h"
-#endif
-

 #include "egg-toolbar-editor.h"
 #include "egg-editable-toolbar.h"
 #include "egg-toolbars-model.h"
 #include "egg-toolbar-editor.h"
 #include "egg-editable-toolbar.h"
 #include "egg-toolbars-model.h"


@@ -70,15 +65,9 @@
 #include "ev-utils.h"
 #include "ev-history.h"
 #include "ev-image.h"
 #include "ev-utils.h"
 #include "ev-history.h"
 #include "ev-image.h"

+#include "ev-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>
 #include <gtk/gtkprintunixdialog.h>

-#endif

 
 #ifdef ENABLE_PDF
 #include <poppler.h>
 
 #ifdef ENABLE_PDF
 #include <poppler.h>


@@ -87,12 +76,13 @@
 #include <glib/gstdio.h>
 #include <glib/gi18n.h>
 #include <gtk/gtk.h>
 #include <glib/gstdio.h>
 #include <glib/gi18n.h>
 #include <gtk/gtk.h>

-#include <gnome.h>
-#include <libgnomevfs/gnome-vfs-utils.h>
-#include <libgnomevfs/gnome-vfs-async-ops.h>
+#include <gio/gio.h>

 #include <gconf/gconf-client.h>
 
 #include <gconf/gconf-client.h>
 

+#include <errno.h>
+#include <stdlib.h>

 #include <string.h>
 #include <string.h>

+#include <unistd.h>

 
 typedef enum {
        PAGE_MODE_DOCUMENT,
 
 typedef enum {
        PAGE_MODE_DOCUMENT,


@@ -116,41 +106,42 @@ struct _EvWindowPrivate {
 
        GtkWidget *main_box;
        GtkWidget *menubar;
 
        GtkWidget *main_box;
        GtkWidget *menubar;

-       GtkWidget *toolbar_dock;

        GtkWidget *toolbar;
        GtkWidget *hpaned;
        GtkWidget *toolbar;
        GtkWidget *hpaned;

+       GtkWidget *view_box;

        GtkWidget *sidebar;
        GtkWidget *find_bar;
        GtkWidget *scrolled_window;
        GtkWidget *view;
        GtkWidget *sidebar;
        GtkWidget *find_bar;
        GtkWidget *scrolled_window;
        GtkWidget *view;

+       GtkWidget *message_area;

        GtkWidget *password_view;
        GtkWidget *sidebar_thumbs;
        GtkWidget *sidebar_links;
        GtkWidget *sidebar_attachments;
        GtkWidget *password_view;
        GtkWidget *sidebar_thumbs;
        GtkWidget *sidebar_links;
        GtkWidget *sidebar_attachments;

-       GtkWidget *preview_toolbar;

 
        /* Dialogs */
        GtkWidget *properties;
 
        /* Dialogs */
        GtkWidget *properties;

-#ifdef WITH_PRINT

        GtkWidget *print_dialog;
        GtkWidget *print_dialog;

-#endif

        GtkWidget *password_dialog;
 
        /* UI Builders */
        GtkActionGroup   *action_group;
        GtkActionGroup   *view_popup_action_group;
        GtkActionGroup   *attachment_popup_action_group;
        GtkWidget *password_dialog;
 
        /* UI Builders */
        GtkActionGroup   *action_group;
        GtkActionGroup   *view_popup_action_group;
        GtkActionGroup   *attachment_popup_action_group;

-#ifdef HAVE_GTK_RECENT

        GtkRecentManager *recent_manager;
        GtkActionGroup   *recent_action_group;
        guint             recent_ui_id;
        GtkRecentManager *recent_manager;
        GtkActionGroup   *recent_action_group;
        guint             recent_ui_id;

-#endif

        GtkUIManager     *ui_manager;
 
        /* Fullscreen mode */
        GtkWidget *fullscreen_toolbar;
        GtkUIManager     *ui_manager;
 
        /* Fullscreen mode */
        GtkWidget *fullscreen_toolbar;

-       GtkWidget *fullscreen_popup;
-       guint      fullscreen_timeout_id;
+
+       /* Presentation mode */
+       guint      presentation_timeout_id;
+
+       /* Preview mode */
+       GtkWidget *preview_toolbar;
+       gchar     *print_settings_file;

 
        /* Popup view */
        GtkWidget *view_popup;
 
        /* Popup view */
        GtkWidget *view_popup;


@@ -166,28 +157,26 @@ struct _EvWindowPrivate {
        char *local_uri;
        EvLinkDest *dest;
        gboolean unlink_temp_file;
        char *local_uri;
        EvLinkDest *dest;
        gboolean unlink_temp_file;

+       gboolean in_reload;

        
        EvDocument *document;
        EvHistory *history;
        EvPageCache *page_cache;
        EvWindowPageMode page_mode;
        EvWindowTitle *title;
        
        EvDocument *document;
        EvHistory *history;
        EvPageCache *page_cache;
        EvWindowPageMode page_mode;
        EvWindowTitle *title;

-#ifndef HAVE_GTK_RECENT
-       EggRecentViewUIManager *recent_view;
-#endif
-
-       EvJob *load_job;
-#ifdef WITH_GNOME_PRINT
-       GnomePrintJob *print_job;
-#endif

 
 

-#ifdef WITH_GTK_PRINT
+       EvJob            *load_job;
+       EvJob            *thumbnail_job;
+       EvJob            *save_job;

        EvJob            *print_job;
        EvJob            *print_job;

+
+       /* Printing */
+       gboolean          print_preview;

        GtkPrintJob      *gtk_print_job;
        GtkPrinter       *printer;
        GtkPrintSettings *print_settings;
        GtkPageSetup     *print_page_setup;
        GtkPrintJob      *gtk_print_job;
        GtkPrinter       *printer;
        GtkPrintSettings *print_settings;
        GtkPageSetup     *print_page_setup;

-#endif
+

 };
 
 #define EV_WINDOW_GET_PRIVATE(object) \
 };
 
 #define EV_WINDOW_GET_PRIVATE(object) \


@@ -201,15 +190,25 @@ struct _EvWindowPrivate {
 #define GCONF_LOCKDOWN_SAVE         "/desktop/gnome/lockdown/disable_save_to_disk"
 #define GCONF_LOCKDOWN_PRINT        "/desktop/gnome/lockdown/disable_printing"
 
 #define GCONF_LOCKDOWN_SAVE         "/desktop/gnome/lockdown/disable_save_to_disk"
 #define GCONF_LOCKDOWN_PRINT        "/desktop/gnome/lockdown/disable_printing"
 

-#define FULLSCREEN_TIMEOUT 5 * 1000
+#define PRESENTATION_TIMEOUT 5

 
 #define SIDEBAR_DEFAULT_SIZE    132
 #define LINKS_SIDEBAR_ID "links"
 #define THUMBNAILS_SIDEBAR_ID "thumbnails"
 #define ATTACHMENTS_SIDEBAR_ID "attachments"
 
 
 #define SIDEBAR_DEFAULT_SIZE    132
 #define LINKS_SIDEBAR_ID "links"
 #define THUMBNAILS_SIDEBAR_ID "thumbnails"
 #define ATTACHMENTS_SIDEBAR_ID "attachments"
 

-static void    ev_window_update_actions                (EvWindow *ev_window);
-static void     ev_window_update_fullscreen_popup       (EvWindow         *window);
+static const gchar *document_print_settings[] = {
+       GTK_PRINT_SETTINGS_N_COPIES,
+       GTK_PRINT_SETTINGS_COLLATE,
+       GTK_PRINT_SETTINGS_REVERSE,
+       GTK_PRINT_SETTINGS_NUMBER_UP,
+       GTK_PRINT_SETTINGS_SCALE,
+       GTK_PRINT_SETTINGS_PRINT_PAGES,
+       GTK_PRINT_SETTINGS_PAGE_RANGES,
+       GTK_PRINT_SETTINGS_PAGE_SET
+};
+
+static void    ev_window_update_actions                (EvWindow         *ev_window);

 static void     ev_window_sidebar_visibility_changed_cb (EvSidebar        *ev_sidebar,
                                                         GParamSpec       *pspec,
                                                         EvWindow         *ev_window);
 static void     ev_window_sidebar_visibility_changed_cb (EvSidebar        *ev_sidebar,
                                                         GParamSpec       *pspec,
                                                         EvWindow         *ev_window);


@@ -217,10 +216,12 @@ static void     ev_window_set_page_mode                 (EvWindow         *windo
                                                         EvWindowPageMode  page_mode);
 static void    ev_window_load_job_cb                   (EvJobLoad        *job,
                                                         gpointer          data);
                                                         EvWindowPageMode  page_mode);
 static void    ev_window_load_job_cb                   (EvJobLoad        *job,
                                                         gpointer          data);

-#ifdef WITH_GTK_PRINT
+static void     ev_window_set_icon_from_thumbnail       (EvJobThumbnail   *job,
+                                                        EvWindow         *ev_window);

 static void     ev_window_print_job_cb                  (EvJobPrint       *job,
                                                         EvWindow         *window);
 static void     ev_window_print_job_cb                  (EvJobPrint       *job,
                                                         EvWindow         *window);

-#endif
+static void     ev_window_save_job_cb                   (EvJobSave        *save,
+                                                        EvWindow         *window);

 static void     ev_window_sizing_mode_changed_cb        (EvView           *view,
                                                         GParamSpec       *pspec,
                                                         EvWindow         *ev_window);
 static void     ev_window_sizing_mode_changed_cb        (EvView           *view,
                                                         GParamSpec       *pspec,
                                                         EvWindow         *ev_window);


@@ -249,40 +250,25 @@ static void     ev_view_popup_cmd_save_image_as         (GtkAction        *actio
 static void     ev_view_popup_cmd_copy_image            (GtkAction        *action,
                                                         EvWindow         *window);
 static void    ev_attachment_popup_cmd_open_attachment (GtkAction        *action,
 static void     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_save_attachment_as (GtkAction *action, 
-                                                        EvWindow *window);
+                                                        EvWindow         *window);
+static void    ev_attachment_popup_cmd_save_attachment_as (GtkAction     *action, 
+                                                        EvWindow         *window);

 static void    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_best_fit             (GtkAction        *action, 
                                                         EvWindow         *ev_window);
 static void    ev_window_cmd_view_page_width           (GtkAction        *action, 
                                                         EvWindow         *ev_window);

-static void    fullscreen_set_timeout                  (EvWindow *window);
-static gboolean fullscreen_motion_notify_cb            (GtkWidget *widget,
-                                                        GdkEventMotion *event,
-                                                        gpointer user_data);
-static gboolean fullscreen_leave_notify_cb             (GtkWidget *widget,
-                                                        GdkEventCrossing *event,
-                                                        gpointer user_data);
-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_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);

 
 G_DEFINE_TYPE (EvWindow, ev_window, GTK_TYPE_WINDOW)
 
 
 G_DEFINE_TYPE (EvWindow, ev_window, GTK_TYPE_WINDOW)
 

-static gdouble
-ev_window_get_screen_dpi (EvWindow *ev_window)
-{
-       GdkScreen *screen;
-       gdouble    xdpi, ydpi;
-
-       screen = gtk_window_get_screen (GTK_WINDOW (ev_window));
-
-       xdpi = 25.4 * gdk_screen_get_width (screen) / gdk_screen_get_width_mm (screen);
-       ydpi = 25.4 * gdk_screen_get_height (screen) / gdk_screen_get_height_mm (screen);
-       
-       return (xdpi + ydpi) / 2.0;
-}
-

 static void
 ev_window_set_action_sensitive (EvWindow   *ev_window,
                                const char *name,
 static void
 ev_window_set_action_sensitive (EvWindow   *ev_window,
                                const char *name,


@@ -304,7 +290,7 @@ ev_window_setup_action_sensitivity (EvWindow *ev_window)
        gboolean ok_to_print = TRUE;
        gboolean ok_to_copy = TRUE;
        gboolean has_properties = TRUE;
        gboolean ok_to_print = TRUE;
        gboolean ok_to_copy = TRUE;
        gboolean has_properties = TRUE;

-       gboolean override_restrictions = FALSE;
+       gboolean override_restrictions = TRUE;

        gboolean can_get_text = FALSE;
        gboolean has_pages = FALSE;
        gboolean can_find = FALSE;
        gboolean can_get_text = FALSE;
        gboolean has_pages = FALSE;
        gboolean can_find = FALSE;


@@ -324,7 +310,7 @@ ev_window_setup_action_sensitivity (EvWindow *ev_window)
                has_properties = FALSE;
        }
 
                has_properties = FALSE;
        }
 

-       if (has_document && ev_document_can_get_text (document)) {
+       if (has_document && EV_IS_SELECTION (document)) {

                can_get_text = TRUE;
        }
        
                can_get_text = TRUE;
        }
        


@@ -352,24 +338,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);
 


@@ -386,11 +361,13 @@ ev_window_setup_action_sensitivity (EvWindow *ev_window)
        ev_window_set_action_sensitive (ev_window, "ViewBestFit", has_pages);
        ev_window_set_action_sensitive (ev_window, "ViewPageWidth", has_pages);
        ev_window_set_action_sensitive (ev_window, "ViewReload", has_pages);
        ev_window_set_action_sensitive (ev_window, "ViewBestFit", has_pages);
        ev_window_set_action_sensitive (ev_window, "ViewPageWidth", has_pages);
        ev_window_set_action_sensitive (ev_window, "ViewReload", has_pages);

+       ev_window_set_action_sensitive (ev_window, "ViewAutoscroll", has_pages);

 
        /* Toolbar-specific actions: */
        ev_window_set_action_sensitive (ev_window, PAGE_SELECTOR_ACTION, has_pages);
        ev_window_set_action_sensitive (ev_window, ZOOM_CONTROL_ACTION,  has_pages);
 
        /* Toolbar-specific actions: */
        ev_window_set_action_sensitive (ev_window, PAGE_SELECTOR_ACTION, has_pages);
        ev_window_set_action_sensitive (ev_window, ZOOM_CONTROL_ACTION,  has_pages);

-       ev_window_set_action_sensitive (ev_window, NAVIGATION_ACTION,  has_pages);
+       ev_window_set_action_sensitive (ev_window, NAVIGATION_ACTION,  FALSE);
+       ev_window_set_action_sensitive (ev_window, "PreviewPrint", has_pages && ok_to_print);

 
         ev_window_update_actions (ev_window);
 }
 
         ev_window_update_actions (ev_window);
 }


@@ -401,6 +378,7 @@ ev_window_update_actions (EvWindow *ev_window)
        EvView *view = EV_VIEW (ev_window->priv->view);
        int n_pages = 0, page = -1;
        gboolean has_pages = FALSE;
        EvView *view = EV_VIEW (ev_window->priv->view);
        int n_pages = 0, page = -1;
        gboolean has_pages = FALSE;

+       gboolean presentation_mode;

 
        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);


@@ -408,17 +386,25 @@ ev_window_update_actions (EvWindow *ev_window)
                has_pages = n_pages > 0;
        }
 
                has_pages = n_pages > 0;
        }
 

-       ev_window_set_action_sensitive (ev_window, "EditCopy", has_pages && ev_view_get_has_selection (view));
+       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, "EditFindNext",

-                             ev_view_can_find_next (view));
+                                       ev_view_can_find_next (view));

        ev_window_set_action_sensitive (ev_window, "EditFindPrevious",
        ev_window_set_action_sensitive (ev_window, "EditFindPrevious",

-                             ev_view_can_find_previous (view));
+                                       ev_view_can_find_previous (view));

 
 

+       presentation_mode = ev_view_get_presentation (view);
+       

        ev_window_set_action_sensitive (ev_window, "ViewZoomIn",
        ev_window_set_action_sensitive (ev_window, "ViewZoomIn",

-                             has_pages && ev_view_can_zoom_in (view));
+                                       has_pages &&
+                                       ev_view_can_zoom_in (view) &&
+                                       !presentation_mode);

        ev_window_set_action_sensitive (ev_window, "ViewZoomOut",
        ev_window_set_action_sensitive (ev_window, "ViewZoomOut",

-                             has_pages && ev_view_can_zoom_out (view));
-
+                                       has_pages &&
+                                       ev_view_can_zoom_out (view) &&
+                                       !presentation_mode);
+       

         /* Go menu */
        if (has_pages) {
                ev_window_set_action_sensitive (ev_window, "GoPreviousPage", page > 0);
         /* Go menu */
        if (has_pages) {
                ev_window_set_action_sensitive (ev_window, "GoPreviousPage", page > 0);


@@ -443,7 +429,7 @@ ev_window_update_actions (EvWindow *ev_window)
                                                      ZOOM_CONTROL_ACTION);
 
                real_zoom = ev_view_get_zoom (EV_VIEW (ev_window->priv->view));
                                                      ZOOM_CONTROL_ACTION);
 
                real_zoom = ev_view_get_zoom (EV_VIEW (ev_window->priv->view));

-               real_zoom *= 72.0 / ev_window_get_screen_dpi (ev_window);
+               real_zoom *= 72.0 / get_screen_dpi (GTK_WINDOW (ev_window));

                zoom = ephy_zoom_get_nearest_zoom_level (real_zoom);
 
                ephy_zoom_action_set_zoom_level (EPHY_ZOOM_ACTION (action), zoom);
                zoom = ephy_zoom_get_nearest_zoom_level (real_zoom);
 
                ephy_zoom_action_set_zoom_level (EPHY_ZOOM_ACTION (action), zoom);


@@ -454,7 +440,7 @@ static void
 ev_window_set_view_accels_sensitivity (EvWindow *window, gboolean sensitive)
 {
        gboolean can_find;
 ev_window_set_view_accels_sensitivity (EvWindow *window, gboolean sensitive)
 {
        gboolean can_find;

-       
+

        can_find = window->priv->document && 
            EV_IS_DOCUMENT_FIND (window->priv->document);
 
        can_find = window->priv->document && 
            EV_IS_DOCUMENT_FIND (window->priv->document);
 


@@ -506,21 +492,22 @@ update_chrome_visibility (EvWindow *window)
        fullscreen_toolbar = ((priv->chrome & EV_CHROME_FULLSCREEN_TOOLBAR) != 0 || 
                              (priv->chrome & EV_CHROME_RAISE_TOOLBAR) != 0) && fullscreen;
        findbar = (priv->chrome & EV_CHROME_FINDBAR) != 0;
        fullscreen_toolbar = ((priv->chrome & EV_CHROME_FULLSCREEN_TOOLBAR) != 0 || 
                              (priv->chrome & EV_CHROME_RAISE_TOOLBAR) != 0) && fullscreen;
        findbar = (priv->chrome & EV_CHROME_FINDBAR) != 0;

-       sidebar = (priv->chrome & EV_CHROME_SIDEBAR) != 0 && !fullscreen_mode;
+       sidebar = (priv->chrome & EV_CHROME_SIDEBAR) != 0 && !presentation;

        preview_toolbar = (priv->chrome& EV_CHROME_PREVIEW_TOOLBAR);
 
        set_widget_visibility (priv->menubar, menubar); 
        preview_toolbar = (priv->chrome& EV_CHROME_PREVIEW_TOOLBAR);
 
        set_widget_visibility (priv->menubar, menubar); 

-       set_widget_visibility (priv->toolbar_dock, toolbar);
+       set_widget_visibility (priv->toolbar, toolbar);

        set_widget_visibility (priv->find_bar, findbar);
        set_widget_visibility (priv->sidebar, sidebar);
        set_widget_visibility (priv->find_bar, findbar);
        set_widget_visibility (priv->sidebar, sidebar);

-       set_widget_visibility (priv->preview_toolbar, preview_toolbar);
+       
+       if (priv->preview_toolbar)
+               set_widget_visibility (priv->preview_toolbar, preview_toolbar);

 
        ev_window_set_action_sensitive (window, "EditToolbar", toolbar);
        gtk_widget_set_sensitive (priv->menubar, menubar);
 
 
        ev_window_set_action_sensitive (window, "EditToolbar", toolbar);
        gtk_widget_set_sensitive (priv->menubar, menubar);
 

-       if (priv->fullscreen_popup != NULL) {
+       if (priv->fullscreen_toolbar != NULL) {

                set_widget_visibility (priv->fullscreen_toolbar, fullscreen_toolbar);
                set_widget_visibility (priv->fullscreen_toolbar, fullscreen_toolbar);

-               set_widget_visibility (priv->fullscreen_popup, fullscreen_toolbar);

        }
 }
 
        }
 }
 


@@ -534,8 +521,6 @@ update_chrome_flag (EvWindow *window, EvChrome flag, gboolean active)
        } else {
                priv->chrome &= ~flag;
        }
        } else {
                priv->chrome &= ~flag;
        }

-
-       update_chrome_visibility (window);

 }
 
 static void
 }
 
 static void


@@ -592,6 +577,16 @@ update_sizing_buttons (EvWindow *window)
        }
 }
 
        }
 }
 

+/**
+ * ev_window_is_empty:
+ * @ev_window: The instance of the #EvWindow.
+ *
+ * It does look if there is any document loaded or if there is any job to load
+ * a document.
+ *
+ * Returns: %TRUE if there isn't any document loaded or any any documente to be
+ *          loaded, %FALSE in other case.
+ */

 gboolean
 ev_window_is_empty (const EvWindow *ev_window)
 {
 gboolean
 ev_window_is_empty (const EvWindow *ev_window)
 {


@@ -602,29 +597,56 @@ ev_window_is_empty (const EvWindow *ev_window)
 }
 
 static void
 }
 
 static void

-ev_window_error_dialog_response_cb (GtkWidget *dialog,
-                                  gint       response_id,
-                                  EvWindow  *ev_window)
+ev_window_set_message_area (EvWindow  *window,
+                           GtkWidget *area)

 {
 {

-       gtk_widget_destroy (dialog);
+       if (window->priv->message_area == area)
+               return;
+
+       if (window->priv->message_area)
+               gtk_widget_destroy (window->priv->message_area);
+       window->priv->message_area = area;
+
+       if (!area)
+               return;
+
+       gtk_box_pack_start (GTK_BOX (window->priv->view_box),
+                           window->priv->message_area,
+                           FALSE, FALSE, 0);
+       gtk_box_reorder_child (GTK_BOX (window->priv->view_box),
+                              window->priv->message_area, 0);
+       g_object_add_weak_pointer (G_OBJECT (window->priv->message_area),
+                                  (gpointer) &(window->priv->message_area));

 }
 
 static void
 }
 
 static void

-ev_window_error_dialog (GtkWindow *window, const gchar *msg, GError *error)
+ev_window_error_message_response_cb (EvMessageArea *area,
+                                    gint           response_id,
+                                    EvWindow      *window)

 {
 {

-       GtkWidget *dialog;
+       ev_window_set_message_area (window, NULL);
+}

 
 

-       dialog = gtk_message_dialog_new (GTK_WINDOW (window),
-                                        GTK_DIALOG_DESTROY_WITH_PARENT,
-                                        GTK_MESSAGE_ERROR,
-                                        GTK_BUTTONS_CLOSE,
-                                        msg);
-       gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
-                                                 "%s", error->message);
-       g_signal_connect (dialog, "response",
-                         G_CALLBACK (ev_window_error_dialog_response_cb),
-                          window);
-       gtk_widget_show (dialog);
+static void
+ev_window_error_message (GtkWindow *window, const gchar *msg, GError *error)
+{
+       GtkWidget *area;
+
+       if (EV_WINDOW (window)->priv->message_area)
+               return;
+
+       area = ev_message_area_new (GTK_MESSAGE_ERROR,
+                                   msg,
+                                   GTK_STOCK_CLOSE,
+                                   GTK_RESPONSE_CANCEL,
+                                   NULL);
+       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),
+                         window);
+       gtk_widget_show (area);
+       ev_window_set_message_area (EV_WINDOW (window), area);

 }
 
 static void
 }
 
 static void


@@ -645,8 +667,8 @@ page_changed_cb (EvPageCache *page_cache,
 }
 
 typedef struct _FindTask {
 }
 
 typedef struct _FindTask {

-    const gchar *page_label;
-    gchar *chapter;
+       const gchar *page_label;
+       gchar *chapter;

 } FindTask;
 
 static gboolean
 } FindTask;
 
 static gboolean


@@ -655,26 +677,26 @@ ev_window_find_chapter (GtkTreeModel *tree_model,
                        GtkTreeIter  *iter,
                        gpointer      data)
 {
                        GtkTreeIter  *iter,
                        gpointer      data)
 {

-    FindTask *task = (FindTask *)data;
-    gchar *page_string;
-    
-    gtk_tree_model_get (tree_model, iter,
-                       EV_DOCUMENT_LINKS_COLUMN_PAGE_LABEL, &page_string, 
-                       -1);
-                       
-    if (!page_string)
-           return FALSE;
-           
-    if (!strcmp (page_string, task->page_label)) {
-           gtk_tree_model_get (tree_model, iter,
-                               EV_DOCUMENT_LINKS_COLUMN_MARKUP, &task->chapter, 
-                               -1);
-           g_free (page_string);
-           return TRUE;
-    }
-    
-    g_free (page_string);
-    return FALSE;
+       FindTask *task = (FindTask *)data;
+       gchar *page_string;
+       
+       gtk_tree_model_get (tree_model, iter,
+                           EV_DOCUMENT_LINKS_COLUMN_PAGE_LABEL, &page_string, 
+                           -1);
+       
+       if (!page_string)
+               return FALSE;
+       
+       if (!strcmp (page_string, task->page_label)) {
+               gtk_tree_model_get (tree_model, iter,
+                                   EV_DOCUMENT_LINKS_COLUMN_MARKUP, &task->chapter, 
+                                   -1);
+               g_free (page_string);
+               return TRUE;
+       }
+       
+       g_free (page_string);
+       return FALSE;

 }
 
 static void
 }
 
 static void


@@ -687,6 +709,12 @@ ev_window_add_history (EvWindow *window, gint page, EvLink *link)
        EvLinkAction *action;
        EvLinkDest *dest;
        
        EvLinkAction *action;
        EvLinkDest *dest;
        

+       if (window->priv->history == NULL)
+               return;
+
+       if (!EV_IS_DOCUMENT_LINKS (window->priv->document))
+               return;
+       

        if (link) {
                action = g_object_ref (ev_link_get_action (link));
                dest = ev_link_action_get_dest (action);
        if (link) {
                action = g_object_ref (ev_link_get_action (link));
                dest = ev_link_action_get_dest (action);


@@ -704,8 +732,7 @@ ev_window_add_history (EvWindow *window, gint page, EvLink *link)
        find_task.page_label = page_label;
        find_task.chapter = NULL;
        
        find_task.page_label = page_label;
        find_task.chapter = NULL;
        

-       if (EV_IS_DOCUMENT_LINKS (window->priv->document) && 
-           ev_document_links_has_document_links (EV_DOCUMENT_LINKS (window->priv->document))) {
+       if (ev_document_links_has_document_links (EV_DOCUMENT_LINKS (window->priv->document))) {

                GtkTreeModel *model;
        
                g_object_get (G_OBJECT (window->priv->sidebar_links), "model", &model, NULL);
                GtkTreeModel *model;
        
                g_object_get (G_OBJECT (window->priv->sidebar_links), "model", &model, NULL);


@@ -782,7 +809,7 @@ setup_document_from_metadata (EvWindow *window)
        if (uri && ev_metadata_manager_get (uri, "page", &page, TRUE)) {
                n_pages = ev_page_cache_get_n_pages (window->priv->page_cache);
                new_page = CLAMP (g_value_get_int (&page), 0, n_pages - 1);
        if (uri && ev_metadata_manager_get (uri, "page", &page, TRUE)) {
                n_pages = ev_page_cache_get_n_pages (window->priv->page_cache);
                new_page = CLAMP (g_value_get_int (&page), 0, n_pages - 1);

-               if (new_page == n_pages - 1)
+               if (!window->priv->in_reload && new_page == n_pages - 1)

                        new_page = 0;
                ev_page_cache_set_current_page (window->priv->page_cache,
                                                new_page);
                        new_page = 0;
                ev_page_cache_set_current_page (window->priv->page_cache,
                                                new_page);


@@ -830,7 +857,7 @@ setup_sidebar_from_metadata (EvWindow *window, EvDocument *document)
                } else if (strcmp (page_id, THUMBNAILS_SIDEBAR_ID) && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (thumbs), document)) {
                        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, THUMBNAILS_SIDEBAR_ID) && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (thumbs), document)) {
                        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)) {

-                       ev_sidebar_set_page (EV_SIDEBAR (sidebar), thumbs);
+                       ev_sidebar_set_page (EV_SIDEBAR (sidebar), attachments);

                }
                g_value_unset (&sidebar_page);
        } else if (document && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (links), document)) {
                }
                g_value_unset (&sidebar_page);
        } else if (document && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (links), document)) {


@@ -840,6 +867,7 @@ setup_sidebar_from_metadata (EvWindow *window, EvDocument *document)
        if (ev_metadata_manager_get (uri, "sidebar_visibility", &sidebar_visibility, FALSE)) {
                update_chrome_flag (window, EV_CHROME_SIDEBAR, g_value_get_boolean (&sidebar_visibility));
                g_value_unset (&sidebar_visibility);
        if (ev_metadata_manager_get (uri, "sidebar_visibility", &sidebar_visibility, FALSE)) {
                update_chrome_flag (window, EV_CHROME_SIDEBAR, g_value_get_boolean (&sidebar_visibility));
                g_value_unset (&sidebar_visibility);

+               update_chrome_visibility (window);

        }
 }
 
        }
 }
 


@@ -886,8 +914,14 @@ setup_size_from_metadata (EvWindow *window)
         if (window->priv->page_cache &&
            ev_metadata_manager_get (uri, "window_width_ratio", &width_ratio, FALSE) &&
            ev_metadata_manager_get (uri, "window_height_ratio", &height_ratio, FALSE)) {
         if (window->priv->page_cache &&
            ev_metadata_manager_get (uri, "window_width_ratio", &width_ratio, FALSE) &&
            ev_metadata_manager_get (uri, "window_height_ratio", &height_ratio, FALSE)) {

+               

                gint document_width;
                gint document_height;
                gint document_width;
                gint document_height;

+               
+               GdkScreen *screen;
+               
+               gint request_width;
+               gint request_height;

 
                ev_page_cache_get_max_width (window->priv->page_cache, 
                                             0, 1.0,
 
                ev_page_cache_get_max_width (window->priv->page_cache, 
                                             0, 1.0,


@@ -896,13 +930,22 @@ setup_size_from_metadata (EvWindow *window)
                                             0, 1.0,
                                             &document_height);                 
                
                                             0, 1.0,
                                             &document_height);                 
                

+               request_width = g_value_get_double (&width_ratio) * document_width;
+               request_height = g_value_get_double (&height_ratio) * document_height;
+               
+               screen = gtk_window_get_screen (GTK_WINDOW (window));
+               
+               if (screen) {
+                       request_width = MIN (request_width, gdk_screen_get_width (screen));
+                       request_height = MIN (request_width, gdk_screen_get_height (screen));
+               }
+                               

                gtk_window_resize (GTK_WINDOW (window),
                gtk_window_resize (GTK_WINDOW (window),

-                                  g_value_get_double (&width_ratio) * document_width,
-                                  g_value_get_double (&height_ratio) * document_height);
+                                  request_width,
+                                  request_height);

                g_value_unset (&width_ratio);
                g_value_unset (&height_ratio);
        }
                g_value_unset (&width_ratio);
                g_value_unset (&height_ratio);
        }

-

 }
 
 static void
 }
 
 static void


@@ -944,7 +987,7 @@ setup_view_from_metadata (EvWindow *window)
                gdouble zoom_value;
 
                zoom_value = g_value_get_double (&zoom);
                gdouble zoom_value;
 
                zoom_value = g_value_get_double (&zoom);

-               zoom_value *= ev_window_get_screen_dpi (window) / 72.0;
+               zoom_value *= get_screen_dpi (GTK_WINDOW (window)) / 72.0;

                ev_view_set_zoom (view, zoom_value, FALSE);
                g_value_unset (&zoom);
        }
                ev_view_set_zoom (view, zoom_value, FALSE);
                g_value_unset (&zoom);
        }


@@ -999,36 +1042,84 @@ setup_view_from_metadata (EvWindow *window)
 }
 
 static void
 }
 
 static void

+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);
+
+               g_signal_handlers_disconnect_by_func (ev_window->priv->thumbnail_job,
+                                                     ev_window_set_icon_from_thumbnail,
+                                                     ev_window);
+               g_object_unref (ev_window->priv->thumbnail_job);
+               ev_window->priv->thumbnail_job = NULL;
+       }
+}
+
+static void
+ev_window_set_icon_from_thumbnail (EvJobThumbnail *job,
+                                  EvWindow       *ev_window)
+{
+       if (job->thumbnail) {
+               gtk_window_set_icon (GTK_WINDOW (ev_window),
+                                    job->thumbnail);
+       }
+
+       ev_window_clear_thumbnail_job (ev_window);
+}
+
+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;
+       
+       if (!EV_IS_DOCUMENT_THUMBNAILS (document)) {
+               return;
+       }
+       
+       ev_window_clear_thumbnail_job (ev_window);
+       
+       ev_page_cache_get_size (ev_window->priv->page_cache,
+                               0, 0, 1.0,
+                               &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);
+       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);
+}
+
+static gboolean

 ev_window_setup_document (EvWindow *ev_window)
 {
        const EvDocumentInfo *info;
 ev_window_setup_document (EvWindow *ev_window)
 {
        const EvDocumentInfo *info;

-       EvDocument *document;
-       EvView *view = EV_VIEW (ev_window->priv->view);
+       EvDocument *document = ev_window->priv->document;

        EvSidebar *sidebar = EV_SIDEBAR (ev_window->priv->sidebar);
        GtkAction *action;
        EvSidebar *sidebar = EV_SIDEBAR (ev_window->priv->sidebar);
        GtkAction *action;

-
-       document = ev_window->priv->document;
-       ev_window->priv->page_cache = ev_page_cache_get (ev_window->priv->document);
-       g_signal_connect (ev_window->priv->page_cache, "page-changed", G_CALLBACK (page_changed_cb), ev_window);
-       g_signal_connect (ev_window->priv->page_cache, "history-changed", G_CALLBACK (history_changed_cb), ev_window);
-
+       

        if (EV_IS_DOCUMENT_FIND (document)) {
                g_signal_connect_object (G_OBJECT (document),
                                         "find_changed",
                                         G_CALLBACK (find_changed_cb),  
                                         ev_window, 0);
        }
        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_refresh_window_thumbnail (ev_window, 0);

 
 

-       ev_sidebar_set_document (sidebar, document);
-
-       if (ev_page_cache_get_n_pages (ev_window->priv->page_cache) > 0) {
-               ev_view_set_document (view, document);
-       }

        ev_window_set_page_mode (ev_window, PAGE_MODE_DOCUMENT);
        ev_window_set_page_mode (ev_window, PAGE_MODE_DOCUMENT);

-

        ev_window_title_set_document (ev_window->priv->title, document);
        ev_window_title_set_uri (ev_window->priv->title, ev_window->priv->uri);
 
        ev_window_title_set_document (ev_window->priv->title, document);
        ev_window_title_set_uri (ev_window->priv->title, ev_window->priv->uri);
 

+       ev_sidebar_set_document (sidebar, document);
+

        action = gtk_action_group_get_action (ev_window->priv->action_group, PAGE_SELECTOR_ACTION);
        ev_page_action_set_document (EV_PAGE_ACTION (action), document);
        ev_window_setup_action_sensitivity (ev_window);
        action = gtk_action_group_get_action (ev_window->priv->action_group, PAGE_SELECTOR_ACTION);
        ev_page_action_set_document (EV_PAGE_ACTION (action), document);
        ev_window_setup_action_sensitivity (ev_window);


@@ -1044,12 +1135,38 @@ ev_window_setup_document (EvWindow *ev_window)
                                                   ev_window->priv->document);
        }
        
                                                   ev_window->priv->document);
        }
        

+       info = ev_page_cache_get_info (ev_window->priv->page_cache);
+       update_document_mode (ev_window, info->mode);
+
+       return FALSE;
+}
+
+static void
+ev_window_set_document (EvWindow *ev_window, EvDocument *document)
+{
+       EvView *view = EV_VIEW (ev_window->priv->view);
+
+       if (ev_window->priv->document)
+               g_object_unref (ev_window->priv->document);
+       ev_window->priv->document = g_object_ref (document);
+
+       ev_window_set_message_area (ev_window, NULL);
+       
+       ev_window->priv->page_cache = ev_page_cache_get (ev_window->priv->document);
+       g_signal_connect (ev_window->priv->page_cache, "page-changed",
+                         G_CALLBACK (page_changed_cb), ev_window);
+       g_signal_connect (ev_window->priv->page_cache, "history-changed",
+                         G_CALLBACK (history_changed_cb), ev_window);
+

        setup_size_from_metadata (ev_window);
        setup_size_from_metadata (ev_window);

-       setup_document_from_metadata (ev_window);

        setup_sidebar_from_metadata (ev_window, document);
        setup_sidebar_from_metadata (ev_window, document);

+       setup_document_from_metadata (ev_window);

 
 

-       info = ev_page_cache_get_info (ev_window->priv->page_cache);
-       update_document_mode (ev_window, info->mode);
+       if (ev_page_cache_get_n_pages (ev_window->priv->page_cache) > 0) {
+               ev_view_set_document (view, document);
+       }
+
+       g_idle_add ((GSourceFunc)ev_window_setup_document, ev_window);

 }
 
 static void
 }
 
 static void


@@ -1104,7 +1221,7 @@ ev_window_popup_password_dialog (EvWindow *ev_window)
                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),
                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));
+                                          (gpointer) &(ev_window->priv->password_dialog));

                g_signal_connect (ev_window->priv->password_dialog,
                                  "response",
                                  G_CALLBACK (password_dialog_response),
                g_signal_connect (ev_window->priv->password_dialog,
                                  "response",
                                  G_CALLBACK (password_dialog_response),


@@ -1118,60 +1235,54 @@ ev_window_popup_password_dialog (EvWindow *ev_window)
 static void
 ev_window_clear_load_job (EvWindow *ev_window)
 {
 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);
-
-       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);
-       ev_window->priv->load_job = NULL;
-    }
+       if (ev_window->priv->load_job != NULL) {
+               
+               if (!ev_window->priv->load_job->finished)
+                       ev_job_queue_remove_job (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);
+               ev_window->priv->load_job = NULL;
+       }

 }
 
 static void
 ev_window_clear_local_uri (EvWindow *ev_window)
 {
 }
 
 static void
 ev_window_clear_local_uri (EvWindow *ev_window)
 {

-    char *filename;
-    
-    if (ev_window->priv->local_uri) {
-           filename = g_filename_from_uri (ev_window->priv->local_uri, NULL, NULL);
-           if (filename != NULL) {
-                   g_unlink (filename);
-                   g_free (filename);
-           }
-           g_free (ev_window->priv->local_uri);
-           ev_window->priv->local_uri = NULL;
-    }
+       if (ev_window->priv->local_uri) {
+               ev_tmp_uri_unlink (ev_window->priv->local_uri);
+               g_free (ev_window->priv->local_uri);
+               ev_window->priv->local_uri = NULL;
+       }
+}
+
+static void
+ev_window_clear_print_settings_file (EvWindow *ev_window)
+{
+       if (ev_window->priv->print_settings_file) {
+               g_unlink (ev_window->priv->print_settings_file);
+               g_free (ev_window->priv->print_settings_file);
+               ev_window->priv->print_settings_file = NULL;
+       }

 }
 
 static void
 ev_window_clear_temp_file (EvWindow *ev_window)
 {
 }
 
 static void
 ev_window_clear_temp_file (EvWindow *ev_window)
 {

-       GnomeVFSURI *uri;
-       gchar       *filename;
-       const gchar *tempdir;
+       GFile *file, *tempdir;

 
        if (!ev_window->priv->uri)
                return;
 
 
        if (!ev_window->priv->uri)
                return;
 

-       uri = gnome_vfs_uri_new (ev_window->priv->uri);
-       if (!gnome_vfs_uri_is_local (uri)) {
-               gnome_vfs_uri_unref (uri);
-               return;
-       }
-       gnome_vfs_uri_unref (uri);
-
-       filename = g_filename_from_uri (ev_window->priv->uri, NULL, NULL);
-       if (!filename)
-               return;
+       file = g_file_new_for_uri (ev_window->priv->uri);
+       tempdir = g_file_new_for_path (g_get_tmp_dir ());

 
 

-       tempdir = g_get_tmp_dir ();
-       if (g_ascii_strncasecmp (filename, tempdir, strlen (tempdir)) == 0) {
-               g_unlink (filename);
+       if (g_file_has_prefix (file, tempdir)) {
+               g_file_delete (file, NULL, NULL);

        }
 
        }
 

-       g_free (filename);
+       g_object_unref (file);
+       g_object_unref (tempdir);

 }
 
 /* This callback will executed when load job will be finished.
 }
 
 /* This callback will executed when load job will be finished.


@@ -1195,17 +1306,16 @@ ev_window_load_job_cb  (EvJobLoad *job,
 
        /* Success! */
        if (job->error == NULL) {
 
        /* Success! */
        if (job->error == NULL) {

-               if (ev_window->priv->document)
-                       g_object_unref (ev_window->priv->document);
-               ev_window->priv->document = g_object_ref (document);
+               ev_window_set_document (ev_window, document);
+               
+               if (job->mode != EV_WINDOW_MODE_PREVIEW) {
+                       setup_view_from_metadata (ev_window);
+               }

 
                if (!ev_window->priv->unlink_temp_file) {
 
                if (!ev_window->priv->unlink_temp_file) {

-                       setup_view_from_metadata (ev_window);

                        ev_window_add_recent (ev_window, ev_window->priv->uri);
                }
 
                        ev_window_add_recent (ev_window, ev_window->priv->uri);
                }
 

-               ev_window_setup_document (ev_window);
-

                if (job->dest) {
                        EvLink *link;
                        EvLinkAction *link_action;
                if (job->dest) {
                        EvLink *link;
                        EvLinkAction *link_action;


@@ -1230,41 +1340,74 @@ ev_window_load_job_cb  (EvJobLoad *job,
                                break;
                }
 
                                break;
                }
 

-               ev_window_clear_load_job (ev_window);           
+               /* 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)) {
+                       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);
+               }
+
+               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) {

-               gchar *base_name, *file_name;
+               GFile *file;
+               gchar *base_name;

 
                setup_view_from_metadata (ev_window);
 
 
                setup_view_from_metadata (ev_window);
 

-               file_name = gnome_vfs_format_uri_for_display (job->uri);
-               base_name = g_path_get_basename (file_name);
+               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);
                ev_password_view_set_file_name (EV_PASSWORD_VIEW (ev_window->priv->password_view),
                                                base_name);

-               g_free (file_name);
+               g_object_unref (file);

                g_free (base_name);
                ev_window_set_page_mode (ev_window, PAGE_MODE_PASSWORD);
                
                ev_window_popup_password_dialog (ev_window);
        } else {
                g_free (base_name);
                ev_window_set_page_mode (ev_window, PAGE_MODE_PASSWORD);
                
                ev_window_popup_password_dialog (ev_window);
        } else {

-               ev_window_error_dialog (GTK_WINDOW (ev_window), 
-                                       _("Unable to open document"),
-                                       job->error);
+               ev_window_error_message (GTK_WINDOW (ev_window), 
+                                        _("Unable to open document"),
+                                        job->error);

                ev_window_clear_load_job (ev_window);
                ev_window_clear_load_job (ev_window);

+               ev_window->priv->in_reload = FALSE;

        }       
 
        return;
 }
 
        }       
 
        return;
 }
 

+/**
+ * ev_window_get_uri:
+ * @ev_window: The instance of the #EvWindow.
+ *
+ * It returns the uri of the document showed in the #EvWindow.
+ *
+ * Returns: the uri of the document showed in the #EvWindow.
+ */

 const char *
 ev_window_get_uri (EvWindow *ev_window)
 {
        return ev_window->priv->uri;
 }
 
 const char *
 ev_window_get_uri (EvWindow *ev_window)
 {
        return ev_window->priv->uri;
 }
 

+/**
+ * ev_window_close_dialogs:
+ * @ev_window: The window where dialogs will be closed.
+ *
+ * It looks for password, print and properties dialogs and closes them and
+ * frees them from memory. If there is any print job it does free it too.
+ */

 static void
 ev_window_close_dialogs (EvWindow *ev_window)
 {
 static void
 ev_window_close_dialogs (EvWindow *ev_window)
 {


@@ -1272,44 +1415,23 @@ ev_window_close_dialogs (EvWindow *ev_window)
                gtk_widget_destroy (ev_window->priv->password_dialog);
        ev_window->priv->password_dialog = NULL;
        
                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);
        ev_window->priv->properties = NULL;
 }
 
        
        if (ev_window->priv->properties)
                gtk_widget_destroy (ev_window->priv->properties);
        ev_window->priv->properties = NULL;
 }
 

-static gint
-xfer_update_progress_callback (GnomeVFSAsyncHandle      *handle,
-                              GnomeVFSXferProgressInfo *info,
-                              EvWindow                 *ev_window)
-{
-       switch (info->status) {
-               case GNOME_VFS_XFER_PROGRESS_STATUS_OK:
-                       if (info->phase == GNOME_VFS_XFER_PHASE_COMPLETED) {
-                               ev_job_queue_add_job (ev_window->priv->load_job, EV_JOB_PRIORITY_HIGH);
-                       }
-
-                       return 1;
-               case GNOME_VFS_XFER_PROGRESS_STATUS_VFSERROR:
-               case GNOME_VFS_XFER_PROGRESS_STATUS_OVERWRITE:
-               case GNOME_VFS_XFER_PROGRESS_STATUS_DUPLICATE:
-                       return 1;
-               default:
-                       g_assert_not_reached ();
-       }
-
-       return 0;
+static void
+window_open_file_copy_ready_cb (GFile        *source,
+                               GAsyncResult *async_result,
+                               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);

 }
 
 void
 }
 
 void


@@ -1317,69 +1439,71 @@ ev_window_open_uri (EvWindow       *ev_window,
                    const char     *uri,
                    EvLinkDest     *dest,
                    EvWindowRunMode mode,
                    const char     *uri,
                    EvLinkDest     *dest,
                    EvWindowRunMode mode,

-                   gboolean        unlink_temp_file)
+                   const gchar    *search_string, 
+                   gboolean        unlink_temp_file,
+                   const gchar    *print_settings)

 {
 {

-       GnomeVFSURI *source_uri;
-       GnomeVFSURI *target_uri;
+       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_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;
 
        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);
        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);
+       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);
 
        g_signal_connect (ev_window->priv->load_job,
                          "finished",
                          G_CALLBACK (ev_window_load_job_cb),
                          ev_window);
 

-       source_uri = gnome_vfs_uri_new (uri);
-       if (!gnome_vfs_uri_is_local (source_uri) && !ev_window->priv->local_uri) {
-               GnomeVFSAsyncHandle *handle;
-               GList               *slist = NULL;
-               GList               *tlist = NULL;
-               char                *tmp_name;
-               char                *base_name;
+       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;

 
                /* 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);
 
                /* 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 = gnome_vfs_uri_extract_short_name (source_uri);
+               base_name = g_file_get_basename (source_file);

                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_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);
                

-               target_uri = gnome_vfs_uri_new (ev_window->priv->local_uri);
-               
-               slist = g_list_prepend (slist, source_uri);
-               tlist = g_list_prepend (tlist, target_uri);
-               gnome_vfs_async_xfer (&handle, slist, tlist,
-                                     GNOME_VFS_XFER_DEFAULT | GNOME_VFS_XFER_FOLLOW_LINKS,
-                                     GNOME_VFS_XFER_ERROR_MODE_ABORT,
-                                     GNOME_VFS_XFER_OVERWRITE_MODE_REPLACE,
-                                     GNOME_VFS_PRIORITY_DEFAULT,
-                                     (GnomeVFSAsyncXferProgressCallback)xfer_update_progress_callback,
-                                     ev_window,
-                                     NULL, NULL); 
-               
-               g_list_free (slist);
-               g_list_free (tlist);
-               gnome_vfs_uri_unref (target_uri);
-               gnome_vfs_uri_unref (source_uri);
-               
+               target_file = g_file_new_for_uri (ev_window->priv->local_uri);
+
+               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,
+                                  ev_window);
+               g_object_unref (target_file);

                return;
        }
 
                return;
        }
 

-       gnome_vfs_uri_unref (source_uri);
+       g_object_unref (source_file);

        ev_job_queue_add_job (ev_window->priv->load_job, EV_JOB_PRIORITY_HIGH);
 }
 
        ev_job_queue_add_job (ev_window->priv->load_job, EV_JOB_PRIORITY_HIGH);
 }
 


@@ -1388,6 +1512,8 @@ file_open_dialog_response_cb (GtkWidget *chooser,
                              gint       response_id,
                              EvWindow  *ev_window)
 {
                              gint       response_id,
                              EvWindow  *ev_window)
 {

+       gchar *uri;
+

        if (response_id == GTK_RESPONSE_OK) {
                GSList *uris;
 
        if (response_id == GTK_RESPONSE_OK) {
                GSList *uris;
 


@@ -1400,8 +1526,10 @@ file_open_dialog_response_cb (GtkWidget *chooser,
                g_slist_foreach (uris, (GFunc)g_free, NULL);    
                g_slist_free (uris);
        }
                g_slist_foreach (uris, (GFunc)g_free, NULL);    
                g_slist_free (uris);
        }

-       ev_application_set_chooser_uri (EV_APP, 
-                                       gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (chooser)));
+
+       uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (chooser));
+       ev_application_set_chooser_uri (EV_APP, uri);
+       g_free (uri);

 
        gtk_widget_destroy (chooser);
 }
 
        gtk_widget_destroy (chooser);
 }


@@ -1428,6 +1556,12 @@ ev_window_cmd_file_open (GtkAction *action, EvWindow *window)
        } else if (window->priv->uri != NULL) {
                gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (chooser),
                                          window->priv->uri);
        } else if (window->priv->uri != NULL) {
                gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (chooser),
                                          window->priv->uri);

+       } else {
+               const gchar *folder;
+
+               folder = g_get_user_special_dir (G_USER_DIRECTORY_DOCUMENTS);
+               gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser),
+                                                    folder ? folder : g_get_home_dir ());

        }
        
        g_signal_connect (chooser, "response",
        }
        
        g_signal_connect (chooser, "response",


@@ -1481,18 +1615,22 @@ ev_window_create_tmp_symlink (const gchar *filename, GError **error)
 static void
 ev_window_cmd_file_open_copy_at_dest (EvWindow *window, EvLinkDest *dest)
 {
 static void
 ev_window_cmd_file_open_copy_at_dest (EvWindow *window, EvLinkDest *dest)
 {

-       GError *error = NULL;
-       gchar *symlink_uri;
-       gchar *old_filename;
-       gchar *new_filename;
-
-       old_filename = g_filename_from_uri (window->priv->uri, NULL, NULL);
+       GError      *error = NULL;
+       gchar       *symlink_uri;
+       gchar       *old_filename;
+       gchar       *new_filename;
+       const gchar *uri_unc;
+
+       uri_unc = g_object_get_data (G_OBJECT (window->priv->document),
+                                    "uri-uncompressed");
+       old_filename = g_filename_from_uri (uri_unc ? uri_unc : window->priv->uri,
+                                           NULL, NULL);

        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_dialog (GTK_WINDOW (window),
-                                       _("Cannot open a copy."),
-                                       error);
+               ev_window_error_message (GTK_WINDOW (window),
+                                        _("Cannot open a copy."),
+                                        error);

 
                g_error_free (error);
                g_free (old_filename);
 
                g_error_free (error);
                g_free (old_filename);


@@ -1511,7 +1649,9 @@ ev_window_cmd_file_open_copy_at_dest (EvWindow *window, EvLinkDest *dest)
                                         gtk_window_get_screen (GTK_WINDOW (window)),
                                         dest,
                                         0,
                                         gtk_window_get_screen (GTK_WINDOW (window)),
                                         dest,
                                         0,

+                                        NULL, 

                                         TRUE,
                                         TRUE,

+                                        NULL,

                                         GDK_CURRENT_TIME);
        g_free (symlink_uri);
 }
                                         GDK_CURRENT_TIME);
        g_free (symlink_uri);
 }


@@ -1531,10 +1671,9 @@ ev_window_cmd_file_open_copy (GtkAction *action, EvWindow *window)
        g_object_unref (dest);
 }
 
        g_object_unref (dest);
 }
 

-#ifdef HAVE_GTK_RECENT

 static void
 static void

-ev_window_cmd_recent_file_activate (GtkAction     *action,
-                                   EvWindow      *window)
+ev_window_cmd_recent_file_activate (GtkAction *action,
+                                   EvWindow  *window)

 {
        GtkRecentInfo *info;
        const gchar   *uri;
 {
        GtkRecentInfo *info;
        const gchar   *uri;


@@ -1546,44 +1685,27 @@ ev_window_cmd_recent_file_activate (GtkAction     *action,
        
        ev_application_open_uri_at_dest (EV_APP, uri,
                                         gtk_window_get_screen (GTK_WINDOW (window)),
        
        ev_application_open_uri_at_dest (EV_APP, uri,
                                         gtk_window_get_screen (GTK_WINDOW (window)),

-                                        NULL, 0, FALSE,
+                                        NULL, 0, NULL, FALSE, NULL, 

                                         GDK_CURRENT_TIME);
 }
                                         GDK_CURRENT_TIME);
 }

-#else
+

 static void
 static void

-ev_window_cmd_recent_file_activate (GtkAction *action,
-                                   EvWindow *ev_window)
+ev_window_open_recent_action_item_activated (EvOpenRecentAction *action,
+                                            const gchar        *uri,
+                                            EvWindow           *window)

 {
 {

-       char *uri;
-       EggRecentItem *item;
-
-       item = egg_recent_view_uimanager_get_item (ev_window->priv->recent_view,
-                                                  action);
-
-       uri = egg_recent_item_get_uri (item);
-
-       ev_application_open_uri (EV_APP, uri, NULL,
-                                GDK_CURRENT_TIME, NULL);
-       
-       g_free (uri);
+       ev_application_open_uri_at_dest (EV_APP, uri,
+                                        gtk_window_get_screen (GTK_WINDOW (window)),
+                                        NULL, 0, NULL, FALSE, NULL, 
+                                        GDK_CURRENT_TIME);

 }
 }

-#endif /* HAVE_GTK_RECENT */

 
 static void
 ev_window_add_recent (EvWindow *window, const char *filename)
 {
 
 static void
 ev_window_add_recent (EvWindow *window, const char *filename)
 {

-#ifdef HAVE_GTK_RECENT

        gtk_recent_manager_add_item (window->priv->recent_manager, filename);
        gtk_recent_manager_add_item (window->priv->recent_manager, filename);

-#else
-       EggRecentItem *item;
-
-       item = egg_recent_item_new_from_uri (filename);
-       egg_recent_item_add_group (item, "Evince");
-       egg_recent_model_add_full (ev_application_get_recent_model (EV_APP), item);
-#endif /* HAVE_GTK_RECENT */

 }
 
 }
 

-#ifdef HAVE_GTK_RECENT

 static gint
 compare_recent_items (GtkRecentInfo *a, GtkRecentInfo *b)
 {
 static gint
 compare_recent_items (GtkRecentInfo *a, GtkRecentInfo *b)
 {


@@ -1608,7 +1730,6 @@ compare_recent_items (GtkRecentInfo *a, GtkRecentInfo *b)
 
        return 0;
 }
 
        return 0;
 }

-#endif /* HAVE_GTK_RECENT */

 
 /*
  * Doubles underscore to avoid spurious menu accels.
 
 /*
  * Doubles underscore to avoid spurious menu accels.


@@ -1620,23 +1741,24 @@ ev_window_get_recent_file_label (gint index, const gchar *filename)
        gint length;
        const gchar *p;
        const gchar *end;
        gint length;
        const gchar *p;
        const gchar *end;

- 
+       gboolean is_rtl;
+       
+       is_rtl = (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL);
+

        g_return_val_if_fail (filename != NULL, NULL);
        
        length = strlen (filename);
        str = g_string_sized_new (length + 10);
        g_return_val_if_fail (filename != NULL, NULL);
        
        length = strlen (filename);
        str = g_string_sized_new (length + 10);

-       g_string_printf (str, "_%d.  ", index);
+       g_string_printf (str, "%s_%d.  ", is_rtl ? "\xE2\x80\x8F" : "", index);

 
        p = filename;
        end = filename + length;
  
 
        p = filename;
        end = filename + length;
  

-       while (p != end)
-       {
+       while (p != end) {

                const gchar *next;
                next = g_utf8_next_char (p);
  
                const gchar *next;
                next = g_utf8_next_char (p);
  

-               switch (*p)
-               {
+               switch (*p) {

                        case '_':
                                g_string_append (str, "__");
                                break;
                        case '_':
                                g_string_append (str, "__");
                                break;


@@ -1654,7 +1776,6 @@ ev_window_get_recent_file_label (gint index, const gchar *filename)
 static void
 ev_window_setup_recent (EvWindow *ev_window)
 {
 static void
 ev_window_setup_recent (EvWindow *ev_window)
 {

-#ifdef HAVE_GTK_RECENT

        GList        *items, *l;
        guint         n_items = 0;
        const gchar  *evince = g_get_application_name ();
        GList        *items, *l;
        guint         n_items = 0;
        const gchar  *evince = g_get_application_name ();


@@ -1729,87 +1850,112 @@ ev_window_setup_recent (EvWindow *ev_window)
        
        g_list_foreach (items, (GFunc) gtk_recent_info_unref, NULL);
        g_list_free (items);
        
        g_list_foreach (items, (GFunc) gtk_recent_info_unref, NULL);
        g_list_free (items);

-#else /* HAVE_GTK_RECENT */
-       ev_window->priv->recent_view = egg_recent_view_uimanager_new (ev_window->priv->ui_manager,
-                                                                     "/MainMenu/FileMenu/RecentFilesMenu",
-                                                                     G_CALLBACK (ev_window_cmd_recent_file_activate), 
-                                                                     ev_window);       
-
-        egg_recent_view_uimanager_show_icons (EGG_RECENT_VIEW_UIMANAGER (ev_window->priv->recent_view), FALSE);
-
-       egg_recent_view_set_model (EGG_RECENT_VIEW (ev_window->priv->recent_view),
-                                  ev_application_get_recent_model (EV_APP));
-
-       egg_recent_view_uimanager_set_trailing_sep (ev_window->priv->recent_view, TRUE);
-       
-       g_signal_connect (ev_window->priv->recent_view, "activate",
-                       G_CALLBACK (ev_window_cmd_recent_file_activate), ev_window);
-#endif /* HAVE_GTK_RECENT */

 }
 
 static void
 }
 
 static void

-file_save_dialog_response_cb (GtkWidget *fc,
-                             gint       response_id,
-                             EvWindow  *ev_window)
+window_save_file_copy_ready_cb (GFile        *src,
+                               GAsyncResult *async_result,
+                               GFile        *dst)

 {
 {

-       gboolean success;
+       EvWindow  *window;
+       GtkWidget *dialog;
+       gchar     *name;
+       GError    *error = NULL;

 
 

-       if (response_id == GTK_RESPONSE_OK) {
-               gint    fd;
-               gchar  *filename;
-               gchar  *tmp_filename;
-               GError *error = NULL;
+       if (g_file_copy_finish (src, async_result, &error)) {
+               ev_tmp_file_unlink (src);
+               return;
+       }

 
 

-               filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fc));
-               tmp_filename = g_strdup_printf ("%s.XXXXXX", filename);
-               
-               fd = g_mkstemp (tmp_filename);
-               if (fd == -1) {
-                       gchar *display_name;
-                       gint   save_errno = errno;
-                       
-                       display_name = g_filename_display_name (tmp_filename);
-                       g_set_error (&error,
-                                    G_FILE_ERROR,
-                                    g_file_error_from_errno (save_errno),
-                                    _("Failed to create file “%s”: %s"),
-                                    display_name, g_strerror (save_errno));
-                       g_free (display_name);
-               } else {
-                       gchar *uri;
+       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,
+                                        _("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);
+       ev_tmp_file_unlink (src);

 
 

-                       uri = g_filename_to_uri (tmp_filename, NULL, NULL);
-                       
-                       ev_document_doc_mutex_lock ();
-                       success = ev_document_save (ev_window->priv->document,
-                                                   uri,
-                                                   &error);
-                       ev_document_doc_mutex_unlock ();
+       g_free (name);
+       g_error_free (error);
+}

 
 

-                       g_free (uri);
-                       close (fd);
-               }
+static void
+ev_window_save_remote (EvWindow *ev_window,
+                      GFile    *src,
+                      GFile    *dst)
+{
+       g_object_set_data (G_OBJECT (dst), "ev-window", ev_window);
+       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);                
+}

 
 

-               if (!error) {
-                       if (g_rename (tmp_filename, filename) == -1) {
-                               g_unlink (tmp_filename);
-                       }
-               } else {
-                       gchar *msg;
-                       gchar *uri;
-
-                       uri = g_filename_to_uri (filename, NULL, NULL);
-                       msg = g_strdup_printf (_("The file could not be saved as “%s”."), uri);
-                       ev_window_error_dialog (GTK_WINDOW (ev_window), msg, error);
-                       g_free (msg);
-                       g_free (uri);
-                       g_error_free (error);
-               }
+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);

                
                

-               g_free (tmp_filename);
-               g_free (filename);
+               g_signal_handlers_disconnect_by_func (ev_window->priv->save_job,
+                                                     ev_window_save_job_cb,
+                                                     ev_window);
+               g_object_unref (ev_window->priv->save_job);
+               ev_window->priv->save_job = NULL;
+       }
+}
+
+static void
+ev_window_save_job_cb (EvJobSave *job,
+                      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);

        }
 
        }
 

+       ev_window_clear_save_job (window);
+}
+
+static void
+file_save_dialog_response_cb (GtkWidget *fc,
+                             gint       response_id,
+                             EvWindow  *ev_window)
+{
+       gchar *uri;
+       
+       if (response_id != GTK_RESPONSE_OK) {
+               gtk_widget_destroy (fc);
+               return;
+       }
+       
+       uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (fc));
+       
+       ev_window_clear_save_job (ev_window);
+       ev_window->priv->save_job = ev_job_save_new (ev_window->priv->document,
+                                                    uri, ev_window->priv->uri);
+       g_signal_connect (ev_window->priv->save_job, "finished",
+                         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);
+
+       g_free (uri);
+

        gtk_widget_destroy (fc);
 }
 
        gtk_widget_destroy (fc);
 }
 


@@ -1818,7 +1964,8 @@ ev_window_cmd_save_as (GtkAction *action, EvWindow *ev_window)
 {
        GtkWidget *fc;
        gchar *base_name;
 {
        GtkWidget *fc;
        gchar *base_name;

-       gchar *file_name;
+       GFile *file;
+       const gchar *folder;

 
        fc = gtk_file_chooser_dialog_new (
                _("Save a Copy"),
 
        fc = gtk_file_chooser_dialog_new (
                _("Save a Copy"),


@@ -1830,13 +1977,19 @@ ev_window_cmd_save_as (GtkAction *action, EvWindow *ev_window)
        ev_document_factory_add_filters (fc, ev_window->priv->document);
        gtk_dialog_set_default_response (GTK_DIALOG (fc), GTK_RESPONSE_OK);
 
        ev_document_factory_add_filters (fc, ev_window->priv->document);
        gtk_dialog_set_default_response (GTK_DIALOG (fc), GTK_RESPONSE_OK);
 

-       gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER (fc), TRUE);    
-       file_name = gnome_vfs_format_uri_for_display (ev_window->priv->uri);
-       base_name = g_path_get_basename (file_name);
+       gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (fc), FALSE);
+       gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (fc), TRUE);
+       file = g_file_new_for_uri (ev_window->priv->uri);
+       base_name = g_file_get_basename (file);

        gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (fc), base_name);
        gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (fc), base_name);

-       g_free (file_name);
+       
+       folder = g_get_user_special_dir (G_USER_DIRECTORY_DOCUMENTS);
+       gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (fc),
+                                            folder ? folder : g_get_home_dir ());
+       
+       g_object_unref (file);

        g_free (base_name);
        g_free (base_name);

-
+        

        g_signal_connect (fc, "response",
                          G_CALLBACK (file_save_dialog_response_cb),
                          ev_window);
        g_signal_connect (fc, "response",
                          G_CALLBACK (file_save_dialog_response_cb),
                          ev_window);


@@ -1844,7 +1997,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)
 static void
 ev_window_print_page_setup_done_cb (GtkPageSetup *page_setup,
                                    EvWindow     *window)


@@ -1857,22 +2009,18 @@ ev_window_print_page_setup_done_cb (GtkPageSetup *page_setup,
                g_object_unref (window->priv->print_page_setup);
        window->priv->print_page_setup = g_object_ref (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)
 {
 
 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);
        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)
 {
 static void
 ev_window_clear_print_job (EvWindow *window)
 {


@@ -1886,6 +2034,45 @@ ev_window_clear_print_job (EvWindow *window)
                g_object_unref (window->priv->print_job);
                window->priv->print_job = NULL;
        }
                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)
+{
+       gchar *uri = window->priv->uri;
+       gint   i;
+       
+       /* Load print setting that are specific to the document */
+       for (i = 0; i < G_N_ELEMENTS (document_print_settings); i++) {
+               GValue   value = { 0, };
+               gboolean success;
+
+               success = ev_metadata_manager_get (uri, document_print_settings[i], &value, TRUE);
+               gtk_print_settings_set (window->priv->print_settings,
+                                       document_print_settings[i],
+                                       success ? g_value_get_string (&value) : NULL);
+       }
+}
+
+static void
+ev_window_save_print_settings (EvWindow *window)
+{
+       gchar *uri = window->priv->uri;
+       gint   i;
+       
+       /* Save print settings that are specific to the document */
+       for (i = 0; i < G_N_ELEMENTS (document_print_settings); i++) {
+               const gchar *value;
+
+               value = gtk_print_settings_get (window->priv->print_settings,
+                                               document_print_settings[i]);
+               ev_metadata_manager_set_string (uri, document_print_settings[i], value);
+       }

 }
 
 static void
 }
 
 static void


@@ -1908,6 +2095,11 @@ ev_window_print_finished (GtkPrintJob *print_job,
 
                gtk_dialog_run (GTK_DIALOG (dialog));
                gtk_widget_destroy (dialog);
 
                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);

        }
 }
 
        }
 }
 


@@ -1915,13 +2107,9 @@ static void
 ev_window_print_send (EvWindow    *window,
                      const gchar *filename)
 {
 ev_window_print_send (EvWindow    *window,
                      const gchar *filename)
 {

-       GtkPrintJob *job;

        GtkPrintSettings *settings;
        GtkPrintSettings *settings;

-       GError      *error = NULL;
+       EvFileExporterCapabilities capabilities;

        
        

-       if (window->priv->gtk_print_job)
-               g_object_unref (window->priv->gtk_print_job);
-

        /* 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,
        /* 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,


@@ -1929,32 +2117,73 @@ ev_window_print_send (EvWindow    *window,
         * settings set to default values. 
         */
        settings = gtk_print_settings_copy (window->priv->print_settings);
         * settings set to default values. 
         */
        settings = gtk_print_settings_copy (window->priv->print_settings);

-       gtk_print_settings_set_n_copies (settings, 1);
+       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_page_ranges (settings, NULL, 0);

-       gtk_print_settings_set_page_set (settings, GTK_PAGE_SET_ALL);

        gtk_print_settings_set_print_pages (settings, GTK_PRINT_PAGES_ALL);
        gtk_print_settings_set_print_pages (settings, GTK_PRINT_PAGES_ALL);

-       gtk_print_settings_set_scale (settings, 1.0);
-       gtk_print_settings_set_collate (settings, FALSE);
-       gtk_print_settings_set_reverse (settings, FALSE);
-       
-       job = gtk_print_job_new ("evince-print",
-                                window->priv->printer,
-                                settings,
-                                window->priv->print_page_setup);
-
-       g_object_unref (settings);
+       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);
+       }

        
        

-       window->priv->gtk_print_job = job;
+       if (window->priv->print_preview) {
+               gchar *uri;
+               gchar *print_settings_file = NULL;

 
 

-       if (gtk_print_job_set_source_file (job, filename, &error)) {
-               gtk_print_job_send (job,
-                                   (GtkPrintJobCompleteFunc)ev_window_print_finished,
-                                   window, 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);

        } else {
        } else {

-               ev_window_clear_print_job (window);
-               g_warning (error->message);
-               g_error_free (error);
+               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);
+               }

        }
        }

+
+       g_object_unref (settings);

 }
 
 static void
 }
 
 static void


@@ -1981,6 +2210,7 @@ ev_window_print_dialog_response_cb (GtkDialog *dialog,
        EvPrintPageSet page_set;
        gint           n_ranges = 0;
        gint           copies;
        EvPrintPageSet page_set;
        gint           n_ranges = 0;
        gint           copies;

+       gint           pages_per_sheet;

        gboolean       collate;
        gboolean       reverse;
        gdouble        scale;
        gboolean       collate;
        gboolean       reverse;
        gdouble        scale;


@@ -1990,13 +2220,15 @@ ev_window_print_dialog_response_cb (GtkDialog *dialog,
        GtkPrintPages  print_pages;
        const gchar   *file_format;
        
        GtkPrintPages  print_pages;
        const gchar   *file_format;
        

-       if (response != GTK_RESPONSE_OK) {
+       if (response == GTK_RESPONSE_CANCEL) {

                gtk_widget_destroy (GTK_WIDGET (dialog));
                window->priv->print_dialog = NULL;
 
                return FALSE;
        }
 
                gtk_widget_destroy (GTK_WIDGET (dialog));
                window->priv->print_dialog = NULL;
 
                return FALSE;
        }
 

+       window->priv->print_preview = (response == GTK_RESPONSE_APPLY);
+

        if (window->priv->printer)
                g_object_unref (window->priv->printer);
        if (window->priv->print_settings)
        if (window->priv->printer)
                g_object_unref (window->priv->printer);
        if (window->priv->print_settings)


@@ -2052,7 +2284,17 @@ ev_window_print_dialog_response_cb (GtkDialog *dialog,
                        ranges = g_memdup (page_range, n_ranges * sizeof (GtkPageRange));
        }
                break;
                        ranges = g_memdup (page_range, n_ranges * sizeof (GtkPageRange));
        }
                break;

-       default:
+       case GTK_PRINT_PAGES_ALL: {
+               gint n_pages;
+
+               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;
+       }

                break;
        }
 
                break;
        }
 


@@ -2061,15 +2303,17 @@ ev_window_print_dialog_response_cb (GtkDialog *dialog,
        scale = gtk_print_settings_get_scale (window->priv->print_settings) * 0.01;
        
        width = gtk_page_setup_get_paper_width (window->priv->print_page_setup,
        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_PIXEL);
+                                               GTK_UNIT_POINTS);

        height = gtk_page_setup_get_paper_height (window->priv->print_page_setup,
        height = gtk_page_setup_get_paper_height (window->priv->print_page_setup,

-                                                 GTK_UNIT_PIXEL);
-
+                                                 GTK_UNIT_POINTS);
+       

        if (scale != 1.0) {
                width *= scale;
                height *= scale;
        }
 
        if (scale != 1.0) {
                width *= scale;
                height *= scale;
        }
 

+       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);
        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);


@@ -2079,6 +2323,7 @@ ev_window_print_dialog_response_cb (GtkDialog *dialog,
                                                    width, height,
                                                    ranges, n_ranges,
                                                    page_set,
                                                    width, height,
                                                    ranges, n_ranges,
                                                    page_set,

+                                                   pages_per_sheet,

                                                    copies, collate,
                                                    reverse);
        
                                                    copies, collate,
                                                    reverse);
        


@@ -2115,8 +2360,11 @@ ev_window_print_range (EvWindow *ev_window, int first_page, int last_page)
        current_page = ev_page_cache_get_current_page (page_cache);
        document_last_page = ev_page_cache_get_n_pages (page_cache);
 
        current_page = ev_page_cache_get_current_page (page_cache);
        document_last_page = ev_page_cache_get_n_pages (page_cache);
 

-       if (!ev_window->priv->print_settings)
-               ev_window->priv->print_settings = gtk_print_settings_new ();
+       if (!ev_window->priv->print_settings) {
+               ev_window->priv->print_settings = gtk_print_settings_copy (
+                       ev_application_get_print_settings (EV_APP));
+               ev_window_load_print_settings_from_metadata (ev_window);
+       }

 
        if (first_page != 1 || last_page != document_last_page) {
                GtkPageRange range;
 
        if (first_page != 1 || last_page != document_last_page) {
                GtkPageRange range;


@@ -2134,19 +2382,8 @@ ev_window_print_range (EvWindow *ev_window, int first_page, int last_page)
        dialog = gtk_print_unix_dialog_new (_("Print"), GTK_WINDOW (ev_window));
        ev_window->priv->print_dialog = dialog;
        
        dialog = gtk_print_unix_dialog_new (_("Print"), GTK_WINDOW (ev_window));
        ev_window->priv->print_dialog = dialog;
        

-       capabilities = GTK_PRINT_CAPABILITY_PAGE_SET |
-               GTK_PRINT_CAPABILITY_COPIES |
-               GTK_PRINT_CAPABILITY_COLLATE |
-               GTK_PRINT_CAPABILITY_REVERSE |
-               GTK_PRINT_CAPABILITY_SCALE |
-               GTK_PRINT_CAPABILITY_GENERATE_PS;
-       
-       if (EV_IS_FILE_EXPORTER (ev_window->priv->document) &&
-           ev_file_exporter_format_supported (EV_FILE_EXPORTER (ev_window->priv->document),
-                                              EV_FILE_FORMAT_PDF)) {
-               capabilities |= GTK_PRINT_CAPABILITY_GENERATE_PDF;
-       }
-       
+       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_manual_capabilities (GTK_PRINT_UNIX_DIALOG (dialog),
                                                       capabilities);
 


@@ -2166,124 +2403,6 @@ ev_window_print_range (EvWindow *ev_window, int first_page, int last_page)
 
        gtk_widget_show (dialog);
 }
 
        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);
-
-       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);
-}
-#endif /* WITH_GNOME_PRINT */

 
 static void
 ev_window_print (EvWindow *window)
 
 static void
 ev_window_print (EvWindow *window)


@@ -2294,9 +2413,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


@@ -2313,7 +2430,7 @@ ev_window_cmd_file_properties (GtkAction *action, EvWindow *ev_window)
                ev_properties_dialog_set_document (EV_PROPERTIES_DIALOG (ev_window->priv->properties),
                                                   ev_window->priv->document);
                g_object_add_weak_pointer (G_OBJECT (ev_window->priv->properties),
                ev_properties_dialog_set_document (EV_PROPERTIES_DIALOG (ev_window->priv->properties),
                                                   ev_window->priv->document);
                g_object_add_weak_pointer (G_OBJECT (ev_window->priv->properties),

-                                          (gpointer *) &(ev_window->priv->properties));
+                                          (gpointer) &(ev_window->priv->properties));

                gtk_window_set_transient_for (GTK_WINDOW (ev_window->priv->properties),
                                              GTK_WINDOW (ev_window));
        }
                gtk_window_set_transient_for (GTK_WINDOW (ev_window->priv->properties),
                                              GTK_WINDOW (ev_window));
        }


@@ -2338,6 +2455,7 @@ ev_window_cmd_focus_page_selector (GtkAction *act, EvWindow *window)
        
        update_chrome_flag (window, EV_CHROME_RAISE_TOOLBAR, TRUE);
        ev_window_set_action_sensitive (window, "ViewToolbar", FALSE);
        
        update_chrome_flag (window, EV_CHROME_RAISE_TOOLBAR, TRUE);
        ev_window_set_action_sensitive (window, "ViewToolbar", FALSE);

+       update_chrome_visibility (window);

        
        action = gtk_action_group_get_action (window->priv->action_group,
                                              PAGE_SELECTOR_ACTION);
        
        action = gtk_action_group_get_action (window->priv->action_group,
                                              PAGE_SELECTOR_ACTION);


@@ -2428,6 +2546,7 @@ ev_window_cmd_edit_find (GtkAction *action, EvWindow *ev_window)
        } 
 
        update_chrome_flag (ev_window, EV_CHROME_FINDBAR, TRUE);
        } 
 
        update_chrome_flag (ev_window, EV_CHROME_FINDBAR, TRUE);

+       update_chrome_visibility (ev_window);

        gtk_widget_grab_focus (ev_window->priv->find_bar);
 }
 
        gtk_widget_grab_focus (ev_window->priv->find_bar);
 }
 


@@ -2436,6 +2555,9 @@ ev_window_cmd_edit_find_next (GtkAction *action, EvWindow *ev_window)
 {
         g_return_if_fail (EV_IS_WINDOW (ev_window));
 
 {
         g_return_if_fail (EV_IS_WINDOW (ev_window));
 

+       update_chrome_flag (ev_window, EV_CHROME_FINDBAR, TRUE);
+       update_chrome_visibility (ev_window);
+       gtk_widget_grab_focus (ev_window->priv->find_bar);

        ev_view_find_next (EV_VIEW (ev_window->priv->view));
 }
 
        ev_view_find_next (EV_VIEW (ev_window->priv->view));
 }
 


@@ -2444,6 +2566,9 @@ ev_window_cmd_edit_find_previous (GtkAction *action, EvWindow *ev_window)
 {
         g_return_if_fail (EV_IS_WINDOW (ev_window));
 
 {
         g_return_if_fail (EV_IS_WINDOW (ev_window));
 

+       update_chrome_flag (ev_window, EV_CHROME_FINDBAR, TRUE);
+       update_chrome_visibility (ev_window);
+       gtk_widget_grab_focus (ev_window->priv->find_bar);

        ev_view_find_previous (EV_VIEW (ev_window->priv->view));
 }
 
        ev_view_find_previous (EV_VIEW (ev_window->priv->view));
 }
 


@@ -2455,60 +2580,6 @@ ev_window_cmd_edit_copy (GtkAction *action, EvWindow *ev_window)
        ev_view_copy (EV_VIEW (ev_window->priv->view));
 }
 
        ev_view_copy (EV_VIEW (ev_window->priv->view));
 }
 

-static void
-ev_window_update_fullscreen_popup (EvWindow *window)
-{
-       GtkWidget *popup = window->priv->fullscreen_popup;
-       int popup_width, popup_height;
-       GdkScreen *screen;
-       GdkRectangle screen_rect;
-       gboolean toolbar;
-
-       g_return_if_fail (popup != NULL);
-
-       if (GTK_WIDGET (window)->window == NULL)
-               return;
-
-       toolbar = (window->priv->chrome & EV_CHROME_FULLSCREEN_TOOLBAR) != 0 || 
-                 (window->priv->chrome & EV_CHROME_RAISE_TOOLBAR) != 0;
-       popup_width = popup->requisition.width;
-       popup_height = popup->requisition.height;
-
-       screen = gtk_widget_get_screen (GTK_WIDGET (window));
-       gdk_screen_get_monitor_geometry (screen,
-                       gdk_screen_get_monitor_at_window
-                        (screen,
-                         GTK_WIDGET (window)->window),
-                         &screen_rect);
-       if (toolbar) {
-               gtk_widget_set_size_request (popup,
-                                            screen_rect.width,
-                                            -1);
-               gtk_window_move (GTK_WINDOW (popup),
-                                screen_rect.x,
-                                screen_rect.y);
-
-       } else {
-               if (gtk_widget_get_direction (popup) == GTK_TEXT_DIR_RTL)
-               {
-                       gtk_window_move (GTK_WINDOW (popup),
-                                        screen_rect.x,
-                                        screen_rect.y);
-               } else {
-                       gtk_window_move (GTK_WINDOW (popup),
-                                        screen_rect.x + screen_rect.width - popup_width,
-                                        screen_rect.y);
-               }
-       }
-}
-
-static void
-screen_size_changed_cb (GdkScreen *screen,
-                       EvWindow *window)
-{
-       ev_window_update_fullscreen_popup (window);
-}
-

 static void
 ev_window_sidebar_position_change_cb (GObject *object, GParamSpec *pspec,
                                      EvWindow *ev_window)
 static void
 ev_window_sidebar_position_change_cb (GObject *object, GParamSpec *pspec,
                                      EvWindow *ev_window)


@@ -2519,187 +2590,77 @@ ev_window_sidebar_position_change_cb (GObject *object, GParamSpec *pspec,
 }
 
 static void
 }
 
 static void

-destroy_fullscreen_popup (EvWindow *window)
-{
-       if (window->priv->fullscreen_popup != NULL)
-       {
-               gtk_widget_destroy (window->priv->fullscreen_popup);
-               window->priv->fullscreen_popup = NULL;
-       }
-}
-
-static void
-exit_fullscreen_button_clicked_cb (GtkWidget *button, EvWindow *window)
+ev_window_update_fullscreen_action (EvWindow *window)

 {
        GtkAction *action;
 
        action = gtk_action_group_get_action (window->priv->action_group, "ViewFullscreen");
 {
        GtkAction *action;
 
        action = gtk_action_group_get_action (window->priv->action_group, "ViewFullscreen");

-       g_return_if_fail (action != NULL);
-
-       gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), FALSE);
+       g_signal_handlers_block_by_func
+               (action, G_CALLBACK (ev_window_cmd_view_fullscreen), window);
+       gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
+                                     ev_view_get_fullscreen (EV_VIEW (window->priv->view)));
+       g_signal_handlers_unblock_by_func
+               (action, G_CALLBACK (ev_window_cmd_view_fullscreen), window);

 }
 
 static void
 }
 
 static void

-fullscreen_popup_size_request_cb (GtkWidget *popup, GtkRequisition *req, EvWindow *window)
+fullscreen_toolbar_setup_item_properties (GtkUIManager *ui_manager)

 {
 {

-       ev_window_update_fullscreen_popup (window);
-}
-
-static gboolean
-fullscreen_timeout_cb (EvWindow *window)
-{
-       EvView *view = EV_VIEW (window->priv->view);
+       GtkWidget *item;

 
 

-       if (!view ||
-           (!ev_view_get_fullscreen (EV_VIEW (view)) &&
-            !ev_view_get_presentation (EV_VIEW (view))))
-               return FALSE;
+       item = gtk_ui_manager_get_widget (ui_manager, "/FullscreenToolbar/GoPreviousPage");
+       g_object_set (item, "is-important", FALSE, NULL);

 
 

-       update_chrome_flag (window, EV_CHROME_FULLSCREEN_TOOLBAR, FALSE);
-       ev_view_hide_cursor (EV_VIEW (window->priv->view));
-       window->priv->fullscreen_timeout_id = 0;
+       item = gtk_ui_manager_get_widget (ui_manager, "/FullscreenToolbar/GoNextPage");
+       g_object_set (item, "is-important", FALSE, NULL);

 
 

-       return FALSE;
-}
-
-static void
-fullscreen_set_timeout (EvWindow *window)
-{
-       if (window->priv->fullscreen_timeout_id != 0) {
-               g_source_remove (window->priv->fullscreen_timeout_id);
-       }
+       item = gtk_ui_manager_get_widget (ui_manager, "/FullscreenToolbar/StartPresentation");
+       g_object_set (item, "is-important", TRUE, NULL);

        
        

-       window->priv->fullscreen_timeout_id = 
-           g_timeout_add (FULLSCREEN_TIMEOUT, (GSourceFunc)fullscreen_timeout_cb, window);
-
-       update_chrome_flag (window, EV_CHROME_FULLSCREEN_TOOLBAR, TRUE);
-       update_chrome_visibility (window);
-       ev_view_show_cursor (EV_VIEW (window->priv->view));
+       item = gtk_ui_manager_get_widget (ui_manager, "/FullscreenToolbar/LeaveFullscreen");
+       g_object_set (item, "is-important", TRUE, NULL);

 }
 
 static void
 }
 
 static void

-fullscreen_clear_timeout (EvWindow *window)
+fullscreen_toolbar_remove_shadow (GtkWidget *toolbar)

 {
 {

-       if (window->priv->fullscreen_timeout_id != 0) {
-               g_source_remove (window->priv->fullscreen_timeout_id);
+       static gboolean done = FALSE;
+
+       if (!done) {
+               gtk_rc_parse_string (
+                       "\n"
+                       "   style \"fullscreen-toolbar-style\"\n"
+                       "   {\n"
+                       "      GtkToolbar::shadow-type=GTK_SHADOW_NONE\n"
+                       "   }\n"
+                       "\n"
+                       "    widget \"*.fullscreen-toolbar\" style \"fullscreen-toolbar-style\"\n"
+                       "\n");
+               done = TRUE;

        }
        
        }
        

-       window->priv->fullscreen_timeout_id = 0;
-       update_chrome_visibility (window);
-       ev_view_show_cursor (EV_VIEW (window->priv->view));
+       gtk_widget_set_name (toolbar, "fullscreen-toolbar");

 }
 
 }
 

-
-static gboolean
-fullscreen_motion_notify_cb (GtkWidget *widget,
-                            GdkEventMotion *event,
-                            gpointer user_data)
-{
-       EvWindow *window = EV_WINDOW (user_data);
-
-       fullscreen_set_timeout (window);
-
-       return FALSE;
-}
-
-static gboolean
-fullscreen_leave_notify_cb (GtkWidget *widget,
-                           GdkEventCrossing *event,
-                           gpointer user_data)
-{
-       EvWindow *window = EV_WINDOW (user_data);
-
-       fullscreen_clear_timeout (window);
-
-       return FALSE;
-}
-
-static GtkWidget *
-ev_window_get_exit_fullscreen_button (EvWindow *window)
-{
-       GtkWidget *button, *icon, *label, *hbox;
-
-       button = gtk_button_new ();
-       g_signal_connect (button, "clicked",
-                         G_CALLBACK (exit_fullscreen_button_clicked_cb),
-                         window);
-       gtk_widget_show (button);
-
-       hbox = gtk_hbox_new (FALSE, 2);
-       gtk_widget_show (hbox);
-       gtk_container_add (GTK_CONTAINER (button), hbox);
-
-       icon = gtk_image_new_from_stock (EV_STOCK_LEAVE_FULLSCREEN, GTK_ICON_SIZE_BUTTON);
-       gtk_widget_show (icon);
-       gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);
-
-       label = gtk_label_new (_("Leave Fullscreen"));
-       gtk_widget_show (label);
-       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
-
-       return button;
-}
-
-static GtkWidget *
-ev_window_create_fullscreen_popup (EvWindow *window)
-{
-       GtkWidget *popup;
-       GtkWidget *hbox;
-       GtkWidget *button;
-       GdkScreen *screen;
-
-       window->priv->fullscreen_toolbar = egg_editable_toolbar_new_with_model
-                       (window->priv->ui_manager, ev_application_get_toolbars_model (EV_APP, FALSE), NULL);
-
-       popup = gtk_window_new (GTK_WINDOW_POPUP);
-       hbox = gtk_hbox_new (FALSE, 0);
-       button = ev_window_get_exit_fullscreen_button (window);
-
-       gtk_container_add (GTK_CONTAINER (popup), hbox);
-       gtk_box_pack_start (GTK_BOX (hbox), window->priv->fullscreen_toolbar,
-                           TRUE, TRUE, 0);
-       gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
-
-       gtk_widget_show (button);
-       gtk_widget_show (hbox);
-
-       gtk_window_set_resizable (GTK_WINDOW (popup), FALSE);
-
-       screen = gtk_widget_get_screen (GTK_WIDGET (window));
-       g_signal_connect_object (screen, "size-changed",
-                                G_CALLBACK (screen_size_changed_cb),
-                                window, 0);
-       g_signal_connect_object (popup, "size_request",
-                                G_CALLBACK (fullscreen_popup_size_request_cb),
-                                window, 0);
-
-       gtk_window_set_screen (GTK_WINDOW (popup),
-                              gtk_widget_get_screen (GTK_WIDGET (window)));
-
-       return popup;
-}
-
-

 static void
 static void

-ev_window_update_fullscreen_action (EvWindow *window)
+ev_window_run_fullscreen (EvWindow *window)

 {
 {

-       GtkAction *action;
+       if (!window->priv->fullscreen_toolbar) {
+               window->priv->fullscreen_toolbar =
+                       gtk_ui_manager_get_widget (window->priv->ui_manager,
+                                                  "/FullscreenToolbar");

 
 

-       action = gtk_action_group_get_action (window->priv->action_group, "ViewFullscreen");
-       g_signal_handlers_block_by_func
-               (action, G_CALLBACK (ev_window_cmd_view_fullscreen), window);
-       gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
-                                     ev_view_get_fullscreen (EV_VIEW (window->priv->view)));
-       g_signal_handlers_unblock_by_func
-               (action, G_CALLBACK (ev_window_cmd_view_fullscreen), window);
-}
+               gtk_toolbar_set_style (GTK_TOOLBAR (window->priv->fullscreen_toolbar),
+                                      GTK_TOOLBAR_BOTH_HORIZ);
+               fullscreen_toolbar_remove_shadow (window->priv->fullscreen_toolbar);
+               fullscreen_toolbar_setup_item_properties (window->priv->ui_manager);

 
 

-static void
-ev_window_run_fullscreen (EvWindow *window)
-{
-       if (window->priv->fullscreen_popup == NULL)
-               window->priv->fullscreen_popup
-                       = ev_window_create_fullscreen_popup (window);
+               gtk_box_pack_start (GTK_BOX (window->priv->main_box),
+                                   window->priv->fullscreen_toolbar,
+                                   FALSE, FALSE, 0);
+               gtk_box_reorder_child (GTK_BOX (window->priv->main_box),
+                                      window->priv->fullscreen_toolbar, 1);
+       }

 
        g_object_set (G_OBJECT (window->priv->scrolled_window),
                      "shadow-type", GTK_SHADOW_NONE,
 
        g_object_set (G_OBJECT (window->priv->scrolled_window),
                      "shadow-type", GTK_SHADOW_NONE,


@@ -2707,20 +2668,16 @@ ev_window_run_fullscreen (EvWindow *window)
 
        ev_view_set_fullscreen (EV_VIEW (window->priv->view), TRUE);
        ev_window_update_fullscreen_action (window);
 
        ev_view_set_fullscreen (EV_VIEW (window->priv->view), TRUE);
        ev_window_update_fullscreen_action (window);

+
+       /* If the user doesn't have the main toolbar he/she won't probably want
+        * the toolbar in fullscreen mode. See bug #483048
+        */
+       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));
        gtk_widget_grab_focus (window->priv->view);
        
        gtk_window_fullscreen (GTK_WINDOW (window));
        gtk_widget_grab_focus (window->priv->view);

-       ev_window_update_fullscreen_popup (window);
-
-       g_signal_connect (window->priv->view,
-                         "motion-notify-event",
-                         G_CALLBACK (fullscreen_motion_notify_cb),
-                         window);
-       g_signal_connect (window->priv->view,
-                         "leave-notify-event",
-                         G_CALLBACK (fullscreen_leave_notify_cb),
-                         window);
-       fullscreen_set_timeout (window);

 
        if (!ev_window_is_empty (window))
                ev_metadata_manager_set_boolean (window->priv->uri, "fullscreen", TRUE);
 
        if (!ev_window_is_empty (window))
                ev_metadata_manager_set_boolean (window->priv->uri, "fullscreen", TRUE);


@@ -2740,16 +2697,10 @@ ev_window_stop_fullscreen (EvWindow *window)
 
        ev_view_set_fullscreen (view, FALSE);
        ev_window_update_fullscreen_action (window);
 
        ev_view_set_fullscreen (view, FALSE);
        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));
 
        gtk_window_unfullscreen (GTK_WINDOW (window));
 

-       g_signal_handlers_disconnect_by_func (window->priv->view,
-                                             (gpointer) fullscreen_motion_notify_cb,
-                                             window);
-       g_signal_handlers_disconnect_by_func (window->priv->view,
-                                             (gpointer) fullscreen_leave_notify_cb,
-                                             window);
-       fullscreen_clear_timeout (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);
 }


@@ -2770,6 +2721,70 @@ ev_window_cmd_view_fullscreen (GtkAction *action, EvWindow *window)
        }
 }
 
        }
 }
 

+static gboolean
+presentation_timeout_cb (EvWindow *window)
+{
+       EvView *view = EV_VIEW (window->priv->view);
+
+       if (!view || !ev_view_get_presentation (EV_VIEW (view)))
+               return FALSE;
+
+       ev_view_hide_cursor (EV_VIEW (window->priv->view));
+       window->priv->presentation_timeout_id = 0;
+
+       return FALSE;
+}
+
+static void
+presentation_set_timeout (EvWindow *window)
+{
+       if (window->priv->presentation_timeout_id > 0) {
+               g_source_remove (window->priv->presentation_timeout_id);
+       }
+
+       window->priv->presentation_timeout_id =
+               g_timeout_add_seconds (PRESENTATION_TIMEOUT,
+                                      (GSourceFunc)presentation_timeout_cb, window);
+
+       ev_view_show_cursor (EV_VIEW (window->priv->view));
+}
+
+static void
+presentation_clear_timeout (EvWindow *window)
+{
+       if (window->priv->presentation_timeout_id > 0) {
+               g_source_remove (window->priv->presentation_timeout_id);
+       }
+       
+       window->priv->presentation_timeout_id = 0;
+
+       ev_view_show_cursor (EV_VIEW (window->priv->view));
+}
+
+static gboolean
+presentation_motion_notify_cb (GtkWidget *widget,
+                              GdkEventMotion *event,
+                              gpointer user_data)
+{
+       EvWindow *window = EV_WINDOW (user_data);
+
+       presentation_set_timeout (window);
+
+       return FALSE;
+}
+
+static gboolean
+presentation_leave_notify_cb (GtkWidget *widget,
+                             GdkEventCrossing *event,
+                             gpointer user_data)
+{
+       EvWindow *window = EV_WINDOW (user_data);
+
+       presentation_clear_timeout (window);
+
+       return FALSE;
+}
+

 static void
 ev_window_update_presentation_action (EvWindow *window)
 {
 static void
 ev_window_update_presentation_action (EvWindow *window)
 {


@@ -2794,18 +2809,20 @@ ev_window_run_presentation (EvWindow *window)
        ev_view_set_presentation (EV_VIEW (window->priv->view), TRUE);
        ev_window_update_presentation_action (window);
 
        ev_view_set_presentation (EV_VIEW (window->priv->view), TRUE);
        ev_window_update_presentation_action (window);
 

+       update_chrome_visibility (window);
+       

        gtk_widget_grab_focus (window->priv->view);
        gtk_window_fullscreen (GTK_WINDOW (window));
 
        g_signal_connect (window->priv->view,
                          "motion-notify-event",
        gtk_widget_grab_focus (window->priv->view);
        gtk_window_fullscreen (GTK_WINDOW (window));
 
        g_signal_connect (window->priv->view,
                          "motion-notify-event",

-                         G_CALLBACK (fullscreen_motion_notify_cb),
+                         G_CALLBACK (presentation_motion_notify_cb),

                          window);
        g_signal_connect (window->priv->view,
                          "leave-notify-event",
                          window);
        g_signal_connect (window->priv->view,
                          "leave-notify-event",

-                         G_CALLBACK (fullscreen_leave_notify_cb),
+                         G_CALLBACK (presentation_leave_notify_cb),

                          window);
                          window);

-       fullscreen_set_timeout (window);
+       presentation_set_timeout (window);

 
        ev_application_screensaver_disable (EV_APP);
        
 
        ev_application_screensaver_disable (EV_APP);
        


@@ -2825,15 +2842,16 @@ ev_window_stop_presentation (EvWindow *window)
 
        ev_view_set_presentation (EV_VIEW (window->priv->view), FALSE);
        ev_window_update_presentation_action (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));
 
        g_signal_handlers_disconnect_by_func (window->priv->view,
        gtk_window_unfullscreen (GTK_WINDOW (window));
 
        g_signal_handlers_disconnect_by_func (window->priv->view,

-                                             (gpointer) fullscreen_motion_notify_cb,
+                                             (gpointer) presentation_motion_notify_cb,

                                              window);
        g_signal_handlers_disconnect_by_func (window->priv->view,
                                              window);
        g_signal_handlers_disconnect_by_func (window->priv->view,

-                                             (gpointer) fullscreen_leave_notify_cb,
+                                             (gpointer) presentation_leave_notify_cb,

                                              window);
                                              window);

-       fullscreen_clear_timeout (window);
+       presentation_clear_timeout (window);

 
        ev_application_screensaver_enable (EV_APP);
 
 
        ev_application_screensaver_enable (EV_APP);
 


@@ -2846,7 +2864,7 @@ ev_window_cmd_view_presentation (GtkAction *action, EvWindow *window)
 {
        gboolean presentation;
 
 {
        gboolean presentation;
 

-        g_return_if_fail (EV_IS_WINDOW (window));
+       g_return_if_fail (EV_IS_WINDOW (window));

        ev_window_stop_fullscreen (window);
 
        presentation = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
        ev_window_stop_fullscreen (window);
 
        presentation = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));


@@ -2860,6 +2878,20 @@ ev_window_cmd_view_presentation (GtkAction *action, EvWindow *window)
 static void
 ev_window_run_preview (EvWindow *window)
 {
 static void
 ev_window_run_preview (EvWindow *window)
 {

+       GtkAction *action;
+       
+       if (!window->priv->preview_toolbar) {
+               window->priv->preview_toolbar =
+                       gtk_ui_manager_get_widget (window->priv->ui_manager,
+                                                  "/PreviewToolbar");
+
+               gtk_box_pack_start (GTK_BOX (window->priv->main_box),
+                                   window->priv->preview_toolbar,
+                                   FALSE, FALSE, 0);
+               gtk_box_reorder_child (GTK_BOX (window->priv->main_box),
+                                      window->priv->preview_toolbar, 1);
+       }
+       

        ev_view_set_continuous (EV_VIEW (window->priv->view), FALSE); 
        
        update_chrome_flag (window, EV_CHROME_TOOLBAR, FALSE);
        ev_view_set_continuous (EV_VIEW (window->priv->view), FALSE); 
        
        update_chrome_flag (window, EV_CHROME_TOOLBAR, FALSE);


@@ -2867,36 +2899,18 @@ ev_window_run_preview (EvWindow *window)
        update_chrome_flag (window, EV_CHROME_SIDEBAR, FALSE);
 
        update_chrome_flag (window, EV_CHROME_PREVIEW_TOOLBAR, TRUE);
        update_chrome_flag (window, EV_CHROME_SIDEBAR, FALSE);
 
        update_chrome_flag (window, EV_CHROME_PREVIEW_TOOLBAR, TRUE);

+       
+       action = gtk_action_group_get_action (window->priv->action_group,
+                                             "PreviewPrint");
+#if GTK_CHECK_VERSION (2, 11, 0)
+       gtk_action_set_visible (action, TRUE);
+#else
+       gtk_action_set_visible (action, FALSE);
+#endif

 
        update_chrome_visibility (window);
 }
 
 
        update_chrome_visibility (window);
 }
 

-static gboolean
-ev_window_focus_in_event (GtkWidget *widget, GdkEventFocus *event)
-{
-       EvWindow *window = EV_WINDOW (widget);
-       EvWindowPrivate *priv = window->priv;
-
-       if (ev_view_get_fullscreen (EV_VIEW (priv->view)))
-               fullscreen_set_timeout (window);
-
-       return GTK_WIDGET_CLASS (ev_window_parent_class)->focus_in_event (widget, event);
-}
-
-static gboolean
-ev_window_focus_out_event (GtkWidget *widget, GdkEventFocus *event)
-{
-       EvWindow *window = EV_WINDOW (widget);
-       EvWindowPrivate *priv = window->priv;
-
-       if (ev_view_get_fullscreen (EV_VIEW (priv->view))) {
-               fullscreen_set_timeout (window);
-               gtk_widget_hide (priv->fullscreen_popup);
-       }
-
-       return GTK_WIDGET_CLASS (ev_window_parent_class)->focus_out_event (widget, event);
-}
-

 static void
 ev_window_screen_changed (GtkWidget *widget,
                          GdkScreen *old_screen)
 static void
 ev_window_screen_changed (GtkWidget *widget,
                          GdkScreen *old_screen)


@@ -2909,38 +2923,12 @@ ev_window_screen_changed (GtkWidget *widget,
        if (screen == old_screen)
                return;
 
        if (screen == old_screen)
                return;
 

-#ifdef HAVE_GTK_RECENT
-       if (old_screen) {
-               g_signal_handlers_disconnect_by_func (
-                       gtk_recent_manager_get_for_screen (old_screen),
-                       G_CALLBACK (ev_window_setup_recent), window);
-       }
-
-       priv->recent_manager = gtk_recent_manager_get_for_screen (screen);
-       g_signal_connect_swapped (priv->recent_manager,
-                                 "changed",
-                                 G_CALLBACK (ev_window_setup_recent),
-                                 window);
-#endif
-       
-       ev_view_set_screen_dpi (EV_VIEW (window->priv->view),
-                               ev_window_get_screen_dpi (window));
+       ev_view_set_screen_dpi (EV_VIEW (priv->view),
+                               get_screen_dpi (GTK_WINDOW (window)));

        
        if (GTK_WIDGET_CLASS (ev_window_parent_class)->screen_changed) {
                GTK_WIDGET_CLASS (ev_window_parent_class)->screen_changed (widget, old_screen);
        }
        
        if (GTK_WIDGET_CLASS (ev_window_parent_class)->screen_changed) {
                GTK_WIDGET_CLASS (ev_window_parent_class)->screen_changed (widget, old_screen);
        }

-
-       if (priv->fullscreen_popup != NULL) {
-               g_signal_handlers_disconnect_by_func
-                       (old_screen, G_CALLBACK (screen_size_changed_cb), window);
-
-               g_signal_connect_object (screen, "size-changed",
-                                        G_CALLBACK (screen_size_changed_cb),
-                                        window, 0);
-               gtk_window_set_screen (GTK_WINDOW (priv->fullscreen_popup), screen);
-
-               ev_window_update_fullscreen_popup (window);
-       }

 }
 
 static void
 }
 
 static void


@@ -3018,7 +3006,7 @@ ev_window_cmd_edit_toolbar (GtkAction *action, EvWindow *ev_window)
        gtk_window_set_default_size (GTK_WINDOW (dialog), 500, 400);
          
        editor = egg_toolbar_editor_new (ev_window->priv->ui_manager,
        gtk_window_set_default_size (GTK_WINDOW (dialog), 500, 400);
          
        editor = egg_toolbar_editor_new (ev_window->priv->ui_manager,

-                                        ev_application_get_toolbars_model (EV_APP, FALSE));
+                                        ev_application_get_toolbars_model (EV_APP));

        gtk_container_set_border_width (GTK_CONTAINER (editor), 5);
        gtk_box_set_spacing (GTK_BOX (EGG_TOOLBAR_EDITOR (editor)), 5);
              
        gtk_container_set_border_width (GTK_CONTAINER (editor), 5);
        gtk_box_set_spacing (GTK_BOX (EGG_TOOLBAR_EDITOR (editor)), 5);
              


@@ -3076,76 +3064,245 @@ ev_window_cmd_go_first_page (GtkAction *action, EvWindow *ev_window)
 }
 
 static void
 }
 
 static void

-ev_window_cmd_go_last_page (GtkAction *action, EvWindow *ev_window)
+ev_window_cmd_go_last_page (GtkAction *action, EvWindow *ev_window)
+{
+       int n_pages;
+
+        g_return_if_fail (EV_IS_WINDOW (ev_window));
+
+       n_pages = ev_page_cache_get_n_pages (ev_window->priv->page_cache);
+       ev_page_cache_set_current_page (ev_window->priv->page_cache, n_pages - 1);
+}
+
+static void
+ev_window_cmd_go_forward (GtkAction *action, EvWindow *ev_window)
+{
+       int n_pages, current_page;
+       
+        g_return_if_fail (EV_IS_WINDOW (ev_window));
+
+       n_pages = ev_page_cache_get_n_pages (ev_window->priv->page_cache);
+       current_page = ev_page_cache_get_current_page (ev_window->priv->page_cache);
+       
+       if (current_page + 10 < n_pages)
+               ev_page_cache_set_current_page (ev_window->priv->page_cache, current_page + 10);
+}
+
+static void
+ev_window_cmd_go_backward (GtkAction *action, EvWindow *ev_window)
+{
+       int current_page;
+       
+        g_return_if_fail (EV_IS_WINDOW (ev_window));
+
+       current_page = ev_page_cache_get_current_page (ev_window->priv->page_cache);
+       
+       if (current_page - 10 >= 0)
+               ev_page_cache_set_current_page (ev_window->priv->page_cache, current_page - 10);
+}
+
+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);
+}
+
+static void
+ev_window_cmd_view_autoscroll (GtkAction *action, EvWindow *ev_window)
+{
+       ev_view_autoscroll_start (EV_VIEW (ev_window->priv->view));
+}
+
+static void
+ev_window_cmd_help_contents (GtkAction *action, EvWindow *ev_window)
+{
+       GError *error = NULL;
+       GdkScreen *screen;
+       char *command;
+       const char *lang;
+       char *uri = NULL;
+
+       int i;
+
+       const char * const * langs = g_get_language_names ();
+
+       for (i = 0; langs[i]; i++) {
+               lang = langs[i];
+               if (strchr (lang, '.')) {
+                       continue;
+               }
+
+               uri = g_build_filename(GNOMEDATADIR,
+                                      "/gnome/help/" PACKAGE,
+                                      lang,
+                                      "/evince.xml",
+                                      NULL);
+                                       
+               if (g_file_test (uri, G_FILE_TEST_EXISTS)) {
+                       break;
+               }
+               g_free (uri);
+               uri = NULL;
+       }
+
+       if (uri == NULL) {
+               g_warning ("Cannot find help");
+               return;
+       }
+       
+       command = g_strconcat ("gnome-help ghelp://", uri,  NULL);
+       g_free (uri);
+       
+       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_error_free (error);
+       }
+       g_free (command);
+}
+
+static void
+ev_window_cmd_leave_fullscreen (GtkAction *action, EvWindow *window)

 {
 {

-       int n_pages;
-
-        g_return_if_fail (EV_IS_WINDOW (ev_window));
-
-       n_pages = ev_page_cache_get_n_pages (ev_window->priv->page_cache);
-       ev_page_cache_set_current_page (ev_window->priv->page_cache, n_pages - 1);
+       ev_window_stop_fullscreen (window);

 }
 
 static void
 }
 
 static void

-ev_window_cmd_go_forward (GtkAction *action, EvWindow *ev_window)
+ev_window_cmd_start_presentation (GtkAction *action, EvWindow *window)

 {
 {

-       int n_pages, current_page;
-       
-        g_return_if_fail (EV_IS_WINDOW (ev_window));
-
-       n_pages = ev_page_cache_get_n_pages (ev_window->priv->page_cache);
-       current_page = ev_page_cache_get_current_page (ev_window->priv->page_cache);
-       
-       if (current_page + 10 < n_pages)
-               ev_page_cache_set_current_page (ev_window->priv->page_cache, current_page + 10);
+       ev_window_stop_fullscreen (window);
+       ev_window_run_presentation (window);

 }
 
 }
 

-static void
-ev_window_cmd_go_backward (GtkAction *action, EvWindow *ev_window)
+static gboolean
+ev_window_enumerate_printer_cb (GtkPrinter *printer,
+                               EvWindow   *window)

 {
 {

-       int current_page;
-       
-        g_return_if_fail (EV_IS_WINDOW (ev_window));
+       EvWindowPrivate *priv = window->priv;
+       const gchar *printer_name;

 
 

-       current_page = ev_page_cache_get_current_page (ev_window->priv->page_cache);
-       
-       if (current_page - 10 >= 0)
-               ev_page_cache_set_current_page (ev_window->priv->page_cache, current_page - 10);
+       printer_name = gtk_print_settings_get_printer (priv->print_settings);
+       if ((printer_name
+            && strcmp (printer_name, gtk_printer_get_name (printer)) == 0) ||
+           (!printer_name && gtk_printer_is_default (printer))) {
+               if (priv->printer)
+                       g_object_unref (priv->printer);
+               priv->printer = g_object_ref (printer);
+
+               /* Now that we have the printer, we'll start the print */
+               ev_window_do_preview_print (window);
+
+               return TRUE; /* we're done */
+       }
+
+       return FALSE; /* continue the enumeration */

 }
 
 static void
 }
 
 static void

-ev_window_cmd_view_reload (GtkAction *action, EvWindow *ev_window)
+ev_window_preview_print_finished (GtkPrintJob *print_job,
+                                 EvWindow    *window,
+                                 GError      *error)

 {
 {

-       char *uri;
-
-       g_return_if_fail (EV_IS_WINDOW (ev_window));
+       if (error) {
+               GtkWidget *dialog;

 
 

-       uri = g_strdup (ev_window->priv->uri);
+               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);

 
 

-       ev_window_open_uri (ev_window, uri, NULL, 0, FALSE);
+               gtk_dialog_run (GTK_DIALOG (dialog));
+               gtk_widget_destroy (dialog);
+       }

 
 

-       g_free (uri);
+       g_object_unref (print_job);
+       gtk_widget_destroy (GTK_WIDGET (window));

 }
 
 static void
 }
 
 static void

-ev_window_cmd_help_contents (GtkAction *action, EvWindow *ev_window)
+ev_window_do_preview_print (EvWindow *window)

 {
 {

-       GError *error = NULL;
+       EvWindowPrivate  *priv = window->priv;
+       GtkPageSetup     *page_setup;
+       GtkPrintJob      *job;
+       gchar            *filename;
+       GError           *error = NULL;

 
 

-        g_return_if_fail (EV_IS_WINDOW (ev_window));
+       g_assert (priv->print_settings != NULL);
+       g_assert (priv->printer != NULL);

 
 

-       gnome_help_display ("evince.xml", NULL, &error);
+       page_setup = gtk_page_setup_new ();

 
 

-       if(error != NULL) {
+       job = gtk_print_job_new ("evince-print",
+                                priv->printer,
+                                priv->print_settings,
+                                page_setup);
+
+       g_object_unref (priv->print_settings);
+       priv->print_settings = 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,
+                                       NULL, NULL);
+
+       if (gtk_print_job_set_source_file (job, filename, &error)) {
+               gtk_print_job_send (job,
+                                   (GtkPrintJobCompleteFunc)ev_window_preview_print_finished,
+                                   window, NULL);
+       } else {

                g_warning (error->message);
                g_error_free (error);
        }
                g_warning (error->message);
                g_error_free (error);
        }

+
+       g_free (filename);
+
+       gtk_widget_hide (GTK_WIDGET (window));

 }
 
 static void
 }
 
 static void

-ev_window_cmd_leave_fullscreen (GtkAction *action, EvWindow *window)
+ev_window_cmd_preview_print (GtkAction *action, EvWindow *window)

 {
 {

-       gtk_window_unfullscreen (GTK_WINDOW (window));
+       EvWindowPrivate *priv = window->priv;
+       GtkPrintSettings *print_settings = NULL;
+#if GTK_CHECK_VERSION (2, 11, 0)
+       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 (error) {
+                               g_warning (error->message);
+                               g_error_free (error);
+                               print_settings = NULL;
+                       }
+               }
+       }
+#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;
+
+       gtk_enumerate_printers ((GtkPrinterFunc) ev_window_enumerate_printer_cb,
+                               window, NULL, FALSE);

 }
 
 static void
 }
 
 static void


@@ -3153,9 +3310,12 @@ ev_window_cmd_escape (GtkAction *action, EvWindow *window)
 {
        GtkWidget *widget;
 
 {
        GtkWidget *widget;
 

+       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)) {
                update_chrome_flag (window, EV_CHROME_FINDBAR, FALSE);
        widget = gtk_window_get_focus (GTK_WINDOW (window));
        if (widget && gtk_widget_get_ancestor (widget, EGG_TYPE_FIND_BAR)) {
                update_chrome_flag (window, EV_CHROME_FINDBAR, FALSE);

+               update_chrome_visibility (window);

                gtk_widget_grab_focus (window->priv->view);
        } else {
                gboolean fullscreen;
                gtk_widget_grab_focus (window->priv->view);
        } else {
                gboolean fullscreen;


@@ -3180,38 +3340,6 @@ ev_window_cmd_escape (GtkAction *action, EvWindow *window)
        }
 }
 
        }
 }
 

-static void
-update_view_size (EvView *view, EvWindow *window)
-{
-       int width, height;
-       GtkRequisition vsb_requisition;
-       GtkRequisition hsb_requisition;
-       int scrollbar_spacing;
-
-       /* Calculate the width available for the */
-       width = window->priv->scrolled_window->allocation.width;
-       height = window->priv->scrolled_window->allocation.height;
-
-       if (gtk_scrolled_window_get_shadow_type (GTK_SCROLLED_WINDOW (window->priv->scrolled_window)) == GTK_SHADOW_IN) {
-               width -= 2 * window->priv->view->style->xthickness;
-               height -= 2 * window->priv->view->style->ythickness;
-       }
-
-       gtk_widget_size_request (GTK_SCROLLED_WINDOW (window->priv->scrolled_window)->vscrollbar,
-                                &vsb_requisition);
-       gtk_widget_size_request (GTK_SCROLLED_WINDOW (window->priv->scrolled_window)->hscrollbar,
-                                &hsb_requisition);
-       gtk_widget_style_get (window->priv->scrolled_window,
-                             "scrollbar_spacing", &scrollbar_spacing,
-                             NULL);
-
-       ev_view_set_zoom_for_size (EV_VIEW (window->priv->view),
-                                  MAX (1, width),
-                                  MAX (1, height),
-                                  vsb_requisition.width + scrollbar_spacing,
-                                  hsb_requisition.height + scrollbar_spacing);
-}
-

 static void
 save_sizing_mode (EvWindow *window)
 {
 static void
 save_sizing_mode (EvWindow *window)
 {


@@ -3239,10 +3367,11 @@ ev_window_sizing_mode_changed_cb (EvView *view, GParamSpec *pspec,
 
        scrolled_window = ev_window->priv->scrolled_window;
 
 
        scrolled_window = ev_window->priv->scrolled_window;
 

-       g_signal_handlers_disconnect_by_func (ev_window->priv->view, update_view_size, ev_window);
+       g_signal_handlers_disconnect_by_func (ev_window->priv->view, ev_view_update_view_size, scrolled_window);

 
        if (sizing_mode != EV_SIZING_FREE)
 
        if (sizing_mode != EV_SIZING_FREE)

-               update_view_size (NULL, ev_window);
+               ev_view_update_view_size (EV_VIEW (ev_window->priv->view),
+                                         GTK_SCROLLED_WINDOW (scrolled_window));

 
        switch (sizing_mode) {
                case EV_SIZING_BEST_FIT:
 
        switch (sizing_mode) {
                case EV_SIZING_BEST_FIT:


@@ -3251,8 +3380,8 @@ ev_window_sizing_mode_changed_cb (EvView *view, GParamSpec *pspec,
                                      "vscrollbar-policy", GTK_POLICY_AUTOMATIC,
                                      NULL);
                        g_signal_connect (ev_window->priv->view, "zoom_invalid",
                                      "vscrollbar-policy", GTK_POLICY_AUTOMATIC,
                                      NULL);
                        g_signal_connect (ev_window->priv->view, "zoom_invalid",

-                                         G_CALLBACK (update_view_size),
-                                         ev_window);
+                                         G_CALLBACK (ev_view_update_view_size),
+                                         scrolled_window);

                        break;
                case EV_SIZING_FIT_WIDTH:
                        g_object_set (G_OBJECT (scrolled_window),
                        break;
                case EV_SIZING_FIT_WIDTH:
                        g_object_set (G_OBJECT (scrolled_window),


@@ -3260,8 +3389,8 @@ ev_window_sizing_mode_changed_cb (EvView *view, GParamSpec *pspec,
                                      "vscrollbar-policy", GTK_POLICY_AUTOMATIC,
                                      NULL);
                        g_signal_connect (ev_window->priv->view, "zoom_invalid",
                                      "vscrollbar-policy", GTK_POLICY_AUTOMATIC,
                                      NULL);
                        g_signal_connect (ev_window->priv->view, "zoom_invalid",

-                                         G_CALLBACK (update_view_size),
-                                         ev_window);
+                                         G_CALLBACK (ev_view_update_view_size),
+                                         scrolled_window);

                        break;
                case EV_SIZING_FREE:
                        g_object_set (G_OBJECT (scrolled_window),
                        break;
                case EV_SIZING_FREE:
                        g_object_set (G_OBJECT (scrolled_window),


@@ -3284,7 +3413,7 @@ ev_window_zoom_changed_cb (EvView *view, GParamSpec *pspec, EvWindow *ev_window)
                gdouble zoom;
 
                zoom = ev_view_get_zoom (view);
                gdouble zoom;
 
                zoom = ev_view_get_zoom (view);

-               zoom *= 72.0 / ev_window_get_screen_dpi (ev_window);
+               zoom *= 72.0 / get_screen_dpi (GTK_WINDOW(ev_window));

                ev_metadata_manager_set_double (ev_window->priv->uri, "zoom", zoom);
        }
 }
                ev_metadata_manager_set_double (ev_window->priv->uri, "zoom", zoom);
        }
 }


@@ -3340,6 +3469,7 @@ ev_window_rotation_changed_cb (EvView *view, GParamSpec *pspec, EvWindow *window
 
        ev_sidebar_thumbnails_refresh (EV_SIDEBAR_THUMBNAILS (window->priv->sidebar_thumbs),
                                       rotation);
 
        ev_sidebar_thumbnails_refresh (EV_SIDEBAR_THUMBNAILS (window->priv->sidebar_thumbs),
                                       rotation);

+       ev_window_refresh_window_thumbnail (window, rotation);

 }
 
 static void
 }
 
 static void


@@ -3465,14 +3595,19 @@ ev_window_view_toolbar_cb (GtkAction *action, EvWindow *ev_window)
        
        active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
        update_chrome_flag (ev_window, EV_CHROME_TOOLBAR, active);
        
        active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
        update_chrome_flag (ev_window, EV_CHROME_TOOLBAR, active);

+       update_chrome_visibility (ev_window);

        ev_metadata_manager_set_boolean (NULL, "show_toolbar", active);
 }
 
 static void
 ev_window_view_sidebar_cb (GtkAction *action, EvWindow *ev_window)
 {
        ev_metadata_manager_set_boolean (NULL, "show_toolbar", active);
 }
 
 static void
 ev_window_view_sidebar_cb (GtkAction *action, EvWindow *ev_window)
 {

+       if (ev_view_get_presentation (EV_VIEW (ev_window->priv->view)))
+               return;
+           

        update_chrome_flag (ev_window, EV_CHROME_SIDEBAR,
                            gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)));
        update_chrome_flag (ev_window, EV_CHROME_SIDEBAR,
                            gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)));

+       update_chrome_visibility (ev_window);

 }
 
 static void
 }
 
 static void


@@ -3511,9 +3646,7 @@ ev_window_sidebar_visibility_changed_cb (EvSidebar  *ev_sidebar,
 
        action = gtk_action_group_get_action (ev_window->priv->action_group, "ViewSidebar");
 
 
        action = gtk_action_group_get_action (ev_window->priv->action_group, "ViewSidebar");
 

-       if (!ev_view_get_presentation (view) && 
-           !ev_view_get_fullscreen (view)) {
-
+       if (!ev_view_get_presentation (view)) {

                gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
                                              GTK_WIDGET_VISIBLE (ev_sidebar));
 
                gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
                                              GTK_WIDGET_VISIBLE (ev_sidebar));
 


@@ -3677,6 +3810,7 @@ find_bar_close_cb (EggFindBar *find_bar,
                   EvWindow   *ev_window)
 {
        update_chrome_flag (ev_window, EV_CHROME_FINDBAR, FALSE);
                   EvWindow   *ev_window)
 {
        update_chrome_flag (ev_window, EV_CHROME_FINDBAR, FALSE);

+       update_chrome_visibility (ev_window);

 }
 
 static void
 }
 
 static void


@@ -3685,26 +3819,18 @@ find_bar_search_changed_cb (EggFindBar *find_bar,
                            EvWindow   *ev_window)
 {
        gboolean case_sensitive;
                            EvWindow   *ev_window)
 {
        gboolean case_sensitive;

-       gboolean visible;

        const char *search_string;
 
        const char *search_string;
 

-       g_return_if_fail (EV_IS_WINDOW (ev_window));
-
-       /* Either the string or case sensitivity could have changed,
-        * we connect this callback to both. We also connect it
-        * to ::visible so when the find bar is hidden, we should
-        * pretend the search string is NULL/""
-        */
+       /* Either the string or case sensitivity could have changed. */

 
        case_sensitive = egg_find_bar_get_case_sensitive (find_bar);
 
        case_sensitive = egg_find_bar_get_case_sensitive (find_bar);

-       visible = GTK_WIDGET_VISIBLE (find_bar);

        search_string = egg_find_bar_get_search_string (find_bar);
 
        ev_view_search_changed (EV_VIEW(ev_window->priv->view));
 
        if (ev_window->priv->document &&
            EV_IS_DOCUMENT_FIND (ev_window->priv->document)) {
        search_string = egg_find_bar_get_search_string (find_bar);
 
        ev_view_search_changed (EV_VIEW(ev_window->priv->view));
 
        if (ev_window->priv->document &&
            EV_IS_DOCUMENT_FIND (ev_window->priv->document)) {

-               if (visible && search_string && search_string[0]) {
+               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),
                        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),


@@ -3724,6 +3850,26 @@ find_bar_search_changed_cb (EggFindBar *find_bar,
        }
 }
 
        }
 }
 

+static void
+find_bar_visibility_changed_cb (EggFindBar *find_bar,
+                           GParamSpec *param,
+                           EvWindow   *ev_window)
+{
+       gboolean visible;
+
+       visible = GTK_WIDGET_VISIBLE (find_bar);
+
+       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_window_update_actions (ev_window);
+
+               if (!visible)
+                       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)
 {
 static void
 find_bar_scroll(EggFindBar *find_bar, GtkScrollType scroll, EvWindow* ev_window)
 {


@@ -3751,7 +3897,7 @@ zoom_control_changed_cb (EphyZoomAction *action,
        
        if (mode == EV_SIZING_FREE) {
                ev_view_set_zoom (EV_VIEW (ev_window->priv->view),
        
        if (mode == EV_SIZING_FREE) {
                ev_view_set_zoom (EV_VIEW (ev_window->priv->view),

-                                 zoom * ev_window_get_screen_dpi (ev_window) / 72.0,
+                                 zoom * get_screen_dpi (GTK_WINDOW (ev_window)) / 72.0,

                                  FALSE);
        }
 }
                                  FALSE);
        }
 }


@@ -3801,7 +3947,6 @@ ev_window_dispose (GObject *object)
                priv->attachment_popup_action_group = NULL;
        }
 
                priv->attachment_popup_action_group = NULL;
        }
 

-#ifdef HAVE_GTK_RECENT

        if (priv->recent_action_group) {
                g_object_unref (priv->recent_action_group);
                priv->recent_action_group = NULL;
        if (priv->recent_action_group) {
                g_object_unref (priv->recent_action_group);
                priv->recent_action_group = NULL;


@@ -3815,12 +3960,6 @@ ev_window_dispose (GObject *object)
        }
 
        priv->recent_ui_id = 0;
        }
 
        priv->recent_ui_id = 0;

-#else
-       if (priv->recent_view) {
-               g_object_unref (priv->recent_view);
-               priv->recent_view = NULL;
-       }
-#endif /* HAVE_GTK_RECENT */

 
        if (priv->page_cache) {
                g_signal_handlers_disconnect_by_func (priv->page_cache, page_changed_cb, window);
 
        if (priv->page_cache) {
                g_signal_handlers_disconnect_by_func (priv->page_cache, page_changed_cb, window);


@@ -3845,14 +3984,21 @@ ev_window_dispose (GObject *object)
        if (priv->load_job) {
                ev_window_clear_load_job (window);
        }
        if (priv->load_job) {
                ev_window_clear_load_job (window);
        }

+
+       if (priv->save_job) {
+               ev_window_clear_save_job (window);
+       }
+
+       if (priv->thumbnail_job) {
+               ev_window_clear_thumbnail_job (window);
+       }

        
        if (priv->local_uri) {
                ev_window_clear_local_uri (window);
        
        if (priv->local_uri) {
                ev_window_clear_local_uri (window);

+               priv->local_uri = NULL;

        }
        
        ev_window_close_dialogs (window);
        }
        
        ev_window_close_dialogs (window);

-
-#ifdef WITH_GTK_PRINT

        ev_window_clear_print_job (window);
 
        if (window->priv->gtk_print_job) {
        ev_window_clear_print_job (window);
 
        if (window->priv->gtk_print_job) {


@@ -3874,7 +4020,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);


@@ -3919,11 +4064,15 @@ ev_window_dispose (GObject *object)
                priv->history = NULL;
        }
 
                priv->history = NULL;
        }
 

-       if (priv->fullscreen_timeout_id) {
-               g_source_remove (priv->fullscreen_timeout_id);
-               priv->fullscreen_timeout_id = 0;
+       if (priv->print_settings_file) {
+               ev_window_clear_print_settings_file (window);
+               priv->print_settings_file = NULL;
+       }
+
+       if (priv->presentation_timeout_id > 0) {
+               g_source_remove (priv->presentation_timeout_id);
+               priv->presentation_timeout_id = 0;

        }
        }

-       destroy_fullscreen_popup (window);

 
        G_OBJECT_CLASS (ev_window_parent_class)->dispose (object);
 }
 
        G_OBJECT_CLASS (ev_window_parent_class)->dispose (object);
 }


@@ -3937,8 +4086,6 @@ ev_window_class_init (EvWindowClass *ev_window_class)
        g_object_class->dispose = ev_window_dispose;
        g_object_class->finalize = ev_window_finalize;
 
        g_object_class->dispose = ev_window_dispose;
        g_object_class->finalize = ev_window_finalize;
 

-       widget_class->focus_in_event = ev_window_focus_in_event;
-       widget_class->focus_out_event = ev_window_focus_out_event;

        widget_class->screen_changed = ev_window_screen_changed;
 
        g_type_class_add_private (g_object_class, sizeof (EvWindowPrivate));
        widget_class->screen_changed = ev_window_screen_changed;
 
        g_type_class_add_private (g_object_class, sizeof (EvWindowPrivate));


@@ -3956,7 +4103,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_("Open a _Copy"), NULL,
+       { "FileOpenCopy", NULL, N_("Op_en a Copy"), NULL,

          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",


@@ -3976,11 +4123,7 @@ static const GtkActionEntry entries[] = {
         /* Edit menu */
         { "EditCopy", GTK_STOCK_COPY, NULL, "<control>C", NULL,
           G_CALLBACK (ev_window_cmd_edit_copy) },
         /* Edit menu */
         { "EditCopy", GTK_STOCK_COPY, NULL, "<control>C", NULL,
           G_CALLBACK (ev_window_cmd_edit_copy) },

-#ifdef HAVE_GTK_RECENT

        { "EditSelectAll", GTK_STOCK_SELECT_ALL, N_("Select _All"), "<control>A", NULL,
        { "EditSelectAll", GTK_STOCK_SELECT_ALL, N_("Select _All"), "<control>A", NULL,

-#else
-       { "EditSelectAll", NULL, N_("Select _All"), "<control>A", NULL,
-#endif /* HAVE_GTK_RECENT */

          G_CALLBACK (ev_window_cmd_edit_select_all) },
         { "EditFind", GTK_STOCK_FIND, N_("_Find..."), "<control>F",
           N_("Find a word or phrase in the document"),
          G_CALLBACK (ev_window_cmd_edit_select_all) },
         { "EditFind", GTK_STOCK_FIND, N_("_Find..."), "<control>F",
           N_("Find a word or phrase in the document"),


@@ -4007,17 +4150,20 @@ static const GtkActionEntry entries[] = {
           N_("Reload the document"),
           G_CALLBACK (ev_window_cmd_view_reload) },
 
           N_("Reload the document"),
           G_CALLBACK (ev_window_cmd_view_reload) },
 

+       { "ViewAutoscroll", GTK_STOCK_MEDIA_PLAY, N_("Auto_scroll"), NULL, NULL,
+         G_CALLBACK (ev_window_cmd_view_autoscroll) },
+

         /* Go menu */
         /* Go menu */

-        { "GoPreviousPage", GTK_STOCK_GO_BACK, N_("_Previous Page"), "<control>Page_Up",
+        { "GoPreviousPage", GTK_STOCK_GO_UP, N_("_Previous Page"), "<control>Page_Up",

           N_("Go to the previous page"),
           G_CALLBACK (ev_window_cmd_go_previous_page) },
           N_("Go to the previous page"),
           G_CALLBACK (ev_window_cmd_go_previous_page) },

-        { "GoNextPage", GTK_STOCK_GO_FORWARD, N_("_Next Page"), "<control>Page_Down",
+        { "GoNextPage", GTK_STOCK_GO_DOWN, N_("_Next Page"), "<control>Page_Down",

           N_("Go to the next page"),
           G_CALLBACK (ev_window_cmd_go_next_page) },
           N_("Go to the next page"),
           G_CALLBACK (ev_window_cmd_go_next_page) },

-        { "GoFirstPage", GTK_STOCK_GOTO_FIRST, N_("_First Page"), "<control>Home",
+        { "GoFirstPage", GTK_STOCK_GOTO_TOP, N_("_First Page"), "<control>Home",

           N_("Go to the first page"),
           G_CALLBACK (ev_window_cmd_go_first_page) },
           N_("Go to the first page"),
           G_CALLBACK (ev_window_cmd_go_first_page) },

-        { "GoLastPage", GTK_STOCK_GOTO_LAST, N_("_Last Page"), "<control>End",
+        { "GoLastPage", GTK_STOCK_GOTO_BOTTOM, N_("_Last Page"), "<control>End",

           N_("Go to the last page"),
           G_CALLBACK (ev_window_cmd_go_last_page) },
 
           N_("Go to the last page"),
           G_CALLBACK (ev_window_cmd_go_last_page) },
 


@@ -4029,9 +4175,15 @@ static const GtkActionEntry entries[] = {
          G_CALLBACK (ev_window_cmd_help_about) },
 
        /* Toolbar-only */
          G_CALLBACK (ev_window_cmd_help_about) },
 
        /* Toolbar-only */

-       { "LeaveFullscreen", EV_STOCK_LEAVE_FULLSCREEN, N_("Leave Fullscreen"), NULL,
+       { "LeaveFullscreen", GTK_STOCK_LEAVE_FULLSCREEN, N_("Leave Fullscreen"), NULL,

          N_("Leave fullscreen mode"),
          G_CALLBACK (ev_window_cmd_leave_fullscreen) },
          N_("Leave fullscreen mode"),
          G_CALLBACK (ev_window_cmd_leave_fullscreen) },

+       { "StartPresentation", EV_STOCK_RUN_PRESENTATION, N_("Start Presentation"), NULL,
+         N_("Start a presentation"),
+         G_CALLBACK (ev_window_cmd_start_presentation) },
+       { "PreviewPrint", GTK_STOCK_PRINT, N_("Print"), NULL,
+         N_("Print this document"),
+         G_CALLBACK (ev_window_cmd_preview_print) },

 
        /* Accellerators */
        { "Escape", NULL, "", "Escape", "",
 
        /* Accellerators */
        { "Escape", NULL, "", "Escape", "",


@@ -4093,10 +4245,10 @@ static const GtkToggleActionEntry toggle_entries[] = {
         { "ViewDual", EV_STOCK_VIEW_DUAL, N_("_Dual"), NULL,
          N_("Show two pages at once"),
          G_CALLBACK (ev_window_cmd_dual), FALSE },
         { "ViewDual", EV_STOCK_VIEW_DUAL, N_("_Dual"), NULL,
          N_("Show two pages at once"),
          G_CALLBACK (ev_window_cmd_dual), FALSE },

-        { "ViewFullscreen", NULL, N_("_Fullscreen"), "F11",
+        { "ViewFullscreen", GTK_STOCK_FULLSCREEN, N_("_Fullscreen"), "F11",

           N_("Expand the window to fill the screen"),
           G_CALLBACK (ev_window_cmd_view_fullscreen) },
           N_("Expand the window to fill the screen"),
           G_CALLBACK (ev_window_cmd_view_fullscreen) },

-        { "ViewPresentation", NULL, N_("_Presentation"), "F5",
+        { "ViewPresentation", EV_STOCK_RUN_PRESENTATION, N_("Pre_sentation"), "F5",

           N_("Run document as a presentation"),
           G_CALLBACK (ev_window_cmd_view_presentation) },
         { "ViewBestFit", EV_STOCK_ZOOM_PAGE, N_("_Best Fit"), NULL,
           N_("Run document as a presentation"),
           G_CALLBACK (ev_window_cmd_view_presentation) },
         { "ViewBestFit", EV_STOCK_ZOOM_PAGE, N_("_Best Fit"), NULL,


@@ -4161,6 +4313,7 @@ register_custom_actions (EvWindow *window, GtkActionGroup *group)
                               "name", PAGE_SELECTOR_ACTION,
                               "label", _("Page"),
                               "tooltip", _("Select Page"),
                               "name", PAGE_SELECTOR_ACTION,
                               "label", _("Page"),
                               "tooltip", _("Select Page"),

+                              "icon_name", "text-x-generic",

                               "visible_overflown", FALSE,
                               NULL);
        g_signal_connect (action, "activate_link",
                               "visible_overflown", FALSE,
                               NULL);
        g_signal_connect (action, "activate_link",


@@ -4171,7 +4324,7 @@ register_custom_actions (EvWindow *window, GtkActionGroup *group)
        action = g_object_new (EPHY_TYPE_ZOOM_ACTION,
                               "name", ZOOM_CONTROL_ACTION,
                               "label", _("Zoom"),
        action = g_object_new (EPHY_TYPE_ZOOM_ACTION,
                               "name", ZOOM_CONTROL_ACTION,
                               "label", _("Zoom"),

-                              "stock_id", GTK_STOCK_ZOOM_IN,
+                              "stock_id", EV_STOCK_ZOOM,

                               "tooltip", _("Adjust the zoom level"),
                               "zoom", 1.0,
                               NULL);
                               "tooltip", _("Adjust the zoom level"),
                               "zoom", 1.0,
                               NULL);


@@ -4186,12 +4339,27 @@ register_custom_actions (EvWindow *window, GtkActionGroup *group)
                               "is_important", TRUE,
                               "short_label", _("Back"),
                               "stock_id", GTK_STOCK_GO_DOWN,
                               "is_important", TRUE,
                               "short_label", _("Back"),
                               "stock_id", GTK_STOCK_GO_DOWN,

+                              /*translators: this is the history action*/

                               "tooltip", _("Move across visited pages"),
                               NULL);
        g_signal_connect (action, "activate_link",
                          G_CALLBACK (navigation_action_activate_link_cb), window);
        gtk_action_group_add_action (group, action);
        g_object_unref (action);
                               "tooltip", _("Move across visited pages"),
                               NULL);
        g_signal_connect (action, "activate_link",
                          G_CALLBACK (navigation_action_activate_link_cb), window);
        gtk_action_group_add_action (group, action);
        g_object_unref (action);

+
+       action = g_object_new (EV_TYPE_OPEN_RECENT_ACTION,
+                              "name", "FileOpenRecent",
+                              "label", _("_Open..."),
+                              "tooltip", _("Open an existing document"),
+                              "stock_id", GTK_STOCK_OPEN,
+                              NULL);
+       g_signal_connect (action, "activate",
+                         G_CALLBACK (ev_window_cmd_file_open), window);
+       g_signal_connect (action, "item_activated",
+                         G_CALLBACK (ev_window_open_recent_action_item_activated),
+                         window);
+       gtk_action_group_add_action (group, action);
+       g_object_unref (action);

 }
 
 static void
 }
 
 static void


@@ -4270,6 +4438,8 @@ view_actions_focus_in_cb (GtkWidget *widget, GdkEventFocus *event, EvWindow *win
 
        ev_window_set_view_accels_sensitivity (window, TRUE);
 
 
        ev_window_set_view_accels_sensitivity (window, TRUE);
 

+       update_chrome_visibility (window);
+

        return FALSE;
 }
 
        return FALSE;
 }
 


@@ -4335,12 +4505,15 @@ window_configure_event_cb (EvWindow *window, GdkEventConfigure *event, gpointer
                        ev_page_cache_get_max_height (window->priv->page_cache, 
                                                      0, 1.0,
                                                      &document_height);                        
                        ev_page_cache_get_max_height (window->priv->page_cache, 
                                                      0, 1.0,
                                                      &document_height);                        

-                       ev_metadata_manager_set_int (uri, "window_x", x);
-                       ev_metadata_manager_set_int (uri, "window_y", y);

                        ev_metadata_manager_set_double (uri, "window_width_ratio", 
                        ev_metadata_manager_set_double (uri, "window_width_ratio", 

-                                                       (double)width/document_width);
+                                                       (double)width / document_width);

                        ev_metadata_manager_set_double (uri, "window_height_ratio", 
                        ev_metadata_manager_set_double (uri, "window_height_ratio", 

-                                                       (double)height/document_height);
+                                                       (double)height / document_height);
+                       
+                       ev_metadata_manager_set_int (uri, "window_x", x);
+                       ev_metadata_manager_set_int (uri, "window_y", y);
+                       ev_metadata_manager_set_int (uri, "window_width", width);
+                       ev_metadata_manager_set_int (uri, "window_height", height);

                }
        }
 
                }
        }
 


@@ -4351,31 +4524,48 @@ 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);

-       char *uri = NULL;
+       const char *content_type;
+       GAppInfo *app_info;
+       GFileInfo *file_info;
+       GFile *file;
+       GList *file_list = NULL;
+       
+       if (filename == NULL)
+               return;

 
 

-       if (filename  && g_path_is_absolute (filename)) {
-               uri = gnome_vfs_get_uri_from_local_path (filename);
+       if (g_path_is_absolute (filename)) {
+               file = g_file_new_for_path (filename);

        } else {
        } else {

-               GnomeVFSURI *base_uri, *resolved_uri;
-
-               base_uri = gnome_vfs_uri_new (window->priv->uri);
-               if (base_uri && filename) {
-                       resolved_uri = gnome_vfs_uri_resolve_relative (base_uri, filename);     
-                       if (resolved_uri) {
-                               uri = gnome_vfs_uri_to_string (resolved_uri, GNOME_VFS_URI_HIDE_NONE);
-                               gnome_vfs_uri_unref (resolved_uri);
-                       }
-                       gnome_vfs_uri_unref (base_uri);
-               }
+               GFile *base_file;
+               
+               base_file = g_file_new_for_uri (window->priv->uri);
+               file = g_file_resolve_relative_path (base_file,
+                                                    filename);
+               
+               g_object_unref (base_file);

        }
        }

-
-       if (uri) {
-               gnome_vfs_url_show (uri);
-       } else {
-               gnome_vfs_url_show (filename);
+       
+       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;

        }
        }

+       
+       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);

 
 

-       g_free (uri);
+       /* FIXME: should we use a GAppLaunchContext? */
+       g_app_info_launch (app_info, file_list,
+                          NULL, NULL);
+       
+       g_list_free (file_list);
+       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
           allowing to launch executables is a good idea though. -- marco */
 
        /* According to the PDF spec filename can be an executable. I'm not sure
           allowing to launch executables is a good idea though. -- marco */


@@ -4384,7 +4574,48 @@ launch_action (EvWindow *window, EvLinkAction *action)
 static void
 launch_external_uri (EvWindow *window, EvLinkAction *action)
 {
 static void
 launch_external_uri (EvWindow *window, EvLinkAction *action)
 {

-       gnome_vfs_url_show (ev_link_action_get_uri (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;
+       
+       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;
+       }
+       
+       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);
+       }
+
+       g_object_unref (app);
+       g_object_unref (file);
+       g_list_free (file_list);

 }
 
 static void
 }
 
 static void


@@ -4403,7 +4634,9 @@ open_remote_link (EvWindow *window, EvLinkAction *action)
                                         gtk_window_get_screen (GTK_WINDOW (window)),
                                         ev_link_action_get_dest (action),
                                         0,
                                         gtk_window_get_screen (GTK_WINDOW (window)),
                                         ev_link_action_get_dest (action),
                                         0,

+                                        NULL, 

                                         FALSE,
                                         FALSE,

+                                        NULL,

                                         GDK_CURRENT_TIME);
 
        g_free (uri);
                                         GDK_CURRENT_TIME);
 
        g_free (uri);


@@ -4508,14 +4741,23 @@ ev_view_popup_cmd_copy_link_address (GtkAction *action, EvWindow *window)
        gtk_clipboard_set_text (clipboard, uri, -1);
 }
 
        gtk_clipboard_set_text (clipboard, uri, -1);
 }
 

+

 static void
 image_save_dialog_response_cb (GtkWidget *fc,
                               gint       response_id,
                               EvWindow  *ev_window)
 {
 static void
 image_save_dialog_response_cb (GtkWidget *fc,
                               gint       response_id,
                               EvWindow  *ev_window)
 {

-       gchar  *uri;
-       gchar  *filename;
-       GError *error = NULL;
+       GFile           *target_file;
+       gboolean         is_native;
+       GError          *error = NULL;
+       GdkPixbuf       *pixbuf;
+       gchar           *uri;
+       gchar           *uri_extension;
+       gchar          **extensions;
+       gchar           *filename;
+       gchar           *file_format;
+       GdkPixbufFormat *format;
+       GtkFileFilter   *filter;

        
        if (response_id != GTK_RESPONSE_OK) {
                gtk_widget_destroy (fc);
        
        if (response_id != GTK_RESPONSE_OK) {
                gtk_widget_destroy (fc);


@@ -4523,30 +4765,79 @@ image_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));

-       filename = g_filename_from_uri (uri, NULL, NULL);
+       filter = gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (fc));
+       format = g_object_get_data (G_OBJECT (filter), "pixbuf-format");
+       
+       if (format == NULL) {
+               format = get_gdk_pixbuf_format_by_extension (uri);
+       }
+
+       if (format == NULL) {
+               ev_window_error_message (GTK_WINDOW (ev_window),
+                                        _("Couldn't find appropriate format to save image"),
+                                        NULL);
+               g_free (uri);
+               gtk_widget_destroy (fc);
+
+               return;
+       }
+
+       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);
+       
+       target_file = g_file_new_for_uri (uri_extension);
+       is_native = g_file_is_native (target_file);
+       
+       if (is_native) {
+               filename = g_file_get_path (target_file);
+       } else {
+               filename = ev_tmp_filename ("saveimage");
+       }
+       

        g_free (uri);
        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 ();

        
        

-       /* FIXME: allow saving in other image formats than png */
-       gdk_pixbuf_save (ev_image_get_pixbuf (ev_window->priv->image),
-                        filename, "png", &error, NULL);
+       gdk_pixbuf_save (pixbuf, filename, file_format, &error, NULL);
+       g_free (file_format);
+       g_object_unref (pixbuf);

        
        if (error) {
        
        if (error) {

-               ev_window_error_dialog (GTK_WINDOW (ev_window),
-                                       _("The image could not be saved."),
-                                       error);
+               ev_window_error_message (GTK_WINDOW (ev_window),
+                                        _("The image could not be saved."),
+                                        error);

                g_error_free (error);
                g_error_free (error);

+               g_free (filename);
+               g_object_unref (target_file);
+               gtk_widget_destroy (fc);
+
+               return;

        }
 
        }
 

+       if (!is_native) {
+               GFile *source_file;
+               
+               source_file = g_file_new_for_uri (filename);
+               
+               ev_window_save_remote (ev_window, source_file, target_file);
+               g_object_unref (source_file);
+       }
+       

        g_free (filename);
        g_free (filename);

-
+       g_object_unref (target_file);

        gtk_widget_destroy (fc);
 }
 
 static void
 ev_view_popup_cmd_save_image_as (GtkAction *action, EvWindow *window)
 {
        gtk_widget_destroy (fc);
 }
 
 static void
 ev_view_popup_cmd_save_image_as (GtkAction *action, EvWindow *window)
 {

-       GtkWidget     *fc;
-       GtkFileFilter *filter;
+       GtkWidget *fc;

 
        if (!window->priv->image)
                return;
 
        if (!window->priv->image)
                return;


@@ -4560,13 +4851,11 @@ ev_view_popup_cmd_save_image_as (GtkAction *action, EvWindow *window)
                                          NULL);
 
        gtk_dialog_set_default_response (GTK_DIALOG (fc), GTK_RESPONSE_OK);
                                          NULL);
 
        gtk_dialog_set_default_response (GTK_DIALOG (fc), GTK_RESPONSE_OK);

+       gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (fc), FALSE);

        gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (fc), TRUE);
        gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (fc), TRUE);

-
-       filter = gtk_file_filter_new ();
-       gtk_file_filter_set_name (filter, _("Images"));
-       gtk_file_filter_add_pixbuf_formats (filter);
-       gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fc), filter);
-
+       
+       file_chooser_dialog_add_writable_pixbuf_formats (GTK_FILE_CHOOSER (fc));
+       

        g_signal_connect (fc, "response",
                          G_CALLBACK (image_save_dialog_response_cb),
                          window);
        g_signal_connect (fc, "response",
                          G_CALLBACK (image_save_dialog_response_cb),
                          window);


@@ -4578,14 +4867,20 @@ static void
 ev_view_popup_cmd_copy_image (GtkAction *action, EvWindow *window)
 {
        GtkClipboard *clipboard;
 ev_view_popup_cmd_copy_image (GtkAction *action, EvWindow *window)
 {
        GtkClipboard *clipboard;

+       GdkPixbuf    *pixbuf;

 
        if (!window->priv->image)
                return;
        
        clipboard = gtk_widget_get_clipboard (GTK_WIDGET (window),
                                              GDK_SELECTION_CLIPBOARD);
 
        if (!window->priv->image)
                return;
        
        clipboard = gtk_widget_get_clipboard (GTK_WIDGET (window),
                                              GDK_SELECTION_CLIPBOARD);

-       gtk_clipboard_set_image (clipboard,
-                                ev_image_get_pixbuf (window->priv->image));
+       ev_document_doc_mutex_lock ();
+       pixbuf = ev_document_images_get_image (EV_DOCUMENT_IMAGES (window->priv->document),
+                                              window->priv->image);
+       ev_document_doc_mutex_unlock ();
+       
+       gtk_clipboard_set_image (clipboard, pixbuf);
+       g_object_unref (pixbuf);

 }
 
 static void
 }
 
 static void


@@ -4605,9 +4900,9 @@ ev_attachment_popup_cmd_open_attachment (GtkAction *action, EvWindow *window)
                ev_attachment_open (attachment, &error);
 
                if (error) {
                ev_attachment_open (attachment, &error);
 
                if (error) {

-                       ev_window_error_dialog (GTK_WINDOW (window),
-                                               _("Unable to open attachment"),
-                                               error);
+                       ev_window_error_message (GTK_WINDOW (window),
+                                                _("Unable to open attachment"),
+                                                error);

                        g_error_free (error);
                }
        }
                        g_error_free (error);
                }
        }


@@ -4618,10 +4913,12 @@ attachment_save_dialog_response_cb (GtkWidget *fc,
                                    gint       response_id,
                                    EvWindow  *ev_window)
 {
                                    gint       response_id,
                                    EvWindow  *ev_window)
 {

+       GFile                *target_file;

        gchar                *uri;
        GList                *l;
        GtkFileChooserAction  fc_action;
        gboolean              is_dir;
        gchar                *uri;
        GList                *l;
        GtkFileChooserAction  fc_action;
        gboolean              is_dir;

+       gboolean              is_native;

        
        if (response_id != GTK_RESPONSE_OK) {
                gtk_widget_destroy (fc);
        
        if (response_id != GTK_RESPONSE_OK) {
                gtk_widget_destroy (fc);


@@ -4629,37 +4926,61 @@ attachment_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));

-       
+       target_file = g_file_new_for_uri (uri);

        g_object_get (G_OBJECT (fc), "action", &fc_action, NULL);
        is_dir = (fc_action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
        g_object_get (G_OBJECT (fc), "action", &fc_action, NULL);
        is_dir = (fc_action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);

+       is_native = g_file_is_native (target_file);

        
        for (l = ev_window->priv->attach_list; l && l->data; l = g_list_next (l)) {
                EvAttachment *attachment;
        
        for (l = ev_window->priv->attach_list; l && l->data; l = g_list_next (l)) {
                EvAttachment *attachment;

-               gchar        *filename;
+               GFile        *save_to;

                GError       *error = NULL;
                
                attachment = (EvAttachment *) l->data;
 
                GError       *error = NULL;
                
                attachment = (EvAttachment *) l->data;
 

-               if (is_dir) {
-                       filename = g_strjoin ("/", uri,
-                                             ev_attachment_get_name (attachment),
-                                             NULL);
+               if (is_native) {
+                       if (is_dir) {
+                               save_to = g_file_get_child (target_file,
+                                                           ev_attachment_get_name (attachment));
+                       } else {
+                               save_to = g_object_ref (target_file);
+                       }

                } else {
                } else {

-                       filename = g_strdup (uri);
+                       save_to = ev_tmp_file_get ("saveattachment");

                }
                }

-               
-               ev_attachment_save (attachment, filename, &error);
-               g_free (filename);
+
+               ev_attachment_save (attachment, save_to, &error);

                
                if (error) {
                
                if (error) {

-                       ev_window_error_dialog (GTK_WINDOW (ev_window),
-                                               _("The attachment could not be saved."),
-                                               error);
+                       ev_window_error_message (GTK_WINDOW (ev_window),
+                                                _("The attachment could not be saved."),
+                                                error);

                        g_error_free (error);
                        g_error_free (error);

+                       g_object_unref (save_to);
+
+                       continue;
+               }
+
+               if (!is_native) {
+                       GFile *dest_file;
+
+                       if (is_dir) {
+                               dest_file = g_file_get_child (target_file,
+                                                             ev_attachment_get_name (attachment));
+                       } else {
+                               dest_file = g_object_ref (target_file);
+                       }
+
+                       ev_window_save_remote (ev_window, save_to, dest_file);
+
+                       g_object_unref (dest_file);

                }
                }

+
+               g_object_unref (save_to);

        }
 
        g_free (uri);
        }
 
        g_free (uri);

+       g_object_unref (target_file);

 
        gtk_widget_destroy (fc);
 }
 
        gtk_widget_destroy (fc);
 }


@@ -4687,6 +5008,7 @@ ev_attachment_popup_cmd_save_attachment_as (GtkAction *action, EvWindow *window)
 
        gtk_dialog_set_default_response (GTK_DIALOG (fc), GTK_RESPONSE_OK);
        gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (fc), TRUE);
 
        gtk_dialog_set_default_response (GTK_DIALOG (fc), GTK_RESPONSE_OK);
        gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (fc), TRUE);

+       gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (fc), FALSE);

 
        if (attachment)
                gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (fc),
 
        if (attachment)
                gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (fc),


@@ -4705,14 +5027,12 @@ ev_window_init (EvWindow *ev_window)
        GtkActionGroup *action_group;
        GtkAccelGroup *accel_group;
        GError *error = NULL;
        GtkActionGroup *action_group;
        GtkAccelGroup *accel_group;
        GError *error = NULL;

-       GtkWidget *sidebar_widget, *toolbar_dock;
+       GtkWidget *sidebar_widget;

 
        g_signal_connect (ev_window, "configure_event",
                          G_CALLBACK (window_configure_event_cb), NULL);
        g_signal_connect (ev_window, "window_state_event",
                          G_CALLBACK (window_state_event_cb), NULL);
 
        g_signal_connect (ev_window, "configure_event",
                          G_CALLBACK (window_configure_event_cb), NULL);
        g_signal_connect (ev_window, "window_state_event",
                          G_CALLBACK (window_state_event_cb), NULL);

-       g_signal_connect (ev_window, "notify",
-                         G_CALLBACK (fullscreen_timeout_cb), NULL);

 
        ev_window->priv = EV_WINDOW_GET_PRIVATE (ev_window);
 
 
        ev_window->priv = EV_WINDOW_GET_PRIVATE (ev_window);
 


@@ -4769,17 +5089,20 @@ ev_window_init (EvWindow *ev_window)
                g_error_free (error);
        }
        
                g_error_free (error);
        }
        

-#ifdef HAVE_GTK_RECENT
+#if GTK_CHECK_VERSION(2,11,4)
+       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 (
        ev_window->priv->recent_manager = gtk_recent_manager_get_for_screen (

-               gtk_widget_get_screen (GTK_WIDGET (ev_window)));
+               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,
                                  "changed",
                                  G_CALLBACK (ev_window_setup_recent),
                                  ev_window);
        ev_window->priv->recent_action_group = NULL;
        ev_window->priv->recent_ui_id = 0;
        g_signal_connect_swapped (ev_window->priv->recent_manager,
                                  "changed",
                                  G_CALLBACK (ev_window_setup_recent),
                                  ev_window);

-#endif /* HAVE_GTK_RECENT */
-       
+

        ev_window->priv->menubar =
                 gtk_ui_manager_get_widget (ev_window->priv->ui_manager,
                                            "/MainMenu");
        ev_window->priv->menubar =
                 gtk_ui_manager_get_widget (ev_window->priv->ui_manager,
                                            "/MainMenu");


@@ -4787,33 +5110,19 @@ ev_window_init (EvWindow *ev_window)
                            ev_window->priv->menubar,
                            FALSE, FALSE, 0);
 
                            ev_window->priv->menubar,
                            FALSE, FALSE, 0);
 

-       /* This sucks, but there is no way to have a draw=no, expand=true separator
-        * in a GtkUIManager-built toolbar. So, just add another toolbar.
-        * See gtk+ bug 166489.
-        */
-       toolbar_dock = ev_window->priv->toolbar_dock = gtk_hbox_new (FALSE, 0);
-       gtk_box_pack_start (GTK_BOX (ev_window->priv->main_box), toolbar_dock,
-                           FALSE, FALSE, 0);
-       gtk_widget_show (toolbar_dock);
-

        ev_window->priv->toolbar = GTK_WIDGET 
          (g_object_new (EGG_TYPE_EDITABLE_TOOLBAR,
                         "ui-manager", ev_window->priv->ui_manager,
                         "popup-path", "/ToolbarPopup",
        ev_window->priv->toolbar = GTK_WIDGET 
          (g_object_new (EGG_TYPE_EDITABLE_TOOLBAR,
                         "ui-manager", ev_window->priv->ui_manager,
                         "popup-path", "/ToolbarPopup",

-                        "model", ev_application_get_toolbars_model (EV_APP, FALSE),
+                        "model", ev_application_get_toolbars_model (EV_APP),

                         NULL));
 
        egg_editable_toolbar_show (EGG_EDITABLE_TOOLBAR (ev_window->priv->toolbar),
                                   "DefaultToolBar");
                         NULL));
 
        egg_editable_toolbar_show (EGG_EDITABLE_TOOLBAR (ev_window->priv->toolbar),
                                   "DefaultToolBar");

-       gtk_box_pack_start (GTK_BOX (toolbar_dock), ev_window->priv->toolbar,
-                           TRUE, TRUE, 0);
-       gtk_widget_show (ev_window->priv->toolbar);
-
-       /* Preview toolbar */
-       ev_window->priv->preview_toolbar = egg_editable_toolbar_new_with_model
-                               (ev_window->priv->ui_manager, ev_application_get_toolbars_model (EV_APP, TRUE), NULL);
-       gtk_box_pack_start (GTK_BOX (ev_window->priv->main_box), ev_window->priv->preview_toolbar,
+       gtk_box_pack_start (GTK_BOX (ev_window->priv->main_box),
+                           ev_window->priv->toolbar,

                            FALSE, FALSE, 0);
                            FALSE, FALSE, 0);

+       gtk_widget_show (ev_window->priv->toolbar);

 
        /* Add the main area */
        ev_window->priv->hpaned = gtk_hpaned_new ();
 
        /* Add the main area */
        ev_window->priv->hpaned = gtk_hpaned_new ();


@@ -4834,6 +5143,17 @@ ev_window_init (EvWindow *ev_window)
 
        /* Stub sidebar, for now */
 
 
        /* Stub sidebar, for now */
 

+       sidebar_widget = ev_sidebar_thumbnails_new ();
+       ev_window->priv->sidebar_thumbs = sidebar_widget;
+       g_signal_connect (sidebar_widget,
+                         "notify::main-widget",
+                         G_CALLBACK (sidebar_page_main_widget_update_cb),
+                         ev_window);
+       sidebar_page_main_widget_update_cb (G_OBJECT (sidebar_widget), NULL, ev_window);
+       gtk_widget_show (sidebar_widget);
+       ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar),
+                            sidebar_widget);
+

        sidebar_widget = ev_sidebar_links_new ();
        ev_window->priv->sidebar_links = sidebar_widget;
        g_signal_connect (sidebar_widget,
        sidebar_widget = ev_sidebar_links_new ();
        ev_window->priv->sidebar_links = sidebar_widget;
        g_signal_connect (sidebar_widget,


@@ -4859,29 +5179,23 @@ 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_thumbnails_new ();
-       ev_window->priv->sidebar_thumbs = sidebar_widget;
-       g_signal_connect (sidebar_widget,
-                         "notify::main-widget",
-                         G_CALLBACK (sidebar_page_main_widget_update_cb),
-                         ev_window);
-       sidebar_page_main_widget_update_cb (G_OBJECT (sidebar_widget), NULL, 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,
                                          "shadow-type", GTK_SHADOW_IN,
                                          NULL));
        ev_window->priv->scrolled_window =
                GTK_WIDGET (g_object_new (GTK_TYPE_SCROLLED_WINDOW,
                                          "shadow-type", GTK_SHADOW_IN,
                                          NULL));

+       gtk_box_pack_start (GTK_BOX (ev_window->priv->view_box),
+                           ev_window->priv->scrolled_window,
+                           TRUE, TRUE, 0);

        gtk_widget_show (ev_window->priv->scrolled_window);
 
        gtk_paned_add2 (GTK_PANED (ev_window->priv->hpaned),
        gtk_widget_show (ev_window->priv->scrolled_window);
 
        gtk_paned_add2 (GTK_PANED (ev_window->priv->hpaned),

-                       ev_window->priv->scrolled_window);
+                       ev_window->priv->view_box);
+       gtk_widget_show (ev_window->priv->view_box);

 
        ev_window->priv->view = ev_view_new ();
        ev_view_set_screen_dpi (EV_VIEW (ev_window->priv->view),
 
        ev_window->priv->view = ev_view_new ();
        ev_view_set_screen_dpi (EV_VIEW (ev_window->priv->view),

-                               ev_window_get_screen_dpi (ev_window));
+                               get_screen_dpi (GTK_WINDOW (ev_window)));

        ev_window->priv->password_view = ev_password_view_new ();
        g_signal_connect_swapped (ev_window->priv->password_view,
                                  "unlock",
        ev_window->priv->password_view = ev_password_view_new ();
        g_signal_connect_swapped (ev_window->priv->password_view,
                                  "unlock",


@@ -4982,7 +5296,7 @@ ev_window_init (EvWindow *ev_window)
                          ev_window);
        g_signal_connect (ev_window->priv->find_bar,
                          "notify::visible",
                          ev_window);
        g_signal_connect (ev_window->priv->find_bar,
                          "notify::visible",

-                         G_CALLBACK (find_bar_search_changed_cb),
+                         G_CALLBACK (find_bar_visibility_changed_cb),

                          ev_window);
        g_signal_connect (ev_window->priv->find_bar,
                          "scroll",
                          ev_window);
        g_signal_connect (ev_window->priv->find_bar,
                          "scroll",


@@ -5017,6 +5331,13 @@ ev_window_init (EvWindow *ev_window)
        ev_window_setup_action_sensitivity (ev_window);
 }
 
        ev_window_setup_action_sensitivity (ev_window);
 }
 

+/**
+ * ev_window_new:
+ *
+ * Creates a #GtkWidget that represents the window.
+ *
+ * Returns: the #GtkWidget that represents the window.
+ */

 GtkWidget *
 ev_window_new (void)
 {
 GtkWidget *
 ev_window_new (void)
 {