?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r4255: Make Path optional in PanelRemove SOAP call, allowing removal of items based
[rox-filer/translations.git] / ROX-Filer / src / filer.c
blobf57ca276ee12b3919c28472111d4ea8bc4ece6c1
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 /* filer.c - code for handling filer windows */
23
24 #include "config.h"
25
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <string.h>
29 #include <errno.h>
30 #include <ctype.h>
31 #include <netdb.h>
32 #include <sys/param.h>
33 #include <fnmatch.h>
34
35 #include <gtk/gtk.h>
36 #include <gdk/gdkx.h>
37 #include <gdk/gdkkeysyms.h>
38
39 #include "global.h"
40
41 #include "filer.h"
42 #include "display.h"
43 #include "main.h"
44 #include "fscache.h"
45 #include "support.h"
46 #include "gui_support.h"
47 #include "choices.h"
48 #include "pixmaps.h"
49 #include "menu.h"
50 #include "dnd.h"
51 #include "dir.h"
52 #include "diritem.h"
53 #include "run.h"
54 #include "type.h"
55 #include "options.h"
56 #include "minibuffer.h"
57 #include "icon.h"
58 #include "toolbar.h"
59 #include "bind.h"
60 #include "appinfo.h"
61 #include "mount.h"
62 #include "xml.h"
63 #include "view_iface.h"
64 #include "view_collection.h"
65 #include "view_details.h"
66 #include "action.h"
67 #include "bookmarks.h"
68
69 static XMLwrapper *groups = NULL;
70
71 /* Item we are about to display a tooltip for */
72 static DirItem *tip_item = NULL;
73
74 /* The window which the motion event for the tooltip came from. Use this
75 * to get the correct widget for finding the item under the pointer.
76 */
77 static GdkWindow *motion_window = NULL;
78
79 /* This is rather badly named. It's actually the filer window which received
80 * the last key press or Menu click event.
81 */
82 FilerWindow *window_with_focus = NULL;
83
84 GList *all_filer_windows = NULL;
85
86 static GHashTable *window_with_id = NULL;
87
88 static FilerWindow *window_with_primary = NULL;
89
90 static GHashTable *settings_table=NULL;
91
92 typedef struct {
93 gchar *path;
94
95 guint flags; /* Which parts are valid, see below */
96
97 gint x, y;
98 gint width, height;
99 gboolean show_hidden;
100 ViewType view_type;
101 SortType sort_type;
102 GtkSortType sort_order;
103 gboolean show_thumbs;
104
105 DetailsType details_type;
106 DisplayStyle display_style;
107
108 FilterType filter_type;
109 char *filter;
110 } Settings;
111
112 enum settings_flags{
113 SET_POSITION=1, /* x, y */
114 SET_SIZE=2, /* width, height */
115 SET_HIDDEN=4, /* show_hidden */
116 SET_STYLE=8, /* display_style */
117 SET_SORT=16, /* sort_type, sort_order */
118 SET_DETAILS=32, /* view_type, details_type */
119 SET_THUMBS=64, /* show_thumbs */
120 SET_FILTER=128, /* filter_type, filter */
121 };
122
123 /* Static prototypes */
124 static void attach(FilerWindow *filer_window);
125 static void detach(FilerWindow *filer_window);
126 static void filer_window_destroyed(GtkWidget *widget,
127 FilerWindow *filer_window);
128 static void update_display(Directory *dir,
129 DirAction action,
130 GPtrArray *items,
131 FilerWindow *filer_window);
132 static void set_scanning_display(FilerWindow *filer_window, gboolean scanning);
133 static gboolean may_rescan(FilerWindow *filer_window, gboolean warning);
134 static gboolean minibuffer_show_cb(FilerWindow *filer_window);
135 static FilerWindow *find_filer_window(const char *sym_path, FilerWindow *diff);
136 static void filer_add_widgets(FilerWindow *filer_window, const gchar *wm_class);
137 static void filer_add_signals(FilerWindow *filer_window);
138
139 static void set_selection_state(FilerWindow *filer_window, gboolean normal);
140 static void filer_next_thumb(GObject *window, const gchar *path);
141 static void start_thumb_scanning(FilerWindow *filer_window);
142 static void filer_options_changed(void);
143 static void drag_end(GtkWidget *widget, GdkDragContext *context,
144 FilerWindow *filer_window);
145 static void drag_leave(GtkWidget *widget,
146 GdkDragContext *context,
147 guint32 time,
148 FilerWindow *filer_window);
149 static gboolean drag_motion(GtkWidget *widget,
150 GdkDragContext *context,
151 gint x,
152 gint y,
153 guint time,
154 FilerWindow *filer_window);
155
156 static void load_settings(void);
157 static void save_settings(void);
158 static void check_settings(FilerWindow *filer_window);
159 static char *tip_from_desktop_file(const char *full_path);
160
161 static GdkCursor *busy_cursor = NULL;
162 static GdkCursor *crosshair = NULL;
163
164 /* Indicates whether the filer's display is different to the machine it
165 * is actually running on.
166 */
167 static gboolean not_local = FALSE;
168
169 static Option o_short_flag_names;
170 static Option o_filer_view_type;
171 Option o_filer_auto_resize, o_unique_filer_windows;
172 Option o_filer_size_limit;
173
174 void filer_init(void)
175 {
176 const gchar *ohost;
177 const gchar *dpy;
178 gchar *dpyhost, *tmp;
179
180 option_add_int(&o_filer_size_limit, "filer_size_limit", 75);
181 option_add_int(&o_filer_auto_resize, "filer_auto_resize",
182 RESIZE_ALWAYS);
183 option_add_int(&o_unique_filer_windows, "filer_unique_windows", 0);
184
185 option_add_int(&o_short_flag_names, "filer_short_flag_names", FALSE);
186
187 option_add_int(&o_filer_view_type, "filer_view_type",
188 VIEW_TYPE_COLLECTION);
189
190 option_add_notify(filer_options_changed);
191
192 busy_cursor = gdk_cursor_new(GDK_WATCH);
193 crosshair = gdk_cursor_new(GDK_CROSSHAIR);
194
195 window_with_id = g_hash_table_new_full(g_str_hash, g_str_equal,
196 NULL, NULL);
197
198 /* Is the display on the local machine, or are we being
199 * run remotely? See filer_set_title().
200 */
201 ohost = our_host_name();
202 dpy = gdk_get_display();
203 dpyhost = g_strdup(dpy);
204 tmp = strchr(dpyhost, ':');
205 if (tmp)
206 *tmp = '\0';
207
208 if (dpyhost[0] && strcmp(ohost, dpyhost) != 0)
209 {
210 /* Try the cannonical name for dpyhost (see our_host_name()
211 * in support.c).
212 */
213 struct hostent *ent;
214
215 ent = gethostbyname(dpyhost);
216 if (!ent || strcmp(ohost, ent->h_name) != 0)
217 not_local = TRUE;
218 }
219
220 g_free(dpyhost);
221
222 load_settings();
223 }
224
225 static gboolean if_deleted(gpointer item, gpointer removed)
226 {
227 int i = ((GPtrArray *) removed)->len;
228 DirItem **r = (DirItem **) ((GPtrArray *) removed)->pdata;
229 char *leafname = ((DirItem *) item)->leafname;
230
231 while (i--)
232 {
233 if (strcmp(leafname, r[i]->leafname) == 0)
234 return TRUE;
235 }
236
237 return FALSE;
238 }
239
240 #define DECOR_BORDER 32
241
242 /* Resize the filer window to w x h pixels, plus border (not clamped).
243 * If triggered by a key event, warp the pointer (for SloppyFocus users).
244 */
245 void filer_window_set_size(FilerWindow *filer_window, int w, int h)
246 {
247 GtkWidget *window;
248
249 g_return_if_fail(filer_window != NULL);
250
251 if (filer_window->scrollbar)
252 w += filer_window->scrollbar->allocation.width;
253
254 if (o_toolbar.int_value != TOOLBAR_NONE)
255 h += filer_window->toolbar->allocation.height;
256 if (filer_window->message)
257 h += filer_window->message->allocation.height;
258
259 window = filer_window->window;
260
261 if (GTK_WIDGET_VISIBLE(window))
262 {
263 gint x, y, m;
264 GtkRequisition *req = &window->requisition;
265 GdkWindow *gdk_window = window->window;
266 GdkEvent *event;
267
268 w = MAX(req->width, w);
269 h = MAX(req->height, h);
270 gdk_window_get_pointer(NULL, &x, &y, NULL);
271 m = gdk_screen_get_monitor_at_point(gdk_screen_get_default(),
272 x, y);
273 gdk_window_get_position(gdk_window, &x, &y);
274
275 if (x + w + DECOR_BORDER >
276 monitor_geom[m].x + monitor_geom[m].width ||
277 y + h + DECOR_BORDER >
278 monitor_geom[m].y + monitor_geom[m].height)
279 {
280 if (x + w + DECOR_BORDER >
281 monitor_geom[m].x + monitor_geom[m].width)
282 {
283 x = monitor_geom[m].x + monitor_geom[m].width -
284 w - 4 - DECOR_BORDER;
285 }
286 if (y + h + DECOR_BORDER >
287 monitor_geom[m].y + monitor_geom[m].height)
288 {
289 y = monitor_geom[m].y + monitor_geom[m].height -
290 h - 4 - DECOR_BORDER;
291 }
292 gdk_window_move_resize(gdk_window, x, y, w, h);
293 }
294 else
295 gdk_window_resize(gdk_window, w, h);
296
297 /* If the resize was triggered by a key press, keep
298 * the pointer inside the window so that it doesn't
299 * lose focus when using pointer-follows-mouse.
300 */
301 event = gtk_get_current_event();
302 if (event && event->type == GDK_KEY_PRESS)
303 {
304 int x, y;
305 int nx, ny;
306
307 GdkWindow *win = filer_window->window->window;
308
309 gdk_window_get_pointer(filer_window->window->window,
310 &x, &y, NULL);
311
312 nx = CLAMP(x, 4, w - 4);
313 ny = CLAMP(y, 4, h - 4);
314
315 if (nx != x || ny != y)
316 {
317 XWarpPointer(gdk_x11_drawable_get_xdisplay(win),
318 None,
319 gdk_x11_drawable_get_xid(win),
320 0, 0, 0, 0,
321 nx, ny);
322 }
323 }
324 if (event)
325 gdk_event_free(event);
326 }
327 else
328 gtk_window_set_default_size(GTK_WINDOW(window), w, h);
329 }
330
331 /* Called on a timeout while scanning or when scanning ends
332 * (whichever happens first).
333 */
334 static gint open_filer_window(FilerWindow *filer_window)
335 {
336 Settings *dir_settings;
337 gboolean force_resize;
338
339 dir_settings = (Settings *) g_hash_table_lookup(settings_table,
340 filer_window->sym_path);
341
342 force_resize = !(o_filer_auto_resize.int_value == RESIZE_NEVER &&
343 dir_settings && dir_settings->flags & SET_POSITION);
344
345 view_style_changed(filer_window->view, 0);
346
347 if (filer_window->open_timeout)
348 {
349 g_source_remove(filer_window->open_timeout);
350 filer_window->open_timeout = 0;
351 }
352
353 if (!GTK_WIDGET_VISIBLE(filer_window->window))
354 {
355 display_set_actual_size(filer_window, force_resize);
356 gtk_widget_show(filer_window->window);
357 }
358
359 return FALSE;
360 }
361
362 /* Look through all items we want to display, and queue a recheck on any
363 * that require it.
364 */
365 static void queue_interesting(FilerWindow *filer_window)
366 {
367 DirItem *item;
368 ViewIter iter;
369
370 view_get_iter(filer_window->view, &iter, 0);
371 while ((item = iter.next(&iter)))
372 {
373 if (item->flags & ITEM_FLAG_NEED_RESCAN_QUEUE)
374 dir_queue_recheck(filer_window->directory, item);
375 }
376 }
377
378 static void update_display(Directory *dir,
379 DirAction action,
380 GPtrArray *items,
381 FilerWindow *filer_window)
382 {
383 ViewIface *view = (ViewIface *) filer_window->view;
384
385 switch (action)
386 {
387 case DIR_ADD:
388 view_add_items(view, items);
389 /* Open and resize if currently hidden */
390 open_filer_window(filer_window);
391 break;
392 case DIR_REMOVE:
393 view_delete_if(view, if_deleted, items);
394 toolbar_update_info(filer_window);
395 break;
396 case DIR_START_SCAN:
397 set_scanning_display(filer_window, TRUE);
398 toolbar_update_info(filer_window);
399 break;
400 case DIR_END_SCAN:
401 if (filer_window->window->window)
402 gdk_window_set_cursor(
403 filer_window->window->window,
404 NULL);
405 set_scanning_display(filer_window, FALSE);
406 toolbar_update_info(filer_window);
407 open_filer_window(filer_window);
408
409 if (filer_window->had_cursor &&
410 !view_cursor_visible(view))
411 {
412 ViewIter start;
413 view_get_iter(view, &start, 0);
414 if (start.next(&start))
415 view_cursor_to_iter(view, &start);
416 view_show_cursor(view);
417 filer_window->had_cursor = FALSE;
418 }
419 if (filer_window->auto_select)
420 display_set_autoselect(filer_window,
421 filer_window->auto_select);
422 null_g_free(&filer_window->auto_select);
423
424 filer_create_thumbs(filer_window);
425
426 if (filer_window->thumb_queue)
427 start_thumb_scanning(filer_window);
428 break;
429 case DIR_UPDATE:
430 view_update_items(view, items);
431 break;
432 case DIR_ERROR_CHANGED:
433 filer_set_title(filer_window);
434 break;
435 case DIR_QUEUE_INTERESTING:
436 queue_interesting(filer_window);
437 break;
438 }
439 }
440
441 static void attach(FilerWindow *filer_window)
442 {
443 gdk_window_set_cursor(filer_window->window->window, busy_cursor);
444 view_clear(filer_window->view);
445 filer_window->scanning = TRUE;
446 dir_attach(filer_window->directory, (DirCallback) update_display,
447 filer_window);
448 filer_set_title(filer_window);
449 bookmarks_add_history(filer_window->sym_path);
450
451 if (filer_window->directory->error)
452 {
453 if (spring_in_progress)
454 g_printerr(_("Error scanning '%s':\n%s\n"),
455 filer_window->sym_path,
456 filer_window->directory->error);
457 else
458 delayed_error(_("Error scanning '%s':\n%s"),
459 filer_window->sym_path,
460 filer_window->directory->error);
461 }
462 }
463
464 static void detach(FilerWindow *filer_window)
465 {
466 g_return_if_fail(filer_window->directory != NULL);
467
468 dir_detach(filer_window->directory,
469 (DirCallback) update_display, filer_window);
470 g_object_unref(filer_window->directory);
471 filer_window->directory = NULL;
472 }
473
474 /* If 'start' was mounted by ROX-Filer, return it. Otherwise, try the
475 * parents up the tree.
476 * NULL if we're not in a user mount point.
477 * g_free() the result.
478 */
479 static char *get_ancestor_user_mount_point(const char *start)
480 {
481 char *path;
482
483 path = strdup(start);
484
485 while (1)
486 {
487 char *slash;
488
489 if (mount_is_user_mounted(path))
490 return path;
491
492 if (!path[1])
493 {
494 g_free(path);
495 return NULL;
496 }
497
498 slash = strrchr(path + 1, '/');
499 if (!slash)
500 slash = path + 1;
501 *slash = '\0';
502 }
503 }
504
505 static void umount_dialog_response(GtkWidget *dialog, int response, char *mount)
506 {
507 if (response == GTK_RESPONSE_OK)
508 {
509 GList *list;
510
511 list = g_list_prepend(NULL, mount);
512 action_mount(list, FALSE, FALSE, TRUE);
513 g_list_free(list);
514 }
515
516 g_free(mount);
517
518 gtk_widget_destroy(dialog);
519
520 one_less_window();
521 }
522
523 /* 'filer_window' shows a directory under 'mount'. If no other window also
524 * shows a directory under it, display a non-modal dialog offering to
525 * unmount the directory.
526 * 'mount' is freed by this function, either directly, or after the dialog
527 * closes.
528 */
529 static void may_offer_unmount(FilerWindow *filer_window, char *mount)
530 {
531 GtkWidget *dialog, *button;
532 GList *next;
533 int len;
534
535 len = strlen(mount);
536
537 for (next = all_filer_windows; next; next = next->next)
538 {
539 FilerWindow *other = (FilerWindow *) next->data;
540
541 if (other == filer_window)
542 continue;
543
544 if (strncmp(filer_window->real_path, other->real_path,
545 len) != 0)
546 continue;
547
548 g_return_if_fail(
549 filer_window->real_path[len] != '/' ||
550 filer_window->real_path[len] != '\0');
551
552 if (other->real_path[len] != '/' &&
553 other->real_path[len] != '\0')
554 continue;
555
556 /* Found another window. Don't offer to unmount. */
557 g_free(mount);
558 return;
559 }
560
561 dialog = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_QUESTION,
562 GTK_BUTTONS_NONE,
563 _("Do you want to unmount this device?\n\n"
564 "Unmounting a device makes it safe to remove "
565 "the disk."), mount);
566
567 button = button_new_mixed(ROX_STOCK_MOUNTED, _("No change"));
568 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
569 gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button,
570 GTK_RESPONSE_CANCEL);
571 gtk_widget_show(button);
572
573 button = button_new_mixed(ROX_STOCK_MOUNT, _("Unmount"));
574 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
575 gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button,
576 GTK_RESPONSE_OK);
577 gtk_widget_show(button);
578
579 g_signal_connect(G_OBJECT(dialog), "response",
580 G_CALLBACK(umount_dialog_response), mount);
581
582 gtk_dialog_set_default_response(GTK_DIALOG(dialog),
583 GTK_RESPONSE_OK);
584
585 number_of_windows++;
586 gtk_widget_show(dialog);
587 }
588
589 /* Returns TRUE to prevent closing the window. May offer to unmount a
590 * device.
591 */
592 gboolean filer_window_delete(GtkWidget *window,
593 GdkEvent *unused, /* (may be NULL) */
594 FilerWindow *filer_window)
595 {
596 char *mount;
597
598 mount = get_ancestor_user_mount_point(filer_window->real_path);
599
600 if (mount)
601 may_offer_unmount(filer_window, mount);
602
603 return FALSE;
604 }
605
606 static void filer_window_destroyed(GtkWidget *widget, FilerWindow *filer_window)
607 {
608 all_filer_windows = g_list_remove(all_filer_windows, filer_window);
609
610 g_object_set_data(G_OBJECT(widget), "filer_window", NULL);
611
612 if (window_with_primary == filer_window)
613 window_with_primary = NULL;
614
615 if (window_with_focus == filer_window)
616 {
617 menu_popdown();
618 window_with_focus = NULL;
619 }
620
621 if (filer_window->directory)
622 detach(filer_window);
623
624 if (filer_window->open_timeout)
625 {
626 g_source_remove(filer_window->open_timeout);
627 filer_window->open_timeout = 0;
628 }
629
630 if (filer_window->auto_scroll != -1)
631 {
632 g_source_remove(filer_window->auto_scroll);
633 filer_window->auto_scroll = -1;
634 }
635
636 if (filer_window->thumb_queue)
637 destroy_glist(&filer_window->thumb_queue);
638
639 tooltip_show(NULL);
640
641 filer_set_id(filer_window, NULL);
642
643 if(filer_window->filter_string)
644 g_free(filer_window->filter_string);
645 if(filer_window->regexp)
646 g_free(filer_window->regexp);
647
648 g_free(filer_window->auto_select);
649 g_free(filer_window->real_path);
650 g_free(filer_window->sym_path);
651 g_free(filer_window);
652
653 one_less_window();
654 }
655
656 /* Returns TRUE iff the directory still exists. */
657 static gboolean may_rescan(FilerWindow *filer_window, gboolean warning)
658 {
659 Directory *dir;
660
661 g_return_val_if_fail(filer_window != NULL, FALSE);
662
663 /* We do a fresh lookup (rather than update) because the inode may
664 * have changed.
665 */
666 dir = g_fscache_lookup(dir_cache, filer_window->real_path);
667 if (!dir)
668 {
669 if (warning)
670 info_message(_("Directory missing/deleted"));
671 gtk_widget_destroy(filer_window->window);
672 return FALSE;
673 }
674 if (dir == filer_window->directory)
675 g_object_unref(dir);
676 else
677 {
678 detach(filer_window);
679 filer_window->directory = dir;
680 attach(filer_window);
681 }
682
683 return TRUE;
684 }
685
686 /* No items are now selected. This might be because another app claimed
687 * the selection or because the user unselected all the items.
688 */
689 void filer_lost_selection(FilerWindow *filer_window, guint time)
690 {
691 if (window_with_primary == filer_window)
692 {
693 window_with_primary = NULL;
694 gtk_selection_owner_set(NULL, GDK_SELECTION_PRIMARY, time);
695 }
696 }
697
698 /* Another app has claimed the primary selection */
699 static void filer_lost_primary(GtkWidget *window,
700 GdkEventSelection *event,
701 gpointer user_data)
702 {
703 FilerWindow *filer_window = (FilerWindow *) user_data;
704
705 if (window_with_primary && window_with_primary == filer_window)
706 {
707 window_with_primary = NULL;
708 set_selection_state(filer_window, FALSE);
709 }
710 }
711
712 /* Someone wants us to send them the selection */
713 static void selection_get(GtkWidget *widget,
714 GtkSelectionData *selection_data,
715 guint info,
716 guint time,
717 gpointer data)
718 {
719 GString *reply, *header;
720 FilerWindow *filer_window = (FilerWindow *) data;
721 ViewIter iter;
722 DirItem *item;
723
724 reply = g_string_new(NULL);
725 header = g_string_new(NULL);
726
727 switch (info)
728 {
729 case TARGET_STRING:
730 g_string_printf(header, " %s",
731 make_path(filer_window->sym_path, ""));
732 break;
733 case TARGET_URI_LIST:
734 g_string_printf(header, " file://%s%s",
735 our_host_name_for_dnd(),
736 make_path(filer_window->sym_path, ""));
737 break;
738 }
739
740 view_get_iter(filer_window->view, &iter, VIEW_ITER_SELECTED);
741
742 while ((item = iter.next(&iter)))
743 {
744 g_string_append(reply, header->str);
745 g_string_append(reply, item->leafname);
746 }
747
748 if (reply->len > 0)
749 gtk_selection_data_set_text(selection_data,
750 reply->str + 1, reply->len - 1);
751 else
752 {
753 g_warning("Attempt to paste empty selection!");
754 gtk_selection_data_set_text(selection_data, "", 0);
755 }
756
757 g_string_free(reply, TRUE);
758 g_string_free(header, TRUE);
759 }
760
761 /* Selection has been changed -- try to grab the primary selection
762 * if we don't have it. Also called when clicking on an insensitive selection
763 * to regain primary.
764 * Also updates toolbar info.
765 */
766 void filer_selection_changed(FilerWindow *filer_window, gint time)
767 {
768 toolbar_update_info(filer_window);
769
770 if (window_with_primary == filer_window)
771 return; /* Already got primary */
772
773 if (!view_count_selected(filer_window->view))
774 return; /* Nothing selected */
775
776 if (filer_window->temp_item_selected == FALSE &&
777 gtk_selection_owner_set(GTK_WIDGET(filer_window->window),
778 GDK_SELECTION_PRIMARY,
779 time))
780 {
781 window_with_primary = filer_window;
782 set_selection_state(filer_window, TRUE);
783 }
784 else
785 set_selection_state(filer_window, FALSE);
786 }
787
788 /* Open the item (or add it to the shell command minibuffer) */
789 void filer_openitem(FilerWindow *filer_window, ViewIter *iter, OpenFlags flags)
790 {
791 gboolean shift = (flags & OPEN_SHIFT) != 0;
792 gboolean close_mini = flags & OPEN_FROM_MINI;
793 gboolean close_window = (flags & OPEN_CLOSE_WINDOW) != 0;
794 DirItem *item;
795 const guchar *full_path;
796 gboolean wink = TRUE;
797 Directory *old_dir;
798
799 g_return_if_fail(filer_window != NULL && iter != NULL);
800
801 item = iter->peek(iter);
802
803 g_return_if_fail(item != NULL);
804
805 if (filer_window->mini_type == MINI_SHELL)
806 {
807 minibuffer_add(filer_window, item->leafname);
808 return;
809 }
810
811 if (item->base_type == TYPE_UNKNOWN)
812 dir_update_item(filer_window->directory, item->leafname);
813
814 if (item->base_type == TYPE_DIRECTORY)
815 {
816 /* Never close a filer window when opening a directory
817 * (click on a dir or click on an app with shift).
818 */
819 if (shift || !(item->flags & ITEM_FLAG_APPDIR))
820 close_window = FALSE;
821 }
822
823 full_path = make_path(filer_window->sym_path, item->leafname);
824 if (shift && (item->flags & ITEM_FLAG_SYMLINK))
825 wink = FALSE;
826
827 old_dir = filer_window->directory;
828 if (run_diritem(full_path, item,
829 flags & OPEN_SAME_WINDOW ? filer_window : NULL,
830 filer_window,
831 shift))
832 {
833 if (old_dir != filer_window->directory)
834 return;
835
836 if (close_window)
837 gtk_widget_destroy(filer_window->window);
838 else
839 {
840 if (wink)
841 view_wink_item(filer_window->view, iter);
842 if (close_mini)
843 minibuffer_hide(filer_window);
844 }
845 }
846 }
847
848 static gint pointer_in(GtkWidget *widget,
849 GdkEventCrossing *event,
850 FilerWindow *filer_window)
851 {
852 may_rescan(filer_window, TRUE);
853 return FALSE;
854 }
855
856 static gint pointer_out(GtkWidget *widget,
857 GdkEventCrossing *event,
858 FilerWindow *filer_window)
859 {
860 tooltip_show(NULL);
861 return FALSE;
862 }
863
864 /* Move the cursor to the next selected item in direction 'dir'
865 * (+1 or -1).
866 */
867 void filer_next_selected(FilerWindow *filer_window, int dir)
868 {
869 ViewIter iter, cursor;
870 gboolean have_cursor;
871 ViewIface *view = filer_window->view;
872
873 g_return_if_fail(dir == 1 || dir == -1);
874
875 view_get_cursor(view, &cursor);
876 have_cursor = cursor.peek(&cursor) != NULL;
877
878 view_get_iter(view, &iter,
879 VIEW_ITER_SELECTED |
880 (have_cursor ? VIEW_ITER_FROM_CURSOR : 0) |
881 (dir < 0 ? VIEW_ITER_BACKWARDS : 0));
882
883 if (have_cursor && view_get_selected(view, &cursor))
884 iter.next(&iter); /* Skip the cursor itself */
885
886 if (iter.next(&iter))
887 view_cursor_to_iter(view, &iter);
888 else
889 gdk_beep();
890
891 return;
892 }
893
894 static void return_pressed(FilerWindow *filer_window, GdkEventKey *event)
895 {
896 TargetFunc cb = filer_window->target_cb;
897 gpointer data = filer_window->target_data;
898 OpenFlags flags = 0;
899 ViewIter iter;
900
901 filer_target_mode(filer_window, NULL, NULL, NULL);
902
903 view_get_cursor(filer_window->view, &iter);
904 if (!iter.peek(&iter))
905 return;
906
907 if (cb)
908 {
909 cb(filer_window, &iter, data);
910 return;
911 }
912
913 if (event->state & GDK_SHIFT_MASK)
914 flags |= OPEN_SHIFT;
915 if (event->state & GDK_MOD1_MASK)
916 flags |= OPEN_CLOSE_WINDOW;
917 else
918 flags |= OPEN_SAME_WINDOW;
919
920 filer_openitem(filer_window, &iter, flags);
921 }
922
923 /* Makes sure that 'groups' is up-to-date, reloading from file if it has
924 * changed. If no groups were loaded and there is no file then initialised
925 * groups to an empty document.
926 * Return the node for the 'name' group.
927 */
928 static xmlNode *group_find(char *name)
929 {
930 xmlNode *node;
931 gchar *path;
932
933 /* Update the groups, if possible */
934 path = choices_find_xdg_path_load("Groups.xml", PROJECT, SITE);
935 if (path)
936 {
937 XMLwrapper *wrapper;
938 wrapper = xml_cache_load(path);
939 if (wrapper)
940 {
941 if (groups)
942 g_object_unref(groups);
943 groups = wrapper;
944 }
945
946 g_free(path);
947 }
948
949 if (!groups)
950 {
951 groups = xml_new(NULL);
952 groups->doc = xmlNewDoc("1.0");
953
954 xmlDocSetRootElement(groups->doc,
955 xmlNewDocNode(groups->doc, NULL, "groups", NULL));
956 return NULL;
957 }
958
959 node = xmlDocGetRootElement(groups->doc);
960
961 for (node = node->xmlChildrenNode; node; node = node->next)
962 {
963 guchar *gid;
964
965 gid = xmlGetProp(node, "name");
966
967 if (!gid)
968 continue;
969
970 if (strcmp(name, gid) != 0)
971 continue;
972
973 g_free(gid);
974
975 return node;
976 }
977
978 return NULL;
979 }
980
981 static void group_save(FilerWindow *filer_window, char *name)
982 {
983 xmlNode *group;
984 guchar *save_path;
985 DirItem *item;
986 ViewIter iter;
987
988 group = group_find(name);
989 if (group)
990 {
991 xmlUnlinkNode(group);
992 xmlFreeNode(group);
993 }
994 group = xmlNewChild(xmlDocGetRootElement(groups->doc),
995 NULL, "group", NULL);
996 xmlSetProp(group, "name", name);
997
998 xmlNewTextChild(group, NULL, "directory", filer_window->sym_path);
999
1000 view_get_iter(filer_window->view, &iter, VIEW_ITER_SELECTED);
1001
1002 while ((item = iter.next(&iter)))
1003 xmlNewTextChild(group, NULL, "item", item->leafname);
1004
1005 save_path = choices_find_xdg_path_save("Groups.xml", PROJECT, SITE,
1006 TRUE);
1007 if (save_path)
1008 {
1009 save_xml_file(groups->doc, save_path);
1010 g_free(save_path);
1011 }
1012 }
1013
1014 static gboolean group_restore_cb(ViewIter *iter, gpointer data)
1015 {
1016 GHashTable *in_group = (GHashTable *) data;
1017
1018 return g_hash_table_lookup(in_group,
1019 iter->peek(iter)->leafname) != NULL;
1020 }
1021
1022 static void group_restore(FilerWindow *filer_window, char *name)
1023 {
1024 GHashTable *in_group;
1025 char *path;
1026 xmlNode *group, *node;
1027
1028 group = group_find(name);
1029
1030 if (!group)
1031 {
1032 report_error(_("Group %s is not set. Select some files "
1033 "and press Ctrl+%s to set the group. Press %s "
1034 "on its own to reselect the files later.\n"
1035 "Make sure NumLock is on if you use the keypad."),
1036 name, name, name);
1037 return;
1038 }
1039
1040 node = get_subnode(group, NULL, "directory");
1041 g_return_if_fail(node != NULL);
1042 path = xmlNodeListGetString(groups->doc, node->xmlChildrenNode, 1);
1043 g_return_if_fail(path != NULL);
1044
1045 if (strcmp(path, filer_window->sym_path) != 0)
1046 filer_change_to(filer_window, path, NULL);
1047 g_free(path);
1048
1049 in_group = g_hash_table_new(g_str_hash, g_str_equal);
1050 for (node = group->xmlChildrenNode; node; node = node->next)
1051 {
1052 gchar *leaf;
1053 if (node->type != XML_ELEMENT_NODE)
1054 continue;
1055 if (strcmp(node->name, "item") != 0)
1056 continue;
1057
1058 leaf = xmlNodeListGetString(groups->doc,
1059 node->xmlChildrenNode, 1);
1060 if (!leaf)
1061 g_warning("Missing leafname!\n");
1062 else
1063 g_hash_table_insert(in_group, leaf, filer_window);
1064 }
1065
1066 view_select_if(filer_window->view, &group_restore_cb, in_group);
1067
1068 g_hash_table_foreach(in_group, (GHFunc) g_free, NULL);
1069 g_hash_table_destroy(in_group);
1070 }
1071
1072 static gboolean popup_menu(GtkWidget *widget, FilerWindow *filer_window)
1073 {
1074 ViewIter iter;
1075 GdkEvent *event;
1076
1077 view_get_cursor(filer_window->view, &iter);
1078
1079 event = gtk_get_current_event();
1080 show_filer_menu(filer_window, event, &iter);
1081 if (event)
1082 gdk_event_free(event);
1083
1084 return TRUE;
1085 }
1086
1087 void filer_window_toggle_cursor_item_selected(FilerWindow *filer_window)
1088 {
1089 ViewIface *view = filer_window->view;
1090 ViewIter iter;
1091
1092 view_get_iter(view, &iter, VIEW_ITER_FROM_CURSOR);
1093 if (!iter.next(&iter))
1094 return; /* No cursor */
1095
1096 if (view_get_selected(view, &iter))
1097 view_set_selected(view, &iter, FALSE);
1098 else
1099 view_set_selected(view, &iter, TRUE);
1100
1101 if (iter.next(&iter))
1102 view_cursor_to_iter(view, &iter);
1103 }
1104
1105 gint filer_key_press_event(GtkWidget *widget,
1106 GdkEventKey *event,
1107 FilerWindow *filer_window)
1108 {
1109 ViewIface *view = filer_window->view;
1110 ViewIter cursor;
1111 GtkWidget *focus = GTK_WINDOW(widget)->focus_widget;
1112 guint key = event->keyval;
1113 char group[2] = "1";
1114
1115 window_with_focus = filer_window;
1116
1117 /* Delay setting up the keys until now to speed loading... */
1118 if (ensure_filer_menu())
1119 {
1120 /* Gtk updates in an idle-handler, so force a recheck now */
1121 g_signal_emit_by_name(widget, "keys_changed");
1122 }
1123
1124 if (focus && focus == filer_window->minibuffer)
1125 if (gtk_widget_event(focus, (GdkEvent *) event))
1126 return TRUE; /* Handled */
1127
1128 if (!focus)
1129 gtk_widget_grab_focus(GTK_WIDGET(view));
1130
1131 view_get_cursor(view, &cursor);
1132 if (!cursor.peek(&cursor) && (key == GDK_Up || key == GDK_Down))
1133 {
1134 ViewIter iter;
1135 view_get_iter(view, &iter, 0);
1136 if (iter.next(&iter))
1137 view_cursor_to_iter(view, &iter);
1138 gtk_widget_grab_focus(GTK_WIDGET(view)); /* Needed? */
1139 return TRUE;
1140 }
1141
1142 switch (key)
1143 {
1144 case GDK_Escape:
1145 filer_target_mode(filer_window, NULL, NULL, NULL);
1146 view_cursor_to_iter(filer_window->view, NULL);
1147 view_clear_selection(filer_window->view);
1148 return FALSE;
1149 case GDK_Return:
1150 return_pressed(filer_window, event);
1151 break;
1152 case GDK_ISO_Left_Tab:
1153 filer_next_selected(filer_window, -1);
1154 break;
1155 case GDK_Tab:
1156 filer_next_selected(filer_window, 1);
1157 break;
1158 case GDK_BackSpace:
1159 change_to_parent(filer_window);
1160 break;
1161 case GDK_backslash:
1162 {
1163 ViewIter iter;
1164
1165 tooltip_show(NULL);
1166
1167 view_get_cursor(filer_window->view, &iter);
1168 show_filer_menu(filer_window,
1169 (GdkEvent *) event, &iter);
1170 break;
1171 }
1172 case ' ':
1173 filer_window_toggle_cursor_item_selected(filer_window);
1174 break;
1175 default:
1176 if (key >= GDK_0 && key <= GDK_9)
1177 group[0] = key - GDK_0 + '0';
1178 else if (key >= GDK_KP_0 && key <= GDK_KP_9)
1179 group[0] = key - GDK_KP_0 + '0';
1180 else
1181 {
1182 if (focus && focus != widget &&
1183 gtk_widget_get_toplevel(focus) == widget)
1184 if (gtk_widget_event(focus,
1185 (GdkEvent *) event))
1186 return TRUE; /* Handled */
1187 return FALSE;
1188 }
1189
1190 if (event->state & GDK_CONTROL_MASK)
1191 group_save(filer_window, group);
1192 else
1193 group_restore(filer_window, group);
1194 }
1195
1196 return TRUE;
1197 }
1198
1199 void filer_open_parent(FilerWindow *filer_window)
1200 {
1201 char *dir;
1202 const char *current = filer_window->sym_path;
1203
1204 if (current[0] == '/' && current[1] == '\0')
1205 return; /* Already in the root */
1206
1207 dir = g_path_get_dirname(current);
1208 filer_opendir(dir, filer_window, NULL);
1209 g_free(dir);
1210 }
1211
1212 void change_to_parent(FilerWindow *filer_window)
1213 {
1214 char *dir;
1215 const char *current = filer_window->sym_path;
1216
1217 if (current[0] == '/' && current[1] == '\0')
1218 return; /* Already in the root */
1219
1220 if (mount_is_user_mounted(filer_window->real_path))
1221 may_offer_unmount(filer_window,
1222 g_strdup(filer_window->real_path));
1223
1224 dir = g_path_get_dirname(current);
1225 filer_change_to(filer_window, dir, g_basename(current));
1226 g_free(dir);
1227 }
1228
1229 /* Removes trailing /s from path (modified in place) */
1230 static void tidy_sympath(gchar *path)
1231 {
1232 int l;
1233
1234 g_return_if_fail(path != NULL);
1235
1236 l = strlen(path);
1237 while (l > 1 && path[l - 1] == '/')
1238 {
1239 l--;
1240 path[l] = '\0';
1241 }
1242 }
1243
1244 /* Make filer_window display path. When finished, highlight item 'from', or
1245 * the first item if from is NULL. If there is currently no cursor then
1246 * simply wink 'from' (if not NULL).
1247 * If the cause was a key event and we resize, warp the pointer.
1248 */
1249 void filer_change_to(FilerWindow *filer_window,
1250 const char *path, const char *from)
1251 {
1252 char *from_dup;
1253 char *sym_path, *real_path;
1254 Directory *new_dir;
1255
1256 g_return_if_fail(filer_window != NULL);
1257
1258 filer_cancel_thumbnails(filer_window);
1259
1260 tooltip_show(NULL);
1261
1262 sym_path = g_strdup(path);
1263 real_path = pathdup(path);
1264 new_dir = g_fscache_lookup(dir_cache, real_path);
1265
1266 if (!new_dir)
1267 {
1268 delayed_error(_("Directory '%s' is not accessible"),
1269 sym_path);
1270 g_free(real_path);
1271 g_free(sym_path);
1272 return;
1273 }
1274
1275 if (o_unique_filer_windows.int_value && !spring_in_progress)
1276 {
1277 FilerWindow *fw;
1278
1279 fw = find_filer_window(sym_path, filer_window);
1280 if (fw)
1281 gtk_widget_destroy(fw->window);
1282 }
1283
1284 from_dup = from && *from ? g_strdup(from) : NULL;
1285
1286 detach(filer_window);
1287 g_free(filer_window->real_path);
1288 g_free(filer_window->sym_path);
1289 filer_window->real_path = real_path;
1290 filer_window->sym_path = sym_path;
1291 tidy_sympath(filer_window->sym_path);
1292
1293 filer_window->directory = new_dir;
1294
1295 g_free(filer_window->auto_select);
1296 filer_window->auto_select = from_dup;
1297
1298 filer_window->had_cursor = filer_window->had_cursor ||
1299 view_cursor_visible(filer_window->view);
1300
1301 filer_set_title(filer_window);
1302 if (filer_window->window->window)
1303 gdk_window_set_role(filer_window->window->window,
1304 filer_window->sym_path);
1305 view_cursor_to_iter(filer_window->view, NULL);
1306
1307 attach(filer_window);
1308
1309 check_settings(filer_window);
1310
1311 display_set_actual_size(filer_window, FALSE);
1312
1313 if (o_filer_auto_resize.int_value == RESIZE_ALWAYS)
1314 view_autosize(filer_window->view);
1315
1316 if (filer_window->mini_type == MINI_PATH)
1317 g_idle_add((GSourceFunc) minibuffer_show_cb, filer_window);
1318 }
1319
1320 /* Returns a list containing the full (sym) pathname of every selected item.
1321 * You must g_free() each item in the list.
1322 */
1323 GList *filer_selected_items(FilerWindow *filer_window)
1324 {
1325 GList *retval = NULL;
1326 guchar *dir = filer_window->sym_path;
1327 ViewIter iter;
1328 DirItem *item;
1329
1330 view_get_iter(filer_window->view, &iter, VIEW_ITER_SELECTED);
1331 while ((item = iter.next(&iter)))
1332 {
1333 retval = g_list_prepend(retval,
1334 g_strdup(make_path(dir, item->leafname)));
1335 }
1336
1337 return g_list_reverse(retval);
1338 }
1339
1340 /* Return the single selected item. Error if nothing is selected. */
1341 DirItem *filer_selected_item(FilerWindow *filer_window)
1342 {
1343 ViewIter iter;
1344 DirItem *item;
1345
1346 view_get_iter(filer_window->view, &iter, VIEW_ITER_SELECTED);
1347
1348 item = iter.next(&iter);
1349 g_return_val_if_fail(item != NULL, NULL);
1350 g_return_val_if_fail(iter.next(&iter) == NULL, NULL);
1351
1352 return item;
1353 }
1354
1355 /* Creates and shows a new filer window.
1356 * If src_win != NULL then display options can be taken from that source window.
1357 * Returns the new filer window, or NULL on error.
1358 * Note: if unique windows is in use, may return an existing window.
1359 */
1360 FilerWindow *filer_opendir(const char *path, FilerWindow *src_win,
1361 const gchar *wm_class)
1362 {
1363 FilerWindow *filer_window;
1364 char *real_path;
1365 DisplayStyle dstyle;
1366 DetailsType dtype;
1367 SortType s_type;
1368 GtkSortType s_order;
1369 Settings *dir_settings = NULL;
1370 gboolean force_resize = TRUE;
1371
1372 /* Get the real pathname of the directory and copy it */
1373 real_path = pathdup(path);
1374
1375 if (o_unique_filer_windows.int_value && !spring_in_progress)
1376 {
1377 FilerWindow *same_dir_window;
1378
1379 same_dir_window = find_filer_window(path, NULL);
1380
1381 if (same_dir_window)
1382 {
1383 gtk_window_present(GTK_WINDOW(same_dir_window->window));
1384 return same_dir_window;
1385 }
1386 }
1387
1388 filer_window = g_new(FilerWindow, 1);
1389 filer_window->message = NULL;
1390 filer_window->minibuffer = NULL;
1391 filer_window->minibuffer_label = NULL;
1392 filer_window->minibuffer_area = NULL;
1393 filer_window->temp_show_hidden = FALSE;
1394 filer_window->sym_path = g_strdup(path);
1395 filer_window->real_path = real_path;
1396 filer_window->scanning = FALSE;
1397 filer_window->had_cursor = FALSE;
1398 filer_window->auto_select = NULL;
1399 filer_window->toolbar_text = NULL;
1400 filer_window->target_cb = NULL;
1401 filer_window->mini_type = MINI_NONE;
1402 filer_window->selection_state = GTK_STATE_INSENSITIVE;
1403 filer_window->toolbar = NULL;
1404 filer_window->toplevel_vbox = NULL;
1405 filer_window->view_hbox = NULL;
1406 filer_window->view = NULL;
1407 filer_window->scrollbar = NULL;
1408 filer_window->auto_scroll = -1;
1409 filer_window->window_id = NULL;
1410
1411 tidy_sympath(filer_window->sym_path);
1412
1413 /* Finds the entry for this directory in the dir cache, creating
1414 * a new one if needed. This does not cause a scan to start,
1415 * so if a new entry is created then it will be empty.
1416 */
1417 filer_window->directory = g_fscache_lookup(dir_cache, real_path);
1418 if (!filer_window->directory)
1419 {
1420 delayed_error(_("Directory '%s' not found."), path);
1421 g_free(filer_window->real_path);
1422 g_free(filer_window->sym_path);
1423 g_free(filer_window);
1424 return NULL;
1425 }
1426
1427 filer_window->temp_item_selected = FALSE;
1428 filer_window->flags = (FilerFlags) 0;
1429 filer_window->details_type = DETAILS_TIMES;
1430 filer_window->display_style = UNKNOWN_STYLE;
1431 filer_window->display_style_wanted = UNKNOWN_STYLE;
1432 filer_window->thumb_queue = NULL;
1433 filer_window->max_thumbs = 0;
1434 filer_window->sort_type = -1;
1435
1436 filer_window->filter = FILER_SHOW_ALL;
1437 filer_window->filter_string = NULL;
1438 filer_window->regexp = NULL;
1439
1440 if (src_win && o_display_inherit_options.int_value)
1441 {
1442 s_type = src_win->sort_type;
1443 s_order = src_win->sort_order;
1444 dstyle = src_win->display_style_wanted;
1445 dtype = src_win->details_type;
1446 filer_window->show_hidden = src_win->show_hidden;
1447 filer_window->show_thumbs = src_win->show_thumbs;
1448 filer_window->view_type = src_win->view_type;
1449
1450 filer_set_filter(filer_window, src_win->filter,
1451 src_win->filter_string);
1452 }
1453 else
1454 {
1455 s_type = o_display_sort_by.int_value;
1456 s_order = GTK_SORT_ASCENDING;
1457 dstyle = o_display_size.int_value;
1458 dtype = o_display_details.int_value;
1459 filer_window->show_hidden = o_display_show_hidden.int_value;
1460 filer_window->show_thumbs = o_display_show_thumbs.int_value;
1461 filer_window->view_type = o_filer_view_type.int_value;
1462 }
1463
1464 dir_settings = (Settings *) g_hash_table_lookup(settings_table,
1465 filer_window->sym_path);
1466 if (dir_settings)
1467 {
1468 /* Override the current defaults with the per-directory
1469 * user settings.
1470 */
1471 if (dir_settings->flags & SET_HIDDEN)
1472 filer_window->show_hidden = dir_settings->show_hidden;
1473
1474 if (dir_settings->flags & SET_STYLE)
1475 dstyle = dir_settings->display_style;
1476
1477 if (dir_settings->flags & SET_DETAILS)
1478 {
1479 dtype = dir_settings->details_type;
1480 filer_window->view_type = dir_settings->view_type;
1481 }
1482
1483 if (dir_settings->flags & SET_SORT)
1484 {
1485 s_type = dir_settings->sort_type;
1486 s_order = dir_settings->sort_order;
1487 }
1488
1489 if (dir_settings->flags & SET_THUMBS)
1490 filer_window->show_thumbs = dir_settings->show_thumbs;
1491
1492 if (dir_settings->flags & SET_FILTER)
1493 filer_set_filter(filer_window,
1494 dir_settings->filter_type,
1495 dir_settings->filter);
1496 }
1497
1498 /* Add all the user-interface elements & realise */
1499 filer_add_widgets(filer_window, wm_class);
1500 if (src_win)
1501 gtk_window_set_position(GTK_WINDOW(filer_window->window),
1502 GTK_WIN_POS_MOUSE);
1503
1504 if (dir_settings)
1505 {
1506 if (dir_settings->flags & SET_POSITION)
1507 {
1508 gtk_window_move(GTK_WINDOW(filer_window->window),
1509 dir_settings->x, dir_settings->y);
1510 }
1511 if (dir_settings->flags & SET_SIZE)
1512 {
1513 filer_window_set_size(filer_window,
1514 dir_settings->width,
1515 dir_settings->height);
1516 force_resize = o_filer_auto_resize.int_value != RESIZE_NEVER;
1517 }
1518 }
1519
1520 /* Connect to all the signal handlers */
1521 filer_add_signals(filer_window);
1522
1523 display_set_layout(filer_window, dstyle, dtype, force_resize);
1524 display_set_sort_type(filer_window, s_type, s_order);
1525
1526 /* Open the window after a timeout, or when scanning stops.
1527 * Do this before attaching, because attach() might tell us to
1528 * stop scanning (if a scan isn't needed).
1529 */
1530 filer_window->open_timeout = g_timeout_add(500,
1531 (GSourceFunc) open_filer_window,
1532 filer_window);
1533
1534 /* The view is created empty and then attach() is called, which
1535 * links the filer window to the entry in the directory cache we
1536 * looked up / created above.
1537 *
1538 * The attach() function will immediately callback to the filer window
1539 * to deliver a list of all known entries in the directory (so,
1540 * the number of items will be known after attach() returns).
1541 *
1542 * If the directory was not in the cache (because it hadn't been
1543 * opened it before) then the types and icons for the entries are
1544 * not know, but the list of names is.
1545 */
1546
1547 attach(filer_window);
1548
1549 number_of_windows++;
1550 all_filer_windows = g_list_prepend(all_filer_windows, filer_window);
1551
1552 return filer_window;
1553 }
1554
1555 void filer_set_view_type(FilerWindow *filer_window, ViewType type)
1556 {
1557 GtkWidget *view = NULL;
1558 Directory *dir = NULL;
1559 GHashTable *selected = NULL;
1560
1561 g_return_if_fail(filer_window != NULL);
1562
1563 motion_window = NULL;
1564
1565 if (filer_window->view)
1566 {
1567 /* Save the current selection */
1568 ViewIter iter;
1569 DirItem *item;
1570
1571 selected = g_hash_table_new(g_str_hash, g_str_equal);
1572 view_get_iter(filer_window->view, &iter, VIEW_ITER_SELECTED);
1573 while ((item = iter.next(&iter)))
1574 g_hash_table_insert(selected, item->leafname, "yes");
1575
1576 /* Destroy the old view */
1577 gtk_widget_destroy(GTK_WIDGET(filer_window->view));
1578 filer_window->view = NULL;
1579
1580 dir = filer_window->directory;
1581 g_object_ref(dir);
1582 detach(filer_window);
1583 }
1584
1585 switch (type)
1586 {
1587 case VIEW_TYPE_COLLECTION:
1588 view = view_collection_new(filer_window);
1589 break;
1590 case VIEW_TYPE_DETAILS:
1591 view = view_details_new(filer_window);
1592 break;
1593 }
1594
1595 g_return_if_fail(view != NULL);
1596
1597 filer_window->view = VIEW(view);
1598 filer_window->view_type = type;
1599
1600 gtk_box_pack_start(filer_window->view_hbox, view, TRUE, TRUE, 0);
1601 gtk_widget_show(view);
1602
1603 /* Drag and drop events */
1604 make_drop_target(view, 0);
1605 g_signal_connect(view, "drag_motion",
1606 G_CALLBACK(drag_motion), filer_window);
1607 g_signal_connect(view, "drag_leave",
1608 G_CALLBACK(drag_leave), filer_window);
1609 g_signal_connect(view, "drag_end",
1610 G_CALLBACK(drag_end), filer_window);
1611 /* Dragging from us... */
1612 g_signal_connect(view, "drag_data_get",
1613 GTK_SIGNAL_FUNC(drag_data_get), NULL);
1614
1615 if (dir)
1616 {
1617 /* Only when changing type. Otherwise, will attach later. */
1618 filer_window->directory = dir;
1619 attach(filer_window);
1620
1621 if (o_filer_auto_resize.int_value != RESIZE_NEVER)
1622 view_autosize(filer_window->view);
1623 }
1624
1625 if (selected)
1626 {
1627 ViewIter iter;
1628 DirItem *item;
1629
1630 view_get_iter(filer_window->view, &iter, 0);
1631 while ((item = iter.next(&iter)))
1632 {
1633 if (g_hash_table_lookup(selected, item->leafname))
1634 view_set_selected(filer_window->view,
1635 &iter, TRUE);
1636 }
1637 g_hash_table_destroy(selected);
1638 }
1639 }
1640
1641 /* This adds all the widgets to a new filer window. It is in a separate
1642 * function because filer_opendir() was getting too long...
1643 */
1644 static void filer_add_widgets(FilerWindow *filer_window, const gchar *wm_class)
1645 {
1646 GtkWidget *hbox, *vbox;
1647
1648 /* Create the top-level window widget */
1649 filer_window->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1650 filer_set_title(filer_window);
1651 gtk_widget_set_name(filer_window->window, "rox-filer");
1652
1653 if (wm_class)
1654 gtk_window_set_wmclass(GTK_WINDOW(filer_window->window),
1655 wm_class, PROJECT);
1656
1657 /* This property is cleared when the window is destroyed.
1658 * You can thus ref filer_window->window and use this to see
1659 * if the window no longer exists.
1660 */
1661 g_object_set_data(G_OBJECT(filer_window->window),
1662 "filer_window", filer_window);
1663
1664 /* Create this now to make the Adjustment before the View */
1665 filer_window->scrollbar = gtk_vscrollbar_new(NULL);
1666
1667 vbox = gtk_vbox_new(FALSE, 0);
1668 gtk_container_add(GTK_CONTAINER(filer_window->window), vbox);
1669
1670 filer_window->toplevel_vbox = GTK_BOX(vbox);
1671
1672 /* If there's a message that should be displayed in each window (eg
1673 * 'Running as root'), add it here.
1674 */
1675 if (show_user_message)
1676 {
1677 filer_window->message = gtk_label_new(show_user_message);
1678 gtk_box_pack_start(GTK_BOX(vbox), filer_window->message,
1679 FALSE, TRUE, 0);
1680 gtk_widget_show(filer_window->message);
1681 }
1682
1683 hbox = gtk_hbox_new(FALSE, 0);
1684 filer_window->view_hbox = GTK_BOX(hbox);
1685 gtk_box_pack_start_defaults(GTK_BOX(vbox), hbox);
1686 /* Add the main View widget */
1687 filer_set_view_type(filer_window, filer_window->view_type);
1688 /* Put the scrollbar next to the View */
1689 gtk_box_pack_end(GTK_BOX(hbox),
1690 filer_window->scrollbar, FALSE, TRUE, 0);
1691 gtk_widget_show(hbox);
1692
1693 /* If we want a toolbar, create it now */
1694 toolbar_update_toolbar(filer_window);
1695
1696 /* And the minibuffer (hidden to start with) */
1697 create_minibuffer(filer_window);
1698 gtk_box_pack_end(GTK_BOX(vbox), filer_window->minibuffer_area,
1699 FALSE, TRUE, 0);
1700
1701 /* And the thumbnail progress bar (also hidden) */
1702 {
1703 GtkWidget *cancel;
1704
1705 filer_window->thumb_bar = gtk_hbox_new(FALSE, 2);
1706 gtk_box_pack_end(GTK_BOX(vbox), filer_window->thumb_bar,
1707 FALSE, TRUE, 0);
1708
1709 filer_window->thumb_progress = gtk_progress_bar_new();
1710
1711 gtk_box_pack_start(GTK_BOX(filer_window->thumb_bar),
1712 filer_window->thumb_progress, TRUE, TRUE, 0);
1713
1714 cancel = gtk_button_new_with_label(_("Cancel"));
1715 GTK_WIDGET_UNSET_FLAGS(cancel, GTK_CAN_FOCUS);
1716 gtk_box_pack_start(GTK_BOX(filer_window->thumb_bar),
1717 cancel, FALSE, TRUE, 0);
1718 g_signal_connect_swapped(cancel, "clicked",
1719 G_CALLBACK(filer_cancel_thumbnails),
1720 filer_window);
1721 }
1722
1723 gtk_widget_show(vbox);
1724 gtk_widget_show(filer_window->scrollbar);
1725
1726 gtk_widget_realize(filer_window->window);
1727
1728 gdk_window_set_role(filer_window->window->window,
1729 filer_window->sym_path);
1730
1731 filer_window_set_size(filer_window, 4, 4);
1732 }
1733
1734 static void filer_add_signals(FilerWindow *filer_window)
1735 {
1736 GtkTargetEntry target_table[] =
1737 {
1738 {"text/uri-list", 0, TARGET_URI_LIST},
1739 {"UTF8_STRING", 0, TARGET_STRING},
1740 {"STRING", 0, TARGET_STRING},
1741 {"COMPOUND_TEXT", 0, TARGET_STRING},/* XXX: Treats as STRING */
1742 };
1743
1744 /* Events on the top-level window */
1745 gtk_widget_add_events(filer_window->window, GDK_ENTER_NOTIFY);
1746 g_signal_connect(filer_window->window, "enter-notify-event",
1747 G_CALLBACK(pointer_in), filer_window);
1748 g_signal_connect(filer_window->window, "leave-notify-event",
1749 G_CALLBACK(pointer_out), filer_window);
1750 g_signal_connect(filer_window->window, "destroy",
1751 G_CALLBACK(filer_window_destroyed), filer_window);
1752 g_signal_connect(filer_window->window, "delete-event",
1753 G_CALLBACK(filer_window_delete), filer_window);
1754
1755 g_signal_connect(filer_window->window, "selection_clear_event",
1756 G_CALLBACK(filer_lost_primary), filer_window);
1757
1758 g_signal_connect(filer_window->window, "selection_get",
1759 G_CALLBACK(selection_get), filer_window);
1760 gtk_selection_add_targets(GTK_WIDGET(filer_window->window),
1761 GDK_SELECTION_PRIMARY,
1762 target_table,
1763 sizeof(target_table) / sizeof(*target_table));
1764
1765 g_signal_connect(filer_window->window, "popup-menu",
1766 G_CALLBACK(popup_menu), filer_window);
1767 g_signal_connect(filer_window->window, "key_press_event",
1768 G_CALLBACK(filer_key_press_event), filer_window);
1769
1770 gtk_window_add_accel_group(GTK_WINDOW(filer_window->window),
1771 filer_keys);
1772 }
1773
1774 static gint clear_scanning_display(FilerWindow *filer_window)
1775 {
1776 if (filer_exists(filer_window))
1777 filer_set_title(filer_window);
1778 return FALSE;
1779 }
1780
1781 static void set_scanning_display(FilerWindow *filer_window, gboolean scanning)
1782 {
1783 if (scanning == filer_window->scanning)
1784 return;
1785 filer_window->scanning = scanning;
1786
1787 if (scanning)
1788 filer_set_title(filer_window);
1789 else
1790 g_timeout_add(300, (GSourceFunc) clear_scanning_display,
1791 filer_window);
1792 }
1793
1794 /* Note that filer_window may not exist after this call.
1795 * Returns TRUE iff the directory still exists.
1796 */
1797 gboolean filer_update_dir(FilerWindow *filer_window, gboolean warning)
1798 {
1799 gboolean still_exists;
1800
1801 still_exists = may_rescan(filer_window, warning);
1802
1803 if (still_exists)
1804 dir_update(filer_window->directory, filer_window->sym_path);
1805
1806 return still_exists;
1807 }
1808
1809 void filer_update_all(void)
1810 {
1811 GList *next = all_filer_windows;
1812
1813 while (next)
1814 {
1815 FilerWindow *filer_window = (FilerWindow *) next->data;
1816
1817 /* Updating directory may remove it from list -- stop sending
1818 * patches to move this line!
1819 */
1820 next = next->next;
1821
1822 /* Don't trigger a refresh if we're already scanning.
1823 * Otherwise, two views of a single directory will trigger
1824 * two scans.
1825 */
1826 if (filer_window->directory &&
1827 !filer_window->directory->scanning)
1828 filer_update_dir(filer_window, TRUE);
1829 }
1830 }
1831
1832 /* Refresh the various caches even if we don't think we need to */
1833 void full_refresh(void)
1834 {
1835 mount_update(TRUE);
1836 reread_mime_files(); /* Refreshes all windows */
1837 }
1838
1839 /* See whether a filer window with a given path already exists
1840 * and is different from diff.
1841 */
1842 static FilerWindow *find_filer_window(const char *sym_path, FilerWindow *diff)
1843 {
1844 GList *next;
1845
1846 for (next = all_filer_windows; next; next = next->next)
1847 {
1848 FilerWindow *filer_window = (FilerWindow *) next->data;
1849
1850 if (filer_window != diff &&
1851 strcmp(sym_path, filer_window->sym_path) == 0)
1852 return filer_window;
1853 }
1854
1855 return NULL;
1856 }
1857
1858 /* This path has been mounted/umounted/deleted some files - update all dirs */
1859 void filer_check_mounted(const char *real_path)
1860 {
1861 GList *next = all_filer_windows;
1862 gchar *parent;
1863 int len;
1864 gboolean resize = o_filer_auto_resize.int_value == RESIZE_ALWAYS;
1865
1866 /* DOS disks, etc, often don't change the mtime of the root directory
1867 * on modification, so force a refresh now.
1868 */
1869 g_fscache_update(dir_cache, real_path);
1870
1871 len = strlen(real_path);
1872
1873 while (next)
1874 {
1875 FilerWindow *filer_window = (FilerWindow *) next->data;
1876
1877 next = next->next;
1878
1879 if (strncmp(real_path, filer_window->real_path, len) == 0)
1880 {
1881 char s = filer_window->real_path[len];
1882
1883 if (s == '/' || s == '\0')
1884 {
1885 if (filer_update_dir(filer_window, FALSE) &&
1886 resize)
1887 view_autosize(filer_window->view);
1888 }
1889 }
1890 }
1891
1892 parent = g_path_get_dirname(real_path);
1893 refresh_dirs(parent);
1894 g_free(parent);
1895
1896 icons_may_update(real_path);
1897 }
1898
1899 /* Close all windows displaying 'path' or subdirectories of 'path' */
1900 void filer_close_recursive(const char *path)
1901 {
1902 GList *next = all_filer_windows;
1903 gchar *real;
1904 int len;
1905
1906 real = pathdup(path);
1907 len = strlen(real);
1908
1909 while (next)
1910 {
1911 FilerWindow *filer_window = (FilerWindow *) next->data;
1912
1913 next = next->next;
1914
1915 if (strncmp(real, filer_window->real_path, len) == 0)
1916 {
1917 char s = filer_window->real_path[len];
1918
1919 if (len == 1 || s == '/' || s == '\0')
1920 gtk_widget_destroy(filer_window->window);
1921 }
1922 }
1923 }
1924
1925 /* Like minibuffer_show(), except that:
1926 * - It returns FALSE (to be used from an idle callback)
1927 * - It checks that the filer window still exists.
1928 */
1929 static gboolean minibuffer_show_cb(FilerWindow *filer_window)
1930 {
1931 if (filer_exists(filer_window))
1932 minibuffer_show(filer_window, MINI_PATH);
1933 return FALSE;
1934 }
1935
1936 /* TRUE iff filer_window points to an existing FilerWindow
1937 * structure.
1938 */
1939 gboolean filer_exists(FilerWindow *filer_window)
1940 {
1941 GList *next;
1942
1943 for (next = all_filer_windows; next; next = next->next)
1944 {
1945 FilerWindow *fw = (FilerWindow *) next->data;
1946
1947 if (fw == filer_window)
1948 return TRUE;
1949 }
1950
1951 return FALSE;
1952 }
1953
1954 FilerWindow *filer_get_by_id(const char *id)
1955 {
1956 return g_hash_table_lookup(window_with_id, id);
1957 }
1958
1959 void filer_set_id(FilerWindow *filer_window, const char *id)
1960 {
1961 g_return_if_fail(filer_window != NULL);
1962
1963 if (filer_window->window_id)
1964 {
1965 g_hash_table_remove(window_with_id, filer_window->window_id);
1966 g_free(filer_window->window_id);
1967 filer_window->window_id = NULL;
1968 }
1969
1970 if (id)
1971 {
1972 filer_window->window_id = g_strdup(id);
1973 g_hash_table_insert(window_with_id,
1974 filer_window->window_id,
1975 filer_window);
1976 }
1977 }
1978
1979 /* Make sure the window title is up-to-date */
1980 void filer_set_title(FilerWindow *filer_window)
1981 {
1982 gchar *title = NULL;
1983 guchar *flags = "";
1984
1985 if (filer_window->scanning ||
1986 filer_window->filter != FILER_SHOW_ALL ||
1987 filer_window->show_hidden || filer_window->show_thumbs)
1988 {
1989 if (o_short_flag_names.int_value)
1990 {
1991 const gchar *hidden = "";
1992
1993 switch(filer_window->filter) {
1994 case FILER_SHOW_ALL:
1995 hidden=filer_window->show_hidden? _("A") : "";
1996 break;
1997 case FILER_SHOW_GLOB: hidden = _("G"); break;
1998 default: break;
1999 }
2000
2001 flags = g_strconcat(" +",
2002 filer_window->scanning ? _("S") : "",
2003 hidden,
2004 filer_window->show_thumbs ? _("T") : "",
2005 NULL);
2006 }
2007 else
2008 {
2009 gchar *hidden = NULL;
2010
2011 switch(filer_window->filter) {
2012 case FILER_SHOW_ALL:
2013 hidden = g_strdup(filer_window->show_hidden
2014 ? _("All, ") : "");
2015 break;
2016 case FILER_SHOW_GLOB:
2017 hidden = g_strdup_printf(_("Glob (%s), "),
2018 filer_window->filter_string);
2019 break;
2020 default:
2021 hidden =g_strdup("");
2022 break;
2023 }
2024 flags = g_strconcat(" (",
2025 filer_window->scanning ? _("Scanning, ") : "",
2026 hidden,
2027 filer_window->show_thumbs ? _("Thumbs, ") : "",
2028 NULL);
2029 flags[strlen(flags) - 2] = ')';
2030 g_free(hidden);
2031 }
2032 }
2033
2034 if (not_local)
2035 title = g_strconcat("//", our_host_name(),
2036 filer_window->sym_path, flags, NULL);
2037
2038 if (!title && home_dir_len > 1 &&
2039 strncmp(filer_window->sym_path, home_dir, home_dir_len) == 0)
2040 {
2041 guchar sep = filer_window->sym_path[home_dir_len];
2042
2043 if (sep == '\0' || sep == '/')
2044 title = g_strconcat("~",
2045 filer_window->sym_path + home_dir_len,
2046 flags,
2047 NULL);
2048 }
2049
2050 if (!title)
2051 title = g_strconcat(filer_window->sym_path, flags, NULL);
2052
2053 ensure_utf8(&title);
2054
2055 if (filer_window->directory->error)
2056 {
2057 gchar *old = title;
2058 title = g_strconcat(old, ": ", filer_window->directory->error,
2059 NULL);
2060 g_free(old);
2061 }
2062
2063 gtk_window_set_title(GTK_WINDOW(filer_window->window), title);
2064
2065 g_free(title);
2066
2067 if (flags[0] != '\0')
2068 g_free(flags);
2069 }
2070
2071 /* Reconnect to the same directory (used when the Show Hidden option is
2072 * toggled). This has the side-effect of updating the window title.
2073 */
2074 void filer_detach_rescan(FilerWindow *filer_window)
2075 {
2076 Directory *dir = filer_window->directory;
2077
2078 g_object_ref(dir);
2079 detach(filer_window);
2080 filer_window->directory = dir;
2081 attach(filer_window);
2082 }
2083
2084 /* Puts the filer window into target mode. When an item is chosen,
2085 * fn(filer_window, iter, data) is called. 'reason' will be displayed
2086 * on the toolbar while target mode is active.
2087 *
2088 * Use fn == NULL to cancel target mode.
2089 */
2090 void filer_target_mode(FilerWindow *filer_window,
2091 TargetFunc fn,
2092 gpointer data,
2093 const char *reason)
2094 {
2095 TargetFunc old_fn = filer_window->target_cb;
2096
2097 if (fn != old_fn)
2098 gdk_window_set_cursor(
2099 GTK_WIDGET(filer_window->view)->window,
2100 fn ? crosshair : NULL);
2101
2102 filer_window->target_cb = fn;
2103 filer_window->target_data = data;
2104
2105 if (filer_window->toolbar_text == NULL)
2106 return;
2107
2108 if (fn)
2109 gtk_label_set_text(
2110 GTK_LABEL(filer_window->toolbar_text), reason);
2111 else if (o_toolbar_info.int_value)
2112 {
2113 if (old_fn)
2114 toolbar_update_info(filer_window);
2115 }
2116 else
2117 gtk_label_set_text(GTK_LABEL(filer_window->toolbar_text), "");
2118 }
2119
2120 static void set_selection_state(FilerWindow *filer_window, gboolean normal)
2121 {
2122 GtkStateType old_state = filer_window->selection_state;
2123
2124 filer_window->selection_state = normal
2125 ? GTK_STATE_SELECTED : GTK_STATE_INSENSITIVE;
2126
2127 if (old_state != filer_window->selection_state
2128 && view_count_selected(filer_window->view))
2129 gtk_widget_queue_draw(GTK_WIDGET(filer_window->view));
2130 }
2131
2132 void filer_cancel_thumbnails(FilerWindow *filer_window)
2133 {
2134 gtk_widget_hide(filer_window->thumb_bar);
2135
2136 destroy_glist(&filer_window->thumb_queue);
2137 filer_window->max_thumbs = 0;
2138 }
2139
2140 /* Generate the next thumb for this window. The window object is
2141 * unref'd when there is nothing more to do.
2142 * If the window no longer has a filer window, nothing is done.
2143 */
2144 static gboolean filer_next_thumb_real(GObject *window)
2145 {
2146 FilerWindow *filer_window;
2147 gchar *path;
2148 int done, total;
2149
2150 filer_window = g_object_get_data(window, "filer_window");
2151
2152 if (!filer_window)
2153 {
2154 g_object_unref(window);
2155 return FALSE;
2156 }
2157
2158 if (!filer_window->thumb_queue)
2159 {
2160 filer_cancel_thumbnails(filer_window);
2161 g_object_unref(window);
2162 return FALSE;
2163 }
2164
2165 total = filer_window->max_thumbs;
2166 done = total - g_list_length(filer_window->thumb_queue);
2167
2168 path = (gchar *) filer_window->thumb_queue->data;
2169
2170 pixmap_background_thumb(path, (GFunc) filer_next_thumb, window);
2171
2172 filer_window->thumb_queue = g_list_remove(filer_window->thumb_queue,
2173 path);
2174 g_free(path);
2175
2176 gtk_progress_bar_set_fraction(
2177 GTK_PROGRESS_BAR(filer_window->thumb_progress),
2178 done / (float) total);
2179
2180 return FALSE;
2181 }
2182
2183 /* path is the thumb just loaded, if any.
2184 * window is unref'd (eventually).
2185 */
2186 static void filer_next_thumb(GObject *window, const gchar *path)
2187 {
2188 if (path)
2189 dir_force_update_path(path);
2190
2191 g_idle_add((GSourceFunc) filer_next_thumb_real, window);
2192 }
2193
2194 static void start_thumb_scanning(FilerWindow *filer_window)
2195 {
2196 if (GTK_WIDGET_VISIBLE(filer_window->thumb_bar))
2197 return; /* Already scanning */
2198
2199 gtk_widget_show_all(filer_window->thumb_bar);
2200
2201 g_object_ref(G_OBJECT(filer_window->window));
2202 filer_next_thumb(G_OBJECT(filer_window->window), NULL);
2203 }
2204
2205 /* Set this image to be loaded some time in the future */
2206 void filer_create_thumb(FilerWindow *filer_window, const gchar *path)
2207 {
2208 if (g_list_find_custom(filer_window->thumb_queue, path,
2209 (GCompareFunc) strcmp))
2210 return;
2211
2212 if (!filer_window->thumb_queue)
2213 filer_window->max_thumbs=0;
2214 filer_window->max_thumbs++;
2215
2216 filer_window->thumb_queue = g_list_append(filer_window->thumb_queue,
2217 g_strdup(path));
2218
2219 if (filer_window->scanning)
2220 return; /* Will start when scan ends */
2221
2222 start_thumb_scanning(filer_window);
2223 }
2224
2225 /* If thumbnail display is on, look through all the items in this directory
2226 * and start creating or updating the thumbnails as needed.
2227 */
2228 void filer_create_thumbs(FilerWindow *filer_window)
2229 {
2230 DirItem *item;
2231 ViewIter iter;
2232
2233 if (!filer_window->show_thumbs)
2234 return;
2235
2236 view_get_iter(filer_window->view, &iter, 0);
2237
2238 while ((item = iter.next(&iter)))
2239 {
2240 MaskedPixmap *pixmap;
2241 const guchar *path;
2242 gboolean found;
2243
2244 if (item->base_type != TYPE_FILE)
2245 continue;
2246
2247 /*if (strcmp(item->mime_type->media_type, "image") != 0)
2248 continue;*/
2249
2250 path = make_path(filer_window->real_path, item->leafname);
2251
2252 pixmap = g_fscache_lookup_full(pixmap_cache, path,
2253 FSCACHE_LOOKUP_ONLY_NEW, &found);
2254 if (pixmap)
2255 g_object_unref(pixmap);
2256
2257 /* If we didn't get an image, it could be because:
2258 *
2259 * - We're loading the image now. found is TRUE,
2260 * and we'll update the item later.
2261 * - We tried to load the image and failed. found
2262 * is TRUE.
2263 * - We haven't tried loading the image. found is
2264 * FALSE, and we start creating the thumb here.
2265 */
2266 if (!found)
2267 filer_create_thumb(filer_window, path);
2268 }
2269 }
2270
2271 static void filer_options_changed(void)
2272 {
2273 if (o_short_flag_names.has_changed)
2274 {
2275 GList *next;
2276
2277 for (next = all_filer_windows; next; next = next->next)
2278 {
2279 FilerWindow *filer_window = (FilerWindow *) next->data;
2280
2281 filer_set_title(filer_window);
2282 }
2283 }
2284 }
2285
2286 /* Append interesting information to this GString */
2287 void filer_add_tip_details(FilerWindow *filer_window,
2288 GString *tip, DirItem *item)
2289 {
2290 const guchar *fullpath = NULL;
2291
2292 fullpath = make_path(filer_window->real_path, item->leafname);
2293
2294 if (item->flags & ITEM_FLAG_SYMLINK)
2295 {
2296 char *target;
2297
2298 target = readlink_dup(fullpath);
2299 if (target)
2300 {
2301 ensure_utf8(&target);
2302
2303 g_string_append(tip, _("Symbolic link to "));
2304 g_string_append(tip, target);
2305 g_string_append_c(tip, '\n');
2306 g_free(target);
2307 }
2308 }
2309
2310 if (item->flags & ITEM_FLAG_APPDIR)
2311 {
2312 XMLwrapper *info;
2313 xmlNode *node;
2314
2315 info = appinfo_get(fullpath, item);
2316 if (info && ((node = xml_get_section(info, NULL, "Summary"))))
2317 {
2318 guchar *str;
2319 str = xmlNodeListGetString(node->doc,
2320 node->xmlChildrenNode, 1);
2321 if (str)
2322 {
2323 g_string_append(tip, str);
2324 g_string_append_c(tip, '\n');
2325 g_free(str);
2326 }
2327 }
2328 if (info)
2329 g_object_unref(info);
2330 }
2331 else if (item->mime_type == application_x_desktop)
2332 {
2333 char *summary;
2334 summary = tip_from_desktop_file(fullpath);
2335 if (summary)
2336 {
2337 g_string_append(tip, summary);
2338 g_string_append_c(tip, '\n');
2339 g_free(summary);
2340 }
2341 }
2342
2343 if (!g_utf8_validate(item->leafname, -1, NULL))
2344 g_string_append(tip,
2345 _("This filename is not valid UTF-8. "
2346 "You should rename it.\n"));
2347 }
2348
2349 /* Return the selection as a text/uri-list.
2350 * g_free() the result.
2351 */
2352 static guchar *filer_create_uri_list(FilerWindow *filer_window)
2353 {
2354 GString *string;
2355 GString *leader;
2356 ViewIter iter;
2357 DirItem *item;
2358 guchar *retval;
2359
2360 g_return_val_if_fail(filer_window != NULL, NULL);
2361
2362 string = g_string_new(NULL);
2363
2364 leader = g_string_new(filer_window->sym_path);
2365 if (leader->str[leader->len - 1] != '/')
2366 g_string_append_c(leader, '/');
2367
2368 view_get_iter(filer_window->view, &iter, VIEW_ITER_SELECTED);
2369 while ((item = iter.next(&iter)))
2370 {
2371 EscapedPath *uri;
2372 char *path;
2373
2374 path = g_strconcat(leader->str, item->leafname, NULL);
2375 uri = encode_path_as_uri(path);
2376 g_string_append(string, (char *) uri);
2377 g_string_append(string, "\r\n");
2378 g_free(path);
2379 g_free(uri);
2380 }
2381
2382 g_string_free(leader, TRUE);
2383 retval = string->str;
2384 g_string_free(string, FALSE);
2385
2386 return retval;
2387 }
2388
2389 void filer_perform_action(FilerWindow *filer_window, GdkEventButton *event)
2390 {
2391 BindAction action;
2392 ViewIface *view = filer_window->view;
2393 DirItem *item = NULL;
2394 gboolean press = event->type == GDK_BUTTON_PRESS;
2395 ViewIter iter;
2396 OpenFlags flags = 0;
2397
2398 if (event->button > 3)
2399 return;
2400
2401 view_get_iter_at_point(view, &iter, event->window, event->x, event->y);
2402 item = iter.peek(&iter);
2403
2404 if (item && view_cursor_visible(view))
2405 view_cursor_to_iter(view, &iter);
2406
2407 if (item && event->button == 1 &&
2408 view_get_selected(view, &iter) &&
2409 filer_window->selection_state == GTK_STATE_INSENSITIVE)
2410 {
2411 /* Possibly a really slow DnD operation? */
2412 filer_window->temp_item_selected = FALSE;
2413
2414 filer_selection_changed(filer_window, event->time);
2415 return;
2416 }
2417
2418 if (filer_window->target_cb)
2419 {
2420 dnd_motion_ungrab();
2421 if (item && press && event->button == 1)
2422 filer_window->target_cb(filer_window, &iter,
2423 filer_window->target_data);
2424
2425 filer_target_mode(filer_window, NULL, NULL, NULL);
2426
2427 return;
2428 }
2429
2430 if (!o_single_click.int_value)
2431 {
2432 /* Make sure both parts of a double-click fall on
2433 * the same file.
2434 */
2435 static guchar *first_click = NULL;
2436 static guchar *second_click = NULL;
2437
2438 if (event->type == GDK_BUTTON_PRESS)
2439 {
2440 g_free(first_click);
2441 first_click = second_click;
2442
2443 if (item)
2444 second_click = g_strdup(item->leafname);
2445 else
2446 second_click = NULL;
2447 }
2448
2449 if (event->type == GDK_2BUTTON_PRESS)
2450 {
2451 if (first_click && second_click &&
2452 strcmp(first_click, second_click) != 0)
2453 return;
2454 if ((first_click || second_click) &&
2455 !(first_click && second_click))
2456 return;
2457 }
2458 }
2459
2460 action = bind_lookup_bev(
2461 item ? BIND_DIRECTORY_ICON : BIND_DIRECTORY,
2462 event);
2463
2464 switch (action)
2465 {
2466 case ACT_CLEAR_SELECTION:
2467 view_clear_selection(view);
2468 break;
2469 case ACT_TOGGLE_SELECTED:
2470 view_set_selected(view, &iter,
2471 !view_get_selected(view, &iter));
2472 break;
2473 case ACT_SELECT_EXCL:
2474 view_select_only(view, &iter);
2475 break;
2476 case ACT_EDIT_ITEM:
2477 flags |= OPEN_SHIFT;
2478 /* (no break) */
2479 case ACT_OPEN_ITEM:
2480 if (event->button != 1 || event->state & GDK_MOD1_MASK)
2481 flags |= OPEN_CLOSE_WINDOW;
2482 else
2483 flags |= OPEN_SAME_WINDOW;
2484 if (o_new_button_1.int_value)
2485 flags ^= OPEN_SAME_WINDOW;
2486 if (event->type == GDK_2BUTTON_PRESS)
2487 view_set_selected(view, &iter, FALSE);
2488 dnd_motion_ungrab();
2489
2490 filer_openitem(filer_window, &iter, flags);
2491 break;
2492 case ACT_POPUP_MENU:
2493 dnd_motion_ungrab();
2494 tooltip_show(NULL);
2495 show_filer_menu(filer_window,
2496 (GdkEvent *) event, &iter);
2497 break;
2498 case ACT_PRIME_AND_SELECT:
2499 if (item && !view_get_selected(view, &iter))
2500 view_select_only(view, &iter);
2501 dnd_motion_start(MOTION_READY_FOR_DND);
2502 break;
2503 case ACT_PRIME_AND_TOGGLE:
2504 view_set_selected(view, &iter,
2505 !view_get_selected(view, &iter));
2506 dnd_motion_start(MOTION_READY_FOR_DND);
2507 break;
2508 case ACT_PRIME_FOR_DND:
2509 dnd_motion_start(MOTION_READY_FOR_DND);
2510 break;
2511 case ACT_IGNORE:
2512 if (press && event->button < 4)
2513 {
2514 if (item)
2515 view_wink_item(view, &iter);
2516 dnd_motion_start(MOTION_NONE);
2517 }
2518 break;
2519 case ACT_LASSO_CLEAR:
2520 view_clear_selection(view);
2521 /* (no break) */
2522 case ACT_LASSO_MODIFY:
2523 view_start_lasso_box(view, event);
2524 break;
2525 case ACT_RESIZE:
2526 view_autosize(filer_window->view);
2527 break;
2528 default:
2529 g_warning("Unsupported action : %d\n", action);
2530 break;
2531 }
2532 }
2533
2534 /* It's time to make the tooltip appear. If we're not over the item any
2535 * more, or the item doesn't need a tooltip, do nothing.
2536 */
2537 static gboolean tooltip_activate(GtkWidget *window)
2538 {
2539 FilerWindow *filer_window;
2540 ViewIface *view;
2541 ViewIter iter;
2542 gint x, y;
2543 DirItem *item = NULL;
2544 GString *tip = NULL;
2545
2546 g_return_val_if_fail(tip_item != NULL, 0);
2547
2548 filer_window = g_object_get_data(G_OBJECT(window), "filer_window");
2549
2550 if (!motion_window || !filer_window)
2551 return FALSE; /* Window has been destroyed */
2552
2553 view = filer_window->view;
2554
2555 tooltip_show(NULL);
2556
2557 gdk_window_get_pointer(motion_window, &x, &y, NULL);
2558 view_get_iter_at_point(view, &iter, motion_window, x, y);
2559
2560 item = iter.peek(&iter);
2561 if (item != tip_item)
2562 return FALSE; /* Not still under the pointer */
2563
2564 /* OK, the filer window still exists and the pointer is still
2565 * over the same item. Do we need to show a tip?
2566 */
2567
2568 tip = g_string_new(NULL);
2569
2570 view_extend_tip(filer_window->view, &iter, tip);
2571
2572 filer_add_tip_details(filer_window, tip, tip_item);
2573
2574 if (tip->len > 1)
2575 {
2576 g_string_truncate(tip, tip->len - 1);
2577
2578 tooltip_show(tip->str);
2579 }
2580
2581 g_string_free(tip, TRUE);
2582
2583 return FALSE;
2584 }
2585
2586 /* Motion detected on the View widget */
2587 gint filer_motion_notify(FilerWindow *filer_window, GdkEventMotion *event)
2588 {
2589 ViewIface *view = filer_window->view;
2590 ViewIter iter;
2591 DirItem *item;
2592
2593 view_get_iter_at_point(view, &iter, event->window, event->x, event->y);
2594 item = iter.peek(&iter);
2595
2596 if (item)
2597 {
2598 if (item != tip_item)
2599 {
2600 tooltip_show(NULL);
2601
2602 tip_item = item;
2603 motion_window = event->window;
2604 tooltip_prime((GtkFunction) tooltip_activate,
2605 G_OBJECT(filer_window->window));
2606 }
2607 }
2608 else
2609 {
2610 tooltip_show(NULL);
2611 tip_item = NULL;
2612 }
2613
2614 if (motion_state != MOTION_READY_FOR_DND)
2615 return FALSE;
2616
2617 if (!dnd_motion_moved(event))
2618 return FALSE;
2619
2620 view_get_iter_at_point(view, &iter,
2621 event->window,
2622 event->x - (event->x_root - drag_start_x),
2623 event->y - (event->y_root - drag_start_y));
2624 item = iter.peek(&iter);
2625 if (!item)
2626 return FALSE;
2627
2628 view_wink_item(view, NULL);
2629
2630 if (!view_get_selected(view, &iter))
2631 {
2632 if (event->state & GDK_BUTTON1_MASK)
2633 {
2634 /* Select just this one */
2635 filer_window->temp_item_selected = TRUE;
2636 view_select_only(view, &iter);
2637 }
2638 else
2639 {
2640 if (view_count_selected(view) == 0)
2641 filer_window->temp_item_selected = TRUE;
2642 view_set_selected(view, &iter, TRUE);
2643 }
2644 }
2645
2646 g_return_val_if_fail(view_count_selected(view) > 0, TRUE);
2647
2648 if (view_count_selected(view) == 1)
2649 {
2650 if (item->base_type == TYPE_UNKNOWN)
2651 item = dir_update_item(filer_window->directory,
2652 item->leafname);
2653
2654 if (!item)
2655 {
2656 report_error(_("Item no longer exists!"));
2657 return FALSE;
2658 }
2659
2660 drag_one_item(GTK_WIDGET(view), event,
2661 make_path(filer_window->sym_path, item->leafname),
2662 item, di_image(item));
2663 #if 0
2664 /* XXX: Use thumbnail */
2665 item, view ? view->image : NULL);
2666 #endif
2667 }
2668 else
2669 {
2670 guchar *uris;
2671
2672 uris = filer_create_uri_list(filer_window);
2673 drag_selection(GTK_WIDGET(view), event, uris);
2674 g_free(uris);
2675 }
2676
2677 return FALSE;
2678 }
2679
2680 static void drag_end(GtkWidget *widget, GdkDragContext *context,
2681 FilerWindow *filer_window)
2682 {
2683 filer_set_autoscroll(filer_window, FALSE);
2684
2685 if (filer_window->temp_item_selected)
2686 {
2687 view_clear_selection(filer_window->view);
2688 filer_window->temp_item_selected = FALSE;
2689 }
2690 }
2691
2692 /* Remove highlights */
2693 static void drag_leave(GtkWidget *widget,
2694 GdkDragContext *context,
2695 guint32 time,
2696 FilerWindow *filer_window)
2697 {
2698 dnd_spring_abort();
2699 }
2700
2701 /* Called during the drag when the mouse is in a widget registered
2702 * as a drop target. Returns TRUE if we can accept the drop.
2703 */
2704 static gboolean drag_motion(GtkWidget *widget,
2705 GdkDragContext *context,
2706 gint x,
2707 gint y,
2708 guint time,
2709 FilerWindow *filer_window)
2710 {
2711 DirItem *item;
2712 ViewIface *view = filer_window->view;
2713 ViewIter iter;
2714 GdkDragAction action = context->suggested_action;
2715 const guchar *new_path = NULL;
2716 const char *type = NULL;
2717 gboolean retval = FALSE;
2718 gboolean same_window;
2719
2720 if ((context->actions & GDK_ACTION_ASK) && o_dnd_left_menu.int_value)
2721 {
2722 guint state;
2723 gdk_window_get_pointer(NULL, NULL, NULL, &state);
2724 if (state & GDK_BUTTON1_MASK)
2725 action = GDK_ACTION_ASK;
2726 }
2727
2728 same_window = gtk_drag_get_source_widget(context) == widget;
2729
2730 filer_set_autoscroll(filer_window, TRUE);
2731
2732 if (filer_window->view_type == VIEW_TYPE_DETAILS)
2733 {
2734 GdkWindow *bin;
2735 int bin_y;
2736 /* Correct for position of bin window */
2737 bin = gtk_tree_view_get_bin_window(GTK_TREE_VIEW(view));
2738 gdk_window_get_position(bin, NULL, &bin_y);
2739 y -= bin_y;
2740 }
2741
2742 if (o_dnd_drag_to_icons.int_value)
2743 {
2744 view_get_iter_at_point(view, &iter, widget->window, x, y);
2745 item = iter.peek(&iter);
2746 }
2747 else
2748 item = NULL;
2749
2750 if (item && same_window && view_get_selected(view, &iter))
2751 type = NULL;
2752 else
2753 type = dnd_motion_item(context, &item);
2754
2755 if (!type)
2756 item = NULL;
2757
2758 /* Don't allow drops to non-writeable directories. BUT, still
2759 * allow drops on non-writeable SUBdirectories so that we can
2760 * do the spring-open thing.
2761 */
2762 if (item && type == drop_dest_dir &&
2763 !(item->flags & ITEM_FLAG_APPDIR))
2764 {
2765 dnd_spring_load(context, filer_window);
2766 }
2767 else
2768 dnd_spring_abort();
2769
2770 if (item)
2771 view_cursor_to_iter(view, &iter);
2772 else
2773 {
2774 view_cursor_to_iter(view, NULL);
2775
2776 /* Disallow background drops within a single window */
2777 if (type && same_window)
2778 type = NULL;
2779 }
2780
2781 if (type)
2782 {
2783 if (item)
2784 new_path = make_path(filer_window->sym_path,
2785 item->leafname);
2786 else
2787 new_path = filer_window->sym_path;
2788 }
2789
2790 /* Don't ask about dragging to an application! */
2791 if (type == drop_dest_prog && action == GDK_ACTION_ASK)
2792 action = GDK_ACTION_COPY;
2793
2794 g_dataset_set_data(context, "drop_dest_type", (gpointer) type);
2795 if (type)
2796 {
2797 gdk_drag_status(context, action, time);
2798 g_dataset_set_data_full(context, "drop_dest_path",
2799 g_strdup(new_path), g_free);
2800 retval = TRUE;
2801 }
2802
2803 return retval;
2804 }
2805
2806 static gboolean as_timeout(FilerWindow *filer_window)
2807 {
2808 gboolean retval;
2809
2810 retval = view_auto_scroll_callback(filer_window->view);
2811
2812 if (!retval)
2813 filer_window->auto_scroll = -1;
2814
2815 return retval;
2816 }
2817
2818 /* When autoscroll is on, a timer keeps track of the pointer position.
2819 * While it's near the top or bottom of the window, the window scrolls.
2820 *
2821 * If the mouse buttons are released, the pointer leaves the window, or
2822 * a drag-and-drop operation finishes, auto_scroll is turned off.
2823 */
2824 void filer_set_autoscroll(FilerWindow *filer_window, gboolean auto_scroll)
2825 {
2826 g_return_if_fail(filer_window != NULL);
2827
2828 if (auto_scroll)
2829 {
2830 if (filer_window->auto_scroll != -1)
2831 return; /* Already on! */
2832
2833 filer_window->auto_scroll = g_timeout_add(50,
2834 (GSourceFunc) as_timeout,
2835 filer_window);
2836 }
2837 else
2838 {
2839 if (filer_window->auto_scroll == -1)
2840 return; /* Already off! */
2841
2842 g_source_remove(filer_window->auto_scroll);
2843 filer_window->auto_scroll = -1;
2844 }
2845 }
2846
2847 #define ZERO_MNT "/uri/0install"
2848
2849 static void refresh_done(FilerWindow *filer_window)
2850 {
2851 if (filer_exists(filer_window))
2852 filer_update_dir(filer_window, TRUE);
2853 }
2854
2855 void filer_refresh(FilerWindow *filer_window)
2856 {
2857 if (!strncmp(ZERO_MNT "/", filer_window->real_path, sizeof(ZERO_MNT)))
2858 {
2859 /* Try to run 0refresh */
2860 gint pid;
2861 gchar *argv[] = {"0refresh", NULL, NULL};
2862 const char *host = filer_window->real_path + sizeof(ZERO_MNT);
2863 const char *slash;
2864
2865 slash = strchr(host, '/');
2866 if (slash)
2867 argv[1] = g_strndup(host, slash - host);
2868 else
2869 argv[1] = g_strdup(host);
2870 pid = rox_spawn(filer_window->real_path, (const char **) argv);
2871 g_free(argv[1]);
2872 if (pid)
2873 on_child_death(pid, (CallbackFn) refresh_done,
2874 filer_window);
2875 }
2876
2877 full_refresh();
2878 }
2879
2880 gboolean filer_match_filter(FilerWindow *filer_window, const gchar *filename)
2881 {
2882 g_return_val_if_fail(filename != NULL, FALSE);
2883
2884 if(filename[0]=='.' &&
2885 (!filer_window->temp_show_hidden && !filer_window->show_hidden))
2886 return FALSE;
2887
2888 switch(filer_window->filter) {
2889 case FILER_SHOW_GLOB:
2890 return fnmatch(filer_window->filter_string,
2891 filename, 0)==0;
2892
2893 case FILER_SHOW_ALL:
2894 default:
2895 break;
2896 }
2897 return TRUE;
2898 }
2899
2900 /* Provided to hide the implementation */
2901 void filer_set_hidden(FilerWindow *filer_window, gboolean hidden)
2902 {
2903 filer_window->show_hidden=hidden;
2904 }
2905
2906 /* Set the filter type. Returns TRUE if the type has changed
2907 * (must call filer_detach_rescan).
2908 */
2909 gboolean filer_set_filter(FilerWindow *filer_window, FilterType type,
2910 const gchar *filter_string)
2911 {
2912 /* Is this new filter the same as the old one? */
2913 if (filer_window->filter == type)
2914 {
2915 switch(filer_window->filter)
2916 {
2917 case FILER_SHOW_ALL:
2918 return FALSE;
2919 case FILER_SHOW_GLOB:
2920 if (strcmp(filer_window->filter_string,
2921 filter_string) == 0)
2922 return FALSE;
2923 break;
2924 }
2925 }
2926
2927 /* Clean up old filter */
2928 if (filer_window->filter_string)
2929 {
2930 g_free(filer_window->filter_string);
2931 filer_window->filter_string = NULL;
2932 }
2933 /* Also clean up compiled regexp when implemented */
2934
2935 filer_window->filter = type;
2936
2937 switch(type)
2938 {
2939 case FILER_SHOW_ALL:
2940 /* No extra work */
2941 break;
2942
2943 case FILER_SHOW_GLOB:
2944 filer_window->filter_string = g_strdup(filter_string);
2945 break;
2946
2947 default:
2948 /* oops */
2949 filer_window->filter = FILER_SHOW_ALL;
2950 g_warning("Impossible: filter type %d", type);
2951 break;
2952 }
2953
2954 return TRUE;
2955 }
2956
2957 /* Setting stuff */
2958 static Settings *settings_new(const char *path)
2959 {
2960 Settings *set;
2961
2962 set=g_new(Settings, 1);
2963 memset(set, 0, sizeof(Settings));
2964 if(path)
2965 set->path=g_strdup(path);
2966
2967 return set;
2968 }
2969
2970 static void settings_free(Settings *set)
2971 {
2972 g_free(set->path);
2973 if(set->filter)
2974 g_free(set->filter);
2975 g_free(set);
2976 }
2977
2978 static void store_settings(Settings *set)
2979 {
2980 Settings *old;
2981
2982 old=g_hash_table_lookup(settings_table, set->path);
2983 if(old)
2984 {
2985 g_hash_table_remove(settings_table, set->path);
2986 settings_free(old);
2987 }
2988
2989 g_hash_table_insert(settings_table, set->path, set);
2990 }
2991
2992 /* TODO: use symbolic names in the XML file where possible */
2993 static void load_from_node(Settings *set, xmlDocPtr doc, xmlNodePtr node)
2994 {
2995 xmlChar *str=NULL;
2996
2997 str=xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
2998
2999 if(strcmp(node->name, "X") == 0) {
3000 set->x=atoi(str);
3001 set->flags|=SET_POSITION;
3002 } else if(strcmp(node->name, "Y") == 0) {
3003 set->y=atoi(str);
3004 set->flags|=SET_POSITION;
3005 } else if(strcmp(node->name, "Width") == 0) {
3006 set->width=atoi(str);
3007 set->flags|=SET_SIZE;
3008 } else if(strcmp(node->name, "Height") == 0) {
3009 set->height=atoi(str);
3010 set->flags|=SET_SIZE;
3011 } else if(strcmp(node->name, "ShowHidden") == 0) {
3012 set->show_hidden=atoi(str);
3013 set->flags|=SET_HIDDEN;
3014 } else if(strcmp(node->name, "ViewType") == 0) {
3015 set->view_type=atoi(str);
3016 set->flags|=SET_DETAILS;
3017 } else if(strcmp(node->name, "DetailsType") == 0) {
3018 set->details_type=atoi(str);
3019 set->flags|=SET_DETAILS;
3020 } else if(strcmp(node->name, "SortType") == 0) {
3021 set->sort_type=atoi(str);
3022 set->flags|=SET_SORT;
3023 } else if(strcmp(node->name, "SortOrder") == 0) {
3024 set->sort_order=atoi(str);
3025 set->flags|=SET_SORT;
3026 } else if(strcmp(node->name, "DisplayStyle") == 0) {
3027 set->display_style=atoi(str);
3028 set->flags|=SET_STYLE;
3029 } else if(strcmp(node->name, "ShowThumbs") == 0) {
3030 set->show_thumbs=atoi(str);
3031 set->flags|=SET_THUMBS;
3032 } else if(strcmp(node->name, "FilterType") == 0) {
3033 set->filter_type=atoi(str);
3034 set->flags|=SET_FILTER;
3035 } else if(strcmp(node->name, "Filter") == 0) {
3036 set->filter=g_strdup(str);
3037 set->flags|=SET_FILTER;
3038 }
3039
3040 if(str)
3041 xmlFree(str);
3042 }
3043
3044 static void load_settings(void)
3045 {
3046 gchar *path;
3047 XMLwrapper *settings_doc=NULL;
3048
3049 path=choices_find_xdg_path_load("Settings.xml", PROJECT, SITE);
3050 if(path) {
3051 settings_doc=xml_new(path);
3052 g_free(path);
3053 }
3054
3055 if(!settings_table)
3056 settings_table=g_hash_table_new(g_str_hash, g_str_equal);
3057
3058 if(settings_doc) {
3059 xmlNodePtr node, subnode;
3060
3061 node = xmlDocGetRootElement(settings_doc->doc);
3062
3063 for (node = node->xmlChildrenNode; node; node = node->next)
3064 {
3065 Settings *set;
3066 xmlChar *path;
3067
3068 if (node->type != XML_ELEMENT_NODE)
3069 continue;
3070 if (strcmp(node->name, "FilerWindow") != 0)
3071 continue;
3072
3073 path=xmlGetProp(node, "path");
3074 set=settings_new(path);
3075 xmlFree(path);
3076
3077 for (subnode=node->xmlChildrenNode; subnode;
3078 subnode=subnode->next) {
3079
3080 if (subnode->type != XML_ELEMENT_NODE)
3081 continue;
3082 load_from_node(set, settings_doc->doc,
3083 subnode);
3084 }
3085
3086 store_settings(set);
3087 }
3088 g_object_unref(settings_doc);
3089 }
3090 }
3091
3092 static void add_nodes(gpointer key, gpointer value, gpointer data)
3093 {
3094 xmlNodePtr node=(xmlNodePtr) data;
3095 xmlNodePtr sub;
3096 Settings *set=(Settings *) value;
3097 char *tmp;
3098
3099 sub=xmlNewChild(node, NULL, "FilerWindow", NULL);
3100
3101 xmlSetProp(sub, "path", set->path);
3102
3103 if(set->flags & SET_POSITION) {
3104 tmp=g_strdup_printf("%d", set->x);
3105 xmlNewChild(sub, NULL, "X", tmp);
3106 g_free(tmp);
3107 tmp=g_strdup_printf("%d", set->y);
3108 xmlNewChild(sub, NULL, "Y", tmp);
3109 g_free(tmp);
3110 }
3111 if(set->flags & SET_SIZE) {
3112 tmp=g_strdup_printf("%d", set->width);
3113 xmlNewChild(sub, NULL, "Width", tmp);
3114 g_free(tmp);
3115 tmp=g_strdup_printf("%d", set->height);
3116 xmlNewChild(sub, NULL, "Height", tmp);
3117 g_free(tmp);
3118 }
3119 if(set->flags & SET_HIDDEN) {
3120 tmp=g_strdup_printf("%d", set->show_hidden);
3121 xmlNewChild(sub, NULL, "ShowHidden", tmp);
3122 g_free(tmp);
3123 }
3124 if(set->flags & SET_STYLE) {
3125 tmp=g_strdup_printf("%d", set->display_style);
3126 xmlNewChild(sub, NULL, "DisplayStyle", tmp);
3127 g_free(tmp);
3128 }
3129 if(set->flags & SET_SORT) {
3130 tmp=g_strdup_printf("%d", set->sort_type);
3131 xmlNewChild(sub, NULL, "SortType", tmp);
3132 g_free(tmp);
3133 tmp=g_strdup_printf("%d", set->sort_order);
3134 xmlNewChild(sub, NULL, "SortOrder", tmp);
3135 g_free(tmp);
3136 }
3137 if(set->flags & SET_DETAILS) {
3138 tmp=g_strdup_printf("%d", set->view_type);
3139 xmlNewChild(sub, NULL, "ViewType", tmp);
3140 g_free(tmp);
3141 tmp=g_strdup_printf("%d", set->details_type);
3142 xmlNewChild(sub, NULL, "DetailsType", tmp);
3143 g_free(tmp);
3144 }
3145 if(set->flags & SET_STYLE) {
3146 tmp=g_strdup_printf("%d", set->show_thumbs);
3147 xmlNewChild(sub, NULL, "ShowThumbs", tmp);
3148 g_free(tmp);
3149 }
3150 if(set->flags & SET_FILTER) {
3151 tmp=g_strdup_printf("%d", set->filter_type);
3152 xmlNewChild(sub, NULL, "FilterType", tmp);
3153 g_free(tmp);
3154 if(set->filter && set->filter[0])
3155 xmlNewChild(sub, NULL, "Filter", set->filter);
3156 }
3157 }
3158
3159 static void save_settings(void)
3160 {
3161 gchar *path;
3162
3163 path=choices_find_xdg_path_save("Settings.xml", PROJECT, SITE, TRUE);
3164 if(path) {
3165 xmlDocPtr doc = xmlNewDoc("1.0");
3166 xmlDocSetRootElement(doc, xmlNewDocNode(doc, NULL,
3167 "Settings", NULL));
3168
3169 g_hash_table_foreach(settings_table, add_nodes,
3170 xmlDocGetRootElement(doc));
3171
3172 save_xml_file(doc, path);
3173
3174 g_free(path);
3175 xmlFreeDoc(doc);
3176 }
3177
3178 }
3179
3180 static void check_settings(FilerWindow *filer_window)
3181 {
3182 Settings *set;
3183
3184 set=(Settings *) g_hash_table_lookup(settings_table,
3185 filer_window->sym_path);
3186
3187 if(set) {
3188 if(set->flags & SET_POSITION)
3189 gtk_window_move(GTK_WINDOW(filer_window->window),
3190 set->x, set->y);
3191 if(set->flags & SET_SIZE)
3192 filer_window_set_size(filer_window, set->width,
3193 set->height);
3194 if(set->flags & SET_HIDDEN)
3195 filer_set_hidden(filer_window, set->show_hidden);
3196
3197 if(set->flags & (SET_STYLE|SET_DETAILS)) {
3198 DisplayStyle style=filer_window->display_style;
3199 DetailsType details=filer_window->details_type;
3200
3201 if(set->flags & SET_STYLE)
3202 style=set->display_style;
3203
3204 if(set->flags & SET_DETAILS) {
3205 details=set->details_type;
3206
3207 filer_set_view_type(filer_window,
3208 set->view_type);
3209 }
3210
3211 display_set_layout(filer_window, style,
3212 details, FALSE);
3213 }
3214
3215 if(set->flags & SET_SORT)
3216 display_set_sort_type(filer_window,
3217 set->sort_type,
3218 set->sort_order);
3219
3220 if(set->flags & SET_THUMBS)
3221 display_set_thumbs(filer_window,
3222 set->show_thumbs);
3223
3224 if(set->flags & SET_FILTER)
3225 display_set_filter(filer_window,
3226 set->filter_type,
3227 set->filter);
3228 }
3229
3230 }
3231
3232 typedef struct settings_window {
3233 GtkWidget *window;
3234
3235 GtkWidget *pos, *size, *hidden, *style, *sort, *details,
3236 *thumbs, *filter;
3237
3238 Settings *set;
3239 } SettingsWindow;
3240
3241
3242 static void settings_response(GtkWidget *window, gint response,
3243 SettingsWindow *set_win)
3244 {
3245 if(response==GTK_RESPONSE_OK) {
3246 gint flags=0;
3247
3248 if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(set_win->pos)))
3249 flags|=SET_POSITION;
3250 if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(set_win->size)))
3251 flags|=SET_SIZE;
3252 if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(set_win->hidden)))
3253 flags|=SET_HIDDEN;
3254 if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(set_win->style)))
3255 flags|=SET_STYLE;
3256 if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(set_win->sort)))
3257 flags|=SET_SORT;
3258 if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(set_win->details)))
3259 flags|=SET_DETAILS;
3260 if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(set_win->thumbs)))
3261 flags|=SET_THUMBS;
3262 if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(set_win->filter)))
3263 flags|=SET_FILTER;
3264
3265 set_win->set->flags=flags;
3266 store_settings(set_win->set);
3267 save_settings();
3268 }
3269
3270 gtk_widget_destroy(window);
3271 }
3272
3273 void filer_save_settings(FilerWindow *fwin)
3274 {
3275 SettingsWindow *set_win;
3276 GtkWidget *vbox;
3277 GtkWidget *path;
3278 gint x, y;
3279
3280 Settings *set=settings_new(fwin->sym_path);
3281
3282 gtk_window_get_position(GTK_WINDOW(fwin->window),&x, &y);
3283 set->flags|=SET_POSITION;
3284 set->x=x;
3285 set->y=y;
3286
3287 gtk_window_get_size(GTK_WINDOW(fwin->window),&x, &y);
3288 set->flags|=SET_SIZE;
3289 set->width=x;
3290 set->height=y;
3291
3292 set->flags|=SET_HIDDEN;
3293 set->show_hidden=fwin->show_hidden;
3294
3295 set->flags|=SET_STYLE;
3296 set->display_style=fwin->display_style;
3297
3298 set->flags|=SET_SORT;
3299 set->sort_type=fwin->sort_type;
3300 set->sort_order=fwin->sort_order;
3301
3302 set->flags|=SET_DETAILS;
3303 set->view_type=fwin->view_type;
3304 set->details_type=fwin->details_type;
3305
3306 set->flags|=SET_THUMBS;
3307 set->show_thumbs=fwin->show_thumbs;
3308
3309 set->flags|=SET_FILTER;
3310 set->filter_type=fwin->filter;
3311 if(fwin->filter_string)
3312 set->filter=g_strdup(fwin->filter_string);
3313
3314 /* Store other parameters
3315 */
3316 set_win=g_new(SettingsWindow, 1);
3317
3318 set_win->window=gtk_dialog_new();
3319 number_of_windows++;
3320
3321 gtk_dialog_add_button(GTK_DIALOG(set_win->window),
3322 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
3323 gtk_dialog_add_button(GTK_DIALOG(set_win->window),
3324 GTK_STOCK_OK, GTK_RESPONSE_OK);
3325
3326 g_signal_connect(set_win->window, "destroy",
3327 G_CALLBACK(one_less_window), NULL);
3328 g_signal_connect_swapped(set_win->window, "destroy",
3329 G_CALLBACK(g_free), set_win);
3330
3331 gtk_window_set_title(GTK_WINDOW(set_win->window),
3332 _("Select display properties to save"));
3333
3334 vbox=GTK_DIALOG(set_win->window)->vbox;
3335
3336 path=gtk_label_new(set->path);
3337 gtk_box_pack_start(GTK_BOX(vbox), path, FALSE, FALSE, 2);
3338
3339 set_win->pos=gtk_check_button_new_with_label(_("Position"));
3340 gtk_box_pack_start(GTK_BOX(vbox), set_win->pos, FALSE, FALSE, 2);
3341 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(set_win->pos),
3342 set->flags & SET_POSITION);
3343
3344 set_win->size=gtk_check_button_new_with_label(_("Size"));
3345 gtk_box_pack_start(GTK_BOX(vbox), set_win->size, FALSE, FALSE, 2);
3346 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(set_win->size),
3347 set->flags & SET_SIZE);
3348
3349 set_win->hidden=gtk_check_button_new_with_label(_("Show hidden"));
3350 gtk_box_pack_start(GTK_BOX(vbox), set_win->hidden,
3351 FALSE, FALSE, 2);
3352 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(set_win->hidden),
3353 set->flags & SET_HIDDEN);
3354
3355 set_win->style=gtk_check_button_new_with_label(_("Display style"));
3356 gtk_box_pack_start(GTK_BOX(vbox), set_win->style,
3357 FALSE, FALSE, 2);
3358 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(set_win->style),
3359 set->flags & SET_STYLE);
3360
3361 set_win->sort=gtk_check_button_new_with_label(_("Sort type and order"));
3362 gtk_box_pack_start(GTK_BOX(vbox), set_win->sort, FALSE, FALSE, 2);
3363 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(set_win->sort),
3364 set->flags & SET_SORT);
3365
3366 set_win->details=gtk_check_button_new_with_label(_("Details"));
3367 gtk_box_pack_start(GTK_BOX(vbox), set_win->details, FALSE, FALSE, 2);
3368 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(set_win->details),
3369 set->flags & SET_DETAILS);
3370
3371 set_win->thumbs=gtk_check_button_new_with_label(_("Thumbnails"));
3372 gtk_box_pack_start(GTK_BOX(vbox), set_win->thumbs,
3373 FALSE, FALSE, 2);
3374 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(set_win->thumbs),
3375 set->flags & SET_THUMBS);
3376
3377 set_win->filter=gtk_check_button_new_with_label(_("Filter"));
3378 gtk_box_pack_start(GTK_BOX(vbox), set_win->filter,
3379 FALSE, FALSE, 2);
3380 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(set_win->filter),
3381 set->flags & SET_FILTER);
3382
3383 set_win->set=set;
3384 g_signal_connect(set_win->window, "response",
3385 G_CALLBACK(settings_response), set_win);
3386
3387 gtk_widget_show_all(set_win->window);
3388 }
3389
3390 static char *tip_from_desktop_file(const char *full_path)
3391 {
3392 GError *error = NULL;
3393 char *comment = NULL;
3394
3395 comment = get_value_from_desktop_file(full_path,
3396 "Desktop Entry", "Comment", &error);
3397 if (error)
3398 {
3399 delayed_error("Failed to parse .desktop file '%s':\n%s",
3400 full_path, error->message);
3401 goto err;
3402 }
3403
3404 err:
3405 if (error != NULL)
3406 g_error_free(error);
3407
3408 return comment;
3409 }
For translators