Pileus Git - ~andy/gtk/blob - gtk/gtkviewport.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include "config.h"
  28
  29 #undef GTK_DISABLE_DEPRECATED
  30 #include "gtkviewport.h"
  31 #define GTK_DISABLE_DEPRECATED
  32 #include "gtkintl.h"
  33 #include "gtkmarshalers.h"
  34 #include "gtktypeutils.h"
  35 #include "gtkscrollable.h"
  36 #include "gtkprivate.h"
  37
  38
  39 /**
  40  * SECTION:gtkviewport
  41  * @Short_description: An adapter which makes widgets scrollable
  42  * @Title: GtkViewport
  43  * @See_also:#GtkScrolledWindow, #GtkAdjustment
  44  *
  45  * The #GtkViewport widget acts as an adaptor class, implementing
  46  * scrollability for child widgets that lack their own scrolling
  47  * capabilities. Use #GtkViewport to scroll child widgets such as
  48  * #GtkTable, #GtkBox, and so on.
  49  *
  50  * If a widget has native scrolling abilities, such as #GtkTextView,
  51  * #GtkTreeView or #GtkIconview, it can be added to a #GtkScrolledWindow
  52  * with gtk_container_add(). If a widget does not, you must first add the
  53  * widget to a #GtkViewport, then add the viewport to the scrolled window.
  54  * The convenience function gtk_scrolled_window_add_with_viewport() does
  55  * exactly this, so you can ignore the presence of the viewport.
  56  *
  57  * The #GtkViewport will start scrolling content only if allocated less
  58  * than the child widget's minimum size in a given orientation.
  59  */
  60
  61 struct _GtkViewportPrivate
  62 {
  63   GtkAdjustment  *hadjustment;
  64   GtkAdjustment  *vadjustment;
  65   GtkShadowType   shadow_type;
  66
  67   GdkWindow      *bin_window;
  68   GdkWindow      *view_window;
  69
  70   /* GtkScrollablePolicy needs to be checked when
  71    * driving the scrollable adjustment values */
  72   guint hscroll_policy : 1;
  73   guint vscroll_policy : 1;
  74 };
  75
  76 enum {
  77   PROP_0,
  78   PROP_HADJUSTMENT,
  79   PROP_VADJUSTMENT,
  80   PROP_HSCROLL_POLICY,
  81   PROP_VSCROLL_POLICY,
  82   PROP_SHADOW_TYPE
  83 };
  84
  85
  86 static void gtk_viewport_finalize                 (GObject          *object);
  87 static void gtk_viewport_set_property             (GObject         *object,
  88                                                    guint            prop_id,
  89                                                    const GValue    *value,
  90                                                    GParamSpec      *pspec);
  91 static void gtk_viewport_get_property             (GObject         *object,
  92                                                    guint            prop_id,
  93                                                    GValue          *value,
  94                                                    GParamSpec      *pspec);
  95 static void gtk_viewport_destroy                  (GtkWidget        *widget);
  96 static void gtk_viewport_realize                  (GtkWidget        *widget);
  97 static void gtk_viewport_unrealize                (GtkWidget        *widget);
  98 static gint gtk_viewport_draw                     (GtkWidget        *widget,
  99                                                    cairo_t          *cr);
 100 static void gtk_viewport_add                      (GtkContainer     *container,
 101                                                    GtkWidget        *widget);
 102 static void gtk_viewport_size_allocate            (GtkWidget        *widget,
 103                                                    GtkAllocation    *allocation);
 104 static void gtk_viewport_adjustment_value_changed (GtkAdjustment    *adjustment,
 105                                                    gpointer          data);
 106 static void gtk_viewport_style_set                (GtkWidget        *widget,
 107                                                    GtkStyle         *previous_style);
 108
 109 static void gtk_viewport_get_preferred_width      (GtkWidget        *widget,
 110                                                    gint             *minimum_size,
 111                                                    gint             *natural_size);
 112 static void gtk_viewport_get_preferred_height     (GtkWidget        *widget,
 113                                                    gint             *minimum_size,
 114                                                    gint             *natural_size);
 115
 116
 117 G_DEFINE_TYPE_WITH_CODE (GtkViewport, gtk_viewport, GTK_TYPE_BIN,
 118                          G_IMPLEMENT_INTERFACE (GTK_TYPE_SCROLLABLE, NULL))
 119
 120 static void
 121 gtk_viewport_class_init (GtkViewportClass *class)
 122 {
 123   GObjectClass   *gobject_class;
 124   GtkWidgetClass *widget_class;
 125   GtkContainerClass *container_class;
 126
 127   gobject_class = G_OBJECT_CLASS (class);
 128   widget_class = (GtkWidgetClass*) class;
 129   container_class = (GtkContainerClass*) class;
 130
 131   gobject_class->finalize = gtk_viewport_finalize;
 132   gobject_class->set_property = gtk_viewport_set_property;
 133   gobject_class->get_property = gtk_viewport_get_property;
 134
 135   widget_class->destroy = gtk_viewport_destroy;
 136   widget_class->realize = gtk_viewport_realize;
 137   widget_class->unrealize = gtk_viewport_unrealize;
 138   widget_class->draw = gtk_viewport_draw;
 139   widget_class->size_allocate = gtk_viewport_size_allocate;
 140   widget_class->style_set = gtk_viewport_style_set;
 141   widget_class->get_preferred_width = gtk_viewport_get_preferred_width;
 142   widget_class->get_preferred_height = gtk_viewport_get_preferred_height;
 143
 144   container_class->add = gtk_viewport_add;
 145
 146   /* GtkScrollable implementation */
 147   g_object_class_override_property (gobject_class, PROP_HADJUSTMENT,    "hadjustment");
 148   g_object_class_override_property (gobject_class, PROP_VADJUSTMENT,    "vadjustment");
 149   g_object_class_override_property (gobject_class, PROP_HSCROLL_POLICY, "hscroll-policy");
 150   g_object_class_override_property (gobject_class, PROP_VSCROLL_POLICY, "vscroll-policy");
 151
 152   g_object_class_install_property (gobject_class,
 153                                    PROP_SHADOW_TYPE,
 154                                    g_param_spec_enum ("shadow-type",
 155                                                       P_("Shadow type"),
 156                                                       P_("Determines how the shadowed box around the viewport is drawn"),
 157                                                       GTK_TYPE_SHADOW_TYPE,
 158                                                       GTK_SHADOW_IN,
 159                                                       GTK_PARAM_READWRITE));
 160
 161   g_type_class_add_private (class, sizeof (GtkViewportPrivate));
 162 }
 163
 164 static void
 165 gtk_viewport_set_property (GObject         *object,
 166                            guint            prop_id,
 167                            const GValue    *value,
 168                            GParamSpec      *pspec)
 169 {
 170   GtkViewport *viewport;
 171
 172   viewport = GTK_VIEWPORT (object);
 173
 174   switch (prop_id)
 175     {
 176     case PROP_HADJUSTMENT:
 177       gtk_viewport_set_hadjustment (viewport, g_value_get_object (value));
 178       break;
 179     case PROP_VADJUSTMENT:
 180       gtk_viewport_set_vadjustment (viewport, g_value_get_object (value));
 181       break;
 182     case PROP_HSCROLL_POLICY:
 183       viewport->priv->hscroll_policy = g_value_get_enum (value);
 184       gtk_widget_queue_resize (GTK_WIDGET (viewport));
 185       break;
 186     case PROP_VSCROLL_POLICY:
 187       viewport->priv->vscroll_policy = g_value_get_enum (value);
 188       gtk_widget_queue_resize (GTK_WIDGET (viewport));
 189       break;
 190     case PROP_SHADOW_TYPE:
 191       gtk_viewport_set_shadow_type (viewport, g_value_get_enum (value));
 192       break;
 193     default:
 194       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 195       break;
 196     }
 197 }
 198
 199 static void
 200 gtk_viewport_get_property (GObject         *object,
 201                            guint            prop_id,
 202                            GValue          *value,
 203                            GParamSpec      *pspec)
 204 {
 205   GtkViewport *viewport = GTK_VIEWPORT (object);
 206   GtkViewportPrivate *priv = viewport->priv;
 207
 208   switch (prop_id)
 209     {
 210     case PROP_HADJUSTMENT:
 211       g_value_set_object (value, priv->hadjustment);
 212       break;
 213     case PROP_VADJUSTMENT:
 214       g_value_set_object (value, priv->vadjustment);
 215       break;
 216     case PROP_HSCROLL_POLICY:
 217       g_value_set_enum (value, priv->hscroll_policy);
 218       break;
 219     case PROP_VSCROLL_POLICY:
 220       g_value_set_enum (value, priv->vscroll_policy);
 221       break;
 222     case PROP_SHADOW_TYPE:
 223       g_value_set_enum (value, priv->shadow_type);
 224       break;
 225     default:
 226       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 227       break;
 228     }
 229 }
 230
 231 static void
 232 gtk_viewport_init (GtkViewport *viewport)
 233 {
 234   GtkViewportPrivate *priv;
 235
 236   viewport->priv = G_TYPE_INSTANCE_GET_PRIVATE (viewport,
 237                                                 GTK_TYPE_VIEWPORT,
 238                                                 GtkViewportPrivate);
 239   priv = viewport->priv;
 240
 241   gtk_widget_set_has_window (GTK_WIDGET (viewport), TRUE);
 242
 243   gtk_widget_set_redraw_on_allocate (GTK_WIDGET (viewport), FALSE);
 244   gtk_container_set_resize_mode (GTK_CONTAINER (viewport), GTK_RESIZE_QUEUE);
 245
 246   priv->shadow_type = GTK_SHADOW_IN;
 247   priv->view_window = NULL;
 248   priv->bin_window = NULL;
 249   priv->hadjustment = NULL;
 250   priv->vadjustment = NULL;
 251 }
 252
 253 /**
 254  * gtk_viewport_new:
 255  * @hadjustment: horizontal adjustment.
 256  * @vadjustment: vertical adjustment.
 257  * @returns: a new #GtkViewport.
 258  *
 259  * Creates a new #GtkViewport with the given adjustments.
 260  *
 261  **/
 262 GtkWidget*
 263 gtk_viewport_new (GtkAdjustment *hadjustment,
 264                   GtkAdjustment *vadjustment)
 265 {
 266   GtkWidget *viewport;
 267
 268   viewport = g_object_new (GTK_TYPE_VIEWPORT,
 269                              "hadjustment", hadjustment,
 270                              "vadjustment", vadjustment,
 271                              NULL);
 272
 273   return viewport;
 274 }
 275
 276 #define ADJUSTMENT_POINTER(viewport, orientation)         \
 277   (((orientation) == GTK_ORIENTATION_HORIZONTAL) ?        \
 278      &(viewport)->priv->hadjustment : &(viewport)->priv->vadjustment)
 279
 280 static void
 281 viewport_disconnect_adjustment (GtkViewport    *viewport,
 282                                 GtkOrientation  orientation)
 283 {
 284   GtkAdjustment **adjustmentp = ADJUSTMENT_POINTER (viewport, orientation);
 285
 286   if (*adjustmentp)
 287     {
 288       g_signal_handlers_disconnect_by_func (*adjustmentp,
 289                                             gtk_viewport_adjustment_value_changed,
 290                                             viewport);
 291       g_object_unref (*adjustmentp);
 292       *adjustmentp = NULL;
 293     }
 294 }
 295
 296 static void
 297 gtk_viewport_finalize (GObject *object)
 298 {
 299   GtkViewport *viewport = GTK_VIEWPORT (object);
 300
 301   viewport_disconnect_adjustment (viewport, GTK_ORIENTATION_HORIZONTAL);
 302   viewport_disconnect_adjustment (viewport, GTK_ORIENTATION_VERTICAL);
 303
 304   G_OBJECT_CLASS (gtk_viewport_parent_class)->finalize (object);
 305 }
 306
 307 static void
 308 gtk_viewport_destroy (GtkWidget *widget)
 309 {
 310   GtkViewport *viewport = GTK_VIEWPORT (widget);
 311
 312   viewport_disconnect_adjustment (viewport, GTK_ORIENTATION_HORIZONTAL);
 313   viewport_disconnect_adjustment (viewport, GTK_ORIENTATION_VERTICAL);
 314
 315   GTK_WIDGET_CLASS (gtk_viewport_parent_class)->destroy (widget);
 316 }
 317
 318 static void
 319 viewport_get_view_allocation (GtkViewport   *viewport,
 320                               GtkAllocation *view_allocation)
 321 {
 322   GtkViewportPrivate *priv = viewport->priv;
 323   GtkStyle *style;
 324   GtkWidget *widget = GTK_WIDGET (viewport);
 325   GtkAllocation allocation;
 326   guint border_width;
 327
 328   gtk_widget_get_allocation (widget, &allocation);
 329   border_width = gtk_container_get_border_width (GTK_CONTAINER (viewport));
 330
 331   view_allocation->x = 0;
 332   view_allocation->y = 0;
 333
 334   if (priv->shadow_type != GTK_SHADOW_NONE)
 335     {
 336       style = gtk_widget_get_style (widget);
 337       view_allocation->x = style->xthickness;
 338       view_allocation->y = style->ythickness;
 339     }
 340
 341   view_allocation->width = MAX (1, allocation.width - view_allocation->x * 2 - border_width * 2);
 342   view_allocation->height = MAX (1, allocation.height - view_allocation->y * 2 - border_width * 2);
 343 }
 344
 345 static void
 346 viewport_reclamp_adjustment (GtkAdjustment *adjustment,
 347                              gboolean      *value_changed)
 348 {
 349   gdouble value = adjustment->value;
 350
 351   value = CLAMP (value, 0, adjustment->upper - adjustment->page_size);
 352   if (value != adjustment->value)
 353     {
 354       adjustment->value = value;
 355       if (value_changed)
 356         *value_changed = TRUE;
 357     }
 358   else if (value_changed)
 359     *value_changed = FALSE;
 360 }
 361
 362 /**
 363  * gtk_viewport_get_hadjustment:
 364  * @viewport: a #GtkViewport.
 365  *
 366  * Returns the horizontal adjustment of the viewport.
 367  *
 368  * Return value: (transfer none): the horizontal adjustment of @viewport.
 369  *
 370  * Deprecated: 3.0: Use gtk_scrollable_get_hadjustment()
 371  **/
 372 GtkAdjustment*
 373 gtk_viewport_get_hadjustment (GtkViewport *viewport)
 374 {
 375   GtkViewportPrivate *priv;
 376
 377   g_return_val_if_fail (GTK_IS_VIEWPORT (viewport), NULL);
 378
 379   priv = viewport->priv;
 380
 381   if (!priv->hadjustment)
 382     gtk_viewport_set_hadjustment (viewport, NULL);
 383
 384   return priv->hadjustment;
 385 }
 386
 387 /**
 388  * gtk_viewport_get_vadjustment:
 389  * @viewport: a #GtkViewport.
 390  *
 391  * Returns the vertical adjustment of the viewport.
 392  *
 393  * Return value: (transfer none): the vertical adjustment of @viewport.
 394  *
 395  * Deprecated: 3.0: Use gtk_scrollable_get_vadjustment()
 396  **/
 397 GtkAdjustment*
 398 gtk_viewport_get_vadjustment (GtkViewport *viewport)
 399 {
 400   GtkViewportPrivate *priv;
 401
 402   g_return_val_if_fail (GTK_IS_VIEWPORT (viewport), NULL);
 403
 404   priv = viewport->priv;
 405
 406   if (!priv->vadjustment)
 407     gtk_viewport_set_vadjustment (viewport, NULL);
 408
 409   return priv->vadjustment;
 410 }
 411
 412 static void
 413 viewport_set_hadjustment_values (GtkViewport *viewport,
 414                                  gboolean    *value_changed)
 415 {
 416   GtkBin *bin = GTK_BIN (viewport);
 417   GtkAllocation view_allocation;
 418   GtkAdjustment *hadjustment = gtk_viewport_get_hadjustment (viewport);
 419   GtkWidget *child;
 420   gdouble old_page_size;
 421   gdouble old_upper;
 422   gdouble old_value;
 423
 424   viewport_get_view_allocation (viewport, &view_allocation);
 425
 426   old_page_size = hadjustment->page_size;
 427   old_upper = hadjustment->upper;
 428   old_value = hadjustment->value;
 429   hadjustment->page_size = view_allocation.width;
 430   hadjustment->step_increment = view_allocation.width * 0.1;
 431   hadjustment->page_increment = view_allocation.width * 0.9;
 432
 433   hadjustment->lower = 0;
 434
 435   child = gtk_bin_get_child (bin);
 436   if (child && gtk_widget_get_visible (child))
 437     {
 438       gint minimum_width, natural_width;
 439       gint scroll_height;
 440
 441       if (viewport->priv->vscroll_policy == GTK_SCROLL_MINIMUM)
 442         gtk_widget_get_preferred_height (child, &scroll_height, NULL);
 443       else
 444         gtk_widget_get_preferred_height (child, NULL, &scroll_height);
 445
 446       gtk_widget_get_preferred_width_for_height (child,
 447                                                  MAX (view_allocation.height, scroll_height),
 448                                                  &minimum_width,
 449                                                  &natural_width);
 450
 451       if (viewport->priv->hscroll_policy == GTK_SCROLL_MINIMUM)
 452         hadjustment->upper = MAX (minimum_width, view_allocation.width);
 453       else
 454         hadjustment->upper = MAX (natural_width, view_allocation.width);
 455     }
 456   else
 457     hadjustment->upper = view_allocation.width;
 458
 459   if (gtk_widget_get_direction (GTK_WIDGET (viewport)) == GTK_TEXT_DIR_RTL)
 460     {
 461       gdouble dist = old_upper - (old_value + old_page_size);
 462       hadjustment->value = hadjustment->upper - dist - hadjustment->page_size;
 463       viewport_reclamp_adjustment (hadjustment, value_changed);
 464       *value_changed = (old_value != hadjustment->value);
 465     }
 466   else
 467     viewport_reclamp_adjustment (hadjustment, value_changed);
 468 }
 469
 470 static void
 471 viewport_set_vadjustment_values (GtkViewport *viewport,
 472                                  gboolean    *value_changed)
 473 {
 474   GtkBin *bin = GTK_BIN (viewport);
 475   GtkAllocation view_allocation;
 476   GtkAdjustment *vadjustment = gtk_viewport_get_vadjustment (viewport);
 477   GtkWidget *child;
 478
 479   viewport_get_view_allocation (viewport, &view_allocation);
 480
 481   vadjustment->page_size = view_allocation.height;
 482   vadjustment->step_increment = view_allocation.height * 0.1;
 483   vadjustment->page_increment = view_allocation.height * 0.9;
 484
 485   vadjustment->lower = 0;
 486
 487   child = gtk_bin_get_child (bin);
 488   if (child && gtk_widget_get_visible (child))
 489     {
 490       gint minimum_height, natural_height;
 491       gint scroll_width;
 492
 493       if (viewport->priv->hscroll_policy == GTK_SCROLL_MINIMUM)
 494         gtk_widget_get_preferred_width (child, &scroll_width, NULL);
 495       else
 496         gtk_widget_get_preferred_width (child, NULL, &scroll_width);
 497
 498       gtk_widget_get_preferred_height_for_width (child,
 499                                                  MAX (view_allocation.width, scroll_width),
 500                                                  &minimum_height,
 501                                                  &natural_height);
 502
 503       if (viewport->priv->vscroll_policy == GTK_SCROLL_MINIMUM)
 504         vadjustment->upper = MAX (minimum_height, view_allocation.height);
 505       else
 506         vadjustment->upper = MAX (natural_height, view_allocation.height);
 507     }
 508   else
 509     vadjustment->upper = view_allocation.height;
 510
 511   viewport_reclamp_adjustment (vadjustment, value_changed);
 512 }
 513
 514 static void
 515 viewport_set_adjustment (GtkViewport    *viewport,
 516                          GtkOrientation  orientation,
 517                          GtkAdjustment  *adjustment)
 518 {
 519   GtkAdjustment **adjustmentp = ADJUSTMENT_POINTER (viewport, orientation);
 520   gboolean value_changed;
 521
 522   if (adjustment && adjustment == *adjustmentp)
 523     return;
 524
 525   if (!adjustment)
 526     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
 527   viewport_disconnect_adjustment (viewport, orientation);
 528   *adjustmentp = adjustment;
 529   g_object_ref_sink (adjustment);
 530
 531   if (orientation == GTK_ORIENTATION_HORIZONTAL)
 532     viewport_set_hadjustment_values (viewport, &value_changed);
 533   else
 534     viewport_set_vadjustment_values (viewport, &value_changed);
 535
 536   g_signal_connect (adjustment, "value-changed",
 537                     G_CALLBACK (gtk_viewport_adjustment_value_changed),
 538                     viewport);
 539
 540   gtk_adjustment_changed (adjustment);
 541
 542   if (value_changed)
 543     gtk_adjustment_value_changed (adjustment);
 544   else
 545     gtk_viewport_adjustment_value_changed (adjustment, viewport);
 546 }
 547
 548 /**
 549  * gtk_viewport_set_hadjustment:
 550  * @viewport: a #GtkViewport.
 551  * @adjustment: (allow-none): a #GtkAdjustment.
 552  *
 553  * Sets the horizontal adjustment of the viewport.
 554  *
 555  * Deprecated: 3.0: Use gtk_scrollable_set_hadjustment()
 556  **/
 557 void
 558 gtk_viewport_set_hadjustment (GtkViewport   *viewport,
 559                               GtkAdjustment *adjustment)
 560 {
 561   g_return_if_fail (GTK_IS_VIEWPORT (viewport));
 562   if (adjustment)
 563     g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
 564
 565   viewport_set_adjustment (viewport, GTK_ORIENTATION_HORIZONTAL, adjustment);
 566
 567   g_object_notify (G_OBJECT (viewport), "hadjustment");
 568 }
 569
 570 /**
 571  * gtk_viewport_set_vadjustment:
 572  * @viewport: a #GtkViewport.
 573  * @adjustment: (allow-none): a #GtkAdjustment.
 574  *
 575  * Sets the vertical adjustment of the viewport.
 576  *
 577  * Deprecated: 3.0: Use gtk_scrollable_set_vadjustment()
 578  **/
 579 void
 580 gtk_viewport_set_vadjustment (GtkViewport   *viewport,
 581                               GtkAdjustment *adjustment)
 582 {
 583   g_return_if_fail (GTK_IS_VIEWPORT (viewport));
 584   if (adjustment)
 585     g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
 586
 587   viewport_set_adjustment (viewport, GTK_ORIENTATION_VERTICAL, adjustment);
 588
 589   g_object_notify (G_OBJECT (viewport), "vadjustment");
 590 }
 591
 592 /**
 593  * gtk_viewport_set_shadow_type:
 594  * @viewport: a #GtkViewport.
 595  * @type: the new shadow type.
 596  *
 597  * Sets the shadow type of the viewport.
 598  **/
 599 void
 600 gtk_viewport_set_shadow_type (GtkViewport   *viewport,
 601                               GtkShadowType  type)
 602 {
 603   GtkViewportPrivate *priv;
 604   GtkAllocation allocation;
 605   GtkWidget *widget;
 606
 607   g_return_if_fail (GTK_IS_VIEWPORT (viewport));
 608
 609   widget = GTK_WIDGET (viewport);
 610   priv = viewport->priv;
 611
 612   if ((GtkShadowType) priv->shadow_type != type)
 613     {
 614       priv->shadow_type = type;
 615
 616       if (gtk_widget_get_visible (widget))
 617         {
 618           gtk_widget_get_allocation (widget, &allocation);
 619           gtk_widget_size_allocate (widget, &allocation);
 620           gtk_widget_set_allocation (widget, &allocation);
 621           gtk_widget_queue_draw (widget);
 622         }
 623
 624       g_object_notify (G_OBJECT (viewport), "shadow-type");
 625     }
 626 }
 627
 628 /**
 629  * gtk_viewport_get_shadow_type:
 630  * @viewport: a #GtkViewport
 631  *
 632  * Gets the shadow type of the #GtkViewport. See
 633  * gtk_viewport_set_shadow_type().
 634  *
 635  * Return value: the shadow type
 636  **/
 637 GtkShadowType
 638 gtk_viewport_get_shadow_type (GtkViewport *viewport)
 639 {
 640   g_return_val_if_fail (GTK_IS_VIEWPORT (viewport), GTK_SHADOW_NONE);
 641
 642   return viewport->priv->shadow_type;
 643 }
 644
 645 /**
 646  * gtk_viewport_get_bin_window:
 647  * @viewport: a #GtkViewport
 648  *
 649  * Gets the bin window of the #GtkViewport.
 650  *
 651  * Return value: (transfer none): a #GdkWindow
 652  *
 653  * Since: 2.20
 654  **/
 655 GdkWindow*
 656 gtk_viewport_get_bin_window (GtkViewport *viewport)
 657 {
 658   g_return_val_if_fail (GTK_IS_VIEWPORT (viewport), NULL);
 659
 660   return viewport->priv->bin_window;
 661 }
 662
 663 /**
 664  * gtk_viewport_get_view_window:
 665  * @viewport: a #GtkViewport
 666  *
 667  * Gets the view window of the #GtkViewport.
 668  *
 669  * Return value: (transfer none): a #GdkWindow
 670  *
 671  * Since: 2.22
 672  **/
 673 GdkWindow*
 674 gtk_viewport_get_view_window (GtkViewport *viewport)
 675 {
 676   g_return_val_if_fail (GTK_IS_VIEWPORT (viewport), NULL);
 677
 678   return viewport->priv->view_window;
 679 }
 680
 681 static void
 682 gtk_viewport_realize (GtkWidget *widget)
 683 {
 684   GtkViewport *viewport = GTK_VIEWPORT (widget);
 685   GtkViewportPrivate *priv = viewport->priv;
 686   GtkBin *bin = GTK_BIN (widget);
 687   GtkAdjustment *hadjustment = gtk_viewport_get_hadjustment (viewport);
 688   GtkAdjustment *vadjustment = gtk_viewport_get_vadjustment (viewport);
 689   GtkAllocation allocation;
 690   GtkAllocation view_allocation;
 691   GtkStyle *style;
 692   GtkWidget *child;
 693   GdkWindow *window;
 694   GdkWindowAttr attributes;
 695   gint attributes_mask;
 696   gint event_mask;
 697   guint border_width;
 698
 699   border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
 700
 701   gtk_widget_set_realized (widget, TRUE);
 702
 703   gtk_widget_get_allocation (widget, &allocation);
 704
 705   attributes.x = allocation.x + border_width;
 706   attributes.y = allocation.y + border_width;
 707   attributes.width = allocation.width - border_width * 2;
 708   attributes.height = allocation.height - border_width * 2;
 709   attributes.window_type = GDK_WINDOW_CHILD;
 710   attributes.wclass = GDK_INPUT_OUTPUT;
 711   attributes.visual = gtk_widget_get_visual (widget);
 712
 713   event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
 714   /* We select on button_press_mask so that button 4-5 scrolls are trapped.
 715    */
 716   attributes.event_mask = event_mask | GDK_BUTTON_PRESS_MASK;
 717
 718   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
 719
 720   window = gdk_window_new (gtk_widget_get_parent_window (widget),
 721                            &attributes, attributes_mask);
 722   gtk_widget_set_window (widget, window);
 723   gdk_window_set_user_data (window, viewport);
 724
 725   viewport_get_view_allocation (viewport, &view_allocation);
 726
 727   attributes.x = view_allocation.x;
 728   attributes.y = view_allocation.y;
 729   attributes.width = view_allocation.width;
 730   attributes.height = view_allocation.height;
 731   attributes.event_mask = 0;
 732
 733   priv->view_window = gdk_window_new (window,
 734                                       &attributes, attributes_mask);
 735   gdk_window_set_user_data (priv->view_window, viewport);
 736
 737   attributes.x = - hadjustment->value;
 738   attributes.y = - vadjustment->value;
 739   attributes.width = hadjustment->upper;
 740   attributes.height = vadjustment->upper;
 741
 742   attributes.event_mask = event_mask;
 743
 744   priv->bin_window = gdk_window_new (priv->view_window, &attributes, attributes_mask);
 745   gdk_window_set_user_data (priv->bin_window, viewport);
 746
 747   child = gtk_bin_get_child (bin);
 748   if (child)
 749     gtk_widget_set_parent_window (child, priv->bin_window);
 750
 751   gtk_widget_style_attach (widget);
 752   style = gtk_widget_get_style (widget);
 753   gtk_style_set_background (style, window, GTK_STATE_NORMAL);
 754   gtk_style_set_background (style, priv->bin_window, GTK_STATE_NORMAL);
 755
 756   gdk_window_show (priv->bin_window);
 757   gdk_window_show (priv->view_window);
 758 }
 759
 760 static void
 761 gtk_viewport_unrealize (GtkWidget *widget)
 762 {
 763   GtkViewport *viewport = GTK_VIEWPORT (widget);
 764   GtkViewportPrivate *priv = viewport->priv;
 765
 766   gdk_window_set_user_data (priv->view_window, NULL);
 767   gdk_window_destroy (priv->view_window);
 768   priv->view_window = NULL;
 769
 770   gdk_window_set_user_data (priv->bin_window, NULL);
 771   gdk_window_destroy (priv->bin_window);
 772   priv->bin_window = NULL;
 773
 774   GTK_WIDGET_CLASS (gtk_viewport_parent_class)->unrealize (widget);
 775 }
 776
 777 static gint
 778 gtk_viewport_draw (GtkWidget *widget,
 779                    cairo_t   *cr)
 780 {
 781   GtkViewport *viewport = GTK_VIEWPORT (widget);
 782   GtkViewportPrivate *priv = viewport->priv;
 783   int x, y;
 784
 785   if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget)))
 786     {
 787       gtk_paint_shadow (gtk_widget_get_style (widget),
 788                         cr,
 789                         GTK_STATE_NORMAL, priv->shadow_type,
 790                         widget, "viewport",
 791                         0, 0,
 792                         gdk_window_get_width (gtk_widget_get_window (widget)),
 793                         gdk_window_get_height (gtk_widget_get_window (widget)));
 794     }
 795
 796   if (gtk_cairo_should_draw_window (cr, priv->view_window))
 797     {
 798       /* This is a cute hack to ensure the contents of bin_window are
 799        * restricted to where they are visible. We only need to do this
 800        * clipping when called via gtk_widget_draw() and not in expose
 801        * events. And when that happens every window (including this one)
 802        * should be drawn.
 803        */
 804       gdk_window_get_position (priv->view_window, &x, &y);
 805       cairo_rectangle (cr, x, y,
 806                        gdk_window_get_width (priv->view_window),
 807                        gdk_window_get_height (priv->view_window));
 808       cairo_clip (cr);
 809     }
 810
 811   if (gtk_cairo_should_draw_window (cr, priv->bin_window))
 812     {
 813       gdk_window_get_position (priv->bin_window, &x, &y);
 814       gtk_paint_flat_box (gtk_widget_get_style (widget), cr,
 815                           GTK_STATE_NORMAL, GTK_SHADOW_NONE,
 816                           widget, "viewportbin",
 817                           x, y,
 818                           gdk_window_get_width (priv->bin_window),
 819                           gdk_window_get_height (priv->bin_window));
 820
 821       GTK_WIDGET_CLASS (gtk_viewport_parent_class)->draw (widget, cr);
 822     }
 823
 824   return FALSE;
 825 }
 826
 827 static void
 828 gtk_viewport_add (GtkContainer *container,
 829                   GtkWidget    *child)
 830 {
 831   GtkBin *bin = GTK_BIN (container);
 832   GtkViewport *viewport = GTK_VIEWPORT (bin);
 833   GtkViewportPrivate *priv = viewport->priv;
 834
 835   g_return_if_fail (gtk_bin_get_child (bin) == NULL);
 836
 837   gtk_widget_set_parent_window (child, priv->bin_window);
 838
 839   GTK_CONTAINER_CLASS (gtk_viewport_parent_class)->add (container, child);
 840 }
 841
 842 static void
 843 gtk_viewport_size_allocate (GtkWidget     *widget,
 844                             GtkAllocation *allocation)
 845 {
 846   GtkAllocation widget_allocation;
 847   GtkViewport *viewport = GTK_VIEWPORT (widget);
 848   GtkViewportPrivate *priv = viewport->priv;
 849   GtkBin *bin = GTK_BIN (widget);
 850   guint border_width;
 851   gboolean hadjustment_value_changed, vadjustment_value_changed;
 852   GtkAdjustment *hadjustment = gtk_viewport_get_hadjustment (viewport);
 853   GtkAdjustment *vadjustment = gtk_viewport_get_vadjustment (viewport);
 854   GtkAllocation child_allocation;
 855   GtkWidget *child;
 856
 857   border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
 858
 859   /* If our size changed, and we have a shadow, queue a redraw on widget->window to
 860    * redraw the shadow correctly.
 861    */
 862   gtk_widget_get_allocation (widget, &widget_allocation);
 863   if (gtk_widget_get_mapped (widget) &&
 864       priv->shadow_type != GTK_SHADOW_NONE &&
 865       (widget_allocation.width != allocation->width ||
 866        widget_allocation.height != allocation->height))
 867     gdk_window_invalidate_rect (gtk_widget_get_window (widget), NULL, FALSE);
 868
 869   gtk_widget_set_allocation (widget, allocation);
 870
 871   viewport_set_hadjustment_values (viewport, &hadjustment_value_changed);
 872   viewport_set_vadjustment_values (viewport, &vadjustment_value_changed);
 873
 874   child_allocation.x = 0;
 875   child_allocation.y = 0;
 876   child_allocation.width = hadjustment->upper;
 877   child_allocation.height = vadjustment->upper;
 878   if (gtk_widget_get_realized (widget))
 879     {
 880       GtkAllocation view_allocation;
 881
 882       gdk_window_move_resize (gtk_widget_get_window (widget),
 883                               allocation->x + border_width,
 884                               allocation->y + border_width,
 885                               allocation->width - border_width * 2,
 886                               allocation->height - border_width * 2);
 887
 888       viewport_get_view_allocation (viewport, &view_allocation);
 889       gdk_window_move_resize (priv->view_window,
 890                               view_allocation.x,
 891                               view_allocation.y,
 892                               view_allocation.width,
 893                               view_allocation.height);
 894       gdk_window_move_resize (priv->bin_window,
 895                               - hadjustment->value,
 896                               - vadjustment->value,
 897                               child_allocation.width,
 898                               child_allocation.height);
 899     }
 900
 901   child = gtk_bin_get_child (bin);
 902   if (child && gtk_widget_get_visible (child))
 903     gtk_widget_size_allocate (child, &child_allocation);
 904
 905   gtk_adjustment_changed (hadjustment);
 906   gtk_adjustment_changed (vadjustment);
 907   if (hadjustment_value_changed)
 908     gtk_adjustment_value_changed (hadjustment);
 909   if (vadjustment_value_changed)
 910     gtk_adjustment_value_changed (vadjustment);
 911 }
 912
 913 static void
 914 gtk_viewport_adjustment_value_changed (GtkAdjustment *adjustment,
 915                                        gpointer       data)
 916 {
 917   GtkViewport *viewport = GTK_VIEWPORT (data);
 918   GtkViewportPrivate *priv = viewport->priv;
 919   GtkBin *bin = GTK_BIN (data);
 920   GtkWidget *child;
 921
 922   child = gtk_bin_get_child (bin);
 923   if (child && gtk_widget_get_visible (child) &&
 924       gtk_widget_get_realized (GTK_WIDGET (viewport)))
 925     {
 926       GtkAdjustment *hadjustment = gtk_viewport_get_hadjustment (viewport);
 927       GtkAdjustment *vadjustment = gtk_viewport_get_vadjustment (viewport);
 928       gint old_x, old_y;
 929       gint new_x, new_y;
 930
 931       gdk_window_get_position (priv->bin_window, &old_x, &old_y);
 932       new_x = - hadjustment->value;
 933       new_y = - vadjustment->value;
 934
 935       if (new_x != old_x || new_y != old_y)
 936         {
 937           gdk_window_move (priv->bin_window, new_x, new_y);
 938           gdk_window_process_updates (priv->bin_window, TRUE);
 939         }
 940     }
 941 }
 942
 943 static void
 944 gtk_viewport_style_set (GtkWidget *widget,
 945                         GtkStyle  *previous_style)
 946 {
 947    if (gtk_widget_get_realized (widget) &&
 948        gtk_widget_get_has_window (widget))
 949      {
 950         GtkStyle *style;
 951         GtkViewport *viewport = GTK_VIEWPORT (widget);
 952         GtkViewportPrivate *priv = viewport->priv;
 953
 954         style = gtk_widget_get_style (widget);
 955         gtk_style_set_background (style, priv->bin_window, GTK_STATE_NORMAL);
 956         gtk_style_set_background (style,
 957                                   gtk_widget_get_window (widget),
 958                                   gtk_widget_get_state (widget));
 959      }
 960 }
 961
 962
 963 static void
 964 gtk_viewport_get_preferred_size (GtkWidget      *widget,
 965                                  GtkOrientation  orientation,
 966                                  gint           *minimum_size,
 967                                  gint           *natural_size)
 968 {
 969   GtkViewport *viewport = GTK_VIEWPORT (widget);
 970   GtkViewportPrivate *priv = viewport->priv;
 971   GtkStyle  *style;
 972   GtkWidget *child;
 973   gint       child_min, child_nat;
 974   gint       minimum, natural;
 975
 976   child = gtk_bin_get_child (GTK_BIN (widget));
 977
 978   /* XXX This should probably be (border_width * 2); but GTK+ has
 979    * been doing this with a single border for a while now...
 980    */
 981   minimum = gtk_container_get_border_width (GTK_CONTAINER (widget));
 982
 983   if (priv->shadow_type != GTK_SHADOW_NONE)
 984     {
 985       style = gtk_widget_get_style (GTK_WIDGET (widget));
 986       if (orientation == GTK_ORIENTATION_HORIZONTAL)
 987           minimum += 2 * style->xthickness;
 988       else
 989           minimum += 2 * style->ythickness;
 990     }
 991
 992   natural = minimum;
 993
 994   if (child && gtk_widget_get_visible (child))
 995     {
 996       if (orientation == GTK_ORIENTATION_HORIZONTAL)
 997         gtk_widget_get_preferred_width (child, &child_min, &child_nat);
 998       else
 999         gtk_widget_get_preferred_height (child, &child_min, &child_nat);
1000
1001       minimum += child_min;
1002       natural += child_nat;
1003     }
1004
1005   if (minimum_size)
1006     *minimum_size = minimum;
1007
1008   if (natural_size)
1009     *natural_size = natural;
1010 }
1011
1012 static void
1013 gtk_viewport_get_preferred_width (GtkWidget *widget,
1014                                   gint      *minimum_size,
1015                                   gint      *natural_size)
1016 {
1017   gtk_viewport_get_preferred_size (widget, GTK_ORIENTATION_HORIZONTAL, minimum_size, natural_size);
1018 }
1019
1020 static void
1021 gtk_viewport_get_preferred_height (GtkWidget *widget,
1022                                    gint      *minimum_size,
1023                                    gint      *natural_size)
1024 {
1025   gtk_viewport_get_preferred_size (widget, GTK_ORIENTATION_VERTICAL, minimum_size, natural_size);
1026 }