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  *              move_window_bits
1268  *
1269  * Move the window bits when a window is moved.
1270  */
1271 static void move_window_bits( HWND hwnd, Window window, const RECT *old_rect, const RECT *new_rect,
1272                               const RECT *old_client_rect, const RECT *new_client_rect,
1273                               const RECT *new_window_rect )
1274 {
1275     RECT src_rect = *old_rect;
1276     RECT dst_rect = *new_rect;
1277     HDC hdc_src, hdc_dst;
1278     INT code;
1279     HRGN rgn;
1280     HWND parent = 0;
1281
1282     if (!window)
1283     {
1284         OffsetRect( &dst_rect, -new_window_rect->left, -new_window_rect->top );
1285         parent = GetAncestor( hwnd, GA_PARENT );
1286         hdc_src = GetDCEx( parent, 0, DCX_CACHE );
1287         hdc_dst = GetDCEx( hwnd, 0, DCX_CACHE | DCX_WINDOW );
1288     }
1289     else
1290     {
1291         OffsetRect( &dst_rect, -new_client_rect->left, -new_client_rect->top );
1292         /* make src rect relative to the old position of the window */
1293         OffsetRect( &src_rect, -old_client_rect->left, -old_client_rect->top );
1294         if (dst_rect.left == src_rect.left && dst_rect.top == src_rect.top) return;
1295         hdc_src = hdc_dst = GetDCEx( hwnd, 0, DCX_CACHE );
1296     }
1297
1298     rgn = CreateRectRgnIndirect( &dst_rect );
1299     SelectClipRgn( hdc_dst, rgn );
1300     DeleteObject( rgn );
1301     ExcludeUpdateRgn( hdc_dst, hwnd );
1302
1303     code = X11DRV_START_EXPOSURES;
1304     ExtEscape( hdc_dst, X11DRV_ESCAPE, sizeof(code), (LPSTR)&code, 0, NULL );
1305
1306     TRACE( "copying bits for win %p/%lx %s -> %s\n",
1307            hwnd, window, wine_dbgstr_rect(&src_rect), wine_dbgstr_rect(&dst_rect) );
1308     BitBlt( hdc_dst, dst_rect.left, dst_rect.top,
1309             dst_rect.right - dst_rect.left, dst_rect.bottom - dst_rect.top,
1310             hdc_src, src_rect.left, src_rect.top, SRCCOPY );
1311
1312     rgn = 0;
1313     code = X11DRV_END_EXPOSURES;
1314     ExtEscape( hdc_dst, X11DRV_ESCAPE, sizeof(code), (LPSTR)&code, sizeof(rgn), (LPSTR)&rgn );
1315
1316     ReleaseDC( hwnd, hdc_dst );
1317     if (hdc_src != hdc_dst) ReleaseDC( parent, hdc_src );
1318
1319     if (rgn)
1320     {
1321         if (!window)
1322         {
1323             /* map region to client rect since we are using DCX_WINDOW */
1324             OffsetRgn( rgn, new_window_rect->left - new_client_rect->left,
1325                        new_window_rect->top - new_client_rect->top );
1326             RedrawWindow( hwnd, NULL, rgn,
1327                           RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ALLCHILDREN );
1328         }
1329         else RedrawWindow( hwnd, NULL, rgn, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN );
1330         DeleteObject( rgn );
1331     }
1332 }
1333
1334
1335 /**********************************************************************
1336  *              create_whole_window
1337  *
1338  * Create the whole X window for a given window
1339  */
1340 static void create_whole_window( struct x11drv_win_data *data )
1341 {
1342     int cx, cy, mask;
1343     XSetWindowAttributes attr;
1344     WCHAR text[1024];
1345     COLORREF key;
1346     BYTE alpha;
1347     DWORD layered_flags;
1348     HRGN win_rgn;
1349
1350     if (!data->managed && is_window_managed( data->hwnd, SWP_NOACTIVATE, &data->window_rect ))
1351     {
1352         TRACE( "making win %p/%lx managed\n", data->hwnd, data->whole_window );
1353         data->managed = TRUE;
1354     }
1355
1356     if ((win_rgn = CreateRectRgn( 0, 0, 0, 0 )) && GetWindowRgn( data->hwnd, win_rgn ) == ERROR)
1357     {
1358         DeleteObject( win_rgn );
1359         win_rgn = 0;
1360     }
1361     data->shaped = (win_rgn != 0);
1362
1363     if (data->vis.visualid != default_visual.visualid)
1364         data->colormap = XCreateColormap( data->display, root_window, data->vis.visual, AllocNone );
1365
1366     mask = get_window_attributes( data, &attr );
1367
1368     data->whole_rect = data->window_rect;
1369     X11DRV_window_to_X_rect( data, &data->whole_rect );
1370     if (!(cx = data->whole_rect.right - data->whole_rect.left)) cx = 1;
1371     else if (cx > 65535) cx = 65535;
1372     if (!(cy = data->whole_rect.bottom - data->whole_rect.top)) cy = 1;
1373     else if (cy > 65535) cy = 65535;
1374
1375     data->whole_window = XCreateWindow( data->display, root_window,
1376                                         data->whole_rect.left - virtual_screen_rect.left,
1377                                         data->whole_rect.top - virtual_screen_rect.top,
1378                                         cx, cy, 0, data->vis.depth, InputOutput,
1379                                         data->vis.visual, mask, &attr );
1380     if (!data->whole_window) goto done;
1381
1382     set_initial_wm_hints( data->display, data->whole_window );
1383     set_wm_hints( data );
1384
1385     XSaveContext( data->display, data->whole_window, winContext, (char *)data->hwnd );
1386     SetPropA( data->hwnd, whole_window_prop, (HANDLE)data->whole_window );
1387
1388     /* set the window text */
1389     if (!InternalGetWindowText( data->hwnd, text, sizeof(text)/sizeof(WCHAR) )) text[0] = 0;
1390     sync_window_text( data->display, data->whole_window, text );
1391
1392     /* set the window region */
1393     if (win_rgn || IsRectEmpty( &data->window_rect )) sync_window_region( data, win_rgn );
1394
1395     /* set the window opacity */
1396     if (!GetLayeredWindowAttributes( data->hwnd, &key, &alpha, &layered_flags )) layered_flags = 0;
1397     sync_window_opacity( data->display, data->whole_window, key, alpha, layered_flags );
1398
1399     XFlush( data->display );  /* make sure the window exists before we start painting to it */
1400
1401     sync_window_cursor( data->whole_window );
1402
1403 done:
1404     if (win_rgn) DeleteObject( win_rgn );
1405 }
1406
1407
1408 /**********************************************************************
1409  *              destroy_whole_window
1410  *
1411  * Destroy the whole X window for a given window.
1412  */
1413 static void destroy_whole_window( struct x11drv_win_data *data, BOOL already_destroyed )
1414 {
1415     if (!data->whole_window)
1416     {
1417         if (data->embedded)
1418         {
1419             Window xwin = (Window)GetPropA( data->hwnd, foreign_window_prop );
1420             if (xwin)
1421             {
1422                 if (!already_destroyed) XSelectInput( data->display, xwin, 0 );
1423                 XDeleteContext( data->display, xwin, winContext );
1424                 RemovePropA( data->hwnd, foreign_window_prop );
1425             }
1426         }
1427         return;
1428     }
1429
1430
1431     TRACE( "win %p xwin %lx\n", data->hwnd, data->whole_window );
1432     XDeleteContext( data->display, data->whole_window, winContext );
1433     if (!already_destroyed) XDestroyWindow( data->display, data->whole_window );
1434     if (data->colormap) XFreeColormap( data->display, data->colormap );
1435     data->whole_window = 0;
1436     data->colormap = 0;
1437     data->wm_state = WithdrawnState;
1438     data->net_wm_state = 0;
1439     data->mapped = FALSE;
1440     if (data->xic)
1441     {
1442         XUnsetICFocus( data->xic );
1443         XDestroyIC( data->xic );
1444         data->xic = 0;
1445     }
1446     /* Outlook stops processing messages after destroying a dialog, so we need an explicit flush */
1447     XFlush( data->display );
1448     if (data->surface) window_surface_release( data->surface );
1449     data->surface = NULL;
1450     RemovePropA( data->hwnd, whole_window_prop );
1451 }
1452
1453
1454 /**********************************************************************
1455  *              set_window_visual
1456  *
1457  * Change the visual by destroying and recreating the X window if needed.
1458  */
1459 void set_window_visual( struct x11drv_win_data *data, const XVisualInfo *vis )
1460 {
1461     if (data->vis.visualid == vis->visualid) return;
1462     destroy_whole_window( data, FALSE );
1463     if (data->surface) window_surface_release( data->surface );
1464     data->surface = NULL;
1465     data->vis = *vis;
1466     create_whole_window( data );
1467 }
1468
1469
1470 /*****************************************************************
1471  *              SetWindowText   (X11DRV.@)
1472  */
1473 void CDECL X11DRV_SetWindowText( HWND hwnd, LPCWSTR text )
1474 {
1475     Window win;
1476
1477     if ((win = X11DRV_get_whole_window( hwnd )) && win != DefaultRootWindow(gdi_display))
1478     {
1479         Display *display = thread_init_display();
1480         sync_window_text( display, win, text );
1481     }
1482 }
1483
1484
1485 /***********************************************************************
1486  *              SetWindowStyle   (X11DRV.@)
1487  *
1488  * Update the X state of a window to reflect a style change
1489  */
1490 void CDECL X11DRV_SetWindowStyle( HWND hwnd, INT offset, STYLESTRUCT *style )
1491 {
1492     struct x11drv_win_data *data;
1493     DWORD changed = style->styleNew ^ style->styleOld;
1494
1495     if (hwnd == GetDesktopWindow()) return;
1496     if (!(data = get_win_data( hwnd ))) return;
1497     if (!data->whole_window) goto done;
1498
1499     if (offset == GWL_STYLE && (changed & WS_DISABLED)) set_wm_hints( data );
1500
1501     if (offset == GWL_EXSTYLE && (changed & WS_EX_LAYERED)) /* changing WS_EX_LAYERED resets attributes */
1502     {
1503         set_window_visual( data, &default_visual );
1504         sync_window_opacity( data->display, data->whole_window, 0, 0, 0 );
1505         if (data->surface) set_surface_color_key( data->surface, CLR_INVALID );
1506     }
1507 done:
1508     release_win_data( data );
1509 }
1510
1511
1512 /***********************************************************************
1513  *              DestroyWindow   (X11DRV.@)
1514  */
1515 void CDECL X11DRV_DestroyWindow( HWND hwnd )
1516 {
1517     struct x11drv_thread_data *thread_data = x11drv_thread_data();
1518     struct x11drv_win_data *data;
1519
1520     if (!(data = get_win_data( hwnd ))) return;
1521
1522     destroy_whole_window( data, FALSE );
1523     if (thread_data->last_focus == hwnd) thread_data->last_focus = 0;
1524     if (thread_data->last_xic_hwnd == hwnd) thread_data->last_xic_hwnd = 0;
1525     if (data->icon_pixmap) XFreePixmap( gdi_display, data->icon_pixmap );
1526     if (data->icon_mask) XFreePixmap( gdi_display, data->icon_mask );
1527     HeapFree( GetProcessHeap(), 0, data->icon_bits );
1528     XDeleteContext( gdi_display, (XID)hwnd, win_data_context );
1529     release_win_data( data );
1530     HeapFree( GetProcessHeap(), 0, data );
1531     destroy_gl_drawable( hwnd );
1532 }
1533
1534
1535 /***********************************************************************
1536  *              X11DRV_DestroyNotify
1537  */
1538 void X11DRV_DestroyNotify( HWND hwnd, XEvent *event )
1539 {
1540     struct x11drv_win_data *data;
1541     BOOL embedded;
1542
1543     if (!(data = get_win_data( hwnd ))) return;
1544     embedded = data->embedded;
1545     if (!embedded) FIXME( "window %p/%lx destroyed from the outside\n", hwnd, data->whole_window );
1546
1547     destroy_whole_window( data, TRUE );
1548     release_win_data( data );
1549     if (embedded) SendMessageW( hwnd, WM_CLOSE, 0, 0 );
1550 }
1551
1552
1553 static struct x11drv_win_data *alloc_win_data( Display *display, HWND hwnd )
1554 {
1555     struct x11drv_win_data *data;
1556
1557     if ((data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*data))))
1558     {
1559         data->display = display;
1560         data->vis = default_visual;
1561         data->hwnd = hwnd;
1562         EnterCriticalSection( &win_data_section );
1563         XSaveContext( gdi_display, (XID)hwnd, win_data_context, (char *)data );
1564     }
1565     return data;
1566 }
1567
1568
1569 /* initialize the desktop window id in the desktop manager process */
1570 static BOOL create_desktop_win_data( Display *display, HWND hwnd )
1571 {
1572     struct x11drv_win_data *data;
1573
1574     if (!(data = alloc_win_data( display, hwnd ))) return FALSE;
1575     data->whole_window = root_window;
1576     data->managed = TRUE;
1577     SetPropA( data->hwnd, whole_window_prop, (HANDLE)root_window );
1578     set_initial_wm_hints( display, root_window );
1579     release_win_data( data );
1580     return TRUE;
1581 }
1582
1583 /**********************************************************************
1584  *              CreateDesktopWindow   (X11DRV.@)
1585  */
1586 BOOL CDECL X11DRV_CreateDesktopWindow( HWND hwnd )
1587 {
1588     unsigned int width, height;
1589
1590     /* retrieve the real size of the desktop */
1591     SERVER_START_REQ( get_window_rectangles )
1592     {
1593         req->handle = wine_server_user_handle( hwnd );
1594         req->relative = COORDS_CLIENT;
1595         wine_server_call( req );
1596         width  = reply->window.right;
1597         height = reply->window.bottom;
1598     }
1599     SERVER_END_REQ;
1600
1601     if (!width && !height)  /* not initialized yet */
1602     {
1603         SERVER_START_REQ( set_window_pos )
1604         {
1605             req->handle        = wine_server_user_handle( hwnd );
1606             req->previous      = 0;
1607             req->swp_flags     = SWP_NOZORDER;
1608             req->window.left   = virtual_screen_rect.left;
1609             req->window.top    = virtual_screen_rect.top;
1610             req->window.right  = virtual_screen_rect.right;
1611             req->window.bottom = virtual_screen_rect.bottom;
1612             req->client        = req->window;
1613             wine_server_call( req );
1614         }
1615         SERVER_END_REQ;
1616     }
1617     else
1618     {
1619         Window win = (Window)GetPropA( hwnd, whole_window_prop );
1620         if (win && win != root_window) X11DRV_init_desktop( win, width, height );
1621     }
1622     return TRUE;
1623 }
1624
1625
1626 /**********************************************************************
1627  *              CreateWindow   (X11DRV.@)
1628  */
1629 BOOL CDECL X11DRV_CreateWindow( HWND hwnd )
1630 {
1631     if (hwnd == GetDesktopWindow())
1632     {
1633         struct x11drv_thread_data *data = x11drv_init_thread_data();
1634         XSetWindowAttributes attr;
1635
1636         if (root_window != DefaultRootWindow( gdi_display ))
1637         {
1638             /* the desktop win data can't be created lazily */
1639             if (!create_desktop_win_data( data->display, hwnd )) return FALSE;
1640         }
1641
1642         /* create the cursor clipping window */
1643         attr.override_redirect = TRUE;
1644         attr.event_mask = StructureNotifyMask | FocusChangeMask;
1645         data->clip_window = XCreateWindow( data->display, root_window, 0, 0, 1, 1, 0, 0,
1646                                            InputOnly, default_visual.visual,
1647                                            CWOverrideRedirect | CWEventMask, &attr );
1648         XFlush( data->display );
1649         SetPropA( hwnd, clip_window_prop, (HANDLE)data->clip_window );
1650     }
1651     return TRUE;
1652 }
1653
1654
1655 /***********************************************************************
1656  *              get_win_data
1657  *
1658  * Lock and return the X11 data structure associated with a window.
1659  */
1660 struct x11drv_win_data *get_win_data( HWND hwnd )
1661 {
1662     char *data;
1663
1664     if (!hwnd) return NULL;
1665     EnterCriticalSection( &win_data_section );
1666     if (!XFindContext( gdi_display, (XID)hwnd, win_data_context, &data ))
1667         return (struct x11drv_win_data *)data;
1668     LeaveCriticalSection( &win_data_section );
1669     return NULL;
1670 }
1671
1672
1673 /***********************************************************************
1674  *              release_win_data
1675  *
1676  * Release the data returned by get_win_data.
1677  */
1678 void release_win_data( struct x11drv_win_data *data )
1679 {
1680     if (data) LeaveCriticalSection( &win_data_section );
1681 }
1682
1683
1684 /***********************************************************************
1685  *              X11DRV_create_win_data
1686  *
1687  * Create an X11 data window structure for an existing window.
1688  */
1689 static struct x11drv_win_data *X11DRV_create_win_data( HWND hwnd, const RECT *window_rect,
1690                                                        const RECT *client_rect )
1691 {
1692     Display *display;
1693     struct x11drv_win_data *data;
1694     HWND parent;
1695
1696     if (!(parent = GetAncestor( hwnd, GA_PARENT ))) return NULL;  /* desktop */
1697
1698     /* don't create win data for HWND_MESSAGE windows */
1699     if (parent != GetDesktopWindow() && !GetAncestor( parent, GA_PARENT )) return NULL;
1700
1701     if (GetWindowThreadProcessId( hwnd, NULL ) != GetCurrentThreadId()) return NULL;
1702
1703     display = thread_init_display();
1704     init_clip_window();  /* make sure the clip window is initialized in this thread */
1705
1706     if (!(data = alloc_win_data( display, hwnd ))) return NULL;
1707
1708     data->whole_rect = data->window_rect = *window_rect;
1709     data->client_rect = *client_rect;
1710     if (parent == GetDesktopWindow())
1711     {
1712         create_whole_window( data );
1713         TRACE( "win %p/%lx window %s whole %s client %s\n",
1714                hwnd, data->whole_window, wine_dbgstr_rect( &data->window_rect ),
1715                wine_dbgstr_rect( &data->whole_rect ), wine_dbgstr_rect( &data->client_rect ));
1716     }
1717     return data;
1718 }
1719
1720
1721 /* window procedure for foreign windows */
1722 static LRESULT WINAPI foreign_window_proc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
1723 {
1724     switch(msg)
1725     {
1726     case WM_WINDOWPOSCHANGED:
1727         update_systray_balloon_position();
1728         break;
1729     case WM_PARENTNOTIFY:
1730         if (LOWORD(wparam) == WM_DESTROY)
1731         {
1732             TRACE( "%p: got parent notify destroy for win %lx\n", hwnd, lparam );
1733             PostMessageW( hwnd, WM_CLOSE, 0, 0 );  /* so that we come back here once the child is gone */
1734         }
1735         return 0;
1736     case WM_CLOSE:
1737         if (GetWindow( hwnd, GW_CHILD )) return 0;  /* refuse to die if we still have children */
1738         break;
1739     }
1740     return DefWindowProcW( hwnd, msg, wparam, lparam );
1741 }
1742
1743
1744 /***********************************************************************
1745  *              create_foreign_window
1746  *
1747  * Create a foreign window for the specified X window and its ancestors
1748  */
1749 HWND create_foreign_window( Display *display, Window xwin )
1750 {
1751     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};
1752     static BOOL class_registered;
1753     struct x11drv_win_data *data;
1754     HWND hwnd, parent;
1755     Window xparent, xroot;
1756     Window *xchildren;
1757     unsigned int nchildren;
1758     XWindowAttributes attr;
1759     DWORD style = WS_CLIPCHILDREN;
1760
1761     if (!class_registered)
1762     {
1763         WNDCLASSEXW class;
1764
1765         memset( &class, 0, sizeof(class) );
1766         class.cbSize        = sizeof(class);
1767         class.lpfnWndProc   = foreign_window_proc;
1768         class.lpszClassName = classW;
1769         if (!RegisterClassExW( &class ) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS)
1770         {
1771             ERR( "Could not register foreign window class\n" );
1772             return FALSE;
1773         }
1774         class_registered = TRUE;
1775     }
1776
1777     if (XFindContext( display, xwin, winContext, (char **)&hwnd )) hwnd = 0;
1778     if (hwnd) return hwnd;  /* already created */
1779
1780     XSelectInput( display, xwin, StructureNotifyMask );
1781     if (!XGetWindowAttributes( display, xwin, &attr ) ||
1782         !XQueryTree( display, xwin, &xroot, &xparent, &xchildren, &nchildren ))
1783     {
1784         XSelectInput( display, xwin, 0 );
1785         return 0;
1786     }
1787     XFree( xchildren );
1788
1789     if (xparent == xroot)
1790     {
1791         parent = GetDesktopWindow();
1792         style |= WS_POPUP;
1793         attr.x += virtual_screen_rect.left;
1794         attr.y += virtual_screen_rect.top;
1795     }
1796     else
1797     {
1798         parent = create_foreign_window( display, xparent );
1799         style |= WS_CHILD;
1800     }
1801
1802     hwnd = CreateWindowW( classW, NULL, style, attr.x, attr.y, attr.width, attr.height,
1803                           parent, 0, 0, NULL );
1804
1805     if (!(data = alloc_win_data( display, hwnd )))
1806     {
1807         DestroyWindow( hwnd );
1808         return 0;
1809     }
1810     SetRect( &data->window_rect, attr.x, attr.y, attr.x + attr.width, attr.y + attr.height );
1811     data->whole_rect = data->client_rect = data->window_rect;
1812     data->whole_window = 0;
1813     data->embedded = TRUE;
1814     data->mapped = TRUE;
1815
1816     SetPropA( hwnd, foreign_window_prop, (HANDLE)xwin );
1817     XSaveContext( display, xwin, winContext, (char *)data->hwnd );
1818
1819     ShowWindow( hwnd, SW_SHOW );
1820
1821     TRACE( "win %lx parent %p style %08x %s -> hwnd %p\n",
1822            xwin, parent, style, wine_dbgstr_rect(&data->window_rect), hwnd );
1823
1824     return hwnd;
1825 }
1826
1827
1828 /***********************************************************************
1829  *              X11DRV_get_whole_window
1830  *
1831  * Return the X window associated with the full area of a window
1832  */
1833 Window X11DRV_get_whole_window( HWND hwnd )
1834 {
1835     struct x11drv_win_data *data = get_win_data( hwnd );
1836     Window ret;
1837
1838     if (!data)
1839     {
1840         if (hwnd == GetDesktopWindow()) return root_window;
1841         return (Window)GetPropA( hwnd, whole_window_prop );
1842     }
1843     ret = data->whole_window;
1844     release_win_data( data );
1845     return ret;
1846 }
1847
1848
1849 /***********************************************************************
1850  *              X11DRV_get_ic
1851  *
1852  * Return the X input context associated with a window
1853  */
1854 XIC X11DRV_get_ic( HWND hwnd )
1855 {
1856     struct x11drv_win_data *data = get_win_data( hwnd );
1857     XIM xim;
1858     XIC ret = 0;
1859
1860     if (data)
1861     {
1862         x11drv_thread_data()->last_xic_hwnd = hwnd;
1863         ret = data->xic;
1864         if (!ret && (xim = x11drv_thread_data()->xim)) ret = X11DRV_CreateIC( xim, data );
1865         release_win_data( data );
1866     }
1867     return ret;
1868 }
1869
1870
1871 /***********************************************************************
1872  *              X11DRV_GetDC   (X11DRV.@)
1873  */
1874 void CDECL X11DRV_GetDC( HDC hdc, HWND hwnd, HWND top, const RECT *win_rect,
1875                          const RECT *top_rect, DWORD flags )
1876 {
1877     struct x11drv_escape_set_drawable escape;
1878     HWND parent;
1879
1880     escape.code        = X11DRV_SET_DRAWABLE;
1881     escape.hwnd        = hwnd;
1882     escape.mode        = IncludeInferiors;
1883     escape.fbconfig_id = 0;
1884
1885     escape.dc_rect.left         = win_rect->left - top_rect->left;
1886     escape.dc_rect.top          = win_rect->top - top_rect->top;
1887     escape.dc_rect.right        = win_rect->right - top_rect->left;
1888     escape.dc_rect.bottom       = win_rect->bottom - top_rect->top;
1889
1890     if (top == hwnd)
1891     {
1892         struct x11drv_win_data *data = get_win_data( hwnd );
1893
1894         escape.drawable = data ? data->whole_window : X11DRV_get_whole_window( hwnd );
1895
1896         /* special case: when repainting the root window, clip out top-level windows */
1897         if (data && data->whole_window == root_window) escape.mode = ClipByChildren;
1898         release_win_data( data );
1899     }
1900     else
1901     {
1902         /* find the first ancestor that has a drawable */
1903         for (parent = hwnd; parent && parent != top; parent = GetAncestor( parent, GA_PARENT ))
1904             if ((escape.drawable = X11DRV_get_whole_window( parent ))) break;
1905
1906         if (escape.drawable)
1907         {
1908             POINT pt = { 0, 0 };
1909             MapWindowPoints( 0, parent, &pt, 1 );
1910             escape.dc_rect = *win_rect;
1911             OffsetRect( &escape.dc_rect, pt.x, pt.y );
1912             if (flags & DCX_CLIPCHILDREN) escape.mode = ClipByChildren;
1913         }
1914         else escape.drawable = X11DRV_get_whole_window( top );
1915     }
1916
1917     ExtEscape( hdc, X11DRV_ESCAPE, sizeof(escape), (LPSTR)&escape, 0, NULL );
1918 }
1919
1920
1921 /***********************************************************************
1922  *              X11DRV_ReleaseDC  (X11DRV.@)
1923  */
1924 void CDECL X11DRV_ReleaseDC( HWND hwnd, HDC hdc )
1925 {
1926     struct x11drv_escape_set_drawable escape;
1927
1928     escape.code = X11DRV_SET_DRAWABLE;
1929     escape.hwnd = GetDesktopWindow();
1930     escape.drawable = root_window;
1931     escape.mode = IncludeInferiors;
1932     SetRect( &escape.dc_rect, 0, 0, virtual_screen_rect.right - virtual_screen_rect.left,
1933              virtual_screen_rect.bottom - virtual_screen_rect.top );
1934     OffsetRect( &escape.dc_rect, -virtual_screen_rect.left, -virtual_screen_rect.top );
1935     escape.fbconfig_id = 0;
1936     ExtEscape( hdc, X11DRV_ESCAPE, sizeof(escape), (LPSTR)&escape, 0, NULL );
1937 }
1938
1939
1940 /***********************************************************************
1941  *              SetCapture  (X11DRV.@)
1942  */
1943 void CDECL X11DRV_SetCapture( HWND hwnd, UINT flags )
1944 {
1945     struct x11drv_thread_data *thread_data = x11drv_thread_data();
1946
1947     if (!thread_data) return;
1948     if (!(flags & (GUI_INMOVESIZE | GUI_INMENUMODE))) return;
1949
1950     if (hwnd)
1951     {
1952         Window grab_win = X11DRV_get_whole_window( GetAncestor( hwnd, GA_ROOT ) );
1953
1954         if (!grab_win) return;
1955         XFlush( gdi_display );
1956         XGrabPointer( thread_data->display, grab_win, False,
1957                       PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
1958                       GrabModeAsync, GrabModeAsync, None, None, CurrentTime );
1959         thread_data->grab_window = grab_win;
1960     }
1961     else  /* release capture */
1962     {
1963         XFlush( gdi_display );
1964         XUngrabPointer( thread_data->display, CurrentTime );
1965         XFlush( thread_data->display );
1966         thread_data->grab_window = None;
1967     }
1968 }
1969
1970
1971 /*****************************************************************
1972  *              SetParent   (X11DRV.@)
1973  */
1974 void CDECL X11DRV_SetParent( HWND hwnd, HWND parent, HWND old_parent )
1975 {
1976     struct x11drv_win_data *data;
1977
1978     if (parent == old_parent) return;
1979     if (!(data = get_win_data( hwnd ))) return;
1980     if (data->embedded) goto done;
1981
1982     if (parent != GetDesktopWindow()) /* a child window */
1983     {
1984         if (old_parent == GetDesktopWindow())
1985         {
1986             /* destroy the old X windows */
1987             destroy_whole_window( data, FALSE );
1988             data->managed = FALSE;
1989         }
1990     }
1991     else  /* new top level window */
1992     {
1993         create_whole_window( data );
1994     }
1995 done:
1996     release_win_data( data );
1997     set_gl_drawable_parent( hwnd, parent );
1998     fetch_icon_data( hwnd, 0, 0 );
1999 }
2000
2001
2002 static inline RECT get_surface_rect( const RECT *visible_rect )
2003 {
2004     RECT rect;
2005
2006     IntersectRect( &rect, visible_rect, &virtual_screen_rect );
2007     OffsetRect( &rect, -visible_rect->left, -visible_rect->top );
2008     rect.left &= ~31;
2009     rect.top  &= ~31;
2010     rect.right  = max( rect.left + 32, (rect.right + 31) & ~31 );
2011     rect.bottom = max( rect.top + 32, (rect.bottom + 31) & ~31 );
2012     return rect;
2013 }
2014
2015
2016 /***********************************************************************
2017  *              WindowPosChanging   (X11DRV.@)
2018  */
2019 void CDECL X11DRV_WindowPosChanging( HWND hwnd, HWND insert_after, UINT swp_flags,
2020                                      const RECT *window_rect, const RECT *client_rect, RECT *visible_rect,
2021                                      struct window_surface **surface )
2022 {
2023     struct x11drv_win_data *data = get_win_data( hwnd );
2024     RECT surface_rect;
2025     DWORD flags;
2026     COLORREF key;
2027     BOOL layered = GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_LAYERED;
2028
2029     if (!data && !(data = X11DRV_create_win_data( hwnd, window_rect, client_rect ))) return;
2030
2031     /* check if we need to switch the window to managed */
2032     if (!data->managed && data->whole_window && is_window_managed( hwnd, swp_flags, window_rect ))
2033     {
2034         TRACE( "making win %p/%lx managed\n", hwnd, data->whole_window );
2035         release_win_data( data );
2036         unmap_window( hwnd );
2037         if (!(data = get_win_data( hwnd ))) return;
2038         data->managed = TRUE;
2039     }
2040
2041     *visible_rect = *window_rect;
2042     X11DRV_window_to_X_rect( data, visible_rect );
2043
2044     /* create the window surface if necessary */
2045
2046     if (!data->whole_window) goto done;
2047     if (swp_flags & SWP_HIDEWINDOW) goto done;
2048     if (data->vis.visualid != default_visual.visualid) goto done;
2049
2050     if (*surface) window_surface_release( *surface );
2051     *surface = NULL;  /* indicate that we want to draw directly to the window */
2052
2053     if (data->embedded) goto done;
2054     if (data->whole_window == root_window) goto done;
2055     if (!client_side_graphics && !layered) goto done;
2056
2057     surface_rect = get_surface_rect( visible_rect );
2058     if (data->surface)
2059     {
2060         if (!memcmp( &data->surface->rect, &surface_rect, sizeof(surface_rect) ))
2061         {
2062             /* existing surface is good enough */
2063             window_surface_add_ref( data->surface );
2064             *surface = data->surface;
2065             goto done;
2066         }
2067     }
2068     else if (!(swp_flags & SWP_SHOWWINDOW) && !(GetWindowLongW( hwnd, GWL_STYLE ) & WS_VISIBLE)) goto done;
2069
2070     if (!layered || !GetLayeredWindowAttributes( hwnd, &key, NULL, &flags ) || !(flags & LWA_COLORKEY))
2071         key = CLR_INVALID;
2072
2073     *surface = create_surface( data->whole_window, &data->vis, &surface_rect, key, FALSE );
2074
2075 done:
2076     release_win_data( data );
2077 }
2078
2079
2080 /***********************************************************************
2081  *              WindowPosChanged   (X11DRV.@)
2082  */
2083 void CDECL X11DRV_WindowPosChanged( HWND hwnd, HWND insert_after, UINT swp_flags,
2084                                     const RECT *rectWindow, const RECT *rectClient,
2085                                     const RECT *visible_rect, const RECT *valid_rects,
2086                                     struct window_surface *surface )
2087 {
2088     struct x11drv_thread_data *thread_data;
2089     struct x11drv_win_data *data;
2090     DWORD new_style = GetWindowLongW( hwnd, GWL_STYLE );
2091     RECT old_window_rect, old_whole_rect, old_client_rect;
2092     int event_type;
2093
2094     if (!(data = get_win_data( hwnd ))) return;
2095
2096     thread_data = x11drv_thread_data();
2097
2098     old_window_rect = data->window_rect;
2099     old_whole_rect  = data->whole_rect;
2100     old_client_rect = data->client_rect;
2101     data->window_rect = *rectWindow;
2102     data->whole_rect  = *visible_rect;
2103     data->client_rect = *rectClient;
2104     if (data->vis.visualid == default_visual.visualid)
2105     {
2106         if (surface) window_surface_add_ref( surface );
2107         if (data->surface) window_surface_release( data->surface );
2108         data->surface = surface;
2109     }
2110
2111     TRACE( "win %p window %s client %s style %08x flags %08x\n",
2112            hwnd, wine_dbgstr_rect(rectWindow), wine_dbgstr_rect(rectClient), new_style, swp_flags );
2113
2114     if (!IsRectEmpty( &valid_rects[0] ))
2115     {
2116         Window window = data->whole_window;
2117         int x_offset = old_whole_rect.left - data->whole_rect.left;
2118         int y_offset = old_whole_rect.top - data->whole_rect.top;
2119
2120         /* if all that happened is that the whole window moved, copy everything */
2121         if (!(swp_flags & SWP_FRAMECHANGED) &&
2122             old_whole_rect.right   - data->whole_rect.right   == x_offset &&
2123             old_whole_rect.bottom  - data->whole_rect.bottom  == y_offset &&
2124             old_client_rect.left   - data->client_rect.left   == x_offset &&
2125             old_client_rect.right  - data->client_rect.right  == x_offset &&
2126             old_client_rect.top    - data->client_rect.top    == y_offset &&
2127             old_client_rect.bottom - data->client_rect.bottom == y_offset &&
2128             !memcmp( &valid_rects[0], &data->client_rect, sizeof(RECT) ))
2129         {
2130             /* if we have an X window the bits will be moved by the X server */
2131             if (!window && (x_offset != 0 || y_offset != 0))
2132             {
2133                 release_win_data( data );
2134                 move_window_bits( hwnd, window, &old_whole_rect, visible_rect,
2135                                   &old_client_rect, rectClient, rectWindow );
2136                 if (!(data = get_win_data( hwnd ))) return;
2137             }
2138         }
2139         else
2140         {
2141             release_win_data( data );
2142             move_window_bits( hwnd, window, &valid_rects[1], &valid_rects[0],
2143                               &old_client_rect, rectClient, rectWindow );
2144             if (!(data = get_win_data( hwnd ))) return;
2145         }
2146     }
2147
2148     XFlush( gdi_display );  /* make sure painting is done before we move the window */
2149
2150     sync_gl_drawable( data->hwnd, visible_rect, rectClient );
2151
2152     if (!data->whole_window) goto done;
2153
2154     /* check if we are currently processing an event relevant to this window */
2155     event_type = 0;
2156     if (thread_data &&
2157         thread_data->current_event &&
2158         thread_data->current_event->xany.window == data->whole_window)
2159     {
2160         event_type = thread_data->current_event->type;
2161         if (event_type != ConfigureNotify && event_type != PropertyNotify &&
2162             event_type != GravityNotify && event_type != ReparentNotify)
2163             event_type = 0;  /* ignore other events */
2164     }
2165
2166     if (data->mapped && event_type != ReparentNotify)
2167     {
2168         if (((swp_flags & SWP_HIDEWINDOW) && !(new_style & WS_VISIBLE)) ||
2169             (!event_type && !(new_style & WS_MINIMIZE) &&
2170              !is_window_rect_mapped( rectWindow ) && is_window_rect_mapped( &old_window_rect )))
2171         {
2172             release_win_data( data );
2173             unmap_window( hwnd );
2174             if (is_window_rect_fullscreen( &old_window_rect )) reset_clipping_window();
2175             if (!(data = get_win_data( hwnd ))) return;
2176         }
2177     }
2178
2179     /* don't change position if we are about to minimize or maximize a managed window */
2180     if (!event_type &&
2181         !(data->managed && (swp_flags & SWP_STATECHANGED) && (new_style & (WS_MINIMIZE|WS_MAXIMIZE))))
2182         sync_window_position( data, swp_flags, &old_window_rect, &old_whole_rect, &old_client_rect );
2183
2184     if ((new_style & WS_VISIBLE) &&
2185         ((new_style & WS_MINIMIZE) || is_window_rect_mapped( rectWindow )))
2186     {
2187         if (!data->mapped)
2188         {
2189             BOOL needs_icon = !data->icon_pixmap;
2190
2191             release_win_data( data );
2192             if (needs_icon) fetch_icon_data( hwnd, 0, 0 );
2193             map_window( hwnd, new_style );
2194             return;
2195         }
2196         else if ((swp_flags & SWP_STATECHANGED) && (!data->iconic != !(new_style & WS_MINIMIZE)))
2197         {
2198             set_wm_hints( data );
2199             data->iconic = (new_style & WS_MINIMIZE) != 0;
2200             TRACE( "changing win %p iconic state to %u\n", data->hwnd, data->iconic );
2201             if (data->iconic)
2202                 XIconifyWindow( data->display, data->whole_window, data->vis.screen );
2203             else if (is_window_rect_mapped( rectWindow ))
2204                 XMapWindow( data->display, data->whole_window );
2205             update_net_wm_states( data );
2206         }
2207         else
2208         {
2209             if (swp_flags & (SWP_FRAMECHANGED|SWP_STATECHANGED)) set_wm_hints( data );
2210             if (!event_type) update_net_wm_states( data );
2211         }
2212     }
2213
2214     XFlush( data->display );  /* make sure changes are done before we start painting again */
2215     if (data->surface && data->vis.visualid != default_visual.visualid)
2216         data->surface->funcs->flush( data->surface );
2217
2218 done:
2219     release_win_data( data );
2220 }
2221
2222
2223 /***********************************************************************
2224  *           ShowWindow   (X11DRV.@)
2225  */
2226 UINT CDECL X11DRV_ShowWindow( HWND hwnd, INT cmd, RECT *rect, UINT swp )
2227 {
2228     int x, y;
2229     unsigned int width, height, border, depth;
2230     Window root, top;
2231     DWORD style = GetWindowLongW( hwnd, GWL_STYLE );
2232     struct x11drv_thread_data *thread_data = x11drv_thread_data();
2233     struct x11drv_win_data *data = get_win_data( hwnd );
2234
2235     if (!data || !data->whole_window || !data->managed) goto done;
2236     if (IsRectEmpty( rect )) goto done;
2237     if (style & WS_MINIMIZE)
2238     {
2239         if (rect->left != -32000 || rect->top != -32000)
2240         {
2241             OffsetRect( rect, -32000 - rect->left, -32000 - rect->top );
2242             swp &= ~(SWP_NOMOVE | SWP_NOCLIENTMOVE);
2243         }
2244         goto done;
2245     }
2246     if (!data->mapped || data->iconic) goto done;
2247
2248     /* only fetch the new rectangle if the ShowWindow was a result of a window manager event */
2249
2250     if (!thread_data->current_event || thread_data->current_event->xany.window != data->whole_window)
2251         goto done;
2252
2253     if (thread_data->current_event->type != ConfigureNotify &&
2254         thread_data->current_event->type != PropertyNotify)
2255         goto done;
2256
2257     TRACE( "win %p/%lx cmd %d at %s flags %08x\n",
2258            hwnd, data->whole_window, cmd, wine_dbgstr_rect(rect), swp );
2259
2260     XGetGeometry( thread_data->display, data->whole_window,
2261                   &root, &x, &y, &width, &height, &border, &depth );
2262     XTranslateCoordinates( thread_data->display, data->whole_window, root, 0, 0, &x, &y, &top );
2263     rect->left   = x;
2264     rect->top    = y;
2265     rect->right  = x + width;
2266     rect->bottom = y + height;
2267     OffsetRect( rect, virtual_screen_rect.left, virtual_screen_rect.top );
2268     X11DRV_X_to_window_rect( data, rect );
2269     swp &= ~(SWP_NOMOVE | SWP_NOCLIENTMOVE | SWP_NOSIZE | SWP_NOCLIENTSIZE);
2270
2271 done:
2272     release_win_data( data );
2273     return swp;
2274 }
2275
2276
2277 /**********************************************************************
2278  *              SetWindowIcon (X11DRV.@)
2279  *
2280  * hIcon or hIconSm has changed (or is being initialised for the
2281  * first time). Complete the X11 driver-specific initialisation
2282  * and set the window hints.
2283  */
2284 void CDECL X11DRV_SetWindowIcon( HWND hwnd, UINT type, HICON icon )
2285 {
2286     struct x11drv_win_data *data;
2287
2288     if (!(data = get_win_data( hwnd ))) return;
2289     if (!data->whole_window) goto done;
2290     release_win_data( data );  /* release the lock, fetching the icon requires sending messages */
2291
2292     if (type == ICON_BIG) fetch_icon_data( hwnd, icon, 0 );
2293     else fetch_icon_data( hwnd, 0, icon );
2294
2295     if (!(data = get_win_data( hwnd ))) return;
2296     set_wm_hints( data );
2297 done:
2298     release_win_data( data );
2299 }
2300
2301
2302 /***********************************************************************
2303  *              SetWindowRgn  (X11DRV.@)
2304  *
2305  * Assign specified region to window (for non-rectangular windows)
2306  */
2307 int CDECL X11DRV_SetWindowRgn( HWND hwnd, HRGN hrgn, BOOL redraw )
2308 {
2309     struct x11drv_win_data *data;
2310
2311     if ((data = get_win_data( hwnd )))
2312     {
2313         sync_window_region( data, hrgn );
2314         release_win_data( data );
2315     }
2316     else if (X11DRV_get_whole_window( hwnd ))
2317     {
2318         SendMessageW( hwnd, WM_X11DRV_SET_WIN_REGION, 0, 0 );
2319     }
2320     return TRUE;
2321 }
2322
2323
2324 /***********************************************************************
2325  *              SetLayeredWindowAttributes  (X11DRV.@)
2326  *
2327  * Set transparency attributes for a layered window.
2328  */
2329 void CDECL X11DRV_SetLayeredWindowAttributes( HWND hwnd, COLORREF key, BYTE alpha, DWORD flags )
2330 {
2331     struct x11drv_win_data *data = get_win_data( hwnd );
2332
2333     if (data)
2334     {
2335         if (data->whole_window)
2336             sync_window_opacity( data->display, data->whole_window, key, alpha, flags );
2337         if (data->surface)
2338             set_surface_color_key( data->surface, (flags & LWA_COLORKEY) ? key : CLR_INVALID );
2339         release_win_data( data );
2340     }
2341     else
2342     {
2343         Window win = X11DRV_get_whole_window( hwnd );
2344         if (win)
2345         {
2346             sync_window_opacity( gdi_display, win, key, alpha, flags );
2347             if (flags & LWA_COLORKEY)
2348                 FIXME( "LWA_COLORKEY not supported on foreign process window %p\n", hwnd );
2349         }
2350     }
2351 }
2352
2353
2354 /*****************************************************************************
2355  *              UpdateLayeredWindow  (X11DRV.@)
2356  */
2357 BOOL CDECL X11DRV_UpdateLayeredWindow( HWND hwnd, const UPDATELAYEREDWINDOWINFO *info,
2358                                        const RECT *window_rect )
2359 {
2360     struct window_surface *surface;
2361     struct x11drv_win_data *data;
2362     BLENDFUNCTION blend = { AC_SRC_OVER, 0, 255, 0 };
2363     COLORREF color_key = (info->dwFlags & ULW_COLORKEY) ? info->crKey : CLR_INVALID;
2364     char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
2365     BITMAPINFO *bmi = (BITMAPINFO *)buffer;
2366     void *src_bits, *dst_bits;
2367     RECT rect;
2368     HDC hdc = 0;
2369     HBITMAP dib;
2370     BOOL ret = FALSE;
2371
2372     if (!(data = get_win_data( hwnd ))) return FALSE;
2373
2374     if (!data->embedded && argb_visual.visualid) set_window_visual( data, &argb_visual );
2375
2376     rect = *window_rect;
2377     OffsetRect( &rect, -window_rect->left, -window_rect->top );
2378
2379     surface = data->surface;
2380     if (!surface || memcmp( &surface->rect, &rect, sizeof(RECT) ))
2381     {
2382         data->surface = create_surface( data->whole_window, &data->vis, &rect,
2383                                         color_key, !data->embedded );
2384         if (surface) window_surface_release( surface );
2385         surface = data->surface;
2386     }
2387     else set_surface_color_key( surface, color_key );
2388
2389     if (surface) window_surface_add_ref( surface );
2390     release_win_data( data );
2391
2392     if (!surface) return FALSE;
2393     if (!info->hdcSrc)
2394     {
2395         window_surface_release( surface );
2396         return TRUE;
2397     }
2398
2399     dst_bits = surface->funcs->get_info( surface, bmi );
2400
2401     if (!(dib = CreateDIBSection( info->hdcDst, bmi, DIB_RGB_COLORS, &src_bits, NULL, 0 ))) goto done;
2402     if (!(hdc = CreateCompatibleDC( 0 ))) goto done;
2403
2404     SelectObject( hdc, dib );
2405
2406     surface->funcs->lock( surface );
2407
2408     if (info->prcDirty)
2409     {
2410         IntersectRect( &rect, &rect, info->prcDirty );
2411         memcpy( src_bits, dst_bits, bmi->bmiHeader.biSizeImage );
2412         PatBlt( hdc, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, BLACKNESS );
2413     }
2414     ret = GdiAlphaBlend( hdc, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
2415                          info->hdcSrc,
2416                          rect.left + (info->pptSrc ? info->pptSrc->x : 0),
2417                          rect.top + (info->pptSrc ? info->pptSrc->y : 0),
2418                          rect.right - rect.left, rect.bottom - rect.top,
2419                          (info->dwFlags & ULW_ALPHA) ? *info->pblend : blend );
2420     if (ret)
2421     {
2422         memcpy( dst_bits, src_bits, bmi->bmiHeader.biSizeImage );
2423         add_bounds_rect( surface->funcs->get_bounds( surface ), &rect );
2424     }
2425
2426     surface->funcs->unlock( surface );
2427     surface->funcs->flush( surface );
2428
2429 done:
2430     window_surface_release( surface );
2431     if (hdc) DeleteDC( hdc );
2432     if (dib) DeleteObject( dib );
2433     return ret;
2434 }
2435
2436
2437 /**********************************************************************
2438  *           X11DRV_WindowMessage   (X11DRV.@)
2439  */
2440 LRESULT CDECL X11DRV_WindowMessage( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
2441 {
2442     struct x11drv_win_data *data;
2443
2444     switch(msg)
2445     {
2446     case WM_X11DRV_ACQUIRE_SELECTION:
2447         return X11DRV_AcquireClipboard( hwnd );
2448     case WM_X11DRV_SET_WIN_REGION:
2449         if ((data = get_win_data( hwnd )))
2450         {
2451             sync_window_region( data, (HRGN)1 );
2452             release_win_data( data );
2453         }
2454         return 0;
2455     case WM_X11DRV_RESIZE_DESKTOP:
2456         X11DRV_resize_desktop( LOWORD(lp), HIWORD(lp) );
2457         return 0;
2458     case WM_X11DRV_SET_CURSOR:
2459         if ((data = get_win_data( hwnd )))
2460         {
2461             if (data->whole_window) set_window_cursor( data->whole_window, (HCURSOR)lp );
2462             release_win_data( data );
2463         }
2464         else if (hwnd == x11drv_thread_data()->clip_hwnd)
2465             set_window_cursor( x11drv_thread_data()->clip_window, (HCURSOR)lp );
2466         return 0;
2467     case WM_X11DRV_CLIP_CURSOR:
2468         return clip_cursor_notify( hwnd, (HWND)lp );
2469     default:
2470         FIXME( "got window msg %x hwnd %p wp %lx lp %lx\n", msg, hwnd, wp, lp );
2471         return 0;
2472     }
2473 }
2474
2475
2476 /***********************************************************************
2477  *              is_netwm_supported
2478  */
2479 static BOOL is_netwm_supported( Display *display, Atom atom )
2480 {
2481     static Atom *net_supported;
2482     static int net_supported_count = -1;
2483     int i;
2484
2485     if (net_supported_count == -1)
2486     {
2487         Atom type;
2488         int format;
2489         unsigned long count, remaining;
2490
2491         if (!XGetWindowProperty( display, DefaultRootWindow(display), x11drv_atom(_NET_SUPPORTED), 0,
2492                                  ~0UL, False, XA_ATOM, &type, &format, &count,
2493                                  &remaining, (unsigned char **)&net_supported ))
2494             net_supported_count = get_property_size( format, count ) / sizeof(Atom);
2495         else
2496             net_supported_count = 0;
2497     }
2498
2499     for (i = 0; i < net_supported_count; i++)
2500         if (net_supported[i] == atom) return TRUE;
2501     return FALSE;
2502 }
2503
2504
2505 /***********************************************************************
2506  *           SysCommand   (X11DRV.@)
2507  *
2508  * Perform WM_SYSCOMMAND handling.
2509  */
2510 LRESULT CDECL X11DRV_SysCommand( HWND hwnd, WPARAM wparam, LPARAM lparam )
2511 {
2512     WPARAM hittest = wparam & 0x0f;
2513     int dir;
2514     struct x11drv_win_data *data;
2515
2516     if (!(data = get_win_data( hwnd ))) return -1;
2517     if (!data->whole_window || !data->managed || !data->mapped) goto failed;
2518
2519     switch (wparam & 0xfff0)
2520     {
2521     case SC_MOVE:
2522         if (!hittest) dir = _NET_WM_MOVERESIZE_MOVE_KEYBOARD;
2523         else dir = _NET_WM_MOVERESIZE_MOVE;
2524         break;
2525     case SC_SIZE:
2526         /* windows without WS_THICKFRAME are not resizable through the window manager */
2527         if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_THICKFRAME)) goto failed;
2528
2529         switch (hittest)
2530         {
2531         case WMSZ_LEFT:        dir = _NET_WM_MOVERESIZE_SIZE_LEFT; break;
2532         case WMSZ_RIGHT:       dir = _NET_WM_MOVERESIZE_SIZE_RIGHT; break;
2533         case WMSZ_TOP:         dir = _NET_WM_MOVERESIZE_SIZE_TOP; break;
2534         case WMSZ_TOPLEFT:     dir = _NET_WM_MOVERESIZE_SIZE_TOPLEFT; break;
2535         case WMSZ_TOPRIGHT:    dir = _NET_WM_MOVERESIZE_SIZE_TOPRIGHT; break;
2536         case WMSZ_BOTTOM:      dir = _NET_WM_MOVERESIZE_SIZE_BOTTOM; break;
2537         case WMSZ_BOTTOMLEFT:  dir = _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT; break;
2538         case WMSZ_BOTTOMRIGHT: dir = _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT; break;
2539         default:               dir = _NET_WM_MOVERESIZE_SIZE_KEYBOARD; break;
2540         }
2541         break;
2542
2543     case SC_KEYMENU:
2544         /* prevent a simple ALT press+release from activating the system menu,
2545          * as that can get confusing on managed windows */
2546         if ((WCHAR)lparam) goto failed;  /* got an explicit char */
2547         if (GetMenu( hwnd )) goto failed;  /* window has a real menu */
2548         if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_SYSMENU)) goto failed;  /* no system menu */
2549         TRACE( "ignoring SC_KEYMENU wp %lx lp %lx\n", wparam, lparam );
2550         release_win_data( data );
2551         return 0;
2552
2553     default:
2554         goto failed;
2555     }
2556
2557     if (IsZoomed(hwnd)) goto failed;
2558
2559     if (!is_netwm_supported( data->display, x11drv_atom(_NET_WM_MOVERESIZE) ))
2560     {
2561         TRACE( "_NET_WM_MOVERESIZE not supported\n" );
2562         goto failed;
2563     }
2564
2565     release_win_data( data );
2566     move_resize_window( hwnd, dir );
2567     return 0;
2568
2569 failed:
2570     release_win_data( data );
2571     return -1;
2572 }