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