Change the preview cache back to 1. Don't know when it got set to 0.

Sun May  1 00:46:47 2005  Jonathan Blandford  <jrb@redhat.com>

        * shell/ev-pixbuf-cache.c: (ev_pixbuf_cache_init): Change the
        preview cache back to 1.  Don't know when it got set to 0.

        * shell/ev-view.c: (compute_border), (ev_view_realize),
        (draw_one_page), (ev_view_set_property), (ev_view_get_property),
        (ev_view_class_init), (ev_view_init), (ev_view_set_fullscreen),
        (ev_view_get_fullscreen), (ev_view_set_presentation),
        (ev_view_get_presentation), (ev_view_set_sizing_mode),
        (ev_view_zoom_for_size_presentation), (ev_view_set_zoom_for_size):
        * shell/ev-view.h:
        * shell/ev-window.c:
        (update_chrome_visibility),
        (ev_window_cmd_continuous), (ev_window_cmd_dual),
        (ev_window_cmd_view_best_fit), (ev_window_cmd_view_page_width),
        (update_document_mode), (ev_window_update_fullscreen_action),
        (ev_window_fullscreen), (ev_window_unfullscreen),
        (ev_window_cmd_view_fullscreen),
        (ev_window_update_presentation_action),
        (ev_window_run_presentation), (ev_window_stop_presentation),
        (ev_window_cmd_view_presentation), (ev_window_state_event),
        (ev_window_focus_in_event), (ev_window_focus_out_event),
        (ev_window_cmd_escape), (ev_window_sidebar_visibility_changed_cb):
        * data/evince-ui.xml: Initial presentation mode.  We should
        probably hide this until it's done, as it's quite rough.  Also,
        change full-screen to fullscreen and add two getters to EvView.

diff --git a/ChangeLog b/ChangeLog
index f0ed51cc5c0721ab8a5ca257033fb4e4c6b4c4be..041ddd8cfce6505252872dd849e86c36e0a81aba 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,31 @@
+Sun May  1 00:46:47 2005  Jonathan Blandford  <jrb@redhat.com>
+
+       * shell/ev-pixbuf-cache.c: (ev_pixbuf_cache_init): Change the
+       preview cache back to 1.  Don't know when it got set to 0.
+       
+       * shell/ev-view.c: (compute_border), (ev_view_realize),
+       (draw_one_page), (ev_view_set_property), (ev_view_get_property),
+       (ev_view_class_init), (ev_view_init), (ev_view_set_fullscreen),
+       (ev_view_get_fullscreen), (ev_view_set_presentation),
+       (ev_view_get_presentation), (ev_view_set_sizing_mode),
+       (ev_view_zoom_for_size_presentation), (ev_view_set_zoom_for_size):
+       * shell/ev-view.h:
+       * shell/ev-window.c:
+       (update_chrome_visibility),
+       (ev_window_cmd_continuous), (ev_window_cmd_dual),
+       (ev_window_cmd_view_best_fit), (ev_window_cmd_view_page_width),
+       (update_document_mode), (ev_window_update_fullscreen_action),
+       (ev_window_fullscreen), (ev_window_unfullscreen),
+       (ev_window_cmd_view_fullscreen),
+       (ev_window_update_presentation_action),
+       (ev_window_run_presentation), (ev_window_stop_presentation),
+       (ev_window_cmd_view_presentation), (ev_window_state_event),
+       (ev_window_focus_in_event), (ev_window_focus_out_event),
+       (ev_window_cmd_escape), (ev_window_sidebar_visibility_changed_cb):
+       * data/evince-ui.xml: Initial presentation mode.  We should
+       probably hide this until it's done, as it's quite rough.  Also,
+       change full-screen to fullscreen and add two getters to EvView.
+
 2005-04-29  Marco Pesenti Gritti  <mpg@redhat.com>
 
        * shell/ev-page-action.c: (update_page_cache),

diff --git a/data/evince-ui.xml b/data/evince-ui.xml
index dc11630778bcded20c40b8d62bc967a947433fdf..d6205118180cac45f046110d53e84001cbd2575a 100644 (file)
--- a/data/evince-ui.xml
+++ b/data/evince-ui.xml
@@ -25,6 +25,7 @@
       <menuitem name="ViewSidebarMenu" action="ViewSidebar"/>
       <separator/>
       <menuitem name="ViewFullscreenMenu" action="ViewFullscreen"/>
+      <menuitem name="ViewPresentationMenu" action="ViewPresentation"/>
       <separator/>
       <menuitem name="ViewContinuousMenu" action="ViewContinuous"/>
       <menuitem name="ViewDualMenu" action="ViewDual"/>

diff --git a/shell/ev-pixbuf-cache.c b/shell/ev-pixbuf-cache.c
index 7350c627279267f9fddde73561ef0d3f068fd7df..b5227eef8d8c95be9eff947b3aea789d8f2bfdbd 100644 (file)
--- a/shell/ev-pixbuf-cache.c
+++ b/shell/ev-pixbuf-cache.c
@@ -73,7 +73,7 @@ ev_pixbuf_cache_init (EvPixbufCache *pixbuf_cache)
        pixbuf_cache->end_page = 0;
        pixbuf_cache->job_list = g_new0 (CacheJobInfo, PAGE_CACHE_LEN (pixbuf_cache));
 
-       pixbuf_cache->preload_cache_size = 0;
+       pixbuf_cache->preload_cache_size = 1;
        pixbuf_cache->prev_job = g_new0 (CacheJobInfo, pixbuf_cache->preload_cache_size);
        pixbuf_cache->next_job = g_new0 (CacheJobInfo, pixbuf_cache->preload_cache_size);
 }

diff --git a/shell/ev-view.c b/shell/ev-view.c
index cf00d82ce198bc9689475cd0e579045cd9f847e5..2469dcadf405a0ad0e2d46937c413d5e4b228ad8 100644 (file)
--- a/shell/ev-view.c
+++ b/shell/ev-view.c
@@ -46,7 +46,7 @@ enum {
        PROP_FIND_STATUS,
        PROP_CONTINUOUS,
        PROP_DUAL_PAGE,
-       PROP_FULL_SCREEN,
+       PROP_FULLSCREEN,
        PROP_PRESENTATION,
        PROP_SIZING_MODE,
 };
@@ -121,11 +121,10 @@ struct _EvView {
 
        double scale;
        GtkBorder border;
-       gboolean show_border;
 
        gboolean continuous;
        gboolean dual_page;
-       gboolean full_screen;
+       gboolean fullscreen;
        gboolean presentation;
        EvSizingMode sizing_mode;
 };
@@ -394,13 +393,13 @@ doc_rect_to_view_rect (EvView *view, EvRectangle *doc_rect, GdkRectangle *view_r
 static void
 compute_border (EvView *view, int width, int height, GtkBorder *border)
 {
-       if (view->show_border) {
-               ev_document_misc_get_page_border_size (width, height, border);
-       } else {
+       if (view->presentation) {
                border->left = 0;
                border->right = 0;
                border->top = 0;
                border->bottom = 0;
+       } else {
+               ev_document_misc_get_page_border_size (width, height, border);
        }
 }
 
@@ -642,7 +641,10 @@ ev_view_realize (GtkWidget *widget)
        gdk_window_show (view->bin_window);
 
        widget->style = gtk_style_attach (widget->style, view->bin_window);
-       gdk_window_set_background (view->bin_window, &widget->style->mid[widget->state]);
+       if (view->presentation)
+               gdk_window_set_background (view->bin_window, &widget->style->black);
+       else
+               gdk_window_set_background (view->bin_window, &widget->style->mid [GTK_STATE_NORMAL]);
 
        if (view->document) {
                /* We can't get page size without a target, so we have to
@@ -906,10 +908,9 @@ draw_one_page (EvView       *view,
                                page, view->scale,
                                &width, &height);
 
-       if (view->show_border)
-               ev_document_misc_paint_one_page (view->bin_window,
-                                                GTK_WIDGET (view),
-                                                page_area, border);
+       ev_document_misc_paint_one_page (view->bin_window,
+                                        GTK_WIDGET (view),
+                                        page_area, border);
 
        /* Render the document itself */
        real_page_area = *page_area;
@@ -932,7 +933,6 @@ draw_one_page (EvView       *view,
                scaled_image = gdk_pixbuf_scale_simple (current_pixbuf,
                                                        width, height,
                                                        GDK_INTERP_NEAREST);
-
        if (scaled_image) {
                gdk_draw_pixbuf (view->bin_window,
                                 GTK_WIDGET (view)->style->fg_gc[GTK_STATE_NORMAL],
@@ -1568,8 +1568,8 @@ ev_view_set_property (GObject      *object,
        case PROP_DUAL_PAGE:
                ev_view_set_dual_page (view, g_value_get_boolean (value));
                break;
-       case PROP_FULL_SCREEN:
-               ev_view_set_full_screen (view, g_value_get_boolean (value));
+       case PROP_FULLSCREEN:
+               ev_view_set_fullscreen (view, g_value_get_boolean (value));
                break;
        case PROP_PRESENTATION:
                ev_view_set_presentation (view, g_value_get_boolean (value));
@@ -1604,8 +1604,8 @@ ev_view_get_property (GObject *object,
        case PROP_DUAL_PAGE:
                g_value_set_boolean (value, view->dual_page);
                break;
-       case PROP_FULL_SCREEN:
-               g_value_set_boolean (value, view->full_screen);
+       case PROP_FULLSCREEN:
+               g_value_set_boolean (value, view->fullscreen);
                break;
        case PROP_PRESENTATION:
                g_value_set_boolean (value, view->presentation);
@@ -1696,10 +1696,10 @@ ev_view_class_init (EvViewClass *class)
                                                               FALSE,
                                                               G_PARAM_READWRITE));
        g_object_class_install_property (object_class,
-                                        PROP_FULL_SCREEN,
-                                        g_param_spec_boolean ("full-screen",
+                                        PROP_FULLSCREEN,
+                                        g_param_spec_boolean ("fullscreen",
                                                               "Full Screen",
-                                                              "Draw page in a full-screen fashion",
+                                                              "Draw page in a fullscreen fashion",
                                                               FALSE,
                                                               G_PARAM_READWRITE));
        g_object_class_install_property (object_class,
@@ -1743,12 +1743,11 @@ ev_view_init (EvView *view)
        view->current_page = 0;
        view->pressed_button = -1;
        view->cursor = EV_VIEW_CURSOR_NORMAL;
-       view->show_border = TRUE;
 
        view->continuous = TRUE;
        view->dual_page = FALSE;
        view->presentation = FALSE;
-       view->full_screen = FALSE;
+       view->fullscreen = FALSE;
        view->sizing_mode = EV_SIZING_FIT_WIDTH;
 }
 
@@ -2065,19 +2064,27 @@ ev_view_set_dual_page (EvView   *view,
 }
 
 void
-ev_view_set_full_screen (EvView   *view,
-                        gboolean  full_screen)
+ev_view_set_fullscreen (EvView   *view,
+                        gboolean  fullscreen)
 {
        g_return_if_fail (EV_IS_VIEW (view));
 
-       full_screen = full_screen != FALSE;
+       fullscreen = fullscreen != FALSE;
 
-       if (view->full_screen != full_screen) {
-               view->full_screen = full_screen;
+       if (view->fullscreen != fullscreen) {
+               view->fullscreen = fullscreen;
                gtk_widget_queue_resize (GTK_WIDGET (view));
        }
 
-       g_object_notify (G_OBJECT (view), "full-screen");
+       g_object_notify (G_OBJECT (view), "fullscreen");
+}
+
+gboolean
+ev_view_get_fullscreen (EvView *view)
+{
+       g_return_val_if_fail (EV_IS_VIEW (view), FALSE);
+
+       return view->fullscreen;
 }
 
 void
@@ -2088,24 +2095,44 @@ ev_view_set_presentation (EvView   *view,
 
        presentation = presentation != FALSE;
 
-       if (view->presentation != presentation) {
-               view->presentation = presentation;
-               gtk_widget_queue_resize (GTK_WIDGET (view));
+       if (view->presentation == presentation)
+               return;
+
+       view->presentation = presentation;
+       gtk_widget_queue_resize (GTK_WIDGET (view));
+       if (GTK_WIDGET_REALIZED (view)) {
+               if (view->presentation)
+                       gdk_window_set_background (view->bin_window,
+                                                  &GTK_WIDGET (view)->style->black);
+               else
+                       gdk_window_set_background (view->bin_window,
+                                                  &GTK_WIDGET (view)->style->mid [GTK_STATE_NORMAL]);
        }
 
+
        g_object_notify (G_OBJECT (view), "presentation");
 }
 
+gboolean
+ev_view_get_presentation (EvView *view)
+{
+       g_return_val_if_fail (EV_IS_VIEW (view), FALSE);
+
+       return view->presentation;
+}
+
 void
 ev_view_set_sizing_mode (EvView       *view,
                         EvSizingMode  sizing_mode)
 {
        g_return_if_fail (EV_IS_VIEW (view));
 
-       if (view->sizing_mode != sizing_mode) {
-               view->sizing_mode = sizing_mode;
-               gtk_widget_queue_resize (GTK_WIDGET (view));
-       }
+       if (view->sizing_mode == sizing_mode)
+               return;
+
+       view->sizing_mode = sizing_mode;
+       gtk_widget_queue_resize (GTK_WIDGET (view));
+       
        g_object_notify (G_OBJECT (view), "sizing-mode");
 }
 
@@ -2179,6 +2206,24 @@ zoom_for_size_best_fit (int doc_width,
        return MIN (w_scale, h_scale);
 }
 
+
+static void
+ev_view_zoom_for_size_presentation (EvView *view,
+                                   int     width,
+                                   int     height)
+{
+       int doc_width, doc_height;
+       gdouble scale;
+
+       ev_page_cache_get_size (view->page_cache,
+                               view->current_page,
+                               1.0,
+                               &doc_width,
+                               &doc_height);
+       scale = zoom_for_size_best_fit (doc_width, doc_height, width, height, 0, 0);
+       ev_view_zoom (view, scale, FALSE);
+}
+
 static void
 ev_view_zoom_for_size_continuous_and_dual_page (EvView *view,
                           int     width,
@@ -2351,7 +2396,9 @@ ev_view_set_zoom_for_size (EvView *view,
        if (view->document == NULL)
                return;
 
-       if (view->continuous && view->dual_page)
+       if (view->presentation)
+               ev_view_zoom_for_size_presentation (view, width, height);
+       else if (view->continuous && view->dual_page)
                ev_view_zoom_for_size_continuous_and_dual_page (view, width, height, vsb_width, hsb_height);
        else if (view->continuous)
                ev_view_zoom_for_size_continuous (view, width, height, vsb_width, hsb_height);

diff --git a/shell/ev-view.h b/shell/ev-view.h
index b87d345ebbd477643e1b91e82150b46f68fff02e..a96397f0769d04a7af47681b619589f4e5e5f337 100644 (file)
--- a/shell/ev-view.h
+++ b/shell/ev-view.h
@@ -54,18 +54,22 @@ void                ev_view_select_all      (EvView     *view);
 
 
 /* sizing and behavior */
-/* These are all orthoganal to each other, with the exception of 'presentation'
+/* These are all orthoganal to each other, except 'presentation' trumps all
+ * other behaviors
  */
-void ev_view_set_continuous   (EvView       *view,
-                              gboolean      continuous);
-void ev_view_set_dual_page    (EvView       *view,
-                              gboolean      dual_page);
-void ev_view_set_full_screen  (EvView       *view,
-                              gboolean      full_screen);
-void ev_view_set_presentation (EvView       *view,
-                              gboolean      presentation);
-void ev_view_set_sizing_mode  (EvView       *view,
-                              EvSizingMode  mode);
+void     ev_view_set_continuous   (EvView       *view,
+                                  gboolean      continuous);
+void     ev_view_set_dual_page    (EvView       *view,
+                                  gboolean      dual_page);
+void     ev_view_set_fullscreen   (EvView       *view,
+                                  gboolean      fullscreen);
+gboolean ev_view_get_fullscreen   (EvView       *view);
+void     ev_view_set_presentation (EvView       *view,
+                                  gboolean      presentation);
+gboolean ev_view_get_presentation (EvView       *view);
+void     ev_view_set_sizing_mode  (EvView       *view,
+                                  EvSizingMode  mode);
+
 
 
 /* Page size */

diff --git a/shell/ev-window.c b/shell/ev-window.c
index 471a45dbf7ed6c68f38c80011c306ef043d7ee83..475cb5ddc1e4a44016068dd27c5eef569d17c8b1 100644 (file)
--- a/shell/ev-window.c
+++ b/shell/ev-window.c
@@ -110,7 +110,6 @@ struct _EvWindowPrivate {
        char *password_uri;
 
        EvChrome chrome;
-       gboolean fullscreen_mode;
        GSource *fullscreen_timeout_source;
 
        /* recent file stuff */
@@ -136,18 +135,29 @@ static const GtkTargetEntry ev_drop_types[] = {
 
 #define SIDEBAR_DEFAULT_SIZE    132
 
-static void     ev_window_update_fullscreen_popup (EvWindow         *window);
-static void     ev_window_sidebar_visibility_changed_cb (EvSidebar *ev_sidebar, GParamSpec *pspec,
-                                                        EvWindow   *ev_window);
-static void     ev_window_set_page_mode           (EvWindow         *window,
-                                                  EvWindowPageMode  page_mode);
-static gboolean start_loading_document            (EvWindow         *ev_window,
-                                                  EvDocument       *document,
-                                                  const char       *uri);
-static void     ev_window_sizing_mode_changed_cb (EvView *view, GParamSpec *pspec,
-                                                 EvWindow   *ev_window);
-static void    ev_window_add_recent (EvWindow *window, const char *filename);
-static void    ev_window_fullscreen (EvWindow *window);
+static void     ev_window_update_fullscreen_popup       (EvWindow         *window);
+static void     ev_window_sidebar_visibility_changed_cb (EvSidebar        *ev_sidebar,
+                                                        GParamSpec       *pspec,
+                                                        EvWindow         *ev_window);
+static void     ev_window_set_page_mode                 (EvWindow         *window,
+                                                        EvWindowPageMode  page_mode);
+static gboolean start_loading_document                  (EvWindow         *ev_window,
+                                                        EvDocument       *document,
+                                                        const char       *uri);
+static void     ev_window_sizing_mode_changed_cb        (EvView           *view,
+                                                        GParamSpec       *pspec,
+                                                        EvWindow         *ev_window);
+static void     ev_window_add_recent                    (EvWindow         *window,
+                                                        const char       *filename);
+static void     ev_window_fullscreen                    (EvWindow         *window);
+static void     ev_window_unfullscreen                  (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_cmd_view_presentation         (GtkAction        *action,
+                                                        EvWindow         *window);
+
 
 G_DEFINE_TYPE (EvWindow, ev_window, GTK_TYPE_WINDOW)
 
@@ -253,12 +263,17 @@ update_chrome_visibility (EvWindow *window)
 {
        EvWindowPrivate *priv = window->priv;
        gboolean menubar, toolbar, sidebar, findbar, statusbar, fullscreen_toolbar;
+       gboolean fullscreen_mode, presentation, fullscreen;
+
+       presentation = ev_view_get_presentation (EV_VIEW (priv->view));
+       fullscreen = ev_view_get_fullscreen (EV_VIEW (priv->view));
+       fullscreen_mode = fullscreen || presentation;
 
-       menubar = (priv->chrome & EV_CHROME_MENUBAR) != 0 && !priv->fullscreen_mode;
-       toolbar = (priv->chrome & EV_CHROME_TOOLBAR) != 0 && !priv->fullscreen_mode;
-       sidebar = (priv->chrome & EV_CHROME_SIDEBAR) != 0 && !priv->fullscreen_mode;
+       menubar = (priv->chrome & EV_CHROME_MENUBAR) != 0 && !fullscreen_mode;
+       toolbar = (priv->chrome & EV_CHROME_TOOLBAR) != 0 && !fullscreen_mode;
+       sidebar = (priv->chrome & EV_CHROME_SIDEBAR) != 0 && !fullscreen_mode;
        fullscreen_toolbar = (priv->chrome & EV_CHROME_TOOLBAR) != 0;
-       statusbar = (priv->chrome & EV_CHROME_STATUSBAR) != 0 && !priv->fullscreen_mode;
+       statusbar = (priv->chrome & EV_CHROME_STATUSBAR) != 0 && !fullscreen_mode;
        findbar = (priv->chrome & EV_CHROME_FINDBAR) != 0;
 
        set_widget_visibility (priv->menubar, menubar);
@@ -269,7 +284,7 @@ update_chrome_visibility (EvWindow *window)
        set_widget_visibility (priv->fullscreen_toolbar, fullscreen_toolbar);
 
        if (priv->fullscreen_popup != NULL) {
-               set_widget_visibility (priv->fullscreen_popup, priv->fullscreen_mode);
+               set_widget_visibility (priv->fullscreen_popup, fullscreen);
        }
 }
 
@@ -300,6 +315,7 @@ ev_window_cmd_continuous (GtkAction *action, EvWindow *ev_window)
 {
        gboolean continuous;
 
+       ev_window_stop_presentation (ev_window);
        continuous = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
        g_object_set (G_OBJECT (ev_window->priv->view),
                      "continuous", continuous,
@@ -312,6 +328,7 @@ ev_window_cmd_dual (GtkAction *action, EvWindow *ev_window)
 {
        gboolean dual_page;
 
+       ev_window_stop_presentation (ev_window);
        dual_page = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
        g_object_set (G_OBJECT (ev_window->priv->view),
                      "dual-page", dual_page,
@@ -322,6 +339,8 @@ ev_window_cmd_dual (GtkAction *action, EvWindow *ev_window)
 static void
 ev_window_cmd_view_best_fit (GtkAction *action, EvWindow *ev_window)
 {
+       ev_window_stop_presentation (ev_window);
+
        if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action))) {
                ev_view_set_sizing_mode (EV_VIEW (ev_window->priv->view), EV_SIZING_BEST_FIT);
        } else {
@@ -333,6 +352,8 @@ ev_window_cmd_view_best_fit (GtkAction *action, EvWindow *ev_window)
 static void
 ev_window_cmd_view_page_width (GtkAction *action, EvWindow *ev_window)
 {
+       ev_window_stop_presentation (ev_window);
+
        if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action))) {
                ev_view_set_sizing_mode (EV_VIEW (ev_window->priv->view), EV_SIZING_FIT_WIDTH);
        } else {
@@ -497,7 +518,9 @@ static void
 update_document_mode (EvWindow *window, EvDocumentMode mode)
 {
        if (mode == EV_DOCUMENT_MODE_FULL_SCREEN) {
-               gtk_window_fullscreen (GTK_WINDOW (window));
+               ev_window_fullscreen (window);
+       } else if (mode == EV_DOCUMENT_MODE_PRESENTATION) {
+               ev_window_run_presentation (window);
        }
 }
 
@@ -1326,11 +1349,25 @@ ev_window_create_fullscreen_popup (EvWindow *window)
        return popup;
 }
 
+
 static void
-ev_window_fullscreen (EvWindow *window)
+ev_window_update_fullscreen_action (EvWindow *window)
 {
-       window->priv->fullscreen_mode = TRUE;
+       GtkAction *action;
 
+       action = gtk_action_group_get_action (window->priv->action_group, "ViewFullscreen");
+       g_signal_handlers_block_by_func
+               (action, G_CALLBACK (ev_window_cmd_view_fullscreen), window);
+       gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
+                                     ev_view_get_fullscreen (EV_VIEW (window->priv->view)));
+       g_signal_handlers_unblock_by_func
+               (action, G_CALLBACK (ev_window_cmd_view_fullscreen), window);
+}
+
+static void
+ev_window_fullscreen (EvWindow *window)
+{
+       ev_view_set_fullscreen (EV_VIEW (window->priv->view), TRUE);
        if (window->priv->fullscreen_popup == NULL)
                window->priv->fullscreen_popup
                        = ev_window_create_fullscreen_popup (window);
@@ -1351,7 +1388,8 @@ ev_window_fullscreen (EvWindow *window)
        fullscreen_set_timeout (window);
 
        gtk_widget_grab_focus (window->priv->view);
-
+       ev_window_update_fullscreen_action (window);
+       gtk_window_fullscreen (GTK_WINDOW (window));
        ev_window_update_fullscreen_popup (window);
 }
 
@@ -1360,8 +1398,7 @@ ev_window_unfullscreen (EvWindow *window)
 {
        EvView *view = EV_VIEW (window->priv->view);
 
-       window->priv->fullscreen_mode = FALSE;
-
+       ev_view_set_fullscreen (view, FALSE);
        g_object_set (G_OBJECT (window->priv->scrolled_window),
                      "shadow-type", GTK_SHADOW_IN,
                      NULL);
@@ -1371,33 +1408,86 @@ ev_window_unfullscreen (EvWindow *window)
        g_signal_handlers_disconnect_by_func (view,
                                              (gpointer) fullscreen_motion_notify_cb,
                                              window);
-
-       g_object_set (G_OBJECT (view),
-                     "full-screen", FALSE,
-                     NULL);
+       g_signal_handlers_disconnect_by_func (view,
+                                             (gpointer) fullscreen_leave_notify_cb,
+                                             window);
+       ev_window_update_fullscreen_action (window);
+       gtk_window_unfullscreen (GTK_WINDOW (window));
        update_chrome_visibility (window);
 }
 
 static void
 ev_window_cmd_view_fullscreen (GtkAction *action, EvWindow *window)
 {
-       EvView *view;
        gboolean fullscreen;
 
         g_return_if_fail (EV_IS_WINDOW (window));
+       ev_window_stop_presentation (window);
 
-       view = EV_VIEW (window->priv->view);
        fullscreen = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
-
        if (fullscreen) {
-               gtk_window_fullscreen (GTK_WINDOW (window));
+               ev_window_fullscreen (window);
        } else {
-               gtk_window_unfullscreen (GTK_WINDOW (window));
+               ev_window_unfullscreen (window);
        }
+}
+
+static void
+ev_window_update_presentation_action (EvWindow *window)
+{
+       GtkAction *action;
+
+       action = gtk_action_group_get_action (window->priv->action_group, "ViewPresentation");
+       g_signal_handlers_block_by_func
+               (action, G_CALLBACK (ev_window_cmd_view_presentation), window);
+       gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
+                                     ev_view_get_presentation (EV_VIEW (window->priv->view)));
+       g_signal_handlers_unblock_by_func
+               (action, G_CALLBACK (ev_window_cmd_view_presentation), window);
+}
 
-       g_object_set (G_OBJECT (view),
-                     "full-screen", TRUE,
+static void
+ev_window_run_presentation (EvWindow *window)
+{
+       g_object_set (G_OBJECT (window->priv->scrolled_window),
+                     "shadow-type", GTK_SHADOW_NONE,
                      NULL);
+
+       gtk_widget_grab_focus (window->priv->view);
+       ev_view_set_presentation (EV_VIEW (window->priv->view), TRUE);
+       gtk_window_fullscreen (GTK_WINDOW (window));
+       ev_window_update_presentation_action (window);
+       update_chrome_visibility (window);
+}
+
+static void
+ev_window_stop_presentation (EvWindow *window)
+{
+       if (! ev_view_get_presentation (EV_VIEW (window->priv->view)))
+               return;
+
+       g_object_set (G_OBJECT (window->priv->scrolled_window),
+                     "shadow-type", GTK_SHADOW_IN,
+                     NULL);
+       ev_view_set_presentation (EV_VIEW (window->priv->view), FALSE);
+       gtk_window_unfullscreen (GTK_WINDOW (window));
+       ev_window_update_presentation_action (window);
+       update_chrome_visibility (window);
+}
+
+static void
+ev_window_cmd_view_presentation (GtkAction *action, EvWindow *window)
+{
+       gboolean presentation;
+
+        g_return_if_fail (EV_IS_WINDOW (window));
+
+       presentation = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+       if (presentation) {
+               ev_window_run_presentation (window);
+       } else {
+               ev_window_stop_presentation (window);
+       }
 }
 
 static gboolean
@@ -1414,29 +1504,6 @@ ev_window_state_event (GtkWidget *widget, GdkEventWindowState *event)
                                                   show);
        }
 
-       if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) {
-               GtkActionGroup *action_group;
-               GtkAction *action;
-               gboolean fullscreen;
-
-               fullscreen = event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN;
-
-               if (fullscreen) {
-                       ev_window_fullscreen (window);
-               } else {
-                       ev_window_unfullscreen (window);
-               }
-
-               action_group = window->priv->action_group;
-
-               action = gtk_action_group_get_action (action_group, "ViewFullscreen");
-               g_signal_handlers_block_by_func
-                       (action, G_CALLBACK (ev_window_cmd_view_fullscreen), window);
-               gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), fullscreen);
-               g_signal_handlers_unblock_by_func
-                       (action, G_CALLBACK (ev_window_cmd_view_fullscreen), window);
-       }
-
        return FALSE;
 }
 
@@ -1445,11 +1512,14 @@ ev_window_focus_in_event (GtkWidget *widget, GdkEventFocus *event)
 {
        EvWindow *window = EV_WINDOW (widget);
        EvWindowPrivate *priv = window->priv;
+       gboolean fullscreen;
 
-       if (priv->fullscreen_mode)
-       {
+       g_object_get (priv->view,
+                     "fullscreen", &fullscreen,
+                     NULL);
+
+       if (fullscreen)
                gtk_widget_show (priv->fullscreen_popup);
-       }
 
        return GTK_WIDGET_CLASS (ev_window_parent_class)->focus_in_event (widget, event);
 }
@@ -1459,11 +1529,14 @@ ev_window_focus_out_event (GtkWidget *widget, GdkEventFocus *event)
 {
        EvWindow *window = EV_WINDOW (widget);
        EvWindowPrivate *priv = window->priv;
+       gboolean fullscreen;
 
-       if (priv->fullscreen_mode)
-       {
+       g_object_get (priv->view,
+                     "fullscreen", &fullscreen,
+                     NULL);
+
+       if (fullscreen)
                gtk_widget_hide (priv->fullscreen_popup);
-       }
 
        return GTK_WIDGET_CLASS (ev_window_parent_class)->focus_out_event (widget, event);
 }
@@ -1615,7 +1688,21 @@ ev_window_cmd_escape (GtkAction *action, EvWindow *window)
        if (widget && gtk_widget_get_ancestor (widget, EGG_TYPE_FIND_BAR)) {
                update_chrome_flag (window, EV_CHROME_FINDBAR, NULL, FALSE);
        } else {
-               gtk_window_unfullscreen (GTK_WINDOW (window));
+               gboolean fullscreen;
+               gboolean presentation;
+
+               g_object_get (window->priv->view,
+                             "fullscreen", &fullscreen,
+                             "presentation", &presentation,
+                             NULL);
+
+               if (fullscreen)
+                       ev_window_unfullscreen (window);
+               if (presentation)
+                       ev_window_stop_presentation (window);
+
+               if (fullscreen && presentation)
+                       g_warning ("Both fullscreen and presentation set somehow");
        }
 }
 
@@ -1795,14 +1882,17 @@ ev_window_sidebar_visibility_changed_cb (EvSidebar *ev_sidebar, GParamSpec *pspe
                                         EvWindow   *ev_window)
 {
        GtkAction *action;
-       gboolean visible;
+       gboolean visible, fullscreen;
 
+       g_object_get (ev_window->priv->view,
+                     "fullscreen", &fullscreen,
+                     NULL);
        visible = GTK_WIDGET_VISIBLE (ev_sidebar);
 
        /* In fullscreen mode the sidebar is not visible,
         * but we don't want to update the chrome
         */
-       if (ev_window->priv->fullscreen_mode)
+       if (fullscreen)
                return;
        
        action = gtk_action_group_get_action (ev_window->priv->action_group, "ViewSidebar");
@@ -2154,6 +2244,9 @@ static const GtkToggleActionEntry toggle_entries[] = {
         { "ViewFullscreen", NULL, N_("_Fullscreen"), "F11",
           N_("Expand the window to fill the screen"),
           G_CALLBACK (ev_window_cmd_view_fullscreen) },
+        { "ViewPresentation", NULL, N_("_Presentation"), "F12",
+          N_("Run document as a presentation"),
+          G_CALLBACK (ev_window_cmd_view_presentation) },
         { "ViewBestFit", EV_STOCK_ZOOM_PAGE, N_("_Best Fit"), NULL,
           N_("Make the current document fill the window"),
           G_CALLBACK (ev_window_cmd_view_best_fit) },