static gboolean
gstyle_color_widget_on_drag_drop (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
guint time)
{
GstyleColorWidget *self = (GstyleColorWidget *)widget;
GdkAtom target;
g_assert (GSTYLE_IS_COLOR_WIDGET (self));
g_assert (GDK_IS_DRAG_CONTEXT (context));
target = gtk_drag_dest_find_target (widget, context, NULL);
if ((target == gdk_atom_intern_static_string ("GSTYLE_COLOR_WIDGET") ||
target == gdk_atom_intern_static_string ("application/x-color") ||
gtk_targets_include_text (&target, 1)) &&
is_in_drop_zone (self, x, y))
{
gtk_drag_get_data (widget, context, target, time);
return TRUE;
}
return FALSE;
}
GdkWaylandSelection *
gdk_wayland_selection_new (void)
{
GdkWaylandSelection *selection;
gint i;
/* init atoms */
atoms[ATOM_PRIMARY] = gdk_atom_intern_static_string ("PRIMARY");
atoms[ATOM_CLIPBOARD] = gdk_atom_intern_static_string ("CLIPBOARD");
atoms[ATOM_DND] = gdk_atom_intern_static_string ("GdkWaylandSelection");
selection = g_new0 (GdkWaylandSelection, 1);
for (i = 0; i < G_N_ELEMENTS (selection->selections); i++)
{
selection->selections[i].buffers =
g_hash_table_new_full (NULL, NULL, NULL,
(GDestroyNotify) selection_buffer_cancel_and_unref);
}
selection->offers =
g_hash_table_new_full (NULL, NULL, NULL,
(GDestroyNotify) data_offer_data_free);
selection->stored_selection.fd = -1;
selection->source_targets = g_array_new (FALSE, FALSE, sizeof (GdkAtom));
return selection;
}
static GdkAtom
gimp_clipboard_wait_for_svg (Gimp *gimp)
{
GdkAtom *targets;
gint n_targets;
GdkAtom result = GDK_NONE;
targets = gimp_clipboard_wait_for_targets (gimp, &n_targets);
if (targets)
{
GdkAtom svg_atom = gdk_atom_intern_static_string ("image/svg");
GdkAtom svg_xml_atom = gdk_atom_intern_static_string ("image/svg+xml");
gint i;
for (i = 0; i < n_targets; i++)
{
if (targets[i] == svg_atom)
{
result = svg_atom;
break;
}
else if (targets[i] == svg_xml_atom)
{
result = svg_xml_atom;
break;
}
}
g_free (targets);
}
return result;
}
GdkWaylandSelection *
gdk_wayland_selection_new (void)
{
GdkWaylandSelection *selection;
/* init atoms */
atoms[ATOM_CLIPBOARD] = gdk_atom_intern_static_string ("CLIPBOARD");
atoms[ATOM_DND] = gdk_atom_intern_static_string ("GdkWaylandSelection");
selection = g_new0 (GdkWaylandSelection, 1);
selection->selection_buffers = g_hash_table_new_full (NULL, NULL, NULL,
(GDestroyNotify) selection_buffer_cancel_and_unref);
return selection;
}
static void init_atoms()
{
static int initialized = 0;
if (!initialized) {
MIME_TEXT_PLAIN_TARGET = gdk_atom_intern_static_string("text/plain");
MIME_TEXT_URI_LIST_TARGET = gdk_atom_intern_static_string("text/uri-list");
MIME_JAVA_IMAGE = gdk_atom_intern_static_string("application/x-java-rawimage");
MIME_FILES_TARGET = gdk_atom_intern_static_string("application/x-java-file-list");
initialized = 1;
}
}
/**
* gtk_tree_get_row_drag_data:
* @selection_data: a #GtkSelectionData
* @tree_model: (nullable) (optional) (transfer none) (out): a #GtkTreeModel
* @path: (nullable) (optional) (out): row in @tree_model
*
* Obtains a @tree_model and @path from selection data of target type
* %GTK_TREE_MODEL_ROW. Normally called from a drag_data_received handler.
* This function can only be used if @selection_data originates from the same
* process that’s calling this function, because a pointer to the tree model
* is being passed around. If you aren’t in the same process, then you'll
* get memory corruption. In the #GtkTreeDragDest drag_data_received handler,
* you can assume that selection data of type %GTK_TREE_MODEL_ROW is
* in from the current process. The returned path must be freed with
* gtk_tree_path_free().
*
* Returns: %TRUE if @selection_data had target type %GTK_TREE_MODEL_ROW and
* is otherwise valid
**/
gboolean
gtk_tree_get_row_drag_data (GtkSelectionData *selection_data,
GtkTreeModel **tree_model,
GtkTreePath **path)
{
TreeRowData *trd;
g_return_val_if_fail (selection_data != NULL, FALSE);
if (tree_model)
*tree_model = NULL;
if (path)
*path = NULL;
if (gtk_selection_data_get_target (selection_data) != gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
return FALSE;
if (gtk_selection_data_get_length (selection_data) < 0)
return FALSE;
trd = (void*) gtk_selection_data_get_data (selection_data);
if (tree_model)
*tree_model = trd->model;
if (path)
*path = gtk_tree_path_new_from_string (trd->path);
return TRUE;
}
static guint32
get_netwm_cardinal_property (GdkScreen *screen,
const gchar *name)
{
GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
GdkAtom atom;
guint32 prop = 0;
Atom type;
gint format;
gulong nitems;
gulong bytes_after;
guchar *data;
atom = gdk_atom_intern_static_string (name);
if (!gdk_x11_screen_supports_net_wm_hint (screen, atom))
return 0;
XGetWindowProperty (x11_screen->xdisplay,
x11_screen->xroot_window,
gdk_x11_get_xatom_by_name_for_display (GDK_SCREEN_DISPLAY (screen), name),
0, G_MAXLONG,
False, XA_CARDINAL, &type, &format, &nitems,
&bytes_after, &data);
if (type == XA_CARDINAL)
{
prop = *(gulong *)data;
XFree (data);
}
return prop;
}
static gboolean
is_this_drop_ok (GtkWidget *widget,
GdkDragContext *context)
{
static GdkAtom text_uri_list = GDK_NONE;
GList *l;
GtkWidget *source;
source = gtk_drag_get_source_widget (context);
if (source == widget)
return FALSE;
if (!(gdk_drag_context_get_actions (context) & GDK_ACTION_COPY))
return FALSE;
if (!text_uri_list)
text_uri_list = gdk_atom_intern_static_string ("text/uri-list");
for (l = gdk_drag_context_list_targets (context); l; l = l->next) {
if (GDK_POINTER_TO_ATOM (l->data) == text_uri_list)
break;
}
return l ? TRUE : FALSE;
}
static void setXProperty(GtkWidget* window, const gchar *propertyName, const gchar *propertyValue)
{
GdkAtom property = gdk_atom_intern_static_string(propertyName);
gdk_property_change(gtk_widget_get_window(window), property,
(GdkAtom)XA_STRING, 8, GDK_PROP_MODE_REPLACE,
(const guchar *)propertyValue, strlen(propertyValue));
}
PassRefPtr<DocumentFragment> Pasteboard::documentFragment(Frame* frame, PassRefPtr<Range> context,
bool allowPlainText, bool& chosePlainText)
{
GdkAtom textHtml = gdk_atom_intern_static_string("text/html");
GtkClipboard* clipboard = m_helper->getCurrentTarget(frame);
chosePlainText = false;
if (GtkSelectionData* data = gtk_clipboard_wait_for_contents(clipboard, textHtml)) {
ASSERT(data->data);
String html = String::fromUTF8(reinterpret_cast<gchar*>(data->data), data->length * data->format / 8);
gtk_selection_data_free(data);
if (!html.isEmpty()) {
RefPtr<DocumentFragment> fragment = createFragmentFromMarkup(frame->document(), html, "");
if (fragment)
return fragment.release();
}
}
if (!allowPlainText)
return 0;
if (gchar* utf8 = gtk_clipboard_wait_for_text(clipboard)) {
String text = String::fromUTF8(utf8);
g_free(utf8);
chosePlainText = true;
RefPtr<DocumentFragment> fragment = createFragmentFromText(context.get(), text);
if (fragment)
return fragment.release();
}
return 0;
}
static gboolean
hd_home_plugin_item_property_notify_event (GtkWidget *widget,
GdkEventProperty *event)
{
HDHomePluginItemPrivate *priv = HD_HOME_PLUGIN_ITEM (widget)->priv;
static GdkAtom is_on_current_desktop_atom = GDK_NONE;
if (G_UNLIKELY (is_on_current_desktop_atom == GDK_NONE))
is_on_current_desktop_atom = gdk_atom_intern_static_string ("_HILDON_APPLET_ON_CURRENT_DESKTOP");
if (event->atom == is_on_current_desktop_atom)
{
gboolean old_value = priv->is_on_current_desktop;
if (event->state == GDK_PROPERTY_NEW_VALUE)
priv->is_on_current_desktop = TRUE;
else if (event->state == GDK_PROPERTY_DELETE)
priv->is_on_current_desktop = FALSE;
if (old_value != priv->is_on_current_desktop)
g_object_notify (G_OBJECT (widget), "is-on-current-desktop");
return TRUE;
}
if (GTK_WIDGET_CLASS (hd_home_plugin_item_parent_class)->property_notify_event)
return GTK_WIDGET_CLASS (hd_home_plugin_item_parent_class)->property_notify_event (widget, event);
return FALSE;
}
bool MCX11GetWindowWorkarea(GdkDisplay *p_display, Window p_window, MCRectangle &r_workarea)
{
x11::Atom t_ret;
int t_format, t_status;
unsigned long t_count, t_after;
unsigned long *t_workarea = nil;
x11::Atom XA_CARDINAL = x11::gdk_x11_atom_to_xatom_for_display(p_display, gdk_atom_intern_static_string("CARDINAL"));
t_status = x11::XGetWindowProperty(x11::gdk_x11_display_get_xdisplay(p_display),
x11::gdk_x11_drawable_get_xid(p_window),
x11::gdk_x11_atom_to_xatom_for_display(p_display, MCworkareaatom),
0, 4, False, XA_CARDINAL, &t_ret, &t_format, &t_count, &t_after,
(unsigned char**)&t_workarea);
bool t_success;
t_success = t_status == Success && t_ret == XA_CARDINAL && t_format == 32 && t_count == 4;
if (t_success)
r_workarea = MCRectangleMake(t_workarea[0], t_workarea[1], t_workarea[2], t_workarea[3]);
if (t_workarea != nil)
x11::XFree(t_workarea);
return t_success;
}
static gboolean clipboard_request(SpiceMainChannel *main, guint selection,
guint type, gpointer user_data)
{
g_return_val_if_fail(SPICE_IS_GTK_SESSION(user_data), FALSE);
SpiceGtkSession *self = user_data;
SpiceGtkSessionPrivate *s = self->priv;
GdkAtom atom;
GtkClipboard* cb;
int m;
if (read_only(self))
return FALSE;
cb = get_clipboard_from_selection(s, selection);
g_return_val_if_fail(cb != NULL, FALSE);
for (m = 0; m < SPICE_N_ELEMENTS(atom2agent); m++) {
if (atom2agent[m].vdagent == type)
break;
}
g_return_val_if_fail(m < SPICE_N_ELEMENTS(atom2agent), FALSE);
atom = gdk_atom_intern_static_string(atom2agent[m].xatom);
gtk_clipboard_request_contents(cb, atom, clipboard_received_cb,
weak_ref(G_OBJECT(self)));
return TRUE;
}
void DragClient::startDrag(DragImageRef image, const IntPoint& dragImageOrigin, const IntPoint& eventPos, Clipboard*, Frame* frame, bool linkDrag)
{
Element* targetElement = frame->document()->elementFromPoint(m_startPos.x(), m_startPos.y());
bool imageDrag = false;
if (targetElement)
imageDrag = targetElement->renderer()->isImage();
GdkAtom textHtml = gdk_atom_intern_static_string("text/html");
GdkAtom netscapeUrl = gdk_atom_intern_static_string("_NETSCAPE_URL");
GtkTargetList* targetList = gtk_target_list_new(NULL, 0);
gtk_target_list_add(targetList, textHtml, 0, WEBKIT_WEB_VIEW_TARGET_INFO_HTML);
gtk_target_list_add_text_targets(targetList, WEBKIT_WEB_VIEW_TARGET_INFO_TEXT);
if (linkDrag || imageDrag) {
gtk_target_list_add(targetList, netscapeUrl, 0, WEBKIT_WEB_VIEW_TARGET_INFO_NETSCAPE_URL);
gtk_target_list_add_uri_targets(targetList, WEBKIT_WEB_VIEW_TARGET_INFO_URI_LIST);
}
if (imageDrag)
gtk_target_list_add_image_targets(targetList, WEBKIT_WEB_VIEW_TARGET_INFO_IMAGE, false);
GdkDragAction dragAction = GDK_ACTION_COPY;
if (linkDrag) {
dragAction = GDK_ACTION_LINK;
if (imageDrag)
dragAction = (GdkDragAction)(dragAction | GDK_ACTION_COPY);
}
GdkEvent* event = gdk_event_new(GDK_BUTTON_PRESS);
reinterpret_cast<GdkEventButton*>(event)->window = gtk_widget_get_window(GTK_WIDGET(m_webView));
reinterpret_cast<GdkEventButton*>(event)->time = GDK_CURRENT_TIME;
GdkDragContext* context = gtk_drag_begin(GTK_WIDGET(m_webView),
targetList, dragAction, 1, event);
g_object_ref(context);
if (image)
gtk_drag_set_icon_pixbuf(context, image, eventPos.x() - dragImageOrigin.x(), eventPos.y() - dragImageOrigin.y());
else
gtk_drag_set_icon_default(context);
gtk_target_list_unref(targetList);
}
static void handle_copy_button(GtkButton * button, gpointer data) {
GtkEntry * value_field = GTK_ENTRY(data);
GdkAtom atom = gdk_atom_intern_static_string("CLIPBOARD");
const char * value = gtk_entry_get_text(value_field);
GtkClipboard * clipboard = gtk_clipboard_get(atom);
gtk_clipboard_set_text(clipboard, value, -1);
gtk_clipboard_store(clipboard);
}
static void
gstyle_color_widget_on_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *data,
guint info,
guint time)
{
GstyleColorWidget *self = (GstyleColorWidget *)widget;
GdkAtom target = gtk_selection_data_get_target (data);
GstyleColor *color;
guint16 data_rgba[4];
GdkRGBA rgba;
g_assert (GSTYLE_IS_COLOR_WIDGET (self));
g_assert (GDK_IS_DRAG_CONTEXT (context));
if (self->filter_func != NULL && GSTYLE_IS_COLOR (self->filtered_color))
color = self->filtered_color;
else
color = self->color;
if (target == gdk_atom_intern_static_string ("GSTYLE_COLOR_WIDGET"))
gtk_selection_data_set (data, target, 8, (void*)&color, sizeof (gpointer));
else if (target == gdk_atom_intern_static_string ("application/x-color"))
{
gstyle_color_fill_rgba (color, &rgba);
data_rgba[0] = (guint16) (rgba.red * 65535);
data_rgba[1] = (guint16) (rgba.green * 65535);
data_rgba[2] = (guint16) (rgba.blue * 65535);
data_rgba[3] = (guint16) (rgba.alpha * 65535);
gtk_selection_data_set (data, target, 16, (void*)&data_rgba, 8);
}
else if (gtk_targets_include_text (&target, 1))
{
g_autofree gchar *name = NULL;
name = gstyle_color_to_string (color, GSTYLE_COLOR_KIND_ORIGINAL);
if (name == NULL)
name = gstyle_color_to_string (color, GSTYLE_COLOR_KIND_RGB_HEX6);
gtk_selection_data_set_text (data, name, -1);
}
}
/**
* gtk_tree_set_row_drag_data:
* @selection_data: some #GtkSelectionData
* @tree_model: a #GtkTreeModel
* @path: a row in @tree_model
*
* Sets selection data of target type %GTK_TREE_MODEL_ROW. Normally used
* in a drag_data_get handler.
*
* Returns: %TRUE if the #GtkSelectionData had the proper target type to allow us to set a tree row
**/
gboolean
gtk_tree_set_row_drag_data (GtkSelectionData *selection_data,
GtkTreeModel *tree_model,
GtkTreePath *path)
{
TreeRowData *trd;
gchar *path_str;
gint len;
gint struct_size;
g_return_val_if_fail (selection_data != NULL, FALSE);
g_return_val_if_fail (GTK_IS_TREE_MODEL (tree_model), FALSE);
g_return_val_if_fail (path != NULL, FALSE);
if (gtk_selection_data_get_target (selection_data) != gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
return FALSE;
path_str = gtk_tree_path_to_string (path);
len = strlen (path_str);
/* the old allocate-end-of-struct-to-hold-string trick */
struct_size = sizeof (TreeRowData) + len + 1 -
(sizeof (TreeRowData) - G_STRUCT_OFFSET (TreeRowData, path));
trd = g_malloc (struct_size);
strcpy (trd->path, path_str);
g_free (path_str);
trd->model = tree_model;
gtk_selection_data_set (selection_data,
gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"),
8, /* bytes */
(void*)trd,
struct_size);
g_free (trd);
return TRUE;
}
void iscreenshot_save_to_clipboard(GtkWidget *widget,GdkPixbuf *pixbuf)
{
GtkClipboard *clip;
clip=gtk_clipboard_get(gdk_atom_intern_static_string("CLIPBOARD"));
gtk_clipboard_clear(clip);
gtk_clipboard_set_image(clip,pixbuf);
gtk_main_quit();
}
void
_gdk_windowing_init (void)
{
_gdk_x11_initialize_locale ();
XSetErrorHandler (gdk_x_error);
XSetIOErrorHandler (gdk_x_io_error);
_gdk_selection_property = gdk_atom_intern_static_string ("GDK_SELECTION");
}
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
gstyle_color_widget_on_drag_motion (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
guint time)
{
GstyleColorWidget *self = (GstyleColorWidget *)widget;
GstylePaletteWidgetDndLockFlags dnd_lock;
GdkAtom target;
GdkDragAction drag_action;
g_assert (GSTYLE_IS_COLOR_WIDGET (self));
g_assert (GDK_IS_DRAG_CONTEXT (context));
target = gtk_drag_dest_find_target (widget, context, NULL);
dnd_lock = get_palette_widget_dnd_lock (self);
if ((dnd_lock & GSTYLE_PALETTE_WIDGET_DND_LOCK_FLAGS_DRAG) != 0)
{
gdk_drag_status (context, 0, time);
return FALSE;
}
if ((target == gdk_atom_intern_static_string ("GSTYLE_COLOR_WIDGET") ||
target == gdk_atom_intern_static_string ("application/x-color") ||
gtk_targets_include_text (&target, 1)) &&
(dnd_lock & GSTYLE_PALETTE_WIDGET_DND_LOCK_FLAGS_DROP) == 0 &&
is_in_drop_zone (self, x, y))
{
gtk_drag_highlight (widget);
drag_action = gdk_drag_context_get_actions (context);
if ((drag_action | GDK_ACTION_COPY) != 0)
{
gdk_drag_status (context, GDK_ACTION_COPY, time);
return TRUE;
}
}
gdk_drag_status (context, 0, time);
return FALSE;
}
/* Remove grab. */
static void
ungrab_keyboard (GtkWidget *win, GdkEvent *event, gpointer data)
{
gdk_keyboard_ungrab (gdk_event_get_time (event));
/* Unmake window transient for the root window. */
/* gdk_window_set_transient_for cannot be used with parent = NULL to
unset transient hint (unlike gtk_ version which can). Replacement
code is taken from gtk_window_transient_parent_unrealized. */
gdk_property_delete (win->window,
gdk_atom_intern_static_string ("WM_TRANSIENT_FOR"));
}
static int
get_initial_workspace (void)
{
int ret = -1;
GdkWindow *window;
guchar *data = NULL;
GdkAtom atom;
GdkAtom cardinal_atom;
window = gdk_get_default_root_window();
atom = gdk_atom_intern_static_string ("_NET_CURRENT_DESKTOP");
cardinal_atom = gdk_atom_intern_static_string ("CARDINAL");
if (gdk_property_get (window, atom, cardinal_atom, 0, 8, FALSE, NULL, NULL, NULL, &data)) {
ret = *(int *)data;
g_free (data);
}
return ret;
}
GdkAtom fm_dnd_dest_find_target(FmDndDest* dd, GdkDragContext *drag_context)
{
int i;
for(i = 0; i < G_N_ELEMENTS(fm_default_dnd_dest_targets); ++i)
{
GdkAtom target = gdk_atom_intern_static_string(fm_default_dnd_dest_targets[i].target);
if(fm_drag_context_has_target(drag_context, target))
return target;
}
return GDK_NONE;
}
static void
clipboard_check_atoms (void)
{
if (!got_atoms) {
for (int i = 0; i < N_CLIPBOARD_TARGETS; i++) {
target_atom[i] = GDK_NONE;
}
for (int i = 0; i < G_N_ELEMENTS (targets); i++) {
target_atom[targets[i].info] = gdk_atom_intern_static_string (targets[i].target);
}
got_atoms = TRUE;
}
}
static void
hildon_banner_set_override_flag (HildonBanner *banner)
{
guint32 state = 1;
gdk_property_change (GTK_WIDGET (banner)->window,
gdk_atom_intern_static_string ("_HILDON_DO_NOT_DISTURB_OVERRIDE"),
gdk_x11_xatom_to_atom (XA_INTEGER),
32,
GDK_PROP_MODE_REPLACE,
(const guchar*) &state,
1);
}
static void init_target_atoms()
{
if (target_atoms_initialized) {
return;
}
TARGET_UTF8_STRING_ATOM = gdk_atom_intern_static_string("UTF8_STRING");
TARGET_MIME_TEXT_PLAIN_ATOM = gdk_atom_intern_static_string("text/plain");
TARGET_COMPOUND_TEXT_ATOM = gdk_atom_intern_static_string("COMPOUND_TEXT");
TARGET_STRING_ATOM = gdk_atom_intern_static_string("STRING");
TARGET_MIME_URI_LIST_ATOM = gdk_atom_intern_static_string("text/uri-list");
TARGET_MIME_PNG_ATOM = gdk_atom_intern_static_string("image/png");
TARGET_MIME_JPEG_ATOM = gdk_atom_intern_static_string("image/jpeg");
TARGET_MIME_TIFF_ATOM = gdk_atom_intern_static_string("image/tiff");
TARGET_MIME_BMP_ATOM = gdk_atom_intern_static_string("image/bmp");
target_atoms_initialized = TRUE;
}
static GList *
gdk_x11_screen_get_window_stack (GdkScreen *screen)
{
GdkX11Screen *x11_screen;
GList *ret = NULL;
Atom type_return;
gint format_return;
gulong nitems_return;
gulong bytes_after_return;
guchar *data = NULL;
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
if (!gdk_x11_screen_supports_net_wm_hint (screen,
gdk_atom_intern_static_string ("_NET_CLIENT_LIST_STACKING")))
return NULL;
x11_screen = GDK_X11_SCREEN (screen);
if (XGetWindowProperty (x11_screen->xdisplay, x11_screen->xroot_window,
gdk_x11_get_xatom_by_name_for_display (x11_screen->display,
"_NET_CLIENT_LIST_STACKING"),
0, G_MAXLONG, False, XA_WINDOW, &type_return,
&format_return, &nitems_return,
&bytes_after_return, &data)
== Success)
{
if ((type_return == XA_WINDOW) && (format_return == 32) &&
(data) && (nitems_return > 0))
{
gulong *stack = (gulong *) data;
GdkWindow *win;
int i;
for (i = 0; i < nitems_return; i++)
{
win = gdk_x11_window_foreign_new_for_display (x11_screen->display,
(Window)stack[i]);
if (win != NULL)
ret = g_list_append (ret, win);
}
}
}
if (data)
XFree (data);
return ret;
}
/**
* gtk_target_table_make:
* @format_atom: format atom for the target list
* @n_targets: out variable for the size of the table
*
* Generate the target table for pasting to clipboard. Use
* gtk_target_table_free (targets, n_targets);
*
* Returns: the table and the size in the out variable @n_targets
*/
GtkTargetEntry *
gtk_target_table_make (GdkAtom format_atom, gint * n_targets)
{
GtkTargetList *list;
GtkTargetEntry *targets;
list = gtk_target_list_new (NULL, 0);
gtk_target_list_add (list, format_atom, 0, 0);
#if USE_DEBUG
// this allows to paste into a text editor
gtk_target_list_add (list, gdk_atom_intern_static_string ("UTF8_STRING"), 0,
1);
gtk_target_list_add (list, gdk_atom_intern_static_string ("TEXT"), 0, 2);
gtk_target_list_add (list, gdk_atom_intern_static_string ("text/plain"), 0,
3);
gtk_target_list_add (list,
gdk_atom_intern_static_string ("text/plain;charset=utf-8"), 0, 4);
#endif
targets = gtk_target_table_new_from_list (list, n_targets);
gtk_target_list_unref (list);
return targets;
}
inline static
gboolean cache_src_file_infos(FmDndDest* dd, GtkWidget *dest_widget,
gint x, gint y, GdkDragContext *drag_context)
{
GdkAtom target;
target = gtk_drag_dest_find_target( dest_widget, drag_context, NULL );
if( target != GDK_NONE )
{
GdkDragAction action;
gboolean ret;
/* treat X direct save as a special case. */
if( target == gdk_atom_intern_static_string("XdndDirectSave0") )
{
/* FIXME: need a better way to handle this. */
action = drag_context->suggested_action;
g_signal_emit(dd, signals[QUERY_INFO], 0, x, y, &action, &ret);
gdk_drag_status(drag_context, action, time);
return TRUE;
}
/* g_debug("try to cache src_files"); */
dd->mainloop = g_main_loop_new(NULL, TRUE);
gtk_drag_get_data(dest_widget, drag_context, target, time);
/* run the main loop to block here waiting for
* 'drag-data-received' signal being handled first. */
/* it's possible that g_main_loop_quit is called before we really run the loop. */
if(g_main_loop_is_running(dd->mainloop))
g_main_loop_run(dd->mainloop);
g_main_loop_unref(dd->mainloop);
dd->mainloop = NULL;
/* g_debug("src_files cached: %p", dd->src_files); */
/* dd->src_files should be set now */
if( dd->src_files && fm_list_is_file_info_list(dd->src_files) )
{
/* cache file system id of source files */
if( fm_file_info_list_is_same_fs(dd->src_files) )
{
FmFileInfo* fi = (FmFileInfo*)fm_list_peek_head(dd->src_files);
if(fm_path_is_native(fi->path))
dd->src_dev = fi->dev;
else
dd->src_fs_id = fi->fs_id;
}
}
}
return FALSE;
}
