Index: shell/ev-dualscreen.txt
===================================================================
--- shell/ev-dualscreen.txt	(revision 0)
+++ shell/ev-dualscreen.txt	(revision 0)
@@ -0,0 +1,70 @@
+This file should give you the general idea to ev-dualscreen.c
+First ideas and patch by Johannes Buchner. 
+Ideas, fixes, etc. welcome at buchner.johannes [at] gmx.at; Subject: evince 
+Or per jabber: buchner.johannes@amessage.at
+
+  Dual-screen presentation feature for evince
+  ___________________________________________
+
+ Monitor 1 (Your screen):                  Monitor 2 (Beamer / Projector)
+  
+   ev_view of the presentation pdf
+   width = 1/3*presentationwidth.
+    |
+    |
+    |        ev_view of the same file or 
+    |        a Notes file. Contains the     ev_view presentation mode of 
+    |        same number of pages           the presentation file
+    |         |                               |
+    v         v                               v
+  +-------++----------------+              +-------------------------+
+  |       ||                |              |                         |
+  | Prev  || Notes.pdf      |              |                         |
+  | Slide ||                |              |                         |
+  +-------+|                |              |                         |
+  |       ||                |              |                         |
+  |Current||                |              |       Current Slide     |
+  | Slide ||                |              |      of presentation    |
+  +-------+|                |              |                         |
+  |       ||                |              |                         |
+  | Next  ||                |              |                         |
+  | Slide ||                |              |                         |
+  +-------++----------------+              +-------------------------+
+
+Features:
+  - clicking anywhere => next slide; right-clicking anywhere => prev slide
+    The page number is the same on all three views. 
+
+Possible way of integration:
+
+  <del>a) Own application "evince-presentation" shipped with evince</del>
+
+  b) Menu item "Dual-Screen presentation"
+     1) opens the control window with the current file as presentation file
+	 1) As notes the current file is loaded.
+	 1) (TODO) automatic window placement (see below)  
+	 2) Double clicking or a menu allows loading a Notes file
+	 3) Navigating through the presentation is done on the beamer = the original 
+	 	evince window (clicking, rightclicking, cursor keys, etc.). 
+	
+
+The general idea for window placement is that the user does it (move, set the 
+first window to presentation mode).
+I didn't look at it, but detecting which part of the screen is on the beamer 
+would be quite rough. Also, there is no setup of dualscreen mode what so ever, 
+the user has to do this before (add second monitor in xorg.conf). 
+
+
+Maybe later features: 
+  - clock (without seconds, these distract IMHO)
+  - timer
+  - automatic window placement:
+      We could do the following after a click on the Dualscreen menu button:
+	  
+	  Push the primary window on the other screen (since it is normal to work 
+	  on the local screen rather than on the projector) and set it to 
+	  presentation mode. (Also see gdk/multihead in the gdk manual.)
+	  The control window will be set on the first screen then, maximised.
+	  
+	  An option could be given to the user to choose to flip the windows. Also 
+	  in this dialog a option to save the setting can be given.
Index: shell/ev-dualscreen.c
===================================================================
--- shell/ev-dualscreen.c	(revision 0)
+++ shell/ev-dualscreen.c	(revision 0)
@@ -0,0 +1,375 @@
+/**
+ * Licence: whatever ...
+ * Author: Johannes Buchner <buchner.johannes@gmx.at>
+ *
+ ****
+ *
+ * TODO: It is quite slow atm. Can we load the whole document in memory?
+         (just during the presentation)
+ * TODO: Check for memory leaks.
+ * BUG:  Left sidebar (overview) doesn't always show up -> resize makes it appear
+ * TODO: Add little button to switch monitors (in case we are "doing it wrong") 
+ * TODO: Add Right-click + click navigation to noteview
+ * TODO: Allow loading of a notes files at the right view. Shall we make a 
+         button (bar), <del>a right click menu<del>, double clicking?
+ * TODO: g_signal_connect (ev_window->priv->page_cache, "page-changed",
+			  G_CALLBACK (page_changed_cb), ev_window);
+         Connect the page change between the views.
+		 It seems to work for 1 document, but it also should when loading a 
+		 notes pdf into notesview.
+ ***/
+
+#include "ev-dualscreen.h"
+
+#define EV_DSCWINDOW_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), \
+	EV_TYPE_DSCWINDOW, EvDSCWindowPrivate))
+
+typedef struct _EvDSCWindowPrivate {
+	GtkWidget *main_box;
+	GtkWidget *menubar;
+	GtkWidget *overview;
+	GtkWidget *notesview;
+	
+	GtkWidget *overview_scrolled_window;
+	GtkWidget *notesview_scrolled_window;
+	
+	EvWindow *presentation_window; 
+	EvDocument *presentation_document;
+	gint moveback_monitor;
+} EvDSCWindowPrivate;
+
+static gpointer parent_class = NULL;
+G_DEFINE_TYPE (EvDSCWindow, ev_dscwindow, GTK_TYPE_WINDOW)
+
+static const GtkTargetEntry dscview_drop_targets[] = {
+	{ "text/uri-list", 0, 0 }
+};
+
+static gdouble ev_dscwindow_get_screen_dpi (EvDSCWindow *ev_window);
+static void update_view_size (EvView *view, GtkWidget * scrolled_window);
+
+/**
+ * Callback for window resize and gripper position change
+ * Rezooms the view so the available space is used.
+ **/
+static gboolean
+ev_dscwindow_handle_resized(GtkContainer *container, GParamSpec *pspec,
+	EvDSCWindow *ev_dscwindow)
+{
+	g_message("ev_dscwindow_handle_resized");
+	EvDSCWindowPrivate *priv = EV_DSCWINDOW_GET_PRIVATE(ev_dscwindow);
+
+	update_view_size(EV_VIEW(priv->overview),  
+		GTK_WIDGET(priv->overview_scrolled_window ));
+	update_view_size(EV_VIEW(priv->notesview), 
+		GTK_WIDGET(priv->notesview_scrolled_window));
+	return TRUE;
+}
+
+/**
+ * If the notesview was doubleclicked, the user wants to load a different file.
+ **/
+static void 
+ev_dscwindow_notes_clicked(GtkContainer *container, gpointer user_data, 
+	gpointer user_data2)
+{
+	char* eventsrc = (char *) user_data;
+	char* eventsrc2 = (char *) user_data2;
+	g_print("ev_dscwindow_notes_clicked; from: %s | %s\n", eventsrc, eventsrc2);
+	//g_message("ev_dscwindow_notes_clicked");
+}
+
+static void 
+ev_dscwindow_window_placement(EvDSCWindow * self)
+{
+	EvDSCWindowPrivate *priv = EV_DSCWINDOW_GET_PRIVATE(self);
+	/* 
+		Idea is this: 
+		leave the new window (dscwindow) on this screen, as we assume "this" 
+			screen is the default working screen, not the beamer/projector.
+		throw the source window to "the other" screen.
+		maximize the source window & bring it to (normal) presentation mode
+		maximize the dscwindow.
+		...
+		money!
+	*/
+	g_message("ev_dscwindow_window_placement");
+	
+	// First let's check out if we even got 2 monitors or if it's all fake...
+	
+	
+	GdkDisplay * display = gdk_display_get_default();
+	const gchar * displayname = gdk_display_get_name(display);
+	gint num_screen = gdk_display_get_n_screens(display);
+	
+	g_print("Our display has the name '%s'\n", displayname);
+	g_print("We have %d GdkScreens on it.\n", num_screen);
+	
+	// We do not possess supercow powers, so we only organize the windows if 
+	// it's obvious what the user wants. 
+	if(num_screen==1){
+		g_message("Ok, we will do it just for you.");
+		GtkWindow * presentation_window = GTK_WINDOW(priv->presentation_window);
+		
+		GdkScreen * screen = gtk_window_get_screen(presentation_window);
+		
+		
+		gint num_monitors = gdk_screen_get_n_monitors(screen);
+		g_print("And also we got: %d Monitors\n", num_monitors);
+		
+		if(num_monitors == 2){
+			// which one is the current window on?
+			GdkRectangle coords;
+			/* This returns null -> uncool */
+			gint work_monitor = gdk_screen_get_monitor_at_window(screen, 
+				GTK_WIDGET(priv->presentation_window)->window);
+			/*
+			gtk_window_get_position(presentation_window, &coords.x, &coords.y);
+			
+			gint work_monitor = gdk_screen_get_monitor_at_point(screen, 
+				coords.x, coords.y);
+			*/
+			gint presentation_monitor = (work_monitor == 1 ? 0 : 1); // the other one
+			g_print("Work_monitor: %d -> conclusio: Presentation Monitor: %d\n", 
+				work_monitor, presentation_monitor);
+			
+			gdk_screen_get_monitor_geometry(screen, presentation_monitor, 
+				&coords);
+			g_print("We want the window to go to (%d, %d)", coords.x, coords.y);
+			
+			gtk_window_move(GTK_WINDOW(presentation_window), 
+				coords.x, coords.y);
+			
+			// TODO: set to presentation mode
+			ev_window_run_presentation(priv->presentation_window);
+			
+			priv->moveback_monitor = work_monitor;
+			// TODO: on destroy, move back. If we don't do that, it's going to 
+			// toggle the display on each start ... (although I would expect the
+			// user to close the application, and be relieved that the 
+			// presentation is over... However, this should not be a requirement
+		}
+	}
+	
+	gtk_window_maximize (GTK_WINDOW (self));
+	
+}
+
+/**
+ * ev_dscwindow_init:
+ * Initializer for my window. Sets all kind of stuff. 
+ * ev_dscwindow_set_presentation has to be called afterwards for loading in a 
+ * document.
+ **/
+static void 
+ev_dscwindow_init(EvDSCWindow * self){
+	EvDSCWindowPrivate *priv = EV_DSCWINDOW_GET_PRIVATE(self);
+	priv->moveback_monitor = -1;
+	
+	gtk_window_set_title (GTK_WINDOW (self), _("Presentation Control"));
+	GtkWidget* h = gtk_hpaned_new ();
+	
+	// Left side:
+	/* Wanted setup: 
+	   2 pages high, continous, not dual. fit page width (or best fit).
+	 */ 
+	priv->overview_scrolled_window = GTK_WIDGET (g_object_new (
+		GTK_TYPE_SCROLLED_WINDOW, "shadow-type", GTK_SHADOW_IN, NULL));
+	gtk_widget_show (priv->overview_scrolled_window);
+	gtk_paned_add1(GTK_PANED(h), priv->overview_scrolled_window);
+	
+	priv->overview  = ev_view_new();
+	g_object_ref(priv->overview);
+	ev_view_set_screen_dpi (EV_VIEW (priv->overview),
+				ev_dscwindow_get_screen_dpi (self));
+	gtk_container_add (GTK_CONTAINER (priv->overview_scrolled_window),
+			   priv->overview);
+	gtk_widget_show (priv->overview);
+	
+	ev_view_set_continuous  (EV_VIEW (priv->overview), TRUE);
+	ev_view_set_dual_page   (EV_VIEW (priv->overview), FALSE); 
+	ev_view_set_sizing_mode (EV_VIEW (priv->overview), EV_SIZING_BEST_FIT);
+	
+	// Right side:
+	/* Wanted setup: 
+	   Just one page. best fit. not dual.
+	 */ 
+	priv->notesview_scrolled_window = GTK_WIDGET (g_object_new (
+		GTK_TYPE_SCROLLED_WINDOW, "shadow-type", GTK_SHADOW_IN, NULL));
+	gtk_widget_show (priv->notesview_scrolled_window);
+	gtk_paned_add2(GTK_PANED(h), priv->notesview_scrolled_window);
+	
+	priv->notesview = ev_view_new();
+	g_object_ref(priv->notesview);
+	ev_view_set_screen_dpi (EV_VIEW (priv->notesview),
+				ev_dscwindow_get_screen_dpi (self));
+	gtk_container_add (GTK_CONTAINER (priv->notesview_scrolled_window),
+			   priv->notesview);
+	gtk_widget_show (priv->notesview);
+	
+	ev_view_set_continuous(EV_VIEW (priv->notesview), FALSE);
+	ev_view_set_dual_page(EV_VIEW (priv->notesview), FALSE); 
+	ev_view_set_sizing_mode (EV_VIEW (priv->notesview), EV_SIZING_BEST_FIT);
+	
+	/* ok, done */
+	// TODO: set width of left thing to: (height/[3 or 2?])*doc_width/doc_height
+	gtk_paned_set_position(GTK_PANED(h), 400);
+	gtk_widget_show (h);
+	gtk_container_add (GTK_CONTAINER (self), h);
+	
+	// TODO: Should we maximize the window? 
+	gtk_window_set_default_size (GTK_WINDOW (self), 600, 600);
+	
+	// get the views loaded right in the first place:
+	//ev_dscwindow_handle_resized(NULL, NULL, self); // doesn't work
+	
+	// and also after a position move
+	g_signal_connect (h, "notify::position", 
+		G_CALLBACK (ev_dscwindow_handle_resized), self);
+	
+	// on window resize, we want to rezoom to fit the available space.
+	g_signal_connect (self, "size-allocate", 
+		G_CALLBACK (ev_dscwindow_handle_resized), self);
+	
+	
+	/* let's start with the fancy stuff: Loading the notes */
+	// we don't want to drag stuff in here, as it opens new windows ...
+	gtk_drag_dest_unset(GTK_WIDGET (priv->notesview));
+	gtk_drag_dest_unset(GTK_WIDGET (priv->overview));
+	
+	/*gtk_drag_dest_set (GTK_WIDGET (view),
+		GTK_DEST_DEFAULT_ALL,
+		dscview_drop_targets,
+		G_N_ELEMENTS (dscview_drop_targets),
+		GDK_ACTION_COPY);
+	*/
+	
+	g_signal_connect(self, "clicked", 
+		G_CALLBACK (ev_dscwindow_notes_clicked), ("clicked"));
+	g_signal_connect(self, "button-press-event", 
+		G_CALLBACK (ev_dscwindow_notes_clicked), ("button-press-event"));
+	g_signal_connect(self, "button-release-event", 
+		G_CALLBACK (ev_dscwindow_notes_clicked), ("button-release-event"));
+	g_signal_connect(self, "key-release-event", 
+		G_CALLBACK (ev_dscwindow_notes_clicked), ("key-release-event"));
+	g_signal_connect(self, "key-press-event", 
+		G_CALLBACK (ev_dscwindow_notes_clicked), ("key-press-event"));
+	
+}
+
+static void 
+ev_dscwindow_dispose(GObject *obj){
+	EvDSCWindow * self = EV_DSCWINDOW(obj);
+	EvDSCWindowPrivate *priv = EV_DSCWINDOW_GET_PRIVATE(self);
+	
+	// unload the documents from the views; freeing
+	ev_view_set_document(EV_VIEW (priv->overview),  NULL);
+	ev_view_set_document(EV_VIEW (priv->notesview), NULL);
+	g_object_unref(priv->overview);
+	g_object_unref(priv->notesview);
+	
+	ev_window_stop_presentation(priv->presentation_window);
+	if(priv->moveback_monitor >= 0){
+		GtkWindow * presentation_window = GTK_WINDOW(priv->presentation_window);
+		GdkRectangle coords;
+		
+		gdk_screen_get_monitor_geometry(
+			gtk_window_get_screen(presentation_window), 
+			priv->moveback_monitor, &coords);
+		
+		g_print("We want the window to go back to (%d, %d)\n", coords.x, coords.y);
+		
+		gtk_window_move(presentation_window, coords.x, coords.y);
+	}
+	
+	// destroy the window
+	G_OBJECT_CLASS (parent_class)->dispose (obj);
+}
+
+static void 
+ev_dscwindow_class_init(EvDSCWindowClass * klass){
+	GObjectClass *g_object_class = G_OBJECT_CLASS (klass);
+	parent_class = g_type_class_peek_parent (klass);
+	g_type_class_add_private (klass, sizeof (EvDSCWindowPrivate));
+	g_object_class->dispose  = ev_dscwindow_dispose;
+}
+
+GtkWidget *
+ev_dscwindow_new (void)
+{
+	return GTK_WIDGET (g_object_new (EV_TYPE_DSCWINDOW, 
+		"type", GTK_WINDOW_TOPLEVEL, NULL));
+}
+
+/**
+ * ev_dscwindow_set_presentation:
+ * @presentation_window: Main window we can 
+ * @document: Presentation document we will load in.
+ **/
+void
+ev_dscwindow_set_presentation (EvDSCWindow * self, 
+	EvWindow *presentation_window, EvDocument *document)
+{
+	if(EV_IS_WINDOW(presentation_window)){
+		EvDSCWindowPrivate *priv = EV_DSCWINDOW_GET_PRIVATE(self);
+		priv->presentation_window = presentation_window;
+		priv->presentation_document = document;
+		
+		ev_view_set_document(EV_VIEW (priv->overview),  
+			priv->presentation_document);
+		ev_view_set_document(EV_VIEW (priv->notesview), 
+			priv->presentation_document);
+		ev_dscwindow_window_placement(self);
+		ev_dscwindow_handle_resized(NULL, NULL, self);
+	}
+}
+
+/* cut'n'pasted: */
+
+static gdouble
+ev_dscwindow_get_screen_dpi (EvDSCWindow *ev_window)
+{
+	GdkScreen *screen;
+	gdouble    xdpi, ydpi;
+
+	screen = gtk_window_get_screen (GTK_WINDOW (ev_window));
+
+	xdpi = 25.4 * gdk_screen_get_width (screen) / gdk_screen_get_width_mm (screen);
+	ydpi = 25.4 * gdk_screen_get_height (screen) / gdk_screen_get_height_mm (screen);
+	
+	return (xdpi + ydpi) / 2.0;
+}
+
+static void
+update_view_size (EvView *view, GtkWidget * scrolled_window)
+{
+	int width, height;
+	GtkRequisition vsb_requisition;
+	GtkRequisition hsb_requisition;
+	int scrollbar_spacing;
+	
+	/* Calculate the width available for the */
+	width = scrolled_window->allocation.width;
+	height = scrolled_window->allocation.height;
+
+	if (gtk_scrolled_window_get_shadow_type (
+			GTK_SCROLLED_WINDOW (scrolled_window)) == GTK_SHADOW_IN
+	) {
+		width -= 2 * GTK_WIDGET(view)->style->xthickness;
+		height -= 2 * GTK_WIDGET(view)->style->ythickness;
+	}
+
+	gtk_widget_size_request (GTK_SCROLLED_WINDOW (scrolled_window)->vscrollbar,
+				 &vsb_requisition);
+	gtk_widget_size_request (GTK_SCROLLED_WINDOW (scrolled_window)->hscrollbar,
+				 &hsb_requisition);
+	gtk_widget_style_get (scrolled_window,
+			      "scrollbar_spacing", &scrollbar_spacing,
+			      NULL);
+
+	ev_view_set_zoom_for_size (EV_VIEW (view),
+				   MAX (1, width),
+				   MAX (1, height),
+				   vsb_requisition.width + scrollbar_spacing,
+				   hsb_requisition.height + scrollbar_spacing);
+}
Index: shell/ev-dualscreen.h
===================================================================
--- shell/ev-dualscreen.h	(revision 0)
+++ shell/ev-dualscreen.h	(revision 0)
@@ -0,0 +1,50 @@
+/**
+ * Licence: whatever ...
+ * Author: Johannes Buchner <buchner.johannes@gmx.at>
+ * See ev-dualscreen.txt
+ */
+
+#ifndef EV_DUALSCREEN_H
+#define EV_DUALSCREEN_H
+
+#include <gtk/gtk.h>
+#include <glib.h>
+#include <glib/gi18n.h>
+#include "ev-window.h"
+#include "ev-view.h"
+
+G_BEGIN_DECLS
+typedef struct _EvDSCWindow {
+	GtkWindow		base_instance;
+} EvDSCWindow;
+typedef struct _EvDSCWindowClass {
+	GtkWindowClass base_class;
+} EvDSCWindowClass;
+
+#define EV_TYPE_DSCWINDOW			(ev_dscwindow_get_type())
+#define EV_DSCWINDOW(object)		(G_TYPE_CHECK_INSTANCE_CAST((object), EV_TYPE_DSCWINDOW, EvDSCWindow))
+#define EV_DSCWINDOW_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST((klass), EV_TYPE_DSCWINDOW, EvDSCWindowClass))
+#define EV_IS_DSCWINDOW(object)		(G_TYPE_CHECK_INSTANCE_TYPE((object), EV_TYPE_DSCWINDOW))
+#define EV_IS_DSCWINDOW_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE((klass), EV_TYPE_DSCWINDOW))
+#define EV_DSCWINDOW_GET_CLASS(object)	(G_TYPE_INSTANCE_GET_CLASS((object), EV_TYPE_DSCWINDOW, EvDSCWindowClass))
+
+GType		ev_dscwindow_get_type	  (void);
+
+/**
+ * Open a new presentation control window.
+ * You have to call ev_dscwindow_set_presentation afterwards to link it to the 
+ * document you want to see in it.
+ **/
+GtkWidget * ev_dscwindow_new (void);
+
+/**
+ * ev_dscwindow_set_presentation:
+ * Load in the presentation we want to see.
+ * @presentation_window: Main window we can 
+ * @document: Presentation document we will load in.
+ **/
+void ev_dscwindow_set_presentation (EvDSCWindow * self, 
+	EvWindow *presentation_window, EvDocument *document);
+G_END_DECLS
+
+#endif /* EV_DUALSCREEN_H */
Index: shell/ev-window.c
===================================================================
--- shell/ev-window.c	(revision 2510)
+++ shell/ev-window.c	(working copy)
@@ -47,6 +47,7 @@
 #include "ev-document-find.h"
 #include "ev-document-security.h"
 #include "ev-document-factory.h"
+#include "ev-dualscreen.h"
 #include "ev-job-queue.h"
 #include "ev-jobs.h"
 #include "ev-sidebar-page.h"
@@ -244,8 +245,8 @@
 static void     ev_window_stop_fullscreen               (EvWindow         *window);
 static void     ev_window_cmd_view_fullscreen           (GtkAction        *action,
 							 EvWindow         *window);
-static void     ev_window_run_presentation              (EvWindow         *window);
-static void     ev_window_stop_presentation             (EvWindow         *window);
+//static void     ev_window_run_presentation              (EvWindow         *window);
+//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);
@@ -270,6 +271,7 @@
 static void	view_handle_link_cb 			(EvView *view, 
 							 EvLink *link, 
 							 EvWindow *window);
+static void ev_window_cmd_dualscreen(GtkWidget *widget, gpointer user_data);
 
 G_DEFINE_TYPE (EvWindow, ev_window, GTK_TYPE_WINDOW)
 
@@ -390,6 +392,7 @@
 	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);
+	ev_window_set_action_sensitive (ev_window, "ViewDualScreenPresentation", has_pages);
 
 	/* Toolbar-specific actions: */
 	ev_window_set_action_sensitive (ev_window, PAGE_SELECTOR_ACTION, has_pages);
@@ -2719,6 +2722,15 @@
 	ev_window_update_actions (ev_window);
 }
 
+static void 
+ev_window_cmd_dualscreen(GtkWidget *widget, gpointer user_data)
+{
+	EvWindow *presentation_window = EV_WINDOW (user_data);
+	EvDSCWindow * new_control = EV_DSCWINDOW(g_object_new(EV_TYPE_DSCWINDOW, NULL));
+	ev_dscwindow_set_presentation (new_control, presentation_window, presentation_window->priv->document);
+	gtk_window_present(GTK_WINDOW(new_control));
+}
+
 static void
 ev_window_cmd_view_page_width (GtkAction *action, EvWindow *ev_window)
 {
@@ -2971,7 +2983,7 @@
 		(action, G_CALLBACK (ev_window_cmd_view_presentation), window);
 }
 
-static void
+void
 ev_window_run_presentation (EvWindow *window)
 {
 	g_object_set (G_OBJECT (window->priv->scrolled_window),
@@ -3002,7 +3014,7 @@
 		ev_metadata_manager_set_boolean (window->priv->uri, "presentation", TRUE);
 }
 
-static void
+void
 ev_window_stop_presentation (EvWindow *window)
 {
 	if (!ev_view_get_presentation (EV_VIEW (window->priv->view)))
@@ -3726,6 +3738,10 @@
 		"Bryan Clark <clarkbw@gnome.org>",
 		"Carlos Garcia Campos <carlosgc@gnome.org>",
 		"Wouter Bolsterlee <wbolster@gnome.org>",
+		"",
+		"Contributers:",
+		// I guess a lot more here ...
+		"Johannes Buchner <buchner.johannes@gmx.at> (Dualscreen Presentation)",
 		NULL
 	};
 
@@ -4338,6 +4354,9 @@
         { "ViewReload", GTK_STOCK_REFRESH, N_("_Reload"), "<control>R",
           N_("Reload the document"),
           G_CALLBACK (ev_window_cmd_view_reload) },
+        { "ViewDualScreenPresentation", NULL, N_("Dualscreen Presentation Mode"), NULL /*Shortcut*/,
+          N_("Run document as a presentation for multihead screens"),
+          G_CALLBACK (ev_window_cmd_dualscreen) },
 
         /* Go menu */
         { "GoPreviousPage", GTK_STOCK_GO_BACK, N_("_Previous Page"), "<control>Page_Up",
Index: shell/ev-view.c
===================================================================
--- shell/ev-view.c	(revision 2510)
+++ shell/ev-view.c	(working copy)
@@ -3385,7 +3385,7 @@
 			   G_N_ELEMENTS (view_drop_targets),
 			   GDK_ACTION_COPY);
 }
-
+	
 /*** Callbacks ***/
 
 static void
Index: shell/ev-window.h
===================================================================
--- shell/ev-window.h	(revision 2510)
+++ shell/ev-window.h	(working copy)
@@ -80,6 +80,9 @@
 					   gboolean        unlink_temp_file,
 					   const gchar    *print_settings);
 gboolean	ev_window_is_empty	  (const EvWindow *ev_window);
+void ev_window_run_presentation (EvWindow *window);
+void ev_window_stop_presentation (EvWindow *window);
+
 #ifdef WITH_PRINT
 void		ev_window_print_range     (EvWindow       *ev_window,
 					   int             first_page,
@@ -88,4 +91,3 @@
 G_END_DECLS
 
 #endif /* !EV_WINDOW_H */
-
Index: shell/Makefile.am
===================================================================
--- shell/Makefile.am	(revision 2510)
+++ shell/Makefile.am	(working copy)
@@ -27,6 +27,8 @@
 	eggfindbar.h			\
 	ev-application.c		\
 	ev-application.h		\
+	ev-dualscreen.c			\
+	ev-dualscreen.h			\
 	ev-job-queue.h			\
 	ev-job-queue.c			\
 	ev-jobs.h			\
Index: data/evince-ui.xml
===================================================================
--- data/evince-ui.xml	(revision 2510)
+++ data/evince-ui.xml	(working copy)
@@ -36,6 +36,7 @@
       <separator/>
       <menuitem name="ViewFullscreenMenu" action="ViewFullscreen"/>
       <menuitem name="ViewPresentationMenu" action="ViewPresentation"/>
+      <menuitem name="ViewDualScreenPresentation" action="ViewDualScreenPresentation"/>
       <separator/>
       <menuitem name="ViewContinuousMenu" action="ViewContinuous"/>
       <menuitem name="ViewDualMenu" action="ViewDual"/>
