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