windows/x11drv/wnd.c

   1 /*
   2  * X11 windows driver
   3  *
   4  * Copyright 1993, 1994, 1995, 1996 Alexandre Julliard
   5  *                             1993 David Metcalfe
   6  *                       1995, 1996 Alex Korobka
   7  */
   8
   9 #include "config.h"
  10
  11 #include <X11/Xatom.h>
  12
  13 #include "ts_xlib.h"
  14 #include "ts_xutil.h"
  15
  16 #include <stdlib.h>
  17 #include <string.h>
  18
  19 #include "bitmap.h"
  20 #include "color.h"
  21 #include "debugtools.h"
  22 #include "dce.h"
  23 #include "options.h"
  24 #include "message.h"
  25 #include "heap.h"
  26 #include "win.h"
  27 #include "windef.h"
  28 #include "class.h"
  29 #include "x11drv.h"
  30 #include "wingdi.h"
  31 #include "wine/winuser16.h"
  32
  33 DEFAULT_DEBUG_CHANNEL(win);
  34
  35   /* Some useful macros */
  36 #define HAS_DLGFRAME(style,exStyle) \
  37 ((!((style) & WS_THICKFRAME)) && (((style) & WS_DLGFRAME) || ((exStyle) & WS_EX_DLGMODALFRAME)))
  38
  39 /**********************************************************************/
  40
  41 extern Cursor X11DRV_MOUSE_XCursor;  /* Current X cursor */
  42 extern BOOL   X11DRV_CreateBitmap( HBITMAP );
  43 extern Pixmap X11DRV_BITMAP_Pixmap( HBITMAP );
  44
  45 /**********************************************************************/
  46
  47 /* X context to associate a hwnd to an X window */
  48 XContext winContext = 0;
  49
  50 Atom wmProtocols = None;
  51 Atom wmDeleteWindow = None;
  52 Atom dndProtocol = None;
  53 Atom dndSelection = None;
  54 Atom wmChangeState = None;
  55
  56 Atom kwmDockWindow = None;
  57
  58 /***********************************************************************
  59  *              X11DRV_WND_GetXWindow
  60  *
  61  * Return the X window associated to a window.
  62  */
  63 Window X11DRV_WND_GetXWindow(WND *wndPtr)
  64 {
  65     return wndPtr && wndPtr->pDriverData ?
  66       ((X11DRV_WND_DATA *) wndPtr->pDriverData)->window : 0;
  67 }
  68
  69 /***********************************************************************
  70  *              X11DRV_WND_FindXWindow
  71  *
  72  * Return the the first X window associated to a window chain.
  73  */
  74 Window X11DRV_WND_FindXWindow(WND *wndPtr)
  75 {
  76     while (wndPtr &&
  77            !((X11DRV_WND_DATA *) wndPtr->pDriverData)->window)
  78       wndPtr = wndPtr->parent;
  79     return wndPtr ?
  80       ((X11DRV_WND_DATA *) wndPtr->pDriverData)->window : 0;
  81 }
  82
  83 /***********************************************************************
  84  *              X11DRV_WND_RegisterWindow
  85  *
  86  * Associate an X window to a HWND.
  87  */
  88 static void X11DRV_WND_RegisterWindow(WND *wndPtr)
  89 {
  90   TSXSetWMProtocols( display, X11DRV_WND_GetXWindow(wndPtr), &wmDeleteWindow, 1 );
  91
  92   if (!winContext) winContext = TSXUniqueContext();
  93   TSXSaveContext( display, X11DRV_WND_GetXWindow(wndPtr),
  94                   winContext, (char *) wndPtr->hwndSelf );
  95 }
  96
  97 /**********************************************************************
  98  *              X11DRV_WND_Initialize
  99  */
 100 void X11DRV_WND_Initialize(WND *wndPtr)
 101 {
 102   X11DRV_WND_DATA *pWndDriverData =
 103     (X11DRV_WND_DATA *) HeapAlloc(SystemHeap, 0, sizeof(X11DRV_WND_DATA));
 104
 105   wndPtr->pDriverData = (void *) pWndDriverData;
 106
 107   pWndDriverData->window = 0;
 108 }
 109
 110 /**********************************************************************
 111  *              X11DRV_WND_Finalize
 112  */
 113 void X11DRV_WND_Finalize(WND *wndPtr)
 114 {
 115   X11DRV_WND_DATA *pWndDriverData =
 116     (X11DRV_WND_DATA *) wndPtr->pDriverData;
 117
 118   if (!wndPtr->pDriverData) {
 119      ERR("Trying to destroy window again. Not good.\n");
 120      return;
 121   }
 122   if(pWndDriverData->window)
 123     {
 124       ERR(
 125           "WND destroyed without destroying "
 126           "the associated X Window (%ld)\n",
 127           pWndDriverData->window
 128       );
 129     }
 130   HeapFree(SystemHeap, 0, wndPtr->pDriverData);
 131   wndPtr->pDriverData = NULL;
 132 }
 133
 134 /**********************************************************************
 135  *              X11DRV_WND_CreateDesktopWindow
 136  */
 137 BOOL X11DRV_WND_CreateDesktopWindow(WND *wndPtr, CLASS *classPtr, BOOL bUnicode)
 138 {
 139     if (wmProtocols == None)
 140         wmProtocols = TSXInternAtom( display, "WM_PROTOCOLS", True );
 141     if (wmDeleteWindow == None)
 142         wmDeleteWindow = TSXInternAtom( display, "WM_DELETE_WINDOW", True );
 143     if( dndProtocol == None )
 144         dndProtocol = TSXInternAtom( display, "DndProtocol" , False );
 145     if( dndSelection == None )
 146         dndSelection = TSXInternAtom( display, "DndSelection" , False );
 147     if( wmChangeState == None )
 148         wmChangeState = TSXInternAtom (display, "WM_CHANGE_STATE", False);
 149     if (kwmDockWindow == None)
 150         kwmDockWindow = TSXInternAtom( display, "KWM_DOCKWINDOW", False );
 151
 152     ((X11DRV_WND_DATA *) wndPtr->pDriverData)->window = X11DRV_GetXRootWindow();
 153     X11DRV_WND_RegisterWindow( wndPtr );
 154
 155     return TRUE;
 156 }
 157
 158 /**********************************************************************
 159  *              X11DRV_WND_IconChanged
 160  *
 161  * hIcon or hIconSm has changed (or is being initialised for the
 162  * first time). Complete the X11 driver-specific initialisation.
 163  *
 164  * This is not entirely correct, may need to create
 165  * an icon window and set the pixmap as a background
 166  */
 167 static void X11DRV_WND_IconChanged(WND *wndPtr)
 168 {
 169
 170     HICON16 hIcon = NC_IconForWindow(wndPtr);
 171
 172     if( ((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconBitmap )
 173         DeleteObject( ((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconBitmap );
 174
 175     if( ((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconMask )
 176         DeleteObject( ((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconMask);
 177
 178     if (!hIcon)
 179     {
 180         ((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconBitmap= 0;
 181         ((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconMask= 0;
 182     }
 183     else
 184     {
 185         HBITMAP hbmOrig;
 186         RECT rcMask;
 187         BITMAP bmMask;
 188         ICONINFO ii;
 189         HDC hDC;
 190
 191         GetIconInfo(hIcon, &ii);
 192
 193         X11DRV_CreateBitmap(ii.hbmMask);
 194         X11DRV_CreateBitmap(ii.hbmColor);
 195
 196         GetObjectA(ii.hbmMask, sizeof(bmMask), &bmMask);
 197         rcMask.top    = 0;
 198         rcMask.left   = 0;
 199         rcMask.right  = bmMask.bmWidth;
 200         rcMask.bottom = bmMask.bmHeight;
 201
 202         hDC = CreateCompatibleDC(0);
 203         hbmOrig = SelectObject(hDC, ii.hbmMask);
 204         InvertRect(hDC, &rcMask);
 205         SelectObject(hDC, hbmOrig);
 206         DeleteDC(hDC);
 207
 208         ((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconBitmap = ii.hbmColor;
 209         ((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconMask= ii.hbmMask;
 210     }
 211     return;
 212 }
 213
 214 static void X11DRV_WND_SetIconHints(WND *wndPtr, XWMHints *hints)
 215 {
 216     if (((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconBitmap)
 217     {
 218         hints->icon_pixmap
 219             = X11DRV_BITMAP_Pixmap(((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconBitmap);
 220         hints->flags |= IconPixmapHint;
 221     }
 222     else
 223         hints->flags &= ~IconPixmapHint;
 224
 225     if (((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconMask)
 226     {
 227         hints->icon_mask
 228             = X11DRV_BITMAP_Pixmap(((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconMask);
 229         hints->flags |= IconMaskHint;
 230     }
 231     else
 232         hints->flags &= ~IconMaskHint;
 233 }
 234
 235 /**********************************************************************
 236  *              X11DRV_WND_UpdateIconHints
 237  *
 238  * hIcon or hIconSm has changed (or is being initialised for the
 239  * first time). Complete the X11 driver-specific initialisation
 240  * and set the window hints.
 241  *
 242  * This is not entirely correct, may need to create
 243  * an icon window and set the pixmap as a background
 244  */
 245 static void X11DRV_WND_UpdateIconHints(WND *wndPtr)
 246 {
 247     XWMHints* wm_hints;
 248
 249     X11DRV_WND_IconChanged(wndPtr);
 250
 251     wm_hints = TSXGetWMHints( display, X11DRV_WND_GetXWindow(wndPtr) );
 252     if (!wm_hints) wm_hints = TSXAllocWMHints();
 253     if (wm_hints)
 254     {
 255         X11DRV_WND_SetIconHints(wndPtr, wm_hints);
 256         TSXSetWMHints( display, X11DRV_WND_GetXWindow(wndPtr), wm_hints );
 257         TSXFree( wm_hints );
 258     }
 259 }
 260
 261
 262 /**********************************************************************
 263  *              X11DRV_WND_CreateWindow
 264  */
 265 BOOL X11DRV_WND_CreateWindow(WND *wndPtr, CLASS *classPtr, CREATESTRUCTA *cs, BOOL bUnicode)
 266 {
 267   /* Create the X window (only for top-level windows, and then only */
 268   /* when there's no desktop window) */
 269
 270   if ((X11DRV_GetXRootWindow() == DefaultRootWindow(display))
 271       && (wndPtr->parent->hwndSelf == GetDesktopWindow()))
 272   {
 273       Window    wGroupLeader;
 274       XWMHints* wm_hints;
 275       XSetWindowAttributes win_attr;
 276
 277       /* Create "managed" windows only if a title bar or resizable */
 278       /* frame is required. */
 279         if (WIN_WindowNeedsWMBorder(cs->style, cs->dwExStyle)) {
 280           win_attr.event_mask = ExposureMask | KeyPressMask |
 281             KeyReleaseMask | PointerMotionMask |
 282             ButtonPressMask | ButtonReleaseMask |
 283             FocusChangeMask | StructureNotifyMask;
 284           win_attr.override_redirect = FALSE;
 285           wndPtr->flags |= WIN_MANAGED;
 286         } else {
 287           win_attr.event_mask = ExposureMask | KeyPressMask |
 288             KeyReleaseMask | PointerMotionMask |
 289             ButtonPressMask | ButtonReleaseMask |
 290             FocusChangeMask;
 291           win_attr.override_redirect = TRUE;
 292         }
 293       wndPtr->flags |= WIN_NATIVE;
 294
 295       win_attr.bit_gravity   = (classPtr->style & (CS_VREDRAW | CS_HREDRAW)) ? BGForget : BGNorthWest;
 296       win_attr.colormap      = X11DRV_PALETTE_PaletteXColormap;
 297       win_attr.backing_store = NotUseful;
 298       win_attr.save_under    = ((classPtr->style & CS_SAVEBITS) != 0);
 299       win_attr.cursor        = X11DRV_MOUSE_XCursor;
 300
 301       ((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconBitmap = 0;
 302       ((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconMask = 0;
 303       ((X11DRV_WND_DATA *) wndPtr->pDriverData)->bit_gravity = win_attr.bit_gravity;
 304
 305       /* Zero-size X11 window hack.  X doesn't like them, and will crash */
 306       /* with a BadValue unless we do something ugly like this. */
 307       /* FIXME:  there must be a better way.  */
 308         if (cs->cx <= 0) cs->cx = 1;
 309         if (cs->cy <= 0) cs->cy = 1;
 310       /* EMXIF */
 311
 312       ((X11DRV_WND_DATA *) wndPtr->pDriverData)->window =
 313         TSXCreateWindow( display, X11DRV_GetXRootWindow(),
 314                          cs->x, cs->y, cs->cx, cs->cy,
 315                          0, CopyFromParent,
 316                          InputOutput, CopyFromParent,
 317                          CWEventMask | CWOverrideRedirect |
 318                          CWColormap | CWCursor | CWSaveUnder |
 319                          CWBackingStore | CWBitGravity,
 320                          &win_attr );
 321
 322       if(!(wGroupLeader = X11DRV_WND_GetXWindow(wndPtr)))
 323         return FALSE;
 324
 325       /* If we are the systray, we need to be managed to be noticed by KWM */
 326
 327       if (wndPtr->dwExStyle & WS_EX_TRAYWINDOW)
 328         X11DRV_WND_DockWindow(wndPtr);
 329
 330       if (wndPtr->flags & WIN_MANAGED)
 331       {
 332           XClassHint *class_hints = TSXAllocClassHint();
 333           XSizeHints* size_hints = TSXAllocSizeHints();
 334
 335           if (class_hints)
 336           {
 337               class_hints->res_name = "wineManaged";
 338               class_hints->res_class = "Wine";
 339               TSXSetClassHint( display, ((X11DRV_WND_DATA *) wndPtr->pDriverData)->window, class_hints );
 340               TSXFree (class_hints);
 341           }
 342
 343           if (size_hints)
 344           {
 345               size_hints->win_gravity = StaticGravity;
 346               size_hints->flags = PWinGravity;
 347
 348               if (HAS_DLGFRAME(cs->style,cs->dwExStyle))
 349               {
 350                   size_hints->min_width = size_hints->max_width = cs->cx;
 351                   size_hints->min_height = size_hints->max_height = cs->cy;
 352                   size_hints->flags |= PMinSize | PMaxSize;
 353               }
 354
 355               TSXSetWMSizeHints( display, X11DRV_WND_GetXWindow(wndPtr),
 356                                  size_hints, XA_WM_NORMAL_HINTS );
 357               TSXFree(size_hints);
 358           }
 359       }
 360
 361       if (cs->hwndParent)  /* Get window owner */
 362       {
 363           Window w;
 364           WND *tmpWnd = WIN_FindWndPtr(cs->hwndParent);
 365
 366           w = X11DRV_WND_FindXWindow( tmpWnd );
 367           if (w != None)
 368           {
 369               TSXSetTransientForHint( display, X11DRV_WND_GetXWindow(wndPtr), w );
 370               wGroupLeader = w;
 371           }
 372           WIN_ReleaseWndPtr(tmpWnd);
 373       }
 374
 375       if ((wm_hints = TSXAllocWMHints()))
 376       {
 377           wm_hints->flags = InputHint | StateHint | WindowGroupHint;
 378           wm_hints->input = True;
 379
 380           if( wndPtr->flags & WIN_MANAGED )
 381           {
 382               X11DRV_WND_IconChanged(wndPtr);
 383               X11DRV_WND_SetIconHints(wndPtr, wm_hints);
 384
 385               wm_hints->initial_state = (wndPtr->dwStyle & WS_MINIMIZE)
 386                                         ? IconicState : NormalState;
 387           }
 388           else
 389               wm_hints->initial_state = NormalState;
 390           wm_hints->window_group = wGroupLeader;
 391
 392           TSXSetWMHints( display, X11DRV_WND_GetXWindow(wndPtr), wm_hints );
 393           TSXFree(wm_hints);
 394       }
 395       X11DRV_WND_RegisterWindow( wndPtr );
 396   }
 397   return TRUE;
 398 }
 399
 400 /***********************************************************************
 401  *              X11DRV_WND_DestroyWindow
 402  */
 403 BOOL X11DRV_WND_DestroyWindow(WND *wndPtr)
 404 {
 405    Window w;
 406    if ((w = X11DRV_WND_GetXWindow(wndPtr)))
 407    {
 408        XEvent xe;
 409        TSXDeleteContext( display, w, winContext );
 410        TSXDestroyWindow( display, w );
 411        while( TSXCheckWindowEvent(display, w, NoEventMask, &xe) );
 412
 413        ((X11DRV_WND_DATA *) wndPtr->pDriverData)->window = None;
 414        if( ((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconBitmap )
 415        {
 416            DeleteObject( ((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconBitmap );
 417            ((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconBitmap = 0;
 418        }
 419        if( ((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconMask )
 420        {
 421            DeleteObject( ((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconMask);
 422            ((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconMask= 0;
 423        }
 424    }
 425
 426    return TRUE;
 427 }
 428
 429 /*****************************************************************
 430  *              X11DRV_WND_SetParent
 431  */
 432 WND *X11DRV_WND_SetParent(WND *wndPtr, WND *pWndParent)
 433 {
 434     WND *pDesktop = WIN_GetDesktop();
 435
 436     if( wndPtr && pWndParent && (wndPtr != pDesktop) )
 437     {
 438         WND* pWndPrev = wndPtr->parent;
 439
 440         if( pWndParent != pWndPrev )
 441         {
 442             if ( X11DRV_WND_GetXWindow(wndPtr) )
 443             {
 444                 /* Toplevel window needs to be reparented.  Used by Tk 8.0 */
 445
 446                 TSXDestroyWindow( display, X11DRV_WND_GetXWindow(wndPtr) );
 447                 ((X11DRV_WND_DATA *) wndPtr->pDriverData)->window = None;
 448             }
 449
 450             WIN_UnlinkWindow(wndPtr->hwndSelf);
 451             wndPtr->parent = pWndParent;
 452
 453             /* Create an X counterpart for reparented top-level windows
 454              * when not in the desktop mode. */
 455
 456             if( pWndParent == pDesktop )
 457             {
 458                 if( X11DRV_GetXRootWindow() == DefaultRootWindow(display) )
 459                 {
 460                     CREATESTRUCTA cs;
 461                     cs.lpCreateParams = NULL;
 462                     cs.hInstance = 0; /* not used in following call */
 463                     cs.hMenu = 0; /* not used in following call */
 464                     cs.hwndParent = pWndParent->hwndSelf;
 465                     cs.cy = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
 466                     if (!cs.cy)
 467                       cs.cy = 1;
 468                     cs.cx = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
 469                     if (!cs.cx)
 470                       cs.cx = 1;
 471                     cs.y = wndPtr->rectWindow.top;
 472                     cs.x = wndPtr->rectWindow.left;
 473                     cs.style = wndPtr->dwStyle;
 474                     cs.lpszName = 0; /* not used in following call */
 475                     cs.lpszClass = 0; /*not used in following call */
 476                     cs.dwExStyle = wndPtr->dwExStyle;
 477                     X11DRV_WND_CreateWindow(wndPtr, wndPtr->class,
 478                                             &cs, FALSE);
 479                 }
 480             }
 481             else /* a child window */
 482             {
 483                 if( !( wndPtr->dwStyle & WS_CHILD ) )
 484                 {
 485                     if( wndPtr->wIDmenu != 0)
 486                     {
 487                         DestroyMenu( (HMENU) wndPtr->wIDmenu );
 488                         wndPtr->wIDmenu = 0;
 489                     }
 490                 }
 491             }
 492             WIN_LinkWindow(wndPtr->hwndSelf, HWND_TOP);
 493         }
 494         WIN_ReleaseDesktop();
 495         return pWndPrev;
 496     } /* failure */
 497     WIN_ReleaseDesktop();
 498     return 0;
 499 }
 500
 501 /***********************************************************************
 502  *              X11DRV_WND_ForceWindowRaise
 503  *
 504  * Raise a window on top of the X stacking order, while preserving
 505  * the correct Windows Z order.
 506  */
 507 void X11DRV_WND_ForceWindowRaise(WND *wndPtr)
 508 {
 509   XWindowChanges winChanges;
 510   WND *wndPrev,*pDesktop = WIN_GetDesktop();
 511
 512   if( !wndPtr || !X11DRV_WND_GetXWindow(wndPtr) || (wndPtr->flags & WIN_MANAGED) )
 513   {
 514       WIN_ReleaseDesktop();
 515     return;
 516   }
 517
 518   /* Raise all windows up to wndPtr according to their Z order.
 519    * (it would be easier with sibling-related Below but it doesn't
 520    * work very well with SGI mwm for instance)
 521    */
 522   winChanges.stack_mode = Above;
 523   while (wndPtr)
 524     {
 525       if (X11DRV_WND_GetXWindow(wndPtr))
 526         TSXReconfigureWMWindow( display, X11DRV_WND_GetXWindow(wndPtr), 0,
 527                                 CWStackMode, &winChanges );
 528       wndPrev = pDesktop->child;
 529       if (wndPrev == wndPtr) break;
 530       while (wndPrev && (wndPrev->next != wndPtr)) wndPrev = wndPrev->next;
 531       wndPtr = wndPrev;
 532     }
 533   WIN_ReleaseDesktop();
 534 }
 535
 536 /***********************************************************************
 537  *              X11DRV_WND_FindDesktopXWindow   [Internal]
 538  *
 539  * Find the actual X window which needs be restacked.
 540  * Used by X11DRV_WND_SetWindowPos().
 541  */
 542 static Window X11DRV_WND_FindDesktopXWindow( WND *wndPtr )
 543 {
 544   if (!(wndPtr->flags & WIN_MANAGED))
 545     return X11DRV_WND_GetXWindow(wndPtr);
 546   else
 547     {
 548       Window window, root, parent, *children;
 549       int nchildren;
 550       window = X11DRV_WND_GetXWindow(wndPtr);
 551       for (;;)
 552         {
 553           TSXQueryTree( display, window, &root, &parent,
 554                         &children, &nchildren );
 555           TSXFree( children );
 556           if (parent == root)
 557             return window;
 558           window = parent;
 559         }
 560     }
 561 }
 562
 563 /***********************************************************************
 564  *           WINPOS_SetXWindowPos
 565  *
 566  * SetWindowPos() for an X window. Used by the real SetWindowPos().
 567  */
 568 void X11DRV_WND_SetWindowPos(WND *wndPtr, const WINDOWPOS *winpos, BOOL bChangePos)
 569 {
 570     XWindowChanges winChanges;
 571     int changeMask = 0;
 572     WND *winposPtr = WIN_FindWndPtr( winpos->hwnd );
 573     if ( !winposPtr ) return;
 574
 575     if(!wndPtr->hwndSelf) wndPtr = NULL; /* FIXME: WND destroyed, shouldn't happen!!! */
 576
 577     if (!(winpos->flags & SWP_SHOWWINDOW) && (winpos->flags & SWP_HIDEWINDOW))
 578     {
 579       if(X11DRV_WND_GetXWindow(wndPtr))
 580         TSXUnmapWindow( display, X11DRV_WND_GetXWindow(wndPtr) );
 581     }
 582
 583     if(bChangePos)
 584     {
 585         if ( !(winpos->flags & SWP_NOSIZE))
 586         {
 587           winChanges.width     = (winpos->cx > 0 ) ? winpos->cx : 1;
 588           winChanges.height    = (winpos->cy > 0 ) ? winpos->cy : 1;
 589           changeMask |= CWWidth | CWHeight;
 590
 591           /* Tweak dialog window size hints */
 592
 593           if ((winposPtr->flags & WIN_MANAGED) &&
 594                HAS_DLGFRAME(winposPtr->dwStyle,winposPtr->dwExStyle))
 595             {
 596               XSizeHints *size_hints = TSXAllocSizeHints();
 597
 598               if (size_hints)
 599                 {
 600                   long supplied_return;
 601
 602                   TSXGetWMSizeHints( display, X11DRV_WND_GetXWindow(winposPtr), size_hints,
 603                                      &supplied_return, XA_WM_NORMAL_HINTS);
 604                   size_hints->min_width = size_hints->max_width = winpos->cx;
 605                   size_hints->min_height = size_hints->max_height = winpos->cy;
 606                   TSXSetWMSizeHints( display, X11DRV_WND_GetXWindow(winposPtr), size_hints,
 607                                      XA_WM_NORMAL_HINTS );
 608                   TSXFree(size_hints);
 609                 }
 610             }
 611         }
 612         if (!(winpos->flags & SWP_NOMOVE))
 613         {
 614           winChanges.x = winpos->x;
 615           winChanges.y = winpos->y;
 616           changeMask |= CWX | CWY;
 617         }
 618         if (!(winpos->flags & SWP_NOZORDER))
 619         {
 620           winChanges.stack_mode = Below;
 621           changeMask |= CWStackMode;
 622
 623           if (winpos->hwndInsertAfter == HWND_TOP) winChanges.stack_mode = Above;
 624           else if (winpos->hwndInsertAfter != HWND_BOTTOM)
 625             {
 626               WND*   insertPtr = WIN_FindWndPtr( winpos->hwndInsertAfter );
 627               Window stack[2];
 628
 629               stack[0] = X11DRV_WND_FindDesktopXWindow( insertPtr );
 630               stack[1] = X11DRV_WND_FindDesktopXWindow( winposPtr );
 631
 632               /* for stupid window managers (i.e. all of them) */
 633
 634               TSXRestackWindows(display, stack, 2);
 635               changeMask &= ~CWStackMode;
 636
 637               WIN_ReleaseWndPtr(insertPtr);
 638             }
 639         }
 640         if (changeMask && X11DRV_WND_GetXWindow(winposPtr))
 641         {
 642             TSXReconfigureWMWindow( display, X11DRV_WND_GetXWindow(winposPtr), 0, changeMask, &winChanges );
 643             if( winposPtr->class->style & (CS_VREDRAW | CS_HREDRAW) )
 644                 X11DRV_WND_SetHostAttr( winposPtr, HAK_BITGRAVITY, BGForget );
 645         }
 646     }
 647
 648     if ( winpos->flags & SWP_SHOWWINDOW )
 649     {
 650         if(X11DRV_WND_GetXWindow(wndPtr))
 651            TSXMapWindow( display, X11DRV_WND_GetXWindow(wndPtr) );
 652     }
 653     WIN_ReleaseWndPtr(winposPtr);
 654 }
 655
 656 /*****************************************************************
 657  *              X11DRV_WND_SetText
 658  */
 659 void X11DRV_WND_SetText(WND *wndPtr, LPCSTR text)
 660 {
 661   if (!X11DRV_WND_GetXWindow(wndPtr))
 662     return;
 663
 664   TSXStoreName( display, X11DRV_WND_GetXWindow(wndPtr), text );
 665   TSXSetIconName( display, X11DRV_WND_GetXWindow(wndPtr), text );
 666 }
 667
 668 /*****************************************************************
 669  *              X11DRV_WND_SetFocus
 670  *
 671  * Set the X focus.
 672  * Explicit colormap management seems to work only with OLVWM.
 673  */
 674 void X11DRV_WND_SetFocus(WND *wndPtr)
 675 {
 676   HWND hwnd =  wndPtr->hwndSelf;
 677   XWindowAttributes win_attr;
 678   Window win;
 679   WND *w = wndPtr;
 680
 681   /* Only mess with the X focus if there's */
 682   /* no desktop window and if the window is not managed by the WM. */
 683   if ((X11DRV_GetXRootWindow() != DefaultRootWindow(display))) return;
 684   while (w && !((X11DRV_WND_DATA *) w->pDriverData)->window)
 685       w = w->parent;
 686   if (!w) w = wndPtr;
 687   if (w->flags & WIN_MANAGED) return;
 688
 689   if (!hwnd)    /* If setting the focus to 0, uninstall the colormap */
 690     {
 691       if (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_PRIVATE)
 692         TSXUninstallColormap( display, X11DRV_PALETTE_PaletteXColormap );
 693       return;
 694     }
 695
 696   /* Set X focus and install colormap */
 697
 698   if (!(win = X11DRV_WND_FindXWindow(wndPtr))) return;
 699   if (!TSXGetWindowAttributes( display, win, &win_attr ) ||
 700       (win_attr.map_state != IsViewable))
 701     return;  /* If window is not viewable, don't change anything */
 702
 703   TSXSetInputFocus( display, win, RevertToParent, CurrentTime );
 704   if (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_PRIVATE)
 705     TSXInstallColormap( display, X11DRV_PALETTE_PaletteXColormap );
 706
 707   EVENT_Synchronize();
 708 }
 709
 710 /*****************************************************************
 711  *              X11DRV_WND_PreSizeMove
 712  */
 713 void X11DRV_WND_PreSizeMove(WND *wndPtr)
 714 {
 715   if (!(wndPtr->dwStyle & WS_CHILD) && (X11DRV_GetXRootWindow() == DefaultRootWindow(display)))
 716     TSXGrabServer( display );
 717 }
 718
 719 /*****************************************************************
 720  *               X11DRV_WND_PostSizeMove
 721  */
 722 void X11DRV_WND_PostSizeMove(WND *wndPtr)
 723 {
 724   if (!(wndPtr->dwStyle & WS_CHILD) &&
 725       (X11DRV_GetXRootWindow() == DefaultRootWindow(display)))
 726     TSXUngrabServer( display );
 727 }
 728
 729 /*****************************************************************
 730  *               X11DRV_WND_SurfaceCopy
 731  *
 732  * Copies rect to (rect.left + dx, rect.top + dy).
 733  */
 734 void X11DRV_WND_SurfaceCopy(WND* wndPtr, DC *dcPtr, INT dx, INT dy,
 735                             const RECT *rect, BOOL bUpdate)
 736 {
 737     X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dcPtr->physDev;
 738     POINT dst, src;
 739
 740     dst.x = (src.x = dcPtr->w.DCOrgX + rect->left) + dx;
 741     dst.y = (src.y = dcPtr->w.DCOrgY + rect->top) + dy;
 742
 743     if (bUpdate) /* handles non-Wine windows hanging over the copied area */
 744         TSXSetGraphicsExposures( display, physDev->gc, True );
 745     TSXSetFunction( display, physDev->gc, GXcopy );
 746     TSXCopyArea( display, physDev->drawable, physDev->drawable,
 747                  physDev->gc, src.x, src.y,
 748                  rect->right - rect->left,
 749                  rect->bottom - rect->top,
 750                  dst.x, dst.y );
 751     if (bUpdate)
 752         TSXSetGraphicsExposures( display, physDev->gc, False );
 753
 754     if (bUpdate) /* Make sure exposure events have been processed */
 755         EVENT_Synchronize();
 756 }
 757
 758 /***********************************************************************
 759  *              X11DRV_WND_SetDrawable
 760  *
 761  * Set the drawable, origin and dimensions for the DC associated to
 762  * a given window.
 763  */
 764 void X11DRV_WND_SetDrawable(WND *wndPtr, DC *dc, WORD flags, BOOL bSetClipOrigin)
 765 {
 766     X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
 767     INT dcOrgXCopy = 0, dcOrgYCopy = 0;
 768     BOOL offsetClipRgn = FALSE;
 769
 770     if (!wndPtr)  /* Get a DC for the whole screen */
 771     {
 772         dc->w.DCOrgX = 0;
 773         dc->w.DCOrgY = 0;
 774         physDev->drawable = X11DRV_GetXRootWindow();
 775         TSXSetSubwindowMode( display, physDev->gc, IncludeInferiors );
 776     }
 777     else
 778     {
 779         /*
 780          * This function change the coordinate system (DCOrgX,DCOrgY)
 781          * values. When it moves the origin, other data like the current clipping
 782          * region will not be moved to that new origin. In the case of DCs that are class
 783          * or window DCs that clipping region might be a valid value from a previous use
 784          * of the DC and changing the origin of the DC without moving the clip region
 785          * results in a clip region that is not placed properly in the DC.
 786          * This code will save the dc origin, let the SetDrawable
 787          * modify the origin and reset the clipping. When the clipping is set,
 788          * it is moved according to the new DC origin.
 789          */
 790          if ( (wndPtr->class->style & (CS_OWNDC | CS_CLASSDC)) && (dc->w.hClipRgn > 0))
 791          {
 792              dcOrgXCopy = dc->w.DCOrgX;
 793              dcOrgYCopy = dc->w.DCOrgY;
 794              offsetClipRgn = TRUE;
 795          }
 796
 797         if (flags & DCX_WINDOW)
 798         {
 799             dc->w.DCOrgX  = wndPtr->rectWindow.left;
 800             dc->w.DCOrgY  = wndPtr->rectWindow.top;
 801         }
 802         else
 803         {
 804             dc->w.DCOrgX  = wndPtr->rectClient.left;
 805             dc->w.DCOrgY  = wndPtr->rectClient.top;
 806         }
 807         while (!X11DRV_WND_GetXWindow(wndPtr))
 808         {
 809             wndPtr = wndPtr->parent;
 810             dc->w.DCOrgX += wndPtr->rectClient.left;
 811             dc->w.DCOrgY += wndPtr->rectClient.top;
 812         }
 813         dc->w.DCOrgX -= wndPtr->rectWindow.left;
 814         dc->w.DCOrgY -= wndPtr->rectWindow.top;
 815
 816         /* reset the clip region, according to the new origin */
 817         if ( offsetClipRgn )
 818         {
 819              OffsetRgn(dc->w.hClipRgn, dc->w.DCOrgX - dcOrgXCopy,dc->w.DCOrgY - dcOrgYCopy);
 820         }
 821
 822         physDev->drawable = X11DRV_WND_GetXWindow(wndPtr);
 823
 824 #if 0
 825         /* This is needed when we reuse a cached DC because
 826          * SetDCState() called by ReleaseDC() screws up DC
 827          * origins for child windows.
 828          */
 829
 830         if( bSetClipOrigin )
 831             TSXSetClipOrigin( display, physDev->gc, dc->w.DCOrgX, dc->w.DCOrgY );
 832 #endif
 833     }
 834 }
 835
 836 /***********************************************************************
 837  *              X11DRV_SetWMHint
 838  */
 839 static BOOL X11DRV_SetWMHint(Display* display, WND* wndPtr, int hint, int val)
 840 {
 841     XWMHints* wm_hints = TSXGetWMHints( display, X11DRV_WND_GetXWindow(wndPtr) );
 842     if (!wm_hints) wm_hints = TSXAllocWMHints();
 843     if (wm_hints)
 844     {
 845         wm_hints->flags = hint;
 846         switch( hint )
 847         {
 848             case InputHint:
 849                  wm_hints->input = val;
 850                  break;
 851
 852             case StateHint:
 853                  wm_hints->initial_state = val;
 854                  break;
 855
 856             case IconPixmapHint:
 857                  wm_hints->icon_pixmap = (Pixmap)val;
 858                  break;
 859
 860             case IconWindowHint:
 861                  wm_hints->icon_window = (Window)val;
 862                  break;
 863         }
 864
 865         TSXSetWMHints( display, X11DRV_WND_GetXWindow(wndPtr), wm_hints );
 866         TSXFree(wm_hints);
 867         return TRUE;
 868     }
 869     return FALSE;
 870 }
 871
 872
 873 /***********************************************************************
 874  *              X11DRV_WND_SetHostAttr
 875  *
 876  * This function returns TRUE if the attribute is supported and the
 877  * action was successful. Otherwise it should return FALSE and Wine will try
 878  * to get by without the functionality provided by the host window system.
 879  */
 880 BOOL X11DRV_WND_SetHostAttr(WND* wnd, INT ha, INT value)
 881 {
 882     Window w;
 883
 884     if( (w = X11DRV_WND_GetXWindow(wnd)) )
 885     {
 886         XSetWindowAttributes win_attr;
 887
 888         switch( ha )
 889         {
 890         case HAK_ICONICSTATE: /* called when a window is minimized/restored */
 891
 892                     if( (wnd->flags & WIN_MANAGED) )
 893                     {
 894                         if( value )
 895                         {
 896                             if( wnd->dwStyle & WS_VISIBLE )
 897                             {
 898                                 XClientMessageEvent ev;
 899
 900                                 /* FIXME: set proper icon */
 901
 902                                 ev.type = ClientMessage;
 903                                 ev.display = display;
 904                                 ev.message_type = wmChangeState;
 905                                 ev.format = 32;
 906                                 ev.data.l[0] = IconicState;
 907                                 ev.window = w;
 908
 909                                 if( TSXSendEvent (display,
 910                 RootWindow( display, XScreenNumberOfScreen(X11DRV_GetXScreen()) ),
 911                 True, (SubstructureRedirectMask | SubstructureNotifyMask), (XEvent*)&ev))
 912                                 {
 913                                     XEvent xe;
 914                                     TSXFlush (display);
 915                                     while( !TSXCheckTypedWindowEvent( display, w, UnmapNotify, &xe) );
 916                                 }
 917                                 else
 918                                     break;
 919                             }
 920                             else
 921                                 X11DRV_SetWMHint( display, wnd, StateHint, IconicState );
 922                         }
 923                         else
 924                         {
 925                             if( !(wnd->flags & WS_VISIBLE) )
 926                                 X11DRV_SetWMHint( display, wnd, StateHint, NormalState );
 927                             else
 928                             {
 929                                 XEvent xe;
 930                                 TSXMapWindow(display, w );
 931                                 while( !TSXCheckTypedWindowEvent( display, w, MapNotify, &xe) );
 932                             }
 933                         }
 934                         return TRUE;
 935                     }
 936                     break;
 937
 938         case HAK_BITGRAVITY: /* called when a window is resized */
 939
 940                     if( ((X11DRV_WND_DATA *) wnd->pDriverData)->bit_gravity != value )
 941                     {
 942                         win_attr.bit_gravity = value;
 943                         ((X11DRV_WND_DATA *) wnd->pDriverData)->bit_gravity = value;
 944                         TSXChangeWindowAttributes( display, w, CWBitGravity, &win_attr );
 945                     }
 946                    return TRUE;
 947
 948         case HAK_ICONS: /* called when the icons change */
 949             if ( (wnd->flags & WIN_MANAGED) )
 950                 X11DRV_WND_UpdateIconHints(wnd);
 951             return TRUE;
 952
 953         case HAK_ACCEPTFOCUS: /* called when a window is disabled/enabled */
 954
 955                 if( (wnd->flags & WIN_MANAGED) )
 956                     return X11DRV_SetWMHint( display, wnd, InputHint, value );
 957         }
 958     }
 959     return FALSE;
 960 }
 961
 962 /***********************************************************************
 963  *              X11DRV_WND_IsSelfClipping
 964  */
 965 BOOL X11DRV_WND_IsSelfClipping(WND *wndPtr)
 966 {
 967   return X11DRV_WND_GetXWindow(wndPtr) != None;
 968 }
 969
 970 /***********************************************************************
 971  *              X11DRV_WND_DockWindow
 972  *
 973  * Set the X Property of the window that tells the windowmanager we really
 974  * want to be in the systray
 975  *
 976  * KDE: set "KWM_DOCKWINDOW", type "KWM_DOCKWINDOW" to 1 before a window is
 977  *      mapped.
 978  *
 979  * all others: to be added ;)
 980  */
 981 void X11DRV_WND_DockWindow(WND *wndPtr)
 982 {
 983   int data = 1;
 984   Window win = X11DRV_WND_GetXWindow(wndPtr);
 985   if (kwmDockWindow == None)
 986           return; /* no KDE running */
 987   TSXChangeProperty(
 988     display,win,kwmDockWindow,kwmDockWindow,32,PropModeReplace,(char*)&data,1
 989   );
 990 }
 991