2 * Window related functions
4 * Copyright 1993, 1994, 1995, 1996, 2001 Alexandre Julliard
5 * Copyright 1993 David Metcalfe
6 * Copyright 1995, 1996 Alex Korobka
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.
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.
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
33 #include <X11/Xresource.h>
34 #include <X11/Xutil.h>
36 #include <X11/extensions/shape.h>
37 #endif /* HAVE_LIBXSHAPE */
43 #include "wine/unicode.h"
46 #include "xcomposite.h"
47 #include "wine/debug.h"
48 #include "wine/server.h"
51 WINE_DEFAULT_DEBUG_CHANNEL(x11drv
);
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
65 #define _NET_WM_STATE_REMOVE 0
66 #define _NET_WM_STATE_ADD 1
67 #define _NET_WM_STATE_TOGGLE 2
69 #define SWP_AGG_NOPOSCHANGE (SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE | SWP_NOZORDER)
71 /* X context to associate a hwnd to an X window */
72 XContext winContext
= 0;
74 /* X context to associate a struct x11drv_win_data to an hwnd */
75 static XContext win_data_context
;
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";
86 /***********************************************************************
87 * http://standards.freedesktop.org/startup-notification-spec
89 static void remove_startup_notification(Display
*display
, Window window
)
91 static LONG startup_notification_removed
= 0;
100 if (InterlockedCompareExchange(&startup_notification_removed
, 1, 0) != 0)
103 if (GetEnvironmentVariableA("DESKTOP_STARTUP_ID", id
, sizeof(id
)) == 0)
105 SetEnvironmentVariableA("DESKTOP_STARTUP_ID", NULL
);
107 pos
= snprintf(message
, sizeof(message
), "remove: ID=");
108 message
[pos
++] = '"';
109 for (i
= 0; id
[i
] && pos
< sizeof(message
) - 2; i
++)
111 if (id
[i
] == '"' || id
[i
] == '\\')
112 message
[pos
++] = '\\';
113 message
[pos
++] = id
[i
];
115 message
[pos
++] = '"';
116 message
[pos
++] = '\0';
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;
125 srclen
= strlen(src
) + 1;
133 memset(&xevent
.xclient
.data
.b
[0], 0, 20);
134 memcpy(&xevent
.xclient
.data
.b
[0], src
, msglen
);
138 XSendEvent( display
, DefaultRootWindow( display
), False
, PropertyChangeMask
, &xevent
);
139 xevent
.xclient
.message_type
= x11drv_atom(_NET_STARTUP_INFO
);
145 /***********************************************************************
148 * Check if a given window should be managed
150 static BOOL
is_window_managed( HWND hwnd
, UINT swp_flags
, const RECT
*window_rect
)
152 DWORD style
, ex_style
;
154 if (!managed_mode
) return FALSE
;
156 /* child windows are not managed */
157 style
= GetWindowLongW( hwnd
, GWL_STYLE
);
158 if ((style
& (WS_CHILD
|WS_POPUP
)) == WS_CHILD
) return FALSE
;
159 /* activated windows are managed */
160 if (!(swp_flags
& (SWP_NOACTIVATE
|SWP_HIDEWINDOW
))) return TRUE
;
161 if (hwnd
== GetActiveWindow()) return TRUE
;
162 /* windows with caption are managed */
163 if ((style
& WS_CAPTION
) == WS_CAPTION
) return TRUE
;
164 /* windows with thick frame are managed */
165 if (style
& WS_THICKFRAME
) return TRUE
;
166 if (style
& WS_POPUP
)
171 /* popup with sysmenu == caption are managed */
172 if (style
& WS_SYSMENU
) return TRUE
;
173 /* full-screen popup windows are managed */
174 hmon
= MonitorFromWindow( hwnd
, MONITOR_DEFAULTTOPRIMARY
);
175 mi
.cbSize
= sizeof( mi
);
176 GetMonitorInfoW( hmon
, &mi
);
177 if (window_rect
->left
<= mi
.rcWork
.left
&& window_rect
->right
>= mi
.rcWork
.right
&&
178 window_rect
->top
<= mi
.rcWork
.top
&& window_rect
->bottom
>= mi
.rcWork
.bottom
)
181 /* application windows are managed */
182 ex_style
= GetWindowLongW( hwnd
, GWL_EXSTYLE
);
183 if (ex_style
& WS_EX_APPWINDOW
) return TRUE
;
184 /* default: not managed */
189 /***********************************************************************
190 * X11DRV_is_window_rect_mapped
192 * Check if the X whole window should be mapped based on its rectangle
194 static BOOL
is_window_rect_mapped( const RECT
*rect
)
196 /* don't map if rect is empty */
197 if (IsRectEmpty( rect
)) return FALSE
;
199 /* don't map if rect is off-screen */
200 if (rect
->left
>= virtual_screen_rect
.right
||
201 rect
->top
>= virtual_screen_rect
.bottom
||
202 rect
->right
<= virtual_screen_rect
.left
||
203 rect
->bottom
<= virtual_screen_rect
.top
)
210 /***********************************************************************
211 * is_window_resizable
213 * Check if window should be made resizable by the window manager
215 static inline BOOL
is_window_resizable( struct x11drv_win_data
*data
, DWORD style
)
217 if (style
& WS_THICKFRAME
) return TRUE
;
218 /* Metacity needs the window to be resizable to make it fullscreen */
219 return (data
->whole_rect
.left
<= 0 && data
->whole_rect
.right
>= screen_width
&&
220 data
->whole_rect
.top
<= 0 && data
->whole_rect
.bottom
>= screen_height
);
224 /***********************************************************************
227 static HWND
get_window_owner( HWND hwnd
)
230 HWND owner
= GetWindow( hwnd
, GW_OWNER
);
231 /* ignore the zero-size owners used by Delphi apps */
232 if (owner
&& GetWindowRect( owner
, &rect
) && IsRectEmpty( &rect
)) owner
= 0;
237 /***********************************************************************
238 * get_mwm_decorations
240 static unsigned long get_mwm_decorations( struct x11drv_win_data
*data
,
241 DWORD style
, DWORD ex_style
)
243 unsigned long ret
= 0;
245 if (!decorated_mode
) return 0;
247 if (IsRectEmpty( &data
->window_rect
)) return 0;
248 if (data
->shaped
) return 0;
250 if (ex_style
& WS_EX_TOOLWINDOW
) return 0;
252 if ((style
& WS_CAPTION
) == WS_CAPTION
)
254 ret
|= MWM_DECOR_TITLE
| MWM_DECOR_BORDER
;
255 if (style
& WS_SYSMENU
) ret
|= MWM_DECOR_MENU
;
256 if (style
& WS_MINIMIZEBOX
) ret
|= MWM_DECOR_MINIMIZE
;
257 if (style
& WS_MAXIMIZEBOX
) ret
|= MWM_DECOR_MAXIMIZE
;
259 if (ex_style
& WS_EX_DLGMODALFRAME
) ret
|= MWM_DECOR_BORDER
;
260 else if (style
& WS_THICKFRAME
) ret
|= MWM_DECOR_BORDER
| MWM_DECOR_RESIZEH
;
261 else if ((style
& (WS_DLGFRAME
|WS_BORDER
)) == WS_DLGFRAME
) ret
|= MWM_DECOR_BORDER
;
266 /***********************************************************************
267 * get_x11_rect_offset
269 * Helper for X11DRV_window_to_X_rect and X11DRV_X_to_window_rect.
271 static void get_x11_rect_offset( struct x11drv_win_data
*data
, RECT
*rect
)
273 DWORD style
, ex_style
, style_mask
= 0, ex_style_mask
= 0;
276 rect
->top
= rect
->bottom
= rect
->left
= rect
->right
= 0;
278 style
= GetWindowLongW( data
->hwnd
, GWL_STYLE
);
279 ex_style
= GetWindowLongW( data
->hwnd
, GWL_EXSTYLE
);
280 decor
= get_mwm_decorations( data
, style
, ex_style
);
282 if (decor
& MWM_DECOR_TITLE
) style_mask
|= WS_CAPTION
;
283 if (decor
& MWM_DECOR_BORDER
)
285 style_mask
|= WS_DLGFRAME
| WS_THICKFRAME
;
286 ex_style_mask
|= WS_EX_DLGMODALFRAME
;
289 AdjustWindowRectEx( rect
, style
& style_mask
, FALSE
, ex_style
& ex_style_mask
);
293 /***********************************************************************
294 * get_window_attributes
296 * Fill the window attributes structure for an X window.
298 static int get_window_attributes( Display
*display
, struct x11drv_win_data
*data
,
299 XSetWindowAttributes
*attr
)
301 attr
->override_redirect
= !data
->managed
;
302 attr
->colormap
= X11DRV_PALETTE_PaletteXColormap
;
303 attr
->save_under
= ((GetClassLongW( data
->hwnd
, GCL_STYLE
) & CS_SAVEBITS
) != 0);
304 attr
->cursor
= x11drv_thread_data()->cursor
;
305 attr
->bit_gravity
= NorthWestGravity
;
306 attr
->win_gravity
= StaticGravity
;
307 attr
->backing_store
= NotUseful
;
308 attr
->event_mask
= (ExposureMask
| PointerMotionMask
|
309 ButtonPressMask
| ButtonReleaseMask
| EnterWindowMask
|
310 KeyPressMask
| KeyReleaseMask
| FocusChangeMask
|
311 KeymapStateMask
| StructureNotifyMask
);
312 if (data
->managed
) attr
->event_mask
|= PropertyChangeMask
;
314 return (CWOverrideRedirect
| CWSaveUnder
| CWColormap
| CWCursor
|
315 CWEventMask
| CWBitGravity
| CWBackingStore
);
319 /***********************************************************************
320 * create_client_window
322 static Window
create_client_window( Display
*display
, struct x11drv_win_data
*data
, XVisualInfo
*vis
)
325 XSetWindowAttributes attr
;
327 Visual
*client_visual
= vis
? vis
->visual
: visual
;
329 attr
.bit_gravity
= NorthWestGravity
;
330 attr
.win_gravity
= NorthWestGravity
;
331 attr
.backing_store
= NotUseful
;
332 attr
.event_mask
= (ExposureMask
| PointerMotionMask
|
333 ButtonPressMask
| ButtonReleaseMask
| EnterWindowMask
);
334 mask
= CWEventMask
| CWBitGravity
| CWWinGravity
| CWBackingStore
;
336 if ((cx
= data
->client_rect
.right
- data
->client_rect
.left
) <= 0) cx
= 1;
337 else if (cx
> 65535) cx
= 65535;
338 if ((cy
= data
->client_rect
.bottom
- data
->client_rect
.top
) <= 0) cy
= 1;
339 else if (cy
> 65535) cy
= 65535;
345 attr
.colormap
= XCreateColormap( display
, root_window
, vis
->visual
,
346 (vis
->class == PseudoColor
|| vis
->class == GrayScale
||
347 vis
->class == DirectColor
) ? AllocAll
: AllocNone
);
351 client
= XCreateWindow( display
, data
->whole_window
,
352 data
->client_rect
.left
- data
->whole_rect
.left
,
353 data
->client_rect
.top
- data
->whole_rect
.top
,
354 cx
, cy
, 0, screen_depth
, InputOutput
,
355 client_visual
, mask
, &attr
);
362 if (data
->client_window
)
364 struct x11drv_thread_data
*thread_data
= x11drv_thread_data();
365 if (thread_data
->cursor_window
== data
->client_window
) thread_data
->cursor_window
= None
;
366 XDeleteContext( display
, data
->client_window
, winContext
);
367 XDestroyWindow( display
, data
->client_window
);
369 data
->client_window
= client
;
370 data
->visualid
= XVisualIDFromVisual( client_visual
);
372 if (data
->colormap
) XFreeColormap( display
, data
->colormap
);
373 data
->colormap
= vis
? attr
.colormap
: 0;
375 XMapWindow( display
, data
->client_window
);
376 XSaveContext( display
, data
->client_window
, winContext
, (char *)data
->hwnd
);
379 SetPropA( data
->hwnd
, client_window_prop
, (HANDLE
)data
->client_window
);
380 return data
->client_window
;
384 /***********************************************************************
387 * Change the X window attributes when the window style has changed.
389 static void sync_window_style( Display
*display
, struct x11drv_win_data
*data
)
391 if (data
->whole_window
!= root_window
)
393 XSetWindowAttributes attr
;
394 int mask
= get_window_attributes( display
, data
, &attr
);
397 XChangeWindowAttributes( display
, data
->whole_window
, mask
, &attr
);
403 /***********************************************************************
406 * Update the X11 window region.
408 static void sync_window_region( Display
*display
, struct x11drv_win_data
*data
, HRGN win_region
)
410 #ifdef HAVE_LIBXSHAPE
411 HRGN hrgn
= win_region
;
413 if (!data
->whole_window
) return;
414 data
->shaped
= FALSE
;
416 if (hrgn
== (HRGN
)1) /* hack: win_region == 1 means retrieve region from server */
418 if (!(hrgn
= CreateRectRgn( 0, 0, 0, 0 ))) return;
419 if (GetWindowRgn( data
->hwnd
, hrgn
) == ERROR
)
421 DeleteObject( hrgn
);
429 XShapeCombineMask( display
, data
->whole_window
, ShapeBounding
, 0, 0, None
, ShapeSet
);
434 RGNDATA
*pRegionData
= X11DRV_GetRegionData( hrgn
, 0 );
438 XShapeCombineRectangles( display
, data
->whole_window
, ShapeBounding
,
439 data
->window_rect
.left
- data
->whole_rect
.left
,
440 data
->window_rect
.top
- data
->whole_rect
.top
,
441 (XRectangle
*)pRegionData
->Buffer
,
442 pRegionData
->rdh
.nCount
, ShapeSet
, YXBanded
);
444 HeapFree(GetProcessHeap(), 0, pRegionData
);
448 if (hrgn
&& hrgn
!= win_region
) DeleteObject( hrgn
);
449 #endif /* HAVE_LIBXSHAPE */
453 /***********************************************************************
454 * sync_window_opacity
456 static void sync_window_opacity( Display
*display
, Window win
,
457 COLORREF key
, BYTE alpha
, DWORD flags
)
459 unsigned long opacity
= 0xffffffff;
461 if (flags
& LWA_ALPHA
) opacity
= (0xffffffff / 0xff) * alpha
;
463 if (flags
& LWA_COLORKEY
) FIXME("LWA_COLORKEY not supported\n");
466 if (opacity
== 0xffffffff)
467 XDeleteProperty( display
, win
, x11drv_atom(_NET_WM_WINDOW_OPACITY
) );
469 XChangeProperty( display
, win
, x11drv_atom(_NET_WM_WINDOW_OPACITY
),
470 XA_CARDINAL
, 32, PropModeReplace
, (unsigned char *)&opacity
, 1 );
475 /***********************************************************************
478 static void sync_window_text( Display
*display
, Window win
, const WCHAR
*text
)
481 char *buffer
, *utf8_buffer
;
484 /* allocate new buffer for window text */
485 count
= WideCharToMultiByte(CP_UNIXCP
, 0, text
, -1, NULL
, 0, NULL
, NULL
);
486 if (!(buffer
= HeapAlloc( GetProcessHeap(), 0, count
))) return;
487 WideCharToMultiByte(CP_UNIXCP
, 0, text
, -1, buffer
, count
, NULL
, NULL
);
489 count
= WideCharToMultiByte(CP_UTF8
, 0, text
, strlenW(text
), NULL
, 0, NULL
, NULL
);
490 if (!(utf8_buffer
= HeapAlloc( GetProcessHeap(), 0, count
)))
492 HeapFree( GetProcessHeap(), 0, buffer
);
495 WideCharToMultiByte(CP_UTF8
, 0, text
, strlenW(text
), utf8_buffer
, count
, NULL
, NULL
);
498 if (XmbTextListToTextProperty( display
, &buffer
, 1, XStdICCTextStyle
, &prop
) == Success
)
500 XSetWMName( display
, win
, &prop
);
501 XSetWMIconName( display
, win
, &prop
);
505 Implements a NET_WM UTF-8 title. It should be without a trailing \0,
506 according to the standard
507 ( http://www.pps.jussieu.fr/~jch/software/UTF8_STRING/UTF8_STRING.text ).
509 XChangeProperty( display
, win
, x11drv_atom(_NET_WM_NAME
), x11drv_atom(UTF8_STRING
),
510 8, PropModeReplace
, (unsigned char *) utf8_buffer
, count
);
513 HeapFree( GetProcessHeap(), 0, utf8_buffer
);
514 HeapFree( GetProcessHeap(), 0, buffer
);
518 /***********************************************************************
521 static BOOL
set_win_format( HWND hwnd
, XID fbconfig_id
)
523 struct x11drv_win_data
*data
;
527 if (!(data
= X11DRV_get_win_data(hwnd
)) &&
528 !(data
= X11DRV_create_win_data(hwnd
))) return FALSE
;
530 if (!(vis
= visual_from_fbconfig_id(fbconfig_id
))) return FALSE
;
532 if (data
->whole_window
)
534 Display
*display
= thread_display();
535 Window client
= data
->client_window
;
537 if (vis
->visualid
!= data
->visualid
)
539 client
= create_client_window( display
, data
, vis
);
540 TRACE( "re-created client window %lx for %p fbconfig %lx\n", client
, data
->hwnd
, fbconfig_id
);
546 if (client
) goto done
;
550 w
= data
->client_rect
.right
- data
->client_rect
.left
;
551 h
= data
->client_rect
.bottom
- data
->client_rect
.top
;
556 #ifdef SONAME_LIBXCOMPOSITE
559 XSetWindowAttributes attrib
;
560 static Window dummy_parent
;
563 attrib
.override_redirect
= True
;
566 dummy_parent
= XCreateWindow( gdi_display
, root_window
, -1, -1, 1, 1, 0, screen_depth
,
567 InputOutput
, visual
, CWOverrideRedirect
, &attrib
);
568 XMapWindow( gdi_display
, dummy_parent
);
570 data
->colormap
= XCreateColormap(gdi_display
, dummy_parent
, vis
->visual
,
571 (vis
->class == PseudoColor
||
572 vis
->class == GrayScale
||
573 vis
->class == DirectColor
) ?
574 AllocAll
: AllocNone
);
575 attrib
.colormap
= data
->colormap
;
576 XInstallColormap(gdi_display
, attrib
.colormap
);
578 if(data
->gl_drawable
) XDestroyWindow(gdi_display
, data
->gl_drawable
);
579 data
->gl_drawable
= XCreateWindow(gdi_display
, dummy_parent
, -w
, 0, w
, h
, 0,
580 vis
->depth
, InputOutput
, vis
->visual
,
581 CWColormap
| CWOverrideRedirect
,
583 if(data
->gl_drawable
)
585 pXCompositeRedirectWindow(gdi_display
, data
->gl_drawable
,
586 CompositeRedirectManual
);
587 XMapWindow(gdi_display
, data
->gl_drawable
);
590 XFlush( gdi_display
);
596 WARN("XComposite is not available, using GLXPixmap hack\n");
600 if(data
->pixmap
) XFreePixmap(gdi_display
, data
->pixmap
);
601 data
->pixmap
= XCreatePixmap(gdi_display
, root_window
, w
, h
, vis
->depth
);
609 if(data
->gl_drawable
) destroy_glxpixmap(gdi_display
, data
->gl_drawable
);
610 data
->gl_drawable
= create_glxpixmap(gdi_display
, vis
, data
->pixmap
);
611 if(!data
->gl_drawable
)
613 XFreePixmap(gdi_display
, data
->pixmap
);
617 XFlush( gdi_display
);
619 if (data
->pixmap
) SetPropA(hwnd
, pixmap_prop
, (HANDLE
)data
->pixmap
);
622 if (!data
->gl_drawable
) return FALSE
;
624 TRACE("Created GL drawable 0x%lx, using FBConfigID 0x%lx\n",
625 data
->gl_drawable
, fbconfig_id
);
626 SetPropA(hwnd
, gl_drawable_prop
, (HANDLE
)data
->gl_drawable
);
629 data
->fbconfig_id
= fbconfig_id
;
630 SetPropA(hwnd
, fbconfig_id_prop
, (HANDLE
)data
->fbconfig_id
);
631 /* force DCE invalidation */
632 SetWindowPos( hwnd
, 0, 0, 0, 0, 0,
633 SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOMOVE
|
634 SWP_NOREDRAW
| SWP_DEFERERASE
| SWP_NOSENDCHANGING
| SWP_STATECHANGED
);
638 /***********************************************************************
641 static void sync_gl_drawable(struct x11drv_win_data
*data
)
643 int w
= data
->client_rect
.right
- data
->client_rect
.left
;
644 int h
= data
->client_rect
.bottom
- data
->client_rect
.top
;
652 TRACE("Resizing GL drawable 0x%lx to %dx%d\n", data
->gl_drawable
, w
, h
);
653 #ifdef SONAME_LIBXCOMPOSITE
657 XMoveResizeWindow(gdi_display
, data
->gl_drawable
, -w
, 0, w
, h
);
663 if (!(vis
= visual_from_fbconfig_id(data
->fbconfig_id
))) return;
666 pix
= XCreatePixmap(gdi_display
, root_window
, w
, h
, vis
->depth
);
669 ERR("Failed to create pixmap for offscreen rendering\n");
675 glxp
= create_glxpixmap(gdi_display
, vis
, pix
);
678 ERR("Failed to create drawable for offscreen rendering\n");
679 XFreePixmap(gdi_display
, pix
);
687 mark_drawable_dirty(data
->gl_drawable
, glxp
);
689 XFreePixmap(gdi_display
, data
->pixmap
);
690 destroy_glxpixmap(gdi_display
, data
->gl_drawable
);
691 TRACE( "Recreated GL drawable %lx to replace %lx\n", glxp
, data
->gl_drawable
);
694 data
->gl_drawable
= glxp
;
696 XFlush( gdi_display
);
699 SetPropA(data
->hwnd
, gl_drawable_prop
, (HANDLE
)data
->gl_drawable
);
700 SetPropA(data
->hwnd
, pixmap_prop
, (HANDLE
)data
->pixmap
);
704 /***********************************************************************
707 * fill the window changes structure
709 static int get_window_changes( XWindowChanges
*changes
, const RECT
*old
, const RECT
*new )
713 if (old
->right
- old
->left
!= new->right
- new->left
)
715 if ((changes
->width
= new->right
- new->left
) <= 0) changes
->width
= 1;
716 else if (changes
->width
> 65535) changes
->width
= 65535;
719 if (old
->bottom
- old
->top
!= new->bottom
- new->top
)
721 if ((changes
->height
= new->bottom
- new->top
) <= 0) changes
->height
= 1;
722 else if (changes
->height
> 65535) changes
->height
= 65535;
725 if (old
->left
!= new->left
)
727 changes
->x
= new->left
;
730 if (old
->top
!= new->top
)
732 changes
->y
= new->top
;
739 /***********************************************************************
742 static Window
create_icon_window( Display
*display
, struct x11drv_win_data
*data
)
744 XSetWindowAttributes attr
;
746 attr
.event_mask
= (ExposureMask
| KeyPressMask
| KeyReleaseMask
| PointerMotionMask
|
747 ButtonPressMask
| ButtonReleaseMask
| EnterWindowMask
);
748 attr
.bit_gravity
= NorthWestGravity
;
749 attr
.backing_store
= NotUseful
/*WhenMapped*/;
750 attr
.colormap
= X11DRV_PALETTE_PaletteXColormap
; /* Needed due to our visual */
753 data
->icon_window
= XCreateWindow( display
, root_window
, 0, 0,
754 GetSystemMetrics( SM_CXICON
),
755 GetSystemMetrics( SM_CYICON
),
758 CWEventMask
| CWBitGravity
| CWBackingStore
| CWColormap
, &attr
);
759 XSaveContext( display
, data
->icon_window
, winContext
, (char *)data
->hwnd
);
760 XFlush( display
); /* make sure the window exists before we start painting to it */
763 TRACE( "created %lx\n", data
->icon_window
);
764 SetPropA( data
->hwnd
, icon_window_prop
, (HANDLE
)data
->icon_window
);
765 return data
->icon_window
;
770 /***********************************************************************
771 * destroy_icon_window
773 static void destroy_icon_window( Display
*display
, struct x11drv_win_data
*data
)
775 if (!data
->icon_window
) return;
776 if (x11drv_thread_data()->cursor_window
== data
->icon_window
)
777 x11drv_thread_data()->cursor_window
= None
;
779 XDeleteContext( display
, data
->icon_window
, winContext
);
780 XDestroyWindow( display
, data
->icon_window
);
781 data
->icon_window
= 0;
783 RemovePropA( data
->hwnd
, icon_window_prop
);
787 /***********************************************************************
790 * Set the icon wm hints
792 static void set_icon_hints( Display
*display
, struct x11drv_win_data
*data
, HICON hIcon
)
794 XWMHints
*hints
= data
->wm_hints
;
796 if (data
->hWMIconBitmap
) DeleteObject( data
->hWMIconBitmap
);
797 if (data
->hWMIconMask
) DeleteObject( data
->hWMIconMask
);
798 data
->hWMIconBitmap
= 0;
799 data
->hWMIconMask
= 0;
803 if (!data
->icon_window
) create_icon_window( display
, data
);
804 hints
->icon_window
= data
->icon_window
;
805 hints
->flags
= (hints
->flags
& ~(IconPixmapHint
| IconMaskHint
)) | IconWindowHint
;
815 GetIconInfo(hIcon
, &ii
);
817 GetObjectA(ii
.hbmMask
, sizeof(bmMask
), &bmMask
);
820 rcMask
.right
= bmMask
.bmWidth
;
821 rcMask
.bottom
= bmMask
.bmHeight
;
823 hDC
= CreateCompatibleDC(0);
824 hbmOrig
= SelectObject(hDC
, ii
.hbmMask
);
825 InvertRect(hDC
, &rcMask
);
826 SelectObject(hDC
, ii
.hbmColor
); /* force the color bitmap to x11drv mode too */
827 SelectObject(hDC
, hbmOrig
);
830 data
->hWMIconBitmap
= ii
.hbmColor
;
831 data
->hWMIconMask
= ii
.hbmMask
;
833 hints
->icon_pixmap
= X11DRV_get_pixmap(data
->hWMIconBitmap
);
834 hints
->icon_mask
= X11DRV_get_pixmap(data
->hWMIconMask
);
835 destroy_icon_window( display
, data
);
836 hints
->flags
= (hints
->flags
& ~IconWindowHint
) | IconPixmapHint
| IconMaskHint
;
841 /***********************************************************************
844 * set the window size hints
846 static void set_size_hints( Display
*display
, struct x11drv_win_data
*data
, DWORD style
)
848 XSizeHints
* size_hints
;
850 if (!(size_hints
= XAllocSizeHints())) return;
852 size_hints
->win_gravity
= StaticGravity
;
853 size_hints
->flags
|= PWinGravity
;
855 /* don't update size hints if window is not in normal state */
856 if (!(style
& (WS_MINIMIZE
| WS_MAXIMIZE
)))
858 if (data
->hwnd
!= GetDesktopWindow()) /* don't force position of desktop */
860 size_hints
->x
= data
->whole_rect
.left
;
861 size_hints
->y
= data
->whole_rect
.top
;
862 size_hints
->flags
|= PPosition
;
865 if (!is_window_resizable( data
, style
))
867 size_hints
->max_width
= data
->whole_rect
.right
- data
->whole_rect
.left
;
868 size_hints
->max_height
= data
->whole_rect
.bottom
- data
->whole_rect
.top
;
869 size_hints
->min_width
= size_hints
->max_width
;
870 size_hints
->min_height
= size_hints
->max_height
;
871 size_hints
->flags
|= PMinSize
| PMaxSize
;
874 XSetWMNormalHints( display
, data
->whole_window
, size_hints
);
879 /***********************************************************************
882 * get the name of the current process for setting class hints
884 static char *get_process_name(void)
890 WCHAR module
[MAX_PATH
];
891 DWORD len
= GetModuleFileNameW( 0, module
, MAX_PATH
);
892 if (len
&& len
< MAX_PATH
)
895 WCHAR
*p
, *appname
= module
;
897 if ((p
= strrchrW( appname
, '/' ))) appname
= p
+ 1;
898 if ((p
= strrchrW( appname
, '\\' ))) appname
= p
+ 1;
899 len
= WideCharToMultiByte( CP_UNIXCP
, 0, appname
, -1, NULL
, 0, NULL
, NULL
);
900 if ((ptr
= HeapAlloc( GetProcessHeap(), 0, len
)))
902 WideCharToMultiByte( CP_UNIXCP
, 0, appname
, -1, ptr
, len
, NULL
, NULL
);
911 /***********************************************************************
912 * set_initial_wm_hints
914 * Set the window manager hints that don't change over the lifetime of a window.
916 static void set_initial_wm_hints( Display
*display
, struct x11drv_win_data
*data
)
921 XClassHint
*class_hints
;
922 char *process_name
= get_process_name();
928 protocols
[i
++] = x11drv_atom(WM_DELETE_WINDOW
);
929 protocols
[i
++] = x11drv_atom(_NET_WM_PING
);
930 if (use_take_focus
) protocols
[i
++] = x11drv_atom(WM_TAKE_FOCUS
);
931 XChangeProperty( display
, data
->whole_window
, x11drv_atom(WM_PROTOCOLS
),
932 XA_ATOM
, 32, PropModeReplace
, (unsigned char *)protocols
, i
);
935 if ((class_hints
= XAllocClassHint()))
937 static char wine
[] = "Wine";
939 class_hints
->res_name
= process_name
;
940 class_hints
->res_class
= wine
;
941 XSetClassHint( display
, data
->whole_window
, class_hints
);
942 XFree( class_hints
);
945 /* set the WM_CLIENT_MACHINE and WM_LOCALE_NAME properties */
946 XSetWMProperties(display
, data
->whole_window
, NULL
, NULL
, NULL
, 0, NULL
, NULL
, NULL
);
947 /* set the pid. together, these properties are needed so the window manager can kill us if we freeze */
949 XChangeProperty(display
, data
->whole_window
, x11drv_atom(_NET_WM_PID
),
950 XA_CARDINAL
, 32, PropModeReplace
, (unsigned char *)&i
, 1);
952 XChangeProperty( display
, data
->whole_window
, x11drv_atom(XdndAware
),
953 XA_ATOM
, 32, PropModeReplace
, (unsigned char*)&dndVersion
, 1 );
955 data
->wm_hints
= XAllocWMHints();
960 HICON icon
= (HICON
)SendMessageW( data
->hwnd
, WM_GETICON
, ICON_BIG
, 0 );
961 if (!icon
) icon
= (HICON
)GetClassLongPtrW( data
->hwnd
, GCLP_HICON
);
962 data
->wm_hints
->flags
= 0;
963 set_icon_hints( display
, data
, icon
);
968 /***********************************************************************
971 * Set the window manager hints for a newly-created window
973 static void set_wm_hints( Display
*display
, struct x11drv_win_data
*data
)
978 DWORD style
, ex_style
;
981 if (data
->hwnd
== GetDesktopWindow())
983 /* force some styles for the desktop to get the correct decorations */
984 style
= WS_POPUP
| WS_VISIBLE
| WS_CAPTION
| WS_SYSMENU
| WS_MINIMIZEBOX
;
985 ex_style
= WS_EX_APPWINDOW
;
990 style
= GetWindowLongW( data
->hwnd
, GWL_STYLE
);
991 ex_style
= GetWindowLongW( data
->hwnd
, GWL_EXSTYLE
);
992 owner
= get_window_owner( data
->hwnd
);
995 /* transient for hint */
998 Window owner_win
= X11DRV_get_whole_window( owner
);
1000 XSetTransientForHint( display
, data
->whole_window
, owner_win
);
1001 wine_tsx11_unlock();
1002 group_leader
= owner_win
;
1004 else group_leader
= data
->whole_window
;
1009 set_size_hints( display
, data
, style
);
1011 /* set the WM_WINDOW_TYPE */
1012 if (style
& WS_THICKFRAME
) window_type
= x11drv_atom(_NET_WM_WINDOW_TYPE_NORMAL
);
1013 else if (ex_style
& WS_EX_APPWINDOW
) window_type
= x11drv_atom(_NET_WM_WINDOW_TYPE_NORMAL
);
1014 else if (style
& WS_DLGFRAME
) window_type
= x11drv_atom(_NET_WM_WINDOW_TYPE_DIALOG
);
1015 else if (ex_style
& WS_EX_DLGMODALFRAME
) window_type
= x11drv_atom(_NET_WM_WINDOW_TYPE_DIALOG
);
1016 else if ((style
& WS_POPUP
) && owner
) window_type
= x11drv_atom(_NET_WM_WINDOW_TYPE_DIALOG
);
1017 #if 0 /* many window managers don't handle utility windows very well */
1018 else if (ex_style
& WS_EX_TOOLWINDOW
) window_type
= x11drv_atom(_NET_WM_WINDOW_TYPE_UTILITY
);
1020 else window_type
= x11drv_atom(_NET_WM_WINDOW_TYPE_NORMAL
);
1022 XChangeProperty(display
, data
->whole_window
, x11drv_atom(_NET_WM_WINDOW_TYPE
),
1023 XA_ATOM
, 32, PropModeReplace
, (unsigned char*)&window_type
, 1);
1025 mwm_hints
.flags
= MWM_HINTS_FUNCTIONS
| MWM_HINTS_DECORATIONS
;
1026 mwm_hints
.decorations
= get_mwm_decorations( data
, style
, ex_style
);
1027 mwm_hints
.functions
= MWM_FUNC_MOVE
;
1028 if (is_window_resizable( data
, style
)) mwm_hints
.functions
|= MWM_FUNC_RESIZE
;
1029 if (style
& WS_MINIMIZEBOX
) mwm_hints
.functions
|= MWM_FUNC_MINIMIZE
;
1030 if (style
& WS_MAXIMIZEBOX
) mwm_hints
.functions
|= MWM_FUNC_MAXIMIZE
;
1031 if (style
& WS_SYSMENU
) mwm_hints
.functions
|= MWM_FUNC_CLOSE
;
1033 XChangeProperty( display
, data
->whole_window
, x11drv_atom(_MOTIF_WM_HINTS
),
1034 x11drv_atom(_MOTIF_WM_HINTS
), 32, PropModeReplace
,
1035 (unsigned char*)&mwm_hints
, sizeof(mwm_hints
)/sizeof(long) );
1040 data
->wm_hints
->flags
|= InputHint
| StateHint
| WindowGroupHint
;
1041 data
->wm_hints
->input
= !use_take_focus
&& !(style
& WS_DISABLED
);
1042 data
->wm_hints
->initial_state
= (style
& WS_MINIMIZE
) ? IconicState
: NormalState
;
1043 data
->wm_hints
->window_group
= group_leader
;
1044 XSetWMHints( display
, data
->whole_window
, data
->wm_hints
);
1047 wine_tsx11_unlock();
1051 /***********************************************************************
1052 * update_net_wm_states
1054 void update_net_wm_states( Display
*display
, struct x11drv_win_data
*data
)
1056 static const unsigned int state_atoms
[NB_NET_WM_STATES
] =
1058 XATOM__NET_WM_STATE_FULLSCREEN
,
1059 XATOM__NET_WM_STATE_ABOVE
,
1060 XATOM__NET_WM_STATE_MAXIMIZED_VERT
,
1061 XATOM__NET_WM_STATE_SKIP_PAGER
,
1062 XATOM__NET_WM_STATE_SKIP_TASKBAR
1065 DWORD i
, style
, ex_style
, new_state
= 0;
1067 if (!data
->managed
) return;
1068 if (data
->whole_window
== root_window
) return;
1070 style
= GetWindowLongW( data
->hwnd
, GWL_STYLE
);
1071 if (data
->whole_rect
.left
<= 0 && data
->whole_rect
.right
>= screen_width
&&
1072 data
->whole_rect
.top
<= 0 && data
->whole_rect
.bottom
>= screen_height
)
1074 if ((style
& WS_MAXIMIZE
) && (style
& WS_CAPTION
) == WS_CAPTION
)
1075 new_state
|= (1 << NET_WM_STATE_MAXIMIZED
);
1076 else if (!(style
& WS_MINIMIZE
))
1077 new_state
|= (1 << NET_WM_STATE_FULLSCREEN
);
1079 else if (style
& WS_MAXIMIZE
)
1080 new_state
|= (1 << NET_WM_STATE_MAXIMIZED
);
1082 ex_style
= GetWindowLongW( data
->hwnd
, GWL_EXSTYLE
);
1083 if (ex_style
& WS_EX_TOPMOST
)
1084 new_state
|= (1 << NET_WM_STATE_ABOVE
);
1085 if (ex_style
& WS_EX_TOOLWINDOW
)
1086 new_state
|= (1 << NET_WM_STATE_SKIP_TASKBAR
) | (1 << NET_WM_STATE_SKIP_PAGER
);
1087 if (!(ex_style
& WS_EX_APPWINDOW
) && get_window_owner( data
->hwnd
))
1088 new_state
|= (1 << NET_WM_STATE_SKIP_TASKBAR
);
1090 if (!data
->mapped
) /* set the _NET_WM_STATE atom directly */
1092 Atom atoms
[NB_NET_WM_STATES
+1];
1095 for (i
= count
= 0; i
< NB_NET_WM_STATES
; i
++)
1097 if (!(new_state
& (1 << i
))) continue;
1098 TRACE( "setting wm state %u for unmapped window %p/%lx\n",
1099 i
, data
->hwnd
, data
->whole_window
);
1100 atoms
[count
++] = X11DRV_Atoms
[state_atoms
[i
] - FIRST_XATOM
];
1101 if (state_atoms
[i
] == XATOM__NET_WM_STATE_MAXIMIZED_VERT
)
1102 atoms
[count
++] = x11drv_atom(_NET_WM_STATE_MAXIMIZED_HORZ
);
1105 XChangeProperty( display
, data
->whole_window
, x11drv_atom(_NET_WM_STATE
), XA_ATOM
,
1106 32, PropModeReplace
, (unsigned char *)atoms
, count
);
1107 wine_tsx11_unlock();
1109 else /* ask the window manager to do it for us */
1113 xev
.xclient
.type
= ClientMessage
;
1114 xev
.xclient
.window
= data
->whole_window
;
1115 xev
.xclient
.message_type
= x11drv_atom(_NET_WM_STATE
);
1116 xev
.xclient
.serial
= 0;
1117 xev
.xclient
.display
= display
;
1118 xev
.xclient
.send_event
= True
;
1119 xev
.xclient
.format
= 32;
1120 xev
.xclient
.data
.l
[3] = 1;
1122 for (i
= 0; i
< NB_NET_WM_STATES
; i
++)
1124 if (!((data
->net_wm_state
^ new_state
) & (1 << i
))) continue; /* unchanged */
1126 TRACE( "setting wm state %u for window %p/%lx to %u prev %u\n",
1127 i
, data
->hwnd
, data
->whole_window
,
1128 (new_state
& (1 << i
)) != 0, (data
->net_wm_state
& (1 << i
)) != 0 );
1130 xev
.xclient
.data
.l
[0] = (new_state
& (1 << i
)) ? _NET_WM_STATE_ADD
: _NET_WM_STATE_REMOVE
;
1131 xev
.xclient
.data
.l
[1] = X11DRV_Atoms
[state_atoms
[i
] - FIRST_XATOM
];
1132 xev
.xclient
.data
.l
[2] = ((state_atoms
[i
] == XATOM__NET_WM_STATE_MAXIMIZED_VERT
) ?
1133 x11drv_atom(_NET_WM_STATE_MAXIMIZED_HORZ
) : 0);
1135 XSendEvent( display
, root_window
, False
,
1136 SubstructureRedirectMask
| SubstructureNotifyMask
, &xev
);
1137 wine_tsx11_unlock();
1140 data
->net_wm_state
= new_state
;
1144 /***********************************************************************
1147 static void set_xembed_flags( Display
*display
, struct x11drv_win_data
*data
, unsigned long flags
)
1149 unsigned long info
[2];
1151 info
[0] = 0; /* protocol version */
1154 XChangeProperty( display
, data
->whole_window
, x11drv_atom(_XEMBED_INFO
),
1155 x11drv_atom(_XEMBED_INFO
), 32, PropModeReplace
, (unsigned char*)info
, 2 );
1156 wine_tsx11_unlock();
1160 /***********************************************************************
1163 static void map_window( Display
*display
, struct x11drv_win_data
*data
, DWORD new_style
)
1165 TRACE( "win %p/%lx\n", data
->hwnd
, data
->whole_window
);
1167 remove_startup_notification( display
, data
->whole_window
);
1169 wait_for_withdrawn_state( display
, data
, TRUE
);
1171 if (!data
->embedded
)
1173 update_net_wm_states( display
, data
);
1174 sync_window_style( display
, data
);
1176 XMapWindow( display
, data
->whole_window
);
1177 wine_tsx11_unlock();
1179 else set_xembed_flags( display
, data
, XEMBED_MAPPED
);
1181 data
->mapped
= TRUE
;
1182 data
->iconic
= (new_style
& WS_MINIMIZE
) != 0;
1186 /***********************************************************************
1189 static void unmap_window( Display
*display
, struct x11drv_win_data
*data
)
1191 TRACE( "win %p/%lx\n", data
->hwnd
, data
->whole_window
);
1193 if (!data
->embedded
)
1195 wait_for_withdrawn_state( display
, data
, FALSE
);
1197 if (data
->managed
) XWithdrawWindow( display
, data
->whole_window
, DefaultScreen(display
) );
1198 else XUnmapWindow( display
, data
->whole_window
);
1199 wine_tsx11_unlock();
1201 else set_xembed_flags( display
, data
, 0 );
1203 data
->mapped
= FALSE
;
1204 data
->net_wm_state
= 0;
1208 /***********************************************************************
1209 * make_window_embedded
1211 void make_window_embedded( Display
*display
, struct x11drv_win_data
*data
)
1215 /* the window cannot be mapped before being embedded */
1216 unmap_window( display
, data
);
1217 data
->embedded
= TRUE
;
1218 map_window( display
, data
, 0 );
1222 data
->embedded
= TRUE
;
1223 set_xembed_flags( display
, data
, 0 );
1228 /***********************************************************************
1229 * X11DRV_window_to_X_rect
1231 * Convert a rect from client to X window coordinates
1233 static void X11DRV_window_to_X_rect( struct x11drv_win_data
*data
, RECT
*rect
)
1237 if (!data
->managed
) return;
1238 if (IsRectEmpty( rect
)) return;
1240 get_x11_rect_offset( data
, &rc
);
1242 rect
->left
-= rc
.left
;
1243 rect
->right
-= rc
.right
;
1244 rect
->top
-= rc
.top
;
1245 rect
->bottom
-= rc
.bottom
;
1246 if (rect
->top
>= rect
->bottom
) rect
->bottom
= rect
->top
+ 1;
1247 if (rect
->left
>= rect
->right
) rect
->right
= rect
->left
+ 1;
1251 /***********************************************************************
1252 * X11DRV_X_to_window_rect
1254 * Opposite of X11DRV_window_to_X_rect
1256 void X11DRV_X_to_window_rect( struct x11drv_win_data
*data
, RECT
*rect
)
1260 if (!data
->managed
) return;
1261 if (IsRectEmpty( rect
)) return;
1263 get_x11_rect_offset( data
, &rc
);
1265 rect
->left
+= rc
.left
;
1266 rect
->right
+= rc
.right
;
1267 rect
->top
+= rc
.top
;
1268 rect
->bottom
+= rc
.bottom
;
1269 if (rect
->top
>= rect
->bottom
) rect
->bottom
= rect
->top
+ 1;
1270 if (rect
->left
>= rect
->right
) rect
->right
= rect
->left
+ 1;
1274 /***********************************************************************
1275 * sync_window_position
1277 * Synchronize the X window position with the Windows one
1279 static void sync_window_position( Display
*display
, struct x11drv_win_data
*data
,
1280 UINT swp_flags
, const RECT
*old_window_rect
,
1281 const RECT
*old_whole_rect
, const RECT
*old_client_rect
)
1283 DWORD style
= GetWindowLongW( data
->hwnd
, GWL_STYLE
);
1284 XWindowChanges changes
;
1285 unsigned int mask
= 0;
1287 if (data
->managed
&& data
->iconic
) return;
1289 /* resizing a managed maximized window is not allowed */
1290 if (!(style
& WS_MAXIMIZE
) || !data
->managed
)
1292 changes
.width
= data
->whole_rect
.right
- data
->whole_rect
.left
;
1293 changes
.height
= data
->whole_rect
.bottom
- data
->whole_rect
.top
;
1294 /* if window rect is empty force size to 1x1 */
1295 if (changes
.width
<= 0 || changes
.height
<= 0) changes
.width
= changes
.height
= 1;
1296 if (changes
.width
> 65535) changes
.width
= 65535;
1297 if (changes
.height
> 65535) changes
.height
= 65535;
1298 mask
|= CWWidth
| CWHeight
;
1301 /* only the size is allowed to change for the desktop window */
1302 if (data
->whole_window
!= root_window
)
1304 changes
.x
= data
->whole_rect
.left
- virtual_screen_rect
.left
;
1305 changes
.y
= data
->whole_rect
.top
- virtual_screen_rect
.top
;
1309 if (!(swp_flags
& SWP_NOZORDER
) || (swp_flags
& SWP_SHOWWINDOW
))
1311 /* find window that this one must be after */
1312 HWND prev
= GetWindow( data
->hwnd
, GW_HWNDPREV
);
1313 while (prev
&& !(GetWindowLongW( prev
, GWL_STYLE
) & WS_VISIBLE
))
1314 prev
= GetWindow( prev
, GW_HWNDPREV
);
1315 if (!prev
) /* top child */
1317 changes
.stack_mode
= Above
;
1318 mask
|= CWStackMode
;
1320 /* should use stack_mode Below but most window managers don't get it right */
1321 /* and Above with a sibling doesn't work so well either, so we ignore it */
1325 set_size_hints( display
, data
, style
);
1326 data
->configure_serial
= NextRequest( display
);
1327 XReconfigureWMWindow( display
, data
->whole_window
,
1328 DefaultScreen(display
), mask
, &changes
);
1329 #ifdef HAVE_LIBXSHAPE
1332 int old_x_offset
= old_window_rect
->left
- old_whole_rect
->left
;
1333 int old_y_offset
= old_window_rect
->top
- old_whole_rect
->top
;
1334 int new_x_offset
= data
->window_rect
.left
- data
->whole_rect
.left
;
1335 int new_y_offset
= data
->window_rect
.top
- data
->whole_rect
.top
;
1336 if (old_x_offset
!= new_x_offset
|| old_y_offset
!= new_y_offset
)
1337 XShapeOffsetShape( display
, data
->whole_window
, ShapeBounding
,
1338 new_x_offset
- old_x_offset
, new_y_offset
- old_y_offset
);
1341 wine_tsx11_unlock();
1343 TRACE( "win %p/%lx pos %d,%d,%dx%d after %lx changes=%x serial=%lu\n",
1344 data
->hwnd
, data
->whole_window
, data
->whole_rect
.left
, data
->whole_rect
.top
,
1345 data
->whole_rect
.right
- data
->whole_rect
.left
,
1346 data
->whole_rect
.bottom
- data
->whole_rect
.top
,
1347 changes
.sibling
, mask
, data
->configure_serial
);
1351 /***********************************************************************
1352 * sync_client_position
1354 * Synchronize the X client window position with the Windows one
1356 static void sync_client_position( Display
*display
, struct x11drv_win_data
*data
,
1357 UINT swp_flags
, const RECT
*old_client_rect
,
1358 const RECT
*old_whole_rect
)
1361 XWindowChanges changes
;
1362 RECT old
= *old_client_rect
;
1363 RECT
new = data
->client_rect
;
1365 OffsetRect( &old
, -old_whole_rect
->left
, -old_whole_rect
->top
);
1366 OffsetRect( &new, -data
->whole_rect
.left
, -data
->whole_rect
.top
);
1367 if (!(mask
= get_window_changes( &changes
, &old
, &new ))) return;
1369 if (data
->client_window
)
1371 TRACE( "setting client win %lx pos %d,%d,%dx%d changes=%x\n",
1372 data
->client_window
, new.left
, new.top
,
1373 new.right
- new.left
, new.bottom
- new.top
, mask
);
1375 XConfigureWindow( display
, data
->client_window
, mask
, &changes
);
1376 wine_tsx11_unlock();
1379 if (data
->gl_drawable
&& (mask
& (CWWidth
|CWHeight
))) sync_gl_drawable( data
);
1383 /***********************************************************************
1386 * Move the window bits when a window is moved.
1388 static void move_window_bits( struct x11drv_win_data
*data
, const RECT
*old_rect
, const RECT
*new_rect
,
1389 const RECT
*old_client_rect
)
1391 RECT src_rect
= *old_rect
;
1392 RECT dst_rect
= *new_rect
;
1393 HDC hdc_src
, hdc_dst
;
1398 if (!data
->whole_window
)
1400 OffsetRect( &dst_rect
, -data
->window_rect
.left
, -data
->window_rect
.top
);
1401 parent
= GetAncestor( data
->hwnd
, GA_PARENT
);
1402 hdc_src
= GetDCEx( parent
, 0, DCX_CACHE
);
1403 hdc_dst
= GetDCEx( data
->hwnd
, 0, DCX_CACHE
| DCX_WINDOW
);
1407 OffsetRect( &dst_rect
, -data
->client_rect
.left
, -data
->client_rect
.top
);
1408 /* make src rect relative to the old position of the window */
1409 OffsetRect( &src_rect
, -old_client_rect
->left
, -old_client_rect
->top
);
1410 if (dst_rect
.left
== src_rect
.left
&& dst_rect
.top
== src_rect
.top
) return;
1411 hdc_src
= hdc_dst
= GetDCEx( data
->hwnd
, 0, DCX_CACHE
);
1414 code
= X11DRV_START_EXPOSURES
;
1415 ExtEscape( hdc_dst
, X11DRV_ESCAPE
, sizeof(code
), (LPSTR
)&code
, 0, NULL
);
1417 TRACE( "copying bits for win %p/%lx/%lx %s -> %s\n",
1418 data
->hwnd
, data
->whole_window
, data
->client_window
,
1419 wine_dbgstr_rect(&src_rect
), wine_dbgstr_rect(&dst_rect
) );
1420 BitBlt( hdc_dst
, dst_rect
.left
, dst_rect
.top
,
1421 dst_rect
.right
- dst_rect
.left
, dst_rect
.bottom
- dst_rect
.top
,
1422 hdc_src
, src_rect
.left
, src_rect
.top
, SRCCOPY
);
1424 code
= X11DRV_END_EXPOSURES
;
1425 ExtEscape( hdc_dst
, X11DRV_ESCAPE
, sizeof(code
), (LPSTR
)&code
, sizeof(rgn
), (LPSTR
)&rgn
);
1427 ReleaseDC( data
->hwnd
, hdc_dst
);
1428 if (hdc_src
!= hdc_dst
) ReleaseDC( parent
, hdc_src
);
1432 if (!data
->whole_window
)
1434 /* map region to client rect since we are using DCX_WINDOW */
1435 OffsetRgn( rgn
, data
->window_rect
.left
- data
->client_rect
.left
,
1436 data
->window_rect
.top
- data
->client_rect
.top
);
1437 RedrawWindow( data
->hwnd
, NULL
, rgn
,
1438 RDW_INVALIDATE
| RDW_FRAME
| RDW_ERASE
| RDW_ALLCHILDREN
);
1440 else RedrawWindow( data
->hwnd
, NULL
, rgn
, RDW_INVALIDATE
| RDW_ERASE
| RDW_ALLCHILDREN
);
1441 DeleteObject( rgn
);
1446 /**********************************************************************
1447 * create_whole_window
1449 * Create the whole X window for a given window
1451 static Window
create_whole_window( Display
*display
, struct x11drv_win_data
*data
)
1454 XSetWindowAttributes attr
;
1458 DWORD layered_flags
;
1461 if (!data
->managed
&& is_window_managed( data
->hwnd
, SWP_NOACTIVATE
, &data
->window_rect
))
1463 TRACE( "making win %p/%lx managed\n", data
->hwnd
, data
->whole_window
);
1464 data
->managed
= TRUE
;
1465 SetPropA( data
->hwnd
, managed_prop
, (HANDLE
)1 );
1468 if ((win_rgn
= CreateRectRgn( 0, 0, 0, 0 )) &&
1469 GetWindowRgn( data
->hwnd
, win_rgn
) == ERROR
)
1471 DeleteObject( win_rgn
);
1474 data
->shaped
= (win_rgn
!= 0);
1476 mask
= get_window_attributes( display
, data
, &attr
);
1478 data
->whole_rect
= data
->window_rect
;
1479 X11DRV_window_to_X_rect( data
, &data
->whole_rect
);
1480 if (!(cx
= data
->whole_rect
.right
- data
->whole_rect
.left
)) cx
= 1;
1481 else if (cx
> 65535) cx
= 65535;
1482 if (!(cy
= data
->whole_rect
.bottom
- data
->whole_rect
.top
)) cy
= 1;
1483 else if (cy
> 65535) cy
= 65535;
1486 data
->whole_window
= XCreateWindow( display
, root_window
,
1487 data
->whole_rect
.left
- virtual_screen_rect
.left
,
1488 data
->whole_rect
.top
- virtual_screen_rect
.top
,
1489 cx
, cy
, 0, screen_depth
, InputOutput
,
1490 visual
, mask
, &attr
);
1492 if (data
->whole_window
) XSaveContext( display
, data
->whole_window
, winContext
, (char *)data
->hwnd
);
1493 wine_tsx11_unlock();
1495 if (!data
->whole_window
) goto done
;
1497 if (!create_client_window( display
, data
, NULL
))
1500 XDeleteContext( display
, data
->whole_window
, winContext
);
1501 XDestroyWindow( display
, data
->whole_window
);
1502 data
->whole_window
= 0;
1503 wine_tsx11_unlock();
1507 set_initial_wm_hints( display
, data
);
1508 set_wm_hints( display
, data
);
1510 SetPropA( data
->hwnd
, whole_window_prop
, (HANDLE
)data
->whole_window
);
1512 /* set the window text */
1513 if (!InternalGetWindowText( data
->hwnd
, text
, sizeof(text
)/sizeof(WCHAR
) )) text
[0] = 0;
1514 sync_window_text( display
, data
->whole_window
, text
);
1516 /* set the window region */
1517 if (win_rgn
) sync_window_region( display
, data
, win_rgn
);
1519 /* set the window opacity */
1520 if (!GetLayeredWindowAttributes( data
->hwnd
, &key
, &alpha
, &layered_flags
)) layered_flags
= 0;
1521 sync_window_opacity( display
, data
->whole_window
, key
, alpha
, layered_flags
);
1524 XFlush( display
); /* make sure the window exists before we start painting to it */
1525 wine_tsx11_unlock();
1527 if (win_rgn
) DeleteObject( win_rgn
);
1528 return data
->whole_window
;
1532 /**********************************************************************
1533 * destroy_whole_window
1535 * Destroy the whole X window for a given window.
1537 static void destroy_whole_window( Display
*display
, struct x11drv_win_data
*data
, BOOL already_destroyed
)
1539 struct x11drv_thread_data
*thread_data
= x11drv_thread_data();
1541 if (!data
->whole_window
) return;
1543 TRACE( "win %p xwin %lx/%lx\n", data
->hwnd
, data
->whole_window
, data
->client_window
);
1544 if (thread_data
->cursor_window
== data
->whole_window
||
1545 thread_data
->cursor_window
== data
->client_window
)
1546 thread_data
->cursor_window
= None
;
1548 XDeleteContext( display
, data
->whole_window
, winContext
);
1549 XDeleteContext( display
, data
->client_window
, winContext
);
1550 if (!already_destroyed
) XDestroyWindow( display
, data
->whole_window
);
1551 data
->whole_window
= data
->client_window
= 0;
1552 data
->wm_state
= WithdrawnState
;
1553 data
->net_wm_state
= 0;
1554 data
->mapped
= FALSE
;
1557 XUnsetICFocus( data
->xic
);
1558 XDestroyIC( data
->xic
);
1561 /* Outlook stops processing messages after destroying a dialog, so we need an explicit flush */
1563 XFree( data
->wm_hints
);
1564 data
->wm_hints
= NULL
;
1565 wine_tsx11_unlock();
1566 RemovePropA( data
->hwnd
, whole_window_prop
);
1567 RemovePropA( data
->hwnd
, client_window_prop
);
1571 /*****************************************************************
1572 * SetWindowText (X11DRV.@)
1574 void CDECL
X11DRV_SetWindowText( HWND hwnd
, LPCWSTR text
)
1578 if ((win
= X11DRV_get_whole_window( hwnd
)) && win
!= DefaultRootWindow(gdi_display
))
1580 Display
*display
= thread_init_display();
1581 sync_window_text( display
, win
, text
);
1586 /***********************************************************************
1587 * SetWindowStyle (X11DRV.@)
1589 * Update the X state of a window to reflect a style change
1591 void CDECL
X11DRV_SetWindowStyle( HWND hwnd
, INT offset
, STYLESTRUCT
*style
)
1593 struct x11drv_win_data
*data
;
1596 if (hwnd
== GetDesktopWindow()) return;
1597 changed
= style
->styleNew
^ style
->styleOld
;
1599 if (offset
== GWL_STYLE
&& (changed
& WS_VISIBLE
) && (style
->styleNew
& WS_VISIBLE
))
1601 /* we don't unmap windows, that causes trouble with the window manager */
1602 if (!(data
= X11DRV_get_win_data( hwnd
)) &&
1603 !(data
= X11DRV_create_win_data( hwnd
))) return;
1605 if (data
->whole_window
&& is_window_rect_mapped( &data
->window_rect
))
1607 Display
*display
= thread_display();
1608 set_wm_hints( display
, data
);
1609 if (!data
->mapped
) map_window( display
, data
, style
->styleNew
);
1613 if (offset
== GWL_STYLE
&& (changed
& WS_DISABLED
))
1615 data
= X11DRV_get_win_data( hwnd
);
1616 if (data
&& data
->wm_hints
)
1619 data
->wm_hints
->input
= !(style
->styleNew
& WS_DISABLED
);
1620 XSetWMHints( thread_display(), data
->whole_window
, data
->wm_hints
);
1621 wine_tsx11_unlock();
1625 if (offset
== GWL_EXSTYLE
&& (changed
& WS_EX_LAYERED
))
1627 /* changing WS_EX_LAYERED resets attributes */
1628 if ((data
= X11DRV_get_win_data( hwnd
)) && data
->whole_window
)
1629 sync_window_opacity( thread_display(), data
->whole_window
, 0, 0, 0 );
1634 /***********************************************************************
1635 * DestroyWindow (X11DRV.@)
1637 void CDECL
X11DRV_DestroyWindow( HWND hwnd
)
1639 struct x11drv_thread_data
*thread_data
= x11drv_thread_data();
1640 struct x11drv_win_data
*data
;
1642 if (!(data
= X11DRV_get_win_data( hwnd
))) return;
1647 destroy_glxpixmap(gdi_display
, data
->gl_drawable
);
1648 XFreePixmap(gdi_display
, data
->pixmap
);
1649 wine_tsx11_unlock();
1651 else if (data
->gl_drawable
)
1654 XDestroyWindow(gdi_display
, data
->gl_drawable
);
1655 wine_tsx11_unlock();
1658 destroy_whole_window( thread_data
->display
, data
, FALSE
);
1659 destroy_icon_window( thread_data
->display
, data
);
1664 XFreeColormap( thread_data
->display
, data
->colormap
);
1665 wine_tsx11_unlock();
1668 if (thread_data
->last_focus
== hwnd
) thread_data
->last_focus
= 0;
1669 if (data
->hWMIconBitmap
) DeleteObject( data
->hWMIconBitmap
);
1670 if (data
->hWMIconMask
) DeleteObject( data
->hWMIconMask
);
1672 XDeleteContext( thread_data
->display
, (XID
)hwnd
, win_data_context
);
1673 wine_tsx11_unlock();
1674 HeapFree( GetProcessHeap(), 0, data
);
1678 /***********************************************************************
1679 * X11DRV_DestroyNotify
1681 void X11DRV_DestroyNotify( HWND hwnd
, XEvent
*event
)
1683 Display
*display
= event
->xdestroywindow
.display
;
1684 struct x11drv_win_data
*data
;
1686 if (!(data
= X11DRV_get_win_data( hwnd
))) return;
1688 FIXME( "window %p/%lx destroyed from the outside\n", hwnd
, data
->whole_window
);
1689 destroy_whole_window( display
, data
, TRUE
);
1693 static struct x11drv_win_data
*alloc_win_data( Display
*display
, HWND hwnd
)
1695 struct x11drv_win_data
*data
;
1697 if ((data
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*data
))))
1701 if (!winContext
) winContext
= XUniqueContext();
1702 if (!win_data_context
) win_data_context
= XUniqueContext();
1703 XSaveContext( display
, (XID
)hwnd
, win_data_context
, (char *)data
);
1704 wine_tsx11_unlock();
1710 /* initialize the desktop window id in the desktop manager process */
1711 static struct x11drv_win_data
*create_desktop_win_data( Display
*display
, HWND hwnd
)
1713 struct x11drv_win_data
*data
;
1715 if (!(data
= alloc_win_data( display
, hwnd
))) return NULL
;
1716 data
->whole_window
= data
->client_window
= root_window
;
1717 data
->managed
= TRUE
;
1718 SetPropA( data
->hwnd
, managed_prop
, (HANDLE
)1 );
1719 SetPropA( data
->hwnd
, whole_window_prop
, (HANDLE
)root_window
);
1720 SetPropA( data
->hwnd
, client_window_prop
, (HANDLE
)root_window
);
1721 set_initial_wm_hints( display
, data
);
1725 /**********************************************************************
1726 * CreateDesktopWindow (X11DRV.@)
1728 BOOL CDECL
X11DRV_CreateDesktopWindow( HWND hwnd
)
1730 unsigned int width
, height
;
1732 /* retrieve the real size of the desktop */
1733 SERVER_START_REQ( get_window_rectangles
)
1735 req
->handle
= wine_server_user_handle( hwnd
);
1736 wine_server_call( req
);
1737 width
= reply
->window
.right
- reply
->window
.left
;
1738 height
= reply
->window
.bottom
- reply
->window
.top
;
1742 if (!width
&& !height
) /* not initialized yet */
1744 SERVER_START_REQ( set_window_pos
)
1746 req
->handle
= wine_server_user_handle( hwnd
);
1748 req
->flags
= SWP_NOZORDER
;
1749 req
->window
.left
= virtual_screen_rect
.left
;
1750 req
->window
.top
= virtual_screen_rect
.top
;
1751 req
->window
.right
= virtual_screen_rect
.right
;
1752 req
->window
.bottom
= virtual_screen_rect
.bottom
;
1753 req
->client
= req
->window
;
1754 wine_server_call( req
);
1760 Window win
= (Window
)GetPropA( hwnd
, whole_window_prop
);
1761 if (win
&& win
!= root_window
) X11DRV_init_desktop( win
, width
, height
);
1767 /**********************************************************************
1768 * CreateWindow (X11DRV.@)
1770 BOOL CDECL
X11DRV_CreateWindow( HWND hwnd
)
1772 if (hwnd
== GetDesktopWindow() && root_window
!= DefaultRootWindow( gdi_display
))
1774 Display
*display
= thread_init_display();
1776 /* the desktop win data can't be created lazily */
1777 if (!create_desktop_win_data( display
, hwnd
)) return FALSE
;
1783 /***********************************************************************
1784 * X11DRV_get_win_data
1786 * Return the X11 data structure associated with a window.
1788 struct x11drv_win_data
*X11DRV_get_win_data( HWND hwnd
)
1790 struct x11drv_thread_data
*thread_data
= x11drv_thread_data();
1793 if (!thread_data
) return NULL
;
1794 if (!hwnd
) return NULL
;
1795 if (XFindContext( thread_data
->display
, (XID
)hwnd
, win_data_context
, &data
)) data
= NULL
;
1796 return (struct x11drv_win_data
*)data
;
1800 /***********************************************************************
1801 * X11DRV_create_win_data
1803 * Create an X11 data window structure for an existing window.
1805 struct x11drv_win_data
*X11DRV_create_win_data( HWND hwnd
)
1808 struct x11drv_win_data
*data
;
1811 if (!(parent
= GetAncestor( hwnd
, GA_PARENT
))) return NULL
; /* desktop */
1813 /* don't create win data for HWND_MESSAGE windows */
1814 if (parent
!= GetDesktopWindow() && !GetAncestor( parent
, GA_PARENT
)) return NULL
;
1816 display
= thread_init_display();
1817 if (!(data
= alloc_win_data( display
, hwnd
))) return NULL
;
1819 GetWindowRect( hwnd
, &data
->window_rect
);
1820 MapWindowPoints( 0, parent
, (POINT
*)&data
->window_rect
, 2 );
1821 data
->whole_rect
= data
->window_rect
;
1822 GetClientRect( hwnd
, &data
->client_rect
);
1823 MapWindowPoints( hwnd
, parent
, (POINT
*)&data
->client_rect
, 2 );
1825 if (parent
== GetDesktopWindow())
1827 if (!create_whole_window( display
, data
))
1829 HeapFree( GetProcessHeap(), 0, data
);
1832 TRACE( "win %p/%lx/%lx window %s whole %s client %s\n",
1833 hwnd
, data
->whole_window
, data
->client_window
, wine_dbgstr_rect( &data
->window_rect
),
1834 wine_dbgstr_rect( &data
->whole_rect
), wine_dbgstr_rect( &data
->client_rect
));
1840 /***********************************************************************
1841 * X11DRV_get_whole_window
1843 * Return the X window associated with the full area of a window
1845 Window
X11DRV_get_whole_window( HWND hwnd
)
1847 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
1851 if (hwnd
== GetDesktopWindow()) return root_window
;
1852 return (Window
)GetPropA( hwnd
, whole_window_prop
);
1854 return data
->whole_window
;
1858 /***********************************************************************
1859 * X11DRV_get_client_window
1861 * Return the X window associated with the client area of a window
1863 static Window
X11DRV_get_client_window( HWND hwnd
)
1865 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
1869 if (hwnd
== GetDesktopWindow()) return root_window
;
1870 return (Window
)GetPropA( hwnd
, client_window_prop
);
1872 return data
->client_window
;
1876 /***********************************************************************
1879 * Return the X input context associated with a window
1881 XIC
X11DRV_get_ic( HWND hwnd
)
1883 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
1886 if (!data
) return 0;
1887 if (data
->xic
) return data
->xic
;
1888 if (!(xim
= x11drv_thread_data()->xim
)) return 0;
1889 return X11DRV_CreateIC( xim
, data
);
1893 /***********************************************************************
1894 * X11DRV_GetDC (X11DRV.@)
1896 void CDECL
X11DRV_GetDC( HDC hdc
, HWND hwnd
, HWND top
, const RECT
*win_rect
,
1897 const RECT
*top_rect
, DWORD flags
)
1899 struct x11drv_escape_set_drawable escape
;
1900 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
1902 escape
.code
= X11DRV_SET_DRAWABLE
;
1903 escape
.mode
= IncludeInferiors
;
1904 escape
.fbconfig_id
= 0;
1905 escape
.gl_drawable
= 0;
1907 escape
.gl_copy
= FALSE
;
1909 if (top
== hwnd
&& data
&& IsIconic( hwnd
) && data
->icon_window
)
1911 escape
.drawable
= data
->icon_window
;
1913 else if (top
== hwnd
)
1915 escape
.fbconfig_id
= data
? data
->fbconfig_id
: (XID
)GetPropA( hwnd
, fbconfig_id_prop
);
1916 /* GL draws to the client area even for window DCs */
1917 escape
.gl_drawable
= data
? data
->client_window
: X11DRV_get_client_window( hwnd
);
1918 if (flags
& DCX_WINDOW
)
1919 escape
.drawable
= data
? data
->whole_window
: X11DRV_get_whole_window( hwnd
);
1921 escape
.drawable
= escape
.gl_drawable
;
1925 escape
.drawable
= X11DRV_get_client_window( top
);
1926 escape
.fbconfig_id
= data
? data
->fbconfig_id
: (XID
)GetPropA( hwnd
, fbconfig_id_prop
);
1927 escape
.gl_drawable
= data
? data
->gl_drawable
: (Drawable
)GetPropA( hwnd
, gl_drawable_prop
);
1928 escape
.pixmap
= data
? data
->pixmap
: (Pixmap
)GetPropA( hwnd
, pixmap_prop
);
1929 escape
.gl_copy
= (escape
.gl_drawable
!= 0);
1930 if (flags
& DCX_CLIPCHILDREN
) escape
.mode
= ClipByChildren
;
1933 escape
.dc_rect
.left
= win_rect
->left
- top_rect
->left
;
1934 escape
.dc_rect
.top
= win_rect
->top
- top_rect
->top
;
1935 escape
.dc_rect
.right
= win_rect
->right
- top_rect
->left
;
1936 escape
.dc_rect
.bottom
= win_rect
->bottom
- top_rect
->top
;
1937 escape
.drawable_rect
.left
= top_rect
->left
;
1938 escape
.drawable_rect
.top
= top_rect
->top
;
1939 escape
.drawable_rect
.right
= top_rect
->right
;
1940 escape
.drawable_rect
.bottom
= top_rect
->bottom
;
1942 ExtEscape( hdc
, X11DRV_ESCAPE
, sizeof(escape
), (LPSTR
)&escape
, 0, NULL
);
1946 /***********************************************************************
1947 * X11DRV_ReleaseDC (X11DRV.@)
1949 void CDECL
X11DRV_ReleaseDC( HWND hwnd
, HDC hdc
)
1951 struct x11drv_escape_set_drawable escape
;
1953 escape
.code
= X11DRV_SET_DRAWABLE
;
1954 escape
.drawable
= root_window
;
1955 escape
.mode
= IncludeInferiors
;
1956 escape
.drawable_rect
= virtual_screen_rect
;
1957 SetRect( &escape
.dc_rect
, 0, 0, virtual_screen_rect
.right
- virtual_screen_rect
.left
,
1958 virtual_screen_rect
.bottom
- virtual_screen_rect
.top
);
1959 escape
.fbconfig_id
= 0;
1960 escape
.gl_drawable
= 0;
1962 ExtEscape( hdc
, X11DRV_ESCAPE
, sizeof(escape
), (LPSTR
)&escape
, 0, NULL
);
1966 /***********************************************************************
1967 * SetCapture (X11DRV.@)
1969 void CDECL
X11DRV_SetCapture( HWND hwnd
, UINT flags
)
1971 struct x11drv_thread_data
*thread_data
= x11drv_thread_data();
1973 if (!thread_data
) return;
1974 if (!(flags
& (GUI_INMOVESIZE
| GUI_INMENUMODE
))) return;
1978 Window grab_win
= X11DRV_get_client_window( GetAncestor( hwnd
, GA_ROOT
) );
1980 if (!grab_win
) return;
1982 XFlush( gdi_display
);
1983 XGrabPointer( thread_data
->display
, grab_win
, False
,
1984 PointerMotionMask
| ButtonPressMask
| ButtonReleaseMask
,
1985 GrabModeAsync
, GrabModeAsync
, None
, None
, CurrentTime
);
1986 wine_tsx11_unlock();
1987 thread_data
->grab_window
= grab_win
;
1989 else /* release capture */
1992 XFlush( gdi_display
);
1993 XUngrabPointer( thread_data
->display
, CurrentTime
);
1994 XFlush( thread_data
->display
);
1995 wine_tsx11_unlock();
1996 thread_data
->grab_window
= None
;
2001 /*****************************************************************
2002 * SetParent (X11DRV.@)
2004 void CDECL
X11DRV_SetParent( HWND hwnd
, HWND parent
, HWND old_parent
)
2006 Display
*display
= thread_display();
2007 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
2010 if (parent
== old_parent
) return;
2012 if (parent
!= GetDesktopWindow()) /* a child window */
2014 if (old_parent
== GetDesktopWindow())
2016 /* destroy the old X windows */
2017 destroy_whole_window( display
, data
, FALSE
);
2018 destroy_icon_window( display
, data
);
2021 data
->managed
= FALSE
;
2022 RemovePropA( data
->hwnd
, managed_prop
);
2026 else /* new top level window */
2028 /* FIXME: we ignore errors since we can't really recover anyway */
2029 create_whole_window( display
, data
);
2034 /*****************************************************************
2035 * SetFocus (X11DRV.@)
2039 void CDECL
X11DRV_SetFocus( HWND hwnd
)
2041 Display
*display
= thread_display();
2042 struct x11drv_win_data
*data
;
2043 XWindowChanges changes
;
2045 if (!(hwnd
= GetAncestor( hwnd
, GA_ROOT
))) return;
2046 if (!(data
= X11DRV_get_win_data( hwnd
))) return;
2047 if (data
->managed
|| !data
->whole_window
) return;
2049 /* Set X focus and install colormap */
2051 changes
.stack_mode
= Above
;
2052 XConfigureWindow( display
, data
->whole_window
, CWStackMode
, &changes
);
2053 /* we must not use CurrentTime (ICCCM), so try to use last message time instead */
2054 /* FIXME: this is not entirely correct */
2055 XSetInputFocus( display
, data
->whole_window
, RevertToParent
,
2057 GetMessageTime() - EVENT_x11_time_to_win32_time(0));
2058 wine_tsx11_unlock();
2062 /***********************************************************************
2063 * WindowPosChanging (X11DRV.@)
2065 void CDECL
X11DRV_WindowPosChanging( HWND hwnd
, HWND insert_after
, UINT swp_flags
,
2066 const RECT
*window_rect
, const RECT
*client_rect
, RECT
*visible_rect
)
2068 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
2069 DWORD style
= GetWindowLongW( hwnd
, GWL_STYLE
);
2073 /* create the win data if the window is being made visible */
2074 if (!(style
& WS_VISIBLE
) && !(swp_flags
& SWP_SHOWWINDOW
)) return;
2075 if (!(data
= X11DRV_create_win_data( hwnd
))) return;
2078 /* check if we need to switch the window to managed */
2079 if (!data
->managed
&& data
->whole_window
&& is_window_managed( hwnd
, swp_flags
, window_rect
))
2081 TRACE( "making win %p/%lx managed\n", hwnd
, data
->whole_window
);
2082 if (data
->mapped
) unmap_window( thread_display(), data
);
2083 data
->managed
= TRUE
;
2084 SetPropA( hwnd
, managed_prop
, (HANDLE
)1 );
2087 *visible_rect
= *window_rect
;
2088 X11DRV_window_to_X_rect( data
, visible_rect
);
2092 /***********************************************************************
2093 * WindowPosChanged (X11DRV.@)
2095 void CDECL
X11DRV_WindowPosChanged( HWND hwnd
, HWND insert_after
, UINT swp_flags
,
2096 const RECT
*rectWindow
, const RECT
*rectClient
,
2097 const RECT
*visible_rect
, const RECT
*valid_rects
)
2099 struct x11drv_thread_data
*thread_data
;
2101 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
2102 DWORD new_style
= GetWindowLongW( hwnd
, GWL_STYLE
);
2103 RECT old_window_rect
, old_whole_rect
, old_client_rect
;
2108 thread_data
= x11drv_thread_data();
2109 display
= thread_data
->display
;
2111 old_window_rect
= data
->window_rect
;
2112 old_whole_rect
= data
->whole_rect
;
2113 old_client_rect
= data
->client_rect
;
2114 data
->window_rect
= *rectWindow
;
2115 data
->whole_rect
= *visible_rect
;
2116 data
->client_rect
= *rectClient
;
2118 TRACE( "win %p window %s client %s style %08x flags %08x\n",
2119 hwnd
, wine_dbgstr_rect(rectWindow
), wine_dbgstr_rect(rectClient
), new_style
, swp_flags
);
2121 if (!IsRectEmpty( &valid_rects
[0] ))
2123 int x_offset
= old_whole_rect
.left
- data
->whole_rect
.left
;
2124 int y_offset
= old_whole_rect
.top
- data
->whole_rect
.top
;
2126 /* if all that happened is that the whole window moved, copy everything */
2127 if (!(swp_flags
& SWP_FRAMECHANGED
) &&
2128 old_whole_rect
.right
- data
->whole_rect
.right
== x_offset
&&
2129 old_whole_rect
.bottom
- data
->whole_rect
.bottom
== y_offset
&&
2130 old_client_rect
.left
- data
->client_rect
.left
== x_offset
&&
2131 old_client_rect
.right
- data
->client_rect
.right
== x_offset
&&
2132 old_client_rect
.top
- data
->client_rect
.top
== y_offset
&&
2133 old_client_rect
.bottom
- data
->client_rect
.bottom
== y_offset
&&
2134 !memcmp( &valid_rects
[0], &data
->client_rect
, sizeof(RECT
) ))
2136 /* if we have an X window the bits will be moved by the X server */
2137 if (!data
->whole_window
)
2138 move_window_bits( data
, &old_whole_rect
, &data
->whole_rect
, &old_client_rect
);
2141 move_window_bits( data
, &valid_rects
[1], &valid_rects
[0], &old_client_rect
);
2145 XFlush( gdi_display
); /* make sure painting is done before we move the window */
2146 wine_tsx11_unlock();
2148 sync_client_position( display
, data
, swp_flags
, &old_client_rect
, &old_whole_rect
);
2150 if (!data
->whole_window
) return;
2152 /* check if we are currently processing an event relevant to this window */
2154 if (thread_data
->current_event
&& thread_data
->current_event
->xany
.window
== data
->whole_window
)
2155 event_type
= thread_data
->current_event
->type
;
2157 if (event_type
!= ConfigureNotify
&& event_type
!= PropertyNotify
)
2158 event_type
= 0; /* ignore other events */
2162 if (((swp_flags
& SWP_HIDEWINDOW
) && !(new_style
& WS_VISIBLE
)) ||
2163 (!event_type
&& !is_window_rect_mapped( rectWindow
)))
2164 unmap_window( display
, data
);
2167 /* don't change position if we are about to minimize or maximize a managed window */
2169 !(data
->managed
&& (swp_flags
& SWP_STATECHANGED
) && (new_style
& (WS_MINIMIZE
|WS_MAXIMIZE
))))
2170 sync_window_position( display
, data
, swp_flags
,
2171 &old_window_rect
, &old_whole_rect
, &old_client_rect
);
2173 if ((new_style
& WS_VISIBLE
) &&
2174 ((new_style
& WS_MINIMIZE
) || is_window_rect_mapped( rectWindow
)))
2176 if (!data
->mapped
|| (swp_flags
& (SWP_FRAMECHANGED
|SWP_STATECHANGED
)))
2177 set_wm_hints( display
, data
);
2181 map_window( display
, data
, new_style
);
2183 else if ((swp_flags
& SWP_STATECHANGED
) && (!data
->iconic
!= !(new_style
& WS_MINIMIZE
)))
2185 data
->iconic
= (new_style
& WS_MINIMIZE
) != 0;
2186 TRACE( "changing win %p iconic state to %u\n", data
->hwnd
, data
->iconic
);
2189 XIconifyWindow( display
, data
->whole_window
, DefaultScreen(display
) );
2190 else if (is_window_rect_mapped( rectWindow
))
2191 XMapWindow( display
, data
->whole_window
);
2192 wine_tsx11_unlock();
2193 update_net_wm_states( display
, data
);
2195 else if (!event_type
)
2197 update_net_wm_states( display
, data
);
2202 XFlush( display
); /* make sure changes are done before we start painting again */
2203 wine_tsx11_unlock();
2207 /***********************************************************************
2208 * ShowWindow (X11DRV.@)
2210 UINT CDECL
X11DRV_ShowWindow( HWND hwnd
, INT cmd
, RECT
*rect
, UINT swp
)
2213 unsigned int width
, height
, border
, depth
;
2215 DWORD style
= GetWindowLongW( hwnd
, GWL_STYLE
);
2216 struct x11drv_thread_data
*thread_data
= x11drv_thread_data();
2217 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
2219 if (!data
|| !data
->whole_window
|| !data
->managed
|| !data
->mapped
|| data
->iconic
) return swp
;
2220 if (style
& WS_MINIMIZE
) return swp
;
2221 if (IsRectEmpty( rect
)) return swp
;
2223 /* only fetch the new rectangle if the ShowWindow was a result of a window manager event */
2225 if (!thread_data
->current_event
|| thread_data
->current_event
->xany
.window
!= data
->whole_window
)
2228 if (thread_data
->current_event
->type
!= ConfigureNotify
&&
2229 thread_data
->current_event
->type
!= PropertyNotify
)
2232 TRACE( "win %p/%lx cmd %d at %s flags %08x\n",
2233 hwnd
, data
->whole_window
, cmd
, wine_dbgstr_rect(rect
), swp
);
2236 XGetGeometry( thread_data
->display
, data
->whole_window
,
2237 &root
, &x
, &y
, &width
, &height
, &border
, &depth
);
2238 XTranslateCoordinates( thread_data
->display
, data
->whole_window
, root
, 0, 0, &x
, &y
, &top
);
2239 wine_tsx11_unlock();
2242 rect
->right
= x
+ width
;
2243 rect
->bottom
= y
+ height
;
2244 OffsetRect( rect
, virtual_screen_rect
.left
, virtual_screen_rect
.top
);
2245 X11DRV_X_to_window_rect( data
, rect
);
2246 return swp
& ~(SWP_NOMOVE
| SWP_NOCLIENTMOVE
| SWP_NOSIZE
| SWP_NOCLIENTSIZE
);
2250 /**********************************************************************
2251 * SetWindowIcon (X11DRV.@)
2253 * hIcon or hIconSm has changed (or is being initialised for the
2254 * first time). Complete the X11 driver-specific initialisation
2255 * and set the window hints.
2257 * This is not entirely correct, may need to create
2258 * an icon window and set the pixmap as a background
2260 void CDECL
X11DRV_SetWindowIcon( HWND hwnd
, UINT type
, HICON icon
)
2262 Display
*display
= thread_display();
2263 struct x11drv_win_data
*data
;
2265 if (type
!= ICON_BIG
) return; /* nothing to do here */
2267 if (!(data
= X11DRV_get_win_data( hwnd
))) return;
2268 if (!data
->whole_window
) return;
2269 if (!data
->managed
) return;
2273 set_icon_hints( display
, data
, icon
);
2275 XSetWMHints( display
, data
->whole_window
, data
->wm_hints
);
2276 wine_tsx11_unlock();
2281 /***********************************************************************
2282 * SetWindowRgn (X11DRV.@)
2284 * Assign specified region to window (for non-rectangular windows)
2286 int CDECL
X11DRV_SetWindowRgn( HWND hwnd
, HRGN hrgn
, BOOL redraw
)
2288 struct x11drv_win_data
*data
;
2290 if ((data
= X11DRV_get_win_data( hwnd
)))
2292 sync_window_region( thread_display(), data
, hrgn
);
2294 else if (X11DRV_get_whole_window( hwnd
))
2296 SendMessageW( hwnd
, WM_X11DRV_SET_WIN_REGION
, 0, 0 );
2302 /***********************************************************************
2303 * SetLayeredWindowAttributes (X11DRV.@)
2305 * Set transparency attributes for a layered window.
2307 void CDECL
X11DRV_SetLayeredWindowAttributes( HWND hwnd
, COLORREF key
, BYTE alpha
, DWORD flags
)
2309 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
2313 if (data
->whole_window
)
2314 sync_window_opacity( thread_display(), data
->whole_window
, key
, alpha
, flags
);
2318 Window win
= X11DRV_get_whole_window( hwnd
);
2319 if (win
) sync_window_opacity( gdi_display
, win
, key
, alpha
, flags
);
2324 /**********************************************************************
2325 * X11DRV_WindowMessage (X11DRV.@)
2327 LRESULT CDECL
X11DRV_WindowMessage( HWND hwnd
, UINT msg
, WPARAM wp
, LPARAM lp
)
2329 struct x11drv_win_data
*data
;
2333 case WM_X11DRV_ACQUIRE_SELECTION
:
2334 return X11DRV_AcquireClipboard( hwnd
);
2335 case WM_X11DRV_SET_WIN_FORMAT
:
2336 return set_win_format( hwnd
, (XID
)wp
);
2337 case WM_X11DRV_SET_WIN_REGION
:
2338 if ((data
= X11DRV_get_win_data( hwnd
))) sync_window_region( thread_display(), data
, (HRGN
)1 );
2340 case WM_X11DRV_RESIZE_DESKTOP
:
2341 X11DRV_resize_desktop( LOWORD(lp
), HIWORD(lp
) );
2344 FIXME( "got window msg %x hwnd %p wp %lx lp %lx\n", msg
, hwnd
, wp
, lp
);
2350 /***********************************************************************
2351 * is_netwm_supported
2353 static BOOL
is_netwm_supported( Display
*display
, Atom atom
)
2355 static Atom
*net_supported
;
2356 static int net_supported_count
= -1;
2360 if (net_supported_count
== -1)
2364 unsigned long count
, remaining
;
2366 if (!XGetWindowProperty( display
, DefaultRootWindow(display
), x11drv_atom(_NET_SUPPORTED
), 0,
2367 ~0UL, False
, XA_ATOM
, &type
, &format
, &count
,
2368 &remaining
, (unsigned char **)&net_supported
))
2369 net_supported_count
= get_property_size( format
, count
) / sizeof(Atom
);
2371 net_supported_count
= 0;
2373 wine_tsx11_unlock();
2375 for (i
= 0; i
< net_supported_count
; i
++)
2376 if (net_supported
[i
] == atom
) return TRUE
;
2381 /***********************************************************************
2382 * SysCommand (X11DRV.@)
2384 * Perform WM_SYSCOMMAND handling.
2386 LRESULT CDECL
X11DRV_SysCommand( HWND hwnd
, WPARAM wparam
, LPARAM lparam
)
2388 WPARAM hittest
= wparam
& 0x0f;
2392 Display
*display
= thread_display();
2393 struct x11drv_win_data
*data
;
2395 if (!(data
= X11DRV_get_win_data( hwnd
))) return -1;
2396 if (!data
->whole_window
|| !data
->managed
|| !data
->mapped
) return -1;
2398 switch (wparam
& 0xfff0)
2401 if (!hittest
) dir
= _NET_WM_MOVERESIZE_MOVE_KEYBOARD
;
2402 else dir
= _NET_WM_MOVERESIZE_MOVE
;
2405 /* windows without WS_THICKFRAME are not resizable through the window manager */
2406 if (!(GetWindowLongW( hwnd
, GWL_STYLE
) & WS_THICKFRAME
)) return -1;
2410 case WMSZ_LEFT
: dir
= _NET_WM_MOVERESIZE_SIZE_LEFT
; break;
2411 case WMSZ_RIGHT
: dir
= _NET_WM_MOVERESIZE_SIZE_RIGHT
; break;
2412 case WMSZ_TOP
: dir
= _NET_WM_MOVERESIZE_SIZE_TOP
; break;
2413 case WMSZ_TOPLEFT
: dir
= _NET_WM_MOVERESIZE_SIZE_TOPLEFT
; break;
2414 case WMSZ_TOPRIGHT
: dir
= _NET_WM_MOVERESIZE_SIZE_TOPRIGHT
; break;
2415 case WMSZ_BOTTOM
: dir
= _NET_WM_MOVERESIZE_SIZE_BOTTOM
; break;
2416 case WMSZ_BOTTOMLEFT
: dir
= _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT
; break;
2417 case WMSZ_BOTTOMRIGHT
: dir
= _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT
; break;
2418 default: dir
= _NET_WM_MOVERESIZE_SIZE_KEYBOARD
; break;
2423 /* prevent a simple ALT press+release from activating the system menu,
2424 * as that can get confusing on managed windows */
2425 if ((WCHAR
)lparam
) return -1; /* got an explicit char */
2426 if (GetMenu( hwnd
)) return -1; /* window has a real menu */
2427 if (!(GetWindowLongW( hwnd
, GWL_STYLE
) & WS_SYSMENU
)) return -1; /* no system menu */
2428 TRACE( "ignoring SC_KEYMENU wp %lx lp %lx\n", wparam
, lparam
);
2435 if (IsZoomed(hwnd
)) return -1;
2437 if (!is_netwm_supported( display
, x11drv_atom(_NET_WM_MOVERESIZE
) ))
2439 TRACE( "_NET_WM_MOVERESIZE not supported\n" );
2443 dwPoint
= GetMessagePos();
2444 x
= (short)LOWORD(dwPoint
);
2445 y
= (short)HIWORD(dwPoint
);
2447 TRACE("hwnd %p, x %d, y %d, dir %d\n", hwnd
, x
, y
, dir
);
2449 xev
.xclient
.type
= ClientMessage
;
2450 xev
.xclient
.window
= X11DRV_get_whole_window(hwnd
);
2451 xev
.xclient
.message_type
= x11drv_atom(_NET_WM_MOVERESIZE
);
2452 xev
.xclient
.serial
= 0;
2453 xev
.xclient
.display
= display
;
2454 xev
.xclient
.send_event
= True
;
2455 xev
.xclient
.format
= 32;
2456 xev
.xclient
.data
.l
[0] = x
- virtual_screen_rect
.left
; /* x coord */
2457 xev
.xclient
.data
.l
[1] = y
- virtual_screen_rect
.top
; /* y coord */
2458 xev
.xclient
.data
.l
[2] = dir
; /* direction */
2459 xev
.xclient
.data
.l
[3] = 1; /* button */
2460 xev
.xclient
.data
.l
[4] = 0; /* unused */
2462 /* need to ungrab the pointer that may have been automatically grabbed
2463 * with a ButtonPress event */
2465 XUngrabPointer( display
, CurrentTime
);
2466 XSendEvent(display
, root_window
, False
, SubstructureNotifyMask
, &xev
);
2467 wine_tsx11_unlock();