static gint
gtk_dnd_window_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxDropSource *source )
{
source->GiveFeedback(ConvertFromGTK(gdk_drag_context_get_selected_action(source->m_dragContext)));
return 0;
}
static gboolean
individual_drag_received (EmpathyPersonaView *self,
GdkDragContext *context,
GtkSelectionData *selection)
{
EmpathyIndividualManager *manager = NULL;
FolksIndividual *individual;
const gchar *individual_id;
gboolean success = FALSE;
individual_id = (const gchar *) gtk_selection_data_get_data (selection);
manager = empathy_individual_manager_dup_singleton ();
individual = empathy_individual_manager_lookup_member (manager,
individual_id);
if (individual == NULL)
{
DEBUG ("Failed to find drag event individual with ID '%s'",
individual_id);
g_object_unref (manager);
return FALSE;
}
/* Emit a signal notifying of the drag. */
g_signal_emit (self, signals[DRAG_INDIVIDUAL_RECEIVED], 0,
gdk_drag_context_get_selected_action (context), individual, &success);
g_object_unref (manager);
return success;
}
static void
nemo_icon_container_receive_dropped_icons (NemoIconContainer *container,
GdkDragContext *context,
int x, int y)
{
char *drop_target;
gboolean local_move_only;
double world_x, world_y;
gboolean icon_hit;
GdkDragAction action, real_action;
drop_target = NULL;
if (container->details->dnd_info->drag_info.selection_list == NULL) {
return;
}
real_action = gdk_drag_context_get_selected_action (context);
if (real_action == GDK_ACTION_ASK) {
/* FIXME bugzilla.gnome.org 42485: This belongs in FMDirectoryView, not here. */
/* Check for special case items in selection list */
if (nemo_drag_selection_includes_special_link (container->details->dnd_info->drag_info.selection_list)) {
/* We only want to move the trash */
action = GDK_ACTION_MOVE;
} else {
action = GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK;
}
real_action = nemo_drag_drop_action_ask (GTK_WIDGET (container), action);
}
if (real_action > 0) {
eel_canvas_window_to_world (EEL_CANVAS (container),
x + gtk_adjustment_get_value (gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (container))),
y + gtk_adjustment_get_value (gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (container))),
&world_x, &world_y);
drop_target = nemo_icon_container_find_drop_target (container,
context, x, y, &icon_hit, FALSE);
local_move_only = FALSE;
if (!icon_hit && real_action == GDK_ACTION_MOVE) {
/* we can just move the icon positions if the move ended up in
* the item's parent container
*/
local_move_only = nemo_icon_container_selection_items_local
(container, container->details->dnd_info->drag_info.selection_list);
}
if (local_move_only) {
handle_local_move (container, world_x, world_y);
} else {
handle_nonlocal_move (container, real_action, world_x, world_y, drop_target, icon_hit);
}
}
g_free (drop_target);
nemo_drag_destroy_selection_list (container->details->dnd_info->drag_info.selection_list);
container->details->dnd_info->drag_info.selection_list = NULL;
}
void Ctrl::GtkDragEnd(GtkWidget *widget, GdkDragContext *context, gpointer user_data)
{
LLOG("GtkDragEnd");
dnd_result = DND_NONE;
GdkDragAction a = gdk_drag_context_get_selected_action(context);
dnd_result = a == GDK_ACTION_MOVE ? DND_MOVE : a == GDK_ACTION_COPY ? DND_COPY : DND_NONE;
dnd_source = NULL;
}
static void
source_drag_data_get (GtkWidget *WXUNUSED(widget),
GdkDragContext *context,
GtkSelectionData *selection_data,
guint WXUNUSED(info),
guint WXUNUSED(time),
wxDropSource *drop_source )
{
wxDataFormat format(gtk_selection_data_get_target(selection_data));
wxLogTrace(TRACE_DND, wxT("Drop source: format requested: %s"),
format.GetId().c_str());
drop_source->m_retValue = wxDragError;
wxDataObject *data = drop_source->GetDataObject();
if (!data)
{
wxLogTrace(TRACE_DND, wxT("Drop source: no data object") );
return;
}
if (!data->IsSupportedFormat(format))
{
wxLogTrace(TRACE_DND, wxT("Drop source: unsupported format") );
return;
}
if (data->GetDataSize(format) == 0)
{
wxLogTrace(TRACE_DND, wxT("Drop source: empty data") );
return;
}
size_t size = data->GetDataSize(format);
// printf( "data size: %d.\n", (int)data_size );
guchar *d = new guchar[size];
if (!data->GetDataHere( format, (void*)d ))
{
delete[] d;
return;
}
drop_source->m_retValue = ConvertFromGTK(gdk_drag_context_get_selected_action(context));
gtk_selection_data_set( selection_data,
gtk_selection_data_get_target(selection_data),
8, // 8-bit
d,
size );
delete[] d;
}
void Ctrl::GtkDragEnd(GtkWidget *widget, GdkDragContext *context, gpointer user_data)
{
LLOG("GtkDragEnd");
dnd_result = DND_NONE;
#if GTK_CHECK_VERSION(2,22,0) // No drag&drop support before 2.22, sorry...
GdkDragAction a = gdk_drag_context_get_selected_action(context);
dnd_result = a == GDK_ACTION_MOVE ? DND_MOVE : a == GDK_ACTION_COPY ? DND_COPY : DND_NONE;
#else
dnd_result = DND_NONE;
#endif
dnd_source = NULL;
}
/* Emitted when the data has been received from the source. It should check
* the GtkSelectionData sent by the source, and do something with it. Finally
* it needs to finish the operation by calling gtk_drag_finish, which will emit
* the "data-delete" signal if told to. */
static void drag_data_received_handler(GtkWidget *widget, GdkDragContext *context,
gint x, gint y, GtkSelectionData *selection_data, guint target_type, guint time,
gpointer data)
{
char *filename, *p, *lfn;
gboolean dnd_success = FALSE;
gboolean delete_selection_data = FALSE;
DBG(("drag_data_received_handler"));
/* Deal with what we are given from source */
if(dropdata && (selection_data != NULL) && (gtk_selection_data_get_length (selection_data) >= 0))
{
dropdata = 0;
if (gdk_drag_context_get_selected_action(context) == GDK_ACTION_MOVE) {
delete_selection_data = TRUE;
}
/* FIXME; Check that we got a format we can use */
filename = (char*)gtk_selection_data_get_data(selection_data);
DBG(("DnD got string: %s", filename));
dnd_success = TRUE;
/* incase we got a list of files, terminate the list after the first
file */
p = filename;
while (*p) {
if ((*p == '\n') || (*p == '\r')) {
*p = 0;
break;
}
p++;
}
lfn = g_filename_from_uri(filename, NULL, NULL);
if (!lfn) {
log_error(ui_log, "URI conversion failed: %s", filename);
}
DBG(("DnD using filename: '%s'", lfn));
/* finally call the drop callback set by the individual ui */
if (drop_cb) {
drop_cb(lfn);
}
DBG(("DnD done"));
if (lfn) {
free(lfn);
}
}
if (dnd_success == FALSE) {
DBG(("DnD data transfer failed!"));
}
gtk_drag_finish (context, dnd_success, delete_selection_data, time);
}
static void gtkDragDataGet(GtkWidget *widget, GdkDragContext *drag_context, GtkSelectionData *seldata, guint info, guint time, Ihandle* ih)
{
IFnsCi cbDragData = (IFnsCi)IupGetCallback(ih, "DRAGDATA_CB");
IFns cbDragDataSize = (IFns)IupGetCallback(ih, "DRAGDATASIZE_CB");
if(cbDragData && cbDragDataSize)
{
void* sourceData;
char *type;
int size;
GdkDragAction action;
#if GTK_CHECK_VERSION(2, 22, 0)
action = gdk_drag_context_get_selected_action(drag_context);
#else
action = drag_context->action;
#endif
#if GTK_CHECK_VERSION(2, 14, 0)
type = gdk_atom_name(gtk_selection_data_get_target(seldata));
#else
type = seldata->type;
#endif
if (action != GDK_ACTION_MOVE && action != GDK_ACTION_COPY)
return;
size = cbDragDataSize(ih, type);
if (size <= 0)
return;
sourceData = malloc(size+1);
/* fill data */
cbDragData(ih, type, sourceData, size);
/* Zero-terminates the stored data. */
((guchar*)sourceData)[size] = 0;
gtk_selection_data_set(seldata, gdk_atom_intern(type, 0), 8, (guchar*)sourceData, size+1);
/* gtk_selection_data_set will copy the data */
free(sourceData);
}
(void)widget;
(void)drag_context;
(void)time;
(void)info;
}
static void target_drag_data_received( GtkWidget *WXUNUSED(widget),
GdkDragContext *context,
gint x,
gint y,
GtkSelectionData *data,
guint WXUNUSED(info),
guint time,
wxDropTarget *drop_target )
{
/* Owen Taylor: "call gtk_drag_finish() with
success == TRUE" */
if (gtk_selection_data_get_length(data) <= 0 || gtk_selection_data_get_format(data) != 8)
{
/* negative data length and non 8-bit data format
qualifies for junk */
gtk_drag_finish (context, FALSE, FALSE, time);
return;
}
wxLogTrace(TRACE_DND, wxT( "Drop target: data received event") );
/* inform the wxDropTarget about the current GtkSelectionData.
this is only valid for the duration of this call */
drop_target->GTKSetDragData( data );
wxDragResult result = ConvertFromGTK(gdk_drag_context_get_selected_action(context));
if ( wxIsDragResultOk( drop_target->OnData( x, y, result ) ) )
{
wxLogTrace(TRACE_DND, wxT( "Drop target: OnData returned true") );
/* tell GTK that data transfer was successful */
gtk_drag_finish( context, TRUE, FALSE, time );
}
else
{
wxLogTrace(TRACE_DND, wxT( "Drop target: OnData returned FALSE") );
/* tell GTK that data transfer was not successful */
gtk_drag_finish( context, FALSE, FALSE, time );
}
/* after this, invalidate the drop_target's drag data */
drop_target->GTKSetDragData( NULL );
}
static void gtkDragDataReceived(GtkWidget *widget, GdkDragContext *drag_context, gint x, gint y,
GtkSelectionData *seldata, guint info, guint time, Ihandle *ih)
{
IFnsCiii cbDrop = (IFnsCiii)IupGetCallback(ih, "DROPDATA_CB");
void* targetData = NULL;
char* type;
int size, format, res;
GdkDragAction action;
#if GTK_CHECK_VERSION(2, 22, 0)
action = gdk_drag_context_get_selected_action(drag_context);
#else
action = drag_context->action;
#endif
#if GTK_CHECK_VERSION(2, 14, 0)
type = gdk_atom_name(gtk_selection_data_get_target(seldata));
targetData = (void*)gtk_selection_data_get_data(seldata);
size = gtk_selection_data_get_length(seldata);
format = gtk_selection_data_get_format(seldata);
#else
type = gdk_atom_name(seldata->type);
targetData = (void*)seldata->data;
size = seldata->length;
format = seldata->format;
#endif
if(size <= 0 || format != 8 ||
(action != GDK_ACTION_MOVE && action != GDK_ACTION_COPY))
{
gtk_drag_finish(drag_context, FALSE, FALSE, time);
return;
}
if(cbDrop)
res = cbDrop(ih, type, targetData, size, x, y);
gtk_drag_finish(drag_context, TRUE, FALSE, time);
(void)info;
(void)widget;
(void)time;
}
static void
receive_uris (NautilusTreeViewDragDest *dest,
GdkDragContext *context,
GList *source_uris,
int x, int y)
{
char *drop_target;
GdkDragAction action, real_action;
drop_target = get_drop_target_uri_at_pos (dest, x, y);
g_assert (drop_target != NULL);
real_action = gdk_drag_context_get_selected_action (context);
if (real_action == GDK_ACTION_ASK) {
if (nautilus_drag_selection_includes_special_link (dest->details->drag_list)) {
/* We only want to move the trash */
action = GDK_ACTION_MOVE;
} else {
action = GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK;
}
real_action = nautilus_drag_drop_action_ask
(GTK_WIDGET (dest->details->tree_view), action);
}
/* We only want to copy external uris */
if (dest->details->drag_type == NAUTILUS_ICON_DND_URI_LIST) {
real_action = GDK_ACTION_COPY;
}
if (real_action > 0) {
if (!nautilus_drag_uris_local (drop_target, source_uris)
|| real_action != GDK_ACTION_MOVE) {
g_signal_emit (dest, signals[MOVE_COPY_ITEMS], 0,
source_uris,
drop_target,
real_action,
x, y);
}
}
g_free (drop_target);
}
/* handle dropped text */
static void
receive_dropped_text (NemoIconContainer *container, const char *text, GdkDragContext *context, int x, int y)
{
char *drop_target;
if (text == NULL) {
return;
}
drop_target = nemo_icon_container_find_drop_target (container, context, x, y, NULL, TRUE);
g_signal_emit_by_name (container, "handle_text",
text,
drop_target,
gdk_drag_context_get_selected_action (context),
x, y);
g_free (drop_target);
}
static void dispatchEvent(GdkEvent* event)
{
webkit_web_frame_layout(mainFrame);
WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
if (!view) {
gdk_event_free(event);
return;
}
gtk_main_do_event(event);
if (!currentDragSourceContext) {
gdk_event_free(event);
return;
}
if (event->type == GDK_MOTION_NOTIFY) {
// WebKit has called gtk_drag_start(), but because the main loop isn't
// running GDK internals don't know that the drag has started yet. Pump
// the main loop a little bit so that GDK is in the correct state.
while (gtk_events_pending())
gtk_main_iteration();
// Simulate a drag motion on the top-level GDK window.
GtkWidget* parentWidget = gtk_widget_get_parent(GTK_WIDGET(view));
GdkWindow* parentWidgetWindow = gtk_widget_get_window(parentWidget);
gdk_drag_motion(currentDragSourceContext, parentWidgetWindow, GDK_DRAG_PROTO_XDND,
event->motion.x_root, event->motion.y_root,
gdk_drag_context_get_selected_action(currentDragSourceContext),
gdk_drag_context_get_actions(currentDragSourceContext),
GDK_CURRENT_TIME);
} else if (currentDragSourceContext && event->type == GDK_BUTTON_RELEASE) {
// We've released the mouse button, we should just be able to spin the
// event loop here and have GTK+ send the appropriate notifications for
// the end of the drag.
while (gtk_events_pending())
gtk_main_iteration();
}
gdk_event_free(event);
}
/* handle dropped raw data */
static void
receive_dropped_raw (NemoIconContainer *container, const char *raw_data, int length, const char *direct_save_uri, GdkDragContext *context, int x, int y)
{
char *drop_target;
if (raw_data == NULL) {
return;
}
drop_target = nemo_icon_container_find_drop_target (container, context, x, y, NULL, TRUE);
g_signal_emit_by_name (container, "handle_raw",
raw_data,
length,
drop_target,
direct_save_uri,
gdk_drag_context_get_selected_action (context),
x, y);
g_free (drop_target);
}
static void
receive_dropped_netscape_url (NautilusTreeViewDragDest *dest,
GdkDragContext *context,
int x, int y)
{
char *drop_target;
if (!dest->details->drag_data) {
return;
}
drop_target = get_drop_target_uri_at_pos (dest, x, y);
g_assert (drop_target != NULL);
g_signal_emit (dest, signals[HANDLE_NETSCAPE_URL], 0,
(char*) gtk_selection_data_get_data (dest->details->drag_data),
drop_target,
gdk_drag_context_get_selected_action (context),
x, y);
g_free (drop_target);
}
static void
receive_dropped_raw (NautilusTreeViewDragDest *dest,
const char *raw_data, int length,
GdkDragContext *context,
int x, int y)
{
char *drop_target;
if (!dest->details->drag_data) {
return;
}
drop_target = get_drop_target_uri_at_pos (dest, x, y);
g_assert (drop_target != NULL);
g_signal_emit (dest, signals[HANDLE_RAW], 0,
raw_data, length, drop_target,
dest->details->direct_save_uri,
gdk_drag_context_get_selected_action (context),
x, y);
g_free (drop_target);
}
static void
receive_dropped_text (NemoTreeViewDragDest *dest,
GdkDragContext *context,
int x, int y)
{
char *drop_target;
char *text;
if (!dest->details->drag_data) {
return;
}
drop_target = get_drop_target_uri_at_pos (dest, x, y);
g_assert (drop_target != NULL);
text = gtk_selection_data_get_text (dest->details->drag_data);
g_signal_emit (dest, signals[HANDLE_TEXT], 0,
(char *) text, drop_target,
gdk_drag_context_get_selected_action (context),
x, y);
g_free (text);
g_free (drop_target);
}
static void gtkDragEnd(GtkWidget *widget, GdkDragContext *drag_context, Ihandle *ih)
{
IFni cbDrag = (IFni)IupGetCallback(ih, "DRAGEND_CB");
if(cbDrag)
{
GdkDragAction action;
int remove = -1;
#if GTK_CHECK_VERSION(2, 22, 0)
action = gdk_drag_context_get_selected_action(drag_context);
#else
action = drag_context->action;
#endif
if (action == GDK_ACTION_MOVE)
remove = 1;
else if (action == GDK_ACTION_COPY)
remove = 0;
cbDrag(ih, remove);
}
(void)widget;
}
static void
gth_file_list_drag_data_received (GtkWidget *file_view,
GdkDragContext *context,
int x,
int y,
GtkSelectionData *selection_data,
guint info,
guint time,
gpointer user_data)
{
GthBrowser *browser = user_data;
gboolean success = FALSE;
char **uris;
GList *selected_files;
GdkDragAction action;
g_signal_stop_emission_by_name (file_view, "drag-data-received");
action = gdk_drag_context_get_suggested_action (context);
if (action == GDK_ACTION_COPY || action == GDK_ACTION_MOVE) {
success = TRUE;
}
if (action == GDK_ACTION_ASK) {
GdkDragAction actions =
_gtk_menu_ask_drag_drop_action (file_view,
gdk_drag_context_get_actions (context),
time);
gdk_drag_status (context, actions, time);
success = gdk_drag_context_get_selected_action (context) != 0;
}
if (gtk_selection_data_get_data_type (selection_data) == XDND_ACTION_DIRECT_SAVE_ATOM) {
const guchar *data;
int format;
int length;
data = gtk_selection_data_get_data (selection_data);
format = gtk_selection_data_get_format (selection_data);
length = gtk_selection_data_get_length (selection_data);
if ((format == 8) && (length == 1) && (data[0] == 'S')) {
success = TRUE;
}
else {
gdk_property_change (gdk_drag_context_get_dest_window (context),
XDND_ACTION_DIRECT_SAVE_ATOM,
TEXT_PLAIN_ATOM,
8,
GDK_PROP_MODE_REPLACE,
(const guchar *) "",
0);
success = FALSE;
}
gtk_drag_finish (context, success, FALSE, time);
return;
}
gtk_drag_finish (context, success, FALSE, time);
if (! success)
return;
uris = gtk_selection_data_get_uris (selection_data);
selected_files = _g_file_list_new_from_uriv (uris);
if (selected_files != NULL) {
if (gtk_drag_get_source_widget (context) == file_view) {
GList *file_data_list;
GList *visible_files;
BrowserData *data;
GthTask *task;
file_data_list = gth_file_store_get_visibles (gth_browser_get_file_store (browser));
visible_files = gth_file_data_list_to_file_list (file_data_list);
data = g_object_get_data (G_OBJECT (browser), BROWSER_DATA_KEY);
task = gth_reorder_task_new (gth_browser_get_location_source (browser),
gth_browser_get_location_data (browser),
visible_files,
selected_files,
data->drop_pos);
gth_browser_exec_task (browser, task, FALSE);
g_object_unref (task);
_g_object_list_unref (visible_files);
_g_object_list_unref (file_data_list);
}
else {
GthFileSource *file_source;
gboolean cancel = FALSE;
gboolean move;
file_source = gth_browser_get_location_source (browser);
move = gdk_drag_context_get_selected_action (context) == GDK_ACTION_MOVE;
if (move && ! gth_file_source_can_cut (file_source, (GFile *) selected_files->data)) {
GtkWidget *dialog;
int response;
dialog = _gtk_message_dialog_new (GTK_WINDOW (browser),
GTK_DIALOG_MODAL,
GTK_STOCK_DIALOG_QUESTION,
_("Could not move the files"),
_("Files cannot be moved to the current location, as alternative you can choose to copy them."),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_COPY, GTK_RESPONSE_OK,
NULL);
response = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
if (response == GTK_RESPONSE_CANCEL)
cancel = TRUE;
move = FALSE;
}
if (! cancel) {
GthFileSource *location_source;
BrowserData *data;
GthTask *task;
location_source = gth_main_get_file_source (gth_browser_get_location (browser));
data = g_object_get_data (G_OBJECT (browser), BROWSER_DATA_KEY);
task = gth_copy_task_new (location_source,
gth_browser_get_location_data (browser),
move,
selected_files,
data->drop_pos);
gth_browser_exec_task (browser, task, FALSE);
g_object_unref (task);
g_object_unref (location_source);
}
}
}
_g_object_list_unref (selected_files);
g_strfreev (uris);
}
gboolean on_dir_tree_view_drag_motion ( GtkWidget *widget,
GdkDragContext *drag_context,
gint x,
gint y,
guint time,
PtkFileBrowser* file_browser ) //MOD added
{
GdkDragAction suggested_action;
GdkAtom target;
GtkTargetList* target_list;
target_list = gtk_target_list_new( drag_targets, G_N_ELEMENTS(drag_targets) );
target = gtk_drag_dest_find_target( widget, drag_context, target_list );
gtk_target_list_unref( target_list );
if (target == GDK_NONE)
gdk_drag_status( drag_context, 0, time);
else
{
// Need to set suggested_action because default handler assumes copy
/* Only 'move' is available. The user force move action by pressing Shift key */
if( (gdk_drag_context_get_actions ( drag_context ) & GDK_ACTION_ALL) == GDK_ACTION_MOVE )
suggested_action = GDK_ACTION_MOVE;
/* Only 'copy' is available. The user force copy action by pressing Ctrl key */
else if( (gdk_drag_context_get_actions ( drag_context ) & GDK_ACTION_ALL) == GDK_ACTION_COPY )
suggested_action = GDK_ACTION_COPY;
/* Only 'link' is available. The user force link action by pressing Shift+Ctrl key */
else if( (gdk_drag_context_get_actions ( drag_context ) & GDK_ACTION_ALL) == GDK_ACTION_LINK )
suggested_action = GDK_ACTION_LINK;
/* Several different actions are available. We have to figure out a good default action. */
else
{
int drag_action = xset_get_int( "drag_action", "x" );
if ( drag_action == 1 )
suggested_action = GDK_ACTION_COPY;
else if ( drag_action == 2 )
suggested_action = GDK_ACTION_MOVE;
else if ( drag_action == 3 )
suggested_action = GDK_ACTION_LINK;
else
{
// automatic
file_browser->pending_drag_status_tree = 1;
gtk_drag_get_data (widget, drag_context, target, time);
suggested_action = gdk_drag_context_get_selected_action( drag_context );
}
}
#if GTK_CHECK_VERSION (3, 0, 0)
/* hack to be able to call the default handler with the correct suggested_action */
struct _GdkDragContext {
GObject parent_instance;
/*< private >*/
GdkDragProtocol protocol;
#if GTK_CHECK_VERSION (3, 22, 0)
/* 1.0.6 per Teklad: _GdkDragContext appears to change between
* different versions of GTK3 which causes the crash. It appears they
* added/removed some variables from that struct.
* https://github.com/IgnorantGuru/spacefm/issues/670 */
GdkDisplay *display;
#endif
gboolean is_source;
GdkWindow *source_window;
GdkWindow *dest_window;
GList *targets;
GdkDragAction actions;
GdkDragAction suggested_action;
GdkDragAction action;
guint32 start_time;
GdkDevice *device;
#if GTK_CHECK_VERSION (3, 22, 0)
/* 1.0.6 per Teklad: _GdkDragContext appears to change between
* different versions of GTK3 which causes the crash. It appears they
* added/removed some variables from that struct.
* https://github.com/IgnorantGuru/spacefm/issues/670 */
guint drop_done : 1; /* Whether gdk_drag_drop_done() was performed */
#endif
};
((struct _GdkDragContext *)drag_context)->suggested_action = suggested_action;
#else
drag_context->suggested_action = suggested_action; // needed for default handler
#endif
gdk_drag_status( drag_context, suggested_action, gtk_get_current_event_time() );
}
return FALSE;
}
static void
slot_proxy_handle_drop (GtkWidget *widget,
GdkDragContext *context,
unsigned int time,
NautilusDragSlotProxyInfo *drag_info)
{
GtkWidget *window;
NautilusWindowSlot *target_slot;
NautilusFilesView *target_view;
char *target_uri;
GList *uri_list;
GFile *location;
if (!drag_info->have_data ||
!drag_info->have_valid_data) {
gtk_drag_finish (context, FALSE, FALSE, time);
drag_info_clear (drag_info);
return;
}
window = gtk_widget_get_toplevel (widget);
g_assert (NAUTILUS_IS_WINDOW (window));
if (drag_info->target_slot != NULL) {
target_slot = drag_info->target_slot;
} else {
target_slot = nautilus_window_get_active_slot (NAUTILUS_WINDOW (window));
}
target_uri = NULL;
if (drag_info->target_file != NULL) {
target_uri = nautilus_file_get_uri (drag_info->target_file);
} else if (target_slot != NULL) {
location = nautilus_window_slot_get_location (target_slot);
target_uri = g_file_get_uri (location);
}
target_view = NULL;
if (target_slot != NULL) {
NautilusView *view;
view = nautilus_window_slot_get_current_view (target_slot);
if (view && NAUTILUS_IS_FILES_VIEW (view)) {
target_view = NAUTILUS_FILES_VIEW (view);
}
}
if (target_slot != NULL && target_view != NULL) {
if (drag_info->info == NAUTILUS_ICON_DND_GNOME_ICON_LIST) {
uri_list = nautilus_drag_uri_list_from_selection_list (drag_info->data.selection_list);
g_assert (uri_list != NULL);
nautilus_files_view_drop_proxy_received_uris (target_view,
uri_list,
target_uri,
gdk_drag_context_get_selected_action (context));
g_list_free_full (uri_list, g_free);
} else if (drag_info->info == NAUTILUS_ICON_DND_URI_LIST) {
nautilus_files_view_drop_proxy_received_uris (target_view,
drag_info->data.uri_list,
target_uri,
gdk_drag_context_get_selected_action (context));
}
if (drag_info->info == NAUTILUS_ICON_DND_NETSCAPE_URL) {
nautilus_files_view_handle_netscape_url_drop (target_view,
drag_info->data.netscape_url,
target_uri,
gdk_drag_context_get_selected_action (context),
0, 0);
}
gtk_drag_finish (context, TRUE, FALSE, time);
} else {
gtk_drag_finish (context, FALSE, FALSE, time);
}
g_free (target_uri);
drag_info_clear (drag_info);
}
void on_dir_tree_view_drag_data_received ( GtkWidget *widget,
GdkDragContext *drag_context,
gint x,
gint y,
GtkSelectionData *sel_data,
guint info,
guint time,
gpointer user_data ) //MOD added
{
gchar **list, **puri;
GList* files = NULL;
PtkFileTask* task;
VFSFileTaskType file_action = VFS_FILE_TASK_MOVE;
PtkFileBrowser* file_browser = ( PtkFileBrowser* ) user_data;
char* dest_dir;
char* file_path;
GtkWidget* parent_win;
/* Don't call the default handler */
g_signal_stop_emission_by_name( widget, "drag-data-received" );
if ( ( gtk_selection_data_get_length( sel_data ) >= 0 ) && ( gtk_selection_data_get_format( sel_data ) == 8 ) )
{
dest_dir = dir_tree_view_get_drop_dir( widget, x, y );
if ( dest_dir )
{
puri = list = gtk_selection_data_get_uris( sel_data );
if( file_browser->pending_drag_status_tree )
{
// We only want to update drag status, not really want to drop
dev_t dest_dev;
struct stat statbuf; // skip stat64
if( stat( dest_dir, &statbuf ) == 0 )
{
dest_dev = statbuf.st_dev;
if( 0 == file_browser->drag_source_dev_tree )
{
file_browser->drag_source_dev_tree = dest_dev;
for( ; *puri; ++puri )
{
file_path = g_filename_from_uri( *puri, NULL, NULL );
if( stat( file_path, &statbuf ) == 0 && statbuf.st_dev != dest_dev )
{
file_browser->drag_source_dev_tree = statbuf.st_dev;
g_free( file_path );
break;
}
g_free( file_path );
}
}
if( file_browser->drag_source_dev_tree != dest_dev )
// src and dest are on different devices */
gdk_drag_status( drag_context, GDK_ACTION_COPY, time);
else
gdk_drag_status( drag_context, GDK_ACTION_MOVE, time);
}
else
// stat failed
gdk_drag_status( drag_context, GDK_ACTION_COPY, time);
g_free( dest_dir );
g_strfreev( list );
file_browser->pending_drag_status_tree = 0;
return;
}
if ( puri )
{
if ( 0 == ( gdk_drag_context_get_selected_action ( drag_context ) &
( GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK ) ) )
{
gdk_drag_status( drag_context, GDK_ACTION_MOVE, time);
}
gtk_drag_finish ( drag_context, TRUE, FALSE, time );
while ( *puri )
{
if ( **puri == '/' )
file_path = g_strdup( *puri );
else
file_path = g_filename_from_uri( *puri, NULL, NULL );
if ( file_path )
files = g_list_prepend( files, file_path );
++puri;
}
g_strfreev( list );
switch ( gdk_drag_context_get_selected_action ( drag_context ) )
{
case GDK_ACTION_COPY:
file_action = VFS_FILE_TASK_COPY;
break;
case GDK_ACTION_LINK:
file_action = VFS_FILE_TASK_LINK;
break;
/* FIXME:
GDK_ACTION_DEFAULT, GDK_ACTION_PRIVATE, and GDK_ACTION_ASK are not handled */
default:
break;
}
if ( files )
{
/* Accept the drop and perform file actions */
{
parent_win = gtk_widget_get_toplevel( GTK_WIDGET( file_browser ) );
task = ptk_file_task_new( file_action,
files,
dest_dir,
GTK_WINDOW( parent_win ),
file_browser->task_view );
ptk_file_task_run( task );
}
}
g_free( dest_dir );
gtk_drag_finish ( drag_context, TRUE, FALSE, time );
return ;
}
g_free( dest_dir );
}
//else
// g_warning ("bad dest_dir in on_dir_tree_view_drag_data_received");
}
/* If we are only getting drag status, not finished. */
if( file_browser->pending_drag_status_tree )
{
gdk_drag_status ( drag_context, GDK_ACTION_COPY, time );
file_browser->pending_drag_status_tree = 0;
return;
}
gtk_drag_finish ( drag_context, FALSE, FALSE, time );
}
void DragAndDropHandler::finishDrag(GdkDragContext* context)
{
if (!m_draggingDataObjects.remove(context))
return;
GdkDevice* device = gdk_drag_context_get_device(context);
int x = 0, y = 0;
gdk_device_get_window_at_position(device, &x, &y);
int xRoot = 0, yRoot = 0;
gdk_device_get_position(device, nullptr, &xRoot, &yRoot);
m_page.dragEnded(IntPoint(x, y), IntPoint(xRoot, yRoot), gdkDragActionToDragOperation(gdk_drag_context_get_selected_action(context)));
}
static void
dia_dnd_file_drag_data_received (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
GtkSelectionData *data,
guint info,
guint time,
DDisplay *ddisp)
{
#if GTK_CHECK_VERSION(2,22,0)
switch (gdk_drag_context_get_selected_action(context))
#else
switch (context->action)
#endif
{
case GDK_ACTION_DEFAULT:
case GDK_ACTION_COPY:
case GDK_ACTION_MOVE:
case GDK_ACTION_LINK:
case GDK_ACTION_ASK:
default:
{
Diagram *diagram = NULL;
gchar *sPath = NULL, *pFrom, *pTo;
pFrom = strstr((gchar *) gtk_selection_data_get_data(data), "file:");
while (pFrom) {
GError *error = NULL;
pTo = pFrom;
while (*pTo != 0 && *pTo != 0xd && *pTo != 0xa) pTo ++;
sPath = g_strndup(pFrom, pTo - pFrom);
/* format changed with Gtk+2.0, use conversion */
pFrom = g_filename_from_uri (sPath, NULL, &error);
if (!ddisp)
diagram = diagram_load (pFrom, NULL);
else {
diagram = ddisp->diagram;
if (!diagram_load_into (diagram, pFrom, NULL)) {
/* the import filter is supposed to show the error message */
gtk_drag_finish (context, TRUE, FALSE, time);
break;
}
}
g_free (pFrom);
g_free(sPath);
if (diagram != NULL) {
diagram_update_extents(diagram);
layer_dialog_set_diagram(diagram);
if (diagram->displays == NULL) {
new_display(diagram);
}
}
pFrom = strstr(pTo, "file:");
} /* while */
gtk_drag_finish (context, TRUE, FALSE, time);
}
break;
}
return;
}
void
panel_receive_dnd_data (PanelWidget *panel,
guint info,
int pos,
GtkSelectionData *selection_data,
GdkDragContext *context,
guint time_)
{
const guchar *data;
gboolean success = FALSE;
if (panel_lockdown_get_locked_down ()) {
gtk_drag_finish (context, FALSE, FALSE, time_);
return;
}
data = gtk_selection_data_get_data (selection_data);
switch (info) {
case TARGET_URL:
success = drop_urilist (panel, pos, (char *)data);
break;
case TARGET_NETSCAPE_URL:
success = drop_url (panel, pos, (char *)data);
break;
case TARGET_COLOR:
success = set_background_color (panel->toplevel, (guint16 *) data);
break;
case TARGET_BGIMAGE:
success = set_background_image_from_uri (panel->toplevel, (char *) data);
break;
case TARGET_BACKGROUND_RESET:
if (panel_profile_background_key_is_writable (panel->toplevel, "type")) {
panel_profile_set_background_type (panel->toplevel, PANEL_BACK_NONE);
success = TRUE;
} else {
success = FALSE;
}
break;
case TARGET_DIRECTORY:
success = drop_uri (panel, pos, (char *)data,
PANEL_ICON_FOLDER);
break;
case TARGET_APPLET:
if (!gtk_selection_data_get_data (selection_data)) {
gtk_drag_finish (context, FALSE, FALSE, time_);
return;
}
if (panel_profile_id_lists_are_writable ()) {
mate_panel_applet_frame_create (panel->toplevel, pos, (char *) data);
success = TRUE;
} else {
success = FALSE;
}
break;
case TARGET_APPLET_INTERNAL:
success = drop_internal_applet (panel, pos, (char *)data,
gdk_drag_context_get_selected_action (context));
break;
case TARGET_ICON_INTERNAL:
success = drop_internal_icon (panel, pos, (char *)data,
gdk_drag_context_get_selected_action (context));
break;
default:
gtk_drag_finish (context, FALSE, FALSE, time_);
return;
}
gtk_drag_finish (context, success, FALSE, time_);
}
void DragAndDropHandler::finishDrag(GdkDragContext* context)
{
#if GTK_CHECK_VERSION(3, 16, 0)
// This can happen when attempting to call finish drag from webkitWebViewBaseDragEnd()
// for a obsolete DnD operation that got previously cancelled in startDrag().
if (m_dragContext.get() != context)
return;
if (!m_draggingSelectionData)
return;
m_dragContext = nullptr;
m_draggingSelectionData = nullptr;
#else
if (!m_draggingSelectionDataMap.remove(context))
return;
#endif
GdkDevice* device = gdk_drag_context_get_device(context);
int x = 0, y = 0;
gdk_device_get_window_at_position(device, &x, &y);
int xRoot = 0, yRoot = 0;
gdk_device_get_position(device, nullptr, &xRoot, &yRoot);
m_page.dragEnded(IntPoint(x, y), IntPoint(xRoot, yRoot), gdkDragActionToDragOperation(gdk_drag_context_get_selected_action(context)));
}
