gtk2/gtk/gtklist.c

/* 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 Library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library 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.
 */
#include "gtklist.h"
#include "gtklistitem.h"
#include "gtkmain.h"
#include "gtksignal.h"
#include "gtklabel.h"

enum {
  SELECTION_CHANGED,
  SELECT_CHILD,
  UNSELECT_CHILD,
  LAST_SIGNAL
};

#define SCROLL_TIME  100

static void gtk_list_class_init	     (GtkListClass   *klass);
static void gtk_list_init	     (GtkList	     *list);
static void gtk_list_shutdown	     (GtkObject	     *object);
static void gtk_list_destroy	     (GtkObject	     *object);
static void gtk_list_map	     (GtkWidget	     *widget);
static void gtk_list_unmap	     (GtkWidget	     *widget);
static void gtk_list_realize	     (GtkWidget	     *widget);
static void gtk_list_draw	     (GtkWidget	     *widget,
				      GdkRectangle   *area);
static gint gtk_list_expose	     (GtkWidget	     *widget,
				      GdkEventExpose *event);
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 void gtk_list_size_request    (GtkWidget	     *widget,
				      GtkRequisition *requisition);
static void gtk_list_size_allocate   (GtkWidget	     *widget,
				      GtkAllocation  *allocation);
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 void gtk_real_list_select_child	 (GtkList	*list,
					  GtkWidget	*child);
static void gtk_real_list_unselect_child (GtkList	*list,
					  GtkWidget	*child);


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_move_focus_child    (GtkList       *list,
					  GtkScrollType  scroll_type,
					  gfloat         position);
static void gtk_list_update_extended_selection (GtkList *list,
					        gint     row);
static void gtk_list_focus_lost          (GtkWidget     *item,
					  GdkEventKey   *event,
					  GtkList       *list);
static void gtk_list_set_focus_child     (GtkContainer  *container,
					  GtkWidget     *widget);
static gint gtk_list_focus               (GtkContainer     *container,
					  GtkDirectionType  direction);


static GtkType gtk_list_child_type  (GtkContainer   *container);


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)
    {
      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,
      };

      list_type = gtk_type_unique (GTK_TYPE_CONTAINER, &list_info);
    }

  return list_type;
}

static void
gtk_list_class_init (GtkListClass *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);

  list_signals[SELECTION_CHANGED] =
    gtk_signal_new ("selection_changed",
		    GTK_RUN_FIRST,
		    object_class->type,
		    GTK_SIGNAL_OFFSET (GtkListClass, selection_changed),
		    gtk_marshal_NONE__NONE,
		    GTK_TYPE_NONE, 0);
  list_signals[SELECT_CHILD] =
    gtk_signal_new ("select_child",
		    GTK_RUN_FIRST,
		    object_class->type,
		    GTK_SIGNAL_OFFSET (GtkListClass, select_child),
		    gtk_marshal_NONE__POINTER,
		    GTK_TYPE_NONE, 1,
		    GTK_TYPE_WIDGET);
  list_signals[UNSELECT_CHILD] =
    gtk_signal_new ("unselect_child",
		    GTK_RUN_FIRST,
		    object_class->type,
		    GTK_SIGNAL_OFFSET (GtkListClass, unselect_child),
		    gtk_marshal_NONE__POINTER,
		    GTK_TYPE_NONE, 1,
		    GTK_TYPE_WIDGET);

  gtk_object_class_add_signals (object_class, list_signals, LAST_SIGNAL);

  object_class->shutdown = gtk_list_shutdown;
  object_class->destroy = gtk_list_destroy;

  widget_class->map = gtk_list_map;
  widget_class->unmap = gtk_list_unmap;
  widget_class->realize = gtk_list_realize;
  widget_class->draw = gtk_list_draw;
  widget_class->expose_event = gtk_list_expose;
  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;

  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;
  container_class->focus = gtk_list_focus;

  class->selection_changed = NULL;
  class->select_child = gtk_real_list_select_child;
  class->unselect_child = gtk_real_list_unselect_child;
}

static GtkType
gtk_list_child_type (GtkContainer     *container)
{
  return GTK_TYPE_LIST_ITEM;
}

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;
}

GtkWidget*
gtk_list_new (void)
{
  return GTK_WIDGET (gtk_type_new (GTK_TYPE_LIST));
}

static void
gtk_list_shutdown (GtkObject *object)
{
  gtk_list_clear_items (GTK_LIST (object), 0, -1);

  GTK_OBJECT_CLASS (parent_class)->shutdown (object);
}

static void
gtk_list_destroy (GtkObject *object)
{
  GList *node;

  GtkList *list = GTK_LIST (object);

  for (node = list->children; node; node = node->next)
    {
      GtkWidget *child;

      child = (GtkWidget *)node->data;
      gtk_widget_ref (child);
      gtk_widget_unparent (child);
      gtk_widget_destroy (child);
      gtk_widget_unref (child);
    }
  g_list_free (list->children);
  list->children = NULL;

  for (node = list->selection; node; node = node->next)
    {
      GtkWidget *child;

      child = (GtkWidget *)node->data;
      gtk_widget_unref (child);
    }
  g_list_free (list->selection);
  list->selection = NULL;

  if (GTK_OBJECT_CLASS (parent_class)->destroy)
    (*GTK_OBJECT_CLASS (parent_class)->destroy) (object);
}

void
gtk_list_end_drag_selection (GtkList *list)
{
  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));

  list->drag_selection = FALSE;
  if (GTK_WIDGET_HAS_GRAB (list))
    {
      gtk_grab_remove (GTK_WIDGET (list));
      gdk_pointer_ungrab (GDK_CURRENT_TIME);
    }
  if (list->htimer)
    {
      gtk_timeout_remove (list->htimer);
      list->htimer = 0;
    }
  if (list->vtimer)
    {
      gtk_timeout_remove (list->vtimer);
      list->vtimer = 0;
    }
}

void
gtk_list_insert_items (GtkList *list,
		       GList   *items,
		       gint	position)
{
  GtkWidget *widget;
  GList *tmp_list;
  GList *last;
  gint nchildren;

  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));

  if (!items)
    return;

  gtk_list_end_drag_selection (list);
  if (list->selection_mode == GTK_SELECTION_EXTENDED && list->anchor >= 0)
    gtk_list_end_selection (list);

  tmp_list = items;
  while (tmp_list)
    {
      widget = tmp_list->data;
      tmp_list = tmp_list->next;

      gtk_widget_set_parent (widget, GTK_WIDGET (list));
      gtk_signal_connect (GTK_OBJECT (widget), "focus_out_event",
			  GTK_SIGNAL_FUNC (gtk_list_focus_lost), list);

      if (GTK_WIDGET_VISIBLE (widget->parent))
	{
	  if (GTK_WIDGET_REALIZED (widget->parent) &&
	      !GTK_WIDGET_REALIZED (widget))
	    gtk_widget_realize (widget);

	  if (GTK_WIDGET_MAPPED (widget->parent) &&
	      !GTK_WIDGET_MAPPED (widget))
	    gtk_widget_map (widget);
	}
    }

  nchildren = g_list_length (list->children);
  if ((position < 0) || (position > nchildren))
    position = nchildren;

  if (position == nchildren)
    {
      if (list->children)
	{
	  tmp_list = g_list_last (list->children);
	  tmp_list->next = items;
	  items->prev = tmp_list;
	}
      else
	{
	  list->children = items;
	}
    }
  else
    {
      tmp_list = g_list_nth (list->children, position);
      last = g_list_last (items);

      if (tmp_list->prev)
	tmp_list->prev->next = items;
      last->next = tmp_list;
      items->prev = tmp_list->prev;
      tmp_list->prev = last;

      if (tmp_list == list->children)
	list->children = items;
    }

  if (list->children && !list->selection &&
      (list->selection_mode == GTK_SELECTION_BROWSE))
    {
      widget = list->children->data;
      gtk_list_select_child (list, widget);
    }

  if (GTK_WIDGET_VISIBLE (list))
    gtk_widget_queue_resize (GTK_WIDGET (list));
}

void
gtk_list_append_items (GtkList *list,
		       GList   *items)
{
  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));

  gtk_list_insert_items (list, items, -1);
}

void
gtk_list_prepend_items (GtkList *list,
			GList	*items)
{
  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));

  gtk_list_insert_items (list, items, 0);
}

static void
gtk_list_remove_items_internal (GtkList	 *list,
				GList	 *items,
				gboolean no_unref)
{
  GtkWidget *widget;
  GtkWidget *new_focus_child;
  GtkWidget *old_focus_child;
  GtkContainer *container;
  GList *selected_widgets;
  GList *tmp_list;
  GList *work;
  gboolean grab_focus = FALSE;
  
  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));

  if (!items)
    return;
  
  container = GTK_CONTAINER (list);

  gtk_list_end_drag_selection (list);
  if (list->selection_mode == GTK_SELECTION_EXTENDED && list->anchor >= 0)
    gtk_list_end_selection (list);

  
  tmp_list = items;
  selected_widgets = NULL;
  widget = NULL;
  old_focus_child = new_focus_child = container->focus_child;

  while (tmp_list)
    {
      widget = tmp_list->data;

      tmp_list = tmp_list->next;
      
      if (no_unref)
	gtk_widget_ref (widget);
      
      gtk_signal_disconnect_by_func
	(GTK_OBJECT (widget), GTK_SIGNAL_FUNC (gtk_list_focus_lost), list);


      if (widget == new_focus_child) 
	{
	  work = g_list_find (list->children, widget);

	  if (work)
	    {
	      if (work->next)
		new_focus_child = work->next->data;
	      else if (list->children != work && work->prev)
		new_focus_child = work->prev->data;
	      else
		new_focus_child = NULL;
	      
	      if (GTK_WIDGET_HAS_FOCUS (widget))
		grab_focus = TRUE;
	    }
	}

      list->children = g_list_remove (list->children, widget);

      if (widget->state == GTK_STATE_SELECTED)
	selected_widgets = g_list_prepend (selected_widgets, widget);
      else
	gtk_widget_unparent (widget);
    }
  
  if (selected_widgets)
    {
      tmp_list = selected_widgets;
      while (tmp_list)
	{
	  widget = tmp_list->data;
	  tmp_list = tmp_list->next;
	  
	  gtk_list_unselect_child (list, widget);

	  gtk_widget_unparent (widget);
	}
      
      gtk_signal_emit (GTK_OBJECT (list), list_signals[SELECTION_CHANGED]);
    }
  
  g_list_free (selected_widgets);
  
  if (new_focus_child && new_focus_child != old_focus_child)
    {
      if (grab_focus)
	gtk_widget_grab_focus (new_focus_child);
      else
	gtk_container_set_focus_child (container, new_focus_child);
    }
  
  if (GTK_WIDGET_VISIBLE (list))
    gtk_widget_queue_resize (GTK_WIDGET (list));
}

void
gtk_list_remove_items (GtkList	*list,
		       GList	*items)
{
  gtk_list_remove_items_internal (list, items, FALSE);
}

void
gtk_list_remove_items_no_unref (GtkList	 *list,
				GList	 *items)
{
  gtk_list_remove_items_internal (list, items, TRUE);
}

void
gtk_list_clear_items (GtkList *list,
		      gint     start,
		      gint     end)
{
  GtkWidget *widget;
  GList *start_list;
  GList *end_list;
  GList *tmp_list;
  guint nchildren;

  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));

  nchildren = g_list_length (list->children);

  if (nchildren > 0)
    {
      gboolean selection_changed;

      if ((end < 0) || (end > nchildren))
	end = nchildren;

      if (start >= end)
	return;

      start_list = g_list_nth (list->children, start);
      end_list = g_list_nth (list->children, end);

      gtk_list_end_drag_selection (list);
      if (list->selection_mode == GTK_SELECTION_EXTENDED && list->anchor >= 0)
	gtk_list_end_selection (list);

      if (start_list->prev)
	start_list->prev->next = end_list;
      if (end_list && end_list->prev)
	end_list->prev->next = NULL;
      if (end_list)
	end_list->prev = start_list->prev;
      if (start_list == list->children)
	list->children = end_list;

      selection_changed = FALSE;
      widget = NULL;
      tmp_list = start_list;

      while (tmp_list)
	{
	  widget = tmp_list->data;
	  tmp_list = tmp_list->next;

	  if (widget->state == GTK_STATE_SELECTED)
	    {
	      gtk_list_unselect_child (list, widget);
	      selection_changed = TRUE;
	    }

	  gtk_widget_unparent (widget);
	}

      g_list_free (start_list);

      if (list->children && !list->selection &&
	  (list->selection_mode == GTK_SELECTION_BROWSE))
	{
	  widget = list->children->data;
	  gtk_list_select_child (list, widget);
	}
      else if (selection_changed)
	gtk_signal_emit (GTK_OBJECT (list), list_signals[SELECTION_CHANGED]);

      gtk_widget_queue_resize (GTK_WIDGET (list));
    }
}

void
gtk_list_select_item (GtkList *list,
		      gint     item)
{
  GList *tmp_list;

  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));

  tmp_list = g_list_nth (list->children, item);
  if (tmp_list)
    gtk_list_select_child (list, GTK_WIDGET (tmp_list->data));
}

void
gtk_list_unselect_item (GtkList *list,
			gint	 item)
{
  GList *tmp_list;

  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));

  tmp_list = g_list_nth (list->children, item);
  if (tmp_list)
    gtk_list_unselect_child (list, GTK_WIDGET (tmp_list->data));
}

void
gtk_list_select_child (GtkList	 *list,
		       GtkWidget *child)
{
  gtk_signal_emit (GTK_OBJECT (list), list_signals[SELECT_CHILD], child);
}

void
gtk_list_unselect_child (GtkList   *list,
			 GtkWidget *child)
{
  gtk_signal_emit (GTK_OBJECT (list), list_signals[UNSELECT_CHILD], child);
}

gint
gtk_list_child_position (GtkList   *list,
			 GtkWidget *child)
{
  GList *children;
  gint pos;

  g_return_val_if_fail (list != NULL, -1);
  g_return_val_if_fail (GTK_IS_LIST (list), -1);
  g_return_val_if_fail (child != NULL, -1);

  pos = 0;
  children = list->children;

  while (children)
    {
      if (child == GTK_WIDGET (children->data))
	return pos;

      pos += 1;
      children = children->next;
    }

  return -1;
}

void
gtk_list_set_selection_mode (GtkList	      *list,
			     GtkSelectionMode  mode)
{
  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));

  if (list->selection_mode == mode)
    return;

  list->selection_mode = mode;

  switch (mode)
    {
    case GTK_SELECTION_SINGLE:
    case GTK_SELECTION_BROWSE:
      gtk_list_unselect_all (list);
      break;

    default:
      break;
    }
}


static void
gtk_list_map (GtkWidget *widget)
{
  GtkList *list;
  GtkWidget *child;
  GList *children;

  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_LIST (widget));

  GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
  list = GTK_LIST (widget);

  gdk_window_show (widget->window);

  children = list->children;
  while (children)
    {
      child = children->data;
      children = children->next;

      if (GTK_WIDGET_VISIBLE (child) &&
	  !GTK_WIDGET_MAPPED (child))
	gtk_widget_map (child);
    }
}

static void
gtk_list_unmap (GtkWidget *widget)
{
  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_LIST (widget));

  GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
  gdk_window_hide (widget->window);
}

static void
gtk_list_realize (GtkWidget *widget)
{
  GdkWindowAttr attributes;
  gint attributes_mask;

  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_LIST (widget));

  GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);

  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 void
gtk_list_draw (GtkWidget    *widget,
	       GdkRectangle *area)
{
  GtkList *list;
  GtkWidget *child;
  GdkRectangle child_area;
  GList *children;

  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_LIST (widget));
  g_return_if_fail (area != NULL);

  if (GTK_WIDGET_DRAWABLE (widget))
    {
      list = GTK_LIST (widget);

      children = list->children;
      while (children)
	{
	  child = children->data;
	  children = children->next;

	  if (gtk_widget_intersect (child, area, &child_area))
	    gtk_widget_draw (child, &child_area);
	}
    }
}

static gint
gtk_list_expose (GtkWidget	*widget,
		 GdkEventExpose *event)
{
  GtkList *list;
  GtkWidget *child;
  GdkEventExpose child_event;
  GList *children;

  g_return_val_if_fail (widget != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_LIST (widget), FALSE);
  g_return_val_if_fail (event != NULL, FALSE);

  if (GTK_WIDGET_DRAWABLE (widget))
    {
      list = GTK_LIST (widget);

      child_event = *event;

      children = list->children;
      while (children)
	{
	  child = children->data;
	  children = children->next;

	  if (GTK_WIDGET_NO_WINDOW (child) &&
	      gtk_widget_intersect (child, &event->area, &child_event.area))
	    gtk_widget_event (child, (GdkEvent*) &child_event);
	}
    }

  return FALSE;
}

static void
move_horizontal (GtkList       *list,
		 GtkAdjustment *adj,
		 gint           diff)
{
  gfloat upper;

  adj->value += diff;

  upper = adj->upper - adj->page_size;
  adj->value = MIN (adj->value, upper);
  adj->value = MAX (adj->value, 0.0);

  gtk_signal_emit_by_name (GTK_OBJECT (adj), "value_changed");
}

static gint
horizontal_timeout (GtkWidget *list)
{
  gint x, y;
  GdkEventMotion event;
  GdkModifierType mask;

  g_return_val_if_fail (GTK_IS_LIST (list), FALSE);

  GTK_LIST (list)->htimer = 0;
  gdk_window_get_pointer (list->window, &x, &y, &mask);

  event.is_hint = 0;
  event.x = x;
  event.y = y;
  event.state = mask;

  gtk_list_motion_notify (list, &event);

  return FALSE;
}

static gint
vertical_timeout (GtkWidget *list)
{
  gint x;
  gint y;
  GdkEventMotion event;
  GdkModifierType mask;

  g_return_val_if_fail (GTK_IS_LIST (list), FALSE);

  GTK_LIST (list)->vtimer = 0;
  gdk_window_get_pointer (list->window, &x, &y, &mask);

  event.is_hint = 0;
  event.x = x;
  event.y = y;
  event.state = mask;

  gtk_list_motion_notify (list, &event);

  return FALSE;
}

static gint
gtk_list_motion_notify (GtkWidget      *widget,
			GdkEventMotion *event)
{
  GtkList *list;
  GtkWidget *item = NULL;
  GtkAdjustment *adj;
  GtkContainer *container;
  GList *work;
  gint x;
  gint y;
  gint row = -1;
  gint focus_row = 0;
  gint length = 0;

  g_return_val_if_fail (widget != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_LIST (widget), FALSE);
  g_return_val_if_fail (event != NULL, FALSE);

  list = GTK_LIST (widget);

  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);

  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 = gtk_timeout_add
	    (SCROLL_TIME, (GtkFunction) horizontal_timeout, widget);
	  
	  if (!((x < adj->value && adj->value <= 0) ||
		(x > adj->value + adj->page_size &&
		 adj->value >= adj->upper - adj->page_size)))
	    {
	      if (x < adj->value)
		move_horizontal (list, adj, - 1 + (x - adj->value) / 2 );
	      else
		move_horizontal (list, adj,
				 1 + (x - adj->value - adj->page_size) / 2);
	    }
	}
      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 = gtk_timeout_add (SCROLL_TIME,
				    (GtkFunction) 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_EXTENDED:
      gtk_list_update_extended_selection (list, row);
      break;

    default:
      break;
    }

  return FALSE;
}

static gint
gtk_list_button_press (GtkWidget      *widget,
		       GdkEventButton *event)
{
  GtkList *list;
  GtkWidget *item;

  g_return_val_if_fail (widget != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_LIST (widget), FALSE);
  g_return_val_if_fail (event != NULL, FALSE);

  if (event->button != 1)
    return FALSE;

  list = GTK_LIST (widget);
  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)
	{
	  list->drag_selection = TRUE;
	  gdk_pointer_grab (widget->window, TRUE,
			    GDK_POINTER_MOTION_HINT_MASK |
			    GDK_BUTTON1_MOTION_MASK |
			    GDK_BUTTON_RELEASE_MASK,
			    NULL, NULL, event->time);
	  gtk_grab_add (widget);
	}
      else if (gdk_pointer_is_grabbed () && GTK_WIDGET_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:
	case GTK_SELECTION_MULTIPLE:
	  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_EXTENDED:
	  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 FALSE;
}

static gint
gtk_list_button_release (GtkWidget	*widget,
			 GdkEventButton *event)
{
  GtkList *list;
  GtkWidget *item;

  g_return_val_if_fail (widget != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_LIST (widget), FALSE);
  g_return_val_if_fail (event != NULL, FALSE);

  list = GTK_LIST (widget);

  /* 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_EXTENDED:
 	  if (!(event->state & GDK_SHIFT_MASK))
	    gtk_list_end_selection (list);
	  break;

	case GTK_SELECTION_SINGLE:
	case GTK_SELECTION_MULTIPLE:

	  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 FALSE;
}

static void
gtk_list_size_request (GtkWidget      *widget,
		       GtkRequisition *requisition)
{
  GtkList *list;
  GtkWidget *child;
  GList *children;

  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_LIST (widget));
  g_return_if_fail (requisition != NULL);

  list = GTK_LIST (widget);
  requisition->width = 0;
  requisition->height = 0;

  children = list->children;
  while (children)
    {
      child = children->data;
      children = children->next;

      if (GTK_WIDGET_VISIBLE (child))
	{
	  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;
  GtkWidget *child;
  GtkAllocation child_allocation;
  GList *children;

  g_return_if_fail (widget != NULL);
  g_return_if_fail (GTK_IS_LIST (widget));
  g_return_if_fail (allocation != NULL);

  list = GTK_LIST (widget);

  widget->allocation = *allocation;
  if (GTK_WIDGET_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, allocation->width - child_allocation.x * 2);

      children = list->children;

      while (children)
	{
	  child = children->data;
	  children = children->next;

	  if (GTK_WIDGET_VISIBLE (child))
	    {
	      child_allocation.height = child->requisition.height;

	      gtk_widget_size_allocate (child, &child_allocation);

	      child_allocation.y += child_allocation.height;
	    }
	}
    }
}

static void
gtk_list_add (GtkContainer *container,
	      GtkWidget	   *widget)
{
  GList *item_list;

  g_return_if_fail (container != NULL);
  g_return_if_fail (GTK_IS_LIST (container));
  g_return_if_fail (widget != NULL);
  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 != NULL);
  g_return_if_fail (GTK_IS_LIST (container));
  g_return_if_fail (widget != NULL);
  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;
  GtkWidget *child;
  GList *children;

  g_return_if_fail (container != NULL);
  g_return_if_fail (GTK_IS_LIST (container));
  g_return_if_fail (callback != NULL);

  list = GTK_LIST (container);
  children = list->children;

  while (children)
    {
      child = children->data;
      children = children->next;

      (* callback) (child, callback_data);
    }
}

static void
gtk_real_list_select_child (GtkList   *list,
			    GtkWidget *child)
{
  GList *selection;
  GList *tmp_list;
  GtkWidget *tmp_item;

  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));
  g_return_if_fail (child != NULL);
  g_return_if_fail (GTK_IS_LIST_ITEM (child));

  switch (list->selection_mode)
    {
    case GTK_SELECTION_SINGLE:
    case GTK_SELECTION_BROWSE:
      selection = list->selection;

      while (selection)
	{
	  tmp_item = selection->data;

	  if (tmp_item != child)
	    {
	      tmp_list = selection;
	      selection = selection->next;

	      list->selection = g_list_remove_link (list->selection, tmp_list);
	      g_list_free (tmp_list);

	      gtk_list_item_deselect (GTK_LIST_ITEM (tmp_item));
	      gtk_widget_unref (GTK_WIDGET (tmp_item));
	    }
	  else
	    selection = selection->next;
	}

      if (child->state == GTK_STATE_NORMAL)
	{
	  list->selection = g_list_prepend (list->selection, child);
	  gtk_widget_ref (child);
	  gtk_list_item_select (GTK_LIST_ITEM (child));
	}
      gtk_signal_emit (GTK_OBJECT (list), list_signals[SELECTION_CHANGED]);
      break;

    case GTK_SELECTION_EXTENDED:
      if (list->anchor >= 0)
	return;

    case GTK_SELECTION_MULTIPLE:
      if (child->state == GTK_STATE_NORMAL)
	{
	  list->selection = g_list_prepend (list->selection, child);
	  gtk_widget_ref (child);
	  gtk_list_item_select (GTK_LIST_ITEM (child));
	  gtk_signal_emit (GTK_OBJECT (list), list_signals[SELECTION_CHANGED]);
	}
      break;
    }
}

static void
gtk_real_list_unselect_child (GtkList	*list,
			      GtkWidget *child)
{
  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));
  g_return_if_fail (child != NULL);
  g_return_if_fail (GTK_IS_LIST_ITEM (child));

  if (child->state == GTK_STATE_SELECTED)
    {
      list->selection = g_list_remove (list->selection, child);
      gtk_list_item_deselect (GTK_LIST_ITEM (child));
      gtk_widget_unref (child);
      gtk_signal_emit (GTK_OBJECT (list), list_signals[SELECTION_CHANGED]);
    }
}


/***************************************************************************/

static void
gtk_list_set_anchor (GtkList   *list,
		     gboolean   add_mode,
		     gint       anchor,
		     GtkWidget *undo_focus_child)
{
  GList *work;

  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));
  
  if (list->selection_mode != GTK_SELECTION_EXTENDED || list->anchor >= 0)
    return;

  g_list_free (list->undo_selection);
  g_list_free (list->undo_unselection);
  list->undo_selection = NULL;
  list->undo_unselection = NULL;

  if ((work = g_list_nth (list->children, anchor)))
    {
      if (add_mode)
	gtk_list_fake_toggle_row (list, GTK_WIDGET (work->data));
      else
	{
	  gtk_list_fake_unselect_all (list, GTK_WIDGET (work->data));
	  list->anchor_state = GTK_STATE_SELECTED;
	}
    }

  list->anchor = anchor;
  list->drag_pos = anchor;
  list->undo_focus_child = undo_focus_child;
}

static void
gtk_list_fake_unselect_all (GtkList   *list,
			    GtkWidget *item)
{
  GList *work;

  if (item && item->state == GTK_STATE_NORMAL)
    gtk_widget_set_state (item, GTK_STATE_SELECTED);

  list->undo_selection = list->selection;
  list->selection = NULL;
  
  for (work = list->undo_selection; work; work = work->next)
    if (work->data != item)
      gtk_widget_set_state (GTK_WIDGET (work->data), GTK_STATE_NORMAL);
}

static void
gtk_list_fake_toggle_row (GtkList   *list,
			  GtkWidget *item)
{
  if (!item)
    return;
  
  if (item->state == GTK_STATE_NORMAL)
    {
      list->anchor_state = GTK_STATE_SELECTED;
      gtk_widget_set_state (item, GTK_STATE_SELECTED);
    }
  else
    {
      list->anchor_state = GTK_STATE_NORMAL;
      gtk_widget_set_state (item, GTK_STATE_NORMAL);
    }
}

void
gtk_list_scroll_horizontal (GtkList       *list,
			    GtkScrollType  scroll_type,
			    gfloat         position)
{
  GtkAdjustment *adj;

  g_return_if_fail (list != 0);
  g_return_if_fail (GTK_IS_LIST (list));

  if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list))
    return;

  if (!(adj =
	gtk_object_get_data_by_id (GTK_OBJECT (list), hadjustment_key_id)))
    return;

  switch (scroll_type)
    {
    case GTK_SCROLL_STEP_BACKWARD:
      adj->value = CLAMP (adj->value - adj->step_increment, adj->lower,
			  adj->upper - adj->page_size);
      break;
    case GTK_SCROLL_STEP_FORWARD:
      adj->value = CLAMP (adj->value + adj->step_increment, adj->lower,
			  adj->upper - adj->page_size);
      break;
    case GTK_SCROLL_PAGE_BACKWARD:
      adj->value = CLAMP (adj->value - adj->page_increment, adj->lower,
			  adj->upper - adj->page_size);
      break;
    case GTK_SCROLL_PAGE_FORWARD:
      adj->value = CLAMP (adj->value + adj->page_increment, adj->lower,
			  adj->upper - adj->page_size);
      break;
    case GTK_SCROLL_JUMP:
      adj->value = CLAMP (adj->lower + (adj->upper - adj->lower) * position,
			  adj->lower, adj->upper - adj->page_size);
      break;
    default:
      break;
    }
  gtk_adjustment_value_changed (adj);
}

void
gtk_list_scroll_vertical (GtkList       *list,
			  GtkScrollType  scroll_type,
			  gfloat         position)
{
  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));

  if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list))
    return;

  if (list->selection_mode == GTK_SELECTION_EXTENDED)
    {
      GtkContainer *container;

      if (list->anchor >= 0)
	return;

      container = GTK_CONTAINER (list);
      list->undo_focus_child = container->focus_child;
      gtk_list_move_focus_child (list, scroll_type, position);
      if (container->focus_child != list->undo_focus_child && !list->add_mode)
	{
	  gtk_list_unselect_all (list);
	  gtk_list_select_child (list, container->focus_child);
	}
    }
  else
    gtk_list_move_focus_child (list, scroll_type, position);
}

static void
gtk_list_move_focus_child (GtkList       *list,
			   GtkScrollType  scroll_type,
			   gfloat         position)
{
  GtkContainer *container;
  GList *work;
  GtkWidget *item;
  GtkAdjustment *adj;
  gint new_value;

  g_return_if_fail (list != 0);
  g_return_if_fail (GTK_IS_LIST (list));

  container = GTK_CONTAINER (list);

  if (container->focus_child)
    work = g_list_find (list->children, container->focus_child);
  else
    work = list->children;

  if (!work)
    return;

  switch (scroll_type)
    {
    case GTK_SCROLL_STEP_BACKWARD:
      work = work->prev;
      if (work)
	gtk_widget_grab_focus (GTK_WIDGET (work->data));
      break;

    case GTK_SCROLL_STEP_FORWARD:
      work = work->next;
      if (work)
	gtk_widget_grab_focus (GTK_WIDGET (work->data));
      break;

    case GTK_SCROLL_PAGE_BACKWARD:
      if (!work->prev)
	return;

      item = work->data;
      adj = gtk_object_get_data_by_id (GTK_OBJECT (list), vadjustment_key_id);

      if (adj)
	{
	  gboolean correct = FALSE;

	  new_value = adj->value;

	  if (item->allocation.y <= adj->value)
	    {
	      new_value = MAX (item->allocation.y + item->allocation.height
			       - adj->page_size, adj->lower);
	      correct = TRUE;
	    }

	  if (item->allocation.y > new_value)
	    for (; work; work = work->prev)
	      {
		item = GTK_WIDGET (work->data);
		if (item->allocation.y <= new_value &&
		    item->allocation.y + item->allocation.height > new_value)
		  break;
	      }
	  else
	    for (; work; work = work->next)
	      {
		item = GTK_WIDGET (work->data);
		if (item->allocation.y <= new_value &&
		    item->allocation.y + item->allocation.height > new_value)
		  break;
	      }

	  if (correct && work && work->next && item->allocation.y < new_value)
	    item = work->next->data;
	}
      else
	item = list->children->data;
	  
      gtk_widget_grab_focus (item);
      break;
	  
    case GTK_SCROLL_PAGE_FORWARD:
      if (!work->next)
	return;

      item = work->data;
      adj = gtk_object_get_data_by_id (GTK_OBJECT (list), vadjustment_key_id);

      if (adj)
	{
	  gboolean correct = FALSE;

	  new_value = adj->value;

	  if (item->allocation.y + item->allocation.height >=
	      adj->value + adj->page_size)
	    {
	      new_value = item->allocation.y;
	      correct = TRUE;
	    }

	  new_value = MIN (new_value + adj->page_size, adj->upper);

	  if (item->allocation.y > new_value)
	    for (; work; work = work->prev)
	      {
		item = GTK_WIDGET (work->data);
		if (item->allocation.y <= new_value &&
		    item->allocation.y + item->allocation.height > new_value)
		  break;
	      }
	  else
	    for (; work; work = work->next)
	      {
		item = GTK_WIDGET (work->data);
		if (item->allocation.y <= new_value &&
		    item->allocation.y + item->allocation.height > new_value)
		  break;
	      }

	  if (correct && work && work->prev &&
	      item->allocation.y + item->allocation.height - 1 > new_value)
	    item = work->prev->data;
	}
      else
	item = g_list_last (work)->data;
	  
      gtk_widget_grab_focus (item);
      break;

    case GTK_SCROLL_JUMP:
      new_value = GTK_WIDGET(list)->allocation.height * CLAMP (position, 0, 1);

      for (item = NULL, work = list->children; work; work =work->next)
	{
	  item = GTK_WIDGET (work->data);
	  if (item->allocation.y <= new_value &&
	      item->allocation.y + item->allocation.height > new_value)
	    break;
	}

      gtk_widget_grab_focus (item);
      break;

    default:
      break;
    }
}

void
gtk_list_select_all (GtkList *list)
{
  GtkContainer *container;
  GList *work;
 
  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));

  if (!list->children)
    return;
  
  if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list))
    gtk_list_end_drag_selection (list);

  if (list->selection_mode == GTK_SELECTION_EXTENDED && list->anchor >= 0)
    gtk_list_end_selection (list);

  container = GTK_CONTAINER (list);

  switch (list->selection_mode)
    {
    case GTK_SELECTION_BROWSE:
      if (container->focus_child)
	{
	  gtk_list_select_child (list, container->focus_child);
	  return;
	}
      break;

    case GTK_SELECTION_EXTENDED:
      g_list_free (list->undo_selection);
      g_list_free (list->undo_unselection);
      list->undo_selection = NULL;
      list->undo_unselection = NULL;

      if (list->children &&
	  GTK_WIDGET_STATE (list->children->data) != GTK_STATE_SELECTED)
	gtk_list_fake_toggle_row (list, GTK_WIDGET (list->children->data));

      list->anchor_state =  GTK_STATE_SELECTED;
      list->anchor = 0;
      list->drag_pos = 0;
      list->undo_focus_child = container->focus_child;
      gtk_list_update_extended_selection (list, g_list_length(list->children));
      gtk_list_end_selection (list);
      return;

    case GTK_SELECTION_MULTIPLE:
      for (work = list->children; work; work = work->next)
	{
	  if (GTK_WIDGET_STATE (work->data) == GTK_STATE_NORMAL)
	    gtk_list_select_child (list, GTK_WIDGET (work->data));
	}
      return;

    default:
      break;
    }
}

void
gtk_list_unselect_all (GtkList *list)
{
  GtkContainer *container;
  GtkWidget *item;
  GList *work;
 
  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));

  if (!list->children)
    return;
  
  if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list))
    gtk_list_end_drag_selection (list);

  if (list->selection_mode == GTK_SELECTION_EXTENDED && list->anchor >= 0)
    gtk_list_end_selection (list);

  container = GTK_CONTAINER (list);

  switch (list->selection_mode)
    {
    case GTK_SELECTION_BROWSE:
      if (container->focus_child)
	{
	  gtk_list_select_child (list, container->focus_child);
	  return;
	}
      break;

    case GTK_SELECTION_EXTENDED:
      g_list_free (list->undo_selection);
      g_list_free (list->undo_unselection);
      list->undo_selection = NULL;
      list->undo_unselection = NULL;

      list->anchor = -1;
      list->drag_pos = -1;
      list->undo_focus_child = container->focus_child;
      break;

    default:
      break;
    }

  work = list->selection;

  while (work)
    {
      item = work->data;
      work = work->next;
      gtk_list_unselect_child (list, item);
    }
}

void
gtk_list_extend_selection (GtkList       *list,
			   GtkScrollType  scroll_type,
			   gfloat         position,
			   gboolean       auto_start_selection)
{
  GtkContainer *container;

  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));

  if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list)) ||
      list->selection_mode != GTK_SELECTION_EXTENDED)
    return;

  container = GTK_CONTAINER (list);

  if (auto_start_selection)
    {
      gint focus_row;
      focus_row = g_list_index (list->children, container->focus_child);
      gtk_list_set_anchor (list, list->add_mode, focus_row,
			   container->focus_child);
    }
  else if (list->anchor < 0)
    return;

  gtk_list_move_focus_child (list, scroll_type, position);
  gtk_list_update_extended_selection 
    (list, g_list_index (list->children, container->focus_child));
}

static void
gtk_list_update_extended_selection (GtkList *list,
				    gint     row)
{
  gint i;
  GList *work;
  gint s1 = -1;
  gint s2 = -1;
  gint e1 = -1;
  gint e2 = -1;
  gint length;

  if (row < 0)
    row = 0;

  length = g_list_length (list->children);
  if (row >= length)
    row = length - 1;

  if (list->selection_mode != GTK_SELECTION_EXTENDED || !list->anchor < 0)
    return;

  /* extending downwards */
  if (row > list->drag_pos && list->anchor <= list->drag_pos)
    {
      s2 = list->drag_pos + 1;
      e2 = row;
    }
  /* extending upwards */
  else if (row < list->drag_pos && list->anchor >= list->drag_pos)
    {
      s2 = row;
      e2 = list->drag_pos - 1;
    }
  else if (row < list->drag_pos && list->anchor < list->drag_pos)
    {
      e1 = list->drag_pos;
      /* row and drag_pos on different sides of anchor :
	 take back the selection between anchor and drag_pos,
         select between anchor and row */
      if (row < list->anchor)
	{
	  s1 = list->anchor + 1;
	  s2 = row;
	  e2 = list->anchor - 1;
	}
      /* take back the selection between anchor and drag_pos */
      else
	s1 = row + 1;
    }
  else if (row > list->drag_pos && list->anchor > list->drag_pos)
    {
      s1 = list->drag_pos;
      /* row and drag_pos on different sides of anchor :
	 take back the selection between anchor and drag_pos,
         select between anchor and row */
      if (row > list->anchor)
	{
	  e1 = list->anchor - 1;
	  s2 = list->anchor + 1;
	  e2 = row;
	}
      /* take back the selection between anchor and drag_pos */
      else
	e1 = row - 1;
    }

  list->drag_pos = row;

  /* restore the elements between s1 and e1 */
  if (s1 >= 0)
    {
      for (i = s1, work = g_list_nth (list->children, i); i <= e1;
	   i++, work = work->next)
	{
	  if (g_list_find (list->selection, work->data))
            gtk_widget_set_state (GTK_WIDGET (work->data), GTK_STATE_SELECTED);
          else
            gtk_widget_set_state (GTK_WIDGET (work->data), GTK_STATE_NORMAL);
	}
    }

  /* extend the selection between s2 and e2 */
  if (s2 >= 0)
    {
      for (i = s2, work = g_list_nth (list->children, i); i <= e2;
	   i++, work = work->next)
	if (GTK_WIDGET (work->data)->state != list->anchor_state)
	  gtk_widget_set_state (GTK_WIDGET (work->data), list->anchor_state);
    }
}

void
gtk_list_end_selection (GtkList *list)
{
  gint i;
  gint e;
  GList *work;
  GtkWidget *item;
  gint item_index;

  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));

  if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list)) ||
      list->anchor < 0)
    return;

  i = MIN (list->anchor, list->drag_pos);
  e = MAX (list->anchor, list->drag_pos);
  
  list->anchor = -1;
  list->drag_pos = -1;

  if (list->undo_selection)
    {
      work = list->selection;
      list->selection = list->undo_selection;
      list->undo_selection = work;
      work = list->selection;
      while (work)
	{
	  item = work->data;
	  work = work->next;
	  item_index = g_list_index (list->children, item);
	  if (item_index < i || item_index > e)
	    {
	      gtk_widget_set_state (item, GTK_STATE_SELECTED);
	      gtk_list_unselect_child (list, item);
	      list->undo_selection = g_list_prepend (list->undo_selection,
						     item);
	    }
	}
    }    

  for (work = g_list_nth (list->children, i); i <= e; i++, work = work->next)
    {
      item = work->data;
      if (g_list_find (list->selection, item))
	  {
	    if (item->state == GTK_STATE_NORMAL)
	      {
		gtk_widget_set_state (item, GTK_STATE_SELECTED);
		gtk_list_unselect_child (list, item);
		list->undo_selection = g_list_prepend (list->undo_selection,
						       item);
	      }
	  }
      else if (item->state == GTK_STATE_SELECTED)
	{
	  gtk_widget_set_state (item, GTK_STATE_NORMAL);
	  list->undo_unselection = g_list_prepend (list->undo_unselection,
						   item);
	}
    }

  for (work = list->undo_unselection; work; work = work->next)
    gtk_list_select_child (list, GTK_WIDGET (work->data));

}

void
gtk_list_start_selection (GtkList *list)
{
  GtkContainer *container;
  gint focus_row;

  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));

  if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list))
    return;

  container = GTK_CONTAINER (list);

  if ((focus_row = g_list_index (list->selection, container->focus_child))
      >= 0)
    gtk_list_set_anchor (list, list->add_mode,
			 focus_row, container->focus_child);
}

void
gtk_list_toggle_row (GtkList   *list,
		     GtkWidget *item)
{
  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));
  g_return_if_fail (item != NULL);
  g_return_if_fail (GTK_IS_LIST_ITEM (item));

  switch (list->selection_mode)
    {
    case GTK_SELECTION_EXTENDED:
    case GTK_SELECTION_MULTIPLE:
    case GTK_SELECTION_SINGLE:

      if (item->state == GTK_STATE_SELECTED)
	{
	  gtk_list_unselect_child (list, item);
	  return;
	}

    case GTK_SELECTION_BROWSE:
      gtk_list_select_child (list, item);
      break;
    }
}

void
gtk_list_toggle_focus_row (GtkList *list)
{
  GtkContainer *container;
  gint focus_row;

  g_return_if_fail (list != 0);
  g_return_if_fail (GTK_IS_LIST (list));

  container = GTK_CONTAINER (list);

  if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list)) ||
      !container->focus_child)
    return;

  switch (list->selection_mode)
    {
    case  GTK_SELECTION_SINGLE:
    case  GTK_SELECTION_MULTIPLE:
      
      gtk_list_toggle_row (list, container->focus_child);
      break;
      
    case GTK_SELECTION_EXTENDED:

      if ((focus_row = g_list_index (list->children, container->focus_child))
	  < 0)
	return;

      g_list_free (list->undo_selection);
      g_list_free (list->undo_unselection);
      list->undo_selection = NULL;
      list->undo_unselection = NULL;

      list->anchor = focus_row;
      list->drag_pos = focus_row;
      list->undo_focus_child = container->focus_child;

      if (list->add_mode)
	gtk_list_fake_toggle_row (list, container->focus_child);
      else
	gtk_list_fake_unselect_all (list, container->focus_child);
      
      gtk_list_end_selection (list);
      break;
      
    default:
      break;
    }
}

void
gtk_list_toggle_add_mode (GtkList *list)
{
  GtkContainer *container;

  g_return_if_fail (list != 0);
  g_return_if_fail (GTK_IS_LIST (list));
  
  if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list)) ||
      list->selection_mode != GTK_SELECTION_EXTENDED)
    return;
  
  container = GTK_CONTAINER (list);

  if (list->add_mode)
    {
      list->add_mode = FALSE;
      list->anchor_state = GTK_STATE_SELECTED;
    }
  else
    list->add_mode = TRUE;
  
  if (container->focus_child)
    gtk_widget_queue_draw (container->focus_child);
}

void
gtk_list_undo_selection (GtkList *list)
{
  GList *work;

  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));

  if (list->selection_mode != GTK_SELECTION_EXTENDED ||
      (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list)))
    return;
  
  if (list->anchor >= 0)
    gtk_list_end_selection (list);

  if (!(list->undo_selection || list->undo_unselection))
    {
      gtk_list_unselect_all (list);
      return;
    }

  for (work = list->undo_selection; work; work = work->next)
    gtk_list_select_child (list, GTK_WIDGET (work->data));

  for (work = list->undo_unselection; work; work = work->next)
    gtk_list_unselect_child (list, GTK_WIDGET (work->data));

  if (list->undo_focus_child)
    {
      GtkContainer *container;

      container = GTK_CONTAINER (list);

      if (container->focus_child &&
	  GTK_WIDGET_HAS_FOCUS (container->focus_child))
	gtk_widget_grab_focus (list->undo_focus_child);
      else
	gtk_container_set_focus_child (container, list->undo_focus_child);
    }

  list->undo_focus_child = NULL;
 
  g_list_free (list->undo_selection);
  g_list_free (list->undo_unselection);
  list->undo_selection = NULL;
  list->undo_unselection = NULL;
}

static void
gtk_list_focus_lost (GtkWidget   *item,
		     GdkEventKey *event,
		     GtkList     *list)
{
  g_return_if_fail (list != NULL);
  g_return_if_fail (GTK_IS_LIST (list));
  g_return_if_fail (item != NULL);
  g_return_if_fail (GTK_IS_LIST_ITEM (item));

  if (list->selection_mode == GTK_SELECTION_EXTENDED && list->anchor >= 0 &&
      item == GTK_CONTAINER (list)->focus_child)
    gtk_list_end_selection (list);
}

static void
gtk_list_set_focus_child (GtkContainer *container,
			  GtkWidget    *child)
{
  GtkList *list;

  g_return_if_fail (container != NULL);
  g_return_if_fail (GTK_IS_LIST (container));

  if (child)
    g_return_if_fail (GTK_IS_WIDGET (child));

  list = GTK_LIST (container);
  list->last_focus_child = container->focus_child;

  if (child != container->focus_child)
    {
      if (container->focus_child)
        gtk_widget_unref (container->focus_child);
      container->focus_child = child;
      if (container->focus_child)
        gtk_widget_ref (container->focus_child);
    }

  /* check for v adjustment */
  if (container->focus_child)
    {
      GtkAdjustment *adjustment;

      adjustment = gtk_object_get_data_by_id (GTK_OBJECT (container),
					      vadjustment_key_id);
      if (adjustment)
        gtk_adjustment_clamp_page (adjustment,
                                   container->focus_child->allocation.y,
                                   (container->focus_child->allocation.y +
                                    container->focus_child->allocation.height));
    }

  switch (list->selection_mode)
    {
    case GTK_SELECTION_BROWSE:
      if (child)
	gtk_list_select_child (list, child);
      break;
    default:
      break;
    }
}


static gint
gtk_list_focus (GtkContainer     *container,
		GtkDirectionType  direction)
{
  gint return_val = FALSE;

  g_return_val_if_fail (container != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_LIST (container), FALSE);

  if (!GTK_WIDGET_SENSITIVE (container))
    return_val = FALSE;
  else if (container->focus_child == NULL ||
      !GTK_WIDGET_HAS_FOCUS (container->focus_child))
    {
      if (*GTK_CONTAINER_CLASS (parent_class)->focus)
	return_val = GTK_CONTAINER_CLASS (parent_class)->focus
	  (container, direction);
    }
  
  if (!return_val)
    {
      GtkList *list;

      list =  GTK_LIST (container);
      if (list->selection_mode == GTK_SELECTION_EXTENDED && list->anchor >= 0)
	gtk_list_end_selection (list);
    }

  return return_val;
}