git.oblomov.eu Git - wine/blob - dlls/x11drv/window.c

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