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 #ifndef X_DISPLAY_MISSING
  12
  13 #include <X11/Xatom.h>
  14 #include "ts_xlib.h"
  15 #include "ts_xutil.h"
  16
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include "color.h"
  20 #include "display.h"
  21 #include "dce.h"
  22 #include "options.h"
  23 #include "message.h"
  24 #include "win.h"
  25 #include "windows.h"
  26 #include "x11drv.h"
  27
  28 /**********************************************************************/
  29
  30 extern Cursor DISPLAY_XCursor;  /* Current X cursor */
  31
  32 /**********************************************************************/
  33
  34 /* X context to associate a hwnd to an X window */
  35 XContext winContext = 0;
  36
  37 Atom wmProtocols = None;
  38 Atom wmDeleteWindow = None;
  39 Atom dndProtocol = None;
  40 Atom dndSelection = None;
  41
  42 /***********************************************************************
  43  *           X11DRV_WND_GetXWindow
  44  *
  45  * Return the X window associated to a window.
  46  */
  47 Window X11DRV_WND_GetXWindow(HWND32 hwnd)
  48 {
  49     WND *wndPtr = WIN_FindWndPtr( hwnd );
  50     while (wndPtr && !wndPtr->window) wndPtr = wndPtr->parent;
  51     return wndPtr ? wndPtr->window : 0;
  52 }
  53
  54 /***********************************************************************
  55  *              X11DRV_WND_RegisterWindow
  56  *
  57  * Associate an X window to a HWND.
  58  */
  59 static void X11DRV_WND_RegisterWindow(WND *pWnd)
  60 {
  61   TSXSetWMProtocols( display, pWnd->window, &wmDeleteWindow, 1 );
  62
  63   if (!winContext) winContext = TSXUniqueContext();
  64   TSXSaveContext( display, pWnd->window, winContext, (char *)pWnd );
  65 }
  66
  67 /**********************************************************************
  68  *              X11DRV_WND_CreateDesktopWindow
  69  */
  70 BOOL32 X11DRV_WND_CreateDesktopWindow(WND *wndPtr, CLASS *classPtr, BOOL32 bUnicode)
  71 {
  72     if (wmProtocols == None)
  73         wmProtocols = TSXInternAtom( display, "WM_PROTOCOLS", True );
  74     if (wmDeleteWindow == None)
  75         wmDeleteWindow = TSXInternAtom( display, "WM_DELETE_WINDOW", True );
  76     if( dndProtocol == None )
  77         dndProtocol = TSXInternAtom( display, "DndProtocol" , False );
  78     if( dndSelection == None )
  79         dndSelection = TSXInternAtom( display, "DndSelection" , False );
  80
  81     wndPtr->window = rootWindow;
  82     X11DRV_WND_RegisterWindow( wndPtr );
  83
  84     return TRUE;
  85 }
  86
  87 /**********************************************************************
  88  *              X11DRV_WND_CreateWindow
  89  */
  90 BOOL32 X11DRV_WND_CreateWindow(WND *wndPtr, CLASS *classPtr, CREATESTRUCT32A *cs, BOOL32 bUnicode)
  91 {
  92   /* Create the X window (only for top-level windows, and then only */
  93   /* when there's no desktop window) */
  94
  95   if (!(cs->style & WS_CHILD) && (rootWindow == DefaultRootWindow(display)))
  96     {
  97       XSetWindowAttributes win_attr;
  98
  99       if (Options.managed && ((cs->style & (WS_DLGFRAME | WS_THICKFRAME)) ||
 100                               (cs->dwExStyle & WS_EX_DLGMODALFRAME)))
 101         {
 102           win_attr.event_mask = ExposureMask | KeyPressMask |
 103             KeyReleaseMask | PointerMotionMask |
 104             ButtonPressMask | ButtonReleaseMask |
 105             FocusChangeMask | StructureNotifyMask;
 106           win_attr.override_redirect = FALSE;
 107           wndPtr->flags |= WIN_MANAGED;
 108         }
 109       else
 110         {
 111           win_attr.event_mask = ExposureMask | KeyPressMask |
 112             KeyReleaseMask | PointerMotionMask |
 113             ButtonPressMask | ButtonReleaseMask |
 114             FocusChangeMask;
 115           win_attr.override_redirect = TRUE;
 116         }
 117       win_attr.colormap      = COLOR_GetColormap();
 118       win_attr.backing_store = Options.backingstore ? WhenMapped : NotUseful;
 119       win_attr.save_under    = ((classPtr->style & CS_SAVEBITS) != 0);
 120       win_attr.cursor        = DISPLAY_XCursor;
 121       wndPtr->window = TSXCreateWindow( display, rootWindow, cs->x, cs->y,
 122                                         cs->cx, cs->cy, 0, CopyFromParent,
 123                                         InputOutput, CopyFromParent,
 124                                         CWEventMask | CWOverrideRedirect |
 125                                         CWColormap | CWCursor | CWSaveUnder |
 126                                         CWBackingStore, &win_attr );
 127
 128       if(!wndPtr->window)
 129         return FALSE;
 130
 131       if (wndPtr->flags & WIN_MANAGED) {
 132         XClassHint *class_hints = TSXAllocClassHint();
 133
 134         if (class_hints) {
 135           class_hints->res_name = "wineManaged";
 136           class_hints->res_class = "Wine";
 137           TSXSetClassHint( display, wndPtr->window, class_hints );
 138           TSXFree (class_hints);
 139         }
 140
 141         if (cs->dwExStyle & WS_EX_DLGMODALFRAME) {
 142           XSizeHints* size_hints = TSXAllocSizeHints();
 143
 144           if (size_hints) {
 145               size_hints->min_width = size_hints->max_width = cs->cx;
 146               size_hints->min_height = size_hints->max_height = cs->cy;
 147                 size_hints->flags = (PSize | PMinSize | PMaxSize);
 148                 TSXSetWMSizeHints( display, wndPtr->window, size_hints,
 149                                    XA_WM_NORMAL_HINTS );
 150                 TSXFree(size_hints);
 151             }
 152         }
 153       }
 154
 155       if (cs->hwndParent)  /* Get window owner */
 156         {
 157           Window win = X11DRV_WND_GetXWindow( cs->hwndParent );
 158           if (win) TSXSetTransientForHint( display, wndPtr->window, win );
 159         }
 160       X11DRV_WND_RegisterWindow( wndPtr );
 161     }
 162   return TRUE;
 163 }
 164
 165 /***********************************************************************
 166  *              X11DRV_WND_DestroyWindow
 167  */
 168 BOOL32 X11DRV_WND_DestroyWindow(WND *pWnd)
 169 {
 170    if (pWnd->window)
 171      {
 172        XEvent xe;
 173        TSXDeleteContext( display, pWnd->window, winContext );
 174        TSXDestroyWindow( display, pWnd->window );
 175        while( TSXCheckWindowEvent(display, pWnd->window, NoEventMask, &xe) );
 176        pWnd->window = None;
 177      }
 178
 179    return TRUE;
 180 }
 181
 182 /*****************************************************************
 183  *              X11DRV_WND_SetParent
 184  */
 185 WND *X11DRV_WND_SetParent(WND *wndPtr, WND *pWndParent)
 186 {
 187     if( wndPtr && pWndParent && (wndPtr != WIN_GetDesktop()) )
 188     {
 189         WND* pWndPrev = wndPtr->parent;
 190
 191         if( pWndParent != pWndPrev )
 192         {
 193             BOOL32 bFixupDCE = IsWindowVisible32(wndPtr->hwndSelf);
 194
 195             if ( wndPtr->window )
 196             {
 197                 /* Toplevel window needs to be reparented.  Used by Tk 8.0 */
 198
 199                 TSXDestroyWindow( display, wndPtr->window );
 200                 wndPtr->window = None;
 201             }
 202             else if( bFixupDCE )
 203                 DCE_InvalidateDCE( wndPtr, &wndPtr->rectWindow );
 204
 205             WIN_UnlinkWindow(wndPtr->hwndSelf);
 206             wndPtr->parent = pWndParent;
 207
 208             /* FIXME: Create an X counterpart for reparented top-level windows
 209              * when not in the desktop mode. */
 210
 211             if ( pWndParent != WIN_GetDesktop() ) wndPtr->dwStyle |= WS_CHILD;
 212             WIN_LinkWindow(wndPtr->hwndSelf, HWND_BOTTOM);
 213
 214             if( bFixupDCE )
 215             {
 216                 DCE_InvalidateDCE( wndPtr, &wndPtr->rectWindow );
 217                 UpdateWindow32(wndPtr->hwndSelf);
 218             }
 219         }
 220         return pWndPrev;
 221     } /* failure */
 222     return 0;
 223 }
 224
 225 /***********************************************************************
 226  *              X11DRV_WND_ForceWindowRaise
 227  *
 228  * Raise a window on top of the X stacking order, while preserving
 229  * the correct Windows Z order.
 230  */
 231 void X11DRV_WND_ForceWindowRaise(WND *pWnd)
 232 {
 233   XWindowChanges winChanges;
 234   WND *wndPrev;
 235
 236   if( !pWnd || !pWnd->window || (pWnd->flags & WIN_MANAGED) )
 237     return;
 238
 239   /* Raise all windows up to pWnd according to their Z order.
 240    * (it would be easier with sibling-related Below but it doesn't
 241    * work very well with SGI mwm for instance)
 242    */
 243   winChanges.stack_mode = Above;
 244   while (pWnd)
 245     {
 246       if (pWnd->window) TSXReconfigureWMWindow( display, pWnd->window, 0,
 247                                                 CWStackMode, &winChanges );
 248       wndPrev = WIN_GetDesktop()->child;
 249       if (wndPrev == pWnd) break;
 250       while (wndPrev && (wndPrev->next != pWnd)) wndPrev = wndPrev->next;
 251       pWnd = wndPrev;
 252     }
 253 }
 254
 255 /***********************************************************************
 256  *              X11DRV_WND_FindDesktopXWindow   [Internal]
 257  *
 258  * Find the actual X window which needs be restacked.
 259  * Used by X11DRV_SetWindowPos().
 260  */
 261 static Window X11DRV_WND_FindDesktopXWindow( WND *wndPtr )
 262 {
 263   if (!(wndPtr->flags & WIN_MANAGED))
 264     return wndPtr->window;
 265   else
 266     {
 267       Window window, root, parent, *children;
 268       int nchildren;
 269       window = wndPtr->window;
 270       for (;;)
 271         {
 272           TSXQueryTree( display, window, &root, &parent,
 273                         &children, &nchildren );
 274           TSXFree( children );
 275           if (parent == root)
 276             return window;
 277           window = parent;
 278         }
 279     }
 280 }
 281
 282 /***********************************************************************
 283  *           WINPOS_SetXWindowPos
 284  *
 285  * SetWindowPos() for an X window. Used by the real SetWindowPos().
 286  */
 287 void X11DRV_WND_SetWindowPos(WND *wndPtr, const WINDOWPOS32 *winpos, BOOL32 bSMC_SETXPOS)
 288 {
 289   XWindowChanges winChanges;
 290   int changeMask = 0;
 291   WND *winposPtr = WIN_FindWndPtr( winpos->hwnd );
 292
 293   if (!(winpos->flags & SWP_SHOWWINDOW) && (winpos->flags & SWP_HIDEWINDOW))
 294     {
 295       if(wndPtr && wndPtr->window) TSXUnmapWindow( display, wndPtr->window );
 296     }
 297
 298   if(bSMC_SETXPOS)
 299     {
 300       if ( !(winpos->flags & SWP_NOSIZE))
 301         {
 302           winChanges.width     = winpos->cx;
 303           winChanges.height    = winpos->cy;
 304           changeMask |= CWWidth | CWHeight;
 305
 306           /* Tweak dialog window size hints */
 307
 308           if ((winposPtr->flags & WIN_MANAGED) &&
 309               (winposPtr->dwExStyle & WS_EX_DLGMODALFRAME))
 310             {
 311               XSizeHints *size_hints = TSXAllocSizeHints();
 312
 313               if (size_hints)
 314                 {
 315                   long supplied_return;
 316
 317                   TSXGetWMSizeHints( display, winposPtr->window, size_hints,
 318                                      &supplied_return, XA_WM_NORMAL_HINTS);
 319                   size_hints->min_width = size_hints->max_width = winpos->cx;
 320                   size_hints->min_height = size_hints->max_height = winpos->cy;
 321                   TSXSetWMSizeHints( display, winposPtr->window, size_hints,
 322                                      XA_WM_NORMAL_HINTS );
 323                   TSXFree(size_hints);
 324                 }
 325             }
 326         }
 327       if (!(winpos->flags & SWP_NOMOVE))
 328         {
 329           winChanges.x = winpos->x;
 330           winChanges.y = winpos->y;
 331           changeMask |= CWX | CWY;
 332         }
 333       if (!(winpos->flags & SWP_NOZORDER))
 334         {
 335           winChanges.stack_mode = Below;
 336           changeMask |= CWStackMode;
 337
 338           if (winpos->hwndInsertAfter == HWND_TOP) winChanges.stack_mode = Above;
 339           else if (winpos->hwndInsertAfter != HWND_BOTTOM)
 340             {
 341               WND*   insertPtr = WIN_FindWndPtr( winpos->hwndInsertAfter );
 342               Window stack[2];
 343
 344               stack[0] = X11DRV_WND_FindDesktopXWindow( insertPtr );
 345               stack[1] = X11DRV_WND_FindDesktopXWindow( winposPtr );
 346
 347               /* for stupid window managers (i.e. all of them) */
 348
 349               TSXRestackWindows(display, stack, 2);
 350               changeMask &= ~CWStackMode;
 351             }
 352         }
 353       if (changeMask)
 354         {
 355           TSXReconfigureWMWindow( display, winposPtr->window, 0, changeMask, &winChanges );
 356         }
 357     }
 358
 359   if ( winpos->flags & SWP_SHOWWINDOW )
 360     {
 361       if(wndPtr && wndPtr->window) TSXMapWindow( display, wndPtr->window );
 362     }
 363 }
 364
 365 /*****************************************************************
 366  *              X11DRV_WND_SetText
 367  */
 368 void X11DRV_WND_SetText(WND *wndPtr, LPCSTR text)
 369 {
 370   if (!wndPtr->window)
 371     return;
 372
 373   TSXStoreName( display, wndPtr->window, text );
 374   TSXSetIconName( display, wndPtr->window, text );
 375 }
 376
 377 /*****************************************************************
 378  *              X11DRV_WND_SetFocus
 379  *
 380  * Set the X focus.
 381  * Explicit colormap management seems to work only with OLVWM.
 382  */
 383 void X11DRV_WND_SetFocus(WND *wndPtr)
 384 {
 385   HWND32 hwnd =  wndPtr->hwndSelf;
 386   XWindowAttributes win_attr;
 387
 388   /* Only mess with the X focus if there's */
 389   /* no desktop window and no window manager. */
 390   if ((rootWindow != DefaultRootWindow(display)) || Options.managed) return;
 391
 392   if (!hwnd)    /* If setting the focus to 0, uninstall the colormap */
 393     {
 394       if (COLOR_GetSystemPaletteFlags() & COLOR_PRIVATE)
 395         TSXUninstallColormap( display, COLOR_GetColormap() );
 396       return;
 397     }
 398
 399   /* Set X focus and install colormap */
 400
 401   if (!wndPtr->window) return;
 402
 403   if (!TSXGetWindowAttributes( display, wndPtr->window, &win_attr ) ||
 404       (win_attr.map_state != IsViewable))
 405     return;  /* If window is not viewable, don't change anything */
 406
 407   TSXSetInputFocus( display,wndPtr->window, RevertToParent, CurrentTime );
 408   if (COLOR_GetSystemPaletteFlags() & COLOR_PRIVATE)
 409     TSXInstallColormap( display, COLOR_GetColormap() );
 410
 411   EVENT_Synchronize();
 412 }
 413
 414 /*****************************************************************
 415  *              X11DRV_WND_PreSizeMove
 416  */
 417 void X11DRV_WND_PreSizeMove(WND *wndPtr)
 418 {
 419   if (!(wndPtr->dwStyle & WS_CHILD) && (rootWindow == DefaultRootWindow(display)))
 420     TSXGrabServer( display );
 421 }
 422
 423 /*****************************************************************
 424  *               X11DRV_WND_PostSizeMove
 425  */
 426 void X11DRV_WND_PostSizeMove(WND *wndPtr)
 427 {
 428   if (!(wndPtr->dwStyle & WS_CHILD) && (rootWindow == DefaultRootWindow(display)))
 429     TSXUngrabServer( display );
 430 }
 431
 432 #endif /* !defined(X_DISPLAY_MISSING) */