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