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