static void
drag_data_received (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
GtkSelectionData *selection_data,
guint info,
guint32 time,
gpointer data)
{
GtkWidget *image = GTK_WIDGET (data);
GdkPixbuf *pixbuf;
if (gtk_selection_data_get_length (selection_data) < 0)
return;
pixbuf = gtk_selection_data_get_pixbuf (selection_data);
gtk_image_set_from_pixbuf (GTK_IMAGE (image), pixbuf);
}
static void
gpview_document_view_drag_data_received_cb(GtkWidget *widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *data, guint info, guint time, GPViewSymbolView *view)
{
gboolean success = FALSE;
GPViewDocumentViewPrivate *privat = GPVIEW_DOCUMENT_VIEW_GET_PRIVATE(view);
if (privat != NULL)
{
if (info != 1)
{
g_debug("gpview_document_view_drag_data_received_cb: Wrong format");
}
else if (data == NULL)
{
g_debug("gpview_document_view_drag_data_received_cb: NULL data pointer");
}
else if (gtk_selection_data_get_length(data) < 0)
{
g_debug("gpview_document_view_drag_data_received_cb: Invalid length");
}
else
{
GStrv uris = gtk_selection_data_get_uris(data);
gpview_document_ctrl_add_uris(privat->controller, uris);
g_strfreev(uris);
success = TRUE;
}
}
gtk_drag_finish(context, success, FALSE, time);
g_signal_stop_emission_by_name(
widget,
"drag-data-received"
);
}
static void
on_drag_data_received (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
GtkSelectionData *data,
guint info,
guint time,
gpointer user_data)
{
gint length = gtk_selection_data_get_length (data) ;
if (length >= 0)
{
guchar *text = gtk_selection_data_get_text(data);
if (text)
{
BijiManager *manager;
BijiNoteObj *ret;
BjbMainView *self = BJB_MAIN_VIEW (user_data);
BjbSettings *settings;
/* FIXME Text is guchar utf 8, conversion to perform */
manager = bjb_window_base_get_manager (self->priv->window);
settings = bjb_app_get_settings (g_application_get_default ());
ret = biji_manager_note_new (manager,
(gchar*) text,
bjb_settings_get_default_location (settings));
switch_to_note_view (self, ret); // maybe AFTER drag finish?
g_free (text);
}
}
/* Return false to ensure text is not removed from source
* We just want to create a note. */
gtk_drag_finish (context, FALSE, FALSE, time);
}
static gboolean
receive_xds (NautilusTreeViewDragDest *dest,
GtkWidget *widget,
guint32 time,
GdkDragContext *context,
int x, int y)
{
GFile *location;
const guchar *selection_data;
gint selection_format;
gint selection_length;
selection_data = gtk_selection_data_get_data (dest->details->drag_data);
selection_format = gtk_selection_data_get_format (dest->details->drag_data);
selection_length = gtk_selection_data_get_length (dest->details->drag_data);
if (selection_format == 8
&& selection_length == 1
&& selection_data[0] == 'F') {
gtk_drag_get_data (widget, context,
gdk_atom_intern (NAUTILUS_ICON_DND_RAW_TYPE,
FALSE),
time);
return FALSE;
} else if (selection_format == 8
&& selection_length == 1
&& selection_data[0] == 'S') {
g_assert (dest->details->direct_save_uri != NULL);
location = g_file_new_for_uri (dest->details->direct_save_uri);
nautilus_file_changes_queue_file_added (location);
nautilus_file_changes_consume_changes (TRUE);
g_object_unref (location);
}
return TRUE;
}
static void
swatch_drag_data_received (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
GtkSelectionData *selection_data,
guint info,
guint time)
{
gint length;
guint16 *vals;
GdkRGBA color;
length = gtk_selection_data_get_length (selection_data);
if (length < 0)
return;
/* We accept drops with the wrong format, since the KDE color
* chooser incorrectly drops application/x-color with format 8.
*/
if (length != 8)
{
g_warning ("Received invalid color data\n");
return;
}
vals = (guint16 *) gtk_selection_data_get_data (selection_data);
color.red = (gdouble)vals[0] / 0xffff;
color.green = (gdouble)vals[1] / 0xffff;
color.blue = (gdouble)vals[2] / 0xffff;
color.alpha = (gdouble)vals[3] / 0xffff;
gtk_color_swatch_set_rgba (GTK_COLOR_SWATCH (widget), &color);
}
static void
gstyle_color_widget_on_drag_data_received (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
GtkSelectionData *data,
guint info,
guint time)
{
GstyleColorWidget *self = GSTYLE_COLOR_WIDGET (widget);
GstyleColor * const *src_color;
g_autofree gchar *color_string = NULL;
GstyleColorKind kind;
GdkAtom target;
guint16 *data_rgba;
GdkRGBA rgba;
gint len;
g_assert (GSTYLE_IS_COLOR_WIDGET (self));
g_assert (GDK_IS_DRAG_CONTEXT (context));
target = gtk_selection_data_get_target (data);
if (target == gdk_atom_intern_static_string ("GSTYLE_COLOR_WIDGET"))
{
/* TODO: check if the color widget is coming from a PaletteWidget container */
src_color = (void*)gtk_selection_data_get_data (data);
if (*src_color != self->color)
dnd_color_fill (self, *src_color, self->color);
gtk_drag_finish (context, TRUE, FALSE, time);
return;
}
else if (target == gdk_atom_intern_static_string ("application/x-color"))
{
len = gtk_selection_data_get_length (data);
if (len < 0 )
goto failed;
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-align"
data_rgba = (guint16 *)gtk_selection_data_get_data (data);
#pragma GCC diagnostic pop
rgba.red = data_rgba[0] / 65535.;
rgba.green = data_rgba[1] / 65535.;
rgba.blue = data_rgba[2] / 65535.;
rgba.alpha = data_rgba[3] / 65535.;
gstyle_color_set_rgba (self->color, &rgba);
gtk_drag_finish (context, TRUE, FALSE, time);
return;
}
else if (gtk_targets_include_text (&target, 1))
{
color_string = (gchar *)gtk_selection_data_get_text (data);
if (!gstyle_str_empty0 (color_string))
{
if (!gstyle_color_parse_color_string (color_string, &rgba, &kind))
goto failed;
gstyle_color_set_rgba (self->color, &rgba);
gtk_drag_finish (context, TRUE, FALSE, time);
}
}
failed:
gtk_drag_finish (context, FALSE, FALSE, time);
}
void
on_extensions_view_drag_data_received(GtkWidget *widget, GdkDragContext *drag_context, gint x, gint y, GtkSelectionData *selectiondata, guint info, guint time)
{
GFile *file;
GFileInfo *file_info;
gchar *type_name = NULL;
/* Check that we got data from source */
if(selectiondata == NULL || gtk_selection_data_get_length(selectiondata) < 0)
goto fail;
/* Check that we got the format we can use */
type_name = gdk_atom_name(gtk_selection_data_get_data_type(selectiondata));
if(strcmp(type_name, "text/uri-list") != 0)
goto fail;
/* Do stuff with the data */
char **extension_files = g_uri_list_extract_uris((char *)gtk_selection_data_get_data(selectiondata));
int foo;
/* Get a list of URIs to the dropped files */
for(foo = 0; extension_files[foo] != NULL; foo++) {
GError *err = NULL;
file = g_file_new_for_uri(extension_files[foo]);
file_info = g_file_query_info(file, G_FILE_ATTRIBUTE_STANDARD_TYPE, G_FILE_QUERY_INFO_NONE, NULL, &err);
if(!file_info) {
IO_ERROR_DIALOG(NULL, file, err, _("accessing a URI"));
goto fail2;
}
/* Check whether a directory was dropped. if so, install contents */
/* NOTE: not recursive (that would be kind of silly anyway) */
if(g_file_info_get_file_type(file_info) == G_FILE_TYPE_DIRECTORY) {
GFileEnumerator *dir = g_file_enumerate_children(file, "standard::*", G_FILE_QUERY_INFO_NONE, NULL, &err);
if(!dir) {
IO_ERROR_DIALOG(NULL, file, err, _("opening a directory"));
goto fail3;
}
GFileInfo *entry_info;
while((entry_info = g_file_enumerator_next_file(dir, NULL, &err)) != NULL) {
if(g_file_info_get_file_type(entry_info) != G_FILE_TYPE_DIRECTORY) {
GFile *extension_file = g_file_get_child(file, g_file_info_get_name(entry_info));
i7_app_install_extension(i7_app_get(), extension_file);
g_object_unref(extension_file);
}
g_object_unref(entry_info);
}
g_file_enumerator_close(dir, NULL, &err);
g_object_unref(dir);
if(err) {
IO_ERROR_DIALOG(NULL, file, err, _("reading a directory"));
goto fail3;
}
} else {
/* just install it */
i7_app_install_extension(i7_app_get(), file);
}
g_object_unref(file_info);
g_object_unref(file);
}
g_strfreev(extension_files);
g_free(type_name);
gtk_drag_finish(drag_context, TRUE, FALSE, time);
return;
fail3:
g_object_unref(file_info);
fail2:
g_object_unref(file);
g_strfreev(extension_files);
fail:
g_free(type_name);
gtk_drag_finish(drag_context, FALSE, FALSE, time);
}
static void
mail_attachment_handler_x_uid_list (EAttachmentView *view,
GdkDragContext *drag_context,
gint x,
gint y,
GtkSelectionData *selection_data,
guint info,
guint time,
EAttachmentHandler *handler)
{
static GdkAtom atom = GDK_NONE;
EMailAttachmentHandlerPrivate *priv;
CamelDataWrapper *wrapper;
CamelMimeMessage *message;
CamelMultipart *multipart;
CamelMimePart *mime_part;
CamelFolder *folder = NULL;
EAttachment *attachment;
EAttachmentStore *store;
EMailSession *session;
GPtrArray *uids;
const gchar *data;
const gchar *cp, *end;
gchar *description;
gpointer parent;
gint length;
guint ii;
GError *local_error = NULL;
if (G_UNLIKELY (atom == GDK_NONE))
atom = gdk_atom_intern_static_string ("x-uid-list");
if (gtk_selection_data_get_target (selection_data) != atom)
return;
store = e_attachment_view_get_store (view);
priv = E_MAIL_ATTACHMENT_HANDLER_GET_PRIVATE (handler);
parent = gtk_widget_get_toplevel (GTK_WIDGET (view));
parent = gtk_widget_is_toplevel (parent) ? parent : NULL;
uids = g_ptr_array_new ();
data = (const gchar *) gtk_selection_data_get_data (selection_data);
length = gtk_selection_data_get_length (selection_data);
/* The UID list is delimited by NUL characters.
* Brilliant. So we can't use g_strsplit(). */
cp = data;
end = data + length;
while (cp < end) {
const gchar *start = cp;
while (cp < end && *cp != '\0')
cp++;
/* Skip the first string. */
if (start > data)
g_ptr_array_add (uids, g_strndup (start, cp - start));
cp++;
}
if (uids->len == 0)
goto exit;
session = e_mail_backend_get_session (priv->backend);
/* The first string is the folder URI. */
/* FIXME Not passing a GCancellable here. */
folder = e_mail_session_uri_to_folder_sync (
session, data, 0, NULL, &local_error);
if (folder == NULL)
goto exit;
/* Handle one message. */
if (uids->len == 1) {
const gchar *message_uid;
message_uid = g_ptr_array_index (uids, 0);
/* FIXME Not passing a GCancellable here. */
message = camel_folder_get_message_sync (
folder, message_uid, NULL, &local_error);
if (message == NULL)
goto exit;
attachment = e_attachment_new_for_message (message);
e_attachment_store_add_attachment (store, attachment);
e_attachment_load_async (
attachment, (GAsyncReadyCallback)
call_attachment_load_handle_error, parent ? g_object_ref (parent) : NULL);
g_object_unref (attachment);
g_object_unref (message);
goto exit;
}
/* Build a multipart/digest message out of the UIDs. */
multipart = camel_multipart_new ();
wrapper = CAMEL_DATA_WRAPPER (multipart);
camel_data_wrapper_set_mime_type (wrapper, "multipart/digest");
camel_multipart_set_boundary (multipart, NULL);
for (ii = 0; ii < uids->len; ii++) {
/* FIXME Not passing a GCancellable here. */
message = camel_folder_get_message_sync (
folder, uids->pdata[ii], NULL, &local_error);
if (message == NULL) {
g_object_unref (multipart);
goto exit;
}
mime_part = camel_mime_part_new ();
wrapper = CAMEL_DATA_WRAPPER (message);
camel_mime_part_set_disposition (mime_part, "inline");
camel_medium_set_content (
CAMEL_MEDIUM (mime_part), wrapper);
camel_mime_part_set_content_type (mime_part, "message/rfc822");
camel_multipart_add_part (multipart, mime_part);
g_object_unref (mime_part);
g_object_unref (message);
}
mime_part = camel_mime_part_new ();
wrapper = CAMEL_DATA_WRAPPER (multipart);
camel_medium_set_content (CAMEL_MEDIUM (mime_part), wrapper);
description = g_strdup_printf (
ngettext (
"%d attached message",
"%d attached messages",
uids->len),
uids->len);
camel_mime_part_set_description (mime_part, description);
g_free (description);
attachment = e_attachment_new ();
e_attachment_set_mime_part (attachment, mime_part);
e_attachment_store_add_attachment (store, attachment);
e_attachment_load_async (
attachment, (GAsyncReadyCallback)
call_attachment_load_handle_error, parent ? g_object_ref (parent) : NULL);
g_object_unref (attachment);
g_object_unref (mime_part);
g_object_unref (multipart);
exit:
if (local_error != NULL) {
const gchar *folder_name = data;
if (folder != NULL)
folder_name = camel_folder_get_display_name (folder);
e_alert_run_dialog_for_args (
parent, "mail-composer:attach-nomessages",
folder_name, local_error->message, NULL);
g_clear_error (&local_error);
}
if (folder != NULL)
g_object_unref (folder);
g_ptr_array_free (uids, TRUE);
g_signal_stop_emission_by_name (view, "drag-data-received");
}
static void
mail_attachment_handler_message_rfc822 (EAttachmentView *view,
GdkDragContext *drag_context,
gint x,
gint y,
GtkSelectionData *selection_data,
guint info,
guint time,
EAttachmentHandler *handler)
{
static GdkAtom atom = GDK_NONE;
EAttachmentStore *store;
EAttachment *attachment;
CamelMimeMessage *message;
CamelDataWrapper *wrapper;
CamelStream *stream;
const gchar *data;
gboolean success = FALSE;
gpointer parent;
gint length;
if (G_UNLIKELY (atom == GDK_NONE))
atom = gdk_atom_intern_static_string ("message/rfc822");
if (gtk_selection_data_get_target (selection_data) != atom)
return;
g_signal_stop_emission_by_name (view, "drag-data-received");
data = (const gchar *) gtk_selection_data_get_data (selection_data);
length = gtk_selection_data_get_length (selection_data);
stream = camel_stream_mem_new ();
camel_stream_write (stream, data, length, NULL, NULL);
g_seekable_seek (G_SEEKABLE (stream), 0, G_SEEK_SET, NULL, NULL);
message = camel_mime_message_new ();
wrapper = CAMEL_DATA_WRAPPER (message);
if (!camel_data_wrapper_construct_from_stream_sync (
wrapper, stream, NULL, NULL))
goto exit;
store = e_attachment_view_get_store (view);
parent = gtk_widget_get_toplevel (GTK_WIDGET (view));
parent = gtk_widget_is_toplevel (parent) ? parent : NULL;
attachment = e_attachment_new_for_message (message);
e_attachment_store_add_attachment (store, attachment);
e_attachment_load_async (
attachment, (GAsyncReadyCallback)
call_attachment_load_handle_error, parent ? g_object_ref (parent) : NULL);
g_object_unref (attachment);
success = TRUE;
exit:
g_object_unref (message);
g_object_unref (stream);
gtk_drag_finish (drag_context, success, FALSE, time);
}
static void
on_log_pane_drag_data_received (GtkWidget *widget,
GdkDragContext *context, gint x, gint y,
GtkSelectionData *data, guint target_type,
guint time, GitLogPane *self)
{
Git *plugin;
AnjutaEntry *path_entry;
gboolean success;
gchar **uri_list;
GFile *parent_file;
GFile *file;
gchar *path;
plugin = ANJUTA_PLUGIN_GIT (anjuta_dock_pane_get_plugin (ANJUTA_DOCK_PANE (self)));
path_entry = ANJUTA_ENTRY (gtk_builder_get_object (self->priv->builder,
"path_entry"));
success = FALSE;
if ((data != NULL) &&
(gtk_selection_data_get_length (data) >= 0))
{
if (target_type == 0)
{
uri_list = gtk_selection_data_get_uris (data);
parent_file = NULL;
parent_file = g_file_new_for_path (plugin->project_root_directory);
/* Take only the first file */
file = g_file_new_for_uri (uri_list[0]);
if (parent_file)
{
path = g_file_get_relative_path (parent_file, file);
g_object_unref (parent_file);
}
else
path = g_file_get_path (file);
if (path)
{
anjuta_entry_set_text (path_entry, path);
g_free (self->priv->path);
self->priv->path = g_strdup (path);
refresh_log (self);
g_free (path);
}
success = TRUE;
g_object_unref (file);
g_strfreev (uri_list);
}
}
/* Do not delete source data */
gtk_drag_finish (context, success, FALSE, time);
}
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 );
}
static void
drag_data_received_cb (GtkWidget *widget,
GdkDragContext *context,
int x,
int y,
GtkSelectionData *selection_data,
guint info,
guint32 time,
EphyNodeView *view)
{
GtkTreeViewDropPosition pos;
/* x and y here are valid only on drop ! */
if ((gtk_selection_data_get_length (selection_data) <= 0) ||
(gtk_selection_data_get_data (selection_data) == NULL))
{
return;
}
/* appease GtkTreeView by preventing its drag_data_receive
* from being called */
g_signal_stop_emission_by_name (view, "drag_data_received");
if (!view->priv->have_drag_data)
{
view->priv->have_drag_data = TRUE;
view->priv->drag_data =
gtk_selection_data_copy (selection_data);
}
if (view->priv->drop_occurred)
{
EphyNode *node;
char **uris;
gboolean success = FALSE;
GtkTreePath *path;
if (gtk_tree_view_get_dest_row_at_pos
(GTK_TREE_VIEW (widget), x, y, &path, &pos) == FALSE)
{
return;
}
node = get_node_from_path (view, path);
if (node == NULL) return;
uris = gtk_selection_data_get_uris (selection_data);
if (uris != NULL && ephy_node_get_is_drag_dest (node))
{
/* FIXME fill success */
g_signal_emit (G_OBJECT (view),
ephy_node_view_signals[NODE_DROPPED], 0,
node, uris);
g_strfreev (uris);
}
view->priv->drop_occurred = FALSE;
free_drag_data (view);
gtk_drag_finish (context, success, FALSE, time);
if (path)
{
gtk_tree_path_free (path);
}
}
}
void
selection_received (GtkWidget *widget, GtkSelectionData *selection_data)
{
int position;
int i;
SelType seltype;
char *str;
guchar *data;
GtkTextBuffer *buffer;
GdkAtom type;
if (gtk_selection_data_get_length (selection_data) < 0)
{
g_print("Error retrieving selection\n");
return;
}
type = gtk_selection_data_get_data_type (selection_data);
seltype = SEL_TYPE_NONE;
for (i=0; i<LAST_SEL_TYPE; i++)
{
if (seltypes[i] == type)
{
seltype = i;
break;
}
}
if (seltype == SEL_TYPE_NONE)
{
char *name = gdk_atom_name (type);
g_print("Don't know how to handle type: %s\n",
name?name:"<unknown>");
return;
}
if (selection_string != NULL)
g_string_free (selection_string, TRUE);
selection_string = g_string_new (NULL);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (selection_text));
gtk_text_buffer_set_text (buffer, "", -1);
position = 0;
while (position < gtk_selection_data_get_length (selection_data))
{
data = (guchar *) gtk_selection_data_get_data (selection_data);
switch (seltype)
{
case ATOM:
str = stringify_atom (data, &position);
break;
case COMPOUND_TEXT:
case STRING:
case TEXT:
str = stringify_text (data, &position);
break;
case BITMAP:
case DRAWABLE:
case PIXMAP:
case WINDOW:
case COLORMAP:
str = stringify_xid (data, &position);
break;
case INTEGER:
case PIXEL:
str = stringify_integer (data, &position);
break;
case SPAN:
str = stringify_span (data, &position);
break;
default:
{
char *name = gdk_atom_name (gtk_selection_data_get_data_type (selection_data));
g_print("Can't convert type %s to string\n",
name?name:"<unknown>");
position = gtk_selection_data_get_length (selection_data);
continue;
}
}
gtk_text_buffer_insert_at_cursor (buffer, str, -1);
gtk_text_buffer_insert_at_cursor (buffer, "\n", -1);
g_string_append (selection_string, str);
g_free (str);
}
}
static void
async_targets_selection_received( GtkWidget *WXUNUSED(widget),
GtkSelectionData *selection_data,
guint32 WXUNUSED(time),
wxClipboard *clipboard )
{
if ( !clipboard ) // Assert?
return;
if (!clipboard->m_sink)
return;
wxClipboardEvent *event = new wxClipboardEvent(wxEVT_CLIPBOARD_CHANGED);
event->SetEventObject( clipboard );
int selection_data_length = 0;
if (selection_data)
selection_data_length = gtk_selection_data_get_length(selection_data);
if (selection_data_length <= 0)
{
clipboard->m_sink->QueueEvent( event );
clipboard->m_sink.Release();
return;
}
// make sure we got the data in the correct form
GdkAtom type = gtk_selection_data_get_data_type(selection_data);
if ( type != GDK_SELECTION_TYPE_ATOM )
{
if ( strcmp(wxGtkString(gdk_atom_name(type)), "TARGETS") != 0 )
{
wxLogTrace( TRACE_CLIPBOARD,
wxT("got unsupported clipboard target") );
clipboard->m_sink->QueueEvent( event );
clipboard->m_sink.Release();
return;
}
}
// it's not really a format, of course, but we can reuse its GetId() method
// to format this atom as string
wxDataFormat clip(gtk_selection_data_get_selection(selection_data));
wxLogTrace( TRACE_CLIPBOARD,
wxT("Received available formats for clipboard %s"),
clip.GetId().c_str() );
// the atoms we received, holding a list of targets (= formats)
const GdkAtom* const atoms = (GdkAtom*)gtk_selection_data_get_data(selection_data);
for (size_t i = 0; i < selection_data_length / sizeof(GdkAtom); i++)
{
const wxDataFormat format(atoms[i]);
wxLogTrace(TRACE_CLIPBOARD, wxT("\t%s"), format.GetId().c_str());
event->AddFormat( format );
}
clipboard->m_sink->QueueEvent( event );
clipboard->m_sink.Release();
}
static void
xfdesktop_clipboard_manager_contents_received (GtkClipboard *clipboard,
GtkSelectionData *selection_data,
gpointer user_data)
{
XfdesktopClipboardPasteRequest *request = user_data;
XfdesktopClipboardManager *manager = XFDESKTOP_CLIPBOARD_MANAGER (request->manager);
GtkWindow *parent = GTK_WINDOW(gtk_widget_get_toplevel(request->widget));
gboolean path_copy = TRUE;
GList *path_list = NULL;
GList *dest_file_list = NULL;
GList *l = NULL;
gchar *data;
/* check whether the retrieval worked */
if (G_LIKELY (gtk_selection_data_get_length(selection_data) > 0))
{
/* be sure the selection data is zero-terminated */
data = (gchar *) gtk_selection_data_get_data(selection_data);
data[gtk_selection_data_get_length(selection_data)] = '\0';
/* check whether to copy or move */
if (g_ascii_strncasecmp (data, "copy\n", 5) == 0)
{
path_copy = TRUE;
data += 5;
}
else if (g_ascii_strncasecmp (data, "cut\n", 4) == 0)
{
path_copy = FALSE;
data += 4;
}
/* determine the path list stored with the selection */
path_list = xfdesktop_file_utils_file_list_from_string (data);
}
/* perform the action if possible */
if (G_LIKELY (path_list != NULL))
{
for (l = path_list; l; l = l->next) {
gchar *dest_basename = g_file_get_basename(l->data);
if(dest_basename && *dest_basename != '\0') {
/* If we copy a file, we need to use the new absolute filename
* as the destination. If we move, we need to use the destination
* directory. */
if(path_copy) {
GFile *dest_file = g_file_get_child(request->target_file, dest_basename);
dest_file_list = g_list_prepend(dest_file_list, dest_file);
} else {
dest_file_list = g_list_prepend(dest_file_list, request->target_file);
}
}
g_free(dest_basename);
}
dest_file_list = g_list_reverse(dest_file_list);
if (G_LIKELY (path_copy))
{
xfdesktop_file_utils_transfer_files(GDK_ACTION_COPY,
path_list,
dest_file_list,
gtk_widget_get_screen(GTK_WIDGET(parent)));
} else {
xfdesktop_file_utils_transfer_files(GDK_ACTION_MOVE,
path_list,
dest_file_list,
gtk_widget_get_screen(GTK_WIDGET(parent)));
}
/* clear the clipboard if it contained "cutted data"
* (gtk_clipboard_clear takes care of not clearing
* the selection if we don't own it)
*/
if (G_UNLIKELY (!path_copy))
gtk_clipboard_clear (manager->clipboard);
/* check the contents of the clipboard again
* if either the Xserver or our GTK+ version
* doesn't support the XFixes extension.
*/
if (!gdk_display_supports_selection_notification (gtk_clipboard_get_display (manager->clipboard)))
{
xfdesktop_clipboard_manager_owner_changed (manager->clipboard, NULL, manager);
}
}
/* free the request */
if (G_LIKELY (request->widget != NULL))
g_object_remove_weak_pointer (G_OBJECT (request->widget), (gpointer) &request->widget);
if (G_LIKELY (request->new_files_closure != NULL))
g_closure_unref (request->new_files_closure);
g_object_unref (G_OBJECT (request->manager));
g_list_free(dest_file_list);
g_list_free(path_list);
}
static void
notebook_drag_data_received_cb (GtkWidget *widget,
GdkDragContext *context,
int x,
int y,
GtkSelectionData *selection_data,
guint info,
guint time,
EphyEmbed *embed)
{
EphyWindow *window;
GtkWidget *notebook;
GdkAtom target;
const guchar *data;
target = gtk_selection_data_get_target (selection_data);
if (target == gdk_atom_intern_static_string ("GTK_NOTEBOOK_TAB"))
return;
g_signal_stop_emission_by_name (widget, "drag-data-received");
if (g_settings_get_boolean (EPHY_SETTINGS_LOCKDOWN,
EPHY_PREFS_LOCKDOWN_ARBITRARY_URL))
return;
data = gtk_selection_data_get_data (selection_data);
if (gtk_selection_data_get_length (selection_data) <= 0 || data == NULL)
return;
window = EPHY_WINDOW (gtk_widget_get_toplevel (widget));
notebook = ephy_window_get_notebook (window);
if (target == gdk_atom_intern (EPHY_DND_URL_TYPE, FALSE)) {
char **split;
/* URL_TYPE has format: url \n title */
split = g_strsplit ((const gchar *)data, "\n", 2);
if (split != NULL && split[0] != NULL && split[0][0] != '\0') {
ephy_link_open (EPHY_LINK (notebook), split[0], embed,
embed ? 0 : EPHY_LINK_NEW_TAB);
}
g_strfreev (split);
} else if (target == gdk_atom_intern (EPHY_DND_URI_LIST_TYPE, FALSE)) {
char **uris;
int i;
uris = gtk_selection_data_get_uris (selection_data);
if (uris == NULL)
return;
for (i = 0; i < INSANE_NUMBER_OF_URLS && uris[i] != NULL; i++) {
embed = ephy_link_open (EPHY_LINK (notebook), uris[i], embed,
(embed && i == 0) ? 0 : EPHY_LINK_NEW_TAB);
}
g_strfreev (uris);
} else {
char *text;
text = (char *)gtk_selection_data_get_text (selection_data);
if (text != NULL) {
char *address;
address = ephy_embed_utils_normalize_or_autosearch_address (text);
ephy_link_open (EPHY_LINK (notebook), address, embed,
embed ? 0 : EPHY_LINK_NEW_TAB);
g_free (address);
g_free (text);
}
}
}
/**
* dnd_clarity_drag_data_received:
*
* Used by the drag and drop of a jpg. When the drop is performed, this
* acts on the receipt of the data from the source widget and applies
* the jpg to the track.
*
*/
void dnd_clarity_drag_data_received(GtkWidget *widget, GdkDragContext *dc, gint x, gint y, GtkSelectionData *data, guint info, guint time, gpointer user_data) {
g_return_if_fail(CLARITY_IS_CANVAS(widget));
g_return_if_fail (dc);
g_return_if_fail (data);
g_return_if_fail (gtk_selection_data_get_data(data));
g_return_if_fail (gtk_selection_data_get_length(data) > 0);
/* mozilla bug 402394 */
#if DEBUG
printf ("data length = %d\n", gtk_selection_data_get_length(data->length));
printf ("data->data = %s\n", gtk_selection_data_get_data(data));
#endif
AlbumItem *item;
GList *tracks;
gchar *url = NULL;
Fetch_Cover *fcover;
gchar *filename = NULL;
gboolean image_status = FALSE;
gchar *image_error = NULL;
/* For use with DND_IMAGE_JPEG */
GdkPixbuf *pixbuf;
GError *error = NULL;
ClarityCanvas *ccanvas = CLARITY_CANVAS(widget);
/* Find the display cover item in the cover display */
item = clarity_canvas_get_current_album_item(ccanvas);
if (!item) {
/* looks like there are no covers yet something got dragged into it */
gtk_drag_finish(dc, FALSE, FALSE, time);
return;
}
tracks = item->tracks;
switch (info) {
case DND_IMAGE_JPEG:
#if DEBUG
printf ("Using DND_IMAGE_JPEG\n");
#endif
pixbuf = gtk_selection_data_get_pixbuf(data);
if (pixbuf != NULL) {
/* initialise the url string with a safe value as not used if already have image */
url = "local image";
/* Initialise a fetchcover object */
fcover = fetchcover_new(url, tracks);
clarity_canvas_block_change(ccanvas, TRUE);
/* find the filename with which to save the pixbuf to */
if (fetchcover_select_filename(fcover)) {
filename = g_build_filename(fcover->dir, fcover->filename, NULL);
if (!gdk_pixbuf_save(pixbuf, filename, "jpeg", &error, NULL)) {
/* Save failed for some reason */
if (error->message)
fcover->err_msg = g_strdup(error->message);
else
fcover->err_msg = "Saving image to file failed. No internal error message was returned.";
g_error_free(error);
}
else {
/* Image successfully saved */
image_status = TRUE;
}
}
/* record any errors and free the fetchcover */
if (fcover->err_msg != NULL)
image_error = g_strdup(fcover->err_msg);
free_fetchcover(fcover);
g_object_unref(pixbuf);
clarity_canvas_block_change(ccanvas, FALSE);
}
else {
/* despite the data being of type image/jpeg, the pixbuf is NULL */
image_error = "jpeg data flavour was used but the data did not contain a GdkPixbuf object";
}
break;
case DND_TEXT_PLAIN:
#if DEBUG
printf ("Defaulting to using DND_TEXT_PLAIN\n");
#endif
#ifdef HAVE_CURL
/* initialise the url string with the data from the dnd */
url = g_strdup ((gchar *) gtk_selection_data_get_data(data));
/* Initialise a fetchcover object */
fcover = fetchcover_new (url, tracks);
clarity_canvas_block_change(ccanvas, TRUE);
if (fetchcover_net_retrieve_image (fcover))
{
#if DEBUG
printf ("Successfully retrieved\n");
printf ("Url of fetch cover: %s\n", fcover->url->str);
printf ("filename of fetch cover: %s\n", fcover->filename);
#endif
filename = g_build_filename(fcover->dir, fcover->filename, NULL);
image_status = TRUE;
}
/* record any errors and free the fetchcover */
if (fcover->err_msg != NULL)
image_error = g_strdup(fcover->err_msg);
free_fetchcover (fcover);
clarity_canvas_block_change(ccanvas, FALSE);
#else
image_error = g_strdup(_("Item had to be downloaded but gtkpod was not compiled with curl."));
image_status = FALSE;
#endif
}
if (!image_status || filename == NULL) {
gtkpod_warning(_("Error occurred dropping an image onto the clarity display: %s\n"), image_error);
if (image_error)
g_free(image_error);
if (filename)
g_free(filename);
gtk_drag_finish(dc, FALSE, FALSE, time);
return;
}
clarity_util_update_coverart(tracks, filename);
if (image_error)
g_free(image_error);
g_free(filename);
gtkpod_statusbar_message(_("Successfully set new cover art for selected tracks"));
gtk_drag_finish(dc, FALSE, FALSE, time);
return;
}
// Function adapted from Gens/GS (source/gens/ui/gtk/gens/gens_window_callbacks.c)
void on_sdlsocket_drag_data_received(GtkWidget *widget, GdkDragContext *context, gint x, gint y,
GtkSelectionData *selection_data, guint target_type, guint time,
gpointer data)
{
if (selection_data == NULL || gtk_selection_data_get_length(selection_data) == 0)
{
// No selection data.
gtk_drag_finish(context, FALSE, FALSE, time);
return;
}
gboolean dnd_success = FALSE;
gchar *filename = (gchar*)gtk_selection_data_get_data(selection_data);
if (!filename)
{
// Selection data was not text.
gtk_drag_finish(context, FALSE, FALSE, time);
return;
}
if (strncmp(filename, "file:///", 8) == 0)
{
// "file:///" prefix. Remove the prefix.
filename += 7;
}
else if (strncmp(filename, "file://", 7) == 0)
{
// "file://" prefix. Remove the prefix.
filename += 6;
}
else if (strncmp(filename, "file:/", 6) == 0)
{
// "file:/" prefix. Remove the prefix.
filename += 5;
}
else if (strncmp(filename, "desktop:/", 9) == 0)
{
// "desktop:/" prefix. Remove the prefix and prepend the user's desktop directory.
char tmpname[1024] = {""};
sprintf(tmpname, "%s/Desktop/%s", getenv("HOME"), filename + 9);
filename = tmpname;
}
// Unescape the URI.
char realname[1024];
int i, j;
for (i=0, j=0; i<strlen(filename); j++)
{
if (filename[i] == '%')
{
char tmp[3];
strncpy(tmp, &filename[i+1], 2);
realname[j] = (char)strtol(tmp, NULL, 16);
i += 3;
} else realname[j] = filename[i++];
if(realname[j] == '\r' || realname[j] == '\n') realname[j] = 0;
}
realname[j] = 0;
// Check that the file actually exists. (TODO)
gboolean exists = TRUE;
if (!exists) dnd_success = FALSE;
if (exists)
{
CD_emulation = 0;
strcpy(cart_name, realname);
/* We need to flush any GTK events waiting to happen to avoid a deadlock
* when starting a game fullscreen (at least in Linux). */
while (gtk_events_pending())
gtk_main_iteration();
play_game();
}
gtk_drag_finish(context, dnd_success, FALSE, time);
}
GList *
athena_drag_build_selection_list (GtkSelectionData *data)
{
GList *result;
const guchar *p, *oldp;
int size;
result = NULL;
oldp = gtk_selection_data_get_data (data);
size = gtk_selection_data_get_length (data);
while (size > 0) {
AthenaDragSelectionItem *item;
guint len;
/* The list is in the form:
name\rx:y:width:height\r\n
The geometry information after the first \r is optional. */
/* 1: Decode name. */
p = memchr (oldp, '\r', size);
if (p == NULL) {
break;
}
item = athena_drag_selection_item_new ();
len = p - oldp;
item->uri = g_malloc (len + 1);
memcpy (item->uri, oldp, len);
item->uri[len] = 0;
p++;
if (*p == '\n' || *p == '\0') {
result = g_list_prepend (result, item);
if (p == 0) {
g_warning ("Invalid x-special/gnome-icon-list data received: "
"missing newline character.");
break;
} else {
oldp = p + 1;
continue;
}
}
size -= p - oldp;
oldp = p;
/* 2: Decode geometry information. */
item->got_icon_position = sscanf (p, "%d:%d:%d:%d%*s",
&item->icon_x, &item->icon_y,
&item->icon_width, &item->icon_height) == 4;
if (!item->got_icon_position) {
g_warning ("Invalid x-special/gnome-icon-list data received: "
"invalid icon position specification.");
}
result = g_list_prepend (result, item);
p = memchr (p, '\r', size);
if (p == NULL || p[1] != '\n') {
g_warning ("Invalid x-special/gnome-icon-list data received: "
"missing newline character.");
if (p == NULL) {
break;
}
} else {
p += 2;
}
size -= p - oldp;
oldp = p;
}
return g_list_reverse (result);
}
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);
}
static gboolean
drag_data_received_callback (GtkWidget *widget,
GdkDragContext *context,
int x,
int y,
GtkSelectionData *selection_data,
guint info,
guint32 time,
gpointer data)
{
NautilusTreeViewDragDest *dest;
const gchar *tmp;
int length;
gboolean success, finished;
dest = NAUTILUS_TREE_VIEW_DRAG_DEST (data);
if (!dest->details->have_drag_data) {
dest->details->have_drag_data = TRUE;
dest->details->drag_type = info;
dest->details->drag_data =
gtk_selection_data_copy (selection_data);
if (info == NAUTILUS_ICON_DND_GNOME_ICON_LIST) {
dest->details->drag_list =
nautilus_drag_build_selection_list (selection_data);
}
}
if (dest->details->drop_occurred) {
success = FALSE;
finished = TRUE;
switch (info) {
case NAUTILUS_ICON_DND_GNOME_ICON_LIST :
receive_dropped_icons (dest, context, x, y);
success = TRUE;
break;
case NAUTILUS_ICON_DND_NETSCAPE_URL :
receive_dropped_netscape_url (dest, context, x, y);
success = TRUE;
break;
case NAUTILUS_ICON_DND_URI_LIST :
receive_dropped_uri_list (dest, context, x, y);
success = TRUE;
break;
case NAUTILUS_ICON_DND_TEXT:
receive_dropped_text (dest, context, x, y);
success = TRUE;
break;
case NAUTILUS_ICON_DND_RAW:
length = gtk_selection_data_get_length (selection_data);
tmp = (const gchar *) gtk_selection_data_get_data (selection_data);
receive_dropped_raw (dest, tmp, length, context, x, y);
success = TRUE;
break;
case NAUTILUS_ICON_DND_XDNDDIRECTSAVE:
finished = receive_xds (dest, widget, time, context, x, y);
success = TRUE;
break;
}
if (finished) {
dest->details->drop_occurred = FALSE;
free_drag_data (dest);
gtk_drag_finish (context, success, FALSE, time);
}
}
/* appease GtkTreeView by preventing its drag_data_receive
* from being called */
g_signal_stop_emission_by_name (dest->details->tree_view,
"drag-data-received");
return TRUE;
}
void
clipboard_paste_selection (ddb_playlist_t *plt, int ctx)
{
if (!plt) {
return;
}
GdkDisplay *display = mainwin ? gtk_widget_get_display (mainwin) : gdk_display_get_default();
GtkClipboard *clip = gtk_clipboard_get_for_display (display, GDK_SELECTION_CLIPBOARD);
int type = 0;
GdkAtom *avail_targets = NULL;
int n = 0;
// get all available targets currently in the clipboard.
if (!gtk_clipboard_wait_for_targets (clip, &avail_targets, &n)) {
return;
}
clipboard_check_atoms ();
// we prefer DDB_URI_LIST, so first check all tragets for that
for (int i = 0; i < n; i++) {
if (avail_targets[i] == target_atom[DDB_URI_LIST]) {
type = DDB_URI_LIST;
break;
}
}
if (type == 0) {
// no DDB_URI_LIST, check for other supported targets
for (int i = 0; i < n; i++) {
if (avail_targets[i] == target_atom[GNOME_COPIED_FILES]) {
type = GNOME_COPIED_FILES;
break;
}
else if (avail_targets[i] == target_atom[URI_LIST]) {
type = URI_LIST;
break;
}
}
}
g_free (avail_targets);
if (type) {
GtkSelectionData *data = gtk_clipboard_wait_for_contents (clip, target_atom[type]);
const gchar *pdata = (const gchar *)gtk_selection_data_get_data (data);
gint data_len = gtk_selection_data_get_length (data);
switch (type) {
case DDB_URI_LIST:
clipboard_activate_dest_playlist (pdata, plt, ctx);
clipboard_received_ddb_uri_list (pdata);
break;
case GNOME_COPIED_FILES:
clipboard_activate_dest_playlist (NULL, plt, ctx);
clipboard_received_uri_list (pdata, data_len);
break;
case URI_LIST:
clipboard_activate_dest_playlist (NULL, plt, ctx);
clipboard_received_uri_list (pdata, data_len);
break;
default:
break;
}
gtk_selection_data_free (data);
}
}
static String selectionDataToUTF8String(GtkSelectionData* data)
{
// g_strndup guards against selection data that is not null-terminated.
GOwnPtr<gchar> markupString(g_strndup(reinterpret_cast<const char*>(gtk_selection_data_get_data(data)), gtk_selection_data_get_length(data)));
return String::fromUTF8(markupString.get());
}
static void
toolbar_drag_data_received_cb (GtkToolbar *toolbar,
GdkDragContext *context,
gint x,
gint y,
GtkSelectionData *selection_data,
guint info,
guint time,
EggEditableToolbar *etoolbar)
{
/* This function can be called for two reasons
*
* (1) drag_motion() needs an item to pass to
* gtk_toolbar_set_drop_highlight_item(). We can
* recognize this case by etoolbar->priv->pending being TRUE
* We should just create an item and return.
*
* (2) The drag has finished, and drag_drop() wants us to
* actually add a new item to the toolbar.
*/
GdkAtom type = gtk_selection_data_get_data_type (selection_data);
const char *data = (char *)gtk_selection_data_get_data (selection_data);
int ipos = -1;
char *name = NULL;
gboolean used = FALSE;
/* Find out where the drop is occuring, and the name of what is being dropped. */
if (gtk_selection_data_get_length (selection_data) >= 0)
{
ipos = gtk_toolbar_get_drop_index (toolbar, x, y);
name = egg_toolbars_model_get_name (etoolbar->priv->model, type, data, FALSE);
if (name != NULL)
{
used = ((egg_toolbars_model_get_name_flags (etoolbar->priv->model, name) & EGG_TB_MODEL_NAME_USED) != 0);
}
}
/* If we just want a highlight item, then . */
if (etoolbar->priv->dnd_pending > 0)
{
etoolbar->priv->dnd_pending--;
if (name != NULL && etoolbar->priv->dnd_toolbar == toolbar && !used)
{
etoolbar->priv->dnd_toolitem = create_item_from_action (etoolbar, name);
gtk_toolbar_set_drop_highlight_item (etoolbar->priv->dnd_toolbar,
etoolbar->priv->dnd_toolitem, ipos);
}
}
else
{
gtk_toolbar_set_drop_highlight_item (toolbar, NULL, 0);
etoolbar->priv->dnd_toolbar = NULL;
etoolbar->priv->dnd_toolitem = NULL;
/* If we don't have a name to use yet, try to create one. */
if (name == NULL && gtk_selection_data_get_length (selection_data) >= 0)
{
name = egg_toolbars_model_get_name (etoolbar->priv->model, type, data, TRUE);
}
if (name != NULL && !used)
{
gint tpos = get_toolbar_position (etoolbar, GTK_WIDGET (toolbar));
egg_toolbars_model_add_item (etoolbar->priv->model, tpos, ipos, name);
gtk_drag_finish (context, TRUE, context->action == GDK_ACTION_MOVE, time);
}
else
{
gtk_drag_finish (context, FALSE, context->action == GDK_ACTION_MOVE, time);
}
}
g_free (name);
}
static void
caja_emblem_sidebar_drag_received_cb (GtkWidget *widget,
GdkDragContext *drag_context,
gint x,
gint y,
GtkSelectionData *data,
guint info,
guint time,
CajaEmblemSidebar *emblem_sidebar)
{
GSList *emblems;
Emblem *emblem;
GdkPixbuf *pixbuf;
char *uri, *error, *uri_utf8;
char **uris;
GFile *f;
int i;
gboolean had_failure;
gint data_format, data_length;
const guchar *data_data;
had_failure = FALSE;
emblems = NULL;
data_format = gtk_selection_data_get_format (data);
data_length = gtk_selection_data_get_length (data);
data_data = gtk_selection_data_get_data (data);
switch (info)
{
case TARGET_URI_LIST:
if (data_format != 8 ||
data_length == 0)
{
g_message ("URI list had wrong format (%d) or length (%d)\n",
data_format, data_length);
return;
}
uris = g_uri_list_extract_uris (data_data);
if (uris == NULL)
{
break;
}
for (i = 0; uris[i] != NULL; ++i)
{
f = g_file_new_for_uri (uris[i]);
pixbuf = caja_emblem_load_pixbuf_for_emblem (f);
if (pixbuf == NULL)
{
/* this one apparently isn't an image, or
* at least not one that we know how to read
*/
had_failure = TRUE;
g_object_unref (f);
continue;
}
emblem = g_new (Emblem, 1);
emblem->uri = g_file_get_uri (f);
emblem->name = NULL; /* created later on by the user */
emblem->keyword = NULL;
emblem->pixbuf = pixbuf;
g_object_unref (f);
emblems = g_slist_prepend (emblems, emblem);
}
g_strfreev (uris);
if (had_failure && emblems != NULL)
{
eel_show_error_dialog (_("Some of the files could not be added as emblems."), _("The emblems do not appear to be valid images."), NULL);
}
else if (had_failure && emblems == NULL)
{
eel_show_error_dialog (_("None of the files could be added as emblems."), _("The emblems do not appear to be valid images."), NULL);
}
if (emblems != NULL)
{
show_add_emblems_dialog (emblem_sidebar, emblems);
}
break;
case TARGET_URI:
if (data_format != 8 ||
data_length == 0)
{
g_warning ("URI had wrong format (%d) or length (%d)\n",
data_format, data_length);
return;
}
uri = g_strndup (data_data, data_length);
f = g_file_new_for_uri (uri);
pixbuf = caja_emblem_load_pixbuf_for_emblem (f);
if (pixbuf != NULL)
{
emblem = g_new (Emblem, 1);
emblem->uri = uri;
emblem->name = NULL;
emblem->keyword = NULL;
emblem->pixbuf = pixbuf;
emblems = g_slist_prepend (NULL, emblem);
show_add_emblems_dialog (emblem_sidebar, emblems);
}
else
{
uri_utf8 = g_file_get_parse_name (f);
if (uri_utf8)
{
error = g_strdup_printf (_("The file '%s' does not appear to be a valid image."), uri_utf8);
g_free (uri_utf8);
}
else
{
error = g_strdup (_("The dragged file does not appear to be a valid image."));
}
eel_show_error_dialog (_("The emblem cannot be added."), error, NULL);
g_free (error);
g_free (uri_utf8);
}
g_object_unref (f);
g_free (uri);
break;
case TARGET_NETSCAPE_URL:
if (data_format != 8 ||
data_length == 0)
{
g_message ("URI had wrong format (%d) or length (%d)\n",
data_format, data_length);
return;
}
/* apparently, this is a URI/title pair? or just a pair
* of identical URIs? Regardless, this seems to work...
*/
uris = g_uri_list_extract_uris (data_data);
if (uris == NULL)
{
break;
}
uri = uris[0];
if (uri == NULL)
{
g_strfreev (uris);
break;
}
f = g_file_new_for_uri (uri);
pixbuf = caja_emblem_load_pixbuf_for_emblem (f);
g_object_unref (f);
if (pixbuf != NULL)
{
emblem = g_new (Emblem, 1);
emblem->uri = g_strdup (uri);
emblem->name = NULL;
emblem->keyword = NULL;
emblem->pixbuf = pixbuf;
emblems = g_slist_prepend (NULL, emblem);
show_add_emblems_dialog (emblem_sidebar, emblems);
}
else
{
g_warning ("Tried to load '%s', but failed.\n",
uri);
error = g_strdup_printf (_("The file '%s' does not appear to be a valid image."), uri);
eel_show_error_dialog (_("The emblem cannot be added."), error, NULL);
g_free (error);
}
g_strfreev (uris);
break;
}
}
static void
drag_data_received_callback (GtkWidget *widget,
GdkDragContext *context,
int x,
int y,
GtkSelectionData *data,
guint info,
guint32 time,
gpointer user_data)
{
NemoDragInfo *drag_info;
char *tmp;
const char *tmp_raw;
int length;
gboolean success;
drag_info = &(NEMO_ICON_CONTAINER (widget)->details->dnd_info->drag_info);
drag_info->got_drop_data_type = TRUE;
drag_info->data_type = info;
switch (info) {
case NEMO_ICON_DND_GNOME_ICON_LIST:
nemo_icon_container_dropped_icon_feedback (widget, data, x, y);
break;
case NEMO_ICON_DND_URI_LIST:
case NEMO_ICON_DND_TEXT:
case NEMO_ICON_DND_XDNDDIRECTSAVE:
case NEMO_ICON_DND_RAW:
/* Save the data so we can do the actual work on drop. */
if (drag_info->selection_data != NULL) {
gtk_selection_data_free (drag_info->selection_data);
}
drag_info->selection_data = gtk_selection_data_copy (data);
break;
/* Netscape keeps sending us the data, even though we accept the first drag */
case NEMO_ICON_DND_NETSCAPE_URL:
if (drag_info->selection_data != NULL) {
gtk_selection_data_free (drag_info->selection_data);
drag_info->selection_data = gtk_selection_data_copy (data);
}
break;
case NEMO_ICON_DND_ROOTWINDOW_DROP:
/* Do nothing, this won't even happen, since we don't want to call get_data twice */
break;
}
/* this is the second use case of this callback.
* we have to do the actual work for the drop.
*/
if (drag_info->drop_occured) {
success = FALSE;
switch (info) {
case NEMO_ICON_DND_GNOME_ICON_LIST:
nemo_icon_container_receive_dropped_icons
(NEMO_ICON_CONTAINER (widget),
context, x, y);
break;
case NEMO_ICON_DND_NETSCAPE_URL:
receive_dropped_netscape_url
(NEMO_ICON_CONTAINER (widget),
(char *) gtk_selection_data_get_data (data), context, x, y);
success = TRUE;
break;
case NEMO_ICON_DND_URI_LIST:
receive_dropped_uri_list
(NEMO_ICON_CONTAINER (widget),
(char *) gtk_selection_data_get_data (data), context, x, y);
success = TRUE;
break;
case NEMO_ICON_DND_TEXT:
tmp = gtk_selection_data_get_text (data);
receive_dropped_text
(NEMO_ICON_CONTAINER (widget),
(char *) tmp, context, x, y);
success = TRUE;
g_free (tmp);
break;
case NEMO_ICON_DND_RAW:
length = gtk_selection_data_get_length (data);
tmp_raw = gtk_selection_data_get_data (data);
receive_dropped_raw
(NEMO_ICON_CONTAINER (widget),
tmp_raw, length, drag_info->direct_save_uri,
context, x, y);
success = TRUE;
break;
case NEMO_ICON_DND_ROOTWINDOW_DROP:
/* Do nothing, everything is done by the sender */
break;
case NEMO_ICON_DND_XDNDDIRECTSAVE:
{
const guchar *selection_data;
gint selection_length;
gint selection_format;
selection_data = gtk_selection_data_get_data (drag_info->selection_data);
selection_length = gtk_selection_data_get_length (drag_info->selection_data);
selection_format = gtk_selection_data_get_format (drag_info->selection_data);
if (selection_format == 8 &&
selection_length == 1 &&
selection_data[0] == 'F') {
gtk_drag_get_data (widget, context,
gdk_atom_intern (NEMO_ICON_DND_RAW_TYPE,
FALSE),
time);
return;
} else if (selection_format == 8 &&
selection_length == 1 &&
selection_data[0] == 'F' &&
drag_info->direct_save_uri != NULL) {
GdkPoint p;
GFile *location;
location = g_file_new_for_uri (drag_info->direct_save_uri);
nemo_file_changes_queue_file_added (location);
p.x = x; p.y = y;
nemo_file_changes_queue_schedule_position_set (
location,
p,
gdk_screen_get_number (
gtk_widget_get_screen (widget)));
g_object_unref (location);
nemo_file_changes_consume_changes (TRUE);
success = TRUE;
}
break;
} /* NEMO_ICON_DND_XDNDDIRECTSAVE */
}
gtk_drag_finish (context, success, FALSE, time);
nemo_icon_container_free_drag_data (NEMO_ICON_CONTAINER (widget));
set_drop_target (NEMO_ICON_CONTAINER (widget), NULL);
/* reinitialise it for the next dnd */
drag_info->drop_occured = FALSE;
}
}
static void
on_status_view_drag_data_received (GtkWidget *widget,
GdkDragContext *context, gint x, gint y,
GtkSelectionData *data, guint target_type,
guint time, GitStatusPane *self)
{
Git *plugin;
gboolean success;
gchar **uri_list;
int i;
GFile *file;
gchar *path;
GList *paths;
GitAddCommand *add_command;
plugin = ANJUTA_PLUGIN_GIT (anjuta_dock_pane_get_plugin (ANJUTA_DOCK_PANE (self)));
success = FALSE;
path = NULL;
paths = NULL;
if ((data != NULL) &&
(gtk_selection_data_get_length (data) >= 0))
{
if (target_type == 0)
{
uri_list = gtk_selection_data_get_uris (data);
for (i = 0; uri_list[i]; i++)
{
file = g_file_new_for_uri (uri_list[i]);
path = g_file_get_path (file);
if (path && !g_file_test (path, G_FILE_TEST_IS_DIR))
{
paths = g_list_append (paths,
g_strdup (path +
strlen (plugin->project_root_directory) + 1));
}
g_free (path);
g_object_unref (file);
}
add_command = git_add_command_new_list (plugin->project_root_directory,
paths, FALSE);
g_signal_connect (G_OBJECT (add_command), "command-finished",
G_CALLBACK (g_object_unref),
NULL);
anjuta_command_start (ANJUTA_COMMAND (add_command));
success = TRUE;
anjuta_util_glist_strings_free (paths);
g_strfreev (uri_list);
}
}
/* Do not delete source data */
gtk_drag_finish (context, success, FALSE, time);
}
