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 /* is cursor clipping active? */
72 int clipping_cursor
= 0;
74 /* X context to associate a hwnd to an X window */
75 XContext winContext
= 0;
77 /* X context to associate a struct x11drv_win_data to an hwnd */
78 static XContext win_data_context
;
80 /* time of last user event and window where it's stored */
81 static Time last_user_time
;
82 static Window user_time_window
;
84 static const char foreign_window_prop
[] = "__wine_x11_foreign_window";
85 static const char whole_window_prop
[] = "__wine_x11_whole_window";
86 static const char client_window_prop
[]= "__wine_x11_client_window";
87 static const char icon_window_prop
[] = "__wine_x11_icon_window";
88 static const char clip_window_prop
[] = "__wine_x11_clip_window";
89 static const char fbconfig_id_prop
[] = "__wine_x11_fbconfig_id";
90 static const char gl_drawable_prop
[] = "__wine_x11_gl_drawable";
91 static const char pixmap_prop
[] = "__wine_x11_pixmap";
92 static const char managed_prop
[] = "__wine_x11_managed";
95 /***********************************************************************
96 * http://standards.freedesktop.org/startup-notification-spec
98 static void remove_startup_notification(Display
*display
, Window window
)
100 static LONG startup_notification_removed
= 0;
109 if (InterlockedCompareExchange(&startup_notification_removed
, 1, 0) != 0)
112 if (GetEnvironmentVariableA("DESKTOP_STARTUP_ID", id
, sizeof(id
)) == 0)
114 SetEnvironmentVariableA("DESKTOP_STARTUP_ID", NULL
);
116 if ((src
= strstr( id
, "_TIME" ))) update_user_time( atol( src
+ 5 ));
118 pos
= snprintf(message
, sizeof(message
), "remove: ID=");
119 message
[pos
++] = '"';
120 for (i
= 0; id
[i
] && pos
< sizeof(message
) - 2; i
++)
122 if (id
[i
] == '"' || id
[i
] == '\\')
123 message
[pos
++] = '\\';
124 message
[pos
++] = id
[i
];
126 message
[pos
++] = '"';
127 message
[pos
++] = '\0';
129 xevent
.xclient
.type
= ClientMessage
;
130 xevent
.xclient
.message_type
= x11drv_atom(_NET_STARTUP_INFO_BEGIN
);
131 xevent
.xclient
.display
= display
;
132 xevent
.xclient
.window
= window
;
133 xevent
.xclient
.format
= 8;
136 srclen
= strlen(src
) + 1;
144 memset(&xevent
.xclient
.data
.b
[0], 0, 20);
145 memcpy(&xevent
.xclient
.data
.b
[0], src
, msglen
);
149 XSendEvent( display
, DefaultRootWindow( display
), False
, PropertyChangeMask
, &xevent
);
150 xevent
.xclient
.message_type
= x11drv_atom(_NET_STARTUP_INFO
);
156 struct has_popup_result
162 static BOOL CALLBACK
has_managed_popup( HWND hwnd
, LPARAM lparam
)
164 struct has_popup_result
*result
= (struct has_popup_result
*)lparam
;
165 struct x11drv_win_data
*data
;
167 if (hwnd
== result
->hwnd
) return FALSE
; /* popups are always above owner */
168 if (!(data
= X11DRV_get_win_data( hwnd
))) return TRUE
;
169 if (GetWindow( hwnd
, GW_OWNER
) != result
->hwnd
) return TRUE
;
170 result
->found
= data
->managed
;
171 return !result
->found
;
174 static BOOL
has_owned_popups( HWND hwnd
)
176 struct has_popup_result result
;
179 result
.found
= FALSE
;
180 EnumWindows( has_managed_popup
, (LPARAM
)&result
);
184 /***********************************************************************
187 * Check if a given window should be managed
189 static BOOL
is_window_managed( HWND hwnd
, UINT swp_flags
, const RECT
*window_rect
)
191 DWORD style
, ex_style
;
193 if (!managed_mode
) return FALSE
;
195 /* child windows are not managed */
196 style
= GetWindowLongW( hwnd
, GWL_STYLE
);
197 if ((style
& (WS_CHILD
|WS_POPUP
)) == WS_CHILD
) return FALSE
;
198 /* activated windows are managed */
199 if (!(swp_flags
& (SWP_NOACTIVATE
|SWP_HIDEWINDOW
))) return TRUE
;
200 if (hwnd
== GetActiveWindow()) return TRUE
;
201 /* windows with caption are managed */
202 if ((style
& WS_CAPTION
) == WS_CAPTION
) return TRUE
;
203 /* windows with thick frame are managed */
204 if (style
& WS_THICKFRAME
) return TRUE
;
205 if (style
& WS_POPUP
)
210 /* popup with sysmenu == caption are managed */
211 if (style
& WS_SYSMENU
) return TRUE
;
212 /* full-screen popup windows are managed */
213 hmon
= MonitorFromWindow( hwnd
, MONITOR_DEFAULTTOPRIMARY
);
214 mi
.cbSize
= sizeof( mi
);
215 GetMonitorInfoW( hmon
, &mi
);
216 if (window_rect
->left
<= mi
.rcWork
.left
&& window_rect
->right
>= mi
.rcWork
.right
&&
217 window_rect
->top
<= mi
.rcWork
.top
&& window_rect
->bottom
>= mi
.rcWork
.bottom
)
220 /* application windows are managed */
221 ex_style
= GetWindowLongW( hwnd
, GWL_EXSTYLE
);
222 if (ex_style
& WS_EX_APPWINDOW
) return TRUE
;
223 /* windows that own popups are managed */
224 if (has_owned_popups( hwnd
)) return TRUE
;
225 /* default: not managed */
230 /***********************************************************************
231 * is_window_resizable
233 * Check if window should be made resizable by the window manager
235 static inline BOOL
is_window_resizable( struct x11drv_win_data
*data
, DWORD style
)
237 if (style
& WS_THICKFRAME
) return TRUE
;
238 /* Metacity needs the window to be resizable to make it fullscreen */
239 return is_window_rect_fullscreen( &data
->whole_rect
);
243 /***********************************************************************
244 * get_mwm_decorations
246 static unsigned long get_mwm_decorations( struct x11drv_win_data
*data
,
247 DWORD style
, DWORD ex_style
)
249 unsigned long ret
= 0;
251 if (!decorated_mode
) return 0;
253 if (IsRectEmpty( &data
->window_rect
)) return 0;
254 if (data
->shaped
) return 0;
256 if (ex_style
& WS_EX_TOOLWINDOW
) return 0;
258 if ((style
& WS_CAPTION
) == WS_CAPTION
)
260 ret
|= MWM_DECOR_TITLE
| MWM_DECOR_BORDER
;
261 if (style
& WS_SYSMENU
) ret
|= MWM_DECOR_MENU
;
262 if (style
& WS_MINIMIZEBOX
) ret
|= MWM_DECOR_MINIMIZE
;
263 if (style
& WS_MAXIMIZEBOX
) ret
|= MWM_DECOR_MAXIMIZE
;
265 if (ex_style
& WS_EX_DLGMODALFRAME
) ret
|= MWM_DECOR_BORDER
;
266 else if (style
& WS_THICKFRAME
) ret
|= MWM_DECOR_BORDER
| MWM_DECOR_RESIZEH
;
267 else if ((style
& (WS_DLGFRAME
|WS_BORDER
)) == WS_DLGFRAME
) ret
|= MWM_DECOR_BORDER
;
272 /***********************************************************************
273 * get_x11_rect_offset
275 * Helper for X11DRV_window_to_X_rect and X11DRV_X_to_window_rect.
277 static void get_x11_rect_offset( struct x11drv_win_data
*data
, RECT
*rect
)
279 DWORD style
, ex_style
, style_mask
= 0, ex_style_mask
= 0;
282 rect
->top
= rect
->bottom
= rect
->left
= rect
->right
= 0;
284 style
= GetWindowLongW( data
->hwnd
, GWL_STYLE
);
285 ex_style
= GetWindowLongW( data
->hwnd
, GWL_EXSTYLE
);
286 decor
= get_mwm_decorations( data
, style
, ex_style
);
288 if (decor
& MWM_DECOR_TITLE
) style_mask
|= WS_CAPTION
;
289 if (decor
& MWM_DECOR_BORDER
)
291 style_mask
|= WS_DLGFRAME
| WS_THICKFRAME
;
292 ex_style_mask
|= WS_EX_DLGMODALFRAME
;
295 AdjustWindowRectEx( rect
, style
& style_mask
, FALSE
, ex_style
& ex_style_mask
);
299 /***********************************************************************
300 * get_window_attributes
302 * Fill the window attributes structure for an X window.
304 static int get_window_attributes( Display
*display
, struct x11drv_win_data
*data
,
305 XSetWindowAttributes
*attr
)
307 attr
->override_redirect
= !data
->managed
;
308 attr
->colormap
= X11DRV_PALETTE_PaletteXColormap
;
309 attr
->save_under
= ((GetClassLongW( data
->hwnd
, GCL_STYLE
) & CS_SAVEBITS
) != 0);
310 attr
->bit_gravity
= NorthWestGravity
;
311 attr
->win_gravity
= StaticGravity
;
312 attr
->backing_store
= NotUseful
;
313 attr
->event_mask
= (ExposureMask
| PointerMotionMask
|
314 ButtonPressMask
| ButtonReleaseMask
| EnterWindowMask
|
315 KeyPressMask
| KeyReleaseMask
| FocusChangeMask
|
316 KeymapStateMask
| StructureNotifyMask
);
317 if (data
->managed
) attr
->event_mask
|= PropertyChangeMask
;
319 return (CWOverrideRedirect
| CWSaveUnder
| CWColormap
|
320 CWEventMask
| CWBitGravity
| CWBackingStore
);
324 /***********************************************************************
325 * create_client_window
327 static Window
create_client_window( Display
*display
, struct x11drv_win_data
*data
, XVisualInfo
*vis
)
330 XSetWindowAttributes attr
;
332 Visual
*client_visual
= vis
? vis
->visual
: visual
;
334 attr
.bit_gravity
= NorthWestGravity
;
335 attr
.win_gravity
= NorthWestGravity
;
336 attr
.backing_store
= NotUseful
;
337 attr
.event_mask
= (ExposureMask
| PointerMotionMask
|
338 ButtonPressMask
| ButtonReleaseMask
| EnterWindowMask
);
339 mask
= CWEventMask
| CWBitGravity
| CWWinGravity
| CWBackingStore
;
341 if ((cx
= data
->client_rect
.right
- data
->client_rect
.left
) <= 0) cx
= 1;
342 else if (cx
> 65535) cx
= 65535;
343 if ((cy
= data
->client_rect
.bottom
- data
->client_rect
.top
) <= 0) cy
= 1;
344 else if (cy
> 65535) cy
= 65535;
350 attr
.colormap
= XCreateColormap( display
, root_window
, vis
->visual
,
351 (vis
->class == PseudoColor
|| vis
->class == GrayScale
||
352 vis
->class == DirectColor
) ? AllocAll
: AllocNone
);
356 client
= XCreateWindow( display
, data
->whole_window
,
357 data
->client_rect
.left
- data
->whole_rect
.left
,
358 data
->client_rect
.top
- data
->whole_rect
.top
,
359 cx
, cy
, 0, screen_depth
, InputOutput
,
360 client_visual
, mask
, &attr
);
367 if (data
->client_window
)
369 XDeleteContext( display
, data
->client_window
, winContext
);
370 XDestroyWindow( display
, data
->client_window
);
372 data
->client_window
= client
;
373 data
->visualid
= XVisualIDFromVisual( client_visual
);
375 if (data
->colormap
) XFreeColormap( display
, data
->colormap
);
376 data
->colormap
= vis
? attr
.colormap
: 0;
378 XMapWindow( display
, data
->client_window
);
379 XSaveContext( display
, data
->client_window
, winContext
, (char *)data
->hwnd
);
382 SetPropA( data
->hwnd
, client_window_prop
, (HANDLE
)data
->client_window
);
383 return data
->client_window
;
387 /***********************************************************************
390 * Change the X window attributes when the window style has changed.
392 static void sync_window_style( Display
*display
, struct x11drv_win_data
*data
)
394 if (data
->whole_window
!= root_window
)
396 XSetWindowAttributes attr
;
397 int mask
= get_window_attributes( display
, data
, &attr
);
400 XChangeWindowAttributes( display
, data
->whole_window
, mask
, &attr
);
406 /***********************************************************************
409 * Update the X11 window region.
411 static void sync_window_region( Display
*display
, struct x11drv_win_data
*data
, HRGN win_region
)
413 #ifdef HAVE_LIBXSHAPE
414 HRGN hrgn
= win_region
;
416 if (!data
->whole_window
) return;
417 data
->shaped
= FALSE
;
419 if (IsRectEmpty( &data
->window_rect
)) /* set an empty shape */
421 static XRectangle empty_rect
;
423 XShapeCombineRectangles( display
, data
->whole_window
, ShapeBounding
, 0, 0,
424 &empty_rect
, 1, ShapeSet
, YXBanded
);
429 if (hrgn
== (HRGN
)1) /* hack: win_region == 1 means retrieve region from server */
431 if (!(hrgn
= CreateRectRgn( 0, 0, 0, 0 ))) return;
432 if (GetWindowRgn( data
->hwnd
, hrgn
) == ERROR
)
434 DeleteObject( hrgn
);
442 XShapeCombineMask( display
, data
->whole_window
, ShapeBounding
, 0, 0, None
, ShapeSet
);
447 RGNDATA
*pRegionData
;
449 if (GetWindowLongW( data
->hwnd
, GWL_EXSTYLE
) & WS_EX_LAYOUTRTL
) MirrorRgn( data
->hwnd
, hrgn
);
450 if ((pRegionData
= X11DRV_GetRegionData( hrgn
, 0 )))
453 XShapeCombineRectangles( display
, data
->whole_window
, ShapeBounding
,
454 data
->window_rect
.left
- data
->whole_rect
.left
,
455 data
->window_rect
.top
- data
->whole_rect
.top
,
456 (XRectangle
*)pRegionData
->Buffer
,
457 pRegionData
->rdh
.nCount
, ShapeSet
, YXBanded
);
459 HeapFree(GetProcessHeap(), 0, pRegionData
);
463 if (hrgn
&& hrgn
!= win_region
) DeleteObject( hrgn
);
464 #endif /* HAVE_LIBXSHAPE */
468 /***********************************************************************
469 * sync_window_opacity
471 static void sync_window_opacity( Display
*display
, Window win
,
472 COLORREF key
, BYTE alpha
, DWORD flags
)
474 unsigned long opacity
= 0xffffffff;
476 if (flags
& LWA_ALPHA
) opacity
= (0xffffffff / 0xff) * alpha
;
478 if (flags
& LWA_COLORKEY
) FIXME("LWA_COLORKEY not supported\n");
481 if (opacity
== 0xffffffff)
482 XDeleteProperty( display
, win
, x11drv_atom(_NET_WM_WINDOW_OPACITY
) );
484 XChangeProperty( display
, win
, x11drv_atom(_NET_WM_WINDOW_OPACITY
),
485 XA_CARDINAL
, 32, PropModeReplace
, (unsigned char *)&opacity
, 1 );
490 /***********************************************************************
493 static void sync_window_text( Display
*display
, Window win
, const WCHAR
*text
)
496 char *buffer
, *utf8_buffer
;
499 /* allocate new buffer for window text */
500 count
= WideCharToMultiByte(CP_UNIXCP
, 0, text
, -1, NULL
, 0, NULL
, NULL
);
501 if (!(buffer
= HeapAlloc( GetProcessHeap(), 0, count
))) return;
502 WideCharToMultiByte(CP_UNIXCP
, 0, text
, -1, buffer
, count
, NULL
, NULL
);
504 count
= WideCharToMultiByte(CP_UTF8
, 0, text
, strlenW(text
), NULL
, 0, NULL
, NULL
);
505 if (!(utf8_buffer
= HeapAlloc( GetProcessHeap(), 0, count
)))
507 HeapFree( GetProcessHeap(), 0, buffer
);
510 WideCharToMultiByte(CP_UTF8
, 0, text
, strlenW(text
), utf8_buffer
, count
, NULL
, NULL
);
513 if (XmbTextListToTextProperty( display
, &buffer
, 1, XStdICCTextStyle
, &prop
) == Success
)
515 XSetWMName( display
, win
, &prop
);
516 XSetWMIconName( display
, win
, &prop
);
520 Implements a NET_WM UTF-8 title. It should be without a trailing \0,
521 according to the standard
522 ( http://www.pps.jussieu.fr/~jch/software/UTF8_STRING/UTF8_STRING.text ).
524 XChangeProperty( display
, win
, x11drv_atom(_NET_WM_NAME
), x11drv_atom(UTF8_STRING
),
525 8, PropModeReplace
, (unsigned char *) utf8_buffer
, count
);
528 HeapFree( GetProcessHeap(), 0, utf8_buffer
);
529 HeapFree( GetProcessHeap(), 0, buffer
);
533 /***********************************************************************
536 static BOOL
set_win_format( HWND hwnd
, XID fbconfig_id
)
538 struct x11drv_win_data
*data
;
542 if (!(data
= X11DRV_get_win_data(hwnd
)) &&
543 !(data
= X11DRV_create_win_data(hwnd
))) return FALSE
;
545 if (!(vis
= visual_from_fbconfig_id(fbconfig_id
))) return FALSE
;
547 if (data
->whole_window
)
549 Display
*display
= thread_display();
550 Window client
= data
->client_window
;
552 if (vis
->visualid
!= data
->visualid
)
554 client
= create_client_window( display
, data
, vis
);
555 TRACE( "re-created client window %lx for %p fbconfig %lx\n", client
, data
->hwnd
, fbconfig_id
);
561 if (client
) goto done
;
565 w
= data
->client_rect
.right
- data
->client_rect
.left
;
566 h
= data
->client_rect
.bottom
- data
->client_rect
.top
;
571 #ifdef SONAME_LIBXCOMPOSITE
574 XSetWindowAttributes attrib
;
575 static Window dummy_parent
;
578 attrib
.override_redirect
= True
;
581 dummy_parent
= XCreateWindow( gdi_display
, root_window
, -1, -1, 1, 1, 0, screen_depth
,
582 InputOutput
, visual
, CWOverrideRedirect
, &attrib
);
583 XMapWindow( gdi_display
, dummy_parent
);
585 data
->colormap
= XCreateColormap(gdi_display
, dummy_parent
, vis
->visual
,
586 (vis
->class == PseudoColor
||
587 vis
->class == GrayScale
||
588 vis
->class == DirectColor
) ?
589 AllocAll
: AllocNone
);
590 attrib
.colormap
= data
->colormap
;
591 XInstallColormap(gdi_display
, attrib
.colormap
);
593 if(data
->gl_drawable
) XDestroyWindow(gdi_display
, data
->gl_drawable
);
594 data
->gl_drawable
= XCreateWindow(gdi_display
, dummy_parent
, 0, 0, w
, h
, 0,
595 vis
->depth
, InputOutput
, vis
->visual
,
596 CWColormap
| CWOverrideRedirect
,
598 if(data
->gl_drawable
)
600 pXCompositeRedirectWindow(gdi_display
, data
->gl_drawable
,
601 CompositeRedirectManual
);
602 XMapWindow(gdi_display
, data
->gl_drawable
);
605 XFlush( gdi_display
);
611 WARN("XComposite is not available, using GLXPixmap hack\n");
615 if(data
->pixmap
) XFreePixmap(gdi_display
, data
->pixmap
);
616 data
->pixmap
= XCreatePixmap(gdi_display
, root_window
, w
, h
, vis
->depth
);
624 if(data
->gl_drawable
) destroy_glxpixmap(gdi_display
, data
->gl_drawable
);
625 data
->gl_drawable
= create_glxpixmap(gdi_display
, vis
, data
->pixmap
);
626 if(!data
->gl_drawable
)
628 XFreePixmap(gdi_display
, data
->pixmap
);
632 XFlush( gdi_display
);
634 if (data
->pixmap
) SetPropA(hwnd
, pixmap_prop
, (HANDLE
)data
->pixmap
);
637 if (!data
->gl_drawable
) return FALSE
;
639 TRACE("Created GL drawable 0x%lx, using FBConfigID 0x%lx\n",
640 data
->gl_drawable
, fbconfig_id
);
641 SetPropA(hwnd
, gl_drawable_prop
, (HANDLE
)data
->gl_drawable
);
644 data
->fbconfig_id
= fbconfig_id
;
645 SetPropA(hwnd
, fbconfig_id_prop
, (HANDLE
)data
->fbconfig_id
);
646 /* force DCE invalidation */
647 SetWindowPos( hwnd
, 0, 0, 0, 0, 0,
648 SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOMOVE
|
649 SWP_NOREDRAW
| SWP_DEFERERASE
| SWP_NOSENDCHANGING
| SWP_STATECHANGED
);
653 /***********************************************************************
656 static void sync_gl_drawable(struct x11drv_win_data
*data
)
658 int w
= data
->client_rect
.right
- data
->client_rect
.left
;
659 int h
= data
->client_rect
.bottom
- data
->client_rect
.top
;
667 TRACE("Resizing GL drawable 0x%lx to %dx%d\n", data
->gl_drawable
, w
, h
);
668 #ifdef SONAME_LIBXCOMPOSITE
672 XMoveResizeWindow(gdi_display
, data
->gl_drawable
, 0, 0, w
, h
);
678 if (!(vis
= visual_from_fbconfig_id(data
->fbconfig_id
))) return;
681 pix
= XCreatePixmap(gdi_display
, root_window
, w
, h
, vis
->depth
);
684 ERR("Failed to create pixmap for offscreen rendering\n");
690 glxp
= create_glxpixmap(gdi_display
, vis
, pix
);
693 ERR("Failed to create drawable for offscreen rendering\n");
694 XFreePixmap(gdi_display
, pix
);
702 mark_drawable_dirty(data
->gl_drawable
, glxp
);
704 XFreePixmap(gdi_display
, data
->pixmap
);
705 destroy_glxpixmap(gdi_display
, data
->gl_drawable
);
706 TRACE( "Recreated GL drawable %lx to replace %lx\n", glxp
, data
->gl_drawable
);
709 data
->gl_drawable
= glxp
;
711 XFlush( gdi_display
);
714 SetPropA(data
->hwnd
, gl_drawable_prop
, (HANDLE
)data
->gl_drawable
);
715 SetPropA(data
->hwnd
, pixmap_prop
, (HANDLE
)data
->pixmap
);
719 /***********************************************************************
722 * fill the window changes structure
724 static int get_window_changes( XWindowChanges
*changes
, const RECT
*old
, const RECT
*new )
728 if (old
->right
- old
->left
!= new->right
- new->left
)
730 if ((changes
->width
= new->right
- new->left
) <= 0) changes
->width
= 1;
731 else if (changes
->width
> 65535) changes
->width
= 65535;
734 if (old
->bottom
- old
->top
!= new->bottom
- new->top
)
736 if ((changes
->height
= new->bottom
- new->top
) <= 0) changes
->height
= 1;
737 else if (changes
->height
> 65535) changes
->height
= 65535;
740 if (old
->left
!= new->left
)
742 changes
->x
= new->left
;
745 if (old
->top
!= new->top
)
747 changes
->y
= new->top
;
754 /***********************************************************************
757 static Window
create_icon_window( Display
*display
, struct x11drv_win_data
*data
)
759 XSetWindowAttributes attr
;
761 attr
.event_mask
= (ExposureMask
| KeyPressMask
| KeyReleaseMask
| PointerMotionMask
|
762 ButtonPressMask
| ButtonReleaseMask
| EnterWindowMask
);
763 attr
.bit_gravity
= NorthWestGravity
;
764 attr
.backing_store
= NotUseful
/*WhenMapped*/;
765 attr
.colormap
= X11DRV_PALETTE_PaletteXColormap
; /* Needed due to our visual */
768 data
->icon_window
= XCreateWindow( display
, root_window
, 0, 0,
769 GetSystemMetrics( SM_CXICON
),
770 GetSystemMetrics( SM_CYICON
),
773 CWEventMask
| CWBitGravity
| CWBackingStore
| CWColormap
, &attr
);
774 XSaveContext( display
, data
->icon_window
, winContext
, (char *)data
->hwnd
);
775 XFlush( display
); /* make sure the window exists before we start painting to it */
778 TRACE( "created %lx\n", data
->icon_window
);
779 SetPropA( data
->hwnd
, icon_window_prop
, (HANDLE
)data
->icon_window
);
780 return data
->icon_window
;
785 /***********************************************************************
786 * destroy_icon_window
788 static void destroy_icon_window( Display
*display
, struct x11drv_win_data
*data
)
790 if (!data
->icon_window
) return;
792 XDeleteContext( display
, data
->icon_window
, winContext
);
793 XDestroyWindow( display
, data
->icon_window
);
794 data
->icon_window
= 0;
796 RemovePropA( data
->hwnd
, icon_window_prop
);
800 /***********************************************************************
803 * Return the bitmap bits in ARGB format. Helper for setting icon hints.
805 static unsigned long *get_bitmap_argb( HDC hdc
, HBITMAP color
, HBITMAP mask
, unsigned int *size
)
807 char buffer
[FIELD_OFFSET( BITMAPINFO
, bmiColors
[256] )];
808 BITMAPINFO
*info
= (BITMAPINFO
*)buffer
;
810 unsigned int *ptr
, *bits
= NULL
;
811 unsigned char *mask_bits
= NULL
;
812 int i
, j
, has_alpha
= 0;
814 if (!GetObjectW( color
, sizeof(bm
), &bm
)) return NULL
;
815 info
->bmiHeader
.biSize
= sizeof(BITMAPINFOHEADER
);
816 info
->bmiHeader
.biWidth
= bm
.bmWidth
;
817 info
->bmiHeader
.biHeight
= -bm
.bmHeight
;
818 info
->bmiHeader
.biPlanes
= 1;
819 info
->bmiHeader
.biBitCount
= 32;
820 info
->bmiHeader
.biCompression
= BI_RGB
;
821 info
->bmiHeader
.biSizeImage
= bm
.bmWidth
* bm
.bmHeight
* 4;
822 info
->bmiHeader
.biXPelsPerMeter
= 0;
823 info
->bmiHeader
.biYPelsPerMeter
= 0;
824 info
->bmiHeader
.biClrUsed
= 0;
825 info
->bmiHeader
.biClrImportant
= 0;
826 *size
= bm
.bmWidth
* bm
.bmHeight
+ 2;
827 if (!(bits
= HeapAlloc( GetProcessHeap(), 0, *size
* sizeof(long) ))) goto failed
;
828 if (!GetDIBits( hdc
, color
, 0, bm
.bmHeight
, bits
+ 2, info
, DIB_RGB_COLORS
)) goto failed
;
830 bits
[0] = bm
.bmWidth
;
831 bits
[1] = bm
.bmHeight
;
833 for (i
= 0; i
< bm
.bmWidth
* bm
.bmHeight
; i
++)
834 if ((has_alpha
= (bits
[i
+ 2] & 0xff000000) != 0)) break;
838 unsigned int width_bytes
= (bm
.bmWidth
+ 31) / 32 * 4;
839 /* generate alpha channel from the mask */
840 info
->bmiHeader
.biBitCount
= 1;
841 info
->bmiHeader
.biSizeImage
= width_bytes
* bm
.bmHeight
;
842 if (!(mask_bits
= HeapAlloc( GetProcessHeap(), 0, info
->bmiHeader
.biSizeImage
))) goto failed
;
843 if (!GetDIBits( hdc
, mask
, 0, bm
.bmHeight
, mask_bits
, info
, DIB_RGB_COLORS
)) goto failed
;
845 for (i
= 0; i
< bm
.bmHeight
; i
++)
846 for (j
= 0; j
< bm
.bmWidth
; j
++, ptr
++)
847 if (!((mask_bits
[i
* width_bytes
+ j
/ 8] << (j
% 8)) & 0x80)) *ptr
|= 0xff000000;
848 HeapFree( GetProcessHeap(), 0, mask_bits
);
851 /* convert to array of longs */
852 if (bits
&& sizeof(long) > sizeof(int))
853 for (i
= *size
- 1; i
>= 0; i
--) ((unsigned long *)bits
)[i
] = bits
[i
];
855 return (unsigned long *)bits
;
858 HeapFree( GetProcessHeap(), 0, bits
);
859 HeapFree( GetProcessHeap(), 0, mask_bits
);
864 /***********************************************************************
865 * create_icon_pixmaps
867 static BOOL
create_icon_pixmaps( HDC hdc
, const ICONINFO
*icon
, struct x11drv_win_data
*data
)
869 char buffer
[FIELD_OFFSET( BITMAPINFO
, bmiColors
[256] )];
870 BITMAPINFO
*info
= (BITMAPINFO
*)buffer
;
872 struct gdi_image_bits bits
;
873 Pixmap color_pixmap
= 0, mask_pixmap
= 0;
880 info
->bmiHeader
.biSize
= sizeof(BITMAPINFOHEADER
);
881 info
->bmiHeader
.biBitCount
= 0;
882 if (!(lines
= GetDIBits( hdc
, icon
->hbmColor
, 0, 0, NULL
, info
, DIB_RGB_COLORS
))) goto failed
;
883 if (!(bits
.ptr
= HeapAlloc( GetProcessHeap(), 0, info
->bmiHeader
.biSizeImage
))) goto failed
;
884 if (!GetDIBits( hdc
, icon
->hbmColor
, 0, lines
, bits
.ptr
, info
, DIB_RGB_COLORS
)) goto failed
;
887 vis
.depth
= screen_depth
;
888 vis
.visualid
= visual
->visualid
;
889 vis
.class = visual
->class;
890 vis
.red_mask
= visual
->red_mask
;
891 vis
.green_mask
= visual
->green_mask
;
892 vis
.blue_mask
= visual
->blue_mask
;
893 color_pixmap
= create_pixmap_from_image( hdc
, &vis
, info
, &bits
, DIB_RGB_COLORS
);
894 HeapFree( GetProcessHeap(), 0, bits
.ptr
);
896 if (!color_pixmap
) goto failed
;
898 info
->bmiHeader
.biSize
= sizeof(BITMAPINFOHEADER
);
899 info
->bmiHeader
.biBitCount
= 0;
900 if (!(lines
= GetDIBits( hdc
, icon
->hbmMask
, 0, 0, NULL
, info
, DIB_RGB_COLORS
))) goto failed
;
901 if (!(bits
.ptr
= HeapAlloc( GetProcessHeap(), 0, info
->bmiHeader
.biSizeImage
))) goto failed
;
902 if (!GetDIBits( hdc
, icon
->hbmMask
, 0, lines
, bits
.ptr
, info
, DIB_RGB_COLORS
)) goto failed
;
904 /* invert the mask */
905 for (i
= 0; i
< info
->bmiHeader
.biSizeImage
/ sizeof(DWORD
); i
++) ((DWORD
*)bits
.ptr
)[i
] ^= ~0u;
908 mask_pixmap
= create_pixmap_from_image( hdc
, &vis
, info
, &bits
, DIB_RGB_COLORS
);
909 HeapFree( GetProcessHeap(), 0, bits
.ptr
);
911 if (!mask_pixmap
) goto failed
;
913 data
->icon_pixmap
= color_pixmap
;
914 data
->icon_mask
= mask_pixmap
;
919 if (color_pixmap
) XFreePixmap( gdi_display
, color_pixmap
);
920 if (mask_pixmap
) XFreePixmap( gdi_display
, mask_pixmap
);
922 HeapFree( GetProcessHeap(), 0, bits
.ptr
);
927 /***********************************************************************
930 * Set the icon wm hints
932 static void set_icon_hints( Display
*display
, struct x11drv_win_data
*data
,
933 HICON icon_big
, HICON icon_small
)
935 XWMHints
*hints
= data
->wm_hints
;
939 icon_big
= (HICON
)SendMessageW( data
->hwnd
, WM_GETICON
, ICON_BIG
, 0 );
940 if (!icon_big
) icon_big
= (HICON
)GetClassLongPtrW( data
->hwnd
, GCLP_HICON
);
944 icon_small
= (HICON
)SendMessageW( data
->hwnd
, WM_GETICON
, ICON_SMALL
, 0 );
945 if (!icon_small
) icon_small
= (HICON
)GetClassLongPtrW( data
->hwnd
, GCLP_HICONSM
);
949 if (data
->icon_pixmap
) XFreePixmap( gdi_display
, data
->icon_pixmap
);
950 if (data
->icon_mask
) XFreePixmap( gdi_display
, data
->icon_mask
);
951 data
->icon_pixmap
= data
->icon_mask
= 0;
956 if (!data
->icon_window
) create_icon_window( display
, data
);
957 hints
->icon_window
= data
->icon_window
;
958 hints
->flags
= (hints
->flags
& ~(IconPixmapHint
| IconMaskHint
)) | IconWindowHint
;
962 ICONINFO ii
, ii_small
;
967 if (!GetIconInfo(icon_big
, &ii
)) return;
969 hDC
= CreateCompatibleDC(0);
970 bits
= get_bitmap_argb( hDC
, ii
.hbmColor
, ii
.hbmMask
, &size
);
971 if (bits
&& GetIconInfo( icon_small
, &ii_small
))
973 unsigned int size_small
;
974 unsigned long *bits_small
, *new;
976 if ((bits_small
= get_bitmap_argb( hDC
, ii_small
.hbmColor
, ii_small
.hbmMask
, &size_small
)) &&
977 (bits_small
[0] != bits
[0] || bits_small
[1] != bits
[1])) /* size must be different */
979 if ((new = HeapReAlloc( GetProcessHeap(), 0, bits
,
980 (size
+ size_small
) * sizeof(unsigned long) )))
983 memcpy( bits
+ size
, bits_small
, size_small
* sizeof(unsigned long) );
987 HeapFree( GetProcessHeap(), 0, bits_small
);
988 DeleteObject( ii_small
.hbmColor
);
989 DeleteObject( ii_small
.hbmMask
);
993 XChangeProperty( display
, data
->whole_window
, x11drv_atom(_NET_WM_ICON
),
994 XA_CARDINAL
, 32, PropModeReplace
, (unsigned char *)bits
, size
);
996 XDeleteProperty( display
, data
->whole_window
, x11drv_atom(_NET_WM_ICON
) );
998 HeapFree( GetProcessHeap(), 0, bits
);
1000 if (create_icon_pixmaps( hDC
, &ii
, data
))
1002 hints
->icon_pixmap
= data
->icon_pixmap
;
1003 hints
->icon_mask
= data
->icon_mask
;
1004 hints
->flags
|= IconPixmapHint
| IconMaskHint
;
1006 destroy_icon_window( display
, data
);
1007 hints
->flags
&= ~IconWindowHint
;
1009 DeleteObject( ii
.hbmColor
);
1010 DeleteObject( ii
.hbmMask
);
1016 /***********************************************************************
1019 * set the window size hints
1021 static void set_size_hints( Display
*display
, struct x11drv_win_data
*data
, DWORD style
)
1023 XSizeHints
* size_hints
;
1025 if (!(size_hints
= XAllocSizeHints())) return;
1027 size_hints
->win_gravity
= StaticGravity
;
1028 size_hints
->flags
|= PWinGravity
;
1030 /* don't update size hints if window is not in normal state */
1031 if (!(style
& (WS_MINIMIZE
| WS_MAXIMIZE
)))
1033 if (data
->hwnd
!= GetDesktopWindow()) /* don't force position of desktop */
1035 size_hints
->x
= data
->whole_rect
.left
;
1036 size_hints
->y
= data
->whole_rect
.top
;
1037 size_hints
->flags
|= PPosition
;
1039 else size_hints
->win_gravity
= NorthWestGravity
;
1041 if (!is_window_resizable( data
, style
))
1043 size_hints
->max_width
= data
->whole_rect
.right
- data
->whole_rect
.left
;
1044 size_hints
->max_height
= data
->whole_rect
.bottom
- data
->whole_rect
.top
;
1045 if (size_hints
->max_width
<= 0 ||size_hints
->max_height
<= 0)
1046 size_hints
->max_width
= size_hints
->max_height
= 1;
1047 size_hints
->min_width
= size_hints
->max_width
;
1048 size_hints
->min_height
= size_hints
->max_height
;
1049 size_hints
->flags
|= PMinSize
| PMaxSize
;
1052 XSetWMNormalHints( display
, data
->whole_window
, size_hints
);
1053 XFree( size_hints
);
1057 /***********************************************************************
1060 static void set_mwm_hints( Display
*display
, struct x11drv_win_data
*data
, DWORD style
, DWORD ex_style
)
1064 if (data
->hwnd
== GetDesktopWindow())
1066 if (is_desktop_fullscreen()) mwm_hints
.decorations
= 0;
1067 else mwm_hints
.decorations
= MWM_DECOR_TITLE
| MWM_DECOR_BORDER
| MWM_DECOR_MENU
| MWM_DECOR_MINIMIZE
;
1068 mwm_hints
.functions
= MWM_FUNC_MOVE
| MWM_FUNC_MINIMIZE
| MWM_FUNC_CLOSE
;
1072 mwm_hints
.decorations
= get_mwm_decorations( data
, style
, ex_style
);
1073 mwm_hints
.functions
= MWM_FUNC_MOVE
;
1074 if (is_window_resizable( data
, style
)) mwm_hints
.functions
|= MWM_FUNC_RESIZE
;
1075 if (!(style
& WS_DISABLED
))
1077 if (style
& WS_MINIMIZEBOX
) mwm_hints
.functions
|= MWM_FUNC_MINIMIZE
;
1078 if (style
& WS_MAXIMIZEBOX
) mwm_hints
.functions
|= MWM_FUNC_MAXIMIZE
;
1079 if (style
& WS_SYSMENU
) mwm_hints
.functions
|= MWM_FUNC_CLOSE
;
1083 TRACE( "%p setting mwm hints to %lx,%lx (style %x exstyle %x)\n",
1084 data
->hwnd
, mwm_hints
.decorations
, mwm_hints
.functions
, style
, ex_style
);
1086 mwm_hints
.flags
= MWM_HINTS_FUNCTIONS
| MWM_HINTS_DECORATIONS
;
1087 XChangeProperty( display
, data
->whole_window
, x11drv_atom(_MOTIF_WM_HINTS
),
1088 x11drv_atom(_MOTIF_WM_HINTS
), 32, PropModeReplace
,
1089 (unsigned char*)&mwm_hints
, sizeof(mwm_hints
)/sizeof(long) );
1093 /***********************************************************************
1096 * get the name of the current process for setting class hints
1098 static char *get_process_name(void)
1104 WCHAR module
[MAX_PATH
];
1105 DWORD len
= GetModuleFileNameW( 0, module
, MAX_PATH
);
1106 if (len
&& len
< MAX_PATH
)
1109 WCHAR
*p
, *appname
= module
;
1111 if ((p
= strrchrW( appname
, '/' ))) appname
= p
+ 1;
1112 if ((p
= strrchrW( appname
, '\\' ))) appname
= p
+ 1;
1113 len
= WideCharToMultiByte( CP_UNIXCP
, 0, appname
, -1, NULL
, 0, NULL
, NULL
);
1114 if ((ptr
= HeapAlloc( GetProcessHeap(), 0, len
)))
1116 WideCharToMultiByte( CP_UNIXCP
, 0, appname
, -1, ptr
, len
, NULL
, NULL
);
1125 /***********************************************************************
1126 * set_initial_wm_hints
1128 * Set the window manager hints that don't change over the lifetime of a window.
1130 static void set_initial_wm_hints( Display
*display
, struct x11drv_win_data
*data
)
1134 Atom dndVersion
= WINE_XDND_VERSION
;
1135 XClassHint
*class_hints
;
1136 char *process_name
= get_process_name();
1142 protocols
[i
++] = x11drv_atom(WM_DELETE_WINDOW
);
1143 protocols
[i
++] = x11drv_atom(_NET_WM_PING
);
1144 if (use_take_focus
) protocols
[i
++] = x11drv_atom(WM_TAKE_FOCUS
);
1145 XChangeProperty( display
, data
->whole_window
, x11drv_atom(WM_PROTOCOLS
),
1146 XA_ATOM
, 32, PropModeReplace
, (unsigned char *)protocols
, i
);
1149 if ((class_hints
= XAllocClassHint()))
1151 static char wine
[] = "Wine";
1153 class_hints
->res_name
= process_name
;
1154 class_hints
->res_class
= wine
;
1155 XSetClassHint( display
, data
->whole_window
, class_hints
);
1156 XFree( class_hints
);
1159 /* set the WM_CLIENT_MACHINE and WM_LOCALE_NAME properties */
1160 XSetWMProperties(display
, data
->whole_window
, NULL
, NULL
, NULL
, 0, NULL
, NULL
, NULL
);
1161 /* set the pid. together, these properties are needed so the window manager can kill us if we freeze */
1163 XChangeProperty(display
, data
->whole_window
, x11drv_atom(_NET_WM_PID
),
1164 XA_CARDINAL
, 32, PropModeReplace
, (unsigned char *)&i
, 1);
1166 XChangeProperty( display
, data
->whole_window
, x11drv_atom(XdndAware
),
1167 XA_ATOM
, 32, PropModeReplace
, (unsigned char*)&dndVersion
, 1 );
1169 update_user_time( 0 ); /* make sure that the user time window exists */
1170 if (user_time_window
)
1171 XChangeProperty( display
, data
->whole_window
, x11drv_atom(_NET_WM_USER_TIME_WINDOW
),
1172 XA_WINDOW
, 32, PropModeReplace
, (unsigned char *)&user_time_window
, 1 );
1174 data
->wm_hints
= XAllocWMHints();
1175 wine_tsx11_unlock();
1179 data
->wm_hints
->flags
= 0;
1180 set_icon_hints( display
, data
, 0, 0 );
1185 /***********************************************************************
1186 * get_owner_whole_window
1188 * Retrieve an owner's window, creating it if necessary.
1190 static Window
get_owner_whole_window( HWND owner
, BOOL force_managed
)
1192 struct x11drv_win_data
*data
;
1194 if (!owner
) return 0;
1196 if (!(data
= X11DRV_get_win_data( owner
)))
1198 if (GetWindowThreadProcessId( owner
, NULL
) != GetCurrentThreadId() ||
1199 !(data
= X11DRV_create_win_data( owner
)))
1200 return (Window
)GetPropA( owner
, whole_window_prop
);
1202 else if (!data
->managed
&& force_managed
) /* make it managed */
1204 SetWindowPos( owner
, 0, 0, 0, 0, 0,
1205 SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOMOVE
|
1206 SWP_NOREDRAW
| SWP_DEFERERASE
| SWP_NOSENDCHANGING
| SWP_STATECHANGED
);
1208 return data
->whole_window
;
1212 /***********************************************************************
1215 * Set the window manager hints for a newly-created window
1217 static void set_wm_hints( Display
*display
, struct x11drv_win_data
*data
)
1219 Window group_leader
= data
->whole_window
;
1220 Window owner_win
= 0;
1222 DWORD style
, ex_style
;
1225 if (data
->hwnd
== GetDesktopWindow())
1227 /* force some styles for the desktop to get the correct decorations */
1228 style
= WS_POPUP
| WS_VISIBLE
| WS_CAPTION
| WS_SYSMENU
| WS_MINIMIZEBOX
;
1229 ex_style
= WS_EX_APPWINDOW
;
1234 style
= GetWindowLongW( data
->hwnd
, GWL_STYLE
);
1235 ex_style
= GetWindowLongW( data
->hwnd
, GWL_EXSTYLE
);
1236 owner
= GetWindow( data
->hwnd
, GW_OWNER
);
1237 if ((owner_win
= get_owner_whole_window( owner
, data
->managed
))) group_leader
= owner_win
;
1242 if (owner_win
) XSetTransientForHint( display
, data
->whole_window
, owner_win
);
1245 set_size_hints( display
, data
, style
);
1246 set_mwm_hints( display
, data
, style
, ex_style
);
1248 /* Only use dialog type for owned popups. Metacity allows making fullscreen
1249 * only normal windows, and doesn't handle correctly TRANSIENT_FOR hint for
1250 * dialogs owned by fullscreen windows.
1252 if (((style
& WS_POPUP
) || (ex_style
& WS_EX_DLGMODALFRAME
)) && owner
) window_type
= x11drv_atom(_NET_WM_WINDOW_TYPE_DIALOG
);
1253 else window_type
= x11drv_atom(_NET_WM_WINDOW_TYPE_NORMAL
);
1255 XChangeProperty(display
, data
->whole_window
, x11drv_atom(_NET_WM_WINDOW_TYPE
),
1256 XA_ATOM
, 32, PropModeReplace
, (unsigned char*)&window_type
, 1);
1261 data
->wm_hints
->flags
|= InputHint
| StateHint
| WindowGroupHint
;
1262 data
->wm_hints
->input
= !use_take_focus
&& !(style
& WS_DISABLED
);
1263 data
->wm_hints
->initial_state
= (style
& WS_MINIMIZE
) ? IconicState
: NormalState
;
1264 data
->wm_hints
->window_group
= group_leader
;
1265 XSetWMHints( display
, data
->whole_window
, data
->wm_hints
);
1268 wine_tsx11_unlock();
1272 /***********************************************************************
1275 Window
init_clip_window(void)
1277 struct x11drv_thread_data
*data
= x11drv_init_thread_data();
1279 if (!data
->clip_window
&&
1280 (data
->clip_window
= (Window
)GetPropA( GetDesktopWindow(), clip_window_prop
)))
1283 XSelectInput( data
->display
, data
->clip_window
, StructureNotifyMask
);
1284 wine_tsx11_unlock();
1286 return data
->clip_window
;
1290 /***********************************************************************
1293 void update_user_time( Time time
)
1296 if (!user_time_window
)
1298 user_time_window
= XCreateWindow( gdi_display
, root_window
, -1, -1, 1, 1, 0, 0, InputOnly
,
1299 DefaultVisual(gdi_display
,DefaultScreen(gdi_display
)), 0, NULL
);
1300 TRACE( "user time window %lx\n", user_time_window
);
1302 if (time
&& (!last_user_time
|| (long)(time
- last_user_time
) > 0))
1304 last_user_time
= time
;
1305 XChangeProperty( gdi_display
, user_time_window
, x11drv_atom(_NET_WM_USER_TIME
),
1306 XA_CARDINAL
, 32, PropModeReplace
, (unsigned char *)&time
, 1 );
1308 wine_tsx11_unlock();
1311 /***********************************************************************
1312 * update_net_wm_states
1314 void update_net_wm_states( Display
*display
, struct x11drv_win_data
*data
)
1316 static const unsigned int state_atoms
[NB_NET_WM_STATES
] =
1318 XATOM__NET_WM_STATE_FULLSCREEN
,
1319 XATOM__NET_WM_STATE_ABOVE
,
1320 XATOM__NET_WM_STATE_MAXIMIZED_VERT
,
1321 XATOM__NET_WM_STATE_SKIP_PAGER
,
1322 XATOM__NET_WM_STATE_SKIP_TASKBAR
1325 DWORD i
, style
, ex_style
, new_state
= 0;
1327 if (!data
->managed
) return;
1328 if (data
->whole_window
== root_window
) return;
1330 style
= GetWindowLongW( data
->hwnd
, GWL_STYLE
);
1331 if (is_window_rect_fullscreen( &data
->whole_rect
))
1333 if ((style
& WS_MAXIMIZE
) && (style
& WS_CAPTION
) == WS_CAPTION
)
1334 new_state
|= (1 << NET_WM_STATE_MAXIMIZED
);
1335 else if (!(style
& WS_MINIMIZE
))
1336 new_state
|= (1 << NET_WM_STATE_FULLSCREEN
);
1338 else if (style
& WS_MAXIMIZE
)
1339 new_state
|= (1 << NET_WM_STATE_MAXIMIZED
);
1341 ex_style
= GetWindowLongW( data
->hwnd
, GWL_EXSTYLE
);
1342 if (ex_style
& WS_EX_TOPMOST
)
1343 new_state
|= (1 << NET_WM_STATE_ABOVE
);
1344 if (ex_style
& (WS_EX_TOOLWINDOW
| WS_EX_NOACTIVATE
))
1345 new_state
|= (1 << NET_WM_STATE_SKIP_TASKBAR
) | (1 << NET_WM_STATE_SKIP_PAGER
);
1346 if (!(ex_style
& WS_EX_APPWINDOW
) && GetWindow( data
->hwnd
, GW_OWNER
))
1347 new_state
|= (1 << NET_WM_STATE_SKIP_TASKBAR
);
1349 if (!data
->mapped
) /* set the _NET_WM_STATE atom directly */
1351 Atom atoms
[NB_NET_WM_STATES
+1];
1354 for (i
= count
= 0; i
< NB_NET_WM_STATES
; i
++)
1356 if (!(new_state
& (1 << i
))) continue;
1357 TRACE( "setting wm state %u for unmapped window %p/%lx\n",
1358 i
, data
->hwnd
, data
->whole_window
);
1359 atoms
[count
++] = X11DRV_Atoms
[state_atoms
[i
] - FIRST_XATOM
];
1360 if (state_atoms
[i
] == XATOM__NET_WM_STATE_MAXIMIZED_VERT
)
1361 atoms
[count
++] = x11drv_atom(_NET_WM_STATE_MAXIMIZED_HORZ
);
1364 XChangeProperty( display
, data
->whole_window
, x11drv_atom(_NET_WM_STATE
), XA_ATOM
,
1365 32, PropModeReplace
, (unsigned char *)atoms
, count
);
1366 wine_tsx11_unlock();
1368 else /* ask the window manager to do it for us */
1372 xev
.xclient
.type
= ClientMessage
;
1373 xev
.xclient
.window
= data
->whole_window
;
1374 xev
.xclient
.message_type
= x11drv_atom(_NET_WM_STATE
);
1375 xev
.xclient
.serial
= 0;
1376 xev
.xclient
.display
= display
;
1377 xev
.xclient
.send_event
= True
;
1378 xev
.xclient
.format
= 32;
1379 xev
.xclient
.data
.l
[3] = 1;
1381 for (i
= 0; i
< NB_NET_WM_STATES
; i
++)
1383 if (!((data
->net_wm_state
^ new_state
) & (1 << i
))) continue; /* unchanged */
1385 TRACE( "setting wm state %u for window %p/%lx to %u prev %u\n",
1386 i
, data
->hwnd
, data
->whole_window
,
1387 (new_state
& (1 << i
)) != 0, (data
->net_wm_state
& (1 << i
)) != 0 );
1389 xev
.xclient
.data
.l
[0] = (new_state
& (1 << i
)) ? _NET_WM_STATE_ADD
: _NET_WM_STATE_REMOVE
;
1390 xev
.xclient
.data
.l
[1] = X11DRV_Atoms
[state_atoms
[i
] - FIRST_XATOM
];
1391 xev
.xclient
.data
.l
[2] = ((state_atoms
[i
] == XATOM__NET_WM_STATE_MAXIMIZED_VERT
) ?
1392 x11drv_atom(_NET_WM_STATE_MAXIMIZED_HORZ
) : 0);
1394 XSendEvent( display
, root_window
, False
,
1395 SubstructureRedirectMask
| SubstructureNotifyMask
, &xev
);
1396 wine_tsx11_unlock();
1399 data
->net_wm_state
= new_state
;
1403 /***********************************************************************
1406 static void set_xembed_flags( Display
*display
, struct x11drv_win_data
*data
, unsigned long flags
)
1408 unsigned long info
[2];
1410 if (!data
->whole_window
) return;
1412 info
[0] = 0; /* protocol version */
1415 XChangeProperty( display
, data
->whole_window
, x11drv_atom(_XEMBED_INFO
),
1416 x11drv_atom(_XEMBED_INFO
), 32, PropModeReplace
, (unsigned char*)info
, 2 );
1417 wine_tsx11_unlock();
1421 /***********************************************************************
1424 static void map_window( Display
*display
, struct x11drv_win_data
*data
, DWORD new_style
)
1426 TRACE( "win %p/%lx\n", data
->hwnd
, data
->whole_window
);
1428 remove_startup_notification( display
, data
->whole_window
);
1430 wait_for_withdrawn_state( display
, data
, TRUE
);
1432 if (!data
->embedded
)
1434 update_net_wm_states( display
, data
);
1435 sync_window_style( display
, data
);
1437 XMapWindow( display
, data
->whole_window
);
1438 wine_tsx11_unlock();
1440 else set_xembed_flags( display
, data
, XEMBED_MAPPED
);
1442 data
->mapped
= TRUE
;
1443 data
->iconic
= (new_style
& WS_MINIMIZE
) != 0;
1447 /***********************************************************************
1450 static void unmap_window( Display
*display
, struct x11drv_win_data
*data
)
1452 TRACE( "win %p/%lx\n", data
->hwnd
, data
->whole_window
);
1454 if (!data
->embedded
)
1456 wait_for_withdrawn_state( display
, data
, FALSE
);
1458 if (data
->managed
) XWithdrawWindow( display
, data
->whole_window
, DefaultScreen(display
) );
1459 else XUnmapWindow( display
, data
->whole_window
);
1460 wine_tsx11_unlock();
1462 else set_xembed_flags( display
, data
, 0 );
1464 data
->mapped
= FALSE
;
1465 data
->net_wm_state
= 0;
1469 /***********************************************************************
1470 * make_window_embedded
1472 void make_window_embedded( Display
*display
, struct x11drv_win_data
*data
)
1474 BOOL was_mapped
= data
->mapped
;
1475 /* the window cannot be mapped before being embedded */
1476 if (data
->mapped
) unmap_window( display
, data
);
1478 data
->embedded
= TRUE
;
1479 data
->managed
= TRUE
;
1480 SetPropA( data
->hwnd
, managed_prop
, (HANDLE
)1 );
1481 sync_window_style( display
, data
);
1484 map_window( display
, data
, 0 );
1486 set_xembed_flags( display
, data
, 0 );
1490 /***********************************************************************
1491 * X11DRV_window_to_X_rect
1493 * Convert a rect from client to X window coordinates
1495 static void X11DRV_window_to_X_rect( struct x11drv_win_data
*data
, RECT
*rect
)
1499 if (!data
->managed
) return;
1500 if (IsRectEmpty( rect
)) return;
1502 get_x11_rect_offset( data
, &rc
);
1504 rect
->left
-= rc
.left
;
1505 rect
->right
-= rc
.right
;
1506 rect
->top
-= rc
.top
;
1507 rect
->bottom
-= rc
.bottom
;
1508 if (rect
->top
>= rect
->bottom
) rect
->bottom
= rect
->top
+ 1;
1509 if (rect
->left
>= rect
->right
) rect
->right
= rect
->left
+ 1;
1513 /***********************************************************************
1514 * X11DRV_X_to_window_rect
1516 * Opposite of X11DRV_window_to_X_rect
1518 void X11DRV_X_to_window_rect( struct x11drv_win_data
*data
, RECT
*rect
)
1522 if (!data
->managed
) return;
1523 if (IsRectEmpty( rect
)) return;
1525 get_x11_rect_offset( data
, &rc
);
1527 rect
->left
+= rc
.left
;
1528 rect
->right
+= rc
.right
;
1529 rect
->top
+= rc
.top
;
1530 rect
->bottom
+= rc
.bottom
;
1531 if (rect
->top
>= rect
->bottom
) rect
->bottom
= rect
->top
+ 1;
1532 if (rect
->left
>= rect
->right
) rect
->right
= rect
->left
+ 1;
1536 /***********************************************************************
1537 * sync_window_position
1539 * Synchronize the X window position with the Windows one
1541 static void sync_window_position( Display
*display
, struct x11drv_win_data
*data
,
1542 UINT swp_flags
, const RECT
*old_window_rect
,
1543 const RECT
*old_whole_rect
, const RECT
*old_client_rect
)
1545 DWORD style
= GetWindowLongW( data
->hwnd
, GWL_STYLE
);
1546 DWORD ex_style
= GetWindowLongW( data
->hwnd
, GWL_EXSTYLE
);
1547 XWindowChanges changes
;
1548 unsigned int mask
= 0;
1550 if (data
->managed
&& data
->iconic
) return;
1552 /* resizing a managed maximized window is not allowed */
1553 if (!(style
& WS_MAXIMIZE
) || !data
->managed
)
1555 changes
.width
= data
->whole_rect
.right
- data
->whole_rect
.left
;
1556 changes
.height
= data
->whole_rect
.bottom
- data
->whole_rect
.top
;
1557 /* if window rect is empty force size to 1x1 */
1558 if (changes
.width
<= 0 || changes
.height
<= 0) changes
.width
= changes
.height
= 1;
1559 if (changes
.width
> 65535) changes
.width
= 65535;
1560 if (changes
.height
> 65535) changes
.height
= 65535;
1561 mask
|= CWWidth
| CWHeight
;
1564 /* only the size is allowed to change for the desktop window */
1565 if (data
->whole_window
!= root_window
)
1567 changes
.x
= data
->whole_rect
.left
- virtual_screen_rect
.left
;
1568 changes
.y
= data
->whole_rect
.top
- virtual_screen_rect
.top
;
1572 if (!(swp_flags
& SWP_NOZORDER
) || (swp_flags
& SWP_SHOWWINDOW
))
1574 /* find window that this one must be after */
1575 HWND prev
= GetWindow( data
->hwnd
, GW_HWNDPREV
);
1576 while (prev
&& !(GetWindowLongW( prev
, GWL_STYLE
) & WS_VISIBLE
))
1577 prev
= GetWindow( prev
, GW_HWNDPREV
);
1578 if (!prev
) /* top child */
1580 changes
.stack_mode
= Above
;
1581 mask
|= CWStackMode
;
1583 /* should use stack_mode Below but most window managers don't get it right */
1584 /* and Above with a sibling doesn't work so well either, so we ignore it */
1588 set_size_hints( display
, data
, style
);
1589 set_mwm_hints( display
, data
, style
, ex_style
);
1590 data
->configure_serial
= NextRequest( display
);
1591 XReconfigureWMWindow( display
, data
->whole_window
,
1592 DefaultScreen(display
), mask
, &changes
);
1593 wine_tsx11_unlock();
1594 #ifdef HAVE_LIBXSHAPE
1595 if (IsRectEmpty( old_window_rect
) != IsRectEmpty( &data
->window_rect
))
1596 sync_window_region( display
, data
, (HRGN
)1 );
1599 int old_x_offset
= old_window_rect
->left
- old_whole_rect
->left
;
1600 int old_y_offset
= old_window_rect
->top
- old_whole_rect
->top
;
1601 int new_x_offset
= data
->window_rect
.left
- data
->whole_rect
.left
;
1602 int new_y_offset
= data
->window_rect
.top
- data
->whole_rect
.top
;
1603 if (old_x_offset
!= new_x_offset
|| old_y_offset
!= new_y_offset
)
1606 XShapeOffsetShape( display
, data
->whole_window
, ShapeBounding
,
1607 new_x_offset
- old_x_offset
, new_y_offset
- old_y_offset
);
1608 wine_tsx11_unlock();
1613 TRACE( "win %p/%lx pos %d,%d,%dx%d after %lx changes=%x serial=%lu\n",
1614 data
->hwnd
, data
->whole_window
, data
->whole_rect
.left
, data
->whole_rect
.top
,
1615 data
->whole_rect
.right
- data
->whole_rect
.left
,
1616 data
->whole_rect
.bottom
- data
->whole_rect
.top
,
1617 changes
.sibling
, mask
, data
->configure_serial
);
1621 /***********************************************************************
1622 * sync_client_position
1624 * Synchronize the X client window position with the Windows one
1626 static void sync_client_position( Display
*display
, struct x11drv_win_data
*data
,
1627 UINT swp_flags
, const RECT
*old_client_rect
,
1628 const RECT
*old_whole_rect
)
1631 XWindowChanges changes
;
1632 RECT old
= *old_client_rect
;
1633 RECT
new = data
->client_rect
;
1635 OffsetRect( &old
, -old_whole_rect
->left
, -old_whole_rect
->top
);
1636 OffsetRect( &new, -data
->whole_rect
.left
, -data
->whole_rect
.top
);
1637 if (!(mask
= get_window_changes( &changes
, &old
, &new ))) return;
1639 if (data
->client_window
)
1641 TRACE( "setting client win %lx pos %d,%d,%dx%d changes=%x\n",
1642 data
->client_window
, new.left
, new.top
,
1643 new.right
- new.left
, new.bottom
- new.top
, mask
);
1645 XConfigureWindow( display
, data
->client_window
, mask
, &changes
);
1646 wine_tsx11_unlock();
1649 if (data
->gl_drawable
&& (mask
& (CWWidth
|CWHeight
))) sync_gl_drawable( data
);
1653 /***********************************************************************
1656 * Move the window bits when a window is moved.
1658 static void move_window_bits( struct x11drv_win_data
*data
, const RECT
*old_rect
, const RECT
*new_rect
,
1659 const RECT
*old_client_rect
)
1661 RECT src_rect
= *old_rect
;
1662 RECT dst_rect
= *new_rect
;
1663 HDC hdc_src
, hdc_dst
;
1668 if (!data
->whole_window
)
1670 OffsetRect( &dst_rect
, -data
->window_rect
.left
, -data
->window_rect
.top
);
1671 parent
= GetAncestor( data
->hwnd
, GA_PARENT
);
1672 hdc_src
= GetDCEx( parent
, 0, DCX_CACHE
);
1673 hdc_dst
= GetDCEx( data
->hwnd
, 0, DCX_CACHE
| DCX_WINDOW
);
1677 OffsetRect( &dst_rect
, -data
->client_rect
.left
, -data
->client_rect
.top
);
1678 /* make src rect relative to the old position of the window */
1679 OffsetRect( &src_rect
, -old_client_rect
->left
, -old_client_rect
->top
);
1680 if (dst_rect
.left
== src_rect
.left
&& dst_rect
.top
== src_rect
.top
) return;
1681 hdc_src
= hdc_dst
= GetDCEx( data
->hwnd
, 0, DCX_CACHE
);
1684 rgn
= CreateRectRgnIndirect( &dst_rect
);
1685 SelectClipRgn( hdc_dst
, rgn
);
1686 DeleteObject( rgn
);
1687 ExcludeUpdateRgn( hdc_dst
, data
->hwnd
);
1689 code
= X11DRV_START_EXPOSURES
;
1690 ExtEscape( hdc_dst
, X11DRV_ESCAPE
, sizeof(code
), (LPSTR
)&code
, 0, NULL
);
1692 TRACE( "copying bits for win %p/%lx/%lx %s -> %s\n",
1693 data
->hwnd
, data
->whole_window
, data
->client_window
,
1694 wine_dbgstr_rect(&src_rect
), wine_dbgstr_rect(&dst_rect
) );
1695 BitBlt( hdc_dst
, dst_rect
.left
, dst_rect
.top
,
1696 dst_rect
.right
- dst_rect
.left
, dst_rect
.bottom
- dst_rect
.top
,
1697 hdc_src
, src_rect
.left
, src_rect
.top
, SRCCOPY
);
1700 code
= X11DRV_END_EXPOSURES
;
1701 ExtEscape( hdc_dst
, X11DRV_ESCAPE
, sizeof(code
), (LPSTR
)&code
, sizeof(rgn
), (LPSTR
)&rgn
);
1703 ReleaseDC( data
->hwnd
, hdc_dst
);
1704 if (hdc_src
!= hdc_dst
) ReleaseDC( parent
, hdc_src
);
1708 if (!data
->whole_window
)
1710 /* map region to client rect since we are using DCX_WINDOW */
1711 OffsetRgn( rgn
, data
->window_rect
.left
- data
->client_rect
.left
,
1712 data
->window_rect
.top
- data
->client_rect
.top
);
1713 RedrawWindow( data
->hwnd
, NULL
, rgn
,
1714 RDW_INVALIDATE
| RDW_FRAME
| RDW_ERASE
| RDW_ALLCHILDREN
);
1716 else RedrawWindow( data
->hwnd
, NULL
, rgn
, RDW_INVALIDATE
| RDW_ERASE
| RDW_ALLCHILDREN
);
1717 DeleteObject( rgn
);
1722 /**********************************************************************
1723 * create_whole_window
1725 * Create the whole X window for a given window
1727 static Window
create_whole_window( Display
*display
, struct x11drv_win_data
*data
)
1730 XSetWindowAttributes attr
;
1734 DWORD layered_flags
;
1737 if (!data
->managed
&& is_window_managed( data
->hwnd
, SWP_NOACTIVATE
, &data
->window_rect
))
1739 TRACE( "making win %p/%lx managed\n", data
->hwnd
, data
->whole_window
);
1740 data
->managed
= TRUE
;
1741 SetPropA( data
->hwnd
, managed_prop
, (HANDLE
)1 );
1744 if ((win_rgn
= CreateRectRgn( 0, 0, 0, 0 )) &&
1745 GetWindowRgn( data
->hwnd
, win_rgn
) == ERROR
)
1747 DeleteObject( win_rgn
);
1750 data
->shaped
= (win_rgn
!= 0);
1752 mask
= get_window_attributes( display
, data
, &attr
);
1754 data
->whole_rect
= data
->window_rect
;
1755 X11DRV_window_to_X_rect( data
, &data
->whole_rect
);
1756 if (!(cx
= data
->whole_rect
.right
- data
->whole_rect
.left
)) cx
= 1;
1757 else if (cx
> 65535) cx
= 65535;
1758 if (!(cy
= data
->whole_rect
.bottom
- data
->whole_rect
.top
)) cy
= 1;
1759 else if (cy
> 65535) cy
= 65535;
1762 data
->whole_window
= XCreateWindow( display
, root_window
,
1763 data
->whole_rect
.left
- virtual_screen_rect
.left
,
1764 data
->whole_rect
.top
- virtual_screen_rect
.top
,
1765 cx
, cy
, 0, screen_depth
, InputOutput
,
1766 visual
, mask
, &attr
);
1768 if (data
->whole_window
) XSaveContext( display
, data
->whole_window
, winContext
, (char *)data
->hwnd
);
1769 wine_tsx11_unlock();
1771 if (!data
->whole_window
) goto done
;
1773 if (!create_client_window( display
, data
, NULL
))
1776 XDeleteContext( display
, data
->whole_window
, winContext
);
1777 XDestroyWindow( display
, data
->whole_window
);
1778 data
->whole_window
= 0;
1779 wine_tsx11_unlock();
1783 set_initial_wm_hints( display
, data
);
1784 set_wm_hints( display
, data
);
1786 SetPropA( data
->hwnd
, whole_window_prop
, (HANDLE
)data
->whole_window
);
1788 /* set the window text */
1789 if (!InternalGetWindowText( data
->hwnd
, text
, sizeof(text
)/sizeof(WCHAR
) )) text
[0] = 0;
1790 sync_window_text( display
, data
->whole_window
, text
);
1792 /* set the window region */
1793 if (win_rgn
|| IsRectEmpty( &data
->window_rect
)) sync_window_region( display
, data
, win_rgn
);
1795 /* set the window opacity */
1796 if (!GetLayeredWindowAttributes( data
->hwnd
, &key
, &alpha
, &layered_flags
)) layered_flags
= 0;
1797 sync_window_opacity( display
, data
->whole_window
, key
, alpha
, layered_flags
);
1799 init_clip_window(); /* make sure the clip window is initialized in this thread */
1802 XFlush( display
); /* make sure the window exists before we start painting to it */
1803 wine_tsx11_unlock();
1805 sync_window_cursor( data
->whole_window
);
1808 if (win_rgn
) DeleteObject( win_rgn
);
1809 return data
->whole_window
;
1813 /**********************************************************************
1814 * destroy_whole_window
1816 * Destroy the whole X window for a given window.
1818 static void destroy_whole_window( Display
*display
, struct x11drv_win_data
*data
, BOOL already_destroyed
)
1820 if (!data
->whole_window
)
1824 Window xwin
= (Window
)GetPropA( data
->hwnd
, foreign_window_prop
);
1828 if (!already_destroyed
) XSelectInput( display
, xwin
, 0 );
1829 XDeleteContext( display
, xwin
, winContext
);
1830 wine_tsx11_unlock();
1831 RemovePropA( data
->hwnd
, foreign_window_prop
);
1838 TRACE( "win %p xwin %lx/%lx\n", data
->hwnd
, data
->whole_window
, data
->client_window
);
1840 XDeleteContext( display
, data
->whole_window
, winContext
);
1841 XDeleteContext( display
, data
->client_window
, winContext
);
1842 if (!already_destroyed
) XDestroyWindow( display
, data
->whole_window
);
1843 data
->whole_window
= data
->client_window
= 0;
1844 data
->wm_state
= WithdrawnState
;
1845 data
->net_wm_state
= 0;
1846 data
->mapped
= FALSE
;
1849 XUnsetICFocus( data
->xic
);
1850 XDestroyIC( data
->xic
);
1853 /* Outlook stops processing messages after destroying a dialog, so we need an explicit flush */
1855 XFree( data
->wm_hints
);
1856 data
->wm_hints
= NULL
;
1857 wine_tsx11_unlock();
1858 RemovePropA( data
->hwnd
, whole_window_prop
);
1859 RemovePropA( data
->hwnd
, client_window_prop
);
1863 /*****************************************************************
1864 * SetWindowText (X11DRV.@)
1866 void CDECL
X11DRV_SetWindowText( HWND hwnd
, LPCWSTR text
)
1870 if ((win
= X11DRV_get_whole_window( hwnd
)) && win
!= DefaultRootWindow(gdi_display
))
1872 Display
*display
= thread_init_display();
1873 sync_window_text( display
, win
, text
);
1878 /***********************************************************************
1879 * SetWindowStyle (X11DRV.@)
1881 * Update the X state of a window to reflect a style change
1883 void CDECL
X11DRV_SetWindowStyle( HWND hwnd
, INT offset
, STYLESTRUCT
*style
)
1885 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
1888 if (hwnd
== GetDesktopWindow()) return;
1889 changed
= style
->styleNew
^ style
->styleOld
;
1891 /* if WS_VISIBLE was set through WM_SETREDRAW, map the window if it's the first time */
1892 if (offset
== GWL_STYLE
&& (changed
& WS_VISIBLE
) && (style
->styleNew
& WS_VISIBLE
) && !data
)
1894 if (!(data
= X11DRV_create_win_data( hwnd
))) return;
1896 if (data
->whole_window
&& is_window_rect_mapped( &data
->window_rect
))
1898 Display
*display
= thread_display();
1899 set_wm_hints( display
, data
);
1900 if (!data
->mapped
) map_window( display
, data
, style
->styleNew
);
1903 if (!data
|| !data
->whole_window
) return;
1905 if (offset
== GWL_STYLE
&& (changed
& WS_DISABLED
))
1906 set_wm_hints( thread_display(), data
);
1908 if (offset
== GWL_EXSTYLE
&& (changed
& WS_EX_LAYERED
)) /* changing WS_EX_LAYERED resets attributes */
1909 sync_window_opacity( thread_display(), data
->whole_window
, 0, 0, 0 );
1913 /***********************************************************************
1914 * DestroyWindow (X11DRV.@)
1916 void CDECL
X11DRV_DestroyWindow( HWND hwnd
)
1918 struct x11drv_thread_data
*thread_data
= x11drv_thread_data();
1919 struct x11drv_win_data
*data
;
1921 if (!(data
= X11DRV_get_win_data( hwnd
))) return;
1926 destroy_glxpixmap(gdi_display
, data
->gl_drawable
);
1927 XFreePixmap(gdi_display
, data
->pixmap
);
1928 wine_tsx11_unlock();
1930 else if (data
->gl_drawable
)
1933 XDestroyWindow(gdi_display
, data
->gl_drawable
);
1934 wine_tsx11_unlock();
1937 destroy_whole_window( thread_data
->display
, data
, FALSE
);
1938 destroy_icon_window( thread_data
->display
, data
);
1943 XFreeColormap( thread_data
->display
, data
->colormap
);
1944 wine_tsx11_unlock();
1947 if (thread_data
->last_focus
== hwnd
) thread_data
->last_focus
= 0;
1948 if (thread_data
->last_xic_hwnd
== hwnd
) thread_data
->last_xic_hwnd
= 0;
1950 if (data
->icon_pixmap
) XFreePixmap( gdi_display
, data
->icon_pixmap
);
1951 if (data
->icon_mask
) XFreePixmap( gdi_display
, data
->icon_mask
);
1952 XDeleteContext( thread_data
->display
, (XID
)hwnd
, win_data_context
);
1953 wine_tsx11_unlock();
1954 HeapFree( GetProcessHeap(), 0, data
);
1958 /***********************************************************************
1959 * X11DRV_DestroyNotify
1961 void X11DRV_DestroyNotify( HWND hwnd
, XEvent
*event
)
1963 Display
*display
= event
->xdestroywindow
.display
;
1964 struct x11drv_win_data
*data
;
1966 if (!(data
= X11DRV_get_win_data( hwnd
))) return;
1967 if (!data
->embedded
) FIXME( "window %p/%lx destroyed from the outside\n", hwnd
, data
->whole_window
);
1969 destroy_whole_window( display
, data
, TRUE
);
1970 if (data
->embedded
) SendMessageW( hwnd
, WM_CLOSE
, 0, 0 );
1974 static struct x11drv_win_data
*alloc_win_data( Display
*display
, HWND hwnd
)
1976 struct x11drv_win_data
*data
;
1978 if ((data
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*data
))))
1982 if (!winContext
) winContext
= XUniqueContext();
1983 if (!win_data_context
) win_data_context
= XUniqueContext();
1984 XSaveContext( display
, (XID
)hwnd
, win_data_context
, (char *)data
);
1985 wine_tsx11_unlock();
1991 /* initialize the desktop window id in the desktop manager process */
1992 static struct x11drv_win_data
*create_desktop_win_data( Display
*display
, HWND hwnd
)
1994 struct x11drv_win_data
*data
;
1996 if (!(data
= alloc_win_data( display
, hwnd
))) return NULL
;
1997 data
->whole_window
= data
->client_window
= root_window
;
1998 data
->managed
= TRUE
;
1999 SetPropA( data
->hwnd
, managed_prop
, (HANDLE
)1 );
2000 SetPropA( data
->hwnd
, whole_window_prop
, (HANDLE
)root_window
);
2001 SetPropA( data
->hwnd
, client_window_prop
, (HANDLE
)root_window
);
2002 set_initial_wm_hints( display
, data
);
2006 /**********************************************************************
2007 * CreateDesktopWindow (X11DRV.@)
2009 BOOL CDECL
X11DRV_CreateDesktopWindow( HWND hwnd
)
2011 unsigned int width
, height
;
2013 /* retrieve the real size of the desktop */
2014 SERVER_START_REQ( get_window_rectangles
)
2016 req
->handle
= wine_server_user_handle( hwnd
);
2017 req
->relative
= COORDS_CLIENT
;
2018 wine_server_call( req
);
2019 width
= reply
->window
.right
;
2020 height
= reply
->window
.bottom
;
2024 if (!width
&& !height
) /* not initialized yet */
2026 SERVER_START_REQ( set_window_pos
)
2028 req
->handle
= wine_server_user_handle( hwnd
);
2030 req
->flags
= SWP_NOZORDER
;
2031 req
->window
.left
= virtual_screen_rect
.left
;
2032 req
->window
.top
= virtual_screen_rect
.top
;
2033 req
->window
.right
= virtual_screen_rect
.right
;
2034 req
->window
.bottom
= virtual_screen_rect
.bottom
;
2035 req
->client
= req
->window
;
2036 wine_server_call( req
);
2042 Window win
= (Window
)GetPropA( hwnd
, whole_window_prop
);
2043 if (win
&& win
!= root_window
) X11DRV_init_desktop( win
, width
, height
);
2049 /**********************************************************************
2050 * CreateWindow (X11DRV.@)
2052 BOOL CDECL
X11DRV_CreateWindow( HWND hwnd
)
2054 if (hwnd
== GetDesktopWindow())
2056 struct x11drv_thread_data
*data
= x11drv_init_thread_data();
2057 XSetWindowAttributes attr
;
2059 if (root_window
!= DefaultRootWindow( gdi_display
))
2061 /* the desktop win data can't be created lazily */
2062 if (!create_desktop_win_data( data
->display
, hwnd
)) return FALSE
;
2065 /* create the cursor clipping window */
2066 attr
.override_redirect
= TRUE
;
2067 attr
.event_mask
= StructureNotifyMask
| FocusChangeMask
;
2069 data
->clip_window
= XCreateWindow( data
->display
, root_window
, 0, 0, 1, 1, 0, 0,
2070 InputOnly
, visual
, CWOverrideRedirect
| CWEventMask
, &attr
);
2071 XFlush( data
->display
);
2072 wine_tsx11_unlock();
2073 SetPropA( hwnd
, clip_window_prop
, (HANDLE
)data
->clip_window
);
2079 /***********************************************************************
2080 * X11DRV_get_win_data
2082 * Return the X11 data structure associated with a window.
2084 struct x11drv_win_data
*X11DRV_get_win_data( HWND hwnd
)
2086 struct x11drv_thread_data
*thread_data
= x11drv_thread_data();
2089 if (!thread_data
) return NULL
;
2090 if (!hwnd
) return NULL
;
2091 if (XFindContext( thread_data
->display
, (XID
)hwnd
, win_data_context
, &data
)) data
= NULL
;
2092 return (struct x11drv_win_data
*)data
;
2096 /***********************************************************************
2097 * X11DRV_create_win_data
2099 * Create an X11 data window structure for an existing window.
2101 struct x11drv_win_data
*X11DRV_create_win_data( HWND hwnd
)
2104 struct x11drv_win_data
*data
;
2107 if (!(parent
= GetAncestor( hwnd
, GA_PARENT
))) return NULL
; /* desktop */
2109 /* don't create win data for HWND_MESSAGE windows */
2110 if (parent
!= GetDesktopWindow() && !GetAncestor( parent
, GA_PARENT
)) return NULL
;
2112 display
= thread_init_display();
2113 if (!(data
= alloc_win_data( display
, hwnd
))) return NULL
;
2115 GetWindowRect( hwnd
, &data
->window_rect
);
2116 MapWindowPoints( 0, parent
, (POINT
*)&data
->window_rect
, 2 );
2117 data
->whole_rect
= data
->window_rect
;
2118 GetClientRect( hwnd
, &data
->client_rect
);
2119 MapWindowPoints( hwnd
, parent
, (POINT
*)&data
->client_rect
, 2 );
2121 if (parent
== GetDesktopWindow())
2123 if (!create_whole_window( display
, data
))
2125 HeapFree( GetProcessHeap(), 0, data
);
2128 TRACE( "win %p/%lx/%lx window %s whole %s client %s\n",
2129 hwnd
, data
->whole_window
, data
->client_window
, wine_dbgstr_rect( &data
->window_rect
),
2130 wine_dbgstr_rect( &data
->whole_rect
), wine_dbgstr_rect( &data
->client_rect
));
2136 /* window procedure for foreign windows */
2137 static LRESULT WINAPI
foreign_window_proc( HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
)
2141 case WM_WINDOWPOSCHANGED
:
2142 update_systray_balloon_position();
2144 case WM_PARENTNOTIFY
:
2145 if (LOWORD(wparam
) == WM_DESTROY
)
2147 TRACE( "%p: got parent notify destroy for win %lx\n", hwnd
, lparam
);
2148 PostMessageW( hwnd
, WM_CLOSE
, 0, 0 ); /* so that we come back here once the child is gone */
2152 if (GetWindow( hwnd
, GW_CHILD
)) return 0; /* refuse to die if we still have children */
2155 return DefWindowProcW( hwnd
, msg
, wparam
, lparam
);
2159 /***********************************************************************
2160 * create_foreign_window
2162 * Create a foreign window for the specified X window and its ancestors
2164 HWND
create_foreign_window( Display
*display
, Window xwin
)
2166 static const WCHAR classW
[] = {'_','_','w','i','n','e','_','x','1','1','_','f','o','r','e','i','g','n','_','w','i','n','d','o','w',0};
2167 static BOOL class_registered
;
2168 struct x11drv_win_data
*data
;
2170 Window xparent
, xroot
;
2172 unsigned int nchildren
;
2173 XWindowAttributes attr
;
2174 DWORD style
= WS_CLIPCHILDREN
;
2176 if (!class_registered
)
2180 memset( &class, 0, sizeof(class) );
2181 class.cbSize
= sizeof(class);
2182 class.lpfnWndProc
= foreign_window_proc
;
2183 class.lpszClassName
= classW
;
2184 if (!RegisterClassExW( &class ) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS
)
2186 ERR( "Could not register foreign window class\n" );
2189 class_registered
= TRUE
;
2193 if (XFindContext( display
, xwin
, winContext
, (char **)&hwnd
)) hwnd
= 0;
2194 if (hwnd
) /* already created */
2196 wine_tsx11_unlock();
2200 XSelectInput( display
, xwin
, StructureNotifyMask
);
2201 if (!XGetWindowAttributes( display
, xwin
, &attr
) ||
2202 !XQueryTree( display
, xwin
, &xroot
, &xparent
, &xchildren
, &nchildren
))
2204 XSelectInput( display
, xwin
, 0 );
2205 wine_tsx11_unlock();
2209 wine_tsx11_unlock();
2211 if (xparent
== xroot
)
2213 parent
= GetDesktopWindow();
2215 attr
.x
+= virtual_screen_rect
.left
;
2216 attr
.y
+= virtual_screen_rect
.top
;
2220 parent
= create_foreign_window( display
, xparent
);
2224 hwnd
= CreateWindowW( classW
, NULL
, style
, attr
.x
, attr
.y
, attr
.width
, attr
.height
,
2225 parent
, 0, 0, NULL
);
2227 if (!(data
= alloc_win_data( display
, hwnd
)))
2229 DestroyWindow( hwnd
);
2232 SetRect( &data
->window_rect
, attr
.x
, attr
.y
, attr
.x
+ attr
.width
, attr
.y
+ attr
.height
);
2233 data
->whole_rect
= data
->client_rect
= data
->window_rect
;
2234 data
->whole_window
= data
->client_window
= 0;
2235 data
->embedded
= TRUE
;
2236 data
->mapped
= TRUE
;
2238 SetPropA( hwnd
, foreign_window_prop
, (HANDLE
)xwin
);
2240 XSaveContext( display
, xwin
, winContext
, (char *)data
->hwnd
);
2241 wine_tsx11_unlock();
2243 ShowWindow( hwnd
, SW_SHOW
);
2245 TRACE( "win %lx parent %p style %08x %s -> hwnd %p\n",
2246 xwin
, parent
, style
, wine_dbgstr_rect(&data
->window_rect
), hwnd
);
2252 /***********************************************************************
2253 * X11DRV_get_whole_window
2255 * Return the X window associated with the full area of a window
2257 Window
X11DRV_get_whole_window( HWND hwnd
)
2259 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
2263 if (hwnd
== GetDesktopWindow()) return root_window
;
2264 return (Window
)GetPropA( hwnd
, whole_window_prop
);
2266 return data
->whole_window
;
2270 /***********************************************************************
2271 * X11DRV_get_client_window
2273 * Return the X window associated with the client area of a window
2275 static Window
X11DRV_get_client_window( HWND hwnd
)
2277 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
2281 if (hwnd
== GetDesktopWindow()) return root_window
;
2282 return (Window
)GetPropA( hwnd
, client_window_prop
);
2284 return data
->client_window
;
2288 /***********************************************************************
2291 * Return the X input context associated with a window
2293 XIC
X11DRV_get_ic( HWND hwnd
)
2295 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
2298 if (!data
) return 0;
2300 x11drv_thread_data()->last_xic_hwnd
= hwnd
;
2301 if (data
->xic
) return data
->xic
;
2302 if (!(xim
= x11drv_thread_data()->xim
)) return 0;
2303 return X11DRV_CreateIC( xim
, data
);
2307 /***********************************************************************
2308 * X11DRV_GetDC (X11DRV.@)
2310 void CDECL
X11DRV_GetDC( HDC hdc
, HWND hwnd
, HWND top
, const RECT
*win_rect
,
2311 const RECT
*top_rect
, DWORD flags
)
2313 struct x11drv_escape_set_drawable escape
;
2314 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
2317 escape
.code
= X11DRV_SET_DRAWABLE
;
2318 escape
.mode
= IncludeInferiors
;
2319 escape
.fbconfig_id
= 0;
2320 escape
.gl_drawable
= 0;
2322 escape
.gl_type
= DC_GL_NONE
;
2324 escape
.dc_rect
.left
= win_rect
->left
- top_rect
->left
;
2325 escape
.dc_rect
.top
= win_rect
->top
- top_rect
->top
;
2326 escape
.dc_rect
.right
= win_rect
->right
- top_rect
->left
;
2327 escape
.dc_rect
.bottom
= win_rect
->bottom
- top_rect
->top
;
2331 escape
.fbconfig_id
= data
? data
->fbconfig_id
: (XID
)GetPropA( hwnd
, fbconfig_id_prop
);
2332 /* GL draws to the client area even for window DCs */
2333 escape
.gl_drawable
= data
? data
->client_window
: X11DRV_get_client_window( hwnd
);
2334 if (data
&& IsIconic( hwnd
) && data
->icon_window
)
2336 escape
.drawable
= data
->icon_window
;
2338 else if (flags
& DCX_WINDOW
)
2339 escape
.drawable
= data
? data
->whole_window
: X11DRV_get_whole_window( hwnd
);
2341 escape
.drawable
= escape
.gl_drawable
;
2343 if (escape
.gl_drawable
) escape
.gl_type
= DC_GL_WINDOW
;
2344 /* special case: when repainting the root window, clip out top-level windows */
2345 if (data
&& data
->whole_window
== root_window
) escape
.mode
= ClipByChildren
;
2349 /* find the first ancestor that has a drawable */
2350 for (parent
= hwnd
; parent
&& parent
!= top
; parent
= GetAncestor( parent
, GA_PARENT
))
2351 if ((escape
.drawable
= X11DRV_get_client_window( parent
))) break;
2353 if (escape
.drawable
)
2355 POINT pt
= { 0, 0 };
2356 MapWindowPoints( top
, parent
, &pt
, 1 );
2357 OffsetRect( &escape
.dc_rect
, pt
.x
, pt
.y
);
2359 else escape
.drawable
= X11DRV_get_client_window( top
);
2361 escape
.fbconfig_id
= data
? data
->fbconfig_id
: (XID
)GetPropA( hwnd
, fbconfig_id_prop
);
2362 escape
.gl_drawable
= data
? data
->gl_drawable
: (Drawable
)GetPropA( hwnd
, gl_drawable_prop
);
2363 escape
.pixmap
= data
? data
->pixmap
: (Pixmap
)GetPropA( hwnd
, pixmap_prop
);
2364 if (escape
.gl_drawable
) escape
.gl_type
= escape
.pixmap
? DC_GL_PIXMAP_WIN
: DC_GL_CHILD_WIN
;
2365 if (flags
& DCX_CLIPCHILDREN
) escape
.mode
= ClipByChildren
;
2368 ExtEscape( hdc
, X11DRV_ESCAPE
, sizeof(escape
), (LPSTR
)&escape
, 0, NULL
);
2372 /***********************************************************************
2373 * X11DRV_ReleaseDC (X11DRV.@)
2375 void CDECL
X11DRV_ReleaseDC( HWND hwnd
, HDC hdc
)
2377 struct x11drv_escape_set_drawable escape
;
2379 escape
.code
= X11DRV_SET_DRAWABLE
;
2380 escape
.drawable
= root_window
;
2381 escape
.mode
= IncludeInferiors
;
2382 SetRect( &escape
.dc_rect
, 0, 0, virtual_screen_rect
.right
- virtual_screen_rect
.left
,
2383 virtual_screen_rect
.bottom
- virtual_screen_rect
.top
);
2384 OffsetRect( &escape
.dc_rect
, -virtual_screen_rect
.left
, -virtual_screen_rect
.top
);
2385 escape
.fbconfig_id
= 0;
2386 escape
.gl_drawable
= 0;
2388 escape
.gl_type
= DC_GL_NONE
;
2389 ExtEscape( hdc
, X11DRV_ESCAPE
, sizeof(escape
), (LPSTR
)&escape
, 0, NULL
);
2393 /***********************************************************************
2394 * SetCapture (X11DRV.@)
2396 void CDECL
X11DRV_SetCapture( HWND hwnd
, UINT flags
)
2398 struct x11drv_thread_data
*thread_data
= x11drv_thread_data();
2400 if (!thread_data
) return;
2401 if (!(flags
& (GUI_INMOVESIZE
| GUI_INMENUMODE
))) return;
2405 Window grab_win
= X11DRV_get_client_window( GetAncestor( hwnd
, GA_ROOT
) );
2407 if (!grab_win
) return;
2409 XFlush( gdi_display
);
2410 XGrabPointer( thread_data
->display
, grab_win
, False
,
2411 PointerMotionMask
| ButtonPressMask
| ButtonReleaseMask
,
2412 GrabModeAsync
, GrabModeAsync
, None
, None
, CurrentTime
);
2413 wine_tsx11_unlock();
2414 thread_data
->grab_window
= grab_win
;
2416 else /* release capture */
2419 XFlush( gdi_display
);
2420 XUngrabPointer( thread_data
->display
, CurrentTime
);
2421 XFlush( thread_data
->display
);
2422 wine_tsx11_unlock();
2423 thread_data
->grab_window
= None
;
2428 /*****************************************************************
2429 * SetParent (X11DRV.@)
2431 void CDECL
X11DRV_SetParent( HWND hwnd
, HWND parent
, HWND old_parent
)
2433 Display
*display
= thread_display();
2434 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
2437 if (parent
== old_parent
) return;
2438 if (data
->embedded
) return;
2440 if (parent
!= GetDesktopWindow()) /* a child window */
2442 if (old_parent
== GetDesktopWindow())
2444 /* destroy the old X windows */
2445 destroy_whole_window( display
, data
, FALSE
);
2446 destroy_icon_window( display
, data
);
2449 data
->managed
= FALSE
;
2450 RemovePropA( data
->hwnd
, managed_prop
);
2454 else /* new top level window */
2456 /* FIXME: we ignore errors since we can't really recover anyway */
2457 create_whole_window( display
, data
);
2462 /*****************************************************************
2463 * SetFocus (X11DRV.@)
2467 void CDECL
X11DRV_SetFocus( HWND hwnd
)
2469 Display
*display
= thread_display();
2470 struct x11drv_win_data
*data
;
2471 XWindowChanges changes
;
2474 if (!(hwnd
= GetAncestor( hwnd
, GA_ROOT
))) return;
2475 if (!(data
= X11DRV_get_win_data( hwnd
))) return;
2476 if (data
->managed
|| !data
->whole_window
) return;
2478 if (EVENT_x11_time_to_win32_time(0))
2479 /* ICCCM says don't use CurrentTime, so try to use last message time if possible */
2480 /* FIXME: this is not entirely correct */
2481 timestamp
= GetMessageTime() - EVENT_x11_time_to_win32_time(0);
2483 timestamp
= CurrentTime
;
2485 /* Set X focus and install colormap */
2487 changes
.stack_mode
= Above
;
2488 XConfigureWindow( display
, data
->whole_window
, CWStackMode
, &changes
);
2489 XSetInputFocus( display
, data
->whole_window
, RevertToParent
, timestamp
);
2490 wine_tsx11_unlock();
2494 /***********************************************************************
2495 * WindowPosChanging (X11DRV.@)
2497 void CDECL
X11DRV_WindowPosChanging( HWND hwnd
, HWND insert_after
, UINT swp_flags
,
2498 const RECT
*window_rect
, const RECT
*client_rect
, RECT
*visible_rect
)
2500 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
2501 DWORD style
= GetWindowLongW( hwnd
, GWL_STYLE
);
2505 /* create the win data if the window is being made visible */
2506 if (!(style
& WS_VISIBLE
) && !(swp_flags
& SWP_SHOWWINDOW
)) return;
2507 if (!(data
= X11DRV_create_win_data( hwnd
))) return;
2510 /* check if we need to switch the window to managed */
2511 if (!data
->managed
&& data
->whole_window
&& is_window_managed( hwnd
, swp_flags
, window_rect
))
2513 TRACE( "making win %p/%lx managed\n", hwnd
, data
->whole_window
);
2514 if (data
->mapped
) unmap_window( thread_display(), data
);
2515 data
->managed
= TRUE
;
2516 SetPropA( hwnd
, managed_prop
, (HANDLE
)1 );
2519 *visible_rect
= *window_rect
;
2520 X11DRV_window_to_X_rect( data
, visible_rect
);
2524 /***********************************************************************
2525 * WindowPosChanged (X11DRV.@)
2527 void CDECL
X11DRV_WindowPosChanged( HWND hwnd
, HWND insert_after
, UINT swp_flags
,
2528 const RECT
*rectWindow
, const RECT
*rectClient
,
2529 const RECT
*visible_rect
, const RECT
*valid_rects
)
2531 struct x11drv_thread_data
*thread_data
;
2533 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
2534 DWORD new_style
= GetWindowLongW( hwnd
, GWL_STYLE
);
2535 RECT old_window_rect
, old_whole_rect
, old_client_rect
;
2540 thread_data
= x11drv_thread_data();
2541 display
= thread_data
->display
;
2543 old_window_rect
= data
->window_rect
;
2544 old_whole_rect
= data
->whole_rect
;
2545 old_client_rect
= data
->client_rect
;
2546 data
->window_rect
= *rectWindow
;
2547 data
->whole_rect
= *visible_rect
;
2548 data
->client_rect
= *rectClient
;
2550 TRACE( "win %p window %s client %s style %08x flags %08x\n",
2551 hwnd
, wine_dbgstr_rect(rectWindow
), wine_dbgstr_rect(rectClient
), new_style
, swp_flags
);
2553 if (!IsRectEmpty( &valid_rects
[0] ))
2555 int x_offset
= old_whole_rect
.left
- data
->whole_rect
.left
;
2556 int y_offset
= old_whole_rect
.top
- data
->whole_rect
.top
;
2558 /* if all that happened is that the whole window moved, copy everything */
2559 if (!(swp_flags
& SWP_FRAMECHANGED
) &&
2560 old_whole_rect
.right
- data
->whole_rect
.right
== x_offset
&&
2561 old_whole_rect
.bottom
- data
->whole_rect
.bottom
== y_offset
&&
2562 old_client_rect
.left
- data
->client_rect
.left
== x_offset
&&
2563 old_client_rect
.right
- data
->client_rect
.right
== x_offset
&&
2564 old_client_rect
.top
- data
->client_rect
.top
== y_offset
&&
2565 old_client_rect
.bottom
- data
->client_rect
.bottom
== y_offset
&&
2566 !memcmp( &valid_rects
[0], &data
->client_rect
, sizeof(RECT
) ))
2568 /* if we have an X window the bits will be moved by the X server */
2569 if (!data
->whole_window
&& (x_offset
!= 0 || y_offset
!= 0))
2570 move_window_bits( data
, &old_whole_rect
, &data
->whole_rect
, &old_client_rect
);
2573 move_window_bits( data
, &valid_rects
[1], &valid_rects
[0], &old_client_rect
);
2577 XFlush( gdi_display
); /* make sure painting is done before we move the window */
2578 wine_tsx11_unlock();
2580 sync_client_position( display
, data
, swp_flags
, &old_client_rect
, &old_whole_rect
);
2582 if (!data
->whole_window
) return;
2584 /* check if we are currently processing an event relevant to this window */
2586 if (thread_data
->current_event
&& thread_data
->current_event
->xany
.window
== data
->whole_window
)
2587 event_type
= thread_data
->current_event
->type
;
2589 if (event_type
!= ConfigureNotify
&& event_type
!= PropertyNotify
&&
2590 event_type
!= GravityNotify
&& event_type
!= ReparentNotify
)
2591 event_type
= 0; /* ignore other events */
2593 if (data
->mapped
&& event_type
!= ReparentNotify
)
2595 if (((swp_flags
& SWP_HIDEWINDOW
) && !(new_style
& WS_VISIBLE
)) ||
2597 !is_window_rect_mapped( rectWindow
) && is_window_rect_mapped( &old_window_rect
)))
2599 unmap_window( display
, data
);
2600 if (is_window_rect_fullscreen( &old_window_rect
)) reset_clipping_window();
2604 /* don't change position if we are about to minimize or maximize a managed window */
2606 !(data
->managed
&& (swp_flags
& SWP_STATECHANGED
) && (new_style
& (WS_MINIMIZE
|WS_MAXIMIZE
))))
2607 sync_window_position( display
, data
, swp_flags
,
2608 &old_window_rect
, &old_whole_rect
, &old_client_rect
);
2610 if ((new_style
& WS_VISIBLE
) &&
2611 ((new_style
& WS_MINIMIZE
) || is_window_rect_mapped( rectWindow
)))
2613 if (!data
->mapped
|| (swp_flags
& (SWP_FRAMECHANGED
|SWP_STATECHANGED
)))
2614 set_wm_hints( display
, data
);
2618 map_window( display
, data
, new_style
);
2620 else if ((swp_flags
& SWP_STATECHANGED
) && (!data
->iconic
!= !(new_style
& WS_MINIMIZE
)))
2622 data
->iconic
= (new_style
& WS_MINIMIZE
) != 0;
2623 TRACE( "changing win %p iconic state to %u\n", data
->hwnd
, data
->iconic
);
2626 XIconifyWindow( display
, data
->whole_window
, DefaultScreen(display
) );
2627 else if (is_window_rect_mapped( rectWindow
))
2628 XMapWindow( display
, data
->whole_window
);
2629 wine_tsx11_unlock();
2630 update_net_wm_states( display
, data
);
2632 else if (!event_type
)
2634 update_net_wm_states( display
, data
);
2639 XFlush( display
); /* make sure changes are done before we start painting again */
2640 wine_tsx11_unlock();
2644 /***********************************************************************
2645 * ShowWindow (X11DRV.@)
2647 UINT CDECL
X11DRV_ShowWindow( HWND hwnd
, INT cmd
, RECT
*rect
, UINT swp
)
2650 unsigned int width
, height
, border
, depth
;
2652 DWORD style
= GetWindowLongW( hwnd
, GWL_STYLE
);
2653 struct x11drv_thread_data
*thread_data
= x11drv_thread_data();
2654 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
2656 if (!data
|| !data
->whole_window
|| !data
->managed
|| !data
->mapped
|| data
->iconic
) return swp
;
2657 if (style
& WS_MINIMIZE
) return swp
;
2658 if (IsRectEmpty( rect
)) return swp
;
2660 /* only fetch the new rectangle if the ShowWindow was a result of a window manager event */
2662 if (!thread_data
->current_event
|| thread_data
->current_event
->xany
.window
!= data
->whole_window
)
2665 if (thread_data
->current_event
->type
!= ConfigureNotify
&&
2666 thread_data
->current_event
->type
!= PropertyNotify
)
2669 TRACE( "win %p/%lx cmd %d at %s flags %08x\n",
2670 hwnd
, data
->whole_window
, cmd
, wine_dbgstr_rect(rect
), swp
);
2673 XGetGeometry( thread_data
->display
, data
->whole_window
,
2674 &root
, &x
, &y
, &width
, &height
, &border
, &depth
);
2675 XTranslateCoordinates( thread_data
->display
, data
->whole_window
, root
, 0, 0, &x
, &y
, &top
);
2676 wine_tsx11_unlock();
2679 rect
->right
= x
+ width
;
2680 rect
->bottom
= y
+ height
;
2681 OffsetRect( rect
, virtual_screen_rect
.left
, virtual_screen_rect
.top
);
2682 X11DRV_X_to_window_rect( data
, rect
);
2683 return swp
& ~(SWP_NOMOVE
| SWP_NOCLIENTMOVE
| SWP_NOSIZE
| SWP_NOCLIENTSIZE
);
2687 /**********************************************************************
2688 * SetWindowIcon (X11DRV.@)
2690 * hIcon or hIconSm has changed (or is being initialised for the
2691 * first time). Complete the X11 driver-specific initialisation
2692 * and set the window hints.
2694 * This is not entirely correct, may need to create
2695 * an icon window and set the pixmap as a background
2697 void CDECL
X11DRV_SetWindowIcon( HWND hwnd
, UINT type
, HICON icon
)
2699 Display
*display
= thread_display();
2700 struct x11drv_win_data
*data
;
2703 if (!(data
= X11DRV_get_win_data( hwnd
))) return;
2704 if (!data
->whole_window
) return;
2705 if (!data
->managed
) return;
2709 if (type
== ICON_BIG
) set_icon_hints( display
, data
, icon
, 0 );
2710 else set_icon_hints( display
, data
, 0, icon
);
2712 XSetWMHints( display
, data
->whole_window
, data
->wm_hints
);
2713 wine_tsx11_unlock();
2718 /***********************************************************************
2719 * SetWindowRgn (X11DRV.@)
2721 * Assign specified region to window (for non-rectangular windows)
2723 int CDECL
X11DRV_SetWindowRgn( HWND hwnd
, HRGN hrgn
, BOOL redraw
)
2725 struct x11drv_win_data
*data
;
2727 if ((data
= X11DRV_get_win_data( hwnd
)))
2729 sync_window_region( thread_display(), data
, hrgn
);
2731 else if (X11DRV_get_whole_window( hwnd
))
2733 SendMessageW( hwnd
, WM_X11DRV_SET_WIN_REGION
, 0, 0 );
2739 /***********************************************************************
2740 * SetLayeredWindowAttributes (X11DRV.@)
2742 * Set transparency attributes for a layered window.
2744 void CDECL
X11DRV_SetLayeredWindowAttributes( HWND hwnd
, COLORREF key
, BYTE alpha
, DWORD flags
)
2746 struct x11drv_win_data
*data
= X11DRV_get_win_data( hwnd
);
2750 if (data
->whole_window
)
2751 sync_window_opacity( thread_display(), data
->whole_window
, key
, alpha
, flags
);
2755 Window win
= X11DRV_get_whole_window( hwnd
);
2756 if (win
) sync_window_opacity( gdi_display
, win
, key
, alpha
, flags
);
2761 /**********************************************************************
2762 * X11DRV_WindowMessage (X11DRV.@)
2764 LRESULT CDECL
X11DRV_WindowMessage( HWND hwnd
, UINT msg
, WPARAM wp
, LPARAM lp
)
2766 struct x11drv_win_data
*data
;
2770 case WM_X11DRV_ACQUIRE_SELECTION
:
2771 return X11DRV_AcquireClipboard( hwnd
);
2772 case WM_X11DRV_SET_WIN_FORMAT
:
2773 return set_win_format( hwnd
, (XID
)wp
);
2774 case WM_X11DRV_SET_WIN_REGION
:
2775 if ((data
= X11DRV_get_win_data( hwnd
))) sync_window_region( thread_display(), data
, (HRGN
)1 );
2777 case WM_X11DRV_RESIZE_DESKTOP
:
2778 X11DRV_resize_desktop( LOWORD(lp
), HIWORD(lp
) );
2780 case WM_X11DRV_SET_CURSOR
:
2781 if ((data
= X11DRV_get_win_data( hwnd
)) && data
->whole_window
)
2782 set_window_cursor( data
->whole_window
, (HCURSOR
)lp
);
2783 else if (hwnd
== x11drv_thread_data()->clip_hwnd
)
2784 set_window_cursor( x11drv_thread_data()->clip_window
, (HCURSOR
)lp
);
2786 case WM_X11DRV_CLIP_CURSOR
:
2787 return clip_cursor_notify( hwnd
, (HWND
)lp
);
2789 FIXME( "got window msg %x hwnd %p wp %lx lp %lx\n", msg
, hwnd
, wp
, lp
);
2795 /***********************************************************************
2796 * is_netwm_supported
2798 static BOOL
is_netwm_supported( Display
*display
, Atom atom
)
2800 static Atom
*net_supported
;
2801 static int net_supported_count
= -1;
2805 if (net_supported_count
== -1)
2809 unsigned long count
, remaining
;
2811 if (!XGetWindowProperty( display
, DefaultRootWindow(display
), x11drv_atom(_NET_SUPPORTED
), 0,
2812 ~0UL, False
, XA_ATOM
, &type
, &format
, &count
,
2813 &remaining
, (unsigned char **)&net_supported
))
2814 net_supported_count
= get_property_size( format
, count
) / sizeof(Atom
);
2816 net_supported_count
= 0;
2818 wine_tsx11_unlock();
2820 for (i
= 0; i
< net_supported_count
; i
++)
2821 if (net_supported
[i
] == atom
) return TRUE
;
2826 /***********************************************************************
2827 * SysCommand (X11DRV.@)
2829 * Perform WM_SYSCOMMAND handling.
2831 LRESULT CDECL
X11DRV_SysCommand( HWND hwnd
, WPARAM wparam
, LPARAM lparam
)
2833 WPARAM hittest
= wparam
& 0x0f;
2835 Display
*display
= thread_display();
2836 struct x11drv_win_data
*data
;
2838 if (!(data
= X11DRV_get_win_data( hwnd
))) return -1;
2839 if (!data
->whole_window
|| !data
->managed
|| !data
->mapped
) return -1;
2841 switch (wparam
& 0xfff0)
2844 if (!hittest
) dir
= _NET_WM_MOVERESIZE_MOVE_KEYBOARD
;
2845 else dir
= _NET_WM_MOVERESIZE_MOVE
;
2848 /* windows without WS_THICKFRAME are not resizable through the window manager */
2849 if (!(GetWindowLongW( hwnd
, GWL_STYLE
) & WS_THICKFRAME
)) return -1;
2853 case WMSZ_LEFT
: dir
= _NET_WM_MOVERESIZE_SIZE_LEFT
; break;
2854 case WMSZ_RIGHT
: dir
= _NET_WM_MOVERESIZE_SIZE_RIGHT
; break;
2855 case WMSZ_TOP
: dir
= _NET_WM_MOVERESIZE_SIZE_TOP
; break;
2856 case WMSZ_TOPLEFT
: dir
= _NET_WM_MOVERESIZE_SIZE_TOPLEFT
; break;
2857 case WMSZ_TOPRIGHT
: dir
= _NET_WM_MOVERESIZE_SIZE_TOPRIGHT
; break;
2858 case WMSZ_BOTTOM
: dir
= _NET_WM_MOVERESIZE_SIZE_BOTTOM
; break;
2859 case WMSZ_BOTTOMLEFT
: dir
= _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT
; break;
2860 case WMSZ_BOTTOMRIGHT
: dir
= _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT
; break;
2861 default: dir
= _NET_WM_MOVERESIZE_SIZE_KEYBOARD
; break;
2866 /* prevent a simple ALT press+release from activating the system menu,
2867 * as that can get confusing on managed windows */
2868 if ((WCHAR
)lparam
) return -1; /* got an explicit char */
2869 if (GetMenu( hwnd
)) return -1; /* window has a real menu */
2870 if (!(GetWindowLongW( hwnd
, GWL_STYLE
) & WS_SYSMENU
)) return -1; /* no system menu */
2871 TRACE( "ignoring SC_KEYMENU wp %lx lp %lx\n", wparam
, lparam
);
2878 if (IsZoomed(hwnd
)) return -1;
2880 if (!is_netwm_supported( display
, x11drv_atom(_NET_WM_MOVERESIZE
) ))
2882 TRACE( "_NET_WM_MOVERESIZE not supported\n" );
2886 move_resize_window( display
, data
, dir
);