?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r2215: Switch to our own model for details view. Much faster.
[rox-filer.git] / ROX-Filer / src / view_details.c
bloba4691429d291450adf1dd68abe6725ab0000b972
1 /*
2 * $Id$
3 *
4 * ROX-Filer, filer for the ROX desktop project
5 * Copyright (C) 2002, 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
28 #include "global.h"
29
30 #include "view_iface.h"
31 #include "view_details.h"
32 #include "diritem.h"
33 #include "support.h"
34 #include "type.h"
35 #include "filer.h"
36 #include "display.h"
37 #include "pixmaps.h"
38 #include "dnd.h"
39 #include "bind.h"
40 #include "gui_support.h"
41 #include "menu.h"
42
43 /* These are the column numbers in the ListStore */
44 #define COL_LEAF 0
45 #define COL_TYPE 1
46 #define COL_PERM 2
47 #define COL_OWNER 3
48 #define COL_GROUP 4
49 #define COL_SIZE 5
50 #define COL_MTIME 6
51 #define COL_ITEM 7
52 #define COL_COLOUR 8
53 #define COL_ICON 9
54 #define N_COLUMNS 10
55
56 static gpointer parent_class = NULL;
57
58 struct _ViewDetailsClass {
59 GtkTreeViewClass parent;
60 };
61
62 typedef struct _ViewItem ViewItem;
63
64 struct _ViewItem {
65 DirItem *item;
66 GdkPixbuf *image;
67 int old_pos; /* Used while sorting */
68 };
69
70 typedef struct _ViewDetails ViewDetails;
71
72 struct _ViewDetails {
73 GtkTreeView treeview;
74
75 FilerWindow *filer_window; /* Used for styles, etc */
76
77 GPtrArray *items; /* ViewItem */
78
79 gint sort_column_id;
80 GtkSortType order;
81 int (*sort_fn)(const void *, const void *);
82 };
83
84 /* Static prototypes */
85 static void view_details_finialize(GObject *object);
86 static void view_details_class_init(gpointer gclass, gpointer data);
87 static void view_details_init(GTypeInstance *object, gpointer gclass);
88
89 static void view_details_iface_init(gpointer giface, gpointer iface_data);
90
91 static void view_details_sort(ViewIface *view);
92 static void view_details_style_changed(ViewIface *view, int flags);
93 static gboolean view_details_autoselect(ViewIface *view, const gchar *leaf);
94 static void view_details_add_items(ViewIface *view, GPtrArray *items);
95 static void view_details_update_items(ViewIface *view, GPtrArray *items);
96 static void view_details_delete_if(ViewIface *view,
97 gboolean (*test)(gpointer item, gpointer data),
98 gpointer data);
99 static void view_details_clear(ViewIface *view);
100 static void view_details_select_all(ViewIface *view);
101 static void view_details_clear_selection(ViewIface *view);
102 static int view_details_count_items(ViewIface *view);
103 static int view_details_count_selected(ViewIface *view);
104 static void view_details_show_cursor(ViewIface *view);
105 static void view_details_get_iter(ViewIface *view,
106 ViewIter *iter, IterFlags flags);
107 static void view_details_cursor_to_iter(ViewIface *view, ViewIter *iter);
108 static void view_details_set_selected(ViewIface *view,
109 ViewIter *iter,
110 gboolean selected);
111 static gboolean view_details_get_selected(ViewIface *view, ViewIter *iter);
112 static void view_details_select_only(ViewIface *view, ViewIter *iter);
113 static void view_details_set_frozen(ViewIface *view, gboolean frozen);
114 static void view_details_wink_item(ViewIface *view, ViewIter *iter);
115 static void view_details_autosize(ViewIface *view);
116 static gboolean view_details_cursor_visible(ViewIface *view);
117 static void view_details_set_base(ViewIface *view, ViewIter *iter);
118 #if 0
119 static DirItem *iter_peek(ViewIter *iter);
120 static DirItem *iter_next(ViewIter *iter);
121 #endif
122 static void make_iter(ViewDetails *view_details, ViewIter *iter,
123 IterFlags flags);
124 static void make_item_iter(ViewDetails *view_details,
125 ViewIter *v_iter,
126 GtkTreeIter *t_iter);
127 static void view_details_tree_model_init(GtkTreeModelIface *iface);
128 static gboolean details_get_sort_column_id(GtkTreeSortable *sortable,
129 gint *sort_column_id,
130 GtkSortType *order);
131 static void details_set_sort_column_id(GtkTreeSortable *sortable,
132 gint sort_column_id,
133 GtkSortType order);
134 static void details_set_sort_func(GtkTreeSortable *sortable,
135 gint sort_column_id,
136 GtkTreeIterCompareFunc func,
137 gpointer data,
138 GtkDestroyNotify destroy);
139 static void details_set_default_sort_func(GtkTreeSortable *sortable,
140 GtkTreeIterCompareFunc func,
141 gpointer data,
142 GtkDestroyNotify destroy);
143 static gboolean details_has_default_sort_func(GtkTreeSortable *sortable);
144 static void view_details_sortable_init(GtkTreeSortableIface *iface);
145
146
147 /****************************************************************
148 * EXTERNAL INTERFACE *
149 ****************************************************************/
150
151 GtkWidget *view_details_new(FilerWindow *filer_window)
152 {
153 ViewDetails *view_details;
154
155 view_details = g_object_new(view_details_get_type(), NULL);
156 view_details->filer_window = filer_window;
157
158 gtk_range_set_adjustment(GTK_RANGE(filer_window->scrollbar),
159 gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(view_details)));
160
161 return GTK_WIDGET(view_details);
162 }
163
164 GType view_details_get_type(void)
165 {
166 static GType type = 0;
167
168 if (!type)
169 {
170 static const GTypeInfo info =
171 {
172 sizeof (ViewDetailsClass),
173 NULL, /* base_init */
174 NULL, /* base_finalise */
175 view_details_class_init,
176 NULL, /* class_finalise */
177 NULL, /* class_data */
178 sizeof(ViewDetails),
179 0, /* n_preallocs */
180 view_details_init
181 };
182 static const GInterfaceInfo view_iface_info = {
183 view_details_iface_init,
184 NULL, NULL
185 };
186 static const GInterfaceInfo tree_model_info = {
187 (GInterfaceInitFunc) view_details_tree_model_init,
188 NULL, NULL
189 };
190 static const GInterfaceInfo sortable_info = {
191 (GInterfaceInitFunc) view_details_sortable_init,
192 NULL, NULL
193 };
194
195
196 type = g_type_register_static(gtk_tree_view_get_type(),
197 "ViewDetails", &info, 0);
198
199 g_type_add_interface_static(type, VIEW_TYPE_IFACE,
200 &view_iface_info);
201 g_type_add_interface_static(type, GTK_TYPE_TREE_MODEL,
202 &tree_model_info);
203 g_type_add_interface_static(type, GTK_TYPE_TREE_SORTABLE,
204 &sortable_info);
205 }
206
207 return type;
208 }
209
210 /****************************************************************
211 * INTERNAL FUNCTIONS *
212 ****************************************************************/
213
214 /* Fulfill the GtkTreeModel requirements */
215 static guint details_get_flags(GtkTreeModel *tree_model)
216 {
217 return GTK_TREE_MODEL_LIST_ONLY;
218 }
219
220 static gint details_get_n_columns(GtkTreeModel *tree_model)
221 {
222 return N_COLUMNS;
223 }
224
225 static GType details_get_column_type(GtkTreeModel *tree_model, gint index)
226 {
227 g_return_val_if_fail(index < N_COLUMNS && index >= 0, G_TYPE_INVALID);
228
229 if (index == COL_COLOUR)
230 return GDK_TYPE_COLOR;
231 else if (index == COL_ITEM)
232 return G_TYPE_POINTER;
233 else if (index == COL_ICON)
234 return GDK_TYPE_PIXBUF;
235 return G_TYPE_STRING;
236 }
237
238 static gboolean details_get_iter(GtkTreeModel *tree_model,
239 GtkTreeIter *iter,
240 GtkTreePath *path)
241 {
242 ViewDetails *view_details = (ViewDetails *) tree_model;
243 gint i;
244
245 g_return_val_if_fail(gtk_tree_path_get_depth (path) > 0, FALSE);
246
247 i = gtk_tree_path_get_indices(path)[0];
248
249 if (i >= view_details->items->len)
250 return FALSE;
251
252 iter->user_data = GINT_TO_POINTER(i);
253
254 return TRUE;
255 }
256
257 static GtkTreePath *details_get_path(GtkTreeModel *tree_model,
258 GtkTreeIter *iter)
259 {
260 GtkTreePath *retval;
261
262 retval = gtk_tree_path_new();
263 gtk_tree_path_append_index(retval, GPOINTER_TO_INT(iter->user_data));
264
265 return retval;
266 }
267
268 static void details_get_value(GtkTreeModel *tree_model,
269 GtkTreeIter *iter,
270 gint column,
271 GValue *value)
272 {
273 ViewDetails *view_details = (ViewDetails *) tree_model;
274 gint i;
275 GPtrArray *items = view_details->items;
276 DirItem *item;
277 mode_t m;
278
279 g_return_if_fail(column >= 0 && column < N_COLUMNS);
280
281 i = GPOINTER_TO_INT(iter->user_data);
282 g_return_if_fail(i >= 0 && i < items->len);
283 item = ((ViewItem *) items->pdata[i])->item;
284
285 /* g_print("[ get %d ]\n", column); */
286
287 if (column == COL_LEAF)
288 {
289 g_value_init(value, G_TYPE_STRING);
290 g_value_set_string(value, item->leafname);
291 return;
292 }
293 else if (column == COL_ITEM)
294 {
295 g_value_init(value, G_TYPE_POINTER);
296 g_value_set_pointer(value, item);
297 return;
298 }
299
300 if (item->base_type == TYPE_UNKNOWN)
301 {
302 GType type;
303 type = details_get_column_type(tree_model, column);
304 g_value_init(value, type);
305 if (type == G_TYPE_STRING)
306 g_value_set_string(value, "");
307 else if (type == GDK_TYPE_COLOR)
308 g_value_set_boxed(value, NULL);
309 else
310 g_value_set_object(value, NULL);
311
312 return;
313 }
314 m = item->mode;
315
316 switch (column)
317 {
318 case COL_LEAF:
319 g_value_init(value, G_TYPE_STRING);
320 g_value_set_string(value, item->leafname);
321 break;
322 case COL_ICON:
323 g_value_init(value, GDK_TYPE_PIXBUF);
324 if (!item->image->sm_pixbuf)
325 pixmap_make_small(item->image);
326 g_value_set_object(value, item->image->sm_pixbuf);
327 break;
328 case COL_COLOUR:
329 g_value_init(value, GDK_TYPE_COLOR);
330 g_value_set_boxed(value, type_get_colour(item, NULL));
331 break;
332 case COL_OWNER:
333 g_value_init(value, G_TYPE_STRING);
334 g_value_set_string(value, user_name(item->uid));
335 break;
336 case COL_GROUP:
337 g_value_init(value, G_TYPE_STRING);
338 g_value_set_string(value, group_name(item->gid));
339 break;
340 case COL_MTIME:
341 {
342 gchar *time;
343 time = pretty_time(&item->mtime);
344 g_value_init(value, G_TYPE_STRING);
345 g_value_set_string(value, time);
346 g_free(time);
347 break;
348 }
349 case COL_PERM:
350 g_value_init(value, G_TYPE_STRING);
351 g_value_set_string(value, pretty_permissions(m));
352 break;
353 case COL_SIZE:
354 g_value_init(value, G_TYPE_STRING);
355 if (item->base_type != TYPE_DIRECTORY)
356 g_value_set_string(value,
357 format_size(item->size));
358 break;
359 case COL_TYPE:
360 g_value_init(value, G_TYPE_STRING);
361 g_value_set_string(value,
362 item->flags & ITEM_FLAG_APPDIR? "App" :
363 S_ISDIR(m) ? "Dir" :
364 S_ISCHR(m) ? "Char" :
365 S_ISBLK(m) ? "Blck" :
366 S_ISLNK(m) ? "Link" :
367 S_ISSOCK(m) ? "Sock" :
368 S_ISFIFO(m) ? "Pipe" :
369 S_ISDOOR(m) ? "Door" :
370 "File");
371 break;
372 default:
373 g_value_init(value, G_TYPE_STRING);
374 g_value_set_string(value, "Hello");
375 break;
376 }
377 }
378
379 static gboolean details_iter_next(GtkTreeModel *tree_model, GtkTreeIter *iter)
380 {
381 ViewDetails *view_details = (ViewDetails *) tree_model;
382 int i;
383
384 i = GPOINTER_TO_INT(iter->user_data) + 1;
385 iter->user_data = GINT_TO_POINTER(i);
386
387 return i < view_details->items->len;
388 }
389
390 static gboolean details_iter_children(GtkTreeModel *tree_model,
391 GtkTreeIter *iter,
392 GtkTreeIter *parent)
393 {
394 ViewDetails *view_details = (ViewDetails *) tree_model;
395
396 /* this is a list, nodes have no children */
397 if (parent)
398 return FALSE;
399
400 /* but if parent == NULL we return the list itself as children of the
401 * "root"
402 */
403
404 if (view_details->items->len)
405 {
406 iter->user_data = GINT_TO_POINTER(0);
407 return TRUE;
408 }
409 else
410 return FALSE;
411 }
412
413 static gboolean details_iter_has_child(GtkTreeModel *tree_model,
414 GtkTreeIter *iter)
415 {
416 return FALSE;
417 }
418
419 static gint details_iter_n_children(GtkTreeModel *tree_model, GtkTreeIter *iter)
420 {
421 ViewDetails *view_details = (ViewDetails *) tree_model;
422
423 if (iter == NULL)
424 return view_details->items->len;
425
426 return 0;
427 }
428
429 static gboolean details_iter_nth_child(GtkTreeModel *tree_model,
430 GtkTreeIter *iter,
431 GtkTreeIter *parent,
432 gint n)
433 {
434 ViewDetails *view_details = (ViewDetails *) tree_model;
435
436 if (parent)
437 return FALSE;
438
439 if (n >= 0 && n < view_details->items->len)
440 {
441 iter->user_data = GINT_TO_POINTER(n);
442 return TRUE;
443 }
444 else
445 return FALSE;
446 }
447
448 static gboolean details_iter_parent(GtkTreeModel *tree_model,
449 GtkTreeIter *iter,
450 GtkTreeIter *child)
451 {
452 return FALSE;
453 }
454
455 /* A ViewDetails is both a GtkTreeView and a GtkTreeModel.
456 * The following functions implement the model interface...
457 */
458
459 static void view_details_tree_model_init(GtkTreeModelIface *iface)
460 {
461 iface->get_flags = details_get_flags;
462 iface->get_n_columns = details_get_n_columns;
463 iface->get_column_type = details_get_column_type;
464 iface->get_iter = details_get_iter;
465 iface->get_path = details_get_path;
466 iface->get_value = details_get_value;
467 iface->iter_next = details_iter_next;
468 iface->iter_children = details_iter_children;
469 iface->iter_has_child = details_iter_has_child;
470 iface->iter_n_children = details_iter_n_children;
471 iface->iter_nth_child = details_iter_nth_child;
472 iface->iter_parent = details_iter_parent;
473 }
474
475 static void view_details_sortable_init(GtkTreeSortableIface *iface)
476 {
477 iface->get_sort_column_id = details_get_sort_column_id;
478 iface->set_sort_column_id = details_set_sort_column_id;
479 iface->set_sort_func = details_set_sort_func;
480 iface->set_default_sort_func = details_set_default_sort_func;
481 iface->has_default_sort_func = details_has_default_sort_func;
482 }
483
484 static gboolean details_get_sort_column_id(GtkTreeSortable *sortable,
485 gint *sort_column_id,
486 GtkSortType *order)
487 {
488 ViewDetails *view_details = (ViewDetails *) sortable;
489
490 if (view_details->sort_column_id == -1)
491 return FALSE;
492
493 if (sort_column_id)
494 *sort_column_id = view_details->sort_column_id;
495 if (order)
496 *order = view_details->order;
497 return TRUE;
498 }
499
500 static void details_set_sort_column_id(GtkTreeSortable *sortable,
501 gint sort_column_id,
502 GtkSortType order)
503 {
504 ViewDetails *view_details = (ViewDetails *) sortable;
505
506 if (view_details->sort_column_id == sort_column_id &&
507 view_details->order == order)
508 return;
509
510 view_details->sort_column_id = sort_column_id;
511 view_details->order = order;
512
513 switch (sort_column_id)
514 {
515 case COL_LEAF:
516 view_details->sort_fn = sort_by_name;
517 break;
518 case COL_SIZE:
519 view_details->sort_fn = sort_by_size;
520 break;
521 case COL_MTIME:
522 view_details->sort_fn = sort_by_date;
523 break;
524 case COL_TYPE:
525 view_details->sort_fn = sort_by_type;
526 break;
527 case COL_OWNER:
528 view_details->sort_fn = sort_by_owner;
529 break;
530 case COL_GROUP:
531 view_details->sort_fn = sort_by_group;
532 break;
533 default:
534 g_assert_not_reached();
535 }
536
537 view_details_sort((ViewIface *) view_details);
538
539 gtk_tree_sortable_sort_column_changed(sortable);
540 }
541
542 static void details_set_sort_func(GtkTreeSortable *sortable,
543 gint sort_column_id,
544 GtkTreeIterCompareFunc func,
545 gpointer data,
546 GtkDestroyNotify destroy)
547 {
548 g_assert_not_reached();
549 }
550
551 static void details_set_default_sort_func(GtkTreeSortable *sortable,
552 GtkTreeIterCompareFunc func,
553 gpointer data,
554 GtkDestroyNotify destroy)
555 {
556 g_assert_not_reached();
557 }
558
559 static gboolean details_has_default_sort_func(GtkTreeSortable *sortable)
560 {
561 return FALSE;
562 }
563
564
565 /* End of model implementation */
566
567 static void toggle_selected(GtkTreeSelection *selection, GtkTreeIter *iter)
568 {
569 if (gtk_tree_selection_iter_is_selected(selection, iter))
570 gtk_tree_selection_unselect_iter(selection, iter);
571 else
572 gtk_tree_selection_select_iter(selection, iter);
573 }
574
575 static void perform_action(ViewDetails *view_details, GdkEventButton *event)
576 {
577 BindAction action;
578 FilerWindow *filer_window = view_details->filer_window;
579 DirItem *item = NULL;
580 GtkTreeView *tree = (GtkTreeView *) view_details;
581 GtkTreePath *path = NULL;
582 GtkTreeIter iter;
583 GtkTreeModel *model;
584 GtkTreeSelection *selection;
585 /* OpenFlags flags = 0; */
586
587 model = gtk_tree_view_get_model(tree);
588 selection = gtk_tree_view_get_selection(tree);
589
590 if (gtk_tree_view_get_path_at_pos(tree, event->x, event->y,
591 &path, NULL, NULL, NULL))
592 {
593 g_return_if_fail(path != NULL);
594
595 gtk_tree_model_get_iter(model, &iter, path);
596
597 gtk_tree_model_get(model, &iter, COL_ITEM, &item, -1);
598 }
599
600 /* TODO: Cancel slow DnD */
601 /* TODO: Target callbacks */
602
603 action = bind_lookup_bev(
604 item ? BIND_DIRECTORY_ICON : BIND_DIRECTORY,
605 event);
606
607 switch (action)
608 {
609 case ACT_CLEAR_SELECTION:
610 gtk_tree_selection_unselect_all(selection);
611 break;
612 case ACT_TOGGLE_SELECTED:
613 toggle_selected(selection, &iter);
614 break;
615 #if 0
616 case ACT_SELECT_EXCL:
617 collection_clear_except(collection, item);
618 break;
619 case ACT_EDIT_ITEM:
620 flags |= OPEN_SHIFT;
621 /* (no break) */
622 case ACT_OPEN_ITEM:
623 {
624 ViewIter viter;
625
626 make_item_iter(view_details, &viter, &iter);
627
628 if (event->button != 1 || event->state & GDK_MOD1_MASK)
629 flags |= OPEN_CLOSE_WINDOW;
630 else
631 flags |= OPEN_SAME_WINDOW;
632 if (o_new_button_1.int_value)
633 flags ^= OPEN_SAME_WINDOW;
634 /* TODO */
635 if (event->type == GDK_2BUTTON_PRESS)
636 collection_unselect_item(collection, item);
637 dnd_motion_ungrab();
638
639 filer_openitem(filer_window, &viter, flags);
640 break;
641 }
642 #endif
643 case ACT_POPUP_MENU:
644 {
645 ViewIter viter;
646
647 dnd_motion_ungrab();
648 tooltip_show(NULL);
649
650 make_item_iter(view_details, &viter, &iter);
651 show_filer_menu(filer_window,
652 (GdkEvent *) event, &viter);
653 break;
654 }
655 #if 0
656 case ACT_PRIME_AND_SELECT:
657 if (!selected)
658 collection_clear_except(collection, item);
659 dnd_motion_start(MOTION_READY_FOR_DND);
660 break;
661 case ACT_PRIME_AND_TOGGLE:
662 collection_toggle_item(collection, item);
663 dnd_motion_start(MOTION_READY_FOR_DND);
664 break;
665 case ACT_PRIME_FOR_DND:
666 dnd_motion_start(MOTION_READY_FOR_DND);
667 break;
668 case ACT_IGNORE:
669 if (press && event->button < 4)
670 {
671 if (item)
672 collection_wink_item(collection, item);
673 dnd_motion_start(MOTION_NONE);
674 }
675 break;
676 case ACT_LASSO_CLEAR:
677 collection_clear_selection(collection);
678 /* (no break) */
679 case ACT_LASSO_MODIFY:
680 collection_lasso_box(collection, event->x, event->y);
681 break;
682 case ACT_RESIZE:
683 filer_window_autosize(filer_window);
684 break;
685 #endif
686 default:
687 g_warning("Unsupported action : %d\n", action);
688 break;
689 }
690 }
691
692 static gboolean view_details_button_press(GtkWidget *widget,
693 GdkEventButton *bev)
694 {
695 if (dnd_motion_press(widget, bev))
696 perform_action((ViewDetails *) widget, bev);
697
698 return TRUE;
699 }
700
701 static gboolean view_details_button_release(GtkWidget *widget,
702 GdkEventButton *bev)
703 {
704 if (!dnd_motion_release(bev))
705 perform_action((ViewDetails *) widget, bev);
706
707 return TRUE;
708 }
709
710 static void view_details_destroy(GtkObject *view_details)
711 {
712 VIEW_DETAILS(view_details)->filer_window = NULL;
713 }
714
715 static void view_details_finialize(GObject *object)
716 {
717 ViewDetails *view_details = (ViewDetails *) object;
718
719 g_ptr_array_free(view_details->items, TRUE);
720 view_details->items = NULL;
721
722 G_OBJECT_CLASS(parent_class)->finalize(object);
723 }
724
725 static void view_details_class_init(gpointer gclass, gpointer data)
726 {
727 GObjectClass *object = (GObjectClass *) gclass;
728 GtkWidgetClass *widget = (GtkWidgetClass *) gclass;
729
730 parent_class = g_type_class_peek_parent(gclass);
731
732 object->finalize = view_details_finialize;
733 GTK_OBJECT_CLASS(object)->destroy = view_details_destroy;
734
735 widget->button_press_event = view_details_button_press;
736 widget->button_release_event = view_details_button_release;
737 }
738
739 static void view_details_init(GTypeInstance *object, gpointer gclass)
740 {
741 GtkTreeView *treeview = (GtkTreeView *) object;
742 GtkTreeViewColumn *column;
743 GtkCellRenderer *cell;
744 GtkTreeSortable *sortable_list;
745 ViewDetails *view_details = (ViewDetails *) object;
746
747 view_details->items = g_ptr_array_new();
748
749 /* Sorting */
750 view_details->sort_column_id = -1;
751 view_details->sort_fn = NULL;
752 sortable_list = GTK_TREE_SORTABLE(object);
753 gtk_tree_sortable_set_sort_column_id(sortable_list, COL_LEAF,
754 GTK_SORT_ASCENDING);
755
756 gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(view_details));
757
758 /* Icon */
759 cell = gtk_cell_renderer_pixbuf_new();
760 column = gtk_tree_view_column_new_with_attributes(NULL, cell,
761 "pixbuf", COL_ICON, NULL);
762 gtk_tree_view_append_column(treeview, column);
763
764 /* The rest are text... */
765 cell = gtk_cell_renderer_text_new();
766
767 /* Name */
768 column = gtk_tree_view_column_new_with_attributes(_("Name"), cell,
769 "text", COL_LEAF,
770 "foreground-gdk", COL_COLOUR, NULL);
771 gtk_tree_view_append_column(treeview, column);
772 gtk_tree_view_column_set_sort_column_id(column, COL_LEAF);
773
774 /* Type */
775 column = gtk_tree_view_column_new_with_attributes(_("Type"), cell,
776 "text", COL_TYPE, NULL);
777 gtk_tree_view_append_column(treeview, column);
778 gtk_tree_view_column_set_sort_column_id(column, COL_TYPE);
779
780 /* Perm */
781 column = gtk_tree_view_column_new_with_attributes(_("Permissions"),
782 cell, "text", COL_PERM, NULL);
783 gtk_tree_view_append_column(treeview, column);
784
785 /* Owner */
786 column = gtk_tree_view_column_new_with_attributes(_("Owner"), cell,
787 "text", COL_OWNER, NULL);
788 gtk_tree_view_append_column(treeview, column);
789 gtk_tree_view_column_set_sort_column_id(column, COL_OWNER);
790
791 /* Group */
792 column = gtk_tree_view_column_new_with_attributes(_("Group"), cell,
793 "text", COL_GROUP, NULL);
794 gtk_tree_view_append_column(treeview, column);
795 gtk_tree_view_column_set_sort_column_id(column, COL_GROUP);
796
797 /* Size */
798 column = gtk_tree_view_column_new_with_attributes(_("Size"), cell,
799 "text", COL_SIZE, NULL);
800 gtk_tree_view_append_column(treeview, column);
801 gtk_tree_view_column_set_sort_column_id(column, COL_SIZE);
802
803 /* MTime */
804 column = gtk_tree_view_column_new_with_attributes(_("M-Time"), cell,
805 "text", COL_MTIME, NULL);
806 gtk_tree_view_append_column(treeview, column);
807 gtk_tree_view_column_set_sort_column_id(column, COL_MTIME);
808
809 gtk_widget_set_size_request(GTK_WIDGET(treeview), -1, 50);
810 }
811
812 /* Create the handers for the View interface */
813 static void view_details_iface_init(gpointer giface, gpointer iface_data)
814 {
815 ViewIfaceClass *iface = giface;
816
817 g_assert(G_TYPE_FROM_INTERFACE(iface) == VIEW_TYPE_IFACE);
818
819 /* override stuff */
820 iface->sort = view_details_sort;
821 iface->style_changed = view_details_style_changed;
822 iface->autoselect = view_details_autoselect;
823 iface->add_items = view_details_add_items;
824 iface->update_items = view_details_update_items;
825 iface->delete_if = view_details_delete_if;
826 iface->clear = view_details_clear;
827 iface->select_all = view_details_select_all;
828 iface->clear_selection = view_details_clear_selection;
829 iface->count_items = view_details_count_items;
830 iface->count_selected = view_details_count_selected;
831 iface->show_cursor = view_details_show_cursor;
832 iface->get_iter = view_details_get_iter;
833 iface->cursor_to_iter = view_details_cursor_to_iter;
834 iface->set_selected = view_details_set_selected;
835 iface->get_selected = view_details_get_selected;
836 iface->set_frozen = view_details_set_frozen;
837 iface->select_only = view_details_select_only;
838 iface->wink_item = view_details_wink_item;
839 iface->autosize = view_details_autosize;
840 iface->cursor_visible = view_details_cursor_visible;
841 iface->set_base = view_details_set_base;
842 }
843
844 /* Implementations of the View interface. See view_iface.c for comments. */
845
846 static void view_details_style_changed(ViewIface *view, int flags)
847 {
848 }
849
850 static gint wrap_sort(gconstpointer a, gconstpointer b,
851 ViewDetails *view_details)
852 {
853 ViewItem *ia = *(ViewItem **) a;
854 ViewItem *ib = *(ViewItem **) b;
855
856 if (view_details->order == GTK_SORT_ASCENDING)
857 return view_details->sort_fn(ia->item, ib->item);
858 else
859 return -view_details->sort_fn(ia->item, ib->item);
860 }
861
862 static void view_details_sort(ViewIface *view)
863 {
864 ViewDetails *view_details = (ViewDetails *) view;
865 ViewItem **items = (ViewItem **) view_details->items->pdata;
866 GArray *new_order;
867 gint i, len = view_details->items->len;
868 GtkTreePath *path;
869
870 g_return_if_fail(view_details->sort_fn != NULL);
871
872 if (!len)
873 return;
874
875 for (i = len - 1; i >= 0; i--)
876 items[i]->old_pos = i;
877
878 g_ptr_array_sort_with_data(view_details->items,
879 (GCompareDataFunc) wrap_sort,
880 view_details);
881
882 new_order = g_array_sized_new(FALSE, FALSE, sizeof(gint), len);
883 g_array_set_size(new_order, len);
884
885 for (i = len - 1; i >= 0; i--)
886 g_array_insert_val(new_order, items[i]->old_pos, i);
887
888 path = gtk_tree_path_new();
889 gtk_tree_model_rows_reordered((GtkTreeModel *) view,
890 path, NULL,
891 (gint *) new_order->data);
892 gtk_tree_path_free(path);
893 g_array_free(new_order, TRUE);
894 }
895
896 static gboolean view_details_autoselect(ViewIface *view, const gchar *leaf)
897 {
898 return FALSE;
899 }
900
901 static void view_details_add_items(ViewIface *view, GPtrArray *new_items)
902 {
903 ViewDetails *view_details = (ViewDetails *) view;
904 FilerWindow *filer_window = view_details->filer_window;
905 gboolean show_hidden = filer_window->show_hidden;
906 GPtrArray *items = view_details->items;
907 GtkTreeIter iter;
908 int i;
909 GtkTreePath *path;
910 GtkTreeModel *model = (GtkTreeModel *) view;
911
912 iter.user_data = GINT_TO_POINTER(items->len);
913 path = details_get_path(model, &iter);
914
915 for (i = 0; i < new_items->len; i++)
916 {
917 DirItem *item = (DirItem *) new_items->pdata[i];
918 char *leafname = item->leafname;
919 ViewItem *vitem;
920
921 if (leafname[0] == '.')
922 {
923 if (!show_hidden)
924 continue;
925
926 if (leafname[1] == '\0')
927 continue; /* Never show '.' */
928
929 if (leafname[1] == '.' &&
930 leafname[2] == '\0')
931 continue; /* Never show '..' */
932 }
933
934 vitem = g_new(ViewItem, 1);
935 vitem->item = item;
936 vitem->image = NULL;
937
938 g_ptr_array_add(items, vitem);
939
940 iter.user_data = GINT_TO_POINTER(items->len - 1);
941 gtk_tree_model_row_inserted(model, path, &iter);
942 gtk_tree_path_next(path);
943 }
944
945 gtk_tree_path_free(path);
946
947 view_details_sort(view);
948 }
949
950 /* Find an item in the sorted array.
951 * Returns the item number, or -1 if not found.
952 */
953 static int details_find_item(ViewDetails *view_details, DirItem *item)
954 {
955 ViewItem **items, tmp, *tmpp;
956 int lower, upper;
957 int (*compar)(const void *, const void *);
958
959 g_return_val_if_fail(view_details != NULL, -1);
960 g_return_val_if_fail(item != NULL, -1);
961
962 tmp.item = item;
963 tmpp = &tmp;
964
965 items = (ViewItem **) view_details->items->pdata;
966 compar = view_details->sort_fn;
967
968 g_return_val_if_fail(compar != NULL, -1);
969
970 /* If item is here, then: lower <= i < upper */
971 lower = 0;
972 upper = view_details->items->len;
973
974 while (lower < upper)
975 {
976 int i, cmp;
977
978 i = (lower + upper) >> 1;
979
980 cmp = wrap_sort(&items[i], &tmpp, view_details);
981 if (cmp == 0)
982 return i;
983
984 if (cmp > 0)
985 upper = i;
986 else
987 lower = i + 1;
988 }
989
990 return -1;
991 }
992
993 static void view_details_update_items(ViewIface *view, GPtrArray *items)
994 {
995 ViewDetails *view_details = (ViewDetails *) view;
996 FilerWindow *filer_window = view_details->filer_window;
997 int i;
998 GtkTreeModel *model = (GtkTreeModel *) view_details;
999
1000 g_return_if_fail(items->len > 0);
1001
1002 /* The item data has already been modified, so this gives the
1003 * final sort order...
1004 */
1005 view_details_sort(view);
1006
1007 for (i = 0; i < items->len; i++)
1008 {
1009 DirItem *item = (DirItem *) items->pdata[i];
1010 const gchar *leafname = item->leafname;
1011 int j;
1012
1013 if (leafname[0] == '.' && filer_window->show_hidden == FALSE)
1014 continue;
1015
1016 j = details_find_item(view_details, item);
1017
1018 if (j < 0)
1019 g_warning("Failed to find '%s'\n", leafname);
1020 else
1021 {
1022 GtkTreePath *path;
1023 GtkTreeIter iter;
1024 path = gtk_tree_path_new();
1025 gtk_tree_path_append_index(path, j);
1026 iter.user_data = GINT_TO_POINTER(j);
1027 gtk_tree_model_row_changed(model, path, &iter);
1028 }
1029 }
1030 }
1031
1032 static void view_details_delete_if(ViewIface *view,
1033 gboolean (*test)(gpointer item, gpointer data),
1034 gpointer data)
1035 {
1036 }
1037
1038 static void view_details_clear(ViewIface *view)
1039 {
1040 GtkTreePath *path;
1041 GPtrArray *items = ((ViewDetails *) view)->items;
1042 GtkTreeModel *model = (GtkTreeModel *) view;
1043
1044 path = gtk_tree_path_new();
1045 gtk_tree_path_append_index(path, items->len);
1046
1047 while (gtk_tree_path_prev(path))
1048 gtk_tree_model_row_deleted(model, path);
1049
1050 g_ptr_array_set_size(items, 0);
1051 gtk_tree_path_free(path);
1052 }
1053
1054 static void view_details_select_all(ViewIface *view)
1055 {
1056 }
1057
1058 static void view_details_clear_selection(ViewIface *view)
1059 {
1060 }
1061
1062 static int view_details_count_items(ViewIface *view)
1063 {
1064 return 0;
1065 }
1066
1067 static int view_details_count_selected(ViewIface *view)
1068 {
1069 return 0;
1070 }
1071
1072 static void view_details_show_cursor(ViewIface *view)
1073 {
1074 }
1075
1076 static void view_details_get_iter(ViewIface *view,
1077 ViewIter *iter, IterFlags flags)
1078 {
1079 make_iter((ViewDetails *) view, iter, flags);
1080 }
1081
1082 static void view_details_cursor_to_iter(ViewIface *view, ViewIter *iter)
1083 {
1084 }
1085
1086 static void view_details_set_selected(ViewIface *view,
1087 ViewIter *iter,
1088 gboolean selected)
1089 {
1090 }
1091
1092 static gboolean view_details_get_selected(ViewIface *view, ViewIter *iter)
1093 {
1094 return FALSE;
1095 }
1096
1097 static void view_details_select_only(ViewIface *view, ViewIter *iter)
1098 {
1099 }
1100
1101 static void view_details_set_frozen(ViewIface *view, gboolean frozen)
1102 {
1103 }
1104
1105 static void view_details_wink_item(ViewIface *view, ViewIter *iter)
1106 {
1107 }
1108
1109 static void view_details_autosize(ViewIface *view)
1110 {
1111 }
1112
1113 static gboolean view_details_cursor_visible(ViewIface *view)
1114 {
1115 return FALSE;
1116 }
1117
1118 static void view_details_set_base(ViewIface *view, ViewIter *iter)
1119 {
1120 }
1121
1122 static DirItem *iter_init(ViewIter *iter)
1123 {
1124 return NULL;
1125 }
1126
1127 #if 0
1128 static DirItem *iter_peek(ViewIter *iter)
1129 {
1130 return NULL;
1131 }
1132
1133 static DirItem *iter_next(ViewIter *iter)
1134 {
1135 return NULL;
1136 }
1137 #endif
1138
1139 /* Set the iterator to return 'i' on the next peek() */
1140 static void make_item_iter(ViewDetails *view_details,
1141 ViewIter *iter,
1142 GtkTreeIter *t_iter)
1143 {
1144 make_iter(view_details, iter, 0);
1145
1146 iter->next = iter_init;
1147 iter->peek = iter_init;
1148 iter->n_remaining = 0;
1149 }
1150
1151 static void make_iter(ViewDetails *view_details, ViewIter *iter,
1152 IterFlags flags)
1153 {
1154 /* iter->view_details = view_details; */
1155 iter->next = iter_init;
1156 iter->peek = NULL;
1157
1158 iter->flags = flags;
1159 }
Filer for the ROX desktop