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