?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r1564: Added count_selected to View interface.
[rox-filer.git] / ROX-Filer / src / dnd.c
blob355fb7d3237e65cf3d15f53a7320e8bf38ac0a68
1 /*
2 * $Id$
3 *
4 * ROX-Filer, filer for the ROX desktop project
5 * Copyright (C) 2002, the ROX-Filer team.
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 /* dnd.c - code for handling drag and drop */
23
24 #include "config.h"
25
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <fcntl.h>
29 #include <errno.h>
30 #include <string.h>
31 #include <sys/param.h>
32
33 #include <X11/Xlib.h>
34 #include <X11/Xatom.h>
35 #include <gtk/gtk.h>
36 #include <gdk/gdkx.h>
37
38 #include "global.h"
39
40 #include "view_iface.h"
41 #include "collection.h"
42 #include "dnd.h"
43 #include "type.h"
44 #include "filer.h"
45 #include "action.h"
46 #include "pixmaps.h"
47 #include "gui_support.h"
48 #include "support.h"
49 #include "options.h"
50 #include "run.h"
51 #include "pinboard.h"
52 #include "dir.h"
53 #include "diritem.h"
54 #include "usericons.h"
55 #include "menu.h"
56
57 #define MAXURILEN 4096 /* Longest URI to allow */
58
59 gint drag_start_x, drag_start_y;
60 MotionType motion_state = MOTION_NONE;
61
62 static GList *prompt_local_paths = NULL;
63 static gchar *prompt_dest_path = NULL;
64
65 /* This keeps track of how many mouse buttons are currently down.
66 * We add a grab when it does 0->1 and release it on 1<-0.
67 *
68 * It may also be set to zero to disable the motion system (eg,
69 * when popping up a menu).
70 */
71 gint motion_buttons_pressed = 0;
72
73 /* Static prototypes */
74 static void set_xds_prop(GdkDragContext *context, char *text);
75 static gboolean drag_motion(GtkWidget *widget,
76 GdkDragContext *context,
77 gint x,
78 gint y,
79 guint time,
80 FilerWindow *filer_window);
81 static void drag_leave(GtkWidget *widget,
82 GdkDragContext *context,
83 guint32 time,
84 FilerWindow *filer_window);
85 static void desktop_drag_data_received(GtkWidget *widget,
86 GdkDragContext *context,
87 gint x,
88 gint y,
89 GtkSelectionData *selection_data,
90 guint info,
91 guint32 time,
92 FilerWindow *filer_window);
93 static void got_data_xds_reply(GtkWidget *widget,
94 GdkDragContext *context,
95 GtkSelectionData *selection_data,
96 guint32 time);
97 static void got_data_raw(GtkWidget *widget,
98 GdkDragContext *context,
99 GtkSelectionData *selection_data,
100 guint32 time);
101 static void got_uri_list(GtkWidget *widget,
102 GdkDragContext *context,
103 GtkSelectionData *selection_data,
104 guint32 time);
105 static void drag_end(GtkWidget *widget,
106 GdkDragContext *context,
107 FilerWindow *filer_window);
108 static gboolean drag_drop(GtkWidget *widget,
109 GdkDragContext *context,
110 gint x,
111 gint y,
112 guint time,
113 gpointer data);
114 static void drag_data_received(GtkWidget *widget,
115 GdkDragContext *context,
116 gint x,
117 gint y,
118 GtkSelectionData *selection_data,
119 guint info,
120 guint32 time,
121 gpointer user_data);
122 static gboolean spring_now(gpointer data);
123 static void spring_win_destroyed(GtkWidget *widget, gpointer data);
124 static void menuitem_response(gpointer data, guint action, GtkWidget *widget);
125 static void prompt_action(GList *paths, gchar *dest);
126
127 typedef enum {
128 MENU_COPY,
129 MENU_MOVE,
130 MENU_LINK,
131 MENU_SET_ICON,
132 } MenuActionType;
133 #undef N_
134 #define N_(x) x
135 static GtkItemFactoryEntry menu_def[] = {
136 {N_("Copy"), NULL, menuitem_response, MENU_COPY, NULL},
137 {N_("Move"), NULL, menuitem_response, MENU_MOVE, NULL},
138 {N_("Link"), NULL, menuitem_response, MENU_LINK, NULL},
139 {"", NULL, NULL, 0, "<Separator>"},
140 {N_("Set Icon"), NULL, menuitem_response, MENU_SET_ICON, NULL},
141 };
142 static GtkWidget *dnd_menu = NULL;
143
144 /* The handler of the signal handler for scroll events.
145 * This is used to cancel spring loading when autoscrolling is used.
146 */
147 static gulong scrolled_signal = -1;
148 static GtkObject *scrolled_adj = NULL; /* The object watched */
149
150 /* Possible values for drop_dest_type (can also be NULL).
151 * In either case, drop_dest_path is the app/file/dir to use.
152 */
153 char *drop_dest_prog = "drop_dest_prog"; /* Run a program */
154 char *drop_dest_dir = "drop_dest_dir"; /* Save to path */
155
156 GdkAtom XdndDirectSave0;
157 GdkAtom xa_text_plain;
158 GdkAtom text_uri_list;
159 GdkAtom application_octet_stream;
160 GdkAtom xa_string; /* Not actually used for DnD, but the others are here! */
161
162 static Option o_dnd_drag_to_icons;
163 Option o_dnd_spring_open;
164 static Option o_dnd_spring_delay;
165 static Option o_dnd_middle_menu;
166
167 void dnd_init()
168 {
169 XdndDirectSave0 = gdk_atom_intern("XdndDirectSave0", FALSE);
170 xa_text_plain = gdk_atom_intern("text/plain", FALSE);
171 text_uri_list = gdk_atom_intern("text/uri-list", FALSE);
172 application_octet_stream = gdk_atom_intern("application/octet-stream",
173 FALSE);
174 xa_string = gdk_atom_intern("STRING", FALSE);
175
176 option_add_int(&o_dnd_drag_to_icons, "dnd_drag_to_icons", 1);
177 option_add_int(&o_dnd_spring_open, "dnd_spring_open", 0);
178 option_add_int(&o_dnd_spring_delay, "dnd_spring_delay", 400);
179 option_add_int(&o_dnd_middle_menu, "dnd_middle_menu", TRUE);
180 }
181
182 /* SUPPORT FUNCTIONS */
183
184 /* Set the XdndDirectSave0 property on the source window for this context */
185 static void set_xds_prop(GdkDragContext *context, char *text)
186 {
187 gdk_property_change(context->source_window,
188 XdndDirectSave0,
189 xa_text_plain, 8,
190 GDK_PROP_MODE_REPLACE,
191 text,
192 strlen(text));
193 }
194
195 static char *get_xds_prop(GdkDragContext *context)
196 {
197 guchar *prop_text;
198 gint length;
199
200 if (gdk_property_get(context->source_window,
201 XdndDirectSave0,
202 xa_text_plain,
203 0, MAXURILEN,
204 FALSE,
205 NULL, NULL,
206 &length, &prop_text) && prop_text)
207 {
208 /* Terminate the string */
209 prop_text = g_realloc(prop_text, length + 1);
210 prop_text[length] = '\0';
211 return prop_text;
212 }
213
214 return NULL;
215 }
216
217 /* Is the sender willing to supply this target type? */
218 gboolean provides(GdkDragContext *context, GdkAtom target)
219 {
220 GList *targets = context->targets;
221
222 while (targets && ((GdkAtom) targets->data != target))
223 targets = targets->next;
224
225 return targets != NULL;
226 }
227
228 /* Convert a list of URIs into a list of strings.
229 * Lines beginning with # are skipped.
230 * The text block passed in is zero terminated (after the final CRLF)
231 */
232 GList *uri_list_to_glist(const char *uri_list)
233 {
234 GList *list = NULL;
235
236 while (*uri_list)
237 {
238 char *linebreak;
239 char *uri;
240 int length;
241
242 linebreak = strchr(uri_list, 13);
243
244 if (!linebreak || linebreak[1] != 10)
245 {
246 delayed_error("uri_list_to_glist: %s",
247 _("Incorrect or missing line "
248 "break in text/uri-list data"));
249 return list;
250 }
251
252 length = linebreak - uri_list;
253
254 if (length && uri_list[0] != '#')
255 {
256 uri = g_strndup(uri_list, length);
257 list = g_list_append(list, uri);
258 }
259
260 uri_list = linebreak + 2;
261 }
262
263 return list;
264 }
265
266 /* DRAGGING FROM US */
267
268 /* The user has held the mouse button down over a group of item and moved -
269 * start a drag. 'uri_list' is copied, so you can delete it straight away.
270 */
271 void drag_selection(GtkWidget *widget, GdkEventMotion *event, guchar *uri_list)
272 {
273 GdkDragContext *context;
274 GdkDragAction actions;
275 GtkTargetList *target_list;
276 GtkTargetEntry target_table[] = {
277 {"text/uri-list", 0, TARGET_URI_LIST},
278 };
279
280 if (event->state & GDK_BUTTON1_MASK)
281 actions = GDK_ACTION_COPY | GDK_ACTION_MOVE
282 | GDK_ACTION_LINK | GDK_ACTION_ASK;
283 else
284 {
285 if (o_dnd_middle_menu.int_value)
286 actions = GDK_ACTION_ASK;
287 else
288 actions = GDK_ACTION_MOVE;
289 }
290
291 target_list = gtk_target_list_new(target_table, 1);
292
293 context = gtk_drag_begin(widget,
294 target_list,
295 actions,
296 (event->state & GDK_BUTTON1_MASK) ? 1 :
297 (event->state & GDK_BUTTON2_MASK) ? 2 : 3,
298 (GdkEvent *) event);
299
300 g_dataset_set_data_full(context, "uri_list",
301 g_strdup(uri_list), g_free);
302
303 gtk_drag_set_icon_pixbuf(context, im_multiple->pixbuf, 0, 0);
304 }
305
306 /* Copy/Load this item into another directory/application */
307 void drag_one_item(GtkWidget *widget,
308 GdkEventMotion *event,
309 const guchar *full_path,
310 DirItem *item,
311 MaskedPixmap *image)
312 {
313 guchar *uri;
314 GdkDragContext *context;
315 GdkDragAction actions;
316 GtkTargetList *target_list;
317 GtkTargetEntry target_table[] = {
318 {"text/uri-list", 0, TARGET_URI_LIST},
319 {"application/octet-stream", 0, TARGET_RAW},
320 {"", 0, TARGET_RAW},
321 };
322
323 g_return_if_fail(full_path != NULL);
324 g_return_if_fail(item != NULL);
325
326 if (!image)
327 image = item->image;
328
329 if (item->base_type == TYPE_FILE)
330 {
331 MIME_type *t = item->mime_type;
332
333 target_table[2].target = g_strconcat(t->media_type, "/",
334 t->subtype, NULL);
335 target_list = gtk_target_list_new(target_table, 3);
336 g_free(target_table[2].target);
337 }
338 else
339 target_list = gtk_target_list_new(target_table, 1);
340
341 if (event->state & GDK_BUTTON1_MASK)
342 actions = GDK_ACTION_COPY | GDK_ACTION_ASK
343 | GDK_ACTION_MOVE | GDK_ACTION_LINK;
344 else
345 {
346 if (o_dnd_middle_menu.int_value)
347 actions = GDK_ACTION_ASK;
348 else
349 actions = GDK_ACTION_MOVE;
350 }
351
352 context = gtk_drag_begin(widget,
353 target_list,
354 actions,
355 (event->state & GDK_BUTTON1_MASK) ? 1 :
356 (event->state & GDK_BUTTON2_MASK) ? 2 : 3,
357 (GdkEvent *) event);
358
359 g_dataset_set_data_full(context, "full_path",
360 g_strdup(full_path), g_free);
361 uri = g_strconcat("file://", our_host_name_for_dnd(),
362 full_path, "\r\n", NULL);
363 g_dataset_set_data_full(context, "uri_list", uri, g_free);
364
365 g_return_if_fail(image != NULL);
366
367 gtk_drag_set_icon_pixbuf(context, image->pixbuf, 0, 0);
368 }
369
370 static void drag_end(GtkWidget *widget,
371 GdkDragContext *context,
372 FilerWindow *filer_window)
373 {
374 if (filer_window->temp_item_selected)
375 {
376 view_clear_selection(VIEW(filer_window->view));
377 filer_window->temp_item_selected = FALSE;
378 }
379 }
380
381 /* Called when a remote app wants us to send it some data.
382 * TODO: Maybe we should handle errors better (ie, let the remote app know
383 * the drag has failed)?
384 */
385 void drag_data_get(GtkWidget *widget,
386 GdkDragContext *context,
387 GtkSelectionData *selection_data,
388 guint info,
389 guint32 time,
390 gpointer data)
391 {
392 char *to_send = "E"; /* Default to sending an error */
393 long to_send_length = 1;
394 gboolean delete_once_sent = FALSE;
395 GdkAtom type;
396 guchar *path;
397
398 type = gdk_x11_xatom_to_atom(XA_STRING);
399
400 switch (info)
401 {
402 case TARGET_RAW:
403 path = g_dataset_get_data(context, "full_path");
404 if (path && load_file(path, &to_send, &to_send_length))
405 {
406 delete_once_sent = TRUE;
407 type = selection_data->target;
408 break;
409 }
410 g_warning("drag_data_get: Can't find path!\n");
411 return;
412 case TARGET_URI_LIST:
413 to_send = g_dataset_get_data(context, "uri_list");
414 to_send_length = strlen(to_send);
415 type = text_uri_list; /* (needed for xine) */
416 delete_once_sent = FALSE;
417 break;
418 default:
419 delayed_error("drag_data_get: %s",
420 _("Internal error - bad info type"));
421 break;
422 }
423
424 gtk_selection_data_set(selection_data,
425 type,
426 8,
427 to_send,
428 to_send_length);
429
430 if (delete_once_sent)
431 g_free(to_send);
432 }
433
434 /* DRAGGING TO US */
435
436 /* Set up this widget as a drop-target.
437 * Does not attach any motion handlers.
438 */
439 void make_drop_target(GtkWidget *widget, GtkDestDefaults defaults)
440 {
441 GtkTargetEntry target_table[] =
442 {
443 {"text/uri-list", 0, TARGET_URI_LIST},
444 {"XdndDirectSave0", 0, TARGET_XDS},
445 {"application/octet-stream", 0, TARGET_RAW},
446 };
447
448 gtk_drag_dest_set(widget,
449 defaults,
450 target_table,
451 sizeof(target_table) / sizeof(*target_table),
452 GDK_ACTION_COPY | GDK_ACTION_ASK | GDK_ACTION_MOVE
453 | GDK_ACTION_LINK | GDK_ACTION_PRIVATE);
454
455 g_signal_connect(widget, "drag_drop", G_CALLBACK(drag_drop), NULL);
456 g_signal_connect(widget, "drag_data_received",
457 G_CALLBACK(drag_data_received), NULL);
458 }
459
460 /* Set up this filer window as a drop target. Called once, when the
461 * filer window is first created.
462 */
463 void drag_set_dest(FilerWindow *filer_window)
464 {
465 GtkWidget *widget = GTK_WIDGET(filer_window->collection);
466
467 make_drop_target(widget, 0);
468
469 g_signal_connect(widget, "drag_motion",
470 G_CALLBACK(drag_motion), filer_window);
471 g_signal_connect(widget, "drag_leave",
472 G_CALLBACK(drag_leave), filer_window);
473 g_signal_connect(widget, "drag_end",
474 G_CALLBACK(drag_end), filer_window);
475 }
476
477 /* Like drag_set_dest, but for a pinboard-type widget */
478 void drag_set_pinboard_dest(GtkWidget *widget)
479 {
480 GtkTargetEntry target_table[] = {
481 {"text/uri-list", 0, TARGET_URI_LIST},
482 };
483
484 gtk_drag_dest_set(widget,
485 GTK_DEST_DEFAULT_DROP,
486 target_table,
487 sizeof(target_table) / sizeof(*target_table),
488 GDK_ACTION_LINK);
489 g_signal_connect(widget, "drag_data_received",
490 G_CALLBACK(desktop_drag_data_received), NULL);
491 }
492
493 /* Called during the drag when the mouse is in a widget registered
494 * as a drop target. Returns TRUE if we can accept the drop.
495 */
496 static gboolean drag_motion(GtkWidget *widget,
497 GdkDragContext *context,
498 gint x,
499 gint y,
500 guint time,
501 FilerWindow *filer_window)
502 {
503 DirItem *item;
504 int item_number;
505 GdkDragAction action = context->suggested_action;
506 char *new_path = NULL;
507 char *type = NULL;
508 gboolean retval = FALSE;
509
510 if (o_dnd_drag_to_icons.int_value)
511 item_number = collection_get_item(filer_window->collection,
512 x, y);
513 else
514 item_number = -1;
515
516 item = item_number >= 0
517 ? (DirItem *) filer_window->collection->items[item_number].data
518 : NULL;
519
520 if (item && filer_window->collection->items[item_number].selected)
521 type = NULL;
522 else
523 type = dnd_motion_item(context, &item);
524
525 if (!type)
526 item = NULL;
527
528 /* Don't allow drops to non-writeable directories. BUT, still
529 * allow drops on non-writeable SUBdirectories so that we can
530 * do the spring-open thing.
531 */
532 if (item && type == drop_dest_dir &&
533 !(item->flags & ITEM_FLAG_APPDIR))
534 {
535 #if 0
536 /* XXX: This is needed so that directories don't
537 * spring open while we scroll. Should go in
538 * view_collection.c, I think.
539 */
540 GtkObject *vadj = GTK_OBJECT(filer_window->collection->vadj);
541
542 /* Subdir: prepare for spring-open */
543 if (scrolled_adj != vadj)
544 {
545 if (scrolled_adj)
546 gtk_signal_disconnect(scrolled_adj,
547 scrolled_signal);
548 scrolled_adj = vadj;
549 scrolled_signal = gtk_signal_connect(
550 scrolled_adj,
551 "value_changed",
552 GTK_SIGNAL_FUNC(scrolled),
553 filer_window->collection);
554 }
555 #endif
556 dnd_spring_load(context, filer_window);
557 }
558 else
559 dnd_spring_abort();
560
561 if (item)
562 {
563 collection_set_cursor_item(filer_window->collection,
564 item_number);
565 }
566 else
567 {
568 collection_set_cursor_item(filer_window->collection, -1);
569
570 /* Disallow background drops within a single window */
571 if (type && gtk_drag_get_source_widget(context) == widget)
572 type = NULL;
573 }
574
575 if (type)
576 {
577 if (item)
578 new_path = make_path(filer_window->sym_path,
579 item->leafname)->str;
580 else
581 new_path = filer_window->sym_path;
582 }
583
584 g_dataset_set_data(context, "drop_dest_type", type);
585 if (type)
586 {
587 gdk_drag_status(context, action, time);
588 g_dataset_set_data_full(context, "drop_dest_path",
589 g_strdup(new_path), g_free);
590 retval = TRUE;
591 }
592
593 return retval;
594 }
595
596 /* item is the item the file is held over, NULL for directory background.
597 * 'item' may be NULL on exit if the drop should be treated as onto the
598 * background. Disallow drags to a selected icon before calling this.
599 *
600 * Returns NULL to reject the drop, or drop_dest_prog/drop_dest_dir to
601 * accept. Build the path based on item.
602 */
603 guchar *dnd_motion_item(GdkDragContext *context, DirItem **item_p)
604 {
605 DirItem *item = *item_p;
606
607 if (item)
608 {
609 /* If we didn't drop onto a directory, application or
610 * executable file then act as though the drop is to the
611 * window background.
612 */
613 if (item->base_type != TYPE_DIRECTORY
614 && !(item->mime_type == application_executable))
615 {
616 item = NULL;
617 *item_p = NULL;
618 }
619 }
620
621 if (!item)
622 {
623 /* Drop onto the window background */
624
625 return drop_dest_dir;
626 }
627
628 /* Drop onto a program/directory of some sort */
629
630 if (item->base_type == TYPE_DIRECTORY &&
631 !(item->flags & ITEM_FLAG_APPDIR))
632 {
633 /* A normal directory */
634 if (provides(context, text_uri_list) ||
635 provides(context, XdndDirectSave0))
636 return drop_dest_dir;
637 }
638 else
639 {
640 if (provides(context, text_uri_list) ||
641 provides(context, application_octet_stream))
642 return drop_dest_prog;
643 }
644
645 return NULL;
646 }
647
648 /* Remove highlights */
649 static void drag_leave(GtkWidget *widget,
650 GdkDragContext *context,
651 guint32 time,
652 FilerWindow *filer_window)
653 {
654 dnd_spring_abort();
655 if (scrolled_adj)
656 {
657 g_signal_handler_disconnect(scrolled_adj, scrolled_signal);
658 scrolled_adj = NULL;
659 }
660 }
661
662 /* User has tried to drop some data on us. Decide what format we would
663 * like the data in.
664 */
665 static gboolean drag_drop(GtkWidget *widget,
666 GdkDragContext *context,
667 gint x,
668 gint y,
669 guint time,
670 gpointer data)
671 {
672 const char *error = NULL;
673 char *leafname = NULL;
674 GdkAtom target = GDK_NONE;
675 char *dest_path;
676 char *dest_type = NULL;
677
678 dest_path = g_dataset_get_data(context, "drop_dest_path");
679 dest_type = g_dataset_get_data(context, "drop_dest_type");
680
681 g_return_val_if_fail(dest_path != NULL, TRUE);
682
683 if (dest_type == drop_dest_dir && provides(context, XdndDirectSave0))
684 {
685 leafname = get_xds_prop(context);
686 if (leafname)
687 {
688 if (strchr(leafname, '/'))
689 {
690 error = _("XDS protocol error: "
691 "leafname may not contain '/'\n");
692 g_free(leafname);
693
694 leafname = NULL;
695 }
696 else
697 {
698 GString *uri;
699
700 uri = g_string_new(NULL);
701 g_string_sprintf(uri, "file://%s%s",
702 our_host_name_for_dnd(),
703 make_path(dest_path,
704 leafname)->str);
705 set_xds_prop(context, uri->str);
706 g_string_free(uri, TRUE);
707
708 target = XdndDirectSave0;
709 g_dataset_set_data_full(context, "leafname",
710 leafname, g_free);
711 }
712 }
713 else
714 error = _(
715 "XdndDirectSave0 target provided, but the atom "
716 "XdndDirectSave0 (type text/plain) did not "
717 "contain a leafname\n");
718 }
719 else if (provides(context, text_uri_list))
720 target = text_uri_list;
721 else if (provides(context, application_octet_stream))
722 target = application_octet_stream;
723 else
724 {
725 if (dest_type == drop_dest_dir)
726 error = _("Sorry - I require a target type of "
727 "text/uri-list or XdndDirectSave0.");
728 else
729 error = _("Sorry - I require a target type of "
730 "text/uri-list or application/octet-stream.");
731 }
732
733 if (error)
734 {
735 gtk_drag_finish(context, FALSE, FALSE, time); /* Failure */
736
737 delayed_error("%s", error);
738 }
739 else
740 gtk_drag_get_data(widget, context, target, time);
741
742 return TRUE;
743 }
744
745 /* Called when a text/uri-list arrives */
746 static void desktop_drag_data_received(GtkWidget *widget,
747 GdkDragContext *context,
748 gint x,
749 gint y,
750 GtkSelectionData *selection_data,
751 guint info,
752 guint32 time,
753 FilerWindow *filer_window)
754 {
755 GList *uris, *next;
756 gint dx, dy;
757
758 if (!selection_data->data)
759 {
760 /* Timeout? */
761 return;
762 }
763
764 if (pinboard_drag_in_progress)
765 {
766 pinboard_move_icons();
767 return;
768 }
769
770 gdk_window_get_position(widget->window, &dx, &dy);
771 x += dx;
772 y += dy;
773
774 uris = uri_list_to_glist(selection_data->data);
775
776 for (next = uris; next; next = next->next)
777 {
778 const guchar *path;
779
780 path = get_local_path((gchar *) next->data);
781 if (path)
782 {
783 pinboard_pin(path, NULL, x, y);
784 x += 64;
785 }
786
787 g_free(next->data);
788 }
789
790 if (uris)
791 g_list_free(uris);
792 }
793
794 /* Called when some data arrives from the remote app (which we asked for
795 * in drag_drop).
796 */
797 static void drag_data_received(GtkWidget *widget,
798 GdkDragContext *context,
799 gint x,
800 gint y,
801 GtkSelectionData *selection_data,
802 guint info,
803 guint32 time,
804 gpointer user_data)
805 {
806 if (!selection_data->data)
807 {
808 /* Timeout? */
809 gtk_drag_finish(context, FALSE, FALSE, time); /* Failure */
810 return;
811 }
812
813 switch (info)
814 {
815 case TARGET_XDS:
816 got_data_xds_reply(widget, context,
817 selection_data, time);
818 break;
819 case TARGET_RAW:
820 got_data_raw(widget, context, selection_data, time);
821 break;
822 case TARGET_URI_LIST:
823 got_uri_list(widget, context, selection_data, time);
824 break;
825 default:
826 gtk_drag_finish(context, FALSE, FALSE, time);
827 delayed_error("drag_data_received: %s",
828 _("Unknown target"));
829 break;
830 }
831 }
832
833 static void got_data_xds_reply(GtkWidget *widget,
834 GdkDragContext *context,
835 GtkSelectionData *selection_data,
836 guint32 time)
837 {
838 gboolean mark_unsafe = TRUE;
839 char response = *selection_data->data;
840 const char *error = NULL;
841 char *dest_path;
842
843 dest_path = g_dataset_get_data(context, "drop_dest_path");
844
845 if (selection_data->length != 1)
846 response = '?';
847
848 if (response == 'F')
849 {
850 /* Sender couldn't save there - ask for another
851 * type if possible.
852 */
853 if (provides(context, application_octet_stream))
854 {
855 mark_unsafe = FALSE; /* Wait and see */
856
857 gtk_drag_get_data(widget, context,
858 application_octet_stream, time);
859 }
860 else
861 error = _("Remote app can't or won't send me "
862 "the data - sorry");
863 }
864 else if (response == 'S')
865 {
866 /* Success - data is saved */
867 mark_unsafe = FALSE; /* It really is safe */
868 gtk_drag_finish(context, TRUE, FALSE, time);
869
870 refresh_dirs(dest_path);
871 }
872 else if (response != 'E')
873 {
874 error = _("XDS protocol error: "
875 "return code should be 'S', 'F' or 'E'\n");
876 }
877 /* else: error has been reported by the sender */
878
879 if (mark_unsafe)
880 {
881 set_xds_prop(context, "");
882 /* Unsave also implies that the drag failed */
883 gtk_drag_finish(context, FALSE, FALSE, time);
884 }
885
886 if (error)
887 delayed_error("%s", error);
888 }
889
890 static void got_data_raw(GtkWidget *widget,
891 GdkDragContext *context,
892 GtkSelectionData *selection_data,
893 guint32 time)
894 {
895 const char *leafname;
896 int fd;
897 const char *error = NULL;
898 const char *dest_path;
899
900 g_return_if_fail(selection_data->data != NULL);
901
902 dest_path = g_dataset_get_data(context, "drop_dest_path");
903
904 if (context->action == GDK_ACTION_ASK)
905 {
906 gtk_drag_finish(context, FALSE, FALSE, time); /* Failure */
907 delayed_error(_("Sorry, can't display a menu of actions "
908 "for a remote file / raw data."));
909 return;
910 }
911
912 if (g_dataset_get_data(context, "drop_dest_type") == drop_dest_prog)
913 {
914 /* The data needs to be sent to an application */
915 run_with_data(dest_path,
916 selection_data->data, selection_data->length);
917 gtk_drag_finish(context, TRUE, FALSE, time); /* Success! */
918 return;
919 }
920
921 leafname = g_dataset_get_data(context, "leafname");
922 if (!leafname)
923 leafname = _("UntitledData");
924
925 fd = open(make_path(dest_path, leafname)->str,
926 O_WRONLY | O_CREAT | O_EXCL | O_NOCTTY,
927 S_IRUSR | S_IRGRP | S_IROTH |
928 S_IWUSR | S_IWGRP | S_IWOTH);
929
930 if (fd == -1)
931 error = g_strerror(errno);
932 else
933 {
934 if (write(fd,
935 selection_data->data,
936 selection_data->length) == -1)
937 error = g_strerror(errno);
938
939 if (close(fd) == -1 && !error)
940 error = g_strerror(errno);
941
942 refresh_dirs(dest_path);
943 }
944
945 if (error)
946 {
947 if (provides(context, XdndDirectSave0))
948 set_xds_prop(context, "");
949 gtk_drag_finish(context, FALSE, FALSE, time); /* Failure */
950 delayed_error(_("Error saving file: %s"), error);
951 }
952 else
953 gtk_drag_finish(context, TRUE, FALSE, time); /* Success! */
954 }
955
956 /* We've got a list of URIs from somewhere (probably another filer window).
957 * If the files are on the local machine then try to copy them ourselves,
958 * otherwise, if there was only one file and application/octet-stream was
959 * provided, get the data via the X server.
960 */
961 static void got_uri_list(GtkWidget *widget,
962 GdkDragContext *context,
963 GtkSelectionData *selection_data,
964 guint32 time)
965 {
966 GList *uri_list;
967 const char *error = NULL;
968 GList *next_uri;
969 gboolean send_reply = TRUE;
970 char *dest_path;
971 char *type;
972
973 dest_path = g_dataset_get_data(context, "drop_dest_path");
974 type = g_dataset_get_data(context, "drop_dest_type");
975
976 g_return_if_fail(dest_path != NULL);
977
978 uri_list = uri_list_to_glist(selection_data->data);
979
980 if (!uri_list)
981 error = _("No URIs in the text/uri-list (nothing to do!)");
982 else if (context->action != GDK_ACTION_ASK && type == drop_dest_prog)
983 run_with_files(dest_path, uri_list);
984 else if ((!uri_list->next) && (!get_local_path(uri_list->data)))
985 {
986 /* There is one URI in the list, and it's not on the local
987 * machine. Get it via the X server if possible.
988 */
989
990 if (provides(context, application_octet_stream))
991 {
992 char *leaf;
993 leaf = strrchr(uri_list->data, '/');
994 if (leaf)
995 leaf++;
996 else
997 leaf = uri_list->data;
998 g_dataset_set_data_full(context, "leafname",
999 g_strdup(leaf), g_free);
1000 gtk_drag_get_data(widget, context,
1001 application_octet_stream, time);
1002 send_reply = FALSE;
1003 }
1004 else
1005 error = _("Can't get data from remote machine "
1006 "(application/octet-stream not provided)");
1007 }
1008 else
1009 {
1010 GList *local_paths = NULL;
1011 GList *next;
1012
1013 /* Either one local URI, or a list. If everything in the list
1014 * isn't local then we are stuck.
1015 */
1016
1017 for (next_uri = uri_list; next_uri; next_uri = next_uri->next)
1018 {
1019 const char *path;
1020
1021 path = get_local_path((char *) next_uri->data);
1022
1023 if (path)
1024 local_paths = g_list_append(local_paths,
1025 g_strdup(path));
1026 else
1027 error = _("Some of these files are on a "
1028 "different machine - they will be "
1029 "ignored - sorry");
1030 }
1031
1032 if (!local_paths)
1033 {
1034 error = _("None of these files are on the local "
1035 "machine - I can't operate on multiple "
1036 "remote files - sorry.");
1037 }
1038 else if (context->action == GDK_ACTION_ASK)
1039 prompt_action(local_paths, dest_path);
1040 else if (context->action == GDK_ACTION_MOVE)
1041 action_move(local_paths, dest_path, NULL, -1);
1042 else if (context->action == GDK_ACTION_COPY)
1043 action_copy(local_paths, dest_path, NULL, -1);
1044 else if (context->action == GDK_ACTION_LINK)
1045 action_link(local_paths, dest_path, NULL);
1046 else
1047 error = _("Unknown action requested");
1048
1049 for (next = local_paths; next; next = next->next)
1050 g_free(next->data);
1051 g_list_free(local_paths);
1052 }
1053
1054 if (error)
1055 {
1056 gtk_drag_finish(context, FALSE, FALSE, time); /* Failure */
1057 delayed_error(_("Error getting file list: %s"), error);
1058 }
1059 else if (send_reply)
1060 gtk_drag_finish(context, TRUE, FALSE, time); /* Success! */
1061
1062 next_uri = uri_list;
1063 while (next_uri)
1064 {
1065 g_free(next_uri->data);
1066 next_uri = next_uri->next;
1067 }
1068 g_list_free(uri_list);
1069 }
1070
1071 /* Called when an item from the ACTION_ASK menu is chosen */
1072 static void menuitem_response(gpointer data, guint action, GtkWidget *widget)
1073 {
1074 if (action == MENU_MOVE)
1075 action_move(prompt_local_paths, prompt_dest_path, NULL, -1);
1076 else if (action == MENU_COPY)
1077 action_copy(prompt_local_paths, prompt_dest_path, NULL, -1);
1078 else if (action == MENU_LINK)
1079 action_link(prompt_local_paths, prompt_dest_path, NULL);
1080 else if (action == MENU_SET_ICON)
1081 {
1082 if (g_list_length(prompt_local_paths) == 1)
1083 set_icon_path(prompt_dest_path,
1084 (char*) prompt_local_paths->data);
1085 else
1086 delayed_error(
1087 _("You can't use multiple files with Set Icon!"));
1088 }
1089 }
1090
1091 /* When some local files are dropped somewhere with ACTION_ASK, this
1092 * function is called to display the menu.
1093 */
1094 static void prompt_action(GList *paths, gchar *dest)
1095 {
1096 GList *next;
1097
1098 if (prompt_local_paths)
1099 {
1100 g_list_foreach(prompt_local_paths, (GFunc) g_free, NULL);
1101 g_list_free(prompt_local_paths);
1102 g_free(prompt_dest_path);
1103
1104 prompt_dest_path = NULL;
1105 prompt_local_paths = NULL;
1106 }
1107
1108 /* Make a copy of the arguments */
1109 for (next = paths; next; next = next->next)
1110 prompt_local_paths = g_list_append(prompt_local_paths,
1111 g_strdup((gchar *) next->data));
1112 prompt_dest_path = g_strdup(dest);
1113
1114 if (!dnd_menu)
1115 {
1116 GtkItemFactory *item_factory;
1117
1118 item_factory = menu_create(menu_def,
1119 sizeof(menu_def) / sizeof(*menu_def),
1120 "<dnd>", NULL);
1121 dnd_menu = gtk_item_factory_get_widget(item_factory, "<dnd>");
1122 }
1123
1124 /* Shade 'Set Icon' if there are multiple files */
1125 menu_set_items_shaded(dnd_menu, g_list_length(paths) != 1, 4, 1);
1126
1127 show_popup_menu(dnd_menu, gtk_get_current_event(), 1);
1128 }
1129
1130
1131 /* SPRING-LOADING */
1132
1133 /* This is the code that makes directories pop open if you hold a
1134 * file over them...
1135 *
1136 * First, call dnd_spring_load(context) to arm the system.
1137 * After a timeout (1/2 a second) the dest_path directory will be
1138 * opened in a new window, unless dnd_spring_abort is called first.
1139 */
1140
1141 static gint spring_timeout = -1;
1142 static GdkDragContext *spring_context = NULL;
1143 static FilerWindow *spring_window = NULL;
1144 static FilerWindow *spring_src_window = NULL;
1145
1146 void dnd_spring_load(GdkDragContext *context, FilerWindow *src_win)
1147 {
1148 g_return_if_fail(context != NULL);
1149
1150 if (!o_dnd_spring_open.int_value)
1151 return;
1152
1153 if (spring_context)
1154 dnd_spring_abort();
1155
1156 spring_context = context;
1157 g_object_ref(spring_context);
1158 spring_src_window = src_win;
1159 spring_timeout = gtk_timeout_add(
1160 o_dnd_spring_delay.int_value, spring_now, NULL);
1161 }
1162
1163 void dnd_spring_abort(void)
1164 {
1165 if (!spring_context)
1166 return;
1167
1168 g_object_unref(spring_context);
1169 spring_context = NULL;
1170 gtk_timeout_remove(spring_timeout);
1171 }
1172
1173 /* If all mod keys are released, no buttons are pressed, and the
1174 * mouse is outside the spring window, then close it.
1175 */
1176 static gboolean spring_check_idle(gpointer data)
1177 {
1178 int p_x, p_y;
1179
1180 if (!spring_window)
1181 return FALSE;
1182
1183 if (!get_pointer_xy(&p_x, &p_y))
1184 {
1185 /*
1186 GdkWindow *win = spring_window->window->window;
1187 int x, y;
1188 int w, h;
1189
1190 gdk_window_get_position(win, &x, &y);
1191 gdk_window_get_size(win, &w, &h);
1192
1193 if (p_x < x || p_x > x + w || p_y < y || p_y > y + h)
1194 {
1195 */
1196
1197 gtk_widget_destroy(spring_window->window);
1198 return FALSE; /* Got it! */
1199 }
1200
1201 return TRUE; /* Try again later */
1202 }
1203
1204 static gboolean spring_now(gpointer data)
1205 {
1206 gboolean old_unique = o_unique_filer_windows.int_value;
1207 guchar *dest_path;
1208 gint x, y;
1209
1210 g_return_val_if_fail(spring_context != NULL, FALSE);
1211
1212 dest_path = g_dataset_get_data(spring_context, "drop_dest_path");
1213 g_return_val_if_fail(dest_path != NULL, FALSE);
1214
1215 /*
1216 * Note: Due to a bug in gtk, if a window disappears during
1217 * a drag and the pointer moves over where the window was,
1218 * the sender crashes! Therefore, do not close any windows
1219 * while dragging! (fixed in later versions)
1220 */
1221 /*
1222 if (spring_window)
1223 gtk_widget_destroy(spring_window->window);
1224 */
1225
1226 get_pointer_xy(&x, &y);
1227
1228 o_unique_filer_windows.int_value = FALSE; /* XXX: yuck! */
1229 if (spring_window)
1230 {
1231 collection_set_cursor_item(spring_window->collection, -1);
1232 filer_change_to(spring_window, dest_path, NULL);
1233 /* DON'T move the window. Gtk+ sometimes doesn't
1234 * notice :-(
1235 */
1236 }
1237 else
1238 {
1239 spring_window = filer_opendir(dest_path, spring_src_window);
1240 if (spring_window)
1241 {
1242 gtk_timeout_add(500, spring_check_idle, NULL);
1243 g_signal_connect(spring_window->window, "destroy",
1244 G_CALLBACK(spring_win_destroyed), NULL);
1245 centre_window(spring_window->window->window, x, y);
1246 }
1247 }
1248 o_unique_filer_windows.int_value = old_unique;
1249
1250 dnd_spring_abort();
1251
1252 return FALSE;
1253 }
1254
1255 static void spring_win_destroyed(GtkWidget *widget, gpointer data)
1256 {
1257 spring_window = NULL;
1258 }
1259
1260 /* HANDLING MOTION EVENTS */
1261
1262 /* If not-NULL, then this widget has a grab */
1263 static GtkWidget *motion_widget = NULL;
1264
1265 /* If TRUE, we must gdk_pointer_ungrab() too when finishing */
1266 static gboolean motion_pointer_grab = FALSE;
1267
1268 /* Call this on a button press event. It stores the mouse position
1269 * as the start of the new drag and returns TRUE if all is well.
1270 * Further motions events are disabled at this point - you must
1271 * then call dnd_motion_start() to set the type of motion expected.
1272 * Grabs the widget on the first press.
1273 *
1274 * If the system is not ready to handle a motion event (because a
1275 * button is already held down?) it does nothing and returns FALSE.
1276 *
1277 * If the event is not a single click then it simply returns TRUE.
1278 */
1279 gboolean dnd_motion_press(GtkWidget *widget, GdkEventButton *event)
1280 {
1281 if (event->type != GDK_BUTTON_PRESS)
1282 return TRUE; /* Not a click event! */
1283
1284 motion_buttons_pressed++;
1285 if (motion_buttons_pressed == 1)
1286 {
1287 /* g_print("[ grab! ]\n"); */
1288 gtk_grab_add(widget);
1289 motion_widget = widget;
1290 }
1291
1292 if (motion_state != MOTION_NONE)
1293 return FALSE; /* Ignore clicks - we're busy! */
1294
1295 motion_state = MOTION_DISABLED;
1296 drag_start_x = event->x_root;
1297 drag_start_y = event->y_root;
1298
1299 return TRUE;
1300 }
1301
1302 /* After the button press event, decide what kind of motion is expected.
1303 * If you don't call this then the motion system is disabled - call
1304 * dnd_motion_release() to reset it.
1305 *
1306 * Note: If you open a popup menu or start DND call dnd_motion_ungrab()
1307 * instead.
1308 */
1309 void dnd_motion_start(MotionType motion)
1310 {
1311 g_return_if_fail(motion_state == MOTION_DISABLED);
1312
1313 motion_state = motion;
1314 }
1315
1316 /* Call this on a button release event. If some buttons are still pressed,
1317 * returns TRUE and does nothing.
1318 *
1319 * Otherwise, it resets the motion system to be ready again and returns TRUE.
1320 *
1321 * If the motion system wasn't being used (MOTION_NONE) then it does nothing
1322 * and returns FALSE - process the release event yourself as it isn't part
1323 * of a motion. This also happens if a motion was primed but never happened.
1324 */
1325 gboolean dnd_motion_release(GdkEventButton *event)
1326 {
1327 MotionType motion = motion_state;
1328 int dx, dy;
1329
1330 if (motion_buttons_pressed == 0)
1331 return TRUE; /* We were disabled */
1332
1333 if (motion_buttons_pressed == 1)
1334 dnd_motion_ungrab();
1335 else
1336 {
1337 motion_buttons_pressed--;
1338 return TRUE;
1339 }
1340
1341 if (motion == MOTION_REPOSITION || motion == MOTION_DISABLED)
1342 return TRUE; /* Already done something - eat the event */
1343
1344 /* Eat release events that happen too far from the click
1345 * source. Otherwise, allow the caller to treat this as a click
1346 * that never became a motion.
1347 */
1348 dx = event->x_root - drag_start_x;
1349 dy = event->y_root - drag_start_y;
1350
1351 return ABS(dx) > 5 || ABS(dy) > 5;
1352 }
1353
1354 /* Use this to disable the motion system. The system will be reset once
1355 * all mouse buttons are released.
1356 */
1357 void dnd_motion_disable(void)
1358 {
1359 g_return_if_fail(motion_state != MOTION_NONE &&
1360 motion_state != MOTION_DISABLED);
1361
1362 motion_state = MOTION_DISABLED;
1363 }
1364
1365 /* Use this if something else is going to grab the pointer so that
1366 * we won't get any more motion or release events.
1367 */
1368 void dnd_motion_ungrab(void)
1369 {
1370 if (motion_buttons_pressed > 0)
1371 {
1372 if (motion_pointer_grab)
1373 {
1374 gdk_pointer_ungrab(GDK_CURRENT_TIME);
1375 motion_pointer_grab = FALSE;
1376 /* g_print("[ ungrab_pointer ]\n"); */
1377 }
1378 gtk_grab_remove(motion_widget);
1379 motion_widget = NULL;
1380 motion_buttons_pressed = 0;
1381 /* g_print("[ ungrab ]\n"); */
1382 }
1383
1384 motion_state = MOTION_NONE;
1385 }
1386
1387 /* Call this on motion events. If the mouse position is far enough
1388 * from the click position, returns TRUE and does dnd_motion_ungrab().
1389 * You should then start regular drag-and-drop.
1390 *
1391 * Otherwise, returns FALSE.
1392 */
1393 gboolean dnd_motion_moved(GdkEventMotion *event)
1394 {
1395 int dx, dy;
1396
1397 dx = event->x_root - drag_start_x;
1398 dy = event->y_root - drag_start_y;
1399
1400 if (ABS(dx) <= 5 && ABS(dy) <= 5)
1401 return FALSE; /* Not far enough */
1402
1403 dnd_motion_ungrab();
1404
1405 return TRUE;
1406 }
1407
1408 /* Normally, the X server will automatically grab the pointer on a
1409 * button press and ungrab on release. However, if the grab widget
1410 * is reparented then call this to re-aquire the grab.
1411 */
1412 void dnd_motion_grab_pointer(void)
1413 {
1414 g_return_if_fail(motion_widget != NULL);
1415
1416 gdk_pointer_grab(motion_widget->window, FALSE,
1417 GDK_POINTER_MOTION_MASK |
1418 GDK_BUTTON_RELEASE_MASK,
1419 FALSE, NULL, GDK_CURRENT_TIME);
1420
1421 motion_pointer_grab = TRUE;
1422 }
Filer for the ROX desktop