X-Git-Url: https://www.fi.muni.cz/~kas/git//home/kas/public_html/git/?a=blobdiff_plain;ds=sidebyside;f=shell%2Fev-window.c;h=dcf687e9e35c7cac430be2558b3ef74426064f7d;hb=d47bc2205d248b34dbfcdd349473f54d45d5ec70;hp=2fad47bfadc6ce092611f377ba5d7789924ece91;hpb=67297a0108ba18a69972c98ee1771c3dad41d55b;p=evince.git

diff --git a/shell/ev-window.c b/shell/ev-window.c
index 2fad47bf..dcf687e9 100644
--- a/shell/ev-window.c
+++ b/shell/ev-window.c
@@ -33,11 +33,11 @@
 #include "ev-page-action.h"
 #include "ev-sidebar.h"
 #include "ev-sidebar-links.h"
+#include "ev-sidebar-attachments.h"
 #include "ev-sidebar-thumbnails.h"
 #include "ev-view.h"
 #include "ev-password.h"
 #include "ev-password-view.h"
-#include "ev-attachment-bar.h"
 #include "ev-properties-dialog.h"
 #include "ev-ps-exporter.h"
 #include "ev-document-thumbnails.h"
@@ -50,11 +50,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"
@@ -70,6 +74,10 @@
 #include <libgnomeprintui/gnome-print-dialog.h>
 #endif
 
+#ifdef WITH_GTK_PRINT
+#include <gtk/gtkprintunixdialog.h>
+#endif
+
 #include <poppler.h>
 
 #include <glib/gi18n.h>
@@ -90,7 +98,9 @@ typedef enum {
 	EV_CHROME_TOOLBAR	= 1 << 1,
 	EV_CHROME_FINDBAR	= 1 << 2,
 	EV_CHROME_RAISE_TOOLBAR	= 1 << 3,
-	EV_CHROME_NORMAL	= EV_CHROME_MENUBAR | EV_CHROME_TOOLBAR
+	EV_CHROME_FULLSCREEN_TOOLBAR	= 1 << 4,
+	EV_CHROME_SIDEBAR	= 1 << 5,
+	EV_CHROME_NORMAL	= EV_CHROME_MENUBAR | EV_CHROME_TOOLBAR | EV_CHROME_SIDEBAR
 } EvChrome;
 
 struct _EvWindowPrivate {
@@ -109,20 +119,25 @@ struct _EvWindowPrivate {
 	GtkWidget *password_view;
 	GtkWidget *sidebar_thumbs;
 	GtkWidget *sidebar_links;
-	GtkWidget *attachment_bar;
+	GtkWidget *sidebar_attachments;
 
 	/* 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;
@@ -143,16 +158,26 @@ struct _EvWindowPrivate {
 	EvLinkDest *dest;
 	
 	EvDocument *document;
-	EvDocument *password_document;
+
 	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[] = {
@@ -175,6 +200,7 @@ static const GtkTargetEntry ev_drop_types[] = {
 #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);
@@ -183,8 +209,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);
@@ -201,7 +231,7 @@ 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     show_fullscreen_popup                   (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_copy_link_address     (GtkAction        *action,
@@ -214,6 +244,13 @@ 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);
 
 G_DEFINE_TYPE (EvWindow, ev_window, GTK_TYPE_WINDOW)
 
@@ -262,7 +299,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;
 	}
 
@@ -286,7 +323,7 @@ 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);
@@ -299,10 +336,8 @@ ev_window_setup_action_sensitivity (EvWindow *ev_window)
 
         /* 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);
 
@@ -377,6 +412,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);
@@ -386,12 +426,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);
 	}
 }
 
@@ -410,7 +451,7 @@ static void
 update_chrome_visibility (EvWindow *window)
 {
 	EvWindowPrivate *priv = window->priv;
-	gboolean menubar, toolbar, findbar, fullscreen_toolbar;
+	gboolean menubar, toolbar, findbar, fullscreen_toolbar, sidebar;
 	gboolean fullscreen_mode, presentation, fullscreen;
 
 	presentation = ev_view_get_presentation (EV_VIEW (priv->view));
@@ -420,24 +461,22 @@ update_chrome_visibility (EvWindow *window)
 	menubar = (priv->chrome & EV_CHROME_MENUBAR) != 0 && !fullscreen_mode;
 	toolbar = ((priv->chrome & EV_CHROME_TOOLBAR) != 0  || 
 		   (priv->chrome & EV_CHROME_RAISE_TOOLBAR) != 0) && !fullscreen_mode;
-	fullscreen_toolbar = ((priv->chrome & EV_CHROME_TOOLBAR) != 0 ||
-			      (priv->chrome & EV_CHROME_RAISE_TOOLBAR) != 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;
 
 	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);
 
 	ev_window_set_action_sensitive (window, "EditToolbar", toolbar);
 	gtk_widget_set_sensitive (priv->menubar, menubar);
 
 	if (priv->fullscreen_popup != NULL) {
-		if (fullscreen)
-			show_fullscreen_popup (window);
-		else
-			set_widget_visibility (priv->fullscreen_popup, FALSE);
-
 		set_widget_visibility (priv->fullscreen_toolbar, fullscreen_toolbar);
+		set_widget_visibility (priv->fullscreen_popup, fullscreen_toolbar);
 	}
 }
 
@@ -509,16 +548,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)
 {
@@ -582,26 +611,6 @@ update_document_mode (EvWindow *window, EvDocumentMode mode)
 	}
 }
 
-static void
-update_sidebar_visibility (EvWindow *window)
-{
-	char *uri = window->priv->uri;
-	GValue sidebar_visibility = { 0, };
-
-	if (ev_metadata_manager_get (uri, "sidebar_visibility", &sidebar_visibility, FALSE)) {
-		set_widget_visibility (window->priv->sidebar,
-				       g_value_get_boolean (&sidebar_visibility));
-	}
-}
-
-static void
-update_attachment_bar_visibility (EvWindow *window)
-{
-	set_widget_visibility (window->priv->attachment_bar,
-			       (window->priv->document &&
-			       ev_document_has_attachments (window->priv->document)));
-}
-
 static void
 setup_document_from_metadata (EvWindow *window)
 {
@@ -613,6 +622,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);
 	}
 }
 
@@ -625,11 +635,11 @@ 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;
 }
 
-
 static void
 setup_sidebar_from_metadata (EvWindow *window, EvDocument *document)
 {
@@ -637,42 +647,106 @@ setup_sidebar_from_metadata (EvWindow *window, EvDocument *document)
 	GtkWidget *sidebar = window->priv->sidebar;
 	GtkWidget *links = window->priv->sidebar_links;
 	GtkWidget *thumbs = window->priv->sidebar_thumbs;
+	GtkWidget *attachments = window->priv->sidebar_attachments;
 	GValue sidebar_size = { 0, };
 	GValue sidebar_page = { 0, };
+	GValue sidebar_visibility = { 0, };
 
 	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 (ev_metadata_manager_get (uri, "sidebar_page", &sidebar_page, FALSE)) {
+	
+	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") == 0 && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (links), document)) {
+		
+		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") && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (thumbs), 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);
 		}
-	} else {
-		if (ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (links), document)) {
-			ev_sidebar_set_page (EV_SIDEBAR (sidebar), links);
-		}
+		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);
 	}
 
-	update_sidebar_visibility (window);
+	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, };
@@ -680,31 +754,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 */
@@ -719,16 +778,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 */
@@ -736,6 +798,7 @@ setup_view_from_metadata (EvWindow *window)
 		if (g_value_get_boolean (&presentation) && uri) {
 			ev_window_run_presentation (window);
 		}
+		g_value_unset (&presentation);
 	}
 
 	/* Fullscreen */
@@ -743,6 +806,7 @@ setup_view_from_metadata (EvWindow *window)
 		if (g_value_get_boolean (&fullscreen) && uri) {
 			ev_window_run_fullscreen (window);
 		}
+		g_value_unset (&fullscreen);
 	}
 
 	/* Rotation */
@@ -762,6 +826,7 @@ setup_view_from_metadata (EvWindow *window)
 					break;
 			}
 		}
+		g_value_unset (&rotation);
 	}
 }
 
@@ -772,7 +837,6 @@ ev_window_setup_document (EvWindow *ev_window)
 	EvDocument *document;
 	EvView *view = EV_VIEW (ev_window->priv->view);
 	EvSidebar *sidebar = EV_SIDEBAR (ev_window->priv->sidebar);
-	EvAttachmentBar *attachbar = EV_ATTACHMENT_BAR (ev_window->priv->attachment_bar);
 	GtkAction *action;
 
 	document = ev_window->priv->document;
@@ -793,9 +857,6 @@ ev_window_setup_document (EvWindow *ev_window)
 	}
 	ev_window_set_page_mode (ev_window, PAGE_MODE_DOCUMENT);
 
-	ev_attachment_bar_set_document (attachbar, document);
-	update_attachment_bar_visibility (ev_window);
-
 	ev_window_title_set_document (ev_window->priv->title, document);
 	ev_window_title_set_uri (ev_window->priv->title, ev_window->priv->uri);
 
@@ -808,6 +869,7 @@ ev_window_setup_document (EvWindow *ev_window)
 					           ev_window->priv->document);
 	}
 	
+	setup_size_from_metadata (ev_window);
 	setup_document_from_metadata (ev_window);
 	setup_sidebar_from_metadata (ev_window, document);
 
@@ -827,7 +889,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 ();
 		}
@@ -835,13 +897,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;
 	}
@@ -857,7 +916,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);
 
@@ -930,35 +989,44 @@ 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);
-		
+
+		setup_view_from_metadata (ev_window);
 		ev_window_setup_document (ev_window);
-		ev_window_add_recent (ev_window, ev_window->priv->uri);		
-		ev_window_clear_xfer_job (ev_window);
+		ev_window_add_recent (ev_window, ev_window->priv->uri);
 
-		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;
 	}
 
@@ -970,8 +1038,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),
@@ -979,7 +1045,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), 
@@ -1003,37 +1069,36 @@ 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)
 {
-	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->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),
@@ -1057,7 +1122,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);
@@ -1084,9 +1151,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),
@@ -1095,6 +1166,25 @@ ev_window_cmd_file_open (GtkAction *action, EvWindow *window)
 	gtk_widget_show (chooser);
 }
 
+#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,
+					 GDK_CURRENT_TIME);
+}
+#else
 static void
 ev_window_cmd_recent_file_activate (GtkAction *action,
         	                    EvWindow *ev_window)
@@ -1107,25 +1197,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), 
@@ -1140,6 +1378,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
@@ -1161,7 +1400,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,9 +1428,7 @@ 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);
 
-#ifdef HAVE_GTK_FILE_CHOOSER_SET_DO_OVERWRITE_CONFIRMATION
 	gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER (fc), TRUE);	
-#endif	
 	file_name = gnome_vfs_format_uri_for_display (ev_window->priv->uri);
 	base_name = g_path_get_basename (file_name);
 	gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (fc), base_name);
@@ -1205,85 +1442,336 @@ 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_clear_print_job (EvWindow *window)
 {
-	EvPageCache *page_cache;
-	int last_page;
+	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;
+	EvPageCache   *page_cache;
+	gint           n_ranges = 0;
+	gint           copies;
+	gboolean       collate;
+	gboolean       reverse;
+	gdouble        scale;
+	gint           current_page;
+	gint           width;
+	gint           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;
 	page_cache = ev_page_cache_get (window->priv->document);
-	last_page = ev_page_cache_get_n_pages (page_cache);
+	ev_page_cache_get_size (page_cache,
+				current_page,
+				0, scale,
+				&width, &height);
+	
+	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,
+						    (gdouble)width,
+						    (gdouble)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;
 
-#ifdef WITH_GNOME_PRINT
-	ev_window_print_range (window, 1, last_page);
-#endif
+	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_CAPABILITY_GENERATE_PDF);
+	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
@@ -1300,11 +1788,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);
@@ -1319,12 +1812,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)
 {
@@ -1493,7 +2001,7 @@ ev_window_update_fullscreen_popup (EvWindow *window)
 	if (GTK_WIDGET (window)->window == NULL)
 		return;
 
-	toolbar = (window->priv->chrome & EV_CHROME_TOOLBAR) != 0 || 
+	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;
@@ -1570,13 +2078,15 @@ 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);
 
-	g_object_set (window->priv->fullscreen_popup, "visible", FALSE, NULL);
+	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));
-
 	window->priv->fullscreen_timeout_id = 0;
 
 	return FALSE;
@@ -1590,7 +2100,11 @@ 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);
+	ev_view_show_cursor (EV_VIEW (window->priv->view));
 }
 
 static void
@@ -1599,23 +2113,13 @@ fullscreen_clear_timeout (EvWindow *window)
 	if (window->priv->fullscreen_timeout_id != 0) {
 		g_source_remove (window->priv->fullscreen_timeout_id);
 	}
-
+	
 	window->priv->fullscreen_timeout_id = 0;
+	update_chrome_visibility (window);
 	ev_view_show_cursor (EV_VIEW (window->priv->view));
 }
 
 
-static void
-show_fullscreen_popup (EvWindow *window)
-{
-	if (!GTK_WIDGET_VISIBLE (window->priv->fullscreen_popup)) {
-		g_object_set (window->priv->fullscreen_popup, "visible", TRUE, NULL);
-		ev_view_show_cursor (EV_VIEW (window->priv->view));
-	}
-
-	fullscreen_set_timeout (window);	
-}
-
 static gboolean
 fullscreen_motion_notify_cb (GtkWidget *widget,
 			     GdkEventMotion *event,
@@ -1623,7 +2127,7 @@ fullscreen_motion_notify_cb (GtkWidget *widget,
 {
 	EvWindow *window = EV_WINDOW (user_data);
 
-	show_fullscreen_popup (window);
+	fullscreen_set_timeout (window);
 
 	return FALSE;
 }
@@ -1675,7 +2179,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));
+			(window->priv->ui_manager, ev_application_get_toolbars_model (EV_APP), NULL);
 
 	popup = gtk_window_new (GTK_WINDOW_POPUP);
 	hbox = gtk_hbox_new (FALSE, 0);
@@ -1723,19 +2227,21 @@ ev_window_update_fullscreen_action (EvWindow *window)
 static void
 ev_window_run_fullscreen (EvWindow *window)
 {
-	ev_view_set_fullscreen (EV_VIEW (window->priv->view), TRUE);
 	if (window->priv->fullscreen_popup == NULL)
 		window->priv->fullscreen_popup
 			= ev_window_create_fullscreen_popup (window);
 
-	update_chrome_visibility (window);
-	gtk_widget_hide (window->priv->sidebar);
-	gtk_widget_hide (window->priv->attachment_bar);
-
 	g_object_set (G_OBJECT (window->priv->scrolled_window),
 		      "shadow-type", GTK_SHADOW_NONE,
 		      NULL);
+
+	ev_view_set_fullscreen (EV_VIEW (window->priv->view), TRUE);
+	ev_window_update_fullscreen_action (window);
 	
+	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),
@@ -1746,11 +2252,6 @@ ev_window_run_fullscreen (EvWindow *window)
 			  window);
 	fullscreen_set_timeout (window);
 
-	gtk_widget_grab_focus (window->priv->view);
-	ev_window_update_fullscreen_action (window);
-	gtk_window_fullscreen (GTK_WINDOW (window));
-	ev_window_update_fullscreen_popup (window);
-
 	if (!ev_window_is_empty (window))
 		ev_metadata_manager_set_boolean (window->priv->uri, "fullscreen", TRUE);
 }
@@ -1763,24 +2264,21 @@ ev_window_stop_fullscreen (EvWindow *window)
 	if (!ev_view_get_fullscreen (EV_VIEW (view)))
 		return;
 
-	ev_view_set_fullscreen (view, FALSE);
 	g_object_set (G_OBJECT (window->priv->scrolled_window),
 		      "shadow-type", GTK_SHADOW_IN,
 		      NULL);
 
-	fullscreen_clear_timeout (window);
+	ev_view_set_fullscreen (view, FALSE);
+	ev_window_update_fullscreen_action (window);
+	gtk_window_unfullscreen (GTK_WINDOW (window));
 
-	g_signal_handlers_disconnect_by_func (view,
+	g_signal_handlers_disconnect_by_func (window->priv->view,
 					      (gpointer) fullscreen_motion_notify_cb,
 					      window);
-	g_signal_handlers_disconnect_by_func (view,
+	g_signal_handlers_disconnect_by_func (window->priv->view,
 					      (gpointer) fullscreen_leave_notify_cb,
 					      window);
-	ev_window_update_fullscreen_action (window);
-	gtk_window_unfullscreen (GTK_WINDOW (window));
-	update_chrome_visibility (window);
-	update_sidebar_visibility (window);
-	update_attachment_bar_visibility (window);
+	fullscreen_clear_timeout (window);
 
 	if (!ev_window_is_empty (window))
 		ev_metadata_manager_set_boolean (window->priv->uri, "fullscreen", FALSE);
@@ -1823,13 +2321,21 @@ ev_window_run_presentation (EvWindow *window)
 		      "shadow-type", GTK_SHADOW_NONE,
 		      NULL);
 
-	gtk_widget_grab_focus (window->priv->view);
 	ev_view_set_presentation (EV_VIEW (window->priv->view), TRUE);
-	gtk_window_fullscreen (GTK_WINDOW (window));
 	ev_window_update_presentation_action (window);
-	update_chrome_visibility (window);
-	gtk_widget_hide (window->priv->sidebar);
-	gtk_widget_hide (window->priv->attachment_bar);
+
+	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),
+			  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, "presentation", TRUE);
@@ -1844,12 +2350,18 @@ ev_window_stop_presentation (EvWindow *window)
 	g_object_set (G_OBJECT (window->priv->scrolled_window),
 		      "shadow-type", GTK_SHADOW_IN,
 		      NULL);
+
 	ev_view_set_presentation (EV_VIEW (window->priv->view), FALSE);
-	gtk_window_unfullscreen (GTK_WINDOW (window));
 	ev_window_update_presentation_action (window);
-	update_chrome_visibility (window);
-	update_sidebar_visibility (window);
-	update_attachment_bar_visibility (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, "presentation", FALSE);
@@ -1871,19 +2383,43 @@ ev_window_cmd_view_presentation (GtkAction *action, EvWindow *window)
 	}
 }
 
+static void
+ev_window_run_preview (EvWindow *window)
+{
+	EggToolbarsModel *model;
+	EggTbModelFlags   flags;
+
+	model = egg_toolbars_model_new ();
+
+	egg_toolbars_model_load_toolbars (model,
+					  DATADIR"/evince-toolbar.xml");
+	
+	flags = egg_toolbars_model_get_flags (model, 1);
+	egg_toolbars_model_set_flags (model, 1, flags &= ~(EGG_TB_MODEL_HIDDEN));
+
+	egg_editable_toolbar_set_model (EGG_EDITABLE_TOOLBAR (window->priv->toolbar),
+					model);
+	
+	egg_editable_toolbar_hide (EGG_EDITABLE_TOOLBAR (window->priv->toolbar),
+				   "DefaultToolBar");
+	egg_editable_toolbar_show (EGG_EDITABLE_TOOLBAR (window->priv->toolbar),
+				   "PreviewToolBar");
+
+	ev_view_set_continuous (EV_VIEW (window->priv->view), FALSE); 
+	
+	update_chrome_flag (window, EV_CHROME_MENUBAR, FALSE);
+	update_chrome_flag (window, EV_CHROME_SIDEBAR, FALSE);
+	update_chrome_visibility (window);
+}
+
 static gboolean
 ev_window_focus_in_event (GtkWidget *widget, GdkEventFocus *event)
 {
 	EvWindow *window = EV_WINDOW (widget);
 	EvWindowPrivate *priv = window->priv;
-	gboolean fullscreen;
 
-	g_object_get (priv->view,
-		      "fullscreen", &fullscreen,
-		      NULL);
-
-	if (fullscreen)
-		show_fullscreen_popup (window);
+	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);
 }
@@ -1893,14 +2429,11 @@ ev_window_focus_out_event (GtkWidget *widget, GdkEventFocus *event)
 {
 	EvWindow *window = EV_WINDOW (widget);
 	EvWindowPrivate *priv = window->priv;
-	gboolean fullscreen;
-
-	g_object_get (priv->view,
-		      "fullscreen", &fullscreen,
-		      NULL);
 
-	if (fullscreen)
+	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);
 }
@@ -1913,6 +2446,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);
 	}
@@ -1921,7 +2472,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);
@@ -2011,8 +2561,6 @@ ev_window_cmd_edit_toolbar (GtkAction *action, EvWindow *ev_window)
 	gtk_box_set_spacing (GTK_BOX (EGG_TOOLBAR_EDITOR (editor)), 5);
              
 	gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), editor);
-	egg_toolbar_editor_load_actions (EGG_TOOLBAR_EDITOR (editor),
-				         DATADIR "/evince-toolbar.xml");
 
 	egg_editable_toolbar_set_edit_mode
 		(EGG_EDITABLE_TOOLBAR (ev_window->priv->toolbar), TRUE);
@@ -2107,19 +2655,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);
 
 	g_free (uri);
 }
@@ -2163,10 +2704,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");
@@ -2383,7 +2928,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
 	};
 
@@ -2393,16 +2939,16 @@ ev_window_cmd_help_about (GtkAction *action, EvWindow *ev_window)
 	};
 
 	const char *license[] = {
-		N_("Evince is free software; you can redistribute it and/or modify\n"
-		   "it under the terms of the GNU General Public License as published by\n"
-		   "the Free Software Foundation; either version 2 of the License, or\n"
+		N_("Evince is free software; you can redistribute it and/or modify "
+		   "it under the terms of the GNU General Public License as published by "
+		   "the Free Software Foundation; either version 2 of the License, or "
 		   "(at your option) any later version.\n"),
-		N_("Evince is distributed in the hope that it will be useful,\n"
-		   "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
-		   "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
+		N_("Evince is distributed in the hope that it will be useful, "
+		   "but WITHOUT ANY WARRANTY; without even the implied warranty of "
+		   "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the "
 		   "GNU General Public License for more details.\n"),
-		N_("You should have received a copy of the GNU General Public License\n"
-		   "along with Evince; if not, write to the Free Software Foundation, Inc.,\n"
+		N_("You should have received a copy of the GNU General Public License "
+		   "along with Evince; if not, write to the Free Software Foundation, Inc., "
 		   "59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n")
 	};
 
@@ -2436,6 +2982,7 @@ ev_window_cmd_help_about (GtkAction *action, EvWindow *ev_window)
 		"documenters", documenters,
 		"translator-credits", _("translator-credits"),
 		"logo-icon-name", "evince",
+		"wrap-license", TRUE,
 		NULL);
 
 	g_free (comments);
@@ -2455,8 +3002,8 @@ ev_window_view_toolbar_cb (GtkAction *action, EvWindow *ev_window)
 static void
 ev_window_view_sidebar_cb (GtkAction *action, EvWindow *ev_window)
 {
-	set_widget_visibility (ev_window->priv->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)));
 }
 
 static void
@@ -2473,6 +3020,8 @@ ev_window_sidebar_current_page_changed_cb (EvSidebar  *ev_sidebar,
 		id = LINKS_SIDEBAR_ID;
 	} else if (current_page == ev_window->priv->sidebar_thumbs) {
 		id = THUMBNAILS_SIDEBAR_ID;
+	} else if (current_page == ev_window->priv->sidebar_attachments) {
+		id = ATTACHMENTS_SIDEBAR_ID;
 	} else {
 		g_assert_not_reached();
 	}
@@ -2484,41 +3033,24 @@ ev_window_sidebar_current_page_changed_cb (EvSidebar  *ev_sidebar,
 }
 
 static void
-ev_window_sidebar_visibility_changed_cb (EvSidebar *ev_sidebar, GParamSpec *pspec,
+ev_window_sidebar_visibility_changed_cb (EvSidebar  *ev_sidebar,
+					 GParamSpec *pspec,
 					 EvWindow   *ev_window)
 {
 	EvView *view = EV_VIEW (ev_window->priv->view);
 	GtkAction *action;
 
 	action = gtk_action_group_get_action (ev_window->priv->action_group, "ViewSidebar");
-	
-	g_signal_handlers_block_by_func
-		(action, G_CALLBACK (ev_window_view_sidebar_cb), ev_window);
 	gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
 				      GTK_WIDGET_VISIBLE (ev_sidebar));
-	g_signal_handlers_unblock_by_func
-		(action, G_CALLBACK (ev_window_view_sidebar_cb), ev_window);
 
 	if (!ev_view_get_presentation (view) && 
-	    !ev_view_get_fullscreen (view) &&
-	    !ev_window_is_empty (ev_window)) {
+	    !ev_view_get_fullscreen (view)) {
 		ev_metadata_manager_set_boolean (ev_window->priv->uri, "sidebar_visibility",
 					         GTK_WIDGET_VISIBLE (ev_sidebar));
 	}
 }
 
-static void
-ev_window_attachment_bar_toggled_cb (EvAttachmentBar *ev_attachbar,
-				     GParamSpec      *param_spec,
-				     EvWindow        *ev_window)
-{
-	if (gtk_expander_get_expanded (GTK_EXPANDER (ev_attachbar))) {
-		gtk_widget_grab_focus (GTK_WIDGET (ev_attachbar));
-	} else {
-		gtk_widget_grab_focus (ev_window->priv->view);
-	}
-}
-
 static gboolean
 view_menu_popup_cb (EvView   *view,
 		    EvLink   *link,
@@ -2582,7 +3114,7 @@ view_menu_popup_cb (EvView   *view,
 }
 
 static gboolean
-attachment_bar_menu_popup_cb (EvAttachmentBar *attachbar,
+attachment_bar_menu_popup_cb (EvSidebarAttachments *attachbar,
 			      GList           *attach_list,
 			      EvWindow        *ev_window)
 {
@@ -2740,11 +3272,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;
@@ -2765,6 +3292,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;
@@ -2780,6 +3328,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);
 	}
@@ -2787,13 +3340,32 @@ ev_window_dispose (GObject *object)
 	if (priv->local_uri) {
 		ev_window_clear_local_uri (window);
 	}
+	
+	ev_window_close_dialogs (window);
+
+#ifdef WITH_GTK_PRINT
+	ev_window_clear_print_job (window);
 
-	if (priv->password_document) {
-		g_object_unref (priv->password_document);
-		priv->password_document = NULL;
+	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);
@@ -2978,7 +3550,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",
@@ -3044,7 +3616,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);
 	}
@@ -3104,9 +3678,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);
@@ -3116,22 +3690,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);
@@ -3228,7 +3798,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);
 
@@ -3236,11 +3806,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);
 		}
 	}
 
@@ -3311,14 +3889,43 @@ 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,
 					 GDK_CURRENT_TIME);
 
 	g_free (uri);
 }
 
+static void
+do_action_named (EvWindow *window, EvLinkAction *action)
+{
+	const gchar *name = ev_link_action_get_name (action);
+
+	if (g_ascii_strcasecmp (name, "FirstPage") == 0) {
+		ev_window_cmd_go_first_page (NULL, window);
+	} else if (g_ascii_strcasecmp (name, "PrevPage") == 0) {
+		ev_window_cmd_go_previous_page (NULL, window);
+	} else if (g_ascii_strcasecmp (name, "NextPage") == 0) {
+		ev_window_cmd_go_next_page (NULL, window);
+	} else if (g_ascii_strcasecmp (name, "LastPage") == 0) {
+		ev_window_cmd_go_last_page (NULL, window);
+	} else if (g_ascii_strcasecmp (name, "GoToPage") == 0) {
+		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 in Evince bugzilla "
+		           "(http://bugzilla.gnome.org) with a testcase.",
+			   name);
+	}
+}
+
 static void
 view_external_link_cb (EvView *view, EvLinkAction *action, EvWindow *window)
 {
@@ -3332,6 +3939,9 @@ view_external_link_cb (EvView *view, EvLinkAction *action, EvWindow *window)
 	        case EV_LINK_ACTION_TYPE_GOTO_REMOTE:
 			open_remote_link (window, action);
 			break;
+	        case EV_LINK_ACTION_TYPE_NAMED:
+			do_action_named (window, action);
+			break;
 	        default:
 			g_assert_not_reached ();
 	}
@@ -3459,10 +4069,7 @@ ev_attachment_popup_cmd_save_attachment_as (GtkAction *action, EvWindow *window)
 		NULL);
 
 	gtk_dialog_set_default_response (GTK_DIALOG (fc), GTK_RESPONSE_OK);
-
-#ifdef HAVE_GTK_FILE_CHOOSER_SET_DO_OVERWRITE_CONFIRMATION
 	gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (fc), TRUE);
-#endif
 
 	if (attachment)
 		gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (fc),
@@ -3487,11 +4094,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);
 
@@ -3544,7 +4151,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");
@@ -3562,7 +4180,7 @@ ev_window_init (EvWindow *ev_window)
 	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));
+				(ev_window->priv->ui_manager, ev_application_get_toolbars_model (EV_APP), 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,
@@ -3587,6 +4205,7 @@ ev_window_init (EvWindow *ev_window)
 	gtk_widget_show (ev_window->priv->sidebar);
 
 	/* Stub sidebar, for now */
+
 	sidebar_widget = ev_sidebar_links_new ();
 	ev_window->priv->sidebar_links = sidebar_widget;
 	g_signal_connect (sidebar_widget,
@@ -3602,6 +4221,16 @@ ev_window_init (EvWindow *ev_window)
 	ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar),
 			     sidebar_widget);
 
+	sidebar_widget = ev_sidebar_attachments_new ();
+	ev_window->priv->sidebar_attachments = sidebar_widget;
+	g_signal_connect_object (sidebar_widget,
+				 "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);
+
 	sidebar_widget = ev_sidebar_thumbnails_new ();
 	ev_window->priv->sidebar_thumbs = sidebar_widget;
 	g_signal_connect (sidebar_widget,
@@ -3613,7 +4242,6 @@ ev_window_init (EvWindow *ev_window)
 	ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar),
 			     sidebar_widget);
 
-
 	ev_window->priv->scrolled_window =
 		GTK_WIDGET (g_object_new (GTK_TYPE_SCROLLED_WINDOW,
 					  "shadow-type", GTK_SHADOW_IN,
@@ -3645,16 +4273,6 @@ ev_window_init (EvWindow *ev_window)
 	gtk_widget_show (ev_window->priv->view);
 	gtk_widget_show (ev_window->priv->password_view);
 
-	/* Attachments Bar */
-	ev_window->priv->attachment_bar = ev_attachment_bar_new ();
-	gtk_box_pack_end (GTK_BOX (ev_window->priv->main_box),
-			  ev_window->priv->attachment_bar,
-			  FALSE, TRUE, 0);
-	g_signal_connect_object (ev_window->priv->attachment_bar,
-				 "popup",
-				 G_CALLBACK (attachment_bar_menu_popup_cb),
-				 ev_window, 0);
-
 	/* Find Bar */
 	ev_window->priv->find_bar = egg_find_bar_new ();
 	gtk_box_pack_end (GTK_BOX (ev_window->priv->main_box),
@@ -3707,12 +4325,6 @@ ev_window_init (EvWindow *ev_window)
 			  G_CALLBACK (ev_window_sidebar_current_page_changed_cb),
 			  ev_window);
 
-	/* Connect attachment bar sgignals */
-	g_signal_connect (G_OBJECT (ev_window->priv->attachment_bar),
-			  "notify::expanded",
-			  G_CALLBACK (ev_window_attachment_bar_toggled_cb),
-			  ev_window);
-
 	/* Connect to find bar signals */
 	g_signal_connect (ev_window->priv->find_bar,
 			  "previous",
@@ -3765,19 +4377,19 @@ 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);
-
+	
 	/* Set it user interface params */
 
 	ev_window_setup_recent (ev_window);
+
 	setup_chrome_from_metadata (ev_window);
 	set_chrome_actions (ev_window);
 	update_chrome_visibility (ev_window);
-	update_sidebar_visibility (ev_window);
-	update_attachment_bar_visibility (ev_window);
 
-	gtk_window_set_default_size (GTK_WINDOW (ev_window),
-			             600, 600);
+	gtk_window_set_default_size (GTK_WINDOW (ev_window), 600, 600);
+
 	setup_view_from_metadata (ev_window);
+	setup_sidebar_from_metadata (ev_window, NULL);
 
         ev_window_sizing_mode_changed_cb (EV_VIEW (ev_window->priv->view), NULL, ev_window);
 	ev_window_setup_action_sensitivity (ev_window);