shell/ev-view.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; c-indent-level: 8 -*- */
   2 /* this file is part of evince, a gnome document viewer
   3  *
   4  *  Copyright (C) 2004 Red Hat, Inc
   5  *
   6  * Evince is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Evince is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <gtk/gtkalignment.h>
  22 #include <glib/gi18n.h>
  23 #include <gtk/gtkbindings.h>
  24 #include <gtk/gtkselection.h>
  25 #include <gtk/gtkclipboard.h>
  26 #include <gdk/gdkkeysyms.h>
  27 #include <libgnomevfs/gnome-vfs-utils.h>
  28
  29 #include "ev-marshal.h"
  30 #include "ev-view.h"
  31 #include "ev-document-find.h"
  32 #include "ev-document-misc.h"
  33 #include "ev-debug.h"
  34
  35 #define EV_VIEW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), EV_TYPE_VIEW, EvViewClass))
  36 #define EV_IS_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EV_TYPE_VIEW))
  37 #define EV_VIEW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), EV_TYPE_VIEW, EvViewClass))
  38
  39 enum {
  40         PROP_0,
  41         PROP_STATUS,
  42         PROP_FIND_STATUS
  43 };
  44
  45 enum {
  46   TARGET_STRING,
  47   TARGET_TEXT,
  48   TARGET_COMPOUND_TEXT,
  49   TARGET_UTF8_STRING,
  50   TARGET_TEXT_BUFFER_CONTENTS
  51 };
  52
  53 static const GtkTargetEntry targets[] = {
  54         { "STRING", 0, TARGET_STRING },
  55         { "TEXT",   0, TARGET_TEXT },
  56         { "COMPOUND_TEXT", 0, TARGET_COMPOUND_TEXT },
  57         { "UTF8_STRING", 0, TARGET_UTF8_STRING },
  58 };
  59
  60 typedef enum {
  61         EV_VIEW_CURSOR_NORMAL,
  62         EV_VIEW_CURSOR_LINK,
  63         EV_VIEW_CURSOR_WAIT
  64 } EvViewCursor;
  65
  66 #define ZOOM_IN_FACTOR  1.2
  67 #define ZOOM_OUT_FACTOR (1.0/ZOOM_IN_FACTOR)
  68
  69 #define MIN_SCALE 0.05409
  70 #define MAX_SCALE 18.4884
  71 #define ZOOM_EPSILON 1e-10
  72
  73
  74 struct _EvView {
  75         GtkWidget parent_instance;
  76
  77         EvDocument *document;
  78
  79         GdkWindow *bin_window;
  80
  81         char *status;
  82         char *find_status;
  83
  84         int scroll_x;
  85         int scroll_y;
  86
  87         gboolean pressed_button;
  88         gboolean has_selection;
  89         GdkPoint selection_start;
  90         GdkRectangle selection;
  91         EvViewCursor cursor;
  92
  93         GtkAdjustment *hadjustment;
  94         GtkAdjustment *vadjustment;
  95
  96         int find_page;
  97         int find_result;
  98         int spacing;
  99
 100         double scale;
 101         EvSizingMode sizing_mode;
 102 };
 103
 104 struct _EvViewClass {
 105         GtkWidgetClass parent_class;
 106
 107         void    (*set_scroll_adjustments) (EvView         *view,
 108                                            GtkAdjustment  *hadjustment,
 109                                            GtkAdjustment  *vadjustment);
 110         void    (*scroll_view)            (EvView         *view,
 111                                            GtkScrollType   scroll,
 112                                            gboolean        horizontal);
 113
 114         /* Should this be notify::page? */
 115         void    (*page_changed)           (EvView         *view);
 116 };
 117
 118 static guint page_changed_signal = 0;
 119
 120 static void ev_view_set_scroll_adjustments (EvView         *view,
 121                                             GtkAdjustment  *hadjustment,
 122                                             GtkAdjustment  *vadjustment);
 123
 124 G_DEFINE_TYPE (EvView, ev_view, GTK_TYPE_WIDGET)
 125
 126 /*** Helper functions ***/
 127
 128 static void
 129 view_update_adjustments (EvView *view)
 130 {
 131         int old_x = view->scroll_x;
 132         int old_y = view->scroll_y;
 133
 134         if (view->hadjustment)
 135                 view->scroll_x = view->hadjustment->value;
 136         else
 137                 view->scroll_x = 0;
 138
 139         if (view->vadjustment)
 140                 view->scroll_y = view->vadjustment->value;
 141         else
 142                 view->scroll_y = 0;
 143
 144         if (GTK_WIDGET_REALIZED (view) &&
 145             (view->scroll_x != old_x || view->scroll_y != old_y)) {
 146                 gdk_window_move (view->bin_window, - view->scroll_x, - view->scroll_y);
 147                 gdk_window_process_updates (view->bin_window, TRUE);
 148         }
 149 }
 150
 151 static void
 152 view_set_adjustment_values (EvView         *view,
 153                             GtkOrientation  orientation)
 154 {
 155         GtkWidget *widget = GTK_WIDGET (view);
 156         GtkAdjustment *adjustment;
 157         gboolean value_changed = FALSE;
 158         int requisition;
 159         int allocation;
 160
 161         if (orientation == GTK_ORIENTATION_HORIZONTAL)  {
 162                 requisition = widget->requisition.width;
 163                 allocation = widget->allocation.width;
 164                 adjustment = view->hadjustment;
 165         } else {
 166                 requisition = widget->requisition.height;
 167                 allocation = widget->allocation.height;
 168                 adjustment = view->vadjustment;
 169         }
 170
 171         if (!adjustment)
 172                 return;
 173
 174         adjustment->page_size = allocation;
 175         adjustment->step_increment = allocation * 0.1;
 176         adjustment->page_increment = allocation * 0.9;
 177         adjustment->lower = 0;
 178         adjustment->upper = MAX (allocation, requisition);
 179
 180         if (adjustment->value > adjustment->upper - adjustment->page_size) {
 181                 adjustment->value = adjustment->upper - adjustment->page_size;
 182                 value_changed = TRUE;
 183         }
 184
 185         gtk_adjustment_changed (adjustment);
 186         if (value_changed)
 187                 gtk_adjustment_value_changed (adjustment);
 188 }
 189
 190 /*** Virtual function implementations ***/
 191
 192 static void
 193 ev_view_finalize (GObject *object)
 194 {
 195         EvView *view = EV_VIEW (object);
 196
 197         LOG ("Finalize");
 198
 199         if (view->document)
 200                 g_object_unref (view->document);
 201
 202         ev_view_set_scroll_adjustments (view, NULL, NULL);
 203
 204         G_OBJECT_CLASS (ev_view_parent_class)->finalize (object);
 205 }
 206
 207 static void
 208 ev_view_destroy (GtkObject *object)
 209 {
 210         EvView *view = EV_VIEW (object);
 211
 212         ev_view_set_scroll_adjustments (view, NULL, NULL);
 213
 214         GTK_OBJECT_CLASS (ev_view_parent_class)->destroy (object);
 215 }
 216
 217 static void
 218 ev_view_size_request (GtkWidget      *widget,
 219                       GtkRequisition *requisition)
 220 {
 221         EvView *view = EV_VIEW (widget);
 222         GtkBorder border;
 223         gint width, height;
 224
 225         if (! GTK_WIDGET_REALIZED (widget))
 226                 return;
 227
 228         if (! view->document) {
 229                 requisition->width = 1;
 230                 requisition->height = 1;
 231                 return;
 232         }
 233
 234         ev_document_get_page_size (view->document, -1,
 235                                    &width, &height);
 236         ev_document_misc_get_page_border_size (width, height, &border);
 237
 238         switch (view->sizing_mode) {
 239         case EV_SIZING_BEST_FIT:
 240                 requisition->width = MIN_SCALE * ((float) width) / view->scale;
 241                 requisition->height = MIN_SCALE * ((float) height) / view->scale;
 242                 break;
 243         case EV_SIZING_FIT_WIDTH:
 244                 requisition->width = MIN_SCALE * ((float) width) / view->scale;
 245                 requisition->height = height + border.top + border.bottom;
 246                 requisition->height += view->spacing * 2;
 247                 break;
 248         case EV_SIZING_FREE:
 249                 requisition->width = width + border.left + border.right;
 250                 requisition->height = height + border.top + border.bottom;
 251                 requisition->width += view->spacing * 2;
 252                 requisition->height += view->spacing * 2;
 253                 break;
 254         }
 255 }
 256
 257 static void
 258 ev_view_size_allocate (GtkWidget      *widget,
 259                        GtkAllocation  *allocation)
 260 {
 261         EvView *view = EV_VIEW (widget);
 262
 263         GTK_WIDGET_CLASS (ev_view_parent_class)->size_allocate (widget, allocation);
 264
 265         view_set_adjustment_values (view, GTK_ORIENTATION_HORIZONTAL);
 266         view_set_adjustment_values (view, GTK_ORIENTATION_VERTICAL);
 267
 268         if (GTK_WIDGET_REALIZED (widget)) {
 269                 gdk_window_resize (view->bin_window,
 270                                    MAX (widget->allocation.width, widget->requisition.width),
 271                                    MAX (widget->allocation.height, widget->requisition.height));
 272         }
 273 }
 274
 275 static void
 276 ev_view_realize (GtkWidget *widget)
 277 {
 278         EvView *view = EV_VIEW (widget);
 279         GdkWindowAttr attributes;
 280
 281         GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 282
 283         attributes.window_type = GDK_WINDOW_CHILD;
 284         attributes.wclass = GDK_INPUT_OUTPUT;
 285         attributes.visual = gtk_widget_get_visual (widget);
 286         attributes.colormap = gtk_widget_get_colormap (widget);
 287
 288         attributes.x = widget->allocation.x;
 289         attributes.y = widget->allocation.y;
 290         attributes.width = widget->allocation.width;
 291         attributes.height = widget->allocation.height;
 292         attributes.event_mask = 0;
 293
 294         widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
 295                                          &attributes,
 296                                          GDK_WA_X | GDK_WA_Y |
 297                                          GDK_WA_COLORMAP |
 298                                          GDK_WA_VISUAL);
 299         gdk_window_set_user_data (widget->window, widget);
 300         widget->style = gtk_style_attach (widget->style, widget->window);
 301
 302         attributes.x = 0;
 303         attributes.y = 0;
 304         attributes.width = MAX (widget->allocation.width, widget->requisition.width);
 305         attributes.height = MAX (widget->allocation.height, widget->requisition.height);
 306         attributes.event_mask = GDK_EXPOSURE_MASK |
 307                                 GDK_BUTTON_PRESS_MASK |
 308                                 GDK_BUTTON_RELEASE_MASK |
 309                                 GDK_SCROLL_MASK |
 310                                 GDK_KEY_PRESS_MASK |
 311                                 GDK_POINTER_MOTION_MASK;
 312
 313         view->bin_window = gdk_window_new (widget->window,
 314                                            &attributes,
 315                                            GDK_WA_X | GDK_WA_Y |
 316                                            GDK_WA_COLORMAP |
 317                                            GDK_WA_VISUAL);
 318         gdk_window_set_user_data (view->bin_window, widget);
 319         gdk_window_show (view->bin_window);
 320
 321         widget->style = gtk_style_attach (widget->style, view->bin_window);
 322         gdk_window_set_background (view->bin_window, &widget->style->mid[widget->state]);
 323
 324         if (view->document) {
 325                 ev_document_set_target (view->document, view->bin_window);
 326
 327                 /* We can't get page size without a target, so we have to
 328                  * queue a size request at realization. Could be fixed
 329                  * with EvDocument changes to allow setting a GdkScreen
 330                  * without setting a target.
 331                  */
 332                 gtk_widget_queue_resize (widget);
 333         }
 334 }
 335
 336 static void
 337 ev_view_unrealize (GtkWidget *widget)
 338 {
 339         EvView *view = EV_VIEW (widget);
 340
 341         if (view->document)
 342                 ev_document_set_target (view->document, NULL);
 343
 344         gdk_window_set_user_data (view->bin_window, NULL);
 345         gdk_window_destroy (view->bin_window);
 346         view->bin_window = NULL;
 347
 348         GTK_WIDGET_CLASS (ev_view_parent_class)->unrealize (widget);
 349 }
 350
 351 static guint32
 352 ev_gdk_color_to_rgb (const GdkColor *color)
 353 {
 354   guint32 result;
 355   result = (0xff0000 | (color->red & 0xff00));
 356   result <<= 8;
 357   result |= ((color->green & 0xff00) | (color->blue >> 8));
 358   return result;
 359 }
 360
 361 static void
 362 draw_rubberband (GtkWidget *widget, GdkWindow *window,
 363                  const GdkRectangle *rect, guchar alpha)
 364 {
 365         GdkGC *gc;
 366         GdkPixbuf *pixbuf;
 367         GdkColor *fill_color_gdk;
 368         guint fill_color;
 369
 370         fill_color_gdk = gdk_color_copy (&GTK_WIDGET (widget)->style->base[GTK_STATE_SELECTED]);
 371         fill_color = ev_gdk_color_to_rgb (fill_color_gdk) << 8 | alpha;
 372
 373         pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8,
 374                                  rect->width, rect->height);
 375         gdk_pixbuf_fill (pixbuf, fill_color);
 376
 377         gdk_draw_pixbuf (window, NULL, pixbuf,
 378                          0, 0,
 379                          rect->x,rect->y,
 380                          rect->width, rect->height,
 381                          GDK_RGB_DITHER_NONE,
 382                          0, 0);
 383
 384         g_object_unref (pixbuf);
 385
 386         gc = gdk_gc_new (window);
 387         gdk_gc_set_rgb_fg_color (gc, fill_color_gdk);
 388         gdk_draw_rectangle (window, gc, FALSE,
 389                             rect->x, rect->y,
 390                             rect->width - 1,
 391                             rect->height - 1);
 392         g_object_unref (gc);
 393
 394         gdk_color_free (fill_color_gdk);
 395 }
 396
 397 static void
 398 highlight_find_results (EvView *view)
 399 {
 400         EvDocumentFind *find = EV_DOCUMENT_FIND (view->document);
 401         int i, results;
 402
 403         results = ev_document_find_get_n_results (find);
 404
 405         for (i = 0; i < results; i++) {
 406                 GdkRectangle rectangle;
 407                 guchar alpha;
 408
 409                 alpha = (i == view->find_result) ? 0x90 : 0x20;
 410                 ev_document_find_get_result (find, i, &rectangle);
 411                 draw_rubberband (GTK_WIDGET (view), view->bin_window,
 412                                  &rectangle, alpha);
 413         }
 414 }
 415
 416
 417 static void
 418 expose_bin_window (GtkWidget      *widget,
 419                    GdkEventExpose *event)
 420 {
 421         EvView *view = EV_VIEW (widget);
 422         int x_offset, y_offset;
 423         GtkBorder border;
 424         gint width, height;
 425         GdkRectangle area;
 426         int target_width, target_height;
 427
 428         if (view->document == NULL)
 429                 return;
 430
 431         ev_document_get_page_size (view->document, -1,
 432                                    &width, &height);
 433         ev_document_misc_get_page_border_size (width, height, &border);
 434
 435         x_offset = view->spacing;
 436         y_offset = view->spacing;
 437         target_width = width + border.left + border.right + view->spacing * 2;
 438         target_height = height + border.top + border.bottom + view->spacing * 2;
 439
 440         x_offset += MAX (0, (widget->allocation.width - target_width) / 2);
 441         y_offset += MAX (0, (widget->allocation.height - target_height) / 2);
 442
 443         /* Paint the frame */
 444         area.x = x_offset;
 445         area.y = y_offset;
 446         area.width = width + border.left + border.right;
 447         area.height = height + border.top + border.bottom;
 448         ev_document_misc_paint_one_page (view->bin_window, widget, &area, &border);
 449
 450         /* Render the document itself */
 451         ev_document_set_page_offset (view->document,
 452                                      x_offset + border.left,
 453                                      y_offset + border.top);
 454
 455         LOG ("Render area %d %d %d %d", event->area.x, event->area.y,
 456              event->area.width, event->area.height);
 457
 458         ev_document_render (view->document,
 459                             event->area.x, event->area.y,
 460                             event->area.width, event->area.height);
 461
 462         if (EV_IS_DOCUMENT_FIND (view->document)) {
 463                 highlight_find_results (view);
 464         }
 465
 466         if (view->has_selection) {
 467                 draw_rubberband (widget, view->bin_window,
 468                                  &view->selection, 0x40);
 469         }
 470 }
 471
 472 static gboolean
 473 ev_view_expose_event (GtkWidget      *widget,
 474                       GdkEventExpose *event)
 475 {
 476         EvView *view = EV_VIEW (widget);
 477
 478         if (event->window == view->bin_window)
 479                 expose_bin_window (widget, event);
 480         else
 481                 return GTK_WIDGET_CLASS (ev_view_parent_class)->expose_event (widget, event);
 482
 483         return FALSE;
 484 }
 485
 486 void
 487 ev_view_select_all (EvView *ev_view)
 488 {
 489         GtkWidget *widget = GTK_WIDGET (ev_view);
 490
 491         g_return_if_fail (EV_IS_VIEW (ev_view));
 492
 493         ev_view->has_selection = TRUE;
 494         ev_view->selection.x = ev_view->selection.y = 0;
 495         ev_view->selection.width = widget->requisition.width;
 496         ev_view->selection.height = widget->requisition.height;
 497
 498         gtk_widget_queue_draw (widget);
 499 }
 500
 501 void
 502 ev_view_copy (EvView *ev_view)
 503 {
 504         GtkClipboard *clipboard;
 505         char *text;
 506
 507         text = ev_document_get_text (ev_view->document, &ev_view->selection);
 508         clipboard = gtk_widget_get_clipboard (GTK_WIDGET (ev_view),
 509                                               GDK_SELECTION_CLIPBOARD);
 510         gtk_clipboard_set_text (clipboard, text, -1);
 511         g_free (text);
 512 }
 513
 514 static void
 515 ev_view_primary_get_cb (GtkClipboard     *clipboard,
 516                         GtkSelectionData *selection_data,
 517                         guint             info,
 518                         gpointer          data)
 519 {
 520         EvView *ev_view = EV_VIEW (data);
 521         char *text;
 522
 523         text = ev_document_get_text (ev_view->document, &ev_view->selection);
 524         gtk_selection_data_set_text (selection_data, text, -1);
 525 }
 526
 527 static void
 528 ev_view_primary_clear_cb (GtkClipboard *clipboard,
 529                           gpointer      data)
 530 {
 531         EvView *ev_view = EV_VIEW (data);
 532
 533         ev_view->has_selection = FALSE;
 534 }
 535
 536 static void
 537 ev_view_update_primary_selection (EvView *ev_view)
 538 {
 539         GtkClipboard *clipboard;
 540
 541         clipboard = gtk_widget_get_clipboard (GTK_WIDGET (ev_view),
 542                                               GDK_SELECTION_PRIMARY);
 543
 544         if (ev_view->has_selection) {
 545                 if (!gtk_clipboard_set_with_owner (clipboard,
 546                                                    targets,
 547                                                    G_N_ELEMENTS (targets),
 548                                                    ev_view_primary_get_cb,
 549                                                    ev_view_primary_clear_cb,
 550                                                    G_OBJECT (ev_view)))
 551                         ev_view_primary_clear_cb (clipboard, ev_view);
 552         } else {
 553                 if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (ev_view))
 554                         gtk_clipboard_clear (clipboard);
 555         }
 556 }
 557
 558 static gboolean
 559 ev_view_button_press_event (GtkWidget      *widget,
 560                             GdkEventButton *event)
 561 {
 562         EvView *view = EV_VIEW (widget);
 563
 564         if (!GTK_WIDGET_HAS_FOCUS (widget)) {
 565                 gtk_widget_grab_focus (widget);
 566         }
 567
 568         view->pressed_button = event->button;
 569
 570         switch (event->button) {
 571                 case 1:
 572                         if (view->has_selection) {
 573                                 view->has_selection = FALSE;
 574                                 gtk_widget_queue_draw (widget);
 575                         }
 576
 577                         view->selection_start.x = event->x;
 578                         view->selection_start.y = event->y;
 579                         break;
 580         }
 581
 582         return TRUE;
 583 }
 584
 585 static char *
 586 status_message_from_link (EvLink *link)
 587 {
 588         EvLinkType type;
 589         char *msg;
 590         int page;
 591
 592         type = ev_link_get_link_type (link);
 593
 594         switch (type) {
 595                 case EV_LINK_TYPE_TITLE:
 596                         msg = g_strdup (ev_link_get_title (link));
 597                         break;
 598                 case EV_LINK_TYPE_PAGE:
 599                         page = ev_link_get_page (link);
 600                         msg = g_strdup_printf (_("Go to page %d"), page);
 601                         break;
 602                 case EV_LINK_TYPE_EXTERNAL_URI:
 603                         msg = g_strdup (ev_link_get_uri (link));
 604                         break;
 605                 default:
 606                         msg = NULL;
 607         }
 608
 609         return msg;
 610 }
 611
 612 static void
 613 ev_view_set_status (EvView *view, const char *message)
 614 {
 615         g_return_if_fail (EV_IS_VIEW (view));
 616
 617         if (message != view->status) {
 618                 g_free (view->status);
 619                 view->status = g_strdup (message);
 620                 g_object_notify (G_OBJECT (view), "status");
 621         }
 622 }
 623
 624 static void
 625 ev_view_set_find_status (EvView *view, const char *message)
 626 {
 627         g_return_if_fail (EV_IS_VIEW (view));
 628
 629         g_free (view->find_status);
 630         view->find_status = g_strdup (message);
 631         g_object_notify (G_OBJECT (view), "find-status");
 632 }
 633
 634
 635 static void
 636 ev_view_set_cursor (EvView *view, EvViewCursor new_cursor)
 637 {
 638         GdkCursor *cursor = NULL;
 639         GdkDisplay *display;
 640         GtkWidget *widget;
 641
 642         if (view->cursor == new_cursor) {
 643                 return;
 644         }
 645
 646         widget = gtk_widget_get_toplevel (GTK_WIDGET (view));
 647         display = gtk_widget_get_display (widget);
 648         view->cursor = new_cursor;
 649
 650         switch (new_cursor) {
 651                 case EV_VIEW_CURSOR_NORMAL:
 652                         gdk_window_set_cursor (widget->window, NULL);
 653                         break;
 654                 case EV_VIEW_CURSOR_LINK:
 655                         cursor = gdk_cursor_new_for_display (display, GDK_HAND2);
 656                         break;
 657                 case EV_VIEW_CURSOR_WAIT:
 658                         cursor = gdk_cursor_new_for_display (display, GDK_WATCH);
 659                         break;
 660         }
 661
 662         if (cursor) {
 663                 gdk_window_set_cursor (widget->window, cursor);
 664                 gdk_cursor_unref (cursor);
 665                 gdk_flush();
 666         }
 667 }
 668
 669 static gboolean
 670 ev_view_motion_notify_event (GtkWidget      *widget,
 671                              GdkEventMotion *event)
 672 {
 673         EvView *view = EV_VIEW (widget);
 674
 675         if (view->pressed_button > 0) {
 676                 view->has_selection = TRUE;
 677                 view->selection.x = MIN (view->selection_start.x, event->x);
 678                 view->selection.y = MIN (view->selection_start.y, event->y);
 679                 view->selection.width = ABS (view->selection_start.x - event->x) + 1;
 680                 view->selection.height = ABS (view->selection_start.y - event->y) + 1;
 681
 682                 gtk_widget_queue_draw (widget);
 683         } else if (view->document) {
 684                 EvLink *link;
 685
 686                 link = ev_document_get_link (view->document, event->x, event->y);
 687                 if (link) {
 688                         char *msg;
 689
 690                         msg = status_message_from_link (link);
 691                         ev_view_set_status (view, msg);
 692                         ev_view_set_cursor (view, EV_VIEW_CURSOR_LINK);
 693                         g_free (msg);
 694
 695                         g_object_unref (link);
 696                 } else {
 697                         ev_view_set_status (view, NULL);
 698                         if (view->cursor == EV_VIEW_CURSOR_LINK) {
 699                                 ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
 700                         }
 701                 }
 702         }
 703
 704         return TRUE;
 705 }
 706
 707 static gboolean
 708 ev_view_button_release_event (GtkWidget      *widget,
 709                               GdkEventButton *event)
 710 {
 711         EvView *view = EV_VIEW (widget);
 712
 713         view->pressed_button = -1;
 714
 715         if (view->has_selection) {
 716                 ev_view_update_primary_selection (view);
 717         } else if (view->document) {
 718                 EvLink *link;
 719
 720                 link = ev_document_get_link (view->document,
 721                                              event->x,
 722                                              event->y);
 723                 if (link) {
 724                         ev_view_go_to_link (view, link);
 725                         g_object_unref (link);
 726                 }
 727         }
 728
 729         return FALSE;
 730 }
 731
 732 static void
 733 on_adjustment_value_changed (GtkAdjustment  *adjustment,
 734                              EvView *view)
 735 {
 736         view_update_adjustments (view);
 737 }
 738
 739 static void
 740 set_scroll_adjustment (EvView *view,
 741                        GtkOrientation  orientation,
 742                        GtkAdjustment  *adjustment)
 743 {
 744         GtkAdjustment **to_set;
 745
 746         if (orientation == GTK_ORIENTATION_HORIZONTAL)
 747                 to_set = &view->hadjustment;
 748         else
 749                 to_set = &view->vadjustment;
 750
 751         if (*to_set != adjustment) {
 752                 if (*to_set) {
 753                         g_signal_handlers_disconnect_by_func (*to_set,
 754                                                               (gpointer) on_adjustment_value_changed,
 755                                                               view);
 756                         g_object_unref (*to_set);
 757                 }
 758
 759                 *to_set = adjustment;
 760                 view_set_adjustment_values (view, orientation);
 761
 762                 if (*to_set) {
 763                         g_object_ref (*to_set);
 764                         g_signal_connect (*to_set, "value_changed",
 765                                           G_CALLBACK (on_adjustment_value_changed), view);
 766                 }
 767         }
 768 }
 769
 770 static void
 771 ev_view_set_scroll_adjustments (EvView *view,
 772                                 GtkAdjustment  *hadjustment,
 773                                 GtkAdjustment  *vadjustment)
 774 {
 775         set_scroll_adjustment (view, GTK_ORIENTATION_HORIZONTAL, hadjustment);
 776         set_scroll_adjustment (view, GTK_ORIENTATION_VERTICAL, vadjustment);
 777
 778         view_update_adjustments (view);
 779 }
 780
 781 static void
 782 add_scroll_binding (GtkBindingSet  *binding_set,
 783                     guint           keyval,
 784                     GtkScrollType   scroll,
 785                     gboolean        horizontal)
 786 {
 787   guint keypad_keyval = keyval - GDK_Left + GDK_KP_Left;
 788
 789   gtk_binding_entry_add_signal (binding_set, keyval, 0,
 790                                 "scroll_view", 2,
 791                                 GTK_TYPE_SCROLL_TYPE, scroll,
 792                                 G_TYPE_BOOLEAN, horizontal);
 793   gtk_binding_entry_add_signal (binding_set, keypad_keyval, 0,
 794                                 "scroll_view", 2,
 795                                 GTK_TYPE_SCROLL_TYPE, scroll,
 796                                 G_TYPE_BOOLEAN, horizontal);
 797 }
 798
 799 static void
 800 ev_view_scroll_view (EvView *view,
 801                      GtkScrollType scroll,
 802                      gboolean horizontal)
 803 {
 804         if (scroll == GTK_SCROLL_PAGE_BACKWARD) {
 805                 ev_view_set_page (view, ev_view_get_page (view) - 1);
 806         } else if (scroll == GTK_SCROLL_PAGE_FORWARD) {
 807                 ev_view_set_page (view, ev_view_get_page (view) + 1);
 808         } else {
 809                 GtkAdjustment *adjustment;
 810                 double value;
 811
 812                 if (horizontal) {
 813                         adjustment = view->hadjustment;
 814                 } else {
 815                         adjustment = view->vadjustment;
 816                 }
 817
 818                 value = adjustment->value;
 819
 820                 switch (scroll) {
 821                         case GTK_SCROLL_STEP_BACKWARD:
 822                                 value -= adjustment->step_increment;
 823                                 break;
 824                         case GTK_SCROLL_STEP_FORWARD:
 825                                 value += adjustment->step_increment;
 826                                 break;
 827                         default:
 828                                 break;
 829                 }
 830
 831                 value = CLAMP (value, adjustment->lower,
 832                                adjustment->upper - adjustment->page_size);
 833
 834                 gtk_adjustment_set_value (adjustment, value);
 835         }
 836 }
 837
 838 static void
 839 ev_view_set_property (GObject *object,
 840                       guint prop_id,
 841                       const GValue *value,
 842                       GParamSpec *pspec)
 843 {
 844         switch (prop_id)
 845         {
 846                 /* Read only */
 847                 case PROP_STATUS:
 848                 case PROP_FIND_STATUS:
 849                         break;
 850         }
 851 }
 852
 853 static void
 854 ev_view_get_property (GObject *object,
 855                       guint prop_id,
 856                       GValue *value,
 857                       GParamSpec *pspec)
 858 {
 859         EvView *view = EV_VIEW (object);
 860
 861         switch (prop_id)
 862         {
 863                 case PROP_STATUS:
 864                         g_value_set_string (value, view->status);
 865                         break;
 866                 case PROP_FIND_STATUS:
 867                         g_value_set_string (value, view->status);
 868                         break;
 869         }
 870 }
 871
 872 static void
 873 ev_view_class_init (EvViewClass *class)
 874 {
 875         GObjectClass *object_class = G_OBJECT_CLASS (class);
 876         GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (class);
 877         GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
 878         GtkBindingSet *binding_set;
 879
 880         object_class->finalize = ev_view_finalize;
 881         object_class->set_property = ev_view_set_property;
 882         object_class->get_property = ev_view_get_property;
 883
 884         widget_class->expose_event = ev_view_expose_event;
 885         widget_class->button_press_event = ev_view_button_press_event;
 886         widget_class->motion_notify_event = ev_view_motion_notify_event;
 887         widget_class->button_release_event = ev_view_button_release_event;
 888         widget_class->size_request = ev_view_size_request;
 889         widget_class->size_allocate = ev_view_size_allocate;
 890         widget_class->realize = ev_view_realize;
 891         widget_class->unrealize = ev_view_unrealize;
 892         gtk_object_class->destroy = ev_view_destroy;
 893
 894         class->set_scroll_adjustments = ev_view_set_scroll_adjustments;
 895         class->scroll_view = ev_view_scroll_view;
 896
 897         widget_class->set_scroll_adjustments_signal =  g_signal_new ("set-scroll-adjustments",
 898                                                                      G_OBJECT_CLASS_TYPE (object_class),
 899                                                                      G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 900                                                                      G_STRUCT_OFFSET (EvViewClass, set_scroll_adjustments),
 901                                                                      NULL, NULL,
 902                                                                      ev_marshal_VOID__OBJECT_OBJECT,
 903                                                                      G_TYPE_NONE, 2,
 904                                                                      GTK_TYPE_ADJUSTMENT,
 905                                                                      GTK_TYPE_ADJUSTMENT);
 906         page_changed_signal = g_signal_new ("page-changed",
 907                                             G_OBJECT_CLASS_TYPE (object_class),
 908                                             G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 909                                             G_STRUCT_OFFSET (EvViewClass, page_changed),
 910                                             NULL, NULL,
 911                                             ev_marshal_VOID__NONE,
 912                                             G_TYPE_NONE, 0);
 913
 914         g_signal_new ("scroll_view",
 915                       G_TYPE_FROM_CLASS (object_class),
 916                       G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 917                       G_STRUCT_OFFSET (EvViewClass, scroll_view),
 918                       NULL, NULL,
 919                       ev_marshal_VOID__ENUM_BOOLEAN,
 920                       G_TYPE_NONE, 2,
 921                       GTK_TYPE_SCROLL_TYPE,
 922                       G_TYPE_BOOLEAN);
 923
 924         g_object_class_install_property (object_class,
 925                                          PROP_STATUS,
 926                                          g_param_spec_string ("status",
 927                                                               "Status Message",
 928                                                               "The status message",
 929                                                               NULL,
 930                                                               G_PARAM_READABLE));
 931
 932         g_object_class_install_property (object_class,
 933                                          PROP_STATUS,
 934                                          g_param_spec_string ("find-status",
 935                                                               "Find Status Message",
 936                                                               "The find status message",
 937                                                               NULL,
 938                                                               G_PARAM_READABLE));
 939
 940         binding_set = gtk_binding_set_by_class (class);
 941
 942         add_scroll_binding (binding_set, GDK_Left,  GTK_SCROLL_STEP_BACKWARD, TRUE);
 943         add_scroll_binding (binding_set, GDK_Right, GTK_SCROLL_STEP_FORWARD,  TRUE);
 944         add_scroll_binding (binding_set, GDK_Up,    GTK_SCROLL_STEP_BACKWARD, FALSE);
 945         add_scroll_binding (binding_set, GDK_Down,  GTK_SCROLL_STEP_FORWARD,  FALSE);
 946
 947         add_scroll_binding (binding_set, GDK_Page_Up,   GTK_SCROLL_PAGE_BACKWARD, FALSE);
 948         add_scroll_binding (binding_set, GDK_Page_Down, GTK_SCROLL_PAGE_FORWARD,  FALSE);
 949 }
 950
 951 static void
 952 ev_view_init (EvView *view)
 953 {
 954         GTK_WIDGET_SET_FLAGS (view, GTK_CAN_FOCUS);
 955
 956         view->spacing = 10;
 957         view->scale = 1.0;
 958         view->pressed_button = -1;
 959         view->cursor = EV_VIEW_CURSOR_NORMAL;
 960         view->sizing_mode = EV_SIZING_BEST_FIT;
 961 }
 962
 963 static void
 964 update_find_status_message (EvView *view)
 965 {
 966         char *message;
 967
 968         if (ev_document_get_page (view->document) == view->find_page) {
 969                 int results;
 970
 971                 results = ev_document_find_get_n_results
 972                                 (EV_DOCUMENT_FIND (view->document));
 973
 974                 message = g_strdup_printf (_("%d found on this page"),
 975                                            results);
 976         } else {
 977                 double percent;
 978
 979                 percent = ev_document_find_get_progress
 980                                 (EV_DOCUMENT_FIND (view->document));
 981
 982                 if (percent >= (1.0 - 1e-10)) {
 983                         message = g_strdup (_("Not found"));
 984                 } else {
 985                         message = g_strdup_printf (_("%3d%% remaining to search"),
 986                                                    (int) ((1.0 - percent) * 100));
 987                 }
 988
 989         }
 990
 991         ev_view_set_find_status (view, message);
 992         g_free (message);
 993 }
 994
 995 static void
 996 set_document_page (EvView *view, int new_page)
 997 {
 998         int page;
 999         int pages;
1000
1001         pages = ev_document_get_n_pages (view->document);
1002         page = CLAMP (new_page, 1, pages);
1003
1004         if (view->document) {
1005                 int old_page = ev_document_get_page (view->document);
1006                 int old_width, old_height;
1007
1008                 ev_document_get_page_size (view->document,
1009                                            -1,
1010                                            &old_width, &old_height);
1011
1012                 if (old_page != page) {
1013                         ev_view_set_cursor (view, EV_VIEW_CURSOR_WAIT);
1014                         ev_document_set_page (view->document, page);
1015                 }
1016
1017                 if (old_page != ev_document_get_page (view->document)) {
1018                         int width, height;
1019
1020                         g_signal_emit (view, page_changed_signal, 0);
1021
1022                         view->has_selection = FALSE;
1023                         ev_document_get_page_size (view->document,
1024                                                    -1,
1025                                                    &width, &height);
1026                         if (width != old_width || height != old_height)
1027                                 gtk_widget_queue_resize (GTK_WIDGET (view));
1028
1029                         gtk_adjustment_set_value (view->vadjustment,
1030                                                   view->vadjustment->lower);
1031                 }
1032
1033                 view->find_page = page;
1034                 view->find_result = 0;
1035
1036                 if (EV_IS_DOCUMENT_FIND (view->document)) {
1037                         update_find_status_message (view);
1038                 }
1039         }
1040 }
1041
1042 #define MARGIN 5
1043
1044 static void
1045 ensure_rectangle_is_visible (EvView *view, GdkRectangle *rect)
1046 {
1047         GtkWidget *widget = GTK_WIDGET (view);
1048         GtkAdjustment *adjustment;
1049         int value;
1050
1051         adjustment = view->vadjustment;
1052
1053         if (rect->y < adjustment->value) {
1054                 value = MAX (adjustment->lower, rect->y - MARGIN);
1055                 gtk_adjustment_set_value (view->vadjustment, value);
1056         } else if (rect->y + rect->height >
1057                    adjustment->value + widget->allocation.height) {
1058                 value = MIN (adjustment->upper, rect->y + rect->height -
1059                              widget->allocation.height + MARGIN);
1060                 gtk_adjustment_set_value (view->vadjustment, value);
1061         }
1062
1063         adjustment = view->hadjustment;
1064
1065         if (rect->x < adjustment->value) {
1066                 value = MAX (adjustment->lower, rect->x - MARGIN);
1067                 gtk_adjustment_set_value (view->hadjustment, value);
1068         } else if (rect->x + rect->height >
1069                    adjustment->value + widget->allocation.width) {
1070                 value = MIN (adjustment->upper, rect->x + rect->width -
1071                              widget->allocation.width + MARGIN);
1072                 gtk_adjustment_set_value (view->hadjustment, value);
1073         }
1074 }
1075
1076 static void
1077 jump_to_find_result (EvView *view)
1078 {
1079         EvDocumentFind *find = EV_DOCUMENT_FIND (view->document);
1080         GdkRectangle rect;
1081         int n_results;
1082
1083         n_results = ev_document_find_get_n_results (find);
1084
1085         if (n_results > view->find_result) {
1086                 ev_document_find_get_result
1087                         (find, view->find_result, &rect);
1088                 ensure_rectangle_is_visible (view, &rect);
1089         }
1090 }
1091
1092 static void
1093 jump_to_find_page (EvView *view)
1094 {
1095         int n_pages, i;
1096
1097         n_pages = ev_document_get_n_pages (view->document);
1098
1099         for (i = 0; i <= n_pages; i++) {
1100                 int has_results;
1101                 int page;
1102
1103                 page = i + view->find_page;
1104                 if (page > n_pages) {
1105                         page = page - n_pages;
1106                 }
1107
1108                 has_results = ev_document_find_page_has_results
1109                                 (EV_DOCUMENT_FIND (view->document), page);
1110                 if (has_results == -1) {
1111                         view->find_page = page;
1112                         break;
1113                 } else if (has_results == 1) {
1114                         set_document_page (view, page);
1115                         jump_to_find_result (view);
1116                         break;
1117                 }
1118         }
1119 }
1120
1121 static void
1122 find_changed_cb (EvDocument *document, int page, EvView *view)
1123 {
1124         jump_to_find_page (view);
1125         jump_to_find_result (view);
1126         update_find_status_message (view);
1127
1128         if (ev_document_get_page (document) == page) {
1129                 gtk_widget_queue_draw (GTK_WIDGET (view));
1130         }
1131 }
1132
1133 static void
1134 document_changed_callback (EvDocument *document,
1135                            EvView     *view)
1136 {
1137         gtk_widget_queue_draw (GTK_WIDGET (view));
1138         ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
1139 }
1140
1141 /*** Public API ***/
1142
1143 GtkWidget*
1144 ev_view_new (void)
1145 {
1146         return g_object_new (EV_TYPE_VIEW, NULL);
1147 }
1148
1149 void
1150 ev_view_set_document (EvView     *view,
1151                       EvDocument *document)
1152 {
1153         g_return_if_fail (EV_IS_VIEW (view));
1154
1155         if (document != view->document) {
1156                 if (view->document) {
1157                         g_signal_handlers_disconnect_by_func
1158                                 (view->document, find_changed_cb, view);
1159                         g_object_unref (view->document);
1160                 }
1161
1162                 view->document = document;
1163                 view->find_page = 1;
1164                 view->find_result = 0;
1165
1166                 if (view->document) {
1167                         g_object_ref (view->document);
1168                         if (EV_IS_DOCUMENT_FIND (view->document)) {
1169                                 g_signal_connect (view->document,
1170                                                   "find_changed",
1171                                                   G_CALLBACK (find_changed_cb),
1172                                                   view);
1173                         }
1174                         g_signal_connect (view->document,
1175                                           "changed",
1176                                           G_CALLBACK (document_changed_callback),
1177                                           view);
1178                 }
1179
1180                 if (GTK_WIDGET_REALIZED (view))
1181                         ev_document_set_target (view->document, view->bin_window);
1182
1183                 gtk_widget_queue_resize (GTK_WIDGET (view));
1184
1185                 g_signal_emit (view, page_changed_signal, 0);
1186         }
1187 }
1188
1189 void
1190 ev_view_set_mode (EvView       *view,
1191                   EvSizingMode  sizing_mode)
1192 {
1193         if (view->sizing_mode == sizing_mode)
1194                 return;
1195
1196         view->sizing_mode = sizing_mode;
1197         gtk_widget_queue_resize (GTK_WIDGET (view));
1198 }
1199
1200 static void
1201 go_to_link (EvView *view, EvLink *link)
1202 {
1203         EvLinkType type;
1204         const char *uri;
1205         int page;
1206
1207         type = ev_link_get_link_type (link);
1208
1209         switch (type) {
1210                 case EV_LINK_TYPE_TITLE:
1211                         break;
1212                 case EV_LINK_TYPE_PAGE:
1213                         page = ev_link_get_page (link);
1214                         set_document_page (view, page);
1215                         break;
1216                 case EV_LINK_TYPE_EXTERNAL_URI:
1217                         uri = ev_link_get_uri (link);
1218                         gnome_vfs_url_show (uri);
1219                         break;
1220         }
1221 }
1222
1223 void
1224 ev_view_go_to_link (EvView *view, EvLink *link)
1225 {
1226         go_to_link (view, link);
1227 }
1228
1229 void
1230 ev_view_set_page (EvView *view,
1231                   int     page)
1232 {
1233         g_return_if_fail (EV_IS_VIEW (view));
1234
1235         set_document_page (view, page);
1236 }
1237
1238 int
1239 ev_view_get_page (EvView *view)
1240 {
1241         if (view->document)
1242                 return ev_document_get_page (view->document);
1243         else
1244                 return 1;
1245 }
1246
1247 static void
1248 ev_view_zoom (EvView   *view,
1249               double    factor,
1250               gboolean  relative)
1251 {
1252         double scale;
1253
1254         if (relative)
1255                 scale = view->scale * factor;
1256         else
1257                 scale = factor;
1258
1259         scale = CLAMP (scale, MIN_SCALE, MAX_SCALE);
1260
1261         if (ABS (scale - view->scale) < ZOOM_EPSILON)
1262                 return;
1263
1264         view->scale = scale;
1265
1266         ev_document_set_scale (view->document, view->scale);
1267
1268         gtk_widget_queue_resize (GTK_WIDGET (view));
1269 }
1270
1271 void
1272 ev_view_zoom_in (EvView *view)
1273 {
1274         ev_view_zoom (view, ZOOM_IN_FACTOR, TRUE);
1275 }
1276
1277 void
1278 ev_view_zoom_out (EvView *view)
1279 {
1280         ev_view_zoom (view, ZOOM_OUT_FACTOR, TRUE);
1281 }
1282
1283 void
1284 ev_view_normal_size (EvView *view)
1285 {
1286         ev_view_zoom (view, 1.0, FALSE);
1287 }
1288
1289 /* Unfortunately this is not idempotent (!) (numerical stability
1290  * issues because width and height are rounded) */
1291 void
1292 ev_view_best_fit (EvView *view, int allocation_width, int allocation_height)
1293 {
1294         int target_width, target_height;
1295         int width, height;
1296         GtkBorder border;
1297
1298         if (view->document == NULL)
1299                 return;
1300
1301         width = height = 0;
1302         /* This is the bad part. You could make it stable by doing
1303          * ev_document_set_scale 1.0. But at least with pdf this means
1304          * redrawing the whole page */
1305         ev_document_get_page_size (view->document, -1, &width, &height);
1306         /* FIXME: The border size isn't constant.  Ugh.  Still, if we have extra
1307          * space, we just cut it from the border */
1308         ev_document_misc_get_page_border_size (width, height, &border);
1309
1310         target_width = allocation_width - (view->spacing * 2 + border.left + border.right);
1311         target_height = allocation_height - (view->spacing * 2 + border.top + border.bottom);
1312
1313         LOG ("Best fit %d %d", allocation_width, allocation_height);
1314
1315         if (width != 0 && height != 0) {
1316                 double scale;
1317                 double scale_w, scale_h;
1318
1319                 scale_w = (double)target_width * view->scale / width;
1320                 scale_h = (double)target_height * view->scale / height;
1321
1322                 scale = (scale_w < scale_h) ? scale_w : scale_h;
1323
1324                 ev_view_zoom (view, scale, FALSE);
1325         }
1326
1327 }
1328
1329 void
1330 ev_view_fit_width (EvView *view, int allocation_width, int allocation_height,
1331                    int vsb_width)
1332 {
1333         int target_width, target_height;
1334         int width, height;
1335         GtkBorder border;
1336
1337         if (view->document == NULL)
1338                 return;
1339
1340         width = height = 0;
1341         ev_document_get_page_size (view->document, -1, &width, &height);
1342         ev_document_misc_get_page_border_size (width, height, &border);
1343
1344         target_width = allocation_width - (view->spacing * 2 + border.left + border.right);
1345         target_height = allocation_height - (view->spacing * 2 + border.top + border.bottom);
1346
1347         if (width) {
1348                 double scale;
1349                 scale = (double)target_width * view->scale / width;
1350
1351                 if (height * scale / view->scale > target_height)
1352                         scale = ((double)(target_width - vsb_width) * view->scale / width);
1353
1354                 ev_view_zoom (view, scale, FALSE);
1355         }
1356 }
1357
1358 const char *
1359 ev_view_get_status (EvView *view)
1360 {
1361         g_return_val_if_fail (EV_IS_VIEW (view), NULL);
1362
1363         return view->status;
1364 }
1365
1366 const char *
1367 ev_view_get_find_status (EvView *view)
1368 {
1369         g_return_val_if_fail (EV_IS_VIEW (view), NULL);
1370
1371         return view->find_status;
1372 }
1373
1374 void
1375 ev_view_find_next (EvView *view)
1376 {
1377         int n_results, n_pages;
1378         EvDocumentFind *find = EV_DOCUMENT_FIND (view->document);
1379
1380         n_results = ev_document_find_get_n_results (find);
1381         n_pages = ev_document_get_n_pages (view->document);
1382
1383         view->find_result++;
1384
1385         if (view->find_result >= n_results) {
1386                 view->find_result = 0;
1387                 view->find_page++;
1388
1389                 if (view->find_page > n_pages) {
1390                         view->find_page = 1;
1391                 }
1392
1393                 jump_to_find_page (view);
1394         } else {
1395                 jump_to_find_result (view);
1396                 gtk_widget_queue_draw (GTK_WIDGET (view));
1397         }
1398 }
1399
1400 void
1401 ev_view_find_previous (EvView *view)
1402 {
1403         int n_results, n_pages;
1404         EvDocumentFind *find = EV_DOCUMENT_FIND (view->document);
1405
1406         n_results = ev_document_find_get_n_results (find);
1407         n_pages = ev_document_get_n_pages (view->document);
1408
1409         view->find_result--;
1410
1411         if (view->find_result < 0) {
1412                 view->find_result = 0;
1413                 view->find_page--;
1414
1415                 if (view->find_page < 1) {
1416                         view->find_page = n_pages;
1417                 }
1418
1419                 jump_to_find_page (view);
1420         } else {
1421                 jump_to_find_result (view);
1422                 gtk_widget_queue_draw (GTK_WIDGET (view));
1423         }
1424 }