* Sync with trunk r64401.

svn path=/branches/shell-experiments/; revision=64405

dll/directx/wine/CMakeLists.txt

@@ -3,6 +3,7 @@ add_subdirectory(amstream)
 add_subdirectory(d3d8)
 add_subdirectory(d3d9)
 add_subdirectory(d3dcompiler_43)
+add_subdirectory(d3drm)
 add_subdirectory(d3dx9_24)
 add_subdirectory(d3dx9_25)
 add_subdirectory(d3dx9_26)

dll/directx/wine/d3drm/CMakeLists.txt

@@ -0,0 +1,35 @@
+
+add_definitions(-D__WINESRC__)
+include_directories(${REACTOS_SOURCE_DIR}/include/reactos/wine)
+spec2def(d3drm.dll d3drm.spec)
+
+list(APPEND SOURCE
+    d3drm.c
+    d3drm_main.c
+    device.c
+    face.c
+    frame.c
+    light.c
+    material.c
+    math.c
+    meshbuilder.c
+    texture.c
+    viewport.c
+    d3drm_private.h)
+
+add_library(d3drm SHARED
+    ${SOURCE}
+    version.rc
+    ${CMAKE_CURRENT_BINARY_DIR}/d3drm_stubs.c
+    ${CMAKE_CURRENT_BINARY_DIR}/d3drm.def)
+
+set_module_type(d3drm win32dll UNICODE)
+target_link_libraries(d3drm dxguid uuid wine)
+
+if(CMAKE_C_COMPILER_ID STREQUAL "Clang")
+    target_link_libraries(d3drm mingwex)
+endif()
+
+add_importlibs(d3drm d3dxof msvcrt kernel32 ntdll)
+add_pch(d3drm d3drm_private.h SOURCE)
+add_cd_file(TARGET d3drm DESTINATION reactos/system32 FOR all)

dll/directx/wine/d3drm/d3drm.spec

@@ -0,0 +1,23 @@
+@ stdcall D3DRMColorGetAlpha(long)
+@ stdcall D3DRMColorGetBlue(long)
+@ stdcall D3DRMColorGetGreen(long)
+@ stdcall D3DRMColorGetRed(long)
+@ stdcall D3DRMCreateColorRGB(float float float)
+@ stdcall D3DRMCreateColorRGBA(float float float float)
+@ stdcall D3DRMMatrixFromQuaternion(ptr ptr)
+@ stdcall D3DRMQuaternionFromRotation(ptr ptr float)
+@ stdcall D3DRMQuaternionMultiply(ptr ptr ptr)
+@ stdcall D3DRMQuaternionSlerp(ptr ptr ptr float)
+@ stdcall D3DRMVectorAdd(ptr ptr ptr)
+@ stdcall D3DRMVectorCrossProduct(ptr ptr ptr)
+@ stdcall D3DRMVectorDotProduct(ptr ptr)
+@ stdcall D3DRMVectorModulus(ptr)
+@ stdcall D3DRMVectorNormalize(ptr)
+@ stdcall D3DRMVectorRandom(ptr)
+@ stdcall D3DRMVectorReflect(ptr ptr ptr)
+@ stdcall D3DRMVectorRotate(ptr ptr ptr float)
+@ stdcall D3DRMVectorScale(ptr ptr float)
+@ stdcall D3DRMVectorSubtract(ptr ptr ptr)
+@ stdcall Direct3DRMCreate(ptr)
+@ stub DllCanUnloadNow
+@ stub DllGetClassObject

dll/directx/wine/d3drm/d3drm_main.c

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2004 Ivan Leo Puoti
+ * Copyright 2010 Christian Costa
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "d3drm_private.h"
+
+/***********************************************************************
+ *		DllMain  (D3DRM.@)
+ */
+BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, void *reserved)
+{
+    switch(reason)
+    {
+    case DLL_WINE_PREATTACH:
+        return FALSE;  /* prefer native version */
+    case DLL_PROCESS_ATTACH:
+        DisableThreadLibraryCalls( inst );
+        break;
+    }
+    return TRUE;
+}

dll/directx/wine/d3drm/d3drm_private.h

@@ -0,0 +1,63 @@
+/*
+ *      Direct3DRM private interfaces (D3DRM.DLL)
+ *
+ * Copyright 2010 Christian Costa
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef __D3DRM_PRIVATE_INCLUDED__
+#define __D3DRM_PRIVATE_INCLUDED__
+
+#define WIN32_NO_STATUS
+#define _INC_WINDOWS
+#define COM_NO_WINDOWS_H
+
+#define COBJMACROS
+#define NONAMELESSUNION
+
+#include <windef.h>
+#include <winbase.h>
+#include <wingdi.h>
+#include <d3drm.h>
+#include <dxfile.h>
+#include <rmxfguid.h>
+
+#include <wine/debug.h>
+WINE_DEFAULT_DEBUG_CHANNEL(d3drm);
+
+HRESULT Direct3DRMDevice_create(REFIID riid, IUnknown** ppObj) DECLSPEC_HIDDEN;
+HRESULT Direct3DRMFace_create(REFIID riid, IUnknown** ret_iface) DECLSPEC_HIDDEN;
+HRESULT Direct3DRMFrame_create(REFIID riid, IUnknown* parent_frame, IUnknown** ret_iface) DECLSPEC_HIDDEN;
+HRESULT Direct3DRMLight_create(IUnknown** ppObj) DECLSPEC_HIDDEN;
+HRESULT Direct3DRMMesh_create(IDirect3DRMMesh** obj) DECLSPEC_HIDDEN;
+HRESULT Direct3DRMMeshBuilder_create(REFIID riid, IUnknown** ppObj) DECLSPEC_HIDDEN;
+HRESULT Direct3DRMViewport_create(REFIID riid, IUnknown** ppObj) DECLSPEC_HIDDEN;
+HRESULT Direct3DRMMaterial_create(IDirect3DRMMaterial2** ret_iface) DECLSPEC_HIDDEN;
+HRESULT Direct3DRMTexture_create(REFIID riid, IUnknown** ret_iface) DECLSPEC_HIDDEN;
+
+HRESULT load_mesh_data(IDirect3DRMMeshBuilder3 *iface, IDirectXFileData *data,
+                       D3DRMLOADTEXTURECALLBACK load_texture_proc, void *arg) DECLSPEC_HIDDEN;
+
+struct d3drm_file_header
+{
+    WORD major;
+    WORD minor;
+    DWORD flags;
+};
+
+extern char templates[];
+
+#endif /* __D3DRM_PRIVATE_INCLUDED__ */

dll/directx/wine/d3drm/device.c

@@ -0,0 +1,984 @@
+/*
+ * Implementation of IDirect3DRMDevice Interface
+ *
+ * Copyright 2011, 2012 André Hentschel
+ *
+ * This file contains the (internal) driver registration functions,
+ * driver enumeration APIs and DirectDraw creation functions.
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "d3drm_private.h"
+
+#include <d3drmwin.h>
+
+struct d3drm_device
+{
+    IDirect3DRMDevice2 IDirect3DRMDevice2_iface;
+    IDirect3DRMDevice3 IDirect3DRMDevice3_iface;
+    IDirect3DRMWinDevice IDirect3DRMWinDevice_iface;
+    LONG ref;
+    BOOL dither;
+    D3DRMRENDERQUALITY quality;
+    DWORD rendermode;
+    DWORD height;
+    DWORD width;
+};
+
+static inline struct d3drm_device *impl_from_IDirect3DRMDevice2(IDirect3DRMDevice2 *iface)
+{
+    return CONTAINING_RECORD(iface, struct d3drm_device, IDirect3DRMDevice2_iface);
+}
+
+static inline struct d3drm_device *impl_from_IDirect3DRMDevice3(IDirect3DRMDevice3 *iface)
+{
+    return CONTAINING_RECORD(iface, struct d3drm_device, IDirect3DRMDevice3_iface);
+}
+
+static inline struct d3drm_device *impl_from_IDirect3DRMWinDevice(IDirect3DRMWinDevice *iface)
+{
+    return CONTAINING_RECORD(iface, struct d3drm_device, IDirect3DRMWinDevice_iface);
+}
+
+static HRESULT WINAPI d3drm_device2_QueryInterface(IDirect3DRMDevice2 *iface, REFIID riid, void **out)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
+
+    TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
+
+    if (IsEqualGUID(riid, &IID_IDirect3DRMDevice2)
+            || IsEqualGUID(riid, &IID_IDirect3DRMDevice)
+            || IsEqualGUID(riid, &IID_IUnknown))
+    {
+        *out = &device->IDirect3DRMDevice2_iface;
+    }
+    else if (IsEqualGUID(riid, &IID_IDirect3DRMDevice3))
+    {
+        *out = &device->IDirect3DRMDevice3_iface;
+    }
+    else if (IsEqualGUID(riid, &IID_IDirect3DRMWinDevice))
+    {
+        *out = &device->IDirect3DRMWinDevice_iface;
+    }
+    else
+    {
+        *out = NULL;
+        WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
+        return E_NOINTERFACE;
+    }
+
+    IUnknown_AddRef((IUnknown *)*out);
+    return S_OK;
+}
+
+static ULONG WINAPI d3drm_device2_AddRef(IDirect3DRMDevice2 *iface)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
+    ULONG refcount = InterlockedIncrement(&device->ref);
+
+    TRACE("%p increasing refcount to %u.\n", iface, refcount);
+
+    return refcount;
+}
+
+static ULONG WINAPI d3drm_device2_Release(IDirect3DRMDevice2 *iface)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
+    ULONG refcount = InterlockedDecrement(&device->ref);
+
+    TRACE("%p decreasing refcount to %u.\n", iface, refcount);
+
+    if (!refcount)
+        HeapFree(GetProcessHeap(), 0, device);
+
+    return refcount;
+}
+
+static HRESULT WINAPI d3drm_device2_Clone(IDirect3DRMDevice2 *iface,
+        IUnknown *outer, REFIID iid, void **out)
+{
+    FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device2_AddDestroyCallback(IDirect3DRMDevice2 *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device2_DeleteDestroyCallback(IDirect3DRMDevice2 *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device2_SetAppData(IDirect3DRMDevice2 *iface, DWORD data)
+{
+    FIXME("iface %p, data %#x stub!\n", iface, data);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI d3drm_device2_GetAppData(IDirect3DRMDevice2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return 0;
+}
+
+static HRESULT WINAPI d3drm_device2_SetName(IDirect3DRMDevice2 *iface, const char *name)
+{
+    FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device2_GetName(IDirect3DRMDevice2 *iface, DWORD *size, char *name)
+{
+    FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device2_GetClassName(IDirect3DRMDevice2 *iface, DWORD *size, char *name)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
+
+    TRACE("iface %p, size %p, name %p.\n", iface, size, name);
+
+    return IDirect3DRMDevice3_GetClassName(&device->IDirect3DRMDevice3_iface, size, name);
+}
+
+static HRESULT WINAPI d3drm_device2_Init(IDirect3DRMDevice2 *iface, ULONG width, ULONG height)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
+
+    TRACE("iface %p, width %u, height %u.\n", iface, width, height);
+
+    return IDirect3DRMDevice3_Init(&device->IDirect3DRMDevice3_iface, width, height);
+}
+
+static HRESULT WINAPI d3drm_device2_InitFromD3D(IDirect3DRMDevice2 *iface,
+        IDirect3D *d3d, IDirect3DDevice *d3d_device)
+{
+    FIXME("iface %p, d3d %p, d3d_device %p stub!\n", iface, d3d, d3d_device);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device2_InitFromClipper(IDirect3DRMDevice2 *iface,
+        IDirectDrawClipper *clipper, GUID *guid, int width, int height)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
+
+    TRACE("iface %p, clipper %p, guid %s, width %d, height %d.\n",
+            iface, clipper, debugstr_guid(guid), width, height);
+
+    return IDirect3DRMDevice3_InitFromClipper(&device->IDirect3DRMDevice3_iface,
+            clipper, guid, width, height);
+}
+
+static HRESULT WINAPI d3drm_device2_Update(IDirect3DRMDevice2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_device2_AddUpdateCallback(IDirect3DRMDevice2 *iface,
+        D3DRMUPDATECALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device2_DeleteUpdateCallback(IDirect3DRMDevice2 *iface,
+        D3DRMUPDATECALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device2_SetBufferCount(IDirect3DRMDevice2 *iface, DWORD count)
+{
+    FIXME("iface %p, count %u.\n", iface, count);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI d3drm_device2_GetBufferCount(IDirect3DRMDevice2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device2_SetDither(IDirect3DRMDevice2 *iface, BOOL enable)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
+
+    TRACE("iface %p, enabled %#x.\n", iface, enable);
+
+    return IDirect3DRMDevice3_SetDither(&device->IDirect3DRMDevice3_iface, enable);
+}
+
+static HRESULT WINAPI d3drm_device2_SetShades(IDirect3DRMDevice2 *iface, DWORD count)
+{
+    FIXME("iface %p, count %u stub!\n", iface, count);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device2_SetQuality(IDirect3DRMDevice2 *iface, D3DRMRENDERQUALITY quality)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
+
+    TRACE("iface %p, quality %u.\n", iface, quality);
+
+    return IDirect3DRMDevice3_SetQuality(&device->IDirect3DRMDevice3_iface, quality);
+}
+
+static HRESULT WINAPI d3drm_device2_SetTextureQuality(IDirect3DRMDevice2 *iface, D3DRMTEXTUREQUALITY quality)
+{
+    FIXME("iface %p, quality %u stub!\n", iface, quality);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device2_GetViewports(IDirect3DRMDevice2 *iface, IDirect3DRMViewportArray **array)
+{
+    FIXME("iface %p, array %p stub!\n", iface, array);
+
+    return E_NOTIMPL;
+}
+
+static BOOL WINAPI d3drm_device2_GetDither(IDirect3DRMDevice2 *iface)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return IDirect3DRMDevice3_GetDither(&device->IDirect3DRMDevice3_iface);
+}
+
+static DWORD WINAPI d3drm_device2_GetShades(IDirect3DRMDevice2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI d3drm_device2_GetHeight(IDirect3DRMDevice2 *iface)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return IDirect3DRMDevice3_GetHeight(&device->IDirect3DRMDevice3_iface);
+}
+
+static DWORD WINAPI d3drm_device2_GetWidth(IDirect3DRMDevice2 *iface)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return IDirect3DRMDevice3_GetWidth(&device->IDirect3DRMDevice3_iface);
+}
+
+static DWORD WINAPI d3drm_device2_GetTrianglesDrawn(IDirect3DRMDevice2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI d3drm_device2_GetWireframeOptions(IDirect3DRMDevice2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static D3DRMRENDERQUALITY WINAPI d3drm_device2_GetQuality(IDirect3DRMDevice2 *iface)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return IDirect3DRMDevice3_GetQuality(&device->IDirect3DRMDevice3_iface);
+}
+
+static D3DCOLORMODEL WINAPI d3drm_device2_GetColorModel(IDirect3DRMDevice2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static D3DRMTEXTUREQUALITY WINAPI d3drm_device2_GetTextureQuality(IDirect3DRMDevice2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device2_GetDirect3DDevice(IDirect3DRMDevice2 *iface, IDirect3DDevice **d3d_device)
+{
+    FIXME("iface %p, d3d_device %p stub!\n", iface, d3d_device);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device2_InitFromD3D2(IDirect3DRMDevice2 *iface,
+        IDirect3D2 *d3d, IDirect3DDevice2 *d3d_device)
+{
+    FIXME("iface %p, d3d %p, d3d_device %p stub!\n", iface, d3d, d3d_device);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device2_InitFromSurface(IDirect3DRMDevice2 *iface,
+        GUID *guid, IDirectDraw *ddraw, IDirectDrawSurface *backbuffer)
+{
+    FIXME("iface %p, guid %s, ddraw %p, backbuffer %p stub!\n",
+            iface, debugstr_guid(guid), ddraw, backbuffer);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device2_SetRenderMode(IDirect3DRMDevice2 *iface, DWORD flags)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
+
+    TRACE("iface %p, flags %#x.\n", iface, flags);
+
+    return IDirect3DRMDevice3_SetRenderMode(&device->IDirect3DRMDevice3_iface, flags);
+}
+
+static DWORD WINAPI d3drm_device2_GetRenderMode(IDirect3DRMDevice2 *iface)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return IDirect3DRMDevice3_GetRenderMode(&device->IDirect3DRMDevice3_iface);
+}
+
+static HRESULT WINAPI d3drm_device2_GetDirect3DDevice2(IDirect3DRMDevice2 *iface, IDirect3DDevice2 **d3d_device)
+{
+    FIXME("iface %p, d3d_device %p stub!\n", iface, d3d_device);
+
+    return E_NOTIMPL;
+}
+
+static const struct IDirect3DRMDevice2Vtbl d3drm_device2_vtbl =
+{
+    d3drm_device2_QueryInterface,
+    d3drm_device2_AddRef,
+    d3drm_device2_Release,
+    d3drm_device2_Clone,
+    d3drm_device2_AddDestroyCallback,
+    d3drm_device2_DeleteDestroyCallback,
+    d3drm_device2_SetAppData,
+    d3drm_device2_GetAppData,
+    d3drm_device2_SetName,
+    d3drm_device2_GetName,
+    d3drm_device2_GetClassName,
+    d3drm_device2_Init,
+    d3drm_device2_InitFromD3D,
+    d3drm_device2_InitFromClipper,
+    d3drm_device2_Update,
+    d3drm_device2_AddUpdateCallback,
+    d3drm_device2_DeleteUpdateCallback,
+    d3drm_device2_SetBufferCount,
+    d3drm_device2_GetBufferCount,
+    d3drm_device2_SetDither,
+    d3drm_device2_SetShades,
+    d3drm_device2_SetQuality,
+    d3drm_device2_SetTextureQuality,
+    d3drm_device2_GetViewports,
+    d3drm_device2_GetDither,
+    d3drm_device2_GetShades,
+    d3drm_device2_GetHeight,
+    d3drm_device2_GetWidth,
+    d3drm_device2_GetTrianglesDrawn,
+    d3drm_device2_GetWireframeOptions,
+    d3drm_device2_GetQuality,
+    d3drm_device2_GetColorModel,
+    d3drm_device2_GetTextureQuality,
+    d3drm_device2_GetDirect3DDevice,
+    d3drm_device2_InitFromD3D2,
+    d3drm_device2_InitFromSurface,
+    d3drm_device2_SetRenderMode,
+    d3drm_device2_GetRenderMode,
+    d3drm_device2_GetDirect3DDevice2,
+};
+
+static HRESULT WINAPI d3drm_device3_QueryInterface(IDirect3DRMDevice3 *iface, REFIID riid, void **out)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
+
+    return d3drm_device2_QueryInterface(&device->IDirect3DRMDevice2_iface, riid, out);
+}
+
+static ULONG WINAPI d3drm_device3_AddRef(IDirect3DRMDevice3 *iface)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
+
+    return d3drm_device2_AddRef(&device->IDirect3DRMDevice2_iface);
+}
+
+static ULONG WINAPI d3drm_device3_Release(IDirect3DRMDevice3 *iface)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
+
+    return d3drm_device2_Release(&device->IDirect3DRMDevice2_iface);
+}
+
+static HRESULT WINAPI d3drm_device3_Clone(IDirect3DRMDevice3 *iface,
+        IUnknown *outer, REFIID iid, void **out)
+{
+    FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device3_AddDestroyCallback(IDirect3DRMDevice3 *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device3_DeleteDestroyCallback(IDirect3DRMDevice3 *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device3_SetAppData(IDirect3DRMDevice3 *iface, DWORD data)
+{
+    FIXME("iface %p, data %#x stub!\n", iface, data);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI d3drm_device3_GetAppData(IDirect3DRMDevice3 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return 0;
+}
+
+static HRESULT WINAPI d3drm_device3_SetName(IDirect3DRMDevice3 *iface, const char *name)
+{
+    FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device3_GetName(IDirect3DRMDevice3 *iface, DWORD *size, char *name)
+{
+    FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device3_GetClassName(IDirect3DRMDevice3 *iface, DWORD *size, char *name)
+{
+    TRACE("iface %p, size %p, name %p.\n", iface, size, name);
+
+    if (!size || *size < strlen("Device") || !name)
+        return E_INVALIDARG;
+
+    strcpy(name, "Device");
+    *size = sizeof("Device");
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_device3_Init(IDirect3DRMDevice3 *iface, ULONG width, ULONG height)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
+
+    FIXME("iface %p, width %u, height %u stub!\n", iface, width, height);
+
+    device->height = height;
+    device->width = width;
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_device3_InitFromD3D(IDirect3DRMDevice3 *iface,
+        IDirect3D *d3d, IDirect3DDevice *d3d_device)
+{
+    FIXME("iface %p, d3d %p, d3d_device %p stub!\n", iface, d3d, d3d_device);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device3_InitFromClipper(IDirect3DRMDevice3 *iface,
+        IDirectDrawClipper *clipper, GUID *guid, int width, int height)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
+
+    FIXME("iface %p, clipper %p, guid %s, width %d, height %d stub!\n",
+            iface, clipper, debugstr_guid(guid), width, height);
+
+    device->height = height;
+    device->width = width;
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_device3_Update(IDirect3DRMDevice3 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_device3_AddUpdateCallback(IDirect3DRMDevice3 *iface,
+        D3DRMUPDATECALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device3_DeleteUpdateCallback(IDirect3DRMDevice3 *iface,
+        D3DRMUPDATECALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device3_SetBufferCount(IDirect3DRMDevice3 *iface, DWORD count)
+{
+    FIXME("iface %p, count %u stub!\n", iface, count);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI d3drm_device3_GetBufferCount(IDirect3DRMDevice3 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device3_SetDither(IDirect3DRMDevice3 *iface, BOOL enable)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
+
+    TRACE("iface %p, enable %#x.\n", iface, enable);
+
+    device->dither = enable;
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_device3_SetShades(IDirect3DRMDevice3 *iface, DWORD count)
+{
+    FIXME("iface %p, count %u stub!\n", iface, count);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device3_SetQuality(IDirect3DRMDevice3 *iface, D3DRMRENDERQUALITY quality)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
+
+    TRACE("iface %p, quality %u.\n", iface, quality);
+
+    device->quality = quality;
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_device3_SetTextureQuality(IDirect3DRMDevice3 *iface, D3DRMTEXTUREQUALITY quality)
+{
+    FIXME("iface %p, quality %u stub!\n", iface, quality);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device3_GetViewports(IDirect3DRMDevice3 *iface, IDirect3DRMViewportArray **array)
+{
+    FIXME("iface %p, array %p stub!\n", iface, array);
+
+    return E_NOTIMPL;
+}
+
+static BOOL WINAPI d3drm_device3_GetDither(IDirect3DRMDevice3 *iface)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return device->dither;
+}
+
+static DWORD WINAPI d3drm_device3_GetShades(IDirect3DRMDevice3 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI d3drm_device3_GetHeight(IDirect3DRMDevice3 *iface)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return device->height;
+}
+
+static DWORD WINAPI d3drm_device3_GetWidth(IDirect3DRMDevice3 *iface)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return device->width;
+}
+
+static DWORD WINAPI d3drm_device3_GetTrianglesDrawn(IDirect3DRMDevice3 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI d3drm_device3_GetWireframeOptions(IDirect3DRMDevice3 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static D3DRMRENDERQUALITY WINAPI d3drm_device3_GetQuality(IDirect3DRMDevice3 *iface)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return device->quality;
+}
+
+static D3DCOLORMODEL WINAPI d3drm_device3_GetColorModel(IDirect3DRMDevice3 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static D3DRMTEXTUREQUALITY WINAPI d3drm_device3_GetTextureQuality(IDirect3DRMDevice3 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device3_GetDirect3DDevice(IDirect3DRMDevice3 *iface, IDirect3DDevice **d3d_device)
+{
+    FIXME("iface %p, d3d_device %p stub!\n", iface, d3d_device);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device3_InitFromD3D2(IDirect3DRMDevice3 *iface,
+        IDirect3D2 *d3d, IDirect3DDevice2 *d3d_device)
+{
+    FIXME("iface %p, d3d %p, d3d_device %p stub!\n", iface, d3d, d3d_device);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device3_InitFromSurface(IDirect3DRMDevice3 *iface,
+        GUID *guid, IDirectDraw *ddraw, IDirectDrawSurface *backbuffer)
+{
+    FIXME("iface %p, guid %s, ddraw %p, backbuffer %p stub!\n",
+            iface, debugstr_guid(guid), ddraw, backbuffer);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device3_SetRenderMode(IDirect3DRMDevice3 *iface, DWORD flags)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
+
+    TRACE("iface %p, flags %#x.\n", iface, flags);
+
+    device->rendermode = flags;
+
+    return D3DRM_OK;
+}
+
+static DWORD WINAPI d3drm_device3_GetRenderMode(IDirect3DRMDevice3 *iface)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return device->rendermode;
+}
+
+static HRESULT WINAPI d3drm_device3_GetDirect3DDevice2(IDirect3DRMDevice3 *iface, IDirect3DDevice2 **d3d_device)
+{
+    FIXME("iface %p, d3d_device %p stub!\n", iface, d3d_device);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device3_FindPreferredTextureFormat(IDirect3DRMDevice3 *iface,
+        DWORD bitdepths, DWORD flags, DDPIXELFORMAT *pf)
+{
+    FIXME("iface %p, bitdepths %u, flags %#x, pf %p stub!\n", iface, bitdepths, flags, pf);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device3_RenderStateChange(IDirect3DRMDevice3 *iface,
+        D3DRENDERSTATETYPE state, DWORD value, DWORD flags)
+{
+    FIXME("iface %p, state %#x, value %#x, flags %#x stub!\n", iface, state, value, flags);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device3_LightStateChange(IDirect3DRMDevice3 *iface,
+        D3DLIGHTSTATETYPE state, DWORD value, DWORD flags)
+{
+    FIXME("iface %p, state %#x, value %#x, flags %#x stub!\n", iface, state, value, flags);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device3_GetStateChangeOptions(IDirect3DRMDevice3 *iface,
+        DWORD state_class, DWORD state_idx, DWORD *flags)
+{
+    FIXME("iface %p, state_class %#x, state_idx %#x, flags %p stub!\n",
+            iface, state_class, state_idx, flags);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device3_SetStateChangeOptions(IDirect3DRMDevice3 *iface,
+        DWORD state_class, DWORD state_idx, DWORD flags)
+{
+    FIXME("iface %p, state_class %#x, state_idx %#x, flags %#x stub!\n",
+            iface, state_class, state_idx, flags);
+
+    return E_NOTIMPL;
+}
+
+static const struct IDirect3DRMDevice3Vtbl d3drm_device3_vtbl =
+{
+    d3drm_device3_QueryInterface,
+    d3drm_device3_AddRef,
+    d3drm_device3_Release,
+    d3drm_device3_Clone,
+    d3drm_device3_AddDestroyCallback,
+    d3drm_device3_DeleteDestroyCallback,
+    d3drm_device3_SetAppData,
+    d3drm_device3_GetAppData,
+    d3drm_device3_SetName,
+    d3drm_device3_GetName,
+    d3drm_device3_GetClassName,
+    d3drm_device3_Init,
+    d3drm_device3_InitFromD3D,
+    d3drm_device3_InitFromClipper,
+    d3drm_device3_Update,
+    d3drm_device3_AddUpdateCallback,
+    d3drm_device3_DeleteUpdateCallback,
+    d3drm_device3_SetBufferCount,
+    d3drm_device3_GetBufferCount,
+    d3drm_device3_SetDither,
+    d3drm_device3_SetShades,
+    d3drm_device3_SetQuality,
+    d3drm_device3_SetTextureQuality,
+    d3drm_device3_GetViewports,
+    d3drm_device3_GetDither,
+    d3drm_device3_GetShades,
+    d3drm_device3_GetHeight,
+    d3drm_device3_GetWidth,
+    d3drm_device3_GetTrianglesDrawn,
+    d3drm_device3_GetWireframeOptions,
+    d3drm_device3_GetQuality,
+    d3drm_device3_GetColorModel,
+    d3drm_device3_GetTextureQuality,
+    d3drm_device3_GetDirect3DDevice,
+    d3drm_device3_InitFromD3D2,
+    d3drm_device3_InitFromSurface,
+    d3drm_device3_SetRenderMode,
+    d3drm_device3_GetRenderMode,
+    d3drm_device3_GetDirect3DDevice2,
+    d3drm_device3_FindPreferredTextureFormat,
+    d3drm_device3_RenderStateChange,
+    d3drm_device3_LightStateChange,
+    d3drm_device3_GetStateChangeOptions,
+    d3drm_device3_SetStateChangeOptions,
+};
+
+static HRESULT WINAPI d3drm_device_win_QueryInterface(IDirect3DRMWinDevice *iface, REFIID riid, void **out)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMWinDevice(iface);
+
+    return d3drm_device2_QueryInterface(&device->IDirect3DRMDevice2_iface, riid, out);
+}
+
+static ULONG WINAPI d3drm_device_win_AddRef(IDirect3DRMWinDevice *iface)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMWinDevice(iface);
+
+    return d3drm_device2_AddRef(&device->IDirect3DRMDevice2_iface);
+}
+
+static ULONG WINAPI d3drm_device_win_Release(IDirect3DRMWinDevice *iface)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMWinDevice(iface);
+
+    return d3drm_device2_Release(&device->IDirect3DRMDevice2_iface);
+}
+
+static HRESULT WINAPI d3drm_device_win_Clone(IDirect3DRMWinDevice *iface,
+        IUnknown *outer, REFIID iid, void **out)
+{
+    FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device_win_AddDestroyCallback(IDirect3DRMWinDevice *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device_win_DeleteDestroyCallback(IDirect3DRMWinDevice *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device_win_SetAppData(IDirect3DRMWinDevice *iface, DWORD data)
+{
+    FIXME("iface %p, data %#x stub!\n", iface, data);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI d3drm_device_win_GetAppData(IDirect3DRMWinDevice *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return 0;
+}
+
+static HRESULT WINAPI d3drm_device_win_SetName(IDirect3DRMWinDevice *iface, const char *name)
+{
+    FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device_win_GetName(IDirect3DRMWinDevice *iface, DWORD *size, char *name)
+{
+    FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_device_win_GetClassName(IDirect3DRMWinDevice *iface, DWORD *size, char *name)
+{
+    struct d3drm_device *device = impl_from_IDirect3DRMWinDevice(iface);
+
+    TRACE("iface %p, size %p, name %p.\n", iface, size, name);
+
+    return IDirect3DRMDevice3_GetClassName(&device->IDirect3DRMDevice3_iface, size, name);
+}
+
+static HRESULT WINAPI d3drm_device_win_HandlePaint(IDirect3DRMWinDevice *iface, HDC dc)
+{
+    FIXME("iface %p, dc %p stub!\n", iface, dc);
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_device_win_HandleActivate(IDirect3DRMWinDevice *iface, WORD wparam)
+{
+    FIXME("iface %p, wparam %#x stub!\n", iface, wparam);
+
+    return D3DRM_OK;
+}
+
+static const struct IDirect3DRMWinDeviceVtbl d3drm_device_win_vtbl =
+{
+    d3drm_device_win_QueryInterface,
+    d3drm_device_win_AddRef,
+    d3drm_device_win_Release,
+    d3drm_device_win_Clone,
+    d3drm_device_win_AddDestroyCallback,
+    d3drm_device_win_DeleteDestroyCallback,
+    d3drm_device_win_SetAppData,
+    d3drm_device_win_GetAppData,
+    d3drm_device_win_SetName,
+    d3drm_device_win_GetName,
+    d3drm_device_win_GetClassName,
+    d3drm_device_win_HandlePaint,
+    d3drm_device_win_HandleActivate,
+};
+
+HRESULT Direct3DRMDevice_create(REFIID riid, IUnknown **out)
+{
+    struct d3drm_device *object;
+
+    TRACE("riid %s, out %p.\n", debugstr_guid(riid), out);
+
+    if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+        return E_OUTOFMEMORY;
+
+    object->IDirect3DRMDevice2_iface.lpVtbl = &d3drm_device2_vtbl;
+    object->IDirect3DRMDevice3_iface.lpVtbl = &d3drm_device3_vtbl;
+    object->IDirect3DRMWinDevice_iface.lpVtbl = &d3drm_device_win_vtbl;
+    object->ref = 1;
+
+    if (IsEqualGUID(riid, &IID_IDirect3DRMDevice3))
+        *out = (IUnknown*)&object->IDirect3DRMDevice3_iface;
+    else
+        *out = (IUnknown*)&object->IDirect3DRMDevice2_iface;
+
+    return S_OK;
+}

dll/directx/wine/d3drm/face.c

@@ -0,0 +1,606 @@
+/*
+ * Implementation of IDirect3DRMFace Interface
+ *
+ * Copyright 2013 André Hentschel
+ *
+ * This file contains the (internal) driver registration functions,
+ * driver enumeration APIs and DirectDraw creation functions.
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "d3drm_private.h"
+
+struct d3drm_face
+{
+    IDirect3DRMFace IDirect3DRMFace_iface;
+    IDirect3DRMFace2 IDirect3DRMFace2_iface;
+    LONG ref;
+};
+
+static inline struct d3drm_face *impl_from_IDirect3DRMFace(IDirect3DRMFace *iface)
+{
+    return CONTAINING_RECORD(iface, struct d3drm_face, IDirect3DRMFace_iface);
+}
+
+static inline struct d3drm_face *impl_from_IDirect3DRMFace2(IDirect3DRMFace2 *iface)
+{
+    return CONTAINING_RECORD(iface, struct d3drm_face, IDirect3DRMFace2_iface);
+}
+
+static HRESULT WINAPI d3drm_face1_QueryInterface(IDirect3DRMFace *iface, REFIID riid, void **out)
+{
+    struct d3drm_face *face = impl_from_IDirect3DRMFace(iface);
+
+    TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
+
+
+    if (IsEqualGUID(riid, &IID_IDirect3DRMFace)
+            || IsEqualGUID(riid, &IID_IUnknown))
+    {
+        *out = &face->IDirect3DRMFace_iface;
+    }
+    else if(IsEqualGUID(riid, &IID_IDirect3DRMFace2))
+    {
+        *out = &face->IDirect3DRMFace2_iface;
+    }
+    else
+    {
+        *out = NULL;
+        WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
+        return E_NOINTERFACE;
+    }
+
+    IUnknown_AddRef((IUnknown *)*out);
+    return S_OK;
+}
+
+static ULONG WINAPI d3drm_face1_AddRef(IDirect3DRMFace *iface)
+{
+    struct d3drm_face *face = impl_from_IDirect3DRMFace(iface);
+    ULONG refcount = InterlockedIncrement(&face->ref);
+
+    TRACE("%p increasing refcount to %u.\n", iface, refcount);
+
+    return refcount;
+}
+
+static ULONG WINAPI d3drm_face1_Release(IDirect3DRMFace *iface)
+{
+    struct d3drm_face *face = impl_from_IDirect3DRMFace(iface);
+    ULONG refcount = InterlockedDecrement(&face->ref);
+
+    TRACE("%p decreasing refcount to %u.\n", iface, refcount);
+
+    if (!refcount)
+        HeapFree(GetProcessHeap(), 0, face);
+
+    return refcount;
+}
+
+static HRESULT WINAPI d3drm_face1_Clone(IDirect3DRMFace *iface,
+        IUnknown *outer, REFIID iid, void **out)
+{
+    FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face1_AddDestroyCallback(IDirect3DRMFace *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face1_DeleteDestroyCallback(IDirect3DRMFace *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face1_SetAppData(IDirect3DRMFace *iface, DWORD data)
+{
+    FIXME("iface %p, data %#x stub!\n", iface, data);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI d3drm_face1_GetAppData(IDirect3DRMFace *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return 0;
+}
+
+static HRESULT WINAPI d3drm_face1_SetName(IDirect3DRMFace *iface, const char *name)
+{
+    FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face1_GetName(IDirect3DRMFace *iface, DWORD *size, char *name)
+{
+    FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face1_GetClassName(IDirect3DRMFace *iface, DWORD *size, char *name)
+{
+    struct d3drm_face *face = impl_from_IDirect3DRMFace(iface);
+
+    TRACE("iface %p, size %p, name %p.\n", iface, size, name);
+
+    return IDirect3DRMFace2_GetClassName(&face->IDirect3DRMFace2_iface, size, name);
+}
+
+static HRESULT WINAPI d3drm_face1_AddVertex(IDirect3DRMFace *iface, D3DVALUE x, D3DVALUE y, D3DVALUE z)
+{
+    FIXME("iface %p, x %.8e, y %.8e, z %.8e stub!\n", iface, x, y, z);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face1_AddVertexAndNormalIndexed(IDirect3DRMFace *iface,
+        DWORD vertex, DWORD normal)
+{
+    FIXME("iface %p, vertex %u, normal %u stub!\n", iface, vertex, normal);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face1_SetColorRGB(IDirect3DRMFace *iface,
+        D3DVALUE r, D3DVALUE g, D3DVALUE b)
+{
+    FIXME("iface %p, r %.8e, g %.8e, b %.8e stub!\n", iface, r, g, b);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face1_SetColor(IDirect3DRMFace *iface, D3DCOLOR color)
+{
+    FIXME("iface %p, color 0x%08x stub!\n", iface, color);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face1_SetTexture(IDirect3DRMFace *iface, IDirect3DRMTexture *texture)
+{
+    FIXME("iface %p, texture %p stub!\n", iface, texture);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face1_SetTextureCoordinates(IDirect3DRMFace *iface,
+        DWORD vertex, D3DVALUE u, D3DVALUE v)
+{
+    FIXME("iface %p, vertex %u, u %.8e, v %.8e stub!\n", iface, vertex, u, v);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face1_SetMaterial(IDirect3DRMFace *iface, IDirect3DRMMaterial *material)
+{
+    FIXME("iface %p, material %p stub!\n", iface, material);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face1_SetTextureTopology(IDirect3DRMFace *iface, BOOL wrap_u, BOOL wrap_v)
+{
+    FIXME("iface %p, wrap_u %#x, wrap_v %#x stub!\n", iface, wrap_u, wrap_v);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face1_GetVertex(IDirect3DRMFace *iface,
+        DWORD index, D3DVECTOR *vertex, D3DVECTOR *normal)
+{
+    FIXME("iface %p, index %u, vertex %p, normal %p stub!\n", iface, index, vertex, normal);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face1_GetVertices(IDirect3DRMFace *iface,
+        DWORD *vertex_count, D3DVECTOR *coords, D3DVECTOR *normals)
+{
+    FIXME("iface %p, vertex_count %p, coords %p, normals %p stub!\n",
+            iface, vertex_count, coords, normals);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face1_GetTextureCoordinates(IDirect3DRMFace *iface,
+        DWORD vertex, D3DVALUE *u, D3DVALUE *v)
+{
+    FIXME("iface %p, vertex %u, u %p, v %p stub!\n", iface, vertex, u, v);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face1_GetTextureTopology(IDirect3DRMFace *iface, BOOL *wrap_u, BOOL *wrap_v)
+{
+    FIXME("iface %p, wrap_u %p, wrap_v %p stub!\n", iface, wrap_u, wrap_v);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face1_GetNormal(IDirect3DRMFace *iface, D3DVECTOR *normal)
+{
+    FIXME("iface %p, normal %p stub!\n", iface, normal);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face1_GetTexture(IDirect3DRMFace *iface, IDirect3DRMTexture **texture)
+{
+    FIXME("iface %p, texture %p stub!\n", iface, texture);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face1_GetMaterial(IDirect3DRMFace *iface, IDirect3DRMMaterial **material)
+{
+    FIXME("iface %p, material %p stub!\n", iface, material);
+
+    return E_NOTIMPL;
+}
+
+static int WINAPI d3drm_face1_GetVertexCount(IDirect3DRMFace *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return 0;
+}
+
+static int WINAPI d3drm_face1_GetVertexIndex(IDirect3DRMFace *iface, DWORD which)
+{
+    FIXME("iface %p, which %u stub!\n", iface, which);
+
+    return 0;
+}
+
+static int WINAPI d3drm_face1_GetTextureCoordinateIndex(IDirect3DRMFace *iface, DWORD which)
+{
+    FIXME("iface %p, which %u stub!\n", iface, which);
+
+    return 0;
+}
+
+static D3DCOLOR WINAPI d3drm_face1_GetColor(IDirect3DRMFace *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return 0;
+}
+
+static const struct IDirect3DRMFaceVtbl d3drm_face1_vtbl =
+{
+    d3drm_face1_QueryInterface,
+    d3drm_face1_AddRef,
+    d3drm_face1_Release,
+    d3drm_face1_Clone,
+    d3drm_face1_AddDestroyCallback,
+    d3drm_face1_DeleteDestroyCallback,
+    d3drm_face1_SetAppData,
+    d3drm_face1_GetAppData,
+    d3drm_face1_SetName,
+    d3drm_face1_GetName,
+    d3drm_face1_GetClassName,
+    d3drm_face1_AddVertex,
+    d3drm_face1_AddVertexAndNormalIndexed,
+    d3drm_face1_SetColorRGB,
+    d3drm_face1_SetColor,
+    d3drm_face1_SetTexture,
+    d3drm_face1_SetTextureCoordinates,
+    d3drm_face1_SetMaterial,
+    d3drm_face1_SetTextureTopology,
+    d3drm_face1_GetVertex,
+    d3drm_face1_GetVertices,
+    d3drm_face1_GetTextureCoordinates,
+    d3drm_face1_GetTextureTopology,
+    d3drm_face1_GetNormal,
+    d3drm_face1_GetTexture,
+    d3drm_face1_GetMaterial,
+    d3drm_face1_GetVertexCount,
+    d3drm_face1_GetVertexIndex,
+    d3drm_face1_GetTextureCoordinateIndex,
+    d3drm_face1_GetColor,
+};
+
+static HRESULT WINAPI d3drm_face2_QueryInterface(IDirect3DRMFace2 *iface, REFIID riid, void **out)
+{
+    struct d3drm_face *face = impl_from_IDirect3DRMFace2(iface);
+
+    return d3drm_face1_QueryInterface(&face->IDirect3DRMFace_iface, riid, out);
+}
+
+static ULONG WINAPI d3drm_face2_AddRef(IDirect3DRMFace2 *iface)
+{
+    struct d3drm_face *face = impl_from_IDirect3DRMFace2(iface);
+
+    return d3drm_face1_AddRef(&face->IDirect3DRMFace_iface);
+}
+
+static ULONG WINAPI d3drm_face2_Release(IDirect3DRMFace2 *iface)
+{
+    struct d3drm_face *face = impl_from_IDirect3DRMFace2(iface);
+
+    return d3drm_face1_Release(&face->IDirect3DRMFace_iface);
+}
+
+static HRESULT WINAPI d3drm_face2_Clone(IDirect3DRMFace2 *iface,
+        IUnknown *outer, REFIID iid, void **out)
+{
+    FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face2_AddDestroyCallback(IDirect3DRMFace2 *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face2_DeleteDestroyCallback(IDirect3DRMFace2 *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face2_SetAppData(IDirect3DRMFace2 *iface, DWORD data)
+{
+    FIXME("iface %p, data %#x stub!\n", iface, data);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI d3drm_face2_GetAppData(IDirect3DRMFace2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return 0;
+}
+
+static HRESULT WINAPI d3drm_face2_SetName(IDirect3DRMFace2 *iface, const char *name)
+{
+    FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face2_GetName(IDirect3DRMFace2 *iface, DWORD *size, char *name)
+{
+    FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face2_GetClassName(IDirect3DRMFace2 *iface, DWORD *size, char *name)
+{
+    TRACE("iface %p, size %p, name %p.\n", iface, size, name);
+
+    if (!size || *size < strlen("Face") || !name)
+        return E_INVALIDARG;
+
+    strcpy(name, "Face");
+    *size = sizeof("Face");
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_face2_AddVertex(IDirect3DRMFace2 *iface, D3DVALUE x, D3DVALUE y, D3DVALUE z)
+{
+    FIXME("iface %p, x %.8e, y %.8e, z %.8e stub!\n", iface, x, y, z);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face2_AddVertexAndNormalIndexed(IDirect3DRMFace2 *iface,
+        DWORD vertex, DWORD normal)
+{
+    FIXME("iface %p, vertex %u, normal %u stub!\n", iface, vertex, normal);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face2_SetColorRGB(IDirect3DRMFace2 *iface, D3DVALUE r, D3DVALUE g, D3DVALUE b)
+{
+    FIXME("iface %p, r %.8e, g %.8e, b %.8e stub!\n", iface, r, g, b);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face2_SetColor(IDirect3DRMFace2 *iface, D3DCOLOR color)
+{
+    FIXME("iface %p, color 0x%08x stub!\n", iface, color);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face2_SetTexture(IDirect3DRMFace2 *iface, IDirect3DRMTexture3 *texture)
+{
+    FIXME("iface %p, texture %p stub!\n", iface, texture);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face2_SetTextureCoordinates(IDirect3DRMFace2 *iface,
+        DWORD vertex, D3DVALUE u, D3DVALUE v)
+{
+    FIXME("iface %p, vertex %u, u %.8e, v %.8e stub!\n", iface, vertex, u, v);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face2_SetMaterial(IDirect3DRMFace2 *iface, IDirect3DRMMaterial2 *material)
+{
+    FIXME("iface %p, material %p stub!\n", iface, material);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face2_SetTextureTopology(IDirect3DRMFace2 *iface, BOOL wrap_u, BOOL wrap_v)
+{
+    FIXME("iface %p, wrap_u %#x, wrap_v %#x stub!\n", iface, wrap_u, wrap_v);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face2_GetVertex(IDirect3DRMFace2 *iface,
+        DWORD index, D3DVECTOR *vertex, D3DVECTOR *normal)
+{
+    FIXME("iface %p, index %u, vertex %p, normal %p stub!\n", iface, index, vertex, normal);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face2_GetVertices(IDirect3DRMFace2 *iface,
+        DWORD *vertex_count, D3DVECTOR *coords, D3DVECTOR *normals)
+{
+    FIXME("iface %p, vertex_count %p, coords %p, normals %p stub!\n",
+            iface, vertex_count, coords, normals);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face2_GetTextureCoordinates(IDirect3DRMFace2 *iface,
+        DWORD vertex, D3DVALUE *u, D3DVALUE *v)
+{
+    FIXME("iface %p, vertex %u, u %p, v %p stub!\n", iface, vertex, u, v);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face2_GetTextureTopology(IDirect3DRMFace2 *iface, BOOL *wrap_u, BOOL *wrap_v)
+{
+    FIXME("iface %p, wrap_u %p, wrap_v %p stub!\n", iface, wrap_u, wrap_v);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face2_GetNormal(IDirect3DRMFace2 *iface, D3DVECTOR *normal)
+{
+    FIXME("iface %p, normal %p stub!\n", iface, normal);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face2_GetTexture(IDirect3DRMFace2 *iface, IDirect3DRMTexture3 **texture)
+{
+    FIXME("iface %p, texture %p stub!\n", iface, texture);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_face2_GetMaterial(IDirect3DRMFace2 *iface, IDirect3DRMMaterial2 **material)
+{
+    FIXME("iface %p, material %p stub!\n", iface, material);
+
+    return E_NOTIMPL;
+}
+
+static int WINAPI d3drm_face2_GetVertexCount(IDirect3DRMFace2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return 0;
+}
+
+static int WINAPI d3drm_face2_GetVertexIndex(IDirect3DRMFace2 *iface, DWORD which)
+{
+    FIXME("iface %p, which %u stub!\n", iface, which);
+
+    return 0;
+}
+
+static int WINAPI d3drm_face2_GetTextureCoordinateIndex(IDirect3DRMFace2 *iface, DWORD which)
+{
+    FIXME("iface %p, which %u stub!\n", iface, which);
+
+    return 0;
+}
+
+static D3DCOLOR WINAPI d3drm_face2_GetColor(IDirect3DRMFace2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return 0;
+}
+
+static const struct IDirect3DRMFace2Vtbl d3drm_face2_vtbl =
+{
+    d3drm_face2_QueryInterface,
+    d3drm_face2_AddRef,
+    d3drm_face2_Release,
+    d3drm_face2_Clone,
+    d3drm_face2_AddDestroyCallback,
+    d3drm_face2_DeleteDestroyCallback,
+    d3drm_face2_SetAppData,
+    d3drm_face2_GetAppData,
+    d3drm_face2_SetName,
+    d3drm_face2_GetName,
+    d3drm_face2_GetClassName,
+    d3drm_face2_AddVertex,
+    d3drm_face2_AddVertexAndNormalIndexed,
+    d3drm_face2_SetColorRGB,
+    d3drm_face2_SetColor,
+    d3drm_face2_SetTexture,
+    d3drm_face2_SetTextureCoordinates,
+    d3drm_face2_SetMaterial,
+    d3drm_face2_SetTextureTopology,
+    d3drm_face2_GetVertex,
+    d3drm_face2_GetVertices,
+    d3drm_face2_GetTextureCoordinates,
+    d3drm_face2_GetTextureTopology,
+    d3drm_face2_GetNormal,
+    d3drm_face2_GetTexture,
+    d3drm_face2_GetMaterial,
+    d3drm_face2_GetVertexCount,
+    d3drm_face2_GetVertexIndex,
+    d3drm_face2_GetTextureCoordinateIndex,
+    d3drm_face2_GetColor,
+};
+
+HRESULT Direct3DRMFace_create(REFIID riid, IUnknown **out)
+{
+    struct d3drm_face *object;
+
+    TRACE("riid %s, out %p.\n", debugstr_guid(riid), out);
+
+    if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+        return E_OUTOFMEMORY;
+
+    object->IDirect3DRMFace_iface.lpVtbl = &d3drm_face1_vtbl;
+    object->IDirect3DRMFace2_iface.lpVtbl = &d3drm_face2_vtbl;
+    object->ref = 1;
+
+    if (IsEqualGUID(riid, &IID_IDirect3DRMFace2))
+        *out = (IUnknown*)&object->IDirect3DRMFace2_iface;
+    else
+        *out = (IUnknown*)&object->IDirect3DRMFace_iface;
+
+    return S_OK;
+}

dll/directx/wine/d3drm/light.c

@@ -0,0 +1,383 @@
+/*
+ * Implementation of IDirect3DRMLight Interface
+ *
+ * Copyright 2012 André Hentschel
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "d3drm_private.h"
+
+struct d3drm_light
+{
+    IDirect3DRMLight IDirect3DRMLight_iface;
+    LONG ref;
+    D3DRMLIGHTTYPE type;
+    D3DCOLOR color;
+    D3DVALUE range;
+    D3DVALUE cattenuation;
+    D3DVALUE lattenuation;
+    D3DVALUE qattenuation;
+    D3DVALUE umbra;
+    D3DVALUE penumbra;
+};
+
+static inline struct d3drm_light *impl_from_IDirect3DRMLight(IDirect3DRMLight *iface)
+{
+    return CONTAINING_RECORD(iface, struct d3drm_light, IDirect3DRMLight_iface);
+}
+
+static HRESULT WINAPI d3drm_light_QueryInterface(IDirect3DRMLight *iface, REFIID riid, void **out)
+{
+    TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
+
+    if (IsEqualGUID(riid, &IID_IDirect3DRMLight)
+            || IsEqualGUID(riid, &IID_IUnknown))
+    {
+        IDirect3DRMLight_AddRef(iface);
+        *out = iface;
+        return S_OK;
+    }
+
+    WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
+
+    *out = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI d3drm_light_AddRef(IDirect3DRMLight *iface)
+{
+    struct d3drm_light *light = impl_from_IDirect3DRMLight(iface);
+    ULONG refcount = InterlockedIncrement(&light->ref);
+
+    TRACE("%p increasing refcount to %u.\n", iface, refcount);
+
+    return refcount;
+}
+
+static ULONG WINAPI d3drm_light_Release(IDirect3DRMLight *iface)
+{
+    struct d3drm_light *light = impl_from_IDirect3DRMLight(iface);
+    ULONG refcount = InterlockedDecrement(&light->ref);
+
+    TRACE("%p decreasing refcount to %u.\n", iface, refcount);
+
+    if (!refcount)
+        HeapFree(GetProcessHeap(), 0, light);
+
+    return refcount;
+}
+
+static HRESULT WINAPI d3drm_light_Clone(IDirect3DRMLight *iface,
+        IUnknown *outer, REFIID iid, void **out)
+{
+    FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_light_AddDestroyCallback(IDirect3DRMLight *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_light_DeleteDestroyCallback(IDirect3DRMLight *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_light_SetAppData(IDirect3DRMLight *iface, DWORD data)
+{
+    FIXME("iface %p, data %#x stub!\n", iface, data);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI d3drm_light_GetAppData(IDirect3DRMLight *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return 0;
+}
+
+static HRESULT WINAPI d3drm_light_SetName(IDirect3DRMLight *iface, const char *name)
+{
+    FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_light_GetName(IDirect3DRMLight *iface, DWORD *size, char *name)
+{
+    FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_light_GetClassName(IDirect3DRMLight *iface, DWORD *size, char *name)
+{
+    TRACE("iface %p, size %p, name %p.\n", iface, size, name);
+
+    if (!size || *size < strlen("Light") || !name)
+        return E_INVALIDARG;
+
+    strcpy(name, "Light");
+    *size = sizeof("Light");
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_light_SetType(IDirect3DRMLight *iface, D3DRMLIGHTTYPE type)
+{
+    struct d3drm_light *light = impl_from_IDirect3DRMLight(iface);
+
+    TRACE("iface %p, type %#x.\n", iface, type);
+
+    light->type = type;
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_light_SetColor(IDirect3DRMLight *iface, D3DCOLOR color)
+{
+    struct d3drm_light *light = impl_from_IDirect3DRMLight(iface);
+
+    TRACE("iface %p, color 0x%08x.\n", iface, color);
+
+    light->color = color;
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_light_SetColorRGB(IDirect3DRMLight *iface,
+        D3DVALUE red, D3DVALUE green, D3DVALUE blue)
+{
+    struct d3drm_light *light = impl_from_IDirect3DRMLight(iface);
+
+    TRACE("iface %p, red %.8e, green %.8e, blue %.8e.\n", iface, red, green, blue);
+
+    light->color = RGBA_MAKE((BYTE)(red * 255.0f), (BYTE)(green * 255.0f), (BYTE)(blue * 255.0f), 0xff);
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_light_SetRange(IDirect3DRMLight *iface, D3DVALUE range)
+{
+    struct d3drm_light *light = impl_from_IDirect3DRMLight(iface);
+
+    TRACE("iface %p, range %.8e.\n", iface, range);
+
+    light->range = range;
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_light_SetUmbra(IDirect3DRMLight *iface, D3DVALUE umbra)
+{
+    struct d3drm_light *light = impl_from_IDirect3DRMLight(iface);
+
+    TRACE("iface %p, umbra %.8e.\n", iface, umbra);
+
+    light->umbra = umbra;
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_light_SetPenumbra(IDirect3DRMLight *iface, D3DVALUE penumbra)
+{
+    struct d3drm_light *light = impl_from_IDirect3DRMLight(iface);
+
+    TRACE("iface %p, penumbra %.8e.\n", iface, penumbra);
+
+    light->penumbra = penumbra;
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_light_SetConstantAttenuation(IDirect3DRMLight *iface, D3DVALUE attenuation)
+{
+    struct d3drm_light *light = impl_from_IDirect3DRMLight(iface);
+
+    TRACE("iface %p, attenuation %.8e.\n", iface, attenuation);
+
+    light->cattenuation = attenuation;
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_light_SetLinearAttenuation(IDirect3DRMLight *iface, D3DVALUE attenuation)
+{
+    struct d3drm_light *light = impl_from_IDirect3DRMLight(iface);
+
+    TRACE("iface %p, attenuation %.8e.\n", iface, attenuation);
+
+    light->lattenuation = attenuation;
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_light_SetQuadraticAttenuation(IDirect3DRMLight *iface, D3DVALUE attenuation)
+{
+    struct d3drm_light *light = impl_from_IDirect3DRMLight(iface);
+
+    TRACE("iface %p, attenuation %.8e.\n", iface, attenuation);
+
+    light->qattenuation = attenuation;
+
+    return D3DRM_OK;
+}
+
+static D3DVALUE WINAPI d3drm_light_GetRange(IDirect3DRMLight *iface)
+{
+    struct d3drm_light *light = impl_from_IDirect3DRMLight(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return light->range;
+}
+
+static D3DVALUE WINAPI d3drm_light_GetUmbra(IDirect3DRMLight *iface)
+{
+    struct d3drm_light *light = impl_from_IDirect3DRMLight(iface);
+
+    TRACE("iface %p.\n", light);
+
+    return light->umbra;
+}
+
+static D3DVALUE WINAPI d3drm_light_GetPenumbra(IDirect3DRMLight *iface)
+{
+    struct d3drm_light *light = impl_from_IDirect3DRMLight(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return light->penumbra;
+}
+
+static D3DVALUE WINAPI d3drm_light_GetConstantAttenuation(IDirect3DRMLight *iface)
+{
+    struct d3drm_light *light = impl_from_IDirect3DRMLight(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return light->cattenuation;
+}
+
+static D3DVALUE WINAPI d3drm_light_GetLinearAttenuation(IDirect3DRMLight *iface)
+{
+    struct d3drm_light *light = impl_from_IDirect3DRMLight(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return light->lattenuation;
+}
+
+static D3DVALUE WINAPI d3drm_light_GetQuadraticAttenuation(IDirect3DRMLight *iface)
+{
+    struct d3drm_light *light = impl_from_IDirect3DRMLight(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return light->qattenuation;
+}
+
+static D3DCOLOR WINAPI d3drm_light_GetColor(IDirect3DRMLight *iface)
+{
+    struct d3drm_light *light = impl_from_IDirect3DRMLight(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return light->color;
+}
+
+static D3DRMLIGHTTYPE WINAPI d3drm_light_GetType(IDirect3DRMLight *iface)
+{
+    struct d3drm_light *light = impl_from_IDirect3DRMLight(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return light->type;
+}
+
+static HRESULT WINAPI d3drm_light_SetEnableFrame(IDirect3DRMLight *iface, IDirect3DRMFrame *frame)
+{
+    FIXME("iface %p, frame %p stub!\n", iface, frame);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_light_GetEnableFrame(IDirect3DRMLight *iface, IDirect3DRMFrame **frame)
+{
+    FIXME("iface %p, frame %p stub!\n", iface, frame);
+
+    return E_NOTIMPL;
+}
+
+static const struct IDirect3DRMLightVtbl d3drm_light_vtbl =
+{
+    d3drm_light_QueryInterface,
+    d3drm_light_AddRef,
+    d3drm_light_Release,
+    d3drm_light_Clone,
+    d3drm_light_AddDestroyCallback,
+    d3drm_light_DeleteDestroyCallback,
+    d3drm_light_SetAppData,
+    d3drm_light_GetAppData,
+    d3drm_light_SetName,
+    d3drm_light_GetName,
+    d3drm_light_GetClassName,
+    d3drm_light_SetType,
+    d3drm_light_SetColor,
+    d3drm_light_SetColorRGB,
+    d3drm_light_SetRange,
+    d3drm_light_SetUmbra,
+    d3drm_light_SetPenumbra,
+    d3drm_light_SetConstantAttenuation,
+    d3drm_light_SetLinearAttenuation,
+    d3drm_light_SetQuadraticAttenuation,
+    d3drm_light_GetRange,
+    d3drm_light_GetUmbra,
+    d3drm_light_GetPenumbra,
+    d3drm_light_GetConstantAttenuation,
+    d3drm_light_GetLinearAttenuation,
+    d3drm_light_GetQuadraticAttenuation,
+    d3drm_light_GetColor,
+    d3drm_light_GetType,
+    d3drm_light_SetEnableFrame,
+    d3drm_light_GetEnableFrame,
+};
+
+HRESULT Direct3DRMLight_create(IUnknown **out)
+{
+    struct d3drm_light *object;
+
+    TRACE("out %p.\n", out);
+
+    if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+        return E_OUTOFMEMORY;
+
+    object->IDirect3DRMLight_iface.lpVtbl = &d3drm_light_vtbl;
+    object->ref = 1;
+
+    *out = (IUnknown *)&object->IDirect3DRMLight_iface;
+
+    return S_OK;
+}

dll/directx/wine/d3drm/material.c

@@ -0,0 +1,298 @@
+/*
+ * Implementation of IDirect3DRMMaterial2 interface
+ *
+ * Copyright 2012 Christian Costa
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "d3drm_private.h"
+
+struct color_rgb
+{
+    D3DVALUE r;
+    D3DVALUE g;
+    D3DVALUE b;
+};
+
+struct d3drm_material
+{
+    IDirect3DRMMaterial2 IDirect3DRMMaterial2_iface;
+    LONG ref;
+    struct color_rgb emissive;
+    struct color_rgb specular;
+    D3DVALUE power;
+    struct color_rgb ambient;
+};
+
+static inline struct d3drm_material *impl_from_IDirect3DRMMaterial2(IDirect3DRMMaterial2 *iface)
+{
+    return CONTAINING_RECORD(iface, struct d3drm_material, IDirect3DRMMaterial2_iface);
+}
+
+static HRESULT WINAPI d3drm_material_QueryInterface(IDirect3DRMMaterial2 *iface, REFIID riid, void **out)
+{
+    TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
+
+    if (IsEqualGUID(riid, &IID_IDirect3DRMMaterial2)
+            || IsEqualGUID(riid, &IID_IDirect3DRMMaterial)
+            || IsEqualGUID(riid, &IID_IUnknown))
+    {
+        IDirect3DRMMaterial2_AddRef(iface);
+        *out = iface;
+        return S_OK;
+    }
+
+    WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
+
+    *out = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI d3drm_material_AddRef(IDirect3DRMMaterial2 *iface)
+{
+    struct d3drm_material *material = impl_from_IDirect3DRMMaterial2(iface);
+    ULONG refcount = InterlockedIncrement(&material->ref);
+
+    TRACE("%p increasing refcount to %u.\n", iface, refcount);
+
+    return refcount;
+}
+
+static ULONG WINAPI d3drm_material_Release(IDirect3DRMMaterial2 *iface)
+{
+    struct d3drm_material *material = impl_from_IDirect3DRMMaterial2(iface);
+    ULONG refcount = InterlockedDecrement(&material->ref);
+
+    TRACE("%p decreasing refcount to %u.\n", iface, refcount);
+
+    if (!refcount)
+        HeapFree(GetProcessHeap(), 0, material);
+
+    return refcount;
+}
+
+static HRESULT WINAPI d3drm_material_Clone(IDirect3DRMMaterial2 *iface,
+        IUnknown *outer, REFIID iid, void **out)
+{
+    FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_material_AddDestroyCallback(IDirect3DRMMaterial2 *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_material_DeleteDestroyCallback(IDirect3DRMMaterial2 *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_material_SetAppData(IDirect3DRMMaterial2 *iface, DWORD data)
+{
+    FIXME("iface %p, data %#x stub!\n", iface, data);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI d3drm_material_GetAppData(IDirect3DRMMaterial2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return 0;
+}
+
+static HRESULT WINAPI d3drm_material_SetName(IDirect3DRMMaterial2 *iface, const char *name)
+{
+    FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_material_GetName(IDirect3DRMMaterial2 *iface, DWORD *size, char *name)
+{
+    FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_material_GetClassName(IDirect3DRMMaterial2 *iface, DWORD *size, char *name)
+{
+    TRACE("iface %p, size %p, name %p.\n", iface, size, name);
+
+    if (!size || *size < strlen("Material") || !name)
+        return E_INVALIDARG;
+
+    strcpy(name, "Material");
+    *size = sizeof("Material");
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_material_SetPower(IDirect3DRMMaterial2 *iface, D3DVALUE power)
+{
+    struct d3drm_material *material = impl_from_IDirect3DRMMaterial2(iface);
+
+    TRACE("iface %p, power %.8e.\n", iface, power);
+
+    material->power = power;
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_material_SetSpecular(IDirect3DRMMaterial2 *iface,
+        D3DVALUE r, D3DVALUE g, D3DVALUE b)
+{
+    struct d3drm_material *material = impl_from_IDirect3DRMMaterial2(iface);
+
+    TRACE("iface %p, r %.8e, g %.8e, b %.8e.\n", iface, r, g, b);
+
+    material->specular.r = r;
+    material->specular.g = g;
+    material->specular.b = b;
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_material_SetEmissive(IDirect3DRMMaterial2 *iface,
+        D3DVALUE r, D3DVALUE g, D3DVALUE b)
+{
+    struct d3drm_material *material = impl_from_IDirect3DRMMaterial2(iface);
+
+    TRACE("iface %p, r %.8e, g %.8e, b %.8e.\n", iface, r, g, b);
+
+    material->emissive.r = r;
+    material->emissive.g = g;
+    material->emissive.b = b;
+
+    return D3DRM_OK;
+}
+
+static D3DVALUE WINAPI d3drm_material_GetPower(IDirect3DRMMaterial2 *iface)
+{
+    struct d3drm_material *material = impl_from_IDirect3DRMMaterial2(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return material->power;
+}
+
+static HRESULT WINAPI d3drm_material_GetSpecular(IDirect3DRMMaterial2 *iface,
+        D3DVALUE *r, D3DVALUE *g, D3DVALUE *b)
+{
+    struct d3drm_material *material = impl_from_IDirect3DRMMaterial2(iface);
+
+    TRACE("iface %p, r %p, g %p, b %p.\n", iface, r, g, b);
+
+    *r = material->specular.r;
+    *g = material->specular.g;
+    *b = material->specular.b;
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_material_GetEmissive(IDirect3DRMMaterial2 *iface,
+        D3DVALUE *r, D3DVALUE *g, D3DVALUE *b)
+{
+    struct d3drm_material *material = impl_from_IDirect3DRMMaterial2(iface);
+
+    TRACE("iface %p, r %p, g %p, b %p.\n", iface, r, g, b);
+
+    *r = material->emissive.r;
+    *g = material->emissive.g;
+    *b = material->emissive.b;
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_material_GetAmbient(IDirect3DRMMaterial2 *iface,
+        D3DVALUE *r, D3DVALUE *g, D3DVALUE *b)
+{
+    struct d3drm_material *material = impl_from_IDirect3DRMMaterial2(iface);
+
+    TRACE("iface %p, r %p, g %p, b %p.\n", iface, r, g, b);
+
+    *r = material->ambient.r;
+    *g = material->ambient.g;
+    *b = material->ambient.b;
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_material_SetAmbient(IDirect3DRMMaterial2 *iface,
+        D3DVALUE r, D3DVALUE g, D3DVALUE b)
+{
+    struct d3drm_material *material = impl_from_IDirect3DRMMaterial2(iface);
+
+    TRACE("iface %p, r %.8e, g %.8e, b %.8e.\n", iface, r, g, b);
+
+    material->ambient.r = r;
+    material->ambient.g = g;
+    material->ambient.b = b;
+
+    return D3DRM_OK;
+}
+
+static const struct IDirect3DRMMaterial2Vtbl d3drm_material_vtbl =
+{
+    d3drm_material_QueryInterface,
+    d3drm_material_AddRef,
+    d3drm_material_Release,
+    d3drm_material_Clone,
+    d3drm_material_AddDestroyCallback,
+    d3drm_material_DeleteDestroyCallback,
+    d3drm_material_SetAppData,
+    d3drm_material_GetAppData,
+    d3drm_material_SetName,
+    d3drm_material_GetName,
+    d3drm_material_GetClassName,
+    d3drm_material_SetPower,
+    d3drm_material_SetSpecular,
+    d3drm_material_SetEmissive,
+    d3drm_material_GetPower,
+    d3drm_material_GetSpecular,
+    d3drm_material_GetEmissive,
+    d3drm_material_GetAmbient,
+    d3drm_material_SetAmbient,
+};
+
+HRESULT Direct3DRMMaterial_create(IDirect3DRMMaterial2 **out)
+{
+    struct d3drm_material *object;
+
+    TRACE("out %p.\n", out);
+
+    if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+        return E_OUTOFMEMORY;
+
+    object->IDirect3DRMMaterial2_iface.lpVtbl = &d3drm_material_vtbl;
+    object->ref = 1;
+
+    object->specular.r = 1.0f;
+    object->specular.g = 1.0f;
+    object->specular.b = 1.0f;
+
+    *out = &object->IDirect3DRMMaterial2_iface;
+
+    return S_OK;
+}

dll/directx/wine/d3drm/math.c

@@ -0,0 +1,274 @@
+/*
+ * Copyright 2007 David Adam
+ * Copyright 2007 Vijay Kiran Kamuju
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "d3drm_private.h"
+
+#include <math.h>
+
+/* Create a RGB color from its components */
+D3DCOLOR WINAPI D3DRMCreateColorRGB(D3DVALUE red, D3DVALUE green, D3DVALUE blue)
+{
+    return (D3DRMCreateColorRGBA(red, green, blue, 255.0));
+}
+/* Create a RGBA color from its components */
+D3DCOLOR WINAPI D3DRMCreateColorRGBA(D3DVALUE red, D3DVALUE green, D3DVALUE blue, D3DVALUE alpha)
+{
+    int Red, Green, Blue, Alpha;
+    Red=floor(red*255);
+    Green=floor(green*255);
+    Blue=floor(blue*255);
+    Alpha=floor(alpha*255);
+    if (red < 0) Red=0;
+    if (red > 1) Red=255;
+    if (green < 0) Green=0;
+    if (green > 1) Green=255;
+    if (blue < 0) Blue=0;
+    if (blue > 1) Blue=255;
+    if (alpha < 0) Alpha=0;
+    if (alpha > 1) Alpha=255;
+    return (RGBA_MAKE(Red, Green, Blue, Alpha));
+}
+
+/* Determine the alpha part of a color */
+D3DVALUE WINAPI D3DRMColorGetAlpha(D3DCOLOR color)
+{
+    return (RGBA_GETALPHA(color)/255.0);
+}
+
+/* Determine the blue part of a color */
+D3DVALUE WINAPI D3DRMColorGetBlue(D3DCOLOR color)
+{
+    return (RGBA_GETBLUE(color)/255.0);
+}
+
+/* Determine the green part of a color */
+D3DVALUE WINAPI D3DRMColorGetGreen(D3DCOLOR color)
+{
+    return (RGBA_GETGREEN(color)/255.0);
+}
+
+/* Determine the red part of a color */
+D3DVALUE WINAPI D3DRMColorGetRed(D3DCOLOR color)
+{
+    return (RGBA_GETRED(color)/255.0);
+}
+
+/* Product of 2 quaternions */
+D3DRMQUATERNION * WINAPI D3DRMQuaternionMultiply(D3DRMQUATERNION *q, D3DRMQUATERNION *a, D3DRMQUATERNION *b)
+{
+    D3DRMQUATERNION temp;
+    D3DVECTOR cross_product;
+
+    D3DRMVectorCrossProduct(&cross_product, &a->v, &b->v);
+    temp.s = a->s * b->s - D3DRMVectorDotProduct(&a->v, &b->v);
+    temp.v.u1.x = a->s * b->v.u1.x + b->s * a->v.u1.x + cross_product.u1.x;
+    temp.v.u2.y = a->s * b->v.u2.y + b->s * a->v.u2.y + cross_product.u2.y;
+    temp.v.u3.z = a->s * b->v.u3.z + b->s * a->v.u3.z + cross_product.u3.z;
+
+    *q = temp;
+    return q;
+}
+
+/* Matrix for the Rotation that a unit quaternion represents */
+void WINAPI D3DRMMatrixFromQuaternion(D3DRMMATRIX4D m, D3DRMQUATERNION *q)
+{
+    D3DVALUE w,x,y,z;
+    w = q->s;
+    x = q->v.u1.x;
+    y = q->v.u2.y;
+    z = q->v.u3.z;
+    m[0][0] = 1.0-2.0*(y*y+z*z);
+    m[1][1] = 1.0-2.0*(x*x+z*z);
+    m[2][2] = 1.0-2.0*(x*x+y*y);
+    m[1][0] = 2.0*(x*y+z*w);
+    m[0][1] = 2.0*(x*y-z*w);
+    m[2][0] = 2.0*(x*z-y*w);
+    m[0][2] = 2.0*(x*z+y*w);
+    m[2][1] = 2.0*(y*z+x*w);
+    m[1][2] = 2.0*(y*z-x*w);
+    m[3][0] = 0.0;
+    m[3][1] = 0.0;
+    m[3][2] = 0.0;
+    m[0][3] = 0.0;
+    m[1][3] = 0.0;
+    m[2][3] = 0.0;
+    m[3][3] = 1.0;
+}
+
+/* Return a unit quaternion that represents a rotation of an angle around an axis */
+D3DRMQUATERNION * WINAPI D3DRMQuaternionFromRotation(D3DRMQUATERNION *q, D3DVECTOR *v, D3DVALUE theta)
+{
+    q->s = cos(theta/2.0);
+    D3DRMVectorScale(&q->v, D3DRMVectorNormalize(v), sin(theta/2.0));
+    return q;
+}
+
+/* Interpolation between two quaternions */
+D3DRMQUATERNION * WINAPI D3DRMQuaternionSlerp(D3DRMQUATERNION *q,
+        D3DRMQUATERNION *a, D3DRMQUATERNION *b, D3DVALUE alpha)
+{
+    D3DVALUE dot, epsilon, temp, theta, u;
+    D3DVECTOR v1, v2;
+
+    dot = a->s * b->s + D3DRMVectorDotProduct(&a->v, &b->v);
+    epsilon = 1.0f;
+    temp = 1.0f - alpha;
+    u = alpha;
+    if (dot < 0.0)
+    {
+     epsilon = -1.0;
+     dot = -dot;
+    }
+    if( 1.0f - dot > 0.001f )
+    {
+        theta = acos(dot);
+        temp  = sin(theta * temp) / sin(theta);
+        u = sin(theta * alpha) / sin(theta);
+    }
+    q->s = temp * a->s + epsilon * u * b->s;
+    D3DRMVectorScale(&v1, &a->v, temp);
+    D3DRMVectorScale(&v2, &b->v, epsilon * u);
+    D3DRMVectorAdd(&q->v, &v1, &v2);
+    return q;
+}
+
+/* Add Two Vectors */
+D3DVECTOR * WINAPI D3DRMVectorAdd(D3DVECTOR *d, D3DVECTOR *s1, D3DVECTOR *s2)
+{
+    D3DVECTOR temp;
+
+    temp.u1.x=s1->u1.x + s2->u1.x;
+    temp.u2.y=s1->u2.y + s2->u2.y;
+    temp.u3.z=s1->u3.z + s2->u3.z;
+
+    *d = temp;
+    return d;
+}
+
+/* Subtract Two Vectors */
+D3DVECTOR * WINAPI D3DRMVectorSubtract(D3DVECTOR *d, D3DVECTOR *s1, D3DVECTOR *s2)
+{
+    D3DVECTOR temp;
+
+    temp.u1.x=s1->u1.x - s2->u1.x;
+    temp.u2.y=s1->u2.y - s2->u2.y;
+    temp.u3.z=s1->u3.z - s2->u3.z;
+
+    *d = temp;
+    return d;
+}
+
+/* Cross Product of Two Vectors */
+D3DVECTOR * WINAPI D3DRMVectorCrossProduct(D3DVECTOR *d, D3DVECTOR *s1, D3DVECTOR *s2)
+{
+    D3DVECTOR temp;
+
+    temp.u1.x=s1->u2.y * s2->u3.z - s1->u3.z * s2->u2.y;
+    temp.u2.y=s1->u3.z * s2->u1.x - s1->u1.x * s2->u3.z;
+    temp.u3.z=s1->u1.x * s2->u2.y - s1->u2.y * s2->u1.x;
+
+    *d = temp;
+    return d;
+}
+
+/* Dot Product of Two vectors */
+D3DVALUE WINAPI D3DRMVectorDotProduct(D3DVECTOR *s1, D3DVECTOR *s2)
+{
+    D3DVALUE dot_product;
+    dot_product=s1->u1.x * s2->u1.x + s1->u2.y * s2->u2.y + s1->u3.z * s2->u3.z;
+    return dot_product;
+}
+
+/* Norm of a vector */
+D3DVALUE WINAPI D3DRMVectorModulus(D3DVECTOR *v)
+{
+    D3DVALUE result;
+    result=sqrt(v->u1.x * v->u1.x + v->u2.y * v->u2.y + v->u3.z * v->u3.z);
+    return result;
+}
+
+/* Normalize a vector.  Returns (1,0,0) if INPUT is the NULL vector. */
+D3DVECTOR * WINAPI D3DRMVectorNormalize(D3DVECTOR *u)
+{
+    D3DVALUE modulus = D3DRMVectorModulus(u);
+    if(modulus)
+    {
+        D3DRMVectorScale(u,u,1.0/modulus);
+    }
+    else
+    {
+        u->u1.x=1.0;
+        u->u2.y=0.0;
+        u->u3.z=0.0;
+    }
+    return u;
+}
+
+/* Returns a random unit vector */
+D3DVECTOR * WINAPI D3DRMVectorRandom(D3DVECTOR *d)
+{
+    d->u1.x = rand();
+    d->u2.y = rand();
+    d->u3.z = rand();
+    D3DRMVectorNormalize(d);
+    return d;
+}
+
+/* Reflection of a vector on a surface */
+D3DVECTOR * WINAPI D3DRMVectorReflect(D3DVECTOR *r, D3DVECTOR *ray, D3DVECTOR *norm)
+{
+    D3DVECTOR sca, temp;
+    D3DRMVectorSubtract(&temp, D3DRMVectorScale(&sca, norm, 2.0*D3DRMVectorDotProduct(ray,norm)), ray);
+
+    *r = temp;
+    return r;
+}
+
+/* Rotation of a vector */
+D3DVECTOR * WINAPI D3DRMVectorRotate(D3DVECTOR *r, D3DVECTOR *v, D3DVECTOR *axis, D3DVALUE theta)
+{
+    D3DRMQUATERNION quaternion1, quaternion2, quaternion3;
+    D3DVECTOR norm;
+
+    quaternion1.s = cos(theta * 0.5f);
+    quaternion2.s = cos(theta * 0.5f);
+    norm = *D3DRMVectorNormalize(axis);
+    D3DRMVectorScale(&quaternion1.v, &norm, sin(theta * 0.5f));
+    D3DRMVectorScale(&quaternion2.v, &norm, -sin(theta * 0.5f));
+    quaternion3.s = 0.0;
+    quaternion3.v = *v;
+    D3DRMQuaternionMultiply(&quaternion1, &quaternion1, &quaternion3);
+    D3DRMQuaternionMultiply(&quaternion1, &quaternion1, &quaternion2);
+
+    *r = *D3DRMVectorNormalize(&quaternion1.v);
+    return r;
+}
+
+/* Scale a vector */
+D3DVECTOR * WINAPI D3DRMVectorScale(D3DVECTOR *d, D3DVECTOR *s, D3DVALUE factor)
+{
+    D3DVECTOR temp;
+
+    temp.u1.x=factor * s->u1.x;
+    temp.u2.y=factor * s->u2.y;
+    temp.u3.z=factor * s->u3.z;
+
+    *d = temp;
+    return d;
+}

dll/directx/wine/d3drm/texture.c

@@ -0,0 +1,729 @@
+/*
+ * Implementation of IDirect3DRMTextureX interfaces
+ *
+ * Copyright 2012 Christian Costa
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "d3drm_private.h"
+
+struct d3drm_texture
+{
+    IDirect3DRMTexture2 IDirect3DRMTexture2_iface;
+    IDirect3DRMTexture3 IDirect3DRMTexture3_iface;
+    LONG ref;
+    DWORD app_data;
+};
+
+static inline struct d3drm_texture *impl_from_IDirect3DRMTexture2(IDirect3DRMTexture2 *iface)
+{
+    return CONTAINING_RECORD(iface, struct d3drm_texture, IDirect3DRMTexture2_iface);
+}
+
+static inline struct d3drm_texture *impl_from_IDirect3DRMTexture3(IDirect3DRMTexture3 *iface)
+{
+    return CONTAINING_RECORD(iface, struct d3drm_texture, IDirect3DRMTexture3_iface);
+}
+
+static HRESULT WINAPI d3drm_texture2_QueryInterface(IDirect3DRMTexture2 *iface, REFIID riid, void **out)
+{
+    struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
+
+    TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
+
+    if (IsEqualGUID(riid, &IID_IDirect3DRMTexture2)
+            || IsEqualGUID(riid, &IID_IDirect3DRMTexture)
+            || IsEqualGUID(riid, &IID_IUnknown))
+    {
+        *out = &texture->IDirect3DRMTexture2_iface;
+    }
+    else if (IsEqualGUID(riid, &IID_IDirect3DRMTexture3))
+    {
+        *out = &texture->IDirect3DRMTexture3_iface;
+    }
+    else
+    {
+        *out = NULL;
+        WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
+        return E_NOINTERFACE;
+    }
+
+    IUnknown_AddRef((IUnknown *)*out);
+    return S_OK;
+}
+
+static ULONG WINAPI d3drm_texture2_AddRef(IDirect3DRMTexture2 *iface)
+{
+    struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
+    ULONG refcount = InterlockedIncrement(&texture->ref);
+
+    TRACE("%p increasing refcount to %u.\n", iface, refcount);
+
+    return refcount;
+}
+
+static ULONG WINAPI d3drm_texture2_Release(IDirect3DRMTexture2 *iface)
+{
+    struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
+    ULONG refcount = InterlockedDecrement(&texture->ref);
+
+    TRACE("%p decreasing refcount to %u.\n", iface, refcount);
+
+    if (!refcount)
+        HeapFree(GetProcessHeap(), 0, texture);
+
+    return refcount;
+}
+
+static HRESULT WINAPI d3drm_texture2_Clone(IDirect3DRMTexture2 *iface,
+        IUnknown *outer, REFIID iid, void **out)
+{
+    FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture2_AddDestroyCallback(IDirect3DRMTexture2 *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture2_DeleteDestroyCallback(IDirect3DRMTexture2 *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture2_SetAppData(IDirect3DRMTexture2 *iface, DWORD data)
+{
+    struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
+
+    TRACE("iface %p, data %#x.\n", iface, data);
+
+    return IDirect3DRMTexture3_SetAppData(&texture->IDirect3DRMTexture3_iface, data);
+}
+
+static DWORD WINAPI d3drm_texture2_GetAppData(IDirect3DRMTexture2 *iface)
+{
+    struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return IDirect3DRMTexture3_GetAppData(&texture->IDirect3DRMTexture3_iface);
+}
+
+static HRESULT WINAPI d3drm_texture2_SetName(IDirect3DRMTexture2 *iface, const char *name)
+{
+    FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture2_GetName(IDirect3DRMTexture2 *iface, DWORD *size, char *name)
+{
+    FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture2_GetClassName(IDirect3DRMTexture2 *iface, DWORD *size, char *name)
+{
+    struct d3drm_texture *texture = impl_from_IDirect3DRMTexture2(iface);
+
+    TRACE("iface %p, size %p, name %p.\n", iface, size, name);
+
+    return IDirect3DRMTexture3_GetClassName(&texture->IDirect3DRMTexture3_iface, size, name);
+}
+
+static HRESULT WINAPI d3drm_texture2_InitFromFile(IDirect3DRMTexture2 *iface, const char *filename)
+{
+    FIXME("iface %p, filename %s stub!\n", iface, debugstr_a(filename));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture2_InitFromSurface(IDirect3DRMTexture2 *iface,
+        IDirectDrawSurface *surface)
+{
+    FIXME("iface %p, surface %p stub!\n", iface, surface);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture2_InitFromResource(IDirect3DRMTexture2 *iface, HRSRC resource)
+{
+    FIXME("iface %p, resource %p stub!\n", iface, resource);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture2_Changed(IDirect3DRMTexture2 *iface, BOOL pixels, BOOL palette)
+{
+    FIXME("iface %p, pixels %#x, palette %#x stub!\n", iface, pixels, palette);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture2_SetColors(IDirect3DRMTexture2 *iface, DWORD max_colors)
+{
+    FIXME("iface %p, max_colors %u stub!\n", iface, max_colors);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture2_SetShades(IDirect3DRMTexture2 *iface, DWORD max_shades)
+{
+    FIXME("iface %p, max_shades %u stub!\n", iface, max_shades);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture2_SetDecalSize(IDirect3DRMTexture2 *iface, D3DVALUE width, D3DVALUE height)
+{
+    FIXME("iface %p, width %.8e, height %.8e stub!\n", iface, width, height);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture2_SetDecalOrigin(IDirect3DRMTexture2 *iface, LONG x, LONG y)
+{
+    FIXME("iface %p, x %d, y %d stub!\n", iface, x, y);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture2_SetDecalScale(IDirect3DRMTexture2 *iface, DWORD scale)
+{
+    FIXME("iface %p, scale %u stub!\n", iface, scale);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture2_SetDecalTransparency(IDirect3DRMTexture2 *iface, BOOL transparency)
+{
+    FIXME("iface %p, transparency %#x stub!\n", iface, transparency);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture2_SetDecalTransparentColor(IDirect3DRMTexture2 *iface, D3DCOLOR color)
+{
+    FIXME("iface %p, color 0x%08x stub!\n", iface, color);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture2_GetDecalSize(IDirect3DRMTexture2 *iface, D3DVALUE *width, D3DVALUE *height)
+{
+    FIXME("iface %p, width %p, height %p stub!\n", iface, width, height);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture2_GetDecalOrigin(IDirect3DRMTexture2 *iface, LONG *x, LONG *y)
+{
+    FIXME("iface %p, x %p, y %p stub!\n", iface, x, y);
+
+    return E_NOTIMPL;
+}
+
+static D3DRMIMAGE * WINAPI d3drm_texture2_GetImage(IDirect3DRMTexture2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return NULL;
+}
+
+static DWORD WINAPI d3drm_texture2_GetShades(IDirect3DRMTexture2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return 0;
+}
+
+static DWORD WINAPI d3drm_texture2_GetColors(IDirect3DRMTexture2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return 0;
+}
+
+static DWORD WINAPI d3drm_texture2_GetDecalScale(IDirect3DRMTexture2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return 0;
+}
+
+static BOOL WINAPI d3drm_texture2_GetDecalTransparency(IDirect3DRMTexture2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return FALSE;
+}
+
+static D3DCOLOR WINAPI d3drm_texture2_GetDecalTransparentColor(IDirect3DRMTexture2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return 0;
+}
+
+static HRESULT WINAPI d3drm_texture2_InitFromImage(IDirect3DRMTexture2 *iface, D3DRMIMAGE *image)
+{
+    FIXME("iface %p, image %p stub!\n", iface, image);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture2_InitFromResource2(IDirect3DRMTexture2 *iface,
+        HMODULE module, const char *name, const char *type)
+{
+    FIXME("iface %p, module %p, name %s, type %s stub!\n",
+            iface, module, debugstr_a(name), debugstr_a(type));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture2_GenerateMIPMap(IDirect3DRMTexture2 *iface, DWORD flags)
+{
+    FIXME("iface %p, flags %#x stub!\n", iface, flags);
+
+    return E_NOTIMPL;
+}
+
+static const struct IDirect3DRMTexture2Vtbl d3drm_texture2_vtbl =
+{
+    d3drm_texture2_QueryInterface,
+    d3drm_texture2_AddRef,
+    d3drm_texture2_Release,
+    d3drm_texture2_Clone,
+    d3drm_texture2_AddDestroyCallback,
+    d3drm_texture2_DeleteDestroyCallback,
+    d3drm_texture2_SetAppData,
+    d3drm_texture2_GetAppData,
+    d3drm_texture2_SetName,
+    d3drm_texture2_GetName,
+    d3drm_texture2_GetClassName,
+    d3drm_texture2_InitFromFile,
+    d3drm_texture2_InitFromSurface,
+    d3drm_texture2_InitFromResource,
+    d3drm_texture2_Changed,
+    d3drm_texture2_SetColors,
+    d3drm_texture2_SetShades,
+    d3drm_texture2_SetDecalSize,
+    d3drm_texture2_SetDecalOrigin,
+    d3drm_texture2_SetDecalScale,
+    d3drm_texture2_SetDecalTransparency,
+    d3drm_texture2_SetDecalTransparentColor,
+    d3drm_texture2_GetDecalSize,
+    d3drm_texture2_GetDecalOrigin,
+    d3drm_texture2_GetImage,
+    d3drm_texture2_GetShades,
+    d3drm_texture2_GetColors,
+    d3drm_texture2_GetDecalScale,
+    d3drm_texture2_GetDecalTransparency,
+    d3drm_texture2_GetDecalTransparentColor,
+    d3drm_texture2_InitFromImage,
+    d3drm_texture2_InitFromResource2,
+    d3drm_texture2_GenerateMIPMap,
+};
+
+static HRESULT WINAPI d3drm_texture3_QueryInterface(IDirect3DRMTexture3 *iface, REFIID riid, void **out)
+{
+    struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
+
+    TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
+
+    if (IsEqualGUID(riid, &IID_IDirect3DRMTexture2)
+            || IsEqualGUID(riid, &IID_IDirect3DRMTexture)
+            || IsEqualGUID(riid, &IID_IUnknown))
+    {
+        *out = &texture->IDirect3DRMTexture2_iface;
+    }
+    else if (IsEqualGUID(riid, &IID_IDirect3DRMTexture3))
+    {
+        *out = &texture->IDirect3DRMTexture3_iface;
+    }
+    else
+    {
+        *out = NULL;
+        WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
+        return E_NOINTERFACE;
+    }
+
+    IUnknown_AddRef((IUnknown *)*out);
+    return S_OK;
+}
+
+static ULONG WINAPI d3drm_texture3_AddRef(IDirect3DRMTexture3 *iface)
+{
+    struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
+    ULONG refcount = InterlockedIncrement(&texture->ref);
+
+    TRACE("%p increasing refcount to %u.\n", iface, refcount);
+
+    return refcount;
+}
+
+static ULONG WINAPI d3drm_texture3_Release(IDirect3DRMTexture3 *iface)
+{
+    struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
+    ULONG refcount = InterlockedDecrement(&texture->ref);
+
+    TRACE("%p decreasing refcount to %u.\n", iface, refcount);
+
+    if (!refcount)
+        HeapFree(GetProcessHeap(), 0, texture);
+
+    return refcount;
+}
+
+static HRESULT WINAPI d3drm_texture3_Clone(IDirect3DRMTexture3 *iface,
+        IUnknown *outer, REFIID iid, void **out)
+{
+    FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_AddDestroyCallback(IDirect3DRMTexture3 *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_DeleteDestroyCallback(IDirect3DRMTexture3 *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_SetAppData(IDirect3DRMTexture3 *iface, DWORD data)
+{
+    struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
+
+    TRACE("iface %p, data %#x.\n", iface, data);
+
+    texture->app_data = data;
+
+    return D3DRM_OK;
+}
+
+static DWORD WINAPI d3drm_texture3_GetAppData(IDirect3DRMTexture3 *iface)
+{
+    struct d3drm_texture *texture = impl_from_IDirect3DRMTexture3(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return texture->app_data;
+}
+
+static HRESULT WINAPI d3drm_texture3_SetName(IDirect3DRMTexture3 *iface, const char *name)
+{
+    FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_GetName(IDirect3DRMTexture3 *iface, DWORD *size, char *name)
+{
+    FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_GetClassName(IDirect3DRMTexture3 *iface, DWORD *size, char *name)
+{
+    TRACE("iface %p, size %p, name %p.\n", iface, size, name);
+
+    if (!size || *size < strlen("Texture") || !name)
+        return E_INVALIDARG;
+
+    strcpy(name, "Texture");
+    *size = sizeof("Texture");
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_texture3_InitFromFile(IDirect3DRMTexture3 *iface, const char *filename)
+{
+    FIXME("iface %p, filename %s stub!\n", iface, debugstr_a(filename));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_InitFromSurface(IDirect3DRMTexture3 *iface,
+        IDirectDrawSurface *surface)
+{
+    FIXME("iface %p, surface %p stub!\n", iface, surface);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_InitFromResource(IDirect3DRMTexture3 *iface, HRSRC resource)
+{
+    FIXME("iface %p, resource %p stub!\n", iface, resource);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_Changed(IDirect3DRMTexture3 *iface,
+        DWORD flags, DWORD rect_count, RECT *rects)
+{
+    FIXME("iface %p, flags %#x, rect_count %u, rects %p stub!\n", iface, flags, rect_count, rects);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_SetColors(IDirect3DRMTexture3 *iface, DWORD max_colors)
+{
+    FIXME("iface %p, max_colors %u stub!\n", iface, max_colors);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_SetShades(IDirect3DRMTexture3 *iface, DWORD max_shades)
+{
+    FIXME("iface %p, max_shades %u stub!\n", iface, max_shades);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_SetDecalSize(IDirect3DRMTexture3 *iface, D3DVALUE width, D3DVALUE height)
+{
+    FIXME("iface %p, width %.8e, height %.8e stub!\n", iface, width, height);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_SetDecalOrigin(IDirect3DRMTexture3 *iface, LONG x, LONG y)
+{
+    FIXME("iface %p, x %d, y %d stub!\n", iface, x, y);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_SetDecalScale(IDirect3DRMTexture3 *iface, DWORD scale)
+{
+    FIXME("iface %p, scale %u stub!\n", iface, scale);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_SetDecalTransparency(IDirect3DRMTexture3 *iface, BOOL transparency)
+{
+    FIXME("iface %p, transparency %#x stub!\n", iface, transparency);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_SetDecalTransparentColor(IDirect3DRMTexture3 *iface, D3DCOLOR color)
+{
+    FIXME("iface %p, color 0x%08x stub!\n", iface, color);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_GetDecalSize(IDirect3DRMTexture3 *iface, D3DVALUE *width, D3DVALUE *height)
+{
+    FIXME("iface %p, width %p, height %p stub!\n", iface, width, height);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_GetDecalOrigin(IDirect3DRMTexture3 *iface, LONG *x, LONG *y)
+{
+    FIXME("iface %p, x %p, y %p stub!\n", iface, x, y);
+
+    return E_NOTIMPL;
+}
+
+static D3DRMIMAGE * WINAPI d3drm_texture3_GetImage(IDirect3DRMTexture3 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return NULL;
+}
+
+static DWORD WINAPI d3drm_texture3_GetShades(IDirect3DRMTexture3 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return 0;
+}
+
+static DWORD WINAPI d3drm_texture3_GetColors(IDirect3DRMTexture3 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return 0;
+}
+
+static DWORD WINAPI d3drm_texture3_GetDecalScale(IDirect3DRMTexture3 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return 0;
+}
+
+static BOOL WINAPI d3drm_texture3_GetDecalTransparency(IDirect3DRMTexture3 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return FALSE;
+}
+
+static D3DCOLOR WINAPI d3drm_texture3_GetDecalTransparentColor(IDirect3DRMTexture3 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return 0;
+}
+
+static HRESULT WINAPI d3drm_texture3_InitFromImage(IDirect3DRMTexture3 *iface, D3DRMIMAGE *image)
+{
+    FIXME("iface %p, image %p stub!\n", iface, image);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_InitFromResource2(IDirect3DRMTexture3 *iface,
+        HMODULE module, const char *name, const char *type)
+{
+    FIXME("iface %p, module %p, name %s, type %s stub!\n",
+            iface, module, debugstr_a(name), debugstr_a(type));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_GenerateMIPMap(IDirect3DRMTexture3 *iface, DWORD flags)
+{
+    FIXME("iface %p, flags %#x stub!\n", iface, flags);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_GetSurface(IDirect3DRMTexture3 *iface,
+        DWORD flags, IDirectDrawSurface **surface)
+{
+    FIXME("iface %p, flags %#x, surface %p stub!\n", iface, flags, surface);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_SetCacheOptions(IDirect3DRMTexture3 *iface, LONG importance, DWORD flags)
+{
+    FIXME("iface %p, importance %d, flags %#x stub!\n", iface, importance, flags);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_GetCacheOptions(IDirect3DRMTexture3 *iface,
+        LONG *importance, DWORD *flags)
+{
+    FIXME("iface %p, importance %p, flags %p stub!\n", iface, importance, flags);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_SetDownsampleCallback(IDirect3DRMTexture3 *iface,
+        D3DRMDOWNSAMPLECALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_texture3_SetValidationCallback(IDirect3DRMTexture3 *iface,
+        D3DRMVALIDATIONCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static const struct IDirect3DRMTexture3Vtbl d3drm_texture3_vtbl =
+{
+    d3drm_texture3_QueryInterface,
+    d3drm_texture3_AddRef,
+    d3drm_texture3_Release,
+    d3drm_texture3_Clone,
+    d3drm_texture3_AddDestroyCallback,
+    d3drm_texture3_DeleteDestroyCallback,
+    d3drm_texture3_SetAppData,
+    d3drm_texture3_GetAppData,
+    d3drm_texture3_SetName,
+    d3drm_texture3_GetName,
+    d3drm_texture3_GetClassName,
+    d3drm_texture3_InitFromFile,
+    d3drm_texture3_InitFromSurface,
+    d3drm_texture3_InitFromResource,
+    d3drm_texture3_Changed,
+    d3drm_texture3_SetColors,
+    d3drm_texture3_SetShades,
+    d3drm_texture3_SetDecalSize,
+    d3drm_texture3_SetDecalOrigin,
+    d3drm_texture3_SetDecalScale,
+    d3drm_texture3_SetDecalTransparency,
+    d3drm_texture3_SetDecalTransparentColor,
+    d3drm_texture3_GetDecalSize,
+    d3drm_texture3_GetDecalOrigin,
+    d3drm_texture3_GetImage,
+    d3drm_texture3_GetShades,
+    d3drm_texture3_GetColors,
+    d3drm_texture3_GetDecalScale,
+    d3drm_texture3_GetDecalTransparency,
+    d3drm_texture3_GetDecalTransparentColor,
+    d3drm_texture3_InitFromImage,
+    d3drm_texture3_InitFromResource2,
+    d3drm_texture3_GenerateMIPMap,
+    d3drm_texture3_GetSurface,
+    d3drm_texture3_SetCacheOptions,
+    d3drm_texture3_GetCacheOptions,
+    d3drm_texture3_SetDownsampleCallback,
+    d3drm_texture3_SetValidationCallback,
+};
+
+HRESULT Direct3DRMTexture_create(REFIID riid, IUnknown **out)
+{
+    struct d3drm_texture *object;
+
+    TRACE("riid %s, out %p.\n", debugstr_guid(riid), out);
+
+    if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+        return E_OUTOFMEMORY;
+
+    object->IDirect3DRMTexture2_iface.lpVtbl = &d3drm_texture2_vtbl;
+    object->IDirect3DRMTexture3_iface.lpVtbl = &d3drm_texture3_vtbl;
+    object->ref = 1;
+
+    if (IsEqualGUID(riid, &IID_IDirect3DRMTexture3))
+        *out = (IUnknown *)&object->IDirect3DRMTexture3_iface;
+    else
+        *out = (IUnknown *)&object->IDirect3DRMTexture2_iface;
+
+    return S_OK;
+}

dll/directx/wine/d3drm/version.rc

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2004 Ivan Leo Puoti
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#define WINE_FILEDESCRIPTION_STR "Wine Direct3D Retained Mode Utility Functions"
+#define WINE_FILENAME_STR "d3drm.dll"
+#define WINE_FILEVERSION 5,0,2134,14
+#define WINE_FILEVERSION_STR "5.0.2134.14"
+#define WINE_PRODUCTVERSION 5,0,2134,14
+#define WINE_PRODUCTVERSION_STR "5.0"
+
+#include "wine/wine_common_ver.rc"

dll/directx/wine/d3drm/viewport.c

@@ -0,0 +1,824 @@
+/*
+ * Implementation of IDirect3DRMViewport Interface
+ *
+ * Copyright 2012 André Hentschel
+ *
+ * This file contains the (internal) driver registration functions,
+ * driver enumeration APIs and DirectDraw creation functions.
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "d3drm_private.h"
+
+struct d3drm_viewport
+{
+    IDirect3DRMViewport IDirect3DRMViewport_iface;
+    IDirect3DRMViewport2 IDirect3DRMViewport2_iface;
+    LONG ref;
+    D3DVALUE back;
+    D3DVALUE front;
+    D3DVALUE field;
+    D3DRMPROJECTIONTYPE projection;
+};
+
+static inline struct d3drm_viewport *impl_from_IDirect3DRMViewport(IDirect3DRMViewport *iface)
+{
+    return CONTAINING_RECORD(iface, struct d3drm_viewport, IDirect3DRMViewport_iface);
+}
+
+static inline struct d3drm_viewport *impl_from_IDirect3DRMViewport2(IDirect3DRMViewport2 *iface)
+{
+    return CONTAINING_RECORD(iface, struct d3drm_viewport, IDirect3DRMViewport2_iface);
+}
+
+static HRESULT WINAPI d3drm_viewport1_QueryInterface(IDirect3DRMViewport *iface, REFIID riid, void **out)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport(iface);
+
+    TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
+
+    if (IsEqualGUID(riid, &IID_IDirect3DRMViewport)
+            || IsEqualGUID(riid, &IID_IUnknown))
+    {
+        *out = &viewport->IDirect3DRMViewport_iface;
+    }
+    else if (IsEqualGUID(riid, &IID_IDirect3DRMViewport2))
+    {
+        *out = &viewport->IDirect3DRMViewport2_iface;
+    }
+    else
+    {
+        *out = NULL;
+        WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
+        return E_NOINTERFACE;
+    }
+
+    IUnknown_AddRef((IUnknown *)*out);
+    return S_OK;
+}
+
+static ULONG WINAPI d3drm_viewport1_AddRef(IDirect3DRMViewport *iface)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport(iface);
+    ULONG refcount = InterlockedIncrement(&viewport->ref);
+
+    TRACE("%p increasing refcount to %u.\n", iface, refcount);
+
+    return refcount;
+}
+
+static ULONG WINAPI d3drm_viewport1_Release(IDirect3DRMViewport *iface)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport(iface);
+    ULONG refcount = InterlockedDecrement(&viewport->ref);
+
+    TRACE("%p decreasing refcount to %u.\n", iface, refcount);
+
+    if (!refcount)
+        HeapFree(GetProcessHeap(), 0, viewport);
+
+    return refcount;
+}
+
+static HRESULT WINAPI d3drm_viewport1_Clone(IDirect3DRMViewport *iface,
+        IUnknown *outer, REFIID iid, void **out)
+{
+    FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport1_AddDestroyCallback(IDirect3DRMViewport *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport1_DeleteDestroyCallback(IDirect3DRMViewport *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport1_SetAppData(IDirect3DRMViewport *iface, DWORD data)
+{
+    FIXME("iface %p, data %#x stub!\n", iface, data);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI d3drm_viewport1_GetAppData(IDirect3DRMViewport *iface)
+{
+    FIXME("iface %p.\n", iface);
+
+    return 0;
+}
+
+static HRESULT WINAPI d3drm_viewport1_SetName(IDirect3DRMViewport *iface, const char *name)
+{
+    FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport1_GetName(IDirect3DRMViewport *iface, DWORD *size, char *name)
+{
+    FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport1_GetClassName(IDirect3DRMViewport *iface, DWORD *size, char *name)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport(iface);
+
+    TRACE("iface %p, size %p, name %p.\n", iface, size, name);
+
+    return IDirect3DRMViewport2_GetClassName(&viewport->IDirect3DRMViewport2_iface, size, name);
+}
+
+static HRESULT WINAPI d3drm_viewport1_Init(IDirect3DRMViewport *iface, IDirect3DRMDevice *device,
+        IDirect3DRMFrame *camera, DWORD x, DWORD y, DWORD width, DWORD height)
+{
+    FIXME("iface %p, device %p, camera %p, x %u, y %u, width %u, height %u stub!\n",
+            iface, device, camera, x, y, width, height);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport1_Clear(IDirect3DRMViewport *iface)
+{
+    FIXME("iface %p.\n", iface);
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_viewport1_Render(IDirect3DRMViewport *iface, IDirect3DRMFrame *frame)
+{
+    FIXME("iface %p, frame %p stub!\n", iface, frame);
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_viewport1_SetFront(IDirect3DRMViewport *iface, D3DVALUE front)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport(iface);
+
+    TRACE("iface %p, front %.8e.\n", iface, front);
+
+    return IDirect3DRMViewport2_SetFront(&viewport->IDirect3DRMViewport2_iface, front);
+}
+
+static HRESULT WINAPI d3drm_viewport1_SetBack(IDirect3DRMViewport *iface, D3DVALUE back)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport(iface);
+
+    TRACE("iface %p, back %.8e.\n", iface, back);
+
+    return IDirect3DRMViewport2_SetBack(&viewport->IDirect3DRMViewport2_iface, back);
+}
+
+static HRESULT WINAPI d3drm_viewport1_SetField(IDirect3DRMViewport *iface, D3DVALUE field)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport(iface);
+
+    TRACE("iface %p, field %.8e.\n", iface, field);
+
+    return IDirect3DRMViewport2_SetField(&viewport->IDirect3DRMViewport2_iface, field);
+}
+
+static HRESULT WINAPI d3drm_viewport1_SetUniformScaling(IDirect3DRMViewport *iface, BOOL b)
+{
+    FIXME("iface %p, b %#x stub!\n", iface, b);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport1_SetCamera(IDirect3DRMViewport *iface, IDirect3DRMFrame *camera)
+{
+    FIXME("iface %p, camera %p stub!\n", iface, camera);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport1_SetProjection(IDirect3DRMViewport *iface, D3DRMPROJECTIONTYPE type)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport(iface);
+
+    TRACE("iface %p, type %#x.\n", iface, type);
+
+    return IDirect3DRMViewport2_SetProjection(&viewport->IDirect3DRMViewport2_iface, type);
+}
+
+static HRESULT WINAPI d3drm_viewport1_Transform(IDirect3DRMViewport *iface, D3DRMVECTOR4D *d, D3DVECTOR *s)
+{
+    FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport1_InverseTransform(IDirect3DRMViewport *iface, D3DVECTOR *d, D3DRMVECTOR4D *s)
+{
+    FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport1_Configure(IDirect3DRMViewport *iface,
+        LONG x, LONG y, DWORD width, DWORD height)
+{
+    FIXME("iface %p, x %d, y %d, width %u, height %u stub!\n", iface, x, y, width, height);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport1_ForceUpdate(IDirect3DRMViewport *iface,
+        DWORD x1, DWORD y1, DWORD x2, DWORD y2)
+{
+    FIXME("iface %p, x1 %u, y1 %u, x2 %u, y2 %u stub!\n", iface, x1, y1, x2, y2);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport1_SetPlane(IDirect3DRMViewport *iface,
+        D3DVALUE left, D3DVALUE right, D3DVALUE bottom, D3DVALUE top)
+{
+    FIXME("iface %p, left %.8e, right %.8e, bottom %.8e, top %.8e stub!\n",
+            iface, left, right, bottom, top);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport1_GetCamera(IDirect3DRMViewport *iface, IDirect3DRMFrame **camera)
+{
+    FIXME("iface %p, camera %p stub!\n", iface, camera);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport1_GetDevice(IDirect3DRMViewport *iface, IDirect3DRMDevice **device)
+{
+    FIXME("iface %p, device %p stub!\n", iface, device);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport1_GetPlane(IDirect3DRMViewport *iface,
+        D3DVALUE *left, D3DVALUE *right, D3DVALUE *bottom, D3DVALUE *top)
+{
+    FIXME("iface %p, left %p, right %p, bottom %p, top %p stub!\n",
+            iface, left, right, bottom, top);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport1_Pick(IDirect3DRMViewport *iface,
+        LONG x, LONG y, IDirect3DRMPickedArray **visuals)
+{
+    FIXME("iface %p, x %d, y %d, visuals %p stub!\n", iface, x, y, visuals);
+
+    return E_NOTIMPL;
+}
+
+static BOOL WINAPI d3drm_viewport1_GetUniformScaling(IDirect3DRMViewport *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static LONG WINAPI d3drm_viewport1_GetX(IDirect3DRMViewport *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static LONG WINAPI d3drm_viewport1_GetY(IDirect3DRMViewport *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI d3drm_viewport1_GetWidth(IDirect3DRMViewport *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI d3drm_viewport1_GetHeight(IDirect3DRMViewport *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static D3DVALUE WINAPI d3drm_viewport1_GetField(IDirect3DRMViewport *iface)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return IDirect3DRMViewport2_GetField(&viewport->IDirect3DRMViewport2_iface);
+}
+
+static D3DVALUE WINAPI d3drm_viewport1_GetBack(IDirect3DRMViewport *iface)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return IDirect3DRMViewport2_GetBack(&viewport->IDirect3DRMViewport2_iface);
+}
+
+static D3DVALUE WINAPI d3drm_viewport1_GetFront(IDirect3DRMViewport *iface)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return IDirect3DRMViewport2_GetFront(&viewport->IDirect3DRMViewport2_iface);
+}
+
+static D3DRMPROJECTIONTYPE WINAPI d3drm_viewport1_GetProjection(IDirect3DRMViewport *iface)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return IDirect3DRMViewport2_GetProjection(&viewport->IDirect3DRMViewport2_iface);
+}
+
+static HRESULT WINAPI d3drm_viewport1_GetDirect3DViewport(IDirect3DRMViewport *iface,
+        IDirect3DViewport **viewport)
+{
+    FIXME("iface %p, viewport %p stub!\n", iface, viewport);
+
+    return E_NOTIMPL;
+}
+
+static const struct IDirect3DRMViewportVtbl d3drm_viewport1_vtbl =
+{
+    d3drm_viewport1_QueryInterface,
+    d3drm_viewport1_AddRef,
+    d3drm_viewport1_Release,
+    d3drm_viewport1_Clone,
+    d3drm_viewport1_AddDestroyCallback,
+    d3drm_viewport1_DeleteDestroyCallback,
+    d3drm_viewport1_SetAppData,
+    d3drm_viewport1_GetAppData,
+    d3drm_viewport1_SetName,
+    d3drm_viewport1_GetName,
+    d3drm_viewport1_GetClassName,
+    d3drm_viewport1_Init,
+    d3drm_viewport1_Clear,
+    d3drm_viewport1_Render,
+    d3drm_viewport1_SetFront,
+    d3drm_viewport1_SetBack,
+    d3drm_viewport1_SetField,
+    d3drm_viewport1_SetUniformScaling,
+    d3drm_viewport1_SetCamera,
+    d3drm_viewport1_SetProjection,
+    d3drm_viewport1_Transform,
+    d3drm_viewport1_InverseTransform,
+    d3drm_viewport1_Configure,
+    d3drm_viewport1_ForceUpdate,
+    d3drm_viewport1_SetPlane,
+    d3drm_viewport1_GetCamera,
+    d3drm_viewport1_GetDevice,
+    d3drm_viewport1_GetPlane,
+    d3drm_viewport1_Pick,
+    d3drm_viewport1_GetUniformScaling,
+    d3drm_viewport1_GetX,
+    d3drm_viewport1_GetY,
+    d3drm_viewport1_GetWidth,
+    d3drm_viewport1_GetHeight,
+    d3drm_viewport1_GetField,
+    d3drm_viewport1_GetBack,
+    d3drm_viewport1_GetFront,
+    d3drm_viewport1_GetProjection,
+    d3drm_viewport1_GetDirect3DViewport,
+};
+
+static HRESULT WINAPI d3drm_viewport2_QueryInterface(IDirect3DRMViewport2 *iface, REFIID riid, void **out)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport2(iface);
+
+    TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
+
+    return d3drm_viewport1_QueryInterface(&viewport->IDirect3DRMViewport_iface, riid, out);
+}
+
+static ULONG WINAPI d3drm_viewport2_AddRef(IDirect3DRMViewport2 *iface)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport2(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return d3drm_viewport1_AddRef(&viewport->IDirect3DRMViewport_iface);
+}
+
+static ULONG WINAPI d3drm_viewport2_Release(IDirect3DRMViewport2 *iface)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport2(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return d3drm_viewport1_Release(&viewport->IDirect3DRMViewport_iface);
+}
+
+static HRESULT WINAPI d3drm_viewport2_Clone(IDirect3DRMViewport2 *iface,
+        IUnknown *outer, REFIID iid, void **out)
+{
+    FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport2_AddDestroyCallback(IDirect3DRMViewport2 *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport2_DeleteDestroyCallback(IDirect3DRMViewport2 *iface,
+        D3DRMOBJECTCALLBACK cb, void *ctx)
+{
+    FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport2_SetAppData(IDirect3DRMViewport2 *iface, DWORD data)
+{
+    FIXME("iface %p, data %#x stub!\n", iface, data);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI d3drm_viewport2_GetAppData(IDirect3DRMViewport2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return 0;
+}
+
+static HRESULT WINAPI d3drm_viewport2_SetName(IDirect3DRMViewport2 *iface, const char *name)
+{
+    FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport2_GetName(IDirect3DRMViewport2 *iface, DWORD *size, char *name)
+{
+    FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport2_GetClassName(IDirect3DRMViewport2 *iface, DWORD *size, char *name)
+{
+    TRACE("iface %p, size %p, name %p.\n", iface, size, name);
+
+    if (!size || *size < strlen("Viewport") || !name)
+        return E_INVALIDARG;
+
+    strcpy(name, "Viewport");
+    *size = sizeof("Viewport");
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_viewport2_Init(IDirect3DRMViewport2 *iface, IDirect3DRMDevice3 *device,
+        IDirect3DRMFrame3 *camera, DWORD x, DWORD y, DWORD width, DWORD height)
+{
+    FIXME("iface %p, device %p, camera %p, x %u, y %u, width %u, height %u stub!\n",
+            iface, device, camera, x, y, width, height);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport2_Clear(IDirect3DRMViewport2 *iface, DWORD flags)
+{
+    FIXME("iface %p, flags %#x.\n", iface, flags);
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_viewport2_Render(IDirect3DRMViewport2 *iface, IDirect3DRMFrame3 *frame)
+{
+    FIXME("iface %p, frame %p stub!\n", iface, frame);
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_viewport2_SetFront(IDirect3DRMViewport2 *iface, D3DVALUE front)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport2(iface);
+
+    TRACE("iface %p, front %.8e.\n", iface, front);
+
+    viewport->front = front;
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_viewport2_SetBack(IDirect3DRMViewport2 *iface, D3DVALUE back)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport2(iface);
+
+    TRACE("iface %p, back %.8e.\n", iface, back);
+
+    viewport->back = back;
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_viewport2_SetField(IDirect3DRMViewport2 *iface, D3DVALUE field)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport2(iface);
+
+    TRACE("iface %p, field %.8e.\n", iface, field);
+
+    viewport->field = field;
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_viewport2_SetUniformScaling(IDirect3DRMViewport2 *iface, BOOL b)
+{
+    FIXME("iface %p, b %#x stub!\n", iface, b);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport2_SetCamera(IDirect3DRMViewport2 *iface, IDirect3DRMFrame3 *camera)
+{
+    FIXME("iface %p, camera %p stub!\n", iface, camera);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport2_SetProjection(IDirect3DRMViewport2 *iface, D3DRMPROJECTIONTYPE type)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport2(iface);
+
+    TRACE("iface %p, type %#x.\n", iface, type);
+
+    viewport->projection = type;
+
+    return D3DRM_OK;
+}
+
+static HRESULT WINAPI d3drm_viewport2_Transform(IDirect3DRMViewport2 *iface, D3DRMVECTOR4D *d, D3DVECTOR *s)
+{
+    FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport2_InverseTransform(IDirect3DRMViewport2 *iface, D3DVECTOR *d, D3DRMVECTOR4D *s)
+{
+    FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport2_Configure(IDirect3DRMViewport2 *iface,
+        LONG x, LONG y, DWORD width, DWORD height)
+{
+    FIXME("iface %p, x %d, y %d, width %u, height %u stub!\n", iface, x, y, width, height);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport2_ForceUpdate(IDirect3DRMViewport2* iface,
+        DWORD x1, DWORD y1, DWORD x2, DWORD y2)
+{
+    FIXME("iface %p, x1 %u, y1 %u, x2 %u, y2 %u stub!\n", iface, x1, y1, x2, y2);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport2_SetPlane(IDirect3DRMViewport2 *iface,
+        D3DVALUE left, D3DVALUE right, D3DVALUE bottom, D3DVALUE top)
+{
+    FIXME("iface %p, left %.8e, right %.8e, bottom %.8e, top %.8e stub!\n",
+            iface, left, right, bottom, top);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport2_GetCamera(IDirect3DRMViewport2 *iface, IDirect3DRMFrame3 **camera)
+{
+    FIXME("iface %p, camera %p stub!\n", iface, camera);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport2_GetDevice(IDirect3DRMViewport2 *iface, IDirect3DRMDevice3 **device)
+{
+    FIXME("iface %p, device %p stub!\n", iface, device);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport2_GetPlane(IDirect3DRMViewport2 *iface,
+        D3DVALUE *left, D3DVALUE *right, D3DVALUE *bottom, D3DVALUE *top)
+{
+    FIXME("iface %p, left %p, right %p, bottom %p, top %p stub!\n",
+            iface, left, right, bottom, top);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport2_Pick(IDirect3DRMViewport2 *iface,
+        LONG x, LONG y, IDirect3DRMPickedArray **visuals)
+{
+    FIXME("iface %p, x %d, y %d, visuals %p stub!\n", iface, x, y, visuals);
+
+    return E_NOTIMPL;
+}
+
+static BOOL WINAPI d3drm_viewport2_GetUniformScaling(IDirect3DRMViewport2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static LONG WINAPI d3drm_viewport2_GetX(IDirect3DRMViewport2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static LONG WINAPI d3drm_viewport2_GetY(IDirect3DRMViewport2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI d3drm_viewport2_GetWidth(IDirect3DRMViewport2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static DWORD WINAPI d3drm_viewport2_GetHeight(IDirect3DRMViewport2 *iface)
+{
+    FIXME("iface %p stub!\n", iface);
+
+    return E_NOTIMPL;
+}
+
+static D3DVALUE WINAPI d3drm_viewport2_GetField(IDirect3DRMViewport2 *iface)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport2(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return viewport->field;
+}
+
+static D3DVALUE WINAPI d3drm_viewport2_GetBack(IDirect3DRMViewport2 *iface)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport2(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return viewport->back;
+}
+
+static D3DVALUE WINAPI d3drm_viewport2_GetFront(IDirect3DRMViewport2 *iface)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport2(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return viewport->front;
+}
+
+static D3DRMPROJECTIONTYPE WINAPI d3drm_viewport2_GetProjection(IDirect3DRMViewport2 *iface)
+{
+    struct d3drm_viewport *viewport = impl_from_IDirect3DRMViewport2(iface);
+
+    TRACE("iface %p.\n", iface);
+
+    return viewport->projection;
+}
+
+static HRESULT WINAPI d3drm_viewport2_GetDirect3DViewport(IDirect3DRMViewport2 *iface,
+        IDirect3DViewport **viewport)
+{
+    FIXME("iface %p, viewport %p stub!\n", iface, viewport);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport2_TransformVectors(IDirect3DRMViewport2 *iface,
+        DWORD vector_count, D3DRMVECTOR4D *dst, D3DVECTOR *src)
+{
+    FIXME("iface %p, vector_count %u, dst %p, src %p stub!\n", iface, vector_count, dst, src);
+
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3drm_viewport2_InverseTransformVectors(IDirect3DRMViewport2 *iface,
+        DWORD vector_count, D3DVECTOR *dst, D3DRMVECTOR4D *src)
+{
+    FIXME("iface %p, vector_count %u, dst %p, src %p stub!\n", iface, vector_count, dst, src);
+
+    return E_NOTIMPL;
+}
+
+static const struct IDirect3DRMViewport2Vtbl d3drm_viewport2_vtbl =
+{
+    d3drm_viewport2_QueryInterface,
+    d3drm_viewport2_AddRef,
+    d3drm_viewport2_Release,
+    d3drm_viewport2_Clone,
+    d3drm_viewport2_AddDestroyCallback,
+    d3drm_viewport2_DeleteDestroyCallback,
+    d3drm_viewport2_SetAppData,
+    d3drm_viewport2_GetAppData,
+    d3drm_viewport2_SetName,
+    d3drm_viewport2_GetName,
+    d3drm_viewport2_GetClassName,
+    d3drm_viewport2_Init,
+    d3drm_viewport2_Clear,
+    d3drm_viewport2_Render,
+    d3drm_viewport2_SetFront,
+    d3drm_viewport2_SetBack,
+    d3drm_viewport2_SetField,
+    d3drm_viewport2_SetUniformScaling,
+    d3drm_viewport2_SetCamera,
+    d3drm_viewport2_SetProjection,
+    d3drm_viewport2_Transform,
+    d3drm_viewport2_InverseTransform,
+    d3drm_viewport2_Configure,
+    d3drm_viewport2_ForceUpdate,
+    d3drm_viewport2_SetPlane,
+    d3drm_viewport2_GetCamera,
+    d3drm_viewport2_GetDevice,
+    d3drm_viewport2_GetPlane,
+    d3drm_viewport2_Pick,
+    d3drm_viewport2_GetUniformScaling,
+    d3drm_viewport2_GetX,
+    d3drm_viewport2_GetY,
+    d3drm_viewport2_GetWidth,
+    d3drm_viewport2_GetHeight,
+    d3drm_viewport2_GetField,
+    d3drm_viewport2_GetBack,
+    d3drm_viewport2_GetFront,
+    d3drm_viewport2_GetProjection,
+    d3drm_viewport2_GetDirect3DViewport,
+    d3drm_viewport2_TransformVectors,
+    d3drm_viewport2_InverseTransformVectors,
+};
+
+HRESULT Direct3DRMViewport_create(REFIID riid, IUnknown **out)
+{
+    struct d3drm_viewport *object;
+
+    TRACE("riid %s, out %p.\n", debugstr_guid(riid), out);
+
+    if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+        return E_OUTOFMEMORY;
+
+    object->IDirect3DRMViewport_iface.lpVtbl = &d3drm_viewport1_vtbl;
+    object->IDirect3DRMViewport2_iface.lpVtbl = &d3drm_viewport2_vtbl;
+    object->ref = 1;
+
+    if (IsEqualGUID(riid, &IID_IDirect3DRMViewport2))
+        *out = (IUnknown *)&object->IDirect3DRMViewport2_iface;
+    else
+        *out = (IUnknown *)&object->IDirect3DRMViewport_iface;
+
+    return S_OK;
+}

dll/directx/wine/dsound/CMakeLists.txt

@@ -30,5 +30,5 @@ if(CMAKE_C_COMPILER_ID STREQUAL "Clang")
     target_link_libraries(dsound mingwex)
 endif()
 
-add_importlibs(dsound winmm ole32 advapi32 user32 msvcrt kernel32 ntdll)
+add_importlibs(dsound winmm advapi32 msvcrt kernel32 ntdll)
 add_cd_file(TARGET dsound DESTINATION reactos/system32 FOR all)

dll/directx/wine/dsound/dsound_convert.c

@@ -44,214 +44,488 @@
 #define le32(x) (x)
 #endif
 
-/* This is an inlined version of lrintf. */
-#if defined(_MSC_VER)
-#if defined(_M_AMD64)
-#include <xmmintrin.h>
-#endif
-
-FORCEINLINE
-int
-lrintf(float f)
+static inline void src_advance(const void **src, UINT stride, INT *count, UINT *freqAcc, UINT adj)
 {
-#if defined(_M_IX86)
-    int result;
-    __asm
+    *freqAcc += adj;
+    if (*freqAcc >= (1 << DSOUND_FREQSHIFT))
     {
-        fld f;
-        fistp result;
+        ULONG adv = (*freqAcc >> DSOUND_FREQSHIFT);
+        *freqAcc &= (1 << DSOUND_FREQSHIFT) - 1;
+        *(const char **)src += adv * stride;
+        *count -= adv;
     }
-    return result;
-#elif defined(_M_AMD64)
-    return _mm_cvtss_si32(_mm_load_ss(&f));
-#endif
 }
-#endif
 
-static float get8(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel)
+static void convert_8_to_8 (const void *src, void *dst, UINT src_stride,
+        UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 {
-    const BYTE* buf = dsb->buffer->memory;
-    buf += pos + channel;
-    return (buf[0] - 0x80) / (float)0x80;
+    while (count > 0)
+    {
+        *(BYTE *)dst = *(const BYTE *)src;
+
+        dst = (char *)dst + dst_stride;
+        src_advance(&src, src_stride, &count, &freqAcc, adj);
+    }
 }
 
-static float get16(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel)
+static void convert_8_to_16 (const void *src, void *dst, UINT src_stride,
+        UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 {
-    const BYTE* buf = dsb->buffer->memory;
-    const SHORT *sbuf = (const SHORT*)(buf + pos + 2 * channel);
-    SHORT sample = (SHORT)le16(*sbuf);
-    return sample / (float)0x8000;
+    while (count > 0)
+    {
+        WORD dest = *(const BYTE *)src, *dest16 = dst;
+        *dest16 = le16(dest * 257 - 32768);
+
+        dst = (char *)dst + dst_stride;
+        src_advance(&src, src_stride, &count, &freqAcc, adj);
+    }
 }
 
-static float get24(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel)
+static void convert_8_to_24 (const void *src, void *dst, UINT src_stride,
+        UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 {
-    LONG sample;
-    const BYTE* buf = dsb->buffer->memory;
-    buf += pos + 3 * channel;
-    /* The next expression deliberately has an overflow for buf[2] >= 0x80,
-       this is how negative values are made.
-     */
-    sample = (buf[0] << 8) | (buf[1] << 16) | (buf[2] << 24);
-    return sample / (float)0x80000000U;
+    while (count > 0)
+    {
+        BYTE dest = *(const BYTE *)src;
+        BYTE *dest24 = dst;
+        dest24[0] = dest;
+        dest24[1] = dest;
+        dest24[2] = dest - 0x80;
+
+        dst = (char *)dst + dst_stride;
+        src_advance(&src, src_stride, &count, &freqAcc, adj);
+    }
 }
 
-static float get32(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel)
+static void convert_8_to_32 (const void *src, void *dst, UINT src_stride,
+        UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 {
-    const BYTE* buf = dsb->buffer->memory;
-    const LONG *sbuf = (const LONG*)(buf + pos + 4 * channel);
-    LONG sample = le32(*sbuf);
-    return sample / (float)0x80000000U;
+    while (count > 0)
+    {
+        DWORD dest = *(const BYTE *)src, *dest32 = dst;
+        *dest32 = le32(dest * 16843009 - 2147483648U);
+
+        dst = (char *)dst + dst_stride;
+        src_advance(&src, src_stride, &count, &freqAcc, adj);
+    }
 }
 
-static float getieee32(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel)
+static void convert_16_to_8 (const void *src, void *dst, UINT src_stride,
+        UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 {
-    const BYTE* buf = dsb->buffer->memory;
-    const float *sbuf = (const float*)(buf + pos + 4 * channel);
-    /* The value will be clipped later, when put into some non-float buffer */
-    return *sbuf;
+    while (count > 0)
+    {
+        BYTE *dst8 = dst;
+        *dst8 = (le16(*(const WORD *)src)) / 256;
+        *dst8 -= 0x80;
+
+        dst = (char *)dst + dst_stride;
+        src_advance(&src, src_stride, &count, &freqAcc, adj);
+    }
 }
 
-const bitsgetfunc getbpp[5] = {get8, get16, get24, get32, getieee32};
-
-float get_mono(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel)
+static void convert_16_to_16 (const void *src, void *dst, UINT src_stride,
+        UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 {
-    DWORD channels = dsb->pwfx->nChannels;
-    DWORD c;
-    float val = 0;
-    /* XXX: does Windows include LFE into the mix? */
-    for (c = 0; c < channels; c++)
-        val += dsb->get_aux(dsb, pos, c);
-    val /= channels;
-    return val;
+    while (count > 0)
+    {
+        *(WORD *)dst = *(const WORD *)src;
+
+        dst = (char *)dst + dst_stride;
+        src_advance(&src, src_stride, &count, &freqAcc, adj);
+    }
 }
 
-static inline unsigned char f_to_8(float value)
+static void convert_16_to_24 (const void *src, void *dst, UINT src_stride,
+        UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 {
-    if(value <= -1.f)
-        return 0;
-    if(value >= 1.f * 0x7f / 0x80)
-        return 0xFF;
-    return lrintf((value + 1.f) * 0x80);
+    while (count > 0)
+    {
+        WORD dest = le16(*(const WORD *)src);
+        BYTE *dest24 = dst;
+
+        dest24[0] = dest / 256;
+        dest24[1] = dest;
+        dest24[2] = dest / 256;
+
+        dst = (char *)dst + dst_stride;
+        src_advance(&src, src_stride, &count, &freqAcc, adj);
+    }
 }
 
-static inline SHORT f_to_16(float value)
+static void convert_16_to_32 (const void *src, void *dst, UINT src_stride,
+        UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 {
-    if(value <= -1.f)
-        return 0x8000;
-    if(value >= 1.f * 0x7FFF / 0x8000)
-        return 0x7FFF;
-    return le16(lrintf(value * 0x8000));
+    while (count > 0)
+    {
+        DWORD dest = *(const WORD *)src, *dest32 = dst;
+        *dest32 = dest * 65537;
+
+        dst = (char *)dst + dst_stride;
+        src_advance(&src, src_stride, &count, &freqAcc, adj);
+    }
 }
 
-static LONG f_to_24(float value)
+static void convert_24_to_8 (const void *src, void *dst, UINT src_stride,
+        UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 {
-    if(value <= -1.f)
-        return 0x80000000;
-    if(value >= 1.f * 0x7FFFFF / 0x800000)
-        return 0x7FFFFF00;
-    return lrintf(value * 0x80000000U);
+    while (count > 0)
+    {
+        BYTE *dst8 = dst;
+        *dst8 = ((const BYTE *)src)[2];
+
+        dst = (char *)dst + dst_stride;
+        src_advance(&src, src_stride, &count, &freqAcc, adj);
+    }
 }
 
-static inline LONG f_to_32(float value)
+static void convert_24_to_16 (const void *src, void *dst, UINT src_stride,
+        UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 {
-    if(value <= -1.f)
-        return 0x80000000;
-    if(value >= 1.f * 0x7FFFFFFF / 0x80000000U)  /* this rounds to 1.f */
-        return 0x7FFFFFFF;
-    return le32(lrintf(value * 0x80000000U));
+    while (count > 0)
+    {
+        WORD *dest16 = dst;
+        const BYTE *source = src;
+        *dest16 = le16(source[2] * 256 + source[1]);
+
+        dst = (char *)dst + dst_stride;
+        src_advance(&src, src_stride, &count, &freqAcc, adj);
+    }
 }
 
-void putieee32(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel, float value)
+static void convert_24_to_24 (const void *src, void *dst, UINT src_stride,
+        UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 {
-    BYTE *buf = (BYTE *)dsb->device->tmp_buffer;
-    float *fbuf = (float*)(buf + pos + sizeof(float) * channel);
-    *fbuf = value;
+    while (count > 0)
+    {
+        BYTE *dest24 = dst;
+        const BYTE *src24 = src;
+
+        dest24[0] = src24[0];
+        dest24[1] = src24[1];
+        dest24[2] = src24[2];
+
+        dst = (char *)dst + dst_stride;
+        src_advance(&src, src_stride, &count, &freqAcc, adj);
+    }
 }
 
-void put_mono2stereo(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel, float value)
+static void convert_24_to_32 (const void *src, void *dst, UINT src_stride,
+        UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 {
-    dsb->put_aux(dsb, pos, 0, value);
-    dsb->put_aux(dsb, pos, 1, value);
+    while (count > 0)
+    {
+        DWORD *dest32 = dst;
+        const BYTE *source = src;
+        *dest32 = le32(source[2] * 16777217 + source[1] * 65536 + source[0] * 256);
+
+        dst = (char *)dst + dst_stride;
+        src_advance(&src, src_stride, &count, &freqAcc, adj);
+    }
 }
 
-void mixieee32(float *src, float *dst, unsigned samples)
+static void convert_32_to_8 (const void *src, void *dst, UINT src_stride,
+        UINT dst_stride, INT count, UINT freqAcc, UINT adj)
 {
-    TRACE("%p - %p %d\n", src, dst, samples);
-    while (samples--)
-        *(dst++) += *(src++);
+    while (count > 0)
+    {
+        BYTE *dst8 = dst;
+        *dst8 = (le32(*(const DWORD *)src) / 16777216);
+        *dst8 -= 0x80;
+
+        dst = (char *)dst + dst_stride;
+        src_advance(&src, src_stride, &count, &freqAcc, adj);
+    }
 }
 
-static void norm8(float *src, unsigned char *dst, unsigned len)
+static void convert_32_to_16 (const void *src, void *dst, UINT src_stride,
+        UINT dst_stride, INT count, UINT freqAcc, UINT adj)
+{
+    while (count > 0)
+    {
+        WORD *dest16 = dst;
+        *dest16 = le16(le32(*(const DWORD *)src) / 65536);
+
+        dst = (char *)dst + dst_stride;
+        src_advance(&src, src_stride, &count, &freqAcc, adj);
+    }
+}
+
+static void convert_32_to_24 (const void *src, void *dst, UINT src_stride,
+        UINT dst_stride, INT count, UINT freqAcc, UINT adj)
+{
+    while (count > 0)
+    {
+        DWORD dest = le32(*(const DWORD *)src);
+        BYTE *dest24 = dst;
+
+        dest24[0] = dest / 256;
+        dest24[1] = dest / 65536;
+        dest24[2] = dest / 16777216;
+
+        dst = (char *)dst + dst_stride;
+        src_advance(&src, src_stride, &count, &freqAcc, adj);
+    }
+}
+
+static void convert_32_to_32 (const void *src, void *dst, UINT src_stride,
+        UINT dst_stride, INT count, UINT freqAcc, UINT adj)
+{
+    while (count > 0)
+    {
+        DWORD *dest = dst;
+        *dest = *(const DWORD *)src;
+
+        dst = (char *)dst + dst_stride;
+        src_advance(&src, src_stride, &count, &freqAcc, adj);
+    }
+}
+
+static void convert_ieee_32_to_8 (const void *src, void *dst, UINT src_stride,
+        UINT dst_stride, INT count, UINT freqAcc, UINT adj)
+{
+    while (count > 0)
+    {
+        DWORD src_le = le32(*(DWORD *) src);
+        float v = *((float *) &src_le);
+        INT8 d = 0;
+
+        if (v < -1.0f)
+            d = -128;
+        else if (v >  1.0f)
+            d = 127;
+        else
+            d = v * 127.5f - 0.5f;
+
+        *(BYTE *) dst = d ^ 0x80;
+
+        dst = (char *)dst + dst_stride;
+        src_advance(&src, src_stride, &count, &freqAcc, adj);
+    }
+}
+
+static void convert_ieee_32_to_16 (const void *src, void *dst, UINT src_stride,
+        UINT dst_stride, INT count, UINT freqAcc, UINT adj)
+{
+    while (count > 0)
+    {
+        DWORD src_le = le32(*(DWORD *) src);
+        float v = *((float *) &src_le);
+
+        INT16 *d = (INT16 *) dst;
+
+        if (v < -1.0f)
+            *d = -32768;
+        else if (v >  1.0f)
+            *d = 32767;
+        else
+            *d = v * 32767.5f - 0.5f;
+
+        *d = le16(*d);
+
+        dst = (char *)dst + dst_stride;
+        src_advance(&src, src_stride, &count, &freqAcc, adj);
+    }
+}
+
+static void convert_ieee_32_to_24 (const void *src, void *dst, UINT src_stride,
+        UINT dst_stride, INT count, UINT freqAcc, UINT adj)
+{
+    while (count > 0)
+    {
+        DWORD src_le = le32(*(DWORD *) src);
+        float v = *((float *) &src_le);
+        BYTE *dest24 = dst;
+
+        if (v < -1.0f)
+        {
+            dest24[0] = 0;
+            dest24[1] = 0;
+            dest24[2] = 0x80;
+        }
+        else if (v > 1.0f)
+        {
+            dest24[0] = 0xff;
+            dest24[1] = 0xff;
+            dest24[2] = 0x7f;
+        }
+        else if (v < 0.0f)
+        {
+            dest24[0] = v * 8388608.0f;
+            dest24[1] = v * 32768.0f;
+            dest24[2] = v * 128.0f;
+        }
+        else if (v >= 0.0f)
+        {
+            dest24[0] = v * 8388608.0f;
+            dest24[1] = v * 32768.0f;
+            dest24[2] = v * 127.0f;
+        }
+
+        dst = (char *)dst + dst_stride;
+        src_advance(&src, src_stride, &count, &freqAcc, adj);
+    }
+}
+
+static void convert_ieee_32_to_32 (const void *src, void *dst, UINT src_stride,
+        UINT dst_stride, INT count, UINT freqAcc, UINT adj)
+{
+    while (count > 0)
+    {
+        DWORD src_le = le32(*(DWORD *) src);
+        float v = *((float *) &src_le);
+        INT32 *d = (INT32 *) dst;
+
+        if (v < -1.0f)
+            *d = -2147483647 - 1; /* silence warning */
+        else if (v >  1.0f)
+            *d = 2147483647;
+        else
+            *d = v * 2147483647.5f - 0.5f;
+
+        *d = le32(*d);
+
+        dst = (char *)dst + dst_stride;
+        src_advance(&src, src_stride, &count, &freqAcc, adj);
+    }
+}
+
+const bitsconvertfunc convertbpp[5][4] = {
+    { convert_8_to_8, convert_8_to_16, convert_8_to_24, convert_8_to_32 },
+    { convert_16_to_8, convert_16_to_16, convert_16_to_24, convert_16_to_32 },
+    { convert_24_to_8, convert_24_to_16, convert_24_to_24, convert_24_to_32 },
+    { convert_32_to_8, convert_32_to_16, convert_32_to_24, convert_32_to_32 },
+    { convert_ieee_32_to_8, convert_ieee_32_to_16, convert_ieee_32_to_24, convert_ieee_32_to_32 },
+};
+
+static void mix8(signed char *src, INT *dst, unsigned len)
 {
     TRACE("%p - %p %d\n", src, dst, len);
     while (len--)
-    {
-        *dst = f_to_8(*src);
-        ++dst;
-        ++src;
-    }
+        /* 8-bit WAV is unsigned, it's here converted to signed, normalize function will convert it back again */
+        *(dst++) += (signed char)((BYTE)*(src++) - (BYTE)0x80);
 }
 
-static void norm16(float *src, SHORT *dst, unsigned len)
+static void mix16(SHORT *src, INT *dst, unsigned len)
 {
     TRACE("%p - %p %d\n", src, dst, len);
     len /= 2;
     while (len--)
     {
-        *dst = f_to_16(*src);
-        ++dst;
-        ++src;
+        *dst += le16(*src);
+        ++dst; ++src;
     }
 }
 
-static void norm24(float *src, BYTE *dst, unsigned len)
+static void mix24(BYTE *src, INT *dst, unsigned len)
 {
     TRACE("%p - %p %d\n", src, dst, len);
     len /= 3;
     while (len--)
     {
-        LONG t = f_to_24(*src);
-        dst[0] = (t >> 8) & 0xFF;
-        dst[1] = (t >> 16) & 0xFF;
-        dst[2] = t >> 24;
-        dst += 3;
+        DWORD field;
+        field = ((DWORD)src[2] << 16) + ((DWORD)src[1] << 8) + (DWORD)src[0];
+        if (src[2] & 0x80)
+            field |= 0xFF000000U;
+        *(dst++) += field;
         ++src;
     }
 }
 
-static void norm32(float *src, INT *dst, unsigned len)
+static void mix32(INT *src, LONGLONG *dst, unsigned len)
 {
     TRACE("%p - %p %d\n", src, dst, len);
     len /= 4;
+    while (len--)
+        *(dst++) += le32(*(src++));
+}
+
+const mixfunc mixfunctions[4] = {
+    (mixfunc)mix8,
+    (mixfunc)mix16,
+    (mixfunc)mix24,
+    (mixfunc)mix32
+};
+
+static void norm8(INT *src, signed char *dst, unsigned len)
+{
+    TRACE("%p - %p %d\n", src, dst, len);
     while (len--)
     {
-        *dst = f_to_32(*src);
+        *dst = (*src) + 0x80;
+        if (*src < -0x80)
+            *dst = 0;
+        else if (*src > 0x7f)
+            *dst = 0xff;
         ++dst;
         ++src;
     }
 }
 
-static void normieee32(float *src, float *dst, unsigned len)
+static void norm16(INT *src, SHORT *dst, unsigned len)
 {
     TRACE("%p - %p %d\n", src, dst, len);
-    len /= 4;
+    len /= 2;
     while (len--)
     {
-        if(*src > 1)
-            *dst = 1;
-        else if(*src < -1)
-            *dst = -1;
+        *dst = le16(*src);
+        if (*src <= -0x8000)
+            *dst = le16(0x8000);
+        else if (*src > 0x7fff)
+            *dst = le16(0x7fff);
+        ++dst;
+        ++src;
+    }
+}
+
+static void norm24(INT *src, BYTE *dst, unsigned len)
+{
+    TRACE("%p - %p %d\n", src, dst, len);
+    len /= 3;
+    while (len--)
+    {
+        if (*src <= -0x800000)
+        {
+            dst[0] = 0;
+            dst[1] = 0;
+            dst[2] = 0x80;
+        }
+        else if (*src > 0x7fffff)
+        {
+            dst[0] = 0xff;
+            dst[1] = 0xff;
+            dst[2] = 0x7f;
+        }
         else
-            *dst = *src;
+        {
+            dst[0] = *src;
+            dst[1] = *src >> 8;
+            dst[2] = *src >> 16;
+        }
         ++dst;
         ++src;
     }
 }
 
-const normfunc normfunctions[5] = {
+static void norm32(LONGLONG *src, INT *dst, unsigned len)
+{
+    TRACE("%p - %p %d\n", src, dst, len);
+    len /= 4;
+    while (len--)
+    {
+        *dst = le32(*src);
+        if (*src <= -(LONGLONG)0x80000000)
+            *dst = le32(0x80000000);
+        else if (*src > 0x7fffffff)
+            *dst = le32(0x7fffffff);
+        ++dst;
+        ++src;
+    }
+}
+
+const normfunc normfunctions[4] = {
     (normfunc)norm8,
     (normfunc)norm16,
     (normfunc)norm24,
     (normfunc)norm32,
-    (normfunc)normieee32
 };

dll/directx/wine/dsound/dsound_main.c

@@ -37,34 +37,48 @@
 #include <winreg.h>
 #include <rpcproxy.h>
 
-struct list DSOUND_renderers = LIST_INIT(DSOUND_renderers);
-CRITICAL_SECTION DSOUND_renderers_lock;
-static CRITICAL_SECTION_DEBUG DSOUND_renderers_lock_debug =
-{
-    0, 0, &DSOUND_renderers_lock,
-    { &DSOUND_renderers_lock_debug.ProcessLocksList, &DSOUND_renderers_lock_debug.ProcessLocksList },
-      0, 0, { (DWORD_PTR)(__FILE__ ": DSOUND_renderers_lock") }
-};
-CRITICAL_SECTION DSOUND_renderers_lock = { &DSOUND_renderers_lock_debug, -1, 0, 0, 0, 0 };
-
-struct list DSOUND_capturers = LIST_INIT(DSOUND_capturers);
-CRITICAL_SECTION DSOUND_capturers_lock;
-static CRITICAL_SECTION_DEBUG DSOUND_capturers_lock_debug =
-{
-    0, 0, &DSOUND_capturers_lock,
-    { &DSOUND_capturers_lock_debug.ProcessLocksList, &DSOUND_capturers_lock_debug.ProcessLocksList },
-      0, 0, { (DWORD_PTR)(__FILE__ ": DSOUND_capturers_lock") }
-};
-CRITICAL_SECTION DSOUND_capturers_lock = { &DSOUND_capturers_lock_debug, -1, 0, 0, 0, 0 };
-
+DirectSoundDevice*	DSOUND_renderer[MAXWAVEDRIVERS];
 GUID                    DSOUND_renderer_guids[MAXWAVEDRIVERS];
 GUID                    DSOUND_capture_guids[MAXWAVEDRIVERS];
 
-WCHAR wine_vxd_drv[] = { 'w','i','n','e','m','m','.','v','x','d', 0 };
+HRESULT mmErr(UINT err)
+{
+	switch(err) {
+	case MMSYSERR_NOERROR:
+		return DS_OK;
+	case MMSYSERR_ALLOCATED:
+		return DSERR_ALLOCATED;
+	case MMSYSERR_ERROR:
+	case MMSYSERR_INVALHANDLE:
+	case WAVERR_STILLPLAYING:
+		return DSERR_GENERIC; /* FIXME */
+	case MMSYSERR_NODRIVER:
+		return DSERR_NODRIVER;
+	case MMSYSERR_NOMEM:
+		return DSERR_OUTOFMEMORY;
+	case MMSYSERR_INVALPARAM:
+	case WAVERR_BADFORMAT:
+	case WAVERR_UNPREPARED:
+		return DSERR_INVALIDPARAM;
+	case MMSYSERR_NOTSUPPORTED:
+		return DSERR_UNSUPPORTED;
+	default:
+		FIXME("Unknown MMSYS error %d\n",err);
+		return DSERR_GENERIC;
+	}
+}
 
 /* All default settings, you most likely don't want to touch these, see wiki on UsefulRegistryKeys */
+int ds_emuldriver = 0;
 int ds_hel_buflen = 32768 * 2;
 int ds_snd_queue_max = 10;
+int ds_snd_queue_min = 6;
+int ds_snd_shadow_maxsize = 2;
+int ds_hw_accel = DS_HW_ACCEL_FULL;
+int ds_default_sample_rate = 44100;
+int ds_default_bits_per_sample = 16;
+static int ds_default_playback;
+static int ds_default_capture;
 static HINSTANCE instance;
 
 /*
@@ -114,18 +128,62 @@ void setup_dsound_options(void)
 
     /* get options */
 
+    if (!get_config_key( hkey, appkey, "EmulDriver", buffer, MAX_PATH ))
+        ds_emuldriver = strcmp(buffer, "N");
+
     if (!get_config_key( hkey, appkey, "HelBuflen", buffer, MAX_PATH ))
         ds_hel_buflen = atoi(buffer);
 
     if (!get_config_key( hkey, appkey, "SndQueueMax", buffer, MAX_PATH ))
         ds_snd_queue_max = atoi(buffer);
 
+    if (!get_config_key( hkey, appkey, "SndQueueMin", buffer, MAX_PATH ))
+        ds_snd_queue_min = atoi(buffer);
+
+    if (!get_config_key( hkey, appkey, "HardwareAcceleration", buffer, MAX_PATH )) {
+	if (strcmp(buffer, "Full") == 0)
+	    ds_hw_accel = DS_HW_ACCEL_FULL;
+	else if (strcmp(buffer, "Standard") == 0)
+	    ds_hw_accel = DS_HW_ACCEL_STANDARD;
+	else if (strcmp(buffer, "Basic") == 0)
+	    ds_hw_accel = DS_HW_ACCEL_BASIC;
+	else if (strcmp(buffer, "Emulation") == 0)
+	    ds_hw_accel = DS_HW_ACCEL_EMULATION;
+    }
+
+    if (!get_config_key( hkey, appkey, "DefaultPlayback", buffer, MAX_PATH ))
+        ds_default_playback = atoi(buffer);
+
+    if (!get_config_key( hkey, appkey, "MaxShadowSize", buffer, MAX_PATH ))
+        ds_snd_shadow_maxsize = atoi(buffer);
+
+    if (!get_config_key( hkey, appkey, "DefaultCapture", buffer, MAX_PATH ))
+        ds_default_capture = atoi(buffer);
+
+    if (!get_config_key( hkey, appkey, "DefaultSampleRate", buffer, MAX_PATH ))
+        ds_default_sample_rate = atoi(buffer);
+
+    if (!get_config_key( hkey, appkey, "DefaultBitsPerSample", buffer, MAX_PATH ))
+        ds_default_bits_per_sample = atoi(buffer);
 
     if (appkey) RegCloseKey( appkey );
     if (hkey) RegCloseKey( hkey );
 
+    TRACE("ds_emuldriver = %d\n", ds_emuldriver);
     TRACE("ds_hel_buflen = %d\n", ds_hel_buflen);
     TRACE("ds_snd_queue_max = %d\n", ds_snd_queue_max);
+    TRACE("ds_snd_queue_min = %d\n", ds_snd_queue_min);
+    TRACE("ds_hw_accel = %s\n",
+        ds_hw_accel==DS_HW_ACCEL_FULL ? "Full" :
+        ds_hw_accel==DS_HW_ACCEL_STANDARD ? "Standard" :
+        ds_hw_accel==DS_HW_ACCEL_BASIC ? "Basic" :
+        ds_hw_accel==DS_HW_ACCEL_EMULATION ? "Emulation" :
+        "Unknown");
+    TRACE("ds_default_playback = %d\n", ds_default_playback);
+    TRACE("ds_default_capture = %d\n", ds_default_playback);
+    TRACE("ds_default_sample_rate = %d\n", ds_default_sample_rate);
+    TRACE("ds_default_bits_per_sample = %d\n", ds_default_bits_per_sample);
+    TRACE("ds_snd_shadow_maxsize = %d\n", ds_snd_shadow_maxsize);
 }
 
 static const char * get_device_id(LPCGUID pGuid)
@@ -141,64 +199,6 @@ static const char * get_device_id(LPCGUID pGuid)
     return debugstr_guid(pGuid);
 }
 
-static HRESULT get_mmdevenum(IMMDeviceEnumerator **devenum)
-{
-    HRESULT hr, init_hr;
-
-    init_hr = CoInitialize(NULL);
-
-    hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL,
-            CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, (void**)devenum);
-    if(FAILED(hr)){
-        if(SUCCEEDED(init_hr))
-            CoUninitialize();
-        *devenum = NULL;
-        ERR("CoCreateInstance failed: %08x\n", hr);
-        return hr;
-    }
-
-    return init_hr;
-}
-
-static void release_mmdevenum(IMMDeviceEnumerator *devenum, HRESULT init_hr)
-{
-    IMMDeviceEnumerator_Release(devenum);
-    if(SUCCEEDED(init_hr))
-        CoUninitialize();
-}
-
-static HRESULT get_mmdevice_guid(IMMDevice *device, IPropertyStore *ps,
-        GUID *guid)
-{
-    PROPVARIANT pv;
-    HRESULT hr;
-
-    if(!ps){
-        hr = IMMDevice_OpenPropertyStore(device, STGM_READ, &ps);
-        if(FAILED(hr)){
-            WARN("OpenPropertyStore failed: %08x\n", hr);
-            return hr;
-        }
-    }else
-        IPropertyStore_AddRef(ps);
-
-    PropVariantInit(&pv);
-
-    hr = IPropertyStore_GetValue(ps, &PKEY_AudioEndpoint_GUID, &pv);
-    if(FAILED(hr)){
-        IPropertyStore_Release(ps);
-        WARN("GetValue(GUID) failed: %08x\n", hr);
-        return hr;
-    }
-
-    CLSIDFromString(pv.u.pwszVal, guid);
-
-    PropVariantClear(&pv);
-    IPropertyStore_Release(ps);
-
-    return S_OK;
-}
-
 /***************************************************************************
  * GetDeviceID	[DSOUND.9]
  *
@@ -221,56 +221,34 @@ static HRESULT get_mmdevice_guid(IMMDevice *device, IPropertyStore *ps,
  */
 HRESULT WINAPI GetDeviceID(LPCGUID pGuidSrc, LPGUID pGuidDest)
 {
-    IMMDeviceEnumerator *devenum;
-    EDataFlow flow = (EDataFlow)-1;
-    ERole role = (ERole)-1;
-    HRESULT hr, init_hr;
-
     TRACE("(%s,%p)\n", get_device_id(pGuidSrc),pGuidDest);
 
-    if(!pGuidSrc || !pGuidDest)
-        return DSERR_INVALIDPARAM;
-
-    init_hr = get_mmdevenum(&devenum);
-    if(!devenum)
-        return init_hr;
-
-    if(IsEqualGUID(&DSDEVID_DefaultPlayback, pGuidSrc)){
-        role = eMultimedia;
-        flow = eRender;
-    }else if(IsEqualGUID(&DSDEVID_DefaultVoicePlayback, pGuidSrc)){
-        role = eCommunications;
-        flow = eRender;
-    }else if(IsEqualGUID(&DSDEVID_DefaultCapture, pGuidSrc)){
-        role = eMultimedia;
-        flow = eCapture;
-    }else if(IsEqualGUID(&DSDEVID_DefaultVoiceCapture, pGuidSrc)){
-        role = eCommunications;
-        flow = eCapture;
+    if ( pGuidSrc == NULL) {
+	WARN("invalid parameter: pGuidSrc == NULL\n");
+	return DSERR_INVALIDPARAM;
     }
 
-    if(role != (ERole)-1 && flow != (EDataFlow)-1){
-        IMMDevice *device;
-
-        hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(devenum,
-                flow, role, &device);
-        if(FAILED(hr)){
-            WARN("GetDefaultAudioEndpoint failed: %08x\n", hr);
-            release_mmdevenum(devenum, init_hr);
-            return DSERR_NODRIVER;
-        }
-
-        hr = get_mmdevice_guid(device, NULL, pGuidDest);
-        IMMDevice_Release(device);
-
-        release_mmdevenum(devenum, init_hr);
-
-        return (hr == S_OK) ? DS_OK : hr;
+    if ( pGuidDest == NULL ) {
+	WARN("invalid parameter: pGuidDest == NULL\n");
+	return DSERR_INVALIDPARAM;
     }
 
-    release_mmdevenum(devenum, init_hr);
+    if ( IsEqualGUID( &DSDEVID_DefaultPlayback, pGuidSrc ) ||
+	 IsEqualGUID( &DSDEVID_DefaultVoicePlayback, pGuidSrc ) ) {
+	*pGuidDest = DSOUND_renderer_guids[ds_default_playback];
+        TRACE("returns %s\n", get_device_id(pGuidDest));
+	return DS_OK;
+    }
+
+    if ( IsEqualGUID( &DSDEVID_DefaultCapture, pGuidSrc ) ||
+	 IsEqualGUID( &DSDEVID_DefaultVoiceCapture, pGuidSrc ) ) {
+	*pGuidDest = DSOUND_capture_guids[ds_default_capture];
+        TRACE("returns %s\n", get_device_id(pGuidDest));
+	return DS_OK;
+    }
 
     *pGuidDest = *pGuidSrc;
+    TRACE("returns %s\n", get_device_id(pGuidDest));
 
     return DS_OK;
 }
@@ -322,187 +300,6 @@ HRESULT WINAPI DirectSoundEnumerateA(
     return DirectSoundEnumerateW(a_to_w_callback, &context);
 }
 
-HRESULT get_mmdevice(EDataFlow flow, const GUID *tgt, IMMDevice **device)
-{
-    IMMDeviceEnumerator *devenum;
-    IMMDeviceCollection *coll;
-    UINT count, i;
-    HRESULT hr, init_hr;
-
-    init_hr = get_mmdevenum(&devenum);
-    if(!devenum)
-        return init_hr;
-
-    hr = IMMDeviceEnumerator_EnumAudioEndpoints(devenum, flow,
-            DEVICE_STATE_ACTIVE, &coll);
-    if(FAILED(hr)){
-        WARN("EnumAudioEndpoints failed: %08x\n", hr);
-        release_mmdevenum(devenum, init_hr);
-        return hr;
-    }
-
-    hr = IMMDeviceCollection_GetCount(coll, &count);
-    if(FAILED(hr)){
-        IMMDeviceCollection_Release(coll);
-        release_mmdevenum(devenum, init_hr);
-        WARN("GetCount failed: %08x\n", hr);
-        return hr;
-    }
-
-    for(i = 0; i < count; ++i){
-        GUID guid;
-
-        hr = IMMDeviceCollection_Item(coll, i, device);
-        if(FAILED(hr))
-            continue;
-
-        hr = get_mmdevice_guid(*device, NULL, &guid);
-        if(FAILED(hr)){
-            IMMDevice_Release(*device);
-            continue;
-        }
-
-        if(IsEqualGUID(&guid, tgt)){
-            IMMDeviceCollection_Release(coll);
-            release_mmdevenum(devenum, init_hr);
-            return DS_OK;
-        }
-
-        IMMDevice_Release(*device);
-    }
-
-    WARN("No device with GUID %s found!\n", wine_dbgstr_guid(tgt));
-
-    IMMDeviceCollection_Release(coll);
-    release_mmdevenum(devenum, init_hr);
-
-    return DSERR_INVALIDPARAM;
-}
-
-static BOOL send_device(IMMDevice *device, GUID *guid,
-        LPDSENUMCALLBACKW cb, void *user)
-{
-    IPropertyStore *ps;
-    PROPVARIANT pv;
-    BOOL keep_going;
-    HRESULT hr;
-
-    PropVariantInit(&pv);
-
-    hr = IMMDevice_OpenPropertyStore(device, STGM_READ, &ps);
-    if(FAILED(hr)){
-        WARN("OpenPropertyStore failed: %08x\n", hr);
-        return TRUE;
-    }
-
-    hr = get_mmdevice_guid(device, ps, guid);
-    if(FAILED(hr)){
-        IPropertyStore_Release(ps);
-        return TRUE;
-    }
-
-    hr = IPropertyStore_GetValue(ps,
-            (const PROPERTYKEY *)&DEVPKEY_Device_FriendlyName, &pv);
-    if(FAILED(hr)){
-        IPropertyStore_Release(ps);
-        WARN("GetValue(FriendlyName) failed: %08x\n", hr);
-        return TRUE;
-    }
-
-    TRACE("Calling back with %s (%s)\n", wine_dbgstr_guid(guid),
-            wine_dbgstr_w(pv.u.pwszVal));
-
-    keep_going = cb(guid, pv.u.pwszVal, wine_vxd_drv, user);
-
-    PropVariantClear(&pv);
-    IPropertyStore_Release(ps);
-
-    return keep_going;
-}
-
-/* S_FALSE means the callback returned FALSE at some point
- * S_OK means the callback always returned TRUE */
-HRESULT enumerate_mmdevices(EDataFlow flow, GUID *guids,
-        LPDSENUMCALLBACKW cb, void *user)
-{
-    IMMDeviceEnumerator *devenum;
-    IMMDeviceCollection *coll;
-    IMMDevice *defdev = NULL;
-    UINT count, i, n;
-    BOOL keep_going;
-    HRESULT hr, init_hr;
-
-    static const WCHAR primary_desc[] = {'P','r','i','m','a','r','y',' ',
-        'S','o','u','n','d',' ','D','r','i','v','e','r',0};
-    static const WCHAR empty_drv[] = {0};
-
-    init_hr = get_mmdevenum(&devenum);
-    if(!devenum)
-        return init_hr;
-
-    hr = IMMDeviceEnumerator_EnumAudioEndpoints(devenum, flow,
-            DEVICE_STATE_ACTIVE, &coll);
-    if(FAILED(hr)){
-        release_mmdevenum(devenum, init_hr);
-        WARN("EnumAudioEndpoints failed: %08x\n", hr);
-        return DS_OK;
-    }
-
-    hr = IMMDeviceCollection_GetCount(coll, &count);
-    if(FAILED(hr)){
-        IMMDeviceCollection_Release(coll);
-        release_mmdevenum(devenum, init_hr);
-        WARN("GetCount failed: %08x\n", hr);
-        return DS_OK;
-    }
-
-    if(count == 0){
-        release_mmdevenum(devenum, init_hr);
-        return DS_OK;
-    }
-
-    TRACE("Calling back with NULL (%s)\n", wine_dbgstr_w(primary_desc));
-    keep_going = cb(NULL, primary_desc, empty_drv, user);
-
-    /* always send the default device first */
-    if(keep_going){
-        hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(devenum, flow,
-                eMultimedia, &defdev);
-        if(FAILED(hr)){
-            defdev = NULL;
-            n = 0;
-        }else{
-            keep_going = send_device(defdev, &guids[0], cb, user);
-            n = 1;
-        }
-    }
-
-    for(i = 0; keep_going && i < count; ++i){
-        IMMDevice *device;
-
-        hr = IMMDeviceCollection_Item(coll, i, &device);
-        if(FAILED(hr)){
-            WARN("Item failed: %08x\n", hr);
-            continue;
-        }
-
-        if(device != defdev){
-            send_device(device, &guids[n], cb, user);
-            ++n;
-        }
-
-        IMMDevice_Release(device);
-    }
-
-    if(defdev)
-        IMMDevice_Release(defdev);
-    IMMDeviceCollection_Release(coll);
-
-    release_mmdevenum(devenum, init_hr);
-
-    return (keep_going == TRUE) ? S_OK : S_FALSE;
-}
-
 /***************************************************************************
  * DirectSoundEnumerateW [DSOUND.3]
  *
@@ -520,20 +317,61 @@ HRESULT WINAPI DirectSoundEnumerateW(
 	LPDSENUMCALLBACKW lpDSEnumCallback,
 	LPVOID lpContext )
 {
-    HRESULT hr;
+    unsigned devs, wod;
+    DSDRIVERDESC desc;
+    GUID guid;
+    int err;
+    WCHAR wDesc[MAXPNAMELEN];
+    WCHAR wName[MAXPNAMELEN];
 
-    TRACE("(%p,%p)\n", lpDSEnumCallback, lpContext);
+    TRACE("lpDSEnumCallback = %p, lpContext = %p\n",
+	lpDSEnumCallback, lpContext);
 
     if (lpDSEnumCallback == NULL) {
-        WARN("invalid parameter: lpDSEnumCallback == NULL\n");
-        return DSERR_INVALIDPARAM;
+	WARN("invalid parameter: lpDSEnumCallback == NULL\n");
+	return DSERR_INVALIDPARAM;
     }
 
     setup_dsound_options();
 
-    hr = enumerate_mmdevices(eRender, DSOUND_renderer_guids,
-            lpDSEnumCallback, lpContext);
-    return SUCCEEDED(hr) ? DS_OK : hr;
+    devs = waveOutGetNumDevs();
+    if (devs > 0) {
+	if (GetDeviceID(&DSDEVID_DefaultPlayback, &guid) == DS_OK) {
+            static const WCHAR empty[] = { 0 };
+	    for (wod = 0; wod < devs; ++wod) {
+                if (IsEqualGUID( &guid, &DSOUND_renderer_guids[wod] ) ) {
+                    err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,ds_hw_accel));
+                    if (err == DS_OK) {
+                        TRACE("calling lpDSEnumCallback(NULL,\"%s\",\"%s\",%p)\n",
+                              "Primary Sound Driver",desc.szDrvname,lpContext);
+                        MultiByteToWideChar( CP_ACP, 0, "Primary Sound Driver", -1,
+                                             wDesc, sizeof(wDesc)/sizeof(WCHAR) );
+                        if (lpDSEnumCallback(NULL, wDesc, empty, lpContext) == FALSE)
+                            return DS_OK;
+		    }
+		}
+	    }
+	}
+    }
+
+    for (wod = 0; wod < devs; ++wod) {
+        err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,ds_hw_accel));
+	if (err == DS_OK) {
+            TRACE("calling lpDSEnumCallback(%s,\"%s\",\"%s\",%p)\n",
+                  debugstr_guid(&DSOUND_renderer_guids[wod]),desc.szDesc,desc.szDrvname,lpContext);
+            MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1,
+                                 wDesc, sizeof(wDesc)/sizeof(WCHAR) );
+            wDesc[(sizeof(wDesc)/sizeof(WCHAR)) - 1] = '\0';
+
+            MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1,
+                                 wName, sizeof(wName)/sizeof(WCHAR) );
+            wName[(sizeof(wName)/sizeof(WCHAR)) - 1] = '\0';
+
+            if (lpDSEnumCallback(&DSOUND_renderer_guids[wod], wDesc, wName, lpContext) == FALSE)
+                return DS_OK;
+	}
+    }
+    return DS_OK;
 }
 
 /***************************************************************************
@@ -584,20 +422,64 @@ DirectSoundCaptureEnumerateW(
     LPDSENUMCALLBACKW lpDSEnumCallback,
     LPVOID lpContext)
 {
-    HRESULT hr;
+    unsigned devs, wid;
+    DSDRIVERDESC desc;
+    GUID guid;
+    int err;
+    WCHAR wDesc[MAXPNAMELEN];
+    WCHAR wName[MAXPNAMELEN];
 
     TRACE("(%p,%p)\n", lpDSEnumCallback, lpContext );
 
     if (lpDSEnumCallback == NULL) {
-        WARN("invalid parameter: lpDSEnumCallback == NULL\n");
+	WARN("invalid parameter: lpDSEnumCallback == NULL\n");
         return DSERR_INVALIDPARAM;
     }
 
     setup_dsound_options();
 
-    hr = enumerate_mmdevices(eCapture, DSOUND_capture_guids,
-            lpDSEnumCallback, lpContext);
-    return SUCCEEDED(hr) ? DS_OK : hr;
+    devs = waveInGetNumDevs();
+    if (devs > 0) {
+	if (GetDeviceID(&DSDEVID_DefaultCapture, &guid) == DS_OK) {
+	    for (wid = 0; wid < devs; ++wid) {
+                if (IsEqualGUID( &guid, &DSOUND_capture_guids[wid] ) ) {
+                    err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,ds_hw_accel));
+                    if (err == DS_OK) {
+                        TRACE("calling lpDSEnumCallback(NULL,\"%s\",\"%s\",%p)\n",
+                              "Primary Sound Capture Driver",desc.szDrvname,lpContext);
+                        MultiByteToWideChar( CP_ACP, 0, "Primary Sound Capture Driver", -1,
+                                             wDesc, sizeof(wDesc)/sizeof(WCHAR) );
+                        MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1,
+                                             wName, sizeof(wName)/sizeof(WCHAR) );
+                        wName[(sizeof(wName)/sizeof(WCHAR)) - 1] = '\0';
+
+                        if (lpDSEnumCallback(NULL, wDesc, wName, lpContext) == FALSE)
+                            return DS_OK;
+                    }
+                }
+	    }
+	}
+    }
+
+    for (wid = 0; wid < devs; ++wid) {
+        err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,ds_hw_accel));
+	if (err == DS_OK) {
+            TRACE("calling lpDSEnumCallback(%s,\"%s\",\"%s\",%p)\n",
+                  debugstr_guid(&DSOUND_capture_guids[wid]),desc.szDesc,desc.szDrvname,lpContext);
+            MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1,
+                                 wDesc, sizeof(wDesc)/sizeof(WCHAR) );
+            wDesc[(sizeof(wDesc)/sizeof(WCHAR)) - 1] = '\0';
+
+            MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1,
+                                 wName, sizeof(wName)/sizeof(WCHAR) );
+            wName[(sizeof(wName)/sizeof(WCHAR)) - 1] = '\0';
+
+            if (lpDSEnumCallback(&DSOUND_capture_guids[wid], wDesc, wName, lpContext) == FALSE)
+                return DS_OK;
+	}
+    }
+
+    return DS_OK;
 }
 
 /*******************************************************************************
@@ -618,7 +500,7 @@ static inline IClassFactoryImpl *impl_from_IClassFactory(IClassFactory *iface)
 }
 
 static HRESULT WINAPI
-DSCF_QueryInterface(IClassFactory *iface, REFIID riid, LPVOID *ppobj)
+DSCF_QueryInterface(LPCLASSFACTORY iface, REFIID riid, LPVOID *ppobj)
 {
     IClassFactoryImpl *This = impl_from_IClassFactory(iface);
     TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
@@ -628,7 +510,7 @@ DSCF_QueryInterface(IClassFactory *iface, REFIID riid, LPVOID *ppobj)
         IsEqualIID(riid, &IID_IClassFactory))
     {
         *ppobj = iface;
-        IClassFactory_AddRef(iface);
+        IUnknown_AddRef(iface);
         return S_OK;
     }
     *ppobj = NULL;
@@ -682,12 +564,12 @@ static const IClassFactoryVtbl DSCF_Vtbl = {
 };
 
 static IClassFactoryImpl DSOUND_CF[] = {
-    { { &DSCF_Vtbl }, &CLSID_DirectSound, DSOUND_Create },
-    { { &DSCF_Vtbl }, &CLSID_DirectSound8, DSOUND_Create8 },
-    { { &DSCF_Vtbl }, &CLSID_DirectSoundCapture, DSOUND_CaptureCreate },
-    { { &DSCF_Vtbl }, &CLSID_DirectSoundCapture8, DSOUND_CaptureCreate8 },
-    { { &DSCF_Vtbl }, &CLSID_DirectSoundFullDuplex, DSOUND_FullDuplexCreate },
-    { { &DSCF_Vtbl }, &CLSID_DirectSoundPrivate, IKsPrivatePropertySetImpl_Create },
+    { { &DSCF_Vtbl }, &CLSID_DirectSound, (FnCreateInstance)DSOUND_Create },
+    { { &DSCF_Vtbl }, &CLSID_DirectSound8, (FnCreateInstance)DSOUND_Create8 },
+    { { &DSCF_Vtbl }, &CLSID_DirectSoundCapture, (FnCreateInstance)DSOUND_CaptureCreate },
+    { { &DSCF_Vtbl }, &CLSID_DirectSoundCapture8, (FnCreateInstance)DSOUND_CaptureCreate8 },
+    { { &DSCF_Vtbl }, &CLSID_DirectSoundFullDuplex, (FnCreateInstance)DSOUND_FullDuplexCreate },
+    { { &DSCF_Vtbl }, &CLSID_DirectSoundPrivate, (FnCreateInstance)IKsPrivatePropertySetImpl_Create },
     { { NULL }, NULL, NULL }
 };
 
@@ -765,11 +647,18 @@ HRESULT WINAPI DllCanUnloadNow(void)
  */
 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpvReserved)
 {
+    int i;
     TRACE("(%p %d %p)\n", hInstDLL, fdwReason, lpvReserved);
 
     switch (fdwReason) {
     case DLL_PROCESS_ATTACH:
         TRACE("DLL_PROCESS_ATTACH\n");
+        for (i = 0; i < MAXWAVEDRIVERS; i++) {
+            DSOUND_renderer[i] = NULL;
+            DSOUND_capture[i] = NULL;
+            INIT_GUID(DSOUND_renderer_guids[i], 0xbd6dd71a, 0x3deb, 0x11d1, 0xb1, 0x71, 0x00, 0xc0, 0x4f, 0xc2, 0x00, 0x00 + i);
+            INIT_GUID(DSOUND_capture_guids[i],  0xbd6dd71b, 0x3deb, 0x11d1, 0xb1, 0x71, 0x00, 0xc0, 0x4f, 0xc2, 0x00, 0x00 + i);
+        }
         instance = hInstDLL;
         DisableThreadLibraryCalls(hInstDLL);
         /* Increase refcount on dsound by 1 */
@@ -777,8 +666,6 @@ BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpvReserved)
         break;
     case DLL_PROCESS_DETACH:
         TRACE("DLL_PROCESS_DETACH\n");
-        DeleteCriticalSection(&DSOUND_renderers_lock);
-        DeleteCriticalSection(&DSOUND_capturers_lock);
         break;
     default:
         TRACE("UNKNOWN REASON\n");

dll/directx/wine/dsound/dsound_private.h

@@ -42,13 +42,12 @@
 #include <wingdi.h>
 #include <winternl.h>
 #include <objbase.h>
-#include <mmdeviceapi.h>
 #include <audioclient.h>
-#include <mmsystem.h>
+#include <mmddk.h>
 #include <dsound.h>
 #include <dsconf.h>
+#include <dsdriver.h>
 #include <vfwmsgs.h>
-#include <devpkey.h>
 
 #include <wine/debug.h>
 #include <wine/list.h>
@@ -59,34 +58,48 @@ WINE_DEFAULT_DEBUG_CHANNEL(dsound);
 #define DS_TIME_RES 2  /* Resolution of multimedia timer */
 #define DS_TIME_DEL 10  /* Delay of multimedia timer callback, and duration of HEL fragment */
 
+/* direct sound hardware acceleration levels */
+#define DS_HW_ACCEL_FULL        0	/* default on Windows 98 */
+#define DS_HW_ACCEL_STANDARD    1	/* default on Windows 2000 */
+#define DS_HW_ACCEL_BASIC       2
+#define DS_HW_ACCEL_EMULATION   3
+
+extern int ds_emuldriver DECLSPEC_HIDDEN;
 extern int ds_hel_buflen DECLSPEC_HIDDEN;
 extern int ds_snd_queue_max DECLSPEC_HIDDEN;
+extern int ds_snd_queue_min DECLSPEC_HIDDEN;
+extern int ds_snd_shadow_maxsize DECLSPEC_HIDDEN;
+extern int ds_hw_accel DECLSPEC_HIDDEN;
+extern int ds_default_sample_rate DECLSPEC_HIDDEN;
+extern int ds_default_bits_per_sample DECLSPEC_HIDDEN;
 
 /*****************************************************************************
  * Predeclare the interface implementation structures
  */
+typedef struct IDirectSoundImpl              IDirectSoundImpl;
+typedef struct IDirectSound_IUnknown         IDirectSound_IUnknown;
+typedef struct IDirectSound_IDirectSound     IDirectSound_IDirectSound;
+typedef struct IDirectSound8_IUnknown        IDirectSound8_IUnknown;
+typedef struct IDirectSound8_IDirectSound    IDirectSound8_IDirectSound;
+typedef struct IDirectSound8_IDirectSound8   IDirectSound8_IDirectSound8;
 typedef struct IDirectSoundBufferImpl        IDirectSoundBufferImpl;
+typedef struct IDirectSoundCaptureImpl       IDirectSoundCaptureImpl;
+typedef struct IDirectSoundCaptureBufferImpl IDirectSoundCaptureBufferImpl;
+typedef struct IDirectSoundNotifyImpl        IDirectSoundNotifyImpl;
+typedef struct IDirectSoundCaptureNotifyImpl IDirectSoundCaptureNotifyImpl;
+typedef struct IDirectSound3DListenerImpl    IDirectSound3DListenerImpl;
+typedef struct IDirectSound3DBufferImpl      IDirectSound3DBufferImpl;
+typedef struct IKsBufferPropertySetImpl      IKsBufferPropertySetImpl;
 typedef struct DirectSoundDevice             DirectSoundDevice;
+typedef struct DirectSoundCaptureDevice      DirectSoundCaptureDevice;
 
 /* dsound_convert.h */
-typedef float (*bitsgetfunc)(const IDirectSoundBufferImpl *, DWORD, DWORD);
-typedef void (*bitsputfunc)(const IDirectSoundBufferImpl *, DWORD, DWORD, float);
-extern const bitsgetfunc getbpp[5] DECLSPEC_HIDDEN;
-void putieee32(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel, float value) DECLSPEC_HIDDEN;
-void mixieee32(float *src, float *dst, unsigned samples) DECLSPEC_HIDDEN;
+typedef void (*bitsconvertfunc)(const void *, void *, UINT, UINT, INT, UINT, UINT);
+extern const bitsconvertfunc convertbpp[5][4] DECLSPEC_HIDDEN;
+typedef void (*mixfunc)(const void *, void *, unsigned);
+extern const mixfunc mixfunctions[4] DECLSPEC_HIDDEN;
 typedef void (*normfunc)(const void *, void *, unsigned);
-extern const normfunc normfunctions[5] DECLSPEC_HIDDEN;
-
-typedef struct _DSVOLUMEPAN
-{
-    DWORD	dwTotalLeftAmpFactor;
-    DWORD	dwTotalRightAmpFactor;
-    LONG	lVolume;
-    DWORD	dwVolAmpFactor;
-    LONG	lPan;
-    DWORD	dwPanLeftAmpFactor;
-    DWORD	dwPanRightAmpFactor;
-} DSVOLUMEPAN,*PDSVOLUMEPAN;
+extern const normfunc normfunctions[4] DECLSPEC_HIDDEN;
 
 /*****************************************************************************
  * IDirectSoundDevice implementation structure
@@ -96,11 +109,16 @@ struct DirectSoundDevice
     LONG                        ref;
 
     GUID                        guid;
-    DSCAPS                      drvcaps;
-    DWORD                       priolevel, sleeptime;
-    PWAVEFORMATEX               pwfx, primary_pwfx;
-    UINT                        playing_offs_bytes, in_mmdev_bytes, prebuf;
+    PIDSDRIVER                  driver;
+    DSDRIVERDESC                drvdesc;
+    DSDRIVERCAPS                drvcaps;
+    DWORD                       priolevel;
+    PWAVEFORMATEX               pwfx;
+    HWAVEOUT                    hwo;
+    LPWAVEHDR                   pwave;
+    UINT                        timerID, pwplay, pwqueue, prebuf, helfrags;
     DWORD                       fraglen;
+    PIDSDRIVERBUFFER            hwbuf;
     LPBYTE                      buffer;
     DWORD                       writelead, buflen, state, playpos, mixpos;
     int                         nrofbuffers;
@@ -109,25 +127,18 @@ struct DirectSoundDevice
     CRITICAL_SECTION            mixlock;
     IDirectSoundBufferImpl     *primary;
     DWORD                       speaker_config;
-    float *mix_buffer, *tmp_buffer;
+    LPBYTE                      tmp_buffer, mix_buffer;
     DWORD                       tmp_buffer_len, mix_buffer_len;
 
     DSVOLUMEPAN                 volpan;
 
+    mixfunc mixfunction;
     normfunc normfunction;
 
     /* DirectSound3DListener fields */
+    IDirectSound3DListenerImpl*	listener;
     DS3DLISTENER                ds3dl;
     BOOL                        ds3dl_need_recalc;
-
-    IMMDevice *mmdevice;
-    IAudioClient *client;
-    IAudioClock *clock;
-    IAudioStreamVolume *volume;
-    IAudioRenderClient *render;
-
-    HANDLE sleepev, thread;
-    struct list entry;
 };
 
 /* reference counted buffer memory for duplicated buffer memory */
@@ -145,7 +156,10 @@ HRESULT DirectSoundDevice_Initialize(
 HRESULT DirectSoundDevice_AddBuffer(
     DirectSoundDevice * device,
     IDirectSoundBufferImpl * pDSB) DECLSPEC_HIDDEN;
-void DirectSoundDevice_RemoveBuffer(DirectSoundDevice * device, IDirectSoundBufferImpl * pDSB) DECLSPEC_HIDDEN;
+HRESULT DirectSoundDevice_RemoveBuffer(
+    DirectSoundDevice * device,
+    IDirectSoundBufferImpl * pDSB) DECLSPEC_HIDDEN;
+HRESULT DirectSoundDevice_GetCaps(DirectSoundDevice * device, LPDSCAPS lpDSCaps) DECLSPEC_HIDDEN;
 HRESULT DirectSoundDevice_CreateSoundBuffer(
     DirectSoundDevice * device,
     LPCDSBUFFERDESC dsbd,
@@ -156,6 +170,19 @@ HRESULT DirectSoundDevice_DuplicateSoundBuffer(
     DirectSoundDevice * device,
     LPDIRECTSOUNDBUFFER psb,
     LPLPDIRECTSOUNDBUFFER ppdsb) DECLSPEC_HIDDEN;
+HRESULT DirectSoundDevice_SetCooperativeLevel(
+    DirectSoundDevice * devcie,
+    HWND hwnd,
+    DWORD level) DECLSPEC_HIDDEN;
+HRESULT DirectSoundDevice_Compact(DirectSoundDevice * device) DECLSPEC_HIDDEN;
+HRESULT DirectSoundDevice_GetSpeakerConfig(
+    DirectSoundDevice * device,
+    LPDWORD lpdwSpeakerConfig) DECLSPEC_HIDDEN;
+HRESULT DirectSoundDevice_SetSpeakerConfig(
+    DirectSoundDevice * device,
+    DWORD config) DECLSPEC_HIDDEN;
+HRESULT DirectSoundDevice_VerifyCertification(DirectSoundDevice * device,
+    LPDWORD pdwCertified) DECLSPEC_HIDDEN;
 
 /*****************************************************************************
  * IDirectSoundBuffer implementation structure
@@ -163,74 +190,175 @@ HRESULT DirectSoundDevice_DuplicateSoundBuffer(
 struct IDirectSoundBufferImpl
 {
     IDirectSoundBuffer8         IDirectSoundBuffer8_iface;
-    IDirectSoundNotify          IDirectSoundNotify_iface;
-    IDirectSound3DListener      IDirectSound3DListener_iface; /* only primary buffer */
-    IDirectSound3DBuffer        IDirectSound3DBuffer_iface; /* only secondary buffer */
-    IKsPropertySet              IKsPropertySet_iface;
     LONG                        numIfaces; /* "in use interfaces" refcount */
-    LONG                        ref, refn, ref3D, refiks;
+    LONG                        ref;
     /* IDirectSoundBufferImpl fields */
     DirectSoundDevice*          device;
     RTL_RWLOCK                  lock;
+    PIDSDRIVERBUFFER            hwbuf;
     PWAVEFORMATEX               pwfx;
     BufferMemory*               buffer;
+    LPBYTE                      tmp_buffer;
     DWORD                       playflags,state,leadin;
     DWORD                       writelead,buflen;
     DWORD                       nAvgBytesPerSec;
-    DWORD                       freq;
+    DWORD                       freq, tmp_buffer_len, max_buffer_len;
     DSVOLUMEPAN                 volpan;
     DSBUFFERDESC                dsbd;
     /* used for frequency conversion (PerfectPitch) */
-    ULONG                       freqneeded;
-    DWORD                       firstep;
-    float freqAcc, freqAdjust, firgain;
+    ULONG                       freqneeded, freqAdjust, freqAcc, freqAccNext, resampleinmixer;
     /* used for mixing */
-    DWORD                       sec_mixpos;
+    DWORD                       primary_mixpos, buf_mixpos, sec_mixpos;
 
-    /* IDirectSoundNotify fields */
+    /* IDirectSoundNotifyImpl fields */
+    IDirectSoundNotifyImpl*     notify;
     LPDSBPOSITIONNOTIFY         notifies;
     int                         nrofnotifies;
+    PIDSDRIVERNOTIFY            hwnotify;
+
     /* DirectSound3DBuffer fields */
+    IDirectSound3DBufferImpl*   ds3db;
     DS3DBUFFER                  ds3db_ds3db;
     LONG                        ds3db_lVolume;
     BOOL                        ds3db_need_recalc;
-    /* Used for bit depth conversion */
-    int                         mix_channels;
-    bitsgetfunc get, get_aux;
-    bitsputfunc put, put_aux;
 
+    /* IKsPropertySet fields */
+    IKsBufferPropertySetImpl*   iks;
+    bitsconvertfunc convert;
     struct list entry;
 };
 
-float get_mono(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel) DECLSPEC_HIDDEN;
-void put_mono2stereo(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel, float value) DECLSPEC_HIDDEN;
-
 HRESULT IDirectSoundBufferImpl_Create(
     DirectSoundDevice *device,
     IDirectSoundBufferImpl **ppdsb,
     LPCDSBUFFERDESC dsbd) DECLSPEC_HIDDEN;
+HRESULT IDirectSoundBufferImpl_Destroy(
+    IDirectSoundBufferImpl *pdsb) DECLSPEC_HIDDEN;
 HRESULT IDirectSoundBufferImpl_Duplicate(
     DirectSoundDevice *device,
     IDirectSoundBufferImpl **ppdsb,
     IDirectSoundBufferImpl *pdsb) DECLSPEC_HIDDEN;
 void secondarybuffer_destroy(IDirectSoundBufferImpl *This) DECLSPEC_HIDDEN;
-const IDirectSound3DListenerVtbl ds3dlvt DECLSPEC_HIDDEN;
-const IDirectSound3DBufferVtbl ds3dbvt DECLSPEC_HIDDEN;
-const IKsPropertySetVtbl iksbvt DECLSPEC_HIDDEN;
 
-HRESULT IKsPrivatePropertySetImpl_Create(REFIID riid, void **ppv) DECLSPEC_HIDDEN;
+/*****************************************************************************
+ * DirectSoundCaptureDevice implementation structure
+ */
+struct DirectSoundCaptureDevice
+{
+    /* IDirectSoundCaptureImpl fields */
+    GUID                               guid;
+    LONG                               ref;
+
+    /* DirectSound driver stuff */
+    PIDSCDRIVER                        driver;
+    DSDRIVERDESC                       drvdesc;
+    DSCDRIVERCAPS                      drvcaps;
+    PIDSCDRIVERBUFFER                  hwbuf;
+
+    /* wave driver info */
+    HWAVEIN                            hwi;
+
+    /* more stuff */
+    LPBYTE                             buffer;
+    DWORD                              buflen;
+
+    PWAVEFORMATEX                      pwfx;
+
+    IDirectSoundCaptureBufferImpl*     capture_buffer;
+    DWORD                              state;
+    LPWAVEHDR                          pwave;
+    int                                nrofpwaves;
+    int                                index;
+    CRITICAL_SECTION                   lock;
+};
+
+/*****************************************************************************
+ * IDirectSoundCaptureBuffer implementation structure
+ */
+struct IDirectSoundCaptureBufferImpl
+{
+    /* IUnknown fields */
+    const IDirectSoundCaptureBuffer8Vtbl *lpVtbl;
+    LONG                                ref;
+
+    /* IDirectSoundCaptureBufferImpl fields */
+    DirectSoundCaptureDevice*           device;
+    /* FIXME: don't need this */
+    LPDSCBUFFERDESC                     pdscbd;
+    DWORD                               flags;
+
+    /* IDirectSoundCaptureNotifyImpl fields */
+    IDirectSoundCaptureNotifyImpl*      notify;
+    LPDSBPOSITIONNOTIFY                 notifies;
+    int                                 nrofnotifies;
+    PIDSDRIVERNOTIFY                    hwnotify;
+};
+
+/*****************************************************************************
+ *  IDirectSound3DListener implementation structure
+ */
+struct IDirectSound3DListenerImpl
+{
+    /* IUnknown fields */
+    const IDirectSound3DListenerVtbl *lpVtbl;
+    LONG                        ref;
+    /* IDirectSound3DListenerImpl fields */
+    DirectSoundDevice*          device;
+};
+
+HRESULT IDirectSound3DListenerImpl_Create(
+    DirectSoundDevice           *device,
+    IDirectSound3DListenerImpl **pdsl) DECLSPEC_HIDDEN;
+
+/*****************************************************************************
+ *  IKsBufferPropertySet implementation structure
+ */
+struct IKsBufferPropertySetImpl
+{
+    /* IUnknown fields */
+    const IKsPropertySetVtbl   *lpVtbl;
+    LONG 			ref;
+    /* IKsPropertySetImpl fields */
+    IDirectSoundBufferImpl*	dsb;
+};
+
+HRESULT IKsBufferPropertySetImpl_Create(
+    IDirectSoundBufferImpl *dsb,
+    IKsBufferPropertySetImpl **piks) DECLSPEC_HIDDEN;
+HRESULT IKsBufferPropertySetImpl_Destroy(
+    IKsBufferPropertySetImpl *piks) DECLSPEC_HIDDEN;
+
+HRESULT IKsPrivatePropertySetImpl_Create(REFIID riid, IKsPropertySet **piks) DECLSPEC_HIDDEN;
+
+/*****************************************************************************
+ * IDirectSound3DBuffer implementation structure
+ */
+struct IDirectSound3DBufferImpl
+{
+    /* IUnknown fields */
+    const IDirectSound3DBufferVtbl *lpVtbl;
+    LONG                        ref;
+    /* IDirectSound3DBufferImpl fields */
+    IDirectSoundBufferImpl*     dsb;
+};
+
+HRESULT IDirectSound3DBufferImpl_Create(
+    IDirectSoundBufferImpl *dsb,
+    IDirectSound3DBufferImpl **pds3db) DECLSPEC_HIDDEN;
+HRESULT IDirectSound3DBufferImpl_Destroy(
+    IDirectSound3DBufferImpl *pds3db) DECLSPEC_HIDDEN;
 
 /*******************************************************************************
  */
 
 /* dsound.c */
 
-HRESULT DSOUND_Create(REFIID riid, void **ppv) DECLSPEC_HIDDEN;
-HRESULT DSOUND_Create8(REFIID riid, void **ppv) DECLSPEC_HIDDEN;
-HRESULT IDirectSoundImpl_Create(IUnknown *outer_unk, REFIID riid, void **ppv, BOOL has_ds8) DECLSPEC_HIDDEN;
+HRESULT DSOUND_Create(REFIID riid, LPDIRECTSOUND *ppDS) DECLSPEC_HIDDEN;
+HRESULT DSOUND_Create8(REFIID riid, LPDIRECTSOUND8 *ppDS) DECLSPEC_HIDDEN;
 
 /* primary.c */
 
+DWORD DSOUND_fraglen(DWORD nSamplesPerSec, DWORD nBlockAlign) DECLSPEC_HIDDEN;
 HRESULT DSOUND_PrimaryCreate(DirectSoundDevice *device) DECLSPEC_HIDDEN;
 HRESULT DSOUND_PrimaryDestroy(DirectSoundDevice *device) DECLSPEC_HIDDEN;
 HRESULT DSOUND_PrimaryPlay(DirectSoundDevice *device) DECLSPEC_HIDDEN;
@@ -238,25 +366,26 @@ HRESULT DSOUND_PrimaryStop(DirectSoundDevice *device) DECLSPEC_HIDDEN;
 HRESULT DSOUND_PrimaryGetPosition(DirectSoundDevice *device, LPDWORD playpos, LPDWORD writepos) DECLSPEC_HIDDEN;
 LPWAVEFORMATEX DSOUND_CopyFormat(LPCWAVEFORMATEX wfex) DECLSPEC_HIDDEN;
 HRESULT DSOUND_ReopenDevice(DirectSoundDevice *device, BOOL forcewave) DECLSPEC_HIDDEN;
-HRESULT DSOUND_PrimaryOpen(DirectSoundDevice *device) DECLSPEC_HIDDEN;
 HRESULT primarybuffer_create(DirectSoundDevice *device, IDirectSoundBufferImpl **ppdsb,
     const DSBUFFERDESC *dsbd) DECLSPEC_HIDDEN;
 void primarybuffer_destroy(IDirectSoundBufferImpl *This) DECLSPEC_HIDDEN;
 HRESULT primarybuffer_SetFormat(DirectSoundDevice *device, LPCWAVEFORMATEX wfex) DECLSPEC_HIDDEN;
-LONG capped_refcount_dec(LONG *ref) DECLSPEC_HIDDEN;
 
 /* duplex.c */
-
-HRESULT DSOUND_FullDuplexCreate(REFIID riid, void **ppv) DECLSPEC_HIDDEN;
+ 
+HRESULT DSOUND_FullDuplexCreate(REFIID riid, LPDIRECTSOUNDFULLDUPLEX* ppDSFD) DECLSPEC_HIDDEN;
 
 /* mixer.c */
+DWORD DSOUND_bufpos_to_mixpos(const DirectSoundDevice* device, DWORD pos) DECLSPEC_HIDDEN;
 void DSOUND_CheckEvent(const IDirectSoundBufferImpl *dsb, DWORD playpos, int len) DECLSPEC_HIDDEN;
 void DSOUND_RecalcVolPan(PDSVOLUMEPAN volpan) DECLSPEC_HIDDEN;
 void DSOUND_AmpFactorToVolPan(PDSVOLUMEPAN volpan) DECLSPEC_HIDDEN;
 void DSOUND_RecalcFormat(IDirectSoundBufferImpl *dsb) DECLSPEC_HIDDEN;
-DWORD DSOUND_secpos_to_bufpos(const IDirectSoundBufferImpl *dsb, DWORD secpos, DWORD secmixpos, float *overshot) DECLSPEC_HIDDEN;
+void DSOUND_MixToTemporary(const IDirectSoundBufferImpl *dsb, DWORD writepos, DWORD mixlen, BOOL inmixer) DECLSPEC_HIDDEN;
+DWORD DSOUND_secpos_to_bufpos(const IDirectSoundBufferImpl *dsb, DWORD secpos, DWORD secmixpos, DWORD* overshot) DECLSPEC_HIDDEN;
 
-DWORD CALLBACK DSOUND_mixthread(void *ptr) DECLSPEC_HIDDEN;
+void CALLBACK DSOUND_timer(UINT timerID, UINT msg, DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2) DECLSPEC_HIDDEN;
+void CALLBACK DSOUND_callback(HWAVEOUT hwo, UINT msg, DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2) DECLSPEC_HIDDEN;
 
 /* sound3d.c */
 
@@ -264,9 +393,8 @@ void DSOUND_Calc3DBuffer(IDirectSoundBufferImpl *dsb) DECLSPEC_HIDDEN;
 
 /* capture.c */
  
-HRESULT DSOUND_CaptureCreate(REFIID riid, void **ppv) DECLSPEC_HIDDEN;
-HRESULT DSOUND_CaptureCreate8(REFIID riid, void **ppv) DECLSPEC_HIDDEN;
-HRESULT IDirectSoundCaptureImpl_Create(IUnknown *outer_unk, REFIID riid, void **ppv, BOOL has_dsc8) DECLSPEC_HIDDEN;
+HRESULT DSOUND_CaptureCreate(REFIID riid, LPDIRECTSOUNDCAPTURE *ppDSC) DECLSPEC_HIDDEN;
+HRESULT DSOUND_CaptureCreate8(REFIID riid, LPDIRECTSOUNDCAPTURE8 *ppDSC8) DECLSPEC_HIDDEN;
 
 #define STATE_STOPPED   0
 #define STATE_STARTING  1
@@ -274,24 +402,16 @@ HRESULT IDirectSoundCaptureImpl_Create(IUnknown *outer_unk, REFIID riid, void **
 #define STATE_CAPTURING 2
 #define STATE_STOPPING  3
 
-extern CRITICAL_SECTION DSOUND_renderers_lock DECLSPEC_HIDDEN;
-extern CRITICAL_SECTION DSOUND_capturers_lock DECLSPEC_HIDDEN;
-extern struct list DSOUND_capturers DECLSPEC_HIDDEN;
-extern struct list DSOUND_renderers DECLSPEC_HIDDEN;
+#define DSOUND_FREQSHIFT (20)
 
+extern DirectSoundDevice* DSOUND_renderer[MAXWAVEDRIVERS] DECLSPEC_HIDDEN;
 extern GUID DSOUND_renderer_guids[MAXWAVEDRIVERS] DECLSPEC_HIDDEN;
+
+extern DirectSoundCaptureDevice * DSOUND_capture[MAXWAVEDRIVERS] DECLSPEC_HIDDEN;
 extern GUID DSOUND_capture_guids[MAXWAVEDRIVERS] DECLSPEC_HIDDEN;
 
-extern WCHAR wine_vxd_drv[] DECLSPEC_HIDDEN;
-
+HRESULT mmErr(UINT err) DECLSPEC_HIDDEN;
 void setup_dsound_options(void) DECLSPEC_HIDDEN;
-
-HRESULT get_mmdevice(EDataFlow flow, const GUID *tgt, IMMDevice **device) DECLSPEC_HIDDEN;
-
-BOOL DSOUND_check_supported(IAudioClient *client, DWORD rate,
-        DWORD depth, WORD channels) DECLSPEC_HIDDEN;
-UINT DSOUND_create_timer(LPTIMECALLBACK cb, DWORD_PTR user) DECLSPEC_HIDDEN;
-HRESULT enumerate_mmdevices(EDataFlow flow, GUID *guids,
-        LPDSENUMCALLBACKW cb, void *user) DECLSPEC_HIDDEN;
+const char * dumpCooperativeLevel(DWORD level) DECLSPEC_HIDDEN;
 
 #endif /* _DSOUND_PRIVATE_H_ */

dll/directx/wine/dsound/duplex.c

@@ -27,230 +27,567 @@
  */
 typedef struct IDirectSoundFullDuplexImpl
 {
-    IUnknown               IUnknown_iface;
-    IDirectSoundFullDuplex IDirectSoundFullDuplex_iface;
-    LONG                   ref, refdsfd, numIfaces;
-    IUnknown              *ds8_unk;     /* Aggregated IDirectSound8 */
-    IUnknown              *dsc8_unk;    /* Aggregated IDirectSoundCapture8 */
+    /* IUnknown fields */
+    const IDirectSoundFullDuplexVtbl *lpVtbl;
+    LONG                              ref;
+
+    /* IDirectSoundFullDuplexImpl fields */
+    IDirectSound8                    *renderer_device;
+    IDirectSoundCapture              *capture_device;
+
+    LPUNKNOWN                         pUnknown;
+    LPDIRECTSOUND8                    pDS8;
+    LPDIRECTSOUNDCAPTURE              pDSC;
 } IDirectSoundFullDuplexImpl;
 
-static void fullduplex_destroy(IDirectSoundFullDuplexImpl *This)
-{
-    IDirectSound8 *ds8;
-    IDirectSoundCapture8 *dsc8;
+typedef struct IDirectSoundFullDuplex_IUnknown {
+    const IUnknownVtbl         *lpVtbl;
+    LONG                        ref;
+    IDirectSoundFullDuplexImpl *pdsfd;
+} IDirectSoundFullDuplex_IUnknown;
 
-    if (This->ds8_unk) {
-        IUnknown_QueryInterface(This->ds8_unk, &IID_IDirectSound8, (void**)&ds8);
-        while(IDirectSound8_Release(ds8) > 0);
-        IUnknown_Release(This->ds8_unk);
+typedef struct IDirectSoundFullDuplex_IDirectSound8 {
+    const IDirectSound8Vtbl    *lpVtbl;
+    LONG                        ref;
+    IDirectSoundFullDuplexImpl *pdsfd;
+} IDirectSoundFullDuplex_IDirectSound8;
+
+typedef struct IDirectSoundFullDuplex_IDirectSoundCapture {
+    const IDirectSoundCaptureVtbl *lpVtbl;
+    LONG                           ref;
+    IDirectSoundFullDuplexImpl    *pdsfd;
+} IDirectSoundFullDuplex_IDirectSoundCapture;
+
+/*******************************************************************************
+ * IUnknown
+ */
+static HRESULT WINAPI IDirectSoundFullDuplex_IUnknown_QueryInterface(
+    LPUNKNOWN iface,
+    REFIID riid,
+    LPVOID * ppobj)
+{
+    IDirectSoundFullDuplex_IUnknown *This = (IDirectSoundFullDuplex_IUnknown *)iface;
+    TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
+    return IDirectSoundFullDuplex_QueryInterface((LPDIRECTSOUNDFULLDUPLEX)This->pdsfd, riid, ppobj);
+}
+
+static ULONG WINAPI IDirectSoundFullDuplex_IUnknown_AddRef(
+    LPUNKNOWN iface)
+{
+    IDirectSoundFullDuplex_IUnknown *This = (IDirectSoundFullDuplex_IUnknown *)iface;
+    ULONG ref = InterlockedIncrement(&(This->ref));
+    TRACE("(%p) ref was %d\n", This, ref - 1);
+    return ref;
+}
+
+static ULONG WINAPI IDirectSoundFullDuplex_IUnknown_Release(
+    LPUNKNOWN iface)
+{
+    IDirectSoundFullDuplex_IUnknown *This = (IDirectSoundFullDuplex_IUnknown *)iface;
+    ULONG ref = InterlockedDecrement(&(This->ref));
+    TRACE("(%p) ref was %d\n", This, ref + 1);
+    if (!ref) {
+        This->pdsfd->pUnknown = NULL;
+        HeapFree(GetProcessHeap(), 0, This);
+        TRACE("(%p) released\n", This);
     }
-    if (This->dsc8_unk) {
-        IUnknown_QueryInterface(This->dsc8_unk, &IID_IDirectSoundCapture8, (void**)&dsc8);
-        while(IDirectSoundCapture_Release(dsc8) > 0);
-        IUnknown_Release(This->dsc8_unk);
+    return ref;
+}
+
+static const IUnknownVtbl DirectSoundFullDuplex_Unknown_Vtbl =
+{
+    IDirectSoundFullDuplex_IUnknown_QueryInterface,
+    IDirectSoundFullDuplex_IUnknown_AddRef,
+    IDirectSoundFullDuplex_IUnknown_Release
+};
+
+static HRESULT IDirectSoundFullDuplex_IUnknown_Create(
+    LPDIRECTSOUNDFULLDUPLEX pdsfd,
+    LPUNKNOWN * ppunk)
+{
+    IDirectSoundFullDuplex_IUnknown * pdsfdunk;
+    TRACE("(%p,%p)\n",pdsfd,ppunk);
+
+    if (pdsfd == NULL) {
+        ERR("invalid parameter: pdsfd == NULL\n");
+        return DSERR_INVALIDPARAM;
     }
-    HeapFree(GetProcessHeap(), 0, This);
-    TRACE("(%p) released\n", This);
+
+    if (ppunk == NULL) {
+        ERR("invalid parameter: ppunk == NULL\n");
+        return DSERR_INVALIDPARAM;
+    }
+
+    pdsfdunk = HeapAlloc(GetProcessHeap(),0,sizeof(*pdsfdunk));
+    if (pdsfdunk == NULL) {
+        WARN("out of memory\n");
+        *ppunk = NULL;
+        return DSERR_OUTOFMEMORY;
+    }
+
+    pdsfdunk->lpVtbl = &DirectSoundFullDuplex_Unknown_Vtbl;
+    pdsfdunk->ref = 0;
+    pdsfdunk->pdsfd = (IDirectSoundFullDuplexImpl *)pdsfd;
+
+    *ppunk = (LPUNKNOWN)pdsfdunk;
+
+    return DS_OK;
 }
 
 /*******************************************************************************
- * IUnknown implemetation for DirectSoundFullDuplex
+ * IDirectSoundFullDuplex_IDirectSound8
  */
-static inline IDirectSoundFullDuplexImpl *impl_from_IUnknown(IUnknown *iface)
+static HRESULT WINAPI IDirectSoundFullDuplex_IDirectSound8_QueryInterface(
+    LPDIRECTSOUND8 iface,
+    REFIID riid,
+    LPVOID * ppobj)
 {
-    return CONTAINING_RECORD(iface, IDirectSoundFullDuplexImpl, IUnknown_iface);
+    IDirectSoundFullDuplex_IDirectSound8 *This = (IDirectSoundFullDuplex_IDirectSound8 *)iface;
+    TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
+    return IDirectSoundFullDuplex_QueryInterface((LPDIRECTSOUNDFULLDUPLEX)This->pdsfd, riid, ppobj);
 }
 
-static HRESULT WINAPI IUnknownImpl_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
+static ULONG WINAPI IDirectSoundFullDuplex_IDirectSound8_AddRef(
+    LPDIRECTSOUND8 iface)
 {
-    IDirectSoundFullDuplexImpl *This = impl_from_IUnknown(iface);
+    IDirectSoundFullDuplex_IDirectSound8 *This = (IDirectSoundFullDuplex_IDirectSound8 *)iface;
+    ULONG ref = InterlockedIncrement(&(This->ref));
+    TRACE("(%p) ref was %d\n", This, ref - 1);
+    return ref;
+}
 
-    TRACE("(%p,%s,%p)\n", This, debugstr_guid(riid), ppv);
+static ULONG WINAPI IDirectSoundFullDuplex_IDirectSound8_Release(
+    LPDIRECTSOUND8 iface)
+{
+    IDirectSoundFullDuplex_IDirectSound8 *This = (IDirectSoundFullDuplex_IDirectSound8 *)iface;
+    ULONG ref = InterlockedDecrement(&(This->ref));
+    TRACE("(%p) ref was %d\n", This, ref + 1);
+    if (!ref) {
+        This->pdsfd->pDS8 = NULL;
+        HeapFree(GetProcessHeap(), 0, This);
+        TRACE("(%p) released\n", This);
+    }
+    return ref;
+}
 
-    if (!ppv) {
-        WARN("invalid parameter\n");
-        return E_INVALIDARG;
+static HRESULT WINAPI IDirectSoundFullDuplex_IDirectSound8_CreateSoundBuffer(
+    LPDIRECTSOUND8 iface,
+    LPCDSBUFFERDESC dsbd,
+    LPLPDIRECTSOUNDBUFFER ppdsb,
+    LPUNKNOWN lpunk)
+{
+    IDirectSoundFullDuplex_IDirectSound8 *This = (IDirectSoundFullDuplex_IDirectSound8 *)iface;
+    TRACE("(%p,%p,%p,%p)\n",This,dsbd,ppdsb,lpunk);
+    return IDirectSound8_CreateSoundBuffer(This->pdsfd->renderer_device,dsbd,ppdsb,lpunk);
+}
+
+static HRESULT WINAPI IDirectSoundFullDuplex_IDirectSound8_GetCaps(
+    LPDIRECTSOUND8 iface,
+    LPDSCAPS lpDSCaps)
+{
+    IDirectSoundFullDuplex_IDirectSound8 *This = (IDirectSoundFullDuplex_IDirectSound8 *)iface;
+    TRACE("(%p,%p)\n",This,lpDSCaps);
+    return IDirectSound8_GetCaps(This->pdsfd->renderer_device, lpDSCaps);
+}
+
+static HRESULT WINAPI IDirectSoundFullDuplex_IDirectSound8_DuplicateSoundBuffer(
+    LPDIRECTSOUND8 iface,
+    LPDIRECTSOUNDBUFFER psb,
+    LPLPDIRECTSOUNDBUFFER ppdsb)
+{
+    IDirectSoundFullDuplex_IDirectSound8 *This = (IDirectSoundFullDuplex_IDirectSound8 *)iface;
+    TRACE("(%p,%p,%p)\n",This,psb,ppdsb);
+    return IDirectSound8_DuplicateSoundBuffer(This->pdsfd->renderer_device,psb,ppdsb);
+}
+
+static HRESULT WINAPI IDirectSoundFullDuplex_IDirectSound8_SetCooperativeLevel(
+    LPDIRECTSOUND8 iface,
+    HWND hwnd,
+    DWORD level)
+{
+    IDirectSoundFullDuplex_IDirectSound8 *This = (IDirectSoundFullDuplex_IDirectSound8 *)iface;
+    TRACE("(%p,%p,%s)\n",This,hwnd,dumpCooperativeLevel(level));
+    return IDirectSound8_SetCooperativeLevel(This->pdsfd->renderer_device,hwnd,level);
+}
+
+static HRESULT WINAPI IDirectSoundFullDuplex_IDirectSound8_Compact(
+    LPDIRECTSOUND8 iface)
+{
+    IDirectSoundFullDuplex_IDirectSound8 *This = (IDirectSoundFullDuplex_IDirectSound8 *)iface;
+    TRACE("(%p)\n", This);
+    return IDirectSound8_Compact(This->pdsfd->renderer_device);
+}
+
+static HRESULT WINAPI IDirectSoundFullDuplex_IDirectSound8_GetSpeakerConfig(
+    LPDIRECTSOUND8 iface,
+    LPDWORD lpdwSpeakerConfig)
+{
+    IDirectSoundFullDuplex_IDirectSound8 *This = (IDirectSoundFullDuplex_IDirectSound8 *)iface;
+    TRACE("(%p, %p)\n", This, lpdwSpeakerConfig);
+    return IDirectSound8_GetSpeakerConfig(This->pdsfd->renderer_device,lpdwSpeakerConfig);
+}
+
+static HRESULT WINAPI IDirectSoundFullDuplex_IDirectSound8_SetSpeakerConfig(
+    LPDIRECTSOUND8 iface,
+    DWORD config)
+{
+    IDirectSoundFullDuplex_IDirectSound8 *This = (IDirectSoundFullDuplex_IDirectSound8 *)iface;
+    TRACE("(%p,0x%08x)\n",This,config);
+    return IDirectSound8_SetSpeakerConfig(This->pdsfd->renderer_device,config);
+}
+
+static HRESULT WINAPI IDirectSoundFullDuplex_IDirectSound8_Initialize(
+    LPDIRECTSOUND8 iface,
+    LPCGUID lpcGuid)
+{
+    IDirectSoundFullDuplex_IDirectSound8 *This = (IDirectSoundFullDuplex_IDirectSound8 *)iface;
+    TRACE("(%p, %s)\n", This, debugstr_guid(lpcGuid));
+    return IDirectSound8_Initialize(This->pdsfd->renderer_device,lpcGuid);
+}
+
+static HRESULT WINAPI IDirectSoundFullDuplex_IDirectSound8_VerifyCertification(
+    LPDIRECTSOUND8 iface,
+    DWORD *cert)
+{
+    IDirectSoundFullDuplex_IDirectSound8 *This = (IDirectSoundFullDuplex_IDirectSound8 *)iface;
+    TRACE("(%p, %p)\n", This, cert);
+    return IDirectSound8_VerifyCertification(This->pdsfd->renderer_device,cert);
+}
+
+static const IDirectSound8Vtbl DirectSoundFullDuplex_DirectSound8_Vtbl =
+{
+    IDirectSoundFullDuplex_IDirectSound8_QueryInterface,
+    IDirectSoundFullDuplex_IDirectSound8_AddRef,
+    IDirectSoundFullDuplex_IDirectSound8_Release,
+    IDirectSoundFullDuplex_IDirectSound8_CreateSoundBuffer,
+    IDirectSoundFullDuplex_IDirectSound8_GetCaps,
+    IDirectSoundFullDuplex_IDirectSound8_DuplicateSoundBuffer,
+    IDirectSoundFullDuplex_IDirectSound8_SetCooperativeLevel,
+    IDirectSoundFullDuplex_IDirectSound8_Compact,
+    IDirectSoundFullDuplex_IDirectSound8_GetSpeakerConfig,
+    IDirectSoundFullDuplex_IDirectSound8_SetSpeakerConfig,
+    IDirectSoundFullDuplex_IDirectSound8_Initialize,
+    IDirectSoundFullDuplex_IDirectSound8_VerifyCertification
+};
+
+static HRESULT IDirectSoundFullDuplex_IDirectSound8_Create(
+    LPDIRECTSOUNDFULLDUPLEX pdsfd,
+    LPDIRECTSOUND8 * ppds8)
+{
+    IDirectSoundFullDuplex_IDirectSound8 * pdsfdds8;
+    TRACE("(%p,%p)\n",pdsfd,ppds8);
+
+    if (pdsfd == NULL) {
+        ERR("invalid parameter: pdsfd == NULL\n");
+        return DSERR_INVALIDPARAM;
     }
 
+    if (ppds8 == NULL) {
+        ERR("invalid parameter: ppds8 == NULL\n");
+        return DSERR_INVALIDPARAM;
+    }
+
+    if (((IDirectSoundFullDuplexImpl*)pdsfd)->renderer_device == NULL) {
+        WARN("not initialized\n");
+        *ppds8 = NULL;
+        return DSERR_UNINITIALIZED;
+    }
+
+    pdsfdds8 = HeapAlloc(GetProcessHeap(),0,sizeof(*pdsfdds8));
+    if (pdsfdds8 == NULL) {
+        WARN("out of memory\n");
+        *ppds8 = NULL;
+        return DSERR_OUTOFMEMORY;
+    }
+
+    pdsfdds8->lpVtbl = &DirectSoundFullDuplex_DirectSound8_Vtbl;
+    pdsfdds8->ref = 0;
+    pdsfdds8->pdsfd = (IDirectSoundFullDuplexImpl *)pdsfd;
+
+    *ppds8 = (LPDIRECTSOUND8)pdsfdds8;
+
+    return DS_OK;
+}
+
+/*******************************************************************************
+ * IDirectSoundFullDuplex_IDirectSoundCapture
+ */
+static HRESULT WINAPI IDirectSoundFullDuplex_IDirectSoundCapture_QueryInterface(
+    LPDIRECTSOUNDCAPTURE iface,
+    REFIID riid,
+    LPVOID * ppobj)
+{
+    IDirectSoundFullDuplex_IDirectSoundCapture *This = (IDirectSoundFullDuplex_IDirectSoundCapture *)iface;
+    TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
+    return IDirectSoundFullDuplex_QueryInterface((LPDIRECTSOUNDFULLDUPLEX)This->pdsfd, riid, ppobj);
+}
+
+static ULONG WINAPI IDirectSoundFullDuplex_IDirectSoundCapture_AddRef(
+    LPDIRECTSOUNDCAPTURE iface)
+{
+    IDirectSoundFullDuplex_IDirectSoundCapture *This = (IDirectSoundFullDuplex_IDirectSoundCapture *)iface;
+    ULONG ref = InterlockedIncrement(&(This->ref));
+    TRACE("(%p) ref was %d\n", This, ref - 1);
+    return ref;
+}
+
+static ULONG WINAPI IDirectSoundFullDuplex_IDirectSoundCapture_Release(
+    LPDIRECTSOUNDCAPTURE iface)
+{
+    IDirectSoundFullDuplex_IDirectSoundCapture *This = (IDirectSoundFullDuplex_IDirectSoundCapture *)iface;
+    ULONG ref = InterlockedDecrement(&(This->ref));
+    TRACE("(%p) ref was %d\n", This, ref + 1);
+    if (!ref) {
+        This->pdsfd->pDSC = NULL;
+        HeapFree(GetProcessHeap(), 0, This);
+        TRACE("(%p) released\n", This);
+    }
+    return ref;
+}
+
+static HRESULT WINAPI IDirectSoundFullDuplex_IDirectSoundCapture_CreateCaptureBuffer(
+    LPDIRECTSOUNDCAPTURE iface,
+    LPCDSCBUFFERDESC lpcDSCBufferDesc,
+    LPDIRECTSOUNDCAPTUREBUFFER* lplpDSCaptureBuffer,
+    LPUNKNOWN pUnk)
+{
+    IDirectSoundFullDuplex_IDirectSoundCapture *This = (IDirectSoundFullDuplex_IDirectSoundCapture *)iface;
+    TRACE("(%p,%p,%p,%p)\n",This,lpcDSCBufferDesc,lplpDSCaptureBuffer,pUnk);
+    return IDirectSoundCapture_CreateCaptureBuffer(This->pdsfd->capture_device,lpcDSCBufferDesc,lplpDSCaptureBuffer,pUnk);
+}
+
+static HRESULT WINAPI IDirectSoundFullDuplex_IDirectSoundCapture_GetCaps(
+    LPDIRECTSOUNDCAPTURE iface,
+    LPDSCCAPS lpDSCCaps)
+{
+    IDirectSoundFullDuplex_IDirectSoundCapture *This = (IDirectSoundFullDuplex_IDirectSoundCapture *)iface;
+    TRACE("(%p,%p)\n",This,lpDSCCaps);
+    return IDirectSoundCapture_GetCaps(This->pdsfd->capture_device, lpDSCCaps);
+}
+
+static HRESULT WINAPI IDirectSoundFullDuplex_IDirectSoundCapture_Initialize(
+    LPDIRECTSOUNDCAPTURE iface,
+    LPCGUID lpcGUID)
+{
+    IDirectSoundFullDuplex_IDirectSoundCapture *This = (IDirectSoundFullDuplex_IDirectSoundCapture *)iface;
+    TRACE("(%p, %s)\n", This, debugstr_guid(lpcGUID));
+    return IDirectSoundCapture_Initialize(This->pdsfd->capture_device,lpcGUID);
+}
+
+static const IDirectSoundCaptureVtbl DirectSoundFullDuplex_DirectSoundCapture_Vtbl =
+{
+    IDirectSoundFullDuplex_IDirectSoundCapture_QueryInterface,
+    IDirectSoundFullDuplex_IDirectSoundCapture_AddRef,
+    IDirectSoundFullDuplex_IDirectSoundCapture_Release,
+    IDirectSoundFullDuplex_IDirectSoundCapture_CreateCaptureBuffer,
+    IDirectSoundFullDuplex_IDirectSoundCapture_GetCaps,
+    IDirectSoundFullDuplex_IDirectSoundCapture_Initialize
+};
+
+static HRESULT IDirectSoundFullDuplex_IDirectSoundCapture_Create(
+    LPDIRECTSOUNDFULLDUPLEX pdsfd,
+    LPDIRECTSOUNDCAPTURE8 * ppdsc8)
+{
+    IDirectSoundFullDuplex_IDirectSoundCapture * pdsfddsc;
+    TRACE("(%p,%p)\n",pdsfd,ppdsc8);
+
+    if (pdsfd == NULL) {
+        ERR("invalid parameter: pdsfd == NULL\n");
+        return DSERR_INVALIDPARAM;
+    }
+
+    if (ppdsc8 == NULL) {
+        ERR("invalid parameter: ppdsc8 == NULL\n");
+        return DSERR_INVALIDPARAM;
+    }
+
+    if (((IDirectSoundFullDuplexImpl*)pdsfd)->capture_device == NULL) {
+        WARN("not initialized\n");
+        *ppdsc8 = NULL;
+        return DSERR_UNINITIALIZED;
+    }
+
+    pdsfddsc = HeapAlloc(GetProcessHeap(),0,sizeof(*pdsfddsc));
+    if (pdsfddsc == NULL) {
+        WARN("out of memory\n");
+        *ppdsc8 = NULL;
+        return DSERR_OUTOFMEMORY;
+    }
+
+    pdsfddsc->lpVtbl = &DirectSoundFullDuplex_DirectSoundCapture_Vtbl;
+    pdsfddsc->ref = 0;
+    pdsfddsc->pdsfd = (IDirectSoundFullDuplexImpl *)pdsfd;
+
+    *ppdsc8 = (LPDIRECTSOUNDCAPTURE)pdsfddsc;
+
+    return DS_OK;
+}
+
+/***************************************************************************
+ * IDirectSoundFullDuplexImpl
+ */
+static ULONG WINAPI
+IDirectSoundFullDuplexImpl_AddRef( LPDIRECTSOUNDFULLDUPLEX iface )
+{
+    IDirectSoundFullDuplexImpl *This = (IDirectSoundFullDuplexImpl *)iface;
+    ULONG ref = InterlockedIncrement(&(This->ref));
+    TRACE("(%p) ref was %d\n", This, ref - 1);
+    return ref;
+}
+
+static HRESULT WINAPI
+IDirectSoundFullDuplexImpl_QueryInterface(
+    LPDIRECTSOUNDFULLDUPLEX iface,
+    REFIID riid,
+    LPVOID* ppobj )
+{
+    IDirectSoundFullDuplexImpl *This = (IDirectSoundFullDuplexImpl *)iface;
+    TRACE( "(%p,%s,%p)\n", This, debugstr_guid(riid), ppobj );
+
+    if (ppobj == NULL) {
+	WARN("invalid parameter\n");
+	return E_INVALIDARG;
+    }
+
+    *ppobj = NULL;
+
     if (IsEqualIID(riid, &IID_IUnknown)) {
-        IUnknown_AddRef(&This->IUnknown_iface);
-        *ppv = &This->IUnknown_iface;
+        if (!This->pUnknown) {
+            IDirectSoundFullDuplex_IUnknown_Create(iface, &This->pUnknown);
+            if (!This->pUnknown) {
+                WARN("IDirectSoundFullDuplex_IUnknown_Create() failed\n");
+                *ppobj = NULL;
+                return E_NOINTERFACE;
+            }
+        }
+        IDirectSoundFullDuplex_IUnknown_AddRef(This->pUnknown);
+        *ppobj = This->pUnknown;
         return S_OK;
     } else if (IsEqualIID(riid, &IID_IDirectSoundFullDuplex)) {
-        IDirectSoundFullDuplex_AddRef(&This->IDirectSoundFullDuplex_iface);
-        *ppv = &This->IDirectSoundFullDuplex_iface;
+        IDirectSoundFullDuplexImpl_AddRef(iface);
+        *ppobj = This;
         return S_OK;
-    } else if (This->ds8_unk && (IsEqualIID(riid, &IID_IDirectSound) ||
-                                 IsEqualIID(riid, &IID_IDirectSound8)))
-        return IUnknown_QueryInterface(This->ds8_unk, riid, ppv);
-    else if (This->dsc8_unk && IsEqualIID(riid, &IID_IDirectSoundCapture))
-        return IUnknown_QueryInterface(This->dsc8_unk, riid, ppv);
+    } else if (IsEqualIID(riid, &IID_IDirectSound)
+               || IsEqualIID(riid, &IID_IDirectSound8)) {
+        if (!This->pDS8) {
+            IDirectSoundFullDuplex_IDirectSound8_Create(iface, &This->pDS8);
+            if (!This->pDS8) {
+                WARN("IDirectSoundFullDuplex_IDirectSound8_Create() failed\n");
+                *ppobj = NULL;
+                return E_NOINTERFACE;
+            }
+        }
+        IDirectSoundFullDuplex_IDirectSound8_AddRef(This->pDS8);
+        *ppobj = This->pDS8;
+        return S_OK;
+    } else if (IsEqualIID(riid, &IID_IDirectSoundCapture)) {
+        if (!This->pDSC) {
+            IDirectSoundFullDuplex_IDirectSoundCapture_Create(iface, &This->pDSC);
+            if (!This->pDSC) {
+                WARN("IDirectSoundFullDuplex_IDirectSoundCapture_Create() failed\n");
+                *ppobj = NULL;
+                return E_NOINTERFACE;
+            }
+        }
+        IDirectSoundFullDuplex_IDirectSoundCapture_AddRef(This->pDSC);
+        *ppobj = This->pDSC;
+        return S_OK;
+    }
 
-    *ppv = NULL;
     return E_NOINTERFACE;
 }
 
-static ULONG WINAPI IUnknownImpl_AddRef(IUnknown *iface)
+static ULONG WINAPI
+IDirectSoundFullDuplexImpl_Release( LPDIRECTSOUNDFULLDUPLEX iface )
 {
-    IDirectSoundFullDuplexImpl *This = impl_from_IUnknown(iface);
-    ULONG ref = InterlockedIncrement(&This->ref);
+    IDirectSoundFullDuplexImpl *This = (IDirectSoundFullDuplexImpl *)iface;
+    ULONG ref = InterlockedDecrement(&(This->ref));
+    TRACE("(%p) ref was %d\n", This, ref - 1);
 
-    TRACE("(%p) ref=%d\n", This, ref);
-
-    if(ref == 1)
-        InterlockedIncrement(&This->numIfaces);
+    if (!ref) {
+        if (This->capture_device)
+            IDirectSoundCapture_Release(This->capture_device);
+        if (This->renderer_device)
+            IDirectSound_Release(This->renderer_device);
+        HeapFree( GetProcessHeap(), 0, This );
+	TRACE("(%p) released\n", This);
+    }
     return ref;
 }
 
-static ULONG WINAPI IUnknownImpl_Release(IUnknown *iface)
+static HRESULT WINAPI
+IDirectSoundFullDuplexImpl_Initialize(
+    LPDIRECTSOUNDFULLDUPLEX iface,
+    LPCGUID pCaptureGuid,
+    LPCGUID pRendererGuid,
+    LPCDSCBUFFERDESC lpDscBufferDesc,
+    LPCDSBUFFERDESC lpDsBufferDesc,
+    HWND hWnd,
+    DWORD dwLevel,
+    LPLPDIRECTSOUNDCAPTUREBUFFER8 lplpDirectSoundCaptureBuffer8,
+    LPLPDIRECTSOUNDBUFFER8 lplpDirectSoundBuffer8 )
 {
-    IDirectSoundFullDuplexImpl *This = impl_from_IUnknown(iface);
-    ULONG ref = InterlockedDecrement(&This->ref);
-
-    TRACE("(%p) ref=%d\n", This, ref);
-
-    if (!ref && !InterlockedDecrement(&This->numIfaces))
-        fullduplex_destroy(This);
-    return ref;
-}
-
-static const IUnknownVtbl unk_vtbl =
-{
-    IUnknownImpl_QueryInterface,
-    IUnknownImpl_AddRef,
-    IUnknownImpl_Release
-};
-
-/***************************************************************************
- * IDirectSoundFullDuplex implementation
- */
-static inline IDirectSoundFullDuplexImpl *impl_from_IDirectSoundFullDuplex(IDirectSoundFullDuplex *iface)
-{
-    return CONTAINING_RECORD(iface, IDirectSoundFullDuplexImpl, IDirectSoundFullDuplex_iface);
-}
-
-static HRESULT WINAPI IDirectSoundFullDuplexImpl_QueryInterface(IDirectSoundFullDuplex *iface,
-        REFIID riid, void **ppv)
-{
-    IDirectSoundFullDuplexImpl *This = impl_from_IDirectSoundFullDuplex(iface);
-    TRACE("(%p,%s,%p)\n", This, debugstr_guid(riid), ppv);
-    return IUnknown_QueryInterface(&This->IUnknown_iface, riid, ppv);
-}
-
-static ULONG WINAPI IDirectSoundFullDuplexImpl_AddRef(IDirectSoundFullDuplex *iface)
-{
-    IDirectSoundFullDuplexImpl *This = impl_from_IDirectSoundFullDuplex(iface);
-    ULONG ref = InterlockedIncrement(&This->refdsfd);
-
-    TRACE("(%p) ref=%d\n", This, ref);
-
-    if(ref == 1)
-        InterlockedIncrement(&This->numIfaces);
-    return ref;
-}
-
-static ULONG WINAPI IDirectSoundFullDuplexImpl_Release(IDirectSoundFullDuplex *iface)
-{
-    IDirectSoundFullDuplexImpl *This = impl_from_IDirectSoundFullDuplex(iface);
-    ULONG ref = InterlockedDecrement(&This->refdsfd);
-
-    TRACE("(%p) ref=%d\n", This, ref);
-
-    if (!ref && !InterlockedDecrement(&This->numIfaces))
-        fullduplex_destroy(This);
-    return ref;
-}
-
-static HRESULT WINAPI IDirectSoundFullDuplexImpl_Initialize(IDirectSoundFullDuplex *iface,
-        const GUID *capture_dev, const GUID *render_dev, const DSCBUFFERDESC *cbufdesc,
-        const DSBUFFERDESC *bufdesc, HWND hwnd, DWORD level, IDirectSoundCaptureBuffer8 **dscb8,
-        IDirectSoundBuffer8 **dsb8)
-{
-    IDirectSoundFullDuplexImpl *This = impl_from_IDirectSoundFullDuplex(iface);
-    IDirectSound8 *ds8 = NULL;
-    IDirectSoundCapture8 *dsc8 = NULL;
     HRESULT hr;
+    IDirectSoundFullDuplexImpl *This = (IDirectSoundFullDuplexImpl *)iface;
 
-    TRACE("(%p,%s,%s,%p,%p,%p,%x,%p,%p)\n", This, debugstr_guid(capture_dev),
-            debugstr_guid(render_dev), cbufdesc, bufdesc, hwnd, level, dscb8, dsb8);
+    TRACE("(%p,%s,%s,%p,%p,%p,%x,%p,%p)\n", This,
+        debugstr_guid(pCaptureGuid), debugstr_guid(pRendererGuid),
+        lpDscBufferDesc, lpDsBufferDesc, hWnd, dwLevel,
+        lplpDirectSoundCaptureBuffer8, lplpDirectSoundBuffer8);
 
-    if (!dscb8 || !dsb8)
-        return E_INVALIDARG;
-
-    *dscb8 = NULL;
-    *dsb8 = NULL;
-
-    if (This->ds8_unk || This->dsc8_unk) {
+    if (This->renderer_device != NULL || This->capture_device != NULL) {
         WARN("already initialized\n");
+        *lplpDirectSoundCaptureBuffer8 = NULL;
+        *lplpDirectSoundBuffer8 = NULL;
         return DSERR_ALREADYINITIALIZED;
     }
 
-    hr = IDirectSoundImpl_Create(&This->IUnknown_iface, &IID_IUnknown, (void**)&This->ds8_unk,
-            TRUE);
-    if (SUCCEEDED(hr)) {
-        IUnknown_QueryInterface(This->ds8_unk, &IID_IDirectSound8, (void**)&ds8);
-        hr = IDirectSound_Initialize(ds8, render_dev);
-    }
+    hr = DSOUND_Create8(&IID_IDirectSound8, &This->renderer_device);
+    if (SUCCEEDED(hr))
+        hr = IDirectSound_Initialize(This->renderer_device, pRendererGuid);
     if (hr != DS_OK) {
-        WARN("Creating/initializing IDirectSound8 failed\n");
-        goto error;
+        WARN("DirectSoundDevice_Initialize() failed\n");
+        *lplpDirectSoundCaptureBuffer8 = NULL;
+        *lplpDirectSoundBuffer8 = NULL;
+        return hr;
     }
 
-    IDirectSound8_SetCooperativeLevel(ds8, hwnd, level);
+    IDirectSound8_SetCooperativeLevel(This->renderer_device, hWnd, dwLevel);
 
-    hr = IDirectSound8_CreateSoundBuffer(ds8, bufdesc, (IDirectSoundBuffer**)dsb8, NULL);
+    hr = IDirectSound8_CreateSoundBuffer(This->renderer_device, lpDsBufferDesc,
+        (IDirectSoundBuffer**)lplpDirectSoundBuffer8, NULL);
     if (hr != DS_OK) {
-        WARN("IDirectSoundBuffer_Create() failed\n");
-        goto error;
+        WARN("IDirectSoundBufferImpl_Create() failed\n");
+        *lplpDirectSoundCaptureBuffer8 = NULL;
+        *lplpDirectSoundBuffer8 = NULL;
+        return hr;
     }
 
-    hr = IDirectSoundCaptureImpl_Create(&This->IUnknown_iface, &IID_IUnknown,
-            (void**)&This->dsc8_unk, TRUE);
-    if (SUCCEEDED(hr)) {
-        IUnknown_QueryInterface(This->dsc8_unk, &IID_IDirectSoundCapture8, (void**)&dsc8);
-        hr = IDirectSoundCapture_Initialize(dsc8, capture_dev);
-    }
+    hr = DSOUND_CaptureCreate8(&IID_IDirectSoundCapture8, &This->capture_device);
+    if (SUCCEEDED(hr))
+        hr = IDirectSoundCapture_Initialize(This->capture_device, pCaptureGuid);
     if (hr != DS_OK) {
-        WARN("Creating/initializing IDirectSoundCapture8 failed\n");
-        goto error;
+        WARN("DirectSoundCaptureDevice_Initialize() failed\n");
+        *lplpDirectSoundCaptureBuffer8 = NULL;
+        *lplpDirectSoundBuffer8 = NULL;
+        return hr;
     }
 
-    hr = IDirectSoundCapture_CreateCaptureBuffer(dsc8, cbufdesc,
-            (IDirectSoundCaptureBuffer**)dscb8, NULL);
+    hr = IDirectSoundCapture_CreateCaptureBuffer(This->capture_device,
+        lpDscBufferDesc,
+        (IDirectSoundCaptureBuffer**)lplpDirectSoundCaptureBuffer8,
+        NULL);
     if (hr != DS_OK) {
-        WARN("IDirectSoundCapture_CreateCaptureBuffer() failed\n");
-        goto error;
+        WARN("IDirectSoundCaptureBufferImpl_Create() failed\n");
+        *lplpDirectSoundCaptureBuffer8 = NULL;
+        *lplpDirectSoundBuffer8 = NULL;
+        return hr;
     }
 
-    IDirectSound8_Release(ds8);
-    IDirectSoundCapture_Release(dsc8);
-    return DS_OK;
-
-error:
-    if (*dsb8) {
-        IDirectSoundBuffer8_Release(*dsb8);
-        *dsb8 = NULL;
-    }
-    if (ds8)
-        IDirectSound8_Release(ds8);
-    if (This->ds8_unk) {
-        IUnknown_Release(This->ds8_unk);
-        This->ds8_unk = NULL;
-    }
-    if (*dscb8) {
-        IDirectSoundCaptureBuffer8_Release(*dscb8);
-        *dscb8 = NULL;
-    }
-    if (dsc8)
-        IDirectSoundCapture_Release(dsc8);
-    if (This->dsc8_unk) {
-        IUnknown_Release(This->dsc8_unk);
-        This->dsc8_unk = NULL;
-    }
     return hr;
 }
 
-static const IDirectSoundFullDuplexVtbl dsfd_vtbl =
+static const IDirectSoundFullDuplexVtbl dsfdvt =
 {
     /* IUnknown methods */
     IDirectSoundFullDuplexImpl_QueryInterface,
@@ -261,32 +598,44 @@ static const IDirectSoundFullDuplexVtbl dsfd_vtbl =
     IDirectSoundFullDuplexImpl_Initialize
 };
 
-HRESULT DSOUND_FullDuplexCreate(REFIID riid, void **ppv)
+HRESULT DSOUND_FullDuplexCreate(
+    REFIID riid,
+    LPDIRECTSOUNDFULLDUPLEX* ppDSFD)
 {
-    IDirectSoundFullDuplexImpl *obj;
-    HRESULT hr;
+    IDirectSoundFullDuplexImpl *This = NULL;
+    TRACE("(%s, %p)\n", debugstr_guid(riid), ppDSFD);
 
-    TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
+    if (ppDSFD == NULL) {
+        WARN("invalid parameter: ppDSFD == NULL\n");
+        return DSERR_INVALIDPARAM;
+    }
 
-    *ppv = NULL;
-    obj = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*obj));
-    if (!obj) {
+    if (!IsEqualIID(riid, &IID_IUnknown) &&
+        !IsEqualIID(riid, &IID_IDirectSoundFullDuplex)) {
+        *ppDSFD = 0;
+        return E_NOINTERFACE;
+    }
+
+    /* Get dsound configuration */
+    setup_dsound_options();
+
+    This = HeapAlloc(GetProcessHeap(),
+        HEAP_ZERO_MEMORY, sizeof(IDirectSoundFullDuplexImpl));
+
+    if (This == NULL) {
         WARN("out of memory\n");
+        *ppDSFD = NULL;
         return DSERR_OUTOFMEMORY;
     }
 
-    setup_dsound_options();
+    This->lpVtbl = &dsfdvt;
+    This->ref = 1;
+    This->capture_device = NULL;
+    This->renderer_device = NULL;
 
-    obj->IDirectSoundFullDuplex_iface.lpVtbl = &dsfd_vtbl;
-    obj->IUnknown_iface.lpVtbl = &unk_vtbl;
-    obj->ref = 1;
-    obj->refdsfd = 0;
-    obj->numIfaces = 1;
+    *ppDSFD = (LPDIRECTSOUNDFULLDUPLEX)This;
 
-    hr = IUnknown_QueryInterface(&obj->IUnknown_iface, riid, ppv);
-    IUnknown_Release(&obj->IUnknown_iface);
-
-    return hr;
+    return DS_OK;
 }
 
 /***************************************************************************
@@ -295,50 +644,93 @@ HRESULT DSOUND_FullDuplexCreate(REFIID riid, void **ppv)
  * Create and initialize a DirectSoundFullDuplex interface.
  *
  * PARAMS
- *    capture_dev         [I] Address of sound capture device GUID.
- *    render_dev          [I] Address of sound render device GUID.
- *    cbufdesc            [I] Address of capture buffer description.
- *    bufdesc             [I] Address of  render buffer description.
- *    hwnd                [I] Handle to application window.
- *    level               [I] Cooperative level.
- *    dsfd                [O] Address where full duplex interface returned.
- *    dscb8               [0] Address where capture buffer interface returned.
- *    dsb8                [0] Address where render buffer interface returned.
- *    outer_unk           [I] Must be NULL.
+ *    pcGuidCaptureDevice [I] Address of sound capture device GUID.
+ *    pcGuidRenderDevice  [I] Address of sound render device GUID.
+ *    pcDSCBufferDesc     [I] Address of capture buffer description.
+ *    pcDSBufferDesc      [I] Address of  render buffer description.
+ *    hWnd                [I] Handle to application window.
+ *    dwLevel             [I] Cooperative level.
+ *    ppDSFD              [O] Address where full duplex interface returned.
+ *    ppDSCBuffer8        [0] Address where capture buffer interface returned.
+ *    ppDSBuffer8         [0] Address where render buffer interface returned.
+ *    pUnkOuter           [I] Must be NULL.
  *
  * RETURNS
  *    Success: DS_OK
  *    Failure: DSERR_NOAGGREGATION, DSERR_ALLOCATED, DSERR_INVALIDPARAM,
  *             DSERR_OUTOFMEMORY DSERR_INVALIDCALL DSERR_NODRIVER
  */
-HRESULT WINAPI DirectSoundFullDuplexCreate(const GUID *capture_dev, const GUID *render_dev,
-        const DSCBUFFERDESC *cbufdesc, const DSBUFFERDESC *bufdesc, HWND hwnd, DWORD level,
-        IDirectSoundFullDuplex **dsfd, IDirectSoundCaptureBuffer8 **dscb8,
-        IDirectSoundBuffer8 **dsb8, IUnknown *outer_unk)
+HRESULT WINAPI
+DirectSoundFullDuplexCreate(
+    LPCGUID pcGuidCaptureDevice,
+    LPCGUID pcGuidRenderDevice,
+    LPCDSCBUFFERDESC pcDSCBufferDesc,
+    LPCDSBUFFERDESC pcDSBufferDesc,
+    HWND hWnd,
+    DWORD dwLevel,
+    LPDIRECTSOUNDFULLDUPLEX *ppDSFD,
+    LPDIRECTSOUNDCAPTUREBUFFER8 *ppDSCBuffer8,
+    LPDIRECTSOUNDBUFFER8 *ppDSBuffer8,
+    LPUNKNOWN pUnkOuter)
 {
-    HRESULT hr;
+    HRESULT hres;
+    IDirectSoundFullDuplexImpl *This = NULL;
+    TRACE("(%s,%s,%p,%p,%p,%x,%p,%p,%p,%p)\n",
+        debugstr_guid(pcGuidCaptureDevice), debugstr_guid(pcGuidRenderDevice),
+        pcDSCBufferDesc, pcDSBufferDesc, hWnd, dwLevel, ppDSFD, ppDSCBuffer8,
+        ppDSBuffer8, pUnkOuter);
 
-    TRACE("(%s,%s,%p,%p,%p,%x,%p,%p,%p,%p)\n", debugstr_guid(capture_dev),
-            debugstr_guid(render_dev), cbufdesc, bufdesc, hwnd, level, dsfd, dscb8, dsb8,
-            outer_unk);
-
-    if (!dsfd)
-        return DSERR_INVALIDPARAM;
-    if (outer_unk) {
-        *dsfd = NULL;
+    if (pUnkOuter) {
+        WARN("pUnkOuter != 0\n");
+        *ppDSFD = NULL;
         return DSERR_NOAGGREGATION;
     }
 
-    hr = DSOUND_FullDuplexCreate(&IID_IDirectSoundFullDuplex, (void**)dsfd);
-    if (hr == DS_OK) {
-        hr = IDirectSoundFullDuplex_Initialize(*dsfd, capture_dev, render_dev, cbufdesc, bufdesc,
-                hwnd, level, dscb8, dsb8);
-        if (hr != DS_OK) {
-            IDirectSoundFullDuplex_Release(*dsfd);
-            *dsfd = NULL;
-            WARN("IDirectSoundFullDuplexImpl_Initialize failed\n");
-        }
+    if (pcDSCBufferDesc == NULL) {
+        WARN("invalid parameter: pcDSCBufferDesc == NULL\n");
+        *ppDSFD = NULL;
+        return DSERR_INVALIDPARAM;
     }
 
-    return hr;
+    if (pcDSBufferDesc == NULL) {
+        WARN("invalid parameter: pcDSBufferDesc == NULL\n");
+        *ppDSFD = NULL;
+        return DSERR_INVALIDPARAM;
+    }
+
+    if (ppDSFD == NULL) {
+        WARN("invalid parameter: ppDSFD == NULL\n");
+        return DSERR_INVALIDPARAM;
+    }
+
+    if (ppDSCBuffer8 == NULL) {
+        WARN("invalid parameter: ppDSCBuffer8 == NULL\n");
+        *ppDSFD = NULL;
+        return DSERR_INVALIDPARAM;
+    }
+
+    if (ppDSBuffer8 == NULL) {
+        WARN("invalid parameter: ppDSBuffer8 == NULL\n");
+        *ppDSFD = NULL;
+        return DSERR_INVALIDPARAM;
+    }
+
+    hres = DSOUND_FullDuplexCreate(&IID_IDirectSoundFullDuplex, (LPDIRECTSOUNDFULLDUPLEX*)&This);
+    if (FAILED(hres)) return hres;
+
+    hres = IDirectSoundFullDuplexImpl_Initialize((LPDIRECTSOUNDFULLDUPLEX)This,
+                                                 pcGuidCaptureDevice,
+                                                 pcGuidRenderDevice,
+                                                 pcDSCBufferDesc,
+                                                 pcDSBufferDesc,
+                                                 hWnd, dwLevel, ppDSCBuffer8,
+                                                 ppDSBuffer8);
+    if (hres != DS_OK) {
+        IUnknown_Release((LPDIRECTSOUNDFULLDUPLEX)This);
+        WARN("IDirectSoundFullDuplexImpl_Initialize failed\n");
+        *ppDSFD = NULL;
+    } else
+        *ppDSFD = (LPDIRECTSOUNDFULLDUPLEX)This;
+
+    return hres;
 }

dll/directx/wine/dsound/guid.c

@@ -1,18 +1,13 @@
 /* DO NOT USE THE PRECOMPILED HEADER FOR THIS FILE! */
 
-#include <stdarg.h>
-
 #define WIN32_NO_STATUS
 #define _INC_WINDOWS
 #define COM_NO_WINDOWS_H
 
 #include <windef.h>
-#include <winbase.h>
-#include <wingdi.h>
-#include <objbase.h>
+#include <mmddk.h>
+#include <dsound.h>
 #include <initguid.h>
-#include <mmdeviceapi.h>
-#include <audioclient.h>
-#include <devpkey.h>
+#include <dsdriver.h>
 
 /* NO CODE HERE, THIS IS JUST REQUIRED FOR THE GUID DEFINITIONS */

dll/directx/wine/dsound/propset.c

@@ -21,8 +21,6 @@
 
 #include "dsound_private.h"
 
-static WCHAR wInterface[] = { 'I','n','t','e','r','f','a','c','e',0 };
-
 typedef struct IKsPrivatePropertySetImpl
 {
     IKsPropertySet IKsPropertySet_iface;
@@ -40,7 +38,9 @@ static IKsPrivatePropertySetImpl *impl_from_IKsPropertySet(IKsPropertySet *iface
 
 /* IUnknown methods */
 static HRESULT WINAPI IKsPrivatePropertySetImpl_QueryInterface(
-        IKsPropertySet *iface, REFIID riid, void **ppobj)
+    LPKSPROPERTYSET iface,
+    REFIID riid,
+    LPVOID *ppobj )
 {
     IKsPrivatePropertySetImpl *This = impl_from_IKsPropertySet(iface);
     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
@@ -48,7 +48,7 @@ static HRESULT WINAPI IKsPrivatePropertySetImpl_QueryInterface(
     if (IsEqualIID(riid, &IID_IUnknown) ||
         IsEqualIID(riid, &IID_IKsPropertySet)) {
         *ppobj = iface;
-        IKsPropertySet_AddRef(iface);
+        IUnknown_AddRef(iface);
         return S_OK;
     }
     *ppobj = NULL;
@@ -76,61 +76,67 @@ static ULONG WINAPI IKsPrivatePropertySetImpl_Release(LPKSPROPERTYSET iface)
     return ref;
 }
 
-struct search_data {
-    const WCHAR *tgt_name;
-    GUID *found_guid;
-};
-
-static BOOL CALLBACK search_callback(GUID *guid, const WCHAR *desc,
-        const WCHAR *module, void *user)
-{
-    struct search_data *search = user;
-
-    if(!lstrcmpW(desc, search->tgt_name)){
-        *search->found_guid = *guid;
-        return FALSE;
-    }
-
-    return TRUE;
-}
-
 static HRESULT DSPROPERTY_WaveDeviceMappingW(
     LPVOID pPropData,
     ULONG cbPropData,
     PULONG pcbReturned )
 {
-    HRESULT hr;
-    PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA ppd = pPropData;
-    struct search_data search;
-
+    HRESULT hr = DSERR_INVALIDPARAM;
+    PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA ppd;
     TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
-          pPropData,cbPropData,pcbReturned);
+	  pPropData,cbPropData,pcbReturned);
+
+    ppd = pPropData;
 
     if (!ppd) {
-        WARN("invalid parameter: pPropData\n");
-        return DSERR_INVALIDPARAM;
+	WARN("invalid parameter: pPropData\n");
+	return DSERR_INVALIDPARAM;
     }
 
-    search.tgt_name = ppd->DeviceName;
-    search.found_guid = &ppd->DeviceId;
-
-    if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER)
-        hr = enumerate_mmdevices(eRender, DSOUND_renderer_guids,
-                search_callback, &search);
-    else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE)
-        hr = enumerate_mmdevices(eCapture, DSOUND_capture_guids,
-                search_callback, &search);
-    else
-        return DSERR_INVALIDPARAM;
-
-    if(hr != S_FALSE)
-        /* device was not found */
-        return DSERR_INVALIDPARAM;
+    if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
+        ULONG wod;
+        unsigned int wodn;
+        TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
+        wodn = waveOutGetNumDevs();
+        for (wod = 0; wod < wodn; wod++) {
+            WAVEOUTCAPSW capsW;
+            MMRESULT res;
+            res = waveOutGetDevCapsW(wod, &capsW, sizeof(capsW));
+            if (res == MMSYSERR_NOERROR) {
+                if (lstrcmpW(capsW.szPname, ppd->DeviceName) == 0) {
+                    ppd->DeviceId = DSOUND_renderer_guids[wod];
+                    hr = DS_OK;
+                    TRACE("found %s for %s\n", debugstr_guid(&ppd->DeviceId),
+                          debugstr_w(ppd->DeviceName));
+                    break;
+                }
+            }
+        }
+    } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
+        ULONG wid;
+        unsigned int widn;
+        TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
+        widn = waveInGetNumDevs();
+        for (wid = 0; wid < widn; wid++) {
+            WAVEINCAPSW capsW;
+            MMRESULT res;
+            res = waveInGetDevCapsW(wid, &capsW, sizeof(capsW));
+            if (res == MMSYSERR_NOERROR) {
+                if (lstrcmpW(capsW.szPname, ppd->DeviceName) == 0) {
+                    ppd->DeviceId = DSOUND_capture_guids[wid];
+                    hr = DS_OK;
+                    TRACE("found %s for %s\n", debugstr_guid(&ppd->DeviceId),
+                          debugstr_w(ppd->DeviceName));
+                    break;
+                }
+            }
+        }
+    }
 
     if (pcbReturned)
         *pcbReturned = cbPropData;
 
-    return DS_OK;
+    return hr;
 }
 
 static HRESULT DSPROPERTY_WaveDeviceMappingA(
@@ -174,12 +180,10 @@ static HRESULT DSPROPERTY_DescriptionW(
     PULONG pcbReturned )
 {
     PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA ppd = pPropData;
+    HRESULT err;
     GUID dev_guid;
-    IMMDevice *mmdevice;
-    IPropertyStore *ps;
-    PROPVARIANT pv;
-    DWORD desclen;
-    HRESULT hr;
+    ULONG wod, wid, wodn, widn;
+    DSDRIVERDESC desc;
 
     TRACE("pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
           pPropData,cbPropData,pcbReturned);
@@ -203,41 +207,63 @@ static HRESULT DSPROPERTY_DescriptionW(
 
     GetDeviceID(&ppd->DeviceId, &dev_guid);
 
-    hr = get_mmdevice(eRender, &dev_guid, &mmdevice);
-    if(FAILED(hr)){
-        hr = get_mmdevice(eCapture, &dev_guid, &mmdevice);
-        if(FAILED(hr))
-            return hr;
+    wodn = waveOutGetNumDevs();
+    widn = waveInGetNumDevs();
+    wid = wod = dev_guid.Data4[7];
+    if (!memcmp(&dev_guid, &DSOUND_renderer_guids[0], sizeof(GUID)-1)
+        && wod < wodn)
+    {
+        ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
+        ppd->WaveDeviceId = wod;
+    }
+    else if (!memcmp(&dev_guid, &DSOUND_capture_guids[0], sizeof(GUID)-1)
+             && wid < widn)
+    {
+        ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
+        ppd->WaveDeviceId = wid;
+    }
+    else
+    {
+        WARN("Device not found\n");
+        return E_PROP_ID_UNSUPPORTED;
     }
 
-    hr = IMMDevice_OpenPropertyStore(mmdevice, STGM_READ, &ps);
-    if(FAILED(hr)){
-        IMMDevice_Release(mmdevice);
-        WARN("OpenPropertyStore failed: %08x\n", hr);
-        return hr;
+    if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER)
+        err = waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,ds_hw_accel);
+    else
+        err = waveInMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,ds_hw_accel);
+
+    if (err != MMSYSERR_NOERROR)
+    {
+        WARN("waveMessage(DRV_QUERYDSOUNDDESC) failed!\n");
+        return E_PROP_ID_UNSUPPORTED;
+    }
+    else
+    {
+        /* FIXME: Still a memory leak.. */
+        int desclen, modlen;
+        static WCHAR wInterface[] = { 'I','n','t','e','r','f','a','c','e',0 };
+
+        modlen = MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, NULL, 0 );
+        desclen = MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, NULL, 0 );
+        ppd->Module = HeapAlloc(GetProcessHeap(),0,modlen*sizeof(WCHAR));
+        ppd->Description = HeapAlloc(GetProcessHeap(),0,desclen*sizeof(WCHAR));
+        ppd->Interface = wInterface;
+        if (!ppd->Description || !ppd->Module)
+        {
+            WARN("Out of memory\n");
+            HeapFree(GetProcessHeap(), 0, ppd->Description);
+            HeapFree(GetProcessHeap(), 0, ppd->Module);
+            ppd->Description = ppd->Module = NULL;
+            return E_OUTOFMEMORY;
+        }
+
+        MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, ppd->Module, modlen );
+        MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->Description, desclen );
     }
 
-    hr = IPropertyStore_GetValue(ps,
-            (const PROPERTYKEY *)&DEVPKEY_Device_FriendlyName, &pv);
-    if(FAILED(hr)){
-        IPropertyStore_Release(ps);
-        IMMDevice_Release(mmdevice);
-        WARN("GetValue(FriendlyName) failed: %08x\n", hr);
-        return hr;
-    }
-
-    desclen = lstrlenW(pv.u.pwszVal) + 1;
-    /* FIXME: Still a memory leak.. */
-    ppd->Description = HeapAlloc(GetProcessHeap(), 0, desclen * sizeof(WCHAR));
-    memcpy(ppd->Description, pv.u.pwszVal, desclen * sizeof(WCHAR));
-    ppd->Module = wine_vxd_drv;
-    ppd->Interface = wInterface;
     ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
 
-    PropVariantClear(&pv);
-    IPropertyStore_Release(ps);
-    IMMDevice_Release(mmdevice);
-
     if (pcbReturned) {
         *pcbReturned = sizeof(*ppd);
         TRACE("*pcbReturned=%d\n", *pcbReturned);
@@ -246,49 +272,15 @@ static HRESULT DSPROPERTY_DescriptionW(
     return S_OK;
 }
 
-static
-BOOL CALLBACK enum_callback(GUID *guid, const WCHAR *desc, const WCHAR *module,
-        void *user)
-{
-    PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA ppd = user;
-    DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA data;
-    DWORD len;
-    BOOL ret;
-
-    TRACE("%s %s %s %p\n", wine_dbgstr_guid(guid), wine_dbgstr_w(desc),
-            wine_dbgstr_w(module), user);
-
-    if(!guid)
-        return TRUE;
-
-    data.DeviceId = *guid;
-
-    len = lstrlenW(module) + 1;
-    data.Module = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
-    memcpy(data.Module, module, len * sizeof(WCHAR));
-
-    len = lstrlenW(desc) + 1;
-    data.Description = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
-    memcpy(data.Description, desc, len * sizeof(WCHAR));
-
-    data.Interface = wInterface;
-
-    ret = ppd->Callback(&data, ppd->Context);
-
-    HeapFree(GetProcessHeap(), 0, data.Module);
-    HeapFree(GetProcessHeap(), 0, data.Description);
-
-    return ret;
-}
-
 static HRESULT DSPROPERTY_EnumerateW(
     LPVOID pPropData,
     ULONG cbPropData,
     PULONG pcbReturned )
 {
     PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA ppd = pPropData;
-    HRESULT hr;
-
+    DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA data;
+    BOOL ret;
+    int widn, wodn, i;
     TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
           pPropData,cbPropData,pcbReturned);
 
@@ -301,14 +293,45 @@ static HRESULT DSPROPERTY_EnumerateW(
         return E_PROP_ID_UNSUPPORTED;
     }
 
-    hr = enumerate_mmdevices(eRender, DSOUND_renderer_guids,
-            enum_callback, ppd);
+    wodn = waveOutGetNumDevs();
+    widn = waveInGetNumDevs();
 
-    if(hr == S_OK)
-        hr = enumerate_mmdevices(eCapture, DSOUND_capture_guids,
-                enum_callback, ppd);
+    data.DeviceId = DSOUND_renderer_guids[0];
+    for (i = 0; i < wodn; ++i)
+    {
+        HRESULT hr;
+        data.DeviceId.Data4[7] = i;
+        hr = DSPROPERTY_DescriptionW(&data, sizeof(data), NULL);
+        if (FAILED(hr))
+        {
+            ERR("DescriptionW failed!\n");
+            return S_OK;
+        }
+        ret = ppd->Callback(&data, ppd->Context);
+        HeapFree(GetProcessHeap(), 0, data.Module);
+        HeapFree(GetProcessHeap(), 0, data.Description);
+        if (!ret)
+            return S_OK;
+    }
 
-    return SUCCEEDED(hr) ? DS_OK : hr;
+    data.DeviceId = DSOUND_capture_guids[0];
+    for (i = 0; i < widn; ++i)
+    {
+        HRESULT hr;
+        data.DeviceId.Data4[7] = i;
+        hr = DSPROPERTY_DescriptionW(&data, sizeof(data), NULL);
+        if (FAILED(hr))
+        {
+            ERR("DescriptionW failed!\n");
+            return S_OK;
+        }
+        ret = ppd->Callback(&data, ppd->Context);
+        HeapFree(GetProcessHeap(), 0, data.Module);
+        HeapFree(GetProcessHeap(), 0, data.Description);
+        if (!ret)
+            return S_OK;
+    }
+    return S_OK;
 }
 
 static BOOL DSPROPERTY_descWtoA(const DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA *dataW,
@@ -589,24 +612,23 @@ static const IKsPropertySetVtbl ikspvt = {
     IKsPrivatePropertySetImpl_QuerySupport
 };
 
-HRESULT IKsPrivatePropertySetImpl_Create(REFIID riid, void **ppv)
+HRESULT IKsPrivatePropertySetImpl_Create(
+    REFIID riid,
+    IKsPropertySet **piks)
 {
     IKsPrivatePropertySetImpl *iks;
-    HRESULT hr;
+    TRACE("(%s, %p)\n", debugstr_guid(riid), piks);
 
-    TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
-
-    iks = HeapAlloc(GetProcessHeap(), 0, sizeof(*iks));
-    if (!iks) {
-        WARN("out of memory\n");
-        return DSERR_OUTOFMEMORY;
+    if (!IsEqualIID(riid, &IID_IUnknown) &&
+        !IsEqualIID(riid, &IID_IKsPropertySet)) {
+        *piks = 0;
+        return E_NOINTERFACE;
     }
 
+    iks = HeapAlloc(GetProcessHeap(),0,sizeof(*iks));
     iks->ref = 1;
     iks->IKsPropertySet_iface.lpVtbl = &ikspvt;
 
-    hr = IKsPropertySet_QueryInterface(&iks->IKsPropertySet_iface, riid, ppv);
-    IKsPropertySet_Release(&iks->IKsPropertySet_iface);
-
-    return hr;
+    *piks = &iks->IKsPropertySet_iface;
+    return S_OK;
 }

dll/win32/CMakeLists.txt

@@ -84,6 +84,7 @@ add_subdirectory(mcicda)
 add_subdirectory(mciqtz32)
 add_subdirectory(mciseq)
 add_subdirectory(mciwave)
+add_subdirectory(mgmtapi)
 add_subdirectory(mlang)
 add_subdirectory(mmdevapi)
 add_subdirectory(mmdrv)

dll/win32/localui/lang/ui_Da.rc

@@ -16,12 +16,21 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
 
 LANGUAGE LANG_DANISH, SUBLANG_DEFAULT
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "Lokal port"
+    IDS_INVALIDNAME "'%s' er ikke et gyldigt port navn"
+    IDS_PORTEXISTS "Porten %s findes allerede"
+    IDS_NOTHINGTOCONFIG "Denne port har ingen indstillinger"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "Opret en lokal port"
@@ -29,8 +38,8 @@ FONT 8, "MS Shell Dlg"
 BEGIN
     LTEXT "&Skriv navnet på den nye port:", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "OK", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "Annuller", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "OK", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "Annuller", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -45,12 +54,3 @@ BEGIN
     DEFPUSHBUTTON "OK", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "Annuller", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "Lokal port"
-    IDS_INVALIDNAME "'%s' er ikke et gyldigt port navn"
-    IDS_PORTEXISTS "Porten %s findes allerede"
-    IDS_NOTHINGTOCONFIG "Denne port har ingen indstillinger"
-}

dll/win32/localui/lang/ui_De.rc

@@ -16,6 +16,7 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
@@ -24,6 +25,14 @@
 
 LANGUAGE LANG_GERMAN, SUBLANG_NEUTRAL
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "Lokaler Anschluss"
+    IDS_INVALIDNAME "'%s' ist kein gültiger Anschlussname"
+    IDS_PORTEXISTS "Der Anschluss %s existiert bereits"
+    IDS_NOTHINGTOCONFIG "Dieser Anschluss besitzt keine zu konfigurierenden Optionen"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "Lokalen Anschluss hinzufügen"
@@ -47,12 +56,3 @@ BEGIN
     DEFPUSHBUTTON "OK", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "Abbrechen", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "Lokaler Anschluss"
-    IDS_INVALIDNAME "'%s' ist kein gültiger Anschlussname"
-    IDS_PORTEXISTS "Der Anschluss %s existiert bereits"
-    IDS_NOTHINGTOCONFIG "Dieser Anschluss besitzt keine zu konfigurierenden Optionen"
-}

dll/win32/localui/lang/ui_En.rc

@@ -16,12 +16,21 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
 
 LANGUAGE LANG_ENGLISH, SUBLANG_DEFAULT
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "Local Port"
+    IDS_INVALIDNAME "'%s' is not a valid port name"
+    IDS_PORTEXISTS "Port %s already exists"
+    IDS_NOTHINGTOCONFIG "This port has no options to configure"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "Add a Local Port"
@@ -29,8 +38,8 @@ FONT 8, "MS Shell Dlg"
 BEGIN
     LTEXT "&Enter the port name to add:", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "OK", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "Cancel", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "OK", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "Cancel", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -45,12 +54,3 @@ BEGIN
     DEFPUSHBUTTON "OK", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "Cancel", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "Local Port"
-    IDS_INVALIDNAME "'%s' is not a valid port name"
-    IDS_PORTEXISTS "Port %s already exists"
-    IDS_NOTHINGTOCONFIG "This port has no options to configure"
-}

dll/win32/localui/lang/ui_Es.rc

@@ -16,6 +16,7 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
@@ -24,6 +25,14 @@
 
 LANGUAGE LANG_SPANISH, SUBLANG_NEUTRAL
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "Puerto local"
+    IDS_INVALIDNAME "'%s' no es un nombre de puerto válido"
+    IDS_PORTEXISTS "El puerto %s ya existe"
+    IDS_NOTHINGTOCONFIG "Este puerto no tiene opciones para configurar"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "Agregar un puerto local"
@@ -31,8 +40,8 @@ FONT 8, "MS Shell Dlg"
 BEGIN
     LTEXT "&Ingrese el nombre del puerto a agregar:", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "Aceptar", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "Cancelar", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "Aceptar", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "Cancelar", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -47,12 +56,3 @@ BEGIN
     DEFPUSHBUTTON "Aceptar", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "Cancelar", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "Puerto local"
-    IDS_INVALIDNAME "'%s' no es un nombre de puerto válido"
-    IDS_PORTEXISTS "El puerto %s ya existe"
-    IDS_NOTHINGTOCONFIG "Este puerto no tiene opciones para configurar"
-}

dll/win32/localui/lang/ui_Fr.rc

@@ -16,6 +16,7 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
@@ -24,6 +25,14 @@
 
 LANGUAGE LANG_FRENCH, SUBLANG_NEUTRAL
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "Port local"
+    IDS_INVALIDNAME "« %s » n'est pas un nom de port valide"
+    IDS_PORTEXISTS "Le port %s existe déjà"
+    IDS_NOTHINGTOCONFIG "Ce port n'a pas d'options de configuration"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "Ajouter un port local"
@@ -31,8 +40,8 @@ FONT 8, "MS Shell Dlg"
 BEGIN
     LTEXT "&Saisisser le nom du port à ajouter :", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "OK", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "Annuler", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "OK", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "Annuler", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -47,12 +56,3 @@ BEGIN
     DEFPUSHBUTTON "OK", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "Annuler", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "Port local"
-    IDS_INVALIDNAME "« %s » n'est pas un nom de port valide"
-    IDS_PORTEXISTS "Le port %s existe déjà"
-    IDS_NOTHINGTOCONFIG "Ce port n'a pas d'options de configuration"
-}

dll/win32/localui/lang/ui_He.rc

@@ -18,12 +18,21 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
 
 LANGUAGE LANG_HEBREW, SUBLANG_DEFAULT
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "יציאה מקומית"
+    IDS_INVALIDNAME "'%s' אינו שם יציאה חוקי"
+    IDS_PORTEXISTS "יציאה %s כבר קיימת"
+    IDS_NOTHINGTOCONFIG "ליציאה הזו אין אפשרויות להגדיר"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "הוסף יציאה מקומית"
@@ -31,8 +40,8 @@ FONT 8, "MS Shell Dlg"
 BEGIN
     LTEXT "הזן את שם היציאה כדי להוסיפה:", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "אישור", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "ביטול", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "אישור", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "ביטול", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -47,12 +56,3 @@ BEGIN
     DEFPUSHBUTTON "אישור", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "ביטול", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "יציאה מקומית"
-    IDS_INVALIDNAME "'%s' אינו שם יציאה חוקי"
-    IDS_PORTEXISTS "יציאה %s כבר קיימת"
-    IDS_NOTHINGTOCONFIG "ליציאה הזו אין אפשרויות להגדיר"
-}

dll/win32/localui/lang/ui_Hu.rc

@@ -16,6 +16,7 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
@@ -25,6 +26,14 @@
 
 LANGUAGE LANG_HUNGARIAN, SUBLANG_DEFAULT
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "Helyi port"
+    IDS_INVALIDNAME "A(z) '%s' nem egy érvényes portnév"
+    IDS_PORTEXISTS "A port: %s már létezik"
+    IDS_NOTHINGTOCONFIG "Ennek a portnak nincsenek beállítható tulajdonságai"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "Helyi port hozzáadása"
@@ -32,8 +41,8 @@ FONT 8, "MS Shell Dlg"
 BEGIN
     LTEXT "Adja meg a &hozzáadni kívánt port nevét:", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "OK", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "Mégse", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "OK", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "Mégse", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -48,12 +57,3 @@ BEGIN
     DEFPUSHBUTTON "OK", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "Mégse", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "Helyi port"
-    IDS_INVALIDNAME "A(z) '%s' nem egy érvényes portnév"
-    IDS_PORTEXISTS "A port: %s már létezik"
-    IDS_NOTHINGTOCONFIG "Ennek a portnak nincsenek beállítható tulajdonságai"
-}

dll/win32/localui/lang/ui_It.rc

@@ -17,6 +17,7 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
@@ -26,6 +27,14 @@
 
 LANGUAGE LANG_ITALIAN, SUBLANG_NEUTRAL
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "Porta locale"
+    IDS_INVALIDNAME "'%s' non è un nome di porta valido"
+    IDS_PORTEXISTS "La porta %s già esiste"
+    IDS_NOTHINGTOCONFIG "Questa porta non ha opzioni da configurare"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "Aggiungi una porta locale"
@@ -33,8 +42,8 @@ FONT 8, "MS Shell Dlg"
 BEGIN
     LTEXT "&Inserisci il nome della porta da aggiungere:", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "OK", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "Annulla", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "OK", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "Annulla", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -49,12 +58,3 @@ BEGIN
     DEFPUSHBUTTON "OK", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "Annulla", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "Porta locale"
-    IDS_INVALIDNAME "'%s' non è un nome di porta valido"
-    IDS_PORTEXISTS "La porta %s già esiste"
-    IDS_NOTHINGTOCONFIG "Questa porta non ha opzioni da configurare"
-}

dll/win32/localui/lang/ui_Ja.rc

@@ -16,6 +16,7 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
@@ -25,6 +26,14 @@
 
 LANGUAGE LANG_JAPANESE, SUBLANG_DEFAULT
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "ローカル ポート"
+    IDS_INVALIDNAME "'%s' はポート名として正しくありません"
+    IDS_PORTEXISTS "ポート %s はすでに存在します"
+    IDS_NOTHINGTOCONFIG "このポートには設定項目がありません"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "ローカル ポートの追加"
@@ -32,8 +41,8 @@ FONT 8, "MS Shell Dlg"
 BEGIN
     LTEXT "追加するポートの名前(&E):", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "OK", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "キャンセル", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "OK", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "キャンセル", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -48,12 +57,3 @@ BEGIN
     DEFPUSHBUTTON "OK", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "キャンセル", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "ローカル ポート"
-    IDS_INVALIDNAME "'%s' はポート名として正しくありません"
-    IDS_PORTEXISTS "ポート %s はすでに存在します"
-    IDS_NOTHINGTOCONFIG "このポートには設定項目がありません"
-}

dll/win32/localui/lang/ui_Ko.rc

@@ -17,12 +17,21 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
 
 LANGUAGE LANG_KOREAN, SUBLANG_DEFAULT
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "지역 포트"
+    IDS_INVALIDNAME "'%s'는 올바른 포트 이름이 아닙니다"
+    IDS_PORTEXISTS "포트 %s는 이미 존재합니다"
+    IDS_NOTHINGTOCONFIG "이 포트는 설정할 옵션이 없습니다"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "지역 포트 더하기"
@@ -30,8 +39,8 @@ FONT 9, "MS Shell Dlg"
 BEGIN
     LTEXT "더할 포트 이름 입력(&E):", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "확인", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "취소", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "확인", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "취소", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -46,12 +55,3 @@ BEGIN
     DEFPUSHBUTTON "확인", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "취소", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "지역 포트"
-    IDS_INVALIDNAME "'%s'는 올바른 포트 이름이 아닙니다"
-    IDS_PORTEXISTS "포트 %s는 이미 존재합니다"
-    IDS_NOTHINGTOCONFIG "이 포트는 설정할 옵션이 없습니다"
-}

dll/win32/localui/lang/ui_Lt.rc

@@ -16,6 +16,7 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
@@ -25,6 +26,14 @@
 
 LANGUAGE LANG_LITHUANIAN, SUBLANG_NEUTRAL
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "Vietinis prievadas"
+    IDS_INVALIDNAME "„%s“ yra netinkamas prievado vardas"
+    IDS_PORTEXISTS "Prievadas %s jau egzistuoja"
+    IDS_NOTHINGTOCONFIG "Šis prievadas neturi parinkčių konfigūravimui"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "Pridėti vietinį prievadą"
@@ -32,8 +41,8 @@ FONT 8, "MS Shell Dlg"
 BEGIN
     LTEXT "&Įveskite pridedamo prievado vardą:", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "Gerai", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "Atsisakyti", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "Gerai", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "Atsisakyti", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -48,12 +57,3 @@ BEGIN
     DEFPUSHBUTTON "Gerai", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "Atsisakyti", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "Vietinis prievadas"
-    IDS_INVALIDNAME "„%s“ yra netinkamas prievado vardas"
-    IDS_PORTEXISTS "Prievadas %s jau egzistuoja"
-    IDS_NOTHINGTOCONFIG "Šis prievadas neturi parinkčių konfigūravimui"
-}

dll/win32/localui/lang/ui_Nl.rc

@@ -16,12 +16,21 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
 
 LANGUAGE LANG_DUTCH, SUBLANG_NEUTRAL
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "Lokale Poort"
+    IDS_INVALIDNAME "'%s' is geen valide poort naam"
+    IDS_PORTEXISTS "Poort %s bestaat reeds"
+    IDS_NOTHINGTOCONFIG "Deze poort heeft geen opties om in te stellen"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "Voeg een Lokale Poort toe"
@@ -29,8 +38,8 @@ FONT 8, "MS Shell Dlg"
 BEGIN
     LTEXT "&Voer de toe te voegen poort naam in:", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "OK", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "Annuleren", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "OK", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "Annuleren", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -45,12 +54,3 @@ BEGIN
     DEFPUSHBUTTON "OK", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "Annuleren", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "Lokale Poort"
-    IDS_INVALIDNAME "'%s' is geen valide poort naam"
-    IDS_PORTEXISTS "Poort %s bestaat reeds"
-    IDS_NOTHINGTOCONFIG "Deze poort heeft geen opties om in te stellen"
-}

dll/win32/localui/lang/ui_No.rc

@@ -16,12 +16,21 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
 
 LANGUAGE LANG_NORWEGIAN, SUBLANG_NORWEGIAN_BOKMAL
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "Lokal port"
+    IDS_INVALIDNAME "«%s» er ikke et gyldig portnavn"
+    IDS_PORTEXISTS "Porten %s finnes allerede"
+    IDS_NOTHINGTOCONFIG "Denne porten har ingen innstillinger"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "Legg til en lokal port"
@@ -29,8 +38,8 @@ FONT 8, "MS Shell Dlg"
 BEGIN
     LTEXT "Skriv inn navn&et på den nye porten:", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "OK", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "Avbryt", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "OK", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "Avbryt", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -45,12 +54,3 @@ BEGIN
     DEFPUSHBUTTON "OK", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "Avbryt", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "Lokal port"
-    IDS_INVALIDNAME "«%s» er ikke et gyldig portnavn"
-    IDS_PORTEXISTS "Porten %s finnes allerede"
-    IDS_NOTHINGTOCONFIG "Denne porten har ingen innstillinger"
-}

dll/win32/localui/lang/ui_Pl.rc

@@ -17,12 +17,21 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
 
 LANGUAGE LANG_POLISH, SUBLANG_DEFAULT
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "Port lokalny"
+    IDS_INVALIDNAME "'%s' nie jest poprawnš nazwš portu"
+    IDS_PORTEXISTS "Port %s już istnieje"
+    IDS_NOTHINGTOCONFIG "Ten port nie ma opcji do skonfigurowania"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "Dodaj port lokalny"
@@ -30,8 +39,8 @@ FONT 8, "MS Shell Dlg"
 BEGIN
     LTEXT "&Nazwa nowego portu:", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "&OK", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "&Anuluj", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "&OK", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "&Anuluj", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -46,12 +55,3 @@ BEGIN
     DEFPUSHBUTTON "&OK", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "&Anuluj", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "Port lokalny"
-    IDS_INVALIDNAME "'%s' nie jest poprawnš nazwš portu"
-    IDS_PORTEXISTS "Port %s już istnieje"
-    IDS_NOTHINGTOCONFIG "Ten port nie ma opcji do skonfigurowania"
-}

dll/win32/localui/lang/ui_Pt.rc

@@ -16,12 +16,21 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
 
 LANGUAGE LANG_PORTUGUESE, SUBLANG_NEUTRAL
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "Porta Local"
+    IDS_INVALIDNAME "'%s' não é um nome de porta válido"
+    IDS_PORTEXISTS "Porta %s já existe"
+    IDS_NOTHINGTOCONFIG "Esta porta não possui opções de configuração"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "Adicionar uma porta local"
@@ -29,8 +38,8 @@ FONT 8, "MS Shell Dlg"
 BEGIN
     LTEXT "&Introduza o nome da porta a adicionar:", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "OK", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "Cancelar", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "OK", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "Cancelar", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -45,12 +54,3 @@ BEGIN
     DEFPUSHBUTTON "OK", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "Cancelar", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "Porta Local"
-    IDS_INVALIDNAME "'%s' não é um nome de porta válido"
-    IDS_PORTEXISTS "Porta %s já existe"
-    IDS_NOTHINGTOCONFIG "Esta porta não possui opções de configuração"
-}

dll/win32/localui/lang/ui_Ro.rc

@@ -16,23 +16,32 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
 
+#pragma code_page(65001)
+
 LANGUAGE LANG_ROMANIAN, SUBLANG_NEUTRAL
 
-#pragma code_page(65001)
+STRINGTABLE
+{
+    IDS_LOCALPORT "Port local"
+    IDS_INVALIDNAME "„%s” nu este un nume valid de port"
+    IDS_PORTEXISTS "Portul %s existsă deja"
+    IDS_NOTHINGTOCONFIG "Acest port nu are opțiuni de configurat"
+}
 
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "Adaugare port local"
 FONT 8, "MS Shell Dlg"
 BEGIN
-    LTEXT          "N&umele portului adăugat:",  -1, 7, 13, 194, 13, WS_VISIBLE
-    EDITTEXT                                  ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON  "Con&firmă",               IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON     "A&nulează",               IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    LTEXT "N&umele portului adăugat:", -1, 7, 13, 194, 13, WS_VISIBLE
+    EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
+    DEFPUSHBUTTON "Con&firmă", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "A&nulează", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -41,18 +50,9 @@ STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPW
 CAPTION "Configurare port LPT"
 FONT 8, "MS Shell Dlg"
 BEGIN
-    GROUPBOX       "Temporizare (secunde)",    LPTCONFIG_GROUP, 6, 6, 150, 35, BS_GROUPBOX
-    LTEXT          "&Reîncearcă transmisia:",  -1, 14, 22, 90, 13, WS_VISIBLE
-    EDITTEXT                                   LPTCONFIG_EDIT, 112, 20, 32, 13, WS_VISIBLE | ES_NUMBER
-    DEFPUSHBUTTON  "Con&firmă",                IDOK, 164, 10, 50, 14, WS_VISIBLE
-    PUSHBUTTON     "A&nulează",                IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
+    GROUPBOX "Temporizare (secunde)", LPTCONFIG_GROUP, 6, 6, 150, 35, BS_GROUPBOX
+    LTEXT "&Reîncearcă transmisia:", -1, 14, 22, 90, 13, WS_VISIBLE
+    EDITTEXT LPTCONFIG_EDIT, 112, 20, 32, 13, WS_VISIBLE | ES_NUMBER
+    DEFPUSHBUTTON "Con&firmă", IDOK, 164, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "A&nulează", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT        "Port local"
-    IDS_INVALIDNAME      "„%s” nu este un nume valid de port"
-    IDS_PORTEXISTS       "Portul %s existsă deja"
-    IDS_NOTHINGTOCONFIG  "Acest port nu are opțiuni de configurat"
-}

dll/win32/localui/lang/ui_Ru.rc

@@ -16,6 +16,7 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
@@ -25,6 +26,14 @@
 
 LANGUAGE LANG_RUSSIAN, SUBLANG_DEFAULT
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "Локальный порт"
+    IDS_INVALIDNAME "Неправильное название порта '%s'"
+    IDS_PORTEXISTS "Порт '%s' уже существует"
+    IDS_NOTHINGTOCONFIG "Этот порт не имеет настроек"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "Добавить локальный порт"
@@ -32,8 +41,8 @@ FONT 8, "MS Shell Dlg"
 BEGIN
     LTEXT "Введите &название локального порта:", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "OK", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "Отменить", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "OK", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "Отменить", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -48,12 +57,3 @@ BEGIN
     DEFPUSHBUTTON "OK", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "Отмена", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "Локальный порт"
-    IDS_INVALIDNAME "Неправильное название порта '%s'"
-    IDS_PORTEXISTS "Порт '%s' уже существует"
-    IDS_NOTHINGTOCONFIG "Этот порт не имеет настроек"
-}

dll/win32/localui/lang/ui_Si.rc

@@ -16,6 +16,7 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
@@ -24,6 +25,14 @@
 
 LANGUAGE LANG_SLOVENIAN, SUBLANG_DEFAULT
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "Lokalna vrata"
+    IDS_INVALIDNAME "'%s' ni veljavno ime vrat"
+    IDS_PORTEXISTS "Vrata z imenom %s že obstajajo"
+    IDS_NOTHINGTOCONFIG "Ta vrata nimajo možnosti nastavitve"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "Dodaj lokalna vrata"
@@ -31,8 +40,8 @@ FONT 8, "MS Shell Dlg"
 BEGIN
     LTEXT "&Ime vrat:", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "V redu", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "Prekliči", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "V redu", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "Prekliči", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -47,12 +56,3 @@ BEGIN
     DEFPUSHBUTTON "V redu", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "Prekliči", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "Lokalna vrata"
-    IDS_INVALIDNAME "'%s' ni veljavno ime vrat"
-    IDS_PORTEXISTS "Vrata z imenom %s že obstajajo"
-    IDS_NOTHINGTOCONFIG "Ta vrata nimajo možnosti nastavitve"
-}

dll/win32/localui/lang/ui_Sq.rc

@@ -17,12 +17,21 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
 
 LANGUAGE LANG_ALBANIAN, SUBLANG_NEUTRAL
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "Porti Vendor"
+    IDS_INVALIDNAME "'%s' nuk është emer e vlefshem porti"
+    IDS_PORTEXISTS "Porti %s ekziston"
+    IDS_NOTHINGTOCONFIG "Ky port ska opsione për të konfiguruar"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "Shto një Port Vendor"
@@ -30,8 +39,8 @@ FONT 8, "MS Shell Dlg"
 BEGIN
     LTEXT "Fut emrin e Portit për të shtuar:", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "OK", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "Anulo", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "OK", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "Anulo", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -46,12 +55,3 @@ BEGIN
     DEFPUSHBUTTON "OK", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "Anulo", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "Porti Vendor"
-    IDS_INVALIDNAME "'%s' nuk është emer e vlefshem porti"
-    IDS_PORTEXISTS "Porti %s ekziston"
-    IDS_NOTHINGTOCONFIG "Ky port ska opsione për të konfiguruar"
-}

dll/win32/localui/lang/ui_Sv.rc

@@ -16,12 +16,21 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
 
 LANGUAGE LANG_SWEDISH, SUBLANG_NEUTRAL
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "Lokal port"
+    IDS_INVALIDNAME "'%s' är inte ett giltigt portnamn"
+    IDS_PORTEXISTS "Porten %s finns redan"
+    IDS_NOTHINGTOCONFIG "Denna port har inga alternativ att konfigurera"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "Lägg till en lokal port"
@@ -29,8 +38,8 @@ FONT 8, "MS Shell Dlg"
 BEGIN
     LTEXT "&Ange portnamnet att lägga till:", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "OK", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "Avbryt", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "OK", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "Avbryt", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -45,12 +54,3 @@ BEGIN
     DEFPUSHBUTTON "OK", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "Avbryt", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "Lokal port"
-    IDS_INVALIDNAME "'%s' är inte ett giltigt portnamn"
-    IDS_PORTEXISTS "Porten %s finns redan"
-    IDS_NOTHINGTOCONFIG "Denna port har inga alternativ att konfigurera"
-}

dll/win32/localui/lang/ui_Tr.rc

@@ -16,12 +16,21 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
 
 LANGUAGE LANG_TURKISH, SUBLANG_DEFAULT
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "Yerli Giriş"
+    IDS_INVALIDNAME """%s"", geçerli bir giriş adı değil."
+    IDS_PORTEXISTS "%s girişi önceden var."
+    IDS_NOTHINGTOCONFIG "Bu girişin yapılandırmak için seçeneği yok."
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "Bir Yerli Giriş Ekle"
@@ -29,8 +38,8 @@ FONT 8, "MS Shell Dlg"
 BEGIN
     LTEXT "&Eklemek için giriş adını giriniz:", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "Tamam", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "İptal", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "Tamam", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "İptal", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -45,12 +54,3 @@ BEGIN
     DEFPUSHBUTTON "Tamam", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "İptal", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "Yerli Giriş"
-    IDS_INVALIDNAME """%s"", geçerli bir giriş adı değil."
-    IDS_PORTEXISTS "%s girişi önceden var."
-    IDS_NOTHINGTOCONFIG "Bu girişin yapılandırmak için seçeneği yok."
-}

dll/win32/localui/lang/ui_Uk.rc

@@ -16,6 +16,7 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
@@ -25,6 +26,14 @@
 
 LANGUAGE LANG_UKRAINIAN, SUBLANG_DEFAULT
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "Локальний порт"
+    IDS_INVALIDNAME "'%s' не дійсна назва порту"
+    IDS_PORTEXISTS "Порт '%s' вже існує"
+    IDS_NOTHINGTOCONFIG "Цей порт не має налаштувань"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "Додати локальний порт"
@@ -32,8 +41,8 @@ FONT 8, "MS Shell Dlg"
 BEGIN
     LTEXT "Введіть &назву локального порта:", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "OK", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "Скасувати", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "OK", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "Скасувати", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -48,12 +57,3 @@ BEGIN
     DEFPUSHBUTTON "OK", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "Скасувати", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "Локальний порт"
-    IDS_INVALIDNAME "'%s' не дійсна назва порту"
-    IDS_PORTEXISTS "Порт '%s' вже існує"
-    IDS_NOTHINGTOCONFIG "Цей порт не має налаштувань"
-}

dll/win32/localui/lang/ui_Zh.rc

@@ -16,6 +16,7 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
  */
 
 #include "localui.h"
@@ -25,6 +26,14 @@
 
 LANGUAGE LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED
 
+STRINGTABLE
+{
+    IDS_LOCALPORT "本地端口"
+    IDS_INVALIDNAME "'%s' 不是有效的端口名称"
+    IDS_PORTEXISTS "端口 %s 已经存在"
+    IDS_NOTHINGTOCONFIG "这个端口没有可设置选项"
+}
+
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "添加本地端口"
@@ -32,8 +41,8 @@ FONT 9, "MS Shell Dlg"
 BEGIN
     LTEXT "添加本地端口名称(&E):", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "确定", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "取消", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "确定", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "取消", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -49,17 +58,16 @@ BEGIN
     PUSHBUTTON "取消", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
 
+LANGUAGE LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL
 
 STRINGTABLE
 {
     IDS_LOCALPORT "本地端口"
-    IDS_INVALIDNAME "'%s' 不是有效的端口名称"
-    IDS_PORTEXISTS "端口 %s 已经存在"
-    IDS_NOTHINGTOCONFIG "这个端口没有可设置选项"
+    IDS_INVALIDNAME "'%s' 不是有效的端口名稱"
+    IDS_PORTEXISTS "端口 %s 已經存在"
+    IDS_NOTHINGTOCONFIG "這個端口沒有可設定選項"
 }
 
-LANGUAGE LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL
-
 ADDPORT_DIALOG DIALOG 6, 18, 245, 47
 STYLE DS_CONTEXTHELP | DS_MODALFRAME | DS_SETFONT | DS_SETFOREGROUND | WS_POPUPWINDOW | WS_VISIBLE | WS_CAPTION
 CAPTION "添加本地端口"
@@ -67,8 +75,8 @@ FONT 9, "MS Shell Dlg"
 BEGIN
     LTEXT "添加本地端口名稱(&E):", -1, 7, 13, 194, 13, WS_VISIBLE
     EDITTEXT ADDPORT_EDIT, 6, 28, 174, 12, WS_VISIBLE | ES_AUTOHSCROLL
-    DEFPUSHBUTTON "確定", IDOK, 199, 10, 40, 14, WS_VISIBLE
-    PUSHBUTTON "取消", IDCANCEL, 199, 27, 40, 14, WS_VISIBLE
+    DEFPUSHBUTTON "確定", IDOK, 188, 10, 50, 14, WS_VISIBLE
+    PUSHBUTTON "取消", IDCANCEL, 188, 27, 50, 14, WS_VISIBLE
 END
 
 
@@ -83,12 +91,3 @@ BEGIN
     DEFPUSHBUTTON "確定", IDOK, 164, 10, 50, 14, WS_VISIBLE
     PUSHBUTTON "取消", IDCANCEL, 164, 27, 50, 14, WS_VISIBLE
 END
-
-
-STRINGTABLE
-{
-    IDS_LOCALPORT "本地端口"
-    IDS_INVALIDNAME "'%s' 不是有效的端口名稱"
-    IDS_PORTEXISTS "端口 %s 已經存在"
-    IDS_NOTHINGTOCONFIG "這個端口沒有可設定選項"
-}

dll/win32/lsasrv/authport.c

@@ -237,6 +237,11 @@ AuthPortThreadRoutine(PVOID Param)
                         ReplyMsg = &RequestMsg;
                         break;
 
+                    case LSASS_REQUEST_GET_LOGON_SESSION_DATA:
+                        RequestMsg.Status = LsapGetLogonSessionData(&RequestMsg);
+                        ReplyMsg = &RequestMsg;
+                        break;
+
                     default:
                         RequestMsg.Status = STATUS_INVALID_SYSTEM_SERVICE;
                         ReplyMsg = &RequestMsg;

dll/win32/lsasrv/lsasrv.h

@@ -407,6 +407,9 @@ LsapSetLogonSessionData(IN PLUID LogonId);
 NTSTATUS
 LsapEnumLogonSessions(IN OUT PLSA_API_MSG RequestMsg);
 
+NTSTATUS
+LsapGetLogonSessionData(IN OUT PLSA_API_MSG RequestMsg);
+
 /* utils.c */
 INT
 LsapLoadString(HINSTANCE hInstance,

dll/win32/lsasrv/session.c

@@ -12,6 +12,16 @@ typedef struct _LSAP_LOGON_SESSION
 {
     LIST_ENTRY Entry;
     LUID LogonId;
+    ULONG LogonType;
+    ULONG Session;
+    LARGE_INTEGER LogonTime;
+    PSID Sid;
+    UNICODE_STRING UserName;
+    UNICODE_STRING LogonDomain;
+    UNICODE_STRING AuthenticationPackage;
+    UNICODE_STRING LogonServer;
+    UNICODE_STRING DnsDomainName;
+    UNICODE_STRING Upn;
 } LSAP_LOGON_SESSION, *PLSAP_LOGON_SESSION;
 
 
@@ -58,7 +68,7 @@ LsapSetLogonSessionData(IN PLUID LogonId)
 {
     PLSAP_LOGON_SESSION Session;
 
-    TRACE("()\n");
+    TRACE("LsapSetLogonSessionData()\n");
 
     Session = LsapGetLogonSession(LogonId);
     if (Session == NULL)
@@ -92,7 +102,7 @@ LsapCreateLogonSession(IN PLUID LogonId)
     RtlCopyLuid(&Session->LogonId, LogonId);
 
     /* Insert the new session into the session list */
-    InsertTailList(&SessionListHead, &Session->Entry);
+    InsertHeadList(&SessionListHead, &Session->Entry);
     SessionCount++;
 
     return STATUS_SUCCESS;
@@ -116,6 +126,28 @@ LsapDeleteLogonSession(IN PLUID LogonId)
     RemoveEntryList(&Session->Entry);
     SessionCount--;
 
+    /* Free the session data */
+    if (Session->Sid != NULL)
+        RtlFreeHeap(RtlGetProcessHeap(), 0, Session->Sid);
+
+    if (Session->UserName.Buffer != NULL)
+        RtlFreeHeap(RtlGetProcessHeap(), 0, Session->UserName.Buffer);
+
+    if (Session->LogonDomain.Buffer != NULL)
+        RtlFreeHeap(RtlGetProcessHeap(), 0, Session->LogonDomain.Buffer);
+
+    if (Session->AuthenticationPackage.Buffer != NULL)
+        RtlFreeHeap(RtlGetProcessHeap(), 0, Session->AuthenticationPackage.Buffer);
+
+    if (Session->LogonServer.Buffer != NULL)
+        RtlFreeHeap(RtlGetProcessHeap(), 0, Session->LogonServer.Buffer);
+
+    if (Session->DnsDomainName.Buffer != NULL)
+        RtlFreeHeap(RtlGetProcessHeap(), 0, Session->DnsDomainName.Buffer);
+
+    if (Session->Upn.Buffer != NULL)
+        RtlFreeHeap(RtlGetProcessHeap(), 0, Session->Upn.Buffer);
+
     /* Free the session entry */
     RtlFreeHeap(RtlGetProcessHeap(), 0, Session);
 
@@ -135,7 +167,7 @@ LsapEnumLogonSessions(IN OUT PLSA_API_MSG RequestMsg)
     PVOID ClientBaseAddress = NULL;
     NTSTATUS Status;
 
-    TRACE("LsapEnumLogonSessions()\n");
+    TRACE("LsapEnumLogonSessions(%p)\n", RequestMsg);
 
     Length = SessionCount * sizeof(LUID);
     SessionList = RtlAllocateHeap(RtlGetProcessHeap(),
@@ -166,7 +198,7 @@ LsapEnumLogonSessions(IN OUT PLSA_API_MSG RequestMsg)
                                NULL);
 
     Status = NtOpenProcess(&ProcessHandle,
-                           PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_VM_OPERATION | PROCESS_DUP_HANDLE,
+                           PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_VM_OPERATION,
                            &ObjectAttributes,
                            &RequestMsg->h.ClientId);
     if (!NT_SUCCESS(Status))
@@ -175,6 +207,8 @@ LsapEnumLogonSessions(IN OUT PLSA_API_MSG RequestMsg)
         goto done;
     }
 
+    TRACE("Length: %lu\n", Length);
+
     MemSize = Length;
     Status = NtAllocateVirtualMemory(ProcessHandle,
                                      &ClientBaseAddress,
@@ -188,6 +222,9 @@ LsapEnumLogonSessions(IN OUT PLSA_API_MSG RequestMsg)
         goto done;
     }
 
+    TRACE("MemSize: %lu\n", MemSize);
+    TRACE("ClientBaseAddress: %p\n", ClientBaseAddress);
+
     Status = NtWriteVirtualMemory(ProcessHandle,
                                   ClientBaseAddress,
                                   SessionList,
@@ -212,4 +249,110 @@ done:
     return Status;
 }
 
+
+NTSTATUS
+LsapGetLogonSessionData(IN OUT PLSA_API_MSG RequestMsg)
+{
+    OBJECT_ATTRIBUTES ObjectAttributes;
+    HANDLE ProcessHandle = NULL;
+    PLSAP_LOGON_SESSION Session;
+    PSECURITY_LOGON_SESSION_DATA LocalSessionData;
+    PVOID ClientBaseAddress = NULL;
+    ULONG Length, MemSize;
+    LPWSTR Ptr;
+    NTSTATUS Status;
+
+    TRACE("LsapGetLogonSessionData(%p)\n", RequestMsg);
+
+    TRACE("LogonId: %lx\n", RequestMsg->GetLogonSessionData.Request.LogonId.LowPart);
+    Session = LsapGetLogonSession(&RequestMsg->GetLogonSessionData.Request.LogonId);
+    if (Session == NULL)
+        return STATUS_NO_SUCH_LOGON_SESSION;
+
+    Length = sizeof(SECURITY_LOGON_SESSION_DATA);
+/*
+             Session->UserName.MaximumLength +
+             Session->LogonDomain.MaximumLength +
+             Session->AuthenticationPackage.MaximumLength +
+             Session->LogonServer.MaximumLength +
+             Session->DnsDomainName.MaximumLength +
+             Session->Upn.MaximumLength;
+
+    if (Session->Sid != NULL)
+        RtlLengthSid(Session->Sid);
+*/
+
+    TRACE("Length: %lu\n", Length);
+
+    LocalSessionData = RtlAllocateHeap(RtlGetProcessHeap(),
+                                       HEAP_ZERO_MEMORY,
+                                       Length);
+    if (LocalSessionData == NULL)
+        return STATUS_INSUFFICIENT_RESOURCES;
+
+    Ptr = (LPWSTR)((ULONG_PTR)LocalSessionData + sizeof(SECURITY_LOGON_SESSION_DATA));
+    TRACE("LocalSessionData: %p  Ptr: %p\n", LocalSessionData, Ptr);
+
+    LocalSessionData->Size = sizeof(SECURITY_LOGON_SESSION_DATA);
+
+    RtlCopyLuid(&LocalSessionData->LogonId,
+                &RequestMsg->GetLogonSessionData.Request.LogonId);
+
+    InitializeObjectAttributes(&ObjectAttributes,
+                               NULL,
+                               0,
+                               NULL,
+                               NULL);
+
+    Status = NtOpenProcess(&ProcessHandle,
+                           PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_VM_OPERATION,
+                           &ObjectAttributes,
+                           &RequestMsg->h.ClientId);
+    if (!NT_SUCCESS(Status))
+    {
+        TRACE("NtOpenProcess() failed (Status %lx)\n", Status);
+        goto done;
+    }
+
+    //TRACE("MemSize: %lu\n", MemSize);
+
+    MemSize = Length;
+    Status = NtAllocateVirtualMemory(ProcessHandle,
+                                     &ClientBaseAddress,
+                                     0,
+                                     &MemSize,
+                                     MEM_COMMIT,
+                                     PAGE_READWRITE);
+    if (!NT_SUCCESS(Status))
+    {
+        TRACE("NtAllocateVirtualMemory() failed (Status %lx)\n", Status);
+        goto done;
+    }
+
+    TRACE("MemSize: %lu\n", MemSize);
+    TRACE("ClientBaseAddress: %p\n", ClientBaseAddress);
+
+    Status = NtWriteVirtualMemory(ProcessHandle,
+                                  ClientBaseAddress,
+                                  LocalSessionData,
+                                  Length,
+                                  NULL);
+    if (!NT_SUCCESS(Status))
+    {
+        TRACE("NtWriteVirtualMemory() failed (Status %lx)\n", Status);
+        goto done;
+    }
+
+    RequestMsg->GetLogonSessionData.Reply.SessionDataBuffer = ClientBaseAddress;
+
+done:
+    if (ProcessHandle != NULL)
+        NtClose(ProcessHandle);
+
+    if (LocalSessionData != NULL)
+        RtlFreeHeap(RtlGetProcessHeap(), 0, LocalSessionData);
+
+    return Status;
+}
+
 /* EOF */

dll/win32/mgmtapi/CMakeLists.txt

@@ -0,0 +1,16 @@
+
+add_definitions(-D__WINESRC__)
+include_directories(${REACTOS_SOURCE_DIR}/include/reactos/wine)
+
+spec2def(mgmtapi.dll mgmtapi.spec)
+
+list(APPEND SOURCE
+    mgmtapi.c
+    ${CMAKE_CURRENT_BINARY_DIR}/mgmtapi_stubs.c
+    ${CMAKE_CURRENT_BINARY_DIR}/mgmtapi.def)
+
+add_library(mgmtapi SHARED ${SOURCE})
+set_module_type(mgmtapi win32dll)
+target_link_libraries(mgmtapi wine)
+add_importlibs(mgmtapi msvcrt kernel32 ntdll)
+add_cd_file(TARGET mgmtapi DESTINATION reactos/system32 FOR all)

dll/win32/mgmtapi/mgmtapi.c

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2012 Stefan Leichter
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <stdarg.h>
+#include <windef.h>
+#include <winbase.h>
+
+#include <wine/debug.h>
+
+WINE_DEFAULT_DEBUG_CHANNEL(mgmtapi);
+
+BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, LPVOID reserved )
+{
+    TRACE("%p, %u, %p\n", hinst, reason, reserved);
+
+    switch (reason)
+    {
+        case DLL_WINE_PREATTACH:
+            return FALSE;    /* prefer native version */
+        case DLL_PROCESS_ATTACH:
+            DisableThreadLibraryCalls( hinst );
+            break;
+    }
+    return TRUE;
+}

dll/win32/mgmtapi/mgmtapi.spec

@@ -0,0 +1,9 @@
+@ stub SnmpMgrClose
+@ stub SnmpMgrCtl
+@ stub SnmpMgrGetTrap
+@ stub SnmpMgrGetTrapEx
+@ stub SnmpMgrOidToStr
+@ stub SnmpMgrOpen
+@ stub SnmpMgrRequest
+@ stub SnmpMgrStrToOid
+@ stub SnmpMgrTrapListen

dll/win32/mmdevapi/devenum.c

@@ -1048,8 +1048,8 @@ static void notify_clients(EDataFlow flow, ERole role, const WCHAR *id)
         notify_clients(flow, eMultimedia, id);
 }
 
-static int notify_if_changed(EDataFlow flow, ERole role, HKEY key,
-        const WCHAR *val_name, WCHAR *old_val, IMMDevice *def_dev)
+static BOOL notify_if_changed(EDataFlow flow, ERole role, HKEY key,
+                              const WCHAR *val_name, WCHAR *old_val, IMMDevice *def_dev)
 {
     WCHAR new_val[64], *id;
     DWORD size;
@@ -1064,7 +1064,7 @@ static int notify_if_changed(EDataFlow flow, ERole role, HKEY key,
                 hr = IMMDevice_GetId(def_dev, &id);
                 if(FAILED(hr)){
                     ERR("GetId failed: %08x\n", hr);
-                    return 0;
+                    return FALSE;
                 }
             }else
                 id = NULL;
@@ -1073,23 +1073,23 @@ static int notify_if_changed(EDataFlow flow, ERole role, HKEY key,
             old_val[0] = 0;
             CoTaskMemFree(id);
 
-            return 1;
+            return TRUE;
         }
 
         /* system default -> system default, noop */
-        return 0;
+        return FALSE;
     }
 
     if(!lstrcmpW(old_val, new_val)){
         /* set by user -> same value */
-        return 0;
+        return FALSE;
     }
 
     if(new_val[0] != 0){
         /* set by user -> different value */
         notify_clients(flow, role, new_val);
         memcpy(old_val, new_val, sizeof(new_val));
-        return 1;
+        return TRUE;
     }
 
     /* set by user -> system default */
@@ -1097,7 +1097,7 @@ static int notify_if_changed(EDataFlow flow, ERole role, HKEY key,
         hr = IMMDevice_GetId(def_dev, &id);
         if(FAILED(hr)){
             ERR("GetId failed: %08x\n", hr);
-            return 0;
+            return FALSE;
         }
     }else
         id = NULL;
@@ -1106,7 +1106,7 @@ static int notify_if_changed(EDataFlow flow, ERole role, HKEY key,
     old_val[0] = 0;
     CoTaskMemFree(id);
 
-    return 1;
+    return TRUE;
 }
 
 static DWORD WINAPI notif_thread_proc(void *user)
@@ -1325,10 +1325,10 @@ static HRESULT WINAPI MMDevPropStore_GetCount(IPropertyStore *iface, DWORD *npro
     *nprops = 0;
     do {
         DWORD len = sizeof(buffer)/sizeof(*buffer);
-        if (RegEnumKeyExW(propkey, i, buffer, &len, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
+        if (RegEnumValueW(propkey, i, buffer, &len, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
             break;
         i++;
-    } while (0);
+    } while (1);
     RegCloseKey(propkey);
     TRACE("Returning %i\n", i);
     *nprops = i;
@@ -1351,16 +1351,16 @@ static HRESULT WINAPI MMDevPropStore_GetAt(IPropertyStore *iface, DWORD prop, PR
     if (FAILED(hr))
         return hr;
 
-    if (RegEnumKeyExW(propkey, prop, buffer, &len, NULL, NULL, NULL, NULL) != ERROR_SUCCESS
-        || len <= 40)
+    if (RegEnumValueW(propkey, prop, buffer, &len, NULL, NULL, NULL, NULL) != ERROR_SUCCESS
+        || len <= 39)
     {
         WARN("GetAt %u failed\n", prop);
         return E_INVALIDARG;
     }
     RegCloseKey(propkey);
-    buffer[39] = 0;
+    buffer[38] = 0;
     CLSIDFromString(buffer, &key->fmtid);
-    key->pid = atoiW(&buffer[40]);
+    key->pid = atoiW(&buffer[39]);
     return S_OK;
 }
 

dll/win32/mmdevapi/mmdevapi_classes.idl

@@ -18,6 +18,8 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
+#pragma makedep register
+
 [
     helpstring("MMDeviceEnumerator class"),
     threading(both),

dll/win32/mpr/lang/mpr_Bg.rc

@@ -25,22 +25,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "Öÿëàòà ìðåæà"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Âúâåäåòå ìðåæîâà ïàðîëà"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "Âúâåäåòå âàøåòî ïîòðåáèòåëñêî èìå è ïàðîëà:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "Ïðîêñè", -1, 40, 26, 50, 10
-/* LTEXT "Realm", -1, 40, 46, 50, 10 */
- LTEXT "Ïîòðåáèòåë", -1, 40, 66, 50, 10
- LTEXT "Ïàðîëà", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
- CHECKBOX "&Save this password (Insecure)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "Îòìåíè", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+ LTEXT "Âúâåäåòå âàøåòî ïîòðåáèòåëñêî èìå è ïàðîëà:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Ïðîêñè", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "Ïîòðåáèòåë", -1, 6, 66, 60, 10
+ LTEXT "Ïàðîëà", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ CHECKBOX "&Save this password (insecure)", IDC_SAVEPASSWORD,
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "OK", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Îòìåíè", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_Cs.rc

@@ -28,22 +28,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "Celá sí�"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Zadání sí�ového hesla"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "Prosím zadejte své uživatelské jméno a heslo:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "Proxy", -1, 40, 26, 50, 10
-/* LTEXT "Realm", -1, 40, 46, 50, 10 */
- LTEXT "Uživatel", -1, 40, 66, 50, 10
- LTEXT "Heslo", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "Prosím zadejte své uživatelské jméno a heslo:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Proxy", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "Uživatel", -1, 6, 66, 60, 10
+ LTEXT "Heslo", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "&Uložit toto heslo (Není bezpeèné) ?", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "Zrušit", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "OK", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Zrušit", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_Da.rc

@@ -25,22 +25,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "Hele netværket"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Skriv netværkskodeord"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "Skriv dit brugernavn og kodeord:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "Proxy", -1, 40, 26, 50, 10
-/* LTEXT "Realm", -1, 40, 46, 50, 10 */
- LTEXT "Brugernavn", -1, 40, 66, 50, 10
- LTEXT "Kodeord", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "Skriv dit brugernavn og kodeord:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Proxy", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "Brugernavn", -1, 6, 66, 60, 10
+ LTEXT "Kodeord", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "Gem dette ko&deord (usikkert)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "Annuller", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "OK", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Annuller", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_De.rc

@@ -27,22 +27,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "Gesamtes Netzwerk"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Netzwerkkennung eingeben"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "Bitte geben Sie Benutzernamen und Kennwort ein:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "Proxy", -1, 40, 26, 50, 10
-/* LTEXT "Bereich", -1, 40, 46, 50, 10 */
- LTEXT "Benutzername", -1, 40, 66, 50, 10
- LTEXT "Kennwort", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "Bitte geben Sie Benutzernamen und Kennwort ein:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Proxy", -1, 6, 26, 60, 10
+/* LTEXT "Bereich", -1, 6, 46, 60, 10 */
+ LTEXT "Benutzername", -1, 6, 66, 60, 10
+ LTEXT "Kennwort", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "Dieses Kennwort speichern (unsicher)", IDC_SAVEPASSWORD,
-          80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "Abbrechen", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "OK", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Abbrechen", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_En.rc

@@ -25,22 +25,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "Entire Network"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Enter Network Password"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "Please enter your username and password:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "Proxy", -1, 40, 26, 50, 10
-/* LTEXT "Realm", -1, 40, 46, 50, 10 */
- LTEXT "User", -1, 40, 66, 50, 10
- LTEXT "Password", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
- CHECKBOX "&Save this password (Insecure)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "Cancel", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+ LTEXT "Please enter your username and password:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Proxy", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "User", -1, 6, 66, 60, 10
+ LTEXT "Password", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ CHECKBOX "&Save this password (insecure)", IDC_SAVEPASSWORD,
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "OK", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Cancel", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_Es.rc

@@ -25,22 +25,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "Toda la red"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Introduzca contraseña de red"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "Por favor, introduzca su nombre de usuario y contraseña:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "Proxy", -1, 40, 26, 50, 10
-/* LTEXT "Realm", -1, 40, 46, 50, 10 */
- LTEXT "Usuario", -1, 40, 66, 50, 10
- LTEXT "Contraseña", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "Por favor, introduzca su nombre de usuario y contraseña:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Proxy", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "Usuario", -1, 6, 66, 60, 10
+ LTEXT "Contraseña", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "&Guardar esta contraseña (Inseguro)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "Aceptar", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "Cancelar", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "Aceptar", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Cancelar", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_Fr.rc

@@ -29,22 +29,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "Le réseau entier"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 210, 146
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Entrez le mot de passe réseau"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "Veuillez saisir votre nom d'utilisateur et votre mot de passe :", IDC_EXPLAIN, 10, 6, 150, 17
- LTEXT "Proxy", -1, 10, 31, 50, 10
-/* LTEXT "Realm", -1, 40, 46, 50, 10 */
- LTEXT "Utilisateur", -1, 10, 68, 45, 10
- LTEXT "Mot de passe", -1, 10, 88, 45, 10
- LTEXT "", IDC_PROXY, 56, 32, 144, 14, 0
- LTEXT "", IDC_REALM, 56, 46, 144, 14, 0
- EDITTEXT IDC_USERNAME, 56, 66, 144, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 56, 86, 144, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "Veuillez saisir votre nom d'utilisateur et votre mot de passe :", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Proxy", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "Utilisateur", -1, 6, 66, 60, 10
+ LTEXT "Mot de passe", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "&Enregistrer ce mot de passe (risqué)", IDC_SAVEPASSWORD,
-           56, 106, 144, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "OK", IDOK, 68, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "Annuler", IDCANCEL, 128, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "OK", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Annuler", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_He.rc

@@ -27,22 +27,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "הרשת כולה"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "הזן סיסמת רשת"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "נא הכנס את שם המתשמש והסיסמה שלך:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "שרת מתווך (Proxy)", -1, 40, 26, 50, 10
-/* LTEXT "Realm", -1, 40, 46, 50, 10 */
- LTEXT "שם משתמש", -1, 40, 66, 50, 10
- LTEXT "סיסמה", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "נא הכנס את שם המתשמש והסיסמה שלך:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "שרת מתווך (Proxy)", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "שם משתמש", -1, 6, 66, 60, 10
+ LTEXT "סיסמה", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "זכור את הסיסמה (לא בטוח)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "אישור", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "ביטול", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "אישור", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "ביטול", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_Hu.rc

@@ -25,22 +25,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "Teljes hálózat"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Hálózati jelszó megadása"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "Kérem adja meg a felhasználónevét és jelszavát:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "Proxy", -1, 40, 26, 50, 10
-/* LTEXT "Realm", -1, 40, 46, 50, 10 */
- LTEXT "Felhasználónév", -1, 40, 66, 50, 10
- LTEXT "Jelszó", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "Kérem adja meg a felhasználónevét és jelszavát:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Proxy", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "Felhasználónév", -1, 6, 66, 60, 10
+ LTEXT "Jelszó", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "&Jelszó mentése (nem biztonságos)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "Mégse", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "OK", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Mégse", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_It.rc

@@ -26,22 +26,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "Tutta la rete"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Inserisci la Password di Rete"
 FONT 8, "MS Shell Dlg"
 {
-LTEXT "Inserire nome utente e password:", IDC_EXPLAIN, 40, 6, 150, 15
-LTEXT "Proxy", -1, 40, 26, 50, 10
-/* LTEXT "Realm", -1, 40, 46, 50, 10 */
-LTEXT "Utente", -1, 40, 66, 50, 10
-LTEXT "Password", -1, 40, 86, 50, 10
-LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
-LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
-EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
-EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
-CHECKBOX "&Memorizza la password ( RISCHIOSO! )", IDC_SAVEPASSWORD,
-80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
-PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
-PUSHBUTTON "Annulla", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+ LTEXT "Inserire nome utente e password:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Proxy", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "Utente", -1, 6, 66, 60, 10
+ LTEXT "Password", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ CHECKBOX "&Memorizza la password ( RISCHIOSO! )", IDC_SAVEPASSWORD,
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "OK", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Annulla", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_Ja.rc

@@ -28,22 +28,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "ネットワーク全体"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "ネットワーク用パスワードを入力"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "ユーザー名とパスワードを入力してください:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "プロキシ", -1, 40, 26, 50, 10
-/* LTEXT "Realm", -1, 40, 46, 50, 10 */
- LTEXT "ユーザー名", -1, 40, 66, 50, 10
- LTEXT "パスワード", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "ユーザー名とパスワードを入力してください:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "プロキシ", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "ユーザー名", -1, 6, 66, 60, 10
+ LTEXT "パスワード", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "パスワードを保存する(&S)(セキュアではありません)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "キャンセル", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "OK", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "キャンセル", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_Ko.rc

@@ -26,22 +26,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "전체 네트워크"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "네트워크 암호 입력"
 FONT 9, "MS Shell Dlg"
 {
- LTEXT "당신의 사용자이름과 암호를 입력하시오:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "프록시", -1, 40, 26, 50, 10
-/* LTEXT "Realm", -1, 40, 46, 50, 10 */
- LTEXT "사용자", -1, 40, 66, 50, 10
- LTEXT "암호", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "당신의 사용자이름과 암호를 입력하시오:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "프록시", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "사용자", -1, 6, 66, 60, 10
+ LTEXT "암호", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "암호 저장(&S) (보안에 주의)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "확인", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "취소", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "확인", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "취소", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_Lt.rc

@@ -28,22 +28,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "Visas tinklas"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Įveskite tinklo slaptažodį"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "Įveskite savo naudotojo vardą ir slaptažodį:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "Įgaliot. serv.", -1, 40, 26, 50, 10
-/* LTEXT "Sritis", -1, 40, 46, 50, 10 */
- LTEXT "Naudotojas", -1, 40, 66, 50, 10
- LTEXT "Slaptažodis", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "Įveskite savo naudotojo vardą ir slaptažodį:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Įgaliot. serv.", -1, 6, 26, 60, 10
+/* LTEXT "Sritis", -1, 6, 46, 60, 10 */
+ LTEXT "Naudotojas", -1, 6, 66, 60, 10
+ LTEXT "Slaptažodis", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "Į&rašyti šį slaptažodį (nesaugu)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "Gerai", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "Atsisakyti", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "Gerai", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Atsisakyti", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_Nl.rc

@@ -26,22 +26,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "Gehele netwerk"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Voer het Netwerk Wachtwoord in"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "Voer a.u.b uw gebruikersnaam en wachtwoord in:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "Proxy", -1, 40, 26, 50, 10
-/* LTEXT "Realm", -1, 40, 46, 50, 10 */
- LTEXT "Gebruiker", -1, 40, 66, 50, 10
- LTEXT "Wachtwoord", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "Voer a.u.b uw gebruikersnaam en wachtwoord in:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Proxy", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "Gebruiker", -1, 6, 66, 60, 10
+ LTEXT "Wachtwoord", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "&Sla dit wachtwoord op (Onveilig)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "Annuleren", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "OK", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Annuleren", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_No.rc

@@ -25,22 +25,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "Hele nettverket"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Skriv inn nettverkspassord"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "Skriv inn brukernavnet og passordet ditt:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "Mellomtjener", -1, 40, 26, 50, 10
-/* LTEXT "Område", -1, 40, 46, 50, 10 */
- LTEXT "Bruker", -1, 40, 66, 50, 10
- LTEXT "Passord", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "Skriv inn brukernavnet og passordet ditt:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Mellomtjener", -1, 6, 26, 60, 10
+/* LTEXT "Område", -1, 6, 46, 60, 10 */
+ LTEXT "Bruker", -1, 6, 66, 60, 10
+ LTEXT "Passord", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "Lagre dette pa&ssordet (usikkert)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "Avbryt", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "OK", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Avbryt", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_Pl.rc

@@ -26,22 +26,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "Ca³a sieæ"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Wpisz has³o sieci"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "Proszê wprowadziæ nazwê u¿ytkownika i has³o:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "Proxy", -1, 40, 26, 50, 10
-/* LTEXT "Obszar", -1, 40, 46, 50, 10 */
- LTEXT "U¿ytkownik", -1, 40, 66, 50, 10
- LTEXT "Has³o", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "Proszê wprowadziæ nazwê u¿ytkownika i has³o:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Proxy", -1, 6, 26, 60, 10
+/* LTEXT "Obszar", -1, 6, 46, 60, 10 */
+ LTEXT "U¿ytkownik", -1, 6, 66, 60, 10
+ LTEXT "Has³o", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "&Zapisz to has³o (niebezpieczne)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "Anuluj", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "OK", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Anuluj", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_Pt.rc

@@ -31,44 +31,44 @@ STRINGTABLE
 
 LANGUAGE LANG_PORTUGUESE, SUBLANG_PORTUGUESE_BRAZILIAN
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Entre a senha da rede"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "Por favor, entre como o nome de usuário e a senha:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "Proxy", -1, 40, 26, 50, 10
-/* LTEXT "Realm", -1, 40, 46, 50, 10 */
- LTEXT "Usuário", -1, 40, 66, 50, 10
- LTEXT "Senha", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "Por favor, entre como o nome de usuário e a senha:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Proxy", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "Usuário", -1, 6, 66, 60, 10
+ LTEXT "Senha", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "&Salvar esta senha (Inseguro)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "Cancelar", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "OK", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Cancelar", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }
 
 LANGUAGE LANG_PORTUGUESE, SUBLANG_PORTUGUESE
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Indique a senha da rede"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "Por favor, indique o nome de utilizador e a senha:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "Proxy", -1, 40, 26, 50, 10
-/* LTEXT "Realm", -1, 40, 46, 50, 10 */
- LTEXT "Utilizador", -1, 40, 66, 50, 10
- LTEXT "Senha", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "Por favor, indique o nome de utilizador e a senha:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Proxy", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "Utilizador", -1, 6, 66, 60, 10
+ LTEXT "Senha", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "&Gravar esta senha (Inseguro)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "Cancelar", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "OK", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Cancelar", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_Ro.rc

@@ -27,21 +27,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "Toată rețeaua"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Introducere parolă de rețea"
 FONT 8, "MS Shell Dlg"
 {
-    LTEXT       "Introduceți numele de utilizator și parola:", IDC_EXPLAIN, 40, 6, 150, 15
-    LTEXT       "Mandatar",        -1, 40, 26, 50, 10
-    LTEXT       "Utilizator",   -1, 40, 66, 50, 10
-    LTEXT       "Parolă",       -1, 40, 86, 50, 10
-    LTEXT       "",             IDC_PROXY, 80, 26, 150, 14, 0
-    LTEXT       "",             IDC_REALM, 80, 46, 150, 14, 0
-    EDITTEXT                    IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
-    EDITTEXT                    IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
-    CHECKBOX    "&Păstrează această parolă (nerecomandat)", IDC_SAVEPASSWORD,
-                                80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
-    PUSHBUTTON  "Con&firmă",    IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
-    PUSHBUTTON  "A&nulează",    IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+ LTEXT "Introduceți numele de utilizator și parola:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Mandatar", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "Utilizator", -1, 6, 66, 60, 10
+ LTEXT "Parolă", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ CHECKBOX "&Păstrează această parolă (nerecomandat)", IDC_SAVEPASSWORD,
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "Con&firmă", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "A&nulează", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_Ru.rc

@@ -28,22 +28,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "Вся сеть"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Введите сетевой пароль"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "Введите ваши имя и пароль пользователя:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "Прокси", -1, 40, 26, 50, 10
-/* LTEXT "Realm", -1, 40, 46, 50, 10 */
- LTEXT "Имя", -1, 40, 66, 50, 10
- LTEXT "Пароль", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "Введите ваши имя и пароль пользователя:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Прокси", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "Имя", -1, 6, 66, 60, 10
+ LTEXT "Пароль", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "&Сохранить этот пароль (небезопасно!)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "Отмена", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "OK", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Отмена", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_Si.rc

@@ -27,22 +27,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "Celotno omrežje"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Vnesite omrežno geslo"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "Vnesite uporabniško ime in geslo:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "Proksi", -1, 40, 26, 50, 10
-/* LTEXT "Kraljestvo", -1, 40, 46, 50, 10 */
- LTEXT "Uporabniško ime", -1, 40, 66, 50, 10
- LTEXT "Geslo", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "Vnesite uporabniško ime in geslo:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Proksi", -1, 6, 26, 60, 10
+/* LTEXT "Kraljestvo", -1, 6, 46, 60, 10 */
+ LTEXT "Uporabniško ime", -1, 6, 66, 60, 10
+ LTEXT "Geslo", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "&Shrani geslo (nezaščiteno)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "V redu", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "Prekliči", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "V redu", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Prekliči", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_Sq.rc

@@ -25,22 +25,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "Gjithë Rrjeti"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Fjalëkalimi i Gjithë Rrjetit"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "Ju lutem shkruani emrin e përdoruesit dhe fjalëkalimin:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "Proxi", -1, 40, 26, 50, 10
-/* LTEXT "Realm", -1, 40, 46, 50, 10 */
- LTEXT "Përdoruesi", -1, 40, 66, 50, 10
- LTEXT "Fjalëkalimi", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "Ju lutem shkruani emrin e përdoruesit dhe fjalëkalimin:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Proxi", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "Përdoruesi", -1, 6, 66, 60, 10
+ LTEXT "Fjalëkalimi", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "&Ruaj këtë fjalëkalim (i pasigurt)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "Anulo", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "OK", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Anulo", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_Sv.rc

@@ -25,22 +25,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "Hela nätverket"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Ange nätverkslösenord"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "Ange ditt användarnamn och lösenord:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "Proxy", -1, 40, 26, 50, 10
-/* LTEXT "Realm", -1, 40, 46, 50, 10 */
- LTEXT "Användare", -1, 40, 66, 50, 10
- LTEXT "Lösenord", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "Ange ditt användarnamn och lösenord:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Proxy", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "Användare", -1, 6, 66, 60, 10
+ LTEXT "Lösenord", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "&Spara detta lösenord (osäkert)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "Avbryt", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "OK", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Avbryt", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_Tr.rc

@@ -25,22 +25,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "Tüm Ağ"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Ağ Şifresini Gir"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "Lütfen kullanıcı adınızı ve şifrenizi giriniz:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "Vekil", -1, 40, 26, 50, 10
-/* LTEXT "Erişim Alanı", -1, 40, 46, 50, 10 */
- LTEXT "Kullanıcı", -1, 40, 66, 50, 10
- LTEXT "Şifre", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "Lütfen kullanıcı adınızı ve şifrenizi giriniz:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Vekil", -1, 6, 26, 60, 10
+/* LTEXT "Erişim Alanı", -1, 6, 46, 60, 10 */
+ LTEXT "Kullanıcı", -1, 6, 66, 60, 10
+ LTEXT "Şifre", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "&Bu Şifreyi Sakla (Güvensiz)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "Tamam", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "İptal", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "Tamam", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "İptal", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_Uk.rc

@@ -29,22 +29,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "Вся Мережа"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "Введіть Мережний Пароль"
 FONT 8, "MS Shell Dlg"
 {
- LTEXT "Будь ласка, введіть Ваші ім'я та пароль:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "Проксі", -1, 40, 26, 50, 10
-/* LTEXT "Realm", -1, 40, 46, 50, 10 */
- LTEXT "Користувач", -1, 40, 66, 50, 10
- LTEXT "Пароль", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "Будь ласка, введіть Ваші ім'я та пароль:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "Проксі", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "Користувач", -1, 6, 66, 60, 10
+ LTEXT "Пароль", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "&Зберегти цей пароль (небезпечно)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "OK", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "Скасувати", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "OK", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "Скасувати", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/lang/mpr_Zh.rc

@@ -28,24 +28,24 @@ STRINGTABLE
     IDS_ENTIRENETWORK "整个网络"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "输入网络密码"
 FONT 9, "MS Shell Dlg"
 {
- LTEXT "请输入用户名和密码:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "代理", -1, 40, 26, 50, 10
-/* LTEXT "Realm", -1, 40, 46, 50, 10 */
- LTEXT "用户名", -1, 40, 66, 50, 10
- LTEXT "密码", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "请输入用户名和密码:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "代理", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "用户名", -1, 6, 66, 60, 10
+ LTEXT "密码", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "保存密码(不安全)(&S)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "确定", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "取消", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ DEFPUSHBUTTON "确定", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "取消", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }
 
 LANGUAGE LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL
@@ -55,22 +55,22 @@ STRINGTABLE
     IDS_ENTIRENETWORK "整個網路"
 }
 
-IDD_PROXYDLG DIALOG 36, 24, 250, 154
+IDD_PROXYDLG DIALOG 36, 24, 228, 145
 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
 CAPTION "輸入網路密碼"
 FONT 9, "MS Shell Dlg"
 {
- LTEXT "請輸入用戶名和密碼:", IDC_EXPLAIN, 40, 6, 150, 15
- LTEXT "代理", -1, 40, 26, 50, 10
-/* LTEXT "Realm", -1, 40, 46, 50, 10 */
- LTEXT "用戶名", -1, 40, 66, 50, 10
- LTEXT "密碼", -1, 40, 86, 50, 10
- LTEXT "", IDC_PROXY, 80, 26, 150, 14, 0
- LTEXT "", IDC_REALM, 80, 46, 150, 14, 0
- EDITTEXT IDC_USERNAME, 80, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
- EDITTEXT IDC_PASSWORD, 80, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
+ LTEXT "請輸入用戶名和密碼:", IDC_EXPLAIN, 6, 6, 150, 18
+ LTEXT "代理", -1, 6, 26, 60, 10
+/* LTEXT "Realm", -1, 6, 46, 60, 10 */
+ LTEXT "用戶名", -1, 6, 66, 60, 10
+ LTEXT "密碼", -1, 6, 86, 60, 10
+ LTEXT "", IDC_PROXY, 70, 26, 150, 14, 0
+ LTEXT "", IDC_REALM, 70, 46, 150, 14, 0
+ EDITTEXT IDC_USERNAME, 70, 66, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP
+ EDITTEXT IDC_PASSWORD, 70, 86, 150, 14, ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP | ES_PASSWORD
  CHECKBOX "儲存密碼(不安全)(&S)", IDC_SAVEPASSWORD,
-           80, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
- PUSHBUTTON "確定", IDOK, 98, 126, 56, 14, WS_GROUP | WS_TABSTOP | BS_DEFPUSHBUTTON
- PUSHBUTTON "取消", IDCANCEL, 158, 126, 56, 14, WS_GROUP | WS_TABSTOP
+           70, 106, 150, 12, BS_AUTOCHECKBOX | WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "確定", IDOK, 114, 126, 50, 14, WS_GROUP | WS_TABSTOP
+ PUSHBUTTON "取消", IDCANCEL, 170, 126, 50, 14, WS_GROUP | WS_TABSTOP
 }

dll/win32/mpr/wnet.c

@@ -1753,6 +1753,7 @@ static DWORD get_drive_connection( WCHAR letter, LPWSTR remote, LPDWORD size )
     struct mountmgr_unix_drive *data = (struct mountmgr_unix_drive *)buffer;
     HANDLE mgr;
     DWORD ret = WN_NOT_CONNECTED;
+    DWORD bytes_returned;
 
     if ((mgr = CreateFileW( MOUNTMGR_DOS_DEVICE_NAME, GENERIC_READ|GENERIC_WRITE,
                             FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
@@ -1764,7 +1765,7 @@ static DWORD get_drive_connection( WCHAR letter, LPWSTR remote, LPDWORD size )
     memset( data, 0, sizeof(*data) );
     data->letter = letter;
     if (DeviceIoControl( mgr, IOCTL_MOUNTMGR_QUERY_UNIX_DRIVE, data, sizeof(*data),
-                         data, sizeof(buffer), NULL, NULL ))
+                         data, sizeof(buffer), &bytes_returned, NULL ))
     {
         char *p, *mount_point = buffer + data->mount_point_offset;
         DWORD len;

dll/win32/secur32/lsalpc.c

@@ -108,9 +108,11 @@ LsapOpenLsaPort(VOID)
  */
 NTSTATUS
 NTAPI
-LsaEnumerateLogonSessions(PULONG LogonSessionCount,
-                          PLUID *LogonSessionList)
+LsaEnumerateLogonSessions(
+    PULONG LogonSessionCount,
+    PLUID *LogonSessionList)
 {
+#if 1
     LSA_API_MSG ApiMessage;
     NTSTATUS Status;
 
@@ -144,6 +146,10 @@ LsaEnumerateLogonSessions(PULONG LogonSessionCount,
     *LogonSessionList = ApiMessage.EnumLogonSessions.Reply.LogonSessionBuffer;
 
     return Status;
+#else
+    UNIMPLEMENTED;
+    return STATUS_NOT_IMPLEMENTED;
+#endif
 }
 
 
@@ -152,11 +158,59 @@ LsaEnumerateLogonSessions(PULONG LogonSessionCount,
  */
 NTSTATUS
 NTAPI
-LsaGetLogonSessionData(PLUID LogonId,
-                       PSECURITY_LOGON_SESSION_DATA *ppLogonSessionData)
+LsaGetLogonSessionData(
+    PLUID LogonId,
+    PSECURITY_LOGON_SESSION_DATA *ppLogonSessionData)
 {
+#if 1
+    LSA_API_MSG ApiMessage;
+    PSECURITY_LOGON_SESSION_DATA SessionData;
+    NTSTATUS Status;
+
+    TRACE("LsaGetLogonSessionData(%p %p)\n", LogonId, ppLogonSessionData);
+
+    Status = LsapOpenLsaPort();
+    if (!NT_SUCCESS(Status))
+        return Status;
+
+    ApiMessage.ApiNumber = LSASS_REQUEST_GET_LOGON_SESSION_DATA;
+    ApiMessage.h.u1.s1.DataLength = LSA_PORT_DATA_SIZE(ApiMessage.GetLogonSessionData);
+    ApiMessage.h.u1.s1.TotalLength = LSA_PORT_MESSAGE_SIZE;
+    ApiMessage.h.u2.ZeroInit = 0;
+
+    RtlCopyLuid(&ApiMessage.GetLogonSessionData.Request.LogonId,
+                LogonId);
+
+    Status = NtRequestWaitReplyPort(LsaPortHandle,
+                                    (PPORT_MESSAGE)&ApiMessage,
+                                    (PPORT_MESSAGE)&ApiMessage);
+    if (!NT_SUCCESS(Status))
+    {
+        ERR("NtRequestWaitReplyPort() failed (Status 0x%08lx)\n", Status);
+        return Status;
+    }
+
+    if (!NT_SUCCESS(ApiMessage.Status))
+    {
+        ERR("NtRequestWaitReplyPort() failed (ApiMessage.Status 0x%08lx)\n", ApiMessage.Status);
+        return ApiMessage.Status;
+    }
+
+    SessionData = ApiMessage.GetLogonSessionData.Reply.SessionDataBuffer;
+
+    if (SessionData->UserName.Buffer != NULL)
+        SessionData->UserName.Buffer = (LPWSTR)((ULONG_PTR)&SessionData->UserName.Buffer + (ULONG_PTR)SessionData->UserName.Buffer);
+
+    if (SessionData->Sid != NULL)
+        SessionData->Sid = (LPWSTR)((ULONG_PTR)&SessionData->Sid + (ULONG_PTR)SessionData->Sid);
+
+    *ppLogonSessionData = SessionData;
+
+    return Status;
+#else
     UNIMPLEMENTED;
     return STATUS_NOT_IMPLEMENTED;
+#endif
 }
 
 

include/dxsdk/d3drmwin.h

@@ -1,28 +0,0 @@
-
-#ifndef __D3DRMWIN_H__
-#define __D3DRMWIN_H__
-
-#ifndef WIN32
-#define WIN32
-#endif
-
-#include "d3drm.h"
-#include "ddraw.h"
-#include "d3d.h"
-
-#undef INTERFACE
-#define INTERFACE IDirect3DRMWinDevice
-
-DECLARE_INTERFACE_(IDirect3DRMWinDevice, IDirect3DRMObject)
-{
-  IUNKNOWN_METHODS(PURE);
-  IDIRECT3DRMOBJECT_METHODS(PURE);
-  STDMETHOD(HandlePaint) (THIS_ HDC hdc) PURE;
-  STDMETHOD(HandleActivate) (THIS_ WORD wparam) PURE;
-};
-
-DEFINE_GUID(IID_IDirect3DRMWinDevice, 0xC5016CC0, 0xD273, 0x11CE, 0xAC, 0x48, 0x0, 0x0, 0xC0, 0x38, 0x25, 0xA1);
-WIN_TYPES(IDirect3DRMWinDevice, DIRECT3DRMWINDEVICE);
-
-#endif
-

include/dxsdk/dsdriver.h

@@ -0,0 +1,366 @@
+/*
+ * DirectSound driver
+ * (DirectX 5 version)
+ *
+ * Copyright (C) 2000 Ove Kaaven
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef __WINE_DSDRIVER_H
+#define __WINE_DSDRIVER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*****************************************************************************
+ * Predeclare the interfaces
+ */
+DEFINE_GUID(IID_IDsDriver,		0x8C4233C0l, 0xB4CC, 0x11CE, 0x92, 0x94, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00);
+typedef struct IDsDriver *PIDSDRIVER;
+
+DEFINE_GUID(IID_IDsDriverBuffer,	0x8C4233C1l, 0xB4CC, 0x11CE, 0x92, 0x94, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00);
+typedef struct IDsDriverBuffer *PIDSDRIVERBUFFER;
+
+DEFINE_GUID(IID_IDsDriverPropertySet,	0x0F6F2E8E0, 0xD842, 0x11D0, 0x8F, 0x75, 0x00, 0xC0, 0x4F, 0xC2, 0x8A, 0xCA);
+typedef struct IDsDriverPropertySet *PIDSDRIVERPROPERTYSET;
+
+DEFINE_GUID(IID_IDsDriverNotify,	0x00363EF44, 0x3B57, 0x11D3, 0xAC, 0x79, 0x00, 0x10, 0x5A, 0x01, 0x7f, 0xe1);
+typedef struct IDsDriverNotify *PIDSDRIVERNOTIFY;
+
+DEFINE_GUID(IID_IDsCaptureDriver,	0x03DD10C47, 0x74FB, 0x11D3, 0x90, 0x49, 0xCB, 0xB4, 0xB3, 0x2E, 0xAA, 0x08);
+typedef struct IDsCaptureDriver *PIDSCDRIVER;
+
+DEFINE_GUID(IID_IDsCaptureDriverBuffer,	0x03DD10C48, 0x74FB, 0x11D3, 0x90, 0x49, 0xCB, 0xB4, 0xB3, 0x2E, 0xAA, 0x08);
+typedef struct IDsCaptureDriverBuffer *PIDSCDRIVERBUFFER;
+
+#define DSDDESC_DOMMSYSTEMOPEN		0x00000001
+#define DSDDESC_DOMMSYSTEMSETFORMAT	0x00000002
+#define DSDDESC_USESYSTEMMEMORY		0x00000004
+#define DSDDESC_DONTNEEDPRIMARYLOCK	0x00000008
+#define DSDDESC_DONTNEEDSECONDARYLOCK	0x00000010
+#define DSDDESC_DONTNEEDWRITELEAD	0x00000020
+
+#define DSDHEAP_NOHEAP			0
+#define DSDHEAP_CREATEHEAP		1
+#define DSDHEAP_USEDIRECTDRAWHEAP	2
+#define DSDHEAP_PRIVATEHEAP		3
+
+typedef struct _DSDRIVERDESC
+{
+    DWORD      	dwFlags;
+    CHAR	szDesc[256];
+    CHAR	szDrvname[256];
+    DWORD	dnDevNode;
+    WORD	wVxdId;
+    WORD	wReserved;
+    ULONG	ulDeviceNum;
+    DWORD	dwHeapType;
+    LPVOID	pvDirectDrawHeap;
+    DWORD	dwMemStartAddress;
+    DWORD	dwMemEndAddress;
+    DWORD	dwMemAllocExtra;
+    LPVOID	pvReserved1;
+    LPVOID	pvReserved2;
+} DSDRIVERDESC,*PDSDRIVERDESC;
+
+typedef struct _DSDRIVERCAPS
+{
+    DWORD	dwFlags;
+    DWORD	dwMinSecondarySampleRate;
+    DWORD	dwMaxSecondarySampleRate;
+    DWORD	dwPrimaryBuffers;
+    DWORD	dwMaxHwMixingAllBuffers;
+    DWORD	dwMaxHwMixingStaticBuffers;
+    DWORD	dwMaxHwMixingStreamingBuffers;
+    DWORD	dwFreeHwMixingAllBuffers;
+    DWORD	dwFreeHwMixingStaticBuffers;
+    DWORD	dwFreeHwMixingStreamingBuffers;
+    DWORD	dwMaxHw3DAllBuffers;
+    DWORD	dwMaxHw3DStaticBuffers;
+    DWORD	dwMaxHw3DStreamingBuffers;
+    DWORD	dwFreeHw3DAllBuffers;
+    DWORD	dwFreeHw3DStaticBuffers;
+    DWORD	dwFreeHw3DStreamingBuffers;
+    DWORD	dwTotalHwMemBytes;
+    DWORD	dwFreeHwMemBytes;
+    DWORD	dwMaxContigFreeHwMemBytes;
+} DSDRIVERCAPS,*PDSDRIVERCAPS;
+
+typedef struct _DSVOLUMEPAN
+{
+    DWORD	dwTotalLeftAmpFactor;
+    DWORD	dwTotalRightAmpFactor;
+    LONG	lVolume;
+    DWORD	dwVolAmpFactor;
+    LONG	lPan;
+    DWORD	dwPanLeftAmpFactor;
+    DWORD	dwPanRightAmpFactor;
+} DSVOLUMEPAN,*PDSVOLUMEPAN;
+
+typedef union _DSPROPERTY
+{
+    struct {
+	GUID	Set;
+	ULONG	Id;
+	ULONG	Flags;
+	ULONG	InstanceId;
+    } DUMMYSTRUCTNAME;
+    ULONGLONG	Alignment;
+} DSPROPERTY,*PDSPROPERTY;
+
+typedef struct _DSCDRIVERCAPS
+{
+    DWORD	dwSize;
+    DWORD	dwFlags;
+    DWORD	dwFormats;
+    DWORD	dwChannels;
+} DSCDRIVERCAPS,*PDSCDRIVERCAPS;
+
+/*****************************************************************************
+ * IDsDriver interface
+ */
+#define INTERFACE IDsDriver
+DECLARE_INTERFACE_(IDsDriver,IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+    /*** IDsDriver methods ***/
+    STDMETHOD(GetDriverDesc)(THIS_ PDSDRIVERDESC pDsDriverDesc) PURE;
+    STDMETHOD(Open)(THIS) PURE;
+    STDMETHOD(Close)(THIS) PURE;
+    STDMETHOD(GetCaps)(THIS_ PDSDRIVERCAPS pDsDrvCaps) PURE;
+    STDMETHOD(CreateSoundBuffer)(THIS_ LPWAVEFORMATEX pwfx,DWORD dwFlags,DWORD dwCardAddress,LPDWORD pdwcbBufferSize,LPBYTE *ppbBuffer,LPVOID *ppvObj) PURE;
+    STDMETHOD(DuplicateSoundBuffer)(THIS_ PIDSDRIVERBUFFER pIDsDriverBuffer,LPVOID *ppvObj) PURE;
+};
+#undef INTERFACE
+
+#if !defined (__cplusplus) || defined(CINTERFACE)
+    /*** IUnknown methods ***/
+#define IDsDriver_QueryInterface(p,a,b)         (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDsDriver_AddRef(p)                     (p)->lpVtbl->AddRef(p)
+#define IDsDriver_Release(p)                    (p)->lpVtbl->Release(p)
+    /*** IDsDriver methods ***/
+#define IDsDriver_GetDriverDesc(p,a)            (p)->lpVtbl->GetDriverDesc(p,a)
+#define IDsDriver_Open(p)                       (p)->lpVtbl->Open(p)
+#define IDsDriver_Close(p)                      (p)->lpVtbl->Close(p)
+#define IDsDriver_GetCaps(p,a)                  (p)->lpVtbl->GetCaps(p,a)
+#define IDsDriver_CreateSoundBuffer(p,a,b,c,d,e,f) (p)->lpVtbl->CreateSoundBuffer(p,a,b,c,d,e,f)
+#define IDsDriver_DuplicateSoundBuffer(p,a,b)   (p)->lpVtbl->DuplicateSoundBuffer(p,a,b)
+#endif
+
+/*****************************************************************************
+ * IDsDriverBuffer interface
+ */
+#define INTERFACE IDsDriverBuffer
+DECLARE_INTERFACE_(IDsDriverBuffer,IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+    /*** IDsDriverBuffer methods ***/
+    STDMETHOD(Lock)(THIS_ LPVOID *ppvAudio1,LPDWORD pdwLen1,LPVOID *pdwAudio2,LPDWORD pdwLen2,DWORD dwWritePosition,DWORD dwWriteLen,DWORD dwFlags) PURE;
+    STDMETHOD(Unlock)(THIS_ LPVOID pvAudio1,DWORD dwLen1,LPVOID pvAudio2,DWORD dwLen2) PURE;
+    STDMETHOD(SetFormat)(THIS_ LPWAVEFORMATEX pwfxToSet) PURE;
+    STDMETHOD(SetFrequency)(THIS_ DWORD dwFrequency) PURE;
+    STDMETHOD(SetVolumePan)(THIS_ PDSVOLUMEPAN pDsVolumePan) PURE;
+    STDMETHOD(SetPosition)(THIS_ DWORD dwNewPosition) PURE;
+    STDMETHOD(GetPosition)(THIS_ LPDWORD lpdwCurrentPlayCursor,LPDWORD lpdwCurrentWriteCursor) PURE;
+    STDMETHOD(Play)(THIS_ DWORD dwReserved1,DWORD dwReserved2,DWORD dwFlags) PURE;
+    STDMETHOD(Stop)(THIS) PURE;
+};
+#undef INTERFACE
+
+#if !defined (__cplusplus) || defined(CINTERFACE)
+    /*** IUnknown methods ***/
+#define IDsDriverBuffer_QueryInterface(p,a,b)   (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDsDriverBuffer_AddRef(p)               (p)->lpVtbl->AddRef(p)
+#define IDsDriverBuffer_Release(p)              (p)->lpVtbl->Release(p)
+    /*** IDsDriverBuffer methods ***/
+#define IDsDriverBuffer_Lock(p,a,b,c,d,e,f,g)   (p)->lpVtbl->Lock(p,a,b,c,d,e,f,g)
+#define IDsDriverBuffer_Unlock(p,a,b,c,d)       (p)->lpVtbl->Unlock(p,a,b,c,d)
+#define IDsDriverBuffer_SetFormat(p,a)          (p)->lpVtbl->SetFormat(p,a)
+#define IDsDriverBuffer_SetFrequency(p,a)       (p)->lpVtbl->SetFrequency(p,a)
+#define IDsDriverBuffer_SetVolumePan(p,a)       (p)->lpVtbl->SetVolumePan(p,a)
+#define IDsDriverBuffer_SetPosition(p,a)        (p)->lpVtbl->SetPosition(p,a)
+#define IDsDriverBuffer_GetPosition(p,a,b)      (p)->lpVtbl->GetPosition(p,a,b)
+#define IDsDriverBuffer_Play(p,a,b,c)           (p)->lpVtbl->Play(p,a,b,c)
+#define IDsDriverBuffer_Stop(p)                 (p)->lpVtbl->Stop(p)
+#endif
+
+/*****************************************************************************
+ * IDsDriverPropertySet interface
+ */
+#define INTERFACE IDsDriverPropertySet
+DECLARE_INTERFACE_(IDsDriverPropertySet,IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+    /*** IDsDriverPropertySet methods ***/
+    STDMETHOD(Get)(THIS_ PDSPROPERTY pDsProperty,LPVOID pPropertyParams,ULONG cbPropertyParams,LPVOID pPropertyData,ULONG cbPropertyData,PULONG pcbReturnedData) PURE;
+    STDMETHOD(Set)(THIS_ PDSPROPERTY pDsProperty,LPVOID pPropertyParams,ULONG cbPropertyParams,LPVOID pPropertyData,ULONG cbPropertyData) PURE;
+    STDMETHOD(QuerySupport)(THIS_ REFGUID PropertySetId,ULONG PropertyId,PULONG pSupport) PURE;
+};
+#undef INTERFACE
+
+#if !defined (__cplusplus) || defined(CINTERFACE)
+    /*** IUnknown methods ***/
+#define IDsDriverPropertySet_QueryInterface(p,a,b)      (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDsDriverPropertySet_AddRef(p)                  (p)->lpVtbl->AddRef(p)
+#define IDsDriverPropertySet_Release(p)                 (p)->lpVtbl->Release(p)
+    /*** IDsDriverPropertySet methods ***/
+#define IDsDriverPropertySet_Get(p,a,b,c,d,e,f)         (p)->lpVtbl->Get(p,a,b,c,d,e,f)
+#define IDsDriverPropertySet_Set(p,a,b,c,d,e)           (p)->lpVtbl->Set(p,a,b,c,d,e)
+#define IDsDriverPropertySet_QuerySupport(p,a,b,c)      (p)->lpVtbl->QuerySupport(p,a,b,c)
+#endif
+
+/* Defined property sets */
+DEFINE_GUID(DSPROPSETID_DirectSound3DListener,	  0x6D047B40, 0x7AF9, 0x11D0, 0x92, 0x94, 0x44, 0x45, 0x53, 0x54, 0x0, 0x0);
+typedef enum
+{
+    DSPROPERTY_DIRECTSOUND3DLISTENER_ALL,
+    DSPROPERTY_DIRECTSOUND3DLISTENER_POSITION,
+    DSPROPERTY_DIRECTSOUND3DLISTENER_VELOCITY,
+    DSPROPERTY_DIRECTSOUND3DLISTENER_ORIENTATION,
+    DSPROPERTY_DIRECTSOUND3DLISTENER_DISTANCEFACTOR,
+    DSPROPERTY_DIRECTSOUND3DLISTENER_ROLLOFFFACTOR,
+    DSPROPERTY_DIRECTSOUND3DLISTENER_DOPPLERFACTOR,
+    DSPROPERTY_DIRECTSOUND3DLISTENER_BATCH,
+    DSPROPERTY_DIRECTSOUND3DLISTENER_ALLOCATION
+} DSPROPERTY_DIRECTSOUND3DLISTENER;
+
+DEFINE_GUID(DSPROPSETID_DirectSound3DBuffer,	  0x6D047B41, 0x7AF9, 0x11D0, 0x92, 0x94, 0x44, 0x45, 0x53, 0x54, 0x0, 0x0);
+typedef enum
+{
+    DSPROPERTY_DIRECTSOUND3DBUFFER_ALL,
+    DSPROPERTY_DIRECTSOUND3DBUFFER_POSITION,
+    DSPROPERTY_DIRECTSOUND3DBUFFER_VELOCITY,
+    DSPROPERTY_DIRECTSOUND3DBUFFER_CONEANGLES,
+    DSPROPERTY_DIRECTSOUND3DBUFFER_CONEORIENTATION,
+    DSPROPERTY_DIRECTSOUND3DBUFFER_CONEOUTSIDEVOLUME,
+    DSPROPERTY_DIRECTSOUND3DBUFFER_MINDISTANCE,
+    DSPROPERTY_DIRECTSOUND3DBUFFER_MAXDISTANCE,
+    DSPROPERTY_DIRECTSOUND3DBUFFER_MODE
+} DSPROPERTY_DIRECTSOUND3DBUFFER;
+
+DEFINE_GUID(DSPROPSETID_DirectSoundSpeakerConfig, 0x6D047B42, 0x7AF9, 0x11D0, 0x92, 0x94, 0x44, 0x45, 0x53, 0x54, 0x0, 0x0);
+typedef enum
+{
+    DSPROPERTY_DIRECTSOUNDSPEAKERCONFIG_SPEAKERCONFIG
+} DSPROPERTY_DIRECTSOUNDSPEAKERCONFIG;
+
+/*****************************************************************************
+ * IDsDriverNotify interface
+ */
+#define INTERFACE IDsDriverNotify
+DECLARE_INTERFACE_(IDsDriverNotify,IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+    /*** IDsDriverNotify methods ***/
+    STDMETHOD(SetNotificationPositions)(THIS_ DWORD dwPositionNotifies,LPCDSBPOSITIONNOTIFY pcPositionNotifies) PURE;
+};
+#undef INTERFACE
+
+#if !defined (__cplusplus) || defined(CINTERFACE)
+    /*** IUnknown methods ***/
+#define IDsDriverNotify_QueryInterface(p,a,b)           (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDsDriverNotify_AddRef(p)                       (p)->lpVtbl->AddRef(p)
+#define IDsDriverNotify_Release(p)                      (p)->lpVtbl->Release(p)
+    /*** IDsDriverNotify methods ***/
+#define IDsDriverNotify_SetNotificationPositions(p,a,b) (p)->lpVtbl->SetNotificationPositions(p,a,b)
+#endif
+
+/*****************************************************************************
+ * IDsCaptureDriver interface
+ */
+#define INTERFACE IDsCaptureDriver
+DECLARE_INTERFACE_(IDsCaptureDriver,IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+    /*** IDsCaptureDriver methods ***/
+    STDMETHOD(GetDriverDesc)(THIS_ PDSDRIVERDESC pDsDriverDesc) PURE;
+    STDMETHOD(Open)(THIS) PURE;
+    STDMETHOD(Close)(THIS) PURE;
+    STDMETHOD(GetCaps)(THIS_ PDSCDRIVERCAPS pDsDrvCaps) PURE;
+    STDMETHOD(CreateCaptureBuffer)(THIS_ LPWAVEFORMATEX pwfx,DWORD dwFlags,DWORD dwCardAddress,LPDWORD pdwcbBufferSize,LPBYTE *ppbBuffer,LPVOID *ppvObj) PURE;
+};
+#undef INTERFACE
+
+#if !defined (__cplusplus) || defined(CINTERFACE)
+    /*** IUnknown methods ***/
+#define IDsCaptureDriver_QueryInterface(p,a,b)          (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDsCaptureDriver_AddRef(p)                      (p)->lpVtbl->AddRef(p)
+#define IDsCaptureDriver_Release(p)                     (p)->lpVtbl->Release(p)
+    /*** IDsCaptureDriver methods ***/
+#define IDsCaptureDriver_GetDriverDesc(p,a)             (p)->lpVtbl->GetDriverDesc(p,a)
+#define IDsCaptureDriver_Open(p)                        (p)->lpVtbl->Open(p)
+#define IDsCaptureDriver_Close(p)                       (p)->lpVtbl->Close(p)
+#define IDsCaptureDriver_GetCaps(p,a)                   (p)->lpVtbl->GetCaps(p,a)
+#define IDsCaptureDriver_CreateCaptureBuffer(p,a,b,c,d,e,f) (p)->lpVtbl->CreateCaptureBuffer(p,a,b,c,d,e,f)
+#endif
+
+/*****************************************************************************
+ * IDsCaptureDriverBuffer interface
+ */
+#define INTERFACE IDsCaptureDriverBuffer
+DECLARE_INTERFACE_(IDsCaptureDriverBuffer,IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+    /*** IDsCaptureDriverBuffer methods ***/
+    STDMETHOD(Lock)(THIS_ LPVOID *ppvAudio1,LPDWORD pdwLen1,LPVOID *ppvAudio2,LPDWORD pdwLen2,DWORD dwWritePosition,DWORD dwWriteLen,DWORD dwFlags) PURE;
+    STDMETHOD(Unlock)(THIS_ LPVOID pvAudio1,DWORD dwLen1,LPVOID pvAudio2,DWORD dwLen2) PURE;
+    STDMETHOD(SetFormat)(THIS_ LPWAVEFORMATEX pwfxToSet) PURE;
+    STDMETHOD(GetPosition)(THIS_ LPDWORD lpdwCurrentPlayCursor,LPDWORD lpdwCurrentWriteCursor) PURE;
+    STDMETHOD(GetStatus)(THIS_ LPDWORD lpdwStatus) PURE;
+    STDMETHOD(Start)(THIS_ DWORD dwFlags) PURE;
+    STDMETHOD(Stop)(THIS) PURE;
+};
+#undef INTERFACE
+
+#if !defined (__cplusplus) || defined(CINTERFACE)
+    /*** IUnknown methods ***/
+#define IDsCaptureDriverBuffer_QueryInterface(p,a,b)    (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDsCaptureDriverBuffer_AddRef(p)                (p)->lpVtbl->AddRef(p)
+#define IDsCaptureDriverBuffer_Release(p)               (p)->lpVtbl->Release(p)
+    /*** IDsCaptureDriverBuffer methods ***/
+#define IDsCaptureDriverBuffer_Lock(p,a,b,c,d,e,f,g)    (p)->lpVtbl->Lock(p,a,b,c,d,e,f,g)
+#define IDsCaptureDriverBuffer_Unlock(p,a,b,c,d)        (p)->lpVtbl->Unlock(p,a,b,c,d)
+#define IDsCaptureDriverBuffer_SetFormat(p,a)           (p)->lpVtbl->SetFormat(p,a)
+#define IDsCaptureDriverBuffer_GetPosition(p,a,b)       (p)->lpVtbl->GetPosition(p,a,b)
+#define IDsCaptureDriverBuffer_GetStatus(p,a)           (p)->lpVtbl->GetStatus(p,a)
+#define IDsCaptureDriverBuffer_Start(p,a)               (p)->lpVtbl->Start(p,a)
+#define IDsCaptureDriverBuffer_Stop(p)                  (p)->lpVtbl->Stop(p)
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* __WINE_DSDRIVER_H */

include/dxsdk/dxfile.h

@@ -260,7 +260,10 @@ DEFINE_GUID(TID_DXFILEHeader,               0x3d82ab43, 0x62da, 0x11cf, 0xab, 0x
 
 /* DirectX File errors */
 #define _FACDD  0x876
+
+#ifndef MAKE_DDHRESULT
 #define MAKE_DDHRESULT( code )  MAKE_HRESULT( 1, _FACDD, code )
+#endif
 
 #define DXFILE_OK   0
 

include/ndk/cmtypes.h

@@ -296,6 +296,7 @@ typedef struct _KEY_FULL_INFORMATION
 
 typedef struct _KEY_NAME_INFORMATION
 {
+    ULONG NameLength;
     WCHAR Name[1];
 } KEY_NAME_INFORMATION, *PKEY_NAME_INFORMATION;
 

include/psdk/d3drm.h

@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2005 Peter Berg Larsen
+ * Copyright (C) 2010 Christian Costa
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -20,8 +21,14 @@
 #define __D3DRM_H__
 
 #include <ddraw.h>
-/* #include <d3drmobj.h> */
 
+typedef struct IDirect3DRM *LPDIRECT3DRM, **LPLPDIRECT3DRM;
+
+#include <d3drmobj.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 /* Direct3DRM Object CLSID */
 DEFINE_GUID(CLSID_CDirect3DRM,              0x4516ec41, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3);
@@ -31,4 +38,487 @@ DEFINE_GUID(IID_IDirect3DRM,                0x2bc49361, 0x8327, 0x11cf, 0xac, 0x
 DEFINE_GUID(IID_IDirect3DRM2,               0x4516ecc8, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3);
 DEFINE_GUID(IID_IDirect3DRM3,               0x4516ec83, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3);
 
+typedef struct IDirect3DRM2 *LPDIRECT3DRM2, **LPLPDIRECT3DRM2;
+typedef struct IDirect3DRM3 *LPDIRECT3DRM3, **LPLPDIRECT3DRM3;
+
+HRESULT WINAPI Direct3DRMCreate(struct IDirect3DRM **d3drm);
+
+/*****************************************************************************
+ * IDirect3DRMObject interface
+ */
+#ifdef WINE_NO_UNICODE_MACROS
+#undef GetClassName
+#endif
+#define INTERFACE IDirect3DRM
+DECLARE_INTERFACE_(IDirect3DRM,IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+    /*** IDirect3DRM methods ***/
+    STDMETHOD(CreateObject)(THIS_ REFCLSID clsid, IUnknown *outer, REFIID iid, void **out) PURE;
+    STDMETHOD(CreateFrame)(THIS_ IDirect3DRMFrame *parent, IDirect3DRMFrame **frame) PURE;
+    STDMETHOD(CreateMesh)(THIS_ IDirect3DRMMesh **mesh) PURE;
+    STDMETHOD(CreateMeshBuilder)(THIS_ IDirect3DRMMeshBuilder **mesh_builder) PURE;
+    STDMETHOD(CreateFace)(THIS_ IDirect3DRMFace **face) PURE;
+    STDMETHOD(CreateAnimation)(THIS_ IDirect3DRMAnimation **animation) PURE;
+    STDMETHOD(CreateAnimationSet)(THIS_ IDirect3DRMAnimationSet **set) PURE;
+    STDMETHOD(CreateTexture)(THIS_ D3DRMIMAGE *image, IDirect3DRMTexture **texture) PURE;
+    STDMETHOD(CreateLight)(THIS_ D3DRMLIGHTTYPE type, D3DCOLOR color, IDirect3DRMLight **light) PURE;
+    STDMETHOD(CreateLightRGB)(THIS_ D3DRMLIGHTTYPE type, D3DVALUE r, D3DVALUE g, D3DVALUE b,
+            IDirect3DRMLight **light) PURE;
+    STDMETHOD(CreateMaterial)(THIS_ D3DVALUE power, IDirect3DRMMaterial **material) PURE;
+    STDMETHOD(CreateDevice)(THIS_ DWORD width, DWORD height, IDirect3DRMDevice **device) PURE;
+    STDMETHOD(CreateDeviceFromSurface)(THIS_ GUID *guid, IDirectDraw *ddraw,
+            IDirectDrawSurface *surface, IDirect3DRMDevice **device) PURE;
+    STDMETHOD(CreateDeviceFromD3D)(THIS_ IDirect3D *d3d, IDirect3DDevice *d3d_device,
+            IDirect3DRMDevice **device) PURE;
+    STDMETHOD(CreateDeviceFromClipper)(THIS_ IDirectDrawClipper *clipper, GUID *guid,
+            int width, int height, IDirect3DRMDevice **device) PURE;
+    STDMETHOD(CreateTextureFromSurface)(THIS_ IDirectDrawSurface *surface,
+            IDirect3DRMTexture **texture) PURE;
+    STDMETHOD(CreateShadow)(THIS_ IDirect3DRMVisual *visual, IDirect3DRMLight *light,
+            D3DVALUE px, D3DVALUE py, D3DVALUE pz, D3DVALUE nx, D3DVALUE ny, D3DVALUE nz,
+            IDirect3DRMVisual **shadow) PURE;
+    STDMETHOD(CreateViewport)(THIS_ IDirect3DRMDevice *device, IDirect3DRMFrame *camera,
+            DWORD x, DWORD y, DWORD width, DWORD height, IDirect3DRMViewport **viewport) PURE;
+    STDMETHOD(CreateWrap)(THIS_ D3DRMWRAPTYPE type, IDirect3DRMFrame *reference, D3DVALUE ox, D3DVALUE oy, D3DVALUE oz,
+        D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz, D3DVALUE ou, D3DVALUE ov,
+        D3DVALUE su, D3DVALUE sv, IDirect3DRMWrap **wrap) PURE;
+    STDMETHOD(CreateUserVisual)(THIS_ D3DRMUSERVISUALCALLBACK cb, void *ctx, IDirect3DRMUserVisual **visual) PURE;
+    STDMETHOD(LoadTexture)(THIS_ const char *filename, IDirect3DRMTexture **texture) PURE;
+    STDMETHOD(LoadTextureFromResource)(THIS_ HRSRC resource, IDirect3DRMTexture **texture) PURE;
+    STDMETHOD(SetSearchPath)(THIS_ const char *path) PURE;
+    STDMETHOD(AddSearchPath)(THIS_ const char *path) PURE;
+    STDMETHOD(GetSearchPath)(THIS_ DWORD *size, char *path) PURE;
+    STDMETHOD(SetDefaultTextureColors)(THIS_ DWORD) PURE;
+    STDMETHOD(SetDefaultTextureShades)(THIS_ DWORD) PURE;
+    STDMETHOD(GetDevices)(THIS_ IDirect3DRMDeviceArray **array) PURE;
+    STDMETHOD(GetNamedObject)(THIS_ const char *name, IDirect3DRMObject **object) PURE;
+    STDMETHOD(EnumerateObjects)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE;
+    STDMETHOD(Load)(THIS_ void *source, void *object_id, IID **iids, DWORD iid_count, D3DRMLOADOPTIONS flags,
+            D3DRMLOADCALLBACK load_cb, void *load_ctx, D3DRMLOADTEXTURECALLBACK load_tex_cb, void *load_tex_ctx,
+            IDirect3DRMFrame *parent_frame) PURE;
+    STDMETHOD(Tick)(THIS_ D3DVALUE) PURE;
+};
+#undef INTERFACE
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+/*** IUnknown methods ***/
+#define IDirect3DRM_QueryInterface(p,a,b)                         (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirect3DRM_AddRef(p)                                     (p)->lpVtbl->AddRef(p)
+#define IDirect3DRM_Release(p)                                    (p)->lpVtbl->Release(p)
+/*** IDirect3DRM methods ***/
+#define IDirect3DRM_CreateObject(p,a,b,c,d)                       (p)->lpVtbl->CreateObject(p,a,b,d)
+#define IDirect3DRM_CreateFrame(p,a,b)                            (p)->lpVtbl->CreateFrame(p,a,b)
+#define IDirect3DRM_CreateMesh(p,a)                               (p)->lpVtbl->CreateMesh(p,a)
+#define IDirect3DRM_CreateMeshBuilder(p,a)                        (p)->lpVtbl->CreateMeshBuilder(p,a)
+#define IDirect3DRM_CreateFace(p,a)                               (p)->lpVtbl->CreateFace(p,a)
+#define IDirect3DRM_CreateAnimation(p,a)                          (p)->lpVtbl->CreateAnimation(p,a)
+#define IDirect3DRM_CreateAnimationSet(p,a)                       (p)->lpVtbl->CreateAnimationSet(p,a)
+#define IDirect3DRM_CreateTexture(p,a,b)                          (p)->lpVtbl->CreateTexture(p,a,b)
+#define IDirect3DRM_CreateLight(p,a,b,c)                          (p)->lpVtbl->CreateLight(p,a,b,c)
+#define IDirect3DRM_CreateLightRGB(p,a,b,c,d,e)                   (p)->lpVtbl->CreateLightRGB(p,a,b,c,d,e)
+#define IDirect3DRM_CreateMaterial(p,a,b)                         (p)->lpVtbl->CreateMaterial(p,a,b)
+#define IDirect3DRM_CreateDevice(p,a,b,c)                         (p)->lpVtbl->CreateDevice(p,a,b,c)
+#define IDirect3DRM_CreateDeviceFromSurface(p,a,b,c,d)            (p)->lpVtbl->CreateDeviceFromSurface(p,a,b,c,d)
+#define IDirect3DRM_CreateDeviceFromD3D(p,a,b,c)                  (p)->lpVtbl->CreateDeviceFromD3D(p,a,b,c)
+#define IDirect3DRM_CreateDeviceFromClipper(p,a,b,c,d,e)          (p)->lpVtbl->CreateDeviceFromClipper(p,a,b,c,d,e)
+#define IDirect3DRM_CreateTextureFromSurface(p,a,b)               (p)->lpVtbl->CreateTextureFromSurface(p,a,b)
+#define IDirect3DRM_CreateShadow(p,a,b,c,d,e,f,g,h,i)             (p)->lpVtbl->CreateShadow(p,a,b,c,d,e,f,g,h,i)
+#define IDirect3DRM_CreateViewport(p,a,b,c,d,e,f,g)               (p)->lpVtbl->CreateViewport(p,a,b,c,d,e,f,g)
+#define IDirect3DRM_CreateWrap(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q) (p)->lpVtbl->CreateWrap(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q)
+#define IDirect3DRM_CreateUserVisual(p,a,b,c)                     (p)->lpVtbl->CreateUserVisual(p,a,b,c)
+#define IDirect3DRM_LoadTexture(p,a,b)                            (p)->lpVtbl->LoadTexture(p,a,b)
+#define IDirect3DRM_LoadTextureFromResource(p,a,b)                (p)->lpVtbl->LoadTextureFromResource(p,a,b)
+#define IDirect3DRM_SetSearchPath(p,a)                            (p)->lpVtbl->SetSearchPath(p,a)
+#define IDirect3DRM_AddSearchPath(p,a)                            (p)->lpVtbl->AddSearchPath(p,a)
+#define IDirect3DRM_GetSearchPath(p,a,b)                          (p)->lpVtbl->GetSearchPath(p,a,b)
+#define IDirect3DRM_SetDefaultTextureColors(p,a)                  (p)->lpVtbl->SetDefaultTextureColors(p,a)
+#define IDirect3DRM_SetDefaultTextureShades(p,a)                  (p)->lpVtbl->SetDefaultTextureShades(p,a)
+#define IDirect3DRM_GetDevices(p,a)                               (p)->lpVtbl->GetDevices(p,a)
+#define IDirect3DRM_GetNamedObject(p,a,b)                         (p)->lpVtbl->GetNamedObject(p,a,b)
+#define IDirect3DRM_EnumerateObjects(p,a,b)                       (p)->lpVtbl->EnumerateObjects(p,a,b)
+#define IDirect3DRM_Load(p,a,b,c,d,e,f,g,h,i,j)                   (p)->lpVtbl->Load(p,a,b,c,d,e,f,g,h,i,j)
+#define IDirect3DRM_Tick(p,a)                                     (p)->lpVtbl->Tick(p,a)
+#else
+/*** IUnknown methods ***/
+#define IDirect3DRM_QueryInterface(p,a,b)                         (p)->QueryInterface(a,b)
+#define IDirect3DRM_AddRef(p)                                     (p)->AddRef()
+#define IDirect3DRM_Release(p)                                    (p)->Release()
+/*** IDirect3DRM methods ***/
+#define IDirect3DRM_CreateObject(p,a,b,c,d)                       (p)->CreateObject(a,b,d)
+#define IDirect3DRM_CreateFrame(p,a,b)                            (p)->CreateFrame(a,b)
+#define IDirect3DRM_CreateMesh(p,a)                               (p)->CreateMesh(a)
+#define IDirect3DRM_CreateMeshBuilder(p,a)                        (p)->CreateMeshBuilder(a)
+#define IDirect3DRM_CreateFace(p,a)                               (p)->CreateFace(a)
+#define IDirect3DRM_CreateAnimation(p,a)                          (p)->CreateAnimation(a)
+#define IDirect3DRM_CreateAnimationSet(p,a)                       (p)->CreateAnimationSet(a)
+#define IDirect3DRM_CreateTexture(p,a,b)                          (p)->CreateTexture(a,b)
+#define IDirect3DRM_CreateLight(p,a,b,c)                          (p)->CreateLight(a,b,c)
+#define IDirect3DRM_CreateLightRGB(p,a,b,c,d,e)                   (p)->CreateLightRGB(a,b,c,d,e)
+#define IDirect3DRM_CreateMaterial(p,a,b)                         (p)->CreateMaterial(a,b)
+#define IDirect3DRM_CreateDevice(p,a,b,c)                         (p)->CreateDevice(a,b,c)
+#define IDirect3DRM_CreateDeviceFromSurface(p,a,b,c,d)            (p)->CreateDeviceFromSurface(a,b,c,d)
+#define IDirect3DRM_CreateDeviceFromD3D(p,a,b,c)                  (p)->CreateDeviceFromD3D(a,b,c)
+#define IDirect3DRM_CreateDeviceFromClipper(p,a,b,c,d,e)          (p)->CreateDeviceFromClipper(a,b,c,d,e)
+#define IDirect3DRM_CreateTextureFromSurface(p,a,b)               (p)->CreateTextureFromSurface(a,b)
+#define IDirect3DRM_CreateShadow(p,a,b,c,d,e,f,g,h,i)             (p)->CreateShadow(a,b,c,d,e,f,g,h,i)
+#define IDirect3DRM_CreateViewport(p,a,b,c,d,e,f,g)               (p)->CreateViewport(a,b,c,d,e,f,g)
+#define IDirect3DRM_CreateWrap(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q) (p)->CreateWrap(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q)
+#define IDirect3DRM_CreateUserVisual(p,a,b,c)                     (p)->CreateUserVisual(a,b,c)
+#define IDirect3DRM_LoadTexture(p,a,b)                            (p)->LoadTexture(a,b)
+#define IDirect3DRM_LoadTextureFromResource(p,a,b)                (p)->LoadTextureFromResource(a,b)
+#define IDirect3DRM_SetSearchPath(p,a)                            (p)->SetSearchPath(a)
+#define IDirect3DRM_AddSearchPath(p,a)                            (p)->AddSearchPath(a)
+#define IDirect3DRM_GetSearchPath(p,a,b)                          (p)->GetSearchPath(a,b)
+#define IDirect3DRM_SetDefaultTextureColors(p,a)                  (p)->SetDefaultTextureColors(a)
+#define IDirect3DRM_SetDefaultTextureShades(p,a)                  (p)->SetDefaultTextureShades(a)
+#define IDirect3DRM_GetDevices(p,a)                               (p)->GetDevices(a)
+#define IDirect3DRM_GetNamedObject(p,a,b)                         (p)->GetNamedObject(a,b)
+#define IDirect3DRM_EnumerateObjects(p,a,b)                       (p)->EnumerateObjects(a,b)
+#define IDirect3DRM_Load(p,a,b,c,d,e,f,g,h,i,j)                   (p)->Load(a,b,c,d,e,f,g,h,i,j)
+#define IDirect3DRM_Tick(p,a)                                     (p)->Tick(a)
+#endif
+
+/*****************************************************************************
+ * IDirect3DRM2 interface
+ */
+#ifdef WINE_NO_UNICODE_MACROS
+#undef GetClassName
+#endif
+#define INTERFACE IDirect3DRM2
+DECLARE_INTERFACE_(IDirect3DRM2,IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+    /*** IDirect3DRM2 methods ***/
+    STDMETHOD(CreateObject)(THIS_ REFCLSID clsid, IUnknown *outer, REFIID iid, void **out) PURE;
+    STDMETHOD(CreateFrame)(THIS_ IDirect3DRMFrame *parent, IDirect3DRMFrame2 **frame) PURE;
+    STDMETHOD(CreateMesh)(THIS_ IDirect3DRMMesh **mesh) PURE;
+    STDMETHOD(CreateMeshBuilder)(THIS_ IDirect3DRMMeshBuilder2 **mesh_builder) PURE;
+    STDMETHOD(CreateFace)(THIS_ IDirect3DRMFace **face) PURE;
+    STDMETHOD(CreateAnimation)(THIS_ IDirect3DRMAnimation **animation) PURE;
+    STDMETHOD(CreateAnimationSet)(THIS_ IDirect3DRMAnimationSet **set) PURE;
+    STDMETHOD(CreateTexture)(THIS_ D3DRMIMAGE *image, IDirect3DRMTexture2 **texture) PURE;
+    STDMETHOD(CreateLight)(THIS_ D3DRMLIGHTTYPE type, D3DCOLOR color, IDirect3DRMLight **light) PURE;
+    STDMETHOD(CreateLightRGB)(THIS_ D3DRMLIGHTTYPE type, D3DVALUE r, D3DVALUE g, D3DVALUE b,
+            IDirect3DRMLight **light) PURE;
+    STDMETHOD(CreateMaterial)(THIS_ D3DVALUE power, IDirect3DRMMaterial **material) PURE;
+    STDMETHOD(CreateDevice)(THIS_ DWORD width, DWORD height, IDirect3DRMDevice2 **device) PURE;
+    STDMETHOD(CreateDeviceFromSurface)(THIS_ GUID *guid, IDirectDraw *ddraw,
+            IDirectDrawSurface *surface, IDirect3DRMDevice2 **device) PURE;
+    STDMETHOD(CreateDeviceFromD3D)(THIS_ IDirect3D2 *d3d, IDirect3DDevice2 *d3d_device,
+            IDirect3DRMDevice2 **device) PURE;
+    STDMETHOD(CreateDeviceFromClipper)(THIS_ IDirectDrawClipper *clipper, GUID *guid,
+            int width, int height, IDirect3DRMDevice2 **device) PURE;
+    STDMETHOD(CreateTextureFromSurface)(THIS_ IDirectDrawSurface *surface,
+            IDirect3DRMTexture2 **texture) PURE;
+    STDMETHOD(CreateShadow)(THIS_ IDirect3DRMVisual *visual, IDirect3DRMLight *light,
+            D3DVALUE px, D3DVALUE py, D3DVALUE pz, D3DVALUE nx, D3DVALUE ny, D3DVALUE nz,
+            IDirect3DRMVisual **shadow) PURE;
+    STDMETHOD(CreateViewport)(THIS_ IDirect3DRMDevice *device, IDirect3DRMFrame *camera,
+            DWORD x, DWORD y, DWORD width, DWORD height, IDirect3DRMViewport **viewport) PURE;
+    STDMETHOD(CreateWrap)(THIS_ D3DRMWRAPTYPE type, IDirect3DRMFrame *reference, D3DVALUE ox, D3DVALUE oy, D3DVALUE oz,
+        D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz, D3DVALUE ou, D3DVALUE ov,
+        D3DVALUE su, D3DVALUE sv, IDirect3DRMWrap **wrap) PURE;
+    STDMETHOD(CreateUserVisual)(THIS_ D3DRMUSERVISUALCALLBACK cb, void *ctx, IDirect3DRMUserVisual **visual) PURE;
+    STDMETHOD(LoadTexture)(THIS_ const char *filename, IDirect3DRMTexture2 **texture) PURE;
+    STDMETHOD(LoadTextureFromResource)(THIS_ HMODULE module, const char *resource_name,
+            const char *resource_type, IDirect3DRMTexture2 **texture) PURE;
+    STDMETHOD(SetSearchPath)(THIS_ const char *path) PURE;
+    STDMETHOD(AddSearchPath)(THIS_ const char *path) PURE;
+    STDMETHOD(GetSearchPath)(THIS_ DWORD *size, char *path) PURE;
+    STDMETHOD(SetDefaultTextureColors)(THIS_ DWORD) PURE;
+    STDMETHOD(SetDefaultTextureShades)(THIS_ DWORD) PURE;
+    STDMETHOD(GetDevices)(THIS_ IDirect3DRMDeviceArray **array) PURE;
+    STDMETHOD(GetNamedObject)(THIS_ const char *name, IDirect3DRMObject **object) PURE;
+    STDMETHOD(EnumerateObjects)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE;
+    STDMETHOD(Load)(THIS_ void *source, void *object_id, IID **iids, DWORD iid_count, D3DRMLOADOPTIONS flags,
+            D3DRMLOADCALLBACK load_cb, void *load_ctx, D3DRMLOADTEXTURECALLBACK load_tex_cb, void *load_tex_ctx,
+            IDirect3DRMFrame *parent_frame) PURE;
+    STDMETHOD(Tick)(THIS_ D3DVALUE) PURE;
+    STDMETHOD(CreateProgressiveMesh)(THIS_ IDirect3DRMProgressiveMesh **mesh) PURE;
+};
+#undef INTERFACE
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+/*** IUnknown methods ***/
+#define IDirect3DRM2_QueryInterface(p,a,b)                         (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirect3DRM2_AddRef(p)                                     (p)->lpVtbl->AddRef(p)
+#define IDirect3DRM2_Release(p)                                    (p)->lpVtbl->Release(p)
+/*** IDirect3DRM2 methods ***/
+#define IDirect3DRM2_CreateObject(p,a,b,c,d)                       (p)->lpVtbl->CreateObject(p,a,b,d)
+#define IDirect3DRM2_CreateFrame(p,a,b)                            (p)->lpVtbl->CreateFrame(p,a,b)
+#define IDirect3DRM2_CreateMesh(p,a)                               (p)->lpVtbl->CreateMesh(p,a)
+#define IDirect3DRM2_CreateMeshBuilder(p,a)                        (p)->lpVtbl->CreateMeshBuilder(p,a)
+#define IDirect3DRM2_CreateFace(p,a)                               (p)->lpVtbl->CreateFace(p,a)
+#define IDirect3DRM2_CreateAnimation(p,a)                          (p)->lpVtbl->CreateAnimation(p,a)
+#define IDirect3DRM2_CreateAnimationSet(p,a)                       (p)->lpVtbl->CreateAnimationSet(p,a)
+#define IDirect3DRM2_CreateTexture(p,a,b)                          (p)->lpVtbl->CreateTexture(p,a,b)
+#define IDirect3DRM2_CreateLight(p,a,b,c)                          (p)->lpVtbl->CreateLight(p,a,b,c)
+#define IDirect3DRM2_CreateLightRGB(p,a,b,c,d,e)                   (p)->lpVtbl->CreateLightRGB(p,a,b,c,d,e)
+#define IDirect3DRM2_CreateMaterial(p,a,b)                         (p)->lpVtbl->CreateMaterial(p,a,b)
+#define IDirect3DRM2_CreateDevice(p,a,b,c)                         (p)->lpVtbl->CreateDevice(p,a,b,c)
+#define IDirect3DRM2_CreateDeviceFromSurface(p,a,b,c,d)            (p)->lpVtbl->CreateDeviceFromSurface(p,a,b,c,d)
+#define IDirect3DRM2_CreateDeviceFromD3D(p,a,b,c)                  (p)->lpVtbl->CreateDeviceFromD3D(p,a,b,c)
+#define IDirect3DRM2_CreateDeviceFromClipper(p,a,b,c,d,e)          (p)->lpVtbl->CreateDeviceFromClipper(p,a,b,c,d,e)
+#define IDirect3DRM2_CreateTextureFromSurface(p,a,b)               (p)->lpVtbl->CreateTextureFromSurface(p,a,b)
+#define IDirect3DRM2_CreateShadow(p,a,b,c,d,e,f,g,h,i)             (p)->lpVtbl->CreateShadow(p,a,b,c,d,e,f,g,h,i)
+#define IDirect3DRM2_CreateViewport(p,a,b,c,d,e,f,g)               (p)->lpVtbl->CreateViewport(p,a,b,c,d,e,f,g)
+#define IDirect3DRM2_CreateWrap(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q) (p)->lpVtbl->CreateWrap(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q)
+#define IDirect3DRM2_CreateUserVisual(p,a,b,c)                     (p)->lpVtbl->CreateUserVisual(p,a,b,c)
+#define IDirect3DRM2_LoadTexture(p,a,b)                            (p)->lpVtbl->LoadTexture(p,a,b)
+#define IDirect3DRM2_LoadTextureFromResource(p,a,b,c,d)            (p)->lpVtbl->LoadTextureFromResource(p,a,b,c,d)
+#define IDirect3DRM2_SetSearchPath(p,a)                            (p)->lpVtbl->SetSearchPath(p,a)
+#define IDirect3DRM2_AddSearchPath(p,a)                            (p)->lpVtbl->AddSearchPath(p,a)
+#define IDirect3DRM2_GetSearchPath(p,a,b)                          (p)->lpVtbl->GetSearchPath(p,a,b)
+#define IDirect3DRM2_SetDefaultTextureColors(p,a)                  (p)->lpVtbl->SetDefaultTextureColors(p,a)
+#define IDirect3DRM2_SetDefaultTextureShades(p,a)                  (p)->lpVtbl->SetDefaultTextureShades(p,a)
+#define IDirect3DRM2_GetDevices(p,a)                               (p)->lpVtbl->GetDevices(p,a)
+#define IDirect3DRM2_GetNamedObject(p,a,b)                         (p)->lpVtbl->GetNamedObject(p,a,b)
+#define IDirect3DRM2_EnumerateObjects(p,a,b)                       (p)->lpVtbl->EnumerateObjects(p,a,b)
+#define IDirect3DRM2_Load(p,a,b,c,d,e,f,g,h,i,j)                   (p)->lpVtbl->Load(p,a,b,c,d,e,f,g,h,i,j)
+#define IDirect3DRM2_Tick(p,a)                                     (p)->lpVtbl->Tick(p,a)
+#define IDirect3DRM2_CreateProgressiveMesh(p,a)                    (p)->lpVtbl->CreateProgressiveMesh(p,a)
+#else
+/*** IUnknown methods ***/
+#define IDirect3DRM2_QueryInterface(p,a,b)                         (p)->QueryInterface(a,b)
+#define IDirect3DRM2_AddRef(p)                                     (p)->AddRef()
+#define IDirect3DRM2_Release(p)                                    (p)->Release()
+/*** IDirect3DRM2 methods ***/
+#define IDirect3DRM2_CreateObject(p,a,b,c,d)                       (p)->CreateObject(a,b,d)
+#define IDirect3DRM2_CreateFrame(p,a,b)                            (p)->CreateFrame(a,b)
+#define IDirect3DRM2_CreateMesh(p,a)                               (p)->CreateMesh(a)
+#define IDirect3DRM2_CreateMeshBuilder(p,a)                        (p)->CreateMeshBuilder(a)
+#define IDirect3DRM2_CreateFace(p,a)                               (p)->CreateFace(a)
+#define IDirect3DRM2_CreateAnimation(p,a)                          (p)->CreateAnimation(a)
+#define IDirect3DRM2_CreateAnimationSet(p,a)                       (p)->CreateAnimationSet(a)
+#define IDirect3DRM2_CreateTexture(p,a,b)                          (p)->CreateTexture(a,b)
+#define IDirect3DRM2_CreateLight(p,a,b,c)                          (p)->CreateLight(a,b,c)
+#define IDirect3DRM2_CreateLightRGB(p,a,b,c,d,e)                   (p)->CreateLightRGB(a,b,c,d,e)
+#define IDirect3DRM2_CreateMaterial(p,a,b)                         (p)->CreateMaterial(a,b)
+#define IDirect3DRM2_CreateDevice(p,a,b,c)                         (p)->CreateDevice(a,b,c)
+#define IDirect3DRM2_CreateDeviceFromSurface(p,a,b,c,d)            (p)->CreateDeviceFromSurface(a,b,c,d)
+#define IDirect3DRM2_CreateDeviceFromD3D(p,a,b,c)                  (p)->CreateDeviceFromD3D(a,b,c)
+#define IDirect3DRM2_CreateDeviceFromClipper(p,a,b,c,d,e)          (p)->CreateDeviceFromClipper(a,b,c,d,e)
+#define IDirect3DRM2_CreateTextureFromSurface(p,a,b)               (p)->CreateTextureFromSurface(a,b)
+#define IDirect3DRM2_CreateShadow(p,a,b,c,d,e,f,g,h,i)             (p)->CreateShadow(a,b,c,d,e,f,g,h,i)
+#define IDirect3DRM2_CreateViewport(p,a,b,c,d,e,f,g)               (p)->CreateViewport(a,b,c,d,e,f,g)
+#define IDirect3DRM2_CreateWrap(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q) (p)->CreateWrap(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q)
+#define IDirect3DRM2_CreateUserVisual(p,a,b,c)                     (p)->CreateUserVisual(a,b,c)
+#define IDirect3DRM2_LoadTexture(p,a,b)                            (p)->LoadTexture(a,b)
+#define IDirect3DRM2_LoadTextureFromResource(p,a,b,c,d)            (p)->LoadTextureFromResource(a,b,c,d)
+#define IDirect3DRM2_SetSearchPath(p,a)                            (p)->SetSearchPath(a)
+#define IDirect3DRM2_AddSearchPath(p,a)                            (p)->AddSearchPath(a)
+#define IDirect3DRM2_GetSearchPath(p,a,b)                          (p)->GetSearchPath(a,b)
+#define IDirect3DRM2_SetDefaultTextureColors(p,a)                  (p)->SetDefaultTextureColors(a)
+#define IDirect3DRM2_SetDefaultTextureShades(p,a)                  (p)->SetDefaultTextureShades(a)
+#define IDirect3DRM2_GetDevices(p,a)                               (p)->GetDevices(a)
+#define IDirect3DRM2_GetNamedObject(p,a,b)                         (p)->GetNamedObject(a,b)
+#define IDirect3DRM2_EnumerateObjects(p,a,b)                       (p)->EnumerateObjects(a,b)
+#define IDirect3DRM2_Load(p,a,b,c,d,e,f,g,h,i,j)                   (p)->Load(a,b,c,d,e,f,g,h,i,j)
+#define IDirect3DRM2_Tick(p,a)                                     (p)->Tick(a)
+#define IDirect3DRM2_CreateProgressiveMesh(p,a)                    (p)->CreateProgressiveMesh(p,a)
+#endif
+
+/*****************************************************************************
+ * IDirect3DRM3 interface
+ */
+#ifdef WINE_NO_UNICODE_MACROS
+#undef GetClassName
+#endif
+#define INTERFACE IDirect3DRM3
+DECLARE_INTERFACE_(IDirect3DRM3,IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+    /*** IDirect3DRM2 methods ***/
+    STDMETHOD(CreateObject)(THIS_ REFCLSID clsid, IUnknown *outer, REFIID iid, void **out) PURE;
+    STDMETHOD(CreateFrame)(THIS_ IDirect3DRMFrame3 *parent, IDirect3DRMFrame3 **frame) PURE;
+    STDMETHOD(CreateMesh)(THIS_ IDirect3DRMMesh **mesh) PURE;
+    STDMETHOD(CreateMeshBuilder)(THIS_ IDirect3DRMMeshBuilder3 **mesh_builder) PURE;
+    STDMETHOD(CreateFace)(THIS_ IDirect3DRMFace2 **face) PURE;
+    STDMETHOD(CreateAnimation)(THIS_ IDirect3DRMAnimation2 **animation) PURE;
+    STDMETHOD(CreateAnimationSet)(THIS_ IDirect3DRMAnimationSet2 **set) PURE;
+    STDMETHOD(CreateTexture)(THIS_ D3DRMIMAGE *image, IDirect3DRMTexture3 **texture) PURE;
+    STDMETHOD(CreateLight)(THIS_ D3DRMLIGHTTYPE type, D3DCOLOR color, IDirect3DRMLight **light) PURE;
+    STDMETHOD(CreateLightRGB)(THIS_ D3DRMLIGHTTYPE type, D3DVALUE r, D3DVALUE g, D3DVALUE b,
+            IDirect3DRMLight **light) PURE;
+    STDMETHOD(CreateMaterial)(THIS_ D3DVALUE, IDirect3DRMMaterial2 **material) PURE;
+    STDMETHOD(CreateDevice)(THIS_ DWORD width, DWORD height, IDirect3DRMDevice3 **device) PURE;
+    STDMETHOD(CreateDeviceFromSurface)(THIS_ GUID *guid, IDirectDraw *ddraw,
+            IDirectDrawSurface *surface, IDirect3DRMDevice3 **device) PURE;
+    STDMETHOD(CreateDeviceFromD3D)(THIS_ IDirect3D2 *d3d, IDirect3DDevice2 *d3d_device,
+            IDirect3DRMDevice3 **device) PURE;
+    STDMETHOD(CreateDeviceFromClipper)(THIS_ IDirectDrawClipper *clipper, GUID *guid,
+            int width, int height, IDirect3DRMDevice3 **device) PURE;
+    STDMETHOD(CreateTextureFromSurface)(THIS_ IDirectDrawSurface *surface,
+            IDirect3DRMTexture3 **texture) PURE;
+    STDMETHOD(CreateShadow)(THIS_ IUnknown *object, IDirect3DRMLight *light, D3DVALUE px, D3DVALUE py, D3DVALUE pz,
+            D3DVALUE nx, D3DVALUE ny, D3DVALUE nz, IDirect3DRMShadow2 **shadow) PURE;
+    STDMETHOD(CreateViewport)(THIS_ IDirect3DRMDevice3 *device, IDirect3DRMFrame3 *camera,
+            DWORD x, DWORD y, DWORD width, DWORD height, IDirect3DRMViewport2 **viewport) PURE;
+    STDMETHOD(CreateWrap)(THIS_ D3DRMWRAPTYPE type, IDirect3DRMFrame3 *reference,
+            D3DVALUE ox, D3DVALUE oy, D3DVALUE oz, D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
+            D3DVALUE ux, D3DVALUE uy, D3DVALUE uz, D3DVALUE ou, D3DVALUE ov, D3DVALUE su, D3DVALUE sv,
+            IDirect3DRMWrap **wrap) PURE;
+    STDMETHOD(CreateUserVisual)(THIS_ D3DRMUSERVISUALCALLBACK cb, void *ctx, IDirect3DRMUserVisual **visual) PURE;
+    STDMETHOD(LoadTexture)(THIS_ const char *filename, IDirect3DRMTexture3 **texture) PURE;
+    STDMETHOD(LoadTextureFromResource)(THIS_ HMODULE module, const char *resource_name,
+            const char *resource_type, IDirect3DRMTexture3 **texture) PURE;
+    STDMETHOD(SetSearchPath)(THIS_ const char *path) PURE;
+    STDMETHOD(AddSearchPath)(THIS_ const char *path) PURE;
+    STDMETHOD(GetSearchPath)(THIS_ DWORD *size, char *path) PURE;
+    STDMETHOD(SetDefaultTextureColors)(THIS_ DWORD) PURE;
+    STDMETHOD(SetDefaultTextureShades)(THIS_ DWORD) PURE;
+    STDMETHOD(GetDevices)(THIS_ IDirect3DRMDeviceArray **array) PURE;
+    STDMETHOD(GetNamedObject)(THIS_ const char *name, IDirect3DRMObject **object) PURE;
+    STDMETHOD(EnumerateObjects)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE;
+    STDMETHOD(Load)(THIS_ void *source, void *object_id, IID **iids, DWORD iid_count, D3DRMLOADOPTIONS flags,
+            D3DRMLOADCALLBACK load_cb, void *load_ctx, D3DRMLOADTEXTURECALLBACK load_tex_cb, void *load_tex_ctx,
+            IDirect3DRMFrame3 *parent_frame) PURE;
+    STDMETHOD(Tick)(THIS_ D3DVALUE) PURE;
+    STDMETHOD(CreateProgressiveMesh)(THIS_ IDirect3DRMProgressiveMesh **mesh) PURE;
+    STDMETHOD(RegisterClient)(THIS_ REFGUID guid, DWORD *id) PURE;
+    STDMETHOD(UnregisterClient)(THIS_ REFGUID rguid) PURE;
+    STDMETHOD(CreateClippedVisual)(THIS_ IDirect3DRMVisual *visual, IDirect3DRMClippedVisual **clipped_visual) PURE;
+    STDMETHOD(SetOptions)(THIS_ DWORD) PURE;
+    STDMETHOD(GetOptions)(THIS_ DWORD *flags) PURE;
+};
+#undef INTERFACE
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+/*** IUnknown methods ***/
+#define IDirect3DRM3_QueryInterface(p,a,b)                         (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirect3DRM3_AddRef(p)                                     (p)->lpVtbl->AddRef(p)
+#define IDirect3DRM3_Release(p)                                    (p)->lpVtbl->Release(p)
+/*** IDirect3DRM3 methods ***/
+#define IDirect3DRM3_CreateObject(p,a,b,c,d)                       (p)->lpVtbl->CreateObject(p,a,b,d)
+#define IDirect3DRM3_CreateFrame(p,a,b)                            (p)->lpVtbl->CreateFrame(p,a,b)
+#define IDirect3DRM3_CreateMesh(p,a)                               (p)->lpVtbl->CreateMesh(p,a)
+#define IDirect3DRM3_CreateMeshBuilder(p,a)                        (p)->lpVtbl->CreateMeshBuilder(p,a)
+#define IDirect3DRM3_CreateFace(p,a)                               (p)->lpVtbl->CreateFace(p,a)
+#define IDirect3DRM3_CreateAnimation(p,a)                          (p)->lpVtbl->CreateAnimation(p,a)
+#define IDirect3DRM3_CreateAnimationSet(p,a)                       (p)->lpVtbl->CreateAnimationSet(p,a)
+#define IDirect3DRM3_CreateTexture(p,a,b)                          (p)->lpVtbl->CreateTexture(p,a,b)
+#define IDirect3DRM3_CreateLight(p,a,b,c)                          (p)->lpVtbl->CreateLight(p,a,b,c)
+#define IDirect3DRM3_CreateLightRGB(p,a,b,c,d,e)                   (p)->lpVtbl->CreateLightRGB(p,a,b,c,d,e)
+#define IDirect3DRM3_CreateMaterial(p,a,b)                         (p)->lpVtbl->CreateMaterial(p,a,b)
+#define IDirect3DRM3_CreateDevice(p,a,b,c)                         (p)->lpVtbl->CreateDevice(p,a,b,c)
+#define IDirect3DRM3_CreateDeviceFromSurface(p,a,b,c,d)            (p)->lpVtbl->CreateDeviceFromSurface(p,a,b,c,d)
+#define IDirect3DRM3_CreateDeviceFromD3D(p,a,b,c)                  (p)->lpVtbl->CreateDeviceFromD3D(p,a,b,c)
+#define IDirect3DRM3_CreateDeviceFromClipper(p,a,b,c,d,e)          (p)->lpVtbl->CreateDeviceFromClipper(p,a,b,c,d,e)
+#define IDirect3DRM3_CreateTextureFromSurface(p,a,b)               (p)->lpVtbl->CreateTextureFromSurface(p,a,b)
+#define IDirect3DRM3_CreateShadow(p,a,b,c,d,e,f,g,h,i)             (p)->lpVtbl->CreateShadow(p,a,b,c,d,e,f,g,h,i)
+#define IDirect3DRM3_CreateViewport(p,a,b,c,d,e,f,g)               (p)->lpVtbl->CreateViewport(p,a,b,c,d,e,f,g)
+#define IDirect3DRM3_CreateWrap(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q) (p)->lpVtbl->CreateWrap(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q)
+#define IDirect3DRM3_CreateUserVisual(p,a,b,c)                     (p)->lpVtbl->CreateUserVisual(p,a,b,c)
+#define IDirect3DRM3_LoadTexture(p,a,b)                            (p)->lpVtbl->LoadTexture(p,a,b)
+#define IDirect3DRM3_LoadTextureFromResource(p,a,b,c,d)            (p)->lpVtbl->LoadTextureFromResource(p,a,b,c,d)
+#define IDirect3DRM3_SetSearchPath(p,a)                            (p)->lpVtbl->SetSearchPath(p,a)
+#define IDirect3DRM3_AddSearchPath(p,a)                            (p)->lpVtbl->AddSearchPath(p,a)
+#define IDirect3DRM3_GetSearchPath(p,a,b)                          (p)->lpVtbl->GetSearchPath(p,a,b)
+#define IDirect3DRM3_SetDefaultTextureColors(p,a)                  (p)->lpVtbl->SetDefaultTextureColors(p,a)
+#define IDirect3DRM3_SetDefaultTextureShades(p,a)                  (p)->lpVtbl->SetDefaultTextureShades(p,a)
+#define IDirect3DRM3_GetDevices(p,a)                               (p)->lpVtbl->GetDevices(p,a)
+#define IDirect3DRM3_GetNamedObject(p,a,b)                         (p)->lpVtbl->GetNamedObject(p,a,b)
+#define IDirect3DRM3_EnumerateObjects(p,a,b)                       (p)->lpVtbl->EnumerateObjects(p,a,b)
+#define IDirect3DRM3_Load(p,a,b,c,d,e,f,g,h,i,j)                   (p)->lpVtbl->Load(p,a,b,c,d,e,f,g,h,i,j)
+#define IDirect3DRM3_Tick(p,a)                                     (p)->lpVtbl->Tick(p,a)
+#define IDirect3DRM3_CreateProgressiveMesh(p,a)                    (p)->lpVtbl->CreateProgressiveMesh(p,a)
+#define IDirect3DRM3_RegisterClient(p,a,b)                         (p)->lpVtbl->RegisterClient(p,a,b)
+#define IDirect3DRM3_UnregisterClient(p,a)                         (p)->lpVtbl->UnregisterClient(p,a)
+#define IDirect3DRM3_CreateClippedVisual(p,ab)                     (p)->lpVtbl->CreateClippedVisual(p,a,b)
+#define IDirect3DRM3_SetOptions(p,a)                               (p)->lpVtbl->SetOptions(p,a)
+#define IDirect3DRM3_GetOptions(p,a)                               (p)->lpVtbl->GetOptions(p,a)
+#else
+/*** IUnknown methods ***/
+#define IDirect3DRM3_QueryInterface(p,a,b)                         (p)->QueryInterface(a,b)
+#define IDirect3DRM3_AddRef(p)                                     (p)->AddRef()
+#define IDirect3DRM3_Release(p)                                    (p)->Release()
+/*** IDirect3DRM3 methods ***/
+#define IDirect3DRM3_CreateObject(p,a,b,c,d)                       (p)->CreateObject(a,b,d)
+#define IDirect3DRM3_CreateFrame(p,a,b)                            (p)->CreateFrame(a,b)
+#define IDirect3DRM3_CreateMesh(p,a)                               (p)->CreateMesh(a)
+#define IDirect3DRM3_CreateMeshBuilder(p,a)                        (p)->CreateMeshBuilder(a)
+#define IDirect3DRM3_CreateFace(p,a)                               (p)->CreateFace(a)
+#define IDirect3DRM3_CreateAnimation(p,a)                          (p)->CreateAnimation(a)
+#define IDirect3DRM3_CreateAnimationSet(p,a)                       (p)->CreateAnimationSet(a)
+#define IDirect3DRM3_CreateTexture(p,a,b)                          (p)->CreateTexture(a,b)
+#define IDirect3DRM3_CreateLight(p,a,b,c)                          (p)->CreateLight(a,b,c)
+#define IDirect3DRM3_CreateLightRGB(p,a,b,c,d,e)                   (p)->CreateLightRGB(a,b,c,d,e)
+#define IDirect3DRM3_CreateMaterial(p,a,b)                         (p)->CreateMaterial(a,b)
+#define IDirect3DRM3_CreateDevice(p,a,b,c)                         (p)->CreateDevice(a,b,c)
+#define IDirect3DRM3_CreateDeviceFromSurface(p,a,b,c,d)            (p)->CreateDeviceFromSurface(a,b,c,d)
+#define IDirect3DRM3_CreateDeviceFromD3D(p,a,b,c)                  (p)->CreateDeviceFromD3D(a,b,c)
+#define IDirect3DRM3_CreateDeviceFromClipper(p,a,b,c,d,e)          (p)->CreateDeviceFromClipper(a,b,c,d,e)
+#define IDirect3DRM3_CreateTextureFromSurface(p,a,b)               (p)->CreateTextureFromSurface(a,b)
+#define IDirect3DRM3_CreateShadow(p,a,b,c,d,e,f,g,h,i)             (p)->CreateShadow(a,b,c,d,e,f,g,h,i)
+#define IDirect3DRM3_CreateViewport(p,a,b,c,d,e,f,g)               (p)->CreateViewport(a,b,c,d,e,f,g)
+#define IDirect3DRM3_CreateWrap(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q) (p)->CreateWrap(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q)
+#define IDirect3DRM3_CreateUserVisual(p,a,b,c)                     (p)->CreateUserVisual(a,b,c)
+#define IDirect3DRM3_LoadTexture(p,a,b)                            (p)->LoadTexture(a,b)
+#define IDirect3DRM3_LoadTextureFromResource(p,a,b,c,d)            (p)->LoadTextureFromResource(a,b,c,d)
+#define IDirect3DRM3_SetSearchPath(p,a)                            (p)->SetSearchPath(a)
+#define IDirect3DRM3_AddSearchPath(p,a)                            (p)->AddSearchPath(a)
+#define IDirect3DRM3_GetSearchPath(p,a,b)                          (p)->GetSearchPath(a,b)
+#define IDirect3DRM3_SetDefaultTextureColors(p,a)                  (p)->SetDefaultTextureColors(a)
+#define IDirect3DRM3_SetDefaultTextureShades(p,a)                  (p)->SetDefaultTextureShades(a)
+#define IDirect3DRM3_GetDevices(p,a)                               (p)->GetDevices(a)
+#define IDirect3DRM3_GetNamedObject(p,a,b)                         (p)->GetNamedObject(a,b)
+#define IDirect3DRM3_EnumerateObjects(p,a,b)                       (p)->EnumerateObjects(a,b)
+#define IDirect3DRM3_Load(p,a,b,c,d,e,f,g,h,i,j)                   (p)->Load(a,b,c,d,e,f,g,h,i,j)
+#define IDirect3DRM3_Tick(p,a)                                     (p)->Tick(a)
+#define IDirect3DRM3_CreateProgressiveMesh(p,a)                    (p)->CreateProgressiveMesh(p,a)
+#define IDirect3DRM3_RegisterClient(p,a,b)                         (p)->RegisterClient(p,a,b)
+#define IDirect3DRM3_UnregisterClient(p,a)                         (p)->UnregisterClient(p,a)
+#define IDirect3DRM3_CreateClippedVisual(p,ab)                     (p)->CreateClippedVisual(p,a,b)
+#define IDirect3DRM3_SetOptions(p,a)                               (p)->SetOptions(p,a)
+#define IDirect3DRM3_GetOptions(p,a)                               (p)->GetOptions(p,a)
+#endif
+
+#define D3DRM_OK                        DD_OK
+#define D3DRMERR_BADOBJECT              MAKE_DDHRESULT(781)
+#define D3DRMERR_BADTYPE                MAKE_DDHRESULT(782)
+#define D3DRMERR_BADALLOC               MAKE_DDHRESULT(783)
+#define D3DRMERR_FACEUSED               MAKE_DDHRESULT(784)
+#define D3DRMERR_NOTFOUND               MAKE_DDHRESULT(785)
+#define D3DRMERR_NOTDONEYET             MAKE_DDHRESULT(786)
+#define D3DRMERR_FILENOTFOUND           MAKE_DDHRESULT(787)
+#define D3DRMERR_BADFILE                MAKE_DDHRESULT(788)
+#define D3DRMERR_BADDEVICE              MAKE_DDHRESULT(789)
+#define D3DRMERR_BADVALUE               MAKE_DDHRESULT(790)
+#define D3DRMERR_BADMAJORVERSION        MAKE_DDHRESULT(791)
+#define D3DRMERR_BADMINORVERSION        MAKE_DDHRESULT(792)
+#define D3DRMERR_UNABLETOEXECUTE        MAKE_DDHRESULT(793)
+#define D3DRMERR_LIBRARYNOTFOUND        MAKE_DDHRESULT(794)
+#define D3DRMERR_INVALIDLIBRARY         MAKE_DDHRESULT(795)
+#define D3DRMERR_PENDING                MAKE_DDHRESULT(796)
+#define D3DRMERR_NOTENOUGHDATA          MAKE_DDHRESULT(797)
+#define D3DRMERR_REQUESTTOOLARGE        MAKE_DDHRESULT(798)
+#define D3DRMERR_REQUESTTOOSMALL        MAKE_DDHRESULT(799)
+#define D3DRMERR_CONNECTIONLOST         MAKE_DDHRESULT(800)
+#define D3DRMERR_LOADABORTED            MAKE_DDHRESULT(801)
+#define D3DRMERR_NOINTERNET             MAKE_DDHRESULT(802)
+#define D3DRMERR_BADCACHEFILE           MAKE_DDHRESULT(803)
+#define D3DRMERR_BOXNOTSET              MAKE_DDHRESULT(804)
+#define D3DRMERR_BADPMDATA              MAKE_DDHRESULT(805)
+#define D3DRMERR_CLIENTNOTREGISTERED    MAKE_DDHRESULT(806)
+#define D3DRMERR_NOTCREATEDFROMDDS      MAKE_DDHRESULT(807)
+#define D3DRMERR_NOSUCHKEY              MAKE_DDHRESULT(808)
+#define D3DRMERR_INCOMPATABLEKEY        MAKE_DDHRESULT(809)
+#define D3DRMERR_ELEMENTINUSE           MAKE_DDHRESULT(810)
+#define D3DRMERR_TEXTUREFORMATNOTFOUND  MAKE_DDHRESULT(811)
+#define D3DRMERR_NOTAGGREGATED          MAKE_DDHRESULT(812)
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* __D3DRM_H__ */

include/psdk/d3drmdef.h

@@ -1,6 +1,7 @@
 /*
- * Copyright 2007 Vijay Kiran Kamuju
+ * Copyright 2007,2010 Vijay Kiran Kamuju
  * Copyright 2007 David ADAM
+ * Copyright 2010 Christian Costa
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -27,32 +28,429 @@
 extern "C" {
 #endif
 
-typedef D3DVALUE D3DRMMATRIX4D[4][4];
-typedef struct _D3DRMQUATERNION
+typedef struct _D3DRMVECTOR4D
 {
+    D3DVALUE x;
+    D3DVALUE y;
+    D3DVALUE z;
+    D3DVALUE w;
+} D3DRMVECTOR4D, *LPD3DRMVECTOR4D;
+
+typedef D3DVALUE D3DRMMATRIX4D[4][4];
+
+typedef struct _D3DRMQUATERNION {
     D3DVALUE s;
     D3DVECTOR v;
 } D3DRMQUATERNION, *LPD3DRMQUATERNION;
 
-void WINAPI D3DRMMatrixFromQuaternion(D3DRMMATRIX4D, LPD3DRMQUATERNION);
+typedef struct _D3DRMRAY {
+    D3DVECTOR dvDir;
+    D3DVECTOR dvPos;
+} D3DRMRAY, *LPD3DRMRAY;
 
-LPD3DRMQUATERNION WINAPI D3DRMQuaternionFromRotation(LPD3DRMQUATERNION ,LPD3DVECTOR,D3DVALUE);
-LPD3DRMQUATERNION WINAPI D3DRMQuaternionMultiply(LPD3DRMQUATERNION, LPD3DRMQUATERNION, LPD3DRMQUATERNION);
-LPD3DRMQUATERNION WINAPI D3DRMQuaternionSlerp(LPD3DRMQUATERNION, LPD3DRMQUATERNION, LPD3DRMQUATERNION, D3DVALUE);
+typedef struct _D3DRMBOX {
+    D3DVECTOR min;
+    D3DVECTOR max;
+} D3DRMBOX, *LPD3DRMBOX;
 
-LPD3DVECTOR WINAPI D3DRMVectorAdd(LPD3DVECTOR, LPD3DVECTOR, LPD3DVECTOR);
-LPD3DVECTOR WINAPI D3DRMVectorCrossProduct(LPD3DVECTOR, LPD3DVECTOR, LPD3DVECTOR);
-D3DVALUE WINAPI D3DRMVectorDotProduct(LPD3DVECTOR, LPD3DVECTOR);
-LPD3DVECTOR WINAPI D3DRMVectorNormalize(LPD3DVECTOR);
+typedef void (*D3DRMWRAPCALLBACK)(D3DVECTOR *vec, int *u, int *v, D3DVECTOR *a, D3DVECTOR *b, void *ctx);
+
+typedef enum _D3DRMLIGHTTYPE {
+    D3DRMLIGHT_AMBIENT,
+    D3DRMLIGHT_POINT,
+    D3DRMLIGHT_SPOT,
+    D3DRMLIGHT_DIRECTIONAL,
+    D3DRMLIGHT_PARALLELPOINT
+} D3DRMLIGHTTYPE, *LPD3DRMLIGHTTYPE;
+
+typedef enum _D3DRMSHADEMODE {
+    D3DRMSHADE_FLAT     = 0,
+    D3DRMSHADE_GOURAUD  = 1,
+    D3DRMSHADE_PHONG    = 2,
+    D3DRMSHADE_MASK     = 7,
+    D3DRMSHADE_MAX      = 8
+} D3DRMSHADEMODE, *LPD3DRMSHADEMODE;
+
+typedef enum _D3DRMLIGHTMODE {
+    D3DRMLIGHT_OFF      = 0 * D3DRMSHADE_MAX,
+    D3DRMLIGHT_ON       = 1 * D3DRMSHADE_MAX,
+    D3DRMLIGHT_MASK     = 7 * D3DRMSHADE_MAX,
+    D3DRMLIGHT_MAX      = 8 * D3DRMSHADE_MAX
+} D3DRMLIGHTMODE, *LPD3DRMLIGHTMODE;
+
+typedef enum _D3DRMFILLMODE {
+    D3DRMFILL_POINTS    = 0 * D3DRMLIGHT_MAX,
+    D3DRMFILL_WIREFRAME	= 1 * D3DRMLIGHT_MAX,
+    D3DRMFILL_SOLID     = 2 * D3DRMLIGHT_MAX,
+    D3DRMFILL_MASK      = 7 * D3DRMLIGHT_MAX,
+    D3DRMFILL_MAX       = 8 * D3DRMLIGHT_MAX
+} D3DRMFILLMODE, *LPD3DRMFILLMODE;
+
+typedef DWORD D3DRMRENDERQUALITY, *LPD3DRMRENDERQUALITY;
+
+#define D3DRMRENDER_WIREFRAME   (D3DRMSHADE_FLAT+D3DRMLIGHT_OFF+D3DRMFILL_WIREFRAME)
+#define D3DRMRENDER_UNLITFLAT   (D3DRMSHADE_FLAT+D3DRMLIGHT_OFF+D3DRMFILL_SOLID)
+#define D3DRMRENDER_FLAT        (D3DRMSHADE_FLAT+D3DRMLIGHT_ON+D3DRMFILL_SOLID)
+#define D3DRMRENDER_GOURAUD     (D3DRMSHADE_GOURAUD+D3DRMLIGHT_ON+D3DRMFILL_SOLID)
+#define D3DRMRENDER_PHONG       (D3DRMSHADE_PHONG+D3DRMLIGHT_ON+D3DRMFILL_SOLID
+
+#define D3DRMRENDERMODE_BLENDEDTRANSPARENCY       1
+#define D3DRMRENDERMODE_SORTEDTRANSPARENCY        2
+#define D3DRMRENDERMODE_LIGHTINMODELSPACE         8
+#define D3DRMRENDERMODE_VIEWDEPENDENTSPECULAR    16
+#define D3DRMRENDERMODE_DISABLESORTEDALPHAZWRITE 32
+
+typedef enum _D3DRMTEXTUREQUALITY {
+    D3DRMTEXTURE_NEAREST,
+    D3DRMTEXTURE_LINEAR,
+    D3DRMTEXTURE_MIPNEAREST,
+    D3DRMTEXTURE_MIPLINEAR,
+    D3DRMTEXTURE_LINEARMIPNEAREST,
+    D3DRMTEXTURE_LINEARMIPLINEAR
+} D3DRMTEXTUREQUALITY, *LPD3DRMTEXTUREQUALITY;
+
+#define D3DRMTEXTURE_FORCERESIDENT          0x00000001
+#define D3DRMTEXTURE_STATIC                 0x00000002
+#define D3DRMTEXTURE_DOWNSAMPLEPOINT        0x00000004
+#define D3DRMTEXTURE_DOWNSAMPLEBILINEAR	    0x00000008
+#define D3DRMTEXTURE_DOWNSAMPLEREDUCEDEPTH  0x00000010
+#define D3DRMTEXTURE_DOWNSAMPLENONE         0x00000020
+#define D3DRMTEXTURE_CHANGEDPIXELS          0x00000040
+#define D3DRMTEXTURE_CHANGEDPALETTE         0x00000080
+#define D3DRMTEXTURE_INVALIDATEONLY         0x00000100
+
+#define D3DRMSHADOW_TRUEALPHA               0x00000001
+
+typedef enum _D3DRMCOMBINETYPE {
+    D3DRMCOMBINE_REPLACE,
+    D3DRMCOMBINE_BEFORE,
+    D3DRMCOMBINE_AFTER
+} D3DRMCOMBINETYPE, *LPD3DRMCOMBINETYPE;
+
+typedef D3DCOLORMODEL D3DRMCOLORMODEL, *LPD3DRMCOLORMODEL;
+
+typedef enum _D3DRMPALETTEFLAGS
+{
+    D3DRMPALETTE_FREE,
+    D3DRMPALETTE_READONLY,
+    D3DRMPALETTE_RESERVED
+} D3DRMPALETTEFLAGS, *LPD3DRMPALETTEFLAGS;
+
+typedef struct _D3DRMPALETTEENTRY {
+    unsigned char red;
+    unsigned char green;
+    unsigned char blue;
+    unsigned char flags;
+} D3DRMPALETTEENTRY, *LPD3DRMPALETTEENTRY;
+
+typedef struct _D3DRMIMAGE {
+    int width;
+    int height;
+    int aspectx;
+    int aspecty;
+    int depth;
+    int rgb;
+    int bytes_per_line;
+    void* buffer1;
+    void* buffer2;
+    ULONG red_mask;
+    ULONG green_mask;
+    ULONG blue_mask;
+    ULONG alpha_mask;
+    int palette_size;
+    D3DRMPALETTEENTRY* palette;
+} D3DRMIMAGE, *LPD3DRMIMAGE;
+
+typedef enum _D3DRMWRAPTYPE {
+    D3DRMWRAP_FLAT,
+    D3DRMWRAP_CYLINDER,
+    D3DRMWRAP_SPHERE,
+    D3DRMWRAP_CHROME,
+    D3DRMWRAP_SHEET,
+    D3DRMWRAP_BOX
+} D3DRMWRAPTYPE, *LPD3DRMWRAPTYPE;
+
+#define D3DRMWIREFRAME_CULL             1
+#define D3DRMWIREFRAME_HIDDENLINE       2
+
+typedef enum _D3DRMPROJECTIONTYPE
+{
+    D3DRMPROJECT_PERSPECTIVE,
+    D3DRMPROJECT_ORTHOGRAPHIC,
+    D3DRMPROJECT_RIGHTHANDPERSPECTIVE,
+    D3DRMPROJECT_RIGHTHANDORTHOGRAPHIC
+} D3DRMPROJECTIONTYPE, *LPD3DRMPROJECTIONTYPE;
+
+#define D3DRMOPTIONS_LEFTHANDED  0x00000001
+#define D3DRMOPTIONS_RIGHTHANDED 0x00000002
+
+typedef enum _D3DRMXOFFORMAT {
+    D3DRMXOF_BINARY,
+    D3DRMXOF_COMPRESSED,
+    D3DRMXOF_TEXT
+} D3DRMXOFFORMAT, *LPD3DRMXOFFORMAT;
+
+typedef DWORD D3DRMSAVEOPTIONS;
+#define D3DRMXOFSAVE_NORMALS             1
+#define D3DRMXOFSAVE_TEXTURECOORDINATES  2
+#define D3DRMXOFSAVE_MATERIALS           4
+#define D3DRMXOFSAVE_TEXTURENAMES        8
+#define D3DRMXOFSAVE_ALL                15
+#define D3DRMXOFSAVE_TEMPLATES          16
+#define D3DRMXOFSAVE_TEXTURETOPOLOGY    32
+
+typedef enum _D3DRMCOLORSOURCE {
+    D3DRMCOLOR_FROMFACE,
+    D3DRMCOLOR_FROMVERTEX
+} D3DRMCOLORSOURCE, *LPD3DRMCOLORSOURCE;
+
+typedef enum _D3DRMFRAMECONSTRAINT {
+    D3DRMCONSTRAIN_Z,
+    D3DRMCONSTRAIN_Y,
+    D3DRMCONSTRAIN_X
+} D3DRMFRAMECONSTRAINT, *LPD3DRMFRAMECONSTRAINT;
+
+typedef enum _D3DRMMATERIALMODE {
+    D3DRMMATERIAL_FROMMESH,
+    D3DRMMATERIAL_FROMPARENT,
+    D3DRMMATERIAL_FROMFRAME
+} D3DRMMATERIALMODE, *LPD3DRMMATERIALMODE;
+
+typedef enum _D3DRMFOGMODE {
+    D3DRMFOG_LINEAR,
+    D3DRMFOG_EXPONENTIAL,
+    D3DRMFOG_EXPONENTIALSQUARED
+} D3DRMFOGMODE, *LPD3DRMFOGMODE;
+
+typedef enum _D3DRMZBUFFERMODE {
+    D3DRMZBUFFER_FROMPARENT,
+    D3DRMZBUFFER_ENABLE,
+    D3DRMZBUFFER_DISABLE
+} D3DRMZBUFFERMODE, *LPD3DRMZBUFFERMODE;
+
+typedef enum _D3DRMSORTMODE {
+    D3DRMSORT_FROMPARENT,
+    D3DRMSORT_NONE,
+    D3DRMSORT_FRONTTOBACK,
+    D3DRMSORT_BACKTOFRONT
+} D3DRMSORTMODE, *LPD3DRMSORTMODE;
+
+typedef struct _D3DRMMATERIALOVERRIDE {
+    DWORD         dwSize;
+    DWORD         dwFlags;
+    D3DCOLORVALUE dcDiffuse;
+    D3DCOLORVALUE dcAmbient;
+    D3DCOLORVALUE dcEmissive;
+    D3DCOLORVALUE dcSpecular;
+    D3DVALUE      dvPower;
+    IUnknown *lpD3DRMTex;
+} D3DRMMATERIALOVERRIDE, *LPD3DRMMATERIALOVERRIDE;
+
+#define D3DRMMATERIALOVERRIDE_DIFFUSE_ALPHAONLY     0x00000001
+#define D3DRMMATERIALOVERRIDE_DIFFUSE_RGBONLY       0x00000002
+#define D3DRMMATERIALOVERRIDE_DIFFUSE               0x00000003
+#define D3DRMMATERIALOVERRIDE_AMBIENT               0x00000004
+#define D3DRMMATERIALOVERRIDE_EMISSIVE              0x00000008
+#define D3DRMMATERIALOVERRIDE_SPECULAR              0x00000010
+#define D3DRMMATERIALOVERRIDE_POWER                 0x00000020
+#define D3DRMMATERIALOVERRIDE_TEXTURE               0x00000040
+#define D3DRMMATERIALOVERRIDE_DIFFUSE_ALPHAMULTIPLY 0x00000080
+#define D3DRMMATERIALOVERRIDE_ALL                   0x000000FF
+
+#define D3DRMFPTF_ALPHA                             0x00000001
+#define D3DRMFPTF_NOALPHA                           0x00000002
+#define D3DRMFPTF_PALETTIZED                        0x00000004
+#define D3DRMFPTF_NOTPALETTIZED                     0x00000008
+
+#define D3DRMSTATECHANGE_UPDATEONLY                0x000000001
+#define D3DRMSTATECHANGE_VOLATILE                  0x000000002
+#define D3DRMSTATECHANGE_NONVOLATILE               0x000000004
+#define D3DRMSTATECHANGE_RENDER                    0x000000020
+#define D3DRMSTATECHANGE_LIGHT                     0x000000040
+
+#define D3DRMDEVICE_NOZBUFFER           0x00000001
+
+#define D3DRMCALLBACK_PREORDER		0
+#define D3DRMCALLBACK_POSTORDER		1
+
+#define D3DRMRAYPICK_ONLYBOUNDINGBOXES          0x01
+#define D3DRMRAYPICK_IGNOREFURTHERPRIMITIVES    0x02
+#define D3DRMRAYPICK_INTERPOLATEUV              0x04
+#define D3DRMRAYPICK_INTERPOLATECOLOR           0x08
+#define D3DRMRAYPICK_INTERPOLATENORMAL          0x10
+
+#define D3DRMADDFACES_VERTICESONLY              1
+
+#define D3DRMGENERATENORMALS_PRECOMPACT         1
+#define D3DRMGENERATENORMALS_USECREASEANGLE     2
+
+#define D3DRMMESHBUILDER_DIRECTPARENT           1
+#define D3DRMMESHBUILDER_ROOTMESH               2
+
+#define D3DRMMESHBUILDER_RENDERENABLE   0x00000001
+#define D3DRMMESHBUILDER_PICKENABLE     0x00000002
+
+#define D3DRMADDMESHBUILDER_DONTCOPYAPPDATA     1
+#define D3DRMADDMESHBUILDER_FLATTENSUBMESHES    2
+#define D3DRMADDMESHBUILDER_NOSUBMESHES         4
+
+#define D3DRMMESHBUILDERAGE_GEOMETRY    0x00000001
+#define D3DRMMESHBUILDERAGE_MATERIALS   0x00000002
+#define D3DRMMESHBUILDERAGE_TEXTURES    0x00000004
+
+#define D3DRMFVF_TYPE                   0x00000001
+#define D3DRMFVF_NORMAL                 0x00000002
+#define D3DRMFVF_COLOR                  0x00000004
+#define D3DRMFVF_TEXTURECOORDS          0x00000008
+
+#define D3DRMVERTEX_STRIP               0x00000001
+#define D3DRMVERTEX_FAN                 0x00000002
+#define D3DRMVERTEX_LIST                0x00000004
+
+#define D3DRMCLEAR_TARGET               0x00000001
+#define D3DRMCLEAR_ZBUFFER              0x00000002
+#define D3DRMCLEAR_DIRTYRECTS           0x00000004
+#define D3DRMCLEAR_ALL                  (D3DRMCLEAR_TARGET | D3DRMCLEAR_ZBUFFER | D3DRMCLEAR_DIRTYRECTS)
+
+#define D3DRMFOGMETHOD_VERTEX           0x00000001
+#define D3DRMFOGMETHOD_TABLE            0x00000002
+#define D3DRMFOGMETHOD_ANY              0x00000004
+
+#define D3DRMFRAME_RENDERENABLE         0x00000001
+#define D3DRMFRAME_PICKENABLE           0x00000002
+
+typedef DWORD D3DRMANIMATIONOPTIONS;
+#define D3DRMANIMATION_OPEN             0x00000001
+#define D3DRMANIMATION_CLOSED           0x00000002
+#define D3DRMANIMATION_LINEARPOSITION   0x00000004
+#define D3DRMANIMATION_SPLINEPOSITION   0x00000008
+#define D3DRMANIMATION_SCALEANDROTATION 0x00000010
+#define D3DRMANIMATION_POSITION         0x00000020
+
+typedef DWORD D3DRMINTERPOLATIONOPTIONS;
+#define D3DRMINTERPOLATION_OPEN         0x0001
+#define D3DRMINTERPOLATION_CLOSED       0x0002
+#define D3DRMINTERPOLATION_NEAREST      0x0100
+#define D3DRMINTERPOLATION_LINEAR       0x0004
+#define D3DRMINTERPOLATION_SPLINE       0x0008
+#define D3DRMINTERPOLATION_VERTEXCOLOR  0x0040
+#define D3DRMINTERPOLATION_SLERPNORMALS 0x0080
+
+typedef DWORD D3DRMLOADOPTIONS;
+
+#define D3DRMLOAD_FROMFILE             0x000L
+#define D3DRMLOAD_FROMRESOURCE         0x001L
+#define D3DRMLOAD_FROMMEMORY           0x002L
+#define D3DRMLOAD_FROMSTREAM           0x004L
+#define D3DRMLOAD_FROMURL              0x008L
+
+#define D3DRMLOAD_BYNAME               0x010L
+#define D3DRMLOAD_BYPOSITION           0x020L
+#define D3DRMLOAD_BYGUID               0x040L
+#define D3DRMLOAD_FIRST                0x080L
+
+#define D3DRMLOAD_INSTANCEBYREFERENCE  0x100L
+#define D3DRMLOAD_INSTANCEBYCOPYING    0x200L
+
+#define D3DRMLOAD_ASYNCHRONOUS         0x400L
+
+typedef struct _D3DRMLOADRESOURCE
+{
+    HMODULE hModule;
+    const char *lpName;
+    const char *lpType;
+} D3DRMLOADRESOURCE, *LPD3DRMLOADRESOURCE;
+
+typedef struct _D3DRMLOADMEMORY
+{
+    void *lpMemory;
+    DWORD dSize;
+} D3DRMLOADMEMORY, *LPD3DRMLOADMEMORY;
+
+#define D3DRMPMESHSTATUS_VALID            0x01
+#define D3DRMPMESHSTATUS_INTERRUPTED      0x02
+#define D3DRMPMESHSTATUS_BASEMESHCOMPLETE 0x04
+#define D3DRMPMESHSTATUS_COMPLETE         0x08
+#define D3DRMPMESHSTATUS_RENDERABLE       0x10
+
+#define D3DRMPMESHEVENT_BASEMESH          0x01
+#define D3DRMPMESHEVENT_COMPLETE          0x02
+
+typedef struct _D3DRMPMESHLOADSTATUS {
+    DWORD dwSize;
+    DWORD dwPMeshSize;
+    DWORD dwBaseMeshSize;
+    DWORD dwBytesLoaded;
+    DWORD dwVerticesLoaded;
+    DWORD dwFacesLoaded;
+    HRESULT dwLoadResult;
+    DWORD dwFlags;
+} D3DRMPMESHLOADSTATUS, *LPD3DRMPMESHLOADSTATUS;
+
+typedef enum _D3DRMUSERVISUALREASON {
+    D3DRMUSERVISUAL_CANSEE,
+    D3DRMUSERVISUAL_RENDER
+} D3DRMUSERVISUALREASON, *LPD3DRMUSERVISUALREASON;
+
+typedef struct _D3DRMANIMATIONKEY
+{
+    DWORD dwSize;
+    DWORD dwKeyType;
+    D3DVALUE dvTime;
+    DWORD dwID;
+#if !defined(__cplusplus) || !defined(D3D_OVERLOADS)
+    union
+    {
+	D3DRMQUATERNION dqRotateKey;
+	D3DVECTOR dvScaleKey;
+	D3DVECTOR dvPositionKey;
+    } DUMMYUNIONNAME;
+#else
+    D3DVALUE dvK[4];
+#endif
+} D3DRMANIMATIONKEY;
+typedef D3DRMANIMATIONKEY *LPD3DRMANIMATIONKEY;
+
+#define D3DRMANIMATION_ROTATEKEY   0x01
+#define D3DRMANIMATION_SCALEKEY    0x02
+#define D3DRMANIMATION_POSITIONKEY 0x03
+
+typedef DWORD D3DRMMAPPING, D3DRMMAPPINGFLAG, *LPD3DRMMAPPING;
+static const D3DRMMAPPINGFLAG D3DRMMAP_WRAPU        = 1;
+static const D3DRMMAPPINGFLAG D3DRMMAP_WRAPV        = 2;
+static const D3DRMMAPPINGFLAG D3DRMMAP_PERSPCORRECT = 4;
+
+typedef struct _D3DRMVERTEX {
+    D3DVECTOR position;
+    D3DVECTOR normal;
+    D3DVALUE  tu;
+    D3DVALUE  tv;
+    D3DCOLOR  color;
+} D3DRMVERTEX, *LPD3DRMVERTEX;
+
+typedef LONG D3DRMGROUPINDEX;
+static const D3DRMGROUPINDEX D3DRMGROUP_ALLGROUPS = -1;
+
+void WINAPI D3DRMMatrixFromQuaternion(D3DRMMATRIX4D m, D3DRMQUATERNION *q);
+
+D3DRMQUATERNION * WINAPI D3DRMQuaternionFromRotation(D3DRMQUATERNION *x, D3DVECTOR *axis, D3DVALUE theta);
+D3DRMQUATERNION * WINAPI D3DRMQuaternionMultiply(D3DRMQUATERNION *ret, D3DRMQUATERNION *x, D3DRMQUATERNION *y);
+D3DRMQUATERNION * WINAPI D3DRMQuaternionSlerp(D3DRMQUATERNION *ret,
+        D3DRMQUATERNION *x, D3DRMQUATERNION *y, D3DVALUE alpha);
+
+D3DVECTOR * WINAPI D3DRMVectorAdd(D3DVECTOR *ret, D3DVECTOR *x, D3DVECTOR *y);
+D3DVECTOR * WINAPI D3DRMVectorCrossProduct(D3DVECTOR *ret, D3DVECTOR *x, D3DVECTOR *y);
+D3DVALUE WINAPI D3DRMVectorDotProduct(D3DVECTOR *x, D3DVECTOR *y);
+D3DVECTOR * WINAPI D3DRMVectorNormalize(D3DVECTOR *x);
 
 #define D3DRMVectorNormalise D3DRMVectorNormalize
 
-D3DVALUE WINAPI D3DRMVectorModulus(LPD3DVECTOR);
-LPD3DVECTOR WINAPI D3DRMVectorRandom(LPD3DVECTOR);
-LPD3DVECTOR WINAPI D3DRMVectorRotate(LPD3DVECTOR, LPD3DVECTOR, LPD3DVECTOR, D3DVALUE);
-LPD3DVECTOR WINAPI D3DRMVectorReflect(LPD3DVECTOR, LPD3DVECTOR, LPD3DVECTOR);
-LPD3DVECTOR WINAPI D3DRMVectorScale(LPD3DVECTOR, LPD3DVECTOR, D3DVALUE);
-LPD3DVECTOR WINAPI D3DRMVectorSubtract(LPD3DVECTOR, LPD3DVECTOR, LPD3DVECTOR);
+D3DVALUE WINAPI D3DRMVectorModulus(D3DVECTOR *x);
+D3DVECTOR * WINAPI D3DRMVectorRandom(D3DVECTOR *ret);
+D3DVECTOR * WINAPI D3DRMVectorRotate(D3DVECTOR *ret, D3DVECTOR *x, D3DVECTOR *axis, D3DVALUE theta);
+D3DVECTOR * WINAPI D3DRMVectorReflect(D3DVECTOR *ret, D3DVECTOR *ray, D3DVECTOR *normal);
+D3DVECTOR * WINAPI D3DRMVectorScale(D3DVECTOR *ret, D3DVECTOR *x, D3DVALUE scale);
+D3DVECTOR * WINAPI D3DRMVectorSubtract(D3DVECTOR *ret, D3DVECTOR *x, D3DVECTOR *y);
 
 D3DCOLOR WINAPI D3DRMCreateColorRGB(D3DVALUE, D3DVALUE, D3DVALUE);
 D3DCOLOR WINAPI D3DRMCreateColorRGBA(D3DVALUE, D3DVALUE, D3DVALUE, D3DVALUE);

include/psdk/d3drmwin.h

@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2010 Vijay Kiran Kamuju
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef __D3DRMWIN_H__
+#define __D3DRMWIN_H__
+
+#include <d3drm.h>
+#include <ddraw.h>
+#include <d3d.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*****************************************************************************
+ * Direct3DRMWinDevice interface GUID
+ */
+
+DEFINE_GUID(IID_IDirect3DRMWinDevice,       0xc5016cc0, 0xd273, 0x11ce, 0xac, 0x48, 0x00, 0x00, 0xc0, 0x38, 0x25, 0xa1);
+
+typedef struct IDirect3DRMWinDevice       *LPDIRECT3DRMWINDEVICE, **LPLPDIRECT3DRMWINDEVICE;
+
+/*****************************************************************************
+ * IDirect3DRMWinDevice interface
+ */
+#define INTERFACE IDirect3DRMWinDevice
+DECLARE_INTERFACE_(IDirect3DRMWinDevice,IDirect3DRMObject)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+    /*** IDirect3DRMObject methods ***/
+    STDMETHOD(Clone)(THIS_ IUnknown *outer, REFIID iid, void **out) PURE;
+    STDMETHOD(AddDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE;
+    STDMETHOD(DeleteDestroyCallback)(THIS_ D3DRMOBJECTCALLBACK cb, void *ctx) PURE;
+    STDMETHOD(SetAppData)(THIS_ DWORD data) PURE;
+    STDMETHOD_(DWORD, GetAppData)(THIS) PURE;
+    STDMETHOD(SetName)(THIS_ const char *name) PURE;
+    STDMETHOD(GetName)(THIS_ DWORD *size, char *name) PURE;
+    STDMETHOD(GetClassName)(THIS_ DWORD *size, char *name) PURE;
+    /*** IDirect3DRMWinDevice methods ***/
+    STDMETHOD(HandlePaint)(THIS_ HDC) PURE;
+    STDMETHOD(HandleActivate)(THIS_ WORD) PURE;
+};
+#undef INTERFACE
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+/*** IUnknown methods ***/
+#define IDirect3DRMWinDevice_QueryInterface(p,a,b)        (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirect3DRMWinDevice_AddRef(p)                    (p)->lpVtbl->AddRef(p)
+#define IDirect3DRMWinDevice_Release(p)                   (p)->lpVtbl->Release(p)
+/*** IDirect3DRMObject methods ***/
+#define IDirect3DRMWinDevice_Clone(p,a,b,c)               (p)->lpVtbl->Clone(p,a,b,c)
+#define IDirect3DRMWinDevice_AddDestroyCallback(p,a,b)    (p)->lpVtbl->AddDestroyCallback(p,a,b)
+#define IDirect3DRMWinDevice_DeleteDestroyCallback(p,a,b) (p)->lpVtbl->DeleteDestroyCallback(p,a,b)
+#define IDirect3DRMWinDevice_SetAppData(p,a)              (p)->lpVtbl->SetAppData(p,a)
+#define IDirect3DRMWinDevice_GetAppData(p)                (p)->lpVtbl->GetAppData(p)
+#define IDirect3DRMWinDevice_SetName(p,a)                 (p)->lpVtbl->SetName(p,a)
+#define IDirect3DRMWinDevice_GetName(p,a,b)               (p)->lpVtbl->GetName(p,a,b)
+#define IDirect3DRMWinDevice_GetClassName(p,a,b)          (p)->lpVtbl->GetClassName(p,a,b)
+/*** IDirect3DRMWinDevice methods ***/
+#define IDirect3DRMWinDevice_HandlePaint(p,a)             (p)->lpVtbl->HandlePaint(p,a)
+#define IDirect3DRMWinDevice_HandleActivate(p,a)          (p)->lpVtbl->HandleActivate(p,a)
+#else
+/*** IUnknown methods ***/
+#define IDirect3DRMWinDevice_QueryInterface(p,a,b)        (p)->QueryInterface(a,b)
+#define IDirect3DRMWinDevice_AddRef(p)                    (p)->AddRef()
+#define IDirect3DRMwinDevice_Release(p)                   (p)->Release()
+/*** IDirect3DRMObject methods ***/
+#define IDirect3DRMWinDevice_Clone(p,a,b,c)               (p)->Clone(a,b,c)
+#define IDirect3DRMWinDevice_AddDestroyCallback(p,a,b)    (p)->AddDestroyCallback(a,b)
+#define IDirect3DRMWinDevice_DeleteDestroyCallback(p,a,b) (p)->DeleteDestroyCallback(a,b)
+#define IDirect3DRMWinDevice_SetAppData(p,a)              (p)->SetAppData(a)
+#define IDirect3DRMWinDevice_GetAppData(p)                (p)->GetAppData()
+#define IDirect3DRMWinDevice_SetName(p,a)                 (p)->SetName(a)
+#define IDirect3DRMWinDevice_GetName(p,a,b)               (p)->GetName(a,b)
+#define IDirect3DRMWinDevice_GetClassName(p,a,b)          (p)->GetClassName(a,b)
+/*** IDirect3DRMWinDevice methods ***/
+#define IDirect3DRMWinDevice_HandlePaint(p,a)             (p)->HandlePaint(a)
+#define IDirect3DRMWinDevice_HandleActivate(p,a)          (p)->HandleActivate(a)
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __D3DRMWIN_H__ */

include/psdk/ddraw.h

@@ -13,7 +13,10 @@
 #endif
 
 #define _FACDD        0x876
+
+#ifndef MAKE_DDHRESULT
 #define MAKE_DDHRESULT(c) MAKE_HRESULT(1,_FACDD,c)
+#endif
 
 #ifndef DIRECTDRAW_VERSION
   #define DIRECTDRAW_VERSION 0x0700

include/reactos/subsys/lsass/lsass.h

@@ -22,6 +22,7 @@ typedef enum _LSA_API_NUMBER
     LSASS_REQUEST_LOGON_USER,
     LSASS_REQUEST_LOOKUP_AUTHENTICATION_PACKAGE,
     LSASS_REQUEST_ENUM_LOGON_SESSIONS,
+    LSASS_REQUEST_GET_LOGON_SESSION_DATA,
     LSASS_REQUEST_MAXIMUM
 } LSA_API_NUMBER, *PLSA_API_NUMBER;
 
@@ -129,13 +130,28 @@ typedef struct _LSA_ENUM_LOGON_SESSIONS_MSG
         struct
         {
             ULONG LogonSessionCount;
-            ULONG LogonSessionBufferLength;
             PVOID LogonSessionBuffer;
         } Reply;
     };
 } LSA_ENUM_LOGON_SESSIONS_MSG, *PLSA_ENUM_LOGON_SESSIONS_MSG;
 
 
+typedef struct _LSA_GET_LOGON_SESSION_DATA_MSG
+{
+    union
+    {
+        struct
+        {
+            LUID LogonId;
+        } Request;
+        struct
+        {
+            PVOID SessionDataBuffer;
+        } Reply;
+    };
+} LSA_GET_LOGON_SESSION_DATA_MSG, *PLSA_GET_LOGON_SESSION_DATA_MSG;
+
+
 typedef struct _LSA_API_MSG
 {
     PORT_MESSAGE h;
@@ -153,6 +169,7 @@ typedef struct _LSA_API_MSG
                 LSA_DEREGISTER_LOGON_PROCESS_MSG DeregisterLogonProcess;
                 LSA_LOOKUP_AUTHENTICATION_PACKAGE_MSG LookupAuthenticationPackage;
                 LSA_ENUM_LOGON_SESSIONS_MSG EnumLogonSessions;
+                LSA_GET_LOGON_SESSION_DATA_MSG GetLogonSessionData;
             };
         };
     };

lib/fast486/common.c

@@ -317,6 +317,10 @@ Fast486ExceptionWithErrorCode(PFAST486_STATE State,
     /* Check if this is a triple fault */
     if (State->ExceptionCount == 3)
     {
+        DPRINT("Fast486ExceptionWithErrorCode(%04X:%08X) -- Triple fault\n",
+               State->SegmentRegs[FAST486_REG_CS].Selector,
+               State->InstPtr.Long);
+
         /* Reset the CPU */
         Fast486Reset(State);
         return;