?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r228: Added a nice list displaying the found files. Clicking opens a preview window
[rox-filer.git] / ROX-Filer / src / filer.c
blobce6070e45242da28e6d283a760fdb2b43758e9b7
1 /*
2 * $Id$
3 *
4 * ROX-Filer, filer for the ROX desktop project
5 * Copyright (C) 2000, Thomas Leonard, <tal197@ecs.soton.ac.uk>.
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 <sys/param.h>
31 #include <unistd.h>
32 #include <time.h>
33 #include <ctype.h>
34
35 #include <gtk/gtk.h>
36 #include <gdk/gdkx.h>
37 #include <gdk/gdkkeysyms.h>
38 #include "collection.h"
39
40 #include "main.h"
41 #include "support.h"
42 #include "gui_support.h"
43 #include "filer.h"
44 #include "pixmaps.h"
45 #include "menu.h"
46 #include "dnd.h"
47 #include "run.h"
48 #include "mount.h"
49 #include "type.h"
50 #include "options.h"
51 #include "action.h"
52 #include "minibuffer.h"
53
54 #define ROW_HEIGHT_LARGE 64
55 #define ROW_HEIGHT_SMALL 32
56 #define ROW_HEIGHT_FULL_INFO 44
57 #define SMALL_ICON_HEIGHT 20
58 #define SMALL_ICON_WIDTH 48
59 #define MAX_ICON_HEIGHT 42
60 #define MAX_ICON_WIDTH 48
61 #define PANEL_BORDER 2
62 #define MIN_ITEM_WIDTH 64
63
64 extern int collection_menu_button;
65 extern gboolean collection_single_click;
66
67 FilerWindow *window_with_focus = NULL;
68 GList *all_filer_windows = NULL;
69
70 static DisplayStyle last_display_style = LARGE_ICONS;
71 static gboolean last_show_hidden = FALSE;
72 static int (*last_sort_fn)(const void *a, const void *b) = sort_by_type;
73
74 static FilerWindow *window_with_selection = NULL;
75
76 /* Options bits */
77 static guchar *style_to_name(void);
78 static guchar *sort_fn_to_name(void);
79 static void update_options_label(void);
80
81 static GtkWidget *create_options();
82 static void update_options();
83 static void set_options();
84 static void save_options();
85 static char *filer_single_click(char *data);
86 static char *filer_unique_windows(char *data);
87 static char *filer_menu_on_2(char *data);
88 static char *filer_new_window_on_1(char *data);
89 static char *filer_toolbar(char *data);
90 static char *filer_display_style(char *data);
91 static char *filer_sort_by(char *data);
92
93 static OptionsSection options =
94 {
95 "Filer window options",
96 create_options,
97 update_options,
98 set_options,
99 save_options
100 };
101
102 /* The values correspond to the menu indexes in the option widget */
103 typedef enum {
104 TOOLBAR_NONE = 0,
105 TOOLBAR_NORMAL = 1,
106 TOOLBAR_GNOME = 2,
107 } ToolbarType;
108 static ToolbarType o_toolbar = TOOLBAR_NORMAL;
109 static GtkWidget *menu_toolbar;
110
111 static GtkWidget *display_label;
112
113 static gboolean o_single_click = FALSE;
114 static GtkWidget *toggle_single_click;
115 static gboolean o_new_window_on_1 = FALSE; /* Button 1 => New window */
116 static GtkWidget *toggle_new_window_on_1;
117 static GtkWidget *toggle_menu_on_2;
118 static GtkWidget *toggle_unique_filer_windows;
119 gboolean o_unique_filer_windows = FALSE;
120
121 /* Static prototypes */
122 static void attach(FilerWindow *filer_window);
123 static void detach(FilerWindow *filer_window);
124 static void filer_window_destroyed(GtkWidget *widget,
125 FilerWindow *filer_window);
126 static void show_menu(Collection *collection, GdkEventButton *event,
127 int number_selected, gpointer user_data);
128 static gint focus_in(GtkWidget *widget,
129 GdkEventFocus *event,
130 FilerWindow *filer_window);
131 static gint focus_out(GtkWidget *widget,
132 GdkEventFocus *event,
133 FilerWindow *filer_window);
134 static void add_item(FilerWindow *filer_window, DirItem *item);
135 static void toolbar_up_clicked(GtkWidget *widget, FilerWindow *filer_window);
136 static void toolbar_home_clicked(GtkWidget *widget, FilerWindow *filer_window);
137 static void add_button(GtkWidget *box, int pixmap,
138 GtkSignalFunc cb, FilerWindow *filer_window,
139 char *label, char *tip);
140 static GtkWidget *create_toolbar(FilerWindow *filer_window);
141 static int filer_confirm_close(GtkWidget *widget, GdkEvent *event,
142 FilerWindow *window);
143 static int calc_width(FilerWindow *filer_window, DirItem *item);
144 static void draw_large_icon(GtkWidget *widget,
145 GdkRectangle *area,
146 DirItem *item,
147 gboolean selected);
148 static void draw_string(GtkWidget *widget,
149 GdkFont *font,
150 char *string,
151 int x,
152 int y,
153 int width,
154 gboolean selected);
155 static void draw_item_large(GtkWidget *widget,
156 CollectionItem *item,
157 GdkRectangle *area);
158 static void draw_item_small(GtkWidget *widget,
159 CollectionItem *item,
160 GdkRectangle *area);
161 static void draw_item_full_info(GtkWidget *widget,
162 CollectionItem *colitem,
163 GdkRectangle *area);
164 static gboolean test_point_large(Collection *collection,
165 int point_x, int point_y,
166 CollectionItem *item,
167 int width, int height);
168 static gboolean test_point_small(Collection *collection,
169 int point_x, int point_y,
170 CollectionItem *item,
171 int width, int height);
172 static gboolean test_point_full_info(Collection *collection,
173 int point_x, int point_y,
174 CollectionItem *item,
175 int width, int height);
176 static void update_display(Directory *dir,
177 DirAction action,
178 GPtrArray *items,
179 FilerWindow *filer_window);
180 static void set_scanning_display(FilerWindow *filer_window, gboolean scanning);
181 static void shrink_width(FilerWindow *filer_window);
182 static gboolean may_rescan(FilerWindow *filer_window, gboolean warning);
183 static void open_item(Collection *collection,
184 gpointer item_data, int item_number,
185 gpointer user_data);
186 static gboolean minibuffer_show_cb(FilerWindow *filer_window);
187 static FilerWindow *find_filer_window(char *path, FilerWindow *diff);
188 static void filer_set_title(FilerWindow *filer_window);
189 static gboolean exists(FilerWindow *filer_window);
190
191 static GdkAtom xa_string;
192 enum
193 {
194 TARGET_STRING,
195 TARGET_URI_LIST,
196 };
197
198 static GdkCursor *busy_cursor = NULL;
199 static GtkTooltips *tooltips = NULL;
200
201 void filer_init()
202 {
203 xa_string = gdk_atom_intern("STRING", FALSE);
204
205 options_sections = g_slist_prepend(options_sections, &options);
206 option_register("filer_new_window_on_1", filer_new_window_on_1);
207 option_register("filer_menu_on_2", filer_menu_on_2);
208 option_register("filer_single_click", filer_single_click);
209 option_register("filer_unique_windows", filer_unique_windows);
210 option_register("filer_toolbar", filer_toolbar);
211 option_register("filer_display_style", filer_display_style);
212 option_register("filer_sort_by", filer_sort_by);
213
214 busy_cursor = gdk_cursor_new(GDK_WATCH);
215
216 tooltips = gtk_tooltips_new();
217 }
218
219 static gboolean if_deleted(gpointer item, gpointer removed)
220 {
221 int i = ((GPtrArray *) removed)->len;
222 DirItem **r = (DirItem **) ((GPtrArray *) removed)->pdata;
223 char *leafname = ((DirItem *) item)->leafname;
224
225 while (i--)
226 {
227 if (strcmp(leafname, r[i]->leafname) == 0)
228 return TRUE;
229 }
230
231 return FALSE;
232 }
233
234 static void update_item(FilerWindow *filer_window, DirItem *item)
235 {
236 int i;
237 char *leafname = item->leafname;
238
239 if (leafname[0] == '.')
240 {
241 if (filer_window->show_hidden == FALSE || leafname[1] == '\0'
242 || (leafname[1] == '.' && leafname[2] == '\0'))
243 return;
244 }
245
246 i = collection_find_item(filer_window->collection, item, dir_item_cmp);
247
248 if (i >= 0)
249 collection_draw_item(filer_window->collection, i, TRUE);
250 else
251 g_warning("Failed to find '%s'\n", item->leafname);
252 }
253
254 static void update_display(Directory *dir,
255 DirAction action,
256 GPtrArray *items,
257 FilerWindow *filer_window)
258 {
259 int i;
260 int cursor = filer_window->collection->cursor_item;
261 char *as;
262 Collection *collection = filer_window->collection;
263
264 switch (action)
265 {
266 case DIR_ADD:
267 as = filer_window->auto_select;
268
269 for (i = 0; i < items->len; i++)
270 {
271 DirItem *item = (DirItem *) items->pdata[i];
272
273 add_item(filer_window, item);
274
275 if (cursor != -1 || !as)
276 continue;
277
278 if (strcmp(as, item->leafname) != 0)
279 continue;
280
281 cursor = collection->number_of_items - 1;
282 if (filer_window->had_cursor)
283 {
284 collection_set_cursor_item(collection,
285 cursor);
286 filer_window->mini_cursor_base = cursor;
287 }
288 else
289 collection_wink_item(collection,
290 cursor);
291 }
292
293 collection_qsort(filer_window->collection,
294 filer_window->sort_fn);
295 break;
296 case DIR_REMOVE:
297 collection_delete_if(filer_window->collection,
298 if_deleted,
299 items);
300 break;
301 case DIR_START_SCAN:
302 set_scanning_display(filer_window, TRUE);
303 break;
304 case DIR_END_SCAN:
305 if (filer_window->window->window)
306 gdk_window_set_cursor(
307 filer_window->window->window,
308 NULL);
309 shrink_width(filer_window);
310 if (filer_window->had_cursor &&
311 collection->cursor_item == -1)
312 {
313 collection_set_cursor_item(collection, 0);
314 filer_window->had_cursor = FALSE;
315 }
316 set_scanning_display(filer_window, FALSE);
317 break;
318 case DIR_UPDATE:
319 for (i = 0; i < items->len; i++)
320 {
321 DirItem *item = (DirItem *) items->pdata[i];
322
323 update_item(filer_window, item);
324 }
325 collection_qsort(filer_window->collection,
326 filer_window->sort_fn);
327 break;
328 }
329 }
330
331 static void attach(FilerWindow *filer_window)
332 {
333 gdk_window_set_cursor(filer_window->window->window, busy_cursor);
334 collection_clear(filer_window->collection);
335 filer_window->scanning = TRUE;
336 dir_attach(filer_window->directory, (DirCallback) update_display,
337 filer_window);
338 filer_set_title(filer_window);
339 }
340
341 static void detach(FilerWindow *filer_window)
342 {
343 g_return_if_fail(filer_window->directory != NULL);
344
345 dir_detach(filer_window->directory,
346 (DirCallback) update_display, filer_window);
347 g_fscache_data_unref(dir_cache, filer_window->directory);
348 filer_window->directory = NULL;
349 }
350
351 static void filer_window_destroyed(GtkWidget *widget,
352 FilerWindow *filer_window)
353 {
354 all_filer_windows = g_list_remove(all_filer_windows, filer_window);
355
356 if (window_with_selection == filer_window)
357 window_with_selection = NULL;
358 if (window_with_focus == filer_window)
359 window_with_focus = NULL;
360
361 if (filer_window->directory)
362 detach(filer_window);
363
364 g_free(filer_window->auto_select);
365 g_free(filer_window->path);
366 g_free(filer_window);
367
368 if (--number_of_windows < 1)
369 gtk_main_quit();
370 }
371
372 static int calc_width(FilerWindow *filer_window, DirItem *item)
373 {
374 int pix_width = item->image->width;
375
376 switch (filer_window->display_style)
377 {
378 case FULL_INFO:
379 return MAX_ICON_WIDTH + 12 +
380 MAX(item->details_width, item->name_width);
381 case SMALL_ICONS:
382 return SMALL_ICON_WIDTH + 12 + item->name_width;
383 default:
384 return MAX(pix_width, item->name_width) + 4;
385 }
386 }
387
388 /* Add a single object to a directory display */
389 static void add_item(FilerWindow *filer_window, DirItem *item)
390 {
391 char *leafname = item->leafname;
392 int item_width;
393
394 if (leafname[0] == '.')
395 {
396 if (filer_window->show_hidden == FALSE || leafname[1] == '\0'
397 || (leafname[1] == '.' && leafname[2] == '\0'))
398 return;
399 }
400
401 item_width = calc_width(filer_window, item);
402 if (item_width > filer_window->collection->item_width)
403 collection_set_item_size(filer_window->collection,
404 item_width,
405 filer_window->collection->item_height);
406 collection_insert(filer_window->collection, item);
407 }
408
409 /* Is a point inside an item? */
410 static gboolean test_point_large(Collection *collection,
411 int point_x, int point_y,
412 CollectionItem *colitem,
413 int width, int height)
414 {
415 DirItem *item = (DirItem *) colitem->data;
416 int text_height = item_font->ascent + item_font->descent;
417 MaskedPixmap *image = item->image;
418 int image_y = MAX(0, MAX_ICON_HEIGHT - image->height);
419 int image_width = (image->width >> 1) + 2;
420 int text_width = (item->name_width >> 1) + 2;
421 int x_limit;
422
423 if (point_y < image_y)
424 return FALSE; /* Too high up (don't worry about too low) */
425
426 if (point_y <= image_y + image->height + 2)
427 x_limit = image_width;
428 else if (point_y > height - text_height - 2)
429 x_limit = text_width;
430 else
431 x_limit = MIN(image_width, text_width);
432
433 return ABS(point_x - (width >> 1)) < x_limit;
434 }
435
436 static gboolean test_point_full_info(Collection *collection,
437 int point_x, int point_y,
438 CollectionItem *colitem,
439 int width, int height)
440 {
441 DirItem *item = (DirItem *) colitem->data;
442 MaskedPixmap *image = item->image;
443 int image_y = MAX(0, MAX_ICON_HEIGHT - image->height);
444 int low_top = height
445 - fixed_font->descent - 2 - fixed_font->ascent;
446
447 if (point_x < image->width + 2)
448 return point_x > 2 && point_y > image_y;
449
450 point_x -= MAX_ICON_WIDTH + 8;
451
452 if (point_y >= low_top)
453 return point_x < item->details_width;
454 if (point_y >= low_top - item_font->ascent - item_font->descent)
455 return point_x < item->name_width;
456 return FALSE;
457 }
458
459 static gboolean test_point_small(Collection *collection,
460 int point_x, int point_y,
461 CollectionItem *colitem,
462 int width, int height)
463 {
464 DirItem *item = (DirItem *) colitem->data;
465 MaskedPixmap *image = item->image;
466 int image_y = MAX(0, SMALL_ICON_HEIGHT - image->height);
467 int low_top = height
468 - fixed_font->descent - 2 - item_font->ascent;
469 int iwidth = MIN(SMALL_ICON_WIDTH, image->width);
470
471 if (point_x < iwidth + 2)
472 return point_x > 2 && point_y > image_y;
473
474 point_x -= SMALL_ICON_WIDTH + 4;
475
476 if (point_y >= low_top)
477 return point_x < item->name_width;
478 return FALSE;
479 }
480
481 static void draw_small_icon(GtkWidget *widget,
482 GdkRectangle *area,
483 DirItem *item,
484 gboolean selected)
485 {
486 MaskedPixmap *image = item->image;
487 int width = MIN(image->width, SMALL_ICON_WIDTH);
488 int height = MIN(image->height, SMALL_ICON_HEIGHT);
489 int image_x = area->x + ((area->width - width) >> 1);
490 int image_y;
491 GdkGC *gc = selected ? widget->style->white_gc
492 : widget->style->black_gc;
493 if (!item->image)
494 return;
495
496 gdk_gc_set_clip_mask(gc, item->image->mask);
497
498 image_y = MAX(0, SMALL_ICON_HEIGHT - image->height);
499 gdk_gc_set_clip_origin(gc, image_x, area->y + image_y);
500 gdk_draw_pixmap(widget->window, gc,
501 item->image->pixmap,
502 0, 0, /* Source x,y */
503 image_x, area->y + image_y, /* Dest x,y */
504 width, height);
505
506 if (selected)
507 {
508 gdk_gc_set_function(gc, GDK_INVERT);
509 gdk_draw_rectangle(widget->window,
510 gc,
511 TRUE, image_x, area->y + image_y,
512 width, height);
513 gdk_gc_set_function(gc, GDK_COPY);
514 }
515
516 if (item->flags & ITEM_FLAG_SYMLINK)
517 {
518 gdk_gc_set_clip_origin(gc, image_x, area->y + 8);
519 gdk_gc_set_clip_mask(gc,
520 default_pixmap[TYPE_SYMLINK].mask);
521 gdk_draw_pixmap(widget->window, gc,
522 default_pixmap[TYPE_SYMLINK].pixmap,
523 0, 0, /* Source x,y */
524 image_x, area->y + 8, /* Dest x,y */
525 -1, -1);
526 }
527 else if (item->flags & ITEM_FLAG_MOUNT_POINT)
528 {
529 int type = item->flags & ITEM_FLAG_MOUNTED
530 ? TYPE_MOUNTED
531 : TYPE_UNMOUNTED;
532 gdk_gc_set_clip_origin(gc, image_x, area->y + 8);
533 gdk_gc_set_clip_mask(gc,
534 default_pixmap[type].mask);
535 gdk_draw_pixmap(widget->window, gc,
536 default_pixmap[type].pixmap,
537 0, 0, /* Source x,y */
538 image_x, area->y + 8, /* Dest x,y */
539 -1, -1);
540 }
541
542 gdk_gc_set_clip_mask(gc, NULL);
543 gdk_gc_set_clip_origin(gc, 0, 0);
544 }
545
546 static void draw_large_icon(GtkWidget *widget,
547 GdkRectangle *area,
548 DirItem *item,
549 gboolean selected)
550 {
551 MaskedPixmap *image = item->image;
552 int width = MIN(image->width, MAX_ICON_WIDTH);
553 int height = MIN(image->height, MAX_ICON_WIDTH);
554 int image_x = area->x + ((area->width - width) >> 1);
555 int image_y;
556 GdkGC *gc = selected ? widget->style->white_gc
557 : widget->style->black_gc;
558
559 gdk_gc_set_clip_mask(gc, item->image->mask);
560
561 image_y = MAX(0, MAX_ICON_HEIGHT - image->height);
562 gdk_gc_set_clip_origin(gc, image_x, area->y + image_y);
563 gdk_draw_pixmap(widget->window, gc,
564 item->image->pixmap,
565 0, 0, /* Source x,y */
566 image_x, area->y + image_y, /* Dest x,y */
567 width, height);
568
569 if (selected)
570 {
571 gdk_gc_set_function(gc, GDK_INVERT);
572 gdk_draw_rectangle(widget->window,
573 gc,
574 TRUE, image_x, area->y + image_y,
575 width, height);
576 gdk_gc_set_function(gc, GDK_COPY);
577 }
578
579 if (item->flags & ITEM_FLAG_SYMLINK)
580 {
581 gdk_gc_set_clip_origin(gc, image_x, area->y + 8);
582 gdk_gc_set_clip_mask(gc,
583 default_pixmap[TYPE_SYMLINK].mask);
584 gdk_draw_pixmap(widget->window, gc,
585 default_pixmap[TYPE_SYMLINK].pixmap,
586 0, 0, /* Source x,y */
587 image_x, area->y + 8, /* Dest x,y */
588 -1, -1);
589 }
590 else if (item->flags & ITEM_FLAG_MOUNT_POINT)
591 {
592 int type = item->flags & ITEM_FLAG_MOUNTED
593 ? TYPE_MOUNTED
594 : TYPE_UNMOUNTED;
595 gdk_gc_set_clip_origin(gc, image_x, area->y + 8);
596 gdk_gc_set_clip_mask(gc,
597 default_pixmap[type].mask);
598 gdk_draw_pixmap(widget->window, gc,
599 default_pixmap[type].pixmap,
600 0, 0, /* Source x,y */
601 image_x, area->y + 8, /* Dest x,y */
602 -1, -1);
603 }
604
605 gdk_gc_set_clip_mask(gc, NULL);
606 gdk_gc_set_clip_origin(gc, 0, 0);
607 }
608
609 static void draw_string(GtkWidget *widget,
610 GdkFont *font,
611 char *string,
612 int x,
613 int y,
614 int width,
615 gboolean selected)
616 {
617 int text_height = font->ascent + font->descent;
618
619 if (selected)
620 gtk_paint_flat_box(widget->style, widget->window,
621 GTK_STATE_SELECTED, GTK_SHADOW_NONE,
622 NULL, widget, "text",
623 x, y - font->ascent,
624 width,
625 text_height);
626
627 gdk_draw_text(widget->window,
628 font,
629 selected ? widget->style->white_gc
630 : widget->style->black_gc,
631 x, y,
632 string, strlen(string));
633 }
634
635 /* Return a string (valid until next call) giving details
636 * of this item.
637 */
638 char *details(DirItem *item)
639 {
640 mode_t m = item->mode;
641 static guchar *buf = NULL;
642
643 if (buf)
644 g_free(buf);
645
646 if (item->lstat_errno)
647 buf = g_strdup_printf("lstat(2) failed: %s",
648 g_strerror(item->lstat_errno));
649 else
650 buf = g_strdup_printf("%s %s %-8.8s %-8.8s %s %s",
651 item->flags & ITEM_FLAG_APPDIR? "App " :
652 S_ISDIR(m) ? "Dir " :
653 S_ISCHR(m) ? "Char" :
654 S_ISBLK(m) ? "Blck" :
655 S_ISLNK(m) ? "Link" :
656 S_ISSOCK(m) ? "Sock" :
657 S_ISFIFO(m) ? "Pipe" : "File",
658 pretty_permissions(m),
659 user_name(item->uid),
660 group_name(item->gid),
661 format_size_aligned(item->size),
662 pretty_time(&item->mtime));
663 return buf;
664 }
665
666 static void draw_item_full_info(GtkWidget *widget,
667 CollectionItem *colitem,
668 GdkRectangle *area)
669 {
670 DirItem *item = (DirItem *) colitem->data;
671 MaskedPixmap *image = item->image;
672 int text_x = area->x + MAX_ICON_WIDTH + 8;
673 int low_text_y = area->y + area->height - fixed_font->descent - 2;
674 gboolean selected = colitem->selected;
675 GdkRectangle pic_area;
676
677 pic_area.x = area->x;
678 pic_area.y = area->y;
679 pic_area.width = image->width + 8;
680 pic_area.height = area->height;
681
682 draw_large_icon(widget, &pic_area, item, selected);
683
684 draw_string(widget,
685 item_font,
686 item->leafname,
687 text_x,
688 low_text_y - item_font->descent - fixed_font->ascent,
689 item->name_width,
690 selected);
691 draw_string(widget,
692 fixed_font,
693 details(item),
694 text_x, low_text_y,
695 item->details_width,
696 selected);
697
698 if (item->lstat_errno)
699 return;
700
701 /* Underline the effective permissions */
702 gdk_draw_rectangle(widget->window,
703 selected ? widget->style->white_gc
704 : widget->style->black_gc,
705 TRUE,
706 text_x - 1 + fixed_width *
707 (5 + 4 * applicable(item->uid, item->gid)),
708 low_text_y + fixed_font->descent - 1,
709 fixed_width * 3 + 1, 1);
710 }
711
712 static void draw_item_small(GtkWidget *widget,
713 CollectionItem *colitem,
714 GdkRectangle *area)
715 {
716 DirItem *item = (DirItem *) colitem->data;
717 int text_x = area->x + SMALL_ICON_WIDTH + 4;
718 int low_text_y = area->y + area->height - item_font->descent - 2;
719 gboolean selected = colitem->selected;
720 GdkRectangle pic_area;
721
722 pic_area.x = area->x;
723 pic_area.y = area->y;
724 pic_area.width = SMALL_ICON_WIDTH;
725 pic_area.height = SMALL_ICON_HEIGHT;
726
727 draw_small_icon(widget, &pic_area, item, selected);
728
729 draw_string(widget,
730 item_font,
731 item->leafname,
732 text_x,
733 low_text_y,
734 item->name_width,
735 selected);
736 }
737
738 static void draw_item_large(GtkWidget *widget,
739 CollectionItem *colitem,
740 GdkRectangle *area)
741 {
742 DirItem *item = (DirItem *) colitem->data;
743 int text_x = area->x + ((area->width - item->name_width) >> 1);
744 int text_y = area->y + area->height - item_font->descent - 2;
745 gboolean selected = colitem->selected;
746
747 draw_large_icon(widget, area, item, selected);
748
749 draw_string(widget,
750 item_font,
751 item->leafname,
752 text_x, text_y, item->name_width,
753 selected);
754 }
755
756 static void show_menu(Collection *collection, GdkEventButton *event,
757 int item, gpointer user_data)
758 {
759 show_filer_menu((FilerWindow *) user_data, event, item);
760 }
761
762 /* Returns TRUE iff the directory still exists. */
763 static gboolean may_rescan(FilerWindow *filer_window, gboolean warning)
764 {
765 Directory *dir;
766
767 g_return_val_if_fail(filer_window != NULL, FALSE);
768
769 /* We do a fresh lookup (rather than update) because the inode may
770 * have changed.
771 */
772 dir = g_fscache_lookup(dir_cache, filer_window->path);
773 if (!dir)
774 {
775 if (warning)
776 delayed_error("ROX-Filer", "Directory missing/deleted");
777 gtk_widget_destroy(filer_window->window);
778 return FALSE;
779 }
780 if (dir == filer_window->directory)
781 g_fscache_data_unref(dir_cache, dir);
782 else
783 {
784 detach(filer_window);
785 filer_window->directory = dir;
786 attach(filer_window);
787 }
788
789 return TRUE;
790 }
791
792 /* Another app has grabbed the selection */
793 static gint collection_lose_selection(GtkWidget *widget,
794 GdkEventSelection *event)
795 {
796 if (window_with_selection &&
797 window_with_selection->collection == COLLECTION(widget))
798 {
799 FilerWindow *filer_window = window_with_selection;
800 window_with_selection = NULL;
801 collection_clear_selection(filer_window->collection);
802 }
803
804 return TRUE;
805 }
806
807 /* Someone wants us to send them the selection */
808 static void selection_get(GtkWidget *widget,
809 GtkSelectionData *selection_data,
810 guint info,
811 guint time,
812 gpointer data)
813 {
814 GString *reply, *header;
815 FilerWindow *filer_window;
816 int i;
817 Collection *collection;
818
819 filer_window = gtk_object_get_data(GTK_OBJECT(widget), "filer_window");
820
821 reply = g_string_new(NULL);
822 header = g_string_new(NULL);
823
824 switch (info)
825 {
826 case TARGET_STRING:
827 g_string_sprintf(header, " %s",
828 make_path(filer_window->path, "")->str);
829 break;
830 case TARGET_URI_LIST:
831 g_string_sprintf(header, " file://%s%s",
832 our_host_name(),
833 make_path(filer_window->path, "")->str);
834 break;
835 }
836
837 collection = filer_window->collection;
838 for (i = 0; i < collection->number_of_items; i++)
839 {
840 if (collection->items[i].selected)
841 {
842 DirItem *item =
843 (DirItem *) collection->items[i].data;
844
845 g_string_append(reply, header->str);
846 g_string_append(reply, item->leafname);
847 }
848 }
849 /* This works, but I don't think I like it... */
850 /* g_string_append_c(reply, ' '); */
851
852 gtk_selection_data_set(selection_data, xa_string,
853 8, reply->str + 1, reply->len - 1);
854 g_string_free(reply, TRUE);
855 g_string_free(header, TRUE);
856 }
857
858 /* No items are now selected. This might be because another app claimed
859 * the selection or because the user unselected all the items.
860 */
861 static void lose_selection(Collection *collection,
862 guint time,
863 gpointer user_data)
864 {
865 FilerWindow *filer_window = (FilerWindow *) user_data;
866
867 if (window_with_selection == filer_window)
868 {
869 window_with_selection = NULL;
870 gtk_selection_owner_set(NULL,
871 GDK_SELECTION_PRIMARY,
872 time);
873 }
874 }
875
876 static void gain_selection(Collection *collection,
877 guint time,
878 gpointer user_data)
879 {
880 FilerWindow *filer_window = (FilerWindow *) user_data;
881
882 if (gtk_selection_owner_set(GTK_WIDGET(collection),
883 GDK_SELECTION_PRIMARY,
884 time))
885 {
886 window_with_selection = filer_window;
887 }
888 else
889 collection_clear_selection(filer_window->collection);
890 }
891
892 int sort_by_name(const void *item1, const void *item2)
893 {
894 return strcmp((*((DirItem **)item1))->leafname,
895 (*((DirItem **)item2))->leafname);
896 }
897
898 int sort_by_type(const void *item1, const void *item2)
899 {
900 const DirItem *i1 = (DirItem *) ((CollectionItem *) item1)->data;
901 const DirItem *i2 = (DirItem *) ((CollectionItem *) item2)->data;
902 MIME_type *m1, *m2;
903
904 int diff = i1->base_type - i2->base_type;
905
906 if (!diff)
907 diff = (i1->flags & ITEM_FLAG_APPDIR)
908 - (i2->flags & ITEM_FLAG_APPDIR);
909 if (diff)
910 return diff > 0 ? 1 : -1;
911
912 m1 = i1->mime_type;
913 m2 = i2->mime_type;
914
915 if (m1 && m2)
916 {
917 diff = strcmp(m1->media_type, m2->media_type);
918 if (!diff)
919 diff = strcmp(m1->subtype, m2->subtype);
920 }
921 else if (m1 || m2)
922 diff = m1 ? 1 : -1;
923 else
924 diff = 0;
925
926 if (diff)
927 return diff > 0 ? 1 : -1;
928
929 return sort_by_name(item1, item2);
930 }
931
932 int sort_by_date(const void *item1, const void *item2)
933 {
934 const DirItem *i1 = (DirItem *) ((CollectionItem *) item1)->data;
935 const DirItem *i2 = (DirItem *) ((CollectionItem *) item2)->data;
936
937 return i1->mtime > i2->mtime ? -1 :
938 i1->mtime < i2->mtime ? 1 :
939 sort_by_name(item1, item2);
940 }
941
942 int sort_by_size(const void *item1, const void *item2)
943 {
944 const DirItem *i1 = (DirItem *) ((CollectionItem *) item1)->data;
945 const DirItem *i2 = (DirItem *) ((CollectionItem *) item2)->data;
946
947 return i1->size > i2->size ? -1 :
948 i1->size < i2->size ? 1 :
949 sort_by_name(item1, item2);
950 }
951
952 static void open_item(Collection *collection,
953 gpointer item_data, int item_number,
954 gpointer user_data)
955 {
956 FilerWindow *filer_window = (FilerWindow *) user_data;
957 GdkEvent *event;
958 GdkEventButton *bevent;
959 GdkEventKey *kevent;
960 OpenFlags flags = 0;
961
962 event = (GdkEvent *) gtk_get_current_event();
963
964 bevent = (GdkEventButton *) event;
965 kevent = (GdkEventKey *) event;
966
967 switch (event->type)
968 {
969 case GDK_2BUTTON_PRESS:
970 case GDK_BUTTON_PRESS:
971 case GDK_BUTTON_RELEASE:
972 if (bevent->state & GDK_SHIFT_MASK)
973 flags |= OPEN_SHIFT;
974
975 if (o_new_window_on_1 ^ (bevent->button == 1))
976 flags |= OPEN_SAME_WINDOW;
977
978 if (bevent->button != 1)
979 flags |= OPEN_CLOSE_WINDOW;
980
981 if (o_single_click == FALSE &&
982 (bevent->state & GDK_CONTROL_MASK) != 0)
983 flags ^= OPEN_SAME_WINDOW | OPEN_CLOSE_WINDOW;
984 break;
985 case GDK_KEY_PRESS:
986 flags |= OPEN_SAME_WINDOW;
987 if (kevent->state & GDK_SHIFT_MASK)
988 flags |= OPEN_SHIFT;
989 break;
990 default:
991 break;
992 }
993
994 filer_openitem(filer_window, item_number, flags);
995 }
996
997 /* Return the full path to the directory containing object 'path'.
998 * Relative paths are resolved from the filerwindow's path.
999 */
1000 static void follow_symlink(FilerWindow *filer_window, char *path,
1001 gboolean same_window)
1002 {
1003 char *real, *slash;
1004 char *new_dir;
1005
1006 if (path[0] != '/')
1007 path = make_path(filer_window->path, path)->str;
1008
1009 real = pathdup(path);
1010 slash = strrchr(real, '/');
1011 if (!slash)
1012 {
1013 g_free(real);
1014 delayed_error("ROX-Filer",
1015 "Broken symlink (or you don't have permission "
1016 "to follow it).");
1017 return;
1018 }
1019
1020 *slash = '\0';
1021
1022 if (*real)
1023 new_dir = real;
1024 else
1025 new_dir = "/";
1026
1027 if (filer_window->panel_type || !same_window)
1028 {
1029 FilerWindow *new;
1030
1031 new = filer_opendir(new_dir, PANEL_NO);
1032 filer_set_autoselect(new, slash + 1);
1033 }
1034 else
1035 filer_change_to(filer_window, new_dir, slash + 1);
1036
1037 g_free(real);
1038 }
1039
1040 void filer_openitem(FilerWindow *filer_window, int item_number, OpenFlags flags)
1041 {
1042 gboolean shift = (flags & OPEN_SHIFT) != 0;
1043 gboolean close_mini = flags & OPEN_FROM_MINI;
1044 gboolean same_window = (flags & OPEN_SAME_WINDOW) != 0
1045 && !filer_window->panel_type;
1046 gboolean close_window = (flags & OPEN_CLOSE_WINDOW) != 0
1047 && !filer_window->panel_type;
1048 GtkWidget *widget;
1049 char *full_path;
1050 DirItem *item = (DirItem *)
1051 filer_window->collection->items[item_number].data;
1052 gboolean wink = TRUE, destroy = FALSE;
1053
1054 widget = filer_window->window;
1055 full_path = make_path(filer_window->path,
1056 item->leafname)->str;
1057
1058 if (item->flags & ITEM_FLAG_SYMLINK && shift)
1059 {
1060 char path[MAXPATHLEN + 1];
1061 int got;
1062
1063 got = readlink(make_path(filer_window->path,
1064 item->leafname)->str,
1065 path, MAXPATHLEN);
1066 if (got < 0)
1067 delayed_error("ROX-Filer", g_strerror(errno));
1068 else
1069 {
1070 g_return_if_fail(got <= MAXPATHLEN);
1071 path[got] = '\0';
1072
1073 follow_symlink(filer_window, path,
1074 flags & OPEN_SAME_WINDOW);
1075 }
1076 return;
1077 }
1078
1079 switch (item->base_type)
1080 {
1081 case TYPE_DIRECTORY:
1082 if (item->flags & ITEM_FLAG_APPDIR && !shift)
1083 {
1084 run_app(make_path(filer_window->path,
1085 item->leafname)->str);
1086 if (close_window)
1087 destroy = TRUE;
1088 break;
1089 }
1090
1091 if (item->flags & ITEM_FLAG_MOUNT_POINT && shift)
1092 {
1093 action_mount(filer_window, item);
1094 if (item->flags & ITEM_FLAG_MOUNTED)
1095 break;
1096 }
1097
1098 if (same_window)
1099 {
1100 wink = FALSE;
1101 filer_change_to(filer_window, full_path, NULL);
1102 close_mini = FALSE;
1103 }
1104 else
1105 filer_opendir(full_path, PANEL_NO);
1106 break;
1107 case TYPE_FILE:
1108 if ((item->flags & ITEM_FLAG_EXEC_FILE) && !shift)
1109 {
1110 char *argv[] = {NULL, NULL};
1111
1112 argv[0] = full_path;
1113
1114 if (spawn_full(argv, filer_window->path))
1115 {
1116 if (close_window)
1117 destroy = TRUE;
1118 }
1119 else
1120 report_error("ROX-Filer",
1121 "Failed to fork() child");
1122 }
1123 else
1124 {
1125 GString *message;
1126 MIME_type *type = shift ? &text_plain
1127 : item->mime_type;
1128
1129 g_return_if_fail(type != NULL);
1130
1131 if (type_open(full_path, type))
1132 {
1133 if (close_window)
1134 destroy = TRUE;
1135 }
1136 else
1137 {
1138 message = g_string_new(NULL);
1139 g_string_sprintf(message, "No open "
1140 "action specified for files of "
1141 "this type (%s/%s)",
1142 type->media_type,
1143 type->subtype);
1144 report_error("ROX-Filer", message->str);
1145 g_string_free(message, TRUE);
1146 }
1147 }
1148 break;
1149 default:
1150 report_error("open_item",
1151 "I don't know how to open that");
1152 break;
1153 }
1154
1155 if (destroy)
1156 gtk_widget_destroy(filer_window->window);
1157 else
1158 {
1159 if (wink)
1160 collection_wink_item(filer_window->collection,
1161 item_number);
1162 if (close_mini)
1163 minibuffer_hide(filer_window);
1164 }
1165 }
1166
1167 static gint pointer_in(GtkWidget *widget,
1168 GdkEventCrossing *event,
1169 FilerWindow *filer_window)
1170 {
1171 may_rescan(filer_window, TRUE);
1172 return FALSE;
1173 }
1174
1175 static gint focus_in(GtkWidget *widget,
1176 GdkEventFocus *event,
1177 FilerWindow *filer_window)
1178 {
1179 window_with_focus = filer_window;
1180
1181 return FALSE;
1182 }
1183
1184 static gint focus_out(GtkWidget *widget,
1185 GdkEventFocus *event,
1186 FilerWindow *filer_window)
1187 {
1188 /* TODO: Shade the cursor */
1189
1190 return FALSE;
1191 }
1192
1193 /* Handle keys that can't be bound with the menu */
1194 static gint key_press_event(GtkWidget *widget,
1195 GdkEventKey *event,
1196 FilerWindow *filer_window)
1197 {
1198 switch (event->keyval)
1199 {
1200 case GDK_BackSpace:
1201 change_to_parent(filer_window);
1202 break;
1203 default:
1204 return FALSE;
1205 }
1206
1207 return TRUE;
1208 }
1209
1210 static void toolbar_refresh_clicked(GtkWidget *widget,
1211 FilerWindow *filer_window)
1212 {
1213 full_refresh();
1214 update_dir(filer_window, TRUE);
1215 }
1216
1217 static void toolbar_home_clicked(GtkWidget *widget, FilerWindow *filer_window)
1218 {
1219 filer_change_to(filer_window, home_dir, NULL);
1220 }
1221
1222 static void toolbar_up_clicked(GtkWidget *widget, FilerWindow *filer_window)
1223 {
1224 change_to_parent(filer_window);
1225 }
1226
1227 void change_to_parent(FilerWindow *filer_window)
1228 {
1229 char *copy;
1230 char *slash;
1231
1232 if (filer_window->path[0] == '/' && filer_window->path[1] == '\0')
1233 return; /* Already in the root */
1234
1235 copy = g_strdup(filer_window->path);
1236 slash = strrchr(copy, '/');
1237
1238 if (slash)
1239 {
1240 *slash = '\0';
1241 filer_change_to(filer_window,
1242 *copy ? copy : "/",
1243 slash + 1);
1244 }
1245 else
1246 g_warning("No / in directory path!\n");
1247
1248 g_free(copy);
1249
1250 }
1251
1252 /* Make filer_window display path. When finished, highlight item 'from', or
1253 * the first item if from is NULL. If there is currently no cursor then
1254 * simply wink 'from' (if not NULL).
1255 */
1256 void filer_change_to(FilerWindow *filer_window, char *path, char *from)
1257 {
1258 char *from_dup;
1259 char *real_path = pathdup(path);
1260
1261 if (o_unique_filer_windows)
1262 {
1263 FilerWindow *fw;
1264
1265 fw = find_filer_window(real_path, filer_window);
1266 if (fw)
1267 gtk_widget_destroy(fw->window);
1268 }
1269
1270 from_dup = from && *from ? g_strdup(from) : NULL;
1271
1272 detach(filer_window);
1273 g_free(filer_window->path);
1274 filer_window->path = real_path;
1275
1276 filer_window->directory = g_fscache_lookup(dir_cache,
1277 filer_window->path);
1278 if (filer_window->directory)
1279 {
1280 g_free(filer_window->auto_select);
1281 filer_window->had_cursor =
1282 filer_window->collection->cursor_item != -1
1283 || filer_window->had_cursor;
1284 filer_window->auto_select = from_dup;
1285
1286 filer_set_title(filer_window);
1287 collection_set_cursor_item(filer_window->collection, -1);
1288 attach(filer_window);
1289
1290 if (GTK_WIDGET_VISIBLE(filer_window->minibuffer))
1291 gtk_idle_add((GtkFunction) minibuffer_show_cb,
1292 filer_window);
1293 }
1294 else
1295 {
1296 char *error;
1297
1298 g_free(from_dup);
1299 error = g_strdup_printf("Directory '%s' is not accessible.",
1300 path);
1301 delayed_error("ROX-Filer", error);
1302 g_free(error);
1303 gtk_widget_destroy(filer_window->window);
1304 }
1305 }
1306
1307 int selected_item_number(Collection *collection)
1308 {
1309 int i;
1310
1311 g_return_val_if_fail(collection != NULL, -1);
1312 g_return_val_if_fail(IS_COLLECTION(collection), -1);
1313 g_return_val_if_fail(collection->number_selected == 1, -1);
1314
1315 for (i = 0; i < collection->number_of_items; i++)
1316 if (collection->items[i].selected)
1317 return i;
1318
1319 g_warning("selected_item: number_selected is wrong\n");
1320
1321 return -1;
1322 }
1323
1324 DirItem *selected_item(Collection *collection)
1325 {
1326 int item;
1327
1328 item = selected_item_number(collection);
1329
1330 if (item > -1)
1331 return (DirItem *) collection->items[item].data;
1332 return NULL;
1333 }
1334
1335 static int filer_confirm_close(GtkWidget *widget, GdkEvent *event,
1336 FilerWindow *window)
1337 {
1338 /* TODO: We can open lots of these - very irritating! */
1339 return get_choice("Close panel?",
1340 "You have tried to close a panel via the window "
1341 "manager - I usually find that this is accidental... "
1342 "really close?",
1343 2, "Remove", "Cancel") != 0;
1344 }
1345
1346 /* Make the items as narrow as possible */
1347 static void shrink_width(FilerWindow *filer_window)
1348 {
1349 int i;
1350 Collection *col = filer_window->collection;
1351 int width = MIN_ITEM_WIDTH;
1352 int this_width;
1353 DisplayStyle style = filer_window->display_style;
1354 int text_height;
1355
1356 text_height = item_font->ascent + item_font->descent;
1357
1358 for (i = 0; i < col->number_of_items; i++)
1359 {
1360 this_width = calc_width(filer_window,
1361 (DirItem *) col->items[i].data);
1362 if (this_width > width)
1363 width = this_width;
1364 }
1365
1366 collection_set_item_size(filer_window->collection,
1367 width,
1368 style == FULL_INFO ? MAX_ICON_HEIGHT + 4 :
1369 style == SMALL_ICONS ? MAX(text_height, SMALL_ICON_HEIGHT) + 4
1370 : text_height + MAX_ICON_HEIGHT + 8);
1371 }
1372
1373 void filer_set_sort_fn(FilerWindow *filer_window,
1374 int (*fn)(const void *a, const void *b))
1375 {
1376 if (filer_window->sort_fn == fn)
1377 return;
1378
1379 filer_window->sort_fn = fn;
1380 last_sort_fn = fn;
1381
1382 collection_qsort(filer_window->collection,
1383 filer_window->sort_fn);
1384
1385 update_options_label();
1386 }
1387
1388 void filer_style_set(FilerWindow *filer_window, DisplayStyle style)
1389 {
1390 if (filer_window->display_style == style)
1391 return;
1392
1393 if (filer_window->panel_type)
1394 style = LARGE_ICONS;
1395 else
1396 last_display_style = style;
1397
1398 filer_window->display_style = style;
1399
1400 switch (style)
1401 {
1402 case SMALL_ICONS:
1403 collection_set_functions(filer_window->collection,
1404 draw_item_small, test_point_small);
1405 break;
1406 case FULL_INFO:
1407 collection_set_functions(filer_window->collection,
1408 draw_item_full_info, test_point_full_info);
1409 break;
1410 default:
1411 collection_set_functions(filer_window->collection,
1412 draw_item_large, test_point_large);
1413 break;
1414 }
1415
1416 shrink_width(filer_window);
1417
1418 update_options_label();
1419 }
1420
1421 FilerWindow *filer_opendir(char *path, PanelType panel_type)
1422 {
1423 GtkWidget *hbox, *scrollbar, *collection;
1424 FilerWindow *filer_window;
1425 GtkTargetEntry target_table[] =
1426 {
1427 {"text/uri-list", 0, TARGET_URI_LIST},
1428 {"STRING", 0, TARGET_STRING},
1429 };
1430 char *real_path;
1431
1432 real_path = pathdup(path);
1433
1434 if (o_unique_filer_windows && panel_type == PANEL_NO)
1435 {
1436 FilerWindow *fw;
1437
1438 fw = find_filer_window(real_path, NULL);
1439
1440 if (fw)
1441 {
1442 /* TODO: this should bring the window to the front
1443 * at the same coordinates.
1444 */
1445 gtk_widget_hide(fw->window);
1446 gtk_widget_show(fw->window);
1447 g_free(real_path);
1448 return fw;
1449 }
1450 }
1451
1452 filer_window = g_new(FilerWindow, 1);
1453 filer_window->minibuffer = NULL;
1454 filer_window->path = real_path;
1455 filer_window->scanning = FALSE;
1456 filer_window->had_cursor = FALSE;
1457 filer_window->auto_select = NULL;
1458
1459 filer_window->directory = g_fscache_lookup(dir_cache,
1460 filer_window->path);
1461 if (!filer_window->directory)
1462 {
1463 char *error;
1464
1465 error = g_strdup_printf("Directory '%s' not found.", path);
1466 delayed_error("ROX-Filer", error);
1467 g_free(error);
1468 g_free(filer_window->path);
1469 g_free(filer_window);
1470 return NULL;
1471 }
1472
1473 filer_window->show_hidden = last_show_hidden;
1474 filer_window->panel_type = panel_type;
1475 filer_window->temp_item_selected = FALSE;
1476 filer_window->sort_fn = last_sort_fn;
1477 filer_window->flags = (FilerFlags) 0;
1478 filer_window->display_style = UNKNOWN_STYLE;
1479
1480 filer_window->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1481 filer_set_title(filer_window);
1482
1483 collection = collection_new(NULL);
1484 gtk_object_set_data(GTK_OBJECT(collection),
1485 "filer_window", filer_window);
1486 filer_window->collection = COLLECTION(collection);
1487
1488 gtk_widget_add_events(filer_window->window, GDK_ENTER_NOTIFY);
1489 gtk_signal_connect(GTK_OBJECT(filer_window->window),
1490 "enter-notify-event",
1491 GTK_SIGNAL_FUNC(pointer_in), filer_window);
1492 gtk_signal_connect(GTK_OBJECT(filer_window->window), "focus_in_event",
1493 GTK_SIGNAL_FUNC(focus_in), filer_window);
1494 gtk_signal_connect(GTK_OBJECT(filer_window->window), "focus_out_event",
1495 GTK_SIGNAL_FUNC(focus_out), filer_window);
1496 gtk_signal_connect(GTK_OBJECT(filer_window->window), "destroy",
1497 filer_window_destroyed, filer_window);
1498
1499 gtk_signal_connect(GTK_OBJECT(filer_window->collection), "open_item",
1500 open_item, filer_window);
1501 gtk_signal_connect(GTK_OBJECT(collection), "show_menu",
1502 show_menu, filer_window);
1503 gtk_signal_connect(GTK_OBJECT(collection), "gain_selection",
1504 gain_selection, filer_window);
1505 gtk_signal_connect(GTK_OBJECT(collection), "lose_selection",
1506 lose_selection, filer_window);
1507 gtk_signal_connect(GTK_OBJECT(collection), "drag_selection",
1508 drag_selection, filer_window);
1509 gtk_signal_connect(GTK_OBJECT(collection), "drag_data_get",
1510 drag_data_get, filer_window);
1511 gtk_signal_connect(GTK_OBJECT(collection), "selection_clear_event",
1512 GTK_SIGNAL_FUNC(collection_lose_selection), NULL);
1513 gtk_signal_connect (GTK_OBJECT(collection), "selection_get",
1514 GTK_SIGNAL_FUNC(selection_get), NULL);
1515 gtk_selection_add_targets(collection, GDK_SELECTION_PRIMARY,
1516 target_table,
1517 sizeof(target_table) / sizeof(*target_table));
1518
1519 filer_style_set(filer_window, last_display_style);
1520 drag_set_dest(filer_window);
1521
1522 if (panel_type)
1523 {
1524 int swidth, sheight, iwidth, iheight;
1525 GtkWidget *frame, *win = filer_window->window;
1526
1527 gtk_window_set_wmclass(GTK_WINDOW(win), "ROX-Panel",
1528 "ROX-Filer");
1529 collection_set_panel(filer_window->collection, TRUE);
1530 gtk_signal_connect(GTK_OBJECT(filer_window->window),
1531 "delete_event",
1532 GTK_SIGNAL_FUNC(filer_confirm_close),
1533 filer_window);
1534
1535 gdk_window_get_size(GDK_ROOT_PARENT(), &swidth, &sheight);
1536 iwidth = filer_window->collection->item_width;
1537 iheight = filer_window->collection->item_height;
1538
1539 {
1540 int height = iheight + PANEL_BORDER;
1541 int y = panel_type == PANEL_TOP
1542 ? -PANEL_BORDER
1543 : sheight - height - PANEL_BORDER;
1544
1545 gtk_widget_set_usize(collection, swidth, height);
1546 gtk_widget_set_uposition(win, 0, y);
1547 }
1548
1549 frame = gtk_frame_new(NULL);
1550 gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);
1551 gtk_container_add(GTK_CONTAINER(frame), collection);
1552 gtk_container_add(GTK_CONTAINER(win), frame);
1553
1554 gtk_widget_show_all(frame);
1555 gtk_widget_realize(win);
1556 if (override_redirect)
1557 gdk_window_set_override_redirect(win->window, TRUE);
1558 make_panel_window(win->window);
1559 }
1560 else
1561 {
1562 GtkWidget *vbox;
1563 int col_height = ROW_HEIGHT_LARGE * 3;
1564
1565 gtk_signal_connect(GTK_OBJECT(collection),
1566 "key_press_event",
1567 GTK_SIGNAL_FUNC(key_press_event), filer_window);
1568 gtk_window_set_default_size(GTK_WINDOW(filer_window->window),
1569 filer_window->display_style == LARGE_ICONS ? 400 : 512,
1570 o_toolbar == TOOLBAR_NONE ? col_height:
1571 o_toolbar == TOOLBAR_NORMAL ? col_height + 24 :
1572 col_height + 38);
1573
1574 hbox = gtk_hbox_new(FALSE, 0);
1575 gtk_container_add(GTK_CONTAINER(filer_window->window),
1576 hbox);
1577
1578 vbox = gtk_vbox_new(FALSE, 0);
1579 gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
1580
1581 if (o_toolbar != TOOLBAR_NONE)
1582 {
1583 GtkWidget *toolbar;
1584
1585 toolbar = create_toolbar(filer_window);
1586 gtk_box_pack_start(GTK_BOX(vbox), toolbar,
1587 FALSE, TRUE, 0);
1588 gtk_widget_show_all(toolbar);
1589 }
1590
1591 gtk_box_pack_start(GTK_BOX(vbox), collection, TRUE, TRUE, 0);
1592
1593 filer_window->minibuffer = create_minibuffer(filer_window);
1594 gtk_box_pack_start(GTK_BOX(vbox), filer_window->minibuffer,
1595 FALSE, TRUE, 0);
1596
1597 scrollbar = gtk_vscrollbar_new(COLLECTION(collection)->vadj);
1598 gtk_box_pack_start(GTK_BOX(hbox), scrollbar, FALSE, TRUE, 0);
1599 gtk_accel_group_attach(filer_keys,
1600 GTK_OBJECT(filer_window->window));
1601 gtk_window_set_focus(GTK_WINDOW(filer_window->window),
1602 collection);
1603
1604 gtk_widget_show(hbox);
1605 gtk_widget_show(vbox);
1606 gtk_widget_show(scrollbar);
1607 gtk_widget_show(collection);
1608 }
1609
1610 number_of_windows++;
1611 gtk_widget_show(filer_window->window);
1612 attach(filer_window);
1613
1614 all_filer_windows = g_list_prepend(all_filer_windows, filer_window);
1615
1616 return filer_window;
1617 }
1618
1619 static gint clear_scanning_display(FilerWindow *filer_window)
1620 {
1621 if (exists(filer_window))
1622 filer_set_title(filer_window);
1623 return FALSE;
1624 }
1625
1626 static void set_scanning_display(FilerWindow *filer_window, gboolean scanning)
1627 {
1628 if (scanning == filer_window->scanning)
1629 return;
1630 filer_window->scanning = scanning;
1631
1632 if (scanning)
1633 filer_set_title(filer_window);
1634 else
1635 gtk_timeout_add(300, (GtkFunction) clear_scanning_display,
1636 filer_window);
1637 }
1638
1639 static GtkWidget *create_toolbar(FilerWindow *filer_window)
1640 {
1641 GtkWidget *frame, *box;
1642
1643 if (o_toolbar == TOOLBAR_GNOME)
1644 {
1645 frame = gtk_handle_box_new();
1646 box = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL,
1647 GTK_TOOLBAR_BOTH);
1648 gtk_container_set_border_width(GTK_CONTAINER(box), 2);
1649 gtk_toolbar_set_space_style(GTK_TOOLBAR(box),
1650 GTK_TOOLBAR_SPACE_LINE);
1651 gtk_toolbar_set_button_relief(GTK_TOOLBAR(box),
1652 GTK_RELIEF_NONE);
1653 }
1654 else
1655 {
1656 frame = gtk_frame_new(NULL);
1657 gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);
1658
1659 box = gtk_hbutton_box_new();
1660 gtk_button_box_set_child_size_default(16, 16);
1661 gtk_hbutton_box_set_spacing_default(2);
1662 gtk_button_box_set_layout(GTK_BUTTON_BOX(box),
1663 GTK_BUTTONBOX_START);
1664 }
1665
1666 gtk_container_add(GTK_CONTAINER(frame), box);
1667
1668 add_button(box, TOOLBAR_UP_ICON,
1669 GTK_SIGNAL_FUNC(toolbar_up_clicked),
1670 filer_window,
1671 "Up", "Change to parent directory");
1672 add_button(box, TOOLBAR_HOME_ICON,
1673 GTK_SIGNAL_FUNC(toolbar_home_clicked),
1674 filer_window,
1675 "Home", "Change to home directory");
1676 add_button(box, TOOLBAR_REFRESH_ICON,
1677 GTK_SIGNAL_FUNC(toolbar_refresh_clicked),
1678 filer_window,
1679 "Rescan", "Rescan directory contents");
1680
1681 return frame;
1682 }
1683
1684 static void add_button(GtkWidget *box, int pixmap,
1685 GtkSignalFunc cb, FilerWindow *filer_window,
1686 char *label, char *tip)
1687 {
1688 GtkWidget *button, *icon;
1689
1690 icon = gtk_pixmap_new(default_pixmap[pixmap].pixmap,
1691 default_pixmap[pixmap].mask);
1692
1693 if (o_toolbar == TOOLBAR_GNOME)
1694 {
1695 gtk_toolbar_append_element(GTK_TOOLBAR(box),
1696 GTK_TOOLBAR_CHILD_BUTTON,
1697 NULL,
1698 label,
1699 tip, NULL,
1700 icon,
1701 cb, filer_window);
1702 }
1703 else
1704 {
1705 button = gtk_button_new();
1706 GTK_WIDGET_UNSET_FLAGS(button, GTK_CAN_FOCUS);
1707
1708 gtk_container_add(GTK_CONTAINER(button), icon);
1709 gtk_signal_connect(GTK_OBJECT(button), "clicked",
1710 cb, filer_window);
1711
1712 gtk_tooltips_set_tip(tooltips, button, tip, NULL);
1713
1714 gtk_container_add(GTK_CONTAINER(box), button);
1715 }
1716 }
1717
1718 /* Build up some option widgets to go in the options dialog, but don't
1719 * fill them in yet.
1720 */
1721 static GtkWidget *create_options()
1722 {
1723 GtkWidget *vbox, *menu, *hbox;
1724
1725 vbox = gtk_vbox_new(FALSE, 0);
1726 gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
1727
1728 display_label = gtk_label_new("<>");
1729 gtk_label_set_line_wrap(GTK_LABEL(display_label), TRUE);
1730 gtk_box_pack_start(GTK_BOX(vbox), display_label, FALSE, TRUE, 0);
1731
1732 toggle_new_window_on_1 =
1733 gtk_check_button_new_with_label("New window on button 1 "
1734 "(RISC OS style)");
1735 gtk_box_pack_start(GTK_BOX(vbox), toggle_new_window_on_1,
1736 FALSE, TRUE, 0);
1737
1738 toggle_menu_on_2 =
1739 gtk_check_button_new_with_label("Menu on button 2 "
1740 "(RISC OS style)");
1741 gtk_box_pack_start(GTK_BOX(vbox), toggle_menu_on_2, FALSE, TRUE, 0);
1742
1743 toggle_single_click =
1744 gtk_check_button_new_with_label("Single-click nagivation");
1745 gtk_box_pack_start(GTK_BOX(vbox), toggle_single_click, FALSE, TRUE, 0);
1746
1747 toggle_unique_filer_windows =
1748 gtk_check_button_new_with_label("Unique windows");
1749 gtk_box_pack_start(GTK_BOX(vbox), toggle_unique_filer_windows, FALSE, TRUE, 0);
1750
1751 hbox = gtk_hbox_new(FALSE, 4);
1752 gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
1753
1754 gtk_box_pack_start(GTK_BOX(hbox),
1755 gtk_label_new("Toolbar type for new windows"),
1756 FALSE, TRUE, 0);
1757 menu_toolbar = gtk_option_menu_new();
1758 menu = gtk_menu_new();
1759 gtk_menu_append(GTK_MENU(menu), gtk_menu_item_new_with_label("None"));
1760 gtk_menu_append(GTK_MENU(menu), gtk_menu_item_new_with_label("Normal"));
1761 gtk_menu_append(GTK_MENU(menu), gtk_menu_item_new_with_label("GNOME"));
1762 gtk_option_menu_set_menu(GTK_OPTION_MENU(menu_toolbar), menu);
1763 gtk_box_pack_start(GTK_BOX(hbox), menu_toolbar, TRUE, TRUE, 0);
1764
1765 return vbox;
1766 }
1767
1768 static void update_options_label(void)
1769 {
1770 guchar *str;
1771
1772 str = g_strdup_printf("The last used display style (%s) and sort "
1773 "function (Sort By %s) will be saved if you click on "
1774 "Save.", style_to_name(), sort_fn_to_name());
1775 gtk_label_set_text(GTK_LABEL(display_label), str);
1776 g_free(str);
1777 }
1778
1779 /* Reflect current state by changing the widgets in the options box */
1780 static void update_options()
1781 {
1782 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle_new_window_on_1),
1783 o_new_window_on_1);
1784 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle_menu_on_2),
1785 collection_menu_button == 2 ? 1 : 0);
1786 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle_single_click),
1787 o_single_click);
1788 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle_unique_filer_windows),
1789 o_unique_filer_windows);
1790 gtk_option_menu_set_history(GTK_OPTION_MENU(menu_toolbar), o_toolbar);
1791
1792 update_options_label();
1793 }
1794
1795 /* Set current values by reading the states of the widgets in the options box */
1796 static void set_options()
1797 {
1798 GtkWidget *item, *menu;
1799 GList *list;
1800
1801 o_new_window_on_1 = gtk_toggle_button_get_active(
1802 GTK_TOGGLE_BUTTON(toggle_new_window_on_1));
1803
1804 collection_menu_button = gtk_toggle_button_get_active(
1805 GTK_TOGGLE_BUTTON(toggle_menu_on_2)) ? 2 : 3;
1806
1807 o_single_click = gtk_toggle_button_get_active(
1808 GTK_TOGGLE_BUTTON(toggle_single_click));
1809
1810 o_unique_filer_windows = gtk_toggle_button_get_active(
1811 GTK_TOGGLE_BUTTON(toggle_unique_filer_windows));
1812
1813 collection_single_click = o_single_click ? TRUE : FALSE;
1814
1815 menu = gtk_option_menu_get_menu(GTK_OPTION_MENU(menu_toolbar));
1816 item = gtk_menu_get_active(GTK_MENU(menu));
1817 list = gtk_container_children(GTK_CONTAINER(menu));
1818 o_toolbar = (ToolbarType) g_list_index(list, item);
1819 g_list_free(list);
1820
1821 }
1822
1823 static guchar *style_to_name(void)
1824 {
1825 return last_display_style == LARGE_ICONS ? "Large Icons" :
1826 last_display_style == SMALL_ICONS ? "Small Icons" :
1827 "Full Info";
1828 }
1829
1830 static guchar *sort_fn_to_name(void)
1831 {
1832 return last_sort_fn == sort_by_name ? "Name" :
1833 last_sort_fn == sort_by_type ? "Type" :
1834 last_sort_fn == sort_by_date ? "Date" :
1835 "Size";
1836 }
1837
1838 static void save_options()
1839 {
1840 option_write("filer_new_window_on_1", o_new_window_on_1 ? "1" : "0");
1841 option_write("filer_menu_on_2",
1842 collection_menu_button == 2 ? "1" : "0");
1843 option_write("filer_single_click", o_single_click ? "1" : "0");
1844 option_write("filer_unique_windows", o_unique_filer_windows ? "1" : "0");
1845 option_write("filer_display_style", style_to_name());
1846 option_write("filer_sort_by", sort_fn_to_name());
1847 option_write("filer_toolbar", o_toolbar == TOOLBAR_NONE ? "None" :
1848 o_toolbar == TOOLBAR_NORMAL ? "Normal" :
1849 o_toolbar == TOOLBAR_GNOME ? "GNOME" :
1850 "Unknown");
1851 }
1852
1853 static char *filer_new_window_on_1(char *data)
1854 {
1855 o_new_window_on_1 = atoi(data) != 0;
1856 return NULL;
1857 }
1858
1859 static char *filer_menu_on_2(char *data)
1860 {
1861 collection_menu_button = atoi(data) != 0 ? 2 : 3;
1862 return NULL;
1863 }
1864
1865 static char *filer_single_click(char *data)
1866 {
1867 o_single_click = atoi(data) != 0;
1868 collection_single_click = o_single_click ? TRUE : FALSE;
1869 return NULL;
1870 }
1871
1872 static char *filer_unique_windows(char *data)
1873 {
1874 o_unique_filer_windows = atoi(data) != 0;
1875 return NULL;
1876 }
1877
1878 static char *filer_display_style(char *data)
1879 {
1880 if (g_strcasecmp(data, "Large Icons") == 0)
1881 last_display_style = LARGE_ICONS;
1882 else if (g_strcasecmp(data, "Small Icons") == 0)
1883 last_display_style = SMALL_ICONS;
1884 else if (g_strcasecmp(data, "Full Info") == 0)
1885 last_display_style = FULL_INFO;
1886 else
1887 return "Unknown display style";
1888
1889 return NULL;
1890 }
1891
1892 static char *filer_sort_by(char *data)
1893 {
1894 if (g_strcasecmp(data, "Name") == 0)
1895 last_sort_fn = sort_by_name;
1896 else if (g_strcasecmp(data, "Type") == 0)
1897 last_sort_fn = sort_by_type;
1898 else if (g_strcasecmp(data, "Date") == 0)
1899 last_sort_fn = sort_by_date;
1900 else if (g_strcasecmp(data, "Size") == 0)
1901 last_sort_fn = sort_by_size;
1902 else
1903 return "Unknown sort type";
1904
1905 return NULL;
1906 }
1907
1908 static char *filer_toolbar(char *data)
1909 {
1910 if (g_strcasecmp(data, "None") == 0)
1911 o_toolbar = TOOLBAR_NONE;
1912 else if (g_strcasecmp(data, "Normal") == 0)
1913 o_toolbar = TOOLBAR_NORMAL;
1914 else if (g_strcasecmp(data, "GNOME") == 0)
1915 o_toolbar = TOOLBAR_GNOME;
1916 else
1917 return "Unknown toolbar type";
1918
1919 return NULL;
1920 }
1921
1922 /* Note that filer_window may not exist after this call. */
1923 void update_dir(FilerWindow *filer_window, gboolean warning)
1924 {
1925 if (may_rescan(filer_window, warning))
1926 dir_update(filer_window->directory, filer_window->path);
1927 }
1928
1929 void filer_set_hidden(FilerWindow *filer_window, gboolean hidden)
1930 {
1931 Directory *dir = filer_window->directory;
1932
1933 if (filer_window->show_hidden == hidden)
1934 return;
1935
1936 filer_window->show_hidden = hidden;
1937 last_show_hidden = hidden;
1938
1939 g_fscache_data_ref(dir_cache, dir);
1940 detach(filer_window);
1941 filer_window->directory = dir;
1942 attach(filer_window);
1943 }
1944
1945 /* Refresh the various caches even if we don't think we need to */
1946 void full_refresh(void)
1947 {
1948 mount_update(TRUE);
1949 }
1950
1951 /* See whether a filer window with a given path already exists
1952 * and is different from diff.
1953 */
1954 static FilerWindow *find_filer_window(char *path, FilerWindow *diff)
1955 {
1956 GList *next = all_filer_windows;
1957
1958 while (next)
1959 {
1960 FilerWindow *filer_window = (FilerWindow *) next->data;
1961
1962 if (filer_window->panel_type == PANEL_NO &&
1963 filer_window != diff &&
1964 strcmp(path, filer_window->path) == 0)
1965 {
1966 return filer_window;
1967 }
1968
1969 next = next->next;
1970 }
1971
1972 return NULL;
1973 }
1974
1975 /* This path has been mounted/umounted/deleted some files - update all dirs */
1976 void filer_check_mounted(char *path)
1977 {
1978 GList *next = all_filer_windows;
1979 int len;
1980
1981 len = strlen(path);
1982
1983 while (next)
1984 {
1985 FilerWindow *filer_window = (FilerWindow *) next->data;
1986
1987 next = next->next;
1988
1989 if (strncmp(path, filer_window->path, len) == 0)
1990 {
1991 char s = filer_window->path[len];
1992
1993 if (s == '/' || s == '\0')
1994 update_dir(filer_window, FALSE);
1995 }
1996 }
1997 }
1998
1999 /* Like minibuffer_show(), except that:
2000 * - It returns FALSE (to be used from an idle callback)
2001 * - It checks that the filer window still exists.
2002 */
2003 static gboolean minibuffer_show_cb(FilerWindow *filer_window)
2004 {
2005 if (exists(filer_window))
2006 minibuffer_show(filer_window);
2007 return FALSE;
2008 }
2009
2010 static gboolean exists(FilerWindow *filer_window)
2011 {
2012 GList *next;
2013
2014 for (next = all_filer_windows; next; next = next->next)
2015 {
2016 FilerWindow *fw = (FilerWindow *) next->data;
2017
2018 if (fw == filer_window)
2019 return TRUE;
2020 }
2021
2022 return FALSE;
2023 }
2024
2025 /* Highlight (wink or cursor) this item in the filer window. If the item
2026 * isn't already there but we're scanning then highlight it if it
2027 * appears later.
2028 */
2029 void filer_set_autoselect(FilerWindow *filer_window, guchar *leaf)
2030 {
2031 Collection *col = filer_window->collection;
2032 int i;
2033
2034 g_free(filer_window->auto_select);
2035 filer_window->auto_select = NULL;
2036
2037 for (i = 0; i < col->number_of_items; i++)
2038 {
2039 DirItem *item = (DirItem *) col->items[i].data;
2040
2041 if (strcmp(item->leafname, leaf) == 0)
2042 {
2043 if (col->cursor_item != -1)
2044 collection_set_cursor_item(col, i);
2045 else
2046 collection_wink_item(col, i);
2047 return;
2048 }
2049 }
2050
2051 filer_window->auto_select = g_strdup(leaf);
2052 }
2053
2054 static void filer_set_title(FilerWindow *filer_window)
2055 {
2056 if (filer_window->scanning)
2057 {
2058 guchar *title;
2059
2060 title = g_strdup_printf("%s (Scanning)", filer_window->path);
2061 gtk_window_set_title(GTK_WINDOW(filer_window->window),
2062 title);
2063 g_free(title);
2064 }
2065 else
2066 gtk_window_set_title(GTK_WINDOW(filer_window->window),
2067 filer_window->path);
2068 }
Filer for the ROX desktop