cdkwindow-x11.c

Bug Summary

File:	cdk/x11/cdkwindow-x11.c
Warning:	line 2631, column 30 Access to field 'max_width' results in a dereference of a null pointer (loaded from variable 'geometry')
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-x11.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/rootdir/cdk/x11 -fcoverage-compilation-dir=/rootdir/cdk/x11 -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 ../../cdk -D G_ENABLE_DEBUG -D G_ENABLE_CONSISTENCY_CHECKS -D GLIB_MIN_REQUIRED_VERSION=GLIB_VERSION_2_66 -D GLIB_MAX_ALLOWED_VERSION=GLIB_VERSION_2_66 -I /usr/include/pango-1.0 -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/sysprof-6 -I /usr/include/harfbuzz -I /usr/include/freetype2 -I /usr/include/libpng16 -I /usr/include/libmount -I /usr/include/blkid -I /usr/include/fribidi -I /usr/include/cairo -I /usr/include/pixman-1 -I /usr/include/gdk-pixbuf-2.0 -I /usr/include/x86_64-linux-gnu -I /usr/include/webp -I /usr/include/gio-unix-2.0 -D PIC -internal-isystem /usr/lib/llvm-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.deadcode.UnreachableCode -analyzer-checker alpha.core.CastSize -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.core.IdenticalExpr -analyzer-checker alpha.security.ArrayBoundV2 -analyzer-checker alpha.security.MallocOverflow -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -analyzer-checker alpha.unix.cstring.NotNullTerminated -analyzer-checker alpha.unix.cstring.OutOfBounds -analyzer-checker alpha.core.FixedAddr -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /rootdir/html-report/2025-10-29-215236-44096-1 -x c cdkwindow-x11.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 "cdkwindow-x11.h"

30#include "cdkwindow.h"
31#include "cdkwindowimpl.h"
32#include "cdkvisualprivate.h"
33#include "cdkinternals.h"
34#include "cdkdeviceprivate.h"
35#include "cdkframeclockprivate.h"
36#include "cdkasync.h"
37#include "cdkeventsource.h"
38#include "cdkdisplay-x11.h"
39#include "cdkglcontext-x11.h"
40#include "cdkprivate-x11.h"
41#include "cdk-private.h"

43#include <stdlib.h>
44#include <stdio.h>
45#include <string.h>
46#include <netinet/in.h>
47#include <unistd.h>

49#include <cairo-xlib.h>

51#include "MwmUtil.h"

53#include <X11/Xlib.h>
54#include <X11/Xutil.h>
55#include <X11/Xatom.h>

57#include <X11/extensions/shape.h>

59#ifdef HAVE_XKB1
60#include <X11/XKBlib.h>
61#endif

63#ifdef HAVE_XCOMPOSITE1
64#include <X11/extensions/Xcomposite.h>
65#endif

67#ifdef HAVE_XFIXES1
68#include <X11/extensions/Xfixes.h>
69#endif

71#ifdef HAVE_XDAMAGE1
72#include <X11/extensions/Xdamage.h>
73#endif

75const int _cdk_x11_event_mask_table[21] =
76{
ExposureMask(1L<<15),
PointerMotionMask(1L<<6),
PointerMotionHintMask(1L<<7),
ButtonMotionMask(1L<<13),
Button1MotionMask(1L<<8),
Button2MotionMask(1L<<9),
Button3MotionMask(1L<<10),
ButtonPressMask(1L<<2),
ButtonReleaseMask(1L<<3),
KeyPressMask(1L<<0),
KeyReleaseMask(1L<<1),
EnterWindowMask(1L<<4),
LeaveWindowMask(1L<<5),
FocusChangeMask(1L<<21),
StructureNotifyMask(1L<<17),
PropertyChangeMask(1L<<22),
VisibilityChangeMask(1L<<16),
0,                    /* PROXIMITY_IN */
0,                    /* PROXIMTY_OUT */
SubstructureNotifyMask(1L<<19),
ButtonPressMask(1L<<2)      /* SCROLL; on X mouse wheel events is treated as mouse button 4/5 */
98};

100const gint _cdk_x11_event_mask_table_size = G_N_ELEMENTS (_cdk_x11_event_mask_table)(sizeof (_cdk_x11_event_mask_table) / sizeof ((_cdk_x11_event_mask_table
)[0]));

102/* Forward declarations */
103static void     cdk_x11_window_apply_fullscreen_mode (CdkWindow  *window);
104static gboolean cdk_window_icon_name_set          (CdkWindow  *window);
105static void     set_wm_name                       (CdkDisplay  *display,
				   Window       xwindow,
				   const gchar *name);
108static void     move_to_current_desktop           (CdkWindow *window);
109static void     cdk_window_x11_set_background     (CdkWindow      *window,
                                                 cairo_pattern_t *pattern);

112static void        cdk_window_impl_x11_finalize   (GObject            *object);

114#define WINDOW_IS_TOPLEVEL_OR_FOREIGN(window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
)           \
(CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL ||   \
 CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP ||       \
 CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN)

119#define WINDOW_IS_TOPLEVEL(window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
)                      \
(CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL ||   \
 CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP)

123/* Return whether time1 is considered later than time2 as far as xserver
* time is concerned.  Accounts for wraparound.
*/
126#define XSERVER_TIME_IS_LATER(time1, time2)( (( time1 > time2 ) && ( time1 - time2 < ((guint32
)-1)/2 )) || (( time1 < time2 ) && ( time2 - time1
 > ((guint32)-1)/2 )) )                        \
( (( time1 > time2 ) && ( time1 - time2 < ((guint32)-1)/2 )) ||  \
  (( time1 < time2 ) && ( time2 - time1 > ((guint32)-1)/2 ))     \
)

131struct _CdkX11Window {
CdkWindow parent;
133};

135struct _CdkX11WindowClass {
CdkWindowClass parent_class;
137};

139G_DEFINE_TYPE (CdkX11Window, cdk_x11_window, CDK_TYPE_WINDOW)static void cdk_x11_window_init (CdkX11Window *self); static void
 cdk_x11_window_class_init (CdkX11WindowClass *klass); static
 GType cdk_x11_window_get_type_once (void); static gpointer cdk_x11_window_parent_class
 = ((void*)0); static gint CdkX11Window_private_offset; static
 void cdk_x11_window_class_intern_init (gpointer klass) { cdk_x11_window_parent_class
 = g_type_class_peek_parent (klass); if (CdkX11Window_private_offset
 != 0) g_type_class_adjust_private_offset (klass, &CdkX11Window_private_offset
); cdk_x11_window_class_init ((CdkX11WindowClass*) klass); } __attribute__
 ((__unused__)) static inline gpointer cdk_x11_window_get_instance_private
 (CdkX11Window *self) { return (((gpointer) ((guint8*) (self)
 + (glong) (CdkX11Window_private_offset)))); } GType cdk_x11_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) (
? (gpointer) * (&static_g_define_type_id) : ((void*)0))
; (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
 ((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter_pointer (
&static_g_define_type_id)); })) ) { GType g_define_type_id
 = cdk_x11_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_x11_window_get_type_once (void
) { GType g_define_type_id = g_type_register_static_simple ((
cdk_window_get_type ()), g_intern_static_string ("CdkX11Window"
), sizeof (CdkX11WindowClass), (GClassInitFunc)(void (*)(void
)) cdk_x11_window_class_intern_init, sizeof (CdkX11Window), (
GInstanceInitFunc)(void (*)(void)) cdk_x11_window_init, (GTypeFlags
) 0); { {{};} } return g_define_type_id; }

141static void
142cdk_x11_window_class_init (CdkX11WindowClass *x11_window_class G_GNUC_UNUSED__attribute__ ((__unused__)))
143{
144}

146static void
147cdk_x11_window_init (CdkX11Window *x11_window G_GNUC_UNUSED__attribute__ ((__unused__)))
148{
149}


152G_DEFINE_TYPE (CdkWindowImplX11, cdk_window_impl_x11, CDK_TYPE_WINDOW_IMPL)static void cdk_window_impl_x11_init (CdkWindowImplX11 *self)
; static void cdk_window_impl_x11_class_init (CdkWindowImplX11Class
 *klass); static GType cdk_window_impl_x11_get_type_once (void
); static gpointer cdk_window_impl_x11_parent_class = ((void*
)0); static gint CdkWindowImplX11_private_offset; static void
 cdk_window_impl_x11_class_intern_init (gpointer klass) { cdk_window_impl_x11_parent_class
 = g_type_class_peek_parent (klass); if (CdkWindowImplX11_private_offset
 != 0) g_type_class_adjust_private_offset (klass, &CdkWindowImplX11_private_offset
); cdk_window_impl_x11_class_init ((CdkWindowImplX11Class*) klass
); } __attribute__ ((__unused__)) static inline gpointer cdk_window_impl_x11_get_instance_private
 (CdkWindowImplX11 *self) { return (((gpointer) ((guint8*) (self
) + (glong) (CdkWindowImplX11_private_offset)))); } GType cdk_window_impl_x11_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) (
? (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_impl_x11_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_impl_x11_get_type_once
 (void) { GType g_define_type_id = g_type_register_static_simple
 ((cdk_window_impl_get_type ()), g_intern_static_string ("CdkWindowImplX11"
), sizeof (CdkWindowImplX11Class), (GClassInitFunc)(void (*)(
void)) cdk_window_impl_x11_class_intern_init, sizeof (CdkWindowImplX11
), (GInstanceInitFunc)(void (*)(void)) cdk_window_impl_x11_init
, (GTypeFlags) 0); { {{};} } return g_define_type_id; }

154static void
155cdk_window_impl_x11_init (CdkWindowImplX11 *impl)
156{  
impl->device_cursor = g_hash_table_new_full (NULL((void*)0), NULL((void*)0),
                                             NULL((void*)0), g_object_unref);
impl->window_scale = 1;
impl->frame_sync_enabled = TRUE(!(0));
161}

163CdkToplevelX11 *
164_cdk_x11_window_get_toplevel (CdkWindow *window)
165{
CdkWindowImplX11 *impl;

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_IS_TOPLEVEL (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
))
  return NULL((void*)0);

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

if (!impl->toplevel)
  {
    impl->toplevel = g_new0 (CdkToplevelX11, 1)((CdkToplevelX11 *) g_malloc0_n ((1), sizeof (CdkToplevelX11)
));
    impl->toplevel->have_focused = TRUE(!(0));
  }

return impl->toplevel;
182}

184/**
* _cdk_x11_window_update_size:
* @impl: a #CdkWindowImplX11.
* 
* Updates the state of the window (in particular the drawable's
* cairo surface) when its size has changed.
**/
191void
192_cdk_x11_window_update_size (CdkWindowImplX11 *impl)
193{
if (impl->cairo_surface)
  {
    cairo_xlib_surface_set_size (impl->cairo_surface,
                                 impl->unscaled_width, impl->unscaled_height);
  }
199}

201void
202cdk_x11_window_get_unscaled_size (CdkWindow *window,
                                int *unscaled_width,
                                int *unscaled_height)
205{
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));

if (unscaled_width)
  *unscaled_width = impl->unscaled_width;

if (unscaled_height)
  *unscaled_height = impl->unscaled_height;
213}

215static void
216set_sync_counter(Display     *display,
 XSyncCounter counter,
               gint64       value)
219{
  XSyncValue sync_value;

  XSyncIntsToValue (&sync_value,
                    value & G_GINT64_CONSTANT(0xFFFFFFFF)(0xFFFFFFFFL),
                    value >> 32);
  XSyncSetCounter (display, counter, sync_value);
226}

228static void
229window_pre_damage (CdkWindow *window)
230{
CdkWindow *toplevel_window = cdk_window_get_toplevel (window);
CdkWindowImplX11 *impl;

if (!toplevel_window || !WINDOW_IS_TOPLEVEL (toplevel_window)(((((CdkWindow *)(toplevel_window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(toplevel_window)))->window_type) == CDK_WINDOW_TEMP
))
  return;

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

if (impl->toplevel->in_frame &&
    impl->toplevel->current_counter_value % 2 == 0)
  {
    impl->toplevel->current_counter_value += 1;
    set_sync_counter (CDK_WINDOW_XDISPLAY (impl->wrapper)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (impl->wrapper)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
        impl->toplevel->extended_update_counter,
                      impl->toplevel->current_counter_value);
  }
247}

249static void
250on_surface_changed (void *data)
251{
CdkWindow *window = data;
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));

if (impl->tracking_damage)
  window_pre_damage (window);
257}

259/* We want to know when cairo drawing causes damage to the window,
* so we engage in the _NET_WM_FRAME_DRAWN protocol with the
* window only when there actually is drawing. To do that we use
* a technique (hack) suggested by Uli Schlachter - if we set
* a dummy "mime data" on the cairo surface (this facility is
* used to attach JPEG data to an imager), then cairo wil flush
* and remove the mime data before making any changes to the window.
*/

268static void
269hook_surface_changed (CdkWindow *window)
270{
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));

/* The hooking we do below doesn't work if we're rendering with
 * OpenGL (the cairo surface is not touched) so just always
 * do the frame.
 */
if (window->current_paint.use_gl)
  {
    window_pre_damage (window);
    return;
  }

if (impl->cairo_surface)
  {
    cairo_surface_set_mime_data (impl->cairo_surface,
                                 "x-cdk/change-notify",
                                 (unsigned char *)"X",
                                 1,
                                 on_surface_changed,
                                 window);
    impl->tracking_damage = 1;
  }
293}

295static void
296unhook_surface_changed (CdkWindow *window)
297{
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));

if (impl->cairo_surface)
  {
    impl->tracking_damage = 0;
    cairo_surface_set_mime_data (impl->cairo_surface,
                                 "x-cdk/change-notify",
                                 NULL((void*)0), 0,
                                 NULL((void*)0), NULL((void*)0));
  }
308}

310static void
311cdk_x11_window_predict_presentation_time (CdkWindow *window)
312{
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));
CdkFrameClock *clock;
CdkFrameTimings *timings;
gint64 presentation_time;
gint64 refresh_interval;

if (!WINDOW_IS_TOPLEVEL (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
))
  return;

clock = cdk_window_get_frame_clock (window);

timings = cdk_frame_clock_get_current_timings (clock);

cdk_frame_clock_get_refresh_info (clock,
                                  timings->frame_time,
                                  &refresh_interval, &presentation_time);

if (presentation_time != 0)
  {
    if (timings->slept_before)
      {
        presentation_time += refresh_interval;
      }
    else
      {
        if (presentation_time < timings->frame_time + refresh_interval / 2)
          presentation_time += refresh_interval;
      }
  }
else
  {
    if (timings->slept_before)
      presentation_time = timings->frame_time + refresh_interval + refresh_interval / 2;
    else
      presentation_time = timings->frame_time + refresh_interval;
  }

if (presentation_time < impl->toplevel->throttled_presentation_time)
  presentation_time = impl->toplevel->throttled_presentation_time;

timings->predicted_presentation_time = presentation_time;
354}

356static void
357cdk_x11_window_begin_frame (CdkWindow *window,
                          gboolean   force_frame)
359{
CdkWindowImplX11 *impl;

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 = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));

if (!WINDOW_IS_TOPLEVEL (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
) ||
    impl->toplevel->extended_update_counter == None0L)
  return;

impl->toplevel->in_frame = TRUE(!(0));

if (impl->toplevel->configure_counter_value != 0 &&
    impl->toplevel->configure_counter_value_is_extended)
  {
    impl->toplevel->current_counter_value = impl->toplevel->configure_counter_value;
    if ((impl->toplevel->current_counter_value % 2) == 1)
      impl->toplevel->current_counter_value += 1;

    impl->toplevel->configure_counter_value = 0;

    window_pre_damage (window);
  }
else if (force_frame)
  {
    /* When mapping the window, we really want to freeze the
       rendering of the window by the compositor until we've
       actually painted something into the window's buffer. */
    window_pre_damage (window);
  }
else
  {
    hook_surface_changed (window);
  }
394}

396static void
397cdk_x11_window_end_frame (CdkWindow *window)
398{
CdkFrameClock *clock;
CdkFrameTimings *timings;
CdkWindowImplX11 *impl;

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 = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));

if (!WINDOW_IS_TOPLEVEL (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
) ||
    impl->toplevel->extended_update_counter == None0L ||
    !impl->toplevel->in_frame)
  return;

clock = cdk_window_get_frame_clock (window);
timings = cdk_frame_clock_get_current_timings (clock);

impl->toplevel->in_frame = FALSE(0);

if (impl->toplevel->current_counter_value % 2 == 1)
  {
419#ifdef G_ENABLE_DEBUG1
    if (CDK_DEBUG_CHECK (FRAMES)(_cdk_debug_flags & CDK_DEBUG_FRAMES))
      {
        XImage *image = XGetImage (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                                   CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                                   0, 0, 1, 1,
                                   (1 << 24) - 1,
                                   ZPixmap2);
        XDestroyImage (image)((*((image)->f.destroy_image))((image)));
      }
429#endif /* G_ENABLE_DEBUG */

    /* An increment of 3 means that the frame was not drawn as fast as possible,
     * but rather at a particular time. This can trigger different handling from
     * the compositor.
     */
    if (timings->slept_before)
      impl->toplevel->current_counter_value += 3;
    else
      impl->toplevel->current_counter_value += 1;

    set_sync_counter(CDK_WINDOW_XDISPLAY (impl->wrapper)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (impl->wrapper)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
       impl->toplevel->extended_update_counter,
       impl->toplevel->current_counter_value);

    if (impl->frame_sync_enabled &&
        cdk_x11_screen_supports_net_wm_hint (cdk_window_get_screen (window),
			       cdk_atom_intern_static_string ("_NET_WM_FRAME_DRAWN")))
      {
        impl->toplevel->frame_pending = TRUE(!(0));
        _cdk_frame_clock_freeze (cdk_window_get_frame_clock (window));
        timings->cookie = impl->toplevel->current_counter_value;
      }
  }

unhook_surface_changed (window);

if (impl->toplevel->configure_counter_value != 0 &&
    !impl->toplevel->configure_counter_value_is_extended)
  {
    set_sync_counter (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                      impl->toplevel->update_counter,
                      impl->toplevel->configure_counter_value);

    impl->toplevel->configure_counter_value = 0;
  }

if (!impl->toplevel->frame_pending)
  timings->complete = TRUE(!(0));
468}

470/*****************************************************
* X11 specific implementations of generic functions *
*****************************************************/

474static cairo_surface_t *
475cdk_x11_create_cairo_surface (CdkWindowImplX11 *impl,
	      int width,
	      int height)
478{
CdkVisual *visual;
  
visual = cdk_window_get_visual (impl->wrapper);
return cairo_xlib_surface_create (CDK_WINDOW_XDISPLAY (impl->wrapper)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (impl->wrapper)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                                  CDK_WINDOW_IMPL_X11 (impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((impl)), ((cdk_window_impl_x11_get_type ()))
))))->xid,
                                  CDK_VISUAL_XVISUAL (visual)(cdk_x11_visual_get_xvisual (visual)),
                                  width, height);
486}

488static cairo_surface_t *
489cdk_x11_ref_cairo_surface (CdkWindow *window)
490{
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));

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

if (!impl->cairo_surface)
  {
    impl->cairo_surface = cdk_x11_create_cairo_surface (impl,
                                                        cdk_window_get_width (window) * impl->window_scale,
                                                        cdk_window_get_height (window) * impl->window_scale);
    cairo_surface_set_device_scale (impl->cairo_surface, impl->window_scale, impl->window_scale);

    if (WINDOW_IS_TOPLEVEL (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
) && impl->toplevel->in_frame)
      hook_surface_changed (window);
  }

cairo_surface_reference (impl->cairo_surface);

return impl->cairo_surface;
510}

512static void
513cdk_window_impl_x11_finalize (GObject *object)
514{
CdkWindow *wrapper;
CdkWindowImplX11 *impl;

g_return_if_fail (CDK_IS_WINDOW_IMPL_X11 (object))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((object)); GType __t = ((cdk_window_impl_x11_get_type ())
); gboolean __r; if (!__inst) __r = (0); else if (__inst->
g_class && __inst->g_class->g_type == __t) __r =
 (!(0)); else __r = g_type_check_instance_is_a (__inst, __t);
 __r; })))))) { } else { g_return_if_fail_warning ("Cdk", ((const
 char*) (__func__)), "CDK_IS_WINDOW_IMPL_X11 (object)"); return
; } } while (0);

impl = CDK_WINDOW_IMPL_X11 (object)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((object)), ((cdk_window_impl_x11_get_type ()
))))));

wrapper = impl->wrapper;

if (WINDOW_IS_TOPLEVEL (wrapper)(((((CdkWindow *)(wrapper)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(wrapper)))->window_type) == CDK_WINDOW_TEMP
) && impl->toplevel->in_frame)
  unhook_surface_changed (wrapper);

_cdk_x11_window_grab_check_destroy (wrapper);

if (!CDK_WINDOW_DESTROYED (wrapper)(((CdkWindow *)(wrapper))->destroyed))
  {
    CdkDisplay *display = CDK_WINDOW_DISPLAY (wrapper)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (wrapper)))), ((cdk_x11_screen_get_type
 ()))))))->display);

    _cdk_x11_display_remove_window (display, impl->xid);
    if (impl->toplevel && impl->toplevel->focus_window)
      _cdk_x11_display_remove_window (display, impl->toplevel->focus_window);
  }

g_free (impl->toplevel);

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

g_hash_table_destroy (impl->device_cursor);

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

548typedef struct {
CdkDisplay *display;
Pixmap pixmap;
551} FreePixmapData;

553static void
554free_pixmap (gpointer datap)
555{
FreePixmapData *data = datap;

if (!cdk_display_is_closed (data->display))
  {
    XFreePixmap (CDK_DISPLAY_XDISPLAY (data->display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data->display)), ((cdk_x11_display_get_type()))))))->
xdisplay),
                 data->pixmap);
  }

g_object_unref (data->display);
g_slice_free (FreePixmapData, data)do { if (1) g_slice_free1 (sizeof (FreePixmapData), (data)); else
 (void) ((FreePixmapData*) 0 == (data)); } while (0);
566}

568static void
569attach_free_pixmap_handler (cairo_surface_t *surface,
                          CdkDisplay      *display,
                          Pixmap           pixmap)
572{
static const cairo_user_data_key_t key;
FreePixmapData *data;

data = g_slice_new (FreePixmapData)((FreePixmapData*) g_slice_alloc (sizeof (FreePixmapData)));
data->display = g_object_ref (display)((__typeof__ (display)) (g_object_ref) (display));
data->pixmap = pixmap;

cairo_surface_set_user_data (surface, &key, data, free_pixmap);
581}

583/* Cairo does not guarantee we get an xlib surface if we call
* cairo_surface_create_similar(). In some cases however, we must use a
* pixmap or bitmap in the X11 API.
* These functions ensure an Xlib surface.
*/
588cairo_surface_t *
589_cdk_x11_window_create_bitmap_surface (CdkWindow *window,
                                     int        width,
                                     int        height)
592{
cairo_surface_t *surface;
Pixmap pixmap;

pixmap = XCreatePixmap (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                        CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                        width, height, 1);
surface = cairo_xlib_surface_create_for_bitmap (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                                                pixmap,
                                                CDK_X11_SCREEN (CDK_WINDOW_SCREEN (window))((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xscreen,
                                                width, height);
attach_free_pixmap_handler (surface, CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display), pixmap);

return surface;
606}

608/* Create a surface backed with a pixmap without alpha on the same screen as window */
609static cairo_surface_t *
610cdk_x11_window_create_pixmap_surface (CdkWindow *window,
                                    int        width,
                                    int        height)
613{
CdkScreen *screen = cdk_window_get_screen (window);
CdkVisual *visual = cdk_screen_get_system_visual (screen);
cairo_surface_t *surface;
Pixmap pixmap;

pixmap = XCreatePixmap (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                        CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                        width, height,
                        cdk_visual_get_depth (visual));
surface = cairo_xlib_surface_create (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                                     pixmap,
                                     CDK_VISUAL_XVISUAL (visual)(cdk_x11_visual_get_xvisual (visual)),
                                     width, height);
attach_free_pixmap_handler (surface, CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display), pixmap);

return surface;
630}

632static void
633tmp_unset_bg (CdkWindow *window)
634{
CdkWindowImplX11 *impl;

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

impl->no_bg = TRUE(!(0));

XSetWindowBackgroundPixmap (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                            CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid), None0L);
643}

645static void
646tmp_reset_bg (CdkWindow *window)
647{
CdkWindowImplX11 *impl;

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

impl->no_bg = FALSE(0);

cdk_window_x11_set_background (window, window->background);
655}

657/* Unsetting and resetting window backgrounds.
*
* In many cases it is possible to avoid flicker by unsetting the
* background of windows. For example if the background of the
* parent window is unset when a window is unmapped, a brief flicker
* of background painting is avoided.
*/
664void
665_cdk_x11_window_tmp_unset_bg (CdkWindow *window,
	      gboolean   recurse)
667{
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 || window->destroyed ||
    (window->window_type != CDK_WINDOW_ROOT &&
     !CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0)))
  return;

if (_cdk_window_has_impl (window) &&
    CDK_WINDOW_IS_X11 (window)((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*)
 (((window)->impl)); GType __t = ((cdk_window_impl_x11_get_type
 ())); gboolean __r; if (!__inst) __r = (0); else if (__inst->
g_class && __inst->g_class->g_type == __t) __r =
 (!(0)); else __r = g_type_check_instance_is_a (__inst, __t);
 __r; }))))) &&
    window->window_type != CDK_WINDOW_ROOT &&
    window->window_type != CDK_WINDOW_FOREIGN)
  tmp_unset_bg (window);

if (recurse)
  {
    GList *l;

    for (l = window->children; l != NULL((void*)0); l = l->next)
_cdk_x11_window_tmp_unset_bg (l->data, TRUE(!(0)));
  }
688}

690void
691_cdk_x11_window_tmp_unset_parent_bg (CdkWindow *window)
692{
if (CDK_WINDOW_TYPE (window->parent)((((CdkWindow *)(window->parent)))->window_type) == CDK_WINDOW_ROOT)
  return;

window = _cdk_window_get_impl_window (window->parent);
_cdk_x11_window_tmp_unset_bg (window,	FALSE(0));
698}

700void
701_cdk_x11_window_tmp_reset_bg (CdkWindow *window,
	      gboolean   recurse)
703{
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 || window->destroyed ||
    (window->window_type != CDK_WINDOW_ROOT &&
     !CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0)))
  return;


if (_cdk_window_has_impl (window) &&
    CDK_WINDOW_IS_X11 (window)((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*)
 (((window)->impl)); GType __t = ((cdk_window_impl_x11_get_type
 ())); gboolean __r; if (!__inst) __r = (0); else if (__inst->
g_class && __inst->g_class->g_type == __t) __r =
 (!(0)); else __r = g_type_check_instance_is_a (__inst, __t);
 __r; }))))) &&
    window->window_type != CDK_WINDOW_ROOT &&
    window->window_type != CDK_WINDOW_FOREIGN)
  tmp_reset_bg (window);

if (recurse)
  {
    GList *l;

    for (l = window->children; l != NULL((void*)0); l = l->next)
_cdk_x11_window_tmp_reset_bg (l->data, TRUE(!(0)));
  }
725}

727void
728_cdk_x11_window_tmp_reset_parent_bg (CdkWindow *window)
729{
if (CDK_WINDOW_TYPE (window->parent)((((CdkWindow *)(window->parent)))->window_type) == CDK_WINDOW_ROOT)
  return;

window = _cdk_window_get_impl_window (window->parent);

_cdk_x11_window_tmp_reset_bg (window, FALSE(0));
736}

738void
739_cdk_x11_screen_init_root_window (CdkScreen *screen)
740{
CdkWindow *window;
CdkWindowImplX11 *impl;
CdkX11Screen *x11_screen;

x11_screen = CDK_X11_SCREEN (screen)((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((screen)), ((cdk_x11_screen_get_type ()))))));

g_assert (x11_screen->root_window == NULL)do { if (x11_screen->root_window == ((void*)0)) ; else g_assertion_message_expr
 ("Cdk", "cdkwindow-x11.c", 747, ((const char*) (__func__)), "x11_screen->root_window == NULL"
); } while (0);

window = x11_screen->root_window = _cdk_display_create_window (cdk_screen_get_display (screen));

window->impl = g_object_new (CDK_TYPE_WINDOW_IMPL_X11(cdk_window_impl_x11_get_type ()), NULL((void*)0));
window->impl_window = window;
window->visual = cdk_screen_get_system_visual (screen);

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

impl->xid = x11_screen->xroot_window;
impl->wrapper = window;
impl->window_scale = x11_screen->window_scale;

window->window_type = CDK_WINDOW_ROOT;
window->depth = DefaultDepthOfScreen (x11_screen->xscreen)((x11_screen->xscreen)->root_depth);

window->x = 0;
window->y = 0;
window->abs_x = 0;
window->abs_y = 0;
impl->unscaled_width = WidthOfScreen (x11_screen->xscreen)((x11_screen->xscreen)->width);
impl->unscaled_height = HeightOfScreen (x11_screen->xscreen)((x11_screen->xscreen)->height);
window->width = WidthOfScreen (x11_screen->xscreen)((x11_screen->xscreen)->width) / impl->window_scale;
window->height = HeightOfScreen (x11_screen->xscreen)((x11_screen->xscreen)->height) / impl->window_scale;
window->viewable = TRUE(!(0));

/* see init_randr_support() in cdkscreen-x11.c */
window->event_mask = CDK_STRUCTURE_MASK;

_cdk_window_update_size (x11_screen->root_window);

_cdk_x11_display_add_window (x11_screen->display,
                             &x11_screen->xroot_window,
                             x11_screen->root_window);
782}

784static void
785set_wm_protocols (CdkWindow *window)
786{
CdkDisplay *display = cdk_window_get_display (window);
Atom protocols[4];
int n = 0;

protocols[n++] = cdk_x11_get_xatom_by_name_for_display (display, "WM_DELETE_WINDOW");
protocols[n++] = cdk_x11_get_xatom_by_name_for_display (display, "WM_TAKE_FOCUS");
protocols[n++] = cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_PING");

795#ifdef HAVE_XSYNC1
if (CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->use_sync)
  protocols[n++] = cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_SYNC_REQUEST");
798#endif

XSetWMProtocols (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid), protocols, n);
801}

803static const gchar *
804get_default_title (void)
805{
const char *title;

title = g_get_application_name ();
if (!title)
  title = g_get_prgname ();
if (!title)
  title = "";

return title;
815}

817static void
818check_leader_window_title (CdkDisplay *display)
819{
CdkX11Display *display_x11 = CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))));

if (display_x11->leader_window && !display_x11->leader_window_title_set)
  {
    set_wm_name (display,
   display_x11->leader_window,
   get_default_title ());
    
    display_x11->leader_window_title_set = TRUE(!(0));
  }
830}

832static Window
833create_focus_window (CdkDisplay *display,
     XID         parent)
835{
CdkX11Display *display_x11;
CdkEventMask event_mask;
Display *xdisplay;
Window focus_window;
XSetWindowAttributes attrs;

xdisplay = CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
);
display_x11 = CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))));

focus_window = XCreateWindow (xdisplay, parent,
                              -1, -1, 1, 1, 0,
                              0, /* depth */
                              InputOnly2,
                              CopyFromParent0L,
                              0, &attrs);

event_mask = (CDK_KEY_PRESS_MASK |
              CDK_KEY_RELEASE_MASK |
              CDK_FOCUS_CHANGE_MASK);

cdk_x11_event_source_select_events ((CdkEventSource *) display_x11->event_source,
                                    focus_window,
                                    event_mask, 0);

XMapWindow (xdisplay, focus_window);

return focus_window;
863}

865static void
866ensure_sync_counter (CdkWindow *window)
867{
868#ifdef HAVE_XSYNC1
if (!CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  {
    CdkDisplay *display = CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display);
    CdkToplevelX11 *toplevel = _cdk_x11_window_get_toplevel (window);

    if (toplevel &&
 toplevel->update_counter == None0L &&
 CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->use_sync)
{
 Display *xdisplay = CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
);
 XSyncValue value;
 Atom atom;
 XID counters[2];

 XSyncIntToValue (&value, 0);
 
 toplevel->update_counter = XSyncCreateCounter (xdisplay, value);
 toplevel->extended_update_counter = XSyncCreateCounter (xdisplay, value);
 
 atom = cdk_x11_get_xatom_by_name_for_display (display,
					"_NET_WM_SYNC_REQUEST_COUNTER");

 counters[0] = toplevel->update_counter;
 counters[1] = toplevel->extended_update_counter;
 XChangeProperty (xdisplay, CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
	   atom, XA_CARDINAL((Atom) 6),
	   32, PropModeReplace0,
	   (guchar *)counters, 2);
 
 toplevel->current_counter_value = 0;
}
  }
901#endif
902}

904static void
905setup_toplevel_window (CdkWindow *window, 
       CdkWindow *parent)
907{
CdkToplevelX11 *toplevel = _cdk_x11_window_get_toplevel (window);
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));
CdkDisplay *display = cdk_window_get_display (window);
Display *xdisplay = CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay);
XID xid = CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid);
CdkX11Screen *x11_screen = CDK_X11_SCREEN (CDK_WINDOW_SCREEN (parent))((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (parent)))), ((cdk_x11_screen_get_type
 ()))))));
XSizeHints size_hints;
Window leader_window;

set_wm_protocols (window);

if (!window->input_only)
  {
    /* The focus window is off the visible area, and serves to receive key
     * press events so they don't get sent to child windows.
     */
    toplevel->focus_window = create_focus_window (display, xid);
    _cdk_x11_display_add_window (x11_screen->display,
                                 &toplevel->focus_window,
                                 window);
  }

check_leader_window_title (x11_screen->display);

/* FIXME: Is there any point in doing this? Do any WM's pay
 * attention to PSize, and even if they do, is this the
 * correct value???
 */
size_hints.flags = PSize(1L << 3);
size_hints.width = window->width * impl->window_scale;
size_hints.height = window->height * impl->window_scale;

XSetWMNormalHints (xdisplay, xid, &size_hints);

/* This will set WM_CLIENT_MACHINE and WM_LOCALE_NAME */
XSetWMProperties (xdisplay, xid, NULL((void*)0), NULL((void*)0), NULL((void*)0), 0, NULL((void*)0), NULL((void*)0), NULL((void*)0));

if (!cdk_running_in_sandbox ())
  {
    /* if sandboxed, we're likely in a pid namespace and would only confuse the wm with this */
    long pid = getpid ();
    XChangeProperty (xdisplay, xid,
                     cdk_x11_get_xatom_by_name_for_display (x11_screen->display, "_NET_WM_PID"),
                     XA_CARDINAL((Atom) 6), 32,
                     PropModeReplace0,
                     (guchar *)&pid, 1);
  }

leader_window = CDK_X11_DISPLAY (x11_screen->display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((x11_screen->display)), ((cdk_x11_display_get_type()))
))))->leader_window;
if (!leader_window)
  leader_window = xid;
XChangeProperty (xdisplay, xid, 
   cdk_x11_get_xatom_by_name_for_display (x11_screen->display, "WM_CLIENT_LEADER"),
   XA_WINDOW((Atom) 33), 32, PropModeReplace0,
   (guchar *) &leader_window, 1);

if (toplevel->focus_window != None0L)
  XChangeProperty (xdisplay, xid, 
                   cdk_x11_get_xatom_by_name_for_display (x11_screen->display, "_NET_WM_USER_TIME_WINDOW"),
                   XA_WINDOW((Atom) 33), 32, PropModeReplace0,
                   (guchar *) &toplevel->focus_window, 1);

if (!window->focus_on_map)
  cdk_x11_window_set_user_time (window, 0);
else if (CDK_X11_DISPLAY (x11_screen->display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((x11_screen->display)), ((cdk_x11_display_get_type()))
))))->user_time != 0)
  cdk_x11_window_set_user_time (window, CDK_X11_DISPLAY (x11_screen->display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((x11_screen->display)), ((cdk_x11_display_get_type()))
))))->user_time);

ensure_sync_counter (window);

/* Start off in a frozen state - we'll finish this when we first paint */
cdk_x11_window_begin_frame (window, TRUE(!(0)));
979}

981static void
982on_frame_clock_before_paint (CdkFrameClock *clock G_GNUC_UNUSED__attribute__ ((__unused__)),
                           CdkWindow     *window)
984{
cdk_x11_window_predict_presentation_time (window);
cdk_x11_window_begin_frame (window, FALSE(0));
987}

989static void
990on_frame_clock_after_paint (CdkFrameClock *clock G_GNUC_UNUSED__attribute__ ((__unused__)),
                          CdkWindow     *window)
992{
cdk_x11_window_end_frame (window);

995}

997static void
998connect_frame_clock (CdkWindow *window)
999{
CdkWindowImplX11 *impl;

impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));
if (WINDOW_IS_TOPLEVEL (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
) && !impl->frame_clock_connected)
  {
    CdkFrameClock *frame_clock = cdk_window_get_frame_clock (window);

    g_signal_connect (frame_clock, "before-paint",g_signal_connect_data ((frame_clock), ("before-paint"), (((GCallback
) (on_frame_clock_before_paint))), (window), ((void*)0), (GConnectFlags
) 0)
                      G_CALLBACK (on_frame_clock_before_paint), window)g_signal_connect_data ((frame_clock), ("before-paint"), (((GCallback
) (on_frame_clock_before_paint))), (window), ((void*)0), (GConnectFlags
) 0);
    g_signal_connect (frame_clock, "after-paint",g_signal_connect_data ((frame_clock), ("after-paint"), (((GCallback
) (on_frame_clock_after_paint))), (window), ((void*)0), (GConnectFlags
) 0)
                      G_CALLBACK (on_frame_clock_after_paint), window)g_signal_connect_data ((frame_clock), ("after-paint"), (((GCallback
) (on_frame_clock_after_paint))), (window), ((void*)0), (GConnectFlags
) 0);

    impl->frame_clock_connected = TRUE(!(0));
  }
1014}

1016static void
1017clamp_window_size (CdkWindow *window,
                 gint      *width,
                 gint      *height)
1020{
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));

if (*width * impl->window_scale > 32767 ||
    *height * impl->window_scale > 32767)
  {
    g_warning ("Native Windows wider or taller than 32767 pixels are not supported");

    if (*width * impl->window_scale > 32767)
      *width = 32767 / impl->window_scale;
    if (*height  * impl->window_scale > 32767)
      *height = 32767 /  impl->window_scale;
  }
1033}

1035void
1036_cdk_x11_display_create_window_impl (CdkDisplay    *display,
                                   CdkWindow     *window,
                                   CdkWindow     *real_parent,
                                   CdkScreen     *screen,
                                   CdkEventMask   event_mask,
                                   CdkWindowAttr *attributes,
                                   gint           attributes_mask)
1043{
CdkWindowImplX11 *impl;
CdkX11Screen *x11_screen;
CdkX11Display *display_x11;

Window xparent;
Visual *xvisual;
Display *xdisplay;

XSetWindowAttributes xattributes;
long xattributes_mask;

unsigned int class;
const char *title;

display_x11 = CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))));
xparent = CDK_WINDOW_XID (real_parent)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((real_parent)), ((cdk_window_get_type ())
)))))->impl)), ((cdk_window_impl_x11_get_type ()))))))->
xid);
x11_screen = CDK_X11_SCREEN (screen)((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((screen)), ((cdk_x11_screen_get_type ()))))));

impl = g_object_new (CDK_TYPE_WINDOW_IMPL_X11(cdk_window_impl_x11_get_type ()), NULL((void*)0));
window->impl = CDK_WINDOW_IMPL (impl)((((CdkWindowImpl*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((impl)), ((cdk_window_impl_get_type ()))))));
impl->wrapper = CDK_WINDOW (window)((((CdkWindow*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window)), ((cdk_window_get_type ()))))));
impl->window_scale = x11_screen->window_scale;

xdisplay = x11_screen->xdisplay;

xattributes_mask = 0;

xvisual = cdk_x11_visual_get_xvisual (window->visual);

if (attributes_mask & CDK_WA_NOREDIR)
  {
    xattributes.override_redirect =
      (attributes->override_redirect == FALSE(0))?False0:True1;
    xattributes_mask |= CWOverrideRedirect(1L<<9);
  }
else
  xattributes.override_redirect = False0;

impl->override_redirect = xattributes.override_redirect;

/* This event mask will be set near the end of the function, but to avoid some
 * races, the window has to be created with this mask already.
 */
xattributes.event_mask = StructureNotifyMask(1L<<17) | PropertyChangeMask(1L<<22);
xattributes_mask |= CWEventMask(1L<<11);

/* Sanity checks */
switch (window->window_type)
  {
  case CDK_WINDOW_TOPLEVEL:
  case CDK_WINDOW_TEMP:
    if (CDK_WINDOW_TYPE (window->parent)((((CdkWindow *)(window->parent)))->window_type) != CDK_WINDOW_ROOT)
      {
        /* The common code warns for this case */
        xparent = CDK_SCREEN_XROOTWIN (screen)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((screen)), ((cdk_x11_screen_get_type ()))))))->xroot_window
);
      }
  }

if (!window->input_only)
  {
    class = InputOutput1;

    xattributes.background_pixel = BlackPixel (xdisplay, x11_screen->screen_num)((&((_XPrivDisplay)(xdisplay))->screens[x11_screen->
screen_num])->black_pixel);

    xattributes.border_pixel = BlackPixel (xdisplay, x11_screen->screen_num)((&((_XPrivDisplay)(xdisplay))->screens[x11_screen->
screen_num])->black_pixel);
    xattributes_mask |= CWBorderPixel(1L<<3) | CWBackPixel(1L<<1);

    xattributes.bit_gravity = NorthWestGravity1;
    xattributes_mask |= CWBitGravity(1L<<4);

    xattributes.colormap = _cdk_visual_get_x11_colormap (window->visual);
    xattributes_mask |= CWColormap(1L<<13);

    if (window->window_type == CDK_WINDOW_TEMP)
      {
        xattributes.save_under = True1;
        xattributes.override_redirect = True1;
        xattributes.cursor = None0L;
        xattributes_mask |= CWSaveUnder(1L<<10) | CWOverrideRedirect(1L<<9);

        impl->override_redirect = TRUE(!(0));
      }
  }
else
  {
    class = InputOnly2;
  }

clamp_window_size (window, &window->width, &window->height);

impl->unscaled_width = window->width * impl->window_scale;
impl->unscaled_height = window->height * impl->window_scale;

impl->xid = XCreateWindow (xdisplay, xparent,
                           (window->x + window->parent->abs_x) * impl->window_scale,
                           (window->y + window->parent->abs_y) * impl->window_scale,
                           window->width * impl->window_scale, window->height * impl->window_scale,
                           0, window->depth, class, xvisual,
                           xattributes_mask, &xattributes);

g_object_ref (window)((__typeof__ (window)) (g_object_ref) (window));
_cdk_x11_display_add_window (x11_screen->display, &impl->xid, window);

switch (CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type))
  {
  case CDK_WINDOW_TOPLEVEL:
  case CDK_WINDOW_TEMP:
    if (attributes_mask & CDK_WA_TITLE)
      title = attributes->title;
    else
      title = get_default_title ();

    cdk_window_set_title (window, title);

    if (attributes_mask & CDK_WA_WMCLASS)
      {
        XClassHint *class_hint;

        class_hint = XAllocClassHint ();
        class_hint->res_name = attributes->wmclass_name;
        class_hint->res_class = attributes->wmclass_class;
        XSetClassHint (xdisplay, impl->xid, class_hint);
        XFree (class_hint);
      }

    setup_toplevel_window (window, window->parent);
    break;

  case CDK_WINDOW_CHILD:
  default:
    break;
  }

if (attributes_mask & CDK_WA_TYPE_HINT)
  cdk_window_set_type_hint (window, attributes->type_hint);

if (!window->input_only)
  cdk_window_x11_set_background (window, NULL((void*)0));

cdk_x11_event_source_select_events ((CdkEventSource *) display_x11->event_source,
                                    CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid), event_mask,
                                    StructureNotifyMask(1L<<17) | PropertyChangeMask(1L<<22));

connect_frame_clock (window);

if (CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type) != CDK_WINDOW_CHILD)
  cdk_window_freeze_toplevel_updates (window);
1191}

1193static CdkEventMask
1194x_event_mask_to_cdk_event_mask (long mask)
1195{
CdkEventMask event_mask = 0;
int i;

for (i = 0; i < _cdk_x11_event_mask_table_size; i++)
  {
    if (mask & _cdk_x11_event_mask_table[i])
event_mask |= 1 << (i + 1);
  }

return event_mask;
1206}

1208/**
* cdk_x11_window_foreign_new_for_display:
* @display: (type CdkX11Display): the #CdkDisplay where the window handle comes from.
* @window: an Xlib Window
*
* Wraps a native window in a #CdkWindow. The function will try to
* look up the window using cdk_x11_window_lookup_for_display() first.
* If it does not find it there, it will create a new window.
*
* This may fail if the window has been destroyed. If the window
* was already known to CDK, a new reference to the existing
* #CdkWindow is returned.
*
* Returns: (transfer full): a #CdkWindow wrapper for the native
*   window, or %NULL if the window has been destroyed. The wrapper
*   will be newly created, if one doesn’t exist already.
*
* Since: 2.24
*/
1227CdkWindow *
1228cdk_x11_window_foreign_new_for_display (CdkDisplay *display,
                                      Window      window)
1230{
CdkScreen *screen;
CdkWindow *win;
CdkWindowImplX11 *impl;
CdkX11Display *display_x11;
XWindowAttributes attrs;
Window root, parent;
Window *children = NULL((void*)0);
guint nchildren;
gboolean result;

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

display_x11 = CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))));

if ((win = cdk_x11_window_lookup_for_display (display, window)) != NULL((void*)0))
  return g_object_ref (win)((__typeof__ (win)) (g_object_ref) (win));

cdk_x11_display_error_trap_push (display);
result = XGetWindowAttributes (display_x11->xdisplay, window, &attrs);
if (cdk_x11_display_error_trap_pop (display) || !result)
  return NULL((void*)0);

/* FIXME: This is pretty expensive.
 * Maybe the caller should supply the parent
 */
cdk_x11_display_error_trap_push (display);
result = XQueryTree (display_x11->xdisplay, window, &root, &parent, &children, &nchildren);
if (cdk_x11_display_error_trap_pop (display) || !result)
  return NULL((void*)0);

if (children)
  XFree (children);

screen = _cdk_x11_display_screen_for_xrootwin (display, root);
if (screen == NULL((void*)0))
  return NULL((void*)0);

win = _cdk_display_create_window (display);
win->impl = g_object_new (CDK_TYPE_WINDOW_IMPL_X11(cdk_window_impl_x11_get_type ()), NULL((void*)0));
win->impl_window = win;
win->visual = cdk_x11_screen_lookup_visual (screen,
                                            XVisualIDFromVisual (attrs.visual));

impl = CDK_WINDOW_IMPL_X11 (win->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((win->impl)), ((cdk_window_impl_x11_get_type
 ()))))));
impl->wrapper = win;
impl->window_scale = CDK_X11_SCREEN (screen)((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((screen)), ((cdk_x11_screen_get_type ()))))))->window_scale;

win->parent = cdk_x11_window_lookup_for_display (display, parent);

if (!win->parent || CDK_WINDOW_TYPE (win->parent)((((CdkWindow *)(win->parent)))->window_type) == CDK_WINDOW_FOREIGN)
  win->parent = cdk_screen_get_root_window (screen);

win->parent->children = g_list_concat (&win->children_list_node, win->parent->children);
win->parent->impl_window->native_children =
  g_list_prepend (win->parent->impl_window->native_children, win);

impl->xid = window;

win->x = attrs.x / impl->window_scale;
win->y = attrs.y / impl->window_scale;
impl->unscaled_width = attrs.width;
impl->unscaled_height = attrs.height;
win->width = attrs.width / impl->window_scale;
win->height = attrs.height  / impl->window_scale;
win->window_type = CDK_WINDOW_FOREIGN;
win->destroyed = FALSE(0);

win->event_mask = x_event_mask_to_cdk_event_mask (attrs.your_event_mask);

if (attrs.map_state == IsUnmapped0)
  win->state = CDK_WINDOW_STATE_WITHDRAWN;
else
  win->state = 0;
win->viewable = TRUE(!(0));

win->depth = attrs.depth;

g_object_ref (win)((__typeof__ (win)) (g_object_ref) (win));
_cdk_x11_display_add_window (display, &CDK_WINDOW_XID (win)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((win)), ((cdk_window_get_type ()))))))->
impl)), ((cdk_window_impl_x11_get_type ()))))))->xid), win);

/* Update the clip region, etc */
_cdk_window_update_size (win);

return win;
1315}

1317static void
1318cdk_toplevel_x11_free_contents (CdkDisplay *display,
		CdkToplevelX11 *toplevel)
1320{
if (toplevel->icon_pixmap)
  {
    cairo_surface_destroy (toplevel->icon_pixmap);
    toplevel->icon_pixmap = NULL((void*)0);
  }
if (toplevel->icon_mask)
  {
    cairo_surface_destroy (toplevel->icon_mask);
    toplevel->icon_mask = NULL((void*)0);
  }
if (toplevel->group_leader)
  {
    g_object_unref (toplevel->group_leader);
    toplevel->group_leader = NULL((void*)0);
  }
1336#ifdef HAVE_XSYNC1
if (toplevel->update_counter != None0L)
  {
    XSyncDestroyCounter (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), 
	   toplevel->update_counter);
    XSyncDestroyCounter (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
),
                         toplevel->extended_update_counter);
    toplevel->update_counter = None0L;
    toplevel->extended_update_counter = None0L;

    toplevel->current_counter_value = 0;
  }
1348#endif
1349}

1351static void
1352cdk_x11_window_destroy (CdkWindow *window,
                      gboolean   recursing,
                      gboolean   foreign_destroy)
1355{
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));
CdkToplevelX11 *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);

_cdk_x11_selection_window_destroyed (window);

toplevel = _cdk_x11_window_get_toplevel (window);
if (toplevel)
  cdk_toplevel_x11_free_contents (CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display), toplevel);

unhook_surface_changed (window);

if (impl->cairo_surface)
  {
    cairo_surface_finish (impl->cairo_surface);
    cairo_surface_destroy (impl->cairo_surface);
    impl->cairo_surface = NULL((void*)0);
  }

if (!recursing && !foreign_destroy)
  XDestroyWindow (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay), CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid));
1378}

1380static void
1381cdk_x11_window_destroy_foreign (CdkWindow *window)
1382{
/* It's somebody else's window, but in our hierarchy,
 * so reparent it to the root window, and then send
 * it a delete event, as if we were a WM
 */
XClientMessageEvent xclient;
CdkDisplay *display;

display = CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display);
cdk_x11_display_error_trap_push (display);
cdk_window_hide (window);
cdk_window_reparent (window, NULL((void*)0), 0, 0);

memset (&xclient, 0, sizeof (xclient));
xclient.type = ClientMessage33;
xclient.window = CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid);
xclient.message_type = cdk_x11_get_xatom_by_name_for_display (display, "WM_PROTOCOLS");
xclient.format = 32;
xclient.data.l[0] = cdk_x11_get_xatom_by_name_for_display (display, "WM_DELETE_WINDOW");
xclient.data.l[1] = CurrentTime0L;
xclient.data.l[2] = 0;
xclient.data.l[3] = 0;
xclient.data.l[4] = 0;

XSendEvent (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
            CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
            False0, 0, (XEvent *)&xclient);
cdk_x11_display_error_trap_pop_ignored (display);
1410}

1412static CdkWindow *
1413get_root (CdkWindow *window)
1414{
CdkScreen *screen = cdk_window_get_screen (window);

return cdk_screen_get_root_window (screen);
1418}

1420/* This function is called when the XWindow is really gone.
*/
1422static void
1423cdk_x11_window_destroy_notify (CdkWindow *window)
1424{
CdkWindowImplX11 *window_impl;

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

if (!CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  {
    if (CDK_WINDOW_TYPE(window)((((CdkWindow *)(window)))->window_type) != CDK_WINDOW_FOREIGN)
g_warning ("CdkWindow %#lx unexpectedly destroyed", CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid));

    _cdk_window_destroy (window, TRUE(!(0)));
  }

_cdk_x11_display_remove_window (CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display), CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid));
if (window_impl->toplevel && window_impl->toplevel->focus_window)
  _cdk_x11_display_remove_window (CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display), window_impl->toplevel->focus_window);

_cdk_x11_window_grab_check_destroy (window);

g_object_unref (window);
1444}

1446static CdkDragProtocol
1447cdk_x11_window_get_drag_protocol (CdkWindow *window,
                                CdkWindow **target)
1449{
CdkDragProtocol protocol;
CdkDisplay *display;
guint version;
Window xid;

display = cdk_window_get_display (window);
xid = _cdk_x11_display_get_drag_protocol (display,
                                          CDK_WINDOW_XID (window->impl_window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window->impl_window)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid),
                                          &protocol,
                                          &version);

if (target)
  {
    if (xid != None0L)
      *target = cdk_x11_window_foreign_new_for_display (display, xid);
    else
      *target = NULL((void*)0);
  }

return protocol;
1470}

1472static void
1473update_wm_hints (CdkWindow *window,
 gboolean   force)
1475{
CdkToplevelX11 *toplevel = _cdk_x11_window_get_toplevel (window);
CdkDisplay *display = CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display);
XWMHints wm_hints;

if (!force &&
    !toplevel->is_leader &&
    window->state & CDK_WINDOW_STATE_WITHDRAWN)
  return;

wm_hints.flags = StateHint(1L << 1) | InputHint(1L << 0);
wm_hints.input = window->accept_focus ? True1 : False0;
wm_hints.initial_state = NormalState1;

if (window->state & CDK_WINDOW_STATE_ICONIFIED)
  {
    wm_hints.flags |= StateHint(1L << 1);
    wm_hints.initial_state = IconicState3;
  }

if (toplevel->icon_pixmap)
  {
    wm_hints.flags |= IconPixmapHint(1L << 2);
    wm_hints.icon_pixmap = cairo_xlib_surface_get_drawable (toplevel->icon_pixmap);
  }

if (toplevel->icon_mask)
  {
    wm_hints.flags |= IconMaskHint(1L << 5);
    wm_hints.icon_mask = cairo_xlib_surface_get_drawable (toplevel->icon_mask);
  }

wm_hints.flags |= WindowGroupHint(1L << 6);
if (toplevel->group_leader && !CDK_WINDOW_DESTROYED (toplevel->group_leader)(((CdkWindow *)(toplevel->group_leader))->destroyed))
  {
    wm_hints.flags |= WindowGroupHint(1L << 6);
    wm_hints.window_group = CDK_WINDOW_XID (toplevel->group_leader)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((toplevel->group_leader)), ((cdk_window_get_type
 ()))))))->impl)), ((cdk_window_impl_x11_get_type ()))))))
->xid);
  }
else
  wm_hints.window_group = CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->leader_window;

if (toplevel->urgency_hint)
  wm_hints.flags |= XUrgencyHint(1L << 8);

XSetWMHints (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
      CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
      &wm_hints);
1522}

1524static void
1525set_initial_hints (CdkWindow *window)
1526{
CdkDisplay *display = CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display);
Display *xdisplay = CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
);
Window xwindow = CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid);  
CdkToplevelX11 *toplevel;
Atom atoms[9];
gint i;

toplevel = _cdk_x11_window_get_toplevel (window);

if (!toplevel)
  return;

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

/* We set the spec hints regardless of whether the spec is supported,
 * since it can't hurt and it's kind of expensive to check whether
 * it's supported.
 */

i = 0;

if (window->state & CDK_WINDOW_STATE_MAXIMIZED)
  {
    atoms[i] = cdk_x11_get_xatom_by_name_for_display (display,
					"_NET_WM_STATE_MAXIMIZED_VERT");
    ++i;
    atoms[i] = cdk_x11_get_xatom_by_name_for_display (display,
					"_NET_WM_STATE_MAXIMIZED_HORZ");
    ++i;
    toplevel->have_maxhorz = toplevel->have_maxvert = TRUE(!(0));
  }

if (window->state & CDK_WINDOW_STATE_ABOVE)
  {
    atoms[i] = cdk_x11_get_xatom_by_name_for_display (display,
					"_NET_WM_STATE_ABOVE");
    ++i;
  }

if (window->state & CDK_WINDOW_STATE_BELOW)
  {
    atoms[i] = cdk_x11_get_xatom_by_name_for_display (display,
					"_NET_WM_STATE_BELOW");
    ++i;
  }

if (window->state & CDK_WINDOW_STATE_STICKY)
  {
    atoms[i] = cdk_x11_get_xatom_by_name_for_display (display,
					"_NET_WM_STATE_STICKY");
    ++i;
    toplevel->have_sticky = TRUE(!(0));
  }

if (window->state & CDK_WINDOW_STATE_FULLSCREEN)
  {
    atoms[i] = cdk_x11_get_xatom_by_name_for_display (display,
					"_NET_WM_STATE_FULLSCREEN");
    ++i;
    toplevel->have_fullscreen = TRUE(!(0));
  }

if (window->modal_hint)
  {
    atoms[i] = cdk_x11_get_xatom_by_name_for_display (display,
					"_NET_WM_STATE_MODAL");
    ++i;
  }

if (toplevel->skip_taskbar_hint)
  {
    atoms[i] = cdk_x11_get_xatom_by_name_for_display (display,
					"_NET_WM_STATE_SKIP_TASKBAR");
    ++i;
  }

if (toplevel->skip_pager_hint)
  {
    atoms[i] = cdk_x11_get_xatom_by_name_for_display (display,
					"_NET_WM_STATE_SKIP_PAGER");
    ++i;
  }

if (window->state & CDK_WINDOW_STATE_ICONIFIED)
  {
    atoms[i] = cdk_x11_get_xatom_by_name_for_display (display,
					"_NET_WM_STATE_HIDDEN");
    ++i;
    toplevel->have_hidden = TRUE(!(0));
  }

if (i > 0)
  {
    XChangeProperty (xdisplay,
                     xwindow,
       cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE"),
                     XA_ATOM((Atom) 4), 32, PropModeReplace0,
                     (guchar*) atoms, i);
  }
else 
  {
    XDeleteProperty (xdisplay,
                     xwindow,
       cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE"));
  }

if (window->state & CDK_WINDOW_STATE_STICKY)
  {
    atoms[0] = 0xFFFFFFFF;
    XChangeProperty (xdisplay,
                     xwindow,
       cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_DESKTOP"),
                     XA_CARDINAL((Atom) 6), 32, PropModeReplace0,
                     (guchar*) atoms, 1);
    toplevel->on_all_desktops = TRUE(!(0));
  }
else
  {
    XDeleteProperty (xdisplay,
                     xwindow,
       cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_DESKTOP"));
  }

toplevel->map_serial = NextRequest (xdisplay)(((_XPrivDisplay)(xdisplay))->request + 1);
1651}

1653static void
1654cdk_window_x11_show (CdkWindow *window, gboolean already_mapped)
1655{
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));
Display *xdisplay = CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay);
Window xwindow = CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid);
gboolean unset_bg;

if (!already_mapped)
  set_initial_hints (window);
    
if (WINDOW_IS_TOPLEVEL (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
))
  {
    CdkDisplay *display;
    CdkX11Display *display_x11;
    CdkToplevelX11 *toplevel;

    display = cdk_window_get_display (window);
    display_x11 = CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))));
    toplevel = _cdk_x11_window_get_toplevel (window);
    
    if (toplevel->user_time != 0 &&
     display_x11->user_time != 0 &&
 XSERVER_TIME_IS_LATER (display_x11->user_time, toplevel->user_time)( (( display_x11->user_time > toplevel->user_time ) &&
 ( display_x11->user_time - toplevel->user_time < ((
guint32)-1)/2 )) || (( display_x11->user_time < toplevel
->user_time ) && ( toplevel->user_time - display_x11
->user_time > ((guint32)-1)/2 )) ))
cdk_x11_window_set_user_time (window, display_x11->user_time);
  }

unset_bg = !window->input_only &&
  (window->window_type == CDK_WINDOW_CHILD ||
   impl->override_redirect) &&
  cdk_window_is_viewable (window);

if (unset_bg)
  _cdk_x11_window_tmp_unset_bg (window, TRUE(!(0)));

XMapWindow (xdisplay, xwindow);

if (unset_bg)
  _cdk_x11_window_tmp_reset_bg (window, TRUE(!(0)));

/* Fullscreen on current monitor is the default, no need to apply this mode
 * when mapping a window. This also ensures that the default behavior remains
 * consistent with pre-fullscreen mode implementation.
 */
if (window->fullscreen_mode != CDK_FULLSCREEN_ON_CURRENT_MONITOR)
  cdk_x11_window_apply_fullscreen_mode (window);
1699}

1701static void
1702pre_unmap (CdkWindow *window)
1703{
CdkWindow *start_window = NULL((void*)0);

if (window->input_only)
  return;

if (window->window_type == CDK_WINDOW_CHILD)
  start_window = _cdk_window_get_impl_window ((CdkWindow *)window->parent);
else if (window->window_type == CDK_WINDOW_TEMP)
  start_window = get_root (window);

if (start_window)
  _cdk_x11_window_tmp_unset_bg (start_window, TRUE(!(0)));
1716}

1718static void
1719post_unmap (CdkWindow *window)
1720{
CdkWindow *start_window = NULL((void*)0);

if (window->input_only)
  return;

if (window->window_type == CDK_WINDOW_CHILD)
  start_window = _cdk_window_get_impl_window ((CdkWindow *)window->parent);
else if (window->window_type == CDK_WINDOW_TEMP)
  start_window = get_root (window);

if (start_window)
  {
    _cdk_x11_window_tmp_reset_bg (start_window, TRUE(!(0)));

    if (window->window_type == CDK_WINDOW_CHILD && window->parent)
{
 CdkRectangle invalid_rect;
    
 cdk_window_get_position (window, &invalid_rect.x, &invalid_rect.y);
 invalid_rect.width = cdk_window_get_width (window);
 invalid_rect.height = cdk_window_get_height (window);
 cdk_window_invalidate_rect ((CdkWindow *)window->parent,
		      &invalid_rect, TRUE(!(0)));
}
  }
1746}

1748static void
1749cdk_window_x11_hide (CdkWindow *window)
1750{
/* We'll get the unmap notify eventually, and handle it then,
 * but checking here makes things more consistent if we are
 * just doing stuff ourself.
 */
_cdk_x11_window_grab_check_unmap (window,
                                  NextRequest (CDK_WINDOW_XDISPLAY (window))(((_XPrivDisplay)((((((CdkX11Screen*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay)))->request + 1));

/* You can't simply unmap toplevel windows. */
switch (window->window_type)
  {
  case CDK_WINDOW_TOPLEVEL:
  case CDK_WINDOW_TEMP: /* ? */
    cdk_window_withdraw (window);
    return;
    
  case CDK_WINDOW_FOREIGN:
  case CDK_WINDOW_ROOT:
  case CDK_WINDOW_CHILD:
    break;
  }

_cdk_window_clear_update_area (window);

pre_unmap (window);
XUnmapWindow (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid));
post_unmap (window);
1778}

1780static void
1781cdk_window_x11_withdraw (CdkWindow *window)
1782{
if (!window->destroyed)
  {
    if (CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
      cdk_synthesize_window_state (window,
                                   0,
                                   CDK_WINDOW_STATE_WITHDRAWN);

    g_assert (!CDK_WINDOW_IS_MAPPED (window))do { if (!(((window)->state & CDK_WINDOW_STATE_WITHDRAWN
) == 0)) ; else g_assertion_message_expr ("Cdk", "cdkwindow-x11.c"
, 1790, ((const char*) (__func__)), "!CDK_WINDOW_IS_MAPPED (window)"
); } while (0);

    pre_unmap (window);
    
    XWithdrawWindow (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                     CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid), 0);

    post_unmap (window);
  }
1799}

1801static inline void
1802window_x11_move (CdkWindow *window,
               gint       x,
               gint       y)
1805{
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));

if (CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_CHILD)
  {
    /* The window isn't actually damaged, but it's parent is */
    window_pre_damage (window);
    _cdk_x11_window_move_resize_child (window,
                                       x, y,
                                       window->width, window->height);
  }
else
  {
    XMoveWindow (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                 CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                 x * impl->window_scale, y * impl->window_scale);

    if (impl->override_redirect)
      {
        window->x = x;
        window->y = y;
      }
  }
1828}

1830static inline void
1831window_x11_resize (CdkWindow *window,
                 gint       width,
                 gint       height)
1834{
if (width < 1)
  width = 1;

if (height < 1)
  height = 1;

window_pre_damage (window);

if (CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_CHILD)
  {
    _cdk_x11_window_move_resize_child (window,
                                       window->x, window->y,
                                       width, height);
  }
else
  {
    CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));

    XResizeWindow (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                   CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                   width * impl->window_scale, height * impl->window_scale);

    if (impl->override_redirect)
      {
        impl->unscaled_width = width * impl->window_scale;
        impl->unscaled_height = height * impl->window_scale;
        window->width = width;
        window->height = height;
        _cdk_x11_window_update_size (CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ())))))));
      }
    else
      {
        if (width * impl->window_scale != impl->unscaled_width || height * impl->window_scale != impl->unscaled_height)
          window->resize_count += 1;
      }
  }
1871}

1873static inline void
1874window_x11_move_resize (CdkWindow *window,
                      gint       x,
                      gint       y,
                      gint       width,
                      gint       height)
1879{
if (width < 1)
  width = 1;

if (height < 1)
  height = 1;

window_pre_damage (window);

if (CDK_WINDOW_TYPE (window)((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_CHILD)
  {
    _cdk_x11_window_move_resize_child (window, x, y, width, height);
    _cdk_x11_window_update_size (CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ())))))));
  }
else
  {
    CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));

    XMoveResizeWindow (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                       CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                       x * impl->window_scale, y * impl->window_scale,
                       width * impl->window_scale, height * impl->window_scale);

    if (impl->override_redirect)
      {
        window->x = x;
        window->y = y;

        impl->unscaled_width = width * impl->window_scale;
        impl->unscaled_height = height * impl->window_scale;
        window->width = width;
        window->height = height;

        _cdk_x11_window_update_size (CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ())))))));
      }
    else
      {
        if (width * impl->window_scale != impl->unscaled_width || height * impl->window_scale != impl->unscaled_height)
          window->resize_count += 1;
      }
  }
1920}

1922static void
1923cdk_window_x11_move_resize (CdkWindow *window,
                          gboolean   with_move,
                          gint       x,
                          gint       y,
                          gint       width,
                          gint       height)
1929{
if (with_move && (width < 0 && height < 0))
  window_x11_move (window, x, y);
else
  {
    clamp_window_size (window, &width, &height);

    if (with_move)
      window_x11_move_resize (window, x, y, width, height);
    else
      window_x11_resize (window, width, height);
  }
1941}

1943static void
1944set_scale_recursive (CdkWindow *window, int scale)
1945{
GList *l;

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

    child = l->data;

    if (child->impl != window->impl)
      _cdk_x11_window_set_window_scale (child, scale);
    else
      set_scale_recursive (child, scale);
  }
1959}

1961void
1962_cdk_x11_window_set_window_scale (CdkWindow *window,
		  int scale)
1964{
CdkWindowImplX11 *impl;
CdkToplevelX11 *toplevel;
CdkWindowHints geom_mask;

if (window->window_type == CDK_WINDOW_OFFSCREEN)
  return;

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

impl->window_scale = scale;
if (impl->cairo_surface)
  cairo_surface_set_device_scale (impl->cairo_surface, impl->window_scale, impl->window_scale);
_cdk_window_update_size (window);

toplevel = _cdk_x11_window_get_toplevel (window);
if (toplevel && window->window_type != CDK_WINDOW_FOREIGN)
  {
    /* These are affected by window scale: */
    geom_mask = toplevel->last_geometry_hints_mask &
      (CDK_HINT_MIN_SIZE | CDK_HINT_MAX_SIZE | CDK_HINT_BASE_SIZE | CDK_HINT_RESIZE_INC);
    if (geom_mask)
      cdk_window_set_geometry_hints (window,
                                     &toplevel->last_geometry_hints,
                                     geom_mask);
  }

if (window->window_type == CDK_WINDOW_FOREIGN)
  XMoveWindow (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
               CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
               (window->x + window->parent->abs_x) * impl->window_scale,
               (window->y + window->parent->abs_y) * impl->window_scale);
else if (WINDOW_IS_TOPLEVEL(window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
))
  {
    if (impl->override_redirect)
      {
        impl->unscaled_width = window->width * impl->window_scale;
        impl->unscaled_height = window->height * impl->window_scale;
      }

    XResizeWindow (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                   CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                   window->width * impl->window_scale,
                   window->height * impl->window_scale);
  }
else
  {
    impl->unscaled_width = window->width * impl->window_scale;
    impl->unscaled_height = window->height * impl->window_scale;

    XMoveResizeWindow (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                       CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                       (window->x + window->parent->abs_x) * impl->window_scale,
                       (window->y + window->parent->abs_y) * impl->window_scale,
                       window->width * impl->window_scale,
                       window->height * impl->window_scale);
  }

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

set_scale_recursive (window, scale);
2025}

2027static gboolean
2028cdk_window_x11_reparent (CdkWindow *window,
                       CdkWindow *new_parent,
                       gint       x,
                       gint       y)
2032{
CdkWindowImplX11 *impl;

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

_cdk_x11_window_tmp_unset_bg (window, TRUE(!(0)));
_cdk_x11_window_tmp_unset_parent_bg (window);
XReparentWindow (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
   CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
   CDK_WINDOW_XID (new_parent)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((new_parent)), ((cdk_window_get_type ()))
))))->impl)), ((cdk_window_impl_x11_get_type ()))))))->
xid),
   (new_parent->abs_x + x)  * impl->window_scale,
                 (new_parent->abs_y + y) * impl->window_scale);
_cdk_x11_window_tmp_reset_parent_bg (window);
_cdk_x11_window_tmp_reset_bg (window, TRUE(!(0)));

if (WINDOW_IS_TOPLEVEL (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
))
  connect_frame_clock (window);
else
  /* old frame clock was disposed, our signal handlers removed */
  impl->frame_clock_connected = FALSE(0);

if (CDK_WINDOW_TYPE (new_parent)((((CdkWindow *)(new_parent)))->window_type) == CDK_WINDOW_FOREIGN)
  new_parent = cdk_screen_get_root_window (CDK_WINDOW_SCREEN (window)(cdk_window_get_screen (window)));

window->parent = new_parent;

/* 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:
    /* Reparenting to toplevel */
    
    if (!WINDOW_IS_TOPLEVEL (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
) &&
 CDK_WINDOW_TYPE (new_parent)((((CdkWindow *)(new_parent)))->window_type) == CDK_WINDOW_FOREIGN)
{
 /* This is also done in common code at a later stage, but we
    need it in setup_toplevel, so do it here too */
 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;
 
 /* Wasn't a toplevel, set up */
 setup_toplevel_window (window, new_parent);
}

    break;
    
  case CDK_WINDOW_TOPLEVEL:
  case CDK_WINDOW_CHILD:
  case CDK_WINDOW_TEMP:
    if (WINDOW_IS_TOPLEVEL (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
) &&
 impl->toplevel)
{
 if (impl->toplevel->focus_window)
   {
     XDestroyWindow (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay), impl->toplevel->focus_window);
            _cdk_x11_display_remove_window (CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display), impl->toplevel->focus_window);
   }
 
 cdk_toplevel_x11_free_contents (CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display), 
			  impl->toplevel);
 g_free (impl->toplevel);
 impl->toplevel = NULL((void*)0);
}
  }

return FALSE(0);
2102}

2104static void
2105cdk_window_x11_raise (CdkWindow *window)
2106{
XRaiseWindow (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay), CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid));
2108}

2110static void
2111cdk_window_x11_restack_under (CdkWindow *window,
	      GList *native_siblings /* in requested order, first is bottom-most */)
2113{
Window *windows;
int n_windows, i;
GList *l;

n_windows = g_list_length (native_siblings) + 1;
windows = g_new (Window, n_windows)((Window *) g_malloc_n ((n_windows), sizeof (Window)));

windows[0] = CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid);
/* Reverse order, as input order is bottom-most first */
i = n_windows - 1;
for (l = native_siblings; l != NULL((void*)0); l = l->next)
  windows[i--] = CDK_WINDOW_XID (l->data)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((l->data)), ((cdk_window_get_type ()))
))))->impl)), ((cdk_window_impl_x11_get_type ()))))))->
xid);

XRestackWindows (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay), windows, n_windows);

g_free (windows);
2130}

2132static void
2133cdk_window_x11_restack_toplevel (CdkWindow *window,
		 CdkWindow *sibling,
		 gboolean   above)
2136{
XWindowChanges changes;

changes.sibling = CDK_WINDOW_XID (sibling)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((sibling)), ((cdk_window_get_type ())))))
)->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid
);
changes.stack_mode = above ? Above0 : Below1;
XReconfigureWMWindow (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
	CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
	cdk_x11_screen_get_number (CDK_WINDOW_SCREEN (window)(cdk_window_get_screen (window))),
	CWStackMode(1<<6) | CWSibling(1<<5), &changes);
2145}

2147static void
2148cdk_window_x11_lower (CdkWindow *window)
2149{
XLowerWindow (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay), CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid));
2151}

2153/**
* cdk_x11_window_move_to_current_desktop:
* @window: (type CdkX11Window): a #CdkWindow
* 
* Moves the window to the correct workspace when running under a 
* window manager that supports multiple workspaces, as described
* in the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec) specification.
* Will not do anything if the window is already on all workspaces.
* 
* Since: 2.8
*/
2164void
2165cdk_x11_window_move_to_current_desktop (CdkWindow *window)
2166{
CdkToplevelX11 *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);
g_return_if_fail (CDK_WINDOW_TYPE (window) != CDK_WINDOW_CHILD)do { if ((((((CdkWindow *)(window)))->window_type) != CDK_WINDOW_CHILD
)) { } else { g_return_if_fail_warning ("Cdk", ((const char*)
 (__func__)), "CDK_WINDOW_TYPE (window) != CDK_WINDOW_CHILD")
; return; } } while (0);

toplevel = _cdk_x11_window_get_toplevel (window);

if (toplevel->on_all_desktops)
  return;

move_to_current_desktop (window);
2178}

2180static void
2181move_to_current_desktop (CdkWindow *window)
2182{
guint32 desktop;

desktop = cdk_x11_screen_get_current_desktop (CDK_WINDOW_SCREEN (window)(cdk_window_get_screen (window)));
cdk_x11_window_move_to_desktop (window, desktop);
2187}

2189static guint32
2190get_netwm_cardinal_property (CdkWindow   *window,
                           const gchar *name)
2192{
CdkScreen *screen = CDK_WINDOW_SCREEN (window)(cdk_window_get_screen (window));
CdkX11Screen *x11_screen = CDK_X11_SCREEN (screen)((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((screen)), ((cdk_x11_screen_get_type ()))))));
CdkAtom atom;
guint32 prop = 0;
Atom type;
gint format;
gulong nitems;
gulong bytes_after;
guchar *data;

atom = cdk_atom_intern_static_string (name);

if (!cdk_x11_screen_supports_net_wm_hint (screen, atom))
  return 0;

XGetWindowProperty (x11_screen->xdisplay,
                    CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                    cdk_x11_get_xatom_by_name_for_display (CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display), name),
                    0, G_MAXLONG9223372036854775807L,
                    False0, XA_CARDINAL((Atom) 6), &type, &format, &nitems,
                    &bytes_after, &data);
if (type == XA_CARDINAL((Atom) 6))
  {
    prop = *(gulong *)data;
    XFree (data);
  }

return prop;
2221}

2223/**
* cdk_x11_window_get_desktop:
* @window: (type CdkX11Window): a #CdkWindow
*
* Gets the number of the workspace @window is on.
*
* Returns: the current workspace of @window
*
* Since: 3.10
*/
2233guint32
2234cdk_x11_window_get_desktop (CdkWindow *window)
2235{
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 get_netwm_cardinal_property (window, "_NET_WM_DESKTOP");
2239}

2241/**
* cdk_x11_window_move_to_desktop:
* @window: (type CdkX11Window): a #CdkWindow
* @desktop: the number of the workspace to move the window to
*
* Moves the window to the given workspace when running unde a
* window manager that supports multiple workspaces, as described
* in the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec) specification.
*
* Since: 3.10
*/
2252void
2253cdk_x11_window_move_to_desktop (CdkWindow *window,
                              guint32    desktop)
2255{
CdkAtom atom;
XClientMessageEvent xclient;

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);

atom = cdk_atom_intern_static_string ("_NET_WM_DESKTOP");
if (!cdk_x11_screen_supports_net_wm_hint (CDK_WINDOW_SCREEN (window)(cdk_window_get_screen (window)), atom))
  return;

memset (&xclient, 0, sizeof (xclient));
xclient.type = ClientMessage33;
xclient.serial = 0;
xclient.send_event = True1;
xclient.window = CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid);
xclient.message_type = cdk_x11_atom_to_xatom_for_display (CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display), atom);
xclient.format = 32;

xclient.data.l[0] = desktop;
xclient.data.l[1] = 1; /* source indication */
xclient.data.l[2] = 0;
xclient.data.l[3] = 0;
xclient.data.l[4] = 0;

XSendEvent (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
            CDK_WINDOW_XROOTWIN (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xroot_window),
            False0,
            SubstructureRedirectMask(1L<<20) | SubstructureNotifyMask(1L<<19),
            (XEvent *)&xclient);
2284}

2286static void
2287cdk_x11_window_focus (CdkWindow *window,
      guint32    timestamp)
2289{
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) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

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

if (cdk_x11_screen_supports_net_wm_hint (CDK_WINDOW_SCREEN (window)(cdk_window_get_screen (window)),
			   cdk_atom_intern_static_string ("_NET_ACTIVE_WINDOW")))
  {
    XClientMessageEvent xclient;

    memset (&xclient, 0, sizeof (xclient));
    xclient.type = ClientMessage33;
    xclient.window = CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid);
    xclient.message_type = cdk_x11_get_xatom_by_name_for_display (display,
                                                                  "_NET_ACTIVE_WINDOW");
    xclient.format = 32;
    xclient.data.l[0] = 1; /* requestor type; we're an app */
    xclient.data.l[1] = timestamp;
    xclient.data.l[2] = None0L; /* currently active window */
    xclient.data.l[3] = 0;
    xclient.data.l[4] = 0;
    
    XSendEvent (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), CDK_WINDOW_XROOTWIN (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xroot_window), False0,
                SubstructureRedirectMask(1L<<20) | SubstructureNotifyMask(1L<<19),
                (XEvent *)&xclient);
  }
else
  {
    XRaiseWindow (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid));

    /* There is no way of knowing reliably whether we are viewable;
     * so trap errors asynchronously around the XSetInputFocus call
     */
    cdk_x11_display_error_trap_push (display);
    XSetInputFocus (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
),
                    CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                    RevertToParent2,
                    timestamp);
    cdk_x11_display_error_trap_pop_ignored (display);
  }
2335}

2337static void
2338cdk_x11_window_set_type_hint (CdkWindow        *window,
	      CdkWindowTypeHint hint)
2340{
CdkDisplay *display;
Atom atom;

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

display = cdk_window_get_display (window);

switch (hint)
  {
  case CDK_WINDOW_TYPE_HINT_DIALOG:
    atom = cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_DIALOG");
    break;
  case CDK_WINDOW_TYPE_HINT_MENU:
    atom = cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_MENU");
    break;
  case CDK_WINDOW_TYPE_HINT_TOOLBAR:
    atom = cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_TOOLBAR");
    break;
  case CDK_WINDOW_TYPE_HINT_UTILITY:
    atom = cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_UTILITY");
    break;
  case CDK_WINDOW_TYPE_HINT_SPLASHSCREEN:
    atom = cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_SPLASH");
    break;
  case CDK_WINDOW_TYPE_HINT_DOCK:
    atom = cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_DOCK");
    break;
  case CDK_WINDOW_TYPE_HINT_DESKTOP:
    atom = cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_DESKTOP");
    break;
  case CDK_WINDOW_TYPE_HINT_DROPDOWN_MENU:
    atom = cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU");
    break;
  case CDK_WINDOW_TYPE_HINT_POPUP_MENU:
    atom = cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_POPUP_MENU");
    break;
  case CDK_WINDOW_TYPE_HINT_TOOLTIP:
    atom = cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_TOOLTIP");
    break;
  case CDK_WINDOW_TYPE_HINT_NOTIFICATION:
    atom = cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_NOTIFICATION");
    break;
  case CDK_WINDOW_TYPE_HINT_COMBO:
    atom = cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_COMBO");
    break;
  case CDK_WINDOW_TYPE_HINT_DND:
    atom = cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_DND");
    break;
  default:
    g_warning ("Unknown hint %d passed to cdk_window_set_type_hint", hint);
    /* Fall thru */
  case CDK_WINDOW_TYPE_HINT_NORMAL:
    atom = cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_NORMAL");
    break;
  }

XChangeProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
   cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE"),
   XA_ATOM((Atom) 4), 32, PropModeReplace0,
   (guchar *)&atom, 1);
2403}

2405static CdkWindowTypeHint
2406cdk_x11_window_get_type_hint (CdkWindow *window)
2407{
CdkDisplay *display;
CdkWindowTypeHint type;
Atom type_return;
gint format_return;
gulong nitems_return;
gulong bytes_after_return;
guchar *data = NULL((void*)0);

g_return_val_if_fail (CDK_IS_WINDOW (window), CDK_WINDOW_TYPE_HINT_NORMAL)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_WINDOW_TYPE_HINT_NORMAL
); } } while (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return CDK_WINDOW_TYPE_HINT_NORMAL;

type = CDK_WINDOW_TYPE_HINT_NORMAL;

display = cdk_window_get_display (window);

if (XGetWindowProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                        cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE"),
                        0, G_MAXLONG9223372036854775807L, False0, XA_ATOM((Atom) 4), &type_return,
                        &format_return, &nitems_return, &bytes_after_return,
                        &data) == Success0)
  {
    if ((type_return == XA_ATOM((Atom) 4)) && (format_return == 32) &&
        (data) && (nitems_return == 1))
      {
        Atom atom = *(Atom*)data;

        if (atom == cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_DIALOG"))
          type = CDK_WINDOW_TYPE_HINT_DIALOG;
        else if (atom == cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_MENU"))
          type = CDK_WINDOW_TYPE_HINT_MENU;
        else if (atom == cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_TOOLBAR"))
          type = CDK_WINDOW_TYPE_HINT_TOOLBAR;
        else if (atom == cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_UTILITY"))
          type = CDK_WINDOW_TYPE_HINT_UTILITY;
        else if (atom == cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_SPLASH"))
          type = CDK_WINDOW_TYPE_HINT_SPLASHSCREEN;
        else if (atom == cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_DOCK"))
          type = CDK_WINDOW_TYPE_HINT_DOCK;
        else if (atom == cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_DESKTOP"))
          type = CDK_WINDOW_TYPE_HINT_DESKTOP;
 else if (atom == cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU"))
   type = CDK_WINDOW_TYPE_HINT_DROPDOWN_MENU;
 else if (atom == cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_POPUP_MENU"))
   type = CDK_WINDOW_TYPE_HINT_POPUP_MENU;
 else if (atom == cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_TOOLTIP"))
   type = CDK_WINDOW_TYPE_HINT_TOOLTIP;
 else if (atom == cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_NOTIFICATION"))
   type = CDK_WINDOW_TYPE_HINT_NOTIFICATION;
 else if (atom == cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_COMBO"))
   type = CDK_WINDOW_TYPE_HINT_COMBO;
 else if (atom == cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_TYPE_DND"))
   type = CDK_WINDOW_TYPE_HINT_DND;
      }

    if (type_return != None0L && data != NULL((void*)0))
      XFree (data);
  }

return type;
2470}

2472static void
2473cdk_wmspec_change_state (gboolean   add,
	 CdkWindow *window,
	 CdkAtom    state1,
	 CdkAtom    state2)
2477{
CdkDisplay *display = CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display);
XClientMessageEvent xclient;

2481#define _NET_WM_STATE_REMOVE0        0    /* remove/unset property */
2482#define _NET_WM_STATE_ADD1           1    /* add/set property */
2483#define _NET_WM_STATE_TOGGLE2        2    /* toggle property  */  

memset (&xclient, 0, sizeof (xclient));
xclient.type = ClientMessage33;
xclient.window = CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid);
xclient.message_type = cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE");
xclient.format = 32;
xclient.data.l[0] = add ? _NET_WM_STATE_ADD1 : _NET_WM_STATE_REMOVE0;
xclient.data.l[1] = cdk_x11_atom_to_xatom_for_display (display, state1);
xclient.data.l[2] = cdk_x11_atom_to_xatom_for_display (display, state2);
xclient.data.l[3] = 1; /* source indication */
xclient.data.l[4] = 0;

XSendEvent (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay), CDK_WINDOW_XROOTWIN (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xroot_window), False0,
     SubstructureRedirectMask(1L<<20) | SubstructureNotifyMask(1L<<19),
     (XEvent *)&xclient);
2499}

2501static void
2502cdk_x11_window_set_modal_hint (CdkWindow *window,
	       gboolean   modal)
2504{
if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

window->modal_hint = modal;

if (CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
  cdk_wmspec_change_state (modal, window,
	     cdk_atom_intern_static_string ("_NET_WM_STATE_MODAL"), 
	     CDK_NONE((CdkAtom)((gpointer) (gulong) (0))));
2515}

2517static void
2518cdk_x11_window_set_skip_taskbar_hint (CdkWindow *window,
		      gboolean   skips_taskbar)
2520{
CdkToplevelX11 *toplevel;

g_return_if_fail (CDK_WINDOW_TYPE (window) != CDK_WINDOW_CHILD)do { if ((((((CdkWindow *)(window)))->window_type) != CDK_WINDOW_CHILD
)) { } else { g_return_if_fail_warning ("Cdk", ((const char*)
 (__func__)), "CDK_WINDOW_TYPE (window) != CDK_WINDOW_CHILD")
; return; } } while (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

toplevel = _cdk_x11_window_get_toplevel (window);
toplevel->skip_taskbar_hint = skips_taskbar;

if (CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
  cdk_wmspec_change_state (skips_taskbar, window,
	     cdk_atom_intern_static_string ("_NET_WM_STATE_SKIP_TASKBAR"),
	     CDK_NONE((CdkAtom)((gpointer) (gulong) (0))));
2536}

2538static void
2539cdk_x11_window_set_skip_pager_hint (CdkWindow *window,
		    gboolean   skips_pager)
2541{
CdkToplevelX11 *toplevel;
  
g_return_if_fail (CDK_WINDOW_TYPE (window) != CDK_WINDOW_CHILD)do { if ((((((CdkWindow *)(window)))->window_type) != CDK_WINDOW_CHILD
)) { } else { g_return_if_fail_warning ("Cdk", ((const char*)
 (__func__)), "CDK_WINDOW_TYPE (window) != CDK_WINDOW_CHILD")
; return; } } while (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

toplevel = _cdk_x11_window_get_toplevel (window);
toplevel->skip_pager_hint = skips_pager;

if (CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
  cdk_wmspec_change_state (skips_pager, window,
	     cdk_atom_intern_static_string ("_NET_WM_STATE_SKIP_PAGER"), 
	     CDK_NONE((CdkAtom)((gpointer) (gulong) (0))));
2557}

2559static void
2560cdk_x11_window_set_urgency_hint (CdkWindow *window,
	     gboolean   urgent)
2562{
CdkToplevelX11 *toplevel;
  
g_return_if_fail (CDK_WINDOW_TYPE (window) != CDK_WINDOW_CHILD)do { if ((((((CdkWindow *)(window)))->window_type) != CDK_WINDOW_CHILD
)) { } else { g_return_if_fail_warning ("Cdk", ((const char*)
 (__func__)), "CDK_WINDOW_TYPE (window) != CDK_WINDOW_CHILD")
; return; } } while (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

toplevel = _cdk_x11_window_get_toplevel (window);
toplevel->urgency_hint = urgent;

update_wm_hints (window, FALSE(0));
2575}

2577static void
2578cdk_x11_window_set_geometry_hints (CdkWindow         *window,
		   const CdkGeometry *geometry,
		   CdkWindowHints     geom_mask)
2581{
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));
XSizeHints size_hints;
CdkToplevelX11 *toplevel;

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
1
Assuming field 'destroyed' is 0→
3
←
Taking false branch→
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
2
←
Assuming field 'window_type' is equal to CDK_WINDOW_TOPLEVEL→
  return;

toplevel = _cdk_x11_window_get_toplevel (window);
if (toplevel)
4
←
Assuming 'toplevel' is non-null→
5
←
Taking true branch→
  {
    if (geometry)
6
←
Assuming 'geometry' is null→
7
←
Taking false branch→
      toplevel->last_geometry_hints = *geometry;
    toplevel->last_geometry_hints_mask = geom_mask;
  }

size_hints.flags = 0;

if (geom_mask & CDK_HINT_POS)
8
←
Assuming the condition is false→
9
←
Taking false branch→
  {
    size_hints.flags |= PPosition(1L << 2);
    /* We need to initialize the following obsolete fields because KWM 
     * apparently uses these fields if they are non-zero.
     * #@#!#!$!.
     */
    size_hints.x = 0;
    size_hints.y = 0;
  }

if (geom_mask & CDK_HINT_USER_POS)
10
←
Assuming the condition is false→
11
←
Taking false branch→
  {
    size_hints.flags |= USPosition(1L << 0);
  }

if (geom_mask & CDK_HINT_USER_SIZE)
12
←
Assuming the condition is false→
13
←
Taking false branch→
  {
    size_hints.flags |= USSize(1L << 1);
  }

if (geom_mask & CDK_HINT_MIN_SIZE)
14
←
Assuming the condition is false→
15
←
Taking false branch→
  {
    size_hints.flags |= PMinSize(1L << 4);
    size_hints.min_width = geometry->min_width * impl->window_scale;
    size_hints.min_height = geometry->min_height * impl->window_scale;
  }

if (geom_mask & CDK_HINT_MAX_SIZE)
16
←
Assuming the condition is true→
17
←
Taking true branch→
  {
    size_hints.flags |= PMaxSize(1L << 5);
    size_hints.max_width = MAX (geometry->max_width, 1)(((geometry->max_width) > (1)) ? (geometry->max_width
) : (1)) * impl->window_scale;
18
←
Access to field 'max_width' results in a dereference of a null pointer (loaded from variable 'geometry')
    size_hints.max_height = MAX (geometry->max_height, 1)(((geometry->max_height) > (1)) ? (geometry->max_height
) : (1)) * impl->window_scale;
  }

if (geom_mask & CDK_HINT_BASE_SIZE)
  {
    size_hints.flags |= PBaseSize(1L << 8);
    size_hints.base_width = geometry->base_width * impl->window_scale;
    size_hints.base_height = geometry->base_height * impl->window_scale;
  }

if (geom_mask & CDK_HINT_RESIZE_INC)
  {
    size_hints.flags |= PResizeInc(1L << 6);
    size_hints.width_inc = geometry->width_inc * impl->window_scale;
    size_hints.height_inc = geometry->height_inc * impl->window_scale;
  }
else if (impl->window_scale > 1)
  {
    size_hints.flags |= PResizeInc(1L << 6);
    size_hints.width_inc = impl->window_scale;
    size_hints.height_inc = impl->window_scale;
  }

if (geom_mask & CDK_HINT_ASPECT)
  {
    size_hints.flags |= PAspect(1L << 7);
    if (geometry->min_aspect <= 1)
{
 size_hints.min_aspect.x = 65536 * geometry->min_aspect;
 size_hints.min_aspect.y = 65536;
}
    else
{
 size_hints.min_aspect.x = 65536;
 size_hints.min_aspect.y = 65536 / geometry->min_aspect;;
}
    if (geometry->max_aspect <= 1)
{
 size_hints.max_aspect.x = 65536 * geometry->max_aspect;
 size_hints.max_aspect.y = 65536;
}
    else
{
 size_hints.max_aspect.x = 65536;
 size_hints.max_aspect.y = 65536 / geometry->max_aspect;;
}
  }

if (geom_mask & CDK_HINT_WIN_GRAVITY)
  {
    size_hints.flags |= PWinGravity(1L << 9);
    size_hints.win_gravity = geometry->win_gravity;
  }

/* FIXME: Would it be better to delete this property if
 *        geom_mask == 0? It would save space on the server
 */
XSetWMNormalHints (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
     CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
     &size_hints);
2692}

2694static void
2695cdk_window_get_geometry_hints (CdkWindow      *window,
                             CdkGeometry    *geometry,
                             CdkWindowHints *geom_mask)
2698{
CdkWindowImplX11 *impl;
XSizeHints *size_hints;  
glong junk_supplied_mask = 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);
g_return_if_fail (geometry != NULL)do { if ((geometry != ((void*)0))) { } else { g_return_if_fail_warning
 ("Cdk", ((const char*) (__func__)), "geometry != NULL"); return
; } } while (0);
g_return_if_fail (geom_mask != NULL)do { if ((geom_mask != ((void*)0))) { } else { g_return_if_fail_warning
 ("Cdk", ((const char*) (__func__)), "geom_mask != NULL"); return
; } } while (0);

*geom_mask = 0;

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

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

size_hints = XAllocSizeHints ();
if (!size_hints)
  return;

if (!XGetWMNormalHints (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                        CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                        size_hints,
                        &junk_supplied_mask))
  size_hints->flags = 0;

if (size_hints->flags & PMinSize(1L << 4))
  {
    *geom_mask |= CDK_HINT_MIN_SIZE;
    geometry->min_width = size_hints->min_width / impl->window_scale;
    geometry->min_height = size_hints->min_height / impl->window_scale;
  }

if (size_hints->flags & PMaxSize(1L << 5))
  {
    *geom_mask |= CDK_HINT_MAX_SIZE;
    geometry->max_width = MAX (size_hints->max_width, 1)(((size_hints->max_width) > (1)) ? (size_hints->max_width
) : (1)) / impl->window_scale;
    geometry->max_height = MAX (size_hints->max_height, 1)(((size_hints->max_height) > (1)) ? (size_hints->max_height
) : (1)) / impl->window_scale;
  }

if (size_hints->flags & PResizeInc(1L << 6))
  {
    *geom_mask |= CDK_HINT_RESIZE_INC;
    geometry->width_inc = size_hints->width_inc / impl->window_scale;
    geometry->height_inc = size_hints->height_inc / impl->window_scale;
  }

if (size_hints->flags & PAspect(1L << 7))
  {
    *geom_mask |= CDK_HINT_ASPECT;

    geometry->min_aspect = (gdouble) size_hints->min_aspect.x / (gdouble) size_hints->min_aspect.y;
    geometry->max_aspect = (gdouble) size_hints->max_aspect.x / (gdouble) size_hints->max_aspect.y;
  }

if (size_hints->flags & PWinGravity(1L << 9))
  {
    *geom_mask |= CDK_HINT_WIN_GRAVITY;
    geometry->win_gravity = size_hints->win_gravity;
  }

XFree (size_hints);
2761}

2763static gboolean
2764utf8_is_latin1 (const gchar *str)
2765{
const char *p = str;

while (*p)
  {
    gunichar ch = g_utf8_get_char (p);

    if (ch > 0xff)
return FALSE(0);
    
    p = g_utf8_next_char (p)((p) + g_utf8_skip[*(const guchar *)(p)]);
  }

return TRUE(!(0));
2779}

2781/* Set the property to @utf8_str as STRING if the @utf8_str is fully
* convertable to STRING, otherwise, set it as compound text
*/
2784static void
2785set_text_property (CdkDisplay  *display,
   Window       xwindow,
   Atom         property,
   const gchar *utf8_str)
2789{
gchar *prop_text = NULL((void*)0);
Atom prop_type;
gint prop_length;
gint prop_format;
gboolean is_compound_text;

if (utf8_is_latin1 (utf8_str))
  {
    prop_type = XA_STRING((Atom) 31);
    prop_text = _cdk_x11_display_utf8_to_string_target (display, utf8_str);
    prop_length = prop_text ? strlen (prop_text) : 0;
    prop_format = 8;
    is_compound_text = FALSE(0);
  }
else
  {
    CdkAtom cdk_type;

    cdk_x11_display_utf8_to_compound_text (display,
                                           utf8_str, &cdk_type, &prop_format,
                                           (guchar **)&prop_text, &prop_length);
    prop_type = cdk_x11_atom_to_xatom_for_display (display, cdk_type);
    is_compound_text = TRUE(!(0));
  }

if (prop_text)
  {
    XChangeProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
),
       xwindow,
       property,
       prop_type, prop_format,
       PropModeReplace0, (guchar *)prop_text,
       prop_length);

    if (is_compound_text)
cdk_x11_free_compound_text ((guchar *)prop_text);
    else
g_free (prop_text);
  }
2829}

2831/* Set WM_NAME and _NET_WM_NAME
*/
2833static void
2834set_wm_name (CdkDisplay  *display,
    Window       xwindow,
    const gchar *name)
2837{
XChangeProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), xwindow,
   cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_NAME"),
   cdk_x11_get_xatom_by_name_for_display (display, "UTF8_STRING"), 8,
   PropModeReplace0, (guchar *)name, strlen (name));

set_text_property (display, xwindow,
     cdk_x11_get_xatom_by_name_for_display (display, "WM_NAME"),
     name);
2846}

2848static void
2849cdk_x11_window_set_title (CdkWindow   *window,
	  const gchar *title)
2851{
CdkDisplay *display;
Display *xdisplay;
Window xwindow;

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

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

display = cdk_window_get_display (window);
xdisplay = CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
);
xwindow = CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid);

set_wm_name (display, xwindow, title);

if (!cdk_window_icon_name_set (window))
  {
    XChangeProperty (xdisplay, xwindow,
       cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_ICON_NAME"),
       cdk_x11_get_xatom_by_name_for_display (display, "UTF8_STRING"), 8,
       PropModeReplace0, (guchar *)title, strlen (title));
    
    set_text_property (display, xwindow,
	 cdk_x11_get_xatom_by_name_for_display (display, "WM_ICON_NAME"),
	 title);
  }
2879}

2881static void
2882cdk_x11_window_set_role (CdkWindow   *window,
	 const gchar *role)
2884{
CdkDisplay *display;

display = cdk_window_get_display (window);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

if (role)
  XChangeProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                   cdk_x11_get_xatom_by_name_for_display (display, "WM_WINDOW_ROLE"),
                   XA_STRING((Atom) 31), 8, PropModeReplace0, (guchar *)role, strlen (role));
else
  XDeleteProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                   cdk_x11_get_xatom_by_name_for_display (display, "WM_WINDOW_ROLE"));
2900}

2902static void
2903cdk_x11_window_set_startup_id (CdkWindow   *window,
	       const gchar *startup_id)
2905{
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 (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

if (startup_id)
  XChangeProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                   cdk_x11_get_xatom_by_name_for_display (display, "_NET_STARTUP_ID"), 
                   cdk_x11_get_xatom_by_name_for_display (display, "UTF8_STRING"), 8,
                   PropModeReplace0, (unsigned char *)startup_id, strlen (startup_id));
else
  XDeleteProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                   cdk_x11_get_xatom_by_name_for_display (display, "_NET_STARTUP_ID"));
2924}

2926static void
2927cdk_x11_window_set_transient_for (CdkWindow *window,
		  CdkWindow *parent)
2929{
if (!CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) && !CDK_WINDOW_DESTROYED (parent)(((CdkWindow *)(parent))->destroyed) &&
    WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  XSetTransientForHint (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay), 
	  CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
	  CDK_WINDOW_XID (parent)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((parent)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid));
2935}

2937static gboolean
2938cdk_window_x11_set_back_color (CdkWindow *window,
                             double     red,
                             double     green,
                             double     blue,
                             double     alpha)
2943{
CdkVisual *visual = cdk_window_get_visual (window);

/* I suppose we could handle these, but that'd require fiddling with 
 * xrender formats... */
if (alpha != 1.0)
  return FALSE(0);

switch (visual->type)
  {
  case CDK_VISUAL_DIRECT_COLOR:
  case CDK_VISUAL_TRUE_COLOR:
{
 /* If bits not used for color are used for something other than padding,
  * it's likely alpha, so we set them to 1s.
  */
 guint padding, pixel;
 gint red_prec, red_shift, green_prec, green_shift, blue_prec, blue_shift;

 /* Shifting by >= width-of-type isn't defined in C */
 if (visual->depth >= 32)
   padding = 0;
 else
   padding = ((~(guint32)0)) << visual->depth;
 
 pixel = ~ (visual->red_mask | visual->green_mask | visual->blue_mask | padding);

        cdk_visual_get_red_pixel_details (visual, NULL((void*)0), &red_shift, &red_prec);
        cdk_visual_get_green_pixel_details (visual, NULL((void*)0), &green_shift, &green_prec);
        cdk_visual_get_blue_pixel_details (visual, NULL((void*)0), &blue_shift, &blue_prec);

        pixel += (((int) (red   * ((1 << red_prec  ) - 1))) << red_shift  ) +
                 (((int) (green * ((1 << green_prec) - 1))) << green_shift) +
                 (((int) (blue  * ((1 << blue_prec ) - 1))) << blue_shift );

        XSetWindowBackground (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                              CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid), pixel);
}
    return TRUE(!(0));

  /* These require fiddling with the colormap, and as they're essentially unused
   * we're just gonna skip them for now.
   */
  case CDK_VISUAL_PSEUDO_COLOR:
  case CDK_VISUAL_GRAYSCALE:
  case CDK_VISUAL_STATIC_GRAY:
  case CDK_VISUAL_STATIC_COLOR:
  default:
    break;
  }

return FALSE(0);
2995}

2997static gboolean
2998matrix_is_identity (cairo_matrix_t *matrix)
2999{
return matrix->xx == 1.0 && matrix->yy == 1.0 &&
  matrix->yx == 0.0 && matrix->xy == 0.0 &&
  matrix->x0 == 0.0 && matrix->y0 == 0.0;
3003}

3005static void
3006cdk_window_x11_set_background (CdkWindow      *window,
                             cairo_pattern_t *pattern)
3008{
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));
double r, g, b, a;
cairo_surface_t *surface;
cairo_matrix_t matrix;
cairo_pattern_t *parent_relative_pattern;

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

if (pattern == NULL((void*)0))
  {
    XSetWindowBackgroundPixmap (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                                CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid), None0L);
    return;
  }

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

parent_relative_pattern = cdk_x11_get_parent_relative_pattern ();
3027G_GNUC_END_IGNORE_DEPRECATIONSclang diagnostic pop

if (pattern == parent_relative_pattern)
  {
    Window xroot, xparent, *xchildren;
    guint nxchildren, xparent_depth;
    XWindowAttributes xattrs;

    if (!XQueryTree (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay), CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
          &xroot, &xparent, &xchildren, &nxchildren))
      {
        XSetWindowBackgroundPixmap (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
            CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid), None0L);
        return;
      }

    if (xchildren)
      XFree (xchildren);

    if (xparent) {
      XGetWindowAttributes (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay), xparent, &xattrs);
      xparent_depth = xattrs.depth;
    }

    /* X throws BadMatch if the parent has a different depth when
     * using ParentRelative */
    if (xparent && window->depth == xparent_depth &&
        cairo_pattern_status (pattern) == CAIRO_STATUS_SUCCESS)
      {
        XSetWindowBackgroundPixmap (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                                    CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid), ParentRelative1L);
        return;
      }
    else
      {
        g_warning ("Can't set ParentRelative background for window %#lx, depth of parent doesn't match",
                   CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid));
        XSetWindowBackgroundPixmap (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                                    CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid), None0L);
        return;
      }
  }

switch (cairo_pattern_get_type (pattern))
  {
  case CAIRO_PATTERN_TYPE_SOLID:
    cairo_pattern_get_rgba (pattern, &r, &g, &b, &a);
    if (cdk_window_x11_set_back_color (window, r, g, b, a))
      return;
    break;
  case CAIRO_PATTERN_TYPE_SURFACE:
    cairo_pattern_get_matrix (pattern, &matrix);
    if (cairo_pattern_get_surface (pattern, &surface) == CAIRO_STATUS_SUCCESS &&
        matrix_is_identity (&matrix) &&
        cairo_surface_get_type (surface) == CAIRO_SURFACE_TYPE_XLIB &&
        cairo_xlib_surface_get_visual (surface) == CDK_VISUAL_XVISUAL (cdk_window_get_visual ((window)))(cdk_x11_visual_get_xvisual (cdk_window_get_visual ((window))
)) &&
        cairo_xlib_surface_get_display (surface) == CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay))
      {
        double x, y, sx, sy;

        cairo_surface_get_device_offset (surface, &x, &y);
        sx = sy = 1.;
        cairo_surface_get_device_scale (surface, &sx, &sy);
        /* XXX: This still bombs for non-pixmaps, but there's no way to
         * detect we're not a pixmap in Cairo... */
        if (x == 0.0 && y == 0.0 &&
            sx == impl->window_scale && sy == impl->window_scale)
          {
            XSetWindowBackgroundPixmap (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                                        CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                                        cairo_xlib_surface_get_drawable (surface));
            return;
          }
      }
    /* fall through */
  case CAIRO_PATTERN_TYPE_LINEAR:
  case CAIRO_PATTERN_TYPE_RADIAL:
  default:
    /* fallback: just use black */
    break;
  }

XSetWindowBackgroundPixmap (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                            CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid), None0L);
3111}

3113static void
3114cdk_window_x11_set_device_cursor (CdkWindow *window,
                                CdkDevice *device,
                                CdkCursor *cursor)
3117{
CdkWindowImplX11 *impl;

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);

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

if (!cursor)
  g_hash_table_remove (impl->device_cursor, device);
else
  {
    _cdk_x11_cursor_update_theme (cursor);
    g_hash_table_replace (impl->device_cursor,
                          device, g_object_ref (cursor)((__typeof__ (cursor)) (g_object_ref) (cursor)));
  }

if (!CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  CDK_DEVICE_GET_CLASS (device)((((CdkDeviceClass*) (((GTypeInstance*) ((device)))->g_class
))))->set_window_cursor (device, window, cursor);
3136}

3138CdkCursor *
3139_cdk_x11_window_get_cursor (CdkWindow *window)
3140{
CdkWindowImplX11 *impl;

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 = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));

return impl->cursor;
3148}

3150static void
3151cdk_window_x11_get_geometry (CdkWindow *window,
                           gint      *x,
                           gint      *y,
                           gint      *width,
                           gint      *height)
3156{
Window root;
gint tx;
gint ty;
guint twidth;
guint theight;
guint tborder_width;
guint tdepth;

if (!CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  {
    CdkWindowImplX11 *impl;

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

    XGetGeometry (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
    CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
    &root, &tx, &ty, &twidth, &theight, &tborder_width, &tdepth);
    
    if (x)
*x = tx / impl->window_scale;
    if (y)
*y = ty / impl->window_scale;
    if (width)
*width = twidth / impl->window_scale;
    if (height)
*height = theight / impl->window_scale;
  }
3184}

3186static void
3187cdk_window_x11_get_root_coords (CdkWindow *window,
		gint       x,
		gint       y,
		gint      *root_x,
		gint      *root_y)
3192{
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));
Window child;
gint tx;
gint ty;

XTranslateCoordinates (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                       CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                       CDK_WINDOW_XROOTWIN (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xroot_window),
                       x * impl->window_scale, y * impl->window_scale, &tx, &ty,
                       &child);

if (root_x)
  *root_x = tx / impl->window_scale;
if (root_y)
  *root_y = ty / impl->window_scale;
3208}

3210static void
3211cdk_x11_window_get_frame_extents (CdkWindow    *window,
                                CdkRectangle *rect)
3213{
CdkDisplay *display;
CdkWindowImplX11 *impl;
Window xwindow;
Window xparent;
Window root;
Window child;
Window *children;
guchar *data;
Window *vroots;
Atom type_return;
guint nchildren;
guint nvroots;
gulong nitems_return;
gulong bytes_after_return;
gint format_return;
gint i;
guint ww, wh, wb, wd;
gint wx, wy;
gboolean got_frame_extents = FALSE(0);

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

rect->x = 0;
rect->y = 0;
rect->width = 1;
rect->height = 1;

while (window->parent && (window->parent)->parent)
  window = window->parent;

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

/* Refine our fallback answer a bit using local information */
rect->x = window->x * impl->window_scale;
rect->y = window->y * impl->window_scale;
rect->width = window->width * impl->window_scale;
rect->height = window->height * impl->window_scale;

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

nvroots = 0;
vroots = NULL((void*)0);

display = cdk_window_get_display (window);

cdk_x11_display_error_trap_push (display);

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

/* first try: use _NET_FRAME_EXTENTS */
if (cdk_x11_screen_supports_net_wm_hint (CDK_WINDOW_SCREEN (window)(cdk_window_get_screen (window)),
                                         cdk_atom_intern_static_string ("_NET_FRAME_EXTENTS")) &&
    XGetWindowProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), xwindow,
                        cdk_x11_get_xatom_by_name_for_display (display,
                                                                "_NET_FRAME_EXTENTS"),
                        0, G_MAXLONG9223372036854775807L, False0, XA_CARDINAL((Atom) 6), &type_return,
                        &format_return, &nitems_return, &bytes_after_return,
                        &data)
    == Success0)
  {
    if ((type_return == XA_CARDINAL((Atom) 6)) && (format_return == 32) &&
 (nitems_return == 4) && (data))
      {
 gulong *ldata = (gulong *) data;
 got_frame_extents = TRUE(!(0));

 /* try to get the real client window geometry */
 if (XGetGeometry (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), xwindow,
	    &root, &wx, &wy, &ww, &wh, &wb, &wd) &&
            XTranslateCoordinates (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
),
 			     xwindow, root, 0, 0, &wx, &wy, &child))
          {
     rect->x = wx;
     rect->y = wy;
     rect->width = ww;
     rect->height = wh;
   }

 /* _NET_FRAME_EXTENTS format is left, right, top, bottom */
 rect->x -= ldata[0];
 rect->y -= ldata[2];
 rect->width += ldata[0] + ldata[1];
 rect->height += ldata[2] + ldata[3];
}

    if (data)
XFree (data);
  }

if (got_frame_extents)
  goto out;

/* no frame extents property available, which means we either have a WM that
   is not EWMH compliant or is broken - try fallback and walk up the window
   tree to get our window's parent which hopefully is the window frame */

/* use NETWM_VIRTUAL_ROOTS if available */
root = CDK_WINDOW_XROOTWIN (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xroot_window);

if (cdk_x11_screen_supports_net_wm_hint (CDK_WINDOW_SCREEN (window)(cdk_window_get_screen (window)),
                                         cdk_atom_intern_static_string ("_NET_VIRTUAL_ROOTS")) &&
    XGetWindowProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), root,
	  cdk_x11_get_xatom_by_name_for_display (display, 
						 "_NET_VIRTUAL_ROOTS"),
	  0, G_MAXLONG9223372036854775807L, False0, XA_WINDOW((Atom) 33), &type_return,
	  &format_return, &nitems_return, &bytes_after_return,
	  &data)
    == Success0)
  {
    if ((type_return == XA_WINDOW((Atom) 33)) && (format_return == 32) && (data))
{
 nvroots = nitems_return;
 vroots = (Window *)data;
}
  }

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

do
  {
    xwindow = xparent;

    if (!XQueryTree (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), xwindow,
       &root, &xparent,
       &children, &nchildren))
goto out;
    
    if (children)
XFree (children);

    /* check virtual roots */
    for (i = 0; i < nvroots; i++)
{
 if (xparent == vroots[i])
   {
     root = xparent;
     break;
         }
}
  }
while (xparent != root);

if (XGetGeometry (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), xwindow,
    &root, &wx, &wy, &ww, &wh, &wb, &wd))
  {
    rect->x = wx;
    rect->y = wy;
    rect->width = ww;
    rect->height = wh;
  }

out:
if (vroots)
  XFree (vroots);

/* Here we extend the size to include the extra pixels if we round x/y down
   as well as round the size up when we divide by scale so that the returned
   size is guaranteed to cover the real pixels, but it may overshoot a bit
   in case the window is not positioned/sized according to the scale */
rect->width = (rect->width + rect->x % impl->window_scale + impl->window_scale - 1) / impl->window_scale;
rect->height = (rect->height + rect->y % impl->window_scale + impl->window_scale - 1) / impl->window_scale;
rect->x = rect->x / impl->window_scale;
rect->y = rect->y / impl->window_scale;
cdk_x11_display_error_trap_pop_ignored (display);
3379}

3381static gboolean
3382cdk_window_x11_get_device_state (CdkWindow       *window,
                               CdkDevice       *device,
                               gdouble         *x,
                               gdouble         *y,
                               CdkModifierType *mask)
3387{
CdkWindow *child;

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

/*HIDPI: handle coords here?*/
CDK_DEVICE_GET_CLASS (device)((((CdkDeviceClass*) (((GTypeInstance*) ((device)))->g_class
))))->query_state (device, window,
                                            NULL((void*)0), &child,
                                            NULL((void*)0), NULL((void*)0),
                                            x, y, mask);
return child != NULL((void*)0);
3399}

3401static CdkEventMask
3402cdk_window_x11_get_events (CdkWindow *window)
3403{
XWindowAttributes attrs;
CdkEventMask event_mask;
CdkEventMask filtered;

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  return 0;
else
  {
    XGetWindowAttributes (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
	    CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
	    &attrs);
    event_mask = x_event_mask_to_cdk_event_mask (attrs.your_event_mask);
    /* if property change was filtered out before, keep it filtered out */
    filtered = CDK_STRUCTURE_MASK | CDK_PROPERTY_CHANGE_MASK;
    window->event_mask = event_mask & ((window->event_mask & filtered) | ~filtered);

    return event_mask;
  }
3422}
3423static void
3424cdk_window_x11_set_events (CdkWindow    *window,
                         CdkEventMask  event_mask)
3426{
if (!CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed))
  {
    CdkX11Display *display_x11;
    long xevent_mask = 0;

    if (CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid) != CDK_WINDOW_XROOTWIN (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xroot_window))
      xevent_mask = StructureNotifyMask(1L<<17) | PropertyChangeMask(1L<<22);

    display_x11 = CDK_X11_DISPLAY (cdk_window_get_display (window))((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((cdk_window_get_display (window))), ((cdk_x11_display_get_type
()))))));
    cdk_x11_event_source_select_events ((CdkEventSource *) display_x11->event_source,
                                        CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid), event_mask,
                                        xevent_mask);
  }
3440}

3442static inline void
3443do_shape_combine_region (CdkWindow       *window,
	 const cairo_region_t *shape_region,
	 gint             offset_x,
	 gint             offset_y,
	 gint             shape)
3448{
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));

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

if (shape_region == NULL((void*)0))
  {
    /* Use NULL mask to unset the shape */
    if (shape == ShapeBounding0
 ? cdk_display_supports_shapes (CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display))
 : cdk_display_supports_input_shapes (CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display)))
{
 if (shape == ShapeBounding0)
   {
     _cdk_x11_window_tmp_unset_parent_bg (window);
     _cdk_x11_window_tmp_unset_bg (window, TRUE(!(0)));
   }
 XShapeCombineMask (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
	     CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
	     shape,
	     0, 0,
	     None0L,
	     ShapeSet0);
  if (shape == ShapeBounding0)
   {
     _cdk_x11_window_tmp_reset_parent_bg (window);
     _cdk_x11_window_tmp_reset_bg (window, TRUE(!(0)));
   }
}
    return;
  }

if (shape == ShapeBounding0
    ? cdk_display_supports_shapes (CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display))
    : cdk_display_supports_input_shapes (CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display)))
  {
    gint n_rects = 0;
    XRectangle *xrects = NULL((void*)0);

    _cdk_x11_region_get_xrectangles (shape_region,
                                     0, 0, impl->window_scale,
                                     &xrects, &n_rects);
    
    if (shape == ShapeBounding0)
{
 _cdk_x11_window_tmp_unset_parent_bg (window);
 _cdk_x11_window_tmp_unset_bg (window, TRUE(!(0)));
}
    XShapeCombineRectangles (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                             CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                             shape,
                             offset_x * impl->window_scale,
                             offset_y * impl->window_scale,
                             xrects, n_rects,
                             ShapeSet0,
                             YXBanded3);

    if (shape == ShapeBounding0)
{
 _cdk_x11_window_tmp_reset_parent_bg (window);
 _cdk_x11_window_tmp_reset_bg (window, TRUE(!(0)));
}
    
    g_free (xrects);
  }
3514}

3516static void
3517cdk_window_x11_shape_combine_region (CdkWindow       *window,
                                   const cairo_region_t *shape_region,
                                   gint             offset_x,
                                   gint             offset_y)
3521{
do_shape_combine_region (window, shape_region, offset_x, offset_y, ShapeBounding0);
3523}

3525static void 
3526cdk_window_x11_input_shape_combine_region (CdkWindow       *window,
			   const cairo_region_t *shape_region,
			   gint             offset_x,
			   gint             offset_y)
3530{
3531#ifdef ShapeInput2
do_shape_combine_region (window, shape_region, offset_x, offset_y, ShapeInput2);
3533#endif
3534}


3537static void
3538cdk_x11_window_set_override_redirect (CdkWindow *window,
		  gboolean override_redirect)
3540{
XSetWindowAttributes attr;

if (!CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) &&
    WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  {
    CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));

    attr.override_redirect = (override_redirect? True1 : False0);
    XChangeWindowAttributes (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
	       CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
	       CWOverrideRedirect(1L<<9),
	       &attr);

    impl->override_redirect = attr.override_redirect;
  }
3556}

3558static void
3559cdk_x11_window_set_accept_focus (CdkWindow *window,
		 gboolean accept_focus)
3561{
accept_focus = accept_focus != FALSE(0);

if (window->accept_focus != accept_focus)
  {
    window->accept_focus = accept_focus;

    if (!CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) &&
 WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
update_wm_hints (window, FALSE(0));
  }
3572}

3574static void
3575cdk_x11_window_set_focus_on_map (CdkWindow *window,
		 gboolean focus_on_map)
3577{
focus_on_map = focus_on_map != FALSE(0);

if (window->focus_on_map != focus_on_map)
  {
    window->focus_on_map = focus_on_map;
    
    if ((!CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed)) &&
 (!window->focus_on_map) &&
 WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
cdk_x11_window_set_user_time (window, 0);
  }
3589}

3591/**
* cdk_x11_window_set_user_time:
* @window: (type CdkX11Window): A toplevel #CdkWindow
* @timestamp: An XServer timestamp to which the property should be set
*
* The application can use this call to update the _NET_WM_USER_TIME
* property on a toplevel window.  This property stores an Xserver
* time which represents the time of the last user input event
* received for this window.  This property may be used by the window
* manager to alter the focus, stacking, and/or placement behavior of
* windows when they are mapped depending on whether the new window
* was created by a user action or is a "pop-up" window activated by a
* timer or some other event.
*
* Note that this property is automatically updated by CDK, so this
* function should only be used by applications which handle input
* events bypassing CDK.
*
* Since: 2.6
**/
3611void
3612cdk_x11_window_set_user_time (CdkWindow *window,
                            guint32    timestamp)
3614{
CdkDisplay *display;
CdkX11Display *display_x11;
CdkToplevelX11 *toplevel;
glong timestamp_long = (glong)timestamp;
Window xid;

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

display = cdk_window_get_display (window);
display_x11 = CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))));
toplevel = _cdk_x11_window_get_toplevel (window);

if (!toplevel)
  {
    g_warning ("cdk_window_set_user_time called on non-toplevel\n");
    return;
  }

if (toplevel->focus_window != None0L &&
    cdk_x11_screen_supports_net_wm_hint (CDK_WINDOW_SCREEN (window)(cdk_window_get_screen (window)),
                                         cdk_atom_intern_static_string ("_NET_WM_USER_TIME_WINDOW")))
  xid = toplevel->focus_window;
else
  xid = CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid);

XChangeProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), xid,
                 cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_USER_TIME"),
                 XA_CARDINAL((Atom) 6), 32, PropModeReplace0,
                 (guchar *)&timestamp_long, 1);

if (timestamp_long != CDK_CURRENT_TIME0L &&
    (display_x11->user_time == CDK_CURRENT_TIME0L ||
     XSERVER_TIME_IS_LATER (timestamp_long, display_x11->user_time)( (( timestamp_long > display_x11->user_time ) &&
 ( timestamp_long - display_x11->user_time < ((guint32)
-1)/2 )) || (( timestamp_long < display_x11->user_time )
 && ( display_x11->user_time - timestamp_long >
 ((guint32)-1)/2 )) )))
  display_x11->user_time = timestamp_long;

if (toplevel)
  toplevel->user_time = timestamp_long;
3654}

3656/**
* cdk_x11_window_set_utf8_property:
* @window: (type CdkX11Window): a #CdkWindow
* @name: Property name, will be interned as an X atom
* @value: (allow-none): Property value, or %NULL to delete
*
* This function modifies or removes an arbitrary X11 window
* property of type UTF8_STRING.  If the given @window is
* not a toplevel window, it is ignored.
*
* Since: 3.4
*/
3668void
3669cdk_x11_window_set_utf8_property  (CdkWindow *window,
		   const gchar *name,
		   const gchar *value)
3672{
CdkDisplay *display;

if (!WINDOW_IS_TOPLEVEL (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
))
  return;

display = cdk_window_get_display (window);

if (value != NULL((void*)0))
  {
    XChangeProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
),
                     CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                     cdk_x11_get_xatom_by_name_for_display (display, name),
                     cdk_x11_get_xatom_by_name_for_display (display, "UTF8_STRING"), 8,
                     PropModeReplace0, (guchar *)value, strlen (value));
  }
else
  {
    XDeleteProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
),
                     CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                     cdk_x11_get_xatom_by_name_for_display (display, name));
  }
3694}

3696/**
* cdk_x11_window_set_hide_titlebar_when_maximized:
* @window: (type CdkX11Window): a #CdkWindow
* @hide_titlebar_when_maximized: whether to hide the titlebar when
*                                maximized
*
* Set a hint for the window manager, requesting that the titlebar
* should be hidden when the window is maximized.
*
* 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.4
*/
3711void
3712cdk_x11_window_set_hide_titlebar_when_maximized (CdkWindow *window,
                                               gboolean   hide_titlebar_when_maximized)
3714{
CdkDisplay *display;

if (!WINDOW_IS_TOPLEVEL (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
))
  return;

display = cdk_window_get_display (window);

if (hide_titlebar_when_maximized)
  {
    gulong hide = 1;
    XChangeProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
),
                     CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                     cdk_x11_get_xatom_by_name_for_display (display, "_CTK_HIDE_TITLEBAR_WHEN_MAXIMIZED"),
                     XA_CARDINAL((Atom) 6), 32,
                     PropModeReplace0, (guchar *)&hide, 1);
  }
else
  {
    XDeleteProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
),
                     CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                     cdk_x11_get_xatom_by_name_for_display (display, "_CTK_HIDE_TITLEBAR_WHEN_MAXIMIZED"));
  }
3737}

3739static void
3740cdk_x11_window_set_shadow_width (CdkWindow *window,
                               int        left,
                               int        right,
                               int        top,
                               int        bottom)
3745{
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));
Atom frame_extents;
gulong data[4] = {
  left * impl->window_scale,
  right * impl->window_scale,
  top * impl->window_scale,
  bottom * impl->window_scale
};

frame_extents = cdk_x11_get_xatom_by_name_for_display (cdk_window_get_display (window),
                                                       "_CTK_FRAME_EXTENTS");
XChangeProperty (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                 CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                 frame_extents, XA_CARDINAL((Atom) 6),
                 32, PropModeReplace0,
                 (guchar *) &data, 4);
3762}

3764/**
* cdk_x11_window_set_frame_extents:
* @window: (type CdkX11Window): a #CdkWindow
* @left: The left extent
* @right: The right extent
* @top: The top extent
* @bottom: The bottom extent
*
* This is the same as cdk_window_set_shadow_width() but it only works
* on CdkX11Window.
*
* Since: 3.10
*
* Deprecated: 3.12: Use cdk_window_set_shadow_width() instead.
*/
3779void
3780cdk_x11_window_set_frame_extents (CdkWindow *window,
                                int        left,
                                int        right,
                                int        top,
                                int        bottom)
3785{
cdk_x11_window_set_shadow_width (window, left, right, top, bottom);
3787}

3789/**
* cdk_x11_window_set_theme_variant:
* @window: (type CdkX11Window): a #CdkWindow
* @variant: the theme variant to export
*
* CTK+ applications can request a dark theme variant. In order to
* make other applications - namely window managers using CTK+ for
* themeing - aware of this choice, CTK+ uses this function to
* export the requested theme variant as _CTK_THEME_VARIANT property
* on toplevel windows.
*
* 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.2
*/
3806void
3807cdk_x11_window_set_theme_variant (CdkWindow *window,
                                char      *variant)
3809{
cdk_x11_window_set_utf8_property (window, "_CTK_THEME_VARIANT",
                                  variant ? variant : "");
3812}

3814#define CDK_SELECTION_MAX_SIZE(display)(((262144) < (XExtendedMaxRequestSize ((((((CdkX11Display*
) (void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) == 0 ? XMaxRequestSize
 ((((((CdkX11Display*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((display)), ((cdk_x11_display_get_type()))))
))->xdisplay)) - 100 : XExtendedMaxRequestSize ((((((CdkX11Display
*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) - 100))
 ? (262144) : (XExtendedMaxRequestSize ((((((CdkX11Display*) (
void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) == 0 ? XMaxRequestSize
 ((((((CdkX11Display*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((display)), ((cdk_x11_display_get_type()))))
))->xdisplay)) - 100 : XExtendedMaxRequestSize ((((((CdkX11Display
*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) - 100))                                 \
MIN(262144,                                                           \(((262144) < (XExtendedMaxRequestSize ((((((CdkX11Display*
) (void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) == 0 ? XMaxRequestSize
 ((((((CdkX11Display*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((display)), ((cdk_x11_display_get_type()))))
))->xdisplay)) - 100 : XExtendedMaxRequestSize ((((((CdkX11Display
*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) - 100))
 ? (262144) : (XExtendedMaxRequestSize ((((((CdkX11Display*) (
void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) == 0 ? XMaxRequestSize
 ((((((CdkX11Display*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((display)), ((cdk_x11_display_get_type()))))
))->xdisplay)) - 100 : XExtendedMaxRequestSize ((((((CdkX11Display
*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) - 100))
    XExtendedMaxRequestSize (CDK_DISPLAY_XDISPLAY (display)) == 0     \(((262144) < (XExtendedMaxRequestSize ((((((CdkX11Display*
) (void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) == 0 ? XMaxRequestSize
 ((((((CdkX11Display*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((display)), ((cdk_x11_display_get_type()))))
))->xdisplay)) - 100 : XExtendedMaxRequestSize ((((((CdkX11Display
*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) - 100))
 ? (262144) : (XExtendedMaxRequestSize ((((((CdkX11Display*) (
void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) == 0 ? XMaxRequestSize
 ((((((CdkX11Display*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((display)), ((cdk_x11_display_get_type()))))
))->xdisplay)) - 100 : XExtendedMaxRequestSize ((((((CdkX11Display
*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) - 100))
     ? XMaxRequestSize (CDK_DISPLAY_XDISPLAY (display)) - 100         \(((262144) < (XExtendedMaxRequestSize ((((((CdkX11Display*
) (void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) == 0 ? XMaxRequestSize
 ((((((CdkX11Display*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((display)), ((cdk_x11_display_get_type()))))
))->xdisplay)) - 100 : XExtendedMaxRequestSize ((((((CdkX11Display
*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) - 100))
 ? (262144) : (XExtendedMaxRequestSize ((((((CdkX11Display*) (
void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) == 0 ? XMaxRequestSize
 ((((((CdkX11Display*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((display)), ((cdk_x11_display_get_type()))))
))->xdisplay)) - 100 : XExtendedMaxRequestSize ((((((CdkX11Display
*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) - 100))
     : XExtendedMaxRequestSize (CDK_DISPLAY_XDISPLAY (display)) - 100)(((262144) < (XExtendedMaxRequestSize ((((((CdkX11Display*
) (void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) == 0 ? XMaxRequestSize
 ((((((CdkX11Display*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((display)), ((cdk_x11_display_get_type()))))
))->xdisplay)) - 100 : XExtendedMaxRequestSize ((((((CdkX11Display
*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) - 100))
 ? (262144) : (XExtendedMaxRequestSize ((((((CdkX11Display*) (
void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) == 0 ? XMaxRequestSize
 ((((((CdkX11Display*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((display)), ((cdk_x11_display_get_type()))))
))->xdisplay)) - 100 : XExtendedMaxRequestSize ((((((CdkX11Display
*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) - 100))

3820static void
3821cdk_window_update_icon (CdkWindow *window,
                      GList     *icon_list)
3823{
CdkToplevelX11 *toplevel;
GdkPixbuf *best_icon;
GList *tmp_list;
int best_size;

toplevel = _cdk_x11_window_get_toplevel (window);

if (toplevel->icon_pixmap != NULL((void*)0))
  {
    cairo_surface_destroy (toplevel->icon_pixmap);
    toplevel->icon_pixmap = NULL((void*)0);
  }

if (toplevel->icon_mask != NULL((void*)0))
  {
    cairo_surface_destroy (toplevel->icon_mask);
    toplevel->icon_mask = NULL((void*)0);
  }

3843#define IDEAL_SIZE48 48

best_size = G_MAXINT2147483647;
best_icon = NULL((void*)0);
for (tmp_list = icon_list; tmp_list; tmp_list = tmp_list->next)
  {
    GdkPixbuf *pixbuf = tmp_list->data;
    int this;

    /* average width and height - if someone passes in a rectangular
     * icon they deserve what they get.
     */
    this = gdk_pixbuf_get_width (pixbuf) + gdk_pixbuf_get_height (pixbuf);
    this /= 2;

    if (best_icon == NULL((void*)0))
      {
        best_icon = pixbuf;
        best_size = this;
      }
    else
      {
        /* icon is better if it's 32 pixels or larger, and closer to
         * the ideal size than the current best.
         */
        if (this >= 32 &&
            (ABS (best_size - IDEAL_SIZE)(((best_size - 48) < 0) ? -(best_size - 48) : (best_size -
 48)) <
             ABS (this - IDEAL_SIZE)(((this - 48) < 0) ? -(this - 48) : (this - 48))))
          {
            best_icon = pixbuf;
            best_size = this;
          }
      }
  }

if (best_icon)
  {
    int width = gdk_pixbuf_get_width (best_icon);
    int height = gdk_pixbuf_get_height (best_icon);
    cairo_t *cr;

    toplevel->icon_pixmap = cdk_x11_window_create_pixmap_surface (window,
                                                                  width,
                                                                  height);

    cr = cairo_create (toplevel->icon_pixmap);
    cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
    cdk_cairo_set_source_pixbuf (cr, best_icon, 0, 0);
    if (gdk_pixbuf_get_has_alpha (best_icon))
      {
        /* Saturate the image, so it has bilevel alpha */
        cairo_push_group_with_content (cr, CAIRO_CONTENT_COLOR_ALPHA);
        cairo_paint (cr);
        cairo_set_operator (cr, CAIRO_OPERATOR_SATURATE);
        cairo_paint (cr);
        cairo_pop_group_to_source (cr);
      }
    cairo_paint (cr);
    cairo_destroy (cr);

    if (gdk_pixbuf_get_has_alpha (best_icon))
      {
        toplevel->icon_mask = _cdk_x11_window_create_bitmap_surface (window,
                                                                     width,
                                                                     height);

        cr = cairo_create (toplevel->icon_mask);
        cdk_cairo_set_source_pixbuf (cr, best_icon, 0, 0);
        cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
        cairo_paint (cr);
        cairo_destroy (cr);
      }
  }

update_wm_hints (window, FALSE(0));
3918}

3920static void
3921cdk_x11_window_set_icon_list (CdkWindow *window,
	      GList     *pixbufs)
3923{
gulong *data;
guchar *pixels;
gulong *p;
gint size;
GList *l;
GdkPixbuf *pixbuf;
gint width, height, stride;
gint x, y;
gint n_channels;
CdkDisplay *display;
gint n;

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

display = cdk_window_get_display (window);

l = pixbufs;
size = 0;
n = 0;
while (l)
  {
    pixbuf = l->data;
    g_return_if_fail (GDK_IS_PIXBUF (pixbuf))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((pixbuf)); GType __t = ((gdk_pixbuf_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__
)), "GDK_IS_PIXBUF (pixbuf)"); return; } } while (0);

    width = gdk_pixbuf_get_width (pixbuf);
    height = gdk_pixbuf_get_height (pixbuf);
    
    /* silently ignore overlarge icons */
    if (size + 2 + width * height > CDK_SELECTION_MAX_SIZE(display)(((262144) < (XExtendedMaxRequestSize ((((((CdkX11Display*
) (void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) == 0 ? XMaxRequestSize
 ((((((CdkX11Display*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((display)), ((cdk_x11_display_get_type()))))
))->xdisplay)) - 100 : XExtendedMaxRequestSize ((((((CdkX11Display
*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) - 100))
 ? (262144) : (XExtendedMaxRequestSize ((((((CdkX11Display*) (
void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) == 0 ? XMaxRequestSize
 ((((((CdkX11Display*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((display)), ((cdk_x11_display_get_type()))))
))->xdisplay)) - 100 : XExtendedMaxRequestSize ((((((CdkX11Display
*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((display
)), ((cdk_x11_display_get_type()))))))->xdisplay)) - 100)))
break;
   
    n++;
    size += 2 + width * height;
    
    l = l->next;
  }

data = g_malloc (size * sizeof (gulong));

l = pixbufs;
p = data;
while (l && n > 0)
  {
    pixbuf = l->data;
    
    width = gdk_pixbuf_get_width (pixbuf);
    height = gdk_pixbuf_get_height (pixbuf);
    stride = gdk_pixbuf_get_rowstride (pixbuf);
    n_channels = gdk_pixbuf_get_n_channels (pixbuf);
    
    *p++ = width;
    *p++ = height;

    pixels = gdk_pixbuf_get_pixels (pixbuf);

    for (y = 0; y < height; y++)
{
 for (x = 0; x < width; x++)
   {
     guchar r, g, b, a;
     
     r = pixels[y*stride + x*n_channels + 0];
     g = pixels[y*stride + x*n_channels + 1];
     b = pixels[y*stride + x*n_channels + 2];
     if (n_channels >= 4)
a = pixels[y*stride + x*n_channels + 3];
     else
a = 255;
     
     *p++ = a << 24 | r << 16 | g << 8 | b ;
   }
}

    l = l->next;
    n--;
  }

if (size > 0)
  {
    XChangeProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
),
                     CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
       cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_ICON"),
                     XA_CARDINAL((Atom) 6), 32,
                     PropModeReplace0,
                     (guchar*) data, size);
  }
else
  {
    XDeleteProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
),
                     CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
       cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_ICON"));
  }

g_free (data);

cdk_window_update_icon (window, pixbufs);
4022}

4024static gboolean
4025cdk_window_icon_name_set (CdkWindow *window)
4026{
return GPOINTER_TO_UINT (g_object_get_qdata (G_OBJECT (window),((guint) (gulong) (g_object_get_qdata (((((GObject*) (void *)
 g_type_check_instance_cast ((GTypeInstance*) ((window)), (((
GType) ((20) << (2)))))))), g_quark_from_static_string (
"cdk-icon-name-set"))))
			       g_quark_from_static_string ("cdk-icon-name-set")))((guint) (gulong) (g_object_get_qdata (((((GObject*) (void *)
 g_type_check_instance_cast ((GTypeInstance*) ((window)), (((
GType) ((20) << (2)))))))), g_quark_from_static_string (
"cdk-icon-name-set"))));
4029}

4031static void
4032cdk_x11_window_set_icon_name (CdkWindow   *window,
	      const gchar *name)
4034{
CdkDisplay *display;

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

display = cdk_window_get_display (window);

g_object_set_qdata (G_OBJECT (window)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window)), (((GType) ((20) << (2)))))))), g_quark_from_static_string ("cdk-icon-name-set"),
                    GUINT_TO_POINTER (name != NULL)((gpointer) (gulong) (name != ((void*)0))));

if (name != NULL((void*)0))
  {
    XChangeProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
),
                     CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                     cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_ICON_NAME"),
                     cdk_x11_get_xatom_by_name_for_display (display, "UTF8_STRING"), 8,
                     PropModeReplace0, (guchar *)name, strlen (name));

    set_text_property (display, CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                       cdk_x11_get_xatom_by_name_for_display (display, "WM_ICON_NAME"),
                       name);
  }
else
  {
    XDeleteProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
),
                     CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                     cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_ICON_NAME"));
    XDeleteProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
),
                     CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                     cdk_x11_get_xatom_by_name_for_display (display, "WM_ICON_NAME"));
  }
4067}

4069static void
4070cdk_x11_window_iconify (CdkWindow *window)
4071{
if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

if (CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
  {  
    XIconifyWindow (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
      CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
      cdk_x11_screen_get_number (CDK_WINDOW_SCREEN (window)(cdk_window_get_screen (window))));
  }
else
  {
    /* Flip our client side flag, the real work happens on map. */
    cdk_synthesize_window_state (window,
                                 0,
                                 CDK_WINDOW_STATE_ICONIFIED);
    cdk_wmspec_change_state (TRUE(!(0)), window,
                             cdk_atom_intern_static_string ("_NET_WM_STATE_HIDDEN"),
                             CDK_NONE((CdkAtom)((gpointer) (gulong) (0))));
  }
4092}

4094static void
4095cdk_x11_window_deiconify (CdkWindow *window)
4096{
if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

if (CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
  {  
    cdk_window_show (window);
    cdk_wmspec_change_state (FALSE(0), window,
                             cdk_atom_intern_static_string ("_NET_WM_STATE_HIDDEN"),
                             CDK_NONE((CdkAtom)((gpointer) (gulong) (0))));
  }
else
  {
    /* Flip our client side flag, the real work happens on map. */
    cdk_synthesize_window_state (window,
                                 CDK_WINDOW_STATE_ICONIFIED,
                                 0);
    cdk_wmspec_change_state (FALSE(0), window,
                             cdk_atom_intern_static_string ("_NET_WM_STATE_HIDDEN"),
                             CDK_NONE((CdkAtom)((gpointer) (gulong) (0))));
  }
4118}

4120static void
4121cdk_x11_window_stick (CdkWindow *window)
4122{
if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

if (CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
  {
    /* "stick" means stick to all desktops _and_ do not scroll with the
     * viewport. i.e. glue to the monitor glass in all cases.
     */
    
    XClientMessageEvent xclient;

    /* Request stick during viewport scroll */
    cdk_wmspec_change_state (TRUE(!(0)), window,
	       cdk_atom_intern_static_string ("_NET_WM_STATE_STICKY"),
	       CDK_NONE((CdkAtom)((gpointer) (gulong) (0))));

    /* Request desktop 0xFFFFFFFF */
    memset (&xclient, 0, sizeof (xclient));
    xclient.type = ClientMessage33;
    xclient.window = CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid);
    xclient.display = CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay);
    xclient.message_type = cdk_x11_get_xatom_by_name_for_display (CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display), 
							"_NET_WM_DESKTOP");
    xclient.format = 32;

    xclient.data.l[0] = 0xFFFFFFFF;
    xclient.data.l[1] = 0;
    xclient.data.l[2] = 0;
    xclient.data.l[3] = 0;
    xclient.data.l[4] = 0;

    XSendEvent (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay), CDK_WINDOW_XROOTWIN (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xroot_window), False0,
                SubstructureRedirectMask(1L<<20) | SubstructureNotifyMask(1L<<19),
                (XEvent *)&xclient);
  }
else
  {
    /* Flip our client side flag, the real work happens on map. */
    cdk_synthesize_window_state (window,
                                 0,
                                 CDK_WINDOW_STATE_STICKY);
  }
4166}

4168static void
4169cdk_x11_window_unstick (CdkWindow *window)
4170{
if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

if (CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
  {
    /* Request unstick from viewport */
    cdk_wmspec_change_state (FALSE(0), window,
	       cdk_atom_intern_static_string ("_NET_WM_STATE_STICKY"),
	       CDK_NONE((CdkAtom)((gpointer) (gulong) (0))));

    move_to_current_desktop (window);
  }
else
  {
    /* Flip our client side flag, the real work happens on map. */
    cdk_synthesize_window_state (window,
                                 CDK_WINDOW_STATE_STICKY,
                                 0);

  }
4192}

4194static void
4195cdk_x11_window_maximize (CdkWindow *window)
4196{
if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

if (CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
  cdk_wmspec_change_state (TRUE(!(0)), window,
	     cdk_atom_intern_static_string ("_NET_WM_STATE_MAXIMIZED_VERT"),
	     cdk_atom_intern_static_string ("_NET_WM_STATE_MAXIMIZED_HORZ"));
else
  cdk_synthesize_window_state (window,
		 0,
		 CDK_WINDOW_STATE_MAXIMIZED);
4209}

4211static void
4212cdk_x11_window_unmaximize (CdkWindow *window)
4213{
if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

if (CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
  cdk_wmspec_change_state (FALSE(0), window,
	     cdk_atom_intern_static_string ("_NET_WM_STATE_MAXIMIZED_VERT"),
	     cdk_atom_intern_static_string ("_NET_WM_STATE_MAXIMIZED_HORZ"));
else
  cdk_synthesize_window_state (window,
		 CDK_WINDOW_STATE_MAXIMIZED,
		 0);
4226}

4228static void
4229cdk_x11_window_apply_fullscreen_mode (CdkWindow *window)
4230{
if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

/* _NET_WM_FULLSCREEN_MONITORS gives an indication to the window manager as
 * to which monitors so span across when the window is fullscreen, but it's
 * not a state in itself so this would have no effect if the window is not
 * mapped.
 */

if (CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
  {
    XClientMessageEvent xclient;
    gint                monitors[4];
    gint                i;

    memset (&xclient, 0, sizeof (xclient));
    xclient.type = ClientMessage33;
    xclient.window = CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid);
    xclient.display = CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay);
    xclient.format = 32;

    switch (window->fullscreen_mode)
{
case CDK_FULLSCREEN_ON_CURRENT_MONITOR:

 /* FIXME: This is not part of the EWMH spec!
  *
  * There is no documented mechanism to remove the property
  * _NET_WM_FULLSCREEN_MONITORS once set, so we use use a set of
  * invalid, largest possible value.
  *
  * When given values larger than actual possible monitor values, most
  * window managers who support the _NET_WM_FULLSCREEN_MONITORS spec
  * will simply unset _NET_WM_FULLSCREEN_MONITORS and revert to their
  * default behavior.
  *
  * Successfully tested on mutter/metacity, kwin, compiz and xfwm4.
  *
  * Note, this (non documented) mechanism is unlikely to be an issue
  * as it's used only for transitionning back from "all monitors" to
  * "current monitor" mode.
  *
  * Applications who don't change the default mode won't trigger this
  * mechanism.
  */
 for (i = 0; i < 4; ++i)
   xclient.data.l[i] = G_MAXLONG9223372036854775807L;

 break;

case CDK_FULLSCREEN_ON_ALL_MONITORS:

 _cdk_x11_screen_get_edge_monitors (CDK_WINDOW_SCREEN (window)(cdk_window_get_screen (window)),
			     &monitors[0],
			     &monitors[1],
			     &monitors[2],
			     &monitors[3]);
 /* Translate all 4 monitors from the CDK set into XINERAMA indices */
 for (i = 0; i < 4; ++i)
   {
     xclient.data.l[i] = monitors[i];
     /* Sanity check, if XINERAMA is not available, we could have invalid
      * negative values for the XINERAMA indices.
      */
     if (xclient.data.l[i] < 0)
{
  g_warning ("cdk_x11_window_apply_fullscreen_mode: Invalid XINERAMA monitor index");
  return;
}
   }
 break;

default:
 g_warning ("cdk_x11_window_apply_fullscreen_mode: Unhandled fullscreen mode %d",
     window->fullscreen_mode);
 return;
}

    /* Send fullscreen monitors client message */
    xclient.data.l[4] = 1; /* source indication */
    xclient.message_type = cdk_x11_get_xatom_by_name_for_display (CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display),
						    "_NET_WM_FULLSCREEN_MONITORS");
    XSendEvent (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay), CDK_WINDOW_XROOTWIN (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xroot_window), False0,
                SubstructureRedirectMask(1L<<20) | SubstructureNotifyMask(1L<<19),
                (XEvent *)&xclient);
  }
4318}

4320static void
4321cdk_x11_window_fullscreen (CdkWindow *window)
4322{
if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

if (CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
  {
    cdk_wmspec_change_state (TRUE(!(0)), window,
	       cdk_atom_intern_static_string ("_NET_WM_STATE_FULLSCREEN"),
                             CDK_NONE((CdkAtom)((gpointer) (gulong) (0))));
    /* Actual XRandR layout may have change since we computed the fullscreen
     * monitors in CDK_FULLSCREEN_ON_ALL_MONITORS mode.
     */
    if (window->fullscreen_mode == CDK_FULLSCREEN_ON_ALL_MONITORS)
cdk_x11_window_apply_fullscreen_mode (window);
  }
else
  cdk_synthesize_window_state (window,
                               0,
                               CDK_WINDOW_STATE_FULLSCREEN);
4342}

4344static void
4345cdk_x11_window_fullscreen_on_monitor (CdkWindow *window,
                                    gint       monitor)
4347{
CdkRectangle monitor_geom;

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

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

cdk_screen_get_monitor_geometry (CDK_WINDOW_SCREEN (window)(cdk_window_get_screen (window)), monitor, &monitor_geom);
cdk_window_move (window, monitor_geom.x, monitor_geom.y);
4357G_GNUC_END_IGNORE_DEPRECATIONSclang diagnostic pop

cdk_window_set_fullscreen_mode (window, CDK_FULLSCREEN_ON_CURRENT_MONITOR);
cdk_x11_window_fullscreen (window);
4361}

4363static void
4364cdk_x11_window_unfullscreen (CdkWindow *window)
4365{
if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

if (CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
  cdk_wmspec_change_state (FALSE(0), window,
	     cdk_atom_intern_static_string ("_NET_WM_STATE_FULLSCREEN"),
                           CDK_NONE((CdkAtom)((gpointer) (gulong) (0))));

else
  cdk_synthesize_window_state (window,
		 CDK_WINDOW_STATE_FULLSCREEN,
		 0);
4379}

4381static void
4382cdk_x11_window_set_keep_above (CdkWindow *window,
	       gboolean   setting)
4384{
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) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

if (CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
  {
    if (setting)
cdk_wmspec_change_state (FALSE(0), window,
		 cdk_atom_intern_static_string ("_NET_WM_STATE_BELOW"),
		 CDK_NONE((CdkAtom)((gpointer) (gulong) (0))));
    cdk_wmspec_change_state (setting, window,
	       cdk_atom_intern_static_string ("_NET_WM_STATE_ABOVE"),
	       CDK_NONE((CdkAtom)((gpointer) (gulong) (0))));
  }
else
  cdk_synthesize_window_state (window,
  				 setting ? CDK_WINDOW_STATE_BELOW : CDK_WINDOW_STATE_ABOVE,
		 setting ? CDK_WINDOW_STATE_ABOVE : 0);
4405}

4407static void
4408cdk_x11_window_set_keep_below (CdkWindow *window, gboolean setting)
4409{
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) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

if (CDK_WINDOW_IS_MAPPED (window)(((window)->state & CDK_WINDOW_STATE_WITHDRAWN) == 0))
  {
    if (setting)
cdk_wmspec_change_state (FALSE(0), window,
		 cdk_atom_intern_static_string ("_NET_WM_STATE_ABOVE"),
		 CDK_NONE((CdkAtom)((gpointer) (gulong) (0))));
    cdk_wmspec_change_state (setting, window,
	       cdk_atom_intern_static_string ("_NET_WM_STATE_BELOW"),
	       CDK_NONE((CdkAtom)((gpointer) (gulong) (0))));
  }
else
  cdk_synthesize_window_state (window,
		 setting ? CDK_WINDOW_STATE_ABOVE : CDK_WINDOW_STATE_BELOW,
		 setting ? CDK_WINDOW_STATE_BELOW : 0);
4430}

4432static CdkWindow *
4433cdk_x11_window_get_group (CdkWindow *window)
4434{
CdkToplevelX11 *toplevel;

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
))
  return NULL((void*)0);

toplevel = _cdk_x11_window_get_toplevel (window);

return toplevel->group_leader;
4444}

4446static void
4447cdk_x11_window_set_group (CdkWindow *window,
	  CdkWindow *leader)
4449{
CdkToplevelX11 *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);
g_return_if_fail (CDK_WINDOW_TYPE (window) != CDK_WINDOW_CHILD)do { if ((((((CdkWindow *)(window)))->window_type) != CDK_WINDOW_CHILD
)) { } else { g_return_if_fail_warning ("Cdk", ((const char*)
 (__func__)), "CDK_WINDOW_TYPE (window) != CDK_WINDOW_CHILD")
; return; } } while (0);
g_return_if_fail (leader == NULL || CDK_IS_WINDOW (leader))do { if ((leader == ((void*)0) || (((__extension__ ({ GTypeInstance
 *__inst = (GTypeInstance*) ((leader)); 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__)), "leader == NULL || CDK_IS_WINDOW (leader)"
); return; } } while (0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    (leader != NULL((void*)0) && CDK_WINDOW_DESTROYED (leader)(((CdkWindow *)(leader))->destroyed)) ||
    !WINDOW_IS_TOPLEVEL (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
))
  return;

toplevel = _cdk_x11_window_get_toplevel (window);

if (leader == NULL((void*)0))
  leader = cdk_display_get_default_group (cdk_window_get_display (window));

if (toplevel->group_leader != leader)
  {
    if (toplevel->group_leader)
g_object_unref (toplevel->group_leader);
    toplevel->group_leader = g_object_ref (leader)((__typeof__ (leader)) (g_object_ref) (leader));
    (_cdk_x11_window_get_toplevel (leader))->is_leader = TRUE(!(0));      
  }

update_wm_hints (window, FALSE(0));
4475}

4477static MotifWmHints *
4478cdk_window_get_mwm_hints (CdkWindow *window)
4479{
CdkDisplay *display;
Atom hints_atom = None0L;
guchar *data;
Atom type;
gint format;
gulong nitems;
gulong bytes_after;

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

display = cdk_window_get_display (window);

hints_atom = cdk_x11_get_xatom_by_name_for_display (display, _XA_MOTIF_WM_HINTS"_MOTIF_WM_HINTS");

XGetWindowProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
      hints_atom, 0, sizeof (MotifWmHints)/sizeof (long),
      False0, AnyPropertyType0L, &type, &format, &nitems,
      &bytes_after, &data);

if (type == None0L)
  return NULL((void*)0);

return (MotifWmHints *)data;
4504}

4506static void
4507cdk_window_set_mwm_hints (CdkWindow *window,
	  MotifWmHints *new_hints)
4509{
CdkDisplay *display;
Atom hints_atom = None0L;
guchar *data;
MotifWmHints *hints;
Atom type;
gint format;
gulong nitems;
gulong bytes_after;

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

display = cdk_window_get_display (window);

hints_atom = cdk_x11_get_xatom_by_name_for_display (display, _XA_MOTIF_WM_HINTS"_MOTIF_WM_HINTS");

XGetWindowProperty (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay), CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
      hints_atom, 0, sizeof (MotifWmHints)/sizeof (long),
      False0, AnyPropertyType0L, &type, &format, &nitems,
      &bytes_after, &data);

if (type == None0L)
  hints = new_hints;
else
  {
    hints = (MotifWmHints *)data;

    if (new_hints->flags & MWM_HINTS_FUNCTIONS(1L << 0))
{
 hints->flags |= MWM_HINTS_FUNCTIONS(1L << 0);
 hints->functions = new_hints->functions;
}
    if (new_hints->flags & MWM_HINTS_DECORATIONS(1L << 1))
{
 hints->flags |= MWM_HINTS_DECORATIONS(1L << 1);
 hints->decorations = new_hints->decorations;
}
  }

XChangeProperty (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay), CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
   hints_atom, hints_atom, 32, PropModeReplace0,
   (guchar *)hints, sizeof (MotifWmHints)/sizeof (long));

if (hints != new_hints)
  XFree (hints);
4555}

4557static void
4558cdk_x11_window_set_decorations (CdkWindow      *window,
		CdkWMDecoration decorations)
4560{
MotifWmHints hints;

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

/* initialize to zero to avoid writing uninitialized data to socket */
memset(&hints, 0, sizeof(hints));
hints.flags = MWM_HINTS_DECORATIONS(1L << 1);
hints.decorations = decorations;

cdk_window_set_mwm_hints (window, &hints);
4573}

4575static gboolean
4576cdk_x11_window_get_decorations(CdkWindow       *window,
	       CdkWMDecoration *decorations)
4578{
MotifWmHints *hints;
gboolean result = FALSE(0);

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return FALSE(0);

hints = cdk_window_get_mwm_hints (window);

if (hints)
  {
    if (hints->flags & MWM_HINTS_DECORATIONS(1L << 1))
{
 if (decorations)
   *decorations = hints->decorations;
 result = TRUE(!(0));
}
    
    XFree (hints);
  }

return result;
4601}

4603static void
4604cdk_x11_window_set_functions (CdkWindow    *window,
                            CdkWMFunction functions)
4606{
MotifWmHints hints;

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) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

/* initialize to zero to avoid writing uninitialized data to socket */
memset(&hints, 0, sizeof(hints));
hints.flags = MWM_HINTS_FUNCTIONS(1L << 0);
hints.functions = functions;

cdk_window_set_mwm_hints (window, &hints);
4621}

4623cairo_region_t *
4624_cdk_x11_xwindow_get_shape (Display *xdisplay,
                          Window   window,
                          gint     scale,
                          gint     shape_type)
4628{
cairo_region_t *shape;
CdkRectangle *rl;
XRectangle *xrl;
gint rn, ord, i;

shape = NULL((void*)0);
rn = 0;

/* Note that XShapeGetRectangles returns NULL in two situations:
 * - the server doesn't support the SHAPE extension
 * - the shape is empty
 *
 * Since we can't discriminate these here, we always return
 * an empty shape. It is the callers responsibility to check
 * whether the server supports the SHAPE extensions beforehand.
 */
xrl = XShapeGetRectangles (xdisplay, window, shape_type, &rn, &ord);

if (rn == 0)
  return cairo_region_create (); /* Empty */

if (ord != YXBanded3)
  {
    /* This really shouldn't happen with any xserver, as they
     * generally convert regions to YXBanded internally
     */
    g_warning ("non YXBanded shape masks not supported");
    XFree (xrl);
    return NULL((void*)0);
  }

/* NOTE: The scale divisions here may lose some precision if someone
   else set the shape to be non-scale precision */
rl = g_new (CdkRectangle, rn)((CdkRectangle *) g_malloc_n ((rn), sizeof (CdkRectangle)));
for (i = 0; i < rn; i++)
  {
    rl[i].x = xrl[i].x / scale;
    rl[i].y = xrl[i].y / scale;
    rl[i].width = xrl[i].width / scale;
    rl[i].height = xrl[i].height / scale;
  }
XFree (xrl);

shape = cairo_region_create_rectangles (rl, rn);
g_free (rl);

return shape;
4676}


4679static cairo_region_t *
4680cdk_x11_window_get_shape (CdkWindow *window)
4681{
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));

if (!CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) &&
    cdk_display_supports_shapes (CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display)))
  return _cdk_x11_xwindow_get_shape (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                                     CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                                     impl->window_scale,
                                     ShapeBounding0);

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

4694static cairo_region_t *
4695cdk_x11_window_get_input_shape (CdkWindow *window)
4696{
4697#if defined(ShapeInput2)
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));

if (!CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) &&
    cdk_display_supports_input_shapes (CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display)))
  return _cdk_x11_xwindow_get_shape (CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay),
                                     CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                                     impl->window_scale,
                                     ShapeInput2);
4706#endif

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

4711/* From the WM spec */
4712#define _NET_WM_MOVERESIZE_SIZE_TOPLEFT0      0
4713#define _NET_WM_MOVERESIZE_SIZE_TOP1          1
4714#define _NET_WM_MOVERESIZE_SIZE_TOPRIGHT2     2
4715#define _NET_WM_MOVERESIZE_SIZE_RIGHT3        3
4716#define _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT4  4
4717#define _NET_WM_MOVERESIZE_SIZE_BOTTOM5       5
4718#define _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT6   6
4719#define _NET_WM_MOVERESIZE_SIZE_LEFT7         7
4720#define _NET_WM_MOVERESIZE_MOVE8              8   /* movement only */
4721#define _NET_WM_MOVERESIZE_SIZE_KEYBOARD9     9   /* size via keyboard */
4722#define _NET_WM_MOVERESIZE_MOVE_KEYBOARD10    10   /* move via keyboard */
4723#define _NET_WM_MOVERESIZE_CANCEL11           11   /* cancel operation */

4725static void
4726wmspec_send_message (CdkDisplay *display,
                   CdkWindow  *window,
                   gint        root_x,
                   gint        root_y,
                   gint        action,
                   gint        button)
4732{
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));
XClientMessageEvent xclient;

memset (&xclient, 0, sizeof (xclient));
xclient.type = ClientMessage33;
xclient.window = CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid);
xclient.message_type =
  cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_MOVERESIZE");
xclient.format = 32;
xclient.data.l[0] = root_x * impl->window_scale;
xclient.data.l[1] = root_y * impl->window_scale;
xclient.data.l[2] = action;
xclient.data.l[3] = button;
xclient.data.l[4] = 1;  /* source indication */

XSendEvent (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), CDK_WINDOW_XROOTWIN (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xroot_window), False0,
            SubstructureRedirectMask(1L<<20) | SubstructureNotifyMask(1L<<19),
            (XEvent *)&xclient);
4751}

4753static void
4754handle_wmspec_button_release (CdkDisplay *display,
                            XEvent     *xevent)
4756{
CdkX11Display *display_x11 = CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))));
CdkWindow *window;

4760#if defined (HAVE_XGENERICEVENTS1) && defined (XINPUT_21)
XIEvent *xiev = (XIEvent *) xevent->xcookie.data;
XIDeviceEvent *xidev = (XIDeviceEvent *) xiev;

if (xevent->xany.type == GenericEvent35)
  window = cdk_x11_window_lookup_for_display (display, xidev->event);
else
4767#endif
  window = cdk_x11_window_lookup_for_display (display, xevent->xany.window);

if (display_x11->wm_moveresize_button != 0 && window != NULL((void*)0))
  {
    if ((xevent->xany.type == ButtonRelease5 &&
         xevent->xbutton.button == display_x11->wm_moveresize_button)
4774#if defined (HAVE_XGENERICEVENTS1) && defined (XINPUT_21)
        ||
        (xevent->xany.type == GenericEvent35 &&
         xiev->evtype == XI_ButtonRelease5 &&
         xidev->detail == display_x11->wm_moveresize_button)
4779#endif
        )
      {
        display_x11->wm_moveresize_button = 0;
        wmspec_send_message (display, window, 0, 0, _NET_WM_MOVERESIZE_CANCEL11, 0);
      }
  }
4786}

4788static void
4789wmspec_moveresize (CdkWindow *window,
                 gint       direction,
                 CdkDevice *device,
                 gint       button,
                 gint       root_x,
                 gint       root_y,
                 guint32    timestamp G_GNUC_UNUSED__attribute__ ((__unused__)))
4796{
CdkDisplay *display = CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display);

if (button != 0)
  cdk_seat_ungrab (cdk_device_get_seat (device)); /* Release passive grab */
CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->wm_moveresize_button = button;

wmspec_send_message (display, window, root_x, root_y, direction, button);
4804}

4806static void
4807wmspec_resize_drag (CdkWindow     *window,
                  CdkWindowEdge  edge,
                  CdkDevice     *device,
                  gint           button,
                  gint           root_x,
                  gint           root_y,
                  guint32        timestamp)
4814{
gint direction;

if (button == 0)
  direction = _NET_WM_MOVERESIZE_SIZE_KEYBOARD9;
else
  switch (edge)
    {
    /* Let the compiler turn a switch into a table, instead
     * of doing the table manually, this way is easier to verify.
     */
    case CDK_WINDOW_EDGE_NORTH_WEST:
      direction = _NET_WM_MOVERESIZE_SIZE_TOPLEFT0;
      break;

    case CDK_WINDOW_EDGE_NORTH:
      direction = _NET_WM_MOVERESIZE_SIZE_TOP1;
      break;

    case CDK_WINDOW_EDGE_NORTH_EAST:
      direction = _NET_WM_MOVERESIZE_SIZE_TOPRIGHT2;
      break;

    case CDK_WINDOW_EDGE_WEST:
      direction = _NET_WM_MOVERESIZE_SIZE_LEFT7;
      break;

    case CDK_WINDOW_EDGE_EAST:
      direction = _NET_WM_MOVERESIZE_SIZE_RIGHT3;
      break;

    case CDK_WINDOW_EDGE_SOUTH_WEST:
      direction = _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT6;
      break;

    case CDK_WINDOW_EDGE_SOUTH:
      direction = _NET_WM_MOVERESIZE_SIZE_BOTTOM5;
      break;

    case CDK_WINDOW_EDGE_SOUTH_EAST:
      direction = _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT4;
      break;

    default:
      g_warning ("cdk_window_begin_resize_drag: bad resize edge %d!",
                 edge);
      return;
    }

wmspec_moveresize (window, direction, device, button, root_x, root_y, timestamp);
4864}

4866typedef struct _MoveResizeData MoveResizeData;

4868struct _MoveResizeData
4869{
CdkDisplay *display;

CdkWindow *moveresize_window;
CdkWindow *moveresize_emulation_window;
gboolean is_resize;
CdkWindowEdge resize_edge;
CdkDevice *device;
gint moveresize_button;
gint moveresize_x;
gint moveresize_y;
gint moveresize_orig_x;
gint moveresize_orig_y;
gint moveresize_orig_width;
gint moveresize_orig_height;
CdkWindowHints moveresize_geom_mask;
CdkGeometry moveresize_geometry;
Time moveresize_process_time;
XEvent *moveresize_pending_event;
4888};

4890static MoveResizeData *
4891get_move_resize_data (CdkDisplay *display,
      gboolean    create)
4893{
MoveResizeData *mv_resize;
static GQuark move_resize_quark = 0;

if (!move_resize_quark)
  move_resize_quark = g_quark_from_static_string ("cdk-window-moveresize");

mv_resize = g_object_get_qdata (G_OBJECT (display)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), (((GType) ((20) << (2)))))))), move_resize_quark);

if (!mv_resize && create)
  {
    mv_resize = g_new0 (MoveResizeData, 1)((MoveResizeData *) g_malloc0_n ((1), sizeof (MoveResizeData)
));
    mv_resize->display = display;
    
    g_object_set_qdata (G_OBJECT (display)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), (((GType) ((20) << (2)))))))), move_resize_quark, mv_resize);
  }

return mv_resize;
4911}

4913static void
4914check_maximize (MoveResizeData *mv_resize,
              gdouble         x_root G_GNUC_UNUSED__attribute__ ((__unused__)),
              gdouble         y_root)
4917{
CdkWindowState state;
gint y;

if (mv_resize->is_resize)
  return;

state = cdk_window_get_state (mv_resize->moveresize_window);

if (state & CDK_WINDOW_STATE_MAXIMIZED)
  return;

y = mv_resize->moveresize_orig_y + (y_root - mv_resize->moveresize_y);

if (y < 10)
  cdk_window_maximize (mv_resize->moveresize_window);
4933}

4935static void
4936check_unmaximize (MoveResizeData *mv_resize,
                gdouble         x_root,
                gdouble         y_root)
4939{
CdkWindowState state;
gint dx, dy;

if (mv_resize->is_resize)
  return;

state = cdk_window_get_state (mv_resize->moveresize_window);

if ((state & (CDK_WINDOW_STATE_MAXIMIZED | CDK_WINDOW_STATE_TILED)) == 0)
  return;

dx = x_root - mv_resize->moveresize_x;
dy = y_root - mv_resize->moveresize_y;

if (ABS (dx)(((dx) < 0) ? -(dx) : (dx)) > 20 || ABS (dy)(((dy) < 0) ? -(dy) : (dy)) > 20)
  cdk_window_unmaximize (mv_resize->moveresize_window);
4956}

4958static void
4959update_pos (MoveResizeData *mv_resize,
   gint            new_root_x,
   gint            new_root_y)
4962{
gint dx, dy;

check_unmaximize (mv_resize, new_root_x, new_root_y);
dx = new_root_x - mv_resize->moveresize_x;
dy = new_root_y - mv_resize->moveresize_y;

if (mv_resize->is_resize)
  {
    gint x, y, w, h;

    x = mv_resize->moveresize_orig_x;
    y = mv_resize->moveresize_orig_y;

    w = mv_resize->moveresize_orig_width;
    h = mv_resize->moveresize_orig_height;

    switch (mv_resize->resize_edge)
{
case CDK_WINDOW_EDGE_NORTH_WEST:
 x += dx;
 y += dy;
 w -= dx;
 h -= dy;
 break;
case CDK_WINDOW_EDGE_NORTH:
 y += dy;
 h -= dy;
 break;
case CDK_WINDOW_EDGE_NORTH_EAST:
 y += dy;
 h -= dy;
 w += dx;
 break;
case CDK_WINDOW_EDGE_SOUTH_WEST:
 h += dy;
 x += dx;
 w -= dx;
 break;
case CDK_WINDOW_EDGE_SOUTH_EAST:
 w += dx;
 h += dy;
 break;
case CDK_WINDOW_EDGE_SOUTH:
 h += dy;
 break;
case CDK_WINDOW_EDGE_EAST:
 w += dx;
 break;
case CDK_WINDOW_EDGE_WEST:
 x += dx;
 w -= dx;
 break;
}

    x = MAX (x, 0)(((x) > (0)) ? (x) : (0));
    y = MAX (y, 0)(((y) > (0)) ? (y) : (0));
    w = MAX (w, 1)(((w) > (1)) ? (w) : (1));
    h = MAX (h, 1)(((h) > (1)) ? (h) : (1));

    if (mv_resize->moveresize_geom_mask)
{
 cdk_window_constrain_size (&mv_resize->moveresize_geometry,
		     mv_resize->moveresize_geom_mask,
		     w, h, &w, &h);
}

    cdk_window_move_resize (mv_resize->moveresize_window, x, y, w, h);
  }
else
  {
    gint x, y;

    x = mv_resize->moveresize_orig_x + dx;
    y = mv_resize->moveresize_orig_y + dy;

    cdk_window_move (mv_resize->moveresize_window, x, y);
  }
5040}

5042static void
5043finish_drag (MoveResizeData *mv_resize)
5044{
cdk_window_destroy (mv_resize->moveresize_emulation_window);
mv_resize->moveresize_emulation_window = NULL((void*)0);
g_clear_object (&mv_resize->moveresize_window)do { _Static_assert (sizeof *((&mv_resize->moveresize_window
)) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (((&mv_resize->moveresize_window))) _pp = ((&mv_resize
->moveresize_window)); __typeof__ (*((&mv_resize->moveresize_window
))) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_object_unref
) (_ptr); } while (0);
g_clear_pointer (&mv_resize->moveresize_pending_event, g_free)do { _Static_assert (sizeof *(&mv_resize->moveresize_pending_event
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 ((&mv_resize->moveresize_pending_event)) _pp = (&
mv_resize->moveresize_pending_event); __typeof__ (*(&mv_resize
->moveresize_pending_event)) _ptr = *_pp; *_pp = ((void*)0
); if (_ptr) (g_free) (_ptr); } while (0);
5049}

5051static int
5052lookahead_motion_predicate (Display *xdisplay,
	    XEvent  *event,
	    XPointer arg)
5055{
gboolean *seen_release = (gboolean *)arg;
CdkDisplay *display = cdk_x11_lookup_xdisplay (xdisplay);
MoveResizeData *mv_resize = get_move_resize_data (display, FALSE(0));

if (*seen_release)
  return False0;

switch (event->xany.type)
  {
  case ButtonRelease5:
    *seen_release = TRUE(!(0));
    break;
  case MotionNotify6:
    mv_resize->moveresize_process_time = event->xmotion.time;
    break;
  default:
    break;
  }

return False0;
5076}

5078static gboolean
5079moveresize_lookahead (MoveResizeData *mv_resize,
      XEvent         *event)
5081{
XEvent tmp_event;
gboolean seen_release = FALSE(0);

if (mv_resize->moveresize_process_time)
  {
    if (event->xmotion.time == mv_resize->moveresize_process_time)
      {
        mv_resize->moveresize_process_time = 0;
        return TRUE(!(0));
      }
    else
      return FALSE(0);
  }

XCheckIfEvent (event->xany.display, &tmp_event,
               lookahead_motion_predicate, (XPointer) & seen_release);

return mv_resize->moveresize_process_time == 0;
5100}

5102gboolean
5103_cdk_x11_moveresize_handle_event (XEvent *event)
5104{
guint button_mask = 0;
CdkDisplay *display = cdk_x11_lookup_xdisplay (event->xany.display);
MoveResizeData *mv_resize = get_move_resize_data (display, FALSE(0));
CdkWindowImplX11 *impl;

if (!mv_resize || !mv_resize->moveresize_window)
  {
    handle_wmspec_button_release (display, event);
    return FALSE(0);
  }

impl = CDK_WINDOW_IMPL_X11 (mv_resize->moveresize_window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((mv_resize->moveresize_window->impl)),
 ((cdk_window_impl_x11_get_type ()))))));

if (mv_resize->moveresize_button != 0)
  button_mask = CDK_BUTTON1_MASK << (mv_resize->moveresize_button - 1);

switch (event->xany.type)
  {
  case MotionNotify6:
    if (mv_resize->moveresize_window->resize_count > 0)
      {
        if (mv_resize->moveresize_pending_event)
          *mv_resize->moveresize_pending_event = *event;
        else
          mv_resize->moveresize_pending_event =
            g_memdup2 (event, sizeof (XEvent));

        break;
      }
    if (!moveresize_lookahead (mv_resize, event))
      break;

    update_pos (mv_resize,
                event->xmotion.x_root / impl->window_scale,
                event->xmotion.y_root / impl->window_scale);

    /* This should never be triggered in normal cases, but in the
     * case where the drag started without an implicit grab being
     * in effect, we could miss the release if it occurs before
     * we grab the pointer; this ensures that we will never
     * get a permanently stuck grab.
     */
    if ((event->xmotion.state & button_mask) == 0)
      {
        check_maximize (mv_resize,
                        event->xmotion.x_root / impl->window_scale,
                        event->xmotion.y_root / impl->window_scale);
        finish_drag (mv_resize);
      }
    break;

  case ButtonRelease5:
    update_pos (mv_resize,
                event->xbutton.x_root / impl->window_scale,
                event->xbutton.y_root / impl->window_scale);

    if (event->xbutton.button == mv_resize->moveresize_button)
      {
        check_maximize (mv_resize,
                        event->xmotion.x_root / impl->window_scale,
                        event->xmotion.y_root / impl->window_scale);
        finish_drag (mv_resize);
      }
    break;

5170#if defined (HAVE_XGENERICEVENTS1) && defined (XINPUT_21)
  case GenericEvent35:
    {
      /* we just assume this is an XI2 event */
      XIEvent *ev = (XIEvent *) event->xcookie.data;
      XIDeviceEvent *xev = (XIDeviceEvent *)ev;
      gint state;
      switch (ev->evtype)
        {
        case XI_Motion6:
          update_pos (mv_resize, xev->root_x / impl->window_scale, xev->root_y / impl->window_scale);
          state = _cdk_x11_device_xi2_translate_state (&xev->mods, &xev->buttons, &xev->group);
          if ((state & button_mask) == 0)
            {
              check_maximize (mv_resize,
                              xev->root_x / impl->window_scale,
                              xev->root_y / impl->window_scale);
              finish_drag (mv_resize);
            }
          break;

        case XI_ButtonRelease5:
          update_pos (mv_resize, xev->root_x / impl->window_scale, xev->root_y / impl->window_scale);
          if (xev->detail == mv_resize->moveresize_button)
            {
              check_maximize (mv_resize,
                              xev->root_x / impl->window_scale,
                              xev->root_y / impl->window_scale);
              finish_drag (mv_resize);
            }
          break;
        }
    }
    break;
5204#endif

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

5210gboolean
5211_cdk_x11_moveresize_configure_done (CdkDisplay *display,
                                  CdkWindow  *window)
5213{
MoveResizeData *mv_resize = get_move_resize_data (display, FALSE(0));

if (!mv_resize || window != mv_resize->moveresize_window)
  return FALSE(0);

if (mv_resize->moveresize_pending_event)
  {
    XEvent *tmp_event;

    tmp_event = mv_resize->moveresize_pending_event;
    mv_resize->moveresize_pending_event = NULL((void*)0);
    _cdk_x11_moveresize_handle_event (tmp_event);
    g_free (tmp_event);
  }

return TRUE(!(0));
5230}

5232static void
5233create_moveresize_window (MoveResizeData *mv_resize,
                        guint32         timestamp G_GNUC_UNUSED__attribute__ ((__unused__)))
5235{
CdkWindowAttr attributes;
gint attributes_mask;
CdkGrabStatus status;

g_assert (mv_resize->moveresize_emulation_window == NULL)do { if (mv_resize->moveresize_emulation_window == ((void*
)0)) ; else g_assertion_message_expr ("Cdk", "cdkwindow-x11.c"
, 5240, ((const char*) (__func__)), "mv_resize->moveresize_emulation_window == NULL"
); } while (0);

attributes.x = -100;
attributes.y = -100;
attributes.width = 10;
attributes.height = 10;
attributes.window_type = CDK_WINDOW_TEMP;
attributes.wclass = CDK_INPUT_ONLY;
attributes.override_redirect = TRUE(!(0));
attributes.event_mask = 0;

attributes_mask = CDK_WA_X | CDK_WA_Y | CDK_WA_NOREDIR;

mv_resize->moveresize_emulation_window = 
  cdk_window_new (cdk_screen_get_root_window (cdk_display_get_default_screen (mv_resize->display)),
    &attributes,
    attributes_mask);

cdk_window_show (mv_resize->moveresize_emulation_window);

status = cdk_seat_grab (cdk_device_get_seat (mv_resize->device),
                        mv_resize->moveresize_emulation_window,
                        CDK_SEAT_CAPABILITY_POINTER, FALSE(0),
                        NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0));

if (status != CDK_GRAB_SUCCESS)
  {
    /* If this fails, some other client has grabbed the window
     * already.
     */
    finish_drag (mv_resize);
  }

mv_resize->moveresize_process_time = 0;
5274}

5276/* 
 Calculate mv_resize->moveresize_orig_x and mv_resize->moveresize_orig_y
 so that calling XMoveWindow with these coordinates will not move the 
 window.
 Note that this depends on the WM to implement ICCCM-compliant reference
 point handling.
5282*/
5283static void 
5284calculate_unmoving_origin (MoveResizeData *mv_resize)
5285{
CdkRectangle rect;
gint width, height;

if (mv_resize->moveresize_geom_mask & CDK_HINT_WIN_GRAVITY &&
    mv_resize->moveresize_geometry.win_gravity == CDK_GRAVITY_STATIC)
  {
    cdk_window_get_origin (mv_resize->moveresize_window,
	     &mv_resize->moveresize_orig_x,
	     &mv_resize->moveresize_orig_y);
  }
else
  {
    cdk_window_get_frame_extents (mv_resize->moveresize_window, &rect);
    cdk_window_get_geometry (mv_resize->moveresize_window, 
	       NULL((void*)0), NULL((void*)0), &width, &height);
    
    switch (mv_resize->moveresize_geometry.win_gravity) 
{
case CDK_GRAVITY_NORTH_WEST:
 mv_resize->moveresize_orig_x = rect.x;
 mv_resize->moveresize_orig_y = rect.y;
 break;
case CDK_GRAVITY_NORTH:
 mv_resize->moveresize_orig_x = rect.x + rect.width / 2 - width / 2;
 mv_resize->moveresize_orig_y = rect.y;
 break;	  
case CDK_GRAVITY_NORTH_EAST:
 mv_resize->moveresize_orig_x = rect.x + rect.width - width;
 mv_resize->moveresize_orig_y = rect.y;
 break;
case CDK_GRAVITY_WEST:
 mv_resize->moveresize_orig_x = rect.x;
 mv_resize->moveresize_orig_y = rect.y + rect.height / 2 - height / 2;
 break;
case CDK_GRAVITY_CENTER:
 mv_resize->moveresize_orig_x = rect.x + rect.width / 2 - width / 2;
 mv_resize->moveresize_orig_y = rect.y + rect.height / 2 - height / 2;
 break;
case CDK_GRAVITY_EAST:
 mv_resize->moveresize_orig_x = rect.x + rect.width - width;
 mv_resize->moveresize_orig_y = rect.y + rect.height / 2 - height / 2;
 break;
case CDK_GRAVITY_SOUTH_WEST:
 mv_resize->moveresize_orig_x = rect.x;
 mv_resize->moveresize_orig_y = rect.y + rect.height - height;
 break;
case CDK_GRAVITY_SOUTH:
 mv_resize->moveresize_orig_x = rect.x + rect.width / 2 - width / 2;
 mv_resize->moveresize_orig_y = rect.y + rect.height - height;
 break;
case CDK_GRAVITY_SOUTH_EAST:
 mv_resize->moveresize_orig_x = rect.x + rect.width - width;
 mv_resize->moveresize_orig_y = rect.y + rect.height - height;
 break;
default:
 mv_resize->moveresize_orig_x = rect.x;
 mv_resize->moveresize_orig_y = rect.y;
 break; 
}
  }  
5346}

5348static void
5349emulate_resize_drag (CdkWindow     *window,
                   CdkWindowEdge  edge,
                   CdkDevice     *device,
                   gint           button,
                   gint           root_x,
                   gint           root_y,
                   guint32        timestamp)
5356{
MoveResizeData *mv_resize = get_move_resize_data (CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display), TRUE(!(0)));

if (mv_resize->moveresize_window != NULL((void*)0))
  return; /* already a drag operation in progress */

mv_resize->is_resize = TRUE(!(0));
mv_resize->moveresize_button = button;
mv_resize->resize_edge = edge;
mv_resize->device = device;
mv_resize->moveresize_x = root_x;
mv_resize->moveresize_y = root_y;
mv_resize->moveresize_window = g_object_ref (window)((__typeof__ (window)) (g_object_ref) (window));

mv_resize->moveresize_orig_width = cdk_window_get_width (window);
mv_resize->moveresize_orig_height = cdk_window_get_height (window);

mv_resize->moveresize_geom_mask = 0;
cdk_window_get_geometry_hints (window,
		 &mv_resize->moveresize_geometry,
		 &mv_resize->moveresize_geom_mask);

calculate_unmoving_origin (mv_resize);

create_moveresize_window (mv_resize, timestamp);
5381}

5383static void
5384emulate_move_drag (CdkWindow     *window,
                 CdkDevice     *device,
                 gint           button,
                 gint           root_x,
                 gint           root_y,
                 guint32        timestamp)
5390{
MoveResizeData *mv_resize = get_move_resize_data (CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display), TRUE(!(0)));

if (mv_resize->moveresize_window != NULL((void*)0))
  return; /* already a drag operation in progress */

mv_resize->is_resize = FALSE(0);
mv_resize->device = device;
mv_resize->moveresize_button = button;
mv_resize->moveresize_x = root_x;
mv_resize->moveresize_y = root_y;

mv_resize->moveresize_window = g_object_ref (window)((__typeof__ (window)) (g_object_ref) (window));

calculate_unmoving_origin (mv_resize);

create_moveresize_window (mv_resize, timestamp);
5407}

5409static gboolean
5410_should_perform_ewmh_drag (CdkWindow *window,
                         CdkDevice *device)
5412{
CdkPointerWindowInfo *info;
CdkDisplay *display;

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

if ((!info->last_slave || cdk_device_get_source (info->last_slave) != CDK_SOURCE_TOUCHSCREEN) &&
    cdk_x11_screen_supports_net_wm_hint (CDK_WINDOW_SCREEN (window)(cdk_window_get_screen (window)),
                                         cdk_atom_intern_static_string ("_NET_WM_MOVERESIZE")))
  return TRUE(!(0));

return FALSE(0);
5425}

5427static void
5428cdk_x11_window_begin_resize_drag (CdkWindow     *window,
                                CdkWindowEdge  edge,
                                CdkDevice     *device,
                                gint           button,
                                gint           root_x,
                                gint           root_y,
                                guint32        timestamp)
5435{
if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) ||
    !WINDOW_IS_TOPLEVEL_OR_FOREIGN (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_FOREIGN
))
  return;

/* Avoid EWMH for touch devices */
if (_should_perform_ewmh_drag (window, device))
  wmspec_resize_drag (window, edge, device, button, root_x, root_y, timestamp);
else
  emulate_resize_drag (window, edge, device, button, root_x, root_y, timestamp);
5445}

5447static void
5448cdk_x11_window_begin_move_drag (CdkWindow *window,
                              CdkDevice *device,
		gint       button,
		gint       root_x,
		gint       root_y,
		guint32    timestamp)
5454{
gint direction;

if (CDK_WINDOW_DESTROYED (window)(((CdkWindow *)(window))->destroyed) || !WINDOW_IS_TOPLEVEL (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
))
  return;

if (button == 0)
  direction = _NET_WM_MOVERESIZE_MOVE_KEYBOARD10;
else
  direction = _NET_WM_MOVERESIZE_MOVE8;

/* Avoid EWMH for touch devices */
if (_should_perform_ewmh_drag (window, device))
  wmspec_moveresize (window, direction, device, button, root_x, root_y, timestamp);
else
  emulate_move_drag (window, device, button, root_x, root_y, timestamp);
5470}

5472static gboolean
5473cdk_x11_window_beep (CdkWindow *window)
5474{
CdkDisplay *display;

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

if (!CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->trusted_client)
  return FALSE(0);

5482#ifdef HAVE_XKB1
if (CDK_X11_DISPLAY (display)((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->use_xkb)
  {
    XkbBell (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
),
             CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
             0,
             None0L);
    return TRUE(!(0));
  }
5491#endif

return FALSE(0);
5494}

5496static void
5497cdk_x11_window_set_opacity (CdkWindow *window,
	    gdouble    opacity)
5499{
CdkDisplay *display;
gulong cardinal;

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) ||
    !WINDOW_IS_TOPLEVEL (window)(((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TOPLEVEL
 || ((((CdkWindow *)(window)))->window_type) == CDK_WINDOW_TEMP
))
  return;

display = cdk_window_get_display (window);

if (opacity < 0)
  opacity = 0;
else if (opacity > 1)
  opacity = 1;

cardinal = opacity * 0xffffffff;

if (cardinal == 0xffffffff)
  XDeleteProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
),
     CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
     cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_OPACITY"));
else
  XChangeProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
),
     CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
     cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_WINDOW_OPACITY"),
     XA_CARDINAL((Atom) 6), 32,
     PropModeReplace0,
     (guchar *) &cardinal, 1);
5529}

5531static void
5532cdk_x11_window_set_composited (CdkWindow *window,
                             gboolean   composited)
5534{
5535#if defined(HAVE_XCOMPOSITE1) && defined(HAVE_XDAMAGE1) && defined (HAVE_XFIXES1)
CdkWindowImplX11 *impl;
CdkDisplay *display;
Display *dpy;
Window xid;

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

display = cdk_window_get_display (window);
dpy = CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
);
xid = CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid);

if (composited)
  {
    XCompositeRedirectWindow (dpy, xid, CompositeRedirectManual1);
    impl->damage = XDamageCreate (dpy, xid, XDamageReportBoundingBox2);
  }
else
  {
    XCompositeUnredirectWindow (dpy, xid, CompositeRedirectManual1);
    XDamageDestroy (dpy, impl->damage);
    impl->damage = None0L;
  }
5558#endif
5559}

5561void
5562_cdk_x11_display_before_process_all_updates (CdkDisplay *display G_GNUC_UNUSED__attribute__ ((__unused__)))
5563{
5564}

5566void
5567_cdk_x11_display_after_process_all_updates (CdkDisplay *display)
5568{
/* Sync after all drawing, otherwise the client can get "ahead" of
   the server rendering during animations, such that we fill up
   the Xserver pipes with sync rendering ops not letting other
   clients (including the VM) do anything. */
XSync (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), FALSE(0));
5574}

5576static Boolint
5577timestamp_predicate (Display *display,
     XEvent  *xevent,
     XPointer arg)
5580{
Window xwindow = GPOINTER_TO_UINT (arg)((guint) (gulong) (arg));
CdkDisplay *cdk_display = cdk_x11_lookup_xdisplay (display);

if (xevent->type == PropertyNotify28 &&
    xevent->xproperty.window == xwindow &&
    xevent->xproperty.atom == cdk_x11_get_xatom_by_name_for_display (cdk_display,
						       "CDK_TIMESTAMP_PROP"))
  return True1;

return False0;
5591}

5593/**
* cdk_x11_get_server_time:
* @window: (type CdkX11Window): a #CdkWindow, used for communication
*          with the server.  The window must have
*          CDK_PROPERTY_CHANGE_MASK in its events mask or a hang will
*          result.
*
* Routine to get the current X server time stamp.
*
* Returns: the time stamp.
**/
5604guint32
5605cdk_x11_get_server_time (CdkWindow *window)
5606{
Display *xdisplay;
Window   xwindow;
guchar c = 'a';
XEvent xevent;
Atom timestamp_prop_atom;

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_WINDOW_DESTROYED (window), 0)do { if ((!(((CdkWindow *)(window))->destroyed))) { } else
 { g_return_if_fail_warning ("Cdk", ((const char*) (__func__)
), "!CDK_WINDOW_DESTROYED (window)"); return (0); } } while (
0);

xdisplay = CDK_WINDOW_XDISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xdisplay);
xwindow = CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid);
timestamp_prop_atom =
  cdk_x11_get_xatom_by_name_for_display (CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display),
			   "CDK_TIMESTAMP_PROP");

XChangeProperty (xdisplay, xwindow, timestamp_prop_atom,
   timestamp_prop_atom,
   8, PropModeReplace0, &c, 1);

XIfEvent (xdisplay, &xevent,
   timestamp_predicate, GUINT_TO_POINTER(xwindow)((gpointer) (gulong) (xwindow)));

return xevent.xproperty.time;
5630}

5632/**
* cdk_x11_window_get_xid:
* @window: (type CdkX11Window): a native #CdkWindow.
* 
* Returns the X resource (window) belonging to a #CdkWindow.
* 
* Returns: the ID of @drawable’s X resource.
**/
5640XID
5641cdk_x11_window_get_xid (CdkWindow *window)
5642{
/* Try to ensure the window has a native window */
if (!_cdk_window_has_impl (window))
  {
    cdk_window_ensure_native (window);

    /* We sync here to ensure the window is created in the Xserver when
     * this function returns. This is required because the returned XID
     * for this window must be valid immediately, even with another
     * connection to the Xserver */
    cdk_display_sync (cdk_window_get_display (window));
  }

if (!CDK_WINDOW_IS_X11 (window)((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*)
 (((window)->impl)); GType __t = ((cdk_window_impl_x11_get_type
 ())); gboolean __r; if (!__inst) __r = (0); else if (__inst->
g_class && __inst->g_class->g_type == __t) __r =
 (!(0)); else __r = g_type_check_instance_is_a (__inst, __t);
 __r; }))))))
  {
    g_warning (G_STRLOC"cdkwindow-x11.c" ":" "5657" " drawable is not a native X11 window");
    return None0L;
  }

return CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))))->xid;
5662}

5664static gint
5665cdk_x11_window_get_scale_factor (CdkWindow *window)
5666{
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));

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

return impl->window_scale;
5673}

5675/**
* cdk_x11_window_set_frame_sync_enabled:
* @window: (type CdkX11Window): a native #CdkWindow
* @frame_sync_enabled: whether frame-synchronization should be enabled
*
* This function can be used to disable frame synchronization for a window.
* Normally frame synchronziation will be enabled or disabled based on whether
* the system has a compositor that supports frame synchronization, but if
* the window is not directly managed by the window manager, then frame
* synchronziation may need to be disabled. This is the case for a window
* embedded via the XEMBED protocol.
*
* Since: 3.8
*/
5689void
5690cdk_x11_window_set_frame_sync_enabled (CdkWindow *window,
                                     gboolean   frame_sync_enabled G_GNUC_UNUSED__attribute__ ((__unused__)))
5692{
/* Try to ensure the window has a native window */
if (!_cdk_window_has_impl (window))
  cdk_window_ensure_native (window);

if (!CDK_WINDOW_IS_X11 (window)((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*)
 (((window)->impl)); GType __t = ((cdk_window_impl_x11_get_type
 ())); gboolean __r; if (!__inst) __r = (0); else if (__inst->
g_class && __inst->g_class->g_type == __t) __r =
 (!(0)); else __r = g_type_check_instance_is_a (__inst, __t);
 __r; }))))))
  {
    g_warning (G_STRLOC"cdkwindow-x11.c" ":" "5699" " drawable is not a native X11 window");
    return;
  }

CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))))->frame_sync_enabled = FALSE(0);
5704}

5706static void
5707cdk_x11_window_set_opaque_region (CdkWindow      *window,
                                cairo_region_t *region)
5709{
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));
CdkDisplay *display;
int nitems;
gulong *data;

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

if (region != NULL((void*)0))
  {
    int i, nrects;

    nrects = cairo_region_num_rectangles (region);
    nitems = nrects * 4;
    data = g_new (gulong, nitems)((gulong *) g_malloc_n ((nitems), sizeof (gulong)));

    for (i = 0; i < nrects; i++)
      {
        cairo_rectangle_int_t rect;
        cairo_region_get_rectangle (region, i, &rect);
        data[i*4+0] = rect.x * impl->window_scale;
        data[i*4+1] = rect.y * impl->window_scale;
        data[i*4+2] = rect.width * impl->window_scale;
        data[i*4+3] = rect.height * impl->window_scale;
      }
  }
else
  {
    nitems = 0;
    data = NULL((void*)0);
  }

display = cdk_window_get_display (window);

XChangeProperty (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
),
                 CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid),
                 cdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_OPAQUE_REGION"),
                 XA_CARDINAL((Atom) 6), 32, PropModeReplace0,
                 (guchar *) data, nitems);

g_free (data);
5751}

5753static gboolean
5754cdk_x11_window_show_window_menu (CdkWindow *window,
                               CdkEvent  *event)
5756{
CdkWindowImplX11 *impl = CDK_WINDOW_IMPL_X11 (window->impl)((((CdkWindowImplX11*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((window->impl)), ((cdk_window_impl_x11_get_type
 ()))))));
CdkDisplay *display = CDK_WINDOW_DISPLAY (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->display);
CdkDevice *device;
int device_id;
double x_root, y_root;
XClientMessageEvent xclient = { 0 };

switch (event->type)
  {
  case CDK_BUTTON_PRESS:
  case CDK_BUTTON_RELEASE:
    break;
  default:
    return FALSE(0);
  }

if (!cdk_x11_screen_supports_net_wm_hint (CDK_WINDOW_SCREEN (window)(cdk_window_get_screen (window)),
                                          cdk_atom_intern_static_string ("_CTK_SHOW_WINDOW_MENU")))
  return FALSE(0);

cdk_event_get_root_coords (event, &x_root, &y_root);
device = cdk_event_get_device (event);
g_object_get (G_OBJECT (device)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((device)), (((GType) ((20) << (2)))))))),
              "device-id", &device_id,
              NULL((void*)0));

/* Ungrab the implicit grab */
cdk_seat_ungrab (cdk_device_get_seat (device));

xclient.type = ClientMessage33;
xclient.window = CDK_WINDOW_XID (window)(((((CdkWindowImplX11*) (void *) g_type_check_instance_cast (
(GTypeInstance*) ((((((CdkWindow*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((window)), ((cdk_window_get_type ()))))))
->impl)), ((cdk_window_impl_x11_get_type ()))))))->xid);
xclient.message_type = cdk_x11_get_xatom_by_name_for_display (display, "_CTK_SHOW_WINDOW_MENU");
xclient.data.l[0] = device_id;
xclient.data.l[1] = x_root * impl->window_scale;
xclient.data.l[2] = y_root * impl->window_scale;
xclient.format = 32;

XSendEvent (CDK_DISPLAY_XDISPLAY (display)(((((CdkX11Display*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((display)), ((cdk_x11_display_get_type()))))))->xdisplay
), CDK_WINDOW_XROOTWIN (window)(((((CdkX11Screen*) (void *) g_type_check_instance_cast ((GTypeInstance
*) (((cdk_window_get_screen (window)))), ((cdk_x11_screen_get_type
 ()))))))->xroot_window), False0,
            SubstructureRedirectMask(1L<<20) | SubstructureNotifyMask(1L<<19),
            (XEvent *)&xclient);

return TRUE(!(0));
5799}

5801static void
5802cdk_window_impl_x11_class_init (CdkWindowImplX11Class *klass)
5803{
GObjectClass *object_class = G_OBJECT_CLASS (klass)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((klass)), (((GType) ((20) << (2))))))));
CdkWindowImplClass *impl_class = CDK_WINDOW_IMPL_CLASS (klass)((((CdkWindowImplClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((klass)), ((cdk_window_impl_get_type ()))))));

object_class->finalize = cdk_window_impl_x11_finalize;

impl_class->ref_cairo_surface = cdk_x11_ref_cairo_surface;
impl_class->show = cdk_window_x11_show;
impl_class->hide = cdk_window_x11_hide;
impl_class->withdraw = cdk_window_x11_withdraw;
impl_class->set_events = cdk_window_x11_set_events;
impl_class->get_events = cdk_window_x11_get_events;
impl_class->raise = cdk_window_x11_raise;
impl_class->lower = cdk_window_x11_lower;
impl_class->restack_under = cdk_window_x11_restack_under;
impl_class->restack_toplevel = cdk_window_x11_restack_toplevel;
impl_class->move_resize = cdk_window_x11_move_resize;
impl_class->set_background = cdk_window_x11_set_background;
impl_class->reparent = cdk_window_x11_reparent;
impl_class->set_device_cursor = cdk_window_x11_set_device_cursor;
impl_class->get_geometry = cdk_window_x11_get_geometry;
impl_class->get_root_coords = cdk_window_x11_get_root_coords;
impl_class->get_device_state = cdk_window_x11_get_device_state;
impl_class->shape_combine_region = cdk_window_x11_shape_combine_region;
impl_class->input_shape_combine_region = cdk_window_x11_input_shape_combine_region;
impl_class->queue_antiexpose = _cdk_x11_window_queue_antiexpose;
impl_class->destroy = cdk_x11_window_destroy;
impl_class->destroy_foreign = cdk_x11_window_destroy_foreign;
impl_class->get_shape = cdk_x11_window_get_shape;
impl_class->get_input_shape = cdk_x11_window_get_input_shape;
impl_class->beep = cdk_x11_window_beep;

impl_class->focus = cdk_x11_window_focus;
impl_class->set_type_hint = cdk_x11_window_set_type_hint;
impl_class->get_type_hint = cdk_x11_window_get_type_hint;
impl_class->set_modal_hint = cdk_x11_window_set_modal_hint;
impl_class->set_skip_taskbar_hint = cdk_x11_window_set_skip_taskbar_hint;
impl_class->set_skip_pager_hint = cdk_x11_window_set_skip_pager_hint;
impl_class->set_urgency_hint = cdk_x11_window_set_urgency_hint;
impl_class->set_geometry_hints = cdk_x11_window_set_geometry_hints;
impl_class->set_title = cdk_x11_window_set_title;
impl_class->set_role = cdk_x11_window_set_role;
impl_class->set_startup_id = cdk_x11_window_set_startup_id;
impl_class->set_transient_for = cdk_x11_window_set_transient_for;
impl_class->get_frame_extents = cdk_x11_window_get_frame_extents;
impl_class->set_override_redirect = cdk_x11_window_set_override_redirect;
impl_class->set_accept_focus = cdk_x11_window_set_accept_focus;
impl_class->set_focus_on_map = cdk_x11_window_set_focus_on_map;
impl_class->set_icon_list = cdk_x11_window_set_icon_list;
impl_class->set_icon_name = cdk_x11_window_set_icon_name;
impl_class->iconify = cdk_x11_window_iconify;
impl_class->deiconify = cdk_x11_window_deiconify;
impl_class->stick = cdk_x11_window_stick;
impl_class->unstick = cdk_x11_window_unstick;
impl_class->maximize = cdk_x11_window_maximize;
impl_class->unmaximize = cdk_x11_window_unmaximize;
impl_class->fullscreen = cdk_x11_window_fullscreen;
impl_class->fullscreen_on_monitor = cdk_x11_window_fullscreen_on_monitor;
impl_class->apply_fullscreen_mode = cdk_x11_window_apply_fullscreen_mode;
impl_class->unfullscreen = cdk_x11_window_unfullscreen;
impl_class->set_keep_above = cdk_x11_window_set_keep_above;
impl_class->set_keep_below = cdk_x11_window_set_keep_below;
impl_class->get_group = cdk_x11_window_get_group;
impl_class->set_group = cdk_x11_window_set_group;
impl_class->set_decorations = cdk_x11_window_set_decorations;
impl_class->get_decorations = cdk_x11_window_get_decorations;
impl_class->set_functions = cdk_x11_window_set_functions;
impl_class->begin_resize_drag = cdk_x11_window_begin_resize_drag;
impl_class->begin_move_drag = cdk_x11_window_begin_move_drag;
impl_class->set_opacity = cdk_x11_window_set_opacity;
impl_class->set_composited = cdk_x11_window_set_composited;
impl_class->destroy_notify = cdk_x11_window_destroy_notify;
impl_class->get_drag_protocol = cdk_x11_window_get_drag_protocol;
impl_class->register_dnd = _cdk_x11_window_register_dnd;
impl_class->drag_begin = _cdk_x11_window_drag_begin;
impl_class->sync_rendering = _cdk_x11_window_sync_rendering;
impl_class->simulate_key = _cdk_x11_window_simulate_key;
impl_class->simulate_button = _cdk_x11_window_simulate_button;
impl_class->get_property = _cdk_x11_window_get_property;
impl_class->change_property = _cdk_x11_window_change_property;
impl_class->delete_property = _cdk_x11_window_delete_property;
impl_class->get_scale_factor = cdk_x11_window_get_scale_factor;
impl_class->set_opaque_region = cdk_x11_window_set_opaque_region;
impl_class->set_shadow_width = cdk_x11_window_set_shadow_width;
impl_class->show_window_menu = cdk_x11_window_show_window_menu;
impl_class->create_gl_context = cdk_x11_window_create_gl_context;
impl_class->invalidate_for_new_frame = cdk_x11_window_invalidate_for_new_frame;
impl_class->get_unscaled_size = cdk_x11_window_get_unscaled_size;
5891}