Pileus Git - ~andy/gtk/blob - gtk/gtkscrolledwindow.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 <math.h>
  28
  29 #include "gtkbindings.h"
  30 #include "gtkmarshalers.h"
  31 #include "gtkscrollable.h"
  32 #include "gtkscrollbar.h"
  33 #include "gtkscrolledwindow.h"
  34 #include "gtkwindow.h"
  35 #include "gtkviewport.h"
  36 #include "gtkdnd.h"
  37 #include "gtkmain.h"
  38 #include "gtkprivate.h"
  39 #include "gtktypebuiltins.h"
  40 #include "gtkintl.h"
  41 #include "gtkviewport.h"
  42 #include "gtkwidgetprivate.h"
  43 #include "a11y/gtkscrolledwindowaccessible.h"
  44
  45 /**
  46  * SECTION:gtkscrolledwindow
  47  * @Short_description: Adds scrollbars to its child widget
  48  * @Title: GtkScrolledWindow
  49  * @See_also: #GtkScrollable, #GtkViewport, #GtkAdjustment
  50  *
  51  * #GtkScrolledWindow is a #GtkBin subclass: it's a container
  52  * the accepts a single child widget. #GtkScrolledWindow adds scrollbars
  53  * to the child widget and optionally draws a beveled frame around the
  54  * child widget.
  55  *
  56  * The scrolled window can work in two ways. Some widgets have native
  57  * scrolling support; these widgets implement the #GtkScrollable interface.
  58  * Widgets with native scroll support include #GtkTreeView, #GtkTextView,
  59  * and #GtkLayout.
  60  *
  61  * For widgets that lack native scrolling support, the #GtkViewport
  62  * widget acts as an adaptor class, implementing scrollability for child
  63  * widgets that lack their own scrolling capabilities. Use #GtkViewport
  64  * to scroll child widgets such as #GtkGrid, #GtkBox, and so on.
  65  *
  66  * If a widget has native scrolling abilities, it can be added to the
  67  * #GtkScrolledWindow with gtk_container_add(). If a widget does not, you
  68  * must first add the widget to a #GtkViewport, then add the #GtkViewport
  69  * to the scrolled window. The convenience function
  70  * gtk_scrolled_window_add_with_viewport() does exactly this, so you can
  71  * ignore the presence of the viewport.
  72  *
  73  * The position of the scrollbars is controlled by the scroll
  74  * adjustments. See #GtkAdjustment for the fields in an adjustment - for
  75  * #GtkScrollbar, used by #GtkScrolledWindow, the "value" field
  76  * represents the position of the scrollbar, which must be between the
  77  * "lower" field and "upper - page_size." The "page_size" field
  78  * represents the size of the visible scrollable area. The
  79  * "step_increment" and "page_increment" fields are used when the user
  80  * asks to step down (using the small stepper arrows) or page down (using
  81  * for example the PageDown key).
  82  *
  83  * If a #GtkScrolledWindow doesn't behave quite as you would like, or
  84  * doesn't have exactly the right layout, it's very possible to set up
  85  * your own scrolling with #GtkScrollbar and for example a #GtkGrid.
  86  */
  87
  88
  89 /* scrolled window policy and size requisition handling:
  90  *
  91  * gtk size requisition works as follows:
  92  *   a widget upon size-request reports the width and height that it finds
  93  *   to be best suited to display its contents, including children.
  94  *   the width and/or height reported from a widget upon size requisition
  95  *   may be overidden by the user by specifying a width and/or height
  96  *   other than 0 through gtk_widget_set_size_request().
  97  *
  98  * a scrolled window needs (for implementing all three policy types) to
  99  * request its width and height based on two different rationales.
 100  * 1)   the user wants the scrolled window to just fit into the space
 101  *      that it gets allocated for a specifc dimension.
 102  * 1.1) this does not apply if the user specified a concrete value
 103  *      value for that specific dimension by either specifying usize for the
 104  *      scrolled window or for its child.
 105  * 2)   the user wants the scrolled window to take as much space up as
 106  *      is desired by the child for a specifc dimension (i.e. POLICY_NEVER).
 107  *
 108  * also, kinda obvious:
 109  * 3)   a user would certainly not have choosen a scrolled window as a container
 110  *      for the child, if the resulting allocation takes up more space than the
 111  *      child would have allocated without the scrolled window.
 112  *
 113  * conclusions:
 114  * A) from 1) follows: the scrolled window shouldn't request more space for a
 115  *    specifc dimension than is required at minimum.
 116  * B) from 1.1) follows: the requisition may be overidden by usize of the scrolled
 117  *    window (done automatically) or by usize of the child (needs to be checked).
 118  * C) from 2) follows: for POLICY_NEVER, the scrolled window simply reports the
 119  *    child's dimension.
 120  * D) from 3) follows: the scrolled window child's minimum width and minimum height
 121  *    under A) at least correspond to the space taken up by its scrollbars.
 122  */
 123
 124 #define DEFAULT_SCROLLBAR_SPACING  3
 125 #define TOUCH_BYPASS_CAPTURED_THRESHOLD 30
 126
 127 /* Kinetic scrolling */
 128 #define FRAME_INTERVAL (1000 / 60)
 129 #define MAX_OVERSHOOT_DISTANCE 50
 130 #define FRICTION_DECELERATION 0.003
 131 #define OVERSHOOT_INVERSE_ACCELERATION 0.003
 132 #define RELEASE_EVENT_TIMEOUT 1000
 133
 134 struct _GtkScrolledWindowPrivate
 135 {
 136   GtkWidget     *hscrollbar;
 137   GtkWidget     *vscrollbar;
 138
 139   GtkCornerType  real_window_placement;
 140   guint16  shadow_type;
 141
 142   guint    window_placement_set   : 1;
 143   guint    hscrollbar_policy      : 2;
 144   guint    vscrollbar_policy      : 2;
 145   guint    hscrollbar_visible     : 1;
 146   guint    vscrollbar_visible     : 1;
 147   guint    window_placement       : 2;
 148   guint    focus_out              : 1; /* Flag used by ::move-focus-out implementation */
 149
 150   gint     min_content_width;
 151   gint     min_content_height;
 152
 153   /* Kinetic scrolling */
 154   GdkEvent              *button_press_event;
 155   GdkWindow             *overshoot_window;
 156   GdkDevice             *drag_device;
 157   guint                  kinetic_scrolling         : 1;
 158   guint                  capture_button_press      : 1;
 159   guint                  in_drag                   : 1;
 160   guint                  last_button_event_valid   : 1;
 161
 162   guint                  release_timeout_id;
 163   guint                  deceleration_id;
 164
 165   gdouble                last_button_event_x_root;
 166   gdouble                last_button_event_y_root;
 167
 168   gdouble                last_motion_event_x_root;
 169   gdouble                last_motion_event_y_root;
 170   guint32                last_motion_event_time;
 171
 172   gdouble                x_velocity;
 173   gdouble                y_velocity;
 174
 175   gdouble                unclamped_hadj_value;
 176   gdouble                unclamped_vadj_value;
 177 };
 178
 179 typedef struct
 180 {
 181   GtkScrolledWindow     *scrolled_window;
 182   gint64                 last_deceleration_time;
 183
 184   gdouble                x_velocity;
 185   gdouble                y_velocity;
 186   gdouble                vel_cosine;
 187   gdouble                vel_sine;
 188 } KineticScrollData;
 189
 190 enum {
 191   PROP_0,
 192   PROP_HADJUSTMENT,
 193   PROP_VADJUSTMENT,
 194   PROP_HSCROLLBAR_POLICY,
 195   PROP_VSCROLLBAR_POLICY,
 196   PROP_WINDOW_PLACEMENT,
 197   PROP_WINDOW_PLACEMENT_SET,
 198   PROP_SHADOW_TYPE,
 199   PROP_MIN_CONTENT_WIDTH,
 200   PROP_MIN_CONTENT_HEIGHT,
 201   PROP_KINETIC_SCROLLING
 202 };
 203
 204 /* Signals */
 205 enum
 206 {
 207   SCROLL_CHILD,
 208   MOVE_FOCUS_OUT,
 209   LAST_SIGNAL
 210 };
 211
 212 static void     gtk_scrolled_window_set_property       (GObject           *object,
 213                                                         guint              prop_id,
 214                                                         const GValue      *value,
 215                                                         GParamSpec        *pspec);
 216 static void     gtk_scrolled_window_get_property       (GObject           *object,
 217                                                         guint              prop_id,
 218                                                         GValue            *value,
 219                                                         GParamSpec        *pspec);
 220
 221 static void     gtk_scrolled_window_destroy            (GtkWidget         *widget);
 222 static void     gtk_scrolled_window_screen_changed     (GtkWidget         *widget,
 223                                                         GdkScreen         *previous_screen);
 224 static gboolean gtk_scrolled_window_draw               (GtkWidget         *widget,
 225                                                         cairo_t           *cr);
 226 static void     gtk_scrolled_window_size_allocate      (GtkWidget         *widget,
 227                                                         GtkAllocation     *allocation);
 228 static gboolean gtk_scrolled_window_scroll_event       (GtkWidget         *widget,
 229                                                         GdkEventScroll    *event);
 230 static gboolean gtk_scrolled_window_captured_event     (GtkWidget         *widget,
 231                                                         GdkEvent          *event);
 232 static gboolean gtk_scrolled_window_focus              (GtkWidget         *widget,
 233                                                         GtkDirectionType   direction);
 234 static void     gtk_scrolled_window_add                (GtkContainer      *container,
 235                                                         GtkWidget         *widget);
 236 static void     gtk_scrolled_window_remove             (GtkContainer      *container,
 237                                                         GtkWidget         *widget);
 238 static void     gtk_scrolled_window_forall             (GtkContainer      *container,
 239                                                         gboolean           include_internals,
 240                                                         GtkCallback        callback,
 241                                                         gpointer           callback_data);
 242 static gboolean gtk_scrolled_window_scroll_child       (GtkScrolledWindow *scrolled_window,
 243                                                         GtkScrollType      scroll,
 244                                                         gboolean           horizontal);
 245 static void     gtk_scrolled_window_move_focus_out     (GtkScrolledWindow *scrolled_window,
 246                                                         GtkDirectionType   direction_type);
 247
 248 static void     gtk_scrolled_window_relative_allocation(GtkWidget         *widget,
 249                                                         GtkAllocation     *allocation);
 250 static void     gtk_scrolled_window_adjustment_changed (GtkAdjustment     *adjustment,
 251                                                         gpointer           data);
 252 static void     gtk_scrolled_window_adjustment_value_changed (GtkAdjustment     *adjustment,
 253                                                               gpointer           data);
 254
 255 static void  gtk_scrolled_window_update_real_placement (GtkScrolledWindow *scrolled_window);
 256
 257 static void  gtk_scrolled_window_get_preferred_width   (GtkWidget           *widget,
 258                                                         gint                *minimum_size,
 259                                                         gint                *natural_size);
 260 static void  gtk_scrolled_window_get_preferred_height  (GtkWidget           *widget,
 261                                                         gint                *minimum_size,
 262                                                         gint                *natural_size);
 263 static void  gtk_scrolled_window_get_preferred_height_for_width  (GtkWidget           *layout,
 264                                                         gint                 width,
 265                                                         gint                *minimum_height,
 266                                                         gint                *natural_height);
 267 static void  gtk_scrolled_window_get_preferred_width_for_height  (GtkWidget           *layout,
 268                                                         gint                 width,
 269                                                         gint                *minimum_height,
 270                                                         gint                *natural_height);
 271
 272 static void  gtk_scrolled_window_realize               (GtkWidget           *widget);
 273 static void  gtk_scrolled_window_unrealize             (GtkWidget           *widget);
 274 static void  gtk_scrolled_window_map                   (GtkWidget           *widget);
 275 static void  gtk_scrolled_window_unmap                 (GtkWidget           *widget);
 276 static void  gtk_scrolled_window_grab_notify           (GtkWidget           *widget,
 277                                                         gboolean             was_grabbed);
 278
 279 static gboolean _gtk_scrolled_window_set_adjustment_value      (GtkScrolledWindow *scrolled_window,
 280                                                                 GtkAdjustment     *adjustment,
 281                                                                 gdouble            value,
 282                                                                 gboolean           allow_overshooting,
 283                                                                 gboolean           snap_to_border);
 284
 285 static guint signals[LAST_SIGNAL] = {0};
 286
 287 G_DEFINE_TYPE (GtkScrolledWindow, gtk_scrolled_window, GTK_TYPE_BIN)
 288
 289
 290 static void
 291 add_scroll_binding (GtkBindingSet  *binding_set,
 292                     guint           keyval,
 293                     GdkModifierType mask,
 294                     GtkScrollType   scroll,
 295                     gboolean        horizontal)
 296 {
 297   guint keypad_keyval = keyval - GDK_KEY_Left + GDK_KEY_KP_Left;
 298
 299   gtk_binding_entry_add_signal (binding_set, keyval, mask,
 300                                 "scroll-child", 2,
 301                                 GTK_TYPE_SCROLL_TYPE, scroll,
 302                                 G_TYPE_BOOLEAN, horizontal);
 303   gtk_binding_entry_add_signal (binding_set, keypad_keyval, mask,
 304                                 "scroll-child", 2,
 305                                 GTK_TYPE_SCROLL_TYPE, scroll,
 306                                 G_TYPE_BOOLEAN, horizontal);
 307 }
 308
 309 static void
 310 add_tab_bindings (GtkBindingSet    *binding_set,
 311                   GdkModifierType   modifiers,
 312                   GtkDirectionType  direction)
 313 {
 314   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Tab, modifiers,
 315                                 "move-focus-out", 1,
 316                                 GTK_TYPE_DIRECTION_TYPE, direction);
 317   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Tab, modifiers,
 318                                 "move-focus-out", 1,
 319                                 GTK_TYPE_DIRECTION_TYPE, direction);
 320 }
 321
 322 static void
 323 gtk_scrolled_window_class_init (GtkScrolledWindowClass *class)
 324 {
 325   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
 326   GtkWidgetClass *widget_class;
 327   GtkContainerClass *container_class;
 328   GtkBindingSet *binding_set;
 329
 330   widget_class = (GtkWidgetClass*) class;
 331   container_class = (GtkContainerClass*) class;
 332
 333   gobject_class->set_property = gtk_scrolled_window_set_property;
 334   gobject_class->get_property = gtk_scrolled_window_get_property;
 335
 336   widget_class->destroy = gtk_scrolled_window_destroy;
 337   widget_class->screen_changed = gtk_scrolled_window_screen_changed;
 338   widget_class->draw = gtk_scrolled_window_draw;
 339   widget_class->size_allocate = gtk_scrolled_window_size_allocate;
 340   widget_class->scroll_event = gtk_scrolled_window_scroll_event;
 341   widget_class->focus = gtk_scrolled_window_focus;
 342   widget_class->get_preferred_width = gtk_scrolled_window_get_preferred_width;
 343   widget_class->get_preferred_height = gtk_scrolled_window_get_preferred_height;
 344   widget_class->get_preferred_height_for_width = gtk_scrolled_window_get_preferred_height_for_width;
 345   widget_class->get_preferred_width_for_height = gtk_scrolled_window_get_preferred_width_for_height;
 346   widget_class->realize = gtk_scrolled_window_realize;
 347   widget_class->unrealize = gtk_scrolled_window_unrealize;
 348   widget_class->map = gtk_scrolled_window_map;
 349   widget_class->unmap = gtk_scrolled_window_unmap;
 350   widget_class->grab_notify = gtk_scrolled_window_grab_notify;
 351
 352   container_class->add = gtk_scrolled_window_add;
 353   container_class->remove = gtk_scrolled_window_remove;
 354   container_class->forall = gtk_scrolled_window_forall;
 355   gtk_container_class_handle_border_width (container_class);
 356
 357   class->scrollbar_spacing = -1;
 358
 359   class->scroll_child = gtk_scrolled_window_scroll_child;
 360   class->move_focus_out = gtk_scrolled_window_move_focus_out;
 361
 362   g_object_class_install_property (gobject_class,
 363                                    PROP_HADJUSTMENT,
 364                                    g_param_spec_object ("hadjustment",
 365                                                         P_("Horizontal Adjustment"),
 366                                                         P_("The GtkAdjustment for the horizontal position"),
 367                                                         GTK_TYPE_ADJUSTMENT,
 368                                                         GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 369   g_object_class_install_property (gobject_class,
 370                                    PROP_VADJUSTMENT,
 371                                    g_param_spec_object ("vadjustment",
 372                                                         P_("Vertical Adjustment"),
 373                                                         P_("The GtkAdjustment for the vertical position"),
 374                                                         GTK_TYPE_ADJUSTMENT,
 375                                                         GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 376   g_object_class_install_property (gobject_class,
 377                                    PROP_HSCROLLBAR_POLICY,
 378                                    g_param_spec_enum ("hscrollbar-policy",
 379                                                       P_("Horizontal Scrollbar Policy"),
 380                                                       P_("When the horizontal scrollbar is displayed"),
 381                                                       GTK_TYPE_POLICY_TYPE,
 382                                                       GTK_POLICY_AUTOMATIC,
 383                                                       GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));
 384   g_object_class_install_property (gobject_class,
 385                                    PROP_VSCROLLBAR_POLICY,
 386                                    g_param_spec_enum ("vscrollbar-policy",
 387                                                       P_("Vertical Scrollbar Policy"),
 388                                                       P_("When the vertical scrollbar is displayed"),
 389                                                       GTK_TYPE_POLICY_TYPE,
 390                                                       GTK_POLICY_AUTOMATIC,
 391                                                       GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));
 392
 393   g_object_class_install_property (gobject_class,
 394                                    PROP_WINDOW_PLACEMENT,
 395                                    g_param_spec_enum ("window-placement",
 396                                                       P_("Window Placement"),
 397                                                       P_("Where the contents are located with respect to the scrollbars. This property only takes effect if \"window-placement-set\" is TRUE."),
 398                                                       GTK_TYPE_CORNER_TYPE,
 399                                                       GTK_CORNER_TOP_LEFT,
 400                                                       GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));
 401
 402   /**
 403    * GtkScrolledWindow:window-placement-set:
 404    *
 405    * Whether "window-placement" should be used to determine the location
 406    * of the contents with respect to the scrollbars. Otherwise, the
 407    * "gtk-scrolled-window-placement" setting is used.
 408    *
 409    * Since: 2.10
 410    */
 411   g_object_class_install_property (gobject_class,
 412                                    PROP_WINDOW_PLACEMENT_SET,
 413                                    g_param_spec_boolean ("window-placement-set",
 414                                                          P_("Window Placement Set"),
 415                                                          P_("Whether \"window-placement\" should be used to determine the location of the contents with respect to the scrollbars."),
 416                                                          FALSE,
 417                                                          GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));
 418   g_object_class_install_property (gobject_class,
 419                                    PROP_SHADOW_TYPE,
 420                                    g_param_spec_enum ("shadow-type",
 421                                                       P_("Shadow Type"),
 422                                                       P_("Style of bevel around the contents"),
 423                                                       GTK_TYPE_SHADOW_TYPE,
 424                                                       GTK_SHADOW_NONE,
 425                                                       GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));
 426
 427   /**
 428    * GtkScrolledWindow:scrollbars-within-bevel:
 429    *
 430    * Whether to place scrollbars within the scrolled window's bevel.
 431    *
 432    * Since: 2.12
 433    */
 434   gtk_widget_class_install_style_property (widget_class,
 435                                            g_param_spec_boolean ("scrollbars-within-bevel",
 436                                                                  P_("Scrollbars within bevel"),
 437                                                                  P_("Place scrollbars within the scrolled window's bevel"),
 438                                                                  FALSE,
 439                                                                  GTK_PARAM_READABLE));
 440
 441   gtk_widget_class_install_style_property (widget_class,
 442                                            g_param_spec_int ("scrollbar-spacing",
 443                                                              P_("Scrollbar spacing"),
 444                                                              P_("Number of pixels between the scrollbars and the scrolled window"),
 445                                                              0,
 446                                                              G_MAXINT,
 447                                                              DEFAULT_SCROLLBAR_SPACING,
 448                                                              GTK_PARAM_READABLE));
 449
 450   /**
 451    * GtkScrolledWindow:min-content-width:
 452    *
 453    * The minimum content width of @scrolled_window, or -1 if not set.
 454    *
 455    * Since: 3.0
 456    */
 457   g_object_class_install_property (gobject_class,
 458                                    PROP_MIN_CONTENT_WIDTH,
 459                                    g_param_spec_int ("min-content-width",
 460                                                      P_("Minimum Content Width"),
 461                                                      P_("The minimum width that the scrolled window will allocate to its content"),
 462                                                      -1, G_MAXINT, -1,
 463                                                      GTK_PARAM_READWRITE));
 464
 465   /**
 466    * GtkScrolledWindow:min-content-height:
 467    *
 468    * The minimum content height of @scrolled_window, or -1 if not set.
 469    *
 470    * Since: 3.0
 471    */
 472   g_object_class_install_property (gobject_class,
 473                                    PROP_MIN_CONTENT_HEIGHT,
 474                                    g_param_spec_int ("min-content-height",
 475                                                      P_("Minimum Content Height"),
 476                                                      P_("The minimum height that the scrolled window will allocate to its content"),
 477                                                      -1, G_MAXINT, -1,
 478                                                      GTK_PARAM_READWRITE));
 479
 480   /**
 481    * GtkScrolledWindow:kinetic-scrolling:
 482    *
 483    * The kinetic scrolling behavior flags. Kinetic scrolling
 484    * only applies to devices with source %GDK_SOURCE_TOUCHSCREEN
 485    *
 486    * Since: 3.4
 487    */
 488   g_object_class_install_property (gobject_class,
 489                                    PROP_KINETIC_SCROLLING,
 490                                    g_param_spec_boolean ("kinetic-scrolling",
 491                                                          P_("Kinetic Scrolling"),
 492                                                          P_("Kinetic scrolling mode."),
 493                                                          TRUE,
 494                                                          GTK_PARAM_READABLE |
 495                                                          GTK_PARAM_WRITABLE));
 496   /**
 497    * GtkScrolledWindow::scroll-child:
 498    * @scrolled_window: a #GtkScrolledWindow
 499    * @scroll: a #GtkScrollType describing how much to scroll
 500    * @horizontal: whether the keybinding scrolls the child
 501    *   horizontally or not
 502    *
 503    * The ::scroll-child signal is a
 504    * <link linkend="keybinding-signals">keybinding signal</link>
 505    * which gets emitted when a keybinding that scrolls is pressed.
 506    * The horizontal or vertical adjustment is updated which triggers a
 507    * signal that the scrolled windows child may listen to and scroll itself.
 508    */
 509   signals[SCROLL_CHILD] =
 510     g_signal_new (I_("scroll-child"),
 511                   G_TYPE_FROM_CLASS (gobject_class),
 512                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 513                   G_STRUCT_OFFSET (GtkScrolledWindowClass, scroll_child),
 514                   NULL, NULL,
 515                   _gtk_marshal_BOOLEAN__ENUM_BOOLEAN,
 516                   G_TYPE_BOOLEAN, 2,
 517                   GTK_TYPE_SCROLL_TYPE,
 518                   G_TYPE_BOOLEAN);
 519
 520   /**
 521    * GtkScrolledWindow::move-focus-out:
 522    * @scrolled_window: a #GtkScrolledWindow
 523    * @direction_type: either %GTK_DIR_TAB_FORWARD or
 524    *   %GTK_DIR_TAB_BACKWARD
 525    *
 526    * The ::move-focus-out signal is a
 527    * <link linkend="keybinding-signals">keybinding signal</link>
 528    * which gets emitted when focus is moved away from the scrolled
 529    * window by a keybinding.
 530    * The #GtkWidget::move-focus signal is emitted with @direction_type
 531    * on this scrolled windows toplevel parent in the container hierarchy.
 532    * The default bindings for this signal are
 533    * <keycombo><keycap>Tab</keycap><keycap>Ctrl</keycap></keycombo>
 534    * and
 535    * <keycombo><keycap>Tab</keycap><keycap>Ctrl</keycap><keycap>Shift</keycap></keycombo>.
 536    */
 537   signals[MOVE_FOCUS_OUT] =
 538     g_signal_new (I_("move-focus-out"),
 539                   G_TYPE_FROM_CLASS (gobject_class),
 540                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 541                   G_STRUCT_OFFSET (GtkScrolledWindowClass, move_focus_out),
 542                   NULL, NULL,
 543                   _gtk_marshal_VOID__ENUM,
 544                   G_TYPE_NONE, 1,
 545                   GTK_TYPE_DIRECTION_TYPE);
 546
 547   binding_set = gtk_binding_set_by_class (class);
 548
 549   add_scroll_binding (binding_set, GDK_KEY_Left,  GDK_CONTROL_MASK, GTK_SCROLL_STEP_BACKWARD, TRUE);
 550   add_scroll_binding (binding_set, GDK_KEY_Right, GDK_CONTROL_MASK, GTK_SCROLL_STEP_FORWARD,  TRUE);
 551   add_scroll_binding (binding_set, GDK_KEY_Up,    GDK_CONTROL_MASK, GTK_SCROLL_STEP_BACKWARD, FALSE);
 552   add_scroll_binding (binding_set, GDK_KEY_Down,  GDK_CONTROL_MASK, GTK_SCROLL_STEP_FORWARD,  FALSE);
 553
 554   add_scroll_binding (binding_set, GDK_KEY_Page_Up,   GDK_CONTROL_MASK, GTK_SCROLL_PAGE_BACKWARD, TRUE);
 555   add_scroll_binding (binding_set, GDK_KEY_Page_Down, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_FORWARD,  TRUE);
 556   add_scroll_binding (binding_set, GDK_KEY_Page_Up,   0,                GTK_SCROLL_PAGE_BACKWARD, FALSE);
 557   add_scroll_binding (binding_set, GDK_KEY_Page_Down, 0,                GTK_SCROLL_PAGE_FORWARD,  FALSE);
 558
 559   add_scroll_binding (binding_set, GDK_KEY_Home, GDK_CONTROL_MASK, GTK_SCROLL_START, TRUE);
 560   add_scroll_binding (binding_set, GDK_KEY_End,  GDK_CONTROL_MASK, GTK_SCROLL_END,   TRUE);
 561   add_scroll_binding (binding_set, GDK_KEY_Home, 0,                GTK_SCROLL_START, FALSE);
 562   add_scroll_binding (binding_set, GDK_KEY_End,  0,                GTK_SCROLL_END,   FALSE);
 563
 564   add_tab_bindings (binding_set, GDK_CONTROL_MASK, GTK_DIR_TAB_FORWARD);
 565   add_tab_bindings (binding_set, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
 566
 567   g_type_class_add_private (class, sizeof (GtkScrolledWindowPrivate));
 568
 569   gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE);
 570 }
 571
 572 static void
 573 gtk_scrolled_window_init (GtkScrolledWindow *scrolled_window)
 574 {
 575   GtkScrolledWindowPrivate *priv;
 576
 577   scrolled_window->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE (scrolled_window,
 578                                                               GTK_TYPE_SCROLLED_WINDOW,
 579                                                               GtkScrolledWindowPrivate);
 580
 581   gtk_widget_set_has_window (GTK_WIDGET (scrolled_window), FALSE);
 582   gtk_widget_set_can_focus (GTK_WIDGET (scrolled_window), TRUE);
 583
 584   priv->hscrollbar = NULL;
 585   priv->vscrollbar = NULL;
 586   priv->hscrollbar_policy = GTK_POLICY_AUTOMATIC;
 587   priv->vscrollbar_policy = GTK_POLICY_AUTOMATIC;
 588   priv->hscrollbar_visible = FALSE;
 589   priv->vscrollbar_visible = FALSE;
 590   priv->focus_out = FALSE;
 591   priv->window_placement = GTK_CORNER_TOP_LEFT;
 592   gtk_scrolled_window_update_real_placement (scrolled_window);
 593   priv->min_content_width = -1;
 594   priv->min_content_height = -1;
 595
 596   gtk_scrolled_window_set_kinetic_scrolling (scrolled_window, TRUE);
 597   gtk_scrolled_window_set_capture_button_press (scrolled_window, TRUE);
 598 }
 599
 600 /**
 601  * gtk_scrolled_window_new:
 602  * @hadjustment: (allow-none): horizontal adjustment
 603  * @vadjustment: (allow-none): vertical adjustment
 604  *
 605  * Creates a new scrolled window.
 606  *
 607  * The two arguments are the scrolled window's adjustments; these will be
 608  * shared with the scrollbars and the child widget to keep the bars in sync
 609  * with the child. Usually you want to pass %NULL for the adjustments, which
 610  * will cause the scrolled window to create them for you.
 611  *
 612  * Returns: a new scrolled window
 613  */
 614 GtkWidget*
 615 gtk_scrolled_window_new (GtkAdjustment *hadjustment,
 616                          GtkAdjustment *vadjustment)
 617 {
 618   GtkWidget *scrolled_window;
 619
 620   if (hadjustment)
 621     g_return_val_if_fail (GTK_IS_ADJUSTMENT (hadjustment), NULL);
 622
 623   if (vadjustment)
 624     g_return_val_if_fail (GTK_IS_ADJUSTMENT (vadjustment), NULL);
 625
 626   scrolled_window = g_object_new (GTK_TYPE_SCROLLED_WINDOW,
 627                                     "hadjustment", hadjustment,
 628                                     "vadjustment", vadjustment,
 629                                     NULL);
 630
 631   return scrolled_window;
 632 }
 633
 634 /**
 635  * gtk_scrolled_window_set_hadjustment:
 636  * @scrolled_window: a #GtkScrolledWindow
 637  * @hadjustment: horizontal scroll adjustment
 638  *
 639  * Sets the #GtkAdjustment for the horizontal scrollbar.
 640  */
 641 void
 642 gtk_scrolled_window_set_hadjustment (GtkScrolledWindow *scrolled_window,
 643                                      GtkAdjustment     *hadjustment)
 644 {
 645   GtkScrolledWindowPrivate *priv;
 646   GtkBin *bin;
 647   GtkWidget *child;
 648
 649   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 650   if (hadjustment)
 651     g_return_if_fail (GTK_IS_ADJUSTMENT (hadjustment));
 652   else
 653     hadjustment = (GtkAdjustment*) g_object_new (GTK_TYPE_ADJUSTMENT, NULL);
 654
 655   bin = GTK_BIN (scrolled_window);
 656   priv = scrolled_window->priv;
 657
 658   if (!priv->hscrollbar)
 659     {
 660       gtk_widget_push_composite_child ();
 661       priv->hscrollbar = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, hadjustment);
 662       gtk_widget_set_composite_name (priv->hscrollbar, "hscrollbar");
 663       gtk_widget_pop_composite_child ();
 664
 665       gtk_widget_set_parent (priv->hscrollbar, GTK_WIDGET (scrolled_window));
 666       g_object_ref (priv->hscrollbar);
 667       gtk_widget_show (priv->hscrollbar);
 668     }
 669   else
 670     {
 671       GtkAdjustment *old_adjustment;
 672
 673       old_adjustment = gtk_range_get_adjustment (GTK_RANGE (priv->hscrollbar));
 674       if (old_adjustment == hadjustment)
 675         return;
 676
 677       g_signal_handlers_disconnect_by_func (old_adjustment,
 678                                             gtk_scrolled_window_adjustment_changed,
 679                                             scrolled_window);
 680       gtk_range_set_adjustment (GTK_RANGE (priv->hscrollbar),
 681                                 hadjustment);
 682     }
 683   hadjustment = gtk_range_get_adjustment (GTK_RANGE (priv->hscrollbar));
 684   g_signal_connect (hadjustment,
 685                     "changed",
 686                     G_CALLBACK (gtk_scrolled_window_adjustment_changed),
 687                     scrolled_window);
 688   g_signal_connect (hadjustment,
 689                     "value-changed",
 690                     G_CALLBACK (gtk_scrolled_window_adjustment_value_changed),
 691                     scrolled_window);
 692   gtk_scrolled_window_adjustment_changed (hadjustment, scrolled_window);
 693   gtk_scrolled_window_adjustment_value_changed (hadjustment, scrolled_window);
 694
 695   child = gtk_bin_get_child (bin);
 696   if (GTK_IS_SCROLLABLE (child))
 697     gtk_scrollable_set_hadjustment (GTK_SCROLLABLE (child), hadjustment);
 698
 699   g_object_notify (G_OBJECT (scrolled_window), "hadjustment");
 700 }
 701
 702 /**
 703  * gtk_scrolled_window_set_vadjustment:
 704  * @scrolled_window: a #GtkScrolledWindow
 705  * @vadjustment: vertical scroll adjustment
 706  *
 707  * Sets the #GtkAdjustment for the vertical scrollbar.
 708  */
 709 void
 710 gtk_scrolled_window_set_vadjustment (GtkScrolledWindow *scrolled_window,
 711                                      GtkAdjustment     *vadjustment)
 712 {
 713   GtkScrolledWindowPrivate *priv;
 714   GtkBin *bin;
 715   GtkWidget *child;
 716
 717   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 718   if (vadjustment)
 719     g_return_if_fail (GTK_IS_ADJUSTMENT (vadjustment));
 720   else
 721     vadjustment = (GtkAdjustment*) g_object_new (GTK_TYPE_ADJUSTMENT, NULL);
 722
 723   bin = GTK_BIN (scrolled_window);
 724   priv = scrolled_window->priv;
 725
 726   if (!priv->vscrollbar)
 727     {
 728       gtk_widget_push_composite_child ();
 729       priv->vscrollbar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, vadjustment);
 730       gtk_widget_set_composite_name (priv->vscrollbar, "vscrollbar");
 731       gtk_widget_pop_composite_child ();
 732
 733       gtk_widget_set_parent (priv->vscrollbar, GTK_WIDGET (scrolled_window));
 734       g_object_ref (priv->vscrollbar);
 735       gtk_widget_show (priv->vscrollbar);
 736     }
 737   else
 738     {
 739       GtkAdjustment *old_adjustment;
 740
 741       old_adjustment = gtk_range_get_adjustment (GTK_RANGE (priv->vscrollbar));
 742       if (old_adjustment == vadjustment)
 743         return;
 744
 745       g_signal_handlers_disconnect_by_func (old_adjustment,
 746                                             gtk_scrolled_window_adjustment_changed,
 747                                             scrolled_window);
 748       gtk_range_set_adjustment (GTK_RANGE (priv->vscrollbar),
 749                                 vadjustment);
 750     }
 751   vadjustment = gtk_range_get_adjustment (GTK_RANGE (priv->vscrollbar));
 752   g_signal_connect (vadjustment,
 753                     "changed",
 754                     G_CALLBACK (gtk_scrolled_window_adjustment_changed),
 755                     scrolled_window);
 756   g_signal_connect (vadjustment,
 757                     "value-changed",
 758                     G_CALLBACK (gtk_scrolled_window_adjustment_value_changed),
 759                     scrolled_window);
 760   gtk_scrolled_window_adjustment_changed (vadjustment, scrolled_window);
 761   gtk_scrolled_window_adjustment_value_changed (vadjustment, scrolled_window);
 762
 763   child = gtk_bin_get_child (bin);
 764   if (GTK_IS_SCROLLABLE (child))
 765     gtk_scrollable_set_vadjustment (GTK_SCROLLABLE (child), vadjustment);
 766
 767   g_object_notify (G_OBJECT (scrolled_window), "vadjustment");
 768 }
 769
 770 /**
 771  * gtk_scrolled_window_get_hadjustment:
 772  * @scrolled_window: a #GtkScrolledWindow
 773  *
 774  * Returns the horizontal scrollbar's adjustment, used to connect the
 775  * horizontal scrollbar to the child widget's horizontal scroll
 776  * functionality.
 777  *
 778  * Returns: (transfer none): the horizontal #GtkAdjustment
 779  */
 780 GtkAdjustment*
 781 gtk_scrolled_window_get_hadjustment (GtkScrolledWindow *scrolled_window)
 782 {
 783   GtkScrolledWindowPrivate *priv;
 784
 785   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);
 786
 787   priv = scrolled_window->priv;
 788
 789   return (priv->hscrollbar ?
 790           gtk_range_get_adjustment (GTK_RANGE (priv->hscrollbar)) :
 791           NULL);
 792 }
 793
 794 /**
 795  * gtk_scrolled_window_get_vadjustment:
 796  * @scrolled_window: a #GtkScrolledWindow
 797  *
 798  * Returns the vertical scrollbar's adjustment, used to connect the
 799  * vertical scrollbar to the child widget's vertical scroll functionality.
 800  *
 801  * Returns: (transfer none): the vertical #GtkAdjustment
 802  */
 803 GtkAdjustment*
 804 gtk_scrolled_window_get_vadjustment (GtkScrolledWindow *scrolled_window)
 805 {
 806   GtkScrolledWindowPrivate *priv;
 807
 808   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);
 809
 810   priv = scrolled_window->priv;
 811
 812   return (priv->vscrollbar ?
 813           gtk_range_get_adjustment (GTK_RANGE (priv->vscrollbar)) :
 814           NULL);
 815 }
 816
 817 /**
 818  * gtk_scrolled_window_get_hscrollbar:
 819  * @scrolled_window: a #GtkScrolledWindow
 820  *
 821  * Returns the horizontal scrollbar of @scrolled_window.
 822  *
 823  * Returns: (transfer none): the horizontal scrollbar of the scrolled window,
 824  *     or %NULL if it does not have one.
 825  *
 826  * Since: 2.8
 827  */
 828 GtkWidget*
 829 gtk_scrolled_window_get_hscrollbar (GtkScrolledWindow *scrolled_window)
 830 {
 831   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);
 832
 833   return scrolled_window->priv->hscrollbar;
 834 }
 835
 836 /**
 837  * gtk_scrolled_window_get_vscrollbar:
 838  * @scrolled_window: a #GtkScrolledWindow
 839  *
 840  * Returns the vertical scrollbar of @scrolled_window.
 841  *
 842  * Returns: (transfer none): the vertical scrollbar of the scrolled window,
 843  *     or %NULL if it does not have one.
 844  *
 845  * Since: 2.8
 846  */
 847 GtkWidget*
 848 gtk_scrolled_window_get_vscrollbar (GtkScrolledWindow *scrolled_window)
 849 {
 850   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);
 851
 852   return scrolled_window->priv->vscrollbar;
 853 }
 854
 855 /**
 856  * gtk_scrolled_window_set_policy:
 857  * @scrolled_window: a #GtkScrolledWindow
 858  * @hscrollbar_policy: policy for horizontal bar
 859  * @vscrollbar_policy: policy for vertical bar
 860  *
 861  * Sets the scrollbar policy for the horizontal and vertical scrollbars.
 862  *
 863  * The policy determines when the scrollbar should appear; it is a value
 864  * from the #GtkPolicyType enumeration. If %GTK_POLICY_ALWAYS, the
 865  * scrollbar is always present; if %GTK_POLICY_NEVER, the scrollbar is
 866  * never present; if %GTK_POLICY_AUTOMATIC, the scrollbar is present only
 867  * if needed (that is, if the slider part of the bar would be smaller
 868  * than the trough - the display is larger than the page size).
 869  */
 870 void
 871 gtk_scrolled_window_set_policy (GtkScrolledWindow *scrolled_window,
 872                                 GtkPolicyType      hscrollbar_policy,
 873                                 GtkPolicyType      vscrollbar_policy)
 874 {
 875   GtkScrolledWindowPrivate *priv;
 876   GObject *object = G_OBJECT (scrolled_window);
 877
 878   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 879
 880   priv = scrolled_window->priv;
 881
 882   if ((priv->hscrollbar_policy != hscrollbar_policy) ||
 883       (priv->vscrollbar_policy != vscrollbar_policy))
 884     {
 885       priv->hscrollbar_policy = hscrollbar_policy;
 886       priv->vscrollbar_policy = vscrollbar_policy;
 887
 888       gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
 889
 890       g_object_freeze_notify (object);
 891       g_object_notify (object, "hscrollbar-policy");
 892       g_object_notify (object, "vscrollbar-policy");
 893       g_object_thaw_notify (object);
 894     }
 895 }
 896
 897 /**
 898  * gtk_scrolled_window_get_policy:
 899  * @scrolled_window: a #GtkScrolledWindow
 900  * @hscrollbar_policy: (out) (allow-none): location to store the policy
 901  *     for the horizontal scrollbar, or %NULL.
 902  * @vscrollbar_policy: (out) (allow-none): location to store the policy
 903  *     for the vertical scrollbar, or %NULL.
 904  *
 905  * Retrieves the current policy values for the horizontal and vertical
 906  * scrollbars. See gtk_scrolled_window_set_policy().
 907  */
 908 void
 909 gtk_scrolled_window_get_policy (GtkScrolledWindow *scrolled_window,
 910                                 GtkPolicyType     *hscrollbar_policy,
 911                                 GtkPolicyType     *vscrollbar_policy)
 912 {
 913   GtkScrolledWindowPrivate *priv;
 914
 915   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 916
 917   priv = scrolled_window->priv;
 918
 919   if (hscrollbar_policy)
 920     *hscrollbar_policy = priv->hscrollbar_policy;
 921   if (vscrollbar_policy)
 922     *vscrollbar_policy = priv->vscrollbar_policy;
 923 }
 924
 925 static void
 926 gtk_scrolled_window_update_real_placement (GtkScrolledWindow *scrolled_window)
 927 {
 928   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
 929   GtkSettings *settings;
 930
 931   settings = gtk_widget_get_settings (GTK_WIDGET (scrolled_window));
 932
 933   if (priv->window_placement_set || settings == NULL)
 934     priv->real_window_placement = priv->window_placement;
 935   else
 936     g_object_get (settings,
 937                   "gtk-scrolled-window-placement",
 938                   &priv->real_window_placement,
 939                   NULL);
 940 }
 941
 942 static void
 943 gtk_scrolled_window_set_placement_internal (GtkScrolledWindow *scrolled_window,
 944                                             GtkCornerType      window_placement)
 945 {
 946   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
 947
 948   if (priv->window_placement != window_placement)
 949     {
 950       priv->window_placement = window_placement;
 951
 952       gtk_scrolled_window_update_real_placement (scrolled_window);
 953       gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
 954
 955       g_object_notify (G_OBJECT (scrolled_window), "window-placement");
 956     }
 957 }
 958
 959 static void
 960 gtk_scrolled_window_set_placement_set (GtkScrolledWindow *scrolled_window,
 961                                        gboolean           placement_set,
 962                                        gboolean           emit_resize)
 963 {
 964   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
 965
 966   if (priv->window_placement_set != placement_set)
 967     {
 968       priv->window_placement_set = placement_set;
 969
 970       gtk_scrolled_window_update_real_placement (scrolled_window);
 971       if (emit_resize)
 972         gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
 973
 974       g_object_notify (G_OBJECT (scrolled_window), "window-placement-set");
 975     }
 976 }
 977
 978 /**
 979  * gtk_scrolled_window_set_placement:
 980  * @scrolled_window: a #GtkScrolledWindow
 981  * @window_placement: position of the child window
 982  *
 983  * Sets the placement of the contents with respect to the scrollbars
 984  * for the scrolled window.
 985  *
 986  * The default is %GTK_CORNER_TOP_LEFT, meaning the child is
 987  * in the top left, with the scrollbars underneath and to the right.
 988  * Other values in #GtkCornerType are %GTK_CORNER_TOP_RIGHT,
 989  * %GTK_CORNER_BOTTOM_LEFT, and %GTK_CORNER_BOTTOM_RIGHT.
 990  *
 991  * See also gtk_scrolled_window_get_placement() and
 992  * gtk_scrolled_window_unset_placement().
 993  */
 994 void
 995 gtk_scrolled_window_set_placement (GtkScrolledWindow *scrolled_window,
 996                                    GtkCornerType      window_placement)
 997 {
 998   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 999
1000   gtk_scrolled_window_set_placement_set (scrolled_window, TRUE, FALSE);
1001   gtk_scrolled_window_set_placement_internal (scrolled_window, window_placement);
1002 }
1003
1004 /**
1005  * gtk_scrolled_window_get_placement:
1006  * @scrolled_window: a #GtkScrolledWindow
1007  *
1008  * Gets the placement of the contents with respect to the scrollbars
1009  * for the scrolled window. See gtk_scrolled_window_set_placement().
1010  *
1011  * Return value: the current placement value.
1012  *
1013  * See also gtk_scrolled_window_set_placement() and
1014  * gtk_scrolled_window_unset_placement().
1015  **/
1016 GtkCornerType
1017 gtk_scrolled_window_get_placement (GtkScrolledWindow *scrolled_window)
1018 {
1019   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), GTK_CORNER_TOP_LEFT);
1020
1021   return scrolled_window->priv->window_placement;
1022 }
1023
1024 /**
1025  * gtk_scrolled_window_unset_placement:
1026  * @scrolled_window: a #GtkScrolledWindow
1027  *
1028  * Unsets the placement of the contents with respect to the scrollbars
1029  * for the scrolled window. If no window placement is set for a scrolled
1030  * window, it obeys the "gtk-scrolled-window-placement" XSETTING.
1031  *
1032  * See also gtk_scrolled_window_set_placement() and
1033  * gtk_scrolled_window_get_placement().
1034  *
1035  * Since: 2.10
1036  **/
1037 void
1038 gtk_scrolled_window_unset_placement (GtkScrolledWindow *scrolled_window)
1039 {
1040   GtkScrolledWindowPrivate *priv;
1041
1042   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
1043
1044   priv = scrolled_window->priv;
1045
1046   if (priv->window_placement_set)
1047     {
1048       priv->window_placement_set = FALSE;
1049
1050       gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
1051
1052       g_object_notify (G_OBJECT (scrolled_window), "window-placement-set");
1053     }
1054 }
1055
1056 /**
1057  * gtk_scrolled_window_set_shadow_type:
1058  * @scrolled_window: a #GtkScrolledWindow
1059  * @type: kind of shadow to draw around scrolled window contents
1060  *
1061  * Changes the type of shadow drawn around the contents of
1062  * @scrolled_window.
1063  *
1064  **/
1065 void
1066 gtk_scrolled_window_set_shadow_type (GtkScrolledWindow *scrolled_window,
1067                                      GtkShadowType      type)
1068 {
1069   GtkScrolledWindowPrivate *priv;
1070
1071   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
1072   g_return_if_fail (type >= GTK_SHADOW_NONE && type <= GTK_SHADOW_ETCHED_OUT);
1073
1074   priv = scrolled_window->priv;
1075
1076   if (priv->shadow_type != type)
1077     {
1078       priv->shadow_type = type;
1079
1080       if (gtk_widget_is_drawable (GTK_WIDGET (scrolled_window)))
1081         gtk_widget_queue_draw (GTK_WIDGET (scrolled_window));
1082
1083       gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
1084
1085       g_object_notify (G_OBJECT (scrolled_window), "shadow-type");
1086     }
1087 }
1088
1089 /**
1090  * gtk_scrolled_window_get_shadow_type:
1091  * @scrolled_window: a #GtkScrolledWindow
1092  *
1093  * Gets the shadow type of the scrolled window. See
1094  * gtk_scrolled_window_set_shadow_type().
1095  *
1096  * Return value: the current shadow type
1097  **/
1098 GtkShadowType
1099 gtk_scrolled_window_get_shadow_type (GtkScrolledWindow *scrolled_window)
1100 {
1101   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_NONE);
1102
1103   return scrolled_window->priv->shadow_type;
1104 }
1105
1106 /**
1107  * gtk_scrolled_window_set_kinetic_scrolling:
1108  * @scrolled_window: a #GtkScrolledWindow
1109  * @kinetic_scrolling: %TRUE to enable kinetic scrolling
1110  *
1111  * Turns kinetic scrolling on or off.
1112  * Kinetic scrolling only applies to devices with source
1113  * %GDK_SOURCE_TOUCHSCREEN.
1114  *
1115  * Since: 3.4
1116  **/
1117 void
1118 gtk_scrolled_window_set_kinetic_scrolling (GtkScrolledWindow *scrolled_window,
1119                                            gboolean           kinetic_scrolling)
1120 {
1121   GtkScrolledWindowPrivate *priv;
1122
1123   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
1124
1125   priv = scrolled_window->priv;
1126   if (priv->kinetic_scrolling == kinetic_scrolling)
1127     return;
1128
1129   priv->kinetic_scrolling = kinetic_scrolling;
1130   if (priv->kinetic_scrolling)
1131     {
1132       _gtk_widget_set_captured_event_handler (GTK_WIDGET (scrolled_window),
1133                                               gtk_scrolled_window_captured_event);
1134     }
1135   else
1136     {
1137       _gtk_widget_set_captured_event_handler (GTK_WIDGET (scrolled_window), NULL);
1138       if (priv->release_timeout_id)
1139         {
1140           g_source_remove (priv->release_timeout_id);
1141           priv->release_timeout_id = 0;
1142         }
1143       if (priv->deceleration_id)
1144         {
1145           g_source_remove (priv->deceleration_id);
1146           priv->deceleration_id = 0;
1147         }
1148     }
1149   g_object_notify (G_OBJECT (scrolled_window), "kinetic-scrolling");
1150 }
1151
1152 /**
1153  * gtk_scrolled_window_get_kinetic_scrolling:
1154  * @scrolled_window: a #GtkScrolledWindow
1155  *
1156  * Returns the specified kinetic scrolling behavior.
1157  *
1158  * Return value: the scrolling behavior flags.
1159  *
1160  * Since: 3.4
1161  */
1162 gboolean
1163 gtk_scrolled_window_get_kinetic_scrolling (GtkScrolledWindow *scrolled_window)
1164 {
1165   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), FALSE);
1166
1167   return scrolled_window->priv->kinetic_scrolling;
1168 }
1169
1170 /**
1171  * gtk_scrolled_window_set_capture_button_press:
1172  * @scrolled_window: a #GtkScrolledWindow
1173  * @capture_button_press: %TRUE to capture button presses
1174  *
1175  * Changes the behaviour of @scrolled_window wrt. to the initial
1176  * event that possibly starts kinetic scrolling. When @capture_button_press
1177  * is set to %TRUE, the event is captured by the scrolled window, and
1178  * then later replayed if it is meant to go to the child widget.
1179  *
1180  * This should be enabled if any child widgets perform non-reversible
1181  * actions on #GtkWidget::button-press-event. If they don't, and handle
1182  * additionally handle #GtkWidget::grab-broken-event, it might be better
1183  * to set @capture_button_press to %FALSE.
1184  *
1185  * This setting only has an effect if kinetic scrolling is enabled.
1186  *
1187  * Since: 3.4
1188  */
1189 void
1190 gtk_scrolled_window_set_capture_button_press (GtkScrolledWindow *scrolled_window,
1191                                               gboolean           capture_button_press)
1192 {
1193   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
1194
1195   scrolled_window->priv->capture_button_press = capture_button_press;
1196 }
1197
1198 /**
1199  * gtk_scrolled_window_get_capture_button_press:
1200  * @scrolled_window: a #GtkScrolledWindow
1201  *
1202  * Return whether button presses are captured during kinetic
1203  * scrolling. See gtk_scrolled_window_set_capture_button_press().
1204  *
1205  * Returns: %TRUE if button presses are captured during kinetic scrolling
1206  *
1207  * Since: 3.4
1208  */
1209 gboolean
1210 gtk_scrolled_window_get_capture_button_press (GtkScrolledWindow *scrolled_window)
1211 {
1212   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), FALSE);
1213
1214   return scrolled_window->priv->capture_button_press;
1215 }
1216
1217
1218 static void
1219 gtk_scrolled_window_destroy (GtkWidget *widget)
1220 {
1221   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
1222   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
1223
1224   if (priv->hscrollbar)
1225     {
1226       g_signal_handlers_disconnect_by_func (gtk_range_get_adjustment (GTK_RANGE (priv->hscrollbar)),
1227                                             gtk_scrolled_window_adjustment_changed,
1228                                             scrolled_window);
1229       gtk_widget_unparent (priv->hscrollbar);
1230       gtk_widget_destroy (priv->hscrollbar);
1231       g_object_unref (priv->hscrollbar);
1232       priv->hscrollbar = NULL;
1233     }
1234   if (priv->vscrollbar)
1235     {
1236       g_signal_handlers_disconnect_by_func (gtk_range_get_adjustment (GTK_RANGE (priv->vscrollbar)),
1237                                             gtk_scrolled_window_adjustment_changed,
1238                                             scrolled_window);
1239       gtk_widget_unparent (priv->vscrollbar);
1240       gtk_widget_destroy (priv->vscrollbar);
1241       g_object_unref (priv->vscrollbar);
1242       priv->vscrollbar = NULL;
1243     }
1244
1245   if (priv->release_timeout_id)
1246     {
1247       g_source_remove (priv->release_timeout_id);
1248       priv->release_timeout_id = 0;
1249     }
1250   if (priv->deceleration_id)
1251     {
1252       g_source_remove (priv->deceleration_id);
1253       priv->deceleration_id = 0;
1254     }
1255
1256   if (priv->button_press_event)
1257     {
1258       gdk_event_free (priv->button_press_event);
1259       priv->button_press_event = NULL;
1260     }
1261
1262   GTK_WIDGET_CLASS (gtk_scrolled_window_parent_class)->destroy (widget);
1263 }
1264
1265 static void
1266 gtk_scrolled_window_set_property (GObject      *object,
1267                                   guint         prop_id,
1268                                   const GValue *value,
1269                                   GParamSpec   *pspec)
1270 {
1271   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (object);
1272   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
1273
1274   switch (prop_id)
1275     {
1276     case PROP_HADJUSTMENT:
1277       gtk_scrolled_window_set_hadjustment (scrolled_window,
1278                                            g_value_get_object (value));
1279       break;
1280     case PROP_VADJUSTMENT:
1281       gtk_scrolled_window_set_vadjustment (scrolled_window,
1282                                            g_value_get_object (value));
1283       break;
1284     case PROP_HSCROLLBAR_POLICY:
1285       gtk_scrolled_window_set_policy (scrolled_window,
1286                                       g_value_get_enum (value),
1287                                       priv->vscrollbar_policy);
1288       break;
1289     case PROP_VSCROLLBAR_POLICY:
1290       gtk_scrolled_window_set_policy (scrolled_window,
1291                                       priv->hscrollbar_policy,
1292                                       g_value_get_enum (value));
1293       break;
1294     case PROP_WINDOW_PLACEMENT:
1295       gtk_scrolled_window_set_placement_internal (scrolled_window,
1296                                                   g_value_get_enum (value));
1297       break;
1298     case PROP_WINDOW_PLACEMENT_SET:
1299       gtk_scrolled_window_set_placement_set (scrolled_window,
1300                                              g_value_get_boolean (value),
1301                                              TRUE);
1302       break;
1303     case PROP_SHADOW_TYPE:
1304       gtk_scrolled_window_set_shadow_type (scrolled_window,
1305                                            g_value_get_enum (value));
1306       break;
1307     case PROP_MIN_CONTENT_WIDTH:
1308       gtk_scrolled_window_set_min_content_width (scrolled_window,
1309                                                  g_value_get_int (value));
1310       break;
1311     case PROP_MIN_CONTENT_HEIGHT:
1312       gtk_scrolled_window_set_min_content_height (scrolled_window,
1313                                                   g_value_get_int (value));
1314       break;
1315     case PROP_KINETIC_SCROLLING:
1316       gtk_scrolled_window_set_kinetic_scrolling (scrolled_window,
1317                                                  g_value_get_boolean (value));
1318       break;
1319     default:
1320       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1321       break;
1322     }
1323 }
1324
1325 static void
1326 gtk_scrolled_window_get_property (GObject    *object,
1327                                   guint       prop_id,
1328                                   GValue     *value,
1329                                   GParamSpec *pspec)
1330 {
1331   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (object);
1332   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
1333
1334   switch (prop_id)
1335     {
1336     case PROP_HADJUSTMENT:
1337       g_value_set_object (value,
1338                           G_OBJECT (gtk_scrolled_window_get_hadjustment (scrolled_window)));
1339       break;
1340     case PROP_VADJUSTMENT:
1341       g_value_set_object (value,
1342                           G_OBJECT (gtk_scrolled_window_get_vadjustment (scrolled_window)));
1343       break;
1344     case PROP_WINDOW_PLACEMENT:
1345       g_value_set_enum (value, priv->window_placement);
1346       break;
1347     case PROP_WINDOW_PLACEMENT_SET:
1348       g_value_set_boolean (value, priv->window_placement_set);
1349       break;
1350     case PROP_SHADOW_TYPE:
1351       g_value_set_enum (value, priv->shadow_type);
1352       break;
1353     case PROP_HSCROLLBAR_POLICY:
1354       g_value_set_enum (value, priv->hscrollbar_policy);
1355       break;
1356     case PROP_VSCROLLBAR_POLICY:
1357       g_value_set_enum (value, priv->vscrollbar_policy);
1358       break;
1359     case PROP_MIN_CONTENT_WIDTH:
1360       g_value_set_int (value, priv->min_content_width);
1361       break;
1362     case PROP_MIN_CONTENT_HEIGHT:
1363       g_value_set_int (value, priv->min_content_height);
1364       break;
1365     case PROP_KINETIC_SCROLLING:
1366       g_value_set_boolean (value, priv->kinetic_scrolling);
1367       break;
1368     default:
1369       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1370       break;
1371     }
1372 }
1373
1374 static void
1375 traverse_container (GtkWidget *widget,
1376                     gpointer   data)
1377 {
1378   if (GTK_IS_SCROLLED_WINDOW (widget))
1379     {
1380       gtk_scrolled_window_update_real_placement (GTK_SCROLLED_WINDOW (widget));
1381       gtk_widget_queue_resize (widget);
1382     }
1383   else if (GTK_IS_CONTAINER (widget))
1384     gtk_container_forall (GTK_CONTAINER (widget), traverse_container, NULL);
1385 }
1386
1387 static void
1388 gtk_scrolled_window_settings_changed (GtkSettings *settings)
1389 {
1390   GList *list, *l;
1391
1392   list = gtk_window_list_toplevels ();
1393
1394   for (l = list; l; l = l->next)
1395     gtk_container_forall (GTK_CONTAINER (l->data),
1396                           traverse_container, NULL);
1397
1398   g_list_free (list);
1399 }
1400
1401 static void
1402 gtk_scrolled_window_screen_changed (GtkWidget *widget,
1403                                     GdkScreen *previous_screen)
1404 {
1405   GtkSettings *settings;
1406   guint window_placement_connection;
1407
1408   gtk_scrolled_window_update_real_placement (GTK_SCROLLED_WINDOW (widget));
1409
1410   if (!gtk_widget_has_screen (widget))
1411     return;
1412
1413   settings = gtk_widget_get_settings (widget);
1414
1415   window_placement_connection =
1416     GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (settings),
1417                                          "gtk-scrolled-window-connection"));
1418
1419   if (window_placement_connection)
1420     return;
1421
1422   window_placement_connection =
1423     g_signal_connect (settings, "notify::gtk-scrolled-window-placement",
1424                       G_CALLBACK (gtk_scrolled_window_settings_changed), NULL);
1425   g_object_set_data (G_OBJECT (settings),
1426                      I_("gtk-scrolled-window-connection"),
1427                      GUINT_TO_POINTER (window_placement_connection));
1428 }
1429
1430 static void
1431 gtk_scrolled_window_draw_scrollbars_junction (GtkScrolledWindow *scrolled_window,
1432                                               cairo_t *cr)
1433 {
1434   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
1435   GtkAllocation wid_allocation, hscr_allocation, vscr_allocation;
1436   GtkStyleContext *context;
1437   GdkRectangle junction_rect;
1438   gboolean is_rtl;
1439
1440   is_rtl = gtk_widget_get_direction (GTK_WIDGET (scrolled_window)) == GTK_TEXT_DIR_RTL;
1441   gtk_widget_get_allocation (GTK_WIDGET (scrolled_window), &wid_allocation);
1442   gtk_widget_get_allocation (GTK_WIDGET (priv->hscrollbar), &hscr_allocation);
1443   gtk_widget_get_allocation (GTK_WIDGET (priv->vscrollbar), &vscr_allocation);
1444
1445   junction_rect.x = 0;
1446   junction_rect.y = 0;
1447   junction_rect.width = vscr_allocation.width;
1448   junction_rect.height = hscr_allocation.height;
1449
1450   if ((is_rtl &&
1451        (priv->real_window_placement == GTK_CORNER_TOP_RIGHT ||
1452         priv->real_window_placement == GTK_CORNER_BOTTOM_RIGHT)) ||
1453       (!is_rtl &&
1454        (priv->real_window_placement == GTK_CORNER_TOP_LEFT ||
1455         priv->real_window_placement == GTK_CORNER_BOTTOM_LEFT)))
1456     junction_rect.x = hscr_allocation.width;
1457
1458   if (priv->real_window_placement == GTK_CORNER_TOP_LEFT ||
1459       priv->real_window_placement == GTK_CORNER_TOP_RIGHT)
1460     junction_rect.y = vscr_allocation.height;
1461
1462   context = gtk_widget_get_style_context (GTK_WIDGET (scrolled_window));
1463   gtk_style_context_save (context);
1464   gtk_style_context_add_class (context, GTK_STYLE_CLASS_SCROLLBARS_JUNCTION);
1465
1466   gtk_render_background (context, cr,
1467                          junction_rect.x, junction_rect.y,
1468                          junction_rect.width, junction_rect.height);
1469   gtk_render_frame (context, cr,
1470                     junction_rect.x, junction_rect.y,
1471                     junction_rect.width, junction_rect.height);
1472
1473   gtk_style_context_restore (context);
1474 }
1475
1476 static gboolean
1477 gtk_scrolled_window_draw (GtkWidget *widget,
1478                           cairo_t   *cr)
1479 {
1480   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
1481   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
1482   GtkAllocation relative_allocation;
1483   cairo_pattern_t *pattern = NULL;
1484   GtkStyleContext *context;
1485   GtkWidget *child;
1486
1487   context = gtk_widget_get_style_context (widget);
1488   gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
1489
1490   /* Use child's background if possible */
1491   child = gtk_bin_get_child (GTK_BIN (widget));
1492
1493   if (child && gtk_widget_get_has_window (child))
1494     pattern = gdk_window_get_background_pattern (gtk_widget_get_window (child));
1495
1496   if (pattern &&
1497       cairo_pattern_get_type (pattern) == CAIRO_PATTERN_TYPE_SOLID)
1498     {
1499       cairo_set_source (cr, pattern);
1500
1501       cairo_rectangle (cr, relative_allocation.x, relative_allocation.y,
1502                        relative_allocation.width, relative_allocation.height);
1503       cairo_fill (cr);
1504     }
1505   else
1506     gtk_render_background (context, cr,
1507                            relative_allocation.x, relative_allocation.y,
1508                            relative_allocation.width, relative_allocation.height);
1509
1510   if (priv->hscrollbar_visible &&
1511       priv->vscrollbar_visible)
1512     gtk_scrolled_window_draw_scrollbars_junction (scrolled_window, cr);
1513
1514   if (priv->shadow_type != GTK_SHADOW_NONE)
1515     {
1516       gboolean scrollbars_within_bevel;
1517
1518       gtk_style_context_save (context);
1519       gtk_style_context_add_class (context, GTK_STYLE_CLASS_FRAME);
1520
1521       gtk_widget_style_get (widget, "scrollbars-within-bevel", &scrollbars_within_bevel, NULL);
1522
1523       if (!scrollbars_within_bevel)
1524         {
1525           GtkStateFlags state;
1526           GtkBorder padding, border;
1527
1528           state = gtk_widget_get_state_flags (widget);
1529           gtk_style_context_get_padding (context, state, &padding);
1530           gtk_style_context_get_border (context, state, &border);
1531
1532           relative_allocation.x -= padding.left + border.left;
1533           relative_allocation.y -= padding.top + border.top;
1534           relative_allocation.width += padding.left + padding.right + border.left + border.right;
1535           relative_allocation.height += padding.top + padding.bottom + border.top + border.bottom;
1536         }
1537       else
1538         {
1539           relative_allocation.x = 0;
1540           relative_allocation.y = 0;
1541           relative_allocation.width = gtk_widget_get_allocated_width (widget);
1542           relative_allocation.height = gtk_widget_get_allocated_height (widget);
1543         }
1544
1545       gtk_render_frame (context, cr,
1546                         relative_allocation.x,
1547                         relative_allocation.y,
1548                         relative_allocation.width,
1549                         relative_allocation.height);
1550
1551       gtk_style_context_restore (context);
1552     }
1553
1554   GTK_WIDGET_CLASS (gtk_scrolled_window_parent_class)->draw (widget, cr);
1555
1556   return FALSE;
1557 }
1558
1559 static void
1560 gtk_scrolled_window_forall (GtkContainer *container,
1561                             gboolean      include_internals,
1562                             GtkCallback   callback,
1563                             gpointer      callback_data)
1564 {
1565   GtkScrolledWindowPrivate *priv;
1566   GtkScrolledWindow *scrolled_window;
1567
1568   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (container));
1569   g_return_if_fail (callback != NULL);
1570
1571   GTK_CONTAINER_CLASS (gtk_scrolled_window_parent_class)->forall (container,
1572                                               include_internals,
1573                                               callback,
1574                                               callback_data);
1575   if (include_internals)
1576     {
1577       scrolled_window = GTK_SCROLLED_WINDOW (container);
1578       priv = scrolled_window->priv;
1579
1580       if (priv->vscrollbar)
1581         callback (priv->vscrollbar, callback_data);
1582       if (priv->hscrollbar)
1583         callback (priv->hscrollbar, callback_data);
1584     }
1585 }
1586
1587 static gboolean
1588 gtk_scrolled_window_scroll_child (GtkScrolledWindow *scrolled_window,
1589                                   GtkScrollType      scroll,
1590                                   gboolean           horizontal)
1591 {
1592   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
1593   GtkAdjustment *adjustment = NULL;
1594
1595   switch (scroll)
1596     {
1597     case GTK_SCROLL_STEP_UP:
1598       scroll = GTK_SCROLL_STEP_BACKWARD;
1599       horizontal = FALSE;
1600       break;
1601     case GTK_SCROLL_STEP_DOWN:
1602       scroll = GTK_SCROLL_STEP_FORWARD;
1603       horizontal = FALSE;
1604       break;
1605     case GTK_SCROLL_STEP_LEFT:
1606       scroll = GTK_SCROLL_STEP_BACKWARD;
1607       horizontal = TRUE;
1608       break;
1609     case GTK_SCROLL_STEP_RIGHT:
1610       scroll = GTK_SCROLL_STEP_FORWARD;
1611       horizontal = TRUE;
1612       break;
1613     case GTK_SCROLL_PAGE_UP:
1614       scroll = GTK_SCROLL_PAGE_BACKWARD;
1615       horizontal = FALSE;
1616       break;
1617     case GTK_SCROLL_PAGE_DOWN:
1618       scroll = GTK_SCROLL_PAGE_FORWARD;
1619       horizontal = FALSE;
1620       break;
1621     case GTK_SCROLL_PAGE_LEFT:
1622       scroll = GTK_SCROLL_STEP_BACKWARD;
1623       horizontal = TRUE;
1624       break;
1625     case GTK_SCROLL_PAGE_RIGHT:
1626       scroll = GTK_SCROLL_STEP_FORWARD;
1627       horizontal = TRUE;
1628       break;
1629     case GTK_SCROLL_STEP_BACKWARD:
1630     case GTK_SCROLL_STEP_FORWARD:
1631     case GTK_SCROLL_PAGE_BACKWARD:
1632     case GTK_SCROLL_PAGE_FORWARD:
1633     case GTK_SCROLL_START:
1634     case GTK_SCROLL_END:
1635       break;
1636     default:
1637       g_warning ("Invalid scroll type %u for GtkScrolledWindow::scroll-child", scroll);
1638       return FALSE;
1639     }
1640
1641   if ((horizontal && (!priv->hscrollbar || !priv->hscrollbar_visible)) ||
1642       (!horizontal && (!priv->vscrollbar || !priv->vscrollbar_visible)))
1643     return FALSE;
1644
1645   if (horizontal)
1646     {
1647       if (priv->hscrollbar)
1648         adjustment = gtk_range_get_adjustment (GTK_RANGE (priv->hscrollbar));
1649     }
1650   else
1651     {
1652       if (priv->vscrollbar)
1653         adjustment = gtk_range_get_adjustment (GTK_RANGE (priv->vscrollbar));
1654     }
1655
1656   if (adjustment)
1657     {
1658       gdouble value = gtk_adjustment_get_value (adjustment);
1659
1660       switch (scroll)
1661         {
1662         case GTK_SCROLL_STEP_FORWARD:
1663           value += gtk_adjustment_get_step_increment (adjustment);
1664           break;
1665         case GTK_SCROLL_STEP_BACKWARD:
1666           value -= gtk_adjustment_get_step_increment (adjustment);
1667           break;
1668         case GTK_SCROLL_PAGE_FORWARD:
1669           value += gtk_adjustment_get_page_increment (adjustment);
1670           break;
1671         case GTK_SCROLL_PAGE_BACKWARD:
1672           value -= gtk_adjustment_get_page_increment (adjustment);
1673           break;
1674         case GTK_SCROLL_START:
1675           value = gtk_adjustment_get_lower (adjustment);
1676           break;
1677         case GTK_SCROLL_END:
1678           value = gtk_adjustment_get_upper (adjustment);
1679           break;
1680         default:
1681           g_assert_not_reached ();
1682           break;
1683         }
1684
1685       gtk_adjustment_set_value (adjustment, value);
1686
1687       return TRUE;
1688     }
1689
1690   return FALSE;
1691 }
1692
1693 static void
1694 gtk_scrolled_window_move_focus_out (GtkScrolledWindow *scrolled_window,
1695                                     GtkDirectionType   direction_type)
1696 {
1697   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
1698   GtkWidget *toplevel;
1699
1700   /* Focus out of the scrolled window entirely. We do this by setting
1701    * a flag, then propagating the focus motion to the notebook.
1702    */
1703   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (scrolled_window));
1704   if (!gtk_widget_is_toplevel (toplevel))
1705     return;
1706
1707   g_object_ref (scrolled_window);
1708
1709   priv->focus_out = TRUE;
1710   g_signal_emit_by_name (toplevel, "move-focus", direction_type);
1711   priv->focus_out = FALSE;
1712
1713   g_object_unref (scrolled_window);
1714 }
1715
1716 static void
1717 gtk_scrolled_window_relative_allocation (GtkWidget     *widget,
1718                                          GtkAllocation *allocation)
1719 {
1720   GtkAllocation widget_allocation;
1721   GtkScrolledWindow *scrolled_window;
1722   GtkScrolledWindowPrivate *priv;
1723   gint sb_spacing;
1724   gint sb_width;
1725   gint sb_height;
1726
1727   g_return_if_fail (widget != NULL);
1728   g_return_if_fail (allocation != NULL);
1729
1730   scrolled_window = GTK_SCROLLED_WINDOW (widget);
1731   priv = scrolled_window->priv;
1732
1733   /* Get possible scrollbar dimensions */
1734   sb_spacing = _gtk_scrolled_window_get_scrollbar_spacing (scrolled_window);
1735   gtk_widget_get_preferred_height (priv->hscrollbar, &sb_height, NULL);
1736   gtk_widget_get_preferred_width (priv->vscrollbar, &sb_width, NULL);
1737
1738   /* Subtract some things from our available allocation size */
1739   allocation->x = 0;
1740   allocation->y = 0;
1741
1742   if (priv->shadow_type != GTK_SHADOW_NONE)
1743     {
1744       GtkStyleContext *context;
1745       GtkStateFlags state;
1746       GtkBorder padding, border;
1747
1748       context = gtk_widget_get_style_context (widget);
1749       state = gtk_widget_get_state_flags (widget);
1750
1751       gtk_style_context_save (context);
1752       gtk_style_context_add_class (context, GTK_STYLE_CLASS_FRAME);
1753
1754       gtk_style_context_get_border (context, state, &border);
1755       gtk_style_context_get_padding (context, state, &padding);
1756
1757       allocation->x += padding.left + border.left;
1758       allocation->y += padding.top + border.top;
1759
1760       gtk_style_context_restore (context);
1761     }
1762
1763   gtk_widget_get_allocation (widget, &widget_allocation);
1764   allocation->width = MAX (1, (gint) widget_allocation.width - allocation->x * 2);
1765   allocation->height = MAX (1, (gint) widget_allocation.height - allocation->y * 2);
1766
1767   if (priv->vscrollbar_visible)
1768     {
1769       gboolean is_rtl;
1770
1771       is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
1772
1773       if ((!is_rtl &&
1774            (priv->real_window_placement == GTK_CORNER_TOP_RIGHT ||
1775             priv->real_window_placement == GTK_CORNER_BOTTOM_RIGHT)) ||
1776           (is_rtl &&
1777            (priv->real_window_placement == GTK_CORNER_TOP_LEFT ||
1778             priv->real_window_placement == GTK_CORNER_BOTTOM_LEFT)))
1779         allocation->x += (sb_width +  sb_spacing);
1780
1781       allocation->width = MAX (1, allocation->width - (sb_width + sb_spacing));
1782     }
1783   if (priv->hscrollbar_visible)
1784     {
1785
1786       if (priv->real_window_placement == GTK_CORNER_BOTTOM_LEFT ||
1787           priv->real_window_placement == GTK_CORNER_BOTTOM_RIGHT)
1788         allocation->y += (sb_height + sb_spacing);
1789
1790       allocation->height = MAX (1, allocation->height - (sb_height + sb_spacing));
1791     }
1792 }
1793
1794 static gboolean
1795 _gtk_scrolled_window_get_overshoot (GtkScrolledWindow *scrolled_window,
1796                                     gint              *overshoot_x,
1797                                     gint              *overshoot_y)
1798 {
1799   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
1800   GtkAdjustment *vadjustment, *hadjustment;
1801   gdouble lower, upper, x, y;
1802
1803   /* Vertical overshoot */
1804   vadjustment = gtk_range_get_adjustment (GTK_RANGE (priv->vscrollbar));
1805   lower = gtk_adjustment_get_lower (vadjustment);
1806   upper = gtk_adjustment_get_upper (vadjustment) -
1807     gtk_adjustment_get_page_size (vadjustment);
1808
1809   if (priv->unclamped_vadj_value < lower)
1810     y = priv->unclamped_vadj_value - lower;
1811   else if (priv->unclamped_vadj_value > upper)
1812     y = priv->unclamped_vadj_value - upper;
1813   else
1814     y = 0;
1815
1816   /* Horizontal overshoot */
1817   hadjustment = gtk_range_get_adjustment (GTK_RANGE (priv->hscrollbar));
1818   lower = gtk_adjustment_get_lower (hadjustment);
1819   upper = gtk_adjustment_get_upper (hadjustment) -
1820     gtk_adjustment_get_page_size (hadjustment);
1821
1822   if (priv->unclamped_hadj_value < lower)
1823     x = priv->unclamped_hadj_value - lower;
1824   else if (priv->unclamped_hadj_value > upper)
1825     x = priv->unclamped_hadj_value - upper;
1826   else
1827     x = 0;
1828
1829   if (overshoot_x)
1830     *overshoot_x = x;
1831
1832   if (overshoot_y)
1833     *overshoot_y = y;
1834
1835   return (x != 0 || y != 0);
1836 }
1837
1838 static void
1839 _gtk_scrolled_window_allocate_overshoot_window (GtkScrolledWindow *scrolled_window)
1840 {
1841   GtkAllocation window_allocation, relative_allocation, allocation;
1842   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
1843   GtkWidget *widget = GTK_WIDGET (scrolled_window);
1844   gint overshoot_x, overshoot_y;
1845
1846   if (!gtk_widget_get_realized (widget))
1847     return;
1848
1849   gtk_widget_get_allocation (widget, &allocation);
1850   gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
1851   _gtk_scrolled_window_get_overshoot (scrolled_window,
1852                                       &overshoot_x, &overshoot_y);
1853
1854   window_allocation = relative_allocation;
1855   window_allocation.x += allocation.x;
1856   window_allocation.y += allocation.y;
1857
1858   /* Handle displacement to the left/top by moving the overshoot
1859    * window, overshooting to the bottom/right is handled in
1860    * gtk_scrolled_window_allocate_child()
1861    */
1862   if (overshoot_x < 0)
1863     window_allocation.x += -overshoot_x;
1864
1865   if (overshoot_y < 0)
1866     window_allocation.y += -overshoot_y;
1867
1868   window_allocation.width -= ABS (overshoot_x);
1869   window_allocation.height -= ABS (overshoot_y);
1870
1871   gdk_window_move_resize (priv->overshoot_window,
1872                           window_allocation.x, window_allocation.y,
1873                           window_allocation.width, window_allocation.height);
1874 }
1875
1876 static void
1877 gtk_scrolled_window_allocate_child (GtkScrolledWindow *swindow,
1878                                     GtkAllocation     *relative_allocation)
1879 {
1880   GtkWidget     *widget = GTK_WIDGET (swindow), *child;
1881   GtkAllocation  allocation;
1882   GtkAllocation  child_allocation;
1883   gint           overshoot_x, overshoot_y;
1884
1885   child = gtk_bin_get_child (GTK_BIN (widget));
1886
1887   gtk_widget_get_allocation (widget, &allocation);
1888
1889   gtk_scrolled_window_relative_allocation (widget, relative_allocation);
1890   _gtk_scrolled_window_get_overshoot (swindow, &overshoot_x, &overshoot_y);
1891
1892   /* Handle overshooting to the right/bottom by relocating the
1893    * widget allocation to negative coordinates, so these edges
1894    * stick to the overshoot window border.
1895    */
1896   if (overshoot_x > 0)
1897     child_allocation.x = -overshoot_x;
1898   else
1899     child_allocation.x = 0;
1900
1901   if (overshoot_y > 0)
1902     child_allocation.y = -overshoot_y;
1903   else
1904     child_allocation.y = 0;
1905
1906   child_allocation.width = relative_allocation->width;
1907   child_allocation.height = relative_allocation->height;
1908
1909   gtk_widget_size_allocate (child, &child_allocation);
1910 }
1911
1912 static void
1913 gtk_scrolled_window_size_allocate (GtkWidget     *widget,
1914                                    GtkAllocation *allocation)
1915 {
1916   GtkScrolledWindow *scrolled_window;
1917   GtkScrolledWindowPrivate *priv;
1918   GtkStyleContext *context;
1919   GtkStateFlags state;
1920   GtkBorder padding, border;
1921   GtkBin *bin;
1922   GtkAllocation relative_allocation;
1923   GtkAllocation child_allocation;
1924   GtkWidget *child;
1925   gboolean scrollbars_within_bevel;
1926   gint sb_spacing;
1927   gint sb_width;
1928   gint sb_height;
1929
1930   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
1931   g_return_if_fail (allocation != NULL);
1932
1933   scrolled_window = GTK_SCROLLED_WINDOW (widget);
1934   bin = GTK_BIN (scrolled_window);
1935   priv = scrolled_window->priv;
1936
1937   /* Get possible scrollbar dimensions */
1938   sb_spacing = _gtk_scrolled_window_get_scrollbar_spacing (scrolled_window);
1939   gtk_widget_get_preferred_height (priv->hscrollbar, &sb_height, NULL);
1940   gtk_widget_get_preferred_width (priv->vscrollbar, &sb_width, NULL);
1941
1942   context = gtk_widget_get_style_context (widget);
1943   state = gtk_widget_get_state_flags (widget);
1944
1945   gtk_style_context_save (context);
1946   gtk_style_context_add_class (context, GTK_STYLE_CLASS_FRAME);
1947
1948   gtk_style_context_get_padding (context, state, &padding);
1949   gtk_style_context_get_border (context, state, &border);
1950
1951   gtk_widget_style_get (widget, "scrollbars-within-bevel", &scrollbars_within_bevel, NULL);
1952
1953   gtk_widget_set_allocation (widget, allocation);
1954   gtk_style_context_restore (context);
1955
1956   if (priv->hscrollbar_policy == GTK_POLICY_ALWAYS)
1957     priv->hscrollbar_visible = TRUE;
1958   else if (priv->hscrollbar_policy == GTK_POLICY_NEVER)
1959     priv->hscrollbar_visible = FALSE;
1960   if (priv->vscrollbar_policy == GTK_POLICY_ALWAYS)
1961     priv->vscrollbar_visible = TRUE;
1962   else if (priv->vscrollbar_policy == GTK_POLICY_NEVER)
1963     priv->vscrollbar_visible = FALSE;
1964
1965   child = gtk_bin_get_child (bin);
1966   if (child && gtk_widget_get_visible (child))
1967     {
1968       gint child_scroll_width;
1969       gint child_scroll_height;
1970       gboolean previous_hvis;
1971       gboolean previous_vvis;
1972       guint count = 0;
1973
1974       /* Determine scrollbar visibility first via hfw apis */
1975       if (gtk_widget_get_request_mode (child) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
1976         {
1977           if (gtk_scrollable_get_hscroll_policy (GTK_SCROLLABLE (child)) == GTK_SCROLL_MINIMUM)
1978             gtk_widget_get_preferred_width (child, &child_scroll_width, NULL);
1979           else
1980             gtk_widget_get_preferred_width (child, NULL, &child_scroll_width);
1981
1982           if (priv->vscrollbar_policy == GTK_POLICY_AUTOMATIC)
1983             {
1984               /* First try without a vertical scrollbar if the content will fit the height
1985                * given the extra width of the scrollbar */
1986               if (gtk_scrollable_get_vscroll_policy (GTK_SCROLLABLE (child)) == GTK_SCROLL_MINIMUM)
1987                 gtk_widget_get_preferred_height_for_width (child,
1988                                                            MAX (allocation->width, child_scroll_width),
1989                                                            &child_scroll_height, NULL);
1990               else
1991                 gtk_widget_get_preferred_height_for_width (child,
1992                                                            MAX (allocation->width, child_scroll_width),
1993                                                            NULL, &child_scroll_height);
1994
1995               if (priv->hscrollbar_policy == GTK_POLICY_AUTOMATIC)
1996                 {
1997                   /* Does the content height fit the allocation height ? */
1998                   priv->vscrollbar_visible = child_scroll_height > allocation->height;
1999
2000                   /* Does the content width fit the allocation with minus a possible scrollbar ? */
2001                   priv->hscrollbar_visible =
2002                     child_scroll_width > allocation->width -
2003                     (priv->vscrollbar_visible ? sb_width + sb_spacing : 0);
2004
2005                   /* Now that we've guessed the hscrollbar, does the content height fit
2006                    * the possible new allocation height ? */
2007                   priv->vscrollbar_visible =
2008                     child_scroll_height > allocation->height -
2009                     (priv->hscrollbar_visible ? sb_height + sb_spacing : 0);
2010
2011                   /* Now that we've guessed the vscrollbar, does the content width fit
2012                    * the possible new allocation width ? */
2013                   priv->hscrollbar_visible =
2014                     child_scroll_width > allocation->width -
2015                     (priv->vscrollbar_visible ? sb_width + sb_spacing : 0);
2016                 }
2017               else /* priv->hscrollbar_policy != GTK_POLICY_AUTOMATIC */
2018                 {
2019                   priv->hscrollbar_visible = priv->hscrollbar_policy != GTK_POLICY_NEVER;
2020                   priv->vscrollbar_visible = child_scroll_height > allocation->height -
2021                     (priv->hscrollbar_visible ? sb_height + sb_spacing : 0);
2022                 }
2023             }
2024           else /* priv->vscrollbar_policy != GTK_POLICY_AUTOMATIC */
2025             {
2026               priv->vscrollbar_visible = priv->vscrollbar_policy != GTK_POLICY_NEVER;
2027
2028               if (priv->hscrollbar_policy == GTK_POLICY_AUTOMATIC)
2029                 priv->hscrollbar_visible =
2030                   child_scroll_width > allocation->width -
2031                   (priv->vscrollbar_visible ? 0 : sb_width + sb_spacing);
2032               else
2033                 priv->hscrollbar_visible = priv->hscrollbar_policy != GTK_POLICY_NEVER;
2034             }
2035         }
2036       else /* GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT */
2037         {
2038           if (gtk_scrollable_get_vscroll_policy (GTK_SCROLLABLE (child)) == GTK_SCROLL_MINIMUM)
2039             gtk_widget_get_preferred_height (child, &child_scroll_height, NULL);
2040           else
2041             gtk_widget_get_preferred_height (child, NULL, &child_scroll_height);
2042
2043           if (priv->hscrollbar_policy == GTK_POLICY_AUTOMATIC)
2044             {
2045               /* First try without a horizontal scrollbar if the content will fit the width
2046                * given the extra height of the scrollbar */
2047               if (gtk_scrollable_get_hscroll_policy (GTK_SCROLLABLE (child)) == GTK_SCROLL_MINIMUM)
2048                 gtk_widget_get_preferred_width_for_height (child,
2049                                                            MAX (allocation->height, child_scroll_height),
2050                                                            &child_scroll_width, NULL);
2051               else
2052                 gtk_widget_get_preferred_width_for_height (child,
2053                                                            MAX (allocation->height, child_scroll_height),
2054                                                            NULL, &child_scroll_width);
2055
2056               if (priv->vscrollbar_policy == GTK_POLICY_AUTOMATIC)
2057                 {
2058                   /* Does the content width fit the allocation width ? */
2059                   priv->hscrollbar_visible = child_scroll_width > allocation->width;
2060
2061                   /* Does the content height fit the allocation with minus a possible scrollbar ? */
2062                   priv->vscrollbar_visible =
2063                     child_scroll_height > allocation->height -
2064                     (priv->hscrollbar_visible ? sb_height + sb_spacing : 0);
2065
2066                   /* Now that we've guessed the vscrollbar, does the content width fit
2067                    * the possible new allocation width ? */
2068                   priv->hscrollbar_visible =
2069                     child_scroll_width > allocation->width -
2070                     (priv->vscrollbar_visible ? sb_width + sb_spacing : 0);
2071
2072                   /* Now that we've guessed the hscrollbar, does the content height fit
2073                    * the possible new allocation height ? */
2074                   priv->vscrollbar_visible =
2075                     child_scroll_height > allocation->height -
2076                     (priv->hscrollbar_visible ? sb_height + sb_spacing : 0);
2077                 }
2078               else /* priv->vscrollbar_policy != GTK_POLICY_AUTOMATIC */
2079                 {
2080                   priv->vscrollbar_visible = priv->vscrollbar_policy != GTK_POLICY_NEVER;
2081                   priv->hscrollbar_visible = child_scroll_width > allocation->width -
2082                     (priv->vscrollbar_visible ? sb_width + sb_spacing : 0);
2083                 }
2084             }
2085           else /* priv->hscrollbar_policy != GTK_POLICY_AUTOMATIC */
2086             {
2087               priv->hscrollbar_visible = priv->hscrollbar_policy != GTK_POLICY_NEVER;
2088
2089               if (priv->vscrollbar_policy == GTK_POLICY_AUTOMATIC)
2090                 priv->vscrollbar_visible =
2091                   child_scroll_height > allocation->height -
2092                   (priv->hscrollbar_visible ? 0 : sb_height + sb_spacing);
2093               else
2094                 priv->vscrollbar_visible = priv->vscrollbar_policy != GTK_POLICY_NEVER;
2095             }
2096         }
2097
2098       /* Now after guessing scrollbar visibility; fall back on the allocation loop which
2099        * observes the adjustments to detect scrollbar visibility and also avoids
2100        * infinite recursion
2101        */
2102       do
2103         {
2104           previous_hvis = priv->hscrollbar_visible;
2105           previous_vvis = priv->vscrollbar_visible;
2106           gtk_scrolled_window_allocate_child (scrolled_window, &relative_allocation);
2107
2108           /* Explicitly force scrollbar visibility checks.
2109            *
2110            * Since we make a guess above, the child might not decide to update the adjustments
2111            * if they logically did not change since the last configuration
2112            */
2113           if (priv->hscrollbar)
2114             gtk_scrolled_window_adjustment_changed
2115               (gtk_range_get_adjustment (GTK_RANGE (priv->hscrollbar)), scrolled_window);
2116
2117           if (priv->vscrollbar)
2118             gtk_scrolled_window_adjustment_changed
2119               (gtk_range_get_adjustment (GTK_RANGE (priv->vscrollbar)), scrolled_window);
2120
2121           /* If, after the first iteration, the hscrollbar and the
2122            * vscrollbar flip visiblity... or if one of the scrollbars flip
2123            * on each itteration indefinitly/infinitely, then we just need both
2124            * at this size.
2125            */
2126           if ((count &&
2127                previous_hvis != priv->hscrollbar_visible &&
2128                previous_vvis != priv->vscrollbar_visible) || count > 3)
2129             {
2130               priv->hscrollbar_visible = TRUE;
2131               priv->vscrollbar_visible = TRUE;
2132
2133               gtk_scrolled_window_allocate_child (scrolled_window, &relative_allocation);
2134
2135               break;
2136             }
2137
2138           count++;
2139         }
2140       while (previous_hvis != priv->hscrollbar_visible ||
2141              previous_vvis != priv->vscrollbar_visible);
2142     }
2143   else
2144     {
2145       priv->hscrollbar_visible = priv->hscrollbar_policy == GTK_POLICY_ALWAYS;
2146       priv->vscrollbar_visible = priv->vscrollbar_policy == GTK_POLICY_ALWAYS;
2147       gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
2148     }
2149
2150   if (priv->hscrollbar_visible)
2151     {
2152       if (!gtk_widget_get_visible (priv->hscrollbar))
2153         gtk_widget_show (priv->hscrollbar);
2154
2155       child_allocation.x = relative_allocation.x;
2156       if (priv->real_window_placement == GTK_CORNER_TOP_LEFT ||
2157           priv->real_window_placement == GTK_CORNER_TOP_RIGHT)
2158         child_allocation.y = (relative_allocation.y +
2159                               relative_allocation.height +
2160                               sb_spacing +
2161                               (priv->shadow_type == GTK_SHADOW_NONE ?
2162                                0 : padding.top + border.top));
2163       else
2164         child_allocation.y = 0;
2165
2166       child_allocation.width = relative_allocation.width;
2167       child_allocation.height = sb_height;
2168       child_allocation.x += allocation->x;
2169       child_allocation.y += allocation->y;
2170
2171       if (priv->shadow_type != GTK_SHADOW_NONE)
2172         {
2173           if (!scrollbars_within_bevel)
2174             {
2175               child_allocation.x -= padding.left + border.left;
2176               child_allocation.width += padding.left + padding.right + border.left + border.right;
2177             }
2178           else if (GTK_CORNER_TOP_RIGHT == priv->real_window_placement ||
2179                    GTK_CORNER_TOP_LEFT == priv->real_window_placement)
2180             {
2181               child_allocation.y -= padding.top + border.top;
2182             }
2183           else
2184             {
2185               child_allocation.y += padding.top + border.top;
2186             }
2187         }
2188
2189       gtk_widget_size_allocate (priv->hscrollbar, &child_allocation);
2190     }
2191   else if (gtk_widget_get_visible (priv->hscrollbar))
2192     gtk_widget_hide (priv->hscrollbar);
2193
2194   if (priv->vscrollbar_visible)
2195     {
2196       if (!gtk_widget_get_visible (priv->vscrollbar))
2197         gtk_widget_show (priv->vscrollbar);
2198
2199       if ((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL &&
2200            (priv->real_window_placement == GTK_CORNER_TOP_RIGHT ||
2201             priv->real_window_placement == GTK_CORNER_BOTTOM_RIGHT)) ||
2202           (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR &&
2203            (priv->real_window_placement == GTK_CORNER_TOP_LEFT ||
2204             priv->real_window_placement == GTK_CORNER_BOTTOM_LEFT)))
2205         child_allocation.x = (relative_allocation.x +
2206                               relative_allocation.width +
2207                               sb_spacing +
2208                               (priv->shadow_type == GTK_SHADOW_NONE ?
2209                                0 : padding.left + border.left));
2210       else
2211         child_allocation.x = 0;
2212
2213       child_allocation.y = relative_allocation.y;
2214       child_allocation.width = sb_width;
2215       child_allocation.height = relative_allocation.height;
2216       child_allocation.x += allocation->x;
2217       child_allocation.y += allocation->y;
2218
2219       if (priv->shadow_type != GTK_SHADOW_NONE)
2220         {
2221           if (!scrollbars_within_bevel)
2222             {
2223               child_allocation.y -= padding.top + border.top;
2224               child_allocation.height += padding.top + padding.bottom + border.top + border.bottom;
2225             }
2226           else if (GTK_CORNER_BOTTOM_LEFT == priv->real_window_placement ||
2227                    GTK_CORNER_TOP_LEFT == priv->real_window_placement)
2228             {
2229               child_allocation.x -= padding.left + border.left;
2230             }
2231           else
2232             {
2233               child_allocation.x += padding.left + border.left;
2234             }
2235         }
2236
2237       gtk_widget_size_allocate (priv->vscrollbar, &child_allocation);
2238     }
2239   else if (gtk_widget_get_visible (priv->vscrollbar))
2240     gtk_widget_hide (priv->vscrollbar);
2241
2242   _gtk_scrolled_window_allocate_overshoot_window (scrolled_window);
2243 }
2244
2245 static gboolean
2246 gtk_scrolled_window_scroll_event (GtkWidget      *widget,
2247                                   GdkEventScroll *event)
2248 {
2249   GtkScrolledWindowPrivate *priv;
2250   GtkScrolledWindow *scrolled_window;
2251   gboolean handled = FALSE;
2252   gdouble delta_x;
2253   gdouble delta_y;
2254
2255   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (widget), FALSE);
2256   g_return_val_if_fail (event != NULL, FALSE);
2257
2258   scrolled_window = GTK_SCROLLED_WINDOW (widget);
2259   priv = scrolled_window->priv;
2260
2261   if (gdk_event_get_scroll_deltas ((GdkEvent *) event, &delta_x, &delta_y))
2262     {
2263       if (delta_x != 0.0 && priv->hscrollbar &&
2264           gtk_widget_get_visible (priv->hscrollbar))
2265         {
2266           GtkAdjustment *adj;
2267           gdouble new_value;
2268
2269           adj = gtk_range_get_adjustment (GTK_RANGE (priv->hscrollbar));
2270
2271           new_value = CLAMP (gtk_adjustment_get_value (adj) + delta_x,
2272                              gtk_adjustment_get_lower (adj),
2273                              gtk_adjustment_get_upper (adj) -
2274                              gtk_adjustment_get_page_size (adj));
2275
2276           gtk_adjustment_set_value (adj, new_value);
2277
2278           handled = TRUE;
2279         }
2280
2281       if (delta_y != 0.0 && priv->vscrollbar &&
2282           gtk_widget_get_visible (priv->vscrollbar))
2283         {
2284           GtkAdjustment *adj;
2285           gdouble new_value;
2286
2287           adj = gtk_range_get_adjustment (GTK_RANGE (priv->vscrollbar));
2288
2289           new_value = CLAMP (gtk_adjustment_get_value (adj) + delta_y,
2290                              gtk_adjustment_get_lower (adj),
2291                              gtk_adjustment_get_upper (adj) -
2292                              gtk_adjustment_get_page_size (adj));
2293
2294           gtk_adjustment_set_value (adj, new_value);
2295
2296           handled = TRUE;
2297         }
2298     }
2299   else
2300     {
2301       GtkWidget *range;
2302
2303       if (event->direction == GDK_SCROLL_UP || event->direction == GDK_SCROLL_DOWN)
2304         range = priv->vscrollbar;
2305       else
2306         range = priv->hscrollbar;
2307
2308       if (range && gtk_widget_get_visible (range))
2309         {
2310           GtkAdjustment *adj = gtk_range_get_adjustment (GTK_RANGE (range));
2311           gdouble delta, new_value;
2312
2313           delta = _gtk_range_get_wheel_delta (GTK_RANGE (range), event);
2314
2315           new_value = CLAMP (gtk_adjustment_get_value (adj) + delta,
2316                              gtk_adjustment_get_lower (adj),
2317                              gtk_adjustment_get_upper (adj) -
2318                              gtk_adjustment_get_page_size (adj));
2319
2320           gtk_adjustment_set_value (adj, new_value);
2321
2322           handled = TRUE;
2323         }
2324     }
2325
2326   return handled;
2327 }
2328
2329 static gboolean
2330 _gtk_scrolled_window_set_adjustment_value (GtkScrolledWindow *scrolled_window,
2331                                            GtkAdjustment     *adjustment,
2332                                            gdouble            value,
2333                                            gboolean           allow_overshooting,
2334                                            gboolean           snap_to_border)
2335 {
2336   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
2337   gdouble lower, upper, *prev_value;
2338
2339   lower = gtk_adjustment_get_lower (adjustment);
2340   upper = gtk_adjustment_get_upper (adjustment) -
2341     gtk_adjustment_get_page_size (adjustment);
2342
2343   if (adjustment == gtk_range_get_adjustment (GTK_RANGE (priv->hscrollbar)))
2344     prev_value = &priv->unclamped_hadj_value;
2345   else if (adjustment == gtk_range_get_adjustment (GTK_RANGE (priv->vscrollbar)))
2346     prev_value = &priv->unclamped_vadj_value;
2347   else
2348     return FALSE;
2349
2350   if (snap_to_border)
2351     {
2352       if (*prev_value < 0 && value > 0)
2353         value = 0;
2354       else if (*prev_value > upper && value < upper)
2355         value = upper;
2356     }
2357
2358   if (allow_overshooting)
2359     {
2360       lower -= MAX_OVERSHOOT_DISTANCE;
2361       upper += MAX_OVERSHOOT_DISTANCE;
2362     }
2363
2364   *prev_value = CLAMP (value, lower, upper);
2365   gtk_adjustment_set_value (adjustment, value);
2366
2367   return (*prev_value != value);
2368 }
2369
2370 static gboolean
2371 scrolled_window_deceleration_cb (gpointer user_data)
2372 {
2373   KineticScrollData *data = user_data;
2374   GtkScrolledWindow *scrolled_window = data->scrolled_window;
2375   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
2376   GtkAdjustment *hadjustment, *vadjustment;
2377   gint old_overshoot_x, old_overshoot_y, overshoot_x, overshoot_y;
2378   gdouble value;
2379   gint64 current_time;
2380   guint elapsed;
2381
2382   hadjustment = gtk_range_get_adjustment (GTK_RANGE (priv->hscrollbar));
2383   vadjustment = gtk_range_get_adjustment (GTK_RANGE (priv->vscrollbar));
2384
2385   _gtk_scrolled_window_get_overshoot (scrolled_window,
2386                                       &old_overshoot_x, &old_overshoot_y);
2387
2388   current_time = g_get_monotonic_time ();
2389   elapsed = (current_time - data->last_deceleration_time) / 1000;
2390   data->last_deceleration_time = current_time;
2391
2392   if (hadjustment && priv->hscrollbar_visible)
2393     {
2394       value = priv->unclamped_hadj_value + (data->x_velocity * elapsed);
2395
2396       if (_gtk_scrolled_window_set_adjustment_value (scrolled_window,
2397                                                      hadjustment,
2398                                                      value, TRUE, TRUE))
2399         data->x_velocity = 0;
2400     }
2401   else
2402     data->x_velocity = 0;
2403
2404   if (vadjustment && priv->vscrollbar_visible)
2405     {
2406       value = priv->unclamped_vadj_value + (data->y_velocity * elapsed);
2407
2408       if (_gtk_scrolled_window_set_adjustment_value (scrolled_window,
2409                                                      vadjustment,
2410                                                      value, TRUE, TRUE))
2411         data->y_velocity = 0;
2412     }
2413   else
2414     data->y_velocity = 0;
2415
2416   _gtk_scrolled_window_get_overshoot (scrolled_window,
2417                                       &overshoot_x, &overshoot_y);
2418
2419   if (overshoot_x == 0)
2420     {
2421       if (old_overshoot_x != 0)
2422         {
2423           /* Overshooting finished snapping back */
2424           data->x_velocity = 0;
2425         }
2426       else if (data->x_velocity > 0)
2427         {
2428           data->x_velocity -= FRICTION_DECELERATION * elapsed * data->vel_sine;
2429           data->x_velocity = MAX (0, data->x_velocity);
2430         }
2431       else if (data->x_velocity < 0)
2432         {
2433           data->x_velocity += FRICTION_DECELERATION * elapsed * data->vel_sine;
2434           data->x_velocity = MIN (0, data->x_velocity);
2435         }
2436     }
2437   else if (overshoot_x < 0)
2438     data->x_velocity += OVERSHOOT_INVERSE_ACCELERATION * elapsed;
2439   else if (overshoot_x > 0)
2440     data->x_velocity -= OVERSHOOT_INVERSE_ACCELERATION * elapsed;
2441
2442   if (overshoot_y == 0)
2443     {
2444       if (old_overshoot_y != 0)
2445         {
2446           /* Overshooting finished snapping back */
2447           data->y_velocity = 0;
2448         }
2449       else if (data->y_velocity > 0)
2450         {
2451           data->y_velocity -= FRICTION_DECELERATION * elapsed * data->vel_cosine;
2452           data->y_velocity = MAX (0, data->y_velocity);
2453         }
2454       else if (data->y_velocity < 0)
2455         {
2456           data->y_velocity += FRICTION_DECELERATION * elapsed * data->vel_cosine;
2457           data->y_velocity = MIN (0, data->y_velocity);
2458         }
2459     }
2460   else if (overshoot_y < 0)
2461     data->y_velocity += OVERSHOOT_INVERSE_ACCELERATION * elapsed;
2462   else if (overshoot_y > 0)
2463     data->y_velocity -= OVERSHOOT_INVERSE_ACCELERATION * elapsed;
2464
2465   if (old_overshoot_x != overshoot_x ||
2466       old_overshoot_y != overshoot_y)
2467     {
2468       if (overshoot_x >= 0 || overshoot_y >= 0)
2469         {
2470           /* We need to reallocate the widget to have it at
2471            * negative offset, so there's a "gravity" on the
2472            * bottom/right corner
2473            */
2474           gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
2475         }
2476       else if (overshoot_x < 0 || overshoot_y < 0)
2477         _gtk_scrolled_window_allocate_overshoot_window (scrolled_window);
2478     }
2479
2480   if (overshoot_x != 0 || overshoot_y != 0 ||
2481       data->x_velocity != 0 || data->y_velocity != 0)
2482     return TRUE;
2483   else
2484     {
2485       priv->deceleration_id = 0;
2486       return FALSE;
2487     }
2488 }
2489
2490 static void
2491 gtk_scrolled_window_cancel_deceleration (GtkScrolledWindow *scrolled_window)
2492 {
2493   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
2494
2495   if (priv->deceleration_id)
2496     {
2497       g_source_remove (priv->deceleration_id);
2498       priv->deceleration_id = 0;
2499     }
2500 }
2501
2502 static void
2503 gtk_scrolled_window_start_deceleration (GtkScrolledWindow *scrolled_window)
2504 {
2505   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
2506   KineticScrollData *data;
2507   gdouble angle;
2508
2509   data = g_new0 (KineticScrollData, 1);
2510   data->scrolled_window = scrolled_window;
2511   data->last_deceleration_time = g_get_monotonic_time ();
2512   data->x_velocity = priv->x_velocity;
2513   data->y_velocity = priv->y_velocity;
2514
2515   /* We use sine/cosine as a factor to deceleration x/y components
2516    * of the vector, so we care about the sign later.
2517    */
2518   angle = atan2 (ABS (data->x_velocity), ABS (data->y_velocity));
2519   data->vel_cosine = cos (angle);
2520   data->vel_sine = sin (angle);
2521
2522   scrolled_window->priv->deceleration_id =
2523     gdk_threads_add_timeout_full (G_PRIORITY_DEFAULT,
2524                                   FRAME_INTERVAL,
2525                                   scrolled_window_deceleration_cb,
2526                                   data, (GDestroyNotify) g_free);
2527 }
2528
2529 static gboolean
2530 gtk_scrolled_window_release_captured_event (GtkScrolledWindow *scrolled_window)
2531 {
2532   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
2533
2534   /* Cancel the scrolling and send the button press
2535    * event to the child widget
2536    */
2537   if (!priv->button_press_event)
2538     return FALSE;
2539
2540   if (priv->drag_device)
2541     {
2542       gtk_device_grab_remove (GTK_WIDGET (scrolled_window), priv->drag_device);
2543       priv->drag_device = NULL;
2544     }
2545
2546   if (priv->capture_button_press)
2547     {
2548       GtkWidget *event_widget;
2549
2550       event_widget = gtk_get_event_widget (priv->button_press_event);
2551
2552       if (!_gtk_propagate_captured_event (event_widget,
2553                                           priv->button_press_event,
2554                                           gtk_bin_get_child (GTK_BIN (scrolled_window))))
2555         gtk_propagate_event (event_widget, priv->button_press_event);
2556
2557       gdk_event_free (priv->button_press_event);
2558       priv->button_press_event = NULL;
2559     }
2560
2561   if (_gtk_scrolled_window_get_overshoot (scrolled_window, NULL, NULL))
2562     gtk_scrolled_window_start_deceleration (scrolled_window);
2563
2564   return FALSE;
2565 }
2566
2567 static gboolean
2568 gtk_scrolled_window_calculate_velocity (GtkScrolledWindow *scrolled_window,
2569                                         GdkEvent          *event)
2570 {
2571   GtkScrolledWindowPrivate *priv;
2572   gdouble x_root, y_root;
2573   guint32 _time;
2574
2575 #define STILL_THRESHOLD 40
2576
2577   if (!gdk_event_get_root_coords (event, &x_root, &y_root))
2578     return FALSE;
2579
2580   priv = scrolled_window->priv;
2581   _time = gdk_event_get_time (event);
2582
2583   if (priv->last_motion_event_x_root != x_root ||
2584       priv->last_motion_event_y_root != y_root ||
2585       ABS (_time - priv->last_motion_event_time) > STILL_THRESHOLD)
2586     {
2587       priv->x_velocity = (priv->last_motion_event_x_root - x_root) /
2588         (gdouble) (_time - priv->last_motion_event_time);
2589       priv->y_velocity = (priv->last_motion_event_y_root - y_root) /
2590         (gdouble) (_time - priv->last_motion_event_time);
2591     }
2592
2593   priv->last_motion_event_x_root = x_root;
2594   priv->last_motion_event_y_root = y_root;
2595   priv->last_motion_event_time = _time;
2596
2597 #undef STILL_THRESHOLD
2598
2599   return TRUE;
2600 }
2601
2602 static gboolean
2603 gtk_scrolled_window_captured_button_release (GtkWidget *widget,
2604                                              GdkEvent  *event)
2605 {
2606   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
2607   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
2608   GtkWidget *child;
2609   gboolean overshoot;
2610   guint button;
2611   gdouble x_root, y_root;
2612
2613   if (gdk_event_get_button (event, &button) && button != 1)
2614     return FALSE;
2615
2616   child = gtk_bin_get_child (GTK_BIN (widget));
2617   if (!child)
2618     return FALSE;
2619
2620   gtk_device_grab_remove (widget, priv->drag_device);
2621   priv->drag_device = NULL;
2622
2623   if (priv->release_timeout_id)
2624     {
2625       g_source_remove (priv->release_timeout_id);
2626       priv->release_timeout_id = 0;
2627     }
2628
2629   overshoot = _gtk_scrolled_window_get_overshoot (scrolled_window, NULL, NULL);
2630
2631   if (priv->in_drag)
2632     gdk_device_ungrab (gdk_event_get_device (event), gdk_event_get_time (event));
2633   else
2634     {
2635       /* There hasn't been scrolling at all, so just let the
2636        * child widget handle the button press normally
2637        */
2638       gtk_scrolled_window_release_captured_event (scrolled_window);
2639
2640       if (!overshoot)
2641         return FALSE;
2642     }
2643   priv->in_drag = FALSE;
2644
2645   if (priv->button_press_event)
2646     {
2647       gdk_event_free (priv->button_press_event);
2648       priv->button_press_event = NULL;
2649     }
2650
2651   gtk_scrolled_window_calculate_velocity (scrolled_window, event);
2652
2653   /* Zero out vector components without a visible scrollbar */
2654   if (!priv->hscrollbar_visible)
2655     priv->x_velocity = 0;
2656   if (!priv->vscrollbar_visible)
2657     priv->y_velocity = 0;
2658
2659   if (priv->x_velocity != 0 || priv->y_velocity != 0 || overshoot)
2660     {
2661       gtk_scrolled_window_start_deceleration (scrolled_window);
2662       priv->x_velocity = priv->y_velocity = 0;
2663       priv->last_button_event_valid = FALSE;
2664     }
2665   else
2666     {
2667       gdk_event_get_root_coords (event, &x_root, &y_root);
2668       priv->last_button_event_x_root = x_root;
2669       priv->last_button_event_y_root = y_root;
2670       priv->last_button_event_valid = TRUE;
2671     }
2672
2673   if (priv->capture_button_press)
2674     return TRUE;
2675   else
2676     return FALSE;
2677 }
2678
2679 static gboolean
2680 gtk_scrolled_window_captured_motion_notify (GtkWidget *widget,
2681                                             GdkEvent  *event)
2682 {
2683   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
2684   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
2685   gint old_overshoot_x, old_overshoot_y;
2686   gint new_overshoot_x, new_overshoot_y;
2687   GtkWidget *child;
2688   GtkAdjustment *hadjustment;
2689   GtkAdjustment *vadjustment;
2690   gdouble dx, dy;
2691   GdkModifierType state;
2692   gdouble x_root, y_root;
2693
2694   gdk_event_get_state (event, &state);
2695   if (!(state & GDK_BUTTON1_MASK))
2696     return FALSE;
2697
2698   child = gtk_bin_get_child (GTK_BIN (widget));
2699   if (!child)
2700     return FALSE;
2701
2702   /* Check if we've passed the drag threshold */
2703   gdk_event_get_root_coords (event, &x_root, &y_root);
2704   if (!priv->in_drag)
2705     {
2706       if (gtk_drag_check_threshold (widget,
2707                                     priv->last_button_event_x_root,
2708                                     priv->last_button_event_y_root,
2709                                     x_root, y_root))
2710         {
2711           if (priv->release_timeout_id)
2712             {
2713               g_source_remove (priv->release_timeout_id);
2714               priv->release_timeout_id = 0;
2715             }
2716
2717           priv->last_button_event_valid = FALSE;
2718           priv->in_drag = TRUE;
2719         }
2720       else
2721         return TRUE;
2722     }
2723
2724   gdk_device_grab (priv->drag_device,
2725                    gtk_widget_get_window (widget),
2726                    GDK_OWNERSHIP_WINDOW,
2727                    TRUE,
2728                    GDK_BUTTON_RELEASE_MASK | GDK_BUTTON1_MOTION_MASK,
2729                    NULL,
2730                    gdk_event_get_time (event));
2731
2732   priv->last_button_event_valid = FALSE;
2733
2734   if (priv->button_press_event)
2735     {
2736       gdk_event_free (priv->button_press_event);
2737       priv->button_press_event = NULL;
2738     }
2739
2740   _gtk_scrolled_window_get_overshoot (scrolled_window,
2741                                       &old_overshoot_x, &old_overshoot_y);
2742
2743   hadjustment = gtk_range_get_adjustment (GTK_RANGE (priv->hscrollbar));
2744   if (hadjustment && priv->hscrollbar_visible)
2745     {
2746       dx = (priv->last_motion_event_x_root - x_root) + priv->unclamped_hadj_value;
2747       _gtk_scrolled_window_set_adjustment_value (scrolled_window, hadjustment,
2748                                                  dx, TRUE, FALSE);
2749     }
2750
2751   vadjustment = gtk_range_get_adjustment (GTK_RANGE (priv->vscrollbar));
2752   if (vadjustment && priv->vscrollbar_visible)
2753     {
2754       dy = (priv->last_motion_event_y_root - y_root) + priv->unclamped_vadj_value;
2755       _gtk_scrolled_window_set_adjustment_value (scrolled_window, vadjustment,
2756                                                  dy, TRUE, FALSE);
2757     }
2758
2759   _gtk_scrolled_window_get_overshoot (scrolled_window,
2760                                       &new_overshoot_x, &new_overshoot_y);
2761
2762   if (old_overshoot_x != new_overshoot_x ||
2763       old_overshoot_y != new_overshoot_y)
2764     {
2765       if (new_overshoot_x >= 0 || new_overshoot_y >= 0)
2766         {
2767           /* We need to reallocate the widget to have it at
2768            * negative offset, so there's a "gravity" on the
2769            * bottom/right corner
2770            */
2771           gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
2772         }
2773       else if (new_overshoot_x < 0 || new_overshoot_y < 0)
2774         _gtk_scrolled_window_allocate_overshoot_window (scrolled_window);
2775     }
2776
2777   gtk_scrolled_window_calculate_velocity (scrolled_window, event);
2778
2779   return TRUE;
2780 }
2781
2782 static gboolean
2783 gtk_scrolled_window_captured_button_press (GtkWidget *widget,
2784                                            GdkEvent  *event)
2785 {
2786   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
2787   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
2788   GtkWidget *child;
2789   GtkWidget *event_widget;
2790   GdkDevice *source_device;
2791   GdkInputSource source;
2792   gdouble x_root, y_root;
2793   guint button;
2794
2795   /* If scrollbars are not visible, we don't do kinetic scrolling */
2796   if (!priv->vscrollbar_visible && !priv->hscrollbar_visible)
2797     return FALSE;
2798
2799   source_device = gdk_event_get_source_device (event);
2800   source = gdk_device_get_source (source_device);
2801
2802   if (source != GDK_SOURCE_TOUCHSCREEN)
2803     return FALSE;
2804
2805   event_widget = gtk_get_event_widget (event);
2806
2807   /* If there's another scrolled window between the widget
2808    * receiving the event and this capturing scrolled window,
2809    * let it handle the events.
2810    */
2811   if (widget != gtk_widget_get_ancestor (event_widget, GTK_TYPE_SCROLLED_WINDOW))
2812     return FALSE;
2813
2814   /* Check whether the button press is close to the previous one,
2815    * take that as a shortcut to get the child widget handle events
2816    */
2817   gdk_event_get_root_coords (event, &x_root, &y_root);
2818   if (priv->last_button_event_valid &&
2819       ABS (x_root - priv->last_button_event_x_root) < TOUCH_BYPASS_CAPTURED_THRESHOLD &&
2820       ABS (y_root - priv->last_button_event_y_root) < TOUCH_BYPASS_CAPTURED_THRESHOLD)
2821     {
2822       priv->last_button_event_valid = FALSE;
2823       return FALSE;
2824     }
2825
2826   priv->last_button_event_x_root = priv->last_motion_event_x_root = x_root;
2827   priv->last_button_event_y_root = priv->last_motion_event_y_root = y_root;
2828   priv->last_motion_event_time = gdk_event_get_time (event);
2829   priv->last_button_event_valid = TRUE;
2830
2831   if (gdk_event_get_button (event, &button) && button != 1)
2832     return FALSE;
2833
2834   child = gtk_bin_get_child (GTK_BIN (widget));
2835   if (!child)
2836     return FALSE;
2837
2838   if (priv->hscrollbar == event_widget || priv->vscrollbar == event_widget)
2839     return FALSE;
2840
2841   priv->drag_device = gdk_event_get_device (event);
2842   gtk_device_grab_add (widget, priv->drag_device, TRUE);
2843
2844   gtk_scrolled_window_cancel_deceleration (scrolled_window);
2845
2846   /* Only set the timeout if we're going to store an event */
2847   if (priv->capture_button_press)
2848     priv->release_timeout_id =
2849       gdk_threads_add_timeout (RELEASE_EVENT_TIMEOUT,
2850                                (GSourceFunc) gtk_scrolled_window_release_captured_event,
2851                                scrolled_window);
2852
2853   priv->in_drag = FALSE;
2854
2855   if (priv->capture_button_press)
2856     {
2857       /* Store the button press event in
2858        * case we need to propagate it later
2859        */
2860       priv->button_press_event = gdk_event_copy (event);
2861       return TRUE;
2862     }
2863   else
2864     return FALSE;
2865 }
2866
2867 static gboolean
2868 gtk_scrolled_window_captured_event (GtkWidget *widget,
2869                                     GdkEvent  *event)
2870 {
2871   gboolean retval = FALSE;
2872   GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW (widget)->priv;
2873
2874   switch (event->type)
2875     {
2876     case GDK_TOUCH_BEGIN:
2877     case GDK_BUTTON_PRESS:
2878       retval = gtk_scrolled_window_captured_button_press (widget, event);
2879       break;
2880     case GDK_TOUCH_END:
2881     case GDK_BUTTON_RELEASE:
2882       if (priv->drag_device)
2883         retval = gtk_scrolled_window_captured_button_release (widget, event);
2884       else
2885         priv->last_button_event_valid = FALSE;
2886       break;
2887     case GDK_TOUCH_UPDATE:
2888     case GDK_MOTION_NOTIFY:
2889       if (priv->drag_device)
2890         retval = gtk_scrolled_window_captured_motion_notify (widget, event);
2891       break;
2892     case GDK_LEAVE_NOTIFY:
2893     case GDK_ENTER_NOTIFY:
2894       if (priv->in_drag &&
2895           event->crossing.mode != GDK_CROSSING_GRAB)
2896         retval = TRUE;
2897       break;
2898     default:
2899       break;
2900     }
2901
2902   return retval;
2903 }
2904
2905 static gboolean
2906 gtk_scrolled_window_focus (GtkWidget        *widget,
2907                            GtkDirectionType  direction)
2908 {
2909   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
2910   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
2911   GtkWidget *child;
2912   gboolean had_focus_child;
2913
2914   had_focus_child = gtk_container_get_focus_child (GTK_CONTAINER (widget)) != NULL;
2915
2916   if (priv->focus_out)
2917     {
2918       priv->focus_out = FALSE; /* Clear this to catch the wrap-around case */
2919       return FALSE;
2920     }
2921
2922   if (gtk_widget_is_focus (widget))
2923     return FALSE;
2924
2925   /* We only put the scrolled window itself in the focus chain if it
2926    * isn't possible to focus any children.
2927    */
2928   child = gtk_bin_get_child (GTK_BIN (widget));
2929   if (child)
2930     {
2931       if (gtk_widget_child_focus (child, direction))
2932         return TRUE;
2933     }
2934
2935   if (!had_focus_child && gtk_widget_get_can_focus (widget))
2936     {
2937       gtk_widget_grab_focus (widget);
2938       return TRUE;
2939     }
2940   else
2941     return FALSE;
2942 }
2943
2944 static void
2945 gtk_scrolled_window_adjustment_changed (GtkAdjustment *adjustment,
2946                                         gpointer       data)
2947 {
2948   GtkScrolledWindowPrivate *priv;
2949   GtkScrolledWindow *scrolled_window;
2950
2951   g_return_if_fail (adjustment != NULL);
2952   g_return_if_fail (data != NULL);
2953
2954   scrolled_window = GTK_SCROLLED_WINDOW (data);
2955   priv = scrolled_window->priv;
2956
2957   if (priv->hscrollbar &&
2958       adjustment == gtk_range_get_adjustment (GTK_RANGE (priv->hscrollbar)))
2959     {
2960       if (priv->hscrollbar_policy == GTK_POLICY_AUTOMATIC)
2961         {
2962           gboolean visible;
2963
2964           visible = priv->hscrollbar_visible;
2965           priv->hscrollbar_visible = (gtk_adjustment_get_upper (adjustment) - gtk_adjustment_get_lower (adjustment) >
2966                                       gtk_adjustment_get_page_size (adjustment));
2967
2968           if (priv->hscrollbar_visible != visible)
2969             gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
2970         }
2971     }
2972   else if (priv->vscrollbar &&
2973            adjustment == gtk_range_get_adjustment (GTK_RANGE (priv->vscrollbar)))
2974     {
2975       if (priv->vscrollbar_policy == GTK_POLICY_AUTOMATIC)
2976         {
2977           gboolean visible;
2978
2979           visible = priv->vscrollbar_visible;
2980           priv->vscrollbar_visible = (gtk_adjustment_get_upper (adjustment) - gtk_adjustment_get_lower (adjustment) >
2981                                       gtk_adjustment_get_page_size (adjustment));
2982
2983           if (priv->vscrollbar_visible != visible)
2984             gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
2985         }
2986     }
2987 }
2988
2989 static void
2990 gtk_scrolled_window_adjustment_value_changed (GtkAdjustment *adjustment,
2991                                               gpointer       user_data)
2992 {
2993   GtkScrolledWindow *scrolled_window = user_data;
2994   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
2995
2996   /* Allow overshooting for kinetic scrolling operations */
2997   if (priv->drag_device || priv->deceleration_id)
2998     return;
2999
3000   /* Ensure GtkAdjustment and unclamped values are in sync */
3001   if (priv->vscrollbar &&
3002       adjustment == gtk_range_get_adjustment (GTK_RANGE (priv->vscrollbar)))
3003     priv->unclamped_vadj_value = gtk_adjustment_get_value (adjustment);
3004   else if (priv->hscrollbar &&
3005            adjustment == gtk_range_get_adjustment (GTK_RANGE (priv->hscrollbar)))
3006     priv->unclamped_hadj_value = gtk_adjustment_get_value (adjustment);
3007 }
3008
3009 static void
3010 gtk_scrolled_window_add (GtkContainer *container,
3011                          GtkWidget    *child)
3012 {
3013   GtkScrolledWindowPrivate *priv;
3014   GtkScrolledWindow *scrolled_window;
3015   GtkBin *bin;
3016   GtkWidget *child_widget;
3017   GtkAdjustment *hadj, *vadj;
3018
3019   bin = GTK_BIN (container);
3020   child_widget = gtk_bin_get_child (bin);
3021   g_return_if_fail (child_widget == NULL);
3022
3023   scrolled_window = GTK_SCROLLED_WINDOW (container);
3024   priv = scrolled_window->priv;
3025
3026   if (gtk_widget_get_realized (GTK_WIDGET (bin)))
3027     gtk_widget_set_parent_window (child, priv->overshoot_window);
3028
3029   _gtk_bin_set_child (bin, child);
3030   gtk_widget_set_parent (child, GTK_WIDGET (bin));
3031
3032   hadj = gtk_range_get_adjustment (GTK_RANGE (priv->hscrollbar));
3033   vadj = gtk_range_get_adjustment (GTK_RANGE (priv->vscrollbar));
3034
3035   if (GTK_IS_SCROLLABLE (child))
3036     g_object_set (child, "hadjustment", hadj, "vadjustment", vadj, NULL);
3037   else
3038     g_warning ("gtk_scrolled_window_add(): cannot add non scrollable widget "
3039                "use gtk_scrolled_window_add_with_viewport() instead");
3040 }
3041
3042 static void
3043 gtk_scrolled_window_remove (GtkContainer *container,
3044                             GtkWidget    *child)
3045 {
3046   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (container));
3047   g_return_if_fail (child != NULL);
3048   g_return_if_fail (gtk_bin_get_child (GTK_BIN (container)) == child);
3049
3050   g_object_set (child, "hadjustment", NULL, "vadjustment", NULL, NULL);
3051
3052   /* chain parent class handler to remove child */
3053   GTK_CONTAINER_CLASS (gtk_scrolled_window_parent_class)->remove (container, child);
3054 }
3055
3056 /**
3057  * gtk_scrolled_window_add_with_viewport:
3058  * @scrolled_window: a #GtkScrolledWindow
3059  * @child: the widget you want to scroll
3060  *
3061  * Used to add children without native scrolling capabilities. This
3062  * is simply a convenience function; it is equivalent to adding the
3063  * unscrollable child to a viewport, then adding the viewport to the
3064  * scrolled window. If a child has native scrolling, use
3065  * gtk_container_add() instead of this function.
3066  *
3067  * The viewport scrolls the child by moving its #GdkWindow, and takes
3068  * the size of the child to be the size of its toplevel #GdkWindow.
3069  * This will be very wrong for most widgets that support native scrolling;
3070  * for example, if you add a widget such as #GtkTreeView with a viewport,
3071  * the whole widget will scroll, including the column headings. Thus,
3072  * widgets with native scrolling support should not be used with the
3073  * #GtkViewport proxy.
3074  *
3075  * A widget supports scrolling natively if it implements the
3076  * #GtkScrollable interface.
3077  */
3078 void
3079 gtk_scrolled_window_add_with_viewport (GtkScrolledWindow *scrolled_window,
3080                                        GtkWidget         *child)
3081 {
3082   GtkBin *bin;
3083   GtkWidget *viewport;
3084   GtkWidget *child_widget;
3085
3086   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
3087   g_return_if_fail (GTK_IS_WIDGET (child));
3088   g_return_if_fail (gtk_widget_get_parent (child) == NULL);
3089
3090   bin = GTK_BIN (scrolled_window);
3091   child_widget = gtk_bin_get_child (bin);
3092
3093   if (child_widget)
3094     {
3095       g_return_if_fail (GTK_IS_VIEWPORT (child_widget));
3096       g_return_if_fail (gtk_bin_get_child (GTK_BIN (child_widget)) == NULL);
3097
3098       viewport = child_widget;
3099     }
3100   else
3101     {
3102       viewport =
3103         gtk_viewport_new (gtk_scrolled_window_get_hadjustment (scrolled_window),
3104                           gtk_scrolled_window_get_vadjustment (scrolled_window));
3105       gtk_container_add (GTK_CONTAINER (scrolled_window), viewport);
3106     }
3107
3108   gtk_widget_show (viewport);
3109   gtk_container_add (GTK_CONTAINER (viewport), child);
3110 }
3111
3112 /*
3113  * _gtk_scrolled_window_get_spacing:
3114  * @scrolled_window: a scrolled window
3115  *
3116  * Gets the spacing between the scrolled window's scrollbars and
3117  * the scrolled widget. Used by GtkCombo
3118  *
3119  * Return value: the spacing, in pixels.
3120  */
3121 gint
3122 _gtk_scrolled_window_get_scrollbar_spacing (GtkScrolledWindow *scrolled_window)
3123 {
3124   GtkScrolledWindowClass *class;
3125
3126   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), 0);
3127
3128   class = GTK_SCROLLED_WINDOW_GET_CLASS (scrolled_window);
3129
3130   if (class->scrollbar_spacing >= 0)
3131     return class->scrollbar_spacing;
3132   else
3133     {
3134       gint scrollbar_spacing;
3135
3136       gtk_widget_style_get (GTK_WIDGET (scrolled_window),
3137                             "scrollbar-spacing", &scrollbar_spacing,
3138                             NULL);
3139
3140       return scrollbar_spacing;
3141     }
3142 }
3143
3144
3145 static void
3146 gtk_scrolled_window_get_preferred_size (GtkWidget      *widget,
3147                                         GtkOrientation  orientation,
3148                                         gint           *minimum_size,
3149                                         gint           *natural_size)
3150 {
3151   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
3152   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
3153   GtkBin *bin = GTK_BIN (scrolled_window);
3154   gint extra_width;
3155   gint extra_height;
3156   gint scrollbar_spacing;
3157   GtkRequisition hscrollbar_requisition;
3158   GtkRequisition vscrollbar_requisition;
3159   GtkRequisition minimum_req, natural_req;
3160   GtkWidget *child;
3161   gint min_child_size, nat_child_size;
3162
3163   scrollbar_spacing = _gtk_scrolled_window_get_scrollbar_spacing (scrolled_window);
3164
3165   extra_width = 0;
3166   extra_height = 0;
3167   minimum_req.width = 0;
3168   minimum_req.height = 0;
3169   natural_req.width = 0;
3170   natural_req.height = 0;
3171
3172   gtk_widget_get_preferred_size (priv->hscrollbar,
3173                                  &hscrollbar_requisition, NULL);
3174   gtk_widget_get_preferred_size (priv->vscrollbar,
3175                                  &vscrollbar_requisition, NULL);
3176
3177   child = gtk_bin_get_child (bin);
3178   if (child && gtk_widget_get_visible (child))
3179     {
3180       if (orientation == GTK_ORIENTATION_HORIZONTAL)
3181         {
3182           gtk_widget_get_preferred_width (child,
3183                                           &min_child_size,
3184                                           &nat_child_size);
3185
3186           if (priv->hscrollbar_policy == GTK_POLICY_NEVER)
3187             {
3188               minimum_req.width += min_child_size;
3189               natural_req.width += nat_child_size;
3190             }
3191           else
3192             {
3193               gint min_content_width = priv->min_content_width;
3194
3195               if (min_content_width >= 0)
3196                 {
3197                   minimum_req.width = MAX (minimum_req.width, min_content_width);
3198                   natural_req.width = MAX (natural_req.width, min_content_width);
3199                   extra_width = -1;
3200                 }
3201               else
3202                 {
3203                   minimum_req.width += vscrollbar_requisition.width;
3204                   natural_req.width += vscrollbar_requisition.width;
3205                 }
3206             }
3207         }
3208       else /* GTK_ORIENTATION_VERTICAL */
3209         {
3210           gtk_widget_get_preferred_height (child,
3211                                            &min_child_size,
3212                                            &nat_child_size);
3213
3214           if (priv->vscrollbar_policy == GTK_POLICY_NEVER)
3215             {
3216               minimum_req.height += min_child_size;
3217               natural_req.height += nat_child_size;
3218             }
3219           else
3220             {
3221               gint min_content_height = priv->min_content_height;
3222
3223               if (min_content_height >= 0)
3224                 {
3225                   minimum_req.height = MAX (minimum_req.height, min_content_height);
3226                   natural_req.height = MAX (natural_req.height, min_content_height);
3227                   extra_height = -1;
3228                 }
3229               else
3230                 {
3231                   minimum_req.height += vscrollbar_requisition.height;
3232                   natural_req.height += vscrollbar_requisition.height;
3233                 }
3234             }
3235         }
3236     }
3237
3238   if (priv->hscrollbar_policy == GTK_POLICY_AUTOMATIC ||
3239       priv->hscrollbar_policy == GTK_POLICY_ALWAYS)
3240     {
3241       minimum_req.width = MAX (minimum_req.width, hscrollbar_requisition.width);
3242       natural_req.width = MAX (natural_req.width, hscrollbar_requisition.width);
3243       if (!extra_height || priv->hscrollbar_policy == GTK_POLICY_ALWAYS)
3244         extra_height = scrollbar_spacing + hscrollbar_requisition.height;
3245     }
3246
3247   if (priv->vscrollbar_policy == GTK_POLICY_AUTOMATIC ||
3248       priv->vscrollbar_policy == GTK_POLICY_ALWAYS)
3249     {
3250       minimum_req.height = MAX (minimum_req.height, vscrollbar_requisition.height);
3251       natural_req.height = MAX (natural_req.height, vscrollbar_requisition.height);
3252       if (!extra_width || priv->vscrollbar_policy == GTK_POLICY_ALWAYS)
3253         extra_width = scrollbar_spacing + vscrollbar_requisition.width;
3254     }
3255
3256   minimum_req.width  += MAX (0, extra_width);
3257   minimum_req.height += MAX (0, extra_height);
3258   natural_req.width  += MAX (0, extra_width);
3259   natural_req.height += MAX (0, extra_height);
3260
3261   if (priv->shadow_type != GTK_SHADOW_NONE)
3262     {
3263       GtkStyleContext *context;
3264       GtkStateFlags state;
3265       GtkBorder padding, border;
3266
3267       context = gtk_widget_get_style_context (GTK_WIDGET (widget));
3268       state = gtk_widget_get_state_flags (GTK_WIDGET (widget));
3269
3270       gtk_style_context_save (context);
3271       gtk_style_context_add_class (context, GTK_STYLE_CLASS_FRAME);
3272
3273       gtk_style_context_get_padding (context, state, &padding);
3274       gtk_style_context_get_border (context, state, &border);
3275
3276       minimum_req.width += padding.left + padding.right + border.left + border.right;
3277       minimum_req.height += padding.top + padding.bottom + border.top + border.bottom;
3278       natural_req.width += padding.left + padding.right + border.left + border.right;
3279       natural_req.height += padding.top + padding.bottom + border.top + border.bottom;
3280
3281       gtk_style_context_restore (context);
3282     }
3283
3284   if (orientation == GTK_ORIENTATION_HORIZONTAL)
3285     {
3286       if (minimum_size)
3287         *minimum_size = minimum_req.width;
3288       if (natural_size)
3289         *natural_size = natural_req.width;
3290     }
3291   else
3292     {
3293       if (minimum_size)
3294         *minimum_size = minimum_req.height;
3295       if (natural_size)
3296         *natural_size = natural_req.height;
3297     }
3298 }
3299
3300 static void
3301 gtk_scrolled_window_get_preferred_width (GtkWidget *widget,
3302                                          gint      *minimum_size,
3303                                          gint      *natural_size)
3304 {
3305   gtk_scrolled_window_get_preferred_size (widget, GTK_ORIENTATION_HORIZONTAL, minimum_size, natural_size);
3306 }
3307
3308 static void
3309 gtk_scrolled_window_get_preferred_height (GtkWidget *widget,
3310                                           gint      *minimum_size,
3311                                           gint      *natural_size)
3312 {
3313   gtk_scrolled_window_get_preferred_size (widget, GTK_ORIENTATION_VERTICAL, minimum_size, natural_size);
3314 }
3315
3316 static void
3317 gtk_scrolled_window_get_preferred_height_for_width (GtkWidget *widget,
3318                                                     gint       width,
3319                                                     gint      *minimum_height,
3320                                                     gint      *natural_height)
3321 {
3322   g_return_if_fail (GTK_IS_WIDGET (widget));
3323
3324   GTK_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, minimum_height, natural_height);
3325 }
3326
3327 static void
3328 gtk_scrolled_window_get_preferred_width_for_height (GtkWidget *widget,
3329                                                     gint       height,
3330                                                     gint      *minimum_width,
3331                                                     gint      *natural_width)
3332 {
3333   g_return_if_fail (GTK_IS_WIDGET (widget));
3334
3335   GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, minimum_width, natural_width);
3336 }
3337
3338 static void
3339 gtk_scrolled_window_realize (GtkWidget *widget)
3340 {
3341   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
3342   GtkAllocation allocation, relative_allocation;
3343   GdkWindowAttr attributes;
3344   GtkWidget *child_widget;
3345   gint attributes_mask;
3346
3347   gtk_widget_set_realized (widget, TRUE);
3348   gtk_widget_get_allocation (widget, &allocation);
3349   gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
3350
3351   attributes.window_type = GDK_WINDOW_CHILD;
3352   attributes.x = allocation.x + relative_allocation.x;
3353   attributes.y = allocation.y + relative_allocation.y;
3354   attributes.width = allocation.width;
3355   attributes.height = allocation.height;
3356   attributes.wclass = GDK_INPUT_OUTPUT;
3357   attributes.visual = gtk_widget_get_visual (widget);
3358   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK |
3359     GDK_BUTTON_MOTION_MASK | GDK_TOUCH_MASK;
3360
3361   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3362
3363   scrolled_window->priv->overshoot_window =
3364     gdk_window_new (gtk_widget_get_parent_window (widget),
3365                     &attributes, attributes_mask);
3366
3367   gdk_window_set_user_data (scrolled_window->priv->overshoot_window, widget);
3368
3369   child_widget = gtk_bin_get_child (GTK_BIN (widget));
3370
3371   if (child_widget)
3372     gtk_widget_set_parent_window (child_widget,
3373                                   scrolled_window->priv->overshoot_window);
3374
3375   GTK_WIDGET_CLASS (gtk_scrolled_window_parent_class)->realize (widget);
3376 }
3377
3378 static void
3379 gtk_scrolled_window_unrealize (GtkWidget *widget)
3380 {
3381   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
3382
3383   gdk_window_set_user_data (scrolled_window->priv->overshoot_window, NULL);
3384   gdk_window_destroy (scrolled_window->priv->overshoot_window);
3385   scrolled_window->priv->overshoot_window = NULL;
3386
3387   gtk_widget_set_realized (widget, FALSE);
3388
3389   GTK_WIDGET_CLASS (gtk_scrolled_window_parent_class)->unrealize (widget);
3390 }
3391
3392 static void
3393 gtk_scrolled_window_map (GtkWidget *widget)
3394 {
3395   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
3396
3397   gdk_window_show (scrolled_window->priv->overshoot_window);
3398
3399   GTK_WIDGET_CLASS (gtk_scrolled_window_parent_class)->map (widget);
3400 }
3401
3402 static void
3403 gtk_scrolled_window_unmap (GtkWidget *widget)
3404 {
3405   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
3406
3407   gdk_window_hide (scrolled_window->priv->overshoot_window);
3408
3409   GTK_WIDGET_CLASS (gtk_scrolled_window_parent_class)->unmap (widget);
3410 }
3411
3412 static void
3413 gtk_scrolled_window_grab_notify (GtkWidget *widget,
3414                                  gboolean   was_grabbed)
3415 {
3416   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
3417   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
3418
3419   if (priv->drag_device &&
3420       gtk_widget_device_is_shadowed (widget,
3421                                      priv->drag_device))
3422     {
3423       gdk_device_ungrab (priv->drag_device,
3424                          gtk_get_current_event_time ());
3425       priv->drag_device = NULL;
3426       priv->in_drag = FALSE;
3427
3428       if (priv->release_timeout_id)
3429         {
3430           g_source_remove (priv->release_timeout_id);
3431           priv->release_timeout_id = 0;
3432         }
3433
3434       if (_gtk_scrolled_window_get_overshoot (scrolled_window, NULL, NULL))
3435         gtk_scrolled_window_start_deceleration (scrolled_window);
3436       else
3437         gtk_scrolled_window_cancel_deceleration (scrolled_window);
3438
3439       priv->last_button_event_valid = FALSE;
3440     }
3441 }
3442
3443 /**
3444  * gtk_scrolled_window_get_min_content_width:
3445  * @scrolled_window: a #GtkScrolledWindow
3446  *
3447  * Gets the minimum content width of @scrolled_window, or -1 if not set.
3448  *
3449  * Returns: the minimum content width
3450  *
3451  * Since: 3.0
3452  */
3453 gint
3454 gtk_scrolled_window_get_min_content_width (GtkScrolledWindow *scrolled_window)
3455 {
3456   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), 0);
3457
3458   return scrolled_window->priv->min_content_width;
3459 }
3460
3461 /**
3462  * gtk_scrolled_window_set_min_content_width:
3463  * @scrolled_window: a #GtkScrolledWindow
3464  * @width: the minimal content width
3465  *
3466  * Sets the minimum width that @scrolled_window should keep visible.
3467  * Note that this can and (usually will) be smaller than the minimum
3468  * size of the content.
3469  *
3470  * Since: 3.0
3471  */
3472 void
3473 gtk_scrolled_window_set_min_content_width (GtkScrolledWindow *scrolled_window,
3474                                            gint               width)
3475 {
3476   GtkScrolledWindowPrivate *priv;
3477
3478   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
3479
3480   priv = scrolled_window->priv;
3481
3482   if (priv->min_content_width != width)
3483     {
3484       priv->min_content_width = width;
3485
3486       gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
3487
3488       g_object_notify (G_OBJECT (scrolled_window), "min-content-width");
3489     }
3490 }
3491
3492 /**
3493  * gtk_scrolled_window_get_min_content_height:
3494  * @scrolled_window: a #GtkScrolledWindow
3495  *
3496  * Gets the minimal content height of @scrolled_window, or -1 if not set.
3497  *
3498  * Returns: the minimal content height
3499  *
3500  * Since: 3.0
3501  */
3502 gint
3503 gtk_scrolled_window_get_min_content_height (GtkScrolledWindow *scrolled_window)
3504 {
3505   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), 0);
3506
3507   return scrolled_window->priv->min_content_height;
3508 }
3509
3510 /**
3511  * gtk_scrolled_window_set_min_content_height:
3512  * @scrolled_window: a #GtkScrolledWindow
3513  * @height: the minimal content height
3514  *
3515  * Sets the minimum height that @scrolled_window should keep visible.
3516  * Note that this can and (usually will) be smaller than the minimum
3517  * size of the content.
3518  *
3519  * Since: 3.0
3520  */
3521 void
3522 gtk_scrolled_window_set_min_content_height (GtkScrolledWindow *scrolled_window,
3523                                             gint               height)
3524 {
3525   GtkScrolledWindowPrivate *priv;
3526
3527   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
3528
3529   priv = scrolled_window->priv;
3530
3531   if (priv->min_content_height != height)
3532     {
3533       priv->min_content_height = height;
3534
3535       gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
3536
3537       g_object_notify (G_OBJECT (scrolled_window), "min-content-height");
3538     }
3539 }