?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r217: Merged the MIME-Type and Special fields in the info window into a single
[rox-filer.git] / ROX-Filer / src / action.c
blob6132ec6b089f5b78f017f135eb2f10de752ad228
1 /*
2 * $Id$
3 *
4 * ROX-Filer, filer for the ROX desktop project
5 * Copyright (C) 2000, Thomas Leonard, <tal197@ecs.soton.ac.uk>.
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the Free
9 * Software Foundation; either version 2 of the License, or (at your option)
10 * any later version.
11 *
12 * This program is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * more details.
16 *
17 * You should have received a copy of the GNU General Public License along with
18 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
19 * Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 /* 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 <ctype.h>
31 #include <sys/param.h>
32 #include <unistd.h>
33 #include <errno.h>
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <signal.h>
37 #include <dirent.h>
38 #include <sys/time.h>
39
40 #include "action.h"
41 #include "string.h"
42 #include "support.h"
43 #include "gui_support.h"
44 #include "filer.h"
45 #include "main.h"
46 #include "options.h"
47 #include "modechange.h"
48
49 /* Options bits */
50 static GtkWidget *create_options();
51 static void update_options();
52 static void set_options();
53 static void save_options();
54 static char *action_auto_quiet(char *data);
55
56 static OptionsSection options =
57 {
58 "Action window options",
59 create_options,
60 update_options,
61 set_options,
62 save_options
63 };
64
65 static gboolean o_auto_copy = TRUE;
66 static gboolean o_auto_move = TRUE;
67 static gboolean o_auto_link = TRUE;
68 static gboolean o_auto_delete = FALSE;
69 static gboolean o_auto_mount = TRUE;
70
71 static GtkWidget *w_auto_copy = NULL;
72 static GtkWidget *w_auto_move = NULL;
73 static GtkWidget *w_auto_link = NULL;
74 static GtkWidget *w_auto_delete = NULL;
75 static GtkWidget *w_auto_mount = NULL;
76
77 static GdkColor red = {0, 0xffff, 0, 0};
78
79 /* Parent->Child messages are one character each:
80 *
81 * Q/Y/N Quiet/Yes/No button clicked
82 * F Force deletion of non-writeable items
83 */
84
85 #define SENSITIVE_YESNO(gui_side, state) \
86 do { \
87 gtk_widget_set_sensitive((gui_side)->yes, state); \
88 gtk_widget_set_sensitive((gui_side)->no, state); \
89 if ((gui_side)->entry) \
90 gtk_widget_set_sensitive((gui_side)->entry, state);\
91 } while (0)
92
93 #define ON(flag) ((flag) ? "on" : "off")
94
95 typedef struct _GUIside GUIside;
96 typedef void ActionChild(gpointer data);
97 typedef gboolean ForDirCB(char *path, char *dest_path);
98
99 struct _GUIside
100 {
101 int from_child; /* File descriptor */
102 FILE *to_child;
103 int input_tag; /* gdk_input_add() */
104 GtkWidget *vbox, *log, *window, *dir;
105 GtkWidget *quiet, *yes, *no;
106 GtkWidget *entry; /* May be NULL */
107 int child; /* Process ID */
108 int errors;
109 gboolean show_info; /* For Disk Usage */
110
111 char *next_dir; /* NULL => no timer active */
112 gint next_timer;
113 };
114
115 /* These don't need to be in a structure because we fork() before
116 * using them again.
117 */
118 static int from_parent = 0;
119 static FILE *to_parent = NULL;
120 static gboolean quiet = FALSE;
121 static GString *message = NULL;
122 static char *action_dest = NULL;
123 static char *action_leaf = NULL;
124 static gboolean (*action_do_func)(char *source, char *dest);
125 static size_t size_tally; /* For Disk Usage */
126 static DirItem *mount_item;
127 static struct mode_change *mode_change = NULL; /* For Permissions */
128
129 static gboolean o_force = FALSE;
130 static gboolean o_brief = FALSE;
131 static gboolean o_recurse = FALSE;
132
133 /* This is the last chmod command set, so that bringing up a new
134 * chmod box defaults to the last used command.
135 */
136 static guchar *chmod_command = NULL;
137
138 /* Static prototypes */
139 static gboolean send();
140 static gboolean send_error();
141 static gboolean send_dir(char *dir);
142 static gboolean read_exact(int source, char *buffer, ssize_t len);
143 static void do_mount(FilerWindow *filer_window, DirItem *item);
144 static void add_toggle(GUIside *gui_side, guchar *label, guchar *code);
145 static gboolean reply(int fd, gboolean ignore_quiet);
146
147 /* OPTIONS */
148
149 /* Build up some option widgets to go in the options dialog, but don't
150 * fill them in yet.
151 */
152 static GtkWidget *create_options()
153 {
154 GtkWidget *vbox, *hbox, *label;
155
156 vbox = gtk_vbox_new(FALSE, 0);
157 gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
158
159 label = gtk_label_new("Auto-start (Quiet) these actions:");
160 gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 0);
161
162 hbox = gtk_hbox_new(TRUE, 0);
163 gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
164
165 w_auto_copy = gtk_check_button_new_with_label("Copy");
166 gtk_box_pack_start(GTK_BOX(hbox), w_auto_copy, FALSE, TRUE, 0);
167 w_auto_move = gtk_check_button_new_with_label("Move");
168 gtk_box_pack_start(GTK_BOX(hbox), w_auto_move, FALSE, TRUE, 0);
169 w_auto_link = gtk_check_button_new_with_label("Link");
170 gtk_box_pack_start(GTK_BOX(hbox), w_auto_link, FALSE, TRUE, 0);
171 w_auto_delete = gtk_check_button_new_with_label("Delete");
172 gtk_box_pack_start(GTK_BOX(hbox), w_auto_delete, FALSE, TRUE, 0);
173 w_auto_mount = gtk_check_button_new_with_label("Mount");
174 gtk_box_pack_start(GTK_BOX(hbox), w_auto_mount, FALSE, TRUE, 0);
175
176 return vbox;
177 }
178
179 /* Reflect current state by changing the widgets in the options box */
180 static void update_options()
181 {
182 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w_auto_copy),
183 o_auto_copy);
184 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w_auto_move),
185 o_auto_move);
186 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w_auto_link),
187 o_auto_link);
188 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w_auto_delete),
189 o_auto_delete);
190 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w_auto_mount),
191 o_auto_mount);
192 }
193
194 /* Set current values by reading the states of the widgets in the options box */
195 static void set_options()
196 {
197 o_auto_copy = gtk_toggle_button_get_active(
198 GTK_TOGGLE_BUTTON(w_auto_copy));
199 o_auto_move = gtk_toggle_button_get_active(
200 GTK_TOGGLE_BUTTON(w_auto_move));
201 o_auto_link = gtk_toggle_button_get_active(
202 GTK_TOGGLE_BUTTON(w_auto_link));
203 o_auto_delete = gtk_toggle_button_get_active(
204 GTK_TOGGLE_BUTTON(w_auto_delete));
205 o_auto_mount = gtk_toggle_button_get_active(
206 GTK_TOGGLE_BUTTON(w_auto_mount));
207 }
208
209 static void save_options()
210 {
211 guchar str[] = "cmldt";
212
213 if (o_auto_copy)
214 str[0] = 'C';
215 if (o_auto_move)
216 str[1] = 'M';
217 if (o_auto_link)
218 str[2] = 'L';
219 if (o_auto_delete)
220 str[3] = 'D';
221 if (o_auto_mount)
222 str[4] = 'T';
223
224 option_write("action_auto_quiet", str);
225 }
226
227 static char *action_auto_quiet(char *data)
228 {
229 while (*data)
230 {
231 char c = *data++;
232 gboolean state;
233
234 state = isupper(c);
235
236 switch (tolower(c))
237 {
238 case 'c':
239 o_auto_copy = state;
240 break;
241 case 'm':
242 o_auto_move = state;
243 break;
244 case 'l':
245 o_auto_link = state;
246 break;
247 case 'd':
248 o_auto_delete = state;
249 break;
250 case 't':
251 o_auto_mount = state;
252 break;
253 default:
254 return "Unknown flag";
255 }
256 }
257
258 return NULL;
259 }
260
261 /* SUPPORT */
262
263 /* This is called whenever the user edits the command - send the new command
264 * to the child process.
265 */
266 static void chmod_command_changed(GtkEntry *entry, GUIside *gui_side)
267 {
268 g_free(chmod_command);
269 chmod_command = g_strdup(gtk_entry_get_text(entry));
270
271 if (!gui_side->to_child)
272 return;
273
274 fputc('P', gui_side->to_child);
275 fputs(chmod_command, gui_side->to_child);
276 fputc('\n', gui_side->to_child);
277 fflush(gui_side->to_child);
278 }
279
280 static void show_chmod_help(gpointer data)
281 {
282 static GtkWidget *help = NULL;
283
284 if (!help)
285 {
286 GtkWidget *text, *vbox, *button, *hbox, *sep;
287
288 help = gtk_window_new(GTK_WINDOW_DIALOG);
289 gtk_container_set_border_width(GTK_CONTAINER(help), 10);
290 gtk_window_set_title(GTK_WINDOW(help),
291 "Permissions command reference");
292
293 vbox = gtk_vbox_new(FALSE, 0);
294 gtk_container_add(GTK_CONTAINER(help), vbox);
295
296 text = gtk_label_new(
297 "The format of a command is:\n"
298 "CHANGE, CHANGE, ...\n"
299 "Each CHANGE is:\n"
300 "WHO HOW PERMISSIONS\n"
301 "WHO is some combination of u, g and o which determines whether to\n"
302 "change the permissions for the User (owner), Group or Others.\n"
303 "HOW is +, - or = to add, remove or set exactly the permissions.\n"
304 "PERMISSIONS is some combination of the letters 'rwxXstugo'\n\n"
305
306 "Examples:\n"
307 "u+rw (the file owner gains read and write permission)\n"
308 "g=u (the group permissions are set to be the same as the user's)\n"
309 "o=u-w (others get the same permissions as the owner, but without "
310 "write permission)\n"
311 "a+x (everyone gets execute/access permission - same as 'ugo+x')\n"
312 "a+X (directories become accessable by everyone; files which were\n"
313 "executable by anyone become executable by everyone)\n"
314 "u+rw, go+r (two commands at once!)\n"
315 "u+s (set the SetUID bit - often has no effect on script files)\n"
316 "755 (set the permissions directly)\n"
317
318 "\nSee the chmod(1) man page for full details.");
319 gtk_label_set_justify(GTK_LABEL(text), GTK_JUSTIFY_LEFT);
320 gtk_box_pack_start(GTK_BOX(vbox), text, TRUE, TRUE, 0);
321
322 hbox = gtk_hbox_new(FALSE, 20);
323 gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
324
325 sep = gtk_hseparator_new();
326 gtk_box_pack_start(GTK_BOX(hbox), sep, TRUE, TRUE, 0);
327 button = gtk_button_new_with_label("Close");
328 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, TRUE, 0);
329 gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
330 gtk_widget_hide, GTK_OBJECT(help));
331
332 gtk_signal_connect_object(GTK_OBJECT(help), "delete_event",
333 gtk_widget_hide, GTK_OBJECT(help));
334 }
335
336 if (GTK_WIDGET_VISIBLE(help))
337 gtk_widget_hide(help);
338 gtk_widget_show_all(help);
339 }
340
341 /* TRUE iff `sub' is (or would be) an object inside the directory `parent',
342 * (or the two are the same directory)
343 */
344 static gboolean is_sub_dir(char *sub, char *parent)
345 {
346 int parent_len;
347 guchar *real_sub, *real_parent;
348 gboolean retval;
349
350 real_sub = pathdup(sub);
351 real_parent = pathdup(parent);
352
353 parent_len = strlen(real_parent);
354 if (strncmp(real_parent, real_sub, parent_len))
355 retval = FALSE;
356 else
357 {
358 /* real_sub is at least as long as real_parent and all
359 * characters upto real_parent's length match.
360 */
361
362 retval = real_sub[parent_len] == '\0' ||
363 real_sub[parent_len] == '/';
364 }
365
366 g_free(real_sub);
367 g_free(real_parent);
368
369 return retval;
370 }
371
372 static gboolean display_dir(gpointer data)
373 {
374 GUIside *gui_side = (GUIside *) data;
375
376 gtk_label_set_text(GTK_LABEL(gui_side->dir), gui_side->next_dir + 1);
377 g_free(gui_side->next_dir);
378 gui_side->next_dir = NULL;
379
380 return FALSE;
381 }
382
383 /* Called when the child sends us a message */
384 static void message_from_child(gpointer data,
385 gint source,
386 GdkInputCondition condition)
387 {
388 char buf[5];
389 GUIside *gui_side = (GUIside *) data;
390 GtkWidget *log = gui_side->log;
391
392 if (read_exact(source, buf, 4))
393 {
394 ssize_t message_len;
395 char *buffer;
396
397 buf[4] = '\0';
398 message_len = strtol(buf, NULL, 16);
399 buffer = g_malloc(message_len + 1);
400 if (message_len > 0 && read_exact(source, buffer, message_len))
401 {
402 buffer[message_len] = '\0';
403 if (*buffer == '?')
404 SENSITIVE_YESNO(gui_side, TRUE);
405 else if (*buffer == '+')
406 {
407 refresh_dirs(buffer + 1);
408 g_free(buffer);
409 return;
410 }
411 else if (*buffer == 'm')
412 {
413 filer_check_mounted(buffer + 1);
414 g_free(buffer);
415 return;
416 }
417 else if (*buffer == '/')
418 {
419 if (gui_side->next_dir)
420 g_free(gui_side->next_dir);
421 else
422 gui_side->next_timer =
423 gtk_timeout_add(500,
424 display_dir,
425 gui_side);
426 gui_side->next_dir = buffer;
427 return;
428 }
429 else if (*buffer == '!')
430 gui_side->errors++;
431
432 gtk_text_insert(GTK_TEXT(log),
433 NULL,
434 *buffer == '!' ? &red : NULL,
435 NULL,
436 buffer + 1, message_len - 1);
437 g_free(buffer);
438 return;
439 }
440 g_print("Child died in the middle of a message.\n");
441 }
442
443 /* The child is dead */
444 gui_side->child = 0;
445
446 fclose(gui_side->to_child);
447 gui_side->to_child = NULL;
448 close(gui_side->from_child);
449 gdk_input_remove(gui_side->input_tag);
450 gtk_widget_set_sensitive(gui_side->quiet, FALSE);
451
452 if (gui_side->errors)
453 {
454 GString *report;
455 report = g_string_new(NULL);
456 g_string_sprintf(report, "There %s %d error%s.\n",
457 gui_side->errors == 1 ? "was" : "were",
458 gui_side->errors,
459 gui_side->errors == 1 ? "" : "s");
460 gtk_text_insert(GTK_TEXT(log), NULL, &red, NULL,
461 report->str, report->len);
462
463 g_string_free(report, TRUE);
464 }
465 else if (gui_side->show_info == FALSE)
466 gtk_widget_destroy(gui_side->window);
467 }
468
469 /* Scans src_dir, updating dest_path whenever cb returns TRUE */
470 static void for_dir_contents(ForDirCB *cb, char *src_dir, char *dest_path)
471 {
472 DIR *d;
473 struct dirent *ent;
474 GSList *list = NULL, *next;
475
476 d = opendir(src_dir);
477 if (!d)
478 {
479 send_error();
480 return;
481 }
482
483 send_dir(src_dir);
484
485 while ((ent = readdir(d)))
486 {
487 if (ent->d_name[0] == '.' && (ent->d_name[1] == '\0'
488 || (ent->d_name[1] == '.' && ent->d_name[2] == '\0')))
489 continue;
490 list = g_slist_append(list, g_strdup(make_path(src_dir,
491 ent->d_name)->str));
492 }
493 closedir(d);
494
495 if (!list)
496 return;
497
498 next = list;
499
500 while (next)
501 {
502 if (cb((char *) next->data, dest_path))
503 {
504 g_string_sprintf(message, "+%s", dest_path);
505 send();
506 }
507
508 g_free(next->data);
509 next = next->next;
510 }
511 g_slist_free(list);
512 return;
513 }
514
515 /* Read this many bytes into the buffer. TRUE on success. */
516 static gboolean read_exact(int source, char *buffer, ssize_t len)
517 {
518 while (len > 0)
519 {
520 ssize_t got;
521 got = read(source, buffer, len);
522 if (got < 1)
523 return FALSE;
524 len -= got;
525 buffer += got;
526 }
527 return TRUE;
528 }
529
530 /* Send 'message' to our parent process. TRUE on success. */
531 static gboolean send()
532 {
533 char len_buffer[5];
534 ssize_t len;
535
536 g_return_val_if_fail(message->len < 0xffff, FALSE);
537
538 sprintf(len_buffer, "%04x", message->len);
539 fwrite(len_buffer, 1, 4, to_parent);
540 len = fwrite(message->str, 1, message->len, to_parent);
541 fflush(to_parent);
542 return len == message->len;
543 }
544
545 /* Set the directory indicator at the top of the window */
546 static gboolean send_dir(char *dir)
547 {
548 g_string_sprintf(message, "/%s", dir);
549 return send();
550 }
551
552 static gboolean send_error()
553 {
554 g_string_sprintf(message, "!ERROR: %s\n", g_strerror(errno));
555 return send();
556 }
557
558 static void button_reply(GtkWidget *button, GUIside *gui_side)
559 {
560 char *text;
561
562 if (!gui_side->to_child)
563 return;
564
565 text = gtk_object_get_data(GTK_OBJECT(button), "send-code");
566 g_return_if_fail(text != NULL);
567 fputc(*text, gui_side->to_child);
568 fflush(gui_side->to_child);
569
570 if (*text == 'Y' || *text == 'N' || *text == 'Q')
571 SENSITIVE_YESNO(gui_side, FALSE);
572 }
573
574 static void process_flag(char flag)
575 {
576 switch (flag)
577 {
578 case 'Q':
579 quiet = !quiet;
580 break;
581 case 'F':
582 o_force = !o_force;
583 break;
584 case 'R':
585 o_recurse = !o_recurse;
586 break;
587 case 'B':
588 o_brief = !o_brief;
589 break;
590 default:
591 g_string_sprintf(message,
592 "!ERROR: Bad message '%c'\n", flag);
593 send();
594 break;
595 }
596 }
597
598 /* If the parent has sent any flag toggles, read them */
599 static void check_flags(void)
600 {
601 fd_set set;
602 int got;
603 char retval;
604 struct timeval tv;
605
606 FD_ZERO(&set);
607
608 while (1)
609 {
610 FD_SET(from_parent, &set);
611 tv.tv_sec = 0;
612 tv.tv_usec = 0;
613 got = select(from_parent + 1, &set, NULL, NULL, &tv);
614
615 if (got == -1)
616 g_error("select() failed: %s\n", g_strerror(errno));
617 else if (!got)
618 return;
619
620 got = read(from_parent, &retval, 1);
621 if (got != 1)
622 g_error("read() error: %s\n", g_strerror(errno));
623
624 process_flag(retval);
625 }
626 }
627
628 static void read_new_chmod_command(void)
629 {
630 int len;
631 char c;
632 GString *new;
633
634 new = g_string_new(NULL);
635
636 for (;;)
637 {
638 len = read(from_parent, &c, 1);
639 if (len != 1)
640 {
641 fprintf(stderr, "read() error: %s\n",
642 g_strerror(errno));
643 _exit(1); /* Parent died? */
644 }
645
646 if (c == '\n')
647 break;
648 g_string_append_c(new, c);
649 }
650
651 if (mode_change)
652 mode_free(mode_change);
653 mode_change = mode_compile(new->str, MODE_MASK_ALL);
654 g_string_free(new, TRUE);
655 }
656
657 /* Read until the user sends a reply. If ignore_quiet is TRUE then
658 * the user MUST click Yes or No, else treat quiet on as Yes.
659 * If the user needs prompting then does send().
660 */
661 static gboolean reply(int fd, gboolean ignore_quiet)
662 {
663 ssize_t len;
664 char retval;
665 gboolean asked = FALSE;
666
667 while (ignore_quiet || !quiet)
668 {
669 if (!asked)
670 {
671 send();
672 asked = TRUE;
673 }
674
675 len = read(fd, &retval, 1);
676 if (len != 1)
677 {
678 fprintf(stderr, "read() error: %s\n",
679 g_strerror(errno));
680 _exit(1); /* Parent died? */
681 }
682
683 switch (retval)
684 {
685 case 'Q':
686 quiet = !quiet;
687 if (ignore_quiet)
688 {
689 g_string_assign(message, "?");
690 send();
691 }
692 break;
693 case 'Y':
694 g_string_assign(message, "' Yes\n");
695 send();
696 return TRUE;
697 case 'N':
698 g_string_assign(message, "' No\n");
699 send();
700 return FALSE;
701 case 'P':
702 read_new_chmod_command();
703 break;
704 default:
705 process_flag(retval);
706 break;
707 }
708 }
709
710 if (asked)
711 {
712 g_string_assign(message, "' Quiet\n");
713 send();
714 }
715 return TRUE;
716 }
717
718 static void destroy_action_window(GtkWidget *widget, gpointer data)
719 {
720 GUIside *gui_side = (GUIside *) data;
721
722 if (gui_side->child)
723 {
724 kill(gui_side->child, SIGTERM);
725 fclose(gui_side->to_child);
726 close(gui_side->from_child);
727 gdk_input_remove(gui_side->input_tag);
728 }
729
730 if (gui_side->next_dir)
731 {
732 gtk_timeout_remove(gui_side->next_timer);
733 g_free(gui_side->next_dir);
734 }
735 g_free(gui_side);
736
737 if (--number_of_windows < 1)
738 gtk_main_quit();
739 }
740
741 /* Create two pipes, fork() a child and return a pointer to a GUIside struct
742 * (NULL on failure). The child calls func().
743 *
744 * If autoq then automatically selects 'Quiet'.
745 */
746 static GUIside *start_action(gpointer data, ActionChild *func, gboolean autoq)
747 {
748 int filedes[4]; /* 0 and 2 are for reading */
749 GUIside *gui_side;
750 int child;
751 GtkWidget *vbox, *button, *hbox, *scrollbar, *actions;
752 struct sigaction act;
753
754 if (pipe(filedes))
755 {
756 report_error("ROX-Filer", g_strerror(errno));
757 return NULL;
758 }
759
760 if (pipe(filedes + 2))
761 {
762 close(filedes[0]);
763 close(filedes[1]);
764 report_error("ROX-Filer", g_strerror(errno));
765 return NULL;
766 }
767
768 child = fork();
769 switch (child)
770 {
771 case -1:
772 report_error("ROX-Filer", g_strerror(errno));
773 return NULL;
774 case 0:
775 /* We are the child */
776
777 quiet = autoq;
778
779 /* Reset the SIGCHLD handler */
780 act.sa_handler = SIG_DFL;
781 sigemptyset(&act.sa_mask);
782 act.sa_flags = 0;
783 sigaction(SIGCHLD, &act, NULL);
784
785 message = g_string_new(NULL);
786 close(filedes[0]);
787 close(filedes[3]);
788 to_parent = fdopen(filedes[1], "wb");
789 from_parent = filedes[2];
790 func(data);
791 _exit(0);
792 }
793
794 /* We are the parent */
795 close(filedes[1]);
796 close(filedes[2]);
797 gui_side = g_malloc(sizeof(GUIside));
798 gui_side->from_child = filedes[0];
799 gui_side->to_child = fdopen(filedes[3], "wb");
800 gui_side->log = NULL;
801 gui_side->child = child;
802 gui_side->errors = 0;
803 gui_side->show_info = FALSE;
804 gui_side->entry = NULL;
805
806 gui_side->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
807 gtk_container_set_border_width(GTK_CONTAINER(gui_side->window), 2);
808 gtk_window_set_default_size(GTK_WINDOW(gui_side->window), 450, 200);
809 gtk_signal_connect(GTK_OBJECT(gui_side->window), "destroy",
810 GTK_SIGNAL_FUNC(destroy_action_window), gui_side);
811
812 gui_side->vbox = vbox = gtk_vbox_new(FALSE, 0);
813 gtk_container_add(GTK_CONTAINER(gui_side->window), vbox);
814
815 gui_side->dir = gtk_label_new("<dir>");
816 gui_side->next_dir = NULL;
817 gtk_misc_set_alignment(GTK_MISC(gui_side->dir), 0.5, 0.5);
818 gtk_box_pack_start(GTK_BOX(vbox), gui_side->dir, FALSE, TRUE, 0);
819
820 hbox = gtk_hbox_new(FALSE, 0);
821 gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 4);
822
823 gui_side->log = gtk_text_new(NULL, NULL);
824 gtk_widget_set_usize(gui_side->log, 400, 100);
825 gtk_box_pack_start(GTK_BOX(hbox), gui_side->log, TRUE, TRUE, 0);
826 scrollbar = gtk_vscrollbar_new(GTK_TEXT(gui_side->log)->vadj);
827 gtk_box_pack_start(GTK_BOX(hbox), scrollbar, FALSE, TRUE, 0);
828
829 actions = gtk_hbox_new(TRUE, 4);
830 gtk_box_pack_start(GTK_BOX(vbox), actions, FALSE, TRUE, 0);
831
832 gui_side->quiet = button = gtk_toggle_button_new_with_label("Quiet");
833 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), autoq);
834 gtk_object_set_data(GTK_OBJECT(button), "send-code", "Q");
835 gtk_box_pack_start(GTK_BOX(actions), button, TRUE, TRUE, 0);
836 gtk_signal_connect(GTK_OBJECT(button), "clicked",
837 button_reply, gui_side);
838 gui_side->yes = button = gtk_button_new_with_label("Yes");
839 gtk_object_set_data(GTK_OBJECT(button), "send-code", "Y");
840 gtk_box_pack_start(GTK_BOX(actions), button, TRUE, TRUE, 0);
841 gtk_signal_connect(GTK_OBJECT(button), "clicked",
842 button_reply, gui_side);
843 gui_side->no = button = gtk_button_new_with_label("No");
844 gtk_object_set_data(GTK_OBJECT(button), "send-code", "N");
845 gtk_box_pack_start(GTK_BOX(actions), button, TRUE, TRUE, 0);
846 gtk_signal_connect(GTK_OBJECT(button), "clicked",
847 button_reply, gui_side);
848 SENSITIVE_YESNO(gui_side, FALSE);
849
850 button = gtk_button_new_with_label("Abort");
851 gtk_box_pack_start(GTK_BOX(actions), button, TRUE, TRUE, 0);
852 gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
853 gtk_widget_destroy, GTK_OBJECT(gui_side->window));
854
855 gui_side->input_tag = gdk_input_add(gui_side->from_child,
856 GDK_INPUT_READ,
857 message_from_child,
858 gui_side);
859
860 return gui_side;
861 }
862
863 /* ACTIONS ON ONE ITEM */
864
865 /* These may call themselves recursively, or ask questions, etc.
866 * TRUE iff the directory containing dest_path needs to be rescanned.
867 */
868
869 /* dest_path is the dir containing src_path.
870 * Updates the global size_tally.
871 */
872 static gboolean do_usage(char *src_path, char *dest_path)
873 {
874 struct stat info;
875
876 check_flags();
877
878 if (lstat(src_path, &info))
879 {
880 g_string_sprintf(message, "'%s:\n", src_path);
881 send();
882 send_error();
883 return FALSE;
884 }
885
886 if (S_ISREG(info.st_mode) || S_ISLNK(info.st_mode))
887 size_tally += info.st_size;
888 else if (S_ISDIR(info.st_mode))
889 {
890 g_string_sprintf(message, "?Count contents of %s?",
891 src_path);
892 if (reply(from_parent, FALSE))
893 {
894 char *safe_path;
895 safe_path = g_strdup(src_path);
896 for_dir_contents(do_usage, safe_path, safe_path);
897 g_free(safe_path);
898 }
899 }
900
901 return FALSE;
902 }
903
904 /* dest_path is the dir containing src_path */
905 static gboolean do_delete(char *src_path, char *dest_path)
906 {
907 struct stat info;
908 gboolean write_prot;
909
910 check_flags();
911
912 if (lstat(src_path, &info))
913 {
914 send_error();
915 return FALSE;
916 }
917
918 write_prot = S_ISLNK(info.st_mode) ? FALSE
919 : access(src_path, W_OK) != 0;
920 if (write_prot || !quiet)
921 {
922 g_string_sprintf(message, "?Delete %s'%s'?",
923 write_prot ? "WRITE-PROTECTED " : " ",
924 src_path);
925 if (!reply(from_parent, write_prot && !o_force))
926 return FALSE;
927 }
928 else if (!o_brief)
929 {
930 g_string_sprintf(message, "'Deleting '%s'\n", src_path);
931 send();
932 }
933
934 if (S_ISDIR(info.st_mode))
935 {
936 char *safe_path;
937 safe_path = g_strdup(src_path);
938 for_dir_contents(do_delete, safe_path, safe_path);
939 if (rmdir(safe_path))
940 {
941 g_free(safe_path);
942 send_error();
943 return FALSE;
944 }
945 g_string_sprintf(message, "'Directory '%s' deleted\n",
946 safe_path);
947 send();
948 g_string_sprintf(message, "m%s", safe_path);
949 send();
950 g_free(safe_path);
951 }
952 else if (unlink(src_path))
953 {
954 send_error();
955 return FALSE;
956 }
957
958 return TRUE;
959 }
960
961 /* path is the item to change. If is is a directory then we may recurse
962 * (depending on the recurse flag).
963 */
964 static gboolean do_chmod(char *path, char *dummy)
965 {
966 struct stat info;
967 mode_t new_mode;
968
969 check_flags();
970
971 if (lstat(path, &info))
972 {
973 send_error();
974 return FALSE;
975 }
976 if (S_ISLNK(info.st_mode))
977 return FALSE;
978
979 if (!quiet)
980 {
981 g_string_sprintf(message, "?Change permissions of '%s'?", path);
982 if (!reply(from_parent, FALSE))
983 return FALSE;
984 }
985 else if (!o_brief)
986 {
987 g_string_sprintf(message, "'Changing permissions of '%s'\n",
988 path);
989 send();
990 }
991
992 while (!mode_change)
993 {
994 g_string_assign(message,
995 "!Invalid mode command - change it and try again\n");
996 send();
997 g_string_sprintf(message, "?Change permissions of '%s'?", path);
998 if (!reply(from_parent, TRUE))
999 return FALSE;
1000 }
1001
1002 if (lstat(path, &info))
1003 {
1004 send_error();
1005 return FALSE;
1006 }
1007 if (S_ISLNK(info.st_mode))
1008 return FALSE;
1009
1010 new_mode = mode_adjust(info.st_mode, mode_change);
1011 if (chmod(path, new_mode))
1012 {
1013 send_error();
1014 return FALSE;
1015 }
1016
1017 if (o_recurse && S_ISDIR(info.st_mode))
1018 {
1019 char *safe_path;
1020 safe_path = g_strdup(path);
1021 for_dir_contents(do_chmod, safe_path, safe_path);
1022 g_free(safe_path);
1023 }
1024
1025 return TRUE;
1026 }
1027
1028 /* We want to copy 'object' into directory 'dir'. If 'action_leaf'
1029 * is set then that is the new leafname, otherwise the leafname stays
1030 * the same.
1031 */
1032 static char *make_dest_path(char *object, char *dir)
1033 {
1034 char *leaf;
1035
1036 if (action_leaf)
1037 leaf = action_leaf;
1038 else
1039 {
1040 leaf = strrchr(object, '/');
1041 if (!leaf)
1042 leaf = object; /* Error? */
1043 else
1044 leaf++;
1045 }
1046
1047 return make_path(dir, leaf)->str;
1048 }
1049
1050 /* If action_leaf is not NULL it specifies the new leaf name
1051 */
1052 static gboolean do_copy2(char *path, char *dest)
1053 {
1054 char *dest_path;
1055 struct stat info;
1056 struct stat dest_info;
1057 gboolean retval = TRUE;
1058
1059 check_flags();
1060
1061 dest_path = make_dest_path(path, dest);
1062
1063 if (lstat(path, &info))
1064 {
1065 send_error();
1066 return FALSE;
1067 }
1068
1069 if (lstat(dest_path, &dest_info) == 0)
1070 {
1071 int err;
1072 gboolean merge;
1073
1074 merge = S_ISDIR(info.st_mode) && S_ISDIR(dest_info.st_mode);
1075
1076 g_string_sprintf(message, "?'%s' already exists - %s?",
1077 dest_path,
1078 merge ? "merge contents" : "overwrite");
1079
1080 if (!reply(from_parent, TRUE))
1081 return FALSE;
1082
1083 if (!merge)
1084 {
1085 if (S_ISDIR(dest_info.st_mode))
1086 err = rmdir(dest_path);
1087 else
1088 err = unlink(dest_path);
1089
1090 if (err)
1091 {
1092 send_error();
1093 if (errno != ENOENT)
1094 return FALSE;
1095 g_string_sprintf(message,
1096 "'Trying copy anyway...\n");
1097 send();
1098 }
1099 }
1100 }
1101 else if (!quiet)
1102 {
1103 g_string_sprintf(message, "?Copy %s as %s?", path, dest_path);
1104 if (!reply(from_parent, FALSE))
1105 return FALSE;
1106 }
1107 else
1108 {
1109 g_string_sprintf(message, "'Copying %s as %s\n", path,
1110 dest_path);
1111 send();
1112 }
1113
1114 if (S_ISDIR(info.st_mode))
1115 {
1116 char *safe_path, *safe_dest;
1117 struct stat dest_info;
1118 gboolean exists;
1119
1120 /* (we will do the update ourselves now, rather than
1121 * afterwards)
1122 */
1123 retval = FALSE;
1124
1125 safe_path = g_strdup(path);
1126 safe_dest = g_strdup(dest_path);
1127
1128 exists = !lstat(dest_path, &dest_info);
1129
1130 if (exists && !S_ISDIR(dest_info.st_mode))
1131 {
1132 g_string_sprintf(message,
1133 "!ERROR: Destination already exists, "
1134 "but is not a directory\n");
1135 }
1136 else if (exists == FALSE && mkdir(dest_path, info.st_mode))
1137 send_error();
1138 else
1139 {
1140 if (!exists)
1141 {
1142 /* (just been created then) */
1143 g_string_sprintf(message, "+%s", dest);
1144 send();
1145 }
1146
1147 action_leaf = NULL;
1148 for_dir_contents(do_copy2, safe_path, safe_dest);
1149 /* Note: dest_path now invalid... */
1150 }
1151
1152 g_free(safe_path);
1153 g_free(safe_dest);
1154 }
1155 else if (S_ISLNK(info.st_mode))
1156 {
1157 char target[MAXPATHLEN + 1];
1158 int count;
1159
1160 /* Not all versions of cp(1) can make symlinks,
1161 * so we special-case it.
1162 */
1163
1164 count = readlink(path, target, sizeof(target) - 1);
1165 if (count < 0)
1166 {
1167 send_error();
1168 retval = FALSE;
1169 }
1170 else
1171 {
1172 target[count] = '\0';
1173 if (symlink(target, dest_path))
1174 {
1175 send_error();
1176 retval = FALSE;
1177 }
1178 }
1179 }
1180 else
1181 {
1182 char *argv[] = {"cp", "-pRf", NULL, NULL, NULL};
1183
1184 argv[2] = path;
1185 argv[3] = dest_path;
1186
1187 if (fork_exec_wait(argv))
1188 {
1189 g_string_sprintf(message, "!ERROR: Copy failed\n");
1190 send();
1191 retval = FALSE;
1192 }
1193 }
1194
1195 return retval;
1196 }
1197
1198 /* Copy path to dest.
1199 * Check that path not copied into itself.
1200 */
1201 static gboolean do_copy(char *path, char *dest)
1202 {
1203 if (is_sub_dir(make_dest_path(path, dest), path))
1204 {
1205 g_string_sprintf(message,
1206 "!ERROR: Can't copy directory into itself\n");
1207 send();
1208 return FALSE;
1209 }
1210 return do_copy2(path, dest);
1211 }
1212
1213 /* Move path to dest.
1214 * Check that path not moved into itself.
1215 */
1216 static gboolean do_move(char *path, char *dest)
1217 {
1218 char *dest_path;
1219 char *leaf;
1220 gboolean retval = TRUE;
1221 char *argv[] = {"mv", "-f", NULL, NULL, NULL};
1222 struct stat info2;
1223 gboolean is_dir;
1224
1225 if (is_sub_dir(dest, path))
1226 {
1227 g_string_sprintf(message,
1228 "!ERROR: Can't move directory into itself\n");
1229 send();
1230 return FALSE;
1231 }
1232
1233 check_flags();
1234
1235 leaf = strrchr(path, '/');
1236 if (!leaf)
1237 leaf = path; /* Error? */
1238 else
1239 leaf++;
1240
1241 dest_path = make_path(dest, leaf)->str;
1242
1243 is_dir = lstat(path, &info2) == 0 && S_ISDIR(info2.st_mode);
1244
1245 if (access(dest_path, F_OK) == 0)
1246 {
1247 struct stat info;
1248 int err;
1249
1250 g_string_sprintf(message, "?'%s' already exists - overwrite?",
1251 dest_path);
1252 if (!reply(from_parent, TRUE))
1253 return FALSE;
1254
1255 if (lstat(dest_path, &info))
1256 {
1257 send_error();
1258 return FALSE;
1259 }
1260
1261 if (S_ISDIR(info.st_mode))
1262 err = rmdir(dest_path);
1263 else
1264 err = unlink(dest_path);
1265
1266 if (err)
1267 {
1268 send_error();
1269 if (errno != ENOENT)
1270 return FALSE;
1271 g_string_sprintf(message,
1272 "'Trying move anyway...\n");
1273 send();
1274 }
1275 }
1276 else if (!quiet)
1277 {
1278 g_string_sprintf(message, "?Move %s as %s?", path, dest_path);
1279 if (!reply(from_parent, FALSE))
1280 return FALSE;
1281 }
1282 else
1283 {
1284 g_string_sprintf(message, "'Moving %s as %s\n", path,
1285 dest_path);
1286 send();
1287 }
1288
1289 argv[2] = path;
1290 argv[3] = dest;
1291
1292 if (fork_exec_wait(argv) == 0)
1293 {
1294 g_string_sprintf(message, "+%s", path);
1295 g_string_truncate(message, leaf - path);
1296 send();
1297 if (is_dir) {
1298 g_string_sprintf(message, "m%s", path);
1299 send();
1300 }
1301 }
1302 else
1303 {
1304 g_string_sprintf(message, "!ERROR: Failed to move %s as %s\n",
1305 path, dest_path);
1306 send();
1307 retval = FALSE;
1308 }
1309
1310 return retval;
1311 }
1312
1313 static gboolean do_link(char *path, char *dest)
1314 {
1315 char *dest_path;
1316 char *leaf;
1317
1318 check_flags();
1319
1320 leaf = strrchr(path, '/');
1321 if (!leaf)
1322 leaf = path; /* Error? */
1323 else
1324 leaf++;
1325
1326 dest_path = make_path(dest, leaf)->str;
1327
1328 if (quiet)
1329 {
1330 g_string_sprintf(message, "'Linking %s as %s\n", path,
1331 dest_path);
1332 send();
1333 }
1334 else
1335 {
1336 g_string_sprintf(message, "?Link %s as %s?", path, dest_path);
1337 if (!reply(from_parent, FALSE))
1338 return FALSE;
1339 }
1340
1341 if (symlink(path, dest_path))
1342 {
1343 send_error();
1344 return FALSE;
1345 }
1346
1347 return TRUE;
1348 }
1349
1350 /* Mount/umount this item */
1351 static void do_mount(FilerWindow *filer_window, DirItem *item)
1352 {
1353 char *argv[3] = {NULL, NULL, NULL};
1354 char *action;
1355
1356 check_flags();
1357
1358 argv[0] = item->flags & ITEM_FLAG_MOUNTED ? "umount" : "mount";
1359 action = item->flags & ITEM_FLAG_MOUNTED ? "Unmount" : "Mount";
1360 argv[1] = make_path(filer_window->path, item->leafname)->str;
1361
1362 if (quiet)
1363 {
1364 g_string_sprintf(message, "'%sing %s\n", action, argv[1]);
1365 send();
1366 }
1367 else
1368 {
1369 g_string_sprintf(message, "?%s %s?", action, argv[1]);
1370 if (!reply(from_parent, FALSE))
1371 return;
1372 }
1373
1374 if (fork_exec_wait(argv) == 0)
1375 {
1376 g_string_sprintf(message, "+%s", filer_window->path);
1377 send();
1378 g_string_sprintf(message, "m%s", argv[1]);
1379 send();
1380 }
1381 else
1382 {
1383 g_string_sprintf(message, "!ERROR: %s failed\n", action);
1384 send();
1385 }
1386 }
1387
1388 /* CHILD MAIN LOOPS */
1389
1390 /* After forking, the child calls one of these functions */
1391
1392 static void usage_cb(gpointer data)
1393 {
1394 FilerWindow *filer_window = (FilerWindow *) data;
1395 Collection *collection = filer_window->collection;
1396 DirItem *item;
1397 int left = collection->number_selected;
1398 int i = -1;
1399 off_t total_size = 0;
1400
1401 send_dir(filer_window->path);
1402
1403 while (left > 0)
1404 {
1405 i++;
1406 if (!collection->items[i].selected)
1407 continue;
1408 item = (DirItem *) collection->items[i].data;
1409 size_tally = 0;
1410 do_usage(make_path(filer_window->path,
1411 item->leafname)->str,
1412 filer_window->path);
1413 g_string_sprintf(message, "'%s: %s\n",
1414 item->leafname,
1415 format_size((unsigned long) size_tally));
1416 send();
1417 total_size += size_tally;
1418 left--;
1419 }
1420
1421 g_string_sprintf(message, "'\nTotal: %s\n",
1422 format_size((unsigned long) total_size));
1423 send();
1424 }
1425
1426 #ifdef DO_MOUNT_POINTS
1427 static void mount_cb(gpointer data)
1428 {
1429 FilerWindow *filer_window = (FilerWindow *) data;
1430 Collection *collection = filer_window->collection;
1431 DirItem *item;
1432 int i;
1433 gboolean mount_points = FALSE;
1434
1435 send_dir(filer_window->path);
1436
1437 if (mount_item)
1438 do_mount(filer_window, mount_item);
1439 else
1440 {
1441 for (i = 0; i < collection->number_of_items; i++)
1442 {
1443 if (!collection->items[i].selected)
1444 continue;
1445 item = (DirItem *) collection->items[i].data;
1446 if (!(item->flags & ITEM_FLAG_MOUNT_POINT))
1447 continue;
1448 mount_points = TRUE;
1449
1450 do_mount(filer_window, item);
1451 }
1452
1453 if (!mount_points)
1454 {
1455 g_string_sprintf(message,
1456 "!No mount points selected!\n");
1457 send();
1458 }
1459 }
1460
1461 g_string_sprintf(message, "'\nDone\n");
1462 send();
1463 }
1464 #endif
1465
1466 static void delete_cb(gpointer data)
1467 {
1468 FilerWindow *filer_window = (FilerWindow *) data;
1469 Collection *collection = filer_window->collection;
1470 DirItem *item;
1471 int left = collection->number_selected;
1472 int i = -1;
1473
1474 send_dir(filer_window->path);
1475
1476 while (left > 0)
1477 {
1478 i++;
1479 if (!collection->items[i].selected)
1480 continue;
1481 item = (DirItem *) collection->items[i].data;
1482 if (do_delete(make_path(filer_window->path,
1483 item->leafname)->str,
1484 filer_window->path))
1485 {
1486 g_string_sprintf(message, "+%s", filer_window->path);
1487 send();
1488 }
1489 left--;
1490 }
1491
1492 g_string_sprintf(message, "'\nDone\n");
1493 send();
1494 }
1495
1496 static void chmod_cb(gpointer data)
1497 {
1498 FilerWindow *filer_window = (FilerWindow *) data;
1499 Collection *collection = filer_window->collection;
1500 DirItem *item;
1501 int left = collection->number_selected;
1502 int i = -1;
1503
1504 send_dir(filer_window->path);
1505
1506 mode_change = mode_compile(chmod_command, MODE_MASK_ALL);
1507
1508 while (left > 0)
1509 {
1510 i++;
1511 if (!collection->items[i].selected)
1512 continue;
1513 item = (DirItem *) collection->items[i].data;
1514 if (item->flags & ITEM_FLAG_SYMLINK)
1515 {
1516 g_string_sprintf(message, "!'%s' is a symbolic link\n",
1517 item->leafname);
1518 send();
1519 }
1520 else if (do_chmod(make_path(filer_window->path,
1521 item->leafname)->str, NULL))
1522 {
1523 g_string_sprintf(message, "+%s", filer_window->path);
1524 send();
1525 }
1526 left--;
1527 }
1528
1529 g_string_sprintf(message, "'\nDone\n");
1530 send();
1531 }
1532
1533 static void list_cb(gpointer data)
1534 {
1535 GSList *paths = (GSList *) data;
1536
1537 while (paths)
1538 {
1539 send_dir((char *) paths->data);
1540
1541 if (action_do_func((char *) paths->data, action_dest))
1542 {
1543 g_string_sprintf(message, "+%s", action_dest);
1544 send();
1545 }
1546
1547 paths = paths->next;
1548 }
1549
1550 g_string_sprintf(message, "'\nDone\n");
1551 send();
1552 }
1553
1554 static void add_toggle(GUIside *gui_side, guchar *label, guchar *code)
1555 {
1556 GtkWidget *check;
1557
1558 check = gtk_check_button_new_with_label(label);
1559 gtk_object_set_data(GTK_OBJECT(check), "send-code", code);
1560 gtk_signal_connect(GTK_OBJECT(check), "clicked",
1561 button_reply, gui_side);
1562 gtk_box_pack_start(GTK_BOX(gui_side->vbox), check, FALSE, TRUE, 0);
1563 }
1564
1565
1566 /* EXTERNAL INTERFACE */
1567
1568 /* Count disk space used by selected items */
1569 void action_usage(FilerWindow *filer_window)
1570 {
1571 GUIside *gui_side;
1572 Collection *collection;
1573
1574 collection = filer_window->collection;
1575
1576 if (collection->number_selected < 1)
1577 {
1578 report_error("ROX-Filer", "You need to select some items "
1579 "to count");
1580 return;
1581 }
1582
1583 gui_side = start_action(filer_window, usage_cb, TRUE);
1584 if (!gui_side)
1585 return;
1586
1587 gui_side->show_info = TRUE;
1588
1589 gtk_window_set_title(GTK_WINDOW(gui_side->window), "Disk Usage");
1590 number_of_windows++;
1591 gtk_widget_show_all(gui_side->window);
1592 }
1593
1594 /* Mount/unmount 'item', or all selected mount points if NULL. */
1595 void action_mount(FilerWindow *filer_window, DirItem *item)
1596 {
1597 #ifdef DO_MOUNT_POINTS
1598 GUIside *gui_side;
1599 Collection *collection;
1600
1601 collection = filer_window->collection;
1602
1603 if (item == NULL && collection->number_selected < 1)
1604 {
1605 report_error("ROX-Filer", "You need to select some items "
1606 "to mount or unmount");
1607 return;
1608 }
1609
1610 mount_item = item;
1611 gui_side = start_action(filer_window, mount_cb, o_auto_mount);
1612 if (!gui_side)
1613 return;
1614
1615 gtk_window_set_title(GTK_WINDOW(gui_side->window), "Mount / Unmount");
1616 number_of_windows++;
1617 gtk_widget_show_all(gui_side->window);
1618 #else
1619 report_error("ROX-Filer",
1620 "ROX-Filer does not yet support mount points on your "
1621 "system. Sorry.");
1622 #endif /* DO_MOUNT_POINTS */
1623 }
1624
1625 /* Deletes all selected items in the window */
1626 void action_delete(FilerWindow *filer_window)
1627 {
1628 GUIside *gui_side;
1629 Collection *collection;
1630
1631 collection = filer_window->collection;
1632
1633 if (collection->number_selected < 1)
1634 {
1635 report_error("ROX-Filer", "You need to select some items "
1636 "to delete");
1637 return;
1638 }
1639
1640 gui_side = start_action(filer_window, delete_cb, o_auto_delete);
1641 if (!gui_side)
1642 return;
1643
1644 gtk_window_set_title(GTK_WINDOW(gui_side->window), "Delete");
1645 add_toggle(gui_side,
1646 "Force - don't confirm deletion of non-writeable items", "F");
1647 add_toggle(gui_side,
1648 "Brief - only log directories being deleted", "B");
1649
1650 number_of_windows++;
1651 gtk_widget_show_all(gui_side->window);
1652 }
1653
1654 /* Change the permissions of the selected items */
1655 void action_chmod(FilerWindow *filer_window)
1656 {
1657 GUIside *gui_side;
1658 Collection *collection;
1659 GtkWidget *hbox, *label, *button;
1660
1661 collection = filer_window->collection;
1662
1663 if (collection->number_selected < 1)
1664 {
1665 report_error("ROX-Filer", "You need to select the items "
1666 "whose permissions you want to change");
1667 return;
1668 }
1669
1670 if (!chmod_command)
1671 chmod_command = g_strdup("a+x");
1672 gui_side = start_action(filer_window, chmod_cb, FALSE);
1673 if (!gui_side)
1674 return;
1675
1676 gtk_window_set_title(GTK_WINDOW(gui_side->window), "Permissions");
1677 add_toggle(gui_side,
1678 "Brief - don't list processed files", "B");
1679 add_toggle(gui_side,
1680 "Recurse - also change contents of subdirectories", "R");
1681 hbox = gtk_hbox_new(FALSE, 0);
1682 label = gtk_label_new("Command:");
1683 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 4);
1684 gui_side->entry = gtk_entry_new();
1685 gtk_entry_set_text(GTK_ENTRY(gui_side->entry), chmod_command);
1686 gtk_widget_set_sensitive(gui_side->entry, FALSE);
1687 gtk_box_pack_start(GTK_BOX(hbox), gui_side->entry, TRUE, TRUE, 4);
1688 gtk_signal_connect(GTK_OBJECT(gui_side->entry), "changed",
1689 chmod_command_changed, gui_side);
1690 gtk_box_pack_start(GTK_BOX(gui_side->vbox), hbox, FALSE, TRUE, 0);
1691 button = gtk_button_new_with_label("Show command reference");
1692 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, TRUE, 4);
1693 gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
1694 show_chmod_help, NULL);
1695
1696 number_of_windows++;
1697 gtk_widget_show_all(gui_side->window);
1698 }
1699
1700 void action_copy(GSList *paths, char *dest, char *leaf)
1701 {
1702 GUIside *gui_side;
1703
1704 action_dest = dest;
1705 action_leaf = leaf;
1706 action_do_func = do_copy;
1707 gui_side = start_action(paths, list_cb, o_auto_copy);
1708 if (!gui_side)
1709 return;
1710
1711 gtk_window_set_title(GTK_WINDOW(gui_side->window), "Copy");
1712 number_of_windows++;
1713 gtk_widget_show_all(gui_side->window);
1714 }
1715
1716 void action_move(GSList *paths, char *dest)
1717 {
1718 GUIside *gui_side;
1719
1720 action_dest = dest;
1721 action_do_func = do_move;
1722 gui_side = start_action(paths, list_cb, o_auto_move);
1723 if (!gui_side)
1724 return;
1725
1726 gtk_window_set_title(GTK_WINDOW(gui_side->window), "Move");
1727 number_of_windows++;
1728 gtk_widget_show_all(gui_side->window);
1729 }
1730
1731 void action_link(GSList *paths, char *dest)
1732 {
1733 GUIside *gui_side;
1734
1735 action_dest = dest;
1736 action_do_func = do_link;
1737 gui_side = start_action(paths, list_cb, o_auto_link);
1738 if (!gui_side)
1739 return;
1740
1741 gtk_window_set_title(GTK_WINDOW(gui_side->window), "Link");
1742 number_of_windows++;
1743 gtk_widget_show_all(gui_side->window);
1744 }
1745
1746 void action_init(void)
1747 {
1748 options_sections = g_slist_prepend(options_sections, &options);
1749 option_register("action_auto_quiet", action_auto_quiet);
1750 }
Filer for the ROX desktop