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

diff --git a/shell/ev-window.c b/shell/ev-window.c
index 29b6a039..dcf687e9 100644
--- a/shell/ev-window.c
+++ b/shell/ev-window.c
@@ -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>
@@ -115,16 +123,21 @@ struct _EvWindowPrivate {
 
 	/* 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;
@@ -145,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[] = {
@@ -186,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);
@@ -204,6 +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     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,
@@ -271,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;
 	}
 
@@ -295,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);
@@ -308,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);
 
@@ -386,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);
@@ -395,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);
 	}
 }
 
@@ -516,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)
 {
@@ -600,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);
 	}
 }
 
@@ -612,6 +635,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 +655,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 +668,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 +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 */
@@ -709,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 */
@@ -726,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 */
@@ -733,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 */
@@ -752,6 +826,7 @@ setup_view_from_metadata (EvWindow *window)
 					break;
 			}
 		}
+		g_value_unset (&rotation);
 	}
 }
 
@@ -794,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);
 
@@ -813,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 ();
 		}
@@ -821,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;
 	}
@@ -843,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);
 
@@ -916,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;
 	}
 
@@ -956,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),
@@ -965,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), 
@@ -989,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),
@@ -1043,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);
@@ -1070,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),
@@ -1081,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)
@@ -1093,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), 
@@ -1126,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
@@ -1147,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,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
@@ -1284,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);
@@ -1303,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)
 {
@@ -1554,9 +2078,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 +2100,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);
@@ -1856,6 +2383,35 @@ 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)
 {
@@ -1890,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);
 	}
@@ -1898,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);
@@ -2082,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);
 }
@@ -2138,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");
@@ -2358,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
 	};
 
@@ -2701,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;
@@ -2726,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;
@@ -2741,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);
 	}
@@ -2748,13 +3340,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);
@@ -2939,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",
@@ -3005,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);
 	}
@@ -3065,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);
@@ -3077,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);
@@ -3189,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);
 
@@ -3197,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);
 		}
 	}
 
@@ -3272,9 +3889,11 @@ 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);
@@ -3297,8 +3916,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);
 	}
 }
@@ -3471,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);
 
@@ -3528,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");
@@ -3593,6 +4227,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);
 
@@ -3752,6 +4387,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);