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