/* GTK - The GIMP Toolkit

 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GTK+ Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 

 */

#include "config.h"

#include <string.h> /* memset */

#undef GTK_DISABLE_DEPRECATED

#define __GTK_LIST_C__

#include "gtklist.h"

#include "gtklistitem.h"

#include "gtkmain.h"

#include "gtksignal.h"

#include "gtklabel.h"

#include "gtkmarshalers.h"

#include "gtkintl.h"

#include "gtkalias.h"

enum {

  SELECTION_CHANGED,

  SELECT_CHILD,

  UNSELECT_CHILD,

  LAST_SIGNAL

};

enum {

  ARG_0,

  ARG_SELECTION_MODE

};

#define SCROLL_TIME  100

/*** GtkList Methods ***/

static void gtk_list_class_init	     (GtkListClass   *klass);

static void gtk_list_init	     (GtkList	     *list);

static void gtk_list_set_arg         (GtkObject      *object,

				      GtkArg         *arg,

				      guint           arg_id);

static void gtk_list_get_arg         (GtkObject      *object,

				      GtkArg         *arg,

				      guint           arg_id);

/*** GtkObject Methods ***/

static void gtk_list_dispose	     (GObject	     *object);

/*** GtkWidget Methods ***/

static void gtk_list_size_request    (GtkWidget	     *widget,

				      GtkRequisition *requisition);

static void gtk_list_size_allocate   (GtkWidget	     *widget,

				      GtkAllocation  *allocation);

static void gtk_list_realize	     (GtkWidget	     *widget);

static void gtk_list_unmap	     (GtkWidget	     *widget);

static void gtk_list_style_set	     (GtkWidget      *widget,

				      GtkStyle       *previous_style);

static gint gtk_list_motion_notify   (GtkWidget      *widget,

				      GdkEventMotion *event);

static gint gtk_list_button_press    (GtkWidget      *widget,

				      GdkEventButton *event);

static gint gtk_list_button_release  (GtkWidget	     *widget,

				      GdkEventButton *event);

static gboolean gtk_list_focus       (GtkWidget        *widget,

                                      GtkDirectionType  direction);

/*** GtkContainer Methods ***/

static void gtk_list_add	     (GtkContainer     *container,

				      GtkWidget        *widget);

static void gtk_list_remove	     (GtkContainer     *container,

				      GtkWidget        *widget);

static void gtk_list_forall	     (GtkContainer     *container,

				      gboolean          include_internals,

				      GtkCallback       callback,

				      gpointer          callback_data);

static GtkType gtk_list_child_type   (GtkContainer     *container);

static void gtk_list_set_focus_child (GtkContainer     *container,

				      GtkWidget        *widget);

/*** GtkList Private Functions ***/

static void gtk_list_move_focus_child      (GtkList       *list,

					    GtkScrollType  scroll_type,

					    gfloat         position);

static gint gtk_list_horizontal_timeout    (GtkWidget     *list);

static gint gtk_list_vertical_timeout      (GtkWidget     *list);

static void gtk_list_remove_items_internal (GtkList       *list,

					    GList         *items,

					    gboolean       no_unref);

/*** GtkList Selection Methods ***/

static void gtk_real_list_select_child	        (GtkList   *list,

						 GtkWidget *child);

static void gtk_real_list_unselect_child        (GtkList   *list,

						 GtkWidget *child);

/*** GtkList Selection Functions ***/

static void gtk_list_set_anchor                 (GtkList   *list,

					         gboolean   add_mode,

					         gint       anchor,

					         GtkWidget *undo_focus_child);

static void gtk_list_fake_unselect_all          (GtkList   *list,

			                         GtkWidget *item);

static void gtk_list_fake_toggle_row            (GtkList   *list,

					         GtkWidget *item);

static void gtk_list_update_extended_selection  (GtkList   *list,

					         gint       row);

static void gtk_list_reset_extended_selection   (GtkList   *list);

/*** GtkListItem Signal Functions ***/

static void gtk_list_signal_drag_begin         (GtkWidget      *widget,

						GdkDragContext *context,

						GtkList        *list);

static void gtk_list_signal_toggle_focus_row   (GtkListItem   *list_item,

						GtkList       *list);

static void gtk_list_signal_select_all         (GtkListItem   *list_item,

						GtkList       *list);

static void gtk_list_signal_unselect_all       (GtkListItem   *list_item,

						GtkList       *list);

static void gtk_list_signal_undo_selection     (GtkListItem   *list_item,

						GtkList       *list);

static void gtk_list_signal_start_selection    (GtkListItem   *list_item,

						GtkList       *list);

static void gtk_list_signal_end_selection      (GtkListItem   *list_item,

						GtkList       *list);

static void gtk_list_signal_extend_selection   (GtkListItem   *list_item,

						GtkScrollType  scroll_type,

						gfloat         position,

						gboolean       auto_start_selection,

						GtkList       *list);

static void gtk_list_signal_scroll_horizontal  (GtkListItem   *list_item,

						GtkScrollType  scroll_type,

						gfloat         position,

						GtkList       *list);

static void gtk_list_signal_scroll_vertical    (GtkListItem   *list_item,

						GtkScrollType  scroll_type,

						gfloat         position,

						GtkList       *list);

static void gtk_list_signal_toggle_add_mode    (GtkListItem   *list_item,

						GtkList       *list);

static void gtk_list_signal_item_select        (GtkListItem   *list_item,

						GtkList       *list);

static void gtk_list_signal_item_deselect      (GtkListItem   *list_item,

						GtkList       *list);

static void gtk_list_signal_item_toggle        (GtkListItem   *list_item,

						GtkList       *list);

static void gtk_list_drag_begin (GtkWidget      *widget,

				 GdkDragContext *context);

static GtkContainerClass *parent_class = NULL;

static guint list_signals[LAST_SIGNAL] = { 0 };

static const gchar vadjustment_key[] = "gtk-vadjustment";

static guint        vadjustment_key_id = 0;

static const gchar hadjustment_key[] = "gtk-hadjustment";

static guint        hadjustment_key_id = 0;

GtkType

gtk_list_get_type (void)

{

  static GtkType list_type = 0;

  if (!list_type)

    {

      static const GtkTypeInfo list_info =

      {

	"GtkList",

	sizeof (GtkList),

	sizeof (GtkListClass),

	(GtkClassInitFunc) gtk_list_class_init,

	(GtkObjectInitFunc) gtk_list_init,

	/* reserved_1 */ NULL,

	/* reserved_2 */ NULL,

        (GtkClassInitFunc) NULL,

      };

      I_("GtkList");

      list_type = gtk_type_unique (GTK_TYPE_CONTAINER, &list_info);

    }

  return list_type;

}

static void

gtk_list_class_init (GtkListClass *class)

{

  GObjectClass *gobject_class = G_OBJECT_CLASS (class);

  GtkObjectClass *object_class;

  GtkWidgetClass *widget_class;

  GtkContainerClass *container_class;

  object_class = (GtkObjectClass*) class;

  widget_class = (GtkWidgetClass*) class;

  container_class = (GtkContainerClass*) class;

  parent_class = gtk_type_class (GTK_TYPE_CONTAINER);

  vadjustment_key_id = g_quark_from_static_string (vadjustment_key);

  hadjustment_key_id = g_quark_from_static_string (hadjustment_key);

  gobject_class->dispose = gtk_list_dispose;

  object_class->set_arg = gtk_list_set_arg;

  object_class->get_arg = gtk_list_get_arg;

  widget_class->unmap = gtk_list_unmap;

  widget_class->style_set = gtk_list_style_set;

  widget_class->realize = gtk_list_realize;

  widget_class->button_press_event = gtk_list_button_press;

  widget_class->button_release_event = gtk_list_button_release;

  widget_class->motion_notify_event = gtk_list_motion_notify;

  widget_class->size_request = gtk_list_size_request;

  widget_class->size_allocate = gtk_list_size_allocate;

  widget_class->drag_begin = gtk_list_drag_begin;

  widget_class->focus = gtk_list_focus;

  container_class->add = gtk_list_add;

  container_class->remove = gtk_list_remove;

  container_class->forall = gtk_list_forall;

  container_class->child_type = gtk_list_child_type;

  container_class->set_focus_child = gtk_list_set_focus_child;

  class->selection_changed = NULL;

  class->select_child = gtk_real_list_select_child;

  class->unselect_child = gtk_real_list_unselect_child;

  list_signals[SELECTION_CHANGED] =

    gtk_signal_new (I_("selection-changed"),

		    GTK_RUN_FIRST,

		    GTK_CLASS_TYPE (object_class),

		    GTK_SIGNAL_OFFSET (GtkListClass, selection_changed),

		    _gtk_marshal_VOID__VOID,

		    GTK_TYPE_NONE, 0);

  list_signals[SELECT_CHILD] =

    gtk_signal_new (I_("select-child"),

		    GTK_RUN_FIRST,

		    GTK_CLASS_TYPE (object_class),

		    GTK_SIGNAL_OFFSET (GtkListClass, select_child),

		    _gtk_marshal_VOID__OBJECT,

		    GTK_TYPE_NONE, 1,

		    GTK_TYPE_WIDGET);

  list_signals[UNSELECT_CHILD] =

    gtk_signal_new (I_("unselect-child"),

		    GTK_RUN_FIRST,

		    GTK_CLASS_TYPE (object_class),

		    GTK_SIGNAL_OFFSET (GtkListClass, unselect_child),

		    _gtk_marshal_VOID__OBJECT,

		    GTK_TYPE_NONE, 1,

		    GTK_TYPE_WIDGET);

  gtk_object_add_arg_type ("GtkList::selection-mode",

			   GTK_TYPE_SELECTION_MODE, 

			   GTK_ARG_READWRITE | G_PARAM_STATIC_NAME,

			   ARG_SELECTION_MODE);

}

static void

gtk_list_init (GtkList *list)

{

  list->children = NULL;

  list->selection = NULL;

  list->undo_selection = NULL;

  list->undo_unselection = NULL;

  list->last_focus_child = NULL;

  list->undo_focus_child = NULL;

  list->htimer = 0;

  list->vtimer = 0;

  list->anchor = -1;

  list->drag_pos = -1;

  list->anchor_state = GTK_STATE_SELECTED;

  list->selection_mode = GTK_SELECTION_SINGLE;

  list->drag_selection = FALSE;

  list->add_mode = FALSE;

}

static void

gtk_list_set_arg (GtkObject      *object,

		  GtkArg         *arg,

		  guint           arg_id)

{

  GtkList *list = GTK_LIST (object);

  switch (arg_id)

    {

    case ARG_SELECTION_MODE:

      gtk_list_set_selection_mode (list, GTK_VALUE_ENUM (*arg));

      break;

    }

}

static void

gtk_list_get_arg (GtkObject      *object,

		  GtkArg         *arg,

		  guint           arg_id)

{

  GtkList *list = GTK_LIST (object);

  switch (arg_id)

    {

    case ARG_SELECTION_MODE: 

      GTK_VALUE_ENUM (*arg) = list->selection_mode; 

      break;

    default:

      arg->type = GTK_TYPE_INVALID;

      break;

    }

}

GtkWidget*

gtk_list_new (void)

{

  return GTK_WIDGET (gtk_type_new (GTK_TYPE_LIST));

}

/* Private GtkObject Methods :

 * 

 * gtk_list_dispose

 */

static void

gtk_list_dispose (GObject *object)

{

  gtk_list_clear_items (GTK_LIST (object), 0, -1);

  G_OBJECT_CLASS (parent_class)->dispose (object);

}

/* Private GtkWidget Methods :

 * 

 * gtk_list_size_request

 * gtk_list_size_allocate

 * gtk_list_realize

 * gtk_list_unmap

 * gtk_list_motion_notify

 * gtk_list_button_press

 * gtk_list_button_release

 */

static void

gtk_list_size_request (GtkWidget      *widget,

		       GtkRequisition *requisition)

{

  GtkList *list = GTK_LIST (widget);

  GtkWidget *child;

  GList *children;

  requisition->width = 0;

  requisition->height = 0;

  children = list->children;

  while (children)

    {

      child = children->data;

      children = children->next;

      if (gtk_widget_get_visible (child))

	{

	  GtkRequisition child_requisition;

	  gtk_widget_size_request (child, &child_requisition);

	  requisition->width = MAX (requisition->width,

				    child_requisition.width);

	  requisition->height += child_requisition.height;

	}

    }

  requisition->width += GTK_CONTAINER (list)->border_width * 2;

  requisition->height += GTK_CONTAINER (list)->border_width * 2;

  requisition->width = MAX (requisition->width, 1);

  requisition->height = MAX (requisition->height, 1);

}

static void

gtk_list_size_allocate (GtkWidget     *widget,

			GtkAllocation *allocation)

{

  GtkList *list = GTK_LIST (widget);

  GtkWidget *child;

  GtkAllocation child_allocation;

  GList *children;

  widget->allocation = *allocation;

  if (gtk_widget_get_realized (widget))

    gdk_window_move_resize (widget->window,

			    allocation->x, allocation->y,

			    allocation->width, allocation->height);

  if (list->children)

    {

      child_allocation.x = GTK_CONTAINER (list)->border_width;

      child_allocation.y = GTK_CONTAINER (list)->border_width;

      child_allocation.width = MAX (1, (gint)allocation->width -

				    child_allocation.x * 2);

      children = list->children;

      while (children)

	{

	  child = children->data;

	  children = children->next;

	  if (gtk_widget_get_visible (child))

	    {

	      GtkRequisition child_requisition;

	      gtk_widget_get_child_requisition (child, &child_requisition);

	      child_allocation.height = child_requisition.height;

	      gtk_widget_size_allocate (child, &child_allocation);

	      child_allocation.y += child_allocation.height;

	    }

	}

    }

}

static void

gtk_list_realize (GtkWidget *widget)

{

  GdkWindowAttr attributes;

  gint attributes_mask;

  gtk_widget_set_realized (widget, TRUE);

  attributes.window_type = GDK_WINDOW_CHILD;

  attributes.x = widget->allocation.x;

  attributes.y = widget->allocation.y;

  attributes.width = widget->allocation.width;

  attributes.height = widget->allocation.height;

  attributes.wclass = GDK_INPUT_OUTPUT;

  attributes.visual = gtk_widget_get_visual (widget);

  attributes.colormap = gtk_widget_get_colormap (widget);

  attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;

  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;

  widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),

				   &attributes, attributes_mask);

  gdk_window_set_user_data (widget->window, widget);

  widget->style = gtk_style_attach (widget->style, widget->window);

  gdk_window_set_background (widget->window, 

			     &widget->style->base[GTK_STATE_NORMAL]);

}

static gboolean

list_has_grab (GtkList *list)

{

  return (GTK_WIDGET_HAS_GRAB (list) &&

	  gdk_display_pointer_is_grabbed (gtk_widget_get_display (GTK_WIDGET (list))));

}

static void

gtk_list_unmap (GtkWidget *widget)

{

  GtkList *list = GTK_LIST (widget);

  if (!gtk_widget_get_mapped (widget))

    return;

  gtk_widget_set_mapped (widget, FALSE);

  if (list_has_grab (list))

    {

      gtk_list_end_drag_selection (list);

      if (list->anchor != -1 && list->selection_mode == GTK_SELECTION_MULTIPLE)

	gtk_list_end_selection (list);

    }

  gdk_window_hide (widget->window);

}

static gint

gtk_list_motion_notify (GtkWidget      *widget,

			GdkEventMotion *event)

{

  GtkList *list = GTK_LIST (widget);

  GtkWidget *item = NULL;

  GtkAdjustment *adj;

  GtkContainer *container;

  GList *work;

  gint x;

  gint y;

  gint row = -1;

  gint focus_row = 0;

  gint length = 0;

  if (!list->drag_selection || !list->children)

    return FALSE;

  container = GTK_CONTAINER (widget);

  if (event->is_hint || event->window != widget->window)

    gdk_window_get_pointer (widget->window, &x, &y, NULL);

  else

    {

      x = event->x;

      y = event->y;

    }

  adj = gtk_object_get_data_by_id (GTK_OBJECT (list), hadjustment_key_id);

  /* horizontal autoscrolling */

  if (adj && widget->allocation.width > adj->page_size &&

      (x < adj->value || x >= adj->value + adj->page_size))

    {

      if (list->htimer == 0)

	{

	  list->htimer = gdk_threads_add_timeout

	    (SCROLL_TIME, (GSourceFunc) gtk_list_horizontal_timeout, widget);

	  if (!((x < adj->value && adj->value <= 0) ||

		(x > adj->value + adj->page_size &&

		 adj->value >= adj->upper - adj->page_size)))

	    {

	      gdouble value;

	      if (x < adj->value)

		value = adj->value + (x - adj->value) / 2 - 1;

	      else

		value = adj->value + 1 + (x - adj->value - adj->page_size) / 2;

	      gtk_adjustment_set_value (adj,

					CLAMP (value, 0.0,

					       adj->upper - adj->page_size));

	    }

	}

      else

	return FALSE;

    }

  /* vertical autoscrolling */

  for (work = list->children; work; length++, work = work->next)

    {

      if (row < 0)

	{

	  item = GTK_WIDGET (work->data);

	  if (item->allocation.y > y || 

	      (item->allocation.y <= y &&

	       item->allocation.y + item->allocation.height > y))

	    row = length;

	}

      if (work->data == container->focus_child)

	focus_row = length;

    }

  if (row < 0)

    row = length - 1;

  if (list->vtimer != 0)

    return FALSE;

  if (!((y < 0 && focus_row == 0) ||

	(y > widget->allocation.height && focus_row >= length - 1)))

    list->vtimer = gdk_threads_add_timeout (SCROLL_TIME,

				  (GSourceFunc) gtk_list_vertical_timeout,

				  list);

  if (row != focus_row)

    gtk_widget_grab_focus (item);

  switch (list->selection_mode)

    {

    case GTK_SELECTION_BROWSE:

      gtk_list_select_child (list, item);

      break;

    case GTK_SELECTION_MULTIPLE:

      gtk_list_update_extended_selection (list, row);

      break;

    default:

      break;

    }

  return FALSE;

}

static gint

gtk_list_button_press (GtkWidget      *widget,

		       GdkEventButton *event)

{

  GtkList *list = GTK_LIST (widget);

  GtkWidget *item;

  if (event->button != 1)

    return FALSE;

  item = gtk_get_event_widget ((GdkEvent*) event);

  while (item && !GTK_IS_LIST_ITEM (item))

    item = item->parent;

  if (item && (item->parent == widget))

    {

      gint last_focus_row;

      gint focus_row;

      if (event->type == GDK_BUTTON_PRESS)

	{

	  gtk_grab_add (widget);

	  list->drag_selection = TRUE;

	}

      else if (list_has_grab (list))

	gtk_list_end_drag_selection (list);

      if (!gtk_widget_has_focus(item))

	gtk_widget_grab_focus (item);

      if (list->add_mode)

	{

	  list->add_mode = FALSE;

	  gtk_widget_queue_draw (item);

	}

      switch (list->selection_mode)

	{

	case GTK_SELECTION_SINGLE:

	  if (event->type != GDK_BUTTON_PRESS)

	    gtk_list_select_child (list, item);

	  else

	    list->undo_focus_child = item;

	  break;

	case GTK_SELECTION_BROWSE:

	  break;

	case GTK_SELECTION_MULTIPLE:

	  focus_row = g_list_index (list->children, item);

	  if (list->last_focus_child)

	    last_focus_row = g_list_index (list->children,

					   list->last_focus_child);

	  else

	    {

	      last_focus_row = focus_row;

	      list->last_focus_child = item;

	    }

	  if (event->type != GDK_BUTTON_PRESS)

	    {

	      if (list->anchor >= 0)

		{

		  gtk_list_update_extended_selection (list, focus_row);

		  gtk_list_end_selection (list);

		}

	      gtk_list_select_child (list, item);

	      break;

	    }

	  if (event->state & GDK_CONTROL_MASK)

	    {

	      if (event->state & GDK_SHIFT_MASK)

		{

		  if (list->anchor < 0)

		    {

		      g_list_free (list->undo_selection);

		      g_list_free (list->undo_unselection);

		      list->undo_selection = NULL;

		      list->undo_unselection = NULL;

		      list->anchor = last_focus_row;

		      list->drag_pos = last_focus_row;

		      list->undo_focus_child = list->last_focus_child;

		    }

		  gtk_list_update_extended_selection (list, focus_row);

		}

	      else

		{

		  if (list->anchor < 0)

		    gtk_list_set_anchor (list, TRUE,

					 focus_row, list->last_focus_child);

		  else

		    gtk_list_update_extended_selection (list, focus_row);

		}

	      break;

	    }

	  if (event->state & GDK_SHIFT_MASK)

	    {

	      gtk_list_set_anchor (list, FALSE,

				   last_focus_row, list->last_focus_child);

	      gtk_list_update_extended_selection (list, focus_row);

	      break;

	    }

	  if (list->anchor < 0)

	    gtk_list_set_anchor (list, FALSE, focus_row,

				 list->last_focus_child);

	  else

	    gtk_list_update_extended_selection (list, focus_row);

	  break;

	default:

	  break;

	}

      return TRUE;

    }

  return FALSE;

}

static gint

gtk_list_button_release (GtkWidget	*widget,

			 GdkEventButton *event)

{

  GtkList *list = GTK_LIST (widget);

  GtkWidget *item;

  /* we don't handle button 2 and 3 */

  if (event->button != 1)

    return FALSE;

  if (list->drag_selection)

    {

      gtk_list_end_drag_selection (list);

      switch (list->selection_mode)

	{

	case GTK_SELECTION_MULTIPLE:

 	  if (!(event->state & GDK_SHIFT_MASK))

	    gtk_list_end_selection (list);

	  break;

	case GTK_SELECTION_SINGLE:

	  item = gtk_get_event_widget ((GdkEvent*) event);

	  while (item && !GTK_IS_LIST_ITEM (item))

	    item = item->parent;

	  if (item && item->parent == widget)

	    {

	      if (list->undo_focus_child == item)

		gtk_list_toggle_row (list, item);

	    }

	  list->undo_focus_child = NULL;

	  break;

	default:

	  break;

	}

      return TRUE;

    }

  return FALSE;

}

static void 

gtk_list_style_set	(GtkWidget      *widget,

			 GtkStyle       *previous_style)

{

  GtkStyle *style;

  if (previous_style && gtk_widget_get_realized (widget))

    {

      style = gtk_widget_get_style (widget);

      gdk_window_set_background (gtk_widget_get_window (widget),

                                 &style->base[gtk_widget_get_state (widget)]);

    }

}

/* GtkContainer Methods :

 * gtk_list_add

 * gtk_list_remove

 * gtk_list_forall

 * gtk_list_child_type

 * gtk_list_set_focus_child

 * gtk_list_focus

 */

static void

gtk_list_add (GtkContainer *container,

	      GtkWidget	   *widget)

{

  GList *item_list;

  g_return_if_fail (GTK_IS_LIST_ITEM (widget));

  item_list = g_list_alloc ();

  item_list->data = widget;

  gtk_list_append_items (GTK_LIST (container), item_list);

}

static void

gtk_list_remove (GtkContainer *container,

		 GtkWidget    *widget)

{

  GList *item_list;

  g_return_if_fail (container == GTK_CONTAINER (widget->parent));

  item_list = g_list_alloc ();

  item_list->data = widget;

  gtk_list_remove_items (GTK_LIST (container), item_list);

  g_list_free (item_list);

}

static void

gtk_list_forall (GtkContainer  *container,

		 gboolean       include_internals,

		 GtkCallback	callback,

		 gpointer	callback_data)

{

  GtkList *list = GTK_LIST (container);

  GtkWidget *child;

  GList *children;

  children = list->children;

  while (children)

    {

      child = children->data;

      children = children->next;

      (* callback) (child, callback_data);

    }

}

static GtkType

gtk_list_child_type (GtkContainer *container)

{

  return GTK_TYPE_LIST_ITEM;

}

static void

gtk_list_set_focus_child (GtkContainer *container,

			  GtkWidget    *child)

{

  GtkList *list;

  g_return_if_fail (GTK_IS_LIST (container));

  if (child)

    g_return_if_fail (GTK_IS_WIDGET (child));

  list = GTK_LIST (container);

  if (child != container->focus_child)

    {

      if (container->focus_child)

	{

	  list->last_focus_child = container->focus_child;