?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r3768: Updated years.
[rox-filer.git] / ROX-Filer / src / view_details.c
blobb2efcb612a0296a5a4521e338797fc497576b164
1 /*
2 * $Id$
3 *
4 * ROX-Filer, filer for the ROX desktop project
5 * Copyright (C) 2005, 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_WEIGHT 9
58 #define COL_VIEW_ITEM 10
59 #define N_COLUMNS 11
60
61 static gpointer parent_class = NULL;
62
63 struct _ViewDetailsClass {
64 GtkTreeViewClass parent;
65 };
66
67 /* Static prototypes */
68 static void view_details_finialize(GObject *object);
69 static void view_details_class_init(gpointer gclass, gpointer data);
70 static void view_details_init(GTypeInstance *object, gpointer gclass);
71
72 static void view_details_iface_init(gpointer giface, gpointer iface_data);
73
74 static void view_details_sort(ViewIface *view);
75 static void view_details_style_changed(ViewIface *view, int flags);
76 static void view_details_add_items(ViewIface *view, GPtrArray *items);
77 static void view_details_update_items(ViewIface *view, GPtrArray *items);
78 static void view_details_delete_if(ViewIface *view,
79 gboolean (*test)(gpointer item, gpointer data),
80 gpointer data);
81 static void view_details_clear(ViewIface *view);
82 static void view_details_select_all(ViewIface *view);
83 static void view_details_clear_selection(ViewIface *view);
84 static int view_details_count_items(ViewIface *view);
85 static int view_details_count_selected(ViewIface *view);
86 static void view_details_show_cursor(ViewIface *view);
87 static void view_details_get_iter(ViewIface *view,
88 ViewIter *iter, IterFlags flags);
89 static void view_details_get_iter_at_point(ViewIface *view, ViewIter *iter,
90 GdkWindow *src, int x, int y);
91 static void view_details_cursor_to_iter(ViewIface *view, ViewIter *iter);
92 static void view_details_set_selected(ViewIface *view,
93 ViewIter *iter,
94 gboolean selected);
95 static gboolean view_details_get_selected(ViewIface *view, ViewIter *iter);
96 static void view_details_select_only(ViewIface *view, ViewIter *iter);
97 static void view_details_set_frozen(ViewIface *view, gboolean frozen);
98 static void view_details_wink_item(ViewIface *view, ViewIter *iter);
99 static void view_details_autosize(ViewIface *view);
100 static gboolean view_details_cursor_visible(ViewIface *view);
101 static void view_details_set_base(ViewIface *view, ViewIter *iter);
102 static void view_details_start_lasso_box(ViewIface *view,
103 GdkEventButton *event);
104 static void view_details_extend_tip(ViewIface *view,
105 ViewIter *iter, GString *tip);
106 static gboolean view_details_auto_scroll_callback(ViewIface *view);
107
108 static DirItem *iter_peek(ViewIter *iter);
109 static DirItem *iter_prev(ViewIter *iter);
110 static DirItem *iter_next(ViewIter *iter);
111 static void make_iter(ViewDetails *view_details, ViewIter *iter,
112 IterFlags flags);
113 static void make_item_iter(ViewDetails *view_details, ViewIter *iter, int i);
114 static void view_details_tree_model_init(GtkTreeModelIface *iface);
115 static gboolean details_get_sort_column_id(GtkTreeSortable *sortable,
116 gint *sort_column_id,
117 GtkSortType *order);
118 static void details_set_sort_column_id(GtkTreeSortable *sortable,
119 gint sort_column_id,
120 GtkSortType order);
121 static void details_set_sort_func(GtkTreeSortable *sortable,
122 gint sort_column_id,
123 GtkTreeIterCompareFunc func,
124 gpointer data,
125 GtkDestroyNotify destroy);
126 static void details_set_default_sort_func(GtkTreeSortable *sortable,
127 GtkTreeIterCompareFunc func,
128 gpointer data,
129 GtkDestroyNotify destroy);
130 static gboolean details_has_default_sort_func(GtkTreeSortable *sortable);
131 static void view_details_sortable_init(GtkTreeSortableIface *iface);
132 static void set_selected(ViewDetails *view_details, int i, gboolean selected);
133 static gboolean get_selected(ViewDetails *view_details, int i);
134 static void free_view_item(ViewItem *view_item);
135 static void details_update_header_visibility(ViewDetails *view_details);
136 static void set_lasso(ViewDetails *view_details, int x, int y);
137 static void cancel_wink(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)
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 gint i;
280 GPtrArray *items = view_details->items;
281 ViewItem *view_item;
282 DirItem *item;
283 mode_t m;
284
285 g_return_if_fail(column >= 0 && column < N_COLUMNS);
286
287 i = GPOINTER_TO_INT(iter->user_data);
288 g_return_if_fail(i >= 0 && i < items->len);
289 view_item = (ViewItem *) items->pdata[i];
290 item = view_item->item;
291
292 if (column == COL_LEAF)
293 {
294 g_value_init(value, G_TYPE_STRING);
295 g_value_set_string(value,
296 view_item->utf8_name ? view_item->utf8_name
297 : item->leafname);
298 return;
299 }
300 else if (column == COL_VIEW_ITEM)
301 {
302 g_value_init(value, G_TYPE_POINTER);
303 g_value_set_pointer(value, view_item);
304 return;
305 }
306 else if (column == COL_ITEM)
307 {
308 g_value_init(value, G_TYPE_POINTER);
309 g_value_set_pointer(value, item);
310 return;
311 }
312
313 if (item->base_type == TYPE_UNKNOWN)
314 {
315 GType type;
316 type = details_get_column_type(tree_model, column);
317 g_value_init(value, type);
318 if (type == G_TYPE_STRING)
319 g_value_set_string(value, "");
320 else if (type == GDK_TYPE_COLOR)
321 g_value_set_boxed(value, NULL);
322 else if (type == G_TYPE_INT)
323 g_value_set_int(value, PANGO_WEIGHT_NORMAL);
324 else
325 g_value_set_object(value, NULL);
326
327 return;
328 }
329 m = item->mode;
330
331 switch (column)
332 {
333 case COL_LEAF:
334 g_value_init(value, G_TYPE_STRING);
335 g_value_set_string(value, item->leafname);
336 break;
337 case COL_COLOUR:
338 g_value_init(value, GDK_TYPE_COLOR);
339 if (view_item->utf8_name)
340 {
341 GdkColor red;
342 red.red = 0xffff;
343 red.green = 0;
344 red.blue = 0;
345 g_value_set_boxed(value, &red);
346 }
347 else
348 g_value_set_boxed(value,
349 type_get_colour(item, NULL));
350 break;
351 case COL_OWNER:
352 g_value_init(value, G_TYPE_STRING);
353 g_value_set_string(value, user_name(item->uid));
354 break;
355 case COL_GROUP:
356 g_value_init(value, G_TYPE_STRING);
357 g_value_set_string(value, group_name(item->gid));
358 break;
359 case COL_MTIME:
360 {
361 gchar *time;
362 time = pretty_time(&item->mtime);
363 g_value_init(value, G_TYPE_STRING);
364 g_value_set_string(value, time);
365 g_free(time);
366 break;
367 }
368 case COL_PERM:
369 g_value_init(value, G_TYPE_STRING);
370 g_value_set_string(value, pretty_permissions(m));
371 break;
372 case COL_SIZE:
373 g_value_init(value, G_TYPE_STRING);
374 if (item->base_type != TYPE_DIRECTORY)
375 g_value_set_string(value,
376 format_size(item->size));
377 break;
378 case COL_TYPE:
379 g_value_init(value, G_TYPE_STRING);
380 g_value_set_string(value,
381 item->flags & ITEM_FLAG_APPDIR? "App" :
382 S_ISDIR(m) ? "Dir" :
383 S_ISCHR(m) ? "Char" :
384 S_ISBLK(m) ? "Blck" :
385 S_ISLNK(m) ? "Link" :
386 S_ISSOCK(m) ? "Sock" :
387 S_ISFIFO(m) ? "Pipe" :
388 S_ISDOOR(m) ? "Door" :
389 "File");
390 break;
391 case COL_WEIGHT:
392 g_value_init(value, G_TYPE_INT);
393 if (item->flags & ITEM_FLAG_RECENT)
394 g_value_set_int(value, PANGO_WEIGHT_BOLD);
395 else
396 g_value_set_int(value, PANGO_WEIGHT_NORMAL);
397 break;
398 default:
399 g_value_init(value, G_TYPE_STRING);
400 g_value_set_string(value, "Hello");
401 break;
402 }
403 }
404
405 static gboolean details_iter_next(GtkTreeModel *tree_model, GtkTreeIter *iter)
406 {
407 ViewDetails *view_details = (ViewDetails *) tree_model;
408 int i;
409
410 i = GPOINTER_TO_INT(iter->user_data) + 1;
411 iter->user_data = GINT_TO_POINTER(i);
412
413 return i < view_details->items->len;
414 }
415
416 static gboolean details_iter_children(GtkTreeModel *tree_model,
417 GtkTreeIter *iter,
418 GtkTreeIter *parent)
419 {
420 ViewDetails *view_details = (ViewDetails *) tree_model;
421
422 /* this is a list, nodes have no children */
423 if (parent)
424 return FALSE;
425
426 /* but if parent == NULL we return the list itself as children of the
427 * "root"
428 */
429
430 if (view_details->items->len)
431 {
432 iter->user_data = GINT_TO_POINTER(0);
433 return TRUE;
434 }
435 else
436 return FALSE;
437 }
438
439 static gboolean details_iter_has_child(GtkTreeModel *tree_model,
440 GtkTreeIter *iter)
441 {
442 return FALSE;
443 }
444
445 static gint details_iter_n_children(GtkTreeModel *tree_model, GtkTreeIter *iter)
446 {
447 ViewDetails *view_details = (ViewDetails *) tree_model;
448
449 if (iter == NULL)
450 return view_details->items->len;
451
452 return 0;
453 }
454
455 static gboolean details_iter_nth_child(GtkTreeModel *tree_model,
456 GtkTreeIter *iter,
457 GtkTreeIter *parent,
458 gint n)
459 {
460 ViewDetails *view_details = (ViewDetails *) tree_model;
461
462 if (parent)
463 return FALSE;
464
465 if (n >= 0 && n < view_details->items->len)
466 {
467 iter->user_data = GINT_TO_POINTER(n);
468 return TRUE;
469 }
470 else
471 return FALSE;
472 }
473
474 static gboolean details_iter_parent(GtkTreeModel *tree_model,
475 GtkTreeIter *iter,
476 GtkTreeIter *child)
477 {
478 return FALSE;
479 }
480
481 /* A ViewDetails is both a GtkTreeView and a GtkTreeModel.
482 * The following functions implement the model interface...
483 */
484
485 static void view_details_tree_model_init(GtkTreeModelIface *iface)
486 {
487 iface->get_flags = details_get_flags;
488 iface->get_n_columns = details_get_n_columns;
489 iface->get_column_type = details_get_column_type;
490 iface->get_iter = details_get_iter;
491 iface->get_path = details_get_path;
492 iface->get_value = details_get_value;
493 iface->iter_next = details_iter_next;
494 iface->iter_children = details_iter_children;
495 iface->iter_has_child = details_iter_has_child;
496 iface->iter_n_children = details_iter_n_children;
497 iface->iter_nth_child = details_iter_nth_child;
498 iface->iter_parent = details_iter_parent;
499 }
500
501 static void view_details_sortable_init(GtkTreeSortableIface *iface)
502 {
503 iface->get_sort_column_id = details_get_sort_column_id;
504 iface->set_sort_column_id = details_set_sort_column_id;
505 iface->set_sort_func = details_set_sort_func;
506 iface->set_default_sort_func = details_set_default_sort_func;
507 iface->has_default_sort_func = details_has_default_sort_func;
508 }
509
510 static gboolean details_get_sort_column_id(GtkTreeSortable *sortable,
511 gint *sort_column_id,
512 GtkSortType *order)
513 {
514 ViewDetails *view_details = (ViewDetails *) sortable;
515 FilerWindow *filer_window = view_details->filer_window;
516 int col;
517
518 if (!filer_window)
519 return FALSE; /* Not yet initialised */
520
521 switch (filer_window->sort_type)
522 {
523 case SORT_NAME: col = COL_LEAF; break;
524 case SORT_TYPE: col = COL_TYPE; break;
525 case SORT_DATE: col = COL_MTIME; break;
526 case SORT_SIZE: col = COL_SIZE; break;
527 case SORT_OWNER: col = COL_OWNER; break;
528 case SORT_GROUP: col = COL_GROUP; break;
529 default:
530 g_warning("details_get_sort_column_id(): error!");
531 return FALSE;
532 }
533 if (sort_column_id)
534 *sort_column_id = col;
535 if (order)
536 *order = filer_window->sort_order;
537 return TRUE;
538 }
539
540 static void details_set_sort_column_id(GtkTreeSortable *sortable,
541 gint sort_column_id,
542 GtkSortType order)
543 {
544 ViewDetails *view_details = (ViewDetails *) sortable;
545 FilerWindow *filer_window = view_details->filer_window;
546
547 if (!filer_window)
548 return; /* Not yet initialised */
549
550 switch (sort_column_id)
551 {
552 case COL_LEAF:
553 display_set_sort_type(filer_window, SORT_NAME, order);
554 break;
555 case COL_SIZE:
556 display_set_sort_type(filer_window, SORT_SIZE, order);
557 break;
558 case COL_MTIME:
559 display_set_sort_type(filer_window, SORT_DATE, order);
560 break;
561 case COL_TYPE:
562 display_set_sort_type(filer_window, SORT_TYPE, order);
563 break;
564 case COL_OWNER:
565 display_set_sort_type(filer_window, SORT_OWNER, order);
566 break;
567 case COL_GROUP:
568 display_set_sort_type(filer_window, SORT_GROUP, order);
569 break;
570 default:
571 g_assert_not_reached();
572 }
573 }
574
575 static void details_set_sort_func(GtkTreeSortable *sortable,
576 gint sort_column_id,
577 GtkTreeIterCompareFunc func,
578 gpointer data,
579 GtkDestroyNotify destroy)
580 {
581 g_assert_not_reached();
582 }
583
584 static void details_set_default_sort_func(GtkTreeSortable *sortable,
585 GtkTreeIterCompareFunc func,
586 gpointer data,
587 GtkDestroyNotify destroy)
588 {
589 g_assert_not_reached();
590 }
591
592 static gboolean details_has_default_sort_func(GtkTreeSortable *sortable)
593 {
594 return FALSE;
595 }
596
597
598 /* End of model implementation */
599
600 static gboolean is_selected(ViewDetails *view_details, int i)
601 {
602 ViewIter iter;
603 iter.i = i;
604 return view_details_get_selected((ViewIface *) view_details, &iter);
605 }
606
607 static gboolean view_details_scroll(GtkWidget *widget, GdkEventScroll *event)
608 {
609 GtkTreeView *tree = (GtkTreeView *) widget;
610 GtkTreePath *path = NULL;
611
612 if (!gtk_tree_view_get_path_at_pos(tree, 0, 1, &path, NULL, NULL, NULL))
613 return TRUE; /* Empty? */
614
615 if (event->direction == GDK_SCROLL_UP)
616 gtk_tree_path_prev(path);
617 else if (event->direction == GDK_SCROLL_DOWN)
618 gtk_tree_path_next(path);
619 else
620 goto out;
621
622 gtk_tree_view_scroll_to_cell(tree, path, NULL, TRUE, 0, 0);
623 out:
624 gtk_tree_path_free(path);
625 return TRUE;
626 }
627
628 static gint view_details_key_press(GtkWidget *widget, GdkEventKey *event)
629 {
630 if (event->keyval == GDK_Up || event->keyval == GDK_Down ||
631 event->keyval == GDK_Prior || event->keyval == GDK_Next ||
632 event->keyval == GDK_Home || event->keyval == GDK_End)
633 return GTK_WIDGET_CLASS(parent_class)->key_press_event(widget,
634 event);
635 return FALSE;
636 }
637
638 static gboolean view_details_button_press(GtkWidget *widget,
639 GdkEventButton *bev)
640 {
641 FilerWindow *filer_window = ((ViewDetails *) widget)->filer_window;
642 GtkTreeView *tree = (GtkTreeView *) widget;
643
644 if (bev->window != gtk_tree_view_get_bin_window(tree))
645 return GTK_WIDGET_CLASS(parent_class)->button_press_event(
646 widget, bev);
647
648 if (dnd_motion_press(widget, bev))
649 filer_perform_action(filer_window, bev);
650
651 return TRUE;
652 }
653
654 static int get_lasso_index(ViewDetails *view_details, int y)
655 {
656 GtkTreeViewColumn *column = NULL;
657 GtkTreePath *path = NULL;
658 GtkTreeView *tree = (GtkTreeView *) view_details;
659 gint cell_y;
660 int i;
661
662 if (y < 0)
663 y = 0; /* gtk_tree_view_get_path_at_pos can't handle negatives */
664
665 if (gtk_tree_view_get_path_at_pos(tree, 4, y, &path,
666 &column, NULL, &cell_y))
667 {
668 GdkRectangle rect;
669 i = gtk_tree_path_get_indices(path)[0];
670 gtk_tree_view_get_cell_area(tree, path, column, &rect);
671 gtk_tree_path_free(path);
672
673 if (2 * cell_y > rect.height)
674 i += 1;
675 }
676 else
677 i = view_details->items->len;
678
679 return i;
680 }
681
682 static gboolean select_lasso_cb(ViewIter *iter, gpointer data)
683 {
684 int start = ((int *) data)[0];
685 int end = ((int *) data)[1];
686 GdkFunction fn = ((int *) data)[2];
687 ViewDetails *view_details = (ViewDetails *) iter->view;
688 GtkTreeIter titer;
689
690 titer.user_data = GINT_TO_POINTER(iter->i);
691
692 if (iter->i < start || iter->i >= end)
693 return gtk_tree_selection_iter_is_selected(
694 view_details->selection, &titer);
695
696 if (fn == GDK_SET)
697 return TRUE;
698
699 return !gtk_tree_selection_iter_is_selected(view_details->selection,
700 &titer);
701 }
702
703 static void select_lasso(ViewDetails *view_details, GdkFunction fn)
704 {
705 GtkAdjustment *adj;
706 int range[3];
707
708 adj = gtk_tree_view_get_vadjustment((GtkTreeView *) view_details);
709
710 range[0] = view_details->lasso_start_index;
711 range[1] = get_lasso_index(view_details,
712 view_details->drag_box_y[1] - adj->value);
713 range[2] = fn;
714
715 if (range[0] == range[1])
716 return;
717 if (range[0] > range[1])
718 {
719 int tmp = range[0];
720 range[0] = range[1];
721 range[1] = tmp;
722 }
723
724 view_select_if((ViewIface *) view_details, select_lasso_cb, &range);
725 }
726
727 static gboolean view_details_button_release(GtkWidget *widget,
728 GdkEventButton *bev)
729 {
730 ViewDetails *view_details = (ViewDetails *) widget;
731 FilerWindow *filer_window = view_details->filer_window;
732 GtkTreeView *tree = (GtkTreeView *) widget;
733
734 if (bev->window != gtk_tree_view_get_bin_window(tree))
735 return GTK_WIDGET_CLASS(parent_class)->button_release_event(
736 widget, bev);
737
738 if (!dnd_motion_release(bev))
739 filer_perform_action(filer_window, bev);
740
741 if (motion_buttons_pressed == 0 && view_details->lasso_box)
742 {
743 select_lasso(view_details,
744 bev->button == 1 ? GDK_SET : GDK_INVERT);
745 filer_set_autoscroll(filer_window, FALSE);
746 set_lasso(view_details,
747 view_details->drag_box_x[0],
748 view_details->drag_box_y[0]);
749 view_details->lasso_box = FALSE;
750 }
751
752 return TRUE;
753 }
754
755 static gint view_details_motion_notify(GtkWidget *widget, GdkEventMotion *event)
756 {
757 ViewDetails *view_details = (ViewDetails *) widget;
758 GtkTreeView *tree = (GtkTreeView *) widget;
759
760 if (event->window != gtk_tree_view_get_bin_window(tree))
761 return GTK_WIDGET_CLASS(parent_class)->motion_notify_event(
762 widget, event);
763
764 if (view_details->lasso_box)
765 {
766 GtkAdjustment *adj;
767 adj = gtk_tree_view_get_vadjustment(tree);
768 set_lasso(view_details, event->x, event->y + adj->value);
769 return TRUE;
770 }
771
772 return filer_motion_notify(view_details->filer_window, event);
773 }
774
775 static gboolean view_details_expose(GtkWidget *widget, GdkEventExpose *event)
776 {
777 GtkTreeView *tree = (GtkTreeView *) widget;
778 GtkTreePath *path = NULL;
779 GdkRectangle focus_rectangle;
780 ViewDetails *view_details = (ViewDetails *) widget;
781 gboolean had_cursor;
782
783 had_cursor = (GTK_WIDGET_FLAGS(widget) & GTK_HAS_FOCUS) != 0;
784
785 if (view_details->filer_window->selection_state == GTK_STATE_SELECTED)
786 GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_FOCUS);
787 else
788 GTK_WIDGET_UNSET_FLAGS(widget, GTK_HAS_FOCUS);
789 GTK_WIDGET_CLASS(parent_class)->expose_event(widget, event);
790 if (had_cursor)
791 GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_FOCUS);
792
793 if (event->window != gtk_tree_view_get_bin_window(tree))
794 return FALSE; /* Not the main area */
795
796 if (view_details->lasso_box)
797 {
798 int x, y, width, height;
799 GtkAdjustment *adj;
800
801 adj = gtk_tree_view_get_vadjustment(tree);
802 x = MIN(view_details->drag_box_x[0],
803 view_details->drag_box_x[1]);
804 y = MIN(view_details->drag_box_y[0],
805 view_details->drag_box_y[1]);
806 width = abs(view_details->drag_box_x[1] -
807 view_details->drag_box_x[0]);
808 height = abs(view_details->drag_box_y[1] -
809 view_details->drag_box_y[0]);
810 y -= adj->value;
811
812 if (width && height)
813 gdk_draw_rectangle(event->window,
814 widget->style->fg_gc[GTK_STATE_NORMAL],
815 FALSE, x, y, width - 1, height - 1);
816 }
817
818 if (view_details->wink_item != -1 && view_details->wink_step & 1)
819 {
820 GtkTreePath *wink_path;
821 GdkRectangle wink_area;
822
823 wink_path = gtk_tree_path_new();
824 gtk_tree_path_append_index(wink_path, view_details->wink_item);
825 gtk_tree_view_get_background_area(tree, wink_path,
826 NULL, &wink_area);
827 gtk_tree_path_free(wink_path);
828
829 if (wink_area.height)
830 {
831 /* (visible) */
832 wink_area.width = widget->allocation.width;
833 gdk_draw_rectangle(event->window,
834 widget->style->fg_gc[GTK_STATE_NORMAL],
835 FALSE,
836 wink_area.x + 1,
837 wink_area.y + 1,
838 wink_area.width - 3,
839 wink_area.height - 3);
840 }
841 }
842
843 gtk_tree_view_get_cursor(tree, &path, NULL);
844 if (!path)
845 return FALSE; /* No cursor */
846 gtk_tree_view_get_background_area(tree, path, NULL, &focus_rectangle);
847 gtk_tree_path_free(path);
848
849 if (!focus_rectangle.height)
850 return FALSE; /* Off screen */
851
852 focus_rectangle.width = widget->allocation.width;
853
854 gtk_paint_focus(widget->style,
855 event->window,
856 GTK_STATE_NORMAL,
857 NULL,
858 widget,
859 "treeview",
860 focus_rectangle.x,
861 focus_rectangle.y,
862 focus_rectangle.width,
863 focus_rectangle.height);
864
865 return FALSE;
866 }
867
868 static void view_details_size_request(GtkWidget *widget,
869 GtkRequisition *requisition)
870 {
871 ViewDetails *view_details = (ViewDetails *) widget;
872
873 (*GTK_WIDGET_CLASS(parent_class)->size_request)(widget, requisition);
874
875 view_details->desired_size = *requisition;
876
877 requisition->height = 50;
878 requisition->width = 50;
879 }
880
881 static void view_details_drag_data_received(GtkWidget *widget,
882 GdkDragContext *drag_context,
883 gint x, gint y, GtkSelectionData *data, guint info, guint time)
884 {
885 /* Just here to override annoying default handler */
886 }
887
888 static void view_details_destroy(GtkObject *obj)
889 {
890 ViewDetails *view_details = VIEW_DETAILS(obj);
891
892 view_details->filer_window = NULL;
893 cancel_wink(view_details);
894 }
895
896 static void view_details_finialize(GObject *object)
897 {
898 ViewDetails *view_details = (ViewDetails *) object;
899
900 g_ptr_array_free(view_details->items, TRUE);
901 view_details->items = NULL;
902
903 G_OBJECT_CLASS(parent_class)->finalize(object);
904 }
905
906 static void view_details_class_init(gpointer gclass, gpointer data)
907 {
908 GObjectClass *object = (GObjectClass *) gclass;
909 GtkWidgetClass *widget = (GtkWidgetClass *) gclass;
910
911 parent_class = g_type_class_peek_parent(gclass);
912
913 object->finalize = view_details_finialize;
914 GTK_OBJECT_CLASS(object)->destroy = view_details_destroy;
915
916 widget->scroll_event = view_details_scroll;
917 widget->key_press_event = view_details_key_press;
918 widget->button_press_event = view_details_button_press;
919 widget->button_release_event = view_details_button_release;
920 widget->motion_notify_event = view_details_motion_notify;
921 widget->expose_event = view_details_expose;
922 widget->size_request = view_details_size_request;
923 widget->drag_data_received = view_details_drag_data_received;
924 }
925
926 static gboolean block_focus(GtkWidget *button, GtkDirectionType dir,
927 ViewDetails *view_details)
928 {
929 GTK_WIDGET_UNSET_FLAGS(button, GTK_CAN_FOCUS);
930 return FALSE;
931 }
932
933 static gboolean test_can_change_selection(GtkTreeSelection *sel,
934 GtkTreeModel *model,
935 GtkTreePath *path,
936 gboolean path_currently_selected,
937 gpointer data)
938 {
939 ViewDetails *view_details;
940
941 view_details = VIEW_DETAILS(gtk_tree_selection_get_tree_view(sel));
942
943 return view_details->can_change_selection != 0;
944 }
945
946 static void selection_changed(GtkTreeSelection *selection,
947 gpointer user_data)
948 {
949 ViewDetails *view_details = VIEW_DETAILS(user_data);
950
951 filer_selection_changed(view_details->filer_window,
952 gtk_get_current_event_time());
953 }
954
955 #define ADD_TEXT_COLUMN(name, model_column) \
956 cell = gtk_cell_renderer_text_new(); \
957 column = gtk_tree_view_column_new_with_attributes(name, cell, \
958 "text", model_column, \
959 "foreground-gdk", COL_COLOUR, \
960 "weight", COL_WEIGHT, \
961 NULL); \
962 gtk_tree_view_append_column(treeview, column); \
963 g_signal_connect(column->button, "grab-focus", \
964 G_CALLBACK(block_focus), view_details);
965
966 static void view_details_init(GTypeInstance *object, gpointer gclass)
967 {
968 GtkTreeView *treeview = (GtkTreeView *) object;
969 GtkTreeViewColumn *column;
970 GtkCellRenderer *cell;
971 GtkTreeSortable *sortable_list;
972 ViewDetails *view_details = (ViewDetails *) object;
973
974 view_details->items = g_ptr_array_new();
975 view_details->cursor_base = -1;
976 view_details->wink_item = -1;
977 view_details->desired_size.width = -1;
978 view_details->desired_size.height = -1;
979 view_details->can_change_selection = 0;
980 view_details->lasso_box = FALSE;
981
982 view_details->selection = gtk_tree_view_get_selection(treeview);
983 gtk_tree_selection_set_mode(view_details->selection,
984 GTK_SELECTION_MULTIPLE);
985 gtk_tree_selection_set_select_function(view_details->selection,
986 test_can_change_selection, view_details, NULL);
987 g_signal_connect(view_details->selection, "changed",
988 G_CALLBACK(selection_changed), view_details);
989
990 /* Sorting */
991 view_details->sort_fn = NULL;
992 sortable_list = GTK_TREE_SORTABLE(object);
993
994 gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(view_details));
995
996 /* Icon */
997 cell = cell_icon_new(view_details);
998 column = gtk_tree_view_column_new_with_attributes(NULL, cell,
999 "item", COL_VIEW_ITEM,
1000 NULL);
1001 gtk_tree_view_append_column(treeview, column);
1002
1003 ADD_TEXT_COLUMN(_("_Name"), COL_LEAF);
1004 gtk_tree_view_column_set_sort_column_id(column, COL_LEAF);
1005 gtk_tree_view_column_set_resizable(column, TRUE);
1006 ADD_TEXT_COLUMN(_("_Type"), COL_TYPE);
1007 gtk_tree_view_column_set_sort_column_id(column, COL_TYPE);
1008 ADD_TEXT_COLUMN(_("_Permissions"), COL_PERM);
1009 ADD_TEXT_COLUMN(_("_Owner"), COL_OWNER);
1010 gtk_tree_view_column_set_sort_column_id(column, COL_OWNER);
1011 ADD_TEXT_COLUMN(_("_Group"), COL_GROUP);
1012 gtk_tree_view_column_set_sort_column_id(column, COL_GROUP);
1013 ADD_TEXT_COLUMN(_("_Size"), COL_SIZE);
1014 gtk_tree_view_column_set_sort_column_id(column, COL_SIZE);
1015 ADD_TEXT_COLUMN(_("Last _Modified"), COL_MTIME);
1016 gtk_tree_view_column_set_sort_column_id(column, COL_MTIME);
1017 }
1018
1019 /* Create the handers for the View interface */
1020 static void view_details_iface_init(gpointer giface, gpointer iface_data)
1021 {
1022 ViewIfaceClass *iface = giface;
1023
1024 g_assert(G_TYPE_FROM_INTERFACE(iface) == VIEW_TYPE_IFACE);
1025
1026 /* override stuff */
1027 iface->sort = view_details_sort;
1028 iface->style_changed = view_details_style_changed;
1029 iface->add_items = view_details_add_items;
1030 iface->update_items = view_details_update_items;
1031 iface->delete_if = view_details_delete_if;
1032 iface->clear = view_details_clear;
1033 iface->select_all = view_details_select_all;
1034 iface->clear_selection = view_details_clear_selection;
1035 iface->count_items = view_details_count_items;
1036 iface->count_selected = view_details_count_selected;
1037 iface->show_cursor = view_details_show_cursor;
1038 iface->get_iter = view_details_get_iter;
1039 iface->get_iter_at_point = view_details_get_iter_at_point;
1040 iface->cursor_to_iter = view_details_cursor_to_iter;
1041 iface->set_selected = view_details_set_selected;
1042 iface->get_selected = view_details_get_selected;
1043 iface->set_frozen = view_details_set_frozen;
1044 iface->select_only = view_details_select_only;
1045 iface->wink_item = view_details_wink_item;
1046 iface->autosize = view_details_autosize;
1047 iface->cursor_visible = view_details_cursor_visible;
1048 iface->set_base = view_details_set_base;
1049 iface->start_lasso_box = view_details_start_lasso_box;
1050 iface->extend_tip = view_details_extend_tip;
1051 iface->auto_scroll_callback = view_details_auto_scroll_callback;
1052 }
1053
1054 /* Implementations of the View interface. See view_iface.c for comments. */
1055
1056 static void view_details_style_changed(ViewIface *view, int flags)
1057 {
1058 ViewDetails *view_details = (ViewDetails *) view;
1059 GtkTreeModel *model = (GtkTreeModel *) view;
1060 GtkTreePath *path;
1061 ViewItem **items = (ViewItem **) view_details->items->pdata;
1062 int i;
1063 int n = view_details->items->len;
1064
1065 path = gtk_tree_path_new();
1066 gtk_tree_path_append_index(path, 0);
1067
1068 for (i = 0; i < n; i++)
1069 {
1070 GtkTreeIter iter;
1071 ViewItem *item = items[i];
1072
1073 iter.user_data = GINT_TO_POINTER(i);
1074 if (item->image)
1075 {
1076 g_object_unref(G_OBJECT(item->image));
1077 item->image = NULL;
1078 }
1079 gtk_tree_model_row_changed(model, path, &iter);
1080 gtk_tree_path_next(path);
1081 }
1082
1083 gtk_tree_path_free(path);
1084
1085 gtk_tree_view_columns_autosize((GtkTreeView *) view);
1086
1087 if (flags & VIEW_UPDATE_HEADERS)
1088 details_update_header_visibility(view_details);
1089 }
1090
1091 static gint wrap_sort(gconstpointer a, gconstpointer b,
1092 ViewDetails *view_details)
1093 {
1094 ViewItem *ia = *(ViewItem **) a;
1095 ViewItem *ib = *(ViewItem **) b;
1096
1097 if (view_details->filer_window->sort_order == GTK_SORT_ASCENDING)
1098 return view_details->sort_fn(ia->item, ib->item);
1099 else
1100 return -view_details->sort_fn(ia->item, ib->item);
1101 }
1102
1103 static void resort(ViewDetails *view_details)
1104 {
1105 ViewItem **items = (ViewItem **) view_details->items->pdata;
1106 gint i, len = view_details->items->len;
1107 guint *new_order;
1108 GtkTreePath *path;
1109 int wink_item = view_details->wink_item;
1110
1111 if (!len)
1112 return;
1113
1114 for (i = len - 1; i >= 0; i--)
1115 items[i]->old_pos = i;
1116
1117 switch (view_details->filer_window->sort_type)
1118 {
1119 case SORT_NAME: view_details->sort_fn = sort_by_name; break;
1120 case SORT_TYPE: view_details->sort_fn = sort_by_type; break;
1121 case SORT_DATE: view_details->sort_fn = sort_by_date; break;
1122 case SORT_SIZE: view_details->sort_fn = sort_by_size; break;
1123 case SORT_OWNER: view_details->sort_fn = sort_by_owner; break;
1124 case SORT_GROUP: view_details->sort_fn = sort_by_group; break;
1125 default:
1126 g_assert_not_reached();
1127 }
1128
1129 g_ptr_array_sort_with_data(view_details->items,
1130 (GCompareDataFunc) wrap_sort,
1131 view_details);
1132
1133 new_order = g_new(guint, len);
1134 for (i = len - 1; i >= 0; i--)
1135 {
1136 new_order[i] = items[i]->old_pos;
1137 if (wink_item == items[i]->old_pos)
1138 wink_item = i;
1139 }
1140
1141 view_details->wink_item = wink_item;
1142
1143 path = gtk_tree_path_new();
1144 gtk_tree_model_rows_reordered((GtkTreeModel *) view_details,
1145 path, NULL, new_order);
1146 gtk_tree_path_free(path);
1147 g_free(new_order);
1148 }
1149
1150 static void view_details_sort(ViewIface *view)
1151 {
1152 resort((ViewDetails *) view);
1153 gtk_tree_sortable_sort_column_changed((GtkTreeSortable *) view);
1154 }
1155
1156 static void view_details_add_items(ViewIface *view, GPtrArray *new_items)
1157 {
1158 ViewDetails *view_details = (ViewDetails *) view;
1159 FilerWindow *filer_window = view_details->filer_window;
1160 GPtrArray *items = view_details->items;
1161 GtkTreeIter iter;
1162 int i;
1163 GtkTreePath *path;
1164 GtkTreeModel *model = (GtkTreeModel *) view;
1165
1166 iter.user_data = GINT_TO_POINTER(items->len);
1167 path = details_get_path(model, &iter);
1168
1169 for (i = 0; i < new_items->len; i++)
1170 {
1171 DirItem *item = (DirItem *) new_items->pdata[i];
1172 char *leafname = item->leafname;
1173 ViewItem *vitem;
1174
1175 if(!filer_match_filter(filer_window, leafname))
1176 continue;
1177 if (leafname[0] == '.')
1178 {
1179 if (leafname[1] == '\0')
1180 continue; /* Never show '.' */
1181
1182 if (leafname[1] == '.' &&
1183 leafname[2] == '\0')
1184 continue; /* Never show '..' */
1185 }
1186
1187 vitem = g_new(ViewItem, 1);
1188 vitem->item = item;
1189 vitem->image = NULL;
1190 if (!g_utf8_validate(leafname, -1, NULL))
1191 vitem->utf8_name = to_utf8(leafname);
1192 else
1193 vitem->utf8_name = NULL;
1194
1195 g_ptr_array_add(items, vitem);
1196
1197 iter.user_data = GINT_TO_POINTER(items->len - 1);
1198 gtk_tree_model_row_inserted(model, path, &iter);
1199 gtk_tree_path_next(path);
1200 }
1201
1202 gtk_tree_path_free(path);
1203
1204 resort(view_details);
1205 }
1206
1207 /* Find an item in the sorted array.
1208 * Returns the item number, or -1 if not found.
1209 */
1210 static int details_find_item(ViewDetails *view_details, DirItem *item)
1211 {
1212 ViewItem **items, tmp, *tmpp;
1213 int lower, upper;
1214
1215 g_return_val_if_fail(view_details != NULL, -1);
1216 g_return_val_if_fail(item != NULL, -1);
1217
1218 tmp.item = item;
1219 tmpp = &tmp;
1220
1221 items = (ViewItem **) view_details->items->pdata;
1222
1223 /* If item is here, then: lower <= i < upper */
1224 lower = 0;
1225 upper = view_details->items->len;
1226
1227 while (lower < upper)
1228 {
1229 int i, cmp;
1230
1231 i = (lower + upper) >> 1;
1232
1233 cmp = wrap_sort(&items[i], &tmpp, view_details);
1234 if (cmp == 0)
1235 return i;
1236
1237 if (cmp > 0)
1238 upper = i;
1239 else
1240 lower = i + 1;
1241 }
1242
1243 return -1;
1244 }
1245
1246 static void view_details_update_items(ViewIface *view, GPtrArray *items)
1247 {
1248 ViewDetails *view_details = (ViewDetails *) view;
1249 FilerWindow *filer_window = view_details->filer_window;
1250 int i;
1251 GtkTreeModel *model = (GtkTreeModel *) view_details;
1252
1253 g_return_if_fail(items->len > 0);
1254
1255 /* The item data has already been modified, so this gives the
1256 * final sort order...
1257 */
1258 resort(view_details);
1259
1260 for (i = 0; i < items->len; i++)
1261 {
1262 DirItem *item = (DirItem *) items->pdata[i];
1263 const gchar *leafname = item->leafname;
1264 int j;
1265
1266 if (!filer_match_filter(filer_window, leafname))
1267 continue;
1268
1269 j = details_find_item(view_details, item);
1270
1271 if (j < 0)
1272 g_warning("Failed to find '%s'\n", leafname);
1273 else
1274 {
1275 GtkTreePath *path;
1276 GtkTreeIter iter;
1277 ViewItem *view_item = view_details->items->pdata[j];
1278 if (view_item->image)
1279 {
1280 g_object_unref(G_OBJECT(view_item->image));
1281 view_item->image = NULL;
1282 }
1283 path = gtk_tree_path_new();
1284 gtk_tree_path_append_index(path, j);
1285 iter.user_data = GINT_TO_POINTER(j);
1286 gtk_tree_model_row_changed(model, path, &iter);
1287 }
1288 }
1289 }
1290
1291 static void view_details_delete_if(ViewIface *view,
1292 gboolean (*test)(gpointer item, gpointer data),
1293 gpointer data)
1294 {
1295 GtkTreePath *path;
1296 ViewDetails *view_details = (ViewDetails *) view;
1297 int i = 0;
1298 GPtrArray *items = view_details->items;
1299 GtkTreeModel *model = (GtkTreeModel *) view;
1300
1301 path = gtk_tree_path_new();
1302
1303 gtk_tree_path_append_index(path, i);
1304
1305 while (i < items->len)
1306 {
1307 ViewItem *item = items->pdata[i];
1308
1309 if (test(item->item, data))
1310 {
1311 free_view_item(items->pdata[i]);
1312 g_ptr_array_remove_index(items, i);
1313 gtk_tree_model_row_deleted(model, path);
1314 }
1315 else
1316 {
1317 i++;
1318 gtk_tree_path_next(path);
1319 }
1320 }
1321
1322 gtk_tree_path_free(path);
1323 }
1324
1325 static void view_details_clear(ViewIface *view)
1326 {
1327 GtkTreePath *path;
1328 GPtrArray *items = ((ViewDetails *) view)->items;
1329 GtkTreeModel *model = (GtkTreeModel *) view;
1330
1331 path = gtk_tree_path_new();
1332 gtk_tree_path_append_index(path, items->len);
1333
1334 while (gtk_tree_path_prev(path))
1335 gtk_tree_model_row_deleted(model, path);
1336
1337 g_ptr_array_set_size(items, 0);
1338 gtk_tree_path_free(path);
1339 }
1340
1341 static void view_details_select_all(ViewIface *view)
1342 {
1343 ViewDetails *view_details = (ViewDetails *) view;
1344
1345 view_details->can_change_selection++;
1346 gtk_tree_selection_select_all(view_details->selection);
1347 view_details->can_change_selection--;
1348 }
1349
1350 static void view_details_clear_selection(ViewIface *view)
1351 {
1352 ViewDetails *view_details = (ViewDetails *) view;
1353
1354 view_details->can_change_selection++;
1355 gtk_tree_selection_unselect_all(view_details->selection);
1356 view_details->can_change_selection--;
1357 }
1358
1359 static int view_details_count_items(ViewIface *view)
1360 {
1361 ViewDetails *view_details = (ViewDetails *) view;
1362
1363 return view_details->items->len;
1364 }
1365
1366 #if GTK_MINOR_VERSION < 2
1367 static void view_details_count_inc(GtkTreeModel *model, GtkTreePath *path,
1368 GtkTreeIter *iter, gpointer data)
1369 {
1370 int *count = (int *) data;
1371 (*count) += 1;
1372 }
1373 #endif
1374
1375 static int view_details_count_selected(ViewIface *view)
1376 {
1377 ViewDetails *view_details = (ViewDetails *) view;
1378
1379 #if GTK_MINOR_VERSION >= 2
1380 return gtk_tree_selection_count_selected_rows(view_details->selection);
1381 #else
1382 int count = 0;
1383
1384 gtk_tree_selection_selected_foreach(view_details->selection,
1385 view_details_count_inc, &count);
1386 return count;
1387 #endif
1388 }
1389
1390 static void view_details_show_cursor(ViewIface *view)
1391 {
1392 }
1393
1394 static void view_details_get_iter(ViewIface *view,
1395 ViewIter *iter, IterFlags flags)
1396 {
1397 make_iter((ViewDetails *) view, iter, flags);
1398 }
1399
1400 static void view_details_get_iter_at_point(ViewIface *view, ViewIter *iter,
1401 GdkWindow *src, int x, int y)
1402 {
1403 ViewDetails *view_details = (ViewDetails *) view;
1404 GtkTreeModel *model;
1405 GtkTreeView *tree = (GtkTreeView *) view;
1406 GtkTreePath *path = NULL;
1407 int i = -1;
1408 gint cell_y;
1409
1410 model = gtk_tree_view_get_model(tree);
1411
1412 if (gtk_tree_view_get_path_at_pos(tree, x, y + 4, &path, NULL,
1413 NULL, &cell_y))
1414 {
1415 g_return_if_fail(path != NULL);
1416
1417 if (cell_y > 8)
1418 i = gtk_tree_path_get_indices(path)[0];
1419 gtk_tree_path_free(path);
1420 }
1421
1422 make_item_iter(view_details, iter, i);
1423 }
1424
1425 static void view_details_cursor_to_iter(ViewIface *view, ViewIter *iter)
1426 {
1427 GtkTreePath *path;
1428 ViewDetails *view_details = (ViewDetails *) view;
1429
1430 path = gtk_tree_path_new();
1431
1432 if (iter)
1433 gtk_tree_path_append_index(path, iter->i);
1434 else
1435 {
1436 /* Using depth zero or index -1 gives an error, but this
1437 * is OK!
1438 */
1439 gtk_tree_path_append_index(path, view_details->items->len);
1440 }
1441
1442 gtk_tree_view_set_cursor((GtkTreeView *) view, path, NULL, FALSE);
1443 gtk_tree_path_free(path);
1444 }
1445
1446 static void set_selected(ViewDetails *view_details, int i, gboolean selected)
1447 {
1448 GtkTreeIter iter;
1449
1450 iter.user_data = GINT_TO_POINTER(i);
1451 view_details->can_change_selection++;
1452 if (selected)
1453 gtk_tree_selection_select_iter(view_details->selection, &iter);
1454 else
1455 gtk_tree_selection_unselect_iter(view_details->selection,
1456 &iter);
1457 view_details->can_change_selection--;
1458 }
1459
1460 static void view_details_set_selected(ViewIface *view,
1461 ViewIter *iter,
1462 gboolean selected)
1463 {
1464 set_selected((ViewDetails *) view, iter->i, selected);
1465 }
1466
1467 static gboolean get_selected(ViewDetails *view_details, int i)
1468 {
1469 GtkTreeIter iter;
1470
1471 iter.user_data = GINT_TO_POINTER(i);
1472
1473 return gtk_tree_selection_iter_is_selected(view_details->selection,
1474 &iter);
1475 }
1476
1477 static gboolean view_details_get_selected(ViewIface *view, ViewIter *iter)
1478 {
1479 return get_selected((ViewDetails *) view, iter->i);
1480 }
1481
1482 static void view_details_select_only(ViewIface *view, ViewIter *iter)
1483 {
1484 ViewDetails *view_details = (ViewDetails *) view;
1485 GtkTreePath *path;
1486
1487 path = gtk_tree_path_new();
1488 gtk_tree_path_append_index(path, iter->i);
1489 view_details->can_change_selection++;
1490 gtk_tree_selection_unselect_all(view_details->selection);
1491 gtk_tree_selection_select_range(view_details->selection, path, path);
1492 view_details->can_change_selection--;
1493 gtk_tree_path_free(path);
1494 }
1495
1496 static void view_details_set_frozen(ViewIface *view, gboolean frozen)
1497 {
1498 }
1499
1500 static void redraw_wink_area(ViewDetails *view_details)
1501 {
1502 GtkTreePath *wink_path;
1503 GdkRectangle wink_area;
1504 GtkTreeView *tree = (GtkTreeView *) view_details;
1505
1506 g_return_if_fail(view_details->wink_item >= 0);
1507
1508 wink_path = gtk_tree_path_new();
1509 gtk_tree_path_append_index(wink_path, view_details->wink_item);
1510 gtk_tree_view_get_background_area(tree, wink_path, NULL, &wink_area);
1511 gtk_tree_path_free(wink_path);
1512
1513 if (wink_area.height)
1514 {
1515 GdkWindow *window;
1516 window = gtk_tree_view_get_bin_window(tree);
1517
1518 wink_area.width = GTK_WIDGET(tree)->allocation.width;
1519 gdk_window_invalidate_rect(window, &wink_area, FALSE);
1520 }
1521 }
1522
1523 static void cancel_wink(ViewDetails *view_details)
1524 {
1525 if (view_details->wink_item == -1)
1526 return;
1527
1528 if (view_details->filer_window)
1529 redraw_wink_area(view_details);
1530
1531 view_details->wink_item = -1;
1532 g_source_remove(view_details->wink_timeout);
1533 }
1534
1535 static gboolean wink_timeout(ViewDetails *view_details)
1536 {
1537 view_details->wink_step--;
1538 if (view_details->wink_step < 1)
1539 {
1540 cancel_wink(view_details);
1541 return FALSE;
1542 }
1543
1544 redraw_wink_area(view_details);
1545
1546 return TRUE;
1547 }
1548
1549 static void view_details_wink_item(ViewIface *view, ViewIter *iter)
1550 {
1551 ViewDetails *view_details = (ViewDetails *) view;
1552 GtkTreePath *path;
1553
1554 cancel_wink(view_details);
1555 if (!iter)
1556 return;
1557
1558 view_details->wink_item = iter->i;
1559 view_details->wink_timeout = g_timeout_add(70,
1560 (GSourceFunc) wink_timeout, view_details);
1561 view_details->wink_step = 7;
1562 redraw_wink_area(view_details);
1563
1564 path = gtk_tree_path_new();
1565 gtk_tree_path_append_index(path, iter->i);
1566 gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(view),
1567 path, NULL, FALSE, 0, 0);
1568 gtk_tree_path_free(path);
1569 }
1570
1571 static void view_details_autosize(ViewIface *view)
1572 {
1573 ViewDetails *view_details = (ViewDetails *) view;
1574 FilerWindow *filer_window = view_details->filer_window;
1575 int max_width = (o_filer_size_limit.int_value * monitor_width) / 100;
1576 int max_height = (o_filer_size_limit.int_value * monitor_height) / 100;
1577 int h;
1578 GtkRequisition req;
1579
1580 gtk_widget_queue_resize(GTK_WIDGET(view));
1581 gtk_widget_size_request(GTK_WIDGET(view), &req);
1582
1583 h = MAX(view_details->desired_size.height, SMALL_HEIGHT);
1584
1585 filer_window_set_size(filer_window,
1586 MIN(view_details->desired_size.width, max_width),
1587 MIN(h, max_height));
1588 }
1589
1590 static gboolean view_details_cursor_visible(ViewIface *view)
1591 {
1592 GtkTreePath *path = NULL;
1593
1594 gtk_tree_view_get_cursor((GtkTreeView *) view, &path, NULL);
1595
1596 if (path)
1597 gtk_tree_path_free(path);
1598
1599 return path != NULL;
1600 }
1601
1602 static void view_details_set_base(ViewIface *view, ViewIter *iter)
1603 {
1604 ViewDetails *view_details = (ViewDetails *) view;
1605
1606 view_details->cursor_base = iter->i;
1607 }
1608
1609 /* Change the dynamic corner of the lasso box and trigger a redraw */
1610 static void set_lasso(ViewDetails *view_details, int x, int y)
1611 {
1612 GdkWindow *window;
1613 GdkRectangle area;
1614 int minx, miny, maxx, maxy;
1615
1616 if (x == view_details->drag_box_x[1] &&
1617 y == view_details->drag_box_y[1])
1618 return;
1619
1620 /* Get old region */
1621 minx = MIN(view_details->drag_box_x[0], view_details->drag_box_x[1]);
1622 miny = MIN(view_details->drag_box_y[0], view_details->drag_box_y[1]);
1623 maxx = MAX(view_details->drag_box_x[0], view_details->drag_box_x[1]);
1624 maxy = MAX(view_details->drag_box_y[0], view_details->drag_box_y[1]);
1625
1626 /* Enlarge to cover new point */
1627 minx = MIN(minx, x);
1628 miny = MIN(miny, y);
1629 maxx = MAX(maxx, x);
1630 maxy = MAX(maxy, y);
1631
1632 area.x = minx;
1633 area.y = miny;
1634 area.width = maxx - minx;
1635 area.height = maxy - miny;
1636
1637 view_details->drag_box_x[1] = x;
1638 view_details->drag_box_y[1] = y;
1639
1640 window = gtk_tree_view_get_bin_window((GtkTreeView *) view_details);
1641 if (area.width && area.height)
1642 {
1643 GtkAdjustment *adj;
1644
1645 adj = gtk_tree_view_get_vadjustment((GtkTreeView *)
1646 view_details);
1647 area.y -= adj->value;
1648 gdk_window_invalidate_rect(window, &area, FALSE);
1649 }
1650 }
1651
1652 static void view_details_start_lasso_box(ViewIface *view, GdkEventButton *event)
1653 {
1654 ViewDetails *view_details = (ViewDetails *) view;
1655 GtkAdjustment *adj;
1656
1657 adj = gtk_tree_view_get_vadjustment((GtkTreeView *) view_details);
1658
1659 view_details->lasso_start_index = get_lasso_index(view_details,
1660 event->y);
1661
1662 filer_set_autoscroll(view_details->filer_window, TRUE);
1663
1664 view_details->drag_box_x[0] = view_details->drag_box_x[1] = event->x;
1665 view_details->drag_box_y[0] = view_details->drag_box_y[1] = event->y +
1666 adj->value;
1667 view_details->lasso_box = TRUE;
1668 }
1669
1670 static void view_details_extend_tip(ViewIface *view,
1671 ViewIter *iter, GString *tip)
1672 {
1673 }
1674
1675 static DirItem *iter_init(ViewIter *iter)
1676 {
1677 ViewDetails *view_details = (ViewDetails *) iter->view;
1678 int i = -1;
1679 int n = view_details->items->len;
1680 int flags = iter->flags;
1681
1682 iter->peek = iter_peek;
1683
1684 if (iter->n_remaining == 0)
1685 return NULL;
1686
1687 if (flags & VIEW_ITER_FROM_CURSOR)
1688 {
1689 GtkTreePath *path;
1690 gtk_tree_view_get_cursor((GtkTreeView *) view_details,
1691 &path, NULL);
1692 if (!path)
1693 return NULL; /* No cursor */
1694 i = gtk_tree_path_get_indices(path)[0];
1695 gtk_tree_path_free(path);
1696 }
1697 else if (flags & VIEW_ITER_FROM_BASE)
1698 i = view_details->cursor_base;
1699
1700 if (i < 0 || i >= n)
1701 {
1702 /* Either a normal iteration, or an iteration from an
1703 * invalid starting point.
1704 */
1705 if (flags & VIEW_ITER_BACKWARDS)
1706 i = n - 1;
1707 else
1708 i = 0;
1709 }
1710
1711 if (i < 0 || i >= n)
1712 return NULL; /* No items at all! */
1713
1714 iter->next = flags & VIEW_ITER_BACKWARDS ? iter_prev : iter_next;
1715 iter->n_remaining--;
1716 iter->i = i;
1717
1718 if (flags & VIEW_ITER_SELECTED && !is_selected(view_details, i))
1719 return iter->next(iter);
1720 return iter->peek(iter);
1721 }
1722
1723 static DirItem *iter_prev(ViewIter *iter)
1724 {
1725 ViewDetails *view_details = (ViewDetails *) iter->view;
1726 int n = view_details->items->len;
1727 int i = iter->i;
1728
1729 g_return_val_if_fail(iter->n_remaining >= 0, NULL);
1730
1731 /* i is the last item returned (always valid) */
1732
1733 g_return_val_if_fail(i >= 0 && i < n, NULL);
1734
1735 while (iter->n_remaining)
1736 {
1737 i--;
1738 iter->n_remaining--;
1739
1740 if (i == -1)
1741 i = n - 1;
1742
1743 g_return_val_if_fail(i >= 0 && i < n, NULL);
1744
1745 if (iter->flags & VIEW_ITER_SELECTED &&
1746 !is_selected(view_details, i))
1747 continue;
1748
1749 iter->i = i;
1750 return ((ViewItem *) view_details->items->pdata[i])->item;
1751 }
1752
1753 iter->i = -1;
1754 return NULL;
1755 }
1756
1757 static DirItem *iter_next(ViewIter *iter)
1758 {
1759 ViewDetails *view_details = (ViewDetails *) iter->view;
1760 int n = view_details->items->len;
1761 int i = iter->i;
1762
1763 g_return_val_if_fail(iter->n_remaining >= 0, NULL);
1764
1765 /* i is the last item returned (always valid) */
1766
1767 g_return_val_if_fail(i >= 0 && i < n, NULL);
1768
1769 while (iter->n_remaining)
1770 {
1771 i++;
1772 iter->n_remaining--;
1773
1774 if (i == n)
1775 i = 0;
1776
1777 g_return_val_if_fail(i >= 0 && i < n, NULL);
1778
1779 if (iter->flags & VIEW_ITER_SELECTED &&
1780 !is_selected(view_details, i))
1781 continue;
1782
1783 iter->i = i;
1784 return ((ViewItem *) view_details->items->pdata[i])->item;
1785 }
1786
1787 iter->i = -1;
1788 return NULL;
1789 }
1790
1791 static DirItem *iter_peek(ViewIter *iter)
1792 {
1793 ViewDetails *view_details = (ViewDetails *) iter->view;
1794 int n = view_details->items->len;
1795 int i = iter->i;
1796
1797 if (i == -1)
1798 return NULL;
1799
1800 g_return_val_if_fail(i >= 0 && i < n, NULL);
1801
1802 return ((ViewItem *) view_details->items->pdata[i])->item;
1803 }
1804
1805 /* Set the iterator to return 'i' on the next peek().
1806 * If i is -1, returns NULL on next peek().
1807 */
1808 static void make_item_iter(ViewDetails *view_details, ViewIter *iter, int i)
1809 {
1810 make_iter(view_details, iter, 0);
1811
1812 g_return_if_fail(i >= -1 && i < (int) view_details->items->len);
1813
1814 iter->i = i;
1815 iter->next = iter_next;
1816 iter->peek = iter_peek;
1817 iter->n_remaining = 0;
1818 }
1819
1820 static void make_iter(ViewDetails *view_details, ViewIter *iter,
1821 IterFlags flags)
1822 {
1823 iter->view = (ViewIface *) view_details;
1824 iter->next = iter_init;
1825 iter->peek = NULL;
1826 iter->i = -1;
1827
1828 iter->flags = flags;
1829
1830 if (flags & VIEW_ITER_ONE_ONLY)
1831 {
1832 iter->n_remaining = 1;
1833 iter->next(iter);
1834 }
1835 else
1836 iter->n_remaining = view_details->items->len;
1837 }
1838
1839 static void free_view_item(ViewItem *view_item)
1840 {
1841 if (view_item->image)
1842 g_object_unref(G_OBJECT(view_item->image));
1843 g_free(view_item->utf8_name);
1844 g_free(view_item);
1845 }
1846
1847 static gboolean view_details_auto_scroll_callback(ViewIface *view)
1848 {
1849 GtkTreeView *tree = (GtkTreeView *) view;
1850 ViewDetails *view_details = (ViewDetails *) view;
1851 FilerWindow *filer_window = view_details->filer_window;
1852 GtkRange *scrollbar = (GtkRange *) filer_window->scrollbar;
1853 GtkAdjustment *adj;
1854 GdkWindow *window;
1855 gint x, y, w, h;
1856 GdkModifierType mask;
1857 int diff = 0;
1858
1859 window = gtk_tree_view_get_bin_window(tree);
1860
1861 gdk_window_get_pointer(window, &x, &y, &mask);
1862 gdk_drawable_get_size(window, &w, NULL);
1863
1864 adj = gtk_range_get_adjustment(scrollbar);
1865 h = adj->page_size;
1866
1867 if ((x < 0 || x > w || y < 0 || y > h) && !view_details->lasso_box)
1868 return FALSE; /* Out of window - stop */
1869
1870 if (y < AUTOSCROLL_STEP)
1871 diff = y - AUTOSCROLL_STEP;
1872 else if (y > h - AUTOSCROLL_STEP)
1873 diff = AUTOSCROLL_STEP + y - h;
1874
1875 if (diff)
1876 {
1877 int old = adj->value;
1878 int value = old + diff;
1879
1880 value = CLAMP(value, 0, adj->upper - adj->page_size);
1881 gtk_adjustment_set_value(adj, value);
1882
1883 if (adj->value != old)
1884 dnd_spring_abort();
1885 }
1886
1887 return TRUE;
1888 }
Filer for the ROX desktop