?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r4537: Updated Russian Translation (Nikita E. Shalaev):
[rox-filer/translations.git] / ROX-Filer / src / view_collection.c
blob43ea6fe0965a8fea89581785f533e4674436b395
1 /*
2 * ROX-Filer, filer for the ROX desktop project
3 * Copyright (C) 2006, Thomas Leonard and others (see changelog for details).
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the Free
7 * Software Foundation; either version 2 of the License, or (at your option)
8 * any later version.
9 *
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 * You should have received a copy of the GNU General Public License along with
16 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
17 * Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19
20 /* view_collection.c - a subclass of Collection, used for displaying files */
21
22 #include "config.h"
23
24 #include <gtk/gtk.h>
25 #include <time.h>
26 #include <math.h>
27 #include <string.h>
28
29 #include "global.h"
30
31 #include "collection.h"
32 #include "view_iface.h"
33 #include "view_collection.h"
34 #include "type.h"
35 #include "pixmaps.h"
36 #include "dir.h"
37 #include "diritem.h"
38 #include "gui_support.h"
39 #include "support.h"
40 #include "dnd.h"
41 #include "bind.h"
42 #include "options.h"
43
44 #include "toolbar.h" /* for resizing */
45 #include "filer.h"
46 #include "display.h"
47
48 #define MIN_ITEM_WIDTH 64
49
50 static gpointer parent_class = NULL;
51
52 struct _ViewCollectionClass {
53 GtkViewportClass parent;
54 };
55
56 struct _ViewCollection {
57 GtkViewport viewport;
58
59 Collection *collection;
60 FilerWindow *filer_window; /* Used for styles, etc */
61
62 int cursor_base; /* Cursor when minibuffer opened */
63 };
64
65 typedef struct _Template Template;
66
67 struct _Template {
68 GdkRectangle icon;
69 GdkRectangle leafname;
70 GdkRectangle details;
71 };
72
73 /* GC for drawing colour filenames */
74 static GdkGC *type_gc = NULL;
75
76 /* Static prototypes */
77 static void view_collection_finialize(GObject *object);
78 static void view_collection_class_init(gpointer gclass, gpointer data);
79 static void view_collection_init(GTypeInstance *object, gpointer gclass);
80
81 static void draw_item(GtkWidget *widget,
82 CollectionItem *item,
83 GdkRectangle *area,
84 gpointer user_data);
85 static void fill_template(GdkRectangle *area, CollectionItem *item,
86 ViewCollection *view_collection, Template *template);
87 static void huge_template(GdkRectangle *area, CollectionItem *colitem,
88 ViewCollection *view_collection, Template *template);
89 static void large_template(GdkRectangle *area, CollectionItem *colitem,
90 ViewCollection *view_collection, Template *template);
91 static void small_template(GdkRectangle *area, CollectionItem *colitem,
92 ViewCollection *view_collection, Template *template);
93 static void huge_full_template(GdkRectangle *area, CollectionItem *colitem,
94 ViewCollection *view_collection, Template *template);
95 static void large_full_template(GdkRectangle *area, CollectionItem *colitem,
96 ViewCollection *view_collection, Template *template);
97 static void small_full_template(GdkRectangle *area, CollectionItem *colitem,
98 ViewCollection *view_collection, Template *template);
99 static gboolean test_point(Collection *collection,
100 int point_x, int point_y,
101 CollectionItem *item,
102 int width, int height,
103 gpointer user_data);
104 static void draw_string(GtkWidget *widget,
105 PangoLayout *layout,
106 GdkRectangle *area, /* Area available on screen */
107 int width, /* Width of the full string */
108 GtkStateType selection_state,
109 gboolean box);
110 static void view_collection_iface_init(gpointer giface, gpointer iface_data);
111 static gint coll_motion_notify(GtkWidget *widget,
112 GdkEventMotion *event,
113 ViewCollection *view_collection);
114 static gint coll_button_release(GtkWidget *widget,
115 GdkEventButton *event,
116 ViewCollection *view_collection);
117 static gint coll_button_press(GtkWidget *widget,
118 GdkEventButton *event,
119 ViewCollection *view_collection);
120 static void size_allocate(GtkWidget *w, GtkAllocation *a, gpointer data);
121 static void style_set(Collection *collection,
122 GtkStyle *style,
123 ViewCollection *view_collection);
124 static void display_free_colitem(Collection *collection,
125 CollectionItem *colitem);
126 static void lost_selection(Collection *collection,
127 guint time,
128 gpointer user_data);
129 static void selection_changed(Collection *collection,
130 gint time,
131 gpointer user_data);
132 static void calc_size(FilerWindow *filer_window, CollectionItem *colitem,
133 int *width, int *height);
134 static void make_iter(ViewCollection *view_collection, ViewIter *iter,
135 IterFlags flags);
136 static void make_item_iter(ViewCollection *vc, ViewIter *iter, int i);
137
138 static void view_collection_sort(ViewIface *view);
139 static void view_collection_style_changed(ViewIface *view, int flags);
140 static void view_collection_add_items(ViewIface *view, GPtrArray *items);
141 static void view_collection_update_items(ViewIface *view, GPtrArray *items);
142 static void view_collection_delete_if(ViewIface *view,
143 gboolean (*test)(gpointer item, gpointer data),
144 gpointer data);
145 static void view_collection_clear(ViewIface *view);
146 static void view_collection_select_all(ViewIface *view);
147 static void view_collection_clear_selection(ViewIface *view);
148 static int view_collection_count_items(ViewIface *view);
149 static int view_collection_count_selected(ViewIface *view);
150 static void view_collection_show_cursor(ViewIface *view);
151 static void view_collection_get_iter(ViewIface *view,
152 ViewIter *iter, IterFlags flags);
153 static void view_collection_get_iter_at_point(ViewIface *view, ViewIter *iter,
154 GdkWindow *src, int x, int y);
155 static void view_collection_cursor_to_iter(ViewIface *view, ViewIter *iter);
156 static void view_collection_set_selected(ViewIface *view,
157 ViewIter *iter,
158 gboolean selected);
159 static gboolean view_collection_get_selected(ViewIface *view, ViewIter *iter);
160 static void view_collection_select_only(ViewIface *view, ViewIter *iter);
161 static void view_collection_set_frozen(ViewIface *view, gboolean frozen);
162 static void view_collection_wink_item(ViewIface *view, ViewIter *iter);
163 static void view_collection_autosize(ViewIface *view);
164 static gboolean view_collection_cursor_visible(ViewIface *view);
165 static void view_collection_set_base(ViewIface *view, ViewIter *iter);
166 static void view_collection_start_lasso_box(ViewIface *view,
167 GdkEventButton *event);
168 static void view_collection_extend_tip(ViewIface *view, ViewIter *iter,
169 GString *tip);
170 static gboolean view_collection_auto_scroll_callback(ViewIface *view);
171
172 static DirItem *iter_next(ViewIter *iter);
173 static DirItem *iter_prev(ViewIter *iter);
174 static DirItem *iter_peek(ViewIter *iter);
175
176
177 /****************************************************************
178 * EXTERNAL INTERFACE *
179 ****************************************************************/
180
181 GtkWidget *view_collection_new(FilerWindow *filer_window)
182 {
183 ViewCollection *view_collection;
184
185 view_collection = g_object_new(view_collection_get_type(), NULL);
186 view_collection->filer_window = filer_window;
187
188 /* Starting with GTK+-2.2.2, the vadjustment is reset after init
189 * (even though it's already set during init) to a new adjustment.
190 * Change it back:
191 */
192 gtk_viewport_set_vadjustment(GTK_VIEWPORT(view_collection),
193 view_collection->collection->vadj);
194
195 gtk_range_set_adjustment(GTK_RANGE(filer_window->scrollbar),
196 view_collection->collection->vadj);
197
198 return GTK_WIDGET(view_collection);
199 }
200
201 GType view_collection_get_type(void)
202 {
203 static GType type = 0;
204
205 if (!type)
206 {
207 static const GTypeInfo info =
208 {
209 sizeof (ViewCollectionClass),
210 NULL, /* base_init */
211 NULL, /* base_finalise */
212 view_collection_class_init,
213 NULL, /* class_finalise */
214 NULL, /* class_data */
215 sizeof(ViewCollection),
216 0, /* n_preallocs */
217 view_collection_init
218 };
219 static const GInterfaceInfo iface_info =
220 {
221 view_collection_iface_init, NULL, NULL
222 };
223
224 type = g_type_register_static(gtk_viewport_get_type(),
225 "ViewCollection", &info, 0);
226 g_type_add_interface_static(type, VIEW_TYPE_IFACE, &iface_info);
227 }
228
229 return type;
230 }
231
232 /****************************************************************
233 * INTERNAL FUNCTIONS *
234 ****************************************************************/
235
236 static void view_collection_destroy(GtkObject *view_collection)
237 {
238 VIEW_COLLECTION(view_collection)->filer_window = NULL;
239 }
240
241 static void view_collection_finialize(GObject *object)
242 {
243 /* ViewCollection *view_collection = (ViewCollection *) object; */
244
245 G_OBJECT_CLASS(parent_class)->finalize(object);
246 }
247
248 static void view_collection_grab_focus(GtkWidget *focus_widget)
249 {
250 ViewCollection *view_collection = VIEW_COLLECTION(focus_widget);
251 gtk_widget_grab_focus(GTK_WIDGET(view_collection->collection));
252 }
253
254 static void view_collection_class_init(gpointer gclass, gpointer data)
255 {
256 GObjectClass *object = (GObjectClass *) gclass;
257 GtkWidgetClass *widget = (GtkWidgetClass *) gclass;
258
259 parent_class = g_type_class_peek_parent(gclass);
260
261 widget->grab_focus = view_collection_grab_focus;
262
263 object->finalize = view_collection_finialize;
264 GTK_OBJECT_CLASS(object)->destroy = view_collection_destroy;
265 }
266
267 static void view_collection_init(GTypeInstance *object, gpointer gclass)
268 {
269 ViewCollection *view_collection = (ViewCollection *) object;
270 GtkViewport *viewport = (GtkViewport *) object;
271 GtkWidget *collection;
272 GtkAdjustment *adj;
273
274 collection = collection_new();
275 view_collection->collection = COLLECTION(collection);
276
277 adj = view_collection->collection->vadj;
278 gtk_viewport_set_vadjustment(viewport, adj);
279 gtk_viewport_set_hadjustment(viewport, NULL); /* Or Gtk will crash */
280 gtk_viewport_set_shadow_type(viewport, GTK_SHADOW_NONE);
281 gtk_container_add(GTK_CONTAINER(object), collection);
282 gtk_widget_show(collection);
283 gtk_widget_set_size_request(GTK_WIDGET(view_collection), 4, 4);
284
285 gtk_container_set_resize_mode(GTK_CONTAINER(viewport),
286 GTK_RESIZE_IMMEDIATE);
287
288 view_collection->collection->free_item = display_free_colitem;
289 view_collection->collection->draw_item = draw_item;
290 view_collection->collection->test_point = test_point;
291 view_collection->collection->cb_user_data = view_collection;
292
293 g_signal_connect(collection, "style_set",
294 G_CALLBACK(style_set),
295 view_collection);
296
297 g_signal_connect(collection, "lose_selection",
298 G_CALLBACK(lost_selection), view_collection);
299 g_signal_connect(collection, "selection_changed",
300 G_CALLBACK(selection_changed), view_collection);
301
302 g_signal_connect(collection, "button-release-event",
303 G_CALLBACK(coll_button_release), view_collection);
304 g_signal_connect(collection, "button-press-event",
305 G_CALLBACK(coll_button_press), view_collection);
306 g_signal_connect(collection, "motion-notify-event",
307 G_CALLBACK(coll_motion_notify), view_collection);
308 g_signal_connect(viewport, "size-allocate",
309 G_CALLBACK(size_allocate), view_collection);
310
311 gtk_widget_set_events(collection,
312 GDK_BUTTON1_MOTION_MASK | GDK_BUTTON2_MOTION_MASK |
313 GDK_BUTTON3_MOTION_MASK | GDK_POINTER_MOTION_MASK |
314 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
315 }
316
317
318 static void draw_item(GtkWidget *widget,
319 CollectionItem *colitem,
320 GdkRectangle *area,
321 gpointer user_data)
322 {
323 DirItem *item = (DirItem *) colitem->data;
324 gboolean selected = colitem->selected;
325 Template template;
326 ViewData *view = (ViewData *) colitem->view_data;
327 ViewCollection *view_collection = (ViewCollection *) user_data;
328 FilerWindow *filer_window = view_collection->filer_window;
329 GtkStateType selection_state;
330 GdkColor *color;
331
332 g_return_if_fail(view != NULL);
333
334 if (selected)
335 selection_state = filer_window->selection_state;
336 else
337 selection_state = GTK_STATE_NORMAL;
338
339 color = &widget->style->bg[selection_state];
340
341 fill_template(area, colitem, view_collection, &template);
342
343 /* Set up GC for coloured file types */
344 if (!type_gc)
345 type_gc = gdk_gc_new(widget->window);
346
347 gdk_gc_set_foreground(type_gc, type_get_colour(item,
348 &widget->style->fg[GTK_STATE_NORMAL]));
349
350 if (template.icon.width <= SMALL_WIDTH &&
351 template.icon.height <= SMALL_HEIGHT)
352 {
353 draw_small_icon(widget->window, &template.icon,
354 item, view->image, selected, color);
355 }
356 else if (template.icon.width <= ICON_WIDTH &&
357 template.icon.height <= ICON_HEIGHT)
358 {
359 draw_large_icon(widget->window, &template.icon,
360 item, view->image, selected, color);
361 }
362 else
363 {
364 draw_huge_icon(widget->window, &template.icon,
365 item, view->image, selected, color);
366 }
367
368 draw_string(widget, view->layout,
369 &template.leafname,
370 view->name_width,
371 selection_state,
372 TRUE);
373 if (view->details)
374 draw_string(widget, view->details,
375 &template.details,
376 template.details.width,
377 selection_state,
378 TRUE);
379 }
380
381 /* A template contains the locations of the three rectangles (for the icon,
382 * name and extra details).
383 * Fill in the empty 'template' with the rectanges for this item.
384 */
385 static void fill_template(GdkRectangle *area, CollectionItem *colitem,
386 ViewCollection *view_collection, Template *template)
387 {
388 DisplayStyle style = view_collection->filer_window->display_style;
389 ViewData *view = (ViewData *) colitem->view_data;
390
391 if (view->details)
392 {
393 template->details.width = view->details_width;
394 template->details.height = view->details_height;
395
396 if (style == SMALL_ICONS)
397 small_full_template(area, colitem,
398 view_collection, template);
399 else if (style == LARGE_ICONS)
400 large_full_template(area, colitem,
401 view_collection, template);
402 else
403 huge_full_template(area, colitem,
404 view_collection, template);
405 }
406 else
407 {
408 if (style == HUGE_ICONS)
409 huge_template(area, colitem,
410 view_collection, template);
411 else if (style == LARGE_ICONS)
412 large_template(area, colitem,
413 view_collection, template);
414 else
415 small_template(area, colitem,
416 view_collection, template);
417 }
418 }
419
420 static void huge_template(GdkRectangle *area, CollectionItem *colitem,
421 ViewCollection *view_collection, Template *template)
422 {
423 int col_width = view_collection->collection->item_width;
424 int text_x, text_y;
425 ViewData *view = (ViewData *) colitem->view_data;
426 MaskedPixmap *image = view->image;
427
428 if (image)
429 {
430 if (!image->huge_pixbuf)
431 pixmap_make_huge(image);
432 template->icon.width = image->huge_width;
433 template->icon.height = image->huge_height;
434 }
435 else
436 {
437 template->icon.width = HUGE_WIDTH * 3 / 2;
438 template->icon.height = HUGE_HEIGHT;
439 }
440
441 template->leafname.width = view->name_width;
442 template->leafname.height = view->name_height;
443
444 text_x = area->x + ((col_width - template->leafname.width) >> 1);
445 text_y = area->y + area->height - template->leafname.height;
446
447 template->leafname.x = text_x;
448 template->leafname.y = text_y;
449
450 template->icon.x = area->x + ((col_width - template->icon.width) >> 1);
451 template->icon.y = template->leafname.y - template->icon.height - 2;
452 }
453
454 static void large_template(GdkRectangle *area, CollectionItem *colitem,
455 ViewCollection *view_collection, Template *template)
456 {
457 int col_width = view_collection->collection->item_width;
458 int iwidth, iheight;
459 int image_x;
460 int image_y;
461 ViewData *view = (ViewData *) colitem->view_data;
462 MaskedPixmap *image = view->image;
463
464 int text_x, text_y;
465
466 if (image)
467 {
468 iwidth = MIN(image->width, ICON_WIDTH);
469 iheight = MIN(image->height + 6, ICON_HEIGHT);
470 }
471 else
472 {
473 iwidth = ICON_WIDTH;
474 iheight = ICON_HEIGHT;
475 }
476 image_x = area->x + ((col_width - iwidth) >> 1);
477
478 template->leafname.width = view->name_width;
479 template->leafname.height = view->name_height;
480
481 text_x = area->x + ((col_width - template->leafname.width) >> 1);
482 text_y = area->y + ICON_HEIGHT + 2;
483
484 template->leafname.x = text_x;
485 template->leafname.y = text_y;
486
487 image_y = text_y - iheight;
488 image_y = MAX(area->y, image_y);
489
490 template->icon.x = image_x;
491 template->icon.y = image_y;
492 template->icon.width = iwidth;
493 template->icon.height = MIN(ICON_HEIGHT, iheight);
494 }
495
496 static void small_template(GdkRectangle *area, CollectionItem *colitem,
497 ViewCollection *view_collection, Template *template)
498 {
499 int text_x = area->x + SMALL_WIDTH + 4;
500 int low_text_y;
501 int max_text_width = area->width - SMALL_WIDTH - 4;
502 ViewData *view = (ViewData *) colitem->view_data;
503
504 low_text_y = area->y + area->height / 2 - view->name_height / 2;
505
506 template->leafname.x = text_x;
507 template->leafname.y = low_text_y;
508 template->leafname.width = MIN(max_text_width, view->name_width);
509 template->leafname.height = view->name_height;
510
511 template->icon.x = area->x;
512 template->icon.y = area->y + 1;
513 template->icon.width = SMALL_WIDTH;
514 template->icon.height = SMALL_HEIGHT;
515 }
516
517 static void huge_full_template(GdkRectangle *area, CollectionItem *colitem,
518 ViewCollection *view_collection, Template *template)
519 {
520 int max_text_width = area->width - HUGE_WIDTH - 4;
521 ViewData *view = (ViewData *) colitem->view_data;
522 MaskedPixmap *image = view->image;
523
524 if (image)
525 {
526 if (!image->huge_pixbuf)
527 pixmap_make_huge(image);
528 template->icon.width = image->huge_width;
529 template->icon.height = image->huge_height;
530 }
531 else
532 {
533 template->icon.width = HUGE_WIDTH * 3 / 2;
534 template->icon.height = HUGE_HEIGHT;
535 }
536
537 template->icon.x = area->x + (HUGE_WIDTH - template->icon.width) / 2;
538 template->icon.y = area->y + (area->height - template->icon.height) / 2;
539
540 template->leafname.x = area->x + HUGE_WIDTH + 4;
541 template->leafname.y = area->y + area->height / 2
542 - (view->name_height + 2 + view->details_height) / 2;
543 template->leafname.width = MIN(max_text_width, view->name_width);
544 template->leafname.height = view->name_height;
545
546 if (!image)
547 return; /* Not scanned yet */
548
549 template->details.x = template->leafname.x;
550 template->details.y = template->leafname.y + view->name_height + 2;
551 }
552
553 static void large_full_template(GdkRectangle *area, CollectionItem *colitem,
554 ViewCollection *view_collection, Template *template)
555 {
556 int max_text_width = area->width - ICON_WIDTH - 4;
557 ViewData *view = (ViewData *) colitem->view_data;
558 MaskedPixmap *image = view->image;
559
560 if (image)
561 {
562 template->icon.width = image->width;
563 template->icon.height = image->height;
564 }
565 else
566 {
567 template->icon.width = ICON_WIDTH;
568 template->icon.height = ICON_HEIGHT;
569 }
570
571 template->icon.x = area->x + (ICON_WIDTH - template->icon.width) / 2;
572 template->icon.y = area->y + (area->height - template->icon.height) / 2;
573
574
575 template->leafname.x = area->x + ICON_WIDTH + 4;
576 template->leafname.y = area->y + area->height / 2
577 - (view->name_height + 2 + view->details_height) / 2;
578 template->leafname.width = MIN(max_text_width, view->name_width);
579 template->leafname.height = view->name_height;
580
581 if (!image)
582 return; /* Not scanned yet */
583
584 template->details.x = template->leafname.x;
585 template->details.y = template->leafname.y + view->name_height + 2;
586 }
587
588 static void small_full_template(GdkRectangle *area, CollectionItem *colitem,
589 ViewCollection *view_collection, Template *template)
590 {
591 int col_width = view_collection->collection->item_width;
592 ViewData *view = (ViewData *) colitem->view_data;
593
594 small_template(area, colitem, view_collection, template);
595
596 if (!view->image)
597 return; /* Not scanned yet */
598
599 template->details.x = area->x + col_width - template->details.width;
600 template->details.y = area->y + area->height / 2 - \
601 view->details_height / 2;
602 }
603
604 #define INSIDE(px, py, area) \
605 (px >= area.x && py >= area.y && \
606 px <= area.x + area.width && py <= area.y + area.height)
607
608 static gboolean test_point(Collection *collection,
609 int point_x, int point_y,
610 CollectionItem *colitem,
611 int width, int height,
612 gpointer user_data)
613 {
614 Template template;
615 GdkRectangle area;
616 ViewData *view = (ViewData *) colitem->view_data;
617 ViewCollection *view_collection = (ViewCollection *) user_data;
618
619 area.x = 0;
620 area.y = 0;
621 area.width = width;
622 area.height = height;
623
624 fill_template(&area, colitem, view_collection, &template);
625
626 return INSIDE(point_x, point_y, template.leafname) ||
627 INSIDE(point_x, point_y, template.icon) ||
628 (view->details && INSIDE(point_x, point_y, template.details));
629 }
630
631 /* 'box' renders a background box if the string is also selected */
632 static void draw_string(GtkWidget *widget,
633 PangoLayout *layout,
634 GdkRectangle *area, /* Area available on screen */
635 int width, /* Width of the full string */
636 GtkStateType selection_state,
637 gboolean box)
638 {
639 GdkGC *gc = selection_state == GTK_STATE_NORMAL
640 ? type_gc
641 : widget->style->fg_gc[selection_state];
642
643 if (selection_state != GTK_STATE_NORMAL && box)
644 gtk_paint_flat_box(widget->style, widget->window,
645 selection_state, GTK_SHADOW_NONE,
646 NULL, widget, "text",
647 area->x, area->y,
648 MIN(width, area->width),
649 area->height);
650
651 if (width > area->width)
652 {
653 gdk_gc_set_clip_origin(gc, 0, 0);
654 gdk_gc_set_clip_rectangle(gc, area);
655 }
656
657 gdk_draw_layout(widget->window, gc, area->x, area->y, layout);
658
659 if (width > area->width)
660 {
661 static GdkGC *red_gc = NULL;
662
663 if (!red_gc)
664 {
665 gboolean success;
666 GdkColor red = {0, 0xffff, 0, 0};
667
668 red_gc = gdk_gc_new(widget->window);
669 gdk_colormap_alloc_colors(
670 gtk_widget_get_colormap(widget),
671 &red, 1, FALSE, TRUE, &success);
672 gdk_gc_set_foreground(red_gc, &red);
673 }
674 gdk_draw_rectangle(widget->window, red_gc, TRUE,
675 area->x + area->width - 1, area->y,
676 1, area->height);
677 gdk_gc_set_clip_rectangle(gc, NULL);
678 }
679 }
680
681 /* Create the handers for the View interface */
682 static void view_collection_iface_init(gpointer giface, gpointer iface_data)
683 {
684 ViewIfaceClass *iface = giface;
685
686 g_assert(G_TYPE_FROM_INTERFACE(iface) == VIEW_TYPE_IFACE);
687
688 /* override stuff */
689 iface->sort = view_collection_sort;
690 iface->style_changed = view_collection_style_changed;
691 iface->add_items = view_collection_add_items;
692 iface->update_items = view_collection_update_items;
693 iface->delete_if = view_collection_delete_if;
694 iface->clear = view_collection_clear;
695 iface->select_all = view_collection_select_all;
696 iface->clear_selection = view_collection_clear_selection;
697 iface->count_items = view_collection_count_items;
698 iface->count_selected = view_collection_count_selected;
699 iface->show_cursor = view_collection_show_cursor;
700 iface->get_iter = view_collection_get_iter;
701 iface->get_iter_at_point = view_collection_get_iter_at_point;
702 iface->cursor_to_iter = view_collection_cursor_to_iter;
703 iface->set_selected = view_collection_set_selected;
704 iface->get_selected = view_collection_get_selected;
705 iface->set_frozen = view_collection_set_frozen;
706 iface->select_only = view_collection_select_only;
707 iface->wink_item = view_collection_wink_item;
708 iface->autosize = view_collection_autosize;
709 iface->cursor_visible = view_collection_cursor_visible;
710 iface->set_base = view_collection_set_base;
711 iface->start_lasso_box = view_collection_start_lasso_box;
712 iface->extend_tip = view_collection_extend_tip;
713 iface->auto_scroll_callback = view_collection_auto_scroll_callback;
714 }
715
716 static void view_collection_extend_tip(ViewIface *view, ViewIter *iter,
717 GString *tip)
718 {
719 ViewCollection*view_collection = (ViewCollection *) view;
720 Collection *collection = view_collection->collection;
721 FilerWindow *filer_window = view_collection->filer_window;
722 Template template;
723 int i = iter->i;
724 CollectionItem *colitem = &collection->items[i];
725 ViewData *view_data = (ViewData *) colitem->view_data;
726 GdkRectangle area;
727 int row,col;
728
729 collection_item_to_rowcol(collection, i, &row, &col);
730
731 g_return_if_fail(iter->view == (ViewIface *) view_collection);
732 g_return_if_fail(i >= 0 && i < collection->number_of_items);
733
734 /* TODO: What if the window is narrower than 1 column? */
735 if (filer_window->display_style == LARGE_ICONS ||
736 filer_window->display_style == HUGE_ICONS)
737 return; /* These wrap rather than truncate */
738
739 area.x = col * collection->item_width;
740 area.y = row * collection->item_height;
741 area.height = collection->item_height;
742
743 if (col == collection->columns - 1)
744 area.width = GTK_WIDGET(collection)->allocation.width - area.x;
745 else
746 area.width = collection->item_width;
747
748 fill_template(&area, colitem, view_collection, &template);
749
750 if (template.leafname.width < view_data->name_width)
751 {
752 DirItem *item = (DirItem *) collection->items[i].data;
753
754 g_string_append(tip, item->leafname);
755 g_string_append_c(tip, '\n');
756 }
757 }
758
759 static gint coll_motion_notify(GtkWidget *widget,
760 GdkEventMotion *event,
761 ViewCollection *view_collection)
762 {
763 return filer_motion_notify(view_collection->filer_window, event);
764 }
765
766 /* Viewport is to be resized, so calculate increments */
767 static void size_allocate(GtkWidget *w, GtkAllocation *a, gpointer data)
768 {
769 Collection *col = ((ViewCollection *) data)->collection;
770
771 col->vadj->step_increment = col->item_height;
772 col->vadj->page_increment = col->vadj->page_size;
773 }
774
775 static gint coll_button_release(GtkWidget *widget,
776 GdkEventButton *event,
777 ViewCollection *view_collection)
778 {
779 if (dnd_motion_release(event))
780 {
781 if (motion_buttons_pressed == 0 &&
782 view_collection->collection->lasso_box)
783 {
784 filer_set_autoscroll(view_collection->filer_window,
785 FALSE);
786 collection_end_lasso(view_collection->collection,
787 event->button == 1 ? GDK_SET : GDK_INVERT);
788 }
789 return FALSE;
790 }
791
792 filer_perform_action(view_collection->filer_window, event);
793
794 return FALSE;
795 }
796
797 static gint coll_button_press(GtkWidget *widget,
798 GdkEventButton *event,
799 ViewCollection *view_collection)
800 {
801 collection_set_cursor_item(view_collection->collection, -1, TRUE);
802
803 if (dnd_motion_press(widget, event))
804 filer_perform_action(view_collection->filer_window, event);
805
806 return FALSE;
807 }
808
809 /* Nothing is selected anymore - give up primary */
810 static void lost_selection(Collection *collection,
811 guint time,
812 gpointer user_data)
813 {
814 ViewCollection *view_collection = VIEW_COLLECTION(user_data);
815
816 filer_lost_selection(view_collection->filer_window, time);
817 }
818
819 static void selection_changed(Collection *collection,
820 gint time,
821 gpointer user_data)
822 {
823 ViewCollection *view_collection = VIEW_COLLECTION(user_data);
824
825 filer_selection_changed(view_collection->filer_window, time);
826 }
827
828 static void display_free_colitem(Collection *collection,
829 CollectionItem *colitem)
830 {
831 ViewData *view = (ViewData *) colitem->view_data;
832
833 if (!view)
834 return;
835
836 if (view->layout)
837 {
838 g_object_unref(G_OBJECT(view->layout));
839 view->layout = NULL;
840 }
841 if (view->details)
842 g_object_unref(G_OBJECT(view->details));
843
844 if (view->image)
845 g_object_unref(view->image);
846
847 g_free(view);
848 }
849
850 static void add_item(ViewCollection *view_collection, DirItem *item)
851 {
852 Collection *collection = view_collection->collection;
853 FilerWindow *filer_window = view_collection->filer_window;
854 int old_w = collection->item_width;
855 int old_h = collection->item_height;
856 int w, h, i;
857
858 i = collection_insert(collection, item,
859 display_create_viewdata(filer_window, item));
860
861 calc_size(filer_window, &collection->items[i], &w, &h);
862
863 if (w > old_w || h > old_h)
864 collection_set_item_size(collection,
865 MAX(old_w, w),
866 MAX(old_h, h));
867 }
868
869 static void style_set(Collection *collection,
870 GtkStyle *style,
871 ViewCollection *view_collection)
872 {
873 view_collection_style_changed(VIEW(view_collection),
874 VIEW_UPDATE_VIEWDATA | VIEW_UPDATE_NAME);
875 }
876
877 /* Return the size needed for this item */
878 static void calc_size(FilerWindow *filer_window, CollectionItem *colitem,
879 int *width, int *height)
880 {
881 int pix_width, pix_height;
882 int w;
883 DisplayStyle style = filer_window->display_style;
884 ViewData *view = (ViewData *) colitem->view_data;
885
886 if (filer_window->details_type == DETAILS_NONE)
887 {
888 if (style == HUGE_ICONS)
889 {
890 if (view->image)
891 {
892 if (!view->image->huge_pixbuf)
893 pixmap_make_huge(view->image);
894 pix_width = view->image->huge_width;
895 pix_height = view->image->huge_height;
896 }
897 else
898 {
899 pix_width = HUGE_WIDTH * 3 / 2;
900 pix_height = HUGE_HEIGHT * 3 / 2;
901 }
902 *width = MAX(pix_width, view->name_width) + 4;
903 *height = MAX(view->name_height + pix_height + 4,
904 HUGE_HEIGHT * 3 / 4);
905 }
906 else if (style == SMALL_ICONS)
907 {
908 w = MIN(view->name_width, o_small_width.int_value);
909 *width = SMALL_WIDTH + 12 + w;
910 *height = MAX(view->name_height, SMALL_HEIGHT) + 4;
911 }
912 else
913 {
914 if (view->image)
915 pix_width = view->image->width;
916 else
917 pix_width = ICON_WIDTH;
918 *width = MAX(pix_width, view->name_width) + 4;
919 *height = view->name_height + ICON_HEIGHT + 2;
920 }
921 }
922 else
923 {
924 w = view->details_width;
925 if (style == HUGE_ICONS)
926 {
927 *width = HUGE_WIDTH + 12 + MAX(w, view->name_width);
928 *height = HUGE_HEIGHT - 4;
929 }
930 else if (style == SMALL_ICONS)
931 {
932 int text_height;
933
934 *width = SMALL_WIDTH + view->name_width + 12 + w;
935 text_height = MAX(view->name_height,
936 view->details_height);
937 *height = MAX(text_height, SMALL_HEIGHT) + 4;
938 }
939 else
940 {
941 *width = ICON_WIDTH + 12 + MAX(w, view->name_width);
942 *height = ICON_HEIGHT;
943 }
944 }
945 }
946
947 static void update_item(ViewCollection *view_collection, int i)
948 {
949 Collection *collection = view_collection->collection;
950 int old_w = collection->item_width;
951 int old_h = collection->item_height;
952 int w, h;
953 CollectionItem *colitem;
954 FilerWindow *filer_window = view_collection->filer_window;
955
956 g_return_if_fail(i >= 0 && i < collection->number_of_items);
957
958 colitem = &collection->items[i];
959
960 display_update_view(filer_window,
961 (DirItem *) colitem->data,
962 (ViewData *) colitem->view_data,
963 FALSE);
964
965 calc_size(filer_window, colitem, &w, &h);
966 if (w > old_w || h > old_h)
967 collection_set_item_size(collection,
968 MAX(old_w, w),
969 MAX(old_h, h));
970
971 collection_draw_item(collection, i, TRUE);
972 }
973
974 /* Implementations of the View interface. See view_iface.c for comments. */
975
976 static void view_collection_style_changed(ViewIface *view, int flags)
977 {
978 ViewCollection *view_collection = VIEW_COLLECTION(view);
979 FilerWindow *filer_window = view_collection->filer_window;
980 int i;
981 Collection *col = view_collection->collection;
982 int width = MIN_ITEM_WIDTH;
983 int height = SMALL_HEIGHT;
984 int n = col->number_of_items;
985
986 if (n == 0 && filer_window->display_style != SMALL_ICONS)
987 height = ICON_HEIGHT;
988
989 view_collection->collection->vertical_order = FALSE;
990 if (filer_window->display_style == SMALL_ICONS &&
991 o_vertical_order_small.int_value)
992 view_collection->collection->vertical_order = TRUE;
993 if (filer_window->display_style != SMALL_ICONS &&
994 o_vertical_order_large.int_value)
995 view_collection->collection->vertical_order = TRUE;
996
997
998
999
1000 /* Recalculate all the ViewData structs for this window
1001 * (needed if the text or image has changed in any way) and
1002 * get the size of each item.
1003 */
1004 for (i = 0; i < n; i++)
1005 {
1006 CollectionItem *ci = &col->items[i];
1007 int w, h;
1008
1009 if (flags & (VIEW_UPDATE_VIEWDATA | VIEW_UPDATE_NAME))
1010 display_update_view(filer_window,
1011 (DirItem *) ci->data,
1012 (ViewData *) ci->view_data,
1013 (flags & VIEW_UPDATE_NAME) != 0);
1014
1015 calc_size(filer_window, ci, &w, &h);
1016 if (w > width)
1017 width = w;
1018 if (h > height)
1019 height = h;
1020 }
1021
1022 collection_set_item_size(col, width, height);
1023
1024 gtk_widget_queue_draw(GTK_WIDGET(view_collection));
1025 }
1026
1027 typedef int (*SortFn)(gconstpointer a, gconstpointer b);
1028
1029 static SortFn sort_fn(FilerWindow *fw)
1030 {
1031 switch (fw->sort_type)
1032 {
1033 case SORT_NAME: return sort_by_name;
1034 case SORT_TYPE: return sort_by_type;
1035 case SORT_DATE: return sort_by_date;
1036 case SORT_SIZE: return sort_by_size;
1037 case SORT_OWNER: return sort_by_owner;
1038 case SORT_GROUP: return sort_by_group;
1039 default:
1040 g_assert_not_reached();
1041 }
1042
1043 return NULL;
1044 }
1045
1046 static void view_collection_sort(ViewIface *view)
1047 {
1048 ViewCollection *view_collection = VIEW_COLLECTION(view);
1049 FilerWindow *filer_window = view_collection->filer_window;
1050
1051 collection_qsort(view_collection->collection, sort_fn(filer_window),
1052 filer_window->sort_order);
1053 }
1054
1055 static void view_collection_add_items(ViewIface *view, GPtrArray *items)
1056 {
1057 ViewCollection *view_collection = VIEW_COLLECTION(view);
1058 Collection *collection = view_collection->collection;
1059 FilerWindow *filer_window = view_collection->filer_window;
1060 int old_num, i;
1061
1062 old_num = collection->number_of_items;
1063 for (i = 0; i < items->len; i++)
1064 {
1065 DirItem *item = (DirItem *) items->pdata[i];
1066 char *leafname = item->leafname;
1067
1068 if (!filer_match_filter(filer_window, leafname))
1069 continue;
1070
1071 add_item(view_collection, item);
1072 }
1073
1074 if (old_num != collection->number_of_items)
1075 view_collection_sort(view);
1076 }
1077
1078 static void view_collection_update_items(ViewIface *view, GPtrArray *items)
1079 {
1080 ViewCollection *view_collection = VIEW_COLLECTION(view);
1081 Collection *collection = view_collection->collection;
1082 FilerWindow *filer_window = view_collection->filer_window;
1083 int i;
1084
1085 g_return_if_fail(items->len > 0);
1086
1087 /* The item data has already been modified, so this gives the
1088 * final sort order...
1089 */
1090 collection_qsort(collection, sort_fn(filer_window),
1091 filer_window->sort_order);
1092
1093 for (i = 0; i < items->len; i++)
1094 {
1095 DirItem *item = (DirItem *) items->pdata[i];
1096 const gchar *leafname = item->leafname;
1097 int j;
1098
1099 if (!filer_match_filter(filer_window, leafname))
1100 continue;
1101
1102 j = collection_find_item(collection, item,
1103 sort_fn(filer_window),
1104 filer_window->sort_order);
1105
1106 if (j < 0)
1107 g_warning("Failed to find '%s'\n", leafname);
1108 else
1109 update_item(view_collection, j);
1110 }
1111 }
1112
1113 static void view_collection_delete_if(ViewIface *view,
1114 gboolean (*test)(gpointer item, gpointer data),
1115 gpointer data)
1116 {
1117 ViewCollection *view_collection = VIEW_COLLECTION(view);
1118 Collection *collection = view_collection->collection;
1119
1120 collection_delete_if(collection, test, data);
1121 }
1122
1123 static void view_collection_clear(ViewIface *view)
1124 {
1125 ViewCollection *view_collection = VIEW_COLLECTION(view);
1126 Collection *collection = view_collection->collection;
1127
1128 collection_clear(collection);
1129 }
1130
1131 static void view_collection_select_all(ViewIface *view)
1132 {
1133 ViewCollection *view_collection = VIEW_COLLECTION(view);
1134 Collection *collection = view_collection->collection;
1135
1136 collection_select_all(collection);
1137 }
1138
1139 static void view_collection_clear_selection(ViewIface *view)
1140 {
1141 ViewCollection *view_collection = VIEW_COLLECTION(view);
1142 Collection *collection = view_collection->collection;
1143
1144 collection_clear_selection(collection);
1145 }
1146
1147 static int view_collection_count_items(ViewIface *view)
1148 {
1149 ViewCollection *view_collection = VIEW_COLLECTION(view);
1150 Collection *collection = view_collection->collection;
1151
1152 return collection->number_of_items;
1153 }
1154
1155 static int view_collection_count_selected(ViewIface *view)
1156 {
1157 ViewCollection *view_collection = VIEW_COLLECTION(view);
1158 Collection *collection = view_collection->collection;
1159
1160 return collection->number_selected;
1161 }
1162
1163 static void view_collection_show_cursor(ViewIface *view)
1164 {
1165 ViewCollection *view_collection = VIEW_COLLECTION(view);
1166 Collection *collection = view_collection->collection;
1167
1168 collection_move_cursor(collection, 0, 0);
1169 }
1170
1171 /* The first time the next() method is used, this is called */
1172 static DirItem *iter_init(ViewIter *iter)
1173 {
1174 ViewCollection *view_collection = (ViewCollection *) iter->view;
1175 Collection *collection = view_collection->collection;
1176 int i = -1;
1177 int n = collection->number_of_items;
1178 int flags = iter->flags;
1179
1180 iter->peek = iter_peek;
1181
1182 if (iter->n_remaining == 0)
1183 return NULL;
1184
1185 if (flags & VIEW_ITER_FROM_CURSOR)
1186 {
1187 i = collection->cursor_item;
1188 if (i == -1)
1189 return NULL; /* No cursor */
1190 }
1191 else if (flags & VIEW_ITER_FROM_BASE)
1192 i = view_collection->cursor_base;
1193
1194 if (i < 0 || i >= n)
1195 {
1196 /* Either a normal iteration, or an iteration from an
1197 * invalid starting point.
1198 */
1199 if (flags & VIEW_ITER_BACKWARDS)
1200 i = n - 1;
1201 else
1202 i = 0;
1203 }
1204
1205 if (i < 0 || i >= n)
1206 return NULL; /* No items at all! */
1207
1208 iter->next = flags & VIEW_ITER_BACKWARDS ? iter_prev : iter_next;
1209 iter->n_remaining--;
1210 iter->i = i;
1211
1212 if (flags & VIEW_ITER_SELECTED && !collection->items[i].selected)
1213 return iter->next(iter);
1214 return iter->peek(iter);
1215 }
1216 /* Advance iter to point to the next item and return the new item
1217 * (this saves you calling peek after next each time).
1218 */
1219 static DirItem *iter_next(ViewIter *iter)
1220 {
1221 Collection *collection = ((ViewCollection *) iter->view)->collection;
1222 int n = collection->number_of_items;
1223 int i = iter->i;
1224
1225 g_return_val_if_fail(iter->n_remaining >= 0, NULL);
1226
1227 /* i is the last item returned (always valid) */
1228
1229 g_return_val_if_fail(i >= 0 && i < n, NULL);
1230
1231 while (iter->n_remaining)
1232 {
1233 i++;
1234 iter->n_remaining--;
1235
1236 if (i == n)
1237 i = 0;
1238
1239 g_return_val_if_fail(i >= 0 && i < n, NULL);
1240
1241 if (iter->flags & VIEW_ITER_SELECTED &&
1242 !collection->items[i].selected)
1243 continue;
1244
1245 iter->i = i;
1246 return collection->items[i].data;
1247 }
1248
1249 iter->i = -1;
1250 return NULL;
1251 }
1252
1253 /* Like iter_next, but in the other direction */
1254 static DirItem *iter_prev(ViewIter *iter)
1255 {
1256 Collection *collection = ((ViewCollection *) iter->view)->collection;
1257 int n = collection->number_of_items;
1258 int i = iter->i;
1259
1260 g_return_val_if_fail(iter->n_remaining >= 0, NULL);
1261
1262 /* i is the last item returned (always valid) */
1263
1264 g_return_val_if_fail(i >= 0 && i < n, NULL);
1265
1266 while (iter->n_remaining)
1267 {
1268 i--;
1269 iter->n_remaining--;
1270
1271 if (i == -1)
1272 i = collection->number_of_items - 1;
1273
1274 g_return_val_if_fail(i >= 0 && i < n, NULL);
1275
1276 if (iter->flags & VIEW_ITER_SELECTED &&
1277 !collection->items[i].selected)
1278 continue;
1279
1280 iter->i = i;
1281 return collection->items[i].data;
1282 }
1283
1284 iter->i = -1;
1285 return NULL;
1286 }
1287
1288 static DirItem *iter_peek(ViewIter *iter)
1289 {
1290 Collection *collection = ((ViewCollection *) iter->view)->collection;
1291 int i = iter->i;
1292
1293 if (i == -1)
1294 return NULL;
1295
1296 g_return_val_if_fail(i >= 0 && i < collection->number_of_items, NULL);
1297
1298 return collection->items[i].data;
1299 }
1300
1301 static void make_iter(ViewCollection *view_collection, ViewIter *iter,
1302 IterFlags flags)
1303 {
1304 Collection *collection = view_collection->collection;
1305
1306 iter->view = (ViewIface *) view_collection;
1307 iter->next = iter_init;
1308 iter->peek = NULL;
1309 iter->i = -1;
1310
1311 iter->flags = flags;
1312
1313 if (flags & VIEW_ITER_ONE_ONLY)
1314 {
1315 iter->n_remaining = 1;
1316 iter->next(iter);
1317 }
1318 else
1319 iter->n_remaining = collection->number_of_items;
1320 }
1321
1322 /* Set the iterator to return 'i' on the next peek() */
1323 static void make_item_iter(ViewCollection *view_collection,
1324 ViewIter *iter, int i)
1325 {
1326 Collection *collection = view_collection->collection;
1327
1328 g_return_if_fail(i >= -1 && i < collection->number_of_items);
1329
1330 make_iter(view_collection, iter, 0);
1331
1332 iter->i = i;
1333 iter->next = iter_next;
1334 iter->peek = iter_peek;
1335 iter->n_remaining = 0;
1336 }
1337
1338 static void view_collection_get_iter(ViewIface *view,
1339 ViewIter *iter, IterFlags flags)
1340 {
1341 ViewCollection *view_collection = VIEW_COLLECTION(view);
1342
1343 make_iter(view_collection, iter, flags);
1344 }
1345
1346 static void view_collection_get_iter_at_point(ViewIface *view, ViewIter *iter,
1347 GdkWindow *src, int x, int y)
1348 {
1349 ViewCollection *view_collection = VIEW_COLLECTION(view);
1350 Collection *collection = view_collection->collection;
1351 int i;
1352
1353 if (src == ((GtkWidget *) view)->window)
1354 {
1355 /* The event is on the Viewport, not the collection... */
1356 y += collection->vadj->value;
1357 }
1358
1359 i = collection_get_item(collection, x, y);
1360 make_item_iter(view_collection, iter, i);
1361 }
1362
1363 static void view_collection_cursor_to_iter(ViewIface *view, ViewIter *iter)
1364 {
1365 ViewCollection *view_collection = VIEW_COLLECTION(view);
1366 Collection *collection = view_collection->collection;
1367 FilerWindow *filer_window = view_collection->filer_window;
1368
1369 g_return_if_fail(iter == NULL ||
1370 iter->view == (ViewIface *) view_collection);
1371
1372 collection_set_cursor_item(collection, iter ? iter->i : -1,
1373 filer_window->auto_scroll == -1);
1374 }
1375
1376 static void view_collection_set_selected(ViewIface *view,
1377 ViewIter *iter,
1378 gboolean selected)
1379 {
1380 ViewCollection *view_collection = VIEW_COLLECTION(view);
1381 Collection *collection = view_collection->collection;
1382
1383 g_return_if_fail(iter != NULL &&
1384 iter->view == (ViewIface *) view_collection);
1385 g_return_if_fail(iter->i >= 0 && iter->i < collection->number_of_items);
1386
1387 if (selected)
1388 collection_select_item(collection, iter->i);
1389 else
1390 collection_unselect_item(collection, iter->i);
1391 }
1392
1393 static gboolean view_collection_get_selected(ViewIface *view, ViewIter *iter)
1394 {
1395 ViewCollection *view_collection = VIEW_COLLECTION(view);
1396 Collection *collection = view_collection->collection;
1397
1398 g_return_val_if_fail(iter != NULL &&
1399 iter->view == (ViewIface *) view_collection, FALSE);
1400 g_return_val_if_fail(iter->i >= 0 &&
1401 iter->i < collection->number_of_items, FALSE);
1402
1403 return collection->items[iter->i].selected;
1404 }
1405
1406 static void view_collection_select_only(ViewIface *view, ViewIter *iter)
1407 {
1408 ViewCollection *view_collection = VIEW_COLLECTION(view);
1409 Collection *collection = view_collection->collection;
1410
1411 g_return_if_fail(iter != NULL &&
1412 iter->view == (ViewIface *) view_collection);
1413 g_return_if_fail(iter->i >= 0 && iter->i < collection->number_of_items);
1414
1415 collection_clear_except(collection, iter->i);
1416 }
1417
1418 static void view_collection_set_frozen(ViewIface *view, gboolean frozen)
1419 {
1420 ViewCollection *view_collection = VIEW_COLLECTION(view);
1421 Collection *collection = view_collection->collection;
1422
1423 if (frozen)
1424 collection->block_selection_changed++;
1425 else
1426 collection_unblock_selection_changed(collection,
1427 gtk_get_current_event_time(), TRUE);
1428 }
1429
1430 static void view_collection_wink_item(ViewIface *view, ViewIter *iter)
1431 {
1432 ViewCollection *view_collection = VIEW_COLLECTION(view);
1433 Collection *collection = view_collection->collection;
1434
1435 if (!iter)
1436 {
1437 collection_wink_item(collection, -1);
1438 return;
1439 }
1440
1441 g_return_if_fail(iter != NULL &&
1442 iter->view == (ViewIface *) view_collection);
1443 g_return_if_fail(iter->i >= 0 && iter->i < collection->number_of_items);
1444
1445 collection_wink_item(collection, iter->i);
1446 }
1447
1448 static void view_collection_autosize(ViewIface *view)
1449 {
1450 ViewCollection *view_collection = VIEW_COLLECTION(view);
1451 FilerWindow *filer_window = view_collection->filer_window;
1452 Collection *collection = view_collection->collection;
1453 int n;
1454 int w = collection->item_width;
1455 int h = collection->item_height;
1456 int x;
1457 int rows, cols;
1458 int max_x, max_rows;
1459 const float r = 2.5;
1460 int t = 0;
1461 int space = 0;
1462
1463 /* Get the extra height required for the toolbar and minibuffer,
1464 * if visible.
1465 */
1466 if (o_toolbar.int_value != TOOLBAR_NONE)
1467 t = filer_window->toolbar->allocation.height;
1468 if (filer_window->message)
1469 t += filer_window->message->allocation.height;
1470 if (GTK_WIDGET_VISIBLE(filer_window->minibuffer_area))
1471 {
1472 GtkRequisition req;
1473
1474 gtk_widget_size_request(filer_window->minibuffer_area, &req);
1475 space = req.height + 2;
1476 t += space;
1477 }
1478
1479 n = collection->number_of_items;
1480 if (n == 0)
1481 h = ICON_HEIGHT * 1.5;
1482 n = MAX(n, 2);
1483
1484 max_x = (o_filer_size_limit.int_value * monitor_width) / 100;
1485 max_rows = (o_filer_size_limit.int_value * monitor_height) / (h * 100);
1486
1487 /* Aim for a size where
1488 * x = r(y + t + h), (1)
1489 * unless that's too wide.
1490 *
1491 * t = toolbar (and minibuffer) height
1492 * r = desired (width / height) ratio
1493 *
1494 * Want to display all items:
1495 * (x/w)(y/h) = n
1496 * => xy = nwh
1497 * => x(x/r - t - h) = nwh (from 1)
1498 * => xx - x.rt - hr(1 - nw) = 0
1499 * => 2x = rt +/- sqrt(rt.rt + 4hr(nw - 1))
1500 * Now,
1501 * 4hr(nw - 1) > 0
1502 * so
1503 * sqrt(rt.rt + ...) > rt
1504 *
1505 * So, the +/- must be +:
1506 *
1507 * => x = (rt + sqrt(rt.rt + 4hr(nw - 1))) / 2
1508 *
1509 * ( + w - 1 to round up)
1510 */
1511 x = (r * t + sqrt(r*r*t*t + 4*h*r * (n*w - 1))) / 2 + w - 1;
1512
1513 /* Limit x */
1514 if (x > max_x)
1515 x = max_x;
1516
1517 cols = x / w;
1518 cols = MAX(cols, 1);
1519
1520 /* Choose rows to display all items given our chosen x.
1521 * Don't make the window *too* big!
1522 */
1523 rows = (n + cols - 1) / cols;
1524 if (rows > max_rows)
1525 rows = max_rows;
1526
1527 /* Leave some room for extra icons, but only in Small Icons mode
1528 * otherwise it takes up too much space.
1529 * Also, don't add space if the minibuffer is open.
1530 */
1531 if (space == 0)
1532 space = filer_window->display_style == SMALL_ICONS ? h : 2;
1533
1534 filer_window_set_size(filer_window,
1535 w * MAX(cols, 1),
1536 h * MAX(rows, 1) + space);
1537 }
1538
1539 static gboolean view_collection_cursor_visible(ViewIface *view)
1540 {
1541 ViewCollection *view_collection = VIEW_COLLECTION(view);
1542 Collection *collection = view_collection->collection;
1543
1544 return collection->cursor_item != -1;
1545 }
1546
1547 static void view_collection_set_base(ViewIface *view, ViewIter *iter)
1548 {
1549 ViewCollection *view_collection = VIEW_COLLECTION(view);
1550
1551 view_collection->cursor_base = iter->i;
1552 }
1553
1554 static void view_collection_start_lasso_box(ViewIface *view,
1555 GdkEventButton *event)
1556 {
1557 ViewCollection *view_collection = (ViewCollection *) view;
1558 Collection *collection = view_collection->collection;
1559
1560 filer_set_autoscroll(view_collection->filer_window, TRUE);
1561 collection_lasso_box(collection, event->x, event->y);
1562 }
1563
1564
1565 /* Change the adjustment by this amount. Bounded. */
1566 static void diff_vpos(Collection *collection, int diff)
1567 {
1568 int old = collection->vadj->value;
1569 int value = old + diff;
1570
1571 value = CLAMP(value, 0,
1572 collection->vadj->upper - collection->vadj->page_size);
1573 gtk_adjustment_set_value(collection->vadj, value);
1574
1575 if (collection->vadj->value != old)
1576 dnd_spring_abort();
1577 }
1578
1579 static gboolean view_collection_auto_scroll_callback(ViewIface *view)
1580 {
1581 ViewCollection *view_collection = (ViewCollection *) view;
1582 Collection *collection = view_collection->collection;
1583 GdkWindow *window = ((GtkWidget *) collection)->window;
1584 gint x, y, w, h;
1585 GdkModifierType mask;
1586 int diff = 0;
1587
1588 gdk_window_get_pointer(window, &x, &y, &mask);
1589 gdk_drawable_get_size(window, &w, NULL);
1590
1591 h = collection->vadj->page_size;
1592 y -= collection->vadj->value;
1593
1594 if ((x < 0 || x > w || y < 0 || y > h) && !collection->lasso_box)
1595 return FALSE; /* Out of window - stop */
1596
1597 if (y < AUTOSCROLL_STEP)
1598 diff = y - AUTOSCROLL_STEP;
1599 else if (y > h - AUTOSCROLL_STEP)
1600 diff = AUTOSCROLL_STEP + y - h;
1601
1602 if (diff)
1603 diff_vpos(collection, diff);
1604
1605 return TRUE;
1606 }
For translators