void
gdk_selection_send_notify(guint32 requestor,
GdkAtom selection,
GdkAtom target, GdkAtom property, guint32 time)
{
gchar *sel_name, *tgt_name, *prop_name;
GDK_NOTE(DND,
(sel_name = gdk_atom_name(selection),
tgt_name = gdk_atom_name(target),
prop_name = gdk_atom_name(property),
g_print
("gdk_selection_send_notify: %#x %#x (%s) %#x (%s) %#x (%s)\n",
requestor, selection, sel_name, target, tgt_name, property,
prop_name), g_free(sel_name), g_free(tgt_name),
g_free(prop_name)));
/* Send ourselves a selection clear message so that gtk thinks we don't
* have the selection, and will claim it anew when needed, and
* we thus get a chance to store data in the Windows clipboard.
* Otherwise, if a gtkeditable does a copy to clipboard several times
* only the first one actually gets copied to the Windows clipboard,
* as only he first one causes a call to gdk_property_change.
*
* Hmm, there is something fishy with this. Cut and paste inside the
* same app didn't work, the gtkeditable immediately forgot the
* clipboard contents in gtk_editable_selection_clear as a result of
* this message. OTOH, when I changed gdk_selection_owner_get to
* always return NULL, it works. Sigh.
*/
SendMessage((HWND) requestor, gdk_selection_clear_msg, selection, 0);
}
static void
selection_handler( GtkWidget *WXUNUSED(widget),
GtkSelectionData *selection_data,
guint WXUNUSED(info),
guint WXUNUSED(time),
gpointer WXUNUSED(data) )
{
if (!wxTheClipboard) return;
if (!wxTheClipboard->m_data) return;
wxDataObject *data = wxTheClipboard->m_data;
wxDataFormat format( selection_data->target );
#ifdef __WXDEBUG__
wxLogTrace(TRACE_CLIPBOARD,
_T("clipboard data in format %s, GtkSelectionData is target=%s type=%s selection=%s"),
format.GetId().c_str(),
wxString::FromAscii(gdk_atom_name(selection_data->target)).c_str(),
wxString::FromAscii(gdk_atom_name(selection_data->type)).c_str(),
wxString::FromAscii(gdk_atom_name(selection_data->selection)).c_str()
);
#endif
if (!data->IsSupportedFormat( format )) return;
int size = data->GetDataSize( format );
if (size == 0) return;
void *d = malloc(size);
// Text data will be in UTF8 in Unicode mode.
data->GetDataHere( selection_data->target, d );
#ifdef __WXGTK20__
// NB: GTK+ requires special treatment of UTF8_STRING data, the text
// would show as UTF-8 data interpreted as latin1 (?) in other
// GTK+ apps if we used gtk_selection_data_set()
if (format == wxDataFormat(wxDF_UNICODETEXT))
{
gtk_selection_data_set_text(
selection_data,
(const gchar*)d,
size-1 );
}
else
#endif
{
gtk_selection_data_set(
selection_data,
GDK_SELECTION_TYPE_STRING,
8*sizeof(gchar),
(unsigned char*) d,
size-1 );
}
free(d);
}
GdkFilterReturn filter_func(GdkXEvent *xevent, GdkEvent *event, gpointer data)
{
#ifdef X_EVENT_WATCHING
static const gchar* event_names[] = {
"undefined",
"undefined",
"KeyPress",
"KeyRelease",
"ButtonPress",
"ButtonRelease",
"MotionNotify",
"EnterNotify",
"LeaveNotify",
"FocusIn",
"FocusOut",
"KeymapNotify",
"Expose",
"GraphicsExpose",
"NoExpose",
"VisibilityNotify",
"CreateNotify",
"DestroyNotify",
"UnmapNotify",
"MapNotify",
"MapRequest",
"ReparentNotify",
"ConfigureNotify",
"ConfigureRequest",
"GravityNotify",
"ResizeRequest",
"CirculateNotify",
"CirculateRequest",
"PropertyNotify",
"SelectionClear",
"SelectionRequest",
"SelectionNotify",
"ColormapNotify",
"ClientMessage",
"MappingNotify"
};
XEvent *xe = (XEvent *) xevent;
g_debug ("%d -> %s (win: %d)", xe->type, event_names[xe->type], xe->xany.window);
if (xe->type == PropertyNotify) {
GdkAtom atom = gdk_x11_xatom_to_atom(xe->xproperty.atom);
g_debug (" Atom: %s (%s)", gdk_atom_name(atom), xe->xproperty.state == PropertyNewValue ? "PropertyNewValue" : "PropertyDelete");
} else if (xe->type == ClientMessage) {
GdkAtom atom = gdk_x11_xatom_to_atom(xe->xclient.message_type);
g_debug (" Atom: %s", gdk_atom_name(atom));
}
#endif
return GDK_FILTER_CONTINUE;
}
void
gdk_wayland_selection_store (GdkWindow *window,
GdkAtom type,
GdkPropMode mode,
const guchar *data,
gint len)
{
GdkDisplay *display = gdk_window_get_display (window);
GdkWaylandSelection *selection = gdk_wayland_display_get_selection (display);
GArray *array;
if (type == gdk_atom_intern_static_string ("NULL"))
return;
array = g_array_new (TRUE, FALSE, sizeof (guchar));
g_array_append_vals (array, data, len);
if (selection->stored_selection.data)
{
if (mode != GDK_PROP_MODE_REPLACE &&
type != selection->stored_selection.type)
{
gchar *type_str, *stored_str;
type_str = gdk_atom_name (type);
stored_str = gdk_atom_name (selection->stored_selection.type);
g_warning (G_STRLOC ": Attempted to append/prepend selection data with "
"type %s into the current selection with type %s",
type_str, stored_str);
g_free (type_str);
g_free (stored_str);
return;
}
/* In these cases we also replace the stored data, so we
* apply the inverse operation into the just given data.
*/
if (mode == GDK_PROP_MODE_APPEND)
g_array_prepend_vals (array, selection->stored_selection.data,
selection->stored_selection.data_len - 1);
else if (mode == GDK_PROP_MODE_PREPEND)
g_array_append_vals (array, selection->stored_selection.data,
selection->stored_selection.data_len - 1);
g_free (selection->stored_selection.data);
}
selection->stored_selection.source = window;
selection->stored_selection.data_len = array->len;
selection->stored_selection.data = (guchar *) g_array_free (array, FALSE);
selection->stored_selection.type = type;
gdk_wayland_selection_check_write (selection);
}
static gboolean
image_drag_motion_cb (GtkWidget *widget,
GdkDragContext *context,
gint x, gint y, guint time, EImageChooser *chooser)
{
GList *p;
if (!chooser->priv->editable)
return FALSE;
for (p = gdk_drag_context_list_targets (context); p; p = p->next) {
char *possible_type;
possible_type = gdk_atom_name (GDK_POINTER_TO_ATOM (p->data));
if (!strcmp (possible_type, URI_LIST_TYPE)) {
g_free (possible_type);
gdk_drag_status (context, GDK_ACTION_COPY, time);
return TRUE;
}
g_free (possible_type);
}
return FALSE;
}
NS_IMETHODIMP
nsClipboard::HasDataMatchingFlavors(nsISupportsArray *aFlavorList,
PRInt32 aWhichClipboard, PRBool *_retval)
{
*_retval = PR_FALSE;
PRUint32 length = 0;
aFlavorList->Count(&length);
if (!length)
return NS_OK;
GtkSelectionData *selection_data =
GetTargets(GetSelectionAtom(aWhichClipboard));
if (!selection_data)
return NS_OK;
gint n_targets = 0;
GdkAtom *targets = NULL;
if (!gtk_selection_data_get_targets(selection_data,
&targets, &n_targets) ||
!n_targets)
return NS_OK;
// Walk through the provided types and try to match it to a
// provided type.
for (PRUint32 i = 0; i < length && !*_retval; i++) {
nsCOMPtr<nsISupports> genericFlavor;
aFlavorList->GetElementAt(i, getter_AddRefs(genericFlavor));
nsCOMPtr<nsISupportsCString> flavorWrapper;
flavorWrapper = do_QueryInterface(genericFlavor);
if (flavorWrapper) {
nsXPIDLCString myStr;
flavorWrapper->ToString(getter_Copies(myStr));
// We special case text/unicode here.
if (!strcmp(myStr, kUnicodeMime) &&
gtk_selection_data_targets_include_text(selection_data)) {
*_retval = PR_TRUE;
break;
}
for (PRInt32 j = 0; j < n_targets; j++) {
gchar *atom_name = gdk_atom_name(targets[j]);
if (!strcmp(atom_name, (const char *)myStr))
*_retval = PR_TRUE;
g_free(atom_name);
if (*_retval)
break;
}
}
}
gtk_selection_data_free(selection_data);
g_free(targets);
return NS_OK;
}
static gboolean
gdk_win32_display_request_selection_notification (GdkDisplay *display,
GdkAtom selection)
{
GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
gboolean ret = FALSE;
GDK_NOTE (DND,
g_print ("gdk_display_request_selection_notification (..., %s)",
gdk_atom_name (selection)));
if (selection == GDK_SELECTION_CLIPBOARD ||
selection == GDK_SELECTION_PRIMARY)
{
if (display_win32->clipboard_hwnd == NULL)
{
if (register_clipboard_notification (display))
GDK_NOTE (DND, g_print (" registered"));
else
GDK_NOTE (DND, g_print (" failed to register"));
}
ret = (display_win32->clipboard_hwnd != NULL);
}
else
{
GDK_NOTE (DND, g_print (" unsupported"));
ret = FALSE;
}
GDK_NOTE (DND, g_print (" -> %s\n", ret ? "TRUE" : "FALSE"));
return ret;
}
/**
* gtk_text_buffer_deserialize_get_can_create_tags:
* @buffer: a #GtkTextBuffer
* @format: a #GdkAtom representing a registered rich text format
*
* This functions returns the value set with
* gtk_text_buffer_deserialize_set_can_create_tags()
*
* Return value: whether deserializing this format may create tags
*
* Since: 2.10
**/
gboolean
gtk_text_buffer_deserialize_get_can_create_tags (GtkTextBuffer *buffer,
GdkAtom format)
{
GList *formats;
GList *list;
gchar *format_name;
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE);
g_return_val_if_fail (format != GDK_NONE, FALSE);
formats = g_object_get_qdata (G_OBJECT (buffer), deserialize_quark ());
for (list = formats; list; list = g_list_next (list))
{
GtkRichTextFormat *fmt = list->data;
if (fmt->atom == format)
{
return fmt->can_create_tags;
}
}
format_name = gdk_atom_name (format);
g_warning ("%s: \"%s\" is not registered as deserializable format "
"with text buffer %p",
G_STRFUNC, format_name ? format_name : "not a GdkAtom", buffer);
g_free (format_name);
return FALSE;
}
static gboolean
trash_applet_drag_motion (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
guint time)
{
GList *target;
/* refuse drops of panel applets */
for (target = gdk_drag_context_list_targets (context); target; target = target->next)
{
const char *name = gdk_atom_name (target->data);
if (!strcmp (name, "application/x-panel-icon-internal"))
break;
}
if (target)
gdk_drag_status (context, 0, time);
else
gdk_drag_status (context, GDK_ACTION_MOVE, time);
return TRUE;
}
wxString wxDataFormat::GetId() const
{
gchar* atom_name = gdk_atom_name( m_format );
wxString ret = wxString::FromAscii( atom_name );
g_free(atom_name);
return ret;
}
UINT32 remmina_rdp_cliprdr_get_format_from_gdkatom(GdkAtom atom)
{
TRACE_CALL(__func__);
UINT32 rc;
gchar* name = gdk_atom_name(atom);
rc = 0;
if (g_strcmp0("UTF8_STRING", name) == 0 || g_strcmp0("text/plain;charset=utf-8", name) == 0) {
rc = CF_UNICODETEXT;
}
if (g_strcmp0("TEXT", name) == 0 || g_strcmp0("text/plain", name) == 0) {
rc = CF_TEXT;
}
if (g_strcmp0("text/html", name) == 0) {
rc = CB_FORMAT_HTML;
}
if (g_strcmp0("image/png", name) == 0) {
rc = CB_FORMAT_PNG;
}
if (g_strcmp0("image/jpeg", name) == 0) {
rc = CB_FORMAT_JPEG;
}
if (g_strcmp0("image/bmp", name) == 0) {
rc = CF_DIB;
}
g_free(name);
return rc;
}
GdkWindow *gdk_selection_owner_get(GdkAtom selection)
{
GdkWindow *window;
gchar *sel_name;
#if 0
/* XXX Hmm, gtk selections seem to work best with this. This causes
* gtk to always get the clipboard contents from Windows, and not
* from the editable's own stashed-away copy.
*/
return NULL;
#else
if (selection != gdk_clipboard_atom)
window = NULL;
else {
window = gdk_window_lookup(GetClipboardOwner());
if (window == NULL)
window = (GdkWindow *)GetClipboardOwner();
}
#endif
GDK_NOTE(DND,
(sel_name = gdk_atom_name(selection),
g_print("gdk_selection_owner_get: %#x (%s) = %#x\n",
selection, sel_name,
(window ? GDK_DRAWABLE_XID(window) : 0)),
g_free(sel_name)));
return window;
}
guint
gtksharp_get_gdk_net_active_window (void)
{
GdkAtom actual_property_type;
int actual_format;
int actual_length;
long *data = NULL;
guint windowID = 0;
if (!gdk_property_get (
gdk_screen_get_root_window (gdk_screen_get_default ()),
gdk_atom_intern ("_NET_ACTIVE_WINDOW", FALSE),
gdk_atom_intern ("WINDOW", FALSE),
0,
G_MAXLONG,
FALSE,
&actual_property_type,
&actual_format,
&actual_length,
(guchar **) &data)) {
gchar *actualPropertyTypeName;
g_critical ("Unable to get _NET_ACTIVE_WINDOW");
actualPropertyTypeName = gdk_atom_name (actual_property_type);
if (actualPropertyTypeName) {
g_message ("actual_property_type: %s", actualPropertyTypeName);
g_free(actualPropertyTypeName);
}
return -1;
}
windowID = (gint) data [0];
g_free (data);
return windowID;
}
gint
gtksharp_get_gdk_net_current_desktop (void)
{
GdkAtom actual_property_type;
int actual_format;
int actual_length;
long *data = NULL;
gint current_desktop;
if (!gdk_property_get (
gdk_screen_get_root_window (gdk_screen_get_default ()),
gdk_atom_intern ("_NET_CURRENT_DESKTOP", FALSE),
gdk_atom_intern ("CARDINAL", FALSE),
0,
G_MAXLONG,
FALSE,
&actual_property_type,
&actual_format,
&actual_length,
(guchar **) &data)) {
gchar *actual_property_type_name;
g_critical ("Unable to get _NET_CURRENT_DESKTOP");
actual_property_type_name = gdk_atom_name (actual_property_type);
if (actual_property_type_name) {
g_message ("actual_property_type: %s", actual_property_type_name);
g_free (actual_property_type_name);
}
return -1;
}
current_desktop = (gint) data[0];
g_free (data);
return current_desktop;
}
/**
* gdk_x11_atom_to_xatom_for_display:
* @display: (type GdkX11Display): A #GdkDisplay
* @atom: A #GdkAtom, or %GDK_NONE
*
* Converts from a #GdkAtom to the X atom for a #GdkDisplay
* with the same string value. The special value %GDK_NONE
* is converted to %None.
*
* Return value: the X atom corresponding to @atom, or %None
*
* Since: 2.2
**/
Atom
gdk_x11_atom_to_xatom_for_display (GdkDisplay *display,
GdkAtom atom)
{
Atom xatom = None;
g_return_val_if_fail (GDK_IS_DISPLAY (display), None);
if (atom == GDK_NONE)
return None;
if (gdk_display_is_closed (display))
return None;
xatom = lookup_cached_xatom (display, atom);
if (!xatom)
{
char *name = gdk_atom_name (atom);
xatom = XInternAtom (GDK_DISPLAY_XDISPLAY (display), name, FALSE);
insert_atom_pair (display, atom, xatom);
g_free (name);
}
return xatom;
}
static gboolean
avatar_chooser_drag_drop_cb (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
guint time,
EmpathyAvatarChooser *chooser)
{
EmpathyAvatarChooserPriv *priv;
GList *p;
priv = GET_PRIV (chooser);
if (context->targets == NULL) {
return FALSE;
}
for (p = context->targets; p != NULL; p = p->next) {
char *possible_type;
possible_type = gdk_atom_name (GDK_POINTER_TO_ATOM (p->data));
if (!strcmp (possible_type, URI_LIST_TYPE)) {
g_free (possible_type);
gtk_drag_get_data (widget, context,
GDK_POINTER_TO_ATOM (p->data),
time);
return TRUE;
}
g_free (possible_type);
}
return FALSE;
}
gboolean
contact_list_editor_drag_motion_cb (GtkWidget *widget,
GdkDragContext *context,
gint x, gint y,
guint time)
{
EContactListEditor *editor;
GList *iter;
editor = contact_list_editor_extract (widget);
for (iter = context->targets; iter != NULL; iter = iter->next) {
GdkAtom target = GDK_POINTER_TO_ATOM (iter->data);
gchar *possible_type;
gboolean match;
possible_type = gdk_atom_name (target);
match = (strcmp (possible_type, VCARD_TYPE) == 0);
g_free (possible_type);
if (match) {
gdk_drag_status (context, GDK_ACTION_LINK, time);
return TRUE;
}
}
return FALSE;
}
gboolean
on_extensions_view_drag_drop(GtkWidget *widget, GdkDragContext *drag_context, gint x, gint y, guint time)
{
/* Iterate through the list of target types provided by the source */
GdkAtom target_type = NULL;
GList *iter;
for(iter = gdk_drag_context_list_targets(drag_context); iter != NULL; iter = g_list_next(iter)) {
gchar *type_name = gdk_atom_name(GDK_POINTER_TO_ATOM(iter->data));
/* Select 'text/uri-list' from the list of available targets */
if(!strcmp(type_name, "text/uri-list")) {
g_free(type_name);
target_type = GDK_POINTER_TO_ATOM(iter->data);
break;
}
g_free(type_name);
}
/* If URI list not supported, then cancel */
if(!target_type)
return FALSE;
/* Request the data from the source. */
gtk_drag_get_data(
widget, /* this widget, which will get 'drag-data-received' */
drag_context, /* represents the current state of the DnD */
target_type, /* the target type we want */
time); /* time stamp */
return TRUE;
}
static void set_data(GdkAtom target, GtkSelectionData *selection_data, jobject data)
{
gchar *name = gdk_atom_name(target);
jstring typeString;
jobject result;
if (gtk_targets_include_text(&target, 1)) {
typeString = mainEnv->NewStringUTF("text/plain");
result = mainEnv->CallObjectMethod(data, jMapGet, typeString, NULL);
if (!EXCEPTION_OCCURED(mainEnv) && result != NULL) {
set_text_data(selection_data, (jstring)result);
}
} else if (gtk_targets_include_image(&target, 1, TRUE)) {
typeString = mainEnv->NewStringUTF("application/x-java-rawimage");
result = mainEnv->CallObjectMethod(data, jMapGet, typeString, NULL);
if (!EXCEPTION_OCCURED(mainEnv) && result != NULL) {
set_image_data(selection_data, result);
}
} else if (target == MIME_TEXT_URI_LIST_TARGET) {
set_uri_data(selection_data, data);
} else {
typeString = mainEnv->NewStringUTF(name);
result = mainEnv->CallObjectMethod(data, jMapGet, typeString, NULL);
if (!EXCEPTION_OCCURED(mainEnv) && result != NULL) {
if (mainEnv->IsInstanceOf(result, jStringCls)) {
set_jstring_data(selection_data, target, (jstring)result);
} else if (mainEnv->IsInstanceOf(result, jByteBufferCls)) {
set_bytebuffer_data(selection_data, target, result);
}
}
}
g_free(name);
}
static gboolean
gdk_win32_display_request_selection_notification (GdkDisplay *display,
GdkAtom selection)
{
static HWND hwndViewer = NULL;
gboolean ret = FALSE;
GDK_NOTE (DND,
g_print ("gdk_display_request_selection_notification (..., %s)",
gdk_atom_name (selection)));
if (selection == GDK_SELECTION_CLIPBOARD ||
selection == GDK_SELECTION_PRIMARY)
{
if (!hwndViewer)
{
hwndViewer = _gdk_win32_register_clipboard_notification ();
GDK_NOTE (DND, g_print (" registered"));
}
ret = (hwndViewer != NULL);
}
else
{
GDK_NOTE (DND, g_print (" unsupported"));
ret = FALSE;
}
GDK_NOTE (DND, g_print (" -> %s\n", ret ? "TRUE" : "FALSE"));
return ret;
}
static gboolean
image_drag_drop_cb (GtkWidget *widget,
GdkDragContext *context,
gint x, gint y, guint time, EImageChooser *chooser)
{
GList *p;
if (!chooser->priv->editable)
return FALSE;
if (context->targets == NULL) {
return FALSE;
}
for (p = context->targets; p != NULL; p = p->next) {
char *possible_type;
possible_type = gdk_atom_name (GDK_POINTER_TO_ATOM (p->data));
if (!strcmp (possible_type, URI_LIST_TYPE)) {
g_free (possible_type);
gtk_drag_get_data (widget, context,
GDK_POINTER_TO_ATOM (p->data),
time);
return TRUE;
}
g_free (possible_type);
}
return FALSE;
}
UINT32 remmina_rdp_cliprdr_get_format_from_gdkatom(GdkAtom atom)
{
gchar* name = gdk_atom_name(atom);
if (g_strcmp0("UTF8_STRING", name) == 0 || g_strcmp0("text/plain;charset=utf-8", name) == 0)
{
return CB_FORMAT_UNICODETEXT;
}
if (g_strcmp0("TEXT", name) == 0 || g_strcmp0("text/plain", name) == 0)
{
return CB_FORMAT_TEXT;
}
if (g_strcmp0("text/html", name) == 0)
{
return CB_FORMAT_HTML;
}
if (g_strcmp0("image/png", name) == 0)
{
return CB_FORMAT_PNG;
}
if (g_strcmp0("image/jpeg", name) == 0)
{
return CB_FORMAT_JPEG;
}
if (g_strcmp0("image/bmp", name) == 0)
{
return CB_FORMAT_DIB;
}
return CB_FORMAT_RAW;
}
void
gdk_wayland_selection_add_targets (GdkWindow *window,
GdkAtom selection,
guint ntargets,
GdkAtom *targets)
{
struct wl_data_source *data_source;
guint i;
g_return_if_fail (GDK_IS_WINDOW (window));
data_source = gdk_wayland_selection_get_data_source (window, selection);
if (!data_source)
return;
for (i = 0; i < ntargets; i++)
wl_data_source_offer (data_source, gdk_atom_name (targets[i]));
if (selection == atoms[ATOM_CLIPBOARD])
{
GdkDeviceManager *device_manager;
GdkDisplay *display;
GdkDevice *device;
display = gdk_window_get_display (window);
device_manager = gdk_display_get_device_manager (display);
device = gdk_device_manager_get_client_pointer (device_manager);
gdk_wayland_device_set_selection (device, data_source);
}
}
static gboolean dnd_source_set_raw(GdkWindow *requestor, GdkAtom property, GdkAtom target)
{
gchar *target_name = gdk_atom_name(target);
jobject data = dnd_source_get_data(target_name);
gboolean is_data_set = FALSE;
if (data) {
if (mainEnv->IsInstanceOf(data, jStringCls)) {
const char *cstring = mainEnv->GetStringUTFChars((jstring)data, NULL);
gdk_property_change(requestor, property, GDK_SELECTION_TYPE_STRING,
8, GDK_PROP_MODE_REPLACE, (guchar *) cstring, strlen(cstring));
mainEnv->ReleaseStringUTFChars((jstring)data, cstring);
is_data_set = TRUE;
} else if (mainEnv->IsInstanceOf(data, jByteBufferCls)) {
jbyteArray byteArray = (jbyteArray)mainEnv->CallObjectMethod(data, jByteBufferArray);
if (!EXCEPTION_OCCURED(mainEnv)) {
jbyte* raw = mainEnv->GetByteArrayElements(byteArray, NULL);
jsize nraw = mainEnv->GetArrayLength(byteArray);
gdk_property_change(requestor, property, target,
8, GDK_PROP_MODE_REPLACE, (guchar *) raw, nraw);
mainEnv->ReleaseByteArrayElements(byteArray, raw, JNI_ABORT);
is_data_set = TRUE;
}
}
}
g_free(target_name);
return is_data_set;
}
void Ctrl::DndTargets(GdkDragContext *context)
{
static Index<String> text_targets;
static Index<String> image_targets;
ONCELOCK {
GtkTargetList *target_list = gtk_target_list_new (NULL, 0);
gtk_target_list_add_text_targets (target_list, 0);
ToIndex(target_list, text_targets);
GtkTargetList *target_list2 = gtk_target_list_new (NULL, 0);
gtk_target_list_add_image_targets (target_list2, 0, TRUE);
ToIndex(target_list2, image_targets);
}
dnd_targets.Clear();
dnd_text_target.Clear();
for(GList *list = gdk_drag_context_list_targets(context); list; list = g_list_next (list)) {
String g = gdk_atom_name((GdkAtom)list->data);
if(text_targets.Find(g) >= 0) {
dnd_targets.Add("text");
if(dnd_text_target.IsEmpty())
dnd_text_target = g;
}
else if(image_targets.Find(g) >= 0) {
dnd_targets.Add("image");
if(dnd_image_target.IsEmpty())
dnd_image_target = g;
}
else
dnd_targets.Add(g);
}
}
gboolean
target_drag_motion (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
guint time)
{
GtkWidget *source_widget;
GList *tmp_list;
if (!have_drag)
{
have_drag = TRUE;
gtk_image_set_from_pixbuf (GTK_IMAGE (widget), trashcan_open);
}
source_widget = gtk_drag_get_source_widget (context);
g_print ("motion, source %s\n", source_widget ?
G_OBJECT_TYPE_NAME (source_widget) :
"NULL");
tmp_list = gdk_drag_context_list_targets (context);
while (tmp_list)
{
char *name = gdk_atom_name (GDK_POINTER_TO_ATOM (tmp_list->data));
g_print ("%s\n", name);
g_free (name);
tmp_list = tmp_list->next;
}
gdk_drag_status (context, gdk_drag_context_get_suggested_action (context), time);
return TRUE;
}
Php::Value GtkClipboard_::get_selection()
{
GdkAtom atom = gtk_clipboard_get_selection (GTK_CLIPBOARD(instance));
std::string ret = gdk_atom_name(atom);
return ret;
}
gchar *
stringify_atom (guchar *data, gint *position)
{
gchar *str = gdk_atom_name (*(GdkAtom *)(data+*position));
*position += sizeof(GdkAtom);
return str;
}
static PyObject *
pygdk_atom_str(PyGdkAtom_Object *self)
{
if (!self->name) self->name = gdk_atom_name(self->atom);
if (self->name)
return PyString_FromString(self->name);
return pygdk_atom_repr(self);
}
static void dnd_drag_data_recieved_handler(GtkWidget *widget,
GdkDragContext *context, gint x, gint y,
GtkSelectionData *selection_data, guint info, guint time)
{
static gboolean flag_called_once = FALSE;
gchar **files;
gchar *filename;
gchar *comline;
gint i = 0, j = 0;
gchar *filename_sh;
gchar **strs;
#ifdef ENABLE_CSDI
j = 1;
#endif
DV(g_print("DND start!\n"));
if (g_ascii_strcasecmp(gdk_atom_name(context->targets->data),
"GTK_TEXT_BUFFER_CONTENTS") != 0) {
if (flag_called_once) {
flag_called_once = FALSE;
g_signal_stop_emission_by_name(widget, "drag_data_received");
DV(g_print("second drop signal killed.\n"));
return;
} else
flag_called_once = TRUE;
}
DV({
g_print("info = %d\n", info);
g_print("time = %d\n", time);
g_print("context->protocol = %d\n", context->protocol);
g_print("context->is_source = %d\n", context->is_source);
g_print("context->targets = %d\n", g_list_length(context->targets));
g_print("context->target = %s\n", gdk_atom_name(context->targets->data));
/* g_print("context->target = %s\n", gdk_atom_name(context->targets->next->data));
g_print("context->target = %s\n", gdk_atom_name(context->targets->next->next->data));
g_print("context->actions = %d\n", context->actions);
g_print("context->suggested_action = %d\n", context->suggested_action);
g_print("context->action = %d\n", context->action);
g_print("selection_data->selection = %s\n", gdk_atom_name(selection_data->selection));
g_print("selection_data->target = %s\n", gdk_atom_name(selection_data->target));
*/ g_print("selection_data->type = %s\n", gdk_atom_name(selection_data->type));
g_print("selection_data->format = %d\n", selection_data->format);
g_print("selection_data->length = %d\n", selection_data->length);
g_print("%s\n", selection_data->data);
});