line.c File Reference

#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include "windef.h"
#include "winbase.h"
#include "wine/winternl.h"
#include "wingdi.h"
#include "winreg.h"
#include "winnls.h"
#include "winerror.h"
#include "objbase.h"
#include "tapi.h"
#include "wine/debug.h"

Include dependency graph for line.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (tapi)
DWORD WINAPI	lineAccept (HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
DWORD WINAPI	lineAddProviderA (LPCSTR lpszProviderName, HWND hwndOwner, LPDWORD lpdwPermanentProviderID)
DWORD WINAPI	lineAddProviderW (LPCWSTR lpszProviderName, HWND hwndOwner, LPDWORD lpdwPermanentProviderID)
DWORD WINAPI	lineAddToConference (HCALL hConfCall, HCALL hConsultCall)
DWORD WINAPI	lineAnswer (HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
DWORD WINAPI	lineBlindTransferA (HCALL hCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
DWORD WINAPI	lineClose (HLINE hLine)
DWORD WINAPI	lineCompleteCall (HCALL hCall, LPDWORD lpdwCompletionID, DWORD dwCompletionMode, DWORD dwMessageID)
DWORD WINAPI	lineCompleteTransfer (HCALL hCall, HCALL hConsultCall, LPHCALL lphConfCall, DWORD dwTransferMode)
DWORD WINAPI	lineConfigDialogA (DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass)
DWORD WINAPI	lineConfigDialogW (DWORD dwDeviceID, HWND hwndOwner, LPCWSTR lpszDeviceClass)
DWORD WINAPI	lineConfigDialogEditA (DWORD dwDeviceID, HWND hwndOwner, LPCSTR lpszDeviceClass, LPVOID const lpDeviceConfigIn, DWORD dwSize, LPVARSTRING lpDeviceConfigOut)
DWORD WINAPI	lineConfigProvider (HWND hwndOwner, DWORD dwPermanentProviderID)
DWORD WINAPI	lineDeallocateCall (HCALL hCall)
DWORD WINAPI	lineDevSpecific (HLINE hLine, DWORD dwAddressId, HCALL hCall, LPVOID lpParams, DWORD dwSize)
DWORD WINAPI	lineDevSpecificFeature (HLINE hLine, DWORD dwFeature, LPVOID lpParams, DWORD dwSize)
DWORD WINAPI	lineDialA (HCALL hCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
DWORD WINAPI	lineDialW (HCALL hCall, LPCWSTR lpszDestAddress, DWORD dwCountryCode)
DWORD WINAPI	lineDrop (HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
DWORD WINAPI	lineForwardA (HLINE hLine, DWORD bAllAddress, DWORD dwAddressID, LPLINEFORWARDLIST lpForwardList, DWORD dwNumRingsNoAnswer, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
DWORD WINAPI	lineGatherDigitsA (HCALL hCall, DWORD dwDigitModes, LPSTR lpsDigits, DWORD dwNumDigits, LPCSTR lpszTerminationDigits, DWORD dwFirstDigitTimeout, DWORD dwInterDigitTimeout)
DWORD WINAPI	lineGenerateDigitsA (HCALL hCall, DWORD dwDigitModes, LPCSTR lpszDigits, DWORD dwDuration)
DWORD WINAPI	lineGenerateTone (HCALL hCall, DWORD dwToneMode, DWORD dwDuration, DWORD dwNumTones, LPLINEGENERATETONE lpTones)
DWORD WINAPI	lineGetAddressCapsA (HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAddressID, DWORD dwAPIVersion, DWORD dwExtVersion, LPLINEADDRESSCAPS lpAddressCaps)
DWORD WINAPI	lineGetAddressIDA (HLINE hLine, LPDWORD lpdwAddressID, DWORD dwAddressMode, LPCSTR lpsAddress, DWORD dwSize)
DWORD WINAPI	lineGetAddressStatusA (HLINE hLine, DWORD dwAddressID, LPLINEADDRESSSTATUS lpAddressStatus)
DWORD WINAPI	lineGetAppPriorityA (LPCSTR lpszAppFilename, DWORD dwMediaMode, LPLINEEXTENSIONID const lpExtensionID, DWORD dwRequestMode, LPVARSTRING lpExtensionName, LPDWORD lpdwPriority)
DWORD WINAPI	lineGetCallInfoA (HCALL hCall, LPLINECALLINFO lpCallInfo)
DWORD WINAPI	lineGetCallStatus (HCALL hCall, LPLINECALLSTATUS lpCallStatus)
DWORD WINAPI	lineGetConfRelatedCalls (HCALL hCall, LPLINECALLLIST lpCallList)
DWORD WINAPI	lineGetCountryA (DWORD dwCountryID, DWORD dwAPIVersion, LPLINECOUNTRYLIST lpLineCountryList)
DWORD WINAPI	lineGetCountryW (DWORD id, DWORD version, LPLINECOUNTRYLIST list)
DWORD WINAPI	lineGetDevCapsW (HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtVersion, LPLINEDEVCAPS lpLineDevCaps)
DWORD WINAPI	lineGetDevCapsA (HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtVersion, LPLINEDEVCAPS lpLineDevCaps)
DWORD WINAPI	lineGetDevConfigA (DWORD dwDeviceID, LPVARSTRING lpDeviceConfig, LPCSTR lpszDeviceClass)
DWORD WINAPI	lineGetIDW (HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSelect, LPVARSTRING lpDeviceID, LPCWSTR lpszDeviceClass)
DWORD WINAPI	lineGetIDA (HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSelect, LPVARSTRING lpDeviceID, LPCSTR lpszDeviceClass)
DWORD WINAPI	lineGetIconA (DWORD dwDeviceID, LPCSTR lpszDeviceClass, HICON *lphIcon)
DWORD WINAPI	lineGetLineDevStatusA (HLINE hLine, LPLINEDEVSTATUS lpLineDevStatus)
DWORD WINAPI	lineGetMessage (HLINEAPP hLineApp, LPLINEMESSAGE lpMessage, DWORD dwTimeout)
DWORD WINAPI	lineGetNewCalls (HLINE hLine, DWORD dwAddressID, DWORD dwSelect, LPLINECALLLIST lpCallList)
DWORD WINAPI	lineGetNumRings (HLINE hLine, DWORD dwAddressID, LPDWORD lpdwNumRings)
DWORD WINAPI	lineGetProviderListA (DWORD dwAPIVersion, LPLINEPROVIDERLIST lpProviderList)
DWORD WINAPI	lineGetProviderListW (DWORD dwAPIVersion, LPLINEPROVIDERLIST lpProviderList)
DWORD WINAPI	lineGetRequestA (HLINEAPP hLineApp, DWORD dwRequestMode, LPVOID lpRequestBuffer)
DWORD WINAPI	lineGetStatusMessages (HLINE hLine, LPDWORD lpdwLineStatus, LPDWORD lpdwAddressStates)
DWORD WINAPI	lineGetTranslateCapsA (HLINEAPP hLineApp, DWORD dwAPIVersion, LPLINETRANSLATECAPS lpTranslateCaps)
DWORD WINAPI	lineHandoffA (HCALL hCall, LPCSTR lpszFileName, DWORD dwMediaMode)
DWORD WINAPI	lineHold (HCALL hCall)
DWORD WINAPI	lineInitialize (LPHLINEAPP lphLineApp, HINSTANCE hInstance, LINECALLBACK lpfnCallback, LPCSTR lpszAppName, LPDWORD lpdwNumDevs)
LONG WINAPI	lineInitializeExA (LPHLINEAPP lphLineApp, HINSTANCE hInstance, LINECALLBACK lpfnCallback, LPCSTR lpszFriendlyAppName, LPDWORD lpdwNumDevs, LPDWORD lpdwAPIVersion, LPLINEINITIALIZEEXPARAMS lpLineInitializeExParams)
LONG WINAPI	lineInitializeExW (LPHLINEAPP lphLineApp, HINSTANCE hInstance, LINECALLBACK lpfnCallback, LPCWSTR lpszFriendlyAppName, LPDWORD lpdwNumDevs, LPDWORD lpdwAPIVersion, LPLINEINITIALIZEEXPARAMS lpLineInitializeExParams)
DWORD WINAPI	lineMakeCallW (HLINE hLine, LPHCALL lphCall, LPCWSTR lpszDestAddress, DWORD dwCountryCode, LPLINECALLPARAMS lpCallParams)
DWORD WINAPI	lineMakeCallA (HLINE hLine, LPHCALL lphCall, LPCSTR lpszDestAddress, DWORD dwCountryCode, LPLINECALLPARAMS lpCallParams)
DWORD WINAPI	lineMonitorDigits (HCALL hCall, DWORD dwDigitModes)
DWORD WINAPI	lineMonitorMedia (HCALL hCall, DWORD dwMediaModes)
DWORD WINAPI	lineMonitorTones (HCALL hCall, LPLINEMONITORTONE lpToneList, DWORD dwNumEntries)
DWORD WINAPI	lineNegotiateAPIVersion (HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPILowVersion, DWORD dwAPIHighVersion, LPDWORD lpdwAPIVersion, LPLINEEXTENSIONID lpExtensionID)
DWORD WINAPI	lineNegotiateExtVersion (HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtLowVersion, DWORD dwExtHighVersion, LPDWORD lpdwExtVersion)
DWORD WINAPI	lineOpenW (HLINEAPP hLineApp, DWORD dwDeviceID, LPHLINE lphLine, DWORD dwAPIVersion, DWORD dwExtVersion, DWORD dwCallbackInstance, DWORD dwPrivileges, DWORD dwMediaModes, LPLINECALLPARAMS lpCallParams)
DWORD WINAPI	lineOpenA (HLINEAPP hLineApp, DWORD dwDeviceID, LPHLINE lphLine, DWORD dwAPIVersion, DWORD dwExtVersion, DWORD dwCallbackInstance, DWORD dwPrivileges, DWORD dwMediaModes, LPLINECALLPARAMS lpCallParams)
DWORD WINAPI	lineParkA (HCALL hCall, DWORD dwParkMode, LPCSTR lpszDirAddress, LPVARSTRING lpNonDirAddress)
DWORD WINAPI	linePickupA (HLINE hLine, DWORD dwAddressID, LPHCALL lphCall, LPCSTR lpszDestAddress, LPCSTR lpszGroupID)
DWORD WINAPI	linePrepareAddToConferenceA (HCALL hConfCall, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
DWORD WINAPI	lineRedirectA (HCALL hCall, LPCSTR lpszDestAddress, DWORD dwCountryCode)
DWORD WINAPI	lineRegisterRequestRecipient (HLINEAPP hLineApp, DWORD dwRegistrationInstance, DWORD dwRequestMode, DWORD dwEnable)
DWORD WINAPI	lineReleaseUserUserInfo (HCALL hCall)
DWORD WINAPI	lineRemoveFromConference (HCALL hCall)
DWORD WINAPI	lineRemoveProvider (DWORD dwPermanentProviderID, HWND hwndOwner)
DWORD WINAPI	lineSecureCall (HCALL hCall)
DWORD WINAPI	lineSendUserUserInfo (HCALL hCall, LPCSTR lpsUserUserInfo, DWORD dwSize)
DWORD WINAPI	lineSetAppPriorityA (LPCSTR lpszAppFilename, DWORD dwMediaMode, LPLINEEXTENSIONID const lpExtensionID, DWORD dwRequestMode, LPCSTR lpszExtensionName, DWORD dwPriority)
DWORD WINAPI	lineSetAppSpecific (HCALL hCall, DWORD dwAppSpecific)
DWORD WINAPI	lineSetCallParams (HCALL hCall, DWORD dwBearerMode, DWORD dwMinRate, DWORD dwMaxRate, LPLINEDIALPARAMS lpDialParams)
DWORD WINAPI	lineSetCallPrivilege (HCALL hCall, DWORD dwCallPrivilege)
DWORD WINAPI	lineSetCurrentLocation (HLINEAPP hLineApp, DWORD dwLocation)
DWORD WINAPI	lineSetDevConfigA (DWORD dwDeviceID, LPVOID lpDeviceConfig, DWORD dwSize, LPCSTR lpszDeviceClass)
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)
DWORD WINAPI	lineSetMediaMode (HCALL hCall, DWORD dwMediaModes)
DWORD WINAPI	lineSetNumRings (HLINE hLine, DWORD dwAddressID, DWORD dwNumRings)
DWORD WINAPI	lineSetStatusMessages (HLINE hLine, DWORD dwLineStates, DWORD dwAddressStates)
DWORD WINAPI	lineSetTerminal (HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSelect, DWORD dwTerminalModes, DWORD dwTerminalID, DWORD bEnable)
DWORD WINAPI	lineSetTollListA (HLINEAPP hLineApp, DWORD dwDeviceID, LPCSTR lpszAddressIn, DWORD dwTollListOption)
DWORD WINAPI	lineSetupConferenceA (HCALL hCall, HLINE hLine, LPHCALL lphConfCall, LPHCALL lphConsultCall, DWORD dwNumParties, LPLINECALLPARAMS lpCallParams)
DWORD WINAPI	lineSetupTransferA (HCALL hCall, LPHCALL lphConsultCall, LPLINECALLPARAMS lpCallParams)
DWORD WINAPI	lineShutdown (HLINEAPP hLineApp)
DWORD WINAPI	lineSwapHold (HCALL hActiveCall, HCALL hHeldCall)
DWORD WINAPI	lineTranslateAddressA (HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, LPCSTR lpszAddressIn, DWORD dwCard, DWORD dwTranslateOptions, LPLINETRANSLATEOUTPUT lpTranslateOutput)
DWORD WINAPI	lineTranslateAddressW (HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, LPCWSTR lpszAddressIn, DWORD dwCard, DWORD dwTranslateOptions, LPLINETRANSLATEOUTPUT lpTranslateOutput)
DWORD WINAPI	lineTranslateDialogA (HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, HWND hwndOwner, LPCSTR lpszAddressIn)
DWORD WINAPI	lineTranslateDialogW (HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, HWND hwndOwner, LPCWSTR lpszAddressIn)
DWORD WINAPI	lineUncompleteCall (HLINE hLine, DWORD dwCompletionID)
DWORD WINAPI	lineUnhold (HCALL hCall)
DWORD WINAPI	lineUnparkA (HLINE hLine, DWORD dwAddressID, LPHCALL lphCall, LPCSTR lpszDestAddress)

Variables
static const char	szCountrylistKey []
static const char	szLocationsKey []
static const char	szCardsKey []

Function Documentation

lineAccept()

DWORD WINAPI lineAccept	(	HCALL	hCall,
		LPCSTR	lpsUserUserInfo,
		DWORD	dwSize
	)

Definition at line 50 of file line.c.

{
    FIXME("(%p, %s, %d): stub.\n", hCall, lpsUserUserInfo, dwSize);
    return 1;
}

lineAddProviderA()

DWORD WINAPI lineAddProviderA	(	LPCSTR	lpszProviderName,
		HWND	hwndOwner,
		LPDWORD	lpdwPermanentProviderID
	)

Definition at line 59 of file line.c.

{
    FIXME("(%s, %p, %p): stub.\n", lpszProviderName, hwndOwner, lpdwPermanentProviderID);
    return LINEERR_OPERATIONFAILED;
}

lineAddProviderW()

DWORD WINAPI lineAddProviderW	(	LPCWSTR	lpszProviderName,
		HWND	hwndOwner,
		LPDWORD	lpdwPermanentProviderID
	)

Definition at line 68 of file line.c.

{
    FIXME("(%s, %p, %p): stub.\n", wine_dbgstr_w(lpszProviderName), hwndOwner, lpdwPermanentProviderID);
    return LINEERR_OPERATIONFAILED;
}

lineAddToConference()

DWORD WINAPI lineAddToConference	(	HCALL	hConfCall,
		HCALL	hConsultCall
	)

Definition at line 77 of file line.c.

{
    FIXME("(%p, %p): stub.\n", hConfCall, hConsultCall);
    return 1;
}

lineAnswer()

DWORD WINAPI lineAnswer	(	HCALL	hCall,
		LPCSTR	lpsUserUserInfo,
		DWORD	dwSize
	)

Definition at line 86 of file line.c.

{
    FIXME("(%p, %s, %d): stub.\n", hCall, lpsUserUserInfo, dwSize);
    return 1;
}

lineBlindTransferA()

DWORD WINAPI lineBlindTransferA	(	HCALL	hCall,
		LPCSTR	lpszDestAddress,
		DWORD	dwCountryCode
	)

Definition at line 95 of file line.c.

{
    FIXME("(%p, %s, %08x): stub.\n", hCall, lpszDestAddress, dwCountryCode);
    return 1;
}

lineClose()

DWORD WINAPI lineClose

(

HLINE

hLine

)

Definition at line 104 of file line.c.

{
    FIXME("(%p): stub.\n", hLine);
    return 0;
}

lineCompleteCall()

DWORD WINAPI lineCompleteCall	(	HCALL	hCall,
		LPDWORD	lpdwCompletionID,
		DWORD	dwCompletionMode,
		DWORD	dwMessageID
	)

Definition at line 113 of file line.c.

{
    FIXME("(%p, %p, %08x, %08x): stub.\n", hCall, lpdwCompletionID, dwCompletionMode, dwMessageID);
    return 1;
}

lineCompleteTransfer()

DWORD WINAPI lineCompleteTransfer	(	HCALL	hCall,
		HCALL	hConsultCall,
		LPHCALL	lphConfCall,
		DWORD	dwTransferMode
	)

Definition at line 122 of file line.c.

{
    FIXME("(%p, %p, %p, %08x): stub.\n", hCall, hConsultCall, lphConfCall, dwTransferMode);
    return 1;
}

lineConfigDialogA()

DWORD WINAPI lineConfigDialogA	(	DWORD	dwDeviceID,
		HWND	hwndOwner,
		LPCSTR	lpszDeviceClass
	)

Definition at line 131 of file line.c.

{
    FIXME("(%08x, %p, %s): stub.\n", dwDeviceID, hwndOwner, lpszDeviceClass);
    return 0;
}

lineConfigDialogEditA()

DWORD WINAPI lineConfigDialogEditA	(	DWORD	dwDeviceID,
		HWND	hwndOwner,
		LPCSTR	lpszDeviceClass,
		LPVOID const	lpDeviceConfigIn,
		DWORD	dwSize,
		LPVARSTRING	lpDeviceConfigOut
	)

Definition at line 149 of file line.c.

{
    FIXME("stub.\n");
    return 0;
}

lineConfigDialogW()

DWORD WINAPI lineConfigDialogW	(	DWORD	dwDeviceID,
		HWND	hwndOwner,
		LPCWSTR	lpszDeviceClass
	)

Definition at line 140 of file line.c.

{
    FIXME("(%08x, %p, %s): stub.\n", dwDeviceID, hwndOwner, debugstr_w(lpszDeviceClass));
    return 0;
}

lineConfigProvider()

DWORD WINAPI lineConfigProvider	(	HWND	hwndOwner,
		DWORD	dwPermanentProviderID
	)

Definition at line 158 of file line.c.

{
    FIXME("(%p, %08x): stub.\n", hwndOwner, dwPermanentProviderID);
    return 0;
}

lineDeallocateCall()

DWORD WINAPI lineDeallocateCall

(

HCALL

hCall

)

Definition at line 167 of file line.c.

{
    FIXME("(%p): stub.\n", hCall);
    return 0;
}

lineDevSpecific()

DWORD WINAPI lineDevSpecific	(	HLINE	hLine,
		DWORD	dwAddressId,
		HCALL	hCall,
		LPVOID	lpParams,
		DWORD	dwSize
	)

Definition at line 176 of file line.c.

{
    FIXME("(%p, %08x, %p, %p, %d): stub.\n", hLine, dwAddressId, hCall, lpParams, dwSize);
    return 1;
}

lineDevSpecificFeature()

DWORD WINAPI lineDevSpecificFeature	(	HLINE	hLine,
		DWORD	dwFeature,
		LPVOID	lpParams,
		DWORD	dwSize
	)

Definition at line 185 of file line.c.

{
    FIXME("(%p, %08x, %p, %d): stub.\n", hLine, dwFeature, lpParams, dwSize);
    return 1;
}

lineDialA()

DWORD WINAPI lineDialA	(	HCALL	hCall,
		LPCSTR	lpszDestAddress,
		DWORD	dwCountryCode
	)

Definition at line 194 of file line.c.

{
    FIXME("(%p, %s, %08x): stub.\n", hCall, lpszDestAddress, dwCountryCode);
    return 1;
}

lineDialW()

DWORD WINAPI lineDialW	(	HCALL	hCall,
		LPCWSTR	lpszDestAddress,
		DWORD	dwCountryCode
	)

Definition at line 203 of file line.c.

{
    FIXME("(%p, %s, %08x): stub.\n", hCall, debugstr_w(lpszDestAddress), dwCountryCode);
    return 1;
}

lineDrop()

DWORD WINAPI lineDrop	(	HCALL	hCall,
		LPCSTR	lpsUserUserInfo,
		DWORD	dwSize
	)

Definition at line 212 of file line.c.

{
    FIXME("(%p, %s, %08x): stub.\n", hCall, lpsUserUserInfo, dwSize);
    return 1;
}

lineForwardA()

DWORD WINAPI lineForwardA	(	HLINE	hLine,
		DWORD	bAllAddress,
		DWORD	dwAddressID,
		LPLINEFORWARDLIST	lpForwardList,
		DWORD	dwNumRingsNoAnswer,
		LPHCALL	lphConsultCall,
		LPLINECALLPARAMS	lpCallParams
	)

Definition at line 221 of file line.c.

{
    FIXME("stub.\n");
    return 1;
}

lineGatherDigitsA()

DWORD WINAPI lineGatherDigitsA	(	HCALL	hCall,
		DWORD	dwDigitModes,
		LPSTR	lpsDigits,
		DWORD	dwNumDigits,
		LPCSTR	lpszTerminationDigits,
		DWORD	dwFirstDigitTimeout,
		DWORD	dwInterDigitTimeout
	)

Definition at line 230 of file line.c.

{
    FIXME("stub.\n");
    return 0;
}

lineGenerateDigitsA()

DWORD WINAPI lineGenerateDigitsA	(	HCALL	hCall,
		DWORD	dwDigitModes,
		LPCSTR	lpszDigits,
		DWORD	dwDuration
	)

Definition at line 239 of file line.c.

{
    FIXME("(%p, %08x, %s, %d): stub.\n", hCall, dwDigitModes, lpszDigits, dwDuration);
    return 0;
}

lineGenerateTone()

DWORD WINAPI lineGenerateTone	(	HCALL	hCall,
		DWORD	dwToneMode,
		DWORD	dwDuration,
		DWORD	dwNumTones,
		LPLINEGENERATETONE	lpTones
	)

Definition at line 248 of file line.c.

{
    FIXME("(%p, %08x, %d, %d, %p): stub.\n", hCall, dwToneMode, dwDuration, dwNumTones, lpTones);
    return 0;
}

lineGetAddressCapsA()

DWORD WINAPI lineGetAddressCapsA	(	HLINEAPP	hLineApp,
		DWORD	dwDeviceID,
		DWORD	dwAddressID,
		DWORD	dwAPIVersion,
		DWORD	dwExtVersion,
		LPLINEADDRESSCAPS	lpAddressCaps
	)

Definition at line 257 of file line.c.

{
    FIXME("(%p, %08x, %08x, %08x, %08x, %p): stub.\n", hLineApp, dwDeviceID, dwAddressID, dwAPIVersion, dwExtVersion, lpAddressCaps);
    return 0;
}

lineGetAddressIDA()

DWORD WINAPI lineGetAddressIDA	(	HLINE	hLine,
		LPDWORD	lpdwAddressID,
		DWORD	dwAddressMode,
		LPCSTR	lpsAddress,
		DWORD	dwSize
	)

Definition at line 266 of file line.c.

{
    FIXME("%p, %p, %08x, %s, %d): stub.\n", hLine, lpdwAddressID, dwAddressMode, lpsAddress, dwSize);
    return 0;
}

lineGetAddressStatusA()

DWORD WINAPI lineGetAddressStatusA	(	HLINE	hLine,
		DWORD	dwAddressID,
		LPLINEADDRESSSTATUS	lpAddressStatus
	)

Definition at line 275 of file line.c.

{
    FIXME("(%p, %08x, %p): stub.\n", hLine, dwAddressID, lpAddressStatus);
    return 0;
}

lineGetAppPriorityA()

DWORD WINAPI lineGetAppPriorityA	(	LPCSTR	lpszAppFilename,
		DWORD	dwMediaMode,
		LPLINEEXTENSIONID const	lpExtensionID,
		DWORD	dwRequestMode,
		LPVARSTRING	lpExtensionName,
		LPDWORD	lpdwPriority
	)

Definition at line 284 of file line.c.

{
    FIXME("(%s, %08x, %p, %08x, %p, %p): stub.\n", lpszAppFilename, dwMediaMode, lpExtensionID, dwRequestMode, lpExtensionName, lpdwPriority);
    return 0;
}

lineGetCallInfoA()

DWORD WINAPI lineGetCallInfoA	(	HCALL	hCall,
		LPLINECALLINFO	lpCallInfo
	)

Definition at line 293 of file line.c.

{
    FIXME("(%p, %p): stub.\n", hCall, lpCallInfo);
    return 0;
}

lineGetCallStatus()

DWORD WINAPI lineGetCallStatus	(	HCALL	hCall,
		LPLINECALLSTATUS	lpCallStatus
	)

Definition at line 302 of file line.c.

{
    FIXME("(%p, %p): stub.\n", hCall, lpCallStatus);
    return 0;
}

lineGetConfRelatedCalls()

DWORD WINAPI lineGetConfRelatedCalls	(	HCALL	hCall,
		LPLINECALLLIST	lpCallList
	)

Definition at line 311 of file line.c.

{
    FIXME("(%p, %p): stub.\n", hCall, lpCallList);
    return 0;
}

lineGetCountryA()

DWORD WINAPI lineGetCountryA	(	DWORD	dwCountryID,
		DWORD	dwAPIVersion,
		LPLINECOUNTRYLIST	lpLineCountryList
	)

Definition at line 320 of file line.c.

{
    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;
}

lineGetCountryW()

DWORD WINAPI lineGetCountryW	(	DWORD	id,
		DWORD	version,
		LPLINECOUNTRYLIST	list
	)

Definition at line 480 of file line.c.

{
    static const WCHAR country_listW[] =
        {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
         'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
         'T','e','l','e','p','h','o','n','y','\\','C','o','u','n','t','r','y',' ','L','i','s','t',0};
    static const WCHAR international_ruleW[] =
        {'I','n','t','e','r','n','a','t','i','o','n','a','l','R','u','l','e',0};
    static const WCHAR longdistance_ruleW[] =
        {'L','o','n','g','D','i','s','t','a','n','c','e','R','u','l','e',0};
    static const WCHAR samearea_ruleW[] =
        {'S','a','m','e','A','r','e','a','R','u','l','e',0};
    static const WCHAR nameW[] =
        {'N','a','m','e',0};
    static const WCHAR country_codeW[] =
        {'C','o','u','n','t','r','y','C','o','d','e',0};
    DWORD total_size, offset, i, num_countries, max_subkey_len;
    LINECOUNTRYENTRY *entry;
    WCHAR *subkey_name;
    HKEY hkey;
 
    if (!list) return LINEERR_INVALPOINTER;
    TRACE("(%08x, %08x, %p(%d))\n", id, version, list, list->dwTotalSize);
 
    if (RegOpenKeyW(HKEY_LOCAL_MACHINE, country_listW, &hkey) != ERROR_SUCCESS)
        return LINEERR_INIFILECORRUPT;
 
    total_size = list->dwTotalSize;
    offset = sizeof(LINECOUNTRYLIST);
    if (total_size < offset) return LINEERR_STRUCTURETOOSMALL;
 
    memset(list, 0, total_size);
    list->dwTotalSize         = total_size;
    list->dwUsedSize          = offset;
    list->dwNumCountries      = 0;
    list->dwCountryListSize   = 0;
    list->dwCountryListOffset = offset;
 
    entry = (LINECOUNTRYENTRY *)(list + 1);
 
    if (RegQueryInfoKeyW(hkey, NULL, NULL, NULL, &num_countries, &max_subkey_len,
                         NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
    {
        RegCloseKey(hkey);
        return LINEERR_OPERATIONFAILED;
    }
    if (id) offset = sizeof(LINECOUNTRYENTRY);
    else offset += num_countries * sizeof(LINECOUNTRYENTRY);
 
    max_subkey_len++;
    if (!(subkey_name = HeapAlloc(GetProcessHeap(), 0, max_subkey_len * sizeof(WCHAR))))
    {
        RegCloseKey(hkey);
        return LINEERR_NOMEM;
    }
    for (i = 0; i < num_countries; i++)
    {
        DWORD len, size, size_int, size_long, size_name, size_same;
        HKEY hsubkey;
 
        if (RegEnumKeyW(hkey, i, subkey_name, max_subkey_len) != ERROR_SUCCESS) continue;
        if (id && (wcstol(subkey_name, NULL, 10) != id)) continue;
        if (RegOpenKeyW(hkey, subkey_name, &hsubkey) != ERROR_SUCCESS) continue;
 
        RegQueryValueExW(hsubkey, international_ruleW, NULL, NULL, NULL, &size_int);
        len = size_int;
 
        RegQueryValueExW(hsubkey, longdistance_ruleW, NULL, NULL, NULL, &size_long);
        len += size_long;
 
        RegQueryValueExW(hsubkey, nameW, NULL, NULL, NULL, &size_name);
        len += size_name;
 
        RegQueryValueExW(hsubkey, samearea_ruleW, NULL, NULL, NULL, &size_same);
        len += size_same;
 
        if (total_size < offset + len)
        {
            offset += len;
            RegCloseKey(hsubkey);
            if (id) break;
            continue;
        }
        list->dwNumCountries++;
        list->dwCountryListSize += sizeof(LINECOUNTRYENTRY);
        list->dwUsedSize += len + sizeof(LINECOUNTRYENTRY);
 
        if (id) i = 0;
        entry[i].dwCountryID = wcstol(subkey_name, NULL, 10);
        size = sizeof(DWORD);
        RegQueryValueExW(hsubkey, country_codeW, NULL, NULL, (BYTE *)&entry[i].dwCountryCode, &size);
        entry[i].dwNextCountryID = 0;
 
        if (i > 0) entry[i - 1].dwNextCountryID = entry[i].dwCountryID;
 
        /* add country name */
        entry[i].dwCountryNameSize = size_name;
        entry[i].dwCountryNameOffset = offset;
        RegQueryValueExW(hsubkey, nameW, NULL, NULL, (BYTE *)list + offset, &size_name);
        offset += size_name;
 
        /* add Same Area Rule */
        entry[i].dwSameAreaRuleSize = size_same;
        entry[i].dwSameAreaRuleOffset = offset;
        RegQueryValueExW(hsubkey, samearea_ruleW, NULL, NULL, (BYTE *)list + offset, &size_same);
        offset += size_same;
 
        /* add Long Distance Rule */
        entry[i].dwLongDistanceRuleSize = size_long;
        entry[i].dwLongDistanceRuleOffset = offset;
        RegQueryValueExW(hsubkey, longdistance_ruleW, NULL, NULL, (BYTE *)list + offset, &size_long);
        offset += size_long;
 
        /* add Long Distance Rule */
        entry[i].dwInternationalRuleSize = size_int;
        entry[i].dwInternationalRuleOffset = offset;
        RegQueryValueExW(hsubkey, international_ruleW, NULL, NULL, (BYTE *)list + offset, &size_int);
        offset += size_int;
        RegCloseKey(hsubkey);
 
        TRACE("added country %s at %p\n",
              debugstr_w((const WCHAR *)((const char *)list + entry[i].dwCountryNameOffset)), &entry[i]);
        if (id) break;
    }
    list->dwNeededSize = offset;
 
    TRACE("%d available %d required\n", total_size, offset);
 
    HeapFree(GetProcessHeap(), 0, subkey_name);
    RegCloseKey(hkey);
    return 0;
}

lineGetDevCapsA()

DWORD WINAPI lineGetDevCapsA	(	HLINEAPP	hLineApp,
		DWORD	dwDeviceID,
		DWORD	dwAPIVersion,
		DWORD	dwExtVersion,
		LPLINEDEVCAPS	lpLineDevCaps
	)

Definition at line 630 of file line.c.

{
    static int warn_once;
 
    if(!warn_once++)
        FIXME("(%p, %08x, %08x, %08x, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion,
                                                 dwExtVersion, lpLineDevCaps);
    return LINEERR_OPERATIONFAILED;
}

lineGetDevCapsW()

DWORD WINAPI lineGetDevCapsW	(	HLINEAPP	hLineApp,
		DWORD	dwDeviceID,
		DWORD	dwAPIVersion,
		DWORD	dwExtVersion,
		LPLINEDEVCAPS	lpLineDevCaps
	)

Definition at line 616 of file line.c.

{
    static int warn_once;
 
    if(!warn_once++)
        FIXME("(%p, %08x, %08x, %08x, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion,
                                                 dwExtVersion, lpLineDevCaps);
    return LINEERR_OPERATIONFAILED;
}

lineGetDevConfigA()

DWORD WINAPI lineGetDevConfigA	(	DWORD	dwDeviceID,
		LPVARSTRING	lpDeviceConfig,
		LPCSTR	lpszDeviceClass
	)

Definition at line 644 of file line.c.

{
    FIXME("(%08x, %p, %s): stub.\n", dwDeviceID, lpDeviceConfig, lpszDeviceClass);
    return 0;
}

lineGetIconA()

DWORD WINAPI lineGetIconA	(	DWORD	dwDeviceID,
		LPCSTR	lpszDeviceClass,
		HICON *	lphIcon
	)

Definition at line 676 of file line.c.

{
    FIXME("(%08x, %s, %p): stub.\n", dwDeviceID, lpszDeviceClass, lphIcon);
    return 0;
}

lineGetIDA()

DWORD WINAPI lineGetIDA	(	HLINE	hLine,
		DWORD	dwAddressID,
		HCALL	hCall,
		DWORD	dwSelect,
		LPVARSTRING	lpDeviceID,
		LPCSTR	lpszDeviceClass
	)

Definition at line 665 of file line.c.

{
    FIXME("(%p, %08x, %p, %08x, %p, %s): stub.\n", hLine, dwAddressID, hCall,
                                                   dwSelect, lpDeviceID, lpszDeviceClass);
    return LINEERR_OPERATIONFAILED;
}

lineGetIDW()

DWORD WINAPI lineGetIDW	(	HLINE	hLine,
		DWORD	dwAddressID,
		HCALL	hCall,
		DWORD	dwSelect,
		LPVARSTRING	lpDeviceID,
		LPCWSTR	lpszDeviceClass
	)

Definition at line 653 of file line.c.

{
    FIXME("(%p, %08x, %p, %08x, %p, %s): stub.\n", hLine, dwAddressID, hCall,
                                                   dwSelect, lpDeviceID,
                                                   debugstr_w(lpszDeviceClass));
    return LINEERR_OPERATIONFAILED;
}

lineGetLineDevStatusA()

DWORD WINAPI lineGetLineDevStatusA	(	HLINE	hLine,
		LPLINEDEVSTATUS	lpLineDevStatus
	)

Definition at line 685 of file line.c.

{
    FIXME("(%p, %p): stub.\n", hLine, lpLineDevStatus);
    return 0;
}

lineGetMessage()

DWORD WINAPI lineGetMessage	(	HLINEAPP	hLineApp,
		LPLINEMESSAGE	lpMessage,
		DWORD	dwTimeout
	)

Definition at line 694 of file line.c.

{
    FIXME("(%p, %p, %08x): stub.\n", hLineApp, lpMessage, dwTimeout);
    return 0;
}

lineGetNewCalls()

DWORD WINAPI lineGetNewCalls	(	HLINE	hLine,
		DWORD	dwAddressID,
		DWORD	dwSelect,
		LPLINECALLLIST	lpCallList
	)

Definition at line 703 of file line.c.

{
    FIXME("(%p, %08x, %08x, %p): stub.\n", hLine, dwAddressID, dwSelect, lpCallList);
    return 0;
}

lineGetNumRings()

DWORD WINAPI lineGetNumRings	(	HLINE	hLine,
		DWORD	dwAddressID,
		LPDWORD	lpdwNumRings
	)

Definition at line 712 of file line.c.

{
    FIXME("(%p, %08x, %p): stub.\n", hLine, dwAddressID, lpdwNumRings);
    return 0;
}

lineGetProviderListA()

DWORD WINAPI lineGetProviderListA	(	DWORD	dwAPIVersion,
		LPLINEPROVIDERLIST	lpProviderList
	)

Definition at line 721 of file line.c.

{
    FIXME("(%08x, %p): stub.\n", dwAPIVersion, lpProviderList);
    return LINEERR_OPERATIONFAILED;
}

lineGetProviderListW()

DWORD WINAPI lineGetProviderListW	(	DWORD	dwAPIVersion,
		LPLINEPROVIDERLIST	lpProviderList
	)

Definition at line 730 of file line.c.

{
    FIXME("(%08x, %p): stub.\n", dwAPIVersion, lpProviderList);
    return LINEERR_OPERATIONFAILED;
}

lineGetRequestA()

DWORD WINAPI lineGetRequestA	(	HLINEAPP	hLineApp,
		DWORD	dwRequestMode,
		LPVOID	lpRequestBuffer
	)

Definition at line 739 of file line.c.

{
    FIXME("%p, %08x, %p): stub.\n", hLineApp, dwRequestMode, lpRequestBuffer);
    return 0;
}

lineGetStatusMessages()

DWORD WINAPI lineGetStatusMessages	(	HLINE	hLine,
		LPDWORD	lpdwLineStatus,
		LPDWORD	lpdwAddressStates
	)

Definition at line 748 of file line.c.

{
    FIXME("(%p, %p, %p): stub.\n", hLine, lpdwLineStatus, lpdwAddressStates);
    return 0;
}

lineGetTranslateCapsA()

DWORD WINAPI lineGetTranslateCapsA	(	HLINEAPP	hLineApp,
		DWORD	dwAPIVersion,
		LPLINETRANSLATECAPS	lpTranslateCaps
	)

Definition at line 800 of file line.c.

{
    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) &currentid, &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( _strnicmp(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( _strnicmp(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 CardIDs */
    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( _strnicmp(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( _strnicmp(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 */
}

lineHandoffA()

DWORD WINAPI lineHandoffA	(	HCALL	hCall,
		LPCSTR	lpszFileName,
		DWORD	dwMediaMode
	)

Definition at line 1141 of file line.c.

{
    FIXME("(%p, %s, %08x): stub.\n", hCall, lpszFileName, dwMediaMode);
    return 0;
}

lineHold()

DWORD WINAPI lineHold

(

HCALL

hCall

)

Definition at line 1150 of file line.c.

{
    FIXME("(%p): stub.\n", hCall);
    return 1;
}

lineInitialize()

DWORD WINAPI lineInitialize	(	LPHLINEAPP	lphLineApp,
		HINSTANCE	hInstance,
		LINECALLBACK	lpfnCallback,
		LPCSTR	lpszAppName,
		LPDWORD	lpdwNumDevs
	)

Definition at line 1159 of file line.c.

{
    FIXME("(%p, %p, %p, %s, %p): stub.\n", lphLineApp, hInstance,
      lpfnCallback, debugstr_a(lpszAppName), lpdwNumDevs);
    return 0;
}

lineInitializeExA()

LONG WINAPI lineInitializeExA	(	LPHLINEAPP	lphLineApp,
		HINSTANCE	hInstance,
		LINECALLBACK	lpfnCallback,
		LPCSTR	lpszFriendlyAppName,
		LPDWORD	lpdwNumDevs,
		LPDWORD	lpdwAPIVersion,
		LPLINEINITIALIZEEXPARAMS	lpLineInitializeExParams
	)

Definition at line 1174 of file line.c.

{
    FIXME("(%p, %p, %p, %s, %p, %p, %p): stub.\n", lphLineApp, hInstance,
          lpfnCallback, debugstr_a(lpszFriendlyAppName), lpdwNumDevs, lpdwAPIVersion, lpLineInitializeExParams);
    return 0;
}

lineInitializeExW()

LONG WINAPI lineInitializeExW	(	LPHLINEAPP	lphLineApp,
		HINSTANCE	hInstance,
		LINECALLBACK	lpfnCallback,
		LPCWSTR	lpszFriendlyAppName,
		LPDWORD	lpdwNumDevs,
		LPDWORD	lpdwAPIVersion,
		LPLINEINITIALIZEEXPARAMS	lpLineInitializeExParams
	)

Definition at line 1184 of file line.c.

{
    FIXME("(%p, %p, %p, %s, %p, %p, %p): stub.\n", lphLineApp, hInstance,
          lpfnCallback, debugstr_w(lpszFriendlyAppName), lpdwNumDevs, lpdwAPIVersion, lpLineInitializeExParams);
    return 0;
}

lineMakeCallA()

DWORD WINAPI lineMakeCallA	(	HLINE	hLine,
		LPHCALL	lphCall,
		LPCSTR	lpszDestAddress,
		DWORD	dwCountryCode,
		LPLINECALLPARAMS	lpCallParams
	)

Definition at line 1205 of file line.c.

{
    FIXME("(%p, %p, %s, %08x, %p): stub.\n", hLine, lphCall, lpszDestAddress,
                                             dwCountryCode, lpCallParams);
    return LINEERR_OPERATIONFAILED;
}

lineMakeCallW()

DWORD WINAPI lineMakeCallW	(	HLINE	hLine,
		LPHCALL	lphCall,
		LPCWSTR	lpszDestAddress,
		DWORD	dwCountryCode,
		LPLINECALLPARAMS	lpCallParams
	)

Definition at line 1194 of file line.c.

{
    FIXME("(%p, %p, %s, %08x, %p): stub.\n", hLine, lphCall, debugstr_w(lpszDestAddress),
                                             dwCountryCode, lpCallParams);
    return LINEERR_OPERATIONFAILED;
}

lineMonitorDigits()

DWORD WINAPI lineMonitorDigits	(	HCALL	hCall,
		DWORD	dwDigitModes
	)

Definition at line 1216 of file line.c.

{
    FIXME("(%p, %08x): stub.\n", hCall, dwDigitModes);
    return 0;
}

lineMonitorMedia()

DWORD WINAPI lineMonitorMedia	(	HCALL	hCall,
		DWORD	dwMediaModes
	)

Definition at line 1225 of file line.c.

{
    FIXME("(%p, %08x): stub.\n", hCall, dwMediaModes);
    return 0;
}

lineMonitorTones()

DWORD WINAPI lineMonitorTones	(	HCALL	hCall,
		LPLINEMONITORTONE	lpToneList,
		DWORD	dwNumEntries
	)

Definition at line 1234 of file line.c.

{
    FIXME("(%p, %p, %08x): stub.\n", hCall, lpToneList, dwNumEntries);
    return 0;
}

lineNegotiateAPIVersion()

DWORD WINAPI lineNegotiateAPIVersion	(	HLINEAPP	hLineApp,
		DWORD	dwDeviceID,
		DWORD	dwAPILowVersion,
		DWORD	dwAPIHighVersion,
		LPDWORD	lpdwAPIVersion,
		LPLINEEXTENSIONID	lpExtensionID
	)

Definition at line 1243 of file line.c.

{
    static int warn_once;
 
    if(!warn_once++)
        FIXME("(%p, %d, %d, %d, %p, %p): stub.\n", hLineApp, dwDeviceID,
              dwAPILowVersion, dwAPIHighVersion, lpdwAPIVersion, lpExtensionID);
    *lpdwAPIVersion = dwAPIHighVersion;
    return 0;
}

lineNegotiateExtVersion()

DWORD WINAPI lineNegotiateExtVersion	(	HLINEAPP	hLineApp,
		DWORD	dwDeviceID,
		DWORD	dwAPIVersion,
		DWORD	dwExtLowVersion,
		DWORD	dwExtHighVersion,
		LPDWORD	lpdwExtVersion
	)

Definition at line 1264 of file line.c.

{
    FIXME("stub.\n");
    return 0;
}

lineOpenA()

DWORD WINAPI lineOpenA	(	HLINEAPP	hLineApp,
		DWORD	dwDeviceID,
		LPHLINE	lphLine,
		DWORD	dwAPIVersion,
		DWORD	dwExtVersion,
		DWORD	dwCallbackInstance,
		DWORD	dwPrivileges,
		DWORD	dwMediaModes,
		LPLINECALLPARAMS	lpCallParams
	)

Definition at line 1282 of file line.c.

{
    FIXME("stub.\n");
    return 0;
}

lineOpenW()

DWORD WINAPI lineOpenW	(	HLINEAPP	hLineApp,
		DWORD	dwDeviceID,
		LPHLINE	lphLine,
		DWORD	dwAPIVersion,
		DWORD	dwExtVersion,
		DWORD	dwCallbackInstance,
		DWORD	dwPrivileges,
		DWORD	dwMediaModes,
		LPLINECALLPARAMS	lpCallParams
	)

Definition at line 1273 of file line.c.

{
    FIXME("stub.\n");
    return 0;
}

lineParkA()

DWORD WINAPI lineParkA	(	HCALL	hCall,
		DWORD	dwParkMode,
		LPCSTR	lpszDirAddress,
		LPVARSTRING	lpNonDirAddress
	)

Definition at line 1291 of file line.c.

{
    FIXME("(%p, %08x, %s, %p): stub.\n", hCall, dwParkMode, lpszDirAddress, lpNonDirAddress);
    return 1;
}

linePickupA()

DWORD WINAPI linePickupA	(	HLINE	hLine,
		DWORD	dwAddressID,
		LPHCALL	lphCall,
		LPCSTR	lpszDestAddress,
		LPCSTR	lpszGroupID
	)

Definition at line 1300 of file line.c.

{
    FIXME("(%p, %08x, %p, %s, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress, lpszGroupID);
    return 1;
}

linePrepareAddToConferenceA()

DWORD WINAPI linePrepareAddToConferenceA	(	HCALL	hConfCall,
		LPHCALL	lphConsultCall,
		LPLINECALLPARAMS	lpCallParams
	)

Definition at line 1309 of file line.c.

{
    FIXME("(%p, %p, %p): stub.\n", hConfCall, lphConsultCall, lpCallParams);
    return 1;
}

lineRedirectA()

DWORD WINAPI lineRedirectA	(	HCALL	hCall,
		LPCSTR	lpszDestAddress,
		DWORD	dwCountryCode
	)

Definition at line 1318 of file line.c.

                        {
 
  FIXME(": stub.\n");
  return 1;
}

lineRegisterRequestRecipient()

DWORD WINAPI lineRegisterRequestRecipient	(	HLINEAPP	hLineApp,
		DWORD	dwRegistrationInstance,
		DWORD	dwRequestMode,
		DWORD	dwEnable
	)

Definition at line 1330 of file line.c.

{
    FIXME("(%p, %08x, %08x, %08x): stub.\n", hLineApp, dwRegistrationInstance, dwRequestMode, dwEnable);
    return 1;
}

lineReleaseUserUserInfo()

DWORD WINAPI lineReleaseUserUserInfo

(

HCALL

hCall

)

Definition at line 1339 of file line.c.

{
    FIXME("(%p): stub.\n", hCall);
    return 1;
}

lineRemoveFromConference()

DWORD WINAPI lineRemoveFromConference

(

HCALL

hCall

)

Definition at line 1348 of file line.c.

{
    FIXME("(%p): stub.\n", hCall);
    return 1;
}

lineRemoveProvider()

DWORD WINAPI lineRemoveProvider	(	DWORD	dwPermanentProviderID,
		HWND	hwndOwner
	)

Definition at line 1357 of file line.c.

{
    FIXME("(%08x, %p): stub.\n", dwPermanentProviderID, hwndOwner);
    return 1;
}

lineSecureCall()

DWORD WINAPI lineSecureCall

(

HCALL

hCall

)

Definition at line 1366 of file line.c.

{
    FIXME("(%p): stub.\n", hCall);
    return 1;
}

lineSendUserUserInfo()

DWORD WINAPI lineSendUserUserInfo	(	HCALL	hCall,
		LPCSTR	lpsUserUserInfo,
		DWORD	dwSize
	)

Definition at line 1375 of file line.c.

{
    FIXME("(%p, %s, %08x): stub.\n", hCall, lpsUserUserInfo, dwSize);
    return 1;
}

lineSetAppPriorityA()

DWORD WINAPI lineSetAppPriorityA	(	LPCSTR	lpszAppFilename,
		DWORD	dwMediaMode,
		LPLINEEXTENSIONID const	lpExtensionID,
		DWORD	dwRequestMode,
		LPCSTR	lpszExtensionName,
		DWORD	dwPriority
	)

Definition at line 1384 of file line.c.

{
    FIXME("(%s, %08x, %p, %08x, %s, %08x): stub.\n", lpszAppFilename, dwMediaMode, lpExtensionID, dwRequestMode, lpszExtensionName, dwPriority);
    return 0;
}

lineSetAppSpecific()

DWORD WINAPI lineSetAppSpecific	(	HCALL	hCall,
		DWORD	dwAppSpecific
	)

Definition at line 1393 of file line.c.

{
    FIXME("(%p, %08x): stub.\n", hCall, dwAppSpecific);
    return 0;
}

lineSetCallParams()

DWORD WINAPI lineSetCallParams	(	HCALL	hCall,
		DWORD	dwBearerMode,
		DWORD	dwMinRate,
		DWORD	dwMaxRate,
		LPLINEDIALPARAMS	lpDialParams
	)

Definition at line 1402 of file line.c.

{
    FIXME("(%p, %08x, %08x, %08x, %p): stub.\n", hCall, dwBearerMode, dwMinRate, dwMaxRate, lpDialParams);
    return 1;
}

lineSetCallPrivilege()

DWORD WINAPI lineSetCallPrivilege	(	HCALL	hCall,
		DWORD	dwCallPrivilege
	)

Definition at line 1411 of file line.c.

{
    FIXME("(%p, %08x): stub.\n", hCall, dwCallPrivilege);
    return 0;
}

lineSetCurrentLocation()

DWORD WINAPI lineSetCurrentLocation	(	HLINEAPP	hLineApp,
		DWORD	dwLocation
	)

Definition at line 1420 of file line.c.

{
    FIXME("(%p, %08x): stub.\n", hLineApp, dwLocation);
    return 0;
}

lineSetDevConfigA()

DWORD WINAPI lineSetDevConfigA	(	DWORD	dwDeviceID,
		LPVOID	lpDeviceConfig,
		DWORD	dwSize,
		LPCSTR	lpszDeviceClass
	)

Definition at line 1429 of file line.c.

{
    FIXME("(%08x, %p, %08x, %s): stub.\n", dwDeviceID, lpDeviceConfig, dwSize, lpszDeviceClass);
    return 0;
}

lineSetMediaControl()

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
	)

Definition at line 1438 of file line.c.

{
    FIXME(": stub.\n");
    return 0;
}

lineSetMediaMode()

DWORD WINAPI lineSetMediaMode	(	HCALL	hCall,
		DWORD	dwMediaModes
	)

Definition at line 1459 of file line.c.

{
    FIXME("(%p, %08x): stub.\n", hCall, dwMediaModes);
    return 0;
}

lineSetNumRings()

DWORD WINAPI lineSetNumRings	(	HLINE	hLine,
		DWORD	dwAddressID,
		DWORD	dwNumRings
	)

Definition at line 1468 of file line.c.

{
    FIXME("(%p, %08x, %08x): stub.\n", hLine, dwAddressID, dwNumRings);
    return 0;
}

lineSetStatusMessages()

DWORD WINAPI lineSetStatusMessages	(	HLINE	hLine,
		DWORD	dwLineStates,
		DWORD	dwAddressStates
	)

Definition at line 1477 of file line.c.

{
    FIXME("(%p, %08x, %08x): stub.\n", hLine, dwLineStates, dwAddressStates);
    return 0;
}

lineSetTerminal()

DWORD WINAPI lineSetTerminal	(	HLINE	hLine,
		DWORD	dwAddressID,
		HCALL	hCall,
		DWORD	dwSelect,
		DWORD	dwTerminalModes,
		DWORD	dwTerminalID,
		DWORD	bEnable
	)

Definition at line 1486 of file line.c.

{
    FIXME("(%p, %08x, %p, %08x, %08x, %08x, %08x): stub.\n", hLine, dwAddressID, hCall, dwSelect, dwTerminalModes, dwTerminalID, bEnable);
    return 1;
}

lineSetTollListA()

DWORD WINAPI lineSetTollListA	(	HLINEAPP	hLineApp,
		DWORD	dwDeviceID,
		LPCSTR	lpszAddressIn,
		DWORD	dwTollListOption
	)

Definition at line 1495 of file line.c.

{
    FIXME("(%p, %08x, %s, %08x): stub.\n", hLineApp, dwDeviceID, lpszAddressIn, dwTollListOption);
    return 0;
}

lineSetupConferenceA()

DWORD WINAPI lineSetupConferenceA	(	HCALL	hCall,
		HLINE	hLine,
		LPHCALL	lphConfCall,
		LPHCALL	lphConsultCall,
		DWORD	dwNumParties,
		LPLINECALLPARAMS	lpCallParams
	)

Definition at line 1504 of file line.c.

{
    FIXME("(%p, %p, %p, %p, %08x, %p): stub.\n", hCall, hLine, lphConfCall, lphConsultCall, dwNumParties, lpCallParams);
    return 1;
}

lineSetupTransferA()

DWORD WINAPI lineSetupTransferA	(	HCALL	hCall,
		LPHCALL	lphConsultCall,
		LPLINECALLPARAMS	lpCallParams
	)

Definition at line 1513 of file line.c.

{
    FIXME("(%p, %p, %p): stub.\n", hCall, lphConsultCall, lpCallParams);
    return 1;
}

lineShutdown()

DWORD WINAPI lineShutdown

(

HLINEAPP

hLineApp

)

Definition at line 1522 of file line.c.

{
    FIXME("(%p): stub.\n", hLineApp);
    return 0;
}

lineSwapHold()

DWORD WINAPI lineSwapHold	(	HCALL	hActiveCall,
		HCALL	hHeldCall
	)

Definition at line 1531 of file line.c.

{
    FIXME("(active: %p, held: %p): stub.\n", hActiveCall, hHeldCall);
    return 1;
}

lineTranslateAddressA()

DWORD WINAPI lineTranslateAddressA	(	HLINEAPP	hLineApp,
		DWORD	dwDeviceID,
		DWORD	dwAPIVersion,
		LPCSTR	lpszAddressIn,
		DWORD	dwCard,
		DWORD	dwTranslateOptions,
		LPLINETRANSLATEOUTPUT	lpTranslateOutput
	)

Definition at line 1540 of file line.c.

{
    FIXME("(%p, %08x, %08x, %s, %08x, %08x, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, lpszAddressIn, dwCard, dwTranslateOptions, lpTranslateOutput);
    return 0;
}

lineTranslateAddressW()

DWORD WINAPI lineTranslateAddressW	(	HLINEAPP	hLineApp,
		DWORD	dwDeviceID,
		DWORD	dwAPIVersion,
		LPCWSTR	lpszAddressIn,
		DWORD	dwCard,
		DWORD	dwTranslateOptions,
		LPLINETRANSLATEOUTPUT	lpTranslateOutput
	)

Definition at line 1549 of file line.c.

{
    FIXME("(%p, %08x, %08x, %s, %08x, %08x, %p): stub.\n", hLineApp, dwDeviceID, dwAPIVersion,
            debugstr_w(lpszAddressIn), dwCard, dwTranslateOptions, lpTranslateOutput);
    return 0;
}

lineTranslateDialogA()

DWORD WINAPI lineTranslateDialogA	(	HLINEAPP	hLineApp,
		DWORD	dwDeviceID,
		DWORD	dwAPIVersion,
		HWND	hwndOwner,
		LPCSTR	lpszAddressIn
	)

Definition at line 1561 of file line.c.

{
    FIXME("(%p, %08x, %08x, %p, %s): stub.\n", hLineApp, dwDeviceID, dwAPIVersion, hwndOwner, lpszAddressIn);
    return 0;
}

lineTranslateDialogW()

DWORD WINAPI lineTranslateDialogW	(	HLINEAPP	hLineApp,
		DWORD	dwDeviceID,
		DWORD	dwAPIVersion,
		HWND	hwndOwner,
		LPCWSTR	lpszAddressIn
	)

Definition at line 1570 of file line.c.

{
    FIXME("(%p, %08x, %08x, %p, %s): stub.\n", hLineApp, dwDeviceID,
            dwAPIVersion, hwndOwner, debugstr_w(lpszAddressIn));
    return 0;
}

lineUncompleteCall()

DWORD WINAPI lineUncompleteCall	(	HLINE	hLine,
		DWORD	dwCompletionID
	)

Definition at line 1581 of file line.c.

{
    FIXME("(%p, %08x): stub.\n", hLine, dwCompletionID);
    return 1;
}

lineUnhold()

DWORD WINAPI lineUnhold

(

HCALL

hCall

)

Definition at line 1590 of file line.c.

{
    FIXME("(%p): stub.\n", hCall);
    return 1;
}

lineUnparkA()

DWORD WINAPI lineUnparkA	(	HLINE	hLine,
		DWORD	dwAddressID,
		LPHCALL	lphCall,
		LPCSTR	lpszDestAddress
	)

Definition at line 1599 of file line.c.

{
    FIXME("(%p, %08x, %p, %s): stub.\n", hLine, dwAddressID, lphCall, lpszDestAddress);
    return 1;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

tapi

)

Variable Documentation

szCardsKey

const char szCardsKey[]

static

Initial value:

=
    "Software\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Cards"

Definition at line 43 of file line.c.

Referenced by lineGetTranslateCapsA().

szCountrylistKey

const char szCountrylistKey[]

static

Initial value:

=
    "Software\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Country List"

Definition at line 39 of file line.c.

Referenced by lineGetCountryA().

szLocationsKey

const char szLocationsKey[]

static

Initial value:

=
    "Software\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Locations"

Definition at line 41 of file line.c.

Referenced by lineGetTranslateCapsA().