?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push e3a58d0afb1cfe6030692eaef2e02a8f1eae5cb6
[wine/hacks.git] / dlls / winex11.drv / winpos.c
blob25e643e36f075460b4ba703b99739a2a84c9620b
1 /*
2 * Window position related functions.
3 *
4 * Copyright 1993, 1994, 1995, 2001 Alexandre Julliard
5 * Copyright 1995, 1996, 1999 Alex Korobka
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "config.h"
23
24 #include <X11/Xlib.h>
25 #include <X11/Xutil.h>
26 #include <stdarg.h>
27
28 #include "windef.h"
29 #include "winbase.h"
30 #include "wingdi.h"
31 #include "winuser.h"
32 #include "winerror.h"
33 #include "wine/wingdi16.h"
34
35 #include "x11drv.h"
36
37 #include "wine/server.h"
38 #include "wine/debug.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(x11drv);
41
42 #define SWP_AGG_NOPOSCHANGE \
43 (SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE | SWP_NOZORDER)
44
45 #define _NET_WM_MOVERESIZE_SIZE_TOPLEFT 0
46 #define _NET_WM_MOVERESIZE_SIZE_TOP 1
47 #define _NET_WM_MOVERESIZE_SIZE_TOPRIGHT 2
48 #define _NET_WM_MOVERESIZE_SIZE_RIGHT 3
49 #define _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT 4
50 #define _NET_WM_MOVERESIZE_SIZE_BOTTOM 5
51 #define _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT 6
52 #define _NET_WM_MOVERESIZE_SIZE_LEFT 7
53 #define _NET_WM_MOVERESIZE_MOVE 8 /* movement only */
54 #define _NET_WM_MOVERESIZE_SIZE_KEYBOARD 9 /* size via keyboard */
55 #define _NET_WM_MOVERESIZE_MOVE_KEYBOARD 10 /* move via keyboard */
56
57 #define _NET_WM_STATE_REMOVE 0
58 #define _NET_WM_STATE_ADD 1
59 #define _NET_WM_STATE_TOGGLE 2
60
61 static const char managed_prop[] = "__wine_x11_managed";
62
63 /***********************************************************************
64 * X11DRV_Expose
65 */
66 void X11DRV_Expose( HWND hwnd, XEvent *xev )
67 {
68 XExposeEvent *event = &xev->xexpose;
69 RECT rect;
70 struct x11drv_win_data *data;
71 int flags = RDW_INVALIDATE | RDW_ERASE;
72
73 TRACE( "win %p (%lx) %d,%d %dx%d\n",
74 hwnd, event->window, event->x, event->y, event->width, event->height );
75
76 if (!(data = X11DRV_get_win_data( hwnd ))) return;
77
78 if (event->window == data->whole_window)
79 {
80 rect.left = data->whole_rect.left + event->x;
81 rect.top = data->whole_rect.top + event->y;
82 flags |= RDW_FRAME;
83 }
84 else
85 {
86 rect.left = data->client_rect.left + event->x;
87 rect.top = data->client_rect.top + event->y;
88 }
89 rect.right = rect.left + event->width;
90 rect.bottom = rect.top + event->height;
91
92 if (event->window != root_window)
93 {
94 SERVER_START_REQ( update_window_zorder )
95 {
96 req->window = hwnd;
97 req->rect.left = rect.left;
98 req->rect.top = rect.top;
99 req->rect.right = rect.right;
100 req->rect.bottom = rect.bottom;
101 wine_server_call( req );
102 }
103 SERVER_END_REQ;
104
105 /* make position relative to client area instead of parent */
106 OffsetRect( &rect, -data->client_rect.left, -data->client_rect.top );
107 flags |= RDW_ALLCHILDREN;
108 }
109
110 RedrawWindow( hwnd, &rect, 0, flags );
111 }
112
113 /***********************************************************************
114 * SetWindowStyle (X11DRV.@)
115 *
116 * Update the X state of a window to reflect a style change
117 */
118 void X11DRV_SetWindowStyle( HWND hwnd, DWORD old_style )
119 {
120 Display *display = thread_display();
121 struct x11drv_win_data *data;
122 DWORD new_style, changed;
123
124 if (hwnd == GetDesktopWindow()) return;
125 new_style = GetWindowLongW( hwnd, GWL_STYLE );
126 changed = new_style ^ old_style;
127
128 if ((changed & WS_VISIBLE) && (new_style & WS_VISIBLE))
129 {
130 /* we don't unmap windows, that causes trouble with the window manager */
131 if (!(data = X11DRV_get_win_data( hwnd )) &&
132 !(data = X11DRV_create_win_data( hwnd ))) return;
133
134 if (data->whole_window && X11DRV_is_window_rect_mapped( &data->window_rect ))
135 {
136 X11DRV_set_wm_hints( display, data );
137 if (!data->mapped)
138 {
139 TRACE( "mapping win %p/%lx\n", hwnd, data->whole_window );
140 wait_for_withdrawn_state( display, data, TRUE );
141 X11DRV_sync_window_style( display, data );
142 wine_tsx11_lock();
143 XMapWindow( display, data->whole_window );
144 wine_tsx11_unlock();
145 data->mapped = TRUE;
146 data->iconic = (new_style & WS_MINIMIZE) != 0;
147 }
148 }
149 }
150
151 if (changed & WS_DISABLED)
152 {
153 data = X11DRV_get_win_data( hwnd );
154 if (data && data->wm_hints)
155 {
156 wine_tsx11_lock();
157 data->wm_hints->input = !(new_style & WS_DISABLED);
158 XSetWMHints( display, data->whole_window, data->wm_hints );
159 wine_tsx11_unlock();
160 }
161 }
162 }
163
164
165 /***********************************************************************
166 * update_net_wm_states
167 */
168 static void update_net_wm_states( Display *display, struct x11drv_win_data *data )
169 {
170 static const unsigned int state_atoms[NB_NET_WM_STATES] =
171 {
172 XATOM__NET_WM_STATE_FULLSCREEN,
173 XATOM__NET_WM_STATE_ABOVE,
174 XATOM__NET_WM_STATE_MAXIMIZED_VERT,
175 XATOM__NET_WM_STATE_SKIP_PAGER,
176 XATOM__NET_WM_STATE_SKIP_TASKBAR
177 };
178
179 DWORD i, style, ex_style, new_state = 0;
180 XEvent xev;
181
182 if (!data->managed) return;
183 if (!data->mapped) return;
184
185 style = GetWindowLongW( data->hwnd, GWL_STYLE );
186 if (data->whole_rect.left <= 0 && data->whole_rect.right >= screen_width &&
187 data->whole_rect.top <= 0 && data->whole_rect.bottom >= screen_height)
188 {
189 if ((style & WS_MAXIMIZE) && (style & WS_CAPTION) == WS_CAPTION)
190 new_state |= (1 << NET_WM_STATE_MAXIMIZED);
191 else
192 new_state |= (1 << NET_WM_STATE_FULLSCREEN);
193 }
194 else if (style & WS_MAXIMIZE)
195 new_state |= (1 << NET_WM_STATE_MAXIMIZED);
196
197 ex_style = GetWindowLongW( data->hwnd, GWL_EXSTYLE );
198 if (ex_style & WS_EX_TOPMOST)
199 new_state |= (1 << NET_WM_STATE_ABOVE);
200 if (ex_style & WS_EX_TOOLWINDOW)
201 new_state |= (1 << NET_WM_STATE_SKIP_TASKBAR) | (1 << NET_WM_STATE_SKIP_PAGER);
202
203 xev.xclient.type = ClientMessage;
204 xev.xclient.window = data->whole_window;
205 xev.xclient.message_type = x11drv_atom(_NET_WM_STATE);
206 xev.xclient.serial = 0;
207 xev.xclient.display = display;
208 xev.xclient.send_event = True;
209 xev.xclient.format = 32;
210 xev.xclient.data.l[3] = 1;
211
212 for (i = 0; i < NB_NET_WM_STATES; i++)
213 {
214 if (!((data->net_wm_state ^ new_state) & (1 << i))) continue; /* unchanged */
215
216 TRACE( "setting wm state %u for window %p/%lx to %u prev %u\n",
217 i, data->hwnd, data->whole_window,
218 (new_state & (1 << i)) != 0, (data->net_wm_state & (1 << i)) != 0 );
219
220 xev.xclient.data.l[0] = (new_state & (1 << i)) ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
221 xev.xclient.data.l[1] = X11DRV_Atoms[state_atoms[i] - FIRST_XATOM];
222 xev.xclient.data.l[2] = ((state_atoms[i] == XATOM__NET_WM_STATE_MAXIMIZED_VERT) ?
223 x11drv_atom(_NET_WM_STATE_MAXIMIZED_HORZ) : 0);
224 wine_tsx11_lock();
225 XSendEvent( display, root_window, False, SubstructureRedirectMask | SubstructureNotifyMask, &xev );
226 wine_tsx11_unlock();
227 }
228 data->net_wm_state = new_state;
229 }
230
231
232 /***********************************************************************
233 * move_window_bits
234 *
235 * Move the window bits when a window is moved.
236 */
237 static void move_window_bits( struct x11drv_win_data *data, const RECT *old_rect, const RECT *new_rect,
238 const RECT *old_client_rect )
239 {
240 RECT src_rect = *old_rect;
241 RECT dst_rect = *new_rect;
242 HDC hdc_src, hdc_dst;
243 INT code;
244 HRGN rgn = 0;
245 HWND parent = 0;
246
247 if (!data->whole_window)
248 {
249 OffsetRect( &dst_rect, -data->window_rect.left, -data->window_rect.top );
250 parent = GetAncestor( data->hwnd, GA_PARENT );
251 hdc_src = GetDCEx( parent, 0, DCX_CACHE );
252 hdc_dst = GetDCEx( data->hwnd, 0, DCX_CACHE | DCX_WINDOW );
253 }
254 else
255 {
256 OffsetRect( &dst_rect, -data->client_rect.left, -data->client_rect.top );
257 /* make src rect relative to the old position of the window */
258 OffsetRect( &src_rect, -old_client_rect->left, -old_client_rect->top );
259 if (dst_rect.left == src_rect.left && dst_rect.top == src_rect.top) return;
260 hdc_src = hdc_dst = GetDCEx( data->hwnd, 0, DCX_CACHE );
261 }
262
263 code = X11DRV_START_EXPOSURES;
264 ExtEscape( hdc_dst, X11DRV_ESCAPE, sizeof(code), (LPSTR)&code, 0, NULL );
265
266 TRACE( "copying bits for win %p/%lx/%lx %s -> %s\n",
267 data->hwnd, data->whole_window, data->client_window,
268 wine_dbgstr_rect(&src_rect), wine_dbgstr_rect(&dst_rect) );
269 BitBlt( hdc_dst, dst_rect.left, dst_rect.top,
270 dst_rect.right - dst_rect.left, dst_rect.bottom - dst_rect.top,
271 hdc_src, src_rect.left, src_rect.top, SRCCOPY );
272
273 code = X11DRV_END_EXPOSURES;
274 ExtEscape( hdc_dst, X11DRV_ESCAPE, sizeof(code), (LPSTR)&code, sizeof(rgn), (LPSTR)&rgn );
275
276 ReleaseDC( data->hwnd, hdc_dst );
277 if (hdc_src != hdc_dst) ReleaseDC( parent, hdc_src );
278
279 if (rgn)
280 {
281 if (!data->whole_window)
282 {
283 /* map region to client rect since we are using DCX_WINDOW */
284 OffsetRgn( rgn, data->window_rect.left - data->client_rect.left,
285 data->window_rect.top - data->client_rect.top );
286 RedrawWindow( data->hwnd, NULL, rgn,
287 RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ALLCHILDREN );
288 }
289 else RedrawWindow( data->hwnd, NULL, rgn, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN );
290 DeleteObject( rgn );
291 }
292 }
293
294 /***********************************************************************
295 * SetWindowPos (X11DRV.@)
296 */
297 void X11DRV_SetWindowPos( HWND hwnd, HWND insert_after, UINT swp_flags,
298 const RECT *rectWindow, const RECT *rectClient,
299 const RECT *visible_rect, const RECT *valid_rects )
300 {
301 Display *display = thread_display();
302 struct x11drv_win_data *data = X11DRV_get_win_data( hwnd );
303 DWORD new_style = GetWindowLongW( hwnd, GWL_STYLE );
304 RECT old_window_rect, old_whole_rect, old_client_rect;
305
306 if (!data)
307 {
308 /* create the win data if the window is being made visible */
309 if (!(new_style & WS_VISIBLE)) return;
310 if (!(data = X11DRV_create_win_data( hwnd ))) return;
311 }
312
313 /* check if we need to switch the window to managed */
314 if (!data->managed && data->whole_window && is_window_managed( hwnd, swp_flags, rectWindow ))
315 {
316 TRACE( "making win %p/%lx managed\n", hwnd, data->whole_window );
317 data->managed = TRUE;
318 SetPropA( hwnd, managed_prop, (HANDLE)1 );
319 if (data->mapped)
320 {
321 wine_tsx11_lock();
322 XUnmapWindow( display, data->whole_window );
323 wine_tsx11_unlock();
324 data->mapped = FALSE;
325 }
326 }
327
328 old_window_rect = data->window_rect;
329 old_whole_rect = data->whole_rect;
330 old_client_rect = data->client_rect;
331 data->window_rect = *rectWindow;
332 data->whole_rect = *rectWindow;
333 data->client_rect = *rectClient;
334 X11DRV_window_to_X_rect( data, &data->whole_rect );
335 if (memcmp( visible_rect, &data->whole_rect, sizeof(RECT) ))
336 {
337 TRACE( "%p: need to update visible rect %s -> %s\n", hwnd,
338 wine_dbgstr_rect(visible_rect), wine_dbgstr_rect(&data->whole_rect) );
339 SERVER_START_REQ( set_window_visible_rect )
340 {
341 req->handle = hwnd;
342 req->flags = swp_flags;
343 req->visible.left = data->whole_rect.left;
344 req->visible.top = data->whole_rect.top;
345 req->visible.right = data->whole_rect.right;
346 req->visible.bottom = data->whole_rect.bottom;
347 wine_server_call( req );
348 }
349 SERVER_END_REQ;
350 }
351
352 TRACE( "win %p window %s client %s style %08x flags %08x\n",
353 hwnd, wine_dbgstr_rect(rectWindow), wine_dbgstr_rect(rectClient), new_style, swp_flags );
354
355 if (!IsRectEmpty( &valid_rects[0] ))
356 {
357 int x_offset = old_whole_rect.left - data->whole_rect.left;
358 int y_offset = old_whole_rect.top - data->whole_rect.top;
359
360 /* if all that happened is that the whole window moved, copy everything */
361 if (!(swp_flags & SWP_FRAMECHANGED) &&
362 old_whole_rect.right - data->whole_rect.right == x_offset &&
363 old_whole_rect.bottom - data->whole_rect.bottom == y_offset &&
364 old_client_rect.left - data->client_rect.left == x_offset &&
365 old_client_rect.right - data->client_rect.right == x_offset &&
366 old_client_rect.top - data->client_rect.top == y_offset &&
367 old_client_rect.bottom - data->client_rect.bottom == y_offset &&
368 !memcmp( &valid_rects[0], &data->client_rect, sizeof(RECT) ))
369 {
370 /* if we have an X window the bits will be moved by the X server */
371 if (!data->whole_window)
372 move_window_bits( data, &old_whole_rect, &data->whole_rect, &old_client_rect );
373 }
374 else
375 move_window_bits( data, &valid_rects[1], &valid_rects[0], &old_client_rect );
376 }
377
378 X11DRV_sync_client_position( display, data, swp_flags, &old_client_rect, &old_whole_rect );
379
380 if (!data->whole_window || data->lock_changes) return; /* nothing more to do */
381
382 if (data->mapped && (!(new_style & WS_VISIBLE) || !X11DRV_is_window_rect_mapped( rectWindow )))
383 {
384 TRACE( "unmapping win %p/%lx\n", hwnd, data->whole_window );
385 wait_for_withdrawn_state( display, data, FALSE );
386 wine_tsx11_lock();
387 if (data->managed) XWithdrawWindow( display, data->whole_window, DefaultScreen(display) );
388 else XUnmapWindow( display, data->whole_window );
389 wine_tsx11_unlock();
390 data->mapped = FALSE;
391 data->net_wm_state = 0;
392 }
393
394 /* don't change position if we are about to minimize or maximize a managed window */
395 if (!(data->managed && (swp_flags & SWP_STATECHANGED) && (new_style & (WS_MINIMIZE|WS_MAXIMIZE))))
396 X11DRV_sync_window_position( display, data, swp_flags, &old_client_rect, &old_whole_rect );
397
398 if ((new_style & WS_VISIBLE) &&
399 ((new_style & WS_MINIMIZE) || X11DRV_is_window_rect_mapped( rectWindow )))
400 {
401 if (!data->mapped || (swp_flags & (SWP_FRAMECHANGED|SWP_STATECHANGED)))
402 X11DRV_set_wm_hints( display, data );
403
404 if (!data->mapped)
405 {
406 TRACE( "mapping win %p/%lx\n", hwnd, data->whole_window );
407 wait_for_withdrawn_state( display, data, TRUE );
408 X11DRV_sync_window_style( display, data );
409 wine_tsx11_lock();
410 XMapWindow( display, data->whole_window );
411 XFlush( display );
412 wine_tsx11_unlock();
413 data->mapped = TRUE;
414 data->iconic = (new_style & WS_MINIMIZE) != 0;
415 }
416 else if ((swp_flags & SWP_STATECHANGED) && (!data->iconic != !(new_style & WS_MINIMIZE)))
417 {
418 data->iconic = (new_style & WS_MINIMIZE) != 0;
419 TRACE( "changing win %p iconic state to %u\n", data->hwnd, data->iconic );
420 wine_tsx11_lock();
421 if (data->iconic)
422 XIconifyWindow( display, data->whole_window, DefaultScreen(display) );
423 else if (X11DRV_is_window_rect_mapped( rectWindow ))
424 XMapWindow( display, data->whole_window );
425 wine_tsx11_unlock();
426 }
427 update_net_wm_states( display, data );
428 }
429 }
430
431
432 /**********************************************************************
433 * X11DRV_MapNotify
434 */
435 void X11DRV_MapNotify( HWND hwnd, XEvent *event )
436 {
437 struct x11drv_win_data *data;
438 int state;
439
440 if (!(data = X11DRV_get_win_data( hwnd ))) return;
441 if (!data->mapped) return;
442
443 if (!data->managed)
444 {
445 HWND hwndFocus = GetFocus();
446 if (hwndFocus && IsChild( hwnd, hwndFocus )) X11DRV_SetFocus(hwndFocus); /* FIXME */
447 return;
448 }
449 if (!data->iconic) return;
450
451 state = get_window_wm_state( event->xmap.display, data );
452 if (state == NormalState)
453 {
454 int x, y;
455 unsigned int width, height, border, depth;
456 Window root, top;
457 WINDOWPLACEMENT wp;
458 RECT rect;
459
460 /* FIXME: hack */
461 wine_tsx11_lock();
462 XGetGeometry( event->xmap.display, data->whole_window, &root, &x, &y, &width, &height,
463 &border, &depth );
464 XTranslateCoordinates( event->xmap.display, data->whole_window, root, 0, 0, &x, &y, &top );
465 wine_tsx11_unlock();
466 rect.left = x;
467 rect.top = y;
468 rect.right = x + width;
469 rect.bottom = y + height;
470 OffsetRect( &rect, virtual_screen_rect.left, virtual_screen_rect.top );
471 X11DRV_X_to_window_rect( data, &rect );
472
473 wp.length = sizeof(wp);
474 GetWindowPlacement( hwnd, &wp );
475 wp.flags = 0;
476 wp.showCmd = SW_RESTORE;
477 wp.rcNormalPosition = rect;
478
479 TRACE( "restoring win %p/%lx\n", hwnd, data->whole_window );
480 data->iconic = FALSE;
481 data->lock_changes++;
482 SetWindowPlacement( hwnd, &wp );
483 data->lock_changes--;
484 }
485 else TRACE( "win %p/%lx ignoring since state=%d\n", hwnd, data->whole_window, state );
486 }
487
488
489 /**********************************************************************
490 * X11DRV_UnmapNotify
491 */
492 void X11DRV_UnmapNotify( HWND hwnd, XEvent *event )
493 {
494 struct x11drv_win_data *data;
495 int state;
496
497 if (!(data = X11DRV_get_win_data( hwnd ))) return;
498 if (!data->managed || !data->mapped || data->iconic) return;
499
500 state = get_window_wm_state( event->xunmap.display, data );
501 if (state == IconicState)
502 {
503 TRACE( "minimizing win %p/%lx\n", hwnd, data->whole_window );
504 data->iconic = TRUE;
505 data->lock_changes++;
506 ShowWindow( hwnd, SW_MINIMIZE );
507 data->lock_changes--;
508 }
509 else TRACE( "win %p/%lx ignoring since state=%d\n", hwnd, data->whole_window, state );
510 }
511
512 struct desktop_resize_data
513 {
514 RECT old_screen_rect;
515 RECT old_virtual_rect;
516 };
517
518 static BOOL CALLBACK update_windows_on_desktop_resize( HWND hwnd, LPARAM lparam )
519 {
520 struct x11drv_win_data *data;
521 Display *display = thread_display();
522 struct desktop_resize_data *resize_data = (struct desktop_resize_data *)lparam;
523 int mask = 0;
524
525 if (!(data = X11DRV_get_win_data( hwnd ))) return TRUE;
526
527 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_VISIBLE)
528 {
529 /* update the full screen state */
530 update_net_wm_states( display, data );
531 }
532
533 if (resize_data->old_virtual_rect.left != virtual_screen_rect.left) mask |= CWX;
534 if (resize_data->old_virtual_rect.top != virtual_screen_rect.top) mask |= CWY;
535 if (mask && data->whole_window)
536 {
537 XWindowChanges changes;
538
539 wine_tsx11_lock();
540 changes.x = data->whole_rect.left - virtual_screen_rect.left;
541 changes.y = data->whole_rect.top - virtual_screen_rect.top;
542 XReconfigureWMWindow( display, data->whole_window,
543 DefaultScreen(display), mask, &changes );
544 wine_tsx11_unlock();
545 }
546 return TRUE;
547 }
548
549
550 /***********************************************************************
551 * X11DRV_resize_desktop
552 */
553 void X11DRV_resize_desktop( unsigned int width, unsigned int height )
554 {
555 HWND hwnd = GetDesktopWindow();
556 struct desktop_resize_data resize_data;
557
558 SetRect( &resize_data.old_screen_rect, 0, 0, screen_width, screen_height );
559 resize_data.old_virtual_rect = virtual_screen_rect;
560
561 xinerama_init( width, height );
562
563 if (GetWindowThreadProcessId( hwnd, NULL ) != GetCurrentThreadId())
564 {
565 SendMessageW( hwnd, WM_X11DRV_RESIZE_DESKTOP, 0, MAKELPARAM( width, height ) );
566 }
567 else
568 {
569 TRACE( "desktop %p change to (%dx%d)\n", hwnd, width, height );
570 SetWindowPos( hwnd, 0, virtual_screen_rect.left, virtual_screen_rect.top,
571 virtual_screen_rect.right - virtual_screen_rect.left,
572 virtual_screen_rect.bottom - virtual_screen_rect.top,
573 SWP_NOZORDER | SWP_NOACTIVATE | SWP_DEFERERASE );
574 SendMessageTimeoutW( HWND_BROADCAST, WM_DISPLAYCHANGE, screen_bpp,
575 MAKELPARAM( width, height ), SMTO_ABORTIFHUNG, 2000, NULL );
576 }
577
578 EnumWindows( update_windows_on_desktop_resize, (LPARAM)&resize_data );
579 }
580
581
582 /***********************************************************************
583 * X11DRV_ConfigureNotify
584 */
585 void X11DRV_ConfigureNotify( HWND hwnd, XEvent *xev )
586 {
587 XConfigureEvent *event = &xev->xconfigure;
588 struct x11drv_win_data *data;
589 RECT rect;
590 UINT flags;
591 int cx, cy, x = event->x, y = event->y;
592
593 if (!hwnd) return;
594 if (!(data = X11DRV_get_win_data( hwnd ))) return;
595
596 /* Get geometry */
597
598 if (!event->send_event) /* normal event, need to map coordinates to the root */
599 {
600 Window child;
601 wine_tsx11_lock();
602 XTranslateCoordinates( event->display, data->whole_window, root_window,
603 0, 0, &x, &y, &child );
604 wine_tsx11_unlock();
605 }
606 rect.left = x;
607 rect.top = y;
608 rect.right = x + event->width;
609 rect.bottom = y + event->height;
610 OffsetRect( &rect, virtual_screen_rect.left, virtual_screen_rect.top );
611 TRACE( "win %p new X rect %d,%d,%dx%d (event %d,%d,%dx%d)\n",
612 hwnd, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top,
613 event->x, event->y, event->width, event->height );
614 X11DRV_X_to_window_rect( data, &rect );
615
616 x = rect.left;
617 y = rect.top;
618 cx = rect.right - rect.left;
619 cy = rect.bottom - rect.top;
620 flags = SWP_NOACTIVATE | SWP_NOZORDER;
621
622 /* Compare what has changed */
623
624 GetWindowRect( hwnd, &rect );
625 if (rect.left == x && rect.top == y) flags |= SWP_NOMOVE;
626 else
627 TRACE( "%p moving from (%d,%d) to (%d,%d)\n",
628 hwnd, rect.left, rect.top, x, y );
629
630 if ((rect.right - rect.left == cx && rect.bottom - rect.top == cy) ||
631 IsIconic(hwnd) ||
632 (IsRectEmpty( &rect ) && event->width == 1 && event->height == 1))
633 {
634 if (flags & SWP_NOMOVE) return; /* if nothing changed, don't do anything */
635 flags |= SWP_NOSIZE;
636 }
637 else
638 TRACE( "%p resizing from (%dx%d) to (%dx%d)\n",
639 hwnd, rect.right - rect.left, rect.bottom - rect.top, cx, cy );
640
641 data->lock_changes++;
642 SetWindowPos( hwnd, 0, x, y, cx, cy, flags );
643 data->lock_changes--;
644 }
645
646
647 /***********************************************************************
648 * is_netwm_supported
649 */
650 static BOOL is_netwm_supported( Display *display, Atom atom )
651 {
652 static Atom *net_supported;
653 static int net_supported_count = -1;
654 int i;
655
656 wine_tsx11_lock();
657 if (net_supported_count == -1)
658 {
659 Atom type;
660 int format;
661 unsigned long count, remaining;
662
663 if (!XGetWindowProperty( display, DefaultRootWindow(display), x11drv_atom(_NET_SUPPORTED), 0,
664 ~0UL, False, XA_ATOM, &type, &format, &count,
665 &remaining, (unsigned char **)&net_supported ))
666 net_supported_count = count * (format / 8) / sizeof(Atom);
667 else
668 net_supported_count = 0;
669 }
670 wine_tsx11_unlock();
671
672 for (i = 0; i < net_supported_count; i++)
673 if (net_supported[i] == atom) return TRUE;
674 return FALSE;
675 }
676
677
678 /***********************************************************************
679 * SysCommandSizeMove (X11DRV.@)
680 *
681 * Perform SC_MOVE and SC_SIZE commands.
682 */
683 BOOL X11DRV_SysCommandSizeMove( HWND hwnd, WPARAM wparam )
684 {
685 WPARAM syscommand = wparam & 0xfff0;
686 WPARAM hittest = wparam & 0x0f;
687 DWORD dwPoint;
688 int x, y, dir;
689 XEvent xev;
690 Display *display = thread_display();
691 struct x11drv_win_data *data;
692
693 if (!(data = X11DRV_get_win_data( hwnd ))) return FALSE;
694 if (!data->whole_window || !data->managed) return FALSE;
695
696 if (!is_netwm_supported( display, x11drv_atom(_NET_WM_MOVERESIZE) ))
697 {
698 TRACE( "_NET_WM_MOVERESIZE not supported\n" );
699 return FALSE;
700 }
701
702 if (syscommand == SC_MOVE)
703 {
704 if (!hittest) dir = _NET_WM_MOVERESIZE_MOVE_KEYBOARD;
705 else dir = _NET_WM_MOVERESIZE_MOVE;
706 }
707 else
708 {
709 /* windows without WS_THICKFRAME are not resizable through the window manager */
710 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_THICKFRAME)) return FALSE;
711
712 switch (hittest)
713 {
714 case WMSZ_LEFT: dir = _NET_WM_MOVERESIZE_SIZE_LEFT; break;
715 case WMSZ_RIGHT: dir = _NET_WM_MOVERESIZE_SIZE_RIGHT; break;
716 case WMSZ_TOP: dir = _NET_WM_MOVERESIZE_SIZE_TOP; break;
717 case WMSZ_TOPLEFT: dir = _NET_WM_MOVERESIZE_SIZE_TOPLEFT; break;
718 case WMSZ_TOPRIGHT: dir = _NET_WM_MOVERESIZE_SIZE_TOPRIGHT; break;
719 case WMSZ_BOTTOM: dir = _NET_WM_MOVERESIZE_SIZE_BOTTOM; break;
720 case WMSZ_BOTTOMLEFT: dir = _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT; break;
721 case WMSZ_BOTTOMRIGHT: dir = _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT; break;
722 default: dir = _NET_WM_MOVERESIZE_SIZE_KEYBOARD; break;
723 }
724 }
725
726 dwPoint = GetMessagePos();
727 x = (short)LOWORD(dwPoint);
728 y = (short)HIWORD(dwPoint);
729
730 TRACE("hwnd %p, x %d, y %d, dir %d\n", hwnd, x, y, dir);
731
732 xev.xclient.type = ClientMessage;
733 xev.xclient.window = X11DRV_get_whole_window(hwnd);
734 xev.xclient.message_type = x11drv_atom(_NET_WM_MOVERESIZE);
735 xev.xclient.serial = 0;
736 xev.xclient.display = display;
737 xev.xclient.send_event = True;
738 xev.xclient.format = 32;
739 xev.xclient.data.l[0] = x; /* x coord */
740 xev.xclient.data.l[1] = y; /* y coord */
741 xev.xclient.data.l[2] = dir; /* direction */
742 xev.xclient.data.l[3] = 1; /* button */
743 xev.xclient.data.l[4] = 0; /* unused */
744
745 /* need to ungrab the pointer that may have been automatically grabbed
746 * with a ButtonPress event */
747 wine_tsx11_lock();
748 XUngrabPointer( display, CurrentTime );
749 XSendEvent(display, root_window, False, SubstructureNotifyMask, &xev);
750 wine_tsx11_unlock();
751 return TRUE;
752 }
useful hacks and other patches not (yet) suitable for mainline