libview/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 "config.h"
  22
  23 #include <stdlib.h>
  24 #include <math.h>
  25 #include <string.h>
  26
  27 #include <glib/gi18n-lib.h>
  28 #include <gtk/gtk.h>
  29 #include <gdk/gdkkeysyms.h>
  30
  31 #include "ev-mapping.h"
  32 #include "ev-document-forms.h"
  33 #include "ev-document-images.h"
  34 #include "ev-document-links.h"
  35 #include "ev-document-misc.h"
  36 #include "ev-pixbuf-cache.h"
  37 #include "ev-page-cache.h"
  38 #include "ev-view-marshal.h"
  39 #include "ev-document-annotations.h"
  40 #include "ev-annotation-window.h"
  41 #include "ev-view.h"
  42 #include "ev-view-accessible.h"
  43 #include "ev-view-private.h"
  44 #include "ev-view-type-builtins.h"
  45
  46 #define EV_VIEW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), EV_TYPE_VIEW, EvViewClass))
  47 #define EV_IS_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EV_TYPE_VIEW))
  48 #define EV_VIEW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), EV_TYPE_VIEW, EvViewClass))
  49
  50 enum {
  51         PROP_0,
  52         PROP_HAS_SELECTION
  53 };
  54
  55 enum {
  56         SIGNAL_BINDING_ACTIVATED,
  57         SIGNAL_HANDLE_LINK,
  58         SIGNAL_EXTERNAL_LINK,
  59         SIGNAL_POPUP_MENU,
  60         N_SIGNALS,
  61 };
  62
  63 enum {
  64         TARGET_DND_URI,
  65         TARGET_DND_TEXT,
  66         TARGET_DND_IMAGE
  67 };
  68
  69 static guint signals[N_SIGNALS];
  70
  71 typedef enum {
  72         EV_VIEW_FIND_NEXT,
  73         EV_VIEW_FIND_PREV
  74 } EvViewFindDirection;
  75
  76 #define ZOOM_IN_FACTOR  1.2
  77 #define ZOOM_OUT_FACTOR (1.0/ZOOM_IN_FACTOR)
  78
  79 #define SCROLL_TIME 150
  80
  81 /*** Scrolling ***/
  82 static void       ev_view_set_scroll_adjustments             (GtkLayout          *layout,
  83                                                               GtkAdjustment      *hadjustment,
  84                                                               GtkAdjustment      *vadjustment);
  85 static void       view_update_range_and_current_page         (EvView             *view);
  86 static void       set_scroll_adjustment                      (EvView             *view,
  87                                                               GtkOrientation      orientation,
  88                                                               GtkAdjustment      *adjustment);
  89 static void       add_scroll_binding_keypad                  (GtkBindingSet      *binding_set,
  90                                                               guint               keyval,
  91                                                               GdkModifierType modifiers,
  92                                                               GtkScrollType       scroll,
  93                                                               gboolean            horizontal);
  94 static void       ensure_rectangle_is_visible                (EvView             *view,
  95                                                               GdkRectangle       *rect);
  96
  97 /*** Geometry computations ***/
  98 static void       compute_border                             (EvView             *view,
  99                                                               int                 width,
 100                                                               int                 height,
 101                                                               GtkBorder          *border);
 102 static void       get_page_y_offset                          (EvView             *view,
 103                                                               int                 page,
 104                                                               int                *y_offset);
 105 static gboolean   get_page_extents                           (EvView             *view,
 106                                                               gint                page,
 107                                                               GdkRectangle       *page_area,
 108                                                               GtkBorder          *border);
 109 static void       view_rect_to_doc_rect                      (EvView             *view,
 110                                                               GdkRectangle       *view_rect,
 111                                                               GdkRectangle       *page_area,
 112                                                               EvRectangle        *doc_rect);
 113 static void       doc_rect_to_view_rect                      (EvView             *view,
 114                                                               int                 page,
 115                                                               EvRectangle        *doc_rect,
 116                                                               GdkRectangle       *view_rect);
 117 static gboolean   get_dual_even_left                         (EvView             *view);
 118 static void       find_page_at_location                      (EvView             *view,
 119                                                               gdouble             x,
 120                                                               gdouble             y,
 121                                                               gint               *page,
 122                                                               gint               *x_offset,
 123                                                               gint               *y_offset);
 124 static void       doc_point_to_view_point                    (EvView             *view,
 125                                                               int                 page,
 126                                                               EvPoint            *doc_point,
 127                                                               GdkPoint           *view_point);
 128 /*** Hyperrefs ***/
 129 static EvLink *   ev_view_get_link_at_location               (EvView             *view,
 130                                                               gdouble             x,
 131                                                               gdouble             y);
 132 static char*      tip_from_link                              (EvView             *view,
 133                                                               EvLink             *link);
 134 /*** Forms ***/
 135 static EvFormField *ev_view_get_form_field_at_location       (EvView             *view,
 136                                                                gdouble            x,
 137                                                                gdouble            y);
 138
 139 /*** Annotations ***/
 140 static EvAnnotation *ev_view_get_annotation_at_location      (EvView             *view,
 141                                                               gdouble             x,
 142                                                               gdouble             y);
 143 static void          show_annotation_windows                 (EvView             *view,
 144                                                               gint                page);
 145 static void          hide_annotation_windows                 (EvView             *view,
 146                                                               gint                page);
 147 /*** GtkWidget implementation ***/
 148 static void       ev_view_size_request_continuous_dual_page  (EvView             *view,
 149                                                               GtkRequisition     *requisition);
 150 static void       ev_view_size_request_continuous            (EvView             *view,
 151                                                               GtkRequisition     *requisition);
 152 static void       ev_view_size_request_dual_page             (EvView             *view,
 153                                                               GtkRequisition     *requisition);
 154 static void       ev_view_size_request_single_page           (EvView             *view,
 155                                                               GtkRequisition     *requisition);
 156 static void       ev_view_size_request                       (GtkWidget          *widget,
 157                                                               GtkRequisition     *requisition);
 158 static void       ev_view_size_allocate                      (GtkWidget          *widget,
 159                                                               GtkAllocation      *allocation);
 160 static void       ev_view_realize                            (GtkWidget          *widget);
 161 static gboolean   ev_view_scroll_event                       (GtkWidget          *widget,
 162                                                               GdkEventScroll     *event);
 163 static gboolean   ev_view_expose_event                       (GtkWidget          *widget,
 164                                                               GdkEventExpose     *event);
 165 static gboolean   ev_view_popup_menu                         (GtkWidget          *widget);
 166 static gboolean   ev_view_button_press_event                 (GtkWidget          *widget,
 167                                                               GdkEventButton     *event);
 168 static gboolean   ev_view_motion_notify_event                (GtkWidget          *widget,
 169                                                               GdkEventMotion     *event);
 170 static gboolean   ev_view_button_release_event               (GtkWidget          *widget,
 171                                                               GdkEventButton     *event);
 172 static gboolean   ev_view_enter_notify_event                 (GtkWidget          *widget,
 173                                                               GdkEventCrossing   *event);
 174 static gboolean   ev_view_leave_notify_event                 (GtkWidget          *widget,
 175                                                               GdkEventCrossing   *event);
 176 static void       ev_view_style_set                          (GtkWidget          *widget,
 177                                                               GtkStyle           *old_style);
 178 static void       ev_view_remove_all                         (EvView             *view);
 179
 180 static AtkObject *ev_view_get_accessible                     (GtkWidget *widget);
 181
 182 /*** Drawing ***/
 183 static guint32    ev_gdk_color_to_rgb                        (const GdkColor     *color);
 184 static void       draw_rubberband                            (GtkWidget          *widget,
 185                                                               GdkWindow          *window,
 186                                                               const GdkRectangle *rect,
 187                                                               guchar              alpha);
 188 static void       highlight_find_results                     (EvView             *view,
 189                                                               int                 page);
 190 static void       draw_one_page                              (EvView             *view,
 191                                                               gint                page,
 192                                                               cairo_t            *cr,
 193                                                               GdkRectangle       *page_area,
 194                                                               GtkBorder          *border,
 195                                                               GdkRectangle       *expose_area,
 196                                                               gboolean           *page_ready);
 197 static void       draw_loading_text                          (EvView             *view,
 198                                                               GdkRectangle       *page_area,
 199                                                               GdkRectangle       *expose_area);
 200 static void       ev_view_reload_page                        (EvView             *view,
 201                                                               gint                page,
 202                                                               GdkRegion          *region);
 203
 204 /*** Callbacks ***/
 205 static void       ev_view_change_page                        (EvView             *view,
 206                                                               gint                new_page);
 207 static void       job_finished_cb                            (EvPixbufCache      *pixbuf_cache,
 208                                                               GdkRegion          *region,
 209                                                               EvView             *view);
 210 static void       ev_view_page_changed_cb                    (EvDocumentModel    *model,
 211                                                               gint                old_page,
 212                                                               gint                new_page,
 213                                                               EvView             *view);
 214 static void       on_adjustment_value_changed                (GtkAdjustment      *adjustment,
 215                                                               EvView             *view);
 216
 217 /*** GObject ***/
 218 static void       ev_view_finalize                           (GObject            *object);
 219 static void       ev_view_destroy                            (GtkObject          *object);
 220 static void       ev_view_get_property                       (GObject            *object,
 221                                                               guint               prop_id,
 222                                                               GValue             *value,
 223                                                               GParamSpec         *pspec);
 224 static void       ev_view_class_init                         (EvViewClass        *class);
 225 static void       ev_view_init                               (EvView             *view);
 226
 227 /*** Zoom and sizing ***/
 228 static double   zoom_for_size_fit_width                      (gdouble doc_width,
 229                                                               gdouble doc_height,
 230                                                               int     target_width,
 231                                                               int     target_height);
 232 static double   zoom_for_size_fit_height                     (gdouble doc_width,
 233                                                               gdouble doc_height,
 234                                                               int     target_width,
 235                                                               int     target_height);
 236 static double   zoom_for_size_best_fit                       (gdouble doc_width,
 237                                                               gdouble doc_height,
 238                                                               int     target_width,
 239                                                               int     target_height);
 240 static void     ev_view_zoom_for_size                        (EvView *view,
 241                                                               int     width,
 242                                                               int     height);
 243 static void     ev_view_zoom_for_size_continuous_and_dual_page (EvView *view,
 244                                                                 int     width,
 245                                                                 int     height);
 246 static void     ev_view_zoom_for_size_continuous               (EvView *view,
 247                                                                 int     width,
 248                                                                 int     height);
 249 static void     ev_view_zoom_for_size_dual_page                (EvView *view,
 250                                                                 int     width,
 251                                                                 int     height);
 252 static void     ev_view_zoom_for_size_single_page              (EvView *view,
 253                                                                 int     width,
 254                                                                 int     height);
 255 /*** Cursors ***/
 256 static void       ev_view_set_cursor                         (EvView             *view,
 257                                                               EvViewCursor        new_cursor);
 258 static void       ev_view_handle_cursor_over_xy              (EvView *view,
 259                                                               gint x,
 260                                                               gint y);
 261
 262 /*** Find ***/
 263 static gint         ev_view_find_get_n_results               (EvView             *view,
 264                                                               gint                page);
 265 static EvRectangle *ev_view_find_get_result                  (EvView             *view,
 266                                                               gint                page,
 267                                                               gint                result);
 268 static void       jump_to_find_result                        (EvView             *view);
 269 static void       jump_to_find_page                          (EvView             *view,
 270                                                               EvViewFindDirection direction,
 271                                                               gint                shift);
 272
 273 /*** Selection ***/
 274 static void       compute_selections                         (EvView             *view,
 275                                                               EvSelectionStyle    style,
 276                                                               GdkPoint           *start,
 277                                                               GdkPoint           *stop);
 278 static void       clear_selection                            (EvView             *view);
 279 static void       clear_link_selected                        (EvView             *view);
 280 static void       selection_free                             (EvViewSelection    *selection);
 281 static char*      get_selected_text                          (EvView             *ev_view);
 282 static void       ev_view_primary_get_cb                     (GtkClipboard       *clipboard,
 283                                                               GtkSelectionData   *selection_data,
 284                                                               guint               info,
 285                                                               gpointer            data);
 286 static void       ev_view_primary_clear_cb                   (GtkClipboard       *clipboard,
 287                                                               gpointer            data);
 288 static void       ev_view_update_primary_selection           (EvView             *ev_view);
 289
 290 G_DEFINE_TYPE (EvView, ev_view, GTK_TYPE_LAYOUT)
 291
 292 /* HeightToPage cache */
 293 #define EV_HEIGHT_TO_PAGE_CACHE_KEY "ev-height-to-page-cache"
 294
 295 static void
 296 build_height_to_page (EvHeightToPageCache *cache,
 297                       EvDocument          *document,
 298                       gint                 rotation)
 299 {
 300         gboolean swap, uniform, dual_even_left;
 301         int i;
 302         double uniform_height, page_height, next_page_height;
 303         double saved_height;
 304         gdouble u_width, u_height;
 305         gint n_pages;
 306
 307         swap = (rotation == 90 || rotation == 270);
 308
 309         uniform = ev_document_is_page_size_uniform (document);
 310         n_pages = ev_document_get_n_pages (document);
 311         dual_even_left = (n_pages > 2);
 312
 313         g_free (cache->height_to_page);
 314         g_free (cache->dual_height_to_page);
 315
 316         cache->rotation = rotation;
 317         cache->height_to_page = g_new0 (gdouble, n_pages + 1);
 318         cache->dual_height_to_page = g_new0 (gdouble, n_pages + 2);
 319
 320         if (uniform)
 321                 ev_document_get_page_size (document, 0, &u_width, &u_height);
 322
 323         saved_height = 0;
 324         for (i = 0; i <= n_pages; i++) {
 325                 if (uniform) {
 326                         uniform_height = swap ? u_width : u_height;
 327                         cache->height_to_page[i] = i * uniform_height;
 328                 } else {
 329                         if (i < n_pages) {
 330                                 gdouble w, h;
 331
 332                                 ev_document_get_page_size (document, i, &w, &h);
 333                                 page_height = swap ? w : h;
 334                         } else {
 335                                 page_height = 0;
 336                         }
 337                         cache->height_to_page[i] = saved_height;
 338                         saved_height += page_height;
 339                 }
 340         }
 341
 342         if (dual_even_left && !uniform) {
 343                 gdouble w, h;
 344
 345                 ev_document_get_page_size (document, 0, &w, &h);
 346                 saved_height = swap ? w : h;
 347         } else {
 348                 saved_height = 0;
 349         }
 350
 351         for (i = dual_even_left; i < n_pages + 2; i += 2) {
 352                 if (uniform) {
 353                         uniform_height = swap ? u_width : u_height;
 354                         cache->dual_height_to_page[i] = ((i + dual_even_left) / 2) * uniform_height;
 355                         if (i + 1 < n_pages + 2)
 356                                 cache->dual_height_to_page[i + 1] = ((i + dual_even_left) / 2) * uniform_height;
 357                 } else {
 358                         if (i + 1 < n_pages) {
 359                                 gdouble w, h;
 360
 361                                 ev_document_get_page_size (document, i + 1, &w, &h);
 362                                 next_page_height = swap ? w : h;
 363                         } else {
 364                                 next_page_height = 0;
 365                         }
 366
 367                         if (i < n_pages) {
 368                                 gdouble w, h;
 369
 370                                 ev_document_get_page_size (document, i, &w, &h);
 371                                 page_height = swap ? w : h;
 372                         } else {
 373                                 page_height = 0;
 374                         }
 375
 376                         if (i + 1 < n_pages + 2) {
 377                                 cache->dual_height_to_page[i] = saved_height;
 378                                 cache->dual_height_to_page[i + 1] = saved_height;
 379                                 saved_height += MAX(page_height, next_page_height);
 380                         } else {
 381                                 cache->dual_height_to_page[i] = saved_height;
 382                         }
 383                 }
 384         }
 385 }
 386
 387 static void
 388 ev_height_to_page_cache_get_height (EvHeightToPageCache *cache,
 389                                     EvDocument          *document,
 390                                     gint                 page,
 391                                     gint                 rotation,
 392                                     gdouble             *height,
 393                                     gdouble             *dual_height)
 394 {
 395         if (cache->rotation != rotation)
 396                 build_height_to_page (cache, document, rotation);
 397
 398         *height = cache->height_to_page[page];
 399         *dual_height = cache->dual_height_to_page[page];
 400 }
 401
 402 static void
 403 ev_height_to_page_cache_free (EvHeightToPageCache *cache)
 404 {
 405         if (cache->height_to_page) {
 406                 g_free (cache->height_to_page);
 407                 cache->height_to_page = NULL;
 408         }
 409
 410         if (cache->dual_height_to_page) {
 411                 g_free (cache->dual_height_to_page);
 412                 cache->dual_height_to_page = NULL;
 413         }
 414         g_free (cache);
 415 }
 416
 417 static EvHeightToPageCache *
 418 ev_view_get_height_to_page_cache (EvView *view)
 419 {
 420         EvHeightToPageCache *cache;
 421
 422         if (!view->document)
 423                 return NULL;
 424
 425         cache = g_object_get_data (G_OBJECT (view->document), EV_HEIGHT_TO_PAGE_CACHE_KEY);
 426         if (!cache) {
 427                 cache = g_new0 (EvHeightToPageCache, 1);
 428                 build_height_to_page (cache, view->document, view->rotation);
 429                 g_object_set_data_full (G_OBJECT (view->document),
 430                                         EV_HEIGHT_TO_PAGE_CACHE_KEY,
 431                                         cache,
 432                                         (GDestroyNotify)ev_height_to_page_cache_free);
 433         }
 434
 435         return cache;
 436 }
 437
 438 static void
 439 ev_view_get_height_to_page (EvView *view,
 440                             gint    page,
 441                             gint   *height,
 442                             gint   *dual_height)
 443 {
 444         gdouble h, dh;
 445
 446         if (!view->height_to_page_cache)
 447                 return;
 448
 449         ev_height_to_page_cache_get_height (view->height_to_page_cache,
 450                                             view->document,
 451                                             page,
 452                                             view->rotation,
 453                                             &h, &dh);
 454         if (height)
 455                 *height = (gint)(h * view->scale + 0.5);
 456
 457         if (dual_height)
 458                 *dual_height = (gint)(dh * view->scale + 0.5);
 459 }
 460
 461 static gint
 462 ev_view_get_scrollbar_size (EvView        *view,
 463                             GtkOrientation orientation)
 464 {
 465         GtkWidget *widget = GTK_WIDGET (view);
 466         GtkWidget *sb;
 467         GtkWidget *swindow = gtk_widget_get_parent (GTK_WIDGET (view));
 468         GtkRequisition req;
 469         gint spacing;
 470
 471         if (!GTK_IS_SCROLLED_WINDOW (swindow))
 472                 return 0;
 473
 474         if (orientation == GTK_ORIENTATION_VERTICAL) {
 475                 if (widget->allocation.height >= widget->requisition.height)
 476                         sb = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (swindow));
 477                 else
 478                         return 0;
 479         } else {
 480                 if (widget->allocation.width >= widget->requisition.width)
 481                         sb = gtk_scrolled_window_get_hscrollbar (GTK_SCROLLED_WINDOW (swindow));
 482                 else
 483                         return 0;
 484         }
 485
 486         gtk_widget_style_get (swindow, "scrollbar_spacing", &spacing, NULL);
 487         gtk_widget_size_request (sb, &req);
 488
 489         return (orientation == GTK_ORIENTATION_VERTICAL ? req.width : req.height) + spacing;
 490 }
 491
 492 static void
 493 scroll_to_point (EvView        *view,
 494                  gdouble        x,
 495                  gdouble        y,
 496                  GtkOrientation orientation)
 497 {
 498         if (orientation == GTK_ORIENTATION_VERTICAL) {
 499                 if (view->continuous) {
 500                         gtk_adjustment_clamp_page (view->vadjustment,
 501                                                    y - view->spacing / 2,
 502                                                    y + view->vadjustment->page_size);
 503                 } else {
 504                         gtk_adjustment_set_value (view->vadjustment,
 505                                                   CLAMP (y,
 506                                                   view->vadjustment->lower,
 507                                                   view->vadjustment->upper -
 508                                                   view->vadjustment->page_size));
 509                 }
 510         } else {
 511                 if (view->dual_page) {
 512                         gtk_adjustment_clamp_page (view->hadjustment, x,
 513                                                    x + view->hadjustment->page_size);
 514                 } else {
 515                         gtk_adjustment_set_value (view->hadjustment,
 516                                                   CLAMP (x,
 517                                                   view->hadjustment->lower,
 518                                                   view->hadjustment->upper -
 519                                                   view->hadjustment->page_size));
 520                 }
 521         }
 522 }
 523
 524 static void
 525 ev_view_scroll_to_page_position (EvView *view, GtkOrientation orientation)
 526 {
 527         gdouble x, y;
 528
 529         if (!view->document)
 530                 return;
 531
 532         if ((orientation == GTK_ORIENTATION_VERTICAL && view->pending_point.y == 0) ||
 533             (orientation == GTK_ORIENTATION_HORIZONTAL && view->pending_point.x == 0)) {
 534                 GdkRectangle page_area;
 535                 GtkBorder    border;
 536
 537                 get_page_extents (view, view->current_page, &page_area, &border);
 538                 x = page_area.x;
 539                 y = page_area.y;
 540         } else {
 541                 GdkPoint view_point;
 542
 543                 doc_point_to_view_point (view, view->current_page,
 544                                          &view->pending_point, &view_point);
 545                 x = view_point.x;
 546                 y = view_point.y;
 547         }
 548
 549         scroll_to_point (view, x, y, orientation);
 550 }
 551
 552 static void
 553 view_set_adjustment_values (EvView         *view,
 554                             GtkOrientation  orientation)
 555 {
 556         GtkWidget *widget = GTK_WIDGET (view);
 557         GtkAdjustment *adjustment;
 558         int requisition;
 559         int allocation;
 560
 561         double factor;
 562         gint new_value;
 563
 564         if (orientation == GTK_ORIENTATION_HORIZONTAL)  {
 565                 requisition = widget->requisition.width;
 566                 allocation = widget->allocation.width;
 567                 adjustment = view->hadjustment;
 568         } else {
 569                 requisition = widget->requisition.height;
 570                 allocation = widget->allocation.height;
 571                 adjustment = view->vadjustment;
 572         }
 573
 574         if (!adjustment)
 575                 return;
 576
 577         factor = 1.0;
 578         switch (view->pending_scroll) {
 579                 case SCROLL_TO_KEEP_POSITION:
 580                 case SCROLL_TO_FIND_LOCATION:
 581                         factor = (adjustment->value) / adjustment->upper;
 582                         break;
 583                 case SCROLL_TO_PAGE_POSITION:
 584                         break;
 585                 case SCROLL_TO_CENTER:
 586                         factor = (adjustment->value + adjustment->page_size * 0.5) / adjustment->upper;
 587                         break;
 588         }
 589
 590         adjustment->page_size = allocation;
 591         adjustment->step_increment = allocation * 0.1;
 592         adjustment->page_increment = allocation * 0.9;
 593         adjustment->lower = 0;
 594         adjustment->upper = MAX (allocation, requisition);
 595
 596         /*
 597          * We add 0.5 to the values before to average out our rounding errors.
 598          */
 599         switch (view->pending_scroll) {
 600                 case SCROLL_TO_KEEP_POSITION:
 601                 case SCROLL_TO_FIND_LOCATION:
 602                         new_value = CLAMP (adjustment->upper * factor + 0.5, 0, adjustment->upper - adjustment->page_size);
 603                         gtk_adjustment_set_value (adjustment, (int)new_value);
 604                         break;
 605                 case SCROLL_TO_PAGE_POSITION:
 606                         ev_view_scroll_to_page_position (view, orientation);
 607                         break;
 608                 case SCROLL_TO_CENTER:
 609                         new_value = CLAMP (adjustment->upper * factor - adjustment->page_size * 0.5 + 0.5,
 610                                            0, adjustment->upper - adjustment->page_size);
 611                         gtk_adjustment_set_value (adjustment, (int)new_value);
 612                         break;
 613         }
 614
 615         gtk_adjustment_changed (adjustment);
 616 }
 617
 618 static void
 619 view_update_range_and_current_page (EvView *view)
 620 {
 621         gint start = view->start_page;
 622         gint end = view->end_page;
 623
 624         if (ev_document_get_n_pages (view->document) <= 0 ||
 625             !ev_document_check_dimensions (view->document))
 626                 return;
 627
 628         if (view->continuous) {
 629                 GdkRectangle current_area, unused, page_area;
 630                 GtkBorder border;
 631                 gboolean found = FALSE;
 632                 gint area_max = -1, area;
 633                 gint best_current_page = -1;
 634                 int i, j = 0;
 635
 636                 if (!(view->vadjustment && view->hadjustment))
 637                         return;
 638
 639                 current_area.x = view->hadjustment->value;
 640                 current_area.width = view->hadjustment->page_size;
 641                 current_area.y = view->vadjustment->value;
 642                 current_area.height = view->vadjustment->page_size;
 643
 644                 for (i = 0; i < ev_document_get_n_pages (view->document); i++) {
 645
 646                         get_page_extents (view, i, &page_area, &border);
 647
 648                         if (gdk_rectangle_intersect (&current_area, &page_area, &unused)) {
 649                                 area = unused.width * unused.height;
 650
 651                                 if (!found) {
 652                                         area_max = area;
 653                                         view->start_page = i;
 654                                         found = TRUE;
 655                                         best_current_page = i;
 656                                 }
 657                                 if (area > area_max) {
 658                                         best_current_page = (area == area_max) ? MIN (i, best_current_page) : i;
 659                                         area_max = area;
 660                                 }
 661
 662                                 view->end_page = i;
 663                                 j = 0;
 664                         } else if (found && view->current_page <= view->end_page) {
 665                                 if (view->dual_page && j < 1) {
 666                                         /* In dual mode  we stop searching
 667                                          * after two consecutive non-visible pages.
 668                                          */
 669                                         j++;
 670                                         continue;
 671                                 }
 672                                 break;
 673                         }
 674                 }
 675
 676                 if (view->pending_scroll == SCROLL_TO_KEEP_POSITION) {
 677                         best_current_page = MAX (best_current_page, view->start_page);
 678
 679                         if (view->current_page != best_current_page) {
 680                                 view->current_page = best_current_page;
 681                                 ev_document_model_set_page (view->model, best_current_page);
 682                         }
 683                 }
 684         } else if (view->dual_page) {
 685                 if (view->current_page % 2 == get_dual_even_left (view)) {
 686                         view->start_page = view->current_page;
 687                         if (view->current_page + 1 < ev_document_get_n_pages (view->document))
 688                                 view->end_page = view->start_page + 1;
 689                         else
 690                                 view->end_page = view->start_page;
 691                 } else {
 692                         if (view->current_page < 1)
 693                                 view->start_page = view->current_page;
 694                         else
 695                                 view->start_page = view->current_page - 1;
 696                         view->end_page = view->current_page;
 697                 }
 698         } else {
 699                 view->start_page = view->current_page;
 700                 view->end_page = view->current_page;
 701         }
 702
 703         if (start != view->start_page || end != view->end_page) {
 704                 gint i;
 705
 706                 for (i = start; i < view->start_page && start != -1; i++) {
 707                         hide_annotation_windows (view, i);
 708                 }
 709
 710                 for (i = end; i > view->end_page && end != -1; i--) {
 711                         hide_annotation_windows (view, i);
 712                 }
 713         }
 714
 715         ev_page_cache_set_page_range (view->page_cache,
 716                                       view->start_page,
 717                                       view->end_page);
 718         ev_pixbuf_cache_set_page_range (view->pixbuf_cache,
 719                                         view->start_page,
 720                                         view->end_page,
 721                                         view->rotation,
 722                                         view->scale,
 723                                         view->selection_info.selections);
 724
 725         if (ev_pixbuf_cache_get_surface (view->pixbuf_cache, view->current_page))
 726             gtk_widget_queue_draw (GTK_WIDGET (view));
 727 }
 728
 729 static void
 730 set_scroll_adjustment (EvView *view,
 731                        GtkOrientation  orientation,
 732                        GtkAdjustment  *adjustment)
 733 {
 734         GtkAdjustment **to_set;
 735
 736         if (orientation == GTK_ORIENTATION_HORIZONTAL)
 737                 to_set = &view->hadjustment;
 738         else
 739                 to_set = &view->vadjustment;
 740
 741         if (*to_set != adjustment) {
 742                 if (*to_set) {
 743                         g_signal_handlers_disconnect_by_func (*to_set,
 744                                                               (gpointer) on_adjustment_value_changed,
 745                                                               view);
 746                         g_object_unref (*to_set);
 747                 }
 748
 749                 *to_set = adjustment;
 750                 view_set_adjustment_values (view, orientation);
 751
 752                 if (*to_set) {
 753                         g_object_ref (*to_set);
 754                         g_signal_connect (*to_set, "value_changed",
 755                                           G_CALLBACK (on_adjustment_value_changed), view);
 756                 }
 757         }
 758 }
 759
 760 static void
 761 ev_view_set_scroll_adjustments (GtkLayout      *layout,
 762                                 GtkAdjustment  *hadjustment,
 763                                 GtkAdjustment  *vadjustment)
 764 {
 765         EvView *view = EV_VIEW (layout);
 766
 767         set_scroll_adjustment (view, GTK_ORIENTATION_HORIZONTAL, hadjustment);
 768         set_scroll_adjustment (view, GTK_ORIENTATION_VERTICAL, vadjustment);
 769
 770         on_adjustment_value_changed (NULL, view);
 771 }
 772
 773 static void
 774 add_scroll_binding_keypad (GtkBindingSet  *binding_set,
 775                            guint           keyval,
 776                            GdkModifierType modifiers,
 777                            GtkScrollType   scroll,
 778                            gboolean        horizontal)
 779 {
 780   guint keypad_keyval = keyval - GDK_Left + GDK_KP_Left;
 781
 782   gtk_binding_entry_add_signal (binding_set, keyval, modifiers,
 783                                 "binding_activated", 2,
 784                                 GTK_TYPE_SCROLL_TYPE, scroll,
 785                                 G_TYPE_BOOLEAN, horizontal);
 786   gtk_binding_entry_add_signal (binding_set, keypad_keyval, modifiers,
 787                                 "binding_activated", 2,
 788                                 GTK_TYPE_SCROLL_TYPE, scroll,
 789                                 G_TYPE_BOOLEAN, horizontal);
 790 }
 791
 792 static gdouble
 793 compute_scroll_increment (EvView        *view,
 794                           GtkScrollType  scroll)
 795 {
 796         GtkWidget *widget = GTK_WIDGET (view);
 797         GtkAdjustment *adjustment = view->vadjustment;
 798         GdkRegion *text_region, *region;
 799         gint page;
 800         GdkRectangle rect;
 801         EvRectangle doc_rect;
 802         GdkRectangle page_area;
 803         GtkBorder border;
 804         GdkRectangle *recs;
 805         gint n_recs;
 806         gdouble fraction = 1.0;
 807
 808         if (scroll != GTK_SCROLL_PAGE_BACKWARD && scroll != GTK_SCROLL_PAGE_FORWARD)
 809                 return adjustment->page_size;
 810
 811         page = scroll == GTK_SCROLL_PAGE_BACKWARD ? view->start_page : view->end_page;
 812
 813         text_region = ev_page_cache_get_text_mapping (view->page_cache, page);
 814         if (!text_region || gdk_region_empty (text_region))
 815                 return adjustment->page_size;
 816
 817         get_page_extents (view, page, &page_area, &border);
 818         rect.x = page_area.x + view->scroll_x;
 819         rect.y = view->scroll_y + (scroll == GTK_SCROLL_PAGE_BACKWARD ? 5 : widget->allocation.height - 5);
 820         rect.width = page_area.width;
 821         rect.height = 1;
 822         view_rect_to_doc_rect (view, &rect, &page_area, &doc_rect);
 823
 824         /* Convert the doc rectangle into a GdkRectangle */
 825         rect.x = doc_rect.x1;
 826         rect.y = doc_rect.y1;
 827         rect.width = doc_rect.x2 - doc_rect.x1;
 828         rect.height = MAX (1, doc_rect.y2 - doc_rect.y1);
 829         region = gdk_region_rectangle (&rect);
 830
 831         gdk_region_intersect (region, text_region);
 832         gdk_region_get_rectangles (region, &recs, &n_recs);
 833         gdk_region_destroy (region);
 834         if (n_recs > 0) {
 835                 EvRenderContext *rc;
 836                 EvPage  *ev_page;
 837
 838                 ev_page = ev_document_get_page (view->document, page);
 839                 rc = ev_render_context_new (ev_page, view->rotation, view->scale);
 840                 g_object_unref (ev_page);
 841                 /* Get the selection region to know the height of the line */
 842                 doc_rect.x1 = doc_rect.x2 = recs[0].x + 0.5;
 843                 doc_rect.y1 = doc_rect.y2 = recs[0].y + 0.5;
 844
 845                 ev_document_doc_mutex_lock ();
 846                 region = ev_selection_get_selection_region (EV_SELECTION (view->document),
 847                                                             rc, EV_SELECTION_STYLE_LINE,
 848                                                             &doc_rect);
 849                 ev_document_doc_mutex_unlock ();
 850
 851                 g_object_unref (rc);
 852                 g_free (recs);
 853                 gdk_region_get_rectangles (region, &recs, &n_recs);
 854                 gdk_region_destroy (region);
 855                 if (n_recs > 0) {
 856                         fraction = 1 - (recs[0].height / adjustment->page_size);
 857                 }
 858                 g_free (recs);
 859         }
 860
 861         return adjustment->page_size * fraction;
 862
 863 }
 864
 865 void
 866 ev_view_scroll (EvView        *view,
 867                 GtkScrollType  scroll,
 868                 gboolean       horizontal)
 869 {
 870         GtkAdjustment *adjustment;
 871         double value, increment;
 872         gboolean first_page = FALSE;
 873         gboolean last_page = FALSE;
 874
 875         view->jump_to_find_result = FALSE;
 876
 877         if (view->sizing_mode == EV_SIZING_BEST_FIT) {
 878                 switch (scroll) {
 879                         case GTK_SCROLL_PAGE_BACKWARD:
 880                         case GTK_SCROLL_STEP_BACKWARD:
 881                                 ev_view_previous_page (view);
 882                                 break;
 883                         case GTK_SCROLL_PAGE_FORWARD:
 884                         case GTK_SCROLL_STEP_FORWARD:
 885                                 ev_view_next_page (view);
 886                                 break;
 887                         default:
 888                                 break;
 889                 }
 890                 return;
 891         }
 892
 893         /* Assign values for increment and vertical adjustment */
 894         adjustment = horizontal ? view->hadjustment : view->vadjustment;
 895         value = adjustment->value;
 896
 897         /* Assign boolean for first and last page */
 898         if (view->current_page == 0)
 899                 first_page = TRUE;
 900         if (view->current_page == ev_document_get_n_pages (view->document) - 1)
 901                 last_page = TRUE;
 902
 903         switch (scroll) {
 904                 case GTK_SCROLL_PAGE_BACKWARD:
 905                         /* Do not jump backwards if at the first page */
 906                         if (value == (adjustment->lower) && first_page) {
 907                                 /* Do nothing */
 908                                 /* At the top of a page, assign the upper bound limit of previous page */
 909                         } else if (value == (adjustment->lower)) {
 910                                 value = adjustment->upper - adjustment->page_size;
 911                                 ev_view_previous_page (view);
 912                                 /* Jump to the top */
 913                         } else {
 914                                 increment = compute_scroll_increment (view, GTK_SCROLL_PAGE_BACKWARD);
 915                                 value = MAX (value - increment, adjustment->lower);
 916                         }
 917                         break;
 918                 case GTK_SCROLL_PAGE_FORWARD:
 919                         /* Do not jump forward if at the last page */
 920                         if (value == (adjustment->upper - adjustment->page_size) && last_page) {
 921                                 /* Do nothing */
 922                         /* At the bottom of a page, assign the lower bound limit of next page */
 923                         } else if (value == (adjustment->upper - adjustment->page_size)) {
 924                                 value = 0;
 925                                 ev_view_next_page (view);
 926                         /* Jump to the bottom */
 927                         } else {
 928                                 increment = compute_scroll_increment (view, GTK_SCROLL_PAGE_FORWARD);
 929                                 value = MIN (value + increment, adjustment->upper - adjustment->page_size);
 930                         }
 931                         break;
 932                 case GTK_SCROLL_STEP_BACKWARD:
 933                         value -= adjustment->step_increment;
 934                         break;
 935                 case GTK_SCROLL_STEP_FORWARD:
 936                         value += adjustment->step_increment;
 937                         break;
 938                 case GTK_SCROLL_STEP_DOWN:
 939                         value -= adjustment->step_increment / 10;
 940                         break;
 941                 case GTK_SCROLL_STEP_UP:
 942                         value += adjustment->step_increment / 10;
 943                         break;
 944                 default:
 945                         break;
 946         }
 947
 948         value = CLAMP (value, adjustment->lower,
 949                        adjustment->upper - adjustment->page_size);
 950
 951         gtk_adjustment_set_value (adjustment, value);
 952 }
 953
 954 #define MARGIN 5
 955
 956 static void
 957 ensure_rectangle_is_visible (EvView *view, GdkRectangle *rect)
 958 {
 959         GtkWidget *widget = GTK_WIDGET (view);
 960         GtkAdjustment *adjustment;
 961         int value;
 962
 963         view->pending_scroll = SCROLL_TO_FIND_LOCATION;
 964
 965         adjustment = view->vadjustment;
 966
 967         if (rect->y < adjustment->value) {
 968                 value = MAX (adjustment->lower, rect->y - MARGIN);
 969                 gtk_adjustment_set_value (view->vadjustment, value);
 970         } else if (rect->y + rect->height >
 971                    adjustment->value + widget->allocation.height) {
 972                 value = MIN (adjustment->upper, rect->y + rect->height -
 973                              widget->allocation.height + MARGIN);
 974                 gtk_adjustment_set_value (view->vadjustment, value);
 975         }
 976
 977         adjustment = view->hadjustment;
 978
 979         if (rect->x < adjustment->value) {
 980                 value = MAX (adjustment->lower, rect->x - MARGIN);
 981                 gtk_adjustment_set_value (view->hadjustment, value);
 982         } else if (rect->x + rect->height >
 983                    adjustment->value + widget->allocation.width) {
 984                 value = MIN (adjustment->upper, rect->x + rect->width -
 985                              widget->allocation.width + MARGIN);
 986                 gtk_adjustment_set_value (view->hadjustment, value);
 987         }
 988
 989         gtk_widget_queue_resize (GTK_WIDGET (view));
 990 }
 991
 992 /*** Geometry computations ***/
 993
 994 static void
 995 compute_border (EvView *view, int width, int height, GtkBorder *border)
 996 {
 997         ev_document_misc_get_page_border_size (width, height, border);
 998 }
 999
1000 void
1001 _get_page_size_for_scale_and_rotation (EvDocument *document,
1002                                        gint        page,
1003                                        gdouble     scale,
1004                                        gint        rotation,
1005                                        gint       *page_width,
1006                                        gint       *page_height)
1007 {
1008         gdouble w, h;
1009         gint    width, height;
1010
1011         ev_document_get_page_size (document, page, &w, &h);
1012
1013         width = (gint)(w * scale + 0.5);
1014         height = (gint)(h * scale + 0.5);
1015
1016         if (page_width)
1017                 *page_width = (rotation == 0 || rotation == 180) ? width : height;
1018         if (page_height)
1019                 *page_height = (rotation == 0 || rotation == 180) ? height : width;
1020 }
1021
1022 static void
1023 ev_view_get_page_size (EvView *view,
1024                        gint    page,
1025                        gint   *page_width,
1026                        gint   *page_height)
1027 {
1028         _get_page_size_for_scale_and_rotation (view->document,
1029                                                page,
1030                                                view->scale,
1031                                                view->rotation,
1032                                                page_width,
1033                                                page_height);
1034 }
1035
1036 static void
1037 ev_view_get_max_page_size (EvView *view,
1038                            gint   *max_width,
1039                            gint   *max_height)
1040 {
1041         double w, h;
1042         gint   width, height;
1043
1044         ev_document_get_max_page_size (view->document, &w, &h);
1045
1046         width = (gint)(w * view->scale + 0.5);
1047         height = (gint)(h * view->scale + 0.5);
1048
1049         if (max_width)
1050                 *max_width = (view->rotation == 0 || view->rotation == 180) ? width : height;
1051         if (max_height)
1052                 *max_height = (view->rotation == 0 || view->rotation == 180) ? height : width;
1053 }
1054
1055 static void
1056 get_page_y_offset (EvView *view, int page, int *y_offset)
1057 {
1058         int max_width, offset;
1059         GtkBorder border;
1060
1061         g_return_if_fail (y_offset != NULL);
1062
1063         ev_view_get_max_page_size (view, &max_width, NULL);
1064         compute_border (view, max_width, max_width, &border);
1065
1066         if (view->dual_page) {
1067                 ev_view_get_height_to_page (view, page, NULL, &offset);
1068                 offset += ((page + get_dual_even_left (view)) / 2 + 1) * view->spacing +
1069                         ((page + get_dual_even_left (view)) / 2 ) * (border.top + border.bottom);
1070         } else {
1071                 ev_view_get_height_to_page (view, page, &offset, NULL);
1072                 offset += (page + 1) * view->spacing + page * (border.top + border.bottom);
1073         }
1074
1075         *y_offset = offset;
1076         return;
1077 }
1078
1079 static gboolean
1080 get_page_extents (EvView       *view,
1081                   gint          page,
1082                   GdkRectangle *page_area,
1083                   GtkBorder    *border)
1084 {
1085         GtkWidget *widget;
1086         int width, height;
1087
1088         widget = GTK_WIDGET (view);
1089
1090         /* Get the size of the page */
1091         ev_view_get_page_size (view, page, &width, &height);
1092         compute_border (view, width, height, border);
1093         page_area->width = width + border->left + border->right;
1094         page_area->height = height + border->top + border->bottom;
1095
1096         if (view->continuous) {
1097                 gint max_width;
1098                 gint x, y;
1099
1100                 ev_view_get_max_page_size (view, &max_width, NULL);
1101                 max_width = max_width + border->left + border->right;
1102                 /* Get the location of the bounding box */
1103                 if (view->dual_page) {
1104                         x = view->spacing + ((page % 2 == get_dual_even_left (view)) ? 0 : 1) * (max_width + view->spacing);
1105                         x = x + MAX (0, widget->allocation.width - (max_width * 2 + view->spacing * 3)) / 2;
1106                         if (page % 2 == get_dual_even_left (view))
1107                                 x = x + (max_width - width - border->left - border->right);
1108                 } else {
1109                         x = view->spacing;
1110                         x = x + MAX (0, widget->allocation.width - (width + view->spacing * 2)) / 2;
1111                 }
1112
1113                 get_page_y_offset (view, page, &y);
1114
1115                 page_area->x = x;
1116                 page_area->y = y;
1117         } else {
1118                 gint x, y;
1119                 if (view->dual_page) {
1120                         gint width_2, height_2;
1121                         gint max_width = width;
1122                         gint max_height = height;
1123                         GtkBorder overall_border;
1124                         gint other_page;
1125
1126                         other_page = (page % 2 == get_dual_even_left (view)) ? page + 1: page - 1;
1127
1128                         /* First, we get the bounding box of the two pages */
1129                         if (other_page < ev_document_get_n_pages (view->document)
1130                             && (0 <= other_page)) {
1131                                 ev_view_get_page_size (view, other_page,
1132                                                        &width_2, &height_2);
1133                                 if (width_2 > width)
1134                                         max_width = width_2;
1135                                 if (height_2 > height)
1136                                         max_height = height_2;
1137                         }
1138                         compute_border (view, max_width, max_height, &overall_border);
1139
1140                         /* Find the offsets */
1141                         x = view->spacing;
1142                         y = view->spacing;
1143
1144                         /* Adjust for being the left or right page */
1145                         if (page % 2 == get_dual_even_left (view))
1146                                 x = x + max_width - width;
1147                         else
1148                                 x = x + (max_width + overall_border.left + overall_border.right) + view->spacing;
1149
1150                         y = y + (max_height - height)/2;
1151
1152                         /* Adjust for extra allocation */
1153                         x = x + MAX (0, widget->allocation.width -
1154                                      ((max_width + overall_border.left + overall_border.right) * 2 + view->spacing * 3))/2;
1155                         y = y + MAX (0, widget->allocation.height - (height + view->spacing * 2))/2;
1156                 } else {
1157                         x = view->spacing;
1158                         y = view->spacing;
1159
1160                         /* Adjust for extra allocation */
1161                         x = x + MAX (0, widget->allocation.width - (width + border->left + border->right + view->spacing * 2))/2;
1162                         y = y + MAX (0, widget->allocation.height - (height + border->top + border->bottom +  view->spacing * 2))/2;
1163                 }
1164
1165                 page_area->x = x;
1166                 page_area->y = y;
1167         }
1168
1169         return TRUE;
1170 }
1171
1172 static void
1173 get_doc_page_size (EvView  *view,
1174                    gint     page,
1175                    gdouble *width,
1176                    gdouble *height)
1177 {
1178         double w, h;
1179
1180         ev_document_get_page_size (view->document, page, &w, &h);
1181         if (view->rotation == 0 || view->rotation == 180) {
1182                 if (width) *width = w;
1183                 if (height) *height = h;
1184         } else {
1185                 if (width) *width = h;
1186                 if (height) *height = w;
1187         }
1188 }
1189
1190 static void
1191 view_point_to_doc_point (EvView *view,
1192                          GdkPoint *view_point,
1193                          GdkRectangle *page_area,
1194                          double  *doc_point_x,
1195                          double  *doc_point_y)
1196 {
1197         *doc_point_x = (double) (view_point->x - page_area->x) / view->scale;
1198         *doc_point_y = (double) (view_point->y - page_area->y) / view->scale;
1199 }
1200
1201 static void
1202 view_rect_to_doc_rect (EvView *view,
1203                        GdkRectangle *view_rect,
1204                        GdkRectangle *page_area,
1205                        EvRectangle  *doc_rect)
1206 {
1207         doc_rect->x1 = (double) (view_rect->x - page_area->x) / view->scale;
1208         doc_rect->y1 = (double) (view_rect->y - page_area->y) / view->scale;
1209         doc_rect->x2 = doc_rect->x1 + (double) view_rect->width / view->scale;
1210         doc_rect->y2 = doc_rect->y1 + (double) view_rect->height / view->scale;
1211 }
1212
1213 static void
1214 doc_point_to_view_point (EvView       *view,
1215                          int           page,
1216                          EvPoint      *doc_point,
1217                          GdkPoint     *view_point)
1218 {
1219         GdkRectangle page_area;
1220         GtkBorder border;
1221         double x, y, view_x, view_y;
1222         gdouble width, height;
1223
1224         get_doc_page_size (view, page, &width, &height);
1225
1226         if (view->rotation == 0) {
1227                 x = doc_point->x;
1228                 y = doc_point->y;
1229         } else if (view->rotation == 90) {
1230                 x = width - doc_point->y;
1231                 y = doc_point->x;
1232         } else if (view->rotation == 180) {
1233                 x = width - doc_point->x;
1234                 y = height - doc_point->y;
1235         } else if (view->rotation == 270) {
1236                 x = doc_point->y;
1237                 y = height - doc_point->x;
1238         } else {
1239                 g_assert_not_reached ();
1240         }
1241
1242         get_page_extents (view, page, &page_area, &border);
1243
1244         view_x = CLAMP (x * view->scale, 0, page_area.width);
1245         view_y = CLAMP (y * view->scale, 0, page_area.height);
1246         view_point->x = view_x + page_area.x;
1247         view_point->y = view_y + page_area.y;
1248 }
1249
1250 static void
1251 doc_rect_to_view_rect (EvView       *view,
1252                        int           page,
1253                        EvRectangle  *doc_rect,
1254                        GdkRectangle *view_rect)
1255 {
1256         GdkRectangle page_area;
1257         GtkBorder border;
1258         double x, y, w, h;
1259         gdouble width, height;
1260
1261         get_doc_page_size (view, page, &width, &height);
1262
1263         if (view->rotation == 0) {
1264                 x = doc_rect->x1;
1265                 y = doc_rect->y1;
1266                 w = doc_rect->x2 - doc_rect->x1;
1267                 h = doc_rect->y2 - doc_rect->y1;
1268         } else if (view->rotation == 90) {
1269                 x = width - doc_rect->y2;
1270                 y = doc_rect->x1;
1271                 w = doc_rect->y2 - doc_rect->y1;
1272                 h = doc_rect->x2 - doc_rect->x1;
1273         } else if (view->rotation == 180) {
1274                 x = width - doc_rect->x2;
1275                 y = height - doc_rect->y2;
1276                 w = doc_rect->x2 - doc_rect->x1;
1277                 h = doc_rect->y2 - doc_rect->y1;
1278         } else if (view->rotation == 270) {
1279                 x = doc_rect->y1;
1280                 y = height - doc_rect->x2;
1281                 w = doc_rect->y2 - doc_rect->y1;
1282                 h = doc_rect->x2 - doc_rect->x1;
1283         } else {
1284                 g_assert_not_reached ();
1285         }
1286
1287         get_page_extents (view, page, &page_area, &border);
1288
1289         view_rect->x = x * view->scale + page_area.x;
1290         view_rect->y = y * view->scale + page_area.y;
1291         view_rect->width = w * view->scale;
1292         view_rect->height = h * view->scale;
1293 }
1294
1295 static gboolean
1296 get_dual_even_left (EvView *view)
1297 {
1298         return (ev_document_get_n_pages (view->document) > 2);
1299 }
1300
1301 static void
1302 find_page_at_location (EvView  *view,
1303                        gdouble  x,
1304                        gdouble  y,
1305                        gint    *page,
1306                        gint    *x_offset,
1307                        gint    *y_offset)
1308 {
1309         int i;
1310
1311         if (view->document == NULL)
1312                 return;
1313
1314         g_assert (page);
1315         g_assert (x_offset);
1316         g_assert (y_offset);
1317
1318         for (i = view->start_page; i >= 0 && i <= view->end_page; i++) {
1319                 GdkRectangle page_area;
1320                 GtkBorder border;
1321
1322                 if (! get_page_extents (view, i, &page_area, &border))
1323                         continue;
1324
1325                 if ((x >= page_area.x + border.left) &&
1326                     (x < page_area.x + page_area.width - border.right) &&
1327                     (y >= page_area.y + border.top) &&
1328                     (y < page_area.y + page_area.height - border.bottom)) {
1329                         *page = i;
1330                         *x_offset = x - (page_area.x + border.left);
1331                         *y_offset = y - (page_area.y + border.top);
1332                         return;
1333                 }
1334         }
1335
1336         *page = -1;
1337 }
1338
1339 static gboolean
1340 location_in_text (EvView  *view,
1341                   gdouble  x,
1342                   gdouble  y)
1343 {
1344         GdkRegion *region;
1345         gint page = -1;
1346         gint x_offset = 0, y_offset = 0;
1347
1348         find_page_at_location (view, x, y, &page, &x_offset, &y_offset);
1349
1350         if (page == -1)
1351                 return FALSE;
1352
1353         region = ev_page_cache_get_text_mapping (view->page_cache, page);
1354
1355         if (region)
1356                 return gdk_region_point_in (region, x_offset / view->scale, y_offset / view->scale);
1357         else
1358                 return FALSE;
1359 }
1360
1361 static int
1362 ev_view_get_width (EvView *view)
1363 {
1364         return GTK_WIDGET (view)->allocation.width;
1365 }
1366
1367 static int
1368 ev_view_get_height (EvView *view)
1369 {
1370         return GTK_WIDGET (view)->allocation.height;
1371 }
1372
1373 static gboolean
1374 location_in_selected_text (EvView  *view,
1375                            gdouble  x,
1376                            gdouble  y)
1377 {
1378         gint page = -1;
1379         gint x_offset = 0, y_offset = 0;
1380         EvViewSelection *selection;
1381         GList *l = NULL;
1382
1383         for (l = view->selection_info.selections; l != NULL; l = l->next) {
1384                 selection = (EvViewSelection *)l->data;
1385
1386                 find_page_at_location (view, x, y, &page, &x_offset, &y_offset);
1387
1388                 if (page != selection->page)
1389                         continue;
1390
1391                 if (selection->covered_region &&
1392                     gdk_region_point_in (selection->covered_region, x_offset, y_offset))
1393                         return TRUE;
1394         }
1395
1396         return FALSE;
1397 }
1398
1399 static gboolean
1400 get_doc_point_from_offset (EvView *view,
1401                            gint    page,
1402                            gint    x_offset,
1403                            gint    y_offset,
1404                            gint   *x_new,
1405                            gint   *y_new)
1406 {
1407         gdouble width, height;
1408         double x, y;
1409
1410         get_doc_page_size (view, page, &width, &height);
1411
1412         x_offset = x_offset / view->scale;
1413         y_offset = y_offset / view->scale;
1414
1415         if (view->rotation == 0) {
1416                 x = x_offset;
1417                 y = y_offset;
1418         } else if (view->rotation == 90) {
1419                 x = y_offset;
1420                 y = width - x_offset;
1421         } else if (view->rotation == 180) {
1422                 x = width - x_offset;
1423                 y = height - y_offset;
1424         } else if (view->rotation == 270) {
1425                 x = height - y_offset;
1426                 y = x_offset;
1427         } else {
1428                 g_assert_not_reached ();
1429         }
1430
1431         *x_new = x;
1432         *y_new = y;
1433
1434         return TRUE;
1435 }
1436
1437 static gboolean
1438 get_doc_point_from_location (EvView  *view,
1439                              gdouble  x,
1440                              gdouble  y,
1441                              gint    *page,
1442                              gint    *x_new,
1443                              gint    *y_new)
1444 {
1445         gint x_offset = 0, y_offset = 0;
1446
1447         x += view->scroll_x;
1448         y += view->scroll_y;
1449         find_page_at_location (view, x, y, page, &x_offset, &y_offset);
1450         if (*page == -1)
1451                 return FALSE;
1452
1453         return get_doc_point_from_offset (view, *page, x_offset, y_offset, x_new, y_new);
1454 }
1455
1456 static void
1457 ev_view_get_area_from_mapping (EvView       *view,
1458                                guint         page,
1459                                GList        *mapping_list,
1460                                gconstpointer data,
1461                                GdkRectangle *area)
1462 {
1463         EvMapping *mapping;
1464
1465         mapping = ev_mapping_list_find (mapping_list, data);
1466         doc_rect_to_view_rect (view, page, &mapping->area, area);
1467         area->x -= view->scroll_x;
1468         area->y -= view->scroll_y;
1469 }
1470
1471
1472 /*** Hyperref ***/
1473 static EvLink *
1474 ev_view_get_link_at_location (EvView  *view,
1475                               gdouble  x,
1476                               gdouble  y)
1477 {
1478         gint page = -1;
1479         gint x_new = 0, y_new = 0;
1480         GList *link_mapping;
1481
1482         if (!EV_IS_DOCUMENT_LINKS (view->document))
1483                 return NULL;
1484
1485         if (!get_doc_point_from_location (view, x, y, &page, &x_new, &y_new))
1486                 return NULL;
1487
1488         link_mapping = ev_page_cache_get_link_mapping (view->page_cache, page);
1489
1490         if (link_mapping)
1491                 return ev_mapping_list_get_data (link_mapping, x_new, y_new);
1492         else
1493                 return NULL;
1494 }
1495
1496 static void
1497 goto_fitr_dest (EvView *view, EvLinkDest *dest)
1498 {
1499         EvPoint doc_point;
1500         gdouble zoom, left, top;
1501         gboolean change_left, change_top;
1502
1503         left = ev_link_dest_get_left (dest, &change_left);
1504         top = ev_link_dest_get_top (dest, &change_top);
1505
1506         zoom = zoom_for_size_best_fit (ev_link_dest_get_right (dest) - left,
1507                                        ev_link_dest_get_bottom (dest) - top,
1508                                        ev_view_get_width (view),
1509                                        ev_view_get_height (view));
1510
1511         ev_document_model_set_sizing_mode (view->model, EV_SIZING_FREE);
1512         ev_document_model_set_scale (view->model, zoom);
1513
1514         doc_point.x = change_left ? left : 0;
1515         doc_point.y = change_top ? top : 0;
1516         view->pending_point = doc_point;
1517
1518         ev_view_change_page (view, ev_link_dest_get_page (dest));
1519 }
1520
1521 static void
1522 goto_fitv_dest (EvView *view, EvLinkDest *dest)
1523 {
1524         EvPoint doc_point;
1525         gdouble doc_width, doc_height;
1526         gint page;
1527         double zoom, left;
1528         gboolean change_left;
1529
1530         page = ev_link_dest_get_page (dest);
1531         ev_document_get_page_size (view->document, page, &doc_width, &doc_height);
1532
1533         left = ev_link_dest_get_left (dest, &change_left);
1534         doc_point.x = change_left ? left : 0;
1535         doc_point.y = 0;
1536
1537         zoom = zoom_for_size_fit_height (doc_width - doc_point.x , doc_height,
1538                                          ev_view_get_width (view),
1539                                          ev_view_get_height (view));
1540
1541         ev_document_model_set_sizing_mode (view->model, EV_SIZING_FREE);
1542         ev_document_model_set_scale (view->model, zoom);
1543
1544         view->pending_point = doc_point;
1545
1546         ev_view_change_page (view, page);
1547 }
1548
1549 static void
1550 goto_fith_dest (EvView *view, EvLinkDest *dest)
1551 {
1552         EvPoint doc_point;
1553         gdouble doc_width, doc_height;
1554         gint page;
1555         gdouble zoom, top;
1556         gboolean change_top;
1557
1558         page = ev_link_dest_get_page (dest);
1559         ev_document_get_page_size (view->document, page, &doc_width, &doc_height);
1560
1561         top = ev_link_dest_get_top (dest, &change_top);
1562
1563         doc_point.x = 0;
1564         doc_point.y = change_top ? top : 0;
1565
1566         zoom = zoom_for_size_fit_width (doc_width, top,
1567                                         ev_view_get_width (view),
1568                                         ev_view_get_height (view));
1569
1570         ev_document_model_set_sizing_mode (view->model, EV_SIZING_FIT_WIDTH);
1571         ev_document_model_set_scale (view->model, zoom);
1572
1573         view->pending_point = doc_point;
1574
1575         ev_view_change_page (view, page);
1576 }
1577
1578 static void
1579 goto_fit_dest (EvView *view, EvLinkDest *dest)
1580 {
1581         double zoom;
1582         gdouble doc_width, doc_height;
1583         int page;
1584
1585         page = ev_link_dest_get_page (dest);
1586         ev_document_get_page_size (view->document, page, &doc_width, &doc_height);
1587
1588         zoom = zoom_for_size_best_fit (doc_width, doc_height,
1589                                        ev_view_get_width (view),
1590                                        ev_view_get_height (view));
1591
1592         ev_document_model_set_sizing_mode (view->model, EV_SIZING_BEST_FIT);
1593         ev_document_model_set_scale (view->model, zoom);
1594
1595         ev_view_change_page (view, page);
1596 }
1597
1598 static void
1599 goto_xyz_dest (EvView *view, EvLinkDest *dest)
1600 {
1601         EvPoint doc_point;
1602         gint page;
1603         gdouble zoom, left, top;
1604         gboolean change_zoom, change_left, change_top;
1605
1606         zoom = ev_link_dest_get_zoom (dest, &change_zoom);
1607         page = ev_link_dest_get_page (dest);
1608
1609         if (change_zoom && zoom > 1) {
1610                 ev_document_model_set_sizing_mode (view->model, EV_SIZING_FREE);
1611                 ev_document_model_set_scale (view->model, zoom);
1612         }
1613
1614         left = ev_link_dest_get_left (dest, &change_left);
1615         top = ev_link_dest_get_top (dest, &change_top);
1616
1617         doc_point.x = change_left ? left : 0;
1618         doc_point.y = change_top ? top : 0;
1619         view->pending_point = doc_point;
1620
1621         ev_view_change_page (view, page);
1622 }
1623
1624 static void
1625 goto_dest (EvView *view, EvLinkDest *dest)
1626 {
1627         EvLinkDestType type;
1628         int page, n_pages, current_page;
1629
1630         page = ev_link_dest_get_page (dest);
1631         n_pages = ev_document_get_n_pages (view->document);
1632
1633         if (page < 0 || page >= n_pages)
1634                 return;
1635
1636         current_page = view->current_page;
1637
1638         type = ev_link_dest_get_dest_type (dest);
1639
1640         switch (type) {
1641                 case EV_LINK_DEST_TYPE_PAGE:
1642                         ev_document_model_set_page (view->model, page);
1643                         break;
1644                 case EV_LINK_DEST_TYPE_FIT:
1645                         goto_fit_dest (view, dest);
1646                         break;
1647                 case EV_LINK_DEST_TYPE_FITH:
1648                         goto_fith_dest (view, dest);
1649                         break;
1650                 case EV_LINK_DEST_TYPE_FITV:
1651                         goto_fitv_dest (view, dest);
1652                         break;
1653                 case EV_LINK_DEST_TYPE_FITR:
1654                         goto_fitr_dest (view, dest);
1655                         break;
1656                 case EV_LINK_DEST_TYPE_XYZ:
1657                         goto_xyz_dest (view, dest);
1658                         break;
1659                 case EV_LINK_DEST_TYPE_PAGE_LABEL:
1660                         ev_document_model_set_page_by_label (view->model, ev_link_dest_get_page_label (dest));
1661                         break;
1662                 default:
1663                         g_assert_not_reached ();
1664         }
1665
1666         if (current_page != view->current_page)
1667                 ev_document_model_set_page (view->model, view->current_page);
1668 }
1669
1670 static void
1671 ev_view_goto_dest (EvView *view, EvLinkDest *dest)
1672 {
1673         EvLinkDestType type;
1674
1675         type = ev_link_dest_get_dest_type (dest);
1676
1677         if (type == EV_LINK_DEST_TYPE_NAMED) {
1678                 EvLinkDest  *dest2;
1679                 const gchar *named_dest;
1680
1681                 named_dest = ev_link_dest_get_named_dest (dest);
1682                 dest2 = ev_document_links_find_link_dest (EV_DOCUMENT_LINKS (view->document),
1683                                                           named_dest);
1684                 if (dest2) {
1685                         goto_dest (view, dest2);
1686                         g_object_unref (dest2);
1687                 }
1688
1689                 return;
1690         }
1691
1692         goto_dest (view, dest);
1693 }
1694
1695 void
1696 ev_view_handle_link (EvView *view, EvLink *link)
1697 {
1698         EvLinkAction    *action = NULL;
1699         EvLinkActionType type;
1700
1701         action = ev_link_get_action (link);
1702         if (!action)
1703                 return;
1704
1705         type = ev_link_action_get_action_type (action);
1706
1707         switch (type) {
1708                 case EV_LINK_ACTION_TYPE_GOTO_DEST: {
1709                         EvLinkDest *dest;
1710
1711                         g_signal_emit (view, signals[SIGNAL_HANDLE_LINK], 0, link);
1712
1713                         dest = ev_link_action_get_dest (action);
1714                         ev_view_goto_dest (view, dest);
1715                 }
1716                         break;
1717                 case EV_LINK_ACTION_TYPE_GOTO_REMOTE:
1718                 case EV_LINK_ACTION_TYPE_EXTERNAL_URI:
1719                 case EV_LINK_ACTION_TYPE_LAUNCH:
1720                 case EV_LINK_ACTION_TYPE_NAMED:
1721                         g_signal_emit (view, signals[SIGNAL_EXTERNAL_LINK], 0, action);
1722                         break;
1723         }
1724 }
1725
1726 static char *
1727 tip_from_action_named (EvLinkAction *action)
1728 {
1729         const gchar *name = ev_link_action_get_name (action);
1730
1731         if (g_ascii_strcasecmp (name, "FirstPage") == 0) {
1732                 return g_strdup (_("Go to first page"));
1733         } else if (g_ascii_strcasecmp (name, "PrevPage") == 0) {
1734                 return g_strdup (_("Go to previous page"));
1735         } else if (g_ascii_strcasecmp (name, "NextPage") == 0) {
1736                 return g_strdup (_("Go to next page"));
1737         } else if (g_ascii_strcasecmp (name, "LastPage") == 0) {
1738                 return g_strdup (_("Go to last page"));
1739         } else if (g_ascii_strcasecmp (name, "GoToPage") == 0) {
1740                 return g_strdup (_("Go to page"));
1741         } else if (g_ascii_strcasecmp (name, "Find") == 0) {
1742                 return g_strdup (_("Find"));
1743         }
1744
1745         return NULL;
1746 }
1747
1748 static char *
1749 tip_from_link (EvView *view, EvLink *link)
1750 {
1751         EvLinkAction *action;
1752         EvLinkActionType type;
1753         char *msg = NULL;
1754         char *page_label;
1755         const char *title;
1756
1757         action = ev_link_get_action (link);
1758         title = ev_link_get_title (link);
1759
1760         if (!action)
1761                 return title ? g_strdup (title) : NULL;
1762
1763         type = ev_link_action_get_action_type (action);
1764
1765         switch (type) {
1766                 case EV_LINK_ACTION_TYPE_GOTO_DEST:
1767                         page_label = ev_document_links_get_dest_page_label (EV_DOCUMENT_LINKS (view->document),
1768                                                                             ev_link_action_get_dest (action));
1769                         if (page_label) {
1770                                 msg = g_strdup_printf (_("Go to page %s"), page_label);
1771                                 g_free (page_label);
1772                         }
1773                         break;
1774                 case EV_LINK_ACTION_TYPE_GOTO_REMOTE:
1775                         if (title) {
1776                                 msg = g_strdup_printf (_("Go to %s on file “%s”"), title,
1777                                                        ev_link_action_get_filename (action));
1778                         } else {
1779                                 msg = g_strdup_printf (_("Go to file “%s”"),
1780                                                        ev_link_action_get_filename (action));
1781                         }
1782                         break;
1783                 case EV_LINK_ACTION_TYPE_EXTERNAL_URI:
1784                         msg = g_strdup (ev_link_action_get_uri (action));
1785                         break;
1786                 case EV_LINK_ACTION_TYPE_LAUNCH:
1787                         msg = g_strdup_printf (_("Launch %s"),
1788                                                ev_link_action_get_filename (action));
1789                         break;
1790                 case EV_LINK_ACTION_TYPE_NAMED:
1791                         msg = tip_from_action_named (action);
1792                         break;
1793                 default:
1794                         if (title)
1795                                 msg = g_strdup (title);
1796                         break;
1797         }
1798
1799         return msg;
1800 }
1801
1802 static void
1803 ev_view_handle_cursor_over_xy (EvView *view, gint x, gint y)
1804 {
1805         EvLink       *link;
1806         EvFormField  *field;
1807         EvAnnotation *annot = NULL;
1808
1809         if (view->cursor == EV_VIEW_CURSOR_HIDDEN)
1810                 return;
1811
1812         if (view->drag_info.in_drag) {
1813                 if (view->cursor != EV_VIEW_CURSOR_DRAG)
1814                         ev_view_set_cursor (view, EV_VIEW_CURSOR_DRAG);
1815                 return;
1816         }
1817
1818         if (view->scroll_info.autoscrolling) {
1819                 if (view->cursor != EV_VIEW_CURSOR_AUTOSCROLL)
1820                         ev_view_set_cursor (view, EV_VIEW_CURSOR_AUTOSCROLL);
1821                 return;
1822         }
1823
1824         link = ev_view_get_link_at_location (view, x, y);
1825         if (link) {
1826                 ev_view_set_cursor (view, EV_VIEW_CURSOR_LINK);
1827         } else if ((field = ev_view_get_form_field_at_location (view, x, y))) {
1828                 if (field->is_read_only) {
1829                         if (view->cursor == EV_VIEW_CURSOR_LINK ||
1830                             view->cursor == EV_VIEW_CURSOR_IBEAM ||
1831                             view->cursor == EV_VIEW_CURSOR_DRAG)
1832                                 ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
1833                 } else if (EV_IS_FORM_FIELD_TEXT (field)) {
1834                         ev_view_set_cursor (view, EV_VIEW_CURSOR_IBEAM);
1835                 } else {
1836                         ev_view_set_cursor (view, EV_VIEW_CURSOR_LINK);
1837                 }
1838         } else if ((annot = ev_view_get_annotation_at_location (view, x, y))) {
1839                 ev_view_set_cursor (view, EV_VIEW_CURSOR_LINK);
1840         } else if (location_in_text (view, x + view->scroll_x, y + view->scroll_y)) {
1841                 ev_view_set_cursor (view, EV_VIEW_CURSOR_IBEAM);
1842         } else {
1843                 if (view->cursor == EV_VIEW_CURSOR_LINK ||
1844                     view->cursor == EV_VIEW_CURSOR_IBEAM ||
1845                     view->cursor == EV_VIEW_CURSOR_DRAG ||
1846                     view->cursor == EV_VIEW_CURSOR_AUTOSCROLL)
1847                         ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
1848         }
1849
1850         if (link || annot)
1851                 g_object_set (view, "has-tooltip", TRUE, NULL);
1852 }
1853
1854 /*** Images ***/
1855 static EvImage *
1856 ev_view_get_image_at_location (EvView  *view,
1857                                gdouble  x,
1858                                gdouble  y)
1859 {
1860         gint page = -1;
1861         gint x_new = 0, y_new = 0;
1862         GList *image_mapping;
1863
1864         if (!EV_IS_DOCUMENT_IMAGES (view->document))
1865                 return NULL;
1866
1867         if (!get_doc_point_from_location (view, x, y, &page, &x_new, &y_new))
1868                 return NULL;
1869
1870         image_mapping = ev_page_cache_get_image_mapping (view->page_cache, page);
1871
1872         if (image_mapping)
1873                 return ev_mapping_list_get_data (image_mapping, x_new, y_new);
1874         else
1875                 return NULL;
1876 }
1877
1878 /*** Forms ***/
1879 static EvFormField *
1880 ev_view_get_form_field_at_location (EvView  *view,
1881                                     gdouble  x,
1882                                     gdouble  y)
1883 {
1884         gint page = -1;
1885         gint x_new = 0, y_new = 0;
1886         GList *forms_mapping;
1887
1888         if (!EV_IS_DOCUMENT_FORMS (view->document))
1889                 return NULL;
1890
1891         if (!get_doc_point_from_location (view, x, y, &page, &x_new, &y_new))
1892                 return NULL;
1893
1894         forms_mapping = ev_page_cache_get_form_field_mapping (view->page_cache, page);
1895
1896         if (forms_mapping)
1897                 return ev_mapping_list_get_data (forms_mapping, x_new, y_new);
1898         else
1899                 return NULL;
1900 }
1901
1902 static GdkRegion *
1903 ev_view_form_field_get_region (EvView      *view,
1904                                EvFormField *field)
1905 {
1906         GdkRectangle view_area;
1907         GList       *forms_mapping;
1908
1909         forms_mapping = ev_page_cache_get_form_field_mapping (view->page_cache,
1910                                                               field->page->index);
1911         ev_view_get_area_from_mapping (view, field->page->index,
1912                                        forms_mapping,
1913                                        field, &view_area);
1914
1915         return gdk_region_rectangle (&view_area);
1916 }
1917
1918 static gboolean
1919 ev_view_forms_remove_widgets (EvView *view)
1920 {
1921         ev_view_remove_all (view);
1922
1923         return FALSE;
1924 }
1925
1926 static void
1927 ev_view_form_field_destroy (GtkWidget *widget,
1928                             EvView    *view)
1929 {
1930         g_idle_add ((GSourceFunc)ev_view_forms_remove_widgets, view);
1931 }
1932
1933 static GtkWidget *
1934 ev_view_form_field_button_create_widget (EvView      *view,
1935                                          EvFormField *field)
1936 {
1937         EvFormFieldButton *field_button = EV_FORM_FIELD_BUTTON (field);
1938         GdkRegion         *field_region = NULL;
1939
1940         switch (field_button->type) {
1941                 case EV_FORM_FIELD_BUTTON_PUSH:
1942                         return NULL;
1943                 case EV_FORM_FIELD_BUTTON_CHECK:
1944                 case EV_FORM_FIELD_BUTTON_RADIO: {
1945                         gboolean  state;
1946                         GList    *forms_mapping, *l;
1947
1948                         state = ev_document_forms_form_field_button_get_state (EV_DOCUMENT_FORMS (view->document),
1949                                                                                field);
1950
1951                         /* FIXME: it actually depends on NoToggleToOff flags */
1952                         if (field_button->type == EV_FORM_FIELD_BUTTON_RADIO &&
1953                             state && field_button->state)
1954                                 return NULL;
1955
1956                         field_region = ev_view_form_field_get_region (view, field);
1957
1958                         /* For radio buttons and checkbox buttons that are in a set
1959                          * we need to update also the region for the current selected item
1960                          */
1961                         forms_mapping = ev_page_cache_get_form_field_mapping (view->page_cache,
1962                                                                               field->page->index);
1963                         for (l = forms_mapping; l; l = g_list_next (l)) {
1964                                 EvFormField *button = ((EvMapping *)(l->data))->data;
1965                                 GdkRegion   *button_region;
1966
1967                                 if (button->id == field->id)
1968                                         continue;
1969
1970                                 /* FIXME: only buttons in the same group should be updated */
1971                                 if (!EV_IS_FORM_FIELD_BUTTON (button) ||
1972                                     EV_FORM_FIELD_BUTTON (button)->type != field_button->type ||
1973                                     EV_FORM_FIELD_BUTTON (button)->state != TRUE)
1974                                         continue;
1975
1976                                 button_region = ev_view_form_field_get_region (view, button);
1977                                 gdk_region_union (field_region, button_region);
1978                                 gdk_region_destroy (button_region);
1979                         }
1980
1981                         ev_document_forms_form_field_button_set_state (EV_DOCUMENT_FORMS (view->document),
1982                                                                        field, !state);
1983                         field_button->state = !state;
1984                 }
1985                         break;
1986         }
1987
1988         ev_view_reload_page (view, field->page->index, field_region);
1989         gdk_region_destroy (field_region);
1990
1991         return NULL;
1992 }
1993
1994 static void
1995 ev_view_form_field_text_save (EvView    *view,
1996                               GtkWidget *widget)
1997 {
1998         EvFormField *field;
1999
2000         if (!view->document)
2001                 return;
2002
2003         field = g_object_get_data (G_OBJECT (widget), "form-field");
2004
2005         if (field->changed) {
2006                 EvFormFieldText *field_text = EV_FORM_FIELD_TEXT (field);
2007                 GdkRegion       *field_region;
2008
2009                 field_region = ev_view_form_field_get_region (view, field);
2010
2011                 ev_document_forms_form_field_text_set_text (EV_DOCUMENT_FORMS (view->document),
2012                                                             field, field_text->text);
2013                 field->changed = FALSE;
2014                 ev_view_reload_page (view, field->page->index, field_region);
2015                 gdk_region_destroy (field_region);
2016         }
2017 }
2018
2019 static void
2020 ev_view_form_field_text_changed (GtkWidget   *widget,
2021                                  EvFormField *field)
2022 {
2023         EvFormFieldText *field_text = EV_FORM_FIELD_TEXT (field);
2024         gchar           *text = NULL;
2025
2026         if (GTK_IS_ENTRY (widget)) {
2027                 text = g_strdup (gtk_entry_get_text (GTK_ENTRY (widget)));
2028         } else if (GTK_IS_TEXT_BUFFER (widget)) {
2029                 GtkTextIter start, end;
2030
2031                 gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (widget), &start, &end);
2032                 text = gtk_text_buffer_get_text (GTK_TEXT_BUFFER (widget),
2033                                                  &start, &end, FALSE);
2034         }
2035
2036         if (!field_text->text ||
2037             (field_text->text && g_ascii_strcasecmp (field_text->text, text) != 0)) {
2038                 g_free (field_text->text);
2039                 field_text->text = text;
2040                 field->changed = TRUE;
2041         }
2042 }
2043
2044 static GtkWidget *
2045 ev_view_form_field_text_create_widget (EvView      *view,
2046                                        EvFormField *field)
2047 {
2048         EvFormFieldText *field_text = EV_FORM_FIELD_TEXT (field);
2049         GtkWidget       *text = NULL;
2050         gchar           *txt;
2051
2052         txt = ev_document_forms_form_field_text_get_text (EV_DOCUMENT_FORMS (view->document),
2053                                                           field);
2054
2055         switch (field_text->type) {
2056                 case EV_FORM_FIELD_TEXT_FILE_SELECT:
2057                         /* TODO */
2058                 case EV_FORM_FIELD_TEXT_NORMAL:
2059                         text = gtk_entry_new ();
2060                         gtk_entry_set_has_frame (GTK_ENTRY (text), FALSE);
2061                         gtk_entry_set_max_length (GTK_ENTRY (text), field_text->max_len);
2062                         gtk_entry_set_visibility (GTK_ENTRY (text), !field_text->is_password);
2063
2064                         if (txt) {
2065                                 gtk_entry_set_text (GTK_ENTRY (text), txt);
2066                                 g_free (txt);
2067                         }
2068
2069                         g_signal_connect (text, "changed",
2070                                           G_CALLBACK (ev_view_form_field_text_changed),
2071                                           field);
2072                         g_signal_connect_after (text, "activate",
2073                                                 G_CALLBACK (ev_view_form_field_destroy),
2074                                                 view);
2075                         break;
2076                 case EV_FORM_FIELD_TEXT_MULTILINE: {
2077                         GtkTextBuffer *buffer;
2078
2079                         text = gtk_text_view_new ();
2080                         buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text));
2081
2082                         if (txt) {
2083                                 gtk_text_buffer_set_text (buffer, txt, -1);
2084                                 g_free (txt);
2085                         }
2086
2087                         g_signal_connect (buffer, "changed",
2088                                           G_CALLBACK (ev_view_form_field_text_changed),
2089                                           field);
2090                 }
2091                         break;
2092         }
2093
2094         g_object_weak_ref (G_OBJECT (text),
2095                            (GWeakNotify)ev_view_form_field_text_save,
2096                            view);
2097
2098         return text;
2099 }
2100
2101 static void
2102 ev_view_form_field_choice_save (EvView    *view,
2103                                 GtkWidget *widget)
2104 {
2105         EvFormField *field;
2106
2107         if (!view->document)
2108                 return;
2109
2110         field = g_object_get_data (G_OBJECT (widget), "form-field");
2111
2112         if (field->changed) {
2113                 GList             *l;
2114                 EvFormFieldChoice *field_choice = EV_FORM_FIELD_CHOICE (field);
2115                 GdkRegion         *field_region;
2116
2117                 field_region = ev_view_form_field_get_region (view, field);
2118
2119                 if (field_choice->is_editable) {
2120                         ev_document_forms_form_field_choice_set_text (EV_DOCUMENT_FORMS (view->document),
2121                                                                       field, field_choice->text);
2122                 } else {
2123                         ev_document_forms_form_field_choice_unselect_all (EV_DOCUMENT_FORMS (view->document), field);
2124                         for (l = field_choice->selected_items; l; l = g_list_next (l)) {
2125                                 ev_document_forms_form_field_choice_select_item (EV_DOCUMENT_FORMS (view->document),
2126                                                                                  field,
2127                                                                                  GPOINTER_TO_INT (l->data));
2128                         }
2129                 }
2130                 field->changed = FALSE;
2131                 ev_view_reload_page (view, field->page->index, field_region);
2132                 gdk_region_destroy (field_region);
2133         }
2134 }
2135
2136 static void
2137 ev_view_form_field_choice_changed (GtkWidget   *widget,
2138                                    EvFormField *field)
2139 {
2140         EvFormFieldChoice *field_choice = EV_FORM_FIELD_CHOICE (field);
2141
2142         if (GTK_IS_COMBO_BOX (widget)) {
2143                 gint item;
2144
2145                 item = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
2146                 if (!field_choice->selected_items ||
2147                     GPOINTER_TO_INT (field_choice->selected_items->data) != item) {
2148                         g_list_free (field_choice->selected_items);
2149                         field_choice->selected_items = NULL;
2150                         field_choice->selected_items = g_list_prepend (field_choice->selected_items,
2151                                                                        GINT_TO_POINTER (item));
2152                         field->changed = TRUE;
2153                 }
2154
2155                 if (GTK_IS_COMBO_BOX_ENTRY (widget)) {
2156                         gchar *text;
2157
2158                         text = gtk_combo_box_get_active_text (GTK_COMBO_BOX (widget));
2159                         if (!field_choice->text ||
2160                             (field_choice->text && g_ascii_strcasecmp (field_choice->text, text) != 0)) {
2161                                 g_free (field_choice->text);
2162                                 field_choice->text = text;
2163                                 field->changed = TRUE;
2164                         }
2165                 }
2166         } else if (GTK_IS_TREE_SELECTION (widget)) {
2167                 GtkTreeSelection *selection = GTK_TREE_SELECTION (widget);
2168                 GtkTreeModel     *model;
2169                 GList            *items, *l;
2170
2171                 items = gtk_tree_selection_get_selected_rows (selection, &model);
2172                 g_list_free (field_choice->selected_items);
2173                 field_choice->selected_items = NULL;
2174
2175                 for (l = items; l && l->data; l = g_list_next (l)) {
2176                         GtkTreeIter  iter;
2177                         GtkTreePath *path = (GtkTreePath *)l->data;
2178                         gint         item;
2179
2180                         gtk_tree_model_get_iter (model, &iter, path);
2181                         gtk_tree_model_get (model, &iter, 1, &item, -1);
2182
2183                         field_choice->selected_items = g_list_prepend (field_choice->selected_items,
2184                                                                        GINT_TO_POINTER (item));
2185
2186                         gtk_tree_path_free (path);
2187                 }
2188
2189                 g_list_free (items);
2190
2191                 field->changed = TRUE;
2192         }
2193 }
2194
2195 static GtkWidget *
2196 ev_view_form_field_choice_create_widget (EvView      *view,
2197                                          EvFormField *field)
2198 {
2199         EvFormFieldChoice *field_choice = EV_FORM_FIELD_CHOICE (field);
2200         GtkWidget         *choice;
2201         GtkTreeModel      *model;
2202         gint               n_items, i;
2203         gint               selected_item = 0;
2204
2205         n_items = ev_document_forms_form_field_choice_get_n_items (EV_DOCUMENT_FORMS (view->document),
2206                                                                    field);
2207         model = GTK_TREE_MODEL (gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT));
2208         for (i = 0; i < n_items; i++) {
2209                 GtkTreeIter iter;
2210                 gchar      *item;
2211
2212                 item = ev_document_forms_form_field_choice_get_item (EV_DOCUMENT_FORMS (view->document),
2213                                                                      field, i);
2214                 if (ev_document_forms_form_field_choice_is_item_selected (
2215                             EV_DOCUMENT_FORMS (view->document), field, i)) {
2216                         selected_item = i;
2217                         /* FIXME: we need a get_selected_items function in poppler */
2218                         field_choice->selected_items = g_list_prepend (field_choice->selected_items,
2219                                                                        GINT_TO_POINTER (i));
2220                 }
2221
2222                 if (item) {
2223                         gtk_list_store_append (GTK_LIST_STORE (model), &iter);
2224                         gtk_list_store_set (GTK_LIST_STORE (model), &iter,
2225                                             0, item,
2226                                             1, i,
2227                                             -1);
2228                         g_free (item);
2229                 }
2230         }
2231
2232         if (field_choice->type == EV_FORM_FIELD_CHOICE_LIST) {
2233                 GtkCellRenderer  *renderer;
2234                 GtkWidget        *tree_view;
2235                 GtkTreeSelection *selection;
2236
2237                 tree_view = gtk_tree_view_new_with_model (model);
2238                 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);
2239
2240                 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
2241                 if (field_choice->multi_select) {
2242                         gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
2243                 }
2244
2245                 /* TODO: set selected items */
2246
2247                 renderer = gtk_cell_renderer_text_new ();
2248                 gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view),
2249                                                              0,
2250                                                              "choix", renderer,
2251                                                              "text", 0,
2252                                                              NULL);
2253
2254                 choice = gtk_scrolled_window_new (NULL, NULL);
2255                 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (choice),
2256                                                 GTK_POLICY_AUTOMATIC,
2257                                                 GTK_POLICY_AUTOMATIC);
2258                 gtk_container_add (GTK_CONTAINER (choice), tree_view);
2259                 gtk_widget_show (tree_view);
2260
2261                 g_signal_connect (selection, "changed",
2262                                   G_CALLBACK (ev_view_form_field_choice_changed),
2263                                   field);
2264                 g_signal_connect_after (selection, "changed",
2265                                         G_CALLBACK (ev_view_form_field_destroy),
2266                                         view);
2267         } else if (field_choice->is_editable) { /* ComboBoxEntry */
2268                 gchar *text;
2269
2270                 choice = gtk_combo_box_entry_new_with_model (model, 0);
2271                 text = ev_document_forms_form_field_choice_get_text (EV_DOCUMENT_FORMS (view->document), field);
2272                 if (text) {
2273                         gtk_entry_set_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (choice))), text);
2274                         g_free (text);
2275                 }
2276
2277                 g_signal_connect (choice, "changed",
2278                                   G_CALLBACK (ev_view_form_field_choice_changed),
2279                                   field);
2280                 g_signal_connect_after (GTK_BIN(choice)->child, "activate",
2281                                         G_CALLBACK (ev_view_form_field_destroy),
2282                                         view);
2283         } else { /* ComboBoxText */
2284                 GtkCellRenderer *renderer;
2285
2286                 choice = gtk_combo_box_new_with_model (model);
2287                 renderer = gtk_cell_renderer_text_new ();
2288                 gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (choice),
2289                                             renderer, TRUE);
2290                 gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (choice),
2291                                                 renderer,
2292                                                 "text", 0,
2293                                                 NULL);
2294                 gtk_combo_box_set_active (GTK_COMBO_BOX (choice), selected_item);
2295                 gtk_combo_box_popup (GTK_COMBO_BOX (choice));
2296
2297                 g_signal_connect (choice, "changed",
2298                                   G_CALLBACK (ev_view_form_field_choice_changed),
2299                                   field);
2300                 g_signal_connect_after (choice, "changed",
2301                                         G_CALLBACK (ev_view_form_field_destroy),
2302                                         view);
2303         }
2304
2305         g_object_unref (model);
2306
2307         g_object_weak_ref (G_OBJECT (choice),
2308                            (GWeakNotify)ev_view_form_field_choice_save,
2309                            view);
2310
2311         return choice;
2312 }
2313
2314 static void
2315 ev_view_handle_form_field (EvView      *view,
2316                            EvFormField *field,
2317                            gdouble      x,
2318                            gdouble      y)
2319 {
2320         GtkWidget   *field_widget = NULL;
2321         GList       *form_field_mapping;
2322         GdkRectangle view_area;
2323
2324         if (field->is_read_only)
2325                 return;
2326
2327         if (EV_IS_FORM_FIELD_BUTTON (field)) {
2328                 field_widget = ev_view_form_field_button_create_widget (view, field);
2329         } else if (EV_IS_FORM_FIELD_TEXT (field)) {
2330                 field_widget = ev_view_form_field_text_create_widget (view, field);
2331         } else if (EV_IS_FORM_FIELD_CHOICE (field)) {
2332                 field_widget = ev_view_form_field_choice_create_widget (view, field);
2333         } else if (EV_IS_FORM_FIELD_SIGNATURE (field)) {
2334                 /* TODO */
2335         }
2336
2337         /* Form field doesn't require a widget */
2338         if (!field_widget)
2339                 return;
2340
2341         g_object_set_data_full (G_OBJECT (field_widget), "form-field",
2342                                 g_object_ref (field),
2343                                 (GDestroyNotify)g_object_unref);
2344
2345         form_field_mapping = ev_page_cache_get_form_field_mapping (view->page_cache,
2346                                                                    field->page->index);
2347         ev_view_get_area_from_mapping (view, field->page->index,
2348                                        form_field_mapping,
2349                                        field, &view_area);
2350
2351         gtk_layout_put (GTK_LAYOUT (view), field_widget, view_area.x, view_area.y);
2352         gtk_widget_show (field_widget);
2353         gtk_widget_grab_focus (field_widget);
2354 }
2355
2356 /* Annotations */
2357 static EvViewWindowChild *
2358 ev_view_get_window_child (EvView    *view,
2359                           GtkWidget *window)
2360 {
2361         GList *children = view->window_children;
2362
2363         while (children) {
2364                 EvViewWindowChild *child;
2365
2366                 child = (EvViewWindowChild *)children->data;
2367                 children = children->next;
2368
2369                 if (child->window == window)
2370                         return child;
2371         }
2372
2373         return NULL;
2374 }
2375
2376 static void
2377 ev_view_window_child_move (EvView            *view,
2378                            EvViewWindowChild *child,
2379                            gint               x,
2380                            gint               y)
2381 {
2382         child->x = x;
2383         child->y = y;
2384         gtk_window_move (GTK_WINDOW (child->window),
2385                          MAX (child->parent_x, x),
2386                          MAX (child->parent_y, y));
2387 }
2388
2389 static void
2390 ev_view_window_child_move_with_parent (EvView    *view,
2391                                        GtkWidget *window)
2392 {
2393         EvViewWindowChild *child;
2394         gint               root_x, root_y;
2395
2396         child = ev_view_get_window_child (view, window);
2397         gdk_window_get_origin (gtk_widget_get_window (GTK_WIDGET (view)),
2398                                &root_x, &root_y);
2399         if (root_x != child->parent_x || root_y != child->parent_y) {
2400                 gint dest_x, dest_y;
2401
2402                 dest_x = child->x + (root_x - child->parent_x);
2403                 dest_y = child->y + (root_y - child->parent_y);
2404                 child->parent_x = root_x;
2405                 child->parent_y = root_y;
2406                 ev_view_window_child_move (view, child, dest_x, dest_y);
2407         }
2408
2409         if (child->visible && !GTK_WIDGET_VISIBLE (window))
2410                 gtk_widget_show (window);
2411 }
2412
2413 static void
2414 ev_view_window_child_put (EvView    *view,
2415                           GtkWidget *window,
2416                           guint      page,
2417                           gint       x,
2418                           gint       y,
2419                           gdouble    orig_x,
2420                           gdouble    orig_y)
2421 {
2422         EvViewWindowChild *child;
2423         gint               root_x, root_y;
2424
2425         gdk_window_get_origin (gtk_widget_get_window (GTK_WIDGET (view)),
2426                                &root_x, &root_y);
2427
2428         child = g_new0 (EvViewWindowChild, 1);
2429         child->window = window;
2430         child->page = page;
2431         child->orig_x = orig_x;
2432         child->orig_y = orig_y;
2433         child->parent_x = root_x;
2434         child->parent_y = root_y;
2435         child->visible = ev_annotation_window_is_open (EV_ANNOTATION_WINDOW (window));
2436         ev_view_window_child_move (view, child, x + root_x, y + root_y);
2437
2438         if (child->visible)
2439                 gtk_widget_show (window);
2440         else
2441                 gtk_widget_hide (window);
2442
2443         view->window_children = g_list_append (view->window_children, child);
2444 }
2445
2446 static EvViewWindowChild *
2447 ev_view_find_window_child_for_annot (EvView       *view,
2448                                      guint         page,
2449                                      EvAnnotation *annot)
2450 {
2451         GList *children = view->window_children;
2452
2453         while (children) {
2454                 EvViewWindowChild *child;
2455                 EvAnnotation      *wannot;
2456
2457                 child = (EvViewWindowChild *)children->data;
2458                 children = children->next;
2459
2460                 if (child->page != page)
2461                         continue;
2462
2463                 wannot = ev_annotation_window_get_annotation (EV_ANNOTATION_WINDOW (child->window));
2464                 if (wannot == annot || strcmp (wannot->name, annot->name) == 0)
2465                         return child;
2466         }
2467
2468         return NULL;
2469 }
2470
2471 static void
2472 ev_view_window_children_free (EvView *view)
2473 {
2474         GList *l;
2475
2476         if (!view->window_children)
2477                 return;
2478
2479         for (l = view->window_children; l && l->data; l = g_list_next (l)) {
2480                 EvViewWindowChild *child;
2481
2482                 child = (EvViewWindowChild *)l->data;
2483                 gtk_widget_destroy (GTK_WIDGET (child->window));
2484                 g_free (child);
2485         }
2486         g_list_free (view->window_children);
2487         view->window_children = NULL;
2488         view->window_child_focus = NULL;
2489 }
2490
2491 static void
2492 annotation_window_grab_focus (GtkWidget *widget,
2493                               EvView    *view)
2494 {
2495         if (view->window_child_focus)
2496                 ev_annotation_window_ungrab_focus (EV_ANNOTATION_WINDOW (view->window_child_focus->window));
2497         view->window_child_focus = ev_view_get_window_child (view, widget);
2498 }
2499
2500 static void
2501 annotation_window_closed (EvAnnotationWindow *window,
2502                           EvView             *view)
2503 {
2504         EvViewWindowChild *child;
2505
2506         child = ev_view_get_window_child (view, GTK_WIDGET (window));
2507         child->visible = FALSE;
2508 }
2509
2510 static void
2511 annotation_window_moved (EvAnnotationWindow *window,
2512                          gint                x,
2513                          gint                y,
2514                          EvView             *view)
2515 {
2516         EvViewWindowChild *child;
2517         GdkRectangle       page_area;
2518         GtkBorder          border;
2519         GdkRectangle       view_rect;
2520         EvRectangle        doc_rect;
2521         gint               width, height;
2522
2523         child = ev_view_get_window_child (view, GTK_WIDGET (window));
2524         if (child->x == x && child->y == y)
2525                 return;
2526
2527         child->moved = TRUE;
2528         child->x = x;
2529         child->y = y;
2530
2531         /* Window has been moved by the user,
2532          * we have to set a new origin in doc coords
2533          */
2534         gtk_window_get_size (GTK_WINDOW (window), &width, &height);
2535         view_rect.x = (x - child->parent_x) + view->scroll_x;
2536         view_rect.y = (y - child->parent_y) + view->scroll_y;
2537         view_rect.width = width;
2538         view_rect.height = height;
2539
2540         get_page_extents (view, child->page, &page_area, &border);
2541         view_rect_to_doc_rect (view, &view_rect, &page_area, &doc_rect);
2542         child->orig_x = doc_rect.x1;
2543         child->orig_y = doc_rect.y1;
2544 }
2545
2546 static void
2547 ev_view_annotation_save (EvView       *view,
2548                          EvAnnotation *annot)
2549 {
2550         if (!view->document)
2551                 return;
2552
2553         if (!annot->changed)
2554                 return;
2555
2556         ev_document_annotations_annotation_set_contents (EV_DOCUMENT_ANNOTATIONS (view->document),
2557                                                          annot, annot->contents);
2558         annot->changed = FALSE;
2559 }
2560
2561 static void
2562 show_annotation_windows (EvView *view,
2563                          gint    page)
2564 {
2565         GList     *annots, *l;
2566         GtkWindow *parent;
2567
2568         parent = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (view)));
2569
2570         annots = ev_page_cache_get_annot_mapping (view->page_cache, page);
2571
2572         for (l = annots; l && l->data; l = g_list_next (l)) {
2573                 EvAnnotation      *annot;
2574                 EvViewWindowChild *child;
2575                 GtkWidget         *window;
2576                 EvRectangle       *doc_rect;
2577                 GdkRectangle       view_rect;
2578
2579                 annot = ((EvMapping *)(l->data))->data;
2580
2581                 if (!EV_IS_ANNOTATION_MARKUP (annot))
2582                         continue;
2583
2584                 if (!ev_annotation_markup_has_popup (EV_ANNOTATION_MARKUP (annot)))
2585                         continue;
2586
2587                 window = g_object_get_data (G_OBJECT (annot), "popup");
2588                 if (window) {
2589                         ev_view_window_child_move_with_parent (view, window);
2590                         continue;
2591                 }
2592
2593                 /* Look if we already have a popup for this annot */
2594                 child = ev_view_find_window_child_for_annot (view, page, annot);
2595                 window = child ? child->window : NULL;
2596                 if (window) {
2597                         ev_annotation_window_set_annotation (EV_ANNOTATION_WINDOW (window), annot);
2598                         g_object_set_data (G_OBJECT (annot), "popup", window);
2599                         ev_view_window_child_move_with_parent (view, window);
2600                 } else {
2601                         window = ev_annotation_window_new (annot, parent);
2602                         g_signal_connect (window, "grab_focus",
2603                                           G_CALLBACK (annotation_window_grab_focus),
2604                                           view);
2605                         g_signal_connect (window, "closed",
2606                                           G_CALLBACK (annotation_window_closed),
2607                                           view);
2608                         g_signal_connect (window, "moved",
2609                                           G_CALLBACK (annotation_window_moved),
2610                                           view);
2611                         g_object_set_data (G_OBJECT (annot), "popup", window);
2612
2613                         doc_rect = (EvRectangle *)ev_annotation_window_get_rectangle (EV_ANNOTATION_WINDOW (window));
2614                         doc_rect_to_view_rect (view, page, doc_rect, &view_rect);
2615                         view_rect.x -= view->scroll_x;
2616                         view_rect.y -= view->scroll_y;
2617
2618                         ev_view_window_child_put (view, window, page,
2619                                                   view_rect.x, view_rect.y,
2620                                                   doc_rect->x1, doc_rect->y1);
2621
2622                         g_object_weak_ref (G_OBJECT (annot),
2623                                            (GWeakNotify)ev_view_annotation_save,
2624                                            view);
2625                 }
2626         }
2627 }
2628
2629 static void
2630 hide_annotation_windows (EvView *view,
2631                          gint    page)
2632 {
2633         GList *annots, *l;
2634
2635         annots = ev_page_cache_get_annot_mapping (view->page_cache, page);
2636
2637         for (l = annots; l && l->data; l = g_list_next (l)) {
2638                 EvAnnotation *annot;
2639                 GtkWidget    *window;
2640
2641                 annot = ((EvMapping *)(l->data))->data;
2642
2643                 if (!EV_IS_ANNOTATION_MARKUP (annot))
2644                         continue;
2645
2646                 window = g_object_get_data (G_OBJECT (annot), "popup");
2647                 if (window)
2648                         gtk_widget_hide (window);
2649         }
2650 }
2651
2652 static EvAnnotation *
2653 ev_view_get_annotation_at_location (EvView  *view,
2654                                     gdouble  x,
2655                                     gdouble  y)
2656 {
2657         gint page = -1;
2658         gint x_new = 0, y_new = 0;
2659         GList *annotations_mapping;
2660
2661         if (!EV_IS_DOCUMENT_ANNOTATIONS (view->document))
2662                 return NULL;
2663
2664         if (!get_doc_point_from_location (view, x, y, &page, &x_new, &y_new))
2665                 return NULL;
2666
2667         annotations_mapping = ev_page_cache_get_annot_mapping (view->page_cache, page);
2668
2669         if (annotations_mapping)
2670                 return ev_mapping_list_get_data (annotations_mapping, x_new, y_new);
2671         else
2672                 return NULL;
2673 }
2674
2675 static void
2676 ev_view_handle_annotation (EvView       *view,
2677                            EvAnnotation *annot,
2678                            gdouble       x,
2679                            gdouble       y,
2680                            guint32       timestamp)
2681 {
2682         if (EV_IS_ANNOTATION_MARKUP (annot)) {
2683                 GtkWidget *window;
2684
2685                 window = g_object_get_data (G_OBJECT (annot), "popup");
2686                 if (window) {
2687                         EvViewWindowChild *child;
2688
2689                         child = ev_view_get_window_child (view, window);
2690                         if (!child->visible) {
2691                                 child->visible = TRUE;
2692                                 ev_view_window_child_move (view, child, child->x, child->y);
2693                                 gtk_widget_show (window);
2694                         }
2695                 }
2696         }
2697
2698         if (EV_IS_ANNOTATION_ATTACHMENT (annot)) {
2699                 EvAttachment *attachment = EV_ANNOTATION_ATTACHMENT (annot)->attachment;
2700
2701                 if (attachment) {
2702                         GError *error = NULL;
2703
2704                         ev_attachment_open (attachment,
2705                                             gtk_widget_get_screen (GTK_WIDGET (view)),
2706                                             timestamp,
2707                                             &error);
2708
2709                         if (error) {
2710                                 g_warning ("%s", error->message);
2711                                 g_error_free (error);
2712                         }
2713                 }
2714         }
2715 }
2716
2717 /*** GtkWidget implementation ***/
2718
2719 static void
2720 ev_view_size_request_continuous_dual_page (EvView         *view,
2721                                            GtkRequisition *requisition)
2722 {
2723         gint n_pages;
2724
2725         n_pages = ev_document_get_n_pages (view->document) + 1;
2726         get_page_y_offset (view, n_pages, &requisition->height);
2727
2728         switch (view->sizing_mode) {
2729                 case EV_SIZING_FIT_WIDTH:
2730                 case EV_SIZING_BEST_FIT:
2731                         requisition->width = 1;
2732
2733                         break;
2734                 case EV_SIZING_FREE: {
2735                         gint max_width;
2736                         GtkBorder border;
2737
2738                         ev_view_get_max_page_size (view, &max_width, NULL);
2739                         compute_border (view, max_width, max_width, &border);
2740                         requisition->width = (max_width + border.left + border.right) * 2 + (view->spacing * 3);
2741                 }
2742                         break;
2743                 default:
2744                         g_assert_not_reached ();
2745         }
2746 }
2747
2748 static void
2749 ev_view_size_request_continuous (EvView         *view,
2750                                  GtkRequisition *requisition)
2751 {
2752         gint n_pages;
2753
2754         n_pages = ev_document_get_n_pages (view->document);
2755         get_page_y_offset (view, n_pages, &requisition->height);
2756
2757         switch (view->sizing_mode) {
2758                 case EV_SIZING_FIT_WIDTH:
2759                 case EV_SIZING_BEST_FIT:
2760                         requisition->width = 1;
2761
2762                         break;
2763                 case EV_SIZING_FREE: {
2764                         gint max_width;
2765                         GtkBorder border;
2766
2767                         ev_view_get_max_page_size (view, &max_width, NULL);
2768                         compute_border (view, max_width, max_width, &border);
2769                         requisition->width = max_width + (view->spacing * 2) + border.left + border.right;
2770                 }
2771                         break;
2772                 default:
2773                         g_assert_not_reached ();
2774         }
2775 }
2776
2777 static void
2778 ev_view_size_request_dual_page (EvView         *view,
2779                                 GtkRequisition *requisition)
2780 {
2781         GtkBorder border;
2782         gint width, height;
2783
2784         if (view->sizing_mode == EV_SIZING_BEST_FIT) {
2785                 requisition->width = 1;
2786                 requisition->height = 1;
2787
2788                 return;
2789         }
2790
2791         /* Find the largest of the two. */
2792         ev_view_get_page_size (view,
2793                                view->current_page,
2794                                &width, &height);
2795         if (view->current_page + 1 < ev_document_get_n_pages (view->document)) {
2796                 gint width_2, height_2;
2797                 ev_view_get_page_size (view,
2798                                        view->current_page + 1,
2799                                        &width_2, &height_2);
2800                 if (width_2 > width) {
2801                         width = width_2;
2802                         height = height_2;
2803                 }
2804         }
2805         compute_border (view, width, height, &border);
2806
2807         requisition->width = view->sizing_mode == EV_SIZING_FIT_WIDTH ? 1 :
2808                 ((width + border.left + border.right) * 2) + (view->spacing * 3);
2809         requisition->height = (height + border.top + border.bottom) + (view->spacing * 2);
2810 }
2811
2812 static void
2813 ev_view_size_request_single_page (EvView         *view,
2814                                   GtkRequisition *requisition)
2815 {
2816         GtkBorder border;
2817         gint width, height;
2818
2819         if (view->sizing_mode == EV_SIZING_BEST_FIT) {
2820                 requisition->width = 1;
2821                 requisition->height = 1;
2822
2823                 return;
2824         }
2825
2826         ev_view_get_page_size (view, view->current_page, &width, &height);
2827         compute_border (view, width, height, &border);
2828
2829         requisition->width = view->sizing_mode == EV_SIZING_FIT_WIDTH ? 1 :
2830                 width + border.left + border.right + (2 * view->spacing);
2831         requisition->height = height + border.top + border.bottom + (2 * view->spacing);
2832 }
2833
2834 static void
2835 ev_view_size_request (GtkWidget      *widget,
2836                       GtkRequisition *requisition)
2837 {
2838         EvView *view = EV_VIEW (widget);
2839
2840         if (view->document == NULL) {
2841                 requisition->width = 1;
2842                 requisition->height = 1;
2843                 return;
2844         }
2845
2846         if (view->continuous && view->dual_page)
2847                 ev_view_size_request_continuous_dual_page (view, requisition);
2848         else if (view->continuous)
2849                 ev_view_size_request_continuous (view, requisition);
2850         else if (view->dual_page)
2851                 ev_view_size_request_dual_page (view, requisition);
2852         else
2853                 ev_view_size_request_single_page (view, requisition);
2854 }
2855
2856 static void
2857 ev_view_size_allocate (GtkWidget      *widget,
2858                        GtkAllocation  *allocation)
2859 {
2860         EvView *view = EV_VIEW (widget);
2861         GList  *children, *l;
2862         gint    root_x, root_y;
2863
2864         GTK_WIDGET_CLASS (ev_view_parent_class)->size_allocate (widget, allocation);
2865
2866         if (view->sizing_mode == EV_SIZING_FIT_WIDTH ||
2867             view->sizing_mode == EV_SIZING_BEST_FIT) {
2868                 ev_view_zoom_for_size (view,
2869                                        allocation->width,
2870                                        allocation->height);
2871                 ev_view_size_request (widget, &widget->requisition);
2872         }
2873
2874         view_set_adjustment_values (view, GTK_ORIENTATION_HORIZONTAL);
2875         view_set_adjustment_values (view, GTK_ORIENTATION_VERTICAL);
2876
2877         if (view->document)
2878                 view_update_range_and_current_page (view);
2879
2880         view->pending_scroll = SCROLL_TO_KEEP_POSITION;
2881         view->pending_resize = FALSE;
2882         view->pending_point.x = 0;
2883         view->pending_point.y = 0;
2884
2885         children = gtk_container_get_children (GTK_CONTAINER (widget));
2886         for (l = children; l && l->data; l = g_list_next (l)) {
2887                 EvFormField   *field;
2888                 GdkRectangle   view_area;
2889                 GList         *form_field_mapping;
2890                 GtkAllocation  child_allocation;
2891                 GtkRequisition child_requisition;
2892                 GtkWidget     *child = (GtkWidget *)l->data;
2893
2894                 field = g_object_get_data (G_OBJECT (child), "form-field");
2895                 if (!field)
2896                         continue;
2897
2898                 form_field_mapping = ev_page_cache_get_form_field_mapping (view->page_cache,
2899                                                                            field->page->index);
2900                 ev_view_get_area_from_mapping (view, field->page->index,
2901                                                form_field_mapping,
2902                                                field, &view_area);
2903
2904                 gtk_widget_size_request (child, &child_requisition);
2905                 if (child_requisition.width != view_area.width ||
2906                     child_requisition.height != view_area.height)
2907                         gtk_widget_set_size_request (child, view_area.width, view_area.height);
2908
2909                 gtk_container_child_get (GTK_CONTAINER (widget),
2910                                          child,
2911                                          "x", &child_allocation.x,
2912                                          "y", &child_allocation.y,
2913                                          NULL);
2914                 if (child_allocation.x != view_area.x ||
2915                     child_allocation.y != view_area.y) {
2916                         gtk_layout_move (GTK_LAYOUT (widget), child, view_area.x, view_area.y);
2917                 }
2918         }
2919         g_list_free (children);
2920
2921         if (view->window_children)
2922                 gdk_window_get_origin (gtk_widget_get_window (GTK_WIDGET (view)),
2923                                        &root_x, &root_y);
2924
2925         for (l = view->window_children; l && l->data; l = g_list_next (l)) {
2926                 EvViewWindowChild *child;
2927                 EvRectangle        doc_rect;
2928                 GdkRectangle       view_rect;
2929
2930                 child = (EvViewWindowChild *)l->data;
2931
2932                 doc_rect = *ev_annotation_window_get_rectangle (EV_ANNOTATION_WINDOW (child->window));
2933                 if (child->moved) {
2934                         doc_rect.x1 = child->orig_x;
2935                         doc_rect.y1 = child->orig_y;
2936                 }
2937                 doc_rect_to_view_rect (view, child->page, &doc_rect, &view_rect);
2938                 view_rect.x -= view->scroll_x;
2939                 view_rect.y -= view->scroll_y;
2940
2941                 if (view_rect.x != child->orig_x || view_rect.y != child->orig_y) {
2942                         child->parent_x = root_x;
2943                         child->parent_y = root_y;
2944                         ev_view_window_child_move (view, child, view_rect.x + root_x, view_rect.y + root_y);
2945                 }
2946         }
2947 }
2948
2949 static void
2950 ev_view_realize (GtkWidget *widget)
2951 {
2952         EvView *view = EV_VIEW (widget);
2953
2954         if (GTK_WIDGET_CLASS (ev_view_parent_class)->realize)
2955                 (* GTK_WIDGET_CLASS (ev_view_parent_class)->realize) (widget);
2956
2957         gdk_window_set_events (view->layout.bin_window,
2958                                (gdk_window_get_events (view->layout.bin_window) |
2959                                 GDK_EXPOSURE_MASK |
2960                                 GDK_BUTTON_PRESS_MASK |
2961                                 GDK_BUTTON_RELEASE_MASK |
2962                                 GDK_SCROLL_MASK |
2963                                 GDK_KEY_PRESS_MASK |
2964                                 GDK_POINTER_MOTION_MASK |
2965                                 GDK_POINTER_MOTION_HINT_MASK |
2966                                 GDK_ENTER_NOTIFY_MASK |
2967                                 GDK_LEAVE_NOTIFY_MASK));
2968
2969         gdk_window_set_background (view->layout.bin_window, &widget->style->mid [GTK_STATE_NORMAL]);
2970
2971         on_adjustment_value_changed (NULL, view);
2972 }
2973
2974 static gboolean
2975 ev_view_scroll_event (GtkWidget *widget, GdkEventScroll *event)
2976 {
2977         EvView *view = EV_VIEW (widget);
2978         guint state;
2979
2980         state = event->state & gtk_accelerator_get_default_mod_mask ();
2981
2982         if (state == GDK_CONTROL_MASK) {
2983                 ev_document_model_set_sizing_mode (view->model, EV_SIZING_FREE);
2984                 if (event->direction == GDK_SCROLL_UP ||
2985                     event->direction == GDK_SCROLL_LEFT) {
2986                         if (ev_view_can_zoom_in (view)) {
2987                                 ev_view_zoom_in (view);
2988                         }
2989                 } else {
2990                         if (ev_view_can_zoom_out (view)) {
2991                                 ev_view_zoom_out (view);
2992                         }
2993                 }
2994
2995                 return TRUE;
2996         }
2997
2998         view->jump_to_find_result = FALSE;
2999
3000         /* Shift+Wheel scrolls the in the perpendicular direction */
3001         if (state & GDK_SHIFT_MASK) {
3002                 if (event->direction == GDK_SCROLL_UP)
3003                         event->direction = GDK_SCROLL_LEFT;
3004                 else if (event->direction == GDK_SCROLL_LEFT)
3005                         event->direction = GDK_SCROLL_UP;
3006                 else if (event->direction == GDK_SCROLL_DOWN)
3007                         event->direction = GDK_SCROLL_RIGHT;
3008                 else if (event->direction == GDK_SCROLL_RIGHT)
3009                         event->direction = GDK_SCROLL_DOWN;
3010
3011                 event->state &= ~GDK_SHIFT_MASK;
3012                 state &= ~GDK_SHIFT_MASK;
3013         }
3014
3015         if (state == 0 && view->sizing_mode == EV_SIZING_BEST_FIT && !view->continuous) {
3016                 switch (event->direction) {
3017                         case GDK_SCROLL_DOWN:
3018                         case GDK_SCROLL_RIGHT:
3019                                 ev_view_next_page (view);
3020                                 break;
3021                         case GDK_SCROLL_UP:
3022                         case GDK_SCROLL_LEFT:
3023                                 ev_view_previous_page (view);
3024                                 break;
3025                 }
3026
3027                 return TRUE;
3028         }
3029
3030         return FALSE;
3031 }
3032
3033 static EvViewSelection *
3034 find_selection_for_page (EvView *view,
3035                          gint    page)
3036 {
3037         GList *list;
3038
3039         for (list = view->selection_info.selections; list != NULL; list = list->next) {
3040                 EvViewSelection *selection;
3041
3042                 selection = (EvViewSelection *) list->data;
3043
3044                 if (selection->page == page)
3045                         return selection;
3046         }
3047
3048         return NULL;
3049 }
3050
3051 static gboolean
3052 ev_view_expose_event (GtkWidget      *widget,
3053                       GdkEventExpose *event)
3054 {
3055         EvView  *view = EV_VIEW (widget);
3056         cairo_t *cr;
3057         gint     i;
3058
3059         if (view->loading) {
3060                 GdkRectangle area = {0};
3061
3062                 area.width = widget->allocation.width;
3063                 area.height = widget->allocation.height;
3064
3065                 draw_loading_text (view,
3066                                    &area,
3067                                    &(event->area));
3068         }
3069
3070         if (view->document == NULL)
3071                 return FALSE;
3072
3073         cr = gdk_cairo_create (view->layout.bin_window);
3074
3075         for (i = view->start_page; i >= 0 && i <= view->end_page; i++) {
3076                 GdkRectangle page_area;
3077                 GtkBorder border;
3078                 gboolean page_ready = TRUE;
3079
3080                 if (!get_page_extents (view, i, &page_area, &border))
3081                         continue;
3082
3083                 page_area.x -= view->scroll_x;
3084                 page_area.y -= view->scroll_y;
3085
3086                 draw_one_page (view, i, cr, &page_area, &border, &(event->area), &page_ready);
3087
3088                 if (page_ready && view->find_pages && view->highlight_find_results)
3089                         highlight_find_results (view, i);
3090                 if (page_ready && EV_IS_DOCUMENT_ANNOTATIONS (view->document))
3091                         show_annotation_windows (view, i);
3092         }
3093
3094         cairo_destroy (cr);
3095
3096         if (GTK_WIDGET_CLASS (ev_view_parent_class)->expose_event)
3097                 (* GTK_WIDGET_CLASS (ev_view_parent_class)->expose_event) (widget, event);
3098
3099         return FALSE;
3100 }
3101
3102 static gboolean
3103 ev_view_do_popup_menu (EvView *view,
3104                        gdouble x,
3105                        gdouble y)
3106 {
3107         EvLink       *link;
3108         EvImage      *image;
3109         EvAnnotation *annot;
3110
3111         image = ev_view_get_image_at_location (view, x, y);
3112         if (image) {
3113                 g_signal_emit (view, signals[SIGNAL_POPUP_MENU], 0, image);
3114                 return TRUE;
3115         }
3116
3117         link = ev_view_get_link_at_location (view, x, y);
3118         if (link) {
3119                 g_signal_emit (view, signals[SIGNAL_POPUP_MENU], 0, link);
3120                 return TRUE;
3121         }
3122
3123         annot = ev_view_get_annotation_at_location (view, x, y);
3124         if (annot) {
3125                 g_signal_emit (view, signals[SIGNAL_POPUP_MENU], 0, annot);
3126                 return TRUE;
3127         }
3128
3129         g_signal_emit (view, signals[SIGNAL_POPUP_MENU], 0, NULL);
3130
3131         return TRUE;
3132 }
3133
3134 static gboolean
3135 ev_view_popup_menu (GtkWidget *widget)
3136 {
3137         gint x, y;
3138
3139         gtk_widget_get_pointer (widget, &x, &y);
3140         return ev_view_do_popup_menu (EV_VIEW (widget), x, y);
3141 }
3142
3143 static void
3144 get_link_area (EvView       *view,
3145                gint          x,
3146                gint          y,
3147                EvLink       *link,
3148                GdkRectangle *area)
3149 {
3150         GList *link_mapping;
3151         gint   page;
3152         gint   x_offset = 0, y_offset = 0;
3153
3154         x += view->scroll_x;
3155         y += view->scroll_y;
3156
3157         find_page_at_location (view, x, y, &page, &x_offset, &y_offset);
3158
3159         link_mapping = ev_page_cache_get_link_mapping (view->page_cache, page);
3160         ev_view_get_area_from_mapping (view, page,
3161                                        link_mapping,
3162                                        link, area);
3163 }
3164
3165 static void
3166 get_annot_area (EvView       *view,
3167                gint          x,
3168                gint          y,
3169                EvAnnotation *annot,
3170                GdkRectangle *area)
3171 {
3172         GList *annot_mapping;
3173         gint   page;
3174         gint   x_offset = 0, y_offset = 0;
3175
3176         x += view->scroll_x;
3177         y += view->scroll_y;
3178
3179         find_page_at_location (view, x, y, &page, &x_offset, &y_offset);
3180
3181         annot_mapping = ev_page_cache_get_annot_mapping (view->page_cache, page);
3182         ev_view_get_area_from_mapping (view, page,
3183                                        annot_mapping,
3184                                        annot, area);
3185 }
3186
3187 static gboolean
3188 ev_view_query_tooltip (GtkWidget  *widget,
3189                        gint        x,
3190                        gint        y,
3191                        gboolean    keyboard_tip,
3192                        GtkTooltip *tooltip)
3193 {
3194         EvView       *view = EV_VIEW (widget);
3195         EvLink       *link;
3196         EvAnnotation *annot;
3197         gchar        *text;
3198
3199         annot = ev_view_get_annotation_at_location (view, x, y);
3200         if (annot && annot->contents) {
3201                 GdkRectangle annot_area;
3202
3203                 get_annot_area (view, x, y, annot, &annot_area);
3204                 gtk_tooltip_set_text (tooltip, annot->contents);
3205                 gtk_tooltip_set_tip_area (tooltip, &annot_area);
3206
3207                 return TRUE;
3208         }
3209
3210         link = ev_view_get_link_at_location (view, x, y);
3211         if (!link)
3212                 return FALSE;
3213
3214         text = tip_from_link (view, link);
3215         if (text && g_utf8_validate (text, -1, NULL)) {
3216                 GdkRectangle link_area;
3217
3218                 get_link_area (view, x, y, link, &link_area);
3219                 gtk_tooltip_set_text (tooltip, text);
3220                 gtk_tooltip_set_tip_area (tooltip, &link_area);
3221         }
3222         g_free (text);
3223
3224         return TRUE;
3225 }
3226
3227 static void
3228 start_selection_for_event (EvView         *view,
3229                            GdkEventButton *event)
3230 {
3231         clear_selection (view);
3232
3233         view->selection_info.start.x = event->x + view->scroll_x;
3234         view->selection_info.start.y = event->y + view->scroll_y;
3235
3236         switch (event->type) {
3237                 case GDK_2BUTTON_PRESS:
3238                         view->selection_info.style = EV_SELECTION_STYLE_WORD;
3239                         break;
3240                 case GDK_3BUTTON_PRESS:
3241                         view->selection_info.style = EV_SELECTION_STYLE_LINE;
3242                         break;
3243                 default:
3244                         view->selection_info.style = EV_SELECTION_STYLE_GLYPH;
3245                         return;
3246         }
3247
3248         /* In case of WORD or LINE, compute selections now */
3249         compute_selections (view,
3250                             view->selection_info.style,
3251                             &(view->selection_info.start),
3252                             &(view->selection_info.start));
3253 }
3254
3255 static gboolean
3256 ev_view_button_press_event (GtkWidget      *widget,
3257                             GdkEventButton *event)
3258 {
3259         EvView *view = EV_VIEW (widget);
3260
3261         if (!view->document)
3262                 return FALSE;
3263
3264         if (!GTK_WIDGET_HAS_FOCUS (widget)) {
3265                 gtk_widget_grab_focus (widget);
3266         }
3267
3268         if (view->window_child_focus) {
3269                 EvAnnotationWindow *window;
3270                 EvAnnotation       *annot;
3271
3272                 window = EV_ANNOTATION_WINDOW (view->window_child_focus->window);
3273                 annot = ev_annotation_window_get_annotation (window);
3274                 ev_annotation_window_ungrab_focus (window);
3275                 ev_view_annotation_save (view, annot);
3276                 view->window_child_focus = NULL;
3277         }
3278
3279         view->pressed_button = event->button;
3280         view->selection_info.in_drag = FALSE;
3281
3282         if (view->scroll_info.autoscrolling)
3283                 return TRUE;
3284
3285         switch (event->button) {
3286                 case 1: {
3287                         EvImage *image;
3288                         EvAnnotation *annot;
3289                         EvFormField *field;
3290
3291                         if (EV_IS_SELECTION (view->document) && view->selection_info.selections) {
3292                                 if (event->type == GDK_3BUTTON_PRESS) {
3293                                         start_selection_for_event (view, event);
3294                                 } else if (location_in_selected_text (view,
3295                                                                event->x + view->scroll_x,
3296                                                                event->y + view->scroll_y)) {
3297                                         view->selection_info.in_drag = TRUE;
3298                                 } else {
3299                                         start_selection_for_event (view, event);
3300                                 }
3301
3302                                 gtk_widget_queue_draw (widget);
3303                         } else if ((annot = ev_view_get_annotation_at_location (view, event->x, event->y))) {
3304                                 ev_view_handle_annotation (view, annot, event->x, event->y, event->time);
3305                         } else if ((field = ev_view_get_form_field_at_location (view, event->x, event->y))) {
3306                                 ev_view_remove_all (view);
3307                                 ev_view_handle_form_field (view, field, event->x, event->y);
3308                         } else if (!location_in_text (view, event->x + view->scroll_x, event->y + view->scroll_y) &&
3309                                    (image = ev_view_get_image_at_location (view, event->x, event->y))) {
3310                                 if (view->image_dnd_info.image)
3311                                         g_object_unref (view->image_dnd_info.image);
3312                                 view->image_dnd_info.image = g_object_ref (image);
3313                                 view->image_dnd_info.in_drag = TRUE;
3314
3315                                 view->image_dnd_info.start.x = event->x + view->scroll_x;
3316                                 view->image_dnd_info.start.y = event->y + view->scroll_y;
3317                         } else {
3318                                 ev_view_remove_all (view);
3319
3320                                 if (EV_IS_SELECTION (view->document))
3321                                         start_selection_for_event (view, event);
3322                         }
3323                 }
3324                         return TRUE;
3325                 case 2:
3326                         /* use root coordinates as reference point because
3327                          * scrolling changes window relative coordinates */
3328                         view->drag_info.start.x = event->x_root;
3329                         view->drag_info.start.y = event->y_root;
3330                         view->drag_info.hadj = gtk_adjustment_get_value (view->hadjustment);
3331                         view->drag_info.vadj = gtk_adjustment_get_value (view->vadjustment);
3332
3333                         ev_view_set_cursor (view, EV_VIEW_CURSOR_DRAG);
3334
3335                         return TRUE;
3336                 case 3:
3337                         view->scroll_info.start_y = event->y;
3338                         return ev_view_do_popup_menu (view, event->x, event->y);
3339         }
3340
3341         return FALSE;
3342 }
3343
3344 static void
3345 ev_view_remove_all (EvView *view)
3346 {
3347         GList *children, *child;
3348
3349         children = gtk_container_get_children (GTK_CONTAINER (view));
3350         for (child = children; child && child->data; child = g_list_next (child)) {
3351                 gtk_container_remove (GTK_CONTAINER (view),
3352                                       GTK_WIDGET (child->data));
3353         }
3354         g_list_free (children);
3355 }
3356
3357 /*** Drag and Drop ***/
3358 static void
3359 ev_view_drag_data_get (GtkWidget        *widget,
3360                        GdkDragContext   *context,
3361                        GtkSelectionData *selection_data,
3362                        guint             info,
3363                        guint             time)
3364 {
3365         EvView *view = EV_VIEW (widget);
3366
3367         switch (info) {
3368                 case TARGET_DND_TEXT:
3369                         if (EV_IS_SELECTION (view->document) &&
3370                             view->selection_info.selections) {
3371                                 gchar *text;
3372
3373                                 text = get_selected_text (view);
3374                                 gtk_selection_data_set_text (selection_data,
3375                                                              text,
3376                                                              strlen (text));
3377                                 g_free (text);
3378                         }
3379                         break;
3380                 case TARGET_DND_IMAGE:
3381                         if (view->image_dnd_info.image) {
3382                                 GdkPixbuf *pixbuf;
3383
3384                                 ev_document_doc_mutex_lock ();
3385                                 pixbuf = ev_document_images_get_image (EV_DOCUMENT_IMAGES (view->document),
3386                                                                        view->image_dnd_info.image);
3387                                 ev_document_doc_mutex_unlock ();
3388
3389                                 gtk_selection_data_set_pixbuf (selection_data, pixbuf);
3390                                 g_object_unref (pixbuf);
3391                         }
3392                         break;
3393                 case TARGET_DND_URI:
3394                         if (view->image_dnd_info.image) {
3395                                 GdkPixbuf   *pixbuf;
3396                                 const gchar *tmp_uri;
3397                                 gchar       *uris[2];
3398
3399                                 ev_document_doc_mutex_lock ();
3400                                 pixbuf = ev_document_images_get_image (EV_DOCUMENT_IMAGES (view->document),
3401                                                                        view->image_dnd_info.image);
3402                                 ev_document_doc_mutex_unlock ();
3403
3404                                 tmp_uri = ev_image_save_tmp (view->image_dnd_info.image, pixbuf);
3405                                 g_object_unref (pixbuf);
3406
3407                                 uris[0] = (gchar *)tmp_uri;
3408                                 uris[1] = NULL;
3409                                 gtk_selection_data_set_uris (selection_data, uris);
3410                         }
3411         }
3412 }
3413
3414 static gboolean
3415 ev_view_drag_motion (GtkWidget      *widget,
3416                      GdkDragContext *context,
3417                      gint            x,
3418                      gint            y,
3419                      guint           time)
3420 {
3421         if (gtk_drag_get_source_widget (context) == widget)
3422                 gdk_drag_status (context, 0, time);
3423         else
3424                 gdk_drag_status (context, context->suggested_action, time);
3425
3426         return TRUE;
3427 }
3428
3429 static gboolean
3430 selection_update_idle_cb (EvView *view)
3431 {
3432         compute_selections (view,
3433                             view->selection_info.style,
3434                             &view->selection_info.start,
3435                             &view->motion);
3436         view->selection_update_id = 0;
3437         return FALSE;
3438 }
3439
3440 static gboolean
3441 selection_scroll_timeout_cb (EvView *view)
3442 {
3443         gint x, y, shift = 0;
3444         GtkWidget *widget = GTK_WIDGET (view);
3445
3446         gtk_widget_get_pointer (widget, &x, &y);
3447
3448         if (y > widget->allocation.height) {
3449                 shift = (y - widget->allocation.height) / 2;
3450         } else if (y < 0) {
3451                 shift = y / 2;
3452         }
3453
3454         if (shift)
3455                 gtk_adjustment_set_value (view->vadjustment,
3456                                           CLAMP (view->vadjustment->value + shift,
3457                                           view->vadjustment->lower,
3458                                           view->vadjustment->upper -
3459                                           view->vadjustment->page_size));
3460
3461         if (x > widget->allocation.width) {
3462                 shift = (x - widget->allocation.width) / 2;
3463         } else if (x < 0) {
3464                 shift = x / 2;
3465         }
3466
3467         if (shift)
3468                 gtk_adjustment_set_value (view->hadjustment,
3469                                           CLAMP (view->hadjustment->value + shift,
3470                                           view->hadjustment->lower,
3471                                           view->hadjustment->upper -
3472                                           view->hadjustment->page_size));
3473
3474         return TRUE;
3475 }
3476
3477 static gboolean
3478 ev_view_drag_update_momentum (EvView *view)
3479 {
3480         int i;
3481         if (!view->drag_info.in_drag)
3482                 return FALSE;
3483
3484         for (i = DRAG_HISTORY - 1; i > 0; i--) {
3485                 view->drag_info.buffer[i].x = view->drag_info.buffer[i-1].x;
3486                 view->drag_info.buffer[i].y = view->drag_info.buffer[i-1].y;
3487         }
3488
3489         /* Momentum is a moving average of 10ms granularity over
3490          * the last 100ms with each 10ms stored in buffer.
3491          */
3492
3493         view->drag_info.momentum.x = (view->drag_info.buffer[DRAG_HISTORY - 1].x - view->drag_info.buffer[0].x);
3494         view->drag_info.momentum.y = (view->drag_info.buffer[DRAG_HISTORY - 1].y - view->drag_info.buffer[0].y);
3495
3496         return TRUE;
3497 }
3498
3499 static gboolean
3500 ev_view_scroll_drag_release (EvView *view)
3501 {
3502         gdouble dhadj_value, dvadj_value;
3503         gdouble oldhadjustment, oldvadjustment;
3504
3505         view->drag_info.momentum.x /= 1.2;
3506         view->drag_info.momentum.y /= 1.2; /* Alter these constants to change "friction" */
3507
3508         dhadj_value = view->hadjustment->page_size *
3509                       (gdouble)view->drag_info.momentum.x / GTK_WIDGET (view)->allocation.width;
3510         dvadj_value = view->vadjustment->page_size *
3511                       (gdouble)view->drag_info.momentum.y / GTK_WIDGET (view)->allocation.height;
3512
3513         oldhadjustment = gtk_adjustment_get_value (view->hadjustment);
3514         oldvadjustment = gtk_adjustment_get_value (view->vadjustment);
3515
3516      /* When we reach the edges, we need either to absorb some momentum and bounce by
3517       * multiplying it on -0.5 or stop scrolling by setting momentum to 0. */
3518      if (((oldhadjustment + dhadj_value) > (view->hadjustment->upper - view->hadjustment->page_size)) ||
3519            ((oldhadjustment + dhadj_value) < 0))
3520                 view->drag_info.momentum.x = 0;
3521         if (((oldvadjustment + dvadj_value) > (view->vadjustment->upper - view->vadjustment->page_size)) ||
3522            ((oldvadjustment + dvadj_value) < 0))
3523                 view->drag_info.momentum.y = 0;
3524
3525         gtk_adjustment_set_value (view->hadjustment,
3526                                 MIN (oldhadjustment + dhadj_value,
3527                                 view->hadjustment->upper - view->hadjustment->page_size));
3528         gtk_adjustment_set_value (view->vadjustment,
3529                                 MIN (oldvadjustment + dvadj_value,
3530                                 view->vadjustment->upper - view->vadjustment->page_size));
3531
3532         if (((view->drag_info.momentum.x < 1) && (view->drag_info.momentum.x > -1)) &&
3533            ((view->drag_info.momentum.y < 1) && (view->drag_info.momentum.y > -1)))
3534                 return FALSE;
3535         else
3536                 return TRUE;
3537 }
3538
3539 static gboolean
3540 ev_view_motion_notify_event (GtkWidget      *widget,
3541                              GdkEventMotion *event)
3542 {
3543         EvView *view = EV_VIEW (widget);
3544         gint x, y;
3545
3546         if (!view->document)
3547                 return FALSE;
3548
3549         if (event->is_hint || event->window != view->layout.bin_window) {
3550             gtk_widget_get_pointer (widget, &x, &y);
3551         } else {
3552             x = event->x;
3553             y = event->y;
3554         }
3555
3556         if (view->scroll_info.autoscrolling) {
3557                 view->scroll_info.last_y = y;
3558                 return TRUE;
3559         }
3560
3561         if (view->selection_info.in_drag) {
3562                 if (gtk_drag_check_threshold (widget,
3563                                               view->selection_info.start.x,
3564                                               view->selection_info.start.y,
3565                                               x, y)) {
3566                         GtkTargetList *target_list = gtk_target_list_new (NULL, 0);
3567
3568                         gtk_target_list_add_text_targets (target_list, TARGET_DND_TEXT);
3569
3570                         gtk_drag_begin (widget, target_list,
3571                                         GDK_ACTION_COPY,
3572                                         1, (GdkEvent *)event);
3573
3574                         view->selection_info.in_drag = FALSE;
3575
3576                         gtk_target_list_unref (target_list);
3577
3578                         return TRUE;
3579                 }
3580         } else if (view->image_dnd_info.in_drag) {
3581                 if (gtk_drag_check_threshold (widget,
3582                                               view->selection_info.start.x,
3583                                               view->selection_info.start.y,
3584                                               x, y)) {
3585                         GtkTargetList *target_list = gtk_target_list_new (NULL, 0);
3586
3587                         gtk_target_list_add_uri_targets (target_list, TARGET_DND_URI);
3588                         gtk_target_list_add_image_targets (target_list, TARGET_DND_IMAGE, TRUE);
3589
3590                         gtk_drag_begin (widget, target_list,
3591                                         GDK_ACTION_COPY,
3592                                         1, (GdkEvent *)event);
3593
3594                         view->image_dnd_info.in_drag = FALSE;
3595
3596                         gtk_target_list_unref (target_list);
3597
3598                         return TRUE;
3599                 }
3600         }
3601
3602         switch (view->pressed_button) {
3603         case 1:
3604                 /* For the Evince 0.4.x release, we limit selection to un-rotated
3605                  * documents only.
3606                  */
3607                 if (view->rotation != 0)
3608                         return FALSE;
3609
3610                 /* Schedule timeout to scroll during selection and additionally
3611                  * scroll once to allow arbitrary speed. */
3612                 if (!view->selection_scroll_id)
3613                     view->selection_scroll_id = g_timeout_add (SCROLL_TIME,
3614                                                                (GSourceFunc)selection_scroll_timeout_cb,
3615                                                                view);
3616                 else
3617                     selection_scroll_timeout_cb (view);
3618
3619                 view->selection_info.in_selection = TRUE;
3620                 view->motion.x = x + view->scroll_x;
3621                 view->motion.y = y + view->scroll_y;
3622
3623                 /* Queue an idle to handle the motion.  We do this because
3624                  * handling any selection events in the motion could be slower
3625                  * than new motion events reach us.  We always put it in the
3626                  * idle to make sure we catch up and don't visibly lag the
3627                  * mouse. */
3628                 if (!view->selection_update_id)
3629                         view->selection_update_id = g_idle_add ((GSourceFunc)selection_update_idle_cb, view);
3630
3631                 return TRUE;
3632         case 2:
3633                 if (!view->drag_info.in_drag) {
3634                         gboolean start;
3635                         int i;
3636
3637                         start = gtk_drag_check_threshold (widget,
3638                                                           view->drag_info.start.x,
3639                                                           view->drag_info.start.y,
3640                                                           event->x_root,
3641                                                           event->y_root);
3642                         view->drag_info.in_drag = start;
3643                         view->drag_info.drag_timeout_id = g_timeout_add (10,
3644                                 (GSourceFunc)ev_view_drag_update_momentum, view);
3645                         /* Set 100 to choose how long it takes to build up momentum */
3646                         /* Clear out previous momentum info: */
3647                         for (i = 0; i < DRAG_HISTORY; i++) {
3648                                 view->drag_info.buffer[i].x = event->x;
3649                                 view->drag_info.buffer[i].y = event->y;
3650                         }
3651                         view->drag_info.momentum.x = 0;
3652                         view->drag_info.momentum.y = 0;
3653                 }
3654
3655                 if (view->drag_info.in_drag) {
3656                         int dx, dy;
3657                         gdouble dhadj_value, dvadj_value;
3658
3659                         view->drag_info.buffer[0].x = event->x;
3660                         view->drag_info.buffer[0].y = event->y;
3661
3662                         dx = event->x_root - view->drag_info.start.x;
3663                         dy = event->y_root - view->drag_info.start.y;
3664
3665                         dhadj_value = view->hadjustment->page_size *
3666                                       (gdouble)dx / widget->allocation.width;
3667                         dvadj_value = view->vadjustment->page_size *
3668                                       (gdouble)dy / widget->allocation.height;
3669
3670                         /* clamp scrolling to visible area */
3671                         gtk_adjustment_set_value (view->hadjustment,
3672                                                   MIN(view->drag_info.hadj - dhadj_value,
3673                                                       view->hadjustment->upper -
3674                                                       view->hadjustment->page_size));
3675                         gtk_adjustment_set_value (view->vadjustment,
3676                                                   MIN(view->drag_info.vadj - dvadj_value,
3677                                                       view->vadjustment->upper -
3678                                                       view->vadjustment->page_size));
3679
3680                         return TRUE;
3681                 }
3682
3683                 break;
3684         default:
3685                 ev_view_handle_cursor_over_xy (view, x, y);
3686         }
3687
3688         return FALSE;
3689 }
3690
3691 static gboolean
3692 ev_view_button_release_event (GtkWidget      *widget,
3693                               GdkEventButton *event)
3694 {
3695         EvView *view = EV_VIEW (widget);
3696         EvLink *link = NULL;
3697
3698         view->image_dnd_info.in_drag = FALSE;
3699
3700         if (view->scroll_info.autoscrolling) {
3701                 ev_view_autoscroll_stop (view);
3702                 view->pressed_button = -1;
3703
3704                 return TRUE;
3705         }
3706
3707         if (view->drag_info.in_drag) {
3708                 view->drag_info.release_timeout_id =
3709                         g_timeout_add (20,
3710                                        (GSourceFunc)ev_view_scroll_drag_release, view);
3711         }
3712
3713         if (view->document && !view->drag_info.in_drag && view->pressed_button != 3) {
3714                 link = ev_view_get_link_at_location (view, event->x, event->y);
3715         }
3716
3717         view->drag_info.in_drag = FALSE;
3718
3719         if (view->pressed_button == 2) {
3720                 ev_view_handle_cursor_over_xy (view, event->x, event->y);
3721         }
3722
3723         view->pressed_button = -1;
3724
3725         if (view->selection_scroll_id) {
3726             g_source_remove (view->selection_scroll_id);
3727             view->selection_scroll_id = 0;
3728         }
3729         if (view->selection_update_id) {
3730             g_source_remove (view->selection_update_id);
3731             view->selection_update_id = 0;
3732         }
3733
3734         if (view->selection_info.selections) {
3735                 clear_link_selected (view);
3736                 ev_view_update_primary_selection (view);
3737
3738                 if (view->selection_info.in_drag) {
3739                         clear_selection (view);
3740                         gtk_widget_queue_draw (widget);
3741                 }
3742
3743                 view->selection_info.in_drag = FALSE;
3744         } else if (link) {
3745                 if (event->button == 2) {
3746                         EvLinkAction    *action;
3747                         EvLinkActionType type;
3748
3749                         action = ev_link_get_action (link);
3750                         if (!action)
3751                                 return FALSE;
3752
3753                         type = ev_link_action_get_action_type (action);
3754                         if (type == EV_LINK_ACTION_TYPE_GOTO_DEST) {
3755                                 g_signal_emit (view,
3756                                                signals[SIGNAL_EXTERNAL_LINK],
3757                                                0, action);
3758                         }
3759                 } else {
3760                         ev_view_handle_link (view, link);
3761                 }
3762         }
3763
3764         return FALSE;
3765 }
3766
3767 static gboolean
3768 ev_view_key_press_event (GtkWidget   *widget,
3769                          GdkEventKey *event)
3770 {
3771         EvView *view = EV_VIEW (widget);
3772
3773         if (!view->document)
3774                 return FALSE;
3775
3776         if (!GTK_WIDGET_HAS_FOCUS (widget)) {
3777                 /* Forward key events to current focused window child */
3778                 if (view->window_child_focus) {
3779                         GdkEventKey *new_event;
3780                         gboolean     handled;
3781
3782                         new_event = (GdkEventKey *) gdk_event_copy ((GdkEvent *)event);
3783                         g_object_unref (new_event->window);
3784                         new_event->window = g_object_ref (view->window_child_focus->window->window);
3785                         gtk_widget_realize (view->window_child_focus->window);
3786                         handled = gtk_widget_event (view->window_child_focus->window, (GdkEvent *)new_event);
3787                         gdk_event_free ((GdkEvent *)new_event);
3788
3789                         return handled;
3790                 }
3791
3792                 return FALSE;
3793         }
3794
3795         return gtk_bindings_activate_event (GTK_OBJECT (widget), event);
3796 }
3797
3798 static gint
3799 ev_view_focus_in (GtkWidget     *widget,
3800                   GdkEventFocus *event)
3801 {
3802         if (EV_VIEW (widget)->pixbuf_cache)
3803                 ev_pixbuf_cache_style_changed (EV_VIEW (widget)->pixbuf_cache);
3804         gtk_widget_queue_draw (widget);
3805
3806         return FALSE;
3807 }
3808
3809 static gint
3810 ev_view_focus_out (GtkWidget     *widget,
3811                    GdkEventFocus *event)
3812 {
3813         if (EV_VIEW (widget)->pixbuf_cache)
3814                 ev_pixbuf_cache_style_changed (EV_VIEW (widget)->pixbuf_cache);
3815         gtk_widget_queue_draw (widget);
3816
3817         return FALSE;
3818 }
3819
3820 static gboolean
3821 ev_view_leave_notify_event (GtkWidget *widget, GdkEventCrossing   *event)
3822 {
3823         EvView *view = EV_VIEW (widget);
3824
3825         if (view->cursor != EV_VIEW_CURSOR_NORMAL)
3826                 ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
3827
3828         return FALSE;
3829 }
3830
3831 static gboolean
3832 ev_view_enter_notify_event (GtkWidget *widget, GdkEventCrossing   *event)
3833 {
3834         EvView *view = EV_VIEW (widget);
3835
3836         ev_view_handle_cursor_over_xy (view, event->x, event->y);
3837
3838         return FALSE;
3839 }
3840
3841 static void
3842 ev_view_style_set (GtkWidget *widget,
3843                    GtkStyle  *old_style)
3844 {
3845         if (EV_VIEW (widget)->pixbuf_cache)
3846                 ev_pixbuf_cache_style_changed (EV_VIEW (widget)->pixbuf_cache);
3847
3848         GTK_WIDGET_CLASS (ev_view_parent_class)->style_set (widget, old_style);
3849 }
3850
3851 /*** Drawing ***/
3852
3853 static guint32
3854 ev_gdk_color_to_rgb (const GdkColor *color)
3855 {
3856   guint32 result;
3857   result = (0xff0000 | (color->red & 0xff00));
3858   result <<= 8;
3859   result |= ((color->green & 0xff00) | (color->blue >> 8));
3860   return result;
3861 }
3862
3863 static void
3864 draw_rubberband (GtkWidget *widget, GdkWindow *window,
3865                  const GdkRectangle *rect, guchar alpha)
3866 {
3867         GdkGC *gc;
3868         GdkPixbuf *pixbuf;
3869         GdkColor *fill_color_gdk;
3870         guint fill_color;
3871
3872         fill_color_gdk = gdk_color_copy (&GTK_WIDGET (widget)->style->base[GTK_STATE_SELECTED]);
3873         fill_color = ev_gdk_color_to_rgb (fill_color_gdk) << 8 | alpha;
3874
3875         pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8,
3876                                  rect->width, rect->height);
3877         gdk_pixbuf_fill (pixbuf, fill_color);
3878
3879         gdk_draw_pixbuf (window, NULL, pixbuf,
3880                          0, 0,
3881                          rect->x - EV_VIEW (widget)->scroll_x, rect->y - EV_VIEW (widget)->scroll_y,
3882                          rect->width, rect->height,
3883                          GDK_RGB_DITHER_NONE,
3884                          0, 0);
3885
3886         g_object_unref (pixbuf);
3887
3888         gc = gdk_gc_new (window);
3889         gdk_gc_set_rgb_fg_color (gc, fill_color_gdk);
3890         gdk_draw_rectangle (window, gc, FALSE,
3891                             rect->x - EV_VIEW (widget)->scroll_x, rect->y - EV_VIEW (widget)->scroll_y,
3892                             rect->width - 1,
3893                             rect->height - 1);
3894         g_object_unref (gc);
3895
3896         gdk_color_free (fill_color_gdk);
3897 }
3898
3899
3900 static void
3901 highlight_find_results (EvView *view, int page)
3902 {
3903         gint i, n_results = 0;
3904
3905         n_results = ev_view_find_get_n_results (view, page);
3906
3907         for (i = 0; i < n_results; i++) {
3908                 EvRectangle *rectangle;
3909                 GdkRectangle view_rectangle;
3910                 guchar alpha;
3911
3912                 if (i == view->find_result && page == view->current_page) {
3913                         alpha = 0x90;
3914                 } else {
3915                         alpha = 0x20;
3916                 }
3917
3918                 rectangle = ev_view_find_get_result (view, page, i);
3919                 doc_rect_to_view_rect (view, page, rectangle, &view_rectangle);
3920                 draw_rubberband (GTK_WIDGET (view), view->layout.bin_window,
3921                                  &view_rectangle, alpha);
3922         }
3923 }
3924
3925 static void
3926 draw_loading_text (EvView       *view,
3927                    GdkRectangle *page_area,
3928                    GdkRectangle *expose_area)
3929 {
3930         cairo_t *cr;
3931         gint     width, height;
3932
3933         if (!view->loading_text) {
3934                 const gchar *loading_text = _("Loading...");
3935                 PangoLayout *layout;
3936                 PangoFontDescription *font_desc;
3937                 PangoRectangle logical_rect;
3938                 gint target_width;
3939                 gdouble real_scale;
3940
3941                 ev_document_fc_mutex_lock ();
3942
3943                 layout = gtk_widget_create_pango_layout (GTK_WIDGET (view), loading_text);
3944
3945                 font_desc = pango_font_description_new ();
3946
3947                 /* We set the font to be 10 points, get the size, and scale appropriately */
3948                 pango_font_description_set_size (font_desc, 10 * PANGO_SCALE);
3949                 pango_layout_set_font_description (layout, font_desc);
3950                 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
3951
3952                 target_width = MAX (page_area->width / 2, 1);
3953                 real_scale = ((double)target_width / (double) logical_rect.width) * (PANGO_SCALE * 10);
3954                 pango_font_description_set_size (font_desc, (int)real_scale);
3955                 pango_layout_set_font_description (layout, font_desc);
3956                 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
3957
3958                 view->loading_text = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
3959                                                                  logical_rect.width,
3960                                                                  logical_rect.height);
3961                 cr = cairo_create (view->loading_text);
3962                 cairo_set_source_rgb (cr,
3963                                       155 / (double)255,
3964                                       155 / (double)255,
3965                                       155 / (double)255);
3966                 pango_cairo_show_layout (cr, layout);
3967                 cairo_destroy (cr);
3968
3969                 pango_font_description_free (font_desc);
3970                 g_object_unref (layout);
3971
3972                 ev_document_fc_mutex_unlock ();
3973         }
3974
3975         width = (page_area->width - cairo_image_surface_get_width (view->loading_text)) / 2;
3976         height = (page_area->height - cairo_image_surface_get_height (view->loading_text)) / 2;
3977
3978         cr = gdk_cairo_create (view->layout.bin_window);
3979         cairo_translate (cr,
3980                          page_area->x + width,
3981                          page_area->y + height);
3982         cairo_set_source_surface (cr, view->loading_text, 0, 0);
3983         cairo_paint (cr);
3984         cairo_destroy (cr);
3985 }
3986
3987 static void
3988 draw_one_page (EvView       *view,
3989                gint          page,
3990                cairo_t      *cr,
3991                GdkRectangle *page_area,
3992                GtkBorder    *border,
3993                GdkRectangle *expose_area,
3994                gboolean     *page_ready)
3995 {
3996         GdkRectangle overlap;
3997         GdkRectangle real_page_area;
3998         gint         current_page;
3999
4000         g_assert (view->document);
4001
4002         if (! gdk_rectangle_intersect (page_area, expose_area, &overlap))
4003                 return;
4004
4005         /* Render the document itself */
4006         real_page_area = *page_area;
4007
4008         real_page_area.x += border->left;
4009         real_page_area.y += border->top;
4010         real_page_area.width -= (border->left + border->right);
4011         real_page_area.height -= (border->top + border->bottom);
4012         *page_ready = TRUE;
4013
4014         current_page = ev_document_model_get_page (view->model);
4015         ev_document_misc_paint_one_page (view->layout.bin_window,
4016                                          GTK_WIDGET (view),
4017                                          page_area, border,
4018                                          page == current_page);
4019
4020         if (gdk_rectangle_intersect (&real_page_area, expose_area, &overlap)) {
4021                 gint             width, height;
4022                 gint             page_width, page_height;
4023                 cairo_surface_t *page_surface = NULL;
4024                 gint             selection_width, selection_height;
4025                 cairo_surface_t *selection_surface = NULL;
4026
4027                 page_surface = ev_pixbuf_cache_get_surface (view->pixbuf_cache, page);
4028
4029                 if (!page_surface) {
4030                         draw_loading_text (view,
4031                                            &real_page_area,
4032                                            expose_area);
4033
4034                         *page_ready = FALSE;
4035
4036                         return;
4037                 }
4038
4039                 ev_view_get_page_size (view, page, &width, &height);
4040
4041                 page_width = cairo_image_surface_get_width (page_surface);
4042                 page_height = cairo_image_surface_get_height (page_surface);
4043
4044                 cairo_save (cr);
4045                 cairo_translate (cr, overlap.x, overlap.y);
4046
4047                 if (width != page_width || height != page_height) {
4048                         cairo_pattern_set_filter (cairo_get_source (cr),
4049                                                   CAIRO_FILTER_FAST);
4050                         cairo_scale (cr,
4051                                      (gdouble)width / page_width,
4052                                      (gdouble)height / page_height);
4053                 }
4054
4055                 cairo_surface_set_device_offset (page_surface,
4056                                                  overlap.x - real_page_area.x,
4057                                                  overlap.y - real_page_area.y);
4058                 cairo_set_source_surface (cr, page_surface, 0, 0);
4059                 cairo_paint (cr);
4060                 cairo_restore (cr);
4061
4062                 /* Get the selection pixbuf iff we have something to draw */
4063                 if (find_selection_for_page (view, page) &&
4064                     view->selection_mode == EV_VIEW_SELECTION_TEXT) {
4065                         selection_surface =
4066                                 ev_pixbuf_cache_get_selection_surface (view->pixbuf_cache,
4067                                                                        page,
4068                                                                        view->scale,
4069                                                                        NULL);
4070                 }
4071
4072                 if (!selection_surface) {
4073                         return;
4074                 }
4075
4076                 selection_width = cairo_image_surface_get_width (selection_surface);
4077                 selection_height = cairo_image_surface_get_height (selection_surface);
4078
4079                 cairo_save (cr);
4080                 cairo_translate (cr, overlap.x, overlap.y);
4081
4082                 if (width != selection_width || height != selection_height) {
4083                         cairo_pattern_set_filter (cairo_get_source (cr),
4084                                                   CAIRO_FILTER_FAST);
4085                         cairo_scale (cr,
4086                                      (gdouble)width / selection_width,
4087                                      (gdouble)height / selection_height);
4088                 }
4089
4090                 cairo_surface_set_device_offset (selection_surface,
4091                                                  overlap.x - real_page_area.x,
4092                                                  overlap.y - real_page_area.y);
4093                 cairo_set_source_surface (cr, selection_surface, 0, 0);
4094                 cairo_paint (cr);
4095                 cairo_restore (cr);
4096         }
4097 }
4098
4099 /*** GObject functions ***/
4100
4101 static void
4102 ev_view_finalize (GObject *object)
4103 {
4104         EvView *view = EV_VIEW (object);
4105
4106         clear_selection (view);
4107         clear_link_selected (view);
4108
4109         if (view->image_dnd_info.image)
4110                 g_object_unref (view->image_dnd_info.image);
4111         view->image_dnd_info.image = NULL;
4112
4113         G_OBJECT_CLASS (ev_view_parent_class)->finalize (object);
4114 }
4115
4116 static void
4117 ev_view_destroy (GtkObject *object)
4118 {
4119         EvView *view = EV_VIEW (object);
4120
4121         if (view->model) {
4122                 g_object_unref (view->model);
4123                 view->model = NULL;
4124         }
4125
4126         if (view->pixbuf_cache) {
4127                 g_object_unref (view->pixbuf_cache);
4128                 view->pixbuf_cache = NULL;
4129         }
4130
4131         if (view->document) {
4132                 g_object_unref (view->document);
4133                 view->document = NULL;
4134         }
4135
4136         if (view->page_cache) {
4137                 g_object_unref (view->page_cache);
4138                 view->page_cache = NULL;
4139         }
4140
4141         ev_view_window_children_free (view);
4142
4143         if (view->selection_scroll_id) {
4144             g_source_remove (view->selection_scroll_id);
4145             view->selection_scroll_id = 0;
4146         }
4147
4148         if (view->selection_update_id) {
4149             g_source_remove (view->selection_update_id);
4150             view->selection_update_id = 0;
4151         }
4152
4153         if (view->loading_text) {
4154                 cairo_surface_destroy (view->loading_text);
4155                 view->loading_text = NULL;
4156         }
4157
4158         if (view->scroll_info.timeout_id) {
4159             g_source_remove (view->scroll_info.timeout_id);
4160             view->scroll_info.timeout_id = 0;
4161         }
4162
4163         if (view->drag_info.drag_timeout_id) {
4164                 g_source_remove (view->drag_info.drag_timeout_id);
4165                 view->drag_info.drag_timeout_id = 0;
4166         }
4167
4168         if (view->drag_info.release_timeout_id) {
4169                 g_source_remove (view->drag_info.release_timeout_id);
4170                 view->drag_info.release_timeout_id = 0;
4171         }
4172
4173         ev_view_set_scroll_adjustments (GTK_LAYOUT (view), NULL, NULL);
4174
4175         GTK_OBJECT_CLASS (ev_view_parent_class)->destroy (object);
4176 }
4177
4178 static AtkObject *
4179 ev_view_get_accessible (GtkWidget *widget)
4180 {
4181         static gboolean first_time = TRUE;
4182
4183         if (first_time) {
4184                 AtkObjectFactory *factory;
4185                 AtkRegistry *registry;
4186                 GType derived_type;
4187                 GType derived_atk_type;
4188
4189                 /*
4190                  * Figure out whether accessibility is enabled by looking at the
4191                  * type of the accessible object which would be created for
4192                  * the parent type of EvView.
4193                  */
4194                 derived_type = g_type_parent (EV_TYPE_VIEW);
4195
4196                 registry = atk_get_default_registry ();
4197                 factory = atk_registry_get_factory (registry,
4198                                                     derived_type);
4199                 derived_atk_type = atk_object_factory_get_accessible_type (factory);
4200                 if (g_type_is_a (derived_atk_type, GTK_TYPE_ACCESSIBLE))
4201                         atk_registry_set_factory_type (registry,
4202                                                        EV_TYPE_VIEW,
4203                                                        ev_view_accessible_factory_get_type ());
4204                 first_time = FALSE;
4205         }
4206         return GTK_WIDGET_CLASS (ev_view_parent_class)->get_accessible (widget);
4207 }
4208
4209 static void
4210 ev_view_get_property (GObject *object,
4211                       guint prop_id,
4212                       GValue *value,
4213                       GParamSpec *pspec)
4214 {
4215         EvView *view = EV_VIEW (object);
4216
4217         switch (prop_id) {
4218                 case PROP_HAS_SELECTION:
4219                         g_value_set_boolean (value,
4220                                              view->selection_info.selections != NULL);
4221                         break;
4222                 default:
4223                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
4224         }
4225 }
4226
4227 static void
4228 ev_view_class_init (EvViewClass *class)
4229 {
4230         GObjectClass *object_class = G_OBJECT_CLASS (class);
4231         GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (class);
4232         GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
4233         GtkLayoutClass *layout_class = GTK_LAYOUT_CLASS (class);
4234         GtkBindingSet *binding_set;
4235
4236         object_class->finalize = ev_view_finalize;
4237         object_class->get_property = ev_view_get_property;
4238
4239         widget_class->expose_event = ev_view_expose_event;
4240         widget_class->button_press_event = ev_view_button_press_event;
4241         widget_class->motion_notify_event = ev_view_motion_notify_event;
4242         widget_class->button_release_event = ev_view_button_release_event;
4243         widget_class->key_press_event = ev_view_key_press_event;
4244         widget_class->focus_in_event = ev_view_focus_in;
4245         widget_class->focus_out_event = ev_view_focus_out;
4246         widget_class->get_accessible = ev_view_get_accessible;
4247         widget_class->size_request = ev_view_size_request;
4248         widget_class->size_allocate = ev_view_size_allocate;
4249         widget_class->realize = ev_view_realize;
4250         widget_class->scroll_event = ev_view_scroll_event;
4251         widget_class->enter_notify_event = ev_view_enter_notify_event;
4252         widget_class->leave_notify_event = ev_view_leave_notify_event;
4253         widget_class->style_set = ev_view_style_set;
4254         widget_class->drag_data_get = ev_view_drag_data_get;
4255         widget_class->drag_motion = ev_view_drag_motion;
4256         widget_class->popup_menu = ev_view_popup_menu;
4257         widget_class->query_tooltip = ev_view_query_tooltip;
4258
4259         gtk_object_class->destroy = ev_view_destroy;
4260
4261         layout_class->set_scroll_adjustments = ev_view_set_scroll_adjustments;
4262
4263         class->binding_activated = ev_view_scroll;
4264
4265         signals[SIGNAL_BINDING_ACTIVATED] = g_signal_new ("binding_activated",
4266                          G_TYPE_FROM_CLASS (object_class),
4267                          G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
4268                          G_STRUCT_OFFSET (EvViewClass, binding_activated),
4269                          NULL, NULL,
4270                          ev_view_marshal_VOID__ENUM_BOOLEAN,
4271                          G_TYPE_NONE, 2,
4272                          GTK_TYPE_SCROLL_TYPE,
4273                          G_TYPE_BOOLEAN);
4274         signals[SIGNAL_HANDLE_LINK] = g_signal_new ("handle-link",
4275                          G_TYPE_FROM_CLASS (object_class),
4276                          G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
4277                          G_STRUCT_OFFSET (EvViewClass, handle_link),
4278                          NULL, NULL,
4279                          g_cclosure_marshal_VOID__OBJECT,
4280                          G_TYPE_NONE, 1,
4281                          G_TYPE_OBJECT);
4282         signals[SIGNAL_EXTERNAL_LINK] = g_signal_new ("external-link",
4283                          G_TYPE_FROM_CLASS (object_class),
4284                          G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
4285                          G_STRUCT_OFFSET (EvViewClass, external_link),
4286                          NULL, NULL,
4287                          g_cclosure_marshal_VOID__OBJECT,
4288                          G_TYPE_NONE, 1,
4289                          G_TYPE_OBJECT);
4290         signals[SIGNAL_POPUP_MENU] = g_signal_new ("popup",
4291                          G_TYPE_FROM_CLASS (object_class),
4292                          G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
4293                          G_STRUCT_OFFSET (EvViewClass, popup_menu),
4294                          NULL, NULL,
4295                          g_cclosure_marshal_VOID__OBJECT,
4296                          G_TYPE_NONE, 1,
4297                          G_TYPE_OBJECT);
4298
4299
4300         g_object_class_install_property (object_class,
4301                                          PROP_HAS_SELECTION,
4302                                          g_param_spec_boolean ("has-selection",
4303                                                                "Has selection",
4304                                                                "The view has selections",
4305                                                                FALSE,
4306                                                                G_PARAM_READABLE));
4307
4308         binding_set = gtk_binding_set_by_class (class);
4309
4310         add_scroll_binding_keypad (binding_set, GDK_Left,  0, GTK_SCROLL_STEP_BACKWARD, TRUE);
4311         add_scroll_binding_keypad (binding_set, GDK_Right, 0, GTK_SCROLL_STEP_FORWARD,  TRUE);
4312         add_scroll_binding_keypad (binding_set, GDK_Left,  GDK_MOD1_MASK, GTK_SCROLL_STEP_DOWN, TRUE);
4313         add_scroll_binding_keypad (binding_set, GDK_Right, GDK_MOD1_MASK, GTK_SCROLL_STEP_UP,  TRUE);
4314         add_scroll_binding_keypad (binding_set, GDK_Up,    0, GTK_SCROLL_STEP_BACKWARD, FALSE);
4315         add_scroll_binding_keypad (binding_set, GDK_Down,  0, GTK_SCROLL_STEP_FORWARD,  FALSE);
4316         add_scroll_binding_keypad (binding_set, GDK_Up,    GDK_MOD1_MASK, GTK_SCROLL_STEP_DOWN, FALSE);
4317         add_scroll_binding_keypad (binding_set, GDK_Down,  GDK_MOD1_MASK, GTK_SCROLL_STEP_UP,  FALSE);
4318         gtk_binding_entry_add_signal (binding_set, GDK_H, 0, "binding_activated", 2, GTK_TYPE_SCROLL_TYPE,
4319                                       GTK_SCROLL_STEP_BACKWARD, G_TYPE_BOOLEAN, TRUE);
4320         gtk_binding_entry_add_signal (binding_set, GDK_J, 0, "binding_activated", 2, GTK_TYPE_SCROLL_TYPE,
4321                                       GTK_SCROLL_STEP_FORWARD, G_TYPE_BOOLEAN, FALSE);
4322         gtk_binding_entry_add_signal (binding_set, GDK_K, 0, "binding_activated", 2, GTK_TYPE_SCROLL_TYPE,
4323                                       GTK_SCROLL_STEP_BACKWARD, G_TYPE_BOOLEAN, FALSE);
4324         gtk_binding_entry_add_signal (binding_set, GDK_L, 0, "binding_activated", 2, GTK_TYPE_SCROLL_TYPE,
4325                                       GTK_SCROLL_STEP_FORWARD, G_TYPE_BOOLEAN, TRUE);
4326
4327 }
4328
4329 static void
4330 ev_view_init (EvView *view)
4331 {
4332         GTK_WIDGET_SET_FLAGS (view, GTK_CAN_FOCUS);
4333
4334         view->start_page = -1;
4335         view->end_page = -1;
4336         view->spacing = 5;
4337         view->scale = 1.0;
4338         view->current_page = 0;
4339         view->pressed_button = -1;
4340         view->cursor = EV_VIEW_CURSOR_NORMAL;
4341         view->drag_info.in_drag = FALSE;
4342         view->scroll_info.autoscrolling = FALSE;
4343         view->selection_info.selections = NULL;
4344         view->selection_info.in_selection = FALSE;
4345         view->selection_info.in_drag = FALSE;
4346         view->selection_mode = EV_VIEW_SELECTION_TEXT;
4347         view->continuous = TRUE;
4348         view->dual_page = FALSE;
4349         view->fullscreen = FALSE;
4350         view->sizing_mode = EV_SIZING_FIT_WIDTH;
4351         view->pending_scroll = SCROLL_TO_KEEP_POSITION;
4352         view->jump_to_find_result = TRUE;
4353         view->highlight_find_results = FALSE;
4354
4355         gtk_layout_set_hadjustment (GTK_LAYOUT (view), NULL);
4356         gtk_layout_set_vadjustment (GTK_LAYOUT (view), NULL);
4357 }
4358
4359 /*** Callbacks ***/
4360
4361 static void
4362 ev_view_change_page (EvView *view,
4363                      gint    new_page)
4364 {
4365         gint x, y;
4366
4367         view->current_page = new_page;
4368         view->pending_scroll = SCROLL_TO_PAGE_POSITION;
4369
4370         gtk_widget_get_pointer (GTK_WIDGET (view), &x, &y);
4371         ev_view_handle_cursor_over_xy (view, x, y);
4372
4373         gtk_widget_queue_resize (GTK_WIDGET (view));
4374 }
4375
4376 static void
4377 job_finished_cb (EvPixbufCache *pixbuf_cache,
4378                  GdkRegion     *region,
4379                  EvView        *view)
4380 {
4381         if (region) {
4382                 gdk_window_invalidate_region (view->layout.bin_window,
4383                                               region, TRUE);
4384         } else {
4385                 gtk_widget_queue_draw (GTK_WIDGET (view));
4386         }
4387 }
4388
4389 static void
4390 ev_view_page_changed_cb (EvDocumentModel *model,
4391                          gint             old_page,
4392                          gint             new_page,
4393                          EvView          *view)
4394 {
4395         if (!view->document)
4396                 return;
4397
4398         if (view->current_page != new_page) {
4399                 ev_view_change_page (view, new_page);
4400         } else {
4401                 gtk_widget_queue_draw (GTK_WIDGET (view));
4402         }
4403
4404         view->find_result = 0;
4405 }
4406
4407 static void
4408 on_adjustment_value_changed (GtkAdjustment *adjustment,
4409                              EvView        *view)
4410 {
4411         int dx = 0, dy = 0;
4412         gint x, y;
4413         GList *children, *l;
4414
4415         if (! GTK_WIDGET_REALIZED (view))
4416                 return;
4417
4418         if (view->hadjustment) {
4419                 dx = view->scroll_x - (int) view->hadjustment->value;
4420                 view->scroll_x = (int) view->hadjustment->value;
4421         } else {
4422                 view->scroll_x = 0;
4423         }
4424
4425         if (view->vadjustment) {
4426                 dy = view->scroll_y - (int) view->vadjustment->value;
4427                 view->scroll_y = (int) view->vadjustment->value;
4428         } else {
4429                 view->scroll_y = 0;
4430         }
4431
4432         children = gtk_container_get_children (GTK_CONTAINER (view));
4433         for (l = children; l && l->data; l = g_list_next (l)) {
4434                 gint       child_x, child_y;
4435                 GtkWidget *child = (GtkWidget *)l->data;
4436
4437                 gtk_container_child_get (GTK_CONTAINER (view),
4438                                          child,
4439                                          "x", &child_x,
4440                                          "y", &child_y,
4441                                          NULL);
4442                 gtk_layout_move (GTK_LAYOUT (view), child, child_x + dx, child_y + dy);
4443         }
4444         g_list_free (children);
4445
4446         for (l = view->window_children; l && l->data; l = g_list_next (l)) {
4447                 EvViewWindowChild *child;
4448
4449                 child = (EvViewWindowChild *)l->data;
4450
4451                 ev_view_window_child_move (view, child, child->x + dx, child->y + dy);
4452         }
4453
4454         if (view->pending_resize)
4455                 gtk_widget_queue_draw (GTK_WIDGET (view));
4456         else
4457                 gdk_window_scroll (view->layout.bin_window, dx, dy);
4458
4459         gtk_widget_get_pointer (GTK_WIDGET (view), &x, &y);
4460         ev_view_handle_cursor_over_xy (view, x, y);
4461
4462         if (view->document)
4463                 view_update_range_and_current_page (view);
4464 }
4465
4466 GtkWidget*
4467 ev_view_new (void)
4468 {
4469         GtkWidget *view;
4470
4471         view = g_object_new (EV_TYPE_VIEW, NULL);
4472
4473         return view;
4474 }
4475
4476 static void
4477 setup_caches (EvView *view)
4478 {
4479         gboolean inverted_colors;
4480
4481         view->height_to_page_cache = ev_view_get_height_to_page_cache (view);
4482         view->pixbuf_cache = ev_pixbuf_cache_new (GTK_WIDGET (view), view->document);
4483         view->page_cache = ev_page_cache_new (view->document);
4484         inverted_colors = ev_document_model_get_inverted_colors (view->model);
4485         ev_pixbuf_cache_set_inverted_colors (view->pixbuf_cache, inverted_colors);
4486         g_signal_connect (view->pixbuf_cache, "job-finished", G_CALLBACK (job_finished_cb), view);
4487 }
4488
4489 static void
4490 clear_caches (EvView *view)
4491 {
4492         if (view->pixbuf_cache) {
4493                 g_object_unref (view->pixbuf_cache);
4494                 view->pixbuf_cache = NULL;
4495         }
4496
4497         if (view->page_cache) {
4498                 g_object_unref (view->page_cache);
4499                 view->page_cache = NULL;
4500         }
4501 }
4502
4503 void
4504 ev_view_set_loading (EvView       *view,
4505                      gboolean      loading)
4506 {
4507         view->loading = loading;
4508         gtk_widget_queue_draw (GTK_WIDGET (view));
4509 }
4510
4511 static gboolean
4512 ev_view_autoscroll_cb (EvView *view)
4513 {
4514         gdouble speed, value;
4515
4516         /* If the user stops autoscrolling, autoscrolling will be
4517          * set to false but the timeout will continue; stop the timeout: */
4518         if (!view->scroll_info.autoscrolling) {
4519                 view->scroll_info.timeout_id = 0;
4520                 return FALSE;
4521         }
4522
4523         if (view->scroll_info.last_y > view->scroll_info.start_y &&
4524                 (view->scroll_info.last_y < view->scroll_info.start_y))
4525                 return TRUE;
4526
4527         /* Replace 100 with your speed of choice: The lower the faster.
4528          * Replace 3 with another speed of choice: The higher, the faster it accelerated
4529          *      based on the distance of the starting point from the mouse
4530          * (All also effected by the timeout interval of this callback) */
4531
4532         if (view->scroll_info.start_y > view->scroll_info.last_y)
4533                 speed = -pow ((((gdouble)view->scroll_info.start_y - view->scroll_info.last_y) / 100), 3);
4534         else
4535                 speed = pow ((((gdouble)view->scroll_info.last_y - view->scroll_info.start_y) / 100), 3);
4536
4537         value = gtk_adjustment_get_value (view->vadjustment);
4538         value = CLAMP (value + speed, 0, view->vadjustment->upper - view->vadjustment->page_size);
4539         gtk_adjustment_set_value (view->vadjustment, value);
4540
4541         return TRUE;
4542
4543 }
4544
4545 void
4546 ev_view_autoscroll_start (EvView *view)
4547 {
4548         gint x, y;
4549
4550         g_return_if_fail (EV_IS_VIEW (view));
4551
4552         if (view->scroll_info.autoscrolling)
4553                 return;
4554
4555         view->scroll_info.autoscrolling = TRUE;
4556         view->scroll_info.timeout_id =
4557                 g_timeout_add (20, (GSourceFunc)ev_view_autoscroll_cb,
4558                                view);
4559
4560         gtk_widget_get_pointer (GTK_WIDGET (view), &x, &y);
4561         ev_view_handle_cursor_over_xy (view, x, y);
4562 }
4563
4564 void
4565 ev_view_autoscroll_stop (EvView *view)
4566 {
4567         gint x, y;
4568
4569         g_return_if_fail (EV_IS_VIEW (view));
4570
4571         if (!view->scroll_info.autoscrolling)
4572                 return;
4573
4574         view->scroll_info.autoscrolling = FALSE;
4575         if (view->scroll_info.timeout_id) {
4576                 g_source_remove (view->scroll_info.timeout_id);
4577                 view->scroll_info.timeout_id = 0;
4578         }
4579
4580         gtk_widget_get_pointer (GTK_WIDGET (view), &x, &y);
4581         ev_view_handle_cursor_over_xy (view, x, y);
4582 }
4583
4584 static void
4585 ev_view_document_changed_cb (EvDocumentModel *model,
4586                              GParamSpec      *pspec,
4587                              EvView          *view)
4588 {
4589         EvDocument *document = ev_document_model_get_document (model);
4590
4591         view->loading = FALSE;
4592
4593         if (document != view->document) {
4594                 gint current_page;
4595
4596                 clear_caches (view);
4597
4598                 if (view->document) {
4599                         g_object_unref (view->document);
4600                 }
4601
4602                 view->document = document;
4603                 view->find_result = 0;
4604
4605                 if (view->document) {
4606                         g_object_ref (view->document);
4607                         setup_caches (view);
4608                 }
4609
4610                 current_page = ev_document_model_get_page (model);
4611                 if (view->current_page != current_page) {
4612                         ev_view_change_page (view, current_page);
4613                 } else {
4614                         view->pending_scroll = SCROLL_TO_KEEP_POSITION;
4615                         gtk_widget_queue_resize (GTK_WIDGET (view));
4616                 }
4617         }
4618 }
4619
4620 static void
4621 ev_view_rotation_changed_cb (EvDocumentModel *model,
4622                              GParamSpec      *pspec,
4623                              EvView          *view)
4624 {
4625         gint rotation = ev_document_model_get_rotation (model);
4626
4627         view->rotation = rotation;
4628
4629         if (view->pixbuf_cache) {
4630                 ev_pixbuf_cache_clear (view->pixbuf_cache);
4631                 if (!ev_document_is_page_size_uniform (view->document))
4632                         view->pending_scroll = SCROLL_TO_PAGE_POSITION;
4633                 gtk_widget_queue_resize (GTK_WIDGET (view));
4634         }
4635
4636         ev_view_remove_all (view);
4637
4638         if (rotation != 0)
4639                 clear_selection (view);
4640 }
4641
4642 static void
4643 ev_view_inverted_colors_changed_cb (EvDocumentModel *model,
4644                                     GParamSpec      *pspec,
4645                                     EvView          *view)
4646 {
4647         if (view->pixbuf_cache) {
4648                 gboolean inverted_colors;
4649
4650                 inverted_colors = ev_document_model_get_inverted_colors (model);
4651                 ev_pixbuf_cache_set_inverted_colors (view->pixbuf_cache, inverted_colors);
4652                 gtk_widget_queue_draw (GTK_WIDGET (view));
4653         }
4654 }
4655
4656 static void
4657 ev_view_sizing_mode_changed_cb (EvDocumentModel *model,
4658                                 GParamSpec      *pspec,
4659                                 EvView          *view)
4660 {
4661         EvSizingMode mode = ev_document_model_get_sizing_mode (model);
4662
4663         view->sizing_mode = mode;
4664         if (mode != EV_SIZING_FREE)
4665                 gtk_widget_queue_resize (GTK_WIDGET (view));
4666 }
4667
4668 #define EPSILON 0.0000001
4669 static void
4670 ev_view_scale_changed_cb (EvDocumentModel *model,
4671                           GParamSpec      *pspec,
4672                           EvView          *view)
4673 {
4674         gdouble scale = ev_document_model_get_scale (model);
4675
4676         if (ABS (view->scale - scale) < EPSILON)
4677                 return;
4678
4679         if (view->loading_text) {
4680                 cairo_surface_destroy (view->loading_text);
4681                 view->loading_text = NULL;
4682         }
4683
4684         view->scale = scale;
4685
4686         view->pending_resize = TRUE;
4687         if (view->sizing_mode == EV_SIZING_FREE)
4688                 gtk_widget_queue_resize (GTK_WIDGET (view));
4689 }
4690
4691 static void
4692 ev_view_continuous_changed_cb (EvDocumentModel *model,
4693                                GParamSpec      *pspec,
4694                                EvView          *view)
4695 {
4696         gboolean continuous = ev_document_model_get_continuous (model);
4697
4698         view->continuous = continuous;
4699         view->pending_scroll = SCROLL_TO_PAGE_POSITION;
4700         gtk_widget_queue_resize (GTK_WIDGET (view));
4701 }
4702
4703 static void
4704 ev_view_dual_page_changed_cb (EvDocumentModel *model,
4705                               GParamSpec      *pspec,
4706                               EvView          *view)
4707 {
4708         gboolean dual_page = ev_document_model_get_dual_page (model);
4709
4710         view->dual_page = dual_page;
4711         view->pending_scroll = SCROLL_TO_PAGE_POSITION;
4712         /* FIXME: if we're keeping the pixbuf cache around, we should extend the
4713          * preload_cache_size to be 2 if dual_page is set.
4714          */
4715         gtk_widget_queue_resize (GTK_WIDGET (view));
4716 }
4717
4718 static void
4719 ev_view_fullscreen_changed_cb (EvDocumentModel *model,
4720                                GParamSpec      *pspec,
4721                                EvView          *view)
4722 {
4723         gboolean fullscreen = ev_document_model_get_fullscreen (model);
4724
4725         view->fullscreen = fullscreen;
4726         gtk_widget_queue_resize (GTK_WIDGET (view));
4727 }
4728
4729 void
4730 ev_view_set_model (EvView          *view,
4731                    EvDocumentModel *model)
4732 {
4733         g_return_if_fail (EV_IS_VIEW (view));
4734         g_return_if_fail (EV_IS_DOCUMENT_MODEL (model));
4735
4736         if (model == view->model)
4737                 return;
4738
4739         if (view->model) {
4740                 g_signal_handlers_disconnect_by_func (view->model,
4741                                                       ev_view_document_changed_cb,
4742                                                       view);
4743                 g_signal_handlers_disconnect_by_func (view->model,
4744                                                       ev_view_page_changed_cb,
4745                                                       view);
4746                 g_object_unref (view->model);
4747         }
4748         view->model = g_object_ref (model);
4749
4750         /* Initialize view from model */
4751         view->rotation = ev_document_model_get_rotation (view->model);
4752         view->sizing_mode = ev_document_model_get_sizing_mode (view->model);
4753         view->scale = ev_document_model_get_scale (view->model);
4754         view->continuous = ev_document_model_get_continuous (view->model);
4755         view->dual_page = ev_document_model_get_dual_page (view->model);
4756         view->fullscreen = ev_document_model_get_fullscreen (view->model);
4757         ev_view_document_changed_cb (view->model, NULL, view);
4758
4759         g_signal_connect (view->model, "notify::document",
4760                           G_CALLBACK (ev_view_document_changed_cb),
4761                           view);
4762         g_signal_connect (view->model, "notify::rotation",
4763                           G_CALLBACK (ev_view_rotation_changed_cb),
4764                           view);
4765         g_signal_connect (view->model, "notify::inverted-colors",
4766                           G_CALLBACK (ev_view_inverted_colors_changed_cb),
4767                           view);
4768         g_signal_connect (view->model, "notify::sizing-mode",
4769                           G_CALLBACK (ev_view_sizing_mode_changed_cb),
4770                           view);
4771         g_signal_connect (view->model, "notify::scale",
4772                           G_CALLBACK (ev_view_scale_changed_cb),
4773                           view);
4774         g_signal_connect (view->model, "notify::continuous",
4775                           G_CALLBACK (ev_view_continuous_changed_cb),
4776                           view);
4777         g_signal_connect (view->model, "notify::dual-page",
4778                           G_CALLBACK (ev_view_dual_page_changed_cb),
4779                           view);
4780         g_signal_connect (view->model, "notify::fullscreen",
4781                           G_CALLBACK (ev_view_fullscreen_changed_cb),
4782                           view);
4783         g_signal_connect (view->model, "page-changed",
4784                           G_CALLBACK (ev_view_page_changed_cb),
4785                           view);
4786 }
4787
4788 static void
4789 ev_view_reload_page (EvView    *view,
4790                      gint       page,
4791                      GdkRegion *region)
4792 {
4793         ev_pixbuf_cache_reload_page (view->pixbuf_cache,
4794                                      region,
4795                                      page,
4796                                      view->rotation,
4797                                      view->scale);
4798 }
4799
4800 void
4801 ev_view_reload (EvView *view)
4802 {
4803         ev_pixbuf_cache_clear (view->pixbuf_cache);
4804         view_update_range_and_current_page (view);
4805 }
4806
4807 /*** Zoom and sizing mode ***/
4808
4809 gboolean
4810 ev_view_can_zoom_in (EvView *view)
4811 {
4812         return view->scale * ZOOM_IN_FACTOR <= ev_document_model_get_max_scale (view->model);
4813 }
4814
4815 gboolean
4816 ev_view_can_zoom_out (EvView *view)
4817 {
4818         return view->scale * ZOOM_OUT_FACTOR >= ev_document_model_get_min_scale (view->model);
4819 }
4820
4821 void
4822 ev_view_zoom_in (EvView *view)
4823 {
4824         gdouble scale;
4825
4826         g_return_if_fail (view->sizing_mode == EV_SIZING_FREE);
4827
4828         view->pending_scroll = SCROLL_TO_CENTER;
4829         scale = ev_document_model_get_scale (view->model) * ZOOM_IN_FACTOR;
4830         ev_document_model_set_scale (view->model, scale);
4831 }
4832
4833 void
4834 ev_view_zoom_out (EvView *view)
4835 {
4836         gdouble scale;
4837
4838         g_return_if_fail (view->sizing_mode == EV_SIZING_FREE);
4839
4840         view->pending_scroll = SCROLL_TO_CENTER;
4841         scale = ev_document_model_get_scale (view->model) * ZOOM_OUT_FACTOR;
4842         ev_document_model_set_scale (view->model, scale);
4843 }
4844
4845 static double
4846 zoom_for_size_fit_width (gdouble doc_width,
4847                          gdouble doc_height,
4848                          int     target_width,
4849                          int     target_height)
4850 {
4851         return (double)target_width / doc_width;
4852 }
4853
4854 static double
4855 zoom_for_size_fit_height (gdouble doc_width,
4856                           gdouble doc_height,
4857                           int     target_width,
4858                           int     target_height)
4859 {
4860         return (double)target_height / doc_height;
4861 }
4862
4863 static double
4864 zoom_for_size_best_fit (gdouble doc_width,
4865                         gdouble doc_height,
4866                         int     target_width,
4867                         int     target_height)
4868 {
4869         double w_scale;
4870         double h_scale;
4871
4872         w_scale = (double)target_width / doc_width;
4873         h_scale = (double)target_height / doc_height;
4874
4875         return MIN (w_scale, h_scale);
4876 }
4877
4878 static void
4879 ev_view_zoom_for_size_continuous_and_dual_page (EvView *view,
4880                                                 int     width,
4881                                                 int     height)
4882 {
4883         gdouble doc_width, doc_height;
4884         GtkBorder border;
4885         gdouble scale;
4886
4887         ev_document_get_max_page_size (view->document, &doc_width, &doc_height);
4888         if (view->rotation == 90 || view->rotation == 270) {
4889                 gdouble tmp;
4890
4891                 tmp = doc_width;
4892                 doc_width = doc_height;
4893                 doc_height = tmp;
4894         }
4895
4896         compute_border (view, doc_width, doc_height, &border);
4897
4898         doc_width *= 2;
4899         width -= (2 * (border.left + border.right) + 3 * view->spacing);
4900         height -= (border.top + border.bottom + 2 * view->spacing - 1);
4901
4902         if (view->sizing_mode == EV_SIZING_FIT_WIDTH) {
4903                 gint sb_size;
4904
4905                 sb_size = ev_view_get_scrollbar_size (view, GTK_ORIENTATION_VERTICAL);
4906                 scale = zoom_for_size_fit_width (doc_width, doc_height, width - sb_size, height);
4907         } else if (view->sizing_mode == EV_SIZING_BEST_FIT)
4908                 scale = zoom_for_size_best_fit (doc_width, doc_height, width, height);
4909         else
4910                 g_assert_not_reached ();
4911
4912         ev_document_model_set_scale (view->model, scale);
4913 }
4914
4915 static void
4916 ev_view_zoom_for_size_continuous (EvView *view,
4917                                   int     width,
4918                                   int     height)
4919 {
4920         gdouble doc_width, doc_height;
4921         GtkBorder border;
4922         gdouble scale;
4923
4924         ev_document_get_max_page_size (view->document, &doc_width, &doc_height);
4925         if (view->rotation == 90 || view->rotation == 270) {
4926                 gdouble tmp;
4927
4928                 tmp = doc_width;
4929                 doc_width = doc_height;
4930                 doc_height = tmp;
4931         }
4932
4933         compute_border (view, doc_width, doc_height, &border);
4934
4935         width -= (border.left + border.right + 2 * view->spacing);
4936         height -= (border.top + border.bottom + 2 * view->spacing - 1);
4937
4938         if (view->sizing_mode == EV_SIZING_FIT_WIDTH) {
4939                 gint sb_size;
4940
4941                 sb_size = ev_view_get_scrollbar_size (view, GTK_ORIENTATION_VERTICAL);
4942                 scale = zoom_for_size_fit_width (doc_width, doc_height, width - sb_size, height);
4943         } else if (view->sizing_mode == EV_SIZING_BEST_FIT)
4944                 scale = zoom_for_size_best_fit (doc_width, doc_height, width, height);
4945         else
4946                 g_assert_not_reached ();
4947
4948         ev_document_model_set_scale (view->model, scale);
4949 }
4950
4951 static void
4952 ev_view_zoom_for_size_dual_page (EvView *view,
4953                                  int     width,
4954                                  int     height)
4955 {
4956         GtkBorder border;
4957         gdouble doc_width, doc_height;
4958         gdouble scale;
4959         gint other_page;
4960
4961         other_page = view->current_page ^ 1;
4962
4963         /* Find the largest of the two. */
4964         get_doc_page_size (view, view->current_page, &doc_width, &doc_height);
4965         if (other_page < ev_document_get_n_pages (view->document)) {
4966                 gdouble width_2, height_2;
4967
4968                 get_doc_page_size (view, other_page, &width_2, &height_2);
4969                 if (width_2 > doc_width)
4970                         doc_width = width_2;
4971                 if (height_2 > doc_height)
4972                         doc_height = height_2;
4973         }
4974         compute_border (view, width, height, &border);
4975
4976         doc_width = doc_width * 2;
4977         width -= ((border.left + border.right)* 2 + 3 * view->spacing);
4978         height -= (border.top + border.bottom + 2 * view->spacing);
4979
4980         if (view->sizing_mode == EV_SIZING_FIT_WIDTH) {
4981                 gint sb_size;
4982
4983                 sb_size = ev_view_get_scrollbar_size (view, GTK_ORIENTATION_VERTICAL);
4984                 scale = zoom_for_size_fit_width (doc_width, doc_height, width - sb_size, height);
4985         } else if (view->sizing_mode == EV_SIZING_BEST_FIT)
4986                 scale = zoom_for_size_best_fit (doc_width, doc_height, width, height);
4987         else
4988                 g_assert_not_reached ();
4989
4990         ev_document_model_set_scale (view->model, scale);
4991 }
4992
4993 static void
4994 ev_view_zoom_for_size_single_page (EvView *view,
4995                                    int     width,
4996                                    int     height)
4997 {
4998         gdouble doc_width, doc_height;
4999         GtkBorder border;
5000         gdouble scale;
5001
5002         get_doc_page_size (view, view->current_page, &doc_width, &doc_height);
5003
5004         /* Get an approximate border */
5005         compute_border (view, width, height, &border);
5006
5007         width -= (border.left + border.right + 2 * view->spacing);
5008         height -= (border.top + border.bottom + 2 * view->spacing);
5009
5010         if (view->sizing_mode == EV_SIZING_FIT_WIDTH) {
5011                 gint sb_size;
5012
5013                 sb_size = ev_view_get_scrollbar_size (view, GTK_ORIENTATION_VERTICAL);
5014                 scale = zoom_for_size_fit_width (doc_width, doc_height, width - sb_size, height);
5015         } else if (view->sizing_mode == EV_SIZING_BEST_FIT)
5016                 scale = zoom_for_size_best_fit (doc_width, doc_height, width, height);
5017         else
5018                 g_assert_not_reached ();
5019
5020         ev_document_model_set_scale (view->model, scale);
5021 }
5022
5023 static void
5024 ev_view_zoom_for_size (EvView *view,
5025                        int     width,
5026                        int     height)
5027 {
5028         g_return_if_fail (EV_IS_VIEW (view));
5029         g_return_if_fail (view->sizing_mode == EV_SIZING_FIT_WIDTH ||
5030                           view->sizing_mode == EV_SIZING_BEST_FIT);
5031         g_return_if_fail (width >= 0);
5032         g_return_if_fail (height >= 0);
5033
5034         if (view->document == NULL)
5035                 return;
5036
5037         if (view->continuous && view->dual_page)
5038                 ev_view_zoom_for_size_continuous_and_dual_page (view, width, height);
5039         else if (view->continuous)
5040                 ev_view_zoom_for_size_continuous (view, width, height);
5041         else if (view->dual_page)
5042                 ev_view_zoom_for_size_dual_page (view, width, height);
5043         else
5044                 ev_view_zoom_for_size_single_page (view, width, height);
5045 }
5046
5047 /*** Find ***/
5048 static gint
5049 ev_view_find_get_n_results (EvView *view, gint page)
5050 {
5051         return view->find_pages ? g_list_length (view->find_pages[page]) : 0;
5052 }
5053
5054 static EvRectangle *
5055 ev_view_find_get_result (EvView *view, gint page, gint result)
5056 {
5057         return view->find_pages ? (EvRectangle *) g_list_nth_data (view->find_pages[page], result) : NULL;
5058 }
5059
5060 static void
5061 jump_to_find_result (EvView *view)
5062 {
5063         gint n_results;
5064         gint page = view->current_page;
5065
5066         n_results = ev_view_find_get_n_results (view, page);
5067
5068         if (n_results > 0 && view->find_result < n_results) {
5069                 EvRectangle *rect;
5070                 GdkRectangle view_rect;
5071
5072                 rect = ev_view_find_get_result (view, page, view->find_result);
5073                 doc_rect_to_view_rect (view, page, rect, &view_rect);
5074                 ensure_rectangle_is_visible (view, &view_rect);
5075                 view->jump_to_find_result = FALSE;
5076         }
5077 }
5078
5079 /**
5080  * jump_to_find_page
5081  * @view: #EvView instance
5082  * @direction: Direction to look
5083  * @shift: Shift from current page
5084  *
5085  * Jumps to the first page that has occurences of searched word.
5086  * Uses a direction where to look and a shift from current page.
5087  *
5088  */
5089 static void
5090 jump_to_find_page (EvView *view, EvViewFindDirection direction, gint shift)
5091 {
5092         int n_pages, i;
5093
5094         n_pages = ev_document_get_n_pages (view->document);
5095
5096         for (i = 0; i < n_pages; i++) {
5097                 int page;
5098
5099                 if (direction == EV_VIEW_FIND_NEXT)
5100                         page = view->current_page + i;
5101                 else
5102                         page = view->current_page - i;
5103                 page += shift;
5104
5105                 if (page >= n_pages) {
5106                         page = page - n_pages;
5107                 } else if (page < 0)
5108                         page = page + n_pages;
5109
5110                 if (ev_view_find_get_n_results (view, page) > 0) {
5111                         ev_document_model_set_page (view->model, page);
5112                         break;
5113                 }
5114         }
5115 }
5116
5117 void
5118 ev_view_find_changed (EvView *view, GList **results, gint page)
5119 {
5120         view->find_pages = results;
5121
5122         if (view->jump_to_find_result == TRUE) {
5123                 jump_to_find_page (view, EV_VIEW_FIND_NEXT, 0);
5124                 jump_to_find_result (view);
5125         }
5126
5127         if (view->current_page == page)
5128                 gtk_widget_queue_draw (GTK_WIDGET (view));
5129 }
5130
5131 void
5132 ev_view_find_next (EvView *view)
5133 {
5134         gint n_results;
5135
5136         n_results = ev_view_find_get_n_results (view, view->current_page);
5137         view->find_result++;
5138
5139         if (view->find_result >= n_results) {
5140                 view->find_result = 0;
5141                 jump_to_find_page (view, EV_VIEW_FIND_NEXT, 1);
5142                 jump_to_find_result (view);
5143         } else {
5144                 jump_to_find_result (view);
5145                 gtk_widget_queue_draw (GTK_WIDGET (view));
5146         }
5147 }
5148
5149 void
5150 ev_view_find_previous (EvView *view)
5151 {
5152         view->find_result--;
5153
5154         if (view->find_result < 0) {
5155                 jump_to_find_page (view, EV_VIEW_FIND_PREV, -1);
5156                 view->find_result = MAX (0, ev_view_find_get_n_results (view, view->current_page) - 1);
5157                 jump_to_find_result (view);
5158         } else {
5159                 jump_to_find_result (view);
5160                 gtk_widget_queue_draw (GTK_WIDGET (view));
5161         }
5162 }
5163
5164 void
5165 ev_view_find_search_changed (EvView *view)
5166 {
5167         /* search string has changed, focus on new search result */
5168         view->jump_to_find_result = TRUE;
5169         view->find_pages = NULL;
5170 }
5171
5172 void
5173 ev_view_find_set_highlight_search (EvView *view, gboolean value)
5174 {
5175         view->highlight_find_results = value;
5176         gtk_widget_queue_draw (GTK_WIDGET (view));
5177 }
5178
5179 void
5180 ev_view_find_cancel (EvView *view)
5181 {
5182         view->find_pages = NULL;
5183 }
5184
5185 /*** Selections ***/
5186
5187 /* compute_new_selection_rect/text calculates the area currently selected by
5188  * view_rect.  each handles a different mode;
5189  */
5190 static GList *
5191 compute_new_selection_rect (EvView       *view,
5192                             GdkPoint     *start,
5193                             GdkPoint     *stop)
5194 {
5195         GdkRectangle view_rect;
5196         int n_pages, i;
5197         GList *list = NULL;
5198
5199         g_assert (view->selection_mode == EV_VIEW_SELECTION_RECTANGLE);
5200
5201         view_rect.x = MIN (start->x, stop->x);
5202         view_rect.y = MIN (start->y, stop->y);
5203         view_rect.width = MAX (start->x, stop->x) - view_rect.x;
5204         view_rect.width = MAX (start->y, stop->y) - view_rect.y;
5205
5206         n_pages = ev_document_get_n_pages (view->document);
5207
5208         for (i = 0; i < n_pages; i++) {
5209                 GdkRectangle page_area;
5210                 GtkBorder border;
5211
5212                 if (get_page_extents (view, i, &page_area, &border)) {
5213                         GdkRectangle overlap;
5214
5215                         if (gdk_rectangle_intersect (&page_area, &view_rect, &overlap)) {
5216                                 EvViewSelection *selection;
5217
5218                                 selection = g_new0 (EvViewSelection, 1);
5219                                 selection->page = i;
5220                                 view_rect_to_doc_rect (view, &overlap, &page_area,
5221                                                        &(selection->rect));
5222
5223                                 list = g_list_append (list, selection);
5224                         }
5225                 }
5226         }
5227
5228         return list;
5229 }
5230
5231 static gboolean
5232 gdk_rectangle_point_in (GdkRectangle *rectangle,
5233                         GdkPoint     *point)
5234 {
5235         return rectangle->x <= point->x &&
5236                 rectangle->y <= point->y &&
5237                 point->x < rectangle->x + rectangle->width &&
5238                 point->y < rectangle->y + rectangle->height;
5239 }
5240
5241 static GList *
5242 compute_new_selection_text (EvView          *view,
5243                             EvSelectionStyle style,
5244                             GdkPoint        *start,
5245                             GdkPoint        *stop)
5246 {
5247         int n_pages, i, first, last;
5248         GList *list = NULL;
5249         EvViewSelection *selection;
5250         gdouble width, height;
5251         int start_page, end_page;
5252
5253         g_assert (view->selection_mode == EV_VIEW_SELECTION_TEXT);
5254
5255         n_pages = ev_document_get_n_pages (view->document);
5256
5257         /* First figure out the range of pages the selection
5258          * affects. */
5259         first = n_pages;
5260         last = 0;
5261         if (view->continuous) {
5262                 start_page = 0;
5263                 end_page = n_pages;
5264         } else if (view->dual_page) {
5265                 start_page = view->start_page;
5266                 end_page = view->end_page + 1;
5267         } else {
5268                 start_page = view->current_page;
5269                 end_page = view->current_page + 1;
5270         }
5271
5272         for (i = start_page; i < end_page; i++) {
5273                 GdkRectangle page_area;
5274                 GtkBorder border;
5275
5276                 get_page_extents (view, i, &page_area, &border);
5277                 if (gdk_rectangle_point_in (&page_area, start) ||
5278                     gdk_rectangle_point_in (&page_area, stop)) {
5279                         if (first == n_pages)
5280                                 first = i;
5281                         last = i;
5282                 }
5283
5284         }
5285
5286         /* Now create a list of EvViewSelection's for the affected
5287          * pages.  This could be an empty list, a list of just one
5288          * page or a number of pages.*/
5289         for (i = first; i < last + 1; i++) {
5290                 GdkRectangle page_area;
5291                 GtkBorder border;
5292                 GdkPoint *point;
5293
5294                 get_doc_page_size (view, i, &width, &height);
5295
5296                 selection = g_new0 (EvViewSelection, 1);
5297                 selection->page = i;
5298                 selection->style = style;
5299                 selection->rect.x1 = selection->rect.y1 = 0;
5300                 selection->rect.x2 = width;
5301                 selection->rect.y2 = height;
5302
5303                 get_page_extents (view, i, &page_area, &border);
5304
5305                 if (gdk_rectangle_point_in (&page_area, start))
5306                         point = start;
5307                 else
5308                         point = stop;
5309
5310                 if (i == first)
5311                         view_point_to_doc_point (view, point, &page_area,
5312                                                  &selection->rect.x1,
5313                                                  &selection->rect.y1);
5314
5315                 /* If the selection is contained within just one page,
5316                  * make sure we don't write 'start' into both points
5317                  * in selection->rect. */
5318                 if (first == last)
5319                         point = stop;
5320
5321                 if (i == last)
5322                         view_point_to_doc_point (view, point, &page_area,
5323                                                  &selection->rect.x2,
5324                                                  &selection->rect.y2);
5325
5326                 list = g_list_append (list, selection);
5327         }
5328
5329         return list;
5330 }
5331
5332 /* This function takes the newly calculated list, and figures out which regions
5333  * have changed.  It then queues a redraw approporiately.
5334  */
5335 static void
5336 merge_selection_region (EvView *view,
5337                         GList  *new_list)
5338 {
5339         GList *old_list;
5340         GList *new_list_ptr, *old_list_ptr;
5341
5342         /* Update the selection */
5343         old_list = ev_pixbuf_cache_get_selection_list (view->pixbuf_cache);
5344         g_list_foreach (view->selection_info.selections, (GFunc)selection_free, NULL);
5345         g_list_free (view->selection_info.selections);
5346         view->selection_info.selections = new_list;
5347         ev_pixbuf_cache_set_selection_list (view->pixbuf_cache, new_list);
5348         g_object_notify (G_OBJECT (view), "has-selection");
5349
5350         new_list_ptr = new_list;
5351         old_list_ptr = old_list;
5352
5353         while (new_list_ptr || old_list_ptr) {
5354                 EvViewSelection *old_sel, *new_sel;
5355                 int cur_page;
5356                 GdkRegion *region = NULL;
5357
5358                 new_sel = (new_list_ptr) ? (new_list_ptr->data) : NULL;
5359                 old_sel = (old_list_ptr) ? (old_list_ptr->data) : NULL;
5360
5361                 /* Assume that the lists are in order, and we run through them
5362                  * comparing them, one page at a time.  We come out with the
5363                  * first page we see. */
5364                 if (new_sel && old_sel) {
5365                         if (new_sel->page < old_sel->page) {
5366                                 new_list_ptr = new_list_ptr->next;
5367                                 old_sel = NULL;
5368                         } else if (new_sel->page > old_sel->page) {
5369                                 old_list_ptr = old_list_ptr->next;
5370                                 new_sel = NULL;
5371                         } else {
5372                                 new_list_ptr = new_list_ptr->next;
5373                                 old_list_ptr = old_list_ptr->next;
5374                         }
5375                 } else if (new_sel) {
5376                         new_list_ptr = new_list_ptr->next;
5377                 } else if (old_sel) {
5378                         old_list_ptr = old_list_ptr->next;
5379                 }
5380
5381                 g_assert (new_sel || old_sel);
5382
5383                 /* is the page we're looking at on the screen?*/
5384                 cur_page = new_sel ? new_sel->page : old_sel->page;
5385                 if (cur_page < view->start_page || cur_page > view->end_page)
5386                         continue;
5387
5388                 /* seed the cache with a new page.  We are going to need the new
5389                  * region too. */
5390                 if (new_sel) {
5391                         GdkRegion *tmp_region = NULL;
5392
5393                         ev_pixbuf_cache_get_selection_surface (view->pixbuf_cache,
5394                                                                cur_page,
5395                                                                view->scale,
5396                                                                &tmp_region);
5397
5398                         if (tmp_region) {
5399                                 new_sel->covered_region = gdk_region_copy (tmp_region);
5400                         }
5401                 }
5402
5403                 /* Now we figure out what needs redrawing */
5404                 if (old_sel && new_sel) {
5405                         if (old_sel->covered_region && new_sel->covered_region) {
5406                                 /* We only want to redraw the areas that have
5407                                  * changed, so we xor the old and new regions
5408                                  * and redraw if it's different */
5409                                 region = gdk_region_copy (old_sel->covered_region);
5410                                 gdk_region_xor (region, new_sel->covered_region);
5411                                 if (gdk_region_empty (region)) {
5412                                         gdk_region_destroy (region);
5413                                         region = NULL;
5414                                 }
5415                         } else if (old_sel->covered_region) {
5416                                 region = gdk_region_copy (old_sel->covered_region);
5417                         } else if (new_sel->covered_region) {
5418                                 region = gdk_region_copy (new_sel->covered_region);
5419                         }
5420                 } else if (old_sel && !new_sel) {
5421                         if (old_sel->covered_region && !gdk_region_empty (old_sel->covered_region)) {
5422                                 region = gdk_region_copy (old_sel->covered_region);
5423                         }
5424                 } else if (!old_sel && new_sel) {
5425                         if (new_sel->covered_region && !gdk_region_empty (new_sel->covered_region)) {
5426                                 region = gdk_region_copy (new_sel->covered_region);
5427                         }
5428                 } else {
5429                         g_assert_not_reached ();
5430                 }
5431
5432                 /* Redraw the damaged region! */
5433                 if (region) {
5434                         GdkRectangle page_area;
5435                         GtkBorder border;
5436
5437                         /* I don't know why but the region is smaller
5438                          * than expected. This hack fixes it, I guess
5439                          * 10 pixels more won't hurt
5440                          */
5441                         gdk_region_shrink (region, -5, -5);
5442
5443                         get_page_extents (view, cur_page, &page_area, &border);
5444                         gdk_region_offset (region,
5445                                            page_area.x + border.left - view->scroll_x,
5446                                            page_area.y + border.top - view->scroll_y);
5447                         gdk_window_invalidate_region (view->layout.bin_window, region, TRUE);
5448                         gdk_region_destroy (region);
5449                 }
5450         }
5451
5452         /* Free the old list, now that we're done with it. */
5453         g_list_foreach (old_list, (GFunc) selection_free, NULL);
5454         g_list_free (old_list);
5455 }
5456
5457 static void
5458 compute_selections (EvView          *view,
5459                     EvSelectionStyle style,
5460                     GdkPoint        *start,
5461                     GdkPoint        *stop)
5462 {
5463         GList *list;
5464
5465         if (view->selection_mode == EV_VIEW_SELECTION_RECTANGLE)
5466                 list = compute_new_selection_rect (view, start, stop);
5467         else
5468                 list = compute_new_selection_text (view, style, start, stop);
5469         merge_selection_region (view, list);
5470 }
5471
5472 /* Free's the selection.  It's up to the caller to queue redraws if needed.
5473  */
5474 static void
5475 selection_free (EvViewSelection *selection)
5476 {
5477         if (selection->covered_region)
5478                 gdk_region_destroy (selection->covered_region);
5479         g_free (selection);
5480 }
5481
5482 static void
5483 clear_selection (EvView *view)
5484 {
5485         g_list_foreach (view->selection_info.selections, (GFunc)selection_free, NULL);
5486         g_list_free (view->selection_info.selections);
5487         view->selection_info.selections = NULL;
5488         view->selection_info.in_selection = FALSE;
5489         if (view->pixbuf_cache)
5490                 ev_pixbuf_cache_set_selection_list (view->pixbuf_cache, NULL);
5491         g_object_notify (G_OBJECT (view), "has-selection");
5492 }
5493
5494 void
5495 ev_view_select_all (EvView *view)
5496 {
5497         GList *selections = NULL;
5498         int n_pages, i;
5499
5500         /* Disable selection on rotated pages for the 0.4.0 series */
5501         if (view->rotation != 0)
5502                 return;
5503
5504         clear_selection (view);
5505
5506         n_pages = ev_document_get_n_pages (view->document);
5507         for (i = 0; i < n_pages; i++) {
5508                 gdouble width, height;
5509                 EvViewSelection *selection;
5510
5511                 get_doc_page_size (view, i, &width, &height);
5512
5513                 selection = g_new0 (EvViewSelection, 1);
5514                 selection->page = i;
5515                 selection->style = EV_SELECTION_STYLE_GLYPH;
5516                 selection->rect.x1 = selection->rect.y1 = 0;
5517                 selection->rect.x2 = width;
5518                 selection->rect.y2 = height;
5519
5520                 selections = g_list_append (selections, selection);
5521         }
5522
5523         merge_selection_region (view, selections);
5524         gtk_widget_queue_draw (GTK_WIDGET (view));
5525 }
5526
5527 gboolean
5528 ev_view_get_has_selection (EvView *view)
5529 {
5530         return view->selection_info.selections != NULL;
5531 }
5532
5533 static char *
5534 get_selected_text (EvView *view)
5535 {
5536         GString *text;
5537         GList *l;
5538         gchar *normalized_text;
5539         EvRenderContext *rc;
5540
5541         text = g_string_new (NULL);
5542         rc = ev_render_context_new (NULL, view->rotation, view->scale);
5543
5544         ev_document_doc_mutex_lock ();
5545
5546         for (l = view->selection_info.selections; l != NULL; l = l->next) {
5547                 EvViewSelection *selection = (EvViewSelection *)l->data;
5548                 EvPage *page;
5549                 gchar *tmp;
5550
5551                 page = ev_document_get_page (view->document, selection->page);
5552                 ev_render_context_set_page (rc, page);
5553                 g_object_unref (page);
5554
5555                 tmp = ev_selection_get_selected_text (EV_SELECTION (view->document),
5556                                                       rc, selection->style,
5557                                                       &(selection->rect));
5558
5559                 g_string_append (text, tmp);
5560                 g_free (tmp);
5561         }
5562
5563         g_object_unref (rc);
5564
5565         ev_document_doc_mutex_unlock ();
5566
5567         normalized_text = g_utf8_normalize (text->str, text->len, G_NORMALIZE_NFKC);
5568         g_string_free (text, TRUE);
5569         return normalized_text;
5570 }
5571
5572 static void
5573 ev_view_clipboard_copy (EvView      *view,
5574                         const gchar *text)
5575 {
5576         GtkClipboard *clipboard;
5577
5578         clipboard = gtk_widget_get_clipboard (GTK_WIDGET (view),
5579                                               GDK_SELECTION_CLIPBOARD);
5580         gtk_clipboard_set_text (clipboard, text, -1);
5581 }
5582
5583 void
5584 ev_view_copy (EvView *ev_view)
5585 {
5586         char *text;
5587
5588         if (!EV_IS_SELECTION (ev_view->document))
5589                 return;
5590
5591         text = get_selected_text (ev_view);
5592         ev_view_clipboard_copy (ev_view, text);
5593         g_free (text);
5594 }
5595
5596 static void
5597 ev_view_primary_get_cb (GtkClipboard     *clipboard,
5598                         GtkSelectionData *selection_data,
5599                         guint             info,
5600                         gpointer          data)
5601 {
5602         EvView *ev_view = EV_VIEW (data);
5603
5604         if (ev_view->link_selected) {
5605                 gtk_selection_data_set_text (selection_data,
5606                                              ev_link_action_get_uri (ev_view->link_selected),
5607                                              -1);
5608         } else if (EV_IS_SELECTION (ev_view->document) &&
5609                    ev_view->selection_info.selections) {
5610                 gchar *text;
5611
5612                 text = get_selected_text (ev_view);
5613                 if (text) {
5614                         gtk_selection_data_set_text (selection_data, text, -1);
5615                         g_free (text);
5616                 }
5617         }
5618 }
5619
5620 static void
5621 ev_view_primary_clear_cb (GtkClipboard *clipboard,
5622                           gpointer      data)
5623 {
5624         EvView *view = EV_VIEW (data);
5625
5626         clear_selection (view);
5627         clear_link_selected (view);
5628 }
5629
5630 static void
5631 ev_view_update_primary_selection (EvView *ev_view)
5632 {
5633         GtkClipboard *clipboard;
5634
5635         clipboard = gtk_widget_get_clipboard (GTK_WIDGET (ev_view),
5636                                               GDK_SELECTION_PRIMARY);
5637
5638         if (ev_view->selection_info.selections || ev_view->link_selected) {
5639                 GtkTargetList *target_list;
5640                 GtkTargetEntry *targets;
5641                 int n_targets;
5642
5643                 target_list = gtk_target_list_new (NULL, 0);
5644                 gtk_target_list_add_text_targets (target_list, 0);
5645                 targets = gtk_target_table_new_from_list (target_list, &n_targets);
5646                 gtk_target_list_unref (target_list);
5647
5648                 if (!gtk_clipboard_set_with_owner (clipboard,
5649                                                    targets, n_targets,
5650                                                    ev_view_primary_get_cb,
5651                                                    ev_view_primary_clear_cb,
5652                                                    G_OBJECT (ev_view)))
5653                         ev_view_primary_clear_cb (clipboard, ev_view);
5654
5655                 gtk_target_table_free (targets, n_targets);
5656         } else {
5657                 if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (ev_view))
5658                         gtk_clipboard_clear (clipboard);
5659         }
5660 }
5661
5662 static void
5663 clear_link_selected (EvView *view)
5664 {
5665         if (view->link_selected) {
5666                 g_object_unref (view->link_selected);
5667                 view->link_selected = NULL;
5668         }
5669 }
5670
5671 void
5672 ev_view_copy_link_address (EvView       *view,
5673                            EvLinkAction *action)
5674 {
5675         clear_link_selected (view);
5676
5677         ev_view_clipboard_copy (view, ev_link_action_get_uri (action));
5678
5679         view->link_selected = g_object_ref (action);
5680         ev_view_update_primary_selection (view);
5681 }
5682
5683 /*** Cursor operations ***/
5684 static void
5685 ev_view_set_cursor (EvView *view, EvViewCursor new_cursor)
5686 {
5687         GdkCursor *cursor = NULL;
5688         GtkWidget *widget;
5689
5690         if (view->cursor == new_cursor) {
5691                 return;
5692         }
5693
5694         view->cursor = new_cursor;
5695
5696         widget = gtk_widget_get_toplevel (GTK_WIDGET (view));
5697         cursor = ev_view_cursor_new (gtk_widget_get_display (widget), new_cursor);
5698         gdk_window_set_cursor (view->layout.bin_window, cursor);
5699         gdk_flush ();
5700         if (cursor)
5701                 gdk_cursor_unref (cursor);
5702 }
5703
5704 void
5705 ev_view_hide_cursor (EvView *view)
5706 {
5707        ev_view_set_cursor (view, EV_VIEW_CURSOR_HIDDEN);
5708 }
5709
5710 void
5711 ev_view_show_cursor (EvView *view)
5712 {
5713        ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
5714 }
5715
5716 gboolean
5717 ev_view_next_page (EvView *view)
5718 {
5719         int page, n_pages;
5720
5721         g_return_val_if_fail (EV_IS_VIEW (view), FALSE);
5722
5723         if (!view->document)
5724                 return FALSE;
5725
5726         page = ev_document_model_get_page (view->model);
5727         n_pages = ev_document_get_n_pages (view->document);
5728
5729         if (view->dual_page)
5730                 page = page + 2;
5731         else
5732                 page = page + 1;
5733
5734         if (page < n_pages) {
5735                 ev_document_model_set_page (view->model, page);
5736                 return TRUE;
5737         } else if (view->dual_page && page == n_pages) {
5738                 ev_document_model_set_page (view->model, page - 1);
5739                 return TRUE;
5740         } else {
5741                 return FALSE;
5742         }
5743 }
5744
5745 gboolean
5746 ev_view_previous_page (EvView *view)
5747 {
5748         int page;
5749
5750         g_return_val_if_fail (EV_IS_VIEW (view), FALSE);
5751
5752         if (!view->document)
5753                 return FALSE;
5754
5755         page = ev_document_model_get_page (view->model);
5756
5757         if (view->dual_page)
5758                 page = page - 2;
5759         else
5760                 page = page - 1;
5761
5762         if (page >= 0) {
5763                 ev_document_model_set_page (view->model, page);
5764                 return TRUE;
5765         } else if (view->dual_page && page == -1) {
5766                 ev_document_model_set_page (view->model, 0);
5767                 return TRUE;
5768         } else {
5769                 return FALSE;
5770         }
5771 }
5772