?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dmime: Use the generic IPersistStream for DMParamControlTrack.
[wine.git] / dlls / winex11.drv / window.c
blob50c32906d58c1937d3829709f81fc6af2f37c460
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) - 2; 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 = X11DRV_get_whole_window( owner );
752 XWMHints *wm_hints;
753 Atom window_type;
754
755 if (owner_win)
756 {
757 XSetTransientForHint( data->display, data->whole_window, owner_win );
758 group_leader = owner_win;
759 }
760
761 /* Only use dialog type for owned popups. Metacity allows making fullscreen
762 * only normal windows, and doesn't handle correctly TRANSIENT_FOR hint for
763 * dialogs owned by fullscreen windows.
764 */
765 if (((style & WS_POPUP) || (ex_style & WS_EX_DLGMODALFRAME)) && owner)
766 window_type = x11drv_atom(_NET_WM_WINDOW_TYPE_DIALOG);
767 else
768 window_type = x11drv_atom(_NET_WM_WINDOW_TYPE_NORMAL);
769
770 XChangeProperty(data->display, data->whole_window, x11drv_atom(_NET_WM_WINDOW_TYPE),
771 XA_ATOM, 32, PropModeReplace, (unsigned char*)&window_type, 1);
772
773 if ((wm_hints = XAllocWMHints()))
774 {
775 wm_hints->flags = InputHint | StateHint | WindowGroupHint;
776 wm_hints->input = !use_take_focus && !(style & WS_DISABLED);
777 wm_hints->initial_state = (style & WS_MINIMIZE) ? IconicState : NormalState;
778 wm_hints->window_group = group_leader;
779 if (data->icon_pixmap)
780 {
781 wm_hints->icon_pixmap = data->icon_pixmap;
782 wm_hints->icon_mask = data->icon_mask;
783 wm_hints->flags |= IconPixmapHint | IconMaskHint;
784 }
785 XSetWMHints( data->display, data->whole_window, wm_hints );
786 XFree( wm_hints );
787 }
788
789 if (data->icon_bits)
790 XChangeProperty( data->display, data->whole_window, x11drv_atom(_NET_WM_ICON),
791 XA_CARDINAL, 32, PropModeReplace,
792 (unsigned char *)data->icon_bits, data->icon_size );
793 else
794 XDeleteProperty( data->display, data->whole_window, x11drv_atom(_NET_WM_ICON) );
795
796 }
797
798
799 /***********************************************************************
800 * get_process_name
801 *
802 * get the name of the current process for setting class hints
803 */
804 static char *get_process_name(void)
805 {
806 static char *name;
807
808 if (!name)
809 {
810 WCHAR module[MAX_PATH];
811 DWORD len = GetModuleFileNameW( 0, module, MAX_PATH );
812 if (len && len < MAX_PATH)
813 {
814 char *ptr;
815 WCHAR *p, *appname = module;
816
817 if ((p = strrchrW( appname, '/' ))) appname = p + 1;
818 if ((p = strrchrW( appname, '\\' ))) appname = p + 1;
819 len = WideCharToMultiByte( CP_UNIXCP, 0, appname, -1, NULL, 0, NULL, NULL );
820 if ((ptr = HeapAlloc( GetProcessHeap(), 0, len )))
821 {
822 WideCharToMultiByte( CP_UNIXCP, 0, appname, -1, ptr, len, NULL, NULL );
823 name = ptr;
824 }
825 }
826 }
827 return name;
828 }
829
830
831 /***********************************************************************
832 * set_initial_wm_hints
833 *
834 * Set the window manager hints that don't change over the lifetime of a window.
835 */
836 static void set_initial_wm_hints( Display *display, Window window )
837 {
838 long i;
839 Atom protocols[3];
840 Atom dndVersion = WINE_XDND_VERSION;
841 XClassHint *class_hints;
842 char *process_name = get_process_name();
843
844 /* wm protocols */
845 i = 0;
846 protocols[i++] = x11drv_atom(WM_DELETE_WINDOW);
847 protocols[i++] = x11drv_atom(_NET_WM_PING);
848 if (use_take_focus) protocols[i++] = x11drv_atom(WM_TAKE_FOCUS);
849 XChangeProperty( display, window, x11drv_atom(WM_PROTOCOLS),
850 XA_ATOM, 32, PropModeReplace, (unsigned char *)protocols, i );
851
852 /* class hints */
853 if ((class_hints = XAllocClassHint()))
854 {
855 static char wine[] = "Wine";
856
857 class_hints->res_name = process_name;
858 class_hints->res_class = wine;
859 XSetClassHint( display, window, class_hints );
860 XFree( class_hints );
861 }
862
863 /* set the WM_CLIENT_MACHINE and WM_LOCALE_NAME properties */
864 XSetWMProperties(display, window, NULL, NULL, NULL, 0, NULL, NULL, NULL);
865 /* set the pid. together, these properties are needed so the window manager can kill us if we freeze */
866 i = getpid();
867 XChangeProperty(display, window, x11drv_atom(_NET_WM_PID),
868 XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&i, 1);
869
870 XChangeProperty( display, window, x11drv_atom(XdndAware),
871 XA_ATOM, 32, PropModeReplace, (unsigned char*)&dndVersion, 1 );
872
873 update_user_time( 0 ); /* make sure that the user time window exists */
874 if (user_time_window)
875 XChangeProperty( display, window, x11drv_atom(_NET_WM_USER_TIME_WINDOW),
876 XA_WINDOW, 32, PropModeReplace, (unsigned char *)&user_time_window, 1 );
877 }
878
879
880 /***********************************************************************
881 * make_owner_managed
882 *
883 * If the window is managed, make sure its owner window is too.
884 */
885 static void make_owner_managed( HWND hwnd )
886 {
887 HWND owner;
888
889 if (!(owner = GetWindow( hwnd, GW_OWNER ))) return;
890 if (is_managed( owner )) return;
891 if (!is_managed( hwnd )) return;
892
893 SetWindowPos( owner, 0, 0, 0, 0, 0,
894 SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSIZE | SWP_NOMOVE |
895 SWP_NOREDRAW | SWP_DEFERERASE | SWP_NOSENDCHANGING | SWP_STATECHANGED );
896 }
897
898
899 /***********************************************************************
900 * set_wm_hints
901 *
902 * Set all the window manager hints for a window.
903 */
904 static void set_wm_hints( struct x11drv_win_data *data )
905 {
906 DWORD style, ex_style;
907
908 if (data->hwnd == GetDesktopWindow())
909 {
910 /* force some styles for the desktop to get the correct decorations */
911 style = WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
912 ex_style = WS_EX_APPWINDOW;
913 }
914 else
915 {
916 style = GetWindowLongW( data->hwnd, GWL_STYLE );
917 ex_style = GetWindowLongW( data->hwnd, GWL_EXSTYLE );
918 }
919
920 set_size_hints( data, style );
921 set_mwm_hints( data, style, ex_style );
922 set_style_hints( data, style, ex_style );
923 }
924
925
926 /***********************************************************************
927 * init_clip_window
928 */
929 Window init_clip_window(void)
930 {
931 struct x11drv_thread_data *data = x11drv_init_thread_data();
932
933 if (!data->clip_window &&
934 (data->clip_window = (Window)GetPropA( GetDesktopWindow(), clip_window_prop )))
935 {
936 XSelectInput( data->display, data->clip_window, StructureNotifyMask );
937 }
938 return data->clip_window;
939 }
940
941
942 /***********************************************************************
943 * update_user_time
944 */
945 void update_user_time( Time time )
946 {
947 if (!user_time_window)
948 {
949 Window win = XCreateWindow( gdi_display, root_window, -1, -1, 1, 1, 0, CopyFromParent,
950 InputOnly, CopyFromParent, 0, NULL );
951 if (InterlockedCompareExchangePointer( (void **)&user_time_window, (void *)win, 0 ))
952 XDestroyWindow( gdi_display, win );
953 TRACE( "user time window %lx\n", user_time_window );
954 }
955
956 if (!time) return;
957 XLockDisplay( gdi_display );
958 if (!last_user_time || (long)(time - last_user_time) > 0)
959 {
960 last_user_time = time;
961 XChangeProperty( gdi_display, user_time_window, x11drv_atom(_NET_WM_USER_TIME),
962 XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&time, 1 );
963 }
964 XUnlockDisplay( gdi_display );
965 }
966
967 /***********************************************************************
968 * update_net_wm_states
969 */
970 void update_net_wm_states( struct x11drv_win_data *data )
971 {
972 DWORD i, style, ex_style, new_state = 0;
973
974 if (!data->managed) return;
975 if (data->whole_window == root_window) return;
976
977 style = GetWindowLongW( data->hwnd, GWL_STYLE );
978 if (style & WS_MINIMIZE)
979 new_state |= data->net_wm_state & (1 << NET_WM_STATE_FULLSCREEN);
980 if (is_window_rect_fullscreen( &data->whole_rect ))
981 {
982 if ((style & WS_MAXIMIZE) && (style & WS_CAPTION) == WS_CAPTION)
983 new_state |= (1 << NET_WM_STATE_MAXIMIZED);
984 else if (!(style & WS_MINIMIZE))
985 new_state |= (1 << NET_WM_STATE_FULLSCREEN);
986 }
987 else if (style & WS_MAXIMIZE)
988 new_state |= (1 << NET_WM_STATE_MAXIMIZED);
989
990 ex_style = GetWindowLongW( data->hwnd, GWL_EXSTYLE );
991 if (ex_style & WS_EX_TOPMOST)
992 new_state |= (1 << NET_WM_STATE_ABOVE);
993 if (ex_style & (WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE))
994 new_state |= (1 << NET_WM_STATE_SKIP_TASKBAR) | (1 << NET_WM_STATE_SKIP_PAGER);
995 if (!(ex_style & WS_EX_APPWINDOW) && GetWindow( data->hwnd, GW_OWNER ))
996 new_state |= (1 << NET_WM_STATE_SKIP_TASKBAR);
997
998 if (!data->mapped) /* set the _NET_WM_STATE atom directly */
999 {
1000 Atom atoms[NB_NET_WM_STATES+1];
1001 DWORD count;
1002
1003 for (i = count = 0; i < NB_NET_WM_STATES; i++)
1004 {
1005 if (!(new_state & (1 << i))) continue;
1006 TRACE( "setting wm state %u for unmapped window %p/%lx\n",
1007 i, data->hwnd, data->whole_window );
1008 atoms[count++] = X11DRV_Atoms[net_wm_state_atoms[i] - FIRST_XATOM];
1009 if (net_wm_state_atoms[i] == XATOM__NET_WM_STATE_MAXIMIZED_VERT)
1010 atoms[count++] = x11drv_atom(_NET_WM_STATE_MAXIMIZED_HORZ);
1011 }
1012 XChangeProperty( data->display, data->whole_window, x11drv_atom(_NET_WM_STATE), XA_ATOM,
1013 32, PropModeReplace, (unsigned char *)atoms, count );
1014 }
1015 else /* ask the window manager to do it for us */
1016 {
1017 XEvent xev;
1018
1019 xev.xclient.type = ClientMessage;
1020 xev.xclient.window = data->whole_window;
1021 xev.xclient.message_type = x11drv_atom(_NET_WM_STATE);
1022 xev.xclient.serial = 0;
1023 xev.xclient.display = data->display;
1024 xev.xclient.send_event = True;
1025 xev.xclient.format = 32;
1026 xev.xclient.data.l[3] = 1;
1027
1028 for (i = 0; i < NB_NET_WM_STATES; i++)
1029 {
1030 if (!((data->net_wm_state ^ new_state) & (1 << i))) continue; /* unchanged */
1031
1032 TRACE( "setting wm state %u for window %p/%lx to %u prev %u\n",
1033 i, data->hwnd, data->whole_window,
1034 (new_state & (1 << i)) != 0, (data->net_wm_state & (1 << i)) != 0 );
1035
1036 xev.xclient.data.l[0] = (new_state & (1 << i)) ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
1037 xev.xclient.data.l[1] = X11DRV_Atoms[net_wm_state_atoms[i] - FIRST_XATOM];
1038 xev.xclient.data.l[2] = ((net_wm_state_atoms[i] == XATOM__NET_WM_STATE_MAXIMIZED_VERT) ?
1039 x11drv_atom(_NET_WM_STATE_MAXIMIZED_HORZ) : 0);
1040 XSendEvent( data->display, root_window, False,
1041 SubstructureRedirectMask | SubstructureNotifyMask, &xev );
1042 }
1043 }
1044 data->net_wm_state = new_state;
1045 }
1046
1047 /***********************************************************************
1048 * read_net_wm_states
1049 */
1050 void read_net_wm_states( Display* display, struct x11drv_win_data *data )
1051 {
1052 Atom type, *state;
1053 int format;
1054 unsigned long i, j, count, remaining;
1055 DWORD new_state = 0;
1056 BOOL maximized_horz = FALSE;
1057
1058 if (!data->whole_window) return;
1059
1060 if (!XGetWindowProperty( display, data->whole_window, x11drv_atom(_NET_WM_STATE), 0,
1061 65536/sizeof(CARD32), False, XA_ATOM, &type, &format, &count,
1062 &remaining, (unsigned char **)&state ))
1063 {
1064 if (type == XA_ATOM && format == 32)
1065 {
1066 for (i = 0; i < count; i++)
1067 {
1068 if (state[i] == x11drv_atom(_NET_WM_STATE_MAXIMIZED_HORZ))
1069 maximized_horz = TRUE;
1070 for (j=0; j < NB_NET_WM_STATES; j++)
1071 {
1072 if (state[i] == X11DRV_Atoms[net_wm_state_atoms[j] - FIRST_XATOM])
1073 {
1074 new_state |= 1 << j;
1075 }
1076 }
1077 }
1078 }
1079 XFree( state );
1080 }
1081
1082 if (!maximized_horz)
1083 new_state &= ~(1 << NET_WM_STATE_MAXIMIZED);
1084
1085 data->net_wm_state = new_state;
1086 }
1087
1088
1089 /***********************************************************************
1090 * set_xembed_flags
1091 */
1092 static void set_xembed_flags( struct x11drv_win_data *data, unsigned long flags )
1093 {
1094 unsigned long info[2];
1095
1096 if (!data->whole_window) return;
1097
1098 info[0] = 0; /* protocol version */
1099 info[1] = flags;
1100 XChangeProperty( data->display, data->whole_window, x11drv_atom(_XEMBED_INFO),
1101 x11drv_atom(_XEMBED_INFO), 32, PropModeReplace, (unsigned char*)info, 2 );
1102 }
1103
1104
1105 /***********************************************************************
1106 * map_window
1107 */
1108 static void map_window( HWND hwnd, DWORD new_style )
1109 {
1110 struct x11drv_win_data *data;
1111
1112 make_owner_managed( hwnd );
1113 wait_for_withdrawn_state( hwnd, TRUE );
1114
1115 if (!(data = get_win_data( hwnd ))) return;
1116
1117 if (data->whole_window && !data->mapped)
1118 {
1119 TRACE( "win %p/%lx\n", data->hwnd, data->whole_window );
1120
1121 remove_startup_notification( data->display, data->whole_window );
1122 set_wm_hints( data );
1123
1124 if (!data->embedded)
1125 {
1126 update_net_wm_states( data );
1127 sync_window_style( data );
1128 XMapWindow( data->display, data->whole_window );
1129 XFlush( data->display );
1130 if (data->surface && data->vis.visualid != default_visual.visualid)
1131 data->surface->funcs->flush( data->surface );
1132 }
1133 else set_xembed_flags( data, XEMBED_MAPPED );
1134
1135 data->mapped = TRUE;
1136 data->iconic = (new_style & WS_MINIMIZE) != 0;
1137 }
1138 release_win_data( data );
1139 }
1140
1141
1142 /***********************************************************************
1143 * unmap_window
1144 */
1145 static void unmap_window( HWND hwnd )
1146 {
1147 struct x11drv_win_data *data;
1148
1149 wait_for_withdrawn_state( hwnd, FALSE );
1150
1151 if (!(data = get_win_data( hwnd ))) return;
1152
1153 if (data->mapped)
1154 {
1155 TRACE( "win %p/%lx\n", data->hwnd, data->whole_window );
1156
1157 if (data->embedded) set_xembed_flags( data, 0 );
1158 else if (!data->managed) XUnmapWindow( data->display, data->whole_window );
1159 else XWithdrawWindow( data->display, data->whole_window, data->vis.screen );
1160
1161 data->mapped = FALSE;
1162 data->net_wm_state = 0;
1163 }
1164 release_win_data( data );
1165 }
1166
1167
1168 /***********************************************************************
1169 * make_window_embedded
1170 */
1171 void make_window_embedded( struct x11drv_win_data *data )
1172 {
1173 /* the window cannot be mapped before being embedded */
1174 if (data->mapped)
1175 {
1176 if (data->managed) XUnmapWindow( data->display, data->whole_window );
1177 else XWithdrawWindow( data->display, data->whole_window, data->vis.screen );
1178 data->net_wm_state = 0;
1179 }
1180 data->embedded = TRUE;
1181 data->managed = TRUE;
1182 sync_window_style( data );
1183 set_xembed_flags( data, (data->mapped || data->embedder) ? XEMBED_MAPPED : 0 );
1184 }
1185
1186
1187 /***********************************************************************
1188 * X11DRV_window_to_X_rect
1189 *
1190 * Convert a rect from client to X window coordinates
1191 */
1192 static void X11DRV_window_to_X_rect( struct x11drv_win_data *data, RECT *rect )
1193 {
1194 RECT rc;
1195
1196 if (!data->managed) return;
1197 if (IsRectEmpty( rect )) return;
1198
1199 get_x11_rect_offset( data, &rc );
1200
1201 rect->left -= rc.left;
1202 rect->right -= rc.right;
1203 rect->top -= rc.top;
1204 rect->bottom -= rc.bottom;
1205 if (rect->top >= rect->bottom) rect->bottom = rect->top + 1;
1206 if (rect->left >= rect->right) rect->right = rect->left + 1;
1207 }
1208
1209
1210 /***********************************************************************
1211 * X11DRV_X_to_window_rect
1212 *
1213 * Opposite of X11DRV_window_to_X_rect
1214 */
1215 void X11DRV_X_to_window_rect( struct x11drv_win_data *data, RECT *rect )
1216 {
1217 RECT rc;
1218
1219 if (!data->managed) return;
1220 if (IsRectEmpty( rect )) return;
1221
1222 get_x11_rect_offset( data, &rc );
1223
1224 rect->left += rc.left;
1225 rect->right += rc.right;
1226 rect->top += rc.top;
1227 rect->bottom += rc.bottom;
1228 if (rect->top >= rect->bottom) rect->bottom = rect->top + 1;
1229 if (rect->left >= rect->right) rect->right = rect->left + 1;
1230 }
1231
1232
1233 /***********************************************************************
1234 * sync_window_position
1235 *
1236 * Synchronize the X window position with the Windows one
1237 */
1238 static void sync_window_position( struct x11drv_win_data *data,
1239 UINT swp_flags, const RECT *old_window_rect,
1240 const RECT *old_whole_rect, const RECT *old_client_rect )
1241 {
1242 DWORD style = GetWindowLongW( data->hwnd, GWL_STYLE );
1243 DWORD ex_style = GetWindowLongW( data->hwnd, GWL_EXSTYLE );
1244 XWindowChanges changes;
1245 unsigned int mask = 0;
1246
1247 if (data->managed && data->iconic) return;
1248
1249 /* resizing a managed maximized window is not allowed */
1250 if (!(style & WS_MAXIMIZE) || !data->managed)
1251 {
1252 changes.width = data->whole_rect.right - data->whole_rect.left;
1253 changes.height = data->whole_rect.bottom - data->whole_rect.top;
1254 /* if window rect is empty force size to 1x1 */
1255 if (changes.width <= 0 || changes.height <= 0) changes.width = changes.height = 1;
1256 if (changes.width > 65535) changes.width = 65535;
1257 if (changes.height > 65535) changes.height = 65535;
1258 mask |= CWWidth | CWHeight;
1259 }
1260
1261 /* only the size is allowed to change for the desktop window */
1262 if (data->whole_window != root_window)
1263 {
1264 POINT pt = virtual_screen_to_root( data->whole_rect.left, data->whole_rect.top );
1265 changes.x = pt.x;
1266 changes.y = pt.y;
1267 mask |= CWX | CWY;
1268 }
1269
1270 if (!(swp_flags & SWP_NOZORDER) || (swp_flags & SWP_SHOWWINDOW))
1271 {
1272 /* find window that this one must be after */
1273 HWND prev = GetWindow( data->hwnd, GW_HWNDPREV );
1274 while (prev && !(GetWindowLongW( prev, GWL_STYLE ) & WS_VISIBLE))
1275 prev = GetWindow( prev, GW_HWNDPREV );
1276 if (!prev) /* top child */
1277 {
1278 changes.stack_mode = Above;
1279 mask |= CWStackMode;
1280 }
1281 /* should use stack_mode Below but most window managers don't get it right */
1282 /* and Above with a sibling doesn't work so well either, so we ignore it */
1283 }
1284
1285 set_size_hints( data, style );
1286 set_mwm_hints( data, style, ex_style );
1287 data->configure_serial = NextRequest( data->display );
1288 XReconfigureWMWindow( data->display, data->whole_window, data->vis.screen, mask, &changes );
1289 #ifdef HAVE_LIBXSHAPE
1290 if (IsRectEmpty( old_window_rect ) != IsRectEmpty( &data->window_rect ))
1291 sync_window_region( data, (HRGN)1 );
1292 if (data->shaped)
1293 {
1294 int old_x_offset = old_window_rect->left - old_whole_rect->left;
1295 int old_y_offset = old_window_rect->top - old_whole_rect->top;
1296 int new_x_offset = data->window_rect.left - data->whole_rect.left;
1297 int new_y_offset = data->window_rect.top - data->whole_rect.top;
1298 if (old_x_offset != new_x_offset || old_y_offset != new_y_offset)
1299 XShapeOffsetShape( data->display, data->whole_window, ShapeBounding,
1300 new_x_offset - old_x_offset, new_y_offset - old_y_offset );
1301 }
1302 #endif
1303
1304 TRACE( "win %p/%lx pos %d,%d,%dx%d after %lx changes=%x serial=%lu\n",
1305 data->hwnd, data->whole_window, data->whole_rect.left, data->whole_rect.top,
1306 data->whole_rect.right - data->whole_rect.left,
1307 data->whole_rect.bottom - data->whole_rect.top,
1308 changes.sibling, mask, data->configure_serial );
1309 }
1310
1311
1312 /***********************************************************************
1313 * sync_client_position
1314 *
1315 * Synchronize the X client window position with the Windows one
1316 */
1317 static void sync_client_position( struct x11drv_win_data *data,
1318 const RECT *old_client_rect, const RECT *old_whole_rect )
1319 {
1320 int mask = 0;
1321 XWindowChanges changes;
1322
1323 if (!data->client_window) return;
1324
1325 changes.x = data->client_rect.left - data->whole_rect.left;
1326 changes.y = data->client_rect.top - data->whole_rect.top;
1327 changes.width = min( max( 1, data->client_rect.right - data->client_rect.left ), 65535 );
1328 changes.height = min( max( 1, data->client_rect.bottom - data->client_rect.top ), 65535 );
1329
1330 if (changes.x != old_client_rect->left - old_whole_rect->left) mask |= CWX;
1331 if (changes.y != old_client_rect->top - old_whole_rect->top) mask |= CWY;
1332 if (changes.width != old_client_rect->right - old_client_rect->left) mask |= CWWidth;
1333 if (changes.height != old_client_rect->bottom - old_client_rect->top) mask |= CWHeight;
1334
1335 if (mask)
1336 {
1337 TRACE( "setting client win %lx pos %d,%d,%dx%d changes=%x\n",
1338 data->client_window, changes.x, changes.y, changes.width, changes.height, mask );
1339 XConfigureWindow( data->display, data->client_window, mask, &changes );
1340 }
1341 }
1342
1343
1344 /***********************************************************************
1345 * move_window_bits
1346 *
1347 * Move the window bits when a window is moved.
1348 */
1349 static void move_window_bits( HWND hwnd, Window window, const RECT *old_rect, const RECT *new_rect,
1350 const RECT *old_client_rect, const RECT *new_client_rect,
1351 const RECT *new_window_rect )
1352 {
1353 RECT src_rect = *old_rect;
1354 RECT dst_rect = *new_rect;
1355 HDC hdc_src, hdc_dst;
1356 INT code;
1357 HRGN rgn;
1358 HWND parent = 0;
1359
1360 if (!window)
1361 {
1362 OffsetRect( &dst_rect, -new_window_rect->left, -new_window_rect->top );
1363 parent = GetAncestor( hwnd, GA_PARENT );
1364 hdc_src = GetDCEx( parent, 0, DCX_CACHE );
1365 hdc_dst = GetDCEx( hwnd, 0, DCX_CACHE | DCX_WINDOW );
1366 }
1367 else
1368 {
1369 OffsetRect( &dst_rect, -new_client_rect->left, -new_client_rect->top );
1370 /* make src rect relative to the old position of the window */
1371 OffsetRect( &src_rect, -old_client_rect->left, -old_client_rect->top );
1372 if (dst_rect.left == src_rect.left && dst_rect.top == src_rect.top) return;
1373 hdc_src = hdc_dst = GetDCEx( hwnd, 0, DCX_CACHE );
1374 }
1375
1376 rgn = CreateRectRgnIndirect( &dst_rect );
1377 SelectClipRgn( hdc_dst, rgn );
1378 DeleteObject( rgn );
1379 /* WS_CLIPCHILDREN doesn't exclude children from the window update
1380 * region, and ExcludeUpdateRgn call may inappropriately clip valid
1381 * child window contents from the copied parent window bits, but we
1382 * still want to avoid copying invalid window bits when possible.
1383 */
1384 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_CLIPCHILDREN ))
1385 ExcludeUpdateRgn( hdc_dst, hwnd );
1386
1387 code = X11DRV_START_EXPOSURES;
1388 ExtEscape( hdc_dst, X11DRV_ESCAPE, sizeof(code), (LPSTR)&code, 0, NULL );
1389
1390 TRACE( "copying bits for win %p/%lx %s -> %s\n",
1391 hwnd, window, wine_dbgstr_rect(&src_rect), wine_dbgstr_rect(&dst_rect) );
1392 BitBlt( hdc_dst, dst_rect.left, dst_rect.top,
1393 dst_rect.right - dst_rect.left, dst_rect.bottom - dst_rect.top,
1394 hdc_src, src_rect.left, src_rect.top, SRCCOPY );
1395
1396 rgn = 0;
1397 code = X11DRV_END_EXPOSURES;
1398 ExtEscape( hdc_dst, X11DRV_ESCAPE, sizeof(code), (LPSTR)&code, sizeof(rgn), (LPSTR)&rgn );
1399
1400 ReleaseDC( hwnd, hdc_dst );
1401 if (hdc_src != hdc_dst) ReleaseDC( parent, hdc_src );
1402
1403 if (rgn)
1404 {
1405 if (!window)
1406 {
1407 /* map region to client rect since we are using DCX_WINDOW */
1408 OffsetRgn( rgn, new_window_rect->left - new_client_rect->left,
1409 new_window_rect->top - new_client_rect->top );
1410 RedrawWindow( hwnd, NULL, rgn,
1411 RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ALLCHILDREN );
1412 }
1413 else RedrawWindow( hwnd, NULL, rgn, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN );
1414 DeleteObject( rgn );
1415 }
1416 }
1417
1418
1419 /**********************************************************************
1420 * create_client_window
1421 */
1422 Window create_client_window( struct x11drv_win_data *data, const XVisualInfo *visual )
1423 {
1424 XSetWindowAttributes attr;
1425 int x = data->client_rect.left - data->whole_rect.left;
1426 int y = data->client_rect.top - data->whole_rect.top;
1427 int cx = min( max( 1, data->client_rect.right - data->client_rect.left ), 65535 );
1428 int cy = min( max( 1, data->client_rect.bottom - data->client_rect.top ), 65535 );
1429
1430 if (data->client_window)
1431 {
1432 XDeleteContext( data->display, data->client_window, winContext );
1433 XDestroyWindow( data->display, data->client_window );
1434 }
1435
1436 if (data->colormap) XFreeColormap( data->display, data->colormap );
1437 data->colormap = XCreateColormap( data->display, root_window, visual->visual,
1438 (visual->class == PseudoColor ||
1439 visual->class == GrayScale ||
1440 visual->class == DirectColor) ? AllocAll : AllocNone );
1441 attr.colormap = data->colormap;
1442 attr.bit_gravity = NorthWestGravity;
1443 attr.win_gravity = NorthWestGravity;
1444 attr.backing_store = NotUseful;
1445 attr.event_mask = ExposureMask;
1446 attr.border_pixel = 0;
1447
1448 data->client_window = XCreateWindow( data->display, data->whole_window, x, y, cx, cy,
1449 0, default_visual.depth, InputOutput, visual->visual,
1450 CWBitGravity | CWWinGravity | CWBackingStore |
1451 CWColormap | CWEventMask | CWBorderPixel, &attr );
1452 if (!data->client_window) return 0;
1453
1454 XSaveContext( data->display, data->client_window, winContext, (char *)data->hwnd );
1455 XMapWindow( data->display, data->client_window );
1456 XSync( data->display, False );
1457 return data->client_window;
1458 }
1459
1460
1461 /**********************************************************************
1462 * create_whole_window
1463 *
1464 * Create the whole X window for a given window
1465 */
1466 static void create_whole_window( struct x11drv_win_data *data )
1467 {
1468 int cx, cy, mask;
1469 XSetWindowAttributes attr;
1470 WCHAR text[1024];
1471 COLORREF key;
1472 BYTE alpha;
1473 DWORD layered_flags;
1474 HRGN win_rgn;
1475 POINT pos;
1476
1477 if (!data->managed && is_window_managed( data->hwnd, SWP_NOACTIVATE, &data->window_rect ))
1478 {
1479 TRACE( "making win %p/%lx managed\n", data->hwnd, data->whole_window );
1480 data->managed = TRUE;
1481 }
1482
1483 if ((win_rgn = CreateRectRgn( 0, 0, 0, 0 )) && GetWindowRgn( data->hwnd, win_rgn ) == ERROR)
1484 {
1485 DeleteObject( win_rgn );
1486 win_rgn = 0;
1487 }
1488 data->shaped = (win_rgn != 0);
1489
1490 if (data->vis.visualid != default_visual.visualid)
1491 data->colormap = XCreateColormap( data->display, root_window, data->vis.visual, AllocNone );
1492
1493 mask = get_window_attributes( data, &attr );
1494
1495 data->whole_rect = data->window_rect;
1496 X11DRV_window_to_X_rect( data, &data->whole_rect );
1497 if (!(cx = data->whole_rect.right - data->whole_rect.left)) cx = 1;
1498 else if (cx > 65535) cx = 65535;
1499 if (!(cy = data->whole_rect.bottom - data->whole_rect.top)) cy = 1;
1500 else if (cy > 65535) cy = 65535;
1501
1502 pos = virtual_screen_to_root( data->whole_rect.left, data->whole_rect.top );
1503 data->whole_window = XCreateWindow( data->display, root_window, pos.y, pos.y,
1504 cx, cy, 0, data->vis.depth, InputOutput,
1505 data->vis.visual, mask, &attr );
1506 if (!data->whole_window) goto done;
1507
1508 set_initial_wm_hints( data->display, data->whole_window );
1509 set_wm_hints( data );
1510
1511 XSaveContext( data->display, data->whole_window, winContext, (char *)data->hwnd );
1512 SetPropA( data->hwnd, whole_window_prop, (HANDLE)data->whole_window );
1513
1514 /* set the window text */
1515 if (!InternalGetWindowText( data->hwnd, text, sizeof(text)/sizeof(WCHAR) )) text[0] = 0;
1516 sync_window_text( data->display, data->whole_window, text );
1517
1518 /* set the window region */
1519 if (win_rgn || IsRectEmpty( &data->window_rect )) sync_window_region( data, win_rgn );
1520
1521 /* set the window opacity */
1522 if (!GetLayeredWindowAttributes( data->hwnd, &key, &alpha, &layered_flags )) layered_flags = 0;
1523 sync_window_opacity( data->display, data->whole_window, key, alpha, layered_flags );
1524
1525 XFlush( data->display ); /* make sure the window exists before we start painting to it */
1526
1527 sync_window_cursor( data->whole_window );
1528
1529 done:
1530 if (win_rgn) DeleteObject( win_rgn );
1531 }
1532
1533
1534 /**********************************************************************
1535 * destroy_whole_window
1536 *
1537 * Destroy the whole X window for a given window.
1538 */
1539 static void destroy_whole_window( struct x11drv_win_data *data, BOOL already_destroyed )
1540 {
1541 if (!data->whole_window)
1542 {
1543 if (data->embedded)
1544 {
1545 Window xwin = (Window)GetPropA( data->hwnd, foreign_window_prop );
1546 if (xwin)
1547 {
1548 if (!already_destroyed) XSelectInput( data->display, xwin, 0 );
1549 XDeleteContext( data->display, xwin, winContext );
1550 RemovePropA( data->hwnd, foreign_window_prop );
1551 }
1552 }
1553 return;
1554 }
1555
1556
1557 TRACE( "win %p xwin %lx\n", data->hwnd, data->whole_window );
1558 XDeleteContext( data->display, data->whole_window, winContext );
1559 if (data->client_window) XDeleteContext( data->display, data->client_window, winContext );
1560 if (!already_destroyed) XDestroyWindow( data->display, data->whole_window );
1561 if (data->colormap) XFreeColormap( data->display, data->colormap );
1562 data->whole_window = data->client_window = 0;
1563 data->colormap = 0;
1564 data->wm_state = WithdrawnState;
1565 data->net_wm_state = 0;
1566 data->mapped = FALSE;
1567 if (data->xic)
1568 {
1569 XUnsetICFocus( data->xic );
1570 XDestroyIC( data->xic );
1571 data->xic = 0;
1572 }
1573 /* Outlook stops processing messages after destroying a dialog, so we need an explicit flush */
1574 XFlush( data->display );
1575 if (data->surface) window_surface_release( data->surface );
1576 data->surface = NULL;
1577 RemovePropA( data->hwnd, whole_window_prop );
1578 }
1579
1580
1581 /**********************************************************************
1582 * set_window_visual
1583 *
1584 * Change the visual by destroying and recreating the X window if needed.
1585 */
1586 void set_window_visual( struct x11drv_win_data *data, const XVisualInfo *vis )
1587 {
1588 Window client_window = data->client_window;
1589 Window whole_window = data->whole_window;
1590
1591 if (data->vis.visualid == vis->visualid) return;
1592 data->client_window = 0;
1593 destroy_whole_window( data, client_window != 0 /* don't destroy whole_window until reparented */ );
1594 if (data->surface) window_surface_release( data->surface );
1595 data->surface = NULL;
1596 data->vis = *vis;
1597 create_whole_window( data );
1598 if (!client_window) return;
1599 /* move the client to the new parent */
1600 XReparentWindow( data->display, client_window, data->whole_window,
1601 data->client_rect.left - data->whole_rect.left,
1602 data->client_rect.top - data->whole_rect.top );
1603 data->client_window = client_window;
1604 XDestroyWindow( data->display, whole_window );
1605 }
1606
1607
1608 /*****************************************************************
1609 * SetWindowText (X11DRV.@)
1610 */
1611 void CDECL X11DRV_SetWindowText( HWND hwnd, LPCWSTR text )
1612 {
1613 Window win;
1614
1615 if ((win = X11DRV_get_whole_window( hwnd )) && win != DefaultRootWindow(gdi_display))
1616 {
1617 Display *display = thread_init_display();
1618 sync_window_text( display, win, text );
1619 }
1620 }
1621
1622
1623 /***********************************************************************
1624 * SetWindowStyle (X11DRV.@)
1625 *
1626 * Update the X state of a window to reflect a style change
1627 */
1628 void CDECL X11DRV_SetWindowStyle( HWND hwnd, INT offset, STYLESTRUCT *style )
1629 {
1630 struct x11drv_win_data *data;
1631 DWORD changed = style->styleNew ^ style->styleOld;
1632
1633 if (hwnd == GetDesktopWindow()) return;
1634 if (!(data = get_win_data( hwnd ))) return;
1635 if (!data->whole_window) goto done;
1636
1637 if (offset == GWL_STYLE && (changed & WS_DISABLED)) set_wm_hints( data );
1638
1639 if (offset == GWL_EXSTYLE && (changed & WS_EX_LAYERED)) /* changing WS_EX_LAYERED resets attributes */
1640 {
1641 data->layered = FALSE;
1642 set_window_visual( data, &default_visual );
1643 sync_window_opacity( data->display, data->whole_window, 0, 0, 0 );
1644 if (data->surface) set_surface_color_key( data->surface, CLR_INVALID );
1645 }
1646 done:
1647 release_win_data( data );
1648 }
1649
1650
1651 /***********************************************************************
1652 * DestroyWindow (X11DRV.@)
1653 */
1654 void CDECL X11DRV_DestroyWindow( HWND hwnd )
1655 {
1656 struct x11drv_thread_data *thread_data = x11drv_thread_data();
1657 struct x11drv_win_data *data;
1658
1659 destroy_gl_drawable( hwnd );
1660
1661 if (!(data = get_win_data( hwnd ))) return;
1662
1663 destroy_whole_window( data, FALSE );
1664 if (thread_data->last_focus == hwnd) thread_data->last_focus = 0;
1665 if (thread_data->last_xic_hwnd == hwnd) thread_data->last_xic_hwnd = 0;
1666 if (data->icon_pixmap) XFreePixmap( gdi_display, data->icon_pixmap );
1667 if (data->icon_mask) XFreePixmap( gdi_display, data->icon_mask );
1668 HeapFree( GetProcessHeap(), 0, data->icon_bits );
1669 XDeleteContext( gdi_display, (XID)hwnd, win_data_context );
1670 release_win_data( data );
1671 HeapFree( GetProcessHeap(), 0, data );
1672 }
1673
1674
1675 /***********************************************************************
1676 * X11DRV_DestroyNotify
1677 */
1678 void X11DRV_DestroyNotify( HWND hwnd, XEvent *event )
1679 {
1680 struct x11drv_win_data *data;
1681 BOOL embedded;
1682
1683 if (!(data = get_win_data( hwnd ))) return;
1684 embedded = data->embedded;
1685 if (!embedded) FIXME( "window %p/%lx destroyed from the outside\n", hwnd, data->whole_window );
1686
1687 destroy_whole_window( data, TRUE );
1688 release_win_data( data );
1689 if (embedded) SendMessageW( hwnd, WM_CLOSE, 0, 0 );
1690 }
1691
1692
1693 static struct x11drv_win_data *alloc_win_data( Display *display, HWND hwnd )
1694 {
1695 struct x11drv_win_data *data;
1696
1697 if ((data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*data))))
1698 {
1699 data->display = display;
1700 data->vis = default_visual;
1701 data->hwnd = hwnd;
1702 EnterCriticalSection( &win_data_section );
1703 XSaveContext( gdi_display, (XID)hwnd, win_data_context, (char *)data );
1704 }
1705 return data;
1706 }
1707
1708
1709 /* initialize the desktop window id in the desktop manager process */
1710 BOOL create_desktop_win_data( Window win )
1711 {
1712 struct x11drv_thread_data *thread_data = x11drv_thread_data();
1713 Display *display = thread_data->display;
1714 struct x11drv_win_data *data;
1715
1716 if (!(data = alloc_win_data( display, GetDesktopWindow() ))) return FALSE;
1717 data->whole_window = win;
1718 data->managed = TRUE;
1719 SetPropA( data->hwnd, whole_window_prop, (HANDLE)win );
1720 set_initial_wm_hints( display, win );
1721 release_win_data( data );
1722 if (thread_data->clip_window) XReparentWindow( display, thread_data->clip_window, win, 0, 0 );
1723 return TRUE;
1724 }
1725
1726 /**********************************************************************
1727 * CreateDesktopWindow (X11DRV.@)
1728 */
1729 BOOL CDECL X11DRV_CreateDesktopWindow( HWND hwnd )
1730 {
1731 unsigned int width, height;
1732
1733 /* retrieve the real size of the desktop */
1734 SERVER_START_REQ( get_window_rectangles )
1735 {
1736 req->handle = wine_server_user_handle( hwnd );
1737 req->relative = COORDS_CLIENT;
1738 wine_server_call( req );
1739 width = reply->window.right;
1740 height = reply->window.bottom;
1741 }
1742 SERVER_END_REQ;
1743
1744 if (!width && !height) /* not initialized yet */
1745 {
1746 RECT rect = get_virtual_screen_rect();
1747
1748 SERVER_START_REQ( set_window_pos )
1749 {
1750 req->handle = wine_server_user_handle( hwnd );
1751 req->previous = 0;
1752 req->swp_flags = SWP_NOZORDER;
1753 req->window.left = rect.left;
1754 req->window.top = rect.top;
1755 req->window.right = rect.right;
1756 req->window.bottom = rect.bottom;
1757 req->client = req->window;
1758 wine_server_call( req );
1759 }
1760 SERVER_END_REQ;
1761 }
1762 else
1763 {
1764 Window win = (Window)GetPropA( hwnd, whole_window_prop );
1765 if (win && win != root_window) X11DRV_init_desktop( win, width, height );
1766 }
1767 return TRUE;
1768 }
1769
1770
1771 /**********************************************************************
1772 * CreateWindow (X11DRV.@)
1773 */
1774 BOOL CDECL X11DRV_CreateWindow( HWND hwnd )
1775 {
1776 if (hwnd == GetDesktopWindow())
1777 {
1778 struct x11drv_thread_data *data = x11drv_init_thread_data();
1779 XSetWindowAttributes attr;
1780
1781 /* create the cursor clipping window */
1782 attr.override_redirect = TRUE;
1783 attr.event_mask = StructureNotifyMask | FocusChangeMask;
1784 data->clip_window = XCreateWindow( data->display, root_window, 0, 0, 1, 1, 0, 0,
1785 InputOnly, default_visual.visual,
1786 CWOverrideRedirect | CWEventMask, &attr );
1787 XFlush( data->display );
1788 SetPropA( hwnd, clip_window_prop, (HANDLE)data->clip_window );
1789 }
1790 return TRUE;
1791 }
1792
1793
1794 /***********************************************************************
1795 * get_win_data
1796 *
1797 * Lock and return the X11 data structure associated with a window.
1798 */
1799 struct x11drv_win_data *get_win_data( HWND hwnd )
1800 {
1801 char *data;
1802
1803 if (!hwnd) return NULL;
1804 EnterCriticalSection( &win_data_section );
1805 if (!XFindContext( gdi_display, (XID)hwnd, win_data_context, &data ))
1806 return (struct x11drv_win_data *)data;
1807 LeaveCriticalSection( &win_data_section );
1808 return NULL;
1809 }
1810
1811
1812 /***********************************************************************
1813 * release_win_data
1814 *
1815 * Release the data returned by get_win_data.
1816 */
1817 void release_win_data( struct x11drv_win_data *data )
1818 {
1819 if (data) LeaveCriticalSection( &win_data_section );
1820 }
1821
1822
1823 /***********************************************************************
1824 * X11DRV_create_win_data
1825 *
1826 * Create an X11 data window structure for an existing window.
1827 */
1828 static struct x11drv_win_data *X11DRV_create_win_data( HWND hwnd, const RECT *window_rect,
1829 const RECT *client_rect )
1830 {
1831 Display *display;
1832 struct x11drv_win_data *data;
1833 HWND parent;
1834
1835 if (!(parent = GetAncestor( hwnd, GA_PARENT ))) return NULL; /* desktop */
1836
1837 /* don't create win data for HWND_MESSAGE windows */
1838 if (parent != GetDesktopWindow() && !GetAncestor( parent, GA_PARENT )) return NULL;
1839
1840 if (GetWindowThreadProcessId( hwnd, NULL ) != GetCurrentThreadId()) return NULL;
1841
1842 display = thread_init_display();
1843 init_clip_window(); /* make sure the clip window is initialized in this thread */
1844
1845 if (!(data = alloc_win_data( display, hwnd ))) return NULL;
1846
1847 data->whole_rect = data->window_rect = *window_rect;
1848 data->client_rect = *client_rect;
1849 if (parent == GetDesktopWindow())
1850 {
1851 create_whole_window( data );
1852 TRACE( "win %p/%lx window %s whole %s client %s\n",
1853 hwnd, data->whole_window, wine_dbgstr_rect( &data->window_rect ),
1854 wine_dbgstr_rect( &data->whole_rect ), wine_dbgstr_rect( &data->client_rect ));
1855 }
1856 return data;
1857 }
1858
1859
1860 /* window procedure for foreign windows */
1861 static LRESULT WINAPI foreign_window_proc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
1862 {
1863 switch(msg)
1864 {
1865 case WM_WINDOWPOSCHANGED:
1866 update_systray_balloon_position();
1867 break;
1868 case WM_PARENTNOTIFY:
1869 if (LOWORD(wparam) == WM_DESTROY)
1870 {
1871 TRACE( "%p: got parent notify destroy for win %lx\n", hwnd, lparam );
1872 PostMessageW( hwnd, WM_CLOSE, 0, 0 ); /* so that we come back here once the child is gone */
1873 }
1874 return 0;
1875 case WM_CLOSE:
1876 if (GetWindow( hwnd, GW_CHILD )) return 0; /* refuse to die if we still have children */
1877 break;
1878 }
1879 return DefWindowProcW( hwnd, msg, wparam, lparam );
1880 }
1881
1882
1883 /***********************************************************************
1884 * create_foreign_window
1885 *
1886 * Create a foreign window for the specified X window and its ancestors
1887 */
1888 HWND create_foreign_window( Display *display, Window xwin )
1889 {
1890 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};
1891 static BOOL class_registered;
1892 struct x11drv_win_data *data;
1893 HWND hwnd, parent;
1894 POINT pos;
1895 Window xparent, xroot;
1896 Window *xchildren;
1897 unsigned int nchildren;
1898 XWindowAttributes attr;
1899 DWORD style = WS_CLIPCHILDREN;
1900
1901 if (!class_registered)
1902 {
1903 WNDCLASSEXW class;
1904
1905 memset( &class, 0, sizeof(class) );
1906 class.cbSize = sizeof(class);
1907 class.lpfnWndProc = foreign_window_proc;
1908 class.lpszClassName = classW;
1909 if (!RegisterClassExW( &class ) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS)
1910 {
1911 ERR( "Could not register foreign window class\n" );
1912 return FALSE;
1913 }
1914 class_registered = TRUE;
1915 }
1916
1917 if (XFindContext( display, xwin, winContext, (char **)&hwnd )) hwnd = 0;
1918 if (hwnd) return hwnd; /* already created */
1919
1920 XSelectInput( display, xwin, StructureNotifyMask );
1921 if (!XGetWindowAttributes( display, xwin, &attr ) ||
1922 !XQueryTree( display, xwin, &xroot, &xparent, &xchildren, &nchildren ))
1923 {
1924 XSelectInput( display, xwin, 0 );
1925 return 0;
1926 }
1927 XFree( xchildren );
1928
1929 if (xparent == xroot)
1930 {
1931 parent = GetDesktopWindow();
1932 style |= WS_POPUP;
1933 pos = root_to_virtual_screen( attr.x, attr.y );
1934 }
1935 else
1936 {
1937 parent = create_foreign_window( display, xparent );
1938 style |= WS_CHILD;
1939 pos.x = attr.x;
1940 pos.y = attr.y;
1941 }
1942
1943 hwnd = CreateWindowW( classW, NULL, style, pos.x, pos.y, attr.width, attr.height,
1944 parent, 0, 0, NULL );
1945
1946 if (!(data = alloc_win_data( display, hwnd )))
1947 {
1948 DestroyWindow( hwnd );
1949 return 0;
1950 }
1951 SetRect( &data->window_rect, pos.x, pos.y, pos.x + attr.width, pos.y + attr.height );
1952 data->whole_rect = data->client_rect = data->window_rect;
1953 data->whole_window = data->client_window = 0;
1954 data->embedded = TRUE;
1955 data->mapped = TRUE;
1956
1957 SetPropA( hwnd, foreign_window_prop, (HANDLE)xwin );
1958 XSaveContext( display, xwin, winContext, (char *)data->hwnd );
1959
1960 TRACE( "win %lx parent %p style %08x %s -> hwnd %p\n",
1961 xwin, parent, style, wine_dbgstr_rect(&data->window_rect), hwnd );
1962
1963 release_win_data( data );
1964
1965 ShowWindow( hwnd, SW_SHOW );
1966 return hwnd;
1967 }
1968
1969
1970 /***********************************************************************
1971 * X11DRV_get_whole_window
1972 *
1973 * Return the X window associated with the full area of a window
1974 */
1975 Window X11DRV_get_whole_window( HWND hwnd )
1976 {
1977 struct x11drv_win_data *data = get_win_data( hwnd );
1978 Window ret;
1979
1980 if (!data)
1981 {
1982 if (hwnd == GetDesktopWindow()) return root_window;
1983 return (Window)GetPropA( hwnd, whole_window_prop );
1984 }
1985 ret = data->whole_window;
1986 release_win_data( data );
1987 return ret;
1988 }
1989
1990
1991 /***********************************************************************
1992 * X11DRV_get_ic
1993 *
1994 * Return the X input context associated with a window
1995 */
1996 XIC X11DRV_get_ic( HWND hwnd )
1997 {
1998 struct x11drv_win_data *data = get_win_data( hwnd );
1999 XIM xim;
2000 XIC ret = 0;
2001
2002 if (data)
2003 {
2004 x11drv_thread_data()->last_xic_hwnd = hwnd;
2005 ret = data->xic;
2006 if (!ret && (xim = x11drv_thread_data()->xim)) ret = X11DRV_CreateIC( xim, data );
2007 release_win_data( data );
2008 }
2009 return ret;
2010 }
2011
2012
2013 /***********************************************************************
2014 * X11DRV_GetDC (X11DRV.@)
2015 */
2016 void CDECL X11DRV_GetDC( HDC hdc, HWND hwnd, HWND top, const RECT *win_rect,
2017 const RECT *top_rect, DWORD flags )
2018 {
2019 struct x11drv_escape_set_drawable escape;
2020 HWND parent;
2021
2022 escape.code = X11DRV_SET_DRAWABLE;
2023 escape.mode = IncludeInferiors;
2024
2025 escape.dc_rect.left = win_rect->left - top_rect->left;
2026 escape.dc_rect.top = win_rect->top - top_rect->top;
2027 escape.dc_rect.right = win_rect->right - top_rect->left;
2028 escape.dc_rect.bottom = win_rect->bottom - top_rect->top;
2029
2030 if (top == hwnd)
2031 {
2032 struct x11drv_win_data *data = get_win_data( hwnd );
2033
2034 escape.drawable = data ? data->whole_window : X11DRV_get_whole_window( hwnd );
2035
2036 /* special case: when repainting the root window, clip out top-level windows */
2037 if (data && data->whole_window == root_window) escape.mode = ClipByChildren;
2038 release_win_data( data );
2039 }
2040 else
2041 {
2042 /* find the first ancestor that has a drawable */
2043 for (parent = hwnd; parent && parent != top; parent = GetAncestor( parent, GA_PARENT ))
2044 if ((escape.drawable = X11DRV_get_whole_window( parent ))) break;
2045
2046 if (escape.drawable)
2047 {
2048 POINT pt = { 0, 0 };
2049 MapWindowPoints( 0, parent, &pt, 1 );
2050 escape.dc_rect = *win_rect;
2051 OffsetRect( &escape.dc_rect, pt.x, pt.y );
2052 if (flags & DCX_CLIPCHILDREN) escape.mode = ClipByChildren;
2053 }
2054 else escape.drawable = X11DRV_get_whole_window( top );
2055 }
2056
2057 ExtEscape( hdc, X11DRV_ESCAPE, sizeof(escape), (LPSTR)&escape, 0, NULL );
2058 }
2059
2060
2061 /***********************************************************************
2062 * X11DRV_ReleaseDC (X11DRV.@)
2063 */
2064 void CDECL X11DRV_ReleaseDC( HWND hwnd, HDC hdc )
2065 {
2066 struct x11drv_escape_set_drawable escape;
2067
2068 escape.code = X11DRV_SET_DRAWABLE;
2069 escape.drawable = root_window;
2070 escape.mode = IncludeInferiors;
2071 escape.dc_rect = get_virtual_screen_rect();
2072 OffsetRect( &escape.dc_rect, -2 * escape.dc_rect.left, -2 * escape.dc_rect.top );
2073 ExtEscape( hdc, X11DRV_ESCAPE, sizeof(escape), (LPSTR)&escape, 0, NULL );
2074 }
2075
2076
2077 /*************************************************************************
2078 * ScrollDC (X11DRV.@)
2079 */
2080 BOOL CDECL X11DRV_ScrollDC( HDC hdc, INT dx, INT dy, HRGN update )
2081 {
2082 RECT rect;
2083 BOOL ret;
2084 HRGN expose_rgn = 0;
2085
2086 GetClipBox( hdc, &rect );
2087
2088 if (update)
2089 {
2090 INT code = X11DRV_START_EXPOSURES;
2091 ExtEscape( hdc, X11DRV_ESCAPE, sizeof(code), (LPSTR)&code, 0, NULL );
2092
2093 ret = BitBlt( hdc, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
2094 hdc, rect.left - dx, rect.top - dy, SRCCOPY );
2095
2096 code = X11DRV_END_EXPOSURES;
2097 ExtEscape( hdc, X11DRV_ESCAPE, sizeof(code), (LPSTR)&code,
2098 sizeof(expose_rgn), (LPSTR)&expose_rgn );
2099 if (expose_rgn)
2100 {
2101 CombineRgn( update, update, expose_rgn, RGN_OR );
2102 DeleteObject( expose_rgn );
2103 }
2104 }
2105 else ret = BitBlt( hdc, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
2106 hdc, rect.left - dx, rect.top - dy, SRCCOPY );
2107
2108 return ret;
2109 }
2110
2111
2112 /***********************************************************************
2113 * SetCapture (X11DRV.@)
2114 */
2115 void CDECL X11DRV_SetCapture( HWND hwnd, UINT flags )
2116 {
2117 struct x11drv_thread_data *thread_data = x11drv_thread_data();
2118
2119 if (!thread_data) return;
2120 if (!(flags & (GUI_INMOVESIZE | GUI_INMENUMODE))) return;
2121
2122 if (hwnd)
2123 {
2124 Window grab_win = X11DRV_get_whole_window( GetAncestor( hwnd, GA_ROOT ) );
2125
2126 if (!grab_win) return;
2127 XFlush( gdi_display );
2128 XGrabPointer( thread_data->display, grab_win, False,
2129 PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
2130 GrabModeAsync, GrabModeAsync, None, None, CurrentTime );
2131 thread_data->grab_window = grab_win;
2132 }
2133 else /* release capture */
2134 {
2135 XFlush( gdi_display );
2136 XUngrabPointer( thread_data->display, CurrentTime );
2137 XFlush( thread_data->display );
2138 thread_data->grab_window = None;
2139 }
2140 }
2141
2142
2143 /*****************************************************************
2144 * SetParent (X11DRV.@)
2145 */
2146 void CDECL X11DRV_SetParent( HWND hwnd, HWND parent, HWND old_parent )
2147 {
2148 struct x11drv_win_data *data;
2149
2150 if (parent == old_parent) return;
2151 if (!(data = get_win_data( hwnd ))) return;
2152 if (data->embedded) goto done;
2153
2154 if (parent != GetDesktopWindow()) /* a child window */
2155 {
2156 if (old_parent == GetDesktopWindow())
2157 {
2158 /* destroy the old X windows */
2159 destroy_whole_window( data, FALSE );
2160 data->managed = FALSE;
2161 }
2162 }
2163 else /* new top level window */
2164 {
2165 create_whole_window( data );
2166 }
2167 done:
2168 release_win_data( data );
2169 set_gl_drawable_parent( hwnd, parent );
2170 fetch_icon_data( hwnd, 0, 0 );
2171 }
2172
2173
2174 static inline RECT get_surface_rect( const RECT *visible_rect )
2175 {
2176 RECT rect = get_virtual_screen_rect();
2177
2178 IntersectRect( &rect, &rect, visible_rect );
2179 OffsetRect( &rect, -visible_rect->left, -visible_rect->top );
2180 rect.left &= ~31;
2181 rect.top &= ~31;
2182 rect.right = max( rect.left + 32, (rect.right + 31) & ~31 );
2183 rect.bottom = max( rect.top + 32, (rect.bottom + 31) & ~31 );
2184 return rect;
2185 }
2186
2187
2188 /***********************************************************************
2189 * WindowPosChanging (X11DRV.@)
2190 */
2191 void CDECL X11DRV_WindowPosChanging( HWND hwnd, HWND insert_after, UINT swp_flags,
2192 const RECT *window_rect, const RECT *client_rect, RECT *visible_rect,
2193 struct window_surface **surface )
2194 {
2195 struct x11drv_win_data *data = get_win_data( hwnd );
2196 RECT surface_rect;
2197 DWORD flags;
2198 COLORREF key;
2199 BOOL layered = GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_LAYERED;
2200
2201 if (!data && !(data = X11DRV_create_win_data( hwnd, window_rect, client_rect ))) return;
2202
2203 /* check if we need to switch the window to managed */
2204 if (!data->managed && data->whole_window && is_window_managed( hwnd, swp_flags, window_rect ))
2205 {
2206 TRACE( "making win %p/%lx managed\n", hwnd, data->whole_window );
2207 release_win_data( data );
2208 unmap_window( hwnd );
2209 if (!(data = get_win_data( hwnd ))) return;
2210 data->managed = TRUE;
2211 }
2212
2213 *visible_rect = *window_rect;
2214 X11DRV_window_to_X_rect( data, visible_rect );
2215
2216 /* create the window surface if necessary */
2217
2218 if (!data->whole_window && !data->embedded) goto done;
2219 if (swp_flags & SWP_HIDEWINDOW) goto done;
2220 if (data->vis.visualid != default_visual.visualid) goto done;
2221
2222 if (*surface) window_surface_release( *surface );
2223 *surface = NULL; /* indicate that we want to draw directly to the window */
2224
2225 if (data->embedded) goto done;
2226 if (data->whole_window == root_window) goto done;
2227 if (data->client_window) goto done;
2228 if (!client_side_graphics && !layered) goto done;
2229
2230 surface_rect = get_surface_rect( visible_rect );
2231 if (data->surface)
2232 {
2233 if (!memcmp( &data->surface->rect, &surface_rect, sizeof(surface_rect) ))
2234 {
2235 /* existing surface is good enough */
2236 window_surface_add_ref( data->surface );
2237 *surface = data->surface;
2238 goto done;
2239 }
2240 }
2241 else if (!(swp_flags & SWP_SHOWWINDOW) && !(GetWindowLongW( hwnd, GWL_STYLE ) & WS_VISIBLE)) goto done;
2242
2243 if (!layered || !GetLayeredWindowAttributes( hwnd, &key, NULL, &flags ) || !(flags & LWA_COLORKEY))
2244 key = CLR_INVALID;
2245
2246 *surface = create_surface( data->whole_window, &data->vis, &surface_rect, key, FALSE );
2247
2248 done:
2249 release_win_data( data );
2250 }
2251
2252
2253 /***********************************************************************
2254 * WindowPosChanged (X11DRV.@)
2255 */
2256 void CDECL X11DRV_WindowPosChanged( HWND hwnd, HWND insert_after, UINT swp_flags,
2257 const RECT *rectWindow, const RECT *rectClient,
2258 const RECT *visible_rect, const RECT *valid_rects,
2259 struct window_surface *surface )
2260 {
2261 struct x11drv_thread_data *thread_data;
2262 struct x11drv_win_data *data;
2263 DWORD new_style = GetWindowLongW( hwnd, GWL_STYLE );
2264 RECT old_window_rect, old_whole_rect, old_client_rect;
2265 int event_type;
2266
2267 if (!(data = get_win_data( hwnd ))) return;
2268
2269 thread_data = x11drv_thread_data();
2270
2271 old_window_rect = data->window_rect;
2272 old_whole_rect = data->whole_rect;
2273 old_client_rect = data->client_rect;
2274 data->window_rect = *rectWindow;
2275 data->whole_rect = *visible_rect;
2276 data->client_rect = *rectClient;
2277 if (data->vis.visualid == default_visual.visualid)
2278 {
2279 if (surface) window_surface_add_ref( surface );
2280 if (data->surface) window_surface_release( data->surface );
2281 data->surface = surface;
2282 }
2283
2284 TRACE( "win %p window %s client %s style %08x flags %08x\n",
2285 hwnd, wine_dbgstr_rect(rectWindow), wine_dbgstr_rect(rectClient), new_style, swp_flags );
2286
2287 if (!IsRectEmpty( &valid_rects[0] ))
2288 {
2289 Window window = data->whole_window;
2290 int x_offset = old_whole_rect.left - data->whole_rect.left;
2291 int y_offset = old_whole_rect.top - data->whole_rect.top;
2292
2293 /* if all that happened is that the whole window moved, copy everything */
2294 if (!(swp_flags & SWP_FRAMECHANGED) &&
2295 old_whole_rect.right - data->whole_rect.right == x_offset &&
2296 old_whole_rect.bottom - data->whole_rect.bottom == y_offset &&
2297 old_client_rect.left - data->client_rect.left == x_offset &&
2298 old_client_rect.right - data->client_rect.right == x_offset &&
2299 old_client_rect.top - data->client_rect.top == y_offset &&
2300 old_client_rect.bottom - data->client_rect.bottom == y_offset &&
2301 !memcmp( &valid_rects[0], &data->client_rect, sizeof(RECT) ))
2302 {
2303 /* if we have an X window the bits will be moved by the X server */
2304 if (!window && (x_offset != 0 || y_offset != 0))
2305 {
2306 release_win_data( data );
2307 move_window_bits( hwnd, window, &old_whole_rect, visible_rect,
2308 &old_client_rect, rectClient, rectWindow );
2309 if (!(data = get_win_data( hwnd ))) return;
2310 }
2311 }
2312 else
2313 {
2314 release_win_data( data );
2315 move_window_bits( hwnd, window, &valid_rects[1], &valid_rects[0],
2316 &old_client_rect, rectClient, rectWindow );
2317 if (!(data = get_win_data( hwnd ))) return;
2318 }
2319 }
2320
2321 XFlush( gdi_display ); /* make sure painting is done before we move the window */
2322
2323 sync_client_position( data, &old_client_rect, &old_whole_rect );
2324
2325 if (!data->whole_window)
2326 {
2327 release_win_data( data );
2328 sync_gl_drawable( hwnd, visible_rect, rectClient );
2329 return;
2330 }
2331
2332 /* check if we are currently processing an event relevant to this window */
2333 event_type = 0;
2334 if (thread_data &&
2335 thread_data->current_event &&
2336 thread_data->current_event->xany.window == data->whole_window)
2337 {
2338 event_type = thread_data->current_event->type;
2339 if (event_type != ConfigureNotify && event_type != PropertyNotify &&
2340 event_type != GravityNotify && event_type != ReparentNotify)
2341 event_type = 0; /* ignore other events */
2342 }
2343
2344 if (data->mapped && event_type != ReparentNotify)
2345 {
2346 if (((swp_flags & SWP_HIDEWINDOW) && !(new_style & WS_VISIBLE)) ||
2347 (!event_type && !(new_style & WS_MINIMIZE) &&
2348 !is_window_rect_mapped( rectWindow ) && is_window_rect_mapped( &old_window_rect )))
2349 {
2350 release_win_data( data );
2351 unmap_window( hwnd );
2352 if (is_window_rect_fullscreen( &old_window_rect )) reset_clipping_window();
2353 if (!(data = get_win_data( hwnd ))) return;
2354 }
2355 }
2356
2357 /* don't change position if we are about to minimize or maximize a managed window */
2358 if (!event_type &&
2359 !(data->managed && (swp_flags & SWP_STATECHANGED) && (new_style & (WS_MINIMIZE|WS_MAXIMIZE))))
2360 sync_window_position( data, swp_flags, &old_window_rect, &old_whole_rect, &old_client_rect );
2361
2362 if ((new_style & WS_VISIBLE) &&
2363 ((new_style & WS_MINIMIZE) || is_window_rect_mapped( rectWindow )))
2364 {
2365 if (!data->mapped)
2366 {
2367 BOOL needs_icon = !data->icon_pixmap;
2368 BOOL needs_map = TRUE;
2369
2370 /* layered windows are mapped only once their attributes are set */
2371 if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_LAYERED) needs_map = data->layered;
2372 release_win_data( data );
2373 if (needs_icon) fetch_icon_data( hwnd, 0, 0 );
2374 if (needs_map) map_window( hwnd, new_style );
2375 return;
2376 }
2377 else if ((swp_flags & SWP_STATECHANGED) && (!data->iconic != !(new_style & WS_MINIMIZE)))
2378 {
2379 set_wm_hints( data );
2380 data->iconic = (new_style & WS_MINIMIZE) != 0;
2381 TRACE( "changing win %p iconic state to %u\n", data->hwnd, data->iconic );
2382 if (data->iconic)
2383 XIconifyWindow( data->display, data->whole_window, data->vis.screen );
2384 else if (is_window_rect_mapped( rectWindow ))
2385 XMapWindow( data->display, data->whole_window );
2386 update_net_wm_states( data );
2387 }
2388 else
2389 {
2390 if (swp_flags & (SWP_FRAMECHANGED|SWP_STATECHANGED)) set_wm_hints( data );
2391 if (!event_type) update_net_wm_states( data );
2392 }
2393 }
2394
2395 XFlush( data->display ); /* make sure changes are done before we start painting again */
2396 if (data->surface && data->vis.visualid != default_visual.visualid)
2397 data->surface->funcs->flush( data->surface );
2398
2399 release_win_data( data );
2400 }
2401
2402
2403 /***********************************************************************
2404 * ShowWindow (X11DRV.@)
2405 */
2406 UINT CDECL X11DRV_ShowWindow( HWND hwnd, INT cmd, RECT *rect, UINT swp )
2407 {
2408 int x, y;
2409 unsigned int width, height, border, depth;
2410 Window root, top;
2411 POINT pos;
2412 DWORD style = GetWindowLongW( hwnd, GWL_STYLE );
2413 struct x11drv_thread_data *thread_data = x11drv_thread_data();
2414 struct x11drv_win_data *data = get_win_data( hwnd );
2415
2416 if (!data || !data->whole_window || !data->managed) goto done;
2417 if (IsRectEmpty( rect )) goto done;
2418 if (style & WS_MINIMIZE)
2419 {
2420 if (rect->left != -32000 || rect->top != -32000)
2421 {
2422 OffsetRect( rect, -32000 - rect->left, -32000 - rect->top );
2423 swp &= ~(SWP_NOMOVE | SWP_NOCLIENTMOVE);
2424 }
2425 goto done;
2426 }
2427 if (!data->mapped || data->iconic) goto done;
2428
2429 /* only fetch the new rectangle if the ShowWindow was a result of a window manager event */
2430
2431 if (!thread_data->current_event || thread_data->current_event->xany.window != data->whole_window)
2432 goto done;
2433
2434 if (thread_data->current_event->type != ConfigureNotify &&
2435 thread_data->current_event->type != PropertyNotify)
2436 goto done;
2437
2438 TRACE( "win %p/%lx cmd %d at %s flags %08x\n",
2439 hwnd, data->whole_window, cmd, wine_dbgstr_rect(rect), swp );
2440
2441 XGetGeometry( thread_data->display, data->whole_window,
2442 &root, &x, &y, &width, &height, &border, &depth );
2443 XTranslateCoordinates( thread_data->display, data->whole_window, root, 0, 0, &x, &y, &top );
2444 pos = root_to_virtual_screen( x, y );
2445 rect->left = pos.x;
2446 rect->top = pos.y;
2447 rect->right = pos.x + width;
2448 rect->bottom = pos.y + height;
2449 X11DRV_X_to_window_rect( data, rect );
2450 swp &= ~(SWP_NOMOVE | SWP_NOCLIENTMOVE | SWP_NOSIZE | SWP_NOCLIENTSIZE);
2451
2452 done:
2453 release_win_data( data );
2454 return swp;
2455 }
2456
2457
2458 /**********************************************************************
2459 * SetWindowIcon (X11DRV.@)
2460 *
2461 * hIcon or hIconSm has changed (or is being initialised for the
2462 * first time). Complete the X11 driver-specific initialisation
2463 * and set the window hints.
2464 */
2465 void CDECL X11DRV_SetWindowIcon( HWND hwnd, UINT type, HICON icon )
2466 {
2467 struct x11drv_win_data *data;
2468
2469 if (!(data = get_win_data( hwnd ))) return;
2470 if (!data->whole_window) goto done;
2471 release_win_data( data ); /* release the lock, fetching the icon requires sending messages */
2472
2473 if (type == ICON_BIG) fetch_icon_data( hwnd, icon, 0 );
2474 else fetch_icon_data( hwnd, 0, icon );
2475
2476 if (!(data = get_win_data( hwnd ))) return;
2477 set_wm_hints( data );
2478 done:
2479 release_win_data( data );
2480 }
2481
2482
2483 /***********************************************************************
2484 * SetWindowRgn (X11DRV.@)
2485 *
2486 * Assign specified region to window (for non-rectangular windows)
2487 */
2488 void CDECL X11DRV_SetWindowRgn( HWND hwnd, HRGN hrgn, BOOL redraw )
2489 {
2490 struct x11drv_win_data *data;
2491
2492 if ((data = get_win_data( hwnd )))
2493 {
2494 sync_window_region( data, hrgn );
2495 release_win_data( data );
2496 }
2497 else if (X11DRV_get_whole_window( hwnd ))
2498 {
2499 SendMessageW( hwnd, WM_X11DRV_SET_WIN_REGION, 0, 0 );
2500 }
2501 }
2502
2503
2504 /***********************************************************************
2505 * SetLayeredWindowAttributes (X11DRV.@)
2506 *
2507 * Set transparency attributes for a layered window.
2508 */
2509 void CDECL X11DRV_SetLayeredWindowAttributes( HWND hwnd, COLORREF key, BYTE alpha, DWORD flags )
2510 {
2511 struct x11drv_win_data *data = get_win_data( hwnd );
2512
2513 if (data)
2514 {
2515 if (data->whole_window)
2516 sync_window_opacity( data->display, data->whole_window, key, alpha, flags );
2517 if (data->surface)
2518 set_surface_color_key( data->surface, (flags & LWA_COLORKEY) ? key : CLR_INVALID );
2519
2520 data->layered = TRUE;
2521 if (!data->mapped) /* mapping is delayed until attributes are set */
2522 {
2523 DWORD style = GetWindowLongW( data->hwnd, GWL_STYLE );
2524
2525 if ((style & WS_VISIBLE) &&
2526 ((style & WS_MINIMIZE) || is_window_rect_mapped( &data->window_rect )))
2527 {
2528 release_win_data( data );
2529 map_window( hwnd, style );
2530 return;
2531 }
2532 }
2533 release_win_data( data );
2534 }
2535 else
2536 {
2537 Window win = X11DRV_get_whole_window( hwnd );
2538 if (win)
2539 {
2540 sync_window_opacity( gdi_display, win, key, alpha, flags );
2541 if (flags & LWA_COLORKEY)
2542 FIXME( "LWA_COLORKEY not supported on foreign process window %p\n", hwnd );
2543 }
2544 }
2545 }
2546
2547
2548 /*****************************************************************************
2549 * UpdateLayeredWindow (X11DRV.@)
2550 */
2551 BOOL CDECL X11DRV_UpdateLayeredWindow( HWND hwnd, const UPDATELAYEREDWINDOWINFO *info,
2552 const RECT *window_rect )
2553 {
2554 struct window_surface *surface;
2555 struct x11drv_win_data *data;
2556 BLENDFUNCTION blend = { AC_SRC_OVER, 0, 255, 0 };
2557 COLORREF color_key = (info->dwFlags & ULW_COLORKEY) ? info->crKey : CLR_INVALID;
2558 char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
2559 BITMAPINFO *bmi = (BITMAPINFO *)buffer;
2560 void *src_bits, *dst_bits;
2561 RECT rect;
2562 HDC hdc = 0;
2563 HBITMAP dib;
2564 BOOL ret = FALSE;
2565
2566 if (!(data = get_win_data( hwnd ))) return FALSE;
2567
2568 data->layered = TRUE;
2569 if (!data->embedded && argb_visual.visualid) set_window_visual( data, &argb_visual );
2570
2571 rect = *window_rect;
2572 OffsetRect( &rect, -window_rect->left, -window_rect->top );
2573
2574 surface = data->surface;
2575 if (!surface || memcmp( &surface->rect, &rect, sizeof(RECT) ))
2576 {
2577 data->surface = create_surface( data->whole_window, &data->vis, &rect,
2578 color_key, !data->embedded );
2579 if (surface) window_surface_release( surface );
2580 surface = data->surface;
2581 }
2582 else set_surface_color_key( surface, color_key );
2583
2584 if (surface) window_surface_add_ref( surface );
2585 release_win_data( data );
2586
2587 if (!surface) return FALSE;
2588 if (!info->hdcSrc)
2589 {
2590 window_surface_release( surface );
2591 return TRUE;
2592 }
2593
2594 dst_bits = surface->funcs->get_info( surface, bmi );
2595
2596 if (!(dib = CreateDIBSection( info->hdcDst, bmi, DIB_RGB_COLORS, &src_bits, NULL, 0 ))) goto done;
2597 if (!(hdc = CreateCompatibleDC( 0 ))) goto done;
2598
2599 SelectObject( hdc, dib );
2600
2601 surface->funcs->lock( surface );
2602
2603 if (info->prcDirty)
2604 {
2605 IntersectRect( &rect, &rect, info->prcDirty );
2606 memcpy( src_bits, dst_bits, bmi->bmiHeader.biSizeImage );
2607 PatBlt( hdc, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, BLACKNESS );
2608 }
2609 ret = GdiAlphaBlend( hdc, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
2610 info->hdcSrc,
2611 rect.left + (info->pptSrc ? info->pptSrc->x : 0),
2612 rect.top + (info->pptSrc ? info->pptSrc->y : 0),
2613 rect.right - rect.left, rect.bottom - rect.top,
2614 (info->dwFlags & ULW_ALPHA) ? *info->pblend : blend );
2615 if (ret)
2616 {
2617 memcpy( dst_bits, src_bits, bmi->bmiHeader.biSizeImage );
2618 add_bounds_rect( surface->funcs->get_bounds( surface ), &rect );
2619 }
2620
2621 surface->funcs->unlock( surface );
2622 surface->funcs->flush( surface );
2623
2624 done:
2625 window_surface_release( surface );
2626 if (hdc) DeleteDC( hdc );
2627 if (dib) DeleteObject( dib );
2628 return ret;
2629 }
2630
2631
2632 /**********************************************************************
2633 * X11DRV_WindowMessage (X11DRV.@)
2634 */
2635 LRESULT CDECL X11DRV_WindowMessage( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
2636 {
2637 struct x11drv_win_data *data;
2638
2639 switch(msg)
2640 {
2641 case WM_X11DRV_ACQUIRE_SELECTION:
2642 X11DRV_AcquireClipboard( hwnd );
2643 return 0;
2644 case WM_X11DRV_SET_WIN_REGION:
2645 if ((data = get_win_data( hwnd )))
2646 {
2647 sync_window_region( data, (HRGN)1 );
2648 release_win_data( data );
2649 }
2650 return 0;
2651 case WM_X11DRV_RESIZE_DESKTOP:
2652 X11DRV_resize_desktop( LOWORD(lp), HIWORD(lp) );
2653 return 0;
2654 case WM_X11DRV_SET_CURSOR:
2655 if ((data = get_win_data( hwnd )))
2656 {
2657 if (data->whole_window) set_window_cursor( data->whole_window, (HCURSOR)lp );
2658 release_win_data( data );
2659 }
2660 else if (hwnd == x11drv_thread_data()->clip_hwnd)
2661 set_window_cursor( x11drv_thread_data()->clip_window, (HCURSOR)lp );
2662 return 0;
2663 case WM_X11DRV_CLIP_CURSOR:
2664 return clip_cursor_notify( hwnd, (HWND)lp );
2665 default:
2666 FIXME( "got window msg %x hwnd %p wp %lx lp %lx\n", msg, hwnd, wp, lp );
2667 return 0;
2668 }
2669 }
2670
2671
2672 /***********************************************************************
2673 * is_netwm_supported
2674 */
2675 static BOOL is_netwm_supported( Display *display, Atom atom )
2676 {
2677 static Atom *net_supported;
2678 static int net_supported_count = -1;
2679 int i;
2680
2681 if (net_supported_count == -1)
2682 {
2683 Atom type;
2684 int format;
2685 unsigned long count, remaining;
2686
2687 if (!XGetWindowProperty( display, DefaultRootWindow(display), x11drv_atom(_NET_SUPPORTED), 0,
2688 ~0UL, False, XA_ATOM, &type, &format, &count,
2689 &remaining, (unsigned char **)&net_supported ))
2690 net_supported_count = get_property_size( format, count ) / sizeof(Atom);
2691 else
2692 net_supported_count = 0;
2693 }
2694
2695 for (i = 0; i < net_supported_count; i++)
2696 if (net_supported[i] == atom) return TRUE;
2697 return FALSE;
2698 }
2699
2700
2701 /***********************************************************************
2702 * SysCommand (X11DRV.@)
2703 *
2704 * Perform WM_SYSCOMMAND handling.
2705 */
2706 LRESULT CDECL X11DRV_SysCommand( HWND hwnd, WPARAM wparam, LPARAM lparam )
2707 {
2708 WPARAM hittest = wparam & 0x0f;
2709 int dir;
2710 struct x11drv_win_data *data;
2711
2712 if (!(data = get_win_data( hwnd ))) return -1;
2713 if (!data->whole_window || !data->managed || !data->mapped) goto failed;
2714
2715 switch (wparam & 0xfff0)
2716 {
2717 case SC_MOVE:
2718 if (!hittest) dir = _NET_WM_MOVERESIZE_MOVE_KEYBOARD;
2719 else dir = _NET_WM_MOVERESIZE_MOVE;
2720 break;
2721 case SC_SIZE:
2722 /* windows without WS_THICKFRAME are not resizable through the window manager */
2723 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_THICKFRAME)) goto failed;
2724
2725 switch (hittest)
2726 {
2727 case WMSZ_LEFT: dir = _NET_WM_MOVERESIZE_SIZE_LEFT; break;
2728 case WMSZ_RIGHT: dir = _NET_WM_MOVERESIZE_SIZE_RIGHT; break;
2729 case WMSZ_TOP: dir = _NET_WM_MOVERESIZE_SIZE_TOP; break;
2730 case WMSZ_TOPLEFT: dir = _NET_WM_MOVERESIZE_SIZE_TOPLEFT; break;
2731 case WMSZ_TOPRIGHT: dir = _NET_WM_MOVERESIZE_SIZE_TOPRIGHT; break;
2732 case WMSZ_BOTTOM: dir = _NET_WM_MOVERESIZE_SIZE_BOTTOM; break;
2733 case WMSZ_BOTTOMLEFT: dir = _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT; break;
2734 case WMSZ_BOTTOMRIGHT: dir = _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT; break;
2735 default: dir = _NET_WM_MOVERESIZE_SIZE_KEYBOARD; break;
2736 }
2737 break;
2738
2739 case SC_KEYMENU:
2740 /* prevent a simple ALT press+release from activating the system menu,
2741 * as that can get confusing on managed windows */
2742 if ((WCHAR)lparam) goto failed; /* got an explicit char */
2743 if (GetMenu( hwnd )) goto failed; /* window has a real menu */
2744 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_SYSMENU)) goto failed; /* no system menu */
2745 TRACE( "ignoring SC_KEYMENU wp %lx lp %lx\n", wparam, lparam );
2746 release_win_data( data );
2747 return 0;
2748
2749 default:
2750 goto failed;
2751 }
2752
2753 if (IsZoomed(hwnd)) goto failed;
2754
2755 if (!is_netwm_supported( data->display, x11drv_atom(_NET_WM_MOVERESIZE) ))
2756 {
2757 TRACE( "_NET_WM_MOVERESIZE not supported\n" );
2758 goto failed;
2759 }
2760
2761 release_win_data( data );
2762 move_resize_window( hwnd, dir );
2763 return 0;
2764
2765 failed:
2766 release_win_data( data );
2767 return -1;
2768 }
Windows API implementation