?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r33: Changed to using cursor to highlight panel items instead of selecting them.
[rox-filer.git] / ROX-Filer / src / filer.c
blob8462f8da36b614bdf3f5ed7bd26aafbe2d67b523
1 /* vi: set cindent:
2 * $Id$
3 *
4 * ROX-Filer, filer for the ROX desktop project
5 * By Thomas Leonard, <tal197@ecs.soton.ac.uk>.
6 */
7
8 /* filer.c - code for handling filer windows */
9
10 #include <stdlib.h>
11 #include <stdio.h>
12 #include <errno.h>
13 #include <sys/stat.h>
14 #include <unistd.h>
15 #include <time.h>
16
17 #include <gtk/gtk.h>
18 #include <gdk/gdkx.h>
19 #include <gdk/gdkprivate.h> /* XXX - find another way to do this */
20 #include <gdk/gdkkeysyms.h>
21 #include <collection.h>
22
23 #include "support.h"
24 #include "gui_support.h"
25 #include "filer.h"
26 #include "pixmaps.h"
27 #include "menu.h"
28 #include "dnd.h"
29 #include "apps.h"
30 #include "mount.h"
31
32 #define MAX_ICON_HEIGHT 42
33 #define PANEL_BORDER 2
34
35 FilerWindow *window_with_focus = NULL;
36
37 /* When a child process that changes a directory dies we need to know
38 * which filer window to update. Use this table.
39 */
40 GHashTable *child_to_filer = NULL;
41
42 static int number_of_windows = 0;
43 static FilerWindow *window_with_selection = NULL;
44 static FilerWindow *panel_with_timeout = NULL;
45 static gint panel_timeout;
46
47 /* Static prototypes */
48 static void filer_window_destroyed(GtkWidget *widget,
49 FilerWindow *filer_window);
50 static gboolean idle_scan_dir(gpointer data);
51 static void draw_item(GtkWidget *widget,
52 CollectionItem *item,
53 GdkRectangle *area);
54 void show_menu(Collection *collection, GdkEventButton *event,
55 int number_selected, gpointer user_data);
56 static int sort_by_name(const void *item1, const void *item2);
57 static void add_item(FilerWindow *filer_window, char *leafname);
58 static gboolean test_point(Collection *collection,
59 int point_x, int point_y,
60 CollectionItem *item,
61 int width, int height);
62 static void stop_scanning(FilerWindow *filer_window);
63 static gint focus_in(GtkWidget *widget,
64 GdkEventFocus *event,
65 FilerWindow *filer_window);
66 static gint focus_out(GtkWidget *widget,
67 GdkEventFocus *event,
68 FilerWindow *filer_window);
69
70 void filer_init()
71 {
72 child_to_filer = g_hash_table_new(NULL, NULL);
73 }
74
75 /* When a filer window is destroyed we call this for each entry in the
76 * child_to_filer hash table to remove old entries.
77 */
78 static gboolean child_eq(gpointer key, gpointer data, gpointer filer_window)
79 {
80 return data == filer_window;
81 }
82
83 /* Go though all the FileItems in a collection, freeing all the temp
84 * icons.
85 * TODO: Maybe we should cache icons?
86 */
87 static void free_temp_icons(FilerWindow *filer_window)
88 {
89 int i;
90 Collection *collection = filer_window->collection;
91
92 for (i = 0; i < collection->number_of_items; i++)
93 {
94 FileItem *item = (FileItem *) collection->items[i].data;
95 if (item->flags & ITEM_FLAG_TEMP_ICON)
96 {
97 gdk_pixmap_unref(item->image->pixmap);
98 gdk_pixmap_unref(item->image->mask);
99 g_free(item->image);
100 item->image = default_pixmap + TYPE_ERROR;
101 }
102 }
103 }
104
105 static void filer_window_destroyed(GtkWidget *widget,
106 FilerWindow *filer_window)
107 {
108 if (window_with_selection == filer_window)
109 window_with_selection = NULL;
110 if (window_with_focus == filer_window)
111 window_with_focus = NULL;
112 if (panel_with_timeout == filer_window)
113 {
114 /* Can this happen? */
115 panel_with_timeout = NULL;
116 gtk_timeout_remove(panel_timeout);
117 }
118
119 g_hash_table_foreach_remove(child_to_filer, child_eq, filer_window);
120
121 free_temp_icons(filer_window);
122 if (filer_window->dir)
123 stop_scanning(filer_window);
124 g_free(filer_window->path);
125 g_free(filer_window);
126
127 if (--number_of_windows < 1)
128 gtk_main_quit();
129 }
130
131 static void stop_scanning(FilerWindow *filer_window)
132 {
133 g_return_if_fail(filer_window->dir != NULL);
134
135 closedir(filer_window->dir);
136 gtk_idle_remove(filer_window->idle_scan_id);
137 filer_window->dir = NULL;
138 }
139
140 /* This is called while we are scanning the directory */
141 static gboolean idle_scan_dir(gpointer data)
142 {
143 struct dirent *next;
144 FilerWindow *filer_window = (FilerWindow *) data;
145
146 do
147 {
148 next = readdir(filer_window->dir);
149 if (!next)
150 {
151 closedir(filer_window->dir);
152 filer_window->dir = NULL;
153
154 collection_qsort(filer_window->collection,
155 sort_by_name);
156 return FALSE; /* Finished */
157 }
158
159 add_item(filer_window, next->d_name);
160 } while (!gtk_events_pending());
161
162 return TRUE;
163 }
164
165 /* Add a single object to a directory display */
166 static void add_item(FilerWindow *filer_window, char *leafname)
167 {
168 FileItem *item;
169 int item_width;
170 struct stat info;
171 int base_type;
172 GString *path;
173
174 /* Ignore dot files (should be an option) */
175 if (leafname[0] == '.')
176 return;
177
178 item = g_malloc(sizeof(FileItem));
179 item->leafname = g_strdup(leafname);
180 item->flags = 0;
181
182 path = make_path(filer_window->path, leafname);
183 if (lstat(path->str, &info))
184 base_type = TYPE_ERROR;
185 else
186 {
187 if (S_ISREG(info.st_mode))
188 base_type = TYPE_FILE;
189 else if (S_ISDIR(info.st_mode))
190 {
191 base_type = TYPE_DIRECTORY;
192
193 if (g_hash_table_lookup(mtab_mounts, path->str))
194 item->flags |= ITEM_FLAG_MOUNT_POINT
195 | ITEM_FLAG_MOUNTED;
196 else if (g_hash_table_lookup(fstab_mounts, path->str))
197 item->flags |= ITEM_FLAG_MOUNT_POINT;
198 }
199 else if (S_ISBLK(info.st_mode))
200 base_type = TYPE_BLOCK_DEVICE;
201 else if (S_ISCHR(info.st_mode))
202 base_type = TYPE_CHAR_DEVICE;
203 else if (S_ISFIFO(info.st_mode))
204 base_type = TYPE_PIPE;
205 else if (S_ISSOCK(info.st_mode))
206 base_type = TYPE_SOCKET;
207 else if (S_ISLNK(info.st_mode))
208 {
209 if (stat(path->str, &info))
210 {
211 base_type = TYPE_ERROR;
212 }
213 else
214 {
215 if (S_ISREG(info.st_mode))
216 base_type = TYPE_FILE;
217 else if (S_ISDIR(info.st_mode))
218 base_type = TYPE_DIRECTORY;
219 else if (S_ISBLK(info.st_mode))
220 base_type = TYPE_BLOCK_DEVICE;
221 else if (S_ISCHR(info.st_mode))
222 base_type = TYPE_CHAR_DEVICE;
223 else if (S_ISFIFO(info.st_mode))
224 base_type = TYPE_PIPE;
225 else if (S_ISSOCK(info.st_mode))
226 base_type = TYPE_SOCKET;
227 else
228 base_type = TYPE_UNKNOWN;
229 }
230
231 item->flags |= ITEM_FLAG_SYMLINK;
232 }
233 else
234 base_type = TYPE_UNKNOWN;
235 }
236
237 item->base_type = base_type;
238
239 if (base_type == TYPE_DIRECTORY)
240 {
241 /* Might be an application directory - better check... */
242 g_string_append(path, "/AppRun");
243 if (!stat(path->str, &info))
244 {
245 item->flags |= ITEM_FLAG_APPDIR;
246 }
247 }
248
249 if (item->flags & ITEM_FLAG_APPDIR) /* path still ends /AppRun */
250 {
251 MaskedPixmap *app_icon;
252
253 g_string_truncate(path, path->len - 3);
254 g_string_append(path, "Icon.xpm");
255 app_icon = load_pixmap_from(filer_window->window, path->str);
256 if (app_icon)
257 {
258 item->image = app_icon;
259 item->flags |= ITEM_FLAG_TEMP_ICON;
260 }
261 else
262 item->image = default_pixmap + TYPE_APPDIR;
263 }
264 else
265 item->image = default_pixmap + base_type;
266
267 item->text_width = gdk_string_width(filer_window->window->style->font,
268 leafname);
269
270 /* XXX: Must be a better way... */
271 item->pix_width = ((GdkPixmapPrivate *) item->image->pixmap)->width;
272 item->pix_height = ((GdkPixmapPrivate *) item->image->pixmap)->height;
273
274 item_width = MAX(item->pix_width, item->text_width) + 4;
275
276 if (item_width > filer_window->collection->item_width)
277 collection_set_item_size(filer_window->collection,
278 item_width,
279 filer_window->collection->item_height);
280
281 collection_insert(filer_window->collection, item);
282 }
283
284 static gboolean test_point(Collection *collection,
285 int point_x, int point_y,
286 CollectionItem *colitem,
287 int width, int height)
288 {
289 FileItem *item = (FileItem *) colitem->data;
290 GdkFont *font = GTK_WIDGET(collection)->style->font;
291 int text_height = font->ascent + font->descent;
292 int x_off = ABS(point_x - (width >> 1));
293 int image_y = MAX(0, MAX_ICON_HEIGHT - item->pix_height);
294
295 if (x_off <= (item->pix_width >> 1) + 2 &&
296 point_y >= image_y && point_y <= image_y + item->pix_height)
297 return TRUE;
298
299 if (x_off <= (item->text_width >> 1) + 2 &&
300 point_y > height - text_height - 2)
301 return TRUE;
302
303 return FALSE;
304 }
305
306 static void draw_item(GtkWidget *widget,
307 CollectionItem *colitem,
308 GdkRectangle *area)
309 {
310 FileItem *item = (FileItem *) colitem->data;
311 GdkGC *gc = colitem->selected ? widget->style->white_gc
312 : widget->style->black_gc;
313 int image_x = area->x + ((area->width - item->pix_width) >> 1);
314 GdkFont *font = widget->style->font;
315 int text_x = area->x + ((area->width - item->text_width) >> 1);
316 int text_y = area->y + area->height - font->descent - 2;
317 int text_height = font->ascent + font->descent;
318
319 if (item->image)
320 {
321 int image_y;
322
323 gdk_gc_set_clip_mask(gc, item->image->mask);
324
325 image_y = MAX(0, MAX_ICON_HEIGHT - item->pix_height);
326 gdk_gc_set_clip_origin(gc, image_x, area->y + image_y);
327 gdk_draw_pixmap(widget->window, gc,
328 item->image->pixmap,
329 0, 0, /* Source x,y */
330 image_x, area->y + image_y, /* Dest x,y */
331 -1, MIN(item->pix_height, MAX_ICON_HEIGHT));
332
333 if (item->flags & ITEM_FLAG_SYMLINK)
334 {
335 gdk_gc_set_clip_origin(gc, image_x, area->y + 8);
336 gdk_gc_set_clip_mask(gc,
337 default_pixmap[TYPE_SYMLINK].mask);
338 gdk_draw_pixmap(widget->window, gc,
339 default_pixmap[TYPE_SYMLINK].pixmap,
340 0, 0, /* Source x,y */
341 image_x, area->y + 8, /* Dest x,y */
342 -1, -1);
343 }
344 else if (item->flags & ITEM_FLAG_MOUNT_POINT)
345 {
346 int type = item->flags & ITEM_FLAG_MOUNTED
347 ? TYPE_MOUNTED
348 : TYPE_UNMOUNTED;
349 gdk_gc_set_clip_origin(gc, image_x, area->y + 8);
350 gdk_gc_set_clip_mask(gc,
351 default_pixmap[type].mask);
352 gdk_draw_pixmap(widget->window, gc,
353 default_pixmap[type].pixmap,
354 0, 0, /* Source x,y */
355 image_x, area->y + 8, /* Dest x,y */
356 -1, -1);
357 }
358
359 gdk_gc_set_clip_mask(gc, NULL);
360 gdk_gc_set_clip_origin(gc, 0, 0);
361 }
362
363 if (colitem->selected)
364 gtk_paint_flat_box(widget->style, widget->window,
365 GTK_STATE_SELECTED, GTK_SHADOW_NONE,
366 NULL, widget, "text",
367 text_x, text_y - font->ascent,
368 item->text_width,
369 text_height);
370
371 gdk_draw_text(widget->window,
372 widget->style->font,
373 colitem->selected ? widget->style->white_gc
374 : widget->style->black_gc,
375 text_x, text_y,
376 item->leafname, strlen(item->leafname));
377 }
378
379 void show_menu(Collection *collection, GdkEventButton *event,
380 int item, gpointer user_data)
381 {
382 show_filer_menu((FilerWindow *) user_data, event, item);
383 }
384
385 void scan_dir(FilerWindow *filer_window)
386 {
387 struct stat info;
388
389 if (filer_window->dir)
390 stop_scanning(filer_window);
391 if (panel_with_timeout == filer_window)
392 {
393 panel_with_timeout = NULL;
394 gtk_timeout_remove(panel_timeout);
395 }
396
397 mount_update();
398
399 collection_set_item_size(filer_window->collection, 64, 64);
400 free_temp_icons(filer_window);
401 collection_clear(filer_window->collection);
402 gtk_window_set_title(GTK_WINDOW(filer_window->window),
403 filer_window->path);
404
405 if (stat(filer_window->path, &info))
406 {
407 report_error("Error statting directory", g_strerror(errno));
408 return;
409 }
410 filer_window->m_time = info.st_mtime;
411
412 filer_window->dir = opendir(filer_window->path);
413 if (!filer_window->dir)
414 {
415 report_error("Error scanning directory", g_strerror(errno));
416 return;
417 }
418
419 filer_window->idle_scan_id = gtk_idle_add(idle_scan_dir, filer_window);
420 }
421
422 static void gain_selection(Collection *collection,
423 gint number_selected,
424 gpointer user_data)
425 {
426 FilerWindow *filer_window = (FilerWindow *) user_data;
427
428 if (window_with_selection && window_with_selection != filer_window)
429 collection_clear_selection(window_with_selection->collection);
430
431 window_with_selection = filer_window;
432 }
433
434 static int sort_by_name(const void *item1, const void *item2)
435 {
436 return strcmp((*((FileItem **)item1))->leafname,
437 (*((FileItem **)item2))->leafname);
438 }
439
440 static gint clear_panel_hilight(gpointer data)
441 {
442 collection_set_cursor_item(panel_with_timeout->collection, -1);
443 panel_with_timeout = NULL;
444
445 return FALSE;
446 }
447
448 /* It is possible to highlight an item briefly on a panel by calling this
449 * function.
450 */
451 void panel_set_timeout(FilerWindow *filer_window, gulong msec)
452 {
453 if (panel_with_timeout)
454 {
455 /* Can't have two timeouts at once */
456 gtk_timeout_remove(panel_timeout);
457 clear_panel_hilight(NULL);
458 }
459
460 if (filer_window)
461 {
462 panel_with_timeout = filer_window;
463 panel_timeout = gtk_timeout_add(msec,
464 clear_panel_hilight, NULL);
465 }
466 }
467
468 void open_item(Collection *collection,
469 gpointer item_data, int item_number,
470 gpointer user_data)
471 {
472 FilerWindow *filer_window = (FilerWindow *) user_data;
473 FileItem *item = (FileItem *) item_data;
474 GdkEventButton *event;
475 char *full_path;
476
477 event = (GdkEventButton *) gtk_get_current_event();
478 full_path = make_path(filer_window->path, item->leafname)->str;
479
480 if (filer_window->panel)
481 {
482 panel_set_timeout(NULL, 0);
483 collection_set_cursor_item(collection, item_number);
484 gdk_flush();
485 panel_set_timeout(filer_window, 200);
486 }
487
488 switch (item->base_type)
489 {
490 case TYPE_DIRECTORY:
491 if (item->flags & ITEM_FLAG_APPDIR &&
492 (event->type != GDK_2BUTTON_PRESS ||
493 (event->state & GDK_SHIFT_MASK) == 0))
494 {
495 run_app(make_path(filer_window->path,
496 item->leafname)->str);
497 break;
498 }
499 if (filer_window->panel == FALSE &&
500 (event->type != GDK_2BUTTON_PRESS ||
501 event->button == 1))
502 {
503 filer_window->path = pathdup(full_path);
504 scan_dir(filer_window);
505 }
506 else
507 filer_opendir(full_path, FALSE, BOTTOM);
508 break;
509 default:
510 report_error("open_item",
511 "I don't know how to open that");
512 break;
513 }
514 }
515
516 static gint pointer_in(GtkWidget *widget,
517 GdkEventCrossing *event,
518 FilerWindow *filer_window)
519 {
520 static time_t last_stat_time = 0;
521 static FilerWindow *last_stat_filer = NULL;
522 time_t now;
523
524 now = time(NULL);
525 if (now > last_stat_time + 1 || filer_window != last_stat_filer)
526 {
527 struct stat info;
528
529 last_stat_time = now;
530 last_stat_filer = filer_window;
531
532 if (stat(filer_window->path, &info))
533 gtk_widget_destroy(filer_window->window);
534 else if (info.st_mtime > filer_window->m_time)
535 scan_dir(filer_window);
536 }
537
538 return FALSE;
539 }
540
541 static gint focus_in(GtkWidget *widget,
542 GdkEventFocus *event,
543 FilerWindow *filer_window)
544 {
545 window_with_focus = filer_window;
546
547 return FALSE;
548 }
549
550 static gint focus_out(GtkWidget *widget,
551 GdkEventFocus *event,
552 FilerWindow *filer_window)
553 {
554 /* TODO: Shade the cursor */
555
556 return FALSE;
557 }
558
559 /* Handle keys that can't be bound with the menu */
560 static gint key_press_event(GtkWidget *widget,
561 GdkEventKey *event,
562 FilerWindow *filer_window)
563 {
564 switch (event->keyval)
565 {
566 /*
567 case GDK_Left:
568 move_cursor(-1, 0);
569 break;
570 case GDK_Right:
571 move_cursor(1, 0);
572 break;
573 case GDK_Up:
574 move_cursor(0, -1);
575 break;
576 case GDK_Down:
577 move_cursor(0, 1);
578 break;
579 case GDK_Return:
580 */
581 case GDK_BackSpace:
582 filer_window->path = pathdup(make_path(
583 filer_window->path,
584 "..")->str);
585 scan_dir(filer_window);
586 return TRUE;
587 }
588
589 return FALSE;
590 }
591
592
593 void filer_opendir(char *path, gboolean panel, Side panel_side)
594 {
595 GtkWidget *hbox, *scrollbar, *collection;
596 FilerWindow *filer_window;
597
598 filer_window = g_malloc(sizeof(FilerWindow));
599 filer_window->path = pathdup(path);
600 filer_window->dir = NULL; /* Not scanning */
601 filer_window->panel = panel;
602 filer_window->panel_side = panel_side;
603 filer_window->temp_item_selected = FALSE;
604
605 filer_window->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
606
607 collection = collection_new(NULL);
608 gtk_object_set_data(GTK_OBJECT(collection),
609 "filer_window", filer_window);
610 filer_window->collection = COLLECTION(collection);
611 collection_set_functions(filer_window->collection,
612 draw_item, test_point);
613
614 gtk_widget_add_events(filer_window->window, GDK_ENTER_NOTIFY);
615 gtk_signal_connect(GTK_OBJECT(filer_window->window),
616 "enter-notify-event",
617 GTK_SIGNAL_FUNC(pointer_in), filer_window);
618 gtk_signal_connect(GTK_OBJECT(filer_window->window), "focus_in_event",
619 GTK_SIGNAL_FUNC(focus_in), filer_window);
620 gtk_signal_connect(GTK_OBJECT(filer_window->window), "focus_out_event",
621 GTK_SIGNAL_FUNC(focus_out), filer_window);
622 gtk_signal_connect(GTK_OBJECT(filer_window->window), "key_press_event",
623 GTK_SIGNAL_FUNC(key_press_event), filer_window);
624 gtk_signal_connect(GTK_OBJECT(filer_window->window), "destroy",
625 filer_window_destroyed, filer_window);
626
627 gtk_signal_connect(GTK_OBJECT(filer_window->collection), "open_item",
628 open_item, filer_window);
629 gtk_signal_connect(GTK_OBJECT(collection), "show_menu",
630 show_menu, filer_window);
631 gtk_signal_connect(GTK_OBJECT(collection), "gain_selection",
632 gain_selection, filer_window);
633 gtk_signal_connect(GTK_OBJECT(collection), "drag_selection",
634 drag_selection, filer_window);
635 gtk_signal_connect(GTK_OBJECT(collection), "drag_data_get",
636 drag_data_get, filer_window);
637 drag_set_dest(collection);
638
639 if (panel)
640 {
641 int swidth, sheight, iwidth, iheight;
642 GtkWidget *frame, *win = filer_window->window;
643
644 collection_set_panel(filer_window->collection, TRUE);
645
646 gdk_window_get_size(GDK_ROOT_PARENT(), &swidth, &sheight);
647 iwidth = filer_window->collection->item_width;
648 iheight = filer_window->collection->item_height;
649
650 if (panel_side == TOP || panel_side == BOTTOM)
651 {
652 int height = iheight + PANEL_BORDER;
653 int y = panel_side == TOP
654 ? -PANEL_BORDER
655 : sheight - height - PANEL_BORDER;
656
657 gtk_widget_set_usize(collection, swidth, height);
658 gtk_widget_set_uposition(win, 0, y);
659 }
660 else
661 {
662 int width = iwidth + PANEL_BORDER;
663 int x = panel_side == LEFT
664 ? -PANEL_BORDER
665 : swidth - width - PANEL_BORDER;
666
667 gtk_widget_set_usize(collection, width, sheight);
668 gtk_widget_set_uposition(win, x, 0);
669 }
670
671 frame = gtk_frame_new(NULL);
672 gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);
673 gtk_container_add(GTK_CONTAINER(frame), collection);
674 gtk_container_add(GTK_CONTAINER(win), frame);
675
676 gtk_widget_realize(win);
677 make_panel_window(win->window);
678 }
679 else
680 {
681 gtk_window_set_default_size(GTK_WINDOW(filer_window->window),
682 400, 200);
683
684 hbox = gtk_hbox_new(FALSE, 0);
685 gtk_container_add(GTK_CONTAINER(filer_window->window), hbox);
686
687 gtk_box_pack_start(GTK_BOX(hbox), collection, TRUE, TRUE, 0);
688
689 scrollbar = gtk_vscrollbar_new(COLLECTION(collection)->vadj);
690 gtk_box_pack_start(GTK_BOX(hbox), scrollbar, FALSE, TRUE, 0);
691 }
692
693 gtk_widget_show_all(filer_window->window);
694 number_of_windows++;
695
696 load_default_pixmaps(collection->window);
697
698 gtk_accel_group_attach(filer_keys, GTK_OBJECT(filer_window->window));
699
700 scan_dir(filer_window);
701 }
Filer for the ROX desktop