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