Pileus Git - ~andy/gtk/blob - gtk/gtkcontainer.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 <string.h>
  20 #include "gtkcontainer.h"
  21 #include "gtkprivate.h"
  22 #include "gtksignal.h"
  23 #include "gtkmain.h"
  24 #include <stdarg.h>
  25
  26
  27 enum {
  28   ADD,
  29   REMOVE,
  30   CHECK_RESIZE,
  31   FOCUS,
  32   SET_FOCUS_CHILD,
  33   LAST_SIGNAL
  34 };
  35 enum {
  36   ARG_0,
  37   ARG_BORDER_WIDTH,
  38   ARG_RESIZE_MODE,
  39   ARG_CHILD
  40 };
  41
  42 typedef struct _GtkChildArgInfo GtkChildArgInfo;
  43 struct _GtkChildArgInfo
  44 {
  45   gchar *name;
  46   GtkType type;
  47   GtkType class_type;
  48   guint arg_flags;
  49   guint arg_id;
  50   guint seq_id;
  51 };
  52
  53 /* The global list of toplevel windows */
  54 static GList *toplevel_list = NULL;
  55
  56 static void gtk_container_base_class_init   (GtkContainerClass *klass);
  57 static void gtk_container_class_init        (GtkContainerClass *klass);
  58 static void gtk_container_init              (GtkContainer      *container);
  59 static void gtk_container_destroy           (GtkObject         *object);
  60 static void gtk_container_get_arg           (GtkObject         *object,
  61                                              GtkArg            *arg,
  62                                              guint              arg_id);
  63 static void gtk_container_set_arg           (GtkObject         *object,
  64                                              GtkArg            *arg,
  65                                              guint              arg_id);
  66 static void gtk_container_add_unimplemented (GtkContainer      *container,
  67                                              GtkWidget         *widget);
  68 static void gtk_container_remove_unimplemented (GtkContainer   *container,
  69                                                 GtkWidget      *widget);
  70 static void gtk_container_real_check_resize (GtkContainer      *container);
  71 static gint gtk_container_real_focus        (GtkContainer      *container,
  72                                              GtkDirectionType   direction);
  73 static void gtk_container_real_set_focus_child (GtkContainer      *container,
  74                                              GtkWidget         *widget);
  75 static gint gtk_container_focus_tab         (GtkContainer      *container,
  76                                              GList             *children,
  77                                              GtkDirectionType   direction);
  78 static gint gtk_container_focus_up_down     (GtkContainer      *container,
  79                                              GList             *children,
  80                                              GtkDirectionType   direction);
  81 static gint gtk_container_focus_left_right  (GtkContainer      *container,
  82                                              GList             *children,
  83                                              GtkDirectionType   direction);
  84 static gint gtk_container_focus_move        (GtkContainer      *container,
  85                                              GList             *children,
  86                                              GtkDirectionType   direction);
  87 static void gtk_container_children_callback (GtkWidget         *widget,
  88                                              gpointer           client_data);
  89 static void gtk_container_show_all          (GtkWidget         *widget);
  90 static void gtk_container_hide_all          (GtkWidget         *widget);
  91
  92 static gchar* gtk_container_child_default_composite_name (GtkContainer *container,
  93                                                           GtkWidget    *child);
  94
  95
  96
  97 static guint container_signals[LAST_SIGNAL] = { 0 };
  98 static GHashTable *container_child_arg_info_ht = NULL;
  99
 100 static GtkWidgetClass *parent_class = NULL;
 101
 102 static const gchar *vadjustment_key = "gtk-vadjustment";
 103 static guint        vadjustment_key_id = 0;
 104 static const gchar *hadjustment_key = "gtk-hadjustment";
 105 static guint        hadjustment_key_id = 0;
 106 static GSList      *container_resize_queue = NULL;
 107
 108 GtkType
 109 gtk_container_get_type (void)
 110 {
 111   static GtkType container_type = 0;
 112
 113   if (!container_type)
 114     {
 115       static const GtkTypeInfo container_info =
 116       {
 117         "GtkContainer",
 118         sizeof (GtkContainer),
 119         sizeof (GtkContainerClass),
 120         (GtkClassInitFunc) gtk_container_class_init,
 121         (GtkObjectInitFunc) gtk_container_init,
 122         /* reserved_1 */ NULL,
 123         /* reserved_2 */ NULL,
 124         (GtkClassInitFunc) gtk_container_base_class_init,
 125       };
 126
 127       container_type = gtk_type_unique (gtk_widget_get_type (), &container_info);
 128     }
 129
 130   return container_type;
 131 }
 132
 133 static void
 134 gtk_container_base_class_init (GtkContainerClass *class)
 135 {
 136   /* reset instance specifc class fields that don't get inherited */
 137   class->n_child_args = 0;
 138   class->set_child_arg = NULL;
 139   class->get_child_arg = NULL;
 140 }
 141
 142 static void
 143 gtk_container_class_init (GtkContainerClass *class)
 144 {
 145   GtkObjectClass *object_class;
 146   GtkWidgetClass *widget_class;
 147
 148   object_class = (GtkObjectClass*) class;
 149   widget_class = (GtkWidgetClass*) class;
 150
 151   parent_class = gtk_type_class (gtk_widget_get_type ());
 152
 153   container_child_arg_info_ht = g_hash_table_new (gtk_arg_info_hash,
 154                                                   gtk_arg_info_equal);
 155
 156   vadjustment_key_id = g_quark_from_static_string (vadjustment_key);
 157   hadjustment_key_id = g_quark_from_static_string (hadjustment_key);
 158
 159   gtk_object_add_arg_type ("GtkContainer::border_width", GTK_TYPE_ULONG, GTK_ARG_READWRITE, ARG_BORDER_WIDTH);
 160   gtk_object_add_arg_type ("GtkContainer::resize_mode", GTK_TYPE_RESIZE_MODE, GTK_ARG_READWRITE, ARG_RESIZE_MODE);
 161   gtk_object_add_arg_type ("GtkContainer::child", GTK_TYPE_WIDGET, GTK_ARG_WRITABLE, ARG_CHILD);
 162
 163   container_signals[ADD] =
 164     gtk_signal_new ("add",
 165                     GTK_RUN_FIRST,
 166                     object_class->type,
 167                     GTK_SIGNAL_OFFSET (GtkContainerClass, add),
 168                     gtk_marshal_NONE__POINTER,
 169                     GTK_TYPE_NONE, 1,
 170                     GTK_TYPE_WIDGET);
 171   container_signals[REMOVE] =
 172     gtk_signal_new ("remove",
 173                     GTK_RUN_FIRST,
 174                     object_class->type,
 175                     GTK_SIGNAL_OFFSET (GtkContainerClass, remove),
 176                     gtk_marshal_NONE__POINTER,
 177                     GTK_TYPE_NONE, 1,
 178                     GTK_TYPE_WIDGET);
 179   container_signals[CHECK_RESIZE] =
 180     gtk_signal_new ("check_resize",
 181                     GTK_RUN_LAST,
 182                     object_class->type,
 183                     GTK_SIGNAL_OFFSET (GtkContainerClass, check_resize),
 184                     gtk_marshal_NONE__NONE,
 185                     GTK_TYPE_NONE, 0);
 186   container_signals[FOCUS] =
 187     gtk_signal_new ("focus",
 188                     GTK_RUN_LAST,
 189                     object_class->type,
 190                     GTK_SIGNAL_OFFSET (GtkContainerClass, focus),
 191                     gtk_marshal_ENUM__ENUM,
 192                     GTK_TYPE_DIRECTION_TYPE, 1,
 193                     GTK_TYPE_DIRECTION_TYPE);
 194   container_signals[SET_FOCUS_CHILD] =
 195     gtk_signal_new ("set-focus-child",
 196                     GTK_RUN_FIRST,
 197                     object_class->type,
 198                     GTK_SIGNAL_OFFSET (GtkContainerClass, set_focus_child),
 199                     gtk_marshal_NONE__POINTER,
 200                     GTK_TYPE_NONE, 1,
 201                     GTK_TYPE_WIDGET);
 202   gtk_object_class_add_signals (object_class, container_signals, LAST_SIGNAL);
 203
 204   object_class->get_arg = gtk_container_get_arg;
 205   object_class->set_arg = gtk_container_set_arg;
 206   object_class->destroy = gtk_container_destroy;
 207
 208   widget_class->show_all = gtk_container_show_all;
 209   widget_class->hide_all = gtk_container_hide_all;
 210
 211   class->add = gtk_container_add_unimplemented;
 212   class->remove = gtk_container_remove_unimplemented;
 213   class->check_resize = gtk_container_real_check_resize;
 214   class->forall = NULL;
 215   class->focus = gtk_container_real_focus;
 216   class->set_focus_child = gtk_container_real_set_focus_child;
 217   class->child_type = NULL;
 218   class->composite_name = gtk_container_child_default_composite_name;
 219 }
 220
 221 GtkType
 222 gtk_container_child_type (GtkContainer      *container)
 223 {
 224   GtkType slot;
 225   GtkContainerClass *class;
 226
 227   g_return_val_if_fail (container != NULL, 0);
 228   g_return_val_if_fail (GTK_IS_CONTAINER (container), 0);
 229
 230   class = GTK_CONTAINER_CLASS (GTK_OBJECT (container)->klass);
 231   if (class->child_type)
 232     slot = class->child_type (container);
 233   else
 234     slot = GTK_TYPE_NONE;
 235
 236   return slot;
 237 }
 238
 239 /****************************************************
 240  * GtkContainer child argument mechanism
 241  *
 242  ****************************************************/
 243
 244 void
 245 gtk_container_add_with_args (GtkContainer      *container,
 246                              GtkWidget         *widget,
 247                              const gchar       *first_arg_name,
 248                              ...)
 249 {
 250   g_return_if_fail (container != NULL);
 251   g_return_if_fail (GTK_IS_CONTAINER (container));
 252   g_return_if_fail (widget != NULL);
 253   g_return_if_fail (GTK_IS_WIDGET (widget));
 254   g_return_if_fail (widget->parent == NULL);
 255
 256   gtk_widget_ref (GTK_WIDGET (container));
 257   gtk_widget_ref (widget);
 258
 259   gtk_signal_emit (GTK_OBJECT (container), container_signals[ADD], widget);
 260
 261   if (widget->parent)
 262     {
 263       va_list var_args;
 264       GSList *arg_list = NULL;
 265       GSList *info_list = NULL;
 266       gchar *error;
 267
 268       va_start (var_args, first_arg_name);
 269       error = gtk_container_child_args_collect (GTK_OBJECT_TYPE (container),
 270                                                 &arg_list,
 271                                                 &info_list,
 272                                                 first_arg_name,
 273                                                 var_args);
 274       va_end (var_args);
 275
 276       if (error)
 277         {
 278           g_warning ("gtk_container_add_with_args(): %s", error);
 279           g_free (error);
 280         }
 281       else
 282         {
 283           GSList *slist_arg;
 284           GSList *slist_info;
 285
 286           slist_arg = arg_list;
 287           slist_info = info_list;
 288           while (slist_arg)
 289             {
 290               gtk_container_arg_set (container, widget, slist_arg->data, slist_info->data);
 291               slist_arg = slist_arg->next;
 292               slist_info = slist_info->next;
 293             }
 294           gtk_args_collect_cleanup (arg_list, info_list);
 295         }
 296     }
 297
 298   gtk_widget_unref (widget);
 299   gtk_widget_unref (GTK_WIDGET (container));
 300 }
 301
 302 void
 303 gtk_container_addv (GtkContainer      *container,
 304                     GtkWidget         *widget,
 305                     guint              n_args,
 306                     GtkArg            *args)
 307 {
 308   g_return_if_fail (container != NULL);
 309   g_return_if_fail (GTK_IS_CONTAINER (container));
 310   g_return_if_fail (widget != NULL);
 311   g_return_if_fail (GTK_IS_WIDGET (widget));
 312   g_return_if_fail (widget->parent == NULL);
 313
 314   gtk_widget_ref (GTK_WIDGET (container));
 315   gtk_widget_ref (widget);
 316
 317   gtk_signal_emit (GTK_OBJECT (container), container_signals[ADD], widget);
 318
 319   if (widget->parent)
 320     {
 321       GtkArg *max_args;
 322
 323       for (max_args = args + n_args; args < max_args; args++)
 324         gtk_container_arg_set (container, widget, args, NULL);
 325     }
 326
 327   gtk_widget_unref (widget);
 328   gtk_widget_unref (GTK_WIDGET (container));
 329 }
 330
 331 void
 332 gtk_container_child_setv (GtkContainer      *container,
 333                           GtkWidget         *child,
 334                           guint              n_args,
 335                           GtkArg            *args)
 336 {
 337   GtkArg *max_args;
 338
 339   g_return_if_fail (container != NULL);
 340   g_return_if_fail (GTK_IS_CONTAINER (container));
 341   g_return_if_fail (child != NULL);
 342   g_return_if_fail (GTK_IS_WIDGET (child));
 343   g_return_if_fail (child->parent != NULL);
 344   if (n_args)
 345     g_return_if_fail (args != NULL);
 346
 347   for (max_args = args + n_args; args < max_args; args++)
 348     gtk_container_arg_set (container, child, args, NULL);
 349 }
 350
 351 void
 352 gtk_container_child_getv (GtkContainer      *container,
 353                           GtkWidget         *child,
 354                           guint              n_args,
 355                           GtkArg            *args)
 356 {
 357   GtkArg *max_args;
 358
 359   g_return_if_fail (container != NULL);
 360   g_return_if_fail (GTK_IS_CONTAINER (container));
 361   g_return_if_fail (child != NULL);
 362   g_return_if_fail (GTK_IS_WIDGET (child));
 363   g_return_if_fail (child->parent != NULL);
 364   if (n_args)
 365     g_return_if_fail (args != NULL);
 366
 367   for (max_args = args + n_args; args < max_args; args++)
 368     gtk_container_arg_get (container, child, args, NULL);
 369 }
 370
 371 void
 372 gtk_container_child_set (GtkContainer      *container,
 373                          GtkWidget         *child,
 374                          const gchar       *first_arg_name,
 375                          ...)
 376 {
 377   va_list var_args;
 378   GSList *arg_list = NULL;
 379   GSList *info_list = NULL;
 380   gchar *error;
 381
 382   g_return_if_fail (container != NULL);
 383   g_return_if_fail (GTK_IS_CONTAINER (container));
 384   g_return_if_fail (child != NULL);
 385   g_return_if_fail (GTK_IS_WIDGET (child));
 386   g_return_if_fail (child->parent != NULL);
 387
 388   va_start (var_args, first_arg_name);
 389   error = gtk_container_child_args_collect (GTK_OBJECT_TYPE (container),
 390                                             &arg_list,
 391                                             &info_list,
 392                                             first_arg_name,
 393                                             var_args);
 394   va_end (var_args);
 395
 396   if (error)
 397     {
 398       g_warning ("gtk_container_child_set(): %s", error);
 399       g_free (error);
 400     }
 401   else
 402     {
 403       GSList *slist_arg;
 404       GSList *slist_info;
 405
 406       slist_arg = arg_list;
 407       slist_info = info_list;
 408       while (slist_arg)
 409         {
 410           gtk_container_arg_set (container, child, slist_arg->data, slist_info->data);
 411           slist_arg = slist_arg->next;
 412           slist_info = slist_info->next;
 413         }
 414       gtk_args_collect_cleanup (arg_list, info_list);
 415     }
 416 }
 417
 418 void
 419 gtk_container_arg_set (GtkContainer *container,
 420                        GtkWidget    *child,
 421                        GtkArg       *arg,
 422                        GtkArgInfo   *info)
 423 {
 424   GtkContainerClass *class;
 425
 426   g_return_if_fail (container != NULL);
 427   g_return_if_fail (GTK_IS_CONTAINER (container));
 428   g_return_if_fail (child != NULL);
 429   g_return_if_fail (GTK_IS_WIDGET (child));
 430   g_return_if_fail (arg != NULL);
 431
 432   if (!info)
 433     {
 434       gchar *error;
 435
 436       error = gtk_arg_get_info (GTK_OBJECT_TYPE (container),
 437                                 container_child_arg_info_ht,
 438                                 arg->name,
 439                                 &info);
 440       if (error)
 441         {
 442           g_warning ("gtk_container_arg_set(): %s", error);
 443           g_free (error);
 444           return;
 445         }
 446     }
 447   g_return_if_fail (info->arg_flags & GTK_ARG_CHILD_ARG);
 448
 449   if (! (info->arg_flags & GTK_ARG_WRITABLE))
 450     {
 451       g_warning ("gtk_container_arg_set(): argument \"%s\" is not writable",
 452                  info->full_name);
 453       return;
 454     }
 455   if (info->type != arg->type)
 456     {
 457       g_warning ("gtk_container_arg_set(): argument \"%s\" has invalid type `%s'",
 458                  info->full_name,
 459                  gtk_type_name (arg->type));
 460       return;
 461     }
 462
 463   class = gtk_type_class (info->class_type);
 464   g_assert (class->set_child_arg != NULL);
 465   class->set_child_arg (container, child, arg, info->arg_id);
 466 }
 467
 468 void
 469 gtk_container_arg_get (GtkContainer *container,
 470                        GtkWidget    *child,
 471                        GtkArg       *arg,
 472                        GtkArgInfo   *info)
 473 {
 474   GtkContainerClass *class;
 475
 476   g_return_if_fail (container != NULL);
 477   g_return_if_fail (GTK_IS_CONTAINER (container));
 478   g_return_if_fail (child != NULL);
 479   g_return_if_fail (GTK_IS_WIDGET (child));
 480   g_return_if_fail (arg != NULL);
 481
 482   if (!info)
 483     {
 484       gchar *error;
 485
 486       error = gtk_arg_get_info (GTK_OBJECT_TYPE (container),
 487                                 container_child_arg_info_ht,
 488                                 arg->name,
 489                                 &info);
 490       if (error)
 491         {
 492           g_warning ("gtk_container_arg_get(): %s", error);
 493           g_free (error);
 494           arg->type = GTK_TYPE_INVALID;
 495           return;
 496         }
 497     }
 498   g_return_if_fail (info->arg_flags & GTK_ARG_CHILD_ARG);
 499
 500   if (! (info->arg_flags & GTK_ARG_READABLE))
 501     {
 502       g_warning ("gtk_container_arg_get(): argument \"%s\" is not readable",
 503                  info->full_name);
 504       arg->type = GTK_TYPE_INVALID;
 505       return;
 506     }
 507
 508   class = gtk_type_class (info->class_type);
 509   g_assert (class->get_child_arg != NULL);
 510   arg->type = info->type;
 511   class->get_child_arg (container, child, arg, info->arg_id);
 512 }
 513
 514 void
 515 gtk_container_add_child_arg_type (const gchar       *arg_name,
 516                                   GtkType            arg_type,
 517                                   guint              arg_flags,
 518                                   guint              arg_id)
 519 {
 520   g_return_if_fail (arg_name != NULL);
 521   g_return_if_fail (arg_type > GTK_TYPE_NONE);
 522   g_return_if_fail (arg_id > 0);
 523   g_return_if_fail ((arg_flags & GTK_ARG_READWRITE) == GTK_ARG_READWRITE);
 524   /* g_return_if_fail ((arg_flags & GTK_ARG_CHILD_ARG) != 0); */
 525
 526   arg_flags |= GTK_ARG_CHILD_ARG;
 527   arg_flags &= GTK_ARG_MASK;
 528
 529   gtk_arg_type_new_static (GTK_TYPE_CONTAINER,
 530                            arg_name,
 531                            GTK_STRUCT_OFFSET (GtkContainerClass, n_child_args),
 532                            container_child_arg_info_ht,
 533                            arg_type,
 534                            arg_flags,
 535                            arg_id);
 536 }
 537
 538 gchar*
 539 gtk_container_child_args_collect (GtkType       object_type,
 540                                   GSList      **arg_list_p,
 541                                   GSList      **info_list_p,
 542                                   const gchar  *first_arg_name,
 543                                   va_list       var_args)
 544 {
 545   return gtk_args_collect (object_type,
 546                            container_child_arg_info_ht,
 547                            arg_list_p,
 548                            info_list_p,
 549                            first_arg_name,
 550                            var_args);
 551 }
 552
 553 gchar*
 554 gtk_container_child_arg_get_info (GtkType       object_type,
 555                                   const gchar  *arg_name,
 556                                   GtkArgInfo  **info_p)
 557 {
 558   return gtk_arg_get_info (object_type,
 559                            container_child_arg_info_ht,
 560                            arg_name,
 561                            info_p);
 562 }
 563
 564 GtkArg*
 565 gtk_container_query_child_args (GtkType            class_type,
 566                                 guint32          **arg_flags,
 567                                 guint             *n_args)
 568 {
 569   g_return_val_if_fail (n_args != NULL, NULL);
 570   *n_args = 0;
 571   g_return_val_if_fail (gtk_type_is_a (class_type, GTK_TYPE_CONTAINER), NULL);
 572
 573   return gtk_args_query (class_type, container_child_arg_info_ht, arg_flags, n_args);
 574 }
 575
 576
 577 static void
 578 gtk_container_add_unimplemented (GtkContainer     *container,
 579                                  GtkWidget        *widget)
 580 {
 581   g_warning ("GtkContainerClass::add not implemented for `%s'", gtk_type_name (GTK_OBJECT_TYPE (container)));
 582 }
 583
 584 static void
 585 gtk_container_remove_unimplemented (GtkContainer     *container,
 586                                     GtkWidget        *widget)
 587 {
 588   g_warning ("GtkContainerClass::remove not implemented for `%s'", gtk_type_name (GTK_OBJECT_TYPE (container)));
 589 }
 590
 591 static void
 592 gtk_container_init (GtkContainer *container)
 593 {
 594   container->focus_child = NULL;
 595   container->border_width = 0;
 596   container->need_resize = FALSE;
 597   container->resize_mode = GTK_RESIZE_PARENT;
 598   container->resize_widgets = NULL;
 599 }
 600
 601 static void
 602 gtk_container_destroy (GtkObject *object)
 603 {
 604   GtkContainer *container;
 605
 606   g_return_if_fail (object != NULL);
 607   g_return_if_fail (GTK_IS_CONTAINER (object));
 608
 609   container = GTK_CONTAINER (object);
 610
 611   if (GTK_CONTAINER_RESIZE_PENDING (container))
 612     {
 613       container_resize_queue = g_slist_remove (container_resize_queue, container);
 614       GTK_PRIVATE_UNSET_FLAG (container, GTK_RESIZE_PENDING);
 615     }
 616   gtk_container_clear_resize_widgets (container);
 617
 618   gtk_container_foreach (container, (GtkCallback) gtk_widget_destroy, NULL);
 619
 620   if (GTK_OBJECT_CLASS (parent_class)->destroy)
 621     (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 622 }
 623
 624 static void
 625 gtk_container_set_arg (GtkObject    *object,
 626                        GtkArg       *arg,
 627                        guint         arg_id)
 628 {
 629   GtkContainer *container;
 630
 631   container = GTK_CONTAINER (object);
 632
 633   switch (arg_id)
 634     {
 635     case ARG_BORDER_WIDTH:
 636       gtk_container_set_border_width (container, GTK_VALUE_ULONG (*arg));
 637       break;
 638     case ARG_RESIZE_MODE:
 639       gtk_container_set_resize_mode (container, GTK_VALUE_ENUM (*arg));
 640       break;
 641     case ARG_CHILD:
 642       gtk_container_add (container, GTK_WIDGET (GTK_VALUE_OBJECT (*arg)));
 643       break;
 644     default:
 645       break;
 646     }
 647 }
 648
 649 static void
 650 gtk_container_get_arg (GtkObject    *object,
 651                        GtkArg       *arg,
 652                        guint         arg_id)
 653 {
 654   GtkContainer *container;
 655
 656   container = GTK_CONTAINER (object);
 657
 658   switch (arg_id)
 659     {
 660     case ARG_BORDER_WIDTH:
 661       GTK_VALUE_ULONG (*arg) = container->border_width;
 662       break;
 663     case ARG_RESIZE_MODE:
 664       GTK_VALUE_ENUM (*arg) = container->resize_mode;
 665       break;
 666     default:
 667       arg->type = GTK_TYPE_INVALID;
 668       break;
 669     }
 670 }
 671
 672 void
 673 gtk_container_set_border_width (GtkContainer *container,
 674                                 guint         border_width)
 675 {
 676   g_return_if_fail (container != NULL);
 677   g_return_if_fail (GTK_IS_CONTAINER (container));
 678
 679   if (container->border_width != border_width)
 680     {
 681       container->border_width = border_width;
 682
 683       if (GTK_WIDGET_REALIZED (container))
 684         gtk_widget_queue_resize (GTK_WIDGET (container));
 685     }
 686 }
 687
 688 void
 689 gtk_container_add (GtkContainer *container,
 690                    GtkWidget    *widget)
 691 {
 692   g_return_if_fail (container != NULL);
 693   g_return_if_fail (GTK_IS_CONTAINER (container));
 694   g_return_if_fail (widget != NULL);
 695   g_return_if_fail (GTK_IS_WIDGET (widget));
 696   g_return_if_fail (widget->parent == NULL);
 697
 698   gtk_signal_emit (GTK_OBJECT (container), container_signals[ADD], widget);
 699 }
 700
 701 void
 702 gtk_container_remove (GtkContainer *container,
 703                       GtkWidget    *widget)
 704 {
 705   g_return_if_fail (container != NULL);
 706   g_return_if_fail (GTK_IS_CONTAINER (container));
 707   g_return_if_fail (widget != NULL);
 708   g_return_if_fail (GTK_IS_WIDGET (widget));
 709   g_return_if_fail (widget->parent == GTK_WIDGET (container));
 710
 711   gtk_signal_emit (GTK_OBJECT (container), container_signals[REMOVE], widget);
 712 }
 713
 714 void
 715 gtk_container_block_resize (GtkContainer *container)
 716 {
 717   g_return_if_fail (container != NULL);
 718   g_return_if_fail (GTK_IS_CONTAINER (container));
 719
 720   g_message ("gtk_container_block_resize() is deprecated");
 721 }
 722
 723 void
 724 gtk_container_unblock_resize (GtkContainer *container)
 725 {
 726   g_return_if_fail (container != NULL);
 727   g_return_if_fail (GTK_IS_CONTAINER (container));
 728
 729   g_message ("gtk_container_unblock_resize() is deprecated");
 730 }
 731
 732 void
 733 gtk_container_clear_resize_widgets (GtkContainer *container)
 734 {
 735   GSList *node;
 736
 737   g_return_if_fail (container != NULL);
 738   g_return_if_fail (GTK_IS_CONTAINER (container));
 739
 740   node = container->resize_widgets;
 741
 742   if (node)
 743     gtk_signal_disconnect_by_func (GTK_OBJECT (container),
 744                                    GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
 745                                    NULL);
 746
 747   while (node)
 748     {
 749       GtkWidget *widget = node->data;
 750
 751       GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
 752       node = node->next;
 753     }
 754
 755   g_slist_free (container->resize_widgets);
 756   container->resize_widgets = NULL;
 757 }
 758
 759 void
 760 gtk_container_set_resize_mode (GtkContainer  *container,
 761                                GtkResizeMode  resize_mode)
 762 {
 763   g_return_if_fail (container != NULL);
 764   g_return_if_fail (GTK_IS_CONTAINER (container));
 765   g_return_if_fail (resize_mode <= GTK_RESIZE_IMMEDIATE);
 766
 767   if (GTK_WIDGET_TOPLEVEL (container) &&
 768       resize_mode == GTK_RESIZE_PARENT)
 769     resize_mode = GTK_RESIZE_QUEUE;
 770
 771   if (container->resize_mode != resize_mode)
 772     {
 773       container->resize_mode = resize_mode;
 774
 775       if (resize_mode == GTK_RESIZE_IMMEDIATE)
 776         gtk_container_check_resize (container);
 777       else
 778         {
 779           gtk_container_clear_resize_widgets (container);
 780           gtk_widget_queue_resize (GTK_WIDGET (container));
 781         }
 782     }
 783 }
 784
 785 gint
 786 gtk_container_need_resize (GtkContainer     *container)
 787 {
 788   g_message ("gtk_container_need_resize() is deprecated");
 789
 790   gtk_container_check_resize (container);
 791   return FALSE;
 792 }
 793
 794 static GtkContainer*
 795 gtk_container_get_resize_container (GtkContainer *container)
 796 {
 797   GtkWidget *widget;
 798
 799   widget = GTK_WIDGET (container);
 800
 801   while (widget->parent)
 802     {
 803       widget = widget->parent;
 804       if (GTK_IS_RESIZE_CONTAINER (widget) && !GTK_WIDGET_RESIZE_NEEDED (widget))
 805         break;
 806     }
 807
 808   return GTK_IS_RESIZE_CONTAINER (widget) ? (GtkContainer*) widget : NULL;
 809 }
 810
 811 static gboolean
 812 gtk_container_idle_sizer (gpointer data)
 813 {
 814   GDK_THREADS_ENTER ();
 815
 816   /* we may be invoked with a container_resize_queue of NULL, because
 817    * queue_resize could have been adding an extra idle function while
 818    * the queue still got processed. we better just ignore such case
 819    * than trying to explicitely work around them with some extra flags,
 820    * since it doesn't cause any actual harm.
 821    */
 822   while (container_resize_queue)
 823     {
 824       GSList *slist;
 825       GtkWidget *widget;
 826
 827       slist = container_resize_queue;
 828       container_resize_queue = slist->next;
 829       widget = slist->data;
 830       g_slist_free_1 (slist);
 831
 832       GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_PENDING);
 833       gtk_container_check_resize (GTK_CONTAINER (widget));
 834     }
 835
 836   GDK_THREADS_LEAVE ();
 837
 838   return FALSE;
 839 }
 840
 841 void
 842 gtk_container_queue_resize (GtkContainer *container)
 843 {
 844   GtkContainer *resize_container;
 845
 846   g_return_if_fail (container != NULL);
 847   g_return_if_fail (GTK_IS_CONTAINER (container));
 848
 849   if (GTK_OBJECT_DESTROYED (container) ||
 850       GTK_WIDGET_RESIZE_NEEDED (container))
 851     return;
 852
 853   if (GTK_IS_RESIZE_CONTAINER (container))
 854     gtk_container_clear_resize_widgets (container);
 855
 856   resize_container = gtk_container_get_resize_container (container);
 857
 858   if (resize_container)
 859     {
 860       if (GTK_WIDGET_VISIBLE (resize_container))
 861         {
 862           switch (resize_container->resize_mode)
 863             {
 864             case GTK_RESIZE_QUEUE:
 865               if (!GTK_CONTAINER_RESIZE_PENDING (resize_container))
 866                 {
 867                   GTK_PRIVATE_SET_FLAG (resize_container, GTK_RESIZE_PENDING);
 868                   if (container_resize_queue == NULL)
 869                     gtk_idle_add_priority (GTK_PRIORITY_RESIZE,
 870                                            gtk_container_idle_sizer,
 871                                            NULL);
 872                   container_resize_queue = g_slist_prepend (container_resize_queue, resize_container);
 873                 }
 874
 875               GTK_PRIVATE_SET_FLAG (container, GTK_RESIZE_NEEDED);
 876               if (!resize_container->resize_widgets)
 877                 gtk_signal_connect (GTK_OBJECT (resize_container),
 878                                     "size_allocate",
 879                                     GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
 880                                     NULL);
 881               resize_container->resize_widgets =
 882                 g_slist_prepend (resize_container->resize_widgets, container);
 883               break;
 884
 885             case GTK_RESIZE_IMMEDIATE:
 886               GTK_PRIVATE_SET_FLAG (container, GTK_RESIZE_NEEDED);
 887               if (!resize_container->resize_widgets)
 888                 gtk_signal_connect (GTK_OBJECT (resize_container),
 889                                     "size_allocate",
 890                                     GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
 891                                     NULL);
 892               resize_container->resize_widgets =
 893                 g_slist_prepend (resize_container->resize_widgets, container);
 894               gtk_container_check_resize (resize_container);
 895               break;
 896
 897             case GTK_RESIZE_PARENT:
 898               /* Ignore */
 899               break;
 900             }
 901         }
 902       else
 903         {
 904           /* We need to let hidden toplevels know that something
 905            * changed while they where hidden. For other resize containers,
 906            * they will get resized when they are shown.
 907            */
 908           if (GTK_WIDGET_TOPLEVEL (resize_container))
 909             gtk_container_check_resize (resize_container);
 910         }
 911     }
 912 }
 913
 914 void
 915 gtk_container_check_resize (GtkContainer *container)
 916 {
 917   g_return_if_fail (container != NULL);
 918   g_return_if_fail (GTK_IS_CONTAINER (container));
 919
 920   gtk_signal_emit (GTK_OBJECT (container), container_signals[CHECK_RESIZE]);
 921 }
 922
 923 static void
 924 gtk_container_real_check_resize (GtkContainer *container)
 925 {
 926   GtkWidget *widget;
 927
 928   g_return_if_fail (container != NULL);
 929   g_return_if_fail (GTK_IS_CONTAINER (container));
 930
 931   widget = GTK_WIDGET (container);
 932
 933   gtk_widget_size_request (widget, &widget->requisition);
 934
 935   if (widget->requisition.width > widget->allocation.width ||
 936       widget->requisition.height > widget->allocation.height)
 937     {
 938       if (GTK_IS_RESIZE_CONTAINER (container))
 939         {
 940           gtk_widget_size_allocate (GTK_WIDGET (container),
 941                                     &GTK_WIDGET (container)->allocation);
 942           gtk_widget_queue_draw (GTK_WIDGET (container));
 943         }
 944       else
 945         gtk_widget_queue_resize (widget);
 946     }
 947   else
 948     {
 949       gtk_container_resize_children (container);
 950     }
 951 }
 952
 953 /* The container hasn't changed size but one of its children
 954  *  queued a resize request. Which means that the allocation
 955  *  is not sufficient for the requisition of some child.
 956  *  We've already performed a size request at this point,
 957  *  so we simply need to run through the list of resize
 958  *  widgets and reallocate their sizes appropriately. We
 959  *  make the optimization of not performing reallocation
 960  *  for a widget who also has a parent in the resize widgets
 961  *  list. GTK_RESIZE_NEEDED is used for flagging those
 962  *  parents inside this function.
 963  */
 964 void
 965 gtk_container_resize_children (GtkContainer *container)
 966 {
 967   GtkWidget *widget;
 968   GtkWidget *resize_container;
 969   GSList *resize_widgets;
 970   GSList *resize_containers;
 971   GSList *node;
 972
 973   /* resizing invariants:
 974    * toplevels have *always* resize_mode != GTK_RESIZE_PARENT set.
 975    * containers with resize_mode==GTK_RESIZE_PARENT have to have resize_widgets
 976    * set to NULL.
 977    * containers that are flagged RESIZE_NEEDED must have resize_widgets set to
 978    * NULL, or are toplevels (thus have ->parent set to NULL).
 979    * widgets that are in some container->resize_widgets list must be flagged with
 980    * RESIZE_NEEDED.
 981    * widgets that have RESIZE_NEEDED set must be referenced in some
 982    * GTK_IS_RESIZE_CONTAINER (container)->resize_widgets list.
 983    * containers that have an idle sizer pending must be flagged with
 984    * RESIZE_PENDING.
 985    */
 986
 987   g_return_if_fail (container != NULL);
 988   g_return_if_fail (GTK_IS_CONTAINER (container));
 989
 990   /* we first check out if we actually need to perform a resize,
 991    * which is not the case if we got another container queued for
 992    * a resize in our anchestry. also we can skip the whole
 993    * resize_widgets checks if we are a toplevel and NEED_RESIZE.
 994    * this code implies that our allocation is sufficient for our
 995    * requisition, since otherwise we would NEED_RESIZE.
 996    */
 997   resize_container = GTK_WIDGET (container);
 998   while (resize_container)
 999     {
1000       if (GTK_WIDGET_RESIZE_NEEDED (resize_container))
1001         break;
1002       resize_container = resize_container->parent;
1003     }
1004   if (resize_container)
1005     {
1006       /* queue_resize and size_allocate both clear our
1007        * resize_widgets list.
1008        */
1009       if (resize_container->parent)
1010         gtk_container_queue_resize (container);
1011       else
1012         {
1013           gtk_widget_size_allocate (GTK_WIDGET (container),
1014                                     &GTK_WIDGET (container)->allocation);
1015           gtk_widget_queue_draw (GTK_WIDGET (container));
1016         }
1017       return;
1018     }
1019
1020   resize_container = GTK_WIDGET (container);
1021
1022   /* we now walk the anchestry for all resize widgets as long
1023    * as they are our children and as long as their allocation
1024    * is insufficient, since we don't need to reallocate below that.
1025    */
1026   resize_widgets = container->resize_widgets;
1027   if (resize_widgets)
1028     gtk_signal_disconnect_by_func (GTK_OBJECT (container),
1029                                    GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
1030                                    NULL);
1031   container->resize_widgets = NULL;
1032   for (node = resize_widgets; node; node = node->next)
1033     {
1034       widget = node->data;
1035
1036       GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
1037
1038       while (widget->parent != resize_container &&
1039              ((widget->allocation.width < widget->requisition.width) ||
1040               (widget->allocation.height < widget->requisition.height)))
1041         widget = widget->parent;
1042
1043       GTK_PRIVATE_SET_FLAG (widget, GTK_RESIZE_NEEDED);
1044       node->data = widget;
1045     }
1046
1047   /* for the newly setup resize_widgets list, we now walk each widget's
1048    * anchestry to sort those widgets out that have RESIZE_NEEDED parents.
1049    * we can safely stop the walk if we are the parent, since we checked
1050    * our own anchestry already.
1051    */
1052   resize_containers = NULL;
1053   for (node = resize_widgets; node; node = node->next)
1054     {
1055       GtkWidget *parent;
1056
1057       widget = node->data;
1058
1059       if (!GTK_WIDGET_RESIZE_NEEDED (widget))
1060         continue;
1061
1062       parent = widget->parent;
1063
1064       while (parent != resize_container)
1065         {
1066           if (GTK_WIDGET_RESIZE_NEEDED (parent))
1067             {
1068               GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
1069               widget = parent;
1070             }
1071           parent = parent->parent;
1072         }
1073
1074       if (!g_slist_find (resize_containers, widget))
1075         {
1076           resize_containers = g_slist_prepend (resize_containers, widget);
1077           gtk_widget_ref (widget);
1078         }
1079     }
1080   g_slist_free (resize_widgets);
1081
1082   for (node = resize_containers; node; node = node->next)
1083     {
1084       widget = node->data;
1085
1086       GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
1087       gtk_widget_size_allocate (widget, &widget->allocation);
1088       gtk_widget_queue_draw (widget);
1089       gtk_widget_unref (widget);
1090     }
1091   g_slist_free (resize_containers);
1092 }
1093
1094 void
1095 gtk_container_forall (GtkContainer *container,
1096                       GtkCallback   callback,
1097                       gpointer      callback_data)
1098 {
1099   GtkContainerClass *class;
1100
1101   g_return_if_fail (container != NULL);
1102   g_return_if_fail (GTK_IS_CONTAINER (container));
1103   g_return_if_fail (callback != NULL);
1104
1105   class = GTK_CONTAINER_CLASS (GTK_OBJECT (container)->klass);
1106
1107   if (class->forall)
1108     class->forall (container, TRUE, callback, callback_data);
1109 }
1110
1111 void
1112 gtk_container_foreach (GtkContainer *container,
1113                        GtkCallback   callback,
1114                        gpointer      callback_data)
1115 {
1116   GtkContainerClass *class;
1117
1118   g_return_if_fail (container != NULL);
1119   g_return_if_fail (GTK_IS_CONTAINER (container));
1120   g_return_if_fail (callback != NULL);
1121
1122   class = GTK_CONTAINER_CLASS (GTK_OBJECT (container)->klass);
1123
1124   if (class->forall)
1125     class->forall (container, FALSE, callback, callback_data);
1126 }
1127
1128 typedef struct _GtkForeachData  GtkForeachData;
1129 struct _GtkForeachData
1130 {
1131   GtkObject         *container;
1132   GtkCallbackMarshal callback;
1133   gpointer           callback_data;
1134 };
1135
1136 static void
1137 gtk_container_foreach_unmarshal (GtkWidget *child,
1138                                  gpointer data)
1139 {
1140   GtkForeachData *fdata = (GtkForeachData*) data;
1141   GtkArg args[2];
1142
1143   /* first argument */
1144   args[0].name = NULL;
1145   args[0].type = GTK_OBJECT(child)->klass->type;
1146   GTK_VALUE_OBJECT(args[0]) = GTK_OBJECT (child);
1147
1148   /* location for return value */
1149   args[1].name = NULL;
1150   args[1].type = GTK_TYPE_NONE;
1151
1152   fdata->callback (fdata->container, fdata->callback_data, 1, args);
1153 }
1154
1155 void
1156 gtk_container_foreach_full (GtkContainer       *container,
1157                             GtkCallback         callback,
1158                             GtkCallbackMarshal  marshal,
1159                             gpointer            callback_data,
1160                             GtkDestroyNotify    notify)
1161 {
1162   g_return_if_fail (container != NULL);
1163   g_return_if_fail (GTK_IS_CONTAINER (container));
1164
1165   if (marshal)
1166     {
1167       GtkForeachData fdata;
1168
1169       fdata.container     = GTK_OBJECT (container);
1170       fdata.callback      = marshal;
1171       fdata.callback_data = callback_data;
1172
1173       gtk_container_foreach (container, gtk_container_foreach_unmarshal, &fdata);
1174     }
1175   else
1176     {
1177       g_return_if_fail (callback != NULL);
1178
1179       gtk_container_foreach (container, callback, &callback_data);
1180     }
1181
1182   if (notify)
1183     notify (callback_data);
1184 }
1185
1186 gint
1187 gtk_container_focus (GtkContainer     *container,
1188                      GtkDirectionType  direction)
1189 {
1190   gint return_val;
1191
1192   g_return_val_if_fail (container != NULL, FALSE);
1193   g_return_val_if_fail (GTK_IS_CONTAINER (container), FALSE);
1194
1195   gtk_signal_emit (GTK_OBJECT (container),
1196                    container_signals[FOCUS],
1197                    direction, &return_val);
1198
1199   return return_val;
1200 }
1201
1202 void
1203 gtk_container_set_focus_child (GtkContainer *container,
1204                                GtkWidget    *widget)
1205 {
1206   g_return_if_fail (container != NULL);
1207   g_return_if_fail (GTK_IS_CONTAINER (container));
1208   if (widget)
1209     g_return_if_fail (GTK_IS_WIDGET (widget));
1210
1211   gtk_signal_emit (GTK_OBJECT (container), container_signals[SET_FOCUS_CHILD], widget);
1212 }
1213
1214 GList*
1215 gtk_container_children (GtkContainer *container)
1216 {
1217   GList *children;
1218
1219   children = NULL;
1220
1221   gtk_container_foreach (container,
1222                          gtk_container_children_callback,
1223                          &children);
1224
1225   return g_list_reverse (children);
1226 }
1227
1228 void
1229 gtk_container_register_toplevel (GtkContainer *container)
1230 {
1231   g_return_if_fail (container != NULL);
1232
1233   toplevel_list = g_list_prepend (toplevel_list, container);
1234
1235   gtk_widget_ref (GTK_WIDGET (container));
1236   gtk_object_sink (GTK_OBJECT (container));
1237 }
1238
1239 void
1240 gtk_container_unregister_toplevel (GtkContainer *container)
1241 {
1242   GList *node;
1243
1244   g_return_if_fail (container != NULL);
1245
1246   node = g_list_find (toplevel_list, container);
1247   g_return_if_fail (node != NULL);
1248
1249   toplevel_list = g_list_remove_link (toplevel_list, node);
1250   g_list_free_1 (node);
1251
1252   gtk_widget_unref (GTK_WIDGET (container));
1253 }
1254
1255 GList*
1256 gtk_container_get_toplevels (void)
1257 {
1258   /* XXX: fixme we should ref all these widgets and duplicate
1259    * the list.
1260    */
1261   return toplevel_list;
1262 }
1263
1264 static void
1265 gtk_container_child_position_callback (GtkWidget *widget,
1266                                        gpointer   client_data)
1267 {
1268   struct {
1269     GtkWidget *child;
1270     guint i;
1271     guint index;
1272   } *data = client_data;
1273
1274   data->i++;
1275   if (data->child == widget)
1276     data->index = data->i;
1277 }
1278
1279 static gchar*
1280 gtk_container_child_default_composite_name (GtkContainer *container,
1281                                             GtkWidget    *child)
1282 {
1283   struct {
1284     GtkWidget *child;
1285     guint i;
1286     guint index;
1287   } data;
1288   gchar *name;
1289
1290   /* fallback implementation */
1291   data.child = child;
1292   data.i = 0;
1293   data.index = 0;
1294   gtk_container_forall (container,
1295                         gtk_container_child_position_callback,
1296                         &data);
1297
1298   name = g_strdup_printf ("%s-%u",
1299                           gtk_type_name (GTK_OBJECT_TYPE (child)),
1300                           data.index);
1301
1302   return name;
1303 }
1304
1305 gchar*
1306 gtk_container_child_composite_name (GtkContainer *container,
1307                                     GtkWidget    *child)
1308 {
1309   g_return_val_if_fail (container != NULL, NULL);
1310   g_return_val_if_fail (GTK_IS_CONTAINER (container), NULL);
1311   g_return_val_if_fail (child != NULL, NULL);
1312   g_return_val_if_fail (GTK_IS_WIDGET (child), NULL);
1313   g_return_val_if_fail (child->parent == GTK_WIDGET (container), NULL);
1314
1315   if (GTK_WIDGET_COMPOSITE_CHILD (child))
1316     {
1317       static GQuark quark_composite_name = 0;
1318       gchar *name;
1319
1320       if (!quark_composite_name)
1321         quark_composite_name = g_quark_from_static_string ("gtk-composite-name");
1322
1323       name = gtk_object_get_data_by_id (GTK_OBJECT (child), quark_composite_name);
1324       if (!name)
1325         {
1326           GtkContainerClass *class;
1327
1328           class = GTK_CONTAINER_CLASS (GTK_OBJECT (container)->klass);
1329           if (class->composite_name)
1330             name = class->composite_name (container, child);
1331         }
1332       else
1333         name = g_strdup (name);
1334
1335       return name;
1336     }
1337
1338   return NULL;
1339 }
1340
1341 void
1342 gtk_container_real_set_focus_child (GtkContainer     *container,
1343                                     GtkWidget        *child)
1344 {
1345   g_return_if_fail (container != NULL);
1346   g_return_if_fail (GTK_IS_CONTAINER (container));
1347   if (child)
1348     g_return_if_fail (GTK_IS_WIDGET (child));
1349
1350   if (child != container->focus_child)
1351     {
1352       if (container->focus_child)
1353         gtk_widget_unref (container->focus_child);
1354       container->focus_child = child;
1355       if (container->focus_child)
1356         gtk_widget_ref (container->focus_child);
1357     }
1358
1359
1360   /* check for h/v adjustments
1361    */
1362   if (container->focus_child)
1363     {
1364       GtkAdjustment *adjustment;
1365
1366       adjustment = gtk_object_get_data_by_id (GTK_OBJECT (container), vadjustment_key_id);
1367       if (adjustment)
1368         gtk_adjustment_clamp_page (adjustment,
1369                                    container->focus_child->allocation.y,
1370                                    (container->focus_child->allocation.y +
1371                                     container->focus_child->allocation.height));
1372
1373       adjustment = gtk_object_get_data_by_id (GTK_OBJECT (container), hadjustment_key_id);
1374       if (adjustment)
1375         gtk_adjustment_clamp_page (adjustment,
1376                                    container->focus_child->allocation.x,
1377                                    (container->focus_child->allocation.x +
1378                                     container->focus_child->allocation.width));
1379     }
1380 }
1381
1382 static gint
1383 gtk_container_real_focus (GtkContainer     *container,
1384                           GtkDirectionType  direction)
1385 {
1386   GList *children;
1387   GList *tmp_list;
1388   GList *tmp_list2;
1389   gint return_val;
1390
1391   g_return_val_if_fail (container != NULL, FALSE);
1392   g_return_val_if_fail (GTK_IS_CONTAINER (container), FALSE);
1393
1394   /* Fail if the container is inappropriate for focus movement
1395    */
1396   if (!GTK_WIDGET_DRAWABLE (container) ||
1397       !GTK_WIDGET_SENSITIVE (container))
1398     return FALSE;
1399
1400   return_val = FALSE;
1401
1402   if (GTK_WIDGET_CAN_FOCUS (container))
1403     {
1404       gtk_widget_grab_focus (GTK_WIDGET (container));
1405       return_val = TRUE;
1406     }
1407   else
1408     {
1409       /* Get a list of the containers children
1410        */
1411       children = NULL;
1412       gtk_container_forall (container,
1413                             gtk_container_children_callback,
1414                             &children);
1415       children = g_list_reverse (children);
1416       /* children = gtk_container_children (container); */
1417
1418       if (children)
1419         {
1420           /* Remove any children which are inappropriate for focus movement
1421            */
1422           tmp_list = children;
1423           while (tmp_list)
1424             {
1425               if (GTK_WIDGET_SENSITIVE (tmp_list->data) &&
1426                   GTK_WIDGET_DRAWABLE (tmp_list->data) &&
1427                   (GTK_IS_CONTAINER (tmp_list->data) || GTK_WIDGET_CAN_FOCUS (tmp_list->data)))
1428                 tmp_list = tmp_list->next;
1429               else
1430                 {
1431                   tmp_list2 = tmp_list;
1432                   tmp_list = tmp_list->next;
1433
1434                   children = g_list_remove_link (children, tmp_list2);
1435                   g_list_free_1 (tmp_list2);
1436                 }
1437             }
1438
1439           switch (direction)
1440             {
1441             case GTK_DIR_TAB_FORWARD:
1442             case GTK_DIR_TAB_BACKWARD:
1443               return_val = gtk_container_focus_tab (container, children, direction);
1444               break;
1445             case GTK_DIR_UP:
1446             case GTK_DIR_DOWN:
1447               return_val = gtk_container_focus_up_down (container, children, direction);
1448               break;
1449             case GTK_DIR_LEFT:
1450             case GTK_DIR_RIGHT:
1451               return_val = gtk_container_focus_left_right (container, children, direction);
1452               break;
1453             }
1454
1455           g_list_free (children);
1456         }
1457     }
1458
1459   return return_val;
1460 }
1461
1462 static gint
1463 gtk_container_focus_tab (GtkContainer     *container,
1464                          GList            *children,
1465                          GtkDirectionType  direction)
1466 {
1467   GtkWidget *child;
1468   GtkWidget *child2;
1469   GList *tmp_list;
1470   guint length;
1471   guint i, j;
1472
1473   length = g_list_length (children);
1474
1475   /* sort the children in the y direction */
1476   for (i = 1; i < length; i++)
1477     {
1478       j = i;
1479       tmp_list = g_list_nth (children, j);
1480       child = tmp_list->data;
1481
1482       while (j > 0)
1483         {
1484           child2 = tmp_list->prev->data;
1485           if (child->allocation.y < child2->allocation.y)
1486             {
1487               tmp_list->data = tmp_list->prev->data;
1488               tmp_list = tmp_list->prev;
1489               j--;
1490             }
1491           else
1492             break;
1493         }
1494
1495       tmp_list->data = child;
1496     }
1497
1498   /* sort the children in the x direction while
1499    *  maintaining the y direction sort.
1500    */
1501   for (i = 1; i < length; i++)
1502     {
1503       j = i;
1504       tmp_list = g_list_nth (children, j);
1505       child = tmp_list->data;
1506
1507       while (j > 0)
1508         {
1509           child2 = tmp_list->prev->data;
1510           if ((child->allocation.x < child2->allocation.x) &&
1511               (child->allocation.y == child2->allocation.y))
1512             {
1513               tmp_list->data = tmp_list->prev->data;
1514               tmp_list = tmp_list->prev;
1515               j--;
1516             }
1517           else
1518             break;
1519         }
1520
1521       tmp_list->data = child;
1522     }
1523
1524   /* if we are going backwards then reverse the order
1525    *  of the children.
1526    */
1527   if (direction == GTK_DIR_TAB_BACKWARD)
1528     children = g_list_reverse (children);
1529
1530   return gtk_container_focus_move (container, children, direction);
1531 }
1532
1533 static gint
1534 gtk_container_focus_up_down (GtkContainer     *container,
1535                              GList            *children,
1536                              GtkDirectionType  direction)
1537 {
1538   GtkWidget *child;
1539   GtkWidget *child2;
1540   GList *tmp_list;
1541   gint dist1, dist2;
1542   gint focus_x;
1543   gint focus_width;
1544   guint length;
1545   guint i, j;
1546
1547   /* return failure if there isn't a focus child */
1548   if (container->focus_child)
1549     {
1550       focus_width = container->focus_child->allocation.width / 2;
1551       focus_x = container->focus_child->allocation.x + focus_width;
1552     }
1553   else
1554     {
1555       focus_width = GTK_WIDGET (container)->allocation.width;
1556       if (GTK_WIDGET_NO_WINDOW (container))
1557         focus_x = GTK_WIDGET (container)->allocation.x;
1558       else
1559         focus_x = 0;
1560     }
1561
1562   length = g_list_length (children);
1563
1564   /* sort the children in the y direction */
1565   for (i = 1; i < length; i++)
1566     {
1567       j = i;
1568       tmp_list = g_list_nth (children, j);
1569       child = tmp_list->data;
1570
1571       while (j > 0)
1572         {
1573           child2 = tmp_list->prev->data;
1574           if (child->allocation.y < child2->allocation.y)
1575             {
1576               tmp_list->data = tmp_list->prev->data;
1577               tmp_list = tmp_list->prev;
1578               j--;
1579             }
1580           else
1581             break;
1582         }
1583
1584       tmp_list->data = child;
1585     }
1586
1587   /* sort the children in distance in the x direction
1588    *  in distance from the current focus child while maintaining the
1589    *  sort in the y direction
1590    */
1591   for (i = 1; i < length; i++)
1592     {
1593       j = i;
1594       tmp_list = g_list_nth (children, j);
1595       child = tmp_list->data;
1596       dist1 = (child->allocation.x + child->allocation.width / 2) - focus_x;
1597
1598       while (j > 0)
1599         {
1600           child2 = tmp_list->prev->data;
1601           dist2 = (child2->allocation.x + child2->allocation.width / 2) - focus_x;
1602
1603           if ((dist1 < dist2) &&
1604               (child->allocation.y >= child2->allocation.y))
1605             {
1606               tmp_list->data = tmp_list->prev->data;
1607               tmp_list = tmp_list->prev;
1608               j--;
1609             }
1610           else
1611             break;
1612         }
1613
1614       tmp_list->data = child;
1615     }
1616
1617   /* go and invalidate any widget which is too
1618    *  far from the focus widget.
1619    */
1620   if (!container->focus_child &&
1621       (direction == GTK_DIR_UP))
1622     focus_x += focus_width;
1623
1624   tmp_list = children;
1625   while (tmp_list)
1626     {
1627       child = tmp_list->data;
1628
1629       dist1 = (child->allocation.x + child->allocation.width / 2) - focus_x;
1630       if (((direction == GTK_DIR_DOWN) && (dist1 < 0)) ||
1631           ((direction == GTK_DIR_UP) && (dist1 > 0)))
1632         tmp_list->data = NULL;
1633
1634       tmp_list = tmp_list->next;
1635     }
1636
1637   if (direction == GTK_DIR_UP)
1638     children = g_list_reverse (children);
1639
1640   return gtk_container_focus_move (container, children, direction);
1641 }
1642
1643 static gint
1644 gtk_container_focus_left_right (GtkContainer     *container,
1645                                 GList            *children,
1646                                 GtkDirectionType  direction)
1647 {
1648   GtkWidget *child;
1649   GtkWidget *child2;
1650   GList *tmp_list;
1651   gint dist1, dist2;
1652   gint focus_y;
1653   gint focus_height;
1654   guint length;
1655   guint i, j;
1656
1657   /* return failure if there isn't a focus child */
1658   if (container->focus_child)
1659     {
1660       focus_height = container->focus_child->allocation.height / 2;
1661       focus_y = container->focus_child->allocation.y + focus_height;
1662     }
1663   else
1664     {
1665       focus_height = GTK_WIDGET (container)->allocation.height;
1666       if (GTK_WIDGET_NO_WINDOW (container))
1667         focus_y = GTK_WIDGET (container)->allocation.y;
1668       else
1669         focus_y = 0;
1670     }
1671
1672   length = g_list_length (children);
1673
1674   /* sort the children in the x direction */
1675   for (i = 1; i < length; i++)
1676     {
1677       j = i;
1678       tmp_list = g_list_nth (children, j);
1679       child = tmp_list->data;
1680
1681       while (j > 0)
1682         {
1683           child2 = tmp_list->prev->data;
1684           if (child->allocation.x < child2->allocation.x)
1685             {
1686               tmp_list->data = tmp_list->prev->data;
1687               tmp_list = tmp_list->prev;
1688               j--;
1689             }
1690           else
1691             break;
1692         }
1693
1694       tmp_list->data = child;
1695     }
1696
1697   /* sort the children in distance in the y direction
1698    *  in distance from the current focus child while maintaining the
1699    *  sort in the x direction
1700    */
1701   for (i = 1; i < length; i++)
1702     {
1703       j = i;
1704       tmp_list = g_list_nth (children, j);
1705       child = tmp_list->data;
1706       dist1 = (child->allocation.y + child->allocation.height / 2) - focus_y;
1707
1708       while (j > 0)
1709         {
1710           child2 = tmp_list->prev->data;
1711           dist2 = (child2->allocation.y + child2->allocation.height / 2) - focus_y;
1712
1713           if ((dist1 < dist2) &&
1714               (child->allocation.x >= child2->allocation.x))
1715             {
1716               tmp_list->data = tmp_list->prev->data;
1717               tmp_list = tmp_list->prev;
1718               j--;
1719             }
1720           else
1721             break;
1722         }
1723
1724       tmp_list->data = child;
1725     }
1726
1727   /* go and invalidate any widget which is too
1728    *  far from the focus widget.
1729    */
1730   if (!container->focus_child &&
1731       (direction == GTK_DIR_LEFT))
1732     focus_y += focus_height;
1733
1734   tmp_list = children;
1735   while (tmp_list)
1736     {
1737       child = tmp_list->data;
1738
1739       dist1 = (child->allocation.y + child->allocation.height / 2) - focus_y;
1740       if (((direction == GTK_DIR_RIGHT) && (dist1 < 0)) ||
1741           ((direction == GTK_DIR_LEFT) && (dist1 > 0)))
1742         tmp_list->data = NULL;
1743
1744       tmp_list = tmp_list->next;
1745     }
1746
1747   if (direction == GTK_DIR_LEFT)
1748     children = g_list_reverse (children);
1749
1750   return gtk_container_focus_move (container, children, direction);
1751 }
1752
1753 static gint
1754 gtk_container_focus_move (GtkContainer     *container,
1755                           GList            *children,
1756                           GtkDirectionType  direction)
1757 {
1758   GtkWidget *focus_child;
1759   GtkWidget *child;
1760
1761   focus_child = container->focus_child;
1762   gtk_container_set_focus_child (container, NULL);
1763
1764   while (children)
1765     {
1766       child = children->data;
1767       children = children->next;
1768
1769       if (!child)
1770         continue;
1771
1772       if (focus_child)
1773         {
1774           if (focus_child == child)
1775             {
1776               focus_child = NULL;
1777
1778               if (GTK_WIDGET_DRAWABLE (child) &&
1779                   GTK_IS_CONTAINER (child) &&
1780                   !GTK_WIDGET_HAS_FOCUS (child))
1781                 if (gtk_container_focus (GTK_CONTAINER (child), direction))
1782                   return TRUE;
1783             }
1784         }
1785       else if (GTK_WIDGET_DRAWABLE (child))
1786         {
1787           if (GTK_IS_CONTAINER (child))
1788             {
1789               if (gtk_container_focus (GTK_CONTAINER (child), direction))
1790                 return TRUE;
1791             }
1792           else if (GTK_WIDGET_CAN_FOCUS (child))
1793             {
1794               gtk_widget_grab_focus (child);
1795               return TRUE;
1796             }
1797         }
1798     }
1799
1800   return FALSE;
1801 }
1802
1803
1804 static void
1805 gtk_container_children_callback (GtkWidget *widget,
1806                                  gpointer   client_data)
1807 {
1808   GList **children;
1809
1810   children = (GList**) client_data;
1811   *children = g_list_prepend (*children, widget);
1812 }
1813
1814 void
1815 gtk_container_set_focus_vadjustment (GtkContainer  *container,
1816                                      GtkAdjustment *adjustment)
1817 {
1818   g_return_if_fail (container != NULL);
1819   g_return_if_fail (GTK_IS_CONTAINER (container));
1820   if (adjustment)
1821     g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
1822
1823   if (adjustment)
1824     gtk_object_ref (GTK_OBJECT(adjustment));
1825
1826   gtk_object_set_data_by_id_full (GTK_OBJECT (container),
1827                                   vadjustment_key_id,
1828                                   adjustment,
1829                                   (GtkDestroyNotify) gtk_object_unref);
1830 }
1831
1832 void
1833 gtk_container_set_focus_hadjustment (GtkContainer  *container,
1834                                      GtkAdjustment *adjustment)
1835 {
1836   g_return_if_fail (container != NULL);
1837   g_return_if_fail (GTK_IS_CONTAINER (container));
1838   if (adjustment)
1839     g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
1840
1841   if (adjustment)
1842     gtk_object_ref (GTK_OBJECT (adjustment));
1843
1844   gtk_object_set_data_by_id_full (GTK_OBJECT (container),
1845                                   hadjustment_key_id,
1846                                   adjustment,
1847                                   (GtkDestroyNotify) gtk_object_unref);
1848 }
1849
1850
1851 static void
1852 gtk_container_show_all (GtkWidget *widget)
1853 {
1854   g_return_if_fail (widget != NULL);
1855   g_return_if_fail (GTK_IS_CONTAINER (widget));
1856
1857   gtk_container_foreach (GTK_CONTAINER (widget),
1858                          (GtkCallback) gtk_widget_show_all,
1859                          NULL);
1860   gtk_widget_show (widget);
1861 }
1862
1863 static void
1864 gtk_container_hide_all (GtkWidget *widget)
1865 {
1866   g_return_if_fail (widget != NULL);
1867   g_return_if_fail (GTK_IS_CONTAINER (widget));
1868
1869   gtk_widget_hide (widget);
1870   gtk_container_foreach (GTK_CONTAINER (widget),
1871                          (GtkCallback) gtk_widget_hide_all,
1872                          NULL);
1873 }