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