]> www.fi.muni.cz Git - evince.git/blobdiff - shell/ev-view.c
Updated Lithuanian translation.
[evince.git] / shell / ev-view.c
index 3da8d138fed932334dc6f52eb2786c79c60a0d92..47c4eaec8d5f623de694877daa3a628866652ea5 100644 (file)
@@ -19,6 +19,7 @@
  */
 
 #include <math.h>
  */
 
 #include <math.h>
+#include <string.h>
 #include <gtk/gtkalignment.h>
 #include <glib/gi18n.h>
 #include <gtk/gtkbindings.h>
 #include <gtk/gtkalignment.h>
 #include <glib/gi18n.h>
 #include <gtk/gtkbindings.h>
 
 #include "ev-marshal.h"
 #include "ev-view.h"
 
 #include "ev-marshal.h"
 #include "ev-view.h"
+#include "ev-view-private.h"
+#include "ev-utils.h"
+#include "ev-selection.h"
 #include "ev-document-find.h"
 #include "ev-document-misc.h"
 #include "ev-debug.h"
 #include "ev-job-queue.h"
 #include "ev-page-cache.h"
 #include "ev-pixbuf-cache.h"
 #include "ev-document-find.h"
 #include "ev-document-misc.h"
 #include "ev-debug.h"
 #include "ev-job-queue.h"
 #include "ev-page-cache.h"
 #include "ev-pixbuf-cache.h"
+#include "ev-tooltip.h"
 
 #define EV_VIEW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), EV_TYPE_VIEW, EvViewClass))
 #define EV_IS_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EV_TYPE_VIEW))
 #define EV_VIEW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), EV_TYPE_VIEW, EvViewClass))
 
 
 #define EV_VIEW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), EV_TYPE_VIEW, EvViewClass))
 #define EV_IS_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EV_TYPE_VIEW))
 #define EV_VIEW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), EV_TYPE_VIEW, EvViewClass))
 
+
 enum {
        PROP_0,
        PROP_STATUS,
 enum {
        PROP_0,
        PROP_STATUS,
@@ -49,11 +55,16 @@ enum {
        PROP_FULLSCREEN,
        PROP_PRESENTATION,
        PROP_SIZING_MODE,
        PROP_FULLSCREEN,
        PROP_PRESENTATION,
        PROP_SIZING_MODE,
+       PROP_ZOOM,
+       PROP_ROTATION,
+       PROP_HAS_SELECTION,
 };
 
 enum {
 };
 
 enum {
-       SIGNAL_SCROLL_VIEW,
+       SIGNAL_BINDING_ACTIVATED,
        SIGNAL_ZOOM_INVALID,
        SIGNAL_ZOOM_INVALID,
+       SIGNAL_EXTERNAL_LINK,
+       SIGNAL_POPUP_MENU,
        N_SIGNALS,
 };
 
        N_SIGNALS,
 };
 
@@ -75,102 +86,25 @@ static const GtkTargetEntry targets[] = {
 static guint signals[N_SIGNALS];
 
 typedef enum {
 static guint signals[N_SIGNALS];
 
 typedef enum {
-       EV_VIEW_CURSOR_NORMAL,
-       EV_VIEW_CURSOR_LINK,
-       EV_VIEW_CURSOR_WAIT,
-       EV_VIEW_CURSOR_HIDDEN,
-       EV_VIEW_CURSOR_DRAG
-} EvViewCursor;
+       EV_VIEW_FIND_NEXT,
+       EV_VIEW_FIND_PREV
+} EvViewFindDirection;
 
 #define ZOOM_IN_FACTOR  1.2
 #define ZOOM_OUT_FACTOR (1.0/ZOOM_IN_FACTOR)
 
 #define MIN_SCALE 0.05409
 
 #define ZOOM_IN_FACTOR  1.2
 #define ZOOM_OUT_FACTOR (1.0/ZOOM_IN_FACTOR)
 
 #define MIN_SCALE 0.05409
-#define MAX_SCALE 6.0
-
-typedef struct {
-       EvRectangle rect;
-       int page;
-} EvViewSelection;
-
-typedef struct {
-        gboolean dragging;
-       GdkPoint start;
-       gdouble hadj;
-       gdouble vadj;
-} DragInfo;
-
-typedef enum {
-       SCROLL_TO_KEEP_POSITION,
-       SCROLL_TO_CURRENT_PAGE,
-       SCROLL_TO_CENTER
-} PendingScroll;
-
-struct _EvView {
-       GtkWidget parent_instance;
-
-       EvDocument *document;
-
-       char *status;
-       char *find_status;
-
-       int scroll_x;
-       int scroll_y;
-
-       DragInfo drag_info;
-       gboolean pressed_button;
-       GdkPoint selection_start;
-       GList *selections;
-       EvViewCursor cursor;
-
-       GtkAdjustment *hadjustment;
-       GtkAdjustment *vadjustment;
-
-       EvPageCache *page_cache;
-       EvPixbufCache *pixbuf_cache;
-
-       gint start_page;
-       gint end_page;
-       gint current_page;
-
-       EvJobRender *current_job;
-
-       int find_page;
-       int find_result;
-       int spacing;
-
-       double scale;
-       GtkBorder border;
-
-       gboolean continuous;
-       gboolean dual_page;
-       gboolean fullscreen;
-       gboolean presentation;
-       EvSizingMode sizing_mode;
-       
-       PendingScroll pending_scroll;
-};
-
-struct _EvViewClass {
-       GtkWidgetClass parent_class;
+#define MAX_SCALE 4.0
 
 
-       void    (*set_scroll_adjustments) (EvView         *view,
-                                          GtkAdjustment  *hadjustment,
-                                          GtkAdjustment  *vadjustment);
-       void    (*scroll_view)            (EvView         *view,
-                                          GtkScrollType   scroll,
-                                          gboolean        horizontal);
-       void    (*zoom_invalid)           (EvView         *view);
-};
+#define SCROLL_TIME 150
 
 /*** Scrolling ***/
 
 /*** Scrolling ***/
-static void       view_update_adjustments                    (EvView             *view);
+static void       scroll_to_current_page                    (EvView *view,
+                                                             GtkOrientation orientation);
 static void       ev_view_set_scroll_adjustments             (EvView             *view,
                                                              GtkAdjustment      *hadjustment,
                                                              GtkAdjustment      *vadjustment);
 static void       view_update_range_and_current_page         (EvView             *view);
 static void       ev_view_set_scroll_adjustments             (EvView             *view,
                                                              GtkAdjustment      *hadjustment,
                                                              GtkAdjustment      *vadjustment);
 static void       view_update_range_and_current_page         (EvView             *view);
-static void       view_scroll_to_page                        (EvView             *view,
-                                                             gint                new_page);
 static void       set_scroll_adjustment                      (EvView             *view,
                                                              GtkOrientation      orientation,
                                                              GtkAdjustment      *adjustment);
 static void       set_scroll_adjustment                      (EvView             *view,
                                                              GtkOrientation      orientation,
                                                              GtkAdjustment      *adjustment);
@@ -179,9 +113,10 @@ static void       ev_view_set_scroll_adjustments             (EvView
                                                              GtkAdjustment      *vadjustment);
 static void       add_scroll_binding_keypad                  (GtkBindingSet      *binding_set,
                                                              guint               keyval,
                                                              GtkAdjustment      *vadjustment);
 static void       add_scroll_binding_keypad                  (GtkBindingSet      *binding_set,
                                                              guint               keyval,
+                                                             GdkModifierType modifiers,
                                                              GtkScrollType       scroll,
                                                              gboolean            horizontal);
                                                              GtkScrollType       scroll,
                                                              gboolean            horizontal);
-static void       ev_view_scroll_view                        (EvView             *view,
+static void       ev_view_binding_activated                  (EvView             *view,
                                                              GtkScrollType       scroll,
                                                              gboolean            horizontal);
 static void       ensure_rectangle_is_visible                (EvView             *view,
                                                              GtkScrollType       scroll,
                                                              gboolean            horizontal);
 static void       ensure_rectangle_is_visible                (EvView             *view,
@@ -192,6 +127,10 @@ static void       compute_border                             (EvView
                                                              int                 width,
                                                              int                 height,
                                                              GtkBorder          *border);
                                                              int                 width,
                                                              int                 height,
                                                              GtkBorder          *border);
+static void       get_page_y_offset                          (EvView *view,
+                                                             int page,
+                                                             double zoom,
+                                                             int *y_offset);
 static gboolean   get_page_extents                           (EvView             *view,
                                                              gint                page,
                                                              GdkRectangle       *page_area,
 static gboolean   get_page_extents                           (EvView             *view,
                                                              gint                page,
                                                              GdkRectangle       *page_area,
@@ -204,25 +143,25 @@ static void       doc_rect_to_view_rect                      (EvView
                                                              int                 page,
                                                              EvRectangle        *doc_rect,
                                                              GdkRectangle       *view_rect);
                                                              int                 page,
                                                              EvRectangle        *doc_rect,
                                                              GdkRectangle       *view_rect);
-static void       get_bounding_box_size                      (EvView             *view,
-                                                             int                *max_width,
-                                                             int                *max_height);
 static void       find_page_at_location                      (EvView             *view,
                                                              gdouble             x,
                                                              gdouble             y,
                                                              gint               *page,
                                                              gint               *x_offset,
                                                              gint               *y_offset);
 static void       find_page_at_location                      (EvView             *view,
                                                              gdouble             x,
                                                              gdouble             y,
                                                              gint               *page,
                                                              gint               *x_offset,
                                                              gint               *y_offset);
-
+static gboolean  doc_point_to_view_point                    (EvView       *view,
+                                                             int           page,
+                                                             EvPoint      *doc_point,
+                                                             GdkPoint     *view_point);
 /*** Hyperrefs ***/
 /*** Hyperrefs ***/
-static EvLink*    get_link_at_location                       (EvView             *view,
-                                                             gdouble             x,
-                                                             gdouble             y);
-static void       go_to_link                                 (EvView             *view,
-                                                             EvLink             *link);
-static char*      status_message_from_link                   (EvView             *view,
+static EvLink *   ev_view_get_link_at_location                      (EvView  *view,
+                                                             gdouble  x,
+                                                             gdouble  y);
+static char*      tip_from_link                              (EvView             *view,
                                                              EvLink             *link);
                                                              EvLink             *link);
-
+static void       handle_link_over_xy                        (EvView *view, 
+                                                             gint x, 
+                                                             gint y);
 /*** GtkWidget implementation ***/
 static void       ev_view_size_request_continuous_dual_page  (EvView             *view,
                                                              GtkRequisition     *requisition);
 /*** GtkWidget implementation ***/
 static void       ev_view_size_request_continuous_dual_page  (EvView             *view,
                                                              GtkRequisition     *requisition);
@@ -237,17 +176,25 @@ static void       ev_view_size_request                       (GtkWidget
 static void       ev_view_size_allocate                      (GtkWidget          *widget,
                                                              GtkAllocation      *allocation);
 static void       ev_view_realize                            (GtkWidget          *widget);
 static void       ev_view_size_allocate                      (GtkWidget          *widget,
                                                              GtkAllocation      *allocation);
 static void       ev_view_realize                            (GtkWidget          *widget);
-static void       ev_view_unrealize                          (GtkWidget          *widget);
 static gboolean   ev_view_scroll_event                       (GtkWidget          *widget,
                                                              GdkEventScroll     *event);
 static gboolean   ev_view_expose_event                       (GtkWidget          *widget,
                                                              GdkEventExpose     *event);
 static gboolean   ev_view_scroll_event                       (GtkWidget          *widget,
                                                              GdkEventScroll     *event);
 static gboolean   ev_view_expose_event                       (GtkWidget          *widget,
                                                              GdkEventExpose     *event);
+static gboolean   ev_view_popup_menu                         (GtkWidget         *widget);
 static gboolean   ev_view_button_press_event                 (GtkWidget          *widget,
                                                              GdkEventButton     *event);
 static gboolean   ev_view_motion_notify_event                (GtkWidget          *widget,
                                                              GdkEventMotion     *event);
 static gboolean   ev_view_button_release_event               (GtkWidget          *widget,
                                                              GdkEventButton     *event);
 static gboolean   ev_view_button_press_event                 (GtkWidget          *widget,
                                                              GdkEventButton     *event);
 static gboolean   ev_view_motion_notify_event                (GtkWidget          *widget,
                                                              GdkEventMotion     *event);
 static gboolean   ev_view_button_release_event               (GtkWidget          *widget,
                                                              GdkEventButton     *event);
+static gboolean   ev_view_enter_notify_event                 (GtkWidget          *widget,
+                                                             GdkEventCrossing   *event);
+static gboolean   ev_view_leave_notify_event                 (GtkWidget          *widget,
+                                                             GdkEventCrossing   *event);
+static void       ev_view_style_set                          (GtkWidget          *widget,
+                                                             GtkStyle           *old_style);
+
+static AtkObject *ev_view_get_accessible                     (GtkWidget *widget);
 
 /*** Drawing ***/
 static guint32    ev_gdk_color_to_rgb                        (const GdkColor     *color);
 
 /*** Drawing ***/
 static guint32    ev_gdk_color_to_rgb                        (const GdkColor     *color);
@@ -262,6 +209,9 @@ static void       draw_one_page                              (EvView
                                                              GdkRectangle       *page_area,
                                                              GtkBorder          *border,
                                                              GdkRectangle       *expose_area);
                                                              GdkRectangle       *page_area,
                                                              GtkBorder          *border,
                                                              GdkRectangle       *expose_area);
+static void      draw_loading_text                          (EvView             *view,
+                                                             GdkRectangle       *page_area,
+                                                             GdkRectangle       *expose_area);
 
 /*** Callbacks ***/
 static void       find_changed_cb                            (EvDocument         *document,
 
 /*** Callbacks ***/
 static void       find_changed_cb                            (EvDocument         *document,
@@ -295,6 +245,11 @@ static double   zoom_for_size_fit_width                         (int doc_width,
                                                              int target_width,
                                                              int target_height,
                                                              int vsb_width);
                                                              int target_width,
                                                              int target_height,
                                                              int vsb_width);
+static double   zoom_for_size_fit_height                    (int doc_width,
+                                                             int doc_height,
+                                                             int target_width,
+                                                             int target_height,
+                                                             int vsb_height);
 static double  zoom_for_size_best_fit                       (int doc_width,
                                                              int doc_height,
                                                              int target_width,
 static double  zoom_for_size_best_fit                       (int doc_width,
                                                              int doc_height,
                                                              int target_width,
@@ -337,12 +292,15 @@ static void       ev_view_set_find_status                    (EvView
                                                              const char         *message);
 /*** Find ***/
 static void       jump_to_find_result                        (EvView             *view);
                                                              const char         *message);
 /*** Find ***/
 static void       jump_to_find_result                        (EvView             *view);
-static void       jump_to_find_page                          (EvView             *view);
+static void       jump_to_find_page                          (EvView             *view, 
+                                                             EvViewFindDirection direction);
 
 /*** Selection ***/
 static void       compute_selections                         (EvView             *view,
 
 /*** Selection ***/
 static void       compute_selections                         (EvView             *view,
-                                                             GdkRectangle       *view_rect);
+                                                             GdkPoint           *start,
+                                                             GdkPoint           *stop);
 static void       clear_selection                            (EvView             *view);
 static void       clear_selection                            (EvView             *view);
+static void       selection_free                             (EvViewSelection    *selection);
 static char*      get_selected_text                          (EvView             *ev_view);
 static void       ev_view_primary_get_cb                     (GtkClipboard       *clipboard,
                                                              GtkSelectionData   *selection_data,
 static char*      get_selected_text                          (EvView             *ev_view);
 static void       ev_view_primary_get_cb                     (GtkClipboard       *clipboard,
                                                              GtkSelectionData   *selection_data,
@@ -352,37 +310,51 @@ static void       ev_view_primary_clear_cb                   (GtkClipboard
                                                              gpointer            data);
 static void       ev_view_update_primary_selection           (EvView             *ev_view);
 
                                                              gpointer            data);
 static void       ev_view_update_primary_selection           (EvView             *ev_view);
 
-                                               
+
 G_DEFINE_TYPE (EvView, ev_view, GTK_TYPE_WIDGET)
 
 static void
 G_DEFINE_TYPE (EvView, ev_view, GTK_TYPE_WIDGET)
 
 static void
-view_update_adjustments (EvView *view)
+scroll_to_current_page (EvView *view, GtkOrientation orientation)
 {
 {
-       int dx = 0, dy = 0;
+       GdkPoint view_point;
 
 
-       if (! GTK_WIDGET_REALIZED (view))
+       if (view->document == NULL) {
                return;
                return;
+       }
 
 
-       if (view->hadjustment) {
-               dx = view->scroll_x - view->hadjustment->value;
-               view->scroll_x = view->hadjustment->value;
+        doc_point_to_view_point (view, view->current_page, &view->pending_point, &view_point);
+
+       if (orientation == GTK_ORIENTATION_VERTICAL) {
+               view->pending_point.y = 0;
        } else {
        } else {
-               view->scroll_x = 0;
+               view->pending_point.x = 0;
        }
 
        }
 
-       if (view->vadjustment) {
-               dy = view->scroll_y - view->vadjustment->value;
-               view->scroll_y = view->vadjustment->value;
+       if (orientation == GTK_ORIENTATION_VERTICAL) {
+               if (view->continuous) {
+                       gtk_adjustment_clamp_page (view->vadjustment,
+                                                  view_point.y - view->spacing / 2,
+                                                  view_point.y + view->vadjustment->page_size);
+               } else {
+                       gtk_adjustment_set_value (view->vadjustment,
+                                                 CLAMP (view_point.y,
+                                                 view->vadjustment->lower,
+                                                 view->vadjustment->upper -
+                                                 view->vadjustment->page_size));
+               }
        } else {
        } else {
-               view->scroll_y = 0;
+               if (view->dual_page) {
+                       gtk_adjustment_clamp_page (view->hadjustment,
+                                                  view_point.x,
+                                                  view_point.x + view->hadjustment->page_size);
+               } else {
+                       gtk_adjustment_set_value (view->hadjustment,
+                                                 CLAMP (view_point.x,
+                                                 view->hadjustment->lower,
+                                                 view->hadjustment->upper -
+                                                 view->hadjustment->page_size));
+               }
        }
        }
-               
-       //      gtk_widget_queue_draw (GTK_WIDGET (view));
-       gdk_window_scroll (GTK_WIDGET (view)->window, dx, dy);
-
-
-       if (view->document)
-               view_update_range_and_current_page (view);
 }
 
 static void
 }
 
 static void
@@ -409,15 +381,15 @@ view_set_adjustment_values (EvView         *view,
 
        if (!adjustment)
                return;
 
        if (!adjustment)
                return;
-       
+
        factor = 1.0;
        switch (view->pending_scroll) {
        factor = 1.0;
        switch (view->pending_scroll) {
-               case SCROLL_TO_KEEP_POSITION: 
-                       factor = adjustment->value / adjustment->upper;
+               case SCROLL_TO_KEEP_POSITION:
+                       factor = (adjustment->value) / adjustment->upper;
                        break;
                        break;
-               case SCROLL_TO_CURRENT_PAGE: 
+               case SCROLL_TO_PAGE_POSITION:
                        break;
                        break;
-               case SCROLL_TO_CENTER: 
+               case SCROLL_TO_CENTER:
                        factor = (adjustment->value + adjustment->page_size * 0.5) / adjustment->upper;
                        break;
        }
                        factor = (adjustment->value + adjustment->page_size * 0.5) / adjustment->upper;
                        break;
        }
@@ -428,19 +400,21 @@ view_set_adjustment_values (EvView         *view,
        adjustment->lower = 0;
        adjustment->upper = MAX (allocation, requisition);
 
        adjustment->lower = 0;
        adjustment->upper = MAX (allocation, requisition);
 
+       /*
+        * We add 0.5 to the values before to average out our rounding errors.
+        */
        switch (view->pending_scroll) {
        switch (view->pending_scroll) {
-               case SCROLL_TO_KEEP_POSITION: 
-                       new_value = CLAMP (adjustment->upper * factor, 0, adjustment->upper - adjustment->page_size);
-                       gtk_adjustment_set_value (adjustment, new_value);
+               case SCROLL_TO_KEEP_POSITION:
+                       new_value = CLAMP (adjustment->upper * factor + 0.5, 0, adjustment->upper - adjustment->page_size);
+                       gtk_adjustment_set_value (adjustment, (int)new_value);
                        break;
                        break;
-               case SCROLL_TO_CURRENT_PAGE: 
-                       if (orientation == GTK_ORIENTATION_VERTICAL) {
-                               view_scroll_to_page (view, view->current_page);
-                       }
+               case SCROLL_TO_PAGE_POSITION:
+                       scroll_to_current_page (view, orientation);
                        break;
                        break;
-               case SCROLL_TO_CENTER: 
-                       new_value = CLAMP (adjustment->upper * factor - adjustment->page_size * 0.5, 0, adjustment->upper - adjustment->page_size);
-                       gtk_adjustment_set_value (adjustment, new_value);
+               case SCROLL_TO_CENTER:
+                       new_value = CLAMP (adjustment->upper * factor - adjustment->page_size * 0.5 + 0.5,
+                                          0, adjustment->upper - adjustment->page_size);
+                       gtk_adjustment_set_value (adjustment, (int)new_value);
                        break;
        }
 
                        break;
        }
 
@@ -450,129 +424,80 @@ view_set_adjustment_values (EvView         *view,
 static void
 view_update_range_and_current_page (EvView *view)
 {
 static void
 view_update_range_and_current_page (EvView *view)
 {
+       gint current_page;
+       
+       if (view->pending_scroll != SCROLL_TO_KEEP_POSITION)
+               return;
+
        /* Presentation trumps all other modes */
        if (view->presentation) {
                view->start_page = view->current_page;
                view->end_page = view->current_page;
        } else if (view->continuous) {
                GdkRectangle current_area, unused, page_area;
        /* Presentation trumps all other modes */
        if (view->presentation) {
                view->start_page = view->current_page;
                view->end_page = view->current_page;
        } else if (view->continuous) {
                GdkRectangle current_area, unused, page_area;
-               gint current_page;
+               GtkBorder border;
                gboolean found = FALSE;
                int i;
                gboolean found = FALSE;
                int i;
-               
-               get_bounding_box_size (view, &(page_area.width), &(page_area.height));
-               page_area.x = view->spacing;
-               page_area.y = view->spacing;
 
 
-               if (view->hadjustment) {
-                       current_area.x = view->hadjustment->value;
-                       current_area.width = view->hadjustment->page_size;
-               } else {
-                       current_area.x = page_area.x;
-                       current_area.width = page_area.width;
-               }
+               if (!(view->vadjustment && view->hadjustment))
+                       return;
 
 
-               if (view->vadjustment) {
-                       current_area.y = view->vadjustment->value;
-                       current_area.height = view->vadjustment->page_size;
-               } else {
-                       current_area.y = page_area.y;
-                       current_area.height = page_area.height;
-               }
+               current_area.x = view->hadjustment->value;
+               current_area.width = view->hadjustment->upper;
+               current_area.y = view->vadjustment->value;
+               current_area.height = view->vadjustment->page_size;
 
                for (i = 0; i < ev_page_cache_get_n_pages (view->page_cache); i++) {
 
                for (i = 0; i < ev_page_cache_get_n_pages (view->page_cache); i++) {
+
+                       get_page_extents (view, i, &page_area, &border);
+
                        if (gdk_rectangle_intersect (&current_area, &page_area, &unused)) {
                                if (! found) {
                                        view->start_page = i;
                                        found = TRUE;
                        if (gdk_rectangle_intersect (&current_area, &page_area, &unused)) {
                                if (! found) {
                                        view->start_page = i;
                                        found = TRUE;
-                                       
+
                                }
                                view->end_page = i;
                        } else if (found) {
                                break;
                        }
                                }
                                view->end_page = i;
                        } else if (found) {
                                break;
                        }
-                       if (view->dual_page) {
-                               if (i % 2 == 0) {
-                                       page_area.x += page_area.width + view->spacing;
-                               } else {
-                                       page_area.x = view->spacing;
-                                       page_area.y += page_area.height + view->spacing;
-                               }
-                       } else {
-                               page_area.y += page_area.height + view->spacing;
-                       }
                }
 
                }
 
-               current_page = ev_page_cache_get_current_page (view->page_cache);
-
-               if (current_page < view->start_page || current_page > view->end_page) {
-                       view->current_page = view->start_page;
-                       ev_page_cache_set_current_page (view->page_cache, view->start_page);
-               }                       
        } else {
                if (view->dual_page) {
        } else {
                if (view->dual_page) {
-                       if (view->current_page % 2 == 0) {
+                       if (view->current_page % 2 == ev_page_cache_get_dual_even_left (view->page_cache)) {
                                view->start_page = view->current_page;
                                if (view->current_page + 1 < ev_page_cache_get_n_pages (view->page_cache))
                                        view->end_page = view->start_page + 1;
                                view->start_page = view->current_page;
                                if (view->current_page + 1 < ev_page_cache_get_n_pages (view->page_cache))
                                        view->end_page = view->start_page + 1;
+                               else 
+                                       view->end_page = view->start_page;
                        } else {
                        } else {
-                               view->start_page = view->current_page - 1;
+                               if (view->current_page - 1 < 0)
+                                       view->start_page = view->current_page;
+                               else
+                                       view->start_page = view->current_page - 1;
                                view->end_page = view->current_page;
                        }
                } else {
                        view->start_page = view->current_page;
                        view->end_page = view->current_page;
                }
                                view->end_page = view->current_page;
                        }
                } else {
                        view->start_page = view->current_page;
                        view->end_page = view->current_page;
                }
-       }
-
-       ev_pixbuf_cache_set_page_range (view->pixbuf_cache,
-                                       view->start_page,
-                                       view->end_page,
-                                       view->scale);   
-}
-
-static void
-view_scroll_to_page (EvView *view, gint new_page)
-{
-       EvPageCache *page_cache = view->page_cache;
-       int old_width, old_height;
-       int new_width, new_height;
-       int max_height, n_rows;
-
-       ev_page_cache_get_size (page_cache,
-                               view->current_page,
-                               view->scale,
-                               &old_width, &old_height);
-
-       ev_page_cache_get_size (page_cache,
-                               new_page,
-                               view->scale,
-                               &new_width, &new_height);
 
 
-       compute_border (view, new_width, new_height, &(view->border));
+       }
 
 
-       if (new_width != old_width || new_height != old_height)
-               gtk_widget_queue_resize (GTK_WIDGET (view));
-       else
-               gtk_widget_queue_draw (GTK_WIDGET (view));
-       
-       if (view->continuous) {
-               
-               n_rows = view->dual_page ? new_page / 2 : new_page;
-               
-               get_bounding_box_size (view, NULL, &max_height);
+       current_page = ev_page_cache_get_current_page (view->page_cache);
 
 
-               gtk_adjustment_clamp_page(view->vadjustment,
-                                         (max_height + view->spacing) * n_rows, 
-                                         (max_height + view->spacing) * n_rows +
-                                          view->vadjustment->page_size);
-       } else {
-               gtk_adjustment_set_value (view->vadjustment,
-                                         view->vadjustment->lower);
+       if (current_page < view->start_page || current_page > view->end_page) {
+               view->current_page = view->start_page;
+               ev_page_cache_set_current_page (view->page_cache, view->start_page);
        }
 
        }
 
-       view->current_page = new_page;
-       view_update_range_and_current_page (view);
+       ev_pixbuf_cache_set_page_range (view->pixbuf_cache,
+                                       view->start_page,
+                                       view->end_page,
+                                       view->rotation,
+                                       view->scale,
+                                       view->selection_info.selections);
 }
 
 static void
 }
 
 static void
@@ -614,23 +539,24 @@ ev_view_set_scroll_adjustments (EvView *view,
        set_scroll_adjustment (view, GTK_ORIENTATION_HORIZONTAL, hadjustment);
        set_scroll_adjustment (view, GTK_ORIENTATION_VERTICAL, vadjustment);
 
        set_scroll_adjustment (view, GTK_ORIENTATION_HORIZONTAL, hadjustment);
        set_scroll_adjustment (view, GTK_ORIENTATION_VERTICAL, vadjustment);
 
-       view_update_adjustments (view);
+       on_adjustment_value_changed (NULL, view);
 }
 
 static void
 add_scroll_binding_keypad (GtkBindingSet  *binding_set,
                           guint           keyval,
 }
 
 static void
 add_scroll_binding_keypad (GtkBindingSet  *binding_set,
                           guint           keyval,
+                          GdkModifierType modifiers,
                           GtkScrollType   scroll,
                           gboolean        horizontal)
 {
   guint keypad_keyval = keyval - GDK_Left + GDK_KP_Left;
 
                           GtkScrollType   scroll,
                           gboolean        horizontal)
 {
   guint keypad_keyval = keyval - GDK_Left + GDK_KP_Left;
 
-  gtk_binding_entry_add_signal (binding_set, keyval, 0,
-                                "scroll_view", 2,
+  gtk_binding_entry_add_signal (binding_set, keyval, modifiers,
+                                "binding_activated", 2,
                                 GTK_TYPE_SCROLL_TYPE, scroll,
                                G_TYPE_BOOLEAN, horizontal);
                                 GTK_TYPE_SCROLL_TYPE, scroll,
                                G_TYPE_BOOLEAN, horizontal);
-  gtk_binding_entry_add_signal (binding_set, keypad_keyval, 0,
-                                "scroll_view", 2,
+  gtk_binding_entry_add_signal (binding_set, keypad_keyval, modifiers,
+                                "binding_activated", 2,
                                 GTK_TYPE_SCROLL_TYPE, scroll,
                                G_TYPE_BOOLEAN, horizontal);
 }
                                 GTK_TYPE_SCROLL_TYPE, scroll,
                                G_TYPE_BOOLEAN, horizontal);
 }
@@ -663,7 +589,7 @@ ev_view_scroll (EvView        *view,
                                /* At the top of a page, assign the upper bound limit of previous page */
                        } else if (value == (adjustment->lower)) {
                                value = adjustment->upper - adjustment->page_size;
                                /* At the top of a page, assign the upper bound limit of previous page */
                        } else if (value == (adjustment->lower)) {
                                value = adjustment->upper - adjustment->page_size;
-                               ev_page_cache_set_current_page (view->page_cache, view->current_page - 1);
+                               ev_view_previous_page (view);
                                /* Jump to the top */
                        } else {
                                value = MAX (value - increment, adjustment->lower);
                                /* Jump to the top */
                        } else {
                                value = MAX (value - increment, adjustment->lower);
@@ -676,7 +602,7 @@ ev_view_scroll (EvView        *view,
                        /* At the bottom of a page, assign the lower bound limit of next page */
                        } else if (value == (adjustment->upper - adjustment->page_size)) {
                                value = 0;
                        /* At the bottom of a page, assign the lower bound limit of next page */
                        } else if (value == (adjustment->upper - adjustment->page_size)) {
                                value = 0;
-                               ev_page_cache_set_current_page (view->page_cache, view->current_page + 1);
+                               ev_view_next_page (view);
                        /* Jump to the bottom */
                        } else {
                                value = MIN (value + increment, adjustment->upper - adjustment->page_size);
                        /* Jump to the bottom */
                        } else {
                                value = MIN (value + increment, adjustment->upper - adjustment->page_size);
@@ -690,13 +616,27 @@ ev_view_scroll (EvView        *view,
 }
 
 static void
 }
 
 static void
-ev_view_scroll_view (EvView *view,
-                    GtkScrollType scroll,
-                    gboolean horizontal)
+ev_view_binding_activated (EvView *view,
+                          GtkScrollType scroll,
+                          gboolean horizontal)
 {
        GtkAdjustment *adjustment;
        double value;
 
 {
        GtkAdjustment *adjustment;
        double value;
 
+       if (view->presentation) {
+               switch (scroll) {
+                       case GTK_SCROLL_STEP_BACKWARD:
+                               ev_view_previous_page (view);
+                               break;
+                       case GTK_SCROLL_STEP_FORWARD:
+                               ev_view_next_page (view);
+                               break;
+                       default:
+                               break;
+               }
+               return;
+       }
+
        if (horizontal) {
                adjustment = view->hadjustment;
        } else {
        if (horizontal) {
                adjustment = view->hadjustment;
        } else {
@@ -712,6 +652,12 @@ ev_view_scroll_view (EvView *view,
                case GTK_SCROLL_STEP_FORWARD:
                        value += adjustment->step_increment;
                        break;
                case GTK_SCROLL_STEP_FORWARD:
                        value += adjustment->step_increment;
                        break;
+               case GTK_SCROLL_STEP_DOWN:
+                       value -= adjustment->step_increment/10;
+                       break;
+               case GTK_SCROLL_STEP_UP:
+                       value += adjustment->step_increment/10;
+                       break;
                default:
                        break;
        }
                default:
                        break;
        }
@@ -731,6 +677,8 @@ ensure_rectangle_is_visible (EvView *view, GdkRectangle *rect)
        GtkAdjustment *adjustment;
        int value;
 
        GtkAdjustment *adjustment;
        int value;
 
+       view->pending_scroll = SCROLL_TO_KEEP_POSITION;
+
        adjustment = view->vadjustment;
 
        if (rect->y < adjustment->value) {
        adjustment = view->vadjustment;
 
        if (rect->y < adjustment->value) {
@@ -771,6 +719,32 @@ compute_border (EvView *view, int width, int height, GtkBorder *border)
        }
 }
 
        }
 }
 
+static void
+get_page_y_offset (EvView *view, int page, double zoom, int *y_offset)
+{
+       int max_width, offset;
+       GtkBorder border;
+
+       g_return_if_fail (y_offset != NULL);
+
+       ev_page_cache_get_max_width (view->page_cache, view->rotation, zoom, &max_width);
+
+       compute_border (view, max_width, max_width, &border);
+
+       if (view->dual_page) {
+               ev_page_cache_get_height_to_page (view->page_cache, page,
+                                                 view->rotation, zoom, NULL, &offset);
+               offset += ((page + ev_page_cache_get_dual_even_left (view->page_cache)) / 2 + 1) * view->spacing + ((page + ev_page_cache_get_dual_even_left (view->page_cache)) / 2 ) * (border.top + border.bottom);
+       } else {
+               ev_page_cache_get_height_to_page (view->page_cache, page,
+                                                 view->rotation, zoom, &offset, NULL);
+               offset += (page + 1) * view->spacing + page * (border.top + border.bottom);
+       }
+
+       *y_offset = offset;
+       return;
+}
+
 static gboolean
 get_page_extents (EvView       *view,
                  gint          page,
 static gboolean
 get_page_extents (EvView       *view,
                  gint          page,
@@ -782,24 +756,9 @@ get_page_extents (EvView       *view,
 
        widget = GTK_WIDGET (view);
 
 
        widget = GTK_WIDGET (view);
 
-       /* Quick sanity check */
-       if (view->presentation) {
-               if (view->current_page != page)
-                       return FALSE;
-       } else if (view->continuous) {
-               if (page < view->start_page ||
-                   page > view->end_page)
-                       return FALSE;
-       } else if (view->dual_page) {
-               if (ABS (page - view->current_page) > 1)
-                       return FALSE;
-       } else {
-               if (view->current_page != page)
-                       return FALSE;
-       }
-
        /* Get the size of the page */
        ev_page_cache_get_size (view->page_cache, page,
        /* Get the size of the page */
        ev_page_cache_get_size (view->page_cache, page,
+                               view->rotation,
                                view->scale,
                                &width, &height);
        compute_border (view, width, height, border);
                                view->scale,
                                &width, &height);
        compute_border (view, width, height, border);
@@ -810,20 +769,25 @@ get_page_extents (EvView       *view,
                page_area->x = (MAX (0, widget->allocation.width - width))/2;
                page_area->y = (MAX (0, widget->allocation.height - height))/2;
        } else if (view->continuous) {
                page_area->x = (MAX (0, widget->allocation.width - width))/2;
                page_area->y = (MAX (0, widget->allocation.height - height))/2;
        } else if (view->continuous) {
-               gint max_width, max_height;
+               gint max_width;
                gint x, y;
 
                gint x, y;
 
-               get_bounding_box_size (view, &max_width, &max_height);
+               ev_page_cache_get_max_width (view->page_cache, view->rotation,
+                                            view->scale, &max_width);
+               max_width = max_width + border->left + border->right;
                /* Get the location of the bounding box */
                if (view->dual_page) {
                /* Get the location of the bounding box */
                if (view->dual_page) {
-                       x = view->spacing + (page % 2) * (max_width + view->spacing);
-                       y = view->spacing + (page / 2) * (max_height + view->spacing);
-                       x = x + MAX (0, widget->allocation.width - (max_width * 2 + view->spacing * 3))/2;
+                       x = view->spacing + ((page % 2 == ev_page_cache_get_dual_even_left (view->page_cache)) ? 0 : 1) * (max_width + view->spacing);
+                       x = x + MAX (0, widget->allocation.width - (max_width * 2 + view->spacing * 3)) / 2;
+                       if (page % 2 == ev_page_cache_get_dual_even_left (view->page_cache))
+                               x = x + (max_width - width - border->left - border->right);
                } else {
                        x = view->spacing;
                } else {
                        x = view->spacing;
-                       y = view->spacing + page * (max_height + view->spacing);
-                       x = x + MAX (0, widget->allocation.width - (max_width + view->spacing * 2))/2;
+                       x = x + MAX (0, widget->allocation.width - (width + view->spacing * 2)) / 2;
                }
                }
+
+               get_page_y_offset (view, page, view->scale, &y);
+
                page_area->x = x;
                page_area->y = y;
        } else {
                page_area->x = x;
                page_area->y = y;
        } else {
@@ -835,12 +799,14 @@ get_page_extents (EvView       *view,
                        GtkBorder overall_border;
                        gint other_page;
 
                        GtkBorder overall_border;
                        gint other_page;
 
-                       other_page = page ^ 1;
+                       other_page = (page % 2 == ev_page_cache_get_dual_even_left (view->page_cache)) ? page + 1: page - 1;
 
                        /* First, we get the bounding box of the two pages */
 
                        /* First, we get the bounding box of the two pages */
-                       if (other_page < ev_page_cache_get_n_pages (view->page_cache)) {
+                       if (other_page < ev_page_cache_get_n_pages (view->page_cache)
+                           && (0 <= other_page)) {
                                ev_page_cache_get_size (view->page_cache,
                                ev_page_cache_get_size (view->page_cache,
-                                                       page + 1,
+                                                       other_page,
+                                                       view->rotation,
                                                        view->scale,
                                                        &width_2, &height_2);
                                if (width_2 > width)
                                                        view->scale,
                                                        &width_2, &height_2);
                                if (width_2 > width)
@@ -855,7 +821,7 @@ get_page_extents (EvView       *view,
                        y = view->spacing;
 
                        /* Adjust for being the left or right page */
                        y = view->spacing;
 
                        /* Adjust for being the left or right page */
-                       if (page % 2 == 0)
+                       if (page % 2 == ev_page_cache_get_dual_even_left (view->page_cache))
                                x = x + max_width - width;
                        else
                                x = x + (max_width + overall_border.left + overall_border.right) + view->spacing;
                                x = x + max_width - width;
                        else
                                x = x + (max_width + overall_border.left + overall_border.right) + view->spacing;
@@ -871,8 +837,8 @@ get_page_extents (EvView       *view,
                        y = view->spacing;
 
                        /* Adjust for extra allocation */
                        y = view->spacing;
 
                        /* Adjust for extra allocation */
-                       x = x + MAX (0, widget->allocation.width - (width + view->spacing * 2))/2;
-                       y = y + MAX (0, widget->allocation.height - (height + view->spacing * 2))/2;
+                       x = x + MAX (0, widget->allocation.width - (width + border->left + border->right + view->spacing * 2))/2;
+                       y = y + MAX (0, widget->allocation.height - (height + border->top + border->bottom +  view->spacing * 2))/2;
                }
 
                page_area->x = x;
                }
 
                page_area->x = x;
@@ -882,60 +848,118 @@ get_page_extents (EvView       *view,
        return TRUE;
 }
 
        return TRUE;
 }
 
+static void
+view_point_to_doc_point (EvView *view,
+                        GdkPoint *view_point,
+                        GdkRectangle *page_area,
+                        double  *doc_point_x,
+                        double  *doc_point_y)
+{
+       *doc_point_x = (double) (view_point->x - page_area->x) / view->scale;
+       *doc_point_y = (double) (view_point->y - page_area->y) / view->scale;
+}
+
 static void
 view_rect_to_doc_rect (EvView *view,
                       GdkRectangle *view_rect,
                       GdkRectangle *page_area,
                       EvRectangle  *doc_rect)
 {
 static void
 view_rect_to_doc_rect (EvView *view,
                       GdkRectangle *view_rect,
                       GdkRectangle *page_area,
                       EvRectangle  *doc_rect)
 {
-       doc_rect->x1 = floor ((view_rect->x - page_area->x) / view->scale);
-       doc_rect->y1 = floor ((view_rect->y - page_area->y) / view->scale);
-       doc_rect->x2 = doc_rect->x1 + ceil (view_rect->width / view->scale);
-       doc_rect->y2 = doc_rect->y1 + ceil (view_rect->height / view->scale);
+       doc_rect->x1 = (double) (view_rect->x - page_area->x) / view->scale;
+       doc_rect->y1 = (double) (view_rect->y - page_area->y) / view->scale;
+       doc_rect->x2 = doc_rect->x1 + (double) view_rect->width / view->scale;
+       doc_rect->y2 = doc_rect->y1 + (double) view_rect->height / view->scale;
 }
 
 }
 
-static void
-doc_rect_to_view_rect (EvView       *view,
-                       int           page,
-                      EvRectangle  *doc_rect,
-                      GdkRectangle *view_rect)
+static gboolean
+doc_point_to_view_point (EvView       *view,
+                         int           page,
+                        EvPoint      *doc_point,
+                        GdkPoint     *view_point)
 {
        GdkRectangle page_area;
        GtkBorder border;
 {
        GdkRectangle page_area;
        GtkBorder border;
+       double x, y, view_x, view_y;
        int width, height;
 
        int width, height;
 
+       ev_page_cache_get_size (view->page_cache, page,
+                               view->rotation,
+                               1.0,
+                               &width, &height);
+
+       if (view->rotation == 0) {
+               x = doc_point->x;
+               y = doc_point->y;
+       } else if (view->rotation == 90) {
+               x = width - doc_point->y;
+               y = doc_point->x;
+       } else if (view->rotation == 180) {
+               x = width - doc_point->x;
+               y = height - doc_point->y;
+       } else if (view->rotation == 270) {
+               x = doc_point->y;
+               y = height - doc_point->x;
+       } else {
+               g_assert_not_reached ();
+       }
+
        get_page_extents (view, page, &page_area, &border);
 
        get_page_extents (view, page, &page_area, &border);
 
-       width = doc_rect->x2 - doc_rect->x1;
-       height = doc_rect->y2 - doc_rect->y1;
-       view_rect->x = floor (doc_rect->x1 * view->scale) + page_area.x;
-       view_rect->y = floor (doc_rect->y1 * view->scale) + page_area.y;
-       view_rect->width = ceil (width * view->scale);
-       view_rect->height = ceil (height * view->scale);
+       view_x = x * view->scale;
+       view_y = y * view->scale;
+       view_point->x = view_x + page_area.x;
+       view_point->y = view_y + page_area.y;
+
+       return (view_x > 0 && view_x <= page_area.width &&
+               view_y > 0 && view_y <= page_area.height);
 }
 
 static void
 }
 
 static void
-get_bounding_box_size (EvView *view, int *max_width, int *max_height)
+doc_rect_to_view_rect (EvView       *view,
+                       int           page,
+                      EvRectangle  *doc_rect,
+                      GdkRectangle *view_rect)
 {
 {
+       GdkRectangle page_area;
        GtkBorder border;
        GtkBorder border;
+       double x, y, w, h;
        int width, height;
 
        int width, height;
 
-       if (max_width) {
-               ev_page_cache_get_max_width_size (view->page_cache,
-                                                 view->scale,
-                                                 &width, &height);
-               compute_border (view, width, height, &border);
-               *max_width = width + border.left + border.right;
+       ev_page_cache_get_size (view->page_cache, page,
+                               view->rotation,
+                               1.0,
+                               &width, &height);
+
+       if (view->rotation == 0) {
+               x = doc_rect->x1;
+               y = doc_rect->y1;
+               w = doc_rect->x2 - doc_rect->x1;
+               h = doc_rect->y2 - doc_rect->y1;
+       } else if (view->rotation == 90) {
+               x = width - doc_rect->y2;
+               y = doc_rect->x1;
+               w = doc_rect->y2 - doc_rect->y1;
+               h = doc_rect->x2 - doc_rect->x1;
+       } else if (view->rotation == 180) {
+               x = width - doc_rect->x2;
+               y = height - doc_rect->y2;
+               w = doc_rect->x2 - doc_rect->x1;
+               h = doc_rect->y2 - doc_rect->y1;
+       } else if (view->rotation == 270) {
+               x = doc_rect->y1;
+               y = height - doc_rect->x2;
+               w = doc_rect->y2 - doc_rect->y1;
+               h = doc_rect->x2 - doc_rect->x1;
+       } else {
+               g_assert_not_reached ();
        }
 
        }
 
+       get_page_extents (view, page, &page_area, &border);
 
 
-       if (max_height) {
-               ev_page_cache_get_max_height_size (view->page_cache,
-                                                  view->scale,
-                                                  &width, &height);
-               compute_border (view, width, height, &border);
-               *max_height = height + border.top + border.bottom;
-       }
+       view_rect->x = x * view->scale + page_area.x;
+       view_rect->y = y * view->scale + page_area.y;
+       view_rect->width = w * view->scale;
+       view_rect->height = h * view->scale;
 }
 
 static void
 }
 
 static void
@@ -976,15 +1000,78 @@ find_page_at_location (EvView  *view,
        *page = -1;
 }
 
        *page = -1;
 }
 
+static gboolean
+location_in_text (EvView  *view,
+                 gdouble  x,
+                 gdouble  y)
+{
+       GdkRegion *region;
+       gint page = -1;
+       gint x_offset = 0, y_offset = 0;
+
+       find_page_at_location (view, x, y, &page, &x_offset, &y_offset);
+
+       if (page == -1)
+               return FALSE;
+       
+       region = ev_pixbuf_cache_get_text_mapping (view->pixbuf_cache, page);
+
+       if (region)
+               return gdk_region_point_in (region, x_offset / view->scale, y_offset / view->scale);
+       else
+               return FALSE;
+}
+
+static int
+ev_view_get_width (EvView *view)
+{
+       return GTK_WIDGET (view)->allocation.width;
+}
+
+static int
+ev_view_get_height (EvView *view)
+{
+       return GTK_WIDGET (view)->allocation.height;
+}
+
+static gboolean
+location_in_selected_text (EvView  *view,
+                          gdouble  x,
+                          gdouble  y)
+{
+       gint page = -1;
+       gint x_offset = 0, y_offset = 0;
+       EvViewSelection *selection;
+       GList *l = NULL;
+
+       for (l = view->selection_info.selections; l != NULL; l = l->next) {
+               selection = (EvViewSelection *)l->data;
+               
+               find_page_at_location (view, x, y, &page, &x_offset, &y_offset);
+               
+               if (page != selection->page)
+                       continue;
+               
+               if (selection->covered_region &&
+                   gdk_region_point_in (selection->covered_region, x_offset, y_offset))
+                       return TRUE;
+       }
+
+       return FALSE;
+}
+
 /*** Hyperref ***/
 static EvLink *
 /*** Hyperref ***/
 static EvLink *
-get_link_at_location (EvView  *view,
-                     gdouble  x,
-                     gdouble  y)
+ev_view_get_link_at_location (EvView  *view,
+                             gdouble  x,
+                             gdouble  y)
 {
        gint page = -1;
        gint x_offset = 0, y_offset = 0;
        GList *link_mapping;
 {
        gint page = -1;
        gint x_offset = 0, y_offset = 0;
        GList *link_mapping;
+       
+       x += view->scroll_x;
+       y += view->scroll_y;
 
        find_page_at_location (view, x, y, &page, &x_offset, &y_offset);
 
 
        find_page_at_location (view, x, y, &page, &x_offset, &y_offset);
 
@@ -999,75 +1086,259 @@ get_link_at_location (EvView  *view,
                return NULL;
 }
 
                return NULL;
 }
 
-/* FIXME: standardize this sometime */
 static void
 static void
-go_to_link (EvView *view, EvLink *link)
+goto_fitr_link (EvView *view, EvLink *link)
 {
 {
-       EvLinkType type;
-       const char *uri;
+       EvPoint doc_point;
        int page;
        int page;
+       double zoom;
 
 
-       type = ev_link_get_link_type (link);
-
-       switch (type) {
-               case EV_LINK_TYPE_TITLE:
-                       break;
-               case EV_LINK_TYPE_PAGE:
-                       page = ev_link_get_page (link);
-                       ev_page_cache_set_current_page (view->page_cache, page);
-                       break;
-               case EV_LINK_TYPE_EXTERNAL_URI:
-                       uri = ev_link_get_uri (link);
-                       gnome_vfs_url_show (uri);
-                       break;
-       }
-}
-
-static char *
-status_message_from_link (EvView *view, EvLink *link)
-{
-       EvLinkType type;
-       char *msg = NULL;
-       char *page_label;
+       zoom = zoom_for_size_best_fit (ev_link_get_right (link) - ev_link_get_left (link),
+                                      ev_link_get_top (link) - ev_link_get_bottom (link),
+                                      ev_view_get_width (view),
+                                      ev_view_get_height (view), 0, 0);
 
 
-       type = ev_link_get_link_type (link);
+       ev_view_set_sizing_mode (view, EV_SIZING_FREE);
+       ev_view_set_zoom (view, zoom, FALSE);
 
 
-       switch (type) {
-               case EV_LINK_TYPE_TITLE:
-                       if (ev_link_get_title (link))
-                               msg = g_strdup (ev_link_get_title (link));
-                       break;
-               case EV_LINK_TYPE_PAGE:
-                       page_label = ev_page_cache_get_page_label (view->page_cache, ev_link_get_page (link));
-                       msg = g_strdup_printf (_("Go to page %s"), page_label);
-                       g_free (page_label);
-                       break;
-               case EV_LINK_TYPE_EXTERNAL_URI:
-                       msg = g_strdup (ev_link_get_uri (link));
-                       break;
-               default:
-                       break;
-       }
+       page = ev_link_get_page (link);
+       doc_point.x = ev_link_get_left (link);
+       doc_point.y = ev_link_get_top (link);
+       
+       view->current_page = page;
+       view->pending_point = doc_point;
+       view->pending_scroll = SCROLL_TO_PAGE_POSITION;
 
 
-       return msg;
+       gtk_widget_queue_resize (GTK_WIDGET (view));
 }
 
 }
 
-
-/*** GtkWidget implementation ***/
-
 static void
 static void
-ev_view_size_request_continuous_dual_page (EvView         *view,
-                                              GtkRequisition *requisition)
+goto_fitv_link (EvView *view, EvLink *link)
 {
 {
-       int max_width, max_height;
-       int n_rows;
+       EvPoint doc_point;
+       int doc_width, doc_height, page;
+       double zoom;
 
 
-       get_bounding_box_size (view, &max_width, &max_height);
+       page = ev_link_get_page (link);
+       ev_page_cache_get_size (view->page_cache, page, 0, 1.0, &doc_width, &doc_height);
 
 
-       n_rows = (1 + ev_page_cache_get_n_pages (view->page_cache)) / 2;
+       doc_point.x = ev_link_get_left (link);
+       doc_point.y = 0;
 
 
-       requisition->width = (max_width * 2) + (view->spacing * 3);
-       requisition->height = max_height * n_rows + (view->spacing * (n_rows + 1));
+       zoom = zoom_for_size_fit_height (doc_width - doc_point.x , doc_height,
+                                        ev_view_get_width (view),
+                                        ev_view_get_height (view), 0);
+
+       ev_view_set_sizing_mode (view, EV_SIZING_FREE);
+       ev_view_set_zoom (view, zoom, FALSE);
+
+       view->current_page = page;
+       view->pending_point = doc_point;
+       view->pending_scroll = SCROLL_TO_PAGE_POSITION;
+
+       gtk_widget_queue_resize (GTK_WIDGET (view));
+}
+
+static void
+goto_fith_link (EvView *view, EvLink *link)
+{
+       EvPoint doc_point;
+       int doc_width, doc_height, page;
+       double zoom;
+
+       page = ev_link_get_page (link);
+       ev_page_cache_get_size (view->page_cache, page, 0, 1.0, &doc_width, &doc_height);
+
+       doc_point.x = 0;
+       doc_point.y = doc_height - ev_link_get_top (link);
+
+       zoom = zoom_for_size_fit_width (doc_width, ev_link_get_top (link),
+                                       ev_view_get_width (view),
+                                       ev_view_get_height (view), 0);
+
+       ev_view_set_sizing_mode (view, EV_SIZING_FREE);
+       ev_view_set_zoom (view, zoom, FALSE);
+
+       view->current_page = page;
+       view->pending_point = doc_point;
+       view->pending_scroll = SCROLL_TO_PAGE_POSITION;
+
+       gtk_widget_queue_resize (GTK_WIDGET (view));
+}
+
+static void
+goto_fit_link (EvView *view, EvLink *link)
+{
+       double zoom;
+       int doc_width, doc_height;
+       int page;
+
+       page = ev_link_get_page (link);
+       ev_page_cache_get_size (view->page_cache, page, 0, 1.0, &doc_width, &doc_height);
+
+       zoom = zoom_for_size_best_fit (doc_width, doc_height, ev_view_get_width (view),
+                                      ev_view_get_height (view), 0, 0);
+
+       ev_view_set_sizing_mode (view, EV_SIZING_FREE);
+       ev_view_set_zoom (view, zoom, FALSE);
+
+       view->current_page = page;
+       view->pending_scroll = SCROLL_TO_PAGE_POSITION;
+
+       gtk_widget_queue_resize (GTK_WIDGET (view));
+}
+
+static void
+goto_xyz_link (EvView *view, EvLink *link)
+{
+       EvPoint doc_point;
+       int height, page;
+       double zoom;
+
+       zoom = ev_link_get_zoom (link);
+       page = ev_link_get_page (link);
+       ev_page_cache_get_size (view->page_cache, page, 0, 1.0, NULL, &height);
+
+       if (zoom != 0) {
+               ev_view_set_sizing_mode (view, EV_SIZING_FREE);
+               ev_view_set_zoom (view, zoom, FALSE);
+       }
+
+       doc_point.x = ev_link_get_left (link);
+       doc_point.y = height - ev_link_get_top (link);
+
+       view->current_page = page;
+       view->pending_point = doc_point;
+       view->pending_scroll = SCROLL_TO_PAGE_POSITION;
+
+       gtk_widget_queue_resize (GTK_WIDGET (view));
+}
+
+void
+ev_view_goto_link (EvView *view, EvLink *link)
+{
+       EvLinkType type;
+       int page;
+
+       type = ev_link_get_link_type (link);
+
+       switch (type) {
+               case EV_LINK_TYPE_TITLE:
+                       break;
+               case EV_LINK_TYPE_PAGE:
+                       page = ev_link_get_page (link);
+                       ev_page_cache_set_current_page (view->page_cache, page);
+                       break;
+               case EV_LINK_TYPE_PAGE_FIT:
+                       goto_fit_link (view, link);
+                       break;
+               case EV_LINK_TYPE_PAGE_FITH:
+                       goto_fith_link (view, link);
+                       break;
+               case EV_LINK_TYPE_PAGE_FITV:
+                       goto_fitv_link (view, link);
+                       break;
+               case EV_LINK_TYPE_PAGE_FITR:
+                       goto_fitr_link (view, link);
+                       break;
+               case EV_LINK_TYPE_PAGE_XYZ:
+                       goto_xyz_link (view, link);
+                       break;
+               case EV_LINK_TYPE_EXTERNAL_URI:
+               case EV_LINK_TYPE_LAUNCH:
+                       g_signal_emit (view, signals[SIGNAL_EXTERNAL_LINK], 0, link);
+                       break;
+       }
+}
+
+static char *
+tip_from_link (EvView *view, EvLink *link)
+{
+       EvLinkType type;
+       char *msg = NULL;
+       char *page_label;
+
+       type = ev_link_get_link_type (link);
+
+       switch (type) {
+               case EV_LINK_TYPE_TITLE:
+                       if (ev_link_get_title (link))
+                               msg = g_strdup (ev_link_get_title (link));
+                       break;
+               case EV_LINK_TYPE_PAGE:
+               case EV_LINK_TYPE_PAGE_XYZ:
+                       page_label = ev_page_cache_get_page_label (view->page_cache, ev_link_get_page (link));
+                       msg = g_strdup_printf (_("Go to page %s"), page_label);
+                       g_free (page_label);
+                       break;
+               case EV_LINK_TYPE_EXTERNAL_URI:
+                       msg = g_strdup (ev_link_get_uri (link));
+                       break;
+               default:
+                       break;
+       }
+
+       return msg;
+}
+
+static void
+handle_link_over_xy (EvView *view, gint x, gint y)
+{
+       EvLink *link;
+
+       link = ev_view_get_link_at_location (view, x, y);
+
+       if (view->link_tooltip == NULL) {
+               view->link_tooltip = ev_tooltip_new (GTK_WIDGET (view));
+       }
+
+       if (view->hovered_link != link) {
+               view->hovered_link = link;
+               ev_tooltip_deactivate (EV_TOOLTIP (view->link_tooltip));
+       }
+
+        if (link) {
+               char *msg = tip_from_link (view, link);
+
+               if (msg && g_utf8_validate (msg, -1, NULL)) {
+                       EvTooltip *tooltip = EV_TOOLTIP (view->link_tooltip);
+
+                       ev_tooltip_set_position (tooltip, x, y);
+                       ev_tooltip_set_text (tooltip, msg);
+                       ev_tooltip_activate (tooltip);
+               }
+               g_free (msg);
+
+               ev_view_set_cursor (view, EV_VIEW_CURSOR_LINK);
+       } else if (location_in_text (view, x + view->scroll_x, y + view->scroll_y)) {
+               ev_view_set_cursor (view, EV_VIEW_CURSOR_IBEAM);
+       } else {
+               ev_view_set_status (view, NULL);
+               if (view->cursor == EV_VIEW_CURSOR_LINK ||
+                   view->cursor == EV_VIEW_CURSOR_IBEAM)
+                       ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
+       }
+       return;
+}
+
+/*** GtkWidget implementation ***/
+
+static void
+ev_view_size_request_continuous_dual_page (EvView         *view,
+                                          GtkRequisition *requisition)
+{
+       int max_width;
+       gint n_pages;
+       GtkBorder border;
+
+       ev_page_cache_get_max_width (view->page_cache, view->rotation,
+                                    view->scale, &max_width);
+       compute_border (view, max_width, max_width, &border);
+
+       n_pages = ev_page_cache_get_n_pages (view->page_cache) + 1;
+
+       requisition->width = (max_width + border.left + border.right) * 2 + (view->spacing * 3);
+       get_page_y_offset (view, n_pages, view->scale, &requisition->height);
 
        if (view->sizing_mode == EV_SIZING_FIT_WIDTH) {
                requisition->width = 1;
 
        if (view->sizing_mode == EV_SIZING_FIT_WIDTH) {
                requisition->width = 1;
@@ -1083,15 +1354,18 @@ static void
 ev_view_size_request_continuous (EvView         *view,
                                 GtkRequisition *requisition)
 {
 ev_view_size_request_continuous (EvView         *view,
                                 GtkRequisition *requisition)
 {
-       int max_width, max_height;
+       int max_width;
        int n_pages;
        int n_pages;
+       GtkBorder border;
 
 
-       get_bounding_box_size (view, &max_width, &max_height);
 
 
+       ev_page_cache_get_max_width (view->page_cache, view->rotation,
+                                    view->scale, &max_width);
        n_pages = ev_page_cache_get_n_pages (view->page_cache);
        n_pages = ev_page_cache_get_n_pages (view->page_cache);
+       compute_border (view, max_width, max_width, &border);
 
 
-       requisition->width = max_width + (view->spacing * 2);
-       requisition->height = max_height * n_pages + (view->spacing * (n_pages + 1));
+       requisition->width = max_width + (view->spacing * 2) + border.left + border.right;
+       get_page_y_offset (view, n_pages, view->scale, &requisition->height);
 
        if (view->sizing_mode == EV_SIZING_FIT_WIDTH) {
                requisition->width = 1;
 
        if (view->sizing_mode == EV_SIZING_FIT_WIDTH) {
                requisition->width = 1;
@@ -1113,12 +1387,14 @@ ev_view_size_request_dual_page (EvView         *view,
        /* Find the largest of the two. */
        ev_page_cache_get_size (view->page_cache,
                                view->current_page,
        /* Find the largest of the two. */
        ev_page_cache_get_size (view->page_cache,
                                view->current_page,
+                               view->rotation,
                                view->scale,
                                &width, &height);
        if (view->current_page + 1 < ev_page_cache_get_n_pages (view->page_cache)) {
                gint width_2, height_2;
                ev_page_cache_get_size (view->page_cache,
                                        view->current_page + 1,
                                view->scale,
                                &width, &height);
        if (view->current_page + 1 < ev_page_cache_get_n_pages (view->page_cache)) {
                gint width_2, height_2;
                ev_page_cache_get_size (view->page_cache,
                                        view->current_page + 1,
+                                       view->rotation,
                                        view->scale,
                                        &width_2, &height_2);
                if (width_2 > width) {
                                        view->scale,
                                        &width_2, &height_2);
                if (width_2 > width) {
@@ -1150,6 +1426,7 @@ ev_view_size_request_single_page (EvView         *view,
 
        ev_page_cache_get_size (view->page_cache,
                                view->current_page,
 
        ev_page_cache_get_size (view->page_cache,
                                view->current_page,
+                               view->rotation,
                                view->scale,
                                &width, &height);
        compute_border (view, width, height, &border);
                                view->scale,
                                &width, &height);
        compute_border (view, width, height, &border);
@@ -1172,9 +1449,6 @@ ev_view_size_request (GtkWidget      *widget,
 {
        EvView *view = EV_VIEW (widget);
 
 {
        EvView *view = EV_VIEW (widget);
 
-       if (!GTK_WIDGET_REALIZED (widget))
-               return;
-
        if (view->document == NULL) {
                requisition->width = 1;
                requisition->height = 1;
        if (view->document == NULL) {
                requisition->width = 1;
                requisition->height = 1;
@@ -1202,22 +1476,23 @@ ev_view_size_allocate (GtkWidget      *widget,
                       GtkAllocation  *allocation)
 {
        EvView *view = EV_VIEW (widget);
                       GtkAllocation  *allocation)
 {
        EvView *view = EV_VIEW (widget);
-       
+
        if (view->sizing_mode == EV_SIZING_FIT_WIDTH ||
        if (view->sizing_mode == EV_SIZING_FIT_WIDTH ||
-                 view->sizing_mode == EV_SIZING_BEST_FIT) {
+           view->sizing_mode == EV_SIZING_BEST_FIT) {
 
                g_signal_emit (view, signals[SIGNAL_ZOOM_INVALID], 0);
 
                g_signal_emit (view, signals[SIGNAL_ZOOM_INVALID], 0);
-               
+
                ev_view_size_request (widget, &widget->requisition);
        }
                ev_view_size_request (widget, &widget->requisition);
        }
-       
+
        view_set_adjustment_values (view, GTK_ORIENTATION_HORIZONTAL);
        view_set_adjustment_values (view, GTK_ORIENTATION_VERTICAL);
 
        view->pending_scroll = SCROLL_TO_KEEP_POSITION;
        view_set_adjustment_values (view, GTK_ORIENTATION_HORIZONTAL);
        view_set_adjustment_values (view, GTK_ORIENTATION_VERTICAL);
 
        view->pending_scroll = SCROLL_TO_KEEP_POSITION;
+       view->pending_resize = FALSE;
 
        if (view->document)
 
        if (view->document)
-               view_update_range_and_current_page (view);              
+               view_update_range_and_current_page (view);
 
        GTK_WIDGET_CLASS (ev_view_parent_class)->size_allocate (widget, allocation);
 }
 
        GTK_WIDGET_CLASS (ev_view_parent_class)->size_allocate (widget, allocation);
 }
@@ -1246,6 +1521,8 @@ ev_view_realize (GtkWidget *widget)
                                GDK_SCROLL_MASK |
                                GDK_KEY_PRESS_MASK |
                                GDK_POINTER_MOTION_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;
 
        widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
                                GDK_LEAVE_NOTIFY_MASK;
 
        widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
@@ -1260,62 +1537,97 @@ ev_view_realize (GtkWidget *widget)
                gdk_window_set_background (widget->window, &widget->style->black);
        else
                gdk_window_set_background (widget->window, &widget->style->mid [GTK_STATE_NORMAL]);
                gdk_window_set_background (widget->window, &widget->style->black);
        else
                gdk_window_set_background (widget->window, &widget->style->mid [GTK_STATE_NORMAL]);
-
-       if (view->document) {
-               /* We can't get page size without a target, so we have to
-                * queue a size request at realization. Could be fixed
-                * with EvDocument changes to allow setting a GdkScreen
-                * without setting a target.
-                */
-               gtk_widget_queue_resize (widget);
-       }
-}
-
-static void
-ev_view_unrealize (GtkWidget *widget)
-{
-       GTK_WIDGET_CLASS (ev_view_parent_class)->unrealize (widget);
 }
 
 static gboolean
 ev_view_scroll_event (GtkWidget *widget, GdkEventScroll *event)
 {
 }
 
 static gboolean
 ev_view_scroll_event (GtkWidget *widget, GdkEventScroll *event)
 {
-       EvView *view = EV_VIEW (widget); 
+       EvView *view = EV_VIEW (widget);
+       guint state;
 
 
-       if ((event->state & GDK_CONTROL_MASK) != 0) {   
+       state = event->state & gtk_accelerator_get_default_mod_mask ();
 
 
-                ev_view_set_sizing_mode (view, EV_SIZING_FREE);         
+       if (state == GDK_CONTROL_MASK && view->presentation == FALSE) {
+               ev_view_set_sizing_mode (view, EV_SIZING_FREE);
 
 
-                if ((event->direction == GDK_SCROLL_UP || 
-                       event->direction == GDK_SCROLL_LEFT) &&
-                       ev_view_can_zoom_in (view)) {
+               if (event->direction == GDK_SCROLL_UP ||
+                   event->direction == GDK_SCROLL_LEFT) {
+                       if (ev_view_can_zoom_in (view)) {
                                ev_view_zoom_in (view);
                                ev_view_zoom_in (view);
-                } else if (ev_view_can_zoom_out (view)) {
+                       }
+               } else {
+                       if (ev_view_can_zoom_out (view)) {
                                ev_view_zoom_out (view);
                                ev_view_zoom_out (view);
-                }               
+                       }
+               }
 
 
-                return TRUE;
+               return TRUE;
        }
        }
-       
-       if ((event->state & GDK_SHIFT_MASK) != 0) {     
+
+       /* Shift+Wheel scrolls the in the perpendicular direction */
+       if (state & GDK_SHIFT_MASK) {
                if (event->direction == GDK_SCROLL_UP)
                        event->direction = GDK_SCROLL_LEFT;
                if (event->direction == GDK_SCROLL_UP)
                        event->direction = GDK_SCROLL_LEFT;
+               if (event->direction == GDK_SCROLL_LEFT)
+                       event->direction = GDK_SCROLL_UP;
                if (event->direction == GDK_SCROLL_DOWN)
                        event->direction = GDK_SCROLL_RIGHT;
                if (event->direction == GDK_SCROLL_DOWN)
                        event->direction = GDK_SCROLL_RIGHT;
+               if (event->direction == GDK_SCROLL_RIGHT)
+                       event->direction = GDK_SCROLL_DOWN;
+
+               event->state &= ~GDK_SHIFT_MASK;
+               state &= ~GDK_SHIFT_MASK;
+       }
+
+       if (state == 0 && view->presentation) {
+               switch (event->direction) {
+               case GDK_SCROLL_DOWN:
+               case GDK_SCROLL_RIGHT:
+                       ev_view_next_page (view);       
+                       break;
+               case GDK_SCROLL_UP:
+               case GDK_SCROLL_LEFT:
+                       ev_view_previous_page (view);
+                       break;
+               }
+
+               return TRUE;
        }
 
        return FALSE;
 }
 
        }
 
        return FALSE;
 }
 
+static EvViewSelection *
+find_selection_for_page (EvView *view,
+                        gint    page)
+{
+       GList *list;
+
+       for (list = view->selection_info.selections; list != NULL; list = list->next) {
+               EvViewSelection *selection;
+
+               selection = (EvViewSelection *) list->data;
+
+               if (selection->page == page)
+                       return selection;
+       }
+
+       return NULL;
+}
+
 static gboolean
 ev_view_expose_event (GtkWidget      *widget,
                      GdkEventExpose *event)
 {
        EvView *view = EV_VIEW (widget);
 static gboolean
 ev_view_expose_event (GtkWidget      *widget,
                      GdkEventExpose *event)
 {
        EvView *view = EV_VIEW (widget);
-       GdkRectangle rubberband;
-       GList *l;
        int i;
 
        int i;
 
+       if (view->loading) {
+               draw_loading_text (view,
+                                  &(widget->allocation),
+                                  &(event->area));
+       }
+
        if (view->document == NULL)
                return FALSE;
 
        if (view->document == NULL)
                return FALSE;
 
@@ -1325,52 +1637,63 @@ ev_view_expose_event (GtkWidget      *widget,
 
                if (!get_page_extents (view, i, &page_area, &border))
                        continue;
 
                if (!get_page_extents (view, i, &page_area, &border))
                        continue;
-                   
+
                page_area.x -= view->scroll_x;
                page_area.y -= view->scroll_y;
                page_area.x -= view->scroll_x;
                page_area.y -= view->scroll_y;
-                   
+
                draw_one_page (view, i, &page_area, &border, &(event->area));
 
                draw_one_page (view, i, &page_area, &border, &(event->area));
 
-               if (EV_IS_DOCUMENT_FIND (view->document)) {
+               if (EV_IS_DOCUMENT_FIND (view->document))
                        highlight_find_results (view, i);
                        highlight_find_results (view, i);
-               }
-       }
-
-       for (l = view->selections; l != NULL; l = l->next) {
-               EvViewSelection *selection = (EvViewSelection *)l->data;
-
-               doc_rect_to_view_rect (view, selection->page,
-                                      &selection->rect, &rubberband);
-               if (rubberband.width > 0 && rubberband.height > 0) {
-                       draw_rubberband (GTK_WIDGET (view), GTK_WIDGET(view)->window,
-                                        &rubberband, 0x40);
-               }
        }
 
        return FALSE;
 }
 
        }
 
        return FALSE;
 }
 
+static gboolean
+ev_view_popup_menu (GtkWidget *widget)
+{
+    gint x, y;
+    EvLink *link;
+    EvView *view = EV_VIEW (widget);
+    
+    gtk_widget_get_pointer (widget, &x, &y);
+    link = ev_view_get_link_at_location (view, x, y);
+    g_signal_emit (view, signals[SIGNAL_POPUP_MENU], 0, link);
+    return TRUE;
+}
+
 static gboolean
 ev_view_button_press_event (GtkWidget      *widget,
                            GdkEventButton *event)
 {
        EvView *view = EV_VIEW (widget);
 static gboolean
 ev_view_button_press_event (GtkWidget      *widget,
                            GdkEventButton *event)
 {
        EvView *view = EV_VIEW (widget);
-
+       EvLink *link;
+       
        if (!GTK_WIDGET_HAS_FOCUS (widget)) {
                gtk_widget_grab_focus (widget);
        }
        if (!GTK_WIDGET_HAS_FOCUS (widget)) {
                gtk_widget_grab_focus (widget);
        }
-
+       
        view->pressed_button = event->button;
        view->pressed_button = event->button;
-
+       view->selection_info.in_drag = FALSE;
+       
        switch (event->button) {
        switch (event->button) {
-               case 1:
-                       if (view->selections) {
-                               clear_selection (view);
+               case 1:
+                       if (view->selection_info.selections) {
+                               if (location_in_selected_text (view,
+                                                              event->x + view->scroll_x,
+                                                              event->y + view->scroll_y)) {
+                                       view->selection_info.in_drag = TRUE;
+                               } else {
+                                       clear_selection (view);
+                               }
+                               
                                gtk_widget_queue_draw (widget);
                        }
 
                                gtk_widget_queue_draw (widget);
                        }
 
-                       view->selection_start.x = event->x;
-                       view->selection_start.y = event->y;
+                       view->selection_info.start.x = event->x + view->scroll_x;
+                       view->selection_info.start.y = event->y + view->scroll_y;
+                       
                        return TRUE;
                case 2:
                        /* use root coordinates as reference point because
                        return TRUE;
                case 2:
                        /* use root coordinates as reference point because
@@ -1382,33 +1705,148 @@ ev_view_button_press_event (GtkWidget      *widget,
 
                        ev_view_set_cursor (view, EV_VIEW_CURSOR_DRAG);
 
 
                        ev_view_set_cursor (view, EV_VIEW_CURSOR_DRAG);
 
+                       return TRUE;
+               case 3:
+                       link = ev_view_get_link_at_location (view, event->x, event->y);
+                       g_signal_emit (view, signals[SIGNAL_POPUP_MENU], 0, link);
                        return TRUE;
        }
                        return TRUE;
        }
+       
+       return FALSE;
+}
 
 
+static void
+ev_view_drag_data_get (GtkWidget        *widget,
+                      GdkDragContext   *context,
+                      GtkSelectionData *selection_data,
+                      guint             info,
+                      guint             time)
+{
+       EvView *view = EV_VIEW (widget);
+
+       if (view->selection_info.selections &&
+           ev_document_can_get_text (view->document)) {
+               gchar *text;
+
+               text = get_selected_text (view);
+
+               gtk_selection_data_set_text (selection_data, text, strlen (text));
+
+               g_free (text);
+       }
+}
+
+static gboolean
+selection_update_idle_cb (EvView *view)
+{
+       compute_selections (view, &view->selection_info.start, &view->motion);
+       view->selection_update_id = 0;
        return FALSE;
 }
 
        return FALSE;
 }
 
+static gboolean
+selection_scroll_timeout_cb (EvView *view)
+{      
+       gint x, y, shift = 0;
+       GtkWidget *widget = GTK_WIDGET (view);
+       
+       gtk_widget_get_pointer (widget, &x, &y);
+
+       if (y > widget->allocation.height) {
+               shift = (y - widget->allocation.height) / 2;
+       } else if (y < 0) {
+               shift = y / 2;
+       }
+
+       if (shift)
+               gtk_adjustment_set_value (view->vadjustment,
+                                         CLAMP (view->vadjustment->value + shift,
+                                         view->vadjustment->lower,
+                                         view->vadjustment->upper -
+                                         view->vadjustment->page_size));       
+
+       if (x > widget->allocation.width) {
+               shift = (x - widget->allocation.width) / 2;
+       } else if (x < 0) {
+               shift = x / 2;
+       }
+
+       if (shift)
+               gtk_adjustment_set_value (view->hadjustment,
+                                         CLAMP (view->hadjustment->value + shift,
+                                         view->hadjustment->lower,
+                                         view->hadjustment->upper -
+                                         view->hadjustment->page_size));       
+
+       return TRUE;
+}
+
 static gboolean
 ev_view_motion_notify_event (GtkWidget      *widget,
                             GdkEventMotion *event)
 {
        EvView *view = EV_VIEW (widget);
 static gboolean
 ev_view_motion_notify_event (GtkWidget      *widget,
                             GdkEventMotion *event)
 {
        EvView *view = EV_VIEW (widget);
+       gint x, y;
+
+       if (!view->document)
+               return FALSE;
+               
+        if (event->is_hint || event->window != widget->window) {
+           gtk_widget_get_pointer (widget, &x, &y);
+        } else {
+           x = event->x;
+           y = event->y;
+       }
+
+       if (view->selection_info.in_drag) {
+               if (gtk_drag_check_threshold (widget,
+                                             view->selection_info.start.x,
+                                             view->selection_info.start.y,
+                                             x, y)) {
+                       GdkDragContext *context;
+                       GtkTargetList *target_list = gtk_target_list_new (NULL, 0);
 
 
-       if (view->pressed_button == 1) {
-               GdkRectangle selection;
+                       gtk_target_list_add_text_targets (target_list, 0);
 
 
-               selection.x = MIN (view->selection_start.x, event->x) + view->scroll_x;
-               selection.y = MIN (view->selection_start.y, event->y) + view->scroll_y;
-               selection.width = ABS (view->selection_start.x - event->x) + 1;
-               selection.height = ABS (view->selection_start.y - event->y) + 1;
+                       context = gtk_drag_begin (widget, target_list,
+                                                 GDK_ACTION_COPY,
+                                                 1, (GdkEvent *)event);
 
 
-               compute_selections (view, &selection);
+                       view->selection_info.in_drag = FALSE;
 
 
-               gtk_widget_queue_draw (widget);
+                       gtk_target_list_unref (target_list);
+
+                       return TRUE;
+               }
+       }
+       
+       /* For the Evince 0.4.x release, we limit selection to un-rotated
+        * documents only.
+        */
+       if (view->pressed_button == 1 && view->rotation == 0) {
+
+               /* Schedule timeout to scroll during selection and additionally 
+                * scroll once to allow arbitrary speed. */
+               if (!view->selection_scroll_id)
+                   view->selection_scroll_id = g_timeout_add (SCROLL_TIME, (GSourceFunc)selection_scroll_timeout_cb, view);
+               else 
+                   selection_scroll_timeout_cb (view);
+
+               view->selection_info.in_selection = TRUE;
+               view->motion.x = x + view->scroll_x;
+               view->motion.y = y + view->scroll_y;
+
+               /* Queue an idle to handle the motion.  We do this because      
+                * handling any selection events in the motion could be slower  
+                * than new motion events reach us.  We always put it in the    
+                * idle to make sure we catch up and don't visibly lag the      
+                * mouse. */
+               if (!view->selection_update_id)
+                       view->selection_update_id = g_idle_add ((GSourceFunc)selection_update_idle_cb, view);
 
                return TRUE;
        } else if (view->pressed_button == 2) {
 
                return TRUE;
        } else if (view->pressed_button == 2) {
-               if (!view->drag_info.dragging) {
+               if (!view->drag_info.in_drag) {
                        gboolean start;
 
                        start = gtk_drag_check_threshold (widget,
                        gboolean start;
 
                        start = gtk_drag_check_threshold (widget,
@@ -1416,10 +1854,10 @@ ev_view_motion_notify_event (GtkWidget      *widget,
                                                          view->drag_info.start.y,
                                                          event->x_root,
                                                          event->y_root);
                                                          view->drag_info.start.y,
                                                          event->x_root,
                                                          event->y_root);
-                       view->drag_info.dragging = start;
+                       view->drag_info.in_drag = start;
                }
 
                }
 
-               if (view->drag_info.dragging) {
+               if (view->drag_info.in_drag) {
                        int dx, dy;
                        gdouble dhadj_value, dvadj_value;
 
                        int dx, dy;
                        gdouble dhadj_value, dvadj_value;
 
@@ -1443,23 +1881,12 @@ ev_view_motion_notify_event (GtkWidget      *widget,
 
                        return TRUE;
                }
 
                        return TRUE;
                }
-       } else if (view->pressed_button <= 0 && view->document) {
-               EvLink *link;
-
-               link = get_link_at_location (view, event->x + view->scroll_x, event->y + view->scroll_y);
-                if (link) {
-                       char *msg;
-
-                       msg = status_message_from_link (view, link);
-                       ev_view_set_status (view, msg);
-                       ev_view_set_cursor (view, EV_VIEW_CURSOR_LINK);
-                       g_free (msg);
-               } else {
-                       ev_view_set_status (view, NULL);
-                       if (view->cursor == EV_VIEW_CURSOR_LINK) {
-                               ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
-                       }
-               }
+       /* For the Evince 0.4.x release, we limit links to un-rotated documents
+        * only.
+        */
+       } else if (view->pressed_button <= 0 &&
+                  view->rotation == 0) {
+               handle_link_over_xy (view, x, y);
                return TRUE;
        }
 
                return TRUE;
        }
 
@@ -1471,28 +1898,116 @@ ev_view_button_release_event (GtkWidget      *widget,
                              GdkEventButton *event)
 {
        EvView *view = EV_VIEW (widget);
                              GdkEventButton *event)
 {
        EvView *view = EV_VIEW (widget);
+       EvLink *link;
 
        if (view->pressed_button == 2) {
                ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
        }
 
 
        if (view->pressed_button == 2) {
                ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
        }
 
+       if (view->document) {
+               link = ev_view_get_link_at_location (view, event->x, event->y);
+       } else {
+               link = NULL;
+       }
+
        view->pressed_button = -1;
        view->pressed_button = -1;
-       view->drag_info.dragging = FALSE;
+       view->drag_info.in_drag = FALSE;
 
 
-       if (view->selections) {
-               ev_view_update_primary_selection (view);
-       } else if (view->document) {
-               EvLink *link;
+       if (view->selection_scroll_id) {
+           g_source_remove (view->selection_scroll_id);
+           view->selection_scroll_id = 0;
+       }
+       if (view->selection_update_id) {
+           g_source_remove (view->selection_update_id);
+           view->selection_update_id = 0;
+       }
 
 
-               link = get_link_at_location (view, event->x + view->scroll_x, event->y + view->scroll_y);
-               if (link) {
-                       go_to_link (view, link);
+       if (view->selection_info.selections) {
+               ev_view_update_primary_selection (view);
+               
+               if (view->selection_info.in_drag) {
+                       clear_selection (view);
+                       gtk_widget_queue_draw (widget);
+               }
+               
+               view->selection_info.in_drag = FALSE;
+       } else if (link) {
+               ev_view_goto_link (view, link);
+       } else if (view->presentation) {
+               switch (event->button) {
+               case 1:
+                       ev_view_next_page (view);       
+                       return TRUE;
+               case 3:
+                       ev_view_previous_page (view);   
+                       return TRUE;
                }
        }
                }
        }
+       return FALSE;
+}
+
+static gint
+ev_view_focus_in (GtkWidget     *widget,
+                 GdkEventFocus *event)
+{
+       if (EV_VIEW (widget)->pixbuf_cache)
+               ev_pixbuf_cache_style_changed (EV_VIEW (widget)->pixbuf_cache);
+       gtk_widget_queue_draw (widget);
 
        return FALSE;
 }
 
 
        return FALSE;
 }
 
+static gint
+ev_view_focus_out (GtkWidget     *widget,
+                    GdkEventFocus *event)
+{
+       if (EV_VIEW (widget)->pixbuf_cache)
+               ev_pixbuf_cache_style_changed (EV_VIEW (widget)->pixbuf_cache);
+       gtk_widget_queue_draw (widget);
+
+       return FALSE;
+}
+
+static gboolean
+ev_view_leave_notify_event (GtkWidget *widget, GdkEventCrossing   *event)
+{
+       EvView *view = EV_VIEW (widget);
+    
+       ev_view_set_status (view, NULL);
+
+       if (view->cursor == EV_VIEW_CURSOR_LINK ||
+           view->cursor == EV_VIEW_CURSOR_IBEAM)
+               ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
+
+       if (view->link_tooltip) {
+               view->hovered_link = NULL;
+               ev_tooltip_deactivate (EV_TOOLTIP (view->link_tooltip));
+       }
+
+       return FALSE;
+}
+
+static gboolean
+ev_view_enter_notify_event (GtkWidget *widget, GdkEventCrossing   *event)
+{
+       EvView *view = EV_VIEW (widget);
+
+       handle_link_over_xy (view, event->x, event->y);
+    
+       return FALSE;
+}
+
+static void
+ev_view_style_set (GtkWidget *widget,
+                  GtkStyle  *old_style)
+{
+       if (EV_VIEW (widget)->pixbuf_cache)
+               ev_pixbuf_cache_style_changed (EV_VIEW (widget)->pixbuf_cache);
+
+       GTK_WIDGET_CLASS (ev_view_parent_class)->style_set (widget, old_style);
+}
+
 /*** Drawing ***/
 
 static guint32
 /*** Drawing ***/
 
 static guint32
@@ -1513,7 +2028,7 @@ draw_rubberband (GtkWidget *widget, GdkWindow *window,
        GdkPixbuf *pixbuf;
        GdkColor *fill_color_gdk;
        guint fill_color;
        GdkPixbuf *pixbuf;
        GdkColor *fill_color_gdk;
        guint fill_color;
-       
+
        fill_color_gdk = gdk_color_copy (&GTK_WIDGET (widget)->style->base[GTK_STATE_SELECTED]);
        fill_color = ev_gdk_color_to_rgb (fill_color_gdk) << 8 | alpha;
 
        fill_color_gdk = gdk_color_copy (&GTK_WIDGET (widget)->style->base[GTK_STATE_SELECTED]);
        fill_color = ev_gdk_color_to_rgb (fill_color_gdk) << 8 | alpha;
 
@@ -1565,8 +2080,7 @@ highlight_find_results (EvView *view, int page)
                        alpha = 0x20;
                }
 
                        alpha = 0x20;
                }
 
-               ev_document_find_get_result (find, page,
-                                            i, &rectangle);
+               ev_document_find_get_result (find, page, i, &rectangle);
                doc_rect_to_view_rect (view, page, &rectangle, &view_rectangle);
                draw_rubberband (GTK_WIDGET (view), GTK_WIDGET(view)->window,
                                 &view_rectangle, alpha);
                doc_rect_to_view_rect (view, page, &rectangle, &view_rectangle);
                draw_rubberband (GTK_WIDGET (view), GTK_WIDGET(view)->window,
                                 &view_rectangle, alpha);
@@ -1574,27 +2088,72 @@ highlight_find_results (EvView *view, int page)
 }
 
 static void
 }
 
 static void
-draw_one_page (EvView       *view,
-              gint          page,
-              GdkRectangle *page_area,
-              GtkBorder    *border,
-              GdkRectangle *expose_area)
+draw_loading_text (EvView       *view,
+                  GdkRectangle *page_area,
+                  GdkRectangle *expose_area)
+{
+       PangoLayout *layout;
+       PangoFontDescription *font_desc;
+       PangoRectangle logical_rect;
+       double real_scale;
+       int target_width;
+
+       const char *loading_text = _("Loading...");     
+
+       layout = gtk_widget_create_pango_layout (GTK_WIDGET (view), loading_text);
+
+       font_desc = pango_font_description_new ();
+
+
+       /* We set the font to be 10 points, get the size, and scale appropriately */
+       pango_font_description_set_size (font_desc, 10 * PANGO_SCALE);
+       pango_layout_set_font_description (layout, font_desc);
+       pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
+
+       /* Make sure we fit the middle of the page */
+       target_width = MAX (page_area->width / 2, 1);
+       real_scale = ((double)target_width / (double) logical_rect.width) * (PANGO_SCALE * 10);
+       pango_font_description_set_size (font_desc, (int)real_scale);
+       pango_layout_set_font_description (layout, font_desc);
+       pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
+
+       gtk_paint_layout (GTK_WIDGET (view)->style,
+                         GTK_WIDGET (view)->window,
+                         GTK_WIDGET_STATE (view),
+                         FALSE,
+                         page_area,
+                         GTK_WIDGET (view),
+                         NULL,
+                         page_area->x + (target_width/2),
+                         page_area->y + (page_area->height - logical_rect.height) / 2,
+                         layout);
+
+       pango_font_description_free (font_desc);
+       g_object_unref (layout);
+}
+
+static void
+draw_one_page (EvView          *view,
+              gint             page,
+              GdkRectangle    *page_area,
+              GtkBorder       *border,
+              GdkRectangle    *expose_area)
 {
        gint width, height;
 {
        gint width, height;
-       GdkPixbuf *scaled_image;
        GdkPixbuf *current_pixbuf;
        GdkRectangle overlap;
        GdkRectangle real_page_area;
        GdkPixbuf *current_pixbuf;
        GdkRectangle overlap;
        GdkRectangle real_page_area;
+       EvViewSelection *selection;
 
        g_assert (view->document);
 
        g_assert (view->document);
-
-       if (!gdk_rectangle_intersect (page_area, expose_area, &overlap))
+       if (! gdk_rectangle_intersect (page_area, expose_area, &overlap))
                return;
 
                return;
 
+       selection = find_selection_for_page (view, page);
        ev_page_cache_get_size (view->page_cache,
        ev_page_cache_get_size (view->page_cache,
-                               page, view->scale,
+                               page, view->rotation,
+                               view->scale,
                                &width, &height);
                                &width, &height);
-
        /* Render the document itself */
        real_page_area = *page_area;
 
        /* Render the document itself */
        real_page_area = *page_area;
 
@@ -1603,36 +2162,77 @@ draw_one_page (EvView       *view,
        real_page_area.width -= (border->left + border->right);
        real_page_area.height -= (border->top + border->bottom);
 
        real_page_area.width -= (border->left + border->right);
        real_page_area.height -= (border->top + border->bottom);
 
-       if (! gdk_rectangle_intersect (&real_page_area, expose_area, &overlap))
-               return;
-
        ev_document_misc_paint_one_page (GTK_WIDGET(view)->window,
                                         GTK_WIDGET (view),
                                         page_area, border);
 
        ev_document_misc_paint_one_page (GTK_WIDGET(view)->window,
                                         GTK_WIDGET (view),
                                         page_area, border);
 
-       current_pixbuf = ev_pixbuf_cache_get_pixbuf (view->pixbuf_cache, page);
-
-       if (current_pixbuf == NULL)
-               scaled_image = NULL;
-       else if (width == gdk_pixbuf_get_width (current_pixbuf) &&
-                height == gdk_pixbuf_get_height (current_pixbuf))
-               scaled_image = g_object_ref (current_pixbuf);
-       else
-               scaled_image = gdk_pixbuf_scale_simple (current_pixbuf,
-                                                       width, height,
-                                                       GDK_INTERP_NEAREST);
+       if (gdk_rectangle_intersect (&real_page_area, expose_area, &overlap)) {
+               GdkPixbuf *selection_pixbuf = NULL;
+               GdkPixbuf *scaled_image;
+               GdkPixbuf *scaled_selection;
+
+               current_pixbuf = ev_pixbuf_cache_get_pixbuf (view->pixbuf_cache, page);
+
+               /* Get the selection pixbuf iff we have something to draw */
+               if (current_pixbuf && view->selection_mode == EV_VIEW_SELECTION_TEXT && selection)
+                       selection_pixbuf = ev_pixbuf_cache_get_selection_pixbuf (view->pixbuf_cache,
+                                                                                page,
+                                                                                view->scale,
+                                                                                NULL);
+
+               if (current_pixbuf == NULL)
+                       scaled_image = NULL;
+               else if (width == gdk_pixbuf_get_width (current_pixbuf) &&
+                        height == gdk_pixbuf_get_height (current_pixbuf))
+                       scaled_image = g_object_ref (current_pixbuf);
+               else
+                       /* FIXME: We don't want to scale the whole area, just the right
+                        * area of it */
+                       scaled_image = gdk_pixbuf_scale_simple (current_pixbuf,
+                                                               width, height,
+                                                               GDK_INTERP_NEAREST);
+
+               if (selection_pixbuf == NULL)
+                       scaled_selection = NULL;
+               else if (width == gdk_pixbuf_get_width (selection_pixbuf) &&
+                        height == gdk_pixbuf_get_height (selection_pixbuf))
+                       scaled_selection = g_object_ref (selection_pixbuf);
+               else
+                       /* FIXME: We don't want to scale the whole area, just the right
+                        * area of it */
+                       scaled_selection = gdk_pixbuf_scale_simple (selection_pixbuf,
+                                                                   width, height,
+                                                                   GDK_INTERP_NEAREST);
+
+               if (scaled_image) {
+                       gdk_draw_pixbuf (GTK_WIDGET(view)->window,
+                                        GTK_WIDGET (view)->style->fg_gc[GTK_STATE_NORMAL],
+                                        scaled_image,
+                                        overlap.x - real_page_area.x,
+                                        overlap.y - real_page_area.y,
+                                        overlap.x, overlap.y,
+                                        overlap.width, overlap.height,
+                                        GDK_RGB_DITHER_NORMAL,
+                                        0, 0);
+                       g_object_unref (scaled_image);
+               } else {
+                       draw_loading_text (view,
+                                          &real_page_area,
+                                          expose_area);
+               }
 
 
-       if (scaled_image) {
-               gdk_draw_pixbuf (GTK_WIDGET(view)->window,
-                                GTK_WIDGET (view)->style->fg_gc[GTK_STATE_NORMAL],
-                                scaled_image,
-                                overlap.x - real_page_area.x,
-                                overlap.y - real_page_area.y,
-                                overlap.x, overlap.y,
-                                overlap.width, overlap.height,
-                                GDK_RGB_DITHER_NORMAL,
-                                0, 0);
-               g_object_unref (scaled_image);
+               if (scaled_selection) {
+                       gdk_draw_pixbuf (GTK_WIDGET(view)->window,
+                                        GTK_WIDGET (view)->style->fg_gc[GTK_STATE_NORMAL],
+                                        scaled_selection,
+                                        overlap.x - real_page_area.x,
+                                        overlap.y - real_page_area.y,
+                                        overlap.x, overlap.y,
+                                        overlap.width, overlap.height,
+                                        GDK_RGB_DITHER_NORMAL,
+                                        0, 0);
+                       g_object_unref (scaled_selection);
+               }
        }
 }
 
        }
 }
 
@@ -1662,10 +2262,26 @@ ev_view_destroy (GtkObject *object)
                g_object_unref (view->document);
                view->document = NULL;
        }
                g_object_unref (view->document);
                view->document = NULL;
        }
+
        if (view->pixbuf_cache) {
                g_object_unref (view->pixbuf_cache);
                view->pixbuf_cache = NULL;
        }
        if (view->pixbuf_cache) {
                g_object_unref (view->pixbuf_cache);
                view->pixbuf_cache = NULL;
        }
+
+       if (view->link_tooltip) {
+               gtk_widget_destroy (view->link_tooltip);
+       }
+
+       if (view->selection_scroll_id) {
+           g_source_remove (view->selection_scroll_id);
+           view->selection_scroll_id = 0;
+       }
+
+       if (view->selection_update_id) {
+           g_source_remove (view->selection_update_id);
+           view->selection_update_id = 0;
+       }
+
        ev_view_set_scroll_adjustments (view, NULL, NULL);
 
        GTK_OBJECT_CLASS (ev_view_parent_class)->destroy (object);
        ev_view_set_scroll_adjustments (view, NULL, NULL);
 
        GTK_OBJECT_CLASS (ev_view_parent_class)->destroy (object);
@@ -1696,11 +2312,48 @@ ev_view_set_property (GObject      *object,
        case PROP_SIZING_MODE:
                ev_view_set_sizing_mode (view, g_value_get_enum (value));
                break;
        case PROP_SIZING_MODE:
                ev_view_set_sizing_mode (view, g_value_get_enum (value));
                break;
+       case PROP_ZOOM:
+               ev_view_set_zoom (view, g_value_get_double (value), FALSE);
+               break;
+       case PROP_ROTATION:
+               ev_view_set_rotation (view, g_value_get_int (value));
+               break;
        default:
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
        }
 }
 
        default:
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
        }
 }
 
+static AtkObject *
+ev_view_get_accessible (GtkWidget *widget)
+{
+       static gboolean first_time = TRUE;
+
+       if (first_time) {
+               AtkObjectFactory *factory;
+               AtkRegistry *registry;
+               GType derived_type; 
+               GType derived_atk_type; 
+
+               /*
+                * Figure out whether accessibility is enabled by looking at the
+                * type of the accessible object which would be created for
+                * the parent type of EvView.
+                */
+               derived_type = g_type_parent (EV_TYPE_VIEW);
+
+               registry = atk_get_default_registry ();
+               factory = atk_registry_get_factory (registry,
+                                                   derived_type);
+               derived_atk_type = atk_object_factory_get_accessible_type (factory);
+               if (g_type_is_a (derived_atk_type, GTK_TYPE_ACCESSIBLE)) 
+                       atk_registry_set_factory_type (registry, 
+                                                      EV_TYPE_VIEW,
+                                                      ev_view_accessible_factory_get_type ());
+               first_time = FALSE;
+       } 
+       return GTK_WIDGET_CLASS (ev_view_parent_class)->get_accessible (widget);
+}
+
 static void
 ev_view_get_property (GObject *object,
                      guint prop_id,
 static void
 ev_view_get_property (GObject *object,
                      guint prop_id,
@@ -1732,6 +2385,16 @@ ev_view_get_property (GObject *object,
        case PROP_SIZING_MODE:
                g_value_set_enum (value, view->sizing_mode);
                break;
        case PROP_SIZING_MODE:
                g_value_set_enum (value, view->sizing_mode);
                break;
+       case PROP_ZOOM:
+               g_value_set_double (value, view->scale);
+               break;
+       case PROP_ROTATION:
+               g_value_set_int (value, view->rotation);
+               break;
+       case PROP_HAS_SELECTION:
+               g_value_set_boolean (value,
+                                    view->selection_info.selections != NULL);
+               break;
        default:
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
        }
        default:
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
        }
@@ -1753,17 +2416,24 @@ ev_view_class_init (EvViewClass *class)
        widget_class->button_press_event = ev_view_button_press_event;
        widget_class->motion_notify_event = ev_view_motion_notify_event;
        widget_class->button_release_event = ev_view_button_release_event;
        widget_class->button_press_event = ev_view_button_press_event;
        widget_class->motion_notify_event = ev_view_motion_notify_event;
        widget_class->button_release_event = ev_view_button_release_event;
+       widget_class->focus_in_event = ev_view_focus_in;
+       widget_class->focus_out_event = ev_view_focus_out;
+       widget_class->get_accessible = ev_view_get_accessible;
        widget_class->size_request = ev_view_size_request;
        widget_class->size_allocate = ev_view_size_allocate;
        widget_class->realize = ev_view_realize;
        widget_class->size_request = ev_view_size_request;
        widget_class->size_allocate = ev_view_size_allocate;
        widget_class->realize = ev_view_realize;
-       widget_class->unrealize = ev_view_unrealize;
        widget_class->scroll_event = ev_view_scroll_event;
        widget_class->scroll_event = ev_view_scroll_event;
+       widget_class->enter_notify_event = ev_view_enter_notify_event;
+       widget_class->leave_notify_event = ev_view_leave_notify_event;
+       widget_class->style_set = ev_view_style_set;
+       widget_class->drag_data_get = ev_view_drag_data_get;
+       widget_class->popup_menu = ev_view_popup_menu;
        gtk_object_class->destroy = ev_view_destroy;
 
        class->set_scroll_adjustments = ev_view_set_scroll_adjustments;
        gtk_object_class->destroy = ev_view_destroy;
 
        class->set_scroll_adjustments = ev_view_set_scroll_adjustments;
-       class->scroll_view = ev_view_scroll_view;
+       class->binding_activated = ev_view_binding_activated;
 
 
-       widget_class->set_scroll_adjustments_signal =  
+       widget_class->set_scroll_adjustments_signal =
            g_signal_new ("set-scroll-adjustments",
                          G_OBJECT_CLASS_TYPE (object_class),
                          G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
            g_signal_new ("set-scroll-adjustments",
                          G_OBJECT_CLASS_TYPE (object_class),
                          G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
@@ -1774,10 +2444,10 @@ ev_view_class_init (EvViewClass *class)
                          GTK_TYPE_ADJUSTMENT,
                          GTK_TYPE_ADJUSTMENT);
 
                          GTK_TYPE_ADJUSTMENT,
                          GTK_TYPE_ADJUSTMENT);
 
-       signals[SIGNAL_SCROLL_VIEW] = g_signal_new ("scroll-view",
+       signals[SIGNAL_BINDING_ACTIVATED] = g_signal_new ("binding_activated",
                         G_TYPE_FROM_CLASS (object_class),
                         G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
                         G_TYPE_FROM_CLASS (object_class),
                         G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
-                        G_STRUCT_OFFSET (EvViewClass, scroll_view),
+                        G_STRUCT_OFFSET (EvViewClass, binding_activated),
                         NULL, NULL,
                         ev_marshal_VOID__ENUM_BOOLEAN,
                         G_TYPE_NONE, 2,
                         NULL, NULL,
                         ev_marshal_VOID__ENUM_BOOLEAN,
                         G_TYPE_NONE, 2,
@@ -1791,6 +2461,22 @@ ev_view_class_init (EvViewClass *class)
                         NULL, NULL,
                         ev_marshal_VOID__VOID,
                         G_TYPE_NONE, 0, G_TYPE_NONE);
                         NULL, NULL,
                         ev_marshal_VOID__VOID,
                         G_TYPE_NONE, 0, G_TYPE_NONE);
+       signals[SIGNAL_EXTERNAL_LINK] = g_signal_new ("external-link",
+                        G_TYPE_FROM_CLASS (object_class),
+                        G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+                        G_STRUCT_OFFSET (EvViewClass, external_link),
+                        NULL, NULL,
+                        g_cclosure_marshal_VOID__OBJECT,
+                        G_TYPE_NONE, 1,
+                        G_TYPE_OBJECT);
+       signals[SIGNAL_POPUP_MENU] = g_signal_new ("popup",
+                        G_TYPE_FROM_CLASS (object_class),
+                        G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+                        G_STRUCT_OFFSET (EvViewClass, popup_menu),
+                        NULL, NULL,
+                        g_cclosure_marshal_VOID__OBJECT,
+                        G_TYPE_NONE, 1,
+                        G_TYPE_OBJECT);
 
        g_object_class_install_property (object_class,
                                         PROP_STATUS,
 
        g_object_class_install_property (object_class,
                                         PROP_STATUS,
@@ -1847,12 +2533,42 @@ ev_view_class_init (EvViewClass *class)
                                                            EV_SIZING_FIT_WIDTH,
                                                            G_PARAM_READWRITE));
 
                                                            EV_SIZING_FIT_WIDTH,
                                                            G_PARAM_READWRITE));
 
+       g_object_class_install_property (object_class,
+                                        PROP_ZOOM,
+                                        g_param_spec_double ("zoom",
+                                                             "Zoom factor",
+                                                              "Zoom factor",
+                                                              MIN_SCALE,
+                                                              MAX_SCALE,
+                                                              1.0,
+                                                              G_PARAM_READWRITE));
+       g_object_class_install_property (object_class,
+                                        PROP_ROTATION,
+                                        g_param_spec_double ("rotation",
+                                                             "Rotation",
+                                                              "Rotation",
+                                                              0,
+                                                              360,
+                                                              0,
+                                                              G_PARAM_READWRITE));
+       g_object_class_install_property (object_class,
+                                        PROP_HAS_SELECTION,
+                                        g_param_spec_boolean ("has-selection",
+                                                              "Has selection",
+                                                              "The view has selections",
+                                                              FALSE,
+                                                              G_PARAM_READABLE));
+
        binding_set = gtk_binding_set_by_class (class);
 
        binding_set = gtk_binding_set_by_class (class);
 
-       add_scroll_binding_keypad (binding_set, GDK_Left,  GTK_SCROLL_STEP_BACKWARD, TRUE);
-       add_scroll_binding_keypad (binding_set, GDK_Right, GTK_SCROLL_STEP_FORWARD,  TRUE);
-       add_scroll_binding_keypad (binding_set, GDK_Up,    GTK_SCROLL_STEP_BACKWARD, FALSE);
-       add_scroll_binding_keypad (binding_set, GDK_Down,  GTK_SCROLL_STEP_FORWARD,  FALSE);
+       add_scroll_binding_keypad (binding_set, GDK_Left,  0, GTK_SCROLL_STEP_BACKWARD, TRUE);
+       add_scroll_binding_keypad (binding_set, GDK_Right, 0, GTK_SCROLL_STEP_FORWARD,  TRUE);
+       add_scroll_binding_keypad (binding_set, GDK_Left,  GDK_MOD1_MASK, GTK_SCROLL_STEP_DOWN, TRUE);
+       add_scroll_binding_keypad (binding_set, GDK_Right, GDK_MOD1_MASK, GTK_SCROLL_STEP_UP,  TRUE);
+       add_scroll_binding_keypad (binding_set, GDK_Up,    0, GTK_SCROLL_STEP_BACKWARD, FALSE);
+       add_scroll_binding_keypad (binding_set, GDK_Down,  0, GTK_SCROLL_STEP_FORWARD,  FALSE);
+       add_scroll_binding_keypad (binding_set, GDK_Up,    GDK_MOD1_MASK, GTK_SCROLL_STEP_DOWN, FALSE);
+       add_scroll_binding_keypad (binding_set, GDK_Down,  GDK_MOD1_MASK, GTK_SCROLL_STEP_UP,  FALSE);
 }
 
 static void
 }
 
 static void
@@ -1860,13 +2576,16 @@ ev_view_init (EvView *view)
 {
        GTK_WIDGET_SET_FLAGS (view, GTK_CAN_FOCUS);
 
 {
        GTK_WIDGET_SET_FLAGS (view, GTK_CAN_FOCUS);
 
-       view->spacing = 10;
+       view->spacing = 5;
        view->scale = 1.0;
        view->current_page = 0;
        view->pressed_button = -1;
        view->cursor = EV_VIEW_CURSOR_NORMAL;
        view->scale = 1.0;
        view->current_page = 0;
        view->pressed_button = -1;
        view->cursor = EV_VIEW_CURSOR_NORMAL;
-       view->drag_info.dragging = FALSE;
-
+       view->drag_info.in_drag = FALSE;
+       view->selection_info.selections = NULL;
+       view->selection_info.in_selection = FALSE;
+       view->selection_info.in_drag = FALSE;
+       view->selection_mode = EV_VIEW_SELECTION_TEXT;
        view->continuous = TRUE;
        view->dual_page = FALSE;
        view->presentation = FALSE;
        view->continuous = TRUE;
        view->dual_page = FALSE;
        view->presentation = FALSE;
@@ -1880,52 +2599,111 @@ ev_view_init (EvView *view)
 static void
 find_changed_cb (EvDocument *document, int page, EvView *view)
 {
 static void
 find_changed_cb (EvDocument *document, int page, EvView *view)
 {
-       jump_to_find_page (view);
-       jump_to_find_result (view);
-       update_find_status_message (view);
+       jump_to_find_page (view, EV_VIEW_FIND_NEXT);
+       jump_to_find_result (view);
+       update_find_status_message (view);
+
+       if (view->current_page == page)
+               gtk_widget_queue_draw (GTK_WIDGET (view));
+}
+
+static void
+job_finished_cb (EvPixbufCache *pixbuf_cache,
+                EvView        *view)
+{
+       gtk_widget_queue_draw (GTK_WIDGET (view));
+}
+
+static void
+page_changed_cb (EvPageCache *page_cache,
+                int          new_page,
+                EvView      *view)
+{
+       if (view->current_page != new_page) {
+
+               view->current_page = new_page;
+               view->pending_scroll = SCROLL_TO_PAGE_POSITION;
+               gtk_widget_queue_resize (GTK_WIDGET (view));
+
+               if (EV_IS_DOCUMENT_FIND (view->document)) {
+                       view->find_page = new_page;
+                       view->find_result = 0;
+                       update_find_status_message (view);
+               }
+       }
+}
+
+static void on_adjustment_value_changed (GtkAdjustment  *adjustment,
+                                        EvView *view)
+{
+       int dx = 0, dy = 0;
+
+       if (! GTK_WIDGET_REALIZED (view))
+               return;
+
+       if (view->hadjustment) {
+               dx = view->scroll_x - (int) view->hadjustment->value;
+               view->scroll_x = (int) view->hadjustment->value;
+       } else {
+               view->scroll_x = 0;
+       }
+
+       if (view->vadjustment) {
+               dy = view->scroll_y - (int) view->vadjustment->value;
+               view->scroll_y = (int) view->vadjustment->value;
+       } else {
+               view->scroll_y = 0;
+       }
+
+
+       if (view->pending_resize)
+               gtk_widget_queue_draw (GTK_WIDGET (view));
+       else
+               gdk_window_scroll (GTK_WIDGET (view)->window, dx, dy);
+
+
+       if (view->document)
+               view_update_range_and_current_page (view);
+}
+
+GtkWidget*
+ev_view_new (void)
+{
+       GtkWidget *view;
 
 
-       if (view->current_page == page)
-               gtk_widget_queue_draw (GTK_WIDGET (view));
+       view = g_object_new (EV_TYPE_VIEW, NULL);
+
+       return view;
 }
 
 static void
 }
 
 static void
-job_finished_cb (EvPixbufCache *pixbuf_cache,
-                EvView        *view)
+setup_caches (EvView *view)
 {
 {
-       gtk_widget_queue_draw (GTK_WIDGET (view));
+       view->page_cache = ev_page_cache_get (view->document);
+       g_signal_connect (view->page_cache, "page-changed", G_CALLBACK (page_changed_cb), view);
+       view->pixbuf_cache = ev_pixbuf_cache_new (GTK_WIDGET (view), view->document);
+       g_signal_connect (view->pixbuf_cache, "job-finished", G_CALLBACK (job_finished_cb), view);
 }
 
 static void
 }
 
 static void
-page_changed_cb (EvPageCache *page_cache,
-                int          new_page,
-                EvView      *view)
+clear_caches (EvView *view)
 {
 {
-       if (view->current_page != new_page) {
-
-               view_scroll_to_page (view, new_page);
-
-               if (EV_IS_DOCUMENT_FIND (view->document)) {
-                       view->find_page = new_page;
-                       view->find_result = 0;
-                       update_find_status_message (view);
-               }
+       if (view->pixbuf_cache) {
+               g_object_unref (view->pixbuf_cache);
+               view->pixbuf_cache = NULL;
        }
        }
-}
 
 
-static void on_adjustment_value_changed (GtkAdjustment  *adjustment,
-                                        EvView *view)
-{
-       view_update_adjustments (view);
+       if (view->page_cache) {
+               view->page_cache = NULL;
+       }
 }
 
 }
 
-GtkWidget*
-ev_view_new (void)
+void
+ev_view_set_loading (EvView      *view,
+                    gboolean      loading)
 {
 {
-       GtkWidget *view;
-
-       view = g_object_new (EV_TYPE_VIEW, NULL);
-
-       return view;
+       view->loading = loading;
+       gtk_widget_queue_draw (GTK_WIDGET (view));
 }
 
 void
 }
 
 void
@@ -1934,7 +2712,11 @@ ev_view_set_document (EvView     *view,
 {
        g_return_if_fail (EV_IS_VIEW (view));
 
 {
        g_return_if_fail (EV_IS_VIEW (view));
 
+       view->loading = FALSE;
+       
        if (document != view->document) {
        if (document != view->document) {
+               clear_caches (view);
+
                if (view->document) {
                         g_signal_handlers_disconnect_by_func (view->document,
                                                               find_changed_cb,
                if (view->document) {
                         g_signal_handlers_disconnect_by_func (view->document,
                                                               find_changed_cb,
@@ -1956,11 +2738,8 @@ ev_view_set_document (EvView     *view,
                                                  G_CALLBACK (find_changed_cb),
                                                  view);
                        }
                                                  G_CALLBACK (find_changed_cb),
                                                  view);
                        }
-                       view->page_cache = ev_document_get_page_cache (view->document);
-                       view->pending_scroll = SCROLL_TO_CURRENT_PAGE;
-                       g_signal_connect (view->page_cache, "page-changed", G_CALLBACK (page_changed_cb), view);
-                       view->pixbuf_cache = ev_pixbuf_cache_new (view->document);
-                       g_signal_connect (view->pixbuf_cache, "job-finished", G_CALLBACK (job_finished_cb), view);
+
+                       setup_caches (view);
                 }
 
                gtk_widget_queue_resize (GTK_WIDGET (view));
                 }
 
                gtk_widget_queue_resize (GTK_WIDGET (view));
@@ -1986,9 +2765,13 @@ ev_view_set_zoom (EvView   *view,
 
        if (ABS (view->scale - scale) < EPSILON)
                return;
 
        if (ABS (view->scale - scale) < EPSILON)
                return;
+
        view->scale = scale;
        view->scale = scale;
+       view->pending_resize = TRUE;
 
        gtk_widget_queue_resize (GTK_WIDGET (view));
 
        gtk_widget_queue_resize (GTK_WIDGET (view));
+
+       g_object_notify (G_OBJECT (view), "zoom");
 }
 
 double
 }
 
 double
@@ -1997,6 +2780,14 @@ ev_view_get_zoom (EvView *view)
        return view->scale;
 }
 
        return view->scale;
 }
 
+gboolean
+ev_view_get_continuous (EvView *view)
+{
+       g_return_val_if_fail (EV_IS_VIEW (view), FALSE);
+
+       return view->continuous;
+}
+
 void
 ev_view_set_continuous (EvView   *view,
                        gboolean  continuous)
 void
 ev_view_set_continuous (EvView   *view,
                        gboolean  continuous)
@@ -2007,13 +2798,21 @@ ev_view_set_continuous (EvView   *view,
 
        if (view->continuous != continuous) {
                view->continuous = continuous;
 
        if (view->continuous != continuous) {
                view->continuous = continuous;
-               view->pending_scroll = SCROLL_TO_CURRENT_PAGE;
+               view->pending_scroll = SCROLL_TO_PAGE_POSITION;
                gtk_widget_queue_resize (GTK_WIDGET (view));
        }
 
        g_object_notify (G_OBJECT (view), "continuous");
 }
 
                gtk_widget_queue_resize (GTK_WIDGET (view));
        }
 
        g_object_notify (G_OBJECT (view), "continuous");
 }
 
+gboolean
+ev_view_get_dual_page (EvView *view)
+{
+       g_return_val_if_fail (EV_IS_VIEW (view), FALSE);
+
+       return view->dual_page;
+}
+
 void
 ev_view_set_dual_page (EvView   *view,
                       gboolean  dual_page)
 void
 ev_view_set_dual_page (EvView   *view,
                       gboolean  dual_page)
@@ -2024,8 +2823,8 @@ ev_view_set_dual_page (EvView   *view,
 
        if (view->dual_page == dual_page)
                return;
 
        if (view->dual_page == dual_page)
                return;
-    
-       view->pending_scroll = SCROLL_TO_CURRENT_PAGE;
+
+       view->pending_scroll = SCROLL_TO_PAGE_POSITION;
        view->dual_page = dual_page;
        /* FIXME: if we're keeping the pixbuf cache around, we should extend the
         * preload_cache_size to be 2 if dual_page is set.
        view->dual_page = dual_page;
        /* FIXME: if we're keeping the pixbuf cache around, we should extend the
         * preload_cache_size to be 2 if dual_page is set.
@@ -2043,11 +2842,12 @@ ev_view_set_fullscreen (EvView   *view,
 
        fullscreen = fullscreen != FALSE;
 
 
        fullscreen = fullscreen != FALSE;
 
-       if (view->fullscreen != fullscreen) {
-               view->fullscreen = fullscreen;
-               gtk_widget_queue_resize (GTK_WIDGET (view));
-       }
-
+       if (view->fullscreen == fullscreen) 
+               return;
+               
+       view->fullscreen = fullscreen;
+       gtk_widget_queue_resize (GTK_WIDGET (view));
+       
        g_object_notify (G_OBJECT (view), "fullscreen");
 }
 
        g_object_notify (G_OBJECT (view), "fullscreen");
 }
 
@@ -2071,7 +2871,9 @@ ev_view_set_presentation (EvView   *view,
                return;
 
        view->presentation = presentation;
                return;
 
        view->presentation = presentation;
+       view->pending_scroll = SCROLL_TO_PAGE_POSITION;
        gtk_widget_queue_resize (GTK_WIDGET (view));
        gtk_widget_queue_resize (GTK_WIDGET (view));
+
        if (GTK_WIDGET_REALIZED (view)) {
                if (view->presentation)
                        gdk_window_set_background (GTK_WIDGET(view)->window,
        if (GTK_WIDGET_REALIZED (view)) {
                if (view->presentation)
                        gdk_window_set_background (GTK_WIDGET(view)->window,
@@ -2104,7 +2906,7 @@ ev_view_set_sizing_mode (EvView       *view,
 
        view->sizing_mode = sizing_mode;
        gtk_widget_queue_resize (GTK_WIDGET (view));
 
        view->sizing_mode = sizing_mode;
        gtk_widget_queue_resize (GTK_WIDGET (view));
-       
+
        g_object_notify (G_OBJECT (view), "sizing-mode");
 }
 
        g_object_notify (G_OBJECT (view), "sizing-mode");
 }
 
@@ -2132,7 +2934,7 @@ void
 ev_view_zoom_in (EvView *view)
 {
        g_return_if_fail (view->sizing_mode == EV_SIZING_FREE);
 ev_view_zoom_in (EvView *view)
 {
        g_return_if_fail (view->sizing_mode == EV_SIZING_FREE);
-       
+
        view->pending_scroll = SCROLL_TO_CENTER;
        ev_view_set_zoom (view, ZOOM_IN_FACTOR, TRUE);
 }
        view->pending_scroll = SCROLL_TO_CENTER;
        ev_view_set_zoom (view, ZOOM_IN_FACTOR, TRUE);
 }
@@ -2146,6 +2948,52 @@ ev_view_zoom_out (EvView *view)
        ev_view_set_zoom (view, ZOOM_OUT_FACTOR, TRUE);
 }
 
        ev_view_set_zoom (view, ZOOM_OUT_FACTOR, TRUE);
 }
 
+void
+ev_view_rotate_right (EvView *view)
+{
+       int rotation = view->rotation + 90;
+
+       if (rotation >= 360) {
+               rotation -= 360;
+       }
+
+       ev_view_set_rotation (view, rotation);
+}
+
+void
+ev_view_rotate_left (EvView *view)
+{
+       int rotation = view->rotation - 90;
+
+       if (rotation < 0) {
+               rotation += 360;
+       }
+
+       ev_view_set_rotation (view, rotation);
+}
+
+void
+ev_view_set_rotation (EvView *view, int rotation)
+{
+       view->rotation = rotation;
+
+       if (view->pixbuf_cache) {
+               ev_pixbuf_cache_clear (view->pixbuf_cache);
+               gtk_widget_queue_resize (GTK_WIDGET (view));
+       }
+
+       if (rotation != 0)
+               clear_selection (view);
+
+       g_object_notify (G_OBJECT (view), "rotation");
+}
+
+int
+ev_view_get_rotation (EvView *view)
+{
+       return view->rotation;
+}
+
 static double
 zoom_for_size_fit_width (int doc_width,
                         int doc_height,
 static double
 zoom_for_size_fit_width (int doc_width,
                         int doc_height,
@@ -2163,6 +3011,23 @@ zoom_for_size_fit_width (int doc_width,
        return scale;
 }
 
        return scale;
 }
 
+static double
+zoom_for_size_fit_height (int doc_width,
+                         int doc_height,
+                         int target_width,
+                         int target_height,
+                         int vsb_height)
+{
+       double scale;
+
+       scale = (double)target_height / doc_height;
+
+       if (doc_width * scale > target_width)
+               scale = (double) (target_height - vsb_height) / doc_height;
+
+       return scale;
+}
+
 static double
 zoom_for_size_best_fit (int doc_width,
                        int doc_height,
 static double
 zoom_for_size_best_fit (int doc_width,
                        int doc_height,
@@ -2196,6 +3061,7 @@ ev_view_zoom_for_size_presentation (EvView *view,
 
        ev_page_cache_get_size (view->page_cache,
                                view->current_page,
 
        ev_page_cache_get_size (view->page_cache,
                                view->current_page,
+                               view->rotation,
                                1.0,
                                &doc_width,
                                &doc_height);
                                1.0,
                                &doc_width,
                                &doc_height);
@@ -2214,12 +3080,14 @@ ev_view_zoom_for_size_continuous_and_dual_page (EvView *view,
        GtkBorder border;
        gdouble scale;
 
        GtkBorder border;
        gdouble scale;
 
-       ev_page_cache_get_max_width_size (view->page_cache,
-                                         1.0,
-                                         &doc_width, NULL);
-       ev_page_cache_get_max_height_size (view->page_cache,
-                                          1.0,
-                                          NULL, &doc_height);
+       ev_page_cache_get_max_width (view->page_cache,
+                                    view->rotation,
+                                    1.0,
+                                    &doc_width);
+       ev_page_cache_get_max_height (view->page_cache,
+                                     view->rotation,
+                                     1.0,
+                                     &doc_height);
        compute_border (view, doc_width, doc_height, &border);
 
        doc_width = doc_width * 2;
        compute_border (view, doc_width, doc_height, &border);
 
        doc_width = doc_width * 2;
@@ -2250,12 +3118,14 @@ ev_view_zoom_for_size_continuous (EvView *view,
        GtkBorder border;
        gdouble scale;
 
        GtkBorder border;
        gdouble scale;
 
-       ev_page_cache_get_max_width_size (view->page_cache,
-                                         1.0,
-                                         &doc_width, NULL);
-       ev_page_cache_get_max_height_size (view->page_cache,
-                                          1.0,
-                                          NULL, &doc_height);
+       ev_page_cache_get_max_width (view->page_cache,
+                                    view->rotation,
+                                    1.0,
+                                    &doc_width);
+       ev_page_cache_get_max_height (view->page_cache,
+                                     view->rotation,
+                                     1.0,
+                                     &doc_height);
        compute_border (view, doc_width, doc_height, &border);
 
        width -= (border.left + border.right + 2 * view->spacing);
        compute_border (view, doc_width, doc_height, &border);
 
        width -= (border.left + border.right + 2 * view->spacing);
@@ -2291,6 +3161,7 @@ ev_view_zoom_for_size_dual_page (EvView *view,
        /* Find the largest of the two. */
        ev_page_cache_get_size (view->page_cache,
                                view->current_page,
        /* Find the largest of the two. */
        ev_page_cache_get_size (view->page_cache,
                                view->current_page,
+                               view->rotation,
                                1.0,
                                &doc_width, &doc_height);
 
                                1.0,
                                &doc_width, &doc_height);
 
@@ -2298,6 +3169,7 @@ ev_view_zoom_for_size_dual_page (EvView *view,
                gint width_2, height_2;
                ev_page_cache_get_size (view->page_cache,
                                        other_page,
                gint width_2, height_2;
                ev_page_cache_get_size (view->page_cache,
                                        other_page,
+                                       view->rotation,
                                        1.0,
                                        &width_2, &height_2);
                if (width_2 > doc_width)
                                        1.0,
                                        &width_2, &height_2);
                if (width_2 > doc_width)
@@ -2334,6 +3206,7 @@ ev_view_zoom_for_size_single_page (EvView *view,
 
        ev_page_cache_get_size (view->page_cache,
                                view->current_page,
 
        ev_page_cache_get_size (view->page_cache,
                                view->current_page,
+                               view->rotation,
                                1.0,
                                &doc_width,
                                &doc_height);
                                1.0,
                                &doc_width,
                                &doc_height);
@@ -2359,7 +3232,7 @@ ev_view_set_zoom_for_size (EvView *view,
                           int     height,
                           int     vsb_width,
                           int     hsb_height)
                           int     height,
                           int     vsb_width,
                           int     hsb_height)
-{      
+{
        g_return_if_fail (view->sizing_mode == EV_SIZING_FIT_WIDTH ||
                          view->sizing_mode == EV_SIZING_BEST_FIT);
        g_return_if_fail (width >= 0);
        g_return_if_fail (view->sizing_mode == EV_SIZING_FIT_WIDTH ||
                          view->sizing_mode == EV_SIZING_BEST_FIT);
        g_return_if_fail (width >= 0);
@@ -2423,10 +3296,8 @@ update_find_status_message (EvView *view)
        } else {
                double percent;
 
        } else {
                double percent;
 
-               ev_document_doc_mutex_lock ();
                percent = ev_document_find_get_progress
                                (EV_DOCUMENT_FIND (view->document));
                percent = ev_document_find_get_progress
                                (EV_DOCUMENT_FIND (view->document));
-               ev_document_doc_mutex_unlock ();
                if (percent >= (1.0 - 1e-10)) {
                        message = g_strdup (_("Not found"));
                } else {
                if (percent >= (1.0 - 1e-10)) {
                        message = g_strdup (_("Not found"));
                } else {
@@ -2436,6 +3307,7 @@ update_find_status_message (EvView *view)
 
        }
        ev_view_set_find_status (view, message);
 
        }
        ev_view_set_find_status (view, message);
+       g_free (message);
 }
 
 const char *
 }
 
 const char *
@@ -2467,15 +3339,11 @@ jump_to_find_result (EvView *view)
        int n_results;
        int page = view->find_page;
 
        int n_results;
        int page = view->find_page;
 
-       ev_document_doc_mutex_lock ();
        n_results = ev_document_find_get_n_results (find, page);
        n_results = ev_document_find_get_n_results (find, page);
-       ev_document_doc_mutex_unlock ();
 
 
-       if (n_results > view->find_result) {
-               ev_document_doc_mutex_lock ();
+       if (n_results > 0  && view->find_result < n_results) {
                ev_document_find_get_result
                        (find, page, view->find_result, &rect);
                ev_document_find_get_result
                        (find, page, view->find_result, &rect);
-               ev_document_doc_mutex_unlock ();
 
                doc_rect_to_view_rect (view, page, &rect, &view_rect);
                ensure_rectangle_is_visible (view, &view_rect);
 
                doc_rect_to_view_rect (view, page, &rect, &view_rect);
                ensure_rectangle_is_visible (view, &view_rect);
@@ -2483,7 +3351,7 @@ jump_to_find_result (EvView *view)
 }
 
 static void
 }
 
 static void
-jump_to_find_page (EvView *view)
+jump_to_find_page (EvView *view, EvViewFindDirection direction)
 {
        int n_pages, i;
 
 {
        int n_pages, i;
 
@@ -2492,12 +3360,19 @@ jump_to_find_page (EvView *view)
        for (i = 0; i < n_pages; i++) {
                int has_results;
                int page;
        for (i = 0; i < n_pages; i++) {
                int has_results;
                int page;
+               
+               if (direction == EV_VIEW_FIND_NEXT)
+                       page = view->find_page + i;
+               else
+                       page = view->find_page - i;
+
 
 
-               page = i + view->find_page;
                if (page >= n_pages) {
                        page = page - n_pages;
                }
                if (page >= n_pages) {
                        page = page - n_pages;
                }
-
+               if (page < 0) 
+                       page = page + n_pages;
+               
                has_results = ev_document_find_page_has_results
                                (EV_DOCUMENT_FIND (view->document), page);
                if (has_results == -1) {
                has_results = ev_document_find_page_has_results
                                (EV_DOCUMENT_FIND (view->document), page);
                if (has_results == -1) {
@@ -2505,7 +3380,6 @@ jump_to_find_page (EvView *view)
                        break;
                } else if (has_results == 1) {
                        ev_page_cache_set_current_page (view->page_cache, page);
                        break;
                } else if (has_results == 1) {
                        ev_page_cache_set_current_page (view->page_cache, page);
-                       jump_to_find_result (view);
                        break;
                }
        }
                        break;
                }
        }
@@ -2514,44 +3388,43 @@ jump_to_find_page (EvView *view)
 gboolean
 ev_view_can_find_next (EvView *view)
 {
 gboolean
 ev_view_can_find_next (EvView *view)
 {
-       int n_results = 0;
-
        if (EV_IS_DOCUMENT_FIND (view->document)) {
                EvDocumentFind *find = EV_DOCUMENT_FIND (view->document);
        if (EV_IS_DOCUMENT_FIND (view->document)) {
                EvDocumentFind *find = EV_DOCUMENT_FIND (view->document);
+               int i, n_pages;
 
 
-               ev_document_doc_mutex_lock ();
-               n_results = ev_document_find_get_n_results (find, view->current_page);
-               ev_document_doc_mutex_unlock ();
+               n_pages = ev_page_cache_get_n_pages (view->page_cache);
+               for (i = 0; i < n_pages; i++) {
+                       if (ev_document_find_get_n_results (find, i) > 0) {
+                               return TRUE;
+                       }
+               }
        }
 
        }
 
-       return n_results > 0;
+       return FALSE;
 }
 
 void
 ev_view_find_next (EvView *view)
 {
 }
 
 void
 ev_view_find_next (EvView *view)
 {
-       EvPageCache *page_cache;
        int n_results, n_pages;
        EvDocumentFind *find = EV_DOCUMENT_FIND (view->document);
 
        int n_results, n_pages;
        EvDocumentFind *find = EV_DOCUMENT_FIND (view->document);
 
-       page_cache = ev_document_get_page_cache (view->document);
-       ev_document_doc_mutex_lock ();
        n_results = ev_document_find_get_n_results (find, view->current_page);
        n_results = ev_document_find_get_n_results (find, view->current_page);
-       ev_document_doc_mutex_unlock ();
 
 
-       n_pages = ev_page_cache_get_n_pages (page_cache);
+       n_pages = ev_page_cache_get_n_pages (view->page_cache);
 
        view->find_result++;
 
        if (view->find_result >= n_results) {
 
        view->find_result++;
 
        if (view->find_result >= n_results) {
+
                view->find_result = 0;
                view->find_page++;
                view->find_result = 0;
                view->find_page++;
-
                if (view->find_page >= n_pages) {
                        view->find_page = 0;
                }
 
                if (view->find_page >= n_pages) {
                        view->find_page = 0;
                }
 
-               jump_to_find_page (view);
+               jump_to_find_page (view, EV_VIEW_FIND_NEXT);
+               jump_to_find_result (view);
        } else {
                jump_to_find_result (view);
                gtk_widget_queue_draw (GTK_WIDGET (view));
        } else {
                jump_to_find_result (view);
                gtk_widget_queue_draw (GTK_WIDGET (view));
@@ -2565,25 +3438,24 @@ ev_view_find_previous (EvView *view)
        EvDocumentFind *find = EV_DOCUMENT_FIND (view->document);
        EvPageCache *page_cache;
 
        EvDocumentFind *find = EV_DOCUMENT_FIND (view->document);
        EvPageCache *page_cache;
 
-       page_cache = ev_document_get_page_cache (view->document);
+       page_cache = ev_page_cache_get (view->document);
 
 
-       ev_document_doc_mutex_lock ();
        n_results = ev_document_find_get_n_results (find, view->current_page);
        n_results = ev_document_find_get_n_results (find, view->current_page);
-       ev_document_doc_mutex_unlock ();
 
        n_pages = ev_page_cache_get_n_pages (page_cache);
 
        view->find_result--;
 
        if (view->find_result < 0) {
 
        n_pages = ev_page_cache_get_n_pages (page_cache);
 
        view->find_result--;
 
        if (view->find_result < 0) {
-               view->find_result = 0;
-               view->find_page--;
 
 
+               view->find_page--;
                if (view->find_page < 0) {
                        view->find_page = n_pages - 1;
                }
 
                if (view->find_page < 0) {
                        view->find_page = n_pages - 1;
                }
 
-               jump_to_find_page (view);
+               jump_to_find_page (view, EV_VIEW_FIND_PREV);
+               view->find_result = ev_document_find_get_n_results (find, view->current_page) - 1;
+               jump_to_find_result (view);
        } else {
                jump_to_find_result (view);
                gtk_widget_queue_draw (GTK_WIDGET (view));
        } else {
                jump_to_find_result (view);
                gtk_widget_queue_draw (GTK_WIDGET (view));
@@ -2592,22 +3464,35 @@ ev_view_find_previous (EvView *view)
 
 /*** Selections ***/
 
 
 /*** Selections ***/
 
-static void
-compute_selections (EvView *view, GdkRectangle *view_rect)
+/* compute_new_selection_rect/text calculates the area currently selected by
+ * view_rect.  each handles a different mode;
+ */
+static GList *
+compute_new_selection_rect (EvView       *view,
+                           GdkPoint     *start,
+                           GdkPoint     *stop)
 {
 {
+       GdkRectangle view_rect;
        int n_pages, i;
        int n_pages, i;
+       GList *list = NULL;
 
 
-       clear_selection (view);
+       g_assert (view->selection_mode == EV_VIEW_SELECTION_RECTANGLE);
+       
+       view_rect.x = MIN (start->x, stop->x);
+       view_rect.y = MIN (start->y, stop->y);
+       view_rect.width = MAX (start->x, stop->x) - view_rect.x;
+       view_rect.width = MAX (start->y, stop->y) - view_rect.y;
 
        n_pages = ev_page_cache_get_n_pages (view->page_cache);
 
        n_pages = ev_page_cache_get_n_pages (view->page_cache);
+
        for (i = 0; i < n_pages; i++) {
                GdkRectangle page_area;
                GtkBorder border;
        for (i = 0; i < n_pages; i++) {
                GdkRectangle page_area;
                GtkBorder border;
-
+               
                if (get_page_extents (view, i, &page_area, &border)) {
                        GdkRectangle overlap;
 
                if (get_page_extents (view, i, &page_area, &border)) {
                        GdkRectangle overlap;
 
-                       if (gdk_rectangle_intersect (&page_area, view_rect, &overlap)) {
+                       if (gdk_rectangle_intersect (&page_area, &view_rect, &overlap)) {
                                EvViewSelection *selection;
 
                                selection = g_new0 (EvViewSelection, 1);
                                EvViewSelection *selection;
 
                                selection = g_new0 (EvViewSelection, 1);
@@ -2615,18 +3500,264 @@ compute_selections (EvView *view, GdkRectangle *view_rect)
                                view_rect_to_doc_rect (view, &overlap, &page_area,
                                                       &(selection->rect));
 
                                view_rect_to_doc_rect (view, &overlap, &page_area,
                                                       &(selection->rect));
 
-                               view->selections = g_list_append
-                                               (view->selections, selection);
+                               list = g_list_append (list, selection);
+                       }
+               }
+       }
+
+       return list;
+}
+
+static gboolean
+gdk_rectangle_point_in (GdkRectangle *rectangle,
+                       GdkPoint     *point)
+{
+       return rectangle->x <= point->x &&
+               rectangle->y <= point->y &&
+               point->x < rectangle->x + rectangle->width &&
+               point->y < rectangle->y + rectangle->height;
+}
+
+static GList *
+compute_new_selection_text (EvView   *view,
+                           GdkPoint *start,
+                           GdkPoint *stop)
+{
+       int n_pages, i, first, last;
+       GList *list = NULL;
+       EvViewSelection *selection;
+       gint width, height;
+       int start_page, end_page;
+
+       g_assert (view->selection_mode == EV_VIEW_SELECTION_TEXT);
+
+       n_pages = ev_page_cache_get_n_pages (view->page_cache);
+
+       /* First figure out the range of pages the selection
+        * affects. */
+       first = n_pages;
+       last = 0;
+       if (view->continuous) {
+               start_page = 0;
+               end_page = n_pages;
+       } else if (view->dual_page) {
+               start_page = view->start_page;
+               end_page = view->end_page + 1;
+       } else {
+               start_page = view->current_page;
+               end_page = view->current_page + 1;
+       }
+
+       for (i = start_page; i < end_page; i++) {
+               GdkRectangle page_area;
+               GtkBorder border;
+               
+               get_page_extents (view, i, &page_area, &border);
+               if (gdk_rectangle_point_in (&page_area, start) || 
+                   gdk_rectangle_point_in (&page_area, stop)) {
+                       if (first == n_pages)
+                               first = i;
+                       last = i;
+               }
+
+       }
+
+
+
+       /* Now create a list of EvViewSelection's for the affected
+        * pages.  This could be an empty list, a list of just one
+        * page or a number of pages.*/
+       for (i = first; i < last + 1; i++) {
+               GdkRectangle page_area;
+               GtkBorder border;
+               GdkPoint *point;
+
+               ev_page_cache_get_size (view->page_cache, i,
+                                       view->rotation,
+                                       1.0, &width, &height);
+
+               selection = g_new0 (EvViewSelection, 1);
+               selection->page = i;
+               selection->rect.x1 = selection->rect.y1 = 0;
+               selection->rect.x2 = width;
+               selection->rect.y2 = height;
+
+               get_page_extents (view, i, &page_area, &border);
+
+               if (gdk_rectangle_point_in (&page_area, start))
+                       point = start;
+               else
+                       point = stop;
+
+               if (i == first)
+                       view_point_to_doc_point (view, point, &page_area,
+                                                &selection->rect.x1,
+                                                &selection->rect.y1);
+
+               /* If the selection is contained within just one page,
+                * make sure we don't write 'start' into both points
+                * in selection->rect. */
+               if (first == last)
+                       point = stop;
+
+               if (i == last)
+                       view_point_to_doc_point (view, point, &page_area,
+                                                &selection->rect.x2,
+                                                &selection->rect.y2);
+
+               list = g_list_append (list, selection);
+       }
+
+       return list;
+}
+
+/* This function takes the newly calculated list, and figures out which regions
+ * have changed.  It then queues a redraw approporiately.
+ */
+static void
+merge_selection_region (EvView *view,
+                       GList  *new_list)
+{
+       GList *old_list;
+       GList *new_list_ptr, *old_list_ptr;
+
+       /* Update the selection */
+       old_list = ev_pixbuf_cache_get_selection_list (view->pixbuf_cache);
+       g_list_foreach (view->selection_info.selections, (GFunc)selection_free, NULL);
+       view->selection_info.selections = new_list;
+       ev_pixbuf_cache_set_selection_list (view->pixbuf_cache, new_list);
+       g_object_notify (G_OBJECT (view), "has-selection");
+
+       new_list_ptr = new_list;
+       old_list_ptr = old_list;
+
+       while (new_list_ptr || old_list_ptr) {
+               EvViewSelection *old_sel, *new_sel;
+               int cur_page;
+               GdkRegion *region = NULL;
+
+               new_sel = (new_list_ptr) ? (new_list_ptr->data) : NULL;
+               old_sel = (old_list_ptr) ? (old_list_ptr->data) : NULL;
+
+               /* Assume that the lists are in order, and we run through them
+                * comparing them, one page at a time.  We come out with the
+                * first page we see. */
+               if (new_sel && old_sel) {
+                       if (new_sel->page < old_sel->page) {
+                               new_list_ptr = new_list_ptr->next;
+                               old_sel = NULL;
+                       } else if (new_sel->page > old_sel->page) {
+                               old_list_ptr = old_list_ptr->next;
+                               new_sel = NULL;
+                       } else {
+                               new_list_ptr = new_list_ptr->next;
+                               old_list_ptr = old_list_ptr->next;
+                       }
+               } else if (new_sel) {
+                       new_list_ptr = new_list_ptr->next;
+               } else if (old_sel) {
+                       old_list_ptr = old_list_ptr->next;
+               }
+
+               g_assert (new_sel || old_sel);
+
+               /* is the page we're looking at on the screen?*/
+               cur_page = new_sel ? new_sel->page : old_sel->page;
+               if (cur_page < view->start_page || cur_page > view->end_page)
+                       continue;
+
+               /* seed the cache with a new page.  We are going to need the new
+                * region too. */
+               if (new_sel) {
+                       GdkRegion *tmp_region = NULL;
+                       ev_pixbuf_cache_get_selection_pixbuf (view->pixbuf_cache,
+                                                             cur_page,
+                                                             view->scale,
+                                                             &tmp_region);
+                       if (tmp_region) {
+                               new_sel->covered_region = gdk_region_copy (tmp_region);
                        }
                }
                        }
                }
+
+               /* Now we figure out what needs redrawing */
+               if (old_sel && new_sel) {
+                       if (old_sel->covered_region &&
+                           new_sel->covered_region) {
+                               /* We only want to redraw the areas that have
+                                * changed, so we xor the old and new regions
+                                * and redraw if it's different */
+                               region = gdk_region_copy (old_sel->covered_region);
+                               gdk_region_xor (region, new_sel->covered_region);
+                               if (gdk_region_empty (region)) {
+                                       gdk_region_destroy (region);
+                                       region = NULL;
+                               }
+                       } else if (old_sel->covered_region) {
+                               region = gdk_region_copy (old_sel->covered_region);
+                       } else if (new_sel->covered_region) {
+                               region = gdk_region_copy (new_sel->covered_region);
+                       }
+               } else if (old_sel && !new_sel) {
+                       if (old_sel->covered_region && !gdk_region_empty (old_sel->covered_region)) {
+                               region = gdk_region_copy (old_sel->covered_region);
+                       }
+               } else if (!old_sel && new_sel) {
+                       if (new_sel->covered_region && !gdk_region_empty (new_sel->covered_region)) {
+                               region = gdk_region_copy (new_sel->covered_region);
+                       }
+               } else {
+                       g_assert_not_reached ();
+               }
+
+               /* Redraw the damaged region! */
+               if (region) {
+                       GdkRectangle page_area;
+                       GtkBorder border;
+
+                       get_page_extents (view, cur_page, &page_area, &border);
+                       gdk_region_offset (region,
+                                          page_area.x + border.left - view->scroll_x,
+                                          page_area.y + border.top - view->scroll_y);
+                       gdk_window_invalidate_region (GTK_WIDGET (view)->window, region, TRUE);
+                       gdk_region_destroy (region);
+               }
        }
        }
+
+       /* Free the old list, now that we're done with it. */
+       g_list_foreach (old_list, (GFunc) selection_free, NULL);
+}
+
+static void
+compute_selections (EvView   *view,
+                   GdkPoint *start,
+                   GdkPoint *stop)
+{
+       GList *list;
+
+       if (view->selection_mode == EV_VIEW_SELECTION_RECTANGLE)
+               list = compute_new_selection_rect (view, start, stop);
+       else
+               list = compute_new_selection_text (view, start, stop);
+       merge_selection_region (view, list);
+}
+
+/* Free's the selection.  It's up to the caller to queue redraws if needed.
+ */
+static void
+selection_free (EvViewSelection *selection)
+{
+       if (selection->covered_region)
+               gdk_region_destroy (selection->covered_region);
+       g_free (selection);
 }
 
 static void
 clear_selection (EvView *view)
 {
 }
 
 static void
 clear_selection (EvView *view)
 {
-       g_list_foreach (view->selections, (GFunc)g_free, NULL);
-       view->selections = NULL;
+       g_list_foreach (view->selection_info.selections, (GFunc)selection_free, NULL);
+       view->selection_info.selections = NULL;
+       view->selection_info.in_selection = FALSE;
+       g_object_notify (G_OBJECT (view), "has-selection");
 }
 
 
 }
 
 
@@ -2635,6 +3766,10 @@ ev_view_select_all (EvView *view)
 {
        int n_pages, i;
 
 {
        int n_pages, i;
 
+       /* Disable selection on rotated pages for the 0.4.0 series */
+       if (view->rotation != 0)
+               return;
+
        clear_selection (view);
 
        n_pages = ev_page_cache_get_n_pages (view->page_cache);
        clear_selection (view);
 
        n_pages = ev_page_cache_get_n_pages (view->page_cache);
@@ -2643,7 +3778,9 @@ ev_view_select_all (EvView *view)
                EvViewSelection *selection;
 
                ev_page_cache_get_size (view->page_cache,
                EvViewSelection *selection;
 
                ev_page_cache_get_size (view->page_cache,
-                                       i, 1.0, &width, &height);
+                                       i,
+                                       view->rotation,
+                                       1.0, &width, &height);
 
                selection = g_new0 (EvViewSelection, 1);
                selection->page = i;
 
                selection = g_new0 (EvViewSelection, 1);
                selection->page = i;
@@ -2651,12 +3788,20 @@ ev_view_select_all (EvView *view)
                selection->rect.x2 = width;
                selection->rect.y2 = height;
 
                selection->rect.x2 = width;
                selection->rect.y2 = height;
 
-               view->selections = g_list_append (view->selections, selection);
+               view->selection_info.selections = g_list_append (view->selection_info.selections, selection);
        }
 
        }
 
+       ev_pixbuf_cache_set_selection_list (view->pixbuf_cache, view->selection_info.selections);
+       g_object_notify (G_OBJECT (view), "has-selection");
        gtk_widget_queue_draw (GTK_WIDGET (view));
 }
 
        gtk_widget_queue_draw (GTK_WIDGET (view));
 }
 
+gboolean
+ev_view_get_has_selection (EvView *view)
+{
+       return view->selection_info.selections != NULL;
+}
+
 static char *
 get_selected_text (EvView *ev_view)
 {
 static char *
 get_selected_text (EvView *ev_view)
 {
@@ -2667,7 +3812,7 @@ get_selected_text (EvView *ev_view)
 
        ev_document_doc_mutex_lock ();
 
 
        ev_document_doc_mutex_lock ();
 
-       for (l = ev_view->selections; l != NULL; l = l->next) {
+       for (l = ev_view->selection_info.selections; l != NULL; l = l->next) {
                EvViewSelection *selection = (EvViewSelection *)l->data;
                char *tmp;
 
                EvViewSelection *selection = (EvViewSelection *)l->data;
                char *tmp;
 
@@ -2735,7 +3880,7 @@ ev_view_update_primary_selection (EvView *ev_view)
        clipboard = gtk_widget_get_clipboard (GTK_WIDGET (ev_view),
                                               GDK_SELECTION_PRIMARY);
 
        clipboard = gtk_widget_get_clipboard (GTK_WIDGET (ev_view),
                                               GDK_SELECTION_PRIMARY);
 
-       if (ev_view->selections) {
+       if (ev_view->selection_info.selections) {
                if (!gtk_clipboard_set_with_owner (clipboard,
                                                   targets,
                                                   G_N_ELEMENTS (targets),
                if (!gtk_clipboard_set_with_owner (clipboard,
                                                   targets,
                                                   G_N_ELEMENTS (targets),
@@ -2782,6 +3927,9 @@ ev_view_set_cursor (EvView *view, EvViewCursor new_cursor)
                case EV_VIEW_CURSOR_NORMAL:
                        gdk_window_set_cursor (widget->window, NULL);
                        break;
                case EV_VIEW_CURSOR_NORMAL:
                        gdk_window_set_cursor (widget->window, NULL);
                        break;
+               case EV_VIEW_CURSOR_IBEAM:
+                       cursor = gdk_cursor_new_for_display (display, GDK_XTERM);
+                       break;
                case EV_VIEW_CURSOR_LINK:
                        cursor = gdk_cursor_new_for_display (display, GDK_HAND2);
                        break;
                case EV_VIEW_CURSOR_LINK:
                        cursor = gdk_cursor_new_for_display (display, GDK_HAND2);
                        break;
@@ -2815,6 +3963,48 @@ ev_view_show_cursor (EvView *view)
        ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
 }
 
        ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
 }
 
+gboolean
+ev_view_next_page (EvView *view)
+{
+       int page;
+
+       g_return_val_if_fail (EV_IS_VIEW (view), FALSE);
+
+       page = ev_page_cache_get_current_page (view->page_cache);
+       page = ev_view_get_dual_page (view) ? page + 2 : page + 1;
+
+       if (page < ev_page_cache_get_n_pages (view->page_cache)) {
+               ev_page_cache_set_current_page (view->page_cache, page);
+               return TRUE;
+       } else if (ev_view_get_dual_page (view) && page == ev_page_cache_get_n_pages (view->page_cache)) {
+               ev_page_cache_set_current_page (view->page_cache, page - 1);
+               return TRUE;
+       } else {
+               return FALSE;
+       }
+}
+
+gboolean
+ev_view_previous_page (EvView *view)
+{
+       int page;
+
+       g_return_val_if_fail (EV_IS_VIEW (view), FALSE);
+
+       page = ev_page_cache_get_current_page (view->page_cache);
+       page = ev_view_get_dual_page (view) ? page - 2 : page - 1;
+
+       if (page >= 0) {
+               ev_page_cache_set_current_page (view->page_cache, page);
+               return TRUE;
+       } else if (ev_view_get_dual_page (view) && page == -1) {
+               ev_page_cache_set_current_page (view->page_cache, 0);
+               return TRUE;
+       } else {        
+               return FALSE;
+       }
+}
+
 /*** Enum description for usage in signal ***/
 
 GType
 /*** Enum description for usage in signal ***/
 
 GType
@@ -2832,4 +4022,3 @@ ev_sizing_mode_get_type (void)
   }
   return etype;
 }
   }
   return etype;
 }
-