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 <gdk/gdkkeysyms.h>
  28 #include "gtkbindings.h"
  29 #include "gtkmarshalers.h"
  30 #include "gtkscrolledwindow.h"
  31 #include "gtkintl.h"
  32
  33
  34 /* scrolled window policy and size requisition handling:
  35  *
  36  * gtk size requisition works as follows:
  37  *   a widget upon size-request reports the width and height that it finds
  38  *   to be best suited to display its contents, including children.
  39  *   the width and/or height reported from a widget upon size requisition
  40  *   may be overidden by the user by specifying a width and/or height
  41  *   other than 0 through gtk_widget_set_usize().
  42  *
  43  * a scrolled window needs (for imlementing all three policy types) to
  44  * request its width and height based on two different rationales.
  45  * 1)   the user wants the scrolled window to just fit into the space
  46  *      that it gets allocated for a specifc dimension.
  47  * 1.1) this does not apply if the user specified a concrete value
  48  *      value for that specific dimension by either specifying usize for the
  49  *      scrolled window or for its child.
  50  * 2)   the user wants the scrolled window to take as much space up as
  51  *      is desired by the child for a specifc dimension (i.e. POLICY_NEVER).
  52  *
  53  * also, kinda obvious:
  54  * 3)   a user would certainly not have choosen a scrolled window as a container
  55  *      for the child, if the resulting allocation takes up more space than the
  56  *      child would have allocated without the scrolled window.
  57  *
  58  * conclusions:
  59  * A) from 1) follows: the scrolled window shouldn't request more space for a
  60  *    specifc dimension than is required at minimum.
  61  * B) from 1.1) follows: the requisition may be overidden by usize of the scrolled
  62  *    window (done automatically) or by usize of the child (needs to be checked).
  63  * C) from 2) follows: for POLICY_NEVER, the scrolled window simply reports the
  64  *    child's dimension.
  65  * D) from 3) follows: the scrolled window child's minimum width and minimum height
  66  *    under A) at least correspond to the space taken up by its scrollbars.
  67  */
  68
  69 #define DEFAULT_SCROLLBAR_SPACING  3
  70
  71 #define SCROLLBAR_SPACING(w)                                                            \
  72   (GTK_SCROLLED_WINDOW_GET_CLASS (w)->scrollbar_spacing >= 0 ?                          \
  73    GTK_SCROLLED_WINDOW_GET_CLASS (w)->scrollbar_spacing : DEFAULT_SCROLLBAR_SPACING)
  74
  75 enum {
  76   PROP_0,
  77   PROP_HADJUSTMENT,
  78   PROP_VADJUSTMENT,
  79   PROP_HSCROLLBAR_POLICY,
  80   PROP_VSCROLLBAR_POLICY,
  81   PROP_WINDOW_PLACEMENT,
  82   PROP_SHADOW_TYPE,
  83   PROP_LAST
  84 };
  85
  86 /* Signals */
  87 enum
  88 {
  89   SCROLL_CHILD,
  90   MOVE_FOCUS_OUT,
  91   LAST_SIGNAL
  92 };
  93
  94 static void gtk_scrolled_window_class_init         (GtkScrolledWindowClass *klass);
  95 static void gtk_scrolled_window_init               (GtkScrolledWindow      *scrolled_window);
  96 static void gtk_scrolled_window_destroy            (GtkObject              *object);
  97 static void gtk_scrolled_window_finalize           (GObject                *object);
  98 static void gtk_scrolled_window_set_property       (GObject                *object,
  99                                                     guint                   prop_id,
 100                                                     const GValue           *value,
 101                                                     GParamSpec             *pspec);
 102 static void gtk_scrolled_window_get_property       (GObject                *object,
 103                                                     guint                   prop_id,
 104                                                     GValue                 *value,
 105                                                     GParamSpec             *pspec);
 106
 107 static gint gtk_scrolled_window_expose             (GtkWidget              *widget,
 108                                                     GdkEventExpose         *event);
 109 static void gtk_scrolled_window_size_request       (GtkWidget              *widget,
 110                                                     GtkRequisition         *requisition);
 111 static void gtk_scrolled_window_size_allocate      (GtkWidget              *widget,
 112                                                     GtkAllocation          *allocation);
 113 static gint gtk_scrolled_window_scroll_event       (GtkWidget              *widget,
 114                                                     GdkEventScroll         *event);
 115 static gint gtk_scrolled_window_focus              (GtkWidget              *widget,
 116                                                     GtkDirectionType        direction);
 117 static void gtk_scrolled_window_add                (GtkContainer           *container,
 118                                                     GtkWidget              *widget);
 119 static void gtk_scrolled_window_remove             (GtkContainer           *container,
 120                                                     GtkWidget              *widget);
 121 static void gtk_scrolled_window_forall             (GtkContainer           *container,
 122                                                     gboolean                include_internals,
 123                                                     GtkCallback             callback,
 124                                                     gpointer                callback_data);
 125 static void gtk_scrolled_window_scroll_child       (GtkScrolledWindow      *scrolled_window,
 126                                                     GtkScrollType           scroll,
 127                                                     gboolean                horizontal);
 128 static void gtk_scrolled_window_move_focus_out     (GtkScrolledWindow      *scrolled_window,
 129                                                     GtkDirectionType        direction_type);
 130
 131 static void gtk_scrolled_window_relative_allocation(GtkWidget              *widget,
 132                                                     GtkAllocation          *allocation);
 133 static void gtk_scrolled_window_adjustment_changed (GtkAdjustment          *adjustment,
 134                                                     gpointer                data);
 135
 136 static GtkContainerClass *parent_class = NULL;
 137
 138 static guint signals[LAST_SIGNAL] = {0};
 139
 140 GType
 141 gtk_scrolled_window_get_type (void)
 142 {
 143   static GType scrolled_window_type = 0;
 144
 145   if (!scrolled_window_type)
 146     {
 147       static const GTypeInfo scrolled_window_info =
 148       {
 149         sizeof (GtkScrolledWindowClass),
 150         NULL,           /* base_init */
 151         NULL,           /* base_finalize */
 152         (GClassInitFunc) gtk_scrolled_window_class_init,
 153         NULL,           /* class_finalize */
 154         NULL,           /* class_data */
 155         sizeof (GtkScrolledWindow),
 156         0,              /* n_preallocs */
 157         (GInstanceInitFunc) gtk_scrolled_window_init,
 158       };
 159
 160       scrolled_window_type =
 161         g_type_register_static (GTK_TYPE_BIN, "GtkScrolledWindow",
 162                                 &scrolled_window_info, 0);
 163     }
 164
 165   return scrolled_window_type;
 166 }
 167
 168 static void
 169 add_scroll_binding (GtkBindingSet  *binding_set,
 170                     guint           keyval,
 171                     GdkModifierType mask,
 172                     GtkScrollType   scroll,
 173                     gboolean        horizontal)
 174 {
 175   guint keypad_keyval = keyval - GDK_Left + GDK_KP_Left;
 176
 177   gtk_binding_entry_add_signal (binding_set, keyval, mask,
 178                                 "scroll_child", 2,
 179                                 GTK_TYPE_SCROLL_TYPE, scroll,
 180                                 G_TYPE_BOOLEAN, horizontal);
 181   gtk_binding_entry_add_signal (binding_set, keypad_keyval, mask,
 182                                 "scroll_child", 2,
 183                                 GTK_TYPE_SCROLL_TYPE, scroll,
 184                                 G_TYPE_BOOLEAN, horizontal);
 185 }
 186
 187 static void
 188 add_tab_bindings (GtkBindingSet    *binding_set,
 189                   GdkModifierType   modifiers,
 190                   GtkDirectionType  direction)
 191 {
 192   gtk_binding_entry_add_signal (binding_set, GDK_Tab, modifiers,
 193                                 "move_focus_out", 1,
 194                                 GTK_TYPE_DIRECTION_TYPE, direction);
 195   gtk_binding_entry_add_signal (binding_set, GDK_KP_Tab, modifiers,
 196                                 "move_focus_out", 1,
 197                                 GTK_TYPE_DIRECTION_TYPE, direction);
 198 }
 199
 200 static void
 201 gtk_scrolled_window_class_init (GtkScrolledWindowClass *class)
 202 {
 203   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
 204   GtkObjectClass *object_class;
 205   GtkWidgetClass *widget_class;
 206   GtkContainerClass *container_class;
 207   GtkBindingSet *binding_set;
 208
 209   object_class = (GtkObjectClass*) class;
 210   widget_class = (GtkWidgetClass*) class;
 211   container_class = (GtkContainerClass*) class;
 212
 213   parent_class = g_type_class_peek_parent (class);
 214
 215   gobject_class->finalize = gtk_scrolled_window_finalize;
 216   gobject_class->set_property = gtk_scrolled_window_set_property;
 217   gobject_class->get_property = gtk_scrolled_window_get_property;
 218
 219   object_class->destroy = gtk_scrolled_window_destroy;
 220
 221   widget_class->expose_event = gtk_scrolled_window_expose;
 222   widget_class->size_request = gtk_scrolled_window_size_request;
 223   widget_class->size_allocate = gtk_scrolled_window_size_allocate;
 224   widget_class->scroll_event = gtk_scrolled_window_scroll_event;
 225   widget_class->focus = gtk_scrolled_window_focus;
 226
 227   container_class->add = gtk_scrolled_window_add;
 228   container_class->remove = gtk_scrolled_window_remove;
 229   container_class->forall = gtk_scrolled_window_forall;
 230
 231   class->scrollbar_spacing = -1;
 232
 233   class->scroll_child = gtk_scrolled_window_scroll_child;
 234   class->move_focus_out = gtk_scrolled_window_move_focus_out;
 235
 236   g_object_class_install_property (gobject_class,
 237                                    PROP_HADJUSTMENT,
 238                                    g_param_spec_object ("hadjustment",
 239                                                         _("Horizontal Adjustment"),
 240                                                         _("The GtkAdjustment for the horizontal position"),
 241                                                         GTK_TYPE_ADJUSTMENT,
 242                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 243   g_object_class_install_property (gobject_class,
 244                                    PROP_VADJUSTMENT,
 245                                    g_param_spec_object ("vadjustment",
 246                                                         _("Vertical Adjustment"),
 247                                                         _("The GtkAdjustment for the vertical position"),
 248                                                         GTK_TYPE_ADJUSTMENT,
 249                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 250   g_object_class_install_property (gobject_class,
 251                                    PROP_HSCROLLBAR_POLICY,
 252                                    g_param_spec_enum ("hscrollbar_policy",
 253                                                       _("Horizontal Scrollbar Policy"),
 254                                                       _("When the horizontal scrollbar is displayed"),
 255                                                       GTK_TYPE_POLICY_TYPE,
 256                                                       GTK_POLICY_ALWAYS,
 257                                                       G_PARAM_READABLE | G_PARAM_WRITABLE));
 258   g_object_class_install_property (gobject_class,
 259                                    PROP_VSCROLLBAR_POLICY,
 260                                    g_param_spec_enum ("vscrollbar_policy",
 261                                                       _("Vertical Scrollbar Policy"),
 262                                                       _("When the vertical scrollbar is displayed"),
 263                                                       GTK_TYPE_POLICY_TYPE,
 264                                                       GTK_POLICY_ALWAYS,
 265                                                       G_PARAM_READABLE | G_PARAM_WRITABLE));
 266
 267   g_object_class_install_property (gobject_class,
 268                                    PROP_WINDOW_PLACEMENT,
 269                                    g_param_spec_enum ("window_placement",
 270                                                       _("Window Placement"),
 271                                                       _("Where the contents are located with respect to the scrollbars"),
 272                                                       GTK_TYPE_CORNER_TYPE,
 273                                                       GTK_CORNER_TOP_LEFT,
 274                                                       G_PARAM_READABLE | G_PARAM_WRITABLE));
 275   g_object_class_install_property (gobject_class,
 276                                    PROP_SHADOW_TYPE,
 277                                    g_param_spec_enum ("shadow_type",
 278                                                       _("Shadow Type"),
 279                                                       _("Style of bevel around the contents"),
 280                                                       GTK_TYPE_SHADOW_TYPE,
 281                                                       GTK_SHADOW_NONE,
 282                                                       G_PARAM_READABLE | G_PARAM_WRITABLE));
 283
 284   signals[SCROLL_CHILD] =
 285     g_signal_new ("scroll_child",
 286                   G_TYPE_FROM_CLASS (object_class),
 287                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 288                   G_STRUCT_OFFSET (GtkScrolledWindowClass, scroll_child),
 289                   NULL, NULL,
 290                   _gtk_marshal_VOID__ENUM_BOOLEAN,
 291                   G_TYPE_NONE, 2,
 292                   GTK_TYPE_SCROLL_TYPE,
 293                   G_TYPE_BOOLEAN);
 294   signals[MOVE_FOCUS_OUT] =
 295     g_signal_new ("move_focus_out",
 296                   G_TYPE_FROM_CLASS (object_class),
 297                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 298                   G_STRUCT_OFFSET (GtkScrolledWindowClass, move_focus_out),
 299                   NULL, NULL,
 300                   _gtk_marshal_VOID__ENUM,
 301                   G_TYPE_NONE, 1,
 302                   GTK_TYPE_DIRECTION_TYPE);
 303
 304   binding_set = gtk_binding_set_by_class (class);
 305
 306   add_scroll_binding (binding_set, GDK_Left,  GDK_CONTROL_MASK, GTK_SCROLL_STEP_BACKWARD, TRUE);
 307   add_scroll_binding (binding_set, GDK_Right, GDK_CONTROL_MASK, GTK_SCROLL_STEP_FORWARD,  TRUE);
 308   add_scroll_binding (binding_set, GDK_Up,    GDK_CONTROL_MASK, GTK_SCROLL_STEP_BACKWARD, FALSE);
 309   add_scroll_binding (binding_set, GDK_Down,  GDK_CONTROL_MASK, GTK_SCROLL_STEP_FORWARD,  FALSE);
 310
 311   add_scroll_binding (binding_set, GDK_Page_Up,   GDK_CONTROL_MASK, GTK_SCROLL_PAGE_BACKWARD, TRUE);
 312   add_scroll_binding (binding_set, GDK_Page_Down, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_FORWARD,  TRUE);
 313   add_scroll_binding (binding_set, GDK_Page_Up,   0,                GTK_SCROLL_PAGE_BACKWARD, FALSE);
 314   add_scroll_binding (binding_set, GDK_Page_Down, 0,                GTK_SCROLL_PAGE_FORWARD,  FALSE);
 315
 316   add_scroll_binding (binding_set, GDK_Home, GDK_CONTROL_MASK, GTK_SCROLL_START, TRUE);
 317   add_scroll_binding (binding_set, GDK_End,  GDK_CONTROL_MASK, GTK_SCROLL_END,   TRUE);
 318   add_scroll_binding (binding_set, GDK_Home, 0,                GTK_SCROLL_START, FALSE);
 319   add_scroll_binding (binding_set, GDK_End,  0,                GTK_SCROLL_END,   FALSE);
 320
 321   add_tab_bindings (binding_set, GDK_CONTROL_MASK, GTK_DIR_TAB_FORWARD);
 322   add_tab_bindings (binding_set, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
 323 }
 324
 325 static void
 326 gtk_scrolled_window_init (GtkScrolledWindow *scrolled_window)
 327 {
 328   GTK_WIDGET_SET_FLAGS (scrolled_window, GTK_NO_WINDOW | GTK_CAN_FOCUS);
 329
 330   scrolled_window->hscrollbar = NULL;
 331   scrolled_window->vscrollbar = NULL;
 332   scrolled_window->hscrollbar_policy = GTK_POLICY_ALWAYS;
 333   scrolled_window->vscrollbar_policy = GTK_POLICY_ALWAYS;
 334   scrolled_window->hscrollbar_visible = FALSE;
 335   scrolled_window->vscrollbar_visible = FALSE;
 336   scrolled_window->focus_out = FALSE;
 337   scrolled_window->window_placement = GTK_CORNER_TOP_LEFT;
 338
 339 }
 340
 341 GtkWidget*
 342 gtk_scrolled_window_new (GtkAdjustment *hadjustment,
 343                          GtkAdjustment *vadjustment)
 344 {
 345   GtkWidget *scrolled_window;
 346
 347   if (hadjustment)
 348     g_return_val_if_fail (GTK_IS_ADJUSTMENT (hadjustment), NULL);
 349
 350   if (vadjustment)
 351     g_return_val_if_fail (GTK_IS_ADJUSTMENT (vadjustment), NULL);
 352
 353   scrolled_window = gtk_widget_new (GTK_TYPE_SCROLLED_WINDOW,
 354                                     "hadjustment", hadjustment,
 355                                     "vadjustment", vadjustment,
 356                                     NULL);
 357
 358   return scrolled_window;
 359 }
 360
 361 void
 362 gtk_scrolled_window_set_hadjustment (GtkScrolledWindow *scrolled_window,
 363                                      GtkAdjustment     *hadjustment)
 364 {
 365   GtkBin *bin;
 366
 367   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 368   if (hadjustment)
 369     g_return_if_fail (GTK_IS_ADJUSTMENT (hadjustment));
 370   else
 371     hadjustment = (GtkAdjustment*) gtk_object_new (GTK_TYPE_ADJUSTMENT, NULL);
 372
 373   bin = GTK_BIN (scrolled_window);
 374
 375   if (!scrolled_window->hscrollbar)
 376     {
 377       gtk_widget_push_composite_child ();
 378       scrolled_window->hscrollbar = gtk_hscrollbar_new (hadjustment);
 379       gtk_widget_set_composite_name (scrolled_window->hscrollbar, "hscrollbar");
 380       gtk_widget_pop_composite_child ();
 381
 382       gtk_widget_set_parent (scrolled_window->hscrollbar, GTK_WIDGET (scrolled_window));
 383       g_object_ref (scrolled_window->hscrollbar);
 384       gtk_widget_show (scrolled_window->hscrollbar);
 385     }
 386   else
 387     {
 388       GtkAdjustment *old_adjustment;
 389
 390       old_adjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));
 391       if (old_adjustment == hadjustment)
 392         return;
 393
 394       g_signal_handlers_disconnect_by_func (old_adjustment,
 395                                             gtk_scrolled_window_adjustment_changed,
 396                                             scrolled_window);
 397       gtk_range_set_adjustment (GTK_RANGE (scrolled_window->hscrollbar),
 398                                 hadjustment);
 399     }
 400   hadjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));
 401   g_signal_connect (hadjustment,
 402                     "changed",
 403                     G_CALLBACK (gtk_scrolled_window_adjustment_changed),
 404                     scrolled_window);
 405   gtk_scrolled_window_adjustment_changed (hadjustment, scrolled_window);
 406
 407   if (bin->child)
 408     gtk_widget_set_scroll_adjustments (bin->child,
 409                                        gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
 410                                        gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)));
 411
 412   g_object_notify (G_OBJECT (scrolled_window), "hadjustment");
 413 }
 414
 415 void
 416 gtk_scrolled_window_set_vadjustment (GtkScrolledWindow *scrolled_window,
 417                                      GtkAdjustment     *vadjustment)
 418 {
 419   GtkBin *bin;
 420
 421   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 422   if (vadjustment)
 423     g_return_if_fail (GTK_IS_ADJUSTMENT (vadjustment));
 424   else
 425     vadjustment = (GtkAdjustment*) gtk_object_new (GTK_TYPE_ADJUSTMENT, NULL);
 426
 427   bin = GTK_BIN (scrolled_window);
 428
 429   if (!scrolled_window->vscrollbar)
 430     {
 431       gtk_widget_push_composite_child ();
 432       scrolled_window->vscrollbar = gtk_vscrollbar_new (vadjustment);
 433       gtk_widget_set_composite_name (scrolled_window->vscrollbar, "vscrollbar");
 434       gtk_widget_pop_composite_child ();
 435
 436       gtk_widget_set_parent (scrolled_window->vscrollbar, GTK_WIDGET (scrolled_window));
 437       g_object_ref (scrolled_window->vscrollbar);
 438       gtk_widget_show (scrolled_window->vscrollbar);
 439     }
 440   else
 441     {
 442       GtkAdjustment *old_adjustment;
 443
 444       old_adjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));
 445       if (old_adjustment == vadjustment)
 446         return;
 447
 448       g_signal_handlers_disconnect_by_func (old_adjustment,
 449                                             gtk_scrolled_window_adjustment_changed,
 450                                             scrolled_window);
 451       gtk_range_set_adjustment (GTK_RANGE (scrolled_window->vscrollbar),
 452                                 vadjustment);
 453     }
 454   vadjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));
 455   g_signal_connect (vadjustment,
 456                     "changed",
 457                     G_CALLBACK (gtk_scrolled_window_adjustment_changed),
 458                     scrolled_window);
 459   gtk_scrolled_window_adjustment_changed (vadjustment, scrolled_window);
 460
 461   if (bin->child)
 462     gtk_widget_set_scroll_adjustments (bin->child,
 463                                        gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
 464                                        gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)));
 465
 466   g_object_notify (G_OBJECT (scrolled_window), "vadjustment");
 467 }
 468
 469 GtkAdjustment*
 470 gtk_scrolled_window_get_hadjustment (GtkScrolledWindow *scrolled_window)
 471 {
 472   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);
 473
 474   return (scrolled_window->hscrollbar ?
 475           gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)) :
 476           NULL);
 477 }
 478
 479 GtkAdjustment*
 480 gtk_scrolled_window_get_vadjustment (GtkScrolledWindow *scrolled_window)
 481 {
 482   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);
 483
 484   return (scrolled_window->vscrollbar ?
 485           gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)) :
 486           NULL);
 487 }
 488
 489 void
 490 gtk_scrolled_window_set_policy (GtkScrolledWindow *scrolled_window,
 491                                 GtkPolicyType      hscrollbar_policy,
 492                                 GtkPolicyType      vscrollbar_policy)
 493 {
 494   GObject *object = G_OBJECT (scrolled_window);
 495
 496   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 497
 498   if ((scrolled_window->hscrollbar_policy != hscrollbar_policy) ||
 499       (scrolled_window->vscrollbar_policy != vscrollbar_policy))
 500     {
 501       scrolled_window->hscrollbar_policy = hscrollbar_policy;
 502       scrolled_window->vscrollbar_policy = vscrollbar_policy;
 503
 504       gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
 505
 506       g_object_freeze_notify (object);
 507       g_object_notify (object, "hscrollbar_policy");
 508       g_object_notify (object, "vscrollbar_policy");
 509       g_object_thaw_notify (object);
 510     }
 511 }
 512
 513 /**
 514  * gtk_scrolled_window_get_policy:
 515  * @scrolled_window: a #GtkScrolledWindow
 516  * @hscrollbar_policy: location to store the policy for the horizontal scrollbar, or %NULL.
 517  * @vscrollbar_policy: location to store the policy for the horizontal scrollbar, or %NULL.
 518  *
 519  * Retrieves the current policy values for the horizontal and vertical
 520  * scrollbars. See gtk_scrolled_window_set_policy().
 521  **/
 522 void
 523 gtk_scrolled_window_get_policy (GtkScrolledWindow *scrolled_window,
 524                                 GtkPolicyType     *hscrollbar_policy,
 525                                 GtkPolicyType     *vscrollbar_policy)
 526 {
 527   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 528
 529   if (hscrollbar_policy)
 530     *hscrollbar_policy = scrolled_window->hscrollbar_policy;
 531   if (vscrollbar_policy)
 532     *vscrollbar_policy = scrolled_window->vscrollbar_policy;
 533 }
 534
 535 void
 536 gtk_scrolled_window_set_placement (GtkScrolledWindow *scrolled_window,
 537                                    GtkCornerType      window_placement)
 538 {
 539   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 540
 541   if (scrolled_window->window_placement != window_placement)
 542     {
 543       scrolled_window->window_placement = window_placement;
 544
 545       gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
 546
 547       g_object_notify (G_OBJECT (scrolled_window), "window_placement");
 548     }
 549 }
 550
 551 /**
 552  * gtk_scrolled_window_get_placement:
 553  * @scrolled_window: a #GtkScrolledWindow
 554  *
 555  * Gets the placement of the scrollbars for the scrolled window. See
 556  * gtk_scrolled_window_set_placement().
 557  *
 558  * Return value: the current placement value.
 559  **/
 560 GtkCornerType
 561 gtk_scrolled_window_get_placement (GtkScrolledWindow *scrolled_window)
 562 {
 563   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), GTK_CORNER_TOP_LEFT);
 564
 565   return scrolled_window->window_placement;
 566 }
 567
 568 /**
 569  * gtk_scrolled_window_set_shadow_type:
 570  * @scrolled_window: a #GtkScrolledWindow
 571  * @type: kind of shadow to draw around scrolled window contents
 572  *
 573  * Changes the type of shadow drawn around the contents of
 574  * @scrolled_window.
 575  *
 576  **/
 577 void
 578 gtk_scrolled_window_set_shadow_type (GtkScrolledWindow *scrolled_window,
 579                                      GtkShadowType      type)
 580 {
 581   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 582   g_return_if_fail (type >= GTK_SHADOW_NONE && type <= GTK_SHADOW_ETCHED_OUT);
 583
 584   if (scrolled_window->shadow_type != type)
 585     {
 586       scrolled_window->shadow_type = type;
 587
 588       if (GTK_WIDGET_DRAWABLE (scrolled_window))
 589         gtk_widget_queue_draw (GTK_WIDGET (scrolled_window));
 590
 591       gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
 592
 593       g_object_notify (G_OBJECT (scrolled_window), "shadow_type");
 594     }
 595 }
 596
 597 /**
 598  * gtk_scrolled_window_get_shadow_type:
 599  * @scrolled_window: a #GtkScrolledWindow
 600  *
 601  * Gets the shadow type of the scrolled window. See
 602  * gtk_scrolled_window_set_shadow_type().
 603  *
 604  * Return value: the current shadow type
 605  **/
 606 GtkShadowType
 607 gtk_scrolled_window_get_shadow_type (GtkScrolledWindow *scrolled_window)
 608 {
 609   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_NONE);
 610
 611   return scrolled_window->shadow_type;
 612 }
 613
 614 static void
 615 gtk_scrolled_window_destroy (GtkObject *object)
 616 {
 617   GtkScrolledWindow *scrolled_window;
 618
 619   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (object));
 620
 621   scrolled_window = GTK_SCROLLED_WINDOW (object);
 622
 623   gtk_widget_unparent (scrolled_window->hscrollbar);
 624   gtk_widget_unparent (scrolled_window->vscrollbar);
 625   gtk_widget_destroy (scrolled_window->hscrollbar);
 626   gtk_widget_destroy (scrolled_window->vscrollbar);
 627
 628   GTK_OBJECT_CLASS (parent_class)->destroy (object);
 629 }
 630
 631 static void
 632 gtk_scrolled_window_finalize (GObject *object)
 633 {
 634   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (object);
 635
 636   g_object_unref (scrolled_window->hscrollbar);
 637   g_object_unref (scrolled_window->vscrollbar);
 638
 639   G_OBJECT_CLASS (parent_class)->finalize (object);
 640 }
 641
 642 static void
 643 gtk_scrolled_window_set_property (GObject      *object,
 644                                   guint         prop_id,
 645                                   const GValue *value,
 646                                   GParamSpec   *pspec)
 647 {
 648   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (object);
 649
 650   switch (prop_id)
 651     {
 652     case PROP_HADJUSTMENT:
 653       gtk_scrolled_window_set_hadjustment (scrolled_window,
 654                                            g_value_get_object (value));
 655       break;
 656     case PROP_VADJUSTMENT:
 657       gtk_scrolled_window_set_vadjustment (scrolled_window,
 658                                            g_value_get_object (value));
 659       break;
 660     case PROP_HSCROLLBAR_POLICY:
 661       gtk_scrolled_window_set_policy (scrolled_window,
 662                                       g_value_get_enum (value),
 663                                       scrolled_window->vscrollbar_policy);
 664       break;
 665     case PROP_VSCROLLBAR_POLICY:
 666       gtk_scrolled_window_set_policy (scrolled_window,
 667                                       scrolled_window->hscrollbar_policy,
 668                                       g_value_get_enum (value));
 669       break;
 670     case PROP_WINDOW_PLACEMENT:
 671       gtk_scrolled_window_set_placement (scrolled_window,
 672                                          g_value_get_enum (value));
 673       break;
 674     case PROP_SHADOW_TYPE:
 675       gtk_scrolled_window_set_shadow_type (scrolled_window,
 676                                            g_value_get_enum (value));
 677       break;
 678     default:
 679       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 680       break;
 681     }
 682 }
 683
 684 static void
 685 gtk_scrolled_window_get_property (GObject    *object,
 686                                   guint       prop_id,
 687                                   GValue     *value,
 688                                   GParamSpec *pspec)
 689 {
 690   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (object);
 691
 692   switch (prop_id)
 693     {
 694     case PROP_HADJUSTMENT:
 695       g_value_set_object (value,
 696                           G_OBJECT (gtk_scrolled_window_get_hadjustment (scrolled_window)));
 697       break;
 698     case PROP_VADJUSTMENT:
 699       g_value_set_object (value,
 700                           G_OBJECT (gtk_scrolled_window_get_vadjustment (scrolled_window)));
 701       break;
 702     case PROP_HSCROLLBAR_POLICY:
 703       g_value_set_enum (value, scrolled_window->hscrollbar_policy);
 704       break;
 705     case PROP_VSCROLLBAR_POLICY:
 706       g_value_set_enum (value, scrolled_window->vscrollbar_policy);
 707       break;
 708     case PROP_WINDOW_PLACEMENT:
 709       g_value_set_enum (value, scrolled_window->window_placement);
 710       break;
 711     case PROP_SHADOW_TYPE:
 712       g_value_set_enum (value, scrolled_window->shadow_type);
 713       break;
 714     default:
 715       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 716       break;
 717     }
 718 }
 719
 720 static void
 721 gtk_scrolled_window_paint (GtkWidget    *widget,
 722                            GdkRectangle *area)
 723 {
 724   GtkAllocation relative_allocation;
 725   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
 726
 727   if (scrolled_window->shadow_type != GTK_SHADOW_NONE)
 728     {
 729       gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
 730
 731       relative_allocation.x -= widget->style->xthickness;
 732       relative_allocation.y -= widget->style->ythickness;
 733       relative_allocation.width += 2 * widget->style->xthickness;
 734       relative_allocation.height += 2 * widget->style->ythickness;
 735
 736       gtk_paint_shadow (widget->style, widget->window,
 737                         GTK_STATE_NORMAL, scrolled_window->shadow_type,
 738                         area, widget, "scrolled_window",
 739                         widget->allocation.x + relative_allocation.x,
 740                         widget->allocation.y + relative_allocation.y,
 741                         relative_allocation.width,
 742                         relative_allocation.height);
 743     }
 744 }
 745
 746 static gint
 747 gtk_scrolled_window_expose (GtkWidget      *widget,
 748                             GdkEventExpose *event)
 749 {
 750   if (GTK_WIDGET_DRAWABLE (widget))
 751     {
 752       gtk_scrolled_window_paint (widget, &event->area);
 753
 754       (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
 755     }
 756
 757   return FALSE;
 758 }
 759
 760 static void
 761 gtk_scrolled_window_forall (GtkContainer *container,
 762                             gboolean      include_internals,
 763                             GtkCallback   callback,
 764                             gpointer      callback_data)
 765 {
 766   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (container));
 767   g_return_if_fail (callback != NULL);
 768
 769   GTK_CONTAINER_CLASS (parent_class)->forall (container,
 770                                               include_internals,
 771                                               callback,
 772                                               callback_data);
 773   if (include_internals)
 774     {
 775       GtkScrolledWindow *scrolled_window;
 776
 777       scrolled_window = GTK_SCROLLED_WINDOW (container);
 778
 779       if (scrolled_window->vscrollbar)
 780         callback (scrolled_window->vscrollbar, callback_data);
 781       if (scrolled_window->hscrollbar)
 782         callback (scrolled_window->hscrollbar, callback_data);
 783     }
 784 }
 785
 786 static void
 787 gtk_scrolled_window_scroll_child (GtkScrolledWindow *scrolled_window,
 788                                   GtkScrollType      scroll,
 789                                   gboolean           horizontal)
 790 {
 791   GtkAdjustment *adjustment = NULL;
 792
 793   switch (scroll)
 794     {
 795     case GTK_SCROLL_STEP_UP:
 796       scroll = GTK_SCROLL_STEP_BACKWARD;
 797       horizontal = FALSE;
 798       break;
 799     case GTK_SCROLL_STEP_DOWN:
 800       scroll = GTK_SCROLL_STEP_FORWARD;
 801       horizontal = FALSE;
 802       break;
 803     case GTK_SCROLL_STEP_LEFT:
 804       scroll = GTK_SCROLL_STEP_BACKWARD;
 805       horizontal = TRUE;
 806       break;
 807     case GTK_SCROLL_STEP_RIGHT:
 808       scroll = GTK_SCROLL_STEP_FORWARD;
 809       horizontal = TRUE;
 810       break;
 811     case GTK_SCROLL_PAGE_UP:
 812       scroll = GTK_SCROLL_PAGE_BACKWARD;
 813       horizontal = FALSE;
 814       break;
 815     case GTK_SCROLL_PAGE_DOWN:
 816       scroll = GTK_SCROLL_PAGE_FORWARD;
 817       horizontal = FALSE;
 818       break;
 819     case GTK_SCROLL_PAGE_LEFT:
 820       scroll = GTK_SCROLL_STEP_BACKWARD;
 821       horizontal = TRUE;
 822       break;
 823     case GTK_SCROLL_PAGE_RIGHT:
 824       scroll = GTK_SCROLL_STEP_FORWARD;
 825       horizontal = TRUE;
 826       break;
 827     case GTK_SCROLL_STEP_BACKWARD:
 828     case GTK_SCROLL_STEP_FORWARD:
 829     case GTK_SCROLL_PAGE_BACKWARD:
 830     case GTK_SCROLL_PAGE_FORWARD:
 831     case GTK_SCROLL_START:
 832     case GTK_SCROLL_END:
 833       break;
 834     default:
 835       g_warning ("Invalid scroll type %d for GtkSpinButton::change-value", scroll);
 836       return;
 837     }
 838
 839   if (horizontal)
 840     {
 841       if (scrolled_window->hscrollbar)
 842         adjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));
 843     }
 844   else
 845     {
 846       if (scrolled_window->vscrollbar)
 847         adjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));
 848     }
 849
 850   if (adjustment)
 851     {
 852       gdouble value = adjustment->value;
 853
 854       switch (scroll)
 855         {
 856         case GTK_SCROLL_STEP_FORWARD:
 857           value += adjustment->step_increment;
 858           break;
 859         case GTK_SCROLL_STEP_BACKWARD:
 860           value -= adjustment->step_increment;
 861           break;
 862         case GTK_SCROLL_PAGE_FORWARD:
 863           value += adjustment->page_increment;
 864           break;
 865         case GTK_SCROLL_PAGE_BACKWARD:
 866           value -= adjustment->page_increment;
 867           break;
 868         case GTK_SCROLL_START:
 869           value = adjustment->lower;
 870           break;
 871         case GTK_SCROLL_END:
 872           value = adjustment->upper;
 873           break;
 874         default:
 875           g_assert_not_reached ();
 876           break;
 877         }
 878
 879       value = CLAMP (value, adjustment->lower, adjustment->upper - adjustment->page_size);
 880
 881       gtk_adjustment_set_value (adjustment, value);
 882     }
 883 }
 884
 885 static void
 886 gtk_scrolled_window_move_focus_out (GtkScrolledWindow *scrolled_window,
 887                                     GtkDirectionType   direction_type)
 888 {
 889   GtkWidget *toplevel;
 890
 891   /* Focus out of the scrolled window entirely. We do this by setting
 892    * a flag, then propagating the focus motion to the notebook.
 893    */
 894   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (scrolled_window));
 895   if (!GTK_WIDGET_TOPLEVEL (toplevel))
 896     return;
 897
 898   g_object_ref (scrolled_window);
 899
 900   scrolled_window->focus_out = TRUE;
 901   g_signal_emit_by_name (toplevel, "move_focus", direction_type);
 902   scrolled_window->focus_out = FALSE;
 903
 904   g_object_unref (scrolled_window);
 905 }
 906
 907 static void
 908 gtk_scrolled_window_size_request (GtkWidget      *widget,
 909                                   GtkRequisition *requisition)
 910 {
 911   GtkScrolledWindow *scrolled_window;
 912   GtkBin *bin;
 913   gint extra_width;
 914   gint extra_height;
 915   GtkRequisition hscrollbar_requisition;
 916   GtkRequisition vscrollbar_requisition;
 917   GtkRequisition child_requisition;
 918
 919   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
 920   g_return_if_fail (requisition != NULL);
 921
 922   scrolled_window = GTK_SCROLLED_WINDOW (widget);
 923   bin = GTK_BIN (scrolled_window);
 924
 925   extra_width = 0;
 926   extra_height = 0;
 927   requisition->width = 0;
 928   requisition->height = 0;
 929
 930   gtk_widget_size_request (scrolled_window->hscrollbar,
 931                            &hscrollbar_requisition);
 932   gtk_widget_size_request (scrolled_window->vscrollbar,
 933                            &vscrollbar_requisition);
 934
 935   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
 936     {
 937       gtk_widget_size_request (bin->child, &child_requisition);
 938
 939       if (scrolled_window->hscrollbar_policy == GTK_POLICY_NEVER)
 940         requisition->width += child_requisition.width;
 941       else
 942         {
 943           GtkWidgetAuxInfo *aux_info = _gtk_widget_get_aux_info (bin->child, FALSE);
 944
 945           if (aux_info && aux_info->width > 0)
 946             {
 947               requisition->width += aux_info->width;
 948               extra_width = -1;
 949             }
 950           else
 951             requisition->width += vscrollbar_requisition.width;
 952         }
 953
 954       if (scrolled_window->vscrollbar_policy == GTK_POLICY_NEVER)
 955         requisition->height += child_requisition.height;
 956       else
 957         {
 958           GtkWidgetAuxInfo *aux_info = _gtk_widget_get_aux_info (bin->child, FALSE);
 959
 960           if (aux_info && aux_info->height > 0)
 961             {
 962               requisition->height += aux_info->height;
 963               extra_height = -1;
 964             }
 965           else
 966             requisition->height += hscrollbar_requisition.height;
 967         }
 968     }
 969
 970   if (scrolled_window->hscrollbar_policy == GTK_POLICY_AUTOMATIC ||
 971       scrolled_window->hscrollbar_policy == GTK_POLICY_ALWAYS)
 972     {
 973       requisition->width = MAX (requisition->width, hscrollbar_requisition.width);
 974       if (!extra_height || scrolled_window->hscrollbar_policy == GTK_POLICY_ALWAYS)
 975         extra_height = SCROLLBAR_SPACING (scrolled_window) + hscrollbar_requisition.height;
 976     }
 977
 978   if (scrolled_window->vscrollbar_policy == GTK_POLICY_AUTOMATIC ||
 979       scrolled_window->vscrollbar_policy == GTK_POLICY_ALWAYS)
 980     {
 981       requisition->height = MAX (requisition->height, vscrollbar_requisition.height);
 982       if (!extra_height || scrolled_window->vscrollbar_policy == GTK_POLICY_ALWAYS)
 983         extra_width = SCROLLBAR_SPACING (scrolled_window) + vscrollbar_requisition.width;
 984     }
 985
 986   requisition->width += GTK_CONTAINER (widget)->border_width * 2 + MAX (0, extra_width);
 987   requisition->height += GTK_CONTAINER (widget)->border_width * 2 + MAX (0, extra_height);
 988
 989   if (scrolled_window->shadow_type != GTK_SHADOW_NONE)
 990     {
 991       requisition->width += 2 * widget->style->xthickness;
 992       requisition->height += 2 * widget->style->ythickness;
 993     }
 994 }
 995
 996 static void
 997 gtk_scrolled_window_relative_allocation (GtkWidget     *widget,
 998                                          GtkAllocation *allocation)
 999 {
1000   GtkScrolledWindow *scrolled_window;
1001
1002   g_return_if_fail (widget != NULL);
1003   g_return_if_fail (allocation != NULL);
1004
1005   scrolled_window = GTK_SCROLLED_WINDOW (widget);
1006
1007   allocation->x = GTK_CONTAINER (widget)->border_width;
1008   allocation->y = GTK_CONTAINER (widget)->border_width;
1009
1010   if (scrolled_window->shadow_type != GTK_SHADOW_NONE)
1011     {
1012       allocation->x += widget->style->xthickness;
1013       allocation->y += widget->style->ythickness;
1014     }
1015
1016   allocation->width = MAX (1, (gint)widget->allocation.width - allocation->x * 2);
1017   allocation->height = MAX (1, (gint)widget->allocation.height - allocation->y * 2);
1018
1019   if (scrolled_window->vscrollbar_visible)
1020     {
1021       GtkRequisition vscrollbar_requisition;
1022       gtk_widget_get_child_requisition (scrolled_window->vscrollbar,
1023                                         &vscrollbar_requisition);
1024
1025       if (scrolled_window->window_placement == GTK_CORNER_TOP_RIGHT ||
1026           scrolled_window->window_placement == GTK_CORNER_BOTTOM_RIGHT)
1027         allocation->x += (vscrollbar_requisition.width +
1028                           SCROLLBAR_SPACING (scrolled_window));
1029
1030       allocation->width = MAX (1, (gint)allocation->width -
1031                                ((gint)vscrollbar_requisition.width +
1032                                 (gint)SCROLLBAR_SPACING (scrolled_window)));
1033     }
1034   if (scrolled_window->hscrollbar_visible)
1035     {
1036       GtkRequisition hscrollbar_requisition;
1037       gtk_widget_get_child_requisition (scrolled_window->hscrollbar,
1038                                         &hscrollbar_requisition);
1039
1040       if (scrolled_window->window_placement == GTK_CORNER_BOTTOM_LEFT ||
1041           scrolled_window->window_placement == GTK_CORNER_BOTTOM_RIGHT)
1042         allocation->y += (hscrollbar_requisition.height +
1043                           SCROLLBAR_SPACING (scrolled_window));
1044
1045       allocation->height = MAX (1, (gint)allocation->height -
1046                                 ((gint)hscrollbar_requisition.height +
1047                                  (gint)SCROLLBAR_SPACING (scrolled_window)));
1048     }
1049 }
1050
1051 static void
1052 gtk_scrolled_window_size_allocate (GtkWidget     *widget,
1053                                    GtkAllocation *allocation)
1054 {
1055   GtkScrolledWindow *scrolled_window;
1056   GtkBin *bin;
1057   GtkAllocation relative_allocation;
1058   GtkAllocation child_allocation;
1059
1060   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
1061   g_return_if_fail (allocation != NULL);
1062
1063   scrolled_window = GTK_SCROLLED_WINDOW (widget);
1064   bin = GTK_BIN (scrolled_window);
1065
1066   widget->allocation = *allocation;
1067
1068   if (scrolled_window->hscrollbar_policy == GTK_POLICY_ALWAYS)
1069     scrolled_window->hscrollbar_visible = TRUE;
1070   else if (scrolled_window->hscrollbar_policy == GTK_POLICY_NEVER)
1071     scrolled_window->hscrollbar_visible = FALSE;
1072   if (scrolled_window->vscrollbar_policy == GTK_POLICY_ALWAYS)
1073     scrolled_window->vscrollbar_visible = TRUE;
1074   else if (scrolled_window->vscrollbar_policy == GTK_POLICY_NEVER)
1075     scrolled_window->vscrollbar_visible = FALSE;
1076
1077   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
1078     {
1079       gboolean previous_hvis;
1080       gboolean previous_vvis;
1081       guint count = 0;
1082
1083       do
1084         {
1085           gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
1086
1087           child_allocation.x = relative_allocation.x + allocation->x;
1088           child_allocation.y = relative_allocation.y + allocation->y;
1089           child_allocation.width = relative_allocation.width;
1090           child_allocation.height = relative_allocation.height;
1091
1092           previous_hvis = scrolled_window->hscrollbar_visible;
1093           previous_vvis = scrolled_window->vscrollbar_visible;
1094
1095           gtk_widget_size_allocate (bin->child, &child_allocation);
1096
1097           /* If, after the first iteration, the hscrollbar and the
1098            * vscrollbar flip visiblity, then we need both.
1099            */
1100           if (count &&
1101               previous_hvis != scrolled_window->hscrollbar_visible &&
1102               previous_vvis != scrolled_window->vscrollbar_visible)
1103             {
1104               scrolled_window->hscrollbar_visible = TRUE;
1105               scrolled_window->vscrollbar_visible = TRUE;
1106
1107               /* a new resize is already queued at this point,
1108                * so we will immediatedly get reinvoked
1109                */
1110               return;
1111             }
1112
1113           count++;
1114         }
1115       while (previous_hvis != scrolled_window->hscrollbar_visible ||
1116              previous_vvis != scrolled_window->vscrollbar_visible);
1117     }
1118   else
1119     gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
1120
1121   if (scrolled_window->hscrollbar_visible)
1122     {
1123       GtkRequisition hscrollbar_requisition;
1124       gtk_widget_get_child_requisition (scrolled_window->hscrollbar,
1125                                         &hscrollbar_requisition);
1126
1127       if (!GTK_WIDGET_VISIBLE (scrolled_window->hscrollbar))
1128         gtk_widget_show (scrolled_window->hscrollbar);
1129
1130       child_allocation.x = relative_allocation.x;
1131       if (scrolled_window->window_placement == GTK_CORNER_TOP_LEFT ||
1132           scrolled_window->window_placement == GTK_CORNER_TOP_RIGHT)
1133         child_allocation.y = (relative_allocation.y +
1134                               relative_allocation.height +
1135                               SCROLLBAR_SPACING (scrolled_window) +
1136                               (scrolled_window->shadow_type == GTK_SHADOW_NONE ?
1137                                0 : widget->style->ythickness));
1138       else
1139         child_allocation.y = GTK_CONTAINER (scrolled_window)->border_width;
1140
1141       child_allocation.width = relative_allocation.width;
1142       child_allocation.height = hscrollbar_requisition.height;
1143       child_allocation.x += allocation->x;
1144       child_allocation.y += allocation->y;
1145
1146       if (scrolled_window->shadow_type != GTK_SHADOW_NONE)
1147         {
1148           child_allocation.x -= widget->style->xthickness;
1149           child_allocation.width += 2 * widget->style->xthickness;
1150         }
1151
1152       gtk_widget_size_allocate (scrolled_window->hscrollbar, &child_allocation);
1153     }
1154   else if (GTK_WIDGET_VISIBLE (scrolled_window->hscrollbar))
1155     gtk_widget_hide (scrolled_window->hscrollbar);
1156
1157   if (scrolled_window->vscrollbar_visible)
1158     {
1159       GtkRequisition vscrollbar_requisition;
1160       if (!GTK_WIDGET_VISIBLE (scrolled_window->vscrollbar))
1161         gtk_widget_show (scrolled_window->vscrollbar);
1162
1163       gtk_widget_get_child_requisition (scrolled_window->vscrollbar,
1164                                         &vscrollbar_requisition);
1165
1166       if (scrolled_window->window_placement == GTK_CORNER_TOP_LEFT ||
1167           scrolled_window->window_placement == GTK_CORNER_BOTTOM_LEFT)
1168         child_allocation.x = (relative_allocation.x +
1169                               relative_allocation.width +
1170                               SCROLLBAR_SPACING (scrolled_window) +
1171                               (scrolled_window->shadow_type == GTK_SHADOW_NONE ?
1172                                0 : widget->style->xthickness));
1173       else
1174         child_allocation.x = GTK_CONTAINER (scrolled_window)->border_width;
1175
1176       child_allocation.y = relative_allocation.y;
1177       child_allocation.width = vscrollbar_requisition.width;
1178       child_allocation.height = relative_allocation.height;
1179       child_allocation.x += allocation->x;
1180       child_allocation.y += allocation->y;
1181
1182       if (scrolled_window->shadow_type != GTK_SHADOW_NONE)
1183         {
1184           child_allocation.y -= widget->style->ythickness;
1185           child_allocation.height += 2 * widget->style->ythickness;
1186         }
1187
1188       gtk_widget_size_allocate (scrolled_window->vscrollbar, &child_allocation);
1189     }
1190   else if (GTK_WIDGET_VISIBLE (scrolled_window->vscrollbar))
1191     gtk_widget_hide (scrolled_window->vscrollbar);
1192 }
1193
1194 static gint
1195 gtk_scrolled_window_scroll_event (GtkWidget *widget,
1196                                   GdkEventScroll *event)
1197 {
1198   GtkWidget *range;
1199
1200   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (widget), FALSE);
1201   g_return_val_if_fail (event != NULL, FALSE);
1202
1203   if (event->direction == GDK_SCROLL_UP || event->direction == GDK_SCROLL_DOWN)
1204     range = GTK_SCROLLED_WINDOW (widget)->vscrollbar;
1205   else
1206     range = GTK_SCROLLED_WINDOW (widget)->hscrollbar;
1207
1208   if (range && GTK_WIDGET_VISIBLE (range))
1209     {
1210       GtkAdjustment *adj = GTK_RANGE (range)->adjustment;
1211       gdouble new_value;
1212
1213       if (event->direction == GDK_SCROLL_UP || event->direction == GDK_SCROLL_LEFT)
1214         new_value = adj->value - adj->page_increment / 2;
1215       else
1216         new_value = adj->value + adj->page_increment / 2;
1217
1218       new_value = CLAMP (new_value, adj->lower, adj->upper - adj->page_size);
1219       gtk_adjustment_set_value (adj, new_value);
1220
1221       return TRUE;
1222     }
1223
1224   return FALSE;
1225 }
1226
1227 static gint
1228 gtk_scrolled_window_focus (GtkWidget        *widget,
1229                            GtkDirectionType  direction)
1230 {
1231   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
1232   gboolean had_focus_child = GTK_CONTAINER (widget)->focus_child != NULL;
1233
1234   if (scrolled_window->focus_out)
1235     {
1236       scrolled_window->focus_out = FALSE; /* Clear this to catch the wrap-around case */
1237       return FALSE;
1238     }
1239
1240   if (gtk_widget_is_focus (widget))
1241     return FALSE;
1242
1243   /* We only put the scrolled window itself in the focus chain if it
1244    * isn't possible to focus any children.
1245    */
1246   if (GTK_BIN (widget)->child)
1247     {
1248       if (gtk_widget_child_focus (GTK_BIN (widget)->child, direction))
1249         return TRUE;
1250     }
1251
1252   if (!had_focus_child)
1253     {
1254       gtk_widget_grab_focus (widget);
1255       return TRUE;
1256     }
1257   else
1258     return FALSE;
1259 }
1260
1261 static void
1262 gtk_scrolled_window_adjustment_changed (GtkAdjustment *adjustment,
1263                                         gpointer       data)
1264 {
1265   GtkScrolledWindow *scrolled_win;
1266
1267   g_return_if_fail (adjustment != NULL);
1268   g_return_if_fail (data != NULL);
1269
1270   scrolled_win = GTK_SCROLLED_WINDOW (data);
1271
1272   if (scrolled_win->hscrollbar &&
1273       adjustment == gtk_range_get_adjustment (GTK_RANGE (scrolled_win->hscrollbar)))
1274     {
1275       if (scrolled_win->hscrollbar_policy == GTK_POLICY_AUTOMATIC)
1276         {
1277           gboolean visible;
1278
1279           visible = scrolled_win->hscrollbar_visible;
1280           scrolled_win->hscrollbar_visible = (adjustment->upper - adjustment->lower >
1281                                               adjustment->page_size);
1282           if (scrolled_win->hscrollbar_visible != visible)
1283             gtk_widget_queue_resize (GTK_WIDGET (scrolled_win));
1284         }
1285     }
1286   else if (scrolled_win->vscrollbar &&
1287            adjustment == gtk_range_get_adjustment (GTK_RANGE (scrolled_win->vscrollbar)))
1288     {
1289       if (scrolled_win->vscrollbar_policy == GTK_POLICY_AUTOMATIC)
1290         {
1291           gboolean visible;
1292
1293           visible = scrolled_win->vscrollbar_visible;
1294           scrolled_win->vscrollbar_visible = (adjustment->upper - adjustment->lower >
1295                                               adjustment->page_size);
1296           if (scrolled_win->vscrollbar_visible != visible)
1297             gtk_widget_queue_resize (GTK_WIDGET (scrolled_win));
1298         }
1299     }
1300 }
1301
1302 static void
1303 gtk_scrolled_window_add (GtkContainer *container,
1304                          GtkWidget    *child)
1305 {
1306   GtkScrolledWindow *scrolled_window;
1307   GtkBin *bin;
1308
1309   bin = GTK_BIN (container);
1310   g_return_if_fail (bin->child == NULL);
1311
1312   scrolled_window = GTK_SCROLLED_WINDOW (container);
1313
1314   bin->child = child;
1315   gtk_widget_set_parent (child, GTK_WIDGET (bin));
1316
1317   /* this is a temporary message */
1318   if (!gtk_widget_set_scroll_adjustments (child,
1319                                           gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
1320                                           gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar))))
1321     g_warning ("gtk_scrolled_window_add(): cannot add non scrollable widget "
1322                "use gtk_scrolled_window_add_with_viewport() instead");
1323 }
1324
1325 static void
1326 gtk_scrolled_window_remove (GtkContainer *container,
1327                             GtkWidget    *child)
1328 {
1329   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (container));
1330   g_return_if_fail (child != NULL);
1331   g_return_if_fail (GTK_BIN (container)->child == child);
1332
1333   gtk_widget_set_scroll_adjustments (child, NULL, NULL);
1334
1335   /* chain parent class handler to remove child */
1336   GTK_CONTAINER_CLASS (parent_class)->remove (container, child);
1337 }
1338
1339 void
1340 gtk_scrolled_window_add_with_viewport (GtkScrolledWindow *scrolled_window,
1341                                        GtkWidget         *child)
1342 {
1343   GtkBin *bin;
1344   GtkWidget *viewport;
1345
1346   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
1347   g_return_if_fail (GTK_IS_WIDGET (child));
1348   g_return_if_fail (child->parent == NULL);
1349
1350   bin = GTK_BIN (scrolled_window);
1351
1352   if (bin->child != NULL)
1353     {
1354       g_return_if_fail (GTK_IS_VIEWPORT (bin->child));
1355       g_return_if_fail (GTK_BIN (bin->child)->child == NULL);
1356
1357       viewport = bin->child;
1358     }
1359   else
1360     {
1361       viewport =
1362         gtk_viewport_new (gtk_scrolled_window_get_hadjustment (scrolled_window),
1363                           gtk_scrolled_window_get_vadjustment (scrolled_window));
1364       gtk_container_add (GTK_CONTAINER (scrolled_window), viewport);
1365     }
1366
1367   gtk_widget_show (viewport);
1368   gtk_container_add (GTK_CONTAINER (viewport), child);
1369 }