1 /* GTK - The GIMP Toolkit
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser 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.
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 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser 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.
21 * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
22 * file for a list of people on the GTK+ Team. See the ChangeLog
23 * files for a list of changes. These files are distributed with
24 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
28 #include <string.h> /* memset */
31 #include "gtklistitem.h"
33 #include "gtksignal.h"
35 #include "gtkmarshalers.h"
52 #define SCROLL_TIME 100
54 /*** GtkList Methods ***/
55 static void gtk_list_class_init (GtkListClass *klass);
56 static void gtk_list_init (GtkList *list);
57 static void gtk_list_set_arg (GtkObject *object,
60 static void gtk_list_get_arg (GtkObject *object,
63 /*** GtkObject Methods ***/
64 static void gtk_list_dispose (GObject *object);
66 /*** GtkWidget Methods ***/
67 static void gtk_list_size_request (GtkWidget *widget,
68 GtkRequisition *requisition);
69 static void gtk_list_size_allocate (GtkWidget *widget,
70 GtkAllocation *allocation);
71 static void gtk_list_realize (GtkWidget *widget);
72 static void gtk_list_unmap (GtkWidget *widget);
73 static void gtk_list_style_set (GtkWidget *widget,
74 GtkStyle *previous_style);
75 static gint gtk_list_motion_notify (GtkWidget *widget,
76 GdkEventMotion *event);
77 static gint gtk_list_button_press (GtkWidget *widget,
78 GdkEventButton *event);
79 static gint gtk_list_button_release (GtkWidget *widget,
80 GdkEventButton *event);
82 static gboolean gtk_list_focus (GtkWidget *widget,
83 GtkDirectionType direction);
85 /*** GtkContainer Methods ***/
86 static void gtk_list_add (GtkContainer *container,
88 static void gtk_list_remove (GtkContainer *container,
90 static void gtk_list_forall (GtkContainer *container,
91 gboolean include_internals,
93 gpointer callback_data);
94 static GtkType gtk_list_child_type (GtkContainer *container);
95 static void gtk_list_set_focus_child (GtkContainer *container,
98 /*** GtkList Private Functions ***/
99 static void gtk_list_move_focus_child (GtkList *list,
100 GtkScrollType scroll_type,
102 static gint gtk_list_horizontal_timeout (GtkWidget *list);
103 static gint gtk_list_vertical_timeout (GtkWidget *list);
104 static void gtk_list_remove_items_internal (GtkList *list,
108 /*** GtkList Selection Methods ***/
109 static void gtk_real_list_select_child (GtkList *list,
111 static void gtk_real_list_unselect_child (GtkList *list,
114 /*** GtkList Selection Functions ***/
115 static void gtk_list_set_anchor (GtkList *list,
118 GtkWidget *undo_focus_child);
119 static void gtk_list_fake_unselect_all (GtkList *list,
121 static void gtk_list_fake_toggle_row (GtkList *list,
123 static void gtk_list_update_extended_selection (GtkList *list,
125 static void gtk_list_reset_extended_selection (GtkList *list);
127 /*** GtkListItem Signal Functions ***/
128 static void gtk_list_signal_drag_begin (GtkWidget *widget,
129 GdkDragContext *context,
131 static void gtk_list_signal_toggle_focus_row (GtkListItem *list_item,
133 static void gtk_list_signal_select_all (GtkListItem *list_item,
135 static void gtk_list_signal_unselect_all (GtkListItem *list_item,
137 static void gtk_list_signal_undo_selection (GtkListItem *list_item,
139 static void gtk_list_signal_start_selection (GtkListItem *list_item,
141 static void gtk_list_signal_end_selection (GtkListItem *list_item,
143 static void gtk_list_signal_extend_selection (GtkListItem *list_item,
144 GtkScrollType scroll_type,
146 gboolean auto_start_selection,
148 static void gtk_list_signal_scroll_horizontal (GtkListItem *list_item,
149 GtkScrollType scroll_type,
152 static void gtk_list_signal_scroll_vertical (GtkListItem *list_item,
153 GtkScrollType scroll_type,
156 static void gtk_list_signal_toggle_add_mode (GtkListItem *list_item,
158 static void gtk_list_signal_item_select (GtkListItem *list_item,
160 static void gtk_list_signal_item_deselect (GtkListItem *list_item,
162 static void gtk_list_signal_item_toggle (GtkListItem *list_item,
166 static void gtk_list_drag_begin (GtkWidget *widget,
167 GdkDragContext *context);
170 static GtkContainerClass *parent_class = NULL;
171 static guint list_signals[LAST_SIGNAL] = { 0 };
173 static const gchar vadjustment_key[] = "gtk-vadjustment";
174 static guint vadjustment_key_id = 0;
175 static const gchar hadjustment_key[] = "gtk-hadjustment";
176 static guint hadjustment_key_id = 0;
179 gtk_list_get_type (void)
181 static GtkType list_type = 0;
185 static const GtkTypeInfo list_info =
189 sizeof (GtkListClass),
190 (GtkClassInitFunc) gtk_list_class_init,
191 (GtkObjectInitFunc) gtk_list_init,
192 /* reserved_1 */ NULL,
193 /* reserved_2 */ NULL,
194 (GtkClassInitFunc) NULL,
198 list_type = gtk_type_unique (GTK_TYPE_CONTAINER, &list_info);
205 gtk_list_class_init (GtkListClass *class)
207 GObjectClass *gobject_class = G_OBJECT_CLASS (class);
208 GtkObjectClass *object_class;
209 GtkWidgetClass *widget_class;
210 GtkContainerClass *container_class;
212 object_class = (GtkObjectClass*) class;
213 widget_class = (GtkWidgetClass*) class;
214 container_class = (GtkContainerClass*) class;
216 parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
218 vadjustment_key_id = g_quark_from_static_string (vadjustment_key);
219 hadjustment_key_id = g_quark_from_static_string (hadjustment_key);
221 gobject_class->dispose = gtk_list_dispose;
224 object_class->set_arg = gtk_list_set_arg;
225 object_class->get_arg = gtk_list_get_arg;
227 widget_class->unmap = gtk_list_unmap;
228 widget_class->style_set = gtk_list_style_set;
229 widget_class->realize = gtk_list_realize;
230 widget_class->button_press_event = gtk_list_button_press;
231 widget_class->button_release_event = gtk_list_button_release;
232 widget_class->motion_notify_event = gtk_list_motion_notify;
233 widget_class->size_request = gtk_list_size_request;
234 widget_class->size_allocate = gtk_list_size_allocate;
235 widget_class->drag_begin = gtk_list_drag_begin;
236 widget_class->focus = gtk_list_focus;
238 container_class->add = gtk_list_add;
239 container_class->remove = gtk_list_remove;
240 container_class->forall = gtk_list_forall;
241 container_class->child_type = gtk_list_child_type;
242 container_class->set_focus_child = gtk_list_set_focus_child;
244 class->selection_changed = NULL;
245 class->select_child = gtk_real_list_select_child;
246 class->unselect_child = gtk_real_list_unselect_child;
248 list_signals[SELECTION_CHANGED] =
249 gtk_signal_new (I_("selection-changed"),
251 GTK_CLASS_TYPE (object_class),
252 GTK_SIGNAL_OFFSET (GtkListClass, selection_changed),
253 _gtk_marshal_VOID__VOID,
255 list_signals[SELECT_CHILD] =
256 gtk_signal_new (I_("select_child"),
258 GTK_CLASS_TYPE (object_class),
259 GTK_SIGNAL_OFFSET (GtkListClass, select_child),
260 _gtk_marshal_VOID__OBJECT,
263 list_signals[UNSELECT_CHILD] =
264 gtk_signal_new (I_("unselect_child"),
266 GTK_CLASS_TYPE (object_class),
267 GTK_SIGNAL_OFFSET (GtkListClass, unselect_child),
268 _gtk_marshal_VOID__OBJECT,
272 gtk_object_add_arg_type ("GtkList::selection-mode",
273 GTK_TYPE_SELECTION_MODE,
274 GTK_ARG_READWRITE | G_PARAM_STATIC_NAME,
279 gtk_list_init (GtkList *list)
281 list->children = NULL;
282 list->selection = NULL;
284 list->undo_selection = NULL;
285 list->undo_unselection = NULL;
287 list->last_focus_child = NULL;
288 list->undo_focus_child = NULL;
295 list->anchor_state = GTK_STATE_SELECTED;
297 list->selection_mode = GTK_SELECTION_SINGLE;
298 list->drag_selection = FALSE;
299 list->add_mode = FALSE;
303 gtk_list_set_arg (GtkObject *object,
307 GtkList *list = GTK_LIST (object);
311 case ARG_SELECTION_MODE:
312 gtk_list_set_selection_mode (list, GTK_VALUE_ENUM (*arg));
318 gtk_list_get_arg (GtkObject *object,
322 GtkList *list = GTK_LIST (object);
326 case ARG_SELECTION_MODE:
327 GTK_VALUE_ENUM (*arg) = list->selection_mode;
330 arg->type = GTK_TYPE_INVALID;
338 return GTK_WIDGET (gtk_type_new (GTK_TYPE_LIST));
342 /* Private GtkObject Methods :
347 gtk_list_dispose (GObject *object)
349 gtk_list_clear_items (GTK_LIST (object), 0, -1);
351 G_OBJECT_CLASS (parent_class)->dispose (object);
355 /* Private GtkWidget Methods :
357 * gtk_list_size_request
358 * gtk_list_size_allocate
361 * gtk_list_motion_notify
362 * gtk_list_button_press
363 * gtk_list_button_release
366 gtk_list_size_request (GtkWidget *widget,
367 GtkRequisition *requisition)
369 GtkList *list = GTK_LIST (widget);
373 requisition->width = 0;
374 requisition->height = 0;
376 children = list->children;
379 child = children->data;
380 children = children->next;
382 if (GTK_WIDGET_VISIBLE (child))
384 GtkRequisition child_requisition;
386 gtk_widget_size_request (child, &child_requisition);
388 requisition->width = MAX (requisition->width,
389 child_requisition.width);
390 requisition->height += child_requisition.height;
394 requisition->width += GTK_CONTAINER (list)->border_width * 2;
395 requisition->height += GTK_CONTAINER (list)->border_width * 2;
397 requisition->width = MAX (requisition->width, 1);
398 requisition->height = MAX (requisition->height, 1);
402 gtk_list_size_allocate (GtkWidget *widget,
403 GtkAllocation *allocation)
405 GtkList *list = GTK_LIST (widget);
407 GtkAllocation child_allocation;
410 widget->allocation = *allocation;
411 if (GTK_WIDGET_REALIZED (widget))
412 gdk_window_move_resize (widget->window,
413 allocation->x, allocation->y,
414 allocation->width, allocation->height);
418 child_allocation.x = GTK_CONTAINER (list)->border_width;
419 child_allocation.y = GTK_CONTAINER (list)->border_width;
420 child_allocation.width = MAX (1, (gint)allocation->width -
421 child_allocation.x * 2);
423 children = list->children;
427 child = children->data;
428 children = children->next;
430 if (GTK_WIDGET_VISIBLE (child))
432 GtkRequisition child_requisition;
433 gtk_widget_get_child_requisition (child, &child_requisition);
435 child_allocation.height = child_requisition.height;
437 gtk_widget_size_allocate (child, &child_allocation);
439 child_allocation.y += child_allocation.height;
446 gtk_list_realize (GtkWidget *widget)
448 GdkWindowAttr attributes;
449 gint attributes_mask;
451 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
453 attributes.window_type = GDK_WINDOW_CHILD;
454 attributes.x = widget->allocation.x;
455 attributes.y = widget->allocation.y;
456 attributes.width = widget->allocation.width;
457 attributes.height = widget->allocation.height;
458 attributes.wclass = GDK_INPUT_OUTPUT;
459 attributes.visual = gtk_widget_get_visual (widget);
460 attributes.colormap = gtk_widget_get_colormap (widget);
461 attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
463 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
465 widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
466 &attributes, attributes_mask);
467 gdk_window_set_user_data (widget->window, widget);
469 widget->style = gtk_style_attach (widget->style, widget->window);
470 gdk_window_set_background (widget->window,
471 &widget->style->base[GTK_STATE_NORMAL]);
475 list_has_grab (GtkList *list)
477 return (GTK_WIDGET_HAS_GRAB (list) &&
478 gdk_display_pointer_is_grabbed (gtk_widget_get_display (GTK_WIDGET (list))));
483 gtk_list_unmap (GtkWidget *widget)
485 GtkList *list = GTK_LIST (widget);
487 if (!GTK_WIDGET_MAPPED (widget))
490 GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
492 if (list_has_grab (list))
494 gtk_list_end_drag_selection (list);
496 if (list->anchor != -1 && list->selection_mode == GTK_SELECTION_MULTIPLE)
497 gtk_list_end_selection (list);
500 gdk_window_hide (widget->window);
504 gtk_list_motion_notify (GtkWidget *widget,
505 GdkEventMotion *event)
507 GtkList *list = GTK_LIST (widget);
508 GtkWidget *item = NULL;
510 GtkContainer *container;
518 if (!list->drag_selection || !list->children)
521 container = GTK_CONTAINER (widget);
523 if (event->is_hint || event->window != widget->window)
524 gdk_window_get_pointer (widget->window, &x, &y, NULL);
531 adj = gtk_object_get_data_by_id (GTK_OBJECT (list), hadjustment_key_id);
533 /* horizontal autoscrolling */
534 if (adj && widget->allocation.width > adj->page_size &&
535 (x < adj->value || x >= adj->value + adj->page_size))
537 if (list->htimer == 0)
539 list->htimer = gdk_threads_add_timeout
540 (SCROLL_TIME, (GSourceFunc) gtk_list_horizontal_timeout, widget);
542 if (!((x < adj->value && adj->value <= 0) ||
543 (x > adj->value + adj->page_size &&
544 adj->value >= adj->upper - adj->page_size)))
549 value = adj->value + (x - adj->value) / 2 - 1;
551 value = adj->value + 1 + (x - adj->value - adj->page_size) / 2;
553 gtk_adjustment_set_value (adj,
555 adj->upper - adj->page_size));
563 /* vertical autoscrolling */
564 for (work = list->children; work; length++, work = work->next)
568 item = GTK_WIDGET (work->data);
569 if (item->allocation.y > y ||
570 (item->allocation.y <= y &&
571 item->allocation.y + item->allocation.height > y))
575 if (work->data == container->focus_child)
582 if (list->vtimer != 0)
585 if (!((y < 0 && focus_row == 0) ||
586 (y > widget->allocation.height && focus_row >= length - 1)))
587 list->vtimer = gdk_threads_add_timeout (SCROLL_TIME,
588 (GSourceFunc) gtk_list_vertical_timeout,
591 if (row != focus_row)
592 gtk_widget_grab_focus (item);
594 switch (list->selection_mode)
596 case GTK_SELECTION_BROWSE:
597 gtk_list_select_child (list, item);
599 case GTK_SELECTION_MULTIPLE:
600 gtk_list_update_extended_selection (list, row);
610 gtk_list_button_press (GtkWidget *widget,
611 GdkEventButton *event)
613 GtkList *list = GTK_LIST (widget);
616 if (event->button != 1)
619 item = gtk_get_event_widget ((GdkEvent*) event);
621 while (item && !GTK_IS_LIST_ITEM (item))
624 if (item && (item->parent == widget))
629 if (event->type == GDK_BUTTON_PRESS)
631 gtk_grab_add (widget);
632 list->drag_selection = TRUE;
634 else if (list_has_grab (list))
635 gtk_list_end_drag_selection (list);
637 if (!GTK_WIDGET_HAS_FOCUS(item))
638 gtk_widget_grab_focus (item);
642 list->add_mode = FALSE;
643 gtk_widget_queue_draw (item);
646 switch (list->selection_mode)
648 case GTK_SELECTION_SINGLE:
649 if (event->type != GDK_BUTTON_PRESS)
650 gtk_list_select_child (list, item);
652 list->undo_focus_child = item;
655 case GTK_SELECTION_BROWSE:
658 case GTK_SELECTION_MULTIPLE:
659 focus_row = g_list_index (list->children, item);
661 if (list->last_focus_child)
662 last_focus_row = g_list_index (list->children,
663 list->last_focus_child);
666 last_focus_row = focus_row;
667 list->last_focus_child = item;
670 if (event->type != GDK_BUTTON_PRESS)
672 if (list->anchor >= 0)
674 gtk_list_update_extended_selection (list, focus_row);
675 gtk_list_end_selection (list);
677 gtk_list_select_child (list, item);
681 if (event->state & GDK_CONTROL_MASK)
683 if (event->state & GDK_SHIFT_MASK)
685 if (list->anchor < 0)
687 g_list_free (list->undo_selection);
688 g_list_free (list->undo_unselection);
689 list->undo_selection = NULL;
690 list->undo_unselection = NULL;
692 list->anchor = last_focus_row;
693 list->drag_pos = last_focus_row;
694 list->undo_focus_child = list->last_focus_child;
696 gtk_list_update_extended_selection (list, focus_row);
700 if (list->anchor < 0)
701 gtk_list_set_anchor (list, TRUE,
702 focus_row, list->last_focus_child);
704 gtk_list_update_extended_selection (list, focus_row);
709 if (event->state & GDK_SHIFT_MASK)
711 gtk_list_set_anchor (list, FALSE,
712 last_focus_row, list->last_focus_child);
713 gtk_list_update_extended_selection (list, focus_row);
717 if (list->anchor < 0)
718 gtk_list_set_anchor (list, FALSE, focus_row,
719 list->last_focus_child);
721 gtk_list_update_extended_selection (list, focus_row);
735 gtk_list_button_release (GtkWidget *widget,
736 GdkEventButton *event)
738 GtkList *list = GTK_LIST (widget);
741 /* we don't handle button 2 and 3 */
742 if (event->button != 1)
745 if (list->drag_selection)
747 gtk_list_end_drag_selection (list);
749 switch (list->selection_mode)
751 case GTK_SELECTION_MULTIPLE:
752 if (!(event->state & GDK_SHIFT_MASK))
753 gtk_list_end_selection (list);
756 case GTK_SELECTION_SINGLE:
758 item = gtk_get_event_widget ((GdkEvent*) event);
760 while (item && !GTK_IS_LIST_ITEM (item))
763 if (item && item->parent == widget)
765 if (list->undo_focus_child == item)
766 gtk_list_toggle_row (list, item);
768 list->undo_focus_child = NULL;
782 gtk_list_style_set (GtkWidget *widget,
783 GtkStyle *previous_style)
785 if (previous_style && GTK_WIDGET_REALIZED (widget))
786 gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
789 /* GtkContainer Methods :
793 * gtk_list_child_type
794 * gtk_list_set_focus_child
798 gtk_list_add (GtkContainer *container,
803 g_return_if_fail (GTK_IS_LIST_ITEM (widget));
805 item_list = g_list_alloc ();
806 item_list->data = widget;
808 gtk_list_append_items (GTK_LIST (container), item_list);
812 gtk_list_remove (GtkContainer *container,
817 g_return_if_fail (container == GTK_CONTAINER (widget->parent));
819 item_list = g_list_alloc ();
820 item_list->data = widget;
822 gtk_list_remove_items (GTK_LIST (container), item_list);
824 g_list_free (item_list);
828 gtk_list_forall (GtkContainer *container,
829 gboolean include_internals,
830 GtkCallback callback,
831 gpointer callback_data)
833 GtkList *list = GTK_LIST (container);
837 children = list->children;
841 child = children->data;
842 children = children->next;
844 (* callback) (child, callback_data);
849 gtk_list_child_type (GtkContainer *container)
851 return GTK_TYPE_LIST_ITEM;
855 gtk_list_set_focus_child (GtkContainer *container,
860 g_return_if_fail (GTK_IS_LIST (container));
863 g_return_if_fail (GTK_IS_WIDGET (child));
865 list = GTK_LIST (container);
867 if (child != container->focus_child)
869 if (container->focus_child)
871 list->last_focus_child = container->focus_child;
872 g_object_unref (container->focus_child);
874 container->focus_child = child;
875 if (container->focus_child)
876 gtk_widget_ref (container->focus_child);
879 /* check for v adjustment */
880 if (container->focus_child)
882 GtkAdjustment *adjustment;
884 adjustment = gtk_object_get_data_by_id (GTK_OBJECT (container),
887 gtk_adjustment_clamp_page (adjustment,
888 container->focus_child->allocation.y,
889 (container->focus_child->allocation.y +
890 container->focus_child->allocation.height));
891 switch (list->selection_mode)
893 case GTK_SELECTION_BROWSE:
894 gtk_list_select_child (list, child);
896 case GTK_SELECTION_MULTIPLE:
897 if (!list->last_focus_child && !list->add_mode)
899 list->undo_focus_child = list->last_focus_child;
900 gtk_list_unselect_all (list);
901 gtk_list_select_child (list, child);
911 gtk_list_focus (GtkWidget *widget,
912 GtkDirectionType direction)
914 gint return_val = FALSE;
915 GtkContainer *container;
917 container = GTK_CONTAINER (widget);
919 if (container->focus_child == NULL ||
920 !GTK_WIDGET_HAS_FOCUS (container->focus_child))
922 if (GTK_LIST (container)->last_focus_child)
923 gtk_container_set_focus_child
924 (container, GTK_LIST (container)->last_focus_child);
926 if (GTK_WIDGET_CLASS (parent_class)->focus)
927 return_val = GTK_WIDGET_CLASS (parent_class)->focus (widget,
935 list = GTK_LIST (container);
936 if (list->selection_mode == GTK_SELECTION_MULTIPLE && list->anchor >= 0)
937 gtk_list_end_selection (list);
939 if (container->focus_child)
940 list->last_focus_child = container->focus_child;
947 /* Public GtkList Methods :
949 * gtk_list_insert_items
950 * gtk_list_append_items
951 * gtk_list_prepend_items
952 * gtk_list_remove_items
953 * gtk_list_remove_items_no_unref
954 * gtk_list_clear_items
956 * gtk_list_child_position
959 gtk_list_insert_items (GtkList *list,
968 g_return_if_fail (GTK_IS_LIST (list));
973 gtk_list_end_drag_selection (list);
974 if (list->selection_mode == GTK_SELECTION_MULTIPLE && list->anchor >= 0)
975 gtk_list_end_selection (list);
980 widget = tmp_list->data;
981 tmp_list = tmp_list->next;
983 gtk_widget_set_parent (widget, GTK_WIDGET (list));
984 gtk_signal_connect (GTK_OBJECT (widget), "drag_begin",
985 GTK_SIGNAL_FUNC (gtk_list_signal_drag_begin),
987 gtk_signal_connect (GTK_OBJECT (widget), "toggle_focus_row",
988 GTK_SIGNAL_FUNC (gtk_list_signal_toggle_focus_row),
990 gtk_signal_connect (GTK_OBJECT (widget), "select_all",
991 GTK_SIGNAL_FUNC (gtk_list_signal_select_all),
993 gtk_signal_connect (GTK_OBJECT (widget), "unselect_all",
994 GTK_SIGNAL_FUNC (gtk_list_signal_unselect_all),
996 gtk_signal_connect (GTK_OBJECT (widget), "undo_selection",
997 GTK_SIGNAL_FUNC (gtk_list_signal_undo_selection),
999 gtk_signal_connect (GTK_OBJECT (widget), "start_selection",
1000 GTK_SIGNAL_FUNC (gtk_list_signal_start_selection),
1002 gtk_signal_connect (GTK_OBJECT (widget), "end_selection",
1003 GTK_SIGNAL_FUNC (gtk_list_signal_end_selection),
1005 gtk_signal_connect (GTK_OBJECT (widget), "extend_selection",
1006 GTK_SIGNAL_FUNC (gtk_list_signal_extend_selection),
1008 gtk_signal_connect (GTK_OBJECT (widget), "scroll_horizontal",
1009 GTK_SIGNAL_FUNC (gtk_list_signal_scroll_horizontal),
1011 gtk_signal_connect (GTK_OBJECT (widget), "scroll_vertical",
1012 GTK_SIGNAL_FUNC (gtk_list_signal_scroll_vertical),
1014 gtk_signal_connect (GTK_OBJECT (widget), "toggle_add_mode",
1015 GTK_SIGNAL_FUNC (gtk_list_signal_toggle_add_mode),
1017 gtk_signal_connect (GTK_OBJECT (widget), "select",
1018 GTK_SIGNAL_FUNC (gtk_list_signal_item_select),
1020 gtk_signal_connect (GTK_OBJECT (widget), "deselect",
1021 GTK_SIGNAL_FUNC (gtk_list_signal_item_deselect),
1023 gtk_signal_connect (GTK_OBJECT (widget), "toggle",
1024 GTK_SIGNAL_FUNC (gtk_list_signal_item_toggle),
1029 nchildren = g_list_length (list->children);
1030 if ((position < 0) || (position > nchildren))
1031 position = nchildren;
1033 if (position == nchildren)
1037 tmp_list = g_list_last (list->children);
1038 tmp_list->next = items;
1039 items->prev = tmp_list;
1043 list->children = items;
1048 tmp_list = g_list_nth (list->children, position);
1049 last = g_list_last (items);
1052 tmp_list->prev->next = items;
1053 last->next = tmp_list;
1054 items->prev = tmp_list->prev;
1055 tmp_list->prev = last;
1057 if (tmp_list == list->children)
1058 list->children = items;
1061 if (list->children && !list->selection &&
1062 (list->selection_mode == GTK_SELECTION_BROWSE))
1064 widget = list->children->data;
1065 gtk_list_select_child (list, widget);
1070 gtk_list_append_items (GtkList *list,
1073 g_return_if_fail (GTK_IS_LIST (list));
1075 gtk_list_insert_items (list, items, -1);
1079 gtk_list_prepend_items (GtkList *list,
1082 g_return_if_fail (GTK_IS_LIST (list));
1084 gtk_list_insert_items (list, items, 0);
1088 gtk_list_remove_items (GtkList *list,
1091 gtk_list_remove_items_internal (list, items, FALSE);
1095 gtk_list_remove_items_no_unref (GtkList *list,
1098 gtk_list_remove_items_internal (list, items, TRUE);
1102 gtk_list_clear_items (GtkList *list,
1106 GtkContainer *container;
1108 GtkWidget *new_focus_child = NULL;
1113 gboolean grab_focus = FALSE;
1115 g_return_if_fail (GTK_IS_LIST (list));
1117 nchildren = g_list_length (list->children);
1122 if ((end < 0) || (end > nchildren))
1128 container = GTK_CONTAINER (list);
1130 gtk_list_end_drag_selection (list);
1131 if (list->selection_mode == GTK_SELECTION_MULTIPLE)
1133 if (list->anchor >= 0)
1134 gtk_list_end_selection (list);
1136 gtk_list_reset_extended_selection (list);
1139 start_list = g_list_nth (list->children, start);
1140 end_list = g_list_nth (list->children, end);
1142 if (start_list->prev)
1143 start_list->prev->next = end_list;
1144 if (end_list && end_list->prev)
1145 end_list->prev->next = NULL;
1147 end_list->prev = start_list->prev;
1148 if (start_list == list->children)
1149 list->children = end_list;
1151 if (container->focus_child)
1153 if (g_list_find (start_list, container->focus_child))
1155 if (start_list->prev)
1156 new_focus_child = start_list->prev->data;
1157 else if (list->children)
1158 new_focus_child = list->children->data;
1160 if (GTK_WIDGET_HAS_FOCUS (container->focus_child))
1165 tmp_list = start_list;
1168 widget = tmp_list->data;
1169 tmp_list = tmp_list->next;
1171 gtk_widget_ref (widget);
1173 if (widget->state == GTK_STATE_SELECTED)
1174 gtk_list_unselect_child (list, widget);
1176 gtk_signal_disconnect_by_data (GTK_OBJECT (widget), (gpointer) list);
1177 gtk_widget_unparent (widget);
1179 if (widget == list->undo_focus_child)
1180 list->undo_focus_child = NULL;
1181 if (widget == list->last_focus_child)
1182 list->last_focus_child = NULL;
1184 g_object_unref (widget);
1187 g_list_free (start_list);
1189 if (new_focus_child)
1192 gtk_widget_grab_focus (new_focus_child);
1193 else if (container->focus_child)
1194 gtk_container_set_focus_child (container, new_focus_child);
1196 if ((list->selection_mode == GTK_SELECTION_BROWSE ||
1197 list->selection_mode == GTK_SELECTION_MULTIPLE) && !list->selection)
1199 list->last_focus_child = new_focus_child;
1200 gtk_list_select_child (list, new_focus_child);
1204 if (GTK_WIDGET_VISIBLE (list))
1205 gtk_widget_queue_resize (GTK_WIDGET (list));
1209 gtk_list_child_position (GtkList *list,
1215 g_return_val_if_fail (GTK_IS_LIST (list), -1);
1216 g_return_val_if_fail (child != NULL, -1);
1219 children = list->children;
1223 if (child == GTK_WIDGET (children->data))
1227 children = children->next;
1234 /* Private GtkList Insert/Remove Item Functions:
1236 * gtk_list_remove_items_internal
1239 gtk_list_remove_items_internal (GtkList *list,
1244 GtkWidget *new_focus_child;
1245 GtkWidget *old_focus_child;
1246 GtkContainer *container;
1249 gboolean grab_focus = FALSE;
1251 g_return_if_fail (GTK_IS_LIST (list));
1256 container = GTK_CONTAINER (list);
1258 gtk_list_end_drag_selection (list);
1259 if (list->selection_mode == GTK_SELECTION_MULTIPLE)
1261 if (list->anchor >= 0)
1262 gtk_list_end_selection (list);
1264 gtk_list_reset_extended_selection (list);
1270 widget = tmp_list->data;
1271 tmp_list = tmp_list->next;
1273 if (widget->state == GTK_STATE_SELECTED)
1274 gtk_list_unselect_child (list, widget);
1277 if (container->focus_child)
1279 old_focus_child = new_focus_child = container->focus_child;
1280 if (GTK_WIDGET_HAS_FOCUS (container->focus_child))
1284 old_focus_child = new_focus_child = list->last_focus_child;
1289 widget = tmp_list->data;
1290 tmp_list = tmp_list->next;
1292 gtk_widget_ref (widget);
1294 gtk_widget_ref (widget);
1296 if (widget == new_focus_child)
1298 work = g_list_find (list->children, widget);
1303 new_focus_child = work->next->data;
1304 else if (list->children != work && work->prev)
1305 new_focus_child = work->prev->data;
1307 new_focus_child = NULL;
1311 gtk_signal_disconnect_by_data (GTK_OBJECT (widget), (gpointer) list);
1312 list->children = g_list_remove (list->children, widget);
1313 gtk_widget_unparent (widget);
1315 if (widget == list->undo_focus_child)
1316 list->undo_focus_child = NULL;
1317 if (widget == list->last_focus_child)
1318 list->last_focus_child = NULL;
1320 g_object_unref (widget);
1323 if (new_focus_child && new_focus_child != old_focus_child)
1326 gtk_widget_grab_focus (new_focus_child);
1327 else if (container->focus_child)
1328 gtk_container_set_focus_child (container, new_focus_child);
1330 if (list->selection_mode == GTK_SELECTION_BROWSE && !list->selection)
1332 list->last_focus_child = new_focus_child;
1333 gtk_list_select_child (list, new_focus_child);
1337 if (GTK_WIDGET_VISIBLE (list))
1338 gtk_widget_queue_resize (GTK_WIDGET (list));
1342 /* Public GtkList Selection Methods :
1344 * gtk_list_set_selection_mode
1345 * gtk_list_select_item
1346 * gtk_list_unselect_item
1347 * gtk_list_select_child
1348 * gtk_list_unselect_child
1349 * gtk_list_select_all
1350 * gtk_list_unselect_all
1351 * gtk_list_extend_selection
1352 * gtk_list_end_drag_selection
1353 * gtk_list_start_selection
1354 * gtk_list_end_selection
1355 * gtk_list_toggle_row
1356 * gtk_list_toggle_focus_row
1357 * gtk_list_toggle_add_mode
1358 * gtk_list_undo_selection
1361 gtk_list_set_selection_mode (GtkList *list,
1362 GtkSelectionMode mode)
1364 g_return_if_fail (GTK_IS_LIST (list));
1366 if (list->selection_mode == mode)
1369 list->selection_mode = mode;
1373 case GTK_SELECTION_SINGLE:
1374 case GTK_SELECTION_BROWSE:
1375 gtk_list_unselect_all (list);
1383 gtk_list_select_item (GtkList *list,
1388 g_return_if_fail (GTK_IS_LIST (list));
1390 tmp_list = g_list_nth (list->children, item);
1392 gtk_list_select_child (list, GTK_WIDGET (tmp_list->data));
1396 gtk_list_unselect_item (GtkList *list,
1401 g_return_if_fail (GTK_IS_LIST (list));
1403 tmp_list = g_list_nth (list->children, item);
1405 gtk_list_unselect_child (list, GTK_WIDGET (tmp_list->data));
1409 gtk_list_select_child (GtkList *list,
1412 gtk_signal_emit (GTK_OBJECT (list), list_signals[SELECT_CHILD], child);
1416 gtk_list_unselect_child (GtkList *list,
1419 gtk_signal_emit (GTK_OBJECT (list), list_signals[UNSELECT_CHILD], child);
1423 gtk_list_select_all (GtkList *list)
1425 GtkContainer *container;
1427 g_return_if_fail (GTK_IS_LIST (list));
1429 if (!list->children)
1432 if (list_has_grab (list))
1433 gtk_list_end_drag_selection (list);
1435 if (list->selection_mode == GTK_SELECTION_MULTIPLE && list->anchor >= 0)
1436 gtk_list_end_selection (list);
1438 container = GTK_CONTAINER (list);
1440 switch (list->selection_mode)
1442 case GTK_SELECTION_BROWSE:
1443 if (container->focus_child)
1445 gtk_list_select_child (list, container->focus_child);
1449 case GTK_SELECTION_MULTIPLE:
1450 g_list_free (list->undo_selection);
1451 g_list_free (list->undo_unselection);
1452 list->undo_selection = NULL;
1453 list->undo_unselection = NULL;
1455 if (list->children &&
1456 GTK_WIDGET_STATE (list->children->data) != GTK_STATE_SELECTED)
1457 gtk_list_fake_toggle_row (list, GTK_WIDGET (list->children->data));
1459 list->anchor_state = GTK_STATE_SELECTED;
1462 list->undo_focus_child = container->focus_child;
1463 gtk_list_update_extended_selection (list, g_list_length(list->children));
1464 gtk_list_end_selection (list);
1472 gtk_list_unselect_all (GtkList *list)
1474 GtkContainer *container;
1478 g_return_if_fail (GTK_IS_LIST (list));
1480 if (!list->children)
1483 if (list_has_grab (list))
1484 gtk_list_end_drag_selection (list);
1486 if (list->selection_mode == GTK_SELECTION_MULTIPLE && list->anchor >= 0)
1487 gtk_list_end_selection (list);
1489 container = GTK_CONTAINER (list);
1491 switch (list->selection_mode)
1493 case GTK_SELECTION_BROWSE:
1494 if (container->focus_child)
1496 gtk_list_select_child (list, container->focus_child);
1500 case GTK_SELECTION_MULTIPLE:
1501 gtk_list_reset_extended_selection (list);
1507 work = list->selection;
1513 gtk_list_unselect_child (list, item);
1518 gtk_list_extend_selection (GtkList *list,
1519 GtkScrollType scroll_type,
1521 gboolean auto_start_selection)
1523 GtkContainer *container;
1525 g_return_if_fail (GTK_IS_LIST (list));
1527 if (list_has_grab (list) ||
1528 list->selection_mode != GTK_SELECTION_MULTIPLE)
1531 container = GTK_CONTAINER (list);
1533 if (auto_start_selection)
1537 focus_row = g_list_index (list->children, container->focus_child);
1538 gtk_list_set_anchor (list, list->add_mode, focus_row,
1539 container->focus_child);
1541 else if (list->anchor < 0)
1544 gtk_list_move_focus_child (list, scroll_type, position);
1545 gtk_list_update_extended_selection
1546 (list, g_list_index (list->children, container->focus_child));
1550 gtk_list_end_drag_selection (GtkList *list)
1552 g_return_if_fail (GTK_IS_LIST (list));
1554 list->drag_selection = FALSE;
1555 if (GTK_WIDGET_HAS_GRAB (list))
1556 gtk_grab_remove (GTK_WIDGET (list));
1560 g_source_remove (list->htimer);
1565 g_source_remove (list->vtimer);
1571 gtk_list_start_selection (GtkList *list)
1573 GtkContainer *container;
1576 g_return_if_fail (GTK_IS_LIST (list));
1578 if (list_has_grab (list))
1581 container = GTK_CONTAINER (list);
1583 if ((focus_row = g_list_index (list->selection, container->focus_child))
1585 gtk_list_set_anchor (list, list->add_mode,
1586 focus_row, container->focus_child);
1590 gtk_list_end_selection (GtkList *list)
1599 g_return_if_fail (GTK_IS_LIST (list));
1601 if (list_has_grab (list) || list->anchor < 0)
1604 i = MIN (list->anchor, list->drag_pos);
1605 e = MAX (list->anchor, list->drag_pos);
1607 top_down = (list->anchor < list->drag_pos);
1610 list->drag_pos = -1;
1612 if (list->undo_selection)
1614 work = list->selection;
1615 list->selection = list->undo_selection;
1616 list->undo_selection = work;
1617 work = list->selection;
1622 item_index = g_list_index (list->children, item);
1623 if (item_index < i || item_index > e)
1625 gtk_widget_set_state (item, GTK_STATE_SELECTED);
1626 gtk_list_unselect_child (list, item);
1627 list->undo_selection = g_list_prepend (list->undo_selection,
1635 for (work = g_list_nth (list->children, i); i <= e;
1636 i++, work = work->next)
1639 if (g_list_find (list->selection, item))
1641 if (item->state == GTK_STATE_NORMAL)
1643 gtk_widget_set_state (item, GTK_STATE_SELECTED);
1644 gtk_list_unselect_child (list, item);
1645 list->undo_selection = g_list_prepend (list->undo_selection,
1649 else if (item->state == GTK_STATE_SELECTED)
1651 gtk_widget_set_state (item, GTK_STATE_NORMAL);
1652 list->undo_unselection = g_list_prepend (list->undo_unselection,
1659 for (work = g_list_nth (list->children, e); i <= e;
1660 e--, work = work->prev)
1663 if (g_list_find (list->selection, item))
1665 if (item->state == GTK_STATE_NORMAL)
1667 gtk_widget_set_state (item, GTK_STATE_SELECTED);
1668 gtk_list_unselect_child (list, item);
1669 list->undo_selection = g_list_prepend (list->undo_selection,
1673 else if (item->state == GTK_STATE_SELECTED)
1675 gtk_widget_set_state (item, GTK_STATE_NORMAL);
1676 list->undo_unselection = g_list_prepend (list->undo_unselection,
1682 for (work = g_list_reverse (list->undo_unselection); work; work = work->next)
1683 gtk_list_select_child (list, GTK_WIDGET (work->data));
1689 gtk_list_toggle_row (GtkList *list,
1692 g_return_if_fail (GTK_IS_LIST (list));
1693 g_return_if_fail (GTK_IS_LIST_ITEM (item));
1695 switch (list->selection_mode)
1697 case GTK_SELECTION_MULTIPLE:
1698 case GTK_SELECTION_SINGLE:
1699 if (item->state == GTK_STATE_SELECTED)
1701 gtk_list_unselect_child (list, item);
1704 case GTK_SELECTION_BROWSE:
1705 gtk_list_select_child (list, item);
1711 gtk_list_toggle_focus_row (GtkList *list)
1713 GtkContainer *container;
1716 g_return_if_fail (list != 0);
1717 g_return_if_fail (GTK_IS_LIST (list));
1719 container = GTK_CONTAINER (list);
1721 if (list_has_grab (list) || !container->focus_child)
1724 switch (list->selection_mode)
1726 case GTK_SELECTION_SINGLE:
1727 gtk_list_toggle_row (list, container->focus_child);
1729 case GTK_SELECTION_MULTIPLE:
1730 if ((focus_row = g_list_index (list->children, container->focus_child))
1734 g_list_free (list->undo_selection);
1735 g_list_free (list->undo_unselection);
1736 list->undo_selection = NULL;
1737 list->undo_unselection = NULL;
1739 list->anchor = focus_row;
1740 list->drag_pos = focus_row;
1741 list->undo_focus_child = container->focus_child;
1744 gtk_list_fake_toggle_row (list, container->focus_child);
1746 gtk_list_fake_unselect_all (list, container->focus_child);
1748 gtk_list_end_selection (list);
1756 gtk_list_toggle_add_mode (GtkList *list)
1758 GtkContainer *container;
1760 g_return_if_fail (list != 0);
1761 g_return_if_fail (GTK_IS_LIST (list));
1763 if (list_has_grab (list) ||
1764 list->selection_mode != GTK_SELECTION_MULTIPLE)
1767 container = GTK_CONTAINER (list);
1771 list->add_mode = FALSE;
1772 list->anchor_state = GTK_STATE_SELECTED;
1775 list->add_mode = TRUE;
1777 if (container->focus_child)
1778 gtk_widget_queue_draw (container->focus_child);
1782 gtk_list_undo_selection (GtkList *list)
1786 g_return_if_fail (GTK_IS_LIST (list));
1788 if (list->selection_mode != GTK_SELECTION_MULTIPLE ||
1789 list_has_grab (list))
1792 if (list->anchor >= 0)
1793 gtk_list_end_selection (list);
1795 if (!(list->undo_selection || list->undo_unselection))
1797 gtk_list_unselect_all (list);
1801 for (work = list->undo_selection; work; work = work->next)
1802 gtk_list_select_child (list, GTK_WIDGET (work->data));
1804 for (work = list->undo_unselection; work; work = work->next)
1805 gtk_list_unselect_child (list, GTK_WIDGET (work->data));
1807 if (list->undo_focus_child)
1809 GtkContainer *container;
1811 container = GTK_CONTAINER (list);
1813 if (container->focus_child &&
1814 GTK_WIDGET_HAS_FOCUS (container->focus_child))
1815 gtk_widget_grab_focus (list->undo_focus_child);
1817 gtk_container_set_focus_child (container, list->undo_focus_child);
1820 list->undo_focus_child = NULL;
1822 g_list_free (list->undo_selection);
1823 g_list_free (list->undo_unselection);
1824 list->undo_selection = NULL;
1825 list->undo_unselection = NULL;
1829 /* Private GtkList Selection Methods :
1831 * gtk_real_list_select_child
1832 * gtk_real_list_unselect_child
1835 gtk_real_list_select_child (GtkList *list,
1838 g_return_if_fail (GTK_IS_LIST (list));
1839 g_return_if_fail (GTK_IS_LIST_ITEM (child));
1841 switch (child->state)
1843 case GTK_STATE_SELECTED:
1844 case GTK_STATE_INSENSITIVE:
1847 gtk_list_item_select (GTK_LIST_ITEM (child));
1853 gtk_real_list_unselect_child (GtkList *list,
1856 g_return_if_fail (GTK_IS_LIST (list));
1857 g_return_if_fail (GTK_IS_LIST_ITEM (child));
1859 if (child->state == GTK_STATE_SELECTED)
1860 gtk_list_item_deselect (GTK_LIST_ITEM (child));
1864 /* Private GtkList Selection Functions :
1866 * gtk_list_set_anchor
1867 * gtk_list_fake_unselect_all
1868 * gtk_list_fake_toggle_row
1869 * gtk_list_update_extended_selection
1870 * gtk_list_reset_extended_selection
1873 gtk_list_set_anchor (GtkList *list,
1876 GtkWidget *undo_focus_child)
1880 g_return_if_fail (GTK_IS_LIST (list));
1882 if (list->selection_mode != GTK_SELECTION_MULTIPLE || list->anchor >= 0)
1885 g_list_free (list->undo_selection);
1886 g_list_free (list->undo_unselection);
1887 list->undo_selection = NULL;
1888 list->undo_unselection = NULL;
1890 if ((work = g_list_nth (list->children, anchor)))
1893 gtk_list_fake_toggle_row (list, GTK_WIDGET (work->data));
1896 gtk_list_fake_unselect_all (list, GTK_WIDGET (work->data));
1897 list->anchor_state = GTK_STATE_SELECTED;
1901 list->anchor = anchor;
1902 list->drag_pos = anchor;
1903 list->undo_focus_child = undo_focus_child;
1907 gtk_list_fake_unselect_all (GtkList *list,
1912 if (item && item->state == GTK_STATE_NORMAL)
1913 gtk_widget_set_state (item, GTK_STATE_SELECTED);
1915 list->undo_selection = list->selection;
1916 list->selection = NULL;
1918 for (work = list->undo_selection; work; work = work->next)
1919 if (work->data != item)
1920 gtk_widget_set_state (GTK_WIDGET (work->data), GTK_STATE_NORMAL);
1924 gtk_list_fake_toggle_row (GtkList *list,
1930 if (item->state == GTK_STATE_NORMAL)
1932 list->anchor_state = GTK_STATE_SELECTED;
1933 gtk_widget_set_state (item, GTK_STATE_SELECTED);
1937 list->anchor_state = GTK_STATE_NORMAL;
1938 gtk_widget_set_state (item, GTK_STATE_NORMAL);
1943 gtk_list_update_extended_selection (GtkList *list,
1957 length = g_list_length (list->children);
1961 if (list->selection_mode != GTK_SELECTION_MULTIPLE || !list->anchor < 0)
1964 /* extending downwards */
1965 if (row > list->drag_pos && list->anchor <= list->drag_pos)
1967 s2 = list->drag_pos + 1;
1970 /* extending upwards */
1971 else if (row < list->drag_pos && list->anchor >= list->drag_pos)
1974 e2 = list->drag_pos - 1;
1976 else if (row < list->drag_pos && list->anchor < list->drag_pos)
1978 e1 = list->drag_pos;
1979 /* row and drag_pos on different sides of anchor :
1980 take back the selection between anchor and drag_pos,
1981 select between anchor and row */
1982 if (row < list->anchor)
1984 s1 = list->anchor + 1;
1986 e2 = list->anchor - 1;
1988 /* take back the selection between anchor and drag_pos */
1992 else if (row > list->drag_pos && list->anchor > list->drag_pos)
1994 s1 = list->drag_pos;
1995 /* row and drag_pos on different sides of anchor :
1996 take back the selection between anchor and drag_pos,
1997 select between anchor and row */
1998 if (row > list->anchor)
2000 e1 = list->anchor - 1;
2001 s2 = list->anchor + 1;
2004 /* take back the selection between anchor and drag_pos */
2009 list->drag_pos = row;
2011 /* restore the elements between s1 and e1 */
2014 for (i = s1, work = g_list_nth (list->children, i); i <= e1;
2015 i++, work = work->next)
2017 if (g_list_find (list->selection, work->data))
2018 gtk_widget_set_state (GTK_WIDGET (work->data), GTK_STATE_SELECTED);
2020 gtk_widget_set_state (GTK_WIDGET (work->data), GTK_STATE_NORMAL);
2024 /* extend the selection between s2 and e2 */
2027 for (i = s2, work = g_list_nth (list->children, i); i <= e2;
2028 i++, work = work->next)
2029 if (GTK_WIDGET (work->data)->state != list->anchor_state)
2030 gtk_widget_set_state (GTK_WIDGET (work->data), list->anchor_state);
2035 gtk_list_reset_extended_selection (GtkList *list)
2037 g_return_if_fail (list != 0);
2038 g_return_if_fail (GTK_IS_LIST (list));
2040 g_list_free (list->undo_selection);
2041 g_list_free (list->undo_unselection);
2042 list->undo_selection = NULL;
2043 list->undo_unselection = NULL;
2046 list->drag_pos = -1;
2047 list->undo_focus_child = GTK_CONTAINER (list)->focus_child;
2050 /* Public GtkList Scroll Methods :
2052 * gtk_list_scroll_horizontal
2053 * gtk_list_scroll_vertical
2056 gtk_list_scroll_horizontal (GtkList *list,
2057 GtkScrollType scroll_type,
2062 g_return_if_fail (list != 0);
2063 g_return_if_fail (GTK_IS_LIST (list));
2065 if (list_has_grab (list))
2069 gtk_object_get_data_by_id (GTK_OBJECT (list), hadjustment_key_id)))
2072 switch (scroll_type)
2074 case GTK_SCROLL_STEP_UP:
2075 case GTK_SCROLL_STEP_BACKWARD:
2076 adj->value = CLAMP (adj->value - adj->step_increment, adj->lower,
2077 adj->upper - adj->page_size);
2079 case GTK_SCROLL_STEP_DOWN:
2080 case GTK_SCROLL_STEP_FORWARD:
2081 adj->value = CLAMP (adj->value + adj->step_increment, adj->lower,
2082 adj->upper - adj->page_size);
2084 case GTK_SCROLL_PAGE_UP:
2085 case GTK_SCROLL_PAGE_BACKWARD:
2086 adj->value = CLAMP (adj->value - adj->page_increment, adj->lower,
2087 adj->upper - adj->page_size);
2089 case GTK_SCROLL_PAGE_DOWN:
2090 case GTK_SCROLL_PAGE_FORWARD:
2091 adj->value = CLAMP (adj->value + adj->page_increment, adj->lower,
2092 adj->upper - adj->page_size);
2094 case GTK_SCROLL_JUMP:
2095 adj->value = CLAMP (adj->lower + (adj->upper - adj->lower) * position,
2096 adj->lower, adj->upper - adj->page_size);
2101 gtk_adjustment_value_changed (adj);
2105 gtk_list_scroll_vertical (GtkList *list,
2106 GtkScrollType scroll_type,
2109 g_return_if_fail (GTK_IS_LIST (list));
2111 if (list_has_grab (list))
2114 if (list->selection_mode == GTK_SELECTION_MULTIPLE)
2116 GtkContainer *container;
2118 if (list->anchor >= 0)
2121 container = GTK_CONTAINER (list);
2122 list->undo_focus_child = container->focus_child;
2123 gtk_list_move_focus_child (list, scroll_type, position);
2124 if (container->focus_child != list->undo_focus_child && !list->add_mode)
2126 gtk_list_unselect_all (list);
2127 gtk_list_select_child (list, container->focus_child);
2131 gtk_list_move_focus_child (list, scroll_type, position);
2135 /* Private GtkList Scroll/Focus Functions :
2137 * gtk_list_move_focus_child
2138 * gtk_list_horizontal_timeout
2139 * gtk_list_vertical_timeout
2142 gtk_list_move_focus_child (GtkList *list,
2143 GtkScrollType scroll_type,
2146 GtkContainer *container;
2152 g_return_if_fail (list != 0);
2153 g_return_if_fail (GTK_IS_LIST (list));
2155 container = GTK_CONTAINER (list);
2157 if (container->focus_child)
2158 work = g_list_find (list->children, container->focus_child);
2160 work = list->children;
2165 switch (scroll_type)
2167 case GTK_SCROLL_STEP_BACKWARD:
2170 gtk_widget_grab_focus (GTK_WIDGET (work->data));
2172 case GTK_SCROLL_STEP_FORWARD:
2175 gtk_widget_grab_focus (GTK_WIDGET (work->data));
2177 case GTK_SCROLL_PAGE_BACKWARD:
2182 adj = gtk_object_get_data_by_id (GTK_OBJECT (list), vadjustment_key_id);
2186 gboolean correct = FALSE;
2188 new_value = adj->value;
2190 if (item->allocation.y <= adj->value)
2192 new_value = MAX (item->allocation.y + item->allocation.height
2193 - adj->page_size, adj->lower);
2197 if (item->allocation.y > new_value)
2198 for (; work; work = work->prev)
2200 item = GTK_WIDGET (work->data);
2201 if (item->allocation.y <= new_value &&
2202 item->allocation.y + item->allocation.height > new_value)
2206 for (; work; work = work->next)
2208 item = GTK_WIDGET (work->data);
2209 if (item->allocation.y <= new_value &&
2210 item->allocation.y + item->allocation.height > new_value)
2214 if (correct && work && work->next && item->allocation.y < new_value)
2215 item = work->next->data;
2218 item = list->children->data;
2220 gtk_widget_grab_focus (item);
2222 case GTK_SCROLL_PAGE_FORWARD:
2227 adj = gtk_object_get_data_by_id (GTK_OBJECT (list), vadjustment_key_id);
2231 gboolean correct = FALSE;
2233 new_value = adj->value;
2235 if (item->allocation.y + item->allocation.height >=
2236 adj->value + adj->page_size)
2238 new_value = item->allocation.y;
2242 new_value = MIN (new_value + adj->page_size, adj->upper);
2244 if (item->allocation.y > new_value)
2245 for (; work; work = work->prev)
2247 item = GTK_WIDGET (work->data);
2248 if (item->allocation.y <= new_value &&
2249 item->allocation.y + item->allocation.height > new_value)
2253 for (; work; work = work->next)
2255 item = GTK_WIDGET (work->data);
2256 if (item->allocation.y <= new_value &&
2257 item->allocation.y + item->allocation.height > new_value)
2261 if (correct && work && work->prev &&
2262 item->allocation.y + item->allocation.height - 1 > new_value)
2263 item = work->prev->data;
2266 item = g_list_last (work)->data;
2268 gtk_widget_grab_focus (item);
2270 case GTK_SCROLL_JUMP:
2271 new_value = GTK_WIDGET(list)->allocation.height * CLAMP (position, 0, 1);
2273 for (item = NULL, work = list->children; work; work =work->next)
2275 item = GTK_WIDGET (work->data);
2276 if (item->allocation.y <= new_value &&
2277 item->allocation.y + item->allocation.height > new_value)
2281 gtk_widget_grab_focus (item);
2289 do_fake_motion (GtkWidget *list)
2291 GdkEvent *event = gdk_event_new (GDK_MOTION_NOTIFY);
2293 event->motion.send_event = TRUE;
2295 gtk_list_motion_notify (list, (GdkEventMotion *)event);
2296 gdk_event_free (event);
2300 gtk_list_horizontal_timeout (GtkWidget *list)
2302 GTK_LIST (list)->htimer = 0;
2303 do_fake_motion (list);
2309 gtk_list_vertical_timeout (GtkWidget *list)
2311 GTK_LIST (list)->vtimer = 0;
2312 do_fake_motion (list);
2318 /* Private GtkListItem Signal Functions :
2320 * gtk_list_signal_toggle_focus_row
2321 * gtk_list_signal_select_all
2322 * gtk_list_signal_unselect_all
2323 * gtk_list_signal_undo_selection
2324 * gtk_list_signal_start_selection
2325 * gtk_list_signal_end_selection
2326 * gtk_list_signal_extend_selection
2327 * gtk_list_signal_scroll_horizontal
2328 * gtk_list_signal_scroll_vertical
2329 * gtk_list_signal_toggle_add_mode
2330 * gtk_list_signal_item_select
2331 * gtk_list_signal_item_deselect
2332 * gtk_list_signal_item_toggle
2335 gtk_list_signal_toggle_focus_row (GtkListItem *list_item,
2338 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2339 g_return_if_fail (GTK_IS_LIST (list));
2341 gtk_list_toggle_focus_row (list);
2345 gtk_list_signal_select_all (GtkListItem *list_item,
2348 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2349 g_return_if_fail (GTK_IS_LIST (list));
2351 gtk_list_select_all (list);
2355 gtk_list_signal_unselect_all (GtkListItem *list_item,
2358 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2359 g_return_if_fail (GTK_IS_LIST (list));
2361 gtk_list_unselect_all (list);
2365 gtk_list_signal_undo_selection (GtkListItem *list_item,
2368 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2369 g_return_if_fail (GTK_IS_LIST (list));
2371 gtk_list_undo_selection (list);
2375 gtk_list_signal_start_selection (GtkListItem *list_item,
2378 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2379 g_return_if_fail (GTK_IS_LIST (list));
2381 gtk_list_start_selection (list);
2385 gtk_list_signal_end_selection (GtkListItem *list_item,
2388 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2389 g_return_if_fail (GTK_IS_LIST (list));
2391 gtk_list_end_selection (list);
2395 gtk_list_signal_extend_selection (GtkListItem *list_item,
2396 GtkScrollType scroll_type,
2398 gboolean auto_start_selection,
2401 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2402 g_return_if_fail (GTK_IS_LIST (list));
2404 gtk_list_extend_selection (list, scroll_type, position,
2405 auto_start_selection);
2409 gtk_list_signal_scroll_horizontal (GtkListItem *list_item,
2410 GtkScrollType scroll_type,
2414 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2415 g_return_if_fail (GTK_IS_LIST (list));
2417 gtk_list_scroll_horizontal (list, scroll_type, position);
2421 gtk_list_signal_scroll_vertical (GtkListItem *list_item,
2422 GtkScrollType scroll_type,
2426 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2427 g_return_if_fail (GTK_IS_LIST (list));
2429 gtk_list_scroll_vertical (list, scroll_type, position);
2433 gtk_list_signal_toggle_add_mode (GtkListItem *list_item,
2436 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2437 g_return_if_fail (GTK_IS_LIST (list));
2439 gtk_list_toggle_add_mode (list);
2443 gtk_list_signal_item_select (GtkListItem *list_item,
2450 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2451 g_return_if_fail (GTK_IS_LIST (list));
2453 if (GTK_WIDGET (list_item)->state != GTK_STATE_SELECTED)
2456 switch (list->selection_mode)
2458 case GTK_SELECTION_SINGLE:
2459 case GTK_SELECTION_BROWSE:
2461 selection = list->selection;
2465 tmp_list = selection;
2466 selection = selection->next;
2468 if (tmp_list->data == list_item)
2469 sel_list = tmp_list;
2471 gtk_list_item_deselect (GTK_LIST_ITEM (tmp_list->data));
2476 list->selection = g_list_prepend (list->selection, list_item);
2477 gtk_widget_ref (GTK_WIDGET (list_item));
2479 gtk_signal_emit (GTK_OBJECT (list), list_signals[SELECTION_CHANGED]);
2481 case GTK_SELECTION_MULTIPLE:
2482 if (list->anchor >= 0)
2488 gtk_list_signal_item_deselect (GtkListItem *list_item,
2493 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2494 g_return_if_fail (GTK_IS_LIST (list));
2496 if (GTK_WIDGET (list_item)->state != GTK_STATE_NORMAL)
2499 node = g_list_find (list->selection, list_item);
2503 list->selection = g_list_remove_link (list->selection, node);
2504 g_list_free_1 (node);
2505 g_object_unref (list_item);
2506 gtk_signal_emit (GTK_OBJECT (list), list_signals[SELECTION_CHANGED]);
2511 gtk_list_signal_item_toggle (GtkListItem *list_item,
2514 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2515 g_return_if_fail (GTK_IS_LIST (list));
2517 if ((list->selection_mode == GTK_SELECTION_BROWSE ||
2518 list->selection_mode == GTK_SELECTION_MULTIPLE) &&
2519 GTK_WIDGET (list_item)->state == GTK_STATE_NORMAL)
2521 gtk_widget_set_state (GTK_WIDGET (list_item), GTK_STATE_SELECTED);
2525 switch (GTK_WIDGET (list_item)->state)
2527 case GTK_STATE_SELECTED:
2528 gtk_list_signal_item_select (list_item, list);
2530 case GTK_STATE_NORMAL:
2531 gtk_list_signal_item_deselect (list_item, list);
2539 gtk_list_signal_drag_begin (GtkWidget *widget,
2540 GdkDragContext *context,
2543 g_return_if_fail (GTK_IS_LIST_ITEM (widget));
2544 g_return_if_fail (GTK_IS_LIST (list));
2546 gtk_list_drag_begin (GTK_WIDGET (list), context);
2550 gtk_list_drag_begin (GtkWidget *widget,
2551 GdkDragContext *context)
2555 g_return_if_fail (GTK_IS_LIST (widget));
2556 g_return_if_fail (context != NULL);
2558 list = GTK_LIST (widget);
2560 if (list->drag_selection)
2562 gtk_list_end_drag_selection (list);
2564 switch (list->selection_mode)
2566 case GTK_SELECTION_MULTIPLE:
2567 gtk_list_end_selection (list);
2569 case GTK_SELECTION_SINGLE:
2570 list->undo_focus_child = NULL;
2578 #define __GTK_LIST_C__
2579 #include "gtkaliasdef.c"