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