wine/dlls/winex11.drv/window.c

Version: ~ [ wine-1.5.30 ] ~ [ wine-1.5.29 ] ~ [ wine-1.5.28 ] ~ [ wine-1.5.27 ] ~ [ wine-1.5.26 ] ~ [ wine-1.5.25 ] ~ [ wine-1.5.24 ] ~ [ wine-1.5.23 ] ~ [ wine-1.5.22 ] ~ [ wine-1.5.21 ] ~ [ wine-1.5.20 ] ~ [ wine-1.5.19 ] ~ [ wine-1.5.18 ] ~ [ wine-1.5.17 ] ~ [ wine-1.5.16 ] ~ [ wine-1.5.15 ] ~ [ wine-1.5.14 ] ~ [ wine-1.5.13 ] ~ [ wine-1.5.12 ] ~ [ wine-1.5.11 ] ~ [ wine-1.5.10 ] ~ [ wine-1.5.9 ] ~ [ wine-1.5.8 ] ~ [ wine-1.5.7 ] ~ [ wine-1.4.1 ] ~ [ wine-1.5.6 ] ~ [ wine-1.5.5 ] ~ [ wine-1.5.4 ] ~ [ wine-1.5.3 ] ~ [ wine-1.5.2 ] ~ [ wine-1.5.1 ] ~ [ wine-1.5.0 ] ~ [ wine-1.4 ] ~ [ wine-1.4-rc6 ] ~ [ wine-1.4-rc5 ] ~ [ wine-1.4-rc4 ] ~ [ wine-1.4-rc3 ] ~ [ wine-1.4-rc2 ] ~ [ wine-1.4-rc1 ] ~ [ wine-1.3.37 ] ~ [ wine-1.3.36 ] ~ [ wine-1.3.35 ] ~ [ wine-1.3.34 ] ~ [ wine-1.3.33 ] ~ [ wine-1.3.32 ] ~ [ wine-1.3.31 ] ~ [ wine-1.3.30 ] ~ [ wine-1.3.29 ] ~ [ wine-1.3.28 ] ~ [ wine-1.3.27 ] ~ [ wine-1.3.26 ] ~ [ wine-1.3.25 ] ~ [ wine-1.3.24 ] ~ [ wine-1.3.23 ] ~ [ wine-1.3.22 ] ~ [ wine-1.3.21 ] ~ [ wine-1.3.20 ] ~ [ wine-1.3.19 ] ~ [ wine-1.3.18 ] ~ [ wine-1.2.3 ] ~ [ wine-1.3.17 ] ~ [ wine-1.3.16 ] ~ [ wine-1.3.15 ] ~ [ wine-1.3.14 ] ~ [ wine-1.3.13 ] ~ [ wine-1.3.12 ] ~ [ wine-1.3.11 ] ~ [ wine-1.3.10 ] ~ [ wine-1.3.9 ] ~ [ wine-1.2.2 ] ~ [ wine-1.3.8 ] ~ [ wine-1.3.7 ] ~ [ wine-1.3.6 ] ~ [ wine-1.3.5 ] ~ [ wine-1.2.1 ] ~ [ wine-1.3.4 ] ~ [ wine-1.3.3 ] ~ [ wine-1.3.2 ] ~ [ wine-1.3.1 ] ~ [ wine-1.3.0 ] ~ [ wine-1.2 ] ~ [ wine-1.2-rc7 ] ~ [ wine-1.2-rc6 ] ~ [ wine-1.2-rc5 ] ~ [ wine-1.2-rc4 ] ~ [ wine-1.2-rc3 ] ~ [ wine-1.2-rc2 ] ~ [ wine-1.2-rc1 ] ~ [ wine-1.1.44 ] ~ [ wine-1.1.43 ] ~ [ wine-1.1.42 ] ~ [ wine-1.1.41 ] ~ [ wine-1.1.40 ] ~ [ wine-1.1.39 ] ~ [ wine-1.1.38 ] ~ [ wine-1.1.37 ] ~ [ wine-1.1.36 ] ~ [ wine-1.1.35 ] ~ [ wine-1.1.34 ] ~ [ wine-1.1.33 ] ~ [ wine-1.1.32 ] ~ [ wine-1.1.31 ] ~ [ wine-1.1.30 ] ~ [ wine-1.1.29 ] ~ [ wine-1.1.28 ] ~ [ wine-1.1.27 ] ~ [ wine-1.1.26 ] ~ [ wine-1.1.25 ] ~ [ wine-1.1.24 ] ~ [ wine-1.1.23 ] ~ [ wine-1.1.22 ] ~ [ wine-1.1.21 ] ~ [ wine-1.1.20 ] ~ [ wine-1.1.19 ] ~ [ wine-1.1.18 ] ~ [ wine-1.1.17 ] ~ [ wine-1.1.16 ] ~ [ wine-1.1.15 ] ~ [ wine-1.1.14 ] ~ [ wine-1.1.13 ] ~ [ wine-1.1.12 ] ~ [ wine-1.1.11 ] ~ [ wine-1.1.10 ] ~ [ wine-1.1.9 ] ~ [ wine-1.1.8 ] ~ [ wine-1.1.7 ] ~ [ wine-1.0.1 ] ~ [ wine-1.1.6 ] ~ [ wine-1.1.5 ] ~ [ wine-1.1.4 ] ~ [ wine-1.1.3 ] ~ [ wine-1.1.2 ] ~ [ wine-1.1.1 ] ~ [ wine-1.1.0 ] ~ [ wine-1.0 ] ~

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

Wine Cross Reference wine/dlls/winex11.drv/window.c

Wine Cross Reference
wine/dlls/winex11.drv/window.c