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 Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
20 #include "gtklistitem.h"
22 #include "gtksignal.h"
32 #define SCROLL_TIME 100
34 /** GtkList Methods **/
35 static void gtk_list_class_init (GtkListClass *klass);
36 static void gtk_list_init (GtkList *list);
38 /** GtkObject Methods **/
39 static void gtk_list_shutdown (GtkObject *object);
41 /** GtkWidget Methods **/
42 static void gtk_list_size_request (GtkWidget *widget,
43 GtkRequisition *requisition);
44 static void gtk_list_size_allocate (GtkWidget *widget,
45 GtkAllocation *allocation);
46 static void gtk_list_realize (GtkWidget *widget);
47 static void gtk_list_map (GtkWidget *widget);
48 static void gtk_list_unmap (GtkWidget *widget);
49 static void gtk_list_style_set (GtkWidget *widget,
50 GtkStyle *previous_style);
51 static void gtk_list_draw (GtkWidget *widget,
53 static gint gtk_list_expose (GtkWidget *widget,
54 GdkEventExpose *event);
55 static gint gtk_list_motion_notify (GtkWidget *widget,
56 GdkEventMotion *event);
57 static gint gtk_list_button_press (GtkWidget *widget,
58 GdkEventButton *event);
59 static gint gtk_list_button_release (GtkWidget *widget,
60 GdkEventButton *event);
62 /** GtkContainer Methods **/
63 static void gtk_list_add (GtkContainer *container,
65 static void gtk_list_remove (GtkContainer *container,
67 static void gtk_list_forall (GtkContainer *container,
68 gboolean include_internals,
70 gpointer callback_data);
71 static GtkType gtk_list_child_type (GtkContainer *container);
72 static void gtk_list_set_focus_child (GtkContainer *container,
74 static gint gtk_list_focus (GtkContainer *container,
75 GtkDirectionType direction);
77 /** GtkList Private Functions **/
78 static void gtk_list_move_focus_child (GtkList *list,
79 GtkScrollType scroll_type,
81 static gint gtk_list_horizontal_timeout (GtkWidget *list);
82 static gint gtk_list_vertical_timeout (GtkWidget *list);
83 static void gtk_list_remove_items_internal (GtkList *list,
87 /** GtkList Selection Methods **/
88 static void gtk_real_list_select_child (GtkList *list,
90 static void gtk_real_list_unselect_child (GtkList *list,
93 /** GtkList Selection Functions **/
94 static void gtk_list_set_anchor (GtkList *list,
97 GtkWidget *undo_focus_child);
98 static void gtk_list_fake_unselect_all (GtkList *list,
100 static void gtk_list_fake_toggle_row (GtkList *list,
102 static void gtk_list_update_extended_selection (GtkList *list,
105 /** GtkListItem Signal Functions **/
106 static void gtk_list_signal_drag_begin (GtkWidget *widget,
107 GdkDragContext *context,
109 static void gtk_list_signal_focus_lost (GtkWidget *item,
112 static void gtk_list_signal_toggle_focus_row (GtkListItem *list_item,
114 static void gtk_list_signal_select_all (GtkListItem *list_item,
116 static void gtk_list_signal_unselect_all (GtkListItem *list_item,
118 static void gtk_list_signal_undo_selection (GtkListItem *list_item,
120 static void gtk_list_signal_start_selection (GtkListItem *list_item,
122 static void gtk_list_signal_end_selection (GtkListItem *list_item,
124 static void gtk_list_signal_extend_selection (GtkListItem *list_item,
125 GtkScrollType scroll_type,
127 gboolean auto_start_selection,
129 static void gtk_list_signal_scroll_horizontal (GtkListItem *list_item,
130 GtkScrollType scroll_type,
133 static void gtk_list_signal_scroll_vertical (GtkListItem *list_item,
134 GtkScrollType scroll_type,
137 static void gtk_list_signal_toggle_add_mode (GtkListItem *list_item,
139 static void gtk_list_signal_item_select (GtkListItem *list_item,
141 static void gtk_list_signal_item_deselect (GtkListItem *list_item,
143 static void gtk_list_signal_item_toggle (GtkListItem *list_item,
147 static void gtk_list_drag_begin (GtkWidget *widget,
148 GdkDragContext *context);
151 static GtkContainerClass *parent_class = NULL;
152 static guint list_signals[LAST_SIGNAL] = { 0 };
154 static const gchar *vadjustment_key = "gtk-vadjustment";
155 static guint vadjustment_key_id = 0;
156 static const gchar *hadjustment_key = "gtk-hadjustment";
157 static guint hadjustment_key_id = 0;
160 gtk_list_get_type (void)
162 static GtkType list_type = 0;
166 static const GtkTypeInfo list_info =
170 sizeof (GtkListClass),
171 (GtkClassInitFunc) gtk_list_class_init,
172 (GtkObjectInitFunc) gtk_list_init,
173 /* reserved_1 */ NULL,
174 /* reserved_2 */ NULL,
175 (GtkClassInitFunc) NULL,
178 list_type = gtk_type_unique (GTK_TYPE_CONTAINER, &list_info);
185 gtk_list_class_init (GtkListClass *class)
187 GtkObjectClass *object_class;
188 GtkWidgetClass *widget_class;
189 GtkContainerClass *container_class;
191 object_class = (GtkObjectClass*) class;
192 widget_class = (GtkWidgetClass*) class;
193 container_class = (GtkContainerClass*) class;
195 parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
197 vadjustment_key_id = g_quark_from_static_string (vadjustment_key);
198 hadjustment_key_id = g_quark_from_static_string (hadjustment_key);
200 list_signals[SELECTION_CHANGED] =
201 gtk_signal_new ("selection_changed",
204 GTK_SIGNAL_OFFSET (GtkListClass, selection_changed),
205 gtk_marshal_NONE__NONE,
207 list_signals[SELECT_CHILD] =
208 gtk_signal_new ("select_child",
211 GTK_SIGNAL_OFFSET (GtkListClass, select_child),
212 gtk_marshal_NONE__POINTER,
215 list_signals[UNSELECT_CHILD] =
216 gtk_signal_new ("unselect_child",
219 GTK_SIGNAL_OFFSET (GtkListClass, unselect_child),
220 gtk_marshal_NONE__POINTER,
224 gtk_object_class_add_signals (object_class, list_signals, LAST_SIGNAL);
226 object_class->shutdown = gtk_list_shutdown;
228 widget_class->map = gtk_list_map;
229 widget_class->unmap = gtk_list_unmap;
230 widget_class->style_set = gtk_list_style_set;
231 widget_class->realize = gtk_list_realize;
232 widget_class->draw = gtk_list_draw;
233 widget_class->expose_event = gtk_list_expose;
234 widget_class->button_press_event = gtk_list_button_press;
235 widget_class->button_release_event = gtk_list_button_release;
236 widget_class->motion_notify_event = gtk_list_motion_notify;
237 widget_class->size_request = gtk_list_size_request;
238 widget_class->size_allocate = gtk_list_size_allocate;
239 widget_class->drag_begin = gtk_list_drag_begin;
241 container_class->add = gtk_list_add;
242 container_class->remove = gtk_list_remove;
243 container_class->forall = gtk_list_forall;
244 container_class->child_type = gtk_list_child_type;
245 container_class->set_focus_child = gtk_list_set_focus_child;
246 container_class->focus = gtk_list_focus;
248 class->selection_changed = NULL;
249 class->select_child = gtk_real_list_select_child;
250 class->unselect_child = gtk_real_list_unselect_child;
254 gtk_list_init (GtkList *list)
256 list->children = NULL;
257 list->selection = NULL;
259 list->undo_selection = NULL;
260 list->undo_unselection = NULL;
262 list->last_focus_child = NULL;
263 list->undo_focus_child = NULL;
270 list->anchor_state = GTK_STATE_SELECTED;
272 list->selection_mode = GTK_SELECTION_SINGLE;
273 list->drag_selection = FALSE;
274 list->add_mode = FALSE;
280 return GTK_WIDGET (gtk_type_new (GTK_TYPE_LIST));
284 /* Private GtkObject Methods :
289 gtk_list_shutdown (GtkObject *object)
291 gtk_list_clear_items (GTK_LIST (object), 0, -1);
292 GTK_OBJECT_CLASS (parent_class)->shutdown (object);
296 /* Private GtkWidget Methods :
298 * gtk_list_size_request
299 * gtk_list_size_allocate
303 * gtk_list_motion_notify
304 * gtk_list_button_press
305 * gtk_list_button_release
308 gtk_list_size_request (GtkWidget *widget,
309 GtkRequisition *requisition)
315 g_return_if_fail (widget != NULL);
316 g_return_if_fail (GTK_IS_LIST (widget));
317 g_return_if_fail (requisition != NULL);
319 list = GTK_LIST (widget);
320 requisition->width = 0;
321 requisition->height = 0;
323 children = list->children;
326 child = children->data;
327 children = children->next;
329 if (GTK_WIDGET_VISIBLE (child))
331 gtk_widget_size_request (child, &child->requisition);
333 requisition->width = MAX (requisition->width,
334 child->requisition.width);
335 requisition->height += child->requisition.height;
339 requisition->width += GTK_CONTAINER (list)->border_width * 2;
340 requisition->height += GTK_CONTAINER (list)->border_width * 2;
342 requisition->width = MAX (requisition->width, 1);
343 requisition->height = MAX (requisition->height, 1);
347 gtk_list_size_allocate (GtkWidget *widget,
348 GtkAllocation *allocation)
352 GtkAllocation child_allocation;
355 g_return_if_fail (widget != NULL);
356 g_return_if_fail (GTK_IS_LIST (widget));
357 g_return_if_fail (allocation != NULL);
359 list = GTK_LIST (widget);
361 widget->allocation = *allocation;
362 if (GTK_WIDGET_REALIZED (widget))
363 gdk_window_move_resize (widget->window,
364 allocation->x, allocation->y,
365 allocation->width, allocation->height);
369 child_allocation.x = GTK_CONTAINER (list)->border_width;
370 child_allocation.y = GTK_CONTAINER (list)->border_width;
371 child_allocation.width = MAX (1, (gint)allocation->width -
372 child_allocation.x * 2);
374 children = list->children;
378 child = children->data;
379 children = children->next;
381 if (GTK_WIDGET_VISIBLE (child))
383 child_allocation.height = child->requisition.height;
385 gtk_widget_size_allocate (child, &child_allocation);
387 child_allocation.y += child_allocation.height;
394 gtk_list_realize (GtkWidget *widget)
396 GdkWindowAttr attributes;
397 gint attributes_mask;
399 g_return_if_fail (widget != NULL);
400 g_return_if_fail (GTK_IS_LIST (widget));
402 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
404 attributes.window_type = GDK_WINDOW_CHILD;
405 attributes.x = widget->allocation.x;
406 attributes.y = widget->allocation.y;
407 attributes.width = widget->allocation.width;
408 attributes.height = widget->allocation.height;
409 attributes.wclass = GDK_INPUT_OUTPUT;
410 attributes.visual = gtk_widget_get_visual (widget);
411 attributes.colormap = gtk_widget_get_colormap (widget);
412 attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
414 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
416 widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
417 &attributes, attributes_mask);
418 gdk_window_set_user_data (widget->window, widget);
420 widget->style = gtk_style_attach (widget->style, widget->window);
421 gdk_window_set_background (widget->window,
422 &widget->style->base[GTK_STATE_NORMAL]);
426 gtk_list_map (GtkWidget *widget)
432 g_return_if_fail (widget != NULL);
433 g_return_if_fail (GTK_IS_LIST (widget));
435 GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
436 list = GTK_LIST (widget);
438 children = list->children;
441 child = children->data;
442 children = children->next;
444 if (GTK_WIDGET_VISIBLE (child) &&
445 !GTK_WIDGET_MAPPED (child))
446 gtk_widget_map (child);
449 gdk_window_show (widget->window);
453 gtk_list_unmap (GtkWidget *widget)
455 g_return_if_fail (widget != NULL);
456 g_return_if_fail (GTK_IS_LIST (widget));
458 GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
459 gdk_window_hide (widget->window);
463 gtk_list_motion_notify (GtkWidget *widget,
464 GdkEventMotion *event)
467 GtkWidget *item = NULL;
469 GtkContainer *container;
477 g_return_val_if_fail (widget != NULL, FALSE);
478 g_return_val_if_fail (GTK_IS_LIST (widget), FALSE);
479 g_return_val_if_fail (event != NULL, FALSE);
481 list = GTK_LIST (widget);
483 if (!list->drag_selection || !list->children)
486 container = GTK_CONTAINER (widget);
488 if (event->is_hint || event->window != widget->window)
489 gdk_window_get_pointer (widget->window, &x, &y, NULL);
491 adj = gtk_object_get_data_by_id (GTK_OBJECT (list), hadjustment_key_id);
493 /* horizontal autoscrolling */
494 if (adj && widget->allocation.width > adj->page_size &&
495 (x < adj->value || x >= adj->value + adj->page_size))
497 if (list->htimer == 0)
499 list->htimer = gtk_timeout_add
500 (SCROLL_TIME, (GtkFunction) gtk_list_horizontal_timeout, widget);
502 if (!((x < adj->value && adj->value <= 0) ||
503 (x > adj->value + adj->page_size &&
504 adj->value >= adj->upper - adj->page_size)))
509 value = adj->value + (x - adj->value) / 2 - 1;
511 value = adj->value + 1 + (x - adj->value - adj->page_size) / 2;
513 gtk_adjustment_set_value (adj,
515 adj->upper - adj->page_size));
523 /* vertical autoscrolling */
524 for (work = list->children; work; length++, work = work->next)
528 item = GTK_WIDGET (work->data);
529 if (item->allocation.y > y ||
530 (item->allocation.y <= y &&
531 item->allocation.y + item->allocation.height > y))
535 if (work->data == container->focus_child)
542 if (list->vtimer != 0)
545 if (!((y < 0 && focus_row == 0) ||
546 (y > widget->allocation.height && focus_row >= length - 1)))
547 list->vtimer = gtk_timeout_add (SCROLL_TIME,
548 (GtkFunction) gtk_list_vertical_timeout,
551 if (row != focus_row)
552 gtk_widget_grab_focus (item);
554 switch (list->selection_mode)
556 case GTK_SELECTION_BROWSE:
557 gtk_list_select_child (list, item);
559 case GTK_SELECTION_EXTENDED:
560 gtk_list_update_extended_selection (list, row);
570 gtk_list_button_press (GtkWidget *widget,
571 GdkEventButton *event)
576 g_return_val_if_fail (widget != NULL, FALSE);
577 g_return_val_if_fail (GTK_IS_LIST (widget), FALSE);
578 g_return_val_if_fail (event != NULL, FALSE);
580 if (event->button != 1)
583 list = GTK_LIST (widget);
584 item = gtk_get_event_widget ((GdkEvent*) event);
586 while (item && !GTK_IS_LIST_ITEM (item))
589 if (item && (item->parent == widget))
594 if (event->type == GDK_BUTTON_PRESS)
596 list->drag_selection = TRUE;
597 gdk_pointer_grab (widget->window, TRUE,
598 GDK_POINTER_MOTION_HINT_MASK |
599 GDK_BUTTON1_MOTION_MASK |
600 GDK_BUTTON_RELEASE_MASK,
601 NULL, NULL, event->time);
602 gtk_grab_add (widget);
604 else if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list))
605 gtk_list_end_drag_selection (list);
607 if (!GTK_WIDGET_HAS_FOCUS(item))
608 gtk_widget_grab_focus (item);
612 list->add_mode = FALSE;
613 gtk_widget_queue_draw (item);
616 switch (list->selection_mode)
618 case GTK_SELECTION_SINGLE:
619 case GTK_SELECTION_MULTIPLE:
620 if (event->type != GDK_BUTTON_PRESS)
621 gtk_list_select_child (list, item);
623 list->undo_focus_child = item;
626 case GTK_SELECTION_BROWSE:
629 case GTK_SELECTION_EXTENDED:
630 focus_row = g_list_index (list->children, item);
632 if (list->last_focus_child)
633 last_focus_row = g_list_index (list->children,
634 list->last_focus_child);
637 last_focus_row = focus_row;
638 list->last_focus_child = item;
641 if (event->type != GDK_BUTTON_PRESS)
643 if (list->anchor >= 0)
645 gtk_list_update_extended_selection (list, focus_row);
646 gtk_list_end_selection (list);
648 gtk_list_select_child (list, item);
652 if (event->state & GDK_CONTROL_MASK)
654 if (event->state & GDK_SHIFT_MASK)
656 if (list->anchor < 0)
658 g_list_free (list->undo_selection);
659 g_list_free (list->undo_unselection);
660 list->undo_selection = NULL;
661 list->undo_unselection = NULL;
663 list->anchor = last_focus_row;
664 list->drag_pos = last_focus_row;
665 list->undo_focus_child = list->last_focus_child;
667 gtk_list_update_extended_selection (list, focus_row);
671 if (list->anchor < 0)
672 gtk_list_set_anchor (list, TRUE,
673 focus_row, list->last_focus_child);
675 gtk_list_update_extended_selection (list, focus_row);
680 if (event->state & GDK_SHIFT_MASK)
682 gtk_list_set_anchor (list, FALSE,
683 last_focus_row, list->last_focus_child);
684 gtk_list_update_extended_selection (list, focus_row);
688 if (list->anchor < 0)
689 gtk_list_set_anchor (list, FALSE, focus_row,
690 list->last_focus_child);
692 gtk_list_update_extended_selection (list, focus_row);
704 gtk_list_button_release (GtkWidget *widget,
705 GdkEventButton *event)
710 g_return_val_if_fail (widget != NULL, FALSE);
711 g_return_val_if_fail (GTK_IS_LIST (widget), FALSE);
712 g_return_val_if_fail (event != NULL, FALSE);
714 list = GTK_LIST (widget);
716 /* we don't handle button 2 and 3 */
717 if (event->button != 1)
720 if (list->drag_selection)
722 gtk_list_end_drag_selection (list);
724 switch (list->selection_mode)
726 case GTK_SELECTION_EXTENDED:
727 if (!(event->state & GDK_SHIFT_MASK))
728 gtk_list_end_selection (list);
731 case GTK_SELECTION_SINGLE:
732 case GTK_SELECTION_MULTIPLE:
734 item = gtk_get_event_widget ((GdkEvent*) event);
736 while (item && !GTK_IS_LIST_ITEM (item))
739 if (item && item->parent == widget)
741 if (list->undo_focus_child == item)
742 gtk_list_toggle_row (list, item);
744 list->undo_focus_child = NULL;
756 gtk_list_draw (GtkWidget *widget,
761 GdkRectangle child_area;
764 g_return_if_fail (widget != NULL);
765 g_return_if_fail (GTK_IS_LIST (widget));
766 g_return_if_fail (area != NULL);
768 if (GTK_WIDGET_DRAWABLE (widget))
770 list = GTK_LIST (widget);
772 children = list->children;
775 child = children->data;
776 children = children->next;
778 if (gtk_widget_intersect (child, area, &child_area))
779 gtk_widget_draw (child, &child_area);
785 gtk_list_expose (GtkWidget *widget,
786 GdkEventExpose *event)
790 GdkEventExpose child_event;
793 g_return_val_if_fail (widget != NULL, FALSE);
794 g_return_val_if_fail (GTK_IS_LIST (widget), FALSE);
795 g_return_val_if_fail (event != NULL, FALSE);
797 if (GTK_WIDGET_DRAWABLE (widget))
799 list = GTK_LIST (widget);
801 child_event = *event;
803 children = list->children;
806 child = children->data;
807 children = children->next;
809 if (GTK_WIDGET_NO_WINDOW (child) &&
810 gtk_widget_intersect (child, &event->area, &child_event.area))
811 gtk_widget_event (child, (GdkEvent*) &child_event);
819 gtk_list_style_set (GtkWidget *widget,
820 GtkStyle *previous_style)
822 g_return_if_fail (widget != NULL);
824 if (previous_style && GTK_WIDGET_REALIZED (widget))
825 gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
828 /* GtkContainer Methods :
832 * gtk_list_child_type
833 * gtk_list_set_focus_child
837 gtk_list_add (GtkContainer *container,
842 g_return_if_fail (container != NULL);
843 g_return_if_fail (GTK_IS_LIST (container));
844 g_return_if_fail (widget != NULL);
845 g_return_if_fail (GTK_IS_LIST_ITEM (widget));
847 item_list = g_list_alloc ();
848 item_list->data = widget;
850 gtk_list_append_items (GTK_LIST (container), item_list);
854 gtk_list_remove (GtkContainer *container,
859 g_return_if_fail (container != NULL);
860 g_return_if_fail (GTK_IS_LIST (container));
861 g_return_if_fail (widget != NULL);
862 g_return_if_fail (container == GTK_CONTAINER (widget->parent));
864 item_list = g_list_alloc ();
865 item_list->data = widget;
867 gtk_list_remove_items (GTK_LIST (container), item_list);
869 g_list_free (item_list);
873 gtk_list_forall (GtkContainer *container,
874 gboolean include_internals,
875 GtkCallback callback,
876 gpointer callback_data)
882 g_return_if_fail (container != NULL);
883 g_return_if_fail (GTK_IS_LIST (container));
884 g_return_if_fail (callback != NULL);
886 list = GTK_LIST (container);
887 children = list->children;
891 child = children->data;
892 children = children->next;
894 (* callback) (child, callback_data);
899 gtk_list_child_type (GtkContainer *container)
901 return GTK_TYPE_LIST_ITEM;
905 gtk_list_set_focus_child (GtkContainer *container,
910 g_return_if_fail (container != NULL);
911 g_return_if_fail (GTK_IS_LIST (container));
914 g_return_if_fail (GTK_IS_WIDGET (child));
916 list = GTK_LIST (container);
917 list->last_focus_child = container->focus_child;
919 if (child != container->focus_child)
921 if (container->focus_child)
922 gtk_widget_unref (container->focus_child);
923 container->focus_child = child;
924 if (container->focus_child)
925 gtk_widget_ref (container->focus_child);
928 /* check for v adjustment */
929 if (container->focus_child)
931 GtkAdjustment *adjustment;
933 adjustment = gtk_object_get_data_by_id (GTK_OBJECT (container),
936 gtk_adjustment_clamp_page (adjustment,
937 container->focus_child->allocation.y,
938 (container->focus_child->allocation.y +
939 container->focus_child->allocation.height));
942 switch (list->selection_mode)
944 case GTK_SELECTION_BROWSE:
946 gtk_list_select_child (list, child);
954 gtk_list_focus (GtkContainer *container,
955 GtkDirectionType direction)
957 gint return_val = FALSE;
959 g_return_val_if_fail (container != NULL, FALSE);
960 g_return_val_if_fail (GTK_IS_LIST (container), FALSE);
962 if (!GTK_WIDGET_IS_SENSITIVE (container))
964 else if (container->focus_child == NULL ||
965 !GTK_WIDGET_HAS_FOCUS (container->focus_child))
967 if (GTK_CONTAINER_CLASS (parent_class)->focus)
968 return_val = GTK_CONTAINER_CLASS (parent_class)->focus
969 (container, direction);
976 list = GTK_LIST (container);
977 if (list->selection_mode == GTK_SELECTION_EXTENDED && list->anchor >= 0)
978 gtk_list_end_selection (list);
985 /* Public GtkList Methods :
987 * gtk_list_insert_items
988 * gtk_list_append_items
989 * gtk_list_prepend_items
990 * gtk_list_remove_items
991 * gtk_list_remove_items_no_unref
992 * gtk_list_clear_items
994 * gtk_list_child_position
997 gtk_list_insert_items (GtkList *list,
1006 g_return_if_fail (list != NULL);
1007 g_return_if_fail (GTK_IS_LIST (list));
1012 gtk_list_end_drag_selection (list);
1013 if (list->selection_mode == GTK_SELECTION_EXTENDED && list->anchor >= 0)
1014 gtk_list_end_selection (list);
1019 widget = tmp_list->data;
1020 tmp_list = tmp_list->next;
1022 gtk_widget_set_parent (widget, GTK_WIDGET (list));
1023 gtk_signal_connect (GTK_OBJECT (widget), "drag_begin",
1024 GTK_SIGNAL_FUNC (gtk_list_signal_drag_begin),
1026 gtk_signal_connect (GTK_OBJECT (widget), "focus_out_event",
1027 GTK_SIGNAL_FUNC (gtk_list_signal_focus_lost),
1029 gtk_signal_connect (GTK_OBJECT (widget), "toggle_focus_row",
1030 GTK_SIGNAL_FUNC (gtk_list_signal_toggle_focus_row),
1032 gtk_signal_connect (GTK_OBJECT (widget), "select_all",
1033 GTK_SIGNAL_FUNC (gtk_list_signal_select_all),
1035 gtk_signal_connect (GTK_OBJECT (widget), "unselect_all",
1036 GTK_SIGNAL_FUNC (gtk_list_signal_unselect_all),
1038 gtk_signal_connect (GTK_OBJECT (widget), "undo_selection",
1039 GTK_SIGNAL_FUNC (gtk_list_signal_undo_selection),
1041 gtk_signal_connect (GTK_OBJECT (widget), "start_selection",
1042 GTK_SIGNAL_FUNC (gtk_list_signal_start_selection),
1044 gtk_signal_connect (GTK_OBJECT (widget), "end_selection",
1045 GTK_SIGNAL_FUNC (gtk_list_signal_end_selection),
1047 gtk_signal_connect (GTK_OBJECT (widget), "extend_selection",
1048 GTK_SIGNAL_FUNC (gtk_list_signal_extend_selection),
1050 gtk_signal_connect (GTK_OBJECT (widget), "scroll_horizontal",
1051 GTK_SIGNAL_FUNC (gtk_list_signal_scroll_horizontal),
1053 gtk_signal_connect (GTK_OBJECT (widget), "scroll_vertical",
1054 GTK_SIGNAL_FUNC (gtk_list_signal_scroll_vertical),
1056 gtk_signal_connect (GTK_OBJECT (widget), "toggle_add_mode",
1057 GTK_SIGNAL_FUNC (gtk_list_signal_toggle_add_mode),
1059 gtk_signal_connect (GTK_OBJECT (widget), "select",
1060 GTK_SIGNAL_FUNC (gtk_list_signal_item_select),
1062 gtk_signal_connect (GTK_OBJECT (widget), "deselect",
1063 GTK_SIGNAL_FUNC (gtk_list_signal_item_deselect),
1065 gtk_signal_connect (GTK_OBJECT (widget), "toggle",
1066 GTK_SIGNAL_FUNC (gtk_list_signal_item_toggle),
1069 if (GTK_WIDGET_VISIBLE (widget->parent))
1071 if (GTK_WIDGET_REALIZED (widget->parent) &&
1072 !GTK_WIDGET_REALIZED (widget))
1073 gtk_widget_realize (widget);
1075 if (GTK_WIDGET_MAPPED (widget->parent) &&
1076 !GTK_WIDGET_MAPPED (widget))
1077 gtk_widget_map (widget);
1081 nchildren = g_list_length (list->children);
1082 if ((position < 0) || (position > nchildren))
1083 position = nchildren;
1085 if (position == nchildren)
1089 tmp_list = g_list_last (list->children);
1090 tmp_list->next = items;
1091 items->prev = tmp_list;
1095 list->children = items;
1100 tmp_list = g_list_nth (list->children, position);
1101 last = g_list_last (items);
1104 tmp_list->prev->next = items;
1105 last->next = tmp_list;
1106 items->prev = tmp_list->prev;
1107 tmp_list->prev = last;
1109 if (tmp_list == list->children)
1110 list->children = items;
1113 if (list->children && !list->selection &&
1114 (list->selection_mode == GTK_SELECTION_BROWSE))
1116 widget = list->children->data;
1117 gtk_list_select_child (list, widget);
1120 if (GTK_WIDGET_VISIBLE (list))
1121 gtk_widget_queue_resize (GTK_WIDGET (list));
1125 gtk_list_append_items (GtkList *list,
1128 g_return_if_fail (list != NULL);
1129 g_return_if_fail (GTK_IS_LIST (list));
1131 gtk_list_insert_items (list, items, -1);
1135 gtk_list_prepend_items (GtkList *list,
1138 g_return_if_fail (list != NULL);
1139 g_return_if_fail (GTK_IS_LIST (list));
1141 gtk_list_insert_items (list, items, 0);
1145 gtk_list_remove_items (GtkList *list,
1148 gtk_list_remove_items_internal (list, items, FALSE);
1152 gtk_list_remove_items_no_unref (GtkList *list,
1155 gtk_list_remove_items_internal (list, items, TRUE);
1159 gtk_list_clear_items (GtkList *list,
1169 g_return_if_fail (list != NULL);
1170 g_return_if_fail (GTK_IS_LIST (list));
1172 nchildren = g_list_length (list->children);
1176 gboolean selection_changed;
1178 if ((end < 0) || (end > nchildren))
1184 start_list = g_list_nth (list->children, start);
1185 end_list = g_list_nth (list->children, end);
1187 gtk_list_end_drag_selection (list);
1188 if (list->selection_mode == GTK_SELECTION_EXTENDED && list->anchor >= 0)
1189 gtk_list_end_selection (list);
1191 if (start_list->prev)
1192 start_list->prev->next = end_list;
1193 if (end_list && end_list->prev)
1194 end_list->prev->next = NULL;
1196 end_list->prev = start_list->prev;
1197 if (start_list == list->children)
1198 list->children = end_list;
1200 selection_changed = FALSE;
1202 tmp_list = start_list;
1206 widget = tmp_list->data;
1207 tmp_list = tmp_list->next;
1209 if (widget->state == GTK_STATE_SELECTED)
1211 gtk_list_unselect_child (list, widget);
1212 selection_changed = TRUE;
1215 gtk_widget_unparent (widget);
1218 g_list_free (start_list);
1220 if (list->children && !list->selection &&
1221 (list->selection_mode == GTK_SELECTION_BROWSE))
1223 widget = list->children->data;
1224 gtk_list_select_child (list, widget);
1226 else if (selection_changed)
1227 gtk_signal_emit (GTK_OBJECT (list), list_signals[SELECTION_CHANGED]);
1229 gtk_widget_queue_resize (GTK_WIDGET (list));
1234 gtk_list_child_position (GtkList *list,
1240 g_return_val_if_fail (list != NULL, -1);
1241 g_return_val_if_fail (GTK_IS_LIST (list), -1);
1242 g_return_val_if_fail (child != NULL, -1);
1245 children = list->children;
1249 if (child == GTK_WIDGET (children->data))
1253 children = children->next;
1260 /* Private GtkList Insert/Remove Item Functions:
1262 * gtk_list_remove_items_internal
1265 gtk_list_remove_items_internal (GtkList *list,
1270 GtkWidget *new_focus_child;
1271 GtkWidget *old_focus_child;
1272 GtkContainer *container;
1275 gboolean grab_focus = FALSE;
1277 g_return_if_fail (list != NULL);
1278 g_return_if_fail (GTK_IS_LIST (list));
1283 container = GTK_CONTAINER (list);
1285 gtk_list_end_drag_selection (list);
1286 if (list->selection_mode == GTK_SELECTION_EXTENDED)
1288 if (list->anchor >= 0)
1289 gtk_list_end_selection (list);
1291 if (list->undo_selection || list->undo_unselection)
1293 g_list_free (list->undo_selection);
1294 g_list_free (list->undo_unselection);
1295 list->undo_selection = NULL;
1296 list->undo_unselection = NULL;
1299 list->drag_pos = -1;
1300 list->undo_focus_child = container->focus_child;
1307 widget = tmp_list->data;
1308 tmp_list = tmp_list->next;
1310 if (widget->state == GTK_STATE_SELECTED)
1311 gtk_list_unselect_child (list, widget);
1316 old_focus_child = new_focus_child = container->focus_child;
1320 widget = tmp_list->data;
1321 tmp_list = tmp_list->next;
1324 gtk_widget_ref (widget);
1327 if (widget == new_focus_child)
1329 work = g_list_find (list->children, widget);
1334 new_focus_child = work->next->data;
1335 else if (list->children != work && work->prev)
1336 new_focus_child = work->prev->data;
1338 new_focus_child = NULL;
1340 if (GTK_WIDGET_HAS_FOCUS (widget))
1345 gtk_signal_disconnect_by_data (GTK_OBJECT (widget), (gpointer) list);
1346 list->children = g_list_remove (list->children, widget);
1347 gtk_widget_unparent (widget);
1350 if (new_focus_child && new_focus_child != old_focus_child)
1353 gtk_widget_grab_focus (new_focus_child);
1355 gtk_container_set_focus_child (container, new_focus_child);
1358 if (GTK_WIDGET_VISIBLE (list))
1359 gtk_widget_queue_resize (GTK_WIDGET (list));
1363 /* Public GtkList Selection Methods :
1365 * gtk_list_set_selection_mode
1366 * gtk_list_select_item
1367 * gtk_list_unselect_item
1368 * gtk_list_select_child
1369 * gtk_list_unselect_child
1370 * gtk_list_select_all
1371 * gtk_list_unselect_all
1372 * gtk_list_extend_selection
1373 * gtk_list_end_drag_selection
1374 * gtk_list_start_selection
1375 * gtk_list_end_selection
1376 * gtk_list_toggle_row
1377 * gtk_list_toggle_focus_row
1378 * gtk_list_toggle_add_mode
1379 * gtk_list_undo_selection
1382 gtk_list_set_selection_mode (GtkList *list,
1383 GtkSelectionMode mode)
1385 g_return_if_fail (list != NULL);
1386 g_return_if_fail (GTK_IS_LIST (list));
1388 if (list->selection_mode == mode)
1391 list->selection_mode = mode;
1395 case GTK_SELECTION_SINGLE:
1396 case GTK_SELECTION_BROWSE:
1397 gtk_list_unselect_all (list);
1406 gtk_list_select_item (GtkList *list,
1411 g_return_if_fail (list != NULL);
1412 g_return_if_fail (GTK_IS_LIST (list));
1414 tmp_list = g_list_nth (list->children, item);
1416 gtk_list_select_child (list, GTK_WIDGET (tmp_list->data));
1420 gtk_list_unselect_item (GtkList *list,
1425 g_return_if_fail (list != NULL);
1426 g_return_if_fail (GTK_IS_LIST (list));
1428 tmp_list = g_list_nth (list->children, item);
1430 gtk_list_unselect_child (list, GTK_WIDGET (tmp_list->data));
1434 gtk_list_select_child (GtkList *list,
1437 gtk_signal_emit (GTK_OBJECT (list), list_signals[SELECT_CHILD], child);
1441 gtk_list_unselect_child (GtkList *list,
1444 gtk_signal_emit (GTK_OBJECT (list), list_signals[UNSELECT_CHILD], child);
1448 gtk_list_select_all (GtkList *list)
1450 GtkContainer *container;
1453 g_return_if_fail (list != NULL);
1454 g_return_if_fail (GTK_IS_LIST (list));
1456 if (!list->children)
1459 if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list))
1460 gtk_list_end_drag_selection (list);
1462 if (list->selection_mode == GTK_SELECTION_EXTENDED && list->anchor >= 0)
1463 gtk_list_end_selection (list);
1465 container = GTK_CONTAINER (list);
1467 switch (list->selection_mode)
1469 case GTK_SELECTION_BROWSE:
1470 if (container->focus_child)
1472 gtk_list_select_child (list, container->focus_child);
1477 case GTK_SELECTION_EXTENDED:
1478 g_list_free (list->undo_selection);
1479 g_list_free (list->undo_unselection);
1480 list->undo_selection = NULL;
1481 list->undo_unselection = NULL;
1483 if (list->children &&
1484 GTK_WIDGET_STATE (list->children->data) != GTK_STATE_SELECTED)
1485 gtk_list_fake_toggle_row (list, GTK_WIDGET (list->children->data));
1487 list->anchor_state = GTK_STATE_SELECTED;
1490 list->undo_focus_child = container->focus_child;
1491 gtk_list_update_extended_selection (list, g_list_length(list->children));
1492 gtk_list_end_selection (list);
1495 case GTK_SELECTION_MULTIPLE:
1496 for (work = list->children; work; work = work->next)
1498 if (GTK_WIDGET_STATE (work->data) == GTK_STATE_NORMAL)
1499 gtk_list_select_child (list, GTK_WIDGET (work->data));
1509 gtk_list_unselect_all (GtkList *list)
1511 GtkContainer *container;
1515 g_return_if_fail (list != NULL);
1516 g_return_if_fail (GTK_IS_LIST (list));
1518 if (!list->children)
1521 if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list))
1522 gtk_list_end_drag_selection (list);
1524 if (list->selection_mode == GTK_SELECTION_EXTENDED && list->anchor >= 0)
1525 gtk_list_end_selection (list);
1527 container = GTK_CONTAINER (list);
1529 switch (list->selection_mode)
1531 case GTK_SELECTION_BROWSE:
1532 if (container->focus_child)
1534 gtk_list_select_child (list, container->focus_child);
1539 case GTK_SELECTION_EXTENDED:
1540 g_list_free (list->undo_selection);
1541 g_list_free (list->undo_unselection);
1542 list->undo_selection = NULL;
1543 list->undo_unselection = NULL;
1546 list->drag_pos = -1;
1547 list->undo_focus_child = container->focus_child;
1554 work = list->selection;
1560 gtk_list_unselect_child (list, item);
1565 gtk_list_extend_selection (GtkList *list,
1566 GtkScrollType scroll_type,
1568 gboolean auto_start_selection)
1570 GtkContainer *container;
1572 g_return_if_fail (list != NULL);
1573 g_return_if_fail (GTK_IS_LIST (list));
1575 if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list)) ||
1576 list->selection_mode != GTK_SELECTION_EXTENDED)
1579 container = GTK_CONTAINER (list);
1581 if (auto_start_selection)
1585 focus_row = g_list_index (list->children, container->focus_child);
1586 gtk_list_set_anchor (list, list->add_mode, focus_row,
1587 container->focus_child);
1589 else if (list->anchor < 0)
1592 gtk_list_move_focus_child (list, scroll_type, position);
1593 gtk_list_update_extended_selection
1594 (list, g_list_index (list->children, container->focus_child));
1598 gtk_list_end_drag_selection (GtkList *list)
1600 g_return_if_fail (list != NULL);
1601 g_return_if_fail (GTK_IS_LIST (list));
1603 list->drag_selection = FALSE;
1604 if (GTK_WIDGET_HAS_GRAB (list))
1606 gtk_grab_remove (GTK_WIDGET (list));
1607 gdk_pointer_ungrab (GDK_CURRENT_TIME);
1611 gtk_timeout_remove (list->htimer);
1616 gtk_timeout_remove (list->vtimer);
1622 gtk_list_start_selection (GtkList *list)
1624 GtkContainer *container;
1627 g_return_if_fail (list != NULL);
1628 g_return_if_fail (GTK_IS_LIST (list));
1630 if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list))
1633 container = GTK_CONTAINER (list);
1635 if ((focus_row = g_list_index (list->selection, container->focus_child))
1637 gtk_list_set_anchor (list, list->add_mode,
1638 focus_row, container->focus_child);
1642 gtk_list_end_selection (GtkList *list)
1650 g_return_if_fail (list != NULL);
1651 g_return_if_fail (GTK_IS_LIST (list));
1653 if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list)) ||
1657 i = MIN (list->anchor, list->drag_pos);
1658 e = MAX (list->anchor, list->drag_pos);
1661 list->drag_pos = -1;
1663 if (list->undo_selection)
1665 work = list->selection;
1666 list->selection = list->undo_selection;
1667 list->undo_selection = work;
1668 work = list->selection;
1673 item_index = g_list_index (list->children, item);
1674 if (item_index < i || item_index > e)
1676 gtk_widget_set_state (item, GTK_STATE_SELECTED);
1677 gtk_list_unselect_child (list, item);
1678 list->undo_selection = g_list_prepend (list->undo_selection,
1684 for (work = g_list_nth (list->children, i); i <= e; i++, work = work->next)
1687 if (g_list_find (list->selection, item))
1689 if (item->state == GTK_STATE_NORMAL)
1691 gtk_widget_set_state (item, GTK_STATE_SELECTED);
1692 gtk_list_unselect_child (list, item);
1693 list->undo_selection = g_list_prepend (list->undo_selection,
1697 else if (item->state == GTK_STATE_SELECTED)
1699 gtk_widget_set_state (item, GTK_STATE_NORMAL);
1700 list->undo_unselection = g_list_prepend (list->undo_unselection,
1705 for (work = list->undo_unselection; work; work = work->next)
1706 gtk_list_select_child (list, GTK_WIDGET (work->data));
1711 gtk_list_toggle_row (GtkList *list,
1714 g_return_if_fail (list != NULL);
1715 g_return_if_fail (GTK_IS_LIST (list));
1716 g_return_if_fail (item != NULL);
1717 g_return_if_fail (GTK_IS_LIST_ITEM (item));
1719 switch (list->selection_mode)
1721 case GTK_SELECTION_EXTENDED:
1722 case GTK_SELECTION_MULTIPLE:
1723 case GTK_SELECTION_SINGLE:
1725 if (item->state == GTK_STATE_SELECTED)
1727 gtk_list_unselect_child (list, item);
1731 case GTK_SELECTION_BROWSE:
1732 gtk_list_select_child (list, item);
1738 gtk_list_toggle_focus_row (GtkList *list)
1740 GtkContainer *container;
1743 g_return_if_fail (list != 0);
1744 g_return_if_fail (GTK_IS_LIST (list));
1746 container = GTK_CONTAINER (list);
1748 if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list)) ||
1749 !container->focus_child)
1752 switch (list->selection_mode)
1754 case GTK_SELECTION_SINGLE:
1755 case GTK_SELECTION_MULTIPLE:
1757 gtk_list_toggle_row (list, container->focus_child);
1760 case GTK_SELECTION_EXTENDED:
1762 if ((focus_row = g_list_index (list->children, container->focus_child))
1766 g_list_free (list->undo_selection);
1767 g_list_free (list->undo_unselection);
1768 list->undo_selection = NULL;
1769 list->undo_unselection = NULL;
1771 list->anchor = focus_row;
1772 list->drag_pos = focus_row;
1773 list->undo_focus_child = container->focus_child;
1776 gtk_list_fake_toggle_row (list, container->focus_child);
1778 gtk_list_fake_unselect_all (list, container->focus_child);
1780 gtk_list_end_selection (list);
1789 gtk_list_toggle_add_mode (GtkList *list)
1791 GtkContainer *container;
1793 g_return_if_fail (list != 0);
1794 g_return_if_fail (GTK_IS_LIST (list));
1796 if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list)) ||
1797 list->selection_mode != GTK_SELECTION_EXTENDED)
1800 container = GTK_CONTAINER (list);
1804 list->add_mode = FALSE;
1805 list->anchor_state = GTK_STATE_SELECTED;
1808 list->add_mode = TRUE;
1810 if (container->focus_child)
1811 gtk_widget_queue_draw (container->focus_child);
1815 gtk_list_undo_selection (GtkList *list)
1819 g_return_if_fail (list != NULL);
1820 g_return_if_fail (GTK_IS_LIST (list));
1822 if (list->selection_mode != GTK_SELECTION_EXTENDED ||
1823 (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list)))
1826 if (list->anchor >= 0)
1827 gtk_list_end_selection (list);
1829 if (!(list->undo_selection || list->undo_unselection))
1831 gtk_list_unselect_all (list);
1835 for (work = list->undo_selection; work; work = work->next)
1836 gtk_list_select_child (list, GTK_WIDGET (work->data));
1838 for (work = list->undo_unselection; work; work = work->next)
1839 gtk_list_unselect_child (list, GTK_WIDGET (work->data));
1841 if (list->undo_focus_child)
1843 GtkContainer *container;
1845 container = GTK_CONTAINER (list);
1847 if (container->focus_child &&
1848 GTK_WIDGET_HAS_FOCUS (container->focus_child))
1849 gtk_widget_grab_focus (list->undo_focus_child);
1851 gtk_container_set_focus_child (container, list->undo_focus_child);
1854 list->undo_focus_child = NULL;
1856 g_list_free (list->undo_selection);
1857 g_list_free (list->undo_unselection);
1858 list->undo_selection = NULL;
1859 list->undo_unselection = NULL;
1863 /* Private GtkList Selection Methods :
1865 * gtk_real_list_select_child
1866 * gtk_real_list_unselect_child
1869 gtk_real_list_select_child (GtkList *list,
1872 g_return_if_fail (list != NULL);
1873 g_return_if_fail (GTK_IS_LIST (list));
1874 g_return_if_fail (child != NULL);
1875 g_return_if_fail (GTK_IS_LIST_ITEM (child));
1877 switch (child->state)
1879 case GTK_STATE_SELECTED:
1880 case GTK_STATE_INSENSITIVE:
1883 gtk_list_item_select (GTK_LIST_ITEM (child));
1889 gtk_real_list_unselect_child (GtkList *list,
1892 g_return_if_fail (list != NULL);
1893 g_return_if_fail (GTK_IS_LIST (list));
1894 g_return_if_fail (child != NULL);
1895 g_return_if_fail (GTK_IS_LIST_ITEM (child));
1897 if (child->state == GTK_STATE_SELECTED)
1898 gtk_list_item_deselect (GTK_LIST_ITEM (child));
1902 /* Private GtkList Selection Functions :
1904 * gtk_list_set_anchor
1905 * gtk_list_fake_unselect_all
1906 * gtk_list_fake_toggle_row
1907 * gtk_list_update_extended_selection
1910 gtk_list_set_anchor (GtkList *list,
1913 GtkWidget *undo_focus_child)
1917 g_return_if_fail (list != NULL);
1918 g_return_if_fail (GTK_IS_LIST (list));
1920 if (list->selection_mode != GTK_SELECTION_EXTENDED || list->anchor >= 0)
1923 g_list_free (list->undo_selection);
1924 g_list_free (list->undo_unselection);
1925 list->undo_selection = NULL;
1926 list->undo_unselection = NULL;
1928 if ((work = g_list_nth (list->children, anchor)))
1931 gtk_list_fake_toggle_row (list, GTK_WIDGET (work->data));
1934 gtk_list_fake_unselect_all (list, GTK_WIDGET (work->data));
1935 list->anchor_state = GTK_STATE_SELECTED;
1939 list->anchor = anchor;
1940 list->drag_pos = anchor;
1941 list->undo_focus_child = undo_focus_child;
1945 gtk_list_fake_unselect_all (GtkList *list,
1950 if (item && item->state == GTK_STATE_NORMAL)
1951 gtk_widget_set_state (item, GTK_STATE_SELECTED);
1953 list->undo_selection = list->selection;
1954 list->selection = NULL;
1956 for (work = list->undo_selection; work; work = work->next)
1957 if (work->data != item)
1958 gtk_widget_set_state (GTK_WIDGET (work->data), GTK_STATE_NORMAL);
1962 gtk_list_fake_toggle_row (GtkList *list,
1968 if (item->state == GTK_STATE_NORMAL)
1970 list->anchor_state = GTK_STATE_SELECTED;
1971 gtk_widget_set_state (item, GTK_STATE_SELECTED);
1975 list->anchor_state = GTK_STATE_NORMAL;
1976 gtk_widget_set_state (item, GTK_STATE_NORMAL);
1981 gtk_list_update_extended_selection (GtkList *list,
1995 length = g_list_length (list->children);
1999 if (list->selection_mode != GTK_SELECTION_EXTENDED || !list->anchor < 0)
2002 /* extending downwards */
2003 if (row > list->drag_pos && list->anchor <= list->drag_pos)
2005 s2 = list->drag_pos + 1;
2008 /* extending upwards */
2009 else if (row < list->drag_pos && list->anchor >= list->drag_pos)
2012 e2 = list->drag_pos - 1;
2014 else if (row < list->drag_pos && list->anchor < list->drag_pos)
2016 e1 = list->drag_pos;
2017 /* row and drag_pos on different sides of anchor :
2018 take back the selection between anchor and drag_pos,
2019 select between anchor and row */
2020 if (row < list->anchor)
2022 s1 = list->anchor + 1;
2024 e2 = list->anchor - 1;
2026 /* take back the selection between anchor and drag_pos */
2030 else if (row > list->drag_pos && list->anchor > list->drag_pos)
2032 s1 = list->drag_pos;
2033 /* row and drag_pos on different sides of anchor :
2034 take back the selection between anchor and drag_pos,
2035 select between anchor and row */
2036 if (row > list->anchor)
2038 e1 = list->anchor - 1;
2039 s2 = list->anchor + 1;
2042 /* take back the selection between anchor and drag_pos */
2047 list->drag_pos = row;
2049 /* restore the elements between s1 and e1 */
2052 for (i = s1, work = g_list_nth (list->children, i); i <= e1;
2053 i++, work = work->next)
2055 if (g_list_find (list->selection, work->data))
2056 gtk_widget_set_state (GTK_WIDGET (work->data), GTK_STATE_SELECTED);
2058 gtk_widget_set_state (GTK_WIDGET (work->data), GTK_STATE_NORMAL);
2062 /* extend the selection between s2 and e2 */
2065 for (i = s2, work = g_list_nth (list->children, i); i <= e2;
2066 i++, work = work->next)
2067 if (GTK_WIDGET (work->data)->state != list->anchor_state)
2068 gtk_widget_set_state (GTK_WIDGET (work->data), list->anchor_state);
2073 /* Public GtkList Scroll Methods :
2075 * gtk_list_scroll_horizontal
2076 * gtk_list_scroll_vertical
2079 gtk_list_scroll_horizontal (GtkList *list,
2080 GtkScrollType scroll_type,
2085 g_return_if_fail (list != 0);
2086 g_return_if_fail (GTK_IS_LIST (list));
2088 if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list))
2092 gtk_object_get_data_by_id (GTK_OBJECT (list), hadjustment_key_id)))
2095 switch (scroll_type)
2097 case GTK_SCROLL_STEP_BACKWARD:
2098 adj->value = CLAMP (adj->value - adj->step_increment, adj->lower,
2099 adj->upper - adj->page_size);
2101 case GTK_SCROLL_STEP_FORWARD:
2102 adj->value = CLAMP (adj->value + adj->step_increment, adj->lower,
2103 adj->upper - adj->page_size);
2105 case GTK_SCROLL_PAGE_BACKWARD:
2106 adj->value = CLAMP (adj->value - adj->page_increment, adj->lower,
2107 adj->upper - adj->page_size);
2109 case GTK_SCROLL_PAGE_FORWARD:
2110 adj->value = CLAMP (adj->value + adj->page_increment, adj->lower,
2111 adj->upper - adj->page_size);
2113 case GTK_SCROLL_JUMP:
2114 adj->value = CLAMP (adj->lower + (adj->upper - adj->lower) * position,
2115 adj->lower, adj->upper - adj->page_size);
2120 gtk_adjustment_value_changed (adj);
2124 gtk_list_scroll_vertical (GtkList *list,
2125 GtkScrollType scroll_type,
2128 g_return_if_fail (list != NULL);
2129 g_return_if_fail (GTK_IS_LIST (list));
2131 if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (list))
2134 if (list->selection_mode == GTK_SELECTION_EXTENDED)
2136 GtkContainer *container;
2138 if (list->anchor >= 0)
2141 container = GTK_CONTAINER (list);
2142 list->undo_focus_child = container->focus_child;
2143 gtk_list_move_focus_child (list, scroll_type, position);
2144 if (container->focus_child != list->undo_focus_child && !list->add_mode)
2146 gtk_list_unselect_all (list);
2147 gtk_list_select_child (list, container->focus_child);
2151 gtk_list_move_focus_child (list, scroll_type, position);
2155 /* Private GtkList Scroll/Focus Functions :
2157 * gtk_list_move_focus_child
2158 * gtk_list_horizontal_timeout
2159 * gtk_list_vertical_timeout
2162 gtk_list_move_focus_child (GtkList *list,
2163 GtkScrollType scroll_type,
2166 GtkContainer *container;
2172 g_return_if_fail (list != 0);
2173 g_return_if_fail (GTK_IS_LIST (list));
2175 container = GTK_CONTAINER (list);
2177 if (container->focus_child)
2178 work = g_list_find (list->children, container->focus_child);
2180 work = list->children;
2185 switch (scroll_type)
2187 case GTK_SCROLL_STEP_BACKWARD:
2190 gtk_widget_grab_focus (GTK_WIDGET (work->data));
2193 case GTK_SCROLL_STEP_FORWARD:
2196 gtk_widget_grab_focus (GTK_WIDGET (work->data));
2199 case GTK_SCROLL_PAGE_BACKWARD:
2204 adj = gtk_object_get_data_by_id (GTK_OBJECT (list), vadjustment_key_id);
2208 gboolean correct = FALSE;
2210 new_value = adj->value;
2212 if (item->allocation.y <= adj->value)
2214 new_value = MAX (item->allocation.y + item->allocation.height
2215 - adj->page_size, adj->lower);
2219 if (item->allocation.y > new_value)
2220 for (; work; work = work->prev)
2222 item = GTK_WIDGET (work->data);
2223 if (item->allocation.y <= new_value &&
2224 item->allocation.y + item->allocation.height > new_value)
2228 for (; work; work = work->next)
2230 item = GTK_WIDGET (work->data);
2231 if (item->allocation.y <= new_value &&
2232 item->allocation.y + item->allocation.height > new_value)
2236 if (correct && work && work->next && item->allocation.y < new_value)
2237 item = work->next->data;
2240 item = list->children->data;
2242 gtk_widget_grab_focus (item);
2245 case GTK_SCROLL_PAGE_FORWARD:
2250 adj = gtk_object_get_data_by_id (GTK_OBJECT (list), vadjustment_key_id);
2254 gboolean correct = FALSE;
2256 new_value = adj->value;
2258 if (item->allocation.y + item->allocation.height >=
2259 adj->value + adj->page_size)
2261 new_value = item->allocation.y;
2265 new_value = MIN (new_value + adj->page_size, adj->upper);
2267 if (item->allocation.y > new_value)
2268 for (; work; work = work->prev)
2270 item = GTK_WIDGET (work->data);
2271 if (item->allocation.y <= new_value &&
2272 item->allocation.y + item->allocation.height > new_value)
2276 for (; work; work = work->next)
2278 item = GTK_WIDGET (work->data);
2279 if (item->allocation.y <= new_value &&
2280 item->allocation.y + item->allocation.height > new_value)
2284 if (correct && work && work->prev &&
2285 item->allocation.y + item->allocation.height - 1 > new_value)
2286 item = work->prev->data;
2289 item = g_list_last (work)->data;
2291 gtk_widget_grab_focus (item);
2294 case GTK_SCROLL_JUMP:
2295 new_value = GTK_WIDGET(list)->allocation.height * CLAMP (position, 0, 1);
2297 for (item = NULL, work = list->children; work; work =work->next)
2299 item = GTK_WIDGET (work->data);
2300 if (item->allocation.y <= new_value &&
2301 item->allocation.y + item->allocation.height > new_value)
2305 gtk_widget_grab_focus (item);
2314 gtk_list_horizontal_timeout (GtkWidget *list)
2317 GdkEventMotion event;
2318 GdkModifierType mask;
2320 GDK_THREADS_ENTER ();
2322 GTK_LIST (list)->htimer = 0;
2323 gdk_window_get_pointer (list->window, &x, &y, &mask);
2330 gtk_list_motion_notify (list, &event);
2332 GDK_THREADS_LEAVE ();
2338 gtk_list_vertical_timeout (GtkWidget *list)
2342 GdkEventMotion event;
2343 GdkModifierType mask;
2345 GDK_THREADS_ENTER ();
2347 GTK_LIST (list)->vtimer = 0;
2348 gdk_window_get_pointer (list->window, &x, &y, &mask);
2355 gtk_list_motion_notify (list, &event);
2357 GDK_THREADS_LEAVE ();
2363 /* Private GtkListItem Signal Functions :
2365 * gtk_list_signal_focus_lost
2366 * gtk_list_signal_toggle_focus_row
2367 * gtk_list_signal_select_all
2368 * gtk_list_signal_unselect_all
2369 * gtk_list_signal_undo_selection
2370 * gtk_list_signal_start_selection
2371 * gtk_list_signal_end_selection
2372 * gtk_list_signal_extend_selection
2373 * gtk_list_signal_scroll_horizontal
2374 * gtk_list_signal_scroll_vertical
2375 * gtk_list_signal_toggle_add_mode
2376 * gtk_list_signal_item_select
2377 * gtk_list_signal_item_deselect
2378 * gtk_list_signal_item_toggle
2381 gtk_list_signal_focus_lost (GtkWidget *item,
2385 g_return_if_fail (list != NULL);
2386 g_return_if_fail (GTK_IS_LIST (list));
2387 g_return_if_fail (item != NULL);
2388 g_return_if_fail (GTK_IS_LIST_ITEM (item));
2390 if (list->selection_mode == GTK_SELECTION_EXTENDED &&
2391 list->anchor >= 0 &&
2392 item == GTK_CONTAINER (list)->focus_child)
2393 gtk_list_end_selection (list);
2397 gtk_list_signal_toggle_focus_row (GtkListItem *list_item,
2400 g_return_if_fail (list_item != 0);
2401 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2402 g_return_if_fail (list != NULL);
2403 g_return_if_fail (GTK_IS_LIST (list));
2405 gtk_list_toggle_focus_row (list);
2409 gtk_list_signal_select_all (GtkListItem *list_item,
2412 g_return_if_fail (list_item != 0);
2413 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2414 g_return_if_fail (list != NULL);
2415 g_return_if_fail (GTK_IS_LIST (list));
2417 gtk_list_select_all (list);
2421 gtk_list_signal_unselect_all (GtkListItem *list_item,
2424 g_return_if_fail (list_item != 0);
2425 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2426 g_return_if_fail (list != NULL);
2427 g_return_if_fail (GTK_IS_LIST (list));
2429 gtk_list_unselect_all (list);
2433 gtk_list_signal_undo_selection (GtkListItem *list_item,
2436 g_return_if_fail (list_item != 0);
2437 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2438 g_return_if_fail (list != NULL);
2439 g_return_if_fail (GTK_IS_LIST (list));
2441 gtk_list_undo_selection (list);
2445 gtk_list_signal_start_selection (GtkListItem *list_item,
2448 g_return_if_fail (list_item != 0);
2449 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2450 g_return_if_fail (list != NULL);
2451 g_return_if_fail (GTK_IS_LIST (list));
2453 gtk_list_start_selection (list);
2457 gtk_list_signal_end_selection (GtkListItem *list_item,
2460 g_return_if_fail (list_item != 0);
2461 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2462 g_return_if_fail (list != NULL);
2463 g_return_if_fail (GTK_IS_LIST (list));
2465 gtk_list_end_selection (list);
2469 gtk_list_signal_extend_selection (GtkListItem *list_item,
2470 GtkScrollType scroll_type,
2472 gboolean auto_start_selection,
2475 g_return_if_fail (list_item != 0);
2476 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2477 g_return_if_fail (list != NULL);
2478 g_return_if_fail (GTK_IS_LIST (list));
2480 gtk_list_extend_selection (list, scroll_type, position,
2481 auto_start_selection);
2485 gtk_list_signal_scroll_horizontal (GtkListItem *list_item,
2486 GtkScrollType scroll_type,
2490 g_return_if_fail (list_item != 0);
2491 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2492 g_return_if_fail (list != NULL);
2493 g_return_if_fail (GTK_IS_LIST (list));
2495 gtk_list_scroll_horizontal (list, scroll_type, position);
2499 gtk_list_signal_scroll_vertical (GtkListItem *list_item,
2500 GtkScrollType scroll_type,
2504 g_return_if_fail (list_item != 0);
2505 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2506 g_return_if_fail (list != NULL);
2507 g_return_if_fail (GTK_IS_LIST (list));
2509 gtk_list_scroll_vertical (list, scroll_type, position);
2513 gtk_list_signal_toggle_add_mode (GtkListItem *list_item,
2516 g_return_if_fail (list_item != 0);
2517 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2518 g_return_if_fail (list != NULL);
2519 g_return_if_fail (GTK_IS_LIST (list));
2521 gtk_list_toggle_add_mode (list);
2525 gtk_list_signal_item_select (GtkListItem *list_item,
2532 g_return_if_fail (list_item != 0);
2533 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2534 g_return_if_fail (list != NULL);
2535 g_return_if_fail (GTK_IS_LIST (list));
2537 if (GTK_WIDGET (list_item)->state != GTK_STATE_SELECTED)
2540 switch (list->selection_mode)
2542 case GTK_SELECTION_SINGLE:
2543 case GTK_SELECTION_BROWSE:
2545 selection = list->selection;
2549 tmp_list = selection;
2550 selection = selection->next;
2552 if (tmp_list->data == list_item)
2553 sel_list = tmp_list;
2555 gtk_list_item_deselect (GTK_LIST_ITEM (tmp_list->data));
2560 list->selection = g_list_prepend (list->selection, list_item);
2561 gtk_widget_ref (GTK_WIDGET (list_item));
2563 gtk_signal_emit (GTK_OBJECT (list), list_signals[SELECTION_CHANGED]);
2565 case GTK_SELECTION_EXTENDED:
2566 if (list->anchor >= 0)
2568 case GTK_SELECTION_MULTIPLE:
2569 if (!g_list_find (list->selection, list_item))
2571 list->selection = g_list_prepend (list->selection, list_item);
2572 gtk_widget_ref (GTK_WIDGET (list_item));
2573 gtk_signal_emit (GTK_OBJECT (list), list_signals[SELECTION_CHANGED]);
2580 gtk_list_signal_item_deselect (GtkListItem *list_item,
2585 g_return_if_fail (list_item != 0);
2586 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2587 g_return_if_fail (list != NULL);
2588 g_return_if_fail (GTK_IS_LIST (list));
2590 if (GTK_WIDGET (list_item)->state != GTK_STATE_NORMAL)
2593 node = g_list_find (list->selection, list_item);
2597 list->selection = g_list_remove_link (list->selection, node);
2598 g_list_free_1 (node);
2599 gtk_widget_unref (GTK_WIDGET (list_item));
2600 gtk_signal_emit (GTK_OBJECT (list), list_signals[SELECTION_CHANGED]);
2605 gtk_list_signal_item_toggle (GtkListItem *list_item,
2608 g_return_if_fail (list_item != 0);
2609 g_return_if_fail (GTK_IS_LIST_ITEM (list_item));
2610 g_return_if_fail (list != NULL);
2611 g_return_if_fail (GTK_IS_LIST (list));
2613 switch (GTK_WIDGET (list_item)->state)
2615 case GTK_STATE_SELECTED:
2616 gtk_list_signal_item_select (list_item, list);
2618 case GTK_STATE_NORMAL:
2619 gtk_list_signal_item_deselect (list_item, list);
2627 gtk_list_signal_drag_begin (GtkWidget *widget,
2628 GdkDragContext *context,
2631 g_return_if_fail (widget != NULL);
2632 g_return_if_fail (GTK_IS_LIST_ITEM (widget));
2633 g_return_if_fail (list != NULL);
2634 g_return_if_fail (GTK_IS_LIST (list));
2636 gtk_list_drag_begin (GTK_WIDGET (list), context);
2640 gtk_list_drag_begin (GtkWidget *widget,
2641 GdkDragContext *context)
2645 g_return_if_fail (widget != NULL);
2646 g_return_if_fail (GTK_IS_LIST (widget));
2647 g_return_if_fail (context != NULL);
2649 list = GTK_LIST (widget);
2651 if (list->drag_selection)
2653 gtk_list_end_drag_selection (list);
2655 switch (list->selection_mode)
2657 case GTK_SELECTION_EXTENDED:
2658 gtk_list_end_selection (list);
2660 case GTK_SELECTION_SINGLE:
2661 case GTK_SELECTION_MULTIPLE:
2662 list->undo_focus_child = NULL;