diff --git a/Makefile.in b/Makefile.in index 2ea45622449..351a0c3fd64 100644 --- a/Makefile.in +++ b/Makefile.in @@ -39,6 +39,7 @@ LIBSUBDIRS = \ dlls/psapi \ dlls/rasapi32 \ dlls/shell32 \ + dlls/tapi32 \ dlls/ver \ dlls/version \ dlls/winaspi \ @@ -112,6 +113,7 @@ LIBOBJS = \ 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 d21293d8c47..a83b473ed5f 100755 --- a/configure +++ b/configure @@ -4607,6 +4607,7 @@ dlls/ntdll/Makefile 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/ntdll/Makefile 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 242d48335ef..e2fa92353b9 100644 --- a/configure.in +++ b/configure.in @@ -632,6 +632,7 @@ dlls/ntdll/Makefile 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 dff63430d85..76cc186647d 100644 --- a/dlls/Makefile.in +++ b/dlls/Makefile.in @@ -9,6 +9,7 @@ SUBDIRS = \ ntdll \ psapi \ shell32 \ + tapi32 \ ver \ version \ winaspi \ diff --git a/dlls/tapi32/.cvsignore b/dlls/tapi32/.cvsignore new file mode 100644 index 00000000000..f3c7a7c5da6 --- /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 00000000000..5c2c793112a --- /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 00000000000..429e4a332e2 --- /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 00000000000..8219052844a --- /dev/null +++ b/dlls/tapi32/line.c @@ -0,0 +1,526 @@ +/* + * TAPI32 line services + * + * Copyright 1999 Andreas Mohr + */ + +#include +#include +#include +#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 00000000000..0a92cbf7ace --- /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 f129e3e5dbd..8dc89080be2 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 9f9ad398e26..2e5b986748c 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 @@ short debug_msg_enabled[][DEBUG_CLASS_COUNT] = { {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 @@ const char* debug_ch_name[] = { "syscolor", "system", "tab", +"tapi", "task", "text", "thread", diff --git a/include/tapi.h b/include/tapi.h new file mode 100644 index 00000000000..a40494177a8 --- /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 2c4c23206f2..b99b404f11f 100644 --- a/misc/Makefile.in +++ b/misc/Makefile.in @@ -29,7 +29,6 @@ C_SRCS = \ 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 331518d0329..00000000000 --- a/misc/tapi32.c +++ /dev/null @@ -1,76 +0,0 @@ -/* - * TAPI32 - * - * Copyright (c) 1998 Andreas Mohr - */ - -#include -#include -#include -#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 7664a25a2c4..e418c592297 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