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 <string.h>
  23 #include <gtk/gtkalignment.h>
  24 #include <glib/gi18n.h>
  25 #include <gtk/gtkbindings.h>
  26 #include <gtk/gtkselection.h>
  27 #include <gtk/gtkclipboard.h>
  28 #include <gdk/gdkkeysyms.h>
  29 #include <libgnomevfs/gnome-vfs-utils.h>
  30
  31 #include "ev-marshal.h"
  32 #include "ev-view.h"
  33 #include "ev-view-private.h"
  34 #include "ev-utils.h"
  35 #include "ev-selection.h"
  36 #include "ev-document-find.h"
  37 #include "ev-document-misc.h"
  38 #include "ev-debug.h"
  39 #include "ev-job-queue.h"
  40 #include "ev-page-cache.h"
  41 #include "ev-pixbuf-cache.h"
  42 #include "ev-tooltip.h"
  43
  44 #define EV_VIEW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), EV_TYPE_VIEW, EvViewClass))
  45 #define EV_IS_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EV_TYPE_VIEW))
  46 #define EV_VIEW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), EV_TYPE_VIEW, EvViewClass))
  47
  48
  49 enum {
  50         PROP_0,
  51         PROP_STATUS,
  52         PROP_FIND_STATUS,
  53         PROP_CONTINUOUS,
  54         PROP_DUAL_PAGE,
  55         PROP_FULLSCREEN,
  56         PROP_PRESENTATION,
  57         PROP_SIZING_MODE,
  58         PROP_ZOOM,
  59         PROP_ROTATION,
  60         PROP_HAS_SELECTION,
  61 };
  62
  63 enum {
  64         SIGNAL_BINDING_ACTIVATED,
  65         SIGNAL_ZOOM_INVALID,
  66         SIGNAL_EXTERNAL_LINK,
  67         SIGNAL_POPUP_MENU,
  68         N_SIGNALS,
  69 };
  70
  71 enum {
  72         TARGET_STRING,
  73         TARGET_TEXT,
  74         TARGET_COMPOUND_TEXT,
  75         TARGET_UTF8_STRING,
  76         TARGET_TEXT_BUFFER_CONTENTS
  77 };
  78
  79 static const GtkTargetEntry targets[] = {
  80         { "STRING", 0, TARGET_STRING },
  81         { "TEXT",   0, TARGET_TEXT },
  82         { "COMPOUND_TEXT", 0, TARGET_COMPOUND_TEXT },
  83         { "UTF8_STRING", 0, TARGET_UTF8_STRING },
  84 };
  85
  86 static guint signals[N_SIGNALS];
  87
  88 typedef enum {
  89         EV_VIEW_FIND_NEXT,
  90         EV_VIEW_FIND_PREV
  91 } EvViewFindDirection;
  92
  93 #define ZOOM_IN_FACTOR  1.2
  94 #define ZOOM_OUT_FACTOR (1.0/ZOOM_IN_FACTOR)
  95
  96 #define MIN_SCALE 0.05409
  97 #define MAX_SCALE 4.0
  98
  99 #define SCROLL_TIME 150
 100
 101 /*** Scrolling ***/
 102 static void       scroll_to_current_page                     (EvView *view,
 103                                                               GtkOrientation orientation);
 104 static void       ev_view_set_scroll_adjustments             (EvView             *view,
 105                                                               GtkAdjustment      *hadjustment,
 106                                                               GtkAdjustment      *vadjustment);
 107 static void       view_update_range_and_current_page         (EvView             *view);
 108 static void       set_scroll_adjustment                      (EvView             *view,
 109                                                               GtkOrientation      orientation,
 110                                                               GtkAdjustment      *adjustment);
 111 static void       ev_view_set_scroll_adjustments             (EvView             *view,
 112                                                               GtkAdjustment      *hadjustment,
 113                                                               GtkAdjustment      *vadjustment);
 114 static void       add_scroll_binding_keypad                  (GtkBindingSet      *binding_set,
 115                                                               guint               keyval,
 116                                                               GdkModifierType modifiers,
 117                                                               EvScrollType       scroll,
 118                                                               gboolean            horizontal);
 119 static void       ensure_rectangle_is_visible                (EvView             *view,
 120                                                               GdkRectangle       *rect);
 121
 122 /*** Geometry computations ***/
 123 static void       compute_border                             (EvView             *view,
 124                                                               int                 width,
 125                                                               int                 height,
 126                                                               GtkBorder          *border);
 127 static void       get_page_y_offset                          (EvView *view,
 128                                                               int page,
 129                                                               double zoom,
 130                                                               int *y_offset);
 131 static gboolean   get_page_extents                           (EvView             *view,
 132                                                               gint                page,
 133                                                               GdkRectangle       *page_area,
 134                                                               GtkBorder          *border);
 135 static void       view_rect_to_doc_rect                      (EvView             *view,
 136                                                               GdkRectangle       *view_rect,
 137                                                               GdkRectangle       *page_area,
 138                                                               EvRectangle        *doc_rect);
 139 static void       doc_rect_to_view_rect                      (EvView             *view,
 140                                                               int                 page,
 141                                                               EvRectangle        *doc_rect,
 142                                                               GdkRectangle       *view_rect);
 143 static void       find_page_at_location                      (EvView             *view,
 144                                                               gdouble             x,
 145                                                               gdouble             y,
 146                                                               gint               *page,
 147                                                               gint               *x_offset,
 148                                                               gint               *y_offset);
 149 static gboolean  doc_point_to_view_point                     (EvView       *view,
 150                                                               int           page,
 151                                                               EvPoint      *doc_point,
 152                                                               GdkPoint     *view_point);
 153 /*** Hyperrefs ***/
 154 static EvLink *   ev_view_get_link_at_location               (EvView  *view,
 155                                                               gdouble  x,
 156                                                               gdouble  y);
 157 static char*      tip_from_link                              (EvView             *view,
 158                                                               EvLink             *link);
 159 static void       handle_link_over_xy                        (EvView *view,
 160                                                               gint x,
 161                                                               gint y);
 162 /*** GtkWidget implementation ***/
 163 static void       ev_view_size_request_continuous_dual_page  (EvView             *view,
 164                                                               GtkRequisition     *requisition);
 165 static void       ev_view_size_request_continuous            (EvView             *view,
 166                                                               GtkRequisition     *requisition);
 167 static void       ev_view_size_request_dual_page             (EvView             *view,
 168                                                               GtkRequisition     *requisition);
 169 static void       ev_view_size_request_single_page           (EvView             *view,
 170                                                               GtkRequisition     *requisition);
 171 static void       ev_view_size_request                       (GtkWidget          *widget,
 172                                                               GtkRequisition     *requisition);
 173 static void       ev_view_size_allocate                      (GtkWidget          *widget,
 174                                                               GtkAllocation      *allocation);
 175 static void       ev_view_realize                            (GtkWidget          *widget);
 176 static gboolean   ev_view_scroll_event                       (GtkWidget          *widget,
 177                                                               GdkEventScroll     *event);
 178 static gboolean   ev_view_expose_event                       (GtkWidget          *widget,
 179                                                               GdkEventExpose     *event);
 180 static gboolean   ev_view_popup_menu                         (GtkWidget          *widget);
 181 static gboolean   ev_view_button_press_event                 (GtkWidget          *widget,
 182                                                               GdkEventButton     *event);
 183 static gboolean   ev_view_motion_notify_event                (GtkWidget          *widget,
 184                                                               GdkEventMotion     *event);
 185 static gboolean   ev_view_button_release_event               (GtkWidget          *widget,
 186                                                               GdkEventButton     *event);
 187 static gboolean   ev_view_enter_notify_event                 (GtkWidget          *widget,
 188                                                               GdkEventCrossing   *event);
 189 static gboolean   ev_view_leave_notify_event                 (GtkWidget          *widget,
 190                                                               GdkEventCrossing   *event);
 191 static void       ev_view_style_set                          (GtkWidget          *widget,
 192                                                               GtkStyle           *old_style);
 193
 194 static AtkObject *ev_view_get_accessible                     (GtkWidget *widget);
 195
 196 /*** Drawing ***/
 197 static guint32    ev_gdk_color_to_rgb                        (const GdkColor     *color);
 198 static void       draw_rubberband                            (GtkWidget          *widget,
 199                                                               GdkWindow          *window,
 200                                                               const GdkRectangle *rect,
 201                                                               guchar              alpha);
 202 static void       highlight_find_results                     (EvView             *view,
 203                                                               int                 page);
 204 static void       draw_one_page                              (EvView             *view,
 205                                                               gint                page,
 206                                                               GdkRectangle       *page_area,
 207                                                               GtkBorder          *border,
 208                                                               GdkRectangle       *expose_area);
 209 static void       draw_loading_text                          (EvView             *view,
 210                                                               GdkRectangle       *page_area,
 211                                                               GdkRectangle       *expose_area);
 212
 213 /*** Callbacks ***/
 214 static void       find_changed_cb                            (EvDocument         *document,
 215                                                               int                 page,
 216                                                               EvView             *view);
 217 static void       job_finished_cb                            (EvPixbufCache      *pixbuf_cache,
 218                                                               EvView             *view);
 219 static void       page_changed_cb                            (EvPageCache        *page_cache,
 220                                                               int                 new_page,
 221                                                               EvView             *view);
 222 static void       on_adjustment_value_changed                (GtkAdjustment      *adjustment,
 223                                                               EvView             *view);
 224
 225 /*** GObject ***/
 226 static void       ev_view_finalize                           (GObject            *object);
 227 static void       ev_view_destroy                            (GtkObject          *object);
 228 static void       ev_view_set_property                       (GObject            *object,
 229                                                               guint               prop_id,
 230                                                               const GValue       *value,
 231                                                               GParamSpec         *pspec);
 232 static void       ev_view_get_property                       (GObject            *object,
 233                                                               guint               prop_id,
 234                                                               GValue             *value,
 235                                                               GParamSpec         *pspec);
 236 static void       ev_view_class_init                         (EvViewClass        *class);
 237 static void       ev_view_init                               (EvView             *view);
 238
 239 /*** Zoom and sizing ***/
 240 static double   zoom_for_size_fit_width                      (int doc_width,
 241                                                               int doc_height,
 242                                                               int target_width,
 243                                                               int target_height,
 244                                                               int vsb_width);
 245 static double   zoom_for_size_fit_height                     (int doc_width,
 246                                                               int doc_height,
 247                                                               int target_width,
 248                                                               int target_height,
 249                                                               int vsb_height);
 250 static double   zoom_for_size_best_fit                       (int doc_width,
 251                                                               int doc_height,
 252                                                               int target_width,
 253                                                               int target_height,
 254                                                               int vsb_width,
 255                                                               int hsb_width);
 256 static void     ev_view_zoom_for_size_presentation           (EvView *view,
 257                                                               int     width,
 258                                                               int     height);
 259 static void     ev_view_zoom_for_size_continuous_and_dual_page (EvView *view,
 260                                                                 int     width,
 261                                                                 int     height,
 262                                                                 int     vsb_width,
 263                                                                 int     hsb_height);
 264 static void     ev_view_zoom_for_size_continuous               (EvView *view,
 265                                                                 int     width,
 266                                                                 int     height,
 267                                                                 int     vsb_width,
 268                                                                 int     hsb_height);
 269 static void     ev_view_zoom_for_size_dual_page                (EvView *view,
 270                                                                 int     width,
 271                                                                 int     height,
 272                                                                 int     vsb_width,
 273                                                                 int     hsb_height);
 274 static void     ev_view_zoom_for_size_single_page              (EvView *view,
 275                                                                 int     width,
 276                                                                 int     height,
 277                                                                 int     vsb_width,
 278                                                                 int     hsb_height);
 279 /*** Cursors ***/
 280 static GdkCursor* ev_view_create_invisible_cursor            (void);
 281 static void       ev_view_set_cursor                         (EvView             *view,
 282                                                               EvViewCursor        new_cursor);
 283
 284 /*** Status messages ***/
 285 static void       ev_view_set_status                         (EvView             *view,
 286                                                               const char         *message);
 287 static void       update_find_status_message                 (EvView             *view,
 288                                                               gboolean            this_page);
 289 static void       ev_view_set_find_status                    (EvView             *view,
 290                                                               const char         *message);
 291 /*** Find ***/
 292 static void       jump_to_find_result                        (EvView             *view);
 293 static void       jump_to_find_page                          (EvView             *view,
 294                                                               EvViewFindDirection direction,
 295                                                               gint                shift);
 296
 297 /*** Selection ***/
 298 static void       compute_selections                         (EvView             *view,
 299                                                               GdkPoint           *start,
 300                                                               GdkPoint           *stop);
 301 static void       clear_selection                            (EvView             *view);
 302 static void       selection_free                             (EvViewSelection    *selection);
 303 static char*      get_selected_text                          (EvView             *ev_view);
 304 static void       ev_view_primary_get_cb                     (GtkClipboard       *clipboard,
 305                                                               GtkSelectionData   *selection_data,
 306                                                               guint               info,
 307                                                               gpointer            data);
 308 static void       ev_view_primary_clear_cb                   (GtkClipboard       *clipboard,
 309                                                               gpointer            data);
 310 static void       ev_view_update_primary_selection           (EvView             *ev_view);
 311
 312
 313 G_DEFINE_TYPE (EvView, ev_view, GTK_TYPE_WIDGET)
 314
 315 static void
 316 scroll_to_current_page (EvView *view, GtkOrientation orientation)
 317 {
 318         GdkPoint view_point;
 319
 320         if (view->document == NULL) {
 321                 return;
 322         }
 323
 324         doc_point_to_view_point (view, view->current_page, &view->pending_point, &view_point);
 325
 326         if (orientation == GTK_ORIENTATION_VERTICAL) {
 327                 view->pending_point.y = 0;
 328         } else {
 329                 view->pending_point.x = 0;
 330         }
 331
 332         if (orientation == GTK_ORIENTATION_VERTICAL) {
 333                 if (view->continuous) {
 334                         gtk_adjustment_clamp_page (view->vadjustment,
 335                                                    view_point.y - view->spacing / 2,
 336                                                    view_point.y + view->vadjustment->page_size);
 337                 } else {
 338                         gtk_adjustment_set_value (view->vadjustment,
 339                                                   CLAMP (view_point.y,
 340                                                   view->vadjustment->lower,
 341                                                   view->vadjustment->upper -
 342                                                   view->vadjustment->page_size));
 343                 }
 344         } else {
 345                 if (view->dual_page) {
 346                         gtk_adjustment_clamp_page (view->hadjustment,
 347                                                    view_point.x,
 348                                                    view_point.x + view->hadjustment->page_size);
 349                 } else {
 350                         gtk_adjustment_set_value (view->hadjustment,
 351                                                   CLAMP (view_point.x,
 352                                                   view->hadjustment->lower,
 353                                                   view->hadjustment->upper -
 354                                                   view->hadjustment->page_size));
 355                 }
 356         }
 357 }
 358
 359 static void
 360 view_set_adjustment_values (EvView         *view,
 361                             GtkOrientation  orientation)
 362 {
 363         GtkWidget *widget = GTK_WIDGET (view);
 364         GtkAdjustment *adjustment;
 365         int requisition;
 366         int allocation;
 367
 368         double factor;
 369         gint new_value;
 370
 371         if (orientation == GTK_ORIENTATION_HORIZONTAL)  {
 372                 requisition = widget->requisition.width;
 373                 allocation = widget->allocation.width;
 374                 adjustment = view->hadjustment;
 375         } else {
 376                 requisition = widget->requisition.height;
 377                 allocation = widget->allocation.height;
 378                 adjustment = view->vadjustment;
 379         }
 380
 381         if (!adjustment)
 382                 return;
 383
 384         factor = 1.0;
 385         switch (view->pending_scroll) {
 386                 case SCROLL_TO_KEEP_POSITION:
 387                         factor = (adjustment->value) / adjustment->upper;
 388                         break;
 389                 case SCROLL_TO_PAGE_POSITION:
 390                         break;
 391                 case SCROLL_TO_CENTER:
 392                         factor = (adjustment->value + adjustment->page_size * 0.5) / adjustment->upper;
 393                         break;
 394         }
 395
 396         adjustment->page_size = allocation;
 397         adjustment->step_increment = allocation * 0.1;
 398         adjustment->page_increment = allocation * 0.9;
 399         adjustment->lower = 0;
 400         adjustment->upper = MAX (allocation, requisition);
 401
 402         /*
 403          * We add 0.5 to the values before to average out our rounding errors.
 404          */
 405         switch (view->pending_scroll) {
 406                 case SCROLL_TO_KEEP_POSITION:
 407                         new_value = CLAMP (adjustment->upper * factor + 0.5, 0, adjustment->upper - adjustment->page_size);
 408                         gtk_adjustment_set_value (adjustment, (int)new_value);
 409                         break;
 410                 case SCROLL_TO_PAGE_POSITION:
 411                         scroll_to_current_page (view, orientation);
 412                         break;
 413                 case SCROLL_TO_CENTER:
 414                         new_value = CLAMP (adjustment->upper * factor - adjustment->page_size * 0.5 + 0.5,
 415                                            0, adjustment->upper - adjustment->page_size);
 416                         gtk_adjustment_set_value (adjustment, (int)new_value);
 417                         break;
 418         }
 419
 420         gtk_adjustment_changed (adjustment);
 421 }
 422
 423 static void
 424 view_update_range_and_current_page (EvView *view)
 425 {
 426         gint current_page;
 427         gint best_current_page = -1;
 428
 429         if (view->pending_scroll != SCROLL_TO_KEEP_POSITION)
 430                 return;
 431
 432         /* Presentation trumps all other modes */
 433         if (view->presentation) {
 434                 view->start_page = view->current_page;
 435                 view->end_page = view->current_page;
 436         } else if (view->continuous) {
 437                 GdkRectangle current_area, unused, page_area;
 438                 GtkBorder border;
 439                 gboolean found = FALSE;
 440                 gint area_max, area;
 441                 int i;
 442
 443                 if (!(view->vadjustment && view->hadjustment))
 444                         return;
 445
 446                 current_area.x = view->hadjustment->value;
 447                 current_area.width = view->hadjustment->upper;
 448                 current_area.y = view->vadjustment->value;
 449                 current_area.height = view->vadjustment->page_size;
 450
 451                 for (i = 0; i < ev_page_cache_get_n_pages (view->page_cache); i++) {
 452
 453                         get_page_extents (view, i, &page_area, &border);
 454
 455                         if (gdk_rectangle_intersect (&current_area, &page_area, &unused)) {
 456                                 area = unused.width * unused.height;
 457
 458                                 if (!found) {
 459                                         area_max = area;
 460                                         view->start_page = i;
 461                                         found = TRUE;
 462                                         best_current_page = i;
 463                                 }
 464                                 if (area > area_max) {
 465                                         best_current_page = (area == area_max) ? MIN (i, best_current_page) : i;
 466                                         area_max = area;
 467                                 }
 468
 469                                 view->end_page = i;
 470                         } else if (found) {
 471                                 break;
 472                         }
 473                 }
 474
 475         } else if (view->dual_page) {
 476                 if (view->current_page % 2 == ev_page_cache_get_dual_even_left (view->page_cache)) {
 477                         view->start_page = view->current_page;
 478                         if (view->current_page + 1 < ev_page_cache_get_n_pages (view->page_cache))
 479                                 view->end_page = view->start_page + 1;
 480                         else
 481                                 view->end_page = view->start_page;
 482                 } else {
 483                         if (view->current_page < 1)
 484                                 view->start_page = view->current_page;
 485                         else
 486                                 view->start_page = view->current_page - 1;
 487                         view->end_page = view->current_page;
 488                 }
 489         } else {
 490                 view->start_page = view->current_page;
 491                 view->end_page = view->current_page;
 492         }
 493
 494         best_current_page = MAX (best_current_page, view->start_page);
 495         current_page = ev_page_cache_get_current_page (view->page_cache);
 496
 497         if (current_page != best_current_page) {
 498                 view->current_page = best_current_page;
 499                 ev_page_cache_set_current_page (view->page_cache, best_current_page);
 500         }
 501
 502         ev_pixbuf_cache_set_page_range (view->pixbuf_cache,
 503                                         view->start_page,
 504                                         view->end_page,
 505                                         view->rotation,
 506                                         view->scale,
 507                                         view->selection_info.selections);
 508 }
 509
 510 static void
 511 set_scroll_adjustment (EvView *view,
 512                        GtkOrientation  orientation,
 513                        GtkAdjustment  *adjustment)
 514 {
 515         GtkAdjustment **to_set;
 516
 517         if (orientation == GTK_ORIENTATION_HORIZONTAL)
 518                 to_set = &view->hadjustment;
 519         else
 520                 to_set = &view->vadjustment;
 521
 522         if (*to_set != adjustment) {
 523                 if (*to_set) {
 524                         g_signal_handlers_disconnect_by_func (*to_set,
 525                                                               (gpointer) on_adjustment_value_changed,
 526                                                               view);
 527                         g_object_unref (*to_set);
 528                 }
 529
 530                 *to_set = adjustment;
 531                 view_set_adjustment_values (view, orientation);
 532
 533                 if (*to_set) {
 534                         g_object_ref (*to_set);
 535                         g_signal_connect (*to_set, "value_changed",
 536                                           G_CALLBACK (on_adjustment_value_changed), view);
 537                 }
 538         }
 539 }
 540
 541 static void
 542 ev_view_set_scroll_adjustments (EvView *view,
 543                                 GtkAdjustment  *hadjustment,
 544                                 GtkAdjustment  *vadjustment)
 545 {
 546         set_scroll_adjustment (view, GTK_ORIENTATION_HORIZONTAL, hadjustment);
 547         set_scroll_adjustment (view, GTK_ORIENTATION_VERTICAL, vadjustment);
 548
 549         on_adjustment_value_changed (NULL, view);
 550 }
 551
 552 static void
 553 add_scroll_binding_keypad (GtkBindingSet  *binding_set,
 554                            guint           keyval,
 555                            GdkModifierType modifiers,
 556                            EvScrollType    scroll,
 557                            gboolean        horizontal)
 558 {
 559   guint keypad_keyval = keyval - GDK_Left + GDK_KP_Left;
 560
 561   gtk_binding_entry_add_signal (binding_set, keyval, modifiers,
 562                                 "binding_activated", 2,
 563                                 EV_TYPE_SCROLL_TYPE, scroll,
 564                                 G_TYPE_BOOLEAN, horizontal);
 565   gtk_binding_entry_add_signal (binding_set, keypad_keyval, modifiers,
 566                                 "binding_activated", 2,
 567                                 EV_TYPE_SCROLL_TYPE, scroll,
 568                                 G_TYPE_BOOLEAN, horizontal);
 569 }
 570
 571 void
 572 ev_view_scroll (EvView        *view,
 573                 EvScrollType   scroll,
 574                 gboolean horizontal)
 575 {
 576         GtkAdjustment *adjustment;
 577         double value, increment;
 578         gboolean first_page = FALSE;
 579         gboolean last_page = FALSE;
 580
 581         view->jump_to_find_result = FALSE;
 582
 583         if (view->presentation) {
 584                 switch (scroll) {
 585                         case EV_SCROLL_PAGE_BACKWARD:
 586                         case EV_SCROLL_STEP_BACKWARD:
 587                                 ev_view_previous_page (view);
 588                                 break;
 589                         case EV_SCROLL_PAGE_FORWARD:
 590                         case EV_SCROLL_STEP_FORWARD:
 591                                 ev_view_next_page (view);
 592                                 break;
 593                         default:
 594                                 break;
 595                 }
 596                 return;
 597         }
 598
 599         /* Assign values for increment and vertical adjustment */
 600         adjustment = horizontal ? view->hadjustment : view->vadjustment;
 601         increment = adjustment->page_size * 0.75;
 602         value = adjustment->value;
 603
 604         /* Assign boolean for first and last page */
 605         if (view->current_page == 0)
 606                 first_page = TRUE;
 607         if (view->current_page == ev_page_cache_get_n_pages (view->page_cache) - 1)
 608                 last_page = TRUE;
 609
 610         switch (scroll) {
 611                 case EV_SCROLL_PAGE_BACKWARD:
 612                         /* Do not jump backwards if at the first page */
 613                         if (value == (adjustment->lower) && first_page) {
 614                                 /* Do nothing */
 615                                 /* At the top of a page, assign the upper bound limit of previous page */
 616                         } else if (value == (adjustment->lower)) {
 617                                 value = adjustment->upper - adjustment->page_size;
 618                                 ev_view_previous_page (view);
 619                                 /* Jump to the top */
 620                         } else {
 621                                 value = MAX (value - increment, adjustment->lower);
 622                         }
 623                         break;
 624                 case EV_SCROLL_PAGE_FORWARD:
 625                         /* Do not jump forward if at the last page */
 626                         if (value == (adjustment->upper - adjustment->page_size) && last_page) {
 627                                 /* Do nothing */
 628                         /* At the bottom of a page, assign the lower bound limit of next page */
 629                         } else if (value == (adjustment->upper - adjustment->page_size)) {
 630                                 value = 0;
 631                                 ev_view_next_page (view);
 632                         /* Jump to the bottom */
 633                         } else {
 634                                 value = MIN (value + increment, adjustment->upper - adjustment->page_size);
 635                         }
 636                         break;
 637                 case EV_SCROLL_STEP_BACKWARD:
 638                         value -= adjustment->step_increment;
 639                         break;
 640                 case EV_SCROLL_STEP_FORWARD:
 641                         value += adjustment->step_increment;
 642                         break;
 643                 case EV_SCROLL_STEP_DOWN:
 644                         value -= adjustment->step_increment / 10;
 645                         break;
 646                 case EV_SCROLL_STEP_UP:
 647                         value += adjustment->step_increment / 10;
 648                         break;
 649                 default:
 650                         break;
 651         }
 652
 653         value = CLAMP (value, adjustment->lower,
 654                        adjustment->upper - adjustment->page_size);
 655
 656         gtk_adjustment_set_value (adjustment, value);
 657 }
 658
 659 #define MARGIN 5
 660
 661 static void
 662 ensure_rectangle_is_visible (EvView *view, GdkRectangle *rect)
 663 {
 664         GtkWidget *widget = GTK_WIDGET (view);
 665         GtkAdjustment *adjustment;
 666         int value;
 667
 668         view->pending_scroll = SCROLL_TO_KEEP_POSITION;
 669
 670         adjustment = view->vadjustment;
 671
 672         if (rect->y < adjustment->value) {
 673                 value = MAX (adjustment->lower, rect->y - MARGIN);
 674                 gtk_adjustment_set_value (view->vadjustment, value);
 675         } else if (rect->y + rect->height >
 676                    adjustment->value + widget->allocation.height) {
 677                 value = MIN (adjustment->upper, rect->y + rect->height -
 678                              widget->allocation.height + MARGIN);
 679                 gtk_adjustment_set_value (view->vadjustment, value);
 680         }
 681
 682         adjustment = view->hadjustment;
 683
 684         if (rect->x < adjustment->value) {
 685                 value = MAX (adjustment->lower, rect->x - MARGIN);
 686                 gtk_adjustment_set_value (view->hadjustment, value);
 687         } else if (rect->x + rect->height >
 688                    adjustment->value + widget->allocation.width) {
 689                 value = MIN (adjustment->upper, rect->x + rect->width -
 690                              widget->allocation.width + MARGIN);
 691                 gtk_adjustment_set_value (view->hadjustment, value);
 692         }
 693 }
 694
 695 /*** Geometry computations ***/
 696
 697 static void
 698 compute_border (EvView *view, int width, int height, GtkBorder *border)
 699 {
 700         if (view->presentation) {
 701                 border->left = 0;
 702                 border->right = 0;
 703                 border->top = 0;
 704                 border->bottom = 0;
 705         } else {
 706                 ev_document_misc_get_page_border_size (width, height, border);
 707         }
 708 }
 709
 710 static void
 711 get_page_y_offset (EvView *view, int page, double zoom, int *y_offset)
 712 {
 713         int max_width, offset;
 714         GtkBorder border;
 715
 716         g_return_if_fail (y_offset != NULL);
 717
 718         ev_page_cache_get_max_width (view->page_cache, view->rotation, zoom, &max_width);
 719
 720         compute_border (view, max_width, max_width, &border);
 721
 722         if (view->dual_page) {
 723                 ev_page_cache_get_height_to_page (view->page_cache, page,
 724                                                   view->rotation, zoom, NULL, &offset);
 725                 offset += ((page + ev_page_cache_get_dual_even_left (view->page_cache)) / 2 + 1) * view->spacing + ((page + ev_page_cache_get_dual_even_left (view->page_cache)) / 2 ) * (border.top + border.bottom);
 726         } else {
 727                 ev_page_cache_get_height_to_page (view->page_cache, page,
 728                                                   view->rotation, zoom, &offset, NULL);
 729                 offset += (page + 1) * view->spacing + page * (border.top + border.bottom);
 730         }
 731
 732         *y_offset = offset;
 733         return;
 734 }
 735
 736 static gboolean
 737 get_page_extents (EvView       *view,
 738                   gint          page,
 739                   GdkRectangle *page_area,
 740                   GtkBorder    *border)
 741 {
 742         GtkWidget *widget;
 743         int width, height;
 744
 745         widget = GTK_WIDGET (view);
 746
 747         /* Get the size of the page */
 748         ev_page_cache_get_size (view->page_cache, page,
 749                                 view->rotation,
 750                                 view->scale,
 751                                 &width, &height);
 752         compute_border (view, width, height, border);
 753         page_area->width = width + border->left + border->right;
 754         page_area->height = height + border->top + border->bottom;
 755
 756         if (view->presentation) {
 757                 page_area->x = (MAX (0, widget->allocation.width - width))/2;
 758                 page_area->y = (MAX (0, widget->allocation.height - height))/2;
 759         } else if (view->continuous) {
 760                 gint max_width;
 761                 gint x, y;
 762
 763                 ev_page_cache_get_max_width (view->page_cache, view->rotation,
 764                                              view->scale, &max_width);
 765                 max_width = max_width + border->left + border->right;
 766                 /* Get the location of the bounding box */
 767                 if (view->dual_page) {
 768                         x = view->spacing + ((page % 2 == ev_page_cache_get_dual_even_left (view->page_cache)) ? 0 : 1) * (max_width + view->spacing);
 769                         x = x + MAX (0, widget->allocation.width - (max_width * 2 + view->spacing * 3)) / 2;
 770                         if (page % 2 == ev_page_cache_get_dual_even_left (view->page_cache))
 771                                 x = x + (max_width - width - border->left - border->right);
 772                 } else {
 773                         x = view->spacing;
 774                         x = x + MAX (0, widget->allocation.width - (width + view->spacing * 2)) / 2;
 775                 }
 776
 777                 get_page_y_offset (view, page, view->scale, &y);
 778
 779                 page_area->x = x;
 780                 page_area->y = y;
 781         } else {
 782                 gint x, y;
 783                 if (view->dual_page) {
 784                         gint width_2, height_2;
 785                         gint max_width = width;
 786                         gint max_height = height;
 787                         GtkBorder overall_border;
 788                         gint other_page;
 789
 790                         other_page = (page % 2 == ev_page_cache_get_dual_even_left (view->page_cache)) ? page + 1: page - 1;
 791
 792                         /* First, we get the bounding box of the two pages */
 793                         if (other_page < ev_page_cache_get_n_pages (view->page_cache)
 794                             && (0 <= other_page)) {
 795                                 ev_page_cache_get_size (view->page_cache,
 796                                                         other_page,
 797                                                         view->rotation,
 798                                                         view->scale,
 799                                                         &width_2, &height_2);
 800                                 if (width_2 > width)
 801                                         max_width = width_2;
 802                                 if (height_2 > height)
 803                                         max_height = height_2;
 804                         }
 805                         compute_border (view, max_width, max_height, &overall_border);
 806
 807                         /* Find the offsets */
 808                         x = view->spacing;
 809                         y = view->spacing;
 810
 811                         /* Adjust for being the left or right page */
 812                         if (page % 2 == ev_page_cache_get_dual_even_left (view->page_cache))
 813                                 x = x + max_width - width;
 814                         else
 815                                 x = x + (max_width + overall_border.left + overall_border.right) + view->spacing;
 816
 817                         y = y + (max_height - height)/2;
 818
 819                         /* Adjust for extra allocation */
 820                         x = x + MAX (0, widget->allocation.width -
 821                                      ((max_width + overall_border.left + overall_border.right) * 2 + view->spacing * 3))/2;
 822                         y = y + MAX (0, widget->allocation.height - (height + view->spacing * 2))/2;
 823                 } else {
 824                         x = view->spacing;
 825                         y = view->spacing;
 826
 827                         /* Adjust for extra allocation */
 828                         x = x + MAX (0, widget->allocation.width - (width + border->left + border->right + view->spacing * 2))/2;
 829                         y = y + MAX (0, widget->allocation.height - (height + border->top + border->bottom +  view->spacing * 2))/2;
 830                 }
 831
 832                 page_area->x = x;
 833                 page_area->y = y;
 834         }
 835
 836         return TRUE;
 837 }
 838
 839 static void
 840 view_point_to_doc_point (EvView *view,
 841                          GdkPoint *view_point,
 842                          GdkRectangle *page_area,
 843                          double  *doc_point_x,
 844                          double  *doc_point_y)
 845 {
 846         *doc_point_x = (double) (view_point->x - page_area->x) / view->scale;
 847         *doc_point_y = (double) (view_point->y - page_area->y) / view->scale;
 848 }
 849
 850 static void
 851 view_rect_to_doc_rect (EvView *view,
 852                        GdkRectangle *view_rect,
 853                        GdkRectangle *page_area,
 854                        EvRectangle  *doc_rect)
 855 {
 856         doc_rect->x1 = (double) (view_rect->x - page_area->x) / view->scale;
 857         doc_rect->y1 = (double) (view_rect->y - page_area->y) / view->scale;
 858         doc_rect->x2 = doc_rect->x1 + (double) view_rect->width / view->scale;
 859         doc_rect->y2 = doc_rect->y1 + (double) view_rect->height / view->scale;
 860 }
 861
 862 static gboolean
 863 doc_point_to_view_point (EvView       *view,
 864                          int           page,
 865                          EvPoint      *doc_point,
 866                          GdkPoint     *view_point)
 867 {
 868         GdkRectangle page_area;
 869         GtkBorder border;
 870         double x, y, view_x, view_y;
 871         int width, height;
 872
 873         ev_page_cache_get_size (view->page_cache, page,
 874                                 view->rotation,
 875                                 1.0,
 876                                 &width, &height);
 877
 878         if (view->rotation == 0) {
 879                 x = doc_point->x;
 880                 y = doc_point->y;
 881         } else if (view->rotation == 90) {
 882                 x = width - doc_point->y;
 883                 y = doc_point->x;
 884         } else if (view->rotation == 180) {
 885                 x = width - doc_point->x;
 886                 y = height - doc_point->y;
 887         } else if (view->rotation == 270) {
 888                 x = doc_point->y;
 889                 y = height - doc_point->x;
 890         } else {
 891                 g_assert_not_reached ();
 892         }
 893
 894         get_page_extents (view, page, &page_area, &border);
 895
 896         view_x = x * view->scale;
 897         view_y = y * view->scale;
 898         view_point->x = view_x + page_area.x;
 899         view_point->y = view_y + page_area.y;
 900
 901         return (view_x > 0 && view_x <= page_area.width &&
 902                 view_y > 0 && view_y <= page_area.height);
 903 }
 904
 905 static void
 906 doc_rect_to_view_rect (EvView       *view,
 907                        int           page,
 908                        EvRectangle  *doc_rect,
 909                        GdkRectangle *view_rect)
 910 {
 911         GdkRectangle page_area;
 912         GtkBorder border;
 913         double x, y, w, h;
 914         int width, height;
 915
 916         ev_page_cache_get_size (view->page_cache, page,
 917                                 view->rotation,
 918                                 1.0,
 919                                 &width, &height);
 920
 921         if (view->rotation == 0) {
 922                 x = doc_rect->x1;
 923                 y = doc_rect->y1;
 924                 w = doc_rect->x2 - doc_rect->x1;
 925                 h = doc_rect->y2 - doc_rect->y1;
 926         } else if (view->rotation == 90) {
 927                 x = width - doc_rect->y2;
 928                 y = doc_rect->x1;
 929                 w = doc_rect->y2 - doc_rect->y1;
 930                 h = doc_rect->x2 - doc_rect->x1;
 931         } else if (view->rotation == 180) {
 932                 x = width - doc_rect->x2;
 933                 y = height - doc_rect->y2;
 934                 w = doc_rect->x2 - doc_rect->x1;
 935                 h = doc_rect->y2 - doc_rect->y1;
 936         } else if (view->rotation == 270) {
 937                 x = doc_rect->y1;
 938                 y = height - doc_rect->x2;
 939                 w = doc_rect->y2 - doc_rect->y1;
 940                 h = doc_rect->x2 - doc_rect->x1;
 941         } else {
 942                 g_assert_not_reached ();
 943         }
 944
 945         get_page_extents (view, page, &page_area, &border);
 946
 947         view_rect->x = x * view->scale + page_area.x;
 948         view_rect->y = y * view->scale + page_area.y;
 949         view_rect->width = w * view->scale;
 950         view_rect->height = h * view->scale;
 951 }
 952
 953 static void
 954 find_page_at_location (EvView  *view,
 955                        gdouble  x,
 956                        gdouble  y,
 957                        gint    *page,
 958                        gint    *x_offset,
 959                        gint    *y_offset)
 960 {
 961         int i;
 962
 963         if (view->document == NULL)
 964                 return;
 965
 966         g_assert (page);
 967         g_assert (x_offset);
 968         g_assert (y_offset);
 969
 970         for (i = view->start_page; i <= view->end_page; i++) {
 971                 GdkRectangle page_area;
 972                 GtkBorder border;
 973
 974                 if (! get_page_extents (view, i, &page_area, &border))
 975                         continue;
 976
 977                 if ((x >= page_area.x + border.left) &&
 978                     (x < page_area.x + page_area.width - border.right) &&
 979                     (y >= page_area.y + border.top) &&
 980                     (y < page_area.y + page_area.height - border.bottom)) {
 981                         *page = i;
 982                         *x_offset = x - (page_area.x + border.left);
 983                         *y_offset = y - (page_area.y + border.top);
 984                         return;
 985                 }
 986         }
 987
 988         *page = -1;
 989 }
 990
 991 static gboolean
 992 location_in_text (EvView  *view,
 993                   gdouble  x,
 994                   gdouble  y)
 995 {
 996         GdkRegion *region;
 997         gint page = -1;
 998         gint x_offset = 0, y_offset = 0;
 999
1000         find_page_at_location (view, x, y, &page, &x_offset, &y_offset);
1001
1002         if (page == -1)
1003                 return FALSE;
1004
1005         region = ev_pixbuf_cache_get_text_mapping (view->pixbuf_cache, page);
1006
1007         if (region)
1008                 return gdk_region_point_in (region, x_offset / view->scale, y_offset / view->scale);
1009         else
1010                 return FALSE;
1011 }
1012
1013 static int
1014 ev_view_get_width (EvView *view)
1015 {
1016         return GTK_WIDGET (view)->allocation.width;
1017 }
1018
1019 static int
1020 ev_view_get_height (EvView *view)
1021 {
1022         return GTK_WIDGET (view)->allocation.height;
1023 }
1024
1025 static gboolean
1026 location_in_selected_text (EvView  *view,
1027                            gdouble  x,
1028                            gdouble  y)
1029 {
1030         gint page = -1;
1031         gint x_offset = 0, y_offset = 0;
1032         EvViewSelection *selection;
1033         GList *l = NULL;
1034
1035         for (l = view->selection_info.selections; l != NULL; l = l->next) {
1036                 selection = (EvViewSelection *)l->data;
1037
1038                 find_page_at_location (view, x, y, &page, &x_offset, &y_offset);
1039
1040                 if (page != selection->page)
1041                         continue;
1042
1043                 if (selection->covered_region &&
1044                     gdk_region_point_in (selection->covered_region, x_offset, y_offset))
1045                         return TRUE;
1046         }
1047
1048         return FALSE;
1049 }
1050
1051 /*** Hyperref ***/
1052 static EvLink *
1053 ev_view_get_link_at_location (EvView  *view,
1054                               gdouble  x,
1055                               gdouble  y)
1056 {
1057         gint page = -1;
1058         gint x_offset = 0, y_offset = 0;
1059         GList *link_mapping;
1060
1061         x += view->scroll_x;
1062         y += view->scroll_y;
1063
1064         find_page_at_location (view, x, y, &page, &x_offset, &y_offset);
1065
1066         if (page == -1)
1067                 return NULL;
1068
1069         link_mapping = ev_pixbuf_cache_get_link_mapping (view->pixbuf_cache, page);
1070
1071         if (link_mapping)
1072                 return ev_link_mapping_find (link_mapping, x_offset / view->scale, y_offset / view->scale);
1073         else
1074                 return NULL;
1075 }
1076
1077 static void
1078 goto_fitr_link (EvView *view, EvLink *link)
1079 {
1080         EvPoint doc_point;
1081         int page;
1082         double zoom;
1083
1084         zoom = zoom_for_size_best_fit (ev_link_get_right (link) - ev_link_get_left (link),
1085                                        ev_link_get_top (link) - ev_link_get_bottom (link),
1086                                        ev_view_get_width (view),
1087                                        ev_view_get_height (view), 0, 0);
1088
1089         ev_view_set_sizing_mode (view, EV_SIZING_FREE);
1090         ev_view_set_zoom (view, zoom, FALSE);
1091
1092         page = ev_link_get_page (link);
1093         doc_point.x = ev_link_get_left (link);
1094         doc_point.y = ev_link_get_top (link);
1095
1096         view->current_page = page;
1097         view->pending_point = doc_point;
1098         view->pending_scroll = SCROLL_TO_PAGE_POSITION;
1099
1100         gtk_widget_queue_resize (GTK_WIDGET (view));
1101 }
1102
1103 static void
1104 goto_fitv_link (EvView *view, EvLink *link)
1105 {
1106         EvPoint doc_point;
1107         int doc_width, doc_height, page;
1108         double zoom;
1109
1110         page = ev_link_get_page (link);
1111         ev_page_cache_get_size (view->page_cache, page, 0, 1.0, &doc_width, &doc_height);
1112
1113         doc_point.x = ev_link_get_left (link);
1114         doc_point.y = 0;
1115
1116         zoom = zoom_for_size_fit_height (doc_width - doc_point.x , doc_height,
1117                                          ev_view_get_width (view),
1118                                          ev_view_get_height (view), 0);
1119
1120         ev_view_set_sizing_mode (view, EV_SIZING_FREE);
1121         ev_view_set_zoom (view, zoom, FALSE);
1122
1123         view->current_page = page;
1124         view->pending_point = doc_point;
1125         view->pending_scroll = SCROLL_TO_PAGE_POSITION;
1126
1127         gtk_widget_queue_resize (GTK_WIDGET (view));
1128 }
1129
1130 static void
1131 goto_fith_link (EvView *view, EvLink *link)
1132 {
1133         EvPoint doc_point;
1134         int doc_width, doc_height, page;
1135         double zoom;
1136
1137         page = ev_link_get_page (link);
1138         ev_page_cache_get_size (view->page_cache, page, 0, 1.0, &doc_width, &doc_height);
1139
1140         doc_point.x = 0;
1141         doc_point.y = doc_height - ev_link_get_top (link);
1142
1143         zoom = zoom_for_size_fit_width (doc_width, ev_link_get_top (link),
1144                                         ev_view_get_width (view),
1145                                         ev_view_get_height (view), 0);
1146
1147         ev_view_set_sizing_mode (view, EV_SIZING_FREE);
1148         ev_view_set_zoom (view, zoom, FALSE);
1149
1150         view->current_page = page;
1151         view->pending_point = doc_point;
1152         view->pending_scroll = SCROLL_TO_PAGE_POSITION;
1153
1154         gtk_widget_queue_resize (GTK_WIDGET (view));
1155 }
1156
1157 static void
1158 goto_fit_link (EvView *view, EvLink *link)
1159 {
1160         double zoom;
1161         int doc_width, doc_height;
1162         int page;
1163
1164         page = ev_link_get_page (link);
1165         ev_page_cache_get_size (view->page_cache, page, 0, 1.0, &doc_width, &doc_height);
1166
1167         zoom = zoom_for_size_best_fit (doc_width, doc_height, ev_view_get_width (view),
1168                                        ev_view_get_height (view), 0, 0);
1169
1170         ev_view_set_sizing_mode (view, EV_SIZING_FREE);
1171         ev_view_set_zoom (view, zoom, FALSE);
1172
1173         view->current_page = page;
1174         view->pending_scroll = SCROLL_TO_PAGE_POSITION;
1175
1176         gtk_widget_queue_resize (GTK_WIDGET (view));
1177 }
1178
1179 static void
1180 goto_xyz_link (EvView *view, EvLink *link)
1181 {
1182         EvPoint doc_point;
1183         int height, page;
1184         double zoom;
1185
1186         zoom = ev_link_get_zoom (link);
1187         page = ev_link_get_page (link);
1188         ev_page_cache_get_size (view->page_cache, page, 0, 1.0, NULL, &height);
1189
1190         if (zoom != 0) {
1191                 ev_view_set_sizing_mode (view, EV_SIZING_FREE);
1192                 ev_view_set_zoom (view, zoom, FALSE);
1193         }
1194
1195         doc_point.x = ev_link_get_left (link);
1196         doc_point.y = height - ev_link_get_top (link);
1197
1198         view->current_page = page;
1199         view->pending_point = doc_point;
1200         view->pending_scroll = SCROLL_TO_PAGE_POSITION;
1201
1202         gtk_widget_queue_resize (GTK_WIDGET (view));
1203 }
1204
1205 void
1206 ev_view_goto_link (EvView *view, EvLink *link)
1207 {
1208         EvLinkType type;
1209         int page;
1210
1211         type = ev_link_get_link_type (link);
1212
1213         switch (type) {
1214                 case EV_LINK_TYPE_TITLE:
1215                         break;
1216                 case EV_LINK_TYPE_PAGE:
1217                         page = ev_link_get_page (link);
1218                         ev_page_cache_set_current_page (view->page_cache, page);
1219                         break;
1220                 case EV_LINK_TYPE_PAGE_FIT:
1221                         goto_fit_link (view, link);
1222                         break;
1223                 case EV_LINK_TYPE_PAGE_FITH:
1224                         goto_fith_link (view, link);
1225                         break;
1226                 case EV_LINK_TYPE_PAGE_FITV:
1227                         goto_fitv_link (view, link);
1228                         break;
1229                 case EV_LINK_TYPE_PAGE_FITR:
1230                         goto_fitr_link (view, link);
1231                         break;
1232                 case EV_LINK_TYPE_PAGE_XYZ:
1233                         goto_xyz_link (view, link);
1234                         break;
1235                 case EV_LINK_TYPE_EXTERNAL_URI:
1236                 case EV_LINK_TYPE_LAUNCH:
1237                         g_signal_emit (view, signals[SIGNAL_EXTERNAL_LINK], 0, link);
1238                         break;
1239         }
1240 }
1241
1242 static char *
1243 tip_from_link (EvView *view, EvLink *link)
1244 {
1245         EvLinkType type;
1246         char *msg = NULL;
1247         char *page_label;
1248
1249         type = ev_link_get_link_type (link);
1250
1251         switch (type) {
1252                 case EV_LINK_TYPE_TITLE:
1253                         if (ev_link_get_title (link))
1254                                 msg = g_strdup (ev_link_get_title (link));
1255                         break;
1256                 case EV_LINK_TYPE_PAGE:
1257                 case EV_LINK_TYPE_PAGE_XYZ:
1258                         page_label = ev_page_cache_get_page_label (view->page_cache, ev_link_get_page (link));
1259                         msg = g_strdup_printf (_("Go to page %s"), page_label);
1260                         g_free (page_label);
1261                         break;
1262                 case EV_LINK_TYPE_EXTERNAL_URI:
1263                         msg = g_strdup (ev_link_get_uri (link));
1264                         break;
1265                 default:
1266                         break;
1267         }
1268
1269         return msg;
1270 }
1271
1272 static void
1273 handle_link_over_xy (EvView *view, gint x, gint y)
1274 {
1275         EvLink *link;
1276
1277         link = ev_view_get_link_at_location (view, x, y);
1278
1279         if (view->link_tooltip == NULL) {
1280                 view->link_tooltip = ev_tooltip_new (GTK_WIDGET (view));
1281         }
1282
1283         if (view->hovered_link != link) {
1284                 view->hovered_link = link;
1285                 ev_tooltip_deactivate (EV_TOOLTIP (view->link_tooltip));
1286         }
1287
1288         if (link) {
1289                 char *msg = tip_from_link (view, link);
1290
1291                 if (msg && g_utf8_validate (msg, -1, NULL)) {
1292                         EvTooltip *tooltip = EV_TOOLTIP (view->link_tooltip);
1293
1294                         ev_tooltip_set_position (tooltip, x, y);
1295                         ev_tooltip_set_text (tooltip, msg);
1296                         ev_tooltip_activate (tooltip);
1297                 }
1298                 g_free (msg);
1299
1300                 ev_view_set_cursor (view, EV_VIEW_CURSOR_LINK);
1301         } else if (location_in_text (view, x + view->scroll_x, y + view->scroll_y)) {
1302                 ev_view_set_cursor (view, EV_VIEW_CURSOR_IBEAM);
1303         } else {
1304                 ev_view_set_status (view, NULL);
1305                 if (view->cursor == EV_VIEW_CURSOR_LINK ||
1306                     view->cursor == EV_VIEW_CURSOR_IBEAM)
1307                         ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
1308         }
1309         return;
1310 }
1311
1312 /*** GtkWidget implementation ***/
1313
1314 static void
1315 ev_view_size_request_continuous_dual_page (EvView         *view,
1316                                            GtkRequisition *requisition)
1317 {
1318         int max_width;
1319         gint n_pages;
1320         GtkBorder border;
1321
1322         ev_page_cache_get_max_width (view->page_cache, view->rotation,
1323                                      view->scale, &max_width);
1324         compute_border (view, max_width, max_width, &border);
1325
1326         n_pages = ev_page_cache_get_n_pages (view->page_cache) + 1;
1327
1328         requisition->width = (max_width + border.left + border.right) * 2 + (view->spacing * 3);
1329         get_page_y_offset (view, n_pages, view->scale, &requisition->height);
1330
1331         if (view->sizing_mode == EV_SIZING_FIT_WIDTH) {
1332                 requisition->width = 1;
1333         } else if (view->sizing_mode == EV_SIZING_BEST_FIT) {
1334                 requisition->width = 1;
1335                 /* FIXME: This could actually be set on one page docs or docs
1336                  * with a strange aspect ratio. */
1337                 /* requisition->height = 1;*/
1338         }
1339 }
1340
1341 static void
1342 ev_view_size_request_continuous (EvView         *view,
1343                                  GtkRequisition *requisition)
1344 {
1345         int max_width;
1346         int n_pages;
1347         GtkBorder border;
1348
1349
1350         ev_page_cache_get_max_width (view->page_cache, view->rotation,
1351                                      view->scale, &max_width);
1352         n_pages = ev_page_cache_get_n_pages (view->page_cache);
1353         compute_border (view, max_width, max_width, &border);
1354
1355         requisition->width = max_width + (view->spacing * 2) + border.left + border.right;
1356         get_page_y_offset (view, n_pages, view->scale, &requisition->height);
1357
1358         if (view->sizing_mode == EV_SIZING_FIT_WIDTH) {
1359                 requisition->width = 1;
1360         } else if (view->sizing_mode == EV_SIZING_BEST_FIT) {
1361                 requisition->width = 1;
1362                 /* FIXME: This could actually be set on one page docs or docs
1363                  * with a strange aspect ratio. */
1364                 /* requisition->height = 1;*/
1365         }
1366 }
1367
1368 static void
1369 ev_view_size_request_dual_page (EvView         *view,
1370                                 GtkRequisition *requisition)
1371 {
1372         GtkBorder border;
1373         gint width, height;
1374
1375         /* Find the largest of the two. */
1376         ev_page_cache_get_size (view->page_cache,
1377                                 view->current_page,
1378                                 view->rotation,
1379                                 view->scale,
1380                                 &width, &height);
1381         if (view->current_page + 1 < ev_page_cache_get_n_pages (view->page_cache)) {
1382                 gint width_2, height_2;
1383                 ev_page_cache_get_size (view->page_cache,
1384                                         view->current_page + 1,
1385                                         view->rotation,
1386                                         view->scale,
1387                                         &width_2, &height_2);
1388                 if (width_2 > width) {
1389                         width = width_2;
1390                         height = height_2;
1391                 }
1392         }
1393         compute_border (view, width, height, &border);
1394
1395         requisition->width = ((width + border.left + border.right) * 2) +
1396                 (view->spacing * 3);
1397         requisition->height = (height + border.top + border.bottom) +
1398                 (view->spacing * 2);
1399
1400         if (view->sizing_mode == EV_SIZING_FIT_WIDTH) {
1401                 requisition->width = 1;
1402         } else if (view->sizing_mode == EV_SIZING_BEST_FIT) {
1403                 requisition->width = 1;
1404                 requisition->height = 1;
1405         }
1406 }
1407
1408 static void
1409 ev_view_size_request_single_page (EvView         *view,
1410                                   GtkRequisition *requisition)
1411 {
1412         GtkBorder border;
1413         gint width, height;
1414
1415         ev_page_cache_get_size (view->page_cache,
1416                                 view->current_page,
1417                                 view->rotation,
1418                                 view->scale,
1419                                 &width, &height);
1420         compute_border (view, width, height, &border);
1421
1422         requisition->width = width + border.left + border.right + (2 * view->spacing);
1423         requisition->height = height + border.top + border.bottom + (2 * view->spacing);
1424
1425         if (view->sizing_mode == EV_SIZING_FIT_WIDTH) {
1426                 requisition->width = 1;
1427                 requisition->height = height + border.top + border.bottom + (2 * view->spacing);
1428         } else if (view->sizing_mode == EV_SIZING_BEST_FIT) {
1429                 requisition->width = 1;
1430                 requisition->height = 1;
1431         }
1432 }
1433
1434 static void
1435 ev_view_size_request (GtkWidget      *widget,
1436                       GtkRequisition *requisition)
1437 {
1438         EvView *view = EV_VIEW (widget);
1439
1440         if (view->document == NULL) {
1441                 requisition->width = 1;
1442                 requisition->height = 1;
1443                 return;
1444         }
1445
1446         if (view->presentation) {
1447                 requisition->width = 1;
1448                 requisition->height = 1;
1449                 return;
1450         }
1451
1452         if (view->continuous && view->dual_page)
1453                 ev_view_size_request_continuous_dual_page (view, requisition);
1454         else if (view->continuous)
1455                 ev_view_size_request_continuous (view, requisition);
1456         else if (view->dual_page)
1457                 ev_view_size_request_dual_page (view, requisition);
1458         else
1459                 ev_view_size_request_single_page (view, requisition);
1460 }
1461
1462 static void
1463 ev_view_size_allocate (GtkWidget      *widget,
1464                        GtkAllocation  *allocation)
1465 {
1466         EvView *view = EV_VIEW (widget);
1467
1468         if (view->sizing_mode == EV_SIZING_FIT_WIDTH ||
1469             view->sizing_mode == EV_SIZING_BEST_FIT) {
1470
1471                 g_signal_emit (view, signals[SIGNAL_ZOOM_INVALID], 0);
1472
1473                 ev_view_size_request (widget, &widget->requisition);
1474         }
1475
1476         view_set_adjustment_values (view, GTK_ORIENTATION_HORIZONTAL);
1477         view_set_adjustment_values (view, GTK_ORIENTATION_VERTICAL);
1478
1479         view->pending_scroll = SCROLL_TO_KEEP_POSITION;
1480         view->pending_resize = FALSE;
1481
1482         if (view->document)
1483                 view_update_range_and_current_page (view);
1484
1485         GTK_WIDGET_CLASS (ev_view_parent_class)->size_allocate (widget, allocation);
1486 }
1487
1488 static void
1489 ev_view_realize (GtkWidget *widget)
1490 {
1491         EvView *view = EV_VIEW (widget);
1492         GdkWindowAttr attributes;
1493
1494         GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
1495
1496
1497         attributes.window_type = GDK_WINDOW_CHILD;
1498         attributes.wclass = GDK_INPUT_OUTPUT;
1499         attributes.visual = gtk_widget_get_visual (widget);
1500         attributes.colormap = gtk_widget_get_colormap (widget);
1501
1502         attributes.x = widget->allocation.x;
1503         attributes.y = widget->allocation.y;
1504         attributes.width = widget->allocation.width;
1505         attributes.height = widget->allocation.height;
1506         attributes.event_mask = GDK_EXPOSURE_MASK |
1507                                 GDK_BUTTON_PRESS_MASK |
1508                                 GDK_BUTTON_RELEASE_MASK |
1509                                 GDK_SCROLL_MASK |
1510                                 GDK_KEY_PRESS_MASK |
1511                                 GDK_POINTER_MOTION_MASK |
1512                                 GDK_POINTER_MOTION_HINT_MASK |
1513                                 GDK_ENTER_NOTIFY_MASK |
1514                                 GDK_LEAVE_NOTIFY_MASK;
1515
1516         widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
1517                                          &attributes,
1518                                          GDK_WA_X | GDK_WA_Y |
1519                                          GDK_WA_COLORMAP |
1520                                          GDK_WA_VISUAL);
1521         gdk_window_set_user_data (widget->window, widget);
1522         widget->style = gtk_style_attach (widget->style, widget->window);
1523
1524         if (view->presentation)
1525                 gdk_window_set_background (widget->window, &widget->style->black);
1526         else
1527                 gdk_window_set_background (widget->window, &widget->style->mid [GTK_STATE_NORMAL]);
1528 }
1529
1530 static gboolean
1531 ev_view_scroll_event (GtkWidget *widget, GdkEventScroll *event)
1532 {
1533         EvView *view = EV_VIEW (widget);
1534         guint state;
1535
1536         state = event->state & gtk_accelerator_get_default_mod_mask ();
1537
1538         if (state == GDK_CONTROL_MASK && view->presentation == FALSE) {
1539                 ev_view_set_sizing_mode (view, EV_SIZING_FREE);
1540
1541                 if (event->direction == GDK_SCROLL_UP ||
1542                     event->direction == GDK_SCROLL_LEFT) {
1543                         if (ev_view_can_zoom_in (view)) {
1544                                 ev_view_zoom_in (view);
1545                         }
1546                 } else {
1547                         if (ev_view_can_zoom_out (view)) {
1548                                 ev_view_zoom_out (view);
1549                         }
1550                 }
1551
1552                 return TRUE;
1553         }
1554
1555         view->jump_to_find_result = FALSE;
1556         /* Shift+Wheel scrolls the in the perpendicular direction */
1557         if (state & GDK_SHIFT_MASK) {
1558                 if (event->direction == GDK_SCROLL_UP)
1559                         event->direction = GDK_SCROLL_LEFT;
1560                 if (event->direction == GDK_SCROLL_LEFT)
1561                         event->direction = GDK_SCROLL_UP;
1562                 if (event->direction == GDK_SCROLL_DOWN)
1563                         event->direction = GDK_SCROLL_RIGHT;
1564                 if (event->direction == GDK_SCROLL_RIGHT)
1565                         event->direction = GDK_SCROLL_DOWN;
1566
1567                 event->state &= ~GDK_SHIFT_MASK;
1568                 state &= ~GDK_SHIFT_MASK;
1569         }
1570
1571         if (state == 0 && view->presentation) {
1572                 switch (event->direction) {
1573                 case GDK_SCROLL_DOWN:
1574                 case GDK_SCROLL_RIGHT:
1575                         ev_view_next_page (view);
1576                         break;
1577                 case GDK_SCROLL_UP:
1578                 case GDK_SCROLL_LEFT:
1579                         ev_view_previous_page (view);
1580                         break;
1581                 }
1582
1583                 return TRUE;
1584         }
1585
1586         return FALSE;
1587 }
1588
1589 static EvViewSelection *
1590 find_selection_for_page (EvView *view,
1591                          gint    page)
1592 {
1593         GList *list;
1594
1595         for (list = view->selection_info.selections; list != NULL; list = list->next) {
1596                 EvViewSelection *selection;
1597
1598                 selection = (EvViewSelection *) list->data;
1599
1600                 if (selection->page == page)
1601                         return selection;
1602         }
1603
1604         return NULL;
1605 }
1606
1607 static gboolean
1608 ev_view_expose_event (GtkWidget      *widget,
1609                       GdkEventExpose *event)
1610 {
1611         EvView *view = EV_VIEW (widget);
1612         int i;
1613
1614         if (view->loading) {
1615                 GdkRectangle area = {0};
1616
1617                 area.width = widget->allocation.width;
1618                 area.height = widget->allocation.height;
1619
1620                 draw_loading_text (view,
1621                                    &area,
1622                                    &(event->area));
1623         }
1624
1625         if (view->document == NULL)
1626                 return FALSE;
1627
1628         for (i = view->start_page; i <= view->end_page; i++) {
1629                 GdkRectangle page_area;
1630                 GtkBorder border;
1631
1632                 if (!get_page_extents (view, i, &page_area, &border))
1633                         continue;
1634
1635                 page_area.x -= view->scroll_x;
1636                 page_area.y -= view->scroll_y;
1637
1638                 draw_one_page (view, i, &page_area, &border, &(event->area));
1639
1640                 if (EV_IS_DOCUMENT_FIND (view->document))
1641                         highlight_find_results (view, i);
1642         }
1643
1644         return FALSE;
1645 }
1646
1647 static gboolean
1648 ev_view_popup_menu (GtkWidget *widget)
1649 {
1650     gint x, y;
1651     EvLink *link;
1652     EvView *view = EV_VIEW (widget);
1653
1654     gtk_widget_get_pointer (widget, &x, &y);
1655     link = ev_view_get_link_at_location (view, x, y);
1656     g_signal_emit (view, signals[SIGNAL_POPUP_MENU], 0, link);
1657     return TRUE;
1658 }
1659
1660 static gboolean
1661 ev_view_button_press_event (GtkWidget      *widget,
1662                             GdkEventButton *event)
1663 {
1664         EvView *view = EV_VIEW (widget);
1665         EvLink *link;
1666
1667         if (!GTK_WIDGET_HAS_FOCUS (widget)) {
1668                 gtk_widget_grab_focus (widget);
1669         }
1670
1671         view->pressed_button = event->button;
1672         view->selection_info.in_drag = FALSE;
1673
1674         switch (event->button) {
1675                 case 1:
1676                         if (view->selection_info.selections) {
1677                                 if (location_in_selected_text (view,
1678                                                                event->x + view->scroll_x,
1679                                                                event->y + view->scroll_y)) {
1680                                         view->selection_info.in_drag = TRUE;
1681                                 } else {
1682                                         clear_selection (view);
1683                                 }
1684
1685                                 gtk_widget_queue_draw (widget);
1686                         }
1687
1688                         view->selection_info.start.x = event->x + view->scroll_x;
1689                         view->selection_info.start.y = event->y + view->scroll_y;
1690
1691                         return TRUE;
1692                 case 2:
1693                         /* use root coordinates as reference point because
1694                          * scrolling changes window relative coordinates */
1695                         view->drag_info.start.x = event->x_root;
1696                         view->drag_info.start.y = event->y_root;
1697                         view->drag_info.hadj = gtk_adjustment_get_value (view->hadjustment);
1698                         view->drag_info.vadj = gtk_adjustment_get_value (view->vadjustment);
1699
1700                         ev_view_set_cursor (view, EV_VIEW_CURSOR_DRAG);
1701
1702                         return TRUE;
1703                 case 3:
1704                         link = ev_view_get_link_at_location (view, event->x, event->y);
1705                         g_signal_emit (view, signals[SIGNAL_POPUP_MENU], 0, link);
1706                         return TRUE;
1707         }
1708
1709         return FALSE;
1710 }
1711
1712 static void
1713 ev_view_drag_data_get (GtkWidget        *widget,
1714                        GdkDragContext   *context,
1715                        GtkSelectionData *selection_data,
1716                        guint             info,
1717                        guint             time)
1718 {
1719         EvView *view = EV_VIEW (widget);
1720
1721         if (view->selection_info.selections &&
1722             ev_document_can_get_text (view->document)) {
1723                 gchar *text;
1724
1725                 text = get_selected_text (view);
1726
1727                 gtk_selection_data_set_text (selection_data, text, strlen (text));
1728
1729                 g_free (text);
1730         }
1731 }
1732
1733 static gboolean
1734 selection_update_idle_cb (EvView *view)
1735 {
1736         compute_selections (view, &view->selection_info.start, &view->motion);
1737         view->selection_update_id = 0;
1738         return FALSE;
1739 }
1740
1741 static gboolean
1742 selection_scroll_timeout_cb (EvView *view)
1743 {
1744         gint x, y, shift = 0;
1745         GtkWidget *widget = GTK_WIDGET (view);
1746
1747         gtk_widget_get_pointer (widget, &x, &y);
1748
1749         if (y > widget->allocation.height) {
1750                 shift = (y - widget->allocation.height) / 2;
1751         } else if (y < 0) {
1752                 shift = y / 2;
1753         }
1754
1755         if (shift)
1756                 gtk_adjustment_set_value (view->vadjustment,
1757                                           CLAMP (view->vadjustment->value + shift,
1758                                           view->vadjustment->lower,
1759                                           view->vadjustment->upper -
1760                                           view->vadjustment->page_size));
1761
1762         if (x > widget->allocation.width) {
1763                 shift = (x - widget->allocation.width) / 2;
1764         } else if (x < 0) {
1765                 shift = x / 2;
1766         }
1767
1768         if (shift)
1769                 gtk_adjustment_set_value (view->hadjustment,
1770                                           CLAMP (view->hadjustment->value + shift,
1771                                           view->hadjustment->lower,
1772                                           view->hadjustment->upper -
1773                                           view->hadjustment->page_size));
1774
1775         return TRUE;
1776 }
1777
1778 static gboolean
1779 ev_view_motion_notify_event (GtkWidget      *widget,
1780                              GdkEventMotion *event)
1781 {
1782         EvView *view = EV_VIEW (widget);
1783         gint x, y;
1784
1785         if (!view->document)
1786                 return FALSE;
1787
1788         if (event->is_hint || event->window != widget->window) {
1789             gtk_widget_get_pointer (widget, &x, &y);
1790         } else {
1791             x = event->x;
1792             y = event->y;
1793         }
1794
1795         if (view->selection_info.in_drag) {
1796                 if (gtk_drag_check_threshold (widget,
1797                                               view->selection_info.start.x,
1798                                               view->selection_info.start.y,
1799                                               x, y)) {
1800                         GdkDragContext *context;
1801                         GtkTargetList *target_list = gtk_target_list_new (NULL, 0);
1802
1803                         gtk_target_list_add_text_targets (target_list, 0);
1804
1805                         context = gtk_drag_begin (widget, target_list,
1806                                                   GDK_ACTION_COPY,
1807                                                   1, (GdkEvent *)event);
1808
1809                         view->selection_info.in_drag = FALSE;
1810
1811                         gtk_target_list_unref (target_list);
1812
1813                         return TRUE;
1814                 }
1815         }
1816
1817         /* For the Evince 0.4.x release, we limit selection to un-rotated
1818          * documents only.
1819          */
1820         if (view->pressed_button == 1 && view->rotation == 0) {
1821
1822                 /* Schedule timeout to scroll during selection and additionally
1823                  * scroll once to allow arbitrary speed. */
1824                 if (!view->selection_scroll_id)
1825                     view->selection_scroll_id = g_timeout_add (SCROLL_TIME, (GSourceFunc)selection_scroll_timeout_cb, view);
1826                 else
1827                     selection_scroll_timeout_cb (view);
1828
1829                 view->selection_info.in_selection = TRUE;
1830                 view->motion.x = x + view->scroll_x;
1831                 view->motion.y = y + view->scroll_y;
1832
1833                 /* Queue an idle to handle the motion.  We do this because
1834                  * handling any selection events in the motion could be slower
1835                  * than new motion events reach us.  We always put it in the
1836                  * idle to make sure we catch up and don't visibly lag the
1837                  * mouse. */
1838                 if (!view->selection_update_id)
1839                         view->selection_update_id = g_idle_add ((GSourceFunc)selection_update_idle_cb, view);
1840
1841                 return TRUE;
1842         } else if (view->pressed_button == 2) {
1843                 if (!view->drag_info.in_drag) {
1844                         gboolean start;
1845
1846                         start = gtk_drag_check_threshold (widget,
1847                                                           view->drag_info.start.x,
1848                                                           view->drag_info.start.y,
1849                                                           event->x_root,
1850                                                           event->y_root);
1851                         view->drag_info.in_drag = start;
1852                 }
1853
1854                 if (view->drag_info.in_drag) {
1855                         int dx, dy;
1856                         gdouble dhadj_value, dvadj_value;
1857
1858                         dx = event->x_root - view->drag_info.start.x;
1859                         dy = event->y_root - view->drag_info.start.y;
1860
1861                         dhadj_value = view->hadjustment->page_size *
1862                                       (gdouble)dx / widget->allocation.width;
1863                         dvadj_value = view->vadjustment->page_size *
1864                                       (gdouble)dy / widget->allocation.height;
1865
1866                         /* clamp scrolling to visible area */
1867                         gtk_adjustment_set_value (view->hadjustment,
1868                                                   MIN(view->drag_info.hadj - dhadj_value,
1869                                                       view->hadjustment->upper -
1870                                                       view->hadjustment->page_size));
1871                         gtk_adjustment_set_value (view->vadjustment,
1872                                                   MIN(view->drag_info.vadj - dvadj_value,
1873                                                       view->vadjustment->upper -
1874                                                       view->vadjustment->page_size));
1875
1876                         return TRUE;
1877                 }
1878         /* For the Evince 0.4.x release, we limit links to un-rotated documents
1879          * only.
1880          */
1881         } else if (view->pressed_button <= 0 &&
1882                    view->rotation == 0) {
1883                 handle_link_over_xy (view, x, y);
1884                 return TRUE;
1885         }
1886
1887         return FALSE;
1888 }
1889
1890 static gboolean
1891 ev_view_button_release_event (GtkWidget      *widget,
1892                               GdkEventButton *event)
1893 {
1894         EvView *view = EV_VIEW (widget);
1895         EvLink *link;
1896
1897         if (view->pressed_button == 2) {
1898                 ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
1899         }
1900
1901         if (view->document) {
1902                 link = ev_view_get_link_at_location (view, event->x, event->y);
1903         } else {
1904                 link = NULL;
1905         }
1906
1907         view->pressed_button = -1;
1908         view->drag_info.in_drag = FALSE;
1909
1910         if (view->selection_scroll_id) {
1911             g_source_remove (view->selection_scroll_id);
1912             view->selection_scroll_id = 0;
1913         }
1914         if (view->selection_update_id) {
1915             g_source_remove (view->selection_update_id);
1916             view->selection_update_id = 0;
1917         }
1918
1919         if (view->selection_info.selections) {
1920                 ev_view_update_primary_selection (view);
1921
1922                 if (view->selection_info.in_drag) {
1923                         clear_selection (view);
1924                         gtk_widget_queue_draw (widget);
1925                 }
1926
1927                 view->selection_info.in_drag = FALSE;
1928         } else if (link) {
1929                 ev_view_goto_link (view, link);
1930         } else if (view->presentation) {
1931                 switch (event->button) {
1932                 case 1:
1933                         ev_view_next_page (view);
1934                         return TRUE;
1935                 case 3:
1936                         ev_view_previous_page (view);
1937                         return TRUE;
1938                 }
1939         }
1940
1941         return FALSE;
1942 }
1943
1944 static gint
1945 ev_view_focus_in (GtkWidget     *widget,
1946                   GdkEventFocus *event)
1947 {
1948         if (EV_VIEW (widget)->pixbuf_cache)
1949                 ev_pixbuf_cache_style_changed (EV_VIEW (widget)->pixbuf_cache);
1950         gtk_widget_queue_draw (widget);
1951
1952         return FALSE;
1953 }
1954
1955 static gint
1956 ev_view_focus_out (GtkWidget     *widget,
1957                      GdkEventFocus *event)
1958 {
1959         if (EV_VIEW (widget)->pixbuf_cache)
1960                 ev_pixbuf_cache_style_changed (EV_VIEW (widget)->pixbuf_cache);
1961         gtk_widget_queue_draw (widget);
1962
1963         return FALSE;
1964 }
1965
1966 static gboolean
1967 ev_view_leave_notify_event (GtkWidget *widget, GdkEventCrossing   *event)
1968 {
1969         EvView *view = EV_VIEW (widget);
1970
1971         ev_view_set_status (view, NULL);
1972
1973         if (view->cursor == EV_VIEW_CURSOR_LINK ||
1974             view->cursor == EV_VIEW_CURSOR_IBEAM)
1975                 ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
1976
1977         if (view->link_tooltip) {
1978                 view->hovered_link = NULL;
1979                 ev_tooltip_deactivate (EV_TOOLTIP (view->link_tooltip));
1980         }
1981
1982         return FALSE;
1983 }
1984
1985 static gboolean
1986 ev_view_enter_notify_event (GtkWidget *widget, GdkEventCrossing   *event)
1987 {
1988         EvView *view = EV_VIEW (widget);
1989
1990         handle_link_over_xy (view, event->x, event->y);
1991
1992         return FALSE;
1993 }
1994
1995 static void
1996 ev_view_style_set (GtkWidget *widget,
1997                    GtkStyle  *old_style)
1998 {
1999         if (EV_VIEW (widget)->pixbuf_cache)
2000                 ev_pixbuf_cache_style_changed (EV_VIEW (widget)->pixbuf_cache);
2001
2002         GTK_WIDGET_CLASS (ev_view_parent_class)->style_set (widget, old_style);
2003 }
2004
2005 /*** Drawing ***/
2006
2007 static guint32
2008 ev_gdk_color_to_rgb (const GdkColor *color)
2009 {
2010   guint32 result;
2011   result = (0xff0000 | (color->red & 0xff00));
2012   result <<= 8;
2013   result |= ((color->green & 0xff00) | (color->blue >> 8));
2014   return result;
2015 }
2016
2017 static void
2018 draw_rubberband (GtkWidget *widget, GdkWindow *window,
2019                  const GdkRectangle *rect, guchar alpha)
2020 {
2021         GdkGC *gc;
2022         GdkPixbuf *pixbuf;
2023         GdkColor *fill_color_gdk;
2024         guint fill_color;
2025
2026         fill_color_gdk = gdk_color_copy (&GTK_WIDGET (widget)->style->base[GTK_STATE_SELECTED]);
2027         fill_color = ev_gdk_color_to_rgb (fill_color_gdk) << 8 | alpha;
2028
2029         pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8,
2030                                  rect->width, rect->height);
2031         gdk_pixbuf_fill (pixbuf, fill_color);
2032
2033         gdk_draw_pixbuf (window, NULL, pixbuf,
2034                          0, 0,
2035                          rect->x - EV_VIEW (widget)->scroll_x, rect->y - EV_VIEW (widget)->scroll_y,
2036                          rect->width, rect->height,
2037                          GDK_RGB_DITHER_NONE,
2038                          0, 0);
2039
2040         g_object_unref (pixbuf);
2041
2042         gc = gdk_gc_new (window);
2043         gdk_gc_set_rgb_fg_color (gc, fill_color_gdk);
2044         gdk_draw_rectangle (window, gc, FALSE,
2045                             rect->x - EV_VIEW (widget)->scroll_x, rect->y - EV_VIEW (widget)->scroll_y,
2046                             rect->width - 1,
2047                             rect->height - 1);
2048         g_object_unref (gc);
2049
2050         gdk_color_free (fill_color_gdk);
2051 }
2052
2053
2054 static void
2055 highlight_find_results (EvView *view, int page)
2056 {
2057         EvDocumentFind *find;
2058         int i, results = 0;
2059
2060         g_return_if_fail (EV_IS_DOCUMENT_FIND (view->document));
2061
2062         find = EV_DOCUMENT_FIND (view->document);
2063
2064         results = ev_document_find_get_n_results (find, page);
2065
2066         for (i = 0; i < results; i++) {
2067                 EvRectangle rectangle;
2068                 GdkRectangle view_rectangle;
2069                 guchar alpha;
2070
2071                 if (i == view->find_result && page == view->current_page) {
2072                         alpha = 0x90;
2073                 } else {
2074                         alpha = 0x20;
2075                 }
2076
2077                 ev_document_find_get_result (find, page, i, &rectangle);
2078                 doc_rect_to_view_rect (view, page, &rectangle, &view_rectangle);
2079                 draw_rubberband (GTK_WIDGET (view), GTK_WIDGET(view)->window,
2080                                  &view_rectangle, alpha);
2081         }
2082 }
2083
2084 static void
2085 draw_loading_text (EvView       *view,
2086                    GdkRectangle *page_area,
2087                    GdkRectangle *expose_area)
2088 {
2089         PangoLayout *layout;
2090         PangoFontDescription *font_desc;
2091         PangoRectangle logical_rect;
2092         double real_scale;
2093         int target_width;
2094
2095         const char *loading_text = _("Loading...");
2096
2097         layout = gtk_widget_create_pango_layout (GTK_WIDGET (view), loading_text);
2098
2099         font_desc = pango_font_description_new ();
2100
2101
2102         /* We set the font to be 10 points, get the size, and scale appropriately */
2103         pango_font_description_set_size (font_desc, 10 * PANGO_SCALE);
2104         pango_layout_set_font_description (layout, font_desc);
2105         pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
2106
2107         /* Make sure we fit the middle of the page */
2108         target_width = MAX (page_area->width / 2, 1);
2109         real_scale = ((double)target_width / (double) logical_rect.width) * (PANGO_SCALE * 10);
2110         pango_font_description_set_size (font_desc, (int)real_scale);
2111         pango_layout_set_font_description (layout, font_desc);
2112         pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
2113
2114         gtk_paint_layout (GTK_WIDGET (view)->style,
2115                           GTK_WIDGET (view)->window,
2116                           GTK_WIDGET_STATE (view),
2117                           FALSE,
2118                           page_area,
2119                           GTK_WIDGET (view),
2120                           NULL,
2121                           page_area->x + (target_width/2),
2122                           page_area->y + (page_area->height - logical_rect.height) / 2,
2123                           layout);
2124
2125         pango_font_description_free (font_desc);
2126         g_object_unref (layout);
2127 }
2128
2129 static void
2130 draw_one_page (EvView          *view,
2131                gint             page,
2132                GdkRectangle    *page_area,
2133                GtkBorder       *border,
2134                GdkRectangle    *expose_area)
2135 {
2136         gint width, height;
2137         GdkPixbuf *current_pixbuf;
2138         GdkRectangle overlap;
2139         GdkRectangle real_page_area;
2140         EvViewSelection *selection;
2141         gint current_page;
2142
2143         g_assert (view->document);
2144
2145         if (! gdk_rectangle_intersect (page_area, expose_area, &overlap))
2146                 return;
2147
2148         current_page = ev_page_cache_get_current_page (view->page_cache);
2149         selection = find_selection_for_page (view, page);
2150         ev_page_cache_get_size (view->page_cache,
2151                                 page, view->rotation,
2152                                 view->scale,
2153                                 &width, &height);
2154         /* Render the document itself */
2155         real_page_area = *page_area;
2156
2157         real_page_area.x += border->left;
2158         real_page_area.y += border->top;
2159         real_page_area.width -= (border->left + border->right);
2160         real_page_area.height -= (border->top + border->bottom);
2161
2162         ev_document_misc_paint_one_page (GTK_WIDGET(view)->window,
2163                                          GTK_WIDGET (view),
2164                                          page_area, border,
2165                                          page == current_page);
2166
2167         if (gdk_rectangle_intersect (&real_page_area, expose_area, &overlap)) {
2168                 GdkPixbuf *selection_pixbuf = NULL;
2169                 GdkPixbuf *scaled_image;
2170                 GdkPixbuf *scaled_selection;
2171
2172                 current_pixbuf = ev_pixbuf_cache_get_pixbuf (view->pixbuf_cache, page);
2173
2174                 /* Get the selection pixbuf iff we have something to draw */
2175                 if (current_pixbuf && view->selection_mode == EV_VIEW_SELECTION_TEXT && selection)
2176                         selection_pixbuf = ev_pixbuf_cache_get_selection_pixbuf (view->pixbuf_cache,
2177                                                                                  page,
2178                                                                                  view->scale,
2179                                                                                  NULL);
2180
2181                 if (current_pixbuf == NULL)
2182                         scaled_image = NULL;
2183                 else if (width == gdk_pixbuf_get_width (current_pixbuf) &&
2184                          height == gdk_pixbuf_get_height (current_pixbuf))
2185                         scaled_image = g_object_ref (current_pixbuf);
2186                 else
2187                         /* FIXME: We don't want to scale the whole area, just the right
2188                          * area of it */
2189                         scaled_image = gdk_pixbuf_scale_simple (current_pixbuf,
2190                                                                 width, height,
2191                                                                 GDK_INTERP_NEAREST);
2192
2193                 if (selection_pixbuf == NULL)
2194                         scaled_selection = NULL;
2195                 else if (width == gdk_pixbuf_get_width (selection_pixbuf) &&
2196                          height == gdk_pixbuf_get_height (selection_pixbuf))
2197                         scaled_selection = g_object_ref (selection_pixbuf);
2198                 else
2199                         /* FIXME: We don't want to scale the whole area, just the right
2200                          * area of it */
2201                         scaled_selection = gdk_pixbuf_scale_simple (selection_pixbuf,
2202                                                                     width, height,
2203                                                                     GDK_INTERP_NEAREST);
2204
2205                 if (scaled_image) {
2206                         gdk_draw_pixbuf (GTK_WIDGET(view)->window,
2207                                          GTK_WIDGET (view)->style->fg_gc[GTK_STATE_NORMAL],
2208                                          scaled_image,
2209                                          overlap.x - real_page_area.x,
2210                                          overlap.y - real_page_area.y,
2211                                          overlap.x, overlap.y,
2212                                          overlap.width, overlap.height,
2213                                          GDK_RGB_DITHER_NORMAL,
2214                                          0, 0);
2215                         g_object_unref (scaled_image);
2216                 } else {
2217                         draw_loading_text (view,
2218                                            &real_page_area,
2219                                            expose_area);
2220                 }
2221
2222                 if (scaled_selection) {
2223                         gdk_draw_pixbuf (GTK_WIDGET(view)->window,
2224                                          GTK_WIDGET (view)->style->fg_gc[GTK_STATE_NORMAL],
2225                                          scaled_selection,
2226                                          overlap.x - real_page_area.x,
2227                                          overlap.y - real_page_area.y,
2228                                          overlap.x, overlap.y,
2229                                          overlap.width, overlap.height,
2230                                          GDK_RGB_DITHER_NORMAL,
2231                                          0, 0);
2232                         g_object_unref (scaled_selection);
2233                 }
2234         }
2235 }
2236
2237 /*** GObject functions ***/
2238
2239 static void
2240 ev_view_finalize (GObject *object)
2241 {
2242         EvView *view = EV_VIEW (object);
2243
2244         LOG ("Finalize");
2245
2246         g_free (view->status);
2247         g_free (view->find_status);
2248
2249         clear_selection (view);
2250
2251         G_OBJECT_CLASS (ev_view_parent_class)->finalize (object);
2252 }
2253
2254 static void
2255 ev_view_destroy (GtkObject *object)
2256 {
2257         EvView *view = EV_VIEW (object);
2258
2259         if (view->document) {
2260                 g_object_unref (view->document);
2261                 view->document = NULL;
2262         }
2263
2264         if (view->pixbuf_cache) {
2265                 g_object_unref (view->pixbuf_cache);
2266                 view->pixbuf_cache = NULL;
2267         }
2268
2269         if (view->link_tooltip) {
2270                 gtk_widget_destroy (view->link_tooltip);
2271         }
2272
2273         if (view->selection_scroll_id) {
2274             g_source_remove (view->selection_scroll_id);
2275             view->selection_scroll_id = 0;
2276         }
2277
2278         if (view->selection_update_id) {
2279             g_source_remove (view->selection_update_id);
2280             view->selection_update_id = 0;
2281         }
2282
2283         ev_view_set_scroll_adjustments (view, NULL, NULL);
2284
2285         GTK_OBJECT_CLASS (ev_view_parent_class)->destroy (object);
2286 }
2287
2288 static void
2289 ev_view_set_property (GObject      *object,
2290                       guint         prop_id,
2291                       const GValue *value,
2292                       GParamSpec   *pspec)
2293 {
2294         EvView *view = EV_VIEW (object);
2295
2296         switch (prop_id)
2297         {
2298         case PROP_CONTINUOUS:
2299                 ev_view_set_continuous (view, g_value_get_boolean (value));
2300                 break;
2301         case PROP_DUAL_PAGE:
2302                 ev_view_set_dual_page (view, g_value_get_boolean (value));
2303                 break;
2304         case PROP_FULLSCREEN:
2305                 ev_view_set_fullscreen (view, g_value_get_boolean (value));
2306                 break;
2307         case PROP_PRESENTATION:
2308                 ev_view_set_presentation (view, g_value_get_boolean (value));
2309                 break;
2310         case PROP_SIZING_MODE:
2311                 ev_view_set_sizing_mode (view, g_value_get_enum (value));
2312                 break;
2313         case PROP_ZOOM:
2314                 ev_view_set_zoom (view, g_value_get_double (value), FALSE);
2315                 break;
2316         case PROP_ROTATION:
2317                 ev_view_set_rotation (view, g_value_get_int (value));
2318                 break;
2319         default:
2320                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2321         }
2322 }
2323
2324 static AtkObject *
2325 ev_view_get_accessible (GtkWidget *widget)
2326 {
2327         static gboolean first_time = TRUE;
2328
2329         if (first_time) {
2330                 AtkObjectFactory *factory;
2331                 AtkRegistry *registry;
2332                 GType derived_type;
2333                 GType derived_atk_type;
2334
2335                 /*
2336                  * Figure out whether accessibility is enabled by looking at the
2337                  * type of the accessible object which would be created for
2338                  * the parent type of EvView.
2339                  */
2340                 derived_type = g_type_parent (EV_TYPE_VIEW);
2341
2342                 registry = atk_get_default_registry ();
2343                 factory = atk_registry_get_factory (registry,
2344                                                     derived_type);
2345                 derived_atk_type = atk_object_factory_get_accessible_type (factory);
2346                 if (g_type_is_a (derived_atk_type, GTK_TYPE_ACCESSIBLE))
2347                         atk_registry_set_factory_type (registry,
2348                                                        EV_TYPE_VIEW,
2349                                                        ev_view_accessible_factory_get_type ());
2350                 first_time = FALSE;
2351         }
2352         return GTK_WIDGET_CLASS (ev_view_parent_class)->get_accessible (widget);
2353 }
2354
2355 static void
2356 ev_view_get_property (GObject *object,
2357                       guint prop_id,
2358                       GValue *value,
2359                       GParamSpec *pspec)
2360 {
2361         EvView *view = EV_VIEW (object);
2362
2363         switch (prop_id)
2364         {
2365         case PROP_STATUS:
2366                 g_value_set_string (value, view->status);
2367                 break;
2368         case PROP_FIND_STATUS:
2369                 g_value_set_string (value, view->status);
2370                 break;
2371         case PROP_CONTINUOUS:
2372                 g_value_set_boolean (value, view->continuous);
2373                 break;
2374         case PROP_DUAL_PAGE:
2375                 g_value_set_boolean (value, view->dual_page);
2376                 break;
2377         case PROP_FULLSCREEN:
2378                 g_value_set_boolean (value, view->fullscreen);
2379                 break;
2380         case PROP_PRESENTATION:
2381                 g_value_set_boolean (value, view->presentation);
2382                 break;
2383         case PROP_SIZING_MODE:
2384                 g_value_set_enum (value, view->sizing_mode);
2385                 break;
2386         case PROP_ZOOM:
2387                 g_value_set_double (value, view->scale);
2388                 break;
2389         case PROP_ROTATION:
2390                 g_value_set_int (value, view->rotation);
2391                 break;
2392         case PROP_HAS_SELECTION:
2393                 g_value_set_boolean (value,
2394                                      view->selection_info.selections != NULL);
2395                 break;
2396         default:
2397                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2398         }
2399 }
2400
2401 static void
2402 ev_view_class_init (EvViewClass *class)
2403 {
2404         GObjectClass *object_class = G_OBJECT_CLASS (class);
2405         GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (class);
2406         GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
2407         GtkBindingSet *binding_set;
2408
2409         object_class->finalize = ev_view_finalize;
2410         object_class->set_property = ev_view_set_property;
2411         object_class->get_property = ev_view_get_property;
2412
2413         widget_class->expose_event = ev_view_expose_event;
2414         widget_class->button_press_event = ev_view_button_press_event;
2415         widget_class->motion_notify_event = ev_view_motion_notify_event;
2416         widget_class->button_release_event = ev_view_button_release_event;
2417         widget_class->focus_in_event = ev_view_focus_in;
2418         widget_class->focus_out_event = ev_view_focus_out;
2419         widget_class->get_accessible = ev_view_get_accessible;
2420         widget_class->size_request = ev_view_size_request;
2421         widget_class->size_allocate = ev_view_size_allocate;
2422         widget_class->realize = ev_view_realize;
2423         widget_class->scroll_event = ev_view_scroll_event;
2424         widget_class->enter_notify_event = ev_view_enter_notify_event;
2425         widget_class->leave_notify_event = ev_view_leave_notify_event;
2426         widget_class->style_set = ev_view_style_set;
2427         widget_class->drag_data_get = ev_view_drag_data_get;
2428         widget_class->popup_menu = ev_view_popup_menu;
2429         gtk_object_class->destroy = ev_view_destroy;
2430
2431         class->set_scroll_adjustments = ev_view_set_scroll_adjustments;
2432         class->binding_activated = ev_view_scroll;
2433
2434         widget_class->set_scroll_adjustments_signal =
2435             g_signal_new ("set-scroll-adjustments",
2436                           G_OBJECT_CLASS_TYPE (object_class),
2437                           G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
2438                           G_STRUCT_OFFSET (EvViewClass, set_scroll_adjustments),
2439                           NULL, NULL,
2440                           ev_marshal_VOID__OBJECT_OBJECT,
2441                           G_TYPE_NONE, 2,
2442                           GTK_TYPE_ADJUSTMENT,
2443                           GTK_TYPE_ADJUSTMENT);
2444
2445         signals[SIGNAL_BINDING_ACTIVATED] = g_signal_new ("binding_activated",
2446                          G_TYPE_FROM_CLASS (object_class),
2447                          G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
2448                          G_STRUCT_OFFSET (EvViewClass, binding_activated),
2449                          NULL, NULL,
2450                          ev_marshal_VOID__ENUM_BOOLEAN,
2451                          G_TYPE_NONE, 2,
2452                          GTK_TYPE_SCROLL_TYPE,
2453                          G_TYPE_BOOLEAN);
2454
2455         signals[SIGNAL_ZOOM_INVALID] = g_signal_new ("zoom-invalid",
2456                          G_TYPE_FROM_CLASS (object_class),
2457                          G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
2458                          G_STRUCT_OFFSET (EvViewClass, zoom_invalid),
2459                          NULL, NULL,
2460                          ev_marshal_VOID__VOID,
2461                          G_TYPE_NONE, 0, G_TYPE_NONE);
2462         signals[SIGNAL_EXTERNAL_LINK] = g_signal_new ("external-link",
2463                          G_TYPE_FROM_CLASS (object_class),
2464                          G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
2465                          G_STRUCT_OFFSET (EvViewClass, external_link),
2466                          NULL, NULL,
2467                          g_cclosure_marshal_VOID__OBJECT,
2468                          G_TYPE_NONE, 1,
2469                          G_TYPE_OBJECT);
2470         signals[SIGNAL_POPUP_MENU] = g_signal_new ("popup",
2471                          G_TYPE_FROM_CLASS (object_class),
2472                          G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
2473                          G_STRUCT_OFFSET (EvViewClass, popup_menu),
2474                          NULL, NULL,
2475                          g_cclosure_marshal_VOID__OBJECT,
2476                          G_TYPE_NONE, 1,
2477                          G_TYPE_OBJECT);
2478
2479         g_object_class_install_property (object_class,
2480                                          PROP_STATUS,
2481                                          g_param_spec_string ("status",
2482                                                               "Status Message",
2483                                                               "The status message",
2484                                                               NULL,
2485                                                               G_PARAM_READABLE));
2486
2487         g_object_class_install_property (object_class,
2488                                          PROP_FIND_STATUS,
2489                                          g_param_spec_string ("find-status",
2490                                                               "Find Status Message",
2491                                                               "The find status message",
2492                                                               NULL,
2493                                                               G_PARAM_READABLE));
2494
2495         g_object_class_install_property (object_class,
2496                                          PROP_CONTINUOUS,
2497                                          g_param_spec_boolean ("continuous",
2498                                                                "Continuous",
2499                                                                "Continuous scrolling mode",
2500                                                                TRUE,
2501                                                                G_PARAM_READWRITE));
2502
2503         g_object_class_install_property (object_class,
2504                                          PROP_DUAL_PAGE,
2505                                          g_param_spec_boolean ("dual-page",
2506                                                                "Dual Page",
2507                                                                "Two pages visible at once",
2508                                                                FALSE,
2509                                                                G_PARAM_READWRITE));
2510         g_object_class_install_property (object_class,
2511                                          PROP_FULLSCREEN,
2512                                          g_param_spec_boolean ("fullscreen",
2513                                                                "Full Screen",
2514                                                                "Draw page in a fullscreen fashion",
2515                                                                FALSE,
2516                                                                G_PARAM_READWRITE));
2517         g_object_class_install_property (object_class,
2518                                          PROP_PRESENTATION,
2519                                          g_param_spec_boolean ("presentation",
2520                                                                "Presentation",
2521                                                                "Draw page in presentation mode",
2522                                                                TRUE,
2523                                                                G_PARAM_READWRITE));
2524
2525         g_object_class_install_property (object_class,
2526                                          PROP_SIZING_MODE,
2527                                          g_param_spec_enum ("sizing-mode",
2528                                                             "Sizing Mode",
2529                                                             "Sizing Mode",
2530                                                             EV_TYPE_SIZING_MODE,
2531                                                             EV_SIZING_FIT_WIDTH,
2532                                                             G_PARAM_READWRITE));
2533
2534         g_object_class_install_property (object_class,
2535                                          PROP_ZOOM,
2536                                          g_param_spec_double ("zoom",
2537                                                               "Zoom factor",
2538                                                                "Zoom factor",
2539                                                                MIN_SCALE,
2540                                                                MAX_SCALE,
2541                                                                1.0,
2542                                                                G_PARAM_READWRITE));
2543         g_object_class_install_property (object_class,
2544                                          PROP_ROTATION,
2545                                          g_param_spec_double ("rotation",
2546                                                               "Rotation",
2547                                                                "Rotation",
2548                                                                0,
2549                                                                360,
2550                                                                0,
2551                                                                G_PARAM_READWRITE));
2552         g_object_class_install_property (object_class,
2553                                          PROP_HAS_SELECTION,
2554                                          g_param_spec_boolean ("has-selection",
2555                                                                "Has selection",
2556                                                                "The view has selections",
2557                                                                FALSE,
2558                                                                G_PARAM_READABLE));
2559
2560         binding_set = gtk_binding_set_by_class (class);
2561
2562         add_scroll_binding_keypad (binding_set, GDK_Left,  0, EV_SCROLL_STEP_BACKWARD, TRUE);
2563         add_scroll_binding_keypad (binding_set, GDK_Right, 0, EV_SCROLL_STEP_FORWARD,  TRUE);
2564         add_scroll_binding_keypad (binding_set, GDK_Left,  GDK_MOD1_MASK, EV_SCROLL_STEP_DOWN, TRUE);
2565         add_scroll_binding_keypad (binding_set, GDK_Right, GDK_MOD1_MASK, EV_SCROLL_STEP_UP,  TRUE);
2566         add_scroll_binding_keypad (binding_set, GDK_Up,    0, EV_SCROLL_STEP_BACKWARD, FALSE);
2567         add_scroll_binding_keypad (binding_set, GDK_Down,  0, EV_SCROLL_STEP_FORWARD,  FALSE);
2568         add_scroll_binding_keypad (binding_set, GDK_Up,    GDK_MOD1_MASK, EV_SCROLL_STEP_DOWN, FALSE);
2569         add_scroll_binding_keypad (binding_set, GDK_Down,  GDK_MOD1_MASK, EV_SCROLL_STEP_UP,  FALSE);
2570 }
2571
2572 static void
2573 ev_view_init (EvView *view)
2574 {
2575         GTK_WIDGET_SET_FLAGS (view, GTK_CAN_FOCUS);
2576
2577         view->spacing = 5;
2578         view->scale = 1.0;
2579         view->current_page = 0;
2580         view->pressed_button = -1;
2581         view->cursor = EV_VIEW_CURSOR_NORMAL;
2582         view->drag_info.in_drag = FALSE;
2583         view->selection_info.selections = NULL;
2584         view->selection_info.in_selection = FALSE;
2585         view->selection_info.in_drag = FALSE;
2586         view->selection_mode = EV_VIEW_SELECTION_TEXT;
2587         view->continuous = TRUE;
2588         view->dual_page = FALSE;
2589         view->presentation = FALSE;
2590         view->fullscreen = FALSE;
2591         view->sizing_mode = EV_SIZING_FIT_WIDTH;
2592         view->pending_scroll = SCROLL_TO_KEEP_POSITION;
2593         view->jump_to_find_result = TRUE;
2594 }
2595
2596 /*** Callbacks ***/
2597
2598 static void
2599 find_changed_cb (EvDocument *document, int page, EvView *view)
2600 {
2601         double percent;
2602         int n_pages;
2603
2604         percent = ev_document_find_get_progress
2605                         (EV_DOCUMENT_FIND (view->document));
2606         n_pages = ev_page_cache_get_n_pages (view->page_cache);
2607
2608         if (view->jump_to_find_result == TRUE) {
2609                 jump_to_find_page (view, EV_VIEW_FIND_NEXT, 0);
2610                 jump_to_find_result (view);
2611         }
2612         update_find_status_message (view, percent * n_pages >= n_pages - 1 );
2613         if (view->current_page == page)
2614                 gtk_widget_queue_draw (GTK_WIDGET (view));
2615 }
2616
2617 static void
2618 job_finished_cb (EvPixbufCache *pixbuf_cache,
2619                  EvView        *view)
2620 {
2621         gtk_widget_queue_draw (GTK_WIDGET (view));
2622 }
2623
2624 static void
2625 page_changed_cb (EvPageCache *page_cache,
2626                  int          new_page,
2627                  EvView      *view)
2628 {
2629         if (view->current_page != new_page) {
2630                 view->current_page = new_page;
2631                 view->pending_scroll = SCROLL_TO_PAGE_POSITION;
2632                 gtk_widget_queue_resize (GTK_WIDGET (view));
2633         } else {
2634                 gtk_widget_queue_draw (GTK_WIDGET (view));
2635         }
2636
2637         if (EV_IS_DOCUMENT_FIND (view->document)) {
2638                 view->find_result = 0;
2639                 update_find_status_message (view, TRUE);
2640         }
2641 }
2642
2643 static void on_adjustment_value_changed (GtkAdjustment  *adjustment,
2644                                          EvView *view)
2645 {
2646         int dx = 0, dy = 0;
2647
2648         if (! GTK_WIDGET_REALIZED (view))
2649                 return;
2650
2651         if (view->hadjustment) {
2652                 dx = view->scroll_x - (int) view->hadjustment->value;
2653                 view->scroll_x = (int) view->hadjustment->value;
2654         } else {
2655                 view->scroll_x = 0;
2656         }
2657
2658         if (view->vadjustment) {
2659                 dy = view->scroll_y - (int) view->vadjustment->value;
2660                 view->scroll_y = (int) view->vadjustment->value;
2661         } else {
2662                 view->scroll_y = 0;
2663         }
2664
2665
2666         if (view->pending_resize)
2667                 gtk_widget_queue_draw (GTK_WIDGET (view));
2668         else
2669                 gdk_window_scroll (GTK_WIDGET (view)->window, dx, dy);
2670
2671
2672         if (view->document)
2673                 view_update_range_and_current_page (view);
2674 }
2675
2676 GtkWidget*
2677 ev_view_new (void)
2678 {
2679         GtkWidget *view;
2680
2681         view = g_object_new (EV_TYPE_VIEW, NULL);
2682
2683         return view;
2684 }
2685
2686 static void
2687 setup_caches (EvView *view)
2688 {
2689         view->page_cache = ev_page_cache_get (view->document);
2690         g_signal_connect (view->page_cache, "page-changed", G_CALLBACK (page_changed_cb), view);
2691         view->pixbuf_cache = ev_pixbuf_cache_new (GTK_WIDGET (view), view->document);
2692         g_signal_connect (view->pixbuf_cache, "job-finished", G_CALLBACK (job_finished_cb), view);
2693 }
2694
2695 static void
2696 clear_caches (EvView *view)
2697 {
2698         if (view->pixbuf_cache) {
2699                 g_object_unref (view->pixbuf_cache);
2700                 view->pixbuf_cache = NULL;
2701         }
2702
2703         if (view->page_cache) {
2704                 view->page_cache = NULL;
2705         }
2706 }
2707
2708 void
2709 ev_view_set_loading (EvView       *view,
2710                      gboolean      loading)
2711 {
2712         view->loading = loading;
2713         gtk_widget_queue_draw (GTK_WIDGET (view));
2714 }
2715
2716 void
2717 ev_view_set_document (EvView     *view,
2718                       EvDocument *document)
2719 {
2720         g_return_if_fail (EV_IS_VIEW (view));
2721
2722         view->loading = FALSE;
2723
2724         if (document != view->document) {
2725                 clear_caches (view);
2726
2727                 if (view->document) {
2728                         g_signal_handlers_disconnect_by_func (view->document,
2729                                                               find_changed_cb,
2730                                                               view);
2731                         g_object_unref (view->document);
2732                         view->page_cache = NULL;
2733
2734                 }
2735
2736                 view->document = document;
2737                 view->find_result = 0;
2738
2739                 if (view->document) {
2740                         g_object_ref (view->document);
2741                         if (EV_IS_DOCUMENT_FIND (view->document)) {
2742                                 g_signal_connect (view->document,
2743                                                   "find_changed",
2744                                                   G_CALLBACK (find_changed_cb),
2745                                                   view);
2746                         }
2747
2748                         setup_caches (view);
2749                 }
2750
2751                 gtk_widget_queue_resize (GTK_WIDGET (view));
2752         }
2753 }
2754
2755 /*** Zoom and sizing mode ***/
2756
2757 #define EPSILON 0.0000001
2758 void
2759 ev_view_set_zoom (EvView   *view,
2760                   double    factor,
2761                   gboolean  relative)
2762 {
2763         double scale;
2764
2765         if (relative)
2766                 scale = view->scale * factor;
2767         else
2768                 scale = factor;
2769
2770         scale = CLAMP (scale, MIN_SCALE, MAX_SCALE);
2771
2772         if (ABS (view->scale - scale) < EPSILON)
2773                 return;
2774
2775         view->scale = scale;
2776         view->pending_resize = TRUE;
2777
2778         gtk_widget_queue_resize (GTK_WIDGET (view));
2779
2780         g_object_notify (G_OBJECT (view), "zoom");
2781 }
2782
2783 double
2784 ev_view_get_zoom (EvView *view)
2785 {
2786         return view->scale;
2787 }
2788
2789 gboolean
2790 ev_view_get_continuous (EvView *view)
2791 {
2792         g_return_val_if_fail (EV_IS_VIEW (view), FALSE);
2793
2794         return view->continuous;
2795 }
2796
2797 void
2798 ev_view_set_continuous (EvView   *view,
2799                         gboolean  continuous)
2800 {
2801         g_return_if_fail (EV_IS_VIEW (view));
2802
2803         continuous = continuous != FALSE;
2804
2805         if (view->continuous != continuous) {
2806                 view->continuous = continuous;
2807                 view->pending_scroll = SCROLL_TO_PAGE_POSITION;
2808                 gtk_widget_queue_resize (GTK_WIDGET (view));
2809         }
2810
2811         g_object_notify (G_OBJECT (view), "continuous");
2812 }
2813
2814 gboolean
2815 ev_view_get_dual_page (EvView *view)
2816 {
2817         g_return_val_if_fail (EV_IS_VIEW (view), FALSE);
2818
2819         return view->dual_page;
2820 }
2821
2822 void
2823 ev_view_set_dual_page (EvView   *view,
2824                        gboolean  dual_page)
2825 {
2826         g_return_if_fail (EV_IS_VIEW (view));
2827
2828         dual_page = dual_page != FALSE;
2829
2830         if (view->dual_page == dual_page)
2831                 return;
2832
2833         view->pending_scroll = SCROLL_TO_PAGE_POSITION;
2834         view->dual_page = dual_page;
2835         /* FIXME: if we're keeping the pixbuf cache around, we should extend the
2836          * preload_cache_size to be 2 if dual_page is set.
2837          */
2838         gtk_widget_queue_resize (GTK_WIDGET (view));
2839
2840         g_object_notify (G_OBJECT (view), "dual-page");
2841 }
2842
2843 void
2844 ev_view_set_fullscreen (EvView   *view,
2845                          gboolean  fullscreen)
2846 {
2847         g_return_if_fail (EV_IS_VIEW (view));
2848
2849         fullscreen = fullscreen != FALSE;
2850
2851         if (view->fullscreen == fullscreen)
2852                 return;
2853
2854         view->fullscreen = fullscreen;
2855         gtk_widget_queue_resize (GTK_WIDGET (view));
2856
2857         g_object_notify (G_OBJECT (view), "fullscreen");
2858 }
2859
2860 gboolean
2861 ev_view_get_fullscreen (EvView *view)
2862 {
2863         g_return_val_if_fail (EV_IS_VIEW (view), FALSE);
2864
2865         return view->fullscreen;
2866 }
2867
2868 void
2869 ev_view_set_presentation (EvView   *view,
2870                           gboolean  presentation)
2871 {
2872         g_return_if_fail (EV_IS_VIEW (view));
2873
2874         presentation = presentation != FALSE;
2875
2876         if (view->presentation == presentation)
2877                 return;
2878
2879         view->presentation = presentation;
2880         view->pending_scroll = SCROLL_TO_PAGE_POSITION;
2881         gtk_widget_queue_resize (GTK_WIDGET (view));
2882
2883         if (GTK_WIDGET_REALIZED (view)) {
2884                 if (view->presentation)
2885                         gdk_window_set_background (GTK_WIDGET(view)->window,
2886                                                    &GTK_WIDGET (view)->style->black);
2887                 else
2888                         gdk_window_set_background (GTK_WIDGET(view)->window,
2889                                                    &GTK_WIDGET (view)->style->mid [GTK_STATE_NORMAL]);
2890         }
2891
2892
2893         g_object_notify (G_OBJECT (view), "presentation");
2894 }
2895
2896 gboolean
2897 ev_view_get_presentation (EvView *view)
2898 {
2899         g_return_val_if_fail (EV_IS_VIEW (view), FALSE);
2900
2901         return view->presentation;
2902 }
2903
2904 void
2905 ev_view_set_sizing_mode (EvView       *view,
2906                          EvSizingMode  sizing_mode)
2907 {
2908         g_return_if_fail (EV_IS_VIEW (view));
2909
2910         if (view->sizing_mode == sizing_mode)
2911                 return;
2912
2913         view->sizing_mode = sizing_mode;
2914         gtk_widget_queue_resize (GTK_WIDGET (view));
2915
2916         g_object_notify (G_OBJECT (view), "sizing-mode");
2917 }
2918
2919 EvSizingMode
2920 ev_view_get_sizing_mode (EvView *view)
2921 {
2922         g_return_val_if_fail (EV_IS_VIEW (view), EV_SIZING_FREE);
2923
2924         return view->sizing_mode;
2925 }
2926
2927 gboolean
2928 ev_view_can_zoom_in (EvView *view)
2929 {
2930         return view->scale * ZOOM_IN_FACTOR <= MAX_SCALE;
2931 }
2932
2933 gboolean
2934 ev_view_can_zoom_out (EvView *view)
2935 {
2936         return view->scale * ZOOM_OUT_FACTOR >= MIN_SCALE;
2937 }
2938
2939 void
2940 ev_view_zoom_in (EvView *view)
2941 {
2942         g_return_if_fail (view->sizing_mode == EV_SIZING_FREE);
2943
2944         view->pending_scroll = SCROLL_TO_CENTER;
2945         ev_view_set_zoom (view, ZOOM_IN_FACTOR, TRUE);
2946 }
2947
2948 void
2949 ev_view_zoom_out (EvView *view)
2950 {
2951         g_return_if_fail (view->sizing_mode == EV_SIZING_FREE);
2952
2953         view->pending_scroll = SCROLL_TO_CENTER;
2954         ev_view_set_zoom (view, ZOOM_OUT_FACTOR, TRUE);
2955 }
2956
2957 void
2958 ev_view_rotate_right (EvView *view)
2959 {
2960         int rotation = view->rotation + 90;
2961
2962         if (rotation >= 360) {
2963                 rotation -= 360;
2964         }
2965
2966         ev_view_set_rotation (view, rotation);
2967 }
2968
2969 void
2970 ev_view_rotate_left (EvView *view)
2971 {
2972         int rotation = view->rotation - 90;
2973
2974         if (rotation < 0) {
2975                 rotation += 360;
2976         }
2977
2978         ev_view_set_rotation (view, rotation);
2979 }
2980
2981 void
2982 ev_view_set_rotation (EvView *view, int rotation)
2983 {
2984         view->rotation = rotation;
2985
2986         if (view->pixbuf_cache) {
2987                 ev_pixbuf_cache_clear (view->pixbuf_cache);
2988                 gtk_widget_queue_resize (GTK_WIDGET (view));
2989         }
2990
2991         if (rotation != 0)
2992                 clear_selection (view);
2993
2994         g_object_notify (G_OBJECT (view), "rotation");
2995 }
2996
2997 int
2998 ev_view_get_rotation (EvView *view)
2999 {
3000         return view->rotation;
3001 }
3002
3003 static double
3004 zoom_for_size_fit_width (int doc_width,
3005                          int doc_height,
3006                          int target_width,
3007                          int target_height,
3008                          int vsb_width)
3009 {
3010         double scale;
3011
3012         scale = (double)target_width / doc_width;
3013
3014         if (doc_height * scale > target_height)
3015                 scale = (double) (target_width - vsb_width) / doc_width;
3016
3017         return scale;
3018 }
3019
3020 static double
3021 zoom_for_size_fit_height (int doc_width,
3022                           int doc_height,
3023                           int target_width,
3024                           int target_height,
3025                           int vsb_height)
3026 {
3027         double scale;
3028
3029         scale = (double)target_height / doc_height;
3030
3031         if (doc_width * scale > target_width)
3032                 scale = (double) (target_height - vsb_height) / doc_height;
3033
3034         return scale;
3035 }
3036
3037 static double
3038 zoom_for_size_best_fit (int doc_width,
3039                         int doc_height,
3040                         int target_width,
3041                         int target_height,
3042                         int vsb_width,
3043                         int hsb_width)
3044 {
3045         double w_scale;
3046         double h_scale;
3047
3048         w_scale = (double)target_width / doc_width;
3049         h_scale = (double)target_height / doc_height;
3050
3051         if (doc_height * w_scale > target_height)
3052                 w_scale = (double) (target_width - vsb_width) / doc_width;
3053         if (doc_width * h_scale > target_width)
3054                 h_scale = (double) (target_height - hsb_width) / doc_height;
3055
3056         return MIN (w_scale, h_scale);
3057 }
3058
3059
3060 static void
3061 ev_view_zoom_for_size_presentation (EvView *view,
3062                                     int     width,
3063                                     int     height)
3064 {
3065         int doc_width, doc_height;
3066         gdouble scale;
3067
3068         ev_page_cache_get_size (view->page_cache,
3069                                 view->current_page,
3070                                 view->rotation,
3071                                 1.0,
3072                                 &doc_width,
3073                                 &doc_height);
3074         scale = zoom_for_size_best_fit (doc_width, doc_height, width, height, 0, 0);
3075         ev_view_set_zoom (view, scale, FALSE);
3076 }
3077
3078 static void
3079 ev_view_zoom_for_size_continuous_and_dual_page (EvView *view,
3080                            int     width,
3081                            int     height,
3082                            int     vsb_width,
3083                            int     hsb_height)
3084 {
3085         int doc_width, doc_height;
3086         GtkBorder border;
3087         gdouble scale;
3088
3089         ev_page_cache_get_max_width (view->page_cache,
3090                                      view->rotation,
3091                                      1.0,
3092                                      &doc_width);
3093         ev_page_cache_get_max_height (view->page_cache,
3094                                       view->rotation,
3095                                       1.0,
3096                                       &doc_height);
3097         compute_border (view, doc_width, doc_height, &border);
3098
3099         doc_width = doc_width * 2;
3100         width -= (2 * (border.left + border.right) + 3 * view->spacing);
3101         height -= (border.top + border.bottom + 2 * view->spacing - 1);
3102
3103         /* FIXME: We really need to calculate the overall height here, not the
3104          * page height.  We assume there's always a vertical scrollbar for
3105          * now.  We need to fix this. */
3106         if (view->sizing_mode == EV_SIZING_FIT_WIDTH)
3107                 scale = zoom_for_size_fit_width (doc_width, doc_height, width - vsb_width, height, 0);
3108         else if (view->sizing_mode == EV_SIZING_BEST_FIT)
3109                 scale = zoom_for_size_best_fit (doc_width, doc_height, width - vsb_width, height, 0, hsb_height);
3110         else
3111                 g_assert_not_reached ();
3112
3113         ev_view_set_zoom (view, scale, FALSE);
3114 }
3115
3116 static void
3117 ev_view_zoom_for_size_continuous (EvView *view,
3118                                   int     width,
3119                                   int     height,
3120                                   int     vsb_width,
3121                                   int     hsb_height)
3122 {
3123         int doc_width, doc_height;
3124         GtkBorder border;
3125         gdouble scale;
3126
3127         ev_page_cache_get_max_width (view->page_cache,
3128                                      view->rotation,
3129                                      1.0,
3130                                      &doc_width);
3131         ev_page_cache_get_max_height (view->page_cache,
3132                                       view->rotation,
3133                                       1.0,
3134                                       &doc_height);
3135         compute_border (view, doc_width, doc_height, &border);
3136
3137         width -= (border.left + border.right + 2 * view->spacing);
3138         height -= (border.top + border.bottom + 2 * view->spacing - 1);
3139
3140         /* FIXME: We really need to calculate the overall height here, not the
3141          * page height.  We assume there's always a vertical scrollbar for
3142          * now.  We need to fix this. */
3143         if (view->sizing_mode == EV_SIZING_FIT_WIDTH)
3144                 scale = zoom_for_size_fit_width (doc_width, doc_height, width - vsb_width, height, 0);
3145         else if (view->sizing_mode == EV_SIZING_BEST_FIT)
3146                 scale = zoom_for_size_best_fit (doc_width, doc_height, width - vsb_width, height, 0, hsb_height);
3147         else
3148                 g_assert_not_reached ();
3149
3150         ev_view_set_zoom (view, scale, FALSE);
3151 }
3152
3153 static void
3154 ev_view_zoom_for_size_dual_page (EvView *view,
3155                                  int     width,
3156                                  int     height,
3157                                  int     vsb_width,
3158                                  int     hsb_height)
3159 {
3160         GtkBorder border;
3161         gint doc_width, doc_height;
3162         gdouble scale;
3163         gint other_page;
3164
3165         other_page = view->current_page ^ 1;
3166
3167         /* Find the largest of the two. */
3168         ev_page_cache_get_size (view->page_cache,
3169                                 view->current_page,
3170                                 view->rotation,
3171                                 1.0,
3172                                 &doc_width, &doc_height);
3173
3174         if (other_page < ev_page_cache_get_n_pages (view->page_cache)) {
3175                 gint width_2, height_2;
3176                 ev_page_cache_get_size (view->page_cache,
3177                                         other_page,
3178                                         view->rotation,
3179                                         1.0,
3180                                         &width_2, &height_2);
3181                 if (width_2 > doc_width)
3182                         doc_width = width_2;
3183                 if (height_2 > doc_height)
3184                         doc_height = height_2;
3185         }
3186         compute_border (view, doc_width, doc_height, &border);
3187
3188         doc_width = doc_width * 2;
3189         width -= ((border.left + border.right)* 2 + 3 * view->spacing);
3190         height -= (border.top + border.bottom + 2 * view->spacing);
3191
3192         if (view->sizing_mode == EV_SIZING_FIT_WIDTH)
3193                 scale = zoom_for_size_fit_width (doc_width, doc_height, width, height, vsb_width);
3194         else if (view->sizing_mode == EV_SIZING_BEST_FIT)
3195                 scale = zoom_for_size_best_fit (doc_width, doc_height, width, height, vsb_width, hsb_height);
3196         else
3197                 g_assert_not_reached ();
3198
3199         ev_view_set_zoom (view, scale, FALSE);
3200 }
3201
3202 static void
3203 ev_view_zoom_for_size_single_page (EvView *view,
3204                                    int     width,
3205                                    int     height,
3206                                    int     vsb_width,
3207                                    int     hsb_height)
3208 {
3209         int doc_width, doc_height;
3210         GtkBorder border;
3211         gdouble scale;
3212
3213         ev_page_cache_get_size (view->page_cache,
3214                                 view->current_page,
3215                                 view->rotation,
3216                                 1.0,
3217                                 &doc_width,
3218                                 &doc_height);
3219         /* Get an approximate border */
3220         compute_border (view, width, height, &border);
3221
3222         width -= (border.left + border.right + 2 * view->spacing);
3223         height -= (border.top + border.bottom + 2 * view->spacing);
3224
3225         if (view->sizing_mode == EV_SIZING_FIT_WIDTH)
3226                 scale = zoom_for_size_fit_width (doc_width, doc_height, width, height, vsb_width);
3227         else if (view->sizing_mode == EV_SIZING_BEST_FIT)
3228                 scale = zoom_for_size_best_fit (doc_width, doc_height, width, height, vsb_width, hsb_height);
3229         else
3230                 g_assert_not_reached ();
3231
3232         ev_view_set_zoom (view, scale, FALSE);
3233 }
3234
3235 void
3236 ev_view_set_zoom_for_size (EvView *view,
3237                            int     width,
3238                            int     height,
3239                            int     vsb_width,
3240                            int     hsb_height)
3241 {
3242         g_return_if_fail (view->sizing_mode == EV_SIZING_FIT_WIDTH ||
3243                           view->sizing_mode == EV_SIZING_BEST_FIT);
3244         g_return_if_fail (width >= 0);
3245         g_return_if_fail (height >= 0);
3246
3247         if (view->document == NULL)
3248                 return;
3249
3250         if (view->presentation)
3251                 ev_view_zoom_for_size_presentation (view, width, height);
3252         else if (view->continuous && view->dual_page)
3253                 ev_view_zoom_for_size_continuous_and_dual_page (view, width, height, vsb_width, hsb_height);
3254         else if (view->continuous)
3255                 ev_view_zoom_for_size_continuous (view, width, height, vsb_width, hsb_height);
3256         else if (view->dual_page)
3257                 ev_view_zoom_for_size_dual_page (view, width, height, vsb_width, hsb_height);
3258         else
3259                 ev_view_zoom_for_size_single_page (view, width, height, vsb_width, hsb_height);
3260 }
3261
3262 /*** Status text messages ***/
3263
3264 const char *
3265 ev_view_get_status (EvView *view)
3266 {
3267         g_return_val_if_fail (EV_IS_VIEW (view), NULL);
3268
3269         return view->status;
3270 }
3271
3272 static void
3273 ev_view_set_status (EvView *view, const char *message)
3274 {
3275         g_return_if_fail (EV_IS_VIEW (view));
3276
3277         if (message != view->status) {
3278                 g_free (view->status);
3279                 view->status = g_strdup (message);
3280                 g_object_notify (G_OBJECT (view), "status");
3281         }
3282 }
3283
3284 static void
3285 update_find_status_message (EvView *view, gboolean this_page)
3286 {
3287         char *message;
3288
3289         if (this_page) {
3290                 int results;
3291
3292                 results = ev_document_find_get_n_results
3293                                 (EV_DOCUMENT_FIND (view->document),
3294                                  view->current_page);
3295                 /* TRANS: Sometimes this could be better translated as
3296                    "%d hit(s) on this page".  Therefore this string
3297                    contains plural cases. */
3298                 message = g_strdup_printf (ngettext ("%d found on this page",
3299                                                      "%d found on this page",
3300                                                      results),
3301                                            results);
3302         } else {
3303                 double percent;
3304
3305                 percent = ev_document_find_get_progress
3306                                 (EV_DOCUMENT_FIND (view->document));
3307                 message = g_strdup_printf (_("%3d%% remaining to search"),
3308                                            (int) ((1.0 - percent) * 100));
3309
3310         }
3311         ev_view_set_find_status (view, message);
3312         g_free (message);
3313 }
3314
3315 const char *
3316 ev_view_get_find_status (EvView *view)
3317 {
3318         g_return_val_if_fail (EV_IS_VIEW (view), NULL);
3319
3320         return view->find_status;
3321 }
3322
3323 static void
3324 ev_view_set_find_status (EvView *view, const char *message)
3325 {
3326         g_return_if_fail (EV_IS_VIEW (view));
3327
3328         g_free (view->find_status);
3329         view->find_status = g_strdup (message);
3330         g_object_notify (G_OBJECT (view), "find-status");
3331 }
3332
3333 /*** Find ***/
3334
3335 static void
3336 jump_to_find_result (EvView *view)
3337 {
3338         EvDocumentFind *find = EV_DOCUMENT_FIND (view->document);
3339         EvRectangle rect;
3340         GdkRectangle view_rect;
3341         int n_results;
3342         int page = view->current_page;
3343
3344         n_results = ev_document_find_get_n_results (find, page);
3345
3346         if (n_results > 0  && view->find_result < n_results) {
3347                 ev_document_find_get_result
3348                         (find, page, view->find_result, &rect);
3349
3350                 doc_rect_to_view_rect (view, page, &rect, &view_rect);
3351                 ensure_rectangle_is_visible (view, &view_rect);
3352         }
3353 }
3354
3355 /**
3356  * jump_to_find_page
3357  * @view: #EvView instance
3358  * @direction: Direction to look
3359  * @shift: Shift from current page
3360  *
3361  * Jumps to the first page that has occurences of searched word.
3362  * Uses a direction where to look and a shift from current page.
3363  *
3364  */
3365 static void
3366 jump_to_find_page (EvView *view, EvViewFindDirection direction, gint shift)
3367 {
3368         int n_pages, i;
3369
3370         n_pages = ev_page_cache_get_n_pages (view->page_cache);
3371
3372         for (i = 0; i < n_pages; i++) {
3373                 int has_results;
3374                 int page;
3375
3376                 if (direction == EV_VIEW_FIND_NEXT)
3377                         page = view->current_page + i;
3378                 else
3379                         page = view->current_page - i;
3380                 page += shift;
3381
3382                 if (page >= n_pages) {
3383                         page = page - n_pages;
3384                 }
3385                 if (page < 0)
3386                         page = page + n_pages;
3387
3388                 has_results = ev_document_find_page_has_results
3389                                 (EV_DOCUMENT_FIND (view->document), page);
3390                 if (has_results == -1) {
3391                         break;
3392                 } else if (has_results == 1) {
3393                         ev_page_cache_set_current_page (view->page_cache, page);
3394                         break;
3395                 }
3396         }
3397 }
3398
3399 gboolean
3400 ev_view_can_find_next (EvView *view)
3401 {
3402         if (EV_IS_DOCUMENT_FIND (view->document)) {
3403                 EvDocumentFind *find = EV_DOCUMENT_FIND (view->document);
3404                 int i, n_pages;
3405
3406                 n_pages = ev_page_cache_get_n_pages (view->page_cache);
3407                 for (i = 0; i < n_pages; i++) {
3408                         if (ev_document_find_get_n_results (find, i) > 0) {
3409                                 return TRUE;
3410                         }
3411                 }
3412         }
3413
3414         return FALSE;
3415 }
3416
3417 void
3418 ev_view_find_next (EvView *view)
3419 {
3420         int n_results, n_pages;
3421         EvDocumentFind *find = EV_DOCUMENT_FIND (view->document);
3422
3423         n_results = ev_document_find_get_n_results (find, view->current_page);
3424
3425         n_pages = ev_page_cache_get_n_pages (view->page_cache);
3426
3427         view->find_result++;
3428
3429         if (view->find_result >= n_results) {
3430
3431                 view->find_result = 0;
3432                 jump_to_find_page (view, EV_VIEW_FIND_NEXT, 1);
3433                 jump_to_find_result (view);
3434         } else {
3435                 jump_to_find_result (view);
3436                 gtk_widget_queue_draw (GTK_WIDGET (view));
3437         }
3438 }
3439
3440 gboolean
3441 ev_view_can_find_previous (EvView *view)
3442 {
3443         if (EV_IS_DOCUMENT_FIND (view->document)) {
3444                 EvDocumentFind *find = EV_DOCUMENT_FIND (view->document);
3445                 int i, n_pages;
3446
3447                 n_pages = ev_page_cache_get_n_pages (view->page_cache);
3448                 for (i = n_pages - 1; i >= 0; i--) {
3449                         if (ev_document_find_get_n_results (find, i) > 0) {
3450                                 return TRUE;
3451                         }
3452                 }
3453         }
3454
3455         return FALSE;
3456 }
3457 void
3458 ev_view_find_previous (EvView *view)
3459 {
3460         int n_results, n_pages;
3461         EvDocumentFind *find = EV_DOCUMENT_FIND (view->document);
3462         EvPageCache *page_cache;
3463
3464         page_cache = ev_page_cache_get (view->document);
3465
3466         n_results = ev_document_find_get_n_results (find, view->current_page);
3467
3468         n_pages = ev_page_cache_get_n_pages (page_cache);
3469
3470         view->find_result--;
3471
3472         if (view->find_result < 0) {
3473
3474                 jump_to_find_page (view, EV_VIEW_FIND_PREV, -1);
3475                 view->find_result = ev_document_find_get_n_results (find, view->current_page) - 1;
3476                 jump_to_find_result (view);
3477         } else {
3478                 jump_to_find_result (view);
3479                 gtk_widget_queue_draw (GTK_WIDGET (view));
3480         }
3481 }
3482
3483 void ev_view_search_changed (EvView *view)
3484 {
3485         /* search string has changed, focus on new search result */
3486         view->jump_to_find_result = TRUE;
3487 }
3488
3489 /*** Selections ***/
3490
3491 /* compute_new_selection_rect/text calculates the area currently selected by
3492  * view_rect.  each handles a different mode;
3493  */
3494 static GList *
3495 compute_new_selection_rect (EvView       *view,
3496                             GdkPoint     *start,
3497                             GdkPoint     *stop)
3498 {
3499         GdkRectangle view_rect;
3500         int n_pages, i;
3501         GList *list = NULL;
3502
3503         g_assert (view->selection_mode == EV_VIEW_SELECTION_RECTANGLE);
3504
3505         view_rect.x = MIN (start->x, stop->x);
3506         view_rect.y = MIN (start->y, stop->y);
3507         view_rect.width = MAX (start->x, stop->x) - view_rect.x;
3508         view_rect.width = MAX (start->y, stop->y) - view_rect.y;
3509
3510         n_pages = ev_page_cache_get_n_pages (view->page_cache);
3511
3512         for (i = 0; i < n_pages; i++) {
3513                 GdkRectangle page_area;
3514                 GtkBorder border;
3515
3516                 if (get_page_extents (view, i, &page_area, &border)) {
3517                         GdkRectangle overlap;
3518
3519                         if (gdk_rectangle_intersect (&page_area, &view_rect, &overlap)) {
3520                                 EvViewSelection *selection;
3521
3522                                 selection = g_new0 (EvViewSelection, 1);
3523                                 selection->page = i;
3524                                 view_rect_to_doc_rect (view, &overlap, &page_area,
3525                                                        &(selection->rect));
3526
3527                                 list = g_list_append (list, selection);
3528                         }
3529                 }
3530         }
3531
3532         return list;
3533 }
3534
3535 static gboolean
3536 gdk_rectangle_point_in (GdkRectangle *rectangle,
3537                         GdkPoint     *point)
3538 {
3539         return rectangle->x <= point->x &&
3540                 rectangle->y <= point->y &&
3541                 point->x < rectangle->x + rectangle->width &&
3542                 point->y < rectangle->y + rectangle->height;
3543 }
3544
3545 static GList *
3546 compute_new_selection_text (EvView   *view,
3547                             GdkPoint *start,
3548                             GdkPoint *stop)
3549 {
3550         int n_pages, i, first, last;
3551         GList *list = NULL;
3552         EvViewSelection *selection;
3553         gint width, height;
3554         int start_page, end_page;
3555
3556         g_assert (view->selection_mode == EV_VIEW_SELECTION_TEXT);
3557
3558         n_pages = ev_page_cache_get_n_pages (view->page_cache);
3559
3560         /* First figure out the range of pages the selection
3561          * affects. */
3562         first = n_pages;
3563         last = 0;
3564         if (view->continuous) {
3565                 start_page = 0;
3566                 end_page = n_pages;
3567         } else if (view->dual_page) {
3568                 start_page = view->start_page;
3569                 end_page = view->end_page + 1;
3570         } else {
3571                 start_page = view->current_page;
3572                 end_page = view->current_page + 1;
3573         }
3574
3575         for (i = start_page; i < end_page; i++) {
3576                 GdkRectangle page_area;
3577                 GtkBorder border;
3578
3579                 get_page_extents (view, i, &page_area, &border);
3580                 if (gdk_rectangle_point_in (&page_area, start) ||
3581                     gdk_rectangle_point_in (&page_area, stop)) {
3582                         if (first == n_pages)
3583                                 first = i;
3584                         last = i;
3585                 }
3586
3587         }
3588
3589
3590
3591         /* Now create a list of EvViewSelection's for the affected
3592          * pages.  This could be an empty list, a list of just one
3593          * page or a number of pages.*/
3594         for (i = first; i < last + 1; i++) {
3595                 GdkRectangle page_area;
3596                 GtkBorder border;
3597                 GdkPoint *point;
3598
3599                 ev_page_cache_get_size (view->page_cache, i,
3600                                         view->rotation,
3601                                         1.0, &width, &height);
3602
3603                 selection = g_new0 (EvViewSelection, 1);
3604                 selection->page = i;
3605                 selection->rect.x1 = selection->rect.y1 = 0;
3606                 selection->rect.x2 = width;
3607                 selection->rect.y2 = height;
3608
3609                 get_page_extents (view, i, &page_area, &border);
3610
3611                 if (gdk_rectangle_point_in (&page_area, start))
3612                         point = start;
3613                 else
3614                         point = stop;
3615
3616                 if (i == first)
3617                         view_point_to_doc_point (view, point, &page_area,
3618                                                  &selection->rect.x1,
3619                                                  &selection->rect.y1);
3620
3621                 /* If the selection is contained within just one page,
3622                  * make sure we don't write 'start' into both points
3623                  * in selection->rect. */
3624                 if (first == last)
3625                         point = stop;
3626
3627                 if (i == last)
3628                         view_point_to_doc_point (view, point, &page_area,
3629                                                  &selection->rect.x2,
3630                                                  &selection->rect.y2);
3631
3632                 list = g_list_append (list, selection);
3633         }
3634
3635         return list;
3636 }
3637
3638 /* This function takes the newly calculated list, and figures out which regions
3639  * have changed.  It then queues a redraw approporiately.
3640  */
3641 static void
3642 merge_selection_region (EvView *view,
3643                         GList  *new_list)
3644 {
3645         GList *old_list;
3646         GList *new_list_ptr, *old_list_ptr;
3647
3648         /* Update the selection */
3649         old_list = ev_pixbuf_cache_get_selection_list (view->pixbuf_cache);
3650         g_list_foreach (view->selection_info.selections, (GFunc)selection_free, NULL);
3651         view->selection_info.selections = new_list;
3652         ev_pixbuf_cache_set_selection_list (view->pixbuf_cache, new_list);
3653         g_object_notify (G_OBJECT (view), "has-selection");
3654
3655         new_list_ptr = new_list;
3656         old_list_ptr = old_list;
3657
3658         while (new_list_ptr || old_list_ptr) {
3659                 EvViewSelection *old_sel, *new_sel;
3660                 int cur_page;
3661                 GdkRegion *region = NULL;
3662
3663                 new_sel = (new_list_ptr) ? (new_list_ptr->data) : NULL;
3664                 old_sel = (old_list_ptr) ? (old_list_ptr->data) : NULL;
3665
3666                 /* Assume that the lists are in order, and we run through them
3667                  * comparing them, one page at a time.  We come out with the
3668                  * first page we see. */
3669                 if (new_sel && old_sel) {
3670                         if (new_sel->page < old_sel->page) {
3671                                 new_list_ptr = new_list_ptr->next;
3672                                 old_sel = NULL;
3673                         } else if (new_sel->page > old_sel->page) {
3674                                 old_list_ptr = old_list_ptr->next;
3675                                 new_sel = NULL;
3676                         } else {
3677                                 new_list_ptr = new_list_ptr->next;
3678                                 old_list_ptr = old_list_ptr->next;
3679                         }
3680                 } else if (new_sel) {
3681                         new_list_ptr = new_list_ptr->next;
3682                 } else if (old_sel) {
3683                         old_list_ptr = old_list_ptr->next;
3684                 }
3685
3686                 g_assert (new_sel || old_sel);
3687
3688                 /* is the page we're looking at on the screen?*/
3689                 cur_page = new_sel ? new_sel->page : old_sel->page;
3690                 if (cur_page < view->start_page || cur_page > view->end_page)
3691                         continue;
3692
3693                 /* seed the cache with a new page.  We are going to need the new
3694                  * region too. */
3695                 if (new_sel) {
3696                         GdkRegion *tmp_region = NULL;
3697                         ev_pixbuf_cache_get_selection_pixbuf (view->pixbuf_cache,
3698                                                               cur_page,
3699                                                               view->scale,
3700                                                               &tmp_region);
3701                         if (tmp_region) {
3702                                 new_sel->covered_region = gdk_region_copy (tmp_region);
3703                         }
3704                 }
3705
3706                 /* Now we figure out what needs redrawing */
3707                 if (old_sel && new_sel) {
3708                         if (old_sel->covered_region &&
3709                             new_sel->covered_region) {
3710                                 /* We only want to redraw the areas that have
3711                                  * changed, so we xor the old and new regions
3712                                  * and redraw if it's different */
3713                                 region = gdk_region_copy (old_sel->covered_region);
3714                                 gdk_region_xor (region, new_sel->covered_region);
3715                                 if (gdk_region_empty (region)) {
3716                                         gdk_region_destroy (region);
3717                                         region = NULL;
3718                                 }
3719                         } else if (old_sel->covered_region) {
3720                                 region = gdk_region_copy (old_sel->covered_region);
3721                         } else if (new_sel->covered_region) {
3722                                 region = gdk_region_copy (new_sel->covered_region);
3723                         }
3724                 } else if (old_sel && !new_sel) {
3725                         if (old_sel->covered_region && !gdk_region_empty (old_sel->covered_region)) {
3726                                 region = gdk_region_copy (old_sel->covered_region);
3727                         }
3728                 } else if (!old_sel && new_sel) {
3729                         if (new_sel->covered_region && !gdk_region_empty (new_sel->covered_region)) {
3730                                 region = gdk_region_copy (new_sel->covered_region);
3731                         }
3732                 } else {
3733                         g_assert_not_reached ();
3734                 }
3735
3736                 /* Redraw the damaged region! */
3737                 if (region) {
3738                         GdkRectangle page_area;
3739                         GtkBorder border;
3740
3741                         get_page_extents (view, cur_page, &page_area, &border);
3742                         gdk_region_offset (region,
3743                                            page_area.x + border.left - view->scroll_x,
3744                                            page_area.y + border.top - view->scroll_y);
3745                         gdk_window_invalidate_region (GTK_WIDGET (view)->window, region, TRUE);
3746                         gdk_region_destroy (region);
3747                 }
3748         }
3749
3750         /* Free the old list, now that we're done with it. */
3751         g_list_foreach (old_list, (GFunc) selection_free, NULL);
3752 }
3753
3754 static void
3755 compute_selections (EvView   *view,
3756                     GdkPoint *start,
3757                     GdkPoint *stop)
3758 {
3759         GList *list;
3760
3761         if (view->selection_mode == EV_VIEW_SELECTION_RECTANGLE)
3762                 list = compute_new_selection_rect (view, start, stop);
3763         else
3764                 list = compute_new_selection_text (view, start, stop);
3765         merge_selection_region (view, list);
3766 }
3767
3768 /* Free's the selection.  It's up to the caller to queue redraws if needed.
3769  */
3770 static void
3771 selection_free (EvViewSelection *selection)
3772 {
3773         if (selection->covered_region)
3774                 gdk_region_destroy (selection->covered_region);
3775         g_free (selection);
3776 }
3777
3778 static void
3779 clear_selection (EvView *view)
3780 {
3781         g_list_foreach (view->selection_info.selections, (GFunc)selection_free, NULL);
3782         view->selection_info.selections = NULL;
3783         view->selection_info.in_selection = FALSE;
3784         g_object_notify (G_OBJECT (view), "has-selection");
3785 }
3786
3787
3788 void
3789 ev_view_select_all (EvView *view)
3790 {
3791         int n_pages, i;
3792
3793         /* Disable selection on rotated pages for the 0.4.0 series */
3794         if (view->rotation != 0)
3795                 return;
3796
3797         clear_selection (view);
3798
3799         n_pages = ev_page_cache_get_n_pages (view->page_cache);
3800         for (i = 0; i < n_pages; i++) {
3801                 int width, height;
3802                 EvViewSelection *selection;
3803
3804                 ev_page_cache_get_size (view->page_cache,
3805                                         i,
3806                                         view->rotation,
3807                                         1.0, &width, &height);
3808
3809                 selection = g_new0 (EvViewSelection, 1);
3810                 selection->page = i;
3811                 selection->rect.x1 = selection->rect.y1 = 0;
3812                 selection->rect.x2 = width;
3813                 selection->rect.y2 = height;
3814
3815                 view->selection_info.selections = g_list_append (view->selection_info.selections, selection);
3816         }
3817
3818         ev_pixbuf_cache_set_selection_list (view->pixbuf_cache, view->selection_info.selections);
3819         g_object_notify (G_OBJECT (view), "has-selection");
3820         gtk_widget_queue_draw (GTK_WIDGET (view));
3821 }
3822
3823 gboolean
3824 ev_view_get_has_selection (EvView *view)
3825 {
3826         return view->selection_info.selections != NULL;
3827 }
3828
3829 static char *
3830 get_selected_text (EvView *ev_view)
3831 {
3832         GString *text;
3833         GList *l;
3834
3835         text = g_string_new (NULL);
3836
3837         ev_document_doc_mutex_lock ();
3838
3839         for (l = ev_view->selection_info.selections; l != NULL; l = l->next) {
3840                 EvViewSelection *selection = (EvViewSelection *)l->data;
3841                 char *tmp;
3842
3843                 tmp = ev_document_get_text (ev_view->document,
3844                                             selection->page,
3845                                             &selection->rect);
3846                 g_string_append (text, tmp);
3847                 g_free (tmp);
3848         }
3849
3850         ev_document_doc_mutex_unlock ();
3851
3852         return g_string_free (text, FALSE);
3853 }
3854
3855 void
3856 ev_view_copy (EvView *ev_view)
3857 {
3858         GtkClipboard *clipboard;
3859         char *text;
3860
3861         if (!ev_document_can_get_text (ev_view->document)) {
3862                 return;
3863         }
3864
3865         text = get_selected_text (ev_view);
3866         clipboard = gtk_widget_get_clipboard (GTK_WIDGET (ev_view),
3867                                               GDK_SELECTION_CLIPBOARD);
3868         gtk_clipboard_set_text (clipboard, text, -1);
3869         g_free (text);
3870 }
3871
3872 static void
3873 ev_view_primary_get_cb (GtkClipboard     *clipboard,
3874                         GtkSelectionData *selection_data,
3875                         guint             info,
3876                         gpointer          data)
3877 {
3878         EvView *ev_view = EV_VIEW (data);
3879         char *text;
3880
3881         if (!ev_document_can_get_text (ev_view->document)) {
3882                 return;
3883         }
3884
3885         text = get_selected_text (ev_view);
3886         gtk_selection_data_set_text (selection_data, text, -1);
3887         g_free (text);
3888 }
3889
3890 static void
3891 ev_view_primary_clear_cb (GtkClipboard *clipboard,
3892                           gpointer      data)
3893 {
3894         EvView *view = EV_VIEW (data);
3895
3896         clear_selection (view);
3897 }
3898
3899 static void
3900 ev_view_update_primary_selection (EvView *ev_view)
3901 {
3902         GtkClipboard *clipboard;
3903
3904         clipboard = gtk_widget_get_clipboard (GTK_WIDGET (ev_view),
3905                                               GDK_SELECTION_PRIMARY);
3906
3907         if (ev_view->selection_info.selections) {
3908                 if (!gtk_clipboard_set_with_owner (clipboard,
3909                                                    targets,
3910                                                    G_N_ELEMENTS (targets),
3911                                                    ev_view_primary_get_cb,
3912                                                    ev_view_primary_clear_cb,
3913                                                    G_OBJECT (ev_view)))
3914                         ev_view_primary_clear_cb (clipboard, ev_view);
3915         } else {
3916                 if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (ev_view))
3917                         gtk_clipboard_clear (clipboard);
3918         }
3919 }
3920
3921 /*** Cursor operations ***/
3922
3923 static GdkCursor *
3924 ev_view_create_invisible_cursor(void)
3925 {
3926        GdkBitmap *empty;
3927        GdkColor black = { 0, 0, 0, 0 };
3928        static char bits[] = { 0x00 };
3929
3930        empty = gdk_bitmap_create_from_data (NULL, bits, 1, 1);
3931
3932        return gdk_cursor_new_from_pixmap (empty, empty, &black, &black, 0, 0);
3933 }
3934
3935 static void
3936 ev_view_set_cursor (EvView *view, EvViewCursor new_cursor)
3937 {
3938         GdkCursor *cursor = NULL;
3939         GdkDisplay *display;
3940         GtkWidget *widget;
3941
3942         if (view->cursor == new_cursor) {
3943                 return;
3944         }
3945
3946         widget = gtk_widget_get_toplevel (GTK_WIDGET (view));
3947         display = gtk_widget_get_display (widget);
3948         view->cursor = new_cursor;
3949
3950         switch (new_cursor) {
3951                 case EV_VIEW_CURSOR_NORMAL:
3952                         gdk_window_set_cursor (widget->window, NULL);
3953                         break;
3954                 case EV_VIEW_CURSOR_IBEAM:
3955                         cursor = gdk_cursor_new_for_display (display, GDK_XTERM);
3956                         break;
3957                 case EV_VIEW_CURSOR_LINK:
3958                         cursor = gdk_cursor_new_for_display (display, GDK_HAND2);
3959                         break;
3960                 case EV_VIEW_CURSOR_WAIT:
3961                         cursor = gdk_cursor_new_for_display (display, GDK_WATCH);
3962                         break;
3963                 case EV_VIEW_CURSOR_HIDDEN:
3964                         cursor = ev_view_create_invisible_cursor ();
3965                         break;
3966                 case EV_VIEW_CURSOR_DRAG:
3967                         cursor = gdk_cursor_new_for_display (display, GDK_FLEUR);
3968                         break;
3969         }
3970
3971         if (cursor) {
3972                 gdk_window_set_cursor (widget->window, cursor);
3973                 gdk_cursor_unref (cursor);
3974                 gdk_flush();
3975         }
3976 }
3977
3978 void
3979 ev_view_hide_cursor (EvView *view)
3980 {
3981        ev_view_set_cursor (view, EV_VIEW_CURSOR_HIDDEN);
3982 }
3983
3984 void
3985 ev_view_show_cursor (EvView *view)
3986 {
3987        ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
3988 }
3989
3990 gboolean
3991 ev_view_next_page (EvView *view)
3992 {
3993         int page;
3994
3995         g_return_val_if_fail (EV_IS_VIEW (view), FALSE);
3996
3997         page = ev_page_cache_get_current_page (view->page_cache);
3998
3999         if (view->dual_page && !view->presentation)
4000                 page = page + 2;
4001         else
4002                 page = page + 1;
4003
4004         if (page < ev_page_cache_get_n_pages (view->page_cache)) {
4005                 ev_page_cache_set_current_page (view->page_cache, page);
4006                 return TRUE;
4007         } else if (ev_view_get_dual_page (view) && page == ev_page_cache_get_n_pages (view->page_cache)) {
4008                 ev_page_cache_set_current_page (view->page_cache, page - 1);
4009                 return TRUE;
4010         } else {
4011                 return FALSE;
4012         }
4013 }
4014
4015 gboolean
4016 ev_view_previous_page (EvView *view)
4017 {
4018         int page;
4019
4020         g_return_val_if_fail (EV_IS_VIEW (view), FALSE);
4021
4022         page = ev_page_cache_get_current_page (view->page_cache);
4023
4024         if (view->dual_page && !view->presentation)
4025                 page = page - 2;
4026         else
4027                 page = page - 1;
4028
4029         if (page >= 0) {
4030                 ev_page_cache_set_current_page (view->page_cache, page);
4031                 return TRUE;
4032         } else if (ev_view_get_dual_page (view) && page == -1) {
4033                 ev_page_cache_set_current_page (view->page_cache, 0);
4034                 return TRUE;
4035         } else {
4036                 return FALSE;
4037         }
4038 }
4039
4040 /*** Enum description for usage in signal ***/
4041
4042 GType
4043 ev_sizing_mode_get_type (void)
4044 {
4045   static GType etype = 0;
4046   if (etype == 0) {
4047     static const GEnumValue values[] = {
4048       { EV_SIZING_FIT_WIDTH, "EV_SIZING_FIT_WIDTH", "fit-width" },
4049       { EV_SIZING_BEST_FIT, "EV_SIZING_BEST_FIT", "best-fit" },
4050       { EV_SIZING_FREE, "EV_SIZING_FREE", "free" },
4051       { 0, NULL, NULL }
4052     };
4053     etype = g_enum_register_static ("EvSizingMode", values);
4054   }
4055   return etype;
4056 }
4057
4058 GType
4059 ev_scroll_type_get_type (void)
4060 {
4061   static GType etype = 0;
4062   if (etype == 0) {
4063     static const GEnumValue values[] = {
4064       { EV_SCROLL_PAGE_FORWARD, "EV_SCROLL_PAGE_FORWARD", "scroll-page-forward" },
4065       { EV_SCROLL_PAGE_BACKWARD, "EV_SCROLL_PAGE_BACKWARD", "scroll-page-backward" },
4066       { EV_SCROLL_STEP_FORWARD, "EV_SCROLL_STEP_FORWARD", "scroll-step-forward" },
4067       { EV_SCROLL_STEP_FORWARD, "EV_SCROLL_STEP_FORWARD", "scroll-step-forward" },
4068       { EV_SCROLL_STEP_UP, "EV_SCROLL_STEP_UP", "scroll-step-up" },
4069       { EV_SCROLL_STEP_DOWN, "EV_SCROLL_STEP_DOWN", "scroll-step-down" },
4070       { 0, NULL, NULL }
4071     };
4072     etype = g_enum_register_static ("EvScrollType", values);
4073   }
4074   return etype;
4075 }