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