--- evince-2.30.3.orig/shell/ev-window.c	2010-07-28 13:24:16.000000000 +0200
+++ evince-2.30.3/shell/ev-window.c	2010-07-28 11:28:27.000000000 +0200
@@ -357,10 +357,12 @@ ev_window_setup_action_sensitivity (EvWi
 	gboolean can_get_text = FALSE;
 	gboolean has_pages = FALSE;
 	gboolean can_find = FALSE;
+	guint n_pages = 0;
 
 	if (document) {
 		has_document = TRUE;
-		has_pages = ev_document_get_n_pages (document) > 0;
+		n_pages = ev_document_get_n_pages (document);
+		has_pages = n_pages > 0;
 		info = ev_document_get_info (document);
 	}
 
@@ -426,6 +428,7 @@ ev_window_setup_action_sensitivity (EvWi
         /* View menu */
 	ev_window_set_action_sensitive (ev_window, "ViewContinuous", has_pages);
 	ev_window_set_action_sensitive (ev_window, "ViewDual", has_pages);
+	ev_window_set_action_sensitive (ev_window, "ViewEvenLeft", n_pages > 2);
 	ev_window_set_action_sensitive (ev_window, "ViewBestFit", has_pages);
 	ev_window_set_action_sensitive (ev_window, "ViewPageWidth", has_pages);
 	ev_window_set_action_sensitive (ev_window, "ViewReload", has_pages);
@@ -972,6 +975,7 @@ setup_model_from_metadata (EvWindow *win
 	gboolean inverted_colors = FALSE;
 	gboolean continuous = FALSE;
 	gboolean dual_page = FALSE;
+	gboolean dual_page_even_left = FALSE;
 	gboolean fullscreen = FALSE;
 
 	if (!window->priv->metadata)
@@ -1032,6 +1036,11 @@ setup_model_from_metadata (EvWindow *win
 		ev_document_model_set_dual_page (window->priv->model, dual_page);
 	}
 
+	/* Dual page even left */
+	if (ev_metadata_get_boolean (window->priv->metadata, "dual-page-even-left", &dual_page_even_left)) {
+		ev_document_model_set_dual_page_even_left (window->priv->model, dual_page_even_left);
+	}
+
 	/* Fullscreen */
 	if (ev_metadata_get_boolean (window->priv->metadata, "fullscreen", &fullscreen)) {
 		if (fullscreen) {
@@ -3383,6 +3392,16 @@ ev_window_cmd_dual (GtkAction *action, E
 }
 
 static void
+ev_window_cmd_dual_even_left (GtkAction *action, EvWindow *ev_window)
+{
+	gboolean dual_page_even_left;
+
+	ev_window_stop_presentation (ev_window, TRUE);
+	dual_page_even_left = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+	ev_document_model_set_dual_page_even_left (ev_window->priv->model, dual_page_even_left);
+}
+
+static void
 ev_window_cmd_view_best_fit (GtkAction *action, EvWindow *ev_window)
 {
 	ev_window_stop_presentation (ev_window, TRUE);
@@ -4153,6 +4172,20 @@ ev_window_update_dual_page_action (EvWin
 }
 
 static void
+ev_window_update_dual_page_even_left_action (EvWindow *window)
+{
+	GtkAction *action;
+
+	action = gtk_action_group_get_action (window->priv->action_group, "ViewEvenLeft");
+	g_signal_handlers_block_by_func
+		(action, G_CALLBACK (ev_window_cmd_dual_even_left), window);
+	gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
+				      ev_document_model_get_dual_page_even_left (window->priv->model));
+	g_signal_handlers_unblock_by_func
+		(action, G_CALLBACK (ev_window_cmd_dual_even_left), window);
+}
+
+static void
 ev_window_continuous_changed_cb (EvDocumentModel *model,
 				 GParamSpec      *pspec,
 				 EvWindow        *ev_window)
@@ -4220,6 +4253,18 @@ ev_window_dual_mode_changed_cb (EvDocume
 					 ev_document_model_get_dual_page (model));
 }
 
+static void
+ev_window_dual_even_left_mode_changed_cb (EvDocumentModel *model,
+				          GParamSpec      *pspec,
+				          EvWindow        *ev_window)
+{
+	ev_window_update_dual_page_even_left_action (ev_window);
+
+	if (ev_window->priv->metadata && !ev_window_is_empty (ev_window))
+		ev_metadata_set_boolean (ev_window->priv->metadata, "dual-page-even-left",
+					 ev_document_model_get_dual_page_even_left (model));
+}
+
 static char *
 build_comments_string (EvDocument *document)
 {
@@ -5221,6 +5266,9 @@ static const GtkToggleActionEntry toggle
         { "ViewDual", EV_STOCK_VIEW_DUAL, N_("_Dual"), NULL,
 	  N_("Show two pages at once"),
 	  G_CALLBACK (ev_window_cmd_dual), FALSE },
+        { "ViewEvenLeft", NULL, N_("_Even Left"), NULL,
+	  N_("Show even pages on the left"),
+	  G_CALLBACK (ev_window_cmd_dual_even_left), TRUE },
         { "ViewFullscreen", GTK_STOCK_FULLSCREEN, N_("_Fullscreen"), "F11",
           N_("Expand the window to fill the screen"),
           G_CALLBACK (ev_window_cmd_view_fullscreen) },
@@ -6437,6 +6485,10 @@ ev_window_init (EvWindow *ev_window)
 			  G_CALLBACK (ev_window_dual_mode_changed_cb),
 			  ev_window);
 	g_signal_connect (ev_window->priv->model,
+			  "notify::dual-page-even-left",
+			  G_CALLBACK (ev_window_dual_even_left_mode_changed_cb),
+			  ev_window);
+	g_signal_connect (ev_window->priv->model,
 			  "notify::inverted-colors",
 			  G_CALLBACK (ev_window_inverted_colors_changed_cb),
 			  ev_window);
--- evince-2.30.3.orig/data/evince-toolbar.xml	2010-07-28 13:22:47.000000000 +0200
+++ evince-2.30.3/data/evince-toolbar.xml	2010-07-28 11:17:15.000000000 +0200
@@ -6,6 +6,7 @@
     <toolitem name="FileSaveAs"/>
     <toolitem name="ViewContinuous"/>
     <toolitem name="ViewDual"/>
+    <toolitem name="ViewEvenLeft"/>
     <toolitem name="ViewInvertedColors"/>
     <toolitem name="ViewReload"/>
     <toolitem name="ViewAutoscroll"/>
--- evince-2.30.3.orig/data/evince-ui.xml	2010-07-28 13:23:01.000000000 +0200
+++ evince-2.30.3/data/evince-ui.xml	2010-07-28 11:17:39.000000000 +0200
@@ -39,6 +39,7 @@
       <separator/>
       <menuitem name="ViewContinuousMenu" action="ViewContinuous"/>
       <menuitem name="ViewDualMenu" action="ViewDual"/>
+      <menuitem name="ViewEvenLeftMenu" action="ViewEvenLeft"/>
       <separator/>
       <menuitem name="ViewInvertedColors" action="ViewInvertedColors"/>
       <separator/>
--- evince-2.30.3.orig/libview/ev-view-private.h	2010-07-28 13:25:16.000000000 +0200
+++ evince-2.30.3/libview/ev-view-private.h	2010-07-28 11:37:06.000000000 +0200
@@ -104,7 +104,8 @@ typedef enum {
 typedef struct _EvHeightToPageCache {
 	gint rotation;
 	gdouble *height_to_page;
-	gdouble *dual_height_to_page;
+	gdouble *dual_height_to_page_even_left;
+	gdouble *dual_height_to_page_odd_left;
 } EvHeightToPageCache;
 
 struct _EvView {
@@ -153,6 +154,7 @@ struct _EvView {
 	gboolean continuous;
 	gboolean dual_page;
 	gboolean fullscreen;
+	gint dual_page_even_left;
 	EvSizingMode sizing_mode;
 	cairo_surface_t *loading_text;
 
--- evince-2.30.3.orig/libview/ev-document-model.h	2010-07-28 13:25:03.000000000 +0200
+++ evince-2.30.3/libview/ev-document-model.h	2010-07-28 10:49:09.000000000 +0200
@@ -78,6 +78,9 @@ gboolean         ev_document_model_get_c
 void             ev_document_model_set_dual_page     (EvDocumentModel *model,
 						      gboolean         dual_page);
 gboolean         ev_document_model_get_dual_page     (EvDocumentModel *model);
+void             ev_document_model_set_dual_page_even_left (EvDocumentModel *model,
+						            gboolean         dual_page);
+gboolean         ev_document_model_get_dual_page_even_left (EvDocumentModel *model);
 void             ev_document_model_set_fullscreen    (EvDocumentModel *model,
 						      gboolean         fullscreen);
 gboolean         ev_document_model_get_fullscreen    (EvDocumentModel *model);
--- evince-2.30.3.orig/libview/ev-document-model.c	2010-07-28 13:24:03.000000000 +0200
+++ evince-2.30.3/libview/ev-document-model.c	2010-07-28 10:57:24.000000000 +0200
@@ -37,6 +37,7 @@ struct _EvDocumentModel
 	EvSizingMode sizing_mode;
 	guint continuous : 1;
 	guint dual_page  : 1;
+	guint dual_page_even_left  : 1;
 	guint fullscreen : 1;
 	guint inverted_colors : 1;
 
@@ -64,6 +65,7 @@ enum {
 	PROP_SIZING_MODE,
 	PROP_CONTINUOUS,
 	PROP_DUAL_PAGE,
+	PROP_DUAL_PAGE_EVEN_LEFT,
 	PROP_FULLSCREEN
 };
 
@@ -123,6 +125,9 @@ ev_document_model_set_property (GObject 
 	case PROP_DUAL_PAGE:
 		ev_document_model_set_dual_page (model, g_value_get_boolean (value));
 		break;
+	case PROP_DUAL_PAGE_EVEN_LEFT:
+		ev_document_model_set_dual_page_even_left (model, g_value_get_boolean (value));
+		break;
 	case PROP_FULLSCREEN:
 		ev_document_model_set_fullscreen (model, g_value_get_boolean (value));
 		break;
@@ -164,6 +169,9 @@ ev_document_model_get_property (GObject 
 	case PROP_DUAL_PAGE:
 		g_value_set_boolean (value, ev_document_model_get_dual_page (model));
 		break;
+	case PROP_DUAL_PAGE_EVEN_LEFT:
+		g_value_set_boolean (value, ev_document_model_get_dual_page_even_left (model));
+		break;
 	case PROP_FULLSCREEN:
 		g_value_set_boolean (value, ev_document_model_get_fullscreen (model));
 		break;
@@ -240,6 +248,13 @@ ev_document_model_class_init (EvDocument
 							       FALSE,
 							       G_PARAM_READWRITE));
 	g_object_class_install_property (g_object_class,
+					 PROP_DUAL_PAGE_EVEN_LEFT,
+					 g_param_spec_boolean ("dual-page-even-left",
+							       "Dual Page Even Left",
+							       "Whether document is displayed with even pages on the left in dual page mode",
+							       TRUE,
+							       G_PARAM_READWRITE));
+	g_object_class_install_property (g_object_class,
 					 PROP_FULLSCREEN,
 					 g_param_spec_boolean ("fullscreen",
 							       "Fullscreen",
@@ -266,6 +281,7 @@ ev_document_model_init (EvDocumentModel 
 	model->scale = 1.;
 	model->sizing_mode = EV_SIZING_FIT_WIDTH;
 	model->continuous = TRUE;
+	model->dual_page_even_left = TRUE;
 	model->inverted_colors = FALSE;
 	model->min_scale = 0.;
 	model->max_scale = G_MAXDOUBLE;
@@ -300,6 +316,9 @@ ev_document_model_set_document (EvDocume
 	model->document = g_object_ref (document);
 
 	model->n_pages = ev_document_get_n_pages (document);
+        /* FIXME: Is here a good place to do this? */
+	if (model->n_pages < 3 && model->dual_page_even_left)
+		ev_document_model_set_dual_page_even_left (model, FALSE);
 	ev_document_model_set_page (model, CLAMP (model->page, 0,
 						  model->n_pages - 1));
 
@@ -547,6 +566,30 @@ ev_document_model_get_dual_page (EvDocum
 }
 
 void
+ev_document_model_set_dual_page_even_left (EvDocumentModel *model,
+				           gboolean         dual_page_even_left)
+{
+	g_return_if_fail (EV_IS_DOCUMENT_MODEL (model));
+
+	dual_page_even_left = dual_page_even_left != FALSE;
+
+	if (dual_page_even_left == model->dual_page_even_left)
+		return;
+
+	model->dual_page_even_left = dual_page_even_left;
+
+	g_object_notify (G_OBJECT (model), "dual-page-even-left");
+}
+
+gboolean
+ev_document_model_get_dual_page_even_left (EvDocumentModel *model)
+{
+	g_return_val_if_fail (EV_IS_DOCUMENT_MODEL (model), FALSE);
+
+	return model->dual_page_even_left;
+}
+
+void
 ev_document_model_set_fullscreen (EvDocumentModel *model,
 				  gboolean         fullscreen)
 {
--- evince-2.30.3.orig/libview/ev-view.c	2010-07-28 13:24:08.000000000 +0200
+++ evince-2.30.3/libview/ev-view.c	2010-07-28 13:20:57.000000000 +0200
@@ -110,7 +110,6 @@ static void       doc_rect_to_view_rect 
 							      int                 page,
 							      EvRectangle        *doc_rect,
 							      GdkRectangle       *view_rect);
-static gboolean   get_dual_even_left                         (EvView             *view);
 static void       find_page_at_location                      (EvView             *view,
 							      gdouble             x,
 							      gdouble             y,
@@ -289,91 +288,104 @@ build_height_to_page (EvHeightToPageCach
 		      EvDocument          *document,
 		      gint                 rotation)
 {
-	gboolean swap, uniform, dual_even_left;
+	gboolean swap, uniform;
 	int i;
 	double uniform_height, page_height, next_page_height;
 	double saved_height;
 	gdouble u_width, u_height;
+	double *page_heights = NULL;
 	gint n_pages;
 
 	swap = (rotation == 90 || rotation == 270);
 
 	uniform = ev_document_is_page_size_uniform (document);
 	n_pages = ev_document_get_n_pages (document);
-	dual_even_left = (n_pages > 2);
 
 	g_free (cache->height_to_page);
-	g_free (cache->dual_height_to_page);
+	g_free (cache->dual_height_to_page_even_left);
+	g_free (cache->dual_height_to_page_odd_left);
 
 	cache->rotation = rotation;
 	cache->height_to_page = g_new0 (gdouble, n_pages + 1);
-	cache->dual_height_to_page = g_new0 (gdouble, n_pages + 2);
+	cache->dual_height_to_page_even_left = g_new0 (gdouble, n_pages + 2);
+	cache->dual_height_to_page_odd_left = g_new0 (gdouble, n_pages + 2);
 
+	/* Find all the page heights as we are going to use them several times */
 	if (uniform)
 		ev_document_get_page_size (document, 0, &u_width, &u_height);
+	else {
+		page_heights = g_new (gdouble, n_pages);
+		for (i = 0; i < n_pages; i++) {
+			gdouble w, h;
 
-	saved_height = 0;
+			ev_document_get_page_size (document, i, &w, &h);
+			page_heights[i] = swap ? w : h;
+		}
+	}
+
+	/* Single-page view */
+	saved_height = 0.0;
 	for (i = 0; i <= n_pages; i++) {
 		if (uniform) {
 			uniform_height = swap ? u_width : u_height;
 			cache->height_to_page[i] = i * uniform_height;
 		} else {
-			if (i < n_pages) {
-				gdouble w, h;
-
-				ev_document_get_page_size (document, i, &w, &h);
-				page_height = swap ? w : h;
-			} else {
-				page_height = 0;
-			}
 			cache->height_to_page[i] = saved_height;
-			saved_height += page_height;
+			saved_height += (i < n_pages) ? page_heights[i] : 0.0;
 		}
 	}
 
-	if (dual_even_left && !uniform) {
+	/* Dual view, even pages left (book) */
+	if (!uniform) {
 		gdouble w, h;
 
 		ev_document_get_page_size (document, 0, &w, &h);
 		saved_height = swap ? w : h;
-	} else {
-		saved_height = 0;
 	}
 
-	for (i = dual_even_left; i < n_pages + 2; i += 2) {
-    		if (uniform) {
+	for (i = 1; i < n_pages + 2; i += 2) {
+		if (uniform) {
 			uniform_height = swap ? u_width : u_height;
-			cache->dual_height_to_page[i] = ((i + dual_even_left) / 2) * uniform_height;
+			cache->dual_height_to_page_even_left[i] = ((i + 1) / 2) * uniform_height;
 			if (i + 1 < n_pages + 2)
-				cache->dual_height_to_page[i + 1] = ((i + dual_even_left) / 2) * uniform_height;
+				cache->dual_height_to_page_even_left[i + 1] = ((i + 1) / 2) * uniform_height;
 		} else {
-			if (i + 1 < n_pages) {
-				gdouble w, h;
+			next_page_height = (i + 1 < n_pages) ? page_heights[i] : 0.0;
+			page_height = (i < n_pages) ? page_heights[i] : 0.0;
 
-				ev_document_get_page_size (document, i + 1, &w, &h);
-				next_page_height = swap ? w : h;
+			if (i + 1 < n_pages + 2) {
+				cache->dual_height_to_page_even_left[i] = saved_height;
+				cache->dual_height_to_page_even_left[i + 1] = saved_height;
+				saved_height += MAX(page_height, next_page_height);
 			} else {
-				next_page_height = 0;
+				cache->dual_height_to_page_even_left[i] = saved_height;
 			}
+		}
+	}
 
-			if (i < n_pages) {
-				gdouble w, h;
-
-				ev_document_get_page_size (document, i, &w, &h);
-				page_height = swap ? w : h;
-			} else {
-				page_height = 0;
-			}
+	/* Dual view, odd pages left (plain) */
+	saved_height = 0.0;
+	for (i = 0; i < n_pages + 2; i += 2) {
+		if (uniform) {
+			uniform_height = swap ? u_width : u_height;
+			cache->dual_height_to_page_odd_left[i] = (i / 2) * uniform_height;
+			if (i + 1 < n_pages + 2)
+				cache->dual_height_to_page_odd_left[i + 1] = (i / 2) * uniform_height;
+		} else {
+			next_page_height = (i + 1 < n_pages) ? page_heights[i] : 0.0;
+			page_height = (i < n_pages) ? page_heights[i] : 0.0;
 
 			if (i + 1 < n_pages + 2) {
-				cache->dual_height_to_page[i] = saved_height;
-				cache->dual_height_to_page[i + 1] = saved_height;
+				cache->dual_height_to_page_odd_left[i] = saved_height;
+				cache->dual_height_to_page_odd_left[i + 1] = saved_height;
 				saved_height += MAX(page_height, next_page_height);
 			} else {
-				cache->dual_height_to_page[i] = saved_height;
+				cache->dual_height_to_page_odd_left[i] = saved_height;
 			}
 		}
 	}
+
+	g_free(page_heights);
 }
 
 static void
@@ -382,13 +394,15 @@ ev_height_to_page_cache_get_height (EvHe
 				    gint                 page,
 				    gint                 rotation,
 				    gdouble             *height,
-				    gdouble             *dual_height)
+				    gdouble             *dual_height_even_left,
+				    gdouble             *dual_height_odd_left)
 {
 	if (cache->rotation != rotation)
 		build_height_to_page (cache, document, rotation);
 
 	*height = cache->height_to_page[page];
-	*dual_height = cache->dual_height_to_page[page];
+	*dual_height_even_left = cache->dual_height_to_page_even_left[page];
+	*dual_height_odd_left = cache->dual_height_to_page_odd_left[page];
 }
 
 static void
@@ -399,9 +413,14 @@ ev_height_to_page_cache_free (EvHeightTo
 		cache->height_to_page = NULL;
 	}
 
-	if (cache->dual_height_to_page) {
-		g_free (cache->dual_height_to_page);
-		cache->dual_height_to_page = NULL;
+	if (cache->dual_height_to_page_even_left) {
+		g_free (cache->dual_height_to_page_even_left);
+		cache->dual_height_to_page_even_left = NULL;
+	}
+
+	if (cache->dual_height_to_page_odd_left) {
+		g_free (cache->dual_height_to_page_odd_left);
+		cache->dual_height_to_page_odd_left = NULL;
 	}
 	g_free (cache);
 }
@@ -431,9 +450,10 @@ static void
 ev_view_get_height_to_page (EvView *view,
 			    gint    page,
 			    gint   *height,
-			    gint   *dual_height)
+			    gint   *dual_height_even_left,
+			    gint   *dual_height_odd_left)
 {
-	gdouble h, dh;
+	gdouble h, edh, odh;
 
 	if (!view->height_to_page_cache)
 		return;
@@ -442,12 +462,16 @@ ev_view_get_height_to_page (EvView *view
 					    view->document,
 					    page,
 					    view->rotation,
-					    &h, &dh);
+					    &h, &edh, &odh);
+
 	if (height)
 		*height = (gint)(h * view->scale + 0.5);
 
-	if (dual_height)
-		*dual_height = (gint)(dh * view->scale + 0.5);
+	if (dual_height_even_left)
+		*dual_height_even_left = (gint)(edh * view->scale + 0.5);
+
+	if (dual_height_odd_left)
+		*dual_height_odd_left = (gint)(odh * view->scale + 0.5);
 }
 
 static gint
@@ -674,7 +698,7 @@ view_update_range_and_current_page (EvVi
 			}
 		}
 	} else if (view->dual_page) {
-		if (view->current_page % 2 == get_dual_even_left (view)) {
+		if (view->current_page % 2 == view->dual_page_even_left) {
 			view->start_page = view->current_page;
 			if (view->current_page + 1 < ev_document_get_n_pages (view->document))
 				view->end_page = view->start_page + 1;
@@ -1059,11 +1083,14 @@ get_page_y_offset (EvView *view, int pag
 	compute_border (view, max_width, max_width, &border);
 
 	if (view->dual_page) {
-		ev_view_get_height_to_page (view, page, NULL, &offset);
-		offset += ((page + get_dual_even_left (view)) / 2 + 1) * view->spacing +
-			((page + get_dual_even_left (view)) / 2 ) * (border.top + border.bottom);
+		if (view->dual_page_even_left)
+			ev_view_get_height_to_page (view, page, NULL, &offset, NULL);
+		else
+			ev_view_get_height_to_page (view, page, NULL, NULL, &offset);
+		offset += ((page + view->dual_page_even_left) / 2 + 1) * view->spacing +
+			((page + view->dual_page_even_left) / 2 ) * (border.top + border.bottom);
 	} else {
-		ev_view_get_height_to_page (view, page, &offset, NULL);
+		ev_view_get_height_to_page (view, page, &offset, NULL, NULL);
 		offset += (page + 1) * view->spacing + page * (border.top + border.bottom);
 	}
 
@@ -1096,9 +1123,9 @@ get_page_extents (EvView       *view,
 		max_width = max_width + border->left + border->right;
 		/* Get the location of the bounding box */
 		if (view->dual_page) {
-			x = view->spacing + ((page % 2 == get_dual_even_left (view)) ? 0 : 1) * (max_width + view->spacing);
+			x = view->spacing + ((page % 2 == view->dual_page_even_left) ? 0 : 1) * (max_width + view->spacing);
 			x = x + MAX (0, widget->allocation.width - (max_width * 2 + view->spacing * 3)) / 2;
-			if (page % 2 == get_dual_even_left (view))
+			if (page % 2 == view->dual_page_even_left)
 				x = x + (max_width - width - border->left - border->right);
 		} else {
 			x = view->spacing;
@@ -1118,7 +1145,7 @@ get_page_extents (EvView       *view,
 			GtkBorder overall_border;
 			gint other_page;
 
-			other_page = (page % 2 == get_dual_even_left (view)) ? page + 1: page - 1;
+			other_page = (page % 2 == view->dual_page_even_left) ? page + 1: page - 1;
 
 			/* First, we get the bounding box of the two pages */
 			if (other_page < ev_document_get_n_pages (view->document)
@@ -1137,7 +1164,7 @@ get_page_extents (EvView       *view,
 			y = view->spacing;
 
 			/* Adjust for being the left or right page */
-			if (page % 2 == get_dual_even_left (view))
+			if (page % 2 == view->dual_page_even_left)
 				x = x + max_width - width;
 			else
 				x = x + (max_width + overall_border.left + overall_border.right) + view->spacing;
@@ -1287,12 +1314,6 @@ doc_rect_to_view_rect (EvView       *vie
 	view_rect->height = h * view->scale;
 }
 
-static gboolean
-get_dual_even_left (EvView *view)
-{
-	return (ev_document_get_n_pages (view->document) > 2);
-}
-
 static void
 find_page_at_location (EvView  *view,
 		       gdouble  x,
@@ -4341,6 +4362,7 @@ ev_view_init (EvView *view)
 	view->selection_mode = EV_VIEW_SELECTION_TEXT;
 	view->continuous = TRUE;
 	view->dual_page = FALSE;
+	view->dual_page_even_left = TRUE;
 	view->fullscreen = FALSE;
 	view->sizing_mode = EV_SIZING_FIT_WIDTH;
 	view->pending_scroll = SCROLL_TO_KEEP_POSITION;
@@ -4710,6 +4732,21 @@ ev_view_dual_page_changed_cb (EvDocument
 }
 
 static void
+ev_view_dual_page_even_left_changed_cb (EvDocumentModel *model,
+			                GParamSpec      *pspec,
+			                EvView          *view)
+{
+	gboolean dual_page_even_left = ev_document_model_get_dual_page_even_left (model);
+
+	view->dual_page_even_left = dual_page_even_left;
+	view->pending_scroll = SCROLL_TO_PAGE_POSITION;
+	/* FIXME: if we're keeping the pixbuf cache around, we should extend the
+	 * preload_cache_size to be 2 if dual_page is set.
+	 */
+	gtk_widget_queue_resize (GTK_WIDGET (view));
+}
+
+static void
 ev_view_fullscreen_changed_cb (EvDocumentModel *model,
 			       GParamSpec      *pspec,
 			       EvView          *view)
@@ -4747,6 +4784,7 @@ ev_view_set_model (EvView          *view
 	view->scale = ev_document_model_get_scale (view->model);
 	view->continuous = ev_document_model_get_continuous (view->model);
 	view->dual_page = ev_document_model_get_dual_page (view->model);
+	view->dual_page_even_left = ev_document_model_get_dual_page_even_left (view->model);
 	view->fullscreen = ev_document_model_get_fullscreen (view->model);
 	ev_view_document_changed_cb (view->model, NULL, view);
 
@@ -4771,6 +4809,9 @@ ev_view_set_model (EvView          *view
 	g_signal_connect (view->model, "notify::dual-page",
 			  G_CALLBACK (ev_view_dual_page_changed_cb),
 			  view);
+	g_signal_connect (view->model, "notify::dual-page-even-left",
+			  G_CALLBACK (ev_view_dual_page_even_left_changed_cb),
+			  view);
 	g_signal_connect (view->model, "notify::fullscreen",
 			  G_CALLBACK (ev_view_fullscreen_changed_cb),
 			  view);
