shell/ev-view.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; c-indent-level: 8 -*- */
   2 /* this file is part of evince, a gnome document viewer
   3  *
   4  *  Copyright (C) 2004 Red Hat, Inc
   5  *
   6  * Evince is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Evince is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <math.h>
  22 #include <gtk/gtkalignment.h>
  23 #include <glib/gi18n.h>
  24 #include <gtk/gtkbindings.h>
  25 #include <gtk/gtkselection.h>
  26 #include <gtk/gtkclipboard.h>
  27 #include <gdk/gdkkeysyms.h>
  28 #include <libgnomevfs/gnome-vfs-utils.h>
  29
  30 #include "ev-marshal.h"
  31 #include "ev-view.h"
  32 #include "ev-selection.h"
  33 #include "ev-document-find.h"
  34 #include "ev-document-misc.h"
  35 #include "ev-debug.h"
  36 #include "ev-job-queue.h"
  37 #include "ev-page-cache.h"
  38 #include "ev-pixbuf-cache.h"
  39
  40 #define EV_VIEW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), EV_TYPE_VIEW, EvViewClass))
  41 #define EV_IS_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EV_TYPE_VIEW))
  42 #define EV_VIEW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), EV_TYPE_VIEW, EvViewClass))
  43
  44 enum {
  45         PROP_0,
  46         PROP_STATUS,
  47         PROP_FIND_STATUS,
  48         PROP_CONTINUOUS,
  49         PROP_DUAL_PAGE,
  50         PROP_FULLSCREEN,
  51         PROP_PRESENTATION,
  52         PROP_SIZING_MODE,
  53         PROP_ZOOM,
  54 };
  55
  56 enum {
  57         SIGNAL_BINDING_ACTIVATED,
  58         SIGNAL_ZOOM_INVALID,
  59         N_SIGNALS,
  60 };
  61
  62 enum {
  63         TARGET_STRING,
  64         TARGET_TEXT,
  65         TARGET_COMPOUND_TEXT,
  66         TARGET_UTF8_STRING,
  67         TARGET_TEXT_BUFFER_CONTENTS
  68 };
  69
  70 static const GtkTargetEntry targets[] = {
  71         { "STRING", 0, TARGET_STRING },
  72         { "TEXT",   0, TARGET_TEXT },
  73         { "COMPOUND_TEXT", 0, TARGET_COMPOUND_TEXT },
  74         { "UTF8_STRING", 0, TARGET_UTF8_STRING },
  75 };
  76
  77 static guint signals[N_SIGNALS];
  78
  79 typedef enum {
  80         EV_VIEW_CURSOR_NORMAL,
  81         EV_VIEW_CURSOR_LINK,
  82         EV_VIEW_CURSOR_WAIT,
  83         EV_VIEW_CURSOR_HIDDEN,
  84         EV_VIEW_CURSOR_DRAG
  85 } EvViewCursor;
  86
  87 #define ZOOM_IN_FACTOR  1.2
  88 #define ZOOM_OUT_FACTOR (1.0/ZOOM_IN_FACTOR)
  89
  90 #define MIN_SCALE 0.05409
  91 #define MAX_SCALE 4.0
  92
  93 /* Information for middle clicking and moving around the doc */
  94 typedef struct {
  95         gboolean in_drag;
  96         GdkPoint start;
  97         gdouble hadj;
  98         gdouble vadj;
  99 } DragInfo;
 100
 101 /* Information for handling selection */
 102 typedef struct {
 103         gboolean in_selection;
 104         GdkPoint start;
 105         GList *selections;
 106 } SelectionInfo;
 107
 108 typedef enum {
 109         SCROLL_TO_KEEP_POSITION,
 110         SCROLL_TO_CURRENT_PAGE,
 111         SCROLL_TO_CENTER
 112 } PendingScroll;
 113
 114 struct _EvView {
 115         GtkWidget parent_instance;
 116
 117         EvDocument *document;
 118
 119         char *status;
 120         char *find_status;
 121
 122         gint scroll_x;
 123         gint scroll_y;
 124
 125         /* Information for middle clicking and dragging around. */
 126         DragInfo drag_info;
 127
 128         /* Selection */
 129         EvViewSelectionMode selection_mode;
 130         SelectionInfo selection_info;
 131
 132         gboolean pressed_button;
 133         EvViewCursor cursor;
 134
 135         GtkAdjustment *hadjustment;
 136         GtkAdjustment *vadjustment;
 137
 138         EvPageCache *page_cache;
 139         EvPixbufCache *pixbuf_cache;
 140
 141         gint start_page;
 142         gint end_page;
 143         gint current_page;
 144
 145         EvJobRender *current_job;
 146
 147         int find_page;
 148         int find_result;
 149         int spacing;
 150
 151         double scale;
 152
 153         gboolean continuous;
 154         gboolean dual_page;
 155         gboolean fullscreen;
 156         gboolean presentation;
 157         EvSizingMode sizing_mode;
 158
 159         PendingScroll pending_scroll;
 160         gboolean pending_resize;
 161 };
 162
 163 struct _EvViewClass {
 164         GtkWidgetClass parent_class;
 165
 166         void    (*set_scroll_adjustments) (EvView         *view,
 167                                            GtkAdjustment  *hadjustment,
 168                                            GtkAdjustment  *vadjustment);
 169         void    (*binding_activated)      (EvView         *view,
 170                                            GtkScrollType   scroll,
 171                                            gboolean        horizontal);
 172         void    (*zoom_invalid)           (EvView         *view);
 173 };
 174
 175 /*** Scrolling ***/
 176 static void       scroll_to_current_page                     (EvView *view,
 177                                                               GtkOrientation orientation);
 178 static void       ev_view_set_scroll_adjustments             (EvView             *view,
 179                                                               GtkAdjustment      *hadjustment,
 180                                                               GtkAdjustment      *vadjustment);
 181 static void       view_update_range_and_current_page         (EvView             *view);
 182 static void       set_scroll_adjustment                      (EvView             *view,
 183                                                               GtkOrientation      orientation,
 184                                                               GtkAdjustment      *adjustment);
 185 static void       ev_view_set_scroll_adjustments             (EvView             *view,
 186                                                               GtkAdjustment      *hadjustment,
 187                                                               GtkAdjustment      *vadjustment);
 188 static void       add_scroll_binding_keypad                  (GtkBindingSet      *binding_set,
 189                                                               guint               keyval,
 190                                                               GtkScrollType       scroll,
 191                                                               gboolean            horizontal);
 192 static void       ev_view_binding_activated                  (EvView             *view,
 193                                                               GtkScrollType       scroll,
 194                                                               gboolean            horizontal);
 195 static void       ensure_rectangle_is_visible                (EvView             *view,
 196                                                               GdkRectangle       *rect);
 197
 198 /*** Geometry computations ***/
 199 static void       compute_border                             (EvView             *view,
 200                                                               int                 width,
 201                                                               int                 height,
 202                                                               GtkBorder          *border);
 203 static void       get_page_y_offset                          (EvView *view,
 204                                                               int page,
 205                                                               double zoom,
 206                                                               int *y_offset);
 207 static gboolean   get_page_extents                           (EvView             *view,
 208                                                               gint                page,
 209                                                               GdkRectangle       *page_area,
 210                                                               GtkBorder          *border);
 211 static void       view_rect_to_doc_rect                      (EvView             *view,
 212                                                               GdkRectangle       *view_rect,
 213                                                               GdkRectangle       *page_area,
 214                                                               EvRectangle        *doc_rect);
 215 static void       doc_rect_to_view_rect                      (EvView             *view,
 216                                                               int                 page,
 217                                                               EvRectangle        *doc_rect,
 218                                                               GdkRectangle       *view_rect);
 219 static void       find_page_at_location                      (EvView             *view,
 220                                                               gdouble             x,
 221                                                               gdouble             y,
 222                                                               gint               *page,
 223                                                               gint               *x_offset,
 224                                                               gint               *y_offset);
 225
 226 /*** Hyperrefs ***/
 227 static EvLink*    get_link_at_location                       (EvView             *view,
 228                                                               gdouble             x,
 229                                                               gdouble             y);
 230 static void       go_to_link                                 (EvView             *view,
 231                                                               EvLink             *link);
 232 static char*      status_message_from_link                   (EvView             *view,
 233                                                               EvLink             *link);
 234
 235 /*** GtkWidget implementation ***/
 236 static void       ev_view_size_request_continuous_dual_page  (EvView             *view,
 237                                                               GtkRequisition     *requisition);
 238 static void       ev_view_size_request_continuous            (EvView             *view,
 239                                                               GtkRequisition     *requisition);
 240 static void       ev_view_size_request_dual_page             (EvView             *view,
 241                                                               GtkRequisition     *requisition);
 242 static void       ev_view_size_request_single_page           (EvView             *view,
 243                                                               GtkRequisition     *requisition);
 244 static void       ev_view_size_request                       (GtkWidget          *widget,
 245                                                               GtkRequisition     *requisition);
 246 static void       ev_view_size_allocate                      (GtkWidget          *widget,
 247                                                               GtkAllocation      *allocation);
 248 static void       ev_view_realize                            (GtkWidget          *widget);
 249 static void       ev_view_unrealize                          (GtkWidget          *widget);
 250 static gboolean   ev_view_scroll_event                       (GtkWidget          *widget,
 251                                                               GdkEventScroll     *event);
 252 static gboolean   ev_view_expose_event                       (GtkWidget          *widget,
 253                                                               GdkEventExpose     *event);
 254 static gboolean   ev_view_button_press_event                 (GtkWidget          *widget,
 255                                                               GdkEventButton     *event);
 256 static gboolean   ev_view_motion_notify_event                (GtkWidget          *widget,
 257                                                               GdkEventMotion     *event);
 258 static gboolean   ev_view_button_release_event               (GtkWidget          *widget,
 259                                                               GdkEventButton     *event);
 260
 261 /*** Drawing ***/
 262 static guint32    ev_gdk_color_to_rgb                        (const GdkColor     *color);
 263 static void       draw_rubberband                            (GtkWidget          *widget,
 264                                                               GdkWindow          *window,
 265                                                               const GdkRectangle *rect,
 266                                                               guchar              alpha);
 267 static void       highlight_find_results                     (EvView             *view,
 268                                                               int                 page);
 269 static void       draw_one_page                              (EvView             *view,
 270                                                               gint                page,
 271                                                               GdkRectangle       *page_area,
 272                                                               GtkBorder          *border,
 273                                                               GdkRectangle       *expose_area);
 274
 275 /*** Callbacks ***/
 276 static void       find_changed_cb                            (EvDocument         *document,
 277                                                               int                 page,
 278                                                               EvView             *view);
 279 static void       job_finished_cb                            (EvPixbufCache      *pixbuf_cache,
 280                                                               EvView             *view);
 281 static void       page_changed_cb                            (EvPageCache        *page_cache,
 282                                                               int                 new_page,
 283                                                               EvView             *view);
 284 static void       on_adjustment_value_changed                (GtkAdjustment      *adjustment,
 285                                                               EvView             *view);
 286
 287 /*** GObject ***/
 288 static void       ev_view_finalize                           (GObject            *object);
 289 static void       ev_view_destroy                            (GtkObject          *object);
 290 static void       ev_view_set_property                       (GObject            *object,
 291                                                               guint               prop_id,
 292                                                               const GValue       *value,
 293                                                               GParamSpec         *pspec);
 294 static void       ev_view_get_property                       (GObject            *object,
 295                                                               guint               prop_id,
 296                                                               GValue             *value,
 297                                                               GParamSpec         *pspec);
 298 static void       ev_view_class_init                         (EvViewClass        *class);
 299 static void       ev_view_init                               (EvView             *view);
 300
 301 /*** Zoom and sizing ***/
 302 static double   zoom_for_size_fit_width                      (int doc_width,
 303                                                               int doc_height,
 304                                                               int target_width,
 305                                                               int target_height,
 306                                                               int vsb_width);
 307 static double   zoom_for_size_best_fit                       (int doc_width,
 308                                                               int doc_height,
 309                                                               int target_width,
 310                                                               int target_height,
 311                                                               int vsb_width,
 312                                                               int hsb_width);
 313 static void     ev_view_zoom_for_size_presentation           (EvView *view,
 314                                                               int     width,
 315                                                               int     height);
 316 static void     ev_view_zoom_for_size_continuous_and_dual_page (EvView *view,
 317                                                                 int     width,
 318                                                                 int     height,
 319                                                                 int     vsb_width,
 320                                                                 int     hsb_height);
 321 static void     ev_view_zoom_for_size_continuous               (EvView *view,
 322                                                                 int     width,
 323                                                                 int     height,
 324                                                                 int     vsb_width,
 325                                                                 int     hsb_height);
 326 static void     ev_view_zoom_for_size_dual_page                (EvView *view,
 327                                                                 int     width,
 328                                                                 int     height,
 329                                                                 int     vsb_width,
 330                                                                 int     hsb_height);
 331 static void     ev_view_zoom_for_size_single_page              (EvView *view,
 332                                                                 int     width,
 333                                                                 int     height,
 334                                                                 int     vsb_width,
 335                                                                 int     hsb_height);
 336 /*** Cursors ***/
 337 static GdkCursor* ev_view_create_invisible_cursor            (void);
 338 static void       ev_view_set_cursor                         (EvView             *view,
 339                                                               EvViewCursor        new_cursor);
 340
 341 /*** Status messages ***/
 342 static void       ev_view_set_status                         (EvView             *view,
 343                                                               const char         *message);
 344 static void       update_find_status_message                 (EvView             *view);
 345 static void       ev_view_set_find_status                    (EvView             *view,
 346                                                               const char         *message);
 347 /*** Find ***/
 348 static void       jump_to_find_result                        (EvView             *view);
 349 static void       jump_to_find_page                          (EvView             *view);
 350
 351 /*** Selection ***/
 352 static void       compute_selections                         (EvView             *view,
 353                                                               GdkPoint           *start,
 354                                                               GdkPoint           *stop);
 355 static void       clear_selection                            (EvView             *view);
 356 static char*      get_selected_text                          (EvView             *ev_view);
 357 static void       ev_view_primary_get_cb                     (GtkClipboard       *clipboard,
 358                                                               GtkSelectionData   *selection_data,
 359                                                               guint               info,
 360                                                               gpointer            data);
 361 static void       ev_view_primary_clear_cb                   (GtkClipboard       *clipboard,
 362                                                               gpointer            data);
 363 static void       ev_view_update_primary_selection           (EvView             *ev_view);
 364
 365
 366 G_DEFINE_TYPE (EvView, ev_view, GTK_TYPE_WIDGET)
 367
 368 static void
 369 scroll_to_current_page (EvView *view, GtkOrientation orientation)
 370 {
 371         GdkRectangle page_area;
 372         GtkBorder border;
 373
 374         get_page_extents (view, view->current_page, &page_area, &border);
 375
 376         if (orientation == GTK_ORIENTATION_VERTICAL) {
 377                 if (view->continuous) {
 378                         gtk_adjustment_clamp_page (view->vadjustment,
 379                                                    page_area.y - view->spacing,
 380                                                    page_area.y + view->vadjustment->page_size);
 381                 } else {
 382                         gtk_adjustment_set_value (view->vadjustment,
 383                                                   view->vadjustment->lower);
 384                 }
 385         } else {
 386                 if (view->dual_page) {
 387                         gtk_adjustment_clamp_page (view->hadjustment,
 388                                                    page_area.x,
 389                                                    page_area.x + view->hadjustment->page_size);
 390                 } else {
 391                         gtk_adjustment_set_value (view->hadjustment,
 392                                                   CLAMP (view->hadjustment->value,
 393                                                   view->hadjustment->lower,
 394                                                   view->hadjustment->upper -
 395                                                   view->hadjustment->page_size));
 396                 }
 397         }
 398 }
 399
 400 static void
 401 view_set_adjustment_values (EvView         *view,
 402                             GtkOrientation  orientation)
 403 {
 404         GtkWidget *widget = GTK_WIDGET (view);
 405         GtkAdjustment *adjustment;
 406         int requisition;
 407         int allocation;
 408
 409         double factor;
 410         gint new_value;
 411
 412         if (orientation == GTK_ORIENTATION_HORIZONTAL)  {
 413                 requisition = widget->requisition.width;
 414                 allocation = widget->allocation.width;
 415                 adjustment = view->hadjustment;
 416         } else {
 417                 requisition = widget->requisition.height;
 418                 allocation = widget->allocation.height;
 419                 adjustment = view->vadjustment;
 420         }
 421
 422         if (!adjustment)
 423                 return;
 424
 425         factor = 1.0;
 426         switch (view->pending_scroll) {
 427                 case SCROLL_TO_KEEP_POSITION:
 428                         factor = (adjustment->value) / adjustment->upper;
 429                         break;
 430                 case SCROLL_TO_CURRENT_PAGE:
 431                         break;
 432                 case SCROLL_TO_CENTER:
 433                         factor = (adjustment->value + adjustment->page_size * 0.5) / adjustment->upper;
 434                         break;
 435         }
 436
 437         adjustment->page_size = allocation;
 438         adjustment->step_increment = allocation * 0.1;
 439         adjustment->page_increment = allocation * 0.9;
 440         adjustment->lower = 0;
 441         adjustment->upper = MAX (allocation, requisition);
 442
 443         /*
 444          * We add 0.5 to the values before to average out our rounding errors.
 445          */
 446         switch (view->pending_scroll) {
 447                 case SCROLL_TO_KEEP_POSITION:
 448                         new_value = CLAMP (adjustment->upper * factor + 0.5, 0, adjustment->upper - adjustment->page_size);
 449                         gtk_adjustment_set_value (adjustment, (int)new_value);
 450                         break;
 451                 case SCROLL_TO_CURRENT_PAGE:
 452                         scroll_to_current_page (view, orientation);
 453                         break;
 454                 case SCROLL_TO_CENTER:
 455                         new_value = CLAMP (adjustment->upper * factor - adjustment->page_size * 0.5 + 0.5,
 456                                            0, adjustment->upper - adjustment->page_size);
 457                         gtk_adjustment_set_value (adjustment, (int)new_value);
 458                         break;
 459         }
 460
 461         gtk_adjustment_changed (adjustment);
 462 }
 463
 464 static void
 465 view_update_range_and_current_page (EvView *view)
 466 {
 467         /* Presentation trumps all other modes */
 468         if (view->presentation) {
 469                 view->start_page = view->current_page;
 470                 view->end_page = view->current_page;
 471         } else if (view->continuous) {
 472                 GdkRectangle current_area, unused, page_area;
 473                 GtkBorder border;
 474                 gint current_page;
 475                 gboolean found = FALSE;
 476                 int i;
 477
 478                 if (!(view->vadjustment && view->hadjustment))
 479                         return;
 480
 481                 current_area.x = view->hadjustment->value;
 482                 current_area.width = view->hadjustment->upper;
 483                 current_area.y = view->vadjustment->value;
 484                 current_area.height = view->vadjustment->page_size;
 485
 486                 for (i = 0; i < ev_page_cache_get_n_pages (view->page_cache); i++) {
 487
 488                         get_page_extents (view, i, &page_area, &border);
 489
 490                         if (gdk_rectangle_intersect (&current_area, &page_area, &unused)) {
 491                                 if (! found) {
 492                                         view->start_page = i;
 493                                         found = TRUE;
 494
 495                                 }
 496                                 view->end_page = i;
 497                         } else if (found) {
 498                                 break;
 499                         }
 500                 }
 501
 502                 current_page = ev_page_cache_get_current_page (view->page_cache);
 503
 504                 if (current_page < view->start_page || current_page > view->end_page) {
 505                         view->current_page = view->start_page;
 506                         ev_page_cache_set_current_page (view->page_cache, view->start_page);
 507                 }
 508         } else {
 509                 if (view->dual_page) {
 510                         if (view->current_page % 2 == 0) {
 511                                 view->start_page = view->current_page;
 512                                 if (view->current_page + 1 < ev_page_cache_get_n_pages (view->page_cache))
 513                                         view->end_page = view->start_page + 1;
 514                         } else {
 515                                 view->start_page = view->current_page - 1;
 516                                 view->end_page = view->current_page;
 517                         }
 518                 } else {
 519                         view->start_page = view->current_page;
 520                         view->end_page = view->current_page;
 521                 }
 522         }
 523
 524         ev_pixbuf_cache_set_page_range (view->pixbuf_cache,
 525                                         view->start_page,
 526                                         view->end_page,
 527                                         view->scale,
 528                                         view->selection_info.selections);
 529 }
 530
 531 static void
 532 set_scroll_adjustment (EvView *view,
 533                        GtkOrientation  orientation,
 534                        GtkAdjustment  *adjustment)
 535 {
 536         GtkAdjustment **to_set;
 537
 538         if (orientation == GTK_ORIENTATION_HORIZONTAL)
 539                 to_set = &view->hadjustment;
 540         else
 541                 to_set = &view->vadjustment;
 542
 543         if (*to_set != adjustment) {
 544                 if (*to_set) {
 545                         g_signal_handlers_disconnect_by_func (*to_set,
 546                                                               (gpointer) on_adjustment_value_changed,
 547                                                               view);
 548                         g_object_unref (*to_set);
 549                 }
 550
 551                 *to_set = adjustment;
 552                 view_set_adjustment_values (view, orientation);
 553
 554                 if (*to_set) {
 555                         g_object_ref (*to_set);
 556                         g_signal_connect (*to_set, "value_changed",
 557                                           G_CALLBACK (on_adjustment_value_changed), view);
 558                 }
 559         }
 560 }
 561
 562 static void
 563 ev_view_set_scroll_adjustments (EvView *view,
 564                                 GtkAdjustment  *hadjustment,
 565                                 GtkAdjustment  *vadjustment)
 566 {
 567         set_scroll_adjustment (view, GTK_ORIENTATION_HORIZONTAL, hadjustment);
 568         set_scroll_adjustment (view, GTK_ORIENTATION_VERTICAL, vadjustment);
 569
 570         on_adjustment_value_changed (NULL, view);
 571 }
 572
 573 static void
 574 add_scroll_binding_keypad (GtkBindingSet  *binding_set,
 575                            guint           keyval,
 576                            GtkScrollType   scroll,
 577                            gboolean        horizontal)
 578 {
 579   guint keypad_keyval = keyval - GDK_Left + GDK_KP_Left;
 580
 581   gtk_binding_entry_add_signal (binding_set, keyval, 0,
 582                                 "binding_activated", 2,
 583                                 GTK_TYPE_SCROLL_TYPE, scroll,
 584                                 G_TYPE_BOOLEAN, horizontal);
 585   gtk_binding_entry_add_signal (binding_set, keypad_keyval, 0,
 586                                 "binding_activated", 2,
 587                                 GTK_TYPE_SCROLL_TYPE, scroll,
 588                                 G_TYPE_BOOLEAN, horizontal);
 589 }
 590
 591 void
 592 ev_view_scroll (EvView        *view,
 593                 EvScrollType   scroll)
 594 {
 595         GtkAdjustment *adjustment;
 596         double value, increment;
 597         gboolean first_page = FALSE;
 598         gboolean last_page = FALSE;
 599
 600         /* Assign values for increment and vertical adjustment */
 601         adjustment = view->vadjustment;
 602         increment = adjustment->page_size * 0.75;
 603         value = adjustment->value;
 604
 605         /* Assign boolean for first and last page */
 606         if (view->current_page == 0)
 607                 first_page = TRUE;
 608         if (view->current_page == ev_page_cache_get_n_pages (view->page_cache) - 1)
 609                 last_page = TRUE;
 610
 611         switch (scroll) {
 612                 case EV_SCROLL_PAGE_BACKWARD:
 613                         /* Do not jump backwards if at the first page */
 614                         if (value == (adjustment->lower) && first_page) {
 615                                 /* Do nothing */
 616                                 /* At the top of a page, assign the upper bound limit of previous page */
 617                         } else if (value == (adjustment->lower)) {
 618                                 value = adjustment->upper - adjustment->page_size;
 619                                 ev_page_cache_set_current_page (view->page_cache, view->current_page - 1);
 620                                 /* Jump to the top */
 621                         } else {
 622                                 value = MAX (value - increment, adjustment->lower);
 623                         }
 624                         break;
 625                 case EV_SCROLL_PAGE_FORWARD:
 626                         /* Do not jump forward if at the last page */
 627                         if (value == (adjustment->upper - adjustment->page_size) && last_page) {
 628                                 /* Do nothing */
 629                         /* At the bottom of a page, assign the lower bound limit of next page */
 630                         } else if (value == (adjustment->upper - adjustment->page_size)) {
 631                                 value = 0;
 632                                 ev_page_cache_set_current_page (view->page_cache, view->current_page + 1);
 633                         /* Jump to the bottom */
 634                         } else {
 635                                 value = MIN (value + increment, adjustment->upper - adjustment->page_size);
 636                         }
 637                         break;
 638                 default:
 639                         break;
 640         }
 641
 642         gtk_adjustment_set_value (adjustment, value);
 643 }
 644
 645 static void
 646 ev_view_binding_activated (EvView *view,
 647                            GtkScrollType scroll,
 648                            gboolean horizontal)
 649 {
 650         GtkAdjustment *adjustment;
 651         double value;
 652
 653         if (view->presentation) {
 654                 switch (scroll) {
 655                         case GTK_SCROLL_STEP_BACKWARD:
 656                                 ev_page_cache_prev_page (view->page_cache);
 657                                 break;
 658                         case GTK_SCROLL_STEP_FORWARD:
 659                                 ev_page_cache_next_page (view->page_cache);
 660                                 break;
 661                         default:
 662                                 break;
 663                 }
 664                 return;
 665         }
 666
 667         if (horizontal) {
 668                 adjustment = view->hadjustment;
 669         } else {
 670                 adjustment = view->vadjustment;
 671         }
 672
 673         value = adjustment->value;
 674
 675         switch (scroll) {
 676                 case GTK_SCROLL_STEP_BACKWARD:
 677                         value -= adjustment->step_increment;
 678                         break;
 679                 case GTK_SCROLL_STEP_FORWARD:
 680                         value += adjustment->step_increment;
 681                         break;
 682                 default:
 683                         break;
 684         }
 685
 686         value = CLAMP (value, adjustment->lower,
 687                        adjustment->upper - adjustment->page_size);
 688
 689         gtk_adjustment_set_value (adjustment, value);
 690 }
 691
 692 #define MARGIN 5
 693
 694 static void
 695 ensure_rectangle_is_visible (EvView *view, GdkRectangle *rect)
 696 {
 697         GtkWidget *widget = GTK_WIDGET (view);
 698         GtkAdjustment *adjustment;
 699         int value;
 700
 701         adjustment = view->vadjustment;
 702
 703         if (rect->y < adjustment->value) {
 704                 value = MAX (adjustment->lower, rect->y - MARGIN);
 705                 gtk_adjustment_set_value (view->vadjustment, value);
 706         } else if (rect->y + rect->height >
 707                    adjustment->value + widget->allocation.height) {
 708                 value = MIN (adjustment->upper, rect->y + rect->height -
 709                              widget->allocation.height + MARGIN);
 710                 gtk_adjustment_set_value (view->vadjustment, value);
 711         }
 712
 713         adjustment = view->hadjustment;
 714
 715         if (rect->x < adjustment->value) {
 716                 value = MAX (adjustment->lower, rect->x - MARGIN);
 717                 gtk_adjustment_set_value (view->hadjustment, value);
 718         } else if (rect->x + rect->height >
 719                    adjustment->value + widget->allocation.width) {
 720                 value = MIN (adjustment->upper, rect->x + rect->width -
 721                              widget->allocation.width + MARGIN);
 722                 gtk_adjustment_set_value (view->hadjustment, value);
 723         }
 724 }
 725
 726 /*** Geometry computations ***/
 727
 728 static void
 729 compute_border (EvView *view, int width, int height, GtkBorder *border)
 730 {
 731         if (view->presentation) {
 732                 border->left = 0;
 733                 border->right = 0;
 734                 border->top = 0;
 735                 border->bottom = 0;
 736         } else {
 737                 ev_document_misc_get_page_border_size (width, height, border);
 738         }
 739 }
 740
 741 static void       get_page_y_offset                          (EvView *view,
 742                                                               int page,
 743                                                               double zoom,
 744                                                               int *y_offset)
 745 {
 746         int max_width, offset;
 747         GtkBorder border;
 748
 749         g_return_if_fail (y_offset != NULL);
 750
 751         ev_page_cache_get_max_width (view->page_cache, zoom, &max_width);
 752
 753         compute_border (view, max_width, max_width, &border);
 754
 755         if (view->dual_page) {
 756                 ev_page_cache_get_height_to_page (view->page_cache, page, zoom, NULL, &offset);
 757                 offset += (page / 2 + 1) * view->spacing + (page / 2) * (border.top + border.bottom);
 758         } else {
 759                 ev_page_cache_get_height_to_page (view->page_cache, page, zoom, &offset, NULL);
 760                 offset += (page + 1) * view->spacing + page * (border.top + border.bottom);
 761         }
 762
 763         *y_offset = offset;
 764         return;
 765 }
 766
 767 static gboolean
 768 get_page_extents (EvView       *view,
 769                   gint          page,
 770                   GdkRectangle *page_area,
 771                   GtkBorder    *border)
 772 {
 773         GtkWidget *widget;
 774         int width, height;
 775
 776         widget = GTK_WIDGET (view);
 777
 778         /* Get the size of the page */
 779         ev_page_cache_get_size (view->page_cache, page,
 780                                 view->scale,
 781                                 &width, &height);
 782         compute_border (view, width, height, border);
 783         page_area->width = width + border->left + border->right;
 784         page_area->height = height + border->top + border->bottom;
 785
 786         if (view->presentation) {
 787                 page_area->x = (MAX (0, widget->allocation.width - width))/2;
 788                 page_area->y = (MAX (0, widget->allocation.height - height))/2;
 789         } else if (view->continuous) {
 790                 gint max_width;
 791                 gint x, y;
 792
 793                 ev_page_cache_get_max_width (view->page_cache, view->scale, &max_width);
 794                 max_width = max_width + border->left + border->right;
 795                 /* Get the location of the bounding box */
 796                 if (view->dual_page) {
 797                         x = view->spacing + (page % 2) * (max_width + view->spacing);
 798                         x = x + MAX (0, widget->allocation.width - (max_width * 2 + view->spacing * 3)) / 2;
 799                         if (page % 2 == 0)
 800                                 x = x + (max_width - width - border->left - border->right);
 801                 } else {
 802                         x = view->spacing;
 803                         x = x + MAX (0, widget->allocation.width - (width + view->spacing * 2)) / 2;
 804                 }
 805
 806                 get_page_y_offset (view, page, view->scale, &y);
 807
 808                 page_area->x = x;
 809                 page_area->y = y;
 810         } else {
 811                 gint x, y;
 812                 if (view->dual_page) {
 813                         gint width_2, height_2;
 814                         gint max_width = width;
 815                         gint max_height = height;
 816                         GtkBorder overall_border;
 817                         gint other_page;
 818
 819                         other_page = page ^ 1;
 820
 821                         /* First, we get the bounding box of the two pages */
 822                         if (other_page < ev_page_cache_get_n_pages (view->page_cache)) {
 823                                 ev_page_cache_get_size (view->page_cache,
 824                                                         other_page,
 825                                                         view->scale,
 826                                                         &width_2, &height_2);
 827                                 if (width_2 > width)
 828                                         max_width = width_2;
 829                                 if (height_2 > height)
 830                                         max_height = height_2;
 831                         }
 832                         compute_border (view, max_width, max_height, &overall_border);
 833
 834                         /* Find the offsets */
 835                         x = view->spacing;
 836                         y = view->spacing;
 837
 838                         /* Adjust for being the left or right page */
 839                         if (page % 2 == 0)
 840                                 x = x + max_width - width;
 841                         else
 842                                 x = x + (max_width + overall_border.left + overall_border.right) + view->spacing;
 843
 844                         y = y + (max_height - height)/2;
 845
 846                         /* Adjust for extra allocation */
 847                         x = x + MAX (0, widget->allocation.width -
 848                                      ((max_width + overall_border.left + overall_border.right) * 2 + view->spacing * 3))/2;
 849                         y = y + MAX (0, widget->allocation.height - (height + view->spacing * 2))/2;
 850                 } else {
 851                         x = view->spacing;
 852                         y = view->spacing;
 853
 854                         /* Adjust for extra allocation */
 855                         x = x + MAX (0, widget->allocation.width - (width + border->left + border->right + view->spacing * 2))/2;
 856                         y = y + MAX (0, widget->allocation.height - (height + border->top + border->bottom +  view->spacing * 2))/2;
 857                 }
 858
 859                 page_area->x = x;
 860                 page_area->y = y;
 861         }
 862
 863         return TRUE;
 864 }
 865
 866 static void
 867 view_point_to_doc_point (EvView *view,
 868                          GdkPoint *view_point,
 869                          GdkRectangle *page_area,
 870                          double  *doc_point_x,
 871                          double  *doc_point_y)
 872 {
 873         *doc_point_x = (double) (view_point->x - page_area->x) / view->scale;
 874         *doc_point_y = (double) (view_point->y - page_area->y) / view->scale;
 875 }
 876
 877 static void
 878 view_rect_to_doc_rect (EvView *view,
 879                        GdkRectangle *view_rect,
 880                        GdkRectangle *page_area,
 881                        EvRectangle  *doc_rect)
 882 {
 883         doc_rect->x1 = (double) (view_rect->x - page_area->x) / view->scale;
 884         doc_rect->y1 = (double) (view_rect->y - page_area->y) / view->scale;
 885         doc_rect->x2 = doc_rect->x1 + (double) view_rect->width / view->scale;
 886         doc_rect->y2 = doc_rect->y1 + (double) view_rect->height / view->scale;
 887 }
 888
 889 static void
 890 doc_rect_to_view_rect (EvView       *view,
 891                        int           page,
 892                        EvRectangle  *doc_rect,
 893                        GdkRectangle *view_rect)
 894 {
 895         GdkRectangle page_area;
 896         GtkBorder border;
 897         int width, height;
 898
 899         get_page_extents (view, page, &page_area, &border);
 900
 901         width = doc_rect->x2 - doc_rect->x1;
 902         height = doc_rect->y2 - doc_rect->y1;
 903         view_rect->x = floor (doc_rect->x1 * view->scale) + page_area.x;
 904         view_rect->y = floor (doc_rect->y1 * view->scale) + page_area.y;
 905         view_rect->width = ceil (width * view->scale);
 906         view_rect->height = ceil (height * view->scale);
 907 }
 908
 909 static void
 910 find_page_at_location (EvView  *view,
 911                        gdouble  x,
 912                        gdouble  y,
 913                        gint    *page,
 914                        gint    *x_offset,
 915                        gint    *y_offset)
 916 {
 917         int i;
 918
 919         if (view->document == NULL)
 920                 return;
 921
 922         g_assert (page);
 923         g_assert (x_offset);
 924         g_assert (y_offset);
 925
 926         for (i = view->start_page; i <= view->end_page; i++) {
 927                 GdkRectangle page_area;
 928                 GtkBorder border;
 929
 930                 if (! get_page_extents (view, i, &page_area, &border))
 931                         continue;
 932
 933                 if ((x >= page_area.x + border.left) &&
 934                     (x < page_area.x + page_area.width - border.right) &&
 935                     (y >= page_area.y + border.top) &&
 936                     (y < page_area.y + page_area.height - border.bottom)) {
 937                         *page = i;
 938                         *x_offset = x - (page_area.x + border.left);
 939                         *y_offset = y - (page_area.y + border.top);
 940                         return;
 941                 }
 942         }
 943
 944         *page = -1;
 945 }
 946
 947 /*** Hyperref ***/
 948 static EvLink *
 949 get_link_at_location (EvView  *view,
 950                       gdouble  x,
 951                       gdouble  y)
 952 {
 953         gint page = -1;
 954         gint x_offset = 0, y_offset = 0;
 955         GList *link_mapping;
 956
 957         find_page_at_location (view, x, y, &page, &x_offset, &y_offset);
 958
 959         if (page == -1)
 960                 return NULL;
 961
 962         link_mapping = ev_pixbuf_cache_get_link_mapping (view->pixbuf_cache, page);
 963
 964         if (link_mapping)
 965                 return ev_link_mapping_find (link_mapping, x_offset / view->scale, y_offset / view->scale);
 966         else
 967                 return NULL;
 968 }
 969
 970 /* FIXME: standardize this sometime */
 971 static void
 972 go_to_link (EvView *view, EvLink *link)
 973 {
 974         EvLinkType type;
 975         const char *uri;
 976         int page;
 977
 978         type = ev_link_get_link_type (link);
 979
 980         switch (type) {
 981                 case EV_LINK_TYPE_TITLE:
 982                         break;
 983                 case EV_LINK_TYPE_PAGE:
 984                         page = ev_link_get_page (link);
 985                         ev_page_cache_set_current_page (view->page_cache, page);
 986                         break;
 987                 case EV_LINK_TYPE_EXTERNAL_URI:
 988                         uri = ev_link_get_uri (link);
 989                         gnome_vfs_url_show (uri);
 990                         break;
 991         }
 992 }
 993
 994 static char *
 995 status_message_from_link (EvView *view, EvLink *link)
 996 {
 997         EvLinkType type;
 998         char *msg = NULL;
 999         char *page_label;
1000
1001         type = ev_link_get_link_type (link);
1002
1003         switch (type) {
1004                 case EV_LINK_TYPE_TITLE:
1005                         if (ev_link_get_title (link))
1006                                 msg = g_strdup (ev_link_get_title (link));
1007                         break;
1008                 case EV_LINK_TYPE_PAGE:
1009                         page_label = ev_page_cache_get_page_label (view->page_cache, ev_link_get_page (link));
1010                         msg = g_strdup_printf (_("Go to page %s"), page_label);
1011                         g_free (page_label);
1012                         break;
1013                 case EV_LINK_TYPE_EXTERNAL_URI:
1014                         msg = g_strdup (ev_link_get_uri (link));
1015                         break;
1016                 default:
1017                         break;
1018         }
1019
1020         return msg;
1021 }
1022
1023
1024 /*** GtkWidget implementation ***/
1025
1026 static void
1027 ev_view_size_request_continuous_dual_page (EvView         *view,
1028                                            GtkRequisition *requisition)
1029 {
1030         int max_width;
1031         gint n_pages;
1032         GtkBorder border;
1033
1034         ev_page_cache_get_max_width (view->page_cache, view->scale, &max_width);
1035         compute_border (view, max_width, max_width, &border);
1036
1037         n_pages = ev_page_cache_get_n_pages (view->page_cache) + 1;
1038
1039         requisition->width = (max_width + border.left + border.right) * 2 + (view->spacing * 3);
1040         get_page_y_offset (view, n_pages, view->scale, &requisition->height);
1041
1042         if (view->sizing_mode == EV_SIZING_FIT_WIDTH) {
1043                 requisition->width = 1;
1044         } else if (view->sizing_mode == EV_SIZING_BEST_FIT) {
1045                 requisition->width = 1;
1046                 /* FIXME: This could actually be set on one page docs or docs
1047                  * with a strange aspect ratio. */
1048                 /* requisition->height = 1;*/
1049         }
1050 }
1051
1052 static void
1053 ev_view_size_request_continuous (EvView         *view,
1054                                  GtkRequisition *requisition)
1055 {
1056         int max_width;
1057         int n_pages;
1058         GtkBorder border;
1059
1060
1061         ev_page_cache_get_max_width (view->page_cache, view->scale, &max_width);
1062         n_pages = ev_page_cache_get_n_pages (view->page_cache);
1063         compute_border (view, max_width, max_width, &border);
1064
1065         requisition->width = max_width + (view->spacing * 2) + border.left + border.right;
1066         get_page_y_offset (view, n_pages, view->scale, &requisition->height);
1067
1068         if (view->sizing_mode == EV_SIZING_FIT_WIDTH) {
1069                 requisition->width = 1;
1070         } else if (view->sizing_mode == EV_SIZING_BEST_FIT) {
1071                 requisition->width = 1;
1072                 /* FIXME: This could actually be set on one page docs or docs
1073                  * with a strange aspect ratio. */
1074                 /* requisition->height = 1;*/
1075         }
1076 }
1077
1078 static void
1079 ev_view_size_request_dual_page (EvView         *view,
1080                                 GtkRequisition *requisition)
1081 {
1082         GtkBorder border;
1083         gint width, height;
1084
1085         /* Find the largest of the two. */
1086         ev_page_cache_get_size (view->page_cache,
1087                                 view->current_page,
1088                                 view->scale,
1089                                 &width, &height);
1090         if (view->current_page + 1 < ev_page_cache_get_n_pages (view->page_cache)) {
1091                 gint width_2, height_2;
1092                 ev_page_cache_get_size (view->page_cache,
1093                                         view->current_page + 1,
1094                                         view->scale,
1095                                         &width_2, &height_2);
1096                 if (width_2 > width) {
1097                         width = width_2;
1098                         height = height_2;
1099                 }
1100         }
1101         compute_border (view, width, height, &border);
1102
1103         requisition->width = ((width + border.left + border.right) * 2) +
1104                 (view->spacing * 3);
1105         requisition->height = (height + border.top + border.bottom) +
1106                 (view->spacing * 2);
1107
1108         if (view->sizing_mode == EV_SIZING_FIT_WIDTH) {
1109                 requisition->width = 1;
1110         } else if (view->sizing_mode == EV_SIZING_BEST_FIT) {
1111                 requisition->width = 1;
1112                 requisition->height = 1;
1113         }
1114 }
1115
1116 static void
1117 ev_view_size_request_single_page (EvView         *view,
1118                                   GtkRequisition *requisition)
1119 {
1120         GtkBorder border;
1121         gint width, height;
1122
1123         ev_page_cache_get_size (view->page_cache,
1124                                 view->current_page,
1125                                 view->scale,
1126                                 &width, &height);
1127         compute_border (view, width, height, &border);
1128
1129         requisition->width = width + border.left + border.right + (2 * view->spacing);
1130         requisition->height = height + border.top + border.bottom + (2 * view->spacing);
1131
1132         if (view->sizing_mode == EV_SIZING_FIT_WIDTH) {
1133                 requisition->width = 1;
1134                 requisition->height = height + border.top + border.bottom + (2 * view->spacing);
1135         } else if (view->sizing_mode == EV_SIZING_BEST_FIT) {
1136                 requisition->width = 1;
1137                 requisition->height = 1;
1138         }
1139 }
1140
1141 static void
1142 ev_view_size_request (GtkWidget      *widget,
1143                       GtkRequisition *requisition)
1144 {
1145         EvView *view = EV_VIEW (widget);
1146
1147         if (view->document == NULL) {
1148                 requisition->width = 1;
1149                 requisition->height = 1;
1150                 return;
1151         }
1152
1153         if (view->presentation) {
1154                 requisition->width = 1;
1155                 requisition->height = 1;
1156                 return;
1157         }
1158
1159         if (view->continuous && view->dual_page)
1160                 ev_view_size_request_continuous_dual_page (view, requisition);
1161         else if (view->continuous)
1162                 ev_view_size_request_continuous (view, requisition);
1163         else if (view->dual_page)
1164                 ev_view_size_request_dual_page (view, requisition);
1165         else
1166                 ev_view_size_request_single_page (view, requisition);
1167 }
1168
1169 static void
1170 ev_view_size_allocate (GtkWidget      *widget,
1171                        GtkAllocation  *allocation)
1172 {
1173         EvView *view = EV_VIEW (widget);
1174
1175         if (view->sizing_mode == EV_SIZING_FIT_WIDTH ||
1176                   view->sizing_mode == EV_SIZING_BEST_FIT) {
1177
1178                 g_signal_emit (view, signals[SIGNAL_ZOOM_INVALID], 0);
1179
1180                 ev_view_size_request (widget, &widget->requisition);
1181         }
1182
1183         view_set_adjustment_values (view, GTK_ORIENTATION_HORIZONTAL);
1184         view_set_adjustment_values (view, GTK_ORIENTATION_VERTICAL);
1185
1186         view->pending_scroll = SCROLL_TO_KEEP_POSITION;
1187         view->pending_resize = FALSE;
1188
1189         if (view->document)
1190                 view_update_range_and_current_page (view);
1191
1192         GTK_WIDGET_CLASS (ev_view_parent_class)->size_allocate (widget, allocation);
1193 }
1194
1195 static void
1196 ev_view_realize (GtkWidget *widget)
1197 {
1198         EvView *view = EV_VIEW (widget);
1199         GdkWindowAttr attributes;
1200
1201         GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
1202
1203
1204         attributes.window_type = GDK_WINDOW_CHILD;
1205         attributes.wclass = GDK_INPUT_OUTPUT;
1206         attributes.visual = gtk_widget_get_visual (widget);
1207         attributes.colormap = gtk_widget_get_colormap (widget);
1208
1209         attributes.x = widget->allocation.x;
1210         attributes.y = widget->allocation.y;
1211         attributes.width = widget->allocation.width;
1212         attributes.height = widget->allocation.height;
1213         attributes.event_mask = GDK_EXPOSURE_MASK |
1214                                 GDK_BUTTON_PRESS_MASK |
1215                                 GDK_BUTTON_RELEASE_MASK |
1216                                 GDK_SCROLL_MASK |
1217                                 GDK_KEY_PRESS_MASK |
1218                                 GDK_POINTER_MOTION_MASK |
1219                                 GDK_LEAVE_NOTIFY_MASK;
1220
1221         widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
1222                                          &attributes,
1223                                          GDK_WA_X | GDK_WA_Y |
1224                                          GDK_WA_COLORMAP |
1225                                          GDK_WA_VISUAL);
1226         gdk_window_set_user_data (widget->window, widget);
1227         widget->style = gtk_style_attach (widget->style, widget->window);
1228
1229         if (view->presentation)
1230                 gdk_window_set_background (widget->window, &widget->style->black);
1231         else
1232                 gdk_window_set_background (widget->window, &widget->style->mid [GTK_STATE_NORMAL]);
1233 }
1234
1235 static void
1236 ev_view_unrealize (GtkWidget *widget)
1237 {
1238         GTK_WIDGET_CLASS (ev_view_parent_class)->unrealize (widget);
1239 }
1240
1241 static gboolean
1242 ev_view_scroll_event (GtkWidget *widget, GdkEventScroll *event)
1243 {
1244         EvView *view = EV_VIEW (widget);
1245
1246         if ((event->state & GDK_CONTROL_MASK) != 0) {
1247
1248                  ev_view_set_sizing_mode (view, EV_SIZING_FREE);
1249
1250                  if (event->direction == GDK_SCROLL_UP ||
1251                         event->direction == GDK_SCROLL_LEFT) {
1252                             if (ev_view_can_zoom_in (view)) {
1253                                     ev_view_zoom_in (view);
1254                             }
1255                  } else {
1256                             if (ev_view_can_zoom_out (view)) {
1257                                     ev_view_zoom_out (view);
1258                             }
1259                  }
1260                  return TRUE;
1261         }
1262
1263         if ((event->state & GDK_SHIFT_MASK) != 0) {
1264                 if (event->direction == GDK_SCROLL_UP)
1265                         event->direction = GDK_SCROLL_LEFT;
1266                 if (event->direction == GDK_SCROLL_DOWN)
1267                         event->direction = GDK_SCROLL_RIGHT;
1268         }
1269
1270         return FALSE;
1271 }
1272
1273 static EvViewSelection *
1274 find_selection_for_page (EvView *view,
1275                          gint    page)
1276 {
1277         GList *list;
1278
1279         for (list = view->selection_info.selections; list != NULL; list = list->next) {
1280                 EvViewSelection *selection;
1281
1282                 selection = (EvViewSelection *) list->data;
1283
1284                 if (selection->page == page)
1285                         return selection;
1286         }
1287
1288         return NULL;
1289 }
1290
1291 static gboolean
1292 ev_view_expose_event (GtkWidget      *widget,
1293                       GdkEventExpose *event)
1294 {
1295         EvView *view = EV_VIEW (widget);
1296         int i;
1297
1298         if (view->document == NULL)
1299                 return FALSE;
1300
1301         for (i = view->start_page; i <= view->end_page; i++) {
1302                 GdkRectangle page_area;
1303                 GtkBorder border;
1304
1305                 if (!get_page_extents (view, i, &page_area, &border))
1306                         continue;
1307
1308                 page_area.x -= view->scroll_x;
1309                 page_area.y -= view->scroll_y;
1310
1311                 draw_one_page (view, i, &page_area, &border, &(event->area));
1312
1313                 if (EV_IS_DOCUMENT_FIND (view->document))
1314                         highlight_find_results (view, i);
1315         }
1316
1317         return FALSE;
1318 }
1319
1320 static gboolean
1321 ev_view_button_press_event (GtkWidget      *widget,
1322                             GdkEventButton *event)
1323 {
1324         EvView *view = EV_VIEW (widget);
1325
1326         if (!GTK_WIDGET_HAS_FOCUS (widget)) {
1327                 gtk_widget_grab_focus (widget);
1328         }
1329
1330         view->pressed_button = event->button;
1331
1332         switch (event->button) {
1333                 case 1:
1334                         if (view->selection_info.selections) {
1335                                 clear_selection (view);
1336                                 gtk_widget_queue_draw (widget);
1337                         }
1338
1339                         view->selection_info.start.x = event->x + view->scroll_x;
1340                         view->selection_info.start.y = event->y + view->scroll_y;
1341                         return TRUE;
1342                 case 2:
1343                         /* use root coordinates as reference point because
1344                          * scrolling changes window relative coordinates */
1345                         view->drag_info.start.x = event->x_root;
1346                         view->drag_info.start.y = event->y_root;
1347                         view->drag_info.hadj = gtk_adjustment_get_value (view->hadjustment);
1348                         view->drag_info.vadj = gtk_adjustment_get_value (view->vadjustment);
1349
1350                         ev_view_set_cursor (view, EV_VIEW_CURSOR_DRAG);
1351
1352                         return TRUE;
1353         }
1354
1355         return FALSE;
1356 }
1357
1358 static gboolean
1359 ev_view_motion_notify_event (GtkWidget      *widget,
1360                              GdkEventMotion *event)
1361 {
1362         EvView *view = EV_VIEW (widget);
1363
1364         if (!view->document)
1365                 return FALSE;
1366
1367         if (view->pressed_button == 1) {
1368                 GdkPoint point;
1369
1370                 view->selection_info.in_selection = TRUE;
1371                 point.x = event->x + view->scroll_x;
1372                 point.y = event->y + view->scroll_y;
1373                 compute_selections (view, &view->selection_info.start, &point);
1374
1375                 return TRUE;
1376         } else if (view->pressed_button == 2) {
1377                 if (!view->drag_info.in_drag) {
1378                         gboolean start;
1379
1380                         start = gtk_drag_check_threshold (widget,
1381                                                           view->drag_info.start.x,
1382                                                           view->drag_info.start.y,
1383                                                           event->x_root,
1384                                                           event->y_root);
1385                         view->drag_info.in_drag = start;
1386                 }
1387
1388                 if (view->drag_info.in_drag) {
1389                         int dx, dy;
1390                         gdouble dhadj_value, dvadj_value;
1391
1392                         dx = event->x_root - view->drag_info.start.x;
1393                         dy = event->y_root - view->drag_info.start.y;
1394
1395                         dhadj_value = view->hadjustment->page_size *
1396                                       (gdouble)dx / widget->allocation.width;
1397                         dvadj_value = view->vadjustment->page_size *
1398                                       (gdouble)dy / widget->allocation.height;
1399
1400                         /* clamp scrolling to visible area */
1401                         gtk_adjustment_set_value (view->hadjustment,
1402                                                   MIN(view->drag_info.hadj - dhadj_value,
1403                                                       view->hadjustment->upper -
1404                                                       view->hadjustment->page_size));
1405                         gtk_adjustment_set_value (view->vadjustment,
1406                                                   MIN(view->drag_info.vadj - dvadj_value,
1407                                                       view->vadjustment->upper -
1408                                                       view->vadjustment->page_size));
1409
1410                         return TRUE;
1411                 }
1412         } else if (view->pressed_button <= 0) {
1413                 EvLink *link;
1414
1415                 link = get_link_at_location (view, event->x + view->scroll_x, event->y + view->scroll_y);
1416                 if (link) {
1417                         char *msg;
1418
1419                         msg = status_message_from_link (view, link);
1420                         ev_view_set_status (view, msg);
1421                         ev_view_set_cursor (view, EV_VIEW_CURSOR_LINK);
1422                         g_free (msg);
1423                 } else {
1424                         ev_view_set_status (view, NULL);
1425                         if (view->cursor == EV_VIEW_CURSOR_LINK) {
1426                                 ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
1427                         }
1428                 }
1429                 return TRUE;
1430         }
1431
1432         return FALSE;
1433 }
1434
1435 static gboolean
1436 ev_view_button_release_event (GtkWidget      *widget,
1437                               GdkEventButton *event)
1438 {
1439         EvView *view = EV_VIEW (widget);
1440
1441         if (view->pressed_button == 2) {
1442                 ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
1443         }
1444
1445         view->pressed_button = -1;
1446         view->drag_info.in_drag = FALSE;
1447
1448         if (view->selection_info.selections) {
1449                 ev_view_update_primary_selection (view);
1450         } else if (view->document) {
1451                 EvLink *link;
1452
1453                 link = get_link_at_location (view, event->x + view->scroll_x, event->y + view->scroll_y);
1454                 if (link) {
1455                         go_to_link (view, link);
1456                 }
1457         }
1458
1459         return FALSE;
1460 }
1461
1462 /*** Drawing ***/
1463
1464 static guint32
1465 ev_gdk_color_to_rgb (const GdkColor *color)
1466 {
1467   guint32 result;
1468   result = (0xff0000 | (color->red & 0xff00));
1469   result <<= 8;
1470   result |= ((color->green & 0xff00) | (color->blue >> 8));
1471   return result;
1472 }
1473
1474 static void
1475 draw_rubberband (GtkWidget *widget, GdkWindow *window,
1476                  const GdkRectangle *rect, guchar alpha)
1477 {
1478         GdkGC *gc;
1479         GdkPixbuf *pixbuf;
1480         GdkColor *fill_color_gdk;
1481         guint fill_color;
1482
1483         fill_color_gdk = gdk_color_copy (&GTK_WIDGET (widget)->style->base[GTK_STATE_SELECTED]);
1484         fill_color = ev_gdk_color_to_rgb (fill_color_gdk) << 8 | alpha;
1485
1486         pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8,
1487                                  rect->width, rect->height);
1488         gdk_pixbuf_fill (pixbuf, fill_color);
1489
1490         gdk_draw_pixbuf (window, NULL, pixbuf,
1491                          0, 0,
1492                          rect->x - EV_VIEW (widget)->scroll_x, rect->y - EV_VIEW (widget)->scroll_y,
1493                          rect->width, rect->height,
1494                          GDK_RGB_DITHER_NONE,
1495                          0, 0);
1496
1497         g_object_unref (pixbuf);
1498
1499         gc = gdk_gc_new (window);
1500         gdk_gc_set_rgb_fg_color (gc, fill_color_gdk);
1501         gdk_draw_rectangle (window, gc, FALSE,
1502                             rect->x - EV_VIEW (widget)->scroll_x, rect->y - EV_VIEW (widget)->scroll_y,
1503                             rect->width - 1,
1504                             rect->height - 1);
1505         g_object_unref (gc);
1506
1507         gdk_color_free (fill_color_gdk);
1508 }
1509
1510
1511 static void
1512 highlight_find_results (EvView *view, int page)
1513 {
1514         EvDocumentFind *find;
1515         int i, results = 0;
1516
1517         g_return_if_fail (EV_IS_DOCUMENT_FIND (view->document));
1518
1519         find = EV_DOCUMENT_FIND (view->document);
1520
1521         results = ev_document_find_get_n_results (find, page);
1522
1523         for (i = 0; i < results; i++) {
1524                 EvRectangle rectangle;
1525                 GdkRectangle view_rectangle;
1526                 guchar alpha;
1527
1528                 if (i == view->find_result && page == view->find_page) {
1529                         alpha = 0x90;
1530                 } else {
1531                         alpha = 0x20;
1532                 }
1533
1534                 ev_document_find_get_result (find, page,
1535                                              i, &rectangle);
1536                 doc_rect_to_view_rect (view, page, &rectangle, &view_rectangle);
1537                 draw_rubberband (GTK_WIDGET (view), GTK_WIDGET(view)->window,
1538                                  &view_rectangle, alpha);
1539         }
1540 }
1541
1542 static void
1543 draw_one_page (EvView          *view,
1544                gint             page,
1545                GdkRectangle    *page_area,
1546                GtkBorder       *border,
1547                GdkRectangle    *expose_area)
1548 {
1549         gint width, height;
1550         GdkPixbuf *current_pixbuf;
1551         GdkRectangle overlap;
1552         GdkRectangle real_page_area;
1553         EvViewSelection *selection;
1554
1555         g_assert (view->document);
1556         if (! gdk_rectangle_intersect (page_area, expose_area, &overlap))
1557                 return;
1558
1559         selection = find_selection_for_page (view, page);
1560         ev_page_cache_get_size (view->page_cache,
1561                                 page, view->scale,
1562                                 &width, &height);
1563         /* Render the document itself */
1564         real_page_area = *page_area;
1565
1566         real_page_area.x += border->left;
1567         real_page_area.y += border->top;
1568         real_page_area.width -= (border->left + border->right);
1569         real_page_area.height -= (border->top + border->bottom);
1570
1571         ev_document_misc_paint_one_page (GTK_WIDGET(view)->window,
1572                                          GTK_WIDGET (view),
1573                                          page_area, border);
1574
1575         if (gdk_rectangle_intersect (&real_page_area, expose_area, &overlap)) {
1576                 GdkPixbuf *selection_pixbuf = NULL;
1577                 GdkPixbuf *scaled_image;
1578                 GdkPixbuf *scaled_selection;
1579
1580                 current_pixbuf = ev_pixbuf_cache_get_pixbuf (view->pixbuf_cache, page);
1581
1582                 /* Get the selection pixbuf iff we have something to draw */
1583                 if (current_pixbuf && view->selection_mode == EV_VIEW_SELECTION_TEXT && selection)
1584                         selection_pixbuf = ev_pixbuf_cache_get_selection_pixbuf (view->pixbuf_cache,
1585                                                                                  page,
1586                                                                                  view->scale);
1587
1588                 if (current_pixbuf == NULL)
1589                         scaled_image = NULL;
1590                 else if (width == gdk_pixbuf_get_width (current_pixbuf) &&
1591                          height == gdk_pixbuf_get_height (current_pixbuf))
1592                         scaled_image = g_object_ref (current_pixbuf);
1593                 else
1594                         /* FIXME: We don't want to scale the whole area, just the right
1595                          * area of it */
1596                         scaled_image = gdk_pixbuf_scale_simple (current_pixbuf,
1597                                                                 width, height,
1598                                                                 GDK_INTERP_NEAREST);
1599
1600                 if (selection_pixbuf == NULL)
1601                         scaled_selection = NULL;
1602                 else if (width == gdk_pixbuf_get_width (selection_pixbuf) &&
1603                          height == gdk_pixbuf_get_height (selection_pixbuf))
1604                         scaled_selection = g_object_ref (selection_pixbuf);
1605                 else
1606                         /* FIXME: We don't want to scale the whole area, just the right
1607                          * area of it */
1608                         scaled_selection = gdk_pixbuf_scale_simple (selection_pixbuf,
1609                                                                     width, height,
1610                                                                     GDK_INTERP_NEAREST);
1611
1612                 if (scaled_image) {
1613                         gdk_draw_pixbuf (GTK_WIDGET(view)->window,
1614                                          GTK_WIDGET (view)->style->fg_gc[GTK_STATE_NORMAL],
1615                                          scaled_image,
1616                                          overlap.x - real_page_area.x,
1617                                          overlap.y - real_page_area.y,
1618                                          overlap.x, overlap.y,
1619                                          overlap.width, overlap.height,
1620                                          GDK_RGB_DITHER_NORMAL,
1621                                          0, 0);
1622                         g_object_unref (scaled_image);
1623                 }
1624
1625                 if (scaled_selection) {
1626                         gdk_draw_pixbuf (GTK_WIDGET(view)->window,
1627                                          GTK_WIDGET (view)->style->fg_gc[GTK_STATE_NORMAL],
1628                                          scaled_selection,
1629                                          overlap.x - real_page_area.x,
1630                                          overlap.y - real_page_area.y,
1631                                          overlap.x, overlap.y,
1632                                          overlap.width, overlap.height,
1633                                          GDK_RGB_DITHER_NORMAL,
1634                                          0, 0);
1635                         g_object_unref (scaled_selection);
1636                 }
1637         }
1638 }
1639
1640 /*** GObject functions ***/
1641
1642 static void
1643 ev_view_finalize (GObject *object)
1644 {
1645         EvView *view = EV_VIEW (object);
1646
1647         LOG ("Finalize");
1648
1649         g_free (view->status);
1650         g_free (view->find_status);
1651
1652         clear_selection (view);
1653
1654         G_OBJECT_CLASS (ev_view_parent_class)->finalize (object);
1655 }
1656
1657 static void
1658 ev_view_destroy (GtkObject *object)
1659 {
1660         EvView *view = EV_VIEW (object);
1661
1662         if (view->document) {
1663                 g_object_unref (view->document);
1664                 view->document = NULL;
1665         }
1666         if (view->pixbuf_cache) {
1667                 g_object_unref (view->pixbuf_cache);
1668                 view->pixbuf_cache = NULL;
1669         }
1670         ev_view_set_scroll_adjustments (view, NULL, NULL);
1671
1672         GTK_OBJECT_CLASS (ev_view_parent_class)->destroy (object);
1673 }
1674
1675 static void
1676 ev_view_set_property (GObject      *object,
1677                       guint         prop_id,
1678                       const GValue *value,
1679                       GParamSpec   *pspec)
1680 {
1681         EvView *view = EV_VIEW (object);
1682
1683         switch (prop_id)
1684         {
1685         case PROP_CONTINUOUS:
1686                 ev_view_set_continuous (view, g_value_get_boolean (value));
1687                 break;
1688         case PROP_DUAL_PAGE:
1689                 ev_view_set_dual_page (view, g_value_get_boolean (value));
1690                 break;
1691         case PROP_FULLSCREEN:
1692                 ev_view_set_fullscreen (view, g_value_get_boolean (value));
1693                 break;
1694         case PROP_PRESENTATION:
1695                 ev_view_set_presentation (view, g_value_get_boolean (value));
1696                 break;
1697         case PROP_SIZING_MODE:
1698                 ev_view_set_sizing_mode (view, g_value_get_enum (value));
1699                 break;
1700         case PROP_ZOOM:
1701                 ev_view_set_zoom (view, g_value_get_double (value), FALSE);
1702                 break;
1703         default:
1704                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1705         }
1706 }
1707
1708 static void
1709 ev_view_get_property (GObject *object,
1710                       guint prop_id,
1711                       GValue *value,
1712                       GParamSpec *pspec)
1713 {
1714         EvView *view = EV_VIEW (object);
1715
1716         switch (prop_id)
1717         {
1718         case PROP_STATUS:
1719                 g_value_set_string (value, view->status);
1720                 break;
1721         case PROP_FIND_STATUS:
1722                 g_value_set_string (value, view->status);
1723                 break;
1724         case PROP_CONTINUOUS:
1725                 g_value_set_boolean (value, view->continuous);
1726                 break;
1727         case PROP_DUAL_PAGE:
1728                 g_value_set_boolean (value, view->dual_page);
1729                 break;
1730         case PROP_FULLSCREEN:
1731                 g_value_set_boolean (value, view->fullscreen);
1732                 break;
1733         case PROP_PRESENTATION:
1734                 g_value_set_boolean (value, view->presentation);
1735                 break;
1736         case PROP_SIZING_MODE:
1737                 g_value_set_enum (value, view->sizing_mode);
1738                 break;
1739         case PROP_ZOOM:
1740                 g_value_set_double (value, view->scale);
1741                 break;
1742         default:
1743                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1744         }
1745 }
1746
1747 static void
1748 ev_view_class_init (EvViewClass *class)
1749 {
1750         GObjectClass *object_class = G_OBJECT_CLASS (class);
1751         GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (class);
1752         GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
1753         GtkBindingSet *binding_set;
1754
1755         object_class->finalize = ev_view_finalize;
1756         object_class->set_property = ev_view_set_property;
1757         object_class->get_property = ev_view_get_property;
1758
1759         widget_class->expose_event = ev_view_expose_event;
1760         widget_class->button_press_event = ev_view_button_press_event;
1761         widget_class->motion_notify_event = ev_view_motion_notify_event;
1762         widget_class->button_release_event = ev_view_button_release_event;
1763         widget_class->size_request = ev_view_size_request;
1764         widget_class->size_allocate = ev_view_size_allocate;
1765         widget_class->realize = ev_view_realize;
1766         widget_class->unrealize = ev_view_unrealize;
1767         widget_class->scroll_event = ev_view_scroll_event;
1768         gtk_object_class->destroy = ev_view_destroy;
1769
1770         class->set_scroll_adjustments = ev_view_set_scroll_adjustments;
1771         class->binding_activated = ev_view_binding_activated;
1772
1773         widget_class->set_scroll_adjustments_signal =
1774             g_signal_new ("set-scroll-adjustments",
1775                           G_OBJECT_CLASS_TYPE (object_class),
1776                           G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1777                           G_STRUCT_OFFSET (EvViewClass, set_scroll_adjustments),
1778                           NULL, NULL,
1779                           ev_marshal_VOID__OBJECT_OBJECT,
1780                           G_TYPE_NONE, 2,
1781                           GTK_TYPE_ADJUSTMENT,
1782                           GTK_TYPE_ADJUSTMENT);
1783
1784         signals[SIGNAL_BINDING_ACTIVATED] = g_signal_new ("binding_activated",
1785                          G_TYPE_FROM_CLASS (object_class),
1786                          G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1787                          G_STRUCT_OFFSET (EvViewClass, binding_activated),
1788                          NULL, NULL,
1789                          ev_marshal_VOID__ENUM_BOOLEAN,
1790                          G_TYPE_NONE, 2,
1791                          GTK_TYPE_SCROLL_TYPE,
1792                          G_TYPE_BOOLEAN);
1793
1794         signals[SIGNAL_ZOOM_INVALID] = g_signal_new ("zoom-invalid",
1795                          G_TYPE_FROM_CLASS (object_class),
1796                          G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1797                          G_STRUCT_OFFSET (EvViewClass, zoom_invalid),
1798                          NULL, NULL,
1799                          ev_marshal_VOID__VOID,
1800                          G_TYPE_NONE, 0, G_TYPE_NONE);
1801
1802         g_object_class_install_property (object_class,
1803                                          PROP_STATUS,
1804                                          g_param_spec_string ("status",
1805                                                               "Status Message",
1806                                                               "The status message",
1807                                                               NULL,
1808                                                               G_PARAM_READABLE));
1809
1810         g_object_class_install_property (object_class,
1811                                          PROP_FIND_STATUS,
1812                                          g_param_spec_string ("find-status",
1813                                                               "Find Status Message",
1814                                                               "The find status message",
1815                                                               NULL,
1816                                                               G_PARAM_READABLE));
1817
1818         g_object_class_install_property (object_class,
1819                                          PROP_CONTINUOUS,
1820                                          g_param_spec_boolean ("continuous",
1821                                                                "Continuous",
1822                                                                "Continuous scrolling mode",
1823                                                                TRUE,
1824                                                                G_PARAM_READWRITE));
1825
1826         g_object_class_install_property (object_class,
1827                                          PROP_DUAL_PAGE,
1828                                          g_param_spec_boolean ("dual-page",
1829                                                                "Dual Page",
1830                                                                "Two pages visible at once",
1831                                                                FALSE,
1832                                                                G_PARAM_READWRITE));
1833         g_object_class_install_property (object_class,
1834                                          PROP_FULLSCREEN,
1835                                          g_param_spec_boolean ("fullscreen",
1836                                                                "Full Screen",
1837                                                                "Draw page in a fullscreen fashion",
1838                                                                FALSE,
1839                                                                G_PARAM_READWRITE));
1840         g_object_class_install_property (object_class,
1841                                          PROP_PRESENTATION,
1842                                          g_param_spec_boolean ("presentation",
1843                                                                "Presentation",
1844                                                                "Draw page in presentation mode",
1845                                                                TRUE,
1846                                                                G_PARAM_READWRITE));
1847
1848         g_object_class_install_property (object_class,
1849                                          PROP_SIZING_MODE,
1850                                          g_param_spec_enum ("sizing-mode",
1851                                                             "Sizing Mode",
1852                                                             "Sizing Mode",
1853                                                             EV_TYPE_SIZING_MODE,
1854                                                             EV_SIZING_FIT_WIDTH,
1855                                                             G_PARAM_READWRITE));
1856
1857         g_object_class_install_property (object_class,
1858                                          PROP_ZOOM,
1859                                          g_param_spec_double ("zoom",
1860                                                               "Zoom factor",
1861                                                                "Zoom factor",
1862                                                                MIN_SCALE,
1863                                                                MAX_SCALE,
1864                                                                1.0,
1865                                                                G_PARAM_READWRITE));
1866
1867         binding_set = gtk_binding_set_by_class (class);
1868
1869         add_scroll_binding_keypad (binding_set, GDK_Left,  GTK_SCROLL_STEP_BACKWARD, TRUE);
1870         add_scroll_binding_keypad (binding_set, GDK_Right, GTK_SCROLL_STEP_FORWARD,  TRUE);
1871         add_scroll_binding_keypad (binding_set, GDK_Up,    GTK_SCROLL_STEP_BACKWARD, FALSE);
1872         add_scroll_binding_keypad (binding_set, GDK_Down,  GTK_SCROLL_STEP_FORWARD,  FALSE);
1873 }
1874
1875 static void
1876 ev_view_init (EvView *view)
1877 {
1878         GTK_WIDGET_SET_FLAGS (view, GTK_CAN_FOCUS);
1879
1880         view->spacing = 5;
1881         view->scale = 1.0;
1882         view->current_page = 0;
1883         view->pressed_button = -1;
1884         view->cursor = EV_VIEW_CURSOR_NORMAL;
1885         view->drag_info.in_drag = FALSE;
1886         view->selection_info.in_selection = FALSE;
1887
1888         view->selection_mode = EV_VIEW_SELECTION_TEXT;
1889         view->continuous = TRUE;
1890         view->dual_page = FALSE;
1891         view->presentation = FALSE;
1892         view->fullscreen = FALSE;
1893         view->sizing_mode = EV_SIZING_FIT_WIDTH;
1894         view->pending_scroll = SCROLL_TO_KEEP_POSITION;
1895 }
1896
1897 /*** Callbacks ***/
1898
1899 static void
1900 find_changed_cb (EvDocument *document, int page, EvView *view)
1901 {
1902         jump_to_find_page (view);
1903         jump_to_find_result (view);
1904         update_find_status_message (view);
1905
1906         if (view->current_page == page)
1907                 gtk_widget_queue_draw (GTK_WIDGET (view));
1908 }
1909
1910 static void
1911 job_finished_cb (EvPixbufCache *pixbuf_cache,
1912                  EvView        *view)
1913 {
1914         gtk_widget_queue_draw (GTK_WIDGET (view));
1915 }
1916
1917 static void
1918 page_changed_cb (EvPageCache *page_cache,
1919                  int          new_page,
1920                  EvView      *view)
1921 {
1922         if (view->current_page != new_page) {
1923
1924                 view->current_page = new_page;
1925                 view->pending_scroll = SCROLL_TO_CURRENT_PAGE;
1926                 gtk_widget_queue_resize (GTK_WIDGET (view));
1927
1928                 if (EV_IS_DOCUMENT_FIND (view->document)) {
1929                         view->find_page = new_page;
1930                         view->find_result = 0;
1931                         update_find_status_message (view);
1932                 }
1933         }
1934 }
1935
1936 static void on_adjustment_value_changed (GtkAdjustment  *adjustment,
1937                                          EvView *view)
1938 {
1939         int dx = 0, dy = 0;
1940
1941         if (! GTK_WIDGET_REALIZED (view))
1942                 return;
1943
1944         if (view->hadjustment) {
1945                 dx = view->scroll_x - (int) view->hadjustment->value;
1946                 view->scroll_x = (int) view->hadjustment->value;
1947         } else {
1948                 view->scroll_x = 0;
1949         }
1950
1951         if (view->vadjustment) {
1952                 dy = view->scroll_y - (int) view->vadjustment->value;
1953                 view->scroll_y = (int) view->vadjustment->value;
1954         } else {
1955                 view->scroll_y = 0;
1956         }
1957
1958
1959         if (view->pending_resize)
1960                 gtk_widget_queue_draw (GTK_WIDGET (view));
1961         else
1962                 gdk_window_scroll (GTK_WIDGET (view)->window, dx, dy);
1963
1964
1965         if (view->document)
1966                 view_update_range_and_current_page (view);
1967 }
1968
1969 GtkWidget*
1970 ev_view_new (void)
1971 {
1972         GtkWidget *view;
1973
1974         view = g_object_new (EV_TYPE_VIEW, NULL);
1975
1976         return view;
1977 }
1978
1979 static void
1980 setup_caches (EvView *view)
1981 {
1982         view->page_cache = ev_page_cache_get (view->document);
1983         g_signal_connect (view->page_cache, "page-changed", G_CALLBACK (page_changed_cb), view);
1984         view->pixbuf_cache = ev_pixbuf_cache_new (view->document);
1985         g_signal_connect (view->pixbuf_cache, "job-finished", G_CALLBACK (job_finished_cb), view);
1986 }
1987
1988 static void
1989 clear_caches (EvView *view)
1990 {
1991         if (view->pixbuf_cache) {
1992                 g_object_unref (view->pixbuf_cache);
1993                 view->pixbuf_cache = NULL;
1994         }
1995
1996         if (view->document) {
1997                 ev_page_cache_clear (view->document);
1998         }
1999 }
2000
2001 void
2002 ev_view_set_document (EvView     *view,
2003                       EvDocument *document)
2004 {
2005         g_return_if_fail (EV_IS_VIEW (view));
2006
2007         if (document != view->document) {
2008                 clear_caches (view);
2009
2010                 if (view->document) {
2011                         g_signal_handlers_disconnect_by_func (view->document,
2012                                                               find_changed_cb,
2013                                                               view);
2014                         g_object_unref (view->document);
2015                         view->page_cache = NULL;
2016
2017                 }
2018
2019                 view->document = document;
2020                 view->find_page = 0;
2021                 view->find_result = 0;
2022
2023                 if (view->document) {
2024                         g_object_ref (view->document);
2025                         if (EV_IS_DOCUMENT_FIND (view->document)) {
2026                                 g_signal_connect (view->document,
2027                                                   "find_changed",
2028                                                   G_CALLBACK (find_changed_cb),
2029                                                   view);
2030                         }
2031
2032                         setup_caches (view);
2033                 }
2034
2035                 gtk_widget_queue_resize (GTK_WIDGET (view));
2036         }
2037 }
2038
2039 /*** Zoom and sizing mode ***/
2040
2041 #define EPSILON 0.0000001
2042 void
2043 ev_view_set_zoom (EvView   *view,
2044                   double    factor,
2045                   gboolean  relative)
2046 {
2047         double scale;
2048
2049         if (relative)
2050                 scale = view->scale * factor;
2051         else
2052                 scale = factor;
2053
2054         scale = CLAMP (scale, MIN_SCALE, MAX_SCALE);
2055
2056         if (ABS (view->scale - scale) < EPSILON)
2057                 return;
2058
2059         view->scale = scale;
2060         view->pending_resize = TRUE;
2061
2062         gtk_widget_queue_resize (GTK_WIDGET (view));
2063
2064         g_object_notify (G_OBJECT (view), "zoom");
2065 }
2066
2067 double
2068 ev_view_get_zoom (EvView *view)
2069 {
2070         return view->scale;
2071 }
2072
2073 void
2074 ev_view_set_continuous (EvView   *view,
2075                         gboolean  continuous)
2076 {
2077         g_return_if_fail (EV_IS_VIEW (view));
2078
2079         continuous = continuous != FALSE;
2080
2081         if (view->continuous != continuous) {
2082                 view->continuous = continuous;
2083                 view->pending_scroll = SCROLL_TO_CURRENT_PAGE;
2084                 gtk_widget_queue_resize (GTK_WIDGET (view));
2085         }
2086
2087         g_object_notify (G_OBJECT (view), "continuous");
2088 }
2089
2090 void
2091 ev_view_set_dual_page (EvView   *view,
2092                        gboolean  dual_page)
2093 {
2094         g_return_if_fail (EV_IS_VIEW (view));
2095
2096         dual_page = dual_page != FALSE;
2097
2098         if (view->dual_page == dual_page)
2099                 return;
2100
2101         view->pending_scroll = SCROLL_TO_CURRENT_PAGE;
2102         view->dual_page = dual_page;
2103         /* FIXME: if we're keeping the pixbuf cache around, we should extend the
2104          * preload_cache_size to be 2 if dual_page is set.
2105          */
2106         gtk_widget_queue_resize (GTK_WIDGET (view));
2107
2108         g_object_notify (G_OBJECT (view), "dual-page");
2109 }
2110
2111 void
2112 ev_view_set_fullscreen (EvView   *view,
2113                          gboolean  fullscreen)
2114 {
2115         g_return_if_fail (EV_IS_VIEW (view));
2116
2117         fullscreen = fullscreen != FALSE;
2118
2119         if (view->fullscreen != fullscreen) {
2120                 view->fullscreen = fullscreen;
2121                 gtk_widget_queue_resize (GTK_WIDGET (view));
2122         }
2123
2124         g_object_notify (G_OBJECT (view), "fullscreen");
2125 }
2126
2127 gboolean
2128 ev_view_get_fullscreen (EvView *view)
2129 {
2130         g_return_val_if_fail (EV_IS_VIEW (view), FALSE);
2131
2132         return view->fullscreen;
2133 }
2134
2135 void
2136 ev_view_set_presentation (EvView   *view,
2137                           gboolean  presentation)
2138 {
2139         g_return_if_fail (EV_IS_VIEW (view));
2140
2141         presentation = presentation != FALSE;
2142
2143         if (view->presentation == presentation)
2144                 return;
2145
2146         view->presentation = presentation;
2147         gtk_widget_queue_resize (GTK_WIDGET (view));
2148         if (GTK_WIDGET_REALIZED (view)) {
2149                 if (view->presentation)
2150                         gdk_window_set_background (GTK_WIDGET(view)->window,
2151                                                    &GTK_WIDGET (view)->style->black);
2152                 else
2153                         gdk_window_set_background (GTK_WIDGET(view)->window,
2154                                                    &GTK_WIDGET (view)->style->mid [GTK_STATE_NORMAL]);
2155         }
2156
2157
2158         g_object_notify (G_OBJECT (view), "presentation");
2159 }
2160
2161 gboolean
2162 ev_view_get_presentation (EvView *view)
2163 {
2164         g_return_val_if_fail (EV_IS_VIEW (view), FALSE);
2165
2166         return view->presentation;
2167 }
2168
2169 void
2170 ev_view_set_sizing_mode (EvView       *view,
2171                          EvSizingMode  sizing_mode)
2172 {
2173         g_return_if_fail (EV_IS_VIEW (view));
2174
2175         if (view->sizing_mode == sizing_mode)
2176                 return;
2177
2178         view->sizing_mode = sizing_mode;
2179         gtk_widget_queue_resize (GTK_WIDGET (view));
2180
2181         g_object_notify (G_OBJECT (view), "sizing-mode");
2182 }
2183
2184 EvSizingMode
2185 ev_view_get_sizing_mode (EvView *view)
2186 {
2187         g_return_val_if_fail (EV_IS_VIEW (view), EV_SIZING_FREE);
2188
2189         return view->sizing_mode;
2190 }
2191
2192 gboolean
2193 ev_view_can_zoom_in (EvView *view)
2194 {
2195         return view->scale * ZOOM_IN_FACTOR <= MAX_SCALE;
2196 }
2197
2198 gboolean
2199 ev_view_can_zoom_out (EvView *view)
2200 {
2201         return view->scale * ZOOM_OUT_FACTOR >= MIN_SCALE;
2202 }
2203
2204 void
2205 ev_view_zoom_in (EvView *view)
2206 {
2207         g_return_if_fail (view->sizing_mode == EV_SIZING_FREE);
2208
2209         view->pending_scroll = SCROLL_TO_CENTER;
2210         ev_view_set_zoom (view, ZOOM_IN_FACTOR, TRUE);
2211 }
2212
2213 void
2214 ev_view_zoom_out (EvView *view)
2215 {
2216         g_return_if_fail (view->sizing_mode == EV_SIZING_FREE);
2217
2218         view->pending_scroll = SCROLL_TO_CENTER;
2219         ev_view_set_zoom (view, ZOOM_OUT_FACTOR, TRUE);
2220 }
2221
2222 static void
2223 ev_view_set_orientation (EvView         *view,
2224                          EvOrientation   orientation)
2225 {
2226         ev_document_set_orientation (view->document, orientation);
2227
2228         clear_caches (view);
2229         setup_caches (view);
2230
2231         gtk_widget_queue_resize (GTK_WIDGET (view));
2232 }
2233
2234 void
2235 ev_view_rotate_right (EvView *view)
2236 {
2237         EvOrientation orientation, new_orientation;
2238
2239         orientation = ev_document_get_orientation (view->document);
2240         if (orientation == EV_ORIENTATION_PORTRAIT) {
2241                 new_orientation = EV_ORIENTATION_LANDSCAPE;
2242         } else if (orientation == EV_ORIENTATION_LANDSCAPE) {
2243                 new_orientation = EV_ORIENTATION_UPSIDEDOWN;
2244         } else if (orientation == EV_ORIENTATION_UPSIDEDOWN) {
2245                 new_orientation = EV_ORIENTATION_SEASCAPE;
2246         } else {
2247                 new_orientation = EV_ORIENTATION_PORTRAIT;
2248         }
2249         ev_view_set_orientation (view, new_orientation);
2250 }
2251
2252 void
2253 ev_view_rotate_left (EvView *view)
2254 {
2255         EvOrientation orientation, new_orientation;
2256
2257         orientation = ev_document_get_orientation (view->document);
2258         if (orientation == EV_ORIENTATION_PORTRAIT) {
2259                 new_orientation = EV_ORIENTATION_SEASCAPE;
2260         } else if (orientation == EV_ORIENTATION_SEASCAPE) {
2261                 new_orientation = EV_ORIENTATION_UPSIDEDOWN;
2262         } else if (orientation == EV_ORIENTATION_UPSIDEDOWN) {
2263                 new_orientation = EV_ORIENTATION_LANDSCAPE;
2264         } else {
2265                 new_orientation = EV_ORIENTATION_PORTRAIT;
2266         }
2267         ev_view_set_orientation (view, new_orientation);
2268 }
2269
2270 static double
2271 zoom_for_size_fit_width (int doc_width,
2272                          int doc_height,
2273                          int target_width,
2274                          int target_height,
2275                          int vsb_width)
2276 {
2277         double scale;
2278
2279         scale = (double)target_width / doc_width;
2280
2281         if (doc_height * scale > target_height)
2282                 scale = (double) (target_width - vsb_width) / doc_width;
2283
2284         return scale;
2285 }
2286
2287 static double
2288 zoom_for_size_best_fit (int doc_width,
2289                         int doc_height,
2290                         int target_width,
2291                         int target_height,
2292                         int vsb_width,
2293                         int hsb_width)
2294 {
2295         double w_scale;
2296         double h_scale;
2297
2298         w_scale = (double)target_width / doc_width;
2299         h_scale = (double)target_height / doc_height;
2300
2301         if (doc_height * w_scale > target_height)
2302                 w_scale = (double) (target_width - vsb_width) / doc_width;
2303         if (doc_width * h_scale > target_width)
2304                 h_scale = (double) (target_height - hsb_width) / doc_height;
2305
2306         return MIN (w_scale, h_scale);
2307 }
2308
2309
2310 static void
2311 ev_view_zoom_for_size_presentation (EvView *view,
2312                                     int     width,
2313                                     int     height)
2314 {
2315         int doc_width, doc_height;
2316         gdouble scale;
2317
2318         ev_page_cache_get_size (view->page_cache,
2319                                 view->current_page,
2320                                 1.0,
2321                                 &doc_width,
2322                                 &doc_height);
2323         scale = zoom_for_size_best_fit (doc_width, doc_height, width, height, 0, 0);
2324         ev_view_set_zoom (view, scale, FALSE);
2325 }
2326
2327 static void
2328 ev_view_zoom_for_size_continuous_and_dual_page (EvView *view,
2329                            int     width,
2330                            int     height,
2331                            int     vsb_width,
2332                            int     hsb_height)
2333 {
2334         int doc_width, doc_height;
2335         GtkBorder border;
2336         gdouble scale;
2337
2338         ev_page_cache_get_max_width (view->page_cache,
2339                                      1.0,
2340                                      &doc_width);
2341         ev_page_cache_get_max_height (view->page_cache,
2342                                       1.0,
2343                                       &doc_height);
2344         compute_border (view, doc_width, doc_height, &border);
2345
2346         doc_width = doc_width * 2;
2347         width -= (2 * (border.left + border.right) + 3 * view->spacing);
2348         height -= (border.top + border.bottom + 2 * view->spacing - 1);
2349
2350         /* FIXME: We really need to calculate the overall height here, not the
2351          * page height.  We assume there's always a vertical scrollbar for
2352          * now.  We need to fix this. */
2353         if (view->sizing_mode == EV_SIZING_FIT_WIDTH)
2354                 scale = zoom_for_size_fit_width (doc_width, doc_height, width - vsb_width, height, 0);
2355         else if (view->sizing_mode == EV_SIZING_BEST_FIT)
2356                 scale = zoom_for_size_best_fit (doc_width, doc_height, width - vsb_width, height, 0, hsb_height);
2357         else
2358                 g_assert_not_reached ();
2359
2360         ev_view_set_zoom (view, scale, FALSE);
2361 }
2362
2363 static void
2364 ev_view_zoom_for_size_continuous (EvView *view,
2365                                   int     width,
2366                                   int     height,
2367                                   int     vsb_width,
2368                                   int     hsb_height)
2369 {
2370         int doc_width, doc_height;
2371         GtkBorder border;
2372         gdouble scale;
2373
2374         ev_page_cache_get_max_width (view->page_cache,
2375                                      1.0,
2376                                      &doc_width);
2377         ev_page_cache_get_max_height (view->page_cache,
2378                                       1.0,
2379                                       &doc_height);
2380         compute_border (view, doc_width, doc_height, &border);
2381
2382         width -= (border.left + border.right + 2 * view->spacing);
2383         height -= (border.top + border.bottom + 2 * view->spacing - 1);
2384
2385         /* FIXME: We really need to calculate the overall height here, not the
2386          * page height.  We assume there's always a vertical scrollbar for
2387          * now.  We need to fix this. */
2388         if (view->sizing_mode == EV_SIZING_FIT_WIDTH)
2389                 scale = zoom_for_size_fit_width (doc_width, doc_height, width - vsb_width, height, 0);
2390         else if (view->sizing_mode == EV_SIZING_BEST_FIT)
2391                 scale = zoom_for_size_best_fit (doc_width, doc_height, width - vsb_width, height, 0, hsb_height);
2392         else
2393                 g_assert_not_reached ();
2394
2395         ev_view_set_zoom (view, scale, FALSE);
2396 }
2397
2398 static void
2399 ev_view_zoom_for_size_dual_page (EvView *view,
2400                                  int     width,
2401                                  int     height,
2402                                  int     vsb_width,
2403                                  int     hsb_height)
2404 {
2405         GtkBorder border;
2406         gint doc_width, doc_height;
2407         gdouble scale;
2408         gint other_page;
2409
2410         other_page = view->current_page ^ 1;
2411
2412         /* Find the largest of the two. */
2413         ev_page_cache_get_size (view->page_cache,
2414                                 view->current_page,
2415                                 1.0,
2416                                 &doc_width, &doc_height);
2417
2418         if (other_page < ev_page_cache_get_n_pages (view->page_cache)) {
2419                 gint width_2, height_2;
2420                 ev_page_cache_get_size (view->page_cache,
2421                                         other_page,
2422                                         1.0,
2423                                         &width_2, &height_2);
2424                 if (width_2 > doc_width)
2425                         doc_width = width_2;
2426                 if (height_2 > doc_height)
2427                         doc_height = height_2;
2428         }
2429         compute_border (view, doc_width, doc_height, &border);
2430
2431         doc_width = doc_width * 2;
2432         width -= ((border.left + border.right)* 2 + 3 * view->spacing);
2433         height -= (border.top + border.bottom + 2 * view->spacing);
2434
2435         if (view->sizing_mode == EV_SIZING_FIT_WIDTH)
2436                 scale = zoom_for_size_fit_width (doc_width, doc_height, width, height, vsb_width);
2437         else if (view->sizing_mode == EV_SIZING_BEST_FIT)
2438                 scale = zoom_for_size_best_fit (doc_width, doc_height, width, height, vsb_width, hsb_height);
2439         else
2440                 g_assert_not_reached ();
2441
2442         ev_view_set_zoom (view, scale, FALSE);
2443 }
2444
2445 static void
2446 ev_view_zoom_for_size_single_page (EvView *view,
2447                                    int     width,
2448                                    int     height,
2449                                    int     vsb_width,
2450                                    int     hsb_height)
2451 {
2452         int doc_width, doc_height;
2453         GtkBorder border;
2454         gdouble scale;
2455
2456         ev_page_cache_get_size (view->page_cache,
2457                                 view->current_page,
2458                                 1.0,
2459                                 &doc_width,
2460                                 &doc_height);
2461         /* Get an approximate border */
2462         compute_border (view, width, height, &border);
2463
2464         width -= (border.left + border.right + 2 * view->spacing);
2465         height -= (border.top + border.bottom + 2 * view->spacing);
2466
2467         if (view->sizing_mode == EV_SIZING_FIT_WIDTH)
2468                 scale = zoom_for_size_fit_width (doc_width, doc_height, width, height, vsb_width);
2469         else if (view->sizing_mode == EV_SIZING_BEST_FIT)
2470                 scale = zoom_for_size_best_fit (doc_width, doc_height, width, height, vsb_width, hsb_height);
2471         else
2472                 g_assert_not_reached ();
2473
2474         ev_view_set_zoom (view, scale, FALSE);
2475 }
2476
2477 void
2478 ev_view_set_zoom_for_size (EvView *view,
2479                            int     width,
2480                            int     height,
2481                            int     vsb_width,
2482                            int     hsb_height)
2483 {
2484         g_return_if_fail (view->sizing_mode == EV_SIZING_FIT_WIDTH ||
2485                           view->sizing_mode == EV_SIZING_BEST_FIT);
2486         g_return_if_fail (width >= 0);
2487         g_return_if_fail (height >= 0);
2488
2489         if (view->document == NULL)
2490                 return;
2491
2492         if (view->presentation)
2493                 ev_view_zoom_for_size_presentation (view, width, height);
2494         else if (view->continuous && view->dual_page)
2495                 ev_view_zoom_for_size_continuous_and_dual_page (view, width, height, vsb_width, hsb_height);
2496         else if (view->continuous)
2497                 ev_view_zoom_for_size_continuous (view, width, height, vsb_width, hsb_height);
2498         else if (view->dual_page)
2499                 ev_view_zoom_for_size_dual_page (view, width, height, vsb_width, hsb_height);
2500         else
2501                 ev_view_zoom_for_size_single_page (view, width, height, vsb_width, hsb_height);
2502 }
2503
2504 /*** Status text messages ***/
2505
2506 const char *
2507 ev_view_get_status (EvView *view)
2508 {
2509         g_return_val_if_fail (EV_IS_VIEW (view), NULL);
2510
2511         return view->status;
2512 }
2513
2514 static void
2515 ev_view_set_status (EvView *view, const char *message)
2516 {
2517         g_return_if_fail (EV_IS_VIEW (view));
2518
2519         if (message != view->status) {
2520                 g_free (view->status);
2521                 view->status = g_strdup (message);
2522                 g_object_notify (G_OBJECT (view), "status");
2523         }
2524 }
2525
2526 static void
2527 update_find_status_message (EvView *view)
2528 {
2529         char *message;
2530
2531         if (view->current_page == view->find_page) {
2532                 int results;
2533
2534                 results = ev_document_find_get_n_results
2535                                 (EV_DOCUMENT_FIND (view->document),
2536                                  view->current_page);
2537                 /* TRANS: Sometimes this could be better translated as
2538                    "%d hit(s) on this page".  Therefore this string
2539                    contains plural cases. */
2540                 message = g_strdup_printf (ngettext ("%d found on this page",
2541                                                      "%d found on this page",
2542                                                      results),
2543                                            results);
2544         } else {
2545                 double percent;
2546
2547                 percent = ev_document_find_get_progress
2548                                 (EV_DOCUMENT_FIND (view->document));
2549                 if (percent >= (1.0 - 1e-10)) {
2550                         message = g_strdup (_("Not found"));
2551                 } else {
2552                         message = g_strdup_printf (_("%3d%% remaining to search"),
2553                                                    (int) ((1.0 - percent) * 100));
2554                 }
2555
2556         }
2557         ev_view_set_find_status (view, message);
2558         g_free (message);
2559 }
2560
2561 const char *
2562 ev_view_get_find_status (EvView *view)
2563 {
2564         g_return_val_if_fail (EV_IS_VIEW (view), NULL);
2565
2566         return view->find_status;
2567 }
2568
2569 static void
2570 ev_view_set_find_status (EvView *view, const char *message)
2571 {
2572         g_return_if_fail (EV_IS_VIEW (view));
2573
2574         g_free (view->find_status);
2575         view->find_status = g_strdup (message);
2576         g_object_notify (G_OBJECT (view), "find-status");
2577 }
2578
2579 /*** Find ***/
2580
2581 static void
2582 jump_to_find_result (EvView *view)
2583 {
2584         EvDocumentFind *find = EV_DOCUMENT_FIND (view->document);
2585         EvRectangle rect;
2586         GdkRectangle view_rect;
2587         int n_results;
2588         int page = view->find_page;
2589
2590         n_results = ev_document_find_get_n_results (find, page);
2591
2592         if (n_results > view->find_result) {
2593                 ev_document_find_get_result
2594                         (find, page, view->find_result, &rect);
2595
2596                 doc_rect_to_view_rect (view, page, &rect, &view_rect);
2597                 ensure_rectangle_is_visible (view, &view_rect);
2598         }
2599 }
2600
2601 static void
2602 jump_to_find_page (EvView *view)
2603 {
2604         int n_pages, i;
2605
2606         n_pages = ev_page_cache_get_n_pages (view->page_cache);
2607
2608         for (i = 0; i < n_pages; i++) {
2609                 int has_results;
2610                 int page;
2611
2612                 page = i + view->find_page;
2613                 if (page >= n_pages) {
2614                         page = page - n_pages;
2615                 }
2616
2617                 has_results = ev_document_find_page_has_results
2618                                 (EV_DOCUMENT_FIND (view->document), page);
2619                 if (has_results == -1) {
2620                         view->find_page = page;
2621                         break;
2622                 } else if (has_results == 1) {
2623                         ev_page_cache_set_current_page (view->page_cache, page);
2624                         jump_to_find_result (view);
2625                         break;
2626                 }
2627         }
2628 }
2629
2630 gboolean
2631 ev_view_can_find_next (EvView *view)
2632 {
2633         int n_results = 0;
2634
2635         if (EV_IS_DOCUMENT_FIND (view->document)) {
2636                 EvDocumentFind *find = EV_DOCUMENT_FIND (view->document);
2637
2638                 n_results = ev_document_find_get_n_results (find, view->current_page);
2639         }
2640
2641         return n_results > 0;
2642 }
2643
2644 void
2645 ev_view_find_next (EvView *view)
2646 {
2647         EvPageCache *page_cache;
2648         int n_results, n_pages;
2649         EvDocumentFind *find = EV_DOCUMENT_FIND (view->document);
2650
2651         page_cache = ev_page_cache_get (view->document);
2652         n_results = ev_document_find_get_n_results (find, view->current_page);
2653
2654         n_pages = ev_page_cache_get_n_pages (page_cache);
2655
2656         view->find_result++;
2657
2658         if (view->find_result >= n_results) {
2659                 view->find_result = 0;
2660                 view->find_page++;
2661
2662                 if (view->find_page >= n_pages) {
2663                         view->find_page = 0;
2664                 }
2665
2666                 jump_to_find_page (view);
2667         } else {
2668                 jump_to_find_result (view);
2669                 gtk_widget_queue_draw (GTK_WIDGET (view));
2670         }
2671 }
2672
2673 void
2674 ev_view_find_previous (EvView *view)
2675 {
2676         int n_results, n_pages;
2677         EvDocumentFind *find = EV_DOCUMENT_FIND (view->document);
2678         EvPageCache *page_cache;
2679
2680         page_cache = ev_page_cache_get (view->document);
2681
2682         n_results = ev_document_find_get_n_results (find, view->current_page);
2683
2684         n_pages = ev_page_cache_get_n_pages (page_cache);
2685
2686         view->find_result--;
2687
2688         if (view->find_result < 0) {
2689                 view->find_result = 0;
2690                 view->find_page--;
2691
2692                 if (view->find_page < 0) {
2693                         view->find_page = n_pages - 1;
2694                 }
2695
2696                 jump_to_find_page (view);
2697         } else {
2698                 jump_to_find_result (view);
2699                 gtk_widget_queue_draw (GTK_WIDGET (view));
2700         }
2701 }
2702
2703 /*** Selections ***/
2704
2705 /* compute_new_selection_rect/text calculates the area currently selected by
2706  * view_rect.  each handles a different mode;
2707  */
2708 static GList *
2709 compute_new_selection_rect (EvView       *view,
2710                             GdkPoint     *start,
2711                             GdkPoint     *stop)
2712 {
2713         GdkRectangle view_rect;
2714         int n_pages, i;
2715         GList *list = NULL;
2716
2717         g_assert (view->selection_mode == EV_VIEW_SELECTION_RECTANGLE);
2718
2719         view_rect.x = MIN (start->x, stop->x);
2720         view_rect.y = MIN (start->y, stop->y);
2721         view_rect.width = MAX (start->x, stop->x) - view_rect.x;
2722         view_rect.width = MAX (start->y, stop->y) - view_rect.y;
2723
2724         n_pages = ev_page_cache_get_n_pages (view->page_cache);
2725
2726         for (i = 0; i < n_pages; i++) {
2727                 GdkRectangle page_area;
2728                 GtkBorder border;
2729
2730                 if (get_page_extents (view, i, &page_area, &border)) {
2731                         GdkRectangle overlap;
2732
2733                         if (gdk_rectangle_intersect (&page_area, &view_rect, &overlap)) {
2734                                 EvViewSelection *selection;
2735
2736                                 selection = g_new0 (EvViewSelection, 1);
2737                                 selection->page = i;
2738                                 view_rect_to_doc_rect (view, &overlap, &page_area,
2739                                                        &(selection->rect));
2740
2741                                 list = g_list_append (list, selection);
2742                         }
2743                 }
2744         }
2745
2746         return list;
2747 }
2748
2749 static gboolean
2750 gdk_rectangle_point_in (GdkRectangle *rectangle,
2751                         GdkPoint     *point)
2752 {
2753         return rectangle->x <= point->x &&
2754                 rectangle->y <= point->y &&
2755                 point->x < rectangle->x + rectangle->width &&
2756                 point->y < rectangle->y + rectangle->height;
2757 }
2758
2759 static GList *
2760 compute_new_selection_text (EvView   *view,
2761                             GdkPoint *start,
2762                             GdkPoint *stop)
2763 {
2764         int n_pages, i, first, last;
2765         GList *list = NULL;
2766         EvViewSelection *selection;
2767         gint width, height;
2768
2769         g_assert (view->selection_mode == EV_VIEW_SELECTION_TEXT);
2770
2771         n_pages = ev_page_cache_get_n_pages (view->page_cache);
2772
2773         /* First figure out the range of pages the selection
2774          * affects. */
2775         first = n_pages;
2776         last = 0;
2777         for (i = 0; i < n_pages; i++) {
2778                 GdkRectangle page_area;
2779                 GtkBorder border;
2780
2781                 get_page_extents (view, i, &page_area, &border);
2782                 if (gdk_rectangle_point_in (&page_area, start) ||
2783                     gdk_rectangle_point_in (&page_area, stop)) {
2784                         if (first == n_pages)
2785                                 first = i;
2786                         last = i;
2787                 }
2788
2789         }
2790
2791
2792
2793         /* Now create a list of EvViewSelection's for the affected
2794          * pages.  This could be an empty list, a list of just one
2795          * page or a number of pages.*/
2796         for (i = first; i < last + 1; i++) {
2797                 GdkRectangle page_area;
2798                 GtkBorder border;
2799                 GdkPoint *point;
2800
2801                 ev_page_cache_get_size (view->page_cache, i,
2802                                         1.0, &width, &height);
2803
2804                 selection = g_new0 (EvViewSelection, 1);
2805                 selection->page = i;
2806                 selection->rect.x1 = selection->rect.y1 = 0;
2807                 selection->rect.x2 = width;
2808                 selection->rect.y2 = height;
2809
2810                 get_page_extents (view, i, &page_area, &border);
2811
2812                 if (gdk_rectangle_point_in (&page_area, start))
2813                         point = start;
2814                 else
2815                         point = stop;
2816
2817                 if (i == first)
2818                         view_point_to_doc_point (view, point, &page_area,
2819                                                  &selection->rect.x1,
2820                                                  &selection->rect.y1);
2821
2822                 /* If the selection is contained within just one page,
2823                  * make sure we don't write 'start' into both points
2824                  * in selection->rect. */
2825                 if (first == last)
2826                         point = stop;
2827
2828                 if (i == last)
2829                         view_point_to_doc_point (view, point, &page_area,
2830                                                  &selection->rect.x2,
2831                                                  &selection->rect.y2);
2832
2833                 list = g_list_append (list, selection);
2834         }
2835
2836         return list;
2837 }
2838
2839 /* This function takes the newly calculated list, and figures out which regions
2840  * have changed.  It then queues a redraw approporiately.
2841  */
2842 static void
2843 merge_selection_region (EvView *view,
2844                         GList  *list)
2845 {
2846
2847         /* FIXME: actually write... */
2848         clear_selection (view);
2849         gtk_widget_queue_draw (GTK_WIDGET (view));
2850
2851         view->selection_info.selections = list;
2852         ev_pixbuf_cache_set_selection_list (view->pixbuf_cache, list);
2853 }
2854
2855 static void
2856 compute_selections (EvView   *view,
2857                     GdkPoint *start,
2858                     GdkPoint *stop)
2859 {
2860         GList *list;
2861
2862         if (view->selection_mode == EV_VIEW_SELECTION_RECTANGLE)
2863                 list = compute_new_selection_rect (view, start, stop);
2864         else
2865                 list = compute_new_selection_text (view, start, stop);
2866         merge_selection_region (view, list);
2867 }
2868
2869 /* Free's the selection.  It's up to the caller to queue redraws if needed.
2870  */
2871 static void
2872 selection_free (EvViewSelection *selection)
2873 {
2874         g_free (selection);
2875 }
2876
2877 static void
2878 clear_selection (EvView *view)
2879 {
2880         g_list_foreach (view->selection_info.selections, (GFunc)selection_free, NULL);
2881         view->selection_info.selections = NULL;
2882         view->selection_info.in_selection = FALSE;
2883 }
2884
2885
2886 void
2887 ev_view_select_all (EvView *view)
2888 {
2889         int n_pages, i;
2890
2891         clear_selection (view);
2892
2893         n_pages = ev_page_cache_get_n_pages (view->page_cache);
2894         for (i = 0; i < n_pages; i++) {
2895                 int width, height;
2896                 EvViewSelection *selection;
2897
2898                 ev_page_cache_get_size (view->page_cache,
2899                                         i, 1.0, &width, &height);
2900
2901                 selection = g_new0 (EvViewSelection, 1);
2902                 selection->page = i;
2903                 selection->rect.x1 = selection->rect.y1 = 0;
2904                 selection->rect.x2 = width;
2905                 selection->rect.y2 = height;
2906
2907                 view->selection_info.selections = g_list_append (view->selection_info.selections, selection);
2908         }
2909
2910         ev_pixbuf_cache_set_selection_list (view->pixbuf_cache, view->selection_info.selections);
2911         gtk_widget_queue_draw (GTK_WIDGET (view));
2912 }
2913
2914 static char *
2915 get_selected_text (EvView *ev_view)
2916 {
2917         GString *text;
2918         GList *l;
2919
2920         text = g_string_new (NULL);
2921
2922         ev_document_doc_mutex_lock ();
2923
2924         for (l = ev_view->selection_info.selections; l != NULL; l = l->next) {
2925                 EvViewSelection *selection = (EvViewSelection *)l->data;
2926                 char *tmp;
2927
2928                 tmp = ev_document_get_text (ev_view->document,
2929                                             selection->page,
2930                                             &selection->rect);
2931                 g_string_append (text, tmp);
2932                 g_free (tmp);
2933         }
2934
2935         ev_document_doc_mutex_unlock ();
2936
2937         return g_string_free (text, FALSE);
2938 }
2939
2940 void
2941 ev_view_copy (EvView *ev_view)
2942 {
2943         GtkClipboard *clipboard;
2944         char *text;
2945
2946         if (!ev_document_can_get_text (ev_view->document)) {
2947                 return;
2948         }
2949
2950         text = get_selected_text (ev_view);
2951         clipboard = gtk_widget_get_clipboard (GTK_WIDGET (ev_view),
2952                                               GDK_SELECTION_CLIPBOARD);
2953         gtk_clipboard_set_text (clipboard, text, -1);
2954         g_free (text);
2955 }
2956
2957 static void
2958 ev_view_primary_get_cb (GtkClipboard     *clipboard,
2959                         GtkSelectionData *selection_data,
2960                         guint             info,
2961                         gpointer          data)
2962 {
2963         EvView *ev_view = EV_VIEW (data);
2964         char *text;
2965
2966         if (!ev_document_can_get_text (ev_view->document)) {
2967                 return;
2968         }
2969
2970         text = get_selected_text (ev_view);
2971         gtk_selection_data_set_text (selection_data, text, -1);
2972         g_free (text);
2973 }
2974
2975 static void
2976 ev_view_primary_clear_cb (GtkClipboard *clipboard,
2977                           gpointer      data)
2978 {
2979         EvView *view = EV_VIEW (data);
2980
2981         clear_selection (view);
2982 }
2983
2984 static void
2985 ev_view_update_primary_selection (EvView *ev_view)
2986 {
2987         GtkClipboard *clipboard;
2988
2989         clipboard = gtk_widget_get_clipboard (GTK_WIDGET (ev_view),
2990                                               GDK_SELECTION_PRIMARY);
2991
2992         if (ev_view->selection_info.selections) {
2993                 if (!gtk_clipboard_set_with_owner (clipboard,
2994                                                    targets,
2995                                                    G_N_ELEMENTS (targets),
2996                                                    ev_view_primary_get_cb,
2997                                                    ev_view_primary_clear_cb,
2998                                                    G_OBJECT (ev_view)))
2999                         ev_view_primary_clear_cb (clipboard, ev_view);
3000         } else {
3001                 if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (ev_view))
3002                         gtk_clipboard_clear (clipboard);
3003         }
3004 }
3005
3006 /*** Cursor operations ***/
3007
3008 static GdkCursor *
3009 ev_view_create_invisible_cursor(void)
3010 {
3011        GdkBitmap *empty;
3012        GdkColor black = { 0, 0, 0, 0 };
3013        static char bits[] = { 0x00 };
3014
3015        empty = gdk_bitmap_create_from_data (NULL, bits, 1, 1);
3016
3017        return gdk_cursor_new_from_pixmap (empty, empty, &black, &black, 0, 0);
3018 }
3019
3020 static void
3021 ev_view_set_cursor (EvView *view, EvViewCursor new_cursor)
3022 {
3023         GdkCursor *cursor = NULL;
3024         GdkDisplay *display;
3025         GtkWidget *widget;
3026
3027         if (view->cursor == new_cursor) {
3028                 return;
3029         }
3030
3031         widget = gtk_widget_get_toplevel (GTK_WIDGET (view));
3032         display = gtk_widget_get_display (widget);
3033         view->cursor = new_cursor;
3034
3035         switch (new_cursor) {
3036                 case EV_VIEW_CURSOR_NORMAL:
3037                         gdk_window_set_cursor (widget->window, NULL);
3038                         break;
3039                 case EV_VIEW_CURSOR_LINK:
3040                         cursor = gdk_cursor_new_for_display (display, GDK_HAND2);
3041                         break;
3042                 case EV_VIEW_CURSOR_WAIT:
3043                         cursor = gdk_cursor_new_for_display (display, GDK_WATCH);
3044                         break;
3045                 case EV_VIEW_CURSOR_HIDDEN:
3046                         cursor = ev_view_create_invisible_cursor ();
3047                         break;
3048                 case EV_VIEW_CURSOR_DRAG:
3049                         cursor = gdk_cursor_new_for_display (display, GDK_FLEUR);
3050                         break;
3051         }
3052
3053         if (cursor) {
3054                 gdk_window_set_cursor (widget->window, cursor);
3055                 gdk_cursor_unref (cursor);
3056                 gdk_flush();
3057         }
3058 }
3059
3060 void
3061 ev_view_hide_cursor (EvView *view)
3062 {
3063        ev_view_set_cursor (view, EV_VIEW_CURSOR_HIDDEN);
3064 }
3065
3066 void
3067 ev_view_show_cursor (EvView *view)
3068 {
3069        ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
3070 }
3071
3072 /*** Enum description for usage in signal ***/
3073
3074 GType
3075 ev_sizing_mode_get_type (void)
3076 {
3077   static GType etype = 0;
3078   if (etype == 0) {
3079     static const GEnumValue values[] = {
3080       { EV_SIZING_FIT_WIDTH, "EV_SIZING_FIT_WIDTH", "fit-width" },
3081       { EV_SIZING_BEST_FIT, "EV_SIZING_BEST_FIT", "best-fit" },
3082       { EV_SIZING_FREE, "EV_SIZING_FREE", "free" },
3083       { 0, NULL, NULL }
3084     };
3085     etype = g_enum_register_static ("EvSizingMode", values);
3086   }
3087   return etype;
3088 }
3089