*** empty log message ***

[evince.git] / shell / ev-view.c

diff --git a/shell/ev-view.c b/shell/ev-view.c
index 4ea0fce268ad555d6e3e330a46f9cc88d594dffc..8e494adedc1a527007b1860ddb634a725c1dc06a 100644 (file)
--- a/shell/ev-view.c
+++ b/shell/ev-view.c
@@ -29,6 +29,7 @@
 
 #include "ev-marshal.h"
 #include "ev-view.h"
 
 #include "ev-marshal.h"
 #include "ev-view.h"

+#include "ev-selection.h"

 #include "ev-document-find.h"
 #include "ev-document-misc.h"
 #include "ev-debug.h"
 #include "ev-document-find.h"
 #include "ev-document-misc.h"
 #include "ev-debug.h"


@@ -53,7 +54,7 @@ enum {
 };
 
 enum {
 };
 
 enum {

-       SIGNAL_SCROLL_VIEW,
+       SIGNAL_BINDING_ACTIVATED,

        SIGNAL_ZOOM_INVALID,
        N_SIGNALS,
 };
        SIGNAL_ZOOM_INVALID,
        N_SIGNALS,
 };


@@ -77,6 +78,7 @@ static guint signals[N_SIGNALS];
 
 typedef enum {
        EV_VIEW_CURSOR_NORMAL,
 
 typedef enum {
        EV_VIEW_CURSOR_NORMAL,

+       EV_VIEW_CURSOR_IBEAM,

        EV_VIEW_CURSOR_LINK,
        EV_VIEW_CURSOR_WAIT,
        EV_VIEW_CURSOR_HIDDEN,
        EV_VIEW_CURSOR_LINK,
        EV_VIEW_CURSOR_WAIT,
        EV_VIEW_CURSOR_HIDDEN,


@@ -89,18 +91,21 @@ typedef enum {
 #define MIN_SCALE 0.05409
 #define MAX_SCALE 4.0
 
 #define MIN_SCALE 0.05409
 #define MAX_SCALE 4.0
 

+/* Information for middle clicking and moving around the doc */

 typedef struct {
 typedef struct {

-       EvRectangle rect;
-       int page;
-} EvViewSelection;
-
-typedef struct {
-        gboolean dragging;
+        gboolean in_drag;

        GdkPoint start;
        gdouble hadj;
        gdouble vadj;
 } DragInfo;
 
        GdkPoint start;
        gdouble hadj;
        gdouble vadj;
 } DragInfo;
 

+/* Information for handling selection */
+typedef struct {
+       gboolean in_selection;
+       GdkPoint start;
+       GList *selections;
+} SelectionInfo;
+

 typedef enum {
        SCROLL_TO_KEEP_POSITION,
        SCROLL_TO_CURRENT_PAGE,
 typedef enum {
        SCROLL_TO_KEEP_POSITION,
        SCROLL_TO_CURRENT_PAGE,


@@ -118,10 +123,14 @@ struct _EvView {
        gint scroll_x;
        gint scroll_y;
 
        gint scroll_x;
        gint scroll_y;
 

+       /* Information for middle clicking and dragging around. */

        DragInfo drag_info;
        DragInfo drag_info;

+
+       /* Selection */
+       EvViewSelectionMode selection_mode;
+       SelectionInfo selection_info;
+

        gboolean pressed_button;
        gboolean pressed_button;

-       GdkPoint selection_start;
-       GList *selections;

        EvViewCursor cursor;
 
        GtkAdjustment *hadjustment;
        EvViewCursor cursor;
 
        GtkAdjustment *hadjustment;


@@ -141,14 +150,13 @@ struct _EvView {
        int spacing;
 
        double scale;
        int spacing;
 
        double scale;

-       GtkBorder border;

 
        gboolean continuous;
        gboolean dual_page;
        gboolean fullscreen;
        gboolean presentation;
        EvSizingMode sizing_mode;
 
        gboolean continuous;
        gboolean dual_page;
        gboolean fullscreen;
        gboolean presentation;
        EvSizingMode sizing_mode;

-       
+

        PendingScroll pending_scroll;
        gboolean pending_resize;
 };
        PendingScroll pending_scroll;
        gboolean pending_resize;
 };


@@ -159,13 +167,15 @@ struct _EvViewClass {
        void    (*set_scroll_adjustments) (EvView         *view,
                                           GtkAdjustment  *hadjustment,
                                           GtkAdjustment  *vadjustment);
        void    (*set_scroll_adjustments) (EvView         *view,
                                           GtkAdjustment  *hadjustment,
                                           GtkAdjustment  *vadjustment);

-       void    (*scroll_view)            (EvView         *view,
+       void    (*binding_activated)      (EvView         *view,

                                           GtkScrollType   scroll,
                                           gboolean        horizontal);
        void    (*zoom_invalid)           (EvView         *view);
 };
 
 /*** Scrolling ***/
                                           GtkScrollType   scroll,
                                           gboolean        horizontal);
        void    (*zoom_invalid)           (EvView         *view);
 };
 
 /*** Scrolling ***/

+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       ev_view_set_scroll_adjustments             (EvView             *view,
                                                              GtkAdjustment      *hadjustment,
                                                              GtkAdjustment      *vadjustment);


@@ -180,7 +190,7 @@ static void       add_scroll_binding_keypad                  (GtkBindingSet
                                                              guint               keyval,
                                                              GtkScrollType       scroll,
                                                              gboolean            horizontal);
                                                              guint               keyval,
                                                              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,


@@ -191,6 +201,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,


@@ -203,9 +217,6 @@ 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,
 static void       find_page_at_location                      (EvView             *view,
                                                              gdouble             x,
                                                              gdouble             y,


@@ -340,7 +351,8 @@ static void       jump_to_find_page                          (EvView
 
 /*** 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 char*      get_selected_text                          (EvView             *ev_view);
 static void       ev_view_primary_get_cb                     (GtkClipboard       *clipboard,
 static void       clear_selection                            (EvView             *view);
 static char*      get_selected_text                          (EvView             *ev_view);
 static void       ev_view_primary_get_cb                     (GtkClipboard       *clipboard,


@@ -351,46 +363,40 @@ 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
 scroll_to_current_page (EvView *view, GtkOrientation orientation)
 {
 G_DEFINE_TYPE (EvView, ev_view, GTK_TYPE_WIDGET)
 
 static void
 scroll_to_current_page (EvView *view, GtkOrientation orientation)
 {

-       int max_width, max_height, n_rows;
-       
-       get_bounding_box_size (view, &max_width, &max_height);
-       
-       if (orientation == GTK_ORIENTATION_VERTICAL) {  
-               if (view->continuous) {
-                       n_rows = view->dual_page ? view->current_page / 2 : view->current_page;
+       GdkRectangle page_area;
+       GtkBorder border;
+
+       if (view->document == NULL) {
+               return;
+       }
+
+       get_page_extents (view, view->current_page, &page_area, &border);

 
 

+       if (orientation == GTK_ORIENTATION_VERTICAL) {
+               if (view->continuous) {

                        gtk_adjustment_clamp_page (view->vadjustment,
                        gtk_adjustment_clamp_page (view->vadjustment,

-                                                  (max_height + view->spacing) * n_rows,
-                                                  (max_height + view->spacing) * n_rows +
-                                                  view->vadjustment->page_size);
+                                                  page_area.y - view->spacing,
+                                                  page_area.y + view->vadjustment->page_size);

                } else {
                        gtk_adjustment_set_value (view->vadjustment,
                                                  view->vadjustment->lower);
                }
        } else {
                if (view->dual_page) {
                } else {
                        gtk_adjustment_set_value (view->vadjustment,
                                                  view->vadjustment->lower);
                }
        } else {
                if (view->dual_page) {

-                       if (view->current_page % 2 == 0) {
-                               gtk_adjustment_set_value (view->hadjustment,
-                                                         view->hadjustment->lower);
-                       } else {
-                               gtk_adjustment_clamp_page (view->hadjustment,
-                                                          view->hadjustment->lower + 
-                                                          max_width + view->spacing, 
-                                                          view->hadjustment->lower +
-                                                          max_width + view->spacing +
-                                                          view->hadjustment->page_size);
-                       }
+                       gtk_adjustment_clamp_page (view->hadjustment,
+                                                  page_area.x,
+                                                  page_area.x + view->hadjustment->page_size);

                } else {
                        gtk_adjustment_set_value (view->hadjustment,
                } else {
                        gtk_adjustment_set_value (view->hadjustment,

-                                                 CLAMP (view->hadjustment->value, 
+                                                 CLAMP (view->hadjustment->value,

                                                  view->hadjustment->lower,
                                                  view->hadjustment->lower,

-                                                 view->hadjustment->upper - 
+                                                 view->hadjustment->upper -

                                                  view->hadjustment->page_size));
                }
        }
                                                  view->hadjustment->page_size));
                }
        }


@@ -420,15 +426,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: 
+               case SCROLL_TO_KEEP_POSITION:

                        factor = (adjustment->value) / adjustment->upper;
                        break;
                        factor = (adjustment->value) / adjustment->upper;
                        break;

-               case SCROLL_TO_CURRENT_PAGE: 
+               case SCROLL_TO_CURRENT_PAGE:

                        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;
        }


@@ -439,18 +445,18 @@ 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) {
         * We add 0.5 to the values before to average out our rounding errors.
         */
        switch (view->pending_scroll) {

-               case SCROLL_TO_KEEP_POSITION: 
+               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;
                        new_value = CLAMP (adjustment->upper * factor + 0.5, 0, adjustment->upper - adjustment->page_size);
                        gtk_adjustment_set_value (adjustment, (int)new_value);
                        break;

-               case SCROLL_TO_CURRENT_PAGE: 
+               case SCROLL_TO_CURRENT_PAGE:

                        scroll_to_current_page (view, orientation);
                        break;
                        scroll_to_current_page (view, orientation);
                        break;

-               case SCROLL_TO_CENTER: 
+               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);
                        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);


@@ -469,51 +475,33 @@ view_update_range_and_current_page (EvView *view)
                view->end_page = view->current_page;
        } else if (view->continuous) {
                GdkRectangle current_area, unused, page_area;
                view->end_page = view->current_page;
        } else if (view->continuous) {
                GdkRectangle current_area, unused, page_area;

+               GtkBorder border;

                gint current_page;
                gboolean found = FALSE;
                int i;
                gint current_page;
                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);
                }
 
                current_page = ev_page_cache_get_current_page (view->page_cache);


@@ -521,7 +509,7 @@ view_update_range_and_current_page (EvView *view)
                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);
                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) {
                        if (view->current_page % 2 == 0) {
        } else {
                if (view->dual_page) {
                        if (view->current_page % 2 == 0) {


@@ -541,7 +529,8 @@ view_update_range_and_current_page (EvView *view)
        ev_pixbuf_cache_set_page_range (view->pixbuf_cache,
                                        view->start_page,
                                        view->end_page,
        ev_pixbuf_cache_set_page_range (view->pixbuf_cache,
                                        view->start_page,
                                        view->end_page,

-                                       view->scale);   
+                                       view->scale,
+                                       view->selection_info.selections);

 }
 
 static void
 }
 
 static void


@@ -595,11 +584,11 @@ add_scroll_binding_keypad (GtkBindingSet  *binding_set,
   guint keypad_keyval = keyval - GDK_Left + GDK_KP_Left;
 
   gtk_binding_entry_add_signal (binding_set, keyval, 0,
   guint keypad_keyval = keyval - GDK_Left + GDK_KP_Left;
 
   gtk_binding_entry_add_signal (binding_set, keyval, 0,

-                                "scroll_view", 2,
+                                "binding_activated", 2,

                                 GTK_TYPE_SCROLL_TYPE, scroll,
                                G_TYPE_BOOLEAN, horizontal);
   gtk_binding_entry_add_signal (binding_set, keypad_keyval, 0,
                                 GTK_TYPE_SCROLL_TYPE, scroll,
                                G_TYPE_BOOLEAN, horizontal);
   gtk_binding_entry_add_signal (binding_set, keypad_keyval, 0,

-                                "scroll_view", 2,
+                                "binding_activated", 2,

                                 GTK_TYPE_SCROLL_TYPE, scroll,
                                G_TYPE_BOOLEAN, horizontal);
 }
                                 GTK_TYPE_SCROLL_TYPE, scroll,
                                G_TYPE_BOOLEAN, horizontal);
 }


@@ -659,13 +648,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_page_cache_prev_page (view->page_cache);
+                               break;
+                       case GTK_SCROLL_STEP_FORWARD:
+                               ev_page_cache_next_page (view->page_cache);
+                               break;
+                       default:
+                               break;
+               }
+               return;
+       }
+

        if (horizontal) {
                adjustment = view->hadjustment;
        } else {
        if (horizontal) {
                adjustment = view->hadjustment;
        } else {


@@ -740,6 +743,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, 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, zoom, NULL, &offset);
+               offset += (page / 2 + 1) * view->spacing + (page / 2) * (border.top + border.bottom);
+       } else {
+               ev_page_cache_get_height_to_page (view->page_cache, page, 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,


@@ -751,22 +780,6 @@ 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,
                                view->scale,
        /* Get the size of the page */
        ev_page_cache_get_size (view->page_cache, page,
                                view->scale,


@@ -779,20 +792,24 @@ 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->scale, &max_width);
+               max_width = max_width + border->left + border->right;

                /* Get the location of the bounding box */
                if (view->dual_page) {
                        x = view->spacing + (page % 2) * (max_width + view->spacing);
                /* 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 = x + MAX (0, widget->allocation.width - (max_width * 2 + view->spacing * 3)) / 2;
+                       if (page % 2 == 0)
+                               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 {


@@ -851,16 +868,27 @@ 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
 }
 
 static void


@@ -883,30 +911,6 @@ doc_rect_to_view_rect (EvView       *view,
        view_rect->height = ceil (height * view->scale);
 }
 
        view_rect->height = ceil (height * view->scale);
 }
 

-static void
-get_bounding_box_size (EvView *view, int *max_width, int *max_height)
-{
-       GtkBorder border;
-       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;
-       }
-
-
-       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;
-       }
-}
-

 static void
 find_page_at_location (EvView  *view,
                       gdouble  x,
 static void
 find_page_at_location (EvView  *view,
                       gdouble  x,


@@ -945,6 +949,28 @@ 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;
+}
+

 /*** Hyperref ***/
 static EvLink *
 get_link_at_location (EvView  *view,
 /*** Hyperref ***/
 static EvLink *
 get_link_at_location (EvView  *view,


@@ -1026,17 +1052,19 @@ status_message_from_link (EvView *view, EvLink *link)
 
 static void
 ev_view_size_request_continuous_dual_page (EvView         *view,
 
 static void
 ev_view_size_request_continuous_dual_page (EvView         *view,

-                                              GtkRequisition *requisition)
+                                          GtkRequisition *requisition)

 {
 {

-       int max_width, max_height;
-       int n_rows;
+       int max_width;
+       gint n_pages;
+       GtkBorder border;

 
 

-       get_bounding_box_size (view, &max_width, &max_height);
+       ev_page_cache_get_max_width (view->page_cache, view->scale, &max_width);
+       compute_border (view, max_width, max_width, &border);

 
 

-       n_rows = (1 + ev_page_cache_get_n_pages (view->page_cache)) / 2;
+       n_pages = ev_page_cache_get_n_pages (view->page_cache) + 1;

 
 

-       requisition->width = (max_width * 2) + (view->spacing * 3);
-       requisition->height = max_height * n_rows + (view->spacing * (n_rows + 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;


@@ -1052,15 +1080,17 @@ 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->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;


@@ -1168,15 +1198,15 @@ 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 ||
                  view->sizing_mode == EV_SIZING_BEST_FIT) {
 
                g_signal_emit (view, signals[SIGNAL_ZOOM_INVALID], 0);
        if (view->sizing_mode == EV_SIZING_FIT_WIDTH ||
                  view->sizing_mode == EV_SIZING_BEST_FIT) {
 
                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_set_adjustment_values (view, GTK_ORIENTATION_HORIZONTAL);
        view_set_adjustment_values (view, GTK_ORIENTATION_VERTICAL);
 


@@ -1184,7 +1214,7 @@ ev_view_size_allocate (GtkWidget      *widget,
        view->pending_resize = FALSE;
 
        if (view->document)
        view->pending_resize = FALSE;
 
        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);
 }


@@ -1238,13 +1268,13 @@ ev_view_unrealize (GtkWidget *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);

 
 

-       if ((event->state & GDK_CONTROL_MASK) != 0) {   
+       if ((event->state & GDK_CONTROL_MASK) != 0) {

 
 

-                ev_view_set_sizing_mode (view, EV_SIZING_FREE);         
+                ev_view_set_sizing_mode (view, EV_SIZING_FREE);

 
 

-                if (event->direction == GDK_SCROLL_UP || 
+                if (event->direction == GDK_SCROLL_UP ||

                        event->direction == GDK_SCROLL_LEFT) {
                            if (ev_view_can_zoom_in (view)) {
                                    ev_view_zoom_in (view);
                        event->direction == GDK_SCROLL_LEFT) {
                            if (ev_view_can_zoom_in (view)) {
                                    ev_view_zoom_in (view);


@@ -1252,12 +1282,12 @@ ev_view_scroll_event (GtkWidget *widget, GdkEventScroll *event)
                 } else {
                            if (ev_view_can_zoom_out (view)) {
                                    ev_view_zoom_out (view);
                 } else {
                            if (ev_view_can_zoom_out (view)) {
                                    ev_view_zoom_out (view);

-                           }   
+                           }

                 }
                 return TRUE;
        }
                 }
                 return TRUE;
        }

-       
-       if ((event->state & GDK_SHIFT_MASK) != 0) {     
+
+       if ((event->state & GDK_SHIFT_MASK) != 0) {

                if (event->direction == GDK_SCROLL_UP)
                        event->direction = GDK_SCROLL_LEFT;
                if (event->direction == GDK_SCROLL_DOWN)
                if (event->direction == GDK_SCROLL_UP)
                        event->direction = GDK_SCROLL_LEFT;
                if (event->direction == GDK_SCROLL_DOWN)


@@ -1267,13 +1297,29 @@ ev_view_scroll_event (GtkWidget *widget, GdkEventScroll *event)
        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;
 
        if (view->document == NULL)
        int i;
 
        if (view->document == NULL)


@@ -1285,26 +1331,14 @@ 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;


@@ -1324,13 +1358,13 @@ ev_view_button_press_event (GtkWidget      *widget,
 
        switch (event->button) {
                case 1:
 
        switch (event->button) {
                case 1:

-                       if (view->selections) {
+                       if (view->selection_info.selections) {

                                clear_selection (view);
                                gtk_widget_queue_draw (widget);
                        }
 
                                clear_selection (view);
                                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


@@ -1354,21 +1388,20 @@ ev_view_motion_notify_event (GtkWidget      *widget,
 {
        EvView *view = EV_VIEW (widget);
 
 {
        EvView *view = EV_VIEW (widget);
 

-       if (view->pressed_button == 1) {
-               GdkRectangle selection;
-
-               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;
+       if (!view->document)
+               return FALSE;

 
 

-               compute_selections (view, &selection);
+       if (view->pressed_button == 1) {
+               GdkPoint point;

 
 

-               gtk_widget_queue_draw (widget);
+               view->selection_info.in_selection = TRUE;
+               point.x = event->x + view->scroll_x;
+               point.y = event->y + view->scroll_y;
+               compute_selections (view, &view->selection_info.start, &point);

 
                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,


@@ -1376,10 +1409,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;
 


@@ -1403,7 +1436,7 @@ ev_view_motion_notify_event (GtkWidget      *widget,
 
                        return TRUE;
                }
 
                        return TRUE;
                }

-       } else if (view->pressed_button <= 0 && view->document) {
+       } else if (view->pressed_button <= 0) {

                EvLink *link;
 
                link = get_link_at_location (view, event->x + view->scroll_x, event->y + view->scroll_y);
                EvLink *link;
 
                link = get_link_at_location (view, event->x + view->scroll_x, event->y + view->scroll_y);


@@ -1414,11 +1447,13 @@ ev_view_motion_notify_event (GtkWidget      *widget,
                        ev_view_set_status (view, msg);
                        ev_view_set_cursor (view, EV_VIEW_CURSOR_LINK);
                        g_free (msg);
                        ev_view_set_status (view, msg);
                        ev_view_set_cursor (view, EV_VIEW_CURSOR_LINK);
                        g_free (msg);

+               } else if (location_in_text (view, event->x + view->scroll_x, event->y + view->scroll_y)) {
+                       ev_view_set_cursor (view, EV_VIEW_CURSOR_IBEAM);

                } else {
                        ev_view_set_status (view, NULL);
                } else {
                        ev_view_set_status (view, NULL);

-                       if (view->cursor == EV_VIEW_CURSOR_LINK) {
+                       if (view->cursor == EV_VIEW_CURSOR_LINK ||
+                           view->cursor == EV_VIEW_CURSOR_IBEAM)

                                ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
                                ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);

-                       }

                }
                return TRUE;
        }
                }
                return TRUE;
        }


@@ -1437,9 +1472,9 @@ ev_view_button_release_event (GtkWidget      *widget,
        }
 
        view->pressed_button = -1;
        }
 
        view->pressed_button = -1;

-       view->drag_info.dragging = FALSE;
+       view->drag_info.in_drag = FALSE;

 
 

-       if (view->selections) {
+       if (view->selection_info.selections) {

                ev_view_update_primary_selection (view);
        } else if (view->document) {
                EvLink *link;
                ev_view_update_primary_selection (view);
        } else if (view->document) {
                EvLink *link;


@@ -1473,7 +1508,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;
 


@@ -1534,22 +1569,23 @@ 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_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);
        if (! gdk_rectangle_intersect (page_area, expose_area, &overlap))
                return;
 
 
        g_assert (view->document);
        if (! gdk_rectangle_intersect (page_area, expose_area, &overlap))
                return;
 

+       selection = find_selection_for_page (view, page);

        ev_page_cache_get_size (view->page_cache,
                                page, view->scale,
                                &width, &height);
        ev_page_cache_get_size (view->page_cache,
                                page, view->scale,
                                &width, &height);


@@ -1566,8 +1602,18 @@ draw_one_page (EvView       *view,
                                         page_area, border);
 
        if (gdk_rectangle_intersect (&real_page_area, expose_area, &overlap)) {
                                         page_area, border);
 
        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);
 
                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);
+

                if (current_pixbuf == NULL)
                        scaled_image = NULL;
                else if (width == gdk_pixbuf_get_width (current_pixbuf) &&
                if (current_pixbuf == NULL)
                        scaled_image = NULL;
                else if (width == gdk_pixbuf_get_width (current_pixbuf) &&


@@ -1580,6 +1626,18 @@ draw_one_page (EvView       *view,
                                                                width, height,
                                                                GDK_INTERP_NEAREST);
 
                                                                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],
                if (scaled_image) {
                        gdk_draw_pixbuf (GTK_WIDGET(view)->window,
                                         GTK_WIDGET (view)->style->fg_gc[GTK_STATE_NORMAL],


@@ -1592,6 +1650,19 @@ draw_one_page (EvView       *view,
                                         0, 0);
                        g_object_unref (scaled_image);
                }
                                         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);
+               }

        }
 }
 
        }
 }
 


@@ -1726,9 +1797,9 @@ ev_view_class_init (EvViewClass *class)
        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,


@@ -1739,10 +1810,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,


@@ -1817,7 +1888,7 @@ ev_view_class_init (EvViewClass *class)
                                         g_param_spec_double ("zoom",
                                                              "Zoom factor",
                                                               "Zoom factor",
                                         g_param_spec_double ("zoom",
                                                              "Zoom factor",
                                                               "Zoom factor",

-                                                              MIN_SCALE, 
+                                                              MIN_SCALE,

                                                               MAX_SCALE,
                                                               1.0,
                                                               G_PARAM_READWRITE));
                                                               MAX_SCALE,
                                                               1.0,
                                                               G_PARAM_READWRITE));


@@ -1840,8 +1911,10 @@ ev_view_init (EvView *view)
        view->current_page = 0;
        view->pressed_button = -1;
        view->cursor = EV_VIEW_CURSOR_NORMAL;
        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.in_selection = 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;


@@ -1876,7 +1949,7 @@ page_changed_cb (EvPageCache *page_cache,
                 EvView      *view)
 {
        if (view->current_page != new_page) {
                 EvView      *view)
 {
        if (view->current_page != new_page) {

-               
+

                view->current_page = new_page;
                view->pending_scroll = SCROLL_TO_CURRENT_PAGE;
                gtk_widget_queue_resize (GTK_WIDGET (view));
                view->current_page = new_page;
                view->pending_scroll = SCROLL_TO_CURRENT_PAGE;
                gtk_widget_queue_resize (GTK_WIDGET (view));


@@ -1910,16 +1983,17 @@ static void on_adjustment_value_changed (GtkAdjustment  *adjustment,
        } else {
                view->scroll_y = 0;
        }
        } else {
                view->scroll_y = 0;
        }

-       
-       
-       if (view->pending_resize)       
+
+
+       if (view->pending_resize)

                gtk_widget_queue_draw (GTK_WIDGET (view));
        else
                gdk_window_scroll (GTK_WIDGET (view)->window, dx, dy);
 
 
        if (view->document)
                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);}
+               view_update_range_and_current_page (view);
+}

 
 GtkWidget*
 ev_view_new (void)
 
 GtkWidget*
 ev_view_new (void)


@@ -1931,6 +2005,28 @@ ev_view_new (void)
        return view;
 }
 
        return view;
 }
 

+static void
+setup_caches (EvView *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 (view->document);
+       g_signal_connect (view->pixbuf_cache, "job-finished", G_CALLBACK (job_finished_cb), view);
+}
+
+static void
+clear_caches (EvView *view)
+{
+       if (view->pixbuf_cache) {
+               g_object_unref (view->pixbuf_cache);
+               view->pixbuf_cache = NULL;
+       }
+
+       if (view->document) {
+               ev_page_cache_clear (view->document);
+       }
+}
+

 void
 ev_view_set_document (EvView     *view,
                      EvDocument *document)
 void
 ev_view_set_document (EvView     *view,
                      EvDocument *document)


@@ -1938,6 +2034,8 @@ ev_view_set_document (EvView     *view,
        g_return_if_fail (EV_IS_VIEW (view));
 
        if (document != view->document) {
        g_return_if_fail (EV_IS_VIEW (view));
 
        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,


@@ -1947,11 +2045,6 @@ ev_view_set_document (EvView     *view,
 
                 }
 
 
                 }
 

-               if (view->pixbuf_cache) {
-                       g_object_unref (view->pixbuf_cache);
-                       view->pixbuf_cache = NULL;
-               }
-

                view->document = document;
                view->find_page = 0;
                view->find_result = 0;
                view->document = document;
                view->find_page = 0;
                view->find_result = 0;


@@ -1964,10 +2057,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);
-                       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));


@@ -1996,7 +2087,7 @@ ev_view_set_zoom (EvView   *view,
 
        view->scale = scale;
        view->pending_resize = TRUE;
 
        view->scale = scale;
        view->pending_resize = TRUE;

-       
+

        gtk_widget_queue_resize (GTK_WIDGET (view));
 
        g_object_notify (G_OBJECT (view), "zoom");
        gtk_widget_queue_resize (GTK_WIDGET (view));
 
        g_object_notify (G_OBJECT (view), "zoom");


@@ -2008,6 +2099,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)


@@ -2025,6 +2124,14 @@ ev_view_set_continuous (EvView   *view,
        g_object_notify (G_OBJECT (view), "continuous");
 }
 
        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)


@@ -2035,7 +2142,7 @@ 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->dual_page = dual_page;
        /* FIXME: if we're keeping the pixbuf cache around, we should extend the
        view->pending_scroll = SCROLL_TO_CURRENT_PAGE;
        view->dual_page = dual_page;
        /* FIXME: if we're keeping the pixbuf cache around, we should extend the


@@ -2054,11 +2161,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");
 }
 


@@ -2082,7 +2190,9 @@ ev_view_set_presentation (EvView   *view,
                return;
 
        view->presentation = presentation;
                return;
 
        view->presentation = presentation;

+       view->pending_scroll = SCROLL_TO_CURRENT_PAGE;

        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,


@@ -2115,7 +2225,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");
 }
 


@@ -2143,7 +2253,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);
 }


@@ -2157,6 +2267,54 @@ ev_view_zoom_out (EvView *view)
        ev_view_set_zoom (view, ZOOM_OUT_FACTOR, TRUE);
 }
 
        ev_view_set_zoom (view, ZOOM_OUT_FACTOR, TRUE);
 }
 

+static void
+ev_view_set_orientation (EvView         *view,
+                        EvOrientation   orientation)
+{
+       ev_document_set_orientation (view->document, orientation);
+
+       clear_caches (view);
+       setup_caches (view);
+
+       gtk_widget_queue_resize (GTK_WIDGET (view));
+}
+
+void
+ev_view_rotate_right (EvView *view)
+{
+       EvOrientation orientation, new_orientation;
+
+       orientation = ev_document_get_orientation (view->document);
+       if (orientation == EV_ORIENTATION_PORTRAIT) {
+               new_orientation = EV_ORIENTATION_LANDSCAPE;
+       } else if (orientation == EV_ORIENTATION_LANDSCAPE) {
+               new_orientation = EV_ORIENTATION_UPSIDEDOWN;
+       } else if (orientation == EV_ORIENTATION_UPSIDEDOWN) {
+               new_orientation = EV_ORIENTATION_SEASCAPE;
+       } else {
+               new_orientation = EV_ORIENTATION_PORTRAIT;
+       }
+       ev_view_set_orientation (view, new_orientation);
+}
+
+void
+ev_view_rotate_left (EvView *view)
+{
+       EvOrientation orientation, new_orientation;
+
+       orientation = ev_document_get_orientation (view->document);
+       if (orientation == EV_ORIENTATION_PORTRAIT) {
+               new_orientation = EV_ORIENTATION_SEASCAPE;
+       } else if (orientation == EV_ORIENTATION_SEASCAPE) {
+               new_orientation = EV_ORIENTATION_UPSIDEDOWN;
+       } else if (orientation == EV_ORIENTATION_UPSIDEDOWN) {
+               new_orientation = EV_ORIENTATION_LANDSCAPE;
+       } else {
+               new_orientation = EV_ORIENTATION_PORTRAIT;
+       }
+       ev_view_set_orientation (view, new_orientation);
+}
+

 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,


@@ -2225,12 +2383,12 @@ 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,
+                                    1.0,
+                                    &doc_width);
+       ev_page_cache_get_max_height (view->page_cache,
+                                     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;


@@ -2261,12 +2419,12 @@ 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,
+                                    1.0,
+                                    &doc_width);
+       ev_page_cache_get_max_height (view->page_cache,
+                                     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);


@@ -2370,7 +2528,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);


@@ -2445,6 +2603,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 *


@@ -2537,7 +2696,7 @@ ev_view_find_next (EvView *view)
        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);
+       page_cache = ev_page_cache_get (view->document);

        n_results = ev_document_find_get_n_results (find, view->current_page);
 
        n_pages = ev_page_cache_get_n_pages (page_cache);
        n_results = ev_document_find_get_n_results (find, view->current_page);
 
        n_pages = ev_page_cache_get_n_pages (page_cache);


@@ -2566,7 +2725,7 @@ 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);

 
        n_results = ev_document_find_get_n_results (find, view->current_page);
 
 
        n_results = ev_document_find_get_n_results (find, view->current_page);
 


@@ -2591,22 +2750,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);


@@ -2614,18 +2786,148 @@ 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;
+
+       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;
+       for (i = 0; i < n_pages; 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,
+                                       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  *list)
+{
+
+       /* FIXME: actually write... */
+       clear_selection (view);
+       gtk_widget_queue_draw (GTK_WIDGET (view));
+
+       view->selection_info.selections = list;
+       ev_pixbuf_cache_set_selection_list (view->pixbuf_cache, list);
+}
+
+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)
+{
+       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;

 }
 
 
 }
 
 


@@ -2650,9 +2952,10 @@ 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);

        gtk_widget_queue_draw (GTK_WIDGET (view));
 }
 
        gtk_widget_queue_draw (GTK_WIDGET (view));
 }
 


@@ -2666,7 +2969,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;
 


@@ -2734,7 +3037,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),


@@ -2781,6 +3084,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;