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