?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r2417: Merged icons and backdrop dropboxes into a single Ultimate DropBox widget,
[rox-filer.git] / ROX-Filer / src / view_details.c
blob2d548d4f4d1e5bcab10d21fe95cc3b0da0f741dd
1 /*
2 * $Id$
3 *
4 * ROX-Filer, filer for the ROX desktop project
5 * Copyright (C) 2003, the ROX-Filer team.
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the Free
9 * Software Foundation; either version 2 of the License, or (at your option)
10 * any later version.
11 *
12 * This program is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * more details.
16 *
17 * You should have received a copy of the GNU General Public License along with
18 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
19 * Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 /* view_details.c - display a list of files in a TreeView */
23
24 #include "config.h"
25
26 #include <gtk/gtk.h>
27 #include <gdk/gdkkeysyms.h>
28
29 #include "global.h"
30
31 #include "view_iface.h"
32 #include "view_details.h"
33 #include "dir.h"
34 #include "diritem.h"
35 #include "support.h"
36 #include "type.h"
37 #include "filer.h"
38 #include "display.h"
39 #include "pixmaps.h"
40 #include "dnd.h"
41 #include "bind.h"
42 #include "gui_support.h"
43 #include "menu.h"
44 #include "options.h"
45 #include "cell_icon.h"
46
47 /* These are the column numbers in the ListStore */
48 #define COL_LEAF 0
49 #define COL_TYPE 1
50 #define COL_PERM 2
51 #define COL_OWNER 3
52 #define COL_GROUP 4
53 #define COL_SIZE 5
54 #define COL_MTIME 6
55 #define COL_ITEM 7
56 #define COL_COLOUR 8
57 #define COL_BG_COLOUR 9
58 #define COL_WEIGHT 10
59 #define COL_VIEW_ITEM 11
60 #define N_COLUMNS 12
61
62 static gpointer parent_class = NULL;
63
64 struct _ViewDetailsClass {
65 GtkTreeViewClass parent;
66 };
67
68 /* Static prototypes */
69 static void view_details_finialize(GObject *object);
70 static void view_details_class_init(gpointer gclass, gpointer data);
71 static void view_details_init(GTypeInstance *object, gpointer gclass);
72
73 static void view_details_iface_init(gpointer giface, gpointer iface_data);
74
75 static void view_details_sort(ViewIface *view);
76 static void view_details_style_changed(ViewIface *view, int flags);
77 static gboolean view_details_autoselect(ViewIface *view, const gchar *leaf);
78 static void view_details_add_items(ViewIface *view, GPtrArray *items);
79 static void view_details_update_items(ViewIface *view, GPtrArray *items);
80 static void view_details_delete_if(ViewIface *view,
81 gboolean (*test)(gpointer item, gpointer data),
82 gpointer data);
83 static void view_details_clear(ViewIface *view);
84 static void view_details_select_all(ViewIface *view);
85 static void view_details_clear_selection(ViewIface *view);
86 static int view_details_count_items(ViewIface *view);
87 static int view_details_count_selected(ViewIface *view);
88 static void view_details_show_cursor(ViewIface *view);
89 static void view_details_get_iter(ViewIface *view,
90 ViewIter *iter, IterFlags flags);
91 static void view_details_get_iter_at_point(ViewIface *view, ViewIter *iter,
92 GdkWindow *src, int x, int y);
93 static void view_details_cursor_to_iter(ViewIface *view, ViewIter *iter);
94 static void view_details_set_selected(ViewIface *view,
95 ViewIter *iter,
96 gboolean selected);
97 static gboolean view_details_get_selected(ViewIface *view, ViewIter *iter);
98 static void view_details_select_only(ViewIface *view, ViewIter *iter);
99 static void view_details_set_frozen(ViewIface *view, gboolean frozen);
100 static void view_details_wink_item(ViewIface *view, ViewIter *iter);
101 static void view_details_autosize(ViewIface *view);
102 static gboolean view_details_cursor_visible(ViewIface *view);
103 static void view_details_set_base(ViewIface *view, ViewIter *iter);
104 static void view_details_start_lasso_box(ViewIface *view,
105 GdkEventButton *event);
106 static void view_details_extend_tip(ViewIface *view,
107 ViewIter *iter, GString *tip);
108 static gboolean view_details_auto_scroll_callback(ViewIface *view);
109
110 static DirItem *iter_peek(ViewIter *iter);
111 static DirItem *iter_prev(ViewIter *iter);
112 static DirItem *iter_next(ViewIter *iter);
113 static void make_iter(ViewDetails *view_details, ViewIter *iter,
114 IterFlags flags);
115 static void make_item_iter(ViewDetails *view_details, ViewIter *iter, int i);
116 static void view_details_tree_model_init(GtkTreeModelIface *iface);
117 static gboolean details_get_sort_column_id(GtkTreeSortable *sortable,
118 gint *sort_column_id,
119 GtkSortType *order);
120 static void details_set_sort_column_id(GtkTreeSortable *sortable,
121 gint sort_column_id,
122 GtkSortType order);
123 static void details_set_sort_func(GtkTreeSortable *sortable,
124 gint sort_column_id,
125 GtkTreeIterCompareFunc func,
126 gpointer data,
127 GtkDestroyNotify destroy);
128 static void details_set_default_sort_func(GtkTreeSortable *sortable,
129 GtkTreeIterCompareFunc func,
130 gpointer data,
131 GtkDestroyNotify destroy);
132 static gboolean details_has_default_sort_func(GtkTreeSortable *sortable);
133 static void view_details_sortable_init(GtkTreeSortableIface *iface);
134 static void set_selected(ViewDetails *view_details, int i, gboolean selected);
135 static gboolean get_selected(ViewDetails *view_details, int i);
136 static void free_view_item(ViewItem *view_item);
137 static void details_update_header_visibility(ViewDetails *view_details);
138
139
140 /****************************************************************
141 * EXTERNAL INTERFACE *
142 ****************************************************************/
143
144 GtkWidget *view_details_new(FilerWindow *filer_window)
145 {
146 ViewDetails *view_details;
147
148 view_details = g_object_new(view_details_get_type(), NULL);
149 view_details->filer_window = filer_window;
150
151 gtk_range_set_adjustment(GTK_RANGE(filer_window->scrollbar),
152 gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(view_details)));
153
154 if (filer_window->sort_type != -1)
155 view_details_sort((ViewIface *) view_details);
156
157 details_update_header_visibility(view_details);
158
159 return GTK_WIDGET(view_details);
160 }
161
162 GType view_details_get_type(void)
163 {
164 static GType type = 0;
165
166 if (!type)
167 {
168 static const GTypeInfo info =
169 {
170 sizeof (ViewDetailsClass),
171 NULL, /* base_init */
172 NULL, /* base_finalise */
173 view_details_class_init,
174 NULL, /* class_finalise */
175 NULL, /* class_data */
176 sizeof(ViewDetails),
177 0, /* n_preallocs */
178 view_details_init
179 };
180 static const GInterfaceInfo view_iface_info = {
181 view_details_iface_init,
182 NULL, NULL
183 };
184 static const GInterfaceInfo tree_model_info = {
185 (GInterfaceInitFunc) view_details_tree_model_init,
186 NULL, NULL
187 };
188 static const GInterfaceInfo sortable_info = {
189 (GInterfaceInitFunc) view_details_sortable_init,
190 NULL, NULL
191 };
192
193
194 type = g_type_register_static(gtk_tree_view_get_type(),
195 "ViewDetails", &info, 0);
196
197 g_type_add_interface_static(type, VIEW_TYPE_IFACE,
198 &view_iface_info);
199 g_type_add_interface_static(type, GTK_TYPE_TREE_MODEL,
200 &tree_model_info);
201 g_type_add_interface_static(type, GTK_TYPE_TREE_SORTABLE,
202 &sortable_info);
203 }
204
205 return type;
206 }
207
208 /****************************************************************
209 * INTERNAL FUNCTIONS *
210 ****************************************************************/
211
212 /* Update the visibility of the list headers */
213 static void details_update_header_visibility(ViewDetails *view_details)
214 {
215 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view_details),
216 o_display_show_headers.int_value);
217 }
218
219 /* Fulfill the GtkTreeModel requirements */
220 static guint details_get_flags(GtkTreeModel *tree_model)
221 {
222 return GTK_TREE_MODEL_LIST_ONLY;
223 }
224
225 static gint details_get_n_columns(GtkTreeModel *tree_model)
226 {
227 return N_COLUMNS;
228 }
229
230 static GType details_get_column_type(GtkTreeModel *tree_model, gint index)
231 {
232 g_return_val_if_fail(index < N_COLUMNS && index >= 0, G_TYPE_INVALID);
233
234 if (index == COL_COLOUR || index == COL_BG_COLOUR)
235 return GDK_TYPE_COLOR;
236 else if (index == COL_ITEM || index == COL_VIEW_ITEM)
237 return G_TYPE_POINTER;
238 else if (index == COL_WEIGHT)
239 return G_TYPE_INT;
240 return G_TYPE_STRING;
241 }
242
243 static gboolean details_get_iter(GtkTreeModel *tree_model,
244 GtkTreeIter *iter,
245 GtkTreePath *path)
246 {
247 ViewDetails *view_details = (ViewDetails *) tree_model;
248 gint i;
249
250 g_return_val_if_fail(gtk_tree_path_get_depth (path) > 0, FALSE);
251
252 i = gtk_tree_path_get_indices(path)[0];
253
254 if (i >= view_details->items->len)
255 return FALSE;
256
257 iter->user_data = GINT_TO_POINTER(i);
258
259 return TRUE;
260 }
261
262 static GtkTreePath *details_get_path(GtkTreeModel *tree_model,
263 GtkTreeIter *iter)
264 {
265 GtkTreePath *retval;
266
267 retval = gtk_tree_path_new();
268 gtk_tree_path_append_index(retval, GPOINTER_TO_INT(iter->user_data));
269
270 return retval;
271 }
272
273 static void details_get_value(GtkTreeModel *tree_model,
274 GtkTreeIter *iter,
275 gint column,
276 GValue *value)
277 {
278 ViewDetails *view_details = (ViewDetails *) tree_model;
279 GtkStyle *style = ((GtkWidget *) tree_model)->style;
280 gint i;
281 GPtrArray *items = view_details->items;
282 ViewItem *view_item;
283 DirItem *item;
284 mode_t m;
285
286 g_return_if_fail(column >= 0 && column < N_COLUMNS);
287
288 i = GPOINTER_TO_INT(iter->user_data);
289 g_return_if_fail(i >= 0 && i < items->len);
290 view_item = (ViewItem *) items->pdata[i];
291 item = view_item->item;
292
293 if (column == COL_LEAF)
294 {
295 g_value_init(value, G_TYPE_STRING);
296 g_value_set_string(value,
297 view_item->utf8_name ? view_item->utf8_name
298 : item->leafname);
299 return;
300 }
301 else if (column == COL_VIEW_ITEM)
302 {
303 g_value_init(value, G_TYPE_POINTER);
304 g_value_set_pointer(value, view_item);
305 return;
306 }
307 else if (column == COL_ITEM)
308 {
309 g_value_init(value, G_TYPE_POINTER);
310 g_value_set_pointer(value, item);
311 return;
312 }
313
314 if (item->base_type == TYPE_UNKNOWN)
315 {
316 GType type;
317 type = details_get_column_type(tree_model, column);
318 g_value_init(value, type);
319 if (type == G_TYPE_STRING)
320 g_value_set_string(value, "");
321 else if (type == GDK_TYPE_COLOR)
322 g_value_set_boxed(value, NULL);
323 else if (type == G_TYPE_INT)
324 g_value_set_int(value, PANGO_WEIGHT_NORMAL);
325 else
326 g_value_set_object(value, NULL);
327
328 return;
329 }
330 m = item->mode;
331
332 switch (column)
333 {
334 case COL_LEAF:
335 g_value_init(value, G_TYPE_STRING);
336 g_value_set_string(value, item->leafname);
337 break;
338 case COL_COLOUR:
339 g_value_init(value, GDK_TYPE_COLOR);
340 if (view_item->utf8_name)
341 {
342 GdkColor red;
343 red.red = 0xffff;
344 red.green = 0;
345 red.blue = 0;
346 g_value_set_boxed(value, &red);
347 }
348 else
349 g_value_set_boxed(value,
350 type_get_colour(item, NULL));
351 break;
352 case COL_BG_COLOUR:
353 g_value_init(value, GDK_TYPE_COLOR);
354 if (view_item->selected)
355 {
356 GtkStateType state = view_details->
357 filer_window->selection_state;
358 g_value_set_boxed(value, &style->base[state]);
359 }
360 else
361 g_value_set_boxed(value, NULL);
362 break;
363 case COL_OWNER:
364 g_value_init(value, G_TYPE_STRING);
365 g_value_set_string(value, user_name(item->uid));
366 break;
367 case COL_GROUP:
368 g_value_init(value, G_TYPE_STRING);
369 g_value_set_string(value, group_name(item->gid));
370 break;
371 case COL_MTIME:
372 {
373 gchar *time;
374 time = pretty_time(&item->mtime);
375 g_value_init(value, G_TYPE_STRING);
376 g_value_set_string(value, time);
377 g_free(time);
378 break;
379 }
380 case COL_PERM:
381 g_value_init(value, G_TYPE_STRING);
382 g_value_set_string(value, pretty_permissions(m));
383 break;
384 case COL_SIZE:
385 g_value_init(value, G_TYPE_STRING);
386 if (item->base_type != TYPE_DIRECTORY)
387 g_value_set_string(value,
388 format_size(item->size));
389 break;
390 case COL_TYPE:
391 g_value_init(value, G_TYPE_STRING);
392 g_value_set_string(value,
393 item->flags & ITEM_FLAG_APPDIR? "App" :
394 S_ISDIR(m) ? "Dir" :
395 S_ISCHR(m) ? "Char" :
396 S_ISBLK(m) ? "Blck" :
397 S_ISLNK(m) ? "Link" :
398 S_ISSOCK(m) ? "Sock" :
399 S_ISFIFO(m) ? "Pipe" :
400 S_ISDOOR(m) ? "Door" :
401 "File");
402 break;
403 case COL_WEIGHT:
404 g_value_init(value, G_TYPE_INT);
405 if (item->flags & ITEM_FLAG_RECENT)
406 g_value_set_int(value, PANGO_WEIGHT_BOLD);
407 else
408 g_value_set_int(value, PANGO_WEIGHT_NORMAL);
409 break;
410 default:
411 g_value_init(value, G_TYPE_STRING);
412 g_value_set_string(value, "Hello");
413 break;
414 }
415 }
416
417 static gboolean details_iter_next(GtkTreeModel *tree_model, GtkTreeIter *iter)
418 {
419 ViewDetails *view_details = (ViewDetails *) tree_model;
420 int i;
421
422 i = GPOINTER_TO_INT(iter->user_data) + 1;
423 iter->user_data = GINT_TO_POINTER(i);
424
425 return i < view_details->items->len;
426 }
427
428 static gboolean details_iter_children(GtkTreeModel *tree_model,
429 GtkTreeIter *iter,
430 GtkTreeIter *parent)
431 {
432 ViewDetails *view_details = (ViewDetails *) tree_model;
433
434 /* this is a list, nodes have no children */
435 if (parent)
436 return FALSE;
437
438 /* but if parent == NULL we return the list itself as children of the
439 * "root"
440 */
441
442 if (view_details->items->len)
443 {
444 iter->user_data = GINT_TO_POINTER(0);
445 return TRUE;
446 }
447 else
448 return FALSE;
449 }
450
451 static gboolean details_iter_has_child(GtkTreeModel *tree_model,
452 GtkTreeIter *iter)
453 {
454 return FALSE;
455 }
456
457 static gint details_iter_n_children(GtkTreeModel *tree_model, GtkTreeIter *iter)
458 {
459 ViewDetails *view_details = (ViewDetails *) tree_model;
460
461 if (iter == NULL)
462 return view_details->items->len;
463
464 return 0;
465 }
466
467 static gboolean details_iter_nth_child(GtkTreeModel *tree_model,
468 GtkTreeIter *iter,
469 GtkTreeIter *parent,
470 gint n)
471 {
472 ViewDetails *view_details = (ViewDetails *) tree_model;
473
474 if (parent)
475 return FALSE;
476
477 if (n >= 0 && n < view_details->items->len)
478 {
479 iter->user_data = GINT_TO_POINTER(n);
480 return TRUE;
481 }
482 else
483 return FALSE;
484 }
485
486 static gboolean details_iter_parent(GtkTreeModel *tree_model,
487 GtkTreeIter *iter,
488 GtkTreeIter *child)
489 {
490 return FALSE;
491 }
492
493 /* A ViewDetails is both a GtkTreeView and a GtkTreeModel.
494 * The following functions implement the model interface...
495 */
496
497 static void view_details_tree_model_init(GtkTreeModelIface *iface)
498 {
499 iface->get_flags = details_get_flags;
500 iface->get_n_columns = details_get_n_columns;
501 iface->get_column_type = details_get_column_type;
502 iface->get_iter = details_get_iter;
503 iface->get_path = details_get_path;
504 iface->get_value = details_get_value;
505 iface->iter_next = details_iter_next;
506 iface->iter_children = details_iter_children;
507 iface->iter_has_child = details_iter_has_child;
508 iface->iter_n_children = details_iter_n_children;
509 iface->iter_nth_child = details_iter_nth_child;
510 iface->iter_parent = details_iter_parent;
511 }
512
513 static void view_details_sortable_init(GtkTreeSortableIface *iface)
514 {
515 iface->get_sort_column_id = details_get_sort_column_id;
516 iface->set_sort_column_id = details_set_sort_column_id;
517 iface->set_sort_func = details_set_sort_func;
518 iface->set_default_sort_func = details_set_default_sort_func;
519 iface->has_default_sort_func = details_has_default_sort_func;
520 }
521
522 static gboolean details_get_sort_column_id(GtkTreeSortable *sortable,
523 gint *sort_column_id,
524 GtkSortType *order)
525 {
526 ViewDetails *view_details = (ViewDetails *) sortable;
527 FilerWindow *filer_window = view_details->filer_window;
528 int col;
529
530 if (!filer_window)
531 return FALSE; /* Not yet initialised */
532
533 switch (filer_window->sort_type)
534 {
535 case SORT_NAME: col = COL_LEAF; break;
536 case SORT_TYPE: col = COL_TYPE; break;
537 case SORT_DATE: col = COL_MTIME; break;
538 case SORT_SIZE: col = COL_SIZE; break;
539 case SORT_OWNER: col = COL_OWNER; break;
540 case SORT_GROUP: col = COL_GROUP; break;
541 default:
542 g_warning("details_get_sort_column_id(): error!");
543 return FALSE;
544 }
545 if (sort_column_id)
546 *sort_column_id = col;
547 if (order)
548 *order = filer_window->sort_order;
549 return TRUE;
550 }
551
552 static void details_set_sort_column_id(GtkTreeSortable *sortable,
553 gint sort_column_id,
554 GtkSortType order)
555 {
556 ViewDetails *view_details = (ViewDetails *) sortable;
557 FilerWindow *filer_window = view_details->filer_window;
558
559 if (!filer_window)
560 return; /* Not yet initialised */
561
562 switch (sort_column_id)
563 {
564 case COL_LEAF:
565 display_set_sort_type(filer_window, SORT_NAME, order);
566 break;
567 case COL_SIZE:
568 display_set_sort_type(filer_window, SORT_SIZE, order);
569 break;
570 case COL_MTIME:
571 display_set_sort_type(filer_window, SORT_DATE, order);
572 break;
573 case COL_TYPE:
574 display_set_sort_type(filer_window, SORT_TYPE, order);
575 break;
576 case COL_OWNER:
577 display_set_sort_type(filer_window, SORT_OWNER, order);
578 break;
579 case COL_GROUP:
580 display_set_sort_type(filer_window, SORT_GROUP, order);
581 break;
582 default:
583 g_assert_not_reached();
584 }
585 }
586
587 static void details_set_sort_func(GtkTreeSortable *sortable,
588 gint sort_column_id,
589 GtkTreeIterCompareFunc func,
590 gpointer data,
591 GtkDestroyNotify destroy)
592 {
593 g_assert_not_reached();
594 }
595
596 static void details_set_default_sort_func(GtkTreeSortable *sortable,
597 GtkTreeIterCompareFunc func,
598 gpointer data,
599 GtkDestroyNotify destroy)
600 {
601 g_assert_not_reached();
602 }
603
604 static gboolean details_has_default_sort_func(GtkTreeSortable *sortable)
605 {
606 return FALSE;
607 }
608
609
610 /* End of model implementation */
611
612 static gboolean is_selected(ViewDetails *view_details, int i)
613 {
614 ViewIter iter;
615 iter.i = i;
616 return view_details_get_selected((ViewIface *) view_details, &iter);
617 }
618
619 static gboolean view_details_scroll(GtkWidget *widget, GdkEventScroll *event)
620 {
621 GtkTreeView *tree = (GtkTreeView *) widget;
622 GtkTreePath *path = NULL;
623
624 if (!gtk_tree_view_get_path_at_pos(tree, 0, 1, &path, NULL, NULL, NULL))
625 return TRUE; /* Empty? */
626
627 if (event->direction == GDK_SCROLL_UP)
628 gtk_tree_path_prev(path);
629 else if (event->direction == GDK_SCROLL_DOWN)
630 gtk_tree_path_next(path);
631 else
632 goto out;
633
634 gtk_tree_view_scroll_to_cell(tree, path, NULL, TRUE, 0, 0);
635 out:
636 gtk_tree_path_free(path);
637 return TRUE;
638 }
639
640 static gboolean view_details_button_press(GtkWidget *widget,
641 GdkEventButton *bev)
642 {
643 FilerWindow *filer_window = ((ViewDetails *) widget)->filer_window;
644 GtkTreeView *tree = (GtkTreeView *) widget;
645
646 if (bev->window != gtk_tree_view_get_bin_window(tree))
647 return GTK_WIDGET_CLASS(parent_class)->button_press_event(
648 widget, bev);
649
650 if (dnd_motion_press(widget, bev))
651 filer_perform_action(filer_window, bev);
652
653 return TRUE;
654 }
655
656 static gboolean view_details_button_release(GtkWidget *widget,
657 GdkEventButton *bev)
658 {
659 FilerWindow *filer_window = ((ViewDetails *) widget)->filer_window;
660 GtkTreeView *tree = (GtkTreeView *) widget;
661
662 if (bev->window != gtk_tree_view_get_bin_window(tree))
663 return GTK_WIDGET_CLASS(parent_class)->button_release_event(
664 widget, bev);
665
666 if (!dnd_motion_release(bev))
667 filer_perform_action(filer_window, bev);
668
669 return TRUE;
670 }
671
672 static gint view_details_motion_notify(GtkWidget *widget, GdkEventMotion *event)
673 {
674 ViewDetails *view_details = (ViewDetails *) widget;
675 GtkTreeView *tree = (GtkTreeView *) widget;
676
677 if (event->window != gtk_tree_view_get_bin_window(tree))
678 return GTK_WIDGET_CLASS(parent_class)->motion_notify_event(
679 widget, event);
680
681 return filer_motion_notify(view_details->filer_window, event);
682 }
683
684 static gboolean view_details_expose(GtkWidget *widget, GdkEventExpose *event)
685 {
686 GtkTreeView *tree = (GtkTreeView *) widget;
687 GtkTreePath *path = NULL;
688 GdkRectangle focus_rectangle;
689 gboolean had_cursor;
690
691 had_cursor = (GTK_WIDGET_FLAGS(widget) & GTK_HAS_FOCUS) != 0;
692
693 if (had_cursor)
694 GTK_WIDGET_UNSET_FLAGS(widget, GTK_HAS_FOCUS);
695 GTK_WIDGET_CLASS(parent_class)->expose_event(widget, event);
696 if (had_cursor)
697 GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_FOCUS);
698
699 if (event->window != gtk_tree_view_get_bin_window(tree))
700 return FALSE; /* Not the main area */
701
702 gtk_tree_view_get_cursor(tree, &path, NULL);
703 if (!path)
704 return FALSE; /* No cursor */
705 gtk_tree_view_get_background_area(tree, path, NULL, &focus_rectangle);
706 gtk_tree_path_free(path);
707
708 if (!focus_rectangle.height)
709 return FALSE; /* Off screen */
710
711 focus_rectangle.width = widget->allocation.width;
712
713 gtk_paint_focus(widget->style,
714 event->window,
715 GTK_STATE_NORMAL,
716 NULL,
717 widget,
718 "treeview",
719 focus_rectangle.x,
720 focus_rectangle.y,
721 focus_rectangle.width,
722 focus_rectangle.height);
723
724 return FALSE;
725 }
726
727 static void view_details_size_request(GtkWidget *widget,
728 GtkRequisition *requisition)
729 {
730 ViewDetails *view_details = (ViewDetails *) widget;
731
732 (*GTK_WIDGET_CLASS(parent_class)->size_request)(widget, requisition);
733
734 view_details->desired_size = *requisition;
735
736 requisition->height = 50;
737 requisition->width = 50;
738 }
739
740 static void view_details_drag_data_received(GtkWidget *widget,
741 GdkDragContext *drag_context,
742 gint x, gint y, GtkSelectionData *data, guint info, guint time)
743 {
744 /* Just here to override annoying default handler */
745 }
746
747 static void view_details_destroy(GtkObject *view_details)
748 {
749 VIEW_DETAILS(view_details)->filer_window = NULL;
750 }
751
752 static void view_details_finialize(GObject *object)
753 {
754 ViewDetails *view_details = (ViewDetails *) object;
755
756 g_ptr_array_free(view_details->items, TRUE);
757 view_details->items = NULL;
758
759 G_OBJECT_CLASS(parent_class)->finalize(object);
760 }
761
762 static void view_details_class_init(gpointer gclass, gpointer data)
763 {
764 GObjectClass *object = (GObjectClass *) gclass;
765 GtkWidgetClass *widget = (GtkWidgetClass *) gclass;
766
767 parent_class = g_type_class_peek_parent(gclass);
768
769 object->finalize = view_details_finialize;
770 GTK_OBJECT_CLASS(object)->destroy = view_details_destroy;
771
772 widget->scroll_event = view_details_scroll;
773 widget->button_press_event = view_details_button_press;
774 widget->button_release_event = view_details_button_release;
775 widget->motion_notify_event = view_details_motion_notify;
776 widget->expose_event = view_details_expose;
777 widget->size_request = view_details_size_request;
778 widget->drag_data_received = view_details_drag_data_received;
779 }
780
781 static gboolean block_focus(GtkWidget *button, GtkDirectionType dir,
782 ViewDetails *view_details)
783 {
784 GTK_WIDGET_UNSET_FLAGS(button, GTK_CAN_FOCUS);
785 return FALSE;
786 }
787
788 #define ADD_TEXT_COLUMN(name, model_column) \
789 cell = gtk_cell_renderer_text_new(); \
790 column = gtk_tree_view_column_new_with_attributes(name, cell, \
791 "text", model_column, \
792 "foreground-gdk", COL_COLOUR, \
793 "background-gdk", COL_BG_COLOUR, \
794 "weight", COL_WEIGHT, \
795 NULL); \
796 gtk_tree_view_append_column(treeview, column); \
797 g_signal_connect(column->button, "grab-focus", \
798 G_CALLBACK(block_focus), view_details);
799
800 static void view_details_init(GTypeInstance *object, gpointer gclass)
801 {
802 GtkTreeView *treeview = (GtkTreeView *) object;
803 GtkTreeViewColumn *column;
804 GtkCellRenderer *cell;
805 GtkTreeSortable *sortable_list;
806 GtkTreeSelection *selection;
807 ViewDetails *view_details = (ViewDetails *) object;
808
809 view_details->items = g_ptr_array_new();
810 view_details->cursor_base = -1;
811 view_details->desired_size.width = -1;
812 view_details->desired_size.height = -1;
813
814 selection = gtk_tree_view_get_selection(treeview);
815 gtk_tree_selection_set_mode(selection, GTK_SELECTION_NONE);
816
817 /* Sorting */
818 view_details->sort_fn = NULL;
819 sortable_list = GTK_TREE_SORTABLE(object);
820
821 gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(view_details));
822
823 /* Icon */
824 cell = cell_icon_new(view_details);
825 column = gtk_tree_view_column_new_with_attributes(NULL, cell,
826 "item", COL_VIEW_ITEM,
827 "background-gdk", COL_BG_COLOUR,
828 NULL);
829 gtk_tree_view_append_column(treeview, column);
830
831 ADD_TEXT_COLUMN(_("_Name"), COL_LEAF);
832 gtk_tree_view_column_set_sort_column_id(column, COL_LEAF);
833 gtk_tree_view_column_set_resizable(column, TRUE);
834 ADD_TEXT_COLUMN(_("_Type"), COL_TYPE);
835 gtk_tree_view_column_set_sort_column_id(column, COL_TYPE);
836 ADD_TEXT_COLUMN(_("_Permissions"), COL_PERM);
837 ADD_TEXT_COLUMN(_("_Owner"), COL_OWNER);
838 gtk_tree_view_column_set_sort_column_id(column, COL_OWNER);
839 ADD_TEXT_COLUMN(_("_Group"), COL_GROUP);
840 gtk_tree_view_column_set_sort_column_id(column, COL_GROUP);
841 ADD_TEXT_COLUMN(_("_Size"), COL_SIZE);
842 gtk_tree_view_column_set_sort_column_id(column, COL_SIZE);
843 ADD_TEXT_COLUMN(_("Last _Modified"), COL_MTIME);
844 gtk_tree_view_column_set_sort_column_id(column, COL_MTIME);
845 }
846
847 /* Create the handers for the View interface */
848 static void view_details_iface_init(gpointer giface, gpointer iface_data)
849 {
850 ViewIfaceClass *iface = giface;
851
852 g_assert(G_TYPE_FROM_INTERFACE(iface) == VIEW_TYPE_IFACE);
853
854 /* override stuff */
855 iface->sort = view_details_sort;
856 iface->style_changed = view_details_style_changed;
857 iface->autoselect = view_details_autoselect;
858 iface->add_items = view_details_add_items;
859 iface->update_items = view_details_update_items;
860 iface->delete_if = view_details_delete_if;
861 iface->clear = view_details_clear;
862 iface->select_all = view_details_select_all;
863 iface->clear_selection = view_details_clear_selection;
864 iface->count_items = view_details_count_items;
865 iface->count_selected = view_details_count_selected;
866 iface->show_cursor = view_details_show_cursor;
867 iface->get_iter = view_details_get_iter;
868 iface->get_iter_at_point = view_details_get_iter_at_point;
869 iface->cursor_to_iter = view_details_cursor_to_iter;
870 iface->set_selected = view_details_set_selected;
871 iface->get_selected = view_details_get_selected;
872 iface->set_frozen = view_details_set_frozen;
873 iface->select_only = view_details_select_only;
874 iface->wink_item = view_details_wink_item;
875 iface->autosize = view_details_autosize;
876 iface->cursor_visible = view_details_cursor_visible;
877 iface->set_base = view_details_set_base;
878 iface->start_lasso_box = view_details_start_lasso_box;
879 iface->extend_tip = view_details_extend_tip;
880 iface->auto_scroll_callback = view_details_auto_scroll_callback;
881 }
882
883 /* Implementations of the View interface. See view_iface.c for comments. */
884
885 static void view_details_style_changed(ViewIface *view, int flags)
886 {
887 ViewDetails *view_details = (ViewDetails *) view;
888 GtkTreeModel *model = (GtkTreeModel *) view;
889 GtkTreePath *path;
890 ViewItem **items = (ViewItem **) view_details->items->pdata;
891 int i;
892 int n = view_details->items->len;
893
894 path = gtk_tree_path_new();
895 gtk_tree_path_append_index(path, 0);
896
897 for (i = 0; i < n; i++)
898 {
899 GtkTreeIter iter;
900 ViewItem *item = items[i];
901
902 iter.user_data = GINT_TO_POINTER(i);
903 if (item->image)
904 {
905 g_object_unref(G_OBJECT(item->image));
906 item->image = NULL;
907 }
908 gtk_tree_model_row_changed(model, path, &iter);
909 gtk_tree_path_next(path);
910 }
911
912 gtk_tree_path_free(path);
913
914 gtk_tree_view_columns_autosize((GtkTreeView *) view);
915
916 if (flags & VIEW_UPDATE_HEADERS)
917 details_update_header_visibility(view_details);
918 }
919
920 static gint wrap_sort(gconstpointer a, gconstpointer b,
921 ViewDetails *view_details)
922 {
923 ViewItem *ia = *(ViewItem **) a;
924 ViewItem *ib = *(ViewItem **) b;
925
926 if (view_details->filer_window->sort_order == GTK_SORT_ASCENDING)
927 return view_details->sort_fn(ia->item, ib->item);
928 else
929 return -view_details->sort_fn(ia->item, ib->item);
930 }
931
932 static void resort(ViewDetails *view_details)
933 {
934 ViewItem **items = (ViewItem **) view_details->items->pdata;
935 gint i, len = view_details->items->len;
936 guint *new_order;
937 GtkTreePath *path;
938
939 if (!len)
940 return;
941
942 for (i = len - 1; i >= 0; i--)
943 items[i]->old_pos = i;
944
945 switch (view_details->filer_window->sort_type)
946 {
947 case SORT_NAME: view_details->sort_fn = sort_by_name; break;
948 case SORT_TYPE: view_details->sort_fn = sort_by_type; break;
949 case SORT_DATE: view_details->sort_fn = sort_by_date; break;
950 case SORT_SIZE: view_details->sort_fn = sort_by_size; break;
951 case SORT_OWNER: view_details->sort_fn = sort_by_owner; break;
952 case SORT_GROUP: view_details->sort_fn = sort_by_group; break;
953 default:
954 g_assert_not_reached();
955 }
956
957 g_ptr_array_sort_with_data(view_details->items,
958 (GCompareDataFunc) wrap_sort,
959 view_details);
960
961 new_order = g_new(guint, len);
962 for (i = len - 1; i >= 0; i--)
963 new_order[i] = items[i]->old_pos;
964
965 path = gtk_tree_path_new();
966 gtk_tree_model_rows_reordered((GtkTreeModel *) view_details,
967 path, NULL, new_order);
968 gtk_tree_path_free(path);
969 g_free(new_order);
970 }
971
972 static void view_details_sort(ViewIface *view)
973 {
974 resort((ViewDetails *) view);
975 gtk_tree_sortable_sort_column_changed((GtkTreeSortable *) view);
976 }
977
978 static gboolean view_details_autoselect(ViewIface *view, const gchar *leaf)
979 {
980 return FALSE;
981 }
982
983 static void view_details_add_items(ViewIface *view, GPtrArray *new_items)
984 {
985 ViewDetails *view_details = (ViewDetails *) view;
986 FilerWindow *filer_window = view_details->filer_window;
987 gboolean show_hidden = filer_window->show_hidden;
988 GPtrArray *items = view_details->items;
989 GtkTreeIter iter;
990 int i;
991 GtkTreePath *path;
992 GtkTreeModel *model = (GtkTreeModel *) view;
993
994 iter.user_data = GINT_TO_POINTER(items->len);
995 path = details_get_path(model, &iter);
996
997 for (i = 0; i < new_items->len; i++)
998 {
999 DirItem *item = (DirItem *) new_items->pdata[i];
1000 char *leafname = item->leafname;
1001 ViewItem *vitem;
1002
1003 if (leafname[0] == '.')
1004 {
1005 if (!show_hidden)
1006 continue;
1007
1008 if (leafname[1] == '\0')
1009 continue; /* Never show '.' */
1010
1011 if (leafname[1] == '.' &&
1012 leafname[2] == '\0')
1013 continue; /* Never show '..' */
1014 }
1015
1016 vitem = g_new(ViewItem, 1);
1017 vitem->item = item;
1018 vitem->image = NULL;
1019 vitem->selected = FALSE;
1020 if (!g_utf8_validate(leafname, -1, NULL))
1021 vitem->utf8_name = to_utf8(leafname);
1022 else
1023 vitem->utf8_name = NULL;
1024
1025 g_ptr_array_add(items, vitem);
1026
1027 iter.user_data = GINT_TO_POINTER(items->len - 1);
1028 gtk_tree_model_row_inserted(model, path, &iter);
1029 gtk_tree_path_next(path);
1030 }
1031
1032 gtk_tree_path_free(path);
1033
1034 resort(view_details);
1035 }
1036
1037 /* Find an item in the sorted array.
1038 * Returns the item number, or -1 if not found.
1039 */
1040 static int details_find_item(ViewDetails *view_details, DirItem *item)
1041 {
1042 ViewItem **items, tmp, *tmpp;
1043 int lower, upper;
1044
1045 g_return_val_if_fail(view_details != NULL, -1);
1046 g_return_val_if_fail(item != NULL, -1);
1047
1048 tmp.item = item;
1049 tmpp = &tmp;
1050
1051 items = (ViewItem **) view_details->items->pdata;
1052
1053 /* If item is here, then: lower <= i < upper */
1054 lower = 0;
1055 upper = view_details->items->len;
1056
1057 while (lower < upper)
1058 {
1059 int i, cmp;
1060
1061 i = (lower + upper) >> 1;
1062
1063 cmp = wrap_sort(&items[i], &tmpp, view_details);
1064 if (cmp == 0)
1065 return i;
1066
1067 if (cmp > 0)
1068 upper = i;
1069 else
1070 lower = i + 1;
1071 }
1072
1073 return -1;
1074 }
1075
1076 static void view_details_update_items(ViewIface *view, GPtrArray *items)
1077 {
1078 ViewDetails *view_details = (ViewDetails *) view;
1079 FilerWindow *filer_window = view_details->filer_window;
1080 int i;
1081 GtkTreeModel *model = (GtkTreeModel *) view_details;
1082
1083 g_return_if_fail(items->len > 0);
1084
1085 /* The item data has already been modified, so this gives the
1086 * final sort order...
1087 */
1088 resort(view_details);
1089
1090 for (i = 0; i < items->len; i++)
1091 {
1092 DirItem *item = (DirItem *) items->pdata[i];
1093 const gchar *leafname = item->leafname;
1094 int j;
1095
1096 if (leafname[0] == '.' && filer_window->show_hidden == FALSE)
1097 continue;
1098
1099 j = details_find_item(view_details, item);
1100
1101 if (j < 0)
1102 g_warning("Failed to find '%s'\n", leafname);
1103 else
1104 {
1105 GtkTreePath *path;
1106 GtkTreeIter iter;
1107 ViewItem *view_item = view_details->items->pdata[j];
1108 if (view_item->image)
1109 {
1110 g_object_unref(G_OBJECT(view_item->image));
1111 view_item->image = NULL;
1112 }
1113 path = gtk_tree_path_new();
1114 gtk_tree_path_append_index(path, j);
1115 iter.user_data = GINT_TO_POINTER(j);
1116 gtk_tree_model_row_changed(model, path, &iter);
1117 }
1118 }
1119 }
1120
1121 static void view_details_delete_if(ViewIface *view,
1122 gboolean (*test)(gpointer item, gpointer data),
1123 gpointer data)
1124 {
1125 GtkTreePath *path;
1126 ViewDetails *view_details = (ViewDetails *) view;
1127 int i = 0;
1128 GPtrArray *items = view_details->items;
1129 GtkTreeModel *model = (GtkTreeModel *) view;
1130
1131 path = gtk_tree_path_new();
1132
1133 gtk_tree_path_append_index(path, i);
1134
1135 while (i < items->len)
1136 {
1137 ViewItem *item = items->pdata[i];
1138
1139 if (test(item->item, data))
1140 {
1141 free_view_item(items->pdata[i]);
1142 g_ptr_array_remove_index(items, i);
1143 gtk_tree_model_row_deleted(model, path);
1144 }
1145 else
1146 {
1147 i++;
1148 gtk_tree_path_next(path);
1149 }
1150 }
1151
1152 gtk_tree_path_free(path);
1153 }
1154
1155 static void view_details_clear(ViewIface *view)
1156 {
1157 GtkTreePath *path;
1158 GPtrArray *items = ((ViewDetails *) view)->items;
1159 GtkTreeModel *model = (GtkTreeModel *) view;
1160
1161 path = gtk_tree_path_new();
1162 gtk_tree_path_append_index(path, items->len);
1163
1164 while (gtk_tree_path_prev(path))
1165 gtk_tree_model_row_deleted(model, path);
1166
1167 g_ptr_array_set_size(items, 0);
1168 gtk_tree_path_free(path);
1169 }
1170
1171 static void view_details_select_all(ViewIface *view)
1172 {
1173 int i;
1174 int n = ((ViewDetails *) view)->items->len;
1175
1176 for (i = 0; i < n; i++)
1177 {
1178 ViewIter iter;
1179 iter.i = i;
1180 view_details_set_selected(view, &iter, TRUE);
1181 }
1182 }
1183
1184 static void view_details_clear_selection(ViewIface *view)
1185 {
1186 int i;
1187 int n = ((ViewDetails *) view)->items->len;
1188
1189 for (i = 0; i < n; i++)
1190 {
1191 ViewIter iter;
1192 iter.i = i;
1193 view_details_set_selected(view, &iter, FALSE);
1194 }
1195 }
1196
1197 static int view_details_count_items(ViewIface *view)
1198 {
1199 ViewDetails *view_details = (ViewDetails *) view;
1200
1201 return view_details->items->len;
1202 }
1203
1204 static int view_details_count_selected(ViewIface *view)
1205 {
1206 ViewDetails *view_details = (ViewDetails *) view;
1207 int n = view_details->items->len;
1208 ViewItem **items = (ViewItem **) view_details->items->pdata;
1209 int count = 0;
1210 int i;
1211
1212 for (i = 0; i < n; i++)
1213 if (items[i]->selected)
1214 count++;
1215
1216 return count;
1217 }
1218
1219 static void view_details_show_cursor(ViewIface *view)
1220 {
1221 }
1222
1223 static void view_details_get_iter(ViewIface *view,
1224 ViewIter *iter, IterFlags flags)
1225 {
1226 make_iter((ViewDetails *) view, iter, flags);
1227 }
1228
1229 static void view_details_get_iter_at_point(ViewIface *view, ViewIter *iter,
1230 GdkWindow *src, int x, int y)
1231 {
1232 ViewDetails *view_details = (ViewDetails *) view;
1233 GtkTreeModel *model;
1234 GtkTreeView *tree = (GtkTreeView *) view;
1235 GtkTreePath *path = NULL;
1236 int i = -1;
1237
1238 model = gtk_tree_view_get_model(tree);
1239
1240 if (gtk_tree_view_get_path_at_pos(tree, x, y, &path, NULL, NULL, NULL))
1241 {
1242 g_return_if_fail(path != NULL);
1243
1244 i = gtk_tree_path_get_indices(path)[0];
1245 gtk_tree_path_free(path);
1246 }
1247
1248 make_item_iter(view_details, iter, i);
1249 }
1250
1251 static void view_details_cursor_to_iter(ViewIface *view, ViewIter *iter)
1252 {
1253 GtkTreePath *path;
1254 ViewDetails *view_details = (ViewDetails *) view;
1255
1256 path = gtk_tree_path_new();
1257
1258 if (iter)
1259 gtk_tree_path_append_index(path, iter->i);
1260 else
1261 {
1262 /* Using depth zero or index -1 gives an error, but this
1263 * is OK!
1264 */
1265 gtk_tree_path_append_index(path, view_details->items->len);
1266 }
1267
1268 gtk_tree_view_set_cursor((GtkTreeView *) view, path, NULL, FALSE);
1269 gtk_tree_path_free(path);
1270 }
1271
1272 static void set_selected(ViewDetails *view_details, int i, gboolean selected)
1273 {
1274 GtkTreeModel *model = (GtkTreeModel *) view_details;
1275 GtkTreeIter t_iter;
1276 GtkTreePath *path;
1277 GPtrArray *items = view_details->items;
1278 ViewItem *view_item;
1279
1280 g_return_if_fail(i >= 0 && i < items->len);
1281 view_item = (ViewItem *) items->pdata[i];
1282
1283 if (view_item->selected == selected)
1284 return;
1285
1286 view_item->selected = selected;
1287
1288 path = gtk_tree_path_new();
1289 gtk_tree_path_append_index(path, i);
1290 t_iter.user_data = GINT_TO_POINTER(i);
1291 gtk_tree_model_row_changed(model, path, &t_iter);
1292 gtk_tree_path_free(path);
1293 }
1294
1295 static void view_details_set_selected(ViewIface *view,
1296 ViewIter *iter,
1297 gboolean selected)
1298 {
1299 set_selected((ViewDetails *) view, iter->i, selected);
1300 }
1301
1302 static gboolean get_selected(ViewDetails *view_details, int i)
1303 {
1304 GPtrArray *items = view_details->items;
1305
1306 g_return_val_if_fail(i >= 0 && i < items->len, FALSE);
1307
1308 return ((ViewItem *) items->pdata[i])->selected;
1309 }
1310
1311 static gboolean view_details_get_selected(ViewIface *view, ViewIter *iter)
1312 {
1313 return get_selected((ViewDetails *) view, iter->i);
1314 }
1315
1316 static void view_details_select_only(ViewIface *view, ViewIter *iter)
1317 {
1318 ViewDetails *view_details = (ViewDetails *) view;
1319 int i = iter->i;
1320 int n = view_details->items->len;
1321
1322 set_selected(view_details, i, TRUE);
1323
1324 while (n > 0)
1325 {
1326 n--;
1327
1328 if (n != i)
1329 set_selected(view_details, n, FALSE);
1330 }
1331 }
1332
1333 static void view_details_set_frozen(ViewIface *view, gboolean frozen)
1334 {
1335 }
1336
1337 static void view_details_wink_item(ViewIface *view, ViewIter *iter)
1338 {
1339 /* TODO */
1340 }
1341
1342 static void view_details_autosize(ViewIface *view)
1343 {
1344 ViewDetails *view_details = (ViewDetails *) view;
1345 FilerWindow *filer_window = view_details->filer_window;
1346 int max_width = (o_filer_size_limit.int_value * screen_width) / 100;
1347 int max_height = (o_filer_size_limit.int_value * screen_height) / 100;
1348 int h;
1349 GtkRequisition req;
1350
1351 gtk_widget_queue_resize(GTK_WIDGET(view));
1352 gtk_widget_size_request(GTK_WIDGET(view), &req);
1353
1354 h = MAX(view_details->desired_size.height, SMALL_HEIGHT);
1355
1356 filer_window_set_size(filer_window,
1357 MIN(view_details->desired_size.width, max_width),
1358 MIN(h, max_height));
1359 }
1360
1361 static gboolean view_details_cursor_visible(ViewIface *view)
1362 {
1363 return FALSE;
1364 }
1365
1366 static void view_details_set_base(ViewIface *view, ViewIter *iter)
1367 {
1368 ViewDetails *view_details = (ViewDetails *) view;
1369
1370 view_details->cursor_base = iter->i;
1371 }
1372
1373 static void view_details_start_lasso_box(ViewIface *view, GdkEventButton *event)
1374 {
1375 }
1376
1377 static void view_details_extend_tip(ViewIface *view,
1378 ViewIter *iter, GString *tip)
1379 {
1380 }
1381
1382 static DirItem *iter_init(ViewIter *iter)
1383 {
1384 ViewDetails *view_details = (ViewDetails *) iter->view;
1385 int i = -1;
1386 int n = view_details->items->len;
1387 int flags = iter->flags;
1388
1389 iter->peek = iter_peek;
1390
1391 if (iter->n_remaining == 0)
1392 return NULL;
1393
1394 if (flags & VIEW_ITER_FROM_CURSOR)
1395 {
1396 GtkTreePath *path;
1397 gtk_tree_view_get_cursor((GtkTreeView *) view_details,
1398 &path, NULL);
1399 if (!path)
1400 return NULL; /* No cursor */
1401 i = gtk_tree_path_get_indices(path)[0];
1402 gtk_tree_path_free(path);
1403 }
1404 else if (flags & VIEW_ITER_FROM_BASE)
1405 i = view_details->cursor_base;
1406
1407 if (i < 0 || i >= n)
1408 {
1409 /* Either a normal iteration, or an iteration from an
1410 * invalid starting point.
1411 */
1412 if (flags & VIEW_ITER_BACKWARDS)
1413 i = n - 1;
1414 else
1415 i = 0;
1416 }
1417
1418 if (i < 0 || i >= n)
1419 return NULL; /* No items at all! */
1420
1421 iter->next = flags & VIEW_ITER_BACKWARDS ? iter_prev : iter_next;
1422 iter->n_remaining--;
1423 iter->i = i;
1424
1425 if (flags & VIEW_ITER_SELECTED && !is_selected(view_details, i))
1426 return iter->next(iter);
1427 return iter->peek(iter);
1428 }
1429
1430 static DirItem *iter_prev(ViewIter *iter)
1431 {
1432 ViewDetails *view_details = (ViewDetails *) iter->view;
1433 int n = view_details->items->len;
1434 int i = iter->i;
1435
1436 g_return_val_if_fail(iter->n_remaining >= 0, NULL);
1437
1438 /* i is the last item returned (always valid) */
1439
1440 g_return_val_if_fail(i >= 0 && i < n, NULL);
1441
1442 while (iter->n_remaining)
1443 {
1444 i--;
1445 iter->n_remaining--;
1446
1447 if (i == -1)
1448 i = n - 1;
1449
1450 g_return_val_if_fail(i >= 0 && i < n, NULL);
1451
1452 if (iter->flags & VIEW_ITER_SELECTED &&
1453 !is_selected(view_details, i))
1454 continue;
1455
1456 iter->i = i;
1457 return ((ViewItem *) view_details->items->pdata[i])->item;
1458 }
1459
1460 iter->i = -1;
1461 return NULL;
1462 }
1463
1464 static DirItem *iter_next(ViewIter *iter)
1465 {
1466 ViewDetails *view_details = (ViewDetails *) iter->view;
1467 int n = view_details->items->len;
1468 int i = iter->i;
1469
1470 g_return_val_if_fail(iter->n_remaining >= 0, NULL);
1471
1472 /* i is the last item returned (always valid) */
1473
1474 g_return_val_if_fail(i >= 0 && i < n, NULL);
1475
1476 while (iter->n_remaining)
1477 {
1478 i++;
1479 iter->n_remaining--;
1480
1481 if (i == n)
1482 i = 0;
1483
1484 g_return_val_if_fail(i >= 0 && i < n, NULL);
1485
1486 if (iter->flags & VIEW_ITER_SELECTED &&
1487 !is_selected(view_details, i))
1488 continue;
1489
1490 iter->i = i;
1491 return ((ViewItem *) view_details->items->pdata[i])->item;
1492 }
1493
1494 iter->i = -1;
1495 return NULL;
1496 }
1497
1498 static DirItem *iter_peek(ViewIter *iter)
1499 {
1500 ViewDetails *view_details = (ViewDetails *) iter->view;
1501 int n = view_details->items->len;
1502 int i = iter->i;
1503
1504 if (i == -1)
1505 return NULL;
1506
1507 g_return_val_if_fail(i >= 0 && i < n, NULL);
1508
1509 return ((ViewItem *) view_details->items->pdata[i])->item;
1510 }
1511
1512 /* Set the iterator to return 'i' on the next peek().
1513 * If i is -1, returns NULL on next peek().
1514 */
1515 static void make_item_iter(ViewDetails *view_details, ViewIter *iter, int i)
1516 {
1517 make_iter(view_details, iter, 0);
1518
1519 g_return_if_fail(i >= -1 && i < (int) view_details->items->len);
1520
1521 iter->i = i;
1522 iter->next = iter_next;
1523 iter->peek = iter_peek;
1524 iter->n_remaining = 0;
1525 }
1526
1527 static void make_iter(ViewDetails *view_details, ViewIter *iter,
1528 IterFlags flags)
1529 {
1530 iter->view = (ViewIface *) view_details;
1531 iter->next = iter_init;
1532 iter->peek = NULL;
1533 iter->i = -1;
1534
1535 iter->flags = flags;
1536
1537 if (flags & VIEW_ITER_ONE_ONLY)
1538 {
1539 iter->n_remaining = 1;
1540 iter->next(iter);
1541 }
1542 else
1543 iter->n_remaining = view_details->items->len;
1544 }
1545
1546 static void free_view_item(ViewItem *view_item)
1547 {
1548 if (view_item->image)
1549 g_object_unref(G_OBJECT(view_item->image));
1550 g_free(view_item->utf8_name);
1551 g_free(view_item);
1552 }
1553
1554 static gboolean view_details_auto_scroll_callback(ViewIface *view)
1555 {
1556 GtkTreeView *tree = (GtkTreeView *) view;
1557 ViewDetails *view_details = (ViewDetails *) view;
1558 FilerWindow *filer_window = view_details->filer_window;
1559 GtkRange *scrollbar = (GtkRange *) filer_window->scrollbar;
1560 GtkAdjustment *adj;
1561 GdkWindow *window;
1562 gint x, y, w, h;
1563 GdkModifierType mask;
1564 int diff = 0;
1565
1566 window = gtk_tree_view_get_bin_window(tree);
1567
1568 gdk_window_get_pointer(window, &x, &y, &mask);
1569 gdk_drawable_get_size(window, &w, NULL);
1570
1571 adj = gtk_range_get_adjustment(scrollbar);
1572 h = adj->page_size;
1573
1574 if ((x < 0 || x > w || y < 0 || y > h)) /* && !view->lasso_box) */
1575 return FALSE; /* Out of window - stop */
1576
1577 if (y < AUTOSCROLL_STEP)
1578 diff = y - AUTOSCROLL_STEP;
1579 else if (y > h - AUTOSCROLL_STEP)
1580 diff = AUTOSCROLL_STEP + y - h;
1581
1582 if (diff)
1583 {
1584 int old = adj->value;
1585 int value = old + diff;
1586
1587 value = CLAMP(value, 0, adj->upper - adj->page_size);
1588 gtk_adjustment_set_value(adj, value);
1589
1590 if (adj->value != old)
1591 dnd_spring_abort();
1592 }
1593
1594 return TRUE;
1595 }
Filer for the ROX desktop