cdkwindow.c

Bug Summary

File:	cdk/cdkwindow.c
Warning:	line 3905, column 11 Access of the memory returned by 'alloca' at index 1, while it holds only a single 'struct _CdkWindow *' element
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 cdkwindow.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 -fdebug-compilation-dir=/rootdir/cdk -fcoverage-compilation-dir=/rootdir/cdk -resource-dir /usr/lib/llvm-19/lib/clang/19 -D HAVE_CONFIG_H -I . -I .. -D G_LOG_DOMAIN="Cdk" -D G_LOG_USE_STRUCTURED=1 -D CDK_COMPILATION -I .. -I ../cdk -I .. -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-19/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/15/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -ferror-limit 19 -fvisibility=hidden -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -analyzer-checker deadcode.DeadStores -analyzer-checker alpha.security.ArrayBoundV2 -analyzer-checker alpha.unix.cstring.NotNullTerminated -analyzer-checker alpha.deadcode.UnreachableCode -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -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/2025-12-18-102107-44033-1 -x c cdkwindow.c
1/* CDK - The GIMP Drawing Kit
* Copyright (C) 1995-2007 Peter Mattis, Spencer Kimball,
* Josh MacDonald, Ryan Lortie
*
* 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/>.
*/

19/*
* 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/.
*/

26#include "config.h"

28#include <cairo-gobject.h>

30#include "cdkwindow.h"

32#include "cdkrectangle.h"
33#include "cdkinternals.h"
34#include "cdkintl.h"
35#include "cdkscreenprivate.h"
36#include "cdkdisplayprivate.h"
37#include "cdkdeviceprivate.h"
38#include "cdkvisualprivate.h"
39#include "cdkmarshalers.h"
40#include "cdkframeclockidle.h"
41#include "cdkwindowimpl.h"
42#include "cdkglcontextprivate.h"
43#include "cdkdrawingcontextprivate.h"
44#include "cdk-private.h"

46#include <math.h>

48#include <epoxy/gl.h>

50/* for the use of round() */
51#include "fallback-c89.c"

53#ifdef CDK_WINDOWING_WAYLAND
54#include "wayland/cdkwayland.h"
55#endif

57#undef DEBUG_WINDOW_PRINTING


60/**
* SECTION:windows
* @Short_description: Onscreen display areas in the target window system
* @Title: Windows
*
* A #CdkWindow is a (usually) rectangular region on the screen.
* It’s a low-level object, used to implement high-level objects such as
* #CtkWidget and #CtkWindow on the CTK+ level. A #CtkWindow is a toplevel
* window, the thing a user might think of as a “window” with a titlebar
* and so on; a #CtkWindow may contain many #CdkWindows. For example,
* each #CtkButton has a #CdkWindow associated with it.
*
* # Composited Windows # {#COMPOSITED-WINDOWS}
*
* Normally, the windowing system takes care of rendering the contents
* of a child window onto its parent window. This mechanism can be
* intercepted by calling cdk_window_set_composited() on the child
* window. For a “composited” window it is the
* responsibility of the application to render the window contents at
* the right spot.
*
* # Offscreen Windows # {#OFFSCREEN-WINDOWS}
*
* Offscreen windows are more general than composited windows, since
* they allow not only to modify the rendering of the child window onto
* its parent, but also to apply coordinate transformations.
*
* To integrate an offscreen window into a window hierarchy, one has
* to call cdk_offscreen_window_set_embedder() and handle a number of
* signals. The #CdkWindow::pick-embedded-child signal on the embedder
* window is used to select an offscreen child at given coordinates,
* and the #CdkWindow::to-embedder and #CdkWindow::from-embedder signals
* on the offscreen window are used to translate coordinates between
* the embedder and the offscreen window.
*
* For rendering an offscreen window onto its embedder, the contents
* of the offscreen window are available as a surface, via
* cdk_offscreen_window_get_surface().
*/


101/* Historically a CdkWindow always matches a platform native window,
* be it a toplevel window or a child window. In this setup the
* CdkWindow (and other CdkDrawables) were platform independent classes,
* and the actual platform specific implementation was in a delegate
* object available as “impl” in the window object.
*
* With the addition of client side windows and offscreen windows this
* changes a bit. The application-visible CdkWindow object behaves as
* it did before, but not all such windows now have a corresponding native
* window. Instead windows that are “client side” are emulated by the cdk
* code such that clipping, drawing, moving, events etc work as expected.
*
* For CdkWindows that have a native window the “impl” object is the
* same as before. However, for all client side windows the impl object
* is shared with its parent (i.e. all client windows descendants of one
* native window has the same impl.
*
* Additionally there is a new type of platform independent impl object,
* CdkOffscreenWindow. All windows of type CDK_WINDOW_OFFSCREEN get an impl
* of this type (while their children are generally CDK_WINDOW_CHILD virtual
* windows). Such windows work by allocating a #cairo_surface_t as the backing
* store for drawing operations, which is resized with the window.
*
* CdkWindows have a pointer to the “impl window” they are in, i.e.
* the topmost CdkWindow which have the same “impl” value. This is stored
* in impl_window, which is different from the window itself only for client
* side windows.
* All CdkWindows (native or not) track the position of the window in the parent
* (x, y), the size of the window (width, height), the position of the window
* with respect to the impl window (abs_x, abs_y). We also track the clip
* region of the window wrt parent windows, in window-relative coordinates (clip_region).
*
* All toplevel windows are native windows, but also child windows can be
* native (although not children of offscreens). We always listen to
* a basic set of events (see get_native_event_mask) for these windows
* so that we can emulate events for any client side children.
*
* For native windows we apply the calculated clip region as a window shape
* so that eg. client side siblings that overlap the native child properly
* draws over the native child window.
*/

143/* This adds a local value to the CdkVisibilityState enum */
144#define CDK_VISIBILITY_NOT_VIEWABLE3 3

146enum {
PICK_EMBEDDED_CHILD, /* only called if children are embedded */
TO_EMBEDDER,
FROM_EMBEDDER,
CREATE_SURFACE,
MOVED_TO_RECT,
LAST_SIGNAL
153};

155enum {
PROP_0,
PROP_CURSOR,
LAST_PROP
159};

161/* Global info */

163static void cdk_window_finalize   (GObject              *object);

165static void cdk_window_set_property (GObject      *object,
                                   guint         prop_id,
                                   const GValue *value,
                                   GParamSpec   *pspec);
169static void cdk_window_get_property (GObject      *object,
                                   guint         prop_id,
                                   GValue       *value,
                                   GParamSpec   *pspec);

174static void cdk_window_clear_backing_region (CdkWindow *window);

176static void recompute_visible_regions   (CdkWindow *private,
			 gboolean recalculate_children);
178static void cdk_window_invalidate_in_parent (CdkWindow *private);
179static void move_native_children        (CdkWindow *private);
180static void update_cursor               (CdkDisplay *display,
                                       CdkDevice  *device);
182static void impl_window_add_update_area (CdkWindow *impl_window,
			 cairo_region_t *region);
184static void cdk_window_invalidate_region_full (CdkWindow       *window,
			       const cairo_region_t *region,
			       gboolean         invalidate_children);
187static void cdk_window_invalidate_rect_full (CdkWindow          *window,
			     const CdkRectangle *rect,
			     gboolean            invalidate_children);
190static cairo_surface_t *cdk_window_ref_impl_surface (CdkWindow *window);

192static void cdk_window_set_frame_clock (CdkWindow      *window,
                                      CdkFrameClock  *clock);

195static void draw_ugly_color (CdkWindow       *window,
                           const cairo_region_t *region,
                           int color);


200static guint signals[LAST_SIGNAL] = { 0 };
201static GParamSpec *properties[LAST_PROP] = { NULL((void*)0), };

203G_DEFINE_ABSTRACT_TYPE (CdkWindow, cdk_window, G_TYPE_OBJECT)static void cdk_window_init (CdkWindow *self); static void cdk_window_class_init
 (CdkWindowClass *klass); static GType cdk_window_get_type_once
 (void); static gpointer cdk_window_parent_class = ((void*)0)
; static gint CdkWindow_private_offset; static void cdk_window_class_intern_init
 (gpointer klass) { cdk_window_parent_class = g_type_class_peek_parent
 (klass); if (CdkWindow_private_offset != 0) g_type_class_adjust_private_offset
 (klass, &CdkWindow_private_offset); cdk_window_class_init
 ((CdkWindowClass*) klass); } __attribute__ ((__unused__)) static
 inline gpointer cdk_window_get_instance_private (CdkWindow *
self) { return (((gpointer) ((guint8*) (self) + (glong) (CdkWindow_private_offset
)))); } GType cdk_window_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_window_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_window_get_type_once (void) {
 GType g_define_type_id = g_type_register_static_simple (((GType
) ((20) << (2))), g_intern_static_string ("CdkWindow"),
 sizeof (CdkWindowClass), (GClassInitFunc)(void (*)(void)) cdk_window_class_intern_init
, sizeof (CdkWindow), (GInstanceInitFunc)(void (*)(void)) cdk_window_init
, (GTypeFlags) G_TYPE_FLAG_ABSTRACT); { {{};} } return g_define_type_id
; }

205#ifdef DEBUG_WINDOW_PRINTING
206char *
207print_region (cairo_region_t *region)
208{
GString *s = g_string_new ("{");
if (cairo_region_is_empty (region))
  {
    g_string_append (s, "empty")(__builtin_constant_p ("empty") ? __extension__ ({ const char
 * const __val = ("empty"); g_string_append_len_inline (s, __val
, (__val != ((void*)0)) ? (gssize) strlen (((__val) + !(__val
))) : (gssize) -1); }) : g_string_append_len_inline (s, "empty"
, (gssize) -1));
  }
else
  {
    int num = cairo_region_num_rectangles (region);
    cairo_rectangle_int_t r;

    if (num == 1)
{
 cairo_region_get_rectangle (region, 0, &r);
 g_string_append_printf (s, "%dx%d @%d,%d", r.width, r.height, r.x, r.y);
}
    else
{
 int i;
 cairo_region_get_extents (region, &r);
 g_string_append_printf (s, "extent: %dx%d @%d,%d, details: ", r.width, r.height, r.x, r.y);
 for (i = 0; i < num; i++)
   {
            cairo_region_get_rectangle (region, i, &r);
     g_string_append_printf (s, "[%dx%d @%d,%d]", r.width, r.height, r.x, r.y);
     if (i != num -1)
g_string_append (s, ", ")(__builtin_constant_p (", ") ? __extension__ ({ const char * const
 __val = (", "); g_string_append_len_inline (s, __val, (__val
 != ((void*)0)) ? (gssize) strlen (((__val) + !(__val))) : (gssize
) -1); }) : g_string_append_len_inline (s, ", ", (gssize) -1)
);
   }
}
  }
g_string_append (s, "}")(__builtin_constant_p ("}") ? __extension__ ({ const char * const
 __val = ("}"); g_string_append_len_inline (s, __val, (__val !=
 ((void*)0)) ? (gssize) strlen (((__val) + !(__val))) : (gssize
) -1); }) : g_string_append_len_inline (s, "}", (gssize) -1));
return g_string_free (s, FALSE)(__builtin_constant_p ((0)) ? (((0)) ? (g_string_free) ((s), (
(0))) : g_string_free_and_steal (s)) : (g_string_free) ((s), (
(0))));
240}
241#endif

243static GList *
244list_insert_link_before (GList *list,
                       GList *sibling,
                       GList *link)
247{
if (list == NULL((void*)0) || sibling == list)
  {
    link->prev = NULL((void*)0);
    link->next = list;
    if (list)
      list->prev = link;
    return link;
  }
else if (sibling == NULL((void*)0))
  {
    GList *last = g_list_last (list);

    last->next = link;
    link->prev = last;
    link->next = NULL((void*)0);

    return list;
  }
else
  {
    link->next = sibling;
    link->prev = sibling->prev;
    sibling->prev = link;

    if (link->prev)
      link->prev->next = link;

    return list;
  }
277}

279static void
280cdk_window_init (CdkWindow *window)
281{
/* 0-initialization is good for all other fields. */

window->window_type = CDK_WINDOW_CHILD;

window->state = CDK_WINDOW_STATE_WITHDRAWN;
window->fullscreen_mode = CDK_FULLSCREEN_ON_CURRENT_MONITOR;
window->width = 1;
window->height = 1;
window->toplevel_window_type = -1;
/* starts hidden */
window->effective_visibility = CDK_VISIBILITY_NOT_VIEWABLE3;
window->visibility = CDK_VISIBILITY_FULLY_OBSCURED;
/* Default to unobscured since some backends don't send visibility events */
window->native_visibility = CDK_VISIBILITY_UNOBSCURED;
window->children_list_node.data = window;

window->device_cursor = g_hash_table_new_full (NULL((void*)0), NULL((void*)0),
                                               NULL((void*)0), g_object_unref);
300}

302/* Stop and return on the first non-NULL parent */
303static gboolean
304accumulate_get_window (GSignalInvocationHint *ihint G_GNUC_UNUSED__attribute__ ((__unused__)),
       GValue                *return_accu,
       const GValue          *handler_return,
       gpointer               data G_GNUC_UNUSED__attribute__ ((__unused__)))
308{
g_value_copy (handler_return, return_accu);
/* Continue while returning NULL */
return g_value_get_object (handler_return) == NULL((void*)0);
312}

314static gboolean
315create_surface_accumulator (GSignalInvocationHint *ihint G_GNUC_UNUSED__attribute__ ((__unused__)),
                          GValue                *return_accu,
                          const GValue          *handler_return,
                          gpointer               data G_GNUC_UNUSED__attribute__ ((__unused__)))
319{
g_value_copy (handler_return, return_accu);

/* Stop on the first non-NULL return value */
return g_value_get_boxed (handler_return) == NULL((void*)0);
324}

326static GQuark quark_pointer_window = 0;

328static void
329cdk_window_class_init (CdkWindowClass *klass)
330{
GObjectClass *object_class = G_OBJECT_CLASS (klass)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((klass)), (((GType) ((20) << (2))))))));

object_class->finalize = cdk_window_finalize;
object_class->set_property = cdk_window_set_property;
object_class->get_property = cdk_window_get_property;

klass->create_surface = _cdk_offscreen_window_create_surface;

quark_pointer_window = g_quark_from_static_string ("ctk-pointer-window");


/* Properties */

/**
 * CdkWindow:cursor:
 *
 * The mouse pointer for a #CdkWindow. See cdk_window_set_cursor() and
 * cdk_window_get_cursor() for details.
 *
 * Since: 2.18
 */
properties[PROP_CURSOR] =
    g_param_spec_object ("cursor",
                         P_("Cursor")dgettext("ctk30" "-properties","Cursor"),
                         P_("Cursor")dgettext("ctk30" "-properties","Cursor"),
                         CDK_TYPE_CURSOR(cdk_cursor_get_type ()),
                         G_PARAM_READWRITE);
g_object_class_install_properties (object_class, LAST_PROP, properties);

/**
 * CdkWindow::pick-embedded-child:
 * @window: the window on which the signal is emitted
 * @x: x coordinate in the window
 * @y: y coordinate in the window
 *
 * The ::pick-embedded-child signal is emitted to find an embedded
 * child at the given position.
 *
 * Returns: (nullable) (transfer none): the #CdkWindow of the
 *     embedded child at @x, @y, or %NULL
 *
 * Since: 2.18
 */
signals[PICK_EMBEDDED_CHILD] =
  g_signal_new (g_intern_static_string ("pick-embedded-child"),
  G_OBJECT_CLASS_TYPE (object_class)((((GTypeClass*) (object_class))->g_type)),
  G_SIGNAL_RUN_LAST,
                G_STRUCT_OFFSET (CdkWindowClass, pick_embedded_child)((glong) __builtin_offsetof(CdkWindowClass, pick_embedded_child
)),
  accumulate_get_window, NULL((void*)0),
  _cdk_marshal_OBJECT__DOUBLE_DOUBLE,
  CDK_TYPE_WINDOW(cdk_window_get_type ()),
  2,
  G_TYPE_DOUBLE((GType) ((15) << (2))),
  G_TYPE_DOUBLE((GType) ((15) << (2))));
g_signal_set_va_marshaller (signals[PICK_EMBEDDED_CHILD],
                            G_OBJECT_CLASS_TYPE (object_class)((((GTypeClass*) (object_class))->g_type)),
                            _cdk_marshal_OBJECT__DOUBLE_DOUBLEv);

/**
 * CdkWindow::to-embedder:
 * @window: the offscreen window on which the signal is emitted
 * @offscreen_x: x coordinate in the offscreen window
 * @offscreen_y: y coordinate in the offscreen window
 * @embedder_x: (out) (type double): return location for the x
 *     coordinate in the embedder window
 * @embedder_y: (out) (type double): return location for the y
 *     coordinate in the embedder window
 *
 * The ::to-embedder signal is emitted to translate coordinates
 * in an offscreen window to its embedder.
 *
 * See also #CdkWindow::from-embedder.
 *
 * Since: 2.18
 */
signals[TO_EMBEDDER] =
  g_signal_new (g_intern_static_string ("to-embedder"),
  G_OBJECT_CLASS_TYPE (object_class)((((GTypeClass*) (object_class))->g_type)),
  G_SIGNAL_RUN_LAST,
                G_STRUCT_OFFSET (CdkWindowClass, to_embedder)((glong) __builtin_offsetof(CdkWindowClass, to_embedder)),
  NULL((void*)0), NULL((void*)0),
  _cdk_marshal_VOID__DOUBLE_DOUBLE_POINTER_POINTER,
  G_TYPE_NONE((GType) ((1) << (2))),
  4,
  G_TYPE_DOUBLE((GType) ((15) << (2))),
  G_TYPE_DOUBLE((GType) ((15) << (2))),
  G_TYPE_POINTER((GType) ((17) << (2))),
  G_TYPE_POINTER((GType) ((17) << (2))));
g_signal_set_va_marshaller (signals[TO_EMBEDDER],
                            G_OBJECT_CLASS_TYPE (object_class)((((GTypeClass*) (object_class))->g_type)),
                            _cdk_marshal_VOID__DOUBLE_DOUBLE_POINTER_POINTERv);

/**
 * CdkWindow::from-embedder:
 * @window: the offscreen window on which the signal is emitted
 * @embedder_x: x coordinate in the embedder window
 * @embedder_y: y coordinate in the embedder window
 * @offscreen_x: (out) (type double): return location for the x
 *     coordinate in the offscreen window
 * @offscreen_y: (out) (type double): return location for the y
 *     coordinate in the offscreen window
 *
 * The ::from-embedder signal is emitted to translate coordinates
 * in the embedder of an offscreen window to the offscreen window.
 *
 * See also #CdkWindow::to-embedder.
 *
 * Since: 2.18
 */
signals[FROM_EMBEDDER] =
  g_signal_new (g_intern_static_string ("from-embedder"),
  G_OBJECT_CLASS_TYPE (object_class)((((GTypeClass*) (object_class))->g_type)),
  G_SIGNAL_RUN_LAST,
                G_STRUCT_OFFSET (CdkWindowClass, from_embedder)((glong) __builtin_offsetof(CdkWindowClass, from_embedder)),
  NULL((void*)0), NULL((void*)0),
  _cdk_marshal_VOID__DOUBLE_DOUBLE_POINTER_POINTER,
  G_TYPE_NONE((GType) ((1) << (2))),
  4,
  G_TYPE_DOUBLE((GType) ((15) << (2))),
  G_TYPE_DOUBLE((GType) ((15) << (2))),
  G_TYPE_POINTER((GType) ((17) << (2))),
  G_TYPE_POINTER((GType) ((17) << (2))));
g_signal_set_va_marshaller (signals[FROM_EMBEDDER],
                            G_OBJECT_CLASS_TYPE (object_class)((((GTypeClass*) (object_class))->g_type)),
                            _cdk_marshal_VOID__DOUBLE_DOUBLE_POINTER_POINTERv);

/**
 * CdkWindow::create-surface:
 * @window: the offscreen window on which the signal is emitted
 * @width: the width of the offscreen surface to create
 * @height: the height of the offscreen surface to create
 *
 * The ::create-surface signal is emitted when an offscreen window
 * needs its surface (re)created, which happens either when the
 * window is first drawn to, or when the window is being
 * resized. The first signal handler that returns a non-%NULL
 * surface will stop any further signal emission, and its surface
 * will be used.
 *
 * Note that it is not possible to access the window's previous
 * surface from within any callback of this signal. Calling
 * cdk_offscreen_window_get_surface() will lead to a crash.
 *
 * Returns: the newly created #cairo_surface_t for the offscreen window
 *
 * Since: 3.0
 */
signals[CREATE_SURFACE] =
  g_signal_new (g_intern_static_string ("create-surface"),
                G_OBJECT_CLASS_TYPE (object_class)((((GTypeClass*) (object_class))->g_type)),
                G_SIGNAL_RUN_LAST,
                G_STRUCT_OFFSET (CdkWindowClass, create_surface)((glong) __builtin_offsetof(CdkWindowClass, create_surface)),
                create_surface_accumulator, NULL((void*)0),
                _cdk_marshal_BOXED__INT_INT,
                CAIRO_GOBJECT_TYPE_SURFACEcairo_gobject_surface_get_type (),
                2,
                G_TYPE_INT((GType) ((6) << (2))),
                G_TYPE_INT((GType) ((6) << (2))));
g_signal_set_va_marshaller (signals[CREATE_SURFACE],
                            G_OBJECT_CLASS_TYPE (object_class)((((GTypeClass*) (object_class))->g_type)),
                            _cdk_marshal_BOXED__INT_INTv);

/**
 * CdkWindow::moved-to-rect:
 * @window: the #CdkWindow that moved
 * @flipped_rect: (nullable): the position of @window after any possible
 *                flipping or %NULL if the backend can't obtain it
 * @final_rect: (nullable): the final position of @window or %NULL if the
 *              backend can't obtain it
 * @flipped_x: %TRUE if the anchors were flipped horizontally
 * @flipped_y: %TRUE if the anchors were flipped vertically
 *
 * Emitted when the position of @window is finalized after being moved to a
 * destination rectangle.
 *
 * @window might be flipped over the destination rectangle in order to keep
 * it on-screen, in which case @flipped_x and @flipped_y will be set to %TRUE
 * accordingly.
 *
 * @flipped_rect is the ideal position of @window after any possible
 * flipping, but before any possible sliding. @final_rect is @flipped_rect,
 * but possibly translated in the case that flipping is still ineffective in
 * keeping @window on-screen.
 *
 * Since: 3.22
 * Stability: Private
 */
signals[MOVED_TO_RECT] =
  g_signal_new (g_intern_static_string ("moved-to-rect"),
                G_OBJECT_CLASS_TYPE (object_class)((((GTypeClass*) (object_class))->g_type)),
                G_SIGNAL_RUN_FIRST,
                0,
                NULL((void*)0),
                NULL((void*)0),
                _cdk_marshal_VOID__POINTER_POINTER_BOOLEAN_BOOLEAN,
                G_TYPE_NONE((GType) ((1) << (2))),
                4,
                G_TYPE_POINTER((GType) ((17) << (2))),
                G_TYPE_POINTER((GType) ((17) << (2))),
                G_TYPE_BOOLEAN((GType) ((5) << (2))),
                G_TYPE_BOOLEAN((GType) ((5) << (2))));
g_signal_set_va_marshaller (signals[MOVED_TO_RECT],
                            G_OBJECT_CLASS_TYPE (object_class)((((GTypeClass*) (object_class))->g_type)),
                            _cdk_marshal_VOID__POINTER_POINTER_BOOLEAN_BOOLEANv);
535}

537static void
538seat_removed_cb (CdkDisplay *display G_GNUC_UNUSED__attribute__ ((__unused__)),
               CdkSeat    *seat,
               CdkWindow  *window)
541{
CdkDevice *device = cdk_seat_get_pointer (seat);

window->devices_inside = g_list_remove (window->devices_inside, device);
g_hash_table_remove (window->device_cursor, device);

if (window->device_events)
  g_hash_table_remove (window->device_events, device);
549}

551static void
552cdk_window_finalize (GObject *object)
553{
CdkWindow *window = CDK_WINDOW (object)((((CdkWindow*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((cdk_window_get_type ()))))));

g_signal_handlers_disconnect_by_func (cdk_window_get_display (window),g_signal_handlers_disconnect_matched ((cdk_window_get_display
 (window)), (GSignalMatchType) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA
), 0, 0, ((void*)0), (seat_removed_cb), (window))
                                      seat_removed_cb, window)g_signal_handlers_disconnect_matched ((cdk_window_get_display
 (window)), (GSignalMatchType) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA
), 0, 0, ((void*)0), (seat_removed_cb), (window));

if (!CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  {
    if (CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type) != CDK_WINDOW_FOREIGN)
{
 g_warning ("losing last reference to undestroyed window");
 _cdk_window_destroy (window, FALSE(0));
}
    else
/* We use TRUE here, to keep us from actually calling
* XDestroyWindow() on the window
*/
_cdk_window_destroy (window, TRUE(!(0)));
  }

if (window->synthesized_crossing_event_id)
  {
    g_source_remove (window->synthesized_crossing_event_id);
    window->synthesized_crossing_event_id = 0;
  }

if (window->impl)
  {
    g_object_unref (window->impl);
    window->impl = NULL((void*)0);
  }

if (window->impl_window != window)
  {
    g_object_unref (window->impl_window);
    window->impl_window = NULL((void*)0);
  }

if (window->shape)
  cairo_region_destroy (window->shape);

if (window->input_shape)
  cairo_region_destroy (window->input_shape);

if (window->cursor)
  g_object_unref (window->cursor);

if (window->device_cursor)
  g_hash_table_destroy (window->device_cursor);

if (window->device_events)
  g_hash_table_destroy (window->device_events);

if (window->source_event_masks)
  g_hash_table_destroy (window->source_event_masks);

if (window->devices_inside)
  g_list_free (window->devices_inside);

if (window->opaque_region)
  cairo_region_destroy (window->opaque_region);

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

618static void
619cdk_window_set_property (GObject      *object,
                       guint         prop_id,
                       const GValue *value,
                       GParamSpec   *pspec)
623{
CdkWindow *window = (CdkWindow *)object;

switch (prop_id)
  {
  case PROP_CURSOR:
    cdk_window_set_cursor (window, g_value_get_object (value));
    break;

  default:
    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec)do { GObject *_glib__object = (GObject*) ((object)); GParamSpec
 *_glib__pspec = (GParamSpec*) ((pspec)); guint _glib__property_id
 = ((prop_id)); g_warning ("%s:%d: invalid %s id %u for \"%s\" of type '%s' in '%s'"
, "cdkwindow.c", 633, ("property"), _glib__property_id, _glib__pspec
->name, g_type_name ((((((GTypeClass*) (((GTypeInstance*) (
_glib__pspec))->g_class))->g_type)))), (g_type_name (((
(((GTypeClass*) (((GTypeInstance*) (_glib__object))->g_class
))->g_type)))))); } while (0);
    break;
  }
636}

638static void
639cdk_window_get_property (GObject    *object,
                       guint       prop_id,
                       GValue     *value,
                       GParamSpec *pspec)
643{
CdkWindow *window = (CdkWindow *) object;

switch (prop_id)
  {
  case PROP_CURSOR:
    g_value_set_object (value, cdk_window_get_cursor (window));
    break;

  default:
    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec)do { GObject *_glib__object = (GObject*) ((object)); GParamSpec
 *_glib__pspec = (GParamSpec*) ((pspec)); guint _glib__property_id
 = ((prop_id)); g_warning ("%s:%d: invalid %s id %u for \"%s\" of type '%s' in '%s'"
, "cdkwindow.c", 653, ("property"), _glib__property_id, _glib__pspec
->name, g_type_name ((((((GTypeClass*) (((GTypeInstance*) (
_glib__pspec))->g_class))->g_type)))), (g_type_name (((
(((GTypeClass*) (((GTypeInstance*) (_glib__object))->g_class
))->g_type)))))); } while (0);
    break;
  }
656}

658static gboolean
659cdk_window_is_offscreen (CdkWindow *window)
660{
return window->window_type == CDK_WINDOW_OFFSCREEN;
662}

664static gboolean
665cdk_window_is_subsurface (CdkWindow *window)
666{
 return window->window_type == CDK_WINDOW_SUBSURFACE;
668}

670static CdkWindow *
671cdk_window_get_impl_window (CdkWindow *window)
672{
return window->impl_window;
674}

676CdkWindow *
677_cdk_window_get_impl_window (CdkWindow *window)
678{
return cdk_window_get_impl_window (window);
680}

682static gboolean
683cdk_window_has_impl (CdkWindow *window)
684{
return window->impl_window == window;
686}

688static gboolean
689cdk_window_is_toplevel (CdkWindow *window)
690{
return
  window->parent == NULL((void*)0) ||
  window->parent->window_type == CDK_WINDOW_ROOT;
694}

696gboolean
697_cdk_window_has_impl (CdkWindow *window)
698{
return cdk_window_has_impl (window);
700}

702static gboolean
703cdk_window_has_no_impl (CdkWindow *window)
704{
return window->impl_window != window;
706}

708static void
709remove_sibling_overlapped_area (CdkWindow *window,
		cairo_region_t *region)
711{
CdkWindow *parent;
CdkWindow *sibling;
cairo_region_t *child_region;
CdkRectangle r;
GList *l;
cairo_region_t *shape;

parent = window->parent;

if (cdk_window_is_toplevel (window))
  return;

/* Convert from from window coords to parent coords */
cairo_region_translate (region, window->x, window->y);

for (l = parent->children; l; l = l->next)
  {
    sibling = l->data;

    if (sibling == window)
break;

    if (!CDK_WINDOW_IS_MAPPED (sibling)(((sibling)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0) || sibling->input_only || sibling->composited)
continue;

    /* Ignore offscreen children, as they don't draw in their parent and
     * don't take part in the clipping */
    if (cdk_window_is_offscreen (sibling))
continue;

    r.x = sibling->x;
    r.y = sibling->y;
    r.width = sibling->width;
    r.height = sibling->height;

    child_region = cairo_region_create_rectangle (&r);

    if (sibling->shape)
{
 /* Adjust shape region to parent window coords */
 cairo_region_translate (sibling->shape, sibling->x, sibling->y);
 cairo_region_intersect (child_region, sibling->shape);
 cairo_region_translate (sibling->shape, -sibling->x, -sibling->y);
}
    else if (window->window_type == CDK_WINDOW_FOREIGN)
{
 shape = CDK_WINDOW_IMPL_GET_CLASS (sibling)((((CdkWindowImplClass*) (((GTypeInstance*) ((sibling)))->
g_class))))->get_shape (sibling);
 if (shape)
   {
     cairo_region_intersect (child_region, shape);
     cairo_region_destroy (shape);
   }
}

    cairo_region_subtract (region, child_region);
    cairo_region_destroy (child_region);
  }

remove_sibling_overlapped_area (parent, region);

/* Convert back to window coords */
cairo_region_translate (region, -window->x, -window->y);
774}

776static void
777remove_child_area (CdkWindow *window,
   gboolean for_input,
   cairo_region_t *region)
780{
CdkWindow *child;
cairo_region_t *child_region;
CdkRectangle r;
GList *l;
cairo_region_t *shape;

for (l = window->children; l; l = l->next)
  {
    child = l->data;

    /* If region is empty already, no need to do
anything potentially costly */
    if (cairo_region_is_empty (region))
break;

    if (!CDK_WINDOW_IS_MAPPED (child)(((child)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0) || child->input_only || child->composited)
continue;

    /* Ignore offscreen children, as they don't draw in their parent and
     * don't take part in the clipping */
    if (cdk_window_is_offscreen (child))
continue;

    r.x = child->x;
    r.y = child->y;
    r.width = child->width;
    r.height = child->height;

    /* Bail early if child totally outside region */
    if (cairo_region_contains_rectangle (region, &r) == CAIRO_REGION_OVERLAP_OUT)
continue;

    child_region = cairo_region_create_rectangle (&r);

    if (child->shape)
{
 /* Adjust shape region to parent window coords */
 cairo_region_translate (child->shape, child->x, child->y);
 cairo_region_intersect (child_region, child->shape);
 cairo_region_translate (child->shape, -child->x, -child->y);
}
    else if (window->window_type == CDK_WINDOW_FOREIGN)
{
 shape = CDK_WINDOW_IMPL_GET_CLASS (child)((((CdkWindowImplClass*) (((GTypeInstance*) ((child)))->g_class
))))->get_shape (child);
 if (shape)
   {
     cairo_region_intersect (child_region, shape);
     cairo_region_destroy (shape);
   }
}

    if (for_input)
{
 if (child->input_shape)
   cairo_region_intersect (child_region, child->input_shape);
 else if (window->window_type == CDK_WINDOW_FOREIGN)
   {
     shape = CDK_WINDOW_IMPL_GET_CLASS (child)((((CdkWindowImplClass*) (((GTypeInstance*) ((child)))->g_class
))))->get_input_shape (child);
     if (shape)
{
  cairo_region_intersect (child_region, shape);
  cairo_region_destroy (shape);
}
   }
}

    cairo_region_subtract (region, child_region);
    cairo_region_destroy (child_region);
  }
850}

852static CdkVisibilityState
853effective_visibility (CdkWindow *window)
854{
CdkVisibilityState native;

if (!cdk_window_is_viewable (window))
  return CDK_VISIBILITY_NOT_VIEWABLE3;

native = window->impl_window->native_visibility;

if (native == CDK_VISIBILITY_FULLY_OBSCURED ||
    window->visibility == CDK_VISIBILITY_FULLY_OBSCURED)
  return CDK_VISIBILITY_FULLY_OBSCURED;
else if (native == CDK_VISIBILITY_UNOBSCURED)
  return window->visibility;
else /* native PARTIAL, private partial or unobscured  */
  return CDK_VISIBILITY_PARTIAL;
869}

871static void
872cdk_window_update_visibility (CdkWindow *window)
873{
CdkVisibilityState new_visibility;
CdkEvent *event;

new_visibility = effective_visibility (window);

if (new_visibility != window->effective_visibility)
  {
    window->effective_visibility = new_visibility;

    if (new_visibility != CDK_VISIBILITY_NOT_VIEWABLE3 &&
 window->event_mask & CDK_VISIBILITY_NOTIFY_MASK)
{
 event = _cdk_make_event (window, CDK_VISIBILITY_NOTIFY,
		   NULL((void*)0), FALSE(0));
 event->visibility.state = new_visibility;
}
  }
891}

893static void
894cdk_window_update_visibility_recursively (CdkWindow *window,
			  CdkWindow *only_for_impl)
896{
CdkWindow *child;
GList *l;

cdk_window_update_visibility (window);
for (l = window->children; l != NULL((void*)0); l = l->next)
  {
    child = l->data;
    if ((only_for_impl == NULL((void*)0)) ||
 (only_for_impl == child->impl_window))
cdk_window_update_visibility_recursively (child, only_for_impl);
  }
908}

910static gboolean
911should_apply_clip_as_shape (CdkWindow *window)
912{
return
  cdk_window_has_impl (window) &&
  /* Not for offscreens */
  !cdk_window_is_offscreen (window) &&
  /* or for non-shaped toplevels */
  (!cdk_window_is_toplevel (window) ||
   window->shape != NULL((void*)0) || window->applied_shape) &&
  /* or for foreign windows */
  window->window_type != CDK_WINDOW_FOREIGN &&
  /* or for the root window */
  window->window_type != CDK_WINDOW_ROOT;
924}

926static void
927apply_shape (CdkWindow *window,
    cairo_region_t *region)
929{
CdkWindowImplClass *impl_class;

/* We trash whether we applied a shape so that
   we can avoid unsetting it many times, which
   could happen in e.g. apply_clip_as_shape as
   windows get resized */
impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));
if (region)
  impl_class->shape_combine_region (window,
		      region, 0, 0);
else if (window->applied_shape)
  impl_class->shape_combine_region (window,
		      NULL((void*)0), 0, 0);

window->applied_shape = region != NULL((void*)0);
945}

947static gboolean
948region_rect_equal (const cairo_region_t *region,
                 const CdkRectangle *rect)
950{
  CdkRectangle extents;

  if (cairo_region_num_rectangles (region) != 1)
      return FALSE(0);

  cairo_region_get_extents (region, &extents);

  return extents.x == rect->x &&
      extents.y == rect->y &&
      extents.width == rect->width &&
      extents.height == rect->height;
962}

964static void
965apply_clip_as_shape (CdkWindow *window)
966{
CdkRectangle r;
cairo_region_t *region;

r.x = r.y = 0;
r.width = window->width;
r.height = window->height;

region = cairo_region_copy (window->clip_region);
remove_sibling_overlapped_area (window, region);

/* We only apply the clip region if would differ
   from the actual clip region implied by the size
   of the window. This is to avoid unneccessarily
   adding meaningless shapes to all native subwindows */
if (!region_rect_equal (region, &r))
  apply_shape (window, region);
else
  apply_shape (window, NULL((void*)0));

cairo_region_destroy (region);
987}

989static void
990recompute_visible_regions_internal (CdkWindow *private,
		    gboolean   recalculate_clip,
		    gboolean   recalculate_children)
993{
CdkRectangle r;
GList *l;
CdkWindow *child;
cairo_region_t *new_clip;
gboolean clip_region_changed;
gboolean abs_pos_changed;
int old_abs_x, old_abs_y;

old_abs_x = private->abs_x;
old_abs_y = private->abs_y;

/* Update absolute position */
if ((cdk_window_has_impl (private) &&
     private->window_type != CDK_WINDOW_SUBSURFACE) ||
    (cdk_window_is_toplevel (private) &&
     private->window_type == CDK_WINDOW_SUBSURFACE))
  {
    /* Native windows and toplevel subsurfaces start here */
    private->abs_x = 0;
    private->abs_y = 0;
  }
else
  {
    private->abs_x = private->parent->abs_x + private->x;
    private->abs_y = private->parent->abs_y + private->y;
  }

abs_pos_changed =
  private->abs_x != old_abs_x ||
  private->abs_y != old_abs_y;

/* Update clip region based on:
 * parent clip
 * window size/position
 */
clip_region_changed = FALSE(0);
if (recalculate_clip)
  {
    if (private->viewable)
{
 /* Calculate visible region (sans children) in parent window coords */
 r.x = private->x;
 r.y = private->y;
 r.width = private->width;
 r.height = private->height;
 new_clip = cairo_region_create_rectangle (&r);

 if (!cdk_window_is_toplevel (private))
   cairo_region_intersect (new_clip, private->parent->clip_region);

 /* Convert from parent coords to window coords */
 cairo_region_translate (new_clip, -private->x, -private->y);

 if (should_apply_clip_as_shape (private) && private->shape)
   cairo_region_intersect (new_clip, private->shape);
}
    else
 new_clip = cairo_region_create ();

    if (private->clip_region == NULL((void*)0) ||
 !cairo_region_equal (private->clip_region, new_clip))
clip_region_changed = TRUE(!(0));

    if (private->clip_region)
cairo_region_destroy (private->clip_region);
    private->clip_region = new_clip;
  }

if (clip_region_changed)
  {
    CdkVisibilityState visibility;
    gboolean fully_visible;

    if (cairo_region_is_empty (private->clip_region))
visibility = CDK_VISIBILITY_FULLY_OBSCURED;
    else
      {
        if (private->shape)
          {
     fully_visible = cairo_region_equal (private->clip_region,
                                       private->shape);
          }
        else
          {
     r.x = 0;
     r.y = 0;
     r.width = private->width;
     r.height = private->height;
     fully_visible = region_rect_equal (private->clip_region, &r);
   }

 if (fully_visible)
   visibility = CDK_VISIBILITY_UNOBSCURED;
 else
   visibility = CDK_VISIBILITY_PARTIAL;
}

    if (private->visibility != visibility)
{
 private->visibility = visibility;
 cdk_window_update_visibility (private);
}
  }

/* Update all children, recursively (except for root, where children are not exact). */
if ((abs_pos_changed || clip_region_changed || recalculate_children) &&
    private->window_type != CDK_WINDOW_ROOT)
  {
    for (l = private->children; l; l = l->next)
{
 child = l->data;
 /* Only recalculate clip if the the clip region changed, otherwise
  * there is no way the child clip region could change (its has not e.g. moved)
  * Except if recalculate_children is set to force child updates
  */
 recompute_visible_regions_internal (child,
			      recalculate_clip && (clip_region_changed || recalculate_children),
			      FALSE(0));
}
  }
1114}

1116/* Call this when private has changed in one or more of these ways:
*  size changed
*  window moved
*  new window added
*  stacking order of window changed
*  child deleted
*
* It will recalculate abs_x/y and the clip regions
*
* Unless the window didn’t change stacking order or size/pos, pass in TRUE
* for recalculate_siblings. (Mostly used internally for the recursion)
*
* If a child window was removed (and you can’t use that child for
* recompute_visible_regions), pass in TRUE for recalculate_children on the parent
*/
1131static void
1132recompute_visible_regions (CdkWindow *private,
	   gboolean recalculate_children)
1134{
CdkWindow *toplevel;

toplevel = cdk_window_get_toplevel (private);
toplevel->geometry_dirty = TRUE(!(0));

recompute_visible_regions_internal (private,
		      TRUE(!(0)),
		      recalculate_children);
1143}

1145static void
1146cdk_window_clear_old_updated_area (CdkWindow *window)
1147{
int i;

for (i = 0; i < 2; i++)
  {
    if (window->old_updated_area[i])
      {
        cairo_region_destroy (window->old_updated_area[i]);
        window->old_updated_area[i] = NULL((void*)0);
      }
  }
1158}

1160static void
1161cdk_window_append_old_updated_area (CdkWindow *window,
                                  cairo_region_t *region)
1163{
if (window->old_updated_area[1])
  cairo_region_destroy (window->old_updated_area[1]);
window->old_updated_area[1] = window->old_updated_area[0];
window->old_updated_area[0] = cairo_region_reference (region);
1168}

1170void
1171_cdk_window_update_size (CdkWindow *window)
1172{
cdk_window_clear_old_updated_area (window);
recompute_visible_regions (window, FALSE(0));
1175}

1177/* Find the native window that would be just above "child"
* in the native stacking order if “child” was a native window
* (it doesn’t have to be native). If there is no such native
* window inside this native parent then NULL is returned.
* If child is NULL, find lowest native window in parent.
*/
1183static CdkWindow *
1184find_native_sibling_above_helper (CdkWindow *parent,
		  CdkWindow *child)
1186{
CdkWindow *w;
GList *l;

if (child)
  {
    l = g_list_find (parent->children, child);
    g_assert (l != NULL)do { if (l != ((void*)0)) ; else g_assertion_message_expr ("Cdk"
, "cdkwindow.c", 1193, ((const char*) (__func__)), "l != NULL"
); } while (0); /* Better be a child of its parent... */
    l = l->prev; /* Start looking at the one above the child */
  }
else
  l = g_list_last (parent->children);

for (; l != NULL((void*)0); l = l->prev)
  {
    w = l->data;

    if (cdk_window_has_impl (w))
return w;

    g_assert (parent != w)do { if (parent != w) ; else g_assertion_message_expr ("Cdk",
 "cdkwindow.c", 1206, ((const char*) (__func__)), "parent != w"
); } while (0);
    w = find_native_sibling_above_helper (w, NULL((void*)0));
    if (w)
return w;
  }

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


1216static CdkWindow *
1217find_native_sibling_above (CdkWindow *parent,
	   CdkWindow *child)
1219{
CdkWindow *w;

if (!parent)
  return NULL((void*)0);

w = find_native_sibling_above_helper (parent, child);
if (w)
  return w;

if (cdk_window_has_impl (parent))
  return NULL((void*)0);
else
  return find_native_sibling_above (parent->parent, parent);
1233}

1235static CdkEventMask
1236get_native_device_event_mask (CdkWindow *private,
                            CdkDevice *device)
1238{
CdkEventMask event_mask;

if (device)
  event_mask = GPOINTER_TO_INT (g_hash_table_lookup (private->device_events, device))((gint) (glong) (g_hash_table_lookup (private->device_events
, device)));
else
  event_mask = private->event_mask;

if (private->window_type == CDK_WINDOW_ROOT ||
    private->window_type == CDK_WINDOW_FOREIGN)
  return event_mask;
else
  {
    CdkEventMask mask;

    /* Do whatever the app asks to, since the app
     * may be asking for weird things for native windows,
     * but don't use motion hints as that may affect non-native
     * child windows that don't want it. Also, we need to
     * set all the app-specified masks since they will be picked
     * up by any implicit grabs (i.e. if they were not set as
     * native we would not get the events we need). */
    mask = private->event_mask & ~CDK_POINTER_MOTION_HINT_MASK;

    /* We need thse for all native windows so we can
emulate events on children: */
    mask |=
CDK_EXPOSURE_MASK |
CDK_VISIBILITY_NOTIFY_MASK |
CDK_ENTER_NOTIFY_MASK | CDK_LEAVE_NOTIFY_MASK;

    /* Additionally we select for pointer and button events
     * for toplevels as we need to get these to emulate
     * them for non-native subwindows. Even though we don't
     * select on them for all native windows we will get them
     * as the events are propagated out to the first window
     * that select for them.
     * Not selecting for button press on all windows is an
     * important thing, because in X only one client can do
     * so, and we don't want to unexpectedly prevent another
     * client from doing it.
     *
     * We also need to do the same if the app selects for button presses
     * because then we will get implicit grabs for this window, and the
     * event mask used for that grab is based on the rest of the mask
     * for the window, but we might need more events than this window
     * lists due to some non-native child window.
     */
    if (cdk_window_is_toplevel (private) ||
        mask & CDK_BUTTON_PRESS_MASK)
      mask |=
        CDK_TOUCH_MASK |
        CDK_POINTER_MOTION_MASK |
        CDK_BUTTON_PRESS_MASK | CDK_BUTTON_RELEASE_MASK |
        CDK_SCROLL_MASK;

    return mask;
  }
1296}

1298static CdkEventMask
1299get_native_grab_event_mask (CdkEventMask grab_mask)
1300{
/* Similar to the above but for pointer events only */
return
  CDK_POINTER_MOTION_MASK |
  CDK_BUTTON_PRESS_MASK | CDK_BUTTON_RELEASE_MASK |
  CDK_ENTER_NOTIFY_MASK | CDK_LEAVE_NOTIFY_MASK |
  CDK_SCROLL_MASK |
  (grab_mask &
   ~CDK_POINTER_MOTION_HINT_MASK);
1309}

1311static CdkEventMask
1312get_native_event_mask (CdkWindow *private)
1313{
return get_native_device_event_mask (private, NULL((void*)0));
1315}

1317/* Puts the native window in the right order wrt the other native windows
* in the hierarchy, given the position it has in the client side data.
* This is useful if some operation changed the stacking order.
* This calls assumes the native window is now topmost in its native parent.
*/
1322static void
1323sync_native_window_stack_position (CdkWindow *window)
1324{
CdkWindow *above;
CdkWindowImplClass *impl_class;
GList listhead = {0};

impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));

above = find_native_sibling_above (window->parent, window);
if (above)
  {
    listhead.data = window;
    impl_class->restack_under (above, &listhead);
  }
1337}

1339/**
* cdk_window_new: (constructor)
* @parent: (allow-none): a #CdkWindow, or %NULL to create the window as a child of
*   the default root window for the default display.
* @attributes: attributes of the new window
* @attributes_mask: (type CdkWindowAttributesType): mask indicating which
*   fields in @attributes are valid
*
* Creates a new #CdkWindow using the attributes from
* @attributes. See #CdkWindowAttr and #CdkWindowAttributesType for
* more details.  Note: to use this on displays other than the default
* display, @parent must be specified.
*
* Returns: (transfer full): the new #CdkWindow
**/
1354CdkWindow*
1355cdk_window_new (CdkWindow     *parent,
CdkWindowAttr *attributes,
gint           attributes_mask)
1358{
CdkWindow *window;
CdkScreen *screen;
CdkDisplay *display;
int x, y;
gboolean native;
CdkEventMask event_mask;
CdkWindow *real_parent;

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

if (!parent)
  {
    screen = cdk_screen_get_default ();
    parent = cdk_screen_get_root_window (screen);
  }
else
  screen = cdk_window_get_screen (parent);

g_return_val_if_fail (CDK_IS_WINDOW (parent), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((parent)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (parent)"); return (((void*)0)); } } while
 (0);

if (CDK_WINDOW_DESTROYED (parent)(((CdkWindow *)(parent))->destroyed))
  {
    g_warning ("cdk_window_new(): parent is destroyed");
    return NULL((void*)0);
  }

if (attributes_mask & CDK_WA_VISUAL)
  {
    g_return_val_if_fail (cdk_visual_get_screen (attributes->visual) == screen, NULL)do { if ((cdk_visual_get_screen (attributes->visual) == screen
)) { } else { g_return_if_fail_warning ("Cdk", ((const char*)
 (__func__)), "cdk_visual_get_screen (attributes->visual) == screen"
); return (((void*)0)); } } while (0);
  }

display = cdk_screen_get_display (screen);

window = _cdk_display_create_window (display);

/* Windows with a foreign parent are treated as if they are children
 * of the root window, except for actual creation.
 */
real_parent = parent;
if (CDK_WINDOW_TYPE (parent)((((CdkWindow *)(parent)))->window_type) == CDK_WINDOW_FOREIGN)
  parent = cdk_screen_get_root_window (screen);

window->parent = parent;

window->accept_focus = TRUE(!(0));
window->focus_on_map = TRUE(!(0));
window->event_compression = TRUE(!(0));

if (attributes_mask & CDK_WA_X)
  x = attributes->x;
else
  x = 0;

if (attributes_mask & CDK_WA_Y)
  y = attributes->y;
else
  y = 0;

window->x = x;
window->y = y;
window->width = (attributes->width > 1) ? (attributes->width) : (1);
window->height = (attributes->height > 1) ? (attributes->height) : (1);
window->alpha = 255;

if (attributes->wclass == CDK_INPUT_ONLY)
  {
    /* Backwards compatiblity - we've always ignored
     * attributes->window_type for input-only windows
     * before
     */
    if (CDK_WINDOW_TYPE (parent)((((CdkWindow *)(parent)))->window_type) == CDK_WINDOW_ROOT)
window->window_type = CDK_WINDOW_TEMP;
    else
window->window_type = CDK_WINDOW_CHILD;
  }
else
  window->window_type = attributes->window_type;

/* Sanity checks */
switch (window->window_type)
  {
  case CDK_WINDOW_TOPLEVEL:
  case CDK_WINDOW_TEMP:
  case CDK_WINDOW_OFFSCREEN:
    if (CDK_WINDOW_TYPE (parent)((((CdkWindow *)(parent)))->window_type) != CDK_WINDOW_ROOT)
g_warning (G_STRLOC"cdkwindow.c" ":" "1444" "Toplevel windows must be created as children of\n"
   "of a window of type CDK_WINDOW_ROOT or CDK_WINDOW_FOREIGN");
    break;
  case CDK_WINDOW_SUBSURFACE:
1448#ifdef CDK_WINDOWING_WAYLAND
    if (!CDK_IS_WAYLAND_DISPLAY (display)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) (
(display)); GType __t = ((cdk_wayland_display_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; })))))
      {
        g_warning (G_STRLOC"cdkwindow.c" ":" "1451" "Subsurface windows can only be used on Wayland");
        return NULL((void*)0);
      }
1454#endif
    break;
  case CDK_WINDOW_CHILD:
    break;
  default:
    g_warning (G_STRLOC"cdkwindow.c" ":" "1459" "cannot make windows of type %d", window->window_type);
    return NULL((void*)0);
  }

if (attributes_mask & CDK_WA_VISUAL)
  window->visual = attributes->visual;
else
  window->visual = cdk_screen_get_system_visual (screen);

window->event_mask = attributes->event_mask;

if (attributes->wclass == CDK_INPUT_OUTPUT)
  {
    window->input_only = FALSE(0);
    window->depth = window->visual->depth;

    /* XXX: Cache this somehow? */
    window->background = cairo_pattern_create_rgba (0, 0, 0, 0);
  }
else
  {
    window->depth = 0;
    window->input_only = TRUE(!(0));
  }

window->parent->children = g_list_concat (&window->children_list_node, window->parent->children);

if (window->parent->window_type == CDK_WINDOW_ROOT)
  {
    CdkFrameClock *frame_clock = g_object_new (CDK_TYPE_FRAME_CLOCK_IDLE(cdk_frame_clock_idle_get_type ()), NULL((void*)0));
    cdk_window_set_frame_clock (window, frame_clock);
    g_object_unref (frame_clock);
  }

native = FALSE(0);
if (window->parent->window_type == CDK_WINDOW_ROOT)
  native = TRUE(!(0)); /* Always use native windows for toplevels */

1497#ifdef CDK_WINDOWING_WAYLAND
if (window->window_type == CDK_WINDOW_SUBSURFACE)
  native = TRUE(!(0)); /* Always use native windows for subsurfaces as well */
1500#endif

if (cdk_window_is_offscreen (window))
  {
    _cdk_offscreen_window_new (window, attributes, attributes_mask);
    window->impl_window = window;
  }
else if (native)
  {
    event_mask = get_native_event_mask (window);

    /* Create the impl */
    _cdk_display_create_window_impl (display, window, real_parent, screen, event_mask, attributes, attributes_mask);
    window->impl_window = window;

    parent->impl_window->native_children = g_list_prepend (parent->impl_window->native_children, window);

    /* This will put the native window topmost in the native parent, which may
     * be wrong wrt other native windows in the non-native hierarchy, so restack */
    if (!_cdk_window_has_impl (real_parent))
sync_native_window_stack_position (window);
  }
else
  {
    window->impl_window = g_object_ref (window->parent->impl_window)((__typeof__ (window->parent->impl_window)) (g_object_ref
) (window->parent->impl_window));
    window->impl = g_object_ref (window->impl_window->impl)((__typeof__ (window->impl_window->impl)) (g_object_ref
) (window->impl_window->impl));
  }

recompute_visible_regions (window, FALSE(0));

cdk_window_set_cursor (window, ((attributes_mask & CDK_WA_CURSOR) ?
		  (attributes->cursor) :
		  NULL((void*)0)));

g_signal_connect (cdk_window_get_display (parent), "seat-removed",g_signal_connect_data ((cdk_window_get_display (parent)), ("seat-removed"
), (((GCallback) (seat_removed_cb))), (window), ((void*)0), (
GConnectFlags) 0)
                  G_CALLBACK (seat_removed_cb), window)g_signal_connect_data ((cdk_window_get_display (parent)), ("seat-removed"
), (((GCallback) (seat_removed_cb))), (window), ((void*)0), (
GConnectFlags) 0);

if ((_cdk_gl_flags & (CDK_GL_ALWAYS | CDK_GL_DISABLE)) == CDK_GL_ALWAYS)
  {
    GError *error = NULL((void*)0);

    if (cdk_window_get_paint_gl_context (window, &error) == NULL((void*)0))
      {
        g_warning ("Unable to force GL enabled: %s", error->message);
        g_error_free (error);
      }
  }

return window;
1549}

1551static gboolean
1552is_parent_of (CdkWindow *parent,
     CdkWindow *child)
1554{
CdkWindow *w;

w = child;
while (w != NULL((void*)0))
  {
    if (w == parent)
return TRUE(!(0));

    w = cdk_window_get_parent (w);
  }

return FALSE(0);
1567}

1569static void
1570change_impl (CdkWindow *private,
    CdkWindow *impl_window,
    CdkWindowImpl *new)
1573{
GList *l;
CdkWindow *child;
CdkWindowImpl *old_impl;
CdkWindow *old_impl_window;

old_impl = private->impl;
old_impl_window = private->impl_window;
if (private != impl_window)
  private->impl_window = g_object_ref (impl_window)((__typeof__ (impl_window)) (g_object_ref) (impl_window));
else
  private->impl_window = private;
private->impl = g_object_ref (new)((__typeof__ (new)) (g_object_ref) (new));
if (old_impl_window != private)
  g_object_unref (old_impl_window);
g_object_unref (old_impl);

for (l = private->children; l != NULL((void*)0); l = l->next)
  {
    child = l->data;

    if (child->impl == old_impl)
change_impl (child, impl_window, new);
    else
      {
        /* The child is a native, update native_children */
        old_impl_window->native_children =
          g_list_remove (old_impl_window->native_children, child);
        impl_window->native_children =
          g_list_prepend (impl_window->native_children, child);
      }
  }
1605}

1607static void
1608reparent_to_impl (CdkWindow *private)
1609{
GList *l;
CdkWindow *child;
gboolean show;
CdkWindowImplClass *impl_class;

impl_class = CDK_WINDOW_IMPL_GET_CLASS (private->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((private->impl
)))->g_class))));

/* Enumerate in reverse order so we get the right order for the native
   windows (first in childrens list is topmost, and reparent places on top) */
for (l = g_list_last (private->children); l != NULL((void*)0); l = l->prev)
  {
    child = l->data;

    if (child->impl == private->impl)
reparent_to_impl (child);
    else
{
 show = impl_class->reparent ((CdkWindow *)child,
		       (CdkWindow *)private,
		       child->x, child->y);
 if (show)
   cdk_window_show_unraised ((CdkWindow *)child);
}
  }
1634}


1637/**
* cdk_window_reparent:
* @window: a #CdkWindow
* @new_parent: new parent to move @window into
* @x: X location inside the new parent
* @y: Y location inside the new parent
*
* Reparents @window into the given @new_parent. The window being
* reparented will be unmapped as a side effect.
*
**/
1648void
1649cdk_window_reparent (CdkWindow *window,
     CdkWindow *new_parent,
     gint       x,
     gint       y)
1653{
CdkWindow *old_parent;
CdkScreen *screen;
gboolean show, was_mapped;
gboolean do_reparent_to_impl;
CdkEventMask old_native_event_mask;
CdkWindowImplClass *impl_class;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);
g_return_if_fail (new_parent == NULL || CDK_IS_WINDOW (new_parent))do { if ((new_parent == ((void*)0) || (((__extension__ ({ GTypeInstance
 *__inst = (GTypeInstance*) ((new_parent)); GType __t = ((cdk_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; })))))) { } else { g_return_if_fail_warning ("Cdk", ((const
 char*) (__func__)), "new_parent == NULL || CDK_IS_WINDOW (new_parent)"
); return; } } while (0);
g_return_if_fail (CDK_WINDOW_TYPE (window) != CDK_WINDOW_ROOT)do { if ((((((CdkWindow *)(window)))->window_type) != CDK_WINDOW_ROOT
)) { } else { g_return_if_fail_warning ("Cdk", ((const char*)
 (__func__)), "CDK_WINDOW_TYPE (window) != CDK_WINDOW_ROOT");
 return; } } while (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    (new_parent && CDK_WINDOW_DESTROYED (new_parent)(((CdkWindow *)(new_parent))->destroyed)))
  return;

screen = cdk_window_get_screen (window);
if (!new_parent)
  new_parent = cdk_screen_get_root_window (screen);

/* No input-output children of input-only windows */
if (new_parent->input_only && !window->input_only)
  return;

/* Don't create loops in hierarchy */
if (is_parent_of (window, new_parent))
  return;

impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));
old_parent = window->parent;

was_mapped = CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0);

/* Reparenting to toplevel. Ensure we have a native window so this can work */
if (new_parent->window_type == CDK_WINDOW_ROOT ||
    new_parent->window_type == CDK_WINDOW_FOREIGN)
  cdk_window_ensure_native (window);

old_native_event_mask = 0;
do_reparent_to_impl = FALSE(0);
if (cdk_window_has_impl (window))
  {
    old_native_event_mask = get_native_event_mask (window);
    /* Native window */
    show = impl_class->reparent (window, new_parent, x, y);
  }
else
  {
    /* This shouldn't happen, as we created a native in this case, check anyway to see if that ever fails */
    g_assert (new_parent->window_type != CDK_WINDOW_ROOT &&do { if (new_parent->window_type != CDK_WINDOW_ROOT &&
 new_parent->window_type != CDK_WINDOW_FOREIGN) ; else g_assertion_message_expr
 ("Cdk", "cdkwindow.c", 1703, ((const char*) (__func__)), "new_parent->window_type != CDK_WINDOW_ROOT && new_parent->window_type != CDK_WINDOW_FOREIGN"
); } while (0)
new_parent->window_type != CDK_WINDOW_FOREIGN)do { if (new_parent->window_type != CDK_WINDOW_ROOT &&
 new_parent->window_type != CDK_WINDOW_FOREIGN) ; else g_assertion_message_expr
 ("Cdk", "cdkwindow.c", 1703, ((const char*) (__func__)), "new_parent->window_type != CDK_WINDOW_ROOT && new_parent->window_type != CDK_WINDOW_FOREIGN"
); } while (0);

    show = was_mapped;
    cdk_window_hide (window);

    do_reparent_to_impl = TRUE(!(0));
    change_impl (window,
   new_parent->impl_window,
   new_parent->impl);
  }

/* From here on, we treat parents of type CDK_WINDOW_FOREIGN like
 * the root window
 */
if (CDK_WINDOW_TYPE (new_parent)((((CdkWindow *)(new_parent)))->window_type) == CDK_WINDOW_FOREIGN)
  {
    new_parent = cdk_screen_get_root_window (screen);
  }

if (old_parent)
  {
    old_parent->children = g_list_remove_link (old_parent->children, &window->children_list_node);

    if (cdk_window_has_impl (window))
      old_parent->impl_window->native_children =
        g_list_remove (old_parent->impl_window->native_children, window);
  }

window->parent = new_parent;
window->x = x;
window->y = y;

new_parent->children = g_list_concat (&window->children_list_node, new_parent->children);

if (cdk_window_has_impl (window))
  new_parent->impl_window->native_children = g_list_prepend (new_parent->impl_window->native_children, window);

/* Switch the window type as appropriate */

switch (CDK_WINDOW_TYPE (new_parent)((((CdkWindow *)(new_parent)))->window_type))
  {
  case CDK_WINDOW_ROOT:
  case CDK_WINDOW_FOREIGN:
    if (window->toplevel_window_type != -1)
CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type) = window->toplevel_window_type;
    else if (CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_CHILD)
CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type) = CDK_WINDOW_TOPLEVEL;
    break;
  case CDK_WINDOW_OFFSCREEN:
  case CDK_WINDOW_TOPLEVEL:
  case CDK_WINDOW_CHILD:
  case CDK_WINDOW_TEMP:
    if (CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type) != CDK_WINDOW_CHILD && \
 CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type) != CDK_WINDOW_FOREIGN)
{
 /* Save the original window type so we can restore it if the
  * window is reparented back to be a toplevel
  */
 window->toplevel_window_type = CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type);
 CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type) = CDK_WINDOW_CHILD;
}
  }

/* If we changed the window type, we might have to set or
 * unset the frame clock on the window
 */
if (CDK_WINDOW_TYPE (new_parent)((((CdkWindow *)(new_parent)))->window_type) == CDK_WINDOW_ROOT &&
    CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type) != CDK_WINDOW_FOREIGN)
  {
    if (window->frame_clock == NULL((void*)0))
      {
        CdkFrameClock *frame_clock = g_object_new (CDK_TYPE_FRAME_CLOCK_IDLE(cdk_frame_clock_idle_get_type ()), NULL((void*)0));
        cdk_window_set_frame_clock (window, frame_clock);
        g_object_unref (frame_clock);
      }
  }
else
  {
    if (window->frame_clock != NULL((void*)0))
      {
        g_object_run_dispose (G_OBJECT (window->frame_clock)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window->frame_clock)), (((GType) ((20) << (2)))
))))));
        cdk_window_set_frame_clock (window, NULL((void*)0));
      }
  }

/* We might have changed window type for a native windows, so we
   need to change the event mask too. */
if (cdk_window_has_impl (window))
  {
    CdkEventMask native_event_mask = get_native_event_mask (window);

    if (native_event_mask != old_native_event_mask)
impl_class->set_events (window,	native_event_mask);
  }

_cdk_window_update_viewable (window);

recompute_visible_regions (window, FALSE(0));

if (do_reparent_to_impl)
  reparent_to_impl (window);
else
  {
    /* The reparent will have put the native window topmost in the native parent,
     * which may be wrong wrt other native windows in the non-native hierarchy,
     * so restack */
    if (!cdk_window_has_impl (new_parent))
sync_native_window_stack_position (window);
  }

if (show)
  cdk_window_show_unraised (window);
else
  _cdk_synthesize_crossing_events_for_geometry_change (window);
1817}

1819/**
* cdk_window_ensure_native:
* @window: a #CdkWindow
*
* Tries to ensure that there is a window-system native window for this
* CdkWindow. This may fail in some situations, returning %FALSE.
*
* Offscreen window and children of them can never have native windows.
*
* Some backends may not support native child windows.
*
* Returns: %TRUE if the window has a native window, %FALSE otherwise
*
* Since: 2.18
*/
1834gboolean
1835cdk_window_ensure_native (CdkWindow *window)
1836{
CdkWindow *impl_window;
CdkWindowImpl *new_impl, *old_impl;
CdkDisplay *display;
CdkScreen *screen;
CdkWindow *above, *parent;
GList listhead;
CdkWindowImplClass *impl_class;

g_return_val_if_fail (CDK_IS_WINDOW (window), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return ((0)); } } while (0);

if (CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_ROOT ||
    CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return FALSE(0);

impl_window = cdk_window_get_impl_window (window);

if (cdk_window_is_offscreen (impl_window))
  return FALSE(0); /* native in offscreens not supported */

if (impl_window == window)
  /* Already has an impl, and its not offscreen . */
  return TRUE(!(0));

/* Need to create a native window */

screen = cdk_window_get_screen (window);
display = cdk_screen_get_display (screen);
parent = window->parent;

old_impl = window->impl;
_cdk_display_create_window_impl (display,
                                 window, parent,
                                 screen,
                                 get_native_event_mask (window),
                                 NULL((void*)0), 0);
new_impl = window->impl;

parent->impl_window->native_children =
  g_list_prepend (parent->impl_window->native_children, window);

window->impl = old_impl;
change_impl (window, window, new_impl);

impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));

/* Native window creation will put the native window topmost in the
 * native parent, which may be wrong wrt the position of the previous
 * non-native window wrt to the other non-native children, so correct this.
 */
above = find_native_sibling_above (parent, window);
if (above)
  {
    listhead.data = window;
    listhead.prev = NULL((void*)0);
    listhead.next = NULL((void*)0);
    impl_class->restack_under ((CdkWindow *)above, &listhead);
  }

recompute_visible_regions (window, FALSE(0));

reparent_to_impl (window);

if (!window->input_only)
  impl_class->set_background (window, window->background);

impl_class->input_shape_combine_region (window,
                                        window->input_shape,
                                        0, 0);

if (cdk_window_is_viewable (window))
  impl_class->show (window, FALSE(0));

cdk_window_invalidate_in_parent (window);

return TRUE(!(0));
1912}

1914/**
* _cdk_event_filter_unref:
* @window: (allow-none): A #CdkWindow, or %NULL to be the global window
* @filter: A window filter
*
* Release a reference to @filter.  Note this function may
* mutate the list storage, so you need to handle this
* if iterating over a list of filters.
*/
1923void
1924_cdk_event_filter_unref (CdkWindow       *window,
	 CdkEventFilter  *filter)
1926{
GList **filters;
GList *tmp_list;

if (window == NULL((void*)0))
  filters = &_cdk_default_filters;
else
  filters = &window->filters;

tmp_list = *filters;
while (tmp_list)
  {
    CdkEventFilter *iter_filter = tmp_list->data;
    GList *node;

    node = tmp_list;
    tmp_list = tmp_list->next;

    if (iter_filter != filter)
continue;

    g_assert (iter_filter->ref_count > 0)do { if (iter_filter->ref_count > 0) ; else g_assertion_message_expr
 ("Cdk", "cdkwindow.c", 1947, ((const char*) (__func__)), "iter_filter->ref_count > 0"
); } while (0);

    filter->ref_count--;
    if (filter->ref_count != 0)
continue;

    *filters = g_list_remove_link (*filters, node);
    g_free (filter);
    g_list_free_1 (node);
  }
1957}

1959static void
1960window_remove_filters (CdkWindow *window)
1961{
while (window->filters)
  _cdk_event_filter_unref (window, window->filters->data);
1964}

1966static void
1967update_pointer_info_foreach (CdkDisplay           *display G_GNUC_UNUSED__attribute__ ((__unused__)),
                           CdkDevice            *device G_GNUC_UNUSED__attribute__ ((__unused__)),
                           CdkPointerWindowInfo *pointer_info,
                           gpointer              user_data)
1971{
CdkWindow *window = user_data;

if (pointer_info->toplevel_under_pointer == window)
  {
    g_object_unref (pointer_info->toplevel_under_pointer);
    pointer_info->toplevel_under_pointer = NULL((void*)0);
  }
1979}

1981static void
1982window_remove_from_pointer_info (CdkWindow  *window,
                               CdkDisplay *display)
1984{
_cdk_display_pointer_info_foreach (display,
                                   update_pointer_info_foreach,
                                   window);
1988}

1990static void
1991cdk_window_free_current_paint (CdkWindow *window)
1992{
cairo_surface_destroy (window->current_paint.surface);
window->current_paint.surface = NULL((void*)0);

cairo_region_destroy (window->current_paint.region);
window->current_paint.region = NULL((void*)0);

cairo_region_destroy (window->current_paint.flushed_region);
window->current_paint.flushed_region = NULL((void*)0);

cairo_region_destroy (window->current_paint.need_blend_region);
window->current_paint.need_blend_region = NULL((void*)0);

window->current_paint.surface_needs_composite = FALSE(0);
2006}

2008/**
* _cdk_window_destroy_hierarchy:
* @window: a #CdkWindow
* @recursing: If %TRUE, then this is being called because a parent
*            was destroyed.
* @recursing_native: If %TRUE, then this is being called because a native parent
*            was destroyed. This generally means that the call to the
*            windowing system to destroy the window can be omitted, since
*            it will be destroyed as a result of the parent being destroyed.
*            Unless @foreign_destroy.
* @foreign_destroy: If %TRUE, the window or a parent was destroyed by some
*            external agency. The window has already been destroyed and no
*            windowing system calls should be made. (This may never happen
*            for some windowing systems.)
*
* Internal function to destroy a window. Like cdk_window_destroy(),
* but does not drop the reference count created by cdk_window_new().
**/
2026static void
2027_cdk_window_destroy_hierarchy (CdkWindow *window,
	       gboolean   recursing,
	       gboolean   recursing_native,
	       gboolean   foreign_destroy)
2031{
CdkWindowImplClass *impl_class;
CdkWindow *temp_window;
CdkScreen *screen;
CdkDisplay *display;
GList *tmp;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return;

display = cdk_window_get_display (window);
screen = cdk_window_get_screen (window);
temp_window = g_object_get_qdata (G_OBJECT (screen)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((screen)), (((GType) ((20) << (2)))))))), quark_pointer_window);
if (temp_window == window)
  g_object_set_qdata (G_OBJECT (screen)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((screen)), (((GType) ((20) << (2)))))))), quark_pointer_window, NULL((void*)0));

switch (window->window_type)
  {
  case CDK_WINDOW_ROOT:
    if (!screen->closed)
{
 g_error ("attempted to destroy root window");
 break;
}
    /* else fall thru */
  case CDK_WINDOW_TOPLEVEL:
  case CDK_WINDOW_CHILD:
  case CDK_WINDOW_TEMP:
  case CDK_WINDOW_FOREIGN:
  case CDK_WINDOW_OFFSCREEN:
  case CDK_WINDOW_SUBSURFACE:
    if (window->window_type == CDK_WINDOW_FOREIGN && !foreign_destroy)
{
 /* Logically, it probably makes more sense to send
  * a "destroy yourself" message to the foreign window
  * whether or not it's in our hierarchy; but for historical
  * reasons, we only send "destroy yourself" messages to
  * foreign windows in our hierarchy.
  */
 if (window->parent)
          {
            impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));

            if (cdk_window_has_impl (window))
              impl_class->destroy_foreign (window);
          }

 /* Also for historical reasons, we remove any filters
  * on a foreign window when it or a parent is destroyed;
  * this likely causes problems if two separate portions
  * of code are maintaining filter lists on a foreign window.
  */
 window_remove_filters (window);
}
    else
{
 if (window->parent)
   {
     if (window->parent->children)
              window->parent->children = g_list_remove_link (window->parent->children, &window->children_list_node);

            if (cdk_window_has_impl (window))
              window->parent->impl_window->native_children =
                g_list_remove (window->parent->impl_window->native_children, window);

     if (!recursing &&
  CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
{
  recompute_visible_regions (window, FALSE(0));
  cdk_window_invalidate_in_parent (window);
}
   }

        if (window->gl_paint_context)
          {
            /* Make sure to destroy if current */
            g_object_run_dispose (G_OBJECT (window->gl_paint_context)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window->gl_paint_context)), (((GType) ((20) << (
2)))))))));
            g_object_unref (window->gl_paint_context);
            window->gl_paint_context = NULL((void*)0);
          }

        if (window->frame_clock)
          {
            g_object_run_dispose (G_OBJECT (window->frame_clock)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window->frame_clock)), (((GType) ((20) << (2)))
))))));
            cdk_window_set_frame_clock (window, NULL((void*)0));
          }

        cdk_window_free_current_paint (window);

        if (window->background)
          {
            cairo_pattern_destroy (window->background);
            window->background = NULL((void*)0);
          }

 if (window->window_type == CDK_WINDOW_FOREIGN)
   g_assert (window->children == NULL)do { if (window->children == ((void*)0)) ; else g_assertion_message_expr
 ("Cdk", "cdkwindow.c", 2129, ((const char*) (__func__)), "window->children == NULL"
); } while (0);
 else
   {
     tmp = window->children;
     window->children = NULL((void*)0);
     /* No need to free children list, its all made up of in-struct nodes */

     while (tmp)
{
  temp_window = tmp->data;
  tmp = tmp->next;

  if (temp_window)
    _cdk_window_destroy_hierarchy (temp_window,
				   TRUE(!(0)),
				   recursing_native || cdk_window_has_impl (window),
				   foreign_destroy);
}


            if (cdk_window_has_impl (window))
              g_assert (window->native_children == NULL)do { if (window->native_children == ((void*)0)) ; else g_assertion_message_expr
 ("Cdk", "cdkwindow.c", 2150, ((const char*) (__func__)), "window->native_children == NULL"
); } while (0);
   }

 _cdk_window_clear_update_area (window);

 impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));

 if (cdk_window_has_impl (window))
   impl_class->destroy (window, recursing_native, foreign_destroy);
 else
   {
     /* hide to make sure we repaint and break grabs */
     cdk_window_hide (window);
   }

 window->state |= CDK_WINDOW_STATE_WITHDRAWN;
 window->parent = NULL((void*)0);
 window->destroyed = TRUE(!(0));

 window_remove_filters (window);

 window_remove_from_pointer_info (window, display);

 if (window->clip_region)
   {
     cairo_region_destroy (window->clip_region);
     window->clip_region = NULL((void*)0);
   }
}
    break;
  }
2181}

2183/**
* _cdk_window_destroy:
* @window: a #CdkWindow
* @foreign_destroy: If %TRUE, the window or a parent was destroyed by some
*            external agency. The window has already been destroyed and no
*            windowing system calls should be made. (This may never happen
*            for some windowing systems.)
*
* Internal function to destroy a window. Like cdk_window_destroy(),
* but does not drop the reference count created by cdk_window_new().
**/
2194void
2195_cdk_window_destroy (CdkWindow *window,
     gboolean   foreign_destroy)
2197{
_cdk_window_destroy_hierarchy (window, FALSE(0), FALSE(0), foreign_destroy);
2199}

2201/**
* cdk_window_destroy:
* @window: a #CdkWindow
*
* Destroys the window system resources associated with @window and decrements @window's
* reference count. The window system resources for all children of @window are also
* destroyed, but the children’s reference counts are not decremented.
*
* Note that a window will not be destroyed automatically when its reference count
* reaches zero. You must call this function yourself before that happens.
*
**/
2213void
2214cdk_window_destroy (CdkWindow *window)
2215{
_cdk_window_destroy_hierarchy (window, FALSE(0), FALSE(0), FALSE(0));
g_object_unref (window);
2218}

2220/**
* cdk_window_set_user_data:
* @window: a #CdkWindow
* @user_data: (allow-none) (type GObject.Object): user data
*
* For most purposes this function is deprecated in favor of
* g_object_set_data(). However, for historical reasons CTK+ stores
* the #CtkWidget that owns a #CdkWindow as user data on the
* #CdkWindow. So, custom widget implementations should use
* this function for that. If CTK+ receives an event for a #CdkWindow,
* and the user data for the window is non-%NULL, CTK+ will assume the
* user data is a #CtkWidget, and forward the event to that widget.
*
**/
2234void
2235cdk_window_set_user_data (CdkWindow *window,
	  gpointer   user_data)
2237{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

window->user_data = user_data;
2241}

2243/**
* cdk_window_get_user_data:
* @window: a #CdkWindow
* @data: (out): return location for user data
*
* Retrieves the user data for @window, which is normally the widget
* that @window belongs to. See cdk_window_set_user_data().
*
**/
2252void
2253cdk_window_get_user_data (CdkWindow *window,
	  gpointer  *data)
2255{
*data = window->user_data;
2257}

2259/**
* cdk_window_get_window_type:
* @window: a #CdkWindow
*
* Gets the type of the window. See #CdkWindowType.
*
* Returns: type of window
**/
2267CdkWindowType
2268cdk_window_get_window_type (CdkWindow *window)
2269{
g_return_val_if_fail (CDK_IS_WINDOW (window), (CdkWindowType) -1)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return ((CdkWindowType) -1); }
 } while (0);

return CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type);
2273}

2275/**
* cdk_window_get_visual:
* @window: a #CdkWindow
* 
* Gets the #CdkVisual describing the pixel format of @window.
* 
* Returns: (transfer none): a #CdkVisual
*
* Since: 2.24
**/
2285CdkVisual*
2286cdk_window_get_visual (CdkWindow *window)
2287{
g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

return window->visual;
2291}

2293/**
* cdk_window_get_screen:
* @window: a #CdkWindow
* 
* Gets the #CdkScreen associated with a #CdkWindow.
* 
* Returns: (transfer none): the #CdkScreen associated with @window
*
* Since: 2.24
**/
2303CdkScreen*
2304cdk_window_get_screen (CdkWindow *window)
2305{
g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

return cdk_visual_get_screen (window->visual);
2309}

2311/**
* cdk_window_get_display:
* @window: a #CdkWindow
* 
* Gets the #CdkDisplay associated with a #CdkWindow.
* 
* Returns: (transfer none): the #CdkDisplay associated with @window
*
* Since: 2.24
**/
2321CdkDisplay *
2322cdk_window_get_display (CdkWindow *window)
2323{
g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

return cdk_screen_get_display (cdk_visual_get_screen (window->visual));
2327}
2328/**
* cdk_window_is_destroyed:
* @window: a #CdkWindow
*
* Check to see if a window is destroyed..
*
* Returns: %TRUE if the window is destroyed
*
* Since: 2.18
**/
2338gboolean
2339cdk_window_is_destroyed (CdkWindow *window)
2340{
return CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed);
2342}

2344static void
2345to_embedder (CdkWindow *window,
           gdouble    offscreen_x,
           gdouble    offscreen_y,
           gdouble   *embedder_x,
           gdouble   *embedder_y)
2350{
g_signal_emit (window, signals[TO_EMBEDDER], 0,
               offscreen_x, offscreen_y,
               embedder_x, embedder_y);
2354}

2356static void
2357from_embedder (CdkWindow *window,
             gdouble    embedder_x,
             gdouble    embedder_y,
             gdouble   *offscreen_x,
             gdouble   *offscreen_y)
2362{
g_signal_emit (window, signals[FROM_EMBEDDER], 0,
               embedder_x, embedder_y,
               offscreen_x, offscreen_y);
2366}

2368/**
* cdk_window_has_native:
* @window: a #CdkWindow
*
* Checks whether the window has a native window or not. Note that
* you can use cdk_window_ensure_native() if a native window is needed.
*
* Returns: %TRUE if the @window has a native window, %FALSE otherwise.
*
* Since: 2.22
*/
2379gboolean
2380cdk_window_has_native (CdkWindow *window)
2381{
g_return_val_if_fail (CDK_IS_WINDOW (window), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return ((0)); } } while (0);

return window->parent == NULL((void*)0) || window->parent->impl != window->impl;
2385}

2387/**
* cdk_window_get_position:
* @window: a #CdkWindow
* @x: (out) (allow-none): X coordinate of window
* @y: (out) (allow-none): Y coordinate of window
*
* Obtains the position of the window as reported in the
* most-recently-processed #CdkEventConfigure. Contrast with
* cdk_window_get_geometry() which queries the X server for the
* current window position, regardless of which events have been
* received or processed.
*
* The position coordinates are relative to the window’s parent window.
*
**/
2402void
2403cdk_window_get_position (CdkWindow *window,
	 gint      *x,
	 gint      *y)
2406{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (x)
  *x = window->x;
if (y)
  *y = window->y;
2413}

2415/**
* cdk_window_get_parent:
* @window: a #CdkWindow
*
* Obtains the parent of @window, as known to CDK. Does not query the
* X server; thus this returns the parent as passed to cdk_window_new(),
* not the actual parent. This should never matter unless you’re using
* Xlib calls mixed with CDK calls on the X11 platform. It may also
* matter for toplevel windows, because the window manager may choose
* to reparent them.
*
* Note that you should use cdk_window_get_effective_parent() when
* writing generic code that walks up a window hierarchy, because
* cdk_window_get_parent() will most likely not do what you expect if
* there are offscreen windows in the hierarchy.
*
* Returns: (transfer none): parent of @window
**/
2433CdkWindow*
2434cdk_window_get_parent (CdkWindow *window)
2435{
g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

return window->parent;
2439}

2441/**
* cdk_window_get_effective_parent:
* @window: a #CdkWindow
*
* Obtains the parent of @window, as known to CDK. Works like
* cdk_window_get_parent() for normal windows, but returns the
* window’s embedder for offscreen windows.
*
* See also: cdk_offscreen_window_get_embedder()
*
* Returns: (transfer none): effective parent of @window
*
* Since: 2.22
**/
2455CdkWindow *
2456cdk_window_get_effective_parent (CdkWindow *window)
2457{
g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

if (cdk_window_is_offscreen (window))
  return cdk_offscreen_window_get_embedder (window);
else if (cdk_window_is_subsurface (window))
  return window->transient_for;
else
  return window->parent;
2466}

2468/**
* cdk_window_get_toplevel:
* @window: a #CdkWindow
*
* Gets the toplevel window that’s an ancestor of @window.
*
* Any window type but %CDK_WINDOW_CHILD is considered a
* toplevel window, as is a %CDK_WINDOW_CHILD window that
* has a root window as parent.
*
* Note that you should use cdk_window_get_effective_toplevel() when
* you want to get to a window’s toplevel as seen on screen, because
* cdk_window_get_toplevel() will most likely not do what you expect
* if there are offscreen windows in the hierarchy.
*
* Returns: (transfer none): the toplevel window containing @window
**/
2485CdkWindow *
2486cdk_window_get_toplevel (CdkWindow *window)
2487{
g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

while (window->window_type == CDK_WINDOW_CHILD ||
       window->window_type == CDK_WINDOW_SUBSURFACE)
  {
    if (cdk_window_is_toplevel (window))
break;
    window = window->parent;
  }

return window;
2499}

2501/**
* cdk_window_get_effective_toplevel:
* @window: a #CdkWindow
*
* Gets the toplevel window that’s an ancestor of @window.
*
* Works like cdk_window_get_toplevel(), but treats an offscreen window's
* embedder as its parent, using cdk_window_get_effective_parent().
*
* See also: cdk_offscreen_window_get_embedder()
*
* Returns: (transfer none): the effective toplevel window containing @window
*
* Since: 2.22
**/
2516CdkWindow *
2517cdk_window_get_effective_toplevel (CdkWindow *window)
2518{
CdkWindow *parent;

g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

while ((parent = cdk_window_get_effective_parent (window)) != NULL((void*)0) &&
(cdk_window_get_window_type (parent) != CDK_WINDOW_ROOT))
  window = parent;

return window;
2528}

2530/**
* cdk_window_get_children:
* @window: a #CdkWindow
*
* Gets the list of children of @window known to CDK.
* This function only returns children created via CDK,
* so for example it’s useless when used with the root window;
* it only returns windows an application created itself.
*
* The returned list must be freed, but the elements in the
* list need not be.
*
* Returns: (transfer container) (element-type CdkWindow):
*     list of child windows inside @window
**/
2545GList*
2546cdk_window_get_children (CdkWindow *window)
2547{
g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return NULL((void*)0);

return g_list_copy (window->children);
2554}

2556/**
* cdk_window_peek_children:
* @window: a #CdkWindow
*
* Like cdk_window_get_children(), but does not copy the list of
* children, so the list does not need to be freed.
*
* Returns: (transfer none) (element-type CdkWindow):
*     a reference to the list of child windows in @window
**/
2566GList *
2567cdk_window_peek_children (CdkWindow *window)
2568{
g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return NULL((void*)0);

return window->children;
2575}


2578/**
* cdk_window_get_children_with_user_data:
* @window: a #CdkWindow
* @user_data: user data to look for
*
* Gets the list of children of @window known to CDK with a
* particular @user_data set on it.
*
* The returned list must be freed, but the elements in the
* list need not be.
*
* The list is returned in (relative) stacking order, i.e. the
* lowest window is first.
*
* Returns: (transfer container) (element-type CdkWindow):
*     list of child windows inside @window
*
* Since: 3.10
**/
2597GList *
2598cdk_window_get_children_with_user_data (CdkWindow *window,
                                      gpointer   user_data)
2600{
CdkWindow *child;
GList *res, *l;

g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return NULL((void*)0);

res = NULL((void*)0);
for (l = window->children; l != NULL((void*)0); l = l->next)
  {
    child = l->data;

    if (child->user_data == user_data)
res = g_list_prepend (res, child);
  }

return res;
2619}


2622/**
* cdk_window_add_filter: (skip)
* @window: (allow-none): a #CdkWindow
* @function: filter callback
* @data: data to pass to filter callback
*
* Adds an event filter to @window, allowing you to intercept events
* before they reach CDK. This is a low-level operation and makes it
* easy to break CDK and/or CTK+, so you have to know what you're
* doing. Pass %NULL for @window to get all events for all windows,
* instead of events for a specific window.
*
* If you are interested in X GenericEvents, bear in mind that
* XGetEventData() has been already called on the event, and
* XFreeEventData() must not be called within @function.
**/
2638void
2639cdk_window_add_filter (CdkWindow     *window,
       CdkFilterFunc  function,
       gpointer       data)
2642{
GList *tmp_list;
CdkEventFilter *filter;

g_return_if_fail (window == NULL || CDK_IS_WINDOW (window))do { if ((window == ((void*)0) || (((__extension__ ({ GTypeInstance
 *__inst = (GTypeInstance*) ((window)); GType __t = ((cdk_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; })))))) { } else { g_return_if_fail_warning ("Cdk", ((const
 char*) (__func__)), "window == NULL || CDK_IS_WINDOW (window)"
); return; } } while (0);

if (window && CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return;

/* Filters are for the native events on the native window, so
   ensure there is a native window. */
if (window)
  cdk_window_ensure_native (window);

if (window)
  tmp_list = window->filters;
else
  tmp_list = _cdk_default_filters;

while (tmp_list)
  {
    filter = (CdkEventFilter *)tmp_list->data;
    if ((filter->function == function) && (filter->data == data))
      {
        filter->ref_count++;
        filter->flags = 0;
        return;
      }
    tmp_list = tmp_list->next;
  }

filter = g_new (CdkEventFilter, 1)((CdkEventFilter *) g_malloc_n ((1), sizeof (CdkEventFilter))
);
filter->function = function;
filter->data = data;
filter->ref_count = 1;
filter->flags = 0;

if (window)
  window->filters = g_list_append (window->filters, filter);
else
  _cdk_default_filters = g_list_append (_cdk_default_filters, filter);
2683}

2685/**
* cdk_window_remove_filter: (skip)
* @window: a #CdkWindow
* @function: previously-added filter function
* @data: user data for previously-added filter function
*
* Remove a filter previously added with cdk_window_add_filter().
*/
2693void
2694cdk_window_remove_filter (CdkWindow     *window,
                        CdkFilterFunc  function,
                        gpointer       data)
2697{
GList *tmp_list;
CdkEventFilter *filter;

g_return_if_fail (window == NULL || CDK_IS_WINDOW (window))do { if ((window == ((void*)0) || (((__extension__ ({ GTypeInstance
 *__inst = (GTypeInstance*) ((window)); GType __t = ((cdk_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; })))))) { } else { g_return_if_fail_warning ("Cdk", ((const
 char*) (__func__)), "window == NULL || CDK_IS_WINDOW (window)"
); return; } } while (0);

if (window)
  tmp_list = window->filters;
else
  tmp_list = _cdk_default_filters;

while (tmp_list)
  {
    filter = (CdkEventFilter *)tmp_list->data;
    tmp_list = tmp_list->next;

    if ((filter->function == function) && (filter->data == data))
      {
        filter->flags |= CDK_EVENT_FILTER_REMOVED;

        _cdk_event_filter_unref (window, filter);

        return;
      }
  }
2722}

2724/**
* cdk_screen_get_toplevel_windows:
* @screen: The #CdkScreen where the toplevels are located.
*
* Obtains a list of all toplevel windows known to CDK on the screen @screen.
* A toplevel window is a child of the root window (see
* cdk_get_default_root_window()).
*
* The returned list should be freed with g_list_free(), but
* its elements need not be freed.
*
* Returns: (transfer container) (element-type CdkWindow):
*     list of toplevel windows, free with g_list_free()
*
* Since: 2.2
**/
2740GList *
2741cdk_screen_get_toplevel_windows (CdkScreen *screen)
2742{
CdkWindow * root_window;
GList *new_list = NULL((void*)0);
GList *tmp_list;

g_return_val_if_fail (CDK_IS_SCREEN (screen), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((screen)); GType __t = ((cdk_screen_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_SCREEN (screen)"); return (((void*)0)); } } while
 (0);

root_window = cdk_screen_get_root_window (screen);

tmp_list = root_window->children;
while (tmp_list)
  {
    CdkWindow *w = tmp_list->data;

    if (w->window_type != CDK_WINDOW_FOREIGN)
new_list = g_list_prepend (new_list, w);
    tmp_list = tmp_list->next;
  }

return new_list;
2762}

2764/**
* cdk_window_is_visible:
* @window: a #CdkWindow
*
* Checks whether the window has been mapped (with cdk_window_show() or
* cdk_window_show_unraised()).
*
* Returns: %TRUE if the window is mapped
**/
2773gboolean
2774cdk_window_is_visible (CdkWindow *window)
2775{
g_return_val_if_fail (CDK_IS_WINDOW (window), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return ((0)); } } while (0);

return CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0);
2779}

2781/**
* cdk_window_is_viewable:
* @window: a #CdkWindow
*
* Check if the window and all ancestors of the window are
* mapped. (This is not necessarily "viewable" in the X sense, since
* we only check as far as we have CDK window parents, not to the root
* window.)
*
* Returns: %TRUE if the window is viewable
**/
2792gboolean
2793cdk_window_is_viewable (CdkWindow *window)
2794{
g_return_val_if_fail (CDK_IS_WINDOW (window), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return ((0)); } } while (0);

if (window->destroyed)
  return FALSE(0);

return window->viewable;
2801}

2803/**
* cdk_window_get_state:
* @window: a #CdkWindow
*
* Gets the bitwise OR of the currently active window state flags,
* from the #CdkWindowState enumeration.
*
* Returns: window state bitfield
**/
2812CdkWindowState
2813cdk_window_get_state (CdkWindow *window)
2814{
g_return_val_if_fail (CDK_IS_WINDOW (window), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return ((0)); } } while (0);

return window->state;
2818}

2820static cairo_content_t
2821cdk_window_get_content (CdkWindow *window)
2822{
cairo_surface_t *surface;
cairo_content_t content;

g_return_val_if_fail (CDK_IS_WINDOW (window), 0)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (0); } } while (0);

surface = cdk_window_ref_impl_surface (window);
content = cairo_surface_get_content (surface);
cairo_surface_destroy (surface);

return content;
2833}

2835static cairo_surface_t *
2836cdk_window_ref_impl_surface (CdkWindow *window)
2837{
return CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->ref_cairo_surface (cdk_window_get_impl_window (window));
2839}

2841CdkGLContext *
2842cdk_window_get_paint_gl_context (CdkWindow  *window,
                               GError    **error)
2844{
GError *internal_error = NULL((void*)0);

if (_cdk_gl_flags & CDK_GL_DISABLE)
  {
    g_set_error_literal (error, CDK_GL_ERROR(cdk_gl_error_quark ()),
                         CDK_GL_ERROR_NOT_AVAILABLE,
                         _("GL support disabled via CDK_DEBUG")((char *) g_dgettext ("ctk30", "GL support disabled via CDK_DEBUG"
)));
    return NULL((void*)0);
  }

if (window->impl_window->gl_paint_context == NULL((void*)0))
  {
    CdkWindowImplClass *impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));

    if (impl_class->create_gl_context == NULL((void*)0))
      {
        g_set_error_literal (error, CDK_GL_ERROR(cdk_gl_error_quark ()), CDK_GL_ERROR_NOT_AVAILABLE,
                             _("The current backend does not support OpenGL")((char *) g_dgettext ("ctk30", "The current backend does not support OpenGL"
)));
        return NULL((void*)0);
      }

    window->impl_window->gl_paint_context =
      impl_class->create_gl_context (window->impl_window,
                                     TRUE(!(0)),
                                     NULL((void*)0),
                                     &internal_error);
  }

if (internal_error != NULL((void*)0))
  {
    g_propagate_error (error, internal_error);
    g_clear_object (&(window->impl_window->gl_paint_context))do { _Static_assert (sizeof *((&(window->impl_window->
gl_paint_context))) == sizeof (gpointer), "Expression evaluates to false"
); __typeof__ (((&(window->impl_window->gl_paint_context
)))) _pp = ((&(window->impl_window->gl_paint_context
))); __typeof__ (*((&(window->impl_window->gl_paint_context
)))) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_object_unref
) (_ptr); } while (0);
    return NULL((void*)0);
  }

cdk_gl_context_realize (window->impl_window->gl_paint_context, &internal_error);
if (internal_error != NULL((void*)0))
  {
    g_propagate_error (error, internal_error);
    g_clear_object (&(window->impl_window->gl_paint_context))do { _Static_assert (sizeof *((&(window->impl_window->
gl_paint_context))) == sizeof (gpointer), "Expression evaluates to false"
); __typeof__ (((&(window->impl_window->gl_paint_context
)))) _pp = ((&(window->impl_window->gl_paint_context
))); __typeof__ (*((&(window->impl_window->gl_paint_context
)))) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_object_unref
) (_ptr); } while (0);
    return NULL((void*)0);
  }

return window->impl_window->gl_paint_context;
2889}

2891/**
* cdk_window_create_gl_context:
* @window: a #CdkWindow
* @error: return location for an error
*
* Creates a new #CdkGLContext matching the
* framebuffer format to the visual of the #CdkWindow. The context
* is disconnected from any particular window or surface.
*
* If the creation of the #CdkGLContext failed, @error will be set.
*
* Before using the returned #CdkGLContext, you will need to
* call cdk_gl_context_make_current() or cdk_gl_context_realize().
*
* Returns: (transfer full): the newly created #CdkGLContext, or
* %NULL on error
*
* Since: 3.16
**/
2910CdkGLContext *
2911cdk_window_create_gl_context (CdkWindow    *window,
                            GError      **error)
2913{
CdkGLContext *paint_context;

g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);
g_return_val_if_fail (error == NULL || *error == NULL, NULL)do { if ((error == ((void*)0) || *error == ((void*)0))) { } else
 { g_return_if_fail_warning ("Cdk", ((const char*) (__func__)
), "error == NULL || *error == NULL"); return (((void*)0)); }
 } while (0);

paint_context = cdk_window_get_paint_gl_context (window, error);
if (paint_context == NULL((void*)0))
  return NULL((void*)0);

return CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->create_gl_context (window->impl_window,
						      FALSE(0),
                                                                    paint_context,
                                                                    error);
2927}

2929static void
2930cdk_window_begin_paint_internal (CdkWindow            *window,
	         const cairo_region_t *region)
2932{
CdkRectangle clip_box;
CdkWindowImplClass *impl_class;
double sx, sy;
gboolean needs_surface;
cairo_content_t surface_content;

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !cdk_window_has_impl (window))
  return;

if (window->current_paint.surface != NULL((void*)0))
  {
    g_warning ("A paint operation on the window is alredy in progress. "
               "This is not allowed.");
    return;
  }

impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));

needs_surface = TRUE(!(0));
if (impl_class->begin_paint)
  needs_surface = impl_class->begin_paint (window);

window->current_paint.region = cairo_region_copy (region);
cairo_region_intersect (window->current_paint.region, window->clip_region);
cairo_region_get_extents (window->current_paint.region, &clip_box);

window->current_paint.flushed_region = cairo_region_create ();
window->current_paint.need_blend_region = cairo_region_create ();

surface_content = cdk_window_get_content (window);

window->current_paint.use_gl = window->impl_window->gl_paint_context != NULL((void*)0);

if (window->current_paint.use_gl)
  {
    CdkGLContext *context;

    int ww = cdk_window_get_width (window) * cdk_window_get_scale_factor (window);
    int wh = cdk_window_get_height (window) * cdk_window_get_scale_factor (window);

    context = cdk_window_get_paint_gl_context (window, NULL((void*)0));
    if (context == NULL((void*)0))
      {
        g_warning ("gl rendering failed, context: %p", context);
        window->current_paint.use_gl = FALSE(0);
      }
    else
      {
 cdk_gl_context_make_current (context);
        /* With gl we always need a surface to combine the gl
           drawing with the native drawing. */
        needs_surface = TRUE(!(0));
        /* Also, we need the surface to include alpha */
        surface_content = CAIRO_CONTENT_COLOR_ALPHA;

        /* Initial setup */
        glClearColorepoxy_glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
        glDisableepoxy_glDisable (GL_DEPTH_TEST0x0B71);
        glDisableepoxy_glDisable(GL_BLEND0x0BE2);
        glBlendFuncepoxy_glBlendFunc (GL_ONE1, GL_ONE_MINUS_SRC_ALPHA0x0303);

        glViewportepoxy_glViewport (0, 0, ww, wh);
      }
  }

if (needs_surface)
  {
    window->current_paint.surface = cdk_window_create_similar_surface (window,
                                                                       surface_content,
                                                                       MAX (clip_box.width, 1)(((clip_box.width) > (1)) ? (clip_box.width) : (1)),
                                                                       MAX (clip_box.height, 1)(((clip_box.height) > (1)) ? (clip_box.height) : (1)));
    sx = sy = 1;
    cairo_surface_get_device_scale (window->current_paint.surface, &sx, &sy);
    cairo_surface_set_device_offset (window->current_paint.surface, -clip_box.x*sx, -clip_box.y*sy);
    cdk_cairo_surface_mark_as_direct (window->current_paint.surface, window);

    window->current_paint.surface_needs_composite = TRUE(!(0));
  }
else
  {
    window->current_paint.surface = cdk_window_ref_impl_surface (window);
    window->current_paint.surface_needs_composite = FALSE(0);
  }

if (!cairo_region_is_empty (window->current_paint.region))
  cdk_window_clear_backing_region (window);
3020}

3022static void
3023cdk_window_end_paint_internal (CdkWindow *window)
3024{
CdkWindow *composited;
CdkWindowImplClass *impl_class;
CdkRectangle clip_box = { 0, };
cairo_t *cr;

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !cdk_window_has_impl (window))
  return;

if (window->current_paint.surface == NULL((void*)0))
  {
    g_warning (G_STRLOC"cdkwindow.c" ":" "3036"": no preceding call to cdk_window_begin_draw_frame(), see documentation");
    return;
  }

impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));

if (impl_class->end_paint)
  impl_class->end_paint (window);

if (window->current_paint.surface_needs_composite)
  {
    cairo_surface_t *surface;

    cairo_region_get_extents (window->current_paint.region, &clip_box);

    if (window->current_paint.use_gl)
      {
        cairo_region_t *opaque_region = cairo_region_copy (window->current_paint.region);
        cairo_region_subtract (opaque_region, window->current_paint.flushed_region);
        cairo_region_subtract (opaque_region, window->current_paint.need_blend_region);

        cdk_gl_context_make_current (window->gl_paint_context);

        if (!cairo_region_is_empty (opaque_region))
          cdk_gl_texture_from_surface (window->current_paint.surface,
                                       opaque_region);
        if (!cairo_region_is_empty (window->current_paint.need_blend_region))
          {
            glEnableepoxy_glEnable(GL_BLEND0x0BE2);
            cdk_gl_texture_from_surface (window->current_paint.surface,
                                         window->current_paint.need_blend_region);
            glDisableepoxy_glDisable(GL_BLEND0x0BE2);
          }

        cairo_region_destroy (opaque_region);

        cdk_gl_context_end_frame (window->gl_paint_context,
                                  window->current_paint.region,
                                  window->active_update_area);
      }
    else
      {
        surface = cdk_window_ref_impl_surface (window);
        cr = cairo_create (surface);

        cairo_set_source_surface (cr, window->current_paint.surface, 0, 0);
        cdk_cairo_region (cr, window->current_paint.region);
        cairo_clip (cr);

        cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
        cairo_paint (cr);

        cairo_destroy (cr);

        cairo_surface_flush (surface);
        cairo_surface_destroy (surface);
      }
  }

cdk_window_free_current_paint (window);

/* find a composited window in our hierarchy to signal its
 * parent to redraw, calculating the clip box as we go...
 *
 * stop if parent becomes NULL since then we'd have nowhere
 * to draw (ie: 'composited' will always be non-NULL here).
 */
for (composited = window;
     composited->parent;
     composited = composited->parent)
  {
    clip_box.x += composited->x;
    clip_box.y += composited->y;
    clip_box.width = MIN (clip_box.width, composited->parent->width - clip_box.x)(((clip_box.width) < (composited->parent->width - clip_box
.x)) ? (clip_box.width) : (composited->parent->width - clip_box
.x));
    clip_box.height = MIN (clip_box.height, composited->parent->height - clip_box.y)(((clip_box.height) < (composited->parent->height - clip_box
.y)) ? (clip_box.height) : (composited->parent->height -
 clip_box.y));

    if (composited->composited)
{
 cdk_window_invalidate_rect (CDK_WINDOW (composited->parent)((((CdkWindow*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((composited->parent)), ((cdk_window_get_type ())))))),
		      &clip_box, FALSE(0));
 break;
}
  }
3119}

3121/**
* cdk_window_begin_paint_rect:
* @window: a #CdkWindow
* @rectangle: rectangle you intend to draw to
*
* A convenience wrapper around cdk_window_begin_paint_region() which
* creates a rectangular region for you. See
* cdk_window_begin_paint_region() for details.
*
* Deprecated: 3.22: Use cdk_window_begin_draw_frame() instead
*/
3132void
3133cdk_window_begin_paint_rect (CdkWindow          *window,
	     const CdkRectangle *rectangle)
3135{
cairo_region_t *region;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

region = cairo_region_create_rectangle (rectangle);
cdk_window_begin_paint_internal (window, region);
cairo_region_destroy (region);
3143}

3145/**
* cdk_window_begin_paint_region:
* @window: a #CdkWindow
* @region: region you intend to draw to
*
* Indicates that you are beginning the process of redrawing @region.
* A backing store (offscreen buffer) large enough to contain @region
* will be created. The backing store will be initialized with the
* background color or background surface for @window. Then, all
* drawing operations performed on @window will be diverted to the
* backing store.  When you call cdk_window_end_paint(), the backing
* store will be copied to @window, making it visible onscreen. Only
* the part of @window contained in @region will be modified; that is,
* drawing operations are clipped to @region.
*
* The net result of all this is to remove flicker, because the user
* sees the finished product appear all at once when you call
* cdk_window_end_paint(). If you draw to @window directly without
* calling cdk_window_begin_paint_region(), the user may see flicker
* as individual drawing operations are performed in sequence.  The
* clipping and background-initializing features of
* cdk_window_begin_paint_region() are conveniences for the
* programmer, so you can avoid doing that work yourself.
*
* When using CTK+, the widget system automatically places calls to
* cdk_window_begin_paint_region() and cdk_window_end_paint() around
* emissions of the expose_event signal. That is, if you’re writing an
* expose event handler, you can assume that the exposed area in
* #CdkEventExpose has already been cleared to the window background,
* is already set as the clip region, and already has a backing store.
* Therefore in most cases, application code need not call
* cdk_window_begin_paint_region(). (You can disable the automatic
* calls around expose events on a widget-by-widget basis by calling
* ctk_widget_set_double_buffered().)
*
* If you call this function multiple times before calling the
* matching cdk_window_end_paint(), the backing stores are pushed onto
* a stack. cdk_window_end_paint() copies the topmost backing store
* onscreen, subtracts the topmost region from all other regions in
* the stack, and pops the stack. All drawing operations affect only
* the topmost backing store in the stack. One matching call to
* cdk_window_end_paint() is required for each call to
* cdk_window_begin_paint_region().
*
* Deprecated: 3.22: Use cdk_window_begin_draw_frame() instead
*/
3191void
3192cdk_window_begin_paint_region (CdkWindow            *window,
	       const cairo_region_t *region)
3194{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

cdk_window_begin_paint_internal (window, region);
3198}

3200/**
* cdk_window_begin_draw_frame:
* @window: a #CdkWindow
* @region: a Cairo region
*
* Indicates that you are beginning the process of redrawing @region
* on @window, and provides you with a #CdkDrawingContext.
*
* If @window is a top level #CdkWindow, backed by a native window
* implementation, a backing store (offscreen buffer) large enough to
* contain @region will be created. The backing store will be initialized
* with the background color or background surface for @window. Then, all
* drawing operations performed on @window will be diverted to the
* backing store. When you call cdk_window_end_frame(), the contents of
* the backing store will be copied to @window, making it visible
* on screen. Only the part of @window contained in @region will be
* modified; that is, drawing operations are clipped to @region.
*
* The net result of all this is to remove flicker, because the user
* sees the finished product appear all at once when you call
* cdk_window_end_draw_frame(). If you draw to @window directly without
* calling cdk_window_begin_draw_frame(), the user may see flicker
* as individual drawing operations are performed in sequence.
*
* When using CTK+, the widget system automatically places calls to
* cdk_window_begin_draw_frame() and cdk_window_end_draw_frame() around
* emissions of the `CtkWidget::draw` signal. That is, if you’re
* drawing the contents of the widget yourself, you can assume that the
* widget has a cleared background, is already set as the clip region,
* and already has a backing store. Therefore in most cases, application
* code in CTK does not need to call cdk_window_begin_draw_frame()
* explicitly.
*
* Returns: (transfer none): a #CdkDrawingContext context that should be
*   used to draw the contents of the window; the returned context is owned
*   by CDK.
*
* Since: 3.22
*/
3239CdkDrawingContext *
3240cdk_window_begin_draw_frame (CdkWindow            *window,
                           const cairo_region_t *region)
3242{
CdkDrawingContext *context;
CdkWindowImplClass *impl_class;

g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

if (window->drawing_context != NULL((void*)0))
  {
    g_critical ("The window %p already has a drawing context. You cannot "
                "call cdk_window_begin_draw_frame() without calling "
                "cdk_window_end_draw_frame() first.", window);
    return NULL((void*)0);
  }

if (cdk_window_has_native (window) && cdk_window_is_toplevel (window))
  cdk_window_begin_paint_internal (window, region);

impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));
if (impl_class->create_draw_context != NULL((void*)0))
  {
    context = impl_class->create_draw_context (window, region);
  }
else
  {
    context = g_object_new (CDK_TYPE_DRAWING_CONTEXT(cdk_drawing_context_get_type ()),
                            "window", window,
                            "clip", region,
                            NULL((void*)0));
  }

/* Do not take a reference, to avoid creating cycles */
window->drawing_context = context;

return context;
3276}

3278/**
* cdk_window_end_draw_frame:
* @window: a #CdkWindow
* @context: the #CdkDrawingContext created by cdk_window_begin_draw_frame()
*
* Indicates that the drawing of the contents of @window started with
* cdk_window_begin_frame() has been completed.
*
* This function will take care of destroying the #CdkDrawingContext.
*
* It is an error to call this function without a matching
* cdk_window_begin_frame() first.
*
* Since: 3.22
*/
3293void
3294cdk_window_end_draw_frame (CdkWindow         *window,
                         CdkDrawingContext *context)
3296{
CdkWindowImplClass *impl_class;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);
g_return_if_fail (CDK_IS_DRAWING_CONTEXT (context))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((context)); GType __t = ((cdk_drawing_context_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; })))))) { } else { g_return_if_fail_warning ("Cdk", ((const
 char*) (__func__)), "CDK_IS_DRAWING_CONTEXT (context)"); return
; } } while (0);

if (window->drawing_context == NULL((void*)0))
  {
    g_critical ("The window %p has no drawing context. You must call "
                "cdk_window_begin_draw_frame() before calling "
                "cdk_window_end_draw_frame().", window);
    return;
  }

if (cdk_window_has_native (window) && cdk_window_is_toplevel (window))
  cdk_window_end_paint_internal (window);

impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));
if (impl_class->destroy_draw_context != NULL((void*)0))
  impl_class->destroy_draw_context (window, context);
else
  g_object_unref (context);

window->drawing_context = NULL((void*)0);
3320}

3322/*< private >
* cdk_window_get_current_paint_region:
* @window: a #CdkWindow
*
* Retrieves a copy of the current paint region.
*
* Returns: (transfer full): a Cairo region
*/
3330cairo_region_t *
3331cdk_window_get_current_paint_region (CdkWindow *window)
3332{
cairo_region_t *region;

if (window->impl_window->current_paint.region != NULL((void*)0))
  {
    region = cairo_region_copy (window->impl_window->current_paint.region);
    cairo_region_translate (region, -window->abs_x, -window->abs_y);
  }
else
  {
    region = cairo_region_copy (window->clip_region);
  }

return region;
3346}

3348/*< private >
* cdk_window_get_drawing_context:
* @window: a #CdkWindow
*
* Retrieves the #CdkDrawingContext associated to @window by
* cdk_window_begin_draw_frame().
*
* Returns: (transfer none) (nullable): a #CdkDrawingContext, if any is set
*/
3357CdkDrawingContext *
3358cdk_window_get_drawing_context (CdkWindow *window)
3359{
g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return NULL((void*)0);

return window->drawing_context;
3366}

3368/**
* cdk_window_mark_paint_from_clip:
* @window: a #CdkWindow
* @cr: a #cairo_t
*
* If you call this during a paint (e.g. between cdk_window_begin_paint_region()
* and cdk_window_end_paint() then CDK will mark the current clip region of the
* window as being drawn. This is required when mixing GL rendering via
* cdk_cairo_draw_from_gl() and cairo rendering, as otherwise CDK has no way
* of knowing when something paints over the GL-drawn regions.
*
* This is typically called automatically by CTK+ and you don't need
* to care about this.
*
* Since: 3.16
**/
3384void
3385cdk_window_mark_paint_from_clip (CdkWindow *window,
                               cairo_t   *cr)
3387{
cairo_region_t *clip_region;
CdkWindow *impl_window = window->impl_window;

if (impl_window->current_paint.surface == NULL((void*)0) ||
    cairo_get_target (cr) != impl_window->current_paint.surface)
  return;

if (cairo_region_is_empty (impl_window->current_paint.flushed_region))
  return;

/* This here seems a bit weird, but basically, we're taking the current
   clip and applying also the flushed region, and the result is that the
   new clip is the intersection of these. This is the area where the newly
   drawn region overlaps a previosly flushed area, which is an area of the
   double buffer surface that need to be blended OVER the back buffer rather
   than SRCed. */
cairo_save (cr);
/* We set the identity matrix here so we get and apply regions in native
   window coordinates. */
cairo_identity_matrix (cr);
cdk_cairo_region (cr, impl_window->current_paint.flushed_region);
cairo_clip (cr);

clip_region = cdk_cairo_region_from_clip (cr);
if (clip_region == NULL((void*)0))
  {
    /* Failed to represent clip as region, mark all as requiring
       blend */
    cairo_region_union (impl_window->current_paint.need_blend_region,
                        impl_window->current_paint.flushed_region);
    cairo_region_destroy (impl_window->current_paint.flushed_region);
    impl_window->current_paint.flushed_region = cairo_region_create ();
  }
else
  {
    cairo_region_subtract (impl_window->current_paint.flushed_region, clip_region);
    cairo_region_union (impl_window->current_paint.need_blend_region, clip_region);
  }
cairo_region_destroy (clip_region);

/* Clear the area on the double buffer surface to transparent so we
   can start drawing from scratch the area "above" the flushed
   region */
cairo_set_source_rgba (cr, 0, 0, 0, 0);
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_paint (cr);

cairo_restore (cr);
3436}

3438/**
* cdk_window_end_paint:
* @window: a #CdkWindow
*
* Indicates that the backing store created by the most recent call
* to cdk_window_begin_paint_region() should be copied onscreen and
* deleted, leaving the next-most-recent backing store or no backing
* store at all as the active paint region. See
* cdk_window_begin_paint_region() for full details.
*
* It is an error to call this function without a matching
* cdk_window_begin_paint_region() first.
**/
3451void
3452cdk_window_end_paint (CdkWindow *window)
3453{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

cdk_window_end_paint_internal (window);
3457}

3459/**
* cdk_window_flush:
* @window: a #CdkWindow
*
* This function does nothing.
*
* Since: 2.18
*
* Deprecated: 3.14
**/
3469void
3470cdk_window_flush (CdkWindow *window G_GNUC_UNUSED__attribute__ ((__unused__)))
3471{
3472}

3474/**
* cdk_window_get_clip_region:
* @window: a #CdkWindow
* 
* Computes the region of a window that potentially can be written
* to by drawing primitives. This region may not take into account
* other factors such as if the window is obscured by other windows,
* but no area outside of this region will be affected by drawing
* primitives.
* 
* Returns: a #cairo_region_t. This must be freed with cairo_region_destroy()
*          when you are done.
**/
3487cairo_region_t*
3488cdk_window_get_clip_region (CdkWindow *window)
3489{
cairo_region_t *result;

g_return_val_if_fail (CDK_WINDOW (window), NULL)do { if ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
)) { } else { g_return_if_fail_warning ("Cdk", ((const char*)
 (__func__)), "CDK_WINDOW (window)"); return (((void*)0)); } }
 while (0);

result = cairo_region_copy (window->clip_region);

if (window->current_paint.region != NULL((void*)0))
  cairo_region_intersect (result, window->current_paint.region);

return result;
3500}

3502/**
* cdk_window_get_visible_region:
* @window: a #CdkWindow
* 
* Computes the region of the @window that is potentially visible.
* This does not necessarily take into account if the window is
* obscured by other windows, but no area outside of this region
* is visible.
* 
* Returns: a #cairo_region_t. This must be freed with cairo_region_destroy()
*          when you are done.
**/
3514cairo_region_t *
3515cdk_window_get_visible_region (CdkWindow *window)
3516{
g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

return cairo_region_copy (window->clip_region);
3520}

3522static void
3523cdk_window_clear_backing_region (CdkWindow *window)
3524{
CdkWindow *bg_window;
cairo_pattern_t *pattern = NULL((void*)0);
int x_offset = 0, y_offset = 0;
cairo_t *cr;

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return;

cr = cairo_create (window->current_paint.surface);

for (bg_window = window; bg_window; bg_window = bg_window->parent)
  {
    pattern = cdk_window_get_background_pattern (bg_window);

    if (pattern)
      break;

    x_offset += bg_window->x;
    y_offset += bg_window->y;
  }

if (pattern)
  {
    cairo_translate (cr, -x_offset, -y_offset);
    cairo_set_source (cr, pattern);
    cairo_translate (cr, x_offset, y_offset);
  }
else
  cairo_set_source_rgb (cr, 0, 0, 0);

cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cdk_cairo_region (cr, window->current_paint.region);
cairo_fill (cr);

cairo_destroy (cr);
3560}

3562/* This returns either the current working surface on the paint stack
* or the actual impl surface of the window. This should not be used
* from very many places: be careful! */
3565static cairo_surface_t *
3566ref_window_surface (CdkWindow *window)
3567{
if (window->impl_window->current_paint.surface)
  return cairo_surface_reference (window->impl_window->current_paint.surface);
else
  return cdk_window_ref_impl_surface (window);
3572}

3574/* This is used in places like cdk_cairo_set_source_window and
* other places to take "screenshots" of windows. Thus, we allow
* it to be used outside of a begin_paint / end_paint. */
3577cairo_surface_t *
3578_cdk_window_ref_cairo_surface (CdkWindow *window)
3579{
cairo_surface_t *surface;

g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

surface = ref_window_surface (window);

if (cdk_window_has_impl (window))
  {
    return surface;
  }
else
  {
    cairo_surface_t *subsurface;
    subsurface = cairo_surface_create_for_rectangle (surface,
                                                     window->abs_x,
                                                     window->abs_y,
                                                     window->width,
                                                     window->height);
    cairo_surface_destroy (surface);
    return subsurface;
  }
3601}

3603/**
* cdk_cairo_create:
* @window: a #CdkWindow
* 
* Creates a Cairo context for drawing to @window.
*
* Note that calling cairo_reset_clip() on the resulting #cairo_t will
* produce undefined results, so avoid it at all costs.
*
* Typically, this function is used to draw on a #CdkWindow out of the paint
* cycle of the toolkit; this should be avoided, as it breaks various assumptions
* and optimizations.
*
* If you are drawing on a native #CdkWindow in response to a %CDK_EXPOSE event
* you should use cdk_window_begin_draw_frame() and cdk_drawing_context_get_cairo_context()
* instead. CTK will automatically do this for you when drawing a widget.
*
* Returns: A newly created Cairo context. Free with
*  cairo_destroy() when you are done drawing.
* 
* Since: 2.8
**/
3625cairo_t *
3626cdk_cairo_create (CdkWindow *window)
3627{
cairo_region_t *region;
cairo_surface_t *surface;
cairo_t *cr;

g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

surface = _cdk_window_ref_cairo_surface (window);

cr = cairo_create (surface);

region = cdk_window_get_current_paint_region (window);
cdk_cairo_region (cr, region);
cairo_region_destroy (region);
cairo_clip (cr);

/* Assign a drawing context, if one is set; if cdk_cairo_create()
 * is called outside of a frame drawing then this is going to be
 * NULL.
 */
cdk_cairo_set_drawing_context (cr, window->drawing_context);

cairo_surface_destroy (surface);

return cr;
3652}

3654/* Code for dirty-region queueing
*/
3656static GSList *update_windows = NULL((void*)0);
3657gboolean _cdk_debug_updates = FALSE(0);

3659static inline gboolean
3660cdk_window_is_ancestor (CdkWindow *window,
	CdkWindow *ancestor)
3662{
while (window)
  {
    CdkWindow *parent = window->parent;

    if (parent == ancestor)
return TRUE(!(0));

    window = parent;
  }

return FALSE(0);
3674}

3676static void
3677cdk_window_add_update_window (CdkWindow *window)
3678{
GSList *tmp;
GSList *prev = NULL((void*)0);
gboolean has_ancestor_in_list = FALSE(0);

/*  Check whether "window" is already in "update_windows" list.
 *  It could be added during execution of ctk_widget_destroy() when
 *  setting focus widget to NULL and redrawing old focus widget.
 *  See bug 711552.
 */
tmp = g_slist_find (update_windows, window);
if (tmp != NULL((void*)0))
  return;

for (tmp = update_windows; tmp; tmp = tmp->next)
  {
    CdkWindow *parent = window->parent;

    /*  check if tmp is an ancestor of "window"; if it is, set a
     *  flag indicating that all following windows are either
     *  children of "window" or from a differen hierarchy
     */
    if (!has_ancestor_in_list && cdk_window_is_ancestor (window, tmp->data))
has_ancestor_in_list = TRUE(!(0));

    /* insert in reverse stacking order when adding around siblings,
     * so processing updates properly paints over lower stacked windows
     */
    if (parent == CDK_WINDOW (tmp->data)((((CdkWindow*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tmp->data)), ((cdk_window_get_type ()))))))->parent)
{
 gint index = g_list_index (parent->children, window);
 for (; tmp && parent == CDK_WINDOW (tmp->data)((((CdkWindow*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tmp->data)), ((cdk_window_get_type ()))))))->parent; tmp = tmp->next)
   {
     gint sibling_index = g_list_index (parent->children, tmp->data);
     if (index > sibling_index)
break;
     prev = tmp;
   }
 /* here, tmp got advanced past all lower stacked siblings */
 tmp = g_slist_prepend (tmp, g_object_ref (window)((__typeof__ (window)) (g_object_ref) (window)));
 if (prev)
   prev->next = tmp;
 else
   update_windows = tmp;
 return;
}

    /*  if "window" has an ancestor in the list and tmp is one of
     *  "window's" children, insert "window" before tmp
     */
    if (has_ancestor_in_list && cdk_window_is_ancestor (tmp->data, window))
{
 tmp = g_slist_prepend (tmp, g_object_ref (window)((__typeof__ (window)) (g_object_ref) (window)));

 if (prev)
   prev->next = tmp;
 else
   update_windows = tmp;
 return;
}

    /*  if we're at the end of the list and had an ancestor it it,
     *  append to the list
     */
    if (! tmp->next && has_ancestor_in_list)
{
 tmp = g_slist_append (tmp, g_object_ref (window)((__typeof__ (window)) (g_object_ref) (window)));
 return;
}

    prev = tmp;
  }

/*  if all above checks failed ("window" is from a different
 *  hierarchy than what is already in the list) or the list is
 *  empty, prepend
 */
update_windows = g_slist_prepend (update_windows, g_object_ref (window)((__typeof__ (window)) (g_object_ref) (window)));
3756}

3758static void
3759cdk_window_remove_update_window (CdkWindow *window)
3760{
GSList *link;

link = g_slist_find (update_windows, window);
if (link != NULL((void*)0))
  {
    update_windows = g_slist_delete_link (update_windows, link);
    g_object_unref (window);
  }
3769}

3771static gboolean
3772cdk_window_is_toplevel_frozen (CdkWindow *window)
3773{
CdkWindow *toplevel;

toplevel = cdk_window_get_toplevel (window);

return toplevel->update_and_descendants_freeze_count > 0;
3779}

3781static void
3782cdk_window_schedule_update (CdkWindow *window)
3783{
CdkFrameClock *frame_clock;

if (window &&
    (window->update_freeze_count ||
     cdk_window_is_toplevel_frozen (window)))
  return;

/* If there's no frame clock (a foreign window), then the invalid
 * region will just stick around unless cdk_window_process_updates()
 * is called. */
frame_clock = cdk_window_get_frame_clock (window);
if (frame_clock)
  cdk_frame_clock_request_phase (cdk_window_get_frame_clock (window),
                                 CDK_FRAME_CLOCK_PHASE_PAINT);
3798}

3800static void
3801cdk_window_add_damage (CdkWindow *toplevel,
                     cairo_region_t *damaged_region)
3803{
CdkDisplay *display;
CdkEvent event = { 0, };

/* This function only makes sense for offscreen windows. */
g_assert (cdk_window_is_offscreen (toplevel))do { if (cdk_window_is_offscreen (toplevel)) ; else g_assertion_message_expr
 ("Cdk", "cdkwindow.c", 3808, ((const char*) (__func__)), "cdk_window_is_offscreen (toplevel)"
); } while (0);

event.expose.type = CDK_DAMAGE;
event.expose.window = toplevel;
event.expose.send_event = FALSE(0);
event.expose.region = damaged_region;
cairo_region_get_extents (event.expose.region, &event.expose.area);

display = cdk_window_get_display (event.expose.window);
_cdk_event_queue_append (display, cdk_event_copy (&event));
3818}

3820static void
3821_cdk_window_process_updates_recurse_helper (CdkWindow *window,
                                          cairo_region_t *expose_region)
3823{
CdkWindow *child;
cairo_region_t *clipped_expose_region;
CdkWindow **children;
CdkWindow **free_children = NULL((void*)0);
int i, n_children;
GList *l;
GList *last_link;

if (window->destroyed)
2
←
Assuming field 'destroyed' is 0→
  return;

if (window->alpha == 0 && !cdk_window_has_impl (window))
3
←
Assuming field 'alpha' is not equal to 0→
  return;

clipped_expose_region = cairo_region_copy (expose_region);

if (!cdk_window_has_impl (window))
4
←
Taking true branch→
  cairo_region_translate (clipped_expose_region, -window->x, -window->y);

cairo_region_intersect (clipped_expose_region, window->clip_region);

if (cairo_region_is_empty (clipped_expose_region))
5
←
Assuming the condition is false→
6
←
Taking false branch→
  goto out;

if (cdk_window_is_offscreen (window))
  cdk_window_add_damage (window, clipped_expose_region);

/* Paint the window before the children, clipped to the window region */

/* While ctk+ no longer handles exposes on anything but native
   window we still have to send them to all windows that have the
   event mask set for backwards compat. We also need to send
   it to all native windows, even if they don't specify the
   expose mask, because they may have non-native children that do. */
if (cdk_window_has_impl (window) ||
8
←
Taking false branch→
    window->event_mask & CDK_EXPOSURE_MASK)
7
←
Assuming the condition is false→
  {
    CdkEvent event;

    event.expose.type = CDK_EXPOSE;
    event.expose.window = window; /* we already hold a ref */
    event.expose.send_event = FALSE(0);
    event.expose.count = 0;
    event.expose.region = clipped_expose_region;
    cairo_region_get_extents (clipped_expose_region, &event.expose.area);

    _cdk_event_emit (&event);
  }

n_children = 0;
last_link = NULL((void*)0);
/* Count n_children and fetch bottommost at same time */
for (l = window->children; l != NULL((void*)0); l = l->next)
9
←
Assuming 'l' is not equal to NULL→
10
←
Loop condition is true.  Entering loop body→
11
←
Assuming 'l' is equal to NULL→
12
←
Loop condition is false. Execution continues on line 3882→
  {
    last_link = l;
    n_children++;
  }

children = g_newa (CdkWindow *, n_children)((CdkWindow **) __builtin_alloca (sizeof (CdkWindow *) * (gsize
) (n_children)));
if (children12.1
'children' is not equal to NULL
 == NULL((void*)0))
13
←
Taking false branch→
  children = free_children = g_new (CdkWindow *, n_children)((CdkWindow * *) g_malloc_n ((n_children), sizeof (CdkWindow *
)));

n_children = 0;
/* Iterate over children, starting at bottommost */
for (l = last_link; l13.1
'l' is not equal to NULL
 != NULL((void*)0); l = l->prev)
14
←
Loop condition is true.  Entering loop body→
23
←
Assuming 'l' is not equal to NULL→
24
←
Loop condition is true.  Entering loop body→
  {
    child = l->data;

    if (child->destroyed || !CDK_WINDOW_IS_MAPPED (child)(((child)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0) || child->input_only || child->composited)
15
←
Assuming field 'destroyed' is 0→
16
←
Assuming the condition is true→
17
←
Assuming field 'input_only' is 0→
18
←
Assuming field 'composited' is 0→
19
←
Taking false branch→
25
←
Assuming field 'destroyed' is 0→
26
←
Assuming the condition is true→
27
←
Assuming field 'input_only' is 0→
28
←
Assuming field 'composited' is 0→
29
←
Taking false branch→
      continue;

    /* Ignore offscreen children, as they don't draw in their parent and
     * don't take part in the clipping */
    if (cdk_window_is_offscreen (child))
20
←
Taking false branch→
30
←
Taking false branch→
      continue;

    /* Client side child, expose */
    if (child->impl == window->impl)
21
←
Assuming 'child->impl' is equal to 'window->impl'→
22
←
Taking true branch→
31
←
Assuming 'child->impl' is equal to 'window->impl'→
32
←
Taking true branch→
      {
        /* ref the child to make this reentrancy safe for expose
           handlers freeing other windows */
        children[n_children++] = g_object_ref (child)((__typeof__ (child)) (g_object_ref) (child));
33
←
Access of the memory returned by 'alloca' at index 1, while it holds only a single 'struct _CdkWindow *' element
      }
  }

for (i = 0; i < n_children; i++)
  {
    _cdk_window_process_updates_recurse_helper ((CdkWindow *)children[i],
                                                clipped_expose_region);
    g_object_unref (children[i]);
  }


g_free (free_children);

out:
cairo_region_destroy (clipped_expose_region);
3921}

3923void
3924_cdk_window_process_updates_recurse (CdkWindow *window,
                                   cairo_region_t *expose_region)
3926{
_cdk_window_process_updates_recurse_helper (window, expose_region);
1
Calling '_cdk_window_process_updates_recurse_helper'→
3928}


3931static void
3932cdk_window_update_native_shapes (CdkWindow *window)
3933{
CdkWindow *child;
GList *l;

if (should_apply_clip_as_shape (window))
  apply_clip_as_shape (window);

for (l = window->native_children; l != NULL((void*)0); l = l->next)
  {
    child = l->data;

    cdk_window_update_native_shapes (child);
  }
3946}

3948/* Process and remove any invalid area on the native window by creating
* expose events for the window and all non-native descendants.
*/
3951static void
3952cdk_window_process_updates_internal (CdkWindow *window)
3953{
CdkWindowImplClass *impl_class;
CdkWindow *toplevel;
CdkDisplay *display;

display = cdk_window_get_display (window);
toplevel = cdk_window_get_toplevel (window);
if (toplevel->geometry_dirty)
  {
    cdk_window_update_native_shapes (toplevel);
    toplevel->geometry_dirty = FALSE(0);
  }

/* Ensure the window lives while updating it */
g_object_ref (window)((__typeof__ (window)) (g_object_ref) (window));

window->in_update = TRUE(!(0));

/* If an update got queued during update processing, we can get a
 * window in the update queue that has an empty update_area.
 * just ignore it.
 */
if (window->update_area)
  {
    g_assert (window->active_update_area == NULL)do { if (window->active_update_area == ((void*)0)) ; else g_assertion_message_expr
 ("Cdk", "cdkwindow.c", 3977, ((const char*) (__func__)), "window->active_update_area == NULL"
); } while (0); /* No reentrancy */

    window->active_update_area = window->update_area;
    window->update_area = NULL((void*)0);

    if (cdk_window_is_viewable (window))
{
 cairo_region_t *expose_region;

 expose_region = cairo_region_copy (window->active_update_area);

 impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));

        /* Sometimes we can't just paint only the new area, as the windowing system
         * requires more to be repainted. For instance, with OpenGL you typically
         * repaint all of each frame each time and then swap the buffer, although
         * there are extensions that allow us to reuse part of an old frame.
         */
        if (impl_class->invalidate_for_new_frame)
          impl_class->invalidate_for_new_frame (window, expose_region);

 /* Clip to part visible in impl window */
 cairo_region_intersect (expose_region, window->clip_region);

 if (cdk_display_get_debug_updates (display))
   {
            cairo_region_t *swap_region = cairo_region_copy (expose_region);
            cairo_region_subtract (swap_region, window->active_update_area);
            draw_ugly_color (window, swap_region, 1);
            cairo_region_destroy (swap_region);

     /* Make sure we see the red invalid area before redrawing. */
     cdk_display_sync (cdk_window_get_display (window));
     g_usleep (70000);
   }

        if (impl_class->queue_antiexpose)
          impl_class->queue_antiexpose (window, expose_region);

        impl_class->process_updates_recurse (window, expose_region);

        cdk_window_append_old_updated_area (window, window->active_update_area);

        cairo_region_destroy (expose_region);
      }

    cairo_region_destroy (window->active_update_area);
    window->active_update_area = NULL((void*)0);
  }

window->in_update = FALSE(0);

g_object_unref (window);
4030}

4032static void
4033flush_all_displays (void)
4034{
GSList *displays, *l;

displays = cdk_display_manager_list_displays (cdk_display_manager_get ());
for (l = displays; l; l = l->next)
  cdk_display_flush (l->data);

g_slist_free (displays);
4042}

4044static void
4045before_process_all_updates (void)
4046{
GSList *displays, *l;

displays = cdk_display_manager_list_displays (cdk_display_manager_get ());
for (l = displays; l; l = l->next)
  CDK_DISPLAY_GET_CLASS (l->data)((((CdkDisplayClass*) (((GTypeInstance*) ((l->data)))->
g_class))))->before_process_all_updates (l->data);

g_slist_free (displays);
4054}

4056static void
4057after_process_all_updates (void)
4058{
GSList *displays, *l;

displays = cdk_display_manager_list_displays (cdk_display_manager_get ());
for (l = displays; l; l = l->next)
  CDK_DISPLAY_GET_CLASS (l->data)((((CdkDisplayClass*) (((GTypeInstance*) ((l->data)))->
g_class))))->after_process_all_updates (l->data);

g_slist_free (displays);
4066}

4068/* Currently it is not possible to override
* cdk_window_process_all_updates in the same manner as
* cdk_window_process_updates and cdk_window_invalidate_maybe_recurse
* by implementing the CdkPaintable interface.  If in the future a
* backend would need this, the right solution would be to add a
* method to CdkDisplay that can be optionally
* NULL. cdk_window_process_all_updates can then walk the list of open
* displays and call the mehod.
*/

4078/**
* cdk_window_process_all_updates:
*
* Calls cdk_window_process_updates() for all windows (see #CdkWindow)
* in the application.
**/
4084void
4085cdk_window_process_all_updates (void)
4086{
GSList *old_update_windows = update_windows;
GSList *tmp_list = update_windows;
static gboolean in_process_all_updates = FALSE(0);
static gboolean got_recursive_update = FALSE(0);

if (in_process_all_updates)
  {
    /* We can't do this now since that would recurse, so
delay it until after the recursion is done. */
    got_recursive_update = TRUE(!(0));
    return;
  }

in_process_all_updates = TRUE(!(0));
got_recursive_update = FALSE(0);

update_windows = NULL((void*)0);

before_process_all_updates ();

while (tmp_list)
  {
    CdkWindow *window = tmp_list->data;

    if (!CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
{
 if (window->update_freeze_count ||
     cdk_window_is_toplevel_frozen (window))
   cdk_window_add_update_window (window);
 else
   cdk_window_process_updates_internal (window);
}

    g_object_unref (window);
    tmp_list = tmp_list->next;
  }

g_slist_free (old_update_windows);

flush_all_displays ();

after_process_all_updates ();

in_process_all_updates = FALSE(0);

/* If we ignored a recursive call, schedule a
   redraw now so that it eventually happens,
   otherwise we could miss an update if nothing
   else schedules an update. */
if (got_recursive_update)
  cdk_window_schedule_update (NULL((void*)0));
4138}


4141enum {
PROCESS_UPDATES_NO_RECURSE,
PROCESS_UPDATES_WITH_ALL_CHILDREN,
PROCESS_UPDATES_WITH_SAME_CLOCK_CHILDREN
4145};

4147static void
4148find_impl_windows_to_update (GPtrArray  *list,
                           CdkWindow  *window,
                           gint        recurse_mode)
4151{
GList *node;

/* Recurse first, so that we process updates in reverse stacking
 * order so composition or painting over achieves the desired effect
 * for offscreen windows
 */
if (recurse_mode != PROCESS_UPDATES_NO_RECURSE)
  {
    for (node = window->children; node; node = node->next)
      {
        CdkWindow *child = node->data;

        if (!CDK_WINDOW_DESTROYED (child)(((CdkWindow *)(child))->destroyed) &&
            (recurse_mode == PROCESS_UPDATES_WITH_ALL_CHILDREN ||
            (recurse_mode == PROCESS_UPDATES_WITH_SAME_CLOCK_CHILDREN &&
             child->frame_clock == NULL((void*)0))))
          {
            find_impl_windows_to_update (list, child, recurse_mode);
          }
      }
  }

/* add reference count so the window cannot be deleted in a callback */
if (window->impl_window == window)
  g_ptr_array_add (list, g_object_ref (window)((__typeof__ (window)) (g_object_ref) (window)));
4177}

4179static void
4180cdk_window_process_updates_with_mode (CdkWindow     *window,
                                    int            recurse_mode)
4182{
GPtrArray *list;
int i;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return;

list = g_ptr_array_new_with_free_func (g_object_unref);
find_impl_windows_to_update (list, window, recurse_mode);

if (window->impl_window != window)
  g_ptr_array_add (list, g_object_ref (window->impl_window)((__typeof__ (window->impl_window)) (g_object_ref) (window
->impl_window)));

for (i = (int)list->len - 1; i >= 0; i --)
  {
    CdkWindow *impl_window = g_ptr_array_index (list, i)((list)->pdata)[i];

    if (impl_window->update_area &&
        !impl_window->update_freeze_count &&
        !cdk_window_is_toplevel_frozen (impl_window) &&

        /* Don't recurse into process_updates_internal, we'll
         * do the update later when idle instead. */
        !impl_window->in_update)
      {
        cdk_window_process_updates_internal (impl_window);
        cdk_window_remove_update_window (impl_window);
      }
  }

g_ptr_array_free (list, TRUE(!(0)));
4215}

4217/**
* cdk_window_process_updates:
* @window: a #CdkWindow
* @update_children: whether to also process updates for child windows
*
* Sends one or more expose events to @window. The areas in each
* expose event will cover the entire update area for the window (see
* cdk_window_invalidate_region() for details). Normally CDK calls
* cdk_window_process_all_updates() on your behalf, so there’s no
* need to call this function unless you want to force expose events
* to be delivered immediately and synchronously (vs. the usual
* case, where CDK delivers them in an idle handler). Occasionally
* this is useful to produce nicer scrolling behavior, for example.
**/
4231void
4232cdk_window_process_updates (CdkWindow *window,
	    gboolean   update_children)
4234{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

cdk_window_process_updates_with_mode (window,
                                      update_children ?
                                      PROCESS_UPDATES_WITH_ALL_CHILDREN :
                                      PROCESS_UPDATES_NO_RECURSE);
4241}

4243static void
4244cdk_window_invalidate_rect_full (CdkWindow          *window,
		  const CdkRectangle *rect,
		  gboolean            invalidate_children)
4247{
CdkRectangle window_rect;
cairo_region_t *region;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return;

if (window->input_only || !window->viewable)
  return;

if (!rect)
  {
    window_rect.x = 0;
    window_rect.y = 0;
    window_rect.width = window->width;
    window_rect.height = window->height;
    rect = &window_rect;
  }

region = cairo_region_create_rectangle (rect);
cdk_window_invalidate_region_full (window, region, invalidate_children);
cairo_region_destroy (region);
4271}

4273/**
* cdk_window_invalidate_rect:
* @window: a #CdkWindow
* @rect: (allow-none): rectangle to invalidate or %NULL to invalidate the whole
*      window
* @invalidate_children: whether to also invalidate child windows
*
* A convenience wrapper around cdk_window_invalidate_region() which
* invalidates a rectangular region. See
* cdk_window_invalidate_region() for details.
**/
4284void
4285cdk_window_invalidate_rect (CdkWindow          *window,
	    const CdkRectangle *rect,
	    gboolean            invalidate_children)
4288{
cdk_window_invalidate_rect_full (window, rect, invalidate_children);
4290}

4292/**
* cdk_window_set_invalidate_handler: (skip)
* @window: a #CdkWindow
* @handler: a #CdkWindowInvalidateHandlerFunc callback function
*
* Registers an invalidate handler for a specific window. This
* will get called whenever a region in the window or its children
* is invalidated.
*
* This can be used to record the invalidated region, which is
* useful if you are keeping an offscreen copy of some region
* and want to keep it up to date. You can also modify the
* invalidated region in case you’re doing some effect where
* e.g. a child widget appears in multiple places.
*
* Since: 3.10
**/
4309void
4310cdk_window_set_invalidate_handler (CdkWindow                      *window,
		   CdkWindowInvalidateHandlerFunc  handler)
4312{
window->invalidate_handler = handler;
4314}

4316static void
4317draw_ugly_color (CdkWindow       *window,
 const cairo_region_t *region,
               int color)
4320{
cairo_t *cr;

cr = cdk_cairo_create (window);

/* Draw ugly color all over the newly-invalid region */
if (color == 0)
  cairo_set_source_rgb (cr, 50000/65535., 10000/65535., 10000/65535.);
else
  cairo_set_source_rgb (cr, 10000/65535., 50000/65535., 10000/65535.);

cdk_cairo_region (cr, region);
cairo_fill (cr);

cairo_destroy (cr);
4335}

4337static void
4338impl_window_add_update_area (CdkWindow *impl_window,
	     cairo_region_t *region)
4340{
if (impl_window->update_area)
  cairo_region_union (impl_window->update_area, region);
else
  {
    cdk_window_add_update_window (impl_window);
    impl_window->update_area = cairo_region_copy (region);
    cdk_window_schedule_update (impl_window);
  }
4349}

4351static void
4352cdk_window_invalidate_maybe_recurse_full (CdkWindow            *window,
			  const cairo_region_t *region,
                                        CdkWindowChildFunc    child_func,
			  gpointer              user_data);

4357/* Returns true if window is a decendant of parent, but stops looking
* at the first native window. Also ensures that all parents match
* child_func if non-null..
*
* This is useful in combination with
* window->impl_window->native_children as it lets you find all native
* decendants in an efficient way (assuming few children are native).
*/
4365static gboolean
4366has_visible_ancestor_in_impl (CdkWindow *window,
                            CdkWindow *ancestor,
                            CdkWindowChildFunc child_func,
                            gpointer user_data)
4370{
CdkWindow *p;
CdkWindow *stop_at;

p = window->parent;
stop_at = p->impl_window;
while (p != NULL((void*)0))
  {
    if (!p->viewable)
      return FALSE(0);
    if (child_func &&
        !(*child_func) ((CdkWindow *)p, user_data))
      return FALSE(0);
    if (p == ancestor)
      return TRUE(!(0));
    if (p == stop_at)
      return FALSE(0);
    p = p->parent;
  }
return FALSE(0);
4390}

4392static void
4393invalidate_impl_subwindows (CdkWindow            *window,
	    const cairo_region_t *region,
	    CdkWindowChildFunc    child_func,
	    gpointer              user_data)
4397{
GList *l;

/* Iterate over all native children of the native window
   that window is in. */
for (l = window->impl_window->native_children;
     l != NULL((void*)0);
     l = l->next)
  {
    CdkWindow *native_child = l->data;
    cairo_region_t *tmp;
    int dx, dy;

    if (native_child->input_only)
continue;

    /* Then skip any that does not have window as an ancestor,
     * also checking that the ancestors are visible and pass child_func
     * This is fast if we assume native children are rare */
    if (!has_visible_ancestor_in_impl (native_child, window,
                                       child_func, user_data))
      continue;

    dx = native_child->parent->abs_x + native_child->x - window->abs_x;
    dy = native_child->parent->abs_y + native_child->y - window->abs_y;

    tmp = cairo_region_copy (region);
    cairo_region_translate (tmp, -dx, -dy);
    cdk_window_invalidate_maybe_recurse_full (native_child,
                                              tmp, child_func, user_data);
    cairo_region_destroy (tmp);
  }
4429}

4431static void
4432cdk_window_invalidate_maybe_recurse_full (CdkWindow            *window,
			  const cairo_region_t *region,
                                        CdkWindowChildFunc    child_func,
			  gpointer              user_data)
4436{
cairo_region_t *visible_region;
cairo_rectangle_int_t r;
CdkDisplay *display;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return;

if (window->input_only ||
    !window->viewable ||
    cairo_region_is_empty (region) ||
    window->window_type == CDK_WINDOW_ROOT)
  return;

r.x = 0;
r.y = 0;

visible_region = cairo_region_copy (region);

if (child_func)
  invalidate_impl_subwindows (window, region, child_func, user_data);

display = cdk_window_get_display (window);
if (cdk_display_get_debug_updates (display))
  draw_ugly_color (window, visible_region, 0);

while (window != NULL((void*)0) && 
!cairo_region_is_empty (visible_region))
  {
    if (window->invalidate_handler)
window->invalidate_handler (window, visible_region);

    r.width = window->width;
    r.height = window->height;
    cairo_region_intersect_rectangle (visible_region, &r);

    if (cdk_window_has_impl (window))
{
 impl_window_add_update_area (window, visible_region);
 break;
}
    else
{
 cairo_region_translate (visible_region,
		  window->x, window->y);
 window = window->parent;
}
  }

cairo_region_destroy (visible_region);
4488}

4490/**
* cdk_window_invalidate_maybe_recurse:
* @window: a #CdkWindow
* @region: a #cairo_region_t
* @child_func: (scope call) (allow-none): function to use to decide if to
*     recurse to a child, %NULL means never recurse.
* @user_data: data passed to @child_func
*
* Adds @region to the update area for @window. The update area is the
* region that needs to be redrawn, or “dirty region.” The call
* cdk_window_process_updates() sends one or more expose events to the
* window, which together cover the entire update area. An
* application would normally redraw the contents of @window in
* response to those expose events.
*
* CDK will call cdk_window_process_all_updates() on your behalf
* whenever your program returns to the main loop and becomes idle, so
* normally there’s no need to do that manually, you just need to
* invalidate regions that you know should be redrawn.
*
* The @child_func parameter controls whether the region of
* each child window that intersects @region will also be invalidated.
* Only children for which @child_func returns #TRUE will have the area
* invalidated.
**/
4515void
4516cdk_window_invalidate_maybe_recurse (CdkWindow            *window,
		     const cairo_region_t *region,
                                   CdkWindowChildFunc    child_func,
		     gpointer              user_data)
4520{
cdk_window_invalidate_maybe_recurse_full (window, region,
			    child_func, user_data);
4523}

4525static gboolean
4526true_predicate (CdkWindow *window G_GNUC_UNUSED__attribute__ ((__unused__)),
gpointer   user_data G_GNUC_UNUSED__attribute__ ((__unused__)))
4528{
return TRUE(!(0));
4530}

4532static void
4533cdk_window_invalidate_region_full (CdkWindow       *window,
		    const cairo_region_t *region,
		    gboolean         invalidate_children)
4536{
cdk_window_invalidate_maybe_recurse_full (window, region,
			    invalidate_children ?
			    true_predicate : (gboolean (*) (CdkWindow *, gpointer))NULL((void*)0),
		       NULL((void*)0));
4541}

4543/**
* cdk_window_invalidate_region:
* @window: a #CdkWindow
* @region: a #cairo_region_t
* @invalidate_children: %TRUE to also invalidate child windows
*
* Adds @region to the update area for @window. The update area is the
* region that needs to be redrawn, or “dirty region.” The call
* cdk_window_process_updates() sends one or more expose events to the
* window, which together cover the entire update area. An
* application would normally redraw the contents of @window in
* response to those expose events.
*
* CDK will call cdk_window_process_all_updates() on your behalf
* whenever your program returns to the main loop and becomes idle, so
* normally there’s no need to do that manually, you just need to
* invalidate regions that you know should be redrawn.
*
* The @invalidate_children parameter controls whether the region of
* each child window that intersects @region will also be invalidated.
* If %FALSE, then the update area for child windows will remain
* unaffected. See cdk_window_invalidate_maybe_recurse if you need
* fine grained control over which children are invalidated.
**/
4567void
4568cdk_window_invalidate_region (CdkWindow       *window,
	      const cairo_region_t *region,
	      gboolean         invalidate_children)
4571{
cdk_window_invalidate_maybe_recurse (window, region,
		       invalidate_children ?
			 true_predicate : (gboolean (*) (CdkWindow *, gpointer))NULL((void*)0),
		       NULL((void*)0));
4576}

4578/**
* _cdk_window_invalidate_for_expose:
* @window: a #CdkWindow
* @region: a #cairo_region_t
*
* Adds @region to the update area for @window. The update area is the
* region that needs to be redrawn, or “dirty region.” The call
* cdk_window_process_updates() sends one or more expose events to the
* window, which together cover the entire update area. An
* application would normally redraw the contents of @window in
* response to those expose events.
*
* CDK will call cdk_window_process_all_updates() on your behalf
* whenever your program returns to the main loop and becomes idle, so
* normally there’s no need to do that manually, you just need to
* invalidate regions that you know should be redrawn.
*
* This version of invalidation is used when you recieve expose events
* from the native window system. It exposes the native window, plus
* any non-native child windows (but not native child windows, as those would
* have gotten their own expose events).
**/
4600void
4601_cdk_window_invalidate_for_expose (CdkWindow       *window,
		   cairo_region_t       *region)
4603{
cdk_window_invalidate_maybe_recurse_full (window, region,
			    (gboolean (*) (CdkWindow *, gpointer))cdk_window_has_no_impl,
			    NULL((void*)0));
4607}


4610/**
* cdk_window_get_update_area:
* @window: a #CdkWindow
*
* Transfers ownership of the update area from @window to the caller
* of the function. That is, after calling this function, @window will
* no longer have an invalid/dirty region; the update area is removed
* from @window and handed to you. If a window has no update area,
* cdk_window_get_update_area() returns %NULL. You are responsible for
* calling cairo_region_destroy() on the returned region if it’s non-%NULL.
*
* Returns: the update area for @window
**/
4623cairo_region_t *
4624cdk_window_get_update_area (CdkWindow *window)
4625{
CdkWindow *impl_window;
cairo_region_t *tmp_region, *to_remove;

g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

impl_window = cdk_window_get_impl_window (window);

if (impl_window->update_area)
  {
    tmp_region = cairo_region_copy (window->clip_region);
    /* Convert to impl coords */
    cairo_region_translate (tmp_region, window->abs_x, window->abs_y);
    cairo_region_intersect (tmp_region, impl_window->update_area);

    if (cairo_region_is_empty (tmp_region))
{
 cairo_region_destroy (tmp_region);
 return NULL((void*)0);
}
    else
{
 /* Convert from impl coords */
 cairo_region_translate (tmp_region, -window->abs_x, -window->abs_y);

 /* Don't remove any update area that is overlapped by sibling windows
    or child windows as these really need to be repainted independently of this window. */
 to_remove = cairo_region_copy (tmp_region);

 remove_child_area (window, FALSE(0), to_remove);
 remove_sibling_overlapped_area (window, to_remove);

 /* Remove from update_area */
 cairo_region_translate (to_remove, window->abs_x, window->abs_y);
 cairo_region_subtract (impl_window->update_area, to_remove);

 cairo_region_destroy (to_remove);

 if (cairo_region_is_empty (impl_window->update_area))
   {
     cairo_region_destroy (impl_window->update_area);
     impl_window->update_area = NULL((void*)0);

     cdk_window_remove_update_window ((CdkWindow *)impl_window);
   }

 return tmp_region;
}
  }
else
  return NULL((void*)0);
4676}

4678/**
* _cdk_window_clear_update_area:
* @window: a #CdkWindow.
*
* Internal function to clear the update area for a window. This
* is called when the window is hidden or destroyed.
**/
4685void
4686_cdk_window_clear_update_area (CdkWindow *window)
4687{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (window->update_area)
  {
    cdk_window_remove_update_window (window);

    cairo_region_destroy (window->update_area);
    window->update_area = NULL((void*)0);
  }
4697}

4699/**
* cdk_window_freeze_updates:
* @window: a #CdkWindow
*
* Temporarily freezes a window such that it won’t receive expose
* events.  The window will begin receiving expose events again when
* cdk_window_thaw_updates() is called. If cdk_window_freeze_updates()
* has been called more than once, cdk_window_thaw_updates() must be called
* an equal number of times to begin processing exposes.
**/
4709void
4710cdk_window_freeze_updates (CdkWindow *window)
4711{
CdkWindow *impl_window;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

impl_window = cdk_window_get_impl_window (window);
impl_window->update_freeze_count++;
4718}

4720/**
* cdk_window_thaw_updates:
* @window: a #CdkWindow
*
* Thaws a window frozen with cdk_window_freeze_updates().
**/
4726void
4727cdk_window_thaw_updates (CdkWindow *window)
4728{
CdkWindow *impl_window;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

impl_window = cdk_window_get_impl_window (window);

g_return_if_fail (impl_window->update_freeze_count > 0)do { if ((impl_window->update_freeze_count > 0)) { } else
 { g_return_if_fail_warning ("Cdk", ((const char*) (__func__)
), "impl_window->update_freeze_count > 0"); return; } }
 while (0);

if (--impl_window->update_freeze_count == 0)
  cdk_window_schedule_update (CDK_WINDOW (impl_window)((((CdkWindow*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((impl_window)), ((cdk_window_get_type ())))))));
4739}

4741/**
* cdk_window_freeze_toplevel_updates_libctk_only:
* @window: a #CdkWindow
*
* Temporarily freezes a window and all its descendants such that it won't
* receive expose events.  The window will begin receiving expose events
* again when cdk_window_thaw_toplevel_updates_libctk_only() is called. If
* cdk_window_freeze_toplevel_updates_libctk_only()
* has been called more than once,
* cdk_window_thaw_toplevel_updates_libctk_only() must be called
* an equal number of times to begin processing exposes.
*
* This function is not part of the CDK public API and is only
* for use by CTK+.
*
* Deprecated: 3.16: This symbol was never meant to be used outside of CTK+
*/
4758void
4759cdk_window_freeze_toplevel_updates_libctk_only (CdkWindow *window)
4760{
cdk_window_freeze_toplevel_updates (window);
4762}

4764void
4765cdk_window_freeze_toplevel_updates (CdkWindow *window)
4766{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);
g_return_if_fail (window->window_type != CDK_WINDOW_CHILD)do { if ((window->window_type != CDK_WINDOW_CHILD)) { } else
 { g_return_if_fail_warning ("Cdk", ((const char*) (__func__)
), "window->window_type != CDK_WINDOW_CHILD"); return; } }
 while (0);

window->update_and_descendants_freeze_count++;
_cdk_frame_clock_freeze (cdk_window_get_frame_clock (window));
4772}

4774/**
* cdk_window_thaw_toplevel_updates_libctk_only:
* @window: a #CdkWindow
*
* Thaws a window frozen with
* cdk_window_freeze_toplevel_updates_libctk_only().
*
* This function is not part of the CDK public API and is only
* for use by CTK+.
*
* Deprecated: 3.16: This symbol was never meant to be used outside of CTK+
*/
4786void
4787cdk_window_thaw_toplevel_updates_libctk_only (CdkWindow *window)
4788{
cdk_window_thaw_toplevel_updates (window);
4790}

4792void
4793cdk_window_thaw_toplevel_updates (CdkWindow *window)
4794{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);
g_return_if_fail (window->window_type != CDK_WINDOW_CHILD)do { if ((window->window_type != CDK_WINDOW_CHILD)) { } else
 { g_return_if_fail_warning ("Cdk", ((const char*) (__func__)
), "window->window_type != CDK_WINDOW_CHILD"); return; } }
 while (0);
g_return_if_fail (window->update_and_descendants_freeze_count > 0)do { if ((window->update_and_descendants_freeze_count >
 0)) { } else { g_return_if_fail_warning ("Cdk", ((const char
*) (__func__)), "window->update_and_descendants_freeze_count > 0"
); return; } } while (0);

window->update_and_descendants_freeze_count--;
_cdk_frame_clock_thaw (cdk_window_get_frame_clock (window));

cdk_window_schedule_update (window);
4803}

4805/**
* cdk_window_set_debug_updates:
* @setting: %TRUE to turn on update debugging
*
* With update debugging enabled, calls to
* cdk_window_invalidate_region() clear the invalidated region of the
* screen to a noticeable color, and CDK pauses for a short time
* before sending exposes to windows during
* cdk_window_process_updates().  The net effect is that you can see
* the invalid region for each window and watch redraws as they
* occur. This allows you to diagnose inefficiencies in your application.
*
* In essence, because the CDK rendering model prevents all flicker,
* if you are redrawing the same region 400 times you may never
* notice, aside from noticing a speed problem. Enabling update
* debugging causes CTK to flicker slowly and noticeably, so you can
* see exactly what’s being redrawn when, in what order.
*
* The --ctk-debug=updates command line option passed to CTK+ programs
* enables this debug option at application startup time. That's
* usually more useful than calling cdk_window_set_debug_updates()
* yourself, though you might want to use this function to enable
* updates sometime after application startup time.
*/
4829void
4830cdk_window_set_debug_updates (gboolean setting)
4831{
_cdk_debug_updates = setting;
4833}

4835/**
* cdk_window_constrain_size:
* @geometry: a #CdkGeometry structure
* @flags: a mask indicating what portions of @geometry are set
* @width: desired width of window
* @height: desired height of the window
* @new_width: (out): location to store resulting width
* @new_height: (out): location to store resulting height
*
* Constrains a desired width and height according to a
* set of geometry hints (such as minimum and maximum size).
*/
4847void
4848cdk_window_constrain_size (CdkGeometry    *geometry,
	   CdkWindowHints  flags,
	   gint            width,
	   gint            height,
	   gint           *new_width,
	   gint           *new_height)
4854{
/* This routine is partially borrowed from fvwm.
 *
 * Copyright 1993, Robert Nation
 *     You may use this code for any purpose, as long as the original
 *     copyright remains in the source code and all documentation
 *
 * which in turn borrows parts of the algorithm from uwm
 */
gint min_width = 0;
gint min_height = 0;
gint base_width = 0;
gint base_height = 0;
gint xinc = 1;
gint yinc = 1;
gint max_width = G_MAXINT2147483647;
gint max_height = G_MAXINT2147483647;

4872#define FLOOR(value, base)	( ((gint) ((value) / (base))) * (base) )

if ((flags & CDK_HINT_BASE_SIZE) && (flags & CDK_HINT_MIN_SIZE))
  {
    base_width = geometry->base_width;
    base_height = geometry->base_height;
    min_width = geometry->min_width;
    min_height = geometry->min_height;
  }
else if (flags & CDK_HINT_BASE_SIZE)
  {
    base_width = geometry->base_width;
    base_height = geometry->base_height;
    min_width = geometry->base_width;
    min_height = geometry->base_height;
  }
else if (flags & CDK_HINT_MIN_SIZE)
  {
    base_width = geometry->min_width;
    base_height = geometry->min_height;
    min_width = geometry->min_width;
    min_height = geometry->min_height;
  }

if (flags & CDK_HINT_MAX_SIZE)
  {
    max_width = geometry->max_width ;
    max_height = geometry->max_height;
  }

if (flags & CDK_HINT_RESIZE_INC)
  {
    xinc = MAX (xinc, geometry->width_inc)(((xinc) > (geometry->width_inc)) ? (xinc) : (geometry->
width_inc));
    yinc = MAX (yinc, geometry->height_inc)(((yinc) > (geometry->height_inc)) ? (yinc) : (geometry
->height_inc));
  }

/* clamp width and height to min and max values
 */
width = CLAMP (width, min_width, max_width)(((width) > (max_width)) ? (max_width) : (((width) < (min_width
)) ? (min_width) : (width)));
height = CLAMP (height, min_height, max_height)(((height) > (max_height)) ? (max_height) : (((height) <
 (min_height)) ? (min_height) : (height)));

/* shrink to base + N * inc
 */
width = base_width + FLOOR (width - base_width, xinc);
height = base_height + FLOOR (height - base_height, yinc);

/* constrain aspect ratio, according to:
 *
 *                width
 * min_aspect <= -------- <= max_aspect
 *                height
 */

if (flags & CDK_HINT_ASPECT &&
    geometry->min_aspect > 0 &&
    geometry->max_aspect > 0)
  {
    gint delta;

    if (geometry->min_aspect * height > width)
{
 delta = FLOOR (height - width / geometry->min_aspect, yinc);
 if (height - delta >= min_height)
   height -= delta;
 else
   {
     delta = FLOOR (height * geometry->min_aspect - width, xinc);
     if (width + delta <= max_width)
width += delta;
   }
}

    if (geometry->max_aspect * height < width)
{
 delta = FLOOR (width - height * geometry->max_aspect, xinc);
 if (width - delta >= min_width)
   width -= delta;
 else
   {
     delta = FLOOR (width / geometry->max_aspect - height, yinc);
     if (height + delta <= max_height)
height += delta;
   }
}
  }

4958#undef FLOOR

*new_width = width;
*new_height = height;
4962}

4964/**
* cdk_window_get_pointer:
* @window: a #CdkWindow
* @x: (out) (allow-none): return location for X coordinate of pointer or %NULL to not
*      return the X coordinate
* @y: (out) (allow-none):  return location for Y coordinate of pointer or %NULL to not
*      return the Y coordinate
* @mask: (out) (allow-none): return location for modifier mask or %NULL to not return the
*      modifier mask
*
* Obtains the current pointer position and modifier state.
* The position is given in coordinates relative to the upper left
* corner of @window.
*
* Returns: (nullable) (transfer none): the window containing the
* pointer (as with cdk_window_at_pointer()), or %NULL if the window
* containing the pointer isn’t known to CDK
**/
4982CdkWindow*
4983cdk_window_get_pointer (CdkWindow	  *window,
	gint		  *x,
	gint		  *y,
	CdkModifierType   *mask)
4987{
CdkDisplay *display;
CdkDevice *pointer;

g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

display = cdk_window_get_display (window);
pointer = cdk_seat_get_pointer (cdk_display_get_default_seat (display));

return cdk_window_get_device_position (window, pointer, x, y, mask);
4997}

4999/**
* cdk_window_get_device_position_double:
* @window: a #CdkWindow.
* @device: pointer #CdkDevice to query to.
* @x: (out) (allow-none): return location for the X coordinate of @device, or %NULL.
* @y: (out) (allow-none): return location for the Y coordinate of @device, or %NULL.
* @mask: (out) (allow-none): return location for the modifier mask, or %NULL.
*
* Obtains the current device position in doubles and modifier state.
* The position is given in coordinates relative to the upper left
* corner of @window.
*
* Returns: (nullable) (transfer none): The window underneath @device
* (as with cdk_device_get_window_at_position()), or %NULL if the
* window is not known to CDK.
*
* Since: 3.10
**/
5017CdkWindow *
5018cdk_window_get_device_position_double (CdkWindow       *window,
                                     CdkDevice       *device,
                                     double          *x,
                                     double          *y,
                                     CdkModifierType *mask)
5023{
gdouble tmp_x, tmp_y;
CdkModifierType tmp_mask;
gboolean normal_child;

g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);
g_return_val_if_fail (CDK_IS_DEVICE (device), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((device)); GType __t = ((cdk_device_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_DEVICE (device)"); return (((void*)0)); } } while
 (0);
g_return_val_if_fail (cdk_device_get_source (device) != CDK_SOURCE_KEYBOARD, NULL)do { if ((cdk_device_get_source (device) != CDK_SOURCE_KEYBOARD
)) { } else { g_return_if_fail_warning ("Cdk", ((const char*)
 (__func__)), "cdk_device_get_source (device) != CDK_SOURCE_KEYBOARD"
); return (((void*)0)); } } while (0);

tmp_x = tmp_y = 0;
tmp_mask = 0;
normal_child = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->get_device_state (window,
                                                                           device,
                                                                           &tmp_x, &tmp_y,
                                                                           &tmp_mask);
/* We got the coords on the impl, convert to the window */
tmp_x -= window->abs_x;
tmp_y -= window->abs_y;

if (x)
  *x = tmp_x;
if (y)
  *y = tmp_y;
if (mask)
  *mask = tmp_mask;

_cdk_display_enable_motion_hints (cdk_window_get_display (window), device);

if (normal_child)
  return _cdk_window_find_child_at (window, tmp_x, tmp_y);
return NULL((void*)0);
5054}

5056/**
* cdk_window_get_device_position:
* @window: a #CdkWindow.
* @device: pointer #CdkDevice to query to.
* @x: (out) (allow-none): return location for the X coordinate of @device, or %NULL.
* @y: (out) (allow-none): return location for the Y coordinate of @device, or %NULL.
* @mask: (out) (allow-none): return location for the modifier mask, or %NULL.
*
* Obtains the current device position and modifier state.
* The position is given in coordinates relative to the upper left
* corner of @window.
*
* Use cdk_window_get_device_position_double() if you need subpixel precision.
*
* Returns: (nullable) (transfer none): The window underneath @device
* (as with cdk_device_get_window_at_position()), or %NULL if the
* window is not known to CDK.
*
* Since: 3.0
**/
5076CdkWindow *
5077cdk_window_get_device_position (CdkWindow       *window,
                              CdkDevice       *device,
                              gint            *x,
                              gint            *y,
                              CdkModifierType *mask)
5082{
gdouble tmp_x, tmp_y;

window = cdk_window_get_device_position_double (window, device,
                                                &tmp_x, &tmp_y, mask);
if (x)
  *x = round (tmp_x);
if (y)
  *y = round (tmp_y);

return window;
5093}

5095/**
* cdk_window_at_pointer:
* @win_x: (out) (allow-none): return location for origin of the window under the pointer
* @win_y: (out) (allow-none): return location for origin of the window under the pointer
*
* Obtains the window underneath the mouse pointer, returning the
* location of that window in @win_x, @win_y. Returns %NULL if the
* window under the mouse pointer is not known to CDK (if the window
* belongs to another application and a #CdkWindow hasn’t been created
* for it with cdk_window_foreign_new())
*
* NOTE: For multihead-aware widgets or applications use
* cdk_display_get_window_at_pointer() instead.
*
* Returns: (transfer none): window under the mouse pointer
**/
5111CdkWindow*
5112cdk_window_at_pointer (gint *win_x,
       gint *win_y)
5114{
return cdk_display_get_window_at_pointer (cdk_display_get_default (), win_x, win_y);
5116}

5118/**
* cdk_get_default_root_window:
*
* Obtains the root window (parent all other windows are inside)
* for the default display and screen.
*
* Returns: (transfer none): the default root window
**/
5126CdkWindow *
5127cdk_get_default_root_window (void)
5128{
return cdk_screen_get_root_window (cdk_screen_get_default ());
5130}

5132static void
5133get_all_native_children (CdkWindow *window,
	 GList **native)
5135{
CdkWindow *child;
GList *l;

for (l = window->children; l != NULL((void*)0); l = l->next)
  {
    child = l->data;

    if (cdk_window_has_impl (child))
*native = g_list_prepend (*native, child);
    else
get_all_native_children (child, native);
  }
5148}


5151static gboolean
5152cdk_window_raise_internal (CdkWindow *window)
5153{
CdkWindow *parent = window->parent;
CdkWindow *above;
GList *native_children;
GList *l, listhead;
CdkWindowImplClass *impl_class;
gboolean did_raise = FALSE(0);

if (parent && parent->children->data != window)
  {
    parent->children = g_list_remove_link (parent->children, &window->children_list_node);
    parent->children = g_list_concat (&window->children_list_node, parent->children);
    did_raise = TRUE(!(0));
  }

impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));
/* Just do native raise for toplevels */
if (cdk_window_is_toplevel (window) ||
    /* The restack_under codepath should work correctly even if the parent
is native, but it relies on the order of ->children to be correct,
and some apps like SWT reorder the x windows without cdks knowledge,
so we use raise directly in order to make these behave as before
when using native windows */
    (cdk_window_has_impl (window) && cdk_window_has_impl (parent)))
  {
    impl_class->raise (window);
  }
else if (cdk_window_has_impl (window))
  {
    above = find_native_sibling_above (parent, window);
    if (above)
{
 listhead.data = window;
 listhead.next = NULL((void*)0);
 listhead.prev = NULL((void*)0);
 impl_class->restack_under ((CdkWindow *)above,
		     &listhead);
}
    else
impl_class->raise (window);
  }
else
  {
    native_children = NULL((void*)0);
    get_all_native_children (window, &native_children);
    if (native_children != NULL((void*)0))
{
 above = find_native_sibling_above (parent, window);

 if (above)
   impl_class->restack_under (above, native_children);
 else
   {
     /* Right order, since native_children is bottom-topmost first */
     for (l = native_children; l != NULL((void*)0); l = l->next)
impl_class->raise (l->data);
   }

 g_list_free (native_children);
}
  }

return did_raise;
5216}

5218/* Returns TRUE If the native window was mapped or unmapped */
5219static gboolean
5220set_viewable (CdkWindow *w,
     gboolean val)
5222{
CdkWindow *child;
CdkWindowImplClass *impl_class;
GList *l;

if (w->viewable == val)
  return FALSE(0);

w->viewable = val;

if (val)
  recompute_visible_regions (w, FALSE(0));

for (l = w->children; l != NULL((void*)0); l = l->next)
  {
    child = l->data;

    if (CDK_WINDOW_IS_MAPPED (child)(((child)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0) &&
 child->window_type != CDK_WINDOW_FOREIGN)
set_viewable (child, val);
  }

if (cdk_window_has_impl (w)  &&
    w->window_type != CDK_WINDOW_FOREIGN &&
    !cdk_window_is_toplevel (w))
  {
    /* For most native windows we show/hide them not when they are
     * mapped/unmapped, because that may not produce the correct results.
     * For instance, if a native window have a non-native parent which is
     * hidden, but its native parent is viewable then showing the window
     * would make it viewable to X but its not viewable wrt the non-native
     * hierarchy. In order to handle this we track the cdk side viewability
     * and only map really viewable windows.
     *
     * There are two exceptions though:
     *
     * For foreign windows we don't want ever change the mapped state
     * except when explicitly done via cdk_window_show/hide, as this may
     * cause problems for client owning the foreign window when its window
     * is suddenly mapped or unmapped.
     *
     * For toplevel windows embedded in a foreign window (e.g. a plug)
     * we sometimes synthesize a map of a window, but the native
     * window is really shown by the embedder, so we don't want to
     * do the show ourselves. We can't really tell this case from the normal
     * toplevel show as such toplevels are seen by cdk as parents of the
     * root window, so we make an exception for all toplevels.
     */

    impl_class = CDK_WINDOW_IMPL_GET_CLASS (w->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((w->impl)))->
g_class))));
    if (val)
impl_class->show ((CdkWindow *)w, FALSE(0));
    else
impl_class->hide ((CdkWindow *)w);

    return TRUE(!(0));
  }

return FALSE(0);
5281}

5283/* Returns TRUE If the native window was mapped or unmapped */
5284gboolean
5285_cdk_window_update_viewable (CdkWindow *window)
5286{
gboolean viewable;

if (window->window_type == CDK_WINDOW_FOREIGN ||
    window->window_type == CDK_WINDOW_ROOT)
  viewable = TRUE(!(0));
else if (cdk_window_is_toplevel (window) ||
  window->parent->viewable)
  viewable = CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0);
else
  viewable = FALSE(0);

return set_viewable (window, viewable);
5299}

5301static void
5302cdk_window_show_internal (CdkWindow *window, gboolean raise)
5303{
CdkWindowImplClass *impl_class;
gboolean was_mapped, was_viewable;
gboolean did_show, did_raise = FALSE(0);

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (window->destroyed)
  return;

was_mapped = CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0);
was_viewable = window->viewable;

if (raise)
  {
    /* Keep children in (reverse) stacking order */
    did_raise = cdk_window_raise_internal (window);
  }

if (cdk_window_has_impl (window))
  {
    if (!was_mapped)
cdk_synthesize_window_state (window,
		     CDK_WINDOW_STATE_WITHDRAWN,
		     CDK_WINDOW_STATE_FOCUSED);
  }
else
  {
    window->state = 0;
  }

did_show = _cdk_window_update_viewable (window);

/* If it was already viewable the backend show op won't be called, call it
   again to ensure things happen right if the mapped tracking was not right
   for e.g. a foreign window.
   Dunno if this is strictly needed but its what happened pre-csw.
   Also show if not done by cdk_window_update_viewable. */
if (cdk_window_has_impl (window) && (was_viewable || !did_show))
  {
    impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));
    impl_class->show (window, !did_show ? was_mapped : TRUE(!(0)));
  }

if (!was_mapped && !cdk_window_has_impl (window))
  {
    if (window->event_mask & CDK_STRUCTURE_MASK)
_cdk_make_event (window, CDK_MAP, NULL((void*)0), FALSE(0));

    if (window->parent && window->parent->event_mask & CDK_SUBSTRUCTURE_MASK)
_cdk_make_event (window, CDK_MAP, NULL((void*)0), FALSE(0));
  }

if (!was_mapped || did_raise)
  {
    recompute_visible_regions (window, FALSE(0));

    /* If any decendants became visible we need to send visibility notify */
    cdk_window_update_visibility_recursively (window, NULL((void*)0));

    if (cdk_window_is_viewable (window))
{
 _cdk_synthesize_crossing_events_for_geometry_change (window);
 cdk_window_invalidate_rect_full (window, NULL((void*)0), TRUE(!(0)));
}
  }
5369}

5371/**
* cdk_window_show_unraised:
* @window: a #CdkWindow
*
* Shows a #CdkWindow onscreen, but does not modify its stacking
* order. In contrast, cdk_window_show() will raise the window
* to the top of the window stack.
*
* On the X11 platform, in Xlib terms, this function calls
* XMapWindow() (it also updates some internal CDK state, which means
* that you can’t really use XMapWindow() directly on a CDK window).
*/
5383void
5384cdk_window_show_unraised (CdkWindow *window)
5385{
cdk_window_show_internal (window, FALSE(0));
5387}

5389/**
* cdk_window_raise:
* @window: a #CdkWindow
*
* Raises @window to the top of the Z-order (stacking order), so that
* other windows with the same parent window appear below @window.
* This is true whether or not the windows are visible.
*
* If @window is a toplevel, the window manager may choose to deny the
* request to move the window in the Z-order, cdk_window_raise() only
* requests the restack, does not guarantee it.
*/
5401void
5402cdk_window_raise (CdkWindow *window)
5403{
gboolean did_raise;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (window->destroyed)
  return;

/* Keep children in (reverse) stacking order */
did_raise = cdk_window_raise_internal (window);

if (did_raise &&
    !cdk_window_is_toplevel (window) &&
    cdk_window_is_viewable (window) &&
    !window->input_only)
  cdk_window_invalidate_region_full (window, window->clip_region, TRUE(!(0)));
5419}

5421static void
5422cdk_window_lower_internal (CdkWindow *window)
5423{
CdkWindow *parent = window->parent;
CdkWindowImplClass *impl_class;
CdkWindow *above;
GList *native_children;
GList *l, listhead;

if (parent)
  {
    parent->children = g_list_remove_link (parent->children, &window->children_list_node);
    parent->children = g_list_concat (parent->children, &window->children_list_node);
  }

impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));
/* Just do native lower for toplevels */
if (cdk_window_is_toplevel (window) ||
    /* The restack_under codepath should work correctly even if the parent
is native, but it relies on the order of ->children to be correct,
and some apps like SWT reorder the x windows without cdks knowledge,
so we use lower directly in order to make these behave as before
when using native windows */
    (cdk_window_has_impl (window) && cdk_window_has_impl (parent)))
  {
    impl_class->lower (window);
  }
else if (cdk_window_has_impl (window))
  {
    above = find_native_sibling_above (parent, window);
    if (above)
{
 listhead.data = window;
 listhead.next = NULL((void*)0);
 listhead.prev = NULL((void*)0);
 impl_class->restack_under ((CdkWindow *)above, &listhead);
}
    else
impl_class->raise (window);
  }
else
  {
    native_children = NULL((void*)0);
    get_all_native_children (window, &native_children);
    if (native_children != NULL((void*)0))
{
 above = find_native_sibling_above (parent, window);

 if (above)
   impl_class->restack_under ((CdkWindow *)above,
		       native_children);
 else
   {
     /* Right order, since native_children is bottom-topmost first */
     for (l = native_children; l != NULL((void*)0); l = l->next)
impl_class->raise (l->data);
   }

 g_list_free (native_children);
}

  }
5483}

5485static void
5486cdk_window_invalidate_in_parent (CdkWindow *private)
5487{
CdkRectangle r, child;

if (cdk_window_is_toplevel (private))
  return;

/* get the visible rectangle of the parent */
r.x = r.y = 0;
r.width = private->parent->width;
r.height = private->parent->height;

child.x = private->x;
child.y = private->y;
child.width = private->width;
child.height = private->height;
cdk_rectangle_intersect (&r, &child, &r);

cdk_window_invalidate_rect_full (private->parent, &r, TRUE(!(0)));
5505}


5508/**
* cdk_window_lower:
* @window: a #CdkWindow
*
* Lowers @window to the bottom of the Z-order (stacking order), so that
* other windows with the same parent window appear above @window.
* This is true whether or not the other windows are visible.
*
* If @window is a toplevel, the window manager may choose to deny the
* request to move the window in the Z-order, cdk_window_lower() only
* requests the restack, does not guarantee it.
*
* Note that cdk_window_show() raises the window again, so don’t call this
* function before cdk_window_show(). (Try cdk_window_show_unraised().)
*/
5523void
5524cdk_window_lower (CdkWindow *window)
5525{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (window->destroyed)
  return;

/* Keep children in (reverse) stacking order */
cdk_window_lower_internal (window);

_cdk_synthesize_crossing_events_for_geometry_change (window);
cdk_window_invalidate_in_parent (window);
5536}

5538/**
* cdk_window_restack:
* @window: a #CdkWindow
* @sibling: (allow-none): a #CdkWindow that is a sibling of @window, or %NULL
* @above: a boolean
*
* Changes the position of  @window in the Z-order (stacking order), so that
* it is above @sibling (if @above is %TRUE) or below @sibling (if @above is
* %FALSE).
*
* If @sibling is %NULL, then this either raises (if @above is %TRUE) or
* lowers the window.
*
* If @window is a toplevel, the window manager may choose to deny the
* request to move the window in the Z-order, cdk_window_restack() only
* requests the restack, does not guarantee it.
*
* Since: 2.18
*/
5557void
5558cdk_window_restack (CdkWindow     *window,
    CdkWindow     *sibling,
    gboolean       above)
5561{
CdkWindowImplClass *impl_class;
CdkWindow *parent;
CdkWindow *above_native;
GList *sibling_link;
GList *native_children;
GList *l, listhead;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);
g_return_if_fail (sibling == NULL || CDK_IS_WINDOW (sibling))do { if ((sibling == ((void*)0) || (((__extension__ ({ GTypeInstance
 *__inst = (GTypeInstance*) ((sibling)); GType __t = ((cdk_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; })))))) { } else { g_return_if_fail_warning ("Cdk", ((const
 char*) (__func__)), "sibling == NULL || CDK_IS_WINDOW (sibling)"
); return; } } while (0);

if (window->destroyed)
  return;

if (sibling == NULL((void*)0))
  {
    if (above)
cdk_window_raise (window);
    else
cdk_window_lower (window);
    return;
  }

if (cdk_window_is_toplevel (window))
  {
    g_return_if_fail (cdk_window_is_toplevel (sibling))do { if ((cdk_window_is_toplevel (sibling))) { } else { g_return_if_fail_warning
 ("Cdk", ((const char*) (__func__)), "cdk_window_is_toplevel (sibling)"
); return; } } while (0);
    impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));
    impl_class->restack_toplevel (window, sibling, above);
    return;
  }

parent = window->parent;
if (parent)
  {
    sibling_link = g_list_find (parent->children, sibling);
    g_return_if_fail (sibling_link != NULL)do { if ((sibling_link != ((void*)0))) { } else { g_return_if_fail_warning
 ("Cdk", ((const char*) (__func__)), "sibling_link != NULL");
 return; } } while (0);
    if (sibling_link == NULL((void*)0))
return;

    parent->children = g_list_remove_link (parent->children, &window->children_list_node);
    if (above)
parent->children = list_insert_link_before (parent->children,
                                                  sibling_link,
                                                  &window->children_list_node);
    else
parent->children = list_insert_link_before (parent->children,
                                                  sibling_link->next,
                                                  &window->children_list_node);

    impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));
    if (cdk_window_has_impl (window))
{
 above_native = find_native_sibling_above (parent, window);
 if (above_native)
   {
     listhead.data = window;
     listhead.next = NULL((void*)0);
     listhead.prev = NULL((void*)0);
     impl_class->restack_under (above_native, &listhead);
   }
 else
   impl_class->raise (window);
}
    else
{
 native_children = NULL((void*)0);
 get_all_native_children (window, &native_children);
 if (native_children != NULL((void*)0))
   {
     above_native = find_native_sibling_above (parent, window);
     if (above_native)
impl_class->restack_under (above_native,
			   native_children);
     else
{
  /* Right order, since native_children is bottom-topmost first */
  for (l = native_children; l != NULL((void*)0); l = l->next)
    impl_class->raise (l->data);
}

     g_list_free (native_children);
   }
}
  }

_cdk_synthesize_crossing_events_for_geometry_change (window);
cdk_window_invalidate_in_parent (window);
5648}


5651/**
* cdk_window_show:
* @window: a #CdkWindow
*
* Like cdk_window_show_unraised(), but also raises the window to the
* top of the window stack (moves the window to the front of the
* Z-order).
*
* This function maps a window so it’s visible onscreen. Its opposite
* is cdk_window_hide().
*
* When implementing a #CtkWidget, you should call this function on the widget's
* #CdkWindow as part of the “map” method.
*/
5665void
5666cdk_window_show (CdkWindow *window)
5667{
cdk_window_show_internal (window, TRUE(!(0)));
5669}

5671/**
* cdk_window_hide:
* @window: a #CdkWindow
*
* For toplevel windows, withdraws them, so they will no longer be
* known to the window manager; for all windows, unmaps them, so
* they won’t be displayed. Normally done automatically as
* part of ctk_widget_hide().
*/
5680void
5681cdk_window_hide (CdkWindow *window)
5682{
CdkWindowImplClass *impl_class;
gboolean was_mapped, did_hide;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (window->destroyed)
  return;

was_mapped = CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0);

if (cdk_window_has_impl (window))
  {

    if (CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
cdk_synthesize_window_state (window,
		     0,
		     CDK_WINDOW_STATE_WITHDRAWN);
  }
else if (was_mapped)
  {
    CdkDisplay *display;
    CdkDeviceManager *device_manager;
    GList *devices, *d;

    G_GNUC_BEGIN_IGNORE_DEPRECATIONSclang diagnostic push
 clang diagnostic ignored "-Wdeprecated-declarations"

;

    /* May need to break grabs on children */
    display = cdk_window_get_display (window);
    device_manager = cdk_display_get_device_manager (display);

    /* Get all devices */
    devices = cdk_device_manager_list_devices (device_manager, CDK_DEVICE_TYPE_MASTER);
    devices = g_list_concat (devices, cdk_device_manager_list_devices (device_manager, CDK_DEVICE_TYPE_SLAVE));
    devices = g_list_concat (devices, cdk_device_manager_list_devices (device_manager, CDK_DEVICE_TYPE_FLOATING));

    for (d = devices; d; d = d->next)
      {
        CdkDevice *device = d->data;

        if (_cdk_display_end_device_grab (display,
                                          device,
                                          _cdk_display_get_next_serial (display),
                                          window,
                                          TRUE(!(0))))
          cdk_device_ungrab (device, CDK_CURRENT_TIME0L);
      }

    window->state = CDK_WINDOW_STATE_WITHDRAWN;
    g_list_free (devices);
    G_GNUC_END_IGNORE_DEPRECATIONSclang diagnostic pop
;
  }

did_hide = _cdk_window_update_viewable (window);

/* Hide foreign window as those are not handled by update_viewable. */
if (cdk_window_has_impl (window) && (!did_hide))
  {
    impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));
    impl_class->hide (window);
  }

cdk_window_clear_old_updated_area (window);
recompute_visible_regions (window, FALSE(0));

/* all decendants became non-visible, we need to send visibility notify */
cdk_window_update_visibility_recursively (window, NULL((void*)0));

if (was_mapped && !cdk_window_has_impl (window))
  {
    if (window->event_mask & CDK_STRUCTURE_MASK)
_cdk_make_event (window, CDK_UNMAP, NULL((void*)0), FALSE(0));

    if (window->parent && window->parent->event_mask & CDK_SUBSTRUCTURE_MASK)
_cdk_make_event (window, CDK_UNMAP, NULL((void*)0), FALSE(0));

    _cdk_synthesize_crossing_events_for_geometry_change (window->parent);
  }

/* Invalidate the rect */
if (was_mapped)
  cdk_window_invalidate_in_parent (window);
5764}

5766/**
* cdk_window_withdraw:
* @window: a toplevel #CdkWindow
*
* Withdraws a window (unmaps it and asks the window manager to forget about it).
* This function is not really useful as cdk_window_hide() automatically
* withdraws toplevel windows before hiding them.
**/
5774void
5775cdk_window_withdraw (CdkWindow *window)
5776{
CdkWindowImplClass *impl_class;
gboolean was_mapped;
CdkGLContext *current_context;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (window->destroyed)
  return;

was_mapped = CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0);

if (cdk_window_has_impl (window))
  {
    impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));
    impl_class->withdraw (window);

    if (was_mapped)
{
 if (window->event_mask & CDK_STRUCTURE_MASK)
   _cdk_make_event (window, CDK_UNMAP, NULL((void*)0), FALSE(0));

 if (window->parent && window->parent->event_mask & CDK_SUBSTRUCTURE_MASK)
   _cdk_make_event (window, CDK_UNMAP, NULL((void*)0), FALSE(0));

 _cdk_synthesize_crossing_events_for_geometry_change (window->parent);
}

    current_context = cdk_gl_context_get_current ();
    if (current_context != NULL((void*)0) && cdk_gl_context_get_window (current_context) == window)
      cdk_gl_context_clear_current ();

    recompute_visible_regions (window, FALSE(0));
    cdk_window_clear_old_updated_area (window);
  }
5811}

5813/**
* cdk_window_set_events:
* @window: a #CdkWindow
* @event_mask: event mask for @window
*
* The event mask for a window determines which events will be reported
* for that window from all master input devices. For example, an event mask
* including #CDK_BUTTON_PRESS_MASK means the window should report button
* press events. The event mask is the bitwise OR of values from the
* #CdkEventMask enumeration.
*
* See the [input handling overview][event-masks] for details.
**/
5826void
5827cdk_window_set_events (CdkWindow       *window,
       CdkEventMask     event_mask)
5829{
CdkWindowImplClass *impl_class;
CdkDisplay *display;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (window->destroyed)
  return;

/* If motion hint is disabled, enable motion events again */
display = cdk_window_get_display (window);
if ((window->event_mask & CDK_POINTER_MOTION_HINT_MASK) &&
    !(event_mask & CDK_POINTER_MOTION_HINT_MASK))
  {
    GList *devices = window->devices_inside;

    while (devices)
      {
        _cdk_display_enable_motion_hints (display, (CdkDevice *) devices->data);
        devices = devices->next;
      }
  }

window->event_mask = event_mask;

if (cdk_window_has_impl (window))
  {
    impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));
    impl_class->set_events (window,
	      get_native_event_mask (window));
  }

5861}

5863/**
* cdk_window_get_events:
* @window: a #CdkWindow
*
* Gets the event mask for @window for all master input devices. See
* cdk_window_set_events().
*
* Returns: event mask for @window
**/
5872CdkEventMask
5873cdk_window_get_events (CdkWindow *window)
5874{
g_return_val_if_fail (CDK_IS_WINDOW (window), 0)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (0); } } while (0);

if (window->destroyed)
  return 0;

return window->event_mask;
5881}

5883/**
* cdk_window_set_device_events:
* @window: a #CdkWindow
* @device: #CdkDevice to enable events for.
* @event_mask: event mask for @window
*
* Sets the event mask for a given device (Normally a floating device, not
* attached to any visible pointer) to @window. For example, an event mask
* including #CDK_BUTTON_PRESS_MASK means the window should report button
* press events. The event mask is the bitwise OR of values from the
* #CdkEventMask enumeration.
*
* See the [input handling overview][event-masks] for details.
*
* Since: 3.0
**/
5899void
5900cdk_window_set_device_events (CdkWindow    *window,
                            CdkDevice    *device,
                            CdkEventMask  event_mask)
5903{
CdkEventMask device_mask;
CdkDisplay *display;
CdkWindow *native;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);
g_return_if_fail (CDK_IS_DEVICE (device))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((device)); GType __t = ((cdk_device_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_DEVICE (device)"); return; } } while (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return;

/* If motion hint is disabled, enable motion events again */
display = cdk_window_get_display (window);
if ((window->event_mask & CDK_POINTER_MOTION_HINT_MASK) &&
    !(event_mask & CDK_POINTER_MOTION_HINT_MASK))
  _cdk_display_enable_motion_hints (display, device);

if (G_UNLIKELY (!window->device_events)(!window->device_events))
  window->device_events = g_hash_table_new (NULL((void*)0), NULL((void*)0));

if (event_mask == 0)
  {
    /* FIXME: unsetting events on a master device
     * would restore window->event_mask
     */
    g_hash_table_remove (window->device_events, device);
  }
else
  g_hash_table_insert (window->device_events, device,
                       GINT_TO_POINTER (event_mask)((gpointer) (glong) (event_mask)));

native = cdk_window_get_toplevel (window);

while (cdk_window_is_offscreen (native))
  {
    native = cdk_offscreen_window_get_embedder (native);

    if (native == NULL((void*)0) ||
 (!_cdk_window_has_impl (native) &&
  !cdk_window_is_viewable (native)))
return;

    native = cdk_window_get_toplevel (native);
  }

device_mask = get_native_device_event_mask (window, device);
CDK_DEVICE_GET_CLASS (device)((((CdkDeviceClass*) (((GTypeInstance*) ((device)))->g_class
))))->select_window_events (device, native, device_mask);
5950}

5952/**
* cdk_window_get_device_events:
* @window: a #CdkWindow.
* @device: a #CdkDevice.
*
* Returns the event mask for @window corresponding to an specific device.
*
* Returns: device event mask for @window
*
* Since: 3.0
**/
5963CdkEventMask
5964cdk_window_get_device_events (CdkWindow *window,
                            CdkDevice *device)
5966{
CdkEventMask mask;

g_return_val_if_fail (CDK_IS_WINDOW (window), 0)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (0); } } while (0);
g_return_val_if_fail (CDK_IS_DEVICE (device), 0)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((device)); GType __t = ((cdk_device_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_DEVICE (device)"); return (0); } } while (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return 0;

if (!window->device_events)
  return 0;

mask = GPOINTER_TO_INT (g_hash_table_lookup (window->device_events, device))((gint) (glong) (g_hash_table_lookup (window->device_events
, device)));

/* FIXME: device could be controlled by window->event_mask */

return mask;
5983}

5985static void
5986cdk_window_move_resize_toplevel (CdkWindow *window,
                               gboolean   with_move,
                               gint       x,
                               gint       y,
                               gint       width,
                               gint       height)
5992{
cairo_region_t *old_region, *new_region;
CdkWindowImplClass *impl_class;
gboolean expose;
gboolean is_resize;

expose = FALSE(0);
old_region = NULL((void*)0);

is_resize = (width != -1) || (height != -1);

if (cdk_window_is_viewable (window) &&
    !window->input_only)
  {
    expose = TRUE(!(0));
    old_region = cairo_region_copy (window->clip_region);
  }

impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));
impl_class->move_resize (window, with_move, x, y, width, height);

/* Avoid recomputing for pure toplevel moves, for performance reasons */
if (is_resize)
  recompute_visible_regions (window, FALSE(0));

if (expose)
  {
    new_region = cairo_region_copy (window->clip_region);

    /* This is the newly exposed area (due to any resize),
     * X will expose it, but lets do that without the roundtrip
     */
    cairo_region_subtract (new_region, old_region);
    cdk_window_invalidate_region_full (window, new_region, TRUE(!(0)));

    cairo_region_destroy (old_region);
    cairo_region_destroy (new_region);
  }

_cdk_synthesize_crossing_events_for_geometry_change (window);
6032}


6035static void
6036move_native_children (CdkWindow *private)
6037{
GList *l;
CdkWindow *child;
CdkWindowImplClass *impl_class;

for (l = private->children; l; l = l->next)
  {
    child = l->data;

    if (child->impl != private->impl)
{
 impl_class = CDK_WINDOW_IMPL_GET_CLASS (child->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((child->impl)
))->g_class))));
 impl_class->move_resize (child, TRUE(!(0)),
		   child->x, child->y,
		   child->width, child->height);
}
    else
move_native_children  (child);
  }
6056}

6058static void
6059cdk_window_move_resize_internal (CdkWindow *window,
		 gboolean   with_move,
		 gint       x,
		 gint       y,
		 gint       width,
		 gint       height)
6065{
cairo_region_t *old_region, *new_region;
CdkWindowImplClass *impl_class;
gboolean expose;
int old_abs_x, old_abs_y;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (window->destroyed)
  return;

if (cdk_window_is_toplevel (window))
  {
    cdk_window_move_resize_toplevel (window, with_move, x, y, width, height);
    return;
  }

if (width == 0)
  width = 1;
if (height == 0)
  height = 1;

/* Bail early if no change */
if (window->width == width &&
    window->height == height &&
    (!with_move ||
     (window->x == x &&
window->y == y)))
  return;

/* Handle child windows */

expose = FALSE(0);
old_region = NULL((void*)0);

if (cdk_window_is_viewable (window) &&
    !window->input_only)
  {
    CdkRectangle r;

    expose = TRUE(!(0));

    r.x = window->x;
    r.y = window->y;
    r.width = window->width;
    r.height = window->height;

    old_region = cairo_region_create_rectangle (&r);
  }

/* Set the new position and size */
if (with_move)
  {
    window->x = x;
    window->y = y;
  }
if (!(width < 0 && height < 0))
  {
    window->width = width;
    window->height = height;
  }

old_abs_x = window->abs_x;
old_abs_y = window->abs_y;

recompute_visible_regions (window, FALSE(0));

if (cdk_window_has_impl (window))
  {
    impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));

    /* Do the actual move after recomputing things, as this will have set the shape to
the now correct one, thus avoiding copying regions that should not be copied. */
    impl_class->move_resize (window, TRUE(!(0)),
	       window->x, window->y,
	       window->width, window->height);
  }
else if (old_abs_x != window->abs_x ||
  old_abs_y != window->abs_y)
  move_native_children (window);

if (expose)
  {
    CdkRectangle r;

    r.x = window->x;
    r.y = window->y;
    r.width = window->width;
    r.height = window->height;

    new_region = cairo_region_create_rectangle (&r);

    cairo_region_union (new_region, old_region);

    cdk_window_invalidate_region_full (window->parent, new_region, TRUE(!(0)));

    cairo_region_destroy (old_region);
    cairo_region_destroy (new_region);
  }

_cdk_synthesize_crossing_events_for_geometry_change (window);
6166}



6170/**
* cdk_window_move:
* @window: a #CdkWindow
* @x: X coordinate relative to window’s parent
* @y: Y coordinate relative to window’s parent
*
* Repositions a window relative to its parent window.
* For toplevel windows, window managers may ignore or modify the move;
* you should probably use ctk_window_move() on a #CtkWindow widget
* anyway, instead of using CDK functions. For child windows,
* the move will reliably succeed.
*
* If you’re also planning to resize the window, use cdk_window_move_resize()
* to both move and resize simultaneously, for a nicer visual effect.
**/
6185void
6186cdk_window_move (CdkWindow *window,
 gint       x,
 gint       y)
6189{
cdk_window_move_resize_internal (window, TRUE(!(0)), x, y, -1, -1);
6191}

6193/**
* cdk_window_resize:
* @window: a #CdkWindow
* @width: new width of the window
* @height: new height of the window
*
* Resizes @window; for toplevel windows, asks the window manager to resize
* the window. The window manager may not allow the resize. When using CTK+,
* use ctk_window_resize() instead of this low-level CDK function.
*
* Windows may not be resized below 1x1.
*
* If you’re also planning to move the window, use cdk_window_move_resize()
* to both move and resize simultaneously, for a nicer visual effect.
**/
6208void
6209cdk_window_resize (CdkWindow *window,
   gint       width,
   gint       height)
6212{
cdk_window_move_resize_internal (window, FALSE(0), 0, 0, width, height);
6214}


6217/**
* cdk_window_move_resize:
* @window: a #CdkWindow
* @x: new X position relative to window’s parent
* @y: new Y position relative to window’s parent
* @width: new width
* @height: new height
*
* Equivalent to calling cdk_window_move() and cdk_window_resize(),
* except that both operations are performed at once, avoiding strange
* visual effects. (i.e. the user may be able to see the window first
* move, then resize, if you don’t use cdk_window_move_resize().)
**/
6230void
6231cdk_window_move_resize (CdkWindow *window,
	gint       x,
	gint       y,
	gint       width,
	gint       height)
6236{
cdk_window_move_resize_internal (window, TRUE(!(0)), x, y, width, height);
6238}

6240/**
* cdk_window_move_to_rect:
* @window: the #CdkWindow to move
* @rect: (not nullable): the destination #CdkRectangle to align @window with
* @rect_anchor: the point on @rect to align with @window's anchor point
* @window_anchor: the point on @window to align with @rect's anchor point
* @anchor_hints: positioning hints to use when limited on space
* @rect_anchor_dx: horizontal offset to shift @window, i.e. @rect's anchor
*                  point
* @rect_anchor_dy: vertical offset to shift @window, i.e. @rect's anchor point
*
* Moves @window to @rect, aligning their anchor points.
*
* @rect is relative to the top-left corner of the window that @window is
* transient for. @rect_anchor and @window_anchor determine anchor points on
* @rect and @window to pin together. @rect's anchor point can optionally be
* offset by @rect_anchor_dx and @rect_anchor_dy, which is equivalent to
* offsetting the position of @window.
*
* @anchor_hints determines how @window will be moved if the anchor points cause
* it to move off-screen. For example, %CDK_ANCHOR_FLIP_X will replace
* %CDK_GRAVITY_NORTH_WEST with %CDK_GRAVITY_NORTH_EAST and vice versa if
* @window extends beyond the left or right edges of the monitor.
*
* Connect to the #CdkWindow::moved-to-rect signal to find out how it was
* actually positioned.
*
* Since: 3.24
*/
6269void
6270cdk_window_move_to_rect (CdkWindow          *window,
                       const CdkRectangle *rect,
                       CdkGravity          rect_anchor,
                       CdkGravity          window_anchor,
                       CdkAnchorHints      anchor_hints,
                       gint                rect_anchor_dx,
                       gint                rect_anchor_dy)
6277{
CdkWindowImplClass *impl_class;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);
g_return_if_fail (window->transient_for)do { if ((window->transient_for)) { } else { g_return_if_fail_warning
 ("Cdk", ((const char*) (__func__)), "window->transient_for"
); return; } } while (0);
g_return_if_fail (rect)do { if ((rect)) { } else { g_return_if_fail_warning ("Cdk", (
(const char*) (__func__)), "rect"); return; } } while (0);

impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));
impl_class->move_to_rect (window,
                          rect,
                          rect_anchor,
                          window_anchor,
                          anchor_hints,
                          rect_anchor_dx,
                          rect_anchor_dy);
6292}

6294/**
* cdk_window_scroll:
* @window: a #CdkWindow
* @dx: Amount to scroll in the X direction
* @dy: Amount to scroll in the Y direction
*
* Scroll the contents of @window, both pixels and children, by the
* given amount. @window itself does not move. Portions of the window
* that the scroll operation brings in from offscreen areas are
* invalidated. The invalidated region may be bigger than what would
* strictly be necessary.
*
* For X11, a minimum area will be invalidated if the window has no
* subwindows, or if the edges of the window’s parent do not extend
* beyond the edges of the window. In other cases, a multi-step process
* is used to scroll the window which may produce temporary visual
* artifacts and unnecessary invalidations.
**/
6312void
6313cdk_window_scroll (CdkWindow *window,
   gint       dx,
   gint       dy)
6316{
GList *tmp_list;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (dx == 0 && dy == 0)
  return;

if (window->destroyed)
  return;

/* First move all child windows, without causing invalidation */

tmp_list = window->children;
while (tmp_list)
  {
    CdkWindow *child = CDK_WINDOW (tmp_list->data)((((CdkWindow*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((tmp_list->data)), ((cdk_window_get_type ()))))));

    /* Just update the positions, the bits will move with the copy */
    child->x += dx;
    child->y += dy;

    tmp_list = tmp_list->next;
  }

recompute_visible_regions (window, TRUE(!(0)));

move_native_children (window);

cdk_window_invalidate_rect_full (window, NULL((void*)0), TRUE(!(0)));

_cdk_synthesize_crossing_events_for_geometry_change (window);
6348}

6350/**
* cdk_window_move_region:
* @window: a #CdkWindow
* @region: The #cairo_region_t to move
* @dx: Amount to move in the X direction
* @dy: Amount to move in the Y direction
*
* Move the part of @window indicated by @region by @dy pixels in the Y
* direction and @dx pixels in the X direction. The portions of @region
* that not covered by the new position of @region are invalidated.
*
* Child windows are not moved.
*
* Since: 2.8
*/
6365void
6366cdk_window_move_region (CdkWindow            *window,
                      const cairo_region_t *region,
                      gint                  dx,
                      gint                  dy)
6370{
cairo_region_t *expose_area;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);
g_return_if_fail (region != NULL)do { if ((region != ((void*)0))) { } else { g_return_if_fail_warning
 ("Cdk", ((const char*) (__func__)), "region != NULL"); return
; } } while (0);

if (dx == 0 && dy == 0)
  return;

if (window->destroyed)
  return;

expose_area = cairo_region_copy (region);
cairo_region_translate (expose_area, dx, dy);
cairo_region_union (expose_area, region);

cdk_window_invalidate_region_full (window, expose_area, FALSE(0));
cairo_region_destroy (expose_area);
6388}

6390/**
* cdk_window_set_background:
* @window: a #CdkWindow
* @color: a #CdkColor
*
* Sets the background color of @window.
*
* However, when using CTK+, influence the background of a widget
* using a style class or CSS — if you’re an application — or with
* ctk_style_context_set_background() — if you're implementing a
* custom widget.
*/
6402void
6403cdk_window_set_background (CdkWindow      *window,
	   const CdkColor *color)
6405{
cairo_pattern_t *pattern;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

pattern = cairo_pattern_create_rgb (color->red   / 65535.,
                                    color->green / 65535.,
                                    color->blue  / 65535.);

cdk_window_set_background_pattern (window, pattern);

cairo_pattern_destroy (pattern);
6417}

6419/**
* cdk_window_set_background_rgba:
* @window: a #CdkWindow
* @rgba: a #CdkRGBA color
*
* Sets the background color of @window.
*
* See also cdk_window_set_background_pattern().
**/
6428void
6429cdk_window_set_background_rgba (CdkWindow     *window,
                              const CdkRGBA *rgba)
6431{
cairo_pattern_t *pattern;
CdkRGBA prev_rgba;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);
g_return_if_fail (rgba != NULL)do { if ((rgba != ((void*)0))) { } else { g_return_if_fail_warning
 ("Cdk", ((const char*) (__func__)), "rgba != NULL"); return;
 } } while (0);

/*
 * If the new RGBA matches the previous pattern, ignore the change so that
 * we do not invalidate the window contents.
 */
if ((window->background != NULL((void*)0)) &&
    (cairo_pattern_get_type (window->background) == CAIRO_PATTERN_TYPE_SOLID) &&
    (cairo_pattern_get_rgba (window->background,
                             &prev_rgba.red,
                             &prev_rgba.green,
                             &prev_rgba.blue,
                             &prev_rgba.alpha) == CAIRO_STATUS_SUCCESS) &&
    cdk_rgba_equal (&prev_rgba, rgba))
  return;

pattern = cairo_pattern_create_rgba (rgba->red, rgba->green,
                                     rgba->blue, rgba->alpha);

cdk_window_set_background_pattern (window, pattern);

cairo_pattern_destroy (pattern);
6458}


6461/**
* cdk_window_set_background_pattern:
* @window: a #CdkWindow
* @pattern: (allow-none): a pattern to use, or %NULL
*
* Sets the background of @window.
*
* A background of %NULL means that the window won't have any background. On the
* X11 backend it's also possible to inherit the background from the parent
* window using cdk_x11_get_parent_relative_pattern().
*
* The windowing system will normally fill a window with its background
* when the window is obscured then exposed.
*/
6475void
6476cdk_window_set_background_pattern (CdkWindow       *window,
                                 cairo_pattern_t *pattern)
6478{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (window->input_only)
  return;

if (pattern)
  cairo_pattern_reference (pattern);
if (window->background)
  cairo_pattern_destroy (window->background);
window->background = pattern;

if (cdk_window_has_impl (window))
  {
    CdkWindowImplClass *impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));
    impl_class->set_background (window, pattern);
  }
else
  cdk_window_invalidate_rect_full (window, NULL((void*)0), TRUE(!(0)));
6497}

6499/**
* cdk_window_get_background_pattern:
* @window: a window
*
* Gets the pattern used to clear the background on @window.
*
* Returns: (nullable) (transfer none): The pattern to use for the
* background or %NULL if there is no background.
*
* Since: 2.22
**/
6510cairo_pattern_t *
6511cdk_window_get_background_pattern (CdkWindow *window)
6512{
g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

return window->background;
6516}

6518static void
6519cdk_window_set_cursor_internal (CdkWindow *window,
                              CdkDevice *device,
                              CdkCursor *cursor)
6522{
if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return;

g_assert (cdk_window_get_display (window) == cdk_device_get_display (device))do { if (cdk_window_get_display (window) == cdk_device_get_display
 (device)) ; else g_assertion_message_expr ("Cdk", "cdkwindow.c"
, 6526, ((const char*) (__func__)), "cdk_window_get_display (window) == cdk_device_get_display (device)"
); } while (0);
g_assert (!cursor || cdk_window_get_display (window) == cdk_cursor_get_display (cursor))do { if (!cursor || cdk_window_get_display (window) == cdk_cursor_get_display
 (cursor)) ; else g_assertion_message_expr ("Cdk", "cdkwindow.c"
, 6527, ((const char*) (__func__)), "!cursor || cdk_window_get_display (window) == cdk_cursor_get_display (cursor)"
); } while (0);

if (window->window_type == CDK_WINDOW_ROOT ||
    window->window_type == CDK_WINDOW_FOREIGN)
  CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_device_cursor (window, device, cursor);
else
  {
    CdkPointerWindowInfo *pointer_info;
    CdkDisplay *display;

    display = cdk_window_get_display (window);
    pointer_info = _cdk_display_get_pointer_info (display, device);

    if (_cdk_window_event_parent_of (window, pointer_info->window_under_pointer))
      update_cursor (display, device);
  }
6543}

6545/**
* cdk_window_get_cursor:
* @window: a #CdkWindow
*
* Retrieves a #CdkCursor pointer for the cursor currently set on the
* specified #CdkWindow, or %NULL.  If the return value is %NULL then
* there is no custom cursor set on the specified window, and it is
* using the cursor for its parent window.
*
* Returns: (nullable) (transfer none): a #CdkCursor, or %NULL. The
*   returned object is owned by the #CdkWindow and should not be
*   unreferenced directly. Use cdk_window_set_cursor() to unset the
*   cursor of the window
*
* Since: 2.18
*/
6561CdkCursor *
6562cdk_window_get_cursor (CdkWindow *window)
6563{
g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

return window->cursor;
6567}

6569/**
* cdk_window_set_cursor:
* @window: a #CdkWindow
* @cursor: (allow-none): a cursor
*
* Sets the default mouse pointer for a #CdkWindow.
*
* Note that @cursor must be for the same display as @window.
*
* Use cdk_cursor_new_for_display() or cdk_cursor_new_from_pixbuf() to
* create the cursor. To make the cursor invisible, use %CDK_BLANK_CURSOR.
* Passing %NULL for the @cursor argument to cdk_window_set_cursor() means
* that @window will use the cursor of its parent window. Most windows
* should use this default.
*/
6584void
6585cdk_window_set_cursor (CdkWindow *window,
       CdkCursor *cursor)
6587{
CdkDisplay *display;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

display = cdk_window_get_display (window);

if (window->cursor)
  {
    g_object_unref (window->cursor);
    window->cursor = NULL((void*)0);
  }

if (!CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  {
    CdkDevice *device;
    GList *seats, *s;

    if (cursor)
window->cursor = g_object_ref (cursor)((__typeof__ (cursor)) (g_object_ref) (cursor));

    seats = cdk_display_list_seats (display);

    for (s = seats; s; s = s->next)
      {
        GList *devices, *d;

        device = cdk_seat_get_pointer (s->data);
        cdk_window_set_cursor_internal (window, device, window->cursor);

        devices = cdk_seat_get_slaves (s->data, CDK_SEAT_CAPABILITY_TABLET_STYLUS);
        for (d = devices; d; d = d->next)
          {
            device = cdk_device_get_associated_device (d->data);
            cdk_window_set_cursor_internal (window, device, window->cursor);
          }
        g_list_free (devices);
      }

    g_list_free (seats);
    g_object_notify_by_pspec (G_OBJECT (window)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window)), (((GType) ((20) << (2)))))))), properties[PROP_CURSOR]);
  }
6629}

6631/**
* cdk_window_get_device_cursor:
* @window: a #CdkWindow.
* @device: a master, pointer #CdkDevice.
*
* Retrieves a #CdkCursor pointer for the @device currently set on the
* specified #CdkWindow, or %NULL.  If the return value is %NULL then
* there is no custom cursor set on the specified window, and it is
* using the cursor for its parent window.
*
* Returns: (nullable) (transfer none): a #CdkCursor, or %NULL. The
*   returned object is owned by the #CdkWindow and should not be
*   unreferenced directly. Use cdk_window_set_cursor() to unset the
*   cursor of the window
*
* Since: 3.0
**/
6648CdkCursor *
6649cdk_window_get_device_cursor (CdkWindow *window,
                            CdkDevice *device)
6651{
g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);
g_return_val_if_fail (CDK_IS_DEVICE (device), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((device)); GType __t = ((cdk_device_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_DEVICE (device)"); return (((void*)0)); } } while
 (0);
g_return_val_if_fail (cdk_device_get_source (device) != CDK_SOURCE_KEYBOARD, NULL)do { if ((cdk_device_get_source (device) != CDK_SOURCE_KEYBOARD
)) { } else { g_return_if_fail_warning ("Cdk", ((const char*)
 (__func__)), "cdk_device_get_source (device) != CDK_SOURCE_KEYBOARD"
); return (((void*)0)); } } while (0);
g_return_val_if_fail (cdk_device_get_device_type (device) == CDK_DEVICE_TYPE_MASTER, NULL)do { if ((cdk_device_get_device_type (device) == CDK_DEVICE_TYPE_MASTER
)) { } else { g_return_if_fail_warning ("Cdk", ((const char*)
 (__func__)), "cdk_device_get_device_type (device) == CDK_DEVICE_TYPE_MASTER"
); return (((void*)0)); } } while (0);

return g_hash_table_lookup (window->device_cursor, device);
6658}

6660/**
* cdk_window_set_device_cursor:
* @window: a #CdkWindow
* @device: a master, pointer #CdkDevice
* @cursor: a #CdkCursor
*
* Sets a specific #CdkCursor for a given device when it gets inside @window.
* Use cdk_cursor_new_for_display() or cdk_cursor_new_from_pixbuf() to create
* the cursor. To make the cursor invisible, use %CDK_BLANK_CURSOR. Passing
* %NULL for the @cursor argument to cdk_window_set_cursor() means that
* @window will use the cursor of its parent window. Most windows should
* use this default.
*
* Since: 3.0
**/
6675void
6676cdk_window_set_device_cursor (CdkWindow *window,
                            CdkDevice *device,
                            CdkCursor *cursor)
6679{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);
g_return_if_fail (CDK_IS_DEVICE (device))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((device)); GType __t = ((cdk_device_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_DEVICE (device)"); return; } } while (0);
g_return_if_fail (cdk_device_get_source (device) != CDK_SOURCE_KEYBOARD)do { if ((cdk_device_get_source (device) != CDK_SOURCE_KEYBOARD
)) { } else { g_return_if_fail_warning ("Cdk", ((const char*)
 (__func__)), "cdk_device_get_source (device) != CDK_SOURCE_KEYBOARD"
); return; } } while (0);
g_return_if_fail (cdk_device_get_device_type (device) == CDK_DEVICE_TYPE_MASTER)do { if ((cdk_device_get_device_type (device) == CDK_DEVICE_TYPE_MASTER
)) { } else { g_return_if_fail_warning ("Cdk", ((const char*)
 (__func__)), "cdk_device_get_device_type (device) == CDK_DEVICE_TYPE_MASTER"
); return; } } while (0);

if (!cursor)
  g_hash_table_remove (window->device_cursor, device);
else
  g_hash_table_replace (window->device_cursor, device, g_object_ref (cursor)((__typeof__ (cursor)) (g_object_ref) (cursor)));

cdk_window_set_cursor_internal (window, device, cursor);
6691}

6693/**
* cdk_window_get_geometry:
* @window: a #CdkWindow
* @x: (out) (allow-none): return location for X coordinate of window (relative to its parent)
* @y: (out) (allow-none): return location for Y coordinate of window (relative to its parent)
* @width: (out) (allow-none): return location for width of window
* @height: (out) (allow-none): return location for height of window
*
* Any of the return location arguments to this function may be %NULL,
* if you aren’t interested in getting the value of that field.
*
* The X and Y coordinates returned are relative to the parent window
* of @window, which for toplevels usually means relative to the
* window decorations (titlebar, etc.) rather than relative to the
* root window (screen-size background window).
*
* On the X11 platform, the geometry is obtained from the X server,
* so reflects the latest position of @window; this may be out-of-sync
* with the position of @window delivered in the most-recently-processed
* #CdkEventConfigure. cdk_window_get_position() in contrast gets the
* position from the most recent configure event.
*
* Note: If @window is not a toplevel, it is much better
* to call cdk_window_get_position(), cdk_window_get_width() and
* cdk_window_get_height() instead, because it avoids the roundtrip to
* the X server and because these functions support the full 32-bit
* coordinate space, whereas cdk_window_get_geometry() is restricted to
* the 16-bit coordinates of X11.
*/
6722void
6723cdk_window_get_geometry (CdkWindow *window,
	 gint      *x,
	 gint      *y,
	 gint      *width,
	 gint      *height)
6728{
CdkWindow *parent;
CdkWindowImplClass *impl_class;

if (!window)
  window = cdk_screen_get_root_window ((cdk_screen_get_default ()));

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (!CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  {
    if (cdk_window_has_impl (window))
{
 impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));
 impl_class->get_geometry (window, x, y,
		    width, height);
 /* This reports the position wrt to the native parent, we need to convert
    it to be relative to the client side parent */
 parent = window->parent;
 if (parent && !cdk_window_has_impl (parent))
   {
     if (x)
*x -= parent->abs_x;
     if (y)
*y -= parent->abs_y;
   }
}
    else
{
        if (x)
          *x = window->x;
        if (y)
          *y = window->y;
 if (width)
   *width = window->width;
 if (height)
   *height = window->height;
}
  }
6767}

6769/**
* cdk_window_get_width:
* @window: a #CdkWindow
*
* Returns the width of the given @window.
*
* On the X11 platform the returned size is the size reported in the
* most-recently-processed configure event, rather than the current
* size on the X server.
*
* Returns: The width of @window
*
* Since: 2.24
*/
6783int
6784cdk_window_get_width (CdkWindow *window)
6785{
g_return_val_if_fail (CDK_IS_WINDOW (window), 0)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (0); } } while (0);

return window->width;
6789}

6791/**
* cdk_window_get_height:
* @window: a #CdkWindow
*
* Returns the height of the given @window.
*
* On the X11 platform the returned size is the size reported in the
* most-recently-processed configure event, rather than the current
* size on the X server.
*
* Returns: The height of @window
*
* Since: 2.24
*/
6805int
6806cdk_window_get_height (CdkWindow *window)
6807{
g_return_val_if_fail (CDK_IS_WINDOW (window), 0)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (0); } } while (0);

return window->height;
6811}

6813/**
* cdk_window_get_origin:
* @window: a #CdkWindow
* @x: (out) (allow-none): return location for X coordinate
* @y: (out) (allow-none): return location for Y coordinate
*
* Obtains the position of a window in root window coordinates.
* (Compare with cdk_window_get_position() and
* cdk_window_get_geometry() which return the position of a window
* relative to its parent window.)
*
* Returns: not meaningful, ignore
*/
6826gint
6827cdk_window_get_origin (CdkWindow *window,
       gint      *x,
       gint      *y)
6830{
gint dummy_x, dummy_y;

g_return_val_if_fail (CDK_IS_WINDOW (window), 0)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (0); } } while (0);

cdk_window_get_root_coords (window,
                            0, 0,
                            x ? x : &dummy_x,
                            y ? y : &dummy_y);

return TRUE(!(0));
6841}

6843/**
* cdk_window_get_root_coords:
* @window: a #CdkWindow
* @x: X coordinate in window
* @y: Y coordinate in window
* @root_x: (out): return location for X coordinate
* @root_y: (out): return location for Y coordinate
*
* Obtains the position of a window position in root
* window coordinates. This is similar to
* cdk_window_get_origin() but allows you to pass
* in any position in the window, not just the origin.
*
* Since: 2.18
*/
6858void
6859cdk_window_get_root_coords (CdkWindow *window,
	    gint       x,
	    gint       y,
	    gint      *root_x,
	    gint      *root_y)
6864{
CdkWindowImplClass *impl_class;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  {
    *root_x = 0;
    *root_y = 0;
    return;
  }

impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));
impl_class->get_root_coords (window->impl_window,
	       x + window->abs_x,
	       y + window->abs_y,
	       root_x, root_y);
6881}

6883/**
* cdk_window_coords_to_parent:
* @window: a child window
* @x: X coordinate in child’s coordinate system
* @y: Y coordinate in child’s coordinate system
* @parent_x: (out) (allow-none): return location for X coordinate
* in parent’s coordinate system, or %NULL
* @parent_y: (out) (allow-none): return location for Y coordinate
* in parent’s coordinate system, or %NULL
*
* Transforms window coordinates from a child window to its parent
* window, where the parent window is the normal parent as returned by
* cdk_window_get_parent() for normal windows, and the window's
* embedder as returned by cdk_offscreen_window_get_embedder() for
* offscreen windows.
*
* For normal windows, calling this function is equivalent to adding
* the return values of cdk_window_get_position() to the child coordinates.
* For offscreen windows however (which can be arbitrarily transformed),
* this function calls the CdkWindow::to-embedder: signal to translate
* the coordinates.
*
* You should always use this function when writing generic code that
* walks up a window hierarchy.
*
* See also: cdk_window_coords_from_parent()
*
* Since: 2.22
**/
6912void
6913cdk_window_coords_to_parent (CdkWindow *window,
                           gdouble    x,
                           gdouble    y,
                           gdouble   *parent_x,
                           gdouble   *parent_y)
6918{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (cdk_window_is_offscreen (window))
  {
    gdouble px, py;

    to_embedder (window, x, y, &px, &py);

    if (parent_x)
      *parent_x = px;

    if (parent_y)
      *parent_y = py;
  }
else
  {
    if (parent_x)
      *parent_x = x + window->x;

    if (parent_y)
      *parent_y = y + window->y;
  }
6941}

6943/**
* cdk_window_coords_from_parent:
* @window: a child window
* @parent_x: X coordinate in parent’s coordinate system
* @parent_y: Y coordinate in parent’s coordinate system
* @x: (out) (allow-none): return location for X coordinate in child’s coordinate system
* @y: (out) (allow-none): return location for Y coordinate in child’s coordinate system
*
* Transforms window coordinates from a parent window to a child
* window, where the parent window is the normal parent as returned by
* cdk_window_get_parent() for normal windows, and the window's
* embedder as returned by cdk_offscreen_window_get_embedder() for
* offscreen windows.
*
* For normal windows, calling this function is equivalent to subtracting
* the return values of cdk_window_get_position() from the parent coordinates.
* For offscreen windows however (which can be arbitrarily transformed),
* this function calls the CdkWindow::from-embedder: signal to translate
* the coordinates.
*
* You should always use this function when writing generic code that
* walks down a window hierarchy.
*
* See also: cdk_window_coords_to_parent()
*
* Since: 2.22
**/
6970void
6971cdk_window_coords_from_parent (CdkWindow *window,
                             gdouble    parent_x,
                             gdouble    parent_y,
                             gdouble   *x,
                             gdouble   *y)
6976{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (cdk_window_is_offscreen (window))
  {
    gdouble cx, cy;

    from_embedder (window, parent_x, parent_y, &cx, &cy);

    if (x)
      *x = cx;

    if (y)
      *y = cy;
  }
else
  {
    if (x)
      *x = parent_x - window->x;

    if (y)
      *y = parent_y - window->y;
  }
6999}

7001/**
* cdk_window_shape_combine_region:
* @window: a #CdkWindow
* @shape_region: (allow-none): region of window to be non-transparent
* @offset_x: X position of @shape_region in @window coordinates
* @offset_y: Y position of @shape_region in @window coordinates
*
* Makes pixels in @window outside @shape_region be transparent,
* so that the window may be nonrectangular.
*
* If @shape_region is %NULL, the shape will be unset, so the whole
* window will be opaque again. @offset_x and @offset_y are ignored
* if @shape_region is %NULL.
*
* On the X11 platform, this uses an X server extension which is
* widely available on most common platforms, but not available on
* very old X servers, and occasionally the implementation will be
* buggy. On servers without the shape extension, this function
* will do nothing.
*
* This function works on both toplevel and child windows.
*/
7023void
7024cdk_window_shape_combine_region (CdkWindow       *window,
		 const cairo_region_t *shape_region,
		 gint             offset_x,
		 gint             offset_y)
7028{
cairo_region_t *old_region, *new_region, *diff;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return;

if (!window->shape && shape_region == NULL((void*)0))
  return;

window->shaped = (shape_region != NULL((void*)0));

if (window->shape)
  cairo_region_destroy (window->shape);

old_region = NULL((void*)0);
if (CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
  old_region = cairo_region_copy (window->clip_region);

if (shape_region)
  {
    window->shape = cairo_region_copy (shape_region);
    cairo_region_translate (window->shape, offset_x, offset_y);
  }
else
  window->shape = NULL((void*)0);

recompute_visible_regions (window, FALSE(0));

if (old_region)
  {
    new_region = cairo_region_copy (window->clip_region);

    /* New area in the window, needs invalidation */
    diff = cairo_region_copy (new_region);
    cairo_region_subtract (diff, old_region);

    cdk_window_invalidate_region_full (window, diff, TRUE(!(0)));

    cairo_region_destroy (diff);

    if (!cdk_window_is_toplevel (window))
{
 /* New area in the non-root parent window, needs invalidation */
 diff = cairo_region_copy (old_region);
 cairo_region_subtract (diff, new_region);

 /* Adjust region to parent window coords */
 cairo_region_translate (diff, window->x, window->y);

 cdk_window_invalidate_region_full (window->parent, diff, TRUE(!(0)));

 cairo_region_destroy (diff);
}

    cairo_region_destroy (new_region);
    cairo_region_destroy (old_region);
  }
7087}

7089static void
7090do_child_shapes (CdkWindow *window,
 gboolean merge)
7092{
CdkRectangle r;
cairo_region_t *region;

r.x = 0;
r.y = 0;
r.width = window->width;
r.height = window->height;

region = cairo_region_create_rectangle (&r);
remove_child_area (window, FALSE(0), region);

if (merge && window->shape)
  cairo_region_subtract (region, window->shape);

cairo_region_xor_rectangle (region, &r);

cdk_window_shape_combine_region (window, region, 0, 0);

cairo_region_destroy (region);
7112}

7114/**
* cdk_window_set_child_shapes:
* @window: a #CdkWindow
*
* Sets the shape mask of @window to the union of shape masks
* for all children of @window, ignoring the shape mask of @window
* itself. Contrast with cdk_window_merge_child_shapes() which includes
* the shape mask of @window in the masks to be merged.
**/
7123void
7124cdk_window_set_child_shapes (CdkWindow *window)
7125{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

do_child_shapes (window, FALSE(0));
7129}

7131/**
* cdk_window_merge_child_shapes:
* @window: a #CdkWindow
*
* Merges the shape masks for any child windows into the
* shape mask for @window. i.e. the union of all masks
* for @window and its children will become the new mask
* for @window. See cdk_window_shape_combine_region().
*
* This function is distinct from cdk_window_set_child_shapes()
* because it includes @window’s shape mask in the set of shapes to
* be merged.
*/
7144void
7145cdk_window_merge_child_shapes (CdkWindow *window)
7146{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

do_child_shapes (window, TRUE(!(0)));
7150}

7152/**
* cdk_window_input_shape_combine_region:
* @window: a #CdkWindow
* @shape_region: region of window to be non-transparent
* @offset_x: X position of @shape_region in @window coordinates
* @offset_y: Y position of @shape_region in @window coordinates
*
* Like cdk_window_shape_combine_region(), but the shape applies
* only to event handling. Mouse events which happen while
* the pointer position corresponds to an unset bit in the
* mask will be passed on the window below @window.
*
* An input shape is typically used with RGBA windows.
* The alpha channel of the window defines which pixels are
* invisible and allows for nicely antialiased borders,
* and the input shape controls where the window is
* “clickable”.
*
* On the X11 platform, this requires version 1.1 of the
* shape extension.
*
* On the Win32 platform, this functionality is not present and the
* function does nothing.
*
* Since: 2.10
*/
7178void
7179cdk_window_input_shape_combine_region (CdkWindow       *window,
		       const cairo_region_t *shape_region,
		       gint             offset_x,
		       gint             offset_y)
7183{
CdkWindowImplClass *impl_class;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return;

if (window->input_shape)
  cairo_region_destroy (window->input_shape);

if (shape_region)
  {
    window->input_shape = cairo_region_copy (shape_region);
    cairo_region_translate (window->input_shape, offset_x, offset_y);
  }
else
  window->input_shape = NULL((void*)0);

if (cdk_window_has_impl (window))
  {
    impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));
    impl_class->input_shape_combine_region (window, window->input_shape, 0, 0);
  }

/* Pointer may have e.g. moved outside window due to the input mask change */
_cdk_synthesize_crossing_events_for_geometry_change (window);
7210}

7212static void
7213do_child_input_shapes (CdkWindow *window,
       gboolean merge)
7215{
CdkRectangle r;
cairo_region_t *region;

r.x = 0;
r.y = 0;
r.width = window->width;
r.height = window->height;

region = cairo_region_create_rectangle (&r);
remove_child_area (window, TRUE(!(0)), region);

if (merge && window->shape)
  cairo_region_subtract (region, window->shape);
if (merge && window->input_shape)
  cairo_region_subtract (region, window->input_shape);

cairo_region_xor_rectangle (region, &r);

cdk_window_input_shape_combine_region (window, region, 0, 0);
7235}


7238/**
* cdk_window_set_child_input_shapes:
* @window: a #CdkWindow
*
* Sets the input shape mask of @window to the union of input shape masks
* for all children of @window, ignoring the input shape mask of @window
* itself. Contrast with cdk_window_merge_child_input_shapes() which includes
* the input shape mask of @window in the masks to be merged.
*
* Since: 2.10
**/
7249void
7250cdk_window_set_child_input_shapes (CdkWindow *window)
7251{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

do_child_input_shapes (window, FALSE(0));
7255}

7257/**
* cdk_window_set_pass_through:
* @window: a #CdkWindow
* @pass_through: a boolean
*
* Sets whether input to the window is passed through to the window
* below.
*
* The default value of this is %FALSE, which means that pointer
* events that happen inside the window are send first to the window,
* but if the event is not selected by the event mask then the event
* is sent to the parent window, and so on up the hierarchy.
*
* If @pass_through is %TRUE then such pointer events happen as if the
* window wasn't there at all, and thus will be sent first to any
* windows below @window. This is useful if the window is used in a
* transparent fashion. In the terminology of the web this would be called
* "pointer-events: none".
*
* Note that a window with @pass_through %TRUE can still have a subwindow
* without pass through, so you can get events on a subset of a window. And in
* that cases you would get the in-between related events such as the pointer
* enter/leave events on its way to the destination window.
*
* Since: 3.18
**/
7283void
7284cdk_window_set_pass_through (CdkWindow *window,
                           gboolean   pass_through)
7286{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

window->pass_through = !!pass_through;

/* Pointer may have e.g. moved outside window due to the input region change */
_cdk_synthesize_crossing_events_for_geometry_change (window);
7293}

7295/**
* cdk_window_get_pass_through:
* @window: a #CdkWindow
*
* Returns whether input to the window is passed through to the window
* below.
*
* See cdk_window_set_pass_through() for details
*
* Since: 3.18
**/
7306gboolean
7307cdk_window_get_pass_through (CdkWindow *window)
7308{
g_return_val_if_fail (CDK_IS_WINDOW (window), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return ((0)); } } while (0);

return window->pass_through;
7312}

7314/**
* cdk_window_merge_child_input_shapes:
* @window: a #CdkWindow
*
* Merges the input shape masks for any child windows into the
* input shape mask for @window. i.e. the union of all input masks
* for @window and its children will become the new input mask
* for @window. See cdk_window_input_shape_combine_region().
*
* This function is distinct from cdk_window_set_child_input_shapes()
* because it includes @window’s input shape mask in the set of
* shapes to be merged.
*
* Since: 2.10
**/
7329void
7330cdk_window_merge_child_input_shapes (CdkWindow *window)
7331{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

do_child_input_shapes (window, TRUE(!(0)));
7335}


7338/**
* cdk_window_set_static_gravities:
* @window: a #CdkWindow
* @use_static: %TRUE to turn on static gravity
*
* Used to set the bit gravity of the given window to static, and flag
* it so all children get static subwindow gravity. This is used if you
* are implementing scary features that involve deep knowledge of the
* windowing system. Don’t worry about it.
*
* Returns: %FALSE
*
* Deprecated: 3.16: static gravities haven't worked on anything but X11
*   for a long time.
*/
7353gboolean
7354cdk_window_set_static_gravities (CdkWindow *window,
		 gboolean   use_static G_GNUC_UNUSED__attribute__ ((__unused__)))
7356{
g_return_val_if_fail (CDK_IS_WINDOW (window), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return ((0)); } } while (0);

return FALSE(0);
7360}

7362/**
* cdk_window_get_composited:
* @window: a #CdkWindow
*
* Determines whether @window is composited.
*
* See cdk_window_set_composited().
*
* Returns: %TRUE if the window is composited.
*
* Since: 2.22
**/
7374gboolean
7375cdk_window_get_composited (CdkWindow *window)
7376{
g_return_val_if_fail (CDK_IS_WINDOW (window), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return ((0)); } } while (0);

return window->composited;
7380}

7382/**
* cdk_window_set_composited:
* @window: a #CdkWindow
* @composited: %TRUE to set the window as composited
*
* Sets a #CdkWindow as composited, or unsets it. Composited
* windows do not automatically have their contents drawn to
* the screen. Drawing is redirected to an offscreen buffer
* and an expose event is emitted on the parent of the composited
* window. It is the responsibility of the parent’s expose handler
* to manually merge the off-screen content onto the screen in
* whatever way it sees fit.
*
* It only makes sense for child windows to be composited; see
* cdk_window_set_opacity() if you need translucent toplevel
* windows.
*
* An additional effect of this call is that the area of this
* window is no longer clipped from regions marked for
* invalidation on its parent. Draws done on the parent
* window are also no longer clipped by the child.
*
* This call is only supported on some systems (currently,
* only X11 with new enough Xcomposite and Xdamage extensions).
* You must call cdk_display_supports_composite() to check if
* setting a window as composited is supported before
* attempting to do so.
*
* Since: 2.12
*/
7412void
7413cdk_window_set_composited (CdkWindow *window,
	   gboolean   composited)
7415{
CdkDisplay *display;
CdkWindowImplClass *impl_class;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

composited = composited != FALSE(0);

if (window->composited == composited)
  return;

if (composited)
  cdk_window_ensure_native (window);

display = cdk_window_get_display (window);

impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));

if (composited && (!cdk_display_supports_composite (display) || !impl_class->set_composited))
  {
    g_warning ("cdk_window_set_composited called but "
               "compositing is not supported");
    return;
  }

impl_class->set_composited (window, composited);

recompute_visible_regions (window, FALSE(0));

if (CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
  cdk_window_invalidate_in_parent (window);

window->composited = composited;
7448}

7450/**
* cdk_window_get_modal_hint:
* @window: A toplevel #CdkWindow.
*
* Determines whether or not the window manager is hinted that @window
* has modal behaviour.
*
* Returns: whether or not the window has the modal hint set.
*
* Since: 2.22
*/
7461gboolean
7462cdk_window_get_modal_hint (CdkWindow *window)
7463{
g_return_val_if_fail (CDK_IS_WINDOW (window), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return ((0)); } } while (0);

return window->modal_hint;
7467}

7469/**
* cdk_window_get_accept_focus:
* @window: a toplevel #CdkWindow.
*
* Determines whether or not the desktop environment shuld be hinted that
* the window does not want to receive input focus.
*
* Returns: whether or not the window should receive input focus.
*
* Since: 2.22
*/
7480gboolean
7481cdk_window_get_accept_focus (CdkWindow *window)
7482{
g_return_val_if_fail (CDK_IS_WINDOW (window), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return ((0)); } } while (0);

return window->accept_focus;
7486}

7488/**
* cdk_window_get_focus_on_map:
* @window: a toplevel #CdkWindow.
*
* Determines whether or not the desktop environment should be hinted that the
* window does not want to receive input focus when it is mapped.
*
* Returns: whether or not the window wants to receive input focus when
* it is mapped.
*
* Since: 2.22
*/
7500gboolean
7501cdk_window_get_focus_on_map (CdkWindow *window)
7502{
g_return_val_if_fail (CDK_IS_WINDOW (window), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return ((0)); } } while (0);

return window->focus_on_map;
7506}

7508/**
* cdk_window_is_input_only:
* @window: a toplevel #CdkWindow
*
* Determines whether or not the window is an input only window.
*
* Returns: %TRUE if @window is input only
*
* Since: 2.22
*/
7518gboolean
7519cdk_window_is_input_only (CdkWindow *window)
7520{
g_return_val_if_fail (CDK_IS_WINDOW (window), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return ((0)); } } while (0);

return window->input_only;
7524}

7526/**
* cdk_window_is_shaped:
* @window: a toplevel #CdkWindow
*
* Determines whether or not the window is shaped.
*
* Returns: %TRUE if @window is shaped
*
* Since: 2.22
*/
7536gboolean
7537cdk_window_is_shaped (CdkWindow *window)
7538{
g_return_val_if_fail (CDK_IS_WINDOW (window), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return ((0)); } } while (0);

return window->shaped;
7542}

7544/* Gets the toplevel for a window as used for events,
 i.e. including offscreen parents */
7546static CdkWindow *
7547get_event_parent (CdkWindow *window)
7548{
if (cdk_window_is_offscreen (window))
  return cdk_offscreen_window_get_embedder ((CdkWindow *)window);
else
  return window->parent;
7553}

7555/* Gets the toplevel for a window as used for events,
 i.e. including offscreen parents going up to the native
 toplevel */
7558static CdkWindow *
7559get_event_toplevel (CdkWindow *window)
7560{
CdkWindow *parent;

while ((parent = get_event_parent (window)) != NULL((void*)0) &&
(parent->window_type != CDK_WINDOW_ROOT))
  window = parent;

return window;
7568}

7570gboolean
7571_cdk_window_event_parent_of (CdkWindow *parent,
  	             CdkWindow *child)
7573{
CdkWindow *w;

w = child;
while (w != NULL((void*)0))
  {
    if (w == parent)
return TRUE(!(0));

    w = get_event_parent (w);
  }

return FALSE(0);
7586}

7588static void
7589update_cursor (CdkDisplay *display,
             CdkDevice  *device)
7591{
CdkWindow *cursor_window, *parent, *toplevel;
CdkWindow *pointer_window;
CdkWindowImplClass *impl_class;
CdkPointerWindowInfo *pointer_info;
CdkDeviceGrabInfo *grab;
CdkCursor *cursor;

pointer_info = _cdk_display_get_pointer_info (display, device);
pointer_window = pointer_info->window_under_pointer;

/* We ignore the serials here and just pick the last grab
   we've sent, as that would shortly be used anyway. */
grab = _cdk_display_get_last_device_grab (display, device);
if (/* have grab */
    grab != NULL((void*)0) &&
    /* the pointer is not in a descendant of the grab window */
    !_cdk_window_event_parent_of (grab->window, pointer_window))
  {
    /* use the cursor from the grab window */
    cursor_window = grab->window;
  }
else
  {
    /* otherwise use the cursor from the pointer window */
    cursor_window = pointer_window;
  }

/* Find the first window with the cursor actually set, as
   the cursor is inherited from the parent */
while (cursor_window->cursor == NULL((void*)0) &&
       !g_hash_table_contains (cursor_window->device_cursor, device) &&
(parent = get_event_parent (cursor_window)) != NULL((void*)0) &&
parent->window_type != CDK_WINDOW_ROOT)
  cursor_window = parent;

cursor = g_hash_table_lookup (cursor_window->device_cursor, device);

if (!cursor)
  cursor = cursor_window->cursor;

/* Set all cursors on toplevel, otherwise its tricky to keep track of
 * which native window has what cursor set. */
toplevel = get_event_toplevel (pointer_window);
impl_class = CDK_WINDOW_IMPL_GET_CLASS (toplevel->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((toplevel->impl
)))->g_class))));
impl_class->set_device_cursor (toplevel, device, cursor);
7637}

7639static gboolean
7640point_in_window (CdkWindow *window,
 gdouble    x,
               gdouble    y)
7643{
return
  x >= 0 && x < window->width &&
  y >= 0 && y < window->height &&
  (window->shape == NULL((void*)0) ||
   cairo_region_contains_point (window->shape,
	  x, y)) &&
  (window->input_shape == NULL((void*)0) ||
   cairo_region_contains_point (window->input_shape,
	  x, y));
7653}

7655/* Same as point_in_window, except it also takes pass_through and its
 interaction with child windows into account */
7657static gboolean
7658point_in_input_window (CdkWindow *window,
       gdouble    x,
       gdouble    y,
       CdkWindow **input_window,
       gdouble   *input_window_x,
       gdouble   *input_window_y)
7664{
CdkWindow *sub;
double child_x, child_y;
GList *l;

if (!point_in_window (window, x, y))
  return FALSE(0);

if (!window->pass_through)
  {
    if (input_window)
{
 *input_window = window;
 *input_window_x = x;
 *input_window_y = y;
}
    return TRUE(!(0));
  }

/* For pass-through, must be over a child input window */

/* Children is ordered in reverse stack order, i.e. first is topmost */
for (l = window->children; l != NULL((void*)0); l = l->next)
  {
    sub = l->data;

    if (!CDK_WINDOW_IS_MAPPED (sub)(((sub)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
continue;

    cdk_window_coords_from_parent ((CdkWindow *)sub,
		     x, y,
		     &child_x, &child_y);
    if (point_in_input_window (sub, child_x, child_y,
		 input_window, input_window_x, input_window_y))
{
 if (input_window)
   cdk_window_coords_to_parent (sub,
			 *input_window_x,
			 *input_window_y,
			 input_window_x,
			 input_window_y);
 return TRUE(!(0));
}
  }

return FALSE(0);
7710}

7712static CdkWindow *
7713convert_native_coords_to_toplevel (CdkWindow *window,
		   gdouble    child_x,
                                 gdouble    child_y,
		   gdouble   *toplevel_x,
                                 gdouble   *toplevel_y)
7718{
gdouble x, y;

x = child_x;
y = child_y;

while (!cdk_window_is_toplevel (window))
  {
    x += window->x;
    y += window->y;
    window = window->parent;
  }

*toplevel_x = x;
*toplevel_y = y;

return window;
7735}

7737static void
7738convert_toplevel_coords_to_window (CdkWindow *window,
		   gdouble    toplevel_x,
		   gdouble    toplevel_y,
		   gdouble   *window_x,
		   gdouble   *window_y)
7743{
CdkWindow *parent;
gdouble x, y;
GList *children, *l;

x = toplevel_x;
y = toplevel_y;

children = NULL((void*)0);
while ((parent = get_event_parent (window)) != NULL((void*)0) &&
(parent->window_type != CDK_WINDOW_ROOT))
  {
    children = g_list_prepend (children, window);
    window = parent;
  }

for (l = children; l != NULL((void*)0); l = l->next)
  cdk_window_coords_from_parent (l->data, x, y, &x, &y);

g_list_free (children);

*window_x = x;
*window_y = y;
7766}

7768static CdkWindow *
7769pick_embedded_child (CdkWindow *window,
     gdouble    x,
                   gdouble    y)
7772{
CdkWindow *res;

res = NULL((void*)0);
g_signal_emit (window,
 signals[PICK_EMBEDDED_CHILD], 0,
 x, y, &res);

return res;
7781}

7783CdkWindow *
7784_cdk_window_find_child_at (CdkWindow *window,
	   double     x,
                         double     y)
7787{
CdkWindow *sub;
double child_x, child_y;
GList *l;

if (point_in_window (window, x, y))
  {
    /* Children is ordered in reverse stack order, i.e. first is topmost */
    for (l = window->children; l != NULL((void*)0); l = l->next)
{
 sub = l->data;

 if (!CDK_WINDOW_IS_MAPPED (sub)(((sub)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
   continue;

 cdk_window_coords_from_parent ((CdkWindow *)sub,
                                       x, y,
                                       &child_x, &child_y);
 if (point_in_input_window (sub, child_x, child_y,
		     NULL((void*)0), NULL((void*)0), NULL((void*)0)))
   return (CdkWindow *)sub;
}

    if (window->num_offscreen_children > 0)
{
 sub = pick_embedded_child (window,
		     x, y);
 if (sub)
   return (CdkWindow *)sub;
}
  }

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

7822CdkWindow *
7823_cdk_window_find_descendant_at (CdkWindow *window,
		gdouble    x,
                              gdouble    y,
		gdouble   *found_x,
		gdouble   *found_y)
7828{
CdkWindow *sub, *input_window;
gdouble child_x, child_y;
GList *l;
gboolean found;

if (point_in_window (window, x, y))
  {
    do
{
 found = FALSE(0);
 /* Children is ordered in reverse stack order, i.e. first is topmost */
 for (l = window->children; l != NULL((void*)0); l = l->next)
   {
     sub = l->data;

     if (!CDK_WINDOW_IS_MAPPED (sub)(((sub)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
continue;

     cdk_window_coords_from_parent ((CdkWindow *)sub,
                                           x, y,
                                           &child_x, &child_y);
     if (point_in_input_window (sub, child_x, child_y,
			 &input_window, &child_x, &child_y))
{
  x = child_x;
  y = child_y;
  window = input_window;
  found = TRUE(!(0));
  break;
}
   }
 if (!found &&
     window->num_offscreen_children > 0)
   {
     sub = pick_embedded_child (window,
			 x, y);
     if (sub)
{
  found = TRUE(!(0));
  window = sub;
  from_embedder (sub, x, y, &x, &y);
}
   }
}
    while (found);
  }
else
  {
    /* Not in window at all */
    window = NULL((void*)0);
  }

if (found_x)
  *found_x = x;
if (found_y)
  *found_y = y;

return window;
7887}

7889/**
* cdk_window_beep:
* @window: a toplevel #CdkWindow
*
* Emits a short beep associated to @window in the appropriate
* display, if supported. Otherwise, emits a short beep on
* the display just as cdk_display_beep().
*
* Since: 2.12
**/
7899void
7900cdk_window_beep (CdkWindow *window)
7901{
CdkDisplay *display;
CdkWindow *toplevel;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return;

toplevel = get_event_toplevel (window);
display = cdk_window_get_display (window);

if (toplevel)
  {
    if (CDK_WINDOW_IMPL_GET_CLASS (toplevel->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((toplevel->impl
)))->g_class))))->beep (toplevel))
      return;
  }

/* If windows fail to beep, we beep the display. */
cdk_display_beep (display);
7921}

7923/**
* cdk_window_set_support_multidevice:
* @window: a #CdkWindow.
* @support_multidevice: %TRUE to enable multidevice support in @window.
*
* This function will enable multidevice features in @window.
*
* Multidevice aware windows will need to handle properly multiple,
* per device enter/leave events, device grabs and grab ownerships.
*
* Since: 3.0
**/
7935void
7936cdk_window_set_support_multidevice (CdkWindow *window,
                                  gboolean   support_multidevice)
7938{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return;

if (window->support_multidevice == support_multidevice)
  return;

window->support_multidevice = support_multidevice;

/* FIXME: What to do if called when some pointers are inside the window ? */
7950}

7952/**
* cdk_window_get_support_multidevice:
* @window: a #CdkWindow.
*
* Returns %TRUE if the window is aware of the existence of multiple
* devices.
*
* Returns: %TRUE if the window handles multidevice features.
*
* Since: 3.0
**/
7963gboolean
7964cdk_window_get_support_multidevice (CdkWindow *window)
7965{
g_return_val_if_fail (CDK_IS_WINDOW (window), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return ((0)); } } while (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return FALSE(0);

return window->support_multidevice;
7972}

7974static const guint type_masks[] = {
CDK_SUBSTRUCTURE_MASK, /* CDK_DELETE                 = 0  */
CDK_STRUCTURE_MASK, /* CDK_DESTROY                   = 1  */
CDK_EXPOSURE_MASK, /* CDK_EXPOSE                     = 2  */
CDK_POINTER_MOTION_MASK, /* CDK_MOTION_NOTIFY        = 3  */
CDK_BUTTON_PRESS_MASK, /* CDK_BUTTON_PRESS           = 4  */
CDK_BUTTON_PRESS_MASK, /* CDK_2BUTTON_PRESS          = 5  */
CDK_BUTTON_PRESS_MASK, /* CDK_3BUTTON_PRESS          = 6  */
CDK_BUTTON_RELEASE_MASK, /* CDK_BUTTON_RELEASE       = 7  */
CDK_KEY_PRESS_MASK, /* CDK_KEY_PRESS                 = 8  */
CDK_KEY_RELEASE_MASK, /* CDK_KEY_RELEASE             = 9  */
CDK_ENTER_NOTIFY_MASK, /* CDK_ENTER_NOTIFY           = 10 */
CDK_LEAVE_NOTIFY_MASK, /* CDK_LEAVE_NOTIFY           = 11 */
CDK_FOCUS_CHANGE_MASK, /* CDK_FOCUS_CHANGE           = 12 */
CDK_STRUCTURE_MASK, /* CDK_CONFIGURE                 = 13 */
CDK_VISIBILITY_NOTIFY_MASK, /* CDK_MAP               = 14 */
CDK_VISIBILITY_NOTIFY_MASK, /* CDK_UNMAP             = 15 */
CDK_PROPERTY_CHANGE_MASK, /* CDK_PROPERTY_NOTIFY     = 16 */
CDK_PROPERTY_CHANGE_MASK, /* CDK_SELECTION_CLEAR     = 17 */
CDK_PROPERTY_CHANGE_MASK, /* CDK_SELECTION_REQUEST   = 18 */
CDK_PROPERTY_CHANGE_MASK, /* CDK_SELECTION_NOTIFY    = 19 */
CDK_PROXIMITY_IN_MASK, /* CDK_PROXIMITY_IN           = 20 */
CDK_PROXIMITY_OUT_MASK, /* CDK_PROXIMITY_OUT         = 21 */
CDK_ALL_EVENTS_MASK, /* CDK_DRAG_ENTER               = 22 */
CDK_ALL_EVENTS_MASK, /* CDK_DRAG_LEAVE               = 23 */
CDK_ALL_EVENTS_MASK, /* CDK_DRAG_MOTION              = 24 */
CDK_ALL_EVENTS_MASK, /* CDK_DRAG_STATUS              = 25 */
CDK_ALL_EVENTS_MASK, /* CDK_DROP_START               = 26 */
CDK_ALL_EVENTS_MASK, /* CDK_DROP_FINISHED            = 27 */
CDK_ALL_EVENTS_MASK, /* CDK_CLIENT_EVENT	       = 28 */
CDK_VISIBILITY_NOTIFY_MASK, /* CDK_VISIBILITY_NOTIFY = 29 */
CDK_EXPOSURE_MASK, /* CDK_NO_EXPOSE                  = 30 */
CDK_SCROLL_MASK | CDK_SMOOTH_SCROLL_MASK,/* CDK_SCROLL= 31 */
0, /* CDK_WINDOW_STATE = 32 */
0, /* CDK_SETTING = 33 */
0, /* CDK_OWNER_CHANGE = 34 */
0, /* CDK_GRAB_BROKEN = 35 */
0, /* CDK_DAMAGE = 36 */
CDK_TOUCH_MASK, /* CDK_TOUCH_BEGIN = 37 */
CDK_TOUCH_MASK, /* CDK_TOUCH_UPDATE = 38 */
CDK_TOUCH_MASK, /* CDK_TOUCH_END = 39 */
CDK_TOUCH_MASK, /* CDK_TOUCH_CANCEL = 40 */
CDK_TOUCHPAD_GESTURE_MASK, /* CDK_TOUCHPAD_SWIPE = 41 */
CDK_TOUCHPAD_GESTURE_MASK, /* CDK_TOUCHPAD_PINCH = 42 */
CDK_TABLET_PAD_MASK, /* CDK_PAD_BUTTON_PRESS  = 43 */
CDK_TABLET_PAD_MASK, /* CDK_PAD_BUTTON_RELEASE = 44 */
CDK_TABLET_PAD_MASK, /* CDK_PAD_RING = 45 */
CDK_TABLET_PAD_MASK, /* CDK_PAD_STRIP = 46 */
CDK_TABLET_PAD_MASK, /* CDK_PAD_GROUP_MODE = 47 */
8023};
8024G_STATIC_ASSERT (G_N_ELEMENTS (type_masks) == CDK_EVENT_LAST)_Static_assert ((sizeof (type_masks) / sizeof ((type_masks)[0
])) == CDK_EVENT_LAST, "Expression evaluates to false");

8026/* send motion events if the right buttons are down */
8027static guint
8028update_evmask_for_button_motion (guint           evmask,
		 CdkModifierType mask)
8030{
if (evmask & CDK_BUTTON_MOTION_MASK &&
    mask & (CDK_BUTTON1_MASK |
     CDK_BUTTON2_MASK |
     CDK_BUTTON3_MASK |
     CDK_BUTTON4_MASK |
     CDK_BUTTON5_MASK))
  evmask |= CDK_POINTER_MOTION_MASK;

if ((evmask & CDK_BUTTON1_MOTION_MASK && mask & CDK_BUTTON1_MASK) ||
    (evmask & CDK_BUTTON2_MOTION_MASK && mask & CDK_BUTTON2_MASK) ||
    (evmask & CDK_BUTTON3_MOTION_MASK && mask & CDK_BUTTON3_MASK))
  evmask |= CDK_POINTER_MOTION_MASK;

return evmask;
8045}

8047static gboolean
8048is_button_type (CdkEventType type)
8049{
return type == CDK_BUTTON_PRESS ||
type == CDK_2BUTTON_PRESS ||
type == CDK_3BUTTON_PRESS ||
type == CDK_BUTTON_RELEASE ||
       type == CDK_TOUCH_BEGIN ||
       type == CDK_TOUCH_END ||
       type == CDK_TOUCH_CANCEL ||
type == CDK_SCROLL;
8058}

8060static gboolean
8061is_gesture_type (CdkEventType type)
8062{
return (type == CDK_TOUCHPAD_SWIPE ||
        type == CDK_TOUCHPAD_PINCH);
8065}

8067static gboolean
8068is_motion_type (CdkEventType type)
8069{
return type == CDK_MOTION_NOTIFY ||
       type == CDK_TOUCH_UPDATE ||
type == CDK_ENTER_NOTIFY ||
type == CDK_LEAVE_NOTIFY;
8074}

8076static gboolean
8077is_touch_type (CdkEventType type)
8078{
return type == CDK_TOUCH_BEGIN ||
       type == CDK_TOUCH_UPDATE ||
       type == CDK_TOUCH_END ||
       type == CDK_TOUCH_CANCEL;
8083}

8085static CdkWindow *
8086find_common_ancestor (CdkWindow *win1,
      CdkWindow *win2)
8088{
CdkWindow *tmp;
GList *path1 = NULL((void*)0), *path2 = NULL((void*)0);
GList *list1, *list2;

tmp = win1;
while (tmp != NULL((void*)0) && tmp->window_type != CDK_WINDOW_ROOT)
  {
    path1 = g_list_prepend (path1, tmp);
    tmp = get_event_parent (tmp);
  }

tmp = win2;
while (tmp != NULL((void*)0) && tmp->window_type != CDK_WINDOW_ROOT)
  {
    path2 = g_list_prepend (path2, tmp);
    tmp = get_event_parent (tmp);
  }

list1 = path1;
list2 = path2;
tmp = NULL((void*)0);
while (list1 && list2 && (list1->data == list2->data))
  {
    tmp = list1->data;
    list1 = list1->next;
    list2 = list2->next;
  }
g_list_free (path1);
g_list_free (path2);

return tmp;
8120}

8122CdkEvent *
8123_cdk_make_event (CdkWindow    *window,
 CdkEventType  type,
 CdkEvent     *event_in_queue,
 gboolean      before_event)
8127{
CdkEvent *event = cdk_event_new (type);
guint32 the_time;
CdkModifierType the_state;

the_time = cdk_event_get_time (event_in_queue);
cdk_event_get_state (event_in_queue, &the_state);

event->any.window = g_object_ref (window)((__typeof__ (window)) (g_object_ref) (window));
event->any.send_event = FALSE(0);
if (event_in_queue && event_in_queue->any.send_event)
  event->any.send_event = TRUE(!(0));

switch (type)
  {
  case CDK_MOTION_NOTIFY:
    event->motion.time = the_time;
    event->motion.axes = NULL((void*)0);
    event->motion.state = the_state;
    break;

  case CDK_BUTTON_PRESS:
  case CDK_2BUTTON_PRESS:
  case CDK_3BUTTON_PRESS:
  case CDK_BUTTON_RELEASE:
    event->button.time = the_time;
    event->button.axes = NULL((void*)0);
    event->button.state = the_state;
    break;

  case CDK_TOUCH_BEGIN:
  case CDK_TOUCH_UPDATE:
  case CDK_TOUCH_END:
  case CDK_TOUCH_CANCEL:
    event->touch.time = the_time;
    event->touch.axes = NULL((void*)0);
    event->touch.state = the_state;
    break;

  case CDK_SCROLL:
    event->scroll.time = the_time;
    event->scroll.state = the_state;
    break;

  case CDK_KEY_PRESS:
  case CDK_KEY_RELEASE:
    event->key.time = the_time;
    event->key.state = the_state;
    break;

  case CDK_ENTER_NOTIFY:
  case CDK_LEAVE_NOTIFY:
    event->crossing.time = the_time;
    event->crossing.state = the_state;
    break;

  case CDK_PROPERTY_NOTIFY:
    event->property.time = the_time;
    event->property.state = the_state;
    break;

  case CDK_SELECTION_CLEAR:
  case CDK_SELECTION_REQUEST:
  case CDK_SELECTION_NOTIFY:
    event->selection.time = the_time;
    break;

  case CDK_PROXIMITY_IN:
  case CDK_PROXIMITY_OUT:
    event->proximity.time = the_time;
    break;

  case CDK_DRAG_ENTER:
  case CDK_DRAG_LEAVE:
  case CDK_DRAG_MOTION:
  case CDK_DRAG_STATUS:
  case CDK_DROP_START:
  case CDK_DROP_FINISHED:
    event->dnd.time = the_time;
    break;

  case CDK_TOUCHPAD_SWIPE:
    event->touchpad_swipe.time = the_time;
    event->touchpad_swipe.state = the_state;
    break;

  case CDK_TOUCHPAD_PINCH:
    event->touchpad_pinch.time = the_time;
    event->touchpad_pinch.state = the_state;
    break;

  case CDK_FOCUS_CHANGE:
  case CDK_CONFIGURE:
  case CDK_MAP:
  case CDK_UNMAP:
  case CDK_CLIENT_EVENT:
  case CDK_VISIBILITY_NOTIFY:
  case CDK_DELETE:
  case CDK_DESTROY:
  case CDK_EXPOSE:
  default:
    break;
  }

if (event_in_queue)
  {
  if (before_event)
    _cdk_event_queue_insert_before (cdk_window_get_display (window), event_in_queue, event);
  else
    _cdk_event_queue_insert_after (cdk_window_get_display (window), event_in_queue, event);
  }
else
  _cdk_event_queue_append (cdk_window_get_display (window), event);

return event;
8242}

8244static void
8245send_crossing_event (CdkDisplay                 *display,
     CdkWindow                  *toplevel,
     CdkWindow                  *window,
     CdkEventType                type,
     CdkCrossingMode             mode,
     CdkNotifyType               notify_type,
     CdkWindow                  *subwindow,
                   CdkDevice                  *device,
                   CdkDevice                  *source_device,
     gdouble                     toplevel_x,
     gdouble                     toplevel_y,
     CdkModifierType             mask,
     guint32                     time_,
     CdkEvent                   *event_in_queue,
     gulong                      serial)
8260{
CdkEvent *event;
guint32 window_event_mask, type_event_mask;
CdkDeviceGrabInfo *grab;
CdkTouchGrabInfo *touch_grab = NULL((void*)0);
CdkPointerWindowInfo *pointer_info;
gboolean block_event = FALSE(0);
CdkEventSequence *sequence;

grab = _cdk_display_has_device_grab (display, device, serial);
pointer_info = _cdk_display_get_pointer_info (display, device);

sequence = cdk_event_get_event_sequence (event_in_queue);
if (sequence)
  touch_grab = _cdk_display_has_touch_grab (display, device, sequence, serial);

if (touch_grab)
  {
    if (window != touch_grab->window)
      return;

    window_event_mask = touch_grab->event_mask;
  }
else if (grab != NULL((void*)0) &&
         !grab->owner_events)
  {
    /* !owner_event => only report events wrt grab window, ignore rest */
    if ((CdkWindow *)window != grab->window)
return;
    window_event_mask = grab->event_mask;
  }
else
  window_event_mask = window->event_mask;

if (type == CDK_ENTER_NOTIFY &&
    (pointer_info->need_touch_press_enter ||
     (source_device &&
      cdk_device_get_source (source_device) == CDK_SOURCE_TOUCHSCREEN)) &&
    mode != CDK_CROSSING_TOUCH_BEGIN &&
    mode != CDK_CROSSING_TOUCH_END)
  {
    pointer_info->need_touch_press_enter = TRUE(!(0));
    block_event = TRUE(!(0));
  }
else if (type == CDK_LEAVE_NOTIFY)
  {
    type_event_mask = CDK_LEAVE_NOTIFY_MASK;
    window->devices_inside = g_list_remove (window->devices_inside, device);

    if (!window->support_multidevice && window->devices_inside)
      {
        /* Block leave events unless it's the last pointer */
        block_event = TRUE(!(0));
      }
  }
else
  {
    type_event_mask = CDK_ENTER_NOTIFY_MASK;

    if (!window->support_multidevice && window->devices_inside)
      {
        /* Only emit enter events for the first device */
        block_event = TRUE(!(0));
      }

    if (cdk_device_get_device_type (device) == CDK_DEVICE_TYPE_MASTER &&
        cdk_device_get_mode (device) != CDK_MODE_DISABLED &&
        !g_list_find (window->devices_inside, device))
      window->devices_inside = g_list_prepend (window->devices_inside, device);
  }

if (block_event)
  return;

if (window_event_mask & type_event_mask)
  {
    event = _cdk_make_event ((CdkWindow *)window, type, event_in_queue, TRUE(!(0)));
    cdk_event_set_device (event, device);
    cdk_event_set_seat (event, cdk_device_get_seat (device));

    if (source_device)
      cdk_event_set_source_device (event, source_device);

    event->crossing.time = time_;
    event->crossing.subwindow = subwindow;
    if (subwindow)
g_object_ref (subwindow)((__typeof__ (subwindow)) (g_object_ref) (subwindow));
    convert_toplevel_coords_to_window ((CdkWindow *)window,
			 toplevel_x, toplevel_y,
			 &event->crossing.x, &event->crossing.y);
    event->crossing.x_root = toplevel_x + toplevel->x;
    event->crossing.y_root = toplevel_y + toplevel->y;
    event->crossing.mode = mode;
    event->crossing.detail = notify_type;
    event->crossing.focus = FALSE(0);
    event->crossing.state = mask;
  }
8357}


8360/* The coordinates are in the toplevel window that src/dest are in.
* src and dest are always (if != NULL) in the same toplevel, as
* we get a leave-notify and set the window_under_pointer to null
* before crossing to another toplevel.
*/
8365void
8366_cdk_synthesize_crossing_events (CdkDisplay                 *display,
		 CdkWindow                  *src,
		 CdkWindow                  *dest,
                               CdkDevice                  *device,
                               CdkDevice                  *source_device,
		 CdkCrossingMode             mode,
		 double                      toplevel_x,
		 double                      toplevel_y,
		 CdkModifierType             mask,
		 guint32                     time_,
		 CdkEvent                   *event_in_queue,
		 gulong                      serial,
		 gboolean                    non_linear)
8379{
CdkWindow *c;
CdkWindow *win, *last, *next;
GList *path, *list;
CdkWindow *a;
CdkWindow *b;
CdkWindow *toplevel;
CdkNotifyType notify_type;

/* TODO: Don't send events to toplevel, as we get those from the windowing system */

a = (src && CDK_IS_WINDOW (src)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) (
(src)); GType __t = ((cdk_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; }))))) ? src : NULL((void*)0);
b = (dest && CDK_IS_WINDOW (dest)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) (
(dest)); GType __t = ((cdk_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; }))))) ? dest : NULL((void*)0);

if (src == dest)
  return; /* No crossings generated between src and dest */

if (cdk_device_get_device_type (device) != CDK_DEVICE_TYPE_MASTER)
  {
    if (a && cdk_window_get_device_events (src, device) == 0)
      a = NULL((void*)0);

    if (b && cdk_window_get_device_events (dest, device) == 0)
      b = NULL((void*)0);
  }

if (!a && !b)
  return;

c = find_common_ancestor (a, b);

non_linear |= (c != a) && (c != b);

if (a) /* There might not be a source (i.e. if no previous pointer_in_window) */
  {
    toplevel = cdk_window_get_toplevel (a);

    /* Traverse up from a to (excluding) c sending leave events */
    if (non_linear)
notify_type = CDK_NOTIFY_NONLINEAR;
    else if (c == a)
notify_type = CDK_NOTIFY_INFERIOR;
    else
notify_type = CDK_NOTIFY_ANCESTOR;
    send_crossing_event (display, toplevel,
	   a, CDK_LEAVE_NOTIFY,
	   mode,
	   notify_type,
	   NULL((void*)0), device, source_device,
	   toplevel_x, toplevel_y,
	   mask, time_,
	   event_in_queue,
	   serial);

    if (c != a)
{
 if (non_linear)
   notify_type = CDK_NOTIFY_NONLINEAR_VIRTUAL;
 else
   notify_type = CDK_NOTIFY_VIRTUAL;

 last = a;
 win = get_event_parent (a);
 while (win != c && win->window_type != CDK_WINDOW_ROOT)
   {
     send_crossing_event (display, toplevel,
		   win, CDK_LEAVE_NOTIFY,
		   mode,
		   notify_type,
		   (CdkWindow *)last,
		   device, source_device,
		   toplevel_x, toplevel_y,
		   mask, time_,
		   event_in_queue,
		   serial);

     last = win;
     win = get_event_parent (win);
   }
}
  }

if (b) /* Might not be a dest, e.g. if we're moving out of the window */
  {
    toplevel = cdk_window_get_toplevel ((CdkWindow *)b);

    /* Traverse down from c to b */
    if (c != b)
{
 path = NULL((void*)0);
 win = get_event_parent (b);
 while (win != c && win->window_type != CDK_WINDOW_ROOT)
   {
     path = g_list_prepend (path, win);
     win = get_event_parent (win);
   }

 if (non_linear)
   notify_type = CDK_NOTIFY_NONLINEAR_VIRTUAL;
 else
   notify_type = CDK_NOTIFY_VIRTUAL;

 list = path;
 while (list)
   {
     win = list->data;
     list = list->next;
     if (list)
next = list->data;
     else
next = b;

     send_crossing_event (display, toplevel,
		   win, CDK_ENTER_NOTIFY,
		   mode,
		   notify_type,
		   (CdkWindow *)next,
		   device, source_device,
		   toplevel_x, toplevel_y,
		   mask, time_,
		   event_in_queue,
		   serial);
   }
 g_list_free (path);
}


    if (non_linear)
notify_type = CDK_NOTIFY_NONLINEAR;
    else if (c == a)
notify_type = CDK_NOTIFY_ANCESTOR;
    else
notify_type = CDK_NOTIFY_INFERIOR;

    send_crossing_event (display, toplevel,
	   b, CDK_ENTER_NOTIFY,
	   mode,
	   notify_type,
	   NULL((void*)0),
                         device, source_device,
	   toplevel_x, toplevel_y,
	   mask, time_,
	   event_in_queue,
	   serial);
  }
8524}

8526/* Returns the window inside the event window with the pointer in it
* at the specified coordinates, or NULL if its not in any child of
* the toplevel. It also takes into account !owner_events grabs.
*/
8530static CdkWindow *
8531get_pointer_window (CdkDisplay *display,
    CdkWindow *event_window,
                  CdkDevice *device,
    gdouble toplevel_x,
    gdouble toplevel_y,
    gulong serial)
8537{
CdkWindow *pointer_window;
CdkDeviceGrabInfo *grab;
CdkPointerWindowInfo *pointer_info;

pointer_info = _cdk_display_get_pointer_info (display, device);

if (event_window == pointer_info->toplevel_under_pointer)
  pointer_window =
    _cdk_window_find_descendant_at (event_window,
		      toplevel_x, toplevel_y,
		      NULL((void*)0), NULL((void*)0));
else
  pointer_window = NULL((void*)0);

grab = _cdk_display_has_device_grab (display, device, serial);
if (grab != NULL((void*)0) &&
    !grab->owner_events &&
    pointer_window != grab->window &&
    !cdk_window_is_ancestor (pointer_window, grab->window))
  pointer_window = NULL((void*)0);

return pointer_window;
8560}

8562void
8563_cdk_display_set_window_under_pointer (CdkDisplay *display,
                                     CdkDevice  *device,
		       CdkWindow  *window)
8566{
CdkPointerWindowInfo *device_info;

device_info = _cdk_display_get_pointer_info (display, device);

if (device_info->window_under_pointer)
  g_object_unref (device_info->window_under_pointer);
device_info->window_under_pointer = window;

if (window)
  {
    g_object_ref (window)((__typeof__ (window)) (g_object_ref) (window));
    update_cursor (display, device);
  }

_cdk_display_enable_motion_hints (display, device);
8582}

8584/**
* cdk_pointer_grab:
* @window: the #CdkWindow which will own the grab (the grab window).
* @owner_events: if %FALSE then all pointer events are reported with respect to
*                @window and are only reported if selected by @event_mask. If %TRUE then pointer
*                events for this application are reported as normal, but pointer events outside
*                this application are reported with respect to @window and only if selected by
*                @event_mask. In either mode, unreported events are discarded.
* @event_mask: specifies the event mask, which is used in accordance with
*              @owner_events. Note that only pointer events (i.e. button and motion events)
*              may be selected.
* @confine_to: (allow-none): If non-%NULL, the pointer will be confined to this
*              window during the grab. If the pointer is outside @confine_to, it will
*              automatically be moved to the closest edge of @confine_to and enter
*              and leave events will be generated as necessary.
* @cursor: (allow-none): the cursor to display while the grab is active. If this is %NULL then
*          the normal cursors are used for @window and its descendants, and the cursor
*          for @window is used for all other windows.
* @time_: the timestamp of the event which led to this pointer grab. This usually
*         comes from a #CdkEventButton struct, though %CDK_CURRENT_TIME can be used if
*         the time isn’t known.
*
* Grabs the pointer (usually a mouse) so that all events are passed to this
* application until the pointer is ungrabbed with cdk_pointer_ungrab(), or
* the grab window becomes unviewable.
* This overrides any previous pointer grab by this client.
*
* Pointer grabs are used for operations which need complete control over mouse
* events, even if the mouse leaves the application.
* For example in CTK+ it is used for Drag and Drop, for dragging the handle in
* the #CtkHPaned and #CtkVPaned widgets.
*
* Note that if the event mask of an X window has selected both button press and
* button release events, then a button press event will cause an automatic
* pointer grab until the button is released.
* X does this automatically since most applications expect to receive button
* press and release events in pairs.
* It is equivalent to a pointer grab on the window with @owner_events set to
* %TRUE.
*
* If you set up anything at the time you take the grab that needs to be cleaned
* up when the grab ends, you should handle the #CdkEventGrabBroken events that
* are emitted when the grab ends unvoluntarily.
*
* Returns: %CDK_GRAB_SUCCESS if the grab was successful.
**/
8630CdkGrabStatus
8631cdk_pointer_grab (CdkWindow *	  window,
  gboolean	  owner_events,
  CdkEventMask	  event_mask,
  CdkWindow *	  confine_to,
  CdkCursor *	  cursor,
  guint32	  time)
8637{
CdkWindow *native;
CdkDisplay *display;
CdkDevice *device;
CdkGrabStatus res = 0;
gulong serial;
GList *seats, *s;

g_return_val_if_fail (window != NULL, CDK_GRAB_FAILED)do { if ((window != ((void*)0))) { } else { g_return_if_fail_warning
 ("Cdk", ((const char*) (__func__)), "window != NULL"); return
 (CDK_GRAB_FAILED); } } while (0);
g_return_val_if_fail (CDK_IS_WINDOW (window), CDK_GRAB_FAILED)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (CDK_GRAB_FAILED); } } while
 (0);
g_return_val_if_fail (confine_to == NULL || CDK_IS_WINDOW (confine_to), CDK_GRAB_FAILED)do { if ((confine_to == ((void*)0) || (((__extension__ ({ GTypeInstance
 *__inst = (GTypeInstance*) ((confine_to)); GType __t = ((cdk_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; })))))) { } else { g_return_if_fail_warning ("Cdk", ((const
 char*) (__func__)), "confine_to == NULL || CDK_IS_WINDOW (confine_to)"
); return (CDK_GRAB_FAILED); } } while (0);

/* We need a native window for confine to to work, ensure we have one */
if (confine_to)
  {
    if (!cdk_window_ensure_native (confine_to))
{
 g_warning ("Can't confine to grabbed window, not native");
 confine_to = NULL((void*)0);
}
  }

/* Non-viewable client side window => fail */
if (!_cdk_window_has_impl (window) &&
    !cdk_window_is_viewable (window))
  return CDK_GRAB_NOT_VIEWABLE;

native = cdk_window_get_toplevel (window);
while (cdk_window_is_offscreen (native))
  {
    native = cdk_offscreen_window_get_embedder (native);

    if (native == NULL((void*)0) ||
 (!_cdk_window_has_impl (native) &&
  !cdk_window_is_viewable (native)))
return CDK_GRAB_NOT_VIEWABLE;

    native = cdk_window_get_toplevel (native);
  }

display = cdk_window_get_display (window);

serial = _cdk_display_get_next_serial (display);
seats = cdk_display_list_seats (display);

for (s = seats; s; s = s->next)
  {
    device = cdk_seat_get_pointer (s->data);

    res = CDK_DEVICE_GET_CLASS (device)((((CdkDeviceClass*) (((GTypeInstance*) ((device)))->g_class
))))->grab (device,
                                               native,
                                               owner_events,
                                               get_native_grab_event_mask (event_mask),
                                               confine_to,
                                               cursor,
                                               time);

    if (res == CDK_GRAB_SUCCESS)
      _cdk_display_add_device_grab (display,
                                    device,
                                    window,
                                    native,
                                    CDK_OWNERSHIP_NONE,
                                    owner_events,
                                    event_mask,
                                    serial,
                                    time,
                                    FALSE(0));
  }

/* FIXME: handle errors when grabbing */

g_list_free (seats);

return res;
8712}

8714/**
* cdk_keyboard_grab:
* @window: the #CdkWindow which will own the grab (the grab window).
* @owner_events: if %FALSE then all keyboard events are reported with respect to
*   @window. If %TRUE then keyboard events for this application are
*   reported as normal, but keyboard events outside this application
*   are reported with respect to @window. Both key press and key
*   release events are always reported, independant of the event mask
*   set by the application.
* @time_: a timestamp from a #CdkEvent, or %CDK_CURRENT_TIME if no timestamp is
*   available.
*
* Grabs the keyboard so that all events are passed to this
* application until the keyboard is ungrabbed with cdk_keyboard_ungrab().
* This overrides any previous keyboard grab by this client.
*
* If you set up anything at the time you take the grab that needs to be cleaned
* up when the grab ends, you should handle the #CdkEventGrabBroken events that
* are emitted when the grab ends unvoluntarily.
*
* Returns: %CDK_GRAB_SUCCESS if the grab was successful.
**/
8736CdkGrabStatus
8737cdk_keyboard_grab (CdkWindow *window,
   gboolean   owner_events,
   guint32    time)
8740{
CdkWindow *native;
CdkDisplay *display;
CdkDevice *device;
CdkGrabStatus res = 0;
gulong serial;
GList *seats, *s;

g_return_val_if_fail (CDK_IS_WINDOW (window), CDK_GRAB_FAILED)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (CDK_GRAB_FAILED); } } while
 (0);

/* Non-viewable client side window => fail */
if (!_cdk_window_has_impl (window) &&
    !cdk_window_is_viewable (window))
  return CDK_GRAB_NOT_VIEWABLE;

native = cdk_window_get_toplevel (window);

while (cdk_window_is_offscreen (native))
  {
    native = cdk_offscreen_window_get_embedder (native);

    if (native == NULL((void*)0) ||
 (!_cdk_window_has_impl (native) &&
  !cdk_window_is_viewable (native)))
return CDK_GRAB_NOT_VIEWABLE;

    native = cdk_window_get_toplevel (native);
  }

display = cdk_window_get_display (window);
serial = _cdk_display_get_next_serial (display);
seats = cdk_display_list_seats (display);

for (s = seats; s; s = s->next)
  {
    device = cdk_seat_get_keyboard (s->data);

    res = CDK_DEVICE_GET_CLASS (device)((((CdkDeviceClass*) (((GTypeInstance*) ((device)))->g_class
))))->grab (device,
                                               native,
                                               owner_events,
                                               CDK_KEY_PRESS_MASK | CDK_KEY_RELEASE_MASK,
                                               NULL((void*)0),
                                               NULL((void*)0),
                                               time);

    if (res == CDK_GRAB_SUCCESS)
      _cdk_display_add_device_grab (display,
                                    device,
                                    window,
                                    native,
                                    CDK_OWNERSHIP_NONE,
                                    owner_events, 0,
                                    serial,
                                    time,
                                    FALSE(0));
  }

/* FIXME: handle errors when grabbing */

g_list_free (seats);

return res;
8802}

8804/**
* cdk_window_geometry_changed:
* @window: an embedded offscreen #CdkWindow
*
* This function informs CDK that the geometry of an embedded
* offscreen window has changed. This is necessary for CDK to keep
* track of which offscreen window the pointer is in.
*
* Since: 2.18
*/
8814void
8815cdk_window_geometry_changed (CdkWindow *window)
8816{
_cdk_synthesize_crossing_events_for_geometry_change (window);
8818}

8820static void
8821source_events_device_added (CdkDeviceManager *device_manager G_GNUC_UNUSED__attribute__ ((__unused__)),
                          CdkDevice        *device,
                          gpointer          user_data)
8824{
CdkWindow *window;
CdkEventMask event_mask;
CdkInputSource source;

if (cdk_device_get_device_type (device) != CDK_DEVICE_TYPE_FLOATING)
  return;

window = user_data;
source = cdk_device_get_source (device);

event_mask = GPOINTER_TO_INT (g_hash_table_lookup (window->source_event_masks,((gint) (glong) (g_hash_table_lookup (window->source_event_masks
, ((gpointer) (glong) (source)))))
                                                   GINT_TO_POINTER (source)))((gint) (glong) (g_hash_table_lookup (window->source_event_masks
, ((gpointer) (glong) (source)))));
if (event_mask)
  cdk_window_set_device_events (window, device, event_mask);
8839}

8841static void
8842source_events_device_changed (CdkDeviceManager *device_manager G_GNUC_UNUSED__attribute__ ((__unused__)),
                            CdkDevice        *device,
                            gpointer          user_data)
8845{
CdkDeviceType type;
CdkInputSource source;
CdkEventMask event_mask;
CdkWindow *window;

window = user_data;
type = cdk_device_get_device_type (device);
source = cdk_device_get_source (device);

event_mask = GPOINTER_TO_INT (g_hash_table_lookup (window->source_event_masks,((gint) (glong) (g_hash_table_lookup (window->source_event_masks
, ((gpointer) (glong) (source)))))
                                                   GINT_TO_POINTER (source)))((gint) (glong) (g_hash_table_lookup (window->source_event_masks
, ((gpointer) (glong) (source)))));

if (!event_mask)
  return;

if (type == CDK_DEVICE_TYPE_FLOATING)
  {
    /* The device was just floated, enable its event mask */
    cdk_window_set_device_events (window, device, event_mask);
  }
else if (type == CDK_DEVICE_TYPE_SLAVE)
  cdk_window_set_device_events (window, device, 0);
8868}

8870/**
* cdk_window_set_source_events:
* @window: a #CdkWindow
* @source: a #CdkInputSource to define the source class.
* @event_mask: event mask for @window
*
* Sets the event mask for any floating device (i.e. not attached to any
* visible pointer) that has the source defined as @source. This event
* mask will be applied both to currently existing, newly added devices
* after this call, and devices being attached/detached.
*
* Since: 3.0
**/
8883void
8884cdk_window_set_source_events (CdkWindow      *window,
                            CdkInputSource  source,
                            CdkEventMask    event_mask)
8887{
CdkDeviceManager *device_manager;
CdkDisplay *display;
GList *devices, *d;
guint size;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

G_GNUC_BEGIN_IGNORE_DEPRECATIONSclang diagnostic push
 clang diagnostic ignored "-Wdeprecated-declarations"

;
display = cdk_window_get_display (window);
device_manager = cdk_display_get_device_manager (display);

devices = cdk_device_manager_list_devices (device_manager, CDK_DEVICE_TYPE_FLOATING);

/* Set event mask for existing devices */
for (d = devices; d; d = d->next)
  {
    CdkDevice *device = d->data;

    if (source == cdk_device_get_source (device))
      cdk_window_set_device_events (window, device, event_mask);
  }

g_list_free (devices);
G_GNUC_END_IGNORE_DEPRECATIONSclang diagnostic pop
;

/* Update accounting */
if (G_UNLIKELY (!window->source_event_masks)(!window->source_event_masks))
  window->source_event_masks = g_hash_table_new (NULL((void*)0), NULL((void*)0));

if (event_mask)
  g_hash_table_insert (window->source_event_masks,
                       GUINT_TO_POINTER (source)((gpointer) (gulong) (source)),
                       GUINT_TO_POINTER (event_mask)((gpointer) (gulong) (event_mask)));
else
  g_hash_table_remove (window->source_event_masks,
                       GUINT_TO_POINTER (source)((gpointer) (gulong) (source)));

size = g_hash_table_size (window->source_event_masks);

/* Update handler if needed */
if (!window->device_added_handler_id && size > 0)
  {
    window->device_added_handler_id =
      g_signal_connect (device_manager, "device-added",g_signal_connect_data ((device_manager), ("device-added"), ((
(GCallback) (source_events_device_added))), (window), ((void*
)0), (GConnectFlags) 0)
                        G_CALLBACK (source_events_device_added), window)g_signal_connect_data ((device_manager), ("device-added"), ((
(GCallback) (source_events_device_added))), (window), ((void*
)0), (GConnectFlags) 0);
    window->device_changed_handler_id =
      g_signal_connect (device_manager, "device-changed",g_signal_connect_data ((device_manager), ("device-changed"), (
((GCallback) (source_events_device_changed))), (window), ((void
*)0), (GConnectFlags) 0)
                        G_CALLBACK (source_events_device_changed), window)g_signal_connect_data ((device_manager), ("device-changed"), (
((GCallback) (source_events_device_changed))), (window), ((void
*)0), (GConnectFlags) 0);
  }
else if (window->device_added_handler_id && size == 0)
  g_signal_handler_disconnect (device_manager, window->device_added_handler_id);
8939}

8941/**
* cdk_window_get_source_events:
* @window: a #CdkWindow
* @source: a #CdkInputSource to define the source class.
*
* Returns the event mask for @window corresponding to the device class specified
* by @source.
*
* Returns: source event mask for @window
**/
8951CdkEventMask
8952cdk_window_get_source_events (CdkWindow      *window,
                            CdkInputSource  source)
8954{
g_return_val_if_fail (CDK_IS_WINDOW (window), 0)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (0); } } while (0);

return GPOINTER_TO_UINT (g_hash_table_lookup (window->source_event_masks,((guint) (gulong) (g_hash_table_lookup (window->source_event_masks
, ((gpointer) (gulong) (source)))))
                                              GUINT_TO_POINTER (source)))((guint) (gulong) (g_hash_table_lookup (window->source_event_masks
, ((gpointer) (gulong) (source)))));
8959}

8961static gboolean
8962do_synthesize_crossing_event (gpointer data)
8963{
CdkDisplay *display;
CdkWindow *changed_toplevel;
GHashTableIter iter;
gpointer key, value;
gulong serial;

changed_toplevel = data;

changed_toplevel->synthesized_crossing_event_id = 0;

if (CDK_WINDOW_DESTROYED (changed_toplevel)(((CdkWindow *)(changed_toplevel))->destroyed))
  return FALSE(0);

display = cdk_window_get_display (changed_toplevel);
serial = _cdk_display_get_next_serial (display);
g_hash_table_iter_init (&iter, display->pointers_info);

while (g_hash_table_iter_next (&iter, &key, &value))
  {
    CdkWindow *new_window_under_pointer;
    CdkPointerWindowInfo *pointer_info = value;
    CdkDevice *device = key;

    if (changed_toplevel == pointer_info->toplevel_under_pointer)
      {
        new_window_under_pointer =
          get_pointer_window (display, changed_toplevel,
                              device,
                              pointer_info->toplevel_x,
                              pointer_info->toplevel_y,
                              serial);
        if (new_window_under_pointer != pointer_info->window_under_pointer)
          {
            CdkDevice *source_device;

            if (pointer_info->last_slave)
              source_device = pointer_info->last_slave;
            else
              source_device = device;

            _cdk_synthesize_crossing_events (display,
                                             pointer_info->window_under_pointer,
                                             new_window_under_pointer,
                                             device, source_device,
                                             CDK_CROSSING_NORMAL,
                                             pointer_info->toplevel_x,
                                             pointer_info->toplevel_y,
                                             pointer_info->state,
                                             CDK_CURRENT_TIME0L,
                                             NULL((void*)0),
                                             serial,
                                             FALSE(0));
            _cdk_display_set_window_under_pointer (display, device, new_window_under_pointer);
          }
      }
  }

return FALSE(0);
9022}

9024void
9025_cdk_synthesize_crossing_events_for_geometry_change (CdkWindow *changed_window)
9026{
CdkWindow *toplevel;

toplevel = get_event_toplevel (changed_window);

if (toplevel->synthesized_crossing_event_id == 0)
  {
    toplevel->synthesized_crossing_event_id =
      cdk_threads_add_idle_full (CDK_PRIORITY_EVENTS(0) - 1,
                                 do_synthesize_crossing_event,
                                 toplevel, NULL((void*)0));
    g_source_set_name_by_id (toplevel->synthesized_crossing_event_id,
                             "[ctk+] do_synthesize_crossing_event");
  }
9040}

9042/* Don't use for crossing events */
9043static CdkWindow *
9044get_event_window (CdkDisplay                 *display,
                CdkDevice                  *device,
                CdkEventSequence           *sequence,
                CdkWindow                  *pointer_window,
                CdkEventType                type,
                CdkModifierType             mask,
                guint                      *evmask_out,
                gboolean                    pointer_emulated,
                gulong                      serial)
9053{
guint evmask, emulated_mask = 0;
CdkWindow *grab_window;
CdkDeviceGrabInfo *grab;
CdkTouchGrabInfo *touch_grab;

touch_grab = _cdk_display_has_touch_grab (display, device, sequence, serial);
grab = _cdk_display_get_last_device_grab (display, device);

/* Default value. */
if (evmask_out)
  *evmask_out = 0;

if (is_touch_type (type) && pointer_emulated)
  {
    switch (type)
      {
      case CDK_TOUCH_BEGIN:
        emulated_mask |= CDK_BUTTON_PRESS_MASK;
        break;
      case CDK_TOUCH_UPDATE:
        emulated_mask |= CDK_POINTER_MOTION_MASK;
        break;
      case CDK_TOUCH_END:
        emulated_mask |= CDK_BUTTON_RELEASE_MASK;
      default:
        break;
      }
  }

if (touch_grab != NULL((void*)0) &&
    (!grab || grab->implicit || touch_grab->serial >= grab->serial_start))
  {
    evmask = touch_grab->event_mask;
    evmask = update_evmask_for_button_motion (evmask, mask);

    if (evmask & (type_masks[type] | emulated_mask))
      {
        if (evmask_out)
          *evmask_out = evmask;
        return touch_grab->window;
      }
    else
      return NULL((void*)0);
  }

if (grab != NULL((void*)0) && !grab->owner_events)
  {
    evmask = grab->event_mask;
    evmask = update_evmask_for_button_motion (evmask, mask);

    grab_window = grab->window;

    if (evmask & (type_masks[type] | emulated_mask))
{
 if (evmask_out)
   *evmask_out = evmask;
 return grab_window;
}
    else
return NULL((void*)0);
  }

while (pointer_window != NULL((void*)0))
  {
    evmask = pointer_window->event_mask;
    evmask = update_evmask_for_button_motion (evmask, mask);

    if (evmask & (type_masks[type] | emulated_mask))
{
 if (evmask_out)
   *evmask_out = evmask;
 return pointer_window;
}

    pointer_window = get_event_parent (pointer_window);
  }

if (grab != NULL((void*)0) &&
    grab->owner_events)
  {
    evmask = grab->event_mask;
    evmask = update_evmask_for_button_motion (evmask, mask);

    if (evmask & (type_masks[type] | emulated_mask))
{
 if (evmask_out)
   *evmask_out = evmask;
 return grab->window;
}
    else
return NULL((void*)0);
  }

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

9150static gboolean
9151proxy_pointer_event (CdkDisplay                 *display,
     CdkEvent                   *source_event,
     gulong                      serial)
9154{
CdkWindow *toplevel_window, *event_window;
CdkWindow *pointer_window;
CdkPointerWindowInfo *pointer_info;
CdkDevice *device, *source_device;
CdkEvent *event;
guint state;
gdouble toplevel_x, toplevel_y;
guint32 time_;
gboolean non_linear, need_synthetic_enter = FALSE(0);
gint event_type;

event_type = source_event->type;
event_window = source_event->any.window;
cdk_event_get_coords (source_event, &toplevel_x, &toplevel_y);
cdk_event_get_state (source_event, &state);
time_ = cdk_event_get_time (source_event);
device = cdk_event_get_device (source_event);
source_device = cdk_event_get_source_device (source_event);
pointer_info = _cdk_display_get_pointer_info (display, device);
toplevel_window = convert_native_coords_to_toplevel (event_window,
				       toplevel_x, toplevel_y,
				       &toplevel_x, &toplevel_y);

non_linear = FALSE(0);
if ((source_event->type == CDK_LEAVE_NOTIFY ||
     source_event->type == CDK_ENTER_NOTIFY) &&
    (source_event->crossing.detail == CDK_NOTIFY_NONLINEAR ||
     source_event->crossing.detail == CDK_NOTIFY_NONLINEAR_VIRTUAL))
  non_linear = TRUE(!(0));

if (pointer_info->need_touch_press_enter &&
    cdk_device_get_source (pointer_info->last_slave) != CDK_SOURCE_TOUCHSCREEN &&
    (source_event->type != CDK_TOUCH_UPDATE ||
     cdk_event_get_pointer_emulated (source_event)))
  {
    pointer_info->need_touch_press_enter = FALSE(0);
    need_synthetic_enter = TRUE(!(0));
  }

/* If we get crossing events with subwindow unexpectedly being NULL
   that means there is a native subwindow that cdk doesn't know about.
   We track these and forward them, with the correct virtual window
   events inbetween.
   This is important to get right, as metacity uses cdk for the frame
   windows, but cdk doesn't know about the client windows reparented
   into the frame. */
if (((source_event->type == CDK_LEAVE_NOTIFY &&
source_event->crossing.detail == CDK_NOTIFY_INFERIOR) ||
     (source_event->type == CDK_ENTER_NOTIFY &&
(source_event->crossing.detail == CDK_NOTIFY_VIRTUAL ||
source_event->crossing.detail == CDK_NOTIFY_NONLINEAR_VIRTUAL))) &&
    source_event->crossing.subwindow == NULL((void*)0))
  {
    /* Left for an unknown (to cdk) subwindow */

    /* Send leave events from window under pointer to event window
that will get the subwindow == NULL window */
    _cdk_synthesize_crossing_events (display,
		       pointer_info->window_under_pointer,
		       event_window,
                                     device, source_device,
		       source_event->crossing.mode,
		       toplevel_x, toplevel_y,
		       state, time_,
		       source_event,
		       serial,
		       non_linear);

    /* Send subwindow == NULL event */
    send_crossing_event (display,
	   toplevel_window,
	   event_window,
	   source_event->type,
	   source_event->crossing.mode,
	   source_event->crossing.detail,
	   NULL((void*)0),
                         device, source_device,
	   toplevel_x, toplevel_y,
	   state, time_,
	   source_event,
	   serial);

    _cdk_display_set_window_under_pointer (display, device, NULL((void*)0));
    return TRUE(!(0));
  }

pointer_window = get_pointer_window (display, toplevel_window, device,
		       toplevel_x, toplevel_y, serial);

if (((source_event->type == CDK_ENTER_NOTIFY &&
source_event->crossing.detail == CDK_NOTIFY_INFERIOR) ||
     (source_event->type == CDK_LEAVE_NOTIFY &&
(source_event->crossing.detail == CDK_NOTIFY_VIRTUAL ||
source_event->crossing.detail == CDK_NOTIFY_NONLINEAR_VIRTUAL))) &&
    source_event->crossing.subwindow == NULL((void*)0))
  {
    /* Entered from an unknown (to cdk) subwindow */

    /* Send subwindow == NULL event */
    send_crossing_event (display,
	   toplevel_window,
	   event_window,
	   source_event->type,
	   source_event->crossing.mode,
	   source_event->crossing.detail,
	   NULL((void*)0),
                         device, source_device,
	   toplevel_x, toplevel_y,
	   state, time_,
	   source_event,
	   serial);

    /* Send enter events from event window to pointer_window */
    _cdk_synthesize_crossing_events (display,
		       event_window,
		       pointer_window,
                                     device, source_device,
		       source_event->crossing.mode,
		       toplevel_x, toplevel_y,
		       state, time_,
		       source_event,
		       serial, non_linear);
    _cdk_display_set_window_under_pointer (display, device, pointer_window);
    return TRUE(!(0));
  }

if ((source_event->type != CDK_TOUCH_UPDATE ||
     cdk_event_get_pointer_emulated (source_event)) &&
    pointer_info->window_under_pointer != pointer_window)
  {
    /* Either a toplevel crossing notify that ended up inside a child window,
or a motion notify that got into another child window  */

    /* Different than last time, send crossing events */
    _cdk_synthesize_crossing_events (display,
		       pointer_info->window_under_pointer,
		       pointer_window,
                                     device, source_device,
		       CDK_CROSSING_NORMAL,
		       toplevel_x, toplevel_y,
		       state, time_,
		       source_event,
		       serial, non_linear);
    _cdk_display_set_window_under_pointer (display, device, pointer_window);
  }

if (source_event->type == CDK_MOTION_NOTIFY ||
    source_event->type == CDK_TOUCH_UPDATE)
  {
    CdkWindow *event_win;
    guint evmask;
    gboolean is_hint;
    CdkEventSequence *sequence;

    sequence = cdk_event_get_event_sequence (source_event);

    event_win = get_event_window (display,
                                  device,
                                  sequence,
                                  pointer_window,
                                  source_event->type,
                                  state,
                                  &evmask,
                                  cdk_event_get_pointer_emulated (source_event),
                                  serial);

    if (event_type == CDK_TOUCH_UPDATE)
      {
        if (cdk_event_get_pointer_emulated (source_event))
          {
            /* Touch events emulating pointer events are transformed back
             * to pointer events if:
             * 1 - The event window doesn't select for touch events
             * 2 - There's no touch grab for this sequence, which means
             *     it was started as a pointer sequence, but a device
             *     grab added touch events afterwards, the sequence must
             *     not mutate in this case.
             */
            if ((evmask & CDK_TOUCH_MASK) == 0 ||
                !_cdk_display_has_touch_grab (display, device, sequence, serial))
              event_type = CDK_MOTION_NOTIFY;
          }
        else if ((evmask & CDK_TOUCH_MASK) == 0)
          return TRUE(!(0));
      }

    if (is_touch_type (source_event->type) && !is_touch_type (event_type))
      state |= CDK_BUTTON1_MASK;

    if (event_win &&
        cdk_device_get_device_type (device) != CDK_DEVICE_TYPE_MASTER &&
        cdk_window_get_device_events (event_win, device) == 0)
      return TRUE(!(0));

    /* The last device to interact with the window was a touch device,
     * which synthesized a leave notify event, so synthesize another enter
     * notify to tell the pointer is on the window.
     */
    if (need_synthetic_enter)
      _cdk_synthesize_crossing_events (display,
                                       NULL((void*)0), pointer_window,
                                       device, source_device,
                                       CDK_CROSSING_DEVICE_SWITCH,
                                       toplevel_x, toplevel_y,
                                       state, time_, NULL((void*)0),
                                       serial, FALSE(0));

    is_hint = FALSE(0);

    if (event_win &&
        event_type == CDK_MOTION_NOTIFY &&
 (evmask & CDK_POINTER_MOTION_HINT_MASK))
{
        gulong *device_serial;

        device_serial = g_hash_table_lookup (display->motion_hint_info, device);

        if (!device_serial ||
            (*device_serial != 0 &&
             serial < *device_serial))
   event_win = NULL((void*)0); /* Ignore event */
 else
   {
     is_hint = TRUE(!(0));
            *device_serial = G_MAXULONG(9223372036854775807L *2UL+1UL);
   }
}

    if (!event_win)
      return TRUE(!(0));

    event = cdk_event_new (event_type);
    event->any.window = g_object_ref (event_win)((__typeof__ (event_win)) (g_object_ref) (event_win));
    event->any.send_event = source_event->any.send_event;

    cdk_event_set_device (event, cdk_event_get_device (source_event));
    cdk_event_set_source_device (event, source_device);
    cdk_event_set_seat (event, cdk_device_get_seat (device));
    cdk_event_set_device_tool (event, cdk_event_get_device_tool (source_event));

    if (event_type == CDK_TOUCH_UPDATE)
{
 event->touch.time = time_;
 event->touch.state = state | CDK_BUTTON1_MASK;
 event->touch.sequence = source_event->touch.sequence;
 event->touch.emulating_pointer = source_event->touch.emulating_pointer;
 convert_toplevel_coords_to_window (event_win,
			     toplevel_x, toplevel_y,
			     &event->touch.x, &event->touch.y);
 cdk_event_get_root_coords (source_event,
		     &event->touch.x_root,
		     &event->touch.y_root);

 event->touch.axes = g_memdup2 (source_event->touch.axes,
			 sizeof (gdouble) * cdk_device_get_n_axes (source_event->touch.device));
}
    else
{
 event->motion.time = time_;
 event->motion.state = state;
 event->motion.is_hint = is_hint;

 convert_toplevel_coords_to_window (event_win,
			     toplevel_x, toplevel_y,
			     &event->motion.x, &event->motion.y);
 cdk_event_get_root_coords (source_event,
		     &event->motion.x_root,
		     &event->motion.y_root);

 if (is_touch_type (source_event->type))
   event->motion.axes = g_memdup2 (source_event->touch.axes,
			    sizeof (gdouble) * cdk_device_get_n_axes (source_event->touch.device));
 else
   event->motion.axes = g_memdup2 (source_event->motion.axes,
			    sizeof (gdouble) * cdk_device_get_n_axes (source_event->motion.device));
}

    /* Just insert the event */
    _cdk_event_queue_insert_after (cdk_window_get_display (event_win),
		     source_event, event);
  }

/* unlink all move events from queue.
   We handle our own, including our emulated masks. */
return TRUE(!(0));
9440}

9442#define CDK_ANY_BUTTON_MASK(CDK_BUTTON1_MASK | CDK_BUTTON2_MASK | CDK_BUTTON3_MASK | CDK_BUTTON4_MASK
 | CDK_BUTTON5_MASK) (CDK_BUTTON1_MASK | \
	     CDK_BUTTON2_MASK | \
	     CDK_BUTTON3_MASK | \
	     CDK_BUTTON4_MASK | \
	     CDK_BUTTON5_MASK)

9448static gboolean
9449proxy_button_event (CdkEvent *source_event,
    gulong serial)
9451{
CdkWindow *toplevel_window, *event_window;
CdkWindow *event_win;
CdkWindow *pointer_window;
CdkWindow *parent;
CdkEvent *event;
CdkPointerWindowInfo *pointer_info;
CdkDeviceGrabInfo *pointer_grab;
guint state;
guint32 time_;
CdkEventType type;
gdouble toplevel_x, toplevel_y;
CdkDisplay *display;
CdkWindow *w;
CdkDevice *device, *source_device;
CdkEventMask evmask;
CdkEventSequence *sequence;

type = source_event->any.type;
event_window = source_event->any.window;
cdk_event_get_coords (source_event, &toplevel_x, &toplevel_y);
cdk_event_get_state (source_event, &state);
time_ = cdk_event_get_time (source_event);
device = cdk_event_get_device (source_event);
source_device = cdk_event_get_source_device (source_event);
display = cdk_window_get_display (source_event->any.window);
toplevel_window = convert_native_coords_to_toplevel (event_window,
				       toplevel_x, toplevel_y,
				       &toplevel_x, &toplevel_y);

sequence = cdk_event_get_event_sequence (source_event);

pointer_info = _cdk_display_get_pointer_info (display, device);
pointer_grab = _cdk_display_has_device_grab (display, device, serial);

if ((type == CDK_BUTTON_PRESS ||
     type == CDK_TOUCH_BEGIN) &&
    !source_event->any.send_event &&
    (!pointer_grab ||
     (type == CDK_TOUCH_BEGIN && pointer_grab->implicit &&
      !cdk_event_get_pointer_emulated (source_event))))
  {
    pointer_window =
_cdk_window_find_descendant_at (toplevel_window,
			toplevel_x, toplevel_y,
			NULL((void*)0), NULL((void*)0));

    /* Find the event window, that gets the grab */
    w = pointer_window;
    while (w != NULL((void*)0) &&
    (parent = get_event_parent (w)) != NULL((void*)0) &&
    parent->window_type != CDK_WINDOW_ROOT)
{
 if (w->event_mask & CDK_BUTTON_PRESS_MASK &&
            (type == CDK_BUTTON_PRESS ||
             cdk_event_get_pointer_emulated (source_event)))
   break;

        if (type == CDK_TOUCH_BEGIN &&
            w->event_mask & CDK_TOUCH_MASK)
          break;

 w = parent;
}
    pointer_window = w;

    if (pointer_window)
      {
        if (type == CDK_TOUCH_BEGIN &&
            pointer_window->event_mask & CDK_TOUCH_MASK)
          {
            _cdk_display_add_touch_grab (display, device, sequence,
                                         pointer_window, event_window,
                                         cdk_window_get_events (pointer_window),
                                         serial, time_);
          }
        else if (type == CDK_BUTTON_PRESS ||
                 cdk_event_get_pointer_emulated (source_event))
          {
            _cdk_display_add_device_grab  (display,
                                           device,
                                           pointer_window,
                                           event_window,
                                           CDK_OWNERSHIP_NONE,
                                           FALSE(0),
                                           cdk_window_get_events (pointer_window),
                                           serial,
                                           time_,
                                           TRUE(!(0)));
            _cdk_display_device_grab_update (display, device,
                                             source_device, serial);
          }
      }
  }

pointer_window = get_pointer_window (display, toplevel_window, device,
		       toplevel_x, toplevel_y,
		       serial);

event_win = get_event_window (display,
                              device,
                              sequence,
                              pointer_window,
                              type, state,
                              &evmask,
                              cdk_event_get_pointer_emulated (source_event),
                              serial);

if (type == CDK_TOUCH_BEGIN || type == CDK_TOUCH_END)
  {
    if (cdk_event_get_pointer_emulated (source_event))
      {
        if ((evmask & CDK_TOUCH_MASK) == 0 ||
            !_cdk_display_has_touch_grab (display, device, sequence, serial))
          {
            if (type == CDK_TOUCH_BEGIN)
              type = CDK_BUTTON_PRESS;
            else if (type == CDK_TOUCH_END)
              type = CDK_BUTTON_RELEASE;
          }
      }
    else if ((evmask & CDK_TOUCH_MASK) == 0)
      return TRUE(!(0));
  }

if (source_event->type == CDK_TOUCH_END && !is_touch_type (type))
  state |= CDK_BUTTON1_MASK;

if (event_win == NULL((void*)0))
  return TRUE(!(0));

if (cdk_device_get_device_type (device) != CDK_DEVICE_TYPE_MASTER &&
    cdk_window_get_device_events (event_win, device) == 0)
  return TRUE(!(0));

if ((type == CDK_BUTTON_PRESS ||
     (type == CDK_TOUCH_BEGIN &&
      cdk_event_get_pointer_emulated (source_event))) &&
    pointer_info->need_touch_press_enter)
  {
    CdkCrossingMode mode;

    /* The last device to interact with the window was a touch device,
     * which synthesized a leave notify event, so synthesize another enter
     * notify to tell the pointer is on the window.
     */
    if (cdk_device_get_source (source_device) == CDK_SOURCE_TOUCHSCREEN)
      mode = CDK_CROSSING_TOUCH_BEGIN;
    else
      mode = CDK_CROSSING_DEVICE_SWITCH;

    pointer_info->need_touch_press_enter = FALSE(0);
    _cdk_synthesize_crossing_events (display,
                                     NULL((void*)0),
                                     pointer_info->window_under_pointer,
                                     device, source_device, mode,
                                     toplevel_x, toplevel_y,
                                     state, time_, source_event,
                                     serial, FALSE(0));
  }
else if (type == CDK_SCROLL &&
         (((evmask & CDK_SMOOTH_SCROLL_MASK) == 0 &&
           source_event->scroll.direction == CDK_SCROLL_SMOOTH) ||
          ((evmask & CDK_SMOOTH_SCROLL_MASK) != 0 &&
           source_event->scroll.direction != CDK_SCROLL_SMOOTH &&
           cdk_event_get_pointer_emulated (source_event))))
  return FALSE(0);

event = _cdk_make_event (event_win, type, source_event, FALSE(0));

switch (type)
  {
  case CDK_BUTTON_PRESS:
  case CDK_BUTTON_RELEASE:
    event->button.button = source_event->button.button;
    convert_toplevel_coords_to_window (event_win,
			 toplevel_x, toplevel_y,
			 &event->button.x, &event->button.y);
    cdk_event_get_root_coords (source_event,
		 &event->button.x_root,
		 &event->button.y_root);
    cdk_event_set_device (event, cdk_event_get_device (source_event));
    cdk_event_set_source_device (event, source_device);
    cdk_event_set_seat (event, cdk_device_get_seat (device));
    cdk_event_set_device_tool (event, cdk_event_get_device_tool (source_event));

    if (is_touch_type (source_event->type))
      {
        if (type == CDK_BUTTON_RELEASE)
          event->button.state |= CDK_BUTTON1_MASK;
 event->button.button = 1;
 event->button.axes = g_memdup2 (source_event->touch.axes,
			  sizeof (gdouble) * cdk_device_get_n_axes (source_event->touch.device));
}
    else
{
 event->button.button = source_event->button.button;
 event->button.axes = g_memdup2 (source_event->button.axes,
			  sizeof (gdouble) * cdk_device_get_n_axes (source_event->button.device));
}

    if (type == CDK_BUTTON_PRESS)
      _cdk_event_button_generate (display, event);
    else if ((type == CDK_BUTTON_RELEASE ||
              (type == CDK_TOUCH_END &&
               cdk_event_get_pointer_emulated (source_event))) &&
             pointer_window == pointer_info->window_under_pointer &&
             cdk_device_get_source (source_device) == CDK_SOURCE_TOUCHSCREEN)
      {
        /* Synthesize a leave notify event
         * whenever a touch device is released
         */
        pointer_info->need_touch_press_enter = TRUE(!(0));
        _cdk_synthesize_crossing_events (display,
                                         pointer_window, NULL((void*)0),
                                         device, source_device,
                                         CDK_CROSSING_TOUCH_END,
                                         toplevel_x, toplevel_y,
                                         state, time_, NULL((void*)0),
                                         serial, FALSE(0));
      }
    return TRUE(!(0));

  case CDK_TOUCH_BEGIN:
  case CDK_TOUCH_END:
  case CDK_TOUCH_CANCEL:
    convert_toplevel_coords_to_window (event_win,
                                       toplevel_x, toplevel_y,
                                       &event->button.x, &event->button.y);
    cdk_event_get_root_coords (source_event,
		 &event->touch.x_root,
		 &event->touch.y_root);
    event->touch.state = state;
    event->touch.device = source_event->touch.device;
    event->touch.axes = g_memdup2 (source_event->touch.axes,
                                   sizeof (gdouble) * cdk_device_get_n_axes (source_event->touch.device));
    event->touch.sequence = source_event->touch.sequence;
    event->touch.emulating_pointer = source_event->touch.emulating_pointer;

    cdk_event_set_source_device (event, source_device);

    if (((type == CDK_TOUCH_END || type == CDK_TOUCH_CANCEL) &&
         cdk_event_get_pointer_emulated (source_event)) &&
         pointer_window == pointer_info->window_under_pointer &&
         cdk_device_get_source (source_device) == CDK_SOURCE_TOUCHSCREEN)
      {
        /* Synthesize a leave notify event
         * whenever a touch device is released
         */
        pointer_info->need_touch_press_enter = TRUE(!(0));
        _cdk_synthesize_crossing_events (display,
                                         pointer_window, NULL((void*)0),
                                         device, source_device,
                                         CDK_CROSSING_TOUCH_END,
                                         toplevel_x, toplevel_y,
                                         state, time_, NULL((void*)0),
                                         serial, FALSE(0));
      }
    return TRUE(!(0));

  case CDK_SCROLL:
    event->scroll.direction = source_event->scroll.direction;
    convert_toplevel_coords_to_window (event_win,
			 toplevel_x, toplevel_y,
			 &event->scroll.x, &event->scroll.y);
    event->scroll.x_root = source_event->scroll.x_root;
    event->scroll.y_root = source_event->scroll.y_root;
    event->scroll.state = state;
    event->scroll.device = source_event->scroll.device;
    event->scroll.delta_x = source_event->scroll.delta_x;
    event->scroll.delta_y = source_event->scroll.delta_y;
    event->scroll.is_stop = source_event->scroll.is_stop;
    cdk_event_set_source_device (event, source_device);
    return TRUE(!(0));

  default:
    return FALSE(0);
  }

return TRUE(!(0)); /* Always unlink original, we want to obey the emulated event mask */
9731}

9733static gboolean
9734proxy_gesture_event (CdkEvent *source_event,
                   gulong    serial)
9736{
CdkWindow *toplevel_window, *pointer_window, *event_win;
CdkDevice *device, *source_device;
gdouble toplevel_x, toplevel_y;
CdkDisplay *display;
CdkEventMask evmask;
CdkEventType evtype;
CdkEvent *event;
guint state;

evtype = source_event->any.type;
cdk_event_get_coords (source_event, &toplevel_x, &toplevel_y);
cdk_event_get_state (source_event, &state);
device = cdk_event_get_device (source_event);
source_device = cdk_event_get_source_device (source_event);
display = cdk_window_get_display (source_event->any.window);
toplevel_window = convert_native_coords_to_toplevel (source_event->any.window,
				       toplevel_x, toplevel_y,
				       &toplevel_x, &toplevel_y);

pointer_window = get_pointer_window (display, toplevel_window, device,
		       toplevel_x, toplevel_y,
		       serial);

event_win = get_event_window (display, device, NULL((void*)0),
                              pointer_window, evtype, state,
                              &evmask, FALSE(0), serial);
if (!event_win)
  return TRUE(!(0));

if ((evmask & CDK_TOUCHPAD_GESTURE_MASK) == 0)
  return TRUE(!(0));

event = _cdk_make_event (event_win, evtype, source_event, FALSE(0));
cdk_event_set_device (event, device);
cdk_event_set_source_device (event, source_device);
cdk_event_set_seat (event, cdk_device_get_seat (device));

switch (evtype)
  {
  case CDK_TOUCHPAD_SWIPE:
    convert_toplevel_coords_to_window (event_win,
                                       toplevel_x, toplevel_y,
                                       &event->touchpad_swipe.x,
                                       &event->touchpad_swipe.y);
    cdk_event_get_root_coords (source_event,
		 &event->touchpad_swipe.x_root,
		 &event->touchpad_swipe.y_root);
    event->touchpad_swipe.dx = source_event->touchpad_swipe.dx;
    event->touchpad_swipe.dy = source_event->touchpad_swipe.dy;
    event->touchpad_swipe.n_fingers = source_event->touchpad_swipe.n_fingers;
    event->touchpad_swipe.phase = source_event->touchpad_swipe.phase;
    break;

  case CDK_TOUCHPAD_PINCH:
    convert_toplevel_coords_to_window (event_win,
                                       toplevel_x, toplevel_y,
                                       &event->touchpad_pinch.x,
                                       &event->touchpad_pinch.y);
    cdk_event_get_root_coords (source_event,
		 &event->touchpad_pinch.x_root,
		 &event->touchpad_pinch.y_root);
    event->touchpad_pinch.dx = source_event->touchpad_pinch.dx;
    event->touchpad_pinch.dy = source_event->touchpad_pinch.dy;
    event->touchpad_pinch.scale = source_event->touchpad_pinch.scale;
    event->touchpad_pinch.angle_delta = source_event->touchpad_pinch.angle_delta;
    event->touchpad_pinch.n_fingers = source_event->touchpad_pinch.n_fingers;
    event->touchpad_pinch.phase = source_event->touchpad_pinch.phase;
    break;

  default:
    break;
  }

return TRUE(!(0));
9811}

9813#ifdef DEBUG_WINDOW_PRINTING

9815#ifdef CDK_WINDOWING_X11
9816#include "x11/cdkx.h"
9817#endif

9819static void
9820cdk_window_print (CdkWindow *window,
  int indent)
9822{
char *s;
const char *window_types[] = {
  "root",
  "toplevel",
  "child",
  "dialog",
  "temp",
  "foreign",
  "offscreen"
};

g_print ("%*s%p: [%s] %d,%d %dx%d", indent, "", window,
  window->user_data ? g_type_name_from_instance (window->user_data) : "no widget",
  window->x, window->y,
  window->width, window->height
  );

if (cdk_window_has_impl (window))
  {
9842#ifdef CDK_WINDOWING_X11
    g_print (" impl(0x%lx)", cdk_x11_window_get_xid (window));
9844#endif
  }

if (window->window_type != CDK_WINDOW_CHILD)
  g_print (" %s", window_types[window->window_type]);

if (window->input_only)
  g_print (" input-only");

if (window->shaped)
  g_print (" shaped");

if (!cdk_window_is_visible ((CdkWindow *)window))
  g_print (" hidden");

g_print (" abs[%d,%d]",
  window->abs_x, window->abs_y);

if (window->alpha != 255)
  g_print (" alpha[%d]",
  window->alpha);

s = print_region (window->clip_region);
g_print (" clipbox[%s]", s);

g_print ("\n");
9870}


9873static void
9874cdk_window_print_tree (CdkWindow *window,
       int indent,
       gboolean include_input_only)
9877{
GList *l;

if (window->input_only && !include_input_only)
  return;

cdk_window_print (window, indent);

for (l = window->children; l != NULL((void*)0); l = l->next)
  cdk_window_print_tree (l->data, indent + 4, include_input_only);
9887}

9889#endif /* DEBUG_WINDOW_PRINTING */

9891void
9892_cdk_windowing_got_event (CdkDisplay *display,
                        GList      *event_link,
                        CdkEvent   *event,
                        gulong      serial)
9896{
CdkWindow *event_window;
gdouble x, y;
gboolean unlink_event = FALSE(0);
CdkDeviceGrabInfo *button_release_grab;
CdkPointerWindowInfo *pointer_info = NULL((void*)0);
CdkDevice *device, *source_device;
gboolean is_toplevel;

_cdk_display_update_last_event (display, event);

device = cdk_event_get_device (event);
source_device = cdk_event_get_source_device (event);

if (device)
  {
    if (cdk_device_get_source (device) != CDK_SOURCE_KEYBOARD &&
        cdk_device_get_source (device) != CDK_SOURCE_TABLET_PAD)
      {
        pointer_info = _cdk_display_get_pointer_info (display, device);

        if (source_device != pointer_info->last_slave &&
            cdk_device_get_device_type (source_device) == CDK_DEVICE_TYPE_SLAVE)
          g_set_object (&pointer_info->last_slave, source_device)(__extension__ ({ _Static_assert (sizeof *(&pointer_info->
last_slave) == sizeof (source_device), "Expression evaluates to false"
); union { char *in; GObject **out; } _object_ptr; _object_ptr
.in = (char *) (&pointer_info->last_slave); (void) (0 ?
 *(&pointer_info->last_slave) = (source_device), (0) :
 (0)); (g_set_object) (_object_ptr.out, (GObject *) source_device
); }));
        else if (pointer_info->last_slave)
          source_device = pointer_info->last_slave;
      }

    _cdk_display_device_grab_update (display, device, source_device, serial);

    if (cdk_device_get_input_mode (device) == CDK_MODE_DISABLED ||
        !_cdk_display_check_grab_ownership (display, device, serial))
      {
        /* Device events are blocked by another
         * device grab, or the device is disabled
         */
        unlink_event = TRUE(!(0));
        goto out;
      }
  }

event_window = event->any.window;
if (!event_window)
  goto out;

9941#ifdef DEBUG_WINDOW_PRINTING
if (event->type == CDK_KEY_PRESS &&
    (event->key.keyval == 0xa7 ||
     event->key.keyval == 0xbd))
  {
    cdk_window_print_tree (event_window, 0, event->key.keyval == 0xbd);
  }
9948#endif

if (event->type == CDK_VISIBILITY_NOTIFY)
  {
    event_window->native_visibility = event->visibility.state;
    cdk_window_update_visibility_recursively (event_window, event_window);
    goto out;
  }

if (!(event->type == CDK_TOUCH_CANCEL ||
      is_button_type (event->type) ||
      is_motion_type (event->type) ||
      is_gesture_type (event->type)) ||
    event_window->window_type == CDK_WINDOW_ROOT)
  goto out;

is_toplevel = cdk_window_is_toplevel (event_window);

if ((event->type == CDK_ENTER_NOTIFY ||
     event->type == CDK_LEAVE_NOTIFY) &&
    (event->crossing.mode == CDK_CROSSING_GRAB ||
     event->crossing.mode == CDK_CROSSING_UNGRAB) &&
    (_cdk_display_has_device_grab (display, device, serial) ||
     event->crossing.detail == CDK_NOTIFY_INFERIOR))
  {
    /* We synthesize all crossing events due to grabs ourselves,
     * so we ignore the native ones caused by our native pointer_grab
     * calls. Otherwise we would proxy these crossing event and cause
     * multiple copies of crossing events for grabs.
     *
     * We do want to handle grabs from other clients though, as for
     * instance alt-tab in metacity causes grabs like these and
     * we want to handle those. Thus the has_pointer_grab check.
     *
     * Implicit grabs on child windows create some grabbing events
     * that are sent before the button press. This means we can't
     * detect these with the has_pointer_grab check (as the implicit
     * grab is only noticed when we get button press event), so we
     * detect these events by checking for INFERIOR enter or leave
     * events. These should never be a problem to filter out.
     */

    /* We ended up in this window after some (perhaps other clients)
     * grab, so update the toplevel_under_window state
     */
    if (pointer_info && is_toplevel &&
        event->type == CDK_ENTER_NOTIFY &&
        event->crossing.mode == CDK_CROSSING_UNGRAB)
      {
        if (pointer_info->toplevel_under_pointer)
          g_object_unref (pointer_info->toplevel_under_pointer);
        pointer_info->toplevel_under_pointer = g_object_ref (event_window)((__typeof__ (event_window)) (g_object_ref) (event_window));
      }

    unlink_event = TRUE(!(0));
    goto out;
  }

/* Track toplevel_under_pointer */
if (pointer_info && is_toplevel)
  {
    if (event->type == CDK_ENTER_NOTIFY &&
        event->crossing.detail != CDK_NOTIFY_INFERIOR)
      {
        if (pointer_info->toplevel_under_pointer)
          g_object_unref (pointer_info->toplevel_under_pointer);
        pointer_info->toplevel_under_pointer = g_object_ref (event_window)((__typeof__ (event_window)) (g_object_ref) (event_window));
      }
    else if (event->type == CDK_LEAVE_NOTIFY &&
             event->crossing.detail != CDK_NOTIFY_INFERIOR &&
             pointer_info->toplevel_under_pointer == event_window)
      {
        if (pointer_info->toplevel_under_pointer)
          g_object_unref (pointer_info->toplevel_under_pointer);
        pointer_info->toplevel_under_pointer = NULL((void*)0);
      }
  }

if (pointer_info &&
    (!is_touch_type (event->type) ||
     cdk_event_get_pointer_emulated (event)))
  {
    guint old_state, old_button;

    /* Store last pointer window and position/state */
    old_state = pointer_info->state;
    old_button = pointer_info->button;

    cdk_event_get_coords (event, &x, &y);
    convert_native_coords_to_toplevel (event_window, x, y,  &x, &y);
    pointer_info->toplevel_x = x;
    pointer_info->toplevel_y = y;
    cdk_event_get_state (event, &pointer_info->state);

    if (event->type == CDK_BUTTON_PRESS ||
        event->type == CDK_BUTTON_RELEASE)
      pointer_info->button = event->button.button;
    else if (event->type == CDK_TOUCH_BEGIN ||
             event->type == CDK_TOUCH_END)
      pointer_info->button = 1;

    if (device &&
        (pointer_info->state != old_state ||
         pointer_info->button != old_button))
      _cdk_display_enable_motion_hints (display, device);
  }

if (is_motion_type (event->type))
  unlink_event = proxy_pointer_event (display, event, serial);
else if (is_button_type (event->type))
  unlink_event = proxy_button_event (event, serial);
else if (is_gesture_type (event->type))
  unlink_event = proxy_gesture_event (event, serial);

if ((event->type == CDK_BUTTON_RELEASE ||
     event->type == CDK_TOUCH_CANCEL ||
     event->type == CDK_TOUCH_END) &&
    !event->any.send_event)
  {
    CdkEventSequence *sequence;

    sequence = cdk_event_get_event_sequence (event);
    if (sequence)
      {
        _cdk_display_end_touch_grab (display, device, sequence);
      }

    if (event->type == CDK_BUTTON_RELEASE ||
        cdk_event_get_pointer_emulated (event))
      {
        button_release_grab =
          _cdk_display_has_device_grab (display, device, serial);

        if (button_release_grab &&
            button_release_grab->implicit &&
            (event->button.state & CDK_ANY_BUTTON_MASK(CDK_BUTTON1_MASK | CDK_BUTTON2_MASK | CDK_BUTTON3_MASK | CDK_BUTTON4_MASK
 | CDK_BUTTON5_MASK) & ~(CDK_BUTTON1_MASK << (event->button.button - 1))) == 0)
          {
            button_release_grab->serial_end = serial;
            button_release_grab->implicit_ungrab = FALSE(0);
            _cdk_display_device_grab_update (display, device, source_device, serial);
          }
      }
  }

out:
if (unlink_event)
  {
    _cdk_event_queue_remove_link (display, event_link);
    g_list_free_1 (event_link);
    cdk_event_free (event);
  }

/* This does two things - first it sees if there are motions at the
 * end of the queue that can be compressed. Second, if there is just
 * a single motion that won't be dispatched because it is a compression
 * candidate it queues up flushing the event queue.
 */
_cdk_event_queue_handle_motion_compression (display);
10106}

10108/**
* cdk_window_create_similar_surface:
* @window: window to make new surface similar to
* @content: the content for the new surface
* @width: width of the new surface
* @height: height of the new surface
*
* Create a new surface that is as compatible as possible with the
* given @window. For example the new surface will have the same
* fallback resolution and font options as @window. Generally, the new
* surface will also use the same backend as @window, unless that is
* not possible for some reason. The type of the returned surface may
* be examined with cairo_surface_get_type().
*
* Initially the surface contents are all 0 (transparent if contents
* have transparency, black otherwise.)
*
* Returns: a pointer to the newly allocated surface. The caller
* owns the surface and should call cairo_surface_destroy() when done
* with it.
*
* This function always returns a valid pointer, but it will return a
* pointer to a “nil” surface if @other is already in an error state
* or any other error occurs.
*
* Since: 2.22
**/
10135cairo_surface_t *
10136cdk_window_create_similar_surface (CdkWindow *     window,
                                 cairo_content_t content,
                                 int             width,
                                 int             height)
10140{
CdkDisplay *display;
CdkRenderingMode rendering_mode;
cairo_surface_t *window_surface, *surface;
double sx, sy;

g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

window_surface = cdk_window_ref_impl_surface (window);
sx = sy = 1;
cairo_surface_get_device_scale (window_surface, &sx, &sy);

display = cdk_window_get_display (window);
rendering_mode = cdk_display_get_rendering_mode (display);

switch (rendering_mode)
{
  case CDK_RENDERING_MODE_RECORDING:
    {
      cairo_rectangle_t rect = { 0, 0, width * sx, height *sy };
      surface = cairo_recording_surface_create (content, &rect);
      cairo_surface_set_device_scale (surface, sx, sy);
    }
    break;
  case CDK_RENDERING_MODE_IMAGE:
    surface = cairo_image_surface_create (content == CAIRO_CONTENT_COLOR ? CAIRO_FORMAT_RGB24 :
                                          content == CAIRO_CONTENT_ALPHA ? CAIRO_FORMAT_A8 : CAIRO_FORMAT_ARGB32,
                                          width * sx, height * sy);
    cairo_surface_set_device_scale (surface, sx, sy);
    break;
  case CDK_RENDERING_MODE_SIMILAR:
  default:
    surface = cairo_surface_create_similar (window_surface,
                                            content,
                                            width, height);
    break;
}

cairo_surface_destroy (window_surface);

return surface;
10181}


10184/**
* cdk_window_create_similar_image_surface:
* @window: (nullable): window to make new surface similar to, or
*   %NULL if none
* @format: (type int): the format for the new surface
* @width: width of the new surface
* @height: height of the new surface
* @scale: the scale of the new surface, or 0 to use same as @window
*
* Create a new image surface that is efficient to draw on the
* given @window.
*
* Initially the surface contents are all 0 (transparent if contents
* have transparency, black otherwise.)
*
* The @width and @height of the new surface are not affected by
* the scaling factor of the @window, or by the @scale argument; they
* are the size of the surface in device pixels. If you wish to create
* an image surface capable of holding the contents of @window you can
* use:
*
* |[<!-- language="C" -->
*   int scale = cdk_window_get_scale_factor (window);
*   int width = cdk_window_get_width (window) * scale;
*   int height = cdk_window_get_height (window) * scale;
*
*   // format is set elsewhere
*   cairo_surface_t *surface =
*     cdk_window_create_similar_image_surface (window,
*                                              format,
*                                              width, height,
*                                              scale);
* ]|
*
* Note that unlike cairo_surface_create_similar_image(), the new
* surface's device scale is set to @scale, or to the scale factor of
* @window if @scale is 0.
*
* Returns: a pointer to the newly allocated surface. The caller
* owns the surface and should call cairo_surface_destroy() when done
* with it.
*
* This function always returns a valid pointer, but it will return a
* pointer to a “nil” surface if @other is already in an error state
* or any other error occurs.
*
* Since: 3.10
**/
10232cairo_surface_t *
10233cdk_window_create_similar_image_surface (CdkWindow *     window,
			 cairo_format_t  format,
			 int             width,
			 int             height,
			 int             scale)
10238{
CdkWindowImplClass *impl_class;
cairo_surface_t *window_surface, *surface;
CdkDisplay *display;
CdkScreen *screen;

g_return_val_if_fail (window ==NULL || CDK_IS_WINDOW (window), NULL)do { if ((window ==((void*)0) || (((__extension__ ({ GTypeInstance
 *__inst = (GTypeInstance*) ((window)); GType __t = ((cdk_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; })))))) { } else { g_return_if_fail_warning ("Cdk", ((const
 char*) (__func__)), "window ==NULL || CDK_IS_WINDOW (window)"
); return (((void*)0)); } } while (0);

if (window == NULL((void*)0))
  {
    display = cdk_display_get_default ();
    screen = cdk_display_get_default_screen (display);
    window = cdk_screen_get_root_window (screen);
  }

impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));

if (impl_class->create_similar_image_surface)
  surface = impl_class->create_similar_image_surface (window, format, width, height);
else
  {
    window_surface = cdk_window_ref_impl_surface (window);
    surface =
      cairo_surface_create_similar_image (window_surface,
                                          format,
                                          width,
                                          height);
    cairo_surface_destroy (window_surface);
  }

if (scale == 0)
  scale = cdk_window_get_scale_factor (window);

cairo_surface_set_device_scale (surface, scale, scale);

return surface;
10274}


10277/**
* cdk_window_focus:
* @window: a #CdkWindow
* @timestamp: timestamp of the event triggering the window focus
*
* Sets keyboard focus to @window. In most cases, ctk_window_present_with_time()
* should be used on a #CtkWindow, rather than calling this function.
*
**/
10286void
10287cdk_window_focus (CdkWindow *window,
                guint32    timestamp)
10289{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->focus (window, timestamp);
10291}

10293/**
* cdk_window_set_type_hint:
* @window: A toplevel #CdkWindow
* @hint: A hint of the function this window will have
*
* The application can use this call to provide a hint to the window
* manager about the functionality of a window. The window manager
* can use this information when determining the decoration and behaviour
* of the window.
*
* The hint must be set before the window is mapped.
**/
10305void
10306cdk_window_set_type_hint (CdkWindow        *window,
	  CdkWindowTypeHint hint)
10308{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_type_hint (window, hint);
10310}

10312/**
* cdk_window_get_type_hint:
* @window: A toplevel #CdkWindow
*
* This function returns the type hint set for a window.
*
* Returns: The type hint set for @window
*
* Since: 2.10
**/
10322CdkWindowTypeHint
10323cdk_window_get_type_hint (CdkWindow *window)
10324{
return CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->get_type_hint (window);
10326}

10328/**
* cdk_window_set_modal_hint:
* @window: A toplevel #CdkWindow
* @modal: %TRUE if the window is modal, %FALSE otherwise.
*
* The application can use this hint to tell the window manager
* that a certain window has modal behaviour. The window manager
* can use this information to handle modal windows in a special
* way.
*
* You should only use this on windows for which you have
* previously called cdk_window_set_transient_for()
**/
10341void
10342cdk_window_set_modal_hint (CdkWindow *window,
	   gboolean   modal)
10344{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_modal_hint (window, modal);
10346}

10348/**
* cdk_window_set_skip_taskbar_hint:
* @window: a toplevel #CdkWindow
* @skips_taskbar: %TRUE to skip the taskbar
*
* Toggles whether a window should appear in a task list or window
* list. If a window’s semantic type as specified with
* cdk_window_set_type_hint() already fully describes the window, this
* function should not be called in addition,
* instead you should allow the window to be treated according to
* standard policy for its semantic type.
*
* Since: 2.2
**/
10362void
10363cdk_window_set_skip_taskbar_hint (CdkWindow *window,
                                gboolean   skips_taskbar)
10365{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_skip_taskbar_hint (window, skips_taskbar);
10367}

10369/**
* cdk_window_set_skip_pager_hint:
* @window: a toplevel #CdkWindow
* @skips_pager: %TRUE to skip the pager
*
* Toggles whether a window should appear in a pager (workspace
* switcher, or other desktop utility program that displays a small
* thumbnail representation of the windows on the desktop). If a
* window’s semantic type as specified with cdk_window_set_type_hint()
* already fully describes the window, this function should
* not be called in addition, instead you should
* allow the window to be treated according to standard policy for
* its semantic type.
*
* Since: 2.2
**/
10385void
10386cdk_window_set_skip_pager_hint (CdkWindow *window,
                              gboolean   skips_pager)
10388{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_skip_pager_hint (window, skips_pager);
10390}

10392/**
* cdk_window_set_urgency_hint:
* @window: a toplevel #CdkWindow
* @urgent: %TRUE if the window is urgent
*
* Toggles whether a window needs the user's
* urgent attention.
*
* Since: 2.8
**/
10402void
10403cdk_window_set_urgency_hint (CdkWindow *window,
	     gboolean   urgent)
10405{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_urgency_hint (window, urgent);
10407}

10409/**
* cdk_window_set_geometry_hints:
* @window: a toplevel #CdkWindow
* @geometry: geometry hints
* @geom_mask: bitmask indicating fields of @geometry to pay attention to
*
* Sets the geometry hints for @window. Hints flagged in @geom_mask
* are set, hints not flagged in @geom_mask are unset.
* To unset all hints, use a @geom_mask of 0 and a @geometry of %NULL.
*
* This function provides hints to the windowing system about
* acceptable sizes for a toplevel window. The purpose of
* this is to constrain user resizing, but the windowing system
* will typically  (but is not required to) also constrain the
* current size of the window to the provided values and
* constrain programatic resizing via cdk_window_resize() or
* cdk_window_move_resize().
*
* Note that on X11, this effect has no effect on windows
* of type %CDK_WINDOW_TEMP or windows where override redirect
* has been turned on via cdk_window_set_override_redirect()
* since these windows are not resizable by the user.
*
* Since you can’t count on the windowing system doing the
* constraints for programmatic resizes, you should generally
* call cdk_window_constrain_size() yourself to determine
* appropriate sizes.
*
**/
10438void
10439cdk_window_set_geometry_hints (CdkWindow         *window,
	       const CdkGeometry *geometry,
	       CdkWindowHints     geom_mask)
10442{
g_return_if_fail (geometry != NULL || geom_mask == 0)do { if ((geometry != ((void*)0) || geom_mask == 0)) { } else
 { g_return_if_fail_warning ("Cdk", ((const char*) (__func__)
), "geometry != NULL || geom_mask == 0"); return; } } while (
0);

CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_geometry_hints (window, geometry, geom_mask);
10446}

10448/**
* cdk_window_set_title:
* @window: a toplevel #CdkWindow
* @title: title of @window
*
* Sets the title of a toplevel window, to be displayed in the titlebar.
* If you haven’t explicitly set the icon name for the window
* (using cdk_window_set_icon_name()), the icon name will be set to
* @title as well. @title must be in UTF-8 encoding (as with all
* user-readable strings in CDK/CTK+). @title may not be %NULL.
**/
10459void
10460cdk_window_set_title (CdkWindow   *window,
      const gchar *title)
10462{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_title (window, title);
10464}

10466/**
* cdk_window_set_role:
* @window: a toplevel #CdkWindow
* @role: a string indicating its role
*
* When using CTK+, typically you should use ctk_window_set_role() instead
* of this low-level function.
*
* The window manager and session manager use a window’s role to
* distinguish it from other kinds of window in the same application.
* When an application is restarted after being saved in a previous
* session, all windows with the same title and role are treated as
* interchangeable.  So if you have two windows with the same title
* that should be distinguished for session management purposes, you
* should set the role on those windows. It doesn’t matter what string
* you use for the role, as long as you have a different role for each
* non-interchangeable kind of window.
*
**/
10485void
10486cdk_window_set_role (CdkWindow   *window,
     const gchar *role)
10488{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_role (window, role);
10490}

10492/**
* cdk_window_set_startup_id:
* @window: a toplevel #CdkWindow
* @startup_id: a string with startup-notification identifier
*
* When using CTK+, typically you should use ctk_window_set_startup_id()
* instead of this low-level function.
*
* Since: 2.12
*
**/
10503void
10504cdk_window_set_startup_id (CdkWindow   *window,
	   const gchar *startup_id)
10506{
CdkWindowImplClass *klass = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));

if (klass->set_startup_id)
  klass->set_startup_id (window, startup_id);
10511}

10513/**
* cdk_window_set_transient_for:
* @window: a toplevel #CdkWindow
* @parent: another toplevel #CdkWindow
*
* Indicates to the window manager that @window is a transient dialog
* associated with the application window @parent. This allows the
* window manager to do things like center @window on @parent and
* keep @window above @parent.
*
* See ctk_window_set_transient_for() if you’re using #CtkWindow or
* #CtkDialog.
**/
10526void
10527cdk_window_set_transient_for (CdkWindow *window,
	      CdkWindow *parent)
10529{
window->transient_for = parent;

CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_transient_for (window, parent);
10533}

10535/**
* cdk_window_get_root_origin:
* @window: a toplevel #CdkWindow
* @x: (out): return location for X position of window frame
* @y: (out): return location for Y position of window frame
*
* Obtains the top-left corner of the window manager frame in root
* window coordinates.
*
**/
10545void
10546cdk_window_get_root_origin (CdkWindow *window,
	    gint      *x,
	    gint      *y)
10549{
CdkRectangle rect;

cdk_window_get_frame_extents (window, &rect);

if (x)
  *x = rect.x;

if (y)
  *y = rect.y;
10559}

10561/**
* cdk_window_get_frame_extents:
* @window: a toplevel #CdkWindow
* @rect: (out): rectangle to fill with bounding box of the window frame
*
* Obtains the bounding box of the window, including window manager
* titlebar/borders if any. The frame position is given in root window
* coordinates. To get the position of the window itself (rather than
* the frame) in root window coordinates, use cdk_window_get_origin().
*
**/
10572void
10573cdk_window_get_frame_extents (CdkWindow    *window,
                            CdkRectangle *rect)
10575{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->get_frame_extents (window, rect);
10577}

10579/**
* cdk_window_set_override_redirect:
* @window: a toplevel #CdkWindow
* @override_redirect: %TRUE if window should be override redirect
*
* An override redirect window is not under the control of the window manager.
* This means it won’t have a titlebar, won’t be minimizable, etc. - it will
* be entirely under the control of the application. The window manager
* can’t see the override redirect window at all.
*
* Override redirect should only be used for short-lived temporary
* windows, such as popup menus. #CtkMenu uses an override redirect
* window in its implementation, for example.
*
**/
10594void
10595cdk_window_set_override_redirect (CdkWindow *window,
		  gboolean override_redirect)
10597{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_override_redirect (window, override_redirect);
10599}

10601/**
* cdk_window_set_accept_focus:
* @window: a toplevel #CdkWindow
* @accept_focus: %TRUE if the window should receive input focus
*
* Setting @accept_focus to %FALSE hints the desktop environment that the
* window doesn’t want to receive input focus.
*
* On X, it is the responsibility of the window manager to interpret this
* hint. ICCCM-compliant window manager usually respect it.
*
* Since: 2.4
**/
10614void
10615cdk_window_set_accept_focus (CdkWindow *window,
	     gboolean accept_focus)
10617{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_accept_focus (window, accept_focus);
10619}

10621/**
* cdk_window_set_focus_on_map:
* @window: a toplevel #CdkWindow
* @focus_on_map: %TRUE if the window should receive input focus when mapped
*
* Setting @focus_on_map to %FALSE hints the desktop environment that the
* window doesn’t want to receive input focus when it is mapped.
* focus_on_map should be turned off for windows that aren’t triggered
* interactively (such as popups from network activity).
*
* On X, it is the responsibility of the window manager to interpret
* this hint. Window managers following the freedesktop.org window
* manager extension specification should respect it.
*
* Since: 2.6
**/
10637void
10638cdk_window_set_focus_on_map (CdkWindow *window,
	     gboolean focus_on_map)
10640{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_focus_on_map (window, focus_on_map);
10642}

10644/**
* cdk_window_set_event_compression:
* @window: a #CdkWindow
* @event_compression: %TRUE if motion events should be compressed
*
* Determines whether or not extra unprocessed motion events in
* the event queue can be discarded. If %TRUE only the most recent
* event will be delivered.
*
* Some types of applications, e.g. paint programs, need to see all
* motion events and will benefit from turning off event compression.
*
* By default, event compression is enabled.
*
* Since: 3.12
**/
10660void
10661cdk_window_set_event_compression (CdkWindow *window,
                                gboolean   event_compression)
10663{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

window->event_compression = !!event_compression;
10667}

10669/**
* cdk_window_get_event_compression:
* @window: a #CdkWindow
*
* Get the current event compression setting for this window.
*
* Returns: %TRUE if motion events will be compressed
*
* Since: 3.12
**/
10679gboolean
10680cdk_window_get_event_compression (CdkWindow *window)
10681{
g_return_val_if_fail (CDK_IS_WINDOW (window), TRUE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return ((!(0))); } } while (0);

return window->event_compression;
10685}

10687/**
* cdk_window_set_icon_list:
* @window: The #CdkWindow toplevel window to set the icon of.
* @pixbufs: (transfer none) (element-type GdkPixbuf):
*     A list of pixbufs, of different sizes.
*
* Sets a list of icons for the window. One of these will be used
* to represent the window when it has been iconified. The icon is
* usually shown in an icon box or some sort of task bar. Which icon
* size is shown depends on the window manager. The window manager
* can scale the icon  but setting several size icons can give better
* image quality since the window manager may only need to scale the
* icon by a small amount or not at all.
*
* Note that some platforms don't support window icons.
*/
10703void
10704cdk_window_set_icon_list (CdkWindow *window,
	  GList     *pixbufs)
10706{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_icon_list (window, pixbufs);
10708}

10710/**
* cdk_window_set_icon_name:
* @window: a toplevel #CdkWindow
* @name: (allow-none): name of window while iconified (minimized)
*
* Windows may have a name used while minimized, distinct from the
* name they display in their titlebar. Most of the time this is a bad
* idea from a user interface standpoint. But you can set such a name
* with this function, if you like.
*
* After calling this with a non-%NULL @name, calls to cdk_window_set_title()
* will not update the icon title.
*
* Using %NULL for @name unsets the icon title; further calls to
* cdk_window_set_title() will again update the icon title as well.
*
* Note that some platforms don't support window icons.
**/
10728void
10729cdk_window_set_icon_name (CdkWindow   *window,
	  const gchar *name)
10731{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_icon_name (window, name);
10733}

10735/**
* cdk_window_iconify:
* @window: a toplevel #CdkWindow
*
* Asks to iconify (minimize) @window. The window manager may choose
* to ignore the request, but normally will honor it. Using
* ctk_window_iconify() is preferred, if you have a #CtkWindow widget.
*
* This function only makes sense when @window is a toplevel window.
*
**/
10746void
10747cdk_window_iconify (CdkWindow *window)
10748{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->iconify (window);
10750}

10752/**
* cdk_window_deiconify:
* @window: a toplevel #CdkWindow
*
* Attempt to deiconify (unminimize) @window. On X11 the window manager may
* choose to ignore the request to deiconify. When using CTK+,
* use ctk_window_deiconify() instead of the #CdkWindow variant. Or better yet,
* you probably want to use ctk_window_present_with_time(), which raises the window, focuses it,
* unminimizes it, and puts it on the current desktop.
*
**/
10763void
10764cdk_window_deiconify (CdkWindow *window)
10765{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->deiconify (window);
10767}

10769/**
* cdk_window_stick:
* @window: a toplevel #CdkWindow
*
* “Pins” a window such that it’s on all workspaces and does not scroll
* with viewports, for window managers that have scrollable viewports.
* (When using #CtkWindow, ctk_window_stick() may be more useful.)
*
* On the X11 platform, this function depends on window manager
* support, so may have no effect with many window managers. However,
* CDK will do the best it can to convince the window manager to stick
* the window. For window managers that don’t support this operation,
* there’s nothing you can do to force it to happen.
*
**/
10784void
10785cdk_window_stick (CdkWindow *window)
10786{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->stick (window);
10788}

10790/**
* cdk_window_unstick:
* @window: a toplevel #CdkWindow
*
* Reverse operation for cdk_window_stick(); see cdk_window_stick(),
* and ctk_window_unstick().
*
**/
10798void
10799cdk_window_unstick (CdkWindow *window)
10800{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->unstick (window);
10802}

10804/**
* cdk_window_maximize:
* @window: a toplevel #CdkWindow
*
* Maximizes the window. If the window was already maximized, then
* this function does nothing.
*
* On X11, asks the window manager to maximize @window, if the window
* manager supports this operation. Not all window managers support
* this, and some deliberately ignore it or don’t have a concept of
* “maximized”; so you can’t rely on the maximization actually
* happening. But it will happen with most standard window managers,
* and CDK makes a best effort to get it to happen.
*
* On Windows, reliably maximizes the window.
*
**/
10821void
10822cdk_window_maximize (CdkWindow *window)
10823{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->maximize (window);
10825}

10827/**
* cdk_window_unmaximize:
* @window: a toplevel #CdkWindow
*
* Unmaximizes the window. If the window wasn’t maximized, then this
* function does nothing.
*
* On X11, asks the window manager to unmaximize @window, if the
* window manager supports this operation. Not all window managers
* support this, and some deliberately ignore it or don’t have a
* concept of “maximized”; so you can’t rely on the unmaximization
* actually happening. But it will happen with most standard window
* managers, and CDK makes a best effort to get it to happen.
*
* On Windows, reliably unmaximizes the window.
*
**/
10844void
10845cdk_window_unmaximize (CdkWindow *window)
10846{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->unmaximize (window);
10848}

10850/**
* cdk_window_fullscreen:
* @window: a toplevel #CdkWindow
*
* Moves the window into fullscreen mode. This means the
* window covers the entire screen and is above any panels
* or task bars.
*
* If the window was already fullscreen, then this function does nothing.
*
* On X11, asks the window manager to put @window in a fullscreen
* state, if the window manager supports this operation. Not all
* window managers support this, and some deliberately ignore it or
* don’t have a concept of “fullscreen”; so you can’t rely on the
* fullscreenification actually happening. But it will happen with
* most standard window managers, and CDK makes a best effort to get
* it to happen.
*
* Since: 2.2
**/
10870void
10871cdk_window_fullscreen (CdkWindow *window)
10872{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->fullscreen (window);
10874}

10876/**
* cdk_window_fullscreen_on_monitor:
* @window: a toplevel #CdkWindow
* @monitor: Which monitor to display fullscreen on.
*
* Moves the window into fullscreen mode on the given monitor. This means
* the window covers the entire screen and is above any panels or task bars.
*
* If the window was already fullscreen, then this function does nothing.
* Since: UNRELEASED
**/
10887void
10888cdk_window_fullscreen_on_monitor (CdkWindow      *window,
                                gint            monitor)
10890{
CdkDisplay *display = cdk_window_get_display (window);

g_return_if_fail (monitor >= 0)do { if ((monitor >= 0)) { } else { g_return_if_fail_warning
 ("Cdk", ((const char*) (__func__)), "monitor >= 0"); return
; } } while (0);
g_return_if_fail (monitor < cdk_display_get_n_monitors (display))do { if ((monitor < cdk_display_get_n_monitors (display)))
 { } else { g_return_if_fail_warning ("Cdk", ((const char*) (
__func__)), "monitor < cdk_display_get_n_monitors (display)"
); return; } } while (0);

if (CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->fullscreen_on_monitor != NULL((void*)0))
  CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->fullscreen_on_monitor (window, monitor);
else
  CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->fullscreen (window);
10900}

10902/**
* cdk_window_set_fullscreen_mode:
* @window: a toplevel #CdkWindow
* @mode: fullscreen mode
*
* Specifies whether the @window should span over all monitors (in a multi-head
* setup) or only the current monitor when in fullscreen mode.
*
* The @mode argument is from the #CdkFullscreenMode enumeration.
* If #CDK_FULLSCREEN_ON_ALL_MONITORS is specified, the fullscreen @window will
* span over all monitors from the #CdkScreen.
*
* On X11, searches through the list of monitors from the #CdkScreen the ones
* which delimit the 4 edges of the entire #CdkScreen and will ask the window
* manager to span the @window over these monitors.
*
* If the XINERAMA extension is not available or not usable, this function
* has no effect.
*
* Not all window managers support this, so you can’t rely on the fullscreen
* window to span over the multiple monitors when #CDK_FULLSCREEN_ON_ALL_MONITORS
* is specified.
*
* Since: 3.8
**/
10927void
10928cdk_window_set_fullscreen_mode (CdkWindow        *window,
                              CdkFullscreenMode mode)
10930{
CdkWindowImplClass *impl_class;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (window->fullscreen_mode != mode)
  {
    window->fullscreen_mode = mode;

    impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));
    if (impl_class->apply_fullscreen_mode != NULL((void*)0))
      impl_class->apply_fullscreen_mode (window);
  }
10943}

10945/**
* cdk_window_get_fullscreen_mode:
* @window: a toplevel #CdkWindow
*
* Obtains the #CdkFullscreenMode of the @window.
*
* Returns: The #CdkFullscreenMode applied to the window when fullscreen.
*
* Since: 3.8
**/
10955CdkFullscreenMode
10956cdk_window_get_fullscreen_mode (CdkWindow *window)
10957{
g_return_val_if_fail (CDK_IS_WINDOW (window), CDK_FULLSCREEN_ON_CURRENT_MONITOR)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (CDK_FULLSCREEN_ON_CURRENT_MONITOR
); } } while (0);

return window->fullscreen_mode;
10961}

10963/**
* cdk_window_unfullscreen:
* @window: a toplevel #CdkWindow
*
* Moves the window out of fullscreen mode. If the window was not
* fullscreen, does nothing.
*
* On X11, asks the window manager to move @window out of the fullscreen
* state, if the window manager supports this operation. Not all
* window managers support this, and some deliberately ignore it or
* don’t have a concept of “fullscreen”; so you can’t rely on the
* unfullscreenification actually happening. But it will happen with
* most standard window managers, and CDK makes a best effort to get
* it to happen.
*
* Since: 2.2
**/
10980void
10981cdk_window_unfullscreen (CdkWindow *window)
10982{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->unfullscreen (window);
10984}

10986/**
* cdk_window_set_keep_above:
* @window: a toplevel #CdkWindow
* @setting: whether to keep @window above other windows
*
* Set if @window must be kept above other windows. If the
* window was already above, then this function does nothing.
*
* On X11, asks the window manager to keep @window above, if the window
* manager supports this operation. Not all window managers support
* this, and some deliberately ignore it or don’t have a concept of
* “keep above”; so you can’t rely on the window being kept above.
* But it will happen with most standard window managers,
* and CDK makes a best effort to get it to happen.
*
* Since: 2.4
**/
11003void
11004cdk_window_set_keep_above (CdkWindow *window,
                         gboolean   setting)
11006{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_keep_above (window, setting);
11008}

11010/**
* cdk_window_set_keep_below:
* @window: a toplevel #CdkWindow
* @setting: whether to keep @window below other windows
*
* Set if @window must be kept below other windows. If the
* window was already below, then this function does nothing.
*
* On X11, asks the window manager to keep @window below, if the window
* manager supports this operation. Not all window managers support
* this, and some deliberately ignore it or don’t have a concept of
* “keep below”; so you can’t rely on the window being kept below.
* But it will happen with most standard window managers,
* and CDK makes a best effort to get it to happen.
*
* Since: 2.4
**/
11027void
11028cdk_window_set_keep_below (CdkWindow *window, gboolean setting)
11029{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_keep_below (window, setting);
11031}

11033/**
* cdk_window_get_group:
* @window: a toplevel #CdkWindow
*
* Returns the group leader window for @window. See cdk_window_set_group().
*
* Returns: (transfer none): the group leader window for @window
*
* Since: 2.4
**/
11043CdkWindow *
11044cdk_window_get_group (CdkWindow *window)
11045{
return CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->get_group (window);
11047}

11049/**
* cdk_window_set_group:
* @window: a toplevel #CdkWindow
* @leader: (allow-none): group leader window, or %NULL to restore the default group leader window
*
* Sets the group leader window for @window. By default,
* CDK sets the group leader for all toplevel windows
* to a global window implicitly created by CDK. With this function
* you can override this default.
*
* The group leader window allows the window manager to distinguish
* all windows that belong to a single application. It may for example
* allow users to minimize/unminimize all windows belonging to an
* application at once. You should only set a non-default group window
* if your application pretends to be multiple applications.
**/
11065void
11066cdk_window_set_group (CdkWindow *window,
      CdkWindow *leader)
11068{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_group (window, leader);
11070}

11072/**
* cdk_window_set_decorations:
* @window: a toplevel #CdkWindow
* @decorations: decoration hint mask
*
* “Decorations” are the features the window manager adds to a toplevel #CdkWindow.
* This function sets the traditional Motif window manager hints that tell the
* window manager which decorations you would like your window to have.
* Usually you should use ctk_window_set_decorated() on a #CtkWindow instead of
* using the CDK function directly.
*
* The @decorations argument is the logical OR of the fields in
* the #CdkWMDecoration enumeration. If #CDK_DECOR_ALL is included in the
* mask, the other bits indicate which decorations should be turned off.
* If #CDK_DECOR_ALL is not included, then the other bits indicate
* which decorations should be turned on.
*
* Most window managers honor a decorations hint of 0 to disable all decorations,
* but very few honor all possible combinations of bits.
*
**/
11093void
11094cdk_window_set_decorations (CdkWindow      *window,
	    CdkWMDecoration decorations)
11096{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_decorations (window, decorations);
11098}

11100/**
* cdk_window_get_decorations:
* @window: The toplevel #CdkWindow to get the decorations from
* @decorations: (out): The window decorations will be written here
*
* Returns the decorations set on the CdkWindow with
* cdk_window_set_decorations().
*
* Returns: %TRUE if the window has decorations set, %FALSE otherwise.
**/
11110gboolean
11111cdk_window_get_decorations(CdkWindow       *window,
	   CdkWMDecoration *decorations)
11113{
return CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->get_decorations (window, decorations);
11115}

11117/**
* cdk_window_set_functions:
* @window: a toplevel #CdkWindow
* @functions: bitmask of operations to allow on @window
*
* Sets hints about the window management functions to make available
* via buttons on the window frame.
*
* On the X backend, this function sets the traditional Motif window
* manager hint for this purpose. However, few window managers do
* anything reliable or interesting with this hint. Many ignore it
* entirely.
*
* The @functions argument is the logical OR of values from the
* #CdkWMFunction enumeration. If the bitmask includes #CDK_FUNC_ALL,
* then the other bits indicate which functions to disable; if
* it doesn’t include #CDK_FUNC_ALL, it indicates which functions to
* enable.
*
**/
11137void
11138cdk_window_set_functions (CdkWindow    *window,
	  CdkWMFunction functions)
11140{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_functions (window, functions);
11142}

11144/**
* cdk_window_begin_resize_drag_for_device:
* @window: a toplevel #CdkWindow
* @edge: the edge or corner from which the drag is started
* @device: the device used for the operation
* @button: the button being used to drag, or 0 for a keyboard-initiated drag
* @root_x: root window X coordinate of mouse click that began the drag
* @root_y: root window Y coordinate of mouse click that began the drag
* @timestamp: timestamp of mouse click that began the drag (use cdk_event_get_time())
*
* Begins a window resize operation (for a toplevel window).
* You might use this function to implement a “window resize grip,” for
* example; in fact #CtkStatusbar uses it. The function works best
* with window managers that support the
* [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)
* but has a fallback implementation for other window managers.
*
* Since: 3.4
*/
11163void
11164cdk_window_begin_resize_drag_for_device (CdkWindow     *window,
                                       CdkWindowEdge  edge,
                                       CdkDevice     *device,
                                       gint           button,
                                       gint           root_x,
                                       gint           root_y,
                                       guint32        timestamp)
11171{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->begin_resize_drag (window, edge, device, button, root_x, root_y, timestamp);
11173}

11175/**
* cdk_window_begin_resize_drag:
* @window: a toplevel #CdkWindow
* @edge: the edge or corner from which the drag is started
* @button: the button being used to drag, or 0 for a keyboard-initiated drag
* @root_x: root window X coordinate of mouse click that began the drag
* @root_y: root window Y coordinate of mouse click that began the drag
* @timestamp: timestamp of mouse click that began the drag (use cdk_event_get_time())
*
* Begins a window resize operation (for a toplevel window).
*
* This function assumes that the drag is controlled by the
* client pointer device, use cdk_window_begin_resize_drag_for_device()
* to begin a drag with a different device.
*/
11190void
11191cdk_window_begin_resize_drag (CdkWindow     *window,
                            CdkWindowEdge  edge,
                            gint           button,
                            gint           root_x,
                            gint           root_y,
                            guint32        timestamp)
11197{
CdkDisplay *display;
CdkDevice *device;

display = cdk_window_get_display (window);
device = cdk_seat_get_pointer (cdk_display_get_default_seat (display));
cdk_window_begin_resize_drag_for_device (window, edge,
                                         device, button, root_x, root_y, timestamp);
11205}

11207/**
* cdk_window_begin_move_drag_for_device:
* @window: a toplevel #CdkWindow
* @device: the device used for the operation
* @button: the button being used to drag, or 0 for a keyboard-initiated drag
* @root_x: root window X coordinate of mouse click that began the drag
* @root_y: root window Y coordinate of mouse click that began the drag
* @timestamp: timestamp of mouse click that began the drag
*
* Begins a window move operation (for a toplevel window).
* You might use this function to implement a “window move grip,” for
* example. The function works best with window managers that support the
* [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)
* but has a fallback implementation for other window managers.
*
* Since: 3.4
*/
11224void
11225cdk_window_begin_move_drag_for_device (CdkWindow *window,
                                     CdkDevice *device,
                                     gint       button,
                                     gint       root_x,
                                     gint       root_y,
                                     guint32    timestamp)
11231{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->begin_move_drag (window,
                                                           device, button, root_x, root_y, timestamp);
11234}

11236/**
* cdk_window_begin_move_drag:
* @window: a toplevel #CdkWindow
* @button: the button being used to drag, or 0 for a keyboard-initiated drag
* @root_x: root window X coordinate of mouse click that began the drag
* @root_y: root window Y coordinate of mouse click that began the drag
* @timestamp: timestamp of mouse click that began the drag
*
* Begins a window move operation (for a toplevel window).
*
* This function assumes that the drag is controlled by the
* client pointer device, use cdk_window_begin_move_drag_for_device()
* to begin a drag with a different device.
*/
11250void
11251cdk_window_begin_move_drag (CdkWindow *window,
                          gint       button,
                          gint       root_x,
                          gint       root_y,
                          guint32    timestamp)
11256{
CdkDisplay *display;
CdkDevice *device;

display = cdk_window_get_display (window);
device = cdk_seat_get_pointer (cdk_display_get_default_seat (display));
cdk_window_begin_move_drag_for_device (window, device, button, root_x, root_y, timestamp);
11263}

11265/**
* cdk_window_enable_synchronized_configure:
* @window: a toplevel #CdkWindow
*
* Does nothing, present only for compatiblity.
*
* Since: 2.6
* Deprecated: 3.8: this function is no longer needed
**/
11274void
11275cdk_window_enable_synchronized_configure (CdkWindow *window G_GNUC_UNUSED__attribute__ ((__unused__)))
11276{
11277}

11279/**
* cdk_window_configure_finished:
* @window: a toplevel #CdkWindow
*
* Does nothing, present only for compatiblity.
*
* Since: 2.6
* Deprecated: 3.8: this function is no longer needed
**/
11288void
11289cdk_window_configure_finished (CdkWindow *window G_GNUC_UNUSED__attribute__ ((__unused__)))
11290{
11291}

11293/**
* cdk_window_set_opacity:
* @window: a top-level or non-native #CdkWindow
* @opacity: opacity
*
* Set @window to render as partially transparent,
* with opacity 0 being fully transparent and 1 fully opaque. (Values
* of the opacity parameter are clamped to the [0,1] range.) 
*
* For toplevel windows this depends on support from the windowing system
* that may not always be there. For instance, On X11, this works only on
* X screens with a compositing manager running. On Wayland, there is no
* per-window opacity value that the compositor would apply. Instead, use
* `cdk_window_set_opaque_region (window, NULL)` to tell the compositor
* that the entire window is (potentially) non-opaque, and draw your content
* with alpha, or use ctk_widget_set_opacity() to set an overall opacity
* for your widgets.
*
* For child windows this function only works for non-native windows.
*
* For setting up per-pixel alpha topelevels, see cdk_screen_get_rgba_visual(),
* and for non-toplevels, see cdk_window_set_composited().
*
* Support for non-toplevel windows was added in 3.8.
*
* Since: 2.12
*/
11320void
11321cdk_window_set_opacity (CdkWindow *window,
	gdouble    opacity)
11323{
if (opacity < 0)
  opacity = 0;
else if (opacity > 1)
  opacity = 1;

window->alpha = round (opacity * 255);

if (window->destroyed)
  return;

if (cdk_window_has_impl (window))
  CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->set_opacity (window, opacity);
else
  {
    recompute_visible_regions (window, FALSE(0));
    cdk_window_invalidate_rect_full (window, NULL((void*)0), TRUE(!(0)));
  }
11341}

11343/* This function is called when the XWindow is really gone.
*/
11345void
11346cdk_window_destroy_notify (CdkWindow *window)
11347{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->destroy_notify (window);
11349}

11351/**
* cdk_window_register_dnd:
* @window: a #CdkWindow.
*
* Registers a window as a potential drop destination.
*/
11357void
11358cdk_window_register_dnd (CdkWindow *window)
11359{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->register_dnd (window);
11361}

11363/**
* cdk_window_get_drag_protocol:
* @window: the destination window
* @target: (out) (allow-none) (transfer full): location of the window
*    where the drop should happen. This may be @window or a proxy window,
*    or %NULL if @window does not support Drag and Drop.
*
* Finds out the DND protocol supported by a window.
*
* Returns: the supported DND protocol.
*
* Since: 3.0
*/
11376CdkDragProtocol
11377cdk_window_get_drag_protocol (CdkWindow  *window,
                            CdkWindow **target)
11379{
g_return_val_if_fail (CDK_IS_WINDOW (window), CDK_DRAG_PROTO_NONE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (CDK_DRAG_PROTO_NONE); }
 } while (0);

return CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->get_drag_protocol (window, target);
11383}

11385/**
* cdk_drag_begin:
* @window: the source window for this drag.
* @targets: (transfer none) (element-type CdkAtom): the offered targets,
*     as list of #CdkAtoms
*
* Starts a drag and creates a new drag context for it.
* This function assumes that the drag is controlled by the
* client pointer device, use cdk_drag_begin_for_device() to
* begin a drag with a different device.
*
* This function is called by the drag source.
*
* Returns: (transfer full): a newly created #CdkDragContext
*/
11400CdkDragContext *
11401cdk_drag_begin (CdkWindow     *window,
              GList         *targets)
11403{
CdkDisplay *display;
CdkDevice *device;

display = cdk_window_get_display (window);
device = cdk_seat_get_pointer (cdk_display_get_default_seat (display));

return cdk_drag_begin_for_device (window, device, targets);
11411}

11413/**
* cdk_drag_begin_for_device:
* @window: the source window for this drag
* @device: the device that controls this drag
* @targets: (transfer none) (element-type CdkAtom): the offered targets,
*     as list of #CdkAtoms
*
* Starts a drag and creates a new drag context for it.
*
* This function is called by the drag source.
*
* Returns: (transfer full): a newly created #CdkDragContext
*/
11426CdkDragContext *
11427cdk_drag_begin_for_device (CdkWindow *window,
                         CdkDevice *device,
                         GList     *targets)
11430{
gint x, y;

cdk_device_get_position (device, NULL((void*)0), &x, &y);

return cdk_drag_begin_from_point (window, device, targets, x, y);
11436}

11438/**
* cdk_drag_begin_from_point:
* @window: the source window for this drag
* @device: the device that controls this drag
* @targets: (transfer none) (element-type CdkAtom): the offered targets,
*     as list of #CdkAtoms
* @x_root: the x coordinate where the drag nominally started
* @y_root: the y coordinate where the drag nominally started
*
* Starts a drag and creates a new drag context for it.
*
* This function is called by the drag source.
*
* Returns: (transfer full): a newly created #CdkDragContext
*
* Since: 3.20
*/
11455CdkDragContext *
11456cdk_drag_begin_from_point (CdkWindow *window,
                         CdkDevice *device,
                         GList     *targets,
                         gint       x_root,
                         gint       y_root)
11461{
return CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->drag_begin (window, device, targets, x_root, y_root);
11463}

11465/**
* cdk_test_render_sync:
* @window: a mapped #CdkWindow
*
* Retrieves a pixel from @window to force the windowing
* system to carry out any pending rendering commands.
*
* This function is intended to be used to synchronize with rendering
* pipelines, to benchmark windowing system rendering operations.
*
* Since: 2.14
**/
11477void
11478cdk_test_render_sync (CdkWindow *window)
11479{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->sync_rendering (window);
11481}

11483/**
* cdk_test_simulate_key:
* @window: a #CdkWindow to simulate a key event for
* @x:      x coordinate within @window for the key event
* @y:      y coordinate within @window for the key event
* @keyval: A CDK keyboard value
* @modifiers: Keyboard modifiers the event is setup with
* @key_pressrelease: either %CDK_KEY_PRESS or %CDK_KEY_RELEASE
*
* This function is intended to be used in CTK+ test programs.
* If (@x,@y) are > (-1,-1), it will warp the mouse pointer to
* the given (@x,@y) coordinates within @window and simulate a
* key press or release event.
*
* When the mouse pointer is warped to the target location, use
* of this function outside of test programs that run in their
* own virtual windowing system (e.g. Xvfb) is not recommended.
* If (@x,@y) are passed as (-1,-1), the mouse pointer will not
* be warped and @window origin will be used as mouse pointer
* location for the event.
*
* Also, cdk_test_simulate_key() is a fairly low level function,
* for most testing purposes, ctk_test_widget_send_key() is the
* right function to call which will generate a key press event
* followed by its accompanying key release event.
*
* Returns: whether all actions necessary for a key event simulation
*     were carried out successfully
*
* Since: 2.14
*/
11514gboolean
11515cdk_test_simulate_key (CdkWindow      *window,
                     gint            x,
                     gint            y,
                     guint           keyval,
                     CdkModifierType modifiers,
                     CdkEventType    key_pressrelease)
11521{
return CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))
  ->simulate_key (window, x, y, keyval, modifiers, key_pressrelease);
11524}

11526/**
* cdk_test_simulate_button:
* @window: a #CdkWindow to simulate a button event for
* @x:      x coordinate within @window for the button event
* @y:      y coordinate within @window for the button event
* @button: Number of the pointer button for the event, usually 1, 2 or 3
* @modifiers: Keyboard modifiers the event is setup with
* @button_pressrelease: either %CDK_BUTTON_PRESS or %CDK_BUTTON_RELEASE
*
* This function is intended to be used in CTK+ test programs.
* It will warp the mouse pointer to the given (@x,@y) coordinates
* within @window and simulate a button press or release event.
* Because the mouse pointer needs to be warped to the target
* location, use of this function outside of test programs that
* run in their own virtual windowing system (e.g. Xvfb) is not
* recommended.
*
11543* Also, cdk_test_simulate_button() is a fairly low level function,
* for most testing purposes, ctk_test_widget_click() is the right
* function to call which will generate a button press event followed
* by its accompanying button release event.
*
* Returns: whether all actions necessary for a button event simulation
*     were carried out successfully
*
* Since: 2.14
*/
11553gboolean
11554cdk_test_simulate_button (CdkWindow      *window,
                        gint            x,
                        gint            y,
                        guint           button, /*1..3*/
                        CdkModifierType modifiers,
                        CdkEventType    button_pressrelease)
11560{
return CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))
  ->simulate_button (window, x, y, button, modifiers, button_pressrelease);
11563}

11565/**
* cdk_property_get:
* @window: a #CdkWindow
* @property: the property to retrieve
* @type: the desired property type, or %CDK_NONE, if any type of data
*   is acceptable. If this does not match the actual
*   type, then @actual_format and @actual_length will
*   be filled in, a warning will be printed to stderr
*   and no data will be returned.
* @offset: the offset into the property at which to begin
*   retrieving data, in 4 byte units.
* @length: the length of the data to retrieve in bytes.  Data is
*   considered to be retrieved in 4 byte chunks, so @length
*   will be rounded up to the next highest 4 byte boundary
*   (so be careful not to pass a value that might overflow
*   when rounded up).
* @pdelete: if %TRUE, delete the property after retrieving the
*   data.
* @actual_property_type: (out) (transfer none): location to store the
*   actual type of the property.
* @actual_format: (out): location to store the actual return format of the
*   data; either 8, 16 or 32 bits.
* @actual_length: location to store the length of the retrieved data, in
*   bytes.  Data returned in the 32 bit format is stored
*   in a long variable, so the actual number of 32 bit
*   elements should be be calculated via
*   @actual_length / sizeof(glong) to ensure portability to
*   64 bit systems.
* @data: (out) (array length=actual_length) (transfer full): location
*   to store a pointer to the data. The retrieved data should be
*   freed with g_free() when you are finished using it.
*
* Retrieves a portion of the contents of a property. If the
* property does not exist, then the function returns %FALSE,
* and %CDK_NONE will be stored in @actual_property_type.
*
* The XGetWindowProperty() function that cdk_property_get()
* uses has a very confusing and complicated set of semantics.
* Unfortunately, cdk_property_get() makes the situation
* worse instead of better (the semantics should be considered
* undefined), and also prints warnings to stderr in cases where it
* should return a useful error to the program. You are advised to use
* XGetWindowProperty() directly until a replacement function for
* cdk_property_get() is provided.
*
* Returns: %TRUE if data was successfully received and stored
*   in @data, otherwise %FALSE.
*/
11613gboolean
11614cdk_property_get (CdkWindow  *window,
                CdkAtom     property,
                CdkAtom     type,
                gulong      offset,
                gulong      length,
                gint        pdelete,
                CdkAtom    *actual_property_type,
                gint       *actual_format_type,
                gint       *actual_length,
                guchar    **data)
11624{
return CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))
  ->get_property (window, property, type, offset, length, pdelete,
                  actual_property_type, actual_format_type,
                  actual_length, data);
11629}

11631/**
* cdk_property_change: (skip)
* @window: a #CdkWindow
* @property: the property to change
* @type: the new type for the property. If @mode is
*   %CDK_PROP_MODE_PREPEND or %CDK_PROP_MODE_APPEND, then this
*   must match the existing type or an error will occur.
* @format: the new format for the property. If @mode is
*   %CDK_PROP_MODE_PREPEND or %CDK_PROP_MODE_APPEND, then this
*   must match the existing format or an error will occur.
* @mode: a value describing how the new data is to be combined
*   with the current data.
* @data: the data (a `guchar *`
*   `gushort *`, or `gulong *`,
*   depending on @format), cast to a `guchar *`.
* @nelements: the number of elements of size determined by the format,
*   contained in @data.
*
* Changes the contents of a property on a window.
*/
11651void
11652cdk_property_change (CdkWindow    *window,
                   CdkAtom       property,
                   CdkAtom       type,
                   gint          format,
                   CdkPropMode   mode,
                   const guchar *data,
                   gint          nelements)
11659{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))
  ->change_property (window, property, type, format, mode, data, nelements);
11662}

11664/**
* cdk_property_delete:
* @window: a #CdkWindow
* @property: the property to delete
*
* Deletes a property from a window.
*/
11671void
11672cdk_property_delete (CdkWindow *window,
                   CdkAtom    property)
11674{
CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))))->delete_property (window, property);
11676}

11678static void
11679cdk_window_flush_events (CdkFrameClock *clock,
                       void          *data)
11681{
CdkWindow *window;
CdkDisplay *display;

window = CDK_WINDOW (data)((((CdkWindow*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((cdk_window_get_type ()))))));

display = cdk_window_get_display (window);
_cdk_event_queue_flush (display);
_cdk_display_pause_events (display);

cdk_frame_clock_request_phase (clock, CDK_FRAME_CLOCK_PHASE_RESUME_EVENTS);

window->frame_clock_events_paused = TRUE(!(0));
11694}

11696static void
11697cdk_window_paint_on_clock (CdkFrameClock *clock G_GNUC_UNUSED__attribute__ ((__unused__)),
	   void          *data)
11699{
CdkWindow *window;

window = CDK_WINDOW (data)((((CdkWindow*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((cdk_window_get_type ()))))));

/* Update window and any children on the same clock.
 */
cdk_window_process_updates_with_mode (window, PROCESS_UPDATES_WITH_SAME_CLOCK_CHILDREN);
11707}

11709static void
11710cdk_window_resume_events (CdkFrameClock *clock G_GNUC_UNUSED__attribute__ ((__unused__)),
                        void          *data)
11712{
CdkWindow *window;
CdkDisplay *display;

window = CDK_WINDOW (data)((((CdkWindow*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((cdk_window_get_type ()))))));

display = cdk_window_get_display (window);
_cdk_display_unpause_events (display);

window->frame_clock_events_paused = FALSE(0);
11722}

11724static void
11725cdk_window_set_frame_clock (CdkWindow     *window,
                          CdkFrameClock *clock)
11727{
g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);
g_return_if_fail (clock == NULL || CDK_IS_FRAME_CLOCK (clock))do { if ((clock == ((void*)0) || (((__extension__ ({ GTypeInstance
 *__inst = (GTypeInstance*) ((clock)); GType __t = ((cdk_frame_clock_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; })))))) { } else { g_return_if_fail_warning ("Cdk", ((const
 char*) (__func__)), "clock == NULL || CDK_IS_FRAME_CLOCK (clock)"
); return; } } while (0);
g_return_if_fail (clock == NULL || cdk_window_is_toplevel (window))do { if ((clock == ((void*)0) || cdk_window_is_toplevel (window
))) { } else { g_return_if_fail_warning ("Cdk", ((const char*
) (__func__)), "clock == NULL || cdk_window_is_toplevel (window)"
); return; } } while (0);

if (clock == window->frame_clock)
  return;

if (clock)
  {
    g_object_ref (clock)((__typeof__ (clock)) (g_object_ref) (clock));
    g_signal_connect (G_OBJECT (clock),g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((clock)), (((GType) ((20) << (2))))
))))), ("flush-events"), (((GCallback) (cdk_window_flush_events
))), (window), ((void*)0), (GConnectFlags) 0)
                      "flush-events",g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((clock)), (((GType) ((20) << (2))))
))))), ("flush-events"), (((GCallback) (cdk_window_flush_events
))), (window), ((void*)0), (GConnectFlags) 0)
                      G_CALLBACK (cdk_window_flush_events),g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((clock)), (((GType) ((20) << (2))))
))))), ("flush-events"), (((GCallback) (cdk_window_flush_events
))), (window), ((void*)0), (GConnectFlags) 0)
                      window)g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((clock)), (((GType) ((20) << (2))))
))))), ("flush-events"), (((GCallback) (cdk_window_flush_events
))), (window), ((void*)0), (GConnectFlags) 0);
    g_signal_connect (G_OBJECT (clock),g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((clock)), (((GType) ((20) << (2))))
))))), ("paint"), (((GCallback) (cdk_window_paint_on_clock)))
, (window), ((void*)0), (GConnectFlags) 0)
                      "paint",g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((clock)), (((GType) ((20) << (2))))
))))), ("paint"), (((GCallback) (cdk_window_paint_on_clock)))
, (window), ((void*)0), (GConnectFlags) 0)
                      G_CALLBACK (cdk_window_paint_on_clock),g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((clock)), (((GType) ((20) << (2))))
))))), ("paint"), (((GCallback) (cdk_window_paint_on_clock)))
, (window), ((void*)0), (GConnectFlags) 0)
                      window)g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((clock)), (((GType) ((20) << (2))))
))))), ("paint"), (((GCallback) (cdk_window_paint_on_clock)))
, (window), ((void*)0), (GConnectFlags) 0);
    g_signal_connect (G_OBJECT (clock),g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((clock)), (((GType) ((20) << (2))))
))))), ("resume-events"), (((GCallback) (cdk_window_resume_events
))), (window), ((void*)0), (GConnectFlags) 0)
                      "resume-events",g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((clock)), (((GType) ((20) << (2))))
))))), ("resume-events"), (((GCallback) (cdk_window_resume_events
))), (window), ((void*)0), (GConnectFlags) 0)
                      G_CALLBACK (cdk_window_resume_events),g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((clock)), (((GType) ((20) << (2))))
))))), ("resume-events"), (((GCallback) (cdk_window_resume_events
))), (window), ((void*)0), (GConnectFlags) 0)
                      window)g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((clock)), (((GType) ((20) << (2))))
))))), ("resume-events"), (((GCallback) (cdk_window_resume_events
))), (window), ((void*)0), (GConnectFlags) 0);
  }

if (window->frame_clock)
  {
    if (window->frame_clock_events_paused)
      cdk_window_resume_events (window->frame_clock, G_OBJECT (window)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window)), (((GType) ((20) << (2)))))))));

    g_signal_handlers_disconnect_by_func (G_OBJECT (window->frame_clock),g_signal_handlers_disconnect_matched ((((((GObject*) (void *)
 g_type_check_instance_cast ((GTypeInstance*) ((window->frame_clock
)), (((GType) ((20) << (2))))))))), (GSignalMatchType) (
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)0),
 (((GCallback) (cdk_window_flush_events))), (window))
                                          G_CALLBACK (cdk_window_flush_events),g_signal_handlers_disconnect_matched ((((((GObject*) (void *)
 g_type_check_instance_cast ((GTypeInstance*) ((window->frame_clock
)), (((GType) ((20) << (2))))))))), (GSignalMatchType) (
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)0),
 (((GCallback) (cdk_window_flush_events))), (window))
                                          window)g_signal_handlers_disconnect_matched ((((((GObject*) (void *)
 g_type_check_instance_cast ((GTypeInstance*) ((window->frame_clock
)), (((GType) ((20) << (2))))))))), (GSignalMatchType) (
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)0),
 (((GCallback) (cdk_window_flush_events))), (window));
    g_signal_handlers_disconnect_by_func (G_OBJECT (window->frame_clock),g_signal_handlers_disconnect_matched ((((((GObject*) (void *)
 g_type_check_instance_cast ((GTypeInstance*) ((window->frame_clock
)), (((GType) ((20) << (2))))))))), (GSignalMatchType) (
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)0),
 (((GCallback) (cdk_window_paint_on_clock))), (window))
                                          G_CALLBACK (cdk_window_paint_on_clock),g_signal_handlers_disconnect_matched ((((((GObject*) (void *)
 g_type_check_instance_cast ((GTypeInstance*) ((window->frame_clock
)), (((GType) ((20) << (2))))))))), (GSignalMatchType) (
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)0),
 (((GCallback) (cdk_window_paint_on_clock))), (window))
                                          window)g_signal_handlers_disconnect_matched ((((((GObject*) (void *)
 g_type_check_instance_cast ((GTypeInstance*) ((window->frame_clock
)), (((GType) ((20) << (2))))))))), (GSignalMatchType) (
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)0),
 (((GCallback) (cdk_window_paint_on_clock))), (window));
    g_signal_handlers_disconnect_by_func (G_OBJECT (window->frame_clock),g_signal_handlers_disconnect_matched ((((((GObject*) (void *)
 g_type_check_instance_cast ((GTypeInstance*) ((window->frame_clock
)), (((GType) ((20) << (2))))))))), (GSignalMatchType) (
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)0),
 (((GCallback) (cdk_window_resume_events))), (window))
                                          G_CALLBACK (cdk_window_resume_events),g_signal_handlers_disconnect_matched ((((((GObject*) (void *)
 g_type_check_instance_cast ((GTypeInstance*) ((window->frame_clock
)), (((GType) ((20) << (2))))))))), (GSignalMatchType) (
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)0),
 (((GCallback) (cdk_window_resume_events))), (window))
                                          window)g_signal_handlers_disconnect_matched ((((((GObject*) (void *)
 g_type_check_instance_cast ((GTypeInstance*) ((window->frame_clock
)), (((GType) ((20) << (2))))))))), (GSignalMatchType) (
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)0),
 (((GCallback) (cdk_window_resume_events))), (window));
    g_object_unref (window->frame_clock);
  }

window->frame_clock = clock;
11770}

11772/**
* cdk_window_get_frame_clock:
* @window: window to get frame clock for
*
* Gets the frame clock for the window. The frame clock for a window
* never changes unless the window is reparented to a new toplevel
* window.
*
* Since: 3.8
* Returns: (transfer none): the frame clock
*/
11783CdkFrameClock*
11784cdk_window_get_frame_clock (CdkWindow *window)
11785{
CdkWindow *toplevel;

g_return_val_if_fail (CDK_IS_WINDOW (window), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (((void*)0)); } } while
 (0);

toplevel = cdk_window_get_toplevel (window);

return toplevel->frame_clock;
11793}

11795/**
* cdk_window_get_scale_factor:
* @window: window to get scale factor for
*
* Returns the internal scale factor that maps from window coordiantes
* to the actual device pixels. On traditional systems this is 1, but
* on very high density outputs this can be a higher value (often 2).
*
* A higher value means that drawing is automatically scaled up to
* a higher resolution, so any code doing drawing will automatically look
* nicer. However, if you are supplying pixel-based data the scale
* value can be used to determine whether to use a pixel resource
* with higher resolution data.
*
* The scale of a window may change during runtime, if this happens
* a configure event will be sent to the toplevel window.
*
* Since: 3.10
* Returns: the scale factor
*/
11815gint
11816cdk_window_get_scale_factor (CdkWindow *window)
11817{
CdkWindowImplClass *impl_class;

g_return_val_if_fail (CDK_IS_WINDOW (window), 1)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return (1); } } while (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return 1;

impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));

if (impl_class->get_scale_factor)
  return impl_class->get_scale_factor (window);

return 1;
11831}

11833/* Returns the *real* unscaled size, which may be a fractional size
 in window scale coordinates. We need this to properly handle GL
 coordinates which are y-flipped in the real coordinates. */
11836void
11837cdk_window_get_unscaled_size (CdkWindow *window,
                            int *unscaled_width,
                            int *unscaled_height)
11840{
CdkWindowImplClass *impl_class;
gint scale;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);

if (window->impl_window == window)
  {
    impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));

    if (impl_class->get_unscaled_size)
      {
        impl_class->get_unscaled_size (window, unscaled_width, unscaled_height);
        return;
      }
  }

scale = cdk_window_get_scale_factor (window);

if (unscaled_width)
  *unscaled_width = window->width * scale;

if (unscaled_height)
  *unscaled_height = window->height * scale;
11864}


11867/**
* cdk_window_set_opaque_region:
* @window: a top-level or non-native #CdkWindow
* @region: (allow-none):  a region, or %NULL
*
* For optimisation purposes, compositing window managers may
* like to not draw obscured regions of windows, or turn off blending
* during for these regions. With RGB windows with no transparency,
* this is just the shape of the window, but with ARGB32 windows, the
* compositor does not know what regions of the window are transparent
* or not.
*
* This function only works for toplevel windows.
*
* CTK+ will update this property automatically if
* the @window background is opaque, as we know where the opaque regions
* are. If your window background is not opaque, please update this
* property in your #CtkWidget::style-updated handler.
*
* Since: 3.10
*/
11888void
11889cdk_window_set_opaque_region (CdkWindow      *window,
                            cairo_region_t *region)
11891{
CdkWindowImplClass *impl_class;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);
g_return_if_fail (!CDK_WINDOW_DESTROYED (window))do { if ((!(((CdkWindow *)(window))->destroyed))) { } else
 { g_return_if_fail_warning ("Cdk", ((const char*) (__func__)
), "!CDK_WINDOW_DESTROYED (window)"); return; } } while (0);

if (cairo_region_equal (window->opaque_region, region))
  return;

g_clear_pointer (&window->opaque_region, cairo_region_destroy)do { _Static_assert (sizeof *(&window->opaque_region) ==
 sizeof (gpointer), "Expression evaluates to false"); __typeof__
 ((&window->opaque_region)) _pp = (&window->opaque_region
); __typeof__ (*(&window->opaque_region)) _ptr = *_pp;
 *_pp = ((void*)0); if (_ptr) (cairo_region_destroy) (_ptr); }
 while (0);

if (region != NULL((void*)0))
  window->opaque_region = cairo_region_reference (region);

impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));

if (impl_class->set_opaque_region)
  impl_class->set_opaque_region (window, region);
11909}

11911/**
* cdk_window_set_shadow_width:
* @window: a #CdkWindow
* @left: The left extent
* @right: The right extent
* @top: The top extent
* @bottom: The bottom extent
*
* Newer CTK+ windows using client-side decorations use extra geometry
* around their frames for effects like shadows and invisible borders.
* Window managers that want to maximize windows or snap to edges need
* to know where the extents of the actual frame lie, so that users
* don’t feel like windows are snapping against random invisible edges.
*
* Note that this property is automatically updated by CTK+, so this
* function should only be used by applications which do not use CTK+
* to create toplevel windows.
*
* Since: 3.12
*/
11931void
11932cdk_window_set_shadow_width (CdkWindow *window,
                           gint       left,
                           gint       right,
                           gint       top,
                           gint       bottom)
11937{
CdkWindowImplClass *impl_class;

g_return_if_fail (CDK_IS_WINDOW (window))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return; } } while (0);
g_return_if_fail (!CDK_WINDOW_DESTROYED (window))do { if ((!(((CdkWindow *)(window))->destroyed))) { } else
 { g_return_if_fail_warning ("Cdk", ((const char*) (__func__)
), "!CDK_WINDOW_DESTROYED (window)"); return; } } while (0);
g_return_if_fail (left >= 0 && right >= 0 && top >= 0 && bottom >= 0)do { if ((left >= 0 && right >= 0 && top
 >= 0 && bottom >= 0)) { } else { g_return_if_fail_warning
 ("Cdk", ((const char*) (__func__)), "left >= 0 && right >= 0 && top >= 0 && bottom >= 0"
); return; } } while (0);

window->shadow_top = top;
window->shadow_left = left;
window->shadow_right = right;
window->shadow_bottom = bottom;

impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));

if (impl_class->set_shadow_width)
  impl_class->set_shadow_width (window, left, right, top, bottom);
11953}

11955/**
* cdk_window_show_window_menu:
* @window: a #CdkWindow
* @event: a #CdkEvent to show the menu for
*
* Asks the windowing system to show the window menu. The window menu
* is the menu shown when right-clicking the titlebar on traditional
* windows managed by the window manager. This is useful for windows
* using client-side decorations, activating it with a right-click
* on the window decorations.
*
* Returns: %TRUE if the window menu was shown and %FALSE otherwise.
*
* Since: 3.14
*/
11970gboolean
11971cdk_window_show_window_menu (CdkWindow *window,
                           CdkEvent  *event)
11973{
CdkWindowImplClass *impl_class;

g_return_val_if_fail (CDK_IS_WINDOW (window), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((window)); GType __t = ((cdk_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; })))))) { }
 else { g_return_if_fail_warning ("Cdk", ((const char*) (__func__
)), "CDK_IS_WINDOW (window)"); return ((0)); } } while (0);
g_return_val_if_fail (!CDK_WINDOW_DESTROYED (window), FALSE)do { if ((!(((CdkWindow *)(window))->destroyed))) { } else
 { g_return_if_fail_warning ("Cdk", ((const char*) (__func__)
), "!CDK_WINDOW_DESTROYED (window)"); return ((0)); } } while
 (0);

impl_class = CDK_WINDOW_IMPL_GET_CLASS (window->impl)((((CdkWindowImplClass*) (((GTypeInstance*) ((window->impl
)))->g_class))));

if (impl_class->show_window_menu)
  return impl_class->show_window_menu (window, event);
else
  return FALSE(0);
11985}