?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r2622: Remove default GtkTreeView keys (they conflicted with the menus).
[rox-filer.git] / ROX-Filer / src / view_details.c
blob1d883d6e0a41f0f4de789695eafe482ce686626c
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_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 return GTK_WIDGET_CLASS(parent_class)->key_press_event(widget,
632 event);
633 return FALSE;
634 }
635
636 static gboolean view_details_button_press(GtkWidget *widget,
637 GdkEventButton *bev)
638 {
639 FilerWindow *filer_window = ((ViewDetails *) widget)->filer_window;
640 GtkTreeView *tree = (GtkTreeView *) widget;
641
642 if (bev->window != gtk_tree_view_get_bin_window(tree))
643 return GTK_WIDGET_CLASS(parent_class)->button_press_event(
644 widget, bev);
645
646 if (dnd_motion_press(widget, bev))
647 filer_perform_action(filer_window, bev);
648
649 return TRUE;
650 }
651
652 static int get_lasso_index(ViewDetails *view_details, int y)
653 {
654 GtkTreeViewColumn *column = NULL;
655 GtkTreePath *path = NULL;
656 GtkTreeView *tree = (GtkTreeView *) view_details;
657 gint cell_y;
658 int i;
659
660 if (gtk_tree_view_get_path_at_pos(tree, 4, y, &path,
661 &column, NULL, &cell_y))
662 {
663 GdkRectangle rect;
664 i = gtk_tree_path_get_indices(path)[0];
665 gtk_tree_view_get_cell_area(tree, path, column, &rect);
666 gtk_tree_path_free(path);
667
668 if (2 * cell_y > rect.height)
669 i += 1;
670 }
671 else
672 i = view_details->items->len;
673
674 return i;
675 }
676
677 static gboolean select_lasso_cb(ViewIter *iter, gpointer data)
678 {
679 int start = ((int *) data)[0];
680 int end = ((int *) data)[1];
681 GdkFunction fn = ((int *) data)[2];
682 ViewDetails *view_details = (ViewDetails *) iter->view;
683 GtkTreeIter titer;
684
685 titer.user_data = GINT_TO_POINTER(iter->i);
686
687 if (iter->i < start || iter->i >= end)
688 return gtk_tree_selection_iter_is_selected(
689 view_details->selection, &titer);
690
691 if (fn == GDK_SET)
692 return TRUE;
693
694 return !gtk_tree_selection_iter_is_selected(view_details->selection,
695 &titer);
696 }
697
698 static void select_lasso(ViewDetails *view_details, GdkFunction fn)
699 {
700 GtkAdjustment *adj;
701 int range[3];
702
703 adj = gtk_tree_view_get_vadjustment((GtkTreeView *) view_details);
704
705 range[0] = view_details->lasso_start_index;
706 range[1] = get_lasso_index(view_details,
707 view_details->drag_box_y[1] - adj->value);
708 range[2] = fn;
709
710 if (range[0] == range[1])
711 return;
712 if (range[0] > range[1])
713 {
714 int tmp = range[0];
715 range[0] = range[1];
716 range[1] = tmp;
717 }
718
719 view_select_if((ViewIface *) view_details, select_lasso_cb, &range);
720 }
721
722 static gboolean view_details_button_release(GtkWidget *widget,
723 GdkEventButton *bev)
724 {
725 ViewDetails *view_details = (ViewDetails *) widget;
726 FilerWindow *filer_window = view_details->filer_window;
727 GtkTreeView *tree = (GtkTreeView *) widget;
728
729 if (bev->window != gtk_tree_view_get_bin_window(tree))
730 return GTK_WIDGET_CLASS(parent_class)->button_release_event(
731 widget, bev);
732
733 if (!dnd_motion_release(bev))
734 filer_perform_action(filer_window, bev);
735
736 if (motion_buttons_pressed == 0 && view_details->lasso_box)
737 {
738 select_lasso(view_details,
739 bev->button == 1 ? GDK_SET : GDK_INVERT);
740 filer_set_autoscroll(filer_window, FALSE);
741 set_lasso(view_details,
742 view_details->drag_box_x[0],
743 view_details->drag_box_y[0]);
744 view_details->lasso_box = FALSE;
745 }
746
747 return TRUE;
748 }
749
750 static gint view_details_motion_notify(GtkWidget *widget, GdkEventMotion *event)
751 {
752 ViewDetails *view_details = (ViewDetails *) widget;
753 GtkTreeView *tree = (GtkTreeView *) widget;
754
755 if (event->window != gtk_tree_view_get_bin_window(tree))
756 return GTK_WIDGET_CLASS(parent_class)->motion_notify_event(
757 widget, event);
758
759 if (view_details->lasso_box)
760 {
761 GtkAdjustment *adj;
762 adj = gtk_tree_view_get_vadjustment(tree);
763 set_lasso(view_details, event->x, event->y + adj->value);
764 return TRUE;
765 }
766
767 return filer_motion_notify(view_details->filer_window, event);
768 }
769
770 static gboolean view_details_expose(GtkWidget *widget, GdkEventExpose *event)
771 {
772 GtkTreeView *tree = (GtkTreeView *) widget;
773 GtkTreePath *path = NULL;
774 GdkRectangle focus_rectangle;
775 ViewDetails *view_details = (ViewDetails *) widget;
776 gboolean had_cursor;
777
778 had_cursor = (GTK_WIDGET_FLAGS(widget) & GTK_HAS_FOCUS) != 0;
779
780 if (view_details->filer_window->selection_state == GTK_STATE_SELECTED)
781 GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_FOCUS);
782 else
783 GTK_WIDGET_UNSET_FLAGS(widget, GTK_HAS_FOCUS);
784 GTK_WIDGET_CLASS(parent_class)->expose_event(widget, event);
785 if (had_cursor)
786 GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_FOCUS);
787
788 if (event->window != gtk_tree_view_get_bin_window(tree))
789 return FALSE; /* Not the main area */
790
791 if (view_details->lasso_box)
792 {
793 int x, y, width, height;
794 GtkAdjustment *adj;
795
796 adj = gtk_tree_view_get_vadjustment(tree);
797 x = MIN(view_details->drag_box_x[0],
798 view_details->drag_box_x[1]);
799 y = MIN(view_details->drag_box_y[0],
800 view_details->drag_box_y[1]);
801 width = abs(view_details->drag_box_x[1] -
802 view_details->drag_box_x[0]);
803 height = abs(view_details->drag_box_y[1] -
804 view_details->drag_box_y[0]);
805 y -= adj->value;
806
807 if (width && height)
808 gdk_draw_rectangle(event->window,
809 widget->style->fg_gc[GTK_STATE_NORMAL],
810 FALSE, x, y, width - 1, height - 1);
811 }
812
813 if (view_details->wink_item != -1 && view_details->wink_step & 1)
814 {
815 GtkTreePath *wink_path;
816 GdkRectangle wink_area;
817
818 wink_path = gtk_tree_path_new();
819 gtk_tree_path_append_index(wink_path, view_details->wink_item);
820 gtk_tree_view_get_background_area(tree, wink_path,
821 NULL, &wink_area);
822 gtk_tree_path_free(wink_path);
823
824 if (wink_area.height)
825 {
826 /* (visible) */
827 wink_area.width = widget->allocation.width;
828 gdk_draw_rectangle(event->window,
829 widget->style->fg_gc[GTK_STATE_NORMAL],
830 FALSE,
831 wink_area.x + 1,
832 wink_area.y + 1,
833 wink_area.width - 3,
834 wink_area.height - 3);
835 }
836 }
837
838 gtk_tree_view_get_cursor(tree, &path, NULL);
839 if (!path)
840 return FALSE; /* No cursor */
841 gtk_tree_view_get_background_area(tree, path, NULL, &focus_rectangle);
842 gtk_tree_path_free(path);
843
844 if (!focus_rectangle.height)
845 return FALSE; /* Off screen */
846
847 focus_rectangle.width = widget->allocation.width;
848
849 gtk_paint_focus(widget->style,
850 event->window,
851 GTK_STATE_NORMAL,
852 NULL,
853 widget,
854 "treeview",
855 focus_rectangle.x,
856 focus_rectangle.y,
857 focus_rectangle.width,
858 focus_rectangle.height);
859
860 return FALSE;
861 }
862
863 static void view_details_size_request(GtkWidget *widget,
864 GtkRequisition *requisition)
865 {
866 ViewDetails *view_details = (ViewDetails *) widget;
867
868 (*GTK_WIDGET_CLASS(parent_class)->size_request)(widget, requisition);
869
870 view_details->desired_size = *requisition;
871
872 requisition->height = 50;
873 requisition->width = 50;
874 }
875
876 static void view_details_drag_data_received(GtkWidget *widget,
877 GdkDragContext *drag_context,
878 gint x, gint y, GtkSelectionData *data, guint info, guint time)
879 {
880 /* Just here to override annoying default handler */
881 }
882
883 static void view_details_destroy(GtkObject *obj)
884 {
885 ViewDetails *view_details = VIEW_DETAILS(obj);
886
887 view_details->filer_window = NULL;
888 cancel_wink(view_details);
889 }
890
891 static void view_details_finialize(GObject *object)
892 {
893 ViewDetails *view_details = (ViewDetails *) object;
894
895 g_ptr_array_free(view_details->items, TRUE);
896 view_details->items = NULL;
897
898 G_OBJECT_CLASS(parent_class)->finalize(object);
899 }
900
901 static void view_details_class_init(gpointer gclass, gpointer data)
902 {
903 GObjectClass *object = (GObjectClass *) gclass;
904 GtkWidgetClass *widget = (GtkWidgetClass *) gclass;
905
906 parent_class = g_type_class_peek_parent(gclass);
907
908 object->finalize = view_details_finialize;
909 GTK_OBJECT_CLASS(object)->destroy = view_details_destroy;
910
911 widget->scroll_event = view_details_scroll;
912 widget->key_press_event = view_details_key_press;
913 widget->button_press_event = view_details_button_press;
914 widget->button_release_event = view_details_button_release;
915 widget->motion_notify_event = view_details_motion_notify;
916 widget->expose_event = view_details_expose;
917 widget->size_request = view_details_size_request;
918 widget->drag_data_received = view_details_drag_data_received;
919 }
920
921 static gboolean block_focus(GtkWidget *button, GtkDirectionType dir,
922 ViewDetails *view_details)
923 {
924 GTK_WIDGET_UNSET_FLAGS(button, GTK_CAN_FOCUS);
925 return FALSE;
926 }
927
928 static gboolean test_can_change_selection(GtkTreeSelection *sel,
929 GtkTreeModel *model,
930 GtkTreePath *path,
931 gboolean path_currently_selected,
932 gpointer data)
933 {
934 ViewDetails *view_details;
935
936 view_details = VIEW_DETAILS(gtk_tree_selection_get_tree_view(sel));
937
938 return view_details->can_change_selection != 0;
939 }
940
941 static void selection_changed(GtkTreeSelection *selection,
942 gpointer user_data)
943 {
944 ViewDetails *view_details = VIEW_DETAILS(user_data);
945
946 filer_selection_changed(view_details->filer_window,
947 gtk_get_current_event_time());
948 }
949
950 #define ADD_TEXT_COLUMN(name, model_column) \
951 cell = gtk_cell_renderer_text_new(); \
952 column = gtk_tree_view_column_new_with_attributes(name, cell, \
953 "text", model_column, \
954 "foreground-gdk", COL_COLOUR, \
955 "weight", COL_WEIGHT, \
956 NULL); \
957 gtk_tree_view_append_column(treeview, column); \
958 g_signal_connect(column->button, "grab-focus", \
959 G_CALLBACK(block_focus), view_details);
960
961 static void view_details_init(GTypeInstance *object, gpointer gclass)
962 {
963 GtkTreeView *treeview = (GtkTreeView *) object;
964 GtkTreeViewColumn *column;
965 GtkCellRenderer *cell;
966 GtkTreeSortable *sortable_list;
967 ViewDetails *view_details = (ViewDetails *) object;
968
969 view_details->items = g_ptr_array_new();
970 view_details->cursor_base = -1;
971 view_details->wink_item = -1;
972 view_details->desired_size.width = -1;
973 view_details->desired_size.height = -1;
974 view_details->can_change_selection = 0;
975 view_details->lasso_box = FALSE;
976
977 view_details->selection = gtk_tree_view_get_selection(treeview);
978 gtk_tree_selection_set_mode(view_details->selection,
979 GTK_SELECTION_MULTIPLE);
980 gtk_tree_selection_set_select_function(view_details->selection,
981 test_can_change_selection, view_details, NULL);
982 g_signal_connect(view_details->selection, "changed",
983 G_CALLBACK(selection_changed), view_details);
984
985 /* Sorting */
986 view_details->sort_fn = NULL;
987 sortable_list = GTK_TREE_SORTABLE(object);
988
989 gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(view_details));
990
991 /* Icon */
992 cell = cell_icon_new(view_details);
993 column = gtk_tree_view_column_new_with_attributes(NULL, cell,
994 "item", COL_VIEW_ITEM,
995 NULL);
996 gtk_tree_view_append_column(treeview, column);
997
998 ADD_TEXT_COLUMN(_("_Name"), COL_LEAF);
999 gtk_tree_view_column_set_sort_column_id(column, COL_LEAF);
1000 gtk_tree_view_column_set_resizable(column, TRUE);
1001 ADD_TEXT_COLUMN(_("_Type"), COL_TYPE);
1002 gtk_tree_view_column_set_sort_column_id(column, COL_TYPE);
1003 ADD_TEXT_COLUMN(_("_Permissions"), COL_PERM);
1004 ADD_TEXT_COLUMN(_("_Owner"), COL_OWNER);
1005 gtk_tree_view_column_set_sort_column_id(column, COL_OWNER);
1006 ADD_TEXT_COLUMN(_("_Group"), COL_GROUP);
1007 gtk_tree_view_column_set_sort_column_id(column, COL_GROUP);
1008 ADD_TEXT_COLUMN(_("_Size"), COL_SIZE);
1009 gtk_tree_view_column_set_sort_column_id(column, COL_SIZE);
1010 ADD_TEXT_COLUMN(_("Last _Modified"), COL_MTIME);
1011 gtk_tree_view_column_set_sort_column_id(column, COL_MTIME);
1012 }
1013
1014 /* Create the handers for the View interface */
1015 static void view_details_iface_init(gpointer giface, gpointer iface_data)
1016 {
1017 ViewIfaceClass *iface = giface;
1018
1019 g_assert(G_TYPE_FROM_INTERFACE(iface) == VIEW_TYPE_IFACE);
1020
1021 /* override stuff */
1022 iface->sort = view_details_sort;
1023 iface->style_changed = view_details_style_changed;
1024 iface->add_items = view_details_add_items;
1025 iface->update_items = view_details_update_items;
1026 iface->delete_if = view_details_delete_if;
1027 iface->clear = view_details_clear;
1028 iface->select_all = view_details_select_all;
1029 iface->clear_selection = view_details_clear_selection;
1030 iface->count_items = view_details_count_items;
1031 iface->count_selected = view_details_count_selected;
1032 iface->show_cursor = view_details_show_cursor;
1033 iface->get_iter = view_details_get_iter;
1034 iface->get_iter_at_point = view_details_get_iter_at_point;
1035 iface->cursor_to_iter = view_details_cursor_to_iter;
1036 iface->set_selected = view_details_set_selected;
1037 iface->get_selected = view_details_get_selected;
1038 iface->set_frozen = view_details_set_frozen;
1039 iface->select_only = view_details_select_only;
1040 iface->wink_item = view_details_wink_item;
1041 iface->autosize = view_details_autosize;
1042 iface->cursor_visible = view_details_cursor_visible;
1043 iface->set_base = view_details_set_base;
1044 iface->start_lasso_box = view_details_start_lasso_box;
1045 iface->extend_tip = view_details_extend_tip;
1046 iface->auto_scroll_callback = view_details_auto_scroll_callback;
1047 }
1048
1049 /* Implementations of the View interface. See view_iface.c for comments. */
1050
1051 static void view_details_style_changed(ViewIface *view, int flags)
1052 {
1053 ViewDetails *view_details = (ViewDetails *) view;
1054 GtkTreeModel *model = (GtkTreeModel *) view;
1055 GtkTreePath *path;
1056 ViewItem **items = (ViewItem **) view_details->items->pdata;
1057 int i;
1058 int n = view_details->items->len;
1059
1060 path = gtk_tree_path_new();
1061 gtk_tree_path_append_index(path, 0);
1062
1063 for (i = 0; i < n; i++)
1064 {
1065 GtkTreeIter iter;
1066 ViewItem *item = items[i];
1067
1068 iter.user_data = GINT_TO_POINTER(i);
1069 if (item->image)
1070 {
1071 g_object_unref(G_OBJECT(item->image));
1072 item->image = NULL;
1073 }
1074 gtk_tree_model_row_changed(model, path, &iter);
1075 gtk_tree_path_next(path);
1076 }
1077
1078 gtk_tree_path_free(path);
1079
1080 gtk_tree_view_columns_autosize((GtkTreeView *) view);
1081
1082 if (flags & VIEW_UPDATE_HEADERS)
1083 details_update_header_visibility(view_details);
1084 }
1085
1086 static gint wrap_sort(gconstpointer a, gconstpointer b,
1087 ViewDetails *view_details)
1088 {
1089 ViewItem *ia = *(ViewItem **) a;
1090 ViewItem *ib = *(ViewItem **) b;
1091
1092 if (view_details->filer_window->sort_order == GTK_SORT_ASCENDING)
1093 return view_details->sort_fn(ia->item, ib->item);
1094 else
1095 return -view_details->sort_fn(ia->item, ib->item);
1096 }
1097
1098 static void resort(ViewDetails *view_details)
1099 {
1100 ViewItem **items = (ViewItem **) view_details->items->pdata;
1101 gint i, len = view_details->items->len;
1102 guint *new_order;
1103 GtkTreePath *path;
1104 int wink_item = view_details->wink_item;
1105
1106 if (!len)
1107 return;
1108
1109 for (i = len - 1; i >= 0; i--)
1110 items[i]->old_pos = i;
1111
1112 switch (view_details->filer_window->sort_type)
1113 {
1114 case SORT_NAME: view_details->sort_fn = sort_by_name; break;
1115 case SORT_TYPE: view_details->sort_fn = sort_by_type; break;
1116 case SORT_DATE: view_details->sort_fn = sort_by_date; break;
1117 case SORT_SIZE: view_details->sort_fn = sort_by_size; break;
1118 case SORT_OWNER: view_details->sort_fn = sort_by_owner; break;
1119 case SORT_GROUP: view_details->sort_fn = sort_by_group; break;
1120 default:
1121 g_assert_not_reached();
1122 }
1123
1124 g_ptr_array_sort_with_data(view_details->items,
1125 (GCompareDataFunc) wrap_sort,
1126 view_details);
1127
1128 new_order = g_new(guint, len);
1129 for (i = len - 1; i >= 0; i--)
1130 {
1131 new_order[i] = items[i]->old_pos;
1132 if (wink_item == items[i]->old_pos)
1133 wink_item = i;
1134 }
1135
1136 view_details->wink_item = wink_item;
1137
1138 path = gtk_tree_path_new();
1139 gtk_tree_model_rows_reordered((GtkTreeModel *) view_details,
1140 path, NULL, new_order);
1141 gtk_tree_path_free(path);
1142 g_free(new_order);
1143 }
1144
1145 static void view_details_sort(ViewIface *view)
1146 {
1147 resort((ViewDetails *) view);
1148 gtk_tree_sortable_sort_column_changed((GtkTreeSortable *) view);
1149 }
1150
1151 static void view_details_add_items(ViewIface *view, GPtrArray *new_items)
1152 {
1153 ViewDetails *view_details = (ViewDetails *) view;
1154 FilerWindow *filer_window = view_details->filer_window;
1155 gboolean show_hidden = filer_window->show_hidden;
1156 GPtrArray *items = view_details->items;
1157 GtkTreeIter iter;
1158 int i;
1159 GtkTreePath *path;
1160 GtkTreeModel *model = (GtkTreeModel *) view;
1161
1162 iter.user_data = GINT_TO_POINTER(items->len);
1163 path = details_get_path(model, &iter);
1164
1165 for (i = 0; i < new_items->len; i++)
1166 {
1167 DirItem *item = (DirItem *) new_items->pdata[i];
1168 char *leafname = item->leafname;
1169 ViewItem *vitem;
1170
1171 if (leafname[0] == '.')
1172 {
1173 if (!show_hidden)
1174 continue;
1175
1176 if (leafname[1] == '\0')
1177 continue; /* Never show '.' */
1178
1179 if (leafname[1] == '.' &&
1180 leafname[2] == '\0')
1181 continue; /* Never show '..' */
1182 }
1183
1184 vitem = g_new(ViewItem, 1);
1185 vitem->item = item;
1186 vitem->image = NULL;
1187 if (!g_utf8_validate(leafname, -1, NULL))
1188 vitem->utf8_name = to_utf8(leafname);
1189 else
1190 vitem->utf8_name = NULL;
1191
1192 g_ptr_array_add(items, vitem);
1193
1194 iter.user_data = GINT_TO_POINTER(items->len - 1);
1195 gtk_tree_model_row_inserted(model, path, &iter);
1196 gtk_tree_path_next(path);
1197 }
1198
1199 gtk_tree_path_free(path);
1200
1201 resort(view_details);
1202 }
1203
1204 /* Find an item in the sorted array.
1205 * Returns the item number, or -1 if not found.
1206 */
1207 static int details_find_item(ViewDetails *view_details, DirItem *item)
1208 {
1209 ViewItem **items, tmp, *tmpp;
1210 int lower, upper;
1211
1212 g_return_val_if_fail(view_details != NULL, -1);
1213 g_return_val_if_fail(item != NULL, -1);
1214
1215 tmp.item = item;
1216 tmpp = &tmp;
1217
1218 items = (ViewItem **) view_details->items->pdata;
1219
1220 /* If item is here, then: lower <= i < upper */
1221 lower = 0;
1222 upper = view_details->items->len;
1223
1224 while (lower < upper)
1225 {
1226 int i, cmp;
1227
1228 i = (lower + upper) >> 1;
1229
1230 cmp = wrap_sort(&items[i], &tmpp, view_details);
1231 if (cmp == 0)
1232 return i;
1233
1234 if (cmp > 0)
1235 upper = i;
1236 else
1237 lower = i + 1;
1238 }
1239
1240 return -1;
1241 }
1242
1243 static void view_details_update_items(ViewIface *view, GPtrArray *items)
1244 {
1245 ViewDetails *view_details = (ViewDetails *) view;
1246 FilerWindow *filer_window = view_details->filer_window;
1247 int i;
1248 GtkTreeModel *model = (GtkTreeModel *) view_details;
1249
1250 g_return_if_fail(items->len > 0);
1251
1252 /* The item data has already been modified, so this gives the
1253 * final sort order...
1254 */
1255 resort(view_details);
1256
1257 for (i = 0; i < items->len; i++)
1258 {
1259 DirItem *item = (DirItem *) items->pdata[i];
1260 const gchar *leafname = item->leafname;
1261 int j;
1262
1263 if (leafname[0] == '.' && filer_window->show_hidden == FALSE)
1264 continue;
1265
1266 j = details_find_item(view_details, item);
1267
1268 if (j < 0)
1269 g_warning("Failed to find '%s'\n", leafname);
1270 else
1271 {
1272 GtkTreePath *path;
1273 GtkTreeIter iter;
1274 ViewItem *view_item = view_details->items->pdata[j];
1275 if (view_item->image)
1276 {
1277 g_object_unref(G_OBJECT(view_item->image));
1278 view_item->image = NULL;
1279 }
1280 path = gtk_tree_path_new();
1281 gtk_tree_path_append_index(path, j);
1282 iter.user_data = GINT_TO_POINTER(j);
1283 gtk_tree_model_row_changed(model, path, &iter);
1284 }
1285 }
1286 }
1287
1288 static void view_details_delete_if(ViewIface *view,
1289 gboolean (*test)(gpointer item, gpointer data),
1290 gpointer data)
1291 {
1292 GtkTreePath *path;
1293 ViewDetails *view_details = (ViewDetails *) view;
1294 int i = 0;
1295 GPtrArray *items = view_details->items;
1296 GtkTreeModel *model = (GtkTreeModel *) view;
1297
1298 path = gtk_tree_path_new();
1299
1300 gtk_tree_path_append_index(path, i);
1301
1302 while (i < items->len)
1303 {
1304 ViewItem *item = items->pdata[i];
1305
1306 if (test(item->item, data))
1307 {
1308 free_view_item(items->pdata[i]);
1309 g_ptr_array_remove_index(items, i);
1310 gtk_tree_model_row_deleted(model, path);
1311 }
1312 else
1313 {
1314 i++;
1315 gtk_tree_path_next(path);
1316 }
1317 }
1318
1319 gtk_tree_path_free(path);
1320 }
1321
1322 static void view_details_clear(ViewIface *view)
1323 {
1324 GtkTreePath *path;
1325 GPtrArray *items = ((ViewDetails *) view)->items;
1326 GtkTreeModel *model = (GtkTreeModel *) view;
1327
1328 path = gtk_tree_path_new();
1329 gtk_tree_path_append_index(path, items->len);
1330
1331 while (gtk_tree_path_prev(path))
1332 gtk_tree_model_row_deleted(model, path);
1333
1334 g_ptr_array_set_size(items, 0);
1335 gtk_tree_path_free(path);
1336 }
1337
1338 static void view_details_select_all(ViewIface *view)
1339 {
1340 ViewDetails *view_details = (ViewDetails *) view;
1341
1342 view_details->can_change_selection++;
1343 gtk_tree_selection_select_all(view_details->selection);
1344 view_details->can_change_selection--;
1345 }
1346
1347 static void view_details_clear_selection(ViewIface *view)
1348 {
1349 ViewDetails *view_details = (ViewDetails *) view;
1350
1351 view_details->can_change_selection++;
1352 gtk_tree_selection_unselect_all(view_details->selection);
1353 view_details->can_change_selection--;
1354 }
1355
1356 static int view_details_count_items(ViewIface *view)
1357 {
1358 ViewDetails *view_details = (ViewDetails *) view;
1359
1360 return view_details->items->len;
1361 }
1362
1363 #if GTK_MINOR_VERSION < 2
1364 static void view_details_count_inc(GtkTreeModel *model, GtkTreePath *path,
1365 GtkTreeIter *iter, gpointer data)
1366 {
1367 int *count = (int *) data;
1368 (*count) += 1;
1369 }
1370 #endif
1371
1372 static int view_details_count_selected(ViewIface *view)
1373 {
1374 ViewDetails *view_details = (ViewDetails *) view;
1375
1376 #if GTK_MINOR_VERSION >= 2
1377 return gtk_tree_selection_count_selected_rows(view_details->selection);
1378 #else
1379 int count = 0;
1380
1381 gtk_tree_selection_selected_foreach(view_details->selection,
1382 view_details_count_inc, &count);
1383 return count;
1384 #endif
1385 }
1386
1387 static void view_details_show_cursor(ViewIface *view)
1388 {
1389 }
1390
1391 static void view_details_get_iter(ViewIface *view,
1392 ViewIter *iter, IterFlags flags)
1393 {
1394 make_iter((ViewDetails *) view, iter, flags);
1395 }
1396
1397 static void view_details_get_iter_at_point(ViewIface *view, ViewIter *iter,
1398 GdkWindow *src, int x, int y)
1399 {
1400 ViewDetails *view_details = (ViewDetails *) view;
1401 GtkTreeModel *model;
1402 GtkTreeView *tree = (GtkTreeView *) view;
1403 GtkTreePath *path = NULL;
1404 int i = -1;
1405 gint cell_y;
1406
1407 model = gtk_tree_view_get_model(tree);
1408
1409 if (gtk_tree_view_get_path_at_pos(tree, x, y + 4, &path, NULL,
1410 NULL, &cell_y))
1411 {
1412 g_return_if_fail(path != NULL);
1413
1414 if (cell_y > 8)
1415 i = gtk_tree_path_get_indices(path)[0];
1416 gtk_tree_path_free(path);
1417 }
1418
1419 make_item_iter(view_details, iter, i);
1420 }
1421
1422 static void view_details_cursor_to_iter(ViewIface *view, ViewIter *iter)
1423 {
1424 GtkTreePath *path;
1425 ViewDetails *view_details = (ViewDetails *) view;
1426
1427 path = gtk_tree_path_new();
1428
1429 if (iter)
1430 gtk_tree_path_append_index(path, iter->i);
1431 else
1432 {
1433 /* Using depth zero or index -1 gives an error, but this
1434 * is OK!
1435 */
1436 gtk_tree_path_append_index(path, view_details->items->len);
1437 }
1438
1439 gtk_tree_view_set_cursor((GtkTreeView *) view, path, NULL, FALSE);
1440 gtk_tree_path_free(path);
1441 }
1442
1443 static void set_selected(ViewDetails *view_details, int i, gboolean selected)
1444 {
1445 GtkTreeIter iter;
1446
1447 iter.user_data = GINT_TO_POINTER(i);
1448 view_details->can_change_selection++;
1449 if (selected)
1450 gtk_tree_selection_select_iter(view_details->selection, &iter);
1451 else
1452 gtk_tree_selection_unselect_iter(view_details->selection,
1453 &iter);
1454 view_details->can_change_selection--;
1455 }
1456
1457 static void view_details_set_selected(ViewIface *view,
1458 ViewIter *iter,
1459 gboolean selected)
1460 {
1461 set_selected((ViewDetails *) view, iter->i, selected);
1462 }
1463
1464 static gboolean get_selected(ViewDetails *view_details, int i)
1465 {
1466 GtkTreeIter iter;
1467
1468 iter.user_data = GINT_TO_POINTER(i);
1469
1470 return gtk_tree_selection_iter_is_selected(view_details->selection,
1471 &iter);
1472 }
1473
1474 static gboolean view_details_get_selected(ViewIface *view, ViewIter *iter)
1475 {
1476 return get_selected((ViewDetails *) view, iter->i);
1477 }
1478
1479 static void view_details_select_only(ViewIface *view, ViewIter *iter)
1480 {
1481 ViewDetails *view_details = (ViewDetails *) view;
1482 GtkTreePath *path;
1483
1484 path = gtk_tree_path_new();
1485 gtk_tree_path_append_index(path, iter->i);
1486 view_details->can_change_selection++;
1487 gtk_tree_selection_unselect_all(view_details->selection);
1488 gtk_tree_selection_select_range(view_details->selection, path, path);
1489 view_details->can_change_selection--;
1490 gtk_tree_path_free(path);
1491 }
1492
1493 static void view_details_set_frozen(ViewIface *view, gboolean frozen)
1494 {
1495 }
1496
1497 static void redraw_wink_area(ViewDetails *view_details)
1498 {
1499 GtkTreePath *wink_path;
1500 GdkRectangle wink_area;
1501 GtkTreeView *tree = (GtkTreeView *) view_details;
1502
1503 g_return_if_fail(view_details->wink_item >= 0);
1504
1505 wink_path = gtk_tree_path_new();
1506 gtk_tree_path_append_index(wink_path, view_details->wink_item);
1507 gtk_tree_view_get_background_area(tree, wink_path, NULL, &wink_area);
1508 gtk_tree_path_free(wink_path);
1509
1510 if (wink_area.height)
1511 {
1512 GdkWindow *window;
1513 window = gtk_tree_view_get_bin_window(tree);
1514
1515 wink_area.width = GTK_WIDGET(tree)->allocation.width;
1516 gdk_window_invalidate_rect(window, &wink_area, FALSE);
1517 }
1518 }
1519
1520 static void cancel_wink(ViewDetails *view_details)
1521 {
1522 if (view_details->wink_item == -1)
1523 return;
1524
1525 if (view_details->filer_window)
1526 redraw_wink_area(view_details);
1527
1528 view_details->wink_item = -1;
1529 g_source_remove(view_details->wink_timeout);
1530 }
1531
1532 static gboolean wink_timeout(ViewDetails *view_details)
1533 {
1534 view_details->wink_step--;
1535 if (view_details->wink_step < 1)
1536 {
1537 cancel_wink(view_details);
1538 return FALSE;
1539 }
1540
1541 redraw_wink_area(view_details);
1542
1543 return TRUE;
1544 }
1545
1546 static void view_details_wink_item(ViewIface *view, ViewIter *iter)
1547 {
1548 ViewDetails *view_details = (ViewDetails *) view;
1549 GtkTreePath *path;
1550
1551 cancel_wink(view_details);
1552 if (!iter)
1553 return;
1554
1555 view_details->wink_item = iter->i;
1556 view_details->wink_timeout = g_timeout_add(70,
1557 (GSourceFunc) wink_timeout, view_details);
1558 view_details->wink_step = 7;
1559 redraw_wink_area(view_details);
1560
1561 path = gtk_tree_path_new();
1562 gtk_tree_path_append_index(path, iter->i);
1563 gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(view),
1564 path, NULL, FALSE, 0, 0);
1565 gtk_tree_path_free(path);
1566 }
1567
1568 static void view_details_autosize(ViewIface *view)
1569 {
1570 ViewDetails *view_details = (ViewDetails *) view;
1571 FilerWindow *filer_window = view_details->filer_window;
1572 int max_width = (o_filer_size_limit.int_value * screen_width) / 100;
1573 int max_height = (o_filer_size_limit.int_value * screen_height) / 100;
1574 int h;
1575 GtkRequisition req;
1576
1577 gtk_widget_queue_resize(GTK_WIDGET(view));
1578 gtk_widget_size_request(GTK_WIDGET(view), &req);
1579
1580 h = MAX(view_details->desired_size.height, SMALL_HEIGHT);
1581
1582 filer_window_set_size(filer_window,
1583 MIN(view_details->desired_size.width, max_width),
1584 MIN(h, max_height));
1585 }
1586
1587 static gboolean view_details_cursor_visible(ViewIface *view)
1588 {
1589 GtkTreePath *path = NULL;
1590
1591 gtk_tree_view_get_cursor((GtkTreeView *) view, &path, NULL);
1592
1593 if (path)
1594 gtk_tree_path_free(path);
1595
1596 return path != NULL;
1597 }
1598
1599 static void view_details_set_base(ViewIface *view, ViewIter *iter)
1600 {
1601 ViewDetails *view_details = (ViewDetails *) view;
1602
1603 view_details->cursor_base = iter->i;
1604 }
1605
1606 /* Change the dynamic corner of the lasso box and trigger a redraw */
1607 static void set_lasso(ViewDetails *view_details, int x, int y)
1608 {
1609 GdkWindow *window;
1610 GdkRectangle area;
1611 int minx, miny, maxx, maxy;
1612
1613 if (x == view_details->drag_box_x[1] &&
1614 y == view_details->drag_box_y[1])
1615 return;
1616
1617 /* Get old region */
1618 minx = MIN(view_details->drag_box_x[0], view_details->drag_box_x[1]);
1619 miny = MIN(view_details->drag_box_y[0], view_details->drag_box_y[1]);
1620 maxx = MAX(view_details->drag_box_x[0], view_details->drag_box_x[1]);
1621 maxy = MAX(view_details->drag_box_y[0], view_details->drag_box_y[1]);
1622
1623 /* Enlarge to cover new point */
1624 minx = MIN(minx, x);
1625 miny = MIN(miny, y);
1626 maxx = MAX(maxx, x);
1627 maxy = MAX(maxy, y);
1628
1629 area.x = minx;
1630 area.y = miny;
1631 area.width = maxx - minx;
1632 area.height = maxy - miny;
1633
1634 view_details->drag_box_x[1] = x;
1635 view_details->drag_box_y[1] = y;
1636
1637 window = gtk_tree_view_get_bin_window((GtkTreeView *) view_details);
1638 if (area.width && area.height)
1639 {
1640 GtkAdjustment *adj;
1641
1642 adj = gtk_tree_view_get_vadjustment((GtkTreeView *)
1643 view_details);
1644 area.y -= adj->value;
1645 gdk_window_invalidate_rect(window, &area, FALSE);
1646 }
1647 }
1648
1649 static void view_details_start_lasso_box(ViewIface *view, GdkEventButton *event)
1650 {
1651 ViewDetails *view_details = (ViewDetails *) view;
1652 GtkAdjustment *adj;
1653
1654 adj = gtk_tree_view_get_vadjustment((GtkTreeView *) view_details);
1655
1656 view_details->lasso_start_index = get_lasso_index(view_details,
1657 event->y);
1658
1659 filer_set_autoscroll(view_details->filer_window, TRUE);
1660
1661 view_details->drag_box_x[0] = view_details->drag_box_x[1] = event->x;
1662 view_details->drag_box_y[0] = view_details->drag_box_y[1] = event->y +
1663 adj->value;
1664 view_details->lasso_box = TRUE;
1665 }
1666
1667 static void view_details_extend_tip(ViewIface *view,
1668 ViewIter *iter, GString *tip)
1669 {
1670 }
1671
1672 static DirItem *iter_init(ViewIter *iter)
1673 {
1674 ViewDetails *view_details = (ViewDetails *) iter->view;
1675 int i = -1;
1676 int n = view_details->items->len;
1677 int flags = iter->flags;
1678
1679 iter->peek = iter_peek;
1680
1681 if (iter->n_remaining == 0)
1682 return NULL;
1683
1684 if (flags & VIEW_ITER_FROM_CURSOR)
1685 {
1686 GtkTreePath *path;
1687 gtk_tree_view_get_cursor((GtkTreeView *) view_details,
1688 &path, NULL);
1689 if (!path)
1690 return NULL; /* No cursor */
1691 i = gtk_tree_path_get_indices(path)[0];
1692 gtk_tree_path_free(path);
1693 }
1694 else if (flags & VIEW_ITER_FROM_BASE)
1695 i = view_details->cursor_base;
1696
1697 if (i < 0 || i >= n)
1698 {
1699 /* Either a normal iteration, or an iteration from an
1700 * invalid starting point.
1701 */
1702 if (flags & VIEW_ITER_BACKWARDS)
1703 i = n - 1;
1704 else
1705 i = 0;
1706 }
1707
1708 if (i < 0 || i >= n)
1709 return NULL; /* No items at all! */
1710
1711 iter->next = flags & VIEW_ITER_BACKWARDS ? iter_prev : iter_next;
1712 iter->n_remaining--;
1713 iter->i = i;
1714
1715 if (flags & VIEW_ITER_SELECTED && !is_selected(view_details, i))
1716 return iter->next(iter);
1717 return iter->peek(iter);
1718 }
1719
1720 static DirItem *iter_prev(ViewIter *iter)
1721 {
1722 ViewDetails *view_details = (ViewDetails *) iter->view;
1723 int n = view_details->items->len;
1724 int i = iter->i;
1725
1726 g_return_val_if_fail(iter->n_remaining >= 0, NULL);
1727
1728 /* i is the last item returned (always valid) */
1729
1730 g_return_val_if_fail(i >= 0 && i < n, NULL);
1731
1732 while (iter->n_remaining)
1733 {
1734 i--;
1735 iter->n_remaining--;
1736
1737 if (i == -1)
1738 i = n - 1;
1739
1740 g_return_val_if_fail(i >= 0 && i < n, NULL);
1741
1742 if (iter->flags & VIEW_ITER_SELECTED &&
1743 !is_selected(view_details, i))
1744 continue;
1745
1746 iter->i = i;
1747 return ((ViewItem *) view_details->items->pdata[i])->item;
1748 }
1749
1750 iter->i = -1;
1751 return NULL;
1752 }
1753
1754 static DirItem *iter_next(ViewIter *iter)
1755 {
1756 ViewDetails *view_details = (ViewDetails *) iter->view;
1757 int n = view_details->items->len;
1758 int i = iter->i;
1759
1760 g_return_val_if_fail(iter->n_remaining >= 0, NULL);
1761
1762 /* i is the last item returned (always valid) */
1763
1764 g_return_val_if_fail(i >= 0 && i < n, NULL);
1765
1766 while (iter->n_remaining)
1767 {
1768 i++;
1769 iter->n_remaining--;
1770
1771 if (i == n)
1772 i = 0;
1773
1774 g_return_val_if_fail(i >= 0 && i < n, NULL);
1775
1776 if (iter->flags & VIEW_ITER_SELECTED &&
1777 !is_selected(view_details, i))
1778 continue;
1779
1780 iter->i = i;
1781 return ((ViewItem *) view_details->items->pdata[i])->item;
1782 }
1783
1784 iter->i = -1;
1785 return NULL;
1786 }
1787
1788 static DirItem *iter_peek(ViewIter *iter)
1789 {
1790 ViewDetails *view_details = (ViewDetails *) iter->view;
1791 int n = view_details->items->len;
1792 int i = iter->i;
1793
1794 if (i == -1)
1795 return NULL;
1796
1797 g_return_val_if_fail(i >= 0 && i < n, NULL);
1798
1799 return ((ViewItem *) view_details->items->pdata[i])->item;
1800 }
1801
1802 /* Set the iterator to return 'i' on the next peek().
1803 * If i is -1, returns NULL on next peek().
1804 */
1805 static void make_item_iter(ViewDetails *view_details, ViewIter *iter, int i)
1806 {
1807 make_iter(view_details, iter, 0);
1808
1809 g_return_if_fail(i >= -1 && i < (int) view_details->items->len);
1810
1811 iter->i = i;
1812 iter->next = iter_next;
1813 iter->peek = iter_peek;
1814 iter->n_remaining = 0;
1815 }
1816
1817 static void make_iter(ViewDetails *view_details, ViewIter *iter,
1818 IterFlags flags)
1819 {
1820 iter->view = (ViewIface *) view_details;
1821 iter->next = iter_init;
1822 iter->peek = NULL;
1823 iter->i = -1;
1824
1825 iter->flags = flags;
1826
1827 if (flags & VIEW_ITER_ONE_ONLY)
1828 {
1829 iter->n_remaining = 1;
1830 iter->next(iter);
1831 }
1832 else
1833 iter->n_remaining = view_details->items->len;
1834 }
1835
1836 static void free_view_item(ViewItem *view_item)
1837 {
1838 if (view_item->image)
1839 g_object_unref(G_OBJECT(view_item->image));
1840 g_free(view_item->utf8_name);
1841 g_free(view_item);
1842 }
1843
1844 static gboolean view_details_auto_scroll_callback(ViewIface *view)
1845 {
1846 GtkTreeView *tree = (GtkTreeView *) view;
1847 ViewDetails *view_details = (ViewDetails *) view;
1848 FilerWindow *filer_window = view_details->filer_window;
1849 GtkRange *scrollbar = (GtkRange *) filer_window->scrollbar;
1850 GtkAdjustment *adj;
1851 GdkWindow *window;
1852 gint x, y, w, h;
1853 GdkModifierType mask;
1854 int diff = 0;
1855
1856 window = gtk_tree_view_get_bin_window(tree);
1857
1858 gdk_window_get_pointer(window, &x, &y, &mask);
1859 gdk_drawable_get_size(window, &w, NULL);
1860
1861 adj = gtk_range_get_adjustment(scrollbar);
1862 h = adj->page_size;
1863
1864 if ((x < 0 || x > w || y < 0 || y > h)) /* && !view->lasso_box) */
1865 return FALSE; /* Out of window - stop */
1866
1867 if (y < AUTOSCROLL_STEP)
1868 diff = y - AUTOSCROLL_STEP;
1869 else if (y > h - AUTOSCROLL_STEP)
1870 diff = AUTOSCROLL_STEP + y - h;
1871
1872 if (diff)
1873 {
1874 int old = adj->value;
1875 int value = old + diff;
1876
1877 value = CLAMP(value, 0, adj->upper - adj->page_size);
1878 gtk_adjustment_set_value(adj, value);
1879
1880 if (adj->value != old)
1881 dnd_spring_abort();
1882 }
1883
1884 return TRUE;
1885 }
Filer for the ROX desktop