X-Git-Url: https://www.fi.muni.cz/~kas/git//home/kas/public_html/git/?a=blobdiff_plain;f=shell%2Fev-window.c;h=98d888f41d940726b3724ee64f45fb50d98bc64c;hb=2dc20d298ea8064cf09bc5acc201a9df4e4cd4f0;hp=29b6a039b17b6987ac0df4487897b95be378bd2a;hpb=4235880ace7cb1372fbd0bdb18de256370b3808f;p=evince.git

diff --git a/shell/ev-window.c b/shell/ev-window.c
index 29b6a039..98d888f4 100644
--- a/shell/ev-window.c
+++ b/shell/ev-window.c
@@ -30,6 +30,7 @@
 
 #include "ev-window.h"
 #include "ev-window-title.h"
+#include "ev-navigation-action.h"
 #include "ev-page-action.h"
 #include "ev-sidebar.h"
 #include "ev-sidebar-links.h"
@@ -50,11 +51,15 @@
 #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-recent-model.h"
 #include "egg-toolbars-model.h"
 #include "ephy-zoom.h"
 #include "ephy-zoom-action.h"
@@ -64,20 +69,30 @@
 #include "ev-file-helpers.h"
 #include "ev-utils.h"
 #include "ev-debug.h"
+#include "ev-history.h"
 
 #ifdef WITH_GNOME_PRINT
 #include "ev-print-job.h"
 #include <libgnomeprintui/gnome-print-dialog.h>
 #endif
 
+#ifdef WITH_GTK_PRINT
+#include <gtk/gtkprintunixdialog.h>
+#endif
+
+#ifdef ENABLE_PDF
 #include <poppler.h>
+#endif
 
+#include <glib/gstdio.h>
 #include <glib/gi18n.h>
 #include <gtk/gtk.h>
 #include <gnome.h>
 #include <libgnomevfs/gnome-vfs-utils.h>
 #include <gconf/gconf-client.h>
 
+#include "totem-scrsaver.h"
+
 #include <string.h>
 
 typedef enum {
@@ -92,6 +107,7 @@ typedef enum {
 	EV_CHROME_RAISE_TOOLBAR	= 1 << 3,
 	EV_CHROME_FULLSCREEN_TOOLBAR	= 1 << 4,
 	EV_CHROME_SIDEBAR	= 1 << 5,
+	EV_CHROME_PREVIEW_TOOLBAR       = 1 << 6,
 	EV_CHROME_NORMAL	= EV_CHROME_MENUBAR | EV_CHROME_TOOLBAR | EV_CHROME_SIDEBAR
 } EvChrome;
 
@@ -112,25 +128,34 @@ struct _EvWindowPrivate {
 	GtkWidget *sidebar_thumbs;
 	GtkWidget *sidebar_links;
 	GtkWidget *sidebar_attachments;
+	GtkWidget *preview_toolbar;
 
 	/* Dialogs */
 	GtkWidget *properties;
-#ifdef WITH_GNOME_PRINT
+#ifdef WITH_PRINT
 	GtkWidget *print_dialog;
 #endif
 	GtkWidget *password_dialog;
 
 	/* UI Builders */
-	GtkActionGroup *action_group;
-	GtkActionGroup *view_popup_action_group;
-	GtkActionGroup *attachment_popup_action_group;
-	GtkUIManager   *ui_manager;
+	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;
+#endif
+	GtkUIManager     *ui_manager;
 
 	/* Fullscreen mode */
 	GtkWidget *fullscreen_toolbar;
 	GtkWidget *fullscreen_popup;
 	guint      fullscreen_timeout_id;
-	
+
+	/* Screensaver */
+	TotemScrsaver *screensaver;
+
 	/* Popup link */
 	GtkWidget *view_popup;
 	EvLink    *link;
@@ -143,18 +168,29 @@ struct _EvWindowPrivate {
 	char *uri;
 	char *local_uri;
 	EvLinkDest *dest;
+	gboolean unlink_temp_file;
 	
 	EvDocument *document;
-	EvDocument *password_document;
+	EvHistory *history;
 	EvPageCache *page_cache;
 	EvWindowPageMode page_mode;
 	EvWindowTitle *title;
+#ifndef HAVE_GTK_RECENT
 	EggRecentViewUIManager *recent_view;
+#endif
 
 	EvJob *xfer_job;
 #ifdef WITH_GNOME_PRINT
 	GnomePrintJob *print_job;
 #endif
+
+#ifdef WITH_GTK_PRINT
+	EvJob            *print_job;
+	GtkPrintJob      *gtk_print_job;
+	GtkPrinter       *printer;
+	GtkPrintSettings *print_settings;
+	GtkPageSetup     *print_page_setup;
+#endif
 };
 
 static const GtkTargetEntry ev_drop_types[] = {
@@ -167,6 +203,7 @@ static const GtkTargetEntry ev_drop_types[] = {
 
 #define PAGE_SELECTOR_ACTION	"PageSelector"
 #define ZOOM_CONTROL_ACTION	"ViewZoom"
+#define NAVIGATION_ACTION	"Navigation"
 
 #define GCONF_OVERRIDE_RESTRICTIONS "/apps/evince/override_restrictions"
 #define GCONF_LOCKDOWN_SAVE         "/desktop/gnome/lockdown/disable_save_to_disk"
@@ -186,8 +223,12 @@ static void     ev_window_sidebar_visibility_changed_cb (EvSidebar        *ev_si
 							 EvWindow         *ev_window);
 static void     ev_window_set_page_mode                 (EvWindow         *window,
 							 EvWindowPageMode  page_mode);
-static void	ev_window_xfer_job_cb  			(EvJobXfer *job,
-							 gpointer data);
+static void	ev_window_xfer_job_cb  			(EvJobXfer        *job,
+							 gpointer          data);
+#ifdef WITH_GTK_PRINT
+static void     ev_window_print_job_cb                  (EvJobPrint       *job,
+							 EvWindow         *window);
+#endif
 static void     ev_window_sizing_mode_changed_cb        (EvView           *view,
 							 GParamSpec       *pspec,
 							 EvWindow         *ev_window);
@@ -204,8 +245,11 @@ static void     ev_window_run_presentation              (EvWindow         *windo
 static void     ev_window_stop_presentation             (EvWindow         *window);
 static void     ev_window_cmd_view_presentation         (GtkAction        *action,
 							 EvWindow         *window);
+static void     ev_window_run_preview                   (EvWindow         *window);
 static void     ev_view_popup_cmd_open_link             (GtkAction        *action,
 							 EvWindow         *window);
+static void     ev_view_popup_cmd_open_link_new_window  (GtkAction        *action,
+							 EvWindow         *window);
 static void     ev_view_popup_cmd_copy_link_address     (GtkAction        *action,
 							 EvWindow         *window);
 static void	ev_attachment_popup_cmd_open_attachment (GtkAction        *action,
@@ -271,7 +315,7 @@ ev_window_setup_action_sensitivity (EvWindow *ev_window)
 		can_get_text = TRUE;
 	}
 	
-	if (has_document && EV_IS_DOCUMENT_FIND (document)) {
+	if (has_pages && EV_IS_DOCUMENT_FIND (document)) {
 		can_find = TRUE;
 	}
 
@@ -295,23 +339,31 @@ ev_window_setup_action_sensitivity (EvWindow *ev_window)
 	if (gconf_client_get_bool (client, GCONF_LOCKDOWN_PRINT, NULL)) {
 		ok_to_print = FALSE;
 	}
-#ifndef WITH_GNOME_PRINT
+#ifndef WITH_PRINT
 	ok_to_print = FALSE;
 #endif
 	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);
+
+#ifdef WITH_GTK_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);
 
         /* Edit menu */
 	ev_window_set_action_sensitive (ev_window, "EditSelectAll", has_pages && can_get_text);
-	ev_window_set_action_sensitive (ev_window, "EditFind",
-			      has_pages && EV_IS_DOCUMENT_FIND (document));
-	ev_window_set_action_sensitive (ev_window, "Slash",
-			      has_pages && EV_IS_DOCUMENT_FIND (document));
+	ev_window_set_action_sensitive (ev_window, "EditFind", can_find);
+	ev_window_set_action_sensitive (ev_window, "Slash", can_find);
 	ev_window_set_action_sensitive (ev_window, "EditRotateLeft", has_pages);
 	ev_window_set_action_sensitive (ev_window, "EditRotateRight", has_pages);
 
@@ -325,6 +377,7 @@ ev_window_setup_action_sensitivity (EvWindow *ev_window)
 	/* 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_update_actions (ev_window);
 }
@@ -386,6 +439,11 @@ ev_window_update_actions (EvWindow *ev_window)
 static void
 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);
+
 	if (window->priv->action_group) {
 		ev_window_set_action_sensitive (window, "PageDown", sensitive);
 		ev_window_set_action_sensitive (window, "PageUp", sensitive);
@@ -395,12 +453,13 @@ ev_window_set_view_accels_sensitivity (EvWindow *window, gboolean sensitive)
 		ev_window_set_action_sensitive (window, "ShiftBackSpace", sensitive);
 		ev_window_set_action_sensitive (window, "Return", sensitive);
 		ev_window_set_action_sensitive (window, "ShiftReturn", sensitive);
-		ev_window_set_action_sensitive (window, "Slash", sensitive);
 		ev_window_set_action_sensitive (window, "Plus", sensitive);
 		ev_window_set_action_sensitive (window, "Minus", sensitive);
 		ev_window_set_action_sensitive (window, "KpPlus", sensitive);
 		ev_window_set_action_sensitive (window, "KpMinus", sensitive);
 		ev_window_set_action_sensitive (window, "Equal", sensitive);
+
+		ev_window_set_action_sensitive (window, "Slash", sensitive && can_find);
 	}
 }
 
@@ -421,6 +480,7 @@ update_chrome_visibility (EvWindow *window)
 	EvWindowPrivate *priv = window->priv;
 	gboolean menubar, toolbar, findbar, fullscreen_toolbar, sidebar;
 	gboolean fullscreen_mode, presentation, fullscreen;
+	gboolean preview_toolbar;
 
 	presentation = ev_view_get_presentation (EV_VIEW (priv->view));
 	fullscreen = ev_view_get_fullscreen (EV_VIEW (priv->view));
@@ -433,11 +493,13 @@ update_chrome_visibility (EvWindow *window)
 			      (priv->chrome & EV_CHROME_RAISE_TOOLBAR) != 0) && fullscreen;
 	findbar = (priv->chrome & EV_CHROME_FINDBAR) != 0;
 	sidebar = (priv->chrome & EV_CHROME_SIDEBAR) != 0 && !fullscreen_mode;
+	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->find_bar, findbar);
 	set_widget_visibility (priv->sidebar, sidebar);
+	set_widget_visibility (priv->preview_toolbar, preview_toolbar);
 
 	ev_window_set_action_sensitive (window, "EditToolbar", toolbar);
 	gtk_widget_set_sensitive (priv->menubar, menubar);
@@ -516,16 +578,6 @@ update_sizing_buttons (EvWindow *window)
 	}
 }
 
-void
-ev_window_open_page_label (EvWindow   *ev_window, 
-			   const char *label)
-{
-	if (ev_window->priv->page_cache) {
-		ev_page_cache_set_page_label (ev_window->priv->page_cache, 
-					      label);
-	}
-}
-
 gboolean
 ev_window_is_empty (const EvWindow *ev_window)
 {
@@ -572,7 +624,15 @@ page_changed_cb (EvPageCache *page_cache,
 		 gint         page,
 		 EvWindow    *ev_window)
 {
+	gchar *label;
+	
 	ev_window_update_actions (ev_window);
+	
+	if (ev_window->priv->history) {
+		label = ev_page_cache_get_page_label (ev_window->priv->page_cache, page);
+		ev_history_add_page (ev_window->priv->history, page, label);
+		g_free (label);
+	}
 
 	if (!ev_window_is_empty (ev_window))
 		ev_metadata_manager_set_int (ev_window->priv->uri, "page", page);
@@ -600,6 +660,7 @@ setup_document_from_metadata (EvWindow *window)
 		new_page = CLAMP (g_value_get_int (&page), 0, ev_page_cache_get_n_pages (window->priv->page_cache) - 1);
 		ev_page_cache_set_current_page (window->priv->page_cache,
 						new_page);
+		g_value_unset (&page);
 	}
 }
 
@@ -612,6 +673,7 @@ setup_chrome_from_metadata (EvWindow *window)
 	if (ev_metadata_manager_get (NULL, "show_toolbar", &show_toolbar, FALSE)) {
 		if (!g_value_get_boolean (&show_toolbar))
 			chrome &= ~EV_CHROME_TOOLBAR;
+		g_value_unset (&show_toolbar);
 	}
 	window->priv->chrome = chrome;
 }
@@ -631,11 +693,12 @@ setup_sidebar_from_metadata (EvWindow *window, EvDocument *document)
 	if (ev_metadata_manager_get (uri, "sidebar_size", &sidebar_size, FALSE)) {
 		gtk_paned_set_position (GTK_PANED (window->priv->hpaned),
 					g_value_get_int (&sidebar_size));
+		g_value_unset(&sidebar_size);
 	}
 	
 	if (document && ev_metadata_manager_get (uri, "sidebar_page", &sidebar_page, FALSE)) {
 		const char *page_id = g_value_get_string (&sidebar_page);
-
+		
 		if (strcmp (page_id, LINKS_SIDEBAR_ID) == 0 && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (links), document)) {
 			ev_sidebar_set_page (EV_SIDEBAR (sidebar), links);
 		} else if (strcmp (page_id, THUMBNAILS_SIDEBAR_ID) && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (thumbs), document)) {
@@ -643,26 +706,85 @@ setup_sidebar_from_metadata (EvWindow *window, EvDocument *document)
 		} 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);
 		}
+		g_value_unset (&sidebar_page);
 	} else if (document && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (links), document)) {
 		ev_sidebar_set_page (EV_SIDEBAR (sidebar), links);
 	}
 
 	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);
 	}
 }
 
 static void
-setup_view_from_metadata (EvWindow *window)
+setup_size_from_metadata (EvWindow *window)
 {
-	EvView *view = EV_VIEW (window->priv->view);
 	char *uri = window->priv->uri;
-	GEnumValue *enum_value;
 	GValue width = { 0, };
 	GValue height = { 0, };
+	GValue width_ratio = { 0, };
+	GValue height_ratio = { 0, };
 	GValue maximized = { 0, };
 	GValue x = { 0, };
 	GValue y = { 0, };
+
+	if (ev_metadata_manager_get (uri, "window_maximized", &maximized, FALSE)) {
+		if (g_value_get_boolean (&maximized)) {
+			gtk_window_maximize (GTK_WINDOW (window));
+			return;
+		} else {
+			gtk_window_unmaximize (GTK_WINDOW (window));
+		}
+		g_value_unset (&maximized);
+	}
+
+	if (ev_metadata_manager_get (uri, "window_x", &x, TRUE) &&
+	    ev_metadata_manager_get (uri, "window_y", &y, TRUE)) {
+		gtk_window_move (GTK_WINDOW (window), g_value_get_int (&x),
+				 g_value_get_int (&y));
+	        g_value_unset (&x);
+	        g_value_unset (&y);
+	}
+
+        if (ev_metadata_manager_get (uri, "window_width", &width, TRUE) &&
+	    ev_metadata_manager_get (uri, "window_height", &height, TRUE)) {
+		gtk_window_resize (GTK_WINDOW (window),
+				   g_value_get_int (&width),
+				   g_value_get_int (&height));
+	    	g_value_unset (&width);
+		g_value_unset (&height);
+		return;
+	}
+
+        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;
+
+		ev_page_cache_get_max_width (window->priv->page_cache, 
+					     0, 1.0,
+					     &document_width);
+		ev_page_cache_get_max_height (window->priv->page_cache, 
+					     0, 1.0,
+					     &document_height);			
+		
+		gtk_window_resize (GTK_WINDOW (window),
+				   g_value_get_double (&width_ratio) * document_width,
+				   g_value_get_double (&height_ratio) * document_height);
+	    	g_value_unset (&width_ratio);
+		g_value_unset (&height_ratio);
+	}
+
+}
+
+static void
+setup_view_from_metadata (EvWindow *window)
+{
+	EvView *view = EV_VIEW (window->priv->view);
+	char *uri = window->priv->uri;
+	GEnumValue *enum_value;
 	GValue sizing_mode = { 0, };
 	GValue zoom = { 0, };
 	GValue continuous = { 0, };
@@ -670,31 +792,16 @@ setup_view_from_metadata (EvWindow *window)
 	GValue presentation = { 0, };
 	GValue fullscreen = { 0, };
 	GValue rotation = { 0, };
-	gboolean restore_size = TRUE;
-
-	/* Window size */
+	GValue maximized = { 0, };
 
+	/* Maximized */
 	if (ev_metadata_manager_get (uri, "window_maximized", &maximized, FALSE)) {
 		if (g_value_get_boolean (&maximized)) {
 			gtk_window_maximize (GTK_WINDOW (window));
-			restore_size = FALSE;
 		} else {
 			gtk_window_unmaximize (GTK_WINDOW (window));
 		}
-	}
-
-	if (restore_size &&
-	    ev_metadata_manager_get (uri, "window_width", &width, TRUE) &&
-            ev_metadata_manager_get (uri, "window_height", &height, TRUE)) {
-		gtk_window_resize (GTK_WINDOW (window),
-				   g_value_get_int (&width),
-				   g_value_get_int (&height));
-	}
-	if (restore_size &&
-	    ev_metadata_manager_get (uri, "window_x", &x, TRUE) &&
-	    ev_metadata_manager_get (uri, "window_y", &y, TRUE)) {
-		gtk_window_move (GTK_WINDOW (window), g_value_get_int (&x),
-				 g_value_get_int (&y));
+		g_value_unset (&maximized);
 	}
 
 	/* Sizing mode */
@@ -709,16 +816,19 @@ setup_view_from_metadata (EvWindow *window)
 	if (ev_metadata_manager_get (uri, "zoom", &zoom, FALSE) &&
 	    ev_view_get_sizing_mode (view) == EV_SIZING_FREE) {
 		ev_view_set_zoom (view, g_value_get_double (&zoom), FALSE);
+		g_value_unset (&zoom);
 	}
 
 	/* Continuous */
 	if (ev_metadata_manager_get (uri, "continuous", &continuous, FALSE)) {
 		ev_view_set_continuous (view, g_value_get_boolean (&continuous));
+		g_value_unset (&continuous);
 	}
 
 	/* Dual page */
 	if (ev_metadata_manager_get (uri, "dual-page", &dual_page, FALSE)) {
 		ev_view_set_dual_page (view, g_value_get_boolean (&dual_page));
+		g_value_unset (&dual_page);
 	}
 
 	/* Presentation */
@@ -726,6 +836,7 @@ setup_view_from_metadata (EvWindow *window)
 		if (g_value_get_boolean (&presentation) && uri) {
 			ev_window_run_presentation (window);
 		}
+		g_value_unset (&presentation);
 	}
 
 	/* Fullscreen */
@@ -733,6 +844,7 @@ setup_view_from_metadata (EvWindow *window)
 		if (g_value_get_boolean (&fullscreen) && uri) {
 			ev_window_run_fullscreen (window);
 		}
+		g_value_unset (&fullscreen);
 	}
 
 	/* Rotation */
@@ -752,6 +864,7 @@ setup_view_from_metadata (EvWindow *window)
 					break;
 			}
 		}
+		g_value_unset (&rotation);
 	}
 }
 
@@ -789,11 +902,19 @@ ev_window_setup_document (EvWindow *ev_window)
 	ev_page_action_set_document (EV_PAGE_ACTION (action), document);
 	ev_window_setup_action_sensitivity (ev_window);
 
+	if (ev_window->priv->history)
+		g_object_unref (ev_window->priv->history);
+	ev_window->priv->history = ev_history_new ();
+	action = gtk_action_group_get_action (ev_window->priv->action_group, NAVIGATION_ACTION);
+        ev_navigation_action_set_history (EV_NAVIGATION_ACTION (action), ev_window->priv->history);
+        ev_navigation_action_set_window (EV_NAVIGATION_ACTION (action), ev_window);
+	
 	if (ev_window->priv->properties) {
 		ev_properties_dialog_set_document (EV_PROPERTIES_DIALOG (ev_window->priv->properties),
 					           ev_window->priv->document);
 	}
 	
+	setup_size_from_metadata (ev_window);
 	setup_document_from_metadata (ev_window);
 	setup_sidebar_from_metadata (ev_window, document);
 
@@ -813,7 +934,7 @@ password_dialog_response (GtkWidget *password_dialog,
 		password = ev_password_dialog_get_password (EV_PASSWORD_DIALOG (password_dialog));
 		if (password) {
 			ev_document_doc_mutex_lock ();
-			ev_document_security_set_password (EV_DOCUMENT_SECURITY (ev_window->priv->password_document),
+			ev_document_security_set_password (EV_DOCUMENT_SECURITY (ev_window->priv->xfer_job->document),
 							   password);
 			ev_document_doc_mutex_unlock ();
 		}
@@ -821,13 +942,10 @@ password_dialog_response (GtkWidget *password_dialog,
 
 		ev_password_dialog_save_password (EV_PASSWORD_DIALOG (password_dialog));
 
-		g_object_unref (ev_window->priv->password_document);
-		ev_window->priv->password_document = NULL;
-
 		ev_window_title_set_type (ev_window->priv->title, EV_WINDOW_TITLE_DOCUMENT);
 		ev_job_queue_add_job (ev_window->priv->xfer_job, EV_JOB_PRIORITY_HIGH);
 		
-    		gtk_widget_destroy (password_dialog);
+		gtk_widget_destroy (password_dialog);
 			
 		return;
 	}
@@ -843,7 +961,7 @@ password_dialog_response (GtkWidget *password_dialog,
 static void
 ev_window_popup_password_dialog (EvWindow *ev_window)
 {
-	g_assert (ev_window->priv->password_document);
+	g_assert (ev_window->priv->xfer_job);
 
 	gtk_widget_set_sensitive (ev_window->priv->password_view, FALSE);
 
@@ -889,7 +1007,7 @@ ev_window_clear_local_uri (EvWindow *ev_window)
     if (ev_window->priv->local_uri) {
 	    filename = g_filename_from_uri (ev_window->priv->local_uri, NULL, NULL);
 	    if (filename != NULL) {
-		    unlink (filename);
+		    g_unlink (filename);
 		    g_free (filename);
 	    }
 	    g_free (ev_window->priv->local_uri);
@@ -897,6 +1015,35 @@ ev_window_clear_local_uri (EvWindow *ev_window)
     }
 }
 
+static void
+ev_window_clear_temp_file (EvWindow *ev_window)
+{
+	GnomeVFSURI *uri;
+	gchar       *filename;
+	const gchar *tempdir;
+
+	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;
+
+	tempdir = g_get_tmp_dir ();
+	if (g_ascii_strncasecmp (filename, tempdir, strlen (tempdir)) == 0) {
+		g_unlink (filename);
+	}
+
+	g_free (filename);
+}
+
 /* This callback will executed when load job will be finished.
  *
  * Since the flow of the error dialog is very confusing, we assume that both
@@ -916,35 +1063,47 @@ ev_window_xfer_job_cb  (EvJobXfer *job,
 	
 	ev_view_set_loading (EV_VIEW (ev_window->priv->view), FALSE);
 
-	if (ev_window->priv->password_document) {
-		g_object_unref (ev_window->priv->password_document);
-		ev_window->priv->password_document = NULL;
-	}
-
 	/* Success! */
 	if (job->error == NULL) {
 
-		g_free (ev_window->priv->uri);
+		if (ev_window->priv->uri)
+			g_free (ev_window->priv->uri);
 		ev_window->priv->uri = g_strdup (job->uri);
-		setup_view_from_metadata (ev_window);
 
-		if (job->local_uri) {
-			ev_window->priv->local_uri = g_strdup (job->local_uri);
-		} else {
-			ev_window->priv->local_uri = NULL;
-		}
+		if (ev_window->priv->local_uri)
+			g_free (ev_window->priv->local_uri);
+		ev_window->priv->local_uri = 
+		    job->local_uri ? g_strdup (job->local_uri) : NULL;
 		
 		if (ev_window->priv->document)
 			g_object_unref (ev_window->priv->document);
 		ev_window->priv->document = g_object_ref (document);
-		
+
+		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_setup_document (ev_window);
-		ev_window_add_recent (ev_window, ev_window->priv->uri);		
-		ev_window_clear_xfer_job (ev_window);
 
-		if (ev_window->priv->dest)
-			ev_window_goto_dest (ev_window, ev_window->priv->dest);
-		
+		if (job->dest)
+			ev_window_goto_dest (ev_window, job->dest);
+
+		switch (job->mode) {
+		        case EV_WINDOW_MODE_FULLSCREEN:
+				ev_window_run_fullscreen (ev_window);
+				break;
+		        case EV_WINDOW_MODE_PRESENTATION:
+				ev_window_run_presentation (ev_window);
+				break;
+		        case EV_WINDOW_MODE_PREVIEW:
+				ev_window_run_preview (ev_window);
+				break;
+		        default:
+				break;
+		}
+
+		ev_window_clear_xfer_job (ev_window);		
 		return;
 	}
 
@@ -956,8 +1115,6 @@ ev_window_xfer_job_cb  (EvJobXfer *job,
 		ev_window->priv->uri = g_strdup (job->uri);
 		setup_view_from_metadata (ev_window);
 
-		ev_window->priv->password_document = g_object_ref (document);
-
 		file_name = gnome_vfs_format_uri_for_display (job->uri);
 		base_name = g_path_get_basename (file_name);
 		ev_password_view_set_file_name (EV_PASSWORD_VIEW (ev_window->priv->password_view),
@@ -965,7 +1122,7 @@ ev_window_xfer_job_cb  (EvJobXfer *job,
 		g_free (file_name);
 		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), 
@@ -989,37 +1146,39 @@ ev_window_close_dialogs (EvWindow *ev_window)
 	if (ev_window->priv->password_dialog)
 		gtk_widget_destroy (ev_window->priv->password_dialog);
 	ev_window->priv->password_dialog = NULL;
+	
+#ifdef WITH_PRINT
+	if (ev_window->priv->print_dialog)
+		gtk_widget_destroy (ev_window->priv->print_dialog);
+	ev_window->priv->print_dialog = NULL;
+#endif
 
 #ifdef WITH_GNOME_PRINT
-	if (ev_window->priv->print_dialog) {
-		gtk_widget_destroy (ev_window->priv->print_dialog);
+	if (ev_window->priv->print_job)
 		g_object_unref (ev_window->priv->print_job);
-	}
-	ev_window->priv->print_dialog = NULL;
 	ev_window->priv->print_job = NULL;
 #endif
-
+	
 	if (ev_window->priv->properties)
 		gtk_widget_destroy (ev_window->priv->properties);
 	ev_window->priv->properties = NULL;
 }
 
 void
-ev_window_open_uri (EvWindow *ev_window, const char *uri, EvLinkDest *dest)
+ev_window_open_uri (EvWindow       *ev_window,
+		    const char     *uri,
+		    EvLinkDest     *dest,
+		    EvWindowRunMode mode,
+		    gboolean        unlink_temp_file)
 {
-	g_free (ev_window->priv->uri);
-	ev_window->priv->uri = NULL;
-
-	if (ev_window->priv->dest)
-		g_object_unref (ev_window->priv->dest);
-	ev_window->priv->dest = dest ? g_object_ref (dest) : NULL;
-	
 	ev_window_close_dialogs (ev_window);
 	ev_window_clear_xfer_job (ev_window);
 	ev_window_clear_local_uri (ev_window);
 	ev_view_set_loading (EV_VIEW (ev_window->priv->view), TRUE);
+
+	ev_window->priv->unlink_temp_file = unlink_temp_file;
 	
-	ev_window->priv->xfer_job = ev_job_xfer_new (uri);
+	ev_window->priv->xfer_job = ev_job_xfer_new (uri, dest, mode);
 	g_signal_connect (ev_window->priv->xfer_job,
 			  "finished",
 			  G_CALLBACK (ev_window_xfer_job_cb),
@@ -1043,7 +1202,9 @@ file_open_dialog_response_cb (GtkWidget *chooser,
 
 		uris = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (chooser));
 
-		ev_application_open_uri_list (EV_APP, uris, GDK_CURRENT_TIME);
+		ev_application_open_uri_list (EV_APP, uris,
+					      gtk_window_get_screen (GTK_WINDOW (ev_window)),
+					      GDK_CURRENT_TIME);
 	
 		g_slist_foreach (uris, (GFunc)g_free, NULL);	
 		g_slist_free (uris);
@@ -1070,9 +1231,13 @@ ev_window_cmd_file_open (GtkAction *action, EvWindow *window)
 	ev_document_factory_add_filters (chooser, NULL);
 	gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (chooser), TRUE);
 	gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (chooser), FALSE);
-	if (ev_application_get_chooser_uri (EV_APP) != NULL)
+	if (ev_application_get_chooser_uri (EV_APP) != NULL) {
 		gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (chooser),
 					  ev_application_get_chooser_uri (EV_APP));
+	} else if (window->priv->uri != NULL) {
+		gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (chooser),
+					  window->priv->uri);
+	}
 	
 	g_signal_connect (chooser, "response",
 			  G_CALLBACK (file_open_dialog_response_cb),
@@ -1081,6 +1246,119 @@ ev_window_cmd_file_open (GtkAction *action, EvWindow *window)
 	gtk_widget_show (chooser);
 }
 
+static gchar *
+ev_window_create_tmp_symlink (const gchar *filename, GError **error)
+{
+	gchar *tmp_filename = NULL;
+	gchar *name;
+	gint   res;
+	guint  i = 0;
+
+	name = g_path_get_basename (filename);
+	
+	do {
+		gchar *basename;
+
+		if (tmp_filename)
+			g_free (tmp_filename);
+
+		basename = g_strdup_printf ("%s-%d", name, i++);
+		tmp_filename = g_build_filename (ev_tmp_dir (),
+						 basename, NULL);
+		
+		g_free (basename);
+	} while ((res = symlink (filename, tmp_filename)) != 0 && errno == EEXIST);
+
+	g_free (name);
+	
+	if (res != 0 && errno != EEXIST) {
+		if (error) {
+			*error = g_error_new (G_FILE_ERROR,
+					      g_file_error_from_errno (errno),
+					      _("Couldn't create symlink “%s”: %s"),
+					      tmp_filename, strerror (errno));
+		}
+
+		g_free (tmp_filename);
+
+		return NULL;
+	}
+	
+	return tmp_filename;
+}
+
+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);
+	new_filename = ev_window_create_tmp_symlink (old_filename, &error);
+
+	if (error) {
+		ev_window_error_dialog (GTK_WINDOW (window),
+					_("Cannot open a copy."),
+					error);
+
+		g_error_free (error);
+		g_free (old_filename);
+		g_free (new_filename);
+
+		return;
+	}
+		
+	g_free (old_filename);
+
+	symlink_uri = g_filename_to_uri (new_filename, NULL, NULL);
+	g_free (new_filename);
+
+	ev_application_open_uri_at_dest (EV_APP,
+					 symlink_uri,
+					 gtk_window_get_screen (GTK_WINDOW (window)),
+					 dest,
+					 0,
+					 TRUE,
+					 GDK_CURRENT_TIME);
+	g_free (symlink_uri);
+}
+
+static void
+ev_window_cmd_file_open_copy (GtkAction *action, EvWindow *window)
+{
+	EvPageCache *page_cache;
+	EvLinkDest  *dest;
+	gint         current_page;
+
+	page_cache = ev_page_cache_get (window->priv->document);
+	current_page = ev_page_cache_get_current_page (page_cache);
+	
+	dest = ev_link_dest_new_page (current_page);
+	ev_window_cmd_file_open_copy_at_dest (window, dest);
+	g_object_unref (dest);
+}
+
+#ifdef HAVE_GTK_RECENT
+static void
+ev_window_cmd_recent_file_activate (GtkAction     *action,
+				    EvWindow      *window)
+{
+	GtkRecentInfo *info;
+	const gchar   *uri;
+
+	info = g_object_get_data (G_OBJECT (action), "gtk-recent-info");
+	g_assert (info != NULL);
+	
+	uri = gtk_recent_info_get_uri (info);
+	
+	ev_application_open_uri_at_dest (EV_APP, uri,
+					 gtk_window_get_screen (GTK_WINDOW (window)),
+					 NULL, 0, FALSE,
+					 GDK_CURRENT_TIME);
+}
+#else
 static void
 ev_window_cmd_recent_file_activate (GtkAction *action,
         	                    EvWindow *ev_window)
@@ -1093,25 +1371,173 @@ ev_window_cmd_recent_file_activate (GtkAction *action,
 
 	uri = egg_recent_item_get_uri (item);
 
-	ev_application_open_uri (EV_APP, uri, NULL, GDK_CURRENT_TIME, NULL);
+	ev_application_open_uri (EV_APP, uri, NULL,
+				 GDK_CURRENT_TIME, NULL);
 	
 	g_free (uri);
 }
+#endif /* HAVE_GTK_RECENT */
 
 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);
+#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)
+{
+	gboolean     has_ev_a, has_ev_b;
+	const gchar *evince = g_get_application_name ();
+
+	has_ev_a = gtk_recent_info_has_application (a, evince);
+	has_ev_b = gtk_recent_info_has_application (b, evince);
+	
+	if (has_ev_a && has_ev_b) {
+		time_t time_a, time_b;
+
+		time_a = gtk_recent_info_get_modified (a);
+		time_b = gtk_recent_info_get_modified (b);
+
+		return (time_b - time_a);
+	} else if (has_ev_a) {
+		return -1;
+	} else if (has_ev_b) {
+		return 1;
+	}
+
+	return 0;
+}
+#endif /* HAVE_GTK_RECENT */
+
+/*
+ * Doubles underscore to avoid spurious menu accels.
+ */
+static gchar * 
+ev_window_get_recent_file_label (gint index, const gchar *filename)
+{
+	GString *str;
+	gint length;
+	const gchar *p;
+	const gchar *end;
+ 
+	g_return_val_if_fail (filename != NULL, NULL);
+	
+	length = strlen (filename);
+	str = g_string_sized_new (length + 10);
+	g_string_printf (str, "_%d.  ", index);
+
+	p = filename;
+	end = filename + length;
+ 
+	while (p != end)
+	{
+		const gchar *next;
+		next = g_utf8_next_char (p);
+ 
+		switch (*p)
+		{
+			case '_':
+				g_string_append (str, "__");
+				break;
+			default:
+				g_string_append_len (str, p, next - p);
+				break;
+		}
+ 
+		p = next;
+	}
+ 
+	return g_string_free (str, FALSE);
 }
 
 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 ();
+	static guint  i = 0;
+
+	if (ev_window->priv->recent_ui_id > 0) {
+		gtk_ui_manager_remove_ui (ev_window->priv->ui_manager,
+					  ev_window->priv->recent_ui_id);
+		gtk_ui_manager_ensure_update (ev_window->priv->ui_manager);
+	}
+	ev_window->priv->recent_ui_id = gtk_ui_manager_new_merge_id (ev_window->priv->ui_manager);
+
+	if (ev_window->priv->recent_action_group) {
+		gtk_ui_manager_remove_action_group (ev_window->priv->ui_manager,
+						    ev_window->priv->recent_action_group);
+		g_object_unref (ev_window->priv->recent_action_group);
+	}
+	ev_window->priv->recent_action_group = gtk_action_group_new ("RecentFilesActions");
+	gtk_ui_manager_insert_action_group (ev_window->priv->ui_manager,
+					    ev_window->priv->recent_action_group, 0);
+
+	items = gtk_recent_manager_get_items (ev_window->priv->recent_manager);
+	items = g_list_sort (items, (GCompareFunc) compare_recent_items);
+
+	for (l = items; l && l->data; l = g_list_next (l)) {
+		GtkRecentInfo *info;
+		GtkAction     *action;
+		gchar         *action_name;
+		gchar         *label;
+
+		info = (GtkRecentInfo *) l->data;
 
+		if (!gtk_recent_info_has_application (info, evince))
+			continue;
+
+		action_name = g_strdup_printf ("RecentFile%u", i++);
+		label = ev_window_get_recent_file_label (
+			n_items + 1, gtk_recent_info_get_display_name (info));
+		
+		action = g_object_new (GTK_TYPE_ACTION,
+				       "name", action_name,
+				       "label", label,
+				       NULL);
+
+		g_object_set_data_full (G_OBJECT (action),
+					"gtk-recent-info",
+					gtk_recent_info_ref (info),
+					(GDestroyNotify) gtk_recent_info_unref);
+		
+		g_signal_connect (G_OBJECT (action), "activate",
+				  G_CALLBACK (ev_window_cmd_recent_file_activate),
+				  (gpointer) ev_window);
+
+		gtk_action_group_add_action (ev_window->priv->recent_action_group,
+					     action);
+		g_object_unref (action);
+
+		gtk_ui_manager_add_ui (ev_window->priv->ui_manager,
+				       ev_window->priv->recent_ui_id,
+				       "/MainMenu/FileMenu/RecentFilesMenu",
+				       label,
+				       action_name,
+				       GTK_UI_MANAGER_MENUITEM,
+				       FALSE);
+		g_free (action_name);
+		g_free (label);
+
+		if (++n_items == 5)
+			break;
+	}
+	
+	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), 
@@ -1126,6 +1552,7 @@ ev_window_setup_recent (EvWindow *ev_window)
 	
 	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
@@ -1147,7 +1574,7 @@ file_save_dialog_response_cb (GtkWidget *fc,
 
 		if (err) {
 			gchar *msg;
-			msg = g_strdup_printf (_("The file could not be saved as \"%s\"."), uri);
+			msg = g_strdup_printf (_("The file could not be saved as “%s”."), uri);
 			ev_window_error_dialog (GTK_WINDOW (fc), msg, err);
 			g_free (msg);
 		}
@@ -1189,85 +1616,367 @@ ev_window_cmd_save_as (GtkAction *action, EvWindow *ev_window)
 	gtk_widget_show (fc);
 }
 
+#ifdef WITH_GTK_PRINT
 static void
-ev_window_print (EvWindow *window)
+ev_window_print_page_setup_done_cb (GtkPageSetup *page_setup,
+				    EvWindow     *window)
 {
-	EvPageCache *page_cache;
-	int last_page;
+	/* Dialog was canceled */
+	if (!page_setup)
+		return;
 
-	page_cache = ev_page_cache_get (window->priv->document);
-	last_page = ev_page_cache_get_n_pages (page_cache);
+	if (window->priv->print_page_setup)
+		g_object_unref (window->priv->print_page_setup);
+	window->priv->print_page_setup = g_object_ref (page_setup);
+}
+#endif /* WITH_GTK_PRINT */
 
-#ifdef WITH_GNOME_PRINT
-	ev_window_print_range (window, 1, last_page);
-#endif
+static void
+ev_window_cmd_file_print_setup (GtkAction *action, EvWindow *ev_window)
+{
+#ifdef WITH_GTK_PRINT
+	gtk_print_run_page_setup_dialog_async (
+		GTK_WINDOW (ev_window),
+		ev_window->priv->print_page_setup,
+		ev_window->priv->print_settings,
+		(GtkPageSetupDoneFunc) ev_window_print_page_setup_done_cb,
+		ev_window);
+#endif /* WITH_GTK_PRINT */
+}
+
+#ifdef WITH_GTK_PRINT
+static void
+ev_window_clear_print_job (EvWindow *window)
+{
+	if (window->priv->print_job) {
+		if (!window->priv->print_job->finished)
+			ev_job_queue_remove_job (window->priv->print_job);
+
+		g_signal_handlers_disconnect_by_func (window->priv->print_job,
+						      ev_window_print_job_cb,
+						      window);
+		g_object_unref (window->priv->print_job);
+		window->priv->print_job = NULL;
+	}
+}
+
+static void
+ev_window_print_finished (GtkPrintJob *print_job,
+			  EvWindow    *window,
+			  GError      *error)
+{
+	ev_window_clear_print_job (window);
+	
+	if (error) {
+		GtkWidget *dialog;
+		
+		dialog = gtk_message_dialog_new (GTK_WINDOW (window),
+						 GTK_DIALOG_MODAL,
+						 GTK_MESSAGE_ERROR,
+						 GTK_BUTTONS_OK,
+						 _("Failed to print document"));
+		gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
+							  error->message);
+
+		gtk_dialog_run (GTK_DIALOG (dialog));
+		gtk_widget_destroy (dialog);
+	}
+}
+
+static void
+ev_window_print_send (EvWindow    *window,
+		      const gchar *filename)
+{
+	GtkPrintJob *job;
+	GError      *error = NULL;
+	
+	if (window->priv->gtk_print_job)
+		g_object_unref (window->priv->gtk_print_job);
+	
+	job = gtk_print_job_new ("evince-print",
+				 window->priv->printer,
+				 window->priv->print_settings,
+				 window->priv->print_page_setup);
+	
+	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);
+	}
 }
 
+static void
+ev_window_print_job_cb (EvJobPrint *job,
+			EvWindow   *window)
+{
+	if (job->error) {
+		g_warning (job->error->message);
+		ev_window_clear_print_job (window);
+		return;
+	}
+
+	g_assert (job->temp_file != NULL);
+
+	ev_window_print_send (window, job->temp_file);
+}
+
+static gboolean
+ev_window_print_dialog_response_cb (GtkDialog *dialog,
+				    gint       response,
+				    EvWindow  *window)
+{
+	EvPrintRange  *ranges = NULL;
+	EvPrintPageSet page_set;
+	gint           n_ranges = 0;
+	gint           copies;
+	gboolean       collate;
+	gboolean       reverse;
+	gdouble        scale;
+	gint           current_page;
+	gdouble        width;
+	gdouble        height;
+	GtkPrintPages  print_pages;
+	
+	if (response != GTK_RESPONSE_OK) {
+		gtk_widget_destroy (GTK_WIDGET (dialog));
+		window->priv->print_dialog = NULL;
+
+		return FALSE;
+	}
+
+	if (window->priv->printer)
+		g_object_unref (window->priv->printer);
+	if (window->priv->print_settings)
+		g_object_unref (window->priv->print_settings);
+	if (window->priv->print_page_setup)
+		g_object_unref (window->priv->print_page_setup);
+	
+	window->priv->printer = g_object_ref (
+		gtk_print_unix_dialog_get_selected_printer (GTK_PRINT_UNIX_DIALOG (dialog)));
+	window->priv->print_settings = g_object_ref (
+		gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (dialog)));
+	window->priv->print_page_setup = g_object_ref (
+		gtk_print_unix_dialog_get_page_setup (GTK_PRINT_UNIX_DIALOG (dialog)));
+
+	if (!gtk_printer_accepts_ps (window->priv->printer)) {
+		GtkWidget *msgdialog;
+
+		msgdialog = gtk_message_dialog_new (GTK_WINDOW (dialog),
+						    GTK_DIALOG_MODAL,
+						    GTK_MESSAGE_ERROR,
+						    GTK_BUTTONS_OK,
+						    _("Printing is not supported on this printer."));
+		
+		gtk_dialog_run (GTK_DIALOG (msgdialog));
+		gtk_widget_destroy (msgdialog);
+
+		return FALSE;
+	}
+
+	ev_window_clear_print_job (window);
+	
+	current_page = gtk_print_unix_dialog_get_current_page (GTK_PRINT_UNIX_DIALOG (dialog));
+	print_pages = gtk_print_settings_get_print_pages (window->priv->print_settings);
+	
+	switch (print_pages) {
+	case GTK_PRINT_PAGES_CURRENT:
+		ranges = g_new0 (EvPrintRange, 1);
+		
+		ranges->start = current_page;
+		ranges->end = current_page;
+		n_ranges = 1;
+				
+		break;
+	case GTK_PRINT_PAGES_RANGES: {
+		GtkPageRange *page_range;
+		
+		page_range = gtk_print_settings_get_page_ranges (window->priv->print_settings,
+								 &n_ranges);
+		if (n_ranges > 0)
+			ranges = g_memdup (page_range, n_ranges * sizeof (GtkPageRange));
+	}
+		break;
+	default:
+		break;
+	}
+
+	page_set = (EvPrintPageSet)gtk_print_settings_get_page_set (window->priv->print_settings);
+
+	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);
+	height = gtk_page_setup_get_paper_height (window->priv->print_page_setup,
+						  GTK_UNIT_PIXEL);
+
+	if (scale != 1.0) {
+		width *= scale;
+		height *= scale;
+	}
+
+	copies = gtk_print_settings_get_n_copies (window->priv->print_settings);
+	collate = gtk_print_settings_get_collate (window->priv->print_settings);
+	reverse = gtk_print_settings_get_reverse (window->priv->print_settings);
+	
+	window->priv->print_job = ev_job_print_new (window->priv->document,
+						    width, height,
+						    ranges, n_ranges,
+						    page_set,
+						    copies, collate,
+						    reverse);
+	
+	g_signal_connect (window->priv->print_job, "finished",
+			  G_CALLBACK (ev_window_print_job_cb),
+			  window);
+	/* The priority doesn't matter for this job */
+	ev_job_queue_add_job (window->priv->print_job, EV_JOB_PRIORITY_LOW);
+	
+	gtk_widget_destroy (GTK_WIDGET (dialog));
+	window->priv->print_dialog = NULL;
+
+	return TRUE;
+}
+
+void
+ev_window_print_range (EvWindow *ev_window, int first_page, int last_page)
+{
+	GtkWidget   *dialog;
+	EvPageCache *page_cache;
+	gint         current_page;
+	gint         document_last_page;
+
+	g_return_if_fail (EV_IS_WINDOW (ev_window));
+	g_return_if_fail (ev_window->priv->document != NULL);
+
+	if (ev_window->priv->print_dialog) {
+		gtk_window_present (GTK_WINDOW (ev_window->priv->print_dialog));
+		return;
+	}
+	
+	page_cache = ev_page_cache_get (ev_window->priv->document);
+	current_page = ev_page_cache_get_current_page (page_cache);
+	document_last_page = ev_page_cache_get_n_pages (page_cache);
+
+	if (!ev_window->priv->print_settings)
+		ev_window->priv->print_settings = gtk_print_settings_new ();
+
+	if (first_page != 1 || last_page != document_last_page) {
+		GtkPageRange range;
+
+		/* Ranges in GtkPrint are 0 - N */
+		range.start = first_page - 1;
+		range.end = last_page - 1;
+		
+		gtk_print_settings_set_print_pages (ev_window->priv->print_settings,
+						    GTK_PRINT_PAGES_RANGES);
+		gtk_print_settings_set_page_ranges (ev_window->priv->print_settings,
+						    &range, 1);
+	}
+
+	dialog = gtk_print_unix_dialog_new (_("Print"), GTK_WINDOW (ev_window));
+	ev_window->priv->print_dialog = dialog;
+	gtk_print_unix_dialog_set_manual_capabilities (GTK_PRINT_UNIX_DIALOG (dialog),
+						       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);
+
+	gtk_print_unix_dialog_set_current_page (GTK_PRINT_UNIX_DIALOG (dialog),
+						current_page);
+	
+	gtk_print_unix_dialog_set_settings (GTK_PRINT_UNIX_DIALOG (dialog),
+					    ev_window->priv->print_settings);
+	
+	if (ev_window->priv->print_page_setup)
+		gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (dialog),
+						      ev_window->priv->print_page_setup);
+	
+	g_signal_connect (G_OBJECT (dialog), "response",
+			  G_CALLBACK (ev_window_print_dialog_response_cb),
+			  ev_window);
+
+	gtk_widget_show (dialog);
+}
+#endif /* WITH_GTK_PRINT */
 
 #ifdef WITH_GNOME_PRINT
 static gboolean
-ev_window_print_dialog_response_cb (GtkDialog *print_dialog, gint response, gpointer data)
+ev_window_print_dialog_response_cb (GtkDialog *print_dialog,
+				    gint       response,
+				    EvWindow  *ev_window)
 {
-    EvWindow *ev_window = EV_WINDOW (data);
-    EvPrintJob *print_job;
-    GnomePrintConfig *config;
+	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;
-    }
+	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;
-    }
+	config = gnome_print_dialog_get_config (GNOME_PRINT_DIALOG (print_dialog));
 
-    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);
+	/* 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;
+	}
 
-    if (print_job != NULL) {
-	ev_print_job_print (print_job, GTK_WINDOW (ev_window));
-	g_object_unref (print_job);
-    }
+	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);
+	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;
+	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;
+	return FALSE;
 }
 
 void
@@ -1284,11 +1993,16 @@ ev_window_print_range (EvWindow *ev_window, int first_page, int last_page)
 	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));								
+	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);
@@ -1303,12 +2017,27 @@ ev_window_print_range (EvWindow *ev_window, int first_page, int last_page)
 					   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);
+	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);
-	return;
 }
 #endif /* WITH_GNOME_PRINT */
-	
+
+static void
+ev_window_print (EvWindow *window)
+{
+	EvPageCache *page_cache;
+	gint         last_page;
+
+	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);
+#endif
+}
+
 static void
 ev_window_cmd_file_print (GtkAction *action, EvWindow *ev_window)
 {
@@ -1554,9 +2283,12 @@ fullscreen_popup_size_request_cb (GtkWidget *popup, GtkRequisition *req, EvWindo
 }
 
 static gboolean
-fullscreen_timeout_cb (gpointer data)
+fullscreen_timeout_cb (EvWindow *window)
 {
-	EvWindow *window = EV_WINDOW (data);
+	EvView *view = EV_VIEW (window->priv->view);
+
+	if (!view || !ev_view_get_fullscreen (EV_VIEW (view)))
+		return FALSE;
 	
 	update_chrome_flag (window, EV_CHROME_FULLSCREEN_TOOLBAR, FALSE);
 	ev_view_hide_cursor (EV_VIEW (window->priv->view));
@@ -1573,7 +2305,7 @@ fullscreen_set_timeout (EvWindow *window)
 	}
 	
 	window->priv->fullscreen_timeout_id = 
-	    g_timeout_add (FULLSCREEN_TIMEOUT, fullscreen_timeout_cb, window);
+	    g_timeout_add (FULLSCREEN_TIMEOUT, (GSourceFunc)fullscreen_timeout_cb, window);
 
 	update_chrome_flag (window, EV_CHROME_FULLSCREEN_TOOLBAR, TRUE);
 	update_chrome_visibility (window);
@@ -1652,7 +2384,7 @@ ev_window_create_fullscreen_popup (EvWindow *window)
 	GdkScreen *screen;
 
 	window->priv->fullscreen_toolbar = egg_editable_toolbar_new_with_model
-			(window->priv->ui_manager, ev_application_get_toolbars_model (EV_APP), NULL);
+			(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);
@@ -1810,6 +2542,8 @@ ev_window_run_presentation (EvWindow *window)
 			  window);
 	fullscreen_set_timeout (window);
 
+	totem_scrsaver_disable (window->priv->screensaver);
+
 	if (!ev_window_is_empty (window))
 		ev_metadata_manager_set_boolean (window->priv->uri, "presentation", TRUE);
 }
@@ -1836,6 +2570,8 @@ ev_window_stop_presentation (EvWindow *window)
 					      window);
 	fullscreen_clear_timeout (window);
 
+	totem_scrsaver_enable (window->priv->screensaver);
+
 	if (!ev_window_is_empty (window))
 		ev_metadata_manager_set_boolean (window->priv->uri, "presentation", FALSE);
 }
@@ -1856,6 +2592,20 @@ ev_window_cmd_view_presentation (GtkAction *action, EvWindow *window)
 	}
 }
 
+static void
+ev_window_run_preview (EvWindow *window)
+{
+	ev_view_set_continuous (EV_VIEW (window->priv->view), FALSE); 
+	
+	update_chrome_flag (window, EV_CHROME_TOOLBAR, FALSE);
+	update_chrome_flag (window, EV_CHROME_MENUBAR, FALSE);
+	update_chrome_flag (window, EV_CHROME_SIDEBAR, FALSE);
+
+	update_chrome_flag (window, EV_CHROME_PREVIEW_TOOLBAR, TRUE);
+
+	update_chrome_visibility (window);
+}
+
 static gboolean
 ev_window_focus_in_event (GtkWidget *widget, GdkEventFocus *event)
 {
@@ -1890,6 +2640,24 @@ ev_window_screen_changed (GtkWidget *widget,
 	EvWindowPrivate *priv = window->priv;
 	GdkScreen *screen;
 
+	screen = gtk_widget_get_screen (widget);
+	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
+	
 	if (GTK_WIDGET_CLASS (ev_window_parent_class)->screen_changed) {
 		GTK_WIDGET_CLASS (ev_window_parent_class)->screen_changed (widget, old_screen);
 	}
@@ -1898,7 +2666,6 @@ ev_window_screen_changed (GtkWidget *widget,
 		g_signal_handlers_disconnect_by_func
 			(old_screen, G_CALLBACK (screen_size_changed_cb), window);
 
-		screen = gtk_widget_get_screen (widget);
 		g_signal_connect_object (screen, "size-changed",
 					 G_CALLBACK (screen_size_changed_cb),
 					 window, 0);
@@ -1983,7 +2750,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,
-					 ev_application_get_toolbars_model (EV_APP));
+					 ev_application_get_toolbars_model (EV_APP, FALSE));
 	gtk_container_set_border_width (GTK_CONTAINER (editor), 5);
 	gtk_box_set_spacing (GTK_BOX (EGG_TOOLBAR_EDITOR (editor)), 5);
              
@@ -2082,19 +2849,12 @@ static void
 ev_window_cmd_view_reload (GtkAction *action, EvWindow *ev_window)
 {
 	char *uri;
-	int page;
 
 	g_return_if_fail (EV_IS_WINDOW (ev_window));
 
-	page = ev_page_cache_get_current_page (ev_window->priv->page_cache);
 	uri = g_strdup (ev_window->priv->uri);
 
-	ev_window_open_uri (ev_window, uri, NULL);
-
-	/* In case the number of pages in the document has changed. */
-	page = CLAMP (page, 0, ev_page_cache_get_n_pages (ev_window->priv->page_cache) - 1);
-
-	ev_page_cache_set_current_page (ev_window->priv->page_cache, page);
+	ev_window_open_uri (ev_window, uri, NULL, 0, FALSE);
 
 	g_free (uri);
 }
@@ -2138,10 +2898,14 @@ ev_window_cmd_escape (GtkAction *action, EvWindow *window)
 			      "presentation", &presentation,
 			      NULL);
 
-		if (fullscreen)
+		if (fullscreen) {
 			ev_window_stop_fullscreen (window);
-		if (presentation)
+		} else if (presentation) {
 			ev_window_stop_presentation (window);
+			gtk_widget_grab_focus (window->priv->view);
+		} else {
+			gtk_widget_grab_focus (window->priv->view);
+		}
 
 		if (fullscreen && presentation)
 			g_warning ("Both fullscreen and presentation set somehow");
@@ -2326,6 +3090,7 @@ ev_window_dual_mode_changed_cb (EvView *view, GParamSpec *pspec, EvWindow *ev_wi
 static char *
 build_comments_string (void)
 {
+#ifdef ENABLE_PDF
 	PopplerBackend backend;
 	const char *backend_name;
 	const char *version;
@@ -2347,6 +3112,9 @@ build_comments_string (void)
 	return g_strdup_printf (_("PostScript and PDF File Viewer.\n"
 				  "Using poppler %s (%s)"),
 				version, backend_name);
+#else
+	return g_strdup_printf (_("Document Viewer."));
+#endif
 }
 
 static void
@@ -2358,7 +3126,8 @@ ev_window_cmd_help_about (GtkAction *action, EvWindow *ev_window)
 		"Marco Pesenti Gritti <marco@gnome.org>",
 		"Nickolay V. Shmyrev <nshmyrev@yandex.ru>",
 		"Bryan Clark <clarkbw@gnome.org>",
-		"Carlos Garcia Campos  <carlosgc@gnome.org>",
+		"Carlos Garcia Campos <carlosgc@gnome.org>",
+		"Wouter Bolsterlee <wbolster@gnome.org>",
 		NULL
 	};
 
@@ -2403,7 +3172,7 @@ ev_window_cmd_help_about (GtkAction *action, EvWindow *ev_window)
 		"name", _("Evince"),
 		"version", VERSION,
 		"copyright",
-		_("\xc2\xa9 1996-2005 The Evince authors"),
+		_("\xc2\xa9 1996-2007 The Evince authors"),
 		"license", license_trans,
 		"website", "http://www.gnome.org/projects/evince",
 		"comments", comments,
@@ -2470,11 +3239,13 @@ ev_window_sidebar_visibility_changed_cb (EvSidebar  *ev_sidebar,
 	GtkAction *action;
 
 	action = gtk_action_group_get_action (ev_window->priv->action_group, "ViewSidebar");
-	gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
-				      GTK_WIDGET_VISIBLE (ev_sidebar));
 
 	if (!ev_view_get_presentation (view) && 
 	    !ev_view_get_fullscreen (view)) {
+
+		gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
+					      GTK_WIDGET_VISIBLE (ev_sidebar));
+
 		ev_metadata_manager_set_boolean (ev_window->priv->uri, "sidebar_visibility",
 					         GTK_WIDGET_VISIBLE (ev_sidebar));
 	}
@@ -2536,6 +3307,10 @@ view_menu_popup_cb (EvView   *view,
 					      "GoLink");
 	gtk_action_set_visible (action, show_internal);
 
+	action = gtk_action_group_get_action (ev_window->priv->view_popup_action_group,
+					      "OpenLinkNewWindow");
+	gtk_action_set_visible (action, show_internal);
+
 	gtk_menu_popup (GTK_MENU (popup), NULL, NULL,
 			NULL, NULL,
 			3, gtk_get_current_event_time ());
@@ -2701,11 +3476,6 @@ ev_window_dispose (GObject *object)
 		priv->title = NULL;
 	}
 
-	if (priv->recent_view) {
-		g_object_unref (priv->recent_view);
-		priv->recent_view = NULL;
-	}
-
 	if (priv->ui_manager) {
 		g_object_unref (priv->ui_manager);
 		priv->ui_manager = NULL;
@@ -2726,6 +3496,27 @@ ev_window_dispose (GObject *object)
 		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_manager) {
+		g_signal_handlers_disconnect_by_func (priv->recent_manager,
+						      ev_window_setup_recent,
+						      window);
+		priv->recent_manager = NULL;
+	}
+
+	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);
 		priv->page_cache = NULL;
@@ -2741,6 +3532,11 @@ ev_window_dispose (GObject *object)
 		priv->view = NULL;
 	}
 
+	if (priv->password_view) {
+		g_object_unref (priv->password_view);
+		priv->password_view = NULL;
+	}
+
 	if (priv->xfer_job) {
 		ev_window_clear_xfer_job (window);
 	}
@@ -2748,13 +3544,32 @@ ev_window_dispose (GObject *object)
 	if (priv->local_uri) {
 		ev_window_clear_local_uri (window);
 	}
+	
+	ev_window_close_dialogs (window);
 
-	if (priv->password_document) {
-		g_object_unref (priv->password_document);
-		priv->password_document = NULL;
+#ifdef WITH_GTK_PRINT
+	ev_window_clear_print_job (window);
+
+	if (window->priv->gtk_print_job) {
+		g_object_unref (window->priv->gtk_print_job);
+		window->priv->gtk_print_job = NULL;
 	}
 	
-	ev_window_close_dialogs (window);
+	if (window->priv->printer) {
+		g_object_unref (window->priv->printer);
+		window->priv->printer = NULL;
+	}
+
+	if (window->priv->print_settings) {
+		g_object_unref (window->priv->print_settings);
+		window->priv->print_settings = NULL;
+	}
+
+	if (window->priv->print_page_setup) {
+		g_object_unref (window->priv->print_page_setup);
+		window->priv->print_page_setup = NULL;
+	}
+#endif
 
 	if (priv->link) {
 		g_object_unref (priv->link);
@@ -2778,6 +3593,8 @@ ev_window_dispose (GObject *object)
 	}
 
 	if (priv->uri) {
+		if (priv->unlink_temp_file)
+			ev_window_clear_temp_file (window);
 		g_free (priv->uri);
 		priv->uri = NULL;
 	}
@@ -2787,6 +3604,11 @@ ev_window_dispose (GObject *object)
 		priv->dest = NULL;
 	}
 
+	if (priv->history) {
+		g_object_unref (priv->history);
+		priv->history = NULL;
+	}
+
 	if (priv->fullscreen_timeout_id) {
 		g_source_remove (priv->fullscreen_timeout_id);
 		priv->fullscreen_timeout_id = 0;
@@ -2824,9 +3646,15 @@ static const GtkActionEntry entries[] = {
 	{ "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,
+	  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_("Save a copy of the current document"),
 	  G_CALLBACK (ev_window_cmd_save_as) },
+	{ "FilePrintSetup", NULL, N_("Print Set_up..."), NULL,
+	  N_("Setup the page settings for printing"),
+	  G_CALLBACK (ev_window_cmd_file_print_setup) },
 	{ "FilePrint", GTK_STOCK_PRINT, N_("_Print..."), "<control>P",
 	  N_("Print this document"),
 	  G_CALLBACK (ev_window_cmd_file_print) },
@@ -2849,9 +3677,9 @@ static const GtkActionEntry entries[] = {
 	  G_CALLBACK (ev_window_cmd_edit_find_previous) },
         { "EditToolbar", NULL, N_("T_oolbar"), NULL, NULL,
           G_CALLBACK (ev_window_cmd_edit_toolbar) },
-	{ "EditRotateLeft", NULL, N_("Rotate _Left"), NULL, NULL,
+	{ "EditRotateLeft", EV_STOCK_ROTATE_LEFT, N_("Rotate _Left"), NULL, NULL,
 	  G_CALLBACK (ev_window_cmd_edit_rotate_left) },
-	{ "EditRotateRight", NULL, N_("Rotate _Right"), NULL, NULL,
+	{ "EditRotateRight", EV_STOCK_ROTATE_RIGHT, N_("Rotate _Right"), NULL, NULL,
 	  G_CALLBACK (ev_window_cmd_edit_rotate_right) },
 
         /* View menu */
@@ -2939,7 +3767,7 @@ static const GtkActionEntry entries[] = {
 /* Toggle items */
 static const GtkToggleActionEntry toggle_entries[] = {
 	/* View Menu */
-	{ "ViewToolbar", NULL, N_("_Toolbar"), "<shift><control>T",
+	{ "ViewToolbar", NULL, N_("_Toolbar"), NULL,
 	  N_("Show or hide the toolbar"),
 	  G_CALLBACK (ev_window_view_toolbar_cb), TRUE },
         { "ViewSidebar", GTK_STOCK_INDEX, N_("Side _Pane"), "F9",
@@ -2972,6 +3800,8 @@ static const GtkActionEntry view_popup_entries [] = {
 	  NULL, G_CALLBACK (ev_view_popup_cmd_open_link) },
 	{ "GoLink", GTK_STOCK_GO_FORWARD, N_("_Go To"), NULL,
 	  NULL, G_CALLBACK (ev_view_popup_cmd_open_link) },
+	{ "OpenLinkNewWindow", NULL, N_("Open in New _Window"), NULL,
+	  NULL, G_CALLBACK (ev_view_popup_cmd_open_link_new_window) },
 	{ "CopyLinkAddress", NULL, N_("_Copy Link Address"), NULL,
 	  NULL,
 	  G_CALLBACK (ev_view_popup_cmd_copy_link_address) },
@@ -3005,7 +3835,9 @@ drag_data_received_cb (GtkWidget *widget, GdkDragContext *context,
 
 		gnome_vfs_uri_list_free (uri_list);
 		
-		ev_application_open_uri_list (EV_APP, uris, 0);
+		ev_application_open_uri_list (EV_APP, uris,
+					      gtk_widget_get_screen (widget),
+					      0);
 		
 		g_slist_free (uris);
 	}
@@ -3057,6 +3889,17 @@ register_custom_actions (EvWindow *window, GtkActionGroup *group)
 			  G_CALLBACK (zoom_control_changed_cb), window);
 	gtk_action_group_add_action (group, action);
 	g_object_unref (action);
+
+	action = g_object_new (EV_TYPE_NAVIGATION_ACTION,
+			       "name", NAVIGATION_ACTION,
+			       "label", _("Navigation"),
+			       "is_important", TRUE,
+			       "short_label", _("Back"),
+			       "stock_id", GTK_STOCK_GO_DOWN,
+			       "tooltip", _("Move across visited pages"),
+			       NULL);
+	gtk_action_group_add_action (group, action);
+	g_object_unref (action);
 }
 
 static void
@@ -3065,9 +3908,9 @@ set_action_properties (GtkActionGroup *action_group)
 	GtkAction *action;
 
 	action = gtk_action_group_get_action (action_group, "GoPreviousPage");
+	g_object_set (action, "is-important", TRUE, NULL);
 	/*translators: this is the label for toolbar button*/
 	g_object_set (action, "short_label", _("Previous"), NULL);
-	g_object_set (action, "is-important", TRUE, NULL);
 
 	action = gtk_action_group_get_action (action_group, "GoNextPage");
 	g_object_set (action, "is-important", TRUE, NULL);
@@ -3077,22 +3920,18 @@ set_action_properties (GtkActionGroup *action_group)
 	action = gtk_action_group_get_action (action_group, "ViewZoomIn");
 	/*translators: this is the label for toolbar button*/
 	g_object_set (action, "short_label", _("Zoom In"), NULL);
-	action = gtk_action_group_get_action (action_group, "ViewZoomIn");
 
 	action = gtk_action_group_get_action (action_group, "ViewZoomOut");
 	/*translators: this is the label for toolbar button*/
 	g_object_set (action, "short_label", _("Zoom Out"), NULL);
-	action = gtk_action_group_get_action (action_group, "ViewZoomIn");
 
 	action = gtk_action_group_get_action (action_group, "ViewBestFit");
 	/*translators: this is the label for toolbar button*/
 	g_object_set (action, "short_label", _("Best Fit"), NULL);
-	action = gtk_action_group_get_action (action_group, "ViewZoomIn");
 
 	action = gtk_action_group_get_action (action_group, "ViewPageWidth");
 	/*translators: this is the label for toolbar button*/
 	g_object_set (action, "short_label", _("Fit Width"), NULL);
-	action = gtk_action_group_get_action (action_group, "ViewZoomIn");
 
 	action = gtk_action_group_get_action (action_group, "LeaveFullscreen");
 	g_object_set (action, "is-important", TRUE, NULL);
@@ -3189,7 +4028,7 @@ window_configure_event_cb (EvWindow *window, GdkEventConfigure *event, gpointer
 {
 	char *uri = window->priv->uri;
 	GdkWindowState state;
-	int x, y, width, height;
+	int x, y, width, height, document_width, document_height;
 
 	state = gdk_window_get_state (GTK_WIDGET (window)->window);
 
@@ -3197,11 +4036,19 @@ window_configure_event_cb (EvWindow *window, GdkEventConfigure *event, gpointer
 		gtk_window_get_position (GTK_WINDOW (window), &x, &y);
 		gtk_window_get_size (GTK_WINDOW (window), &width, &height);
 
-		if (!ev_window_is_empty (window)) {
+		if (!ev_window_is_empty (window) && window->priv->page_cache) {
+			ev_page_cache_get_max_width (window->priv->page_cache, 
+						     0, 1.0,
+						     &document_width);
+			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_int (uri, "window_width", width);
-			ev_metadata_manager_set_int (uri, "window_height", height);
+			ev_metadata_manager_set_double (uri, "window_width_ratio", 
+							(double)width/document_width);
+			ev_metadata_manager_set_double (uri, "window_height_ratio", 
+							(double)height/document_height);
 		}
 	}
 
@@ -3272,9 +4119,12 @@ open_remote_link (EvWindow *window, EvLinkAction *action)
 	uri = g_build_filename (dir, ev_link_action_get_filename (action),
 				NULL);
 	g_free (dir);
-	
+
 	ev_application_open_uri_at_dest (EV_APP, uri,
+					 gtk_window_get_screen (GTK_WINDOW (window)),
 					 ev_link_action_get_dest (action),
+					 0,
+					 FALSE,
 					 GDK_CURRENT_TIME);
 
 	g_free (uri);
@@ -3297,8 +4147,12 @@ do_action_named (EvWindow *window, EvLinkAction *action)
 		ev_window_cmd_focus_page_selector (NULL, window);
 	} else if (g_ascii_strcasecmp (name, "Find") == 0) {
 		ev_window_cmd_edit_find (NULL, window);
+	} else if (g_ascii_strcasecmp (name, "Close") == 0) {
+		ev_window_cmd_file_close_window (NULL, window);
 	} else {
-		g_warning ("Unimplemented named action: %s, please post a bug report with a testcase.",
+		g_warning ("Unimplemented named action: %s, please post a "
+		           "bug report in Evince bugzilla "
+		           "(http://bugzilla.gnome.org) with a testcase.",
 			   name);
 	}
 }
@@ -3330,6 +4184,23 @@ ev_view_popup_cmd_open_link (GtkAction *action, EvWindow *window)
 	ev_view_handle_link (EV_VIEW (window->priv->view), window->priv->link);
 }
 
+static void
+ev_view_popup_cmd_open_link_new_window (GtkAction *action, EvWindow *window)
+{
+	EvLinkAction *ev_action = NULL;
+	EvLinkDest   *dest;
+
+	ev_action = ev_link_get_action (window->priv->link);
+	if (!ev_action)
+		return;
+
+	dest = ev_link_action_get_dest (ev_action);
+	if (!dest)
+		return;
+
+	ev_window_cmd_file_open_copy_at_dest (window, dest);
+}
+
 static void
 ev_view_popup_cmd_copy_link_address (GtkAction *action, EvWindow *window)
 {
@@ -3471,11 +4342,11 @@ ev_window_init (EvWindow *ev_window)
 			  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->dest = NULL;
-
 	ev_window->priv->page_mode = PAGE_MODE_DOCUMENT;
 	ev_window->priv->title = ev_window_title_new (ev_window);
 
@@ -3528,7 +4399,18 @@ ev_window_init (EvWindow *ev_window)
 		g_warning ("building menus failed: %s", error->message);
 		g_error_free (error);
 	}
-
+	
+#ifdef HAVE_GTK_RECENT
+	ev_window->priv->recent_manager = gtk_recent_manager_get_for_screen (
+		gtk_widget_get_screen (GTK_WIDGET (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");
@@ -3545,14 +4427,25 @@ ev_window_init (EvWindow *ev_window)
 			    FALSE, FALSE, 0);
 	gtk_widget_show (toolbar_dock);
 
-	ev_window->priv->toolbar = egg_editable_toolbar_new_with_model
-				(ev_window->priv->ui_manager, ev_application_get_toolbars_model (EV_APP), NULL);
+	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),
+			 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,
+			    FALSE, FALSE, 0);
+
 	/* Add the main area */
 	ev_window->priv->hpaned = gtk_hpaned_new ();
 	g_signal_connect (ev_window->priv->hpaned,
@@ -3593,6 +4486,7 @@ ev_window_init (EvWindow *ev_window)
 				 "popup",
 				 G_CALLBACK (attachment_bar_menu_popup_cb),
 				 ev_window, 0);
+	gtk_widget_show (sidebar_widget);
 	ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar),
 			     sidebar_widget);
 
@@ -3742,7 +4636,11 @@ ev_window_init (EvWindow *ev_window)
 	g_signal_connect_swapped (G_OBJECT (ev_window->priv->view), "drag-data-received",
 				  G_CALLBACK (drag_data_received_cb),
 				  ev_window);
-	
+
+	/* Screensaver */
+
+	ev_window->priv->screensaver = totem_scrsaver_new ();
+
 	/* Set it user interface params */
 
 	ev_window_setup_recent (ev_window);
@@ -3752,6 +4650,7 @@ ev_window_init (EvWindow *ev_window)
 	update_chrome_visibility (ev_window);
 
 	gtk_window_set_default_size (GTK_WINDOW (ev_window), 600, 600);
+
 	setup_view_from_metadata (ev_window);
 	setup_sidebar_from_metadata (ev_window, NULL);