mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
666 lines
17 KiB
666 lines
17 KiB
#include "SDKInternal.h"
|
|
#include <atlbase.h>
|
|
|
|
#if(_WIN32_WINNT < 0x0500)
|
|
extern "C"
|
|
WINUSERAPI
|
|
BOOL
|
|
WINAPI
|
|
AllowSetForegroundWindow(
|
|
DWORD dwProcessId);
|
|
|
|
#define ASFW_ANY ((DWORD)-1)
|
|
#endif
|
|
|
|
|
|
/* [local] */ HRESULT STDMETHODCALLTYPE INmObject_CallDialog_Proxy(
|
|
INmObject __RPC_FAR * This,
|
|
/* [in] */ long hwnd,
|
|
/* [in] */ int options)
|
|
{
|
|
AllowSetForegroundWindow(ASFW_ANY);
|
|
return INmObject_RemoteCallDialog_Proxy(This, hwnd, options);
|
|
}
|
|
|
|
|
|
/* [call_as] */ HRESULT STDMETHODCALLTYPE INmObject_CallDialog_Stub(
|
|
INmObject __RPC_FAR * This,
|
|
/* [in] */ long hwnd,
|
|
/* [in] */ int options)
|
|
{
|
|
return This->CallDialog(hwnd, options);
|
|
}
|
|
|
|
|
|
/* [local] */ HRESULT STDMETHODCALLTYPE INmObject_ShowLocal_Proxy(
|
|
INmObject __RPC_FAR * This,
|
|
/* [in] */ NM_APPID appId)
|
|
{
|
|
AllowSetForegroundWindow(ASFW_ANY);
|
|
return INmObject_RemoteShowLocal_Proxy(This, appId);
|
|
}
|
|
|
|
/* [call_as] */ HRESULT STDMETHODCALLTYPE INmObject_ShowLocal_Stub(
|
|
INmObject __RPC_FAR * This,
|
|
/* [in] */ NM_APPID appId)
|
|
{
|
|
return This->ShowLocal(appId);
|
|
}
|
|
|
|
|
|
|
|
/* [local] */ HRESULT STDMETHODCALLTYPE INmManager_Initialize_Proxy(
|
|
INmManager __RPC_FAR * This,
|
|
/* [out][in] */ ULONG __RPC_FAR *puOptions,
|
|
/* [out][in] */ ULONG __RPC_FAR *puchCaps)
|
|
{
|
|
|
|
ULONG uOptions = puOptions ? *puOptions : NM_INIT_NORMAL;
|
|
ULONG uchCaps = puchCaps ? *puchCaps : NMCH_ALL;
|
|
|
|
HRESULT hr = INmManager_RemoteInitialize_Proxy(This, &uOptions, &uchCaps);
|
|
|
|
if(puOptions)
|
|
{
|
|
*puOptions = uOptions;
|
|
}
|
|
|
|
if(puchCaps)
|
|
{
|
|
*puchCaps = uchCaps;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/* [call_as] */ HRESULT STDMETHODCALLTYPE INmManager_Initialize_Stub(
|
|
INmManager __RPC_FAR * This,
|
|
/* [out][in] */ ULONG __RPC_FAR *puOptions,
|
|
/* [out][in] */ ULONG __RPC_FAR *puchCaps)
|
|
{
|
|
|
|
return This->Initialize(puOptions, puchCaps);
|
|
}
|
|
|
|
|
|
/* [local] */ HRESULT STDMETHODCALLTYPE INmManager_CreateConference_Proxy(
|
|
INmManager __RPC_FAR * This,
|
|
/* [out] */ INmConference __RPC_FAR *__RPC_FAR *ppConference,
|
|
/* [in] */ BSTR bstrName,
|
|
/* [in] */ BSTR bstrPassword,
|
|
/* [in] */ ULONG uchCaps)
|
|
{
|
|
INmConference* pConf = ppConference ? *ppConference : NULL;
|
|
|
|
// These may be OLECHARs and not BSTR
|
|
CComBSTR _bstrName = bstrName;
|
|
CComBSTR _bstrPassword = bstrPassword;
|
|
|
|
HRESULT hr = INmManager_RemoteCreateConference_Proxy(This, &pConf, _bstrName, _bstrPassword, uchCaps);
|
|
|
|
if(ppConference)
|
|
{
|
|
*ppConference = pConf;
|
|
}
|
|
else if(SUCCEEDED(hr))
|
|
{
|
|
// Since the client does not want this pointer, we discard it
|
|
pConf->Release();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/* [call_as] */ HRESULT STDMETHODCALLTYPE INmManager_CreateConference_Stub(
|
|
INmManager __RPC_FAR * This,
|
|
/* [out] */ INmConference __RPC_FAR *__RPC_FAR *ppConference,
|
|
/* [in] */ BSTR bstrName,
|
|
/* [in] */ BSTR bstrPassword,
|
|
/* [in] */ ULONG uchCaps)
|
|
{
|
|
return This->CreateConference(ppConference, bstrName, bstrPassword, uchCaps);
|
|
}
|
|
|
|
/* [local] */ HRESULT STDMETHODCALLTYPE INmManager_CreateCall_Proxy(
|
|
INmManager __RPC_FAR * This,
|
|
/* [out] */ INmCall __RPC_FAR *__RPC_FAR *ppCall,
|
|
/* [in] */ NM_CALL_TYPE callType,
|
|
/* [in] */ NM_ADDR_TYPE addrType,
|
|
/* [in] */ BSTR bstrAddr,
|
|
/* [in] */ INmConference __RPC_FAR *pConference)
|
|
{
|
|
INmCall* pCall = NULL;
|
|
|
|
// These may be OLECHARs and not BSTR
|
|
CComBSTR _bstrAddr = bstrAddr;
|
|
|
|
|
|
HRESULT hr = INmManager_RemoteCreateCall_Proxy(This, &pCall, callType, addrType, _bstrAddr, pConference);
|
|
|
|
if(ppCall)
|
|
{
|
|
*ppCall = pCall;
|
|
}
|
|
else if(SUCCEEDED(hr))
|
|
{
|
|
// Since the client does not want this pointer, we discard it
|
|
pCall->Release();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/* [call_as] */ HRESULT STDMETHODCALLTYPE INmManager_CreateCall_Stub(
|
|
INmManager __RPC_FAR * This,
|
|
/* [out] */ INmCall __RPC_FAR *__RPC_FAR *ppCall,
|
|
/* [in] */ NM_CALL_TYPE callType,
|
|
/* [in] */ NM_ADDR_TYPE addrType,
|
|
/* [in] */ BSTR bstrAddr,
|
|
/* [in] */ INmConference __RPC_FAR *pConference)
|
|
{
|
|
return This->CreateCall(ppCall, callType, addrType, bstrAddr, pConference);
|
|
}
|
|
|
|
/* [local] */ HRESULT STDMETHODCALLTYPE INmManager_CallConference_Proxy(
|
|
INmManager __RPC_FAR * This,
|
|
/* [out] */ INmCall __RPC_FAR *__RPC_FAR *ppCall,
|
|
/* [in] */ NM_CALL_TYPE callType,
|
|
/* [in] */ NM_ADDR_TYPE addrType,
|
|
/* [in] */ BSTR bstrAddr,
|
|
/* [in] */ BSTR bstrName,
|
|
/* [in] */ BSTR bstrPassword)
|
|
{
|
|
INmCall* pCall = ppCall ? *ppCall : NULL;
|
|
|
|
CComBSTR _bstrAddr = bstrAddr;
|
|
CComBSTR _bstrName = bstrName;
|
|
CComBSTR _bstrPassword = bstrPassword;
|
|
|
|
HRESULT hr = INmManager_RemoteCallConference_Proxy(This, &pCall, callType, addrType, _bstrAddr, _bstrName, _bstrPassword);
|
|
|
|
if(ppCall)
|
|
{
|
|
*ppCall = pCall;
|
|
}
|
|
else if(SUCCEEDED(hr))
|
|
{
|
|
// Since the client does not want this pointer, we discard it
|
|
pCall->Release();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/* [call_as] */ HRESULT STDMETHODCALLTYPE INmManager_CallConference_Stub(
|
|
INmManager __RPC_FAR * This,
|
|
/* [out] */ INmCall __RPC_FAR *__RPC_FAR *ppCall,
|
|
/* [in] */ NM_CALL_TYPE callType,
|
|
/* [in] */ NM_ADDR_TYPE addrType,
|
|
/* [in] */ BSTR bstrAddr,
|
|
/* [in] */ BSTR bstrName,
|
|
/* [in] */ BSTR bstrPassword)
|
|
{
|
|
return This->CallConference(ppCall, callType, addrType, bstrAddr, bstrName, bstrPassword);
|
|
}
|
|
|
|
/* [local] */ HRESULT STDMETHODCALLTYPE INmConference_CreateDataChannel_Proxy(
|
|
INmConference __RPC_FAR * This,
|
|
/* [out] */ INmChannelData __RPC_FAR *__RPC_FAR *ppChannel,
|
|
/* [in] */ REFGUID rguid)
|
|
{
|
|
INmChannelData* pChan = ppChannel ? *ppChannel : NULL;
|
|
HRESULT hr = INmConference_RemoteCreateDataChannel_Proxy(This, &pChan, rguid);
|
|
if(ppChannel)
|
|
{
|
|
*ppChannel = pChan;
|
|
}
|
|
else if(SUCCEEDED(hr))
|
|
{
|
|
// Since the client does not want this pointer, we discard it
|
|
pChan->Release();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/* [call_as] */ HRESULT STDMETHODCALLTYPE INmConference_CreateDataChannel_Stub(
|
|
INmConference __RPC_FAR * This,
|
|
/* [out] */ INmChannelData __RPC_FAR *__RPC_FAR *ppChannel,
|
|
/* [in] */ REFGUID rguid)
|
|
{
|
|
return This->CreateDataChannel(ppChannel, rguid);
|
|
}
|
|
|
|
|
|
/* [local] */ HRESULT STDMETHODCALLTYPE INmChannelFt_SendFile_Proxy(
|
|
INmChannelFt __RPC_FAR * This,
|
|
/* [out] */ INmFt __RPC_FAR *__RPC_FAR *ppFt,
|
|
/* [in] */ INmMember __RPC_FAR *pMember,
|
|
/* [in] */ BSTR bstrFile,
|
|
/* [in] */ ULONG uOptions)
|
|
{
|
|
INmFt* pFt = ppFt ? *ppFt : NULL;
|
|
CComBSTR _bstrFile = bstrFile;
|
|
|
|
HRESULT hr = INmChannelFt_RemoteSendFile_Proxy(This, &pFt, pMember, _bstrFile, uOptions);
|
|
if(ppFt)
|
|
{
|
|
*ppFt = pFt;
|
|
}
|
|
else if(SUCCEEDED(hr))
|
|
{
|
|
// Since the client does not want this pointer, we discard it
|
|
pFt->Release();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/* [call_as] */ HRESULT STDMETHODCALLTYPE INmChannelFt_SendFile_Stub(
|
|
INmChannelFt __RPC_FAR * This,
|
|
/* [out] */ INmFt __RPC_FAR *__RPC_FAR *ppFt,
|
|
/* [in] */ INmMember __RPC_FAR *pMember,
|
|
/* [in] */ BSTR bstrFile,
|
|
/* [in] */ ULONG uOptions)
|
|
{
|
|
return This->SendFile(ppFt, pMember, bstrFile, uOptions);
|
|
}
|
|
|
|
|
|
/* [local] */ HRESULT STDMETHODCALLTYPE INmChannelFt_SetReceiveFileDir_Proxy(
|
|
INmChannelFt __RPC_FAR * This,
|
|
/* [in] */ BSTR bstrDir)
|
|
{
|
|
CComBSTR _bstrDir = bstrDir;
|
|
return INmChannelFt_RemoteSetReceiveFileDir_Proxy(This, _bstrDir);
|
|
}
|
|
|
|
|
|
/* [call_as] */ HRESULT STDMETHODCALLTYPE INmChannelFt_SetReceiveFileDir_Stub(
|
|
INmChannelFt __RPC_FAR * This,
|
|
/* [in] */ BSTR bstrDir)
|
|
{
|
|
return This->SetReceiveFileDir(bstrDir);
|
|
}
|
|
|
|
|
|
/* [local] */ HRESULT STDMETHODCALLTYPE IEnumNmConference_Next_Proxy(
|
|
IEnumNmConference __RPC_FAR * This,
|
|
/* [in] */ ULONG cConference,
|
|
/* [out] */ INmConference __RPC_FAR *__RPC_FAR *rgpConference,
|
|
/* [out] */ ULONG __RPC_FAR *pcFetched)
|
|
{
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
// The user can pass NULL for rpgConference and set cConference to 0
|
|
// to get the number of items, but they have to BOTH be set!
|
|
if ((0 == cConference) && (NULL == rgpConference) && (NULL != pcFetched))
|
|
{
|
|
INmConference *pConference = NULL;
|
|
cConference = 1;
|
|
|
|
// Return the number of remaining elements
|
|
ULONG ulItems = *pcFetched = 0;
|
|
|
|
hr = IEnumNmConference_RemoteNext_Proxy(This, cConference, &pConference, pcFetched, &ulItems, TRUE);
|
|
|
|
*pcFetched = ulItems;
|
|
|
|
return hr;
|
|
}
|
|
|
|
if ((NULL == rgpConference) || ((NULL == pcFetched) && (cConference != 1)))
|
|
return E_POINTER;
|
|
|
|
ULONG cFetched = pcFetched ? *pcFetched : 0;
|
|
|
|
// This parameter is only used when we have to determine the number of elements
|
|
ULONG ulUnused;
|
|
|
|
hr = IEnumNmConference_RemoteNext_Proxy(This, cConference, rgpConference, &cFetched, &ulUnused, FALSE);
|
|
|
|
if(pcFetched)
|
|
{
|
|
*pcFetched = cFetched;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/* [call_as] */ HRESULT STDMETHODCALLTYPE IEnumNmConference_Next_Stub(
|
|
IEnumNmConference __RPC_FAR * This,
|
|
/* [in] */ ULONG cConference,
|
|
/* [length_is][size_is][out] */ INmConference __RPC_FAR *__RPC_FAR *rgpConference,
|
|
/* [out] */ ULONG __RPC_FAR *pcFetched,
|
|
/* [out] */ ULONG __RPC_FAR *pcItems,
|
|
/* [in] */ BOOL bGetNumberRemaining)
|
|
{
|
|
if(bGetNumberRemaining)
|
|
{
|
|
HRESULT hr = This->Next(0, NULL, pcFetched);
|
|
|
|
// Store the numebr of items
|
|
*pcItems = *pcFetched;
|
|
|
|
// This is so the marshaller does not think that *rgpConference has valid info
|
|
*pcFetched = 0;
|
|
return hr;
|
|
}
|
|
|
|
return This->Next(cConference, rgpConference, pcFetched);
|
|
|
|
}
|
|
|
|
|
|
/* [local] */ HRESULT STDMETHODCALLTYPE IEnumNmMember_Next_Proxy(
|
|
IEnumNmMember __RPC_FAR * This,
|
|
/* [in] */ ULONG cMember,
|
|
/* [out] */ INmMember __RPC_FAR *__RPC_FAR *rgpMember,
|
|
/* [out] */ ULONG __RPC_FAR *pcFetched)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// The user can pass NULL for rpgMember and set cMember to 0
|
|
// to get the number of items, but they have to BOTH be set!
|
|
if ((0 == cMember) && (NULL == rgpMember) && (NULL != pcFetched))
|
|
{
|
|
INmMember *pMember = NULL;
|
|
cMember = 1;
|
|
|
|
// Return the number of remaining elements
|
|
ULONG ulItems = *pcFetched = 0;
|
|
|
|
hr = IEnumNmMember_RemoteNext_Proxy(This, cMember, &pMember, pcFetched, &ulItems, TRUE);
|
|
|
|
*pcFetched = ulItems;
|
|
|
|
return hr;
|
|
}
|
|
|
|
if ((NULL == rgpMember) || ((NULL == pcFetched) && (cMember != 1)))
|
|
return E_POINTER;
|
|
|
|
ULONG cFetched = pcFetched ? *pcFetched : 0;
|
|
|
|
// This parameter is only used when we have to determine the number of elements
|
|
ULONG ulUnused;
|
|
|
|
hr = IEnumNmMember_RemoteNext_Proxy(This, cMember, rgpMember, &cFetched, &ulUnused, FALSE);
|
|
|
|
if(pcFetched)
|
|
{
|
|
*pcFetched = cFetched;
|
|
}
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
|
|
/* [call_as] */ HRESULT STDMETHODCALLTYPE IEnumNmMember_Next_Stub(
|
|
IEnumNmMember __RPC_FAR * This,
|
|
/* [in] */ ULONG cMember,
|
|
/* [length_is][size_is][out] */ INmMember __RPC_FAR *__RPC_FAR *rgpMember,
|
|
/* [out] */ ULONG __RPC_FAR *pcFetched,
|
|
/* [out] */ ULONG __RPC_FAR *pcItems,
|
|
/* [in] */ BOOL bGetNumberRemaining)
|
|
{
|
|
if(bGetNumberRemaining)
|
|
{
|
|
HRESULT hr = This->Next(0, NULL, pcFetched);
|
|
|
|
// Store the numebr of items
|
|
*pcItems = *pcFetched;
|
|
|
|
// This is so the marshaller does not think that *rgpMember has valid info
|
|
*pcFetched = 0;
|
|
return hr;
|
|
}
|
|
|
|
return This->Next(cMember, rgpMember, pcFetched);
|
|
}
|
|
|
|
|
|
|
|
/* [local] */ HRESULT STDMETHODCALLTYPE IEnumNmChannel_Next_Proxy(
|
|
IEnumNmChannel __RPC_FAR * This,
|
|
/* [in] */ ULONG cChannel,
|
|
/* [out] */ INmChannel __RPC_FAR *__RPC_FAR *rgpChannel,
|
|
/* [out] */ ULONG __RPC_FAR *pcFetched)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// The user can pass NULL for rpgChannel and set cChannel to 0
|
|
// to get the number of items, but they have to BOTH be set!
|
|
if ((0 == cChannel) && (NULL == rgpChannel) && (NULL != pcFetched))
|
|
{
|
|
INmChannel *pChannel = NULL;
|
|
cChannel = 1;
|
|
|
|
// Return the number of remaining elements
|
|
ULONG ulItems = *pcFetched = 0;
|
|
|
|
hr = IEnumNmChannel_RemoteNext_Proxy(This, cChannel, &pChannel, pcFetched, &ulItems, TRUE);
|
|
|
|
*pcFetched = ulItems;
|
|
|
|
return hr;
|
|
}
|
|
|
|
if ((NULL == rgpChannel) || ((NULL == pcFetched) && (cChannel != 1)))
|
|
return E_POINTER;
|
|
|
|
ULONG cFetched = pcFetched ? *pcFetched : 0;
|
|
|
|
// This parameter is only used when we have to determine the number of elements
|
|
ULONG ulUnused;
|
|
|
|
hr = IEnumNmChannel_RemoteNext_Proxy(This, cChannel, rgpChannel, &cFetched, &ulUnused, FALSE);
|
|
|
|
if(pcFetched)
|
|
{
|
|
*pcFetched = cFetched;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/* [call_as] */ HRESULT STDMETHODCALLTYPE IEnumNmChannel_Next_Stub(
|
|
IEnumNmChannel __RPC_FAR * This,
|
|
/* [in] */ ULONG cChannel,
|
|
/* [length_is][size_is][out] */ INmChannel __RPC_FAR *__RPC_FAR *rgpChannel,
|
|
/* [out] */ ULONG __RPC_FAR *pcFetched,
|
|
/* [out] */ ULONG __RPC_FAR *pcItems,
|
|
/* [in] */ BOOL bGetNumberRemaining)
|
|
{
|
|
if(bGetNumberRemaining)
|
|
{
|
|
HRESULT hr = This->Next(0, NULL, pcFetched);
|
|
|
|
// Store the numebr of items
|
|
*pcItems = *pcFetched;
|
|
|
|
// This is so the marshaller does not think that *rgpChannel has valid info
|
|
*pcFetched = 0;
|
|
return hr;
|
|
}
|
|
|
|
return This->Next(cChannel, rgpChannel, pcFetched);
|
|
}
|
|
|
|
|
|
/* [local] */ HRESULT STDMETHODCALLTYPE IEnumNmCall_Next_Proxy(
|
|
IEnumNmCall __RPC_FAR * This,
|
|
/* [in] */ ULONG cCall,
|
|
/* [out] */ INmCall __RPC_FAR *__RPC_FAR *rgpCall,
|
|
/* [out] */ ULONG __RPC_FAR *pcFetched)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// The user can pass NULL for rpgCall and set cCall to 0
|
|
// to get the number of items, but they have to BOTH be set!
|
|
if ((0 == cCall) && (NULL == rgpCall) && (NULL != pcFetched))
|
|
{
|
|
INmCall *pCall = NULL;
|
|
cCall = 1;
|
|
|
|
// Return the number of remaining elements
|
|
ULONG ulItems = *pcFetched = 0;
|
|
|
|
hr = IEnumNmCall_RemoteNext_Proxy(This, cCall, &pCall, pcFetched, &ulItems, TRUE);
|
|
|
|
*pcFetched = ulItems;
|
|
|
|
return hr;
|
|
}
|
|
|
|
if ((NULL == rgpCall) || ((NULL == pcFetched) && (cCall != 1)))
|
|
return E_POINTER;
|
|
|
|
ULONG cFetched = pcFetched ? *pcFetched : 0;
|
|
|
|
// This parameter is only used when we have to determine the number of elements
|
|
ULONG ulUnused;
|
|
|
|
hr = IEnumNmCall_RemoteNext_Proxy(This, cCall, rgpCall, &cFetched, &ulUnused, FALSE);
|
|
|
|
if(pcFetched)
|
|
{
|
|
*pcFetched = cFetched;
|
|
}
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
|
|
/* [call_as] */ HRESULT STDMETHODCALLTYPE IEnumNmCall_Next_Stub(
|
|
IEnumNmCall __RPC_FAR * This,
|
|
/* [in] */ ULONG cCall,
|
|
/* [length_is][size_is][out] */ INmCall __RPC_FAR *__RPC_FAR *rgpCall,
|
|
/* [out] */ ULONG __RPC_FAR *pcFetched,
|
|
/* [out] */ ULONG __RPC_FAR *pcItems,
|
|
/* [in] */ BOOL bGetNumberRemaining)
|
|
{
|
|
if(bGetNumberRemaining)
|
|
{
|
|
HRESULT hr = This->Next(0, NULL, pcFetched);
|
|
|
|
// Store the numebr of items
|
|
*pcItems = *pcFetched;
|
|
|
|
// This is so the marshaller does not think that *rgpCall has valid info
|
|
*pcFetched = 0;
|
|
return hr;
|
|
}
|
|
|
|
return This->Next(cCall, rgpCall, pcFetched);
|
|
|
|
}
|
|
|
|
/* [local] */ HRESULT STDMETHODCALLTYPE IEnumNmSharableApp_Next_Proxy(
|
|
IEnumNmSharableApp __RPC_FAR * This,
|
|
/* [in] */ ULONG cApp,
|
|
/* [out] */ INmSharableApp __RPC_FAR *__RPC_FAR *rgpApp,
|
|
/* [out] */ ULONG __RPC_FAR *pcFetched)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// The user can pass NULL for rpgSharableApp and set cSharableApp to 0
|
|
// to get the number of items, but they have to BOTH be set!
|
|
if ((0 == cApp) && (NULL == rgpApp) && (NULL != pcFetched))
|
|
{
|
|
INmSharableApp *pSharableApp = NULL;
|
|
cApp = 1;
|
|
|
|
// Return the number of remaining elements
|
|
ULONG ulItems = *pcFetched = 0;
|
|
|
|
hr = IEnumNmSharableApp_RemoteNext_Proxy(This, cApp, &pSharableApp, pcFetched, &ulItems, TRUE);
|
|
|
|
*pcFetched = ulItems;
|
|
|
|
return hr;
|
|
}
|
|
|
|
if ((NULL == rgpApp) || ((NULL == pcFetched) && (cApp != 1)))
|
|
return E_POINTER;
|
|
|
|
ULONG cFetched = pcFetched ? *pcFetched : 0;
|
|
|
|
// This parameter is only used when we have to determine the number of elements
|
|
ULONG ulUnused;
|
|
|
|
hr = IEnumNmSharableApp_RemoteNext_Proxy(This, cApp, rgpApp, &cFetched, &ulUnused, FALSE);
|
|
|
|
if(pcFetched)
|
|
{
|
|
*pcFetched = cFetched;
|
|
}
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
/* [call_as] */ HRESULT STDMETHODCALLTYPE IEnumNmSharableApp_Next_Stub(
|
|
IEnumNmSharableApp __RPC_FAR * This,
|
|
/* [in] */ ULONG cApp,
|
|
/* [length_is][size_is][out] */ INmSharableApp __RPC_FAR *__RPC_FAR *rgpApp,
|
|
/* [out] */ ULONG __RPC_FAR *pcFetched,
|
|
/* [out] */ ULONG __RPC_FAR *pcItems,
|
|
/* [in] */ BOOL bGetNumberRemaining)
|
|
{
|
|
if(bGetNumberRemaining)
|
|
{
|
|
HRESULT hr = This->Next(0, NULL, pcFetched);
|
|
|
|
// Store the numebr of items
|
|
*pcItems = *pcFetched;
|
|
|
|
// This is so the marshaller does not think that *rgpApp has valid info
|
|
*pcFetched = 0;
|
|
return hr;
|
|
}
|
|
|
|
return This->Next(cApp, rgpApp, pcFetched);
|
|
}
|
|
|
|
|
|
|
|
typedef HRESULT (WINAPI *VERIFYUSERINFO)(HWND hwnd, NM_VUI options);
|
|
|
|
/* [local] */ HRESULT STDMETHODCALLTYPE INmObject_VerifyUserInfo_Proxy(
|
|
INmObject __RPC_FAR * This,
|
|
/* [in] */ UINT_PTR hwnd,
|
|
/* [in] */ NM_VUI options)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
HMODULE hMod = LoadLibrary("msconf.dll");
|
|
if (NULL != hMod)
|
|
{
|
|
VERIFYUSERINFO pfnVUI = (VERIFYUSERINFO)GetProcAddress(hMod, "VerifyUserInfo");
|
|
if (NULL != pfnVUI)
|
|
{
|
|
hr = pfnVUI((HWND)hwnd, options);
|
|
}
|
|
FreeLibrary(hMod);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/* [call_as] */ HRESULT STDMETHODCALLTYPE INmObject_VerifyUserInfo_Stub(
|
|
INmObject __RPC_FAR * This,
|
|
/* [in] */ long hwnd,
|
|
/* [in] */ NM_VUI options)
|
|
{
|
|
return This->VerifyUserInfo(hwnd, options);
|
|
}
|
|
|