main.c File Reference

#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 **out, IUnknown *outer_unknown, 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)
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
struct ddraw_handle_table	global_handle_table
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 24 of file main.c.

Function Documentation

CF_CreateDirectDraw()

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

static

Definition at line 554 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 583 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 138 of file main.c.

{
    struct ddraw_handle_entry *entry;
 
    if (!t)
        t = &global_handle_table;
 
    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 %#lx (%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 = 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 667 of file main.c.

{
    struct ddraw_class_factory *factory = impl_from_IClassFactory(iface);
    ULONG ref = InterlockedIncrement(&factory->ref);
 
    TRACE("%p increasing refcount to %lu.\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 713 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 736 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 641 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 687 of file main.c.

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

DDRAW_Create()

static HRESULT DDRAW_Create ( const GUID *  guid, void **  out, IUnknown *  outer_unknown, REFIID  iid  )

static

Definition at line 293 of file main.c.

{
    enum wined3d_device_type device_type;
    struct ddraw *ddraw;
    DWORD flags = 0;
    HRESULT hr;
 
    TRACE("driver_guid %s, ddraw %p, outer_unknown %p, interface_iid %s.\n",
            debugstr_guid(guid), out, outer_unknown, debugstr_guid(iid));
 
    *out = NULL;
 
    if (guid == (GUID *) DDCREATE_EMULATIONONLY)
    {
        device_type = WINED3D_DEVICE_TYPE_REF;
    }
    else if (guid == (GUID *) DDCREATE_HARDWAREONLY)
    {
        device_type = WINED3D_DEVICE_TYPE_HAL;
    }
    else
    {
        device_type = WINED3D_DEVICE_TYPE_HAL;
    }
 
    /* DDraw doesn't support aggregation, according to msdn */
    if (outer_unknown != NULL)
        return CLASS_E_NOAGGREGATION;
 
    if (!IsEqualGUID(iid, &IID_IDirectDraw7))
        flags = WINED3D_LEGACY_FFP_LIGHTING;
 
    if (!(ddraw = calloc(1, sizeof(*ddraw))))
    {
        ERR("Out of memory when creating DirectDraw.\n");
        return E_OUTOFMEMORY;
    }
 
    if (FAILED(hr = ddraw_init(ddraw, flags, device_type)))
    {
        WARN("Failed to initialize ddraw object, hr %#lx.\n", hr);
        free(ddraw);
        return hr;
    }
 
    hr = IDirectDraw7_QueryInterface(&ddraw->IDirectDraw7_iface, iid, out);
    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 58 of file main.c.

{
    struct wined3d_adapter_identifier adapter_id;
    struct wined3d_adapter *wined3d_adapter;
    struct wined3d_output_desc output_desc;
    struct wined3d_output *wined3d_output;
    unsigned int interface_count = 0;
    unsigned int adapter_idx = 0;
    unsigned int output_idx;
    BOOL cont_enum = TRUE;
    HRESULT hr;
 
    while (cont_enum && (wined3d_adapter = wined3d_get_adapter(wined3d, adapter_idx)))
    {
        char device_name[512] = "", description[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.description = description;
        adapter_id.description_size = sizeof(description);
 
        wined3d_mutex_lock();
        if (FAILED(hr = wined3d_adapter_get_identifier(wined3d_adapter, 0x0, &adapter_id)))
        {
            WARN("Failed to get adapter identifier, hr %#lx.\n", hr);
            wined3d_mutex_unlock();
            break;
        }
        wined3d_mutex_unlock();
 
        for (output_idx = 0; cont_enum && (wined3d_output = wined3d_adapter_get_output(
                wined3d_adapter, output_idx)); ++output_idx)
        {
            wined3d_mutex_lock();
            if (FAILED(hr = wined3d_output_get_desc(wined3d_output, &output_desc)))
            {
                WARN("Failed to get output description, hr %#lx.\n", hr);
                wined3d_mutex_unlock();
                break;
            }
            wined3d_mutex_unlock();
 
            TRACE("Interface %u: %s\n", interface_count++,
                    wine_dbgstr_guid(&adapter_id.device_identifier));
            WideCharToMultiByte(CP_ACP, 0, output_desc.device_name, -1, device_name,
                    sizeof(device_name), NULL, NULL);
            cont_enum = callback(&adapter_id.device_identifier, adapter_id.description,
                    device_name, context, output_desc.monitor);
        }
 
        if (FAILED(hr))
            break;
 
        ++adapter_idx;
    }
}

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 184 of file main.c.

{
    struct ddraw_handle_entry *entry;
    void *object;
 
    if (!t)
        t = &global_handle_table;
 
    if (handle == DDRAW_INVALID_HANDLE || handle >= t->entry_count)
    {
        WARN("Invalid handle %#lx passed.\n", handle);
        return NULL;
    }
 
    entry = &t->entries[handle];
    if (entry->type != type)
    {
        WARN("Handle %#lx (%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 213 of file main.c.

{
    struct ddraw_handle_entry *entry;
 
    if (!t)
        t = &global_handle_table;
 
    if (handle == DDRAW_INVALID_HANDLE || handle >= t->entry_count)
    {
        WARN("Invalid handle %#lx passed.\n", handle);
        return NULL;
    }
 
    entry = &t->entries[handle];
    if (entry->type != type)
    {
        WARN("Handle %#lx (%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 132 of file main.c.

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

Referenced by d3d_device_init(), d3d_device_inner_Release(), and DllMain().

ddraw_handle_table_init()

BOOL ddraw_handle_table_init	(	struct ddraw_handle_table *	t,
		UINT	initial_size
	)

Definition at line 118 of file main.c.

{
    if (!(t->entries = calloc(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(), and DllMain().

DirectDrawCreate()

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

Definition at line 357 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 386 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 432 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 452 of file main.c.

{
    struct wined3d *wined3d;
 
    TRACE("callback %p, context %p, flags %#lx.\n", callback, context, flags);
 
    if (flags & ~(DDENUM_ATTACHEDSECONDARYDEVICES |
                  DDENUM_DETACHEDSECONDARYDEVICES |
                  DDENUM_NONDISPLAYDEVICES))
        return DDERR_INVALIDPARAMS;
 
    if (flags & ~DDENUM_ATTACHEDSECONDARYDEVICES)
        FIXME("flags %#lx 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 528 of file main.c.

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

DirectDrawEnumerateW()

HRESULT WINAPI DirectDrawEnumerateW	(	LPDDENUMCALLBACKW	callback,
		void *	context
	)

Definition at line 511 of file main.c.

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

DllGetClassObject()

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

Definition at line 755 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 = calloc(1, 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 800 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 %#lx.\n", GetLastError());
            return FALSE;
        }
 
        if (!ddraw_handle_table_init(&global_handle_table, 64))
        {
            UnregisterClassA(DDRAW_WINDOW_CLASS_NAME, inst);
            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 %ld 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. */
        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;
            unsigned int i;
 
            LIST_FOR_EACH_ENTRY(ddraw, &global_ddraw_list, struct ddraw, ddraw_list_entry)
            {
                struct ddraw_surface *surface;
 
                WARN("DirectDraw object %p has reference counts {%lu, %lu, %lu, %lu, %lu}.\n",
                        ddraw, ddraw->ref7, ddraw->ref4, ddraw->ref3, ddraw->ref2, ddraw->ref1);
 
                if (!list_empty(&ddraw->d3ddevice_list))
                    WARN("DirectDraw object %p has Direct3D device(s) attached.\n", ddraw);
 
                LIST_FOR_EACH_ENTRY(surface, &ddraw->surface_list, struct ddraw_surface, surface_list_entry)
                {
                    WARN("Surface %p has reference counts {%lu, %lu, %lu, %lu, %lu, %lu}.\n",
                            surface, surface->ref7, surface->ref4, surface->ref3,
                            surface->ref2, surface->ref1, surface->gamma_count);
                }
            }
 
            for (i = 0; i < global_handle_table.entry_count; ++i)
            {
                struct ddraw_handle_entry *entry = &global_handle_table.entries[i];
 
                switch (entry->type)
                {
                    case DDRAW_HANDLE_FREE:
                        break;
 
                    case DDRAW_HANDLE_MATERIAL:
                        WARN("Material handle %#x (%p) not unset properly.\n", i + 1, entry->object);
                        break;
 
                    case DDRAW_HANDLE_SURFACE:
                        WARN("Texture handle %#x (%p) not unset properly.\n", i + 1, entry->object);
                        break;
 
                    case DDRAW_HANDLE_MATRIX:
                        WARN("Leftover matrix handle %#x (%p), deleting.\n", i + 1, entry->object);
                        break;
 
                    default:
                        WARN("Handle %#x (%p) has unknown type %#x.\n", i + 1, entry->object, entry->type);
                        break;
                }
            }
            ddraw_handle_table_destroy(&global_handle_table);
        }
 
        if (reserved) break;
        UnregisterClassA(DDRAW_WINDOW_CLASS_NAME, inst);
    }
 
    return TRUE;
}

enum_callback()

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

static

Definition at line 50 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 236 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 622 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 38 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 33 of file main.c.

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

global_handle_table

struct ddraw_handle_table global_handle_table

Definition at line 40 of file main.c.

Referenced by d3d_device2_SwapTextureHandles(), ddraw_allocate_handle(), ddraw_free_handle(), ddraw_get_object(), and DllMain().

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 746 of file main.c.

Referenced by DllGetClassObject().

instance

HINSTANCE instance

static

Definition at line 35 of file main.c.

Referenced by _dump_EnumObjects_flags(), CExplorerBand::_GetTitle(), AtlAxDialogBoxA(), AtlAxDialogBoxW(), CallbackMayRunLong(), connection_collector(), CreateWindowExA(), CreateWindowExW(), d3d12_device_create(), d3d12_device_init(), d3d12_get_vk_physical_device(), D3D12CreateDevice(), dde_execute(), dde_request(), DECLARE_INTERFACE_(), disassociate2_cb(), disassociate3_cb(), disassociate_cb(), DllMain(), DllRegisterServer(), DllUnregisterServer(), DP_IF_EnumGroupPlayers(), DP_IF_EnumGroupsInGroup(), dummy_callback(), enum_devices_callback(), factory_ActivateInstance(), fake_dll_main(), FilterMapper3_RegisterFilter(), FilterMapper3_UnregisterFilter(), get_dom_element(), getItemAndInstanceFromTable(), getItemAndIntegerInstanceFromOid(), ICONTITLE_Create(), IDirectPlay2AImpl_EnumGroupPlayers(), IDirectPlay2AImpl_EnumGroups(), IDirectPlay2AImpl_EnumPlayers(), IDirectPlay2Impl_EnumGroupPlayers(), IDirectPlay2Impl_EnumGroups(), IDirectPlay2Impl_EnumPlayers(), IDirectPlay3AImpl_EnumGroupPlayers(), IDirectPlay3AImpl_EnumGroups(), IDirectPlay3AImpl_EnumGroupsInGroup(), IDirectPlay3AImpl_EnumPlayers(), IDirectPlay3Impl_EnumGroupPlayers(), IDirectPlay3Impl_EnumGroups(), IDirectPlay3Impl_EnumGroupsInGroup(), IDirectPlay3Impl_EnumPlayers(), IDirectPlay4AImpl_EnumGroupPlayers(), IDirectPlay4AImpl_EnumGroups(), IDirectPlay4AImpl_EnumGroupsInGroup(), IDirectPlay4AImpl_EnumPlayers(), IDirectPlay4Impl_EnumGroupPlayers(), IDirectPlay4Impl_EnumGroups(), IDirectPlay4Impl_EnumGroupsInGroup(), IDirectPlay4Impl_EnumPlayers(), impl_from_TP_CALLBACK_INSTANCE(), instance_semaphore_completion_cb(), ldap_cleanup(), ldap_startup(), load_string(), LoadStringA(), LoadStringW(), map_A_to_W(), map_W_to_A(), MPEG3_StreamClose(), MPEG3_StreamConvert(), MPEG3_StreamOpen(), NPP_Destroy(), NPP_New(), NPP_SetWindow(), PdhMakeCounterPathW(), PerfCreateInstance(), PerfDeleteInstance(), PerfSetCounterRefValue(), property_set_Get(), property_set_Set(), RoActivateInstance(), setOidWithItemAndInteger(), simple_group_cancel_cb(), SortTest::sort4(), START_TEST(), task_callback(), test_build_action_map(), test_desktop_winproc(), test_parser(), test_progman_dde(), test_progman_dde2(), test_provider_init(), test_request_groups(), time_stamp_callback(), tp_io_callback(), tp_object_execute(), TpCallbackLeaveCriticalSectionOnCompletion(), TpCallbackMayRunLong(), TpCallbackReleaseMutexOnCompletion(), TpCallbackReleaseSemaphoreOnCompletion(), TpCallbackSetEventOnCompletion(), TpCallbackUnloadDllOnCompletion(), TpDisassociateCallback(), vkd3d_create_device(), vkd3d_create_instance(), vkd3d_create_thread(), vkd3d_destroy_instance(), vkd3d_init_debug_report(), vkd3d_init_instance_caps(), vkd3d_init_vk_global_procs(), vkd3d_instance_decref(), vkd3d_instance_get_vk_instance(), vkd3d_instance_incref(), vkd3d_instance_init(), vkd3d_join_thread(), vkd3d_load_vk_instance_procs(), vkd3d_select_physical_device(), VSSAPI_CVssWriter_Initialize(), and wined3d_init_vulkan().

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 607 of file main.c.