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         gtk_widget_size_allocate (GTK_WIDGET (container),
 940                                   &GTK_WIDGET (container)->allocation);
 941       else
 942         gtk_widget_queue_resize (widget);
 943     }
 944   else
 945     {
 946       gtk_container_resize_children (container);
 947     }
 948 }
 949
 950 /* The container hasn't changed size but one of its children
 951  *  queued a resize request. Which means that the allocation
 952  *  is not sufficient for the requisition of some child.
 953  *  We've already performed a size request at this point,
 954  *  so we simply need to run through the list of resize
 955  *  widgets and reallocate their sizes appropriately. We
 956  *  make the optimization of not performing reallocation
 957  *  for a widget who also has a parent in the resize widgets
 958  *  list. GTK_RESIZE_NEEDED is used for flagging those
 959  *  parents inside this function.
 960  */
 961 void
 962 gtk_container_resize_children (GtkContainer *container)
 963 {
 964   GtkWidget *widget;
 965   GtkWidget *resize_container;
 966   GSList *resize_widgets;
 967   GSList *resize_containers;
 968   GSList *node;
 969
 970   /* resizing invariants:
 971    * toplevels have *always* resize_mode != GTK_RESIZE_PARENT set.
 972    * containers with resize_mode==GTK_RESIZE_PARENT have to have resize_widgets
 973    * set to NULL.
 974    * containers that are flagged RESIZE_NEEDED must have resize_widgets set to
 975    * NULL, or are toplevels (thus have ->parent set to NULL).
 976    * widgets that are in some container->resize_widgets list must be flagged with
 977    * RESIZE_NEEDED.
 978    * widgets that have RESIZE_NEEDED set must be referenced in some
 979    * GTK_IS_RESIZE_CONTAINER (container)->resize_widgets list.
 980    * containers that have an idle sizer pending must be flagged with
 981    * RESIZE_PENDING.
 982    */
 983
 984   g_return_if_fail (container != NULL);
 985   g_return_if_fail (GTK_IS_CONTAINER (container));
 986
 987   /* we first check out if we actually need to perform a resize,
 988    * which is not the case if we got another container queued for
 989    * a resize in our anchestry. also we can skip the whole
 990    * resize_widgets checks if we are a toplevel and NEED_RESIZE.
 991    * this code implies that our allocation is sufficient for our
 992    * requisition, since otherwise we would NEED_RESIZE.
 993    */
 994   resize_container = GTK_WIDGET (container);
 995   while (resize_container)
 996     {
 997       if (GTK_WIDGET_RESIZE_NEEDED (resize_container))
 998         break;
 999       resize_container = resize_container->parent;
1000     }
1001   if (resize_container)
1002     {
1003       /* queue_resize and size_allocate both clear our
1004        * resize_widgets list.
1005        */
1006       if (resize_container->parent)
1007         gtk_container_queue_resize (container);
1008       else
1009         gtk_widget_size_allocate (GTK_WIDGET (container),
1010                                   &GTK_WIDGET (container)->allocation);
1011       return;
1012     }
1013
1014   resize_container = GTK_WIDGET (container);
1015
1016   /* we now walk the anchestry for all resize widgets as long
1017    * as they are our children and as long as their allocation
1018    * is insufficient, since we don't need to reallocate below that.
1019    */
1020   resize_widgets = container->resize_widgets;
1021   if (resize_widgets)
1022     gtk_signal_disconnect_by_func (GTK_OBJECT (container),
1023                                    GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
1024                                    NULL);
1025   container->resize_widgets = NULL;
1026   for (node = resize_widgets; node; node = node->next)
1027     {
1028       widget = node->data;
1029
1030       GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
1031
1032       while (widget->parent != resize_container &&
1033              ((widget->allocation.width < widget->requisition.width) ||
1034               (widget->allocation.height < widget->requisition.height)))
1035         widget = widget->parent;
1036
1037       GTK_PRIVATE_SET_FLAG (widget, GTK_RESIZE_NEEDED);
1038       node->data = widget;
1039     }
1040
1041   /* for the newly setup resize_widgets list, we now walk each widget's
1042    * anchestry to sort those widgets out that have RESIZE_NEEDED parents.
1043    * we can safely stop the walk if we are the parent, since we checked
1044    * our own anchestry already.
1045    */
1046   resize_containers = NULL;
1047   for (node = resize_widgets; node; node = node->next)
1048     {
1049       GtkWidget *parent;
1050
1051       widget = node->data;
1052
1053       if (!GTK_WIDGET_RESIZE_NEEDED (widget))
1054         continue;
1055
1056       parent = widget->parent;
1057
1058       while (parent != resize_container)
1059         {
1060           if (GTK_WIDGET_RESIZE_NEEDED (parent))
1061             {
1062               GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
1063               widget = parent;
1064             }
1065           parent = parent->parent;
1066         }
1067
1068       if (!g_slist_find (resize_containers, widget))
1069         {
1070           resize_containers = g_slist_prepend (resize_containers, widget);
1071           gtk_widget_ref (widget);
1072         }
1073     }
1074   g_slist_free (resize_widgets);
1075
1076   for (node = resize_containers; node; node = node->next)
1077     {
1078       widget = node->data;
1079
1080       GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
1081
1082       gtk_widget_size_allocate (widget, &widget->allocation);
1083
1084       gtk_widget_unref (widget);
1085     }
1086   g_slist_free (resize_containers);
1087 }
1088
1089 void
1090 gtk_container_forall (GtkContainer *container,
1091                       GtkCallback   callback,
1092                       gpointer      callback_data)
1093 {
1094   GtkContainerClass *class;
1095
1096   g_return_if_fail (container != NULL);
1097   g_return_if_fail (GTK_IS_CONTAINER (container));
1098   g_return_if_fail (callback != NULL);
1099
1100   class = GTK_CONTAINER_CLASS (GTK_OBJECT (container)->klass);
1101
1102   if (class->forall)
1103     class->forall (container, TRUE, callback, callback_data);
1104 }
1105
1106 void
1107 gtk_container_foreach (GtkContainer *container,
1108                        GtkCallback   callback,
1109                        gpointer      callback_data)
1110 {
1111   GtkContainerClass *class;
1112
1113   g_return_if_fail (container != NULL);
1114   g_return_if_fail (GTK_IS_CONTAINER (container));
1115   g_return_if_fail (callback != NULL);
1116
1117   class = GTK_CONTAINER_CLASS (GTK_OBJECT (container)->klass);
1118
1119   if (class->forall)
1120     class->forall (container, FALSE, callback, callback_data);
1121 }
1122
1123 typedef struct _GtkForeachData  GtkForeachData;
1124 struct _GtkForeachData
1125 {
1126   GtkObject         *container;
1127   GtkCallbackMarshal callback;
1128   gpointer           callback_data;
1129 };
1130
1131 static void
1132 gtk_container_foreach_unmarshal (GtkWidget *child,
1133                                  gpointer data)
1134 {
1135   GtkForeachData *fdata = (GtkForeachData*) data;
1136   GtkArg args[2];
1137
1138   /* first argument */
1139   args[0].name = NULL;
1140   args[0].type = GTK_OBJECT(child)->klass->type;
1141   GTK_VALUE_OBJECT(args[0]) = GTK_OBJECT (child);
1142
1143   /* location for return value */
1144   args[1].name = NULL;
1145   args[1].type = GTK_TYPE_NONE;
1146
1147   fdata->callback (fdata->container, fdata->callback_data, 1, args);
1148 }
1149
1150 void
1151 gtk_container_foreach_full (GtkContainer       *container,
1152                             GtkCallback         callback,
1153                             GtkCallbackMarshal  marshal,
1154                             gpointer            callback_data,
1155                             GtkDestroyNotify    notify)
1156 {
1157   g_return_if_fail (container != NULL);
1158   g_return_if_fail (GTK_IS_CONTAINER (container));
1159
1160   if (marshal)
1161     {
1162       GtkForeachData fdata;
1163
1164       fdata.container     = GTK_OBJECT (container);
1165       fdata.callback      = marshal;
1166       fdata.callback_data = callback_data;
1167
1168       gtk_container_foreach (container, gtk_container_foreach_unmarshal, &fdata);
1169     }
1170   else
1171     {
1172       g_return_if_fail (callback != NULL);
1173
1174       gtk_container_foreach (container, callback, &callback_data);
1175     }
1176
1177   if (notify)
1178     notify (callback_data);
1179 }
1180
1181 gint
1182 gtk_container_focus (GtkContainer     *container,
1183                      GtkDirectionType  direction)
1184 {
1185   gint return_val;
1186
1187   g_return_val_if_fail (container != NULL, FALSE);
1188   g_return_val_if_fail (GTK_IS_CONTAINER (container), FALSE);
1189
1190   gtk_signal_emit (GTK_OBJECT (container),
1191                    container_signals[FOCUS],
1192                    direction, &return_val);
1193
1194   return return_val;
1195 }
1196
1197 void
1198 gtk_container_set_focus_child (GtkContainer *container,
1199                                GtkWidget    *widget)
1200 {
1201   g_return_if_fail (container != NULL);
1202   g_return_if_fail (GTK_IS_CONTAINER (container));
1203   if (widget)
1204     g_return_if_fail (GTK_IS_WIDGET (widget));
1205
1206   gtk_signal_emit (GTK_OBJECT (container), container_signals[SET_FOCUS_CHILD], widget);
1207 }
1208
1209 GList*
1210 gtk_container_children (GtkContainer *container)
1211 {
1212   GList *children;
1213
1214   children = NULL;
1215
1216   gtk_container_foreach (container,
1217                          gtk_container_children_callback,
1218                          &children);
1219
1220   return g_list_reverse (children);
1221 }
1222
1223 void
1224 gtk_container_register_toplevel (GtkContainer *container)
1225 {
1226   g_return_if_fail (container != NULL);
1227
1228   toplevel_list = g_list_prepend (toplevel_list, container);
1229
1230   gtk_widget_ref (GTK_WIDGET (container));
1231   gtk_object_sink (GTK_OBJECT (container));
1232 }
1233
1234 void
1235 gtk_container_unregister_toplevel (GtkContainer *container)
1236 {
1237   GList *node;
1238
1239   g_return_if_fail (container != NULL);
1240
1241   node = g_list_find (toplevel_list, container);
1242   g_return_if_fail (node != NULL);
1243
1244   toplevel_list = g_list_remove_link (toplevel_list, node);
1245   g_list_free_1 (node);
1246
1247   gtk_widget_unref (GTK_WIDGET (container));
1248 }
1249
1250 GList*
1251 gtk_container_get_toplevels (void)
1252 {
1253   /* XXX: fixme we should ref all these widgets and duplicate
1254    * the list.
1255    */
1256   return toplevel_list;
1257 }
1258
1259 static void
1260 gtk_container_child_position_callback (GtkWidget *widget,
1261                                        gpointer   client_data)
1262 {
1263   struct {
1264     GtkWidget *child;
1265     guint i;
1266     guint index;
1267   } *data = client_data;
1268
1269   data->i++;
1270   if (data->child == widget)
1271     data->index = data->i;
1272 }
1273
1274 static gchar*
1275 gtk_container_child_default_composite_name (GtkContainer *container,
1276                                             GtkWidget    *child)
1277 {
1278   struct {
1279     GtkWidget *child;
1280     guint i;
1281     guint index;
1282   } data;
1283   gchar *name;
1284
1285   /* fallback implementation */
1286   data.child = child;
1287   data.i = 0;
1288   data.index = 0;
1289   gtk_container_forall (container,
1290                         gtk_container_child_position_callback,
1291                         &data);
1292
1293   name = g_strdup_printf ("%s-%u",
1294                           gtk_type_name (GTK_OBJECT_TYPE (child)),
1295                           data.index);
1296
1297   return name;
1298 }
1299
1300 gchar*
1301 gtk_container_child_composite_name (GtkContainer *container,
1302                                     GtkWidget    *child)
1303 {
1304   g_return_val_if_fail (container != NULL, NULL);
1305   g_return_val_if_fail (GTK_IS_CONTAINER (container), NULL);
1306   g_return_val_if_fail (child != NULL, NULL);
1307   g_return_val_if_fail (GTK_IS_WIDGET (child), NULL);
1308   g_return_val_if_fail (child->parent == GTK_WIDGET (container), NULL);
1309
1310   if (GTK_WIDGET_COMPOSITE_CHILD (child))
1311     {
1312       static GQuark quark_composite_name = 0;
1313       gchar *name;
1314
1315       if (!quark_composite_name)
1316         quark_composite_name = g_quark_from_static_string ("gtk-composite-name");
1317
1318       name = gtk_object_get_data_by_id (GTK_OBJECT (child), quark_composite_name);
1319       if (!name)
1320         {
1321           GtkContainerClass *class;
1322
1323           class = GTK_CONTAINER_CLASS (GTK_OBJECT (container)->klass);
1324           if (class->composite_name)
1325             name = class->composite_name (container, child);
1326         }
1327       else
1328         name = g_strdup (name);
1329
1330       return name;
1331     }
1332
1333   return NULL;
1334 }
1335
1336 void
1337 gtk_container_real_set_focus_child (GtkContainer     *container,
1338                                     GtkWidget        *child)
1339 {
1340   g_return_if_fail (container != NULL);
1341   g_return_if_fail (GTK_IS_CONTAINER (container));
1342   if (child)
1343     g_return_if_fail (GTK_IS_WIDGET (child));
1344
1345   if (child != container->focus_child)
1346     {
1347       if (container->focus_child)
1348         gtk_widget_unref (container->focus_child);
1349       container->focus_child = child;
1350       if (container->focus_child)
1351         gtk_widget_ref (container->focus_child);
1352     }
1353
1354
1355   /* check for h/v adjustments
1356    */
1357   if (container->focus_child)
1358     {
1359       GtkAdjustment *adjustment;
1360
1361       adjustment = gtk_object_get_data_by_id (GTK_OBJECT (container), vadjustment_key_id);
1362       if (adjustment)
1363         gtk_adjustment_clamp_page (adjustment,
1364                                    container->focus_child->allocation.y,
1365                                    (container->focus_child->allocation.y +
1366                                     container->focus_child->allocation.height));
1367
1368       adjustment = gtk_object_get_data_by_id (GTK_OBJECT (container), hadjustment_key_id);
1369       if (adjustment)
1370         gtk_adjustment_clamp_page (adjustment,
1371                                    container->focus_child->allocation.x,
1372                                    (container->focus_child->allocation.x +
1373                                     container->focus_child->allocation.width));
1374     }
1375 }
1376
1377 static gint
1378 gtk_container_real_focus (GtkContainer     *container,
1379                           GtkDirectionType  direction)
1380 {
1381   GList *children;
1382   GList *tmp_list;
1383   GList *tmp_list2;
1384   gint return_val;
1385
1386   g_return_val_if_fail (container != NULL, FALSE);
1387   g_return_val_if_fail (GTK_IS_CONTAINER (container), FALSE);
1388
1389   /* Fail if the container is inappropriate for focus movement
1390    */
1391   if (!GTK_WIDGET_DRAWABLE (container) ||
1392       !GTK_WIDGET_IS_SENSITIVE (container))
1393     return FALSE;
1394
1395   return_val = FALSE;
1396
1397   if (GTK_WIDGET_CAN_FOCUS (container))
1398     {
1399       gtk_widget_grab_focus (GTK_WIDGET (container));
1400       return_val = TRUE;
1401     }
1402   else
1403     {
1404       /* Get a list of the containers children
1405        */
1406       children = NULL;
1407       gtk_container_forall (container,
1408                             gtk_container_children_callback,
1409                             &children);
1410       children = g_list_reverse (children);
1411       /* children = gtk_container_children (container); */
1412
1413       if (children)
1414         {
1415           /* Remove any children which are inappropriate for focus movement
1416            */
1417           tmp_list = children;
1418           while (tmp_list)
1419             {
1420               if (GTK_WIDGET_IS_SENSITIVE (tmp_list->data) &&
1421                   GTK_WIDGET_DRAWABLE (tmp_list->data) &&
1422                   (GTK_IS_CONTAINER (tmp_list->data) || GTK_WIDGET_CAN_FOCUS (tmp_list->data)))
1423                 tmp_list = tmp_list->next;
1424               else
1425                 {
1426                   tmp_list2 = tmp_list;
1427                   tmp_list = tmp_list->next;
1428
1429                   children = g_list_remove_link (children, tmp_list2);
1430                   g_list_free_1 (tmp_list2);
1431                 }
1432             }
1433
1434           switch (direction)
1435             {
1436             case GTK_DIR_TAB_FORWARD:
1437             case GTK_DIR_TAB_BACKWARD:
1438               return_val = gtk_container_focus_tab (container, children, direction);
1439               break;
1440             case GTK_DIR_UP:
1441             case GTK_DIR_DOWN:
1442               return_val = gtk_container_focus_up_down (container, children, direction);
1443               break;
1444             case GTK_DIR_LEFT:
1445             case GTK_DIR_RIGHT:
1446               return_val = gtk_container_focus_left_right (container, children, direction);
1447               break;
1448             }
1449
1450           g_list_free (children);
1451         }
1452     }
1453
1454   return return_val;
1455 }
1456
1457 static gint
1458 gtk_container_focus_tab (GtkContainer     *container,
1459                          GList            *children,
1460                          GtkDirectionType  direction)
1461 {
1462   GtkWidget *child;
1463   GtkWidget *child2;
1464   GList *tmp_list;
1465   guint length;
1466   guint i, j;
1467
1468   length = g_list_length (children);
1469
1470   /* sort the children in the y direction */
1471   for (i = 1; i < length; i++)
1472     {
1473       j = i;
1474       tmp_list = g_list_nth (children, j);
1475       child = tmp_list->data;
1476
1477       while (j > 0)
1478         {
1479           child2 = tmp_list->prev->data;
1480           if (child->allocation.y < child2->allocation.y)
1481             {
1482               tmp_list->data = tmp_list->prev->data;
1483               tmp_list = tmp_list->prev;
1484               j--;
1485             }
1486           else
1487             break;
1488         }
1489
1490       tmp_list->data = child;
1491     }
1492
1493   /* sort the children in the x direction while
1494    *  maintaining the y direction sort.
1495    */
1496   for (i = 1; i < length; i++)
1497     {
1498       j = i;
1499       tmp_list = g_list_nth (children, j);
1500       child = tmp_list->data;
1501
1502       while (j > 0)
1503         {
1504           child2 = tmp_list->prev->data;
1505           if ((child->allocation.x < child2->allocation.x) &&
1506               (child->allocation.y == child2->allocation.y))
1507             {
1508               tmp_list->data = tmp_list->prev->data;
1509               tmp_list = tmp_list->prev;
1510               j--;
1511             }
1512           else
1513             break;
1514         }
1515
1516       tmp_list->data = child;
1517     }
1518
1519   /* if we are going backwards then reverse the order
1520    *  of the children.
1521    */
1522   if (direction == GTK_DIR_TAB_BACKWARD)
1523     children = g_list_reverse (children);
1524
1525   return gtk_container_focus_move (container, children, direction);
1526 }
1527
1528 static gint
1529 gtk_container_focus_up_down (GtkContainer     *container,
1530                              GList            *children,
1531                              GtkDirectionType  direction)
1532 {
1533   GtkWidget *child;
1534   GtkWidget *child2;
1535   GList *tmp_list;
1536   gint dist1, dist2;
1537   gint focus_x;
1538   gint focus_width;
1539   guint length;
1540   guint i, j;
1541
1542   /* return failure if there isn't a focus child */
1543   if (container->focus_child)
1544     {
1545       focus_width = container->focus_child->allocation.width / 2;
1546       focus_x = container->focus_child->allocation.x + focus_width;
1547     }
1548   else
1549     {
1550       focus_width = GTK_WIDGET (container)->allocation.width;
1551       if (GTK_WIDGET_NO_WINDOW (container))
1552         focus_x = GTK_WIDGET (container)->allocation.x;
1553       else
1554         focus_x = 0;
1555     }
1556
1557   length = g_list_length (children);
1558
1559   /* sort the children in the y direction */
1560   for (i = 1; i < length; i++)
1561     {
1562       j = i;
1563       tmp_list = g_list_nth (children, j);
1564       child = tmp_list->data;
1565
1566       while (j > 0)
1567         {
1568           child2 = tmp_list->prev->data;
1569           if (child->allocation.y < child2->allocation.y)
1570             {
1571               tmp_list->data = tmp_list->prev->data;
1572               tmp_list = tmp_list->prev;
1573               j--;
1574             }
1575           else
1576             break;
1577         }
1578
1579       tmp_list->data = child;
1580     }
1581
1582   /* sort the children in distance in the x direction
1583    *  in distance from the current focus child while maintaining the
1584    *  sort in the y direction
1585    */
1586   for (i = 1; i < length; i++)
1587     {
1588       j = i;
1589       tmp_list = g_list_nth (children, j);
1590       child = tmp_list->data;
1591       dist1 = (child->allocation.x + child->allocation.width / 2) - focus_x;
1592
1593       while (j > 0)
1594         {
1595           child2 = tmp_list->prev->data;
1596           dist2 = (child2->allocation.x + child2->allocation.width / 2) - focus_x;
1597
1598           if ((dist1 < dist2) &&
1599               (child->allocation.y >= child2->allocation.y))
1600             {
1601               tmp_list->data = tmp_list->prev->data;
1602               tmp_list = tmp_list->prev;
1603               j--;
1604             }
1605           else
1606             break;
1607         }
1608
1609       tmp_list->data = child;
1610     }
1611
1612   /* go and invalidate any widget which is too
1613    *  far from the focus widget.
1614    */
1615   if (!container->focus_child &&
1616       (direction == GTK_DIR_UP))
1617     focus_x += focus_width;
1618
1619   tmp_list = children;
1620   while (tmp_list)
1621     {
1622       child = tmp_list->data;
1623
1624       dist1 = (child->allocation.x + child->allocation.width / 2) - focus_x;
1625       if (((direction == GTK_DIR_DOWN) && (dist1 < 0)) ||
1626           ((direction == GTK_DIR_UP) && (dist1 > 0)))
1627         tmp_list->data = NULL;
1628
1629       tmp_list = tmp_list->next;
1630     }
1631
1632   if (direction == GTK_DIR_UP)
1633     children = g_list_reverse (children);
1634
1635   return gtk_container_focus_move (container, children, direction);
1636 }
1637
1638 static gint
1639 gtk_container_focus_left_right (GtkContainer     *container,
1640                                 GList            *children,
1641                                 GtkDirectionType  direction)
1642 {
1643   GtkWidget *child;
1644   GtkWidget *child2;
1645   GList *tmp_list;
1646   gint dist1, dist2;
1647   gint focus_y;
1648   gint focus_height;
1649   guint length;
1650   guint i, j;
1651
1652   /* return failure if there isn't a focus child */
1653   if (container->focus_child)
1654     {
1655       focus_height = container->focus_child->allocation.height / 2;
1656       focus_y = container->focus_child->allocation.y + focus_height;
1657     }
1658   else
1659     {
1660       focus_height = GTK_WIDGET (container)->allocation.height;
1661       if (GTK_WIDGET_NO_WINDOW (container))
1662         focus_y = GTK_WIDGET (container)->allocation.y;
1663       else
1664         focus_y = 0;
1665     }
1666
1667   length = g_list_length (children);
1668
1669   /* sort the children in the x direction */
1670   for (i = 1; i < length; i++)
1671     {
1672       j = i;
1673       tmp_list = g_list_nth (children, j);
1674       child = tmp_list->data;
1675
1676       while (j > 0)
1677         {
1678           child2 = tmp_list->prev->data;
1679           if (child->allocation.x < child2->allocation.x)
1680             {
1681               tmp_list->data = tmp_list->prev->data;
1682               tmp_list = tmp_list->prev;
1683               j--;
1684             }
1685           else
1686             break;
1687         }
1688
1689       tmp_list->data = child;
1690     }
1691
1692   /* sort the children in distance in the y direction
1693    *  in distance from the current focus child while maintaining the
1694    *  sort in the x direction
1695    */
1696   for (i = 1; i < length; i++)
1697     {
1698       j = i;
1699       tmp_list = g_list_nth (children, j);
1700       child = tmp_list->data;
1701       dist1 = (child->allocation.y + child->allocation.height / 2) - focus_y;
1702
1703       while (j > 0)
1704         {
1705           child2 = tmp_list->prev->data;
1706           dist2 = (child2->allocation.y + child2->allocation.height / 2) - focus_y;
1707
1708           if ((dist1 < dist2) &&
1709               (child->allocation.x >= child2->allocation.x))
1710             {
1711               tmp_list->data = tmp_list->prev->data;
1712               tmp_list = tmp_list->prev;
1713               j--;
1714             }
1715           else
1716             break;
1717         }
1718
1719       tmp_list->data = child;
1720     }
1721
1722   /* go and invalidate any widget which is too
1723    *  far from the focus widget.
1724    */
1725   if (!container->focus_child &&
1726       (direction == GTK_DIR_LEFT))
1727     focus_y += focus_height;
1728
1729   tmp_list = children;
1730   while (tmp_list)
1731     {
1732       child = tmp_list->data;
1733
1734       dist1 = (child->allocation.y + child->allocation.height / 2) - focus_y;
1735       if (((direction == GTK_DIR_RIGHT) && (dist1 < 0)) ||
1736           ((direction == GTK_DIR_LEFT) && (dist1 > 0)))
1737         tmp_list->data = NULL;
1738
1739       tmp_list = tmp_list->next;
1740     }
1741
1742   if (direction == GTK_DIR_LEFT)
1743     children = g_list_reverse (children);
1744
1745   return gtk_container_focus_move (container, children, direction);
1746 }
1747
1748 static gint
1749 gtk_container_focus_move (GtkContainer     *container,
1750                           GList            *children,
1751                           GtkDirectionType  direction)
1752 {
1753   GtkWidget *focus_child;
1754   GtkWidget *child;
1755
1756   focus_child = container->focus_child;
1757   gtk_container_set_focus_child (container, NULL);
1758
1759   while (children)
1760     {
1761       child = children->data;
1762       children = children->next;
1763
1764       if (!child)
1765         continue;
1766
1767       if (focus_child)
1768         {
1769           if (focus_child == child)
1770             {
1771               focus_child = NULL;
1772
1773               if (GTK_WIDGET_DRAWABLE (child) &&
1774                   GTK_IS_CONTAINER (child) &&
1775                   !GTK_WIDGET_HAS_FOCUS (child))
1776                 if (gtk_container_focus (GTK_CONTAINER (child), direction))
1777                   return TRUE;
1778             }
1779         }
1780       else if (GTK_WIDGET_DRAWABLE (child))
1781         {
1782           if (GTK_IS_CONTAINER (child))
1783             {
1784               if (gtk_container_focus (GTK_CONTAINER (child), direction))
1785                 return TRUE;
1786             }
1787           else if (GTK_WIDGET_CAN_FOCUS (child))
1788             {
1789               gtk_widget_grab_focus (child);
1790               return TRUE;
1791             }
1792         }
1793     }
1794
1795   return FALSE;
1796 }
1797
1798
1799 static void
1800 gtk_container_children_callback (GtkWidget *widget,
1801                                  gpointer   client_data)
1802 {
1803   GList **children;
1804
1805   children = (GList**) client_data;
1806   *children = g_list_prepend (*children, widget);
1807 }
1808
1809 void
1810 gtk_container_set_focus_vadjustment (GtkContainer  *container,
1811                                      GtkAdjustment *adjustment)
1812 {
1813   g_return_if_fail (container != NULL);
1814   g_return_if_fail (GTK_IS_CONTAINER (container));
1815   if (adjustment)
1816     g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
1817
1818   if (adjustment)
1819     gtk_object_ref (GTK_OBJECT(adjustment));
1820
1821   gtk_object_set_data_by_id_full (GTK_OBJECT (container),
1822                                   vadjustment_key_id,
1823                                   adjustment,
1824                                   (GtkDestroyNotify) gtk_object_unref);
1825 }
1826
1827 void
1828 gtk_container_set_focus_hadjustment (GtkContainer  *container,
1829                                      GtkAdjustment *adjustment)
1830 {
1831   g_return_if_fail (container != NULL);
1832   g_return_if_fail (GTK_IS_CONTAINER (container));
1833   if (adjustment)
1834     g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
1835
1836   if (adjustment)
1837     gtk_object_ref (GTK_OBJECT (adjustment));
1838
1839   gtk_object_set_data_by_id_full (GTK_OBJECT (container),
1840                                   hadjustment_key_id,
1841                                   adjustment,
1842                                   (GtkDestroyNotify) gtk_object_unref);
1843 }
1844
1845
1846 static void
1847 gtk_container_show_all (GtkWidget *widget)
1848 {
1849   g_return_if_fail (widget != NULL);
1850   g_return_if_fail (GTK_IS_CONTAINER (widget));
1851
1852   gtk_container_foreach (GTK_CONTAINER (widget),
1853                          (GtkCallback) gtk_widget_show_all,
1854                          NULL);
1855   gtk_widget_show (widget);
1856 }
1857
1858 static void
1859 gtk_container_hide_all (GtkWidget *widget)
1860 {
1861   g_return_if_fail (widget != NULL);
1862   g_return_if_fail (GTK_IS_CONTAINER (widget));
1863
1864   gtk_widget_hide (widget);
1865   gtk_container_foreach (GTK_CONTAINER (widget),
1866                          (GtkCallback) gtk_widget_hide_all,
1867                          NULL);
1868 }