Implemented (nearly) all TAPI functions as stubs.
diff --git a/Makefile.in b/Makefile.in
index 2ea4562..351a0c3 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -39,6 +39,7 @@
dlls/psapi \
dlls/rasapi32 \
dlls/shell32 \
+ dlls/tapi32 \
dlls/ver \
dlls/version \
dlls/winaspi \
@@ -112,6 +113,7 @@
dlls/psapi/psapi.o \
dlls/rasapi32/rasapi32.o \
dlls/shell32/shell32.o \
+ dlls/tapi32/tapi32.o \
dlls/ver/ver.o \
dlls/version/version.o \
dlls/winaspi/winaspi.o \
diff --git a/configure b/configure
index d21293d..a83b473 100755
--- a/configure
+++ b/configure
@@ -4607,6 +4607,7 @@
dlls/psapi/Makefile
dlls/rasapi32/Makefile
dlls/shell32/Makefile
+dlls/tapi32/Makefile
dlls/ver/Makefile
dlls/version/Makefile
dlls/winaspi/Makefile
@@ -4769,6 +4770,7 @@
dlls/psapi/Makefile
dlls/rasapi32/Makefile
dlls/shell32/Makefile
+dlls/tapi32/Makefile
dlls/ver/Makefile
dlls/version/Makefile
dlls/winaspi/Makefile
diff --git a/configure.in b/configure.in
index 242d483..e2fa923 100644
--- a/configure.in
+++ b/configure.in
@@ -632,6 +632,7 @@
dlls/psapi/Makefile
dlls/rasapi32/Makefile
dlls/shell32/Makefile
+dlls/tapi32/Makefile
dlls/ver/Makefile
dlls/version/Makefile
dlls/winaspi/Makefile
diff --git a/dlls/Makefile.in b/dlls/Makefile.in
index dff6343..76cc186 100644
--- a/dlls/Makefile.in
+++ b/dlls/Makefile.in
@@ -9,6 +9,7 @@
ntdll \
psapi \
shell32 \
+ tapi32 \
ver \
version \
winaspi \
diff --git a/dlls/tapi32/.cvsignore b/dlls/tapi32/.cvsignore
new file mode 100644
index 0000000..f3c7a7c
--- /dev/null
+++ b/dlls/tapi32/.cvsignore
@@ -0,0 +1 @@
+Makefile
diff --git a/dlls/tapi32/Makefile.in b/dlls/tapi32/Makefile.in
new file mode 100644
index 0000000..5c2c793
--- /dev/null
+++ b/dlls/tapi32/Makefile.in
@@ -0,0 +1,18 @@
+DEFS = @DLLFLAGS@ -D__WINE__
+TOPSRCDIR = @top_srcdir@
+TOPOBJDIR = ../..
+SRCDIR = @srcdir@
+VPATH = @srcdir@
+MODULE = tapi32
+
+C_SRCS = \
+ assisted.c \
+ line.c \
+ phone.c
+
+all: $(MODULE).o
+
+@MAKE_RULES@
+
+### Dependencies:
+
diff --git a/dlls/tapi32/assisted.c b/dlls/tapi32/assisted.c
new file mode 100644
index 0000000..429e4a3
--- /dev/null
+++ b/dlls/tapi32/assisted.c
@@ -0,0 +1,29 @@
+/*
+ * TAPI32 Assisted Telephony
+ *
+ * Copyright 1999 Andreas Mohr
+ */
+
+#include "winbase.h"
+#include "wintypes.h"
+#include "tapi.h"
+#include "debug.h"
+
+DWORD WINAPI tapiGetLocationInfo(LPSTR lpszCountryCode, LPSTR lpszCityCode)
+{
+ char temp[30];
+
+ FIXME(tapi, "(%s, %s): file sections ???\n", lpszCountryCode, lpszCityCode);
+ if (!(GetPrivateProfileStringA("Locations", "CurrentLocation", "", temp, 30, "telephon.ini")))
+ return TAPIERR_REQUESTFAILED;
+ if (!(GetPrivateProfileStringA("Locations", "FIXME_ENTRY", "", lpszCityCode, 8, "telephon.ini")))
+ return TAPIERR_REQUESTFAILED;
+ return 0;
+}
+
+DWORD WINAPI tapiRequestMakeCall(LPCSTR lpszDestAddress, LPCSTR lpszAppName,
+ LPCSTR lpszCalledParty, LPCSTR lpszComment)
+{
+ FIXME(tapi, "(%s, %s, %s, %s): stub.\n", lpszDestAddress, lpszAppName, lpszCalledParty, lpszComment);
+ return 0;
+}
diff --git a/dlls/tapi32/line.c b/dlls/tapi32/line.c
new file mode 100644
index 0000000..8219052
--- /dev/null
+++ b/dlls/tapi32/line.c
@@ -0,0 +1,526 @@
+/*
+ * TAPI32 line services
+ *
+ * Copyright 1999 Andreas Mohr
+ */
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "winbase.h"
+#include "wintypes.h"
+#include "tapi.h"
+#include "debug.h"
+
+DWORD WINAPI lineAccept(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
+{
+ FIXME(tapi, "(%04x, %s, %ld): stub.\n", hCall, lpsUserUserInfo, dwSize);
+ return 1;
+}
+
+DWORD WINAPI lineAddProvider(LPCSTR lpszProviderName, HWND hwndOwner, LPDWORD lpdwPermanentProviderID)
+{
+ FIXME(tapi, "(%s, %04x, %p): stub.\n", lpszProviderName, hwndOwner, lpdwPermanentProviderID);
+ return 1;
+}
+
+DWORD WINAPI lineAddToConference(HCALL hConfCall, HCALL hConsultCall)
+{
+ FIXME(tapi, "(%04x, %04x): stub.\n", hConfCall, hConsultCall);
+ return 1;
+}
+
+DWORD WINAPI lineAnswer(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
+{
+ FIXME(tapi, "(%04x, %s, %ld): stub.\n", hCall, lpsUserUserInfo, dwSize);
+ return 1;
+}
+
+DWORD WINAPI lineBlindTransfer(HCALL hCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
+{
+ FIXME(tapi, "(%04x, %s, %08lx): stub.\n", hCall, lpszDestAddress, dwCountryCode);
+ return 1;
+}
+
+DWORD WINAPI lineClose(HLINE hLine)
+{
+ FIXME(tapi, "(%04x): stub.\n", hLine);
+ return 0;
+}
+
+DWORD WINAPI lineCompleteCall(HCALL hCall, LPDWORD lpdwCompletionID, DWORD dwCompletionMode, DWORD dwMessageID)
+{
+ FIXME(tapi, "(%04x, %p, %08lx, %08lx): stub.\n", hCall, lpdwCompletionID, dwCompletionMode, dwMessageID);
+ return 1;
+}
+
+DWORD WINAPI lineCompleteTransfer(HCALL hCall, HCALL hConsultCall, LPHCALL lphConfCall, DWORD dwTransferMode)
+{
+ FIXME(tapi, "(%04x, %04x, %p, %08lx): stub.\n", hCall, hConsultCall, lphConfCall, dwTransferMode);
+ return 1;
+}
+
+DWORD WINAPI lineConfigDialog(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass)
+{
+ FIXME(tapi, "(%08lx, %04x, %s): stub.\n", dwDeviceID, hwndOwner, lpszDeviceClass);
+ return 0;
+}
+
+DWORD WINAPI lineConfigDialogEdit(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass, LPVOID const lpDeviceConfigIn, DWORD dwSize, LPVARSTRING lpDeviceConfigOut)
+{
+ FIXME(tapi, "stub.\n");
+ return 0;
+}
+
+DWORD WINAPI lineConfigProvider(HWND hwndOwner, DWORD dwPermanentProviderID)
+{
+ FIXME(tapi, "(%04x, %08lx): stub.\n", hwndOwner, dwPermanentProviderID);
+ return 0;
+}
+
+DWORD WINAPI lineDeallocateCall(HCALL hCall)
+{
+ FIXME(tapi, "(%04x): stub.\n", hCall);
+ return 0;
+}
+
+DWORD WINAPI lineDevSpecific(HLINE hLine, DWORD dwAddressId, HCALL hCall, LPVOID lpParams, DWORD dwSize)
+{
+ FIXME(tapi, "(%04x, %08lx, %04x, %p, %ld): stub.\n", hLine, dwAddressId, hCall, lpParams, dwSize);
+ return 1;
+}
+
+DWORD WINAPI lineDevSpecificFeature(HLINE hLine, DWORD dwFeature, LPVOID lpParams, DWORD dwSize)
+{
+ FIXME(tapi, "(%04x, %08lx, %p, %ld): stub.\n", hLine, dwFeature, lpParams, dwSize);
+ return 1;
+}
+
+DWORD WINAPI lineDial(HCALL hCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
+{
+ FIXME(tapi, "(%04x, %s, %08lx): stub.\n", hCall, lpszDestAddress, dwCountryCode);
+ return 1;
+}
+
+DWORD WINAPI lineDrop(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
+{
+ FIXME(tapi, "(%04x, %s, %08lx): stub.\n", hCall, lpsUserUserInfo, dwSize);
+ return 1;
+}
+
+DWORD WINAPI lineForward(HLINE hLine, DWORD bAllAddress, DWORD dwAdressID, LPLINEFORWARDLIST lpForwardList, DWORD dwNumRingsNoAnswer, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
+{
+ FIXME(tapi, "stub.\n");
+ return 1;
+}
+
+DWORD WINAPI lineGatherDigits(HCALL hCall, DWORD dwDigitModes, LPSTR lpsDigits, DWORD dwNumDigits, LPCSTR lpszTerminationDigits, DWORD dwFirstDigitTimeout, DWORD dwInterDigitTimeout)
+{
+ FIXME(tapi, "stub.\n");
+ return 0;
+}
+
+DWORD WINAPI lineGenerateDigits(HCALL hCall, DWORD dwDigitModes, LPCSTR lpszDigits, DWORD dwDuration)
+{
+ FIXME(tapi, "(%04x, %08lx, %s, %ld): stub.\n", hCall, dwDigitModes, lpszDigits, dwDuration);
+ return 0;
+}
+
+DWORD WINAPI lineGenerateTone(HCALL hCall, DWORD dwToneMode, DWORD dwDuration, DWORD dwNumTones, LPLINEGENERATETONE lpTones)
+{
+ FIXME(tapi, "(%04x, %08lx, %ld, %ld, %p): stub.\n", hCall, dwToneMode, dwDuration, dwNumTones, lpTones);
+ return 0;
+}
+
+DWORD WINAPI lineGetAddressCaps(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAddressID, DWORD dwAPIVersion, DWORD dwExtVersion, LPLINEADDRESSCAPS lpAddressCaps)
+{
+ FIXME(tapi, "(%04x, %08lx, %08lx, %08lx, %08lx, %p): stub.\n", hLineApp, dwDeviceID, dwAddressID, dwAPIVersion, dwExtVersion, lpAddressCaps);
+ return 0;
+}
+
+DWORD WINAPI lineGetAddressID(HLINE hLine, LPDWORD lpdwAddressID, DWORD dwAddressMode, LPCSTR lpsAddress, DWORD dwSize)
+{
+ FIXME(tapi, "%04x, %p, %08lx, %s, %ld): stub.\n", hLine, lpdwAddressID, dwAddressMode, lpsAddress, dwSize);
+ return 0;
+}
+
+DWORD WINAPI lineGetAddressStatus(HLINE hLine, DWORD dwAddressID, LPLINEADDRESSSTATUS lpAddressStatus)
+{
+ FIXME(tapi, "(%04x, %08lx, %p): stub.\n", hLine, dwAddressID, lpAddressStatus);
+ return 0;
+}
+
+DWORD WINAPI lineGetAppPriority(LPCSTR lpszAppFilename, DWORD dwMediaMode, LPLINEEXTENSIONID const lpExtensionID, DWORD dwRequestMode, LPVARSTRING lpExtensionName, LPDWORD lpdwPriority)
+{
+ FIXME(tapi, "(%s, %08lx, %p, %08lx, %p, %p): stub.\n", lpszAppFilename, dwMediaMode, lpExtensionID, dwRequestMode, lpExtensionName, lpdwPriority);
+ return 0;
+}
+
+DWORD WINAPI lineGetCallInfo(HCALL hCall, LPLINECALLINFO lpCallInfo)
+{
+ FIXME(tapi, "(%04x, %p): stub.\n", hCall, lpCallInfo);
+ return 0;
+}
+
+DWORD WINAPI lineGetCallStatus(HCALL hCall, LPLINECALLSTATUS lpCallStatus)
+{
+ FIXME(tapi, "(%04x, %p): stub.\n", hCall, lpCallStatus);
+ return 0;
+}
+
+DWORD WINAPI lineGetConfRelatedCalls(HCALL hCall, LPLINECALLLIST lpCallList)
+{
+ FIXME(tapi, "(%04x, %p): stub.\n", hCall, lpCallList);
+ return 0;
+}
+
+DWORD WINAPI lineGetCountry(DWORD dwCountryID, DWORD dwAPIVersion, LPLINECOUNTRYLIST lpLineCountryList)
+{
+ FIXME(tapi, "(%08lx, %08lx, %p): stub.\n", dwCountryID, dwAPIVersion, lpLineCountryList);
+ return 0;
+}
+
+DWORD WINAPI lineGetDevCaps(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtVersion, LPLINEDEVCAPS lpLineDevCaps)
+{
+ FIXME(tapi, "(%04x, %08lx, %08lx, %08lx, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, dwExtVersion, lpLineDevCaps);
+ return 0;
+}
+
+DWORD WINAPI lineGetDevConfig(DWORD dwDeviceID, LPVARSTRING lpDeviceConfig, LPCSTR lpszDeviceClass)
+{
+ FIXME(tapi, "(%08lx, %p, %s): stub.\n", dwDeviceID, lpDeviceConfig, lpszDeviceClass);
+ return 0;
+}
+
+DWORD WINAPI lineGetID(HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSelect, LPVARSTRING lpDeviceID, LPCSTR lpszDeviceClass)
+{
+ FIXME(tapi, "(%04x, %08lx, %04x, %08lx, %p, %s): stub.\n", hLine, dwAddressID, hCall, dwSelect, lpDeviceID, lpszDeviceClass);
+ return 0;
+}
+
+DWORD WINAPI lineGetIcon(DWORD dwDeviceID, LPCSTR lpszDeviceClass, HICON *lphIcon)
+{
+ FIXME(tapi, "(%08lx, %s, %p): stub.\n", dwDeviceID, lpszDeviceClass, lphIcon);
+ return 0;
+}
+
+DWORD WINAPI lineGetLineDevStatus(HLINE hLine, LPLINEDEVSTATUS lpLineDevStatus)
+{
+ FIXME(tapi, "(%04x, %p): stub.\n", hLine, lpLineDevStatus);
+ return 0;
+}
+
+DWORD WINAPI lineGetNewCalls(HLINE hLine, DWORD dwAddressID, DWORD dwSelect, LPLINECALLLIST lpCallList)
+{
+ FIXME(tapi, "(%04x, %08lx, %08lx, %p): stub.\n", hLine, dwAddressID, dwSelect, lpCallList);
+ return 0;
+}
+
+
+DWORD WINAPI lineGetNumRings(HLINE hLine, DWORD dwAddressID, LPDWORD lpdwNumRings)
+{
+ FIXME(tapi, "(%04x, %08lx, %p): stub.\n", hLine, dwAddressID, lpdwNumRings);
+ return 0;
+}
+
+DWORD WINAPI lineGetProviderList(DWORD dwAPIVersion, LPLINEPROVIDERLIST lpProviderList)
+{
+ FIXME(tapi, "(%08lx, %p): stub.\n", dwAPIVersion, lpProviderList);
+ return 0;
+}
+
+DWORD WINAPI lineGetRequest(HLINEAPP hLineApp, DWORD dwRequestMode, LPVOID lpRequestBuffer)
+{
+ FIXME(tapi, "%04x, %08lx, %p): stub.\n", hLineApp, dwRequestMode, lpRequestBuffer);
+ return 0;
+}
+
+DWORD WINAPI lineGetStatusMessages(HLINE hLine, LPDWORD lpdwLineStatus, LPDWORD lpdwAddressStates)
+{
+ FIXME(tapi, "(%04x, %p, %p): stub.\n", hLine, lpdwLineStatus, lpdwAddressStates);
+ return 0;
+}
+
+DWORD WINAPI lineGetTranslateCaps(HLINEAPP hLineApp, DWORD dwAPIVersion, LPLINETRANSLATECAPS lpTranslateCaps)
+{
+ FIXME(tapi, "(%04x, %08lx, %p): stub.\n", hLineApp, dwAPIVersion, lpTranslateCaps);
+ return 0;
+}
+
+DWORD WINAPI lineHandoff(HCALL hCall, LPCSTR lpszFileName, DWORD dwMediaMode)
+{
+ FIXME(tapi, "(%04x, %s, %08lx): stub.\n", hCall, lpszFileName, dwMediaMode);
+ return 0;
+}
+
+DWORD WINAPI lineHold(HCALL hCall)
+{
+ FIXME(tapi, "(%04x): stub.\n", hCall);
+ return 1;
+}
+
+DWORD WINAPI lineInitialize(
+ LPHLINEAPP lphLineApp,
+ HINSTANCE hInstance,
+ LINECALLBACK lpfnCallback,
+ LPCSTR lpszAppName,
+ LPDWORD lpdwNumDevs)
+{
+ FIXME(comm, "stub.\n");
+ return 0;
+}
+
+DWORD WINAPI lineMakeCall(HLINE hLine, LPHCALL lphCall, LPCSTR lpszDestAddress, DWORD dwCountryCode, LPLINECALLPARAMS lpCallParams)
+{
+ FIXME(tapi, "(%04x, %p, %s, %08lx, %p): stub.\n", hLine, lphCall, lpszDestAddress, dwCountryCode, lpCallParams);
+ return 1;
+}
+
+DWORD WINAPI lineMonitorDigits(HCALL hCall, DWORD dwDigitModes)
+{
+ FIXME(tapi, "(%04x, %08lx): stub.\n", hCall, dwDigitModes);
+ return 0;
+}
+
+DWORD WINAPI lineMonitorMedia(HCALL hCall, DWORD dwMediaModes)
+{
+ FIXME(tapi, "(%04x, %08lx): stub.\n", hCall, dwMediaModes);
+ return 0;
+}
+
+DWORD WINAPI lineMonitorTones(HCALL hCall, LPLINEMONITORTONE lpToneList, DWORD dwNumEntries)
+{
+ FIXME(tapi, "(%04x, %p, %08lx): stub.\n", hCall, lpToneList, dwNumEntries);
+ return 0;
+}
+
+DWORD WINAPI lineNegotiateAPIVersion(
+ HLINEAPP hLineApp,
+ DWORD dwDeviceID,
+ DWORD dwAPILowVersion,
+ DWORD dwAPIHighVersion,
+ LPDWORD lpdwAPIVersion,
+ LPLINEEXTENSIONID lpExtensionID
+)
+{
+ FIXME(comm, "stub.\n");
+ *lpdwAPIVersion = dwAPIHighVersion;
+ return 0;
+}
+
+DWORD WINAPI lineNegotiateExtVersion(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtLowVersion, DWORD dwExtHighVersion, LPDWORD lpdwExtVersion)
+{
+ FIXME(tapi, "stub.\n");
+ return 0;
+}
+
+DWORD WINAPI lineOpen(HLINEAPP hLineApp, DWORD dwDeviceID, LPHLINE lphLine, DWORD dwAPIVersion, DWORD dwExtVersion, DWORD dwCallbackInstance, DWORD dwPrivileges, DWORD dwMediaModes, LPLINECALLPARAMS lpCallParams)
+{
+ FIXME(tapi, "stub.\n");
+ return 0;
+}
+
+DWORD WINAPI linePark(HCALL hCall, DWORD dwParkMode, LPCSTR lpszDirAddress, LPVARSTRING lpNonDirAddress)
+{
+ FIXME(tapi, "(%04x, %08lx, %s, %p): stub.\n", hCall, dwParkMode, lpszDirAddress, lpNonDirAddress);
+ return 1;
+}
+
+DWORD WINAPI linePickup(HLINE hLine, DWORD dwAddressID, LPHCALL lphCall, LPCSTR lpszDestAddress, LPCSTR lpszGroupID)
+{
+ FIXME(tapi, "(%04x, %08lx, %p, %s, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress, lpszGroupID);
+ return 1;
+}
+
+DWORD WINAPI linePrepareAddToConference(HCALL hConfCall, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
+{
+ FIXME(tapi, "(%04x, %p, %p): stub.\n", hConfCall, lphConsultCall, lpCallParams);
+ return 1;
+}
+
+/*************************************************************************
+ * lineRedirect [TAPI32.53]
+ *
+ */
+DWORD WINAPI lineRedirect(
+ HCALL hCall,
+ LPCSTR lpszDestAddress,
+ DWORD dwCountryCode) {
+
+ FIXME(comm, ": stub.\n");
+ return 1;
+}
+
+DWORD WINAPI lineRegisterRequestRecipient(HLINEAPP hLineApp, DWORD dwRegistrationInstance, DWORD dwRequestMode, DWORD dwEnable)
+{
+ FIXME(tapi, "(%04x, %08lx, %08lx, %08lx): stub.\n", hLineApp, dwRegistrationInstance, dwRequestMode, dwEnable);
+ return 1;
+}
+
+DWORD WINAPI lineReleaseUserUserInfo(HCALL hCall)
+{
+ FIXME(tapi, "(%04x): stub.\n", hCall);
+ return 1;
+}
+
+DWORD WINAPI lineRemoveFromConference(HCALL hCall)
+{
+ FIXME(tapi, "(%04x): stub.\n", hCall);
+ return 1;
+}
+
+DWORD WINAPI lineRemoveProvider(DWORD dwPermanentProviderID, HWND hwndOwner)
+{
+ FIXME(tapi, "(%08lx, %04x): stub.\n", dwPermanentProviderID, hwndOwner);
+ return 1;
+}
+
+DWORD WINAPI lineSecureCall(HCALL hCall)
+{
+ FIXME(tapi, "(%04x): stub.\n", hCall);
+ return 1;
+}
+
+DWORD WINAPI lineSendUserUserInfo(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
+{
+ FIXME(tapi, "(%04x, %s, %08lx): stub.\n", hCall, lpsUserUserInfo, dwSize);
+ return 1;
+}
+
+DWORD WINAPI lineSetAppPriority(LPCSTR lpszAppFilename, DWORD dwMediaMode, LPLINEEXTENSIONID const lpExtensionID, DWORD dwRequestMode, LPCSTR lpszExtensionName, DWORD dwPriority)
+{
+ FIXME(tapi, "(%s, %08lx, %p, %08lx, %s, %08lx): stub.\n", lpszAppFilename, dwMediaMode, lpExtensionID, dwRequestMode, lpszExtensionName, dwPriority);
+ return 0;
+}
+
+DWORD WINAPI lineSetAppSpecific(HCALL hCall, DWORD dwAppSpecific)
+{
+ FIXME(tapi, "(%04x, %08lx): stub.\n", hCall, dwAppSpecific);
+ return 0;
+}
+
+DWORD WINAPI lineSetCallParams(HCALL hCall, DWORD dwBearerMode, DWORD dwMinRate, DWORD dwMaxRate, LPLINEDIALPARAMS lpDialParams)
+{
+ FIXME(tapi, "(%04x, %08lx, %08lx, %08lx, %p): stub.\n", hCall, dwBearerMode, dwMinRate, dwMaxRate, lpDialParams);
+ return 1;
+}
+
+DWORD WINAPI lineSetCallPrivilege(HCALL hCall, DWORD dwCallPrivilege)
+{
+ FIXME(tapi, "(%04x, %08lx): stub.\n", hCall, dwCallPrivilege);
+ return 0;
+}
+
+DWORD WINAPI lineSetCurrentLocation(HLINEAPP hLineApp, DWORD dwLocation)
+{
+ FIXME(tapi, "(%04x, %08lx): stub.\n", hLineApp, dwLocation);
+ return 0;
+}
+
+DWORD WINAPI lineSetDevConfig(DWORD dwDeviceID, LPVOID lpDeviceConfig, DWORD dwSize, LPCSTR lpszDeviceClass)
+{
+ FIXME(tapi, "(%0lx, %p, %08lx, %s): stub.\n", dwDeviceID, lpDeviceConfig, dwSize, lpszDeviceClass);
+ return 0;
+}
+
+DWORD WINAPI lineSetMediaControl(
+HLINE hLine,
+DWORD dwAddressID,
+HCALL hCall,
+DWORD dwSelect,
+LPLINEMEDIACONTROLDIGIT const lpDigitList,
+DWORD dwDigitNumEntries,
+LPLINEMEDIACONTROLMEDIA const lpMediaList,
+DWORD dwMediaNumEntries,
+LPLINEMEDIACONTROLTONE const lpToneList,
+DWORD dwToneNumEntries,
+LPLINEMEDIACONTROLCALLSTATE const lpCallStateList,
+DWORD dwCallStateNumEntries)
+{
+ FIXME(tapi, ": stub.\n");
+ return 0;
+}
+
+DWORD WINAPI lineSetMediaMode(HCALL hCall, DWORD dwMediaModes)
+{
+ FIXME(tapi, "(%04x, %08lx): stub.\n", hCall, dwMediaModes);
+ return 0;
+}
+
+DWORD WINAPI lineSetNumRings(HLINE hLine, DWORD dwAddressID, DWORD dwNumRings)
+{
+ FIXME(tapi, "(%04x, %08lx, %08lx): stub.\n", hLine, dwAddressID, dwNumRings);
+ return 0;
+}
+
+DWORD WINAPI lineSetStatusMessages(HLINE hLine, DWORD dwLineStates, DWORD dwAddressStates)
+{
+ FIXME(tapi, "(%04x, %08lx, %08lx): stub.\n", hLine, dwLineStates, dwAddressStates);
+ return 0;
+}
+
+DWORD WINAPI lineSetTerminal(HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSelect, DWORD dwTerminalModes, DWORD dwTerminalID, DWORD bEnable)
+{
+ FIXME(tapi, "(%04x, %08lx, %04x, %08lx, %08lx, %08lx, %08lx): stub.\n", hLine, dwAddressID, hCall, dwSelect, dwTerminalModes, dwTerminalID, bEnable);
+ return 1;
+}
+
+DWORD WINAPI lineSetTollList(HLINEAPP hLineApp, DWORD dwDeviceID, LPCSTR lpszAddressIn, DWORD dwTollListOption)
+{
+ FIXME(tapi, "(%04x, %08lx, %s, %08lx): stub.\n", hLineApp, dwDeviceID, lpszAddressIn, dwTollListOption);
+ return 0;
+}
+
+DWORD WINAPI lineSetupConference(HCALL hCall, HLINE hLine, LPHCALL lphConfCall, LPHCALL lphConsultCall, DWORD dwNumParties, LPLINECALLPARAMS lpCallParams)
+{
+ FIXME(tapi, "(%04x, %04x, %p, %p, %08lx, %p): stub.\n", hCall, hLine, lphConfCall, lphConsultCall, dwNumParties, lpCallParams);
+ return 1;
+}
+
+DWORD WINAPI lineSetupTransfer(HCALL hCall, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
+{
+ FIXME(tapi, "(%04x, %p, %p): stub.\n", hCall, lphConsultCall, lpCallParams);
+ return 1;
+}
+
+DWORD WINAPI lineShutdown(HLINEAPP hLineApp)
+{
+ FIXME(tapi, "(%04x): stub.\n", hLineApp);
+ return 0;
+}
+
+DWORD WINAPI lineSwapHold(HCALL hActiveCall, HCALL hHeldCall)
+{
+ FIXME(tapi, "(active: %04x, held: %04x): stub.\n", hActiveCall, hHeldCall);
+ return 1;
+}
+
+DWORD WINAPI lineTranslateAddress(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, LPCSTR lpszAddressIn, DWORD dwCard, DWORD dwTranslateOptions, LPLINETRANSLATEOUTPUT lpTranslateOutput)
+{
+ FIXME(tapi, "(%04x, %08lx, %08lx, %s, %08lx, %08lx, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, lpszAddressIn, dwCard, dwTranslateOptions, lpTranslateOutput);
+ return 0;
+}
+
+DWORD WINAPI lineTranslateDialog(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, HWND hwndOwner, LPCSTR lpszAddressIn)
+{
+ FIXME(tapi, "(%04x, %08lx, %08lx, %04x, %s): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, hwndOwner, lpszAddressIn);
+ return 0;
+}
+
+DWORD WINAPI lineUncompleteCall(HLINE hLine, DWORD dwCompletionID)
+{
+ FIXME(tapi, "(%04x, %08lx): stub.\n", hLine, dwCompletionID);
+ return 1;
+}
+
+DWORD WINAPI lineUnHold(HCALL hCall)
+{
+ FIXME(tapi, "(%04x): stub.\n", hCall);
+ return 1;
+}
+
+DWORD WINAPI lineUnpark(HLINE hLine, DWORD dwAddressID, LPHCALL lphCall, LPCSTR lpszDestAddress)
+{
+ FIXME(tapi, "(%04x, %08lx, %p, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress);
+ return 1;
+}
diff --git a/dlls/tapi32/phone.c b/dlls/tapi32/phone.c
new file mode 100644
index 0000000..0a92cbf
--- /dev/null
+++ b/dlls/tapi32/phone.c
@@ -0,0 +1,206 @@
+/*
+ * TAPI32 phone services
+ *
+ * Copyright 1999 Andreas Mohr
+ */
+
+#include "winbase.h"
+#include "wintypes.h"
+#include "tapi.h"
+#include "debug.h"
+
+static LPPHONE PHONE_Alloc(void)
+{
+}
+
+static LPPHONE PHONE_Get(HPHONE hPhone)
+{
+}
+
+DWORD WINAPI phoneClose(HPHONE hPhone)
+{
+ FIXME(tapi, "(%04x), stub.\n", hPhone);
+ return 0;
+}
+
+DWORD WINAPI phoneConfigDialog(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass)
+{
+ FIXME(tapi, "(%08lx, %04x, %s): stub.\n", dwDeviceID, hwndOwner, lpszDeviceClass);
+ return 0;
+}
+
+DWORD WINAPI phoneDevSpecific(HPHONE hPhone, LPVOID lpParams, DWORD dwSize)
+{
+ FIXME(tapi, "(%04x, %p, %08ld): stub.\n", hPhone, lpParams, dwSize);
+ return 1;
+}
+
+DWORD WINAPI phoneGetButtonInfo(HPHONE hPhone, DWORD dwButtonLampID,
+ LPPHONEBUTTONINFO lpButtonInfo)
+{
+ FIXME(tapi, "(%04x, %08lx, %p): stub.\n", hPhone, dwButtonLampID, lpButtonInfo);
+ return 0;
+}
+
+DWORD WINAPI phoneGetData(HPHONE hPhone, DWORD dwDataID, LPVOID lpData, DWORD dwSize)
+{
+ FIXME(tapi, "(%04x, %08ld, %p, %08ld): stub.\n", hPhone, dwDataID, lpData, dwSize);
+ return 0;
+}
+
+DWORD WINAPI phoneGetDevCaps(HPHONEAPP hPhoneApp, DWORD dwDeviceID,
+ DWORD dwAPIVersion, DWORD dwExtVersion, LPPHONECAPS lpPhoneCaps)
+{
+ FIXME(tapi, "(%04x, %08ld, %08lx, %08lx, %p): stub.\n", hPhoneApp, dwDeviceID, dwAPIVersion, dwExtVersion, lpPhoneCaps);
+ return 0;
+}
+
+DWORD WINAPI phoneGetDisplay(HPHONE hPhone, LPVARSTRING lpDisplay)
+{
+ FIXME(tapi, "(%04x, %p): stub.\n", hPhone, lpDisplay);
+ return 0;
+}
+
+DWORD WINAPI phoneGetGain(HPHONE hPhone, DWORD dwHookSwitchDev, LPDWORD lpdwGain)
+{
+ FIXME(tapi, "(%04x, %08lx, %p): stub.\n", hPhone, dwHookSwitchDev, lpdwGain);
+ return 0;
+}
+
+DWORD WINAPI phoneGetHookSwitch(HPHONE hPhone, LPDWORD lpdwHookSwitchDevs)
+{
+ FIXME(tapi, "(%04x, %p): stub.\n", hPhone, lpdwHookSwitchDevs);
+ return 0;
+}
+
+DWORD WINAPI phoneGetID(HPHONE hPhone, LPVARSTRING lpDeviceID,
+ LPCSTR lpszDeviceClass)
+{
+ FIXME(tapi, "(%04x, %p, %s): stub.\n", hPhone, lpDeviceID, lpszDeviceClass); return 0;
+}
+
+DWORD WINAPI phoneGetIcon(DWORD dwDeviceID, LPCSTR lpszDeviceClass,
+ HICON *lphIcon)
+{
+ FIXME(tapi, "(%08lx, %s, %p): stub.\n", dwDeviceID, lpszDeviceClass, lphIcon);
+ return 0;
+}
+
+DWORD WINAPI phoneGetLamp(HPHONE hPhone, DWORD dwButtonLampID,
+ LPDWORD lpdwLampMode)
+{
+ FIXME(tapi, "(%04x, %08lx, %p): stub.\n", hPhone, dwButtonLampID, lpdwLampMode);
+ return 0;
+}
+
+DWORD WINAPI phoneGetRing(HPHONE hPhone, LPDWORD lpdwRingMode, LPDWORD lpdwVolume)
+{
+ FIXME(tapi, "(%04x, %p, %p): stub.\n", hPhone, lpdwRingMode, lpdwVolume);
+ return 0;
+}
+
+DWORD WINAPI phoneGetStatus(HPHONE hPhone, LPPHONESTATUS lpPhoneStatus)
+{
+ FIXME(tapi, "(%04x, %p): stub.\n", hPhone, lpPhoneStatus);
+ return 0;
+}
+
+DWORD WINAPI phoneGetStatusMessages(HPHONE hPhone, LPDWORD lpdwPhoneStates,
+ LPDWORD lpdwButtonModes, LPDWORD lpdwButtonStates)
+{
+ FIXME(tapi, "(%04x, %p, %p, %p): stub.\n", hPhone, lpdwPhoneStates, lpdwButtonModes, lpdwButtonStates);
+ return 0;
+}
+
+DWORD WINAPI phoneGetVolume(HPHONE hPhone, DWORD dwHookSwitchDevs,
+ LPDWORD lpdwVolume)
+{
+ FIXME(tapi, "(%04x, %08lx, %p): stub.\n", hPhone, dwHookSwitchDevs, lpdwVolume);
+ return 0;
+}
+
+DWORD WINAPI phoneInitialize(LPHPHONEAPP lphPhoneApp, HINSTANCE hInstance, PHONECALLBACK lpfnCallback, LPCSTR lpszAppName, LPDWORD lpdwNumDevs)
+{
+ FIXME(tapi, "(%p, %04x, %p, %s, %p): stub.\n", lphPhoneApp, hInstance, lpfnCallback, lpszAppName, lpdwNumDevs);
+ return 0;
+}
+
+DWORD WINAPI phoneNegotiateAPIVersion(HPHONEAPP hPhoneApp, DWORD dwDeviceID, DWORD dwAPILowVersion, DWORD dwAPIHighVersion, LPDWORD lpdwAPIVersion, LPPHONEEXTENSIONID lpExtensionID)
+{
+ FIXME(tapi, "(): stub.\n");
+ return 0;
+}
+
+DWORD WINAPI phoneNegotiateExtVersion(HPHONEAPP hPhoneApp, DWORD dwDeviceID,
+ DWORD dwAPIVersion, DWORD dwExtLowVersion,
+ DWORD dwExtHighVersion, LPDWORD lpdwExtVersion)
+{
+ FIXME(tapi, "(): stub.\n");
+ return 0;
+}
+
+DWORD WINAPI phoneOpen(HPHONEAPP hPhoneApp, DWORD dwDeviceID, LPHPHONE lphPhone, DWORD dwAPIVersion, DWORD dwExtVersion, DWORD dwCallbackInstance, DWORD dwPrivileges)
+{
+ FIXME(tapi, "(): stub.\n");
+ return 0;
+}
+
+DWORD WINAPI phoneSetButtonInfo(HPHONE hPhone, DWORD dwButtonLampID, LPPHONEBUTTONINFO lpButtonInfo)
+{
+ FIXME(tapi, "(%04x, %08lx, %p): stub.\n", hPhone, dwButtonLampID, lpButtonInfo);
+ return 0;
+}
+
+DWORD WINAPI phoneSetData(HPHONE hPhone, DWORD dwDataID, LPVOID lpData, DWORD dwSize)
+{
+ FIXME(tapi, "(%04x, %08lx, %p, %ld): stub.\n", hPhone, dwDataID, lpData, dwSize);
+ return 1;
+}
+
+DWORD WINAPI phoneSetDisplay(HPHONE hPhone, DWORD dwRow, DWORD dwColumn, LPCSTR lpszDisplay, DWORD dwSize)
+{
+ FIXME(tapi, "(%04x, '%s' at %ld/%ld, len %ld): stub.\n", hPhone, lpszDisplay, dwRow, dwColumn, dwSize);
+ return 1;
+}
+
+DWORD WINAPI phoneSetGain(HPHONE hPhone, DWORD dwHookSwitchDev, DWORD dwGain)
+{
+ FIXME(tapi, "(%04x, %08lx, %ld): stub.\n", hPhone, dwHookSwitchDev, dwGain);
+ return 1;
+}
+
+DWORD WINAPI phoneSetHookSwitch(HPHONE hPhone, DWORD dwHookSwitchDevs, DWORD dwHookSwitchMode)
+{
+ FIXME(tapi, "(%04x, %08lx, %08lx): stub.\n", hPhone, dwHookSwitchDevs, dwHookSwitchMode);
+ return 1;
+}
+
+DWORD WINAPI phoneSetLamp(HPHONE hPhone, DWORD dwButtonLampID, DWORD lpdwLampMode)
+{
+ FIXME(tapi, "(%04x, %08lx, %08lx): stub.\n", hPhone, dwButtonLampID, lpdwLampMode);
+ return 1;
+}
+
+DWORD WINAPI phoneSetRing(HPHONE hPhone, DWORD dwRingMode, DWORD dwVolume)
+{
+ FIXME(tapi, "(%04x, %08lx, %08ld): stub.\n", hPhone, dwRingMode, dwVolume);
+ return 1;
+}
+
+DWORD WINAPI phoneSetStatusMessages(HPHONE hPhone, DWORD dwPhoneStates, DWORD dwButtonModes, DWORD dwButtonStates)
+{
+ FIXME(tapi, "(%04x, %08lx, %08lx, %08lx): stub.\n", hPhone, dwPhoneStates, dwButtonModes, dwButtonStates);
+ return 0; /* FIXME ? */
+}
+
+DWORD WINAPI phoneSetVolume(HPHONE hPhone, DWORD dwHookSwitchDev, DWORD dwVolume)
+{
+ FIXME(tapi, "(%04x, %08lx, %08ld): stub.\n", hPhone, dwHookSwitchDev, dwVolume);
+ return 1;
+}
+
+DWORD WINAPI phoneShutdown(HPHONEAPP hPhoneApp)
+{
+ FIXME(tapi, "(%04x): stub.\n", hPhoneApp);
+ return 0;
+}
diff --git a/include/debug.h b/include/debug.h
index f129e3e..8dc8908 100644
--- a/include/debug.h
+++ b/include/debug.h
@@ -131,33 +131,34 @@
#define dbch_syscolor 123
#define dbch_system 124
#define dbch_tab 125
-#define dbch_task 126
-#define dbch_text 127
-#define dbch_thread 128
-#define dbch_thunk 129
-#define dbch_timer 130
-#define dbch_toolbar 131
-#define dbch_toolhelp 132
-#define dbch_tooltips 133
-#define dbch_trackbar 134
-#define dbch_treeview 135
-#define dbch_ttydrv 136
-#define dbch_tweak 137
-#define dbch_uitools 138
-#define dbch_unknown 139
-#define dbch_updown 140
-#define dbch_ver 141
-#define dbch_virtual 142
-#define dbch_vxd 143
-#define dbch_wave 144
-#define dbch_win 145
-#define dbch_win16drv 146
-#define dbch_win32 147
-#define dbch_wing 148
-#define dbch_winsock 149
-#define dbch_wnet 150
-#define dbch_x11 151
-#define dbch_x11drv 152
+#define dbch_tapi 126
+#define dbch_task 127
+#define dbch_text 128
+#define dbch_thread 129
+#define dbch_thunk 130
+#define dbch_timer 131
+#define dbch_toolbar 132
+#define dbch_toolhelp 133
+#define dbch_tooltips 134
+#define dbch_trackbar 135
+#define dbch_treeview 136
+#define dbch_ttydrv 137
+#define dbch_tweak 138
+#define dbch_uitools 139
+#define dbch_unknown 140
+#define dbch_updown 141
+#define dbch_ver 142
+#define dbch_virtual 143
+#define dbch_vxd 144
+#define dbch_wave 145
+#define dbch_win 146
+#define dbch_win16drv 147
+#define dbch_win32 148
+#define dbch_wing 149
+#define dbch_winsock 150
+#define dbch_wnet 151
+#define dbch_x11 152
+#define dbch_x11drv 153
/* Definitions for classes identifiers */
#define dbcl_fixme 0
#define dbcl_err 1
diff --git a/include/debugdefs.h b/include/debugdefs.h
index 9f9ad39..2e5b986 100644
--- a/include/debugdefs.h
+++ b/include/debugdefs.h
@@ -4,7 +4,7 @@
#include "debugtools.h"
#endif
-#define DEBUG_CHANNEL_COUNT 153
+#define DEBUG_CHANNEL_COUNT 154
#ifdef DEBUG_RUNTIME
short debug_msg_enabled[][DEBUG_CLASS_COUNT] = {
{1, 1, 0, 0},
@@ -160,6 +160,7 @@
{1, 1, 0, 0},
{1, 1, 0, 0},
{1, 1, 0, 0},
+{1, 1, 0, 0},
};
const char* debug_ch_name[] = {
"accel",
@@ -288,6 +289,7 @@
"syscolor",
"system",
"tab",
+"tapi",
"task",
"text",
"thread",
diff --git a/include/tapi.h b/include/tapi.h
new file mode 100644
index 0000000..a404941
--- /dev/null
+++ b/include/tapi.h
@@ -0,0 +1,626 @@
+/*
+ * TAPI definitions
+ *
+ * Copyright (c) 1999 Andreas Mohr
+ */
+
+#ifndef __WINE_TAPI_H
+#define __WINE_TAPI_H
+
+#include "windef.h"
+
+typedef HANDLE HCALL, *LPHCALL;
+typedef HANDLE HLINE, *LPHLINE;
+typedef HANDLE HLINEAPP, *LPHLINEAPP;
+typedef HANDLE HPHONE, *LPHPHONE;
+typedef HANDLE HPHONEAPP, *LPHPHONEAPP;
+
+/* FIXME: bogus codes !! */
+#define TAPIERR_REQUESTFAILED 20
+
+typedef struct lineaddresscaps_tag {
+ DWORD dwTotalSize;
+ DWORD dwNeededSize;
+ DWORD dwUsedSize;
+ DWORD dwLineDeviceID;
+ DWORD dwAddressSize;
+ DWORD dwAddressOffset;
+ DWORD dwDevSpecificSize;
+ DWORD dwDevSpecificOffset;
+ DWORD dwAddressSharing;
+ DWORD dwAddressStates;
+ DWORD dwCallInfoStates;
+ DWORD dwCallerIDFlags;
+ DWORD dwCalledIDFlags;
+ DWORD dwConnectedIDFlags;
+ DWORD dwRedirectionIDFlags;
+ DWORD dwRedirectingIDFlags;
+ DWORD dwCallStates;
+ DWORD dwDialToneModes;
+ DWORD dwBusyModes;
+ DWORD dwSpecialInfo;
+ DWORD dwDisconnectModes;
+ DWORD dwMaxNumActiveCalls;
+ DWORD dwMaxNumOnHoldCalls;
+ DWORD dwMaxNumOnHoldPendingCalls;
+ DWORD dwMaxNumConference;
+ DWORD dwMaxNumTransConf;
+ DWORD dwAddrCapFlags;
+ DWORD dwCallFeatures;
+ DWORD dwRemoveFromConfCaps;
+ DWORD dwRemoveFromConfState;
+ DWORD dwTransferModes;
+ DWORD dwParkModes;
+ DWORD dwForwardModes;
+ DWORD dwMaxForwardEntries;
+ DWORD dwMaxSpecificEntries;
+ DWORD dwMinFwdNumRings;
+ DWORD dwMaxFwdNumRings;
+ DWORD dwMaxCallCompletions;
+ DWORD dwCallCompletionConds;
+ DWORD dwCallCompletionModes;
+ DWORD dwNumCompletionMessages;
+ DWORD dwCompletionMsgTextEntrySize;
+ DWORD dwCompletionMsgTextSize;
+ DWORD dwCompletionMsgTextOffset;
+ DWORD dwAddressFeatures;
+} LINEADDRESSCAPS, *LPLINEADDRESSCAPS;
+
+typedef struct lineaddressstatus_tag {
+ DWORD dwTotalSize;
+ DWORD dwNeededSize;
+ DWORD dwUsedSize;
+ DWORD dwNumInUse;
+ DWORD dwNumActiveCalls;
+ DWORD dwNumOnHoldCalls;
+ DWORD dwNumOnHoldPendCalls;
+ DWORD dwAddressFeatures;
+ DWORD dwNumRingsNoAnswer;
+ DWORD dwForwardNumEntries;
+ DWORD dwForwardSize;
+ DWORD dwForwardOffset;
+ DWORD dwTerminalModesSize;
+ DWORD dwTerminalModesOffset;
+ DWORD dwDevSpecificSize;
+ DWORD dwDevSpecificOffset;
+} LINEADDRESSSTATUS, *LPLINEADDRESSSTATUS;
+
+typedef struct linedialparams_tag {
+ DWORD dwDialPause;
+ DWORD dwDialSpeed;
+ DWORD dwDigitDuration;
+ DWORD dwWaitForDialtone;
+} LINEDIALPARAMS, *LPLINEDIALPARAMS;
+
+typedef struct linecallinfo_tag {
+ DWORD dwTotalSize;
+ DWORD dwNeededSize;
+ DWORD dwUsedSize;
+ HLINE hLine;
+ DWORD dwLineDeviceID;
+ DWORD dwAddressID;
+ DWORD dwBearerMode;
+ DWORD dwRate;
+ DWORD dwMediaMode;
+ DWORD dwAppSpecific;
+ DWORD dwCallID;
+ DWORD dwRelatedCallID;
+ DWORD dwCallParamFlags;
+ DWORD dwCallStates;
+ DWORD dwMonitorDigitModes;
+ DWORD dwMonitorMediaModes;
+ LINEDIALPARAMS DialParams;
+ DWORD dwOrigin;
+ DWORD dwReason;
+ DWORD dwCompletionID;
+ DWORD dwNumOwners;
+ DWORD dwNumMonitors;
+ DWORD dwCountryCode;
+ DWORD dwTrunk;
+ DWORD dwCallerIDFlags;
+ DWORD dwCallerIDSize;
+ DWORD dwCallerIDOffset;
+ DWORD dwCallerIDNameSize;
+ DWORD dwCallerIDNameOffset;
+ DWORD dwCalledIDFlags;
+ DWORD dwCalledIDSize;
+ DWORD dwCalledIDOffset;
+ DWORD dwCalledIDNameSize;
+ DWORD dwCalledIDNameOffset;
+ DWORD dwConnectedIDFlags;
+ DWORD dwConnectedIDSize;
+ DWORD dwConnectedIDOffset;
+ DWORD dwConnectedIDNameSize;
+ DWORD dwConnectedIDNameOffset;
+ DWORD dwRedirectionIDFlags;
+ DWORD dwRedirectionIDSize;
+ DWORD dwRedirectionIDOffset;
+ DWORD dwRedirectionIDNameSize;
+ DWORD dwRedirectionIDNameOffset;
+ DWORD dwRedirectingIDFlags;
+ DWORD dwRedirectingIDSize;
+ DWORD dwRedirectingIDOffset;
+ DWORD dwRedirectingIDNameSize;
+ DWORD dwRedirectingIDNameOffset;
+ DWORD dwAppNameSize;
+ DWORD dwAppNameOffset;
+ DWORD dwDisplayableAddressSize;
+ DWORD dwDisplayableAddressOffset;
+ DWORD dwCalledPartySize;
+ DWORD dwCalledPartyOffset;
+ DWORD dwCommentSize;
+ DWORD dwCommentOffset;
+ DWORD dwDisplaySize;
+ DWORD dwDisplayOffset;
+ DWORD dwUserUserInfoSize;
+ DWORD dwUserUserInfoOffset;
+ DWORD dwHighLevelCompSize;
+ DWORD dwHighLevelCompOffset;
+ DWORD dwLowLevelCompSize;
+ DWORD dwLowLevelCompOffset;
+ DWORD dwChargingInfoSize;
+ DWORD dwChargingInfoOffset;
+ DWORD dwTerminalModesSize;
+ DWORD dwTerminalModesOffset;
+ DWORD dwDevSpecificSize;
+ DWORD dwDevSpecificOffset;
+} LINECALLINFO, *LPLINECALLINFO;
+
+typedef struct linecalllist_tag {
+ DWORD dwTotalSize;
+ DWORD dwNeededSize;
+ DWORD dwUsedSize;
+ DWORD dwCallsNumEntries;
+ DWORD dwCallsSize;
+ DWORD dwCallsOffset;
+} LINECALLLIST, *LPLINECALLLIST;
+
+typedef struct linecallparams_tag {
+ DWORD dwTotalSize;
+ DWORD dwBearerMode;
+ DWORD dwMinRate;
+ DWORD dwMaxRate;
+ DWORD dwMediaMode;
+ DWORD dwCallParamFlags;
+ DWORD dwAddressMode;
+ DWORD dwAddressID;
+ LINEDIALPARAMS DialParams;
+ DWORD dwOrigAddressSize;
+ DWORD dwOrigAddressOffset;
+ DWORD dwDisplayableAddressSize;
+ DWORD dwDisplayableAddressOffset;
+ DWORD dwCalledPartySize;
+ DWORD dwCalledPartyOffset;
+ DWORD dwCommentSize;
+ DWORD dwCommentOffset;
+ DWORD dwUserUserInfoSize;
+ DWORD dwUserUserInfoOffset;
+ DWORD dwHighLevelCompSize;
+ DWORD dwHighLevelCompOffset;
+ DWORD dwLowLevelCompSize;
+ DWORD dwLowLevelCompOffset;
+ DWORD dwDevSpecificSize;
+ DWORD dwDevSpecificOffset;
+} LINECALLPARAMS, *LPLINECALLPARAMS;
+
+typedef struct linecallstatus_tag {
+ DWORD dwTotalSize;
+ DWORD dwNeededSize;
+ DWORD dwUsedSize;
+ DWORD dwCallState;
+ DWORD dwCallStateMode;
+ DWORD dwCallPrivilege;
+ DWORD dwCallFeatures;
+ DWORD dwDevSpecificSize;
+ DWORD dwDevSpecificOffset;
+} LINECALLSTATUS, *LPLINECALLSTATUS;
+
+typedef struct linecountrylist_tag {
+ DWORD dwTotalSize;
+ DWORD dwNeededSize;
+ DWORD dwUsedSize;
+ DWORD dwNumCountries;
+ DWORD dwCountryListSize;
+ DWORD dwCountryListOffset;
+} LINECOUNTRYLIST, *LPLINECOUNTRYLIST;
+
+typedef struct linedevcaps_tag {
+ DWORD dwTotalSize;
+ DWORD dwNeededSize;
+ DWORD dwUsedSize;
+ DWORD dwProviderInfoSize;
+ DWORD dwProviderInfoOffset;
+ DWORD dwSwitchInfoSize;
+ DWORD dwSwitchInfoOffset;
+ DWORD dwPermanentLineID;
+ DWORD dwLineNameSize;
+ DWORD dwLineNameOffset;
+ DWORD dwStringFormat;
+ DWORD dwAddressModes;
+ DWORD dwNumAddresses;
+ DWORD dwBearerModes;
+ DWORD dwMaxRate;
+ DWORD dwMediaModes;
+ DWORD dwGenerateToneModes;
+ DWORD dwGenerateToneMaxNumFreq;
+ DWORD dwGenerateDigitModes;
+ DWORD dwMonitorToneMaxNumFreq;
+ DWORD dwMonitorToneMaxNumEntries;
+ DWORD dwMonitorDigitModes;
+ DWORD dwGatherDigitsMinTimeout;
+ DWORD dwGatherDigitsMaxTimeout;
+ DWORD dwMedCtlDigitMaxListSize;
+ DWORD dwMedCtlMediaMaxListSize;
+ DWORD dwMedCtlToneMaxListSize;
+ DWORD dwMedCtlCallStateMaxListSize;
+ DWORD dwDevCapFlags;
+ DWORD dwMaxNumActiveCalls;
+ DWORD dwAnswerMode;
+ DWORD dwRingModes;
+ DWORD dwLineStates;
+ DWORD dwUUIAcceptSize;
+ DWORD dwUUIAnswerSize;
+ DWORD dwUUIMakeCallSize;
+ DWORD dwUUIDropSize;
+ DWORD dwUUISendUserUserInfoSize;
+ DWORD dwUUICallInfoSize;
+ LINEDIALPARAMS MinDialParams;
+ LINEDIALPARAMS MaxDialParams;
+ LINEDIALPARAMS DefaultDialParams;
+ DWORD dwNumTerminals;
+ DWORD dwTerminalCapsSize;
+ DWORD dwTerminalCapsOffset;
+ DWORD dwTerminalTextEntrySize;
+ DWORD dwTerminalTextSize;
+ DWORD dwTerminalTextOffset;
+ DWORD dwDevSpecificSize;
+ DWORD dwDevSpecificOffset;
+ DWORD dwLineFeatures;
+} LINEDEVCAPS, *LPLINEDEVCAPS;
+
+typedef struct linedevstatus_tag {
+ DWORD dwTotalSize;
+ DWORD dwNeededSize;
+ DWORD dwUsedSize;
+ DWORD dwNumOpens;
+ DWORD dwOpenMediaModes;
+ DWORD dwNumActiveCalls;
+ DWORD dwNumOnHoldCalls;
+ DWORD dwNumOnHoldPendingCalls;
+ DWORD dwLineFeatures;
+ DWORD dwNumCallCompletion;
+ DWORD dwRingMode;
+ DWORD dwSignalLevel;
+ DWORD dwBatteryLevel;
+ DWORD dwRoamMode;
+ DWORD dwDevStatusFlags;
+ DWORD dwTerminalModesSize;
+ DWORD dwTerminalModesOffset;
+ DWORD dwDevSpecificSize;
+ DWORD dwDevSpecificOffset;
+} LINEDEVSTATUS, *LPLINEDEVSTATUS;
+
+typedef struct lineextensionid_tag {
+ DWORD dwExtensionID0;
+ DWORD dwExtensionID1;
+ DWORD dwExtensionID2;
+ DWORD dwExtensionID3;
+} LINEEXTENSIONID, *LPLINEEXTENSIONID;
+
+typedef struct lineforward_tag {
+ DWORD dwForwardMode;
+ DWORD dwCallerAddressSize;
+ DWORD dwCallerAddressOffset;
+ DWORD dwDestCountryCode;
+ DWORD dwDestAddressSize;
+ DWORD dwDestAddressOffset;
+} LINEFORWARD, *LPLINEFORWARD;
+
+typedef struct lineforwardlist_tag {
+ DWORD dwTotalSize;
+ DWORD dwNumEntries;
+ LINEFORWARD ForwardList[1];
+} LINEFORWARDLIST, *LPLINEFORWARDLIST;
+
+typedef struct linegeneratetone_tag {
+ DWORD dwFrequency;
+ DWORD dwCadenceOn;
+ DWORD dwCadenceOff;
+ DWORD dwVolume;
+} LINEGENERATETONE, *LPLINEGENERATETONE;
+
+typedef struct linemediacontrolcallstate_tag {
+ DWORD dwCallStates;
+ DWORD dwMediaControl;
+} LINEMEDIACONTROLCALLSTATE, *LPLINEMEDIACONTROLCALLSTATE;
+
+typedef struct linemediacontroldigit_tag {
+ DWORD dwDigit;
+ DWORD dwDigitModes;
+ DWORD dwMediaControl;
+} LINEMEDIACONTROLDIGIT, *LPLINEMEDIACONTROLDIGIT;
+
+typedef struct linemediacontrolmedia_tag {
+ DWORD dwMediaModes;
+ DWORD dwDuration;
+ DWORD dwMediaControl;
+} LINEMEDIACONTROLMEDIA, *LPLINEMEDIACONTROLMEDIA;
+
+typedef struct linemediacontroltone_tag {
+ DWORD dwAppSpecific;
+ DWORD dwDuration;
+ DWORD dwFrequency1;
+ DWORD dwFrequency2;
+ DWORD dwFrequency3;
+ DWORD dwMediaControl;
+} LINEMEDIACONTROLTONE, *LPLINEMEDIACONTROLTONE;
+
+typedef struct linemonitortone_tag {
+ DWORD dwAppSpecific;
+ DWORD dwDuration;
+ DWORD dwFrequency1;
+ DWORD dwFrequency2;
+ DWORD dwFrequency3;
+} LINEMONITORTONE, *LPLINEMONITORTONE;
+
+typedef struct lineproviderlist_tag {
+ DWORD dwTotalSize;
+ DWORD dwNeededSize;
+ DWORD dwUsedSize;
+ DWORD dwNumProviders;
+ DWORD dwProviderListSize;
+ DWORD dwProviderListOffset;
+} LINEPROVIDERLIST, *LPLINEPROVIDERLIST;
+
+typedef struct linetranslatecaps_tag {
+ DWORD dwTotalSize;
+ DWORD dwNeededSize;
+ DWORD dwUsedSize;
+ DWORD dwNumLocations;
+ DWORD dwLocationListSize;
+ DWORD dwLocationListOffset;
+ DWORD dwCurrentLocationID;
+ DWORD dwNumCards;
+ DWORD dwCardListSize;
+ DWORD dwCardListOffset;
+ DWORD dwCurrentPreferredCardID;
+} LINETRANSLATECAPS, *LPLINETRANSLATECAPS;
+
+typedef struct linetranslateoutput_tag {
+ DWORD dwTotalSize;
+ DWORD dwNeededSize;
+ DWORD dwUsedSize;
+ DWORD dwDialableStringSize;
+ DWORD dwDialableStringOffset;
+ DWORD dwDisplayableStringSize;
+ DWORD dwDisplayableStringOffset;
+ DWORD dwCurrentCountry;
+ DWORD dwDestCountry;
+ DWORD dwTranslateResults;
+} LINETRANSLATEOUTPUT, *LPLINETRANSLATEOUTPUT;
+
+typedef void (CALLBACK * LINECALLBACK)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD);
+
+typedef struct _PHONEAPP {
+} PHONEAPP, *LPPHONEAPP;
+
+typedef struct _PHONE {
+ DWORD dwRingMode;
+ DWORD dwVolume;
+} PHONE, *LPPHONE;
+
+typedef struct phonebuttoninfo_tag {
+ DWORD dwTotalSize;
+ DWORD dwNeededSize;
+ DWORD dwUsedSize;
+ DWORD dwButtonMode;
+ DWORD dwButtonFunction;
+ DWORD dwButtonTextSize;
+ DWORD dwButtonTextOffset;
+ DWORD dwDevSpecificSize;
+ DWORD dwDevSpecificOffset;
+ DWORD dwButtonState;
+} PHONEBUTTONINFO, *LPPHONEBUTTONINFO;
+
+typedef struct phonecaps_tag {
+ DWORD dwTotalSize;
+ DWORD dwNeededSize;
+ DWORD dwUsedSize;
+ DWORD dwProviderInfoSize;
+ DWORD dwProviderInfoOffset;
+ DWORD dwPhoneInfoSize;
+ DWORD dwPhoneInfoOffset;
+ DWORD dwPermanentPhoneID;
+ DWORD dwPhoneNameSize;
+ DWORD dwPhoneNameOffset;
+ DWORD dwStringFormat;
+ DWORD dwPhoneStates;
+ DWORD dwHookSwitchDevs;
+ DWORD dwHandsetHookSwitchModes;
+ DWORD dwSpeakerHookSwitchModes;
+ DWORD dwHeadsetHookSwitchModes;
+ DWORD dwVolumeFlags;
+ DWORD dwGainFlags;
+ DWORD dwDisplayNumRows;
+ DWORD dwDisplayNumColumns;
+ DWORD dwNumRingModes;
+ DWORD dwNumButtonLamps;
+ DWORD dwButtonModesSize;
+ DWORD dwButtonModesOffset;
+ DWORD dwButtonFunctionsSize;
+ DWORD dwButtonFunctionsOffset;
+ DWORD dwLampModesSize;
+ DWORD dwLampModesOffset;
+ DWORD dwNumSetData;
+ DWORD dwSetDataSize;
+ DWORD dwSetDataOffset;
+ DWORD dwNumGetData;
+ DWORD dwGetDataSize;
+ DWORD dwGetDataOffset;
+ DWORD dwDevSpecificSize;
+ DWORD dwDevSpecificOffset;
+} PHONECAPS, *LPPHONECAPS;
+
+typedef struct phoneextensionid_tag {
+ DWORD dwExtensionID0;
+ DWORD dwExtensionID1;
+ DWORD dwExtensionID2;
+ DWORD dwExtensionID3;
+} PHONEEXTENSIONID, *LPPHONEEXTENSIONID;
+
+typedef struct phonestatus_tag {
+ DWORD dwTotalSize;
+ DWORD dwNeededSize;
+ DWORD dwUsedSize;
+ DWORD dwStatusFlags;
+ DWORD dwNumOwners;
+ DWORD dwRingMOde;
+ DWORD dwRingVolume;
+ DWORD dwHandsetHookSwitchMode;
+ DWORD dwHandsetVolume;
+ DWORD dwHandsetGain;
+ DWORD dwSpeakerHookSwitchMode;
+ DWORD dwSpeakerVolume;
+ DWORD dwSpeakerGain;
+ DWORD dwHeadsetHookSwitchMode;
+ DWORD dwHeadsetVolume;
+ DWORD dwHeadsetGain;
+ DWORD dwDisplaySize;
+ DWORD dwDisplayOffset;
+ DWORD dwLampModesSize;
+ DWORD dwLampModesOffset;
+ DWORD dwOwnerNameSize;
+ DWORD dwOwnerNameOffset;
+ DWORD dwDevSpecificSize;
+ DWORD dwDevSpecificOffset;
+} PHONESTATUS, *LPPHONESTATUS;
+
+typedef void (CALLBACK * PHONECALLBACK)(HANDLE, DWORD, DWORD, DWORD, DWORD, DWORD);
+
+typedef struct varstring_tag {
+ DWORD dwTotalSize;
+ DWORD dwNeededSize;
+ DWORD dwUsedSize;
+ DWORD dwStringFormat;
+ DWORD dwStringSize;
+ DWORD dwStringOffset;
+} VARSTRING, *LPVARSTRING;
+
+/* line functions */
+DWORD WINAPI lineAccept(HCALL,LPCSTR,DWORD);
+DWORD WINAPI lineAddProvider(LPCSTR,HWND,LPDWORD);
+DWORD WINAPI lineAddToConference(HCALL,HCALL);
+DWORD WINAPI lineAnswer(HCALL,LPCSTR,DWORD);
+DWORD WINAPI lineBlindTransfer(HCALL,LPCSTR,DWORD);
+DWORD WINAPI lineClose(HLINE);
+DWORD WINAPI lineCompleteCall(HCALL,LPDWORD,DWORD,DWORD);
+DWORD WINAPI lineCompleteTransfer(HCALL,HCALL,LPHCALL,DWORD);
+DWORD WINAPI lineConfigDialog(DWORD,HWND,LPCSTR);
+DWORD WINAPI lineConfigDialogEdit(DWORD,HWND,LPCSTR,LPVOID const,DWORD,LPVARSTRING);
+DWORD WINAPI lineConfigProvider(HWND,DWORD);
+DWORD WINAPI lineDeallocateCall(HCALL);
+DWORD WINAPI lineDevSpecific(HLINE,DWORD,HCALL,LPVOID,DWORD);
+DWORD WINAPI lineDevSpecificFeature(HLINE,DWORD,LPVOID,DWORD);
+DWORD WINAPI lineDial(HCALL,LPCSTR,DWORD);
+DWORD WINAPI lineDrop(HCALL,LPCSTR,DWORD);
+DWORD WINAPI lineForward(HLINE,DWORD,DWORD,LPLINEFORWARDLIST,DWORD,LPHCALL,LPLINECALLPARAMS);
+DWORD WINAPI lineGatherDigits(HCALL,DWORD,LPSTR,DWORD,LPCSTR,DWORD,DWORD);
+DWORD WINAPI lineGenerateDigits(HCALL,DWORD,LPCSTR,DWORD);
+DWORD WINAPI lineGenerateTone(HCALL,DWORD,DWORD,DWORD,LPLINEGENERATETONE);
+DWORD WINAPI lineGetAddressCaps(HLINEAPP,DWORD,DWORD,DWORD,DWORD,LPLINEADDRESSCAPS);
+DWORD WINAPI lineGetAddressID(HLINE,LPDWORD,DWORD,LPCSTR,DWORD);
+DWORD WINAPI lineGetAddressStatus(HLINE,DWORD,LPLINEADDRESSSTATUS);
+DWORD WINAPI lineGetAppPriority(LPCSTR,DWORD,LPLINEEXTENSIONID const,DWORD,LPVARSTRING,LPDWORD);
+DWORD WINAPI lineGetCallInfo(HCALL,LPLINECALLINFO);
+DWORD WINAPI lineGetCallStatus(HCALL,LPLINECALLSTATUS);
+DWORD WINAPI lineGetConfRelatedCalls(HCALL,LPLINECALLLIST);
+DWORD WINAPI lineGetCountry(DWORD,DWORD,LPLINECOUNTRYLIST);
+DWORD WINAPI lineGetDevCaps(HLINEAPP,DWORD,DWORD,DWORD,LPLINEDEVCAPS);
+DWORD WINAPI lineGetDevConfig(DWORD,LPVARSTRING,LPCSTR);
+DWORD WINAPI lineGetID(HLINE,DWORD,HCALL,DWORD,LPVARSTRING,LPCSTR);
+DWORD WINAPI lineGetIcon(DWORD,LPCSTR,HICON *);
+DWORD WINAPI lineGetLineDevStatus(HLINE,LPLINEDEVSTATUS);
+DWORD WINAPI lineGetNewCalls(HLINE,DWORD,DWORD,LPLINECALLLIST);
+DWORD WINAPI lineGetNumRings(HLINE,DWORD,LPDWORD);
+DWORD WINAPI lineGetProviderList(DWORD dwAPIVersion,LPLINEPROVIDERLIST);
+DWORD WINAPI lineGetRequest(HLINEAPP,DWORD,LPVOID);
+DWORD WINAPI lineGetStatusMessages(HLINE,LPDWORD,LPDWORD);
+DWORD WINAPI lineGetTranslateCaps(HLINEAPP,DWORD,LPLINETRANSLATECAPS);
+DWORD WINAPI lineHandoff(HCALL,LPCSTR,DWORD);
+DWORD WINAPI lineHold(HCALL);
+DWORD WINAPI lineInitialize(LPHLINEAPP,HINSTANCE,LINECALLBACK,LPCSTR,LPDWORD);
+DWORD WINAPI lineMakeCall(HLINE,LPHCALL,LPCSTR,DWORD,LPLINECALLPARAMS);
+DWORD WINAPI lineMonitorDigits(HCALL,DWORD);
+DWORD WINAPI lineMonitorMedia(HCALL,DWORD);
+DWORD WINAPI lineMonitorTones(HCALL,LPLINEMONITORTONE,DWORD);
+DWORD WINAPI lineNegotiateAPIVersion(HLINEAPP,DWORD,DWORD,DWORD,LPDWORD,LPLINEEXTENSIONID);
+DWORD WINAPI lineNegotiateExtVersion(HLINEAPP,DWORD,DWORD,DWORD,DWORD,LPDWORD);
+DWORD WINAPI lineOpen(HLINEAPP,DWORD,LPHLINE,DWORD,DWORD,DWORD,DWORD,DWORD,LPLINECALLPARAMS);
+DWORD WINAPI linePark(HCALL,DWORD,LPCSTR,LPVARSTRING);
+DWORD WINAPI linePickup(HLINE,DWORD,LPHCALL,LPCSTR,LPCSTR);
+DWORD WINAPI linePrepareAddToConference(HCALL,LPHCALL,LPLINECALLPARAMS);
+DWORD WINAPI lineRedirect(HCALL,LPCSTR,DWORD);
+DWORD WINAPI lineRegisterRequestRecipient(HLINEAPP,DWORD,DWORD,DWORD);
+DWORD WINAPI lineReleaseUserUserInfo(HCALL);
+DWORD WINAPI lineRemoveFromConference(HCALL);
+DWORD WINAPI lineRemoveProvider(DWORD,HWND);
+DWORD WINAPI lineSecureCall(HCALL);
+DWORD WINAPI lineSendUserUserInfo(HCALL,LPCSTR,DWORD);
+DWORD WINAPI lineSetAppPriority(LPCSTR,DWORD,LPLINEEXTENSIONID const,DWORD,LPCSTR,DWORD);
+DWORD WINAPI lineSetAppSpecific(HCALL,DWORD);
+DWORD WINAPI lineSetCallParams(HCALL,DWORD,DWORD,DWORD,LPLINEDIALPARAMS);
+DWORD WINAPI lineSetCallPrivilege(HCALL,DWORD);
+DWORD WINAPI lineSetCurrentLocation(HLINEAPP,DWORD);
+DWORD WINAPI lineSetDevConfig(DWORD,LPVOID,DWORD,LPCSTR);
+DWORD WINAPI lineSetMediaControl(HLINE,DWORD,HCALL,DWORD,LPLINEMEDIACONTROLDIGIT,DWORD,LPLINEMEDIACONTROLMEDIA,DWORD,LPLINEMEDIACONTROLTONE,DWORD,LPLINEMEDIACONTROLCALLSTATE,DWORD);
+DWORD WINAPI lineSetMediaMode(HCALL,DWORD);
+DWORD WINAPI lineSetNumRings(HLINE,DWORD,DWORD);
+DWORD WINAPI lineSetStatusMessages(HLINE,DWORD,DWORD);
+DWORD WINAPI lineSetTerminal(HLINE,DWORD,HCALL,DWORD,DWORD,DWORD,DWORD);
+DWORD WINAPI lineSetTollList(HLINEAPP,DWORD,LPCSTR,DWORD);
+DWORD WINAPI lineSetupConference(HCALL,HLINE,LPHCALL,LPHCALL,DWORD,LPLINECALLPARAMS);
+DWORD WINAPI lineSetupTransfer(HCALL,LPHCALL,LPLINECALLPARAMS);
+DWORD WINAPI lineShutdown(HLINEAPP);
+DWORD WINAPI lineSwapHold(HCALL,HCALL);
+DWORD WINAPI lineTranslateAddress(HLINEAPP,DWORD,DWORD,LPCSTR,DWORD,DWORD,LPLINETRANSLATEOUTPUT);
+DWORD WINAPI lineTranslateDialog(HLINEAPP,DWORD,DWORD,HWND,LPCSTR);
+DWORD WINAPI lineUncompleteCall(HLINE,DWORD);
+DWORD WINAPI lineUnHold(HCALL);
+DWORD WINAPI lineUnpark(HLINE,DWORD,LPHCALL,LPCSTR);
+
+/* phone functions */
+DWORD WINAPI phoneClose(HPHONE);
+DWORD WINAPI phoneConfigDialog(DWORD,HWND,LPCSTR);
+DWORD WINAPI phoneDevSpecific(HPHONE,LPVOID,DWORD);
+DWORD WINAPI phoneGetButtonInfo(HPHONE,DWORD,LPPHONEBUTTONINFO);
+DWORD WINAPI phoneGetData(HPHONE,DWORD,LPVOID,DWORD);
+DWORD WINAPI phoneGetDevCaps(HPHONEAPP,DWORD,DWORD,DWORD,LPPHONECAPS);
+DWORD WINAPI phoneGetDisplay(HPHONE,LPVARSTRING);
+DWORD WINAPI phoneGetHookSwitch(HPHONE,LPDWORD);
+DWORD WINAPI phoneGetID(HPHONE,LPVARSTRING,LPCSTR);
+DWORD WINAPI phoneGetIcon(DWORD,LPCSTR,HICON *);
+DWORD WINAPI phoneGetLamp(HPHONE,DWORD,LPDWORD);
+DWORD WINAPI phoneGetRing(HPHONE,LPDWORD,LPDWORD);
+DWORD WINAPI phoneGetStatus(HPHONE,LPPHONESTATUS);
+DWORD WINAPI phoneGetStatusMessages(HPHONE,LPDWORD,LPDWORD,LPDWORD);
+DWORD WINAPI phoneGetVolume(HPHONE,DWORD,LPDWORD);
+DWORD WINAPI phoneInitialize(LPHPHONEAPP,HINSTANCE,PHONECALLBACK,LPCSTR,LPDWORD);
+DWORD WINAPI phoneNegotiateAPIVersion(HPHONEAPP,DWORD,DWORD,DWORD,LPDWORD,LPPHONEEXTENSIONID);
+DWORD WINAPI phoneNegotiateExtVersion(HPHONEAPP,DWORD,DWORD,DWORD,DWORD,LPDWORD);
+DWORD WINAPI phoneOpen(HPHONEAPP,DWORD,LPHPHONE,DWORD,DWORD,DWORD,DWORD);
+DWORD WINAPI phoneSetButtonInfo(HPHONE,DWORD,LPPHONEBUTTONINFO);
+DWORD WINAPI phoneSetData(HPHONE,DWORD,LPVOID,DWORD);
+DWORD WINAPI phoneSetDisplay(HPHONE,DWORD,DWORD,LPCSTR,DWORD);
+DWORD WINAPI phoneSetGain(HPHONE,DWORD,DWORD);
+DWORD WINAPI phoneSetHookSwitch(HPHONE,DWORD,DWORD);
+DWORD WINAPI phoneSetLamp(HPHONE,DWORD,DWORD);
+DWORD WINAPI phoneSetRing(HPHONE,DWORD,DWORD);
+DWORD WINAPI phoneSetStatusMessages(HPHONE,DWORD,DWORD,DWORD);
+DWORD WINAPI phoneSetVolume(HPHONE,DWORD,DWORD);
+DWORD WINAPI phoneShutdown(HPHONEAPP);
+
+/* "assisted" functions */
+DWORD WINAPI tapiGetLocationInfo(LPSTR,LPSTR);
+DWORD WINAPI tapiRequestMakeCall(LPCSTR,LPCSTR,LPCSTR,LPCSTR);
+
+#endif /* __WINE_TAPI_H */
diff --git a/misc/Makefile.in b/misc/Makefile.in
index 2c4c232..b99b404 100644
--- a/misc/Makefile.in
+++ b/misc/Makefile.in
@@ -29,7 +29,6 @@
stress.c \
string.c \
system.c \
- tapi32.c \
toolhelp.c \
tweak.c \
version.c \
diff --git a/misc/tapi32.c b/misc/tapi32.c
deleted file mode 100644
index 331518d..0000000
--- a/misc/tapi32.c
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * TAPI32
- *
- * Copyright (c) 1998 Andreas Mohr
- */
-
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include "wintypes.h"
-#include "debug.h"
-
-UINT WINAPI lineInitialize(
- LPVOID lphLineApp, /* FIXME */
- HINSTANCE hInstance,
- LPVOID lpfnCallback, /* FIXME */
- LPCSTR lpszAppName,
- LPDWORD lpdwNumDevs)
-{
- FIXME(comm, "stub.\n");
- return 0;
-}
-
-UINT WINAPI lineShutdown( HANDLE hLineApp ) /* FIXME */
-{
- FIXME(comm, "stub.\n");
- return 0;
-}
-
-UINT WINAPI lineNegotiateAPIVersion(
- HANDLE hLineApp, /* FIXME */
- DWORD dwDeviceID,
- DWORD dwAPILowVersion,
- DWORD dwAPIHighVersion,
- LPDWORD lpdwAPIVersion,
- LPVOID lpExtensionID /* FIXME */
-)
-{
- FIXME(comm, "stub.\n");
- *lpdwAPIVersion = dwAPIHighVersion;
- return 0;
-}
-
-/*************************************************************************
- * lineRedirect32 [TAPI32.53]
- *
- */
-LONG WINAPI lineRedirect(
- HANDLE* hCall,
- LPCSTR lpszDestAddress,
- DWORD dwCountryCode) {
-
- FIXME(comm, ": stub.\n");
- return -1;
-/* return LINEERR_OPERATIONFAILED; */
-}
-
-/*************************************************************************
- * tapiRequestMakeCall32 [TAPI32.113]
- *
- */
-LONG WINAPI tapiRequestMakeCall(
- LPCSTR lpszDestAddress,
- LPCSTR lpszAppName,
- LPCSTR lpszCalledParty,
- LPCSTR lpszComment) {
-
- FIXME(comm, ": stub.\n");
- return -1;
-/* return TAPIERR_REQUESTQUEUEFULL; */
-}
-
-
-
-
-
diff --git a/relay32/tapi32.spec b/relay32/tapi32.spec
index 7664a25..e418c59 100644
--- a/relay32/tapi32.spec
+++ b/relay32/tapi32.spec
@@ -1,117 +1,127 @@
name tapi32
type win32
- 1 stub lineAccept
- 2 stub lineAddProvider
- 3 stub lineAddToConference
- 4 stub lineAnswer
- 5 stub lineBlindTransfer
- 6 stub lineClose
- 7 stub lineCompleteCall
- 8 stub lineCompleteTransfer
- 9 stub lineConfigDialog
- 10 stub lineConfigDialogEdit
- 11 stub lineConfigProvider
- 12 stub lineDeallocateCall
- 13 stub lineDevSpecific
- 14 stub lineDevSpecificFeature
- 15 stub lineDial
- 16 stub lineDrop
- 17 stub lineForward
- 18 stub lineGatherDigits
- 19 stub lineGenerateDigits
- 20 stub lineGenerateTone
- 21 stub lineGetAddressCaps
- 22 stub lineGetAddressID
- 23 stub lineGetAddressStatus
- 24 stub lineGetAppPriority
- 25 stub lineGetCallInfo
- 26 stub lineGetCallStatus
- 27 stub lineGetConfRelatedCalls
- 28 stub lineGetCountry
- 29 stub lineGetDevCaps
- 30 stub lineGetDevConfig
- 31 stub lineGetID
- 32 stub lineGetIcon
- 33 stub lineGetLineDevStatus
- 34 stub lineGetNewCalls
- 35 stub lineGetNumRings
- 36 stub lineGetProviderList
- 37 stub lineGetRequest
- 38 stub lineGetStatusMessages
- 39 stub lineGetTranslateCaps
- 40 stub lineHandoff
- 41 stub lineHold
+ 1 stdcall lineAccept(long str long) lineAccept
+ 2 stdcall lineAddProvider(str long ptr) lineAddProvider
+ 3 stdcall lineAddToConference(long long) lineAddToConference
+ 4 stdcall lineAnswer(long str long) lineAnswer
+ 5 stdcall lineBlindTransfer(long str long) lineBlindTransfer
+ 6 stdcall lineClose(long) lineClose
+ 7 stdcall lineCompleteCall(long ptr long long) lineCompleteCall
+ 8 stdcall lineCompleteTransfer(long long ptr long) lineCompleteTransfer
+ 9 stdcall lineConfigDialog(long long str) lineConfigDialog
+ 10 stdcall lineConfigDialogEdit(long long str ptr long ptr)
+ lineConfigDialogEdit
+ 11 stdcall lineConfigProvider(long long) lineConfigProvider
+ 12 stdcall lineDeallocateCall(long) lineDeallocateCall
+ 13 stdcall lineDevSpecific(long long long ptr long) lineDevSpecific
+ 14 stdcall lineDevSpecificFeature(long long ptr long) lineDevSpecificFeature
+ 15 stdcall lineDial(long str long) lineDial
+ 16 stdcall lineDrop(long str long) lineDrop
+ 17 stdcall lineForward(long long long ptr long ptr ptr) lineForward
+ 18 stdcall lineGatherDigits(long long str long str long long)
+ lineGatherDigits
+ 19 stdcall lineGenerateDigits(long long str long) lineGenerateDigits
+ 20 stdcall lineGenerateTone(long long long long ptr) lineGenerateTone
+ 21 stdcall lineGetAddressCaps(long long long long long ptr)
+ lineGetAddressCaps
+ 22 stdcall lineGetAddressID(long ptr long str long) lineGetAddressID
+ 23 stdcall lineGetAddressStatus(long long ptr) lineGetAddressStatus
+ 24 stdcall lineGetAppPriority(str long ptr long ptr ptr) lineGetAppPriority
+ 25 stdcall lineGetCallInfo(long ptr) lineGetCallInfo
+ 26 stdcall lineGetCallStatus(long ptr) lineGetCallStatus
+ 27 stdcall lineGetConfRelatedCalls(long ptr) lineGetConfRelatedCalls
+ 28 stdcall lineGetCountry(long long ptr) lineGetCountry
+ 29 stdcall lineGetDevCaps(long long long long ptr) lineGetDevCaps
+ 30 stdcall lineGetDevConfig(long ptr str) lineGetDevConfig
+ 31 stdcall lineGetID(long long long long ptr str) lineGetID
+ 32 stdcall lineGetIcon(long str ptr) lineGetIcon
+ 33 stdcall lineGetLineDevStatus(long ptr) lineGetLineDevStatus
+ 34 stdcall lineGetNewCalls(long long long ptr) lineGetNewCalls
+ 35 stdcall lineGetNumRings(long long ptr) lineGetNumRings
+ 36 stdcall lineGetProviderList(long ptr) lineGetProviderList
+ 37 stdcall lineGetRequest(long long ptr) lineGetRequest
+ 38 stdcall lineGetStatusMessages(long ptr ptr) lineGetStatusMessages
+ 39 stdcall lineGetTranslateCaps(long long ptr) lineGetTranslateCaps
+ 40 stdcall lineHandoff(long str long) lineHandoff
+ 41 stdcall lineHold(long) lineHold
42 stdcall lineInitialize(ptr long ptr str ptr) lineInitialize
- 43 stub lineMakeCall
- 44 stub lineMonitorDigits
- 45 stub lineMonitorMedia
- 46 stub lineMonitorTones
+ 43 stdcall lineMakeCall(long ptr str long ptr) lineMakeCall
+ 44 stdcall lineMonitorDigits(long long) lineMonitorDigits
+ 45 stdcall lineMonitorMedia(long long) lineMonitorMedia
+ 46 stdcall lineMonitorTones(long ptr long) lineMonitorTones
47 stdcall lineNegotiateAPIVersion(long long long long ptr ptr) lineNegotiateAPIVersion
- 48 stub lineNegotiateExtVersion
- 49 stub lineOpen
- 50 stub linePark
- 51 stub linePickup
- 52 stub linePrepareAddToConference
- 53 stdcall lineRedirect(long ptr long) lineRedirect
- 54 stub lineRegisterRequestRecipient
- 55 stub lineReleaseUserUserInfo
- 56 stub lineRemoveFromConference
- 57 stub lineRemoveProvider
- 58 stub lineSecureCall
- 59 stub lineSendUserUserInfo
- 60 stub lineSetAppPriority
- 61 stub lineSetAppSpecific
- 62 stub lineSetCallParams
- 63 stub lineSetCallPrivilege
- 64 stub lineSetCurrentLocation
- 65 stub lineSetDevConfig
- 66 stub lineSetMediaControl
- 67 stub lineSetMediaMode
- 68 stub lineSetNumRings
- 69 stub lineSetStatusMessages
- 70 stub lineSetTerminal
- 71 stub lineSetTollList
- 72 stub lineSetupConference
- 73 stub lineSetupTransfer
+ 48 stdcall lineNegotiateExtVersion(long long long long long ptr)
+ lineNegotiateExtVersion
+ 49 stdcall lineOpen(long long ptr long long long long long ptr) lineOpen
+ 50 stdcall linePark(long long str ptr) linePark
+ 51 stdcall linePickup(long long ptr str str) linePickup
+ 52 stdcall linePrepareAddToConference(long ptr ptr) linePrepareAddToConference
+ 53 stdcall lineRedirect(long str long) lineRedirect
+ 54 stdcall lineRegisterRequestRecipient(long long long long)
+ lineRegisterRequestRecipient
+ 55 stdcall lineReleaseUserUserInfo(long) lineReleaseUserUserInfo
+ 56 stdcall lineRemoveFromConference(long) lineRemoveFromConference
+ 57 stdcall lineRemoveProvider(long long) lineRemoveProvider
+ 58 stdcall lineSecureCall(long) lineSecureCall
+ 59 stdcall lineSendUserUserInfo(long str long) lineSendUserUserInfo
+ 60 stdcall lineSetAppPriority(str long ptr long str long) lineSetAppPriority
+ 61 stdcall lineSetAppSpecific(long long) lineSetAppSpecific
+ 62 stdcall lineSetCallParams(long long long long ptr) lineSetCallParams
+ 63 stdcall lineSetCallPrivilege(long long) lineSetCallPrivilege
+ 64 stdcall lineSetCurrentLocation(long long) lineSetCurrentLocation
+ 65 stdcall lineSetDevConfig(long ptr long str) lineSetDevConfig
+ 66 stdcall lineSetMediaControl(long long long long ptr) lineSetMediaControl
+ 67 stdcall lineSetMediaMode(long long) lineSetMediaMode
+ 68 stdcall lineSetNumRings(long long long) lineSetNumRings
+ 69 stdcall lineSetStatusMessages(long long long) lineSetStatusMessages
+ 70 stdcall lineSetTerminal(long long long long long long long)
+ lineSetTerminal
+ 71 stdcall lineSetTollList(long long str long) lineSetTollList
+ 72 stdcall lineSetupConference(long long ptr ptr long ptr)
+ lineSetupConference
+ 73 stdcall lineSetupTransfer(long ptr ptr) lineSetupTransfer
74 stdcall lineShutdown(long) lineShutdown
- 75 stub lineSwapHold
- 76 stub lineTranslateAddress
- 77 stub lineTranslateDialog
- 78 stub lineUncompleteCall
- 79 stub lineUnhold
- 80 stub lineUnpark
- 81 stub phoneClose
- 82 stub phoneConfigDialog
- 83 stub phoneDevSpecific
- 84 stub phoneGetButtonInfo
- 85 stub phoneGetData
- 86 stub phoneGetDevCaps
- 87 stub phoneGetDisplay
- 88 stub phoneGetGain
- 89 stub phoneGetHookSwitch
- 90 stub phoneGetID
- 91 stub phoneGetIcon
- 92 stub phoneGetLamp
- 93 stub phoneGetRing
- 94 stub phoneGetStatus
- 95 stub phoneGetStatusMessages
- 96 stub phoneGetVolume
- 97 stub phoneInitialize
- 98 stub phoneNegotiateAPIVersion
- 99 stub phoneNegotiateExtVersion
-100 stub phoneOpen
-101 stub phoneSetButtonInfo
-102 stub phoneSetData
-103 stub phoneSetDisplay
-104 stub phoneSetGain
-105 stub phoneSetHookSwitch
-106 stub phoneSetLamp
-107 stub phoneSetRing
-108 stub phoneSetStatusMessages
-109 stub phoneSetVolume
-110 stub phoneShutdown
-111 stub tapiGetLocationInfo
+ 75 stdcall lineSwapHold(long long) lineSwapHold
+ 76 stdcall lineTranslateAddress(long long long str long long ptr)
+ lineTranslateAddress
+ 77 stdcall lineTranslateDialog(long long long long str) lineTranslateDialog
+ 78 stdcall lineUncompleteCall(long long) lineUncompleteCall
+ 79 stdcall lineUnHold(long) lineUnHold
+ 80 stdcall lineUnpark(long long ptr str) lineUnpark
+ 81 stdcall phoneClose(long) phoneClose
+ 82 stdcall phoneConfigDialog(long long str) phoneConfigDialog
+ 83 stdcall phoneDevSpecific(long ptr long) phoneDevSpecific
+ 84 stdcall phoneGetButtonInfo(long long ptr) phoneGetButtonInfo
+ 85 stdcall phoneGetData(long long ptr long) phoneGetData
+ 86 stdcall phoneGetDevCaps(long long long long ptr) phoneGetDevCaps
+ 87 stdcall phoneGetDisplay(long ptr) phoneGetDisplay
+ 88 stdcall phoneGetGain(long long ptr) phoneGetGain
+ 89 stdcall phoneGetHookSwitch(long ptr) phoneGetHookSwitch
+ 90 stdcall phoneGetID(long ptr str) phoneGetID
+ 91 stdcall phoneGetIcon(long str ptr) phoneGetIcon
+ 92 stdcall phoneGetLamp(long long ptr) phoneGetLamp
+ 93 stdcall phoneGetRing(long ptr ptr) phoneGetRing
+ 94 stdcall phoneGetStatus(long ptr) phoneGetStatus
+ 95 stdcall phoneGetStatusMessages(long ptr ptr ptr) phoneGetStatusMessages
+ 96 stdcall phoneGetVolume(long long ptr) phoneGetVolume
+ 97 stdcall phoneInitialize(ptr long ptr str ptr) phoneInitialize
+ 98 stdcall phoneNegotiateAPIVersion(long long long long long ptr ptr)
+ phoneNegotiateAPIVersion
+ 99 stdcall phoneNegotiateExtVersion(long long long long long ptr)
+ phoneNegotiateExtVersion
+100 stdcall phoneOpen(long long ptr long long long long) phoneOpen
+101 stdcall phoneSetButtonInfo(long long ptr) phoneSetButtonInfo
+102 stdcall phoneSetData(long long ptr long) phoneSetData
+103 stdcall phoneSetDisplay(long long long str long) phoneSetDisplay
+104 stdcall phoneSetGain(long long long) phoneSetGain
+105 stdcall phoneSetHookSwitch(long long long) phoneSetHookSwitch
+106 stdcall phoneSetLamp(long long long) phoneSetLamp
+107 stdcall phoneSetRing(long long long) phoneSetRing
+108 stdcall phoneSetStatusMessages(long long long long) phoneSetStatusMessages
+109 stdcall phoneSetVolume(long long long) phoneSetVolume
+110 stdcall phoneShutdown(long) phoneShutdown
+111 stdcall tapiGetLocationInfo(str str) tapiGetLocationInfo
112 stub tapiRequestDrop
113 stdcall tapiRequestMakeCall(str str str str) tapiRequestMakeCall
114 stub tapiRequestMediaCall
