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, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include "config.h"
  28 #include <math.h>
  29 #include <gdk/gdkkeysyms.h>
  30 #include "gtkbindings.h"
  31 #include "gtkextendedlayout.h"
  32 #include "gtkmarshalers.h"
  33 #include "gtkscrolledwindow.h"
  34 #include "gtkwindow.h"
  35 #include "gtkprivate.h"
  36 #include "gtkintl.h"
  37 #include "gtkalias.h"
  38
  39
  40 /* scrolled window policy and size requisition handling:
  41  *
  42  * gtk size requisition works as follows:
  43  *   a widget upon size-request reports the width and height that it finds
  44  *   to be best suited to display its contents, including children.
  45  *   the width and/or height reported from a widget upon size requisition
  46  *   may be overidden by the user by specifying a width and/or height
  47  *   other than 0 through gtk_widget_set_size_request().
  48  *
  49  * a scrolled window needs (for implementing all three policy types) to
  50  * request its width and height based on two different rationales.
  51  * 1)   the user wants the scrolled window to just fit into the space
  52  *      that it gets allocated for a specifc dimension.
  53  * 1.1) this does not apply if the user specified a concrete value
  54  *      value for that specific dimension by either specifying usize for the
  55  *      scrolled window or for its child.
  56  * 2)   the user wants the scrolled window to take as much space up as
  57  *      is desired by the child for a specifc dimension (i.e. POLICY_NEVER).
  58  *
  59  * also, kinda obvious:
  60  * 3)   a user would certainly not have choosen a scrolled window as a container
  61  *      for the child, if the resulting allocation takes up more space than the
  62  *      child would have allocated without the scrolled window.
  63  *
  64  * conclusions:
  65  * A) from 1) follows: the scrolled window shouldn't request more space for a
  66  *    specifc dimension than is required at minimum.
  67  * B) from 1.1) follows: the requisition may be overidden by usize of the scrolled
  68  *    window (done automatically) or by usize of the child (needs to be checked).
  69  * C) from 2) follows: for POLICY_NEVER, the scrolled window simply reports the
  70  *    child's dimension.
  71  * D) from 3) follows: the scrolled window child's minimum width and minimum height
  72  *    under A) at least correspond to the space taken up by its scrollbars.
  73  */
  74
  75 #define DEFAULT_SCROLLBAR_SPACING  3
  76
  77 typedef struct {
  78         gboolean window_placement_set;
  79         GtkCornerType real_window_placement;
  80 } GtkScrolledWindowPrivate;
  81
  82 #define GTK_SCROLLED_WINDOW_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_SCROLLED_WINDOW, GtkScrolledWindowPrivate))
  83
  84 enum {
  85   PROP_0,
  86   PROP_HADJUSTMENT,
  87   PROP_VADJUSTMENT,
  88   PROP_HSCROLLBAR_POLICY,
  89   PROP_VSCROLLBAR_POLICY,
  90   PROP_WINDOW_PLACEMENT,
  91   PROP_WINDOW_PLACEMENT_SET,
  92   PROP_SHADOW_TYPE
  93 };
  94
  95 /* Signals */
  96 enum
  97 {
  98   SCROLL_CHILD,
  99   MOVE_FOCUS_OUT,
 100   LAST_SIGNAL
 101 };
 102
 103 static void     gtk_scrolled_window_destroy            (GtkObject         *object);
 104 static void     gtk_scrolled_window_set_property       (GObject           *object,
 105                                                         guint              prop_id,
 106                                                         const GValue      *value,
 107                                                         GParamSpec        *pspec);
 108 static void     gtk_scrolled_window_get_property       (GObject           *object,
 109                                                         guint              prop_id,
 110                                                         GValue            *value,
 111                                                         GParamSpec        *pspec);
 112
 113 static void     gtk_scrolled_window_screen_changed     (GtkWidget         *widget,
 114                                                         GdkScreen         *previous_screen);
 115 static gboolean gtk_scrolled_window_expose             (GtkWidget         *widget,
 116                                                         GdkEventExpose    *event);
 117 static void     gtk_scrolled_window_size_allocate      (GtkWidget         *widget,
 118                                                         GtkAllocation     *allocation);
 119 static gboolean gtk_scrolled_window_scroll_event       (GtkWidget         *widget,
 120                                                         GdkEventScroll    *event);
 121 static gboolean gtk_scrolled_window_focus              (GtkWidget         *widget,
 122                                                         GtkDirectionType   direction);
 123 static void     gtk_scrolled_window_add                (GtkContainer      *container,
 124                                                         GtkWidget         *widget);
 125 static void     gtk_scrolled_window_remove             (GtkContainer      *container,
 126                                                         GtkWidget         *widget);
 127 static void     gtk_scrolled_window_forall             (GtkContainer      *container,
 128                                                         gboolean           include_internals,
 129                                                         GtkCallback        callback,
 130                                                         gpointer           callback_data);
 131 static gboolean gtk_scrolled_window_scroll_child       (GtkScrolledWindow *scrolled_window,
 132                                                         GtkScrollType      scroll,
 133                                                         gboolean           horizontal);
 134 static void     gtk_scrolled_window_move_focus_out     (GtkScrolledWindow *scrolled_window,
 135                                                         GtkDirectionType   direction_type);
 136
 137 static void     gtk_scrolled_window_relative_allocation(GtkWidget         *widget,
 138                                                         GtkAllocation     *allocation);
 139 static void     gtk_scrolled_window_adjustment_changed (GtkAdjustment     *adjustment,
 140                                                         gpointer           data);
 141
 142 static void  gtk_scrolled_window_update_real_placement (GtkScrolledWindow *scrolled_window);
 143
 144 static void  gtk_scrolled_window_extended_layout_init  (GtkExtendedLayoutIface *iface);
 145
 146 static guint signals[LAST_SIGNAL] = {0};
 147
 148 G_DEFINE_TYPE_WITH_CODE (GtkScrolledWindow, gtk_scrolled_window, GTK_TYPE_BIN,
 149                          G_IMPLEMENT_INTERFACE (GTK_TYPE_EXTENDED_LAYOUT,
 150                                                 gtk_scrolled_window_extended_layout_init))
 151
 152
 153 static void
 154 add_scroll_binding (GtkBindingSet  *binding_set,
 155                     guint           keyval,
 156                     GdkModifierType mask,
 157                     GtkScrollType   scroll,
 158                     gboolean        horizontal)
 159 {
 160   guint keypad_keyval = keyval - GDK_Left + GDK_KP_Left;
 161
 162   gtk_binding_entry_add_signal (binding_set, keyval, mask,
 163                                 "scroll-child", 2,
 164                                 GTK_TYPE_SCROLL_TYPE, scroll,
 165                                 G_TYPE_BOOLEAN, horizontal);
 166   gtk_binding_entry_add_signal (binding_set, keypad_keyval, mask,
 167                                 "scroll-child", 2,
 168                                 GTK_TYPE_SCROLL_TYPE, scroll,
 169                                 G_TYPE_BOOLEAN, horizontal);
 170 }
 171
 172 static void
 173 add_tab_bindings (GtkBindingSet    *binding_set,
 174                   GdkModifierType   modifiers,
 175                   GtkDirectionType  direction)
 176 {
 177   gtk_binding_entry_add_signal (binding_set, GDK_Tab, modifiers,
 178                                 "move-focus-out", 1,
 179                                 GTK_TYPE_DIRECTION_TYPE, direction);
 180   gtk_binding_entry_add_signal (binding_set, GDK_KP_Tab, modifiers,
 181                                 "move-focus-out", 1,
 182                                 GTK_TYPE_DIRECTION_TYPE, direction);
 183 }
 184
 185 static void
 186 gtk_scrolled_window_class_init (GtkScrolledWindowClass *class)
 187 {
 188   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
 189   GtkObjectClass *object_class;
 190   GtkWidgetClass *widget_class;
 191   GtkContainerClass *container_class;
 192   GtkBindingSet *binding_set;
 193
 194   object_class = (GtkObjectClass*) class;
 195   widget_class = (GtkWidgetClass*) class;
 196   container_class = (GtkContainerClass*) class;
 197
 198   gobject_class->set_property = gtk_scrolled_window_set_property;
 199   gobject_class->get_property = gtk_scrolled_window_get_property;
 200
 201   object_class->destroy = gtk_scrolled_window_destroy;
 202
 203   widget_class->screen_changed = gtk_scrolled_window_screen_changed;
 204   widget_class->expose_event = gtk_scrolled_window_expose;
 205   widget_class->size_allocate = gtk_scrolled_window_size_allocate;
 206   widget_class->scroll_event = gtk_scrolled_window_scroll_event;
 207   widget_class->focus = gtk_scrolled_window_focus;
 208
 209   container_class->add = gtk_scrolled_window_add;
 210   container_class->remove = gtk_scrolled_window_remove;
 211   container_class->forall = gtk_scrolled_window_forall;
 212
 213   class->scrollbar_spacing = -1;
 214
 215   class->scroll_child = gtk_scrolled_window_scroll_child;
 216   class->move_focus_out = gtk_scrolled_window_move_focus_out;
 217
 218   g_object_class_install_property (gobject_class,
 219                                    PROP_HADJUSTMENT,
 220                                    g_param_spec_object ("hadjustment",
 221                                                         P_("Horizontal Adjustment"),
 222                                                         P_("The GtkAdjustment for the horizontal position"),
 223                                                         GTK_TYPE_ADJUSTMENT,
 224                                                         GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 225   g_object_class_install_property (gobject_class,
 226                                    PROP_VADJUSTMENT,
 227                                    g_param_spec_object ("vadjustment",
 228                                                         P_("Vertical Adjustment"),
 229                                                         P_("The GtkAdjustment for the vertical position"),
 230                                                         GTK_TYPE_ADJUSTMENT,
 231                                                         GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 232   g_object_class_install_property (gobject_class,
 233                                    PROP_HSCROLLBAR_POLICY,
 234                                    g_param_spec_enum ("hscrollbar-policy",
 235                                                       P_("Horizontal Scrollbar Policy"),
 236                                                       P_("When the horizontal scrollbar is displayed"),
 237                                                       GTK_TYPE_POLICY_TYPE,
 238                                                       GTK_POLICY_ALWAYS,
 239                                                       GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));
 240   g_object_class_install_property (gobject_class,
 241                                    PROP_VSCROLLBAR_POLICY,
 242                                    g_param_spec_enum ("vscrollbar-policy",
 243                                                       P_("Vertical Scrollbar Policy"),
 244                                                       P_("When the vertical scrollbar is displayed"),
 245                                                       GTK_TYPE_POLICY_TYPE,
 246                                                       GTK_POLICY_ALWAYS,
 247                                                       GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));
 248
 249   g_object_class_install_property (gobject_class,
 250                                    PROP_WINDOW_PLACEMENT,
 251                                    g_param_spec_enum ("window-placement",
 252                                                       P_("Window Placement"),
 253                                                       P_("Where the contents are located with respect to the scrollbars. This property only takes effect if \"window-placement-set\" is TRUE."),
 254                                                       GTK_TYPE_CORNER_TYPE,
 255                                                       GTK_CORNER_TOP_LEFT,
 256                                                       GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));
 257
 258   /**
 259    * GtkScrolledWindow:window-placement-set:
 260    *
 261    * Whether "window-placement" should be used to determine the location
 262    * of the contents with respect to the scrollbars. Otherwise, the
 263    * "gtk-scrolled-window-placement" setting is used.
 264    *
 265    * Since: 2.10
 266    */
 267   g_object_class_install_property (gobject_class,
 268                                    PROP_WINDOW_PLACEMENT_SET,
 269                                    g_param_spec_boolean ("window-placement-set",
 270                                                          P_("Window Placement Set"),
 271                                                          P_("Whether \"window-placement\" should be used to determine the location of the contents with respect to the scrollbars."),
 272                                                          FALSE,
 273                                                          GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));
 274   g_object_class_install_property (gobject_class,
 275                                    PROP_SHADOW_TYPE,
 276                                    g_param_spec_enum ("shadow-type",
 277                                                       P_("Shadow Type"),
 278                                                       P_("Style of bevel around the contents"),
 279                                                       GTK_TYPE_SHADOW_TYPE,
 280                                                       GTK_SHADOW_NONE,
 281                                                       GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));
 282
 283   /**
 284    * GtkScrolledWindow:scrollbars-within-bevel:
 285    *
 286    * Whether to place scrollbars within the scrolled window's bevel.
 287    *
 288    * Since: 2.12
 289    */
 290   gtk_widget_class_install_style_property (widget_class,
 291                                            g_param_spec_boolean ("scrollbars-within-bevel",
 292                                                                  P_("Scrollbars within bevel"),
 293                                                                  P_("Place scrollbars within the scrolled window's bevel"),
 294                                                                  FALSE,
 295                                                                  GTK_PARAM_READABLE));
 296
 297   gtk_widget_class_install_style_property (widget_class,
 298                                            g_param_spec_int ("scrollbar-spacing",
 299                                                              P_("Scrollbar spacing"),
 300                                                              P_("Number of pixels between the scrollbars and the scrolled window"),
 301                                                              0,
 302                                                              G_MAXINT,
 303                                                              DEFAULT_SCROLLBAR_SPACING,
 304                                                              GTK_PARAM_READABLE));
 305
 306   /**
 307    * GtkSettings:gtk-scrolled-window-placement:
 308    *
 309    * Where the contents of scrolled windows are located with respect to the
 310    * scrollbars, if not overridden by the scrolled window's own placement.
 311    *
 312    * Since: 2.10
 313    */
 314   gtk_settings_install_property (g_param_spec_enum ("gtk-scrolled-window-placement",
 315                                                     P_("Scrolled Window Placement"),
 316                                                     P_("Where the contents of scrolled windows are located with respect to the scrollbars, if not overridden by the scrolled window's own placement."),
 317                                                     GTK_TYPE_CORNER_TYPE,
 318                                                     GTK_CORNER_TOP_LEFT,
 319                                                     G_PARAM_READABLE | G_PARAM_WRITABLE));
 320
 321
 322   signals[SCROLL_CHILD] =
 323     g_signal_new (I_("scroll-child"),
 324                   G_TYPE_FROM_CLASS (object_class),
 325                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 326                   G_STRUCT_OFFSET (GtkScrolledWindowClass, scroll_child),
 327                   NULL, NULL,
 328                   _gtk_marshal_BOOLEAN__ENUM_BOOLEAN,
 329                   G_TYPE_BOOLEAN, 2,
 330                   GTK_TYPE_SCROLL_TYPE,
 331                   G_TYPE_BOOLEAN);
 332   signals[MOVE_FOCUS_OUT] =
 333     g_signal_new (I_("move-focus-out"),
 334                   G_TYPE_FROM_CLASS (object_class),
 335                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 336                   G_STRUCT_OFFSET (GtkScrolledWindowClass, move_focus_out),
 337                   NULL, NULL,
 338                   _gtk_marshal_VOID__ENUM,
 339                   G_TYPE_NONE, 1,
 340                   GTK_TYPE_DIRECTION_TYPE);
 341
 342   binding_set = gtk_binding_set_by_class (class);
 343
 344   add_scroll_binding (binding_set, GDK_Left,  GDK_CONTROL_MASK, GTK_SCROLL_STEP_BACKWARD, TRUE);
 345   add_scroll_binding (binding_set, GDK_Right, GDK_CONTROL_MASK, GTK_SCROLL_STEP_FORWARD,  TRUE);
 346   add_scroll_binding (binding_set, GDK_Up,    GDK_CONTROL_MASK, GTK_SCROLL_STEP_BACKWARD, FALSE);
 347   add_scroll_binding (binding_set, GDK_Down,  GDK_CONTROL_MASK, GTK_SCROLL_STEP_FORWARD,  FALSE);
 348
 349   add_scroll_binding (binding_set, GDK_Page_Up,   GDK_CONTROL_MASK, GTK_SCROLL_PAGE_BACKWARD, TRUE);
 350   add_scroll_binding (binding_set, GDK_Page_Down, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_FORWARD,  TRUE);
 351   add_scroll_binding (binding_set, GDK_Page_Up,   0,                GTK_SCROLL_PAGE_BACKWARD, FALSE);
 352   add_scroll_binding (binding_set, GDK_Page_Down, 0,                GTK_SCROLL_PAGE_FORWARD,  FALSE);
 353
 354   add_scroll_binding (binding_set, GDK_Home, GDK_CONTROL_MASK, GTK_SCROLL_START, TRUE);
 355   add_scroll_binding (binding_set, GDK_End,  GDK_CONTROL_MASK, GTK_SCROLL_END,   TRUE);
 356   add_scroll_binding (binding_set, GDK_Home, 0,                GTK_SCROLL_START, FALSE);
 357   add_scroll_binding (binding_set, GDK_End,  0,                GTK_SCROLL_END,   FALSE);
 358
 359   add_tab_bindings (binding_set, GDK_CONTROL_MASK, GTK_DIR_TAB_FORWARD);
 360   add_tab_bindings (binding_set, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
 361
 362   g_type_class_add_private (class, sizeof (GtkScrolledWindowPrivate));
 363 }
 364
 365 static void
 366 gtk_scrolled_window_init (GtkScrolledWindow *scrolled_window)
 367 {
 368   gtk_widget_set_has_window (GTK_WIDGET (scrolled_window), FALSE);
 369   gtk_widget_set_can_focus (GTK_WIDGET (scrolled_window), TRUE);
 370
 371   scrolled_window->hscrollbar = NULL;
 372   scrolled_window->vscrollbar = NULL;
 373   scrolled_window->hscrollbar_policy = GTK_POLICY_ALWAYS;
 374   scrolled_window->vscrollbar_policy = GTK_POLICY_ALWAYS;
 375   scrolled_window->hscrollbar_visible = FALSE;
 376   scrolled_window->vscrollbar_visible = FALSE;
 377   scrolled_window->focus_out = FALSE;
 378   scrolled_window->window_placement = GTK_CORNER_TOP_LEFT;
 379   gtk_scrolled_window_update_real_placement (scrolled_window);
 380 }
 381
 382 /**
 383  * gtk_scrolled_window_new:
 384  * @hadjustment: (allow-none): horizontal adjustment
 385  * @vadjustment: (allow-none): vertical adjustment
 386  *
 387  * Creates a new scrolled window.
 388  *
 389  * The two arguments are the scrolled window's adjustments; these will be
 390  * shared with the scrollbars and the child widget to keep the bars in sync
 391  * with the child. Usually you want to pass %NULL for the adjustments, which
 392  * will cause the scrolled window to create them for you.
 393  *
 394  * Returns: a new scrolled window
 395  */
 396 GtkWidget*
 397 gtk_scrolled_window_new (GtkAdjustment *hadjustment,
 398                          GtkAdjustment *vadjustment)
 399 {
 400   GtkWidget *scrolled_window;
 401
 402   if (hadjustment)
 403     g_return_val_if_fail (GTK_IS_ADJUSTMENT (hadjustment), NULL);
 404
 405   if (vadjustment)
 406     g_return_val_if_fail (GTK_IS_ADJUSTMENT (vadjustment), NULL);
 407
 408   scrolled_window = g_object_new (GTK_TYPE_SCROLLED_WINDOW,
 409                                     "hadjustment", hadjustment,
 410                                     "vadjustment", vadjustment,
 411                                     NULL);
 412
 413   return scrolled_window;
 414 }
 415
 416 /**
 417  * gtk_scrolled_window_set_hadjustment:
 418  * @scrolled_window: a #GtkScrolledWindow
 419  * @hadjustment: horizontal scroll adjustment
 420  *
 421  * Sets the #GtkAdjustment for the horizontal scrollbar.
 422  */
 423 void
 424 gtk_scrolled_window_set_hadjustment (GtkScrolledWindow *scrolled_window,
 425                                      GtkAdjustment     *hadjustment)
 426 {
 427   GtkBin *bin;
 428
 429   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 430   if (hadjustment)
 431     g_return_if_fail (GTK_IS_ADJUSTMENT (hadjustment));
 432   else
 433     hadjustment = (GtkAdjustment*) g_object_new (GTK_TYPE_ADJUSTMENT, NULL);
 434
 435   bin = GTK_BIN (scrolled_window);
 436
 437   if (!scrolled_window->hscrollbar)
 438     {
 439       gtk_widget_push_composite_child ();
 440       scrolled_window->hscrollbar = gtk_hscrollbar_new (hadjustment);
 441       gtk_widget_set_composite_name (scrolled_window->hscrollbar, "hscrollbar");
 442       gtk_widget_pop_composite_child ();
 443
 444       gtk_widget_set_parent (scrolled_window->hscrollbar, GTK_WIDGET (scrolled_window));
 445       g_object_ref (scrolled_window->hscrollbar);
 446       gtk_widget_show (scrolled_window->hscrollbar);
 447     }
 448   else
 449     {
 450       GtkAdjustment *old_adjustment;
 451
 452       old_adjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));
 453       if (old_adjustment == hadjustment)
 454         return;
 455
 456       g_signal_handlers_disconnect_by_func (old_adjustment,
 457                                             gtk_scrolled_window_adjustment_changed,
 458                                             scrolled_window);
 459       gtk_range_set_adjustment (GTK_RANGE (scrolled_window->hscrollbar),
 460                                 hadjustment);
 461     }
 462   hadjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));
 463   g_signal_connect (hadjustment,
 464                     "changed",
 465                     G_CALLBACK (gtk_scrolled_window_adjustment_changed),
 466                     scrolled_window);
 467   gtk_scrolled_window_adjustment_changed (hadjustment, scrolled_window);
 468
 469   if (bin->child)
 470     gtk_widget_set_scroll_adjustments (bin->child,
 471                                        gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
 472                                        gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)));
 473
 474   g_object_notify (G_OBJECT (scrolled_window), "hadjustment");
 475 }
 476
 477 /**
 478  * gtk_scrolled_window_set_vadjustment:
 479  * @scrolled_window: a #GtkScrolledWindow
 480  * @vadjustment: vertical scroll adjustment
 481  *
 482  * Sets the #GtkAdjustment for the vertical scrollbar.
 483  */
 484 void
 485 gtk_scrolled_window_set_vadjustment (GtkScrolledWindow *scrolled_window,
 486                                      GtkAdjustment     *vadjustment)
 487 {
 488   GtkBin *bin;
 489
 490   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 491   if (vadjustment)
 492     g_return_if_fail (GTK_IS_ADJUSTMENT (vadjustment));
 493   else
 494     vadjustment = (GtkAdjustment*) g_object_new (GTK_TYPE_ADJUSTMENT, NULL);
 495
 496   bin = GTK_BIN (scrolled_window);
 497
 498   if (!scrolled_window->vscrollbar)
 499     {
 500       gtk_widget_push_composite_child ();
 501       scrolled_window->vscrollbar = gtk_vscrollbar_new (vadjustment);
 502       gtk_widget_set_composite_name (scrolled_window->vscrollbar, "vscrollbar");
 503       gtk_widget_pop_composite_child ();
 504
 505       gtk_widget_set_parent (scrolled_window->vscrollbar, GTK_WIDGET (scrolled_window));
 506       g_object_ref (scrolled_window->vscrollbar);
 507       gtk_widget_show (scrolled_window->vscrollbar);
 508     }
 509   else
 510     {
 511       GtkAdjustment *old_adjustment;
 512
 513       old_adjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));
 514       if (old_adjustment == vadjustment)
 515         return;
 516
 517       g_signal_handlers_disconnect_by_func (old_adjustment,
 518                                             gtk_scrolled_window_adjustment_changed,
 519                                             scrolled_window);
 520       gtk_range_set_adjustment (GTK_RANGE (scrolled_window->vscrollbar),
 521                                 vadjustment);
 522     }
 523   vadjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));
 524   g_signal_connect (vadjustment,
 525                     "changed",
 526                     G_CALLBACK (gtk_scrolled_window_adjustment_changed),
 527                     scrolled_window);
 528   gtk_scrolled_window_adjustment_changed (vadjustment, scrolled_window);
 529
 530   if (bin->child)
 531     gtk_widget_set_scroll_adjustments (bin->child,
 532                                        gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
 533                                        gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)));
 534
 535   g_object_notify (G_OBJECT (scrolled_window), "vadjustment");
 536 }
 537
 538 /**
 539  * gtk_scrolled_window_get_hadjustment:
 540  * @scrolled_window: a #GtkScrolledWindow
 541  *
 542  * Returns the horizontal scrollbar's adjustment, used to connect the
 543  * horizontal scrollbar to the child widget's horizontal scroll
 544  * functionality.
 545  *
 546  * Returns: the horizontal #GtkAdjustment
 547  */
 548 GtkAdjustment*
 549 gtk_scrolled_window_get_hadjustment (GtkScrolledWindow *scrolled_window)
 550 {
 551   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);
 552
 553   return (scrolled_window->hscrollbar ?
 554           gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)) :
 555           NULL);
 556 }
 557
 558 /**
 559  * gtk_scrolled_window_get_vadjustment:
 560  * @scrolled_window: a #GtkScrolledWindow
 561  *
 562  * Returns the vertical scrollbar's adjustment, used to connect the
 563  * vertical scrollbar to the child widget's vertical scroll
 564  * functionality.
 565  *
 566  * Returns: the vertical #GtkAdjustment
 567  */
 568 GtkAdjustment*
 569 gtk_scrolled_window_get_vadjustment (GtkScrolledWindow *scrolled_window)
 570 {
 571   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);
 572
 573   return (scrolled_window->vscrollbar ?
 574           gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)) :
 575           NULL);
 576 }
 577
 578 /**
 579  * gtk_scrolled_window_get_hscrollbar:
 580  * @scrolled_window: a #GtkScrolledWindow
 581  *
 582  * Returns the horizontal scrollbar of @scrolled_window.
 583  *
 584  * Returns: the horizontal scrollbar of the scrolled window, or
 585  *  %NULL if it does not have one.
 586  *
 587  * Since: 2.8
 588  */
 589 GtkWidget*
 590 gtk_scrolled_window_get_hscrollbar (GtkScrolledWindow *scrolled_window)
 591 {
 592   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);
 593
 594   return scrolled_window->hscrollbar;
 595 }
 596
 597 /**
 598  * gtk_scrolled_window_get_vscrollbar:
 599  * @scrolled_window: a #GtkScrolledWindow
 600  *
 601  * Returns the vertical scrollbar of @scrolled_window.
 602  *
 603  * Returns: the vertical scrollbar of the scrolled window, or
 604  *  %NULL if it does not have one.
 605  *
 606  * Since: 2.8
 607  */
 608 GtkWidget*
 609 gtk_scrolled_window_get_vscrollbar (GtkScrolledWindow *scrolled_window)
 610 {
 611   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);
 612
 613   return scrolled_window->vscrollbar;
 614 }
 615
 616 /**
 617  * gtk_scrolled_window_set_policy:
 618  * @scrolled_window: a #GtkScrolledWindow
 619  * @hscrollbar_policy: policy for horizontal bar
 620  * @vscrollbar_policy: policy for vertical bar
 621  *
 622  * Sets the scrollbar policy for the horizontal and vertical scrollbars.
 623  *
 624  * The policy determines when the scrollbar should appear; it is a value
 625  * from the #GtkPolicyType enumeration. If %GTK_POLICY_ALWAYS, the
 626  * scrollbar is always present; if %GTK_POLICY_NEVER, the scrollbar is
 627  * never present; if %GTK_POLICY_AUTOMATIC, the scrollbar is present only
 628  * if needed (that is, if the slider part of the bar would be smaller
 629  * than the trough - the display is larger than the page size).
 630  */
 631 void
 632 gtk_scrolled_window_set_policy (GtkScrolledWindow *scrolled_window,
 633                                 GtkPolicyType      hscrollbar_policy,
 634                                 GtkPolicyType      vscrollbar_policy)
 635 {
 636   GObject *object = G_OBJECT (scrolled_window);
 637
 638   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 639
 640   if ((scrolled_window->hscrollbar_policy != hscrollbar_policy) ||
 641       (scrolled_window->vscrollbar_policy != vscrollbar_policy))
 642     {
 643       scrolled_window->hscrollbar_policy = hscrollbar_policy;
 644       scrolled_window->vscrollbar_policy = vscrollbar_policy;
 645
 646       gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
 647
 648       g_object_freeze_notify (object);
 649       g_object_notify (object, "hscrollbar-policy");
 650       g_object_notify (object, "vscrollbar-policy");
 651       g_object_thaw_notify (object);
 652     }
 653 }
 654
 655 /**
 656  * gtk_scrolled_window_get_policy:
 657  * @scrolled_window: a #GtkScrolledWindow
 658  * @hscrollbar_policy: location to store the policy for the horizontal
 659  *     scrollbar, or %NULL.
 660  * @vscrollbar_policy: location to store the policy for the vertical
 661  *     scrollbar, or %NULL.
 662  *
 663  * Retrieves the current policy values for the horizontal and vertical
 664  * scrollbars. See gtk_scrolled_window_set_policy().
 665  */
 666 void
 667 gtk_scrolled_window_get_policy (GtkScrolledWindow *scrolled_window,
 668                                 GtkPolicyType     *hscrollbar_policy,
 669                                 GtkPolicyType     *vscrollbar_policy)
 670 {
 671   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 672
 673   if (hscrollbar_policy)
 674     *hscrollbar_policy = scrolled_window->hscrollbar_policy;
 675   if (vscrollbar_policy)
 676     *vscrollbar_policy = scrolled_window->vscrollbar_policy;
 677 }
 678
 679 static void
 680 gtk_scrolled_window_update_real_placement (GtkScrolledWindow *scrolled_window)
 681 {
 682   GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
 683   GtkSettings *settings;
 684
 685   settings = gtk_widget_get_settings (GTK_WIDGET (scrolled_window));
 686
 687   if (priv->window_placement_set || settings == NULL)
 688     priv->real_window_placement = scrolled_window->window_placement;
 689   else
 690     g_object_get (settings,
 691                   "gtk-scrolled-window-placement",
 692                   &priv->real_window_placement,
 693                   NULL);
 694 }
 695
 696 static void
 697 gtk_scrolled_window_set_placement_internal (GtkScrolledWindow *scrolled_window,
 698                                             GtkCornerType      window_placement)
 699 {
 700   if (scrolled_window->window_placement != window_placement)
 701     {
 702       scrolled_window->window_placement = window_placement;
 703
 704       gtk_scrolled_window_update_real_placement (scrolled_window);
 705       gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
 706
 707       g_object_notify (G_OBJECT (scrolled_window), "window-placement");
 708     }
 709 }
 710
 711 static void
 712 gtk_scrolled_window_set_placement_set (GtkScrolledWindow *scrolled_window,
 713                                        gboolean           placement_set,
 714                                        gboolean           emit_resize)
 715 {
 716   GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
 717
 718   if (priv->window_placement_set != placement_set)
 719     {
 720       priv->window_placement_set = placement_set;
 721
 722       gtk_scrolled_window_update_real_placement (scrolled_window);
 723       if (emit_resize)
 724         gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
 725
 726       g_object_notify (G_OBJECT (scrolled_window), "window-placement-set");
 727     }
 728 }
 729
 730 /**
 731  * gtk_scrolled_window_set_placement:
 732  * @scrolled_window: a #GtkScrolledWindow
 733  * @window_placement: position of the child window
 734  *
 735  * Sets the placement of the contents with respect to the scrollbars
 736  * for the scrolled window.
 737  *
 738  * The default is %GTK_CORNER_TOP_LEFT, meaning the child is
 739  * in the top left, with the scrollbars underneath and to the right.
 740  * Other values in #GtkCornerType are %GTK_CORNER_TOP_RIGHT,
 741  * %GTK_CORNER_BOTTOM_LEFT, and %GTK_CORNER_BOTTOM_RIGHT.
 742  *
 743  * See also gtk_scrolled_window_get_placement() and
 744  * gtk_scrolled_window_unset_placement().
 745  */
 746 void
 747 gtk_scrolled_window_set_placement (GtkScrolledWindow *scrolled_window,
 748                                    GtkCornerType      window_placement)
 749 {
 750   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 751
 752   gtk_scrolled_window_set_placement_set (scrolled_window, TRUE, FALSE);
 753   gtk_scrolled_window_set_placement_internal (scrolled_window, window_placement);
 754 }
 755
 756 /**
 757  * gtk_scrolled_window_get_placement:
 758  * @scrolled_window: a #GtkScrolledWindow
 759  *
 760  * Gets the placement of the contents with respect to the scrollbars
 761  * for the scrolled window. See gtk_scrolled_window_set_placement().
 762  *
 763  * Return value: the current placement value.
 764  *
 765  * See also gtk_scrolled_window_set_placement() and
 766  * gtk_scrolled_window_unset_placement().
 767  **/
 768 GtkCornerType
 769 gtk_scrolled_window_get_placement (GtkScrolledWindow *scrolled_window)
 770 {
 771   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), GTK_CORNER_TOP_LEFT);
 772
 773   return scrolled_window->window_placement;
 774 }
 775
 776 /**
 777  * gtk_scrolled_window_unset_placement:
 778  * @scrolled_window: a #GtkScrolledWindow
 779  *
 780  * Unsets the placement of the contents with respect to the scrollbars
 781  * for the scrolled window. If no window placement is set for a scrolled
 782  * window, it obeys the "gtk-scrolled-window-placement" XSETTING.
 783  *
 784  * See also gtk_scrolled_window_set_placement() and
 785  * gtk_scrolled_window_get_placement().
 786  *
 787  * Since: 2.10
 788  **/
 789 void
 790 gtk_scrolled_window_unset_placement (GtkScrolledWindow *scrolled_window)
 791 {
 792   GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
 793
 794   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 795
 796   if (priv->window_placement_set)
 797     {
 798       priv->window_placement_set = FALSE;
 799
 800       gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
 801
 802       g_object_notify (G_OBJECT (scrolled_window), "window-placement-set");
 803     }
 804 }
 805
 806 /**
 807  * gtk_scrolled_window_set_shadow_type:
 808  * @scrolled_window: a #GtkScrolledWindow
 809  * @type: kind of shadow to draw around scrolled window contents
 810  *
 811  * Changes the type of shadow drawn around the contents of
 812  * @scrolled_window.
 813  *
 814  **/
 815 void
 816 gtk_scrolled_window_set_shadow_type (GtkScrolledWindow *scrolled_window,
 817                                      GtkShadowType      type)
 818 {
 819   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 820   g_return_if_fail (type >= GTK_SHADOW_NONE && type <= GTK_SHADOW_ETCHED_OUT);
 821
 822   if (scrolled_window->shadow_type != type)
 823     {
 824       scrolled_window->shadow_type = type;
 825
 826       if (gtk_widget_is_drawable (GTK_WIDGET (scrolled_window)))
 827         gtk_widget_queue_draw (GTK_WIDGET (scrolled_window));
 828
 829       gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
 830
 831       g_object_notify (G_OBJECT (scrolled_window), "shadow-type");
 832     }
 833 }
 834
 835 /**
 836  * gtk_scrolled_window_get_shadow_type:
 837  * @scrolled_window: a #GtkScrolledWindow
 838  *
 839  * Gets the shadow type of the scrolled window. See
 840  * gtk_scrolled_window_set_shadow_type().
 841  *
 842  * Return value: the current shadow type
 843  **/
 844 GtkShadowType
 845 gtk_scrolled_window_get_shadow_type (GtkScrolledWindow *scrolled_window)
 846 {
 847   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_NONE);
 848
 849   return scrolled_window->shadow_type;
 850 }
 851
 852 static void
 853 gtk_scrolled_window_destroy (GtkObject *object)
 854 {
 855   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (object);
 856
 857   if (scrolled_window->hscrollbar)
 858     {
 859       g_signal_handlers_disconnect_by_func (gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
 860                                             gtk_scrolled_window_adjustment_changed,
 861                                             scrolled_window);
 862       gtk_widget_unparent (scrolled_window->hscrollbar);
 863       gtk_widget_destroy (scrolled_window->hscrollbar);
 864       g_object_unref (scrolled_window->hscrollbar);
 865       scrolled_window->hscrollbar = NULL;
 866     }
 867   if (scrolled_window->vscrollbar)
 868     {
 869       g_signal_handlers_disconnect_by_func (gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)),
 870                                             gtk_scrolled_window_adjustment_changed,
 871                                             scrolled_window);
 872       gtk_widget_unparent (scrolled_window->vscrollbar);
 873       gtk_widget_destroy (scrolled_window->vscrollbar);
 874       g_object_unref (scrolled_window->vscrollbar);
 875       scrolled_window->vscrollbar = NULL;
 876     }
 877
 878   GTK_OBJECT_CLASS (gtk_scrolled_window_parent_class)->destroy (object);
 879 }
 880
 881 static void
 882 gtk_scrolled_window_set_property (GObject      *object,
 883                                   guint         prop_id,
 884                                   const GValue *value,
 885                                   GParamSpec   *pspec)
 886 {
 887   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (object);
 888
 889   switch (prop_id)
 890     {
 891     case PROP_HADJUSTMENT:
 892       gtk_scrolled_window_set_hadjustment (scrolled_window,
 893                                            g_value_get_object (value));
 894       break;
 895     case PROP_VADJUSTMENT:
 896       gtk_scrolled_window_set_vadjustment (scrolled_window,
 897                                            g_value_get_object (value));
 898       break;
 899     case PROP_HSCROLLBAR_POLICY:
 900       gtk_scrolled_window_set_policy (scrolled_window,
 901                                       g_value_get_enum (value),
 902                                       scrolled_window->vscrollbar_policy);
 903       break;
 904     case PROP_VSCROLLBAR_POLICY:
 905       gtk_scrolled_window_set_policy (scrolled_window,
 906                                       scrolled_window->hscrollbar_policy,
 907                                       g_value_get_enum (value));
 908       break;
 909     case PROP_WINDOW_PLACEMENT:
 910       gtk_scrolled_window_set_placement_internal (scrolled_window,
 911                                                   g_value_get_enum (value));
 912       break;
 913     case PROP_WINDOW_PLACEMENT_SET:
 914       gtk_scrolled_window_set_placement_set (scrolled_window,
 915                                              g_value_get_boolean (value),
 916                                              TRUE);
 917       break;
 918     case PROP_SHADOW_TYPE:
 919       gtk_scrolled_window_set_shadow_type (scrolled_window,
 920                                            g_value_get_enum (value));
 921       break;
 922     default:
 923       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 924       break;
 925     }
 926 }
 927
 928 static void
 929 gtk_scrolled_window_get_property (GObject    *object,
 930                                   guint       prop_id,
 931                                   GValue     *value,
 932                                   GParamSpec *pspec)
 933 {
 934   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (object);
 935   GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
 936
 937   switch (prop_id)
 938     {
 939     case PROP_HADJUSTMENT:
 940       g_value_set_object (value,
 941                           G_OBJECT (gtk_scrolled_window_get_hadjustment (scrolled_window)));
 942       break;
 943     case PROP_VADJUSTMENT:
 944       g_value_set_object (value,
 945                           G_OBJECT (gtk_scrolled_window_get_vadjustment (scrolled_window)));
 946       break;
 947     case PROP_HSCROLLBAR_POLICY:
 948       g_value_set_enum (value, scrolled_window->hscrollbar_policy);
 949       break;
 950     case PROP_VSCROLLBAR_POLICY:
 951       g_value_set_enum (value, scrolled_window->vscrollbar_policy);
 952       break;
 953     case PROP_WINDOW_PLACEMENT:
 954       g_value_set_enum (value, scrolled_window->window_placement);
 955       break;
 956     case PROP_WINDOW_PLACEMENT_SET:
 957       g_value_set_boolean (value, priv->window_placement_set);
 958       break;
 959     case PROP_SHADOW_TYPE:
 960       g_value_set_enum (value, scrolled_window->shadow_type);
 961       break;
 962     default:
 963       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 964       break;
 965     }
 966 }
 967
 968 static void
 969 traverse_container (GtkWidget *widget,
 970                     gpointer   data)
 971 {
 972   if (GTK_IS_SCROLLED_WINDOW (widget))
 973     {
 974       gtk_scrolled_window_update_real_placement (GTK_SCROLLED_WINDOW (widget));
 975       gtk_widget_queue_resize (widget);
 976     }
 977   else if (GTK_IS_CONTAINER (widget))
 978     gtk_container_forall (GTK_CONTAINER (widget), traverse_container, NULL);
 979 }
 980
 981 static void
 982 gtk_scrolled_window_settings_changed (GtkSettings *settings)
 983 {
 984   GList *list, *l;
 985
 986   list = gtk_window_list_toplevels ();
 987
 988   for (l = list; l; l = l->next)
 989     gtk_container_forall (GTK_CONTAINER (l->data),
 990                           traverse_container, NULL);
 991
 992   g_list_free (list);
 993 }
 994
 995 static void
 996 gtk_scrolled_window_screen_changed (GtkWidget *widget,
 997                                     GdkScreen *previous_screen)
 998 {
 999   GtkSettings *settings;
1000   guint window_placement_connection;
1001
1002   gtk_scrolled_window_update_real_placement (GTK_SCROLLED_WINDOW (widget));
1003
1004   if (!gtk_widget_has_screen (widget))
1005     return;
1006
1007   settings = gtk_widget_get_settings (widget);
1008
1009   window_placement_connection =
1010     GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (settings),
1011                                          "gtk-scrolled-window-connection"));
1012
1013   if (window_placement_connection)
1014     return;
1015
1016   window_placement_connection =
1017     g_signal_connect (settings, "notify::gtk-scrolled-window-placement",
1018                       G_CALLBACK (gtk_scrolled_window_settings_changed), NULL);
1019   g_object_set_data (G_OBJECT (settings),
1020                      I_("gtk-scrolled-window-connection"),
1021                      GUINT_TO_POINTER (window_placement_connection));
1022 }
1023
1024 static void
1025 gtk_scrolled_window_paint (GtkWidget    *widget,
1026                            GdkRectangle *area)
1027 {
1028   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
1029
1030   if (scrolled_window->shadow_type != GTK_SHADOW_NONE)
1031     {
1032       GtkAllocation relative_allocation;
1033       gboolean scrollbars_within_bevel;
1034
1035       gtk_widget_style_get (widget, "scrollbars-within-bevel", &scrollbars_within_bevel, NULL);
1036
1037       if (!scrollbars_within_bevel)
1038         {
1039           gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
1040
1041           relative_allocation.x -= widget->style->xthickness;
1042           relative_allocation.y -= widget->style->ythickness;
1043           relative_allocation.width += 2 * widget->style->xthickness;
1044           relative_allocation.height += 2 * widget->style->ythickness;
1045         }
1046       else
1047         {
1048           GtkContainer *container = GTK_CONTAINER (widget);
1049
1050           relative_allocation.x = container->border_width;
1051           relative_allocation.y = container->border_width;
1052           relative_allocation.width = widget->allocation.width - 2 * container->border_width;
1053           relative_allocation.height = widget->allocation.height - 2 * container->border_width;
1054         }
1055
1056       gtk_paint_shadow (widget->style, widget->window,
1057                         GTK_STATE_NORMAL, scrolled_window->shadow_type,
1058                         area, widget, "scrolled_window",
1059                         widget->allocation.x + relative_allocation.x,
1060                         widget->allocation.y + relative_allocation.y,
1061                         relative_allocation.width,
1062                         relative_allocation.height);
1063     }
1064 }
1065
1066 static gboolean
1067 gtk_scrolled_window_expose (GtkWidget      *widget,
1068                             GdkEventExpose *event)
1069 {
1070   if (gtk_widget_is_drawable (widget))
1071     {
1072       gtk_scrolled_window_paint (widget, &event->area);
1073
1074       GTK_WIDGET_CLASS (gtk_scrolled_window_parent_class)->expose_event (widget, event);
1075     }
1076
1077   return FALSE;
1078 }
1079
1080 static void
1081 gtk_scrolled_window_forall (GtkContainer *container,
1082                             gboolean      include_internals,
1083                             GtkCallback   callback,
1084                             gpointer      callback_data)
1085 {
1086   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (container));
1087   g_return_if_fail (callback != NULL);
1088
1089   GTK_CONTAINER_CLASS (gtk_scrolled_window_parent_class)->forall (container,
1090                                               include_internals,
1091                                               callback,
1092                                               callback_data);
1093   if (include_internals)
1094     {
1095       GtkScrolledWindow *scrolled_window;
1096
1097       scrolled_window = GTK_SCROLLED_WINDOW (container);
1098
1099       if (scrolled_window->vscrollbar)
1100         callback (scrolled_window->vscrollbar, callback_data);
1101       if (scrolled_window->hscrollbar)
1102         callback (scrolled_window->hscrollbar, callback_data);
1103     }
1104 }
1105
1106 static gboolean
1107 gtk_scrolled_window_scroll_child (GtkScrolledWindow *scrolled_window,
1108                                   GtkScrollType      scroll,
1109                                   gboolean           horizontal)
1110 {
1111   GtkAdjustment *adjustment = NULL;
1112
1113   switch (scroll)
1114     {
1115     case GTK_SCROLL_STEP_UP:
1116       scroll = GTK_SCROLL_STEP_BACKWARD;
1117       horizontal = FALSE;
1118       break;
1119     case GTK_SCROLL_STEP_DOWN:
1120       scroll = GTK_SCROLL_STEP_FORWARD;
1121       horizontal = FALSE;
1122       break;
1123     case GTK_SCROLL_STEP_LEFT:
1124       scroll = GTK_SCROLL_STEP_BACKWARD;
1125       horizontal = TRUE;
1126       break;
1127     case GTK_SCROLL_STEP_RIGHT:
1128       scroll = GTK_SCROLL_STEP_FORWARD;
1129       horizontal = TRUE;
1130       break;
1131     case GTK_SCROLL_PAGE_UP:
1132       scroll = GTK_SCROLL_PAGE_BACKWARD;
1133       horizontal = FALSE;
1134       break;
1135     case GTK_SCROLL_PAGE_DOWN:
1136       scroll = GTK_SCROLL_PAGE_FORWARD;
1137       horizontal = FALSE;
1138       break;
1139     case GTK_SCROLL_PAGE_LEFT:
1140       scroll = GTK_SCROLL_STEP_BACKWARD;
1141       horizontal = TRUE;
1142       break;
1143     case GTK_SCROLL_PAGE_RIGHT:
1144       scroll = GTK_SCROLL_STEP_FORWARD;
1145       horizontal = TRUE;
1146       break;
1147     case GTK_SCROLL_STEP_BACKWARD:
1148     case GTK_SCROLL_STEP_FORWARD:
1149     case GTK_SCROLL_PAGE_BACKWARD:
1150     case GTK_SCROLL_PAGE_FORWARD:
1151     case GTK_SCROLL_START:
1152     case GTK_SCROLL_END:
1153       break;
1154     default:
1155       g_warning ("Invalid scroll type %u for GtkScrolledWindow::scroll-child", scroll);
1156       return FALSE;
1157     }
1158
1159   if ((horizontal && (!scrolled_window->hscrollbar || !scrolled_window->hscrollbar_visible)) ||
1160       (!horizontal && (!scrolled_window->vscrollbar || !scrolled_window->vscrollbar_visible)))
1161     return FALSE;
1162
1163   if (horizontal)
1164     {
1165       if (scrolled_window->hscrollbar)
1166         adjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));
1167     }
1168   else
1169     {
1170       if (scrolled_window->vscrollbar)
1171         adjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));
1172     }
1173
1174   if (adjustment)
1175     {
1176       gdouble value = adjustment->value;
1177
1178       switch (scroll)
1179         {
1180         case GTK_SCROLL_STEP_FORWARD:
1181           value += adjustment->step_increment;
1182           break;
1183         case GTK_SCROLL_STEP_BACKWARD:
1184           value -= adjustment->step_increment;
1185           break;
1186         case GTK_SCROLL_PAGE_FORWARD:
1187           value += adjustment->page_increment;
1188           break;
1189         case GTK_SCROLL_PAGE_BACKWARD:
1190           value -= adjustment->page_increment;
1191           break;
1192         case GTK_SCROLL_START:
1193           value = adjustment->lower;
1194           break;
1195         case GTK_SCROLL_END:
1196           value = adjustment->upper;
1197           break;
1198         default:
1199           g_assert_not_reached ();
1200           break;
1201         }
1202
1203       value = CLAMP (value, adjustment->lower, adjustment->upper - adjustment->page_size);
1204
1205       gtk_adjustment_set_value (adjustment, value);
1206
1207       return TRUE;
1208     }
1209
1210   return FALSE;
1211 }
1212
1213 static void
1214 gtk_scrolled_window_move_focus_out (GtkScrolledWindow *scrolled_window,
1215                                     GtkDirectionType   direction_type)
1216 {
1217   GtkWidget *toplevel;
1218
1219   /* Focus out of the scrolled window entirely. We do this by setting
1220    * a flag, then propagating the focus motion to the notebook.
1221    */
1222   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (scrolled_window));
1223   if (!gtk_widget_is_toplevel (toplevel))
1224     return;
1225
1226   g_object_ref (scrolled_window);
1227
1228   scrolled_window->focus_out = TRUE;
1229   g_signal_emit_by_name (toplevel, "move-focus", direction_type);
1230   scrolled_window->focus_out = FALSE;
1231
1232   g_object_unref (scrolled_window);
1233 }
1234
1235 static void
1236 gtk_scrolled_window_relative_allocation (GtkWidget     *widget,
1237                                          GtkAllocation *allocation)
1238 {
1239   GtkScrolledWindow *scrolled_window;
1240   GtkScrolledWindowPrivate *priv;
1241   gint scrollbar_spacing;
1242
1243   g_return_if_fail (widget != NULL);
1244   g_return_if_fail (allocation != NULL);
1245
1246   scrolled_window = GTK_SCROLLED_WINDOW (widget);
1247   scrollbar_spacing = _gtk_scrolled_window_get_scrollbar_spacing (scrolled_window);
1248
1249   priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
1250
1251   allocation->x = GTK_CONTAINER (widget)->border_width;
1252   allocation->y = GTK_CONTAINER (widget)->border_width;
1253
1254   if (scrolled_window->shadow_type != GTK_SHADOW_NONE)
1255     {
1256       allocation->x += widget->style->xthickness;
1257       allocation->y += widget->style->ythickness;
1258     }
1259
1260   allocation->width = MAX (1, (gint)widget->allocation.width - allocation->x * 2);
1261   allocation->height = MAX (1, (gint)widget->allocation.height - allocation->y * 2);
1262
1263   if (scrolled_window->vscrollbar_visible)
1264     {
1265       GtkRequisition vscrollbar_requisition;
1266       gboolean is_rtl;
1267
1268       gtk_widget_get_child_requisition (scrolled_window->vscrollbar,
1269                                         &vscrollbar_requisition);
1270       is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
1271
1272       if ((!is_rtl &&
1273            (priv->real_window_placement == GTK_CORNER_TOP_RIGHT ||
1274             priv->real_window_placement == GTK_CORNER_BOTTOM_RIGHT)) ||
1275           (is_rtl &&
1276            (priv->real_window_placement == GTK_CORNER_TOP_LEFT ||
1277             priv->real_window_placement == GTK_CORNER_BOTTOM_LEFT)))
1278         allocation->x += (vscrollbar_requisition.width +  scrollbar_spacing);
1279
1280       allocation->width = MAX (1, allocation->width - (vscrollbar_requisition.width + scrollbar_spacing));
1281     }
1282   if (scrolled_window->hscrollbar_visible)
1283     {
1284       GtkRequisition hscrollbar_requisition;
1285       gtk_widget_get_child_requisition (scrolled_window->hscrollbar,
1286                                         &hscrollbar_requisition);
1287
1288       if (priv->real_window_placement == GTK_CORNER_BOTTOM_LEFT ||
1289           priv->real_window_placement == GTK_CORNER_BOTTOM_RIGHT)
1290         allocation->y += (hscrollbar_requisition.height + scrollbar_spacing);
1291
1292       allocation->height = MAX (1, allocation->height - (hscrollbar_requisition.height + scrollbar_spacing));
1293     }
1294 }
1295
1296 static void
1297 gtk_scrolled_window_size_allocate (GtkWidget     *widget,
1298                                    GtkAllocation *allocation)
1299 {
1300   GtkScrolledWindow *scrolled_window;
1301   GtkScrolledWindowPrivate *priv;
1302   GtkBin *bin;
1303   GtkAllocation relative_allocation;
1304   GtkAllocation child_allocation;
1305   gboolean scrollbars_within_bevel;
1306   gint scrollbar_spacing;
1307
1308   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
1309   g_return_if_fail (allocation != NULL);
1310
1311   scrolled_window = GTK_SCROLLED_WINDOW (widget);
1312   bin = GTK_BIN (scrolled_window);
1313
1314   scrollbar_spacing = _gtk_scrolled_window_get_scrollbar_spacing (scrolled_window);
1315   gtk_widget_style_get (widget, "scrollbars-within-bevel", &scrollbars_within_bevel, NULL);
1316
1317   priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
1318
1319   widget->allocation = *allocation;
1320
1321   if (scrolled_window->hscrollbar_policy == GTK_POLICY_ALWAYS)
1322     scrolled_window->hscrollbar_visible = TRUE;
1323   else if (scrolled_window->hscrollbar_policy == GTK_POLICY_NEVER)
1324     scrolled_window->hscrollbar_visible = FALSE;
1325   if (scrolled_window->vscrollbar_policy == GTK_POLICY_ALWAYS)
1326     scrolled_window->vscrollbar_visible = TRUE;
1327   else if (scrolled_window->vscrollbar_policy == GTK_POLICY_NEVER)
1328     scrolled_window->vscrollbar_visible = FALSE;
1329
1330   if (bin->child && gtk_widget_get_visible (bin->child))
1331     {
1332       gboolean previous_hvis;
1333       gboolean previous_vvis;
1334       guint count = 0;
1335
1336       do
1337         {
1338           gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
1339
1340           child_allocation.x = relative_allocation.x + allocation->x;
1341           child_allocation.y = relative_allocation.y + allocation->y;
1342           child_allocation.width = relative_allocation.width;
1343           child_allocation.height = relative_allocation.height;
1344
1345           previous_hvis = scrolled_window->hscrollbar_visible;
1346           previous_vvis = scrolled_window->vscrollbar_visible;
1347
1348           gtk_widget_size_allocate (bin->child, &child_allocation);
1349
1350           /* If, after the first iteration, the hscrollbar and the
1351            * vscrollbar flip visiblity, then we need both.
1352            */
1353           if (count &&
1354               previous_hvis != scrolled_window->hscrollbar_visible &&
1355               previous_vvis != scrolled_window->vscrollbar_visible)
1356             {
1357               scrolled_window->hscrollbar_visible = TRUE;
1358               scrolled_window->vscrollbar_visible = TRUE;
1359
1360               /* a new resize is already queued at this point,
1361                * so we will immediatedly get reinvoked
1362                */
1363               return;
1364             }
1365
1366           count++;
1367         }
1368       while (previous_hvis != scrolled_window->hscrollbar_visible ||
1369              previous_vvis != scrolled_window->vscrollbar_visible);
1370     }
1371   else
1372     {
1373       scrolled_window->hscrollbar_visible = scrolled_window->hscrollbar_policy == GTK_POLICY_ALWAYS;
1374       scrolled_window->vscrollbar_visible = scrolled_window->vscrollbar_policy == GTK_POLICY_ALWAYS;
1375       gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
1376     }
1377
1378   if (scrolled_window->hscrollbar_visible)
1379     {
1380       GtkRequisition hscrollbar_requisition;
1381       gtk_widget_get_child_requisition (scrolled_window->hscrollbar,
1382                                         &hscrollbar_requisition);
1383
1384       if (!gtk_widget_get_visible (scrolled_window->hscrollbar))
1385         gtk_widget_show (scrolled_window->hscrollbar);
1386
1387       child_allocation.x = relative_allocation.x;
1388       if (priv->real_window_placement == GTK_CORNER_TOP_LEFT ||
1389           priv->real_window_placement == GTK_CORNER_TOP_RIGHT)
1390         child_allocation.y = (relative_allocation.y +
1391                               relative_allocation.height +
1392                               scrollbar_spacing +
1393                               (scrolled_window->shadow_type == GTK_SHADOW_NONE ?
1394                                0 : widget->style->ythickness));
1395       else
1396         child_allocation.y = GTK_CONTAINER (scrolled_window)->border_width;
1397
1398       child_allocation.width = relative_allocation.width;
1399       child_allocation.height = hscrollbar_requisition.height;
1400       child_allocation.x += allocation->x;
1401       child_allocation.y += allocation->y;
1402
1403       if (scrolled_window->shadow_type != GTK_SHADOW_NONE)
1404         {
1405           if (!scrollbars_within_bevel)
1406             {
1407               child_allocation.x -= widget->style->xthickness;
1408               child_allocation.width += 2 * widget->style->xthickness;
1409             }
1410           else if (GTK_CORNER_TOP_RIGHT == priv->real_window_placement ||
1411                    GTK_CORNER_TOP_LEFT == priv->real_window_placement)
1412             {
1413               child_allocation.y -= widget->style->ythickness;
1414             }
1415           else
1416             {
1417               child_allocation.y += widget->style->ythickness;
1418             }
1419         }
1420
1421       gtk_widget_size_allocate (scrolled_window->hscrollbar, &child_allocation);
1422     }
1423   else if (gtk_widget_get_visible (scrolled_window->hscrollbar))
1424     gtk_widget_hide (scrolled_window->hscrollbar);
1425
1426   if (scrolled_window->vscrollbar_visible)
1427     {
1428       GtkRequisition vscrollbar_requisition;
1429       if (!gtk_widget_get_visible (scrolled_window->vscrollbar))
1430         gtk_widget_show (scrolled_window->vscrollbar);
1431
1432       gtk_widget_get_child_requisition (scrolled_window->vscrollbar,
1433                                         &vscrollbar_requisition);
1434
1435       if ((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL &&
1436            (priv->real_window_placement == GTK_CORNER_TOP_RIGHT ||
1437             priv->real_window_placement == GTK_CORNER_BOTTOM_RIGHT)) ||
1438           (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR &&
1439            (priv->real_window_placement == GTK_CORNER_TOP_LEFT ||
1440             priv->real_window_placement == GTK_CORNER_BOTTOM_LEFT)))
1441         child_allocation.x = (relative_allocation.x +
1442                               relative_allocation.width +
1443                               scrollbar_spacing +
1444                               (scrolled_window->shadow_type == GTK_SHADOW_NONE ?
1445                                0 : widget->style->xthickness));
1446       else
1447         child_allocation.x = GTK_CONTAINER (scrolled_window)->border_width;
1448
1449       child_allocation.y = relative_allocation.y;
1450       child_allocation.width = vscrollbar_requisition.width;
1451       child_allocation.height = relative_allocation.height;
1452       child_allocation.x += allocation->x;
1453       child_allocation.y += allocation->y;
1454
1455       if (scrolled_window->shadow_type != GTK_SHADOW_NONE)
1456         {
1457           if (!scrollbars_within_bevel)
1458             {
1459               child_allocation.y -= widget->style->ythickness;
1460               child_allocation.height += 2 * widget->style->ythickness;
1461             }
1462           else if (GTK_CORNER_BOTTOM_LEFT == priv->real_window_placement ||
1463                    GTK_CORNER_TOP_LEFT == priv->real_window_placement)
1464             {
1465               child_allocation.x -= widget->style->xthickness;
1466             }
1467           else
1468             {
1469               child_allocation.x += widget->style->xthickness;
1470             }
1471         }
1472
1473       gtk_widget_size_allocate (scrolled_window->vscrollbar, &child_allocation);
1474     }
1475   else if (gtk_widget_get_visible (scrolled_window->vscrollbar))
1476     gtk_widget_hide (scrolled_window->vscrollbar);
1477 }
1478
1479 static gboolean
1480 gtk_scrolled_window_scroll_event (GtkWidget      *widget,
1481                                   GdkEventScroll *event)
1482 {
1483   GtkWidget *range;
1484
1485   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (widget), FALSE);
1486   g_return_val_if_fail (event != NULL, FALSE);
1487
1488   if (event->direction == GDK_SCROLL_UP || event->direction == GDK_SCROLL_DOWN)
1489     range = GTK_SCROLLED_WINDOW (widget)->vscrollbar;
1490   else
1491     range = GTK_SCROLLED_WINDOW (widget)->hscrollbar;
1492
1493   if (range && gtk_widget_get_visible (range))
1494     {
1495       GtkAdjustment *adj = GTK_RANGE (range)->adjustment;
1496       gdouble delta, new_value;
1497
1498       delta = _gtk_range_get_wheel_delta (GTK_RANGE (range), event->direction);
1499
1500       new_value = CLAMP (adj->value + delta, adj->lower, adj->upper - adj->page_size);
1501
1502       gtk_adjustment_set_value (adj, new_value);
1503
1504       return TRUE;
1505     }
1506
1507   return FALSE;
1508 }
1509
1510 static gboolean
1511 gtk_scrolled_window_focus (GtkWidget        *widget,
1512                            GtkDirectionType  direction)
1513 {
1514   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
1515   gboolean had_focus_child = GTK_CONTAINER (widget)->focus_child != NULL;
1516
1517   if (scrolled_window->focus_out)
1518     {
1519       scrolled_window->focus_out = FALSE; /* Clear this to catch the wrap-around case */
1520       return FALSE;
1521     }
1522
1523   if (gtk_widget_is_focus (widget))
1524     return FALSE;
1525
1526   /* We only put the scrolled window itself in the focus chain if it
1527    * isn't possible to focus any children.
1528    */
1529   if (GTK_BIN (widget)->child)
1530     {
1531       if (gtk_widget_child_focus (GTK_BIN (widget)->child, direction))
1532         return TRUE;
1533     }
1534
1535   if (!had_focus_child && gtk_widget_get_can_focus (widget))
1536     {
1537       gtk_widget_grab_focus (widget);
1538       return TRUE;
1539     }
1540   else
1541     return FALSE;
1542 }
1543
1544 static void
1545 gtk_scrolled_window_adjustment_changed (GtkAdjustment *adjustment,
1546                                         gpointer       data)
1547 {
1548   GtkScrolledWindow *scrolled_win;
1549
1550   g_return_if_fail (adjustment != NULL);
1551   g_return_if_fail (data != NULL);
1552
1553   scrolled_win = GTK_SCROLLED_WINDOW (data);
1554
1555   if (scrolled_win->hscrollbar &&
1556       adjustment == gtk_range_get_adjustment (GTK_RANGE (scrolled_win->hscrollbar)))
1557     {
1558       if (scrolled_win->hscrollbar_policy == GTK_POLICY_AUTOMATIC)
1559         {
1560           gboolean visible;
1561
1562           visible = scrolled_win->hscrollbar_visible;
1563           scrolled_win->hscrollbar_visible = (adjustment->upper - adjustment->lower >
1564                                               adjustment->page_size);
1565           if (scrolled_win->hscrollbar_visible != visible)
1566             gtk_widget_queue_resize (GTK_WIDGET (scrolled_win));
1567         }
1568     }
1569   else if (scrolled_win->vscrollbar &&
1570            adjustment == gtk_range_get_adjustment (GTK_RANGE (scrolled_win->vscrollbar)))
1571     {
1572       if (scrolled_win->vscrollbar_policy == GTK_POLICY_AUTOMATIC)
1573         {
1574           gboolean visible;
1575
1576           visible = scrolled_win->vscrollbar_visible;
1577           scrolled_win->vscrollbar_visible = (adjustment->upper - adjustment->lower >
1578                                               adjustment->page_size);
1579           if (scrolled_win->vscrollbar_visible != visible)
1580             gtk_widget_queue_resize (GTK_WIDGET (scrolled_win));
1581         }
1582     }
1583 }
1584
1585 static void
1586 gtk_scrolled_window_add (GtkContainer *container,
1587                          GtkWidget    *child)
1588 {
1589   GtkScrolledWindow *scrolled_window;
1590   GtkBin *bin;
1591
1592   bin = GTK_BIN (container);
1593   g_return_if_fail (bin->child == NULL);
1594
1595   scrolled_window = GTK_SCROLLED_WINDOW (container);
1596
1597   bin->child = child;
1598   gtk_widget_set_parent (child, GTK_WIDGET (bin));
1599
1600   /* this is a temporary message */
1601   if (!gtk_widget_set_scroll_adjustments (child,
1602                                           gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
1603                                           gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar))))
1604     g_warning ("gtk_scrolled_window_add(): cannot add non scrollable widget "
1605                "use gtk_scrolled_window_add_with_viewport() instead");
1606 }
1607
1608 static void
1609 gtk_scrolled_window_remove (GtkContainer *container,
1610                             GtkWidget    *child)
1611 {
1612   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (container));
1613   g_return_if_fail (child != NULL);
1614   g_return_if_fail (GTK_BIN (container)->child == child);
1615
1616   gtk_widget_set_scroll_adjustments (child, NULL, NULL);
1617
1618   /* chain parent class handler to remove child */
1619   GTK_CONTAINER_CLASS (gtk_scrolled_window_parent_class)->remove (container, child);
1620 }
1621
1622 /**
1623  * gtk_scrolled_window_add_with_viewport:
1624  * @scrolled_window: a #GtkScrolledWindow
1625  * @child: the widget you want to scroll
1626  *
1627  * Used to add children without native scrolling capabilities. This
1628  * is simply a convenience function; it is equivalent to adding the
1629  * unscrollable child to a viewport, then adding the viewport to the
1630  * scrolled window. If a child has native scrolling, use
1631  * gtk_container_add() instead of this function.
1632  *
1633  * The viewport scrolls the child by moving its #GdkWindow, and takes
1634  * the size of the child to be the size of its toplevel #GdkWindow.
1635  * This will be very wrong for most widgets that support native scrolling;
1636  * for example, if you add a widget such as #GtkTreeView with a viewport,
1637  * the whole widget will scroll, including the column headings. Thus,
1638  * widgets with native scrolling support should not be used with the
1639  * #GtkViewport proxy.
1640  *
1641  * A widget supports scrolling natively if the
1642  * set_scroll_adjustments_signal field in #GtkWidgetClass is non-zero,
1643  * i.e. has been filled in with a valid signal identifier.
1644  */
1645 void
1646 gtk_scrolled_window_add_with_viewport (GtkScrolledWindow *scrolled_window,
1647                                        GtkWidget         *child)
1648 {
1649   GtkBin *bin;
1650   GtkWidget *viewport;
1651
1652   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
1653   g_return_if_fail (GTK_IS_WIDGET (child));
1654   g_return_if_fail (child->parent == NULL);
1655
1656   bin = GTK_BIN (scrolled_window);
1657
1658   if (bin->child != NULL)
1659     {
1660       g_return_if_fail (GTK_IS_VIEWPORT (bin->child));
1661       g_return_if_fail (GTK_BIN (bin->child)->child == NULL);
1662
1663       viewport = bin->child;
1664     }
1665   else
1666     {
1667       viewport =
1668         gtk_viewport_new (gtk_scrolled_window_get_hadjustment (scrolled_window),
1669                           gtk_scrolled_window_get_vadjustment (scrolled_window));
1670       gtk_container_add (GTK_CONTAINER (scrolled_window), viewport);
1671     }
1672
1673   gtk_widget_show (viewport);
1674   gtk_container_add (GTK_CONTAINER (viewport), child);
1675 }
1676
1677 /*
1678  * _gtk_scrolled_window_get_spacing:
1679  * @scrolled_window: a scrolled window
1680  *
1681  * Gets the spacing between the scrolled window's scrollbars and
1682  * the scrolled widget. Used by GtkCombo
1683  *
1684  * Return value: the spacing, in pixels.
1685  */
1686 gint
1687 _gtk_scrolled_window_get_scrollbar_spacing (GtkScrolledWindow *scrolled_window)
1688 {
1689   GtkScrolledWindowClass *class;
1690
1691   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), 0);
1692
1693   class = GTK_SCROLLED_WINDOW_GET_CLASS (scrolled_window);
1694
1695   if (class->scrollbar_spacing >= 0)
1696     return class->scrollbar_spacing;
1697   else
1698     {
1699       gint scrollbar_spacing;
1700
1701       gtk_widget_style_get (GTK_WIDGET (scrolled_window),
1702                             "scrollbar-spacing", &scrollbar_spacing,
1703                             NULL);
1704
1705       return scrollbar_spacing;
1706     }
1707 }
1708
1709 static void
1710 gtk_scrolled_window_extended_layout_get_desired_size (GtkExtendedLayout *layout,
1711                                                       GtkRequisition    *minimum_size,
1712                                                       GtkRequisition    *natural_size)
1713 {
1714   GtkScrolledWindow *scrolled_window;
1715   GtkBin *bin;
1716   gint extra_width;
1717   gint extra_height;
1718   gint scrollbar_spacing;
1719   GtkRequisition hscrollbar_requisition;
1720   GtkRequisition vscrollbar_requisition;
1721   GtkRequisition min_child_requisition;
1722   GtkRequisition nat_child_requisition;
1723
1724   scrolled_window = GTK_SCROLLED_WINDOW (layout);
1725   bin = GTK_BIN (scrolled_window);
1726
1727   scrollbar_spacing = _gtk_scrolled_window_get_scrollbar_spacing (scrolled_window);
1728
1729   extra_width = 0;
1730   extra_height = 0;
1731   minimum_size->width = 0;
1732   minimum_size->height = 0;
1733   natural_size->width = 0;
1734   natural_size->height = 0;
1735
1736   gtk_widget_size_request (scrolled_window->hscrollbar,
1737                            &hscrollbar_requisition);
1738   gtk_widget_size_request (scrolled_window->vscrollbar,
1739                            &vscrollbar_requisition);
1740
1741   if (bin->child && gtk_widget_get_visible (bin->child))
1742     {
1743       gtk_widget_get_desired_size (bin->child,
1744                                    &min_child_requisition,
1745                                    &nat_child_requisition);
1746
1747       if (scrolled_window->hscrollbar_policy == GTK_POLICY_NEVER)
1748         {
1749           minimum_size->width += min_child_requisition.width;
1750           natural_size->width += nat_child_requisition.width;
1751         }
1752       else
1753         {
1754           GtkWidgetAuxInfo *aux_info = _gtk_widget_get_aux_info (bin->child, FALSE);
1755
1756           if (aux_info && aux_info->width > 0)
1757             {
1758               minimum_size->width += aux_info->width;
1759               natural_size->width += aux_info->width;
1760               extra_width = -1;
1761             }
1762           else
1763             {
1764               minimum_size->width += vscrollbar_requisition.width;
1765               natural_size->width += vscrollbar_requisition.width;
1766             }
1767         }
1768
1769       if (scrolled_window->vscrollbar_policy == GTK_POLICY_NEVER)
1770         {
1771           minimum_size->height += min_child_requisition.height;
1772           natural_size->height += nat_child_requisition.height;
1773         }
1774       else
1775         {
1776           GtkWidgetAuxInfo *aux_info = _gtk_widget_get_aux_info (bin->child, FALSE);
1777
1778           if (aux_info && aux_info->height > 0)
1779             {
1780               minimum_size->height += aux_info->height;
1781               natural_size->height += aux_info->height;
1782               extra_height = -1;
1783             }
1784           else
1785             {
1786               minimum_size->height += hscrollbar_requisition.height;
1787               natural_size->height += hscrollbar_requisition.height;
1788             }
1789         }
1790     }
1791
1792   if (scrolled_window->hscrollbar_policy == GTK_POLICY_AUTOMATIC ||
1793       scrolled_window->hscrollbar_policy == GTK_POLICY_ALWAYS)
1794     {
1795       minimum_size->width = MAX (minimum_size->width, hscrollbar_requisition.width);
1796       natural_size->width = MAX (natural_size->width, hscrollbar_requisition.width);
1797       if (!extra_height || scrolled_window->hscrollbar_policy == GTK_POLICY_ALWAYS)
1798         extra_height = scrollbar_spacing + hscrollbar_requisition.height;
1799     }
1800
1801   if (scrolled_window->vscrollbar_policy == GTK_POLICY_AUTOMATIC ||
1802       scrolled_window->vscrollbar_policy == GTK_POLICY_ALWAYS)
1803     {
1804       minimum_size->height = MAX (minimum_size->height, vscrollbar_requisition.height);
1805       natural_size->height = MAX (natural_size->height, vscrollbar_requisition.height);
1806       if (!extra_height || scrolled_window->vscrollbar_policy == GTK_POLICY_ALWAYS)
1807         extra_width = scrollbar_spacing + vscrollbar_requisition.width;
1808     }
1809
1810   minimum_size->width += GTK_CONTAINER (layout)->border_width * 2 + MAX (0, extra_width);
1811   minimum_size->height += GTK_CONTAINER (layout)->border_width * 2 + MAX (0, extra_height);
1812   natural_size->width += GTK_CONTAINER (layout)->border_width * 2 + MAX (0, extra_width);
1813   natural_size->height += GTK_CONTAINER (layout)->border_width * 2 + MAX (0, extra_height);
1814
1815   if (scrolled_window->shadow_type != GTK_SHADOW_NONE)
1816     {
1817       minimum_size->width += 2 * GTK_WIDGET (layout)->style->xthickness;
1818       minimum_size->height += 2 * GTK_WIDGET (layout)->style->ythickness;
1819       natural_size->width += 2 * GTK_WIDGET (layout)->style->xthickness;
1820       natural_size->height += 2 * GTK_WIDGET (layout)->style->ythickness;
1821     }
1822 }
1823
1824 static void
1825 gtk_scrolled_window_extended_layout_get_height_for_width (GtkExtendedLayout *layout,
1826                                                           gint       width,
1827                                                           gint      *minimum_height,
1828                                                           gint      *natural_height)
1829 {
1830   GtkRequisition minimum_size;
1831   GtkRequisition natural_size;
1832
1833   g_return_if_fail (GTK_IS_WIDGET (layout));
1834
1835 #if 0
1836   TODO: integrate height-for-width with size-groups
1837 #else
1838   gtk_widget_get_desired_size (GTK_WIDGET(layout),
1839                                minimum_height ? &minimum_size : NULL,
1840                                natural_height ? &natural_size : NULL);
1841
1842   if (minimum_height)
1843     *minimum_height = minimum_size.height;
1844   if (natural_height)
1845     *natural_height = natural_size.height;
1846 #endif
1847 }
1848
1849 static void
1850 gtk_scrolled_window_extended_layout_get_width_for_height (GtkExtendedLayout *layout,
1851                                       gint       height,
1852                                       gint      *minimum_width,
1853                                       gint      *natural_width)
1854 {
1855   GtkRequisition minimum_size;
1856   GtkRequisition natural_size;
1857
1858   g_return_if_fail (GTK_IS_WIDGET (layout));
1859
1860 #if 0
1861   TODO: integrate width-for-height with size-groups
1862 #else
1863   gtk_widget_get_desired_size (GTK_WIDGET(layout),
1864                                minimum_width ? &minimum_size : NULL,
1865                                natural_width ? &natural_size : NULL);
1866
1867   if (minimum_width)
1868     *minimum_width = minimum_size.width;
1869   if (natural_width)
1870     *natural_width = natural_size.width;
1871 #endif
1872 }
1873
1874 static void
1875 gtk_scrolled_window_extended_layout_init (GtkExtendedLayoutIface *iface)
1876 {
1877   iface->get_desired_size = gtk_scrolled_window_extended_layout_get_desired_size;
1878   iface->get_width_for_height = gtk_scrolled_window_extended_layout_get_width_for_height;
1879   iface->get_height_for_width = gtk_scrolled_window_extended_layout_get_height_for_width;
1880 }
1881
1882 #define __GTK_SCROLLED_WINDOW_C__
1883 #include "gtkaliasdef.c"