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
  23 #include "ev-marshal.h"
  24 #include "ev-view.h"
  25
  26 #define EV_VIEW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), EV_TYPE_VIEW, EvViewClass))
  27 #define EV_IS_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EV_TYPE_VIEW))
  28 #define EV_VIEW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), EV_TYPE_VIEW, EvViewClass))
  29
  30 struct _EvView {
  31         GtkWidget parent_instance;
  32
  33         EvDocument *document;
  34
  35         GdkWindow *bin_window;
  36
  37         int scroll_x;
  38         int scroll_y;
  39
  40         GtkAdjustment *hadjustment;
  41         GtkAdjustment *vadjustment;
  42
  43         GArray *find_results;
  44 };
  45
  46 struct _EvViewClass {
  47         GtkWidgetClass parent_class;
  48
  49         void    (*set_scroll_adjustments) (EvView         *view,
  50                                            GtkAdjustment  *hadjustment,
  51                                            GtkAdjustment  *vadjustment);
  52
  53         /* Should this be notify::page? */
  54         void    (*page_changed)           (EvView         *view);
  55 };
  56
  57 static guint page_changed_signal = 0;
  58
  59 static void ev_view_set_scroll_adjustments (EvView         *view,
  60                                             GtkAdjustment  *hadjustment,
  61                                             GtkAdjustment  *vadjustment);
  62
  63 G_DEFINE_TYPE (EvView, ev_view, GTK_TYPE_WIDGET)
  64
  65 /*** Helper functions ***/
  66
  67 static void
  68 view_update_adjustments (EvView *view)
  69 {
  70         int old_x = view->scroll_x;
  71         int old_y = view->scroll_y;
  72
  73         if (view->hadjustment)
  74                 view->scroll_x = view->hadjustment->value;
  75         else
  76                 view->scroll_x = 0;
  77
  78         if (view->vadjustment)
  79                 view->scroll_y = view->vadjustment->value;
  80         else
  81                 view->scroll_y = 0;
  82
  83         if (GTK_WIDGET_REALIZED (view) &&
  84             (view->scroll_x != old_x || view->scroll_y != old_y)) {
  85                 gdk_window_move (view->bin_window, - view->scroll_x, - view->scroll_y);
  86                 gdk_window_process_updates (view->bin_window, TRUE);
  87         }
  88 }
  89
  90 static void
  91 view_set_adjustment_values (EvView         *view,
  92                             GtkOrientation  orientation)
  93 {
  94         GtkWidget *widget = GTK_WIDGET (view);
  95         GtkAdjustment *adjustment;
  96         gboolean value_changed = FALSE;
  97         int requisition;
  98         int allocation;
  99
 100         if (orientation == GTK_ORIENTATION_HORIZONTAL)  {
 101                 requisition = widget->requisition.width;
 102                 allocation = widget->allocation.width;
 103                 adjustment = view->hadjustment;
 104         } else {
 105                 requisition = widget->requisition.height;
 106                 allocation = widget->allocation.height;
 107                 adjustment = view->vadjustment;
 108         }
 109
 110         if (!adjustment)
 111                 return;
 112
 113         adjustment->page_size = allocation;
 114         adjustment->step_increment = allocation * 0.1;
 115         adjustment->page_increment = allocation * 0.9;
 116         adjustment->lower = 0;
 117         adjustment->upper = MAX (allocation, requisition);
 118
 119         if (adjustment->value > adjustment->upper - adjustment->page_size) {
 120                 adjustment->value = adjustment->upper - adjustment->page_size;
 121                 value_changed = TRUE;
 122         }
 123
 124         gtk_adjustment_changed (adjustment);
 125         if (value_changed)
 126                 gtk_adjustment_value_changed (adjustment);
 127 }
 128
 129 /*** Virtual function implementations ***/
 130
 131 static void
 132 ev_view_finalize (GObject *object)
 133 {
 134         EvView *view = EV_VIEW (object);
 135
 136         if (view->document)
 137                 g_object_unref (view->document);
 138
 139         ev_view_set_scroll_adjustments (view, NULL, NULL);
 140
 141         g_array_free (view->find_results, TRUE);
 142         view->find_results = NULL;
 143
 144         G_OBJECT_CLASS (ev_view_parent_class)->finalize (object);
 145 }
 146
 147 static void
 148 ev_view_destroy (GtkObject *object)
 149 {
 150         EvView *view = EV_VIEW (object);
 151
 152         ev_view_set_scroll_adjustments (view, NULL, NULL);
 153
 154         GTK_OBJECT_CLASS (ev_view_parent_class)->destroy (object);
 155 }
 156
 157 static void
 158 ev_view_size_request (GtkWidget      *widget,
 159                       GtkRequisition *requisition)
 160 {
 161         EvView *view = EV_VIEW (widget);
 162
 163         if (GTK_WIDGET_REALIZED (widget)) {
 164                 if (view->document) {
 165                         ev_document_get_page_size (view->document,
 166                                                    &requisition->width,
 167                                                    &requisition->height);
 168                 } else {
 169                         requisition->width = 10;
 170                         requisition->height = 10;
 171                 }
 172         }
 173
 174 }
 175
 176 static void
 177 ev_view_size_allocate (GtkWidget      *widget,
 178                        GtkAllocation  *allocation)
 179 {
 180         EvView *view = EV_VIEW (widget);
 181
 182         GTK_WIDGET_CLASS (ev_view_parent_class)->size_allocate (widget, allocation);
 183
 184         view_set_adjustment_values (view, GTK_ORIENTATION_HORIZONTAL);
 185         view_set_adjustment_values (view, GTK_ORIENTATION_VERTICAL);
 186
 187         if (GTK_WIDGET_REALIZED (widget)) {
 188                 gdk_window_resize (view->bin_window,
 189                                    MAX (widget->allocation.width, widget->requisition.width),
 190                                    MAX (widget->allocation.height, widget->requisition.height));
 191         }
 192 }
 193
 194 static void
 195 update_window_backgrounds (EvView *view)
 196 {
 197         GtkWidget *widget = GTK_WIDGET (view);
 198
 199         if (GTK_WIDGET_REALIZED (view)) {
 200                 gdk_window_set_background (view->bin_window,
 201                                            &widget->style->base[GTK_WIDGET_STATE (widget)]);
 202         }
 203 }
 204
 205 static void
 206 ev_view_realize (GtkWidget *widget)
 207 {
 208         EvView *view = EV_VIEW (widget);
 209         GdkWindowAttr attributes;
 210
 211         GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 212
 213         attributes.window_type = GDK_WINDOW_CHILD;
 214         attributes.wclass = GDK_INPUT_OUTPUT;
 215         attributes.visual = gtk_widget_get_visual (widget);
 216         attributes.colormap = gtk_widget_get_colormap (widget);
 217
 218         attributes.x = widget->allocation.x;
 219         attributes.y = widget->allocation.y;
 220         attributes.width = widget->allocation.width;
 221         attributes.height = widget->allocation.height;
 222         attributes.event_mask = 0;
 223
 224         widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
 225                                          &attributes,
 226                                          GDK_WA_X | GDK_WA_Y |
 227                                          GDK_WA_COLORMAP |
 228                                          GDK_WA_VISUAL);
 229         gdk_window_set_user_data (widget->window, widget);
 230         widget->style = gtk_style_attach (widget->style, widget->window);
 231
 232         attributes.x = 0;
 233         attributes.y = 0;
 234         attributes.width = MAX (widget->allocation.width, widget->requisition.width);
 235         attributes.height = MAX (widget->allocation.height, widget->requisition.height);
 236         attributes.event_mask = GDK_EXPOSURE_MASK;
 237
 238         view->bin_window = gdk_window_new (widget->window,
 239                                            &attributes,
 240                                            GDK_WA_X | GDK_WA_Y |
 241                                            GDK_WA_COLORMAP |
 242                                            GDK_WA_VISUAL);
 243         gdk_window_set_user_data (view->bin_window, widget);
 244         gdk_window_show (view->bin_window);
 245
 246         if (view->document) {
 247                 ev_document_set_target (view->document, view->bin_window);
 248
 249                 /* We can't get page size without a target, so we have to
 250                  * queue a size request at realization. Could be fixed
 251                  * with EvDocument changes to allow setting a GdkScreen
 252                  * without setting a target.
 253                  */
 254                 gtk_widget_queue_resize (widget);
 255         }
 256
 257         update_window_backgrounds (view);
 258 }
 259
 260 static void
 261 ev_view_unrealize (GtkWidget *widget)
 262 {
 263         EvView *view = EV_VIEW (widget);
 264
 265         if (view->document)
 266                 ev_document_set_target (view->document, NULL);
 267
 268         gdk_window_set_user_data (view->bin_window, NULL);
 269         gdk_window_destroy (view->bin_window);
 270         view->bin_window = NULL;
 271
 272         GTK_WIDGET_CLASS (ev_view_parent_class)->unrealize (widget);
 273 }
 274
 275 static void
 276 ev_view_style_set (GtkWidget      *widget,
 277                    GtkStyle       *previous_style)
 278 {
 279         update_window_backgrounds (EV_VIEW (widget));
 280 }
 281
 282 static void
 283 ev_view_state_changed (GtkWidget    *widget,
 284                        GtkStateType  previous_state)
 285 {
 286         update_window_backgrounds (EV_VIEW (widget));
 287 }
 288
 289 static void
 290 expose_bin_window (GtkWidget      *widget,
 291                    GdkEventExpose *event)
 292 {
 293         EvView *view = EV_VIEW (widget);
 294         int i;
 295         const EvFindResult *results;
 296
 297         if (view->document)
 298                 ev_document_render (view->document,
 299                                     event->area.x, event->area.y,
 300                                     event->area.width, event->area.height);
 301
 302         results = (EvFindResult*) view->find_results->data;
 303         i = 0;
 304         while (i < view->find_results->len) {
 305 #if 0
 306                 g_printerr ("highlighting result %d at %d,%d %dx%d\n",
 307                             i,
 308                             results[i].highlight_area.x,
 309                             results[i].highlight_area.y,
 310                             results[i].highlight_area.width,
 311                             results[i].highlight_area.height);
 312 #endif
 313                 // if (results[i].page_num == current_page) FIXME
 314                 gdk_draw_rectangle (view->bin_window,
 315                                     widget->style->base_gc[GTK_STATE_SELECTED],
 316                                     FALSE,
 317                                     results[i].highlight_area.x,
 318                                     results[i].highlight_area.y,
 319                                     results[i].highlight_area.width,
 320                                     results[i].highlight_area.height);
 321                 ++i;
 322         }
 323 }
 324
 325 static gboolean
 326 ev_view_expose_event (GtkWidget      *widget,
 327                       GdkEventExpose *event)
 328 {
 329         EvView *view = EV_VIEW (widget);
 330
 331         if (event->window == view->bin_window)
 332                 expose_bin_window (widget, event);
 333         else
 334                 return GTK_WIDGET_CLASS (ev_view_parent_class)->expose_event (widget, event);
 335
 336         return FALSE;
 337 }
 338
 339 static gboolean
 340 ev_view_button_press_event (GtkWidget      *widget,
 341                             GdkEventButton *event)
 342 {
 343         /* EvView *view = EV_VIEW (widget); */
 344
 345         return FALSE;
 346 }
 347
 348 static gboolean
 349 ev_view_motion_notify_event (GtkWidget      *widget,
 350                              GdkEventMotion *event)
 351 {
 352         /* EvView *view = EV_VIEW (widget); */
 353
 354         return FALSE;
 355 }
 356
 357 static gboolean
 358 ev_view_button_release_event (GtkWidget      *widget,
 359                               GdkEventButton *event)
 360 {
 361         /* EvView *view = EV_VIEW (widget); */
 362
 363         return FALSE;
 364 }
 365
 366 static void
 367 on_adjustment_value_changed (GtkAdjustment  *adjustment,
 368                              EvView *view)
 369 {
 370         view_update_adjustments (view);
 371 }
 372
 373 static void
 374 set_scroll_adjustment (EvView *view,
 375                        GtkOrientation  orientation,
 376                        GtkAdjustment  *adjustment)
 377 {
 378         GtkAdjustment **to_set;
 379
 380         if (orientation == GTK_ORIENTATION_HORIZONTAL)
 381                 to_set = &view->hadjustment;
 382         else
 383                 to_set = &view->vadjustment;
 384
 385         if (*to_set != adjustment) {
 386                 if (*to_set) {
 387                         g_signal_handlers_disconnect_by_func (*to_set,
 388                                                               (gpointer) on_adjustment_value_changed,
 389                                                               view);
 390                         g_object_unref (*to_set);
 391                 }
 392
 393                 *to_set = adjustment;
 394                 view_set_adjustment_values (view, orientation);
 395
 396                 if (*to_set) {
 397                         g_object_ref (*to_set);
 398                         g_signal_connect (*to_set, "value_changed",
 399                                           G_CALLBACK (on_adjustment_value_changed), view);
 400                 }
 401         }
 402 }
 403
 404 static void
 405 ev_view_set_scroll_adjustments (EvView *view,
 406                                 GtkAdjustment  *hadjustment,
 407                                 GtkAdjustment  *vadjustment)
 408 {
 409         set_scroll_adjustment (view, GTK_ORIENTATION_HORIZONTAL, hadjustment);
 410         set_scroll_adjustment (view, GTK_ORIENTATION_VERTICAL, vadjustment);
 411
 412         view_update_adjustments (view);
 413 }
 414
 415 static void
 416 ev_view_class_init (EvViewClass *class)
 417 {
 418         GObjectClass *object_class = G_OBJECT_CLASS (class);
 419         GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (class);
 420         GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
 421
 422         object_class->finalize = ev_view_finalize;
 423
 424         widget_class->expose_event = ev_view_expose_event;
 425         widget_class->button_press_event = ev_view_button_press_event;
 426         widget_class->motion_notify_event = ev_view_motion_notify_event;
 427         widget_class->button_release_event = ev_view_button_release_event;
 428         widget_class->size_request = ev_view_size_request;
 429         widget_class->size_allocate = ev_view_size_allocate;
 430         widget_class->realize = ev_view_realize;
 431         widget_class->unrealize = ev_view_unrealize;
 432         widget_class->style_set = ev_view_style_set;
 433         widget_class->state_changed = ev_view_state_changed;
 434         gtk_object_class->destroy = ev_view_destroy;
 435
 436         class->set_scroll_adjustments = ev_view_set_scroll_adjustments;
 437
 438         widget_class->set_scroll_adjustments_signal =  g_signal_new ("set-scroll-adjustments",
 439                                                                      G_OBJECT_CLASS_TYPE (object_class),
 440                                                                      G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 441                                                                      G_STRUCT_OFFSET (EvViewClass, set_scroll_adjustments),
 442                                                                      NULL, NULL,
 443                                                                      ev_marshal_VOID__OBJECT_OBJECT,
 444                                                                      G_TYPE_NONE, 2,
 445                                                                      GTK_TYPE_ADJUSTMENT,
 446                                                                      GTK_TYPE_ADJUSTMENT);
 447         page_changed_signal = g_signal_new ("page-changed",
 448                                             G_OBJECT_CLASS_TYPE (object_class),
 449                                             G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 450                                             G_STRUCT_OFFSET (EvViewClass, page_changed),
 451                                             NULL, NULL,
 452                                             ev_marshal_VOID__NONE,
 453                                             G_TYPE_NONE, 0);
 454 }
 455
 456 static void
 457 ev_view_init (EvView *view)
 458 {
 459         static const GdkColor white = { 0, 0xffff, 0xffff, 0xffff };
 460
 461         gtk_widget_modify_bg (GTK_WIDGET (view), GTK_STATE_NORMAL, &white);
 462
 463         view->find_results = g_array_new (FALSE,
 464                                           FALSE,
 465                                           sizeof (EvFindResult));
 466 }
 467
 468
 469 static void
 470 found_results_callback (EvDocument         *document,
 471                         const EvFindResult *results,
 472                         int                 n_results,
 473                         double              percent_complete,
 474                         void               *data)
 475 {
 476   EvView *view = EV_VIEW (data);
 477
 478   g_array_set_size (view->find_results, 0);
 479
 480   if (n_results > 0)
 481           g_array_append_vals (view->find_results,
 482                                results, n_results);
 483
 484   gtk_widget_queue_draw (GTK_WIDGET (view));
 485 }
 486
 487 /*** Public API ***/
 488
 489 GtkWidget*
 490 ev_view_new (void)
 491 {
 492         return g_object_new (EV_TYPE_VIEW, NULL);
 493 }
 494
 495 void
 496 ev_view_set_document (EvView     *view,
 497                       EvDocument *document)
 498 {
 499         g_return_if_fail (EV_IS_VIEW (view));
 500
 501         if (document != view->document) {
 502                 int old_page = ev_view_get_page (view);
 503
 504                 if (view->document) {
 505                         g_object_unref (view->document);
 506                         g_signal_handlers_disconnect_by_func (view->document,
 507                                                               found_results_callback,
 508                                                               view);
 509                         g_array_set_size (view->find_results, 0);
 510                 }
 511
 512                 view->document = document;
 513
 514                 if (view->document) {
 515                         g_object_ref (view->document);
 516                         g_signal_connect (view->document,
 517                                           "found",
 518                                           G_CALLBACK (found_results_callback),
 519                                           view);
 520                 }
 521
 522                 if (GTK_WIDGET_REALIZED (view))
 523                         ev_document_set_target (view->document, view->bin_window);
 524
 525                 gtk_widget_queue_resize (GTK_WIDGET (view));
 526
 527                 if (old_page != ev_view_get_page (view))
 528                         g_signal_emit (view, page_changed_signal, 0);
 529         }
 530 }
 531
 532 void
 533 ev_view_set_page (EvView *view,
 534                   int     page)
 535 {
 536         if (view->document) {
 537                 int old_page = ev_document_get_page (view->document);
 538                 if (old_page != page)
 539                         ev_document_set_page (view->document, page);
 540                 if (old_page != ev_document_get_page (view->document)) {
 541                         g_signal_emit (view, page_changed_signal, 0);
 542                         gtk_widget_queue_draw (GTK_WIDGET (view));
 543                 }
 544         }
 545 }
 546
 547 int
 548 ev_view_get_page (EvView *view)
 549 {
 550         if (view->document)
 551                 return ev_document_get_page (view->document);
 552         else
 553                 return 1;
 554 }