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