?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r1601: Turned on more compiler warnings, and fixed some minor issues it threw up.
[rox-filer.git] / ROX-Filer / src / collection.c
blob756a21f8f78eaefd721fb18ee78599e8a5fc6283
1 /*
2 * $Id$
3 *
4 * Collection - a GTK+ widget
5 * Copyright (C) 2002, the ROX-Filer team.
6 *
7 * The collection widget provides an area for displaying a collection of
8 * objects (such as files). It allows the user to choose a selection of
9 * them and provides signals to allow popping up menus, detecting
10 * double-clicks etc.
11 *
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License as published by the Free
14 * Software Foundation; either version 2 of the License, or (at your option)
15 * any later version.
16 *
17 * This program is distributed in the hope that it will be useful, but WITHOUT
18 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
19 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
20 * more details.
21 *
22 * You should have received a copy of the GNU General Public License along with
23 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
24 * Place, Suite 330, Boston, MA 02111-1307 USA
25 */
26
27 #include "config.h"
28
29 #include <stdlib.h>
30
31 #include <gtk/gtk.h>
32 #include <gdk/gdkkeysyms.h>
33 #include "global.h"
34
35 #include "collection.h"
36
37 #define MIN_WIDTH 80
38 #define MIN_HEIGHT 60
39 #define MINIMUM_ITEMS 16
40 #define AUTOSCROLL_STEP 20
41
42 #define MAX_WINKS 3 /* Should be an odd number */
43
44 /* Macro to emit the "selection_changed" signal only if allowed */
45 #define EMIT_SELECTION_CHANGED(collection, time) \
46 if (!collection->block_selection_changed) \
47 g_signal_emit(collection, \
48 collection_signals[SELECTION_CHANGED], 0, time)
49
50 enum
51 {
52 PROP_0,
53 PROP_VADJUSTMENT
54 };
55
56 /* Signals:
57 *
58 * void gain_selection(collection, time, user_data)
59 * We've gone from no selected items to having a selection.
60 * Time is the time of the event that caused the change, or
61 * GDK_CURRENT_TIME if not known.
62 *
63 * void lose_selection(collection, time, user_data)
64 * We've dropped to having no selected items.
65 * Time is the time of the event that caused the change, or
66 * GDK_CURRENT_TIME if not known.
67 *
68 * void selection_changed(collection, user_data)
69 * The set of selected items has changed.
70 * Time is the time of the event that caused the change, or
71 * GDK_CURRENT_TIME if not known.
72 */
73 enum
74 {
75 GAIN_SELECTION,
76 LOSE_SELECTION,
77 SELECTION_CHANGED,
78 LAST_SIGNAL
79 };
80
81 static guint collection_signals[LAST_SIGNAL] = { 0 };
82
83 static guint32 current_event_time = GDK_CURRENT_TIME;
84
85 static GtkWidgetClass *parent_class = NULL;
86
87 /* Static prototypes */
88 static void draw_one_item(Collection *collection,
89 int item,
90 GdkRectangle *area);
91 static void collection_class_init(GObjectClass *gclass, gpointer data);
92 static void collection_init(GTypeInstance *object, gpointer g_class);
93 static void collection_destroy(GtkObject *object);
94 static void collection_finalize(GObject *object);
95 static void collection_realize(GtkWidget *widget);
96 static void collection_map(GtkWidget *widget);
97 static void collection_size_request(GtkWidget *widget,
98 GtkRequisition *requisition);
99 static void collection_size_allocate(GtkWidget *widget,
100 GtkAllocation *allocation);
101 static void collection_set_adjustment(Collection *collection,
102 GtkAdjustment *vadj);
103 static void collection_get_property(GObject *object,
104 guint prop_id,
105 GValue *value,
106 GParamSpec *pspec);
107 static void collection_set_property(GObject *object,
108 guint prop_id,
109 const GValue *value,
110 GParamSpec *pspec);
111 static gint collection_expose(GtkWidget *widget, GdkEventExpose *event);
112 static void default_draw_item(GtkWidget *widget,
113 CollectionItem *data,
114 GdkRectangle *area,
115 gpointer user_data);
116 static gboolean default_test_point(Collection *collection,
117 int point_x, int point_y,
118 CollectionItem *data,
119 int width, int height,
120 gpointer user_data);
121 static gint collection_motion_notify(GtkWidget *widget,
122 GdkEventMotion *event);
123 static void add_lasso_box(Collection *collection);
124 static void abort_lasso(Collection *collection);
125 static void remove_lasso_box(Collection *collection);
126 static void draw_lasso_box(Collection *collection);
127 static void cancel_wink(Collection *collection);
128 static gint collection_key_press(GtkWidget *widget, GdkEventKey *event);
129 static void get_visible_limits(Collection *collection, int *first, int *last);
130 static void scroll_to_show(Collection *collection, int item);
131 static void collection_item_set_selected(Collection *collection,
132 gint item,
133 gboolean selected,
134 gboolean signal);
135 static void collection_drag_leave(GtkWidget *widget, GdkDragContext *context,
136 guint time);
137 static void collection_drag_end(GtkWidget *widget, GdkDragContext *context);
138 static gboolean collection_drag_motion(GtkWidget *widget, GdkDragContext
139 *context, gint x, gint y, guint time);
140 static gint collection_scroll_event(GtkWidget *widget, GdkEventScroll *event);
141
142 static void draw_focus_at(Collection *collection, GdkRectangle *area)
143 {
144 GtkWidget *widget;
145 GdkGC *gc;
146
147 widget = GTK_WIDGET(collection);
148
149 if (GTK_WIDGET_FLAGS(widget) & GTK_HAS_FOCUS)
150 gc = widget->style->fg_gc[GTK_STATE_ACTIVE];
151 else
152 gc = widget->style->fg_gc[GTK_STATE_INSENSITIVE];
153
154 gdk_draw_rectangle(widget->window, gc, FALSE,
155 area->x, area->y,
156 collection->item_width - 1,
157 area->height - 1);
158 }
159
160 static void draw_one_item(Collection *collection, int item, GdkRectangle *area)
161 {
162 if (item < collection->number_of_items)
163 {
164 collection->draw_item((GtkWidget *) collection,
165 &collection->items[item],
166 area, collection->cb_user_data);
167 }
168
169 if (item == collection->cursor_item)
170 draw_focus_at(collection, area);
171 }
172
173 GType collection_get_type(void)
174 {
175 static GType my_type = 0;
176
177 if (!my_type)
178 {
179 static const GTypeInfo info =
180 {
181 sizeof(CollectionClass),
182 NULL, /* base_init */
183 NULL, /* base_finalise */
184 (GClassInitFunc) collection_class_init,
185 NULL, /* class_finalise */
186 NULL, /* class_data */
187 sizeof(Collection),
188 0, /* n_preallocs */
189 collection_init
190 };
191
192 my_type = g_type_register_static(gtk_widget_get_type(),
193 "Collection", &info, 0);
194 }
195
196 return my_type;
197 }
198
199 typedef void (*FinalizeFn)(GObject *object);
200
201 static void collection_class_init(GObjectClass *gclass, gpointer data)
202 {
203 CollectionClass *collection_class = (CollectionClass *) gclass;
204 GtkObjectClass *object_class = (GtkObjectClass *) gclass;
205 GtkWidgetClass *widget_class = (GtkWidgetClass *) gclass;
206
207 parent_class = gtk_type_class(gtk_widget_get_type());
208
209 object_class->destroy = collection_destroy;
210 G_OBJECT_CLASS(object_class)->finalize =
211 (FinalizeFn) collection_finalize;
212
213 widget_class->realize = collection_realize;
214 widget_class->expose_event = collection_expose;
215 widget_class->size_request = collection_size_request;
216 widget_class->size_allocate = collection_size_allocate;
217
218 widget_class->key_press_event = collection_key_press;
219
220 widget_class->motion_notify_event = collection_motion_notify;
221 widget_class->map = collection_map;
222 widget_class->scroll_event = collection_scroll_event;
223 widget_class->drag_motion = collection_drag_motion;
224 widget_class->drag_leave = collection_drag_leave;
225 widget_class->drag_end = collection_drag_end;
226
227 gclass->set_property = collection_set_property;
228 gclass->get_property = collection_get_property;
229
230 collection_class->gain_selection = NULL;
231 collection_class->lose_selection = NULL;
232 collection_class->selection_changed = NULL;
233
234 collection_signals[GAIN_SELECTION] = g_signal_new("gain_selection",
235 G_TYPE_FROM_CLASS(gclass),
236 G_SIGNAL_RUN_LAST,
237 G_STRUCT_OFFSET(CollectionClass,
238 gain_selection),
239 NULL, NULL,
240 g_cclosure_marshal_VOID__INT,
241 G_TYPE_NONE, 1,
242 G_TYPE_INT);
243
244 collection_signals[LOSE_SELECTION] = g_signal_new("lose_selection",
245 G_TYPE_FROM_CLASS(gclass),
246 G_SIGNAL_RUN_LAST,
247 G_STRUCT_OFFSET(CollectionClass,
248 lose_selection),
249 NULL, NULL,
250 g_cclosure_marshal_VOID__INT,
251 G_TYPE_NONE, 1,
252 G_TYPE_INT);
253
254 collection_signals[SELECTION_CHANGED] = g_signal_new(
255 "selection_changed",
256 G_TYPE_FROM_CLASS(gclass),
257 G_SIGNAL_RUN_LAST,
258 G_STRUCT_OFFSET(CollectionClass,
259 selection_changed),
260 NULL, NULL,
261 g_cclosure_marshal_VOID__INT,
262 G_TYPE_NONE, 1,
263 G_TYPE_INT);
264
265 g_object_class_install_property(gclass,
266 PROP_VADJUSTMENT,
267 g_param_spec_object("vadjustment",
268 _("Vertical Adjustment"),
269 _("The GtkAdjustment for the vertical position."),
270 GTK_TYPE_ADJUSTMENT,
271 G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
272 }
273
274 static void collection_init(GTypeInstance *instance, gpointer g_class)
275 {
276 Collection *object = (Collection *) instance;
277
278 g_return_if_fail(object != NULL);
279 g_return_if_fail(IS_COLLECTION(object));
280
281 GTK_WIDGET_SET_FLAGS(GTK_WIDGET(object), GTK_CAN_FOCUS);
282
283 object->number_of_items = 0;
284 object->number_selected = 0;
285 object->block_selection_changed = 0;
286 object->columns = 1;
287 object->item_width = 64;
288 object->item_height = 64;
289 object->vadj = NULL;
290
291 object->items = g_new(CollectionItem, MINIMUM_ITEMS);
292 object->cursor_item = -1;
293 object->cursor_item_old = -1;
294 object->wink_item = -1;
295 object->wink_on_map = -1;
296 object->array_size = MINIMUM_ITEMS;
297 object->draw_item = default_draw_item;
298 object->test_point = default_test_point;
299 object->free_item = NULL;
300
301 object->auto_scroll = -1;
302 }
303
304 GtkWidget* collection_new(void)
305 {
306 return GTK_WIDGET(gtk_widget_new(collection_get_type(), NULL));
307 }
308
309 /* After this we are unusable, but our data (if any) is still hanging around.
310 * It will be freed later with finalize.
311 */
312 static void collection_destroy(GtkObject *object)
313 {
314 Collection *collection;
315
316 g_return_if_fail(object != NULL);
317 g_return_if_fail(IS_COLLECTION(object));
318
319 collection = COLLECTION(object);
320
321 collection_clear(collection);
322
323 if (collection->auto_scroll != -1)
324 {
325 gtk_timeout_remove(collection->auto_scroll);
326 collection->auto_scroll = -1;
327 }
328
329 if (collection->vadj)
330 {
331 g_object_unref(G_OBJECT(collection->vadj));
332 collection->vadj = NULL;
333 }
334
335 if (GTK_OBJECT_CLASS(parent_class)->destroy)
336 (*GTK_OBJECT_CLASS(parent_class)->destroy)(object);
337 }
338
339 /* This is the last thing that happens to us. Free all data. */
340 static void collection_finalize(GObject *object)
341 {
342 Collection *collection;
343
344 collection = COLLECTION(object);
345
346 g_return_if_fail(collection->number_of_items == 0);
347
348 g_free(collection->items);
349
350 if (G_OBJECT_CLASS(parent_class)->finalize)
351 G_OBJECT_CLASS(parent_class)->finalize(object);
352 }
353
354 static void collection_drag_leave(GtkWidget *widget, GdkDragContext *context,
355 guint time)
356 {
357 Collection *collection = COLLECTION(widget);
358
359 /* Note that this isn't always called when the pointer leaves the
360 * widget; only if we highlighted an item at some point.
361 */
362
363 /* collection_set_autoscroll(collection, FALSE); - not needed? */
364 collection_set_cursor_item(collection, -1);
365
366 if (GTK_WIDGET_CLASS(parent_class)->drag_leave)
367 (*GTK_WIDGET_CLASS(parent_class)->drag_leave)(widget, context,
368 time);
369 }
370
371 /* Turn on auto scrolling */
372 static gboolean collection_drag_motion(GtkWidget *widget, GdkDragContext
373 *context, gint x, gint y, guint time)
374 {
375 Collection *collection = COLLECTION(widget);
376
377 collection_set_autoscroll(collection, TRUE);
378
379 if (GTK_WIDGET_CLASS(parent_class)->drag_motion)
380 return (*GTK_WIDGET_CLASS(parent_class)->drag_motion)(widget,
381 context, x, y, time);
382 return FALSE;
383 }
384
385 /* Turn off auto scrolling.
386 * (do we need this AND drag_leave?)
387 */
388 static void collection_drag_end(GtkWidget *widget, GdkDragContext *context)
389 {
390 Collection *collection = COLLECTION(widget);
391
392 collection_set_autoscroll(collection, FALSE);
393
394 if (GTK_WIDGET_CLASS(parent_class)->drag_end)
395 (*GTK_WIDGET_CLASS(parent_class)->drag_end)(widget, context);
396 }
397
398 static void collection_map(GtkWidget *widget)
399 {
400 Collection *collection = COLLECTION(widget);
401
402 if (GTK_WIDGET_CLASS(parent_class)->map)
403 (*GTK_WIDGET_CLASS(parent_class)->map)(widget);
404
405 if (collection->wink_on_map >= 0)
406 {
407 collection_wink_item(collection, collection->wink_on_map);
408 collection->wink_on_map = -1;
409 }
410 }
411
412 static void collection_realize(GtkWidget *widget)
413 {
414 Collection *collection;
415 GdkWindowAttr attributes;
416 gint attributes_mask;
417 GdkGCValues xor_values;
418 GdkColor *bg, *fg;
419
420 g_return_if_fail(widget != NULL);
421 g_return_if_fail(IS_COLLECTION(widget));
422 g_return_if_fail(widget->parent != NULL);
423
424 GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
425 collection = COLLECTION(widget);
426
427 attributes.x = widget->allocation.x;
428 attributes.y = widget->allocation.y;
429 attributes.width = widget->allocation.width;
430 attributes.height = widget->allocation.height;
431 attributes.wclass = GDK_INPUT_OUTPUT;
432 attributes.window_type = GDK_WINDOW_CHILD;
433 attributes.event_mask = gtk_widget_get_events(widget) |
434 GDK_EXPOSURE_MASK |
435 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
436 GDK_BUTTON1_MOTION_MASK | GDK_BUTTON2_MOTION_MASK |
437 GDK_BUTTON3_MOTION_MASK;
438 attributes.visual = gtk_widget_get_visual(widget);
439 attributes.colormap = gtk_widget_get_colormap(widget);
440
441 attributes_mask = GDK_WA_X | GDK_WA_Y |
442 GDK_WA_VISUAL | GDK_WA_COLORMAP;
443 widget->window = gdk_window_new(gtk_widget_get_parent_window(widget),
444 &attributes, attributes_mask);
445
446 widget->style = gtk_style_attach(widget->style, widget->window);
447
448 gdk_window_set_user_data(widget->window, widget);
449 gdk_window_set_background(widget->window,
450 &widget->style->bg[GTK_STATE_NORMAL]);
451
452 bg = &widget->style->bg[GTK_STATE_NORMAL];
453 fg = &widget->style->fg[GTK_STATE_NORMAL];
454 xor_values.function = GDK_XOR;
455 xor_values.foreground.pixel = fg->pixel ^ bg->pixel;
456 collection->xor_gc = gdk_gc_new_with_values(widget->window,
457 &xor_values,
458 GDK_GC_FOREGROUND
459 | GDK_GC_FUNCTION);
460 }
461
462 static void collection_size_request(GtkWidget *widget,
463 GtkRequisition *requisition)
464 {
465 Collection *collection = COLLECTION(widget);
466 int rows, cols = collection->columns;
467
468 /* We ask for the total size we need; our containing viewport
469 * will deal with scrolling.
470 */
471 requisition->width = MIN_WIDTH;
472 rows = (collection->number_of_items + cols - 1) / cols;
473 requisition->height = rows * collection->item_height;
474 }
475
476 static gboolean scroll_after_alloc(Collection *collection)
477 {
478 if (collection->wink_item != -1)
479 scroll_to_show(collection, collection->wink_item);
480 else if (collection->cursor_item != -1)
481 scroll_to_show(collection, collection->cursor_item);
482 g_object_unref(G_OBJECT(collection));
483
484 return FALSE;
485 }
486
487 static void collection_size_allocate(GtkWidget *widget,
488 GtkAllocation *allocation)
489 {
490 Collection *collection;
491 int old_columns;
492 gboolean cursor_visible = FALSE;
493
494 g_return_if_fail(widget != NULL);
495 g_return_if_fail(IS_COLLECTION(widget));
496 g_return_if_fail(allocation != NULL);
497
498 collection = COLLECTION(widget);
499
500 if (collection->cursor_item != -1)
501 {
502 int first, last;
503 int crow = collection->cursor_item / collection->columns;
504
505 get_visible_limits(collection, &first, &last);
506
507 cursor_visible = crow >= first && crow <= last;
508 }
509
510 old_columns = collection->columns;
511
512 widget->allocation = *allocation;
513
514 collection->columns = allocation->width / collection->item_width;
515 if (collection->columns < 1)
516 collection->columns = 1;
517
518 if (GTK_WIDGET_REALIZED(widget))
519 {
520 gdk_window_move_resize(widget->window,
521 allocation->x, allocation->y,
522 allocation->width, allocation->height);
523
524 if (cursor_visible)
525 scroll_to_show(collection, collection->cursor_item);
526 }
527
528 if (old_columns != collection->columns)
529 {
530 /* Need to go around again... */
531 gtk_widget_queue_resize(widget);
532 }
533 else if (collection->wink_item != -1 || collection->cursor_item != -1)
534 {
535 /* Viewport resets the adjustments after the alloc */
536 g_object_ref(G_OBJECT(collection));
537 g_idle_add((GSourceFunc) scroll_after_alloc, collection);
538 }
539 }
540
541 /* Return the area occupied by the item at (row, col) by filling
542 * in 'area'.
543 */
544 static void collection_get_item_area(Collection *collection,
545 int row, int col,
546 GdkRectangle *area)
547
548 {
549 area->x = col * collection->item_width;
550 area->y = row * collection->item_height;
551
552 area->width = collection->item_width;
553 area->height = collection->item_height;
554 if (col == collection->columns - 1)
555 area->width <<= 1;
556 }
557
558 static gint collection_expose(GtkWidget *widget, GdkEventExpose *event)
559 {
560 Collection *collection;
561 GdkRectangle item_area;
562 int row, col;
563 int item;
564 int start_row, last_row;
565 int start_col, last_col;
566 int phys_last_col;
567
568 g_return_val_if_fail(widget != NULL, FALSE);
569 g_return_val_if_fail(IS_COLLECTION(widget), FALSE);
570 g_return_val_if_fail(event != NULL, FALSE);
571
572 gtk_paint_flat_box(widget->style, widget->window, GTK_STATE_NORMAL,
573 GTK_SHADOW_NONE, &event->area,
574 widget, "base", 0, 0, -1, -1);
575
576 collection = COLLECTION(widget);
577
578 /* Calculate the ranges to plot */
579 start_row = event->area.y / collection->item_height;
580 last_row = (event->area.y + event->area.height - 1)
581 / collection->item_height;
582 row = start_row;
583
584 start_col = event->area.x / collection->item_width;
585 phys_last_col = (event->area.x + event->area.width - 1)
586 / collection->item_width;
587
588 /* The right-most column may be wider than the others.
589 * Therefore, to redraw the area after the last 'real' column
590 * we may have to draw the right-most column.
591 */
592 if (start_col >= collection->columns)
593 start_col = collection->columns - 1;
594
595 if (phys_last_col >= collection->columns)
596 last_col = collection->columns - 1;
597 else
598 last_col = phys_last_col;
599
600 col = start_col;
601
602 item = row * collection->columns + col;
603
604 while ((item == 0 || item < collection->number_of_items)
605 && row <= last_row)
606 {
607 collection_get_item_area(collection, row, col, &item_area);
608
609 draw_one_item(collection, item, &item_area);
610 col++;
611
612 if (col > last_col)
613 {
614 col = start_col;
615 row++;
616 item = row * collection->columns + col;
617 }
618 else
619 item++;
620 }
621
622 if (collection->lasso_box)
623 draw_lasso_box(collection);
624
625 return FALSE;
626 }
627
628 static void default_draw_item(GtkWidget *widget,
629 CollectionItem *item,
630 GdkRectangle *area,
631 gpointer user_data)
632 {
633 gdk_draw_arc(widget->window,
634 item->selected ? widget->style->white_gc
635 : widget->style->black_gc,
636 TRUE,
637 area->x, area->y,
638 COLLECTION(widget)->item_width, area->height,
639 0, 360 * 64);
640 }
641
642
643 static gboolean default_test_point(Collection *collection,
644 int point_x, int point_y,
645 CollectionItem *item,
646 int width, int height,
647 gpointer user_data)
648 {
649 float f_x, f_y;
650
651 /* Convert to point in unit circle */
652 f_x = ((float) point_x / width) - 0.5;
653 f_y = ((float) point_y / height) - 0.5;
654
655 return (f_x * f_x) + (f_y * f_y) <= .25;
656 }
657
658 static void collection_set_property(GObject *object,
659 guint prop_id,
660 const GValue *value,
661 GParamSpec *pspec)
662 {
663 Collection *collection;
664
665 collection = COLLECTION(object);
666
667 switch (prop_id)
668 {
669 case PROP_VADJUSTMENT:
670 collection_set_adjustment(collection,
671 g_value_get_object(value));
672 break;
673 default:
674 G_OBJECT_WARN_INVALID_PROPERTY_ID(object,
675 prop_id, pspec);
676 break;
677 }
678 }
679
680 static void collection_set_adjustment(Collection *collection,
681 GtkAdjustment *vadj)
682 {
683 if (vadj)
684 g_return_if_fail(GTK_IS_ADJUSTMENT(vadj));
685 else
686 vadj = GTK_ADJUSTMENT(gtk_adjustment_new(0.0,
687 0.0, 0.0,
688 0.0, 0.0, 0.0));
689
690 if (collection->vadj == vadj)
691 return;
692
693 if (collection->vadj)
694 g_object_unref(G_OBJECT(collection->vadj));
695
696 collection->vadj = vadj;
697 g_object_ref(G_OBJECT(collection->vadj));
698 gtk_object_sink(GTK_OBJECT(collection->vadj));
699 }
700
701 static void collection_get_property(GObject *object,
702 guint prop_id,
703 GValue *value,
704 GParamSpec *pspec)
705 {
706 Collection *collection;
707
708 collection = COLLECTION(object);
709
710 switch (prop_id)
711 {
712 case PROP_VADJUSTMENT:
713 g_value_set_object(value, G_OBJECT(collection->vadj));
714 break;
715 default:
716 G_OBJECT_WARN_INVALID_PROPERTY_ID(object,
717 prop_id, pspec);
718 break;
719 }
720 }
721
722 /* Change the adjustment by this amount. Bounded. */
723 static void diff_vpos(Collection *collection, int diff)
724 {
725 int value = collection->vadj->value + diff;
726
727 value = CLAMP(value, 0,
728 collection->vadj->upper - collection->vadj->page_size);
729 gtk_adjustment_set_value(collection->vadj, value);
730 }
731
732 static void resize_arrays(Collection *collection, guint new_size)
733 {
734 g_return_if_fail(collection != NULL);
735 g_return_if_fail(IS_COLLECTION(collection));
736 g_return_if_fail(new_size >= collection->number_of_items);
737
738 collection->items = g_realloc(collection->items,
739 sizeof(CollectionItem) * new_size);
740 collection->array_size = new_size;
741 }
742
743 static gint collection_key_press(GtkWidget *widget, GdkEventKey *event)
744 {
745 Collection *collection;
746 int item;
747 int key;
748
749 g_return_val_if_fail(widget != NULL, FALSE);
750 g_return_val_if_fail(IS_COLLECTION(widget), FALSE);
751 g_return_val_if_fail(event != NULL, FALSE);
752
753 collection = (Collection *) widget;
754 item = collection->cursor_item;
755
756 key = event->keyval;
757 if (event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK))
758 {
759 if (key == GDK_Left || key == GDK_Right || \
760 key == GDK_Up || key == GDK_Down)
761 return TRUE;
762 return FALSE;
763 }
764
765 switch (key)
766 {
767 case GDK_Left:
768 collection_move_cursor(collection, 0, -1);
769 break;
770 case GDK_Right:
771 collection_move_cursor(collection, 0, 1);
772 break;
773 case GDK_Up:
774 collection_move_cursor(collection, -1, 0);
775 break;
776 case GDK_Down:
777 collection_move_cursor(collection, 1, 0);
778 break;
779 case GDK_Home:
780 collection_set_cursor_item(collection, 0);
781 break;
782 case GDK_End:
783 collection_set_cursor_item(collection,
784 MAX((gint) collection->number_of_items - 1, 0));
785 break;
786 case GDK_Page_Up:
787 {
788 int first, last;
789 get_visible_limits(collection, &first, &last);
790 collection_move_cursor(collection, first - last - 1, 0);
791 break;
792 }
793 case GDK_Page_Down:
794 {
795 int first, last;
796 get_visible_limits(collection, &first, &last);
797 collection_move_cursor(collection, last - first + 1, 0);
798 break;
799 }
800 case GDK_Escape:
801 collection_set_cursor_item(collection, -1);
802 collection_clear_selection(collection);
803 return FALSE; /* Pass it on */
804 case ' ':
805 if (item >=0 && item < collection->number_of_items)
806 {
807 collection_toggle_item(collection, item);
808 if (item < collection->number_of_items - 1)
809 collection_set_cursor_item(collection,
810 item + 1);
811 }
812 break;
813 default:
814 return FALSE;
815 }
816
817 return TRUE;
818 }
819
820 /* Wheel mouse scrolling */
821 static gint collection_scroll_event(GtkWidget *widget, GdkEventScroll *event)
822 {
823 Collection *collection;
824 int diff = 0;
825
826 g_return_val_if_fail(widget != NULL, FALSE);
827 g_return_val_if_fail(IS_COLLECTION(widget), FALSE);
828 g_return_val_if_fail(event != NULL, FALSE);
829
830 collection = COLLECTION(widget);
831
832 if (event->direction == GDK_SCROLL_UP)
833 diff = -1;
834 else if (event->direction == GDK_SCROLL_DOWN)
835 diff = 1;
836 else
837 return FALSE;
838
839 if (diff)
840 {
841 int old_value = collection->vadj->value;
842 int new_value = 0;
843 gboolean box = collection->lasso_box;
844 int step = collection->vadj->page_increment / 2;
845
846 new_value = CLAMP(old_value + diff * step, 0.0,
847 collection->vadj->upper
848 - collection->vadj->page_size);
849 diff = new_value - old_value;
850 if (diff)
851 {
852 if (box)
853 {
854 remove_lasso_box(collection);
855 collection->drag_box_y[0] -= diff;
856 }
857 gtk_adjustment_set_value(collection->vadj, new_value);
858 if (box)
859 add_lasso_box(collection);
860 }
861 }
862
863 return TRUE;
864 }
865
866 /* 'from' and 'to' are pixel positions. 'step' is the size of each item.
867 * Returns the index of the first item covered, and the number of items.
868 */
869 static void get_range(int from, int to, int step, gint *pos, gint *len)
870 {
871 int margin = MIN(step / 4, 40);
872
873 if (from > to)
874 {
875 int tmp = to;
876 to = from;
877 from = tmp;
878 }
879
880 from = (from + margin) / step; /* First item */
881 to = (to + step - margin) / step; /* Last item (inclusive) */
882
883 *pos = MAX(from, 0);
884 *len = to - *pos;
885 }
886
887 /* Fills in the area with a rectangle corresponding to the current
888 * size of the lasso box (units of items, not pixels).
889 *
890 * The box will only span valid columns, but the total number
891 * of items is not taken into account (rows or cols).
892 */
893 static void find_lasso_area(Collection *collection, GdkRectangle *area)
894 {
895 int cols = collection->columns;
896 int dx = collection->drag_box_x[0] - collection->drag_box_x[1];
897 int dy = collection->drag_box_y[0] - collection->drag_box_y[1];
898
899 if (ABS(dx) < 8 && ABS(dy) < 8)
900 {
901 /* Didn't move far enough - ignore */
902 area->x = area->y = 0;
903 area->width = 0;
904 area->height = 0;
905 return;
906 }
907
908 get_range(collection->drag_box_x[0], collection->drag_box_x[1],
909 collection->item_width, &area->x, &area->width);
910
911 if (area->x >= cols)
912 area->width = 0;
913 else if (area->x + area->width > cols)
914 area->width = cols - area->x;
915
916 get_range(collection->drag_box_y[0], collection->drag_box_y[1],
917 collection->item_height, &area->y, &area->height);
918 }
919
920 static void collection_process_area(Collection *collection,
921 GdkRectangle *area,
922 GdkFunction fn,
923 guint32 time)
924 {
925 int x, y;
926 guint32 stacked_time;
927 int item;
928 gboolean changed = FALSE;
929 guint old_selected;
930
931 g_return_if_fail(fn == GDK_SET || fn == GDK_INVERT);
932
933 old_selected = collection->number_selected;
934
935 stacked_time = current_event_time;
936 current_event_time = time;
937
938 collection->block_selection_changed++;
939
940 for (y = area->y; y < area->y + area->height; y++)
941 {
942 item = y * collection->columns + area->x;
943
944 for (x = area->x; x < area->x + area->width; x++)
945 {
946 if (item >= collection->number_of_items)
947 goto out;
948
949 if (fn == GDK_INVERT)
950 collection_item_set_selected(collection, item,
951 !collection->items[item].selected,
952 FALSE);
953 else
954 collection_item_set_selected(collection, item,
955 TRUE, FALSE);
956
957 changed = TRUE;
958 item++;
959 }
960 }
961
962 out:
963 if (collection->number_selected && !old_selected)
964 g_signal_emit(collection,
965 collection_signals[GAIN_SELECTION], 0,
966 current_event_time);
967 else if (!collection->number_selected && old_selected)
968 g_signal_emit(collection,
969 collection_signals[LOSE_SELECTION], 0,
970 current_event_time);
971
972 collection_unblock_selection_changed(collection,
973 current_event_time, changed);
974 current_event_time = stacked_time;
975 }
976
977 static gint collection_motion_notify(GtkWidget *widget,
978 GdkEventMotion *event)
979 {
980 Collection *collection;
981 gint x, y;
982
983 g_return_val_if_fail(widget != NULL, FALSE);
984 g_return_val_if_fail(IS_COLLECTION(widget), FALSE);
985 g_return_val_if_fail(event != NULL, FALSE);
986
987 collection = COLLECTION(widget);
988
989 if (!collection->lasso_box)
990 return FALSE;
991
992 if (event->window != widget->window)
993 gdk_window_get_pointer(widget->window, &x, &y, NULL);
994 else
995 {
996 x = event->x;
997 y = event->y;
998 }
999
1000 remove_lasso_box(collection);
1001 collection->drag_box_x[1] = x;
1002 collection->drag_box_y[1] = y;
1003 add_lasso_box(collection);
1004 return TRUE;
1005 }
1006
1007 static void add_lasso_box(Collection *collection)
1008 {
1009 g_return_if_fail(collection != NULL);
1010 g_return_if_fail(IS_COLLECTION(collection));
1011 g_return_if_fail(collection->lasso_box == FALSE);
1012
1013 collection->lasso_box = TRUE;
1014 draw_lasso_box(collection);
1015 }
1016
1017 static void draw_lasso_box(Collection *collection)
1018 {
1019 GtkWidget *widget;
1020 int x, y, width, height;
1021
1022 widget = GTK_WIDGET(collection);
1023
1024 x = MIN(collection->drag_box_x[0], collection->drag_box_x[1]);
1025 y = MIN(collection->drag_box_y[0], collection->drag_box_y[1]);
1026 width = abs(collection->drag_box_x[1] - collection->drag_box_x[0]);
1027 height = abs(collection->drag_box_y[1] - collection->drag_box_y[0]);
1028
1029 /* XXX: A redraw bug sometimes leaves a one-pixel dot on the screen.
1030 * As a quick hack, don't draw boxes that small for now...
1031 */
1032 if (width || height)
1033 gdk_draw_rectangle(widget->window, collection->xor_gc, FALSE,
1034 x, y, width, height);
1035 }
1036
1037 static void abort_lasso(Collection *collection)
1038 {
1039 if (collection->lasso_box)
1040 {
1041 remove_lasso_box(collection);
1042 collection_set_autoscroll(collection, FALSE);
1043 }
1044 }
1045
1046 static void remove_lasso_box(Collection *collection)
1047 {
1048 g_return_if_fail(collection != NULL);
1049 g_return_if_fail(IS_COLLECTION(collection));
1050 g_return_if_fail(collection->lasso_box == TRUE);
1051
1052 draw_lasso_box(collection);
1053
1054 collection->lasso_box = FALSE;
1055
1056 return;
1057 }
1058
1059 /* Make sure that 'item' is fully visible (vertically), scrolling if not. */
1060 static void scroll_to_show(Collection *collection, int item)
1061 {
1062 int first, last, row;
1063
1064 g_return_if_fail(collection != NULL);
1065 g_return_if_fail(IS_COLLECTION(collection));
1066
1067 row = item / collection->columns;
1068 get_visible_limits(collection, &first, &last);
1069
1070 if (row <= first)
1071 {
1072 gtk_adjustment_set_value(collection->vadj,
1073 row * collection->item_height);
1074 }
1075 else if (row >= last)
1076 {
1077 GtkWidget *widget = (GtkWidget *) collection;
1078 gint height;
1079
1080 if (GTK_WIDGET_REALIZED(widget))
1081 {
1082 height = collection->vadj->page_size;
1083 gtk_adjustment_set_value(collection->vadj,
1084 (row + 1) * collection->item_height - height);
1085 }
1086 }
1087 }
1088
1089 /* Return the first and last rows which are [partly] visible. Does not
1090 * ensure that the rows actually exist (contain items).
1091 */
1092 static void get_visible_limits(Collection *collection, int *first, int *last)
1093 {
1094 GtkWidget *widget = (GtkWidget *) collection;
1095 gint scroll = 0, height;
1096
1097 g_return_if_fail(collection != NULL);
1098 g_return_if_fail(IS_COLLECTION(collection));
1099 g_return_if_fail(first != NULL && last != NULL);
1100
1101 if (!GTK_WIDGET_REALIZED(widget))
1102 {
1103 *first = 0;
1104 *last = 0;
1105 }
1106 else
1107 {
1108 scroll = collection->vadj->value;
1109 height = collection->vadj->page_size;
1110
1111 *first = MAX(scroll / collection->item_height, 0);
1112 *last = (scroll + height - 1) /collection->item_height;
1113
1114 if (*last < *first)
1115 *last = *first;
1116 }
1117 }
1118
1119 /* Cancel the current wink effect. */
1120 static void cancel_wink(Collection *collection)
1121 {
1122 gint item;
1123
1124 g_return_if_fail(collection != NULL);
1125 g_return_if_fail(IS_COLLECTION(collection));
1126 g_return_if_fail(collection->wink_item != -1);
1127
1128 item = collection->wink_item;
1129
1130 collection->wink_item = -1;
1131 gtk_timeout_remove(collection->wink_timeout);
1132
1133 collection_draw_item(collection, item, TRUE);
1134 }
1135
1136 /* Draw/undraw a box around collection->wink_item */
1137 static void invert_wink(Collection *collection)
1138 {
1139 GdkRectangle area;
1140 gint row, col;
1141
1142 g_return_if_fail(collection->wink_item >= 0);
1143
1144 if (!GTK_WIDGET_REALIZED(GTK_WIDGET(collection)))
1145 return;
1146
1147 col = collection->wink_item % collection->columns;
1148 row = collection->wink_item / collection->columns;
1149 collection_get_item_area(collection, row, col, &area);
1150
1151 gdk_draw_rectangle(((GtkWidget *) collection)->window,
1152 collection->xor_gc, FALSE,
1153 area.x, area.y,
1154 collection->item_width - 1,
1155 area.height - 1);
1156 }
1157
1158 static gboolean wink_timeout(Collection *collection)
1159 {
1160 gint item;
1161
1162 g_return_val_if_fail(collection != NULL, FALSE);
1163 g_return_val_if_fail(IS_COLLECTION(collection), FALSE);
1164 g_return_val_if_fail(collection->wink_item != -1, FALSE);
1165
1166 item = collection->wink_item;
1167
1168 if (collection->winks_left-- > 0)
1169 {
1170 invert_wink(collection);
1171 return TRUE;
1172 }
1173
1174 collection->wink_item = -1;
1175
1176 collection_draw_item(collection, item, TRUE);
1177
1178 return FALSE;
1179 }
1180
1181 /* This is called frequently while auto_scroll is on.
1182 * Checks the pointer position and scrolls the window if it's
1183 * near the top or bottom.
1184 */
1185 static gboolean as_timeout(Collection *collection)
1186 {
1187 GdkWindow *window = GTK_WIDGET(collection)->window;
1188 gint x, y, w, h;
1189 GdkModifierType mask;
1190 int diff = 0;
1191
1192 gdk_window_get_pointer(window, &x, &y, &mask);
1193 gdk_drawable_get_size(window, &w, NULL);
1194
1195 h = collection->vadj->page_size;
1196 y -= collection->vadj->value;
1197
1198 if ((x < 0 || x > w || y < 0 || y > h) && !collection->lasso_box)
1199 {
1200 collection->auto_scroll = -1;
1201 return FALSE; /* Out of window - stop */
1202 }
1203
1204 if (y < AUTOSCROLL_STEP)
1205 diff = y - AUTOSCROLL_STEP;
1206 else if (y > h - AUTOSCROLL_STEP)
1207 diff = AUTOSCROLL_STEP + y - h;
1208
1209 if (diff)
1210 diff_vpos(collection, diff);
1211
1212 return TRUE;
1213 }
1214
1215 /* Change the selected state of an item.
1216 * Send GAIN/LOSE signals if 'signal' is TRUE.
1217 * Send SELECTION_CHANGED unless blocked.
1218 * Updates number_selected and redraws the item.
1219 */
1220 static void collection_item_set_selected(Collection *collection,
1221 gint item,
1222 gboolean selected,
1223 gboolean signal)
1224 {
1225 g_return_if_fail(collection != NULL);
1226 g_return_if_fail(IS_COLLECTION(collection));
1227 g_return_if_fail(item >= 0 && item < collection->number_of_items);
1228
1229 if (collection->items[item].selected == selected)
1230 return;
1231
1232 collection->items[item].selected = selected;
1233 collection_draw_item(collection, item, TRUE);
1234
1235 if (selected)
1236 {
1237 collection->number_selected++;
1238 if (signal && collection->number_selected == 1)
1239 g_signal_emit(collection,
1240 collection_signals[GAIN_SELECTION], 0,
1241 current_event_time);
1242 }
1243 else
1244 {
1245 collection->number_selected--;
1246 if (signal && collection->number_selected == 0)
1247 g_signal_emit(collection,
1248 collection_signals[LOSE_SELECTION], 0,
1249 current_event_time);
1250 }
1251
1252 EMIT_SELECTION_CHANGED(collection, current_event_time);
1253 }
1254
1255 /* Functions for managing collections */
1256
1257 /* Remove all objects from the collection */
1258 void collection_clear(Collection *collection)
1259 {
1260 collection_delete_if(collection, NULL, NULL);
1261 }
1262
1263 /* Inserts a new item at the end. The new item is unselected, and its
1264 * number is returned.
1265 */
1266 gint collection_insert(Collection *collection, gpointer data, gpointer view)
1267 {
1268 int item;
1269
1270 /* g_return_val_if_fail(IS_COLLECTION(collection), -1); (slow) */
1271
1272 item = collection->number_of_items;
1273
1274 if (item >= collection->array_size)
1275 resize_arrays(collection, item + (item >> 1));
1276
1277 collection->items[item].data = data;
1278 collection->items[item].view_data = view;
1279 collection->items[item].selected = FALSE;
1280
1281 collection->number_of_items++;
1282
1283 gtk_widget_queue_resize(GTK_WIDGET(collection));
1284
1285 collection_draw_item(collection, item, FALSE);
1286
1287 return item;
1288 }
1289
1290 void collection_unselect_item(Collection *collection, gint item)
1291 {
1292 collection_item_set_selected(collection, item, FALSE, TRUE);
1293 }
1294
1295 void collection_select_item(Collection *collection, gint item)
1296 {
1297 collection_item_set_selected(collection, item, TRUE, TRUE);
1298 }
1299
1300 void collection_toggle_item(Collection *collection, gint item)
1301 {
1302 collection_item_set_selected(collection, item,
1303 !collection->items[item].selected, TRUE);
1304 }
1305
1306 /* Select all items in the collection */
1307 void collection_select_all(Collection *collection)
1308 {
1309 GtkWidget *widget;
1310 int item = 0;
1311
1312 g_return_if_fail(collection != NULL);
1313 g_return_if_fail(IS_COLLECTION(collection));
1314
1315 widget = GTK_WIDGET(collection);
1316
1317 if (collection->number_selected == collection->number_of_items)
1318 return; /* Nothing to do */
1319
1320 while (collection->number_selected < collection->number_of_items)
1321 {
1322 while (collection->items[item].selected)
1323 item++;
1324
1325 collection->items[item].selected = TRUE;
1326 collection_draw_item(collection, item, TRUE);
1327 item++;
1328
1329 collection->number_selected++;
1330 }
1331
1332 g_signal_emit(collection, collection_signals[GAIN_SELECTION], 0,
1333 current_event_time);
1334 EMIT_SELECTION_CHANGED(collection, current_event_time);
1335 }
1336
1337 /* Toggle all items in the collection */
1338 void collection_invert_selection(Collection *collection)
1339 {
1340 int item;
1341
1342 g_return_if_fail(collection != NULL);
1343 g_return_if_fail(IS_COLLECTION(collection));
1344
1345 if (collection->number_selected == 0)
1346 {
1347 collection_select_all(collection);
1348 return;
1349 }
1350 else if (collection->number_of_items == collection->number_selected)
1351 {
1352 collection_clear_selection(collection);
1353 return;
1354 }
1355
1356 for (item = 0; item < collection->number_of_items; item++)
1357 collection->items[item].selected =
1358 !collection->items[item].selected;
1359
1360 collection->number_selected = collection->number_of_items -
1361 collection->number_selected;
1362
1363 /* Have to redraw everything... */
1364 gtk_widget_queue_draw(GTK_WIDGET(collection));
1365
1366 EMIT_SELECTION_CHANGED(collection, current_event_time);
1367 }
1368
1369 /* Unselect all items except number item, which is selected (-1 to unselect
1370 * everything).
1371 */
1372 void collection_clear_except(Collection *collection, gint item)
1373 {
1374 GtkWidget *widget;
1375 int i = 0;
1376 int end; /* Selected items to end up with */
1377
1378 g_return_if_fail(collection != NULL);
1379 g_return_if_fail(IS_COLLECTION(collection));
1380 g_return_if_fail(item >= -1 && item < collection->number_of_items);
1381
1382 widget = GTK_WIDGET(collection);
1383
1384 if (item == -1)
1385 end = 0;
1386 else
1387 {
1388 collection_select_item(collection, item);
1389 end = 1;
1390 }
1391
1392 if (collection->number_selected == 0)
1393 return;
1394
1395 while (collection->number_selected > end)
1396 {
1397 while (i == item || !collection->items[i].selected)
1398 i++;
1399
1400 collection->items[i].selected = FALSE;
1401 collection_draw_item(collection, i, TRUE);
1402 i++;
1403
1404 collection->number_selected--;
1405 }
1406
1407 if (end == 0)
1408 g_signal_emit(collection, collection_signals[LOSE_SELECTION], 0,
1409 current_event_time);
1410 EMIT_SELECTION_CHANGED(collection, current_event_time);
1411 }
1412
1413 /* Unselect all items in the collection */
1414 void collection_clear_selection(Collection *collection)
1415 {
1416 g_return_if_fail(collection != NULL);
1417 g_return_if_fail(IS_COLLECTION(collection));
1418
1419 collection_clear_except(collection, -1);
1420 }
1421
1422 /* Force a redraw of the specified item, if it is visible */
1423 void collection_draw_item(Collection *collection, gint item, gboolean blank)
1424 {
1425 GdkRectangle area;
1426 GtkWidget *widget;
1427 int row, col;
1428
1429 g_return_if_fail(collection != NULL);
1430 /* g_return_if_fail(IS_COLLECTION(collection)); (slow) */
1431 g_return_if_fail(item >= 0 &&
1432 (item == 0 || item < collection->number_of_items));
1433
1434 widget = GTK_WIDGET(collection);
1435 if (!GTK_WIDGET_REALIZED(widget))
1436 return;
1437
1438 col = item % collection->columns;
1439 row = item / collection->columns;
1440
1441 collection_get_item_area(collection, row, col, &area);
1442
1443 gdk_window_invalidate_rect(widget->window, &area, FALSE);
1444 }
1445
1446 void collection_set_item_size(Collection *collection, int width, int height)
1447 {
1448 GtkWidget *widget;
1449
1450 g_return_if_fail(collection != NULL);
1451 g_return_if_fail(IS_COLLECTION(collection));
1452 g_return_if_fail(width > 4 && height > 4);
1453
1454 if (collection->item_width == width &&
1455 collection->item_height == height)
1456 return;
1457
1458 widget = GTK_WIDGET(collection);
1459
1460 collection->item_width = width;
1461 collection->item_height = height;
1462
1463 if (GTK_WIDGET_REALIZED(widget))
1464 {
1465 gint window_width;
1466
1467 gdk_drawable_get_size(widget->window, &window_width, NULL);
1468 collection->columns = MAX(window_width / collection->item_width,
1469 1);
1470 if (collection->cursor_item != -1)
1471 scroll_to_show(collection, collection->cursor_item);
1472 gtk_widget_queue_draw(widget);
1473 }
1474
1475 gtk_widget_queue_resize(GTK_WIDGET(collection));
1476 }
1477
1478 static int (*cmp_callback)(const void *a, const void *b) = NULL;
1479 static int collection_cmp(const void *a, const void *b)
1480 {
1481 return cmp_callback(((CollectionItem *) a)->data,
1482 ((CollectionItem *) b)->data);
1483 }
1484
1485 /* Cursor is positioned on item with the same data as before the sort.
1486 * Same for the wink item.
1487 */
1488 void collection_qsort(Collection *collection,
1489 int (*compar)(const void *, const void *))
1490 {
1491 int cursor, wink, items, wink_on_map;
1492 gpointer cursor_data = NULL;
1493 gpointer wink_data = NULL;
1494 gpointer wink_on_map_data = NULL;
1495 CollectionItem *array;
1496 int i;
1497
1498 g_return_if_fail(collection != NULL);
1499 g_return_if_fail(IS_COLLECTION(collection));
1500 g_return_if_fail(compar != NULL);
1501 g_return_if_fail(cmp_callback == NULL);
1502
1503 /* Check to see if it needs sorting (saves redrawing) */
1504 if (collection->number_of_items < 2)
1505 return;
1506
1507 array = collection->items;
1508 for (i = 1; i < collection->number_of_items; i++)
1509 {
1510 if (compar(array[i - 1].data, array[i].data) > 0)
1511 break;
1512 }
1513 if (i == collection->number_of_items)
1514 return; /* Already sorted */
1515
1516 items = collection->number_of_items;
1517
1518 wink_on_map = collection->wink_on_map;
1519 if (wink_on_map >= 0 && wink_on_map < items)
1520 {
1521 wink_on_map_data = collection->items[wink_on_map].data;
1522 collection->wink_on_map = -1;
1523 }
1524 else
1525 wink = -1;
1526
1527 wink = collection->wink_item;
1528 if (wink >= 0 && wink < items)
1529 {
1530 wink_data = collection->items[wink].data;
1531 collection->wink_item = -1;
1532 }
1533 else
1534 wink = -1;
1535
1536 cursor = collection->cursor_item;
1537 if (cursor >= 0 && cursor < items)
1538 cursor_data = collection->items[cursor].data;
1539 else
1540 cursor = -1;
1541
1542 cmp_callback = compar;
1543 qsort(collection->items, items, sizeof(collection->items[0]),
1544 collection_cmp);
1545 cmp_callback = NULL;
1546
1547 if (cursor > -1 || wink > -1 || wink_on_map > -1)
1548 {
1549 int item;
1550
1551 for (item = 0; item < items; item++)
1552 {
1553 if (collection->items[item].data == cursor_data)
1554 collection_set_cursor_item(collection, item);
1555 if (collection->items[item].data == wink_on_map_data)
1556 collection->wink_on_map = item;
1557 if (collection->items[item].data == wink_data)
1558 {
1559 collection->cursor_item_old = item;
1560 collection->wink_item = item;
1561 scroll_to_show(collection, item);
1562 }
1563 }
1564 }
1565
1566 gtk_widget_queue_draw(GTK_WIDGET(collection));
1567 }
1568
1569 /* Find an item in a sorted collection.
1570 * Returns the item number, or -1 if not found.
1571 */
1572 int collection_find_item(Collection *collection, gpointer data,
1573 int (*compar)(const void *, const void *))
1574 {
1575 int lower, upper;
1576
1577 g_return_val_if_fail(collection != NULL, -1);
1578 g_return_val_if_fail(IS_COLLECTION(collection), -1);
1579 g_return_val_if_fail(compar != NULL, -1);
1580
1581 /* If item is here, then: lower <= i < upper */
1582 lower = 0;
1583 upper = collection->number_of_items;
1584
1585 while (lower < upper)
1586 {
1587 int i, cmp;
1588
1589 i = (lower + upper) >> 1;
1590
1591 cmp = compar(collection->items[i].data, data);
1592 if (cmp == 0)
1593 return i;
1594
1595 if (cmp > 0)
1596 upper = i;
1597 else
1598 lower = i + 1;
1599 }
1600
1601 return -1;
1602 }
1603
1604 /* Return the number of the item under the point (x,y), or -1 for none.
1605 * This may call your test_point callback. The point is relative to the
1606 * collection's origin.
1607 */
1608 int collection_get_item(Collection *collection, int x, int y)
1609 {
1610 int row, col;
1611 int width;
1612 int item;
1613
1614 g_return_val_if_fail(collection != NULL, -1);
1615
1616 col = x / collection->item_width;
1617 row = y / collection->item_height;
1618
1619 if (col >= collection->columns)
1620 col = collection->columns - 1;
1621
1622 if (col < 0 || row < 0)
1623 return -1;
1624
1625 if (col == collection->columns - 1)
1626 width = collection->item_width << 1;
1627 else
1628 width = collection->item_width;
1629
1630 item = col + row * collection->columns;
1631 if (item >= collection->number_of_items)
1632 return -1;
1633
1634 x -= col * collection->item_width;
1635 y -= row * collection->item_height;
1636
1637 if (collection->test_point(collection, x, y,
1638 &collection->items[item], width, collection->item_height,
1639 collection->cb_user_data))
1640 return item;
1641
1642 return -1;
1643 }
1644
1645 int collection_selected_item_number(Collection *collection)
1646 {
1647 int i;
1648
1649 g_return_val_if_fail(collection != NULL, -1);
1650 g_return_val_if_fail(IS_COLLECTION(collection), -1);
1651 g_return_val_if_fail(collection->number_selected == 1, -1);
1652
1653 for (i = 0; i < collection->number_of_items; i++)
1654 if (collection->items[i].selected)
1655 return i;
1656
1657 g_warning("collection_selected_item_number: number_selected is wrong");
1658
1659 return -1;
1660 }
1661
1662 /* Set the cursor/highlight over the given item. Passing -1
1663 * hides the cursor. As a special case, you may set the cursor item
1664 * to zero when there are no items.
1665 */
1666 void collection_set_cursor_item(Collection *collection, gint item)
1667 {
1668 int old_item;
1669
1670 g_return_if_fail(collection != NULL);
1671 g_return_if_fail(IS_COLLECTION(collection));
1672 g_return_if_fail(item >= -1 &&
1673 (item < collection->number_of_items || item == 0));
1674
1675 old_item = collection->cursor_item;
1676
1677 if (old_item == item)
1678 return;
1679
1680 collection->cursor_item = item;
1681
1682 if (old_item != -1)
1683 collection_draw_item(collection, old_item, TRUE);
1684
1685 if (item != -1)
1686 {
1687 collection_draw_item(collection, item, TRUE);
1688 if (collection->auto_scroll == -1)
1689 scroll_to_show(collection, item);
1690 }
1691 else if (old_item != -1)
1692 collection->cursor_item_old = old_item;
1693 }
1694
1695 /* Briefly highlight an item to draw the user's attention to it.
1696 * -1 cancels the effect, as does deleting items, sorting the collection
1697 * or starting a new wink effect.
1698 * Otherwise, the effect will cancel itself after a short pause.
1699 * */
1700 void collection_wink_item(Collection *collection, gint item)
1701 {
1702 g_return_if_fail(collection != NULL);
1703 g_return_if_fail(IS_COLLECTION(collection));
1704 g_return_if_fail(item >= -1 && item < collection->number_of_items);
1705
1706 if (collection->wink_item != -1)
1707 cancel_wink(collection);
1708 if (item == -1)
1709 return;
1710
1711 if (!GTK_WIDGET_MAPPED(GTK_WIDGET(collection)))
1712 {
1713 collection->wink_on_map = item;
1714 return;
1715 }
1716
1717 collection->cursor_item_old = collection->wink_item = item;
1718 collection->winks_left = MAX_WINKS;
1719
1720 collection->wink_timeout = gtk_timeout_add(70,
1721 (GtkFunction) wink_timeout,
1722 collection);
1723 scroll_to_show(collection, item);
1724 invert_wink(collection);
1725
1726 gdk_flush();
1727 }
1728
1729 /* Call test(item, data) on each item in the collection.
1730 * Remove all items for which it returns TRUE. test() should
1731 * free the data before returning TRUE. The collection is in an
1732 * inconsistant state during this call (ie, when test() is called).
1733 *
1734 * If test is NULL, remove all items.
1735 */
1736 void collection_delete_if(Collection *collection,
1737 gboolean (*test)(gpointer item, gpointer data),
1738 gpointer data)
1739 {
1740 int in, out = 0;
1741 int selected = 0;
1742 int cursor;
1743
1744 g_return_if_fail(collection != NULL);
1745 g_return_if_fail(IS_COLLECTION(collection));
1746
1747 cursor = collection->cursor_item;
1748
1749 for (in = 0; in < collection->number_of_items; in++)
1750 {
1751 if (test && !test(collection->items[in].data, data))
1752 {
1753 /* Keep item */
1754 if (collection->items[in].selected)
1755 {
1756 collection->items[out].selected = TRUE;
1757 selected++;
1758 }
1759 else
1760 collection->items[out].selected = FALSE;
1761
1762 collection->items[out].data =
1763 collection->items[in].data;
1764 collection->items[out].view_data =
1765 collection->items[in].view_data;
1766 out++;
1767 }
1768 else
1769 {
1770 /* Remove item */
1771 if (collection->free_item)
1772 collection->free_item(collection,
1773 &collection->items[in]);
1774
1775 if (cursor >= in)
1776 cursor--;
1777 }
1778 }
1779
1780 if (in != out)
1781 {
1782 collection->cursor_item = cursor;
1783
1784 if (collection->wink_item != -1)
1785 {
1786 collection->wink_item = -1;
1787 gtk_timeout_remove(collection->wink_timeout);
1788 }
1789
1790 collection->number_of_items = out;
1791 if (collection->number_selected && !selected)
1792 {
1793 /* We've lost all the selected items */
1794 g_signal_emit(collection,
1795 collection_signals[LOSE_SELECTION], 0,
1796 current_event_time);
1797 }
1798
1799 collection->number_selected = selected;
1800 resize_arrays(collection,
1801 MAX(collection->number_of_items, MINIMUM_ITEMS));
1802
1803 if (GTK_WIDGET_REALIZED(GTK_WIDGET(collection)))
1804 gtk_widget_queue_draw(GTK_WIDGET(collection));
1805
1806 gtk_widget_queue_resize(GTK_WIDGET(collection));
1807 }
1808 }
1809
1810 /* Move the cursor by the given row and column offsets.
1811 * Moving by (0,0) can be used to simply make the cursor appear.
1812 */
1813 void collection_move_cursor(Collection *collection, int drow, int dcol)
1814 {
1815 int row, col, item;
1816 int first, last, total_rows;
1817
1818 g_return_if_fail(collection != NULL);
1819 g_return_if_fail(IS_COLLECTION(collection));
1820
1821 get_visible_limits(collection, &first, &last);
1822
1823 item = collection->cursor_item;
1824 if (item == -1)
1825 {
1826 item = MIN(collection->cursor_item_old,
1827 collection->number_of_items - 1);
1828 }
1829
1830 if (item == -1)
1831 {
1832 col = 0;
1833 row = first;
1834 }
1835 else
1836 {
1837 row = item / collection->columns;
1838 col = item % collection->columns + dcol;
1839
1840 if (row < first)
1841 row = first;
1842 else if (row > last)
1843 row = last;
1844 else
1845 row = MAX(row + drow, 0);
1846 }
1847
1848 total_rows = (collection->number_of_items + collection->columns - 1)
1849 / collection->columns;
1850
1851 if (row >= total_rows - 1 && drow > 0)
1852 {
1853 row = total_rows - 1;
1854 item = col + row * collection->columns;
1855 if (item >= collection->number_of_items - 1)
1856 {
1857 collection_set_cursor_item(collection,
1858 collection->number_of_items - 1);
1859 return;
1860 }
1861 }
1862 if (row < 0)
1863 row = 0;
1864
1865 item = col + row * collection->columns;
1866
1867 if (item >= 0 && item < collection->number_of_items)
1868 collection_set_cursor_item(collection, item);
1869 }
1870
1871 /* When autoscroll is on, a timer keeps track of the pointer position.
1872 * While it's near the top or bottom of the window, the window scrolls.
1873 *
1874 * If the mouse buttons are released, the pointer leaves the window, or
1875 * a drag-and-drop operation finishes, auto_scroll is turned off.
1876 */
1877 void collection_set_autoscroll(Collection *collection, gboolean auto_scroll)
1878 {
1879 g_return_if_fail(collection != NULL);
1880 g_return_if_fail(IS_COLLECTION(collection));
1881
1882 if (auto_scroll)
1883 {
1884 if (collection->auto_scroll != -1)
1885 return; /* Already on! */
1886
1887 collection->auto_scroll = gtk_timeout_add(50,
1888 (GtkFunction) as_timeout,
1889 collection);
1890 }
1891 else
1892 {
1893 if (collection->auto_scroll == -1)
1894 return; /* Already off! */
1895
1896 gtk_timeout_remove(collection->auto_scroll);
1897 collection->auto_scroll = -1;
1898 }
1899 }
1900
1901 /* Start a lasso box drag */
1902 void collection_lasso_box(Collection *collection, int x, int y)
1903 {
1904 collection->drag_box_x[0] = x;
1905 collection->drag_box_y[0] = y;
1906 collection->drag_box_x[1] = x;
1907 collection->drag_box_y[1] = y;
1908
1909 collection_set_autoscroll(collection, TRUE);
1910 add_lasso_box(collection);
1911 }
1912
1913 /* Remove the lasso box. Applies fn to each item inside the box.
1914 * fn may be GDK_INVERT, GDK_SET, GDK_NOOP or GDK_CLEAR.
1915 */
1916 void collection_end_lasso(Collection *collection, GdkFunction fn)
1917 {
1918 if (fn != GDK_CLEAR)
1919 {
1920 GdkRectangle region;
1921
1922 find_lasso_area(collection, &region);
1923
1924 collection_process_area(collection, &region, fn,
1925 GDK_CURRENT_TIME);
1926 }
1927
1928 abort_lasso(collection);
1929 }
1930
1931 /* Unblock the selection_changed signal, emitting the signal if the
1932 * block counter reaches zero and emit is TRUE.
1933 */
1934 void collection_unblock_selection_changed(Collection *collection,
1935 guint time,
1936 gboolean emit)
1937 {
1938 g_return_if_fail(collection != NULL);
1939 g_return_if_fail(IS_COLLECTION(collection));
1940 g_return_if_fail(collection->block_selection_changed > 0);
1941
1942 collection->block_selection_changed--;
1943
1944 if (emit && !collection->block_selection_changed)
1945 g_signal_emit(collection,
1946 collection_signals[SELECTION_CHANGED], 0, time);
1947 }
Filer for the ROX desktop