?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winex11: Avoid updating the wm states inside a ConfigureNotify event.
[wine.git] / dlls / winex11.drv / winpos.c
blob1779b4502a43bef5a71addd0e520089265798d40
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 if (!(ex_style & WS_EX_APPWINDOW) && GetWindow( data->hwnd, GW_OWNER ))
203 new_state |= (1 << NET_WM_STATE_SKIP_TASKBAR);
204
205 xev.xclient.type = ClientMessage;
206 xev.xclient.window = data->whole_window;
207 xev.xclient.message_type = x11drv_atom(_NET_WM_STATE);
208 xev.xclient.serial = 0;
209 xev.xclient.display = display;
210 xev.xclient.send_event = True;
211 xev.xclient.format = 32;
212 xev.xclient.data.l[3] = 1;
213
214 for (i = 0; i < NB_NET_WM_STATES; i++)
215 {
216 if (!((data->net_wm_state ^ new_state) & (1 << i))) continue; /* unchanged */
217
218 TRACE( "setting wm state %u for window %p/%lx to %u prev %u\n",
219 i, data->hwnd, data->whole_window,
220 (new_state & (1 << i)) != 0, (data->net_wm_state & (1 << i)) != 0 );
221
222 xev.xclient.data.l[0] = (new_state & (1 << i)) ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
223 xev.xclient.data.l[1] = X11DRV_Atoms[state_atoms[i] - FIRST_XATOM];
224 xev.xclient.data.l[2] = ((state_atoms[i] == XATOM__NET_WM_STATE_MAXIMIZED_VERT) ?
225 x11drv_atom(_NET_WM_STATE_MAXIMIZED_HORZ) : 0);
226 wine_tsx11_lock();
227 XSendEvent( display, root_window, False, SubstructureRedirectMask | SubstructureNotifyMask, &xev );
228 wine_tsx11_unlock();
229 }
230 data->net_wm_state = new_state;
231 }
232
233
234 /***********************************************************************
235 * move_window_bits
236 *
237 * Move the window bits when a window is moved.
238 */
239 static void move_window_bits( struct x11drv_win_data *data, const RECT *old_rect, const RECT *new_rect,
240 const RECT *old_client_rect )
241 {
242 RECT src_rect = *old_rect;
243 RECT dst_rect = *new_rect;
244 HDC hdc_src, hdc_dst;
245 INT code;
246 HRGN rgn = 0;
247 HWND parent = 0;
248
249 if (!data->whole_window)
250 {
251 OffsetRect( &dst_rect, -data->window_rect.left, -data->window_rect.top );
252 parent = GetAncestor( data->hwnd, GA_PARENT );
253 hdc_src = GetDCEx( parent, 0, DCX_CACHE );
254 hdc_dst = GetDCEx( data->hwnd, 0, DCX_CACHE | DCX_WINDOW );
255 }
256 else
257 {
258 OffsetRect( &dst_rect, -data->client_rect.left, -data->client_rect.top );
259 /* make src rect relative to the old position of the window */
260 OffsetRect( &src_rect, -old_client_rect->left, -old_client_rect->top );
261 if (dst_rect.left == src_rect.left && dst_rect.top == src_rect.top) return;
262 hdc_src = hdc_dst = GetDCEx( data->hwnd, 0, DCX_CACHE );
263 }
264
265 code = X11DRV_START_EXPOSURES;
266 ExtEscape( hdc_dst, X11DRV_ESCAPE, sizeof(code), (LPSTR)&code, 0, NULL );
267
268 TRACE( "copying bits for win %p/%lx/%lx %s -> %s\n",
269 data->hwnd, data->whole_window, data->client_window,
270 wine_dbgstr_rect(&src_rect), wine_dbgstr_rect(&dst_rect) );
271 BitBlt( hdc_dst, dst_rect.left, dst_rect.top,
272 dst_rect.right - dst_rect.left, dst_rect.bottom - dst_rect.top,
273 hdc_src, src_rect.left, src_rect.top, SRCCOPY );
274
275 code = X11DRV_END_EXPOSURES;
276 ExtEscape( hdc_dst, X11DRV_ESCAPE, sizeof(code), (LPSTR)&code, sizeof(rgn), (LPSTR)&rgn );
277
278 ReleaseDC( data->hwnd, hdc_dst );
279 if (hdc_src != hdc_dst) ReleaseDC( parent, hdc_src );
280
281 if (rgn)
282 {
283 if (!data->whole_window)
284 {
285 /* map region to client rect since we are using DCX_WINDOW */
286 OffsetRgn( rgn, data->window_rect.left - data->client_rect.left,
287 data->window_rect.top - data->client_rect.top );
288 RedrawWindow( data->hwnd, NULL, rgn,
289 RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ALLCHILDREN );
290 }
291 else RedrawWindow( data->hwnd, NULL, rgn, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN );
292 DeleteObject( rgn );
293 }
294 }
295
296 /***********************************************************************
297 * SetWindowPos (X11DRV.@)
298 */
299 void X11DRV_SetWindowPos( HWND hwnd, HWND insert_after, UINT swp_flags,
300 const RECT *rectWindow, const RECT *rectClient,
301 const RECT *visible_rect, const RECT *valid_rects )
302 {
303 struct x11drv_thread_data *thread_data = x11drv_thread_data();
304 Display *display = thread_data->display;
305 struct x11drv_win_data *data = X11DRV_get_win_data( hwnd );
306 DWORD new_style = GetWindowLongW( hwnd, GWL_STYLE );
307 RECT old_window_rect, old_whole_rect, old_client_rect;
308 int event_type;
309
310 if (!data)
311 {
312 /* create the win data if the window is being made visible */
313 if (!(new_style & WS_VISIBLE)) return;
314 if (!(data = X11DRV_create_win_data( hwnd ))) return;
315 }
316
317 /* check if we need to switch the window to managed */
318 if (!data->managed && data->whole_window && is_window_managed( hwnd, swp_flags, rectWindow ))
319 {
320 TRACE( "making win %p/%lx managed\n", hwnd, data->whole_window );
321 data->managed = TRUE;
322 SetPropA( hwnd, managed_prop, (HANDLE)1 );
323 if (data->mapped)
324 {
325 wine_tsx11_lock();
326 XUnmapWindow( display, data->whole_window );
327 wine_tsx11_unlock();
328 data->mapped = FALSE;
329 }
330 }
331
332 old_window_rect = data->window_rect;
333 old_whole_rect = data->whole_rect;
334 old_client_rect = data->client_rect;
335 data->window_rect = *rectWindow;
336 data->whole_rect = *rectWindow;
337 data->client_rect = *rectClient;
338 X11DRV_window_to_X_rect( data, &data->whole_rect );
339 if (memcmp( visible_rect, &data->whole_rect, sizeof(RECT) ))
340 {
341 TRACE( "%p: need to update visible rect %s -> %s\n", hwnd,
342 wine_dbgstr_rect(visible_rect), wine_dbgstr_rect(&data->whole_rect) );
343 SERVER_START_REQ( set_window_visible_rect )
344 {
345 req->handle = hwnd;
346 req->flags = swp_flags;
347 req->visible.left = data->whole_rect.left;
348 req->visible.top = data->whole_rect.top;
349 req->visible.right = data->whole_rect.right;
350 req->visible.bottom = data->whole_rect.bottom;
351 wine_server_call( req );
352 }
353 SERVER_END_REQ;
354 }
355
356 TRACE( "win %p window %s client %s style %08x flags %08x\n",
357 hwnd, wine_dbgstr_rect(rectWindow), wine_dbgstr_rect(rectClient), new_style, swp_flags );
358
359 if (!IsRectEmpty( &valid_rects[0] ))
360 {
361 int x_offset = old_whole_rect.left - data->whole_rect.left;
362 int y_offset = old_whole_rect.top - data->whole_rect.top;
363
364 /* if all that happened is that the whole window moved, copy everything */
365 if (!(swp_flags & SWP_FRAMECHANGED) &&
366 old_whole_rect.right - data->whole_rect.right == x_offset &&
367 old_whole_rect.bottom - data->whole_rect.bottom == y_offset &&
368 old_client_rect.left - data->client_rect.left == x_offset &&
369 old_client_rect.right - data->client_rect.right == x_offset &&
370 old_client_rect.top - data->client_rect.top == y_offset &&
371 old_client_rect.bottom - data->client_rect.bottom == y_offset &&
372 !memcmp( &valid_rects[0], &data->client_rect, sizeof(RECT) ))
373 {
374 /* if we have an X window the bits will be moved by the X server */
375 if (!data->whole_window)
376 move_window_bits( data, &old_whole_rect, &data->whole_rect, &old_client_rect );
377 }
378 else
379 move_window_bits( data, &valid_rects[1], &valid_rects[0], &old_client_rect );
380 }
381
382 X11DRV_sync_client_position( display, data, swp_flags, &old_client_rect, &old_whole_rect );
383
384 if (!data->whole_window) return;
385
386 /* check if we are currently processing an event relevant to this window */
387 event_type = 0;
388 if (thread_data->current_event && thread_data->current_event->xany.window == data->whole_window)
389 event_type = thread_data->current_event->type;
390
391 if (event_type != ConfigureNotify && event_type != PropertyNotify)
392 event_type = 0; /* ignore other events */
393
394 if (data->mapped && (!(new_style & WS_VISIBLE) ||
395 (!event_type && !X11DRV_is_window_rect_mapped( rectWindow ))))
396 {
397 TRACE( "unmapping win %p/%lx\n", hwnd, data->whole_window );
398 wait_for_withdrawn_state( display, data, FALSE );
399 wine_tsx11_lock();
400 if (data->managed) XWithdrawWindow( display, data->whole_window, DefaultScreen(display) );
401 else XUnmapWindow( display, data->whole_window );
402 wine_tsx11_unlock();
403 data->mapped = FALSE;
404 data->net_wm_state = 0;
405 }
406
407 /* don't change position if we are about to minimize or maximize a managed window */
408 if (!event_type &&
409 !(data->managed && (swp_flags & SWP_STATECHANGED) && (new_style & (WS_MINIMIZE|WS_MAXIMIZE))))
410 X11DRV_sync_window_position( display, data, swp_flags, &old_client_rect, &old_whole_rect );
411
412 if ((new_style & WS_VISIBLE) &&
413 ((new_style & WS_MINIMIZE) || X11DRV_is_window_rect_mapped( rectWindow )))
414 {
415 if (!data->mapped || (swp_flags & (SWP_FRAMECHANGED|SWP_STATECHANGED)))
416 X11DRV_set_wm_hints( display, data );
417
418 if (!data->mapped)
419 {
420 TRACE( "mapping win %p/%lx\n", hwnd, data->whole_window );
421 wait_for_withdrawn_state( display, data, TRUE );
422 X11DRV_sync_window_style( display, data );
423 wine_tsx11_lock();
424 XMapWindow( display, data->whole_window );
425 XFlush( display );
426 wine_tsx11_unlock();
427 data->mapped = TRUE;
428 data->iconic = (new_style & WS_MINIMIZE) != 0;
429 update_net_wm_states( display, data );
430 }
431 else if ((swp_flags & SWP_STATECHANGED) && (!data->iconic != !(new_style & WS_MINIMIZE)))
432 {
433 data->iconic = (new_style & WS_MINIMIZE) != 0;
434 TRACE( "changing win %p iconic state to %u\n", data->hwnd, data->iconic );
435 wine_tsx11_lock();
436 if (data->iconic)
437 XIconifyWindow( display, data->whole_window, DefaultScreen(display) );
438 else if (X11DRV_is_window_rect_mapped( rectWindow ))
439 XMapWindow( display, data->whole_window );
440 wine_tsx11_unlock();
441 update_net_wm_states( display, data );
442 }
443 else if (!event_type)
444 {
445 update_net_wm_states( display, data );
446 }
447 }
448 }
449
450
451 /**********************************************************************
452 * X11DRV_MapNotify
453 */
454 void X11DRV_MapNotify( HWND hwnd, XEvent *event )
455 {
456 struct x11drv_win_data *data;
457
458 if (!(data = X11DRV_get_win_data( hwnd ))) return;
459 if (!data->mapped) return;
460
461 if (!data->managed)
462 {
463 HWND hwndFocus = GetFocus();
464 if (hwndFocus && IsChild( hwnd, hwndFocus )) X11DRV_SetFocus(hwndFocus); /* FIXME */
465 }
466 }
467
468
469 struct desktop_resize_data
470 {
471 RECT old_screen_rect;
472 RECT old_virtual_rect;
473 };
474
475 static BOOL CALLBACK update_windows_on_desktop_resize( HWND hwnd, LPARAM lparam )
476 {
477 struct x11drv_win_data *data;
478 Display *display = thread_display();
479 struct desktop_resize_data *resize_data = (struct desktop_resize_data *)lparam;
480 int mask = 0;
481
482 if (!(data = X11DRV_get_win_data( hwnd ))) return TRUE;
483
484 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_VISIBLE)
485 {
486 /* update the full screen state */
487 update_net_wm_states( display, data );
488 }
489
490 if (resize_data->old_virtual_rect.left != virtual_screen_rect.left) mask |= CWX;
491 if (resize_data->old_virtual_rect.top != virtual_screen_rect.top) mask |= CWY;
492 if (mask && data->whole_window)
493 {
494 XWindowChanges changes;
495
496 wine_tsx11_lock();
497 changes.x = data->whole_rect.left - virtual_screen_rect.left;
498 changes.y = data->whole_rect.top - virtual_screen_rect.top;
499 XReconfigureWMWindow( display, data->whole_window,
500 DefaultScreen(display), mask, &changes );
501 wine_tsx11_unlock();
502 }
503 return TRUE;
504 }
505
506
507 /***********************************************************************
508 * X11DRV_resize_desktop
509 */
510 void X11DRV_resize_desktop( unsigned int width, unsigned int height )
511 {
512 HWND hwnd = GetDesktopWindow();
513 struct desktop_resize_data resize_data;
514
515 SetRect( &resize_data.old_screen_rect, 0, 0, screen_width, screen_height );
516 resize_data.old_virtual_rect = virtual_screen_rect;
517
518 xinerama_init( width, height );
519
520 if (GetWindowThreadProcessId( hwnd, NULL ) != GetCurrentThreadId())
521 {
522 SendMessageW( hwnd, WM_X11DRV_RESIZE_DESKTOP, 0, MAKELPARAM( width, height ) );
523 }
524 else
525 {
526 TRACE( "desktop %p change to (%dx%d)\n", hwnd, width, height );
527 SetWindowPos( hwnd, 0, virtual_screen_rect.left, virtual_screen_rect.top,
528 virtual_screen_rect.right - virtual_screen_rect.left,
529 virtual_screen_rect.bottom - virtual_screen_rect.top,
530 SWP_NOZORDER | SWP_NOACTIVATE | SWP_DEFERERASE );
531 SendMessageTimeoutW( HWND_BROADCAST, WM_DISPLAYCHANGE, screen_bpp,
532 MAKELPARAM( width, height ), SMTO_ABORTIFHUNG, 2000, NULL );
533 }
534
535 EnumWindows( update_windows_on_desktop_resize, (LPARAM)&resize_data );
536 }
537
538
539 /***********************************************************************
540 * X11DRV_ConfigureNotify
541 */
542 void X11DRV_ConfigureNotify( HWND hwnd, XEvent *xev )
543 {
544 XConfigureEvent *event = &xev->xconfigure;
545 struct x11drv_win_data *data;
546 RECT rect;
547 UINT flags;
548 int cx, cy, x = event->x, y = event->y;
549
550 if (!hwnd) return;
551 if (!(data = X11DRV_get_win_data( hwnd ))) return;
552 if (!data->mapped) return;
553
554 /* Get geometry */
555
556 if (!event->send_event) /* normal event, need to map coordinates to the root */
557 {
558 Window child;
559 wine_tsx11_lock();
560 XTranslateCoordinates( event->display, data->whole_window, root_window,
561 0, 0, &x, &y, &child );
562 wine_tsx11_unlock();
563 }
564 rect.left = x;
565 rect.top = y;
566 rect.right = x + event->width;
567 rect.bottom = y + event->height;
568 OffsetRect( &rect, virtual_screen_rect.left, virtual_screen_rect.top );
569 TRACE( "win %p new X rect %d,%d,%dx%d (event %d,%d,%dx%d)\n",
570 hwnd, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top,
571 event->x, event->y, event->width, event->height );
572 X11DRV_X_to_window_rect( data, &rect );
573
574 x = rect.left;
575 y = rect.top;
576 cx = rect.right - rect.left;
577 cy = rect.bottom - rect.top;
578 flags = SWP_NOACTIVATE | SWP_NOZORDER;
579
580 /* Compare what has changed */
581
582 GetWindowRect( hwnd, &rect );
583 if (rect.left == x && rect.top == y) flags |= SWP_NOMOVE;
584 else
585 TRACE( "%p moving from (%d,%d) to (%d,%d)\n",
586 hwnd, rect.left, rect.top, x, y );
587
588 if ((rect.right - rect.left == cx && rect.bottom - rect.top == cy) ||
589 IsIconic(hwnd) ||
590 (IsRectEmpty( &rect ) && event->width == 1 && event->height == 1))
591 {
592 if (flags & SWP_NOMOVE) return; /* if nothing changed, don't do anything */
593 flags |= SWP_NOSIZE;
594 }
595 else
596 TRACE( "%p resizing from (%dx%d) to (%dx%d)\n",
597 hwnd, rect.right - rect.left, rect.bottom - rect.top, cx, cy );
598
599 SetWindowPos( hwnd, 0, x, y, cx, cy, flags );
600 }
601
602
603 /***********************************************************************
604 * is_netwm_supported
605 */
606 static BOOL is_netwm_supported( Display *display, Atom atom )
607 {
608 static Atom *net_supported;
609 static int net_supported_count = -1;
610 int i;
611
612 wine_tsx11_lock();
613 if (net_supported_count == -1)
614 {
615 Atom type;
616 int format;
617 unsigned long count, remaining;
618
619 if (!XGetWindowProperty( display, DefaultRootWindow(display), x11drv_atom(_NET_SUPPORTED), 0,
620 ~0UL, False, XA_ATOM, &type, &format, &count,
621 &remaining, (unsigned char **)&net_supported ))
622 net_supported_count = count * (format / 8) / sizeof(Atom);
623 else
624 net_supported_count = 0;
625 }
626 wine_tsx11_unlock();
627
628 for (i = 0; i < net_supported_count; i++)
629 if (net_supported[i] == atom) return TRUE;
630 return FALSE;
631 }
632
633
634 /***********************************************************************
635 * SysCommandSizeMove (X11DRV.@)
636 *
637 * Perform SC_MOVE and SC_SIZE commands.
638 */
639 BOOL X11DRV_SysCommandSizeMove( HWND hwnd, WPARAM wparam )
640 {
641 WPARAM syscommand = wparam & 0xfff0;
642 WPARAM hittest = wparam & 0x0f;
643 DWORD dwPoint;
644 int x, y, dir;
645 XEvent xev;
646 Display *display = thread_display();
647 struct x11drv_win_data *data;
648
649 if (!(data = X11DRV_get_win_data( hwnd ))) return FALSE;
650 if (!data->whole_window || !data->managed) return FALSE;
651
652 if (!is_netwm_supported( display, x11drv_atom(_NET_WM_MOVERESIZE) ))
653 {
654 TRACE( "_NET_WM_MOVERESIZE not supported\n" );
655 return FALSE;
656 }
657
658 if (syscommand == SC_MOVE)
659 {
660 if (!hittest) dir = _NET_WM_MOVERESIZE_MOVE_KEYBOARD;
661 else dir = _NET_WM_MOVERESIZE_MOVE;
662 }
663 else
664 {
665 /* windows without WS_THICKFRAME are not resizable through the window manager */
666 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_THICKFRAME)) return FALSE;
667
668 switch (hittest)
669 {
670 case WMSZ_LEFT: dir = _NET_WM_MOVERESIZE_SIZE_LEFT; break;
671 case WMSZ_RIGHT: dir = _NET_WM_MOVERESIZE_SIZE_RIGHT; break;
672 case WMSZ_TOP: dir = _NET_WM_MOVERESIZE_SIZE_TOP; break;
673 case WMSZ_TOPLEFT: dir = _NET_WM_MOVERESIZE_SIZE_TOPLEFT; break;
674 case WMSZ_TOPRIGHT: dir = _NET_WM_MOVERESIZE_SIZE_TOPRIGHT; break;
675 case WMSZ_BOTTOM: dir = _NET_WM_MOVERESIZE_SIZE_BOTTOM; break;
676 case WMSZ_BOTTOMLEFT: dir = _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT; break;
677 case WMSZ_BOTTOMRIGHT: dir = _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT; break;
678 default: dir = _NET_WM_MOVERESIZE_SIZE_KEYBOARD; break;
679 }
680 }
681
682 dwPoint = GetMessagePos();
683 x = (short)LOWORD(dwPoint);
684 y = (short)HIWORD(dwPoint);
685
686 TRACE("hwnd %p, x %d, y %d, dir %d\n", hwnd, x, y, dir);
687
688 xev.xclient.type = ClientMessage;
689 xev.xclient.window = X11DRV_get_whole_window(hwnd);
690 xev.xclient.message_type = x11drv_atom(_NET_WM_MOVERESIZE);
691 xev.xclient.serial = 0;
692 xev.xclient.display = display;
693 xev.xclient.send_event = True;
694 xev.xclient.format = 32;
695 xev.xclient.data.l[0] = x; /* x coord */
696 xev.xclient.data.l[1] = y; /* y coord */
697 xev.xclient.data.l[2] = dir; /* direction */
698 xev.xclient.data.l[3] = 1; /* button */
699 xev.xclient.data.l[4] = 0; /* unused */
700
701 /* need to ungrab the pointer that may have been automatically grabbed
702 * with a ButtonPress event */
703 wine_tsx11_lock();
704 XUngrabPointer( display, CurrentTime );
705 XSendEvent(display, root_window, False, SubstructureNotifyMask, &xev);
706 wine_tsx11_unlock();
707 return TRUE;
708 }
Windows API implementation