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