inicial

1 files changed, 1498 insertions, 0 deletions

diff --git a/libview/ev-view-presentation.c b/libview/ev-view-presentation.c
new file mode 100644
index 00000000..31556fa2
--- /dev/null
+++ b/libview/ev-view-presentation.c
@@ -0,0 +1,1498 @@
+/* ev-view-presentation.c
+ *  this file is part of evince, a mate document viewer
+ *
+ * Copyright (C) 2010 Carlos Garcia Campos <[email protected]>
+ *
+ * Evince is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Evince is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <glib/gi18n-lib.h>
+#include <gdk/gdkkeysyms.h>
+
+#include "ev-view-presentation.h"
+#include "ev-jobs.h"
+#include "ev-job-scheduler.h"
+#include "ev-transition-animation.h"
+#include "ev-view-cursor.h"
+#include "ev-page-cache.h"
+
+enum {
+	PROP_0,
+	PROP_DOCUMENT,
+	PROP_CURRENT_PAGE,
+	PROP_ROTATION,
+	PROP_INVERTED_COLORS
+};
+
+enum {
+	CHANGE_PAGE,
+	FINISHED,
+	N_SIGNALS
+};
+
+typedef enum {
+	EV_PRESENTATION_NORMAL,
+	EV_PRESENTATION_BLACK,
+	EV_PRESENTATION_WHITE,
+	EV_PRESENTATION_END
+} EvPresentationState;
+
+struct _EvViewPresentation
+{
+	GtkWidget base;
+
+	guint                  current_page;
+	cairo_surface_t       *current_surface;
+	EvDocument            *document;
+	guint                  rotation;
+	gboolean               inverted_colors;
+	EvPresentationState    state;
+	gdouble                scale;
+	gint                   monitor_width;
+	gint                   monitor_height;
+
+	/* Cursors */
+	EvViewCursor           cursor;
+	guint                  hide_cursor_timeout_id;
+
+	/* Goto Window */
+	GtkWidget             *goto_window;
+	GtkWidget             *goto_entry;
+
+	/* Page Transition */
+	guint                  trans_timeout_id;
+
+	/* Animations */
+	gboolean               enable_animations;
+	EvTransitionAnimation *animation;
+
+	/* Links */
+	EvPageCache           *page_cache;
+
+	EvJob *prev_job;
+	EvJob *curr_job;
+	EvJob *next_job;
+};
+
+struct _EvViewPresentationClass
+{
+	GtkWidgetClass base_class;
+
+	/* signals */
+	void (* change_page) (EvViewPresentation *pview,
+			      GtkScrollType       scroll);
+	void (* finished)    (EvViewPresentation *pview);
+};
+
+static guint signals[N_SIGNALS] = { 0 };
+
+static void ev_view_presentation_next_page               (EvViewPresentation *pview);
+static void ev_view_presentation_previous_page           (EvViewPresentation *pview);
+static void ev_view_presentation_set_cursor_for_location (EvViewPresentation *pview,
+							  gdouble             x,
+							  gdouble             y);
+
+#define HIDE_CURSOR_TIMEOUT 5
+
+G_DEFINE_TYPE (EvViewPresentation, ev_view_presentation, GTK_TYPE_WIDGET)
+
+static void
+ev_view_presentation_set_normal (EvViewPresentation *pview)
+{
+	GtkWidget *widget = GTK_WIDGET (pview);
+	GtkStyle  *style;
+
+	if (pview->state == EV_PRESENTATION_NORMAL)
+		return;
+
+	pview->state = EV_PRESENTATION_NORMAL;
+	style = gtk_widget_get_style (widget);
+	gdk_window_set_background (gtk_widget_get_window (widget), &style->black);
+	gtk_widget_queue_draw (widget);
+}
+
+static void
+ev_view_presentation_set_black (EvViewPresentation *pview)
+{
+	GtkWidget *widget = GTK_WIDGET (pview);
+	GtkStyle  *style;
+
+	if (pview->state == EV_PRESENTATION_BLACK)
+		return;
+
+	pview->state = EV_PRESENTATION_BLACK;
+	style = gtk_widget_get_style (widget);
+	gdk_window_set_background (gtk_widget_get_window (widget), &style->black);
+	gtk_widget_queue_draw (widget);
+}
+
+static void
+ev_view_presentation_set_white (EvViewPresentation *pview)
+{
+	GtkWidget *widget = GTK_WIDGET (pview);
+	GtkStyle  *style;
+
+	if (pview->state == EV_PRESENTATION_WHITE)
+		return;
+
+	pview->state = EV_PRESENTATION_WHITE;
+	style = gtk_widget_get_style (widget);
+	gdk_window_set_background (gtk_widget_get_window (widget), &style->white);
+	gtk_widget_queue_draw (widget);
+}
+
+static void
+ev_view_presentation_set_end (EvViewPresentation *pview)
+{
+	GtkWidget *widget = GTK_WIDGET (pview);
+
+	if (pview->state == EV_PRESENTATION_END)
+		return;
+
+	pview->state = EV_PRESENTATION_END;
+	gtk_widget_queue_draw (widget);
+}
+
+static gdouble
+ev_view_presentation_get_scale_for_page (EvViewPresentation *pview,
+					 guint               page)
+{
+	if (!ev_document_is_page_size_uniform (pview->document) || pview->scale == 0) {
+		gdouble width, height;
+
+		ev_document_get_page_size (pview->document, page, &width, &height);
+		if (pview->rotation == 90 || pview->rotation == 270) {
+			gdouble tmp;
+
+			tmp = width;
+			width = height;
+			height = tmp;
+		}
+		pview->scale = MIN (pview->monitor_width / width, pview->monitor_height / height);
+	}
+
+	return pview->scale;
+}
+
+static void
+ev_view_presentation_get_page_area (EvViewPresentation *pview,
+				    GdkRectangle       *area)
+{
+	GtkWidget    *widget = GTK_WIDGET (pview);
+	GtkAllocation allocation;
+	gdouble       doc_width, doc_height;
+	gint          view_width, view_height;
+	gdouble       scale;
+
+	ev_document_get_page_size (pview->document,
+				   pview->current_page,
+				   &doc_width, &doc_height);
+	scale = ev_view_presentation_get_scale_for_page (pview, pview->current_page);
+
+	if (pview->rotation == 90 || pview->rotation == 270) {
+		view_width = (gint)((doc_height * scale) + 0.5);
+		view_height = (gint)((doc_width * scale) + 0.5);
+	} else {
+		view_width = (gint)((doc_width * scale) + 0.5);
+		view_height = (gint)((doc_height * scale) + 0.5);
+	}
+
+	gtk_widget_get_allocation (widget, &allocation);
+
+	area->x = (MAX (0, allocation.width - view_width)) / 2;
+	area->y = (MAX (0, allocation.height - view_height)) / 2;
+	area->width = view_width;
+	area->height = view_height;
+}
+
+/* Page Transition */
+static gboolean
+transition_next_page (EvViewPresentation *pview)
+{
+	ev_view_presentation_next_page (pview);
+
+	return FALSE;
+}
+
+static void
+ev_view_presentation_transition_stop (EvViewPresentation *pview)
+{
+	if (pview->trans_timeout_id > 0)
+		g_source_remove (pview->trans_timeout_id);
+	pview->trans_timeout_id = 0;
+}
+
+static void
+ev_view_presentation_transition_start (EvViewPresentation *pview)
+{
+	gdouble duration;
+
+	if (!EV_IS_DOCUMENT_TRANSITION (pview->document))
+		return;
+
+	ev_view_presentation_transition_stop (pview);
+
+	duration = ev_document_transition_get_page_duration (EV_DOCUMENT_TRANSITION (pview->document),
+							     pview->current_page);
+	if (duration >= 0) {
+		        pview->trans_timeout_id =
+				g_timeout_add_seconds (duration,
+						       (GSourceFunc) transition_next_page,
+						       pview);
+	}
+}
+
+/* Animations */
+static void
+ev_view_presentation_animation_cancel (EvViewPresentation *pview)
+{
+	if (pview->animation) {
+		g_object_unref (pview->animation);
+		pview->animation = NULL;
+	}
+}
+
+static void
+ev_view_presentation_transition_animation_finish (EvViewPresentation *pview)
+{
+	ev_view_presentation_animation_cancel (pview);
+	ev_view_presentation_transition_start (pview);
+	gtk_widget_queue_draw (GTK_WIDGET (pview));
+}
+
+static void
+ev_view_presentation_transition_animation_frame (EvViewPresentation *pview,
+						 gdouble             progress)
+{
+	gtk_widget_queue_draw (GTK_WIDGET (pview));
+}
+
+static void
+ev_view_presentation_animation_start (EvViewPresentation *pview,
+				      gint                new_page)
+{
+	EvTransitionEffect *effect = NULL;
+	cairo_surface_t    *surface;
+	gint                jump;
+
+	if (!pview->enable_animations)
+		return;
+
+	if (pview->current_page == new_page)
+		return;
+
+	effect = ev_document_transition_get_effect (EV_DOCUMENT_TRANSITION (pview->document),
+						    new_page);
+	if (!effect)
+		return;
+
+	pview->animation = ev_transition_animation_new (effect);
+
+	surface = pview->curr_job ? EV_JOB_RENDER (pview->curr_job)->surface : NULL;
+	ev_transition_animation_set_origin_surface (pview->animation,
+						    surface != NULL ?
+						    surface : pview->current_surface);
+
+	jump = new_page - pview->current_page;
+	if (jump == -1)
+		surface = pview->prev_job ? EV_JOB_RENDER (pview->prev_job)->surface : NULL;
+	else if (jump == 1)
+		surface = pview->next_job ? EV_JOB_RENDER (pview->next_job)->surface : NULL;
+	else
+		surface = NULL;
+	if (surface)
+		ev_transition_animation_set_dest_surface (pview->animation, surface);
+
+	g_signal_connect_swapped (pview->animation, "frame",
+				  G_CALLBACK (ev_view_presentation_transition_animation_frame),
+				  pview);
+	g_signal_connect_swapped (pview->animation, "finished",
+				  G_CALLBACK (ev_view_presentation_transition_animation_finish),
+				  pview);
+}
+
+/* Page Navigation */
+static void
+job_finished_cb (EvJob              *job,
+		 EvViewPresentation *pview)
+{
+	EvJobRender *job_render = EV_JOB_RENDER (job);
+
+	if (pview->inverted_colors)
+		ev_document_misc_invert_surface (job_render->surface);
+
+	if (job != pview->curr_job)
+		return;
+
+	if (pview->animation) {
+		ev_transition_animation_set_dest_surface (pview->animation,
+							  job_render->surface);
+	} else {
+		ev_view_presentation_transition_start (pview);
+		gtk_widget_queue_draw (GTK_WIDGET (pview));
+	}
+}
+
+static EvJob *
+ev_view_presentation_schedule_new_job (EvViewPresentation *pview,
+				       gint                page,
+				       EvJobPriority       priority)
+{
+	EvJob  *job;
+	gdouble scale;
+
+	if (page < 0 || page >= ev_document_get_n_pages (pview->document))
+		return NULL;
+
+	scale = ev_view_presentation_get_scale_for_page (pview, page);
+	job = ev_job_render_new (pview->document, page, pview->rotation, scale, 0, 0);
+	g_signal_connect (job, "finished",
+			  G_CALLBACK (job_finished_cb),
+			  pview);
+	ev_job_scheduler_push_job (job, priority);
+
+	return job;
+}
+
+static void
+ev_view_presentation_delete_job (EvViewPresentation *pview,
+				 EvJob              *job)
+{
+	if (!job)
+		return;
+
+	g_signal_handlers_disconnect_by_func (job, job_finished_cb, pview);
+	ev_job_cancel (job);
+	g_object_unref (job);
+}
+
+static void
+ev_view_presentation_update_current_page (EvViewPresentation *pview,
+					  guint               page)
+{
+	gint jump;
+
+	if (page < 0 || page >= ev_document_get_n_pages (pview->document))
+		return;
+
+	ev_view_presentation_animation_cancel (pview);
+	ev_view_presentation_animation_start (pview, page);
+
+	jump = page - pview->current_page;
+
+	switch (jump) {
+	case 0:
+		if (!pview->curr_job)
+			pview->curr_job = ev_view_presentation_schedule_new_job (pview, page, EV_JOB_PRIORITY_URGENT);
+		if (!pview->next_job)
+			pview->next_job = ev_view_presentation_schedule_new_job (pview, page + 1, EV_JOB_PRIORITY_HIGH);
+		if (!pview->prev_job)
+			pview->prev_job = ev_view_presentation_schedule_new_job (pview, page - 1, EV_JOB_PRIORITY_LOW);
+		break;
+	case -1:
+		ev_view_presentation_delete_job (pview, pview->next_job);
+		pview->next_job = pview->curr_job;
+		pview->curr_job = pview->prev_job;
+
+		if (!pview->curr_job)
+			pview->curr_job = ev_view_presentation_schedule_new_job (pview, page, EV_JOB_PRIORITY_URGENT);
+		else
+			ev_job_scheduler_update_job (pview->curr_job, EV_JOB_PRIORITY_URGENT);
+		pview->prev_job = ev_view_presentation_schedule_new_job (pview, page - 1, EV_JOB_PRIORITY_HIGH);
+		ev_job_scheduler_update_job (pview->next_job, EV_JOB_PRIORITY_LOW);
+
+		break;
+	case 1:
+		ev_view_presentation_delete_job (pview, pview->prev_job);
+		pview->prev_job = pview->curr_job;
+		pview->curr_job = pview->next_job;
+
+		if (!pview->curr_job)
+			pview->curr_job = ev_view_presentation_schedule_new_job (pview, page, EV_JOB_PRIORITY_URGENT);
+		else
+			ev_job_scheduler_update_job (pview->curr_job, EV_JOB_PRIORITY_URGENT);
+		pview->next_job = ev_view_presentation_schedule_new_job (pview, page + 1, EV_JOB_PRIORITY_HIGH);
+		ev_job_scheduler_update_job (pview->prev_job, EV_JOB_PRIORITY_LOW);
+
+		break;
+	case -2:
+		ev_view_presentation_delete_job (pview, pview->next_job);
+		ev_view_presentation_delete_job (pview, pview->curr_job);
+		pview->next_job = pview->prev_job;
+
+		pview->curr_job = ev_view_presentation_schedule_new_job (pview, page, EV_JOB_PRIORITY_URGENT);
+		pview->prev_job = ev_view_presentation_schedule_new_job (pview, page - 1, EV_JOB_PRIORITY_HIGH);
+		if (!pview->next_job)
+			pview->next_job = ev_view_presentation_schedule_new_job (pview, page + 1, EV_JOB_PRIORITY_LOW);
+		else
+			ev_job_scheduler_update_job (pview->next_job, EV_JOB_PRIORITY_LOW);
+		break;
+	case 2:
+		ev_view_presentation_delete_job (pview, pview->prev_job);
+		ev_view_presentation_delete_job (pview, pview->curr_job);
+		pview->prev_job = pview->next_job;
+
+		pview->curr_job = ev_view_presentation_schedule_new_job (pview, page, EV_JOB_PRIORITY_URGENT);
+		pview->next_job = ev_view_presentation_schedule_new_job (pview, page + 1, EV_JOB_PRIORITY_HIGH);
+		if (!pview->prev_job)
+			pview->prev_job = ev_view_presentation_schedule_new_job (pview, page - 1, EV_JOB_PRIORITY_LOW);
+		else
+			ev_job_scheduler_update_job (pview->prev_job, EV_JOB_PRIORITY_LOW);
+		break;
+	default:
+		ev_view_presentation_delete_job (pview, pview->prev_job);
+		ev_view_presentation_delete_job (pview, pview->curr_job);
+		ev_view_presentation_delete_job (pview, pview->next_job);
+
+		pview->curr_job = ev_view_presentation_schedule_new_job (pview, page, EV_JOB_PRIORITY_URGENT);
+		if (jump > 0) {
+			pview->next_job = ev_view_presentation_schedule_new_job (pview, page + 1, EV_JOB_PRIORITY_HIGH);
+			pview->prev_job = ev_view_presentation_schedule_new_job (pview, page - 1, EV_JOB_PRIORITY_LOW);
+		} else {
+			pview->prev_job = ev_view_presentation_schedule_new_job (pview, page - 1, EV_JOB_PRIORITY_HIGH);
+			pview->next_job = ev_view_presentation_schedule_new_job (pview, page + 1, EV_JOB_PRIORITY_LOW);
+		}
+	}
+
+	pview->current_page = page;
+
+	if (pview->page_cache)
+		ev_page_cache_set_page_range (pview->page_cache, page, page);
+
+	if (pview->cursor != EV_VIEW_CURSOR_HIDDEN) {
+		gint x, y;
+
+		gtk_widget_get_pointer (GTK_WIDGET (pview), &x, &y);
+		ev_view_presentation_set_cursor_for_location (pview, x, y);
+	}
+
+	if (EV_JOB_RENDER (pview->curr_job)->surface)
+		gtk_widget_queue_draw (GTK_WIDGET (pview));
+}
+
+static void
+ev_view_presentation_next_page (EvViewPresentation *pview)
+{
+	guint n_pages;
+	gint  new_page;
+
+	switch (pview->state) {
+	case EV_PRESENTATION_BLACK:
+	case EV_PRESENTATION_WHITE:
+		ev_view_presentation_set_normal (pview);
+	case EV_PRESENTATION_END:
+		return;
+	case EV_PRESENTATION_NORMAL:
+		break;
+	}
+
+	n_pages = ev_document_get_n_pages (pview->document);
+	new_page = pview->current_page + 1;
+
+	if (new_page == n_pages)
+		ev_view_presentation_set_end (pview);
+	else
+		ev_view_presentation_update_current_page (pview, new_page);
+}
+
+static void
+ev_view_presentation_previous_page (EvViewPresentation *pview)
+{
+	gint new_page = 0;
+
+	switch (pview->state) {
+	case EV_PRESENTATION_BLACK:
+	case EV_PRESENTATION_WHITE:
+		ev_view_presentation_set_normal (pview);
+		return;
+	case EV_PRESENTATION_END:
+		pview->state = EV_PRESENTATION_NORMAL;
+		new_page = pview->current_page;
+		break;
+	case EV_PRESENTATION_NORMAL:
+		new_page = pview->current_page - 1;
+		break;
+	}
+
+	ev_view_presentation_update_current_page (pview, new_page);
+}
+
+/* Goto Window */
+#define KEY_IS_NUMERIC(keyval) \
+	((keyval >= GDK_0 && keyval <= GDK_9) || (keyval >= GDK_KP_0 && keyval <= GDK_KP_9))
+
+/* Cut and paste from gtkwindow.c */
+static void
+send_focus_change (GtkWidget *widget,
+		   gboolean   in)
+{
+	GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+
+	fevent->focus_change.type = GDK_FOCUS_CHANGE;
+	fevent->focus_change.window = gtk_widget_get_window (widget);
+	fevent->focus_change.in = in;
+	if (fevent->focus_change.window)
+		g_object_ref (fevent->focus_change.window);
+
+	gtk_widget_send_focus_change (widget, fevent);
+
+	gdk_event_free (fevent);
+}
+
+static void
+ev_view_presentation_goto_window_hide (EvViewPresentation *pview)
+{
+	/* send focus-in event */
+	send_focus_change (pview->goto_entry, FALSE);
+	gtk_widget_hide (pview->goto_window);
+	gtk_entry_set_text (GTK_ENTRY (pview->goto_entry), "");
+}
+
+static gboolean
+ev_view_presentation_goto_window_delete_event (GtkWidget          *widget,
+					       GdkEventAny        *event,
+					       EvViewPresentation *pview)
+{
+	ev_view_presentation_goto_window_hide (pview);
+
+	return TRUE;
+}
+
+static gboolean
+ev_view_presentation_goto_window_key_press_event (GtkWidget          *widget,
+						  GdkEventKey        *event,
+						  EvViewPresentation *pview)
+{
+	switch (event->keyval) {
+	case GDK_Escape:
+	case GDK_Tab:
+	case GDK_KP_Tab:
+	case GDK_ISO_Left_Tab:
+		ev_view_presentation_goto_window_hide (pview);
+		return TRUE;
+	case GDK_Return:
+	case GDK_KP_Enter:
+	case GDK_ISO_Enter:
+	case GDK_BackSpace:
+	case GDK_Delete:
+		return FALSE;
+	default:
+		if (!KEY_IS_NUMERIC (event->keyval))
+			return TRUE;
+	}
+
+	return FALSE;
+}
+
+static gboolean
+ev_view_presentation_goto_window_button_press_event (GtkWidget          *widget,
+						     GdkEventButton     *event,
+						     EvViewPresentation *pview)
+{
+	ev_view_presentation_goto_window_hide (pview);
+
+	return TRUE;
+}
+
+static void
+ev_view_presentation_goto_entry_activate (GtkEntry           *entry,
+					  EvViewPresentation *pview)
+{
+	const gchar *text;
+	gint         page;
+
+	text = gtk_entry_get_text (entry);
+	page = atoi (text) - 1;
+
+	ev_view_presentation_goto_window_hide (pview);
+	ev_view_presentation_update_current_page (pview, page);
+}
+
+static void
+ev_view_presentation_goto_window_create (EvViewPresentation *pview)
+{
+	GtkWidget *frame, *hbox, *label;
+	GtkWindow *toplevel, *goto_window;
+
+	toplevel = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (pview)));
+	goto_window = GTK_WINDOW (pview->goto_window);
+
+	if (pview->goto_window) {
+		if (gtk_window_has_group (toplevel))
+			gtk_window_group_add_window (gtk_window_get_group (toplevel), goto_window);
+		else if (gtk_window_has_group (goto_window))
+			gtk_window_group_remove_window (gtk_window_get_group (goto_window), goto_window);
+
+		return;
+	}
+
+	pview->goto_window = gtk_window_new (GTK_WINDOW_POPUP);
+	gtk_window_set_screen (goto_window, gtk_widget_get_screen (GTK_WIDGET (pview)));
+
+	if (gtk_window_has_group (toplevel))
+		gtk_window_group_add_window (gtk_window_get_group (toplevel), goto_window);
+
+	gtk_window_set_modal (goto_window, TRUE);
+
+	g_signal_connect (pview->goto_window, "delete_event",
+			  G_CALLBACK (ev_view_presentation_goto_window_delete_event),
+			  pview);
+	g_signal_connect (pview->goto_window, "key_press_event",
+			  G_CALLBACK (ev_view_presentation_goto_window_key_press_event),
+			  pview);
+	g_signal_connect (pview->goto_window, "button_press_event",
+			  G_CALLBACK (ev_view_presentation_goto_window_button_press_event),
+			  pview);
+
+	frame = gtk_frame_new (NULL);
+	gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
+	gtk_container_add (GTK_CONTAINER (pview->goto_window), frame);
+	gtk_widget_show (frame);
+
+	hbox = gtk_hbox_new (FALSE, 0);
+	gtk_container_set_border_width (GTK_CONTAINER (hbox), 3);
+	gtk_container_add (GTK_CONTAINER (frame), hbox);
+	gtk_widget_show (hbox);
+
+	label = gtk_label_new (_("Jump to page:"));
+	gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 3);
+	gtk_widget_show (label);
+	gtk_widget_realize (label);
+
+	pview->goto_entry = gtk_entry_new ();
+	g_signal_connect (pview->goto_entry, "activate",
+			  G_CALLBACK (ev_view_presentation_goto_entry_activate),
+			  pview);
+	gtk_box_pack_start (GTK_BOX (hbox), pview->goto_entry, TRUE, TRUE, 0);
+	gtk_widget_show (pview->goto_entry);
+	gtk_widget_realize (pview->goto_entry);
+}
+
+static void
+ev_view_presentation_goto_entry_grab_focus (EvViewPresentation *pview)
+{
+	GtkWidgetClass *entry_parent_class;
+
+	entry_parent_class = g_type_class_peek_parent (GTK_ENTRY_GET_CLASS (pview->goto_entry));
+	(entry_parent_class->grab_focus) (pview->goto_entry);
+
+	send_focus_change (pview->goto_entry, TRUE);
+}
+
+static void
+ev_view_presentation_goto_window_send_key_event (EvViewPresentation *pview,
+						 GdkEvent           *event)
+{
+	GdkEventKey *new_event;
+	GdkScreen   *screen;
+
+	/* Move goto window off screen */
+	screen = gtk_widget_get_screen (GTK_WIDGET (pview));
+	gtk_window_move (GTK_WINDOW (pview->goto_window),
+			 gdk_screen_get_width (screen) + 1,
+			 gdk_screen_get_height (screen) + 1);
+	gtk_widget_show (pview->goto_window);
+
+	new_event = (GdkEventKey *) gdk_event_copy (event);
+	g_object_unref (new_event->window);
+	new_event->window = gtk_widget_get_window (pview->goto_window);
+	if (new_event->window)
+		g_object_ref (new_event->window);
+	gtk_widget_realize (pview->goto_window);
+
+	gtk_widget_event (pview->goto_window, (GdkEvent *)new_event);
+	gdk_event_free ((GdkEvent *)new_event);
+	gtk_widget_hide (pview->goto_window);
+}
+
+/* Links */
+static gboolean
+ev_view_presentation_link_is_supported (EvViewPresentation *pview,
+					EvLink             *link)
+{
+	EvLinkAction *action;
+
+	action = ev_link_get_action (link);
+	if (!action)
+		return FALSE;
+
+	switch (ev_link_action_get_action_type (action)) {
+	case EV_LINK_ACTION_TYPE_GOTO_DEST:
+		return ev_link_action_get_dest (action) != NULL;
+	case EV_LINK_ACTION_TYPE_NAMED:
+		return TRUE;
+	default:
+		return FALSE;
+	}
+
+	return FALSE;
+}
+
+static EvLink *
+ev_view_presentation_get_link_at_location (EvViewPresentation *pview,
+					   gdouble             x,
+					   gdouble             y)
+{
+	GdkRectangle   page_area;
+	EvMappingList *link_mapping;
+	EvLink        *link;
+	gdouble        width, height;
+	gdouble        new_x, new_y;
+	gdouble        scale;
+
+	if (!pview->page_cache)
+		return NULL;
+
+	ev_document_get_page_size (pview->document, pview->current_page, &width, &height);
+	ev_view_presentation_get_page_area (pview, &page_area);
+	scale = ev_view_presentation_get_scale_for_page (pview, pview->current_page);
+	x = (x - page_area.x) / scale;
+	y = (y - page_area.y) / scale;
+	switch (pview->rotation) {
+	case 0:
+	case 360:
+		new_x = x;
+		new_y = y;
+		break;
+	case 90:
+		new_x = y;
+		new_y = height - x;
+		break;
+	case 180:
+		new_x = width - x;
+		new_y = height - y;
+		break;
+	case 270:
+		new_x = width - y;
+		new_y = x;
+		break;
+	default:
+		g_assert_not_reached ();
+	}
+
+	link_mapping = ev_page_cache_get_link_mapping (pview->page_cache, pview->current_page);
+
+	link = link_mapping ? ev_mapping_list_get_data (link_mapping, new_x, new_y) : NULL;
+
+	return link && ev_view_presentation_link_is_supported (pview, link) ? link : NULL;
+}
+
+static void
+ev_vew_presentation_goto_link_dest (EvViewPresentation *pview,
+				    EvLink             *link)
+{
+	EvLinkAction *action;
+
+	action = ev_link_get_action (link);
+
+	if (ev_link_action_get_action_type (action) == EV_LINK_ACTION_TYPE_NAMED) {
+		const gchar *name = ev_link_action_get_name (action);
+
+		if (g_ascii_strcasecmp (name, "FirstPage") == 0) {
+			ev_view_presentation_update_current_page (pview, 0);
+		} else if (g_ascii_strcasecmp (name, "PrevPage") == 0) {
+			ev_view_presentation_update_current_page (pview, pview->current_page - 1);
+		} else if (g_ascii_strcasecmp (name, "NextPage") == 0) {
+			ev_view_presentation_update_current_page (pview, pview->current_page + 1);
+		} else if (g_ascii_strcasecmp (name, "LastPage") == 0) {
+			gint n_pages;
+
+			n_pages = ev_document_get_n_pages (pview->document);
+			ev_view_presentation_update_current_page (pview, n_pages - 1);
+		}
+	} else {
+		EvLinkDest *dest;
+		gint        page;
+
+		dest = ev_link_action_get_dest (action);
+		page = ev_document_links_get_dest_page (EV_DOCUMENT_LINKS (pview->document), dest);
+		ev_view_presentation_update_current_page (pview, page);
+	}
+}
+
+/* Cursors */
+static void
+ev_view_presentation_set_cursor (EvViewPresentation *pview,
+				 EvViewCursor        view_cursor)
+{
+	GtkWidget  *widget;
+	GdkCursor  *cursor;
+
+	if (pview->cursor == view_cursor)
+		return;
+
+	widget = GTK_WIDGET (pview);
+	if (!gtk_widget_get_realized (widget))
+		gtk_widget_realize (widget);
+
+	pview->cursor = view_cursor;
+
+	cursor = ev_view_cursor_new (gtk_widget_get_display (widget), view_cursor);
+	gdk_window_set_cursor (gtk_widget_get_window (widget), cursor);
+	gdk_flush ();
+	if (cursor)
+		gdk_cursor_unref (cursor);
+}
+
+static void
+ev_view_presentation_set_cursor_for_location (EvViewPresentation *pview,
+					      gdouble             x,
+					      gdouble             y)
+{
+	if (ev_view_presentation_get_link_at_location (pview, x, y))
+		ev_view_presentation_set_cursor (pview, EV_VIEW_CURSOR_LINK);
+	else
+		ev_view_presentation_set_cursor (pview, EV_VIEW_CURSOR_NORMAL);
+}
+
+static gboolean
+hide_cursor_timeout_cb (EvViewPresentation *pview)
+{
+	ev_view_presentation_set_cursor (pview, EV_VIEW_CURSOR_HIDDEN);
+	pview->hide_cursor_timeout_id = 0;
+
+	return FALSE;
+}
+
+static void
+ev_view_presentation_hide_cursor_timeout_stop (EvViewPresentation *pview)
+{
+	if (pview->hide_cursor_timeout_id > 0)
+		g_source_remove (pview->hide_cursor_timeout_id);
+	pview->hide_cursor_timeout_id = 0;
+}
+
+static void
+ev_view_presentation_hide_cursor_timeout_start (EvViewPresentation *pview)
+{
+	ev_view_presentation_hide_cursor_timeout_stop (pview);
+	pview->hide_cursor_timeout_id =
+		g_timeout_add_seconds (HIDE_CURSOR_TIMEOUT,
+				       (GSourceFunc)hide_cursor_timeout_cb,
+				       pview);
+}
+
+static void
+ev_view_presentation_update_current_surface (EvViewPresentation *pview,
+					     cairo_surface_t    *surface)
+{
+	if (!surface || pview->current_surface == surface)
+		return;
+
+	cairo_surface_reference (surface);
+	if (pview->current_surface)
+		cairo_surface_destroy (pview->current_surface);
+	pview->current_surface = surface;
+}
+
+static void
+ev_view_presentation_destroy (GtkObject *object)
+{
+	EvViewPresentation *pview = EV_VIEW_PRESENTATION (object);
+
+	if (pview->document) {
+		g_object_unref (pview->document);
+		pview->document = NULL;
+	}
+
+	ev_view_presentation_animation_cancel (pview);
+	ev_view_presentation_transition_stop (pview);
+	ev_view_presentation_hide_cursor_timeout_stop (pview);
+
+	if (pview->curr_job) {
+		ev_view_presentation_delete_job (pview, pview->curr_job);
+		pview->curr_job = NULL;
+	}
+
+	if (pview->prev_job) {
+		ev_view_presentation_delete_job (pview, pview->prev_job);
+		pview->prev_job = NULL;
+	}
+
+	if (pview->next_job) {
+		ev_view_presentation_delete_job (pview, pview->next_job);
+		pview->next_job = NULL;
+	}
+
+	if (pview->current_surface) {
+		cairo_surface_destroy (pview->current_surface);
+		pview->current_surface = NULL;
+	}
+
+	if (pview->page_cache) {
+		g_object_unref (pview->page_cache);
+		pview->page_cache = NULL;
+	}
+
+	if (pview->goto_window) {
+		gtk_widget_destroy (pview->goto_window);
+		pview->goto_window = NULL;
+		pview->goto_entry = NULL;
+	}
+
+	GTK_OBJECT_CLASS (ev_view_presentation_parent_class)->destroy (object);
+}
+
+static void
+ev_view_presentation_size_request (GtkWidget      *widget,
+				   GtkRequisition *requisition)
+{
+	requisition->width = 0;
+	requisition->height = 0;
+}
+
+static void
+ev_view_presentation_draw_end_page (EvViewPresentation *pview)
+{
+	GtkWidget *widget = GTK_WIDGET (pview);
+	PangoLayout *layout;
+	PangoFontDescription *font_desc;
+	gchar *markup;
+	GtkAllocation allocation;
+	GdkRectangle area = {0};
+	const gchar *text = _("End of presentation. Click to exit.");
+
+	if (pview->state != EV_PRESENTATION_END)
+		return;
+
+	layout = gtk_widget_create_pango_layout (widget, NULL);
+	markup = g_strdup_printf ("<span foreground=\"white\">%s</span>", text);
+	pango_layout_set_markup (layout, markup, -1);
+	g_free (markup);
+
+	font_desc = pango_font_description_new ();
+	pango_font_description_set_size (font_desc, 16 * PANGO_SCALE);
+	pango_layout_set_font_description (layout, font_desc);
+
+	gtk_widget_get_allocation (widget, &allocation);
+	area.width = allocation.width;
+	area.height = allocation.height;
+
+	gtk_paint_layout (gtk_widget_get_style (widget),
+			  gtk_widget_get_window (widget),
+			  gtk_widget_get_state (widget),
+			  FALSE,
+			  &area,
+			  widget,
+			  NULL,
+			  15,
+			  15,
+			  layout);
+
+	pango_font_description_free (font_desc);
+	g_object_unref (layout);
+}
+
+static gboolean
+ev_view_presentation_expose_event (GtkWidget      *widget,
+				   GdkEventExpose *event)
+{
+	EvViewPresentation *pview = EV_VIEW_PRESENTATION (widget);
+	GdkRectangle        page_area;
+	GdkRectangle        overlap;
+	cairo_surface_t    *surface;
+	cairo_t            *cr;
+
+	switch (pview->state) {
+	case EV_PRESENTATION_END:
+		ev_view_presentation_draw_end_page (pview);
+		return FALSE;
+	case EV_PRESENTATION_BLACK:
+	case EV_PRESENTATION_WHITE:
+		return FALSE;
+	case EV_PRESENTATION_NORMAL:
+		break;
+	}
+
+	if (pview->animation) {
+		if (ev_transition_animation_ready (pview->animation)) {
+			ev_view_presentation_get_page_area (pview, &page_area);
+
+			cr = gdk_cairo_create (gtk_widget_get_window (widget));
+
+			/* normalize to x=0, y=0 */
+			cairo_translate (cr, page_area.x, page_area.y);
+			page_area.x = page_area.y = 0;
+
+			/* Try to fix rounding errors */
+			page_area.width--;
+
+			ev_transition_animation_paint (pview->animation, cr, page_area);
+			cairo_destroy (cr);
+		}
+
+		return TRUE;
+	}
+
+	surface = pview->curr_job ? EV_JOB_RENDER (pview->curr_job)->surface : NULL;
+	if (surface) {
+		ev_view_presentation_update_current_surface (pview, surface);
+	} else if (pview->current_surface) {
+		surface = pview->current_surface;
+	} else {
+		return FALSE;
+	}
+
+	ev_view_presentation_get_page_area (pview, &page_area);
+	if (gdk_rectangle_intersect (&page_area, &(event->area), &overlap)) {
+		cr = gdk_cairo_create (gtk_widget_get_window (widget));
+
+		/* Try to fix rounding errors. See bug #438760 */
+		if (overlap.width == page_area.width)
+			overlap.width--;
+
+		cairo_rectangle (cr, overlap.x, overlap.y, overlap.width, overlap.height);
+		cairo_set_source_surface (cr, surface, page_area.x, page_area.y);
+		cairo_fill (cr);
+		cairo_destroy (cr);
+	}
+
+	return FALSE;
+}
+
+static gboolean
+ev_view_presentation_key_press_event (GtkWidget   *widget,
+				      GdkEventKey *event)
+{
+	EvViewPresentation *pview = EV_VIEW_PRESENTATION (widget);
+
+	if (pview->state == EV_PRESENTATION_END)
+		return gtk_bindings_activate_event (GTK_OBJECT (widget), event);
+
+	switch (event->keyval) {
+	case GDK_b:
+	case GDK_B:
+	case GDK_period:
+	case GDK_KP_Decimal:
+		if (pview->state == EV_PRESENTATION_BLACK)
+			ev_view_presentation_set_normal (pview);
+		else
+			ev_view_presentation_set_black (pview);
+
+		return TRUE;
+	case GDK_w:
+	case GDK_W:
+		if (pview->state == EV_PRESENTATION_WHITE)
+			ev_view_presentation_set_normal (pview);
+		else
+			ev_view_presentation_set_white (pview);
+
+		return TRUE;
+	case GDK_Home:
+		if (pview->state == EV_PRESENTATION_NORMAL) {
+			ev_view_presentation_update_current_page (pview, 0);
+			return TRUE;
+		}
+		break;
+	case GDK_End:
+		if (pview->state == EV_PRESENTATION_NORMAL) {
+			gint page;
+
+			page = ev_document_get_n_pages (pview->document) - 1;
+			ev_view_presentation_update_current_page (pview, page);
+
+			return TRUE;
+		}
+		break;
+	default:
+		break;
+	}
+
+	ev_view_presentation_set_normal (pview);
+
+	if (ev_document_get_n_pages (pview->document) > 1 && KEY_IS_NUMERIC (event->keyval)) {
+		gint x, y;
+
+		ev_view_presentation_goto_window_create (pview);
+		ev_view_presentation_goto_window_send_key_event (pview, (GdkEvent *)event);
+		gtk_widget_get_pointer (GTK_WIDGET (pview), &x, &y);
+		gtk_window_move (GTK_WINDOW (pview->goto_window), x, y);
+		gtk_widget_show (pview->goto_window);
+		ev_view_presentation_goto_entry_grab_focus (pview);
+
+		return TRUE;
+	}
+
+	return gtk_bindings_activate_event (GTK_OBJECT (widget), event);
+}
+
+static gboolean
+ev_view_presentation_button_release_event (GtkWidget      *widget,
+					   GdkEventButton *event)
+{
+	EvViewPresentation *pview = EV_VIEW_PRESENTATION (widget);
+
+	switch (event->button) {
+	case 1: {
+		EvLink *link;
+
+		if (pview->state == EV_PRESENTATION_END) {
+			g_signal_emit (pview, signals[FINISHED], 0, NULL);
+
+			return FALSE;
+		}
+
+		link = ev_view_presentation_get_link_at_location (pview,
+								  event->x,
+								  event->y);
+		if (link)
+			ev_vew_presentation_goto_link_dest (pview, link);
+		else
+			ev_view_presentation_next_page (pview);
+	}
+		break;
+	case 3:
+		ev_view_presentation_previous_page (pview);
+		break;
+	default:
+		break;
+	}
+
+	return FALSE;
+}
+
+static gint
+ev_view_presentation_focus_out (GtkWidget     *widget,
+				GdkEventFocus *event)
+{
+	EvViewPresentation *pview = EV_VIEW_PRESENTATION (widget);
+
+	if (pview->goto_window)
+		ev_view_presentation_goto_window_hide (pview);
+
+	return FALSE;
+}
+
+static gboolean
+ev_view_presentation_motion_notify_event (GtkWidget      *widget,
+					  GdkEventMotion *event)
+{
+	EvViewPresentation *pview = EV_VIEW_PRESENTATION (widget);
+
+	ev_view_presentation_hide_cursor_timeout_start (pview);
+	ev_view_presentation_set_cursor_for_location (pview, event->x, event->y);
+
+	return FALSE;
+}
+
+static gboolean
+init_presentation (GtkWidget *widget)
+{
+	EvViewPresentation *pview = EV_VIEW_PRESENTATION (widget);
+	GdkScreen          *screen = gtk_widget_get_screen (widget);
+	GdkRectangle        monitor;
+	gint                monitor_num;
+
+	monitor_num = gdk_screen_get_monitor_at_window (screen, gtk_widget_get_window (widget));
+	gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
+	pview->monitor_width = monitor.width;
+	pview->monitor_height = monitor.height;
+
+	ev_view_presentation_update_current_page (pview, pview->current_page);
+	ev_view_presentation_hide_cursor_timeout_start (pview);
+
+	return FALSE;
+}
+
+static void
+ev_view_presentation_realize (GtkWidget *widget)
+{
+	GdkWindow    *window;
+	GtkStyle     *style;
+	GdkWindowAttr attributes;
+	GtkAllocation allocation;
+
+	gtk_widget_set_realized (widget, TRUE);
+
+	attributes.window_type = GDK_WINDOW_CHILD;
+	attributes.wclass = GDK_INPUT_OUTPUT;
+	attributes.visual = gtk_widget_get_visual (widget);
+	attributes.colormap = gtk_widget_get_colormap (widget);
+
+	gtk_widget_get_allocation (widget, &allocation);
+	attributes.x = allocation.x;
+	attributes.y = allocation.y;
+	attributes.width = allocation.width;
+	attributes.height = allocation.height;
+	attributes.event_mask = GDK_EXPOSURE_MASK |
+		GDK_BUTTON_PRESS_MASK |
+		GDK_BUTTON_RELEASE_MASK |
+		GDK_SCROLL_MASK |
+		GDK_KEY_PRESS_MASK |
+		GDK_POINTER_MOTION_MASK |
+		GDK_POINTER_MOTION_HINT_MASK |
+		GDK_ENTER_NOTIFY_MASK |
+		GDK_LEAVE_NOTIFY_MASK;
+
+	window = gdk_window_new (gtk_widget_get_parent_window (widget),
+				 &attributes,
+				 GDK_WA_X | GDK_WA_Y |
+				 GDK_WA_COLORMAP |
+				 GDK_WA_VISUAL);
+
+	gdk_window_set_user_data (window, widget);
+	gtk_widget_set_window (widget, window);
+
+	gtk_widget_style_attach (widget);
+	style = gtk_widget_get_style (widget);
+	gdk_window_set_background (window, &style->black);
+
+	g_idle_add ((GSourceFunc)init_presentation, widget);
+}
+
+static void
+ev_view_presentation_change_page (EvViewPresentation *pview,
+				  GtkScrollType       scroll)
+{
+	switch (scroll) {
+	case GTK_SCROLL_PAGE_FORWARD:
+		ev_view_presentation_next_page (pview);
+		break;
+	case GTK_SCROLL_PAGE_BACKWARD:
+		ev_view_presentation_previous_page (pview);
+		break;
+	default:
+		g_assert_not_reached ();
+	}
+}
+
+static gboolean
+ev_view_presentation_scroll_event (GtkWidget      *widget,
+				   GdkEventScroll *event)
+{
+	EvViewPresentation *pview = EV_VIEW_PRESENTATION (widget);
+	guint               state;
+
+	state = event->state & gtk_accelerator_get_default_mod_mask ();
+	if (state != 0)
+		return FALSE;
+
+	switch (event->direction) {
+	case GDK_SCROLL_DOWN:
+	case GDK_SCROLL_RIGHT:
+		ev_view_presentation_change_page (pview, GTK_SCROLL_PAGE_FORWARD);
+		break;
+	case GDK_SCROLL_UP:
+	case GDK_SCROLL_LEFT:
+		ev_view_presentation_change_page (pview, GTK_SCROLL_PAGE_BACKWARD);
+		break;
+	}
+
+	return TRUE;
+}
+
+
+static void
+add_change_page_binding_keypad (GtkBindingSet  *binding_set,
+				guint           keyval,
+				GdkModifierType modifiers,
+				GtkScrollType   scroll)
+{
+	guint keypad_keyval = keyval - GDK_Left + GDK_KP_Left;
+
+	gtk_binding_entry_add_signal (binding_set, keyval, modifiers,
+				      "change_page", 1,
+				      GTK_TYPE_SCROLL_TYPE, scroll);
+	gtk_binding_entry_add_signal (binding_set, keypad_keyval, modifiers,
+				      "change_page", 1,
+				      GTK_TYPE_SCROLL_TYPE, scroll);
+}
+
+static void
+ev_view_presentation_set_property (GObject      *object,
+				   guint         prop_id,
+				   const GValue *value,
+				   GParamSpec   *pspec)
+{
+	EvViewPresentation *pview = EV_VIEW_PRESENTATION (object);
+
+	switch (prop_id) {
+	case PROP_DOCUMENT:
+		pview->document = g_value_dup_object (value);
+		pview->enable_animations = EV_IS_DOCUMENT_TRANSITION (pview->document);
+		break;
+	case PROP_CURRENT_PAGE:
+		pview->current_page = g_value_get_uint (value);
+		break;
+	case PROP_ROTATION:
+		pview->rotation = g_value_get_uint (value);
+		break;
+	case PROP_INVERTED_COLORS:
+		pview->inverted_colors = g_value_get_boolean (value);
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+	}
+}
+
+static GObject *
+ev_view_presentation_constructor (GType                  type,
+				  guint                  n_construct_properties,
+				  GObjectConstructParam *construct_params)
+{
+	GObject            *object;
+	EvViewPresentation *pview;
+
+	object = G_OBJECT_CLASS (ev_view_presentation_parent_class)->constructor (type,
+										  n_construct_properties,
+										  construct_params);
+	pview = EV_VIEW_PRESENTATION (object);
+
+	if (EV_IS_DOCUMENT_LINKS (pview->document)) {
+		pview->page_cache = ev_page_cache_new (pview->document);
+		ev_page_cache_set_flags (pview->page_cache, EV_PAGE_DATA_INCLUDE_LINKS);
+	}
+
+	return object;
+}
+
+static void
+ev_view_presentation_class_init (EvViewPresentationClass *klass)
+{
+	GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+	GObjectClass   *gobject_class = G_OBJECT_CLASS (klass);
+	GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (klass);
+	GtkBindingSet  *binding_set;
+
+	klass->change_page = ev_view_presentation_change_page;
+
+	widget_class->size_request = ev_view_presentation_size_request;
+	widget_class->realize = ev_view_presentation_realize;
+	widget_class->expose_event = ev_view_presentation_expose_event;
+	widget_class->key_press_event = ev_view_presentation_key_press_event;
+	widget_class->button_release_event = ev_view_presentation_button_release_event;
+	widget_class->focus_out_event = ev_view_presentation_focus_out;
+	widget_class->motion_notify_event = ev_view_presentation_motion_notify_event;
+	widget_class->scroll_event = ev_view_presentation_scroll_event;
+
+	gtk_object_class->destroy = ev_view_presentation_destroy;
+
+	gobject_class->constructor = ev_view_presentation_constructor;
+	gobject_class->set_property = ev_view_presentation_set_property;
+
+	g_object_class_install_property (gobject_class,
+					 PROP_DOCUMENT,
+					 g_param_spec_object ("document",
+							      "Document",
+							      "Document",
+							      EV_TYPE_DOCUMENT,
+							      G_PARAM_WRITABLE |
+							      G_PARAM_CONSTRUCT_ONLY));
+	g_object_class_install_property (gobject_class,
+					 PROP_CURRENT_PAGE,
+					 g_param_spec_uint ("current_page",
+							    "Current Page",
+							    "The current page",
+							    0, G_MAXUINT, 0,
+							    G_PARAM_WRITABLE |
+							    G_PARAM_CONSTRUCT_ONLY));
+	g_object_class_install_property (gobject_class,
+					 PROP_ROTATION,
+					 g_param_spec_uint ("rotation",
+							    "Rotation",
+							    "Current rotation angle",
+							    0, 360, 0,
+							    G_PARAM_WRITABLE |
+							    G_PARAM_CONSTRUCT_ONLY));
+	g_object_class_install_property (gobject_class,
+					 PROP_INVERTED_COLORS,
+					 g_param_spec_boolean ("inverted_colors",
+							       "Inverted Colors",
+							       "Whether presentation is displayed with inverted colors",
+							       FALSE,
+							       G_PARAM_WRITABLE |
+							       G_PARAM_CONSTRUCT_ONLY));
+
+	signals[CHANGE_PAGE] =
+		g_signal_new ("change_page",
+			      G_OBJECT_CLASS_TYPE (gobject_class),
+			      G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+			      G_STRUCT_OFFSET (EvViewPresentationClass, change_page),
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__ENUM,
+			      G_TYPE_NONE, 1,
+			      GTK_TYPE_SCROLL_TYPE);
+	signals[FINISHED] =
+		g_signal_new ("finished",
+			      G_OBJECT_CLASS_TYPE (gobject_class),
+			      G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+			      G_STRUCT_OFFSET (EvViewPresentationClass, finished),
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__VOID,
+			      G_TYPE_NONE, 0,
+			      G_TYPE_NONE);
+
+	binding_set = gtk_binding_set_by_class (klass);
+	add_change_page_binding_keypad (binding_set, GDK_Left,  0, GTK_SCROLL_PAGE_BACKWARD);
+	add_change_page_binding_keypad (binding_set, GDK_Right, 0, GTK_SCROLL_PAGE_FORWARD);
+	add_change_page_binding_keypad (binding_set, GDK_Up,    0, GTK_SCROLL_PAGE_BACKWARD);
+	add_change_page_binding_keypad (binding_set, GDK_Down,  0, GTK_SCROLL_PAGE_FORWARD);
+	gtk_binding_entry_add_signal (binding_set, GDK_space, 0,
+				      "change_page", 1,
+				      GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_PAGE_FORWARD);
+	gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, 0,
+				      "change_page", 1,
+				      GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_PAGE_BACKWARD);
+	gtk_binding_entry_add_signal (binding_set, GDK_Page_Down, 0,
+				      "change_page", 1,
+				      GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_PAGE_FORWARD);
+	gtk_binding_entry_add_signal (binding_set, GDK_Page_Up, 0,
+				      "change_page", 1,
+				      GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_PAGE_BACKWARD);
+	gtk_binding_entry_add_signal (binding_set, GDK_J, 0,
+				      "change_page", 1,
+				      GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_PAGE_FORWARD);
+	gtk_binding_entry_add_signal (binding_set, GDK_H, 0,
+				      "change_page", 1,
+				      GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_PAGE_BACKWARD);
+	gtk_binding_entry_add_signal (binding_set, GDK_L, 0,
+				      "change_page", 1,
+				      GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_PAGE_FORWARD);
+	gtk_binding_entry_add_signal (binding_set, GDK_K, 0,
+				      "change_page", 1,
+				      GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_PAGE_BACKWARD);
+}
+
+static void
+ev_view_presentation_init (EvViewPresentation *pview)
+{
+	gtk_widget_set_can_focus (GTK_WIDGET (pview), TRUE);
+}
+
+GtkWidget *
+ev_view_presentation_new (EvDocument *document,
+			  guint       current_page,
+			  guint       rotation,
+			  gboolean    inverted_colors)
+{
+	g_return_val_if_fail (EV_IS_DOCUMENT (document), NULL);
+	g_return_val_if_fail (current_page < ev_document_get_n_pages (document), NULL);
+
+	return GTK_WIDGET (g_object_new (EV_TYPE_VIEW_PRESENTATION,
+					 "document", document,
+					 "current_page", current_page,
+					 "rotation", rotation,
+					 "inverted_colors", inverted_colors,
+					 NULL));
+}
+
+guint
+ev_view_presentation_get_current_page (EvViewPresentation *pview)
+{
+	return pview->current_page;
+}