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       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_pop_composite_child ();
 281
 282       gtk_widget_set_parent (scrolled_window->hscrollbar, GTK_WIDGET (scrolled_window));
 283       gtk_widget_ref (scrolled_window->hscrollbar);
 284       gtk_widget_show (scrolled_window->hscrollbar);
 285     }
 286   else
 287     {
 288       GtkAdjustment *old_adjustment;
 289
 290       old_adjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));
 291       if (old_adjustment == hadjustment)
 292         return;
 293
 294       gtk_signal_disconnect_by_func (GTK_OBJECT (old_adjustment),
 295                                      GTK_SIGNAL_FUNC (gtk_scrolled_window_adjustment_changed),
 296                                      scrolled_window);
 297       gtk_range_set_adjustment (GTK_RANGE (scrolled_window->hscrollbar),
 298                                 hadjustment);
 299     }
 300   hadjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));
 301   gtk_signal_connect (GTK_OBJECT (hadjustment),
 302                       "changed",
 303                       GTK_SIGNAL_FUNC (gtk_scrolled_window_adjustment_changed),
 304                       scrolled_window);
 305   gtk_scrolled_window_adjustment_changed (hadjustment, scrolled_window);
 306
 307   if (bin->child)
 308     gtk_widget_scroll_adjustements (bin->child,
 309                                     gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
 310                                     gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)));
 311 }
 312
 313 void
 314 gtk_scrolled_window_set_vadjustment (GtkScrolledWindow *scrolled_window,
 315                                      GtkAdjustment     *vadjustment)
 316 {
 317   GtkBin *bin;
 318
 319   g_return_if_fail (scrolled_window != NULL);
 320   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 321   if (vadjustment)
 322     g_return_if_fail (GTK_IS_ADJUSTMENT (vadjustment));
 323   else
 324     vadjustment = (GtkAdjustment*) gtk_object_new (GTK_TYPE_ADJUSTMENT, NULL);
 325
 326   bin = GTK_BIN (scrolled_window);
 327
 328   if (!scrolled_window->vscrollbar)
 329     {
 330       gtk_widget_push_composite_child ();
 331       scrolled_window->vscrollbar = gtk_vscrollbar_new (vadjustment);
 332       gtk_widget_pop_composite_child ();
 333
 334       gtk_widget_set_parent (scrolled_window->vscrollbar, GTK_WIDGET (scrolled_window));
 335       gtk_widget_ref (scrolled_window->vscrollbar);
 336       gtk_widget_show (scrolled_window->vscrollbar);
 337     }
 338   else
 339     {
 340       GtkAdjustment *old_adjustment;
 341
 342       old_adjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));
 343       if (old_adjustment == vadjustment)
 344         return;
 345
 346       gtk_signal_disconnect_by_func (GTK_OBJECT (old_adjustment),
 347                                      GTK_SIGNAL_FUNC (gtk_scrolled_window_adjustment_changed),
 348                                      scrolled_window);
 349       gtk_range_set_adjustment (GTK_RANGE (scrolled_window->vscrollbar),
 350                                 vadjustment);
 351     }
 352   vadjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));
 353   gtk_signal_connect (GTK_OBJECT (vadjustment),
 354                       "changed",
 355                       GTK_SIGNAL_FUNC (gtk_scrolled_window_adjustment_changed),
 356                       scrolled_window);
 357   gtk_scrolled_window_adjustment_changed (vadjustment, scrolled_window);
 358
 359   if (bin->child)
 360     gtk_widget_scroll_adjustements (bin->child,
 361                                     gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
 362                                     gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)));
 363 }
 364
 365 GtkAdjustment*
 366 gtk_scrolled_window_get_hadjustment (GtkScrolledWindow *scrolled_window)
 367 {
 368   g_return_val_if_fail (scrolled_window != NULL, NULL);
 369   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);
 370
 371   return (scrolled_window->hscrollbar ?
 372           gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)) :
 373           NULL);
 374 }
 375
 376 GtkAdjustment*
 377 gtk_scrolled_window_get_vadjustment (GtkScrolledWindow *scrolled_window)
 378 {
 379   g_return_val_if_fail (scrolled_window != NULL, NULL);
 380   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);
 381
 382   return (scrolled_window->vscrollbar ?
 383           gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)) :
 384           NULL);
 385 }
 386
 387 void
 388 gtk_scrolled_window_set_policy (GtkScrolledWindow *scrolled_window,
 389                                 GtkPolicyType      hscrollbar_policy,
 390                                 GtkPolicyType      vscrollbar_policy)
 391 {
 392   g_return_if_fail (scrolled_window != NULL);
 393   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 394
 395   if ((scrolled_window->hscrollbar_policy != hscrollbar_policy) ||
 396       (scrolled_window->vscrollbar_policy != vscrollbar_policy))
 397     {
 398       scrolled_window->hscrollbar_policy = hscrollbar_policy;
 399       scrolled_window->vscrollbar_policy = vscrollbar_policy;
 400
 401       gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
 402     }
 403 }
 404
 405 void
 406 gtk_scrolled_window_set_placement (GtkScrolledWindow *scrolled_window,
 407                                    GtkCornerType      window_placement)
 408 {
 409   g_return_if_fail (scrolled_window != NULL);
 410   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 411
 412   if (scrolled_window->window_placement != window_placement)
 413     {
 414       scrolled_window->window_placement = window_placement;
 415
 416       gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
 417     }
 418 }
 419
 420 static void
 421 gtk_scrolled_window_destroy (GtkObject *object)
 422 {
 423   GtkScrolledWindow *scrolled_window;
 424
 425   g_return_if_fail (object != NULL);
 426   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (object));
 427
 428   scrolled_window = GTK_SCROLLED_WINDOW (object);
 429
 430   gtk_widget_unparent (scrolled_window->hscrollbar);
 431   gtk_widget_unparent (scrolled_window->vscrollbar);
 432   gtk_widget_destroy (scrolled_window->hscrollbar);
 433   gtk_widget_destroy (scrolled_window->vscrollbar);
 434
 435   GTK_OBJECT_CLASS (parent_class)->destroy (object);
 436 }
 437
 438 static void
 439 gtk_scrolled_window_finalize (GtkObject *object)
 440 {
 441   GtkScrolledWindow *scrolled_window;
 442
 443   scrolled_window = GTK_SCROLLED_WINDOW (object);
 444
 445   gtk_widget_unref (scrolled_window->hscrollbar);
 446   gtk_widget_unref (scrolled_window->vscrollbar);
 447
 448   GTK_OBJECT_CLASS (parent_class)->finalize (object);
 449 }
 450
 451 static void
 452 gtk_scrolled_window_map (GtkWidget *widget)
 453 {
 454   GtkScrolledWindow *scrolled_window;
 455
 456   g_return_if_fail (widget != NULL);
 457   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
 458
 459   scrolled_window = GTK_SCROLLED_WINDOW (widget);
 460
 461   /* chain parent class handler to map self and child */
 462   GTK_WIDGET_CLASS (parent_class)->map (widget);
 463
 464   if (GTK_WIDGET_VISIBLE (scrolled_window->hscrollbar) &&
 465       !GTK_WIDGET_MAPPED (scrolled_window->hscrollbar))
 466     gtk_widget_map (scrolled_window->hscrollbar);
 467
 468   if (GTK_WIDGET_VISIBLE (scrolled_window->vscrollbar) &&
 469       !GTK_WIDGET_MAPPED (scrolled_window->vscrollbar))
 470     gtk_widget_map (scrolled_window->vscrollbar);
 471 }
 472
 473 static void
 474 gtk_scrolled_window_unmap (GtkWidget *widget)
 475 {
 476   GtkScrolledWindow *scrolled_window;
 477
 478   g_return_if_fail (widget != NULL);
 479   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
 480
 481   scrolled_window = GTK_SCROLLED_WINDOW (widget);
 482
 483   /* chain parent class handler to unmap self and child */
 484   GTK_WIDGET_CLASS (parent_class)->unmap (widget);
 485
 486   if (GTK_WIDGET_MAPPED (scrolled_window->hscrollbar))
 487     gtk_widget_unmap (scrolled_window->hscrollbar);
 488
 489   if (GTK_WIDGET_MAPPED (scrolled_window->vscrollbar))
 490     gtk_widget_unmap (scrolled_window->vscrollbar);
 491 }
 492
 493 static void
 494 gtk_scrolled_window_draw (GtkWidget    *widget,
 495                           GdkRectangle *area)
 496 {
 497   GtkScrolledWindow *scrolled_window;
 498   GtkBin *bin;
 499   GdkRectangle child_area;
 500
 501   g_return_if_fail (widget != NULL);
 502   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
 503   g_return_if_fail (area != NULL);
 504
 505   scrolled_window = GTK_SCROLLED_WINDOW (widget);
 506   bin = GTK_BIN (widget);
 507
 508   if (bin->child && GTK_WIDGET_VISIBLE (bin->child) &&
 509       gtk_widget_intersect (bin->child, area, &child_area))
 510     gtk_widget_draw (bin->child, &child_area);
 511
 512   if (GTK_WIDGET_VISIBLE (scrolled_window->hscrollbar) &&
 513       gtk_widget_intersect (scrolled_window->hscrollbar, area, &child_area))
 514     gtk_widget_draw (scrolled_window->hscrollbar, &child_area);
 515
 516   if (GTK_WIDGET_VISIBLE (scrolled_window->vscrollbar) &&
 517       gtk_widget_intersect (scrolled_window->vscrollbar, area, &child_area))
 518     gtk_widget_draw (scrolled_window->vscrollbar, &child_area);
 519 }
 520
 521 static void
 522 gtk_scrolled_window_forall (GtkContainer *container,
 523                             gboolean      include_internals,
 524                             GtkCallback   callback,
 525                             gpointer      callback_data)
 526 {
 527   g_return_if_fail (container != NULL);
 528   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (container));
 529   g_return_if_fail (callback != NULL);
 530
 531   GTK_CONTAINER_CLASS (parent_class)->forall (container,
 532                                               include_internals,
 533                                               callback,
 534                                               callback_data);
 535   if (include_internals)
 536     {
 537       GtkScrolledWindow *scrolled_window;
 538
 539       scrolled_window = GTK_SCROLLED_WINDOW (container);
 540
 541       if (scrolled_window->vscrollbar)
 542         callback (scrolled_window->vscrollbar, callback_data);
 543       if (scrolled_window->hscrollbar)
 544         callback (scrolled_window->hscrollbar, callback_data);
 545     }
 546 }
 547
 548 static void
 549 gtk_scrolled_window_size_request (GtkWidget      *widget,
 550                                   GtkRequisition *requisition)
 551 {
 552   GtkScrolledWindow *scrolled_window;
 553   GtkBin *bin;
 554   gint extra_height;
 555   gint extra_width;
 556
 557   g_return_if_fail (widget != NULL);
 558   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
 559   g_return_if_fail (requisition != NULL);
 560
 561   scrolled_window = GTK_SCROLLED_WINDOW (widget);
 562   bin = GTK_BIN (scrolled_window);
 563
 564   requisition->width = 0;
 565   requisition->height = 0;
 566
 567   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
 568     {
 569       gtk_widget_size_request (bin->child, &bin->child->requisition);
 570
 571       requisition->width += bin->child->requisition.width;
 572       requisition->height += bin->child->requisition.height;
 573     }
 574
 575   extra_width = 0;
 576   extra_height = 0;
 577
 578   if ((scrolled_window->hscrollbar_policy == GTK_POLICY_AUTOMATIC) ||
 579       GTK_WIDGET_VISIBLE (scrolled_window->hscrollbar))
 580     {
 581       gtk_widget_size_request (scrolled_window->hscrollbar,
 582                                &scrolled_window->hscrollbar->requisition);
 583
 584       requisition->width = MAX (requisition->width, scrolled_window->hscrollbar->requisition.width);
 585       extra_height = SCROLLBAR_SPACING (scrolled_window) + scrolled_window->hscrollbar->requisition.height;
 586     }
 587
 588   if ((scrolled_window->vscrollbar_policy == GTK_POLICY_AUTOMATIC) ||
 589       GTK_WIDGET_VISIBLE (scrolled_window->vscrollbar))
 590     {
 591       gtk_widget_size_request (scrolled_window->vscrollbar,
 592                                &scrolled_window->vscrollbar->requisition);
 593
 594       requisition->height = MAX (requisition->height, scrolled_window->vscrollbar->requisition.height);
 595       extra_width = SCROLLBAR_SPACING (scrolled_window) + scrolled_window->vscrollbar->requisition.width;
 596     }
 597
 598   requisition->width += GTK_CONTAINER (widget)->border_width * 2 + extra_width;
 599   requisition->height += GTK_CONTAINER (widget)->border_width * 2 + extra_height;
 600 }
 601
 602 static void
 603 gtk_scrolled_window_relative_allocation (GtkWidget     *widget,
 604                                          GtkAllocation *allocation)
 605 {
 606   GtkScrolledWindow *scrolled_window;
 607
 608   g_return_if_fail (widget != NULL);
 609   g_return_if_fail (allocation != NULL);
 610
 611   scrolled_window = GTK_SCROLLED_WINDOW (widget);
 612
 613   allocation->x = GTK_CONTAINER (widget)->border_width;
 614   allocation->y = GTK_CONTAINER (widget)->border_width;
 615   allocation->width = MAX (1, widget->allocation.width - allocation->x * 2);
 616   allocation->height = MAX (1, widget->allocation.height - allocation->y * 2);
 617
 618   if (scrolled_window->vscrollbar_visible)
 619     {
 620       if (scrolled_window->window_placement == GTK_CORNER_TOP_RIGHT ||
 621           scrolled_window->window_placement == GTK_CORNER_BOTTOM_RIGHT)
 622         allocation->x += (scrolled_window->vscrollbar->requisition.width +
 623                           SCROLLBAR_SPACING (scrolled_window));
 624
 625       allocation->width = MAX (1, allocation->width -
 626                                (scrolled_window->vscrollbar->requisition.width +
 627                                 SCROLLBAR_SPACING (scrolled_window)));
 628     }
 629   if (scrolled_window->hscrollbar_visible)
 630     {
 631       if (scrolled_window->window_placement == GTK_CORNER_BOTTOM_LEFT ||
 632           scrolled_window->window_placement == GTK_CORNER_BOTTOM_RIGHT)
 633         allocation->y += (scrolled_window->hscrollbar->requisition.height +
 634                           SCROLLBAR_SPACING (scrolled_window));
 635
 636       allocation->height = MAX (1, allocation->height -
 637                                 (scrolled_window->hscrollbar->requisition.height +
 638                                  SCROLLBAR_SPACING (scrolled_window)));
 639     }
 640 }
 641
 642 static void
 643 gtk_scrolled_window_size_allocate (GtkWidget     *widget,
 644                                    GtkAllocation *allocation)
 645 {
 646   GtkScrolledWindow *scrolled_window;
 647   GtkBin *bin;
 648   GtkAllocation relative_allocation;
 649   GtkAllocation child_allocation;
 650
 651   g_return_if_fail (widget != NULL);
 652   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
 653   g_return_if_fail (allocation != NULL);
 654
 655   scrolled_window = GTK_SCROLLED_WINDOW (widget);
 656   bin = GTK_BIN (scrolled_window);
 657
 658   widget->allocation = *allocation;
 659
 660   if (scrolled_window->hscrollbar_policy == GTK_POLICY_ALWAYS)
 661     scrolled_window->hscrollbar_visible = TRUE;
 662   if (scrolled_window->vscrollbar_policy == GTK_POLICY_ALWAYS)
 663     scrolled_window->vscrollbar_visible = TRUE;
 664
 665   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
 666     {
 667       gboolean previous_hvis;
 668       gboolean previous_vvis;
 669       guint count = 0;
 670
 671       do
 672         {
 673           gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
 674
 675           child_allocation.x = relative_allocation.x + allocation->x;
 676           child_allocation.y = relative_allocation.y + allocation->y;
 677           child_allocation.width = relative_allocation.width;
 678           child_allocation.height = relative_allocation.height;
 679
 680           previous_hvis = scrolled_window->hscrollbar_visible;
 681           previous_vvis = scrolled_window->vscrollbar_visible;
 682
 683           gtk_widget_size_allocate (bin->child, &child_allocation);
 684
 685           /* If, after the first iteration, the hscrollbar and the
 686            * vscrollbar flip visiblity, then we need both.
 687            */
 688           if (count &&
 689               previous_hvis != scrolled_window->hscrollbar_visible &&
 690               previous_vvis != scrolled_window->vscrollbar_visible)
 691             {
 692               scrolled_window->hscrollbar_visible = TRUE;
 693               scrolled_window->vscrollbar_visible = TRUE;
 694
 695               /* a new resize is already queued at this point,
 696                * so we will immediatedly get reinvoked
 697                */
 698               return;
 699             }
 700
 701           count++;
 702         }
 703       while (previous_hvis != scrolled_window->hscrollbar_visible ||
 704              previous_vvis != scrolled_window->vscrollbar_visible);
 705     }
 706   else
 707     gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
 708
 709   if (scrolled_window->hscrollbar_visible)
 710     {
 711       if (!GTK_WIDGET_VISIBLE (scrolled_window->hscrollbar))
 712         gtk_widget_show (scrolled_window->hscrollbar);
 713
 714       child_allocation.x = relative_allocation.x;
 715       if (scrolled_window->window_placement == GTK_CORNER_TOP_LEFT ||
 716           scrolled_window->window_placement == GTK_CORNER_TOP_RIGHT)
 717         child_allocation.y = (relative_allocation.y +
 718                               relative_allocation.height +
 719                               SCROLLBAR_SPACING (scrolled_window));
 720       else
 721         child_allocation.y = GTK_CONTAINER (scrolled_window)->border_width;
 722
 723       child_allocation.width = relative_allocation.width;
 724       child_allocation.height = scrolled_window->hscrollbar->requisition.height;
 725       child_allocation.x += allocation->x;
 726       child_allocation.y += allocation->y;
 727
 728       gtk_widget_size_allocate (scrolled_window->hscrollbar, &child_allocation);
 729     }
 730   else if (GTK_WIDGET_VISIBLE (scrolled_window->hscrollbar))
 731     gtk_widget_hide (scrolled_window->hscrollbar);
 732
 733   if (scrolled_window->vscrollbar_visible)
 734     {
 735       if (!GTK_WIDGET_VISIBLE (scrolled_window->vscrollbar))
 736         gtk_widget_show (scrolled_window->vscrollbar);
 737
 738       if (scrolled_window->window_placement == GTK_CORNER_TOP_LEFT ||
 739           scrolled_window->window_placement == GTK_CORNER_BOTTOM_LEFT)
 740         child_allocation.x = (relative_allocation.x +
 741                               relative_allocation.width +
 742                               SCROLLBAR_SPACING (scrolled_window));
 743       else
 744         child_allocation.x = GTK_CONTAINER (scrolled_window)->border_width;
 745
 746       child_allocation.y = relative_allocation.y;
 747       child_allocation.width = scrolled_window->vscrollbar->requisition.width;
 748       child_allocation.height = relative_allocation.height;
 749       child_allocation.x += allocation->x;
 750       child_allocation.y += allocation->y;
 751
 752       gtk_widget_size_allocate (scrolled_window->vscrollbar, &child_allocation);
 753     }
 754   else if (GTK_WIDGET_VISIBLE (scrolled_window->vscrollbar))
 755     gtk_widget_hide (scrolled_window->vscrollbar);
 756 }
 757
 758
 759 static void
 760 gtk_scrolled_window_adjustment_changed (GtkAdjustment *adjustment,
 761                                         gpointer       data)
 762 {
 763   GtkScrolledWindow *scrolled_win;
 764
 765   g_return_if_fail (adjustment != NULL);
 766   g_return_if_fail (data != NULL);
 767
 768   scrolled_win = GTK_SCROLLED_WINDOW (data);
 769
 770   if (adjustment == gtk_range_get_adjustment (GTK_RANGE (scrolled_win->hscrollbar)))
 771     {
 772       if (scrolled_win->hscrollbar_policy == GTK_POLICY_AUTOMATIC)
 773         {
 774           gboolean visible;
 775
 776           visible = scrolled_win->hscrollbar_visible;
 777           scrolled_win->hscrollbar_visible = (adjustment->upper - adjustment->lower >
 778                                               adjustment->page_size);
 779           if (scrolled_win->hscrollbar_visible != visible)
 780             gtk_widget_queue_resize (GTK_WIDGET (scrolled_win));
 781         }
 782     }
 783   else if (adjustment == gtk_range_get_adjustment (GTK_RANGE (scrolled_win->vscrollbar)))
 784     {
 785       if (scrolled_win->vscrollbar_policy == GTK_POLICY_AUTOMATIC)
 786         {
 787           gboolean visible;
 788
 789           visible = scrolled_win->vscrollbar_visible;
 790           scrolled_win->vscrollbar_visible = (adjustment->upper - adjustment->lower >
 791                                               adjustment->page_size);
 792           if (scrolled_win->vscrollbar_visible != visible)
 793             gtk_widget_queue_resize (GTK_WIDGET (scrolled_win));
 794         }
 795     }
 796 }
 797
 798 static void
 799 gtk_scrolled_window_add (GtkContainer *container,
 800                          GtkWidget    *child)
 801 {
 802   GtkScrolledWindow *scrolled_window;
 803   GtkBin *bin;
 804
 805   bin = GTK_BIN (container);
 806   g_return_if_fail (bin->child == NULL);
 807
 808   scrolled_window = GTK_SCROLLED_WINDOW (container);
 809
 810   gtk_widget_set_parent (child, GTK_WIDGET (bin));
 811   bin->child = child;
 812
 813   /* this is a temporary message */
 814   if (!gtk_widget_scroll_adjustements (child,
 815                                        gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
 816                                        gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar))))
 817     g_message ("gtk_scrolled_window_add(): cannot add non scrollable widget "
 818                "use gtk_scrolled_window_add_with_viewport() instead");
 819
 820   if (GTK_WIDGET_VISIBLE (child->parent))
 821     {
 822       if (GTK_WIDGET_REALIZED (child->parent) &&
 823           !GTK_WIDGET_REALIZED (child))
 824         gtk_widget_realize (child);
 825
 826       if (GTK_WIDGET_MAPPED (child->parent) &&
 827           !GTK_WIDGET_MAPPED (child))
 828         gtk_widget_map (child);
 829     }
 830
 831   if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (container))
 832     gtk_widget_queue_resize (child);
 833 }
 834
 835 static void
 836 gtk_scrolled_window_remove (GtkContainer *container,
 837                             GtkWidget    *child)
 838 {
 839   g_return_if_fail (container != NULL);
 840   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (container));
 841   g_return_if_fail (child != NULL);
 842   g_return_if_fail (GTK_BIN (container)->child == child);
 843
 844   gtk_widget_scroll_adjustements (child, NULL, NULL);
 845
 846   /* chain parent class handler to remove child */
 847   GTK_CONTAINER_CLASS (parent_class)->remove (container, child);
 848 }
 849
 850 void
 851 gtk_scrolled_window_add_with_viewport (GtkScrolledWindow *scrolled_window,
 852                                        GtkWidget         *child)
 853 {
 854   GtkBin *bin;
 855   GtkWidget *viewport;
 856
 857   g_return_if_fail (scrolled_window != NULL);
 858   g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
 859   g_return_if_fail (child != NULL);
 860   g_return_if_fail (GTK_IS_WIDGET (child));
 861   g_return_if_fail (child->parent == NULL);
 862
 863   bin = GTK_BIN (scrolled_window);
 864
 865   if (bin->child != NULL)
 866     {
 867       g_return_if_fail (GTK_IS_VIEWPORT (bin->child));
 868       g_return_if_fail (GTK_BIN (bin->child)->child == NULL);
 869
 870       viewport = bin->child;
 871     }
 872   else
 873     {
 874       viewport =
 875         gtk_viewport_new (gtk_scrolled_window_get_hadjustment (scrolled_window),
 876                           gtk_scrolled_window_get_vadjustment (scrolled_window));
 877       gtk_container_add (GTK_CONTAINER (scrolled_window), viewport);
 878     }
 879
 880   gtk_widget_show (viewport);
 881   gtk_container_add (GTK_CONTAINER (viewport), child);
 882 }