Wine-20041201 vendor drop
Added: vendor/wine/dlls/winmm/
Added: vendor/wine/dlls/winmm/current/
Added: vendor/wine/dlls/winmm/current/Makefile.in
Added: vendor/wine/dlls/winmm/current/driver.c
Added: vendor/wine/dlls/winmm/current/joystick.c
Added: vendor/wine/dlls/winmm/current/lolvldrv.c
Added: vendor/wine/dlls/winmm/current/mci.c
Added: vendor/wine/dlls/winmm/current/message16.c
Added: vendor/wine/dlls/winmm/current/midimap/
Added: vendor/wine/dlls/winmm/current/midimap/.cvsignore
Added: vendor/wine/dlls/winmm/current/midimap/Makefile.in
Added: vendor/wine/dlls/winmm/current/midimap/midimap.c
Added: vendor/wine/dlls/winmm/current/midimap/midimap.drv.spec
Added: vendor/wine/dlls/winmm/current/mmio.c
Added: vendor/wine/dlls/winmm/current/mmsystem.c
Added: vendor/wine/dlls/winmm/current/mmsystem.spec
Added: vendor/wine/dlls/winmm/current/playsound.c
Added: vendor/wine/dlls/winmm/current/sound.spec
Added: vendor/wine/dlls/winmm/current/sound16.c
Added: vendor/wine/dlls/winmm/current/time.c
Added: vendor/wine/dlls/winmm/current/wavemap/
Added: vendor/wine/dlls/winmm/current/wavemap/.cvsignore
Added: vendor/wine/dlls/winmm/current/wavemap/Makefile.in
Added: vendor/wine/dlls/winmm/current/wavemap/msacm.drv.spec
Added: vendor/wine/dlls/winmm/current/wavemap/wavemap.c
Added: vendor/wine/dlls/winmm/current/winemm.h
Added: vendor/wine/dlls/winmm/current/winemm16.h
Added: vendor/wine/dlls/winmm/current/winmm.c
Added: vendor/wine/dlls/winmm/current/winmm.spec
Added: vendor/wine/dlls/winmm/current/winmm_Cs.rc
Added: vendor/wine/dlls/winmm/current/winmm_De.rc
Added: vendor/wine/dlls/winmm/current/winmm_En.rc
Added: vendor/wine/dlls/winmm/current/winmm_Es.rc
Added: vendor/wine/dlls/winmm/current/winmm_Fr.rc
Added: vendor/wine/dlls/winmm/current/winmm_It.rc
Added: vendor/wine/dlls/winmm/current/winmm_Ja.rc
Added: vendor/wine/dlls/winmm/current/winmm_Nl.rc
Added: vendor/wine/dlls/winmm/current/winmm_Pt.rc
Added: vendor/wine/dlls/winmm/current/winmm_Ru.rc
Added: vendor/wine/dlls/winmm/current/winmm_Si.rc
Added: vendor/wine/dlls/winmm/current/winmm_Sk.rc
Added: vendor/wine/dlls/winmm/current/winmm_res.rc
_____
Added: vendor/wine/dlls/winmm/current/Makefile.in
--- vendor/wine/dlls/winmm/current/Makefile.in 2004-12-31 16:30:04 UTC
(rev 12637)
+++ vendor/wine/dlls/winmm/current/Makefile.in 2004-12-31 16:34:31 UTC
(rev 12638)
@@ -0,0 +1,34 @@
+EXTRADEFS = -D_WINMM_
+TOPSRCDIR = @top_srcdir@
+TOPOBJDIR = ../..
+SRCDIR = @srcdir@
+VPATH = @srcdir@
+MODULE = winmm.dll
+IMPORTS = user32 advapi32 kernel32 ntdll
+
+C_SRCS = \
+ driver.c \
+ joystick.c \
+ lolvldrv.c \
+ mci.c \
+ mmio.c \
+ playsound.c \
+ time.c \
+ winmm.c
+
+C_SRCS16 = \
+ message16.c \
+ mmsystem.c \
+ sound16.c
+
+SPEC_SRCS16 = \
+ mmsystem.spec \
+ sound.spec
+
+RC_SRCS = winmm_res.rc
+
+SUBDIRS = tests
+
+@MAKE_DLL_RULES@
+
+### Dependencies:
_____
Added: vendor/wine/dlls/winmm/current/driver.c
--- vendor/wine/dlls/winmm/current/driver.c 2004-12-31 16:30:04 UTC
(rev 12637)
+++ vendor/wine/dlls/winmm/current/driver.c 2004-12-31 16:34:31 UTC
(rev 12638)
@@ -0,0 +1,567 @@
+/* -*- tab-width: 8; c-basic-offset: 4 -*- */
+
+/*
+ * WINE Drivers functions
+ *
+ * Copyright 1994 Martin Ayotte
+ * Copyright 1998 Marcus Meissner
+ * Copyright 1999 Eric Pouech
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA
+ */
+
+#include <string.h>
+#include <stdarg.h>
+#include "windef.h"
+#include "winbase.h"
+#include "wingdi.h"
+#include "winuser.h"
+#include "winnls.h"
+#include "winreg.h"
+#include "mmddk.h"
+#include "winemm.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(driver);
+
+#define HKLM_BASE "Software\\Microsoft\\Windows NT\\CurrentVersion"
+
+static LPWINE_DRIVER lpDrvItemList /* = NULL */;
+
+WINE_MMTHREAD* (*pFnGetMMThread16)(UINT16 h) /* = NULL */;
+LPWINE_DRIVER (*pFnOpenDriver16)(LPCSTR,LPCSTR,LPARAM) /* = NULL */;
+LRESULT (*pFnCloseDriver16)(UINT16,LPARAM,LPARAM) /* = NULL */;
+LRESULT (*pFnSendMessage16)(UINT16,UINT,LPARAM,LPARAM) /* =
NULL */;
+
+/**********************************************************************
****
+ * DRIVER_GetNumberOfModuleRefs
[internal]
+ *
+ * Returns the number of open drivers which share the same module.
+ */
+static unsigned DRIVER_GetNumberOfModuleRefs(HMODULE hModule,
WINE_DRIVER** found)
+{
+ LPWINE_DRIVER lpDrv;
+ unsigned count = 0;
+
+ if (found) *found = NULL;
+ for (lpDrv = lpDrvItemList; lpDrv; lpDrv = lpDrv->lpNextItem)
+ {
+ if (!(lpDrv->dwFlags & WINE_GDF_16BIT) && lpDrv->d.d32.hModule
== hModule)
+ {
+ if (found && !*found) *found = lpDrv;
+ count++;
+ }
+ }
+ return count;
+}
+
+/**********************************************************************
****
+ * DRIVER_FindFromHDrvr
[internal]
+ *
+ * From a hDrvr being 32 bits, returns the WINE internal structure.
+ */
+LPWINE_DRIVER DRIVER_FindFromHDrvr(HDRVR hDrvr)
+{
+ LPWINE_DRIVER d = (LPWINE_DRIVER)hDrvr;
+
+ if (hDrvr && HeapValidate(GetProcessHeap(), 0, d) && d->dwMagic ==
WINE_DI_MAGIC) {
+ return d;
+ }
+ return NULL;
+}
+
+/**********************************************************************
****
+ * DRIVER_SendMessage
[internal]
+ */
+static LRESULT inline DRIVER_SendMessage(LPWINE_DRIVER lpDrv, UINT msg,
+ LPARAM lParam1, LPARAM
lParam2)
+{
+ LRESULT ret = 0;
+
+ if (lpDrv->dwFlags & WINE_GDF_16BIT) {
+ /* no need to check mmsystem presence: the driver must have
been opened as a 16 bit one,
+ */
+ if (pFnSendMessage16)
+ ret = pFnSendMessage16(lpDrv->d.d16.hDriver16, msg,
lParam1, lParam2);
+ } else {
+ TRACE("Before call32 proc=%p drvrID=%08lx hDrv=%p wMsg=%04x
p1=%08lx p2=%08lx\n",
+ lpDrv->d.d32.lpDrvProc, lpDrv->d.d32.dwDriverID,
(HDRVR)lpDrv, msg, lParam1, lParam2);
+ ret = lpDrv->d.d32.lpDrvProc(lpDrv->d.d32.dwDriverID,
(HDRVR)lpDrv, msg, lParam1, lParam2);
+ TRACE("After call32 proc=%p drvrID=%08lx hDrv=%p wMsg=%04x
p1=%08lx p2=%08lx => %08lx\n",
+ lpDrv->d.d32.lpDrvProc, lpDrv->d.d32.dwDriverID,
(HDRVR)lpDrv, msg, lParam1, lParam2, ret);
+ }
+ return ret;
+}
+
+/**********************************************************************
****
+ * SendDriverMessage
[WINMM.@]
+ * DrvSendMessage
[WINMM.@]
+ */
+LRESULT WINAPI SendDriverMessage(HDRVR hDriver, UINT msg, LPARAM
lParam1,
+ LPARAM lParam2)
+{
+ LPWINE_DRIVER lpDrv;
+ LRESULT retval = 0;
+
+ TRACE("(%p, %04X, %08lX, %08lX)\n", hDriver, msg, lParam1,
lParam2);
+
+ if ((lpDrv = DRIVER_FindFromHDrvr(hDriver)) != NULL) {
+ retval = DRIVER_SendMessage(lpDrv, msg, lParam1, lParam2);
+ } else {
+ WARN("Bad driver handle %p\n", hDriver);
+ }
+ TRACE("retval = %ld\n", retval);
+
+ return retval;
+}
+
+/**********************************************************************
****
+ * DRIVER_RemoveFromList
[internal]
+ *
+ * Generates all the logic to handle driver closure / deletion
+ * Removes a driver struct to the list of open drivers.
+ */
+static BOOL DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv)
+{
+ if (!(lpDrv->dwFlags & WINE_GDF_16BIT)) {
+ /* last of this driver in list ? */
+ if (DRIVER_GetNumberOfModuleRefs(lpDrv->d.d32.hModule, NULL) ==
1) {
+ DRIVER_SendMessage(lpDrv, DRV_DISABLE, 0L, 0L);
+ DRIVER_SendMessage(lpDrv, DRV_FREE, 0L, 0L);
+ }
+ }
+
+ if (lpDrv->lpPrevItem)
+ lpDrv->lpPrevItem->lpNextItem = lpDrv->lpNextItem;
+ else
+ lpDrvItemList = lpDrv->lpNextItem;
+ if (lpDrv->lpNextItem)
+ lpDrv->lpNextItem->lpPrevItem = lpDrv->lpPrevItem;
+ /* trash magic number */
+ lpDrv->dwMagic ^= 0xa5a5a5a5;
+
+ return TRUE;
+}
+
+/**********************************************************************
****
+ * DRIVER_AddToList
[internal]
+ *
+ * Adds a driver struct to the list of open drivers.
+ * Generates all the logic to handle driver creation / open.
+ */
+static BOOL DRIVER_AddToList(LPWINE_DRIVER lpNewDrv, LPARAM lParam1,
LPARAM lParam2)
+{
+ lpNewDrv->dwMagic = WINE_DI_MAGIC;
+ /* First driver to be loaded for this module, need to load
correctly the module */
+ if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
+ /* first of this driver in list ? */
+ if (DRIVER_GetNumberOfModuleRefs(lpNewDrv->d.d32.hModule, NULL)
== 0) {
+ if (DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) !=
DRV_SUCCESS) {
+ TRACE("DRV_LOAD failed on driver 0x%08lx\n",
(DWORD)lpNewDrv);
+ return FALSE;
+ }
+ /* returned value is not checked */
+ DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
+ }
+ }
+
+ lpNewDrv->lpNextItem = NULL;
+ if (lpDrvItemList == NULL) {
+ lpDrvItemList = lpNewDrv;
+ lpNewDrv->lpPrevItem = NULL;
+ } else {
+ LPWINE_DRIVER lpDrv = lpDrvItemList; /* find end of list */
+ while (lpDrv->lpNextItem != NULL)
+ lpDrv = lpDrv->lpNextItem;
+
+ lpDrv->lpNextItem = lpNewDrv;
+ lpNewDrv->lpPrevItem = lpDrv;
+ }
+
+ if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
+ /* Now just open a new instance of a driver on this module */
+ lpNewDrv->d.d32.dwDriverID = DRIVER_SendMessage(lpNewDrv,
DRV_OPEN, lParam1, lParam2);
+
+ if (lpNewDrv->d.d32.dwDriverID == 0) {
+ TRACE("DRV_OPEN failed on driver 0x%08lx\n",
(DWORD)lpNewDrv);
+ DRIVER_RemoveFromList(lpNewDrv);
+ return FALSE;
+ }
+ }
+ return TRUE;
+}
+
+/**********************************************************************
****
+ * DRIVER_GetLibName
[internal]
+ *
+ */
+BOOL DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf,
int sz)
+{
+ HKEY hKey, hSecKey;
+ DWORD bufLen, lRet;
+
+ lRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE, HKLM_BASE, 0,
KEY_QUERY_VALUE, &hKey);
+ if (lRet == ERROR_SUCCESS) {
+ lRet = RegOpenKeyExA(hKey, sectName, 0, KEY_QUERY_VALUE,
&hSecKey);
+ if (lRet == ERROR_SUCCESS) {
+ lRet = RegQueryValueExA(hSecKey, keyName, 0, 0, buf,
&bufLen);
+ RegCloseKey( hSecKey );
+ }
+ RegCloseKey( hKey );
+ }
+ if (lRet == ERROR_SUCCESS) return TRUE;
+ /* default to system.ini if we can't find it in the registry,
+ * to support native installations where system.ini is still used
*/
+ return GetPrivateProfileStringA(sectName, keyName, "", buf, sz,
"SYSTEM.INI");
+}
+
+/**********************************************************************
****
+ * DRIVER_TryOpenDriver32
[internal]
+ *
+ * Tries to load a 32 bit driver whose DLL's (module) name is fn
+ */
+LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2)
+{
+ LPWINE_DRIVER lpDrv = NULL;
+ HMODULE hModule = 0;
+ LPSTR ptr;
+ LPCSTR cause = 0;
+
+ TRACE("(%s, %08lX);\n", debugstr_a(fn), lParam2);
+
+ if ((ptr = strchr(fn, ' ')) != NULL) {
+ *ptr++ = '\0';
+ while (*ptr == ' ') ptr++;
+ if (*ptr == '\0') ptr = NULL;
+ }
+
+ lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
+ if (lpDrv == NULL) {cause = "OOM"; goto exit;}
+
+ if ((hModule = LoadLibraryA(fn)) == 0) {cause = "Not a 32 bit lib";
goto exit;}
+
+ lpDrv->d.d32.lpDrvProc = (DRIVERPROC)GetProcAddress(hModule,
"DriverProc");
+ if (lpDrv->d.d32.lpDrvProc == NULL) {cause = "no DriverProc"; goto
exit;}
+
+ lpDrv->dwFlags = 0;
+ lpDrv->d.d32.hModule = hModule;
+ lpDrv->d.d32.dwDriverID = 0;
+
+ /* Win32 installable drivers must support a two phase opening
scheme:
+ * + first open with NULL as lParam2 (session instance),
+ * + then do a second open with the real non null lParam2)
+ */
+ if (DRIVER_GetNumberOfModuleRefs(lpDrv->d.d32.hModule, NULL) == 0
&& lParam2)
+ {
+ LPWINE_DRIVER ret;
+
+ if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, 0L))
+ {
+ cause = "load0 failed";
+ goto exit;
+ }
+ ret = DRIVER_TryOpenDriver32(fn, lParam2);
+ if (!ret)
+ {
+ CloseDriver((HDRVR)lpDrv, 0L, 0L);
+ cause = "load1 failed";
+ goto exit;
+ }
+ return ret;
+ }
+
+ if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, lParam2))
+ {cause = "load failed"; goto exit;}
+
+ TRACE("=> %p\n", lpDrv);
+ return lpDrv;
+ exit:
+ FreeLibrary(hModule);
+ HeapFree(GetProcessHeap(), 0, lpDrv);
+ TRACE("Unable to load 32 bit module %s: %s\n", debugstr_a(fn),
cause);
+ return NULL;
+}
+
+/**********************************************************************
****
+ * OpenDriverA
[WINMM.@]
+ * DrvOpenA
[WINMM.@]
+ * (0,1,DRV_LOAD ,0 ,0)
+ * (0,1,DRV_ENABLE,0 ,0)
+ * (0,1,DRV_OPEN ,buf[256],0)
+ */
+HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName,
LPARAM lParam2)
+{
+ LPWINE_DRIVER lpDrv = NULL;
+ char libName[128];
+ LPCSTR lsn = lpSectionName;
+
+ TRACE("(%s, %s, 0x%08lx);\n", debugstr_a(lpDriverName),
debugstr_a(lpSectionName), lParam2);
+
+ if (lsn == NULL) {
+ lstrcpynA(libName, lpDriverName, sizeof(libName));
+
+ if ((lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
+ goto the_end;
+ lsn = "Drivers32";
+ }
+ if (DRIVER_GetLibName(lpDriverName, lsn, libName, sizeof(libName))
&&
+ (lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
+ goto the_end;
+
+ /* now we will try a 16 bit driver (and add all the glue to make it
work... which
+ * is located in our mmsystem implementation)
+ * so ensure, we can load our mmsystem, otherwise just fail
+ */
+ WINMM_CheckForMMSystem();
+ if (pFnOpenDriver16 &&
+ (lpDrv = pFnOpenDriver16(lpDriverName, lpSectionName,
lParam2)))
+ {
+ if (DRIVER_AddToList(lpDrv, 0, lParam2)) goto the_end;
+ HeapFree(GetProcessHeap(), 0, lpDrv);
+ }
+ TRACE("Failed to open driver %s from system.ini file, section
%s\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName));
+ return 0;
+
+ the_end:
+ if (lpDrv) TRACE("=> %08lx\n", (DWORD)lpDrv);
+ return (HDRVR)lpDrv;
+}
+
+/**********************************************************************
****
+ * OpenDriver
[WINMM.@]
+ * DrvOpen
[WINMM.@]
+ */
+HDRVR WINAPI OpenDriverW(LPCWSTR lpDriverName, LPCWSTR lpSectionName,
LPARAM lParam)
+{
+ INT len;
+ LPSTR dn = NULL;
+ LPSTR sn = NULL;
+ HDRVR ret;
+
+ if (lpDriverName)
+ {
+ len = WideCharToMultiByte( CP_ACP, 0, lpDriverName, -1, NULL,
0, NULL, NULL );
+ dn = HeapAlloc( GetProcessHeap(), 0, len );
+ if (!dn) return 0;
+ WideCharToMultiByte( CP_ACP, 0, lpDriverName, -1, dn, len,
NULL, NULL );
+ }
+
+ if (lpSectionName)
+ {
+ len = WideCharToMultiByte( CP_ACP, 0, lpSectionName, -1, NULL,
0, NULL, NULL );
+ sn = HeapAlloc( GetProcessHeap(), 0, len );
+ if (!sn) return 0;
+ WideCharToMultiByte( CP_ACP, 0, lpSectionName, -1, sn, len,
NULL, NULL );
+ }
+
+ ret = OpenDriverA(dn, sn, lParam);
+
+ if (dn) HeapFree(GetProcessHeap(), 0, dn);
+ if (sn) HeapFree(GetProcessHeap(), 0, sn);
+ return ret;
+}
+
+/**********************************************************************
****
+ * CloseDriver
[WINMM.@]
+ * DrvClose
[WINMM.@]
+ */
+LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
+{
+ LPWINE_DRIVER lpDrv;
+
+ TRACE("(%p, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
+
+ if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL)
+ {
+ if (lpDrv->dwFlags & WINE_GDF_16BIT)
+ {
+ if (pFnCloseDriver16)
+ pFnCloseDriver16(lpDrv->d.d16.hDriver16, lParam1,
lParam2);
+ }
+ else
+ {
+ DRIVER_SendMessage(lpDrv, DRV_CLOSE, lParam1, lParam2);
+ lpDrv->d.d32.dwDriverID = 0;
+ }
+ if (DRIVER_RemoveFromList(lpDrv)) {
+ if (!(lpDrv->dwFlags & WINE_GDF_16BIT))
+ {
+ LPWINE_DRIVER lpDrv0;
+
+ /* if driver has an opened session instance, we have to
close it too */
+ if (DRIVER_GetNumberOfModuleRefs(lpDrv->d.d32.hModule,
&lpDrv0) == 1)
+ {
+ DRIVER_SendMessage(lpDrv0, DRV_CLOSE, 0L, 0L);
+ lpDrv0->d.d32.dwDriverID = 0;
+ DRIVER_RemoveFromList(lpDrv0);
+ FreeLibrary(lpDrv0->d.d32.hModule);
+ HeapFree(GetProcessHeap(), 0, lpDrv0);
+ }
+ FreeLibrary(lpDrv->d.d32.hModule);
+ }
+ HeapFree(GetProcessHeap(), 0, lpDrv);
+ return TRUE;
+ }
+ }
+ WARN("Failed to close driver\n");
+ return FALSE;
+}
+
+/**********************************************************************
****
+ * GetDriverFlags [WINMM.@]
+ * [in] hDrvr handle to the driver
+ *
+ * Returns:
+ * 0x00000000 if hDrvr is an invalid handle
+ * 0x80000000 if hDrvr is a valid 32 bit driver
+ * 0x90000000 if hDrvr is a valid 16 bit driver
+ *
+ * native WINMM doesn't return those flags
+ * 0x80000000 for a valid 32 bit driver and that's it
+ * (I may have mixed up the two flags :-(
+ */
+DWORD WINAPI GetDriverFlags(HDRVR hDrvr)
+{
+ LPWINE_DRIVER lpDrv;
+ DWORD ret = 0;
+
+ TRACE("(%p)\n", hDrvr);
+
+ if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
+ ret = WINE_GDF_EXIST | lpDrv->dwFlags;
+ }
+ return ret;
+}
+
+/**********************************************************************
****
+ * GetDriverModuleHandle [WINMM.@]
+ * DrvGetModuleHandle [WINMM.@]
+ */
+HMODULE WINAPI GetDriverModuleHandle(HDRVR hDrvr)
+{
+ LPWINE_DRIVER lpDrv;
+ HMODULE hModule = 0;
+
+ TRACE("(%p);\n", hDrvr);
+
+ if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
+ if (!(lpDrv->dwFlags & WINE_GDF_16BIT))
+ hModule = lpDrv->d.d32.hModule;
+ }
+ TRACE("=> %p\n", hModule);
+ return hModule;
+}
+
+/**********************************************************************
****
+ * DefDriverProc
[WINMM.@]
+ * DrvDefDriverProc
[WINMM.@]
+ */
+LRESULT WINAPI DefDriverProc(DWORD_PTR dwDriverIdentifier, HDRVR hDrv,
+ UINT Msg, LPARAM lParam1, LPARAM lParam2)
+{
+ switch (Msg) {
+ case DRV_LOAD:
+ case DRV_FREE:
+ case DRV_ENABLE:
+ case DRV_DISABLE:
+ return 1;
+ case DRV_INSTALL:
+ case DRV_REMOVE:
+ return DRV_SUCCESS;
+ default:
+ return 0;
+ }
+}
+
+/**********************************************************************
****
+ * DriverCallback
[WINMM.@]
+ */
+BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev,
+ UINT wMsg, DWORD dwUser, DWORD dwParam1,
+ DWORD dwParam2)
+{
+ TRACE("(%08lX, %04X, %p, %04X, %08lX, %08lX, %08lX); !\n",
+ dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
+
+ switch (uFlags & DCB_TYPEMASK) {
+ case DCB_NULL:
+ TRACE("Null !\n");
+ if (dwCallBack)
+ WARN("uFlags=%04X has null DCB value, but dwCallBack=%08lX
is not null !\n", uFlags, dwCallBack);
+ break;
+ case DCB_WINDOW:
+ TRACE("Window(%04lX) handle=%p!\n", dwCallBack, hDev);
+ PostMessageA((HWND)dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
+ break;
+ case DCB_TASK: /* aka DCB_THREAD */
+ TRACE("Task(%04lx) !\n", dwCallBack);
+ PostThreadMessageA(dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
+ break;
+ case DCB_FUNCTION:
+ TRACE("Function (32 bit) !\n");
+ ((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser, dwParam1,
dwParam2);
+ break;
+ case DCB_EVENT:
+ TRACE("Event(%08lx) !\n", dwCallBack);
+ SetEvent((HANDLE)dwCallBack);
+ break;
+ case 6: /* I would dub it DCB_MMTHREADSIGNAL */
+ /* this is an undocumented DCB_ value used for mmThreads
+ * loword of dwCallBack contains the handle of the lpMMThd block
+ * which dwSignalCount has to be incremented
+ */
+ if (pFnGetMMThread16)
+ {
+ WINE_MMTHREAD* lpMMThd =
pFnGetMMThread16(LOWORD(dwCallBack));
+
+ TRACE("mmThread (%04x, %p) !\n", LOWORD(dwCallBack),
lpMMThd);
+ /* same as mmThreadSignal16 */
+ InterlockedIncrement(&lpMMThd->dwSignalCount);
+ SetEvent(lpMMThd->hEvent);
+ /* some other stuff on lpMMThd->hVxD */
+ }
+ break;
+#if 0
+ case 4:
+ /* this is an undocumented DCB_ value for... I don't know */
+ break;
+#endif
+ default:
+ WARN("Unknown callback type %d\n", uFlags & DCB_TYPEMASK);
+ return FALSE;
+ }
+ TRACE("Done\n");
+ return TRUE;
+}
+
+/******************************************************************
+ * DRIVER_UnloadAll
+ *
+ *
+ */
+void DRIVER_UnloadAll(void)
+{
+ LPWINE_DRIVER lpDrv;
+ LPWINE_DRIVER lpNextDrv = NULL;
+ unsigned count = 0;
+
+ for (lpDrv = lpDrvItemList; lpDrv != NULL; lpDrv = lpNextDrv)
+ {
+ lpNextDrv = lpDrv->lpNextItem;
+ CloseDriver((HDRVR)lpDrv, 0, 0);
+ count++;
+ }
+ TRACE("Unloaded %u drivers\n", count);
+}
_____
Added: vendor/wine/dlls/winmm/current/joystick.c
--- vendor/wine/dlls/winmm/current/joystick.c 2004-12-31 16:30:04 UTC
(rev 12637)
+++ vendor/wine/dlls/winmm/current/joystick.c 2004-12-31 16:34:31 UTC
(rev 12638)
@@ -0,0 +1,308 @@
+/* -*- tab-width: 8; c-basic-offset: 4 -*- */
+/*
+ * joystick functions
+ *
+ * Copyright 1997 Andreas Mohr
+ * 2000 Wolfgang Schwotzer
+ * Eric Pouech
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA
+ */
+
+#include "config.h"
+
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#ifdef HAVE_SYS_IOCTL_H
+#include <sys/ioctl.h>
+#endif
+
+#include "windef.h"
+#include "winbase.h"
+#include "mmsystem.h"
+#include "wingdi.h"
+#include "winuser.h"
+#include "winnls.h"
+
+#include "mmddk.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(winmm);
+
+#define MAXJOYSTICK (JOYSTICKID2 + 1)
+#define JOY_PERIOD_MIN (10) /* min Capture time period */
+#define JOY_PERIOD_MAX (1000) /* max Capture time period */
+
+typedef struct tagWINE_JOYSTICK {
+ JOYINFO ji;
+ HWND hCapture;
+ UINT wTimer;
+ DWORD threshold;
+ BOOL bChanged;
+ HDRVR hDriver;
+} WINE_JOYSTICK;
+
+static WINE_JOYSTICK JOY_Sticks[MAXJOYSTICK];
+
+/**********************************************************************
****
+ * JOY_LoadDriver [internal]
+ */
+static BOOL JOY_LoadDriver(DWORD dwJoyID)
+{
+ if (dwJoyID >= MAXJOYSTICK)
+ return FALSE;
+ if (JOY_Sticks[dwJoyID].hDriver)
+ return TRUE;
+
+ JOY_Sticks[dwJoyID].hDriver = OpenDriverA("joystick.drv", 0,
dwJoyID);
+ return (JOY_Sticks[dwJoyID].hDriver != 0);
+}
+
+/**********************************************************************
****
+ * JOY_Timer [internal]
+ */
+static void CALLBACK JOY_Timer(HWND hWnd, UINT wMsg, UINT
wTimer, DWORD dwTime)
+{
+ int i;
+ WINE_JOYSTICK* joy;
+ JOYINFO ji;
+ LONG pos;
+ unsigned buttonChange;
+
+ for (i = 0; i < MAXJOYSTICK; i++) {
+ joy = &JOY_Sticks[i];
+
+ if (joy->hCapture != hWnd) continue;
+
+ joyGetPos(i, &ji);
+ pos = MAKELONG(ji.wXpos, ji.wYpos);
+
+ if (!joy->bChanged ||
+ abs(joy->ji.wXpos - ji.wXpos) > joy->threshold ||
+ abs(joy->ji.wYpos - ji.wYpos) > joy->threshold) {
+ SendMessageA(joy->hCapture, MM_JOY1MOVE + i, ji.wButtons,
pos);
+ joy->ji.wXpos = ji.wXpos;
+ joy->ji.wYpos = ji.wYpos;
+ }
+ if (!joy->bChanged ||
+ abs(joy->ji.wZpos - ji.wZpos) > joy->threshold) {
+ SendMessageA(joy->hCapture, MM_JOY1ZMOVE + i, ji.wButtons,
pos);
+ joy->ji.wZpos = ji.wZpos;
+ }
+ if ((buttonChange = joy->ji.wButtons ^ ji.wButtons) != 0) {
+ if (ji.wButtons & buttonChange)
+ SendMessageA(joy->hCapture, MM_JOY1BUTTONDOWN + i,
+ (buttonChange << 8) | (ji.wButtons &
buttonChange), pos);
+ if (joy->ji.wButtons & buttonChange)
+ SendMessageA(joy->hCapture, MM_JOY1BUTTONUP + i,
+ (buttonChange << 8) | (joy->ji.wButtons &
buttonChange), pos);
+ joy->ji.wButtons = ji.wButtons;
+ }
+ }
+}
+
+/**********************************************************************
****
+ * joyGetNumDevs [WINMM.@]
+ */
+UINT WINAPI joyGetNumDevs(void)
+{
+ UINT ret = 0;
+ int i;
+
+ for (i = 0; i < MAXJOYSTICK; i++) {
+ if (JOY_LoadDriver(i)) {
+ ret += SendDriverMessage(JOY_Sticks[i].hDriver,
JDD_GETNUMDEVS, 0L, 0L);
+ }
+ }
+ return ret;
+}
+
+/**********************************************************************
****
+ * joyGetDevCapsA [WINMM.@]
+ */
+MMRESULT WINAPI joyGetDevCapsA(UINT_PTR wID, LPJOYCAPSA lpCaps, UINT
wSize)
+{
+ if (wID >= MAXJOYSTICK) return JOYERR_PARMS;
+ if (!JOY_LoadDriver(wID)) return MMSYSERR_NODRIVER;
+
+ lpCaps->wPeriodMin = JOY_PERIOD_MIN; /* FIXME */
+ lpCaps->wPeriodMax = JOY_PERIOD_MAX; /* FIXME (same as MS Joystick
Driver) */
+
+ return SendDriverMessage(JOY_Sticks[wID].hDriver, JDD_GETDEVCAPS,
(DWORD)lpCaps, wSize);
+}
+
+/**********************************************************************
****
+ * joyGetDevCapsW [WINMM.@]
+ */
+MMRESULT WINAPI joyGetDevCapsW(UINT_PTR wID, LPJOYCAPSW lpCaps, UINT
wSize)
+{
+ JOYCAPSA jca;
+ MMRESULT ret = joyGetDevCapsA(wID, &jca, sizeof(jca));
+
+ if (ret != JOYERR_NOERROR) return ret;
+ lpCaps->wMid = jca.wMid;
+ lpCaps->wPid = jca.wPid;
+ MultiByteToWideChar( CP_ACP, 0, jca.szPname, -1, lpCaps->szPname,
+ sizeof(lpCaps->szPname)/sizeof(WCHAR) );
+ lpCaps->wXmin = jca.wXmin;
+ lpCaps->wXmax = jca.wXmax;
+ lpCaps->wYmin = jca.wYmin;
+ lpCaps->wYmax = jca.wYmax;
+ lpCaps->wZmin = jca.wZmin;
+ lpCaps->wZmax = jca.wZmax;
+ lpCaps->wNumButtons = jca.wNumButtons;
+ lpCaps->wPeriodMin = jca.wPeriodMin;
+ lpCaps->wPeriodMax = jca.wPeriodMax;
+
+ if (wSize >= sizeof(JOYCAPSW)) { /* Win95 extensions ? */
+ lpCaps->wRmin = jca.wRmin;
+ lpCaps->wRmax = jca.wRmax;
+ lpCaps->wUmin = jca.wUmin;
+ lpCaps->wUmax = jca.wUmax;
+ lpCaps->wVmin = jca.wVmin;
+ lpCaps->wVmax = jca.wVmax;
+ lpCaps->wCaps = jca.wCaps;
+ lpCaps->wMaxAxes = jca.wMaxAxes;
+ lpCaps->wNumAxes = jca.wNumAxes;
+ lpCaps->wMaxButtons = jca.wMaxButtons;
+ MultiByteToWideChar( CP_ACP, 0, jca.szRegKey, -1,
lpCaps->szRegKey,
+ sizeof(lpCaps->szRegKey)/sizeof(WCHAR) );
+ MultiByteToWideChar( CP_ACP, 0, jca.szOEMVxD, -1,
lpCaps->szOEMVxD,
+ sizeof(lpCaps->szOEMVxD)/sizeof(WCHAR) );
+ }
+
+ return ret;
+}
+
+/**********************************************************************
****
+ * joyGetPosEx [WINMM.@]
+ */
+MMRESULT WINAPI joyGetPosEx(UINT wID, LPJOYINFOEX lpInfo)
+{
+ TRACE("(%d, %p);\n", wID, lpInfo);
+
+ if (wID >= MAXJOYSTICK) return JOYERR_PARMS;
+ if (!JOY_LoadDriver(wID)) return MMSYSERR_NODRIVER;
+
+ lpInfo->dwXpos = 0;
+ lpInfo->dwYpos = 0;
+ lpInfo->dwZpos = 0;
+ lpInfo->dwRpos = 0;
+ lpInfo->dwUpos = 0;
+ lpInfo->dwVpos = 0;
+ lpInfo->dwButtons = 0;
+ lpInfo->dwButtonNumber = 0;
+ lpInfo->dwPOV = 0;
+ lpInfo->dwReserved1 = 0;
+ lpInfo->dwReserved2 = 0;
+
+ return SendDriverMessage(JOY_Sticks[wID].hDriver, JDD_GETPOSEX,
(DWORD)lpInfo, 0L);
+}
+
+/**********************************************************************
****
+ * joyGetPos [WINMM.@]
+ */
+MMRESULT WINAPI joyGetPos(UINT wID, LPJOYINFO lpInfo)
+{
+ TRACE("(%d, %p);\n", wID, lpInfo);
+
+ if (wID >= MAXJOYSTICK) return JOYERR_PARMS;
+ if (!JOY_LoadDriver(wID)) return MMSYSERR_NODRIVER;
+
+ lpInfo->wXpos = 0;
+ lpInfo->wYpos = 0;
+ lpInfo->wZpos = 0;
+ lpInfo->wButtons = 0;
+
+ return SendDriverMessage(JOY_Sticks[wID].hDriver, JDD_GETPOS,
(DWORD)lpInfo, 0L);
+}
+
+/**********************************************************************
****
+ * joyGetThreshold [WINMM.@]
+ */
+MMRESULT WINAPI joyGetThreshold(UINT wID, LPUINT lpThreshold)
+{
+ TRACE("(%04X, %p);\n", wID, lpThreshold);
+
+ if (wID >= MAXJOYSTICK) return JOYERR_PARMS;
+
+ *lpThreshold = JOY_Sticks[wID].threshold;
+ return JOYERR_NOERROR;
+}
+
+/**********************************************************************
****
+ * joyReleaseCapture [WINMM.@]
+ */
+MMRESULT WINAPI joyReleaseCapture(UINT wID)
+{
+ TRACE("(%04X);\n", wID);
+
+ if (wID >= MAXJOYSTICK) return JOYERR_PARMS;
+ if (!JOY_LoadDriver(wID)) return MMSYSERR_NODRIVER;
+ if (!JOY_Sticks[wID].hCapture) return JOYERR_NOCANDO;
+
+ KillTimer(JOY_Sticks[wID].hCapture, JOY_Sticks[wID].wTimer);
+ JOY_Sticks[wID].hCapture = 0;
+ JOY_Sticks[wID].wTimer = 0;
+
+ return JOYERR_NOERROR;
+}
+
+/**********************************************************************
****
+ * joySetCapture [WINMM.@]
+ */
+MMRESULT WINAPI joySetCapture(HWND hWnd, UINT wID, UINT wPeriod, BOOL
bChanged)
+{
+ TRACE("(%p, %04X, %d, %d);\n", hWnd, wID, wPeriod, bChanged);
+
+ if (wID >= MAXJOYSTICK || hWnd == 0) return JOYERR_PARMS;
+ if (wPeriod<JOY_PERIOD_MIN || wPeriod>JOY_PERIOD_MAX) return
JOYERR_PARMS;
+ if (!JOY_LoadDriver(wID)) return MMSYSERR_NODRIVER;
+
+ if (JOY_Sticks[wID].hCapture || !IsWindow(hWnd))
+ return JOYERR_NOCANDO; /* FIXME: what should be returned ? */
+
+ if (joyGetPos(wID, &JOY_Sticks[wID].ji) != JOYERR_NOERROR)
+ return JOYERR_UNPLUGGED;
+
+ if ((JOY_Sticks[wID].wTimer = SetTimer(hWnd, 0, wPeriod,
JOY_Timer)) == 0)
+ return JOYERR_NOCANDO;
+
+ JOY_Sticks[wID].hCapture = hWnd;
+ JOY_Sticks[wID].bChanged = bChanged;
+
+ return JOYERR_NOERROR;
+}
+
+/**********************************************************************
****
+ * joySetThreshold [WINMM.@]
+ */
+MMRESULT WINAPI joySetThreshold(UINT wID, UINT wThreshold)
+{
+ TRACE("(%04X, %d);\n", wID, wThreshold);
+
+ if (wID >= MAXJOYSTICK) return MMSYSERR_INVALPARAM;
+
+ JOY_Sticks[wID].threshold = wThreshold;
+
+ return JOYERR_NOERROR;
+}
_____
Added: vendor/wine/dlls/winmm/current/lolvldrv.c
--- vendor/wine/dlls/winmm/current/lolvldrv.c 2004-12-31 16:30:04 UTC
(rev 12637)
+++ vendor/wine/dlls/winmm/current/lolvldrv.c 2004-12-31 16:34:31 UTC
(rev 12638)
@@ -0,0 +1,850 @@
+/* -*- tab-width: 8; c-basic-offset: 4 -*- */
+
+/*
+ * MMSYTEM low level drivers handling functions
+ *
+ * Copyright 1999 Eric Pouech
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA
+ */
+
+#include <string.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <assert.h>
+#include "windef.h"
+#include "winbase.h"
+#include "winreg.h"
+#include "winver.h"
+#include "winemm.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(winmm);
+
+LRESULT (*pFnCallMMDrvFunc16)(DWORD,WORD,WORD,LONG,LONG,LONG)
/* = NULL */;
+unsigned (*pFnLoadMMDrvFunc16)(LPCSTR,LPWINE_DRIVER,
LPWINE_MM_DRIVER) /* = NULL */;
+
+/* each known type of driver has an instance of this structure */
+typedef struct tagWINE_LLTYPE {
+ /* those attributes depend on the specification of the type */
+ LPCSTR typestr; /* name (for debugging) */
+ BOOL bSupportMapper; /* if type is allowed to support
mapper */
+ MMDRV_MAPFUNC Map16To32A; /* those are function pointers
to handle */
+ MMDRV_UNMAPFUNC UnMap16To32A; /* the parameter conversion
(16 vs 32 bit) */
+ MMDRV_MAPFUNC Map32ATo16; /* when hi-func (in mmsystem
or winmm) and */
+ MMDRV_UNMAPFUNC UnMap32ATo16; /* low-func (in .drv) do not
match */
+ LPDRVCALLBACK Callback; /* handles callback for a
specified type */
+ /* those attributes reflect the loaded/current situation for the
type */
+ UINT wMaxId; /* number of loaded devices (sum
across all loaded drivers */
+ LPWINE_MLD lpMlds; /* "static" mlds to access the
part though device IDs */
+ int nMapper; /* index to mapper */
+} WINE_LLTYPE;
+
+static int MMDrvsHi /* = 0 */;
+static WINE_MM_DRIVER MMDrvs[8];
+static LPWINE_MLD MM_MLDrvs[40];
+#define MAX_MM_MLDRVS (sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0]))
+
+#define A(_x,_y) {#_y, _x, NULL, NULL, NULL, NULL, NULL, 0, NULL, -1}
+/* Note: the indices of this array must match the definitions
+ * of the MMDRV_???? manifest constants
+ */
+static WINE_LLTYPE llTypes[MMDRV_MAX] = {
+ A(TRUE, Aux),
+ A(FALSE, Mixer),
+ A(TRUE, MidiIn),
+ A(TRUE, MidiOut),
+ A(TRUE, WaveIn),
+ A(TRUE, WaveOut),
+};
[truncated at 1000 lines; 19399 more skipped]
