main.c File Reference

#include "config.h"
#include "wine/port.h"
#include "ddraw_private.h"
#include "rpcproxy.h"
#include "wine/exception.h"
#include "winreg.h"

Include dependency graph for main.c:

Go to the source code of this file.

Classes
struct	callback_info
struct	ddraw_class_factory

Macros
#define	DDRAW_INIT_GUID

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ddraw)
static BOOL CALLBACK	enum_callback (GUID *guid, char *description, char *driver_name, void *context, HMONITOR monitor)
static void	ddraw_enumerate_secondary_devices (struct wined3d *wined3d, LPDDENUMCALLBACKEXA callback, void *context)
BOOL	ddraw_handle_table_init (struct ddraw_handle_table *t, UINT initial_size)
void	ddraw_handle_table_destroy (struct ddraw_handle_table *t)
DWORD	ddraw_allocate_handle (struct ddraw_handle_table *t, void *object, enum ddraw_handle_type type)
void *	ddraw_free_handle (struct ddraw_handle_table *t, DWORD handle, enum ddraw_handle_type type)
void *	ddraw_get_object (struct ddraw_handle_table *t, DWORD handle, enum ddraw_handle_type type)
HRESULT WINAPI	GetSurfaceFromDC (HDC dc, IDirectDrawSurface4 **surface, HDC *device_dc)
static HRESULT	DDRAW_Create (const GUID *guid, void **DD, IUnknown *UnkOuter, REFIID iid)
HRESULT WINAPI DECLSPEC_HOTPATCH	DirectDrawCreate (GUID *driver_guid, IDirectDraw **ddraw, IUnknown *outer)
HRESULT WINAPI DECLSPEC_HOTPATCH	DirectDrawCreateEx (GUID *driver_guid, void **ddraw, REFIID interface_iid, IUnknown *outer)
HRESULT WINAPI	DirectDrawEnumerateA (LPDDENUMCALLBACKA callback, void *context)
HRESULT WINAPI	DirectDrawEnumerateExA (LPDDENUMCALLBACKEXA callback, void *context, DWORD flags)
HRESULT WINAPI	DirectDrawEnumerateW (LPDDENUMCALLBACKW callback, void *context)
HRESULT WINAPI	DirectDrawEnumerateExW (LPDDENUMCALLBACKEXW callback, void *context, DWORD flags)
static HRESULT	CF_CreateDirectDraw (IUnknown *UnkOuter, REFIID iid, void **obj)
static HRESULT	CF_CreateDirectDrawClipper (IUnknown *UnkOuter, REFIID riid, void **obj)
static struct ddraw_class_factory *	impl_from_IClassFactory (IClassFactory *iface)
static HRESULT WINAPI	ddraw_class_factory_QueryInterface (IClassFactory *iface, REFIID riid, void **out)
static ULONG WINAPI	ddraw_class_factory_AddRef (IClassFactory *iface)
static ULONG WINAPI	ddraw_class_factory_Release (IClassFactory *iface)
static HRESULT WINAPI	ddraw_class_factory_CreateInstance (IClassFactory *iface, IUnknown *outer_unknown, REFIID riid, void **out)
static HRESULT WINAPI	ddraw_class_factory_LockServer (IClassFactory *iface, BOOL dolock)
HRESULT WINAPI	DllGetClassObject (REFCLSID rclsid, REFIID riid, void **out)
HRESULT WINAPI	DllCanUnloadNow (void)
HRESULT WINAPI	DllRegisterServer (void)
HRESULT WINAPI	DllUnregisterServer (void)
BOOL WINAPI	DllMain (HINSTANCE inst, DWORD reason, void *reserved)

Variables
static struct list	global_ddraw_list = LIST_INIT(global_ddraw_list)
static HINSTANCE	instance
DWORD	force_refresh_rate = 0
static const struct object_creation_info	object_creation []
static const IClassFactoryVtbl	IClassFactory_Vtbl

Macro Definition Documentation

DDRAW_INIT_GUID

#define DDRAW_INIT_GUID

Definition at line 27 of file main.c.

Function Documentation

CF_CreateDirectDraw()

static HRESULT CF_CreateDirectDraw ( IUnknown *  UnkOuter, REFIID  iid, void **  obj  )

static

Definition at line 530 of file main.c.

{
    HRESULT hr;
 
    TRACE("outer_unknown %p, riid %s, object %p.\n", UnkOuter, debugstr_guid(iid), obj);
 
    wined3d_mutex_lock();
    hr = DDRAW_Create(NULL, obj, UnkOuter, iid);
    wined3d_mutex_unlock();
 
    return hr;
}

CF_CreateDirectDrawClipper()

static HRESULT CF_CreateDirectDrawClipper ( IUnknown *  UnkOuter, REFIID  riid, void **  obj  )

static

Definition at line 559 of file main.c.

{
    HRESULT hr;
    IDirectDrawClipper *Clip;
 
    TRACE("outer_unknown %p, riid %s, object %p.\n", UnkOuter, debugstr_guid(riid), obj);
 
    wined3d_mutex_lock();
    hr = DirectDrawCreateClipper(0, &Clip, UnkOuter);
    if (hr != DD_OK)
    {
        wined3d_mutex_unlock();
        return hr;
    }
 
    hr = IDirectDrawClipper_QueryInterface(Clip, riid, obj);
    IDirectDrawClipper_Release(Clip);
 
    wined3d_mutex_unlock();
 
    return hr;
}

ddraw_allocate_handle()

DWORD ddraw_allocate_handle	(	struct ddraw_handle_table *	t,
		void *	object,
		enum ddraw_handle_type	type
	)

Definition at line 113 of file main.c.

{
    struct ddraw_handle_entry *entry;
 
    if (t->free_entries)
    {
        DWORD idx = t->free_entries - t->entries;
        /* Use a free handle */
        entry = t->free_entries;
        if (entry->type != DDRAW_HANDLE_FREE)
        {
            ERR("Handle %#x (%p) is in the free list, but has type %#x.\n", idx, entry->object, entry->type);
            return DDRAW_INVALID_HANDLE;
        }
        t->free_entries = entry->object;
        entry->object = object;
        entry->type = type;
 
        return idx;
    }
 
    if (!(t->entry_count < t->table_size))
    {
        /* Grow the table */
        UINT new_size = t->table_size + (t->table_size >> 1);
        struct ddraw_handle_entry *new_entries;
 
        if (!(new_entries = heap_realloc(t->entries, new_size * sizeof(*t->entries))))
        {
            ERR("Failed to grow the handle table.\n");
            return DDRAW_INVALID_HANDLE;
        }
        t->entries = new_entries;
        t->table_size = new_size;
    }
 
    entry = &t->entries[t->entry_count];
    entry->object = object;
    entry->type = type;
 
    return t->entry_count++;
}

Referenced by d3d_device1_CreateMatrix(), d3d_device7_CreateStateBlock(), d3d_device7_EndStateBlock(), d3d_material3_GetHandle(), and d3d_texture2_GetHandle().

ddraw_class_factory_AddRef()

static ULONG WINAPI ddraw_class_factory_AddRef ( IClassFactory *  iface )

static

Definition at line 643 of file main.c.

{
    struct ddraw_class_factory *factory = impl_from_IClassFactory(iface);
    ULONG ref = InterlockedIncrement(&factory->ref);
 
    TRACE("%p increasing refcount to %u.\n", factory, ref);
 
    return ref;
}

ddraw_class_factory_CreateInstance()

static HRESULT WINAPI ddraw_class_factory_CreateInstance ( IClassFactory *  iface, IUnknown *  outer_unknown, REFIID  riid, void **  out  )

static

Definition at line 689 of file main.c.

{
    struct ddraw_class_factory *factory = impl_from_IClassFactory(iface);
 
    TRACE("iface %p, outer_unknown %p, riid %s, out %p.\n",
            iface, outer_unknown, debugstr_guid(riid), out);
 
    return factory->pfnCreateInstance(outer_unknown, riid, out);
}

ddraw_class_factory_LockServer()

static HRESULT WINAPI ddraw_class_factory_LockServer ( IClassFactory *  iface, BOOL  dolock  )

static

Definition at line 712 of file main.c.

{
    FIXME("iface %p, dolock %#x stub!\n", iface, dolock);
 
    return S_OK;
}

ddraw_class_factory_QueryInterface()

static HRESULT WINAPI ddraw_class_factory_QueryInterface ( IClassFactory *  iface, REFIID  riid, void **  out  )

static

Definition at line 617 of file main.c.

{
    TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 
    if (IsEqualGUID(riid, &IID_IUnknown)
        || IsEqualGUID(riid, &IID_IClassFactory))
    {
        IClassFactory_AddRef(iface);
        *out = iface;
        return S_OK;
    }
 
    WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 
    return E_NOINTERFACE;
}

ddraw_class_factory_Release()

static ULONG WINAPI ddraw_class_factory_Release ( IClassFactory *  iface )

static

Definition at line 663 of file main.c.

{
    struct ddraw_class_factory *factory = impl_from_IClassFactory(iface);
    ULONG ref = InterlockedDecrement(&factory->ref);
 
    TRACE("%p decreasing refcount to %u.\n", factory, ref);
 
    if (!ref)
        heap_free(factory);
 
    return ref;
}

DDRAW_Create()

static HRESULT DDRAW_Create ( const GUID *  guid, void **  DD, IUnknown *  UnkOuter, REFIID  iid  )

static

Definition at line 260 of file main.c.

{
    enum wined3d_device_type device_type;
    struct ddraw *ddraw;
    HRESULT hr;
    DWORD flags = 0;
 
    TRACE("driver_guid %s, ddraw %p, outer_unknown %p, interface_iid %s.\n",
            debugstr_guid(guid), DD, UnkOuter, debugstr_guid(iid));
 
    *DD = NULL;
 
    if (guid == (GUID *) DDCREATE_EMULATIONONLY)
    {
        /* Use the reference device id. This doesn't actually change anything,
         * WineD3D always uses OpenGL for D3D rendering. One could make it request
         * indirect rendering
         */
        device_type = WINED3D_DEVICE_TYPE_REF;
    }
    else if(guid == (GUID *) DDCREATE_HARDWAREONLY)
    {
        device_type = WINED3D_DEVICE_TYPE_HAL;
    }
    else
    {
        device_type = 0;
    }
 
    /* DDraw doesn't support aggregation, according to msdn */
    if (UnkOuter != NULL)
        return CLASS_E_NOAGGREGATION;
 
    if (!IsEqualGUID(iid, &IID_IDirectDraw7))
        flags = WINED3D_LEGACY_FFP_LIGHTING;
 
    /* DirectDraw creation comes here */
    if (!(ddraw = heap_alloc_zero(sizeof(*ddraw))))
    {
        ERR("Out of memory when creating DirectDraw\n");
        return E_OUTOFMEMORY;
    }
 
    hr = ddraw_init(ddraw, flags, device_type);
    if (FAILED(hr))
    {
        WARN("Failed to initialize ddraw object, hr %#x.\n", hr);
        heap_free(ddraw);
        return hr;
    }
 
    hr = IDirectDraw7_QueryInterface(&ddraw->IDirectDraw7_iface, iid, DD);
    IDirectDraw7_Release(&ddraw->IDirectDraw7_iface);
    if (SUCCEEDED(hr))
        list_add_head(&global_ddraw_list, &ddraw->ddraw_list_entry);
    else
        WARN("Failed to query interface %s from ddraw object %p.\n", debugstr_guid(iid), ddraw);
 
    return hr;
}

Referenced by CF_CreateDirectDraw(), DirectDrawCreate(), and DirectDrawCreateEx().

ddraw_enumerate_secondary_devices()

static void ddraw_enumerate_secondary_devices ( struct wined3d *  wined3d, LPDDENUMCALLBACKEXA  callback, void *  context  )

static

Definition at line 59 of file main.c.

{
    struct wined3d_adapter_identifier adapter_id;
    struct wined3d_output_desc output_desc;
    BOOL cont_enum = TRUE;
    HRESULT hr = S_OK;
    UINT adapter = 0;
 
    for (adapter = 0; SUCCEEDED(hr) && cont_enum; adapter++)
    {
        char DriverName[512] = "", DriverDescription[512] = "";
 
        /* The Battle.net System Checker expects the GetAdapterIdentifier DeviceName to match the
         * Driver Name, so obtain the DeviceName and GUID from D3D. */
        memset(&adapter_id, 0x0, sizeof(adapter_id));
        adapter_id.device_name = DriverName;
        adapter_id.device_name_size = sizeof(DriverName);
        adapter_id.description = DriverDescription;
        adapter_id.description_size = sizeof(DriverDescription);
        wined3d_mutex_lock();
        if (SUCCEEDED(hr = wined3d_get_adapter_identifier(wined3d, adapter, 0x0, &adapter_id)))
            hr = wined3d_get_output_desc(wined3d, adapter, &output_desc);
        wined3d_mutex_unlock();
        if (SUCCEEDED(hr))
        {
            TRACE("Interface %d: %s\n", adapter, wine_dbgstr_guid(&adapter_id.device_identifier));
            cont_enum = callback(&adapter_id.device_identifier, adapter_id.description,
                    adapter_id.device_name, context, output_desc.monitor);
        }
    }
}

Referenced by DirectDrawEnumerateExA().

ddraw_free_handle()

void * ddraw_free_handle	(	struct ddraw_handle_table *	t,
		DWORD	handle,
		enum ddraw_handle_type	type
	)

Definition at line 156 of file main.c.

{
    struct ddraw_handle_entry *entry;
    void *object;
 
    if (handle == DDRAW_INVALID_HANDLE || handle >= t->entry_count)
    {
        WARN("Invalid handle %#x passed.\n", handle);
        return NULL;
    }
 
    entry = &t->entries[handle];
    if (entry->type != type)
    {
        WARN("Handle %#x (%p) is not of type %#x.\n", handle, entry->object, type);
        return NULL;
    }
 
    object = entry->object;
    entry->object = t->free_entries;
    entry->type = DDRAW_HANDLE_FREE;
    t->free_entries = entry;
 
    return object;
}

Referenced by d3d_device1_DeleteMatrix(), d3d_device7_DeleteStateBlock(), d3d_material3_Release(), and ddraw_surface_wined3d_object_destroyed().

ddraw_get_object()

void * ddraw_get_object	(	struct ddraw_handle_table *	t,
		DWORD	handle,
		enum ddraw_handle_type	type
	)

Definition at line 182 of file main.c.

{
    struct ddraw_handle_entry *entry;
 
    if (handle == DDRAW_INVALID_HANDLE || handle >= t->entry_count)
    {
        WARN("Invalid handle %#x passed.\n", handle);
        return NULL;
    }
 
    entry = &t->entries[handle];
    if (entry->type != type)
    {
        WARN("Handle %#x (%p) is not of type %#x.\n", handle, entry->object, type);
        return NULL;
    }
 
    return entry->object;
}

Referenced by d3d_device1_GetMatrix(), d3d_device1_SetMatrix(), d3d_device3_SetLightState(), d3d_device3_SetRenderState(), d3d_device7_ApplyStateBlock(), d3d_device7_CaptureStateBlock(), and d3d_viewport_SetBackground().

ddraw_handle_table_destroy()

void ddraw_handle_table_destroy

(

struct ddraw_handle_table *

t

)

Definition at line 107 of file main.c.

{
    heap_free(t->entries);
    memset(t, 0, sizeof(*t));
}

Referenced by d3d_device_init(), and d3d_device_inner_Release().

ddraw_handle_table_init()

BOOL ddraw_handle_table_init	(	struct ddraw_handle_table *	t,
		UINT	initial_size
	)

Definition at line 93 of file main.c.

{
    if (!(t->entries = heap_alloc_zero(initial_size * sizeof(*t->entries))))
    {
        ERR("Failed to allocate handle table memory.\n");
        return FALSE;
    }
    t->free_entries = NULL;
    t->table_size = initial_size;
    t->entry_count = 0;
 
    return TRUE;
}

Referenced by d3d_device_init().

DirectDrawCreate()

HRESULT WINAPI DECLSPEC_HOTPATCH DirectDrawCreate	(	GUID *	driver_guid,
		IDirectDraw **	ddraw,
		IUnknown *	outer
	)

Definition at line 333 of file main.c.

{
    HRESULT hr;
 
    TRACE("driver_guid %s, ddraw %p, outer %p.\n",
            debugstr_guid(driver_guid), ddraw, outer);
 
    wined3d_mutex_lock();
    hr = DDRAW_Create(driver_guid, (void **)ddraw, outer, &IID_IDirectDraw);
    wined3d_mutex_unlock();
 
    if (SUCCEEDED(hr))
    {
        if (FAILED(hr = IDirectDraw_Initialize(*ddraw, driver_guid)))
            IDirectDraw_Release(*ddraw);
    }
 
    return hr;
}

DirectDrawCreateEx()

HRESULT WINAPI DECLSPEC_HOTPATCH DirectDrawCreateEx	(	GUID *	driver_guid,
		void **	ddraw,
		REFIID	interface_iid,
		IUnknown *	outer
	)

Definition at line 362 of file main.c.

{
    HRESULT hr;
 
    TRACE("driver_guid %s, ddraw %p, interface_iid %s, outer %p.\n",
            debugstr_guid(driver_guid), ddraw, debugstr_guid(interface_iid), outer);
 
    if (!IsEqualGUID(interface_iid, &IID_IDirectDraw7))
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
    hr = DDRAW_Create(driver_guid, ddraw, outer, interface_iid);
    wined3d_mutex_unlock();
 
    if (SUCCEEDED(hr))
    {
        IDirectDraw7 *ddraw7 = *(IDirectDraw7 **)ddraw;
        hr = IDirectDraw7_Initialize(ddraw7, driver_guid);
        if (FAILED(hr))
            IDirectDraw7_Release(ddraw7);
    }
 
    return hr;
}

DirectDrawEnumerateA()

HRESULT WINAPI DirectDrawEnumerateA	(	LPDDENUMCALLBACKA	callback,
		void *	context
	)

Definition at line 408 of file main.c.

{
    struct callback_info info;
 
    TRACE("callback %p, context %p.\n", callback, context);
 
    info.callback = callback;
    info.context = context;
    return DirectDrawEnumerateExA(enum_callback, &info, 0x0);
}

DirectDrawEnumerateExA()

HRESULT WINAPI DirectDrawEnumerateExA	(	LPDDENUMCALLBACKEXA	callback,
		void *	context,
		DWORD	flags
	)

Definition at line 428 of file main.c.

{
    struct wined3d *wined3d;
 
    TRACE("callback %p, context %p, flags %#x.\n", callback, context, flags);
 
    if (flags & ~(DDENUM_ATTACHEDSECONDARYDEVICES |
                  DDENUM_DETACHEDSECONDARYDEVICES |
                  DDENUM_NONDISPLAYDEVICES))
        return DDERR_INVALIDPARAMS;
 
    if (flags & ~DDENUM_ATTACHEDSECONDARYDEVICES)
        FIXME("flags 0x%08x not handled\n", flags & ~DDENUM_ATTACHEDSECONDARYDEVICES);
 
    TRACE("Enumerating ddraw interfaces\n");
    if (!(wined3d = wined3d_create(DDRAW_WINED3D_FLAGS)))
    {
        if (!(wined3d = wined3d_create(DDRAW_WINED3D_FLAGS | WINED3D_NO3D)))
        {
            WARN("Failed to create a wined3d object.\n");
            return E_FAIL;
        }
 
        WARN("Created a wined3d object without 3D support.\n");
    }
 
    __TRY
    {
        /* QuickTime expects the description "DirectDraw HAL" */
        static CHAR driver_desc[] = "DirectDraw HAL",
        driver_name[] = "display";
        BOOL cont_enum;
 
        TRACE("Default interface: DirectDraw HAL\n");
        cont_enum = callback(NULL, driver_desc, driver_name, context, 0);
 
        /* The Battle.net System Checker expects both a NULL device and a GUID-based device */
        if (cont_enum && (flags & DDENUM_ATTACHEDSECONDARYDEVICES))
            ddraw_enumerate_secondary_devices(wined3d, callback, context);
    }
    __EXCEPT_PAGE_FAULT
    {
        wined3d_decref(wined3d);
        return DDERR_INVALIDPARAMS;
    }
    __ENDTRY;
 
    wined3d_decref(wined3d);
    TRACE("End of enumeration\n");
    return DD_OK;
}

DirectDrawEnumerateExW()

HRESULT WINAPI DirectDrawEnumerateExW	(	LPDDENUMCALLBACKEXW	callback,
		void *	context,
		DWORD	flags
	)

Definition at line 504 of file main.c.

{
    TRACE("callback %p, context %p, flags %#x.\n", callback, context, flags);
 
    return DDERR_UNSUPPORTED;
}

DirectDrawEnumerateW()

HRESULT WINAPI DirectDrawEnumerateW	(	LPDDENUMCALLBACKW	callback,
		void *	context
	)

Definition at line 487 of file main.c.

{
    TRACE("callback %p, context %p.\n", callback, context);
 
    if (!callback)
        return DDERR_INVALIDPARAMS;
    else
        return DDERR_UNSUPPORTED;
}

DllCanUnloadNow()

HRESULT WINAPI DllCanUnloadNow

(

void

)

Definition at line 775 of file main.c.

{
    TRACE("\n");
 
    return S_FALSE;
}

DllGetClassObject()

HRESULT WINAPI DllGetClassObject	(	REFCLSID	rclsid,
		REFIID	riid,
		void **	out
	)

Definition at line 731 of file main.c.

{
    struct ddraw_class_factory *factory;
    unsigned int i;
 
    TRACE("rclsid %s, riid %s, out %p.\n",
            debugstr_guid(rclsid), debugstr_guid(riid), out);
 
    if (!IsEqualGUID(&IID_IClassFactory, riid)
            && !IsEqualGUID(&IID_IUnknown, riid))
        return E_NOINTERFACE;
 
    for (i=0; i < ARRAY_SIZE(object_creation); i++)
    {
        if (IsEqualGUID(object_creation[i].clsid, rclsid))
            break;
    }
 
    if (i == ARRAY_SIZE(object_creation))
    {
        FIXME("%s: no class found.\n", debugstr_guid(rclsid));
        return CLASS_E_CLASSNOTAVAILABLE;
    }
 
    if (!(factory = heap_alloc_zero(sizeof(*factory))))
        return E_OUTOFMEMORY;
 
    factory->IClassFactory_iface.lpVtbl = &IClassFactory_Vtbl;
    factory->ref = 1;
 
    factory->pfnCreateInstance = object_creation[i].pfnCreateInstance;
 
    *out = factory;
    return S_OK;
}

DllMain()

BOOL WINAPI DllMain	(	HINSTANCE	inst,
		DWORD	reason,
		void *	reserved
	)

Definition at line 801 of file main.c.

{
    switch (reason)
    {
    case DLL_PROCESS_ATTACH:
    {
        static HMODULE ddraw_self;
        HKEY hkey = 0;
        WNDCLASSA wc;
 
        /* Register the window class. This is used to create a hidden window
         * for D3D rendering, if the application didn't pass one. It can also
         * be used for creating a device window from SetCooperativeLevel(). */
        wc.style = CS_HREDRAW | CS_VREDRAW;
        wc.lpfnWndProc = DefWindowProcA;
        wc.cbClsExtra = 0;
        wc.cbWndExtra = 0;
        wc.hInstance = inst;
        wc.hIcon = 0;
        wc.hCursor = 0;
        wc.hbrBackground = GetStockObject(BLACK_BRUSH);
        wc.lpszMenuName = NULL;
        wc.lpszClassName = DDRAW_WINDOW_CLASS_NAME;
        if (!RegisterClassA(&wc))
        {
            ERR("Failed to register ddraw window class, last error %#x.\n", GetLastError());
            return FALSE;
        }
 
        /* On Windows one can force the refresh rate that DirectDraw uses by
         * setting an override value in dxdiag.  This is documented in KB315614
         * (main article), KB230002, and KB217348.  By comparing registry dumps
         * before and after setting the override, we see that the override value
         * is stored in HKLM\Software\Microsoft\DirectDraw\ForceRefreshRate as a
         * DWORD that represents the refresh rate to force.  We use this
         * registry entry to modify the behavior of SetDisplayMode so that Wine
         * users can override the refresh rate in a Windows-compatible way.
         *
         * dxdiag will not accept a refresh rate lower than 40 or higher than
         * 120 so this value should be within that range.  It is, of course,
         * possible for a user to set the registry entry value directly so that
         * assumption might not hold.
         *
         * There is no current mechanism for setting this value through the Wine
         * GUI.  It would be most appropriate to set this value through a dxdiag
         * clone, but it may be sufficient to use winecfg.
         *
         * TODO: Create a mechanism for setting this value through the Wine GUI.
         */
        if ( !RegOpenKeyA( HKEY_LOCAL_MACHINE, "Software\\Microsoft\\DirectDraw", &hkey ) )
        {
            DWORD type, data, size;
 
            size = sizeof(data);
            if (!RegQueryValueExA(hkey, "ForceRefreshRate", NULL, &type, (BYTE *)&data, &size) && type == REG_DWORD)
            {
                TRACE("ForceRefreshRate set; overriding refresh rate to %d Hz\n", data);
                force_refresh_rate = data;
            }
            RegCloseKey( hkey );
        }
 
        /* Prevent the ddraw module from being unloaded. When switching to
         * exclusive mode, we replace the window proc of the ddraw window. If
         * an application would unload ddraw from the WM_DESTROY handler for
         * that window, it would return to unmapped memory and die. Apparently
         * this is supposed to work on Windows. */
 
        /* ReactOS r61844: Comment out usage of GET_MODULE_HANDLE_EX_FLAG_PIN because it doesn't work */
        if (!GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS /*| GET_MODULE_HANDLE_EX_FLAG_PIN*/,
                (const WCHAR *)&ddraw_self, &ddraw_self))
            ERR("Failed to get own module handle.\n");
 
        instance = inst;
        DisableThreadLibraryCalls(inst);
        break;
    }
 
    case DLL_PROCESS_DETACH:
        if (WARN_ON(ddraw))
        {
            struct ddraw *ddraw;
 
            LIST_FOR_EACH_ENTRY(ddraw, &global_ddraw_list, struct ddraw, ddraw_list_entry)
            {
                struct ddraw_surface *surface;
 
                WARN("DirectDraw object %p has reference counts {%u, %u, %u, %u, %u}.\n",
                        ddraw, ddraw->ref7, ddraw->ref4, ddraw->ref3, ddraw->ref2, ddraw->ref1);
 
                if (ddraw->d3ddevice)
                    WARN("DirectDraw object %p has Direct3D device %p attached.\n", ddraw, ddraw->d3ddevice);
 
                LIST_FOR_EACH_ENTRY(surface, &ddraw->surface_list, struct ddraw_surface, surface_list_entry)
                {
                    WARN("Surface %p has reference counts {%u, %u, %u, %u, %u, %u}.\n",
                            surface, surface->ref7, surface->ref4, surface->ref3,
                            surface->ref2, surface->ref1, surface->gamma_count);
                }
            }
        }
 
        if (reserved) break;
        UnregisterClassA(DDRAW_WINDOW_CLASS_NAME, inst);
    }
 
    return TRUE;
}

DllRegisterServer()

HRESULT WINAPI DllRegisterServer

(

void

)

Definition at line 783 of file main.c.

{
    return __wine_register_resources( instance );
}

DllUnregisterServer()

HRESULT WINAPI DllUnregisterServer

(

void

)

Definition at line 788 of file main.c.

{
    return __wine_unregister_resources( instance );
}

enum_callback()

static BOOL CALLBACK enum_callback ( GUID *  guid, char *  description, char *  driver_name, void *  context, HMONITOR  monitor  )

static

Definition at line 51 of file main.c.

{
    const struct callback_info *info = context;
 
    return info->callback(guid, description, driver_name, info->context);
}

Referenced by DirectDrawEnumerateA().

GetSurfaceFromDC()

HRESULT WINAPI GetSurfaceFromDC	(	HDC	dc,
		IDirectDrawSurface4 **	surface,
		HDC *	device_dc
	)

Definition at line 202 of file main.c.

{
    struct ddraw *ddraw;
 
    TRACE("dc %p, surface %p, device_dc %p.\n", dc, surface, device_dc);
 
    if (!surface)
        return E_INVALIDARG;
 
    if (!device_dc)
    {
        *surface = NULL;
 
        return E_INVALIDARG;
    }
 
    wined3d_mutex_lock();
    LIST_FOR_EACH_ENTRY(ddraw, &global_ddraw_list, struct ddraw, ddraw_list_entry)
    {
        if (FAILED(IDirectDraw4_GetSurfaceFromDC(&ddraw->IDirectDraw4_iface, dc, surface)))
            continue;
 
        *device_dc = NULL; /* FIXME */
        wined3d_mutex_unlock();
        return DD_OK;
    }
    wined3d_mutex_unlock();
 
    *surface = NULL;
    *device_dc = NULL;
 
    return DDERR_NOTFOUND;
}

impl_from_IClassFactory()

static struct ddraw_class_factory * impl_from_IClassFactory ( IClassFactory *  iface )

inlinestatic

Definition at line 598 of file main.c.

{
    return CONTAINING_RECORD(iface, struct ddraw_class_factory, IClassFactory_iface);
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ddraw

)

Variable Documentation

force_refresh_rate

DWORD force_refresh_rate = 0

Definition at line 41 of file main.c.

Referenced by ddraw7_SetDisplayMode(), and DllMain().

global_ddraw_list

struct list global_ddraw_list = LIST_INIT(global_ddraw_list)

static

Definition at line 36 of file main.c.

Referenced by DDRAW_Create(), DllMain(), and GetSurfaceFromDC().

IClassFactory_Vtbl

const IClassFactoryVtbl IClassFactory_Vtbl

static

Initial value:

=
{
    ddraw_class_factory_QueryInterface,
    ddraw_class_factory_AddRef,
    ddraw_class_factory_Release,
    ddraw_class_factory_CreateInstance,
    ddraw_class_factory_LockServer
}

Definition at line 722 of file main.c.

Referenced by DllGetClassObject().

instance

HINSTANCE instance

static

Definition at line 38 of file main.c.

object_creation

const struct object_creation_info object_creation[]

static

Initial value:

=
{
    { &CLSID_DirectDraw,        CF_CreateDirectDraw },
    { &CLSID_DirectDraw7,       CF_CreateDirectDraw },
    { &CLSID_DirectDrawClipper, CF_CreateDirectDrawClipper }
}

Definition at line 583 of file main.c.