git.oblomov.eu Git - wine/blob - dlls/winex11.drv/window.c

   1 /*
   2  * Window related functions
   3  *
   4  * Copyright 1993, 1994, 1995, 1996, 2001 Alexandre Julliard
   5  * Copyright 1993 David Metcalfe
   6  * Copyright 1995, 1996 Alex Korobka
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24
  25 #include <stdarg.h>
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #ifdef HAVE_UNISTD_H
  29 # include <unistd.h>
  30 #endif
  31
  32 #include <X11/Xlib.h>
  33 #include <X11/Xresource.h>
  34 #include <X11/Xutil.h>
  35 #ifdef HAVE_LIBXSHAPE
  36 #include <X11/extensions/shape.h>
  37 #endif /* HAVE_LIBXSHAPE */
  38
  39 #include "windef.h"
  40 #include "winbase.h"
  41 #include "wingdi.h"
  42 #include "winuser.h"
  43 #include "wine/unicode.h"
  44
  45 #include "x11drv.h"
  46 #include "wine/debug.h"
  47 #include "wine/server.h"
  48 #include "mwm.h"
  49
  50 WINE_DEFAULT_DEBUG_CHANNEL(x11drv);
  51
  52 #define _NET_WM_MOVERESIZE_SIZE_TOPLEFT      0
  53 #define _NET_WM_MOVERESIZE_SIZE_TOP          1
  54 #define _NET_WM_MOVERESIZE_SIZE_TOPRIGHT     2
  55 #define _NET_WM_MOVERESIZE_SIZE_RIGHT        3
  56 #define _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT  4
  57 #define _NET_WM_MOVERESIZE_SIZE_BOTTOM       5
  58 #define _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT   6
  59 #define _NET_WM_MOVERESIZE_SIZE_LEFT         7
  60 #define _NET_WM_MOVERESIZE_MOVE              8
  61 #define _NET_WM_MOVERESIZE_SIZE_KEYBOARD     9
  62 #define _NET_WM_MOVERESIZE_MOVE_KEYBOARD    10
  63
  64 #define _NET_WM_STATE_REMOVE  0
  65 #define _NET_WM_STATE_ADD     1
  66 #define _NET_WM_STATE_TOGGLE  2
  67
  68 #define SWP_AGG_NOPOSCHANGE (SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE | SWP_NOZORDER)
  69
  70 /* is cursor clipping active? */
  71 int clipping_cursor = 0;
  72
  73 /* X context to associate a hwnd to an X window */
  74 XContext winContext = 0;
  75
  76 /* X context to associate a struct x11drv_win_data to an hwnd */
  77 XContext win_data_context = 0;
  78
  79 /* time of last user event and window where it's stored */
  80 static Time last_user_time;
  81 static Window user_time_window;
  82
  83 static const char foreign_window_prop[] = "__wine_x11_foreign_window";
  84 static const char whole_window_prop[] = "__wine_x11_whole_window";
  85 static const char clip_window_prop[]  = "__wine_x11_clip_window";
  86 static const char managed_prop[]      = "__wine_x11_managed";
  87
  88 static CRITICAL_SECTION win_data_section;
  89 static CRITICAL_SECTION_DEBUG critsect_debug =
  90 {
  91     0, 0, &win_data_section,
  92     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  93       0, 0, { (DWORD_PTR)(__FILE__ ": win_data_section") }
  94 };
  95 static CRITICAL_SECTION win_data_section = { &critsect_debug, -1, 0, 0, 0, 0 };
  96
  97
  98 /***********************************************************************
  99  * http://standards.freedesktop.org/startup-notification-spec
 100  */
 101 static void remove_startup_notification(Display *display, Window window)
 102 {
 103     static LONG startup_notification_removed = 0;
 104     char id[1024];
 105     char message[1024];
 106     int i;
 107     int pos;
 108     XEvent xevent;
 109     const char *src;
 110     int srclen;
 111
 112     if (InterlockedCompareExchange(&startup_notification_removed, 1, 0) != 0)
 113         return;
 114
 115     if (GetEnvironmentVariableA("DESKTOP_STARTUP_ID", id, sizeof(id)) == 0)
 116         return;
 117     SetEnvironmentVariableA("DESKTOP_STARTUP_ID", NULL);
 118
 119     if ((src = strstr( id, "_TIME" ))) update_user_time( atol( src + 5 ));
 120
 121     pos = snprintf(message, sizeof(message), "remove: ID=");
 122     message[pos++] = '"';
 123     for (i = 0; id[i] && pos < sizeof(message) - 2; i++)
 124     {
 125         if (id[i] == '"' || id[i] == '\\')
 126             message[pos++] = '\\';
 127         message[pos++] = id[i];
 128     }
 129     message[pos++] = '"';
 130     message[pos++] = '\0';
 131
 132     xevent.xclient.type = ClientMessage;
 133     xevent.xclient.message_type = x11drv_atom(_NET_STARTUP_INFO_BEGIN);
 134     xevent.xclient.display = display;
 135     xevent.xclient.window = window;
 136     xevent.xclient.format = 8;
 137
 138     src = message;
 139     srclen = strlen(src) + 1;
 140
 141     while (srclen > 0)
 142     {
 143         int msglen = srclen;
 144         if (msglen > 20)
 145             msglen = 20;
 146         memset(&xevent.xclient.data.b[0], 0, 20);
 147         memcpy(&xevent.xclient.data.b[0], src, msglen);
 148         src += msglen;
 149         srclen -= msglen;
 150
 151         XSendEvent( display, DefaultRootWindow( display ), False, PropertyChangeMask, &xevent );
 152         xevent.xclient.message_type = x11drv_atom(_NET_STARTUP_INFO);
 153     }
 154 }
 155
 156
 157 struct has_popup_result
 158 {
 159     HWND hwnd;
 160     BOOL found;
 161 };
 162
 163 static BOOL is_managed( HWND hwnd )
 164 {
 165     struct x11drv_win_data *data = get_win_data( hwnd );
 166     BOOL ret = data && data->managed;
 167     release_win_data( data );
 168     return ret;
 169 }
 170
 171 static BOOL CALLBACK has_managed_popup( HWND hwnd, LPARAM lparam )
 172 {
 173     struct has_popup_result *result = (struct has_popup_result *)lparam;
 174
 175     if (hwnd == result->hwnd) return FALSE;  /* popups are always above owner */
 176     if (GetWindow( hwnd, GW_OWNER ) != result->hwnd) return TRUE;
 177     result->found = is_managed( hwnd );
 178     return !result->found;
 179 }
 180
 181 static BOOL has_owned_popups( HWND hwnd )
 182 {
 183     struct has_popup_result result;
 184
 185     result.hwnd = hwnd;
 186     result.found = FALSE;
 187     EnumWindows( has_managed_popup, (LPARAM)&result );
 188     return result.found;
 189 }
 190
 191 /***********************************************************************
 192  *              is_window_managed
 193  *
 194  * Check if a given window should be managed
 195  */
 196 static BOOL is_window_managed( HWND hwnd, UINT swp_flags, const RECT *window_rect )
 197 {
 198     DWORD style, ex_style;
 199
 200     if (!managed_mode) return FALSE;
 201
 202     /* child windows are not managed */
 203     style = GetWindowLongW( hwnd, GWL_STYLE );
 204     if ((style & (WS_CHILD|WS_POPUP)) == WS_CHILD) return FALSE;
 205     /* activated windows are managed */
 206     if (!(swp_flags & (SWP_NOACTIVATE|SWP_HIDEWINDOW))) return TRUE;
 207     if (hwnd == GetActiveWindow()) return TRUE;
 208     /* windows with caption are managed */
 209     if ((style & WS_CAPTION) == WS_CAPTION) return TRUE;
 210     /* windows with thick frame are managed */
 211     if (style & WS_THICKFRAME) return TRUE;
 212     if (style & WS_POPUP)
 213     {
 214         HMONITOR hmon;
 215         MONITORINFO mi;
 216
 217         /* popup with sysmenu == caption are managed */
 218         if (style & WS_SYSMENU) return TRUE;
 219         /* full-screen popup windows are managed */
 220         hmon = MonitorFromWindow( hwnd, MONITOR_DEFAULTTOPRIMARY );
 221         mi.cbSize = sizeof( mi );
 222         GetMonitorInfoW( hmon, &mi );
 223         if (window_rect->left <= mi.rcWork.left && window_rect->right >= mi.rcWork.right &&
 224             window_rect->top <= mi.rcWork.top && window_rect->bottom >= mi.rcWork.bottom)
 225             return TRUE;
 226     }
 227     /* application windows are managed */
 228     ex_style = GetWindowLongW( hwnd, GWL_EXSTYLE );
 229     if (ex_style & WS_EX_APPWINDOW) return TRUE;
 230     /* windows that own popups are managed */
 231     if (has_owned_popups( hwnd )) return TRUE;
 232     /* default: not managed */
 233     return FALSE;
 234 }
 235
 236
 237 /***********************************************************************
 238  *              is_window_resizable
 239  *
 240  * Check if window should be made resizable by the window manager
 241  */
 242 static inline BOOL is_window_resizable( struct x11drv_win_data *data, DWORD style )
 243 {
 244     if (style & WS_THICKFRAME) return TRUE;
 245     /* Metacity needs the window to be resizable to make it fullscreen */
 246     return is_window_rect_fullscreen( &data->whole_rect );
 247 }
 248
 249
 250 /***********************************************************************
 251  *              get_mwm_decorations
 252  */
 253 static unsigned long get_mwm_decorations( struct x11drv_win_data *data,
 254                                           DWORD style, DWORD ex_style )
 255 {
 256     unsigned long ret = 0;
 257
 258     if (!decorated_mode) return 0;
 259
 260     if (IsRectEmpty( &data->window_rect )) return 0;
 261     if (data->shaped) return 0;
 262
 263     if (ex_style & WS_EX_TOOLWINDOW) return 0;
 264
 265     if ((style & WS_CAPTION) == WS_CAPTION)
 266     {
 267         ret |= MWM_DECOR_TITLE | MWM_DECOR_BORDER;
 268         if (style & WS_SYSMENU) ret |= MWM_DECOR_MENU;
 269         if (style & WS_MINIMIZEBOX) ret |= MWM_DECOR_MINIMIZE;
 270         if (style & WS_MAXIMIZEBOX) ret |= MWM_DECOR_MAXIMIZE;
 271     }
 272     if (ex_style & WS_EX_DLGMODALFRAME) ret |= MWM_DECOR_BORDER;
 273     else if (style & WS_THICKFRAME) ret |= MWM_DECOR_BORDER | MWM_DECOR_RESIZEH;
 274     else if ((style & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME) ret |= MWM_DECOR_BORDER;
 275     return ret;
 276 }
 277
 278
 279 /***********************************************************************
 280  *              get_x11_rect_offset
 281  *
 282  * Helper for X11DRV_window_to_X_rect and X11DRV_X_to_window_rect.
 283  */
 284 static void get_x11_rect_offset( struct x11drv_win_data *data, RECT *rect )
 285 {
 286     DWORD style, ex_style, style_mask = 0, ex_style_mask = 0;
 287     unsigned long decor;
 288
 289     rect->top = rect->bottom = rect->left = rect->right = 0;
 290
 291     style = GetWindowLongW( data->hwnd, GWL_STYLE );
 292     ex_style = GetWindowLongW( data->hwnd, GWL_EXSTYLE );
 293     decor = get_mwm_decorations( data, style, ex_style );
 294
 295     if (decor & MWM_DECOR_TITLE) style_mask |= WS_CAPTION;
 296     if (decor & MWM_DECOR_BORDER)
 297     {
 298         style_mask |= WS_DLGFRAME | WS_THICKFRAME;
 299         ex_style_mask |= WS_EX_DLGMODALFRAME;
 300     }
 301
 302     AdjustWindowRectEx( rect, style & style_mask, FALSE, ex_style & ex_style_mask );
 303 }
 304
 305
 306 /***********************************************************************
 307  *              get_window_attributes
 308  *
 309  * Fill the window attributes structure for an X window.
 310  */
 311 static int get_window_attributes( struct x11drv_win_data *data, XSetWindowAttributes *attr )
 312 {
 313     attr->override_redirect = !data->managed;
 314     attr->colormap          = X11DRV_PALETTE_PaletteXColormap;
 315     attr->save_under        = ((GetClassLongW( data->hwnd, GCL_STYLE ) & CS_SAVEBITS) != 0);
 316     attr->bit_gravity       = NorthWestGravity;
 317     attr->win_gravity       = StaticGravity;
 318     attr->backing_store     = NotUseful;
 319     attr->border_pixel      = 0;
 320     attr->event_mask        = (ExposureMask | PointerMotionMask |
 321                                ButtonPressMask | ButtonReleaseMask | EnterWindowMask |
 322                                KeyPressMask | KeyReleaseMask | FocusChangeMask |
 323                                KeymapStateMask | StructureNotifyMask);
 324     if (data->managed) attr->event_mask |= PropertyChangeMask;
 325
 326     return (CWOverrideRedirect | CWSaveUnder | CWColormap | CWBorderPixel |
 327             CWEventMask | CWBitGravity | CWBackingStore);
 328 }
 329
 330
 331 /***********************************************************************
 332  *              sync_window_style
 333  *
 334  * Change the X window attributes when the window style has changed.
 335  */
 336 static void sync_window_style( struct x11drv_win_data *data )
 337 {
 338     if (data->whole_window != root_window)
 339     {
 340         XSetWindowAttributes attr;
 341         int mask = get_window_attributes( data, &attr );
 342
 343         XChangeWindowAttributes( data->display, data->whole_window, mask, &attr );
 344     }
 345 }
 346
 347
 348 /***********************************************************************
 349  *              sync_window_region
 350  *
 351  * Update the X11 window region.
 352  */
 353 static void sync_window_region( struct x11drv_win_data *data, HRGN win_region )
 354 {
 355 #ifdef HAVE_LIBXSHAPE
 356     HRGN hrgn = win_region;
 357
 358     if (!data->whole_window) return;
 359     data->shaped = FALSE;
 360
 361     if (IsRectEmpty( &data->window_rect ))  /* set an empty shape */
 362     {
 363         static XRectangle empty_rect;
 364         XShapeCombineRectangles( data->display, data->whole_window, ShapeBounding, 0, 0,
 365                                  &empty_rect, 1, ShapeSet, YXBanded );
 366         return;
 367     }
 368
 369     if (hrgn == (HRGN)1)  /* hack: win_region == 1 means retrieve region from server */
 370     {
 371         if (!(hrgn = CreateRectRgn( 0, 0, 0, 0 ))) return;
 372         if (GetWindowRgn( data->hwnd, hrgn ) == ERROR)
 373         {
 374             DeleteObject( hrgn );
 375             hrgn = 0;
 376         }
 377     }
 378
 379     if (!hrgn)
 380     {
 381         XShapeCombineMask( data->display, data->whole_window, ShapeBounding, 0, 0, None, ShapeSet );
 382     }
 383     else
 384     {
 385         RGNDATA *pRegionData;
 386
 387         if (GetWindowLongW( data->hwnd, GWL_EXSTYLE ) & WS_EX_LAYOUTRTL) MirrorRgn( data->hwnd, hrgn );
 388         if ((pRegionData = X11DRV_GetRegionData( hrgn, 0 )))
 389         {
 390             XShapeCombineRectangles( data->display, data->whole_window, ShapeBounding,
 391                                      data->window_rect.left - data->whole_rect.left,
 392                                      data->window_rect.top - data->whole_rect.top,
 393                                      (XRectangle *)pRegionData->Buffer,
 394                                      pRegionData->rdh.nCount, ShapeSet, YXBanded );
 395             HeapFree(GetProcessHeap(), 0, pRegionData);
 396             data->shaped = TRUE;
 397         }
 398     }
 399     if (hrgn && hrgn != win_region) DeleteObject( hrgn );
 400 #endif  /* HAVE_LIBXSHAPE */
 401 }
 402
 403
 404 /***********************************************************************
 405  *              sync_window_opacity
 406  */
 407 static void sync_window_opacity( Display *display, Window win,
 408                                  COLORREF key, BYTE alpha, DWORD flags )
 409 {
 410     unsigned long opacity = 0xffffffff;
 411
 412     if (flags & LWA_ALPHA) opacity = (0xffffffff / 0xff) * alpha;
 413
 414     if (opacity == 0xffffffff)
 415         XDeleteProperty( display, win, x11drv_atom(_NET_WM_WINDOW_OPACITY) );
 416     else
 417         XChangeProperty( display, win, x11drv_atom(_NET_WM_WINDOW_OPACITY),
 418                          XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&opacity, 1 );
 419 }
 420
 421
 422 /***********************************************************************
 423  *              sync_window_text
 424  */
 425 static void sync_window_text( Display *display, Window win, const WCHAR *text )
 426 {
 427     UINT count;
 428     char *buffer, *utf8_buffer;
 429     XTextProperty prop;
 430
 431     /* allocate new buffer for window text */
 432     count = WideCharToMultiByte(CP_UNIXCP, 0, text, -1, NULL, 0, NULL, NULL);
 433     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, count ))) return;
 434     WideCharToMultiByte(CP_UNIXCP, 0, text, -1, buffer, count, NULL, NULL);
 435
 436     count = WideCharToMultiByte(CP_UTF8, 0, text, strlenW(text), NULL, 0, NULL, NULL);
 437     if (!(utf8_buffer = HeapAlloc( GetProcessHeap(), 0, count )))
 438     {
 439         HeapFree( GetProcessHeap(), 0, buffer );
 440         return;
 441     }
 442     WideCharToMultiByte(CP_UTF8, 0, text, strlenW(text), utf8_buffer, count, NULL, NULL);
 443
 444     if (XmbTextListToTextProperty( display, &buffer, 1, XStdICCTextStyle, &prop ) == Success)
 445     {
 446         XSetWMName( display, win, &prop );
 447         XSetWMIconName( display, win, &prop );
 448         XFree( prop.value );
 449     }
 450     /*
 451       Implements a NET_WM UTF-8 title. It should be without a trailing \0,
 452       according to the standard
 453       ( http://www.pps.jussieu.fr/~jch/software/UTF8_STRING/UTF8_STRING.text ).
 454     */
 455     XChangeProperty( display, win, x11drv_atom(_NET_WM_NAME), x11drv_atom(UTF8_STRING),
 456                      8, PropModeReplace, (unsigned char *) utf8_buffer, count);
 457
 458     HeapFree( GetProcessHeap(), 0, utf8_buffer );
 459     HeapFree( GetProcessHeap(), 0, buffer );
 460 }
 461
 462
 463 /***********************************************************************
 464  *              get_bitmap_argb
 465  *
 466  * Return the bitmap bits in ARGB format. Helper for setting icon hints.
 467  */
 468 static unsigned long *get_bitmap_argb( HDC hdc, HBITMAP color, HBITMAP mask, unsigned int *size )
 469 {
 470     char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
 471     BITMAPINFO *info = (BITMAPINFO *)buffer;
 472     BITMAP bm;
 473     unsigned int *ptr, *bits = NULL;
 474     unsigned char *mask_bits = NULL;
 475     int i, j, has_alpha = 0;
 476
 477     if (!GetObjectW( color, sizeof(bm), &bm )) return NULL;
 478     info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 479     info->bmiHeader.biWidth = bm.bmWidth;
 480     info->bmiHeader.biHeight = -bm.bmHeight;
 481     info->bmiHeader.biPlanes = 1;
 482     info->bmiHeader.biBitCount = 32;
 483     info->bmiHeader.biCompression = BI_RGB;
 484     info->bmiHeader.biSizeImage = bm.bmWidth * bm.bmHeight * 4;
 485     info->bmiHeader.biXPelsPerMeter = 0;
 486     info->bmiHeader.biYPelsPerMeter = 0;
 487     info->bmiHeader.biClrUsed = 0;
 488     info->bmiHeader.biClrImportant = 0;
 489     *size = bm.bmWidth * bm.bmHeight + 2;
 490     if (!(bits = HeapAlloc( GetProcessHeap(), 0, *size * sizeof(long) ))) goto failed;
 491     if (!GetDIBits( hdc, color, 0, bm.bmHeight, bits + 2, info, DIB_RGB_COLORS )) goto failed;
 492
 493     bits[0] = bm.bmWidth;
 494     bits[1] = bm.bmHeight;
 495
 496     for (i = 0; i < bm.bmWidth * bm.bmHeight; i++)
 497         if ((has_alpha = (bits[i + 2] & 0xff000000) != 0)) break;
 498
 499     if (!has_alpha)
 500     {
 501         unsigned int width_bytes = (bm.bmWidth + 31) / 32 * 4;
 502         /* generate alpha channel from the mask */
 503         info->bmiHeader.biBitCount = 1;
 504         info->bmiHeader.biSizeImage = width_bytes * bm.bmHeight;
 505         if (!(mask_bits = HeapAlloc( GetProcessHeap(), 0, info->bmiHeader.biSizeImage ))) goto failed;
 506         if (!GetDIBits( hdc, mask, 0, bm.bmHeight, mask_bits, info, DIB_RGB_COLORS )) goto failed;
 507         ptr = bits + 2;
 508         for (i = 0; i < bm.bmHeight; i++)
 509             for (j = 0; j < bm.bmWidth; j++, ptr++)
 510                 if (!((mask_bits[i * width_bytes + j / 8] << (j % 8)) & 0x80)) *ptr |= 0xff000000;
 511         HeapFree( GetProcessHeap(), 0, mask_bits );
 512     }
 513
 514     /* convert to array of longs */
 515     if (bits && sizeof(long) > sizeof(int))
 516         for (i = *size - 1; i >= 0; i--) ((unsigned long *)bits)[i] = bits[i];
 517
 518     return (unsigned long *)bits;
 519
 520 failed:
 521     HeapFree( GetProcessHeap(), 0, bits );
 522     HeapFree( GetProcessHeap(), 0, mask_bits );
 523     return NULL;
 524 }
 525
 526
 527 /***********************************************************************
 528  *              create_icon_pixmaps
 529  */
 530 static BOOL create_icon_pixmaps( HDC hdc, const ICONINFO *icon, Pixmap *icon_ret, Pixmap *mask_ret )
 531 {
 532     char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
 533     BITMAPINFO *info = (BITMAPINFO *)buffer;
 534     XVisualInfo vis = default_visual;
 535     struct gdi_image_bits bits;
 536     Pixmap color_pixmap = 0, mask_pixmap = 0;
 537     int i, lines;
 538
 539     bits.ptr = NULL;
 540     bits.free = NULL;
 541     bits.is_copy = TRUE;
 542
 543     info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 544     info->bmiHeader.biBitCount = 0;
 545     if (!(lines = GetDIBits( hdc, icon->hbmColor, 0, 0, NULL, info, DIB_RGB_COLORS ))) goto failed;
 546     if (!(bits.ptr = HeapAlloc( GetProcessHeap(), 0, info->bmiHeader.biSizeImage ))) goto failed;
 547     if (!GetDIBits( hdc, icon->hbmColor, 0, lines, bits.ptr, info, DIB_RGB_COLORS )) goto failed;
 548
 549     color_pixmap = create_pixmap_from_image( hdc, &vis, info, &bits, DIB_RGB_COLORS );
 550     HeapFree( GetProcessHeap(), 0, bits.ptr );
 551     bits.ptr = NULL;
 552     if (!color_pixmap) goto failed;
 553
 554     info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 555     info->bmiHeader.biBitCount = 0;
 556     if (!(lines = GetDIBits( hdc, icon->hbmMask, 0, 0, NULL, info, DIB_RGB_COLORS ))) goto failed;
 557     if (!(bits.ptr = HeapAlloc( GetProcessHeap(), 0, info->bmiHeader.biSizeImage ))) goto failed;
 558     if (!GetDIBits( hdc, icon->hbmMask, 0, lines, bits.ptr, info, DIB_RGB_COLORS )) goto failed;
 559
 560     /* invert the mask */
 561     for (i = 0; i < info->bmiHeader.biSizeImage / sizeof(DWORD); i++) ((DWORD *)bits.ptr)[i] ^= ~0u;
 562
 563     vis.depth = 1;
 564     mask_pixmap = create_pixmap_from_image( hdc, &vis, info, &bits, DIB_RGB_COLORS );
 565     HeapFree( GetProcessHeap(), 0, bits.ptr );
 566     bits.ptr = NULL;
 567     if (!mask_pixmap) goto failed;
 568
 569     *icon_ret = color_pixmap;
 570     *mask_ret = mask_pixmap;
 571     return TRUE;
 572
 573 failed:
 574     if (color_pixmap) XFreePixmap( gdi_display, color_pixmap );
 575     if (mask_pixmap) XFreePixmap( gdi_display, mask_pixmap );
 576     HeapFree( GetProcessHeap(), 0, bits.ptr );
 577     return FALSE;
 578 }
 579
 580
 581 /***********************************************************************
 582  *              fetch_icon_data
 583  */
 584 static void fetch_icon_data( HWND hwnd, HICON icon_big, HICON icon_small )
 585 {
 586     struct x11drv_win_data *data;
 587     ICONINFO ii, ii_small;
 588     HDC hDC;
 589     unsigned int size;
 590     unsigned long *bits;
 591     Pixmap icon_pixmap, mask_pixmap;
 592
 593     if (!icon_big)
 594     {
 595         icon_big = (HICON)SendMessageW( hwnd, WM_GETICON, ICON_BIG, 0 );
 596         if (!icon_big) icon_big = (HICON)GetClassLongPtrW( hwnd, GCLP_HICON );
 597         if (!icon_big) icon_big = LoadIconW( 0, (LPWSTR)IDI_WINLOGO );
 598     }
 599     if (!icon_small)
 600     {
 601         icon_small = (HICON)SendMessageW( hwnd, WM_GETICON, ICON_SMALL, 0 );
 602         if (!icon_small) icon_small = (HICON)GetClassLongPtrW( hwnd, GCLP_HICONSM );
 603     }
 604
 605     if (!GetIconInfo(icon_big, &ii)) return;
 606
 607     hDC = CreateCompatibleDC(0);
 608     bits = get_bitmap_argb( hDC, ii.hbmColor, ii.hbmMask, &size );
 609     if (bits && GetIconInfo( icon_small, &ii_small ))
 610     {
 611         unsigned int size_small;
 612         unsigned long *bits_small, *new;
 613
 614         if ((bits_small = get_bitmap_argb( hDC, ii_small.hbmColor, ii_small.hbmMask, &size_small )) &&
 615             (bits_small[0] != bits[0] || bits_small[1] != bits[1]))  /* size must be different */
 616         {
 617             if ((new = HeapReAlloc( GetProcessHeap(), 0, bits,
 618                                     (size + size_small) * sizeof(unsigned long) )))
 619             {
 620                 bits = new;
 621                 memcpy( bits + size, bits_small, size_small * sizeof(unsigned long) );
 622                 size += size_small;
 623             }
 624         }
 625         HeapFree( GetProcessHeap(), 0, bits_small );
 626         DeleteObject( ii_small.hbmColor );
 627         DeleteObject( ii_small.hbmMask );
 628     }
 629
 630     if (!create_icon_pixmaps( hDC, &ii, &icon_pixmap, &mask_pixmap )) icon_pixmap = mask_pixmap = 0;
 631
 632     DeleteObject( ii.hbmColor );
 633     DeleteObject( ii.hbmMask );
 634     DeleteDC(hDC);
 635
 636     if ((data = get_win_data( hwnd )))
 637     {
 638         if (data->icon_pixmap) XFreePixmap( gdi_display, data->icon_pixmap );
 639         if (data->icon_mask) XFreePixmap( gdi_display, data->icon_mask );
 640         HeapFree( GetProcessHeap(), 0, data->icon_bits );
 641         data->icon_pixmap = icon_pixmap;
 642         data->icon_mask = mask_pixmap;
 643         data->icon_bits = bits;
 644         data->icon_size = size;
 645         release_win_data( data );
 646     }
 647     else
 648     {
 649         if (icon_pixmap) XFreePixmap( gdi_display, icon_pixmap );
 650         if (mask_pixmap) XFreePixmap( gdi_display, mask_pixmap );
 651         HeapFree( GetProcessHeap(), 0, bits );
 652     }
 653 }
 654
 655
 656 /***********************************************************************
 657  *              set_size_hints
 658  *
 659  * set the window size hints
 660  */
 661 static void set_size_hints( struct x11drv_win_data *data, DWORD style )
 662 {
 663     XSizeHints* size_hints;
 664
 665     if (!(size_hints = XAllocSizeHints())) return;
 666
 667     size_hints->win_gravity = StaticGravity;
 668     size_hints->flags |= PWinGravity;
 669
 670     /* don't update size hints if window is not in normal state */
 671     if (!(style & (WS_MINIMIZE | WS_MAXIMIZE)))
 672     {
 673         if (data->hwnd != GetDesktopWindow())  /* don't force position of desktop */
 674         {
 675             size_hints->x = data->whole_rect.left;
 676             size_hints->y = data->whole_rect.top;
 677             size_hints->flags |= PPosition;
 678         }
 679         else size_hints->win_gravity = NorthWestGravity;
 680
 681         if (!is_window_resizable( data, style ))
 682         {
 683             size_hints->max_width = data->whole_rect.right - data->whole_rect.left;
 684             size_hints->max_height = data->whole_rect.bottom - data->whole_rect.top;
 685             if (size_hints->max_width <= 0 ||size_hints->max_height <= 0)
 686                 size_hints->max_width = size_hints->max_height = 1;
 687             size_hints->min_width = size_hints->max_width;
 688             size_hints->min_height = size_hints->max_height;
 689             size_hints->flags |= PMinSize | PMaxSize;
 690         }
 691     }
 692     XSetWMNormalHints( data->display, data->whole_window, size_hints );
 693     XFree( size_hints );
 694 }
 695
 696
 697 /***********************************************************************
 698  *              set_mwm_hints
 699  */
 700 static void set_mwm_hints( struct x11drv_win_data *data, DWORD style, DWORD ex_style )
 701 {
 702     MwmHints mwm_hints;
 703
 704     if (data->hwnd == GetDesktopWindow())
 705     {
 706         if (is_desktop_fullscreen()) mwm_hints.decorations = 0;
 707         else mwm_hints.decorations = MWM_DECOR_TITLE | MWM_DECOR_BORDER | MWM_DECOR_MENU | MWM_DECOR_MINIMIZE;
 708         mwm_hints.functions        = MWM_FUNC_MOVE | MWM_FUNC_MINIMIZE | MWM_FUNC_CLOSE;
 709     }
 710     else
 711     {
 712         mwm_hints.decorations = get_mwm_decorations( data, style, ex_style );
 713         mwm_hints.functions = MWM_FUNC_MOVE;
 714         if (is_window_resizable( data, style )) mwm_hints.functions |= MWM_FUNC_RESIZE;
 715         if (!(style & WS_DISABLED))
 716         {
 717             if (style & WS_MINIMIZEBOX) mwm_hints.functions |= MWM_FUNC_MINIMIZE;
 718             if (style & WS_MAXIMIZEBOX) mwm_hints.functions |= MWM_FUNC_MAXIMIZE;
 719             if (style & WS_SYSMENU)     mwm_hints.functions |= MWM_FUNC_CLOSE;
 720         }
 721     }
 722
 723     TRACE( "%p setting mwm hints to %lx,%lx (style %x exstyle %x)\n",
 724            data->hwnd, mwm_hints.decorations, mwm_hints.functions, style, ex_style );
 725
 726     mwm_hints.flags = MWM_HINTS_FUNCTIONS | MWM_HINTS_DECORATIONS;
 727     XChangeProperty( data->display, data->whole_window, x11drv_atom(_MOTIF_WM_HINTS),
 728                      x11drv_atom(_MOTIF_WM_HINTS), 32, PropModeReplace,
 729                      (unsigned char*)&mwm_hints, sizeof(mwm_hints)/sizeof(long) );
 730 }
 731
 732
 733 /***********************************************************************
 734  *              set_style_hints
 735  */
 736 static void set_style_hints( struct x11drv_win_data *data, DWORD style, DWORD ex_style )
 737 {
 738     Window group_leader = data->whole_window;
 739     HWND owner = GetWindow( data->hwnd, GW_OWNER );
 740     Window owner_win = X11DRV_get_whole_window( owner );
 741     XWMHints *wm_hints;
 742     Atom window_type;
 743
 744     if (owner_win)
 745     {
 746         XSetTransientForHint( data->display, data->whole_window, owner_win );
 747         group_leader = owner_win;
 748     }
 749
 750     /* Only use dialog type for owned popups. Metacity allows making fullscreen
 751      * only normal windows, and doesn't handle correctly TRANSIENT_FOR hint for
 752      * dialogs owned by fullscreen windows.
 753      */
 754     if (((style & WS_POPUP) || (ex_style & WS_EX_DLGMODALFRAME)) && owner)
 755         window_type = x11drv_atom(_NET_WM_WINDOW_TYPE_DIALOG);
 756     else
 757         window_type = x11drv_atom(_NET_WM_WINDOW_TYPE_NORMAL);
 758
 759     XChangeProperty(data->display, data->whole_window, x11drv_atom(_NET_WM_WINDOW_TYPE),
 760                     XA_ATOM, 32, PropModeReplace, (unsigned char*)&window_type, 1);
 761
 762     if ((wm_hints = XAllocWMHints()))
 763     {
 764         wm_hints->flags = InputHint | StateHint | WindowGroupHint;
 765         wm_hints->input = !use_take_focus && !(style & WS_DISABLED);
 766         wm_hints->initial_state = (style & WS_MINIMIZE) ? IconicState : NormalState;
 767         wm_hints->window_group = group_leader;
 768         if (data->icon_pixmap)
 769         {
 770             wm_hints->icon_pixmap = data->icon_pixmap;
 771             wm_hints->icon_mask = data->icon_mask;
 772             wm_hints->flags |= IconPixmapHint | IconMaskHint;
 773         }
 774         XSetWMHints( data->display, data->whole_window, wm_hints );
 775         XFree( wm_hints );
 776     }
 777
 778     if (data->icon_bits)
 779         XChangeProperty( data->display, data->whole_window, x11drv_atom(_NET_WM_ICON),
 780                          XA_CARDINAL, 32, PropModeReplace,
 781                          (unsigned char *)data->icon_bits, data->icon_size );
 782     else
 783         XDeleteProperty( data->display, data->whole_window, x11drv_atom(_NET_WM_ICON) );
 784
 785 }
 786
 787
 788 /***********************************************************************
 789  *              get_process_name
 790  *
 791  * get the name of the current process for setting class hints
 792  */
 793 static char *get_process_name(void)
 794 {
 795     static char *name;
 796
 797     if (!name)
 798     {
 799         WCHAR module[MAX_PATH];
 800         DWORD len = GetModuleFileNameW( 0, module, MAX_PATH );
 801         if (len && len < MAX_PATH)
 802         {
 803             char *ptr;
 804             WCHAR *p, *appname = module;
 805
 806             if ((p = strrchrW( appname, '/' ))) appname = p + 1;
 807             if ((p = strrchrW( appname, '\\' ))) appname = p + 1;
 808             len = WideCharToMultiByte( CP_UNIXCP, 0, appname, -1, NULL, 0, NULL, NULL );
 809             if ((ptr = HeapAlloc( GetProcessHeap(), 0, len )))
 810             {
 811                 WideCharToMultiByte( CP_UNIXCP, 0, appname, -1, ptr, len, NULL, NULL );
 812                 name = ptr;
 813             }
 814         }
 815     }
 816     return name;
 817 }
 818
 819
 820 /***********************************************************************
 821  *              set_initial_wm_hints
 822  *
 823  * Set the window manager hints that don't change over the lifetime of a window.
 824  */
 825 static void set_initial_wm_hints( Display *display, Window window )
 826 {
 827     long i;
 828     Atom protocols[3];
 829     Atom dndVersion = WINE_XDND_VERSION;
 830     XClassHint *class_hints;
 831     char *process_name = get_process_name();
 832
 833     /* wm protocols */
 834     i = 0;
 835     protocols[i++] = x11drv_atom(WM_DELETE_WINDOW);
 836     protocols[i++] = x11drv_atom(_NET_WM_PING);
 837     if (use_take_focus) protocols[i++] = x11drv_atom(WM_TAKE_FOCUS);
 838     XChangeProperty( display, window, x11drv_atom(WM_PROTOCOLS),
 839                      XA_ATOM, 32, PropModeReplace, (unsigned char *)protocols, i );
 840
 841     /* class hints */
 842     if ((class_hints = XAllocClassHint()))
 843     {
 844         static char wine[] = "Wine";
 845
 846         class_hints->res_name = process_name;
 847         class_hints->res_class = wine;
 848         XSetClassHint( display, window, class_hints );
 849         XFree( class_hints );
 850     }
 851
 852     /* set the WM_CLIENT_MACHINE and WM_LOCALE_NAME properties */
 853     XSetWMProperties(display, window, NULL, NULL, NULL, 0, NULL, NULL, NULL);
 854     /* set the pid. together, these properties are needed so the window manager can kill us if we freeze */
 855     i = getpid();
 856     XChangeProperty(display, window, x11drv_atom(_NET_WM_PID),
 857                     XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&i, 1);
 858
 859     XChangeProperty( display, window, x11drv_atom(XdndAware),
 860                      XA_ATOM, 32, PropModeReplace, (unsigned char*)&dndVersion, 1 );
 861
 862     update_user_time( 0 );  /* make sure that the user time window exists */
 863     if (user_time_window)
 864         XChangeProperty( display, window, x11drv_atom(_NET_WM_USER_TIME_WINDOW),
 865                          XA_WINDOW, 32, PropModeReplace, (unsigned char *)&user_time_window, 1 );
 866 }
 867
 868
 869 /***********************************************************************
 870  *              make_owner_managed
 871  *
 872  * If the window is managed, make sure its owner window is too.
 873  */
 874 static void make_owner_managed( HWND hwnd )
 875 {
 876     HWND owner;
 877
 878     if (!(owner = GetWindow( hwnd, GW_OWNER ))) return;
 879     if (is_managed( owner )) return;
 880     if (!is_managed( hwnd )) return;
 881
 882     SetWindowPos( owner, 0, 0, 0, 0, 0,
 883                   SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSIZE | SWP_NOMOVE |
 884                   SWP_NOREDRAW | SWP_DEFERERASE | SWP_NOSENDCHANGING | SWP_STATECHANGED );
 885 }
 886
 887
 888 /***********************************************************************
 889  *              set_wm_hints
 890  *
 891  * Set all the window manager hints for a window.
 892  */
 893 static void set_wm_hints( struct x11drv_win_data *data )
 894 {
 895     DWORD style, ex_style;
 896
 897     if (data->hwnd == GetDesktopWindow())
 898     {
 899         /* force some styles for the desktop to get the correct decorations */
 900         style = WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
 901         ex_style = WS_EX_APPWINDOW;
 902     }
 903     else
 904     {
 905         style = GetWindowLongW( data->hwnd, GWL_STYLE );
 906         ex_style = GetWindowLongW( data->hwnd, GWL_EXSTYLE );
 907     }
 908
 909     set_size_hints( data, style );
 910     set_mwm_hints( data, style, ex_style );
 911     set_style_hints( data, style, ex_style );
 912 }
 913
 914
 915 /***********************************************************************
 916  *     init_clip_window
 917  */
 918 Window init_clip_window(void)
 919 {
 920     struct x11drv_thread_data *data = x11drv_init_thread_data();
 921
 922     if (!data->clip_window &&
 923         (data->clip_window = (Window)GetPropA( GetDesktopWindow(), clip_window_prop )))
 924     {
 925         XSelectInput( data->display, data->clip_window, StructureNotifyMask );
 926     }
 927     return data->clip_window;
 928 }
 929
 930
 931 /***********************************************************************
 932  *     update_user_time
 933  */
 934 void update_user_time( Time time )
 935 {
 936     if (!user_time_window)
 937     {
 938         Window win = XCreateWindow( gdi_display, root_window, -1, -1, 1, 1, 0, CopyFromParent,
 939                                     InputOnly, CopyFromParent, 0, NULL );
 940         if (InterlockedCompareExchangePointer( (void **)&user_time_window, (void *)win, 0 ))
 941             XDestroyWindow( gdi_display, win );
 942         TRACE( "user time window %lx\n", user_time_window );
 943     }
 944
 945     if (!time) return;
 946     XLockDisplay( gdi_display );
 947     if (!last_user_time || (long)(time - last_user_time) > 0)
 948     {
 949         last_user_time = time;
 950         XChangeProperty( gdi_display, user_time_window, x11drv_atom(_NET_WM_USER_TIME),
 951                          XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&time, 1 );
 952     }
 953     XUnlockDisplay( gdi_display );
 954 }
 955
 956 /***********************************************************************
 957  *     update_net_wm_states
 958  */
 959 void update_net_wm_states( struct x11drv_win_data *data )
 960 {
 961     static const unsigned int state_atoms[NB_NET_WM_STATES] =
 962     {
 963         XATOM__NET_WM_STATE_FULLSCREEN,
 964         XATOM__NET_WM_STATE_ABOVE,
 965         XATOM__NET_WM_STATE_MAXIMIZED_VERT,
 966         XATOM__NET_WM_STATE_SKIP_PAGER,
 967         XATOM__NET_WM_STATE_SKIP_TASKBAR
 968     };
 969
 970     DWORD i, style, ex_style, new_state = 0;
 971
 972     if (!data->managed) return;
 973     if (data->whole_window == root_window) return;
 974
 975     style = GetWindowLongW( data->hwnd, GWL_STYLE );
 976     if (is_window_rect_fullscreen( &data->whole_rect ))
 977     {
 978         if ((style & WS_MAXIMIZE) && (style & WS_CAPTION) == WS_CAPTION)
 979             new_state |= (1 << NET_WM_STATE_MAXIMIZED);
 980         else if (!(style & WS_MINIMIZE))
 981             new_state |= (1 << NET_WM_STATE_FULLSCREEN);
 982     }
 983     else if (style & WS_MAXIMIZE)
 984         new_state |= (1 << NET_WM_STATE_MAXIMIZED);
 985
 986     ex_style = GetWindowLongW( data->hwnd, GWL_EXSTYLE );
 987     if (ex_style & WS_EX_TOPMOST)
 988         new_state |= (1 << NET_WM_STATE_ABOVE);
 989     if (ex_style & (WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE))
 990         new_state |= (1 << NET_WM_STATE_SKIP_TASKBAR) | (1 << NET_WM_STATE_SKIP_PAGER);
 991     if (!(ex_style & WS_EX_APPWINDOW) && GetWindow( data->hwnd, GW_OWNER ))
 992         new_state |= (1 << NET_WM_STATE_SKIP_TASKBAR);
 993
 994     if (!data->mapped)  /* set the _NET_WM_STATE atom directly */
 995     {
 996         Atom atoms[NB_NET_WM_STATES+1];
 997         DWORD count;
 998
 999         for (i = count = 0; i < NB_NET_WM_STATES; i++)
1000         {
1001             if (!(new_state & (1 << i))) continue;
1002             TRACE( "setting wm state %u for unmapped window %p/%lx\n",
1003                    i, data->hwnd, data->whole_window );
1004             atoms[count++] = X11DRV_Atoms[state_atoms[i] - FIRST_XATOM];
1005             if (state_atoms[i] == XATOM__NET_WM_STATE_MAXIMIZED_VERT)
1006                 atoms[count++] = x11drv_atom(_NET_WM_STATE_MAXIMIZED_HORZ);
1007         }
1008         XChangeProperty( data->display, data->whole_window, x11drv_atom(_NET_WM_STATE), XA_ATOM,
1009                          32, PropModeReplace, (unsigned char *)atoms, count );
1010     }
1011     else  /* ask the window manager to do it for us */
1012     {
1013         XEvent xev;
1014
1015         xev.xclient.type = ClientMessage;
1016         xev.xclient.window = data->whole_window;
1017         xev.xclient.message_type = x11drv_atom(_NET_WM_STATE);
1018         xev.xclient.serial = 0;
1019         xev.xclient.display = data->display;
1020         xev.xclient.send_event = True;
1021         xev.xclient.format = 32;
1022         xev.xclient.data.l[3] = 1;
1023
1024         for (i = 0; i < NB_NET_WM_STATES; i++)
1025         {
1026             if (!((data->net_wm_state ^ new_state) & (1 << i))) continue;  /* unchanged */
1027
1028             TRACE( "setting wm state %u for window %p/%lx to %u prev %u\n",
1029                    i, data->hwnd, data->whole_window,
1030                    (new_state & (1 << i)) != 0, (data->net_wm_state & (1 << i)) != 0 );
1031
1032             xev.xclient.data.l[0] = (new_state & (1 << i)) ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
1033             xev.xclient.data.l[1] = X11DRV_Atoms[state_atoms[i] - FIRST_XATOM];
1034             xev.xclient.data.l[2] = ((state_atoms[i] == XATOM__NET_WM_STATE_MAXIMIZED_VERT) ?
1035                                      x11drv_atom(_NET_WM_STATE_MAXIMIZED_HORZ) : 0);
1036             XSendEvent( data->display, root_window, False,
1037                         SubstructureRedirectMask | SubstructureNotifyMask, &xev );
1038         }
1039     }
1040     data->net_wm_state = new_state;
1041 }
1042
1043
1044 /***********************************************************************
1045  *     set_xembed_flags
1046  */
1047 static void set_xembed_flags( struct x11drv_win_data *data, unsigned long flags )
1048 {
1049     unsigned long info[2];
1050
1051     if (!data->whole_window) return;
1052
1053     info[0] = 0; /* protocol version */
1054     info[1] = flags;
1055     XChangeProperty( data->display, data->whole_window, x11drv_atom(_XEMBED_INFO),
1056                      x11drv_atom(_XEMBED_INFO), 32, PropModeReplace, (unsigned char*)info, 2 );
1057 }
1058
1059
1060 /***********************************************************************
1061  *     map_window
1062  */
1063 static void map_window( HWND hwnd, DWORD new_style )
1064 {
1065     struct x11drv_win_data *data;
1066
1067     make_owner_managed( hwnd );
1068     wait_for_withdrawn_state( hwnd, TRUE );
1069
1070     if (!(data = get_win_data( hwnd ))) return;
1071
1072     if (data->whole_window && !data->mapped)
1073     {
1074         TRACE( "win %p/%lx\n", data->hwnd, data->whole_window );
1075
1076         remove_startup_notification( data->display, data->whole_window );
1077         set_wm_hints( data );
1078
1079         if (!data->embedded)
1080         {
1081             update_net_wm_states( data );
1082             sync_window_style( data );
1083             XMapWindow( data->display, data->whole_window );
1084             XFlush( data->display );
1085         }
1086         else set_xembed_flags( data, XEMBED_MAPPED );
1087
1088         data->mapped = TRUE;
1089         data->iconic = (new_style & WS_MINIMIZE) != 0;
1090     }
1091     release_win_data( data );
1092 }
1093
1094
1095 /***********************************************************************
1096  *     unmap_window
1097  */
1098 static void unmap_window( HWND hwnd )
1099 {
1100     struct x11drv_win_data *data;
1101
1102     wait_for_withdrawn_state( hwnd, FALSE );
1103
1104     if (!(data = get_win_data( hwnd ))) return;
1105
1106     if (data->mapped)
1107     {
1108         TRACE( "win %p/%lx\n", data->hwnd, data->whole_window );
1109
1110         if (data->embedded) set_xembed_flags( data, 0 );
1111         else if (!data->managed) XUnmapWindow( data->display, data->whole_window );
1112         else XWithdrawWindow( data->display, data->whole_window, DefaultScreen(data->display) );
1113
1114         data->mapped = FALSE;
1115         data->net_wm_state = 0;
1116     }
1117     release_win_data( data );
1118 }
1119
1120
1121 /***********************************************************************
1122  *     make_window_embedded
1123  */
1124 void make_window_embedded( HWND hwnd )
1125 {
1126     struct x11drv_win_data *data = get_win_data( hwnd );
1127
1128     if (!data) return;
1129
1130     /* the window cannot be mapped before being embedded */
1131     if (data->mapped)
1132     {
1133         if (data->managed) XUnmapWindow( data->display, data->whole_window );
1134         else XWithdrawWindow( data->display, data->whole_window, DefaultScreen(data->display) );
1135         data->net_wm_state = 0;
1136     }
1137     data->embedded = TRUE;
1138     data->managed = TRUE;
1139     SetPropA( hwnd, managed_prop, (HANDLE)1 );
1140     sync_window_style( data );
1141     set_xembed_flags( data, data->mapped ? XEMBED_MAPPED : 0 );
1142     release_win_data( data );
1143 }
1144
1145
1146 /***********************************************************************
1147  *              X11DRV_window_to_X_rect
1148  *
1149  * Convert a rect from client to X window coordinates
1150  */
1151 static void X11DRV_window_to_X_rect( struct x11drv_win_data *data, RECT *rect )
1152 {
1153     RECT rc;
1154
1155     if (!data->managed) return;
1156     if (IsRectEmpty( rect )) return;
1157
1158     get_x11_rect_offset( data, &rc );
1159
1160     rect->left   -= rc.left;
1161     rect->right  -= rc.right;
1162     rect->top    -= rc.top;
1163     rect->bottom -= rc.bottom;
1164     if (rect->top >= rect->bottom) rect->bottom = rect->top + 1;
1165     if (rect->left >= rect->right) rect->right = rect->left + 1;
1166 }
1167
1168
1169 /***********************************************************************
1170  *              X11DRV_X_to_window_rect
1171  *
1172  * Opposite of X11DRV_window_to_X_rect
1173  */
1174 void X11DRV_X_to_window_rect( struct x11drv_win_data *data, RECT *rect )
1175 {
1176     RECT rc;
1177
1178     if (!data->managed) return;
1179     if (IsRectEmpty( rect )) return;
1180
1181     get_x11_rect_offset( data, &rc );
1182
1183     rect->left   += rc.left;
1184     rect->right  += rc.right;
1185     rect->top    += rc.top;
1186     rect->bottom += rc.bottom;
1187     if (rect->top >= rect->bottom) rect->bottom = rect->top + 1;
1188     if (rect->left >= rect->right) rect->right = rect->left + 1;
1189 }
1190
1191
1192 /***********************************************************************
1193  *              sync_window_position
1194  *
1195  * Synchronize the X window position with the Windows one
1196  */
1197 static void sync_window_position( struct x11drv_win_data *data,
1198                                   UINT swp_flags, const RECT *old_window_rect,
1199                                   const RECT *old_whole_rect, const RECT *old_client_rect )
1200 {
1201     DWORD style = GetWindowLongW( data->hwnd, GWL_STYLE );
1202     DWORD ex_style = GetWindowLongW( data->hwnd, GWL_EXSTYLE );
1203     XWindowChanges changes;
1204     unsigned int mask = 0;
1205
1206     if (data->managed && data->iconic) return;
1207
1208     /* resizing a managed maximized window is not allowed */
1209     if (!(style & WS_MAXIMIZE) || !data->managed)
1210     {
1211         changes.width = data->whole_rect.right - data->whole_rect.left;
1212         changes.height = data->whole_rect.bottom - data->whole_rect.top;
1213         /* if window rect is empty force size to 1x1 */
1214         if (changes.width <= 0 || changes.height <= 0) changes.width = changes.height = 1;
1215         if (changes.width > 65535) changes.width = 65535;
1216         if (changes.height > 65535) changes.height = 65535;
1217         mask |= CWWidth | CWHeight;
1218     }
1219
1220     /* only the size is allowed to change for the desktop window */
1221     if (data->whole_window != root_window)
1222     {
1223         changes.x = data->whole_rect.left - virtual_screen_rect.left;
1224         changes.y = data->whole_rect.top - virtual_screen_rect.top;
1225         mask |= CWX | CWY;
1226     }
1227
1228     if (!(swp_flags & SWP_NOZORDER) || (swp_flags & SWP_SHOWWINDOW))
1229     {
1230         /* find window that this one must be after */
1231         HWND prev = GetWindow( data->hwnd, GW_HWNDPREV );
1232         while (prev && !(GetWindowLongW( prev, GWL_STYLE ) & WS_VISIBLE))
1233             prev = GetWindow( prev, GW_HWNDPREV );
1234         if (!prev)  /* top child */
1235         {
1236             changes.stack_mode = Above;
1237             mask |= CWStackMode;
1238         }
1239         /* should use stack_mode Below but most window managers don't get it right */
1240         /* and Above with a sibling doesn't work so well either, so we ignore it */
1241     }
1242
1243     set_size_hints( data, style );
1244     set_mwm_hints( data, style, ex_style );
1245     data->configure_serial = NextRequest( data->display );
1246     XReconfigureWMWindow( data->display, data->whole_window,
1247                           DefaultScreen(data->display), mask, &changes );
1248 #ifdef HAVE_LIBXSHAPE
1249     if (IsRectEmpty( old_window_rect ) != IsRectEmpty( &data->window_rect ))
1250         sync_window_region( data, (HRGN)1 );
1251     if (data->shaped)
1252     {
1253         int old_x_offset = old_window_rect->left - old_whole_rect->left;
1254         int old_y_offset = old_window_rect->top - old_whole_rect->top;
1255         int new_x_offset = data->window_rect.left - data->whole_rect.left;
1256         int new_y_offset = data->window_rect.top - data->whole_rect.top;
1257         if (old_x_offset != new_x_offset || old_y_offset != new_y_offset)
1258             XShapeOffsetShape( data->display, data->whole_window, ShapeBounding,
1259                                new_x_offset - old_x_offset, new_y_offset - old_y_offset );
1260     }
1261 #endif
1262
1263     TRACE( "win %p/%lx pos %d,%d,%dx%d after %lx changes=%x serial=%lu\n",
1264            data->hwnd, data->whole_window, data->whole_rect.left, data->whole_rect.top,
1265            data->whole_rect.right - data->whole_rect.left,
1266            data->whole_rect.bottom - data->whole_rect.top,
1267            changes.sibling, mask, data->configure_serial );
1268 }
1269
1270
1271 /***********************************************************************
1272  *              move_window_bits
1273  *
1274  * Move the window bits when a window is moved.
1275  */
1276 static void move_window_bits( HWND hwnd, Window window, const RECT *old_rect, const RECT *new_rect,
1277                               const RECT *old_client_rect, const RECT *new_client_rect,
1278                               const RECT *new_window_rect )
1279 {
1280     RECT src_rect = *old_rect;
1281     RECT dst_rect = *new_rect;
1282     HDC hdc_src, hdc_dst;
1283     INT code;
1284     HRGN rgn;
1285     HWND parent = 0;
1286
1287     if (!window)
1288     {
1289         OffsetRect( &dst_rect, -new_window_rect->left, -new_window_rect->top );
1290         parent = GetAncestor( hwnd, GA_PARENT );
1291         hdc_src = GetDCEx( parent, 0, DCX_CACHE );
1292         hdc_dst = GetDCEx( hwnd, 0, DCX_CACHE | DCX_WINDOW );
1293     }
1294     else
1295     {
1296         OffsetRect( &dst_rect, -new_client_rect->left, -new_client_rect->top );
1297         /* make src rect relative to the old position of the window */
1298         OffsetRect( &src_rect, -old_client_rect->left, -old_client_rect->top );
1299         if (dst_rect.left == src_rect.left && dst_rect.top == src_rect.top) return;
1300         hdc_src = hdc_dst = GetDCEx( hwnd, 0, DCX_CACHE );
1301     }
1302
1303     rgn = CreateRectRgnIndirect( &dst_rect );
1304     SelectClipRgn( hdc_dst, rgn );
1305     DeleteObject( rgn );
1306     ExcludeUpdateRgn( hdc_dst, hwnd );
1307
1308     code = X11DRV_START_EXPOSURES;
1309     ExtEscape( hdc_dst, X11DRV_ESCAPE, sizeof(code), (LPSTR)&code, 0, NULL );
1310
1311     TRACE( "copying bits for win %p/%lx %s -> %s\n",
1312            hwnd, window, wine_dbgstr_rect(&src_rect), wine_dbgstr_rect(&dst_rect) );
1313     BitBlt( hdc_dst, dst_rect.left, dst_rect.top,
1314             dst_rect.right - dst_rect.left, dst_rect.bottom - dst_rect.top,
1315             hdc_src, src_rect.left, src_rect.top, SRCCOPY );
1316
1317     rgn = 0;
1318     code = X11DRV_END_EXPOSURES;
1319     ExtEscape( hdc_dst, X11DRV_ESCAPE, sizeof(code), (LPSTR)&code, sizeof(rgn), (LPSTR)&rgn );
1320
1321     ReleaseDC( hwnd, hdc_dst );
1322     if (hdc_src != hdc_dst) ReleaseDC( parent, hdc_src );
1323
1324     if (rgn)
1325     {
1326         if (!window)
1327         {
1328             /* map region to client rect since we are using DCX_WINDOW */
1329             OffsetRgn( rgn, new_window_rect->left - new_client_rect->left,
1330                        new_window_rect->top - new_client_rect->top );
1331             RedrawWindow( hwnd, NULL, rgn,
1332                           RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ALLCHILDREN );
1333         }
1334         else RedrawWindow( hwnd, NULL, rgn, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN );
1335         DeleteObject( rgn );
1336     }
1337 }
1338
1339
1340 /**********************************************************************
1341  *              create_whole_window
1342  *
1343  * Create the whole X window for a given window
1344  */
1345 static void create_whole_window( struct x11drv_win_data *data )
1346 {
1347     int cx, cy, mask;
1348     XSetWindowAttributes attr;
1349     WCHAR text[1024];
1350     COLORREF key;
1351     BYTE alpha;
1352     DWORD layered_flags;
1353     HRGN win_rgn;
1354
1355     if (!data->managed && is_window_managed( data->hwnd, SWP_NOACTIVATE, &data->window_rect ))
1356     {
1357         TRACE( "making win %p/%lx managed\n", data->hwnd, data->whole_window );
1358         data->managed = TRUE;
1359         SetPropA( data->hwnd, managed_prop, (HANDLE)1 );
1360     }
1361
1362     if ((win_rgn = CreateRectRgn( 0, 0, 0, 0 )) && GetWindowRgn( data->hwnd, win_rgn ) == ERROR)
1363     {
1364         DeleteObject( win_rgn );
1365         win_rgn = 0;
1366     }
1367     data->shaped = (win_rgn != 0);
1368
1369     mask = get_window_attributes( data, &attr );
1370
1371     data->whole_rect = data->window_rect;
1372     X11DRV_window_to_X_rect( data, &data->whole_rect );
1373     if (!(cx = data->whole_rect.right - data->whole_rect.left)) cx = 1;
1374     else if (cx > 65535) cx = 65535;
1375     if (!(cy = data->whole_rect.bottom - data->whole_rect.top)) cy = 1;
1376     else if (cy > 65535) cy = 65535;
1377
1378     data->whole_window = XCreateWindow( data->display, root_window,
1379                                         data->whole_rect.left - virtual_screen_rect.left,
1380                                         data->whole_rect.top - virtual_screen_rect.top,
1381                                         cx, cy, 0, default_visual.depth, InputOutput,
1382                                         default_visual.visual, mask, &attr );
1383     if (!data->whole_window) goto done;
1384
1385     set_initial_wm_hints( data->display, data->whole_window );
1386     set_wm_hints( data );
1387
1388     XSaveContext( data->display, data->whole_window, winContext, (char *)data->hwnd );
1389     SetPropA( data->hwnd, whole_window_prop, (HANDLE)data->whole_window );
1390
1391     /* set the window text */
1392     if (!InternalGetWindowText( data->hwnd, text, sizeof(text)/sizeof(WCHAR) )) text[0] = 0;
1393     sync_window_text( data->display, data->whole_window, text );
1394
1395     /* set the window region */
1396     if (win_rgn || IsRectEmpty( &data->window_rect )) sync_window_region( data, win_rgn );
1397
1398     /* set the window opacity */
1399     if (!GetLayeredWindowAttributes( data->hwnd, &key, &alpha, &layered_flags )) layered_flags = 0;
1400     sync_window_opacity( data->display, data->whole_window, key, alpha, layered_flags );
1401
1402     XFlush( data->display );  /* make sure the window exists before we start painting to it */
1403
1404     sync_window_cursor( data->whole_window );
1405
1406 done:
1407     if (win_rgn) DeleteObject( win_rgn );
1408 }
1409
1410
1411 /**********************************************************************
1412  *              destroy_whole_window
1413  *
1414  * Destroy the whole X window for a given window.
1415  */
1416 static void destroy_whole_window( struct x11drv_win_data *data, BOOL already_destroyed )
1417 {
1418     if (!data->whole_window)
1419     {
1420         if (data->embedded)
1421         {
1422             Window xwin = (Window)GetPropA( data->hwnd, foreign_window_prop );
1423             if (xwin)
1424             {
1425                 if (!already_destroyed) XSelectInput( data->display, xwin, 0 );
1426                 XDeleteContext( data->display, xwin, winContext );
1427                 RemovePropA( data->hwnd, foreign_window_prop );
1428             }
1429         }
1430         return;
1431     }
1432
1433
1434     TRACE( "win %p xwin %lx\n", data->hwnd, data->whole_window );
1435     XDeleteContext( data->display, data->whole_window, winContext );
1436     if (!already_destroyed) XDestroyWindow( data->display, data->whole_window );
1437     data->whole_window = 0;
1438     data->wm_state = WithdrawnState;
1439     data->net_wm_state = 0;
1440     data->mapped = FALSE;
1441     if (data->xic)
1442     {
1443         XUnsetICFocus( data->xic );
1444         XDestroyIC( data->xic );
1445         data->xic = 0;
1446     }
1447     /* Outlook stops processing messages after destroying a dialog, so we need an explicit flush */
1448     XFlush( data->display );
1449     if (data->surface) window_surface_release( data->surface );
1450     data->surface = NULL;
1451     RemovePropA( data->hwnd, whole_window_prop );
1452 }
1453
1454
1455 /*****************************************************************
1456  *              SetWindowText   (X11DRV.@)
1457  */
1458 void CDECL X11DRV_SetWindowText( HWND hwnd, LPCWSTR text )
1459 {
1460     Window win;
1461
1462     if ((win = X11DRV_get_whole_window( hwnd )) && win != DefaultRootWindow(gdi_display))
1463     {
1464         Display *display = thread_init_display();
1465         sync_window_text( display, win, text );
1466     }
1467 }
1468
1469
1470 /***********************************************************************
1471  *              SetWindowStyle   (X11DRV.@)
1472  *
1473  * Update the X state of a window to reflect a style change
1474  */
1475 void CDECL X11DRV_SetWindowStyle( HWND hwnd, INT offset, STYLESTRUCT *style )
1476 {
1477     struct x11drv_win_data *data;
1478     DWORD changed = style->styleNew ^ style->styleOld;
1479
1480     if (hwnd == GetDesktopWindow()) return;
1481     if (!(data = get_win_data( hwnd ))) return;
1482     if (!data->whole_window) goto done;
1483
1484     if (offset == GWL_STYLE && (changed & WS_DISABLED)) set_wm_hints( data );
1485
1486     if (offset == GWL_EXSTYLE && (changed & WS_EX_LAYERED)) /* changing WS_EX_LAYERED resets attributes */
1487     {
1488         sync_window_opacity( data->display, data->whole_window, 0, 0, 0 );
1489         if (data->surface) set_surface_color_key( data->surface, CLR_INVALID );
1490     }
1491 done:
1492     release_win_data( data );
1493 }
1494
1495
1496 /***********************************************************************
1497  *              DestroyWindow   (X11DRV.@)
1498  */
1499 void CDECL X11DRV_DestroyWindow( HWND hwnd )
1500 {
1501     struct x11drv_thread_data *thread_data = x11drv_thread_data();
1502     struct x11drv_win_data *data;
1503
1504     if (!(data = get_win_data( hwnd ))) return;
1505
1506     destroy_whole_window( data, FALSE );
1507     if (thread_data->last_focus == hwnd) thread_data->last_focus = 0;
1508     if (thread_data->last_xic_hwnd == hwnd) thread_data->last_xic_hwnd = 0;
1509     if (data->icon_pixmap) XFreePixmap( gdi_display, data->icon_pixmap );
1510     if (data->icon_mask) XFreePixmap( gdi_display, data->icon_mask );
1511     HeapFree( GetProcessHeap(), 0, data->icon_bits );
1512     XDeleteContext( gdi_display, (XID)hwnd, win_data_context );
1513     release_win_data( data );
1514     HeapFree( GetProcessHeap(), 0, data );
1515     destroy_gl_drawable( hwnd );
1516 }
1517
1518
1519 /***********************************************************************
1520  *              X11DRV_DestroyNotify
1521  */
1522 void X11DRV_DestroyNotify( HWND hwnd, XEvent *event )
1523 {
1524     struct x11drv_win_data *data;
1525     BOOL embedded;
1526
1527     if (!(data = get_win_data( hwnd ))) return;
1528     embedded = data->embedded;
1529     if (!embedded) FIXME( "window %p/%lx destroyed from the outside\n", hwnd, data->whole_window );
1530
1531     destroy_whole_window( data, TRUE );
1532     release_win_data( data );
1533     if (embedded) SendMessageW( hwnd, WM_CLOSE, 0, 0 );
1534 }
1535
1536
1537 static struct x11drv_win_data *alloc_win_data( Display *display, HWND hwnd )
1538 {
1539     struct x11drv_win_data *data;
1540
1541     if ((data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*data))))
1542     {
1543         data->display = display;
1544         data->hwnd = hwnd;
1545         EnterCriticalSection( &win_data_section );
1546         XSaveContext( gdi_display, (XID)hwnd, win_data_context, (char *)data );
1547     }
1548     return data;
1549 }
1550
1551
1552 /* initialize the desktop window id in the desktop manager process */
1553 static BOOL create_desktop_win_data( Display *display, HWND hwnd )
1554 {
1555     struct x11drv_win_data *data;
1556
1557     if (!(data = alloc_win_data( display, hwnd ))) return FALSE;
1558     data->whole_window = root_window;
1559     data->managed = TRUE;
1560     SetPropA( data->hwnd, managed_prop, (HANDLE)1 );
1561     SetPropA( data->hwnd, whole_window_prop, (HANDLE)root_window );
1562     set_initial_wm_hints( display, root_window );
1563     release_win_data( data );
1564     return TRUE;
1565 }
1566
1567 /**********************************************************************
1568  *              CreateDesktopWindow   (X11DRV.@)
1569  */
1570 BOOL CDECL X11DRV_CreateDesktopWindow( HWND hwnd )
1571 {
1572     unsigned int width, height;
1573
1574     /* retrieve the real size of the desktop */
1575     SERVER_START_REQ( get_window_rectangles )
1576     {
1577         req->handle = wine_server_user_handle( hwnd );
1578         req->relative = COORDS_CLIENT;
1579         wine_server_call( req );
1580         width  = reply->window.right;
1581         height = reply->window.bottom;
1582     }
1583     SERVER_END_REQ;
1584
1585     if (!width && !height)  /* not initialized yet */
1586     {
1587         SERVER_START_REQ( set_window_pos )
1588         {
1589             req->handle        = wine_server_user_handle( hwnd );
1590             req->previous      = 0;
1591             req->flags         = SWP_NOZORDER;
1592             req->window.left   = virtual_screen_rect.left;
1593             req->window.top    = virtual_screen_rect.top;
1594             req->window.right  = virtual_screen_rect.right;
1595             req->window.bottom = virtual_screen_rect.bottom;
1596             req->client        = req->window;
1597             wine_server_call( req );
1598         }
1599         SERVER_END_REQ;
1600     }
1601     else
1602     {
1603         Window win = (Window)GetPropA( hwnd, whole_window_prop );
1604         if (win && win != root_window) X11DRV_init_desktop( win, width, height );
1605     }
1606     return TRUE;
1607 }
1608
1609
1610 /**********************************************************************
1611  *              CreateWindow   (X11DRV.@)
1612  */
1613 BOOL CDECL X11DRV_CreateWindow( HWND hwnd )
1614 {
1615     if (hwnd == GetDesktopWindow())
1616     {
1617         struct x11drv_thread_data *data = x11drv_init_thread_data();
1618         XSetWindowAttributes attr;
1619
1620         if (root_window != DefaultRootWindow( gdi_display ))
1621         {
1622             /* the desktop win data can't be created lazily */
1623             if (!create_desktop_win_data( data->display, hwnd )) return FALSE;
1624         }
1625
1626         /* create the cursor clipping window */
1627         attr.override_redirect = TRUE;
1628         attr.event_mask = StructureNotifyMask | FocusChangeMask;
1629         data->clip_window = XCreateWindow( data->display, root_window, 0, 0, 1, 1, 0, 0,
1630                                            InputOnly, default_visual.visual,
1631                                            CWOverrideRedirect | CWEventMask, &attr );
1632         XFlush( data->display );
1633         SetPropA( hwnd, clip_window_prop, (HANDLE)data->clip_window );
1634     }
1635     return TRUE;
1636 }
1637
1638
1639 /***********************************************************************
1640  *              get_win_data
1641  *
1642  * Lock and return the X11 data structure associated with a window.
1643  */
1644 struct x11drv_win_data *get_win_data( HWND hwnd )
1645 {
1646     char *data;
1647
1648     if (!hwnd) return NULL;
1649     EnterCriticalSection( &win_data_section );
1650     if (!XFindContext( gdi_display, (XID)hwnd, win_data_context, &data ))
1651         return (struct x11drv_win_data *)data;
1652     LeaveCriticalSection( &win_data_section );
1653     return NULL;
1654 }
1655
1656
1657 /***********************************************************************
1658  *              release_win_data
1659  *
1660  * Release the data returned by get_win_data.
1661  */
1662 void release_win_data( struct x11drv_win_data *data )
1663 {
1664     if (data) LeaveCriticalSection( &win_data_section );
1665 }
1666
1667
1668 /***********************************************************************
1669  *              X11DRV_create_win_data
1670  *
1671  * Create an X11 data window structure for an existing window.
1672  */
1673 static struct x11drv_win_data *X11DRV_create_win_data( HWND hwnd, const RECT *window_rect,
1674                                                        const RECT *client_rect )
1675 {
1676     Display *display;
1677     struct x11drv_win_data *data;
1678     HWND parent;
1679
1680     if (!(parent = GetAncestor( hwnd, GA_PARENT ))) return NULL;  /* desktop */
1681
1682     /* don't create win data for HWND_MESSAGE windows */
1683     if (parent != GetDesktopWindow() && !GetAncestor( parent, GA_PARENT )) return NULL;
1684
1685     if (GetWindowThreadProcessId( hwnd, NULL ) != GetCurrentThreadId()) return NULL;
1686
1687     display = thread_init_display();
1688     init_clip_window();  /* make sure the clip window is initialized in this thread */
1689
1690     if (!(data = alloc_win_data( display, hwnd ))) return NULL;
1691
1692     data->whole_rect = data->window_rect = *window_rect;
1693     data->client_rect = *client_rect;
1694     if (parent == GetDesktopWindow())
1695     {
1696         create_whole_window( data );
1697         TRACE( "win %p/%lx window %s whole %s client %s\n",
1698                hwnd, data->whole_window, wine_dbgstr_rect( &data->window_rect ),
1699                wine_dbgstr_rect( &data->whole_rect ), wine_dbgstr_rect( &data->client_rect ));
1700     }
1701     return data;
1702 }
1703
1704
1705 /* window procedure for foreign windows */
1706 static LRESULT WINAPI foreign_window_proc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
1707 {
1708     switch(msg)
1709     {
1710     case WM_WINDOWPOSCHANGED:
1711         update_systray_balloon_position();
1712         break;
1713     case WM_PARENTNOTIFY:
1714         if (LOWORD(wparam) == WM_DESTROY)
1715         {
1716             TRACE( "%p: got parent notify destroy for win %lx\n", hwnd, lparam );
1717             PostMessageW( hwnd, WM_CLOSE, 0, 0 );  /* so that we come back here once the child is gone */
1718         }
1719         return 0;
1720     case WM_CLOSE:
1721         if (GetWindow( hwnd, GW_CHILD )) return 0;  /* refuse to die if we still have children */
1722         break;
1723     }
1724     return DefWindowProcW( hwnd, msg, wparam, lparam );
1725 }
1726
1727
1728 /***********************************************************************
1729  *              create_foreign_window
1730  *
1731  * Create a foreign window for the specified X window and its ancestors
1732  */
1733 HWND create_foreign_window( Display *display, Window xwin )
1734 {
1735     static const WCHAR classW[] = {'_','_','w','i','n','e','_','x','1','1','_','f','o','r','e','i','g','n','_','w','i','n','d','o','w',0};
1736     static BOOL class_registered;
1737     struct x11drv_win_data *data;
1738     HWND hwnd, parent;
1739     Window xparent, xroot;
1740     Window *xchildren;
1741     unsigned int nchildren;
1742     XWindowAttributes attr;
1743     DWORD style = WS_CLIPCHILDREN;
1744
1745     if (!class_registered)
1746     {
1747         WNDCLASSEXW class;
1748
1749         memset( &class, 0, sizeof(class) );
1750         class.cbSize        = sizeof(class);
1751         class.lpfnWndProc   = foreign_window_proc;
1752         class.lpszClassName = classW;
1753         if (!RegisterClassExW( &class ) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS)
1754         {
1755             ERR( "Could not register foreign window class\n" );
1756             return FALSE;
1757         }
1758         class_registered = TRUE;
1759     }
1760
1761     if (XFindContext( display, xwin, winContext, (char **)&hwnd )) hwnd = 0;
1762     if (hwnd) return hwnd;  /* already created */
1763
1764     XSelectInput( display, xwin, StructureNotifyMask );
1765     if (!XGetWindowAttributes( display, xwin, &attr ) ||
1766         !XQueryTree( display, xwin, &xroot, &xparent, &xchildren, &nchildren ))
1767     {
1768         XSelectInput( display, xwin, 0 );
1769         return 0;
1770     }
1771     XFree( xchildren );
1772
1773     if (xparent == xroot)
1774     {
1775         parent = GetDesktopWindow();
1776         style |= WS_POPUP;
1777         attr.x += virtual_screen_rect.left;
1778         attr.y += virtual_screen_rect.top;
1779     }
1780     else
1781     {
1782         parent = create_foreign_window( display, xparent );
1783         style |= WS_CHILD;
1784     }
1785
1786     hwnd = CreateWindowW( classW, NULL, style, attr.x, attr.y, attr.width, attr.height,
1787                           parent, 0, 0, NULL );
1788
1789     if (!(data = alloc_win_data( display, hwnd )))
1790     {
1791         DestroyWindow( hwnd );
1792         return 0;
1793     }
1794     SetRect( &data->window_rect, attr.x, attr.y, attr.x + attr.width, attr.y + attr.height );
1795     data->whole_rect = data->client_rect = data->window_rect;
1796     data->whole_window = 0;
1797     data->embedded = TRUE;
1798     data->mapped = TRUE;
1799
1800     SetPropA( hwnd, foreign_window_prop, (HANDLE)xwin );
1801     XSaveContext( display, xwin, winContext, (char *)data->hwnd );
1802
1803     ShowWindow( hwnd, SW_SHOW );
1804
1805     TRACE( "win %lx parent %p style %08x %s -> hwnd %p\n",
1806            xwin, parent, style, wine_dbgstr_rect(&data->window_rect), hwnd );
1807
1808     return hwnd;
1809 }
1810
1811
1812 /***********************************************************************
1813  *              X11DRV_get_whole_window
1814  *
1815  * Return the X window associated with the full area of a window
1816  */
1817 Window X11DRV_get_whole_window( HWND hwnd )
1818 {
1819     struct x11drv_win_data *data = get_win_data( hwnd );
1820     Window ret;
1821
1822     if (!data)
1823     {
1824         if (hwnd == GetDesktopWindow()) return root_window;
1825         return (Window)GetPropA( hwnd, whole_window_prop );
1826     }
1827     ret = data->whole_window;
1828     release_win_data( data );
1829     return ret;
1830 }
1831
1832
1833 /***********************************************************************
1834  *              X11DRV_get_ic
1835  *
1836  * Return the X input context associated with a window
1837  */
1838 XIC X11DRV_get_ic( HWND hwnd )
1839 {
1840     struct x11drv_win_data *data = get_win_data( hwnd );
1841     XIM xim;
1842     XIC ret = 0;
1843
1844     if (data)
1845     {
1846         x11drv_thread_data()->last_xic_hwnd = hwnd;
1847         ret = data->xic;
1848         if (!ret && (xim = x11drv_thread_data()->xim)) ret = X11DRV_CreateIC( xim, data );
1849         release_win_data( data );
1850     }
1851     return ret;
1852 }
1853
1854
1855 /***********************************************************************
1856  *              X11DRV_GetDC   (X11DRV.@)
1857  */
1858 void CDECL X11DRV_GetDC( HDC hdc, HWND hwnd, HWND top, const RECT *win_rect,
1859                          const RECT *top_rect, DWORD flags )
1860 {
1861     struct x11drv_escape_set_drawable escape;
1862     HWND parent;
1863
1864     escape.code        = X11DRV_SET_DRAWABLE;
1865     escape.hwnd        = hwnd;
1866     escape.mode        = IncludeInferiors;
1867     escape.fbconfig_id = 0;
1868
1869     escape.dc_rect.left         = win_rect->left - top_rect->left;
1870     escape.dc_rect.top          = win_rect->top - top_rect->top;
1871     escape.dc_rect.right        = win_rect->right - top_rect->left;
1872     escape.dc_rect.bottom       = win_rect->bottom - top_rect->top;
1873
1874     if (top == hwnd)
1875     {
1876         struct x11drv_win_data *data = get_win_data( hwnd );
1877
1878         escape.drawable = data ? data->whole_window : X11DRV_get_whole_window( hwnd );
1879
1880         /* special case: when repainting the root window, clip out top-level windows */
1881         if (data && data->whole_window == root_window) escape.mode = ClipByChildren;
1882         release_win_data( data );
1883     }
1884     else
1885     {
1886         /* find the first ancestor that has a drawable */
1887         for (parent = hwnd; parent && parent != top; parent = GetAncestor( parent, GA_PARENT ))
1888             if ((escape.drawable = X11DRV_get_whole_window( parent ))) break;
1889
1890         if (escape.drawable)
1891         {
1892             POINT pt = { 0, 0 };
1893             MapWindowPoints( 0, parent, &pt, 1 );
1894             escape.dc_rect = *win_rect;
1895             OffsetRect( &escape.dc_rect, pt.x, pt.y );
1896             if (flags & DCX_CLIPCHILDREN) escape.mode = ClipByChildren;
1897         }
1898         else escape.drawable = X11DRV_get_whole_window( top );
1899     }
1900
1901     ExtEscape( hdc, X11DRV_ESCAPE, sizeof(escape), (LPSTR)&escape, 0, NULL );
1902 }
1903
1904
1905 /***********************************************************************
1906  *              X11DRV_ReleaseDC  (X11DRV.@)
1907  */
1908 void CDECL X11DRV_ReleaseDC( HWND hwnd, HDC hdc )
1909 {
1910     struct x11drv_escape_set_drawable escape;
1911
1912     escape.code = X11DRV_SET_DRAWABLE;
1913     escape.hwnd = GetDesktopWindow();
1914     escape.drawable = root_window;
1915     escape.mode = IncludeInferiors;
1916     SetRect( &escape.dc_rect, 0, 0, virtual_screen_rect.right - virtual_screen_rect.left,
1917              virtual_screen_rect.bottom - virtual_screen_rect.top );
1918     OffsetRect( &escape.dc_rect, -virtual_screen_rect.left, -virtual_screen_rect.top );
1919     escape.fbconfig_id = 0;
1920     ExtEscape( hdc, X11DRV_ESCAPE, sizeof(escape), (LPSTR)&escape, 0, NULL );
1921 }
1922
1923
1924 /***********************************************************************
1925  *              SetCapture  (X11DRV.@)
1926  */
1927 void CDECL X11DRV_SetCapture( HWND hwnd, UINT flags )
1928 {
1929     struct x11drv_thread_data *thread_data = x11drv_thread_data();
1930
1931     if (!thread_data) return;
1932     if (!(flags & (GUI_INMOVESIZE | GUI_INMENUMODE))) return;
1933
1934     if (hwnd)
1935     {
1936         Window grab_win = X11DRV_get_whole_window( GetAncestor( hwnd, GA_ROOT ) );
1937
1938         if (!grab_win) return;
1939         XFlush( gdi_display );
1940         XGrabPointer( thread_data->display, grab_win, False,
1941                       PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
1942                       GrabModeAsync, GrabModeAsync, None, None, CurrentTime );
1943         thread_data->grab_window = grab_win;
1944     }
1945     else  /* release capture */
1946     {
1947         XFlush( gdi_display );
1948         XUngrabPointer( thread_data->display, CurrentTime );
1949         XFlush( thread_data->display );
1950         thread_data->grab_window = None;
1951     }
1952 }
1953
1954
1955 /*****************************************************************
1956  *              SetParent   (X11DRV.@)
1957  */
1958 void CDECL X11DRV_SetParent( HWND hwnd, HWND parent, HWND old_parent )
1959 {
1960     struct x11drv_win_data *data;
1961
1962     if (parent == old_parent) return;
1963     if (!(data = get_win_data( hwnd ))) return;
1964     if (data->embedded) goto done;
1965
1966     if (parent != GetDesktopWindow()) /* a child window */
1967     {
1968         if (old_parent == GetDesktopWindow())
1969         {
1970             /* destroy the old X windows */
1971             destroy_whole_window( data, FALSE );
1972             if (data->managed)
1973             {
1974                 data->managed = FALSE;
1975                 RemovePropA( data->hwnd, managed_prop );
1976             }
1977         }
1978     }
1979     else  /* new top level window */
1980     {
1981         create_whole_window( data );
1982     }
1983 done:
1984     release_win_data( data );
1985     fetch_icon_data( hwnd, 0, 0 );
1986 }
1987
1988
1989 static inline RECT get_surface_rect( const RECT *visible_rect )
1990 {
1991     RECT rect;
1992
1993     IntersectRect( &rect, visible_rect, &virtual_screen_rect );
1994     OffsetRect( &rect, -visible_rect->left, -visible_rect->top );
1995     rect.left &= ~31;
1996     rect.top  &= ~31;
1997     rect.right  = max( rect.left + 32, (rect.right + 31) & ~31 );
1998     rect.bottom = max( rect.top + 32, (rect.bottom + 31) & ~31 );
1999     return rect;
2000 }
2001
2002
2003 /***********************************************************************
2004  *              WindowPosChanging   (X11DRV.@)
2005  */
2006 void CDECL X11DRV_WindowPosChanging( HWND hwnd, HWND insert_after, UINT swp_flags,
2007                                      const RECT *window_rect, const RECT *client_rect, RECT *visible_rect,
2008                                      struct window_surface **surface )
2009 {
2010     struct x11drv_win_data *data = get_win_data( hwnd );
2011     RECT surface_rect;
2012     DWORD flags;
2013     COLORREF key;
2014     BOOL layered = GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_LAYERED;
2015
2016     if (!data && !(data = X11DRV_create_win_data( hwnd, window_rect, client_rect ))) return;
2017
2018     /* check if we need to switch the window to managed */
2019     if (!data->managed && data->whole_window && is_window_managed( hwnd, swp_flags, window_rect ))
2020     {
2021         TRACE( "making win %p/%lx managed\n", hwnd, data->whole_window );
2022         release_win_data( data );
2023         unmap_window( hwnd );
2024         if (!(data = get_win_data( hwnd ))) return;
2025         data->managed = TRUE;
2026         SetPropA( hwnd, managed_prop, (HANDLE)1 );
2027     }
2028
2029     *visible_rect = *window_rect;
2030     X11DRV_window_to_X_rect( data, visible_rect );
2031
2032     /* create the window surface if necessary */
2033     if (!data->whole_window) goto done;
2034     if (data->embedded) goto done;
2035     if (swp_flags & SWP_HIDEWINDOW) goto done;
2036     if (data->whole_window == root_window) goto done;
2037     if (has_gl_drawable( hwnd )) goto done;
2038     if (!client_side_graphics && !layered) goto done;
2039
2040     surface_rect = get_surface_rect( visible_rect );
2041     if (data->surface)
2042     {
2043         if (!memcmp( &data->surface->rect, &surface_rect, sizeof(surface_rect) ))
2044         {
2045             /* existing surface is good enough */
2046             window_surface_add_ref( data->surface );
2047             *surface = data->surface;
2048             goto done;
2049         }
2050     }
2051     else if (!(swp_flags & SWP_SHOWWINDOW) && !(GetWindowLongW( hwnd, GWL_STYLE ) & WS_VISIBLE)) goto done;
2052
2053     if (!layered || !GetLayeredWindowAttributes( hwnd, &key, NULL, &flags ) || !(flags & LWA_COLORKEY))
2054         key = CLR_INVALID;
2055
2056     *surface = create_surface( data->whole_window, &default_visual, &surface_rect, key );
2057
2058 done:
2059     release_win_data( data );
2060 }
2061
2062
2063 /***********************************************************************
2064  *              WindowPosChanged   (X11DRV.@)
2065  */
2066 void CDECL X11DRV_WindowPosChanged( HWND hwnd, HWND insert_after, UINT swp_flags,
2067                                     const RECT *rectWindow, const RECT *rectClient,
2068                                     const RECT *visible_rect, const RECT *valid_rects,
2069                                     struct window_surface *surface )
2070 {
2071     struct x11drv_thread_data *thread_data;
2072     struct x11drv_win_data *data;
2073     DWORD new_style = GetWindowLongW( hwnd, GWL_STYLE );
2074     RECT old_window_rect, old_whole_rect, old_client_rect;
2075     int event_type;
2076
2077     if (!(data = get_win_data( hwnd ))) return;
2078
2079     thread_data = x11drv_thread_data();
2080
2081     old_window_rect = data->window_rect;
2082     old_whole_rect  = data->whole_rect;
2083     old_client_rect = data->client_rect;
2084     data->window_rect = *rectWindow;
2085     data->whole_rect  = *visible_rect;
2086     data->client_rect = *rectClient;
2087     if (surface) window_surface_add_ref( surface );
2088     if (data->surface) window_surface_release( data->surface );
2089     data->surface = surface;
2090
2091     TRACE( "win %p window %s client %s style %08x flags %08x\n",
2092            hwnd, wine_dbgstr_rect(rectWindow), wine_dbgstr_rect(rectClient), new_style, swp_flags );
2093
2094     if (!IsRectEmpty( &valid_rects[0] ))
2095     {
2096         Window window = data->whole_window;
2097         int x_offset = old_whole_rect.left - data->whole_rect.left;
2098         int y_offset = old_whole_rect.top - data->whole_rect.top;
2099
2100         /* if all that happened is that the whole window moved, copy everything */
2101         if (!(swp_flags & SWP_FRAMECHANGED) &&
2102             old_whole_rect.right   - data->whole_rect.right   == x_offset &&
2103             old_whole_rect.bottom  - data->whole_rect.bottom  == y_offset &&
2104             old_client_rect.left   - data->client_rect.left   == x_offset &&
2105             old_client_rect.right  - data->client_rect.right  == x_offset &&
2106             old_client_rect.top    - data->client_rect.top    == y_offset &&
2107             old_client_rect.bottom - data->client_rect.bottom == y_offset &&
2108             !memcmp( &valid_rects[0], &data->client_rect, sizeof(RECT) ))
2109         {
2110             /* if we have an X window the bits will be moved by the X server */
2111             if (!window && (x_offset != 0 || y_offset != 0))
2112             {
2113                 release_win_data( data );
2114                 move_window_bits( hwnd, window, &old_whole_rect, visible_rect,
2115                                   &old_client_rect, rectClient, rectWindow );
2116                 if (!(data = get_win_data( hwnd ))) return;
2117             }
2118         }
2119         else
2120         {
2121             release_win_data( data );
2122             move_window_bits( hwnd, window, &valid_rects[1], &valid_rects[0],
2123                               &old_client_rect, rectClient, rectWindow );
2124             if (!(data = get_win_data( hwnd ))) return;
2125         }
2126     }
2127
2128     XFlush( gdi_display );  /* make sure painting is done before we move the window */
2129
2130     sync_gl_drawable( data->hwnd, visible_rect, rectClient );
2131
2132     if (!data->whole_window) goto done;
2133
2134     /* check if we are currently processing an event relevant to this window */
2135     event_type = 0;
2136     if (thread_data &&
2137         thread_data->current_event &&
2138         thread_data->current_event->xany.window == data->whole_window)
2139     {
2140         event_type = thread_data->current_event->type;
2141         if (event_type != ConfigureNotify && event_type != PropertyNotify &&
2142             event_type != GravityNotify && event_type != ReparentNotify)
2143             event_type = 0;  /* ignore other events */
2144     }
2145
2146     if (data->mapped && event_type != ReparentNotify)
2147     {
2148         if (((swp_flags & SWP_HIDEWINDOW) && !(new_style & WS_VISIBLE)) ||
2149             (!event_type &&
2150              !is_window_rect_mapped( rectWindow ) && is_window_rect_mapped( &old_window_rect )))
2151         {
2152             release_win_data( data );
2153             unmap_window( hwnd );
2154             if (is_window_rect_fullscreen( &old_window_rect )) reset_clipping_window();
2155             if (!(data = get_win_data( hwnd ))) return;
2156         }
2157     }
2158
2159     /* don't change position if we are about to minimize or maximize a managed window */
2160     if (!event_type &&
2161         !(data->managed && (swp_flags & SWP_STATECHANGED) && (new_style & (WS_MINIMIZE|WS_MAXIMIZE))))
2162         sync_window_position( data, swp_flags, &old_window_rect, &old_whole_rect, &old_client_rect );
2163
2164     if ((new_style & WS_VISIBLE) &&
2165         ((new_style & WS_MINIMIZE) || is_window_rect_mapped( rectWindow )))
2166     {
2167         if (!data->mapped)
2168         {
2169             BOOL needs_icon = !data->icon_pixmap;
2170
2171             release_win_data( data );
2172             if (needs_icon) fetch_icon_data( hwnd, 0, 0 );
2173             map_window( hwnd, new_style );
2174             return;
2175         }
2176         else if ((swp_flags & SWP_STATECHANGED) && (!data->iconic != !(new_style & WS_MINIMIZE)))
2177         {
2178             set_wm_hints( data );
2179             data->iconic = (new_style & WS_MINIMIZE) != 0;
2180             TRACE( "changing win %p iconic state to %u\n", data->hwnd, data->iconic );
2181             if (data->iconic)
2182                 XIconifyWindow( data->display, data->whole_window, DefaultScreen(data->display) );
2183             else if (is_window_rect_mapped( rectWindow ))
2184                 XMapWindow( data->display, data->whole_window );
2185             update_net_wm_states( data );
2186         }
2187         else
2188         {
2189             if (swp_flags & (SWP_FRAMECHANGED|SWP_STATECHANGED)) set_wm_hints( data );
2190             if (!event_type) update_net_wm_states( data );
2191         }
2192     }
2193
2194     XFlush( data->display );  /* make sure changes are done before we start painting again */
2195 done:
2196     release_win_data( data );
2197 }
2198
2199
2200 /***********************************************************************
2201  *           ShowWindow   (X11DRV.@)
2202  */
2203 UINT CDECL X11DRV_ShowWindow( HWND hwnd, INT cmd, RECT *rect, UINT swp )
2204 {
2205     int x, y;
2206     unsigned int width, height, border, depth;
2207     Window root, top;
2208     DWORD style = GetWindowLongW( hwnd, GWL_STYLE );
2209     struct x11drv_thread_data *thread_data = x11drv_thread_data();
2210     struct x11drv_win_data *data = get_win_data( hwnd );
2211
2212     if (!data || !data->whole_window || !data->managed || !data->mapped || data->iconic) goto done;
2213     if (style & WS_MINIMIZE) goto done;
2214     if (IsRectEmpty( rect )) goto done;
2215
2216     /* only fetch the new rectangle if the ShowWindow was a result of a window manager event */
2217
2218     if (!thread_data->current_event || thread_data->current_event->xany.window != data->whole_window)
2219         goto done;
2220
2221     if (thread_data->current_event->type != ConfigureNotify &&
2222         thread_data->current_event->type != PropertyNotify)
2223         goto done;
2224
2225     TRACE( "win %p/%lx cmd %d at %s flags %08x\n",
2226            hwnd, data->whole_window, cmd, wine_dbgstr_rect(rect), swp );
2227
2228     XGetGeometry( thread_data->display, data->whole_window,
2229                   &root, &x, &y, &width, &height, &border, &depth );
2230     XTranslateCoordinates( thread_data->display, data->whole_window, root, 0, 0, &x, &y, &top );
2231     rect->left   = x;
2232     rect->top    = y;
2233     rect->right  = x + width;
2234     rect->bottom = y + height;
2235     OffsetRect( rect, virtual_screen_rect.left, virtual_screen_rect.top );
2236     X11DRV_X_to_window_rect( data, rect );
2237     swp &= ~(SWP_NOMOVE | SWP_NOCLIENTMOVE | SWP_NOSIZE | SWP_NOCLIENTSIZE);
2238
2239 done:
2240     release_win_data( data );
2241     return swp;
2242 }
2243
2244
2245 /**********************************************************************
2246  *              SetWindowIcon (X11DRV.@)
2247  *
2248  * hIcon or hIconSm has changed (or is being initialised for the
2249  * first time). Complete the X11 driver-specific initialisation
2250  * and set the window hints.
2251  */
2252 void CDECL X11DRV_SetWindowIcon( HWND hwnd, UINT type, HICON icon )
2253 {
2254     struct x11drv_win_data *data;
2255
2256     if (!(data = get_win_data( hwnd ))) return;
2257     if (!data->whole_window) goto done;
2258     release_win_data( data );  /* release the lock, fetching the icon requires sending messages */
2259
2260     if (type == ICON_BIG) fetch_icon_data( hwnd, icon, 0 );
2261     else fetch_icon_data( hwnd, 0, icon );
2262
2263     if (!(data = get_win_data( hwnd ))) return;
2264     set_wm_hints( data );
2265 done:
2266     release_win_data( data );
2267 }
2268
2269
2270 /***********************************************************************
2271  *              SetWindowRgn  (X11DRV.@)
2272  *
2273  * Assign specified region to window (for non-rectangular windows)
2274  */
2275 int CDECL X11DRV_SetWindowRgn( HWND hwnd, HRGN hrgn, BOOL redraw )
2276 {
2277     struct x11drv_win_data *data;
2278
2279     if ((data = get_win_data( hwnd )))
2280     {
2281         sync_window_region( data, hrgn );
2282         release_win_data( data );
2283     }
2284     else if (X11DRV_get_whole_window( hwnd ))
2285     {
2286         SendMessageW( hwnd, WM_X11DRV_SET_WIN_REGION, 0, 0 );
2287     }
2288     return TRUE;
2289 }
2290
2291
2292 /***********************************************************************
2293  *              SetLayeredWindowAttributes  (X11DRV.@)
2294  *
2295  * Set transparency attributes for a layered window.
2296  */
2297 void CDECL X11DRV_SetLayeredWindowAttributes( HWND hwnd, COLORREF key, BYTE alpha, DWORD flags )
2298 {
2299     struct x11drv_win_data *data = get_win_data( hwnd );
2300
2301     if (data)
2302     {
2303         if (data->whole_window)
2304             sync_window_opacity( data->display, data->whole_window, key, alpha, flags );
2305         if (data->surface)
2306             set_surface_color_key( data->surface, (flags & LWA_COLORKEY) ? key : CLR_INVALID );
2307         release_win_data( data );
2308     }
2309     else
2310     {
2311         Window win = X11DRV_get_whole_window( hwnd );
2312         if (win)
2313         {
2314             sync_window_opacity( gdi_display, win, key, alpha, flags );
2315             if (flags & LWA_COLORKEY)
2316                 FIXME( "LWA_COLORKEY not supported on foreign process window %p\n", hwnd );
2317         }
2318     }
2319 }
2320
2321
2322 /**********************************************************************
2323  *           X11DRV_WindowMessage   (X11DRV.@)
2324  */
2325 LRESULT CDECL X11DRV_WindowMessage( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
2326 {
2327     struct x11drv_win_data *data;
2328
2329     switch(msg)
2330     {
2331     case WM_X11DRV_ACQUIRE_SELECTION:
2332         return X11DRV_AcquireClipboard( hwnd );
2333     case WM_X11DRV_SET_WIN_FORMAT:
2334         return set_win_format( hwnd, (XID)wp );
2335     case WM_X11DRV_SET_WIN_REGION:
2336         if ((data = get_win_data( hwnd )))
2337         {
2338             sync_window_region( data, (HRGN)1 );
2339             release_win_data( data );
2340         }
2341         return 0;
2342     case WM_X11DRV_RESIZE_DESKTOP:
2343         X11DRV_resize_desktop( LOWORD(lp), HIWORD(lp) );
2344         return 0;
2345     case WM_X11DRV_SET_CURSOR:
2346         if ((data = get_win_data( hwnd )))
2347         {
2348             if (data->whole_window) set_window_cursor( data->whole_window, (HCURSOR)lp );
2349             release_win_data( data );
2350         }
2351         else if (hwnd == x11drv_thread_data()->clip_hwnd)
2352             set_window_cursor( x11drv_thread_data()->clip_window, (HCURSOR)lp );
2353         return 0;
2354     case WM_X11DRV_CLIP_CURSOR:
2355         return clip_cursor_notify( hwnd, (HWND)lp );
2356     default:
2357         FIXME( "got window msg %x hwnd %p wp %lx lp %lx\n", msg, hwnd, wp, lp );
2358         return 0;
2359     }
2360 }
2361
2362
2363 /***********************************************************************
2364  *              is_netwm_supported
2365  */
2366 static BOOL is_netwm_supported( Display *display, Atom atom )
2367 {
2368     static Atom *net_supported;
2369     static int net_supported_count = -1;
2370     int i;
2371
2372     if (net_supported_count == -1)
2373     {
2374         Atom type;
2375         int format;
2376         unsigned long count, remaining;
2377
2378         if (!XGetWindowProperty( display, DefaultRootWindow(display), x11drv_atom(_NET_SUPPORTED), 0,
2379                                  ~0UL, False, XA_ATOM, &type, &format, &count,
2380                                  &remaining, (unsigned char **)&net_supported ))
2381             net_supported_count = get_property_size( format, count ) / sizeof(Atom);
2382         else
2383             net_supported_count = 0;
2384     }
2385
2386     for (i = 0; i < net_supported_count; i++)
2387         if (net_supported[i] == atom) return TRUE;
2388     return FALSE;
2389 }
2390
2391
2392 /***********************************************************************
2393  *           SysCommand   (X11DRV.@)
2394  *
2395  * Perform WM_SYSCOMMAND handling.
2396  */
2397 LRESULT CDECL X11DRV_SysCommand( HWND hwnd, WPARAM wparam, LPARAM lparam )
2398 {
2399     WPARAM hittest = wparam & 0x0f;
2400     int dir;
2401     struct x11drv_win_data *data;
2402
2403     if (!(data = get_win_data( hwnd ))) return -1;
2404     if (!data->whole_window || !data->managed || !data->mapped) goto failed;
2405
2406     switch (wparam & 0xfff0)
2407     {
2408     case SC_MOVE:
2409         if (!hittest) dir = _NET_WM_MOVERESIZE_MOVE_KEYBOARD;
2410         else dir = _NET_WM_MOVERESIZE_MOVE;
2411         break;
2412     case SC_SIZE:
2413         /* windows without WS_THICKFRAME are not resizable through the window manager */
2414         if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_THICKFRAME)) goto failed;
2415
2416         switch (hittest)
2417         {
2418         case WMSZ_LEFT:        dir = _NET_WM_MOVERESIZE_SIZE_LEFT; break;
2419         case WMSZ_RIGHT:       dir = _NET_WM_MOVERESIZE_SIZE_RIGHT; break;
2420         case WMSZ_TOP:         dir = _NET_WM_MOVERESIZE_SIZE_TOP; break;
2421         case WMSZ_TOPLEFT:     dir = _NET_WM_MOVERESIZE_SIZE_TOPLEFT; break;
2422         case WMSZ_TOPRIGHT:    dir = _NET_WM_MOVERESIZE_SIZE_TOPRIGHT; break;
2423         case WMSZ_BOTTOM:      dir = _NET_WM_MOVERESIZE_SIZE_BOTTOM; break;
2424         case WMSZ_BOTTOMLEFT:  dir = _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT; break;
2425         case WMSZ_BOTTOMRIGHT: dir = _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT; break;
2426         default:               dir = _NET_WM_MOVERESIZE_SIZE_KEYBOARD; break;
2427         }
2428         break;
2429
2430     case SC_KEYMENU:
2431         /* prevent a simple ALT press+release from activating the system menu,
2432          * as that can get confusing on managed windows */
2433         if ((WCHAR)lparam) goto failed;  /* got an explicit char */
2434         if (GetMenu( hwnd )) goto failed;  /* window has a real menu */
2435         if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_SYSMENU)) goto failed;  /* no system menu */
2436         TRACE( "ignoring SC_KEYMENU wp %lx lp %lx\n", wparam, lparam );
2437         release_win_data( data );
2438         return 0;
2439
2440     default:
2441         goto failed;
2442     }
2443
2444     if (IsZoomed(hwnd)) goto failed;
2445
2446     if (!is_netwm_supported( data->display, x11drv_atom(_NET_WM_MOVERESIZE) ))
2447     {
2448         TRACE( "_NET_WM_MOVERESIZE not supported\n" );
2449         goto failed;
2450     }
2451
2452     release_win_data( data );
2453     move_resize_window( hwnd, dir );
2454     return 0;
2455
2456 failed:
2457     release_win_data( data );
2458     return -1;
2459 }