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 Library 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  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library 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 #include "gtkscrolledwindow.h"
  20 #include "gtksignal.h"
  21
  22
  23 #define SCROLLBAR_SPACING(w) (GTK_SCROLLED_WINDOW_CLASS (GTK_OBJECT (w)->klass)->scrollbar_spacing)
  24
  25 enum {
  26   ARG_0,
  27   ARG_HADJUSTMENT,
  28   ARG_VADJUSTMENT,
  29   ARG_HSCROLLBAR_POLICY,
  30   ARG_VSCROLLBAR_POLICY,
  31   ARG_WINDOW_PLACEMENT
  32 };
  33
  34
  35 static void gtk_scrolled_window_class_init         (GtkScrolledWindowClass *klass);
  36 static void gtk_scrolled_window_init               (GtkScrolledWindow      *scrolled_window);
  37 static void gtk_scrolled_window_set_arg            (GtkObject              *object,
  38                                                     GtkArg                 *arg,
  39                                                     guint                   arg_id);
  40 static void gtk_scrolled_window_get_arg            (GtkObject              *object,
  41                                                     GtkArg                 *arg,
  42                                                     guint                   arg_id);
  43 static void gtk_scrolled_window_destroy            (GtkObject              *object);
  44 static void gtk_scrolled_window_finalize           (GtkObject              *object);
  45 static void gtk_scrolled_window_map                (GtkWidget              *widget);
  46 static void gtk_scrolled_window_unmap              (GtkWidget              *widget);
  47 static void gtk_scrolled_window_draw               (GtkWidget              *widget,
  48                                                     GdkRectangle           *area);
  49 static void gtk_scrolled_window_size_request       (GtkWidget              *widget,
  50                                                     GtkRequisition         *requisition);
  51 static void gtk_scrolled_window_size_allocate      (GtkWidget              *widget,
  52                                                     GtkAllocation          *allocation);
  53 static void gtk_scrolled_window_add                (GtkContainer           *container,
  54                                                     GtkWidget              *widget);
  55 static void gtk_scrolled_window_remove             (GtkContainer           *container,
  56                                                     GtkWidget              *widget);
  57 static void gtk_scrolled_window_forall             (GtkContainer           *container,
  58                                                     gboolean                include_internals,
  59                                                     GtkCallback             callback,
  60                                                     gpointer                callback_data);
  61 static void gtk_scrolled_window_relative_allocation(GtkWidget              *widget,
  62                                                     GtkAllocation          *allocation);
  63 static void gtk_scrolled_window_adjustment_changed (GtkAdjustment          *adjustment,
  64                                                     gpointer                data);
  65
  66
  67 static GtkContainerClass *parent_class = NULL;
  68
  69
  70 GtkType
  71 gtk_scrolled_window_get_type (void)
  72 {
  73   static GtkType scrolled_window_type = 0;
  74
  75   if (!scrolled_window_type)
  76     {
  77       static const GtkTypeInfo scrolled_window_info =
  78       {
  79         "GtkScrolledWindow",
  80         sizeof (GtkScrolledWindow),
  81         sizeof (GtkScrolledWindowClass),
  82         (GtkClassInitFunc) gtk_scrolled_window_class_init,
  83         (GtkObjectInitFunc) gtk_scrolled_window_init,
  84         /* reserved_1 */ NULL,
  85         /* reserved_2 */ NULL,
  86         (GtkClassInitFunc) NULL,
  87       };
  88
  89       scrolled_window_type = gtk_type_unique (GTK_TYPE_BIN, &scrolled_window_info);
  90     }
  91
  92   return scrolled_window_type;
  93 }
  94
  95 static void
  96 gtk_scrolled_window_class_init (GtkScrolledWindowClass *class)
  97 {
  98   GtkObjectClass *object_class;
  99   GtkWidgetClass *widget_class;
 100   GtkContainerClass *container_class;
 101
 102   object_class = (GtkObjectClass*) class;
 103   widget_class = (GtkWidgetClass*) class;
 104   container_class = (GtkContainerClass*) class;
 105   parent_class = gtk_type_class (GTK_TYPE_BIN);
 106
 107   gtk_object_add_arg_type ("GtkScrolledWindow::hadjustment",
 108                            GTK_TYPE_ADJUSTMENT,
 109                            GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
 110                            ARG_HADJUSTMENT);
 111   gtk_object_add_arg_type ("GtkScrolledWindow::vadjustment",
 112                            GTK_TYPE_ADJUSTMENT,
 113                            GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
 114                            ARG_VADJUSTMENT);
 115   gtk_object_add_arg_type ("GtkScrolledWindow::hscrollbar_policy",
 116                            GTK_TYPE_POLICY_TYPE,
 117                            GTK_ARG_READWRITE,
 118                            ARG_HSCROLLBAR_POLICY);
 119   gtk_object_add_arg_type ("GtkScrolledWindow::vscrollbar_policy",
 120                            GTK_TYPE_POLICY_TYPE,
 121                            GTK_ARG_READWRITE,
 122                            ARG_VSCROLLBAR_POLICY);
 123   gtk_object_add_arg_type ("GtkScrolledWindow::window_placement",
 124                            GTK_TYPE_CORNER_TYPE,
 125                            GTK_ARG_READWRITE,
 126                            ARG_WINDOW_PLACEMENT);
 127
 128   object_class->set_arg = gtk_scrolled_window_set_arg;
 129   object_class->get_arg = gtk_scrolled_window_get_arg;
 130   object_class->destroy = gtk_scrolled_window_destroy;
 131   object_class->finalize = gtk_scrolled_window_finalize;
 132
 133   widget_class->map = gtk_scrolled_window_map;
 134   widget_class->unmap = gtk_scrolled_window_unmap;
 135   widget_class->draw = gtk_scrolled_window_draw;
 136   widget_class->size_request = gtk_scrolled_window_size_request;
 137   widget_class->size_allocate = gtk_scrolled_window_size_allocate;
 138
 139   container_class->add = gtk_scrolled_window_add;
 140   container_class->remove = gtk_scrolled_window_remove;
 141   container_class->forall = gtk_scrolled_window_forall;
 142
 143   class->scrollbar_spacing = 5;
 144 }
 145
 146 static void
 147 gtk_scrolled_window_set_arg (GtkObject        *object,
 148                              GtkArg           *arg,
 149                              guint             arg_id)
 150 {
 151   GtkScrolledWindow *scrolled_window;
 152
 153   scrolled_window = GTK_SCROLLED_WINDOW (object);
 154
 155   switch (arg_id)
 156     {
 157     case ARG_HADJUSTMENT:
 158       gtk_scrolled_window_set_hadjustment (scrolled_window, GTK_VALUE_POINTER (*arg));
 159       break;
 160     case ARG_VADJUSTMENT:
 161       gtk_scrolled_window_set_vadjustment (scrolled_window, GTK_VALUE_POINTER (*arg));
 162       break;
 163     case ARG_HSCROLLBAR_POLICY:
 164       gtk_scrolled_window_set_policy (scrolled_window,
 165                                       GTK_VALUE_ENUM (*arg),
 166                                       scrolled_window->vscrollbar_policy);
 167       break;
 168     case ARG_VSCROLLBAR_POLICY:
 169       gtk_scrolled_window_set_policy (scrolled_window,
 170                                       scrolled_window->hscrollbar_policy,
 171                                       GTK_VALUE_ENUM (*arg));
 172       break;
 173     case ARG_WINDOW_PLACEMENT:
 174       gtk_scrolled_window_set_placement (scrolled_window,
 175                                          GTK_VALUE_ENUM (*arg));
 176       break;
 177     default:
 178       break;
 179     }
 180 }
 181
 182 static void
 183 gtk_scrolled_window_get_arg (GtkObject        *object,
 184                              GtkArg           *arg,
 185                              guint             arg_id)
 186 {
 187   GtkScrolledWindow *scrolled_window;
 188
 189   scrolled_window = GTK_SCROLLED_WINDOW (object);
 190
 191   switch (arg_id)
 192     {
 193     case ARG_HADJUSTMENT:
 194       GTK_VALUE_POINTER (*arg) = gtk_scrolled_window_get_hadjustment (scrolled_window);
 195       break;
 196     case ARG_VADJUSTMENT:
 197       GTK_VALUE_POINTER (*arg) = gtk_scrolled_window_get_vadjustment (scrolled_window);
 198       break;
 199     case ARG_HSCROLLBAR_POLICY:
 200       GTK_VALUE_ENUM (*arg) = scrolled_window->hscrollbar_policy;
 201       break;
 202     case ARG_VSCROLLBAR_POLICY:
 203       GTK_VALUE_ENUM (*arg) = scrolled_window->vscrollbar_policy;
 204       break;
 205     case ARG_WINDOW_PLACEMENT:
 206       GTK_VALUE_ENUM (*arg) = scrolled_window->window_placement;
 207       break;
 208     default:
 209       arg->type = GTK_TYPE_INVALID;
 210       break;
 211     }
 212 }
 213
 214 static void
 215 gtk_scrolled_window_init (GtkScrolledWindow *scrolled_window)
 216 {
 217   GTK_WIDGET_SET_FLAGS (scrolled_window, GTK_NO_WINDOW);
 218
 219   gtk_container_set_resize_mode (GTK_CONTAINER (scrolled_window), GTK_RESIZE_QUEUE);
 220
 221   scrolled_window->hscrollbar = NULL;
 222   scrolled_window->vscrollbar = NULL;
 223   scrolled_window->hscrollbar_policy = GTK_POLICY_ALWAYS;
 224   scrolled_window->vscrollbar_policy = GTK_POLICY_ALWAYS;
 225   scrolled_window->hscrollbar_visible = FALSE;
 226   scrolled_window->vscrollbar_visible = FALSE;
 227   scrolled_window->window_placement = GTK_CORNER_TOP_LEFT;
 228 }
 229
 230 GtkWidget*
 231 gtk_scrolled_window_new (GtkAdjustment *hadjustment,
 232                          GtkAdjustment *vadjustment)
 233 {
 234   GtkWidget *scrolled_window;
 235
 236   if (hadjustment)
 237     g_return_val_if_fail (GTK_IS_ADJUSTMENT (hadjustment), NULL);
 238
 239   if (vadjustment)
 240     g_return_val_if_fail (GTK_IS_ADJUSTMENT (vadjustment), NULL);
 241
 242   scrolled_window = gtk_widget_new (GTK_TYPE_SCROLLED_WINDOW,
 243                                     "hadjustment", hadjustment,
 244                                     "vadjustment", vadjustment,
 245                                     NULL);
 246
 247   return scrolled_window;
 248 }
 249
 250 void
 251 gtk_scrolled_window_construct (GtkScrolledWindow *scrolled_window,
 252                                GtkAdjustment     *hadjustment,
 253                                GtkAdjustment     *vadjustment)
 254 {
 255   g_message ("gtk_scrolled_window_construct() is deprecated");
 256   gtk_scrolled_window_set_hadjustment (scrolled_window, hadjustment);
 257   gtk_scrolled_window_set_vadjustment (scrolled_window, vadjustment);
 258   gtk_object_default_construct (GTK_OBJECT (scrolled_window));
 259 }
 260
 261 void
 262 gtk_scrolled_window_set_hadjustment (GtkScrolledWindow *scrolled_window,
 263                                      GtkAdjustment     *hadjustment)
 264 {
 265   GtkBin *bin;
 266
 267   g_return_if_fail (scrolled_window != NULL);
 268   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 269   if (hadjustment)
 270     g_return_if_fail (GTK_IS_ADJUSTMENT (hadjustment));
 271   else
 272     hadjustment = (GtkAdjustment*) gtk_object_new (GTK_TYPE_ADJUSTMENT, NULL);
 273
 274   bin = GTK_BIN (scrolled_window);
 275
 276   if (!scrolled_window->hscrollbar)
 277     {
 278       gtk_widget_push_composite_child ();
 279       scrolled_window->hscrollbar = gtk_hscrollbar_new (hadjustment);
 280       gtk_widget_set_composite_name (scrolled_window->hscrollbar, "hscrollbar");
 281       gtk_widget_pop_composite_child ();
 282
 283       gtk_widget_set_parent (scrolled_window->hscrollbar, GTK_WIDGET (scrolled_window));
 284       gtk_widget_ref (scrolled_window->hscrollbar);
 285       gtk_widget_show (scrolled_window->hscrollbar);
 286     }
 287   else
 288     {
 289       GtkAdjustment *old_adjustment;
 290
 291       old_adjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));
 292       if (old_adjustment == hadjustment)
 293         return;
 294
 295       gtk_signal_disconnect_by_func (GTK_OBJECT (old_adjustment),
 296                                      GTK_SIGNAL_FUNC (gtk_scrolled_window_adjustment_changed),
 297                                      scrolled_window);
 298       gtk_range_set_adjustment (GTK_RANGE (scrolled_window->hscrollbar),
 299                                 hadjustment);
 300     }
 301   hadjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));
 302   gtk_signal_connect (GTK_OBJECT (hadjustment),
 303                       "changed",
 304                       GTK_SIGNAL_FUNC (gtk_scrolled_window_adjustment_changed),
 305                       scrolled_window);
 306   gtk_scrolled_window_adjustment_changed (hadjustment, scrolled_window);
 307
 308   if (bin->child)
 309     gtk_widget_scroll_adjustements (bin->child,
 310                                     gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
 311                                     gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)));
 312 }
 313
 314 void
 315 gtk_scrolled_window_set_vadjustment (GtkScrolledWindow *scrolled_window,
 316                                      GtkAdjustment     *vadjustment)
 317 {
 318   GtkBin *bin;
 319
 320   g_return_if_fail (scrolled_window != NULL);
 321   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 322   if (vadjustment)
 323     g_return_if_fail (GTK_IS_ADJUSTMENT (vadjustment));
 324   else
 325     vadjustment = (GtkAdjustment*) gtk_object_new (GTK_TYPE_ADJUSTMENT, NULL);
 326
 327   bin = GTK_BIN (scrolled_window);
 328
 329   if (!scrolled_window->vscrollbar)
 330     {
 331       gtk_widget_push_composite_child ();
 332       scrolled_window->vscrollbar = gtk_vscrollbar_new (vadjustment);
 333       gtk_widget_set_composite_name (scrolled_window->vscrollbar, "vscrollbar");
 334       gtk_widget_pop_composite_child ();
 335
 336       gtk_widget_set_parent (scrolled_window->vscrollbar, GTK_WIDGET (scrolled_window));
 337       gtk_widget_ref (scrolled_window->vscrollbar);
 338       gtk_widget_show (scrolled_window->vscrollbar);
 339     }
 340   else
 341     {
 342       GtkAdjustment *old_adjustment;
 343
 344       old_adjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));
 345       if (old_adjustment == vadjustment)
 346         return;
 347
 348       gtk_signal_disconnect_by_func (GTK_OBJECT (old_adjustment),
 349                                      GTK_SIGNAL_FUNC (gtk_scrolled_window_adjustment_changed),
 350                                      scrolled_window);
 351       gtk_range_set_adjustment (GTK_RANGE (scrolled_window->vscrollbar),
 352                                 vadjustment);
 353     }
 354   vadjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));
 355   gtk_signal_connect (GTK_OBJECT (vadjustment),
 356                       "changed",
 357                       GTK_SIGNAL_FUNC (gtk_scrolled_window_adjustment_changed),
 358                       scrolled_window);
 359   gtk_scrolled_window_adjustment_changed (vadjustment, scrolled_window);
 360
 361   if (bin->child)
 362     gtk_widget_scroll_adjustements (bin->child,
 363                                     gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
 364                                     gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)));
 365 }
 366
 367 GtkAdjustment*
 368 gtk_scrolled_window_get_hadjustment (GtkScrolledWindow *scrolled_window)
 369 {
 370   g_return_val_if_fail (scrolled_window != NULL, NULL);
 371   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);
 372
 373   return (scrolled_window->hscrollbar ?
 374           gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)) :
 375           NULL);
 376 }
 377
 378 GtkAdjustment*
 379 gtk_scrolled_window_get_vadjustment (GtkScrolledWindow *scrolled_window)
 380 {
 381   g_return_val_if_fail (scrolled_window != NULL, NULL);
 382   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);
 383
 384   return (scrolled_window->vscrollbar ?
 385           gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)) :
 386           NULL);
 387 }
 388
 389 void
 390 gtk_scrolled_window_set_policy (GtkScrolledWindow *scrolled_window,
 391                                 GtkPolicyType      hscrollbar_policy,
 392                                 GtkPolicyType      vscrollbar_policy)
 393 {
 394   g_return_if_fail (scrolled_window != NULL);
 395   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 396
 397   if ((scrolled_window->hscrollbar_policy != hscrollbar_policy) ||
 398       (scrolled_window->vscrollbar_policy != vscrollbar_policy))
 399     {
 400       scrolled_window->hscrollbar_policy = hscrollbar_policy;
 401       scrolled_window->vscrollbar_policy = vscrollbar_policy;
 402
 403       gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
 404     }
 405 }
 406
 407 void
 408 gtk_scrolled_window_set_placement (GtkScrolledWindow *scrolled_window,
 409                                    GtkCornerType      window_placement)
 410 {
 411   g_return_if_fail (scrolled_window != NULL);
 412   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 413
 414   if (scrolled_window->window_placement != window_placement)
 415     {
 416       scrolled_window->window_placement = window_placement;
 417
 418       gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
 419     }
 420 }
 421
 422 static void
 423 gtk_scrolled_window_destroy (GtkObject *object)
 424 {
 425   GtkScrolledWindow *scrolled_window;
 426
 427   g_return_if_fail (object != NULL);
 428   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (object));
 429
 430   scrolled_window = GTK_SCROLLED_WINDOW (object);
 431
 432   gtk_widget_unparent (scrolled_window->hscrollbar);
 433   gtk_widget_unparent (scrolled_window->vscrollbar);
 434   gtk_widget_destroy (scrolled_window->hscrollbar);
 435   gtk_widget_destroy (scrolled_window->vscrollbar);
 436
 437   GTK_OBJECT_CLASS (parent_class)->destroy (object);
 438 }
 439
 440 static void
 441 gtk_scrolled_window_finalize (GtkObject *object)
 442 {
 443   GtkScrolledWindow *scrolled_window;
 444
 445   scrolled_window = GTK_SCROLLED_WINDOW (object);
 446
 447   gtk_widget_unref (scrolled_window->hscrollbar);
 448   gtk_widget_unref (scrolled_window->vscrollbar);
 449
 450   GTK_OBJECT_CLASS (parent_class)->finalize (object);
 451 }
 452
 453 static void
 454 gtk_scrolled_window_map (GtkWidget *widget)
 455 {
 456   GtkScrolledWindow *scrolled_window;
 457
 458   g_return_if_fail (widget != NULL);
 459   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
 460
 461   scrolled_window = GTK_SCROLLED_WINDOW (widget);
 462
 463   /* chain parent class handler to map self and child */
 464   GTK_WIDGET_CLASS (parent_class)->map (widget);
 465
 466   if (GTK_WIDGET_VISIBLE (scrolled_window->hscrollbar) &&
 467       !GTK_WIDGET_MAPPED (scrolled_window->hscrollbar))
 468     gtk_widget_map (scrolled_window->hscrollbar);
 469
 470   if (GTK_WIDGET_VISIBLE (scrolled_window->vscrollbar) &&
 471       !GTK_WIDGET_MAPPED (scrolled_window->vscrollbar))
 472     gtk_widget_map (scrolled_window->vscrollbar);
 473 }
 474
 475 static void
 476 gtk_scrolled_window_unmap (GtkWidget *widget)
 477 {
 478   GtkScrolledWindow *scrolled_window;
 479
 480   g_return_if_fail (widget != NULL);
 481   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
 482
 483   scrolled_window = GTK_SCROLLED_WINDOW (widget);
 484
 485   /* chain parent class handler to unmap self and child */
 486   GTK_WIDGET_CLASS (parent_class)->unmap (widget);
 487
 488   if (GTK_WIDGET_MAPPED (scrolled_window->hscrollbar))
 489     gtk_widget_unmap (scrolled_window->hscrollbar);
 490
 491   if (GTK_WIDGET_MAPPED (scrolled_window->vscrollbar))
 492     gtk_widget_unmap (scrolled_window->vscrollbar);
 493 }
 494
 495 static void
 496 gtk_scrolled_window_draw (GtkWidget    *widget,
 497                           GdkRectangle *area)
 498 {
 499   GtkScrolledWindow *scrolled_window;
 500   GtkBin *bin;
 501   GdkRectangle child_area;
 502
 503   g_return_if_fail (widget != NULL);
 504   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
 505   g_return_if_fail (area != NULL);
 506
 507   scrolled_window = GTK_SCROLLED_WINDOW (widget);
 508   bin = GTK_BIN (widget);
 509
 510   if (bin->child && GTK_WIDGET_VISIBLE (bin->child) &&
 511       gtk_widget_intersect (bin->child, area, &child_area))
 512     gtk_widget_draw (bin->child, &child_area);
 513
 514   if (GTK_WIDGET_VISIBLE (scrolled_window->hscrollbar) &&
 515       gtk_widget_intersect (scrolled_window->hscrollbar, area, &child_area))
 516     gtk_widget_draw (scrolled_window->hscrollbar, &child_area);
 517
 518   if (GTK_WIDGET_VISIBLE (scrolled_window->vscrollbar) &&
 519       gtk_widget_intersect (scrolled_window->vscrollbar, area, &child_area))
 520     gtk_widget_draw (scrolled_window->vscrollbar, &child_area);
 521 }
 522
 523 static void
 524 gtk_scrolled_window_forall (GtkContainer *container,
 525                             gboolean      include_internals,
 526                             GtkCallback   callback,
 527                             gpointer      callback_data)
 528 {
 529   g_return_if_fail (container != NULL);
 530   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (container));
 531   g_return_if_fail (callback != NULL);
 532
 533   GTK_CONTAINER_CLASS (parent_class)->forall (container,
 534                                               include_internals,
 535                                               callback,
 536                                               callback_data);
 537   if (include_internals)
 538     {
 539       GtkScrolledWindow *scrolled_window;
 540
 541       scrolled_window = GTK_SCROLLED_WINDOW (container);
 542
 543       if (scrolled_window->vscrollbar)
 544         callback (scrolled_window->vscrollbar, callback_data);
 545       if (scrolled_window->hscrollbar)
 546         callback (scrolled_window->hscrollbar, callback_data);
 547     }
 548 }
 549
 550 static void
 551 gtk_scrolled_window_size_request (GtkWidget      *widget,
 552                                   GtkRequisition *requisition)
 553 {
 554   GtkScrolledWindow *scrolled_window;
 555   GtkBin *bin;
 556   gint extra_height;
 557   gint extra_width;
 558
 559   g_return_if_fail (widget != NULL);
 560   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
 561   g_return_if_fail (requisition != NULL);
 562
 563   scrolled_window = GTK_SCROLLED_WINDOW (widget);
 564   bin = GTK_BIN (scrolled_window);
 565
 566   requisition->width = 0;
 567   requisition->height = 0;
 568
 569   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
 570     {
 571       gtk_widget_size_request (bin->child, &bin->child->requisition);
 572
 573       requisition->width += bin->child->requisition.width;
 574       requisition->height += bin->child->requisition.height;
 575     }
 576
 577   extra_width = 0;
 578   extra_height = 0;
 579
 580   if ((scrolled_window->hscrollbar_policy == GTK_POLICY_AUTOMATIC) ||
 581       GTK_WIDGET_VISIBLE (scrolled_window->hscrollbar))
 582     {
 583       gtk_widget_size_request (scrolled_window->hscrollbar,
 584                                &scrolled_window->hscrollbar->requisition);
 585
 586       requisition->width = MAX (requisition->width, scrolled_window->hscrollbar->requisition.width);
 587       extra_height = SCROLLBAR_SPACING (scrolled_window) + scrolled_window->hscrollbar->requisition.height;
 588     }
 589
 590   if ((scrolled_window->vscrollbar_policy == GTK_POLICY_AUTOMATIC) ||
 591       GTK_WIDGET_VISIBLE (scrolled_window->vscrollbar))
 592     {
 593       gtk_widget_size_request (scrolled_window->vscrollbar,
 594                                &scrolled_window->vscrollbar->requisition);
 595
 596       requisition->height = MAX (requisition->height, scrolled_window->vscrollbar->requisition.height);
 597       extra_width = SCROLLBAR_SPACING (scrolled_window) + scrolled_window->vscrollbar->requisition.width;
 598     }
 599
 600   requisition->width += GTK_CONTAINER (widget)->border_width * 2 + extra_width;
 601   requisition->height += GTK_CONTAINER (widget)->border_width * 2 + extra_height;
 602 }
 603
 604 static void
 605 gtk_scrolled_window_relative_allocation (GtkWidget     *widget,
 606                                          GtkAllocation *allocation)
 607 {
 608   GtkScrolledWindow *scrolled_window;
 609
 610   g_return_if_fail (widget != NULL);
 611   g_return_if_fail (allocation != NULL);
 612
 613   scrolled_window = GTK_SCROLLED_WINDOW (widget);
 614
 615   allocation->x = GTK_CONTAINER (widget)->border_width;
 616   allocation->y = GTK_CONTAINER (widget)->border_width;
 617   allocation->width = MAX (1, widget->allocation.width - allocation->x * 2);
 618   allocation->height = MAX (1, widget->allocation.height - allocation->y * 2);
 619
 620   if (scrolled_window->vscrollbar_visible)
 621     {
 622       if (scrolled_window->window_placement == GTK_CORNER_TOP_RIGHT ||
 623           scrolled_window->window_placement == GTK_CORNER_BOTTOM_RIGHT)
 624         allocation->x += (scrolled_window->vscrollbar->requisition.width +
 625                           SCROLLBAR_SPACING (scrolled_window));
 626
 627       allocation->width = MAX (1, allocation->width -
 628                                (scrolled_window->vscrollbar->requisition.width +
 629                                 SCROLLBAR_SPACING (scrolled_window)));
 630     }
 631   if (scrolled_window->hscrollbar_visible)
 632     {
 633       if (scrolled_window->window_placement == GTK_CORNER_BOTTOM_LEFT ||
 634           scrolled_window->window_placement == GTK_CORNER_BOTTOM_RIGHT)
 635         allocation->y += (scrolled_window->hscrollbar->requisition.height +
 636                           SCROLLBAR_SPACING (scrolled_window));
 637
 638       allocation->height = MAX (1, allocation->height -
 639                                 (scrolled_window->hscrollbar->requisition.height +
 640                                  SCROLLBAR_SPACING (scrolled_window)));
 641     }
 642 }
 643
 644 static void
 645 gtk_scrolled_window_size_allocate (GtkWidget     *widget,
 646                                    GtkAllocation *allocation)
 647 {
 648   GtkScrolledWindow *scrolled_window;
 649   GtkBin *bin;
 650   GtkAllocation relative_allocation;
 651   GtkAllocation child_allocation;
 652
 653   g_return_if_fail (widget != NULL);
 654   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
 655   g_return_if_fail (allocation != NULL);
 656
 657   scrolled_window = GTK_SCROLLED_WINDOW (widget);
 658   bin = GTK_BIN (scrolled_window);
 659
 660   widget->allocation = *allocation;
 661
 662   if (scrolled_window->hscrollbar_policy == GTK_POLICY_ALWAYS)
 663     scrolled_window->hscrollbar_visible = TRUE;
 664   if (scrolled_window->vscrollbar_policy == GTK_POLICY_ALWAYS)
 665     scrolled_window->vscrollbar_visible = TRUE;
 666
 667   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
 668     {
 669       gboolean previous_hvis;
 670       gboolean previous_vvis;
 671       guint count = 0;
 672
 673       do
 674         {
 675           gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
 676
 677           child_allocation.x = relative_allocation.x + allocation->x;
 678           child_allocation.y = relative_allocation.y + allocation->y;
 679           child_allocation.width = relative_allocation.width;
 680           child_allocation.height = relative_allocation.height;
 681
 682           previous_hvis = scrolled_window->hscrollbar_visible;
 683           previous_vvis = scrolled_window->vscrollbar_visible;
 684
 685           gtk_widget_size_allocate (bin->child, &child_allocation);
 686
 687           /* If, after the first iteration, the hscrollbar and the
 688            * vscrollbar flip visiblity, then we need both.
 689            */
 690           if (count &&
 691               previous_hvis != scrolled_window->hscrollbar_visible &&
 692               previous_vvis != scrolled_window->vscrollbar_visible)
 693             {
 694               scrolled_window->hscrollbar_visible = TRUE;
 695               scrolled_window->vscrollbar_visible = TRUE;
 696
 697               /* a new resize is already queued at this point,
 698                * so we will immediatedly get reinvoked
 699                */
 700               return;
 701             }
 702
 703           count++;
 704         }
 705       while (previous_hvis != scrolled_window->hscrollbar_visible ||
 706              previous_vvis != scrolled_window->vscrollbar_visible);
 707     }
 708   else
 709     gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
 710
 711   if (scrolled_window->hscrollbar_visible)
 712     {
 713       if (!GTK_WIDGET_VISIBLE (scrolled_window->hscrollbar))
 714         gtk_widget_show (scrolled_window->hscrollbar);
 715
 716       child_allocation.x = relative_allocation.x;
 717       if (scrolled_window->window_placement == GTK_CORNER_TOP_LEFT ||
 718           scrolled_window->window_placement == GTK_CORNER_TOP_RIGHT)
 719         child_allocation.y = (relative_allocation.y +
 720                               relative_allocation.height +
 721                               SCROLLBAR_SPACING (scrolled_window));
 722       else
 723         child_allocation.y = GTK_CONTAINER (scrolled_window)->border_width;
 724
 725       child_allocation.width = relative_allocation.width;
 726       child_allocation.height = scrolled_window->hscrollbar->requisition.height;
 727       child_allocation.x += allocation->x;
 728       child_allocation.y += allocation->y;
 729
 730       gtk_widget_size_allocate (scrolled_window->hscrollbar, &child_allocation);
 731     }
 732   else if (GTK_WIDGET_VISIBLE (scrolled_window->hscrollbar))
 733     gtk_widget_hide (scrolled_window->hscrollbar);
 734
 735   if (scrolled_window->vscrollbar_visible)
 736     {
 737       if (!GTK_WIDGET_VISIBLE (scrolled_window->vscrollbar))
 738         gtk_widget_show (scrolled_window->vscrollbar);
 739
 740       if (scrolled_window->window_placement == GTK_CORNER_TOP_LEFT ||
 741           scrolled_window->window_placement == GTK_CORNER_BOTTOM_LEFT)
 742         child_allocation.x = (relative_allocation.x +
 743                               relative_allocation.width +
 744                               SCROLLBAR_SPACING (scrolled_window));
 745       else
 746         child_allocation.x = GTK_CONTAINER (scrolled_window)->border_width;
 747
 748       child_allocation.y = relative_allocation.y;
 749       child_allocation.width = scrolled_window->vscrollbar->requisition.width;
 750       child_allocation.height = relative_allocation.height;
 751       child_allocation.x += allocation->x;
 752       child_allocation.y += allocation->y;
 753
 754       gtk_widget_size_allocate (scrolled_window->vscrollbar, &child_allocation);
 755     }
 756   else if (GTK_WIDGET_VISIBLE (scrolled_window->vscrollbar))
 757     gtk_widget_hide (scrolled_window->vscrollbar);
 758 }
 759
 760
 761 static void
 762 gtk_scrolled_window_adjustment_changed (GtkAdjustment *adjustment,
 763                                         gpointer       data)
 764 {
 765   GtkScrolledWindow *scrolled_win;
 766
 767   g_return_if_fail (adjustment != NULL);
 768   g_return_if_fail (data != NULL);
 769
 770   scrolled_win = GTK_SCROLLED_WINDOW (data);
 771
 772   if (adjustment == gtk_range_get_adjustment (GTK_RANGE (scrolled_win->hscrollbar)))
 773     {
 774       if (scrolled_win->hscrollbar_policy == GTK_POLICY_AUTOMATIC)
 775         {
 776           gboolean visible;
 777
 778           visible = scrolled_win->hscrollbar_visible;
 779           scrolled_win->hscrollbar_visible = (adjustment->upper - adjustment->lower >
 780                                               adjustment->page_size);
 781           if (scrolled_win->hscrollbar_visible != visible)
 782             gtk_widget_queue_resize (GTK_WIDGET (scrolled_win));
 783         }
 784     }
 785   else if (adjustment == gtk_range_get_adjustment (GTK_RANGE (scrolled_win->vscrollbar)))
 786     {
 787       if (scrolled_win->vscrollbar_policy == GTK_POLICY_AUTOMATIC)
 788         {
 789           gboolean visible;
 790
 791           visible = scrolled_win->vscrollbar_visible;
 792           scrolled_win->vscrollbar_visible = (adjustment->upper - adjustment->lower >
 793                                               adjustment->page_size);
 794           if (scrolled_win->vscrollbar_visible != visible)
 795             gtk_widget_queue_resize (GTK_WIDGET (scrolled_win));
 796         }
 797     }
 798 }
 799
 800 static void
 801 gtk_scrolled_window_add (GtkContainer *container,
 802                          GtkWidget    *child)
 803 {
 804   GtkScrolledWindow *scrolled_window;
 805   GtkBin *bin;
 806
 807   bin = GTK_BIN (container);
 808   g_return_if_fail (bin->child == NULL);
 809
 810   scrolled_window = GTK_SCROLLED_WINDOW (container);
 811
 812   gtk_widget_set_parent (child, GTK_WIDGET (bin));
 813   bin->child = child;
 814
 815   /* this is a temporary message */
 816   if (!gtk_widget_scroll_adjustements (child,
 817                                        gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
 818                                        gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar))))
 819     g_message ("gtk_scrolled_window_add(): cannot add non scrollable widget "
 820                "use gtk_scrolled_window_add_with_viewport() instead");
 821
 822   if (GTK_WIDGET_VISIBLE (child->parent))
 823     {
 824       if (GTK_WIDGET_REALIZED (child->parent) &&
 825           !GTK_WIDGET_REALIZED (child))
 826         gtk_widget_realize (child);
 827
 828       if (GTK_WIDGET_MAPPED (child->parent) &&
 829           !GTK_WIDGET_MAPPED (child))
 830         gtk_widget_map (child);
 831     }
 832
 833   if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (container))
 834     gtk_widget_queue_resize (child);
 835 }
 836
 837 static void
 838 gtk_scrolled_window_remove (GtkContainer *container,
 839                             GtkWidget    *child)
 840 {
 841   g_return_if_fail (container != NULL);
 842   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (container));
 843   g_return_if_fail (child != NULL);
 844   g_return_if_fail (GTK_BIN (container)->child == child);
 845
 846   gtk_widget_scroll_adjustements (child, NULL, NULL);
 847
 848   /* chain parent class handler to remove child */
 849   GTK_CONTAINER_CLASS (parent_class)->remove (container, child);
 850 }
 851
 852 void
 853 gtk_scrolled_window_add_with_viewport (GtkScrolledWindow *scrolled_window,
 854                                        GtkWidget         *child)
 855 {
 856   GtkBin *bin;
 857   GtkWidget *viewport;
 858
 859   g_return_if_fail (scrolled_window != NULL);
 860   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 861   g_return_if_fail (child != NULL);
 862   g_return_if_fail (GTK_IS_WIDGET (child));
 863   g_return_if_fail (child->parent == NULL);
 864
 865   bin = GTK_BIN (scrolled_window);
 866
 867   if (bin->child != NULL)
 868     {
 869       g_return_if_fail (GTK_IS_VIEWPORT (bin->child));
 870       g_return_if_fail (GTK_BIN (bin->child)->child == NULL);
 871
 872       viewport = bin->child;
 873     }
 874   else
 875     {
 876       viewport =
 877         gtk_viewport_new (gtk_scrolled_window_get_hadjustment (scrolled_window),
 878                           gtk_scrolled_window_get_vadjustment (scrolled_window));
 879       gtk_container_add (GTK_CONTAINER (scrolled_window), viewport);
 880     }
 881
 882   gtk_widget_show (viewport);
 883   gtk_container_add (GTK_CONTAINER (viewport), child);
 884 }