?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r254: Fixed a bug which stopped adjust-drag working in RISC OS mode.
[rox-filer/ma.git] / ROX-Filer / src / collection.c
blobc0fb660cedce89db53ea4fec96dde9da92f88baa
1 /*
2 * $Id$
3 *
4 * Collection - a GTK+ widget
5 * Copyright (C) 2000, Thomas Leonard, <tal197@ecs.soton.ac.uk>.
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 <stdlib.h>
28
29 #include <gtk/gtk.h>
30 #include <gdk/gdkkeysyms.h>
31 #include "collection.h"
32
33 #define MIN_WIDTH 80
34 #define MIN_HEIGHT 60
35 #define MINIMUM_ITEMS 16
36
37 int collection_menu_button = 3;
38 gboolean collection_single_click = FALSE;
39
40 enum
41 {
42 ARG_0,
43 ARG_VADJUSTMENT
44 };
45
46 /* Signals:
47 *
48 * void open_item(collection, item, item_number, user_data)
49 * User has double clicked on this item.
50 *
51 * void drag_selection(collection, motion_event, number_selected, user_data)
52 * User has tried to drag the selection.
53 *
54 * void show_menu(collection, button_event, item, user_data)
55 * User has menu-clicked on the collection. 'item' is the number
56 * of the item clicked, or -1 if the click was over the background.
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 enum
69 {
70 OPEN_ITEM,
71 DRAG_SELECTION,
72 SHOW_MENU,
73 GAIN_SELECTION,
74 LOSE_SELECTION,
75 LAST_SIGNAL
76 };
77
78 static guint collection_signals[LAST_SIGNAL] = { 0 };
79
80 static guint32 current_event_time = GDK_CURRENT_TIME;
81
82 static GtkWidgetClass *parent_class = NULL;
83
84 static GdkCursor *crosshair = NULL;
85
86 /* Static prototypes */
87 static void draw_one_item(Collection *collection,
88 int item,
89 GdkRectangle *area);
90 static void collection_class_init(CollectionClass *class);
91 static void collection_init(Collection *object);
92 static void collection_destroy(GtkObject *object);
93 static void collection_finalize(GtkObject *object);
94 static void collection_realize(GtkWidget *widget);
95 static gint collection_paint(Collection *collection,
96 GdkRectangle *area);
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_style(GtkWidget *widget,
102 GtkStyle *previous_style);
103 static void collection_set_adjustment(Collection *collection,
104 GtkAdjustment *vadj);
105 static void collection_set_arg( GtkObject *object,
106 GtkArg *arg,
107 guint arg_id);
108 static void collection_get_arg( GtkObject *object,
109 GtkArg *arg,
110 guint arg_id);
111 static void collection_adjustment(GtkAdjustment *adjustment,
112 Collection *collection);
113 static void collection_disconnect(GtkAdjustment *adjustment,
114 Collection *collection);
115 static void set_vadjustment(Collection *collection);
116 static void collection_draw(GtkWidget *widget, GdkRectangle *area);
117 static gint collection_expose(GtkWidget *widget, GdkEventExpose *event);
118 static void scroll_by(Collection *collection, gint diff);
119 static gint collection_button_press(GtkWidget *widget,
120 GdkEventButton *event);
121 static gint collection_button_release(GtkWidget *widget,
122 GdkEventButton *event);
123 static void default_draw_item(GtkWidget *widget,
124 CollectionItem *data,
125 GdkRectangle *area);
126 static gboolean default_test_point(Collection *collection,
127 int point_x, int point_y,
128 CollectionItem *data,
129 int width, int height);
130 static gint collection_motion_notify(GtkWidget *widget,
131 GdkEventMotion *event);
132 static void add_lasso_box(Collection *collection);
133 static void remove_lasso_box(Collection *collection);
134 static void draw_lasso_box(Collection *collection);
135 static int item_at_row_col(Collection *collection, int row, int col);
136 static void collection_clear_except(Collection *collection, gint exception);
137 static void cancel_wink(Collection *collection);
138 static gint collection_key_press(GtkWidget *widget, GdkEventKey *event);
139 static void get_visible_limits(Collection *collection, int *first, int *last);
140 static void scroll_to_show(Collection *collection, int item);
141 static gint focus_in(GtkWidget *widget, GdkEventFocus *event);
142 static gint focus_out(GtkWidget *widget, GdkEventFocus *event);
143 static void draw_focus(GtkWidget *widget);
144
145 static void draw_focus_at(Collection *collection, GdkRectangle *area)
146 {
147 GtkWidget *widget;
148 GdkGC *gc;
149
150 widget = GTK_WIDGET(collection);
151
152 if (collection->target_cb)
153 gc = widget->style->white_gc;
154 else if (GTK_WIDGET_FLAGS(widget) & GTK_HAS_FOCUS)
155 gc = widget->style->black_gc;
156 else
157 gc = widget->style->fg_gc[GTK_STATE_INSENSITIVE];
158
159 gdk_draw_rectangle(widget->window, gc, FALSE,
160 area->x + 1, area->y + 1,
161 area->width - 3,
162 area->height - 3);
163 }
164
165 static void draw_one_item(Collection *collection, int item, GdkRectangle *area)
166 {
167 if (item < collection->number_of_items)
168 {
169 collection->draw_item((GtkWidget *) collection,
170 &collection->items[item],
171 area);
172 if (item == collection->wink_item)
173 gdk_draw_rectangle(((GtkWidget *) collection)->window,
174 ((GtkWidget *) collection)->style->black_gc,
175 FALSE,
176 area->x, area->y,
177 area->width - 1, area->height - 1);
178 }
179
180 if (item == collection->cursor_item)
181 draw_focus_at(collection, area);
182 }
183
184 static void draw_focus(GtkWidget *widget)
185 {
186 Collection *collection;
187
188 g_return_if_fail(widget != NULL);
189 g_return_if_fail(IS_COLLECTION(widget));
190
191 collection = COLLECTION(widget);
192
193 if (collection->cursor_item < 0 || !GTK_WIDGET_REALIZED(widget))
194 return;
195
196 collection_draw_item(collection, collection->cursor_item, FALSE);
197 }
198
199 GtkType collection_get_type(void)
200 {
201 static guint my_type = 0;
202
203 if (!my_type)
204 {
205 static const GtkTypeInfo my_info =
206 {
207 "Collection",
208 sizeof(Collection),
209 sizeof(CollectionClass),
210 (GtkClassInitFunc) collection_class_init,
211 (GtkObjectInitFunc) collection_init,
212 NULL, /* Reserved 1 */
213 NULL, /* Reserved 2 */
214 (GtkClassInitFunc) NULL /* base_class_init_func */
215 };
216
217 my_type = gtk_type_unique(gtk_widget_get_type(),
218 &my_info);
219 }
220
221 return my_type;
222 }
223
224 static void collection_class_init(CollectionClass *class)
225 {
226 GtkObjectClass *object_class;
227 GtkWidgetClass *widget_class;
228
229 object_class = (GtkObjectClass*) class;
230 widget_class = (GtkWidgetClass*) class;
231
232 parent_class = gtk_type_class(gtk_widget_get_type());
233
234 gtk_object_add_arg_type("Collection::vadjustment",
235 GTK_TYPE_ADJUSTMENT,
236 GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
237 ARG_VADJUSTMENT);
238
239 object_class->destroy = collection_destroy;
240 object_class->finalize = collection_finalize;
241
242 widget_class->realize = collection_realize;
243 widget_class->draw = collection_draw;
244 widget_class->expose_event = collection_expose;
245 widget_class->size_request = collection_size_request;
246 widget_class->size_allocate = collection_size_allocate;
247 widget_class->style_set = collection_set_style;
248
249 widget_class->key_press_event = collection_key_press;
250 widget_class->button_press_event = collection_button_press;
251 widget_class->button_release_event = collection_button_release;
252 widget_class->motion_notify_event = collection_motion_notify;
253 widget_class->focus_in_event = focus_in;
254 widget_class->focus_out_event = focus_out;
255 widget_class->draw_focus = draw_focus;
256
257 object_class->set_arg = collection_set_arg;
258 object_class->get_arg = collection_get_arg;
259
260 class->open_item = NULL;
261 class->drag_selection = NULL;
262 class->show_menu = NULL;
263 class->gain_selection = NULL;
264 class->lose_selection = NULL;
265
266 collection_signals[OPEN_ITEM] = gtk_signal_new("open_item",
267 GTK_RUN_LAST,
268 object_class->type,
269 GTK_SIGNAL_OFFSET(CollectionClass,
270 open_item),
271 gtk_marshal_NONE__POINTER_UINT,
272 GTK_TYPE_NONE, 2,
273 GTK_TYPE_POINTER,
274 GTK_TYPE_UINT);
275 collection_signals[DRAG_SELECTION] = gtk_signal_new("drag_selection",
276 GTK_RUN_LAST,
277 object_class->type,
278 GTK_SIGNAL_OFFSET(CollectionClass,
279 drag_selection),
280 gtk_marshal_NONE__POINTER_UINT,
281 GTK_TYPE_NONE, 2,
282 GTK_TYPE_POINTER,
283 GTK_TYPE_UINT);
284 collection_signals[SHOW_MENU] = gtk_signal_new("show_menu",
285 GTK_RUN_LAST,
286 object_class->type,
287 GTK_SIGNAL_OFFSET(CollectionClass,
288 show_menu),
289 gtk_marshal_NONE__POINTER_INT,
290 GTK_TYPE_NONE, 2,
291 GTK_TYPE_POINTER,
292 GTK_TYPE_INT);
293 collection_signals[GAIN_SELECTION] = gtk_signal_new("gain_selection",
294 GTK_RUN_LAST,
295 object_class->type,
296 GTK_SIGNAL_OFFSET(CollectionClass,
297 gain_selection),
298 gtk_marshal_NONE__UINT,
299 GTK_TYPE_NONE, 1,
300 GTK_TYPE_UINT);
301 collection_signals[LOSE_SELECTION] = gtk_signal_new("lose_selection",
302 GTK_RUN_LAST,
303 object_class->type,
304 GTK_SIGNAL_OFFSET(CollectionClass,
305 lose_selection),
306 gtk_marshal_NONE__UINT,
307 GTK_TYPE_NONE, 1,
308 GTK_TYPE_UINT);
309
310 gtk_object_class_add_signals(object_class,
311 collection_signals, LAST_SIGNAL);
312 }
313
314 static void collection_init(Collection *object)
315 {
316 g_return_if_fail(object != NULL);
317 g_return_if_fail(IS_COLLECTION(object));
318
319 if (!crosshair)
320 crosshair = gdk_cursor_new(GDK_CROSSHAIR);
321
322 GTK_WIDGET_SET_FLAGS(GTK_WIDGET(object), GTK_CAN_FOCUS);
323
324 object->panel = FALSE;
325 object->number_of_items = 0;
326 object->number_selected = 0;
327 object->columns = 1;
328 object->item_width = 64;
329 object->item_height = 64;
330 object->vadj = NULL;
331 object->paint_level = PAINT_OVERWRITE;
332 object->last_scroll = 0;
333
334 object->items = g_malloc(sizeof(CollectionItem) * MINIMUM_ITEMS);
335 object->cursor_item = -1;
336 object->wink_item = -1;
337 object->array_size = MINIMUM_ITEMS;
338 object->draw_item = default_draw_item;
339 object->test_point = default_test_point;
340
341 object->buttons_pressed = 0;
342 object->may_drag = FALSE;
343
344 return;
345 }
346
347 GtkWidget* collection_new(GtkAdjustment *vadj)
348 {
349 if (vadj)
350 g_return_val_if_fail(GTK_IS_ADJUSTMENT(vadj), NULL);
351
352 return GTK_WIDGET(gtk_widget_new(collection_get_type(),
353 "vadjustment", vadj,
354 NULL));
355 }
356
357 void collection_set_functions(Collection *collection,
358 CollectionDrawFunc draw_item,
359 CollectionTestFunc test_point)
360 {
361 GtkWidget *widget;
362
363 g_return_if_fail(collection != NULL);
364 g_return_if_fail(IS_COLLECTION(collection));
365
366 widget = GTK_WIDGET(collection);
367
368 if (!draw_item)
369 draw_item = default_draw_item;
370 if (!test_point)
371 test_point = default_test_point;
372
373 collection->draw_item = draw_item;
374 collection->test_point = test_point;
375
376 if (GTK_WIDGET_REALIZED(widget))
377 {
378 collection->paint_level = PAINT_CLEAR;
379 gtk_widget_queue_clear(widget);
380 }
381 }
382
383 /* After this we are unusable, but our data (if any) is still hanging around.
384 * It will be freed later with finalize.
385 */
386 static void collection_destroy(GtkObject *object)
387 {
388 Collection *collection;
389
390 g_return_if_fail(object != NULL);
391 g_return_if_fail(IS_COLLECTION(object));
392
393 collection = COLLECTION(object);
394
395 if (collection->wink_item != -1)
396 {
397 collection->wink_item = -1;
398 gtk_timeout_remove(collection->wink_timeout);
399 }
400
401 gtk_signal_disconnect_by_data(GTK_OBJECT(collection->vadj),
402 collection);
403
404 if (GTK_OBJECT_CLASS(parent_class)->destroy)
405 (*GTK_OBJECT_CLASS(parent_class)->destroy)(object);
406 }
407
408 /* This is the last thing that happens to us. Free all data. */
409 static void collection_finalize(GtkObject *object)
410 {
411 Collection *collection;
412
413 collection = COLLECTION(object);
414
415 if (collection->vadj)
416 {
417 gtk_object_unref(GTK_OBJECT(collection->vadj));
418 }
419
420 g_free(collection->items);
421 }
422
423 static void collection_realize(GtkWidget *widget)
424 {
425 Collection *collection;
426 GdkWindowAttr attributes;
427 gint attributes_mask;
428 GdkGCValues xor_values;
429
430 g_return_if_fail(widget != NULL);
431 g_return_if_fail(IS_COLLECTION(widget));
432 g_return_if_fail(widget->parent != NULL);
433
434 GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
435 collection = COLLECTION(widget);
436
437 attributes.x = widget->allocation.x;
438 attributes.y = widget->allocation.y;
439 attributes.width = widget->allocation.width;
440 attributes.height = widget->allocation.height;
441 attributes.wclass = GDK_INPUT_OUTPUT;
442 attributes.window_type = GDK_WINDOW_CHILD;
443 attributes.event_mask = gtk_widget_get_events(widget) |
444 GDK_EXPOSURE_MASK |
445 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
446 GDK_BUTTON1_MOTION_MASK | GDK_BUTTON2_MOTION_MASK |
447 GDK_BUTTON3_MOTION_MASK;
448 attributes.visual = gtk_widget_get_visual(widget);
449 attributes.colormap = gtk_widget_get_colormap(widget);
450
451 attributes_mask = GDK_WA_X | GDK_WA_Y |
452 GDK_WA_VISUAL | GDK_WA_COLORMAP;
453 widget->window = gdk_window_new(widget->parent->window,
454 &attributes, attributes_mask);
455
456 widget->style = gtk_style_attach(widget->style, widget->window);
457
458 gdk_window_set_user_data(widget->window, widget);
459
460 gdk_window_set_background(widget->window,
461 &widget->style->base[GTK_STATE_INSENSITIVE]);
462
463 /* Try to stop everything flickering horribly */
464 gdk_window_set_static_gravities(widget->window, TRUE);
465
466 set_vadjustment(collection);
467
468 xor_values.function = GDK_XOR;
469 xor_values.foreground.red = 0xffff;
470 xor_values.foreground.green = 0xffff;
471 xor_values.foreground.blue = 0xffff;
472 gdk_color_alloc(gtk_widget_get_colormap(widget),
473 &xor_values.foreground);
474 collection->xor_gc = gdk_gc_new_with_values(widget->window,
475 &xor_values,
476 GDK_GC_FOREGROUND
477 | GDK_GC_FUNCTION);
478 }
479
480 static void collection_size_request(GtkWidget *widget,
481 GtkRequisition *requisition)
482 {
483 requisition->width = MIN_WIDTH;
484 requisition->height = MIN_HEIGHT;
485 }
486
487 static void collection_size_allocate(GtkWidget *widget,
488 GtkAllocation *allocation)
489 {
490 Collection *collection;
491 int old_columns;
492
493 g_return_if_fail(widget != NULL);
494 g_return_if_fail(IS_COLLECTION(widget));
495 g_return_if_fail(allocation != NULL);
496
497 collection = COLLECTION(widget);
498
499 old_columns = collection->columns;
500 if (widget->allocation.x != allocation->x
501 || widget->allocation.y != allocation->y)
502 collection->paint_level = PAINT_CLEAR;
503
504 widget->allocation = *allocation;
505
506 collection->columns = allocation->width / collection->item_width;
507 if (collection->columns < 1)
508 collection->columns = 1;
509
510 if (GTK_WIDGET_REALIZED(widget))
511 {
512 gdk_window_move_resize(widget->window,
513 allocation->x, allocation->y,
514 allocation->width, allocation->height);
515
516 if (old_columns != collection->columns)
517 {
518 collection->paint_level = PAINT_CLEAR;
519 gtk_widget_queue_clear(widget);
520 }
521
522 set_vadjustment(collection);
523
524 if (collection->cursor_item != -1)
525 scroll_to_show(collection, collection->cursor_item);
526 }
527 }
528
529 static void collection_set_style(GtkWidget *widget,
530 GtkStyle *previous_style)
531 {
532 Collection *collection;
533
534 g_return_if_fail(IS_COLLECTION(widget));
535
536 collection = COLLECTION(widget);
537
538 collection->paint_level = PAINT_CLEAR;
539
540 if (parent_class->style_set)
541 (*parent_class->style_set)(widget, previous_style);
542 }
543
544 static gint collection_paint(Collection *collection,
545 GdkRectangle *area)
546 {
547 GdkRectangle whole, item_area;
548 GtkWidget *widget;
549 int row, col;
550 int item;
551 int scroll;
552 int start_row, last_row;
553 int start_col, last_col;
554 int phys_last_col;
555 GdkRectangle clip;
556
557 scroll = collection->vadj->value;
558
559 widget = GTK_WIDGET(collection);
560
561 if (collection->paint_level > PAINT_NORMAL || area == NULL)
562 {
563 guint width, height;
564 gdk_window_get_size(widget->window, &width, &height);
565
566 whole.x = 0;
567 whole.y = 0;
568 whole.width = width;
569 whole.height = height;
570
571 area = &whole;
572
573 if (collection->paint_level == PAINT_CLEAR
574 && !collection->lasso_box)
575 gdk_window_clear(widget->window);
576
577 collection->paint_level = PAINT_NORMAL;
578 }
579
580 /* Calculate the ranges to plot */
581 start_row = (area->y + scroll) / collection->item_height;
582 last_row = (area->y + area->height - 1 + scroll)
583 / collection->item_height;
584 row = start_row;
585
586 start_col = area->x / collection->item_width;
587 phys_last_col = (area->x + area->width - 1) / collection->item_width;
588
589 if (collection->lasso_box)
590 {
591 /* You can't be too careful with lasso boxes...
592 *
593 * clip gives the total area drawn over (this may be larger
594 * than the requested area). It's used to redraw the lasso
595 * box.
596 */
597 clip.x = start_col * collection->item_width;
598 clip.y = start_row * collection->item_height - scroll;
599 clip.width = (phys_last_col - start_col + 1)
600 * collection->item_width;
601 clip.height = (last_row - start_row + 1)
602 * collection->item_height;
603
604 gdk_window_clear_area(widget->window,
605 clip.x, clip.y, clip.width, clip.height);
606 }
607
608 if (start_col < collection->columns)
609 {
610 if (phys_last_col >= collection->columns)
611 last_col = collection->columns - 1;
612 else
613 last_col = phys_last_col;
614
615 col = start_col;
616
617 item = row * collection->columns + col;
618 item_area.width = collection->item_width;
619 item_area.height = collection->item_height;
620
621 while ((item == 0 || item < collection->number_of_items)
622 && row <= last_row)
623 {
624 item_area.x = col * collection->item_width;
625 item_area.y = row * collection->item_height - scroll;
626
627 draw_one_item(collection, item, &item_area);
628 col++;
629
630 if (col > last_col)
631 {
632 col = start_col;
633 row++;
634 item = row * collection->columns + col;
635 }
636 else
637 item++;
638 }
639 }
640
641 if (collection->lasso_box)
642 {
643 gdk_gc_set_clip_rectangle(collection->xor_gc, &clip);
644 draw_lasso_box(collection);
645 gdk_gc_set_clip_rectangle(collection->xor_gc, NULL);
646 }
647
648 return FALSE;
649 }
650
651 static void default_draw_item( GtkWidget *widget,
652 CollectionItem *item,
653 GdkRectangle *area)
654 {
655 gdk_draw_arc(widget->window,
656 item->selected ? widget->style->white_gc
657 : widget->style->black_gc,
658 TRUE,
659 area->x, area->y,
660 area->width, area->height,
661 0, 360 * 64);
662 }
663
664
665 static gboolean default_test_point(Collection *collection,
666 int point_x, int point_y,
667 CollectionItem *item,
668 int width, int height)
669 {
670 float f_x, f_y;
671
672 /* Convert to point in unit circle */
673 f_x = ((float) point_x / width) - 0.5;
674 f_y = ((float) point_y / height) - 0.5;
675
676 return (f_x * f_x) + (f_y * f_y) <= .25;
677 }
678
679 static void collection_set_arg( GtkObject *object,
680 GtkArg *arg,
681 guint arg_id)
682 {
683 Collection *collection;
684
685 collection = COLLECTION(object);
686
687 switch (arg_id)
688 {
689 case ARG_VADJUSTMENT:
690 collection_set_adjustment(collection,
691 GTK_VALUE_POINTER(*arg));
692 break;
693 default:
694 break;
695 }
696 }
697
698 static void collection_set_adjustment( Collection *collection,
699 GtkAdjustment *vadj)
700 {
701 if (vadj)
702 g_return_if_fail (GTK_IS_ADJUSTMENT (vadj));
703 else
704 vadj = GTK_ADJUSTMENT(gtk_adjustment_new(0.0,
705 0.0, 0.0,
706 0.0, 0.0, 0.0));
707 if (collection->vadj && (collection->vadj != vadj))
708 {
709 gtk_signal_disconnect_by_data(GTK_OBJECT(collection->vadj),
710 collection);
711 gtk_object_unref(GTK_OBJECT(collection->vadj));
712 }
713
714 if (collection->vadj != vadj)
715 {
716 collection->vadj = vadj;
717 gtk_object_ref(GTK_OBJECT(collection->vadj));
718 gtk_object_sink(GTK_OBJECT(collection->vadj));
719
720 gtk_signal_connect(GTK_OBJECT(collection->vadj),
721 "changed",
722 (GtkSignalFunc) collection_adjustment,
723 collection);
724 gtk_signal_connect(GTK_OBJECT(collection->vadj),
725 "value_changed",
726 (GtkSignalFunc) collection_adjustment,
727 collection);
728 gtk_signal_connect(GTK_OBJECT(collection->vadj),
729 "disconnect",
730 (GtkSignalFunc) collection_disconnect,
731 collection);
732 collection_adjustment(vadj, collection);
733 }
734 }
735
736 static void collection_get_arg( GtkObject *object,
737 GtkArg *arg,
738 guint arg_id)
739 {
740 Collection *collection;
741
742 collection = COLLECTION(object);
743
744 switch (arg_id)
745 {
746 case ARG_VADJUSTMENT:
747 GTK_VALUE_POINTER(*arg) = collection->vadj;
748 break;
749 default:
750 arg->type = GTK_TYPE_INVALID;
751 break;
752 }
753 }
754
755 /* Something about the adjustment has changed */
756 static void collection_adjustment(GtkAdjustment *adjustment,
757 Collection *collection)
758 {
759 gint diff;
760
761 g_return_if_fail(adjustment != NULL);
762 g_return_if_fail(GTK_IS_ADJUSTMENT(adjustment));
763 g_return_if_fail(collection != NULL);
764 g_return_if_fail(IS_COLLECTION(collection));
765
766 diff = ((gint) adjustment->value) - collection->last_scroll;
767
768 if (diff)
769 {
770 collection->last_scroll = adjustment->value;
771
772 scroll_by(collection, diff);
773 }
774 }
775
776 static void collection_disconnect(GtkAdjustment *adjustment,
777 Collection *collection)
778 {
779 g_return_if_fail(adjustment != NULL);
780 g_return_if_fail(GTK_IS_ADJUSTMENT(adjustment));
781 g_return_if_fail(collection != NULL);
782 g_return_if_fail(IS_COLLECTION(collection));
783
784 collection_set_adjustment(collection, NULL);
785 }
786
787 static void set_vadjustment(Collection *collection)
788 {
789 GtkWidget *widget;
790 guint height;
791 int cols, rows;
792
793 widget = GTK_WIDGET(collection);
794
795 if (!GTK_WIDGET_REALIZED(widget))
796 return;
797
798 gdk_window_get_size(widget->window, NULL, &height);
799 cols = collection->columns;
800 rows = (collection->number_of_items + cols - 1) / cols;
801
802 collection->vadj->lower = 0.0;
803 collection->vadj->upper = collection->item_height * rows;
804
805 collection->vadj->step_increment =
806 MIN(collection->vadj->upper, collection->item_height / 4);
807
808 collection->vadj->page_increment =
809 MIN(collection->vadj->upper,
810 height - 5.0);
811
812 collection->vadj->page_size = MIN(collection->vadj->upper, height);
813
814 collection->vadj->value = MIN(collection->vadj->value,
815 collection->vadj->upper - collection->vadj->page_size);
816
817 collection->vadj->value = MAX(collection->vadj->value, 0.0);
818
819 gtk_signal_emit_by_name(GTK_OBJECT(collection->vadj), "changed");
820 }
821
822 static void collection_draw(GtkWidget *widget, GdkRectangle *area)
823 {
824 Collection *collection;
825
826 g_return_if_fail(widget != NULL);
827 g_return_if_fail(IS_COLLECTION(widget));
828 g_return_if_fail(area != NULL); /* Not actually used */
829
830 collection = COLLECTION(widget);
831
832 if (collection->paint_level > PAINT_NORMAL)
833 collection_paint(collection, area);
834 }
835
836 static gint collection_expose(GtkWidget *widget, GdkEventExpose *event)
837 {
838 g_return_val_if_fail(widget != NULL, FALSE);
839 g_return_val_if_fail(IS_COLLECTION(widget), FALSE);
840 g_return_val_if_fail(event != NULL, FALSE);
841
842 collection_paint(COLLECTION(widget), &event->area);
843
844 return FALSE;
845 }
846
847 /* Positive makes the contents go move up the screen */
848 static void scroll_by(Collection *collection, gint diff)
849 {
850 GtkWidget *widget;
851 guint width, height;
852 guint from_y, to_y;
853 guint amount;
854 GdkRectangle new_area;
855
856 if (diff == 0)
857 return;
858
859 widget = GTK_WIDGET(collection);
860
861 if (collection->lasso_box)
862 remove_lasso_box(collection);
863
864 gdk_window_get_size(widget->window, &width, &height);
865 new_area.x = 0;
866 new_area.width = width;
867
868 if (diff > 0)
869 {
870 amount = diff;
871 from_y = amount;
872 to_y = 0;
873 new_area.y = height - amount;
874 }
875 else
876 {
877 amount = -diff;
878 from_y = 0;
879 to_y = amount;
880 new_area.y = 0;
881 }
882
883 new_area.height = amount;
884
885 if (amount < height)
886 {
887 gdk_draw_pixmap(widget->window,
888 widget->style->white_gc,
889 widget->window,
890 0,
891 from_y,
892 0,
893 to_y,
894 width,
895 height - amount);
896 /* We have to redraw everything because any pending
897 * expose events now contain invalid areas.
898 * Don't need to clear the area first though...
899 */
900 if (collection->paint_level < PAINT_OVERWRITE)
901 collection->paint_level = PAINT_OVERWRITE;
902 }
903 else
904 collection->paint_level = PAINT_CLEAR;
905
906 gdk_window_clear_area(widget->window,
907 0, new_area.y,
908 width, new_area.height);
909 collection_paint(collection, NULL);
910 }
911
912 static void resize_arrays(Collection *collection, guint new_size)
913 {
914 g_return_if_fail(collection != NULL);
915 g_return_if_fail(IS_COLLECTION(collection));
916 g_return_if_fail(new_size >= collection->number_of_items);
917
918 collection->items = g_realloc(collection->items,
919 sizeof(CollectionItem) * new_size);
920 collection->array_size = new_size;
921 }
922
923 static void return_pressed(Collection *collection)
924 {
925 int item = collection->cursor_item;
926 CollectionTargetFunc cb = collection->target_cb;
927 gpointer data = collection->target_data;
928
929 collection_target(collection, NULL, NULL);
930 if (item < 0 || item >= collection->number_of_items)
931 return;
932
933 if (cb)
934 {
935 cb(collection, item, data);
936 return;
937 }
938
939 gtk_signal_emit(GTK_OBJECT(collection),
940 collection_signals[OPEN_ITEM],
941 collection->items[item].data,
942 item);
943 }
944
945 static gint collection_key_press(GtkWidget *widget, GdkEventKey *event)
946 {
947 Collection *collection;
948 int item;
949
950 g_return_val_if_fail(widget != NULL, FALSE);
951 g_return_val_if_fail(IS_COLLECTION(widget), FALSE);
952 g_return_val_if_fail(event != NULL, FALSE);
953
954 collection = (Collection *) widget;
955 item = collection->cursor_item;
956
957 switch (event->keyval)
958 {
959 case GDK_Left:
960 collection_move_cursor(collection, 0, -1);
961 break;
962 case GDK_Right:
963 collection_move_cursor(collection, 0, 1);
964 break;
965 case GDK_Up:
966 collection_move_cursor(collection, -1, 0);
967 break;
968 case GDK_Down:
969 collection_move_cursor(collection, 1, 0);
970 break;
971 case GDK_Home:
972 collection_set_cursor_item(collection, 0);
973 break;
974 case GDK_End:
975 collection_set_cursor_item(collection,
976 MAX((gint) collection->number_of_items - 1, 0));
977 break;
978 case GDK_Page_Up:
979 collection_move_cursor(collection, -10, 0);
980 break;
981 case GDK_Page_Down:
982 collection_move_cursor(collection, 10, 0);
983 break;
984 case GDK_Return:
985 return_pressed(collection);
986 break;
987 case GDK_Escape:
988 if (!collection->target_cb)
989 return FALSE; /* Pass it on */
990 collection_target(collection, NULL, NULL);
991 break;
992 case ' ':
993 if (item >=0 && item < collection->number_of_items)
994 collection_toggle_item(collection, item);
995 break;
996 default:
997 return FALSE;
998 }
999
1000 return TRUE;
1001 }
1002
1003 static gint collection_button_press(GtkWidget *widget,
1004 GdkEventButton *event)
1005 {
1006 Collection *collection;
1007 int row, col;
1008 int item;
1009 int action;
1010 int scroll;
1011 guint stacked_time;
1012
1013 g_return_val_if_fail(widget != NULL, FALSE);
1014 g_return_val_if_fail(IS_COLLECTION(widget), FALSE);
1015 g_return_val_if_fail(event != NULL, FALSE);
1016
1017 collection = COLLECTION(widget);
1018
1019 collection->item_clicked = -1;
1020
1021 if (event->button > 3)
1022 {
1023 int diff;
1024
1025 /* Wheel mouse scrolling */
1026 if (event->button == 4)
1027 diff = -((signed int) collection->item_height) / 4;
1028 else if (event->button == 5)
1029 diff = collection->item_height / 4;
1030 else
1031 diff = 0;
1032
1033 if (diff)
1034 {
1035 int old_value = collection->vadj->value;
1036 int new_value = 0;
1037 gboolean box = collection->lasso_box;
1038
1039 new_value = CLAMP(old_value + diff, 0.0,
1040 collection->vadj->upper
1041 - collection->vadj->page_size);
1042 diff = new_value - old_value;
1043 if (diff)
1044 {
1045 if (box)
1046 {
1047 remove_lasso_box(collection);
1048 collection->drag_box_y[0] -= diff;
1049 }
1050 collection->vadj->value = new_value;
1051 gtk_signal_emit_by_name(
1052 GTK_OBJECT(collection->vadj),
1053 "changed");
1054 if (box)
1055 add_lasso_box(collection);
1056 }
1057 }
1058 return FALSE;
1059 }
1060
1061 if (collection->cursor_item != -1)
1062 collection_set_cursor_item(collection, -1);
1063
1064 scroll = collection->vadj->value;
1065
1066 if (event->type == GDK_BUTTON_PRESS &&
1067 event->button != collection_menu_button)
1068 {
1069 if (collection->buttons_pressed++ == 0)
1070 gtk_grab_add(widget);
1071 else
1072 return FALSE; /* Ignore extra presses */
1073 }
1074
1075 if (event->state & GDK_CONTROL_MASK)
1076 action = 2;
1077 else
1078 action = event->button;
1079
1080 /* Ignore all clicks while we are dragging a lasso box */
1081 if (collection->lasso_box)
1082 return TRUE;
1083
1084 col = event->x / collection->item_width;
1085 row = (event->y + scroll) / collection->item_height;
1086
1087 if (col < 0 || row < 0 || col >= collection->columns)
1088 item = -1;
1089 else
1090 {
1091 item = col + row * collection->columns;
1092 if (item >= collection->number_of_items
1093 ||
1094 !collection->test_point(collection,
1095 event->x - col * collection->item_width,
1096 event->y - row * collection->item_height
1097 + scroll,
1098 &collection->items[item],
1099 collection->item_width,
1100 collection->item_height))
1101 {
1102 item = -1;
1103 }
1104 }
1105
1106 if (collection->target_cb)
1107 {
1108 CollectionTargetFunc cb = collection->target_cb;
1109 gpointer data = collection->target_data;
1110
1111 collection_target(collection, NULL, NULL);
1112 if (collection->buttons_pressed)
1113 {
1114 gtk_grab_remove(widget);
1115 collection->buttons_pressed = 0;
1116 }
1117 if (item > -1 && event->button != collection_menu_button)
1118 cb(collection, item, data);
1119 return TRUE;
1120 }
1121
1122 collection->drag_box_x[0] = event->x;
1123 collection->drag_box_y[0] = event->y;
1124 collection->item_clicked = item;
1125
1126 stacked_time = current_event_time;
1127 current_event_time = event->time;
1128
1129 if (event->button == collection_menu_button)
1130 {
1131 gtk_signal_emit(GTK_OBJECT(collection),
1132 collection_signals[SHOW_MENU],
1133 event,
1134 item);
1135 }
1136 else if (event->type == GDK_2BUTTON_PRESS && collection->panel)
1137 {
1138 /* Do nothing */
1139 }
1140 else if ((event->type == GDK_2BUTTON_PRESS && !collection_single_click)
1141 || collection->panel)
1142 {
1143 if (item >= 0)
1144 {
1145 if (collection->buttons_pressed)
1146 {
1147 gtk_grab_remove(widget);
1148 collection->buttons_pressed = 0;
1149 }
1150 collection_unselect_item(collection, item);
1151 gtk_signal_emit(GTK_OBJECT(collection),
1152 collection_signals[OPEN_ITEM],
1153 collection->items[item].data,
1154 item);
1155 }
1156 }
1157 else if (event->type == GDK_BUTTON_PRESS)
1158 {
1159 collection->may_drag = event->button != collection_menu_button;
1160
1161 if (item >= 0)
1162 {
1163 if (action == 1)
1164 {
1165 if (!collection->items[item].selected)
1166 {
1167 collection_select_item(collection,
1168 item);
1169 collection_clear_except(collection,
1170 item);
1171 }
1172 }
1173 else
1174 collection_toggle_item(collection, item);
1175 }
1176 else if (action == 1)
1177 collection_clear_selection(collection);
1178 }
1179
1180 current_event_time = stacked_time;
1181 return FALSE;
1182 }
1183
1184 static gint collection_button_release(GtkWidget *widget,
1185 GdkEventButton *event)
1186 {
1187 Collection *collection;
1188 int top, bottom;
1189 int row, last_row;
1190 int w, h;
1191 int col, start_col, last_col;
1192 int scroll;
1193 int item;
1194 guint stacked_time;
1195 int button;
1196
1197 g_return_val_if_fail(widget != NULL, FALSE);
1198 g_return_val_if_fail(IS_COLLECTION(widget), FALSE);
1199 g_return_val_if_fail(event != NULL, FALSE);
1200
1201 collection = COLLECTION(widget);
1202 button = event->button;
1203
1204 scroll = collection->vadj->value;
1205
1206 if (event->button > 3 || event->button == collection_menu_button)
1207 return FALSE;
1208 if (collection->buttons_pressed == 0)
1209 return FALSE;
1210 if (--collection->buttons_pressed == 0)
1211 gtk_grab_remove(widget);
1212 else
1213 return FALSE; /* Wait until ALL buttons are up */
1214
1215 if (!collection->lasso_box)
1216 {
1217 int item = collection->item_clicked;
1218
1219 if (collection_single_click && item > -1
1220 && item < collection->number_of_items
1221 && (event->state & GDK_CONTROL_MASK) == 0)
1222 {
1223 int dx = event->x - collection->drag_box_x[0];
1224 int dy = event->y - collection->drag_box_y[0];
1225
1226 if (ABS(dx) + ABS(dy) > 9)
1227 return FALSE;
1228
1229 collection_unselect_item(collection, item);
1230 gtk_signal_emit(GTK_OBJECT(collection),
1231 collection_signals[OPEN_ITEM],
1232 collection->items[item].data,
1233 item);
1234 }
1235
1236 return FALSE;
1237 }
1238
1239 remove_lasso_box(collection);
1240
1241 w = collection->item_width;
1242 h = collection->item_height;
1243
1244 top = collection->drag_box_y[0] + scroll;
1245 bottom = collection->drag_box_y[1] + scroll;
1246 if (top > bottom)
1247 {
1248 int tmp;
1249 tmp = top;
1250 top = bottom;
1251 bottom = tmp;
1252 }
1253 top += h / 4;
1254 bottom -= h / 4;
1255
1256 row = MAX(top / h, 0);
1257 last_row = bottom / h;
1258
1259 top = collection->drag_box_x[0]; /* (left) */
1260 bottom = collection->drag_box_x[1];
1261 if (top > bottom)
1262 {
1263 int tmp;
1264 tmp = top;
1265 top = bottom;
1266 bottom = tmp;
1267 }
1268 top += w / 4;
1269 bottom -= w / 4;
1270 start_col = MAX(top / w, 0);
1271 last_col = bottom / w;
1272 if (last_col >= collection->columns)
1273 last_col = collection->columns - 1;
1274
1275 stacked_time = current_event_time;
1276 current_event_time = event->time;
1277
1278 while (row <= last_row)
1279 {
1280 col = start_col;
1281 item = row * collection->columns + col;
1282 while (col <= last_col)
1283 {
1284 if (item >= collection->number_of_items)
1285 {
1286 current_event_time = stacked_time;
1287 return FALSE;
1288 }
1289
1290 if (button == 1)
1291 collection_select_item(collection, item);
1292 else
1293 collection_toggle_item(collection, item);
1294 col++;
1295 item++;
1296 }
1297 row++;
1298 }
1299
1300 current_event_time = stacked_time;
1301
1302 return FALSE;
1303 }
1304
1305 static gint collection_motion_notify(GtkWidget *widget,
1306 GdkEventMotion *event)
1307 {
1308 Collection *collection;
1309 int x, y;
1310 guint stacked_time;
1311
1312 g_return_val_if_fail(widget != NULL, FALSE);
1313 g_return_val_if_fail(IS_COLLECTION(widget), FALSE);
1314 g_return_val_if_fail(event != NULL, FALSE);
1315
1316 collection = COLLECTION(widget);
1317
1318 if (collection->buttons_pressed == 0)
1319 return FALSE;
1320
1321 stacked_time = current_event_time;
1322 current_event_time = event->time;
1323
1324 if (event->window != widget->window)
1325 gdk_window_get_pointer(widget->window, &x, &y, NULL);
1326 else
1327 {
1328 x = event->x;
1329 y = event->y;
1330 }
1331
1332 if (collection->lasso_box)
1333 {
1334 int new_value = 0, diff;
1335 int height;
1336
1337 gdk_window_get_size(widget->window, NULL, &height);
1338
1339 if (y < 0)
1340 {
1341 int old_value = collection->vadj->value;
1342
1343 new_value = MAX(old_value + y / 10, 0.0);
1344 diff = new_value - old_value;
1345 }
1346 else if (y > height)
1347 {
1348 int old_value = collection->vadj->value;
1349
1350 new_value = MIN(old_value + (y - height) / 10,
1351 collection->vadj->upper
1352 - collection->vadj->page_size);
1353 diff = new_value - old_value;
1354 }
1355 else
1356 diff = 0;
1357
1358 remove_lasso_box(collection);
1359 collection->drag_box_x[1] = x;
1360 collection->drag_box_y[1] = y;
1361
1362 if (diff)
1363 {
1364 collection->drag_box_y[0] -= diff;
1365 collection->vadj->value = new_value;
1366 gtk_signal_emit_by_name(GTK_OBJECT(collection->vadj),
1367 "changed");
1368 }
1369 add_lasso_box(collection);
1370 }
1371 else if (collection->may_drag)
1372 {
1373 int dx = x - collection->drag_box_x[0];
1374 int dy = y - collection->drag_box_y[0];
1375
1376 if (abs(dx) > 9 || abs(dy) > 9)
1377 {
1378 int row, col, item;
1379 int scroll = collection->vadj->value;
1380
1381 collection->may_drag = FALSE;
1382
1383 col = collection->drag_box_x[0]
1384 / collection->item_width;
1385 row = (collection->drag_box_y[0] + scroll)
1386 / collection->item_height;
1387 item = item_at_row_col(collection, row, col);
1388
1389 if (item != -1 && collection->test_point(collection,
1390 collection->drag_box_x[0] -
1391 col * collection->item_width,
1392 collection->drag_box_y[0]
1393 - row * collection->item_height
1394 + scroll,
1395 &collection->items[item],
1396 collection->item_width,
1397 collection->item_height))
1398 {
1399 collection->buttons_pressed = 0;
1400 gtk_grab_remove(widget);
1401 collection_select_item(collection, item);
1402 gtk_signal_emit(GTK_OBJECT(collection),
1403 collection_signals[DRAG_SELECTION],
1404 event,
1405 collection->number_selected);
1406 }
1407 else
1408 {
1409 collection->drag_box_x[1] = x;
1410 collection->drag_box_y[1] = y;
1411 add_lasso_box(collection);
1412 }
1413 }
1414 }
1415
1416 current_event_time = stacked_time;
1417 return FALSE;
1418 }
1419
1420 static void add_lasso_box(Collection *collection)
1421 {
1422 g_return_if_fail(collection != NULL);
1423 g_return_if_fail(IS_COLLECTION(collection));
1424 g_return_if_fail(collection->lasso_box == FALSE);
1425
1426 collection->lasso_box = TRUE;
1427 draw_lasso_box(collection);
1428 }
1429
1430 static void draw_lasso_box(Collection *collection)
1431 {
1432 GtkWidget *widget;
1433 int x, y, width, height;
1434
1435 widget = GTK_WIDGET(collection);
1436
1437 x = MIN(collection->drag_box_x[0], collection->drag_box_x[1]);
1438 y = MIN(collection->drag_box_y[0], collection->drag_box_y[1]);
1439 width = abs(collection->drag_box_x[1] - collection->drag_box_x[0]);
1440 height = abs(collection->drag_box_y[1] - collection->drag_box_y[0]);
1441
1442 gdk_draw_rectangle(widget->window, collection->xor_gc, FALSE,
1443 x, y, width, height);
1444 }
1445
1446 static void remove_lasso_box(Collection *collection)
1447 {
1448 g_return_if_fail(collection != NULL);
1449 g_return_if_fail(IS_COLLECTION(collection));
1450 g_return_if_fail(collection->lasso_box == TRUE);
1451
1452 draw_lasso_box(collection);
1453
1454 collection->lasso_box = FALSE;
1455
1456 return;
1457 }
1458
1459 /* Convert a row,col address to an item number, or -1 if none */
1460 static int item_at_row_col(Collection *collection, int row, int col)
1461 {
1462 int item;
1463
1464 if (row < 0 || col < 0 || col >= collection->columns)
1465 return -1;
1466
1467 item = col + row * collection->columns;
1468
1469 if (item >= collection->number_of_items)
1470 return -1;
1471 return item;
1472 }
1473
1474 /* Make sure that 'item' is fully visible (vertically), scrolling if not. */
1475 static void scroll_to_show(Collection *collection, int item)
1476 {
1477 int first, last, row;
1478
1479 g_return_if_fail(collection != NULL);
1480 g_return_if_fail(IS_COLLECTION(collection));
1481
1482 row = item / collection->columns;
1483 get_visible_limits(collection, &first, &last);
1484
1485 if (row <= first)
1486 {
1487 gtk_adjustment_set_value(collection->vadj,
1488 row * collection->item_height);
1489 }
1490 else if (row >= last)
1491 {
1492 GtkWidget *widget = (GtkWidget *) collection;
1493 int height;
1494
1495 if (GTK_WIDGET_REALIZED(widget))
1496 {
1497 gdk_window_get_size(widget->window, NULL, &height);
1498 gtk_adjustment_set_value(collection->vadj,
1499 (row + 1) * collection->item_height - height);
1500 }
1501 }
1502 }
1503
1504 /* Return the first and last rows which are [partly] visible. Does not
1505 * ensure that the rows actually exist (contain items).
1506 */
1507 static void get_visible_limits(Collection *collection, int *first, int *last)
1508 {
1509 GtkWidget *widget = (GtkWidget *) collection;
1510 int scroll, height;
1511
1512 g_return_if_fail(collection != NULL);
1513 g_return_if_fail(IS_COLLECTION(collection));
1514 g_return_if_fail(first != NULL && last != NULL);
1515
1516 if (!GTK_WIDGET_REALIZED(widget))
1517 {
1518 *first = 0;
1519 *last = 0;
1520 }
1521 else
1522 {
1523 scroll = collection->vadj->value;
1524 gdk_window_get_size(widget->window, NULL, &height);
1525
1526 *first = MAX(scroll / collection->item_height, 0);
1527 *last = (scroll + height - 1) /collection->item_height;
1528
1529 if (*last < *first)
1530 *last = *first;
1531 }
1532 }
1533
1534 /* Unselect all items except number item (-1 to unselect everything) */
1535 static void collection_clear_except(Collection *collection, gint exception)
1536 {
1537 GtkWidget *widget;
1538 GdkRectangle area;
1539 int item = 0;
1540 int scroll;
1541 int end; /* Selected items to end up with */
1542
1543 widget = GTK_WIDGET(collection);
1544 scroll = collection->vadj->value;
1545
1546 end = exception >= 0 && exception < collection->number_of_items
1547 ? collection->items[exception].selected != 0 : 0;
1548
1549 area.width = collection->item_width;
1550 area.height = collection->item_height;
1551
1552 if (collection->number_selected == 0)
1553 return;
1554
1555 while (collection->number_selected > end)
1556 {
1557 while (item == exception || !collection->items[item].selected)
1558 item++;
1559
1560 area.x = (item % collection->columns) * area.width;
1561 area.y = (item / collection->columns) * area.height
1562 - scroll;
1563
1564 collection->items[item++].selected = FALSE;
1565 gdk_window_clear_area(widget->window,
1566 area.x, area.y, area.width, area.height);
1567 collection_paint(collection, &area);
1568
1569 collection->number_selected--;
1570 }
1571
1572 if (end == 0)
1573 gtk_signal_emit(GTK_OBJECT(collection),
1574 collection_signals[LOSE_SELECTION],
1575 current_event_time);
1576 }
1577
1578 /* Cancel the current wink effect. */
1579 static void cancel_wink(Collection *collection)
1580 {
1581 gint item;
1582
1583 g_return_if_fail(collection != NULL);
1584 g_return_if_fail(IS_COLLECTION(collection));
1585 g_return_if_fail(collection->wink_item != -1);
1586
1587 item = collection->wink_item;
1588
1589 collection->wink_item = -1;
1590 gtk_timeout_remove(collection->wink_timeout);
1591
1592 collection_draw_item(collection, item, TRUE);
1593 }
1594
1595 static gboolean cancel_wink_timeout(Collection *collection)
1596 {
1597 gint item;
1598
1599 g_return_val_if_fail(collection != NULL, FALSE);
1600 g_return_val_if_fail(IS_COLLECTION(collection), FALSE);
1601 g_return_val_if_fail(collection->wink_item != -1, FALSE);
1602
1603 item = collection->wink_item;
1604
1605 collection->wink_item = -1;
1606
1607 collection_draw_item(collection, item, TRUE);
1608
1609 return FALSE;
1610 }
1611
1612 static gint focus_in(GtkWidget *widget, GdkEventFocus *event)
1613 {
1614 g_return_val_if_fail(widget != NULL, FALSE);
1615 g_return_val_if_fail(IS_COLLECTION(widget), FALSE);
1616 g_return_val_if_fail(event != NULL, FALSE);
1617
1618 GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_FOCUS);
1619 gtk_widget_draw_focus(widget);
1620
1621 return FALSE;
1622 }
1623
1624 static gint focus_out(GtkWidget *widget, GdkEventFocus *event)
1625 {
1626 g_return_val_if_fail(widget != NULL, FALSE);
1627 g_return_val_if_fail(IS_COLLECTION(widget), FALSE);
1628 g_return_val_if_fail(event != NULL, FALSE);
1629
1630 GTK_WIDGET_UNSET_FLAGS(widget, GTK_HAS_FOCUS);
1631 gtk_widget_draw_focus(widget);
1632
1633 return FALSE;
1634 }
1635
1636 /* Functions for managing collections */
1637
1638 /* Remove all objects from the collection */
1639 void collection_clear(Collection *collection)
1640 {
1641 int prev_selected;
1642
1643 g_return_if_fail(IS_COLLECTION(collection));
1644
1645 if (collection->number_of_items == 0)
1646 return;
1647
1648 if (collection->wink_item != -1)
1649 {
1650 collection->wink_item = -1;
1651 gtk_timeout_remove(collection->wink_timeout);
1652 }
1653
1654 collection_set_cursor_item(collection,
1655 collection->cursor_item == -1 ? -1: 0);
1656 prev_selected = collection->number_selected;
1657 collection->number_of_items = collection->number_selected = 0;
1658
1659 resize_arrays(collection, MINIMUM_ITEMS);
1660
1661 collection->paint_level = PAINT_CLEAR;
1662
1663 gtk_widget_queue_clear(GTK_WIDGET(collection));
1664
1665 if (prev_selected && collection->number_selected == 0)
1666 gtk_signal_emit(GTK_OBJECT(collection),
1667 collection_signals[LOSE_SELECTION],
1668 current_event_time);
1669 }
1670
1671 /* Inserts a new item at the end. The new item is unselected, and its
1672 * number is returned.
1673 */
1674 gint collection_insert(Collection *collection, gpointer data)
1675 {
1676 int item;
1677
1678 g_return_val_if_fail(IS_COLLECTION(collection), -1);
1679
1680 item = collection->number_of_items;
1681
1682 if (item >= collection->array_size)
1683 resize_arrays(collection, item + (item >> 1));
1684
1685 collection->items[item].data = data;
1686 collection->items[item].selected = FALSE;
1687
1688 collection->number_of_items++;
1689
1690 if (GTK_WIDGET_REALIZED(GTK_WIDGET(collection)))
1691 {
1692 set_vadjustment(collection);
1693 collection_draw_item(collection,
1694 collection->number_of_items - 1,
1695 FALSE);
1696 }
1697
1698 return item;
1699 }
1700
1701 /* Unselect an item by number */
1702 void collection_unselect_item(Collection *collection, gint item)
1703 {
1704 g_return_if_fail(collection != NULL);
1705 g_return_if_fail(IS_COLLECTION(collection));
1706 g_return_if_fail(item >= 0 && item < collection->number_of_items);
1707
1708 if (collection->items[item].selected)
1709 {
1710 collection->items[item].selected = FALSE;
1711 collection_draw_item(collection, item, TRUE);
1712
1713 if (--collection->number_selected == 0)
1714 gtk_signal_emit(GTK_OBJECT(collection),
1715 collection_signals[LOSE_SELECTION],
1716 current_event_time);
1717 }
1718 }
1719
1720 /* Select an item by number */
1721 void collection_select_item(Collection *collection, gint item)
1722 {
1723 g_return_if_fail(collection != NULL);
1724 g_return_if_fail(IS_COLLECTION(collection));
1725 g_return_if_fail(item >= 0 && item < collection->number_of_items);
1726
1727 if (collection->items[item].selected)
1728 return; /* Already selected */
1729
1730 collection->items[item].selected = TRUE;
1731 collection_draw_item(collection, item, TRUE);
1732
1733 if (collection->number_selected++ == 0)
1734 gtk_signal_emit(GTK_OBJECT(collection),
1735 collection_signals[GAIN_SELECTION],
1736 current_event_time);
1737 }
1738
1739 /* Toggle the selected state of an item (by number) */
1740 void collection_toggle_item(Collection *collection, gint item)
1741 {
1742 g_return_if_fail(collection != NULL);
1743 g_return_if_fail(IS_COLLECTION(collection));
1744 g_return_if_fail(item >= 0 && item < collection->number_of_items);
1745
1746 if (collection->items[item].selected)
1747 {
1748 collection->items[item].selected = FALSE;
1749 if (--collection->number_selected == 0)
1750 gtk_signal_emit(GTK_OBJECT(collection),
1751 collection_signals[LOSE_SELECTION],
1752 current_event_time);
1753 }
1754 else
1755 {
1756 collection->items[item].selected = TRUE;
1757 if (collection->number_selected++ == 0)
1758 gtk_signal_emit(GTK_OBJECT(collection),
1759 collection_signals[GAIN_SELECTION],
1760 current_event_time);
1761 }
1762 collection_draw_item(collection, item, TRUE);
1763 }
1764
1765 /* Select all items in the collection */
1766 void collection_select_all(Collection *collection)
1767 {
1768 GtkWidget *widget;
1769 GdkRectangle area;
1770 int item = 0;
1771 int scroll;
1772
1773 g_return_if_fail(collection != NULL);
1774 g_return_if_fail(IS_COLLECTION(collection));
1775
1776 widget = GTK_WIDGET(collection);
1777 scroll = collection->vadj->value;
1778
1779 area.width = collection->item_width;
1780 area.height = collection->item_height;
1781
1782 if (collection->number_selected == collection->number_of_items)
1783 return; /* Nothing to do */
1784
1785 while (collection->number_selected < collection->number_of_items)
1786 {
1787 while (collection->items[item].selected)
1788 item++;
1789
1790 area.x = (item % collection->columns) * area.width;
1791 area.y = (item / collection->columns) * area.height
1792 - scroll;
1793
1794 collection->items[item++].selected = TRUE;
1795 gdk_window_clear_area(widget->window,
1796 area.x, area.y, area.width, area.height);
1797 collection_paint(collection, &area);
1798
1799 collection->number_selected++;
1800 }
1801
1802 gtk_signal_emit(GTK_OBJECT(collection),
1803 collection_signals[GAIN_SELECTION],
1804 current_event_time);
1805 }
1806
1807 /* Unselect all items in the collection */
1808 void collection_clear_selection(Collection *collection)
1809 {
1810 g_return_if_fail(collection != NULL);
1811 g_return_if_fail(IS_COLLECTION(collection));
1812
1813 collection_clear_except(collection, -1);
1814 }
1815
1816 /* Force a redraw of the specified item, if it is visible */
1817 void collection_draw_item(Collection *collection, gint item, gboolean blank)
1818 {
1819 int height;
1820 GdkRectangle area;
1821 GtkWidget *widget;
1822 int row, col;
1823 int scroll;
1824 int area_y, area_height; /* NOT shorts! */
1825
1826 g_return_if_fail(collection != NULL);
1827 g_return_if_fail(IS_COLLECTION(collection));
1828 g_return_if_fail(item >= 0 &&
1829 (item == 0 || item < collection->number_of_items));
1830
1831 widget = GTK_WIDGET(collection);
1832 if (!GTK_WIDGET_REALIZED(widget))
1833 return;
1834
1835 col = item % collection->columns;
1836 row = item / collection->columns;
1837 scroll = collection->vadj->value; /* (round to int) */
1838
1839 area.x = col * collection->item_width;
1840 area_y = row * collection->item_height - scroll;
1841 area.width = collection->item_width;
1842 area_height = collection->item_height;
1843
1844 if (area_y + area_height < 0)
1845 return;
1846
1847 gdk_window_get_size(widget->window, NULL, &height);
1848
1849 if (area_y > height)
1850 return;
1851
1852 area.y = area_y;
1853 area.height = area_height;
1854
1855 if (blank || collection->lasso_box)
1856 gdk_window_clear_area(widget->window,
1857 area.x, area.y, area.width, area.height);
1858
1859 draw_one_item(collection, item, &area);
1860
1861 if (collection->lasso_box)
1862 {
1863 gdk_gc_set_clip_rectangle(collection->xor_gc, &area);
1864 draw_lasso_box(collection);
1865 gdk_gc_set_clip_rectangle(collection->xor_gc, NULL);
1866 }
1867 }
1868
1869 void collection_set_item_size(Collection *collection, int width, int height)
1870 {
1871 GtkWidget *widget;
1872
1873 g_return_if_fail(collection != NULL);
1874 g_return_if_fail(IS_COLLECTION(collection));
1875 g_return_if_fail(width > 4 && height > 4);
1876
1877 widget = GTK_WIDGET(collection);
1878
1879 collection->item_width = width;
1880 collection->item_height = height;
1881
1882 if (GTK_WIDGET_REALIZED(widget))
1883 {
1884 int window_width;
1885
1886 collection->paint_level = PAINT_CLEAR;
1887 gdk_window_get_size(widget->window, &window_width, NULL);
1888 collection->columns = MAX(window_width / collection->item_width,
1889 1);
1890
1891 set_vadjustment(collection);
1892 if (collection->cursor_item != -1)
1893 scroll_to_show(collection, collection->cursor_item);
1894 gtk_widget_queue_draw(widget);
1895 }
1896 }
1897
1898 /* Cursor is positioned on item with the same data as before the sort.
1899 * Same for the wink item.
1900 */
1901 void collection_qsort(Collection *collection,
1902 int (*compar)(const void *, const void *))
1903 {
1904 int cursor, wink, items;
1905 gpointer cursor_data = NULL;
1906 gpointer wink_data = NULL;
1907
1908 g_return_if_fail(collection != NULL);
1909 g_return_if_fail(IS_COLLECTION(collection));
1910 g_return_if_fail(compar != NULL);
1911
1912 items = collection->number_of_items;
1913
1914 wink = collection->wink_item;
1915 if (wink >= 0 && wink < items)
1916 wink_data = collection->items[wink].data;
1917 else
1918 wink = -1;
1919
1920 cursor = collection->cursor_item;
1921 if (cursor >= 0 && cursor < items)
1922 cursor_data = collection->items[cursor].data;
1923 else
1924 cursor = -1;
1925
1926 if (collection->wink_item != -1)
1927 {
1928 collection->wink_item = -1;
1929 gtk_timeout_remove(collection->wink_timeout);
1930 }
1931
1932 qsort(collection->items, items, sizeof(collection->items[0]), compar);
1933
1934 if (cursor > -1 || wink > -1)
1935 {
1936 int item;
1937
1938 for (item = 0; item < items; item++)
1939 {
1940 if (collection->items[item].data == cursor_data)
1941 collection_set_cursor_item(collection, item);
1942 if (collection->items[item].data == wink_data)
1943 collection_wink_item(collection, item);
1944 }
1945 }
1946
1947 collection->paint_level = PAINT_CLEAR;
1948
1949 gtk_widget_queue_draw(GTK_WIDGET(collection));
1950 }
1951
1952 /* Find an item in an unsorted collection.
1953 * Returns the item number, or -1 if not found.
1954 */
1955 int collection_find_item(Collection *collection, gpointer data,
1956 int (*compar)(const void *, const void *))
1957 {
1958 int i;
1959
1960 g_return_val_if_fail(collection != NULL, -1);
1961 g_return_val_if_fail(IS_COLLECTION(collection), -1);
1962 g_return_val_if_fail(compar != NULL, -1);
1963
1964 for (i = 0; i < collection->number_of_items; i++)
1965 if (compar(&collection->items[i].data, &data) == 0)
1966 return i;
1967
1968 return -1;
1969 }
1970
1971 /* The collection may be in either normal mode or panel mode.
1972 * In panel mode:
1973 * - a single click calls open_item
1974 * - items are never selected
1975 * - lasso boxes are disabled
1976 */
1977 void collection_set_panel(Collection *collection, gboolean panel)
1978 {
1979 g_return_if_fail(collection != NULL);
1980 g_return_if_fail(IS_COLLECTION(collection));
1981
1982 collection->panel = panel == TRUE;
1983
1984 if (collection->panel)
1985 {
1986 collection_clear_selection(collection);
1987 if (collection->lasso_box)
1988 remove_lasso_box(collection);
1989 }
1990 }
1991
1992 /* Return the number of the item under the point (x,y), or -1 for none.
1993 * This may call your test_point callback. The point is relative to the
1994 * collection's origin.
1995 */
1996 int collection_get_item(Collection *collection, int x, int y)
1997 {
1998 int scroll;
1999 int row, col;
2000 int item;
2001
2002 g_return_val_if_fail(collection != NULL, -1);
2003
2004 scroll = collection->vadj->value;
2005 col = x / collection->item_width;
2006 row = (y + scroll) / collection->item_height;
2007
2008 if (col < 0 || row < 0 || col >= collection->columns)
2009 return -1;
2010
2011 item = col + row * collection->columns;
2012 if (item >= collection->number_of_items
2013 ||
2014 !collection->test_point(collection,
2015 x - col * collection->item_width,
2016 y - row * collection->item_height
2017 + scroll,
2018 &collection->items[item],
2019 collection->item_width,
2020 collection->item_height))
2021 {
2022 return -1;
2023 }
2024
2025 return item;
2026 }
2027
2028 /* Set the cursor/highlight over the given item. Passing -1
2029 * hides the cursor. As a special case, you may set the cursor item
2030 * to zero when there are no items.
2031 */
2032 void collection_set_cursor_item(Collection *collection, gint item)
2033 {
2034 int old_item;
2035
2036 g_return_if_fail(collection != NULL);
2037 g_return_if_fail(IS_COLLECTION(collection));
2038 g_return_if_fail(item >= -1 &&
2039 (item < collection->number_of_items || item == 0));
2040
2041 old_item = collection->cursor_item;
2042
2043 if (old_item == item)
2044 return;
2045
2046 collection->cursor_item = item;
2047
2048 if (old_item != -1)
2049 collection_draw_item(collection, old_item, TRUE);
2050
2051 if (item != -1)
2052 {
2053 collection_draw_item(collection, item, TRUE);
2054 scroll_to_show(collection, item);
2055 }
2056 }
2057
2058 /* Briefly highlight an item to draw the user's attention to it.
2059 * -1 cancels the effect, as does deleting items, sorting the collection
2060 * or starting a new wink effect.
2061 * Otherwise, the effect will cancel itself after a short pause.
2062 * */
2063 void collection_wink_item(Collection *collection, gint item)
2064 {
2065 g_return_if_fail(collection != NULL);
2066 g_return_if_fail(IS_COLLECTION(collection));
2067 g_return_if_fail(item >= -1 && item < collection->number_of_items);
2068
2069 if (collection->wink_item != -1)
2070 cancel_wink(collection);
2071 if (item == -1)
2072 return;
2073
2074 collection->wink_item = item;
2075 collection->wink_timeout = gtk_timeout_add(300,
2076 (GtkFunction) cancel_wink_timeout,
2077 collection);
2078 collection_draw_item(collection, item, TRUE);
2079 scroll_to_show(collection, item);
2080
2081 gdk_flush();
2082 }
2083
2084 /* Call test(item, data) on each item in the collection.
2085 * Remove all items for which it returns TRUE. test() should
2086 * free the data before returning TRUE. The collection is in an
2087 * inconsistant state during this call (ie, when test() is called).
2088 */
2089 void collection_delete_if(Collection *collection,
2090 gboolean (*test)(gpointer item, gpointer data),
2091 gpointer data)
2092 {
2093 int in, out = 0;
2094 int selected = 0;
2095 int cursor;
2096
2097 g_return_if_fail(collection != NULL);
2098 g_return_if_fail(IS_COLLECTION(collection));
2099 g_return_if_fail(test != NULL);
2100
2101 cursor = collection->cursor_item;
2102
2103 for (in = 0; in < collection->number_of_items; in++)
2104 {
2105 if (!test(collection->items[in].data, data))
2106 {
2107 if (collection->items[in].selected)
2108 {
2109 collection->items[out].selected = TRUE;
2110 selected++;
2111 }
2112 else
2113 collection->items[out].selected = FALSE;
2114
2115 collection->items[out++].data =
2116 collection->items[in].data;
2117 }
2118 else if (cursor >= in)
2119 cursor--;
2120 }
2121
2122 if (in != out)
2123 {
2124 collection->cursor_item = cursor;
2125
2126 if (collection->wink_item != -1)
2127 {
2128 collection->wink_item = -1;
2129 gtk_timeout_remove(collection->wink_timeout);
2130 }
2131
2132 collection->number_of_items = out;
2133 collection->number_selected = selected;
2134 resize_arrays(collection,
2135 MAX(collection->number_of_items, MINIMUM_ITEMS));
2136
2137 collection->paint_level = PAINT_CLEAR;
2138
2139 if (GTK_WIDGET_REALIZED(GTK_WIDGET(collection)))
2140 {
2141 set_vadjustment(collection);
2142 gtk_widget_queue_draw(GTK_WIDGET(collection));
2143 }
2144 }
2145 }
2146
2147 /* Display a cross-hair pointer and the next time an item is clicked,
2148 * call the callback function. If the background is clicked or NULL
2149 * is passed as the callback then revert to normal operation.
2150 */
2151 void collection_target(Collection *collection,
2152 CollectionTargetFunc callback,
2153 gpointer user_data)
2154 {
2155 g_return_if_fail(collection != NULL);
2156 g_return_if_fail(IS_COLLECTION(collection));
2157
2158 if (callback != collection->target_cb)
2159 gdk_window_set_cursor(GTK_WIDGET(collection)->window,
2160 callback ? crosshair : NULL);
2161
2162 collection->target_cb = callback;
2163 collection->target_data = user_data;
2164
2165 if (collection->cursor_item != -1)
2166 collection_draw_item(collection, collection->cursor_item,
2167 FALSE);
2168 }
2169
2170 /* Move the cursor by the given row and column offsets. */
2171 void collection_move_cursor(Collection *collection, int drow, int dcol)
2172 {
2173 int row, col, item;
2174 int first, last, total_rows;
2175
2176 g_return_if_fail(collection != NULL);
2177 g_return_if_fail(IS_COLLECTION(collection));
2178
2179 get_visible_limits(collection, &first, &last);
2180
2181 item = collection->cursor_item;
2182 if (item == -1)
2183 {
2184 col = 0;
2185 row = first;
2186 }
2187 else
2188 {
2189 row = item / collection->columns;
2190 col = item % collection->columns + dcol;
2191
2192 if (row < first)
2193 row = first;
2194 else if (row > last)
2195 row = last;
2196 else
2197 row = MAX(row + drow, 0);
2198 }
2199
2200 total_rows = (collection->number_of_items + collection->columns - 1)
2201 / collection->columns;
2202
2203 if (row >= total_rows - 1 && drow > 0)
2204 {
2205 row = total_rows - 1;
2206 item = col + row * collection->columns;
2207 if (item >= collection->number_of_items)
2208 {
2209 row--;
2210 scroll_to_show(collection, item);
2211 }
2212 }
2213 if (row < 0)
2214 row = 0;
2215
2216 item = col + row * collection->columns;
2217
2218 if (item >= 0 && item < collection->number_of_items)
2219 collection_set_cursor_item(collection, item);
2220 }
2221