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