| /* |
| * Window related functions |
| * |
| * Copyright 1993, 1994, 1995, 1996, 2001 Alexandre Julliard |
| * Copyright 1993 David Metcalfe |
| * Copyright 1995, 1996 Alex Korobka |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| |
| #include "config.h" |
| |
| #include <stdlib.h> |
| #include <unistd.h> |
| |
| #include "ts_xlib.h" |
| #include <X11/Xresource.h> |
| #include <X11/Xutil.h> |
| |
| #include "winbase.h" |
| #include "wingdi.h" |
| #include "winreg.h" |
| #include "winuser.h" |
| #include "wine/unicode.h" |
| |
| #include "wine/debug.h" |
| #include "x11drv.h" |
| #include "win.h" |
| #include "winpos.h" |
| #include "mwm.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(x11drv); |
| |
| extern Pixmap X11DRV_BITMAP_Pixmap( HBITMAP ); |
| |
| #define HAS_DLGFRAME(style,exStyle) \ |
| (((exStyle) & WS_EX_DLGMODALFRAME) || \ |
| (((style) & WS_DLGFRAME) && !((style) & WS_THICKFRAME))) |
| |
| /* X context to associate a hwnd to an X window */ |
| XContext winContext = 0; |
| |
| Atom wmProtocols = None; |
| Atom wmDeleteWindow = None; |
| Atom wmTakeFocus = None; |
| Atom dndProtocol = None; |
| Atom dndSelection = None; |
| Atom wmChangeState = None; |
| Atom mwmHints = None; |
| Atom kwmDockWindow = None; |
| Atom netwmPid = None; |
| Atom netwmPing = None; |
| Atom _kde_net_wm_system_tray_window_for = None; /* KDE 2 Final */ |
| |
| static LPCSTR whole_window_atom; |
| static LPCSTR client_window_atom; |
| static LPCSTR icon_window_atom; |
| |
| /*********************************************************************** |
| * is_window_managed |
| * |
| * Check if a given window should be managed |
| */ |
| inline static BOOL is_window_managed( WND *win ) |
| { |
| if (!managed_mode) return FALSE; |
| /* tray window is always managed */ |
| if (win->dwExStyle & WS_EX_TRAYWINDOW) return TRUE; |
| /* child windows are not managed */ |
| if (win->dwStyle & WS_CHILD) return FALSE; |
| /* tool windows are not managed */ |
| if (win->dwExStyle & WS_EX_TOOLWINDOW) return FALSE; |
| /* windows with caption or thick frame are managed */ |
| if ((win->dwStyle & WS_CAPTION) == WS_CAPTION) return TRUE; |
| if (win->dwStyle & WS_THICKFRAME) return TRUE; |
| /* default: not managed */ |
| return FALSE; |
| } |
| |
| |
| /*********************************************************************** |
| * is_client_window_mapped |
| * |
| * Check if the X client window should be mapped |
| */ |
| inline static BOOL is_client_window_mapped( WND *win ) |
| { |
| struct x11drv_win_data *data = win->pDriverData; |
| return !(win->dwStyle & WS_MINIMIZE) && !IsRectEmpty( &data->client_rect ); |
| } |
| |
| |
| /*********************************************************************** |
| * get_window_attributes |
| * |
| * Fill the window attributes structure for an X window. |
| */ |
| static int get_window_attributes( Display *display, WND *win, XSetWindowAttributes *attr ) |
| { |
| BOOL is_top_level = is_window_top_level( win ); |
| BOOL managed = is_top_level && is_window_managed( win ); |
| |
| if (managed) WIN_SetExStyle( win->hwndSelf, win->dwExStyle | WS_EX_MANAGED ); |
| else WIN_SetExStyle( win->hwndSelf, win->dwExStyle & ~WS_EX_MANAGED ); |
| |
| attr->override_redirect = !managed; |
| attr->colormap = X11DRV_PALETTE_PaletteXColormap; |
| attr->save_under = ((win->clsStyle & CS_SAVEBITS) != 0); |
| attr->cursor = x11drv_thread_data()->cursor; |
| attr->event_mask = (ExposureMask | PointerMotionMask | |
| ButtonPressMask | ButtonReleaseMask | EnterWindowMask); |
| |
| if (is_window_top_level( win )) |
| attr->event_mask |= (KeyPressMask | KeyReleaseMask | StructureNotifyMask | |
| FocusChangeMask | KeymapStateMask); |
| |
| return (CWOverrideRedirect | CWSaveUnder | CWEventMask | CWColormap | CWCursor); |
| } |
| |
| |
| /*********************************************************************** |
| * X11DRV_sync_window_style |
| * |
| * Change the X window attributes when the window style has changed. |
| */ |
| void X11DRV_sync_window_style( Display *display, WND *win ) |
| { |
| XSetWindowAttributes attr; |
| int mask; |
| |
| wine_tsx11_lock(); |
| mask = get_window_attributes( display, win, &attr ); |
| XChangeWindowAttributes( display, get_whole_window(win), mask, &attr ); |
| wine_tsx11_unlock(); |
| } |
| |
| |
| /*********************************************************************** |
| * get_window_changes |
| * |
| * fill the window changes structure |
| */ |
| static int get_window_changes( XWindowChanges *changes, const RECT *old, const RECT *new ) |
| { |
| int mask = 0; |
| |
| if (old->right - old->left != new->right - new->left ) |
| { |
| if (!(changes->width = new->right - new->left)) changes->width = 1; |
| mask |= CWWidth; |
| } |
| if (old->bottom - old->top != new->bottom - new->top) |
| { |
| if (!(changes->height = new->bottom - new->top)) changes->height = 1; |
| mask |= CWHeight; |
| } |
| if (old->left != new->left) |
| { |
| changes->x = new->left; |
| mask |= CWX; |
| } |
| if (old->top != new->top) |
| { |
| changes->y = new->top; |
| mask |= CWY; |
| } |
| return mask; |
| } |
| |
| |
| /*********************************************************************** |
| * create_icon_window |
| */ |
| static Window create_icon_window( Display *display, WND *win ) |
| { |
| struct x11drv_win_data *data = win->pDriverData; |
| XSetWindowAttributes attr; |
| |
| attr.event_mask = (ExposureMask | KeyPressMask | KeyReleaseMask | PointerMotionMask | |
| ButtonPressMask | ButtonReleaseMask | EnterWindowMask); |
| attr.bit_gravity = NorthWestGravity; |
| attr.backing_store = NotUseful/*WhenMapped*/; |
| attr.colormap = X11DRV_PALETTE_PaletteXColormap; /* Needed due to our visual */ |
| |
| wine_tsx11_lock(); |
| data->icon_window = XCreateWindow( display, root_window, 0, 0, |
| GetSystemMetrics( SM_CXICON ), |
| GetSystemMetrics( SM_CYICON ), |
| 0, screen_depth, |
| InputOutput, visual, |
| CWEventMask | CWBitGravity | CWBackingStore | CWColormap, &attr ); |
| XSaveContext( display, data->icon_window, winContext, (char *)win->hwndSelf ); |
| wine_tsx11_unlock(); |
| |
| TRACE( "created %lx\n", data->icon_window ); |
| SetPropA( win->hwndSelf, icon_window_atom, (HANDLE)data->icon_window ); |
| return data->icon_window; |
| } |
| |
| |
| |
| /*********************************************************************** |
| * destroy_icon_window |
| */ |
| inline static void destroy_icon_window( Display *display, WND *win ) |
| { |
| struct x11drv_win_data *data = win->pDriverData; |
| |
| if (!data->icon_window) return; |
| if (x11drv_thread_data()->cursor_window == data->icon_window) |
| x11drv_thread_data()->cursor_window = None; |
| wine_tsx11_lock(); |
| XDeleteContext( display, data->icon_window, winContext ); |
| XDestroyWindow( display, data->icon_window ); |
| data->icon_window = 0; |
| wine_tsx11_unlock(); |
| RemovePropA( win->hwndSelf, icon_window_atom ); |
| } |
| |
| |
| /*********************************************************************** |
| * set_icon_hints |
| * |
| * Set the icon wm hints |
| */ |
| static void set_icon_hints( Display *display, WND *wndPtr, XWMHints *hints ) |
| { |
| X11DRV_WND_DATA *data = wndPtr->pDriverData; |
| HICON hIcon = (HICON)GetClassLongA( wndPtr->hwndSelf, GCL_HICON ); |
| |
| if (data->hWMIconBitmap) DeleteObject( data->hWMIconBitmap ); |
| if (data->hWMIconMask) DeleteObject( data->hWMIconMask); |
| data->hWMIconBitmap = 0; |
| data->hWMIconMask = 0; |
| |
| if (!(wndPtr->dwExStyle & WS_EX_MANAGED)) |
| { |
| destroy_icon_window( display, wndPtr ); |
| hints->flags &= ~(IconPixmapHint | IconMaskHint | IconWindowHint); |
| } |
| else if (!hIcon) |
| { |
| if (!data->icon_window) create_icon_window( display, wndPtr ); |
| hints->icon_window = data->icon_window; |
| hints->flags = (hints->flags & ~(IconPixmapHint | IconMaskHint)) | IconWindowHint; |
| } |
| else |
| { |
| HBITMAP hbmOrig; |
| RECT rcMask; |
| BITMAP bmMask; |
| ICONINFO ii; |
| HDC hDC; |
| |
| GetIconInfo(hIcon, &ii); |
| |
| GetObjectA(ii.hbmMask, sizeof(bmMask), &bmMask); |
| rcMask.top = 0; |
| rcMask.left = 0; |
| rcMask.right = bmMask.bmWidth; |
| rcMask.bottom = bmMask.bmHeight; |
| |
| hDC = CreateCompatibleDC(0); |
| hbmOrig = SelectObject(hDC, ii.hbmMask); |
| InvertRect(hDC, &rcMask); |
| SelectObject(hDC, ii.hbmColor); /* force the color bitmap to x11drv mode too */ |
| SelectObject(hDC, hbmOrig); |
| DeleteDC(hDC); |
| |
| data->hWMIconBitmap = ii.hbmColor; |
| data->hWMIconMask = ii.hbmMask; |
| |
| hints->icon_pixmap = X11DRV_BITMAP_Pixmap(data->hWMIconBitmap); |
| hints->icon_mask = X11DRV_BITMAP_Pixmap(data->hWMIconMask); |
| destroy_icon_window( display, wndPtr ); |
| hints->flags = (hints->flags & ~IconWindowHint) | IconPixmapHint | IconMaskHint; |
| } |
| } |
| |
| |
| /*********************************************************************** |
| * set_size_hints |
| * |
| * set the window size hints |
| */ |
| static void set_size_hints( Display *display, WND *win ) |
| { |
| XSizeHints* size_hints; |
| struct x11drv_win_data *data = win->pDriverData; |
| |
| if ((size_hints = XAllocSizeHints())) |
| { |
| size_hints->win_gravity = StaticGravity; |
| size_hints->x = data->whole_rect.left; |
| size_hints->y = data->whole_rect.top; |
| size_hints->flags = PWinGravity | PPosition; |
| |
| if (HAS_DLGFRAME( win->dwStyle, win->dwExStyle )) |
| { |
| size_hints->max_width = data->whole_rect.right - data->whole_rect.left; |
| size_hints->max_height = data->whole_rect.bottom - data->whole_rect.top; |
| size_hints->min_width = size_hints->max_width; |
| size_hints->min_height = size_hints->max_height; |
| size_hints->flags |= PMinSize | PMaxSize; |
| } |
| XSetWMNormalHints( display, data->whole_window, size_hints ); |
| XFree( size_hints ); |
| } |
| } |
| |
| |
| /*********************************************************************** |
| * X11DRV_set_wm_hints |
| * |
| * Set the window manager hints for a newly-created window |
| */ |
| void X11DRV_set_wm_hints( Display *display, WND *win ) |
| { |
| struct x11drv_win_data *data = win->pDriverData; |
| Window group_leader; |
| XClassHint *class_hints; |
| XWMHints* wm_hints; |
| Atom protocols[2]; |
| int i; |
| |
| wine_tsx11_lock(); |
| |
| /* wm protocols */ |
| i = 0; |
| protocols[i++] = wmDeleteWindow; |
| if (wmTakeFocus) protocols[i++] = wmTakeFocus; |
| if (netwmPing) protocols[i++] = netwmPing; |
| XSetWMProtocols( display, data->whole_window, protocols, i ); |
| |
| /* class hints */ |
| if ((class_hints = XAllocClassHint())) |
| { |
| class_hints->res_name = "wine"; |
| class_hints->res_class = "Wine"; |
| XSetClassHint( display, data->whole_window, class_hints ); |
| XFree( class_hints ); |
| } |
| |
| /* transient for hint */ |
| if (win->owner) |
| { |
| Window owner_win = X11DRV_get_whole_window( win->owner ); |
| XSetTransientForHint( display, data->whole_window, owner_win ); |
| group_leader = owner_win; |
| } |
| else group_leader = data->whole_window; |
| |
| /* size hints */ |
| set_size_hints( display, win ); |
| |
| /* systray properties (KDE only for now) */ |
| if (win->dwExStyle & WS_EX_TRAYWINDOW) |
| { |
| int val = 1; |
| if (kwmDockWindow != None) |
| XChangeProperty( display, data->whole_window, kwmDockWindow, kwmDockWindow, |
| 32, PropModeReplace, (char*)&val, 1 ); |
| if (_kde_net_wm_system_tray_window_for != None) |
| XChangeProperty( display, data->whole_window, _kde_net_wm_system_tray_window_for, |
| XA_WINDOW, 32, PropModeReplace, (char*)&data->whole_window, 1 ); |
| } |
| |
| /* set the WM_CLIENT_MACHINE and WM_LOCALE_NAME properties */ |
| XSetWMProperties(display, data->whole_window, NULL, NULL, NULL, 0, NULL, NULL, NULL); |
| /* set the pid. together, these properties are needed so the window manager can kill us if we freeze */ |
| i = getpid(); |
| XChangeProperty(display, data->whole_window, netwmPid, XA_CARDINAL, 32, PropModeReplace, (char *)&i, 1); |
| |
| if (mwmHints != None) |
| { |
| MwmHints mwm_hints; |
| mwm_hints.flags = MWM_HINTS_FUNCTIONS | MWM_HINTS_DECORATIONS; |
| mwm_hints.functions = 0; |
| if ((win->dwStyle & WS_CAPTION) == WS_CAPTION) mwm_hints.functions |= MWM_FUNC_MOVE; |
| if (win->dwStyle & WS_THICKFRAME) mwm_hints.functions |= MWM_FUNC_MOVE | MWM_FUNC_RESIZE; |
| if (win->dwStyle & WS_MINIMIZEBOX) mwm_hints.functions |= MWM_FUNC_MINIMIZE; |
| if (win->dwStyle & WS_MAXIMIZEBOX) mwm_hints.functions |= MWM_FUNC_MAXIMIZE; |
| if (win->dwStyle & WS_SYSMENU) mwm_hints.functions |= MWM_FUNC_CLOSE; |
| mwm_hints.decorations = 0; |
| if ((win->dwStyle & WS_CAPTION) == WS_CAPTION) mwm_hints.decorations |= MWM_DECOR_TITLE; |
| if (win->dwExStyle & WS_EX_DLGMODALFRAME) mwm_hints.decorations |= MWM_DECOR_BORDER; |
| else if (win->dwStyle & WS_THICKFRAME) mwm_hints.decorations |= MWM_DECOR_BORDER | MWM_DECOR_RESIZEH; |
| else if ((win->dwStyle & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME) mwm_hints.decorations |= MWM_DECOR_BORDER; |
| else if (win->dwStyle & WS_BORDER) mwm_hints.decorations |= MWM_DECOR_BORDER; |
| else if (!(win->dwStyle & (WS_CHILD|WS_POPUP))) mwm_hints.decorations |= MWM_DECOR_BORDER; |
| if (win->dwStyle & WS_SYSMENU) mwm_hints.decorations |= MWM_DECOR_MENU; |
| if (win->dwStyle & WS_MINIMIZEBOX) mwm_hints.decorations |= MWM_DECOR_MINIMIZE; |
| if (win->dwStyle & WS_MAXIMIZEBOX) mwm_hints.decorations |= MWM_DECOR_MAXIMIZE; |
| |
| XChangeProperty( display, data->whole_window, mwmHints, mwmHints, 32, |
| PropModeReplace, (char*)&mwm_hints, sizeof(mwm_hints)/sizeof(long) ); |
| } |
| |
| wm_hints = XAllocWMHints(); |
| wine_tsx11_unlock(); |
| |
| /* wm hints */ |
| if (wm_hints) |
| { |
| wm_hints->flags = InputHint | StateHint | WindowGroupHint; |
| wm_hints->input = !(win->dwStyle & WS_DISABLED); |
| |
| set_icon_hints( display, win, wm_hints ); |
| |
| wm_hints->initial_state = (win->dwStyle & WS_MINIMIZE) ? IconicState : NormalState; |
| wm_hints->window_group = group_leader; |
| |
| wine_tsx11_lock(); |
| XSetWMHints( display, data->whole_window, wm_hints ); |
| XFree(wm_hints); |
| wine_tsx11_unlock(); |
| } |
| } |
| |
| |
| /*********************************************************************** |
| * X11DRV_set_iconic_state |
| * |
| * Set the X11 iconic state according to the window style. |
| */ |
| void X11DRV_set_iconic_state( WND *win ) |
| { |
| Display *display = thread_display(); |
| struct x11drv_win_data *data = win->pDriverData; |
| XWMHints* wm_hints; |
| BOOL iconic = IsIconic( win->hwndSelf ); |
| |
| wine_tsx11_lock(); |
| |
| if (iconic) XUnmapWindow( display, data->client_window ); |
| else if (is_client_window_mapped( win )) XMapWindow( display, data->client_window ); |
| |
| if (!(wm_hints = XGetWMHints( display, data->whole_window ))) wm_hints = XAllocWMHints(); |
| wm_hints->flags |= StateHint | IconPositionHint; |
| wm_hints->initial_state = iconic ? IconicState : NormalState; |
| wm_hints->icon_x = win->rectWindow.left; |
| wm_hints->icon_y = win->rectWindow.top; |
| XSetWMHints( display, data->whole_window, wm_hints ); |
| |
| if (win->dwStyle & WS_VISIBLE) |
| { |
| if (iconic) |
| XIconifyWindow( display, data->whole_window, DefaultScreen(display) ); |
| else |
| if (!IsRectEmpty( &win->rectWindow )) XMapWindow( display, data->whole_window ); |
| } |
| |
| XFree(wm_hints); |
| wine_tsx11_unlock(); |
| } |
| |
| |
| /*********************************************************************** |
| * X11DRV_window_to_X_rect |
| * |
| * Convert a rect from client to X window coordinates |
| */ |
| void X11DRV_window_to_X_rect( WND *win, RECT *rect ) |
| { |
| RECT rc; |
| |
| if (!(win->dwExStyle & WS_EX_MANAGED)) return; |
| if (IsRectEmpty( rect )) return; |
| |
| rc.top = rc.bottom = rc.left = rc.right = 0; |
| |
| AdjustWindowRectEx( &rc, win->dwStyle & ~(WS_HSCROLL|WS_VSCROLL), FALSE, win->dwExStyle ); |
| |
| rect->left -= rc.left; |
| rect->right -= rc.right; |
| rect->top -= rc.top; |
| rect->bottom -= rc.bottom; |
| if (rect->top >= rect->bottom) rect->bottom = rect->top + 1; |
| if (rect->left >= rect->right) rect->right = rect->left + 1; |
| } |
| |
| |
| /*********************************************************************** |
| * X11DRV_X_to_window_rect |
| * |
| * Opposite of X11DRV_window_to_X_rect |
| */ |
| void X11DRV_X_to_window_rect( WND *win, RECT *rect ) |
| { |
| if (!(win->dwExStyle & WS_EX_MANAGED)) return; |
| if (IsRectEmpty( rect )) return; |
| |
| AdjustWindowRectEx( rect, win->dwStyle & ~(WS_HSCROLL|WS_VSCROLL), FALSE, win->dwExStyle ); |
| |
| if (rect->top >= rect->bottom) rect->bottom = rect->top + 1; |
| if (rect->left >= rect->right) rect->right = rect->left + 1; |
| } |
| |
| |
| /*********************************************************************** |
| * X11DRV_sync_whole_window_position |
| * |
| * Synchronize the X whole window position with the Windows one |
| */ |
| int X11DRV_sync_whole_window_position( Display *display, WND *win, int zorder ) |
| { |
| XWindowChanges changes; |
| int mask; |
| struct x11drv_win_data *data = win->pDriverData; |
| RECT whole_rect = win->rectWindow; |
| |
| X11DRV_window_to_X_rect( win, &whole_rect ); |
| mask = get_window_changes( &changes, &data->whole_rect, &whole_rect ); |
| |
| if (zorder) |
| { |
| if (is_window_top_level( win )) |
| { |
| /* find window that this one must be after */ |
| HWND prev = GetWindow( win->hwndSelf, GW_HWNDPREV ); |
| while (prev && !(GetWindowLongW( prev, GWL_STYLE ) & WS_VISIBLE)) |
| prev = GetWindow( prev, GW_HWNDPREV ); |
| if (!prev) /* top child */ |
| { |
| changes.stack_mode = Above; |
| mask |= CWStackMode; |
| } |
| else |
| { |
| /* should use stack_mode Below but most window managers don't get it right */ |
| /* so move it above the next one in Z order */ |
| HWND next = GetWindow( win->hwndSelf, GW_HWNDNEXT ); |
| while (next && !(GetWindowLongW( next, GWL_STYLE ) & WS_VISIBLE)) |
| next = GetWindow( next, GW_HWNDNEXT ); |
| if (next) |
| { |
| changes.stack_mode = Above; |
| changes.sibling = X11DRV_get_whole_window(next); |
| mask |= CWStackMode | CWSibling; |
| } |
| } |
| } |
| else |
| { |
| HWND next = GetWindow( win->hwndSelf, GW_HWNDNEXT ); |
| if (!next) /* bottom child */ |
| { |
| changes.stack_mode = Below; |
| mask |= CWStackMode; |
| } |
| else |
| { |
| changes.stack_mode = Above; |
| changes.sibling = X11DRV_get_whole_window(next); |
| mask |= CWStackMode | CWSibling; |
| } |
| } |
| } |
| |
| data->whole_rect = whole_rect; |
| |
| if (mask) |
| { |
| TRACE( "setting win %lx pos %ld,%ld,%ldx%ld after %lx changes=%x\n", |
| data->whole_window, whole_rect.left, whole_rect.top, |
| whole_rect.right - whole_rect.left, whole_rect.bottom - whole_rect.top, |
| changes.sibling, mask ); |
| wine_tsx11_lock(); |
| XSync( gdi_display, False ); /* flush graphics operations before moving the window */ |
| if (is_window_top_level( win )) |
| { |
| if (mask & (CWWidth|CWHeight)) set_size_hints( display, win ); |
| XReconfigureWMWindow( display, data->whole_window, |
| DefaultScreen(display), mask, &changes ); |
| } |
| else XConfigureWindow( display, data->whole_window, mask, &changes ); |
| wine_tsx11_unlock(); |
| } |
| return mask; |
| } |
| |
| |
| /*********************************************************************** |
| * X11DRV_sync_client_window_position |
| * |
| * Synchronize the X client window position with the Windows one |
| */ |
| int X11DRV_sync_client_window_position( Display *display, WND *win ) |
| { |
| XWindowChanges changes; |
| int mask; |
| struct x11drv_win_data *data = win->pDriverData; |
| RECT client_rect = win->rectClient; |
| |
| OffsetRect( &client_rect, -data->whole_rect.left, -data->whole_rect.top ); |
| |
| if ((mask = get_window_changes( &changes, &data->client_rect, &client_rect ))) |
| { |
| BOOL was_mapped = is_client_window_mapped( win ); |
| |
| TRACE( "setting win %lx pos %ld,%ld,%ldx%ld (was %ld,%ld,%ldx%ld) after %lx changes=%x\n", |
| data->client_window, client_rect.left, client_rect.top, |
| client_rect.right - client_rect.left, client_rect.bottom - client_rect.top, |
| data->client_rect.left, data->client_rect.top, |
| data->client_rect.right - data->client_rect.left, |
| data->client_rect.bottom - data->client_rect.top, |
| changes.sibling, mask ); |
| data->client_rect = client_rect; |
| wine_tsx11_lock(); |
| XSync( gdi_display, False ); /* flush graphics operations before moving the window */ |
| if (was_mapped && !is_client_window_mapped( win )) |
| XUnmapWindow( display, data->client_window ); |
| XConfigureWindow( display, data->client_window, mask, &changes ); |
| if (!was_mapped && is_client_window_mapped( win )) |
| XMapWindow( display, data->client_window ); |
| wine_tsx11_unlock(); |
| } |
| return mask; |
| } |
| |
| |
| /*********************************************************************** |
| * X11DRV_register_window |
| * |
| * Associate an X window to a HWND. |
| */ |
| void X11DRV_register_window( Display *display, HWND hwnd, struct x11drv_win_data *data ) |
| { |
| wine_tsx11_lock(); |
| XSaveContext( display, data->whole_window, winContext, (char *)hwnd ); |
| XSaveContext( display, data->client_window, winContext, (char *)hwnd ); |
| wine_tsx11_unlock(); |
| } |
| |
| |
| /********************************************************************** |
| * create_desktop |
| */ |
| static void create_desktop( Display *display, WND *wndPtr ) |
| { |
| X11DRV_WND_DATA *data = wndPtr->pDriverData; |
| |
| wine_tsx11_lock(); |
| winContext = XUniqueContext(); |
| wmProtocols = XInternAtom( display, "WM_PROTOCOLS", False ); |
| wmDeleteWindow = XInternAtom( display, "WM_DELETE_WINDOW", False ); |
| if (use_take_focus) wmTakeFocus = XInternAtom( display, "WM_TAKE_FOCUS", False ); |
| dndProtocol = XInternAtom( display, "DndProtocol" , False ); |
| dndSelection = XInternAtom( display, "DndSelection" , False ); |
| wmChangeState = XInternAtom( display, "WM_CHANGE_STATE", False ); |
| mwmHints = XInternAtom( display, _XA_MWM_HINTS, False ); |
| kwmDockWindow = XInternAtom( display, "KWM_DOCKWINDOW", False ); |
| _kde_net_wm_system_tray_window_for = XInternAtom( display, "_KDE_NET_WM_SYSTEM_TRAY_WINDOW_FOR", False ); |
| netwmPid = XInternAtom( display, "_NET_WM_PID", False ); |
| netwmPing = XInternAtom( display, "_NET_WM_PING", False ); |
| wine_tsx11_unlock(); |
| |
| whole_window_atom = MAKEINTATOMA( GlobalAddAtomA( "__wine_x11_whole_window" )); |
| client_window_atom = MAKEINTATOMA( GlobalAddAtomA( "__wine_x11_client_window" )); |
| icon_window_atom = MAKEINTATOMA( GlobalAddAtomA( "__wine_x11_icon_window" )); |
| |
| data->whole_window = data->client_window = root_window; |
| data->whole_rect = data->client_rect = wndPtr->rectWindow; |
| |
| SetPropA( wndPtr->hwndSelf, whole_window_atom, (HANDLE)root_window ); |
| SetPropA( wndPtr->hwndSelf, client_window_atom, (HANDLE)root_window ); |
| SetPropA( wndPtr->hwndSelf, "__wine_x11_visual_id", (HANDLE)XVisualIDFromVisual(visual) ); |
| |
| if (root_window != DefaultRootWindow(display)) X11DRV_create_desktop_thread(); |
| } |
| |
| |
| /********************************************************************** |
| * create_whole_window |
| * |
| * Create the whole X window for a given window |
| */ |
| static Window create_whole_window( Display *display, WND *win ) |
| { |
| struct x11drv_win_data *data = win->pDriverData; |
| int cx, cy, mask; |
| XSetWindowAttributes attr; |
| Window parent; |
| RECT rect; |
| BOOL is_top_level = is_window_top_level( win ); |
| |
| rect = win->rectWindow; |
| X11DRV_window_to_X_rect( win, &rect ); |
| |
| if (!(cx = rect.right - rect.left)) cx = 1; |
| if (!(cy = rect.bottom - rect.top)) cy = 1; |
| |
| parent = X11DRV_get_client_window( win->parent ); |
| |
| wine_tsx11_lock(); |
| |
| mask = get_window_attributes( display, win, &attr ); |
| |
| /* set the attributes that don't change over the lifetime of the window */ |
| attr.bit_gravity = ForgetGravity; |
| attr.win_gravity = NorthWestGravity; |
| attr.backing_store = NotUseful/*WhenMapped*/; |
| mask |= CWBitGravity | CWWinGravity | CWBackingStore; |
| |
| data->whole_rect = rect; |
| data->whole_window = XCreateWindow( display, parent, rect.left, rect.top, cx, cy, |
| 0, screen_depth, InputOutput, visual, |
| mask, &attr ); |
| |
| if (!data->whole_window) |
| { |
| wine_tsx11_unlock(); |
| return 0; |
| } |
| |
| if (is_top_level) |
| { |
| XIM xim = x11drv_thread_data()->xim; |
| if (xim) data->xic = XCreateIC( xim, |
| XNInputStyle, XIMPreeditNothing | XIMStatusNothing, |
| XNClientWindow, data->whole_window, |
| XNFocusWindow, data->whole_window, |
| 0 ); |
| } |
| |
| /* non-maximized child must be at bottom of Z order */ |
| if ((win->dwStyle & (WS_CHILD|WS_MAXIMIZE)) == WS_CHILD) |
| { |
| XWindowChanges changes; |
| changes.stack_mode = Below; |
| XConfigureWindow( display, data->whole_window, CWStackMode, &changes ); |
| } |
| |
| wine_tsx11_unlock(); |
| |
| if (is_top_level) X11DRV_set_wm_hints( display, win ); |
| |
| return data->whole_window; |
| } |
| |
| |
| /********************************************************************** |
| * create_client_window |
| * |
| * Create the client window for a given window |
| */ |
| static Window create_client_window( Display *display, WND *win ) |
| { |
| struct x11drv_win_data *data = win->pDriverData; |
| RECT rect = data->whole_rect; |
| XSetWindowAttributes attr; |
| |
| OffsetRect( &rect, -data->whole_rect.left, -data->whole_rect.top ); |
| data->client_rect = rect; |
| |
| attr.event_mask = (ExposureMask | PointerMotionMask | |
| ButtonPressMask | ButtonReleaseMask | EnterWindowMask); |
| attr.bit_gravity = (win->clsStyle & (CS_VREDRAW | CS_HREDRAW)) ? |
| ForgetGravity : NorthWestGravity; |
| attr.backing_store = NotUseful/*WhenMapped*/; |
| |
| wine_tsx11_lock(); |
| data->client_window = XCreateWindow( display, data->whole_window, 0, 0, |
| max( rect.right - rect.left, 1 ), |
| max( rect.bottom - rect.top, 1 ), |
| 0, screen_depth, |
| InputOutput, visual, |
| CWEventMask | CWBitGravity | CWBackingStore, &attr ); |
| if (data->client_window && is_client_window_mapped( win )) |
| XMapWindow( display, data->client_window ); |
| wine_tsx11_unlock(); |
| return data->client_window; |
| } |
| |
| |
| /***************************************************************** |
| * SetWindowText (X11DRV.@) |
| */ |
| BOOL X11DRV_SetWindowText( HWND hwnd, LPCWSTR text ) |
| { |
| Display *display = thread_display(); |
| UINT count; |
| char *buffer; |
| char *utf8_buffer; |
| Window win; |
| XTextProperty prop; |
| |
| if ((win = X11DRV_get_whole_window( hwnd ))) |
| { |
| /* allocate new buffer for window text */ |
| count = WideCharToMultiByte(CP_UNIXCP, 0, text, -1, NULL, 0, NULL, NULL); |
| if (!(buffer = HeapAlloc( GetProcessHeap(), 0, count ))) |
| { |
| ERR("Not enough memory for window text\n"); |
| return FALSE; |
| } |
| WideCharToMultiByte(CP_UNIXCP, 0, text, -1, buffer, count, NULL, NULL); |
| |
| count = WideCharToMultiByte(CP_UTF8, 0, text, strlenW(text), NULL, 0, NULL, NULL); |
| if (!(utf8_buffer = HeapAlloc( GetProcessHeap(), 0, count ))) |
| { |
| ERR("Not enough memory for window text in UTF-8\n"); |
| return FALSE; |
| } |
| WideCharToMultiByte(CP_UTF8, 0, text, strlenW(text), utf8_buffer, count, NULL, NULL); |
| |
| wine_tsx11_lock(); |
| if (XmbTextListToTextProperty( display, &buffer, 1, XStdICCTextStyle, &prop ) == Success) |
| { |
| XSetWMName( display, win, &prop ); |
| XSetWMIconName( display, win, &prop ); |
| XFree( prop.value ); |
| } |
| /* |
| Implements a NET_WM UTF-8 title. It should be without a trailing \0, |
| according to the standard |
| ( http://www.pps.jussieu.fr/~jch/software/UTF8_STRING/UTF8_STRING.text ). |
| */ |
| XChangeProperty( display, win, |
| XInternAtom(display, "_NET_WM_NAME", False), |
| XInternAtom(display, "UTF8_STRING", False), |
| 8, PropModeReplace, (unsigned char *) utf8_buffer, |
| count); |
| wine_tsx11_unlock(); |
| |
| HeapFree( GetProcessHeap(), 0, utf8_buffer ); |
| HeapFree( GetProcessHeap(), 0, buffer ); |
| } |
| return TRUE; |
| } |
| |
| |
| /*********************************************************************** |
| * DestroyWindow (X11DRV.@) |
| */ |
| BOOL X11DRV_DestroyWindow( HWND hwnd ) |
| { |
| struct x11drv_thread_data *thread_data = x11drv_thread_data(); |
| Display *display = thread_data->display; |
| WND *wndPtr = WIN_GetPtr( hwnd ); |
| X11DRV_WND_DATA *data = wndPtr->pDriverData; |
| |
| if (!data) goto done; |
| |
| if (data->whole_window) |
| { |
| TRACE( "win %p xwin %lx/%lx\n", hwnd, data->whole_window, data->client_window ); |
| if (thread_data->cursor_window == data->whole_window) thread_data->cursor_window = None; |
| if (thread_data->last_focus == hwnd) thread_data->last_focus = 0; |
| wine_tsx11_lock(); |
| XSync( gdi_display, False ); /* flush any reference to this drawable in GDI queue */ |
| XDeleteContext( display, data->whole_window, winContext ); |
| XDeleteContext( display, data->client_window, winContext ); |
| XDestroyWindow( display, data->whole_window ); /* this destroys client too */ |
| if (data->xic) |
| { |
| XUnsetICFocus( data->xic ); |
| XDestroyIC( data->xic ); |
| } |
| destroy_icon_window( display, wndPtr ); |
| wine_tsx11_unlock(); |
| } |
| |
| if (data->hWMIconBitmap) DeleteObject( data->hWMIconBitmap ); |
| if (data->hWMIconMask) DeleteObject( data->hWMIconMask); |
| HeapFree( GetProcessHeap(), 0, data ); |
| wndPtr->pDriverData = NULL; |
| done: |
| WIN_ReleasePtr( wndPtr ); |
| return TRUE; |
| } |
| |
| |
| /********************************************************************** |
| * CreateWindow (X11DRV.@) |
| */ |
| BOOL X11DRV_CreateWindow( HWND hwnd, CREATESTRUCTA *cs, BOOL unicode ) |
| { |
| HWND hwndLinkAfter; |
| Display *display = thread_display(); |
| WND *wndPtr; |
| struct x11drv_win_data *data; |
| RECT rect; |
| CBT_CREATEWNDA cbtc; |
| BOOL ret = FALSE; |
| |
| if (cs->cx > 65535) |
| { |
| ERR( "invalid window width %d\n", cs->cx ); |
| cs->cx = 65535; |
| } |
| if (cs->cy > 65535) |
| { |
| ERR( "invalid window height %d\n", cs->cx ); |
| cs->cy = 65535; |
| } |
| |
| if (!(data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data)))) return FALSE; |
| data->whole_window = 0; |
| data->client_window = 0; |
| data->icon_window = 0; |
| data->xic = 0; |
| data->hWMIconBitmap = 0; |
| data->hWMIconMask = 0; |
| |
| wndPtr = WIN_GetPtr( hwnd ); |
| wndPtr->pDriverData = data; |
| |
| /* initialize the dimensions before sending WM_GETMINMAXINFO */ |
| SetRect( &rect, cs->x, cs->y, cs->x + cs->cx, cs->y + cs->cy ); |
| WIN_SetRectangles( hwnd, &rect, &rect ); |
| |
| if (!wndPtr->parent) |
| { |
| create_desktop( display, wndPtr ); |
| WIN_ReleasePtr( wndPtr ); |
| return TRUE; |
| } |
| |
| if (!create_whole_window( display, wndPtr )) goto failed; |
| if (!create_client_window( display, wndPtr )) goto failed; |
| TSXSync( display, False ); |
| |
| SetPropA( hwnd, whole_window_atom, (HANDLE)data->whole_window ); |
| SetPropA( hwnd, client_window_atom, (HANDLE)data->client_window ); |
| |
| /* Call the WH_CBT hook */ |
| |
| hwndLinkAfter = ((cs->style & (WS_CHILD|WS_MAXIMIZE)) == WS_CHILD) ? HWND_BOTTOM : HWND_TOP; |
| |
| cbtc.lpcs = cs; |
| cbtc.hwndInsertAfter = hwndLinkAfter; |
| if (HOOK_CallHooks( WH_CBT, HCBT_CREATEWND, (WPARAM)hwnd, (LPARAM)&cbtc, unicode )) |
| { |
| TRACE("CBT-hook returned !0\n"); |
| goto failed; |
| } |
| |
| /* Send the WM_GETMINMAXINFO message and fix the size if needed */ |
| if ((cs->style & WS_THICKFRAME) || !(cs->style & (WS_POPUP | WS_CHILD))) |
| { |
| POINT maxSize, maxPos, minTrack, maxTrack; |
| |
| WIN_ReleasePtr( wndPtr ); |
| WINPOS_GetMinMaxInfo( hwnd, &maxSize, &maxPos, &minTrack, &maxTrack); |
| if (maxSize.x < cs->cx) cs->cx = maxSize.x; |
| if (maxSize.y < cs->cy) cs->cy = maxSize.y; |
| if (cs->cx < minTrack.x ) cs->cx = minTrack.x; |
| if (cs->cy < minTrack.y ) cs->cy = minTrack.y; |
| if (cs->cx < 0) cs->cx = 0; |
| if (cs->cy < 0) cs->cy = 0; |
| |
| if (!(wndPtr = WIN_GetPtr( hwnd ))) return FALSE; |
| SetRect( &rect, cs->x, cs->y, cs->x + cs->cx, cs->y + cs->cy ); |
| WIN_SetRectangles( hwnd, &rect, &rect ); |
| X11DRV_sync_whole_window_position( display, wndPtr, 0 ); |
| } |
| WIN_ReleasePtr( wndPtr ); |
| |
| /* send WM_NCCREATE */ |
| TRACE( "hwnd %p cs %d,%d %dx%d\n", hwnd, cs->x, cs->y, cs->cx, cs->cy ); |
| if (unicode) |
| ret = SendMessageW( hwnd, WM_NCCREATE, 0, (LPARAM)cs ); |
| else |
| ret = SendMessageA( hwnd, WM_NCCREATE, 0, (LPARAM)cs ); |
| if (!ret) |
| { |
| WARN("aborted by WM_xxCREATE!\n"); |
| return FALSE; |
| } |
| |
| if (!(wndPtr = WIN_GetPtr(hwnd))) return FALSE; |
| |
| X11DRV_sync_window_style( display, wndPtr ); |
| |
| /* send WM_NCCALCSIZE */ |
| rect = wndPtr->rectWindow; |
| WIN_ReleasePtr( wndPtr ); |
| SendMessageW( hwnd, WM_NCCALCSIZE, FALSE, (LPARAM)&rect ); |
| |
| if (!(wndPtr = WIN_GetPtr(hwnd))) return FALSE; |
| if (rect.left > rect.right || rect.top > rect.bottom) rect = wndPtr->rectWindow; |
| WIN_SetRectangles( hwnd, &wndPtr->rectWindow, &rect ); |
| X11DRV_sync_client_window_position( display, wndPtr ); |
| X11DRV_register_window( display, hwnd, data ); |
| |
| 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", |
| hwnd, wndPtr->rectWindow.left, wndPtr->rectWindow.top, |
| wndPtr->rectWindow.right, wndPtr->rectWindow.bottom, |
| wndPtr->rectClient.left, wndPtr->rectClient.top, |
| wndPtr->rectClient.right, wndPtr->rectClient.bottom, |
| data->whole_rect.left, data->whole_rect.top, |
| data->whole_rect.right, data->whole_rect.bottom, |
| data->client_rect.left, data->client_rect.top, |
| data->client_rect.right, data->client_rect.bottom, |
| (unsigned int)data->whole_window, (unsigned int)data->client_window ); |
| |
| if ((wndPtr->dwStyle & (WS_CHILD|WS_MAXIMIZE)) == WS_CHILD) |
| WIN_LinkWindow( hwnd, wndPtr->parent, HWND_BOTTOM ); |
| else |
| WIN_LinkWindow( hwnd, wndPtr->parent, HWND_TOP ); |
| |
| WIN_ReleasePtr( wndPtr ); |
| |
| if (unicode) |
| ret = (SendMessageW( hwnd, WM_CREATE, 0, (LPARAM)cs ) != -1); |
| else |
| ret = (SendMessageA( hwnd, WM_CREATE, 0, (LPARAM)cs ) != -1); |
| |
| if (!ret) |
| { |
| WIN_UnlinkWindow( hwnd ); |
| return FALSE; |
| } |
| |
| /* Send the size messages */ |
| |
| if (!(wndPtr = WIN_FindWndPtr(hwnd))) return FALSE; |
| if (!(wndPtr->flags & WIN_NEED_SIZE)) |
| { |
| /* send it anyway */ |
| if (((wndPtr->rectClient.right-wndPtr->rectClient.left) <0) |
| ||((wndPtr->rectClient.bottom-wndPtr->rectClient.top)<0)) |
| WARN("sending bogus WM_SIZE message 0x%08lx\n", |
| MAKELONG(wndPtr->rectClient.right-wndPtr->rectClient.left, |
| wndPtr->rectClient.bottom-wndPtr->rectClient.top)); |
| SendMessageW( hwnd, WM_SIZE, SIZE_RESTORED, |
| MAKELONG(wndPtr->rectClient.right-wndPtr->rectClient.left, |
| wndPtr->rectClient.bottom-wndPtr->rectClient.top)); |
| SendMessageW( hwnd, WM_MOVE, 0, |
| MAKELONG( wndPtr->rectClient.left, wndPtr->rectClient.top ) ); |
| } |
| |
| /* Show the window, maximizing or minimizing if needed */ |
| |
| if (wndPtr->dwStyle & (WS_MINIMIZE | WS_MAXIMIZE)) |
| { |
| extern UINT WINPOS_MinMaximize( HWND hwnd, UINT cmd, LPRECT rect ); /*FIXME*/ |
| |
| RECT newPos; |
| UINT swFlag = (wndPtr->dwStyle & WS_MINIMIZE) ? SW_MINIMIZE : SW_MAXIMIZE; |
| WIN_SetStyle( hwnd, wndPtr->dwStyle & ~(WS_MAXIMIZE | WS_MINIMIZE) ); |
| WINPOS_MinMaximize( hwnd, swFlag, &newPos ); |
| swFlag = ((wndPtr->dwStyle & WS_CHILD) || GetActiveWindow()) |
| ? SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED |
| : SWP_NOZORDER | SWP_FRAMECHANGED; |
| SetWindowPos( hwnd, 0, newPos.left, newPos.top, |
| newPos.right, newPos.bottom, swFlag ); |
| } |
| |
| /* if the window was made visible set create struct flag so that |
| * we do a proper ShowWindow later on */ |
| if (wndPtr->dwStyle & WS_VISIBLE) cs->style |= WS_VISIBLE; |
| |
| WIN_ReleaseWndPtr( wndPtr ); |
| return TRUE; |
| |
| |
| failed: |
| X11DRV_DestroyWindow( hwnd ); |
| if (wndPtr) WIN_ReleasePtr( wndPtr ); |
| return FALSE; |
| } |
| |
| |
| /*********************************************************************** |
| * X11DRV_get_client_window |
| * |
| * Return the X window associated with the client area of a window |
| */ |
| Window X11DRV_get_client_window( HWND hwnd ) |
| { |
| Window ret = 0; |
| WND *win = WIN_GetPtr( hwnd ); |
| |
| if (win == WND_OTHER_PROCESS) |
| return (Window)GetPropA( hwnd, client_window_atom ); |
| |
| if (win) |
| { |
| struct x11drv_win_data *data = win->pDriverData; |
| ret = data->client_window; |
| WIN_ReleasePtr( win ); |
| } |
| return ret; |
| } |
| |
| |
| /*********************************************************************** |
| * X11DRV_get_whole_window |
| * |
| * Return the X window associated with the full area of a window |
| */ |
| Window X11DRV_get_whole_window( HWND hwnd ) |
| { |
| Window ret = 0; |
| WND *win = WIN_GetPtr( hwnd ); |
| |
| if (win == WND_OTHER_PROCESS) |
| return (Window)GetPropA( hwnd, whole_window_atom ); |
| |
| if (win) |
| { |
| struct x11drv_win_data *data = win->pDriverData; |
| ret = data->whole_window; |
| WIN_ReleasePtr( win ); |
| } |
| return ret; |
| } |
| |
| |
| /*********************************************************************** |
| * X11DRV_get_ic |
| * |
| * Return the X input context associated with a window |
| */ |
| XIC X11DRV_get_ic( HWND hwnd ) |
| { |
| XIC ret = 0; |
| WND *win = WIN_GetPtr( hwnd ); |
| |
| if (win && win != WND_OTHER_PROCESS) |
| { |
| struct x11drv_win_data *data = win->pDriverData; |
| ret = data->xic; |
| WIN_ReleasePtr( win ); |
| } |
| return ret; |
| } |
| |
| |
| /***************************************************************** |
| * SetParent (X11DRV.@) |
| */ |
| HWND X11DRV_SetParent( HWND hwnd, HWND parent ) |
| { |
| Display *display = thread_display(); |
| WND *wndPtr; |
| HWND retvalue; |
| |
| /* Windows hides the window first, then shows it again |
| * including the WM_SHOWWINDOW messages and all */ |
| BOOL was_visible = ShowWindow( hwnd, SW_HIDE ); |
| |
| if (!IsWindow( parent )) return 0; |
| if (!(wndPtr = WIN_GetPtr(hwnd)) || wndPtr == WND_OTHER_PROCESS) return 0; |
| |
| retvalue = wndPtr->parent; /* old parent */ |
| if (parent != retvalue) |
| { |
| struct x11drv_win_data *data = wndPtr->pDriverData; |
| |
| WIN_LinkWindow( hwnd, parent, HWND_TOP ); |
| |
| if (parent != GetDesktopWindow()) /* a child window */ |
| { |
| if (!(wndPtr->dwStyle & WS_CHILD)) |
| { |
| HMENU menu = (HMENU)SetWindowLongW( hwnd, GWL_ID, 0 ); |
| if (menu) DestroyMenu( menu ); |
| } |
| } |
| |
| if (is_window_top_level( wndPtr )) X11DRV_set_wm_hints( display, wndPtr ); |
| wine_tsx11_lock(); |
| X11DRV_sync_window_style( display, wndPtr ); |
| XReparentWindow( display, data->whole_window, X11DRV_get_client_window(parent), |
| data->whole_rect.left, data->whole_rect.top ); |
| wine_tsx11_unlock(); |
| } |
| WIN_ReleasePtr( wndPtr ); |
| |
| /* SetParent additionally needs to make hwnd the topmost window |
| in the x-order and send the expected WM_WINDOWPOSCHANGING and |
| WM_WINDOWPOSCHANGED notification messages. |
| */ |
| SetWindowPos( hwnd, HWND_TOPMOST, 0, 0, 0, 0, |
| SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | (was_visible ? SWP_SHOWWINDOW : 0) ); |
| /* FIXME: a WM_MOVE is also generated (in the DefWindowProc handler |
| * for WM_WINDOWPOSCHANGED) in Windows, should probably remove SWP_NOMOVE */ |
| |
| return retvalue; |
| } |
| |
| |
| /***************************************************************** |
| * SetFocus (X11DRV.@) |
| * |
| * Set the X focus. |
| * Explicit colormap management seems to work only with OLVWM. |
| */ |
| void X11DRV_SetFocus( HWND hwnd ) |
| { |
| Display *display = thread_display(); |
| XWindowAttributes win_attr; |
| Window win; |
| |
| /* Only mess with the X focus if there's */ |
| /* no desktop window and if the window is not managed by the WM. */ |
| if (root_window != DefaultRootWindow(display)) return; |
| |
| if (!hwnd) /* If setting the focus to 0, uninstall the colormap */ |
| { |
| if (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_PRIVATE) |
| TSXUninstallColormap( display, X11DRV_PALETTE_PaletteXColormap ); |
| return; |
| } |
| |
| hwnd = GetAncestor( hwnd, GA_ROOT ); |
| if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_MANAGED) return; |
| if (!(win = X11DRV_get_whole_window( hwnd ))) return; |
| |
| /* Set X focus and install colormap */ |
| wine_tsx11_lock(); |
| if (XGetWindowAttributes( display, win, &win_attr ) && |
| (win_attr.map_state == IsViewable)) |
| { |
| /* If window is not viewable, don't change anything */ |
| |
| /* we must not use CurrentTime (ICCCM), so try to use last message time instead */ |
| /* FIXME: this is not entirely correct */ |
| XSetInputFocus( display, win, RevertToParent, |
| /*CurrentTime*/ GetMessageTime() + X11DRV_server_startticks ); |
| if (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_PRIVATE) |
| XInstallColormap( display, X11DRV_PALETTE_PaletteXColormap ); |
| } |
| wine_tsx11_unlock(); |
| } |
| |
| |
| /********************************************************************** |
| * SetWindowIcon (X11DRV.@) |
| * |
| * hIcon or hIconSm has changed (or is being initialised for the |
| * first time). Complete the X11 driver-specific initialisation |
| * and set the window hints. |
| * |
| * This is not entirely correct, may need to create |
| * an icon window and set the pixmap as a background |
| */ |
| HICON X11DRV_SetWindowIcon( HWND hwnd, HICON icon, BOOL small ) |
| { |
| WND *wndPtr; |
| Display *display = thread_display(); |
| HICON old = (HICON)SetClassLongW(hwnd, small ? GCL_HICONSM : GCL_HICON, (LONG)icon ); |
| |
| SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOSIZE | |
| SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER ); |
| |
| if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return old; |
| |
| if (wndPtr->dwExStyle & WS_EX_MANAGED) |
| { |
| Window win = get_whole_window(wndPtr); |
| XWMHints* wm_hints; |
| |
| wine_tsx11_lock(); |
| if (!(wm_hints = XGetWMHints( display, win ))) wm_hints = XAllocWMHints(); |
| wine_tsx11_unlock(); |
| if (wm_hints) |
| { |
| set_icon_hints( display, wndPtr, wm_hints ); |
| wine_tsx11_lock(); |
| XSetWMHints( display, win, wm_hints ); |
| XFree( wm_hints ); |
| wine_tsx11_unlock(); |
| } |
| } |
| WIN_ReleasePtr( wndPtr ); |
| return old; |
| } |
