ddraw_main.c 52.8 KB
Newer Older
1 2 3 4
/*		DirectDraw IDirectDraw interface (generic)
 *
 * Copyright 1997-2000 Marcus Meissner
 * Copyright 1998-2000 Lionel Ulmer (most of Direct3D stuff)
5
 * Copyright 2000-2001 TransGaming Technologies Inc.
6 7 8 9 10 11 12 13 14 15 16 17 18 19
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
 *
 * NOTES
 *
 * WINE currently implements a very basic set of the DirectDraw functionality
 * in graphics/ddraw.c. This implementation uses either the XFree86-DGA extension 
 * to get very fast access to the graphics card framebuffer and doublebuffering
 * features or Xlib, which is slower.
 * The implementation using XFree86-DGA is as fast as the MS equivalent for the
 * stuff that is implemented.
 *
 * Several applications already work, see below.
 * Problems of the implementation using XFree86-DGA:
 *
 *	- XFree86 cannot switch depth on the fly.
 *	  This is a problem with X and unavoidable.
 *	  Current solution is to pop up a MessageBox with an error for 
 *	  mismatched parameters and advice the user to restart the X server
 *	  with the specified depth.
 *	- The rest of the functionality that has to be implemented will have
 *	  to be done in software and will be very slow.
 *	- This requires WINE to be run as root user so XF86DGA can mmap the
 *	  framebuffer into the addressspace of the process.
 *	- Blocks all other X windowed applications.
 *
44
 * This file contains all the interface functions that are shared between
45 46
 * all interfaces. Or better, it is a "common stub" library for the
 * IDirectDraw* objects
47 48 49
 */

#include "config.h"
50
#include "wine/port.h"
51 52

#include <assert.h>
53
#include <stdarg.h>
54 55
#include <string.h>

56 57
#define NONAMELESSUNION
#define NONAMELESSSTRUCT
58

59
#include "winerror.h"
60 61 62
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
63 64
#include "ddraw.h"
#include "d3d.h"
65
#include "wine/debug.h"
66 67

#include "ddraw_private.h"
68
#include "opengl_private.h" /* To have the D3D creation function */
69

70
WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
71

72 73 74
extern const IDirectDrawVtbl DDRAW_IDirectDraw_VTable;
extern const IDirectDraw2Vtbl DDRAW_IDirectDraw2_VTable;
extern const IDirectDraw4Vtbl DDRAW_IDirectDraw4_VTable;
75 76 77 78 79 80 81 82

static void DDRAW_UnsubclassWindow(IDirectDrawImpl* This);

static void Main_DirectDraw_DeleteSurfaces(IDirectDrawImpl* This);
static void Main_DirectDraw_DeleteClippers(IDirectDrawImpl* This);
static void Main_DirectDraw_DeletePalettes(IDirectDrawImpl* This);
static void LosePrimarySurface(IDirectDrawImpl* This);

83 84 85 86
static INT32 allocate_memory(IDirectDrawImpl *This, DWORD mem) ;
static void free_memory(IDirectDrawImpl *This, DWORD mem) ;


87 88 89 90 91 92 93 94 95
static const char ddProp[] = "WINE_DDRAW_Property";

/* Not called from the vtable. */
HRESULT Main_DirectDraw_Construct(IDirectDrawImpl *This, BOOL ex)
{
    /* NOTE: The creator must use HEAP_ZERO_MEMORY or equivalent. */
    This->ref = 1;
    This->ex = ex;

96 97 98
    if (ex) This->local.dwLocalFlags |= DDRAWILCL_DIRECTDRAW7;
    This->local.dwProcessId = GetCurrentProcessId();

99 100 101 102 103 104 105 106 107 108 109 110 111
    This->final_release = Main_DirectDraw_final_release;

    This->create_palette = Main_DirectDrawPalette_Create;

    This->create_offscreen = Main_create_offscreen;
    This->create_texture   = Main_create_texture;
    This->create_zbuffer   = Main_create_zbuffer;
    /* There are no generic versions of create_{primary,backbuffer}. */

    ICOM_INIT_INTERFACE(This, IDirectDraw,  DDRAW_IDirectDraw_VTable);
    ICOM_INIT_INTERFACE(This, IDirectDraw2, DDRAW_IDirectDraw2_VTable);
    ICOM_INIT_INTERFACE(This, IDirectDraw4, DDRAW_IDirectDraw4_VTable);
    /* There is no generic implementation of IDD7 */
112

113 114 115
    /* This is for the moment here... */
    This->free_memory = free_memory;
    This->allocate_memory = allocate_memory;
116
    This->total_vidmem = 64 * 1024 * 1024;
117 118
    This->available_vidmem = This->total_vidmem;
      
119 120 121
    return DD_OK;
}

122 123 124 125 126 127 128 129 130
void Main_DirectDraw_final_release(IDirectDrawImpl* This)
{
    if (IsWindow(This->window))
    {
	if (GetPropA(This->window, ddProp))
	    DDRAW_UnsubclassWindow(This);
	else
	    FIXME("this shouldn't happen, right?\n");
    }
131

132 133 134
    Main_DirectDraw_DeleteSurfaces(This);
    Main_DirectDraw_DeleteClippers(This);
    Main_DirectDraw_DeletePalettes(This);
135 136 137 138 139 140
    if (This->local.lpGbl && This->local.lpGbl->lpExclusiveOwner == &This->local)
    {
	This->local.lpGbl->lpExclusiveOwner = NULL;
	if (This->set_exclusive_mode)
	    This->set_exclusive_mode(This, FALSE);
    }
141 142
}

143 144 145
/* There is no Main_DirectDraw_Create. */

ULONG WINAPI Main_DirectDraw_AddRef(LPDIRECTDRAW7 iface) {
146
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
147
    ULONG ref = InterlockedIncrement(&This->ref);
148

149 150 151
    TRACE("(%p)->() incrementing from %lu.\n", This, ref -1);

    return ref;
152 153 154
}

ULONG WINAPI Main_DirectDraw_Release(LPDIRECTDRAW7 iface) {
155
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
156
    ULONG ref = InterlockedDecrement(&This->ref);
157

158
    TRACE("(%p)->() decrementing from %lu.\n", This, ref +1);
159 160 161 162 163 164 165 166 167 168

    if (ref == 0)
    {
	if (This->final_release != NULL)
	    This->final_release(This);

	/* We free the private. This is an artifact of the fact that I don't
	 * have the destructors set up correctly. */
	if (This->private != (This+1))
	    HeapFree(GetProcessHeap(), 0, This->private);
169

170
	HeapFree(GetProcessHeap(), 0, This);
171
    }
172 173 174 175 176 177 178

    return ref;
}

HRESULT WINAPI Main_DirectDraw_QueryInterface(
    LPDIRECTDRAW7 iface,REFIID refiid,LPVOID *obj
) {
179
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
180 181
    TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(refiid), obj);

182 183 184
    /* According to COM docs, if the QueryInterface fails, obj should be set to NULL */
    *obj = NULL;
    
185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202
    if ( IsEqualGUID( &IID_IUnknown, refiid )
	 || IsEqualGUID( &IID_IDirectDraw7, refiid ) )
    {
	*obj = ICOM_INTERFACE(This, IDirectDraw7);
    }
    else if ( IsEqualGUID( &IID_IDirectDraw, refiid ) )
    {
	*obj = ICOM_INTERFACE(This, IDirectDraw);
    }
    else if ( IsEqualGUID( &IID_IDirectDraw2, refiid ) )
    {
	*obj = ICOM_INTERFACE(This, IDirectDraw2);
    }
    else if ( IsEqualGUID( &IID_IDirectDraw4, refiid ) )
    {
	*obj = ICOM_INTERFACE(This, IDirectDraw4);
    }
#ifdef HAVE_OPENGL
203 204 205 206
    else if ( IsEqualGUID( &IID_IDirect3D  , refiid ) ||
	      IsEqualGUID( &IID_IDirect3D2 , refiid ) ||
	      IsEqualGUID( &IID_IDirect3D3 , refiid ) ||
	      IsEqualGUID( &IID_IDirect3D7 , refiid ) )
207
    {
208 209 210
        if (opengl_initialized) {
	    HRESULT ret_value;

211
	    ret_value = direct3d_create(This);
212 213 214
	    if (FAILED(ret_value)) return ret_value;
	    
	    if ( IsEqualGUID( &IID_IDirect3D  , refiid ) ) {
215
	        *obj = ICOM_INTERFACE(This, IDirect3D);
216 217
		TRACE(" returning Direct3D interface at %p.\n", *obj);	    
	    } else if ( IsEqualGUID( &IID_IDirect3D2  , refiid ) ) {
218
	        *obj = ICOM_INTERFACE(This, IDirect3D2);
219 220
		TRACE(" returning Direct3D2 interface at %p.\n", *obj);	    
	    } else if ( IsEqualGUID( &IID_IDirect3D3  , refiid ) ) {
221
	        *obj = ICOM_INTERFACE(This, IDirect3D3);
222 223
		TRACE(" returning Direct3D3 interface at %p.\n", *obj);	    
	    } else {
224
	        *obj = ICOM_INTERFACE(This, IDirect3D7);
225 226
		TRACE(" returning Direct3D7 interface at %p.\n", *obj);	    
	    }
227
	} else {
228 229 230
	    ERR("Application requests a Direct3D interface but dynamic OpenGL support loading failed !\n");
	    ERR("(%p)->(%s,%p): no interface\n",This,debugstr_guid(refiid),obj);
	    return E_NOINTERFACE;
231
	}
232 233 234 235 236 237 238 239 240 241
    }
#else
    else if ( IsEqualGUID( &IID_IDirect3D  , refiid ) ||
	      IsEqualGUID( &IID_IDirect3D2 , refiid ) ||
	      IsEqualGUID( &IID_IDirect3D3 , refiid ) ||
	      IsEqualGUID( &IID_IDirect3D7 , refiid ) )
    {
        ERR("Application requests a Direct3D interface but OpenGL support not built-in !\n");
	ERR("(%p)->(%s,%p): no interface\n",This,debugstr_guid(refiid),obj);
	return E_NOINTERFACE;
242
    }
243 244 245 246 247 248 249 250 251
#endif
    else
    {
	FIXME("(%p)->(%s,%p): no interface\n",This,debugstr_guid(refiid),obj);
	return E_NOINTERFACE;
    }

    IDirectDraw7_AddRef(iface);
    return S_OK;
252 253
}

254 255 256 257
/* MSDN: "not currently implemented". */
HRESULT WINAPI Main_DirectDraw_Compact(LPDIRECTDRAW7 iface)
{
    TRACE("(%p)\n", iface);
258

259 260 261 262 263 264 265 266
    return DD_OK;
}

HRESULT WINAPI Main_DirectDraw_CreateClipper(LPDIRECTDRAW7 iface,
					     DWORD dwFlags,
					     LPDIRECTDRAWCLIPPER *ppClipper,
					     IUnknown *pUnkOuter)
{
267
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293
    HRESULT hr;

    TRACE("(%p)->(0x%lx, %p, %p)\n", iface, dwFlags, ppClipper, pUnkOuter);

    hr = DirectDrawCreateClipper(dwFlags, ppClipper, pUnkOuter);
    if (FAILED(hr)) return hr;

    /* dwFlags is passed twice, apparently an API wart. */
    hr = IDirectDrawClipper_Initialize(*ppClipper,
				       ICOM_INTERFACE(This, IDirectDraw),
				       dwFlags);
    if (FAILED(hr))
    {
	IDirectDrawClipper_Release(*ppClipper);
	return hr;
    }

    return DD_OK;
}

HRESULT WINAPI
Main_DirectDraw_CreatePalette(LPDIRECTDRAW7 iface, DWORD dwFlags,
			      LPPALETTEENTRY palent,
			      LPDIRECTDRAWPALETTE* ppPalette,
			      LPUNKNOWN pUnknown)
{
294
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
    LPDIRECTDRAWPALETTE pPalette;
    HRESULT hr;

    TRACE("(%p)->(%08lx,%p,%p,%p)\n",This,dwFlags,palent,ppPalette,pUnknown);

    if (ppPalette == NULL) return E_POINTER; /* unchecked */
    if (pUnknown != NULL) return CLASS_E_NOAGGREGATION; /* unchecked */

    hr = This->create_palette(This, dwFlags, &pPalette, pUnknown);
    if (FAILED(hr)) return hr;

    hr = IDirectDrawPalette_SetEntries(pPalette, 0, 0,
				       Main_DirectDrawPalette_Size(dwFlags),
				       palent);
    if (FAILED(hr))
    {
	IDirectDrawPalette_Release(pPalette);
	return hr;
    }
    else
    {
	*ppPalette = pPalette;
317
	return DD_OK;
318
    }
319 320
}

321 322 323 324 325 326 327
HRESULT
Main_create_offscreen(IDirectDrawImpl* This, const DDSURFACEDESC2* pDDSD,
		      LPDIRECTDRAWSURFACE7* ppSurf, LPUNKNOWN pOuter)
{
    assert(pOuter == NULL);

    return DIB_DirectDrawSurface_Create(This, pDDSD, ppSurf, pOuter);
328 329
}

330 331 332 333 334 335
HRESULT
Main_create_texture(IDirectDrawImpl* This, const DDSURFACEDESC2* pDDSD,
		    LPDIRECTDRAWSURFACE7* ppSurf, LPUNKNOWN pOuter,
		    DWORD dwMipMapLevel)
{
    assert(pOuter == NULL);
336

337
    return DIB_DirectDrawSurface_Create(This, pDDSD, ppSurf, pOuter);
338
}
339

340 341 342 343 344 345 346
HRESULT
Main_create_zbuffer(IDirectDrawImpl* This, const DDSURFACEDESC2* pDDSD,
		    LPDIRECTDRAWSURFACE7* ppSurf, LPUNKNOWN pOuter)
{
    assert(pOuter == NULL);

    return FakeZBuffer_DirectDrawSurface_Create(This, pDDSD, ppSurf, pOuter);
347 348
}

349 350 351 352 353
/* Does the texture surface described in pDDSD have any smaller mipmaps? */
static BOOL more_mipmaps(const DDSURFACEDESC2 *pDDSD)
{
    return ((pDDSD->dwFlags & DDSD_MIPMAPCOUNT) && pDDSD->u2.dwMipMapCount > 1
	    && (pDDSD->dwWidth > 1 || pDDSD->dwHeight > 1));
354 355
}

356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
/* Create a texture surface along with any of its mipmaps. */
static HRESULT
create_texture(IDirectDrawImpl* This, const DDSURFACEDESC2 *pDDSD,
	       LPDIRECTDRAWSURFACE7* ppSurf, LPUNKNOWN pUnkOuter)
{
    DDSURFACEDESC2 ddsd;
    DWORD mipmap_level = 0;
    HRESULT hr;

    assert(pUnkOuter == NULL);

    /* is this check right? (pixelformat can be copied from primary) */
    if ((pDDSD->dwFlags&(DDSD_HEIGHT|DDSD_WIDTH)) != (DDSD_HEIGHT|DDSD_WIDTH))
	return DDERR_INVALIDPARAMS;

371 372
    ddsd.dwSize = sizeof(ddsd);
    DD_STRUCT_COPY_BYSIZE((&ddsd),pDDSD);
373 374 375 376

    if (!(ddsd.dwFlags & DDSD_PIXELFORMAT))
    {
	ddsd.u4.ddpfPixelFormat = This->pixelformat;
377
    }
378

379
#ifdef HAVE_OPENGL
380 381 382 383 384
    /* We support for now only DXT1, DXT3 & DXT5 compressed texture formats... */
    if ((ddsd.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) &&
        (ddsd.u4.ddpfPixelFormat.dwFourCC != MAKE_FOURCC('D','X','T','1')) &&
        (ddsd.u4.ddpfPixelFormat.dwFourCC != MAKE_FOURCC('D','X','T','3')) &&
        (ddsd.u4.ddpfPixelFormat.dwFourCC != MAKE_FOURCC('D','X','T','5')) )
385 386 387
    {
        return DDERR_INVALIDPIXELFORMAT;
    }
388 389 390 391

    /* Check if we can really support DXT1, DXT3 & DXT5 */
    if ((ddsd.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) &&
	!GL_extensions.s3tc_compressed_texture && !s3tc_initialized) {
392 393 394 395 396 397
	static BOOLEAN user_warned = 0;
	if (user_warned == 0) {
	    ERR("Trying to create DXT1, DXT3 or DXT5 texture which is not supported by the video card!!!\n");
	    ERR("However there is a library libtxc_dxtn.so that can be used to do the software decompression...\n");
	    user_warned = 1;
	}
398 399
        return DDERR_INVALIDPIXELFORMAT;
    }
400 401 402 403 404 405
#else
    if (ddsd.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC)
    {
	return DDERR_INVALIDPIXELFORMAT;
    }
#endif
406

407
    if ((ddsd.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) && !(ddsd.dwFlags & DDSD_LINEARSIZE))
408
    {
409 410 411 412 413 414 415 416 417 418 419 420 421 422
	int size = 0;
	int width = ddsd.dwWidth;
	int height = ddsd.dwHeight;
	switch(ddsd.u4.ddpfPixelFormat.dwFourCC) {
	    case MAKE_FOURCC('D','X','T','1'): size = ((width+3)&~3) * ((height+3)&~3) / 16 * 8; break;
	    case MAKE_FOURCC('D','X','T','3'): size = ((width+3)&~3) * ((height+3)&~3) / 16 * 16; break;
	    case MAKE_FOURCC('D','X','T','5'): size = ((width+3)&~3) * ((height+3)&~3) / 16 * 16; break;
	    default: FIXME("FOURCC not supported\n"); break;
	}
	ddsd.u1.dwLinearSize = size;
	ddsd.dwFlags |= DDSD_LINEARSIZE;
    } else if (!(ddsd.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) && !(ddsd.dwFlags & DDSD_PITCH)) {
	ddsd.u1.lPitch = DDRAW_width_bpp_to_pitch(ddsd.dwWidth, GET_BPP(ddsd)*8);
	ddsd.dwFlags |= DDSD_PITCH;
423
    }
424

425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448
    if((ddsd.ddsCaps.dwCaps & DDSCAPS_MIPMAP) &&
        !(ddsd.dwFlags & DDSD_MIPMAPCOUNT))
    {
        if(ddsd.ddsCaps.dwCaps & DDSCAPS_COMPLEX)
        {
            /* Undocumented feature: if DDSCAPS_MIPMAP and DDSCAPS_COMPLEX are
             * both set, but mipmap count isn't given, as many mipmap levels
             * as necessary are created to get down to a size where either
             * the width or the height of the texture is 1.
             *
             * This is needed by Anarchy Online. */
            DWORD min = ddsd.dwWidth < ddsd.dwHeight ?
                        ddsd.dwWidth : ddsd.dwHeight;
            ddsd.u2.dwMipMapCount = 0;
            while( min )
            {
                ddsd.u2.dwMipMapCount++;
                min >>= 1;
            }
        }
        else
            /* Create a single mipmap. */
            ddsd.u2.dwMipMapCount = 1;
 
449 450 451
        ddsd.dwFlags |= DDSD_MIPMAPCOUNT;
    }
    
452
    ddsd.dwFlags |= DDSD_PIXELFORMAT;
453 454 455 456

    hr = This->create_texture(This, &ddsd, ppSurf, pUnkOuter, mipmap_level);
    if (FAILED(hr)) return hr;

457 458
    if (This->d3d_private) This->d3d_create_texture(This, ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, *ppSurf), TRUE, 
						    ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, *ppSurf));
459

460 461 462 463 464 465 466 467 468 469
    /* Create attached mipmaps if required. */
    if (more_mipmaps(&ddsd))
    {
	LPDIRECTDRAWSURFACE7 mipmap;
	LPDIRECTDRAWSURFACE7 prev_mipmap;
	DDSURFACEDESC2 mipmap_surface_desc;

	prev_mipmap = *ppSurf;
	IDirectDrawSurface7_AddRef(prev_mipmap);
	mipmap_surface_desc = ddsd;
470
	mipmap_surface_desc.ddsCaps.dwCaps2 |= DDSCAPS2_MIPMAPSUBLEVEL;
471 472 473

	while (more_mipmaps(&mipmap_surface_desc))
	{
474 475
	    IDirectDrawSurfaceImpl *mipmap_impl;
	    
476 477 478 479 480 481 482 483 484
	    mipmap_level++;
	    mipmap_surface_desc.u2.dwMipMapCount--;

	    if (mipmap_surface_desc.dwWidth > 1)
		mipmap_surface_desc.dwWidth /= 2;

	    if (mipmap_surface_desc.dwHeight > 1)
		mipmap_surface_desc.dwHeight /= 2;

485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501
	    if (mipmap_surface_desc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) {
		int size = 0;
		int width = mipmap_surface_desc.dwWidth;
		int height = mipmap_surface_desc.dwHeight;
		switch(mipmap_surface_desc.u4.ddpfPixelFormat.dwFourCC) {
		    case MAKE_FOURCC('D','X','T','1'): size = ((width+3)&~3) * ((height+3)&~3) / 16 * 8; break;
		    case MAKE_FOURCC('D','X','T','3'): size = ((width+3)&~3) * ((height+3)&~3) / 16 * 16; break;
		    case MAKE_FOURCC('D','X','T','5'): size = ((width+3)&~3) * ((height+3)&~3) / 16 * 16; break;
		    default: FIXME("FOURCC not supported\n"); break;
		}
		mipmap_surface_desc.u1.dwLinearSize = size;
	    } else {
		ddsd.u1.lPitch = DDRAW_width_bpp_to_pitch(ddsd.dwWidth, GET_BPP(ddsd)*8);
		mipmap_surface_desc.u1.lPitch
		    = DDRAW_width_bpp_to_pitch(mipmap_surface_desc.dwWidth,
					       GET_BPP(ddsd)*8);
	    }
502 503 504 505 506 507 508 509 510

	    hr = This->create_texture(This, &mipmap_surface_desc, &mipmap,
				      pUnkOuter, mipmap_level);
	    if (FAILED(hr))
	    {
		IDirectDrawSurface7_Release(prev_mipmap);
		IDirectDrawSurface7_Release(*ppSurf);
		return hr;
	    }
511 512 513 514 515 516
	    
	    /* This is needed for delayed mipmap creation */
	    mipmap_impl = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, mipmap);
	    mipmap_impl->mip_main = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, *ppSurf);
	    mipmap_impl->mipmap_level = mipmap_level;

517 518
	    if (This->d3d_private) This->d3d_create_texture(This, ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, mipmap), TRUE,
							    ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, *ppSurf));
519 520 521 522 523 524 525 526 527

	    IDirectDrawSurface7_AddAttachedSurface(prev_mipmap, mipmap);
	    IDirectDrawSurface7_Release(prev_mipmap);
	    prev_mipmap = mipmap;
	}

	IDirectDrawSurface7_Release(prev_mipmap);
    }

528 529 530
    return DD_OK;
}

531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547
/* Creates a primary surface and any indicated backbuffers. */
static HRESULT
create_primary(IDirectDrawImpl* This, LPDDSURFACEDESC2 pDDSD,
	       LPDIRECTDRAWSURFACE7* ppSurf, LPUNKNOWN pUnkOuter)
{
    DDSURFACEDESC2 ddsd;
    HRESULT hr;

    assert(pUnkOuter == NULL);

    if (This->primary_surface != NULL)
	return DDERR_PRIMARYSURFACEALREADYEXISTS;

    /* as documented (what about pitch?) */
    if (pDDSD->dwFlags & (DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT))
	return DDERR_INVALIDPARAMS;

548 549
    ddsd.dwSize = sizeof(ddsd);
    DD_STRUCT_COPY_BYSIZE((&ddsd),pDDSD);
550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571
    ddsd.dwFlags |= DDSD_HEIGHT | DDSD_WIDTH | DDSD_PITCH | DDSD_PIXELFORMAT;
    ddsd.dwHeight = This->height;
    ddsd.dwWidth = This->width;
    ddsd.u1.lPitch = This->pitch;
    ddsd.u4.ddpfPixelFormat = This->pixelformat;
    ddsd.ddsCaps.dwCaps |= DDSCAPS_LOCALVIDMEM | DDSCAPS_VIDEOMEMORY
	| DDSCAPS_VISIBLE | DDSCAPS_FRONTBUFFER;

    if ((ddsd.dwFlags & DDSD_BACKBUFFERCOUNT) && ddsd.dwBackBufferCount > 0)
	ddsd.ddsCaps.dwCaps |= DDSCAPS_FLIP;

    hr = This->create_primary(This, &ddsd, ppSurf, pUnkOuter);
    if (FAILED(hr)) return hr;

    if (ddsd.dwFlags & DDSD_BACKBUFFERCOUNT)
    {
	IDirectDrawSurfaceImpl* primary;
	LPDIRECTDRAWSURFACE7 pPrev;
	DWORD i;

	ddsd.dwFlags &= ~DDSD_BACKBUFFERCOUNT;
	ddsd.ddsCaps.dwCaps &= ~(DDSCAPS_VISIBLE | DDSCAPS_PRIMARYSURFACE
572
				 | DDSCAPS_BACKBUFFER | DDSCAPS_FRONTBUFFER);
573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605

	primary = ICOM_OBJECT(IDirectDrawSurfaceImpl,IDirectDrawSurface7,
			      *ppSurf);
	pPrev = *ppSurf;
	IDirectDrawSurface7_AddRef(pPrev);

	for (i=0; i < ddsd.dwBackBufferCount; i++)
	{
	    LPDIRECTDRAWSURFACE7 pBack;

	    if (i == 0)
		ddsd.ddsCaps.dwCaps |= DDSCAPS_BACKBUFFER;
	    else
		ddsd.ddsCaps.dwCaps &= ~DDSCAPS_BACKBUFFER;

	    hr = This->create_backbuffer(This, &ddsd, &pBack, pUnkOuter,
					 primary);

	    if (FAILED(hr))
	    {
		IDirectDraw7_Release(pPrev);
		IDirectDraw7_Release(*ppSurf);
		return hr;
	    }

	    IDirectDrawSurface7_AddAttachedSurface(pPrev, pBack);
	    IDirectDrawSurface7_Release(pPrev);
	    pPrev = pBack;
	}

	IDirectDrawSurface7_Release(pPrev);
    }

Gavriel State's avatar
Gavriel State committed
606
    This->primary_surface = (IDirectDrawSurfaceImpl *)*ppSurf;
607

608 609 610
    return DD_OK;
}

611 612 613 614 615 616 617 618 619 620 621
static HRESULT
create_offscreen(IDirectDrawImpl* This, LPDDSURFACEDESC2 pDDSD,
		 LPDIRECTDRAWSURFACE7* ppSurf, LPUNKNOWN pUnkOuter)
{
    DDSURFACEDESC2 ddsd;
    HRESULT hr;

    /* is this check right? (pixelformat can be copied from primary) */
    if ((pDDSD->dwFlags&(DDSD_HEIGHT|DDSD_WIDTH)) != (DDSD_HEIGHT|DDSD_WIDTH))
	return DDERR_INVALIDPARAMS;

622 623
    ddsd.dwSize = sizeof(ddsd);
    DD_STRUCT_COPY_BYSIZE((&ddsd),pDDSD);
624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641

    if (!(ddsd.dwFlags & DDSD_PIXELFORMAT))
    {
	ddsd.u4.ddpfPixelFormat = This->pixelformat;
    }

    if (!(ddsd.dwFlags & DDSD_PITCH))
    {
	ddsd.u1.lPitch = DDRAW_width_bpp_to_pitch(ddsd.dwWidth,
						  GET_BPP(ddsd)*8);
    }

    ddsd.dwFlags |= DDSD_PITCH | DDSD_PIXELFORMAT;

    hr = This->create_offscreen(This, &ddsd, ppSurf, pUnkOuter);
    if (FAILED(hr)) return hr;

    return hr;
642 643
}

644 645 646 647 648 649
HRESULT WINAPI
Main_DirectDraw_CreateSurface(LPDIRECTDRAW7 iface, LPDDSURFACEDESC2 pDDSD,
			      LPDIRECTDRAWSURFACE7 *ppSurf,
			      IUnknown *pUnkOuter)
{
    HRESULT hr;
650
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
651 652

    TRACE("(%p)->(%p,%p,%p)\n",This,pDDSD,ppSurf,pUnkOuter);
653
    if (TRACE_ON(ddraw)) {
654
        TRACE("Requesting surface desc :\n");
655 656
        DDRAW_dump_surface_desc(pDDSD);
    }
657

658 659
    if (pUnkOuter != NULL) {
	FIXME("outer != NULL?\n");
660
	return CLASS_E_NOAGGREGATION; /* unchecked */
661
    }
662

663 664 665 666
    if (!(pDDSD->dwFlags & DDSD_CAPS)) {
	/* DVIDEO.DLL does forget the DDSD_CAPS flag ... *sigh* */
    	pDDSD->dwFlags |= DDSD_CAPS;
    }
667 668 669 670
    if (pDDSD->ddsCaps.dwCaps == 0) {
	/* This has been checked on real Windows */
	pDDSD->ddsCaps.dwCaps = DDSCAPS_LOCALVIDMEM | DDSCAPS_VIDEOMEMORY;
    }
671

672 673 674 675 676
    if (pDDSD->ddsCaps.dwCaps & DDSCAPS_ALLOCONLOAD) {
        /* If the surface is of the 'alloconload' type, ignore the LPSURFACE field */
        pDDSD->dwFlags &= ~DDSD_LPSURFACE;
    }

677 678 679 680 681 682
    if ((pDDSD->dwFlags & DDSD_LPSURFACE) && (pDDSD->lpSurface == NULL)) {
        /* Frank Herbert's Dune specifies a null pointer for the surface, ignore the LPSURFACE field */
        WARN("Null surface pointer specified, ignore it!\n");
        pDDSD->dwFlags &= ~DDSD_LPSURFACE;
    }

683 684
    if (ppSurf == NULL) {
	FIXME("You want to get back a surface? Don't give NULL ptrs!\n");
685
	return E_POINTER; /* unchecked */
686
    }
687 688 689 690 691 692 693 694 695 696 697

    if (pDDSD->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
    {
	/* create primary surface & backbuffers */
	hr = create_primary(This, pDDSD, ppSurf, pUnkOuter);
    }
    else if (pDDSD->ddsCaps.dwCaps & DDSCAPS_BACKBUFFER)
    {
       /* create backbuffer surface */
       hr = This->create_backbuffer(This, pDDSD, ppSurf, pUnkOuter, NULL);
    }
698 699 700 701 702
    else if (pDDSD->ddsCaps.dwCaps & DDSCAPS_TEXTURE)
    {
	/* create texture */
	hr = create_texture(This, pDDSD, ppSurf, pUnkOuter);
    }
703 704 705 706 707 708
    else if ( (pDDSD->ddsCaps.dwCaps & DDSCAPS_ZBUFFER) &&
	     !(pDDSD->ddsCaps.dwCaps & DDSCAPS_OFFSCREENPLAIN)) /* Support DDSCAPS_SYSTEMMEMORY */
    {
	/* create z-buffer */
	hr = This->create_zbuffer(This, pDDSD, ppSurf, pUnkOuter);
    }
709 710
    else if ((pDDSD->ddsCaps.dwCaps & DDSCAPS_OFFSCREENPLAIN) ||
	     (pDDSD->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY)) /* No difference in Wine right now */
711 712 713 714 715 716 717
    {
	/* create offscreenplain surface */
	hr = create_offscreen(This, pDDSD, ppSurf, pUnkOuter);
    }
    else
    {
	/* Otherwise, assume offscreenplain surface */
718
	TRACE("App didn't request a valid surface type - assuming offscreenplain\n");
719 720 721
	hr = create_offscreen(This, pDDSD, ppSurf, pUnkOuter);
    }

722 723 724 725
    if (FAILED(hr)) {
	FIXME("failed surface creation with code 0x%08lx\n",hr);
	return hr;
    }
726

727 728 729
    return DD_OK;
}

730 731 732 733
HRESULT WINAPI
Main_DirectDraw_DuplicateSurface(LPDIRECTDRAW7 iface, LPDIRECTDRAWSURFACE7 src,
				 LPDIRECTDRAWSURFACE7* dst)
{
734
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
735

736 737 738 739 740 741
    IDirectDrawSurfaceImpl *pSrc = ICOM_OBJECT(IDirectDrawSurfaceImpl,
					       IDirectDrawSurface7, src);

    TRACE("(%p)->(%p,%p)\n",This,src,dst);

    return pSrc->duplicate_surface(pSrc, dst);
742 743
}

744
/* EnumDisplayModes */
745

746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788
BOOL Main_DirectDraw_DDPIXELFORMAT_Match(const DDPIXELFORMAT *requested,
					 const DDPIXELFORMAT *provided)
{
    /* Some flags must be present in both or neither for a match. */
    static const DWORD must_match = DDPF_PALETTEINDEXED1 | DDPF_PALETTEINDEXED2
	| DDPF_PALETTEINDEXED4 | DDPF_PALETTEINDEXED8 | DDPF_FOURCC
	| DDPF_ZBUFFER | DDPF_STENCILBUFFER;

    if ((requested->dwFlags & provided->dwFlags) != requested->dwFlags)
	return FALSE;

    if ((requested->dwFlags & must_match) != (provided->dwFlags & must_match))
	return FALSE;

    if (requested->dwFlags & DDPF_FOURCC)
	if (requested->dwFourCC != provided->dwFourCC)
	    return FALSE;

    if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_ZBUFFER|DDPF_ALPHA
			      |DDPF_LUMINANCE|DDPF_BUMPDUDV))
	if (requested->u1.dwRGBBitCount != provided->u1.dwRGBBitCount)
	    return FALSE;

    if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_STENCILBUFFER
			      |DDPF_LUMINANCE|DDPF_BUMPDUDV))
	if (requested->u2.dwRBitMask != provided->u2.dwRBitMask)
	    return FALSE;

    if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_ZBUFFER|DDPF_BUMPDUDV))
	if (requested->u3.dwGBitMask != provided->u3.dwGBitMask)
	    return FALSE;

    /* I could be wrong about the bumpmapping. MSDN docs are vague. */
    if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_STENCILBUFFER
			      |DDPF_BUMPDUDV))
	if (requested->u4.dwBBitMask != provided->u4.dwBBitMask)
	    return FALSE;

    if (requested->dwFlags & (DDPF_ALPHAPIXELS|DDPF_ZPIXELS))
	if (requested->u5.dwRGBAlphaBitMask != provided->u5.dwRGBAlphaBitMask)
	    return FALSE;

    return TRUE;
789 790
}

791 792 793 794 795 796 797 798 799
BOOL Main_DirectDraw_DDSD_Match(const DDSURFACEDESC2* requested,
				const DDSURFACEDESC2* provided)
{
    struct compare_info
    {
	DWORD flag;
	ptrdiff_t offset;
	size_t size;
    };
800

801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826
#define CMP(FLAG, FIELD)				\
	{ DDSD_##FLAG, offsetof(DDSURFACEDESC2, FIELD),	\
	  sizeof(((DDSURFACEDESC2 *)(NULL))->FIELD) }

    static const struct compare_info compare[] = {
	CMP(ALPHABITDEPTH, dwAlphaBitDepth),
	CMP(BACKBUFFERCOUNT, dwBackBufferCount),
	CMP(CAPS, ddsCaps),
	CMP(CKDESTBLT, ddckCKDestBlt),
	CMP(CKDESTOVERLAY, u3.ddckCKDestOverlay),
	CMP(CKSRCBLT, ddckCKSrcBlt),
	CMP(CKSRCOVERLAY, ddckCKSrcOverlay),
	CMP(HEIGHT, dwHeight),
	CMP(LINEARSIZE, u1.dwLinearSize),
	CMP(LPSURFACE, lpSurface),
	CMP(MIPMAPCOUNT, u2.dwMipMapCount),
	CMP(PITCH, u1.lPitch),
	/* PIXELFORMAT: manual */
	CMP(REFRESHRATE, u2.dwRefreshRate),
	CMP(TEXTURESTAGE, dwTextureStage),
	CMP(WIDTH, dwWidth),
	/* ZBUFFERBITDEPTH: "obsolete" */
    };

#undef CMP

827
    unsigned int i;
828 829 830 831 832 833 834 835 836 837 838

    if ((requested->dwFlags & provided->dwFlags) != requested->dwFlags)
	return FALSE;

    for (i=0; i < sizeof(compare)/sizeof(compare[0]); i++)
    {
	if (requested->dwFlags & compare[i].flag
	    && memcmp((const char *)provided + compare[i].offset,
		      (const char *)requested + compare[i].offset,
		      compare[i].size) != 0)
	    return FALSE;
839
    }
840 841 842 843 844 845 846 847 848

    if (requested->dwFlags & DDSD_PIXELFORMAT)
    {
	if (!Main_DirectDraw_DDPIXELFORMAT_Match(&requested->u4.ddpfPixelFormat,
						 &provided->u4.ddpfPixelFormat))
	    return FALSE;
    }

    return TRUE;
849 850
}

851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876
#define DDENUMSURFACES_SEARCHTYPE (DDENUMSURFACES_CANBECREATED|DDENUMSURFACES_DOESEXIST)
#define DDENUMSURFACES_MATCHTYPE (DDENUMSURFACES_ALL|DDENUMSURFACES_MATCH|DDENUMSURFACES_NOMATCH)

/* This should be extended so that it can be used by
 * IDirectDrawSurface7::EnumAttachedSurfaces. */
HRESULT
Main_DirectDraw_EnumExistingSurfaces(IDirectDrawImpl *This, DWORD dwFlags,
				     LPDDSURFACEDESC2 lpDDSD2, LPVOID context,
				     LPDDENUMSURFACESCALLBACK7 callback)
{
    IDirectDrawSurfaceImpl *surf;
    BOOL all, nomatch;

    /* A NULL lpDDSD2 is permitted if we are enumerating all surfaces anyway */
    if (lpDDSD2 == NULL && !(dwFlags & DDENUMSURFACES_ALL))
	return DDERR_INVALIDPARAMS;

    all = dwFlags & DDENUMSURFACES_ALL;
    nomatch = dwFlags & DDENUMSURFACES_NOMATCH;

    for (surf = This->surfaces; surf != NULL; surf = surf->next_ddraw)
    {
	if (all
	    || (nomatch != Main_DirectDraw_DDSD_Match(lpDDSD2,
						      &surf->surface_desc)))
	{
877 878
	    LPDIRECTDRAWSURFACE7 isurf = ICOM_INTERFACE(surf, IDirectDrawSurface7);
	    DDSURFACEDESC2 desc;
879

880 881 882 883 884 885
	    if (TRACE_ON(ddraw)) {
		TRACE("  => enumerating surface %p (priv. %p) with description:\n", isurf, surf);
		DDRAW_dump_surface_desc(&surf->surface_desc);
	    }

	    IDirectDrawSurface7_AddRef(isurf);
886

887 888
	    desc = surf->surface_desc;
	    if (callback(isurf, &desc, context)	== DDENUMRET_CANCEL)
889 890 891
		break;
	}
    }
892 893
    TRACE(" end of enumeration.\n");
    
894 895 896
    return DD_OK;
}

897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913
/* I really don't understand how this is supposed to work.
 * We only consider dwHeight, dwWidth and ddpfPixelFormat.dwFlags. */
HRESULT
Main_DirectDraw_EnumCreateableSurfaces(IDirectDrawImpl *This, DWORD dwFlags,
				       LPDDSURFACEDESC2 lpDDSD2,
				       LPVOID context,
				       LPDDENUMSURFACESCALLBACK7 callback)
{
    FIXME("This isn't going to work.\n");

    if ((dwFlags & DDENUMSURFACES_MATCHTYPE) != DDENUMSURFACES_MATCH)
	return DDERR_INVALIDPARAMS;

    /* TODO: implement this.
     * Does this work before SCL is called?
     * Does it only consider off-screen surfaces?
     */
914

915 916
    return E_FAIL;
}
917

918 919
/* For unsigned x. 0 is not a power of 2. */
#define IS_POW_2(x) (((x) & ((x) - 1)) == 0)
920

921 922 923 924 925
HRESULT WINAPI
Main_DirectDraw_EnumSurfaces(LPDIRECTDRAW7 iface, DWORD dwFlags,
			     LPDDSURFACEDESC2 lpDDSD2, LPVOID context,
			     LPDDENUMSURFACESCALLBACK7 callback)
{
926
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
927 928
    TRACE("(%p)->(0x%lx, %p, %p, %p)\n", iface, dwFlags, lpDDSD2, context,
	  callback);
929 930 931 932
    if (TRACE_ON(ddraw)) {
	TRACE(" flags: "); DDRAW_dump_DDENUMSURFACES(dwFlags);
    }
    
933 934 935 936 937 938 939 940 941 942 943 944 945 946
    if (callback == NULL)
	return DDERR_INVALIDPARAMS;

    if (dwFlags & ~(DDENUMSURFACES_SEARCHTYPE|DDENUMSURFACES_MATCHTYPE))
	return DDERR_INVALIDPARAMS;

    if (!IS_POW_2(dwFlags & DDENUMSURFACES_SEARCHTYPE)
	|| !IS_POW_2(dwFlags & DDENUMSURFACES_MATCHTYPE))
	return DDERR_INVALIDPARAMS;

    if (dwFlags & DDENUMSURFACES_DOESEXIST)
    {
	return Main_DirectDraw_EnumExistingSurfaces(This, dwFlags, lpDDSD2,
						    context, callback);
947
    }
948 949 950 951 952 953 954 955 956 957
    else
    {
	return Main_DirectDraw_EnumCreateableSurfaces(This, dwFlags, lpDDSD2,
						      context, callback);
    }
}

HRESULT WINAPI
Main_DirectDraw_EvaluateMode(LPDIRECTDRAW7 iface,DWORD a,DWORD* b)
{
958
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
959 960
    FIXME("(%p)->() stub\n", This);

961 962 963
    return DD_OK;
}

964 965 966
HRESULT WINAPI
Main_DirectDraw_FlipToGDISurface(LPDIRECTDRAW7 iface)
{
967
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
968
    TRACE("(%p)->()\n",This);
969 970 971
    return DD_OK;
}

972 973 974 975
HRESULT WINAPI
Main_DirectDraw_GetCaps(LPDIRECTDRAW7 iface, LPDDCAPS pDriverCaps,
			LPDDCAPS pHELCaps)
{
976
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
977
    TRACE("(%p,%p,%p)\n",This,pDriverCaps,pHELCaps);
978
    if (pDriverCaps != NULL) {
979
	DD_STRUCT_COPY_BYSIZE(pDriverCaps,&This->caps);
980
	if (TRACE_ON(ddraw)) {
981
	  TRACE("Driver Caps :\n");
982 983 984 985
	  DDRAW_dump_DDCAPS(pDriverCaps);
	}
    }
    if (pHELCaps != NULL) {
986
	DD_STRUCT_COPY_BYSIZE(pHELCaps,&This->caps);
987
	if (TRACE_ON(ddraw)) {
988
	  TRACE("HEL Caps :\n");
989 990 991
	  DDRAW_dump_DDCAPS(pHELCaps);
	}
    }
992 993 994
    return DD_OK;
}

995 996 997 998 999 1000 1001 1002
/* GetCaps */
/* GetDeviceIdentifier */
/* GetDIsplayMode */

HRESULT WINAPI
Main_DirectDraw_GetFourCCCodes(LPDIRECTDRAW7 iface, LPDWORD pNumCodes,
			       LPDWORD pCodes)
{
1003
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1004 1005 1006
    if (*pNumCodes) {
	    *pNumCodes=0;
    }
1007
    FIXME("(%p,%p,%p), stub\n",This,pNumCodes,pCodes);
1008 1009 1010
    return DD_OK;
}

1011 1012 1013 1014
HRESULT WINAPI
Main_DirectDraw_GetGDISurface(LPDIRECTDRAW7 iface,
			      LPDIRECTDRAWSURFACE7 *lplpGDIDDSSurface)
{
1015
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026
    TRACE("(%p)->(%p)\n", This, lplpGDIDDSSurface);
    TRACE("returning primary (%p)\n", This->primary_surface);
    *lplpGDIDDSSurface = ICOM_INTERFACE(This->primary_surface, IDirectDrawSurface7);
    if (*lplpGDIDDSSurface)
	IDirectDrawSurface7_AddRef(*lplpGDIDDSSurface);
    return DD_OK;
}

HRESULT WINAPI
Main_DirectDraw_GetMonitorFrequency(LPDIRECTDRAW7 iface,LPDWORD freq)
{
1027
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1028 1029 1030 1031 1032
    FIXME("(%p)->(%p) returns 60 Hz always\n",This,freq);
    *freq = 60*100; /* 60 Hz */
    return DD_OK;
}

1033 1034 1035
HRESULT WINAPI
Main_DirectDraw_GetScanLine(LPDIRECTDRAW7 iface, LPDWORD lpdwScanLine)
{
1036
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1037
    static BOOL hide;
1038

1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050
    /* Since this method is called often, show the fixme only once */
    if (!hide) {
	FIXME("(%p)->(%p) semi-stub\n", This, lpdwScanLine);
	hide = TRUE;
    }

    /* Fake the line sweeping of the monitor */
    /* FIXME: We should synchronize with a source to keep the refresh rate */ 
    *lpdwScanLine = This->cur_scanline++;
    /* Assume 20 scan lines in the vertical blank */
    if (This->cur_scanline >= This->height + 20)
	This->cur_scanline = 0;
1051

1052 1053 1054
    return DD_OK;
}

1055 1056 1057 1058
HRESULT WINAPI
Main_DirectDraw_GetSurfaceFromDC(LPDIRECTDRAW7 iface, HDC hdc,
				 LPDIRECTDRAWSURFACE7 *lpDDS)
{
1059
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1060
    FIXME("(%p)->(%p,%p)\n", This, hdc, lpDDS);
1061

1062 1063 1064
    return DD_OK;
}

1065 1066 1067
HRESULT WINAPI
Main_DirectDraw_GetVerticalBlankStatus(LPDIRECTDRAW7 iface, LPBOOL status)
{
1068
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1069
    TRACE("(%p)->(%p)\n",This,status);
1070 1071
    *status = This->fake_vblank;
    This->fake_vblank = !This->fake_vblank;
1072 1073 1074
    return DD_OK;
}

1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087
/* If we were not initialised then Uninit_Main_IDirectDraw7_Initialize would
 * have been called instead. */
HRESULT WINAPI
Main_DirectDraw_Initialize(LPDIRECTDRAW7 iface, LPGUID lpGuid)
{
    TRACE("(%p)->(%s)\n", iface, debugstr_guid(lpGuid));

    return DDERR_ALREADYINITIALIZED;
}

HRESULT WINAPI
Main_DirectDraw_RestoreAllSurfaces(LPDIRECTDRAW7 iface)
{
1088
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1089 1090 1091 1092 1093 1094 1095
    IDirectDrawSurfaceImpl* surf;

    TRACE("(%p)->()\n", This);

    for (surf = This->surfaces; surf != NULL; surf = surf->next_ddraw)
	IDirectDrawSurface7_Restore(ICOM_INTERFACE(surf, IDirectDrawSurface7));

1096 1097 1098
    return DD_OK;
}

1099 1100 1101
static void DDRAW_SubclassWindow(IDirectDrawImpl* This)
{
    /* Well we don't actually subclass the window yet. */
1102
    SetPropA(This->window, ddProp, This);
1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
}

static void DDRAW_UnsubclassWindow(IDirectDrawImpl* This)
{
    RemovePropA(This->window, ddProp);
}

HRESULT WINAPI
Main_DirectDraw_SetCooperativeLevel(LPDIRECTDRAW7 iface, HWND hwnd,
				    DWORD cooplevel)
{
1114
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1115

1116
    FIXME("(%p)->(%p,%08lx)\n",This,hwnd,cooplevel);
1117 1118 1119 1120 1121 1122 1123 1124
    DDRAW_dump_cooperativelevel(cooplevel);

    /* Makes realMYST test happy. */
    if (This->cooperative_level == cooplevel
	&& This->window == hwnd)
	return DD_OK;

    /* XXX "It cannot be reset while the process has surfaces or palettes
1125 1126
     * created." Otherwise the window can be changed???
     *
1127
     * This appears to be wrong - comment it out for now.
1128 1129 1130
     * This seems to be true at least for DDSCL_SETFOCUSWINDOW
     * It looks like Windows doesn't store the HWND in all cases,
     * probably if DDSCL_NORMAL is specified, but that's not sure
1131
    if (This->window)
1132
	return DDERR_HWNDALREADYSET;
1133 1134
    */

1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184
    /* DDSCL_EXCLUSIVE or DDSCL_NORMAL or DDSCL_SETFOCUSWINDOW must be given */
    if (!(cooplevel & (DDSCL_EXCLUSIVE|DDSCL_NORMAL|DDSCL_SETFOCUSWINDOW)))
    {
        ERR("(%p) : Call to SetCooperativeLevel failed: cooplevel  != DDSCL_EXCLUSIVE|DDSCL_NORMAL|DDSCL_SETFOCUSWINDOW, returning DDERR_INVALIDPARAMS\n", This);
        return DDERR_INVALIDPARAMS;
    }
    /* Device window and focus Window. They only really matter in a
     * Multi-Monitor application, but some games specify them and we
     * have to react correctly. */
    if(cooplevel & DDSCL_SETFOCUSWINDOW)
    {
        /* This flag is a biest: It is only valid when DDSCL_NORMAL has been set
         * or no hwnd is set and no other flags are allowed, except DDSCL_NOWINDOWCHANGES
         */
        if(This->window)
            if(!(This->cooperative_level & DDSCL_NORMAL))
            {
                ERR("(%p) : Call to SetCooperativeLevel failed: DDSCL_SETFOCUSWINDOW may not be used in Cooplevel %08lx, returning DDERR_HWNDALREADYSET\n",
                            This, This->cooperative_level);
                return DDERR_HWNDALREADYSET;
            }
        if((cooplevel != DDSCL_SETFOCUSWINDOW))
            if(cooplevel != (DDSCL_SETFOCUSWINDOW | DDSCL_NOWINDOWCHANGES) )
            {
                ERR("(%p) : Call to SetCooperativeLevel failed: Invalid use of DDSCL_SETFOCUSWINDOW, returning DDERR_INVALIDPARAMS\n", This);
                return DDERR_INVALIDPARAMS;
            }

        /* Don't know what exactly to do, but it's perfectly valid
         * to pass DDSCL_SETFOCUSWINDOW only */
        FIXME("(%p) : Poorly handled flag DDSCL_SETFOCUSWINDOW\n", This);

        /* Store the flag in the cooperative level. I don't think that all other
         * flags should be overwritten, so just add it 
         * (In the most cases this will be DDSCL_SETFOCUSWINDOW | DDSCL_NORMAL) */
        cooplevel |= DDSCL_SETFOCUSWINDOW;

        return DD_OK;
    }

    /* DDSCL_EXCLUSE mode requires  DDSCL_FULLSCREEN and vice versa */
    if((cooplevel & DDSCL_EXCLUSIVE) && !(cooplevel & DDSCL_FULLSCREEN))
        return DDERR_INVALIDPARAMS;
    /* The other case is checked above */

    /* Unhandled flags. Give a warning */
    if(cooplevel & DDSCL_SETDEVICEWINDOW)
        FIXME("(%p) : Unhandled flag DDSCL_SETDEVICEWINDOW.\n", This);
    if(cooplevel & DDSCL_CREATEDEVICEWINDOW)
        FIXME("(%p) : Unhandled flag DDSCL_CREATEDEVICEWINDOW.\n", This);
1185

1186
    /* Perhaps the hwnd is only set in DDSCL_EXLUSIVE and DDSCL_FULLSCREEN mode. Not sure */
1187 1188 1189
    This->window = hwnd;
    This->cooperative_level = cooplevel;

1190
    This->local.hWnd = (ULONG_PTR)hwnd;
1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209
    This->local.dwLocalFlags |= DDRAWILCL_SETCOOPCALLED;
    /* not entirely sure about these */
    if (cooplevel & DDSCL_EXCLUSIVE)     This->local.dwLocalFlags |= DDRAWILCL_HASEXCLUSIVEMODE;
    if (cooplevel & DDSCL_FULLSCREEN)    This->local.dwLocalFlags |= DDRAWILCL_ISFULLSCREEN;
    if (cooplevel & DDSCL_ALLOWMODEX)    This->local.dwLocalFlags |= DDRAWILCL_ALLOWMODEX;
    if (cooplevel & DDSCL_MULTITHREADED) This->local.dwLocalFlags |= DDRAWILCL_MULTITHREADED;
    if (cooplevel & DDSCL_FPUSETUP)      This->local.dwLocalFlags |= DDRAWILCL_FPUSETUP;
    if (cooplevel & DDSCL_FPUPRESERVE)   This->local.dwLocalFlags |= DDRAWILCL_FPUPRESERVE;

    if (This->local.lpGbl) {
	/* assume that this app is the active app (in wine, there's
	 * probably only one app per global ddraw object anyway) */
	if (cooplevel & DDSCL_EXCLUSIVE) This->local.lpGbl->lpExclusiveOwner = &This->local;
	else if (This->local.lpGbl->lpExclusiveOwner == &This->local)
	    This->local.lpGbl->lpExclusiveOwner = NULL;
	if (This->set_exclusive_mode)
	    This->set_exclusive_mode(This, (cooplevel & DDSCL_EXCLUSIVE) != 0);
    }

1210 1211 1212 1213 1214
    ShowWindow(hwnd, SW_SHOW);

    DDRAW_SubclassWindow(This);

    /* TODO Does it also get resized to the current screen size? */
1215 1216 1217 1218

    return DD_OK;
}

1219 1220 1221 1222 1223 1224 1225 1226
HRESULT WINAPI
Main_DirectDraw_SetDisplayMode(LPDIRECTDRAW7 iface, DWORD dwWidth,
			       DWORD dwHeight, LONG lPitch,
			       DWORD dwRefreshRate, DWORD dwFlags,
			       const DDPIXELFORMAT* pixelformat)
{
    short screenX;
    short screenY;
1227

1228
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241

    TRACE("(%p)->SetDisplayMode(%ld,%ld)\n",This,dwWidth,dwHeight);

    if (!(This->cooperative_level & DDSCL_EXCLUSIVE))
	return DDERR_NOEXCLUSIVEMODE;

    if (!IsWindow(This->window))
	return DDERR_GENERIC; /* unchecked */

    LosePrimarySurface(This);

    screenX = GetSystemMetrics(SM_CXSCREEN);
    screenY = GetSystemMetrics(SM_CYSCREEN);
1242

1243 1244 1245 1246 1247 1248
    This->width = dwWidth;
    This->height = dwHeight;
    This->pitch = lPitch;
    This->pixelformat = *pixelformat;

    /* Position the window in the center of the screen - don't center for now */
1249
    /* MoveWindow(This->window, (screenX-dwWidth)/2, (screenY-dwHeight)/2,
1250 1251 1252 1253 1254
                  dwWidth, dwHeight, TRUE);*/
    MoveWindow(This->window, 0, 0, dwWidth, dwHeight, TRUE);

    SetFocus(This->window);

1255 1256 1257
    return DD_OK;
}

1258 1259 1260
HRESULT WINAPI
Main_DirectDraw_RestoreDisplayMode(LPDIRECTDRAW7 iface)
{
1261
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279

    TRACE("(%p)\n",This);
    if (!(This->cooperative_level & DDSCL_EXCLUSIVE))
	return DDERR_NOEXCLUSIVEMODE;

    /* Lose the primary surface if the resolution changes. */
    if (This->orig_width != This->width || This->orig_height != This->height
	|| This->orig_pitch != This->pitch
	|| This->orig_pixelformat.dwFlags != This->pixelformat.dwFlags
	|| !Main_DirectDraw_DDPIXELFORMAT_Match(&This->pixelformat,
						&This->orig_pixelformat))
    {
	LosePrimarySurface(This);
    }

    /* TODO Move the window back where it belongs. */

    return DD_OK;
1280 1281
}

1282 1283 1284 1285
HRESULT WINAPI
Main_DirectDraw_WaitForVerticalBlank(LPDIRECTDRAW7 iface, DWORD dwFlags,
				     HANDLE h)
{
1286
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1287
    FIXME("(%p)->(flags=0x%08lx,handle=%p)\n",This,dwFlags,h);
1288 1289 1290 1291 1292 1293
    return DD_OK;
}

HRESULT WINAPI
Main_DirectDraw_GetDisplayMode(LPDIRECTDRAW7 iface, LPDDSURFACEDESC2 pDDSD)
{
1294
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307
    TRACE("(%p)->GetDisplayMode(%p)\n",This,pDDSD);

    pDDSD->dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_PITCH|DDSD_PIXELFORMAT|DDSD_REFRESHRATE;
    pDDSD->dwHeight = This->height;
    pDDSD->dwWidth = This->width;
    pDDSD->u1.lPitch = This->pitch;
    pDDSD->u2.dwRefreshRate = 60;
    pDDSD->u4.ddpfPixelFormat = This->pixelformat;
    pDDSD->ddsCaps.dwCaps = 0;

    return DD_OK;
}

1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
static INT32 allocate_memory(IDirectDrawImpl *This, DWORD mem)
{
    if (mem > This->available_vidmem) return -1;
    This->available_vidmem -= mem;
    return This->available_vidmem;
}

static void free_memory(IDirectDrawImpl *This, DWORD mem)
{
    This->available_vidmem += mem;
}

1320 1321 1322 1323
HRESULT WINAPI
Main_DirectDraw_GetAvailableVidMem(LPDIRECTDRAW7 iface, LPDDSCAPS2 ddscaps,
				   LPDWORD total, LPDWORD free)
{
1324
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1325 1326
    TRACE("(%p)->(%p,%p,%p)\n", This,ddscaps,total,free);

1327
    if (TRACE_ON(ddraw)) {
1328
        TRACE(" Asking for memory of type : ");
1329
        DDRAW_dump_DDSCAPS2(ddscaps); TRACE("\n");
1330 1331
    }

1332
    /* We have 16 MB videomemory */
1333 1334 1335
    if (total)	*total= This->total_vidmem;
    if (free)	*free = This->available_vidmem;

1336 1337 1338
    TRACE(" returning (total) %ld / (free) %ld\n", 
	  total != NULL ? *total : 0, 
	  free  != NULL ? *free  : 0);
1339
    
1340 1341 1342
    return DD_OK;
}

1343
HRESULT WINAPI Main_DirectDraw_TestCooperativeLevel(LPDIRECTDRAW7 iface) {
1344
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1345
    TRACE("(%p)->(): stub\n", This);
1346 1347 1348 1349

    return DD_OK;
}

1350 1351 1352 1353
HRESULT WINAPI
Main_DirectDraw_StartModeTest(LPDIRECTDRAW7 iface, LPSIZE pModes,
			      DWORD dwNumModes, DWORD dwFlags)
{
1354
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1355
    FIXME("(%p)->() stub\n", This);
1356 1357 1358 1359

    return DD_OK;
}

1360
/*** Owned object management. */
1361

1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374
void Main_DirectDraw_AddSurface(IDirectDrawImpl* This,
				IDirectDrawSurfaceImpl* surface)
{
    assert(surface->ddraw_owner == NULL || surface->ddraw_owner == This);

    surface->ddraw_owner = This;

    /* where should it go? */
    surface->next_ddraw = This->surfaces;
    surface->prev_ddraw = NULL;
    if (This->surfaces)
	This->surfaces->prev_ddraw = surface;
    This->surfaces = surface;
1375 1376
}

1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391
void Main_DirectDraw_RemoveSurface(IDirectDrawImpl* This,
				   IDirectDrawSurfaceImpl* surface)
{
    assert(surface->ddraw_owner == This);

    if (This->surfaces == surface)
	This->surfaces = surface->next_ddraw;

    if (This->primary_surface == surface)
	This->primary_surface = NULL;

    if (surface->next_ddraw)
	surface->next_ddraw->prev_ddraw = surface->prev_ddraw;
    if (surface->prev_ddraw)
	surface->prev_ddraw->next_ddraw = surface->next_ddraw;
1392 1393
}

1394 1395 1396 1397
static void Main_DirectDraw_DeleteSurfaces(IDirectDrawImpl* This)
{
    while (This->surfaces != NULL)
	Main_DirectDrawSurface_ForceDestroy(This->surfaces);
1398 1399
}

1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411
void Main_DirectDraw_AddClipper(IDirectDrawImpl* This,
				IDirectDrawClipperImpl* clipper)
{
    assert(clipper->ddraw_owner == NULL || clipper->ddraw_owner == This);

    clipper->ddraw_owner = This;

    clipper->next_ddraw = This->clippers;
    clipper->prev_ddraw = NULL;
    if (This->clippers)
	This->clippers->prev_ddraw = clipper;
    This->clippers = clipper;
1412 1413
}

1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451
void Main_DirectDraw_RemoveClipper(IDirectDrawImpl* This,
				   IDirectDrawClipperImpl* clipper)
{
    assert(clipper->ddraw_owner == This);

    if (This->clippers == clipper)
	This->clippers = clipper->next_ddraw;

    if (clipper->next_ddraw)
	clipper->next_ddraw->prev_ddraw = clipper->prev_ddraw;
    if (clipper->prev_ddraw)
	clipper->prev_ddraw->next_ddraw = clipper->next_ddraw;
}

static void Main_DirectDraw_DeleteClippers(IDirectDrawImpl* This)
{
    while (This->clippers != NULL)
	Main_DirectDrawClipper_ForceDestroy(This->clippers);
}

void Main_DirectDraw_AddPalette(IDirectDrawImpl* This,
				IDirectDrawPaletteImpl* palette)
{
    assert(palette->ddraw_owner == NULL || palette->ddraw_owner == This);

    palette->ddraw_owner = This;

    /* where should it go? */
    palette->next_ddraw = This->palettes;
    palette->prev_ddraw = NULL;
    if (This->palettes)
	This->palettes->prev_ddraw = palette;
    This->palettes = palette;
}

void Main_DirectDraw_RemovePalette(IDirectDrawImpl* This,
				   IDirectDrawPaletteImpl* palette)
{
1452 1453
    IDirectDrawSurfaceImpl *surf;

1454 1455 1456 1457 1458 1459 1460 1461 1462
    assert(palette->ddraw_owner == This);

    if (This->palettes == palette)
	This->palettes = palette->next_ddraw;

    if (palette->next_ddraw)
	palette->next_ddraw->prev_ddraw = palette->prev_ddraw;
    if (palette->prev_ddraw)
	palette->prev_ddraw->next_ddraw = palette->next_ddraw;
1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473

    /* Here we need also to remove tha palette from any surface which has it as the
     * current palette (checked on Windows)
     */
    for (surf = This->surfaces; surf != NULL; surf = surf->next_ddraw) {
	if (surf->palette == palette) {
	    TRACE("Palette %p attached to surface %p.\n", palette, surf);
	    surf->palette = NULL;
	    surf->set_palette(surf, NULL);
	}
    }
1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504
}

static void Main_DirectDraw_DeletePalettes(IDirectDrawImpl* This)
{
    while (This->palettes != NULL)
	Main_DirectDrawPalette_ForceDestroy(This->palettes);
}

/*** ??? */

static void
LoseSurface(IDirectDrawSurfaceImpl *surface)
{
    if (surface != NULL) surface->lose_surface(surface);
}

static void
LosePrimarySurface(IDirectDrawImpl *This)
{
    /* MSDN: "If another application changes the display mode, the primary
     * surface is lost, and the method returns DDERR_SURFACELOST until the
     * primary surface is recreated to match the new display mode."
     *
     * We mark all the primary surfaces as lost as soon as the display
     * mode is changed (by any application). */

    LoseSurface(This->primary_surface);
}

/******************************************************************************
 * Uninitialised DirectDraw functions
1505
 *
1506 1507 1508 1509 1510 1511 1512 1513 1514
 * This vtable is used when a DirectDraw object is created with
 * CoCreateInstance. The only usable method is Initialize.
 */

void Uninit_DirectDraw_final_release(IDirectDrawImpl *This)
{
    Main_DirectDraw_final_release(This);
}

1515
static const IDirectDraw7Vtbl Uninit_DirectDraw_VTable;
1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556

/* Not called from the vtable. */
HRESULT Uninit_DirectDraw_Construct(IDirectDrawImpl *This, BOOL ex)
{
    HRESULT hr;

    hr = Main_DirectDraw_Construct(This, ex);
    if (FAILED(hr)) return hr;

    This->final_release = Uninit_DirectDraw_final_release;
    ICOM_INIT_INTERFACE(This, IDirectDraw7, Uninit_DirectDraw_VTable);

    return S_OK;
}

HRESULT Uninit_DirectDraw_Create(const GUID* pGUID,
				       LPDIRECTDRAW7* pIface,
				       IUnknown* pUnkOuter, BOOL ex)
{
    HRESULT hr;
    IDirectDrawImpl* This;

    assert(pUnkOuter == NULL); /* XXX no: we must check this */

    This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
		     sizeof(IDirectDrawImpl));
    if (This == NULL) return E_OUTOFMEMORY;

    hr = Uninit_DirectDraw_Construct(This, ex);
    if (FAILED(hr))
	HeapFree(GetProcessHeap(), HEAP_ZERO_MEMORY, This);
    else
	*pIface = ICOM_INTERFACE(This, IDirectDraw7);

    return hr;
}

static HRESULT WINAPI
Uninit_DirectDraw_Initialize(LPDIRECTDRAW7 iface, LPGUID pDeviceGuid)
{
    const ddraw_driver* driver;
1557
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1558

1559
    TRACE("(%p)->(%p)\n", iface, pDeviceGuid);
1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607

    driver = DDRAW_FindDriver(pDeviceGuid);
    /* XXX This return value is not documented. (Not checked.) */
    if (driver == NULL) return DDERR_INVALIDDIRECTDRAWGUID;

    return driver->init(This, pDeviceGuid);
}

static HRESULT WINAPI
Uninit_DirectDraw_Compact(LPDIRECTDRAW7 iface)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_CreateClipper(LPDIRECTDRAW7 iface, DWORD dwFlags,
				LPDIRECTDRAWCLIPPER *lplpDDClipper,
				IUnknown *pUnkOuter)

{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_CreatePalette(LPDIRECTDRAW7 iface, DWORD dwFlags,
				LPPALETTEENTRY lpColorTable,
				LPDIRECTDRAWPALETTE *lplpDDPalette,
				IUnknown *pUnkOuter)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_CreateSurface(LPDIRECTDRAW7 iface,
				LPDDSURFACEDESC2 lpDDSurfaceDesc,
				LPDIRECTDRAWSURFACE7 *lplpDDSurface,
				IUnknown *pUnkOuter)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_DuplicateSurface(LPDIRECTDRAW7 iface,
				   LPDIRECTDRAWSURFACE7 pSurf,
				   LPDIRECTDRAWSURFACE7 *pDupSurf)

{
    return DDERR_NOTINITIALIZED;
1608
}
1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754

static HRESULT WINAPI
Uninit_DirectDraw_EnumDisplayModes(LPDIRECTDRAW7 iface, DWORD dwFlags,
				   LPDDSURFACEDESC2 lpDDSD,
				   LPVOID context,
				   LPDDENUMMODESCALLBACK2 cb)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_EnumSurfaces(LPDIRECTDRAW7 iface, DWORD dwFlags,
			       LPDDSURFACEDESC2 pDDSD, LPVOID context,
			       LPDDENUMSURFACESCALLBACK7 cb)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_FlipToGDISurface(LPDIRECTDRAW7 iface)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_GetCaps(LPDIRECTDRAW7 iface, LPDDCAPS pDriverCaps,
			  LPDDCAPS pHELCaps)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_GetDisplayMode(LPDIRECTDRAW7 iface,
				 LPDDSURFACEDESC2 pDDSD)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_GetFourCCCodes(LPDIRECTDRAW7 iface, LPDWORD pNumCodes,
				 LPDWORD pCodes)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_GetGDISurface(LPDIRECTDRAW7 iface,
				LPDIRECTDRAWSURFACE7 *pGDISurf)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_GetMonitorFrequency(LPDIRECTDRAW7 iface, LPDWORD pdwFreq)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_GetScanLine(LPDIRECTDRAW7 iface, LPDWORD pdwScanLine)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_GetVerticalBlankStatus(LPDIRECTDRAW7 iface, PBOOL pbIsInVB)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_RestoreDisplayMode(LPDIRECTDRAW7 iface)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_SetCooperativeLevel(LPDIRECTDRAW7 iface, HWND hWnd,
				      DWORD dwFlags)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_SetDisplayMode(LPDIRECTDRAW7 iface, DWORD dwWidth,
				 DWORD dwHeight, DWORD dwBPP,
				 DWORD dwRefreshRate, DWORD dwFlags)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_WaitForVerticalBlank(LPDIRECTDRAW7 iface, DWORD dwFlags,
				       HANDLE hEvent)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_GetAvailableVidMem(LPDIRECTDRAW7 iface, LPDDSCAPS2 pDDCaps,
				     LPDWORD pdwTotal, LPDWORD pdwFree)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_GetSurfaceFromDC(LPDIRECTDRAW7 iface, HDC hDC,
				   LPDIRECTDRAWSURFACE7 *pSurf)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_RestoreAllSurfaces(LPDIRECTDRAW7 iface)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_TestCooperativeLevel(LPDIRECTDRAW7 iface)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_GetDeviceIdentifier(LPDIRECTDRAW7 iface,
				      LPDDDEVICEIDENTIFIER2 pDDDI,
				      DWORD dwFlags)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_StartModeTest(LPDIRECTDRAW7 iface, LPSIZE pszModes,
				DWORD cModes, DWORD dwFlags)
{
    return DDERR_NOTINITIALIZED;
}

static HRESULT WINAPI
Uninit_DirectDraw_EvaluateMode(LPDIRECTDRAW7 iface, DWORD dwFlags,
			       LPDWORD pTimeout)
{
    return DDERR_NOTINITIALIZED;
}

1755
static const IDirectDraw7Vtbl Uninit_DirectDraw_VTable =
1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787
{
    Main_DirectDraw_QueryInterface,
    Main_DirectDraw_AddRef,
    Main_DirectDraw_Release,
    Uninit_DirectDraw_Compact,
    Uninit_DirectDraw_CreateClipper,
    Uninit_DirectDraw_CreatePalette,
    Uninit_DirectDraw_CreateSurface,
    Uninit_DirectDraw_DuplicateSurface,
    Uninit_DirectDraw_EnumDisplayModes,
    Uninit_DirectDraw_EnumSurfaces,
    Uninit_DirectDraw_FlipToGDISurface,
    Uninit_DirectDraw_GetCaps,
    Uninit_DirectDraw_GetDisplayMode,
    Uninit_DirectDraw_GetFourCCCodes,
    Uninit_DirectDraw_GetGDISurface,
    Uninit_DirectDraw_GetMonitorFrequency,
    Uninit_DirectDraw_GetScanLine,
    Uninit_DirectDraw_GetVerticalBlankStatus,
    Uninit_DirectDraw_Initialize,
    Uninit_DirectDraw_RestoreDisplayMode,
    Uninit_DirectDraw_SetCooperativeLevel,
    Uninit_DirectDraw_SetDisplayMode,
    Uninit_DirectDraw_WaitForVerticalBlank,
    Uninit_DirectDraw_GetAvailableVidMem,
    Uninit_DirectDraw_GetSurfaceFromDC,
    Uninit_DirectDraw_RestoreAllSurfaces,
    Uninit_DirectDraw_TestCooperativeLevel,
    Uninit_DirectDraw_GetDeviceIdentifier,
    Uninit_DirectDraw_StartModeTest,
    Uninit_DirectDraw_EvaluateMode
};