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