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