git.oblomov.eu Git - wine/blob - dlls/winex11.drv/x11ddraw.c

   1 /*
   2  * DirectDraw driver interface
   3  *
   4  * Copyright 2001 TransGaming Technologies, Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdarg.h>
  24 #include <string.h>
  25 #include <X11/Xlib.h>
  26
  27 #define NONAMELESSUNION
  28 #define NONAMELESSSTRUCT
  29 #include "x11drv.h"
  30
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "wingdi.h"
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(x11drv);
  37
  38 typedef struct _X11DRIVERINFO {
  39   const GUID *          lpGuid;
  40   DWORD                 dwSize;
  41   LPVOID                lpvData;
  42   struct _X11DRIVERINFO*lpNext;
  43 } X11DRIVERINFO,*LPX11DRIVERINFO;
  44
  45 typedef struct _X11DEVICE {
  46   LPX11DRIVERINFO       lpInfo;
  47 } X11DEVICE,*LPX11DEVICE;
  48
  49 extern int dxgrab;
  50
  51 static LPDDRAWI_DDRAWSURFACE_LCL X11DRV_DD_Primary;
  52 static LPDDRAWI_DDRAWSURFACE_GBL X11DRV_DD_PrimaryGbl;
  53 static HWND X11DRV_DD_PrimaryWnd;
  54 static HBITMAP X11DRV_DD_PrimaryDIB;
  55 static Drawable X11DRV_DD_PrimaryDrawable;
  56 static ATOM X11DRV_DD_UserClass;
  57 static UINT X11DRV_DD_GrabMessage;
  58 static WNDPROC X11DRV_DD_GrabOldProcedure;
  59
  60 static void X11DRV_DDHAL_SetPalEntries(Colormap pal, DWORD dwBase, DWORD dwNumEntries,
  61                                        LPPALETTEENTRY lpEntries);
  62
  63 static void SetPrimaryDIB(HBITMAP hBmp)
  64 {
  65   X11DRV_DD_PrimaryDIB = hBmp;
  66   if (hBmp) {
  67     X11DRV_DD_PrimaryDrawable = X11DRV_get_pixmap( hBmp );
  68   } else {
  69     X11DRV_DD_PrimaryDrawable = 0;
  70   }
  71 }
  72
  73 static LRESULT WINAPI GrabWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  74 {
  75   struct x11drv_thread_data *data = x11drv_thread_data();
  76
  77   if(message != X11DRV_DD_GrabMessage)
  78     return CallWindowProcA(X11DRV_DD_GrabOldProcedure, hWnd, message, wParam, lParam);
  79
  80   TRACE("hwnd=%p, grab=%d\n", hWnd, wParam);
  81
  82   if (wParam)
  83   {
  84     /* find the X11 window that ddraw uses */
  85     Window win = X11DRV_get_whole_window(hWnd);
  86     TRACE("X11 window: %ld\n", win);
  87     if (!win) {
  88       TRACE("host off desktop\n");
  89       win = root_window;
  90     }
  91
  92     wine_tsx11_lock();
  93     XGrabPointer(data->display, win, True, 0, GrabModeAsync, GrabModeAsync, win, None, CurrentTime);
  94     wine_tsx11_unlock();
  95     data->grab_window = win;
  96   }
  97   else
  98   {
  99     wine_tsx11_lock();
 100     XUngrabPointer(data->display, CurrentTime);
 101     wine_tsx11_unlock();
 102     data->grab_window = None;
 103   }
 104
 105   return 0;
 106 }
 107
 108 static void GrabPointer(BOOL grab)
 109 {
 110   if(grab) {
 111     Window window = X11DRV_get_whole_window(GetFocus());
 112     if(window)
 113     {
 114       wine_tsx11_lock();
 115       XSetInputFocus(thread_display(), window, RevertToParent, CurrentTime);
 116       wine_tsx11_unlock();
 117     }
 118   }
 119
 120   if(!X11DRV_DD_GrabMessage)
 121     X11DRV_DD_GrabMessage = RegisterWindowMessageA("WINE_X11DRV_GRABPOINTER");
 122
 123   X11DRV_DD_GrabOldProcedure = (WNDPROC)SetWindowLongPtrA(X11DRV_DD_PrimaryWnd,
 124                                                        GWLP_WNDPROC, (LONG_PTR)GrabWndProc);
 125
 126   SendMessageW(X11DRV_DD_PrimaryWnd, X11DRV_DD_GrabMessage, grab, 0);
 127
 128   if(SetWindowLongPtrA(X11DRV_DD_PrimaryWnd, GWLP_WNDPROC,
 129                     (LONG_PTR)X11DRV_DD_GrabOldProcedure) != (LONG_PTR)GrabWndProc)
 130     ERR("Window procedure has been changed!\n");
 131 }
 132
 133 static DWORD PASCAL X11DRV_DDHAL_DestroyDriver(LPDDHAL_DESTROYDRIVERDATA data)
 134 {
 135   data->ddRVal = DD_OK;
 136   return DDHAL_DRIVER_HANDLED;
 137 }
 138
 139 static DWORD PASCAL X11DRV_DDHAL_CreateSurface(LPDDHAL_CREATESURFACEDATA data)
 140 {
 141   if (data->lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) {
 142     X11DRV_DD_Primary = *data->lplpSList;
 143     X11DRV_DD_PrimaryWnd = (HWND)X11DRV_DD_Primary->lpSurfMore->lpDDRAWReserved;
 144     X11DRV_DD_PrimaryGbl = X11DRV_DD_Primary->lpGbl;
 145     SetPrimaryDIB((HBITMAP)GET_LPDDRAWSURFACE_GBL_MORE(X11DRV_DD_PrimaryGbl)->hKernelSurface);
 146     X11DRV_DD_UserClass = GlobalFindAtomA("WINE_DDRAW");
 147     if (dxgrab) GrabPointer(TRUE);
 148   }
 149   data->ddRVal = DD_OK;
 150   return DDHAL_DRIVER_NOTHANDLED;
 151 }
 152
 153 static DWORD PASCAL X11DRV_DDHAL_CreatePalette(LPDDHAL_CREATEPALETTEDATA data)
 154 {
 155   FIXME("stub\n");
 156   /* only makes sense to do anything if the X server is running at 8bpp,
 157    * which few people do nowadays */
 158   data->ddRVal = DD_OK;
 159   return DDHAL_DRIVER_HANDLED;
 160 }
 161
 162 static DDHAL_DDCALLBACKS hal_ddcallbacks = {
 163   sizeof(DDHAL_DDCALLBACKS),
 164   0x3ff, /* all callbacks are 32-bit */
 165   X11DRV_DDHAL_DestroyDriver,
 166   X11DRV_DDHAL_CreateSurface,
 167   NULL, /* SetColorKey */
 168   NULL, /* SetMode */
 169   NULL, /* WaitForVerticalBlank */
 170   NULL, /* CanCreateSurface */
 171   X11DRV_DDHAL_CreatePalette,
 172   NULL, /* GetScanLine */
 173   NULL, /* SetExclusiveMode */
 174   NULL  /* FlipToGDISurface */
 175 };
 176
 177 static DWORD PASCAL X11DRV_DDHAL_DestroySurface(LPDDHAL_DESTROYSURFACEDATA data)
 178 {
 179   if (data->lpDDSurface == X11DRV_DD_Primary) {
 180     if (dxgrab) GrabPointer(FALSE);
 181     X11DRV_DD_Primary = NULL;
 182     X11DRV_DD_PrimaryWnd = 0;
 183     X11DRV_DD_PrimaryGbl = NULL;
 184     SetPrimaryDIB(0);
 185     X11DRV_DD_UserClass = 0;
 186   }
 187   data->ddRVal = DD_OK;
 188   return DDHAL_DRIVER_HANDLED;
 189 }
 190
 191 static DWORD PASCAL X11DRV_DDHAL_SetPalette(LPDDHAL_SETPALETTEDATA data)
 192 {
 193   if (data->lpDDPalette && data->lpDDPalette->u1.dwReserved1) {
 194     if (data->lpDDSurface == X11DRV_DD_Primary) {
 195       FIXME("stub\n");
 196       /* we should probably find the ddraw window (maybe data->lpDD->lpExclusiveOwner->hWnd),
 197        * and attach the palette to it
 198        *
 199        * Colormap pal = data->lpDDPalette->u1.dwReserved1;
 200        */
 201     }
 202   }
 203   data->ddRVal = DD_OK;
 204   return DDHAL_DRIVER_HANDLED;
 205 }
 206
 207 static DDHAL_DDSURFACECALLBACKS hal_ddsurfcallbacks = {
 208   sizeof(DDHAL_DDSURFACECALLBACKS),
 209   0x3fff, /* all callbacks are 32-bit */
 210   X11DRV_DDHAL_DestroySurface,
 211   NULL, /* Flip */
 212   NULL, /* SetClipList */
 213   NULL, /* Lock */
 214   NULL, /* Unlock */
 215   NULL, /* Blt */
 216   NULL, /* SetColorKey */
 217   NULL, /* AddAttachedSurface */
 218   NULL, /* GetBltStatus */
 219   NULL, /* GetFlipStatus */
 220   NULL, /* UpdateOverlay */
 221   NULL, /* SetOverlayPosition */
 222   NULL, /* reserved4 */
 223   X11DRV_DDHAL_SetPalette
 224 };
 225
 226 static DWORD PASCAL X11DRV_DDHAL_DestroyPalette(LPDDHAL_DESTROYPALETTEDATA data)
 227 {
 228   Colormap pal = data->lpDDPalette->u1.dwReserved1;
 229   if (pal)
 230   {
 231       wine_tsx11_lock();
 232       XFreeColormap(gdi_display, pal);
 233       wine_tsx11_unlock();
 234   }
 235   data->ddRVal = DD_OK;
 236   return DDHAL_DRIVER_HANDLED;
 237 }
 238
 239 static DWORD PASCAL X11DRV_DDHAL_SetPaletteEntries(LPDDHAL_SETENTRIESDATA data)
 240 {
 241   X11DRV_DDHAL_SetPalEntries(data->lpDDPalette->u1.dwReserved1,
 242                              data->dwBase, data->dwNumEntries,
 243                              data->lpEntries);
 244   data->ddRVal = DD_OK;
 245   return DDHAL_DRIVER_HANDLED;
 246 }
 247
 248 static DDHAL_DDPALETTECALLBACKS hal_ddpalcallbacks = {
 249   sizeof(DDHAL_DDPALETTECALLBACKS),
 250   0x3, /* all callbacks are 32-bit */
 251   X11DRV_DDHAL_DestroyPalette,
 252   X11DRV_DDHAL_SetPaletteEntries
 253 };
 254
 255 static X11DEVICE x11device = {
 256   NULL
 257 };
 258
 259 static DWORD PASCAL X11DRV_DDHAL_GetDriverInfo(LPDDHAL_GETDRIVERINFODATA data)
 260 {
 261   LPX11DRIVERINFO info = x11device.lpInfo;
 262   while (info) {
 263     if (IsEqualGUID(&data->guidInfo, info->lpGuid)) {
 264       DWORD dwSize = info->dwSize;
 265       data->dwActualSize = dwSize;
 266       if (data->dwExpectedSize < dwSize) dwSize = data->dwExpectedSize;
 267       memcpy(data->lpvData, info->lpvData, dwSize);
 268       data->ddRVal = DD_OK;
 269       return DDHAL_DRIVER_HANDLED;
 270     }
 271     info = info->lpNext;
 272   }
 273   data->ddRVal = DDERR_CURRENTLYNOTAVAIL;
 274   return DDHAL_DRIVER_HANDLED;
 275 }
 276
 277 static DDHALINFO hal_info = {
 278   sizeof(DDHALINFO),
 279   &hal_ddcallbacks,
 280   &hal_ddsurfcallbacks,
 281   &hal_ddpalcallbacks,
 282   {     /* vmiData */
 283    0     /* fpPrimary */
 284   },
 285   {     /* ddCaps (only stuff the HAL implements here) */
 286    sizeof(DDCORECAPS),                                                  /* dwSize */
 287    DDCAPS_GDI | DDCAPS_PALETTE,                                         /* dwCaps */
 288    DDCAPS2_CERTIFIED | DDCAPS2_NONLOCALVIDMEM | DDCAPS2_NOPAGELOCKREQUIRED | DDCAPS2_CANRENDERWINDOWED |
 289    DDCAPS2_WIDESURFACES | DDCAPS2_PRIMARYGAMMA | DDCAPS2_FLIPNOVSYNC,   /* dwCaps2 */
 290    0,                                                                   /* dwCKeyCaps */
 291    0,                                                                   /* dwFXCaps */
 292    0,                                                                   /* dwFXAlphaCaps */
 293    DDPCAPS_8BIT | DDPCAPS_PRIMARYSURFACE,                               /* dwPalCaps */
 294    0,                                                                   /* dwSVCaps */
 295    0,                                                                   /* dwAlphaBltConstBitDepths */
 296    0,                                                                   /* dwAlphaBltPixelBitDepths */
 297    0,                                                                   /* dwAlphaBltSurfaceBitDepths */
 298    0,                                                                   /* dwAlphaOverlayBltConstBitDepths */
 299    0,                                                                   /* dwAlphaOverlayBltPixelBitDepths */
 300    0,                                                                   /* dwAlphaOverlayBltSurfaceBitDepths */
 301    0,                                                                   /* dwZBufferBitDepths */
 302    16*1024*1024,                                                        /* dwVidMemTotal */
 303    16*1024*1024,                                                        /* dwVidMemFree */
 304    0,                                                                   /* dwMaxVisibleOverlays */
 305    0,                                                                   /* dwCurrVisibleOverlays */
 306    0,                                                                   /* dwNumFourCCCodes */
 307    0,                                                                   /* dwAlignBoundarySrc */
 308    0,                                                                   /* dwAlignSizeSrc */
 309    0,                                                                   /* dwAlignBoundaryDest */
 310    0,                                                                   /* dwAlignSizeDest */
 311    0,                                                                   /* dwAlignStrideAlign */
 312    {0},                                                                 /* dwRops */
 313    {                                                                    /* ddsCaps */
 314     DDSCAPS_BACKBUFFER | DDSCAPS_FLIP | DDSCAPS_FRONTBUFFER |
 315     DDSCAPS_OFFSCREENPLAIN | DDSCAPS_PALETTE | DDSCAPS_PRIMARYSURFACE |
 316     DDSCAPS_SYSTEMMEMORY | DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY |
 317     DDSCAPS_VISIBLE | DDSCAPS_LOCALVIDMEM | DDSCAPS_NONLOCALVIDMEM      /* dwCaps */
 318    },
 319    0,                                                                   /* dwMinOverlayStretch */
 320    0,                                                                   /* dwMaxOverlayStretch */
 321    0,                                                                   /* dwMinLiveVideoStretch */
 322    0,                                                                   /* dwMaxLiveVideoStretch */
 323    0,                                                                   /* dwMinHwCodecStretch */
 324    0,                                                                   /* dwMaxHwCodecStretch */
 325    0,                                                                   /* dwReserved1 */
 326    0,                                                                   /* dwReserved2 */
 327    0,                                                                   /* dwReserved2 */
 328    0,                                                                   /* dwSVBCaps */
 329    0,                                                                   /* dwSVBCKeyCaps */
 330    0,                                                                   /* dwSVBFXCaps */
 331    {0},                                                                 /* dwSVBRops */
 332    0,                                                                   /* dwVSBCaps */
 333    0,                                                                   /* dwVSBCKeyCaps */
 334    0,                                                                   /* dwVSBFXCaps */
 335    {0},                                                                 /* dwVSBRops */
 336    0,                                                                   /* dwSSBCaps */
 337    0,                                                                   /* dwSSBCKeyCaps */
 338    0,                                                                   /* dwSSBFXCaps */
 339    {0},                                                                 /* dwSSBRops */
 340    0,                                                                   /* dwMaxVideoPorts */
 341    0,                                                                   /* dwCurrVideoPorts */
 342    0                                                                    /* dwSVBCaps */
 343   },
 344   0,    /* dwMonitorFrequency */
 345   X11DRV_DDHAL_GetDriverInfo,
 346   0,    /* dwModeIndex */
 347   NULL, /* lpdwFourCC */
 348   0,    /* dwNumModes */
 349   NULL, /* lpModeInfo */
 350   DDHALINFO_ISPRIMARYDISPLAY | DDHALINFO_MODEXILLEGAL | DDHALINFO_GETDRIVERINFOSET, /* dwFlags */
 351   &x11device,
 352   0,    /* hInstance */
 353   0,    /* lpD3DGlobalDriverData */
 354   0,    /* lpD3DHALCallbacks */
 355   NULL  /* lpDDExeBufCallbacks */
 356 };
 357
 358 static LPDDHALDDRAWFNS ddraw_fns;
 359 static DWORD ddraw_ver;
 360
 361 static void X11DRV_DDHAL_SetInfo(void)
 362 {
 363   (ddraw_fns->lpSetInfo)(&hal_info, FALSE);
 364 }
 365
 366 INT X11DRV_DCICommand(INT cbInput, const DCICMD *lpCmd, LPVOID lpOutData)
 367 {
 368   TRACE("(%d,(%d,%d,%d),%p)\n", cbInput, lpCmd->dwCommand,
 369         lpCmd->dwParam1, lpCmd->dwParam2, lpOutData);
 370
 371   switch (lpCmd->dwCommand) {
 372   case DDNEWCALLBACKFNS:
 373     ddraw_fns = (LPDDHALDDRAWFNS)lpCmd->dwParam1;
 374     return TRUE;
 375   case DDVERSIONINFO:
 376     {
 377       LPDDVERSIONDATA lpVer = (LPDDVERSIONDATA)lpOutData;
 378       ddraw_ver = lpCmd->dwParam1;
 379       if (!lpVer) break;
 380       /* well, whatever... the DDK says so */
 381       lpVer->dwHALVersion = DD_RUNTIME_VERSION;
 382     }
 383     return TRUE;
 384   case DDGET32BITDRIVERNAME:
 385     {
 386       LPDD32BITDRIVERDATA lpData = (LPDD32BITDRIVERDATA)lpOutData;
 387       /* here, we could ask ddraw to load a separate DLL, that
 388        * would contain the 32-bit ddraw HAL */
 389       strcpy(lpData->szName,"x11drv");
 390       /* the entry point named here should initialize our hal_info
 391        * with 32-bit entry points (ignored for now) */
 392       strcpy(lpData->szEntryPoint,"DriverInit");
 393       lpData->dwContext = 0;
 394     }
 395     return TRUE;
 396   case DDCREATEDRIVEROBJECT:
 397     {
 398       LPDWORD lpInstance = (LPDWORD)lpOutData;
 399
 400       /* FIXME: get x11drv's hInstance */
 401       X11DRV_Settings_CreateDriver(&hal_info);
 402 #ifdef HAVE_OPENGL
 403       /*X11DRV_GLX_CreateDriver(&hal_info);*/
 404 #endif
 405
 406       (ddraw_fns->lpSetInfo)(&hal_info, FALSE);
 407       *lpInstance = hal_info.hInstance;
 408     }
 409     return TRUE;
 410   }
 411   return 0;
 412 }
 413
 414 void X11DRV_DDHAL_SwitchMode(DWORD dwModeIndex, LPVOID fb_addr, LPVIDMEM fb_mem)
 415 {
 416   LPDDHALMODEINFO info = &hal_info.lpModeInfo[dwModeIndex];
 417
 418   hal_info.dwModeIndex        = dwModeIndex;
 419   hal_info.dwMonitorFrequency = info->wRefreshRate;
 420   hal_info.vmiData.fpPrimary  = (FLATPTR)fb_addr;
 421   hal_info.vmiData.dwDisplayWidth  = info->dwWidth;
 422   hal_info.vmiData.dwDisplayHeight = info->dwHeight;
 423   hal_info.vmiData.lDisplayPitch   = info->lPitch;
 424   hal_info.vmiData.ddpfDisplay.dwSize = info->dwBPP ? sizeof(hal_info.vmiData.ddpfDisplay) : 0;
 425   hal_info.vmiData.ddpfDisplay.dwFlags = (info->wFlags & DDMODEINFO_PALETTIZED) ? DDPF_PALETTEINDEXED8 : 0;
 426   hal_info.vmiData.ddpfDisplay.u1.dwRGBBitCount = (info->dwBPP > 24) ? 24 : info->dwBPP;
 427   hal_info.vmiData.ddpfDisplay.u2.dwRBitMask = info->dwRBitMask;
 428   hal_info.vmiData.ddpfDisplay.u3.dwGBitMask = info->dwGBitMask;
 429   hal_info.vmiData.ddpfDisplay.u4.dwBBitMask = info->dwBBitMask;
 430   hal_info.vmiData.dwNumHeaps = fb_mem ? 1 : 0;
 431   hal_info.vmiData.pvmList = fb_mem;
 432
 433   X11DRV_DDHAL_SetInfo();
 434 }
 435
 436 static void X11DRV_DDHAL_SetPalEntries(Colormap pal, DWORD dwBase, DWORD dwNumEntries,
 437                                        LPPALETTEENTRY lpEntries)
 438 {
 439   XColor c;
 440   unsigned int n;
 441
 442   if (pal) {
 443     wine_tsx11_lock();
 444     c.flags = DoRed|DoGreen|DoBlue;
 445     c.pixel = dwBase;
 446     for (n=0; n<dwNumEntries; n++,c.pixel++) {
 447       c.red   = lpEntries[n].peRed   << 8;
 448       c.green = lpEntries[n].peGreen << 8;
 449       c.blue  = lpEntries[n].peBlue  << 8;
 450       XStoreColor(gdi_display, pal, &c);
 451     }
 452     XFlush(gdi_display); /* update display immediately */
 453     wine_tsx11_unlock();
 454   }
 455 }