?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Restore the texture env mode on SetTexture - Fixes problem in
[wine/wine-gecko.git] / dlls / x11drv / window.c
blobf80f909509256cbe3a0ac8bdc07f858da418100d
1 /*
2 * Window related functions
3 *
4 * Copyright 1993, 1994, 1995, 1996, 2001 Alexandre Julliard
5 * Copyright 1993 David Metcalfe
6 * Copyright 1995, 1996 Alex Korobka
7 *
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.
12 *
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.
17 *
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
23 #include "config.h"
24
25 #include <stdlib.h>
26
27 #include "ts_xlib.h"
28 #include <X11/Xresource.h>
29 #include <X11/Xutil.h>
30
31 #include "winbase.h"
32 #include "wingdi.h"
33 #include "winreg.h"
34 #include "winuser.h"
35 #include "wine/unicode.h"
36
37 #include "wine/debug.h"
38 #include "x11drv.h"
39 #include "win.h"
40 #include "winpos.h"
41 #include "mwm.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(x11drv);
44
45 extern Pixmap X11DRV_BITMAP_Pixmap( HBITMAP );
46
47 #define HAS_DLGFRAME(style,exStyle) \
48 (((exStyle) & WS_EX_DLGMODALFRAME) || \
49 (((style) & WS_DLGFRAME) && !((style) & WS_THICKFRAME)))
50
51 /* X context to associate a hwnd to an X window */
52 XContext winContext = 0;
53
54 Atom wmProtocols = None;
55 Atom wmDeleteWindow = None;
56 Atom wmTakeFocus = None;
57 Atom dndProtocol = None;
58 Atom dndSelection = None;
59 Atom wmChangeState = None;
60 Atom mwmHints = None;
61 Atom kwmDockWindow = None;
62 Atom _kde_net_wm_system_tray_window_for = None; /* KDE 2 Final */
63
64 static LPCSTR whole_window_atom;
65 static LPCSTR client_window_atom;
66 static LPCSTR icon_window_atom;
67
68 /***********************************************************************
69 * is_window_managed
70 *
71 * Check if a given window should be managed
72 */
73 inline static BOOL is_window_managed( WND *win )
74 {
75 if (!managed_mode) return FALSE;
76 /* tray window is always managed */
77 if (win->dwExStyle & WS_EX_TRAYWINDOW) return TRUE;
78 /* child windows are not managed */
79 if (win->dwStyle & WS_CHILD) return FALSE;
80 /* tool windows are not managed */
81 if (win->dwExStyle & WS_EX_TOOLWINDOW) return FALSE;
82 /* windows with caption or thick frame are managed */
83 if ((win->dwStyle & WS_CAPTION) == WS_CAPTION) return TRUE;
84 if (win->dwStyle & WS_THICKFRAME) return TRUE;
85 /* default: not managed */
86 return FALSE;
87 }
88
89
90 /***********************************************************************
91 * is_client_window_mapped
92 *
93 * Check if the X client window should be mapped
94 */
95 inline static BOOL is_client_window_mapped( WND *win )
96 {
97 struct x11drv_win_data *data = win->pDriverData;
98 return !(win->dwStyle & WS_MINIMIZE) && !IsRectEmpty( &data->client_rect );
99 }
100
101
102 /***********************************************************************
103 * get_window_attributes
104 *
105 * Fill the window attributes structure for an X window.
106 */
107 static int get_window_attributes( Display *display, WND *win, XSetWindowAttributes *attr )
108 {
109 BOOL is_top_level = is_window_top_level( win );
110 BOOL managed = is_top_level && is_window_managed( win );
111
112 if (managed) WIN_SetExStyle( win->hwndSelf, win->dwExStyle | WS_EX_MANAGED );
113 else WIN_SetExStyle( win->hwndSelf, win->dwExStyle & ~WS_EX_MANAGED );
114
115 attr->override_redirect = !managed;
116 attr->colormap = X11DRV_PALETTE_PaletteXColormap;
117 attr->save_under = ((win->clsStyle & CS_SAVEBITS) != 0);
118 attr->cursor = x11drv_thread_data()->cursor;
119 attr->event_mask = (ExposureMask | KeyPressMask | KeyReleaseMask | PointerMotionMask |
120 ButtonPressMask | ButtonReleaseMask | EnterWindowMask);
121
122 if (is_window_top_level( win ))
123 attr->event_mask |= StructureNotifyMask | FocusChangeMask | KeymapStateMask;
124
125 return (CWOverrideRedirect | CWSaveUnder | CWEventMask | CWColormap | CWCursor);
126 }
127
128
129 /***********************************************************************
130 * X11DRV_sync_window_style
131 *
132 * Change the X window attributes when the window style has changed.
133 */
134 void X11DRV_sync_window_style( Display *display, WND *win )
135 {
136 XSetWindowAttributes attr;
137 int mask;
138
139 wine_tsx11_lock();
140 mask = get_window_attributes( display, win, &attr );
141 XChangeWindowAttributes( display, get_whole_window(win), mask, &attr );
142 wine_tsx11_unlock();
143 }
144
145
146 /***********************************************************************
147 * get_window_changes
148 *
149 * fill the window changes structure
150 */
151 static int get_window_changes( XWindowChanges *changes, const RECT *old, const RECT *new )
152 {
153 int mask = 0;
154
155 if (old->right - old->left != new->right - new->left )
156 {
157 if (!(changes->width = new->right - new->left)) changes->width = 1;
158 mask |= CWWidth;
159 }
160 if (old->bottom - old->top != new->bottom - new->top)
161 {
162 if (!(changes->height = new->bottom - new->top)) changes->height = 1;
163 mask |= CWHeight;
164 }
165 if (old->left != new->left)
166 {
167 changes->x = new->left;
168 mask |= CWX;
169 }
170 if (old->top != new->top)
171 {
172 changes->y = new->top;
173 mask |= CWY;
174 }
175 return mask;
176 }
177
178
179 /***********************************************************************
180 * create_icon_window
181 */
182 static Window create_icon_window( Display *display, WND *win )
183 {
184 struct x11drv_win_data *data = win->pDriverData;
185 XSetWindowAttributes attr;
186
187 attr.event_mask = (ExposureMask | KeyPressMask | KeyReleaseMask | PointerMotionMask |
188 ButtonPressMask | ButtonReleaseMask | EnterWindowMask);
189 attr.bit_gravity = NorthWestGravity;
190 attr.backing_store = NotUseful/*WhenMapped*/;
191 attr.colormap = X11DRV_PALETTE_PaletteXColormap; /* Needed due to our visual */
192
193 wine_tsx11_lock();
194 data->icon_window = XCreateWindow( display, root_window, 0, 0,
195 GetSystemMetrics( SM_CXICON ),
196 GetSystemMetrics( SM_CYICON ),
197 0, screen_depth,
198 InputOutput, visual,
199 CWEventMask | CWBitGravity | CWBackingStore | CWColormap, &attr );
200 XSaveContext( display, data->icon_window, winContext, (char *)win->hwndSelf );
201 wine_tsx11_unlock();
202
203 TRACE( "created %lx\n", data->icon_window );
204 SetPropA( win->hwndSelf, icon_window_atom, (HANDLE)data->icon_window );
205 return data->icon_window;
206 }
207
208
209
210 /***********************************************************************
211 * destroy_icon_window
212 */
213 inline static void destroy_icon_window( Display *display, WND *win )
214 {
215 struct x11drv_win_data *data = win->pDriverData;
216
217 if (!data->icon_window) return;
218 if (x11drv_thread_data()->cursor_window == data->icon_window)
219 x11drv_thread_data()->cursor_window = None;
220 wine_tsx11_lock();
221 XDeleteContext( display, data->icon_window, winContext );
222 XDestroyWindow( display, data->icon_window );
223 data->icon_window = 0;
224 wine_tsx11_unlock();
225 RemovePropA( win->hwndSelf, icon_window_atom );
226 }
227
228
229 /***********************************************************************
230 * set_icon_hints
231 *
232 * Set the icon wm hints
233 */
234 static void set_icon_hints( Display *display, WND *wndPtr, XWMHints *hints )
235 {
236 X11DRV_WND_DATA *data = wndPtr->pDriverData;
237 HICON hIcon = (HICON)GetClassLongA( wndPtr->hwndSelf, GCL_HICON );
238
239 if (data->hWMIconBitmap) DeleteObject( data->hWMIconBitmap );
240 if (data->hWMIconMask) DeleteObject( data->hWMIconMask);
241 data->hWMIconBitmap = 0;
242 data->hWMIconMask = 0;
243
244 if (!(wndPtr->dwExStyle & WS_EX_MANAGED))
245 {
246 destroy_icon_window( display, wndPtr );
247 hints->flags &= ~(IconPixmapHint | IconMaskHint | IconWindowHint);
248 }
249 else if (!hIcon)
250 {
251 if (!data->icon_window) create_icon_window( display, wndPtr );
252 hints->icon_window = data->icon_window;
253 hints->flags = (hints->flags & ~(IconPixmapHint | IconMaskHint)) | IconWindowHint;
254 }
255 else
256 {
257 HBITMAP hbmOrig;
258 RECT rcMask;
259 BITMAP bmMask;
260 ICONINFO ii;
261 HDC hDC;
262
263 GetIconInfo(hIcon, &ii);
264
265 GetObjectA(ii.hbmMask, sizeof(bmMask), &bmMask);
266 rcMask.top = 0;
267 rcMask.left = 0;
268 rcMask.right = bmMask.bmWidth;
269 rcMask.bottom = bmMask.bmHeight;
270
271 hDC = CreateCompatibleDC(0);
272 hbmOrig = SelectObject(hDC, ii.hbmMask);
273 InvertRect(hDC, &rcMask);
274 SelectObject(hDC, ii.hbmColor); /* force the color bitmap to x11drv mode too */
275 SelectObject(hDC, hbmOrig);
276 DeleteDC(hDC);
277
278 data->hWMIconBitmap = ii.hbmColor;
279 data->hWMIconMask = ii.hbmMask;
280
281 hints->icon_pixmap = X11DRV_BITMAP_Pixmap(data->hWMIconBitmap);
282 hints->icon_mask = X11DRV_BITMAP_Pixmap(data->hWMIconMask);
283 destroy_icon_window( display, wndPtr );
284 hints->flags = (hints->flags & ~IconWindowHint) | IconPixmapHint | IconMaskHint;
285 }
286 }
287
288
289 /***********************************************************************
290 * set_size_hints
291 *
292 * set the window size hints
293 */
294 static void set_size_hints( Display *display, WND *win )
295 {
296 XSizeHints* size_hints;
297 struct x11drv_win_data *data = win->pDriverData;
298
299 if ((size_hints = XAllocSizeHints()))
300 {
301 size_hints->win_gravity = StaticGravity;
302 size_hints->x = data->whole_rect.left;
303 size_hints->y = data->whole_rect.top;
304 size_hints->flags = PWinGravity | PPosition;
305
306 if (HAS_DLGFRAME( win->dwStyle, win->dwExStyle ))
307 {
308 size_hints->max_width = data->whole_rect.right - data->whole_rect.left;
309 size_hints->max_height = data->whole_rect.bottom - data->whole_rect.top;
310 size_hints->min_width = size_hints->max_width;
311 size_hints->min_height = size_hints->max_height;
312 size_hints->flags |= PMinSize | PMaxSize;
313 }
314 XSetWMNormalHints( display, data->whole_window, size_hints );
315 XFree( size_hints );
316 }
317 }
318
319
320 /***********************************************************************
321 * X11DRV_set_wm_hints
322 *
323 * Set the window manager hints for a newly-created window
324 */
325 void X11DRV_set_wm_hints( Display *display, WND *win )
326 {
327 struct x11drv_win_data *data = win->pDriverData;
328 Window group_leader;
329 XClassHint *class_hints;
330 XWMHints* wm_hints;
331 Atom protocols[2];
332 int i;
333
334 wine_tsx11_lock();
335
336 /* wm protocols */
337 i = 0;
338 protocols[i++] = wmDeleteWindow;
339 if (wmTakeFocus) protocols[i++] = wmTakeFocus;
340 XSetWMProtocols( display, data->whole_window, protocols, i );
341
342 /* class hints */
343 if ((class_hints = XAllocClassHint()))
344 {
345 class_hints->res_name = "wine";
346 class_hints->res_class = "Wine";
347 XSetClassHint( display, data->whole_window, class_hints );
348 XFree( class_hints );
349 }
350
351 /* transient for hint */
352 if (win->owner)
353 {
354 Window owner_win = X11DRV_get_whole_window( win->owner );
355 XSetTransientForHint( display, data->whole_window, owner_win );
356 group_leader = owner_win;
357 }
358 else group_leader = data->whole_window;
359
360 /* size hints */
361 set_size_hints( display, win );
362
363 /* systray properties (KDE only for now) */
364 if (win->dwExStyle & WS_EX_TRAYWINDOW)
365 {
366 int val = 1;
367 if (kwmDockWindow != None)
368 XChangeProperty( display, data->whole_window, kwmDockWindow, kwmDockWindow,
369 32, PropModeReplace, (char*)&val, 1 );
370 if (_kde_net_wm_system_tray_window_for != None)
371 XChangeProperty( display, data->whole_window, _kde_net_wm_system_tray_window_for,
372 XA_WINDOW, 32, PropModeReplace, (char*)&data->whole_window, 1 );
373 }
374
375 if (mwmHints != None)
376 {
377 MwmHints mwm_hints;
378 mwm_hints.flags = MWM_HINTS_FUNCTIONS | MWM_HINTS_DECORATIONS;
379 mwm_hints.functions = 0;
380 if ((win->dwStyle & WS_CAPTION) == WS_CAPTION) mwm_hints.functions |= MWM_FUNC_MOVE;
381 if (win->dwStyle & WS_THICKFRAME) mwm_hints.functions |= MWM_FUNC_MOVE | MWM_FUNC_RESIZE;
382 if (win->dwStyle & WS_MINIMIZEBOX) mwm_hints.functions |= MWM_FUNC_MINIMIZE;
383 if (win->dwStyle & WS_MAXIMIZEBOX) mwm_hints.functions |= MWM_FUNC_MAXIMIZE;
384 if (win->dwStyle & WS_SYSMENU) mwm_hints.functions |= MWM_FUNC_CLOSE;
385 mwm_hints.decorations = 0;
386 if ((win->dwStyle & WS_CAPTION) == WS_CAPTION) mwm_hints.decorations |= MWM_DECOR_TITLE;
387 if (win->dwExStyle & WS_EX_DLGMODALFRAME) mwm_hints.decorations |= MWM_DECOR_BORDER;
388 else if (win->dwStyle & WS_THICKFRAME) mwm_hints.decorations |= MWM_DECOR_BORDER | MWM_DECOR_RESIZEH;
389 else if ((win->dwStyle & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME) mwm_hints.decorations |= MWM_DECOR_BORDER;
390 else if (win->dwStyle & WS_BORDER) mwm_hints.decorations |= MWM_DECOR_BORDER;
391 else if (!(win->dwStyle & (WS_CHILD|WS_POPUP))) mwm_hints.decorations |= MWM_DECOR_BORDER;
392 if (win->dwStyle & WS_SYSMENU) mwm_hints.decorations |= MWM_DECOR_MENU;
393 if (win->dwStyle & WS_MINIMIZEBOX) mwm_hints.decorations |= MWM_DECOR_MINIMIZE;
394 if (win->dwStyle & WS_MAXIMIZEBOX) mwm_hints.decorations |= MWM_DECOR_MAXIMIZE;
395
396 XChangeProperty( display, data->whole_window, mwmHints, mwmHints, 32,
397 PropModeReplace, (char*)&mwm_hints, sizeof(mwm_hints)/sizeof(long) );
398 }
399
400 wm_hints = XAllocWMHints();
401 wine_tsx11_unlock();
402
403 /* wm hints */
404 if (wm_hints)
405 {
406 wm_hints->flags = InputHint | StateHint | WindowGroupHint;
407 wm_hints->input = !(win->dwStyle & WS_DISABLED);
408
409 set_icon_hints( display, win, wm_hints );
410
411 wm_hints->initial_state = (win->dwStyle & WS_MINIMIZE) ? IconicState : NormalState;
412 wm_hints->window_group = group_leader;
413
414 wine_tsx11_lock();
415 XSetWMHints( display, data->whole_window, wm_hints );
416 XFree(wm_hints);
417 wine_tsx11_unlock();
418 }
419 }
420
421
422 /***********************************************************************
423 * X11DRV_set_iconic_state
424 *
425 * Set the X11 iconic state according to the window style.
426 */
427 void X11DRV_set_iconic_state( WND *win )
428 {
429 Display *display = thread_display();
430 struct x11drv_win_data *data = win->pDriverData;
431 XWMHints* wm_hints;
432 BOOL iconic = IsIconic( win->hwndSelf );
433
434 wine_tsx11_lock();
435
436 if (iconic) XUnmapWindow( display, data->client_window );
437 else if (is_client_window_mapped( win )) XMapWindow( display, data->client_window );
438
439 if (!(wm_hints = XGetWMHints( display, data->whole_window ))) wm_hints = XAllocWMHints();
440 wm_hints->flags |= StateHint | IconPositionHint;
441 wm_hints->initial_state = iconic ? IconicState : NormalState;
442 wm_hints->icon_x = win->rectWindow.left;
443 wm_hints->icon_y = win->rectWindow.top;
444 XSetWMHints( display, data->whole_window, wm_hints );
445
446 if (win->dwStyle & WS_VISIBLE)
447 {
448 if (iconic)
449 XIconifyWindow( display, data->whole_window, DefaultScreen(display) );
450 else
451 if (!IsRectEmpty( &win->rectWindow )) XMapWindow( display, data->whole_window );
452 }
453
454 XFree(wm_hints);
455 wine_tsx11_unlock();
456 }
457
458
459 /***********************************************************************
460 * X11DRV_window_to_X_rect
461 *
462 * Convert a rect from client to X window coordinates
463 */
464 void X11DRV_window_to_X_rect( WND *win, RECT *rect )
465 {
466 RECT rc;
467
468 if (!(win->dwExStyle & WS_EX_MANAGED)) return;
469 if (IsRectEmpty( rect )) return;
470
471 rc.top = rc.bottom = rc.left = rc.right = 0;
472
473 AdjustWindowRectEx( &rc, win->dwStyle & ~(WS_HSCROLL|WS_VSCROLL), FALSE, win->dwExStyle );
474
475 rect->left -= rc.left;
476 rect->right -= rc.right;
477 rect->top -= rc.top;
478 rect->bottom -= rc.bottom;
479 if (rect->top >= rect->bottom) rect->bottom = rect->top + 1;
480 if (rect->left >= rect->right) rect->right = rect->left + 1;
481 }
482
483
484 /***********************************************************************
485 * X11DRV_X_to_window_rect
486 *
487 * Opposite of X11DRV_window_to_X_rect
488 */
489 void X11DRV_X_to_window_rect( WND *win, RECT *rect )
490 {
491 if (!(win->dwExStyle & WS_EX_MANAGED)) return;
492 if (IsRectEmpty( rect )) return;
493
494 AdjustWindowRectEx( rect, win->dwStyle & ~(WS_HSCROLL|WS_VSCROLL), FALSE, win->dwExStyle );
495
496 if (rect->top >= rect->bottom) rect->bottom = rect->top + 1;
497 if (rect->left >= rect->right) rect->right = rect->left + 1;
498 }
499
500
501 /***********************************************************************
502 * X11DRV_sync_whole_window_position
503 *
504 * Synchronize the X whole window position with the Windows one
505 */
506 int X11DRV_sync_whole_window_position( Display *display, WND *win, int zorder )
507 {
508 XWindowChanges changes;
509 int mask;
510 struct x11drv_win_data *data = win->pDriverData;
511 RECT whole_rect = win->rectWindow;
512
513 X11DRV_window_to_X_rect( win, &whole_rect );
514 mask = get_window_changes( &changes, &data->whole_rect, &whole_rect );
515
516 if (zorder)
517 {
518 /* find window that this one must be after */
519 HWND prev = GetWindow( win->hwndSelf, GW_HWNDPREV );
520 while (prev && !(GetWindowLongW( prev, GWL_STYLE ) & WS_VISIBLE))
521 prev = GetWindow( prev, GW_HWNDPREV );
522 if (!prev) /* top child */
523 {
524 changes.stack_mode = Above;
525 mask |= CWStackMode;
526 }
527 else
528 {
529 changes.stack_mode = Below;
530 changes.sibling = X11DRV_get_whole_window(prev);
531 mask |= CWStackMode | CWSibling;
532 }
533 }
534
535 data->whole_rect = whole_rect;
536
537 if (mask)
538 {
539 TRACE( "setting win %lx pos %ld,%ld,%ldx%ld after %lx changes=%x\n",
540 data->whole_window, whole_rect.left, whole_rect.top,
541 whole_rect.right - whole_rect.left, whole_rect.bottom - whole_rect.top,
542 changes.sibling, mask );
543 wine_tsx11_lock();
544 XSync( gdi_display, False ); /* flush graphics operations before moving the window */
545 if (is_window_top_level( win ))
546 {
547 if (mask & (CWWidth|CWHeight)) set_size_hints( display, win );
548 XReconfigureWMWindow( display, data->whole_window,
549 DefaultScreen(display), mask, &changes );
550 }
551 else XConfigureWindow( display, data->whole_window, mask, &changes );
552 wine_tsx11_unlock();
553 }
554 return mask;
555 }
556
557
558 /***********************************************************************
559 * X11DRV_sync_client_window_position
560 *
561 * Synchronize the X client window position with the Windows one
562 */
563 int X11DRV_sync_client_window_position( Display *display, WND *win )
564 {
565 XWindowChanges changes;
566 int mask;
567 struct x11drv_win_data *data = win->pDriverData;
568 RECT client_rect = win->rectClient;
569
570 OffsetRect( &client_rect, -data->whole_rect.left, -data->whole_rect.top );
571
572 if ((mask = get_window_changes( &changes, &data->client_rect, &client_rect )))
573 {
574 BOOL was_mapped = is_client_window_mapped( win );
575
576 TRACE( "setting win %lx pos %ld,%ld,%ldx%ld (was %ld,%ld,%ldx%ld) after %lx changes=%x\n",
577 data->client_window, client_rect.left, client_rect.top,
578 client_rect.right - client_rect.left, client_rect.bottom - client_rect.top,
579 data->client_rect.left, data->client_rect.top,
580 data->client_rect.right - data->client_rect.left,
581 data->client_rect.bottom - data->client_rect.top,
582 changes.sibling, mask );
583 data->client_rect = client_rect;
584 wine_tsx11_lock();
585 XSync( gdi_display, False ); /* flush graphics operations before moving the window */
586 if (was_mapped && !is_client_window_mapped( win ))
587 XUnmapWindow( display, data->client_window );
588 XConfigureWindow( display, data->client_window, mask, &changes );
589 if (!was_mapped && is_client_window_mapped( win ))
590 XMapWindow( display, data->client_window );
591 wine_tsx11_unlock();
592 }
593 return mask;
594 }
595
596
597 /***********************************************************************
598 * X11DRV_register_window
599 *
600 * Associate an X window to a HWND.
601 */
602 void X11DRV_register_window( Display *display, HWND hwnd, struct x11drv_win_data *data )
603 {
604 wine_tsx11_lock();
605 XSaveContext( display, data->whole_window, winContext, (char *)hwnd );
606 XSaveContext( display, data->client_window, winContext, (char *)hwnd );
607 wine_tsx11_unlock();
608 }
609
610
611 /**********************************************************************
612 * create_desktop
613 */
614 static void create_desktop( Display *display, WND *wndPtr, CREATESTRUCTA *cs )
615 {
616 X11DRV_WND_DATA *data = wndPtr->pDriverData;
617
618 wine_tsx11_lock();
619 winContext = XUniqueContext();
620 wmProtocols = XInternAtom( display, "WM_PROTOCOLS", False );
621 wmDeleteWindow = XInternAtom( display, "WM_DELETE_WINDOW", False );
622 if (use_take_focus) wmTakeFocus = XInternAtom( display, "WM_TAKE_FOCUS", False );
623 dndProtocol = XInternAtom( display, "DndProtocol" , False );
624 dndSelection = XInternAtom( display, "DndSelection" , False );
625 wmChangeState = XInternAtom( display, "WM_CHANGE_STATE", False );
626 mwmHints = XInternAtom( display, _XA_MWM_HINTS, False );
627 kwmDockWindow = XInternAtom( display, "KWM_DOCKWINDOW", False );
628 _kde_net_wm_system_tray_window_for = XInternAtom( display, "_KDE_NET_WM_SYSTEM_TRAY_WINDOW_FOR", False );
629 wine_tsx11_unlock();
630
631 whole_window_atom = MAKEINTATOMA( GlobalAddAtomA( "__wine_x11_whole_window" ));
632 client_window_atom = MAKEINTATOMA( GlobalAddAtomA( "__wine_x11_client_window" ));
633 icon_window_atom = MAKEINTATOMA( GlobalAddAtomA( "__wine_x11_icon_window" ));
634
635 data->whole_window = data->client_window = root_window;
636 data->whole_rect = data->client_rect = wndPtr->rectWindow;
637
638 SetPropA( wndPtr->hwndSelf, whole_window_atom, (HANDLE)root_window );
639 SetPropA( wndPtr->hwndSelf, client_window_atom, (HANDLE)root_window );
640 SetPropA( wndPtr->hwndSelf, "__wine_x11_visual_id", (HANDLE)XVisualIDFromVisual(visual) );
641
642 SendMessageW( wndPtr->hwndSelf, WM_NCCREATE, 0, (LPARAM)cs );
643 if (root_window != DefaultRootWindow(display)) X11DRV_create_desktop_thread();
644 }
645
646
647 /**********************************************************************
648 * create_whole_window
649 *
650 * Create the whole X window for a given window
651 */
652 static Window create_whole_window( Display *display, WND *win )
653 {
654 struct x11drv_win_data *data = win->pDriverData;
655 int cx, cy, mask;
656 XSetWindowAttributes attr;
657 Window parent;
658 RECT rect;
659 BOOL is_top_level = is_window_top_level( win );
660
661 rect = win->rectWindow;
662 X11DRV_window_to_X_rect( win, &rect );
663
664 if (!(cx = rect.right - rect.left)) cx = 1;
665 if (!(cy = rect.bottom - rect.top)) cy = 1;
666
667 parent = X11DRV_get_client_window( win->parent );
668
669 wine_tsx11_lock();
670
671 mask = get_window_attributes( display, win, &attr );
672
673 /* set the attributes that don't change over the lifetime of the window */
674 attr.bit_gravity = ForgetGravity;
675 attr.win_gravity = NorthWestGravity;
676 attr.backing_store = NotUseful/*WhenMapped*/;
677 mask |= CWBitGravity | CWWinGravity | CWBackingStore;
678
679 data->whole_rect = rect;
680 data->whole_window = XCreateWindow( display, parent, rect.left, rect.top, cx, cy,
681 0, screen_depth, InputOutput, visual,
682 mask, &attr );
683
684 if (!data->whole_window)
685 {
686 wine_tsx11_unlock();
687 return 0;
688 }
689
690 /* non-maximized child must be at bottom of Z order */
691 if ((win->dwStyle & (WS_CHILD|WS_MAXIMIZE)) == WS_CHILD)
692 {
693 XWindowChanges changes;
694 changes.stack_mode = Below;
695 XConfigureWindow( display, data->whole_window, CWStackMode, &changes );
696 }
697
698 wine_tsx11_unlock();
699
700 if (is_top_level) X11DRV_set_wm_hints( display, win );
701
702 return data->whole_window;
703 }
704
705
706 /**********************************************************************
707 * create_client_window
708 *
709 * Create the client window for a given window
710 */
711 static Window create_client_window( Display *display, WND *win )
712 {
713 struct x11drv_win_data *data = win->pDriverData;
714 RECT rect = data->whole_rect;
715 XSetWindowAttributes attr;
716
717 OffsetRect( &rect, -data->whole_rect.left, -data->whole_rect.top );
718 data->client_rect = rect;
719
720 attr.event_mask = (ExposureMask | KeyPressMask | KeyReleaseMask | PointerMotionMask |
721 ButtonPressMask | ButtonReleaseMask | EnterWindowMask);
722 attr.bit_gravity = (win->clsStyle & (CS_VREDRAW | CS_HREDRAW)) ?
723 ForgetGravity : NorthWestGravity;
724 attr.backing_store = NotUseful/*WhenMapped*/;
725
726 wine_tsx11_lock();
727 data->client_window = XCreateWindow( display, data->whole_window, 0, 0,
728 max( rect.right - rect.left, 1 ),
729 max( rect.bottom - rect.top, 1 ),
730 0, screen_depth,
731 InputOutput, visual,
732 CWEventMask | CWBitGravity | CWBackingStore, &attr );
733 if (data->client_window && is_client_window_mapped( win ))
734 XMapWindow( display, data->client_window );
735 wine_tsx11_unlock();
736 return data->client_window;
737 }
738
739
740 /*****************************************************************
741 * SetWindowText (X11DRV.@)
742 */
743 BOOL X11DRV_SetWindowText( HWND hwnd, LPCWSTR text )
744 {
745 Display *display = thread_display();
746 UINT count;
747 char *buffer;
748 char *utf8_buffer;
749 static UINT text_cp = (UINT)-1;
750 Window win;
751
752 if ((win = X11DRV_get_whole_window( hwnd )))
753 {
754 if (text_cp == (UINT)-1)
755 {
756 HKEY hkey;
757 /* default value */
758 text_cp = CP_ACP;
759 if(!RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\x11drv", &hkey))
760 {
761 char buffer[20];
762 DWORD type, count = sizeof(buffer);
763 if(!RegQueryValueExA(hkey, "TextCP", 0, &type, buffer, &count))
764 text_cp = atoi(buffer);
765 RegCloseKey(hkey);
766 }
767 TRACE("text_cp = %u\n", text_cp);
768 }
769
770 /* allocate new buffer for window text */
771 count = WideCharToMultiByte(text_cp, 0, text, -1, NULL, 0, NULL, NULL);
772 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, count )))
773 {
774 ERR("Not enough memory for window text\n");
775 return FALSE;
776 }
777 WideCharToMultiByte(text_cp, 0, text, -1, buffer, count, NULL, NULL);
778
779 count = WideCharToMultiByte(CP_UTF8, 0, text, strlenW(text), NULL, 0, NULL, NULL);
780 if (!(utf8_buffer = HeapAlloc( GetProcessHeap(), 0, count )))
781 {
782 ERR("Not enough memory for window text in UTF-8\n");
783 return FALSE;
784 }
785 WideCharToMultiByte(CP_UTF8, 0, text, strlenW(text), utf8_buffer, count, NULL, NULL);
786
787 wine_tsx11_lock();
788 XStoreName( display, win, buffer );
789 XSetIconName( display, win, buffer );
790 /*
791 Implements a NET_WM UTF-8 title. It should be without a trailing \0,
792 according to the standard
793 ( http://www.pps.jussieu.fr/~jch/software/UTF8_STRING/UTF8_STRING.text ).
794 */
795 XChangeProperty( display, win,
796 XInternAtom(display, "_NET_WM_NAME", False),
797 XInternAtom(display, "UTF8_STRING", False),
798 8, PropModeReplace, (unsigned char *) utf8_buffer,
799 count);
800 wine_tsx11_unlock();
801
802 HeapFree( GetProcessHeap(), 0, utf8_buffer );
803 HeapFree( GetProcessHeap(), 0, buffer );
804 }
805 return TRUE;
806 }
807
808
809 /***********************************************************************
810 * DestroyWindow (X11DRV.@)
811 */
812 BOOL X11DRV_DestroyWindow( HWND hwnd )
813 {
814 struct x11drv_thread_data *thread_data = x11drv_thread_data();
815 Display *display = thread_data->display;
816 WND *wndPtr = WIN_GetPtr( hwnd );
817 X11DRV_WND_DATA *data = wndPtr->pDriverData;
818
819 if (!data) goto done;
820
821 if (data->whole_window)
822 {
823 TRACE( "win %p xwin %lx/%lx\n", hwnd, data->whole_window, data->client_window );
824 if (thread_data->cursor_window == data->whole_window) thread_data->cursor_window = None;
825 if (thread_data->last_focus == hwnd) thread_data->last_focus = 0;
826 wine_tsx11_lock();
827 XSync( gdi_display, False ); /* flush any reference to this drawable in GDI queue */
828 XDeleteContext( display, data->whole_window, winContext );
829 XDeleteContext( display, data->client_window, winContext );
830 XDestroyWindow( display, data->whole_window ); /* this destroys client too */
831 destroy_icon_window( display, wndPtr );
832 wine_tsx11_unlock();
833 }
834
835 if (data->hWMIconBitmap) DeleteObject( data->hWMIconBitmap );
836 if (data->hWMIconMask) DeleteObject( data->hWMIconMask);
837 HeapFree( GetProcessHeap(), 0, data );
838 wndPtr->pDriverData = NULL;
839 done:
840 WIN_ReleasePtr( wndPtr );
841 return TRUE;
842 }
843
844
845 /**********************************************************************
846 * CreateWindow (X11DRV.@)
847 */
848 BOOL X11DRV_CreateWindow( HWND hwnd, CREATESTRUCTA *cs, BOOL unicode )
849 {
850 HWND hwndLinkAfter;
851 Display *display = thread_display();
852 WND *wndPtr;
853 struct x11drv_win_data *data;
854 RECT rect;
855 CBT_CREATEWNDA cbtc;
856 BOOL ret = FALSE;
857
858 if (cs->cx > 65535)
859 {
860 ERR( "invalid window width %d\n", cs->cx );
861 cs->cx = 65535;
862 }
863 if (cs->cy > 65535)
864 {
865 ERR( "invalid window height %d\n", cs->cx );
866 cs->cy = 65535;
867 }
868
869 if (!(data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data)))) return FALSE;
870 data->whole_window = 0;
871 data->client_window = 0;
872 data->icon_window = 0;
873 data->hWMIconBitmap = 0;
874 data->hWMIconMask = 0;
875
876 wndPtr = WIN_GetPtr( hwnd );
877 wndPtr->pDriverData = data;
878
879 /* initialize the dimensions before sending WM_GETMINMAXINFO */
880 SetRect( &rect, cs->x, cs->y, cs->x + cs->cx, cs->y + cs->cy );
881 WIN_SetRectangles( hwnd, &rect, &rect );
882
883 if (!wndPtr->parent)
884 {
885 create_desktop( display, wndPtr, cs );
886 WIN_ReleasePtr( wndPtr );
887 return TRUE;
888 }
889
890 if (!create_whole_window( display, wndPtr )) goto failed;
891 if (!create_client_window( display, wndPtr )) goto failed;
892 TSXSync( display, False );
893
894 SetPropA( hwnd, whole_window_atom, (HANDLE)data->whole_window );
895 SetPropA( hwnd, client_window_atom, (HANDLE)data->client_window );
896
897 /* Call the WH_CBT hook */
898
899 hwndLinkAfter = ((cs->style & (WS_CHILD|WS_MAXIMIZE)) == WS_CHILD) ? HWND_BOTTOM : HWND_TOP;
900
901 cbtc.lpcs = cs;
902 cbtc.hwndInsertAfter = hwndLinkAfter;
903 if (HOOK_CallHooks( WH_CBT, HCBT_CREATEWND, (WPARAM)hwnd, (LPARAM)&cbtc, unicode ))
904 {
905 TRACE("CBT-hook returned !0\n");
906 goto failed;
907 }
908
909 /* Send the WM_GETMINMAXINFO message and fix the size if needed */
910 if ((cs->style & WS_THICKFRAME) || !(cs->style & (WS_POPUP | WS_CHILD)))
911 {
912 POINT maxSize, maxPos, minTrack, maxTrack;
913
914 WIN_ReleasePtr( wndPtr );
915 WINPOS_GetMinMaxInfo( hwnd, &maxSize, &maxPos, &minTrack, &maxTrack);
916 if (maxSize.x < cs->cx) cs->cx = maxSize.x;
917 if (maxSize.y < cs->cy) cs->cy = maxSize.y;
918 if (cs->cx < minTrack.x ) cs->cx = minTrack.x;
919 if (cs->cy < minTrack.y ) cs->cy = minTrack.y;
920 if (cs->cx < 0) cs->cx = 0;
921 if (cs->cy < 0) cs->cy = 0;
922
923 if (!(wndPtr = WIN_GetPtr( hwnd ))) return FALSE;
924 SetRect( &rect, cs->x, cs->y, cs->x + cs->cx, cs->y + cs->cy );
925 WIN_SetRectangles( hwnd, &rect, &rect );
926 X11DRV_sync_whole_window_position( display, wndPtr, 0 );
927 }
928 WIN_ReleasePtr( wndPtr );
929
930 /* send WM_NCCREATE */
931 TRACE( "hwnd %p cs %d,%d %dx%d\n", hwnd, cs->x, cs->y, cs->cx, cs->cy );
932 if (unicode)
933 ret = SendMessageW( hwnd, WM_NCCREATE, 0, (LPARAM)cs );
934 else
935 ret = SendMessageA( hwnd, WM_NCCREATE, 0, (LPARAM)cs );
936 if (!ret)
937 {
938 WARN("aborted by WM_xxCREATE!\n");
939 return FALSE;
940 }
941
942 if (!(wndPtr = WIN_GetPtr(hwnd))) return FALSE;
943
944 X11DRV_sync_window_style( display, wndPtr );
945
946 /* send WM_NCCALCSIZE */
947 rect = wndPtr->rectWindow;
948 WIN_ReleasePtr( wndPtr );
949 SendMessageW( hwnd, WM_NCCALCSIZE, FALSE, (LPARAM)&rect );
950
951 if (!(wndPtr = WIN_GetPtr(hwnd))) return FALSE;
952 if (rect.left > rect.right || rect.top > rect.bottom) rect = wndPtr->rectWindow;
953 WIN_SetRectangles( hwnd, &wndPtr->rectWindow, &rect );
954 X11DRV_sync_client_window_position( display, wndPtr );
955 X11DRV_register_window( display, hwnd, data );
956
957 TRACE( "win %p window %ld,%ld,%ld,%ld client %ld,%ld,%ld,%ld whole %ld,%ld,%ld,%ld X client %ld,%ld,%ld,%ld xwin %x/%x\n",
958 hwnd, wndPtr->rectWindow.left, wndPtr->rectWindow.top,
959 wndPtr->rectWindow.right, wndPtr->rectWindow.bottom,
960 wndPtr->rectClient.left, wndPtr->rectClient.top,
961 wndPtr->rectClient.right, wndPtr->rectClient.bottom,
962 data->whole_rect.left, data->whole_rect.top,
963 data->whole_rect.right, data->whole_rect.bottom,
964 data->client_rect.left, data->client_rect.top,
965 data->client_rect.right, data->client_rect.bottom,
966 (unsigned int)data->whole_window, (unsigned int)data->client_window );
967
968 if ((wndPtr->dwStyle & (WS_CHILD|WS_MAXIMIZE)) == WS_CHILD)
969 WIN_LinkWindow( hwnd, wndPtr->parent, HWND_BOTTOM );
970 else
971 WIN_LinkWindow( hwnd, wndPtr->parent, HWND_TOP );
972
973 WIN_ReleasePtr( wndPtr );
974
975 if (unicode)
976 ret = (SendMessageW( hwnd, WM_CREATE, 0, (LPARAM)cs ) != -1);
977 else
978 ret = (SendMessageA( hwnd, WM_CREATE, 0, (LPARAM)cs ) != -1);
979
980 if (!ret)
981 {
982 WIN_UnlinkWindow( hwnd );
983 return FALSE;
984 }
985
986 /* Send the size messages */
987
988 if (!(wndPtr = WIN_FindWndPtr(hwnd))) return FALSE;
989 if (!(wndPtr->flags & WIN_NEED_SIZE))
990 {
991 /* send it anyway */
992 if (((wndPtr->rectClient.right-wndPtr->rectClient.left) <0)
993 ||((wndPtr->rectClient.bottom-wndPtr->rectClient.top)<0))
994 WARN("sending bogus WM_SIZE message 0x%08lx\n",
995 MAKELONG(wndPtr->rectClient.right-wndPtr->rectClient.left,
996 wndPtr->rectClient.bottom-wndPtr->rectClient.top));
997 SendMessageW( hwnd, WM_SIZE, SIZE_RESTORED,
998 MAKELONG(wndPtr->rectClient.right-wndPtr->rectClient.left,
999 wndPtr->rectClient.bottom-wndPtr->rectClient.top));
1000 SendMessageW( hwnd, WM_MOVE, 0,
1001 MAKELONG( wndPtr->rectClient.left, wndPtr->rectClient.top ) );
1002 }
1003
1004 /* Show the window, maximizing or minimizing if needed */
1005
1006 if (wndPtr->dwStyle & (WS_MINIMIZE | WS_MAXIMIZE))
1007 {
1008 extern UINT WINPOS_MinMaximize( HWND hwnd, UINT cmd, LPRECT rect ); /*FIXME*/
1009
1010 RECT newPos;
1011 UINT swFlag = (wndPtr->dwStyle & WS_MINIMIZE) ? SW_MINIMIZE : SW_MAXIMIZE;
1012 WIN_SetStyle( hwnd, wndPtr->dwStyle & ~(WS_MAXIMIZE | WS_MINIMIZE) );
1013 WINPOS_MinMaximize( hwnd, swFlag, &newPos );
1014 swFlag = ((wndPtr->dwStyle & WS_CHILD) || GetActiveWindow())
1015 ? SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED
1016 : SWP_NOZORDER | SWP_FRAMECHANGED;
1017 SetWindowPos( hwnd, 0, newPos.left, newPos.top,
1018 newPos.right, newPos.bottom, swFlag );
1019 }
1020
1021 /* if the window was made visible set create struct flag so that
1022 * we do a proper ShowWindow later on */
1023 if (wndPtr->dwStyle & WS_VISIBLE) cs->style |= WS_VISIBLE;
1024
1025 WIN_ReleaseWndPtr( wndPtr );
1026 return TRUE;
1027
1028
1029 failed:
1030 X11DRV_DestroyWindow( hwnd );
1031 if (wndPtr) WIN_ReleasePtr( wndPtr );
1032 return FALSE;
1033 }
1034
1035
1036 /***********************************************************************
1037 * X11DRV_get_client_window
1038 *
1039 * Return the X window associated with the client area of a window
1040 */
1041 Window X11DRV_get_client_window( HWND hwnd )
1042 {
1043 Window ret = 0;
1044 WND *win = WIN_GetPtr( hwnd );
1045
1046 if (win == WND_OTHER_PROCESS)
1047 return (Window)GetPropA( hwnd, client_window_atom );
1048
1049 if (win)
1050 {
1051 struct x11drv_win_data *data = win->pDriverData;
1052 ret = data->client_window;
1053 WIN_ReleasePtr( win );
1054 }
1055 return ret;
1056 }
1057
1058
1059 /***********************************************************************
1060 * X11DRV_get_whole_window
1061 *
1062 * Return the X window associated with the full area of a window
1063 */
1064 Window X11DRV_get_whole_window( HWND hwnd )
1065 {
1066 Window ret = 0;
1067 WND *win = WIN_GetPtr( hwnd );
1068
1069 if (win == WND_OTHER_PROCESS)
1070 return (Window)GetPropA( hwnd, whole_window_atom );
1071
1072 if (win)
1073 {
1074 struct x11drv_win_data *data = win->pDriverData;
1075 ret = data->whole_window;
1076 WIN_ReleasePtr( win );
1077 }
1078 return ret;
1079 }
1080
1081
1082 /*****************************************************************
1083 * SetParent (X11DRV.@)
1084 */
1085 HWND X11DRV_SetParent( HWND hwnd, HWND parent )
1086 {
1087 Display *display = thread_display();
1088 WND *wndPtr;
1089 HWND retvalue;
1090
1091 /* Windows hides the window first, then shows it again
1092 * including the WM_SHOWWINDOW messages and all */
1093 BOOL was_visible = ShowWindow( hwnd, SW_HIDE );
1094
1095 if (!IsWindow( parent )) return 0;
1096 if (!(wndPtr = WIN_GetPtr(hwnd)) || wndPtr == WND_OTHER_PROCESS) return 0;
1097
1098 retvalue = wndPtr->parent; /* old parent */
1099 if (parent != retvalue)
1100 {
1101 struct x11drv_win_data *data = wndPtr->pDriverData;
1102
1103 WIN_LinkWindow( hwnd, parent, HWND_TOP );
1104
1105 if (parent != GetDesktopWindow()) /* a child window */
1106 {
1107 if (!(wndPtr->dwStyle & WS_CHILD))
1108 {
1109 HMENU menu = (HMENU)SetWindowLongW( hwnd, GWL_ID, 0 );
1110 if (menu) DestroyMenu( menu );
1111 }
1112 }
1113
1114 if (is_window_top_level( wndPtr )) X11DRV_set_wm_hints( display, wndPtr );
1115 wine_tsx11_lock();
1116 X11DRV_sync_window_style( display, wndPtr );
1117 XReparentWindow( display, data->whole_window, X11DRV_get_client_window(parent),
1118 data->whole_rect.left, data->whole_rect.top );
1119 wine_tsx11_unlock();
1120 }
1121 WIN_ReleasePtr( wndPtr );
1122
1123 /* SetParent additionally needs to make hwnd the topmost window
1124 in the x-order and send the expected WM_WINDOWPOSCHANGING and
1125 WM_WINDOWPOSCHANGED notification messages.
1126 */
1127 SetWindowPos( hwnd, HWND_TOPMOST, 0, 0, 0, 0,
1128 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | (was_visible ? SWP_SHOWWINDOW : 0) );
1129 /* FIXME: a WM_MOVE is also generated (in the DefWindowProc handler
1130 * for WM_WINDOWPOSCHANGED) in Windows, should probably remove SWP_NOMOVE */
1131
1132 return retvalue;
1133 }
1134
1135
1136 /*****************************************************************
1137 * SetFocus (X11DRV.@)
1138 *
1139 * Set the X focus.
1140 * Explicit colormap management seems to work only with OLVWM.
1141 */
1142 void X11DRV_SetFocus( HWND hwnd )
1143 {
1144 Display *display = thread_display();
1145 XWindowAttributes win_attr;
1146 Window win;
1147
1148 /* Only mess with the X focus if there's */
1149 /* no desktop window and if the window is not managed by the WM. */
1150 if (root_window != DefaultRootWindow(display)) return;
1151
1152 if (!hwnd) /* If setting the focus to 0, uninstall the colormap */
1153 {
1154 if (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_PRIVATE)
1155 TSXUninstallColormap( display, X11DRV_PALETTE_PaletteXColormap );
1156 return;
1157 }
1158
1159 hwnd = GetAncestor( hwnd, GA_ROOT );
1160 if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_MANAGED) return;
1161 if (!(win = X11DRV_get_whole_window( hwnd ))) return;
1162
1163 /* Set X focus and install colormap */
1164 wine_tsx11_lock();
1165 if (XGetWindowAttributes( display, win, &win_attr ) &&
1166 (win_attr.map_state == IsViewable))
1167 {
1168 /* If window is not viewable, don't change anything */
1169
1170 /* we must not use CurrentTime (ICCCM), so try to use last message time instead */
1171 /* FIXME: this is not entirely correct */
1172 XSetInputFocus( display, win, RevertToParent,
1173 /*CurrentTime*/ GetMessageTime() + X11DRV_server_startticks );
1174 if (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_PRIVATE)
1175 XInstallColormap( display, X11DRV_PALETTE_PaletteXColormap );
1176 }
1177 wine_tsx11_unlock();
1178 }
1179
1180
1181 /**********************************************************************
1182 * SetWindowIcon (X11DRV.@)
1183 *
1184 * hIcon or hIconSm has changed (or is being initialised for the
1185 * first time). Complete the X11 driver-specific initialisation
1186 * and set the window hints.
1187 *
1188 * This is not entirely correct, may need to create
1189 * an icon window and set the pixmap as a background
1190 */
1191 HICON X11DRV_SetWindowIcon( HWND hwnd, HICON icon, BOOL small )
1192 {
1193 WND *wndPtr;
1194 Display *display = thread_display();
1195 HICON old = (HICON)SetClassLongW(hwnd, small ? GCL_HICONSM : GCL_HICON, (LONG)icon );
1196
1197 SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOSIZE |
1198 SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER );
1199
1200 if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return old;
1201
1202 if (wndPtr->dwExStyle & WS_EX_MANAGED)
1203 {
1204 Window win = get_whole_window(wndPtr);
1205 XWMHints* wm_hints;
1206
1207 wine_tsx11_lock();
1208 if (!(wm_hints = XGetWMHints( display, win ))) wm_hints = XAllocWMHints();
1209 wine_tsx11_unlock();
1210 if (wm_hints)
1211 {
1212 set_icon_hints( display, wndPtr, wm_hints );
1213 wine_tsx11_lock();
1214 XSetWMHints( display, win, wm_hints );
1215 XFree( wm_hints );
1216 wine_tsx11_unlock();
1217 }
1218 }
1219 WIN_ReleasePtr( wndPtr );
1220 return old;
1221 }
Wine tree for Wine Gecko development