dlls/ddraw/ddraw/user.c

   1 /*      DirectDraw driver for User-based primary surfaces
   2  *
   3  * Copyright 2000-2001 TransGaming Technologies Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 #include "config.h"
  21
  22 #include <assert.h>
  23 #include <stdarg.h>
  24 #include <string.h>
  25
  26 #define NONAMELESSUNION
  27 #define NONAMELESSSTRUCT
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "wingdi.h"
  31 #include "winuser.h"
  32 #include "ddraw.h"
  33 #include "ddraw_private.h"
  34 #include "ddraw/main.h"
  35 #include "ddraw/user.h"
  36 #include "dclipper/main.h"
  37 #include "dpalette/main.h"
  38 #include "dsurface/main.h"
  39 #include "dsurface/dib.h"
  40 #include "dsurface/user.h"
  41 #include "wine/debug.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
  44
  45 static IDirectDraw7Vtbl User_DirectDraw_VTable;
  46
  47 static const DDDEVICEIDENTIFIER2 user_device =
  48 {
  49     "display",
  50     "User (and GDI)",
  51     { { 0x00010001, 0x00010001 } },
  52     0, 0, 0, 0,
  53     /* fe38440c-8969-4283-bc73-749e7bc3c2eb */
  54     {0xfe38440c,0x8969,0x428e, {0x73,0xbc,0x74,0x9e,0x7b,0xc3,0xc2,0xeb}},
  55     0
  56 };
  57
  58 static const DDPIXELFORMAT pixelformats[] =
  59 {
  60     /* 8bpp paletted */
  61     { sizeof(DDPIXELFORMAT), DDPF_RGB|DDPF_PALETTEINDEXED8, 0, { 8 } },
  62     /* 15bpp 5/5/5 */
  63     { sizeof(DDPIXELFORMAT), DDPF_RGB, 0, { 16 }, { 0x7C00 }, { 0x3E0 },
  64       { 0x1F } },
  65     /* 16bpp 5/6/5 */
  66     { sizeof(DDPIXELFORMAT), DDPF_RGB, 0, { 16 }, { 0xF800 }, { 0x7E0 },
  67       { 0x1F } },
  68     /* 24bpp 8/8/8 */
  69     { sizeof(DDPIXELFORMAT), DDPF_RGB, 0, { 24 }, { 0xFF0000 },
  70       { 0x00FF00 }, { 0x0000FF } },
  71     /* 32bpp 8/8/8 */
  72     { sizeof(DDPIXELFORMAT), DDPF_RGB, 0, { 32 }, { 0xFF0000 },
  73       { 0x00FF00 }, { 0x0000FF } }
  74 };
  75
  76 HRESULT User_DirectDraw_Create(const GUID* pGUID, LPDIRECTDRAW7* pIface,
  77                                      IUnknown* pUnkOuter, BOOL ex);
  78 HRESULT User_DirectDraw_Initialize(IDirectDrawImpl*, const GUID*);
  79
  80 static const ddraw_driver user_driver =
  81 {
  82     &user_device,
  83     10,
  84     User_DirectDraw_Create,
  85     User_DirectDraw_Initialize
  86 };
  87
  88 BOOL DDRAW_User_Init(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
  89 {
  90     if (fdwReason == DLL_PROCESS_ATTACH)
  91         DDRAW_register_driver(&user_driver);
  92
  93     return TRUE;
  94 }
  95
  96 static const DDPIXELFORMAT* pixelformat_for_depth(DWORD depth)
  97 {
  98     switch (depth)
  99     {
 100     case  8: return pixelformats + 0;
 101     case 15: return pixelformats + 1;
 102     case 16: return pixelformats + 2;
 103     case 24: return pixelformats + 3;
 104     case 32: return pixelformats + 4;
 105     default: return NULL;
 106     }
 107 }
 108
 109 /* Not called from the vtable. */
 110 HRESULT User_DirectDraw_Construct(IDirectDrawImpl *This, BOOL ex)
 111 {
 112     HRESULT hr;
 113     DWORD depth;
 114     HDC hDC;
 115
 116     TRACE("(%p,%d)\n",This,ex);
 117
 118     hr = Main_DirectDraw_Construct(This, ex);
 119     if (FAILED(hr)) return hr;
 120
 121     This->final_release = User_DirectDraw_final_release;
 122
 123     This->create_primary    = User_DirectDraw_create_primary;
 124     This->create_backbuffer = User_DirectDraw_create_backbuffer;
 125
 126     hDC = CreateDCA("DISPLAY", NULL, NULL, NULL);
 127     depth = GetDeviceCaps(hDC, BITSPIXEL) * GetDeviceCaps(hDC, PLANES);
 128     DeleteDC(hDC);
 129
 130     This->width       = GetSystemMetrics(SM_CXSCREEN);
 131     This->height      = GetSystemMetrics(SM_CYSCREEN);
 132     This->pitch       = DDRAW_width_bpp_to_pitch(This->width, depth);
 133     This->pixelformat = *pixelformat_for_depth(depth);
 134
 135     This->orig_width       = This->width;
 136     This->orig_height      = This->height;
 137     This->orig_pitch       = This->pitch;
 138     This->orig_pixelformat = This->pixelformat;
 139
 140     ICOM_INIT_INTERFACE(This, IDirectDraw7, User_DirectDraw_VTable);
 141
 142     /* capabilities */
 143 #define BLIT_CAPS (DDCAPS_BLT | DDCAPS_BLTCOLORFILL | DDCAPS_BLTDEPTHFILL \
 144           | DDCAPS_BLTSTRETCH | DDCAPS_CANBLTSYSMEM | DDCAPS_CANCLIP      \
 145           | DDCAPS_CANCLIPSTRETCHED | DDCAPS_COLORKEY                     \
 146           | DDCAPS_COLORKEYHWASSIST)
 147 #define CKEY_CAPS (DDCKEYCAPS_DESTBLT | DDCKEYCAPS_SRCBLT)
 148 #define FX_CAPS (DDFXCAPS_BLTALPHA | DDFXCAPS_BLTMIRRORLEFTRIGHT        \
 149                 | DDFXCAPS_BLTMIRRORUPDOWN | DDFXCAPS_BLTROTATION90     \
 150                 | DDFXCAPS_BLTSHRINKX | DDFXCAPS_BLTSHRINKXN            \
 151                 | DDFXCAPS_BLTSHRINKY | DDFXCAPS_BLTSHRINKXN            \
 152                 | DDFXCAPS_BLTSTRETCHX | DDFXCAPS_BLTSTRETCHXN          \
 153                 | DDFXCAPS_BLTSTRETCHY | DDFXCAPS_BLTSTRETCHYN)
 154     This->caps.dwCaps |= DDCAPS_GDI | DDCAPS_PALETTE | BLIT_CAPS;
 155     if( opengl_initialized )
 156     {
 157         /* Hack for D3D code */
 158         This->caps.dwCaps |= DDCAPS_3D;
 159     }
 160     This->caps.dwCaps2 |= DDCAPS2_CERTIFIED | DDCAPS2_NOPAGELOCKREQUIRED |
 161                           DDCAPS2_PRIMARYGAMMA | DDCAPS2_WIDESURFACES;
 162     This->caps.dwCKeyCaps |= CKEY_CAPS;
 163     This->caps.dwFXCaps |= FX_CAPS;
 164     This->caps.dwPalCaps |= DDPCAPS_8BIT | DDPCAPS_PRIMARYSURFACE;
 165     This->caps.dwVidMemTotal = 16*1024*1024;
 166     This->caps.dwVidMemFree = 16*1024*1024;
 167     This->caps.dwSVBCaps |= BLIT_CAPS;
 168     This->caps.dwSVBCKeyCaps |= CKEY_CAPS;
 169     This->caps.dwSVBFXCaps |= FX_CAPS;
 170     This->caps.dwVSBCaps |= BLIT_CAPS;
 171     This->caps.dwVSBCKeyCaps |= CKEY_CAPS;
 172     This->caps.dwVSBFXCaps |= FX_CAPS;
 173     This->caps.dwSSBCaps |= BLIT_CAPS;
 174     This->caps.dwSSBCKeyCaps |= CKEY_CAPS;
 175     This->caps.dwSSBFXCaps |= FX_CAPS;
 176     This->caps.ddsCaps.dwCaps |= DDSCAPS_ALPHA | DDSCAPS_BACKBUFFER |
 177                                  DDSCAPS_FLIP | DDSCAPS_FRONTBUFFER |
 178                                  DDSCAPS_OFFSCREENPLAIN | DDSCAPS_PALETTE |
 179                                  DDSCAPS_PRIMARYSURFACE | DDSCAPS_SYSTEMMEMORY |
 180                                  DDSCAPS_VIDEOMEMORY | DDSCAPS_VISIBLE;
 181     if( opengl_initialized )
 182     {
 183         /* Hacks for D3D code */
 184         This->caps.ddsCaps.dwCaps |= DDSCAPS_3DDEVICE | DDSCAPS_MIPMAP | DDSCAPS_TEXTURE | DDSCAPS_ZBUFFER;
 185     }
 186
 187     This->caps.ddsOldCaps.dwCaps = This->caps.ddsCaps.dwCaps;
 188 #undef BLIT_CAPS
 189 #undef CKEY_CAPS
 190 #undef FX_CAPS
 191
 192     return S_OK;
 193 }
 194
 195 /* This function is called from DirectDrawCreate(Ex) on the most-derived
 196  * class to start construction.
 197  * Not called from the vtable. */
 198 HRESULT User_DirectDraw_Create(const GUID* pGUID, LPDIRECTDRAW7* pIface,
 199                                IUnknown* pUnkOuter, BOOL ex)
 200 {
 201     HRESULT hr;
 202     IDirectDrawImpl* This;
 203
 204     assert(pUnkOuter == NULL);
 205
 206     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 207                      sizeof(IDirectDrawImpl) + sizeof(User_DirectDrawImpl));
 208     if (This == NULL) return E_OUTOFMEMORY;
 209
 210     /* Note that this relation does *not* hold true if the DD object was
 211      * CoCreateInstanced then Initialized. */
 212     This->private = (User_DirectDrawImpl *)(This+1);
 213
 214     /* Initialize the DDCAPS structure */
 215     This->caps.dwSize = sizeof(This->caps);
 216
 217     hr = User_DirectDraw_Construct(This, ex);
 218     if (FAILED(hr))
 219         HeapFree(GetProcessHeap(), 0, This);
 220     else
 221         *pIface = ICOM_INTERFACE(This, IDirectDraw7);
 222
 223     return hr;
 224 }
 225
 226 /* This function is called from Uninit_DirectDraw_Initialize on the
 227  * most-derived-class to start initialization.
 228  * Not called from the vtable. */
 229 HRESULT User_DirectDraw_Initialize(IDirectDrawImpl *This, const GUID* guid)
 230 {
 231     HRESULT hr;
 232     This->private = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 233                               sizeof(User_DirectDrawImpl));
 234     if (This->private == NULL) return E_OUTOFMEMORY;
 235
 236     /* Initialize the DDCAPS structure */
 237     This->caps.dwSize = sizeof(This->caps);
 238
 239     hr = User_DirectDraw_Construct(This, TRUE); /* XXX ex? */
 240     if (FAILED(hr))
 241     {
 242         HeapFree(GetProcessHeap(), 0, This->private);
 243         return hr;
 244     }
 245
 246     return DD_OK;
 247 }
 248
 249 /* Called from an internal function pointer. */
 250 void User_DirectDraw_final_release(IDirectDrawImpl *This)
 251 {
 252     Main_DirectDraw_final_release(This);
 253 }
 254
 255 /* Compact: generic */
 256 /* CreateClipper: generic */
 257 /* CreatePalette: generic (with callback) */
 258 /* CreateSurface: generic (with callbacks) */
 259
 260 HRESULT
 261 User_DirectDraw_create_primary(IDirectDrawImpl* This,
 262                                const DDSURFACEDESC2* pDDSD,
 263                                LPDIRECTDRAWSURFACE7* ppSurf,
 264                                IUnknown* pUnkOuter)
 265 {
 266     return User_DirectDrawSurface_Create(This, pDDSD, ppSurf, pUnkOuter);
 267 }
 268
 269 HRESULT
 270 User_DirectDraw_create_backbuffer(IDirectDrawImpl* This,
 271                                   const DDSURFACEDESC2* pDDSD,
 272                                   LPDIRECTDRAWSURFACE7* ppSurf,
 273                                   IUnknown* pUnkOuter,
 274                                   IDirectDrawSurfaceImpl* primary)
 275 {
 276     return User_DirectDrawSurface_Create(This, pDDSD, ppSurf, pUnkOuter);
 277 }
 278
 279 /* DuplicateSurface: generic */
 280
 281 /* Originally derived from Xlib_IDirectDraw2Impl_EnumDisplayModes.
 282  *
 283  * The depths are whatever DIBsections support on the client side.
 284  * Should they be limited by screen depth?
 285  */
 286 HRESULT WINAPI
 287 User_DirectDraw_EnumDisplayModes(LPDIRECTDRAW7 iface, DWORD dwFlags,
 288                                  LPDDSURFACEDESC2 pDDSD, LPVOID context,
 289                                  LPDDENUMMODESCALLBACK2 callback)
 290 {
 291     DDSURFACEDESC2 callback_sd;
 292     DEVMODEW DevModeW;
 293     const DDPIXELFORMAT* pixelformat;
 294
 295     int i;
 296
 297     TRACE("(%p)->(0x%08lx,%p,%p,%p)\n",iface,dwFlags,pDDSD,context,callback);
 298
 299     ZeroMemory(&callback_sd, sizeof(callback_sd));
 300     callback_sd.dwSize = sizeof(callback_sd);
 301
 302     callback_sd.dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT|DDSD_CAPS
 303         | DDSD_PITCH;
 304
 305     if (dwFlags & DDEDM_REFRESHRATES)
 306         callback_sd.dwFlags |= DDSD_REFRESHRATE;
 307
 308     callback_sd.u2.dwRefreshRate = 60.0;
 309
 310     i = 0;
 311     while (EnumDisplaySettingsExW(NULL, i, &DevModeW, 0))
 312     {
 313         callback_sd.dwHeight = DevModeW.dmPelsHeight;
 314         callback_sd.dwWidth = DevModeW.dmPelsWidth;
 315         if (DevModeW.dmFields&DM_DISPLAYFREQUENCY)
 316         {
 317             callback_sd.u2.dwRefreshRate = DevModeW.dmDisplayFrequency;
 318         }
 319
 320         TRACE("- mode: %ldx%ld\n", callback_sd.dwWidth, callback_sd.dwHeight);
 321
 322         pixelformat = pixelformat_for_depth(DevModeW.dmBitsPerPel);
 323         callback_sd.u1.lPitch
 324             = DDRAW_width_bpp_to_pitch(DevModeW.dmPelsWidth,
 325                                        pixelformat->u1.dwRGBBitCount);
 326
 327         callback_sd.u4.ddpfPixelFormat = *pixelformat;
 328
 329         callback_sd.ddsCaps.dwCaps = 0;
 330         if (pixelformat->dwFlags & DDPF_PALETTEINDEXED8) /* ick */
 331             callback_sd.ddsCaps.dwCaps |= DDSCAPS_PALETTE;
 332
 333         TRACE(" - %2ld bpp, R=%08lx G=%08lx B=%08lx\n",
 334             callback_sd.u4.ddpfPixelFormat.u1.dwRGBBitCount,
 335             callback_sd.u4.ddpfPixelFormat.u2.dwRBitMask,
 336             callback_sd.u4.ddpfPixelFormat.u3.dwGBitMask,
 337             callback_sd.u4.ddpfPixelFormat.u4.dwBBitMask);
 338         if (callback(&callback_sd, context) == DDENUMRET_CANCEL)
 339             return DD_OK;
 340         i++;
 341     }
 342
 343     return DD_OK;
 344 }
 345
 346 /* EnumSurfaces: generic */
 347 /* FlipToGDISurface: ??? */
 348
 349 #if 0
 350 HRESULT WINAPI
 351 User_DirectDraw_GetCaps(LPDIRECTDRAW7 iface, LPDDCAPS pDriverCaps,
 352                         LPDDCAPS pHELCaps)
 353 {
 354 /* Based on my guesses for what is appropriate with some clues from the
 355  * NVidia driver. Not everything is actually implemented yet.
 356  * NV has but we don't: Overlays, Video Ports, DDCAPS_READSCANLINE,
 357  * DDCAPS2_CERTIFIED (heh), DDSCAPS2_NONLOCALVIDMEM, DDSCAPS2_COPYFOURCC.
 358  * It actually has no FX alpha caps.
 359  * Oddly, it doesn't list DDPCAPS_PRIMARYSURFACE.
 360  * And the HEL caps make little sense.
 361  */
 362 #define BLIT_CAPS (DDCAPS_BLT | DDCAPS_BLTCOLORFILL | DDCAPS_BLTDEPTHFILL \
 363           | DDCAPS_BLTSTRETCH | DDCAPS_CANBLTSYSMEM | DDCAPS_CANCLIP      \
 364           | DDCAPS_CANCLIPSTRETCHED | DDCAPS_COLORKEY                     \
 365           | DDCAPS_COLORKEYHWASSIST)
 366
 367 #define CKEY_CAPS (DDCKEYCAPS_DESTBLT | DDCKEYCAPS_SRCBLT)
 368
 369 #define FX_CAPS (DDFXCAPS_BLTALPHA | DDFXCAPS_BLTMIRRORLEFTRIGHT        \
 370                 | DDFXCAPS_BLTMIRRORUPDOWN | DDFXCAPS_BLTROTATION90     \
 371                 | DDFXCAPS_BLTSHRINKX | DDFXCAPS_BLTSHRINKXN            \
 372                 | DDFXCAPS_BLTSHRINKY | DDFXCAPS_BLTSHRINKXN            \
 373                 | DDFXCAPS_BLTSTRETCHX | DDFXCAPS_BLTSTRETCHXN          \
 374                 | DDFXCAPS_BLTSTRETCHY | DDFXCAPS_BLTSTRETCHYN)
 375
 376 #if 0
 377 #define ROPS { SRCCOPY, SRCPAINT, SRCAND, SRCINVERT, SRCERASE, NOTSRCCOPY, \
 378         NOTSRCERASE, MERGEPAINT, BLACKNESS, WHITENESS, }
 379 #else
 380 #define ROPS { 0, }
 381 #endif
 382
 383     static const DDCAPS caps =
 384     { sizeof(DDCAPS),
 385       DDCAPS_3D | DDCAPS_GDI | DDCAPS_PALETTE | BLIT_CAPS,
 386       DDCAPS2_CANMANAGETEXTURE | DDCAPS2_CANRENDERWINDOWED | DDCAPS2_CERTIFIED
 387       | DDCAPS2_NOPAGELOCKREQUIRED | DDCAPS2_PRIMARYGAMMA
 388       | DDCAPS2_WIDESURFACES,
 389       CKEY_CAPS,
 390       FX_CAPS,
 391       0, /* dwFXAlphaCaps */
 392       DDPCAPS_8BIT | DDPCAPS_PRIMARYSURFACE,
 393       0, /* dwSVCaps */
 394       0, /* ? dwAlphaBitConstBitDepths */
 395       0, /* ? dwAlphaBitPixelPitDepths */
 396       0, /* ? dwAlphaBltSurfaceBitDepths */
 397       0, /* ? dwAlphaOverlayConstBitDepths */
 398       0, /* ? dwAlphaOverlayPixelBitDepths */
 399       0, /* ? dwAlphaOverlaySurfaceBitDepths */
 400       DDBD_16, /* ? dwZBufferBitDepths */
 401       16*1024*1024, /* dwVidMemTotal */
 402       16*1024*1024, /* dwVidMemFree */
 403       0, /* dwMaxVisibleOverlays */
 404       0, /* dwCurrVisibleOverlays */
 405       0, /* dwNumFourCCCodes */
 406       0, /* dwAlignBoundarySrc */
 407       0, /* dwAlignSizeSrc */
 408       0, /* dwAlignBoundaryDest */
 409       0, /* dwAlignSizeDest */
 410       0, /* dwAlignStrideAlign */
 411       ROPS, /* XXX dwRops[DD_ROP_SPACE] */
 412       { 0, }, /* XXX ddsOldCaps */
 413       1000, /* dwMinOverlayStretch */
 414       1000, /* dwMaxOverlayStretch */
 415       1000, /* dwMinLiveVideoStretch */
 416       1000, /* dwMaxLiveVideoStretch */
 417       1000, /* dwMinHwCodecStretch */
 418       1000, /* dwMaxHwCodecStretch */
 419       0, 0, 0, /* dwReserved1, 2, 3 */
 420       BLIT_CAPS, /* dwSVBCaps */
 421       CKEY_CAPS, /* dwSVBCKeyCaps */
 422       FX_CAPS, /* dwSVBFXCaps */
 423       ROPS, /* dwSVBRops */
 424       BLIT_CAPS, /* dwVSBCaps */
 425       CKEY_CAPS, /* dwVSBCKeyCaps */
 426       FX_CAPS, /* dwVSBFXCaps */
 427       ROPS, /* dwVSBRops */
 428       BLIT_CAPS, /* dwSSBCaps */
 429       CKEY_CAPS, /* dwSSBCKeyCaps */
 430       FX_CAPS, /* dwSSBFXCaps */
 431       ROPS, /* dwSSBRops */
 432       0, /* dwMaxVideoPorts */
 433       0, /* dwCurrVideoPorts */
 434       0, /* ? dwSVBCaps2 */
 435       BLIT_CAPS, /* ? dwNLVBCaps */
 436       0, /* ? dwNLVBCaps2 */
 437       CKEY_CAPS, /* dwNLVBCKeyCaps */
 438       FX_CAPS, /* dwNLVBFXCaps */
 439       ROPS, /* dwNLVBRops */
 440       { /* ddsCaps */
 441           DDSCAPS_3DDEVICE | DDSCAPS_ALPHA | DDSCAPS_BACKBUFFER | DDSCAPS_FLIP
 442           | DDSCAPS_FRONTBUFFER | DDSCAPS_MIPMAP | DDSCAPS_OFFSCREENPLAIN
 443           | DDSCAPS_PALETTE | DDSCAPS_PRIMARYSURFACE | DDSCAPS_SYSTEMMEMORY
 444           | DDSCAPS_TEXTURE | DDSCAPS_VIDEOMEMORY | DDSCAPS_VISIBLE
 445           | DDSCAPS_ZBUFFER,
 446           DDSCAPS2_CUBEMAP,
 447           0,
 448           0
 449       }
 450     };
 451
 452 #undef BLIT_CAPS
 453 #undef CKEY_CAPS
 454 #undef FX_CAPS
 455 #undef ROPS
 456
 457     ICOM_THIS(IDirectDrawImpl, iface);
 458
 459     TRACE("(%p)->(%p,%p)\n",This,pDriverCaps,pHELCaps);
 460
 461     if (pDriverCaps != NULL)
 462         DD_STRUCT_COPY_BYSIZE(pDriverCaps,&caps);
 463
 464     if (pHELCaps != NULL)
 465         DD_STRUCT_COPY_BYSIZE(pHELCaps,&caps);
 466
 467     return DD_OK;
 468 }
 469 #endif
 470
 471 HRESULT WINAPI
 472 User_DirectDraw_GetDeviceIdentifier(LPDIRECTDRAW7 iface,
 473                                     LPDDDEVICEIDENTIFIER2 pDDDI,
 474                                     DWORD dwFlags)
 475 {
 476     TRACE("(%p)->(%p,%08lx)\n",iface,pDDDI,dwFlags);
 477     *pDDDI = user_device;
 478     return DD_OK;
 479 }
 480
 481 /* GetDisplayMode: generic */
 482 /* GetFourCCCodes: generic */
 483 /* GetGDISurface: ??? */
 484 /* GetMonitorFrequency: generic */
 485 /* GetScanLine: generic */
 486 /* GetSurfaceFromDC: generic */
 487 /* GetVerticalBlankStatus: generic */
 488 /* Initialize: generic */
 489 /* RestoreAllSurfaces: generic */
 490 /* RestoreDisplayMode: generic */
 491 /* SetCooperativeLevel: ??? */
 492
 493 HRESULT WINAPI
 494 User_DirectDraw_SetDisplayMode(LPDIRECTDRAW7 iface, DWORD dwWidth,
 495                                DWORD dwHeight, DWORD dwBPP,
 496                                DWORD dwRefreshRate, DWORD dwFlags)
 497 {
 498     ICOM_THIS(IDirectDrawImpl, iface);
 499
 500     const DDPIXELFORMAT* pixelformat;
 501     DEVMODEW devmode;
 502     LONG pitch;
 503
 504     TRACE("(%p)->(%ldx%ldx%ld,%ld Hz,%08lx)\n",This,dwWidth,dwHeight,dwBPP,dwRefreshRate,dwFlags);
 505     devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
 506     devmode.dmBitsPerPel = dwBPP;
 507     devmode.dmPelsWidth  = dwWidth;
 508     devmode.dmPelsHeight = dwHeight;
 509     if (ChangeDisplaySettingsExW(NULL, &devmode, NULL, CDS_FULLSCREEN, NULL) != DISP_CHANGE_SUCCESSFUL)
 510         return DDERR_INVALIDMODE;
 511
 512     pixelformat = pixelformat_for_depth(dwBPP);
 513     if (pixelformat == NULL)
 514     {
 515         assert(0);
 516         return DDERR_GENERIC;
 517     }
 518
 519     pitch = DDRAW_width_bpp_to_pitch(dwWidth, dwBPP);
 520     return Main_DirectDraw_SetDisplayMode(iface, dwWidth, dwHeight, pitch,
 521                                           dwRefreshRate, dwFlags, pixelformat);
 522 }
 523
 524 /* StartModeTest: ??? */
 525 /* TestCooperativeLevel: generic? */
 526 /* WaitForVerticalBlank: ??? */
 527
 528 static IDirectDraw7Vtbl User_DirectDraw_VTable =
 529 {
 530     Main_DirectDraw_QueryInterface,
 531     Main_DirectDraw_AddRef,
 532     Main_DirectDraw_Release,
 533     Main_DirectDraw_Compact,
 534     Main_DirectDraw_CreateClipper,
 535     Main_DirectDraw_CreatePalette,
 536     Main_DirectDraw_CreateSurface,
 537     Main_DirectDraw_DuplicateSurface,
 538     User_DirectDraw_EnumDisplayModes,
 539     Main_DirectDraw_EnumSurfaces,
 540     Main_DirectDraw_FlipToGDISurface,
 541     Main_DirectDraw_GetCaps,
 542     Main_DirectDraw_GetDisplayMode,
 543     Main_DirectDraw_GetFourCCCodes,
 544     Main_DirectDraw_GetGDISurface,
 545     Main_DirectDraw_GetMonitorFrequency,
 546     Main_DirectDraw_GetScanLine,
 547     Main_DirectDraw_GetVerticalBlankStatus,
 548     Main_DirectDraw_Initialize,
 549     Main_DirectDraw_RestoreDisplayMode,
 550     Main_DirectDraw_SetCooperativeLevel,
 551     User_DirectDraw_SetDisplayMode,
 552     Main_DirectDraw_WaitForVerticalBlank,
 553     Main_DirectDraw_GetAvailableVidMem,
 554     Main_DirectDraw_GetSurfaceFromDC,
 555     Main_DirectDraw_RestoreAllSurfaces,
 556     Main_DirectDraw_TestCooperativeLevel,
 557     User_DirectDraw_GetDeviceIdentifier,
 558     Main_DirectDraw_StartModeTest,
 559     Main_DirectDraw_EvaluateMode
 560 };