cdkdnd-x11.c

Bug Summary

File:	cdk/x11/cdkdnd-x11.c
Warning:	line 1284, column 33 Out of bound memory access (access exceeds upper limit of memory block)
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name cdkdnd-x11.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/rootdir/cdk/x11 -resource-dir /usr/lib/llvm-16/lib/clang/16 -D HAVE_CONFIG_H -I . -I ../.. -D G_LOG_DOMAIN="Cdk" -D G_LOG_USE_STRUCTURED=1 -D CDK_COMPILATION -I ../.. -I ../../cdk -I ../../cdk -D G_ENABLE_DEBUG -D G_ENABLE_CONSISTENCY_CHECKS -D GLIB_MIN_REQUIRED_VERSION=GLIB_VERSION_2_66 -D GLIB_MAX_ALLOWED_VERSION=GLIB_VERSION_2_66 -I /usr/include/pango-1.0 -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/sysprof-6 -I /usr/include/harfbuzz -I /usr/include/freetype2 -I /usr/include/libpng16 -I /usr/include/libmount -I /usr/include/blkid -I /usr/include/fribidi -I /usr/include/cairo -I /usr/include/pixman-1 -I /usr/include/gdk-pixbuf-2.0 -I /usr/include/x86_64-linux-gnu -I /usr/include/webp -I /usr/include/gio-unix-2.0 -D PIC -internal-isystem /usr/lib/llvm-16/lib/clang/16/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fdebug-compilation-dir=/rootdir/cdk/x11 -ferror-limit 19 -fvisibility=hidden -fgnuc-version=4.2.1 -analyzer-checker deadcode.DeadStores -analyzer-checker alpha.deadcode.UnreachableCode -analyzer-checker alpha.core.CastSize -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.core.IdenticalExpr -analyzer-checker alpha.core.SizeofPtr -analyzer-checker alpha.security.ArrayBoundV2 -analyzer-checker alpha.security.MallocOverflow -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -analyzer-checker alpha.unix.cstring.NotNullTerminated -analyzer-checker alpha.unix.cstring.OutOfBounds -analyzer-checker alpha.core.FixedAddr -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /rootdir/html-report/2024-09-19-172241-43638-1 -x c cdkdnd-x11.c
1/* CDK - The GIMP Drawing Kit
* Copyright (C) 1995-1999 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/

18/*
* Modified by the CTK+ Team and others 1997-2000.  See the AUTHORS
* file for a list of people on the CTK+ Team.  See the ChangeLog
* files for a list of changes.  These files are distributed with
* CTK+ at ftp://ftp.ctk.org/pub/ctk/.
*/

25#include "config.h"

27#include "cdkx11dnd.h"
28#include "cdkdndprivate.h"

30#include "cdkmain.h"
31#include "cdkinternals.h"
32#include "cdkasync.h"
33#include "cdkproperty.h"
34#include "cdkprivate-x11.h"
35#include "cdkscreen-x11.h"
36#include "cdkdisplay-x11.h"

38#include <X11/Xlib.h>
39#include <X11/Xutil.h>
40#include <X11/Xatom.h>
41#include <X11/extensions/shape.h>
42#ifdef HAVE_XCOMPOSITE1
43#include <X11/extensions/Xcomposite.h>
44#endif

46#include <string.h>

48typedef enum {
CDK_DRAG_STATUS_DRAG,
CDK_DRAG_STATUS_MOTION_WAIT,
CDK_DRAG_STATUS_ACTION_WAIT,
CDK_DRAG_STATUS_DROP
53} CtkDragStatus;

55typedef struct {
guint32 xid;
gint x, y, width, height;
gboolean mapped;
gboolean shape_selected;
gboolean shape_valid;
cairo_region_t *shape;
62} CdkCacheChild;

64typedef struct {
GList *children;
GHashTable *child_hash;
guint old_event_mask;
CdkScreen *screen;
gint ref_count;
70} CdkWindowCache;


73struct _CdkX11DragContext
74{
CdkDragContext context;

gint start_x;                /* Where the drag started */
gint start_y;
guint16 last_x;              /* Coordinates from last event */
guint16 last_y;
CdkDragAction old_action;    /* The last action we sent to the source */
CdkDragAction old_actions;   /* The last actions we sent to the source */
CdkDragAction xdnd_actions;  /* What is currently set in XdndActionList */
guint version;               /* Xdnd protocol version */

GSList *window_caches;

CdkWindow *drag_window;

CdkWindow *ipc_window;
CdkCursor *cursor;
CdkSeat *grab_seat;
CdkDragAction actions;
CdkDragAction current_action;

gint hot_x;
gint hot_y;

Window dest_xid;             /* The last window we looked up */
Window drop_xid;             /* The (non-proxied) window that is receiving drops */
guint xdnd_targets_set  : 1; /* Whether we've already set XdndTypeList */
guint xdnd_actions_set  : 1; /* Whether we've already set XdndActionList */
guint xdnd_have_actions : 1; /* Whether an XdndActionList was provided */
guint drag_status       : 4; /* current status of drag */
guint drop_failed       : 1; /* Whether the drop was unsuccessful */
106};

108struct _CdkX11DragContextClass
109{
CdkDragContextClass parent_class;
111};

113typedef struct {
gint keysym;
gint modifiers;
116} GrabKey;

118static GrabKey grab_keys[] = {
{ XK_Escape0xff1b, 0 },
{ XK_space0x0020, 0 },
{ XK_KP_Space0xff80, 0 },
{ XK_Return0xff0d, 0 },
{ XK_KP_Enter0xff8d, 0 },
{ XK_Up0xff52, 0 },
{ XK_Up0xff52, Mod1Mask(1<<3) },
{ XK_Down0xff54, 0 },
{ XK_Down0xff54, Mod1Mask(1<<3) },
{ XK_Left0xff51, 0 },
{ XK_Left0xff51, Mod1Mask(1<<3) },
{ XK_Right0xff53, 0 },
{ XK_Right0xff53, Mod1Mask(1<<3) },
{ XK_KP_Up0xff97, 0 },
{ XK_KP_Up0xff97, Mod1Mask(1<<3) },
{ XK_KP_Down0xff99, 0 },
{ XK_KP_Down0xff99, Mod1Mask(1<<3) },
{ XK_KP_Left0xff96, 0 },
{ XK_KP_Left0xff96, Mod1Mask(1<<3) },
{ XK_KP_Right0xff98, 0 },
{ XK_KP_Right0xff98, Mod1Mask(1<<3) }
140};

142/* Forward declarations */

144static CdkWindowCache *cdk_window_cache_get   (CdkScreen      *screen);
145static CdkWindowCache *cdk_window_cache_ref   (CdkWindowCache *cache);
146static void            cdk_window_cache_unref (CdkWindowCache *cache);

148static CdkFilterReturn xdnd_enter_filter    (CdkXEvent *xev,
                                           CdkEvent  *event,
                                           gpointer   data);
151static CdkFilterReturn xdnd_leave_filter    (CdkXEvent *xev,
                                           CdkEvent  *event,
                                           gpointer   data);
154static CdkFilterReturn xdnd_position_filter (CdkXEvent *xev,
                                           CdkEvent  *event,
                                           gpointer   data);
157static CdkFilterReturn xdnd_status_filter   (CdkXEvent *xev,
                                           CdkEvent  *event,
                                           gpointer   data);
160static CdkFilterReturn xdnd_finished_filter (CdkXEvent *xev,
                                           CdkEvent  *event,
                                           gpointer   data);
163static CdkFilterReturn xdnd_drop_filter     (CdkXEvent *xev,
                                           CdkEvent  *event,
                                           gpointer   data);

167static void   xdnd_manage_source_filter (CdkDragContext *context,
                                       CdkWindow      *window,
                                       gboolean        add_filter);

171gboolean cdk_x11_drag_context_handle_event (CdkDragContext *context,
                                          const CdkEvent *event);
173void     cdk_x11_drag_context_action_changed (CdkDragContext *context,
                                            CdkDragAction   action);

176static GList *contexts;
177static GSList *window_caches;

179static const struct {
const char *atom_name;
CdkFilterFunc func;
182} xdnd_filters[] = {
{ "XdndEnter",                    xdnd_enter_filter },
{ "XdndLeave",                    xdnd_leave_filter },
{ "XdndPosition",                 xdnd_position_filter },
{ "XdndStatus",                   xdnd_status_filter },
{ "XdndFinished",                 xdnd_finished_filter },
{ "XdndDrop",                     xdnd_drop_filter },
189};


192G_DEFINE_TYPE (CdkX11DragContext, cdk_x11_drag_context, CDK_TYPE_DRAG_CONTEXT)static void cdk_x11_drag_context_init (CdkX11DragContext *self
); static void cdk_x11_drag_context_class_init (CdkX11DragContextClass
 *klass); static GType cdk_x11_drag_context_get_type_once (void
); static gpointer cdk_x11_drag_context_parent_class = ((void
*)0); static gint CdkX11DragContext_private_offset; static void
 cdk_x11_drag_context_class_intern_init (gpointer klass) { cdk_x11_drag_context_parent_class
 = g_type_class_peek_parent (klass); if (CdkX11DragContext_private_offset
 != 0) g_type_class_adjust_private_offset (klass, &CdkX11DragContext_private_offset
); cdk_x11_drag_context_class_init ((CdkX11DragContextClass*)
 klass); } __attribute__ ((__unused__)) static inline gpointer
 cdk_x11_drag_context_get_instance_private (CdkX11DragContext
 *self) { return (((gpointer) ((guint8*) (self) + (glong) (CdkX11DragContext_private_offset
)))); } GType cdk_x11_drag_context_get_type (void) { static GType
 static_g_define_type_id = 0; if ((__extension__ ({ _Static_assert
 (sizeof *(&static_g_define_type_id) == sizeof (gpointer)
, "Expression evaluates to false"); (void) (0 ? (gpointer) * (
&static_g_define_type_id) : ((void*)0)); (!(__extension__
 ({ _Static_assert (sizeof *(&static_g_define_type_id) ==
 sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
 ((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter_pointer (
&static_g_define_type_id)); })) ) { GType g_define_type_id
 = cdk_x11_drag_context_get_type_once (); (__extension__ ({ _Static_assert
 (sizeof *(&static_g_define_type_id) == sizeof (gpointer)
, "Expression evaluates to false"); 0 ? (void) (*(&static_g_define_type_id
) = (g_define_type_id)) : (void) 0; g_once_init_leave_pointer
 ((&static_g_define_type_id), (gpointer) (guintptr) (g_define_type_id
)); })) ; } return static_g_define_type_id; } __attribute__ (
(__noinline__)) static GType cdk_x11_drag_context_get_type_once
 (void) { GType g_define_type_id = g_type_register_static_simple
 ((cdk_drag_context_get_type ()), g_intern_static_string ("CdkX11DragContext"
), sizeof (CdkX11DragContextClass), (GClassInitFunc)(void (*)
(void)) cdk_x11_drag_context_class_intern_init, sizeof (CdkX11DragContext
), (GInstanceInitFunc)(void (*)(void)) cdk_x11_drag_context_init
, (GTypeFlags) 0); { {{};} } return g_define_type_id; }

194static void
195cdk_x11_drag_context_init (CdkX11DragContext *context)
196{
contexts = g_list_prepend (contexts, context);
198}

200static void        cdk_x11_drag_context_finalize (GObject *object);
201static CdkWindow * cdk_x11_drag_context_find_window (CdkDragContext  *context,
                                                   CdkWindow       *drag_window,
                                                   CdkScreen       *screen,
                                                   gint             x_root,
                                                   gint             y_root,
                                                   CdkDragProtocol *protocol);
207static gboolean    cdk_x11_drag_context_drag_motion (CdkDragContext  *context,
                                                   CdkWindow       *dest_window,
                                                   CdkDragProtocol  protocol,
                                                   gint             x_root,
                                                   gint             y_root,
                                                   CdkDragAction    suggested_action,
                                                   CdkDragAction    possible_actions,
                                                   guint32          time);
215static void        cdk_x11_drag_context_drag_status (CdkDragContext  *context,
                                                   CdkDragAction    action,
                                                   guint32          time_);
218static void        cdk_x11_drag_context_drag_abort  (CdkDragContext  *context,
                                                   guint32          time_);
220static void        cdk_x11_drag_context_drag_drop   (CdkDragContext  *context,
                                                   guint32          time_);
222static void        cdk_x11_drag_context_drop_reply  (CdkDragContext  *context,
                                                   gboolean         accept,
                                                   guint32          time_);
225static void        cdk_x11_drag_context_drop_finish (CdkDragContext  *context,
                                                   gboolean         success,
                                                   guint32          time_);
228static gboolean    cdk_x11_drag_context_drop_status (CdkDragContext  *context);
229static CdkAtom     cdk_x11_drag_context_get_selection (CdkDragContext  *context);
230static CdkWindow * cdk_x11_drag_context_get_drag_window (CdkDragContext *context);
231static void        cdk_x11_drag_context_set_hotspot (CdkDragContext  *context,
                                                   gint             hot_x,
                                                   gint             hot_y);
234static void        cdk_x11_drag_context_drop_done     (CdkDragContext  *context,
                                                     gboolean         success);
236static gboolean    cdk_x11_drag_context_manage_dnd     (CdkDragContext *context,
                                                      CdkWindow      *window,
                                                      CdkDragAction   actions);
239static void        cdk_x11_drag_context_set_cursor     (CdkDragContext *context,
                                                      CdkCursor      *cursor);
241static void        cdk_x11_drag_context_cancel         (CdkDragContext      *context,
                                                      CdkDragCancelReason  reason);
243static void        cdk_x11_drag_context_drop_performed (CdkDragContext *context,
                                                      guint32         time);

246static void
247cdk_x11_drag_context_class_init (CdkX11DragContextClass *klass)
248{
GObjectClass *object_class = G_OBJECT_CLASS (klass)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((klass)), (((GType) ((20) << (2))))))));
CdkDragContextClass *context_class = CDK_DRAG_CONTEXT_CLASS (klass)((((CdkDragContextClass*) (void *) g_type_check_class_cast ((
GTypeClass*) ((klass)), ((cdk_drag_context_get_type ()))))));

object_class->finalize = cdk_x11_drag_context_finalize;

context_class->find_window = cdk_x11_drag_context_find_window;
context_class->drag_status = cdk_x11_drag_context_drag_status;
context_class->drag_motion = cdk_x11_drag_context_drag_motion;
context_class->drag_abort = cdk_x11_drag_context_drag_abort;
context_class->drag_drop = cdk_x11_drag_context_drag_drop;
context_class->drop_reply = cdk_x11_drag_context_drop_reply;
context_class->drop_finish = cdk_x11_drag_context_drop_finish;
context_class->drop_status = cdk_x11_drag_context_drop_status;
context_class->get_selection = cdk_x11_drag_context_get_selection;
context_class->get_drag_window = cdk_x11_drag_context_get_drag_window;
context_class->set_hotspot = cdk_x11_drag_context_set_hotspot;
context_class->drop_done = cdk_x11_drag_context_drop_done;
context_class->manage_dnd = cdk_x11_drag_context_manage_dnd;
context_class->set_cursor = cdk_x11_drag_context_set_cursor;
context_class->cancel = cdk_x11_drag_context_cancel;
context_class->drop_performed = cdk_x11_drag_context_drop_performed;
context_class->handle_event = cdk_x11_drag_context_handle_event;
context_class->action_changed = cdk_x11_drag_context_action_changed;
272}

274static void
275cdk_x11_drag_context_finalize (GObject *object)
276{
CdkDragContext *context = CDK_DRAG_CONTEXT (object)((((CdkDragContext*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((cdk_drag_context_get_type ()))))));
CdkX11DragContext *x11_context = CDK_X11_DRAG_CONTEXT (object)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((object)), ((cdk_x11_drag_context_get_type (
)))))));
CdkWindow *drag_window;

if (context->source_window)
  {
    if ((context->protocol == CDK_DRAG_PROTO_XDND) && !context->is_source)
      xdnd_manage_source_filter (context, context->source_window, FALSE(0));
  }

g_slist_free_full (x11_context->window_caches, (GDestroyNotify)cdk_window_cache_unref);
x11_context->window_caches = NULL((void*)0);

contexts = g_list_remove (contexts, context);

drag_window = context->drag_window;

G_OBJECT_CLASS (cdk_x11_drag_context_parent_class)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((cdk_x11_drag_context_parent_class)), (((GType) ((20) <<
 (2))))))))->finalize (object);

if (drag_window)
  cdk_window_destroy (drag_window);
298}

300/* Drag Contexts */

302static CdkDragContext *
303cdk_drag_context_find (CdkDisplay *display,
                     gboolean    is_source,
                     Window      source_xid,
                     Window      dest_xid)
307{
GList *tmp_list;
CdkDragContext *context;
Window context_dest_xid;

for (tmp_list = contexts; tmp_list; tmp_list = tmp_list->next)
  {
    CdkX11DragContext *context_x11;

    context = (CdkDragContext *)tmp_list->data;
    context_x11 = (CdkX11DragContext *)context;

    if ((context->source_window && cdk_window_get_display (context->source_window) != display) ||
        (context->dest_window && cdk_window_get_display (context->dest_window) != display))
      continue;

    context_dest_xid = context->dest_window
                          ? (context_x11->drop_xid
                                ? context_x11->drop_xid
                                : CDK_WINDOW_XID (context->dest_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid))
                          : None0L;

    if ((!context->is_source == !is_source) &&
        ((source_xid == None0L) || (context->source_window &&
          (CDK_WINDOW_XID (context->source_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid) == source_xid))) &&
        ((dest_xid == None0L) || (context_dest_xid == dest_xid)))
      return context;
  }

return NULL((void*)0);
337}

339static void
340precache_target_list (CdkDragContext *context)
341{
if (context->targets)
  {
    GPtrArray *targets = g_ptr_array_new ();
    GList *tmp_list;
    int i;

    for (tmp_list = context->targets; tmp_list; tmp_list = tmp_list->next)
      g_ptr_array_add (targets, cdk_atom_name (CDK_POINTER_TO_ATOM (tmp_list->data)((CdkAtom)(tmp_list->data))));

    _cdk_x11_precache_atoms (CDK_WINDOW_DISPLAY (context->source_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (context->source_window)))), (
(cdk_x11_screen_get_type ()))))))->display),
                             (const gchar **)targets->pdata,
                             targets->len);

    for (i =0; i < targets->len; i++)
      g_free (targets->pdata[i]);

    g_ptr_array_free (targets, TRUE(!(0)));
  }
360}

362/* Utility functions */

364static void
365free_cache_child (CdkCacheChild *child,
                CdkDisplay    *display)
367{
if (child->shape)
  cairo_region_destroy (child->shape);

if (child->shape_selected && display)
  {
    CdkX11Display *display_x11 = CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))));

    XShapeSelectInput (display_x11->xdisplay, child->xid, 0);
  }

g_free (child);
379}

381static void
382cdk_window_cache_add (CdkWindowCache *cache,
                    guint32         xid,
                    gint            x,
                    gint            y,
                    gint            width,
                    gint            height,
                    gboolean        mapped)
389{
CdkCacheChild *child = g_new (CdkCacheChild, 1)((CdkCacheChild *) g_malloc_n ((1), sizeof (CdkCacheChild)));

child->xid = xid;
child->x = x;
child->y = y;
child->width = width;
child->height = height;
child->mapped = mapped;
child->shape_selected = FALSE(0);
child->shape_valid = FALSE(0);
child->shape = NULL((void*)0);

cache->children = g_list_prepend (cache->children, child);
g_hash_table_insert (cache->child_hash, GUINT_TO_POINTER (xid)((gpointer) (gulong) (xid)),
                     cache->children);
405}

407static CdkFilterReturn
408cdk_window_cache_shape_filter (CdkXEvent *xev,
                             CdkEvent  *event G_GNUC_UNUSED__attribute__ ((__unused__)),
                             gpointer   data)
411{
XEvent *xevent = (XEvent *)xev;
CdkWindowCache *cache = data;

CdkX11Display *display = CDK_X11_DISPLAY (cdk_screen_get_display (cache->screen))((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((cdk_screen_get_display (cache->screen))), ((cdk_x11_display_get_type
()))))));

if (display->have_shapes &&
    xevent->type == display->shape_event_base + ShapeNotify0)
  {
    XShapeEvent *xse = (XShapeEvent*)xevent;
    GList *node;

    node = g_hash_table_lookup (cache->child_hash,
                                GUINT_TO_POINTER (xse->window)((gpointer) (gulong) (xse->window)));
    if (node)
      {
        CdkCacheChild *child = node->data;
        child->shape_valid = FALSE(0);
        if (child->shape)
          {
            cairo_region_destroy (child->shape);
            child->shape = NULL((void*)0);
          }
      }

    return CDK_FILTER_REMOVE;
  }

return CDK_FILTER_CONTINUE;
440}

442static CdkFilterReturn
443cdk_window_cache_filter (CdkXEvent *xev,
                       CdkEvent  *event G_GNUC_UNUSED__attribute__ ((__unused__)),
                       gpointer   data)
446{
XEvent *xevent = (XEvent *)xev;
CdkWindowCache *cache = data;

switch (xevent->type)
  {
  case CirculateNotify26:
    break;
  case ConfigureNotify22:
    {
      XConfigureEvent *xce = &xevent->xconfigure;
      GList *node;

      node = g_hash_table_lookup (cache->child_hash,
                                  GUINT_TO_POINTER (xce->window)((gpointer) (gulong) (xce->window)));
      if (node)
        {
          CdkCacheChild *child = node->data;
          child->x = xce->x;
          child->y = xce->y;
          child->width = xce->width;
          child->height = xce->height;
          if (xce->above == None0L && (node->next))
            {
              GList *last = g_list_last (cache->children);
              cache->children = g_list_remove_link (cache->children, node);
              last->next = node;
              node->next = NULL((void*)0);
              node->prev = last;
            }
          else
            {
              GList *above_node = g_hash_table_lookup (cache->child_hash,
                                                       GUINT_TO_POINTER (xce->above)((gpointer) (gulong) (xce->above)));
              if (above_node && node->next != above_node)
                {
                  /* Put the window above (before in the list) above_node */
                  cache->children = g_list_remove_link (cache->children, node);
                  node->prev = above_node->prev;
                  if (node->prev)
                    node->prev->next = node;
                  else
                    cache->children = node;
                  node->next = above_node;
                  above_node->prev = node;
                }
            }
        }
      break;
    }
  case CreateNotify16:
    {
      XCreateWindowEvent *xcwe = &xevent->xcreatewindow;

      if (!g_hash_table_lookup (cache->child_hash,
                                GUINT_TO_POINTER (xcwe->window)((gpointer) (gulong) (xcwe->window))))
        cdk_window_cache_add (cache, xcwe->window,
                              xcwe->x, xcwe->y, xcwe->width, xcwe->height,
                              FALSE(0));
      break;
    }
  case DestroyNotify17:
    {
      XDestroyWindowEvent *xdwe = &xevent->xdestroywindow;
      GList *node;

      node = g_hash_table_lookup (cache->child_hash,
                                  GUINT_TO_POINTER (xdwe->window)((gpointer) (gulong) (xdwe->window)));
      if (node)
        {
          CdkCacheChild *child = node->data;

          g_hash_table_remove (cache->child_hash,
                               GUINT_TO_POINTER (xdwe->window)((gpointer) (gulong) (xdwe->window)));
          cache->children = g_list_remove_link (cache->children, node);
          /* window is destroyed, no need to disable ShapeNotify */
          free_cache_child (child, NULL((void*)0));
          g_list_free_1 (node);
        }
      break;
    }
  case MapNotify19:
    {
      XMapEvent *xme = &xevent->xmap;
      GList *node;

      node = g_hash_table_lookup (cache->child_hash,
                                  GUINT_TO_POINTER (xme->window)((gpointer) (gulong) (xme->window)));
      if (node)
        {
          CdkCacheChild *child = node->data;
          child->mapped = TRUE(!(0));
        }
      break;
    }
  case ReparentNotify21:
    break;
  case UnmapNotify18:
    {
      XMapEvent *xume = &xevent->xmap;
      GList *node;

      node = g_hash_table_lookup (cache->child_hash,
                                  GUINT_TO_POINTER (xume->window)((gpointer) (gulong) (xume->window)));
      if (node)
        {
          CdkCacheChild *child = node->data;
          child->mapped = FALSE(0);
        }
      break;
    }
  default:
    return CDK_FILTER_CONTINUE;
  }
return CDK_FILTER_REMOVE;
561}

563static CdkWindowCache *
564cdk_window_cache_new (CdkScreen *screen)
565{
XWindowAttributes xwa;
Display *xdisplay = CDK_SCREEN_XDISPLAY (screen)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((screen)), ((cdk_x11_screen_get_type ()))))))->xdisplay
);
CdkWindow *root_window = cdk_screen_get_root_window (screen);
CdkChildInfoX11 *children;
guint nchildren, i;
571#ifdef HAVE_XCOMPOSITE1
Window cow;
573#endif

CdkWindowCache *result = g_new (CdkWindowCache, 1)((CdkWindowCache *) g_malloc_n ((1), sizeof (CdkWindowCache))
);

result->children = NULL((void*)0);
result->child_hash = g_hash_table_new (g_direct_hash, NULL((void*)0));
result->screen = screen;
result->ref_count = 1;

XGetWindowAttributes (xdisplay, CDK_WINDOW_XID (root_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((root_window)), ((cdk_window_get_type ())
)))))->impl)), ((cdk_window_impl_x11_get_type ()))))))->
xid), &xwa);
result->old_event_mask = xwa.your_event_mask;

if (G_UNLIKELY (!CDK_X11_DISPLAY (CDK_X11_SCREEN (screen)->display)->trusted_client)(!((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((((((CdkX11Screen*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((screen)), ((cdk_x11_screen_get_type ()))))
))->display)), ((cdk_x11_display_get_type()))))))->trusted_client
))
  {
    GList *toplevel_windows, *list;
    gint x, y, width, height;

    toplevel_windows = cdk_screen_get_toplevel_windows (screen);
    for (list = toplevel_windows; list; list = list->next)
      {
        CdkWindow *window;
        CdkWindowImplX11 *impl;

        window = CDK_WINDOW (list->data)((((CdkWindow*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((list->data)), ((cdk_window_get_type ()))))));
 impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));
        cdk_window_get_geometry (window, &x, &y, &width, &height);
        cdk_window_cache_add (result, CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                              x * impl->window_scale, y * impl->window_scale, 
		width * impl->window_scale, 
		height * impl->window_scale,
                              cdk_window_is_visible (window));
      }
    g_list_free (toplevel_windows);
    return result;
  }

XSelectInput (xdisplay, CDK_WINDOW_XID (root_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((root_window)), ((cdk_window_get_type ())
)))))->impl)), ((cdk_window_impl_x11_get_type ()))))))->
xid),
              result->old_event_mask | SubstructureNotifyMask(1L<<19));
cdk_window_add_filter (root_window, cdk_window_cache_filter, result);
cdk_window_add_filter (NULL((void*)0), cdk_window_cache_shape_filter, result);

if (!_cdk_x11_get_window_child_info (cdk_screen_get_display (screen),
                                     CDK_WINDOW_XID (root_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((root_window)), ((cdk_window_get_type ())
)))))->impl)), ((cdk_window_impl_x11_get_type ()))))))->
xid),
                                     FALSE(0), NULL((void*)0),
                                     &children, &nchildren))
  return result;

for (i = 0; i < nchildren ; i++)
  {
    cdk_window_cache_add (result, children[i].window,
                          children[i].x, children[i].y, children[i].width, children[i].height,
                          children[i].is_mapped);
  }

g_free (children);

629#ifdef HAVE_XCOMPOSITE1
/*
 * Add the composite overlay window to the cache, as this can be a reasonable
 * Xdnd proxy as well.
 * This is only done when the screen is composited in order to avoid mapping
 * the COW. We assume that the CM is using the COW (which is true for pretty
 * much any CM currently in use).
 */
if (cdk_screen_is_composited (screen))
  {
    cdk_x11_display_error_trap_push (CDK_X11_SCREEN (screen)((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((screen)), ((cdk_x11_screen_get_type ()))))))->display);
    cow = XCompositeGetOverlayWindow (xdisplay, CDK_WINDOW_XID (root_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((root_window)), ((cdk_window_get_type ())
)))))->impl)), ((cdk_window_impl_x11_get_type ()))))))->
xid));
    cdk_window_cache_add (result, cow, 0, 0, 
	    cdk_x11_screen_get_width (screen) * CDK_X11_SCREEN(screen)((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((screen)), ((cdk_x11_screen_get_type ()))))))->window_scale, 
	    cdk_x11_screen_get_height (screen) * CDK_X11_SCREEN(screen)((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((screen)), ((cdk_x11_screen_get_type ()))))))->window_scale, 
	    TRUE(!(0)));
    XCompositeReleaseOverlayWindow (xdisplay, CDK_WINDOW_XID (root_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((root_window)), ((cdk_window_get_type ())
)))))->impl)), ((cdk_window_impl_x11_get_type ()))))))->
xid));
    cdk_x11_display_error_trap_pop_ignored (CDK_X11_SCREEN (screen)((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((screen)), ((cdk_x11_screen_get_type ()))))))->display);
  }
648#endif

return result;
651}

653static void
654cdk_window_cache_destroy (CdkWindowCache *cache)
655{
CdkWindow *root_window = cdk_screen_get_root_window (cache->screen);
CdkDisplay *display;

XSelectInput (CDK_WINDOW_XDISPLAY (root_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (root_window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
              CDK_WINDOW_XID (root_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((root_window)), ((cdk_window_get_type ())
)))))->impl)), ((cdk_window_impl_x11_get_type ()))))))->
xid),
              cache->old_event_mask);
cdk_window_remove_filter (root_window, cdk_window_cache_filter, cache);
cdk_window_remove_filter (NULL((void*)0), cdk_window_cache_shape_filter, cache);

display = cdk_screen_get_display (cache->screen);

cdk_x11_display_error_trap_push (display);
g_list_foreach (cache->children, (GFunc)free_cache_child, display);
cdk_x11_display_error_trap_pop_ignored (display);

g_list_free (cache->children);
g_hash_table_destroy (cache->child_hash);

g_free (cache);
675}

677static CdkWindowCache *
678cdk_window_cache_ref (CdkWindowCache *cache)
679{
cache->ref_count += 1;

return cache;
683}

685static void
686cdk_window_cache_unref (CdkWindowCache *cache)
687{
g_assert (cache->ref_count > 0)do { if (cache->ref_count > 0) ; else g_assertion_message_expr
 ("Cdk", "cdkdnd-x11.c", 688, ((const char*) (__func__)), "cache->ref_count > 0"
); } while (0);

cache->ref_count -= 1;

if (cache->ref_count == 0)
  {
    window_caches = g_slist_remove (window_caches, cache);
    cdk_window_cache_destroy (cache);
  }
697}

699CdkWindowCache *
700cdk_window_cache_get (CdkScreen *screen)
701{
GSList *list;
CdkWindowCache *cache;

for (list = window_caches; list; list = list->next)
  {
    cache = list->data;
    if (cache->screen == screen)
      return cdk_window_cache_ref (cache);
  }

cache = cdk_window_cache_new (screen);

window_caches = g_slist_prepend (window_caches, cache);

return cache;
717}

719static gboolean
720is_pointer_within_shape (CdkDisplay    *display,
                       CdkCacheChild *child,
                       gint           x_pos,
                       gint           y_pos)
724{
if (!child->shape_selected)
  {
    CdkX11Display *display_x11 = CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))));

    XShapeSelectInput (display_x11->xdisplay, child->xid, ShapeNotifyMask(1L << 0));
    child->shape_selected = TRUE(!(0));
  }
if (!child->shape_valid)
  {
    CdkX11Display *display_x11 = CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))));
    cairo_region_t *input_shape;

    child->shape = NULL((void*)0);
    if (cdk_display_supports_shapes (display))
      child->shape = _cdk_x11_xwindow_get_shape (display_x11->xdisplay,
                                                 child->xid, 1,  ShapeBounding0);
741#ifdef ShapeInput2
    input_shape = NULL((void*)0);
    if (cdk_display_supports_input_shapes (display))
      input_shape = _cdk_x11_xwindow_get_shape (display_x11->xdisplay,
                                                child->xid, 1, ShapeInput2);

    if (child->shape && input_shape)
      {
        cairo_region_intersect (child->shape, input_shape);
        cairo_region_destroy (input_shape);
      }
    else if (input_shape)
      {
        child->shape = input_shape;
      }
756#endif

    child->shape_valid = TRUE(!(0));
  }

return child->shape == NULL((void*)0) ||
       cairo_region_contains_point (child->shape, x_pos, y_pos);
763}

765static Window
766get_client_window_at_coords_recurse (CdkDisplay *display,
                                   Window      win,
                                   gboolean    is_toplevel,
                                   gint        x,
                                   gint        y)
771{
CdkChildInfoX11 *children;
unsigned int nchildren;
int i;
gboolean found_child = FALSE(0);
CdkChildInfoX11 child = { 0, };
gboolean has_wm_state = FALSE(0);

if (!_cdk_x11_get_window_child_info (display, win, TRUE(!(0)),
                                     is_toplevel? &has_wm_state : NULL((void*)0),
                                     &children, &nchildren))
  return None0L;

if (has_wm_state)
  {
    g_free (children);

    return win;
  }

for (i = nchildren - 1; (i >= 0) && !found_child; i--)
  {
    CdkChildInfoX11 *cur_child = &children[i];

    if ((cur_child->is_mapped) && (cur_child->window_class == InputOutput1) &&
        (x >= cur_child->x) && (x < cur_child->x + cur_child->width) &&
        (y >= cur_child->y) && (y < cur_child->y + cur_child->height))
      {
        x -= cur_child->x;
        y -= cur_child->y;
        child = *cur_child;
        found_child = TRUE(!(0));
      }
  }

g_free (children);

if (found_child)
  {
    if (child.has_wm_state)
      return child.window;
    else
      return get_client_window_at_coords_recurse (display, child.window, FALSE(0), x, y);
  }
else
  return None0L;
817}

819static Window
820get_client_window_at_coords (CdkWindowCache *cache,
                           Window          ignore,
                           gint            x_root,
                           gint            y_root)
824{
GList *tmp_list;
Window retval = None0L;
CdkDisplay *display;

display = cdk_screen_get_display (cache->screen);

cdk_x11_display_error_trap_push (display);

tmp_list = cache->children;

while (tmp_list && !retval)
  {
    CdkCacheChild *child = tmp_list->data;

    if ((child->xid != ignore) && (child->mapped))
      {
        if ((x_root >= child->x) && (x_root < child->x + child->width) &&
            (y_root >= child->y) && (y_root < child->y + child->height))
          {
            if (!is_pointer_within_shape (display, child,
                                          x_root - child->x,
                                          y_root - child->y))
              {
                tmp_list = tmp_list->next;
                continue;
              }

            retval = get_client_window_at_coords_recurse (display,
                child->xid, TRUE(!(0)),
                x_root - child->x,
                y_root - child->y);
            if (!retval)
              retval = child->xid;
          }
      }
    tmp_list = tmp_list->next;
  }

cdk_x11_display_error_trap_pop_ignored (display);

if (retval)
  return retval;
else
  return CDK_WINDOW_XID (cdk_screen_get_root_window (cache->screen))(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((cdk_screen_get_root_window (cache->screen
))), ((cdk_window_get_type ()))))))->impl)), ((cdk_window_impl_x11_get_type
 ()))))))->xid);
869}

871#ifdef G_ENABLE_DEBUG1
872static void
873print_target_list (GList *targets)
874{
while (targets)
  {
    gchar *name = cdk_atom_name (CDK_POINTER_TO_ATOM (targets->data)((CdkAtom)(targets->data)));
    g_message ("\t%s", name);
    g_free (name);
    targets = targets->next;
  }
882}
883#endif /* G_ENABLE_DEBUG */

885/*************************************************************
***************************** XDND **************************
*************************************************************/

889/* Utility functions */

891static struct {
const gchar *name;
CdkAtom atom;
CdkDragAction action;
895} xdnd_actions_table[] = {
  { "XdndActionCopy",    None0L, CDK_ACTION_COPY },
  { "XdndActionMove",    None0L, CDK_ACTION_MOVE },
  { "XdndActionLink",    None0L, CDK_ACTION_LINK },
  { "XdndActionAsk",     None0L, CDK_ACTION_ASK  },
  { "XdndActionPrivate", None0L, CDK_ACTION_COPY },
};

903static const gint xdnd_n_actions = G_N_ELEMENTS (xdnd_actions_table)(sizeof (xdnd_actions_table) / sizeof ((xdnd_actions_table)[0
]));
904static gboolean xdnd_actions_initialized = FALSE(0);

906static void
907xdnd_initialize_actions (void)
908{
gint i;

xdnd_actions_initialized = TRUE(!(0));
for (i = 0; i < xdnd_n_actions; i++)
  xdnd_actions_table[i].atom = cdk_atom_intern_static_string (xdnd_actions_table[i].name);
914}

916static CdkDragAction
917xdnd_action_from_atom (CdkDisplay *display,
                     Atom        xatom)
919{
CdkAtom atom;
gint i;

if (xatom == None0L)
  return 0;

atom = cdk_x11_xatom_to_atom_for_display (display, xatom);

if (!xdnd_actions_initialized)
  xdnd_initialize_actions();

for (i = 0; i < xdnd_n_actions; i++)
  if (atom == xdnd_actions_table[i].atom)
    return xdnd_actions_table[i].action;

return 0;
936}

938static Atom
939xdnd_action_to_atom (CdkDisplay    *display,
                   CdkDragAction  action)
941{
gint i;

if (!xdnd_actions_initialized)
  xdnd_initialize_actions();

for (i = 0; i < xdnd_n_actions; i++)
  if (action == xdnd_actions_table[i].action)
    return cdk_x11_atom_to_xatom_for_display (display, xdnd_actions_table[i].atom);

return None0L;
952}

954/* Source side */

956static CdkFilterReturn
957xdnd_status_filter (CdkXEvent *xev,
                  CdkEvent  *event,
                  gpointer   data G_GNUC_UNUSED__attribute__ ((__unused__)))
960{
CdkDisplay *display;
XEvent *xevent = (XEvent *)xev;
guint32 dest_window = xevent->xclient.data.l[0];
guint32 flags = xevent->xclient.data.l[1];
Atom action = xevent->xclient.data.l[4];
CdkDragContext *context;

if (!event->any.window ||
    cdk_window_get_window_type (event->any.window) == CDK_WINDOW_FOREIGN)
  return CDK_FILTER_CONTINUE;                 /* Not for us */

CDK_NOTE (DND,do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"XdndStatus: dest_window: %#x  action: %ld", dest_window, action
); }; } while (0)
          g_message ("XdndStatus: dest_window: %#x  action: %ld",do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"XdndStatus: dest_window: %#x  action: %ld", dest_window, action
); }; } while (0)
                     dest_window, action))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"XdndStatus: dest_window: %#x  action: %ld", dest_window, action
); }; } while (0);

display = cdk_window_get_display (event->any.window);
context = cdk_drag_context_find (display, TRUE(!(0)), xevent->xclient.window, dest_window);

if (context)
  {
    CdkX11DragContext *context_x11 = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));
    if (context_x11->drag_status == CDK_DRAG_STATUS_MOTION_WAIT)
      context_x11->drag_status = CDK_DRAG_STATUS_DRAG;

    event->dnd.send_event = FALSE(0);
    event->dnd.type = CDK_DRAG_STATUS;
    event->dnd.context = context;
    cdk_event_set_device (event, cdk_drag_context_get_device (context));
    g_object_ref (context)((__typeof__ (context)) (g_object_ref) (context));

    event->dnd.time = CDK_CURRENT_TIME0L; /* FIXME? */
    if (!(action != 0) != !(flags & 1))
      {
        CDK_NOTE (DND,do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_warning (
"Received status event with flags not corresponding to action!"
); }; } while (0)
                  g_warning ("Received status event with flags not corresponding to action!"))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_warning (
"Received status event with flags not corresponding to action!"
); }; } while (0);
        action = 0;
      }

    context->action = xdnd_action_from_atom (display, action);

    return CDK_FILTER_TRANSLATE;
  }

return CDK_FILTER_REMOVE;
1005}

1007static CdkFilterReturn
1008xdnd_finished_filter (CdkXEvent *xev,
                    CdkEvent  *event,
                    gpointer   data G_GNUC_UNUSED__attribute__ ((__unused__)))
1011{
CdkDisplay *display;
XEvent *xevent = (XEvent *)xev;
guint32 dest_window = xevent->xclient.data.l[0];
CdkDragContext *context;

if (!event->any.window ||
    cdk_window_get_window_type (event->any.window) == CDK_WINDOW_FOREIGN)
  return CDK_FILTER_CONTINUE;                 /* Not for us */

CDK_NOTE (DND,do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"XdndFinished: dest_window: %#x", dest_window); }; } while (0
)
          g_message ("XdndFinished: dest_window: %#x", dest_window))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"XdndFinished: dest_window: %#x", dest_window); }; } while (0
);

display = cdk_window_get_display (event->any.window);
context = cdk_drag_context_find (display, TRUE(!(0)), xevent->xclient.window, dest_window);

if (context)
  {
    CdkX11DragContext *context_x11;

    context_x11 = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));
    if (context_x11->version == 5)
      context_x11->drop_failed = xevent->xclient.data.l[1] == 0;

    event->dnd.type = CDK_DROP_FINISHED;
    event->dnd.context = context;
    cdk_event_set_device (event, cdk_drag_context_get_device (context));
    g_object_ref (context)((__typeof__ (context)) (g_object_ref) (context));

    event->dnd.time = CDK_CURRENT_TIME0L; /* FIXME? */

    return CDK_FILTER_TRANSLATE;
  }

return CDK_FILTER_REMOVE;
1046}

1048static void
1049xdnd_set_targets (CdkX11DragContext *context_x11)
1050{
CdkDragContext *context = CDK_DRAG_CONTEXT (context_x11)((((CdkDragContext*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((context_x11)), ((cdk_drag_context_get_type ()))))));
Atom *atomlist;
GList *tmp_list = context->targets;
gint i;
gint n_atoms = g_list_length (context->targets);
CdkDisplay *display = CDK_WINDOW_DISPLAY (context->source_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (context->source_window)))), (
(cdk_x11_screen_get_type ()))))))->display);

atomlist = g_new (Atom, n_atoms)((Atom *) g_malloc_n ((n_atoms), sizeof (Atom)));
i = 0;
while (tmp_list)
  {
    atomlist[i] = cdk_x11_atom_to_xatom_for_display (display, CDK_POINTER_TO_ATOM (tmp_list->data)((CdkAtom)(tmp_list->data)));
    tmp_list = tmp_list->next;
    i++;
  }

XChangeProperty (CDK_WINDOW_XDISPLAY (context->source_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (context->source_window)))), (
(cdk_x11_screen_get_type ()))))))->xdisplay),
                 CDK_WINDOW_XID (context->source_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid),
                 cdk_x11_get_xatom_by_name_for_display (display, "XdndTypeList"),
                 XA_ATOM((Atom) 4), 32, PropModeReplace0,
                 (guchar *)atomlist, n_atoms);

g_free (atomlist);

context_x11->xdnd_targets_set = 1;
1076}

1078static void
1079xdnd_set_actions (CdkX11DragContext *context_x11)
1080{
CdkDragContext *context = CDK_DRAG_CONTEXT (context_x11)((((CdkDragContext*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((context_x11)), ((cdk_drag_context_get_type ()))))));
Atom *atomlist;
gint i;
gint n_atoms;
guint actions;
CdkDisplay *display = CDK_WINDOW_DISPLAY (context->source_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (context->source_window)))), (
(cdk_x11_screen_get_type ()))))))->display);

if (!xdnd_actions_initialized)
  xdnd_initialize_actions();

actions = context->actions;
n_atoms = 0;
for (i = 0; i < xdnd_n_actions; i++)
  {
    if (actions & xdnd_actions_table[i].action)
      {
        actions &= ~xdnd_actions_table[i].action;
        n_atoms++;
      }
  }

atomlist = g_new (Atom, n_atoms)((Atom *) g_malloc_n ((n_atoms), sizeof (Atom)));

actions = context->actions;
n_atoms = 0;
for (i = 0; i < xdnd_n_actions; i++)
  {
    if (actions & xdnd_actions_table[i].action)
      {
        actions &= ~xdnd_actions_table[i].action;
        atomlist[n_atoms] = cdk_x11_atom_to_xatom_for_display (display, xdnd_actions_table[i].atom);
        n_atoms++;
      }
  }

XChangeProperty (CDK_WINDOW_XDISPLAY (context->source_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (context->source_window)))), (
(cdk_x11_screen_get_type ()))))))->xdisplay),
                 CDK_WINDOW_XID (context->source_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid),
                 cdk_x11_get_xatom_by_name_for_display (display, "XdndActionList"),
                 XA_ATOM((Atom) 4), 32, PropModeReplace0,
                 (guchar *)atomlist, n_atoms);

g_free (atomlist);

context_x11->xdnd_actions_set = TRUE(!(0));
context_x11->xdnd_actions = context->actions;
1126}

1128static void
1129send_client_message_async_cb (Window   window,
                            gboolean success,
                            gpointer data)
1132{
CdkDragContext *context = data;
CDK_NOTE (DND,do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Got async callback for #%lx, success = %d", window, success)
; }; } while (0)
          g_message ("Got async callback for #%lx, success = %d",do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Got async callback for #%lx, success = %d", window, success)
; }; } while (0)
                     window, success))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Got async callback for #%lx, success = %d", window, success)
; }; } while (0);

/* On failure, we immediately continue with the protocol
 * so we don't end up blocking for a timeout
 */
if (!success &&
    context->dest_window &&
    window == CDK_WINDOW_XID (context->dest_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid))
  {
    CdkEvent *temp_event;
    CdkX11DragContext *context_x11 = data;

    g_object_unref (context->dest_window);
    context->dest_window = NULL((void*)0);
    context->action = 0;

    context_x11->drag_status = CDK_DRAG_STATUS_DRAG;

    temp_event = cdk_event_new (CDK_DRAG_STATUS);
    temp_event->dnd.window = g_object_ref (context->source_window)((__typeof__ (context->source_window)) (g_object_ref) (context
->source_window));
    temp_event->dnd.send_event = TRUE(!(0));
    temp_event->dnd.context = g_object_ref (context)((__typeof__ (context)) (g_object_ref) (context));
    temp_event->dnd.time = CDK_CURRENT_TIME0L;
    cdk_event_set_device (temp_event, cdk_drag_context_get_device (context));

    cdk_event_put (temp_event);

    cdk_event_free (temp_event);
  }

g_object_unref (context);
1167}


1170static CdkDisplay *
1171cdk_drag_context_get_display (CdkDragContext *context)
1172{
if (context->source_window)
  return CDK_WINDOW_DISPLAY (context->source_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (context->source_window)))), (
(cdk_x11_screen_get_type ()))))))->display);
else if (context->dest_window)
  return CDK_WINDOW_DISPLAY (context->dest_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (context->dest_window)))), ((cdk_x11_screen_get_type
 ()))))))->display);

g_assert_not_reached ()do { g_assertion_message_expr ("Cdk", "cdkdnd-x11.c", 1178, (
(const char*) (__func__)), ((void*)0)); } while (0);
return NULL((void*)0);
1180}

1182static void
1183send_client_message_async (CdkDragContext      *context,
                         Window               window,
                         gboolean             propagate,
                         glong                event_mask,
                         XClientMessageEvent *event_send)
1188{
CdkDisplay *display = cdk_drag_context_get_display (context);

g_object_ref (context)((__typeof__ (context)) (g_object_ref) (context));

_cdk_x11_send_client_message_async (display, window,
                                    propagate, event_mask, event_send,
                                    send_client_message_async_cb, context);
1196}

1198static gboolean
1199xdnd_send_xevent (CdkX11DragContext *context_x11,
                CdkWindow         *window,
                gboolean           propagate,
                XEvent            *event_send)
1203{
CdkDragContext *context = CDK_DRAG_CONTEXT (context_x11)((((CdkDragContext*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((context_x11)), ((cdk_drag_context_get_type ()))))));
CdkDisplay *display = cdk_drag_context_get_display (context);
Window xwindow;
glong event_mask;

g_assert (event_send->xany.type == ClientMessage)do { if (event_send->xany.type == 33) ; else g_assertion_message_expr
 ("Cdk", "cdkdnd-x11.c", 1209, ((const char*) (__func__)), "event_send->xany.type == ClientMessage"
); } while (0);

/* We short-circuit messages to ourselves */
if (cdk_window_get_window_type (window) != CDK_WINDOW_FOREIGN)
  {
    gint i;

    for (i = 0; i < G_N_ELEMENTS (xdnd_filters)(sizeof (xdnd_filters) / sizeof ((xdnd_filters)[0])); i++)
      {
        if (cdk_x11_get_xatom_by_name_for_display (display, xdnd_filters[i].atom_name) ==
            event_send->xclient.message_type)
          {
            CdkEvent *temp_event;

            temp_event = cdk_event_new (CDK_NOTHING);
            temp_event->any.window = g_object_ref (window)((__typeof__ (window)) (g_object_ref) (window));

            if ((*xdnd_filters[i].func) (event_send, temp_event, NULL((void*)0)) == CDK_FILTER_TRANSLATE)
              cdk_event_put (temp_event);

            cdk_event_free (temp_event);

            return TRUE(!(0));
          }
      }
  }

xwindow = CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid);

if (_cdk_x11_display_is_root_window (display, xwindow))
  event_mask = ButtonPressMask(1L<<2);
else
  event_mask = 0;

send_client_message_async (context, xwindow, propagate, event_mask,
                           &event_send->xclient);

return TRUE(!(0));
1247}

1249static void
1250xdnd_send_enter (CdkX11DragContext *context_x11)
1251{
CdkDragContext *context = CDK_DRAG_CONTEXT (context_x11)((((CdkDragContext*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((context_x11)), ((cdk_drag_context_get_type ()))))));
CdkDisplay *display = CDK_WINDOW_DISPLAY (context->dest_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (context->dest_window)))), ((cdk_x11_screen_get_type
 ()))))))->display);
XEvent xev;

xev.xclient.type = ClientMessage33;
xev.xclient.message_type = cdk_x11_get_xatom_by_name_for_display (display, "XdndEnter");
xev.xclient.format = 32;
xev.xclient.window = context_x11->drop_xid
14
←
Assuming field 'drop_xid' is not equal to 0→
15
←
'?' condition is true→
                         ? context_x11->drop_xid
                         : CDK_WINDOW_XID (context->dest_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid);
xev.xclient.data.l[0] = CDK_WINDOW_XID (context->source_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid);
xev.xclient.data.l[1] = (context_x11->version << 24); /* version */
xev.xclient.data.l[2] = 0;
xev.xclient.data.l[3] = 0;
xev.xclient.data.l[4] = 0;

CDK_NOTE(DND,do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Sending enter source window %#lx XDND protocol version %d\n"
, (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid), context_x11->version); }; } while (0)
16
←
Assuming the condition is false→
17
←
Taking false branch→
18
←
Loop condition is false.  Exiting loop→
         g_message ("Sending enter source window %#lx XDND protocol version %d\n",do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Sending enter source window %#lx XDND protocol version %d\n"
, (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid), context_x11->version); }; } while (0)
                    CDK_WINDOW_XID (context->source_window), context_x11->version))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Sending enter source window %#lx XDND protocol version %d\n"
, (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid), context_x11->version); }; } while (0);
if (g_list_length (context->targets) > 3)
19
←
Assuming the condition is false→
20
←
Taking false branch→
  {
    if (!context_x11->xdnd_targets_set)
      xdnd_set_targets (context_x11);
    xev.xclient.data.l[1] |= 1;
  }
else
  {
    GList *tmp_list = context->targets;
    gint i = 2;

    while (tmp_list)
21
←
Loop condition is true.  Entering loop body→
22
←
Loop condition is true.  Entering loop body→
23
←
Loop condition is true.  Entering loop body→
24
←
Loop condition is true.  Entering loop body→
      {
        xev.xclient.data.l[i] = cdk_x11_atom_to_xatom_for_display (display,
25
←
Out of bound memory access (access exceeds upper limit of memory block)
                                                                   CDK_POINTER_TO_ATOM (tmp_list->data)((CdkAtom)(tmp_list->data)));
        tmp_list = tmp_list->next;
        i++;
      }
  }

if (!xdnd_send_xevent (context_x11, context->dest_window, FALSE(0), &xev))
  {
    CDK_NOTE (DND,do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Send event to %lx failed", (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid)); }; } while (0)
              g_message ("Send event to %lx failed",do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Send event to %lx failed", (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid)); }; } while (0)
                         CDK_WINDOW_XID (context->dest_window)))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Send event to %lx failed", (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid)); }; } while (0);
    g_object_unref (context->dest_window);
    context->dest_window = NULL((void*)0);
  }
1299}

1301static void
1302xdnd_send_leave (CdkX11DragContext *context_x11)
1303{
CdkDragContext *context = CDK_DRAG_CONTEXT (context_x11)((((CdkDragContext*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((context_x11)), ((cdk_drag_context_get_type ()))))));
CdkDisplay *display = CDK_WINDOW_DISPLAY (context->source_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (context->source_window)))), (
(cdk_x11_screen_get_type ()))))))->display);
XEvent xev;

xev.xclient.type = ClientMessage33;
xev.xclient.message_type = cdk_x11_get_xatom_by_name_for_display (display, "XdndLeave");
xev.xclient.format = 32;
xev.xclient.window = context_x11->drop_xid
                         ? context_x11->drop_xid
                         : CDK_WINDOW_XID (context->dest_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid);
xev.xclient.data.l[0] = CDK_WINDOW_XID (context->source_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid);
xev.xclient.data.l[1] = 0;
xev.xclient.data.l[2] = 0;
xev.xclient.data.l[3] = 0;
xev.xclient.data.l[4] = 0;

if (!xdnd_send_xevent (context_x11, context->dest_window, FALSE(0), &xev))
  {
    CDK_NOTE (DND,do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Send event to %lx failed", (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid)); }; } while (0)
              g_message ("Send event to %lx failed",do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Send event to %lx failed", (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid)); }; } while (0)
                         CDK_WINDOW_XID (context->dest_window)))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Send event to %lx failed", (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid)); }; } while (0);
    g_object_unref (context->dest_window);
    context->dest_window = NULL((void*)0);
  }
1328}

1330static void
1331xdnd_send_drop (CdkX11DragContext *context_x11,
              guint32            time)
1333{
CdkDragContext *context = CDK_DRAG_CONTEXT (context_x11)((((CdkDragContext*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((context_x11)), ((cdk_drag_context_get_type ()))))));
CdkDisplay *display = CDK_WINDOW_DISPLAY (context->source_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (context->source_window)))), (
(cdk_x11_screen_get_type ()))))))->display);
XEvent xev;

xev.xclient.type = ClientMessage33;
xev.xclient.message_type = cdk_x11_get_xatom_by_name_for_display (display, "XdndDrop");
xev.xclient.format = 32;
xev.xclient.window = context_x11->drop_xid
                         ? context_x11->drop_xid
                         : CDK_WINDOW_XID (context->dest_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid);
xev.xclient.data.l[0] = CDK_WINDOW_XID (context->source_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid);
xev.xclient.data.l[1] = 0;
xev.xclient.data.l[2] = time;
xev.xclient.data.l[3] = 0;
xev.xclient.data.l[4] = 0;

if (!xdnd_send_xevent (context_x11, context->dest_window, FALSE(0), &xev))
  {
    CDK_NOTE (DND,do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Send event to %lx failed", (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid)); }; } while (0)
              g_message ("Send event to %lx failed",do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Send event to %lx failed", (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid)); }; } while (0)
                         CDK_WINDOW_XID (context->dest_window)))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Send event to %lx failed", (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid)); }; } while (0);
    g_object_unref (context->dest_window);
    context->dest_window = NULL((void*)0);
  }
1358}

1360static void
1361xdnd_send_motion (CdkX11DragContext *context_x11,
                gint               x_root,
                gint               y_root,
                CdkDragAction      action,
                guint32            time)
1366{
CdkDragContext *context = CDK_DRAG_CONTEXT (context_x11)((((CdkDragContext*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((context_x11)), ((cdk_drag_context_get_type ()))))));
CdkDisplay *display = CDK_WINDOW_DISPLAY (context->source_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (context->source_window)))), (
(cdk_x11_screen_get_type ()))))))->display);
XEvent xev;

xev.xclient.type = ClientMessage33;
xev.xclient.message_type = cdk_x11_get_xatom_by_name_for_display (display, "XdndPosition");
xev.xclient.format = 32;
xev.xclient.window = context_x11->drop_xid
                         ? context_x11->drop_xid
                         : CDK_WINDOW_XID (context->dest_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid);
xev.xclient.data.l[0] = CDK_WINDOW_XID (context->source_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid);
xev.xclient.data.l[1] = 0;
xev.xclient.data.l[2] = (x_root << 16) | y_root;
xev.xclient.data.l[3] = time;
xev.xclient.data.l[4] = xdnd_action_to_atom (display, action);

if (!xdnd_send_xevent (context_x11, context->dest_window, FALSE(0), &xev))
  {
    CDK_NOTE (DND,do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Send event to %lx failed", (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid)); }; } while (0)
              g_message ("Send event to %lx failed",do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Send event to %lx failed", (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid)); }; } while (0)
                         CDK_WINDOW_XID (context->dest_window)))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Send event to %lx failed", (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid)); }; } while (0);
    g_object_unref (context->dest_window);
    context->dest_window = NULL((void*)0);
  }
context_x11->drag_status = CDK_DRAG_STATUS_MOTION_WAIT;
1392}

1394static guint32
1395xdnd_check_dest (CdkDisplay *display,
               Window      win,
               guint      *xdnd_version)
1398{
gboolean retval = FALSE(0);
Atom type = None0L;
int format;
unsigned long nitems, after;
guchar *data;
Window proxy;
Atom xdnd_proxy_atom = cdk_x11_get_xatom_by_name_for_display (display, "XdndProxy");
Atom xdnd_aware_atom = cdk_x11_get_xatom_by_name_for_display (display, "XdndAware");

proxy = None0L;

cdk_x11_display_error_trap_push (display);
if (XGetWindowProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), win,
                        xdnd_proxy_atom, 0,
                        1, False0, AnyPropertyType0L,
                        &type, &format, &nitems, &after,
                        &data) == Success0)
  {
    if (type != None0L)
      {
        Window *proxy_data;

        proxy_data = (Window *)data;

        if ((format == 32) && (nitems == 1))
          {
            proxy = *proxy_data;
          }
        else
          {
            CDK_NOTE (DND,do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_warning (
"Invalid XdndProxy property on window %ld", win); }; } while (
0)
                      g_warning ("Invalid XdndProxy property on window %ld", win))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_warning (
"Invalid XdndProxy property on window %ld", win); }; } while (
0);
          }

        XFree (proxy_data);
      }

    if ((XGetWindowProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), proxy ? proxy : win,
                             xdnd_aware_atom, 0,
                             1, False0, AnyPropertyType0L,
                             &type, &format, &nitems, &after,
                             &data) == Success0) &&
        type != None0L)
      {
        Atom *version;

        version = (Atom *)data;

        if ((format == 32) && (nitems == 1))
          {
            if (*version >= 3)
              retval = TRUE(!(0));
            if (xdnd_version)
              *xdnd_version = *version;
          }
        else
          {
            CDK_NOTE (DND,do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_warning (
"Invalid XdndAware property on window %ld", win); }; } while (
0)
                      g_warning ("Invalid XdndAware property on window %ld", win))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_warning (
"Invalid XdndAware property on window %ld", win); }; } while (
0);
          }

        XFree (version);
      }
  }

cdk_x11_display_error_trap_pop_ignored (display);

return retval ? (proxy ? proxy : win) : None0L;
1467}

1469/* Target side */

1471static void
1472xdnd_read_actions (CdkX11DragContext *context_x11)
1473{
CdkDragContext *context = CDK_DRAG_CONTEXT (context_x11)((((CdkDragContext*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((context_x11)), ((cdk_drag_context_get_type ()))))));
CdkDisplay *display = CDK_WINDOW_DISPLAY (context->source_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (context->source_window)))), (
(cdk_x11_screen_get_type ()))))))->display);
Atom type;
int format;
gulong nitems, after;
guchar *data;
Atom *atoms;
gint i;

context_x11->xdnd_have_actions = FALSE(0);

if (cdk_window_get_window_type (context->source_window) == CDK_WINDOW_FOREIGN)
  {
    /* Get the XdndActionList, if set */

    cdk_x11_display_error_trap_push (display);
    if (XGetWindowProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
),
                            CDK_WINDOW_XID (context->source_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid),
                            cdk_x11_get_xatom_by_name_for_display (display, "XdndActionList"),
                            0, 65536,
                            False0, XA_ATOM((Atom) 4), &type, &format, &nitems,
                            &after, &data) == Success0 &&
        type == XA_ATOM((Atom) 4))
      {
        atoms = (Atom *)data;

        context->actions = 0;

        for (i = 0; i < nitems; i++)
          context->actions |= xdnd_action_from_atom (display, atoms[i]);

        context_x11->xdnd_have_actions = TRUE(!(0));

1507#ifdef G_ENABLE_DEBUG1
        if (CDK_DEBUG_CHECK (DND)(_cdk_debug_flags & CDK_DEBUG_DND))
          {
            GString *action_str = g_string_new (NULL((void*)0));
            if (context->actions & CDK_ACTION_MOVE)
              g_string_append(action_str, "MOVE ")(__builtin_constant_p ("MOVE ") ? __extension__ ({ const char
 * const __val = ("MOVE "); g_string_append_len_inline (action_str
, __val, (__val != ((void*)0)) ? (gssize) strlen (((__val) + !
(__val))) : (gssize) -1); }) : g_string_append_len_inline (action_str
, "MOVE ", (gssize) -1));
            if (context->actions & CDK_ACTION_COPY)
              g_string_append(action_str, "COPY ")(__builtin_constant_p ("COPY ") ? __extension__ ({ const char
 * const __val = ("COPY "); g_string_append_len_inline (action_str
, __val, (__val != ((void*)0)) ? (gssize) strlen (((__val) + !
(__val))) : (gssize) -1); }) : g_string_append_len_inline (action_str
, "COPY ", (gssize) -1));
            if (context->actions & CDK_ACTION_LINK)
              g_string_append(action_str, "LINK ")(__builtin_constant_p ("LINK ") ? __extension__ ({ const char
 * const __val = ("LINK "); g_string_append_len_inline (action_str
, __val, (__val != ((void*)0)) ? (gssize) strlen (((__val) + !
(__val))) : (gssize) -1); }) : g_string_append_len_inline (action_str
, "LINK ", (gssize) -1));
            if (context->actions & CDK_ACTION_ASK)
              g_string_append(action_str, "ASK ")(__builtin_constant_p ("ASK ") ? __extension__ ({ const char *
 const __val = ("ASK "); g_string_append_len_inline (action_str
, __val, (__val != ((void*)0)) ? (gssize) strlen (((__val) + !
(__val))) : (gssize) -1); }) : g_string_append_len_inline (action_str
, "ASK ", (gssize) -1));

            g_message("Xdnd actions = %s", action_str->str);
            g_string_free (action_str, TRUE)(__builtin_constant_p ((!(0))) ? (((!(0))) ? (g_string_free) (
(action_str), ((!(0)))) : g_string_free_and_steal (action_str
)) : (g_string_free) ((action_str), ((!(0)))));
          }
1523#endif /* G_ENABLE_DEBUG */

      }

    if (data)
      XFree (data);

    cdk_x11_display_error_trap_pop_ignored (display);
  }
else
  {
    /* Local drag
     */
    CdkDragContext *source_context;

    source_context = cdk_drag_context_find (display, TRUE(!(0)),
                                            CDK_WINDOW_XID (context->source_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid),
                                            CDK_WINDOW_XID (context->dest_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid));

    if (source_context)
      {
        context->actions = source_context->actions;
        context_x11->xdnd_have_actions = TRUE(!(0));
      }
  }
1548}

1550/* We have to make sure that the XdndActionList we keep internally
* is up to date with the XdndActionList on the source window
* because we get no notification, because Xdnd wasn’t meant
* to continually send actions. So we select on PropertyChangeMask
* and add this filter.
*/
1556static CdkFilterReturn
1557xdnd_source_window_filter (CdkXEvent *xev,
                         CdkEvent  *event,
                         gpointer   cb_data)
1560{
XEvent *xevent = (XEvent *)xev;
CdkX11DragContext *context_x11 = cb_data;
CdkDisplay *display = CDK_WINDOW_DISPLAY(event->any.window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (event->any.window)))), ((cdk_x11_screen_get_type
 ()))))))->display);

if ((xevent->xany.type == PropertyNotify28) &&
    (xevent->xproperty.atom == cdk_x11_get_xatom_by_name_for_display (display, "XdndActionList")))
  {
    xdnd_read_actions (context_x11);

    return CDK_FILTER_REMOVE;
  }

return CDK_FILTER_CONTINUE;
1574}

1576static void
1577xdnd_manage_source_filter (CdkDragContext *context,
                         CdkWindow      *window,
                         gboolean        add_filter)
1580{
if (!CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) &&
    cdk_window_get_window_type (window) == CDK_WINDOW_FOREIGN)
  {
    cdk_x11_display_error_trap_push (CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display));

    if (add_filter)
      {
        cdk_window_set_events (window,
                               cdk_window_get_events (window) |
                               CDK_PROPERTY_CHANGE_MASK);
        cdk_window_add_filter (window, xdnd_source_window_filter, context);
      }
    else
      {
        cdk_window_remove_filter (window,
                                  xdnd_source_window_filter,
                                  context);
        /* Should we remove the CDK_PROPERTY_NOTIFY mask?
         * but we might want it for other reasons. (Like
         * INCR selection transactions).
         */
      }

    cdk_x11_display_error_trap_pop_ignored (CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display));
  }
1606}

1608static void
1609base_precache_atoms (CdkDisplay *display)
1610{
CdkX11Display *display_x11 = CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))));

if (!display_x11->base_dnd_atoms_precached)
  {
    static const char *const precache_atoms[] = {
      "WM_STATE",
      "XdndAware",
      "XdndProxy"
    };

    _cdk_x11_precache_atoms (display,
                             precache_atoms, G_N_ELEMENTS (precache_atoms)(sizeof (precache_atoms) / sizeof ((precache_atoms)[0])));

    display_x11->base_dnd_atoms_precached = TRUE(!(0));
  }
1626}

1628static void
1629xdnd_precache_atoms (CdkDisplay *display)
1630{
CdkX11Display *display_x11 = CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))));

if (!display_x11->xdnd_atoms_precached)
  {
    static const gchar *const precache_atoms[] = {
      "XdndActionAsk",
      "XdndActionCopy",
      "XdndActionLink",
      "XdndActionList",
      "XdndActionMove",
      "XdndActionPrivate",
      "XdndDrop",
      "XdndEnter",
      "XdndFinished",
      "XdndLeave",
      "XdndPosition",
      "XdndSelection",
      "XdndStatus",
      "XdndTypeList"
    };

    _cdk_x11_precache_atoms (display,
                             precache_atoms, G_N_ELEMENTS (precache_atoms)(sizeof (precache_atoms) / sizeof ((precache_atoms)[0])));

    display_x11->xdnd_atoms_precached = TRUE(!(0));
  }
1657}

1659static CdkFilterReturn
1660xdnd_enter_filter (CdkXEvent *xev,
                 CdkEvent  *event,
                 gpointer   cb_data G_GNUC_UNUSED__attribute__ ((__unused__)))
1663{
CdkDisplay *display;
CdkX11Display *display_x11;
XEvent *xevent = (XEvent *)xev;
CdkDragContext *context;
CdkX11DragContext *context_x11;
CdkSeat *seat;
gint i;
Atom type;
int format;
gulong nitems, after;
guchar *data;
Atom *atoms;
guint32 source_window;
gboolean get_types;
gint version;

if (!event->any.window ||
    cdk_window_get_window_type (event->any.window) == CDK_WINDOW_FOREIGN)
  return CDK_FILTER_CONTINUE;                 /* Not for us */

source_window = xevent->xclient.data.l[0];
get_types = ((xevent->xclient.data.l[1] & 1) != 0);
version = (xevent->xclient.data.l[1] & 0xff000000) >> 24;

display = CDK_WINDOW_DISPLAY (event->any.window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (event->any.window)))), ((cdk_x11_screen_get_type
 ()))))))->display);
display_x11 = CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))));

xdnd_precache_atoms (display);

CDK_NOTE (DND,do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"XdndEnter: source_window: %#x, version: %#x", source_window,
 version); }; } while (0)
          g_message ("XdndEnter: source_window: %#x, version: %#x",do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"XdndEnter: source_window: %#x, version: %#x", source_window,
 version); }; } while (0)
                     source_window, version))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"XdndEnter: source_window: %#x, version: %#x", source_window,
 version); }; } while (0);

if (version < 3)
  {
    /* Old source ignore */
    CDK_NOTE (DND, g_message ("Ignored old XdndEnter message"))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Ignored old XdndEnter message"); }; } while (0);
    return CDK_FILTER_REMOVE;
  }

if (display_x11->current_dest_drag != NULL((void*)0))
  {
    g_object_unref (display_x11->current_dest_drag);
    display_x11->current_dest_drag = NULL((void*)0);
  }

context_x11 = (CdkX11DragContext *)g_object_new (CDK_TYPE_X11_DRAG_CONTEXT(cdk_x11_drag_context_get_type ()), NULL((void*)0));
context = (CdkDragContext *)context_x11;

context->display = display;
context->protocol = CDK_DRAG_PROTO_XDND;
context_x11->version = version;

/* FIXME: Should extend DnD protocol to have device info */
seat = cdk_display_get_default_seat (display);
cdk_drag_context_set_device (context, cdk_seat_get_pointer (seat));

context->source_window = cdk_x11_window_foreign_new_for_display (display, source_window);
if (!context->source_window)
  {
    g_object_unref (context);
    return CDK_FILTER_REMOVE;
  }
context->dest_window = event->any.window;
g_object_ref (context->dest_window)((__typeof__ (context->dest_window)) (g_object_ref) (context
->dest_window));

context->targets = NULL((void*)0);
if (get_types)
  {
    cdk_x11_display_error_trap_push (display);
    XGetWindowProperty (CDK_WINDOW_XDISPLAY (event->any.window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (event->any.window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                        source_window,
                        cdk_x11_get_xatom_by_name_for_display (display, "XdndTypeList"),
                        0, 65536,
                        False0, XA_ATOM((Atom) 4), &type, &format, &nitems,
                        &after, &data);

    if (cdk_x11_display_error_trap_pop (display) || (format != 32) || (type != XA_ATOM((Atom) 4)))
      {
        g_object_unref (context);

        if (data)
          XFree (data);

        return CDK_FILTER_REMOVE;
      }

    atoms = (Atom *)data;

    for (i = 0; i < nitems; i++)
      context->targets =
        g_list_append (context->targets,
                       CDK_ATOM_TO_POINTER (cdk_x11_xatom_to_atom_for_display (display,(cdk_x11_xatom_to_atom_for_display (display, atoms[i]))
                                                                               atoms[i]))(cdk_x11_xatom_to_atom_for_display (display, atoms[i])));

    XFree (atoms);
  }
else
  {
    for (i = 0; i < 3; i++)
      if (xevent->xclient.data.l[2 + i])
        context->targets =
          g_list_append (context->targets,
                         CDK_ATOM_TO_POINTER (cdk_x11_xatom_to_atom_for_display (display,(cdk_x11_xatom_to_atom_for_display (display, xevent->xclient
.data.l[2 + i]))
                                                                                 xevent->xclient.data.l[2 + i]))(cdk_x11_xatom_to_atom_for_display (display, xevent->xclient
.data.l[2 + i])));
  }

1771#ifdef G_ENABLE_DEBUG1
if (CDK_DEBUG_CHECK (DND)(_cdk_debug_flags & CDK_DEBUG_DND))
  print_target_list (context->targets);
1774#endif /* G_ENABLE_DEBUG */

xdnd_manage_source_filter (context, context->source_window, TRUE(!(0)));
xdnd_read_actions (context_x11);

event->dnd.type = CDK_DRAG_ENTER;
event->dnd.context = context;
cdk_event_set_device (event, cdk_drag_context_get_device (context));
g_object_ref (context)((__typeof__ (context)) (g_object_ref) (context));

display_x11->current_dest_drag = context;

return CDK_FILTER_TRANSLATE;
1787}

1789static CdkFilterReturn
1790xdnd_leave_filter (CdkXEvent *xev,
                 CdkEvent  *event,
                 gpointer   data G_GNUC_UNUSED__attribute__ ((__unused__)))
1793{
XEvent *xevent = (XEvent *)xev;
guint32 source_window = xevent->xclient.data.l[0];
CdkDisplay *display;
CdkX11Display *display_x11;

if (!event->any.window ||
    cdk_window_get_window_type (event->any.window) == CDK_WINDOW_FOREIGN)
  return CDK_FILTER_CONTINUE;                 /* Not for us */

CDK_NOTE (DND,do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"XdndLeave: source_window: %#x", source_window); }; } while (
0)
          g_message ("XdndLeave: source_window: %#x",do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"XdndLeave: source_window: %#x", source_window); }; } while (
0)
                     source_window))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"XdndLeave: source_window: %#x", source_window); }; } while (
0);

display = CDK_WINDOW_DISPLAY (event->any.window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (event->any.window)))), ((cdk_x11_screen_get_type
 ()))))))->display);
display_x11 = CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))));

xdnd_precache_atoms (display);

if ((display_x11->current_dest_drag != NULL((void*)0)) &&
    (display_x11->current_dest_drag->protocol == CDK_DRAG_PROTO_XDND) &&
    (CDK_WINDOW_XID (display_x11->current_dest_drag->source_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((display_x11->current_dest_drag->source_window
)), ((cdk_window_get_type ()))))))->impl)), ((cdk_window_impl_x11_get_type
 ()))))))->xid) == source_window))
  {
    event->dnd.type = CDK_DRAG_LEAVE;
    /* Pass ownership of context to the event */
    event->dnd.context = display_x11->current_dest_drag;
    cdk_event_set_device (event, cdk_drag_context_get_device (event->dnd.context));

    display_x11->current_dest_drag = NULL((void*)0);

    return CDK_FILTER_TRANSLATE;
  }
else
  return CDK_FILTER_REMOVE;
1827}

1829static CdkFilterReturn
1830xdnd_position_filter (CdkXEvent *xev,
                    CdkEvent  *event,
                    gpointer   data G_GNUC_UNUSED__attribute__ ((__unused__)))
1833{
XEvent *xevent = (XEvent *)xev;
guint32 source_window = xevent->xclient.data.l[0];
gint16 x_root = xevent->xclient.data.l[2] >> 16;
gint16 y_root = xevent->xclient.data.l[2] & 0xffff;
guint32 time = xevent->xclient.data.l[3];
Atom action = xevent->xclient.data.l[4];
CdkDisplay *display;
CdkX11Display *display_x11;
CdkDragContext *context;

 if (!event->any.window ||
     cdk_window_get_window_type (event->any.window) == CDK_WINDOW_FOREIGN)
   return CDK_FILTER_CONTINUE;                        /* Not for us */

CDK_NOTE (DND,do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"XdndPosition: source_window: %#x position: (%d, %d)  time: %d  action: %ld"
, source_window, x_root, y_root, time, action); }; } while (0
)
          g_message ("XdndPosition: source_window: %#x position: (%d, %d)  time: %d  action: %ld",do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"XdndPosition: source_window: %#x position: (%d, %d)  time: %d  action: %ld"
, source_window, x_root, y_root, time, action); }; } while (0
)
                     source_window, x_root, y_root, time, action))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"XdndPosition: source_window: %#x position: (%d, %d)  time: %d  action: %ld"
, source_window, x_root, y_root, time, action); }; } while (0
);

display = CDK_WINDOW_DISPLAY (event->any.window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (event->any.window)))), ((cdk_x11_screen_get_type
 ()))))))->display);
display_x11 = CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))));

xdnd_precache_atoms (display);

context = display_x11->current_dest_drag;

if ((context != NULL((void*)0)) &&
    (context->protocol == CDK_DRAG_PROTO_XDND) &&
    (CDK_WINDOW_XID (context->source_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid) == source_window))
  {
    CdkWindowImplX11 *impl;
    CdkX11DragContext *context_x11;

    impl = CDK_WINDOW_IMPL_X11 (event->any.window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((event->any.window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));

    context_x11 = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));

    event->dnd.type = CDK_DRAG_MOTION;
    event->dnd.context = context;
    cdk_event_set_device (event, cdk_drag_context_get_device (context));
    g_object_ref (context)((__typeof__ (context)) (g_object_ref) (context));

    event->dnd.time = time;

    context->suggested_action = xdnd_action_from_atom (display, action);

    if (!context_x11->xdnd_have_actions)
      context->actions = context->suggested_action;

    event->dnd.x_root = x_root / impl->window_scale;
    event->dnd.y_root = y_root / impl->window_scale;

    context_x11->last_x = x_root / impl->window_scale;
    context_x11->last_y = y_root / impl->window_scale;

    return CDK_FILTER_TRANSLATE;
  }

return CDK_FILTER_REMOVE;
1892}

1894static CdkFilterReturn
1895xdnd_drop_filter (CdkXEvent *xev,
                CdkEvent  *event,
                gpointer   data G_GNUC_UNUSED__attribute__ ((__unused__)))
1898{
XEvent *xevent = (XEvent *)xev;
guint32 source_window = xevent->xclient.data.l[0];
guint32 time = xevent->xclient.data.l[2];
CdkDisplay *display;
CdkX11Display *display_x11;
CdkDragContext *context;
CdkX11DragContext *context_x11;

if (!event->any.window ||
    cdk_window_get_window_type (event->any.window) == CDK_WINDOW_FOREIGN)
  return CDK_FILTER_CONTINUE;                 /* Not for us */

CDK_NOTE (DND,do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"XdndDrop: source_window: %#x  time: %d", source_window, time
); }; } while (0)
          g_message ("XdndDrop: source_window: %#x  time: %d",do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"XdndDrop: source_window: %#x  time: %d", source_window, time
); }; } while (0)
                     source_window, time))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"XdndDrop: source_window: %#x  time: %d", source_window, time
); }; } while (0);

display = CDK_WINDOW_DISPLAY (event->any.window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (event->any.window)))), ((cdk_x11_screen_get_type
 ()))))))->display);
display_x11 = CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))));

xdnd_precache_atoms (display);

context = display_x11->current_dest_drag;

if ((context != NULL((void*)0)) &&
    (context->protocol == CDK_DRAG_PROTO_XDND) &&
    (CDK_WINDOW_XID (context->source_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid) == source_window))
  {
    context_x11 = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));
    event->dnd.type = CDK_DROP_START;

    event->dnd.context = context;
    cdk_event_set_device (event, cdk_drag_context_get_device (context));
    g_object_ref (context)((__typeof__ (context)) (g_object_ref) (context));

    event->dnd.time = time;
    event->dnd.x_root = context_x11->last_x;
    event->dnd.y_root = context_x11->last_y;

    cdk_x11_window_set_user_time (event->any.window, time);

    return CDK_FILTER_TRANSLATE;
  }

return CDK_FILTER_REMOVE;
1943}

1945CdkFilterReturn
1946_cdk_x11_dnd_filter (CdkXEvent *xev,
                   CdkEvent  *event,
                   gpointer   data)
1949{
XEvent *xevent = (XEvent *) xev;
CdkDisplay *display;
int i;

if (!CDK_IS_X11_WINDOW (event->any.window)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) (
(event->any.window)); GType __t = ((cdk_x11_window_get_type
 ())); gboolean __r; if (!__inst) __r = (0); else if (__inst->
g_class && __inst->g_class->g_type == __t) __r =
 (!(0)); else __r = g_type_check_instance_is_a (__inst, __t);
 __r; })))))
  return CDK_FILTER_CONTINUE;

if (xevent->type != ClientMessage33)
  return CDK_FILTER_CONTINUE;

display = CDK_WINDOW_DISPLAY (event->any.window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (event->any.window)))), ((cdk_x11_screen_get_type
 ()))))))->display);

for (i = 0; i < G_N_ELEMENTS (xdnd_filters)(sizeof (xdnd_filters) / sizeof ((xdnd_filters)[0])); i++)
  {
    if (xevent->xclient.message_type != cdk_x11_get_xatom_by_name_for_display (display, xdnd_filters[i].atom_name))
      continue;

    return xdnd_filters[i].func (xev, event, data);
  }

return CDK_FILTER_CONTINUE;
1971}

1973/* Source side */

1975static void
1976cdk_drag_do_leave (CdkX11DragContext *context_x11,
                 guint32            time G_GNUC_UNUSED__attribute__ ((__unused__)))
1978{
CdkDragContext *context = CDK_DRAG_CONTEXT (context_x11)((((CdkDragContext*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((context_x11)), ((cdk_drag_context_get_type ()))))));

if (context->dest_window)
  {
    switch (context->protocol)
      {
      case CDK_DRAG_PROTO_XDND:
        xdnd_send_leave (context_x11);
        break;
      case CDK_DRAG_PROTO_ROOTWIN:
      case CDK_DRAG_PROTO_NONE:
      default:
        break;
      }

    g_object_unref (context->dest_window);
    context->dest_window = NULL((void*)0);
  }
1997}

1999static CdkWindow *
2000create_drag_window (CdkScreen *screen)
2001{
CdkWindowAttr attrs = { 0 };
guint mask;

attrs.x = attrs.y = 0;
attrs.width = attrs.height = 100;
attrs.wclass = CDK_INPUT_OUTPUT;
attrs.window_type = CDK_WINDOW_TEMP;
attrs.type_hint = CDK_WINDOW_TYPE_HINT_DND;
attrs.visual = cdk_screen_get_rgba_visual (screen);
if (!attrs.visual)
  attrs.visual = cdk_screen_get_system_visual (screen);

mask = CDK_WA_X | CDK_WA_Y | CDK_WA_VISUAL | CDK_WA_TYPE_HINT;

return cdk_window_new (cdk_screen_get_root_window (screen), &attrs, mask);
2017}

2019CdkDragContext *
2020_cdk_x11_window_drag_begin (CdkWindow *window,
                          CdkDevice *device,
                          GList     *targets,
                          gint       x_root,
                          gint       y_root)
2025{
CdkDragContext *context;

context = (CdkDragContext *) g_object_new (CDK_TYPE_X11_DRAG_CONTEXT(cdk_x11_drag_context_get_type ()), NULL((void*)0));

context->display = cdk_window_get_display (window);
context->is_source = TRUE(!(0));
context->source_window = window;
g_object_ref (window)((__typeof__ (window)) (g_object_ref) (window));

context->targets = g_list_copy (targets);
precache_target_list (context);

context->actions = 0;

cdk_drag_context_set_device (context, device);

CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))))->start_x = x_root;
CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))))->start_y = y_root;
CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))))->last_x = x_root;
CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))))->last_y = y_root;

CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))))->drag_window = create_drag_window (cdk_window_get_screen (window));

return context;
2050}

2052Window
2053_cdk_x11_display_get_drag_protocol (CdkDisplay      *display,
                                  Window           xid,
                                  CdkDragProtocol *protocol,
                                  guint           *version)

2058{
CdkWindow *window;
Window retval;

base_precache_atoms (display);

/* Check for a local drag */
window = cdk_x11_window_lookup_for_display (display, xid);
if (window && cdk_window_get_window_type (window) != CDK_WINDOW_FOREIGN)
  {
    if (g_object_get_data (G_OBJECT (window)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window)), (((GType) ((20) << (2)))))))), "cdk-dnd-registered") != NULL((void*)0))
      {
        *protocol = CDK_DRAG_PROTO_XDND;
        *version = 5;
        xdnd_precache_atoms (display);
        CDK_NOTE (DND, g_message ("Entering local Xdnd window %#x\n", (guint) xid))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Entering local Xdnd window %#x\n", (guint) xid); }; } while (
0);
        return xid;
      }
    else if (_cdk_x11_display_is_root_window (display, xid))
      {
        *protocol = CDK_DRAG_PROTO_ROOTWIN;
        CDK_NOTE (DND, g_message ("Entering root window\n"))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Entering root window\n"); }; } while (0);
        return xid;
      }
  }
else if ((retval = xdnd_check_dest (display, xid, version)))
  {
    *protocol = CDK_DRAG_PROTO_XDND;
    xdnd_precache_atoms (display);
    CDK_NOTE (DND, g_message ("Entering Xdnd window %#x\n", (guint) xid))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Entering Xdnd window %#x\n", (guint) xid); }; } while (0);
    return retval;
  }
else
  {
    /* Check if this is a root window */
    gboolean rootwin = FALSE(0);

    if (_cdk_x11_display_is_root_window (display, (Window) xid))
      rootwin = TRUE(!(0));

    if (rootwin)
      {
        CDK_NOTE (DND, g_message ("Entering root window\n"))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Entering root window\n"); }; } while (0);
        *protocol = CDK_DRAG_PROTO_ROOTWIN;
        return xid;
      }
  }

*protocol = CDK_DRAG_PROTO_NONE;

return 0; /* a.k.a. None */
2109}

2111static CdkWindowCache *
2112drag_context_find_window_cache (CdkX11DragContext *context_x11,
                              CdkScreen         *screen)
2114{
GSList *list;
CdkWindowCache *cache;

for (list = context_x11->window_caches; list; list = list->next)
  {
    cache = list->data;
    if (cache->screen == screen)
      return cache;
  }

cache = cdk_window_cache_get (screen);
context_x11->window_caches = g_slist_prepend (context_x11->window_caches, cache);

return cache;
2129}

2131static CdkWindow *
2132cdk_x11_drag_context_find_window (CdkDragContext  *context,
                                CdkWindow       *drag_window,
                                CdkScreen       *screen,
                                gint             x_root,
                                gint             y_root,
                                CdkDragProtocol *protocol)
2138{
CdkX11Screen *screen_x11 = CDK_X11_SCREEN(screen)((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((screen)), ((cdk_x11_screen_get_type ()))))));
CdkX11DragContext *context_x11 = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));
CdkWindowCache *window_cache;
CdkDisplay *display;
Window dest;
CdkWindow *dest_window;

display = CDK_WINDOW_DISPLAY (context->source_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (context->source_window)))), (
(cdk_x11_screen_get_type ()))))))->display);

window_cache = drag_context_find_window_cache (context_x11, screen);

dest = get_client_window_at_coords (window_cache,
                                    drag_window && CDK_WINDOW_IS_X11 (drag_window)((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*)
 (((drag_window)->impl)); GType __t = ((cdk_window_impl_x11_get_type
 ())); gboolean __r; if (!__inst) __r = (0); else if (__inst->
g_class && __inst->g_class->g_type == __t) __r =
 (!(0)); else __r = g_type_check_instance_is_a (__inst, __t);
 __r; }))))) ?
                                    CDK_WINDOW_XID (drag_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((drag_window)), ((cdk_window_get_type ())
)))))->impl)), ((cdk_window_impl_x11_get_type ()))))))->
xid) : None0L,
                                    x_root * screen_x11->window_scale,
		      y_root * screen_x11->window_scale);

if (context_x11->dest_xid != dest)
  {
    Window recipient;
    context_x11->dest_xid = dest;

    /* Check if new destination accepts drags, and which protocol */

    /* There is some ugliness here. We actually need to pass
     * _three_ pieces of information to drag_motion - dest_window,
     * protocol, and the XID of the unproxied window. The first
     * two are passed explicitly, the third implicitly through
     * protocol->dest_xid.
     */
    recipient = _cdk_x11_display_get_drag_protocol (display,
                                                    dest,
                                                    protocol,
                                                    &context_x11->version);

    if (recipient != None0L)
      dest_window = cdk_x11_window_foreign_new_for_display (display, recipient);
    else
      dest_window = NULL((void*)0);
  }
else
  {
    dest_window = context->dest_window;
    if (dest_window)
      g_object_ref (dest_window)((__typeof__ (dest_window)) (g_object_ref) (dest_window));
    *protocol = context->protocol;
  }

return dest_window;
2188}

2190static void
2191move_drag_window (CdkDragContext *context,
                guint           x_root,
                guint           y_root)
2194{
CdkX11DragContext *context_x11 = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));

cdk_window_move (context_x11->drag_window,
                 x_root - context_x11->hot_x,
                 y_root - context_x11->hot_y);
cdk_window_raise (context_x11->drag_window);
2201}

2203static gboolean
2204cdk_x11_drag_context_drag_motion (CdkDragContext *context,
                                CdkWindow      *dest_window,
                                CdkDragProtocol protocol,
                                gint            x_root,
                                gint            y_root,
                                CdkDragAction   suggested_action,
                                CdkDragAction   possible_actions,
                                guint32         time)
2212{
CdkX11DragContext *context_x11 = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));

if (context_x11->drag_window)
1
Assuming field 'drag_window' is null→
2
←
Taking false branch→
  move_drag_window (context, x_root, y_root);

context_x11->old_actions = context->actions;
context->actions = possible_actions;

if (context_x11->old_actions != possible_actions)
3
←
Assuming 'possible_actions' is equal to field 'old_actions'→
  context_x11->xdnd_actions_set = FALSE(0);

if (protocol == CDK_DRAG_PROTO_XDND && context_x11->version == 0)
4
←
Assuming 'protocol' is equal to CDK_DRAG_PROTO_XDND→
5
←
Assuming field 'version' is not equal to 0→
  {
    /* This ugly hack is necessary since CTK+ doesn't know about
     * the XDND protocol version, and in particular doesn't know
     * that cdk_drag_find_window_for_screen() has the side-effect
     * of setting context_x11->version, and therefore sometimes call
     * cdk_drag_motion() without a prior call to
     * cdk_drag_find_window_for_screen(). This happens, e.g.
     * when CTK+ is proxying DND events to embedded windows.
     */
    if (dest_window)
      {
        CdkDisplay *display = CDK_WINDOW_DISPLAY (dest_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (dest_window)))), ((cdk_x11_screen_get_type
 ()))))))->display);

        xdnd_check_dest (display,
                         CDK_WINDOW_XID (dest_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((dest_window)), ((cdk_window_get_type ())
)))))->impl)), ((cdk_window_impl_x11_get_type ()))))))->
xid),
                         &context_x11->version);
      }
  }

/* When we have a Xdnd target, make sure our XdndActionList
 * matches the current actions;
 */
if (protocol5.1
'protocol' is equal to CDK_DRAG_PROTO_XDND
 == CDK_DRAG_PROTO_XDND && !context_x11->xdnd_actions_set)
6
←
Assuming field 'xdnd_actions_set' is not equal to 0→
7
←
Taking false branch→
  {
    if (dest_window)
      {
        if (cdk_window_get_window_type (dest_window) == CDK_WINDOW_FOREIGN)
          xdnd_set_actions (context_x11);
        else if (context->dest_window == dest_window)
          {
            CdkDisplay *display = CDK_WINDOW_DISPLAY (dest_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (dest_window)))), ((cdk_x11_screen_get_type
 ()))))))->display);
            CdkDragContext *dest_context;

            dest_context = cdk_drag_context_find (display, FALSE(0),
                                                  CDK_WINDOW_XID (context->source_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid),
                                                  CDK_WINDOW_XID (dest_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((dest_window)), ((cdk_window_get_type ())
)))))->impl)), ((cdk_window_impl_x11_get_type ()))))))->
xid));

            if (dest_context)
              {
                dest_context->actions = context->actions;
                CDK_X11_DRAG_CONTEXT (dest_context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((dest_context)), ((cdk_x11_drag_context_get_type
 ()))))))->xdnd_have_actions = TRUE(!(0));
              }
          }
      }
  }

if (context->dest_window != dest_window)
8
←
Assuming 'dest_window' is not equal to field 'dest_window'→
9
←
Taking true branch→
  {
    CdkEvent *temp_event;

    /* Send a leave to the last destination */
    cdk_drag_do_leave (context_x11, time);
    context_x11->drag_status = CDK_DRAG_STATUS_DRAG;

    /* Check if new destination accepts drags, and which protocol */

    if (dest_window)
10
←
Assuming 'dest_window' is non-null→
11
←
Taking true branch→
      {
        context->dest_window = dest_window;
        context_x11->drop_xid = context_x11->dest_xid;
        g_object_ref (context->dest_window)((__typeof__ (context->dest_window)) (g_object_ref) (context
->dest_window));
        context->protocol = protocol;

        switch (protocol)
12
←
Control jumps to 'case CDK_DRAG_PROTO_XDND:'  at line 2290→
          {
          case CDK_DRAG_PROTO_XDND:
            xdnd_send_enter (context_x11);
13
←
Calling 'xdnd_send_enter'→
            break;

          case CDK_DRAG_PROTO_ROOTWIN:
          case CDK_DRAG_PROTO_NONE:
          default:
            break;
          }
        context_x11->old_action = suggested_action;
        context->suggested_action = suggested_action;
        context_x11->old_actions = possible_actions;
      }
    else
      {
        context->dest_window = NULL((void*)0);
        context_x11->drop_xid = None0L;
        context->action = 0;
      }

    /* Push a status event, to let the client know that
     * the drag changed
     */
    temp_event = cdk_event_new (CDK_DRAG_STATUS);
    temp_event->dnd.window = g_object_ref (context->source_window)((__typeof__ (context->source_window)) (g_object_ref) (context
->source_window));
    /* We use this to signal a synthetic status. Perhaps
     * we should use an extra field...
     */
    temp_event->dnd.send_event = TRUE(!(0));

    temp_event->dnd.context = g_object_ref (context)((__typeof__ (context)) (g_object_ref) (context));
    temp_event->dnd.time = time;
    cdk_event_set_device (temp_event, cdk_drag_context_get_device (context));

    cdk_event_put (temp_event);
    cdk_event_free (temp_event);
  }
else
  {
    context_x11->old_action = context->suggested_action;
    context->suggested_action = suggested_action;
  }

/* Send a drag-motion event */

context_x11->last_x = x_root;
context_x11->last_y = y_root;

if (context->dest_window)
  {
    CdkWindowImplX11 *impl;

    impl = CDK_WINDOW_IMPL_X11 (context->dest_window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((context->dest_window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));

    if (context_x11->drag_status == CDK_DRAG_STATUS_DRAG)
      {
        switch (context->protocol)
          {
          case CDK_DRAG_PROTO_XDND:
            xdnd_send_motion (context_x11, x_root * impl->window_scale, y_root * impl->window_scale, suggested_action, time);
            break;

          case CDK_DRAG_PROTO_ROOTWIN:
            {
              CdkEvent *temp_event;
              /* CTK+ traditionally has used application/x-rootwin-drop,
               * but the XDND spec specifies x-rootwindow-drop.
               */
              CdkAtom target1 = cdk_atom_intern_static_string ("application/x-rootwindow-drop");
              CdkAtom target2 = cdk_atom_intern_static_string ("application/x-rootwin-drop");

              if (g_list_find (context->targets,
                               CDK_ATOM_TO_POINTER (target1)(target1)) ||
                  g_list_find (context->targets,
                               CDK_ATOM_TO_POINTER (target2)(target2)))
                context->action = context->suggested_action;
              else
                context->action = 0;

              temp_event = cdk_event_new (CDK_DRAG_STATUS);
              temp_event->dnd.window = g_object_ref (context->source_window)((__typeof__ (context->source_window)) (g_object_ref) (context
->source_window));
              temp_event->dnd.send_event = FALSE(0);
              temp_event->dnd.context = g_object_ref (context)((__typeof__ (context)) (g_object_ref) (context));
              temp_event->dnd.time = time;
              cdk_event_set_device (temp_event, cdk_drag_context_get_device (context));

              cdk_event_put (temp_event);
              cdk_event_free (temp_event);
            }
            break;
          case CDK_DRAG_PROTO_NONE:
            g_warning ("CDK_DRAG_PROTO_NONE is not valid in cdk_drag_motion()");
            break;
          default:
            break;
          }
      }
    else
      return TRUE(!(0));
  }

return FALSE(0);
2392}

2394static void
2395cdk_x11_drag_context_drag_abort (CdkDragContext *context,
                               guint32         time)
2397{
cdk_drag_do_leave (CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ())))))), time);
2399}

2401static void
2402cdk_x11_drag_context_drag_drop (CdkDragContext *context,
                              guint32         time)
2404{
CdkX11DragContext *context_x11 = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));

if (context->dest_window)
  {
    switch (context->protocol)
      {
      case CDK_DRAG_PROTO_XDND:
        xdnd_send_drop (context_x11, time);
        break;

      case CDK_DRAG_PROTO_ROOTWIN:
        g_warning ("Drops for CDK_DRAG_PROTO_ROOTWIN must be handled internally");
        break;
      case CDK_DRAG_PROTO_NONE:
        g_warning ("CDK_DRAG_PROTO_NONE is not valid in cdk_drag_drop()");
        break;
      default:
        break;
      }
  }
2425}

2427/* Destination side */

2429static void
2430cdk_x11_drag_context_drag_status (CdkDragContext *context,
                                CdkDragAction   action,
                                guint32         time_ G_GNUC_UNUSED__attribute__ ((__unused__)))
2433{
CdkX11DragContext *context_x11 = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));
XEvent xev;
CdkDisplay *display;

display = CDK_WINDOW_DISPLAY (context->source_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (context->source_window)))), (
(cdk_x11_screen_get_type ()))))))->display);

context->action = action;

if (context->protocol == CDK_DRAG_PROTO_XDND)
  {
    xev.xclient.type = ClientMessage33;
    xev.xclient.message_type = cdk_x11_get_xatom_by_name_for_display (display, "XdndStatus");
    xev.xclient.format = 32;
    xev.xclient.window = CDK_WINDOW_XID (context->source_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid);

    xev.xclient.data.l[0] = CDK_WINDOW_XID (context->dest_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid);
    xev.xclient.data.l[1] = (action != 0) ? (2 | 1) : 0;
    xev.xclient.data.l[2] = 0;
    xev.xclient.data.l[3] = 0;
    xev.xclient.data.l[4] = xdnd_action_to_atom (display, action);
    if (!xdnd_send_xevent (context_x11, context->source_window, FALSE(0), &xev))
      {
        CDK_NOTE (DND,do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Send event to %lx failed", (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid)); }; } while (0)
                  g_message ("Send event to %lx failed",do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Send event to %lx failed", (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid)); }; } while (0)
                             CDK_WINDOW_XID (context->source_window)))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Send event to %lx failed", (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid)); }; } while (0);
      }
  }

context_x11->old_action = action;
2463}

2465static void
2466cdk_x11_drag_context_drop_reply (CdkDragContext *context G_GNUC_UNUSED__attribute__ ((__unused__)),
                               gboolean        accepted G_GNUC_UNUSED__attribute__ ((__unused__)),
                               guint32         time_ G_GNUC_UNUSED__attribute__ ((__unused__)))
2469{
2470}

2472static void
2473cdk_x11_drag_context_drop_finish (CdkDragContext *context,
                                gboolean        success,
                                guint32         time G_GNUC_UNUSED__attribute__ ((__unused__)))
2476{
if (context->protocol == CDK_DRAG_PROTO_XDND)
  {
    CdkDisplay *display = CDK_WINDOW_DISPLAY (context->source_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (context->source_window)))), (
(cdk_x11_screen_get_type ()))))))->display);
    XEvent xev;

    xev.xclient.type = ClientMessage33;
    xev.xclient.message_type = cdk_x11_get_xatom_by_name_for_display (display, "XdndFinished");
    xev.xclient.format = 32;
    xev.xclient.window = CDK_WINDOW_XID (context->source_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid);

    xev.xclient.data.l[0] = CDK_WINDOW_XID (context->dest_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->dest_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid);
    if (success)
      {
        xev.xclient.data.l[1] = 1;
        xev.xclient.data.l[2] = xdnd_action_to_atom (display,
                                                     context->action);
      }
    else
      {
        xev.xclient.data.l[1] = 0;
        xev.xclient.data.l[2] = None0L;
      }
    xev.xclient.data.l[3] = 0;
    xev.xclient.data.l[4] = 0;

    if (!xdnd_send_xevent (CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ())))))), context->source_window, FALSE(0), &xev))
      {
        CDK_NOTE (DND,do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Send event to %lx failed", (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid)); }; } while (0)
                  g_message ("Send event to %lx failed",do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Send event to %lx failed", (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid)); }; } while (0)
                             CDK_WINDOW_XID (context->source_window)))do { if ((_cdk_debug_flags & CDK_DEBUG_DND)) { g_message (
"Send event to %lx failed", (((((CdkWindowImplX11*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((context->source_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid)); }; } while (0);
      }
  }
2509}

2511void
2512_cdk_x11_window_register_dnd (CdkWindow *window)
2513{
static const gulong xdnd_version = 5;
CdkDisplay *display = cdk_window_get_display (window);

g_return_if_fail (window != NULL)do { if ((window != ((void*)0))) { } else { g_return_if_fail_warning
 ("Cdk", ((const char*) (__func__)), "window != NULL"); return
; } } while (0);

if (cdk_window_get_window_type (window) == CDK_WINDOW_OFFSCREEN)
  return;

base_precache_atoms (display);

if (g_object_get_data (G_OBJECT (window)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window)), (((GType) ((20) << (2)))))))), "cdk-dnd-registered") != NULL((void*)0))
  return;
else
  g_object_set_data (G_OBJECT (window)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window)), (((GType) ((20) << (2)))))))), "cdk-dnd-registered", GINT_TO_POINTER (TRUE)((gpointer) (glong) ((!(0)))));

/* Set XdndAware */

/* The property needs to be of type XA_ATOM, not XA_INTEGER. Blech */
XChangeProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
),
                 CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                 cdk_x11_get_xatom_by_name_for_display (display, "XdndAware"),
                 XA_ATOM((Atom) 4), 32, PropModeReplace0,
                 (guchar *)&xdnd_version, 1);
2537}

2539static CdkAtom
2540cdk_x11_drag_context_get_selection (CdkDragContext *context)
2541{
if (context->protocol == CDK_DRAG_PROTO_XDND)
  return cdk_atom_intern_static_string ("XdndSelection");
else
  return CDK_NONE((CdkAtom)((gpointer) (gulong) (0)));
2546}

2548static gboolean
2549cdk_x11_drag_context_drop_status (CdkDragContext *context)
2550{
return ! CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))))->drop_failed;
2552}

2554static CdkWindow *
2555cdk_x11_drag_context_get_drag_window (CdkDragContext *context)
2556{
return CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))))->drag_window;
2558}

2560static void
2561cdk_x11_drag_context_set_hotspot (CdkDragContext *context,
                                gint            hot_x,
                                gint            hot_y)
2564{
CdkX11DragContext *x11_context = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));

x11_context->hot_x = hot_x;
x11_context->hot_y = hot_y;

if (x11_context->grab_seat)
  {
    /* DnD is managed, update current position */
    move_drag_window (context, x11_context->last_x, x11_context->last_y);
  }
2575}

2577static double
2578ease_out_cubic (double t)
2579{
double p = t - 1;
return p * p * p + 1;
2582}


2585#define ANIM_TIME500000 500000 /* half a second */

2587typedef struct _CdkDragAnim CdkDragAnim;
2588struct _CdkDragAnim {
CdkX11DragContext *context;
CdkFrameClock *frame_clock;
gint64 start_time;
2592};

2594static void
2595cdk_drag_anim_destroy (CdkDragAnim *anim)
2596{
g_object_unref (anim->context);
g_slice_free (CdkDragAnim, anim)do { if (1) g_slice_free1 (sizeof (CdkDragAnim), (anim)); else
 (void) ((CdkDragAnim*) 0 == (anim)); } while (0);
2599}

2601static gboolean
2602cdk_drag_anim_timeout (gpointer data)
2603{
CdkDragAnim *anim = data;
CdkX11DragContext *context = anim->context;
CdkFrameClock *frame_clock = anim->frame_clock;
gint64 current_time;
double f;
double t;

if (!frame_clock)
  return G_SOURCE_REMOVE(0);

current_time = cdk_frame_clock_get_frame_time (frame_clock);

f = (current_time - anim->start_time) / (double) ANIM_TIME500000;

if (f >= 1.0)
  return G_SOURCE_REMOVE(0);

t = ease_out_cubic (f);

cdk_window_show (context->drag_window);
cdk_window_move (context->drag_window,
                 (context->last_x - context->hot_x) +
                 (context->start_x - context->last_x) * t,
                 (context->last_y - context->hot_y) +
                 (context->start_y - context->last_y) * t);
cdk_window_set_opacity (context->drag_window, 1.0 - f);

return G_SOURCE_CONTINUE(!(0));
2632}

2634static void
2635cdk_x11_drag_context_drop_done (CdkDragContext *context,
                              gboolean        success)
2637{
CdkX11DragContext *x11_context = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));
CdkDragAnim *anim;
cairo_surface_t *win_surface;
cairo_surface_t *surface;
cairo_pattern_t *pattern;
cairo_t *cr;

if (success)
  {
    cdk_window_hide (x11_context->drag_window);
    return;
  }

win_surface = _cdk_window_ref_cairo_surface (x11_context->drag_window);
surface = cdk_window_create_similar_surface (x11_context->drag_window,
                                             cairo_surface_get_content (win_surface),
                                             cdk_window_get_width (x11_context->drag_window),
                                             cdk_window_get_height (x11_context->drag_window));
cr = cairo_create (surface);
cairo_set_source_surface (cr, win_surface, 0, 0);
cairo_paint (cr);
cairo_destroy (cr);
cairo_surface_destroy (win_surface);

pattern = cairo_pattern_create_for_surface (surface);

cdk_window_set_background_pattern (x11_context->drag_window, pattern);

cairo_pattern_destroy (pattern);
cairo_surface_destroy (surface);

anim = g_slice_new0 (CdkDragAnim)((CdkDragAnim*) g_slice_alloc0 (sizeof (CdkDragAnim)));
anim->context = g_object_ref (x11_context)((__typeof__ (x11_context)) (g_object_ref) (x11_context));
anim->frame_clock = cdk_window_get_frame_clock (x11_context->drag_window);
anim->start_time = cdk_frame_clock_get_frame_time (anim->frame_clock);

cdk_threads_add_timeout_full (G_PRIORITY_DEFAULT0, 17,
                              cdk_drag_anim_timeout, anim,
                              (GDestroyNotify) cdk_drag_anim_destroy);
2677}

2679static gboolean
2680drag_context_grab (CdkDragContext *context)
2681{
CdkX11DragContext *x11_context = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));
CdkDevice *device = cdk_drag_context_get_device (context);
CdkSeatCapabilities capabilities;
CdkWindow *root;
CdkSeat *seat;
gint keycode, i;
CdkCursor *cursor;

if (!x11_context->ipc_window)
  return FALSE(0);

root = cdk_screen_get_root_window (cdk_window_get_screen (x11_context->ipc_window));
seat = cdk_device_get_seat (cdk_drag_context_get_device (context));

2696#ifdef XINPUT_21
if (CDK_IS_X11_DEVICE_XI2 (device)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) (
(device)); GType __t = ((cdk_x11_device_xi2_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))
  capabilities = CDK_SEAT_CAPABILITY_ALL_POINTING;
else
2700#endif
  capabilities = CDK_SEAT_CAPABILITY_ALL;

cursor = cdk_drag_get_cursor (context, x11_context->current_action);
g_set_object (&x11_context->cursor, cursor)(__extension__ ({ _Static_assert (sizeof *(&x11_context->
cursor) == sizeof (cursor), "Expression evaluates to false");
 union { char *in; GObject **out; } _object_ptr; _object_ptr.
in = (char *) (&x11_context->cursor); (void) (0 ? *(&
x11_context->cursor) = (cursor), (0) : (0)); (g_set_object
) (_object_ptr.out, (GObject *) cursor); }));

if (cdk_seat_grab (seat, x11_context->ipc_window,
                   capabilities, FALSE(0),
                   x11_context->cursor, NULL((void*)0), NULL((void*)0), NULL((void*)0)) != CDK_GRAB_SUCCESS)
  return FALSE(0);

g_set_object (&x11_context->grab_seat, seat)(__extension__ ({ _Static_assert (sizeof *(&x11_context->
grab_seat) == sizeof (seat), "Expression evaluates to false")
; union { char *in; GObject **out; } _object_ptr; _object_ptr
.in = (char *) (&x11_context->grab_seat); (void) (0 ? *
(&x11_context->grab_seat) = (seat), (0) : (0)); (g_set_object
) (_object_ptr.out, (GObject *) seat); }));

cdk_x11_display_error_trap_push (cdk_window_get_display (x11_context->ipc_window));

for (i = 0; i < G_N_ELEMENTS (grab_keys)(sizeof (grab_keys) / sizeof ((grab_keys)[0])); ++i)
  {
    keycode = XKeysymToKeycode (CDK_WINDOW_XDISPLAY (x11_context->ipc_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (x11_context->ipc_window)))), (
(cdk_x11_screen_get_type ()))))))->xdisplay),
                                grab_keys[i].keysym);
    if (keycode == NoSymbol0L)
      continue;

2722#ifdef XINPUT_21
    if (CDK_IS_X11_DEVICE_XI2 (device)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) (
(device)); GType __t = ((cdk_x11_device_xi2_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))
      {
        gint deviceid = cdk_x11_device_get_id (cdk_seat_get_keyboard (seat));
        unsigned char mask[XIMaskLen(XI_LASTEVENT)(((32) >> 3) + 1)];
        XIGrabModifiers mods;
        XIEventMask evmask;
        gint num_mods;

        memset (mask, 0, sizeof (mask));
        XISetMask (mask, XI_KeyPress)(((unsigned char*)(mask))[(2)>>3] |= (1 << ((2) &
 7)));
        XISetMask (mask, XI_KeyRelease)(((unsigned char*)(mask))[(3)>>3] |= (1 << ((3) &
 7)));

        evmask.deviceid = deviceid;
        evmask.mask_len = sizeof (mask);
        evmask.mask = mask;

        num_mods = 1;
        mods.modifiers = grab_keys[i].modifiers;

        XIGrabKeycode (CDK_WINDOW_XDISPLAY (x11_context->ipc_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (x11_context->ipc_window)))), (
(cdk_x11_screen_get_type ()))))))->xdisplay),
                       deviceid,
                       keycode,
                       CDK_WINDOW_XID (root)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((root)), ((cdk_window_get_type ()))))))->
impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                       GrabModeAsync1,
                       GrabModeAsync1,
                       False0,
                       &evmask,
                       num_mods,
                       &mods);
      }
    else
2754#endif
      {
        XGrabKey (CDK_WINDOW_XDISPLAY (x11_context->ipc_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (x11_context->ipc_window)))), (
(cdk_x11_screen_get_type ()))))))->xdisplay),
                  keycode, grab_keys[i].modifiers,
                  CDK_WINDOW_XID (root)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((root)), ((cdk_window_get_type ()))))))->
impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                  FALSE(0),
                  GrabModeAsync1,
                  GrabModeAsync1);
      }
  }

cdk_x11_display_error_trap_pop_ignored (cdk_window_get_display (x11_context->ipc_window));

return TRUE(!(0));
2768}

2770static void
2771drag_context_ungrab (CdkDragContext *context)
2772{
CdkX11DragContext *x11_context = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));
CdkDevice *keyboard;
CdkWindow *root;
gint keycode, i;

if (!x11_context->grab_seat)
  return;

cdk_seat_ungrab (x11_context->grab_seat);

keyboard = cdk_seat_get_keyboard (x11_context->grab_seat);
root = cdk_screen_get_root_window (cdk_window_get_screen (x11_context->ipc_window));
g_clear_object (&x11_context->grab_seat)do { _Static_assert (sizeof *((&x11_context->grab_seat
)) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (((&x11_context->grab_seat))) _pp = ((&x11_context
->grab_seat)); __typeof__ (*((&x11_context->grab_seat
))) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_object_unref
) (_ptr); } while (0);

for (i = 0; i < G_N_ELEMENTS (grab_keys)(sizeof (grab_keys) / sizeof ((grab_keys)[0])); ++i)
  {
    keycode = XKeysymToKeycode (CDK_WINDOW_XDISPLAY (x11_context->ipc_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (x11_context->ipc_window)))), (
(cdk_x11_screen_get_type ()))))))->xdisplay),
                                grab_keys[i].keysym);
    if (keycode == NoSymbol0L)
      continue;

2794#ifdef XINPUT_21
    if (CDK_IS_X11_DEVICE_XI2 (keyboard)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) (
(keyboard)); GType __t = ((cdk_x11_device_xi2_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))
      {
        XIGrabModifiers mods;
        gint num_mods;

        num_mods = 1;
        mods.modifiers = grab_keys[i].modifiers;

        XIUngrabKeycode (CDK_WINDOW_XDISPLAY (x11_context->ipc_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (x11_context->ipc_window)))), (
(cdk_x11_screen_get_type ()))))))->xdisplay),
                         cdk_x11_device_get_id (keyboard),
                         keycode,
                         CDK_WINDOW_XID (root)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((root)), ((cdk_window_get_type ()))))))->
impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                         num_mods,
                         &mods);
      }
    else
2811#endif /* XINPUT_2 */
      {
        XUngrabKey (CDK_WINDOW_XDISPLAY (x11_context->ipc_window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (x11_context->ipc_window)))), (
(cdk_x11_screen_get_type ()))))))->xdisplay),
                    keycode, grab_keys[i].modifiers,
                    CDK_WINDOW_XID (root)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((root)), ((cdk_window_get_type ()))))))->
impl)), ((cdk_window_impl_x11_get_type ()))))))->xid));
      }
  }
2818}

2820static gboolean
2821cdk_x11_drag_context_manage_dnd (CdkDragContext *context,
                               CdkWindow      *ipc_window,
                               CdkDragAction   actions)
2824{
CdkX11DragContext *x11_context = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));

if (x11_context->ipc_window)
  return FALSE(0);

context->protocol = CDK_DRAG_PROTO_XDND;
x11_context->ipc_window = g_object_ref (ipc_window)((__typeof__ (ipc_window)) (g_object_ref) (ipc_window));

if (drag_context_grab (context))
  {
    x11_context->actions = actions;
    move_drag_window (context, x11_context->start_x, x11_context->start_y);
    return TRUE(!(0));
  }
else
  {
    g_clear_object (&x11_context->ipc_window)do { _Static_assert (sizeof *((&x11_context->ipc_window
)) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (((&x11_context->ipc_window))) _pp = ((&x11_context
->ipc_window)); __typeof__ (*((&x11_context->ipc_window
))) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_object_unref
) (_ptr); } while (0);
    return FALSE(0);
  }
2844}

2846static void
2847cdk_x11_drag_context_set_cursor (CdkDragContext *context,
                               CdkCursor      *cursor)
2849{
CdkX11DragContext *x11_context = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));

if (!g_set_object (&x11_context->cursor, cursor)(__extension__ ({ _Static_assert (sizeof *(&x11_context->
cursor) == sizeof (cursor), "Expression evaluates to false");
 union { char *in; GObject **out; } _object_ptr; _object_ptr.
in = (char *) (&x11_context->cursor); (void) (0 ? *(&
x11_context->cursor) = (cursor), (0) : (0)); (g_set_object
) (_object_ptr.out, (GObject *) cursor); })))
  return;

if (x11_context->grab_seat)
  {
    G_GNUC_BEGIN_IGNORE_DEPRECATIONSclang diagnostic push
 clang diagnostic ignored "-Wdeprecated-declarations"

;
    cdk_device_grab (cdk_seat_get_pointer (x11_context->grab_seat),
                     x11_context->ipc_window,
                     CDK_OWNERSHIP_APPLICATION, FALSE(0),
                     CDK_POINTER_MOTION_MASK | CDK_BUTTON_RELEASE_MASK,
                     cursor, CDK_CURRENT_TIME0L);
    G_GNUC_END_IGNORE_DEPRECATIONSclang diagnostic pop
;
  }
2865}

2867static void
2868cdk_x11_drag_context_cancel (CdkDragContext      *context,
                           CdkDragCancelReason  reason G_GNUC_UNUSED__attribute__ ((__unused__)))
2870{
drag_context_ungrab (context);
cdk_drag_drop_done (context, FALSE(0));
2873}

2875static void
2876cdk_x11_drag_context_drop_performed (CdkDragContext *context,
                                   guint32         time_ G_GNUC_UNUSED__attribute__ ((__unused__)))
2878{
drag_context_ungrab (context);
2880}

2882#define BIG_STEP20 20
2883#define SMALL_STEP1 1

2885static void
2886cdk_drag_get_current_actions (CdkModifierType  state,
                            gint             button,
                            CdkDragAction    actions,
                            CdkDragAction   *suggested_action,
                            CdkDragAction   *possible_actions)
2891{
*suggested_action = 0;
*possible_actions = 0;

if ((button == CDK_BUTTON_MIDDLE(2) || button == CDK_BUTTON_SECONDARY(3)) && (actions & CDK_ACTION_ASK))
  {
    *suggested_action = CDK_ACTION_ASK;
    *possible_actions = actions;
  }
else if (state & (CDK_SHIFT_MASK | CDK_CONTROL_MASK))
  {
    if ((state & CDK_SHIFT_MASK) && (state & CDK_CONTROL_MASK))
      {
        if (actions & CDK_ACTION_LINK)
          {
            *suggested_action = CDK_ACTION_LINK;
            *possible_actions = CDK_ACTION_LINK;
          }
      }
    else if (state & CDK_CONTROL_MASK)
      {
        if (actions & CDK_ACTION_COPY)
          {
            *suggested_action = CDK_ACTION_COPY;
            *possible_actions = CDK_ACTION_COPY;
          }
      }
    else
      {
        if (actions & CDK_ACTION_MOVE)
          {
            *suggested_action = CDK_ACTION_MOVE;
            *possible_actions = CDK_ACTION_MOVE;
          }
      }
  }
else
  {
    *possible_actions = actions;

    if ((state & (CDK_MOD1_MASK)) && (actions & CDK_ACTION_ASK))
      *suggested_action = CDK_ACTION_ASK;
    else if (actions & CDK_ACTION_COPY)
      *suggested_action =  CDK_ACTION_COPY;
    else if (actions & CDK_ACTION_MOVE)
      *suggested_action = CDK_ACTION_MOVE;
    else if (actions & CDK_ACTION_LINK)
      *suggested_action = CDK_ACTION_LINK;
  }
2940}

2942static void
2943cdk_drag_update (CdkDragContext  *context,
               gdouble          x_root,
               gdouble          y_root,
               CdkModifierType  mods,
               guint32          evtime)
2948{
CdkX11DragContext *x11_context = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));
CdkDragAction action, possible_actions;
CdkWindow *dest_window;
CdkDragProtocol protocol;

cdk_drag_get_current_actions (mods, CDK_BUTTON_PRIMARY(1), x11_context->actions,
                              &action, &possible_actions);

cdk_drag_find_window_for_screen (context,
                                 x11_context->drag_window,
                                 cdk_display_get_default_screen (cdk_display_get_default ()),
                                 x_root, y_root, &dest_window, &protocol);

cdk_drag_motion (context, dest_window, protocol, x_root, y_root,
                 action, possible_actions, evtime);
2964}

2966static gboolean
2967cdk_dnd_handle_motion_event (CdkDragContext       *context,
                           const CdkEventMotion *event)
2969{
CdkModifierType state;

if (!cdk_event_get_state ((CdkEvent *) event, &state))
  return FALSE(0);

cdk_drag_update (context, event->x_root, event->y_root, state,
                 cdk_event_get_time ((CdkEvent *) event));
return TRUE(!(0));
2978}

2980static gboolean
2981cdk_dnd_handle_key_event (CdkDragContext    *context,
                        const CdkEventKey *event)
2983{
CdkX11DragContext *x11_context = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));
CdkModifierType state;
CdkWindow *root_window;
CdkDevice *pointer;
gint dx, dy;

dx = dy = 0;
state = event->state;
pointer = cdk_device_get_associated_device (cdk_event_get_device ((CdkEvent *) event));

if (event->type == CDK_KEY_PRESS)
  {
    switch (event->keyval)
      {
      case CDK_KEY_Escape0xff1b:
        cdk_drag_context_cancel (context, CDK_DRAG_CANCEL_USER_CANCELLED);
        return TRUE(!(0));

      case CDK_KEY_space0x020:
      case CDK_KEY_Return0xff0d:
      case CDK_KEY_ISO_Enter0xfe34:
      case CDK_KEY_KP_Enter0xff8d:
      case CDK_KEY_KP_Space0xff80:
        if ((cdk_drag_context_get_selected_action (context) != 0) &&
            (cdk_drag_context_get_dest_window (context) != NULL((void*)0)))
          {
            g_signal_emit_by_name (context, "drop-performed",
                                   cdk_event_get_time ((CdkEvent *) event));
          }
        else
          cdk_drag_context_cancel (context, CDK_DRAG_CANCEL_NO_TARGET);

        return TRUE(!(0));

      case CDK_KEY_Up0xff52:
      case CDK_KEY_KP_Up0xff97:
        dy = (state & CDK_MOD1_MASK) ? -BIG_STEP20 : -SMALL_STEP1;
        break;

      case CDK_KEY_Down0xff54:
      case CDK_KEY_KP_Down0xff99:
        dy = (state & CDK_MOD1_MASK) ? BIG_STEP20 : SMALL_STEP1;
        break;

      case CDK_KEY_Left0xff51:
      case CDK_KEY_KP_Left0xff96:
        dx = (state & CDK_MOD1_MASK) ? -BIG_STEP20 : -SMALL_STEP1;
        break;

      case CDK_KEY_Right0xff53:
      case CDK_KEY_KP_Right0xff98:
        dx = (state & CDK_MOD1_MASK) ? BIG_STEP20 : SMALL_STEP1;
        break;
      }
  }

/* The state is not yet updated in the event, so we need
 * to query it here. We could use XGetModifierMapping, but
 * that would be overkill.
 */
root_window = cdk_screen_get_root_window (cdk_window_get_screen (x11_context->ipc_window));
cdk_window_get_device_position (root_window, pointer, NULL((void*)0), NULL((void*)0), &state);

if (dx != 0 || dy != 0)
  {
    x11_context->last_x += dx;
    x11_context->last_y += dy;
    cdk_device_warp (pointer,
                     cdk_window_get_screen (x11_context->ipc_window),
                     x11_context->last_x, x11_context->last_y);
  }

cdk_drag_update (context, x11_context->last_x, x11_context->last_y, state,
                 cdk_event_get_time ((CdkEvent *) event));

return TRUE(!(0));
3060}

3062static gboolean
3063cdk_dnd_handle_grab_broken_event (CdkDragContext           *context,
                                const CdkEventGrabBroken *event)
3065{
CdkX11DragContext *x11_context = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));

/* Don't cancel if we break the implicit grab from the initial button_press.
 * Also, don't cancel if we re-grab on the widget or on our IPC window, for
 * example, when changing the drag cursor.
 */
if (event->implicit ||
    event->grab_window == x11_context->drag_window ||
    event->grab_window == x11_context->ipc_window)
  return FALSE(0);

if (cdk_event_get_device ((CdkEvent *) event) !=
    cdk_drag_context_get_device (context))
  return FALSE(0);

cdk_drag_context_cancel (context, CDK_DRAG_CANCEL_ERROR);
return TRUE(!(0));
3083}

3085static gboolean
3086cdk_dnd_handle_button_event (CdkDragContext       *context,
                           const CdkEventButton *event)
3088{
3089#if 0
/* FIXME: Check the button matches */
if (event->button != x11_context->button)
  return FALSE(0);
3093#endif

if ((cdk_drag_context_get_selected_action (context) != 0) &&
    (cdk_drag_context_get_dest_window (context) != NULL((void*)0)))
  {
    g_signal_emit_by_name (context, "drop-performed",
                           cdk_event_get_time ((CdkEvent *) event));
  }
else
  cdk_drag_context_cancel (context, CDK_DRAG_CANCEL_NO_TARGET);

return TRUE(!(0));
3105}

3107gboolean
3108cdk_dnd_handle_drag_status (CdkDragContext    *context,
                          const CdkEventDND *event)
3110{
CdkX11DragContext *context_x11 = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));
CdkDragAction action;

if (context != event->context)
  return FALSE(0);

action = cdk_drag_context_get_selected_action (context);

if (action != context_x11->current_action)
  {
    context_x11->current_action = action;
    g_signal_emit_by_name (context, "action-changed", action);
  }

return TRUE(!(0));
3126}

3128static gboolean
3129cdk_dnd_handle_drop_finished (CdkDragContext *context,
                            const CdkEventDND *event)
3131{
CdkX11DragContext *x11_context = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));

if (context != event->context)
  return FALSE(0);

g_signal_emit_by_name (context, "dnd-finished");
cdk_drag_drop_done (context, !x11_context->drop_failed);
return TRUE(!(0));
3140}

3142gboolean
3143cdk_x11_drag_context_handle_event (CdkDragContext *context,
                                 const CdkEvent *event)
3145{
CdkX11DragContext *x11_context = CDK_X11_DRAG_CONTEXT (context)((((CdkX11DragContext*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((context)), ((cdk_x11_drag_context_get_type
 ()))))));

if (!context->is_source)
  return FALSE(0);
if (!x11_context->grab_seat && event->type != CDK_DROP_FINISHED)
  return FALSE(0);

switch (event->type)
  {
  case CDK_MOTION_NOTIFY:
    return cdk_dnd_handle_motion_event (context, &event->motion);
  case CDK_BUTTON_RELEASE:
    return cdk_dnd_handle_button_event (context, &event->button);
  case CDK_KEY_PRESS:
  case CDK_KEY_RELEASE:
    return cdk_dnd_handle_key_event (context, &event->key);
  case CDK_GRAB_BROKEN:
    return cdk_dnd_handle_grab_broken_event (context, &event->grab_broken);
  case CDK_DRAG_STATUS:
    return cdk_dnd_handle_drag_status (context, &event->dnd);
  case CDK_DROP_FINISHED:
    return cdk_dnd_handle_drop_finished (context, &event->dnd);
  default:
    break;
  }

return FALSE(0);
3173}

3175void
3176cdk_x11_drag_context_action_changed (CdkDragContext *context,
                                   CdkDragAction   action)
3178{
CdkCursor *cursor;

cursor = cdk_drag_get_cursor (context, action);
cdk_drag_context_set_cursor (context, cursor);
3183}