* TAPI32 line services
*
* Copyright 1999 Andreas Mohr
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <string.h>
#include <stdlib.h>
+#include <stdarg.h>
#include <stdio.h>
-#include "winbase.h"
#include "windef.h"
+#include "winbase.h"
+#include "wingdi.h"
+#include "winreg.h"
+#include "winnls.h"
+#include "winerror.h"
+#include "objbase.h"
#include "tapi.h"
-#include "debug.h"
+#include "wine/debug.h"
-DECLARE_DEBUG_CHANNEL(comm)
-DECLARE_DEBUG_CHANNEL(tapi)
+WINE_DEFAULT_DEBUG_CHANNEL(tapi);
+/* registry keys */
+static const char szCountrylistKey[] =
+ "Software\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Country List";
+static const char szLocationsKey[] =
+ "Software\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Locations";
+static const char szCardsKey[] =
+ "Software\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Cards";
+
+
+/***********************************************************************
+ * lineAccept (TAPI32.@)
+ */
DWORD WINAPI lineAccept(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
{
- FIXME(tapi, "(%04x, %s, %ld): stub.\n", hCall, lpsUserUserInfo, dwSize);
+ FIXME("(%p, %s, %d): stub.\n", hCall, lpsUserUserInfo, dwSize);
return 1;
}
-DWORD WINAPI lineAddProvider(LPCSTR lpszProviderName, HWND hwndOwner, LPDWORD lpdwPermanentProviderID)
+/***********************************************************************
+ * lineAddProvider (TAPI32.@)
+ */
+DWORD WINAPI lineAddProviderA(LPCSTR lpszProviderName, HWND hwndOwner, LPDWORD lpdwPermanentProviderID)
{
- FIXME(tapi, "(%s, %04x, %p): stub.\n", lpszProviderName, hwndOwner, lpdwPermanentProviderID);
+ FIXME("(%s, %p, %p): stub.\n", lpszProviderName, hwndOwner, lpdwPermanentProviderID);
return 1;
-}
+}
+/***********************************************************************
+ * lineAddToConference (TAPI32.@)
+ */
DWORD WINAPI lineAddToConference(HCALL hConfCall, HCALL hConsultCall)
{
- FIXME(tapi, "(%04x, %04x): stub.\n", hConfCall, hConsultCall);
+ FIXME("(%p, %p): stub.\n", hConfCall, hConsultCall);
return 1;
}
+/***********************************************************************
+ * lineAnswer (TAPI32.@)
+ */
DWORD WINAPI lineAnswer(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
{
- FIXME(tapi, "(%04x, %s, %ld): stub.\n", hCall, lpsUserUserInfo, dwSize);
+ FIXME("(%p, %s, %d): stub.\n", hCall, lpsUserUserInfo, dwSize);
return 1;
-}
+}
-DWORD WINAPI lineBlindTransfer(HCALL hCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
+/***********************************************************************
+ * lineBlindTransfer (TAPI32.@)
+ */
+DWORD WINAPI lineBlindTransferA(HCALL hCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
{
- FIXME(tapi, "(%04x, %s, %08lx): stub.\n", hCall, lpszDestAddress, dwCountryCode);
+ FIXME("(%p, %s, %08x): stub.\n", hCall, lpszDestAddress, dwCountryCode);
return 1;
-}
+}
+/***********************************************************************
+ * lineClose (TAPI32.@)
+ */
DWORD WINAPI lineClose(HLINE hLine)
{
- FIXME(tapi, "(%04x): stub.\n", hLine);
+ FIXME("(%p): stub.\n", hLine);
return 0;
-}
+}
+/***********************************************************************
+ * lineCompleteCall (TAPI32.@)
+ */
DWORD WINAPI lineCompleteCall(HCALL hCall, LPDWORD lpdwCompletionID, DWORD dwCompletionMode, DWORD dwMessageID)
{
- FIXME(tapi, "(%04x, %p, %08lx, %08lx): stub.\n", hCall, lpdwCompletionID, dwCompletionMode, dwMessageID);
+ FIXME("(%p, %p, %08x, %08x): stub.\n", hCall, lpdwCompletionID, dwCompletionMode, dwMessageID);
return 1;
-}
+}
+/***********************************************************************
+ * lineCompleteTransfer (TAPI32.@)
+ */
DWORD WINAPI lineCompleteTransfer(HCALL hCall, HCALL hConsultCall, LPHCALL lphConfCall, DWORD dwTransferMode)
{
- FIXME(tapi, "(%04x, %04x, %p, %08lx): stub.\n", hCall, hConsultCall, lphConfCall, dwTransferMode);
+ FIXME("(%p, %p, %p, %08x): stub.\n", hCall, hConsultCall, lphConfCall, dwTransferMode);
return 1;
}
-DWORD WINAPI lineConfigDialog(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass)
+/***********************************************************************
+ * lineConfigDialog (TAPI32.@)
+ */
+DWORD WINAPI lineConfigDialogA(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass)
{
- FIXME(tapi, "(%08lx, %04x, %s): stub.\n", dwDeviceID, hwndOwner, lpszDeviceClass);
+ FIXME("(%08x, %p, %s): stub.\n", dwDeviceID, hwndOwner, lpszDeviceClass);
return 0;
-}
+}
-DWORD WINAPI lineConfigDialogEdit(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass, LPVOID const lpDeviceConfigIn, DWORD dwSize, LPVARSTRING lpDeviceConfigOut)
+/***********************************************************************
+ * lineConfigDialogEdit (TAPI32.@)
+ */
+DWORD WINAPI lineConfigDialogEditA(DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass, LPVOID const lpDeviceConfigIn, DWORD dwSize, LPVARSTRING lpDeviceConfigOut)
{
- FIXME(tapi, "stub.\n");
+ FIXME("stub.\n");
return 0;
-}
+}
+/***********************************************************************
+ * lineConfigProvider (TAPI32.@)
+ */
DWORD WINAPI lineConfigProvider(HWND hwndOwner, DWORD dwPermanentProviderID)
{
- FIXME(tapi, "(%04x, %08lx): stub.\n", hwndOwner, dwPermanentProviderID);
+ FIXME("(%p, %08x): stub.\n", hwndOwner, dwPermanentProviderID);
return 0;
}
+/***********************************************************************
+ * lineDeallocateCall (TAPI32.@)
+ */
DWORD WINAPI lineDeallocateCall(HCALL hCall)
{
- FIXME(tapi, "(%04x): stub.\n", hCall);
+ FIXME("(%p): stub.\n", hCall);
return 0;
}
+/***********************************************************************
+ * lineDevSpecific (TAPI32.@)
+ */
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);
+ FIXME("(%p, %08x, %p, %p, %d): stub.\n", hLine, dwAddressId, hCall, lpParams, dwSize);
return 1;
-}
+}
+/***********************************************************************
+ * lineDevSpecificFeature (TAPI32.@)
+ */
DWORD WINAPI lineDevSpecificFeature(HLINE hLine, DWORD dwFeature, LPVOID lpParams, DWORD dwSize)
{
- FIXME(tapi, "(%04x, %08lx, %p, %ld): stub.\n", hLine, dwFeature, lpParams, dwSize);
+ FIXME("(%p, %08x, %p, %d): stub.\n", hLine, dwFeature, lpParams, dwSize);
return 1;
}
-DWORD WINAPI lineDial(HCALL hCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
+/***********************************************************************
+ * lineDial (TAPI32.@)
+ */
+DWORD WINAPI lineDialA(HCALL hCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
{
- FIXME(tapi, "(%04x, %s, %08lx): stub.\n", hCall, lpszDestAddress, dwCountryCode);
+ FIXME("(%p, %s, %08x): stub.\n", hCall, lpszDestAddress, dwCountryCode);
return 1;
}
-
+
+/***********************************************************************
+ * lineDrop (TAPI32.@)
+ */
DWORD WINAPI lineDrop(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
{
- FIXME(tapi, "(%04x, %s, %08lx): stub.\n", hCall, lpsUserUserInfo, dwSize);
+ FIXME("(%p, %s, %08x): stub.\n", hCall, lpsUserUserInfo, dwSize);
return 1;
}
-DWORD WINAPI lineForward(HLINE hLine, DWORD bAllAddress, DWORD dwAdressID, LPLINEFORWARDLIST lpForwardList, DWORD dwNumRingsNoAnswer, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
+/***********************************************************************
+ * lineForward (TAPI32.@)
+ */
+DWORD WINAPI lineForwardA(HLINE hLine, DWORD bAllAddress, DWORD dwAddressID, LPLINEFORWARDLIST lpForwardList, DWORD dwNumRingsNoAnswer, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
{
- FIXME(tapi, "stub.\n");
+ FIXME("stub.\n");
return 1;
-}
-
-DWORD WINAPI lineGatherDigits(HCALL hCall, DWORD dwDigitModes, LPSTR lpsDigits, DWORD dwNumDigits, LPCSTR lpszTerminationDigits, DWORD dwFirstDigitTimeout, DWORD dwInterDigitTimeout)
+}
+
+/***********************************************************************
+ * lineGatherDigits (TAPI32.@)
+ */
+DWORD WINAPI lineGatherDigitsA(HCALL hCall, DWORD dwDigitModes, LPSTR lpsDigits, DWORD dwNumDigits, LPCSTR lpszTerminationDigits, DWORD dwFirstDigitTimeout, DWORD dwInterDigitTimeout)
{
- FIXME(tapi, "stub.\n");
+ FIXME("stub.\n");
return 0;
}
-DWORD WINAPI lineGenerateDigits(HCALL hCall, DWORD dwDigitModes, LPCSTR lpszDigits, DWORD dwDuration)
+/***********************************************************************
+ * lineGenerateDigits (TAPI32.@)
+ */
+DWORD WINAPI lineGenerateDigitsA(HCALL hCall, DWORD dwDigitModes, LPCSTR lpszDigits, DWORD dwDuration)
{
- FIXME(tapi, "(%04x, %08lx, %s, %ld): stub.\n", hCall, dwDigitModes, lpszDigits, dwDuration);
+ FIXME("(%p, %08x, %s, %d): stub.\n", hCall, dwDigitModes, lpszDigits, dwDuration);
return 0;
}
+/***********************************************************************
+ * lineGenerateTone (TAPI32.@)
+ */
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);
+ FIXME("(%p, %08x, %d, %d, %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)
+/***********************************************************************
+ * lineGetAddressCaps (TAPI32.@)
+ */
+DWORD WINAPI lineGetAddressCapsA(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);
+ FIXME("(%p, %08x, %08x, %08x, %08x, %p): stub.\n", hLineApp, dwDeviceID, dwAddressID, dwAPIVersion, dwExtVersion, lpAddressCaps);
return 0;
}
-DWORD WINAPI lineGetAddressID(HLINE hLine, LPDWORD lpdwAddressID, DWORD dwAddressMode, LPCSTR lpsAddress, DWORD dwSize)
+/***********************************************************************
+ * lineGetAddressID (TAPI32.@)
+ */
+DWORD WINAPI lineGetAddressIDA(HLINE hLine, LPDWORD lpdwAddressID, DWORD dwAddressMode, LPCSTR lpsAddress, DWORD dwSize)
{
- FIXME(tapi, "%04x, %p, %08lx, %s, %ld): stub.\n", hLine, lpdwAddressID, dwAddressMode, lpsAddress, dwSize);
+ FIXME("%p, %p, %08x, %s, %d): stub.\n", hLine, lpdwAddressID, dwAddressMode, lpsAddress, dwSize);
return 0;
}
-DWORD WINAPI lineGetAddressStatus(HLINE hLine, DWORD dwAddressID, LPLINEADDRESSSTATUS lpAddressStatus)
+/***********************************************************************
+ * lineGetAddressStatus (TAPI32.@)
+ */
+DWORD WINAPI lineGetAddressStatusA(HLINE hLine, DWORD dwAddressID, LPLINEADDRESSSTATUS lpAddressStatus)
{
- FIXME(tapi, "(%04x, %08lx, %p): stub.\n", hLine, dwAddressID, lpAddressStatus);
+ FIXME("(%p, %08x, %p): stub.\n", hLine, dwAddressID, lpAddressStatus);
return 0;
-}
+}
-DWORD WINAPI lineGetAppPriority(LPCSTR lpszAppFilename, DWORD dwMediaMode, LPLINEEXTENSIONID const lpExtensionID, DWORD dwRequestMode, LPVARSTRING lpExtensionName, LPDWORD lpdwPriority)
+/***********************************************************************
+ * lineGetAppPriority (TAPI32.@)
+ */
+DWORD WINAPI lineGetAppPriorityA(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);
+ FIXME("(%s, %08x, %p, %08x, %p, %p): stub.\n", lpszAppFilename, dwMediaMode, lpExtensionID, dwRequestMode, lpExtensionName, lpdwPriority);
return 0;
-}
+}
-DWORD WINAPI lineGetCallInfo(HCALL hCall, LPLINECALLINFO lpCallInfo)
+/***********************************************************************
+ * lineGetCallInfo (TAPI32.@)
+ */
+DWORD WINAPI lineGetCallInfoA(HCALL hCall, LPLINECALLINFO lpCallInfo)
{
- FIXME(tapi, "(%04x, %p): stub.\n", hCall, lpCallInfo);
+ FIXME("(%p, %p): stub.\n", hCall, lpCallInfo);
return 0;
}
+/***********************************************************************
+ * lineGetCallStatus (TAPI32.@)
+ */
DWORD WINAPI lineGetCallStatus(HCALL hCall, LPLINECALLSTATUS lpCallStatus)
{
- FIXME(tapi, "(%04x, %p): stub.\n", hCall, lpCallStatus);
+ FIXME("(%p, %p): stub.\n", hCall, lpCallStatus);
return 0;
}
+/***********************************************************************
+ * lineGetConfRelatedCalls (TAPI32.@)
+ */
DWORD WINAPI lineGetConfRelatedCalls(HCALL hCall, LPLINECALLLIST lpCallList)
{
- FIXME(tapi, "(%04x, %p): stub.\n", hCall, lpCallList);
+ FIXME("(%p, %p): stub.\n", hCall, lpCallList);
return 0;
-}
+}
-DWORD WINAPI lineGetCountry(DWORD dwCountryID, DWORD dwAPIVersion, LPLINECOUNTRYLIST lpLineCountryList)
+typedef struct tagTAPI_CountryInfo
{
- FIXME(tapi, "(%08lx, %08lx, %p): stub.\n", dwCountryID, dwAPIVersion, lpLineCountryList);
+ DWORD dwCountryID;
+ DWORD dwCountryCode;
+ LPSTR lpCountryName;
+ LPSTR lpSameAreaRule;
+ LPSTR lpLongDistanceRule;
+ LPSTR lpInternationalRule;
+} TAPI_CountryInfo;
+
+/***********************************************************************
+ * lineGetCountry (TAPI32.@)
+ */
+DWORD WINAPI lineGetCountryA(DWORD dwCountryID, DWORD dwAPIVersion, LPLINECOUNTRYLIST lpLineCountryList)
+{
+ DWORD dwAvailSize, dwOffset, i, num_countries, max_subkey_len;
+ LPLINECOUNTRYENTRY lpLCE;
+ HKEY hkey;
+ char *subkey_name;
+
+ if(!lpLineCountryList) {
+ TRACE("(%08x, %08x, %p): stub. Returning LINEERR_INVALPOINTER\n",
+ dwCountryID, dwAPIVersion, lpLineCountryList);
+ return LINEERR_INVALPOINTER;
+ }
+
+ TRACE("(%08x, %08x, %p(%d)): stub.\n",
+ dwCountryID, dwAPIVersion, lpLineCountryList,
+ lpLineCountryList->dwTotalSize);
+
+ if(RegOpenKeyA(HKEY_LOCAL_MACHINE, szCountrylistKey, &hkey)
+ != ERROR_SUCCESS)
+ return LINEERR_INIFILECORRUPT;
+
+
+ dwAvailSize = lpLineCountryList->dwTotalSize;
+ dwOffset = sizeof (LINECOUNTRYLIST);
+
+ if(dwAvailSize<dwOffset)
+ return LINEERR_STRUCTURETOOSMALL;
+
+ memset(lpLineCountryList, 0, dwAvailSize);
+
+ lpLineCountryList->dwTotalSize = dwAvailSize;
+ lpLineCountryList->dwUsedSize = dwOffset;
+ lpLineCountryList->dwNumCountries = 0;
+ lpLineCountryList->dwCountryListSize = 0;
+ lpLineCountryList->dwCountryListOffset = dwOffset;
+
+ lpLCE = (LPLINECOUNTRYENTRY)(&lpLineCountryList[1]);
+
+ if(RegQueryInfoKeyA(hkey, NULL, NULL, NULL, &num_countries, &max_subkey_len,
+ NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) {
+ RegCloseKey(hkey);
+ return LINEERR_STRUCTURETOOSMALL;
+ }
+
+ if(dwCountryID)
+ dwOffset = sizeof (LINECOUNTRYENTRY);
+ else
+ dwOffset += num_countries * sizeof (LINECOUNTRYENTRY);
+
+ max_subkey_len++;
+ subkey_name = HeapAlloc(GetProcessHeap(), 0, max_subkey_len);
+ for(i = 0; i < num_countries; i++)
+ {
+ DWORD len, size, size_int, size_long, size_name, size_same;
+ HKEY hsubkey;
+
+ if(RegEnumKeyA(hkey, i, subkey_name, max_subkey_len) !=
+ ERROR_SUCCESS)
+ continue;
+
+ if(dwCountryID && (atoi(subkey_name) != dwCountryID))
+ continue;
+
+ if(RegOpenKeyA(hkey, subkey_name, &hsubkey) != ERROR_SUCCESS)
+ continue;
+
+ RegQueryValueExA(hsubkey, "InternationalRule", NULL, NULL,
+ NULL, &size_int);
+ len = size_int;
+
+ RegQueryValueExA(hsubkey, "LongDistanceRule", NULL, NULL,
+ NULL, &size_long);
+ len += size_long;
+
+ RegQueryValueExA(hsubkey, "Name", NULL, NULL,
+ NULL, &size_name);
+ len += size_name;
+
+ RegQueryValueExA(hsubkey, "SameAreaRule", NULL, NULL,
+ NULL, &size_same);
+ len += size_same;
+
+ if(dwAvailSize < (dwOffset+len))
+ {
+ dwOffset += len;
+ RegCloseKey(hsubkey);
+ if(dwCountryID)
+ break;
+ continue;
+ }
+
+ lpLineCountryList->dwNumCountries++;
+ lpLineCountryList->dwCountryListSize += sizeof (LINECOUNTRYENTRY);
+ lpLineCountryList->dwUsedSize += len + sizeof (LINECOUNTRYENTRY);
+
+ if(dwCountryID)
+ i = 0;
+
+ lpLCE[i].dwCountryID = atoi(subkey_name);
+ size = sizeof(DWORD);
+ RegQueryValueExA(hsubkey, "CountryCode", NULL, NULL,
+ (BYTE*)&lpLCE[i].dwCountryCode, &size);
+
+ lpLCE[i].dwNextCountryID = 0;
+
+ if(i > 0)
+ lpLCE[i-1].dwNextCountryID = lpLCE[i].dwCountryID;
+
+ /* add country name */
+ lpLCE[i].dwCountryNameSize = size_name;
+ lpLCE[i].dwCountryNameOffset = dwOffset;
+ RegQueryValueExA(hsubkey, "Name", NULL, NULL,
+ ((LPBYTE)lpLineCountryList)+dwOffset,
+ &size_name);
+ dwOffset += size_name;
+
+ /* add Same Area Rule */
+ lpLCE[i].dwSameAreaRuleSize = size_same;
+ lpLCE[i].dwSameAreaRuleOffset = dwOffset;
+ RegQueryValueExA(hsubkey, "SameAreaRule", NULL, NULL,
+ ((LPBYTE)lpLineCountryList)+dwOffset,
+ &size_same);
+ dwOffset += size_same;
+
+ /* add Long Distance Rule */
+ lpLCE[i].dwLongDistanceRuleSize = size_long;
+ lpLCE[i].dwLongDistanceRuleOffset = dwOffset;
+ RegQueryValueExA(hsubkey, "LongDistanceRule", NULL, NULL,
+ ((LPBYTE)lpLineCountryList)+dwOffset,
+ &size_long);
+ dwOffset += size_long;
+
+ /* add Long Distance Rule */
+ lpLCE[i].dwInternationalRuleSize = size_int;
+ lpLCE[i].dwInternationalRuleOffset = dwOffset;
+ RegQueryValueExA(hsubkey, "InternationalRule", NULL, NULL,
+ ((LPBYTE)lpLineCountryList)+dwOffset,
+ &size_int);
+ dwOffset += size_int;
+ RegCloseKey(hsubkey);
+
+ TRACE("Added country %s at %p\n", (LPSTR)lpLineCountryList + lpLCE[i].dwCountryNameOffset,
+ &lpLCE[i]);
+
+ if(dwCountryID) break;
+ }
+
+ lpLineCountryList->dwNeededSize = dwOffset;
+
+ TRACE("%d available %d required\n", dwAvailSize, dwOffset);
+
+ HeapFree(GetProcessHeap(), 0, subkey_name);
+ RegCloseKey(hkey);
+
return 0;
}
-DWORD WINAPI lineGetDevCaps(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtVersion, LPLINEDEVCAPS lpLineDevCaps)
+/***********************************************************************
+ * lineGetDevCaps (TAPI32.@)
+ */
+DWORD WINAPI lineGetDevCapsA(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtVersion, LPLINEDEVCAPS lpLineDevCaps)
{
- FIXME(tapi, "(%04x, %08lx, %08lx, %08lx, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, dwExtVersion, lpLineDevCaps);
+ FIXME("(%p, %08x, %08x, %08x, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, dwExtVersion, lpLineDevCaps);
return 0;
-}
+}
-DWORD WINAPI lineGetDevConfig(DWORD dwDeviceID, LPVARSTRING lpDeviceConfig, LPCSTR lpszDeviceClass)
+/***********************************************************************
+ * lineGetDevConfig (TAPI32.@)
+ */
+DWORD WINAPI lineGetDevConfigA(DWORD dwDeviceID, LPVARSTRING lpDeviceConfig, LPCSTR lpszDeviceClass)
{
- FIXME(tapi, "(%08lx, %p, %s): stub.\n", dwDeviceID, lpDeviceConfig, lpszDeviceClass);
+ FIXME("(%08x, %p, %s): stub.\n", dwDeviceID, lpDeviceConfig, lpszDeviceClass);
return 0;
}
-DWORD WINAPI lineGetID(HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSelect, LPVARSTRING lpDeviceID, LPCSTR lpszDeviceClass)
+/***********************************************************************
+ * lineGetID (TAPI32.@)
+ */
+DWORD WINAPI lineGetIDA(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);
+ FIXME("(%p, %08x, %p, %08x, %p, %s): stub.\n", hLine, dwAddressID, hCall, dwSelect, lpDeviceID, lpszDeviceClass);
return 0;
}
-DWORD WINAPI lineGetIcon(DWORD dwDeviceID, LPCSTR lpszDeviceClass, HICON *lphIcon)
+/***********************************************************************
+ * lineGetIcon (TAPI32.@)
+ */
+DWORD WINAPI lineGetIconA(DWORD dwDeviceID, LPCSTR lpszDeviceClass, HICON *lphIcon)
{
- FIXME(tapi, "(%08lx, %s, %p): stub.\n", dwDeviceID, lpszDeviceClass, lphIcon);
+ FIXME("(%08x, %s, %p): stub.\n", dwDeviceID, lpszDeviceClass, lphIcon);
return 0;
-}
+}
-DWORD WINAPI lineGetLineDevStatus(HLINE hLine, LPLINEDEVSTATUS lpLineDevStatus)
+/***********************************************************************
+ * lineGetLineDevStatus (TAPI32.@)
+ */
+DWORD WINAPI lineGetLineDevStatusA(HLINE hLine, LPLINEDEVSTATUS lpLineDevStatus)
{
- FIXME(tapi, "(%04x, %p): stub.\n", hLine, lpLineDevStatus);
+ FIXME("(%p, %p): stub.\n", hLine, lpLineDevStatus);
return 0;
-}
+}
+/***********************************************************************
+ * lineGetNewCalls (TAPI32.@)
+ */
DWORD WINAPI lineGetNewCalls(HLINE hLine, DWORD dwAddressID, DWORD dwSelect, LPLINECALLLIST lpCallList)
{
- FIXME(tapi, "(%04x, %08lx, %08lx, %p): stub.\n", hLine, dwAddressID, dwSelect, lpCallList);
+ FIXME("(%p, %08x, %08x, %p): stub.\n", hLine, dwAddressID, dwSelect, lpCallList);
return 0;
}
-
+/***********************************************************************
+ * lineGetNumRings (TAPI32.@)
+ */
DWORD WINAPI lineGetNumRings(HLINE hLine, DWORD dwAddressID, LPDWORD lpdwNumRings)
{
- FIXME(tapi, "(%04x, %08lx, %p): stub.\n", hLine, dwAddressID, lpdwNumRings);
+ FIXME("(%p, %08x, %p): stub.\n", hLine, dwAddressID, lpdwNumRings);
return 0;
}
-DWORD WINAPI lineGetProviderList(DWORD dwAPIVersion, LPLINEPROVIDERLIST lpProviderList)
+/***********************************************************************
+ * lineGetProviderList (TAPI32.@)
+ */
+DWORD WINAPI lineGetProviderListA(DWORD dwAPIVersion, LPLINEPROVIDERLIST lpProviderList)
{
- FIXME(tapi, "(%08lx, %p): stub.\n", dwAPIVersion, lpProviderList);
+ FIXME("(%08x, %p): stub.\n", dwAPIVersion, lpProviderList);
return 0;
-}
+}
-DWORD WINAPI lineGetRequest(HLINEAPP hLineApp, DWORD dwRequestMode, LPVOID lpRequestBuffer)
+/***********************************************************************
+ * lineGetRequest (TAPI32.@)
+ */
+DWORD WINAPI lineGetRequestA(HLINEAPP hLineApp, DWORD dwRequestMode, LPVOID lpRequestBuffer)
{
- FIXME(tapi, "%04x, %08lx, %p): stub.\n", hLineApp, dwRequestMode, lpRequestBuffer);
+ FIXME("%p, %08x, %p): stub.\n", hLineApp, dwRequestMode, lpRequestBuffer);
return 0;
-}
+}
+/***********************************************************************
+ * lineGetStatusMessages (TAPI32.@)
+ */
DWORD WINAPI lineGetStatusMessages(HLINE hLine, LPDWORD lpdwLineStatus, LPDWORD lpdwAddressStates)
{
- FIXME(tapi, "(%04x, %p, %p): stub.\n", hLine, lpdwLineStatus, lpdwAddressStates);
+ FIXME("(%p, %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;
+/***********************************************************************
+ * lineGetTranslateCaps (TAPI32.@)
+ *
+ * get address translate capabilities. Returns a LINETRANSLATECAPS
+ * structure:
+ *
+ * +-----------------------+
+ * |TotalSize |
+ * |NeededSize |
+ * |UsedSize |
+ * +-----------------------+
+ * |NumLocations |
+ * |LocationsListSize |
+ * |LocationsListOffset | -+
+ * |CurrentLocationID | |
+ * +-----------------------+ |
+ * |NumCards | |
+ * |CardListSize | |
+ * |CardListOffset | -|--+
+ * |CurrentPreferredCardID | | |
+ * +-----------------------+ | |
+ * | | <+ |
+ * |LINELOCATIONENTRY #1 | |
+ * | | |
+ * +-----------------------+ |
+ * ~ ~ |
+ * +-----------------------+ |
+ * | | |
+ * |LINELOCATIONENTRY | |
+ * | #NumLocations| |
+ * +-----------------------+ |
+ * | | <---+
+ * |LINECARDENTRY #1 |
+ * | |
+ * +-----------------------+
+ * ~ ~
+ * +-----------------------+
+ * | |
+ * |LINECARDENTRY #NumCards|
+ * | |
+ * +-----------------------+
+ * | room for strings named|
+ * | in the structures |
+ * | above. |
+ * +-----------------------+
+ */
+DWORD WINAPI lineGetTranslateCapsA(HLINEAPP hLineApp, DWORD dwAPIVersion,
+ LPLINETRANSLATECAPS lpTranslateCaps)
+{
+ HKEY hkLocations, hkCards, hkCardLocations, hsubkey;
+ int numlocations, numcards;
+ DWORD maxlockeylen,
+ maxcardkeylen;
+ char *loc_key_name = NULL;
+ char *card_key_name = NULL;
+ LPBYTE strptr;
+ int length;
+ int i;
+ DWORD lendword;
+ DWORD currentid;
+ LPLINELOCATIONENTRY pLocEntry;
+ LPLINECARDENTRY pCardEntry;
+
+ TRACE("(%p, %08x, %p (tot. size %d)\n", hLineApp, dwAPIVersion,
+ lpTranslateCaps, lpTranslateCaps->dwTotalSize );
+ if( lpTranslateCaps->dwTotalSize < sizeof(LINETRANSLATECAPS))
+ return LINEERR_STRUCTURETOOSMALL;
+ if( RegCreateKeyA(HKEY_LOCAL_MACHINE, szLocationsKey, &hkLocations)
+ != ERROR_SUCCESS ) {
+ ERR("unexpected registry error 1.\n");
+ return LINEERR_INIFILECORRUPT;
+ }
+ lendword = sizeof( DWORD);
+ if( RegQueryValueExA( hkLocations, "CurrentID", NULL, NULL,
+ (LPBYTE) ¤tid, &lendword) != ERROR_SUCCESS )
+ currentid = -1; /* change this later */
+ if(RegQueryInfoKeyA(hkLocations, NULL, NULL, NULL, NULL, &maxlockeylen,
+ NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) {
+ RegCloseKey(hkLocations);
+ ERR("unexpected registry error 2.\n");
+ return LINEERR_INIFILECORRUPT;
+ }
+ maxlockeylen++;
+ if( maxlockeylen < 10)
+ maxlockeylen = 10; /* need this also if there is no key */
+ loc_key_name = HeapAlloc( GetProcessHeap(), 0, maxlockeylen);
+ /* first time through: calculate needed space */
+ length=0;
+ i=0;
+ numlocations=0;
+ while( RegEnumKeyA(hkLocations, i, loc_key_name, maxlockeylen)
+ == ERROR_SUCCESS){
+ DWORD size_val;
+ i++;
+ if( strncasecmp(loc_key_name, "location", 8) ||
+ (RegOpenKeyA(hkLocations, loc_key_name, &hsubkey)
+ != ERROR_SUCCESS))
+ continue;
+ numlocations++;
+ length += sizeof(LINELOCATIONENTRY);
+ RegQueryValueExA(hsubkey, "Name",NULL,NULL,NULL,&size_val);
+ length += size_val;
+ RegQueryValueExA(hsubkey, "AreaCode",NULL,NULL,NULL,&size_val);
+ length += size_val;
+ RegQueryValueExA(hsubkey, "OutsideAccess",NULL,NULL,NULL,&size_val);
+ length += size_val;
+ RegQueryValueExA(hsubkey, "LongDistanceAccess",NULL,NULL,NULL,&size_val);
+ length += size_val;
+ RegQueryValueExA(hsubkey, "DisableCallWaiting",NULL,NULL,NULL,&size_val);
+ length += size_val;
+ /* fixme: what about TollPrefixList???? */
+ RegCloseKey(hsubkey);
+ }
+ if(numlocations == 0) {
+ /* add one location */
+ if( RegCreateKeyA( hkLocations, "Location1", &hsubkey)
+ == ERROR_SUCCESS) {
+ DWORD dwval;
+ char buf[10];
+ numlocations = 1;
+ length += sizeof(LINELOCATIONENTRY) + 20 ;
+ RegSetValueExA( hsubkey, "AreaCode", 0, REG_SZ, (const BYTE *)"010", 4);
+ GetLocaleInfoA( LOCALE_SYSTEM_DEFAULT, LOCALE_ICOUNTRY, buf, 8);
+ dwval = atoi(buf);
+ RegSetValueExA( hsubkey, "Country", 0, REG_DWORD, (LPBYTE)&dwval,
+ sizeof(DWORD));
+ RegSetValueExA( hsubkey, "DisableCallWaiting", 0, REG_SZ, (const BYTE *)"", 1);
+ dwval = 1;
+ RegSetValueExA( hsubkey, "Flags", 0, REG_DWORD, (LPBYTE)&dwval,
+ sizeof(DWORD));
+ RegSetValueExA( hsubkey, "LongDistanceAccess", 0, REG_SZ, (const BYTE *)"", 1);
+ RegSetValueExA( hsubkey, "Name", 0, REG_SZ, (const BYTE *)"New Location", 13);
+ RegSetValueExA( hsubkey, "OutsideAccess", 0, REG_SZ, (const BYTE *)"", 1);
+ RegCloseKey(hsubkey);
+ dwval = 1;
+ RegSetValueExA( hkLocations, "CurrentID", 0, REG_DWORD,
+ (LPBYTE)&dwval, sizeof(DWORD));
+ dwval = 2;
+ RegSetValueExA( hkLocations, "NextID", 0, REG_DWORD, (LPBYTE)&dwval,
+ sizeof(DWORD));
+ }
+ }
+ /* do the card list */
+ numcards=0;
+ if( RegCreateKeyA(HKEY_CURRENT_USER, szCardsKey, &hkCards)
+ == ERROR_SUCCESS ) {
+ if(RegQueryInfoKeyA(hkCards, NULL, NULL, NULL, NULL, &maxcardkeylen,
+ NULL, NULL, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
+ maxcardkeylen++;
+ if( maxcardkeylen < 6) maxcardkeylen = 6;
+ card_key_name = HeapAlloc(GetProcessHeap(), 0, maxcardkeylen);
+ i=0;
+ while( RegEnumKeyA(hkCards, i, card_key_name, maxcardkeylen) ==
+ ERROR_SUCCESS){
+ DWORD size_val;
+ i++;
+ if( strncasecmp(card_key_name, "card", 4) || ERROR_SUCCESS !=
+ (RegOpenKeyA(hkCards, card_key_name, &hsubkey) ))
+ continue;
+ numcards++;
+ length += sizeof(LINECARDENTRY);
+ RegQueryValueExA(hsubkey, "Name",NULL,NULL,NULL,&size_val);
+ length += size_val;
+ RegQueryValueExA(hsubkey, "LocalRule",NULL,NULL,NULL,&size_val);
+ length += size_val;
+ RegQueryValueExA(hsubkey, "LDRule",NULL,NULL,NULL,&size_val);
+ length += size_val;
+ RegQueryValueExA(hsubkey, "InternationalRule",NULL,NULL,NULL,
+ &size_val);
+ length += size_val;
+ RegCloseKey(hsubkey);
+ }
+ }
+ /* add one card (direct call) */
+ if (numcards == 0 &&
+ ERROR_SUCCESS == RegCreateKeyA( hkCards, "Card1", &hsubkey)) {
+ DWORD dwval;
+ numcards = 1;
+ length += sizeof(LINECARDENTRY) + 22 ;
+ RegSetValueExA( hsubkey, "Name", 0, REG_SZ, (const BYTE *)"None (Direct Call)", 19);
+ dwval = 1;
+ RegSetValueExA( hsubkey, "Flags", 0, REG_DWORD, (LPBYTE)&dwval,
+ sizeof(DWORD));
+ RegSetValueExA( hsubkey, "InternationalRule", 0, REG_SZ, (const BYTE *)"", 1);
+ RegSetValueExA( hsubkey, "LDRule", 0, REG_SZ, (const BYTE *)"", 1);
+ RegSetValueExA( hsubkey, "LocalRule", 0, REG_SZ, (const BYTE *)"", 1);
+ RegCloseKey(hsubkey);
+ dwval = 2;
+ RegSetValueExA( hkCards, "NextID", 0, REG_DWORD, (LPBYTE)&dwval,
+ sizeof(DWORD));
+ }
+ } else hkCards = 0; /* should really fail */
+ /* check if sufficient room is available */
+ lpTranslateCaps->dwNeededSize = sizeof(LINETRANSLATECAPS) + length;
+ if ( lpTranslateCaps->dwNeededSize > lpTranslateCaps->dwTotalSize ) {
+ RegCloseKey( hkLocations);
+ if( hkCards) RegCloseKey( hkCards);
+ HeapFree(GetProcessHeap(), 0, loc_key_name);
+ HeapFree(GetProcessHeap(), 0, card_key_name);
+ lpTranslateCaps->dwUsedSize = sizeof(LINETRANSLATECAPS);
+ TRACE("Insufficient space: total %d needed %d used %d\n",
+ lpTranslateCaps->dwTotalSize,
+ lpTranslateCaps->dwNeededSize,
+ lpTranslateCaps->dwUsedSize);
+ return 0;
+ }
+ /* fill in the LINETRANSLATECAPS structure */
+ lpTranslateCaps->dwUsedSize = lpTranslateCaps->dwNeededSize;
+ lpTranslateCaps->dwNumLocations = numlocations;
+ lpTranslateCaps->dwLocationListSize = sizeof(LINELOCATIONENTRY) *
+ lpTranslateCaps->dwNumLocations;
+ lpTranslateCaps->dwLocationListOffset = sizeof(LINETRANSLATECAPS);
+ lpTranslateCaps->dwCurrentLocationID = currentid;
+ lpTranslateCaps->dwNumCards = numcards;
+ lpTranslateCaps->dwCardListSize = sizeof(LINECARDENTRY) *
+ lpTranslateCaps->dwNumCards;
+ lpTranslateCaps->dwCardListOffset = lpTranslateCaps->dwLocationListOffset +
+ lpTranslateCaps->dwLocationListSize;
+ lpTranslateCaps->dwCurrentPreferredCardID = 0;
+ /* this is where the strings will be stored */
+ strptr = ((LPBYTE) lpTranslateCaps) +
+ lpTranslateCaps->dwCardListOffset + lpTranslateCaps->dwCardListSize;
+ pLocEntry = (LPLINELOCATIONENTRY) (lpTranslateCaps + 1);
+ /* key with Preferred CardID's */
+ if( RegOpenKeyA(HKEY_CURRENT_USER, szLocationsKey, &hkCardLocations)
+ != ERROR_SUCCESS )
+ hkCardLocations = 0;
+ /* second time through all locations */
+ i=0;
+ while(RegEnumKeyA(hkLocations, i, loc_key_name, maxlockeylen)
+ == ERROR_SUCCESS){
+ DWORD size_val;
+ i++;
+ if( strncasecmp(loc_key_name, "location", 8) ||
+ (RegOpenKeyA(hkLocations, loc_key_name, &hsubkey)
+ != ERROR_SUCCESS))
+ continue;
+ size_val=sizeof(DWORD);
+ if( RegQueryValueExA(hsubkey, "ID",NULL, NULL,
+ (LPBYTE) &(pLocEntry->dwPermanentLocationID), &size_val) !=
+ ERROR_SUCCESS)
+ pLocEntry->dwPermanentLocationID = atoi( loc_key_name + 8);
+ size_val=2048;
+ RegQueryValueExA(hsubkey, "Name",NULL,NULL, strptr, &size_val);
+ pLocEntry->dwLocationNameSize = size_val;
+ pLocEntry->dwLocationNameOffset = strptr - (LPBYTE) lpTranslateCaps;
+ strptr += size_val;
+
+ size_val=2048;
+ RegQueryValueExA(hsubkey, "AreaCode",NULL,NULL, strptr, &size_val);
+ pLocEntry->dwCityCodeSize = size_val;
+ pLocEntry->dwCityCodeOffset = strptr - (LPBYTE) lpTranslateCaps;
+ strptr += size_val;
+
+ size_val=2048;
+ RegQueryValueExA(hsubkey, "OutsideAccess",NULL,NULL, strptr, &size_val);
+ pLocEntry->dwLocalAccessCodeSize = size_val;
+ pLocEntry->dwLocalAccessCodeOffset = strptr - (LPBYTE) lpTranslateCaps;
+ strptr += size_val;
+ size_val=2048;
+ RegQueryValueExA(hsubkey, "LongDistanceAccess",NULL,NULL, strptr,
+ &size_val);
+ pLocEntry->dwLongDistanceAccessCodeSize= size_val;
+ pLocEntry->dwLongDistanceAccessCodeOffset= strptr -
+ (LPBYTE) lpTranslateCaps;
+ strptr += size_val;
+ size_val=2048;
+ RegQueryValueExA(hsubkey, "DisableCallWaiting",NULL,NULL, strptr,
+ &size_val);
+ pLocEntry->dwCancelCallWaitingSize= size_val;
+ pLocEntry->dwCancelCallWaitingOffset= strptr - (LPBYTE) lpTranslateCaps;
+ strptr += size_val;
+
+ pLocEntry->dwTollPrefixListSize = 0; /* FIXME */
+ pLocEntry->dwTollPrefixListOffset = 0; /* FIXME */
+
+ size_val=sizeof(DWORD);
+ RegQueryValueExA(hsubkey, "Country",NULL,NULL,
+ (LPBYTE) &(pLocEntry->dwCountryCode), &size_val);
+ pLocEntry->dwCountryID = pLocEntry->dwCountryCode; /* FIXME */
+ RegQueryValueExA(hsubkey, "Flags",NULL,NULL,
+ (LPBYTE) &(pLocEntry->dwOptions), &size_val);
+ RegCloseKey(hsubkey);
+ /* get preferred cardid */
+ pLocEntry->dwPreferredCardID = 0;
+ if ( hkCardLocations) {
+ size_val=sizeof(DWORD);
+ if(RegOpenKeyA(hkCardLocations, loc_key_name, &hsubkey) ==
+ ERROR_SUCCESS) {
+ RegQueryValueExA(hsubkey, "CallingCard",NULL,NULL,
+ (LPBYTE) &(pLocEntry->dwPreferredCardID), &size_val);
+ RegCloseKey(hsubkey);
+ }
+
+ }
+ /* make sure there is a currentID */
+ if(currentid == -1){
+ currentid = pLocEntry->dwPermanentLocationID;
+ lpTranslateCaps->dwCurrentLocationID = currentid;
+ }
+ if(pLocEntry->dwPermanentLocationID == currentid )
+ lpTranslateCaps->dwCurrentPreferredCardID =
+ pLocEntry->dwPreferredCardID;
+ TRACE("added: ID %d %s CountryCode %d CityCode %s CardID %d "
+ "LocalAccess: %s LongDistanceAccess: %s CountryID %d "
+ "Options %d CancelCallWait %s\n",
+ pLocEntry->dwPermanentLocationID,
+ debugstr_a( (char*)lpTranslateCaps + pLocEntry->dwLocationNameOffset),
+ pLocEntry->dwCountryCode,
+ debugstr_a( (char*)lpTranslateCaps + pLocEntry->dwCityCodeOffset),
+ pLocEntry->dwPreferredCardID,
+ debugstr_a( (char*)lpTranslateCaps + pLocEntry->dwLocalAccessCodeOffset),
+ debugstr_a( (char*)lpTranslateCaps + pLocEntry->dwLongDistanceAccessCodeOffset),
+ pLocEntry->dwCountryID,
+ pLocEntry->dwOptions,
+ debugstr_a( (char*)lpTranslateCaps + pLocEntry->dwCancelCallWaitingOffset));
+ pLocEntry++;
+ }
+ pCardEntry= (LPLINECARDENTRY) pLocEntry;
+ /* do the card list */
+ if( hkCards) {
+ i=0;
+ while( RegEnumKeyA(hkCards, i, card_key_name, maxcardkeylen) ==
+ ERROR_SUCCESS){
+ DWORD size_val;
+ i++;
+ if( strncasecmp(card_key_name, "card", 4) ||
+ (RegOpenKeyA(hkCards, card_key_name, &hsubkey) != ERROR_SUCCESS))
+ continue;
+ size_val=sizeof(DWORD);
+ if( RegQueryValueExA(hsubkey, "ID",NULL, NULL,
+ (LPBYTE) &(pCardEntry->dwPermanentCardID), &size_val) !=
+ ERROR_SUCCESS)
+ pCardEntry->dwPermanentCardID= atoi( card_key_name + 4);
+ size_val=2048;
+ RegQueryValueExA(hsubkey, "Name",NULL,NULL, strptr, &size_val);
+ pCardEntry->dwCardNameSize = size_val;
+ pCardEntry->dwCardNameOffset = strptr - (LPBYTE) lpTranslateCaps;
+ strptr += size_val;
+ pCardEntry->dwCardNumberDigits = 1; /* FIXME */
+ size_val=2048;
+ RegQueryValueExA(hsubkey, "LocalRule",NULL,NULL, strptr, &size_val);
+ pCardEntry->dwSameAreaRuleSize= size_val;
+ pCardEntry->dwSameAreaRuleOffset= strptr - (LPBYTE) lpTranslateCaps;
+ strptr += size_val;
+ size_val=2048;
+ RegQueryValueExA(hsubkey, "LDRule",NULL,NULL, strptr, &size_val);
+ pCardEntry->dwLongDistanceRuleSize = size_val;
+ pCardEntry->dwLongDistanceRuleOffset = strptr - (LPBYTE) lpTranslateCaps;
+ strptr += size_val;
+ size_val=2048;
+ RegQueryValueExA(hsubkey, "InternationalRule",NULL,NULL, strptr,
+ &size_val);
+ pCardEntry->dwInternationalRuleSize = size_val;
+ pCardEntry->dwInternationalRuleOffset = strptr -
+ (LPBYTE) lpTranslateCaps;
+ strptr += size_val;
+ size_val=sizeof(DWORD);
+ RegQueryValueExA(hsubkey, "Flags",NULL, NULL,
+ (LPBYTE) &(pCardEntry->dwOptions), &size_val);
+ TRACE( "added card: ID %d name %s SameArea %s LongDistance %s International %s Options 0x%x\n",
+ pCardEntry->dwPermanentCardID,
+ debugstr_a( (char*)lpTranslateCaps + pCardEntry->dwCardNameOffset),
+ debugstr_a( (char*)lpTranslateCaps + pCardEntry->dwSameAreaRuleOffset),
+ debugstr_a( (char*)lpTranslateCaps + pCardEntry->dwLongDistanceRuleOffset),
+ debugstr_a( (char*)lpTranslateCaps + pCardEntry->dwInternationalRuleOffset),
+ pCardEntry->dwOptions);
+
+ pCardEntry++;
+ }
+ }
+
+ if(hkLocations) RegCloseKey(hkLocations);
+ if(hkCards) RegCloseKey(hkCards);
+ if(hkCardLocations) RegCloseKey(hkCardLocations);
+ HeapFree(GetProcessHeap(), 0, loc_key_name);
+ HeapFree(GetProcessHeap(), 0, card_key_name);
+ TRACE(" returning success tot %d needed %d used %d\n",
+ lpTranslateCaps->dwTotalSize,
+ lpTranslateCaps->dwNeededSize,
+ lpTranslateCaps->dwUsedSize );
+ return 0; /* success */
}
-DWORD WINAPI lineHandoff(HCALL hCall, LPCSTR lpszFileName, DWORD dwMediaMode)
+/***********************************************************************
+ * lineHandoff (TAPI32.@)
+ */
+DWORD WINAPI lineHandoffA(HCALL hCall, LPCSTR lpszFileName, DWORD dwMediaMode)
{
- FIXME(tapi, "(%04x, %s, %08lx): stub.\n", hCall, lpszFileName, dwMediaMode);
+ FIXME("(%p, %s, %08x): stub.\n", hCall, lpszFileName, dwMediaMode);
return 0;
-}
+}
+/***********************************************************************
+ * lineHold (TAPI32.@)
+ */
DWORD WINAPI lineHold(HCALL hCall)
{
- FIXME(tapi, "(%04x): stub.\n", hCall);
+ FIXME("(%p): stub.\n", hCall);
return 1;
-}
+}
+/***********************************************************************
+ * lineInitialize (TAPI32.@)
+ */
DWORD WINAPI lineInitialize(
LPHLINEAPP lphLineApp,
HINSTANCE hInstance,
LPCSTR lpszAppName,
LPDWORD lpdwNumDevs)
{
- FIXME(comm, "stub.\n");
+ FIXME("(%p, %p, %p, %s, %p): stub.\n", lphLineApp, hInstance,
+ lpfnCallback, debugstr_a(lpszAppName), lpdwNumDevs);
return 0;
}
-DWORD WINAPI lineMakeCall(HLINE hLine, LPHCALL lphCall, LPCSTR lpszDestAddress, DWORD dwCountryCode, LPLINECALLPARAMS lpCallParams)
+/***********************************************************************
+ * lineInitializeExA (TAPI32.@)
+ */
+LONG WINAPI lineInitializeExA(LPHLINEAPP lphLineApp, HINSTANCE hInstance, LINECALLBACK lpfnCallback, LPCSTR lpszFriendlyAppName, LPDWORD lpdwNumDevs, LPDWORD lpdwAPIVersion, LPLINEINITIALIZEEXPARAMS lpLineInitializeExParams)
{
- FIXME(tapi, "(%04x, %p, %s, %08lx, %p): stub.\n", hLine, lphCall, lpszDestAddress, dwCountryCode, lpCallParams);
+ FIXME("(%p, %p, %p, %s, %p, %p, %p): stub.\n", lphLineApp, hInstance,
+ lpfnCallback, debugstr_a(lpszFriendlyAppName), lpdwNumDevs, lpdwAPIVersion, lpLineInitializeExParams);
+ return 0;
+}
+
+/***********************************************************************
+ * lineMakeCall (TAPI32.@)
+ */
+DWORD WINAPI lineMakeCallA(HLINE hLine, LPHCALL lphCall, LPCSTR lpszDestAddress, DWORD dwCountryCode, LPLINECALLPARAMS lpCallParams)
+{
+ FIXME("(%p, %p, %s, %08x, %p): stub.\n", hLine, lphCall, lpszDestAddress, dwCountryCode, lpCallParams);
return 1;
}
+/***********************************************************************
+ * lineMonitorDigits (TAPI32.@)
+ */
DWORD WINAPI lineMonitorDigits(HCALL hCall, DWORD dwDigitModes)
{
- FIXME(tapi, "(%04x, %08lx): stub.\n", hCall, dwDigitModes);
+ FIXME("(%p, %08x): stub.\n", hCall, dwDigitModes);
return 0;
}
+/***********************************************************************
+ * lineMonitorMedia (TAPI32.@)
+ */
DWORD WINAPI lineMonitorMedia(HCALL hCall, DWORD dwMediaModes)
{
- FIXME(tapi, "(%04x, %08lx): stub.\n", hCall, dwMediaModes);
+ FIXME("(%p, %08x): stub.\n", hCall, dwMediaModes);
return 0;
-}
+}
+/***********************************************************************
+ * lineMonitorTones (TAPI32.@)
+ */
DWORD WINAPI lineMonitorTones(HCALL hCall, LPLINEMONITORTONE lpToneList, DWORD dwNumEntries)
{
- FIXME(tapi, "(%04x, %p, %08lx): stub.\n", hCall, lpToneList, dwNumEntries);
+ FIXME("(%p, %p, %08x): stub.\n", hCall, lpToneList, dwNumEntries);
return 0;
-}
+}
+/***********************************************************************
+ * lineNegotiateAPIVersion (TAPI32.@)
+ */
DWORD WINAPI lineNegotiateAPIVersion(
HLINEAPP hLineApp,
DWORD dwDeviceID,
LPLINEEXTENSIONID lpExtensionID
)
{
- FIXME(comm, "stub.\n");
+ FIXME("(%p, %d, %d, %d, %p, %p): stub.\n", hLineApp, dwDeviceID,
+ dwAPILowVersion, dwAPIHighVersion, lpdwAPIVersion, lpExtensionID);
*lpdwAPIVersion = dwAPIHighVersion;
return 0;
}
+/***********************************************************************
+ * lineNegotiateExtVersion (TAPI32.@)
+ */
DWORD WINAPI lineNegotiateExtVersion(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtLowVersion, DWORD dwExtHighVersion, LPDWORD lpdwExtVersion)
{
- FIXME(tapi, "stub.\n");
+ FIXME("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)
+/***********************************************************************
+ * lineOpen (TAPI32.@)
+ */
+DWORD WINAPI lineOpenA(HLINEAPP hLineApp, DWORD dwDeviceID, LPHLINE lphLine, DWORD dwAPIVersion, DWORD dwExtVersion, DWORD dwCallbackInstance, DWORD dwPrivileges, DWORD dwMediaModes, LPLINECALLPARAMS lpCallParams)
{
- FIXME(tapi, "stub.\n");
+ FIXME("stub.\n");
return 0;
}
-DWORD WINAPI linePark(HCALL hCall, DWORD dwParkMode, LPCSTR lpszDirAddress, LPVARSTRING lpNonDirAddress)
+/***********************************************************************
+ * linePark (TAPI32.@)
+ */
+DWORD WINAPI lineParkA(HCALL hCall, DWORD dwParkMode, LPCSTR lpszDirAddress, LPVARSTRING lpNonDirAddress)
{
- FIXME(tapi, "(%04x, %08lx, %s, %p): stub.\n", hCall, dwParkMode, lpszDirAddress, lpNonDirAddress);
+ FIXME("(%p, %08x, %s, %p): stub.\n", hCall, dwParkMode, lpszDirAddress, lpNonDirAddress);
return 1;
-}
+}
-DWORD WINAPI linePickup(HLINE hLine, DWORD dwAddressID, LPHCALL lphCall, LPCSTR lpszDestAddress, LPCSTR lpszGroupID)
+/***********************************************************************
+ * linePickup (TAPI32.@)
+ */
+DWORD WINAPI linePickupA(HLINE hLine, DWORD dwAddressID, LPHCALL lphCall, LPCSTR lpszDestAddress, LPCSTR lpszGroupID)
{
- FIXME(tapi, "(%04x, %08lx, %p, %s, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress, lpszGroupID);
+ FIXME("(%p, %08x, %p, %s, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress, lpszGroupID);
return 1;
-}
+}
-DWORD WINAPI linePrepareAddToConference(HCALL hConfCall, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
+/***********************************************************************
+ * linePrepareAddToConference (TAPI32.@)
+ */
+DWORD WINAPI linePrepareAddToConferenceA(HCALL hConfCall, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
{
- FIXME(tapi, "(%04x, %p, %p): stub.\n", hConfCall, lphConsultCall, lpCallParams);
+ FIXME("(%p, %p, %p): stub.\n", hConfCall, lphConsultCall, lpCallParams);
return 1;
-}
+}
-/*************************************************************************
- * lineRedirect [TAPI32.53]
- *
+/***********************************************************************
+ * lineRedirect (TAPI32.@)
*/
-DWORD WINAPI lineRedirect(
+DWORD WINAPI lineRedirectA(
HCALL hCall,
LPCSTR lpszDestAddress,
DWORD dwCountryCode) {
- FIXME(comm, ": stub.\n");
+ FIXME(": stub.\n");
return 1;
}
+/***********************************************************************
+ * lineRegisterRequestRecipient (TAPI32.@)
+ */
DWORD WINAPI lineRegisterRequestRecipient(HLINEAPP hLineApp, DWORD dwRegistrationInstance, DWORD dwRequestMode, DWORD dwEnable)
{
- FIXME(tapi, "(%04x, %08lx, %08lx, %08lx): stub.\n", hLineApp, dwRegistrationInstance, dwRequestMode, dwEnable);
+ FIXME("(%p, %08x, %08x, %08x): stub.\n", hLineApp, dwRegistrationInstance, dwRequestMode, dwEnable);
return 1;
}
+/***********************************************************************
+ * lineReleaseUserUserInfo (TAPI32.@)
+ */
DWORD WINAPI lineReleaseUserUserInfo(HCALL hCall)
{
- FIXME(tapi, "(%04x): stub.\n", hCall);
+ FIXME("(%p): stub.\n", hCall);
return 1;
-}
+}
+/***********************************************************************
+ * lineRemoveFromConference (TAPI32.@)
+ */
DWORD WINAPI lineRemoveFromConference(HCALL hCall)
{
- FIXME(tapi, "(%04x): stub.\n", hCall);
+ FIXME("(%p): stub.\n", hCall);
return 1;
}
+/***********************************************************************
+ * lineRemoveProvider (TAPI32.@)
+ */
DWORD WINAPI lineRemoveProvider(DWORD dwPermanentProviderID, HWND hwndOwner)
{
- FIXME(tapi, "(%08lx, %04x): stub.\n", dwPermanentProviderID, hwndOwner);
+ FIXME("(%08x, %p): stub.\n", dwPermanentProviderID, hwndOwner);
return 1;
-}
+}
+/***********************************************************************
+ * lineSecureCall (TAPI32.@)
+ */
DWORD WINAPI lineSecureCall(HCALL hCall)
{
- FIXME(tapi, "(%04x): stub.\n", hCall);
+ FIXME("(%p): stub.\n", hCall);
return 1;
}
+/***********************************************************************
+ * lineSendUserUserInfo (TAPI32.@)
+ */
DWORD WINAPI lineSendUserUserInfo(HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
{
- FIXME(tapi, "(%04x, %s, %08lx): stub.\n", hCall, lpsUserUserInfo, dwSize);
+ FIXME("(%p, %s, %08x): stub.\n", hCall, lpsUserUserInfo, dwSize);
return 1;
}
-DWORD WINAPI lineSetAppPriority(LPCSTR lpszAppFilename, DWORD dwMediaMode, LPLINEEXTENSIONID const lpExtensionID, DWORD dwRequestMode, LPCSTR lpszExtensionName, DWORD dwPriority)
+/***********************************************************************
+ * lineSetAppPriority (TAPI32.@)
+ */
+DWORD WINAPI lineSetAppPriorityA(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);
+ FIXME("(%s, %08x, %p, %08x, %s, %08x): stub.\n", lpszAppFilename, dwMediaMode, lpExtensionID, dwRequestMode, lpszExtensionName, dwPriority);
return 0;
}
+/***********************************************************************
+ * lineSetAppSpecific (TAPI32.@)
+ */
DWORD WINAPI lineSetAppSpecific(HCALL hCall, DWORD dwAppSpecific)
{
- FIXME(tapi, "(%04x, %08lx): stub.\n", hCall, dwAppSpecific);
+ FIXME("(%p, %08x): stub.\n", hCall, dwAppSpecific);
return 0;
}
+/***********************************************************************
+ * lineSetCallParams (TAPI32.@)
+ */
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);
+ FIXME("(%p, %08x, %08x, %08x, %p): stub.\n", hCall, dwBearerMode, dwMinRate, dwMaxRate, lpDialParams);
return 1;
}
+/***********************************************************************
+ * lineSetCallPrivilege (TAPI32.@)
+ */
DWORD WINAPI lineSetCallPrivilege(HCALL hCall, DWORD dwCallPrivilege)
{
- FIXME(tapi, "(%04x, %08lx): stub.\n", hCall, dwCallPrivilege);
+ FIXME("(%p, %08x): stub.\n", hCall, dwCallPrivilege);
return 0;
-}
-
+}
+
+/***********************************************************************
+ * lineSetCurrentLocation (TAPI32.@)
+ */
DWORD WINAPI lineSetCurrentLocation(HLINEAPP hLineApp, DWORD dwLocation)
{
- FIXME(tapi, "(%04x, %08lx): stub.\n", hLineApp, dwLocation);
+ FIXME("(%p, %08x): stub.\n", hLineApp, dwLocation);
return 0;
}
-DWORD WINAPI lineSetDevConfig(DWORD dwDeviceID, LPVOID lpDeviceConfig, DWORD dwSize, LPCSTR lpszDeviceClass)
+/***********************************************************************
+ * lineSetDevConfig (TAPI32.@)
+ */
+DWORD WINAPI lineSetDevConfigA(DWORD dwDeviceID, LPVOID lpDeviceConfig, DWORD dwSize, LPCSTR lpszDeviceClass)
{
- FIXME(tapi, "(%0lx, %p, %08lx, %s): stub.\n", dwDeviceID, lpDeviceConfig, dwSize, lpszDeviceClass);
+ FIXME("(%08x, %p, %08x, %s): stub.\n", dwDeviceID, lpDeviceConfig, dwSize, lpszDeviceClass);
return 0;
}
+/***********************************************************************
+ * lineSetMediaControl (TAPI32.@)
+ */
DWORD WINAPI lineSetMediaControl(
HLINE hLine,
DWORD dwAddressID,
DWORD dwDigitNumEntries,
LPLINEMEDIACONTROLMEDIA const lpMediaList,
DWORD dwMediaNumEntries,
-LPLINEMEDIACONTROLTONE const lpToneList,
+LPLINEMEDIACONTROLTONE const lpToneList,
DWORD dwToneNumEntries,
LPLINEMEDIACONTROLCALLSTATE const lpCallStateList,
DWORD dwCallStateNumEntries)
{
- FIXME(tapi, ": stub.\n");
+ FIXME(": stub.\n");
return 0;
}
+/***********************************************************************
+ * lineSetMediaMode (TAPI32.@)
+ */
DWORD WINAPI lineSetMediaMode(HCALL hCall, DWORD dwMediaModes)
{
- FIXME(tapi, "(%04x, %08lx): stub.\n", hCall, dwMediaModes);
+ FIXME("(%p, %08x): stub.\n", hCall, dwMediaModes);
return 0;
-}
+}
+/***********************************************************************
+ * lineSetNumRings (TAPI32.@)
+ */
DWORD WINAPI lineSetNumRings(HLINE hLine, DWORD dwAddressID, DWORD dwNumRings)
{
- FIXME(tapi, "(%04x, %08lx, %08lx): stub.\n", hLine, dwAddressID, dwNumRings);
+ FIXME("(%p, %08x, %08x): stub.\n", hLine, dwAddressID, dwNumRings);
return 0;
-}
-
+}
+
+/***********************************************************************
+ * lineSetStatusMessages (TAPI32.@)
+ */
DWORD WINAPI lineSetStatusMessages(HLINE hLine, DWORD dwLineStates, DWORD dwAddressStates)
{
- FIXME(tapi, "(%04x, %08lx, %08lx): stub.\n", hLine, dwLineStates, dwAddressStates);
+ FIXME("(%p, %08x, %08x): stub.\n", hLine, dwLineStates, dwAddressStates);
return 0;
-}
-
+}
+
+/***********************************************************************
+ * lineSetTerminal (TAPI32.@)
+ */
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);
+ FIXME("(%p, %08x, %p, %08x, %08x, %08x, %08x): stub.\n", hLine, dwAddressID, hCall, dwSelect, dwTerminalModes, dwTerminalID, bEnable);
return 1;
-}
+}
-DWORD WINAPI lineSetTollList(HLINEAPP hLineApp, DWORD dwDeviceID, LPCSTR lpszAddressIn, DWORD dwTollListOption)
+/***********************************************************************
+ * lineSetTollList (TAPI32.@)
+ */
+DWORD WINAPI lineSetTollListA(HLINEAPP hLineApp, DWORD dwDeviceID, LPCSTR lpszAddressIn, DWORD dwTollListOption)
{
- FIXME(tapi, "(%04x, %08lx, %s, %08lx): stub.\n", hLineApp, dwDeviceID, lpszAddressIn, dwTollListOption);
+ FIXME("(%p, %08x, %s, %08x): stub.\n", hLineApp, dwDeviceID, lpszAddressIn, dwTollListOption);
return 0;
-}
-
-DWORD WINAPI lineSetupConference(HCALL hCall, HLINE hLine, LPHCALL lphConfCall, LPHCALL lphConsultCall, DWORD dwNumParties, LPLINECALLPARAMS lpCallParams)
+}
+
+/***********************************************************************
+ * lineSetupConference (TAPI32.@)
+ */
+DWORD WINAPI lineSetupConferenceA(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);
+ FIXME("(%p, %p, %p, %p, %08x, %p): stub.\n", hCall, hLine, lphConfCall, lphConsultCall, dwNumParties, lpCallParams);
return 1;
}
-DWORD WINAPI lineSetupTransfer(HCALL hCall, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
+/***********************************************************************
+ * lineSetupTransfer (TAPI32.@)
+ */
+DWORD WINAPI lineSetupTransferA(HCALL hCall, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
{
- FIXME(tapi, "(%04x, %p, %p): stub.\n", hCall, lphConsultCall, lpCallParams);
+ FIXME("(%p, %p, %p): stub.\n", hCall, lphConsultCall, lpCallParams);
return 1;
-}
+}
+/***********************************************************************
+ * lineShutdown (TAPI32.@)
+ */
DWORD WINAPI lineShutdown(HLINEAPP hLineApp)
{
- FIXME(tapi, "(%04x): stub.\n", hLineApp);
+ FIXME("(%p): stub.\n", hLineApp);
return 0;
}
+/***********************************************************************
+ * lineSwapHold (TAPI32.@)
+ */
DWORD WINAPI lineSwapHold(HCALL hActiveCall, HCALL hHeldCall)
{
- FIXME(tapi, "(active: %04x, held: %04x): stub.\n", hActiveCall, hHeldCall);
+ FIXME("(active: %p, held: %p): stub.\n", hActiveCall, hHeldCall);
return 1;
}
-DWORD WINAPI lineTranslateAddress(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, LPCSTR lpszAddressIn, DWORD dwCard, DWORD dwTranslateOptions, LPLINETRANSLATEOUTPUT lpTranslateOutput)
+/***********************************************************************
+ * lineTranslateAddress (TAPI32.@)
+ */
+DWORD WINAPI lineTranslateAddressA(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);
+ FIXME("(%p, %08x, %08x, %s, %08x, %08x, %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)
+/***********************************************************************
+ * lineTranslateDialog (TAPI32.@)
+ */
+DWORD WINAPI lineTranslateDialogA(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, HWND hwndOwner, LPCSTR lpszAddressIn)
{
- FIXME(tapi, "(%04x, %08lx, %08lx, %04x, %s): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, hwndOwner, lpszAddressIn);
+ FIXME("(%p, %08x, %08x, %p, %s): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, hwndOwner, lpszAddressIn);
return 0;
}
+/***********************************************************************
+ * lineUncompleteCall (TAPI32.@)
+ */
DWORD WINAPI lineUncompleteCall(HLINE hLine, DWORD dwCompletionID)
{
- FIXME(tapi, "(%04x, %08lx): stub.\n", hLine, dwCompletionID);
+ FIXME("(%p, %08x): stub.\n", hLine, dwCompletionID);
return 1;
}
-DWORD WINAPI lineUnHold(HCALL hCall)
+/***********************************************************************
+ * lineUnhold (TAPI32.@)
+ */
+DWORD WINAPI lineUnhold(HCALL hCall)
{
- FIXME(tapi, "(%04x): stub.\n", hCall);
+ FIXME("(%p): stub.\n", hCall);
return 1;
}
-DWORD WINAPI lineUnpark(HLINE hLine, DWORD dwAddressID, LPHCALL lphCall, LPCSTR lpszDestAddress)
+/***********************************************************************
+ * lineUnpark (TAPI32.@)
+ */
+DWORD WINAPI lineUnparkA(HLINE hLine, DWORD dwAddressID, LPHCALL lphCall, LPCSTR lpszDestAddress)
{
- FIXME(tapi, "(%04x, %08lx, %p, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress);
+ FIXME("(%p, %08x, %p, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress);
return 1;
-}
+}