X-Git-Url: https://www.fi.muni.cz/~kas/git//home/kas/public_html/git/?a=blobdiff_plain;f=shell%2Fev-window.c;h=02a3087784f0d5975d1093288943ac0e32084b5f;hb=43f607bda8eef3648f018e433647172603ea1a7f;hp=610a18e793b8a03550f3c26da83d07d00211b219;hpb=7e1276794f51b4eaa89392fb81d372a4329f54cb;p=evince.git

diff --git a/shell/ev-window.c b/shell/ev-window.c
index 610a18e7..02a30877 100644
--- a/shell/ev-window.c
+++ b/shell/ev-window.c
@@ -68,7 +68,7 @@
 #include "ev-job-scheduler.h"
 #include "ev-jobs.h"
 #include "ev-message-area.h"
-#include "ev-metadata-manager.h"
+#include "ev-metadata.h"
 #include "ev-navigation-action.h"
 #include "ev-open-recent-action.h"
 #include "ev-page-action.h"
@@ -188,6 +188,7 @@ struct _EvWindowPrivate {
 	EvHistory *history;
 	EvWindowPageMode page_mode;
 	EvWindowTitle *title;
+	EvMetadata *metadata;
 
 	/* Load params */
 	EvLinkDest       *dest;
@@ -205,6 +206,9 @@ struct _EvWindowPrivate {
 	GtkPrintSettings *print_settings;
 	GtkPageSetup     *print_page_setup;
 	gboolean          close_after_print;
+#ifdef WITH_GCONF
+	GConfClient *gconf_client;
+#endif
 };
 
 #define EV_WINDOW_GET_PRIVATE(object) \
@@ -214,9 +218,11 @@ struct _EvWindowPrivate {
 #define ZOOM_CONTROL_ACTION	"ViewZoom"
 #define NAVIGATION_ACTION	"Navigation"
 
+#define GCONF_LOCKDOWN_DIR          "/desktop/gnome/lockdown"
 #define GCONF_OVERRIDE_RESTRICTIONS "/apps/evince/override_restrictions"
 #define GCONF_LOCKDOWN_SAVE         "/desktop/gnome/lockdown/disable_save_to_disk"
 #define GCONF_LOCKDOWN_PRINT        "/desktop/gnome/lockdown/disable_printing"
+#define GCONF_LOCKDOWN_PRINT_SETUP  "/desktop/gnome/lockdown/disable_print_setup"
 
 #define PRESENTATION_TIMEOUT 5
 
@@ -226,6 +232,12 @@ struct _EvWindowPrivate {
 #define ATTACHMENTS_SIDEBAR_ID "attachments"
 #define LAYERS_SIDEBAR_ID "layers"
 
+#define EV_PRINT_SETTINGS_FILE  "print-settings"
+#define EV_PRINT_SETTINGS_GROUP "Print Settings"
+#define EV_PAGE_SETUP_GROUP     "Page Setup"
+
+#define EV_TOOLBARS_FILENAME "evince-toolbar.xml"
+
 #define MIN_SCALE 0.05409
 #define MAX_SCALE 4.0
 
@@ -307,7 +319,8 @@ static void     ev_window_load_file_remote              (EvWindow         *ev_wi
 static void     ev_window_media_player_key_pressed      (EvWindow         *window,
 							 const gchar      *key,
 							 gpointer          user_data);
-static void     ev_window_save_print_page_setup         (EvWindow         *window);
+
+static guint ev_window_n_copies = 0;
 
 G_DEFINE_TYPE (EvWindow, ev_window, GTK_TYPE_WINDOW)
 
@@ -327,18 +340,15 @@ ev_window_setup_action_sensitivity (EvWindow *ev_window)
 {
 	EvDocument *document = ev_window->priv->document;
 	const EvDocumentInfo *info = NULL;
-
 	gboolean has_document = FALSE;
 	gboolean ok_to_print = TRUE;
+	gboolean ok_to_print_setup = TRUE;
 	gboolean ok_to_copy = TRUE;
 	gboolean has_properties = TRUE;
 	gboolean override_restrictions = TRUE;
 	gboolean can_get_text = FALSE;
 	gboolean has_pages = FALSE;
 	gboolean can_find = FALSE;
-#ifdef WITH_GCONF
-	GConfClient *client;
-#endif
 
 	if (document) {
 		has_document = TRUE;
@@ -359,10 +369,10 @@ ev_window_setup_action_sensitivity (EvWindow *ev_window)
 	}
 
 #ifdef WITH_GCONF
-	client = gconf_client_get_default ();
-	override_restrictions = gconf_client_get_bool (client, 
-						       GCONF_OVERRIDE_RESTRICTIONS, 
-						       NULL);
+	if (has_document)
+		override_restrictions = gconf_client_get_bool (ev_window->priv->gconf_client,
+							       GCONF_OVERRIDE_RESTRICTIONS,
+							       NULL);
 #endif
 	if (!override_restrictions && info && info->fields_mask & EV_DOCUMENT_INFO_PERMISSIONS) {
 		ok_to_print = (info->permissions & EV_DOCUMENT_PERMISSIONS_OK_TO_PRINT);
@@ -373,21 +383,28 @@ ev_window_setup_action_sensitivity (EvWindow *ev_window)
 		ok_to_print = FALSE;
 
 #ifdef WITH_GCONF
-	if (gconf_client_get_bool (client, GCONF_LOCKDOWN_SAVE, NULL)) {
+	if (has_document &&
+	    gconf_client_get_bool (ev_window->priv->gconf_client, GCONF_LOCKDOWN_SAVE, NULL)) {
 		ok_to_copy = FALSE;
 	}
 
-	if (gconf_client_get_bool (client, GCONF_LOCKDOWN_PRINT, NULL)) {
+	if (has_document &&
+	    gconf_client_get_bool (ev_window->priv->gconf_client, GCONF_LOCKDOWN_PRINT, NULL)) {
 		ok_to_print = FALSE;
 	}
 
-	g_object_unref (client);
+	if (has_document &&
+	    gconf_client_get_bool (ev_window->priv->gconf_client, GCONF_LOCKDOWN_PRINT_SETUP, NULL)) {
+		ok_to_print_setup = FALSE;
+	}
 #endif
 
 	/* File menu */
 	ev_window_set_action_sensitive (ev_window, "FileOpenCopy", has_document);
 	ev_window_set_action_sensitive (ev_window, "FileSaveAs", has_document && ok_to_copy);
-	ev_window_set_action_sensitive (ev_window, "FilePageSetup", has_pages && ok_to_print);
+#if !GTK_CHECK_VERSION (2, 17, 4)
+	ev_window_set_action_sensitive (ev_window, "FilePageSetup", has_pages && ok_to_print && ok_to_print_setup);
+#endif
 	ev_window_set_action_sensitive (ev_window, "FilePrint", has_pages && ok_to_print);
 	ev_window_set_action_sensitive (ev_window, "FileProperties", has_document && has_properties);
 
@@ -843,8 +860,8 @@ ev_window_page_changed_cb (EvWindow        *ev_window,
 		ev_window_add_history (ev_window, old_page, NULL);
 	}
 
-	if (!ev_window_is_empty (ev_window))
-		ev_metadata_manager_set_int (ev_window->priv->uri, "page", new_page);
+	if (ev_window->priv->metadata && !ev_window_is_empty (ev_window))
+		ev_metadata_set_int (ev_window->priv->metadata, "page", new_page);
 }
 
 static void
@@ -862,12 +879,12 @@ static void
 setup_chrome_from_metadata (EvWindow *window)
 {
 	EvChrome chrome = EV_CHROME_NORMAL;
-	GValue show_toolbar = { 0, };
+	gboolean show_toolbar;
 
-	if (ev_metadata_manager_get (NULL, "show_toolbar", &show_toolbar, FALSE)) {
-		if (!g_value_get_boolean (&show_toolbar))
+	if (window->priv->metadata &&
+	    ev_metadata_get_boolean (window->priv->metadata, "show_toolbar", &show_toolbar)) {
+		if (!show_toolbar)
 			chrome &= ~EV_CHROME_TOOLBAR;
-		g_value_unset (&show_toolbar);
 	}
 	window->priv->chrome = chrome;
 }
@@ -875,26 +892,24 @@ setup_chrome_from_metadata (EvWindow *window)
 static void
 setup_sidebar_from_metadata (EvWindow *window)
 {
-	gchar      *uri = window->priv->uri;
 	EvDocument *document = window->priv->document;
 	GtkWidget  *sidebar = window->priv->sidebar;
 	GtkWidget  *links = window->priv->sidebar_links;
 	GtkWidget  *thumbs = window->priv->sidebar_thumbs;
 	GtkWidget  *attachments = window->priv->sidebar_attachments;
 	GtkWidget  *layers = window->priv->sidebar_layers;
-	GValue      sidebar_size = { 0, };
-	GValue      sidebar_page = { 0, };
-	GValue      sidebar_visibility = { 0, };
+	gchar      *page_id;
+	gint        sidebar_size;
+	gboolean    sidebar_visibility;
 
-	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 (!window->priv->metadata)
+		return;
+
+	if (ev_metadata_get_int (window->priv->metadata, "sidebar_size", &sidebar_size)) {
+		gtk_paned_set_position (GTK_PANED (window->priv->hpaned), sidebar_size);
 	}
-	
-	if (document && ev_metadata_manager_get (uri, "sidebar_page", &sidebar_page, TRUE)) {
-		const char *page_id = g_value_get_string (&sidebar_page);
 
+	if (document && ev_metadata_get_string (window->priv->metadata, "sidebar_page", &page_id)) {
 		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) == 0 && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (thumbs), document)) {
@@ -904,7 +919,6 @@ setup_sidebar_from_metadata (EvWindow *window)
 		} else if (strcmp (page_id, LAYERS_SIDEBAR_ID) == 0 && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (layers), document)) {
 			ev_sidebar_set_page (EV_SIDEBAR (sidebar), layers);
 		}
-		g_value_unset (&sidebar_page);
 	} else if (document) {
 		if (ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (links), document)) {
 			ev_sidebar_set_page (EV_SIDEBAR (sidebar), links);
@@ -917,9 +931,8 @@ setup_sidebar_from_metadata (EvWindow *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);
+	if (ev_metadata_get_boolean (window->priv->metadata, "sidebar_visibility", &sidebar_visibility)) {
+		update_chrome_flag (window, EV_CHROME_SIDEBAR, sidebar_visibility);
 		update_chrome_visibility (window);
 	}
 }
@@ -927,97 +940,87 @@ setup_sidebar_from_metadata (EvWindow *window)
 static void
 setup_model_from_metadata (EvWindow *window)
 {
-	gchar *uri = window->priv->uri;
-	GValue page = { 0, };
-	GValue sizing_mode = { 0, };
-	GValue zoom = { 0, };
-	GValue rotation = { 0, };
-	GValue continuous = { 0, };
-	GValue dual_page = { 0, };
-	GValue fullscreen = { 0, };
+	gint     page;
+	gchar   *sizing_mode;
+	gdouble  zoom;
+	gint     rotation;
+	gboolean continuous = { 0, };
+	gboolean dual_page = { 0, };
+	gboolean fullscreen = { 0, };
+
+	if (!window->priv->metadata)
+		return;
 
 	/* Current page */
-	if (ev_metadata_manager_get (uri, "page", &page, TRUE)) {
-		ev_document_model_set_page (window->priv->model,
-					    g_value_get_int (&page));
-		g_value_unset (&page);
+	if (!window->priv->dest &&
+	    ev_metadata_get_int (window->priv->metadata, "page", &page)) {
+		ev_document_model_set_page (window->priv->model, page);
 	}
 
 	/* Sizing mode */
-	if (ev_metadata_manager_get (uri, "sizing_mode", &sizing_mode, FALSE)) {
+	if (ev_metadata_get_string (window->priv->metadata, "sizing_mode", &sizing_mode)) {
 		GEnumValue *enum_value;
 
 		enum_value = g_enum_get_value_by_nick
-			(g_type_class_peek (EV_TYPE_SIZING_MODE), g_value_get_string (&sizing_mode));
+			(g_type_class_peek (EV_TYPE_SIZING_MODE), sizing_mode);
 		ev_document_model_set_sizing_mode (window->priv->model, enum_value->value);
-		g_value_unset (&sizing_mode);
 	}
 
 	/* Zoom */
 	if (ev_document_model_get_sizing_mode (window->priv->model) == EV_SIZING_FREE &&
-	    ev_metadata_manager_get (uri, "zoom", &zoom, FALSE)) {
-		gdouble zoom_value;
-
-		zoom_value = g_value_get_double (&zoom);
-		zoom_value *= get_screen_dpi (GTK_WINDOW (window)) / 72.0;
-		ev_document_model_set_scale (window->priv->model, zoom_value);
-		g_value_unset (&zoom);
+	    ev_metadata_get_double (window->priv->metadata, "zoom", &zoom)) {
+		zoom *= get_screen_dpi (GTK_WINDOW (window)) / 72.0;
+		ev_document_model_set_scale (window->priv->model, zoom);
 	}
 
 	/* Rotation */
-	if (ev_metadata_manager_get (uri, "rotation", &rotation, TRUE)) {
-		gint rotation_value;
-
-		switch (g_value_get_int (&rotation)) {
+	if (ev_metadata_get_int (window->priv->metadata, "rotation", &rotation)) {
+		switch (rotation) {
 		case 90:
-			rotation_value = 90;
+			rotation = 90;
 			break;
 		case 180:
-			rotation_value = 180;
+			rotation = 180;
 			break;
 		case 270:
-			rotation_value = 270;
+			rotation = 270;
 			break;
 		default:
-			rotation_value = 0;
+			rotation = 0;
 			break;
 		}
-		ev_document_model_set_rotation (window->priv->model, rotation_value);
-		g_value_unset (&rotation);
+		ev_document_model_set_rotation (window->priv->model, rotation);
 	}
 
 	/* Continuous */
-	if (ev_metadata_manager_get (uri, "continuous", &continuous, FALSE)) {
-		ev_document_model_set_continuous (window->priv->model,
-						  g_value_get_boolean (&continuous));
-		g_value_unset (&continuous);
+	if (ev_metadata_get_boolean (window->priv->metadata, "continuous", &continuous)) {
+		ev_document_model_set_continuous (window->priv->model, continuous);
 	}
 
 	/* Dual page */
-	if (ev_metadata_manager_get (uri, "dual-page", &dual_page, FALSE)) {
-		ev_document_model_set_dual_page (window->priv->model,
-						 g_value_get_boolean (&dual_page));
-		g_value_unset (&dual_page);
+	if (ev_metadata_get_boolean (window->priv->metadata, "dual-page", &dual_page)) {
+		ev_document_model_set_dual_page (window->priv->model, dual_page);
 	}
 
 	/* Fullscreen */
-	if (ev_metadata_manager_get (uri, "fullscreen", &fullscreen, FALSE)) {
-		if (g_value_get_boolean (&fullscreen) && uri) {
+	if (ev_metadata_get_boolean (window->priv->metadata, "fullscreen", &fullscreen)) {
+		if (fullscreen) {
 			ev_window_run_fullscreen (window);
 		}
-		g_value_unset (&fullscreen);
 	}
 }
 
 static void
 setup_document_from_metadata (EvWindow *window)
 {
-	gchar *uri = window->priv->uri;
-	gint   page, n_pages;
-	GValue width = { 0, };
-	GValue height = { 0, };
-	GValue width_ratio = { 0, };
-	GValue height_ratio = { 0, };
+	gint    page, n_pages;
+	gint    width;
+	gint    height;
+	gdouble width_ratio;
+	gdouble height_ratio;
+
+	if (!window->priv->metadata)
+		return;
 
 	/* Make sure to not open a document on the last page,
 	 * since closing it on the last page most likely means the
@@ -1030,12 +1033,12 @@ setup_document_from_metadata (EvWindow *window)
 
 	setup_sidebar_from_metadata (window);
 
-	if (ev_metadata_manager_get (uri, "window_width", &width, TRUE) &&
-	    ev_metadata_manager_get (uri, "window_height", &height, TRUE))
+	if (ev_metadata_get_int (window->priv->metadata, "window_width", &width) &&
+	    ev_metadata_get_int (window->priv->metadata, "window_height", &height))
 		return; /* size was already set in setup_size_from_metadata */
 
-	if (ev_metadata_manager_get (uri, "window_width_ratio", &width_ratio, FALSE) &&
-	    ev_metadata_manager_get (uri, "window_height_ratio", &height_ratio, FALSE)) {
+	if (ev_metadata_get_double (window->priv->metadata, "window_width_ratio", &width_ratio) &&
+	    ev_metadata_get_double (window->priv->metadata, "window_height_ratio", &height_ratio)) {
 		gdouble    document_width;
 		gdouble    document_height;
 		GdkScreen *screen;
@@ -1045,77 +1048,68 @@ setup_document_from_metadata (EvWindow *window)
 		ev_document_get_max_page_size (window->priv->document,
 					       &document_width, &document_height);
 
-		request_width = (gint)(g_value_get_double (&width_ratio) * document_width + 0.5);
-		request_height = (gint)(g_value_get_double (&height_ratio) * document_height + 0.5);
-		
+		request_width = (gint)(width_ratio * document_width + 0.5);
+		request_height = (gint)(height_ratio * document_height + 0.5);
+
 		screen = gtk_window_get_screen (GTK_WINDOW (window));
-		
 		if (screen) {
 			request_width = MIN (request_width, gdk_screen_get_width (screen));
 			request_height = MIN (request_width, gdk_screen_get_height (screen));
 		}
-		
+
 		if (request_width > 0 && request_height > 0) {
 			gtk_window_resize (GTK_WINDOW (window),
 					   request_width,
 					   request_height);
 		}
-	    	g_value_unset (&width_ratio);
-		g_value_unset (&height_ratio);
 	}
 }
 
 static void
 setup_size_from_metadata (EvWindow *window)
 {
-	char *uri = window->priv->uri;
-	GValue width = { 0, };
-	GValue height = { 0, };
-	GValue maximized = { 0, };
-	GValue x = { 0, };
-	GValue y = { 0, };
+	gint     width;
+	gint     height;
+	gboolean maximized;
+	gint     x;
+	gint     y;
+
+	if (!window->priv->metadata)
+		return;
 
-	if (ev_metadata_manager_get (uri, "window_maximized", &maximized, FALSE)) {
-		if (g_value_get_boolean (&maximized)) {
+	if (ev_metadata_get_boolean (window->priv->metadata, "window_maximized", &maximized)) {
+		if (maximized) {
 			gtk_window_maximize (GTK_WINDOW (window));
-			g_value_unset (&maximized);
 			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_get_int (window->priv->metadata, "window_x", &x) &&
+	    ev_metadata_get_int (window->priv->metadata, "window_y", &y)) {
+		gtk_window_move (GTK_WINDOW (window), x, 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);
+        if (ev_metadata_get_int (window->priv->metadata, "window_width", &width) &&
+	    ev_metadata_get_int (window->priv->metadata, "window_height", &height)) {
+		gtk_window_resize (GTK_WINDOW (window), width, height);
 	}
 }
 
 static void
 setup_view_from_metadata (EvWindow *window)
 {
-	gchar *uri = window->priv->uri;
-	GValue presentation = { 0, };
+	gboolean presentation;
+
+	if (!window->priv->metadata)
+		return;
 
 	/* Presentation */
-	if (ev_metadata_manager_get (uri, "presentation", &presentation, FALSE)) {
-		if (g_value_get_boolean (&presentation) && uri) {
+	if (ev_metadata_get_boolean (window->priv->metadata, "presentation", &presentation)) {
+		if (presentation) {
 			ev_window_run_presentation (window);
 		}
-		g_value_unset (&presentation);
 	}
 }
 
@@ -1171,6 +1165,17 @@ ev_window_refresh_window_thumbnail (EvWindow *ev_window, int rotation)
 	ev_job_scheduler_push_job (ev_window->priv->thumbnail_job, EV_JOB_PRIORITY_NONE);
 }
 
+#ifdef WITH_GCONF
+static void
+lockdown_changed (GConfClient *client,
+		  guint        cnxn_id,
+		  GConfEntry  *entry,
+		  EvWindow    *ev_window)
+{
+	ev_window_setup_action_sensitivity (ev_window);
+}
+#endif /* WITH_GCONF */
+
 static gboolean
 ev_window_setup_document (EvWindow *ev_window)
 {
@@ -1186,6 +1191,27 @@ ev_window_setup_document (EvWindow *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);
 
+#ifdef WITH_GCONF
+	if (!ev_window->priv->gconf_client)
+		ev_window->priv->gconf_client = gconf_client_get_default ();
+	gconf_client_add_dir (ev_window->priv->gconf_client,
+			      GCONF_LOCKDOWN_DIR,
+			      GCONF_CLIENT_PRELOAD_ONELEVEL,
+			      NULL);
+	gconf_client_add_dir (ev_window->priv->gconf_client,
+			      GCONF_OVERRIDE_RESTRICTIONS,
+			      GCONF_CLIENT_PRELOAD_NONE,
+			      NULL);
+	gconf_client_notify_add (ev_window->priv->gconf_client,
+				 GCONF_LOCKDOWN_DIR,
+				 (GConfClientNotifyFunc)lockdown_changed,
+				 ev_window, NULL, NULL);
+	gconf_client_notify_add (ev_window->priv->gconf_client,
+				 GCONF_OVERRIDE_RESTRICTIONS,
+				 (GConfClientNotifyFunc)lockdown_changed,
+				 ev_window, NULL, NULL);
+#endif /* WITH_GCONF */
+
 	ev_window_setup_action_sensitivity (ev_window);
 
 	if (ev_window->priv->history)
@@ -1560,7 +1586,9 @@ show_loading_progress (EvWindow *ev_window)
 	if (ev_window->priv->message_area)
 		return FALSE;
 
-	display_name = escape_uri_for_display (ev_window->priv->uri);
+	text = g_uri_unescape_string (ev_window->priv->uri, NULL);
+	display_name = g_markup_escape_text (text, -1);
+	g_free (text);
 	text = g_strdup_printf (_("Loading document from “%s”"),
 				display_name);
 
@@ -1699,6 +1727,9 @@ window_open_file_copy_progress_cb (goffset   n_bytes,
 	if (!ev_window->priv->message_area)
 		return;
 
+	if (total_bytes <= 0)
+		return;
+
 	fraction = n_bytes / (gdouble)total_bytes;
 	status = g_strdup_printf (_("Downloading document (%d%%)"),
 				  (gint)(fraction * 100));
@@ -1718,26 +1749,39 @@ ev_window_load_file_remote (EvWindow *ev_window,
 	GFile *target_file;
 	
 	if (!ev_window->priv->local_uri) {
-		gchar *tmp_name;
-		gchar *base_name;
+		char *base_name, *template;
+                GFile *tmp_file;
+                GError *err = NULL;
 
 		/* We'd like to keep extension of source uri since
-		 * it helps to resolve some mime types, say cbz */
-		tmp_name = ev_tmp_filename (NULL);
+		 * it helps to resolve some mime types, say cbz.
+                 */
 		base_name = g_file_get_basename (source_file);
-		ev_window->priv->local_uri = g_strconcat ("file:", tmp_name, "-",
-							  base_name, NULL);
+                template = g_strdup_printf ("document.XXXXXX-%s", base_name);
+                g_free (base_name);
+
+                tmp_file = ev_mkstemp_file (template, &err);
+		g_free (template);
+                if (tmp_file == NULL) {
+                        ev_window_error_message (ev_window, err,
+                                                 "%s", _("Failed to load remote file."));
+                        g_error_free (err);
+                        return;
+                }
+
+		ev_window->priv->local_uri = g_file_get_uri (tmp_file);
+		g_object_unref (tmp_file);
+
 		ev_job_load_set_uri (EV_JOB_LOAD (ev_window->priv->load_job),
 				     ev_window->priv->local_uri);
-		g_free (base_name);
-		g_free (tmp_name);
 	}
 
 	ev_window_reset_progress_cancellable (ev_window);
 	
 	target_file = g_file_new_for_uri (ev_window->priv->local_uri);
 	g_file_copy_async (source_file, target_file,
-			   0, G_PRIORITY_DEFAULT,
+			   G_FILE_COPY_OVERWRITE,
+			   G_PRIORITY_DEFAULT,
 			   ev_window->priv->progress_cancellable,
 			   (GFileProgressCallback)window_open_file_copy_progress_cb,
 			   ev_window, 
@@ -1782,6 +1826,15 @@ ev_window_open_uri (EvWindow       *ev_window,
 		g_free (ev_window->priv->uri);
 	ev_window->priv->uri = g_strdup (uri);
 
+	if (ev_window->priv->metadata)
+		g_object_unref (ev_window->priv->metadata);
+
+	source_file = g_file_new_for_uri (uri);
+	if (ev_is_metadata_supported_for_file (source_file))
+		ev_window->priv->metadata = ev_metadata_new (source_file);
+	else
+		ev_window->priv->metadata = NULL;
+
 	if (ev_window->priv->search_string)
 		g_free (ev_window->priv->search_string);
 	ev_window->priv->search_string = search_string ?
@@ -1800,7 +1853,6 @@ ev_window_open_uri (EvWindow       *ev_window,
 			  G_CALLBACK (ev_window_load_job_cb),
 			  ev_window);
 
-	source_file = g_file_new_for_uri (uri);
 	if (!g_file_is_native (source_file) && !ev_window->priv->local_uri) {
 		ev_window_load_file_remote (ev_window, source_file);
 	} else {
@@ -1951,7 +2003,10 @@ reload_remote_copy_progress_cb (goffset   n_bytes,
 	
 	if (!ev_window->priv->message_area)
 		return;
-	
+
+	if (total_bytes <= 0)
+		return;
+
 	fraction = n_bytes / (gdouble)total_bytes;
 	status = g_strdup_printf (_("Downloading document (%d%%)"),
 				  (gint)(fraction * 100));
@@ -2063,7 +2118,7 @@ file_open_dialog_response_cb (GtkWidget *chooser,
 
 		ev_application_open_uri_list (EV_APP, uris,
 					      gtk_window_get_screen (GTK_WINDOW (ev_window)),
-					      GDK_CURRENT_TIME);
+					      gtk_get_current_event_time ());
 
 		g_slist_foreach (uris, (GFunc)g_free, NULL);
 		g_slist_free (uris);
@@ -2133,12 +2188,16 @@ static void
 ev_window_open_copy_at_dest (EvWindow   *window,
 			     EvLinkDest *dest)
 {
-	GtkWidget *new_window = ev_window_new ();
+	EvWindow *new_window = EV_WINDOW (ev_window_new ());
+
+	ev_window_n_copies++;
 
-	ev_window_open_document (EV_WINDOW (new_window),
+	if (window->priv->metadata)
+		new_window->priv->metadata = g_object_ref (window->priv->metadata);
+	ev_window_open_document (new_window,
 				 window->priv->document,
 				 dest, 0, NULL);
-	gtk_widget_show (new_window);
+	gtk_window_present (GTK_WINDOW (new_window));
 }
 
 static void
@@ -2161,7 +2220,7 @@ ev_window_cmd_recent_file_activate (GtkAction *action,
 	
 	ev_application_open_uri_at_dest (EV_APP, uri,
 					 gtk_window_get_screen (GTK_WINDOW (window)),
-					 NULL, 0, NULL, GDK_CURRENT_TIME);
+					 NULL, 0, NULL, gtk_get_current_event_time ());
 }
 
 static void
@@ -2171,7 +2230,7 @@ ev_window_open_recent_action_item_activated (EvOpenRecentAction *action,
 {
 	ev_application_open_uri_at_dest (EV_APP, uri,
 					 gtk_window_get_screen (GTK_WINDOW (window)),
-					 NULL, 0, NULL, GDK_CURRENT_TIME);
+					 NULL, 0, NULL, gtk_get_current_event_time ());
 }
 
 static void
@@ -2417,7 +2476,10 @@ window_save_file_copy_progress_cb (goffset n_bytes,
 	
 	if (!ev_window->priv->message_area)
 		return;
-	
+
+	if (total_bytes <= 0)
+		return;
+
 	fraction = n_bytes / (gdouble)total_bytes;
 	save_type = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dst), "save-type"));
 
@@ -2593,114 +2655,203 @@ ev_window_cmd_save_as (GtkAction *action, EvWindow *ev_window)
 	gtk_widget_show (fc);
 }
 
+static GKeyFile *
+get_print_settings_file (void)
+{
+	GKeyFile *print_settings_file;
+	gchar    *filename;
+        GError *error = NULL;
+
+	print_settings_file = g_key_file_new ();
+
+	filename = g_build_filename (ev_application_get_dot_dir (EV_APP, FALSE),
+                                     EV_PRINT_SETTINGS_FILE, NULL);
+        if (!g_key_file_load_from_file (print_settings_file,
+                                        filename,
+                                        G_KEY_FILE_KEEP_COMMENTS |
+                                        G_KEY_FILE_KEEP_TRANSLATIONS,
+                                        &error)) {
+
+                /* Don't warn if the file simply doesn't exist */
+                if (!g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NOENT))
+			g_warning ("%s", error->message);
+
+                g_error_free (error);
+	}
+
+	g_free (filename);
+
+	return print_settings_file;
+}
+
 static void
-ev_window_load_print_settings_from_metadata (EvWindow *window)
+save_print_setting_file (GKeyFile *key_file)
 {
-	gchar *uri = window->priv->uri;
-	gint   i;
-	
-	/* Load print setting that are specific to the document */
-	for (i = 0; i < G_N_ELEMENTS (document_print_settings); i++) {
-		GValue   value = { 0, };
-		gboolean success;
+	gchar  *filename;
+	gchar  *data;
+	gsize  data_length;
+	GError *error = NULL;
 
-		success = ev_metadata_manager_get (uri, document_print_settings[i], &value, TRUE);
-		gtk_print_settings_set (window->priv->print_settings,
-					document_print_settings[i],
-					success ? g_value_get_string (&value) : NULL);
-		if (success)
-			g_value_unset (&value);
+	filename = g_build_filename (ev_application_get_dot_dir (EV_APP, TRUE),
+				     EV_PRINT_SETTINGS_FILE, NULL);
+	data = g_key_file_to_data (key_file, &data_length, NULL);
+	g_file_set_contents (filename, data, data_length, &error);
+	if (error) {
+		g_warning ("Failed to save print settings: %s", error->message);
+		g_error_free (error);
 	}
+	g_free (data);
+	g_free (filename);
 }
 
 static void
-ev_window_save_print_settings (EvWindow *window)
+ev_window_save_print_settings (EvWindow         *window,
+			       GtkPrintSettings *print_settings)
 {
-	gchar *uri = window->priv->uri;
-	gint   i;
-	
+	GKeyFile *key_file;
+	gint      i;
+
+	key_file = get_print_settings_file ();
+	gtk_print_settings_to_key_file (print_settings, key_file, EV_PRINT_SETTINGS_GROUP);
+	save_print_setting_file (key_file);
+	g_key_file_free (key_file);
+
+	if (!window->priv->metadata)
+		return;
+
 	/* Save print settings that are specific to the document */
 	for (i = 0; i < G_N_ELEMENTS (document_print_settings); i++) {
 		const gchar *value;
 
-		value = gtk_print_settings_get (window->priv->print_settings,
+		value = gtk_print_settings_get (print_settings,
 						document_print_settings[i]);
-		ev_metadata_manager_set_string (uri, document_print_settings[i], value);
+		ev_metadata_set_string (window->priv->metadata,
+					document_print_settings[i], value);
 	}
 }
 
 static void
-ev_window_save_print_page_setup (EvWindow *window)
+ev_window_save_print_page_setup (EvWindow     *window,
+				 GtkPageSetup *page_setup)
 {
-	gchar        *uri = window->priv->uri;
-	GtkPageSetup *page_setup = window->priv->print_page_setup;
+	GKeyFile *key_file;
+
+	key_file = get_print_settings_file ();
+	gtk_page_setup_to_key_file (page_setup, key_file, EV_PAGE_SETUP_GROUP);
+	save_print_setting_file (key_file);
+	g_key_file_free (key_file);
+
+	if (!window->priv->metadata)
+		return;
 
 	/* Save page setup options that are specific to the document */
-	ev_metadata_manager_set_int (uri, "page-setup-orientation",
-				     gtk_page_setup_get_orientation (page_setup));
-	ev_metadata_manager_set_double (uri, "page-setup-margin-top",
-					gtk_page_setup_get_top_margin (page_setup, GTK_UNIT_MM));
-	ev_metadata_manager_set_double (uri, "page-setup-margin-bottom",
-					gtk_page_setup_get_bottom_margin (page_setup, GTK_UNIT_MM));
-	ev_metadata_manager_set_double (uri, "page-setup-margin-left",
-					gtk_page_setup_get_left_margin (page_setup, GTK_UNIT_MM));
-	ev_metadata_manager_set_double (uri, "page-setup-margin-right",
-					gtk_page_setup_get_right_margin (page_setup, GTK_UNIT_MM));
+	ev_metadata_set_int (window->priv->metadata, "page-setup-orientation",
+			     gtk_page_setup_get_orientation (page_setup));
+	ev_metadata_set_double (window->priv->metadata, "page-setup-margin-top",
+				gtk_page_setup_get_top_margin (page_setup, GTK_UNIT_MM));
+	ev_metadata_set_double (window->priv->metadata, "page-setup-margin-bottom",
+				gtk_page_setup_get_bottom_margin (page_setup, GTK_UNIT_MM));
+	ev_metadata_set_double (window->priv->metadata, "page-setup-margin-left",
+				gtk_page_setup_get_left_margin (page_setup, GTK_UNIT_MM));
+	ev_metadata_set_double (window->priv->metadata, "page-setup-margin-right",
+				gtk_page_setup_get_right_margin (page_setup, GTK_UNIT_MM));
 }
 
 static void
-ev_window_load_print_page_setup_from_metadata (EvWindow *window)
+ev_window_load_print_settings_from_metadata (EvWindow         *window,
+					     GtkPrintSettings *print_settings)
 {
-	gchar        *uri = window->priv->uri;
-	GtkPageSetup *page_setup = window->priv->print_page_setup;
-	GtkPaperSize *paper_size;
-	GValue        value = { 0, };
+	gint i;
+
+	if (!window->priv->metadata)
+		return;
+
+	/* Load print setting that are specific to the document */
+	for (i = 0; i < G_N_ELEMENTS (document_print_settings); i++) {
+		gchar *value = NULL;
+
+		ev_metadata_get_string (window->priv->metadata,
+					document_print_settings[i], &value);
+		gtk_print_settings_set (print_settings,
+					document_print_settings[i], value);
+	}
+}
+
+static void
+ev_window_load_print_page_setup_from_metadata (EvWindow     *window,
+					       GtkPageSetup *page_setup)
+{
+	gint          int_value;
+	gdouble       double_value;
+	GtkPaperSize *paper_size = gtk_page_setup_get_paper_size (page_setup);
 
-	paper_size = gtk_page_setup_get_paper_size (page_setup);
-	
 	/* Load page setup options that are specific to the document */
-	if (ev_metadata_manager_get (uri, "page-setup-orientation", &value, TRUE)) {
-		gtk_page_setup_set_orientation (page_setup, g_value_get_int (&value));
-		g_value_unset (&value);
+	if (window->priv->metadata &&
+	    ev_metadata_get_int (window->priv->metadata, "page-setup-orientation", &int_value)) {
+		gtk_page_setup_set_orientation (page_setup, int_value);
 	} else {
 		gtk_page_setup_set_orientation (page_setup, GTK_PAGE_ORIENTATION_PORTRAIT);
 	}
-	
-	if (ev_metadata_manager_get (uri, "page-setup-margin-top", &value, TRUE)) {
-		gtk_page_setup_set_top_margin (page_setup, g_value_get_double (&value), GTK_UNIT_MM);
-		g_value_unset (&value);
+
+	if (window->priv->metadata &&
+	    ev_metadata_get_double (window->priv->metadata, "page-setup-margin-top", &double_value)) {
+		gtk_page_setup_set_top_margin (page_setup, double_value, GTK_UNIT_MM);
 	} else {
 		gtk_page_setup_set_top_margin (page_setup,
 					       gtk_paper_size_get_default_top_margin (paper_size, GTK_UNIT_MM),
 					       GTK_UNIT_MM);
 	}
 
-	if (ev_metadata_manager_get (uri, "page-setup-margin-bottom", &value, TRUE)) {
-		gtk_page_setup_set_bottom_margin (page_setup, g_value_get_double (&value), GTK_UNIT_MM);
-		g_value_unset (&value);
+	if (window->priv->metadata &&
+	    ev_metadata_get_double (window->priv->metadata, "page-setup-margin-bottom", &double_value)) {
+		gtk_page_setup_set_bottom_margin (page_setup, double_value, GTK_UNIT_MM);
 	} else {
 		gtk_page_setup_set_bottom_margin (page_setup,
 						  gtk_paper_size_get_default_bottom_margin (paper_size, GTK_UNIT_MM),
 						  GTK_UNIT_MM);
 	}
 
-	if (ev_metadata_manager_get (uri, "page-setup-margin-left", &value, TRUE)) {
-		gtk_page_setup_set_left_margin (page_setup, g_value_get_double (&value), GTK_UNIT_MM);
-		g_value_unset (&value);
+	if (window->priv->metadata &&
+	    ev_metadata_get_double (window->priv->metadata, "page-setup-margin-left", &double_value)) {
+		gtk_page_setup_set_left_margin (page_setup, double_value, GTK_UNIT_MM);
 	} else {
 		gtk_page_setup_set_left_margin (page_setup,
 						gtk_paper_size_get_default_left_margin (paper_size, GTK_UNIT_MM),
 						GTK_UNIT_MM);
-	}	
+	}
 
-	if (ev_metadata_manager_get (uri, "page-setup-margin-right", &value, TRUE)) {
-		gtk_page_setup_set_right_margin (page_setup, g_value_get_double (&value), GTK_UNIT_MM);
-		g_value_unset (&value);
+	if (window->priv->metadata &&
+	    ev_metadata_get_double (window->priv->metadata, "page-setup-margin-right", &double_value)) {
+		gtk_page_setup_set_right_margin (page_setup, double_value, GTK_UNIT_MM);
 	} else {
 		gtk_page_setup_set_right_margin (page_setup,
 						 gtk_paper_size_get_default_right_margin (paper_size, GTK_UNIT_MM),
 						 GTK_UNIT_MM);
-	}	
+	}
+}
+
+static GtkPrintSettings *
+get_print_settings (GKeyFile *key_file)
+{
+	GtkPrintSettings *print_settings;
+
+	print_settings = g_key_file_has_group (key_file, EV_PRINT_SETTINGS_GROUP) ?
+		gtk_print_settings_new_from_key_file (key_file, EV_PRINT_SETTINGS_GROUP, NULL) :
+		gtk_print_settings_new ();
+
+	return print_settings ? print_settings : gtk_print_settings_new ();
+}
+
+static GtkPageSetup *
+get_print_page_setup (GKeyFile *key_file)
+{
+	GtkPageSetup *page_setup;
+
+	page_setup = g_key_file_has_group (key_file, EV_PAGE_SETUP_GROUP) ?
+		gtk_page_setup_new_from_key_file (key_file, EV_PAGE_SETUP_GROUP, NULL) :
+		gtk_page_setup_new ();
+
+	return page_setup ? page_setup : gtk_page_setup_new ();
 }
 
 static void
@@ -2711,31 +2862,33 @@ ev_window_print_page_setup_done_cb (GtkPageSetup *page_setup,
 	if (!page_setup)
 		return;
 
-	if (window->priv->print_page_setup != page_setup) {
-		if (window->priv->print_page_setup)
-			g_object_unref (window->priv->print_page_setup);
-		window->priv->print_page_setup = g_object_ref (page_setup);
-	}
-	
-	ev_application_set_page_setup (EV_APP, page_setup);
-	ev_window_save_print_page_setup (window);
+	ev_window_save_print_page_setup (window, page_setup);
 }
 
 static void
-ev_window_cmd_file_print_setup (GtkAction *action, EvWindow *ev_window)
+ev_window_cmd_file_print_setup (GtkAction *action,
+				EvWindow  *ev_window)
 {
-	if (!ev_window->priv->print_page_setup) {
-		ev_window->priv->print_page_setup = gtk_page_setup_copy (
-			ev_application_get_page_setup (EV_APP));
-		ev_window_load_print_page_setup_from_metadata (ev_window);
-	}
-	
-	gtk_print_run_page_setup_dialog_async (
-		GTK_WINDOW (ev_window),
-		ev_window->priv->print_page_setup,
-		ev_window->priv->print_settings,
-		(GtkPageSetupDoneFunc) ev_window_print_page_setup_done_cb,
-		ev_window);
+	GKeyFile         *print_settings_file;
+	GtkPrintSettings *print_settings;
+	GtkPageSetup     *print_page_setup;
+
+	print_settings_file = get_print_settings_file ();
+
+	print_settings = get_print_settings (print_settings_file);
+	ev_window_load_print_settings_from_metadata (ev_window, print_settings);
+
+	print_page_setup = get_print_page_setup (print_settings_file);
+	ev_window_load_print_page_setup_from_metadata (ev_window, print_page_setup);
+
+	gtk_print_run_page_setup_dialog_async (GTK_WINDOW (ev_window),
+					       print_page_setup,
+					       print_settings,
+					       (GtkPageSetupDoneFunc)ev_window_print_page_setup_done_cb,
+					       ev_window);
+	g_object_unref (print_settings);
+	g_object_unref (print_page_setup);
+	g_key_file_free (print_settings_file);
 }
 
 static void
@@ -2791,20 +2944,20 @@ ev_window_print_operation_done (EvPrintOperation       *op,
 				EvWindow               *ev_window)
 {
 	gint n_jobs;
-	
+
 	switch (result) {
 	case GTK_PRINT_OPERATION_RESULT_APPLY: {
 		GtkPrintSettings *print_settings;
-		
+
 		print_settings = ev_print_operation_get_print_settings (op);
-		if (ev_window->priv->print_settings != print_settings) {
-			if (ev_window->priv->print_settings)
-				g_object_unref (ev_window->priv->print_settings);
-			ev_window->priv->print_settings = g_object_ref (print_settings);
+		ev_window_save_print_settings (ev_window, print_settings);
+
+		if (ev_print_operation_get_embed_page_setup (op)) {
+			GtkPageSetup *page_setup;
+
+			page_setup = ev_print_operation_get_default_page_setup (op);
+			ev_window_save_print_page_setup (ev_window, page_setup);
 		}
-		
-		ev_application_set_print_settings (EV_APP, print_settings);
-		ev_window_save_print_settings (ev_window);
 	}
 
 		break;
@@ -2908,19 +3061,12 @@ static void
 ev_window_print_operation_begin_print (EvPrintOperation *op,
 				       EvWindow         *ev_window)
 {
-	GtkPrintSettings *print_settings;
-	
 	if (!ev_window->priv->print_queue)
 		ev_window->priv->print_queue = g_queue_new ();
 
 	g_queue_push_head (ev_window->priv->print_queue, op);
 	ev_window_print_update_pending_jobs_message (ev_window,
 						     g_queue_get_length (ev_window->priv->print_queue));
-	
-	if (ev_window->priv->print_settings)
-		g_object_unref (ev_window->priv->print_settings);
-	print_settings = ev_print_operation_get_print_settings (op);
-	ev_window->priv->print_settings = g_object_ref (print_settings);
 }
 
 void
@@ -2929,6 +3075,9 @@ ev_window_print_range (EvWindow *ev_window,
 		       gint      last_page)
 {
 	EvPrintOperation *op;
+	GKeyFile         *print_settings_file;
+	GtkPrintSettings *print_settings;
+	GtkPageSetup     *print_page_setup;
 	gint              current_page;
 	gint              document_last_page;
 
@@ -2957,17 +3106,13 @@ ev_window_print_range (EvWindow *ev_window,
 	current_page = ev_document_model_get_page (ev_window->priv->model);
 	document_last_page = ev_document_get_n_pages (ev_window->priv->document);
 
-	if (!ev_window->priv->print_settings) {
-		ev_window->priv->print_settings = gtk_print_settings_copy (
-			ev_application_get_print_settings (EV_APP));
-		ev_window_load_print_settings_from_metadata (ev_window);
-	}
+	print_settings_file = get_print_settings_file ();
 
-	if (!ev_window->priv->print_page_setup) {
-		ev_window->priv->print_page_setup = gtk_page_setup_copy (
-			ev_application_get_page_setup (EV_APP));
-		ev_window_load_print_page_setup_from_metadata (ev_window);
-	}
+	print_settings = get_print_settings (print_settings_file);
+	ev_window_load_print_settings_from_metadata (ev_window, print_settings);
+
+	print_page_setup = get_print_page_setup (print_settings_file);
+	ev_window_load_print_page_setup_from_metadata (ev_window, print_page_setup);
 
 	if (first_page != 1 || last_page != document_last_page) {
 		GtkPageRange range;
@@ -2975,17 +3120,28 @@ ev_window_print_range (EvWindow *ev_window,
 		/* 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_settings_set_print_pages (print_settings,
 						    GTK_PRINT_PAGES_RANGES);
-		gtk_print_settings_set_page_ranges (ev_window->priv->print_settings,
+		gtk_print_settings_set_page_ranges (print_settings,
 						    &range, 1);
 	}
 
 	ev_print_operation_set_job_name (op, gtk_window_get_title (GTK_WINDOW (ev_window)));
 	ev_print_operation_set_current_page (op, current_page);
-	ev_print_operation_set_print_settings (op, ev_window->priv->print_settings);
-	ev_print_operation_set_default_page_setup (op, ev_window->priv->print_page_setup);
+	ev_print_operation_set_print_settings (op, print_settings);
+	ev_print_operation_set_default_page_setup (op, print_page_setup);
+#ifdef WITH_GCONF
+	ev_print_operation_set_embed_page_setup (op, !gconf_client_get_bool (ev_window->priv->gconf_client,
+									     GCONF_LOCKDOWN_PRINT_SETUP,
+									     NULL));
+#else
+	ev_print_operation_set_embed_page_setup (op, TRUE);
+#endif
+
+	g_object_unref (print_settings);
+	g_object_unref (print_page_setup);
+	g_key_file_free (print_settings_file);
 
 	ev_print_operation_run (op, GTK_WINDOW (ev_window));
 }
@@ -3246,12 +3402,13 @@ ev_window_cmd_edit_copy (GtkAction *action, EvWindow *ev_window)
 }
 
 static void
-ev_window_sidebar_position_change_cb (GObject *object, GParamSpec *pspec,
-				      EvWindow *ev_window)
+ev_window_sidebar_position_change_cb (GObject    *object,
+				      GParamSpec *pspec,
+				      EvWindow   *ev_window)
 {
-	if (!ev_window_is_empty (ev_window))
-		ev_metadata_manager_set_int (ev_window->priv->uri, "sidebar_size",
-					     gtk_paned_get_position (GTK_PANED (object)));
+	if (ev_window->priv->metadata && !ev_window_is_empty (ev_window))
+		ev_metadata_set_int (ev_window->priv->metadata, "sidebar_size",
+				     gtk_paned_get_position (GTK_PANED (object)));
 }
 
 static void
@@ -3356,8 +3513,8 @@ ev_window_run_fullscreen (EvWindow *window)
 		gtk_window_fullscreen (GTK_WINDOW (window));
 	gtk_widget_grab_focus (window->priv->view);
 
-	if (!ev_window_is_empty (window))
-		ev_metadata_manager_set_boolean (window->priv->uri, "fullscreen", TRUE);
+	if (window->priv->metadata && !ev_window_is_empty (window))
+		ev_metadata_set_boolean (window->priv->metadata, "fullscreen", TRUE);
 }
 
 static void
@@ -3378,8 +3535,8 @@ ev_window_stop_fullscreen (EvWindow *window,
 	if (unfullscreen_window)
 		gtk_window_unfullscreen (GTK_WINDOW (window));
 
-	if (!ev_window_is_empty (window))
-		ev_metadata_manager_set_boolean (window->priv->uri, "fullscreen", FALSE);
+	if (window->priv->metadata && !ev_window_is_empty (window))
+		ev_metadata_set_boolean (window->priv->metadata, "fullscreen", FALSE);
 }
 
 static void
@@ -3512,8 +3669,8 @@ ev_window_run_presentation (EvWindow *window)
 
 	ev_application_screensaver_disable (EV_APP);
 	
-	if (!ev_window_is_empty (window))
-		ev_metadata_manager_set_boolean (window->priv->uri, "presentation", TRUE);
+	if (window->priv->metadata && !ev_window_is_empty (window))
+		ev_metadata_set_boolean (window->priv->metadata, "presentation", TRUE);
 }
 
 static void
@@ -3545,8 +3702,8 @@ ev_window_stop_presentation (EvWindow *window,
 
 	ev_application_screensaver_enable (EV_APP);
 
-	if (!ev_window_is_empty (window))
-		ev_metadata_manager_set_boolean (window->priv->uri, "presentation", FALSE);
+	if (window->priv->metadata && !ev_window_is_empty (window))
+		ev_metadata_set_boolean (window->priv->metadata, "presentation", FALSE);
 }
 
 static void
@@ -3692,42 +3849,54 @@ ev_window_cmd_edit_rotate_right (GtkAction *action, EvWindow *ev_window)
 }
 
 static void
-ev_window_cmd_edit_toolbar_cb (GtkDialog *dialog, gint response, gpointer data)
+ev_window_cmd_edit_toolbar_cb (GtkDialog *dialog,
+			       gint       response,
+			       EvWindow  *ev_window)
 {
-	EvWindow *ev_window = EV_WINDOW (data);
-        egg_editable_toolbar_set_edit_mode
-			(EGG_EDITABLE_TOOLBAR (ev_window->priv->toolbar), FALSE);
-	ev_application_save_toolbars_model (EV_APP);
+	EggEditableToolbar *toolbar;
+	gchar              *toolbars_file;
+
+	toolbar = EGG_EDITABLE_TOOLBAR (ev_window->priv->toolbar);
+        egg_editable_toolbar_set_edit_mode (toolbar, FALSE);
+
+	toolbars_file = g_build_filename (ev_application_get_dot_dir (EV_APP, TRUE),
+					  "evince_toolbar.xml", NULL);
+	egg_toolbars_model_save_toolbars (egg_editable_toolbar_get_model (toolbar),
+					  toolbars_file, "1.0");
+	g_free (toolbars_file);
+
         gtk_widget_destroy (GTK_WIDGET (dialog));
 }
 
 static void
 ev_window_cmd_edit_toolbar (GtkAction *action, EvWindow *ev_window)
 {
-	GtkWidget *dialog;
-	GtkWidget *editor;
+	GtkWidget          *dialog;
+	GtkWidget          *editor;
+	EggEditableToolbar *toolbar;
 
 	dialog = gtk_dialog_new_with_buttons (_("Toolbar Editor"),
-					      GTK_WINDOW (ev_window), 
-				              GTK_DIALOG_DESTROY_WITH_PARENT, 
+					      GTK_WINDOW (ev_window),
+				              GTK_DIALOG_DESTROY_WITH_PARENT,
 					      GTK_STOCK_CLOSE,
-					      GTK_RESPONSE_CLOSE, 
+					      GTK_RESPONSE_CLOSE,
 					      NULL);
 	gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);
 	gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)), 5);
 	gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 2);
 	gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
 	gtk_window_set_default_size (GTK_WINDOW (dialog), 500, 400);
-	  
+
+	toolbar = EGG_EDITABLE_TOOLBAR (ev_window->priv->toolbar);
 	editor = egg_toolbar_editor_new (ev_window->priv->ui_manager,
-					 ev_application_get_toolbars_model (EV_APP));
+					 egg_editable_toolbar_get_model (toolbar));
+
 	gtk_container_set_border_width (GTK_CONTAINER (editor), 5);
 	gtk_box_set_spacing (GTK_BOX (EGG_TOOLBAR_EDITOR (editor)), 5);
-             
+
 	gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), editor);
 
-	egg_editable_toolbar_set_edit_mode
-		(EGG_EDITABLE_TOOLBAR (ev_window->priv->toolbar), TRUE);
+	egg_editable_toolbar_set_edit_mode (toolbar, TRUE);
 
 	g_signal_connect (dialog, "response",
 			  G_CALLBACK (ev_window_cmd_edit_toolbar_cb),
@@ -3834,7 +4003,7 @@ ev_window_cmd_help_contents (GtkAction *action, EvWindow *ev_window)
 
 	gtk_show_uri (gtk_window_get_screen (GTK_WINDOW (ev_window)),
 		      "ghelp:evince",
-		      GDK_CURRENT_TIME,
+		      gtk_get_current_event_time (),
 		      &error);
 	if (error) {
 		ev_window_error_message (ev_window, error, 
@@ -3896,13 +4065,13 @@ save_sizing_mode (EvWindow *window)
 	EvSizingMode mode;
 	GEnumValue *enum_value;
 
-	if (ev_window_is_empty (window))
+	if (!window->priv->metadata || ev_window_is_empty (window))
 		return;
 
 	mode = ev_document_model_get_sizing_mode (window->priv->model);
 	enum_value = g_enum_get_value (g_type_class_peek (EV_TYPE_SIZING_MODE), mode);
-	ev_metadata_manager_set_string (window->priv->uri, "sizing_mode",
-					enum_value->value_nick);
+	ev_metadata_set_string (window->priv->metadata, "sizing_mode",
+				enum_value->value_nick);
 }
 
 static void
@@ -3937,12 +4106,15 @@ ev_window_zoom_changed_cb (EvDocumentModel *model, GParamSpec *pspec, EvWindow *
 {
         ev_window_update_actions (ev_window);
 
+	if (!ev_window->priv->metadata)
+		return;
+
 	if (ev_document_model_get_sizing_mode (model) == EV_SIZING_FREE && !ev_window_is_empty (ev_window)) {
 		gdouble zoom;
 
 		zoom = ev_document_model_get_scale (model);
-		zoom *= 72.0 / get_screen_dpi (GTK_WINDOW(ev_window));
-		ev_metadata_manager_set_double (ev_window->priv->uri, "zoom", zoom);
+		zoom *= 72.0 / get_screen_dpi (GTK_WINDOW (ev_window));
+		ev_metadata_set_double (ev_window->priv->metadata, "zoom", zoom);
 	}
 }
 
@@ -3981,19 +4153,21 @@ ev_window_continuous_changed_cb (EvDocumentModel *model,
 {
 	ev_window_update_continuous_action (ev_window);
 
-	if (!ev_window_is_empty (ev_window))
-		ev_metadata_manager_set_boolean (ev_window->priv->uri, "continuous",
-					         ev_document_model_get_continuous (model));
+	if (ev_window->priv->metadata && !ev_window_is_empty (ev_window))
+		ev_metadata_set_boolean (ev_window->priv->metadata, "continuous",
+					 ev_document_model_get_continuous (model));
 }
 
 static void
-ev_window_rotation_changed_cb (EvDocumentModel *model, GParamSpec *pspec, EvWindow *window)
+ev_window_rotation_changed_cb (EvDocumentModel *model,
+			       GParamSpec      *pspec,
+			       EvWindow        *window)
 {
 	gint rotation = ev_document_model_get_rotation (model);
 
-	if (!ev_window_is_empty (window))
-		ev_metadata_manager_set_int (window->priv->uri, "rotation",
-					     rotation);
+	if (window->priv->metadata && !ev_window_is_empty (window))
+		ev_metadata_set_int (window->priv->metadata, "rotation",
+				     rotation);
 
 	ev_window_refresh_window_thumbnail (window, rotation);
 }
@@ -4011,9 +4185,9 @@ ev_window_dual_mode_changed_cb (EvDocumentModel *model,
 {
 	ev_window_update_dual_page_action (ev_window);
 
-	if (!ev_window_is_empty (ev_window))
-		ev_metadata_manager_set_boolean (ev_window->priv->uri, "dual-page",
-					         ev_document_model_get_dual_page (model));
+	if (ev_window->priv->metadata && !ev_window_is_empty (ev_window))
+		ev_metadata_set_boolean (ev_window->priv->metadata, "dual-page",
+					 ev_document_model_get_dual_page (model));
 }
 
 static char *
@@ -4125,7 +4299,8 @@ ev_window_view_toolbar_cb (GtkAction *action, EvWindow *ev_window)
 	active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
 	update_chrome_flag (ev_window, EV_CHROME_TOOLBAR, active);
 	update_chrome_visibility (ev_window);
-	ev_metadata_manager_set_boolean (NULL, "show_toolbar", active);
+	if (ev_window->priv->metadata)
+		ev_metadata_set_boolean (ev_window->priv->metadata, "show_toolbar", active);
 }
 
 static void
@@ -4163,8 +4338,8 @@ ev_window_sidebar_current_page_changed_cb (EvSidebar  *ev_sidebar,
 
 	g_object_unref (current_page);
 
-	if (!ev_window_is_empty (ev_window))
-		ev_metadata_manager_set_string (ev_window->priv->uri, "sidebar_page", id);
+	if (ev_window->priv->metadata && !ev_window_is_empty (ev_window))
+		ev_metadata_set_string (ev_window->priv->metadata, "sidebar_page", id);
 }
 
 static void
@@ -4181,8 +4356,9 @@ ev_window_sidebar_visibility_changed_cb (EvSidebar  *ev_sidebar,
 		gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
 					      GTK_WIDGET_VISIBLE (ev_sidebar));
 
-		ev_metadata_manager_set_boolean (ev_window->priv->uri, "sidebar_visibility",
-					         GTK_WIDGET_VISIBLE (ev_sidebar));
+		if (ev_window->priv->metadata)
+			ev_metadata_set_boolean (ev_window->priv->metadata, "sidebar_visibility",
+						 GTK_WIDGET_VISIBLE (ev_sidebar));
 	}
 }
 
@@ -4541,15 +4717,13 @@ ev_window_drag_data_received (GtkWidget        *widget,
 static void
 ev_window_finalize (GObject *object)
 {
-	GList *windows = ev_application_get_windows (EV_APP);
+	G_OBJECT_CLASS (ev_window_parent_class)->finalize (object);
 
-	if (windows == NULL) {
+	if (ev_window_n_copies == 0) {
 		ev_application_shutdown (EV_APP);
 	} else {
-		g_list_free (windows);
+		ev_window_n_copies--;
 	}
-	
-	G_OBJECT_CLASS (ev_window_parent_class)->finalize (object);
 }
 
 static void
@@ -4564,12 +4738,24 @@ ev_window_dispose (GObject *object)
 						      ev_window_media_player_key_pressed,
 						      window);
 	}
-	
+
+	if (priv->metadata) {
+		g_object_unref (priv->metadata);
+		priv->metadata = NULL;
+	}
+
 	if (priv->setup_document_idle > 0) {
 		g_source_remove (priv->setup_document_idle);
 		priv->setup_document_idle = 0;
 	}
-	
+
+#ifdef WITH_GCONF
+	if (priv->gconf_client) {
+		g_object_unref (priv->gconf_client);
+		priv->gconf_client = NULL;
+	}
+#endif
+
 	if (priv->monitor) {
 		g_object_unref (priv->monitor);
 		priv->monitor = NULL;
@@ -4670,16 +4856,6 @@ ev_window_dispose (GObject *object)
 	
 	ev_window_close_dialogs (window);
 
-	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;
-	}
-
 	if (priv->link) {
 		g_object_unref (priv->link);
 		priv->link = NULL;
@@ -4928,6 +5104,10 @@ static const GtkActionEntry entries[] = {
           G_CALLBACK (ev_window_cmd_scroll_forward) },
         { "ShiftReturn", NULL, "", "<shift>Return", NULL,
           G_CALLBACK (ev_window_cmd_scroll_backward) },
+	{ "p", GTK_STOCK_GO_UP, "", "p", NULL,
+	  G_CALLBACK (ev_window_cmd_go_previous_page) },
+	{ "n", GTK_STOCK_GO_DOWN, "", "n", NULL,
+	  G_CALLBACK (ev_window_cmd_go_next_page) },
         { "Plus", GTK_STOCK_ZOOM_IN, NULL, "plus", NULL,
           G_CALLBACK (ev_window_cmd_view_zoom_in) },
         { "CtrlEqual", GTK_STOCK_ZOOM_IN, NULL, "<control>equal", NULL,
@@ -5218,8 +5398,8 @@ window_state_event_cb (EvWindow *window, GdkEventWindowState *event, gpointer du
 		gboolean maximized;
 
 		maximized = event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED;
-		if (!ev_window_is_empty (window))
-			ev_metadata_manager_set_boolean (window->priv->uri, "window_maximized", maximized);
+		if (window->priv->metadata && !ev_window_is_empty (window))
+			ev_metadata_set_boolean (window->priv->metadata, "window_maximized", maximized);
 	}
 
 	return FALSE;
@@ -5228,25 +5408,26 @@ window_state_event_cb (EvWindow *window, GdkEventWindowState *event, gpointer du
 static gboolean
 window_configure_event_cb (EvWindow *window, GdkEventConfigure *event, gpointer dummy)
 {
-	char *uri = window->priv->uri;
 	GdkWindowState state;
 	gdouble document_width, document_height;
 
+	if (!window->priv->metadata)
+		return FALSE;
+
 	state = gdk_window_get_state (GTK_WIDGET (window)->window);
 
 	if (!(state & GDK_WINDOW_STATE_FULLSCREEN)) {
 		if (!ev_window_is_empty (window) && window->priv->document) {
 			ev_document_get_max_page_size (window->priv->document,
 						       &document_width, &document_height);
-			ev_metadata_manager_set_double (uri, "window_width_ratio",
-							(double)event->width / document_width);
-			ev_metadata_manager_set_double (uri, "window_height_ratio",
-							(double)event->height / document_height);
-
-			ev_metadata_manager_set_int (uri, "window_x", event->x);
-			ev_metadata_manager_set_int (uri, "window_y", event->y);
-			ev_metadata_manager_set_int (uri, "window_width", event->width);
-			ev_metadata_manager_set_int (uri, "window_height", event->height);
+			ev_metadata_set_double (window->priv->metadata, "window_width_ratio",
+						(double)event->width / document_width);
+			ev_metadata_set_double (window->priv->metadata, "window_height_ratio",
+						(double)event->height / document_height);
+			ev_metadata_set_int (window->priv->metadata, "window_x", event->x);
+			ev_metadata_set_int (window->priv->metadata, "window_y", event->y);
+			ev_metadata_set_int (window->priv->metadata, "window_width", event->width);
+			ev_metadata_set_int (window->priv->metadata, "window_height", event->height);
 		}
 	}
 
@@ -5294,7 +5475,8 @@ launch_action (EvWindow *window, EvLinkAction *action)
 	context = G_APP_LAUNCH_CONTEXT (gdk_app_launch_context_new ());
 	gdk_app_launch_context_set_screen (GDK_APP_LAUNCH_CONTEXT (context),
 					   gtk_window_get_screen (GTK_WINDOW (window)));
-	gdk_app_launch_context_set_timestamp (GDK_APP_LAUNCH_CONTEXT (context), GDK_CURRENT_TIME);
+	gdk_app_launch_context_set_timestamp (GDK_APP_LAUNCH_CONTEXT (context),
+                                              gtk_get_current_event_time ());
 	
 	file_list.data = file;
 	if (!g_app_info_launch (app_info, &file_list, context, &error)) {
@@ -5306,6 +5488,7 @@ launch_action (EvWindow *window, EvLinkAction *action)
 	
 	g_object_unref (app_info);
 	g_object_unref (file);
+        /* FIXMEchpe: unref launch context? */
 
 	/* According to the PDF spec filename can be an executable. I'm not sure
 	   allowing to launch executables is a good idea though. -- marco */
@@ -5323,7 +5506,7 @@ launch_external_uri (EvWindow *window, EvLinkAction *action)
 	gdk_app_launch_context_set_screen (GDK_APP_LAUNCH_CONTEXT (context),
 					   gtk_window_get_screen (GTK_WINDOW (window)));
 	gdk_app_launch_context_set_timestamp (GDK_APP_LAUNCH_CONTEXT (context),
-					      GDK_CURRENT_TIME);
+					      gtk_get_current_event_time ());
 
 	if (!g_strstr_len (uri, strlen (uri), "://") &&
 	    !g_str_has_prefix (uri, "mailto:")) {
@@ -5331,10 +5514,10 @@ launch_external_uri (EvWindow *window, EvLinkAction *action)
 		
 		/* Not a valid uri, assuming it's http */
 		http = g_strdup_printf ("http://%s", uri);
-		ret = g_app_info_launch_default_for_uri (http, NULL, &error);
+		ret = g_app_info_launch_default_for_uri (http, context, &error);
 		g_free (http);
 	} else {
-		ret = g_app_info_launch_default_for_uri (uri, NULL, &error);
+		ret = g_app_info_launch_default_for_uri (uri, context, &error);
 	}
 	
   	if (ret == FALSE) {
@@ -5342,6 +5525,8 @@ launch_external_uri (EvWindow *window, EvLinkAction *action)
 					 "%s", _("Unable to open external link"));
 		g_error_free (error);
 	}
+
+        /* FIXMEchpe: unref launch context? */
 }
 
 static void
@@ -5361,7 +5546,7 @@ open_remote_link (EvWindow *window, EvLinkAction *action)
 					 ev_link_action_get_dest (action),
 					 0,
 					 NULL, 
-					 GDK_CURRENT_TIME);
+					 gtk_get_current_event_time ());
 
 	g_free (uri);
 }
@@ -5528,7 +5713,9 @@ image_save_dialog_response_cb (GtkWidget *fc,
 	if (is_native) {
 		filename = g_file_get_path (target_file);
 	} else {
-		filename = ev_tmp_filename ("saveimage");
+                /* Create a temporary local file to save to */
+                if (ev_mkstemp ("saveimage.XXXXXX", &filename, &error) == -1)
+                        goto has_error;
 	}
 
 	ev_document_doc_mutex_lock ();
@@ -5541,6 +5728,7 @@ image_save_dialog_response_cb (GtkWidget *fc,
 	g_free (file_format);
 	g_object_unref (pixbuf);
 	
+    has_error:
 	if (error) {
 		ev_window_error_message (ev_window, error, 
 					 "%s", _("The image could not be saved."));
@@ -5638,7 +5826,7 @@ ev_attachment_popup_cmd_open_attachment (GtkAction *action, EvWindow *window)
 		
 		attachment = (EvAttachment *) l->data;
 		
-		ev_attachment_open (attachment, screen, GDK_CURRENT_TIME, &error);
+		ev_attachment_open (attachment, screen, gtk_get_current_event_time (), &error);
 
 		if (error) {
 			ev_window_error_message (window, error, 
@@ -5673,7 +5861,7 @@ attachment_save_dialog_response_cb (GtkWidget *fc,
 	
 	for (l = ev_window->priv->attach_list; l && l->data; l = g_list_next (l)) {
 		EvAttachment *attachment;
-		GFile        *save_to;
+		GFile        *save_to = NULL;
 		GError       *error = NULL;
 		
 		attachment = (EvAttachment *) l->data;
@@ -5681,15 +5869,17 @@ attachment_save_dialog_response_cb (GtkWidget *fc,
 		if (is_native) {
 			if (is_dir) {
 				save_to = g_file_get_child (target_file,
+                                    /* FIXMEchpe: file name encoding! */
 							    ev_attachment_get_name (attachment));
 			} else {
 				save_to = g_object_ref (target_file);
 			}
 		} else {
-			save_to = ev_tmp_file_get ("saveattachment");
+			save_to = ev_mkstemp_file ("saveattachment.XXXXXX", &error);
 		}
 
-		ev_attachment_save (attachment, save_to, &error);
+                if (save_to)
+                        ev_attachment_save (attachment, save_to, &error);
 		
 		if (error) {
 			ev_window_error_message (ev_window, error, 
@@ -5795,6 +5985,52 @@ ev_window_media_player_key_pressed (EvWindow    *window,
 	}
 }
 
+static EggToolbarsModel *
+get_toolbars_model (void)
+{
+	EggToolbarsModel *toolbars_model;
+	gchar            *toolbars_file;
+	gchar            *toolbars_path;
+	gint              i;
+
+	toolbars_model = egg_toolbars_model_new ();
+
+	toolbars_file = g_build_filename (ev_application_get_dot_dir (EV_APP, FALSE),
+					  "evince_toolbar.xml", NULL);
+	toolbars_path = g_build_filename (ev_application_get_data_dir (EV_APP),
+					 "evince-toolbar.xml", NULL);
+	egg_toolbars_model_load_names (toolbars_model, toolbars_path);
+
+	if (!egg_toolbars_model_load_toolbars (toolbars_model, toolbars_file)) {
+		egg_toolbars_model_load_toolbars (toolbars_model, toolbars_path);
+                goto skip_conversion;
+	}
+
+	/* Open item doesn't exist anymore,
+	 * convert it to OpenRecent for compatibility
+	 */
+	for (i = 0; i < egg_toolbars_model_n_items (toolbars_model, 0); i++) {
+		const gchar *item;
+
+		item = egg_toolbars_model_item_nth (toolbars_model, 0, i);
+		if (g_ascii_strcasecmp (item, "FileOpen") == 0) {
+			egg_toolbars_model_remove_item (toolbars_model, 0, i);
+			egg_toolbars_model_add_item (toolbars_model, 0, i,
+						     "FileOpenRecent");
+			egg_toolbars_model_save_toolbars (toolbars_model, toolbars_file, "1.0");
+			break;
+		}
+	}
+
+    skip_conversion:
+	g_free (toolbars_file);
+	g_free (toolbars_path);
+
+	egg_toolbars_model_set_flags (toolbars_model, 0, EGG_TB_MODEL_NOT_REMOVABLE);
+
+	return toolbars_model;
+}
+
 static void
 ev_window_init (EvWindow *ev_window)
 {
@@ -5802,6 +6038,7 @@ ev_window_init (EvWindow *ev_window)
 	GtkAccelGroup *accel_group;
 	GError *error = NULL;
 	GtkWidget *sidebar_widget;
+	EggToolbarsModel *toolbars_model;
 	GObject *mpkeys;
 	gchar *ui_path;
 	gdouble dpi;
@@ -5870,7 +6107,17 @@ ev_window_init (EvWindow *ev_window)
 		g_error_free (error);
 	}
 	g_free (ui_path);
-	
+
+#if GTK_CHECK_VERSION (2, 17, 4)
+	{
+		GtkAction *action;
+
+		action = gtk_action_group_get_action (ev_window->priv->action_group,
+						      "FilePageSetup");
+		g_object_set (action, "visible", FALSE, "sensitive", FALSE, NULL);
+	}
+#endif
+
 	ev_window->priv->recent_manager = gtk_recent_manager_get_default ();
 	ev_window->priv->recent_action_group = NULL;
 	ev_window->priv->recent_ui_id = 0;
@@ -5886,12 +6133,14 @@ ev_window_init (EvWindow *ev_window)
 			    ev_window->priv->menubar,
 			    FALSE, FALSE, 0);
 
-	ev_window->priv->toolbar = GTK_WIDGET 
-	  (g_object_new (EGG_TYPE_EDITABLE_TOOLBAR,
-			 "ui-manager", ev_window->priv->ui_manager,
-			 "popup-path", "/ToolbarPopup",
-			 "model", ev_application_get_toolbars_model (EV_APP),
-			 NULL));
+	toolbars_model = get_toolbars_model ();
+	ev_window->priv->toolbar = GTK_WIDGET
+		(g_object_new (EGG_TYPE_EDITABLE_TOOLBAR,
+			       "ui-manager", ev_window->priv->ui_manager,
+			       "popup-path", "/ToolbarPopup",
+			       "model", toolbars_model,
+			       NULL));
+	g_object_unref (toolbars_model);
 
 	egg_editable_toolbar_show (EGG_EDITABLE_TOOLBAR (ev_window->priv->toolbar),
 				   "DefaultToolBar");