?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r171: Fixed a compile problem on IRIX. Updating items now resorts.
[rox-filer.git] / ROX-Filer / src / action.c
blob753da1a122925b690ede42227d598a6e9e157cdf
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 /* action.c - code for handling the filer action windows.
23 * These routines generally fork() and talk to us via pipes.
24 */
25
26 #include "config.h"
27
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <unistd.h>
31 #include <errno.h>
32 #include <sys/types.h>
33 #include <sys/stat.h>
34 #include <signal.h>
35 #include <dirent.h>
36
37 #include "action.h"
38 #include "string.h"
39 #include "support.h"
40 #include "gui_support.h"
41 #include "filer.h"
42 #include "main.h"
43
44 static GdkColor red = {0, 0xffff, 0, 0};
45
46 typedef struct _GUIside GUIside;
47 typedef void ActionChild(gpointer data);
48 typedef gboolean ForDirCB(char *path, char *dest_path);
49
50 struct _GUIside
51 {
52 int from_child; /* File descriptor */
53 FILE *to_child;
54 int input_tag; /* gdk_input_add() */
55 GtkWidget *log, *window, *actions, *dir;
56 int child; /* Process ID */
57 int errors;
58 gboolean show_info; /* For Disk Usage */
59
60 char *next_dir; /* NULL => no timer active */
61 gint next_timer;
62 };
63
64 /* These don't need to be in a structure because we fork() before
65 * using them again.
66 */
67 static int from_parent = 0;
68 static FILE *to_parent = NULL;
69 static gboolean quiet = FALSE;
70 static GString *message = NULL;
71 static char *action_dest = NULL;
72 static gboolean (*action_do_func)(char *source, char *dest);
73 static size_t size_tally; /* For Disk Usage */
74 static DirItem *mount_item;
75
76 /* Static prototypes */
77 static gboolean send();
78 static gboolean send_error();
79 static gboolean send_dir(char *dir);
80 static gboolean read_exact(int source, char *buffer, ssize_t len);
81 static void do_mount(FilerWindow *filer_window, DirItem *item);
82
83 static gboolean display_dir(gpointer data)
84 {
85 GUIside *gui_side = (GUIside *) data;
86
87 gtk_label_set_text(GTK_LABEL(gui_side->dir), gui_side->next_dir + 1);
88 g_free(gui_side->next_dir);
89 gui_side->next_dir = NULL;
90
91 return FALSE;
92 }
93
94 /* Called when the child sends us a message */
95 static void message_from_child(gpointer data,
96 gint source,
97 GdkInputCondition condition)
98 {
99 char buf[5];
100 GUIside *gui_side = (GUIside *) data;
101 GtkWidget *log = gui_side->log;
102
103 if (read_exact(source, buf, 4))
104 {
105 ssize_t message_len;
106 char *buffer;
107
108 buf[4] = '\0';
109 message_len = strtol(buf, NULL, 16);
110 buffer = g_malloc(message_len + 1);
111 if (message_len > 0 && read_exact(source, buffer, message_len))
112 {
113 buffer[message_len] = '\0';
114 if (*buffer == '?')
115 gtk_widget_set_sensitive(gui_side->actions,
116 TRUE);
117 else if (*buffer == '+')
118 {
119 refresh_dirs(buffer + 1);
120 g_free(buffer);
121 return;
122 }
123 else if (*buffer == 'm')
124 {
125 filer_check_mounted(buffer + 1);
126 g_free(buffer);
127 return;
128 }
129 else if (*buffer == '/')
130 {
131 if (gui_side->next_dir)
132 g_free(gui_side->next_dir);
133 else
134 gui_side->next_timer =
135 gtk_timeout_add(500,
136 display_dir,
137 gui_side);
138 gui_side->next_dir = buffer;
139 return;
140 }
141 else if (*buffer == '!')
142 gui_side->errors++;
143
144 gtk_text_insert(GTK_TEXT(log),
145 NULL,
146 *buffer == '!' ? &red : NULL,
147 NULL,
148 buffer + 1, message_len - 1);
149 g_free(buffer);
150 return;
151 }
152 g_print("Child died in the middle of a message.\n");
153 }
154
155 /* The child is dead */
156 gui_side->child = 0;
157
158 fclose(gui_side->to_child);
159 close(gui_side->from_child);
160 gdk_input_remove(gui_side->input_tag);
161
162 if (gui_side->errors)
163 {
164 GString *report;
165 report = g_string_new(NULL);
166 g_string_sprintf(report, "There %s %d error%s.\n",
167 gui_side->errors == 1 ? "was" : "were",
168 gui_side->errors,
169 gui_side->errors == 1 ? "" : "s");
170 gtk_text_insert(GTK_TEXT(log), NULL, &red, NULL,
171 report->str, report->len);
172
173 g_string_free(report, TRUE);
174 }
175 else if (gui_side->show_info == FALSE)
176 gtk_widget_destroy(gui_side->window);
177 }
178
179 /* Scans src_dir, updating dest_path whenever cb returns TRUE */
180 static void for_dir_contents(ForDirCB *cb, char *src_dir, char *dest_path)
181 {
182 DIR *d;
183 struct dirent *ent;
184 GSList *list = NULL, *next;
185
186 d = opendir(src_dir);
187 if (!d)
188 {
189 send_error();
190 return;
191 }
192
193 send_dir(src_dir);
194
195 while ((ent = readdir(d)))
196 {
197 if (ent->d_name[0] == '.' && (ent->d_name[1] == '\0'
198 || (ent->d_name[1] == '.' && ent->d_name[2] == '\0')))
199 continue;
200 list = g_slist_append(list, g_strdup(make_path(src_dir,
201 ent->d_name)->str));
202 }
203 closedir(d);
204
205 if (!list)
206 return;
207
208 next = list;
209
210 while (next)
211 {
212 if (cb((char *) next->data, dest_path))
213 {
214 g_string_sprintf(message, "+%s", dest_path);
215 send();
216 }
217
218 g_free(next->data);
219 next = next->next;
220 }
221 g_slist_free(list);
222 return;
223 }
224
225 /* Read this many bytes into the buffer. TRUE on success. */
226 static gboolean read_exact(int source, char *buffer, ssize_t len)
227 {
228 while (len > 0)
229 {
230 ssize_t got;
231 got = read(source, buffer, len);
232 if (got < 1)
233 return FALSE;
234 len -= got;
235 buffer += got;
236 }
237 return TRUE;
238 }
239
240 /* Send 'message' to our parent process. TRUE on success. */
241 static gboolean send()
242 {
243 char len_buffer[5];
244 ssize_t len;
245
246 g_return_val_if_fail(message->len < 0xffff, FALSE);
247
248 sprintf(len_buffer, "%04x", message->len);
249 fwrite(len_buffer, 1, 4, to_parent);
250 len = fwrite(message->str, 1, message->len, to_parent);
251 fflush(to_parent);
252 return len == message->len;
253 }
254
255 /* Set the directory indicator at the top of the window */
256 static gboolean send_dir(char *dir)
257 {
258 g_string_sprintf(message, "/%s", dir);
259 return send();
260 }
261
262 static gboolean send_error()
263 {
264 g_string_sprintf(message, "!ERROR: %s\n", g_strerror(errno));
265 return send();
266 }
267
268 static void button_reply(GtkWidget *button, GUIside *gui_side)
269 {
270 char *text;
271
272 text = gtk_object_get_data(GTK_OBJECT(button), "send-code");
273 g_return_if_fail(text != NULL);
274 fputc(*text, gui_side->to_child);
275 fflush(gui_side->to_child);
276
277 gtk_widget_set_sensitive(gui_side->actions, FALSE);
278 }
279
280 /* Get one char from fd. Quit on error. */
281 static char reply(int fd)
282 {
283 ssize_t len;
284 char retval;
285
286 len = read(fd, &retval, 1);
287 if (len == 1)
288 return retval;
289
290 fprintf(stderr, "read() error: %s\n", g_strerror(errno));
291 _exit(1); /* Parent died? */
292 return '!';
293 }
294
295 static void destroy_action_window(GtkWidget *widget, gpointer data)
296 {
297 GUIside *gui_side = (GUIside *) data;
298
299 if (gui_side->child)
300 {
301 kill(gui_side->child, SIGTERM);
302 fclose(gui_side->to_child);
303 close(gui_side->from_child);
304 gdk_input_remove(gui_side->input_tag);
305 }
306
307 if (gui_side->next_dir)
308 {
309 gtk_timeout_remove(gui_side->next_timer);
310 g_free(gui_side->next_dir);
311 }
312 g_free(gui_side);
313
314 if (--number_of_windows < 1)
315 gtk_main_quit();
316 }
317
318 /* Create two pipes, fork() a child and return a pointer to a GUIside struct
319 * (NULL on failure). The child calls func().
320 */
321 static GUIside *start_action(gpointer data, ActionChild *func)
322 {
323 int filedes[4]; /* 0 and 2 are for reading */
324 GUIside *gui_side;
325 int child;
326 GtkWidget *vbox, *button, *control, *hbox, *scrollbar;
327
328 if (pipe(filedes))
329 {
330 report_error("ROX-Filer", g_strerror(errno));
331 return NULL;
332 }
333
334 if (pipe(filedes + 2))
335 {
336 close(filedes[0]);
337 close(filedes[1]);
338 report_error("ROX-Filer", g_strerror(errno));
339 return NULL;
340 }
341
342 child = fork();
343 switch (child)
344 {
345 case -1:
346 report_error("ROX-Filer", g_strerror(errno));
347 return NULL;
348 case 0:
349 /* We are the child */
350 message = g_string_new(NULL);
351 close(filedes[0]);
352 close(filedes[3]);
353 to_parent = fdopen(filedes[1], "wb");
354 from_parent = filedes[2];
355 func(data);
356 _exit(0);
357 }
358
359 /* We are the parent */
360 close(filedes[1]);
361 close(filedes[2]);
362 gui_side = g_malloc(sizeof(GUIside));
363 gui_side->from_child = filedes[0];
364 gui_side->to_child = fdopen(filedes[3], "wb");
365 gui_side->log = NULL;
366 gui_side->child = child;
367 gui_side->errors = 0;
368 gui_side->show_info = FALSE;
369
370 gui_side->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
371 gtk_window_set_default_size(GTK_WINDOW(gui_side->window), 500, 100);
372 gtk_signal_connect(GTK_OBJECT(gui_side->window), "destroy",
373 GTK_SIGNAL_FUNC(destroy_action_window), gui_side);
374
375 vbox = gtk_vbox_new(FALSE, 4);
376 gtk_container_add(GTK_CONTAINER(gui_side->window), vbox);
377
378 gui_side->dir = gtk_label_new("<dir>");
379 gui_side->next_dir = NULL;
380 gtk_misc_set_alignment(GTK_MISC(gui_side->dir), 0.5, 0.5);
381 gtk_box_pack_start(GTK_BOX(vbox), gui_side->dir, FALSE, TRUE, 0);
382
383 hbox = gtk_hbox_new(FALSE, 0);
384 gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
385
386 gui_side->log = gtk_text_new(NULL, NULL);
387 gtk_box_pack_start(GTK_BOX(hbox), gui_side->log, TRUE, TRUE, 0);
388 scrollbar = gtk_vscrollbar_new(GTK_TEXT(gui_side->log)->vadj);
389 gtk_box_pack_start(GTK_BOX(hbox), scrollbar, FALSE, TRUE, 0);
390
391 gui_side->actions = gtk_hbox_new(TRUE, 4);
392 gtk_box_pack_start(GTK_BOX(vbox), gui_side->actions, FALSE, TRUE, 0);
393
394 button = gtk_button_new_with_label("Always");
395 gtk_object_set_data(GTK_OBJECT(button), "send-code", "A");
396 gtk_box_pack_start(GTK_BOX(gui_side->actions), button, TRUE, TRUE, 0);
397 gtk_signal_connect(GTK_OBJECT(button), "clicked",
398 button_reply, gui_side);
399 button = gtk_button_new_with_label("Yes");
400 gtk_object_set_data(GTK_OBJECT(button), "send-code", "Y");
401 gtk_box_pack_start(GTK_BOX(gui_side->actions), button, TRUE, TRUE, 0);
402 gtk_signal_connect(GTK_OBJECT(button), "clicked",
403 button_reply, gui_side);
404 button = gtk_button_new_with_label("No");
405 gtk_object_set_data(GTK_OBJECT(button), "send-code", "N");
406 gtk_box_pack_start(GTK_BOX(gui_side->actions), button, TRUE, TRUE, 0);
407 gtk_signal_connect(GTK_OBJECT(button), "clicked",
408 button_reply, gui_side);
409 gtk_widget_set_sensitive(gui_side->actions, FALSE);
410
411 control = gtk_hbox_new(TRUE, 4);
412 gtk_box_pack_start(GTK_BOX(vbox), control, FALSE, TRUE, 0);
413
414 button = gtk_button_new_with_label("Suspend");
415 gtk_box_pack_start(GTK_BOX(control), button, TRUE, TRUE, 0);
416
417 button = gtk_button_new_with_label("Resume");
418 gtk_widget_set_sensitive(button, FALSE);
419 gtk_box_pack_start(GTK_BOX(control), button, TRUE, TRUE, 0);
420
421 button = gtk_button_new_with_label("Abort");
422 gtk_box_pack_start(GTK_BOX(control), button, TRUE, TRUE, 0);
423 gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
424 gtk_widget_destroy, GTK_OBJECT(gui_side->window));
425
426 gui_side->input_tag = gdk_input_add(gui_side->from_child,
427 GDK_INPUT_READ,
428 message_from_child,
429 gui_side);
430
431 return gui_side;
432 }
433
434 /* ACTIONS ON ONE ITEM */
435
436 /* These may call themselves recursively, or ask questions, etc.
437 * TRUE iff the directory containing dest_path needs to be rescanned.
438 */
439
440 /* dest_path is the dir containing src_path.
441 * Updates the global size_tally.
442 */
443 static gboolean do_usage(char *src_path, char *dest_path)
444 {
445 struct stat info;
446
447 if (lstat(src_path, &info))
448 {
449 g_string_sprintf(message, "'%s:\n", src_path);
450 send();
451 send_error();
452 return FALSE;
453 }
454
455 if (S_ISREG(info.st_mode) || S_ISLNK(info.st_mode))
456 size_tally += info.st_size;
457 else if (S_ISDIR(info.st_mode))
458 {
459 char *safe_path;
460 safe_path = g_strdup(src_path);
461 for_dir_contents(do_usage, safe_path, safe_path);
462 g_free(safe_path);
463 }
464
465 return FALSE;
466 }
467
468 /* dest_path is the dir containing src_path */
469 static gboolean do_delete(char *src_path, char *dest_path)
470 {
471 struct stat info;
472 gboolean write_prot;
473 char rep;
474
475 if (lstat(src_path, &info))
476 {
477 send_error();
478 return FALSE;
479 }
480
481 write_prot = S_ISLNK(info.st_mode) ? FALSE
482 : access(src_path, W_OK) != 0;
483 if (quiet == 0 || write_prot)
484 {
485 g_string_sprintf(message, "?Delete %s'%s'?\n",
486 write_prot ? "WRITE-PROTECTED " : " ",
487 src_path);
488 send();
489 rep = reply(from_parent);
490 if (rep == 'A')
491 quiet = TRUE;
492 else if (rep != 'Y')
493 return FALSE;
494 }
495 if (S_ISDIR(info.st_mode))
496 {
497 char *safe_path;
498 safe_path = g_strdup(src_path);
499 for_dir_contents(do_delete, safe_path, safe_path);
500 if (rmdir(safe_path))
501 {
502 g_free(safe_path);
503 send_error();
504 return FALSE;
505 }
506 g_string_assign(message, "'Directory deleted\n");
507 send();
508 g_free(safe_path);
509 }
510 else if (unlink(src_path) == 0)
511 {
512 g_string_sprintf(message, "'Deleted '%s'\n", src_path);
513 send();
514 }
515 else
516 {
517 send_error();
518 return FALSE;
519 }
520
521 return TRUE;
522 }
523
524 static gboolean do_copy(char *path, char *dest)
525 {
526 char *dest_path;
527 char *leaf;
528 struct stat info;
529 gboolean retval = TRUE;
530
531 leaf = strrchr(path, '/');
532 if (!leaf)
533 leaf = path; /* Error? */
534 else
535 leaf++;
536
537 dest_path = make_path(dest, leaf)->str;
538
539 g_string_sprintf(message, "'Copying %s as %s\n", path, dest_path);
540 send();
541
542 if (access(dest_path, F_OK) == 0)
543 {
544 char rep;
545 g_string_sprintf(message, "?'%s' already exists - overwrite?\n",
546 dest_path);
547 send();
548
549 rep = reply(from_parent);
550 if (rep == 'A')
551 quiet = TRUE;
552 else if (rep != 'Y')
553 return FALSE;
554 }
555
556 if (lstat(path, &info))
557 {
558 send_error();
559 return FALSE;
560 }
561
562 if (S_ISDIR(info.st_mode))
563 {
564 char *safe_path, *safe_dest;
565 struct stat dest_info;
566 gboolean exists;
567
568 /* (we will do the update ourselves now, rather than
569 * afterwards)
570 */
571 retval = FALSE;
572
573 safe_path = g_strdup(path);
574 safe_dest = g_strdup(dest_path);
575
576 exists = !lstat(dest_path, &dest_info);
577
578 if (exists && !S_ISDIR(dest_info.st_mode))
579 {
580 g_string_sprintf(message,
581 "!ERROR: Destination already exists, "
582 "but is not a directory\n");
583 }
584 else if (exists == FALSE && mkdir(dest_path, info.st_mode))
585 send_error();
586 else
587 {
588 if (!exists)
589 {
590 /* (just been created then) */
591 g_string_sprintf(message, "+%s", dest);
592 send();
593 }
594
595 for_dir_contents(do_copy, safe_path, safe_dest);
596 /* Note: dest_path now invalid... */
597 }
598
599 g_free(safe_path);
600 g_free(safe_dest);
601 }
602 else
603 {
604 g_string_sprintf(message, "cp -af %s %s", path, dest_path);
605 if (system(message->str))
606 {
607 g_string_sprintf(message, "!ERROR: %s\n",
608 "Copy failed\n");
609 send();
610 retval = FALSE;
611 }
612 }
613
614 return retval;
615 }
616
617 static gboolean do_move(char *path, char *dest)
618 {
619 char *dest_path;
620 char *leaf;
621 gboolean retval = TRUE;
622
623 leaf = strrchr(path, '/');
624 if (!leaf)
625 leaf = path; /* Error? */
626 else
627 leaf++;
628
629 dest_path = make_path(dest, leaf)->str;
630
631 g_string_sprintf(message, "'Moving %s into %s...\n", path, dest);
632 send();
633
634 if (access(dest_path, F_OK) == 0)
635 {
636 char rep;
637 struct stat info;
638
639 g_string_sprintf(message, "?'%s' already exists - overwrite?\n",
640 dest_path);
641 send();
642
643 rep = reply(from_parent);
644 if (rep == 'A')
645 quiet = TRUE;
646 else if (rep != 'Y')
647 return FALSE;
648
649 if (lstat(dest_path, &info))
650 {
651 send_error();
652 return FALSE;
653 }
654
655 if (S_ISDIR(info.st_mode))
656 {
657 char *safe_path, *safe_dest;
658
659 safe_path = g_strdup(path);
660 safe_dest = g_strdup(dest_path);
661 for_dir_contents(do_move, safe_path, safe_dest);
662 g_free(safe_dest);
663 if (rmdir(safe_path))
664 {
665 g_free(safe_path);
666 send_error();
667 return FALSE;
668 }
669 g_string_assign(message, "'Directory deleted\n");
670 send();
671 g_free(safe_path);
672 g_string_sprintf(message, "+%s", path);
673 g_string_truncate(message, leaf - path);
674 send();
675 return TRUE;
676 }
677 }
678
679 g_string_sprintf(message, "mv -f %s %s", path, dest);
680 if (system(message->str) == 0)
681 {
682 g_string_sprintf(message, "+%s", path);
683 g_string_truncate(message, leaf - path);
684 send();
685 }
686 else
687 {
688 g_string_sprintf(message, "!ERROR: Failed to move %s as %s\n",
689 path, dest_path);
690 retval = FALSE;
691 }
692 send();
693
694 return retval;
695 }
696
697 static gboolean do_link(char *path, char *dest)
698 {
699 char *dest_path;
700 char *leaf;
701
702 leaf = strrchr(path, '/');
703 if (!leaf)
704 leaf = path; /* Error? */
705 else
706 leaf++;
707
708 dest_path = make_path(dest, leaf)->str;
709
710 if (symlink(path, dest_path))
711 {
712 send_error();
713 return FALSE;
714 }
715 else
716 {
717 g_string_sprintf(message, "'Symlinked %s as %s\n",
718 path, dest_path);
719 send();
720 }
721
722 return TRUE;
723 }
724
725 /* Mount/umount this item */
726 static void do_mount(FilerWindow *filer_window, DirItem *item)
727 {
728 char *command;
729 char *path;
730
731 path = make_path(filer_window->path, item->leafname)->str;
732
733 command = g_strdup_printf("%smount %s",
734 item->flags & ITEM_FLAG_MOUNTED ? "u" : "", path);
735 g_string_sprintf(message, "'> %s\n", command);
736 send();
737 if (system(command) == 0)
738 {
739 g_string_sprintf(message, "+%s", filer_window->path);
740 send();
741 g_string_sprintf(message, "m%s", path);
742 send();
743 }
744 else
745 {
746 g_string_sprintf(message, "!Operation failed.\n");
747 send();
748 }
749 g_free(command);
750 }
751
752 /* CHILD MAIN LOOPS */
753
754 /* After forking, the child calls one of these functions */
755
756 static void usage_cb(gpointer data)
757 {
758 FilerWindow *filer_window = (FilerWindow *) data;
759 Collection *collection = filer_window->collection;
760 DirItem *item;
761 int left = collection->number_selected;
762 int i = -1;
763 off_t total_size = 0;
764
765 send_dir(filer_window->path);
766
767 while (left > 0)
768 {
769 i++;
770 if (!collection->items[i].selected)
771 continue;
772 item = (DirItem *) collection->items[i].data;
773 size_tally = 0;
774 do_usage(make_path(filer_window->path,
775 item->leafname)->str,
776 filer_window->path);
777 g_string_sprintf(message, "'%s: %s\n",
778 item->leafname,
779 format_size((unsigned long) size_tally));
780 send();
781 total_size += size_tally;
782 left--;
783 }
784
785 g_string_sprintf(message, "'\nTotal: %s\n",
786 format_size((unsigned long) total_size));
787 send();
788 }
789
790 #ifdef DO_MOUNT_POINTS
791 static void mount_cb(gpointer data)
792 {
793 FilerWindow *filer_window = (FilerWindow *) data;
794 Collection *collection = filer_window->collection;
795 DirItem *item;
796 int i;
797 gboolean mount_points = FALSE;
798
799 send_dir(filer_window->path);
800
801 if (mount_item)
802 do_mount(filer_window, mount_item);
803 else
804 {
805 for (i = 0; i < collection->number_of_items; i++)
806 {
807 if (!collection->items[i].selected)
808 continue;
809 item = (DirItem *) collection->items[i].data;
810 if (!(item->flags & ITEM_FLAG_MOUNT_POINT))
811 continue;
812 mount_points = TRUE;
813
814 do_mount(filer_window, item);
815 }
816
817 if (!mount_points)
818 {
819 g_string_sprintf(message,
820 "!No mount points selected!\n");
821 send();
822 }
823 }
824
825 g_string_sprintf(message, "'\nDone\n");
826 send();
827 }
828 #endif
829
830 static void delete_cb(gpointer data)
831 {
832 FilerWindow *filer_window = (FilerWindow *) data;
833 Collection *collection = filer_window->collection;
834 DirItem *item;
835 int left = collection->number_selected;
836 int i = -1;
837
838 send_dir(filer_window->path);
839
840 while (left > 0)
841 {
842 i++;
843 if (!collection->items[i].selected)
844 continue;
845 item = (DirItem *) collection->items[i].data;
846 if (do_delete(make_path(filer_window->path,
847 item->leafname)->str,
848 filer_window->path))
849 {
850 g_string_sprintf(message, "+%s", filer_window->path);
851 send();
852 }
853 left--;
854 }
855
856 g_string_sprintf(message, "'\nDone\n");
857 send();
858 }
859
860 static void list_cb(gpointer data)
861 {
862 GSList *paths = (GSList *) data;
863
864 while (paths)
865 {
866 send_dir((char *) paths->data);
867
868 if (action_do_func((char *) paths->data, action_dest))
869 {
870 g_string_sprintf(message, "+%s", action_dest);
871 send();
872 }
873
874 paths = paths->next;
875 }
876
877 g_string_sprintf(message, "'\nDone\n");
878 send();
879 }
880
881 /* EXTERNAL INTERFACE */
882
883 /* Count disk space used by selected items */
884 void action_usage(FilerWindow *filer_window)
885 {
886 GUIside *gui_side;
887 Collection *collection;
888
889 collection = filer_window->collection;
890
891 if (collection->number_selected < 1)
892 {
893 report_error("ROX-Filer", "You need to select some items "
894 "to count");
895 return;
896 }
897
898 gui_side = start_action(filer_window, usage_cb);
899 if (!gui_side)
900 return;
901
902 gui_side->show_info = TRUE;
903
904 gtk_window_set_title(GTK_WINDOW(gui_side->window), "Disk Usage");
905 number_of_windows++;
906 gtk_widget_show_all(gui_side->window);
907 }
908
909 /* Mount/unmount 'item', or all selected mount points if NULL. */
910 void action_mount(FilerWindow *filer_window, DirItem *item)
911 {
912 #ifdef DO_MOUNT_POINTS
913 GUIside *gui_side;
914 Collection *collection;
915
916 collection = filer_window->collection;
917
918 if (item == NULL && collection->number_selected < 1)
919 {
920 report_error("ROX-Filer", "You need to select some items "
921 "to mount or unmount");
922 return;
923 }
924
925 mount_item = item;
926 gui_side = start_action(filer_window, mount_cb);
927 if (!gui_side)
928 return;
929
930 gtk_window_set_title(GTK_WINDOW(gui_side->window), "Mount / Unmount");
931 number_of_windows++;
932 gtk_widget_show_all(gui_side->window);
933 #else
934 report_error("ROX-Filer",
935 "ROX-Filer does not yet support mount points on your "
936 "system. Sorry.");
937 #endif /* DO_MOUNT_POINTS */
938 }
939
940 /* Deletes all selected items in the window */
941 void action_delete(FilerWindow *filer_window)
942 {
943 GUIside *gui_side;
944 Collection *collection;
945
946 collection = filer_window->collection;
947
948 if (collection->number_selected < 1)
949 {
950 report_error("ROX-Filer", "You need to select some items "
951 "to delete");
952 return;
953 }
954
955 gui_side = start_action(filer_window, delete_cb);
956 if (!gui_side)
957 return;
958
959 gtk_window_set_title(GTK_WINDOW(gui_side->window), "Delete");
960 number_of_windows++;
961 gtk_widget_show_all(gui_side->window);
962 }
963
964 void action_copy(GSList *paths, char *dest)
965 {
966 GUIside *gui_side;
967
968 action_dest = dest;
969 action_do_func = do_copy;
970 gui_side = start_action(paths, list_cb);
971 if (!gui_side)
972 return;
973
974 gtk_window_set_title(GTK_WINDOW(gui_side->window), "Copy");
975 number_of_windows++;
976 gtk_widget_show_all(gui_side->window);
977 }
978
979 void action_move(GSList *paths, char *dest)
980 {
981 GUIside *gui_side;
982
983 action_dest = dest;
984 action_do_func = do_move;
985 gui_side = start_action(paths, list_cb);
986 if (!gui_side)
987 return;
988
989 gtk_window_set_title(GTK_WINDOW(gui_side->window), "Move");
990 number_of_windows++;
991 gtk_widget_show_all(gui_side->window);
992 }
993
994 void action_link(GSList *paths, char *dest)
995 {
996 GUIside *gui_side;
997
998 action_dest = dest;
999 action_do_func = do_link;
1000 gui_side = start_action(paths, list_cb);
1001 if (!gui_side)
1002 return;
1003
1004 gtk_window_set_title(GTK_WINDOW(gui_side->window), "Link");
1005 number_of_windows++;
1006 gtk_widget_show_all(gui_side->window);
1007 }
1008
Filer for the ROX desktop