2000-04-09 16:30:50 +02:00
|
|
|
/* DirectDraw Base Functions
|
|
|
|
*
|
|
|
|
* Copyright 1997-1999 Marcus Meissner
|
|
|
|
* Copyright 1998 Lionel Ulmer (most of Direct3D stuff)
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <assert.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
|
|
|
|
#include "winerror.h"
|
|
|
|
#include "heap.h"
|
|
|
|
#include "dc.h"
|
|
|
|
#include "win.h"
|
|
|
|
#include "wine/exception.h"
|
|
|
|
#include "debugtools.h"
|
|
|
|
#include "message.h"
|
|
|
|
|
2000-08-03 06:22:35 +02:00
|
|
|
#include "initguid.h"
|
|
|
|
#include "ddraw.h"
|
|
|
|
#include "d3d.h"
|
|
|
|
|
2000-04-09 16:30:50 +02:00
|
|
|
/* This for all the enumeration and creation of D3D-related objects */
|
|
|
|
#include "ddraw_private.h"
|
|
|
|
|
|
|
|
#define MAX_DDRAW_DRIVERS 3
|
|
|
|
static ddraw_driver * ddraw_drivers[MAX_DDRAW_DRIVERS];
|
|
|
|
static int nrof_ddraw_drivers = 0;
|
|
|
|
|
|
|
|
DEFAULT_DEBUG_CHANNEL(ddraw);
|
|
|
|
|
|
|
|
/* register a direct draw driver. We better not use malloc for we are in
|
|
|
|
* the ELF startup initialisation at this point.
|
|
|
|
*/
|
|
|
|
void ddraw_register_driver(ddraw_driver *driver) {
|
|
|
|
ddraw_drivers[nrof_ddraw_drivers++] = driver;
|
|
|
|
|
|
|
|
/* increase MAX_DDRAW_DRIVERS if the line below triggers */
|
|
|
|
assert(nrof_ddraw_drivers <= MAX_DDRAW_DRIVERS);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**********************************************************************/
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
LPVOID lpCallback;
|
|
|
|
LPVOID lpContext;
|
|
|
|
} DirectDrawEnumerateProcData;
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* DirectDrawEnumerateExA (DDRAW.*)
|
|
|
|
*/
|
|
|
|
HRESULT WINAPI DirectDrawEnumerateExA(
|
|
|
|
LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
TRACE("(%p,%p, %08lx)\n", lpCallback, lpContext, dwFlags);
|
|
|
|
|
|
|
|
if (TRACE_ON(ddraw)) {
|
|
|
|
DPRINTF(" Flags : ");
|
|
|
|
if (dwFlags & DDENUM_ATTACHEDSECONDARYDEVICES)
|
|
|
|
DPRINTF("DDENUM_ATTACHEDSECONDARYDEVICES ");
|
|
|
|
if (dwFlags & DDENUM_DETACHEDSECONDARYDEVICES)
|
|
|
|
DPRINTF("DDENUM_DETACHEDSECONDARYDEVICES ");
|
|
|
|
if (dwFlags & DDENUM_NONDISPLAYDEVICES)
|
|
|
|
DPRINTF("DDENUM_NONDISPLAYDEVICES ");
|
|
|
|
DPRINTF("\n");
|
|
|
|
}
|
|
|
|
|
2000-05-13 03:28:49 +02:00
|
|
|
/* Invoke callback for what flags we do support */
|
2000-04-09 16:30:50 +02:00
|
|
|
for (i=0;i<MAX_DDRAW_DRIVERS;i++) {
|
|
|
|
if (!ddraw_drivers[i])
|
|
|
|
continue;
|
|
|
|
if (ddraw_drivers[i]->createDDRAW(NULL)) /* !0 is failing */
|
|
|
|
continue;
|
|
|
|
TRACE("Enumerating %s/%s interface\n",ddraw_drivers[i]->name,ddraw_drivers[i]->type);
|
|
|
|
if (!lpCallback(
|
|
|
|
ddraw_drivers[i]->guid,
|
|
|
|
(LPSTR)ddraw_drivers[i]->name,
|
|
|
|
(LPSTR)ddraw_drivers[i]->type,
|
|
|
|
lpContext,
|
|
|
|
0 /* FIXME: flags not supported here */
|
|
|
|
))
|
|
|
|
return DD_OK;
|
|
|
|
}
|
|
|
|
if (nrof_ddraw_drivers) {
|
|
|
|
TRACE("Enumerating the default interface\n");
|
|
|
|
if (!lpCallback(NULL,"WINE (default)", "display", lpContext, 0))
|
|
|
|
return DD_OK;
|
|
|
|
}
|
2000-05-13 03:28:49 +02:00
|
|
|
|
|
|
|
/* Unsupported flags */
|
|
|
|
if (dwFlags & DDENUM_NONDISPLAYDEVICES) {
|
|
|
|
FIXME("no non-display devices supported.\n");
|
|
|
|
}
|
|
|
|
/* Hmm. Leave this out.
|
|
|
|
if (dwFlags & DDENUM_ATTACHEDSECONDARYDEVICES) {
|
|
|
|
FIXME("no attached secondary devices supported.\n");
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
if (dwFlags & DDENUM_DETACHEDSECONDARYDEVICES) {
|
|
|
|
FIXME("no detached secondary devices supported.\n");
|
|
|
|
}
|
|
|
|
|
2000-04-09 16:30:50 +02:00
|
|
|
return DD_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* DirectDrawEnumerateExW (DDRAW.*)
|
|
|
|
*/
|
|
|
|
|
|
|
|
static BOOL CALLBACK DirectDrawEnumerateExProcW(
|
|
|
|
GUID *lpGUID, LPSTR lpDriverDescription, LPSTR lpDriverName,
|
|
|
|
LPVOID lpContext, HMONITOR hm)
|
|
|
|
{
|
|
|
|
DirectDrawEnumerateProcData *pEPD = (DirectDrawEnumerateProcData*)lpContext;
|
|
|
|
LPWSTR lpDriverDescriptionW =
|
|
|
|
HEAP_strdupAtoW(GetProcessHeap(), 0, lpDriverDescription);
|
|
|
|
LPWSTR lpDriverNameW =
|
|
|
|
HEAP_strdupAtoW(GetProcessHeap(), 0, lpDriverName);
|
|
|
|
|
|
|
|
BOOL bResult = (*(LPDDENUMCALLBACKEXW *) pEPD->lpCallback)(
|
|
|
|
lpGUID, lpDriverDescriptionW, lpDriverNameW, pEPD->lpContext, hm);
|
|
|
|
|
|
|
|
HeapFree(GetProcessHeap(), 0, lpDriverDescriptionW);
|
|
|
|
HeapFree(GetProcessHeap(), 0, lpDriverNameW);
|
|
|
|
return bResult;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**********************************************************************/
|
|
|
|
|
|
|
|
HRESULT WINAPI DirectDrawEnumerateExW(
|
|
|
|
LPDDENUMCALLBACKEXW lpCallback, LPVOID lpContext, DWORD dwFlags)
|
|
|
|
{
|
|
|
|
DirectDrawEnumerateProcData epd;
|
|
|
|
epd.lpCallback = (LPVOID) lpCallback;
|
|
|
|
epd.lpContext = lpContext;
|
|
|
|
|
|
|
|
return DirectDrawEnumerateExA(DirectDrawEnumerateExProcW, (LPVOID) &epd, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* DirectDrawEnumerateA (DDRAW.*)
|
|
|
|
*/
|
|
|
|
|
|
|
|
static BOOL CALLBACK DirectDrawEnumerateProcA(
|
|
|
|
GUID *lpGUID, LPSTR lpDriverDescription, LPSTR lpDriverName,
|
|
|
|
LPVOID lpContext, HMONITOR hm)
|
|
|
|
{
|
|
|
|
DirectDrawEnumerateProcData *pEPD = (DirectDrawEnumerateProcData*)lpContext;
|
|
|
|
|
|
|
|
return ((LPDDENUMCALLBACKA) pEPD->lpCallback)(
|
|
|
|
lpGUID, lpDriverDescription, lpDriverName, pEPD->lpContext);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**********************************************************************/
|
|
|
|
|
|
|
|
HRESULT WINAPI DirectDrawEnumerateA(
|
|
|
|
LPDDENUMCALLBACKA lpCallback, LPVOID lpContext)
|
|
|
|
{
|
|
|
|
DirectDrawEnumerateProcData epd;
|
|
|
|
epd.lpCallback = (LPVOID) lpCallback;
|
|
|
|
epd.lpContext = lpContext;
|
|
|
|
|
|
|
|
return DirectDrawEnumerateExA(DirectDrawEnumerateProcA, (LPVOID) &epd, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* DirectDrawEnumerateW (DDRAW.*)
|
|
|
|
*/
|
|
|
|
|
|
|
|
static BOOL WINAPI DirectDrawEnumerateProcW(
|
|
|
|
GUID *lpGUID, LPWSTR lpDriverDescription, LPWSTR lpDriverName,
|
|
|
|
LPVOID lpContext, HMONITOR hm)
|
|
|
|
{
|
|
|
|
DirectDrawEnumerateProcData *pEPD = (DirectDrawEnumerateProcData*)lpContext;
|
|
|
|
|
|
|
|
return ((LPDDENUMCALLBACKW) pEPD->lpCallback)(
|
|
|
|
lpGUID, lpDriverDescription, lpDriverName, pEPD->lpContext);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**********************************************************************/
|
|
|
|
|
|
|
|
HRESULT WINAPI DirectDrawEnumerateW(
|
|
|
|
LPDDENUMCALLBACKW lpCallback, LPVOID lpContext)
|
|
|
|
{
|
|
|
|
DirectDrawEnumerateProcData epd;
|
|
|
|
epd.lpCallback = (LPVOID) lpCallback;
|
|
|
|
epd.lpContext = lpContext;
|
|
|
|
|
|
|
|
return DirectDrawEnumerateExW(DirectDrawEnumerateProcW, (LPVOID) &epd, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
* DirectDraw Window Procedure
|
|
|
|
*/
|
|
|
|
static LRESULT WINAPI DDWndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
|
|
|
|
{
|
|
|
|
LRESULT ret;
|
|
|
|
IDirectDrawImpl* ddraw = NULL;
|
|
|
|
DWORD lastError;
|
|
|
|
|
|
|
|
/* FIXME(ddraw,"(0x%04x,%s,0x%08lx,0x%08lx),stub!\n",(int)hwnd,SPY_GetMsgName(msg),(long)wParam,(long)lParam); */
|
|
|
|
|
|
|
|
SetLastError( ERROR_SUCCESS );
|
|
|
|
ddraw = (IDirectDrawImpl*)GetPropA( hwnd, ddProp );
|
|
|
|
if( (!ddraw) && ( ( lastError = GetLastError() ) != ERROR_SUCCESS ))
|
|
|
|
ERR("Unable to retrieve this ptr from window. Error %08lx\n",lastError);
|
|
|
|
|
|
|
|
if( ddraw ) {
|
|
|
|
/* Perform any special direct draw functions */
|
|
|
|
if (msg==WM_PAINT)
|
2000-07-23 15:39:52 +02:00
|
|
|
ddraw->d->paintable = 1;
|
2000-04-09 16:30:50 +02:00
|
|
|
|
|
|
|
/* Now let the application deal with the rest of this */
|
2000-07-23 15:39:52 +02:00
|
|
|
if( ddraw->d->mainWindow ) {
|
2000-04-09 16:30:50 +02:00
|
|
|
|
|
|
|
/* Don't think that we actually need to call this but...
|
|
|
|
* might as well be on the safe side of things...
|
|
|
|
*/
|
|
|
|
|
2000-07-23 15:39:52 +02:00
|
|
|
/* I changed hwnd to ddraw->d->mainWindow as I did not see why
|
2000-04-09 16:30:50 +02:00
|
|
|
* it should be the procedures of our fake window that gets called
|
|
|
|
* instead of those of the window provided by the application.
|
|
|
|
* And with this patch, mouse clicks work with Monkey Island III
|
|
|
|
* - Lionel
|
|
|
|
*/
|
2000-07-23 15:39:52 +02:00
|
|
|
ret = DefWindowProcA( ddraw->d->mainWindow, msg, wParam, lParam );
|
2000-04-09 16:30:50 +02:00
|
|
|
|
|
|
|
if( !ret ) {
|
2000-07-23 15:39:52 +02:00
|
|
|
WND *tmpWnd =WIN_FindWndPtr(ddraw->d->mainWindow);
|
2000-04-09 16:30:50 +02:00
|
|
|
/* We didn't handle the message - give it to the application */
|
2000-07-23 15:39:52 +02:00
|
|
|
if (ddraw && ddraw->d->mainWindow && tmpWnd)
|
2000-04-09 16:30:50 +02:00
|
|
|
ret = CallWindowProcA(tmpWnd->winproc,
|
2000-07-23 15:39:52 +02:00
|
|
|
ddraw->d->mainWindow, msg, wParam, lParam );
|
2000-04-09 16:30:50 +02:00
|
|
|
WIN_ReleaseWndPtr(tmpWnd);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
} /* else FALLTHROUGH */
|
|
|
|
} /* else FALLTHROUGH */
|
|
|
|
return DefWindowProcA(hwnd,msg,wParam,lParam);
|
|
|
|
}
|
|
|
|
|
2000-04-15 22:44:21 +02:00
|
|
|
/***********************************************************************
|
|
|
|
* DirectDrawCreate
|
|
|
|
*/
|
2000-04-09 16:30:50 +02:00
|
|
|
HRESULT WINAPI DirectDrawCreate(
|
|
|
|
LPGUID lpGUID, LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnkOuter
|
|
|
|
) {
|
|
|
|
IDirectDrawImpl** ilplpDD=(IDirectDrawImpl**)lplpDD;
|
|
|
|
WNDCLASSA wc;
|
|
|
|
HRESULT ret = 0;
|
|
|
|
int i,drvindex=0;
|
2000-04-23 21:53:46 +02:00
|
|
|
GUID zeroGUID;
|
2000-04-09 16:30:50 +02:00
|
|
|
|
|
|
|
struct ddraw_driver *ddd = NULL;
|
|
|
|
|
|
|
|
if (!HIWORD(lpGUID)) lpGUID = NULL;
|
|
|
|
|
|
|
|
TRACE("(%s,%p,%p)\n",debugstr_guid(lpGUID),ilplpDD,pUnkOuter);
|
|
|
|
|
2000-04-23 21:53:46 +02:00
|
|
|
memset(&zeroGUID,0,sizeof(zeroGUID));
|
2000-04-09 16:30:50 +02:00
|
|
|
while (1) {
|
|
|
|
ddd = NULL;
|
|
|
|
if ( ( !lpGUID ) ||
|
2000-04-23 21:53:46 +02:00
|
|
|
( IsEqualGUID( &zeroGUID, lpGUID ) ) ||
|
2000-04-09 16:30:50 +02:00
|
|
|
( IsEqualGUID( &IID_IDirectDraw, lpGUID ) ) ||
|
|
|
|
( IsEqualGUID( &IID_IDirectDraw2, lpGUID ) ) ||
|
2000-05-13 03:28:49 +02:00
|
|
|
( IsEqualGUID( &IID_IDirectDraw4, lpGUID ) ) ||
|
|
|
|
( IsEqualGUID( &IID_IDirectDraw7, lpGUID ) )
|
2000-04-09 16:30:50 +02:00
|
|
|
) {
|
|
|
|
/* choose an interface out of the list */
|
|
|
|
for (i=0;i<nrof_ddraw_drivers;i++) {
|
|
|
|
ddraw_driver *xddd = ddraw_drivers[i];
|
|
|
|
if (!xddd)
|
|
|
|
continue;
|
|
|
|
if (!ddd || (ddd->preference<xddd->preference)) {
|
|
|
|
drvindex = i;
|
|
|
|
ddd = xddd;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (i=0;i<nrof_ddraw_drivers;i++) {
|
|
|
|
if (!ddraw_drivers[i])
|
|
|
|
continue;
|
|
|
|
if (IsEqualGUID(ddraw_drivers[i]->guid,lpGUID)) {
|
|
|
|
drvindex = i;
|
|
|
|
ddd = ddraw_drivers[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!ddd) {
|
|
|
|
if (!nrof_ddraw_drivers) {
|
|
|
|
ERR("DirectDrawCreate(%s,%p,%p): no DirectDraw drivers compiled in.\n",debugstr_guid(lpGUID),lplpDD,pUnkOuter);
|
|
|
|
return DDERR_NODIRECTDRAWHW;
|
|
|
|
}
|
|
|
|
ERR("DirectDrawCreate(%s,%p,%p): did not recognize requested GUID.\n",debugstr_guid(lpGUID),lplpDD,pUnkOuter);
|
|
|
|
return DDERR_INVALIDDIRECTDRAWGUID;
|
|
|
|
}
|
|
|
|
TRACE("using \"%s\" driver, calling %p\n",ddd->name,ddd->createDDRAW);
|
|
|
|
|
|
|
|
ret = ddd->createDDRAW(lplpDD);
|
|
|
|
if (!ret)
|
|
|
|
break;
|
|
|
|
ddraw_drivers[drvindex] = NULL; /* mark this one as unusable */
|
|
|
|
}
|
|
|
|
wc.style = CS_GLOBALCLASS;
|
|
|
|
wc.lpfnWndProc = DDWndProc;
|
|
|
|
wc.cbClsExtra = 0;
|
|
|
|
wc.cbWndExtra = 0;
|
|
|
|
|
|
|
|
/* We can be a child of the desktop since we're really important */
|
|
|
|
wc.hInstance= 0;
|
|
|
|
wc.hIcon = 0;
|
|
|
|
wc.hCursor = (HCURSOR)IDC_ARROWA;
|
|
|
|
wc.hbrBackground = NULL_BRUSH;
|
|
|
|
wc.lpszMenuName = 0;
|
|
|
|
wc.lpszClassName = "WINE_DirectDraw";
|
2000-07-23 15:39:52 +02:00
|
|
|
(*ilplpDD)->d->winclass = RegisterClassA(&wc);
|
2000-04-09 16:30:50 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2000-05-24 01:38:32 +02:00
|
|
|
/***********************************************************************
|
|
|
|
* DirectDrawCreateEx
|
|
|
|
*/
|
2000-05-13 03:28:49 +02:00
|
|
|
HRESULT WINAPI DirectDrawCreateEx(
|
|
|
|
LPGUID lpGUID, LPVOID* lplpDD, REFIID iid, LPUNKNOWN pUnkOuter
|
|
|
|
) {
|
|
|
|
FIXME(":semi stub\n");
|
|
|
|
/* I don't know about what functionality is unique to Ex */
|
2000-05-18 02:03:36 +02:00
|
|
|
return DirectDrawCreate(lpGUID,(LPDIRECTDRAW*)lplpDD,pUnkOuter);
|
2000-05-13 03:28:49 +02:00
|
|
|
}
|
|
|
|
|
2000-04-09 16:30:50 +02:00
|
|
|
/*******************************************************************************
|
|
|
|
* DirectDraw ClassFactory
|
|
|
|
*
|
|
|
|
* Heavily inspired (well, can you say completely copied :-) ) from DirectSound
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
typedef struct {
|
|
|
|
/* IUnknown fields */
|
|
|
|
ICOM_VFIELD(IClassFactory);
|
|
|
|
DWORD ref;
|
|
|
|
} IClassFactoryImpl;
|
|
|
|
|
|
|
|
static HRESULT WINAPI
|
|
|
|
DDCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
|
|
|
|
ICOM_THIS(IClassFactoryImpl,iface);
|
|
|
|
|
|
|
|
FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
|
|
|
|
return E_NOINTERFACE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ULONG WINAPI
|
|
|
|
DDCF_AddRef(LPCLASSFACTORY iface) {
|
|
|
|
ICOM_THIS(IClassFactoryImpl,iface);
|
|
|
|
return ++(This->ref);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ULONG WINAPI DDCF_Release(LPCLASSFACTORY iface) {
|
|
|
|
ICOM_THIS(IClassFactoryImpl,iface);
|
|
|
|
/* static class, won't be freed */
|
|
|
|
return --(This->ref);
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI DDCF_CreateInstance(
|
|
|
|
LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj
|
|
|
|
) {
|
|
|
|
ICOM_THIS(IClassFactoryImpl,iface);
|
|
|
|
|
|
|
|
TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
|
|
|
|
if ( ( IsEqualGUID( &IID_IDirectDraw, riid ) ) ||
|
|
|
|
( IsEqualGUID( &IID_IDirectDraw2, riid ) ) ||
|
|
|
|
( IsEqualGUID( &IID_IDirectDraw4, riid ) ) ) {
|
|
|
|
/* FIXME: reuse already created DirectDraw if present? */
|
|
|
|
return DirectDrawCreate((LPGUID) riid,(LPDIRECTDRAW*)ppobj,pOuter);
|
|
|
|
}
|
|
|
|
return CLASS_E_CLASSNOTAVAILABLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI DDCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
|
|
|
|
ICOM_THIS(IClassFactoryImpl,iface);
|
|
|
|
FIXME("(%p)->(%d),stub!\n",This,dolock);
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ICOM_VTABLE(IClassFactory) DDCF_Vtbl =
|
|
|
|
{
|
|
|
|
ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
|
|
|
|
DDCF_QueryInterface,
|
|
|
|
DDCF_AddRef,
|
|
|
|
DDCF_Release,
|
|
|
|
DDCF_CreateInstance,
|
|
|
|
DDCF_LockServer
|
|
|
|
};
|
|
|
|
static IClassFactoryImpl DDRAW_CF = {&DDCF_Vtbl, 1 };
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
|
|
* DllGetClassObject [DDRAW.13]
|
|
|
|
* Retrieves class object from a DLL object
|
|
|
|
*
|
|
|
|
* NOTES
|
|
|
|
* Docs say returns STDAPI
|
|
|
|
*
|
|
|
|
* PARAMS
|
|
|
|
* rclsid [I] CLSID for the class object
|
|
|
|
* riid [I] Reference to identifier of interface for class object
|
|
|
|
* ppv [O] Address of variable to receive interface pointer for riid
|
|
|
|
*
|
|
|
|
* RETURNS
|
|
|
|
* Success: S_OK
|
|
|
|
* Failure: CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY, E_INVALIDARG,
|
|
|
|
* E_UNEXPECTED
|
|
|
|
*/
|
|
|
|
DWORD WINAPI DDRAW_DllGetClassObject(REFCLSID rclsid,REFIID riid,LPVOID *ppv)
|
|
|
|
{
|
|
|
|
TRACE("(%p,%p,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
|
|
|
|
if ( IsEqualGUID( &IID_IClassFactory, riid ) ) {
|
|
|
|
*ppv = (LPVOID)&DDRAW_CF;
|
|
|
|
IClassFactory_AddRef((IClassFactory*)*ppv);
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
FIXME("(%p,%p,%p): no interface found.\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
|
|
|
|
return CLASS_E_CLASSNOTAVAILABLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
|
|
* DllCanUnloadNow [DDRAW.12] Determines whether the DLL is in use.
|
|
|
|
*
|
|
|
|
* RETURNS
|
|
|
|
* Success: S_OK
|
|
|
|
* Failure: S_FALSE
|
|
|
|
*/
|
|
|
|
DWORD WINAPI DDRAW_DllCanUnloadNow(void) {
|
|
|
|
FIXME("(void): stub\n");
|
|
|
|
return S_FALSE;
|
|
|
|
}
|