2 * Window related functions
4 * Copyright 1993, 1994, 1995, 1996, 2001 Alexandre Julliard
5 * Copyright 1993 David Metcalfe
6 * Copyright 1995, 1996 Alex Korobka
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
33 #include <X11/Xresource.h>
34 #include <X11/Xutil.h>
40 #include "wine/unicode.h"
43 #include "wine/debug.h"
44 #include "wine/server.h"
48 WINE_DEFAULT_DEBUG_CHANNEL(x11drv);
50 /* X context to associate a hwnd to an X window */
51 XContext winContext = 0;
53 /* X context to associate a struct x11drv_win_data to an hwnd */
54 static XContext win_data_context;
56 static const char whole_window_prop[] = "__wine_x11_whole_window";
57 static const char icon_window_prop[] = "__wine_x11_icon_window";
58 static const char managed_prop[] = "__wine_x11_managed";
59 static const char visual_id_prop[] = "__wine_x11_visual_id";
61 /* for XDG systray icons */
62 #define SYSTEM_TRAY_REQUEST_DOCK 0
64 /***********************************************************************
67 * Check if a given window should be managed
69 BOOL is_window_managed( HWND hwnd, UINT swp_flags, const RECT *window_rect )
71 DWORD style, ex_style;
73 /* tray window is always managed */
74 ex_style = GetWindowLongW( hwnd, GWL_EXSTYLE );
75 if (ex_style & WS_EX_TRAYWINDOW) return TRUE;
76 /* child windows are not managed */
77 style = GetWindowLongW( hwnd, GWL_STYLE );
78 if ((style & (WS_CHILD|WS_POPUP)) == WS_CHILD) return FALSE;
79 /* activated windows are managed */
80 if (!(swp_flags & (SWP_NOACTIVATE|SWP_HIDEWINDOW))) return TRUE;
81 if (hwnd == GetActiveWindow()) return TRUE;
82 /* windows with caption are managed */
83 if ((style & WS_CAPTION) == WS_CAPTION) return TRUE;
84 /* tool windows are not managed */
85 if (ex_style & WS_EX_TOOLWINDOW) return FALSE;
86 /* windows with thick frame are managed */
87 if (style & WS_THICKFRAME) return TRUE;
88 /* application windows are managed */
89 if (ex_style & WS_EX_APPWINDOW) return TRUE;
92 /* popup with sysmenu == caption are managed */
93 if (style & WS_SYSMENU) return TRUE;
94 /* full-screen popup windows are managed */
95 if ((window_rect->right - window_rect->left) == screen_width &&
96 (window_rect->bottom - window_rect->top) == screen_height)
99 /* default: not managed */
104 /***********************************************************************
105 * X11DRV_is_window_rect_mapped
107 * Check if the X whole window should be mapped based on its rectangle
109 BOOL X11DRV_is_window_rect_mapped( const RECT *rect )
111 /* don't map if rect is empty */
112 if (IsRectEmpty( rect )) return FALSE;
114 /* don't map if rect is off-screen */
115 if (rect->left >= virtual_screen_rect.right ||
116 rect->top >= virtual_screen_rect.bottom ||
117 rect->right <= virtual_screen_rect.left ||
118 rect->bottom <= virtual_screen_rect.top)
125 /***********************************************************************
126 * get_window_attributes
128 * Fill the window attributes structure for an X window.
130 static int get_window_attributes( Display *display, struct x11drv_win_data *data,
131 XSetWindowAttributes *attr )
133 attr->override_redirect = !data->managed;
134 attr->colormap = X11DRV_PALETTE_PaletteXColormap;
135 attr->save_under = ((GetClassLongW( data->hwnd, GCL_STYLE ) & CS_SAVEBITS) != 0);
136 attr->cursor = x11drv_thread_data()->cursor;
137 attr->bit_gravity = NorthWestGravity;
138 attr->backing_store = NotUseful;
139 attr->event_mask = (ExposureMask | PointerMotionMask |
140 ButtonPressMask | ButtonReleaseMask | EnterWindowMask |
141 KeyPressMask | KeyReleaseMask | FocusChangeMask | KeymapStateMask);
142 if (data->managed) attr->event_mask |= StructureNotifyMask;
144 return (CWOverrideRedirect | CWSaveUnder | CWColormap | CWCursor |
145 CWEventMask | CWBitGravity | CWBackingStore);
149 /***********************************************************************
150 * X11DRV_sync_window_style
152 * Change the X window attributes when the window style has changed.
154 void X11DRV_sync_window_style( Display *display, struct x11drv_win_data *data )
156 if (data->whole_window != root_window)
158 XSetWindowAttributes attr;
159 int mask = get_window_attributes( display, data, &attr );
162 XChangeWindowAttributes( display, data->whole_window, mask, &attr );
168 /***********************************************************************
171 * fill the window changes structure
173 static int get_window_changes( XWindowChanges *changes, const RECT *old, const RECT *new )
177 if (old->right - old->left != new->right - new->left )
179 if (!(changes->width = new->right - new->left)) changes->width = 1;
182 if (old->bottom - old->top != new->bottom - new->top)
184 if (!(changes->height = new->bottom - new->top)) changes->height = 1;
187 if (old->left != new->left)
189 changes->x = new->left;
192 if (old->top != new->top)
194 changes->y = new->top;
201 /***********************************************************************
204 static Window create_icon_window( Display *display, struct x11drv_win_data *data )
206 XSetWindowAttributes attr;
208 attr.event_mask = (ExposureMask | KeyPressMask | KeyReleaseMask | PointerMotionMask |
209 ButtonPressMask | ButtonReleaseMask | EnterWindowMask);
210 attr.bit_gravity = NorthWestGravity;
211 attr.backing_store = NotUseful/*WhenMapped*/;
212 attr.colormap = X11DRV_PALETTE_PaletteXColormap; /* Needed due to our visual */
215 data->icon_window = XCreateWindow( display, root_window, 0, 0,
216 GetSystemMetrics( SM_CXICON ),
217 GetSystemMetrics( SM_CYICON ),
220 CWEventMask | CWBitGravity | CWBackingStore | CWColormap, &attr );
221 XSaveContext( display, data->icon_window, winContext, (char *)data->hwnd );
224 TRACE( "created %lx\n", data->icon_window );
225 SetPropA( data->hwnd, icon_window_prop, (HANDLE)data->icon_window );
226 return data->icon_window;
231 /***********************************************************************
232 * destroy_icon_window
234 static void destroy_icon_window( Display *display, struct x11drv_win_data *data )
236 if (!data->icon_window) return;
237 if (x11drv_thread_data()->cursor_window == data->icon_window)
238 x11drv_thread_data()->cursor_window = None;
240 XDeleteContext( display, data->icon_window, winContext );
241 XDestroyWindow( display, data->icon_window );
242 data->icon_window = 0;
244 RemovePropA( data->hwnd, icon_window_prop );
248 /***********************************************************************
251 * Set the icon wm hints
253 static void set_icon_hints( Display *display, struct x11drv_win_data *data, HICON hIcon )
255 XWMHints *hints = data->wm_hints;
257 if (data->hWMIconBitmap) DeleteObject( data->hWMIconBitmap );
258 if (data->hWMIconMask) DeleteObject( data->hWMIconMask);
259 data->hWMIconBitmap = 0;
260 data->hWMIconMask = 0;
264 destroy_icon_window( display, data );
265 hints->flags &= ~(IconPixmapHint | IconMaskHint | IconWindowHint);
269 if (!data->icon_window) create_icon_window( display, data );
270 hints->icon_window = data->icon_window;
271 hints->flags = (hints->flags & ~(IconPixmapHint | IconMaskHint)) | IconWindowHint;
281 GetIconInfo(hIcon, &ii);
283 GetObjectA(ii.hbmMask, sizeof(bmMask), &bmMask);
286 rcMask.right = bmMask.bmWidth;
287 rcMask.bottom = bmMask.bmHeight;
289 hDC = CreateCompatibleDC(0);
290 hbmOrig = SelectObject(hDC, ii.hbmMask);
291 InvertRect(hDC, &rcMask);
292 SelectObject(hDC, ii.hbmColor); /* force the color bitmap to x11drv mode too */
293 SelectObject(hDC, hbmOrig);
296 data->hWMIconBitmap = ii.hbmColor;
297 data->hWMIconMask = ii.hbmMask;
299 hints->icon_pixmap = X11DRV_get_pixmap(data->hWMIconBitmap);
300 hints->icon_mask = X11DRV_get_pixmap(data->hWMIconMask);
301 destroy_icon_window( display, data );
302 hints->flags = (hints->flags & ~IconWindowHint) | IconPixmapHint | IconMaskHint;
306 /***********************************************************************
307 * systray_dock_window
309 * Docks the given X window with the NETWM system tray.
311 static void systray_dock_window( Display *display, struct x11drv_win_data *data )
313 static Atom systray_atom;
314 Window systray_window;
319 if (DefaultScreen( display ) == 0)
320 systray_atom = x11drv_atom(_NET_SYSTEM_TRAY_S0);
323 char systray_buffer[29]; /* strlen(_NET_SYSTEM_TRAY_S4294967295)+1 */
324 sprintf( systray_buffer, "_NET_SYSTEM_TRAY_S%u", DefaultScreen( display ) );
325 systray_atom = XInternAtom( display, systray_buffer, False );
328 systray_window = XGetSelectionOwner( display, systray_atom );
331 TRACE("Docking tray icon %p\n", data->hwnd);
333 if (systray_window != None)
336 unsigned long info[2];
338 /* Put the window offscreen so it isn't mapped. The window _cannot_ be
339 * mapped if we intend to dock with an XEMBED tray. If the window is
340 * mapped when we dock, it may become visible as a child of the root
341 * window after it docks, which isn't the proper behavior.
343 * For more information on this problem, see
344 * http://standards.freedesktop.org/xembed-spec/latest/ar01s04.html */
346 SetWindowPos( data->hwnd, NULL, virtual_screen_rect.right + 1, virtual_screen_rect.bottom + 1,
347 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE );
349 /* set XEMBED protocol data on the window */
350 info[0] = 0; /* protocol version */
351 info[1] = 1; /* mapped = true */
354 XChangeProperty( display, data->whole_window,
355 x11drv_atom(_XEMBED_INFO),
356 x11drv_atom(_XEMBED_INFO), 32, PropModeReplace,
357 (unsigned char*)info, 2 );
360 /* send the docking request message */
361 ZeroMemory( &ev, sizeof(ev) );
362 ev.xclient.type = ClientMessage;
363 ev.xclient.window = systray_window;
364 ev.xclient.message_type = x11drv_atom( _NET_SYSTEM_TRAY_OPCODE );
365 ev.xclient.format = 32;
366 ev.xclient.data.l[0] = CurrentTime;
367 ev.xclient.data.l[1] = SYSTEM_TRAY_REQUEST_DOCK;
368 ev.xclient.data.l[2] = data->whole_window;
369 ev.xclient.data.l[3] = 0;
370 ev.xclient.data.l[4] = 0;
373 XSendEvent( display, systray_window, False, NoEventMask, &ev );
381 /* fall back to he KDE hints if the WM doesn't support XEMBED'ed
385 XChangeProperty( display, data->whole_window,
386 x11drv_atom(KWM_DOCKWINDOW),
387 x11drv_atom(KWM_DOCKWINDOW), 32, PropModeReplace,
388 (unsigned char*)&val, 1 );
389 XChangeProperty( display, data->whole_window,
390 x11drv_atom(_KDE_NET_WM_SYSTEM_TRAY_WINDOW_FOR),
391 XA_WINDOW, 32, PropModeReplace,
392 (unsigned char*)&data->whole_window, 1 );
398 /***********************************************************************
401 * set the window size hints
403 static void set_size_hints( Display *display, struct x11drv_win_data *data, DWORD style )
405 XSizeHints* size_hints;
407 if ((size_hints = XAllocSizeHints()))
409 size_hints->flags = 0;
411 if (data->hwnd != GetDesktopWindow()) /* don't force position of desktop */
413 size_hints->win_gravity = StaticGravity;
414 size_hints->x = data->whole_rect.left;
415 size_hints->y = data->whole_rect.top;
416 size_hints->flags |= PWinGravity | PPosition;
419 if ( !(style & WS_THICKFRAME) )
421 size_hints->max_width = data->whole_rect.right - data->whole_rect.left;
422 size_hints->max_height = data->whole_rect.bottom - data->whole_rect.top;
423 size_hints->min_width = size_hints->max_width;
424 size_hints->min_height = size_hints->max_height;
425 size_hints->flags |= PMinSize | PMaxSize;
427 XSetWMNormalHints( display, data->whole_window, size_hints );
433 /***********************************************************************
436 * get the name of the current process for setting class hints
438 static char *get_process_name(void)
444 WCHAR module[MAX_PATH];
445 DWORD len = GetModuleFileNameW( 0, module, MAX_PATH );
446 if (len && len < MAX_PATH)
449 WCHAR *p, *appname = module;
451 if ((p = strrchrW( appname, '/' ))) appname = p + 1;
452 if ((p = strrchrW( appname, '\\' ))) appname = p + 1;
453 len = WideCharToMultiByte( CP_UNIXCP, 0, appname, -1, NULL, 0, NULL, NULL );
454 if ((ptr = HeapAlloc( GetProcessHeap(), 0, len )))
456 WideCharToMultiByte( CP_UNIXCP, 0, appname, -1, ptr, len, NULL, NULL );
465 /***********************************************************************
466 * set_initial_wm_hints
468 * Set the window manager hints that don't change over the lifetime of a window.
470 static void set_initial_wm_hints( Display *display, struct x11drv_win_data *data )
475 XClassHint *class_hints;
476 char *process_name = get_process_name();
482 protocols[i++] = x11drv_atom(WM_DELETE_WINDOW);
483 protocols[i++] = x11drv_atom(_NET_WM_PING);
484 if (use_take_focus) protocols[i++] = x11drv_atom(WM_TAKE_FOCUS);
485 XChangeProperty( display, data->whole_window, x11drv_atom(WM_PROTOCOLS),
486 XA_ATOM, 32, PropModeReplace, (unsigned char *)protocols, i );
489 if ((class_hints = XAllocClassHint()))
491 static char wine[] = "Wine";
493 class_hints->res_name = process_name;
494 class_hints->res_class = wine;
495 XSetClassHint( display, data->whole_window, class_hints );
496 XFree( class_hints );
499 /* set the WM_CLIENT_MACHINE and WM_LOCALE_NAME properties */
500 XSetWMProperties(display, data->whole_window, NULL, NULL, NULL, 0, NULL, NULL, NULL);
501 /* set the pid. together, these properties are needed so the window manager can kill us if we freeze */
503 XChangeProperty(display, data->whole_window, x11drv_atom(_NET_WM_PID),
504 XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&i, 1);
506 XChangeProperty( display, data->whole_window, x11drv_atom(XdndAware),
507 XA_ATOM, 32, PropModeReplace, (unsigned char*)&dndVersion, 1 );
513 /***********************************************************************
514 * X11DRV_set_wm_hints
516 * Set the window manager hints for a newly-created window
518 void X11DRV_set_wm_hints( Display *display, struct x11drv_win_data *data )
523 DWORD style = GetWindowLongW( data->hwnd, GWL_STYLE );
524 DWORD ex_style = GetWindowLongW( data->hwnd, GWL_EXSTYLE );
525 HWND owner = GetWindow( data->hwnd, GW_OWNER );
527 if (data->hwnd == GetDesktopWindow())
529 if (data->whole_window == DefaultRootWindow(display)) return;
530 /* force some styles for the desktop to get the correct decorations */
531 style |= WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
535 /* transient for hint */
538 Window owner_win = X11DRV_get_whole_window( owner );
540 XSetTransientForHint( display, data->whole_window, owner_win );
542 group_leader = owner_win;
544 else group_leader = data->whole_window;
549 set_size_hints( display, data, style );
551 /* set the WM_WINDOW_TYPE */
552 window_type = x11drv_atom(_NET_WM_WINDOW_TYPE_NORMAL);
553 if (ex_style & WS_EX_TOOLWINDOW) window_type = x11drv_atom(_NET_WM_WINDOW_TYPE_UTILITY);
554 else if (style & WS_THICKFRAME) window_type = x11drv_atom(_NET_WM_WINDOW_TYPE_NORMAL);
555 else if (style & WS_DLGFRAME) window_type = x11drv_atom(_NET_WM_WINDOW_TYPE_DIALOG);
556 else if (ex_style & WS_EX_DLGMODALFRAME) window_type = x11drv_atom(_NET_WM_WINDOW_TYPE_DIALOG);
558 XChangeProperty(display, data->whole_window, x11drv_atom(_NET_WM_WINDOW_TYPE),
559 XA_ATOM, 32, PropModeReplace, (unsigned char*)&window_type, 1);
561 mwm_hints.flags = MWM_HINTS_FUNCTIONS | MWM_HINTS_DECORATIONS;
562 mwm_hints.functions = MWM_FUNC_MOVE;
563 if (style & WS_THICKFRAME) mwm_hints.functions |= MWM_FUNC_RESIZE;
564 if (style & WS_MINIMIZEBOX) mwm_hints.functions |= MWM_FUNC_MINIMIZE;
565 if (style & WS_MAXIMIZEBOX) mwm_hints.functions |= MWM_FUNC_MAXIMIZE;
566 if (style & WS_SYSMENU) mwm_hints.functions |= MWM_FUNC_CLOSE;
567 mwm_hints.decorations = 0;
568 if ((style & WS_CAPTION) == WS_CAPTION)
570 mwm_hints.decorations |= MWM_DECOR_TITLE;
571 if (style & WS_SYSMENU) mwm_hints.decorations |= MWM_DECOR_MENU;
572 if (style & WS_MINIMIZEBOX) mwm_hints.decorations |= MWM_DECOR_MINIMIZE;
573 if (style & WS_MAXIMIZEBOX) mwm_hints.decorations |= MWM_DECOR_MAXIMIZE;
575 if (ex_style & WS_EX_DLGMODALFRAME) mwm_hints.decorations |= MWM_DECOR_BORDER;
576 else if (style & WS_THICKFRAME) mwm_hints.decorations |= MWM_DECOR_BORDER | MWM_DECOR_RESIZEH;
577 else if ((style & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME) mwm_hints.decorations |= MWM_DECOR_BORDER;
578 else if (style & WS_BORDER) mwm_hints.decorations |= MWM_DECOR_BORDER;
579 else if (!(style & (WS_CHILD|WS_POPUP))) mwm_hints.decorations |= MWM_DECOR_BORDER;
581 XChangeProperty( display, data->whole_window, x11drv_atom(_MOTIF_WM_HINTS),
582 x11drv_atom(_MOTIF_WM_HINTS), 32, PropModeReplace,
583 (unsigned char*)&mwm_hints, sizeof(mwm_hints)/sizeof(long) );
590 data->wm_hints->flags = InputHint | StateHint | WindowGroupHint;
591 data->wm_hints->input = !(style & WS_DISABLED);
592 data->wm_hints->initial_state = (style & WS_MINIMIZE) ? IconicState : NormalState;
593 data->wm_hints->window_group = group_leader;
594 set_icon_hints( display, data, (HICON)GetClassLongPtrW( data->hwnd, GCLP_HICON ) );
597 XSetWMHints( display, data->whole_window, data->wm_hints );
603 /***********************************************************************
604 * X11DRV_set_iconic_state
606 * Set the X11 iconic state according to the window style.
608 void X11DRV_set_iconic_state( HWND hwnd )
610 Display *display = thread_display();
611 struct x11drv_win_data *data;
613 DWORD style = GetWindowLongW( hwnd, GWL_STYLE );
614 BOOL iconic = (style & WS_MINIMIZE) != 0;
616 if (!(data = X11DRV_get_win_data( hwnd ))) return;
617 if (!data->whole_window || data->whole_window == DefaultRootWindow(display)) return;
619 GetWindowRect( hwnd, &rect );
625 data->wm_hints->flags |= StateHint | IconPositionHint;
626 data->wm_hints->initial_state = iconic ? IconicState : NormalState;
627 data->wm_hints->icon_x = rect.left - virtual_screen_rect.left;
628 data->wm_hints->icon_y = rect.top - virtual_screen_rect.top;
629 XSetWMHints( display, data->whole_window, data->wm_hints );
632 if (style & WS_VISIBLE)
635 XIconifyWindow( display, data->whole_window, DefaultScreen(display) );
637 if (X11DRV_is_window_rect_mapped( &rect ))
638 XMapWindow( display, data->whole_window );
645 /***********************************************************************
646 * X11DRV_window_to_X_rect
648 * Convert a rect from client to X window coordinates
650 void X11DRV_window_to_X_rect( struct x11drv_win_data *data, RECT *rect )
654 if (!data->managed) return;
655 if (IsRectEmpty( rect )) return;
657 rc.top = rc.bottom = rc.left = rc.right = 0;
659 AdjustWindowRectEx( &rc, GetWindowLongW( data->hwnd, GWL_STYLE ) & ~(WS_HSCROLL|WS_VSCROLL),
660 FALSE, GetWindowLongW( data->hwnd, GWL_EXSTYLE ) );
662 rect->left -= rc.left;
663 rect->right -= rc.right;
665 rect->bottom -= rc.bottom;
666 if (rect->top >= rect->bottom) rect->bottom = rect->top + 1;
667 if (rect->left >= rect->right) rect->right = rect->left + 1;
671 /***********************************************************************
672 * X11DRV_X_to_window_rect
674 * Opposite of X11DRV_window_to_X_rect
676 void X11DRV_X_to_window_rect( struct x11drv_win_data *data, RECT *rect )
678 if (!data->managed) return;
679 if (IsRectEmpty( rect )) return;
681 AdjustWindowRectEx( rect, GetWindowLongW( data->hwnd, GWL_STYLE ) & ~(WS_HSCROLL|WS_VSCROLL),
682 FALSE, GetWindowLongW( data->hwnd, GWL_EXSTYLE ));
684 if (rect->top >= rect->bottom) rect->bottom = rect->top + 1;
685 if (rect->left >= rect->right) rect->right = rect->left + 1;
689 /***********************************************************************
690 * X11DRV_sync_window_position
692 * Synchronize the X window position with the Windows one
694 void X11DRV_sync_window_position( Display *display, struct x11drv_win_data *data,
695 UINT swp_flags, const RECT *new_client_rect,
696 const RECT *new_whole_rect )
698 XWindowChanges changes;
702 old_whole_rect = data->whole_rect;
703 data->whole_rect = *new_whole_rect;
705 data->client_rect = *new_client_rect;
706 OffsetRect( &data->client_rect, -data->whole_rect.left, -data->whole_rect.top );
708 if (!data->whole_window || data->lock_changes) return;
710 mask = get_window_changes( &changes, &old_whole_rect, &data->whole_rect );
712 if (!(swp_flags & SWP_NOZORDER))
714 /* find window that this one must be after */
715 HWND prev = GetWindow( data->hwnd, GW_HWNDPREV );
716 while (prev && !(GetWindowLongW( prev, GWL_STYLE ) & WS_VISIBLE))
717 prev = GetWindow( prev, GW_HWNDPREV );
718 if (!prev) /* top child */
720 changes.stack_mode = Above;
725 /* should use stack_mode Below but most window managers don't get it right */
726 /* so move it above the next one in Z order */
727 HWND next = GetWindow( data->hwnd, GW_HWNDNEXT );
728 while (next && !(GetWindowLongW( next, GWL_STYLE ) & WS_VISIBLE))
729 next = GetWindow( next, GW_HWNDNEXT );
732 changes.stack_mode = Above;
733 changes.sibling = X11DRV_get_whole_window(next);
734 mask |= CWStackMode | CWSibling;
741 DWORD style = GetWindowLongW( data->hwnd, GWL_STYLE );
743 TRACE( "setting win %lx pos %d,%d,%dx%d after %lx changes=%x\n",
744 data->whole_window, data->whole_rect.left, data->whole_rect.top,
745 data->whole_rect.right - data->whole_rect.left,
746 data->whole_rect.bottom - data->whole_rect.top, changes.sibling, mask );
749 if (mask & (CWWidth|CWHeight)) set_size_hints( display, data, style );
750 if (mask & CWX) changes.x -= virtual_screen_rect.left;
751 if (mask & CWY) changes.y -= virtual_screen_rect.top;
752 XReconfigureWMWindow( display, data->whole_window,
753 DefaultScreen(display), mask, &changes );
759 /**********************************************************************
760 * create_whole_window
762 * Create the whole X window for a given window
764 static Window create_whole_window( Display *display, struct x11drv_win_data *data, DWORD style )
767 XSetWindowAttributes attr;
770 if (!(cx = data->window_rect.right - data->window_rect.left)) cx = 1;
771 if (!(cy = data->window_rect.bottom - data->window_rect.top)) cy = 1;
773 mask = get_window_attributes( display, data, &attr );
777 data->whole_rect = data->window_rect;
778 data->whole_window = XCreateWindow( display, root_window,
779 data->window_rect.left - virtual_screen_rect.left,
780 data->window_rect.top - virtual_screen_rect.top,
781 cx, cy, 0, screen_depth, InputOutput,
782 visual, mask, &attr );
784 if (!data->whole_window)
789 XSaveContext( display, data->whole_window, winContext, (char *)data->hwnd );
791 /* non-maximized child must be at bottom of Z order */
792 if ((style & (WS_CHILD|WS_MAXIMIZE)) == WS_CHILD)
794 XWindowChanges changes;
795 changes.stack_mode = Below;
796 XConfigureWindow( display, data->whole_window, CWStackMode, &changes );
800 xim = x11drv_thread_data()->xim;
801 if (xim) data->xic = X11DRV_CreateIC( xim, display, data->whole_window );
803 set_initial_wm_hints( display, data );
804 X11DRV_set_wm_hints( display, data );
806 SetPropA( data->hwnd, whole_window_prop, (HANDLE)data->whole_window );
807 return data->whole_window;
811 /**********************************************************************
812 * destroy_whole_window
814 * Destroy the whole X window for a given window.
816 static void destroy_whole_window( Display *display, struct x11drv_win_data *data )
818 struct x11drv_thread_data *thread_data = x11drv_thread_data();
820 if (!data->whole_window) return;
822 TRACE( "win %p xwin %lx\n", data->hwnd, data->whole_window );
823 if (thread_data->cursor_window == data->whole_window) thread_data->cursor_window = None;
825 XDeleteContext( display, data->whole_window, winContext );
826 if (data->whole_window != DefaultRootWindow(display))
827 XDestroyWindow( display, data->whole_window );
828 data->whole_window = 0;
831 XUnsetICFocus( data->xic );
832 XDestroyIC( data->xic );
834 /* Outlook stops processing messages after destroying a dialog, so we need an explicit flush */
837 RemovePropA( data->hwnd, whole_window_prop );
841 /*****************************************************************
842 * SetWindowText (X11DRV.@)
844 void X11DRV_SetWindowText( HWND hwnd, LPCWSTR text )
846 Display *display = thread_display();
853 if ((win = X11DRV_get_whole_window( hwnd )) && win != DefaultRootWindow(display))
855 /* allocate new buffer for window text */
856 count = WideCharToMultiByte(CP_UNIXCP, 0, text, -1, NULL, 0, NULL, NULL);
857 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, count )))
859 ERR("Not enough memory for window text\n");
862 WideCharToMultiByte(CP_UNIXCP, 0, text, -1, buffer, count, NULL, NULL);
864 count = WideCharToMultiByte(CP_UTF8, 0, text, strlenW(text), NULL, 0, NULL, NULL);
865 if (!(utf8_buffer = HeapAlloc( GetProcessHeap(), 0, count )))
867 ERR("Not enough memory for window text in UTF-8\n");
868 HeapFree( GetProcessHeap(), 0, buffer );
871 WideCharToMultiByte(CP_UTF8, 0, text, strlenW(text), utf8_buffer, count, NULL, NULL);
874 if (XmbTextListToTextProperty( display, &buffer, 1, XStdICCTextStyle, &prop ) == Success)
876 XSetWMName( display, win, &prop );
877 XSetWMIconName( display, win, &prop );
881 Implements a NET_WM UTF-8 title. It should be without a trailing \0,
882 according to the standard
883 ( http://www.pps.jussieu.fr/~jch/software/UTF8_STRING/UTF8_STRING.text ).
885 XChangeProperty( display, win, x11drv_atom(_NET_WM_NAME), x11drv_atom(UTF8_STRING),
886 8, PropModeReplace, (unsigned char *) utf8_buffer, count);
889 HeapFree( GetProcessHeap(), 0, utf8_buffer );
890 HeapFree( GetProcessHeap(), 0, buffer );
895 /***********************************************************************
896 * DestroyWindow (X11DRV.@)
898 void X11DRV_DestroyWindow( HWND hwnd )
900 struct x11drv_thread_data *thread_data = x11drv_thread_data();
901 Display *display = thread_data->display;
902 struct x11drv_win_data *data;
904 if (!(data = X11DRV_get_win_data( hwnd ))) return;
906 free_window_dce( data );
907 destroy_whole_window( display, data );
908 destroy_icon_window( display, data );
910 if (thread_data->last_focus == hwnd) thread_data->last_focus = 0;
911 if (data->hWMIconBitmap) DeleteObject( data->hWMIconBitmap );
912 if (data->hWMIconMask) DeleteObject( data->hWMIconMask);
914 XDeleteContext( display, (XID)hwnd, win_data_context );
915 XFree( data->wm_hints );
917 HeapFree( GetProcessHeap(), 0, data );
921 static struct x11drv_win_data *alloc_win_data( Display *display, HWND hwnd )
923 struct x11drv_win_data *data;
925 if ((data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data))))
928 data->whole_window = 0;
929 data->icon_window = 0;
931 data->managed = FALSE;
933 data->lock_changes = 0;
934 data->hWMIconBitmap = 0;
935 data->hWMIconMask = 0;
938 if (!winContext) winContext = XUniqueContext();
939 if (!win_data_context) win_data_context = XUniqueContext();
940 XSaveContext( display, (XID)hwnd, win_data_context, (char *)data );
941 data->wm_hints = XAllocWMHints();
948 /* fill in the desktop X window id in the x11drv_win_data structure */
949 static void get_desktop_xwin( Display *display, struct x11drv_win_data *data )
951 Window win = (Window)GetPropA( data->hwnd, whole_window_prop );
955 unsigned int width, height;
957 /* retrieve the real size of the desktop */
958 SERVER_START_REQ( get_window_rectangles )
960 req->handle = data->hwnd;
961 wine_server_call( req );
962 width = reply->window.right - reply->window.left;
963 height = reply->window.bottom - reply->window.top;
966 data->whole_window = win;
967 if (win != root_window) X11DRV_init_desktop( win, width, height );
974 visualid = XVisualIDFromVisual(visual);
976 SetPropA( data->hwnd, whole_window_prop, (HANDLE)root_window );
977 SetPropA( data->hwnd, visual_id_prop, (HANDLE)visualid );
978 data->whole_window = root_window;
979 X11DRV_SetWindowPos( data->hwnd, 0, &virtual_screen_rect, &virtual_screen_rect,
980 SWP_NOZORDER | SWP_NOACTIVATE, NULL );
981 if (root_window != DefaultRootWindow( display ))
983 data->managed = TRUE;
984 SetPropA( data->hwnd, managed_prop, (HANDLE)1 );
989 /**********************************************************************
990 * CreateDesktopWindow (X11DRV.@)
992 BOOL X11DRV_CreateDesktopWindow( HWND hwnd )
994 Display *display = thread_display();
995 struct x11drv_win_data *data;
997 if (!(data = alloc_win_data( display, hwnd ))) return FALSE;
999 get_desktop_xwin( display, data );
1005 /**********************************************************************
1006 * CreateWindow (X11DRV.@)
1008 BOOL X11DRV_CreateWindow( HWND hwnd, CREATESTRUCTA *cs, BOOL unicode )
1010 Display *display = thread_display();
1012 struct x11drv_win_data *data;
1016 CBT_CREATEWNDA cbtc;
1020 if (!(data = alloc_win_data( display, hwnd ))) return FALSE;
1024 ERR( "invalid window width %d\n", cs->cx );
1029 ERR( "invalid window height %d\n", cs->cy );
1034 ERR( "invalid window width %d\n", cs->cx );
1039 ERR( "invalid window height %d\n", cs->cy );
1043 /* initialize the dimensions before sending WM_GETMINMAXINFO */
1044 SetRect( &rect, cs->x, cs->y, cs->x + cs->cx, cs->y + cs->cy );
1045 X11DRV_SetWindowPos( hwnd, 0, &rect, &rect, SWP_NOZORDER | SWP_NOACTIVATE, NULL );
1047 /* create an X window if it's a top level window */
1048 if (GetAncestor( hwnd, GA_PARENT ) == GetDesktopWindow())
1050 if (!create_whole_window( display, data, cs->style )) goto failed;
1052 else if (hwnd == GetDesktopWindow())
1054 get_desktop_xwin( display, data );
1057 /* get class or window DC if needed */
1058 alloc_window_dce( data );
1060 /* Call the WH_CBT hook */
1062 /* the window style passed to the hook must be the real window style,
1063 * rather than just the window style that the caller to CreateWindowEx
1064 * passed in, so we have to copy the original CREATESTRUCT and get the
1065 * the real style. */
1067 cbcs.style = GetWindowLongW(hwnd, GWL_STYLE);
1070 cbtc.hwndInsertAfter = HWND_TOP;
1071 if (HOOK_CallHooks( WH_CBT, HCBT_CREATEWND, (WPARAM)hwnd, (LPARAM)&cbtc, unicode ))
1073 TRACE("CBT-hook returned !0\n");
1077 /* Send the WM_GETMINMAXINFO message and fix the size if needed */
1078 if ((cs->style & WS_THICKFRAME) || !(cs->style & (WS_POPUP | WS_CHILD)))
1080 POINT maxSize, maxPos, minTrack, maxTrack;
1082 WINPOS_GetMinMaxInfo( hwnd, &maxSize, &maxPos, &minTrack, &maxTrack);
1083 if (maxTrack.x < cs->cx) cs->cx = maxTrack.x;
1084 if (maxTrack.y < cs->cy) cs->cy = maxTrack.y;
1085 if (cs->cx < 0) cs->cx = 0;
1086 if (cs->cy < 0) cs->cy = 0;
1088 SetRect( &rect, cs->x, cs->y, cs->x + cs->cx, cs->y + cs->cy );
1089 if (!X11DRV_SetWindowPos( hwnd, 0, &rect, &rect, SWP_NOZORDER | SWP_NOACTIVATE, NULL ))
1093 /* send WM_NCCREATE */
1094 TRACE( "hwnd %p cs %d,%d %dx%d\n", hwnd, cs->x, cs->y, cs->cx, cs->cy );
1096 ret = SendMessageW( hwnd, WM_NCCREATE, 0, (LPARAM)cs );
1098 ret = SendMessageA( hwnd, WM_NCCREATE, 0, (LPARAM)cs );
1101 WARN("aborted by WM_xxCREATE!\n");
1105 /* make sure the window is still valid */
1106 if (!(data = X11DRV_get_win_data( hwnd ))) return FALSE;
1107 if (data->whole_window) X11DRV_sync_window_style( display, data );
1109 /* send WM_NCCALCSIZE */
1110 rect = data->window_rect;
1111 SendMessageW( hwnd, WM_NCCALCSIZE, FALSE, (LPARAM)&rect );
1113 if (!(wndPtr = WIN_GetPtr(hwnd))) return FALSE;
1115 /* yes, even if the CBT hook was called with HWND_TOP */
1116 insert_after = (wndPtr->dwStyle & WS_CHILD) ? HWND_BOTTOM : HWND_TOP;
1118 X11DRV_SetWindowPos( hwnd, insert_after, &wndPtr->rectWindow, &rect, SWP_NOACTIVATE, NULL );
1120 TRACE( "win %p window %d,%d,%d,%d client %d,%d,%d,%d whole %d,%d,%d,%d X client %d,%d,%d,%d xwin %x\n",
1121 hwnd, wndPtr->rectWindow.left, wndPtr->rectWindow.top,
1122 wndPtr->rectWindow.right, wndPtr->rectWindow.bottom,
1123 wndPtr->rectClient.left, wndPtr->rectClient.top,
1124 wndPtr->rectClient.right, wndPtr->rectClient.bottom,
1125 data->whole_rect.left, data->whole_rect.top,
1126 data->whole_rect.right, data->whole_rect.bottom,
1127 data->client_rect.left, data->client_rect.top,
1128 data->client_rect.right, data->client_rect.bottom,
1129 (unsigned int)data->whole_window );
1131 WIN_ReleasePtr( wndPtr );
1134 ret = (SendMessageW( hwnd, WM_CREATE, 0, (LPARAM)cs ) != -1);
1136 ret = (SendMessageA( hwnd, WM_CREATE, 0, (LPARAM)cs ) != -1);
1138 if (!ret) return FALSE;
1140 NotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_WINDOW, 0);
1142 /* Send the size messages */
1144 if (!(wndPtr = WIN_GetPtr(hwnd)) || wndPtr == WND_OTHER_PROCESS) return FALSE;
1145 if (!(wndPtr->flags & WIN_NEED_SIZE))
1147 RECT rect = wndPtr->rectClient;
1148 WIN_ReleasePtr( wndPtr );
1149 /* send it anyway */
1150 if (((rect.right-rect.left) <0) ||((rect.bottom-rect.top)<0))
1151 WARN("sending bogus WM_SIZE message 0x%08x\n",
1152 MAKELONG(rect.right-rect.left, rect.bottom-rect.top));
1153 SendMessageW( hwnd, WM_SIZE, SIZE_RESTORED,
1154 MAKELONG(rect.right-rect.left, rect.bottom-rect.top));
1155 SendMessageW( hwnd, WM_MOVE, 0, MAKELONG( rect.left, rect.top ) );
1157 else WIN_ReleasePtr( wndPtr );
1159 /* Show the window, maximizing or minimizing if needed */
1161 style = GetWindowLongW( hwnd, GWL_STYLE );
1162 if (style & (WS_MINIMIZE | WS_MAXIMIZE))
1164 extern UINT WINPOS_MinMaximize( HWND hwnd, UINT cmd, LPRECT rect ); /*FIXME*/
1167 UINT swFlag = (style & WS_MINIMIZE) ? SW_MINIMIZE : SW_MAXIMIZE;
1168 WIN_SetStyle( hwnd, 0, WS_MAXIMIZE | WS_MINIMIZE );
1169 swFlag = WINPOS_MinMaximize( hwnd, swFlag, &newPos );
1171 swFlag |= SWP_FRAMECHANGED; /* Frame always gets changed */
1172 if (!(style & WS_VISIBLE) || (style & WS_CHILD) || GetActiveWindow()) swFlag |= SWP_NOACTIVATE;
1174 SetWindowPos( hwnd, 0, newPos.left, newPos.top,
1175 newPos.right, newPos.bottom, swFlag );
1178 /* Dock system tray windows. */
1179 /* Dock after the window is created so we don't have problems calling
1181 if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_TRAYWINDOW)
1182 systray_dock_window( display, data );
1187 X11DRV_DestroyWindow( hwnd );
1192 /***********************************************************************
1193 * X11DRV_get_win_data
1195 * Return the X11 data structure associated with a window.
1197 struct x11drv_win_data *X11DRV_get_win_data( HWND hwnd )
1201 if (!hwnd || XFindContext( thread_display(), (XID)hwnd, win_data_context, &data )) data = NULL;
1202 return (struct x11drv_win_data *)data;
1206 /***********************************************************************
1207 * X11DRV_get_whole_window
1209 * Return the X window associated with the full area of a window
1211 Window X11DRV_get_whole_window( HWND hwnd )
1213 struct x11drv_win_data *data = X11DRV_get_win_data( hwnd );
1215 if (!data) return (Window)GetPropA( hwnd, whole_window_prop );
1216 return data->whole_window;
1220 /***********************************************************************
1223 * Return the X input context associated with a window
1225 XIC X11DRV_get_ic( HWND hwnd )
1227 struct x11drv_win_data *data = X11DRV_get_win_data( hwnd );
1229 if (!data) return 0;
1234 /*****************************************************************
1235 * SetParent (X11DRV.@)
1237 void X11DRV_SetParent( HWND hwnd, HWND parent, HWND old_parent )
1239 Display *display = thread_display();
1240 struct x11drv_win_data *data = X11DRV_get_win_data( hwnd );
1243 if (parent == old_parent) return;
1245 if (parent != GetDesktopWindow()) /* a child window */
1247 if (old_parent == GetDesktopWindow())
1249 /* destroy the old X windows */
1250 destroy_whole_window( display, data );
1251 destroy_icon_window( display, data );
1254 data->managed = FALSE;
1255 RemovePropA( data->hwnd, managed_prop );
1259 else /* new top level window */
1261 /* FIXME: we ignore errors since we can't really recover anyway */
1262 create_whole_window( display, data, GetWindowLongW( hwnd, GWL_STYLE ) );
1267 /*****************************************************************
1268 * SetFocus (X11DRV.@)
1271 * Explicit colormap management seems to work only with OLVWM.
1273 void X11DRV_SetFocus( HWND hwnd )
1275 Display *display = thread_display();
1276 struct x11drv_win_data *data;
1277 XWindowAttributes win_attr;
1279 /* Only mess with the X focus if there's */
1280 /* no desktop window and if the window is not managed by the WM. */
1281 if (root_window != DefaultRootWindow(display)) return;
1283 if (!hwnd) /* If setting the focus to 0, uninstall the colormap */
1286 if (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_PRIVATE)
1287 XUninstallColormap( display, X11DRV_PALETTE_PaletteXColormap );
1288 wine_tsx11_unlock();
1292 hwnd = GetAncestor( hwnd, GA_ROOT );
1294 if (!(data = X11DRV_get_win_data( hwnd ))) return;
1295 if (data->managed || !data->whole_window) return;
1297 /* Set X focus and install colormap */
1299 if (XGetWindowAttributes( display, data->whole_window, &win_attr ) &&
1300 (win_attr.map_state == IsViewable))
1302 /* If window is not viewable, don't change anything */
1304 /* we must not use CurrentTime (ICCCM), so try to use last message time instead */
1305 /* FIXME: this is not entirely correct */
1306 XSetInputFocus( display, data->whole_window, RevertToParent,
1308 GetMessageTime() - EVENT_x11_time_to_win32_time(0));
1309 if (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_PRIVATE)
1310 XInstallColormap( display, X11DRV_PALETTE_PaletteXColormap );
1312 wine_tsx11_unlock();
1316 /**********************************************************************
1317 * SetWindowIcon (X11DRV.@)
1319 * hIcon or hIconSm has changed (or is being initialised for the
1320 * first time). Complete the X11 driver-specific initialisation
1321 * and set the window hints.
1323 * This is not entirely correct, may need to create
1324 * an icon window and set the pixmap as a background
1326 void X11DRV_SetWindowIcon( HWND hwnd, UINT type, HICON icon )
1328 Display *display = thread_display();
1329 struct x11drv_win_data *data;
1331 if (type != ICON_BIG) return; /* nothing to do here */
1333 if (!(data = X11DRV_get_win_data( hwnd ))) return;
1334 if (!data->whole_window) return;
1335 if (!data->managed) return;
1339 set_icon_hints( display, data, icon );
1341 XSetWMHints( display, data->whole_window, data->wm_hints );
1342 wine_tsx11_unlock();