diff --git a/reactos/base/applications/tsclient/porting-tools/mstscax/mstscax.cpp b/reactos/base/applications/tsclient/porting-tools/mstscax/mstscax.cpp index 5ff1695b23a..45f540318bb 100644 --- a/reactos/base/applications/tsclient/porting-tools/mstscax/mstscax.cpp +++ b/reactos/base/applications/tsclient/porting-tools/mstscax/mstscax.cpp @@ -14,12 +14,26 @@ namespace HMODULE hmMstscax = NULL; + extern "C" char __ImageBase; + static const HMODULE hmSelf = reinterpret_cast(&__ImageBase); + void init() { if(hmMstscax) return; - hmMstscax = LoadLibrary(TEXT("mstscax_.dll")); + TCHAR szFileName[MAX_PATH + 1]; + GetModuleFileName(hmSelf, szFileName, MAX_PATH); + + std::basic_string strFileName(&szFileName[0]); + std::reverse_iterator::const_iterator > begin(strFileName.end()); + std::reverse_iterator::const_iterator > end(strFileName.begin()); + std::basic_string::const_iterator endPath = std::find(begin, end, TEXT('\\')).base(); + + std::basic_string strPath(strFileName.begin(), endPath); + strPath.append(TEXT("mstscax_.dll")); + + hmMstscax = LoadLibrary(strPath.c_str()); pfnDllGetClassObject = (PFNDLLGETCLASSOBJECT)GetProcAddress(hmMstscax, "DllGetClassObject"); pfnDllCanUnloadNow = (PFNDLLCANUNLOADNOW)GetProcAddress(hmMstscax, "DllCanUnloadNow"); pfnDllGetTscCtlVer = (PFNDLLGETTSCCTLVER)GetProcAddress(hmMstscax, "DllGetTscCtlVer"); @@ -141,8 +155,2068 @@ namespace return X ? TEXT("true") : TEXT("false"); } + std::basic_string VariantToString(const VARIANT& var) + { + std::basic_ostringstream o; + + switch(var.vt & VT_TYPEMASK) + { + case VT_EMPTY: o << ""; break; + case VT_NULL: o << ""; break; + case VT_I2: o << "short"; break; + case VT_I4: o << "long"; break; + case VT_R4: o << "float"; break; + case VT_R8: o << "double"; break; + case VT_CY: o << "CURRENCY"; break; + case VT_DATE: o << "DATE"; break; + case VT_BSTR: o << "string"; break; + case VT_DISPATCH: o << "IDispatch *"; break; + case VT_ERROR: o << "SCODE"; break; + case VT_BOOL: o << "bool"; break; + case VT_VARIANT: o << "VARIANT *"; break; + case VT_UNKNOWN: o << "IUnknown *"; break; + case VT_DECIMAL: o << "DECIMAL"; break; + case VT_I1: o << "char"; break; + case VT_UI1: o << "unsigned char"; break; + case VT_UI2: o << "unsigned short"; break; + case VT_UI4: o << "unsigned long"; break; + case VT_I8: o << "long long"; break; + case VT_UI8: o << "unsigned long long"; break; + case VT_INT: o << "int"; break; + case VT_UINT: o << "unsigned int"; break; + case VT_VOID: o << "void"; break; + case VT_HRESULT: o << "HRESULT"; break; + case VT_PTR: o << "void *"; break; + case VT_SAFEARRAY: o << "SAFEARRAY *"; break; + case VT_LPSTR: o << "LPSTR"; break; + case VT_LPWSTR: o << "LPWSTR"; break; + case VT_RECORD: o << "struct { }"; break; + case VT_INT_PTR: o << "intptr_t"; break; + case VT_UINT_PTR: o << "uintptr_t"; break; + case VT_FILETIME: o << "FILETIME"; break; + default: o << "???"; break; + } + + if(var.vt & VT_ARRAY) + o << "[]"; + else if(var.vt & VT_BYREF) + o << " *"; + else + { + switch(var.vt & VT_TYPEMASK) + { + case VT_EMPTY: + case VT_NULL: + case VT_RECORD: + case VT_VOID: + + // TODO + case VT_CY: + case VT_DATE: + case VT_DECIMAL: + case VT_FILETIME: + break; + + default: + o << " = "; + } + + switch(var.vt & VT_TYPEMASK) + { + case VT_I2: o << var.iVal; break; + case VT_I4: o << var.lVal; break; + case VT_R4: o << var.fltVal; break; + case VT_R8: o << var.dblVal; break; + case VT_BSTR: o << std::wstring(var.bstrVal, var.bstrVal + SysStringLen(var.bstrVal)); break; + case VT_BOOL: o << var.boolVal ? "true" : "false"; break; + case VT_I1: o << int(var.cVal); break; + case VT_UI1: o << unsigned int(var.bVal); break; + case VT_UI2: o << var.uiVal; break; + case VT_UI4: o << var.ulVal; break; + case VT_I8: o << var.llVal; break; + case VT_UI8: o << var.ullVal; break; + case VT_INT: o << var.intVal; break; + case VT_UINT: o << var.uintVal; break; + case VT_LPSTR: o << LPSTR(var.byref); break; + case VT_LPWSTR: o << LPWSTR(var.byref); break; + case VT_INT_PTR: o << var.intVal; break; // BUGBUG + case VT_UINT_PTR: o << var.uintVal; break; // BUGBUG + + case VT_DISPATCH: + case VT_VARIANT: + case VT_UNKNOWN: + case VT_PTR: + case VT_SAFEARRAY: + case VT_RECORD: + o << var.byref; break; + + case VT_ERROR: + case VT_HRESULT: + o << std::hex << var.ulVal; break; + + default: + assert(0); + } + } + + return o.str(); + } + #pragma warning(disable:4584) + IConnectionPointContainer * HookIConnectionPointContainer(IConnectionPointContainer * p); + IEnumConnectionPoints * HookIEnumConnectionPoints(IEnumConnectionPoints * p); + IConnectionPoint * HookIConnectionPoint(IConnectionPoint * p); + IEnumConnections * HookIEnumConnections(IEnumConnections * p); + + class CConnectionPointContainer: public IConnectionPointContainer + { + private: + LONG m_refCount; + IConnectionPointContainer * m_IConnectionPointContainer; + + public: + CConnectionPointContainer(IConnectionPointContainer * pIConnectionPointContainer): + m_refCount(1), + m_IConnectionPointContainer(pIConnectionPointContainer) + { } + + ~CConnectionPointContainer() { m_IConnectionPointContainer->Release(); } + + virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void ** ppvObject) + { + HRESULT hr = S_OK; + + dbgprintf(TEXT("CConnectionPointContainer::QueryInterface(%ls, %p)"), UUIDToString(riid).c_str(), ppvObject); + + if(riid == IID_IUnknown || riid == IID_IConnectionPointContainer) + *ppvObject = this; + else + { + *ppvObject = NULL; + hr = E_NOINTERFACE; + } + + dbgprintf(TEXT("CConnectionPointContainer::QueryInterface -> %08X, ppvObject = %p"), hr, *ppvObject); + return hr; + } + + virtual ULONG STDMETHODCALLTYPE AddRef(void) + { + return InterlockedIncrement(&m_refCount); + } + + virtual ULONG STDMETHODCALLTYPE Release(void) + { + LONG n = InterlockedDecrement(&m_refCount); + + if(n == 0) + delete this; + + return n; + } + + virtual HRESULT STDMETHODCALLTYPE EnumConnectionPoints(IEnumConnectionPoints ** ppEnum) + { + dbgprintf(TEXT("CConnectionPointContainer::EnumConnectionPoints(%p)"), ppEnum); + HRESULT hr = m_IConnectionPointContainer->EnumConnectionPoints(ppEnum); + dbgprintf(TEXT("CConnectionPointContainer::EnumConnectionPoints -> %08X, pEnum = %p"), hr, *ppEnum); + + if(SUCCEEDED(hr)) + *ppEnum = HookIEnumConnectionPoints(*ppEnum); + + return hr; + } + + virtual HRESULT STDMETHODCALLTYPE FindConnectionPoint(REFIID riid, IConnectionPoint ** ppCP) + { + dbgprintf(TEXT("CConnectionPointContainer::FindConnectionPoint(%ls, %p)"), UUIDToString(riid).c_str(), ppCP); + HRESULT hr = m_IConnectionPointContainer->FindConnectionPoint(riid, ppCP); + dbgprintf(TEXT("CConnectionPointContainer::FindConnectionPoint -> %08X, pCP = %p"), hr, *ppCP); + + if(SUCCEEDED(hr)) + *ppCP = HookIConnectionPoint(*ppCP); + + return hr; + } + }; + + class CEnumConnectionPoints: public IEnumConnectionPoints + { + private: + LONG m_refCount; + IEnumConnectionPoints * m_IEnumConnectionPoints; + + public: + CEnumConnectionPoints(IEnumConnectionPoints * pIEnumConnectionPoints): + m_refCount(1), + m_IEnumConnectionPoints(pIEnumConnectionPoints) + { } + + ~CEnumConnectionPoints() { m_IEnumConnectionPoints->Release(); } + + virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void ** ppvObject) + { + HRESULT hr = S_OK; + + dbgprintf(TEXT("CEnumConnectionPoints::QueryInterface(%ls, %p)"), UUIDToString(riid).c_str(), ppvObject); + + if(riid == IID_IUnknown || riid == IID_IEnumConnectionPoints) + *ppvObject = this; + else + { + *ppvObject = NULL; + hr = E_NOINTERFACE; + } + + dbgprintf(TEXT("CEnumConnectionPoints::QueryInterface -> %08X, ppvObject = %p"), hr, *ppvObject); + return hr; + } + + virtual ULONG STDMETHODCALLTYPE AddRef(void) + { + return InterlockedIncrement(&m_refCount); + } + + virtual ULONG STDMETHODCALLTYPE Release(void) + { + LONG n = InterlockedDecrement(&m_refCount); + + if(n == 0) + delete this; + + return n; + } + + virtual HRESULT STDMETHODCALLTYPE Next(ULONG cConnections, LPCONNECTIONPOINT * ppCP, ULONG * pcFetched) + { + dbgprintf(TEXT("CEnumConnectionPoints::Next(%lu, %p, %p)"), cConnections, ppCP, pcFetched); + HRESULT hr = m_IEnumConnectionPoints->Next(cConnections, ppCP, pcFetched); + dbgprintf(TEXT("CEnumConnectionPoints:: -> %08X, pCP = %p, cFetched = %lu"), hr, *ppCP, *pcFetched); + + if(SUCCEEDED(hr)) + *ppCP = HookIConnectionPoint(*ppCP); + + return hr; + } + + virtual HRESULT STDMETHODCALLTYPE Skip(ULONG cConnections) + { + dbgprintf(TEXT("CEnumConnectionPoints::Skip(%lu)"), cConnections); + HRESULT hr = m_IEnumConnectionPoints->Skip(cConnections); + dbgprintf(TEXT("CEnumConnectionPoints:: -> %08X"), hr); + return hr; + } + + virtual HRESULT STDMETHODCALLTYPE Reset(void) + { + dbgprintf(TEXT("CEnumConnectionPoints::Reset()")); + HRESULT hr = m_IEnumConnectionPoints->Reset(); + dbgprintf(TEXT("CEnumConnectionPoints:: -> %08X"), hr); + return hr; + } + + virtual HRESULT STDMETHODCALLTYPE Clone(IEnumConnectionPoints ** ppEnum) + { + dbgprintf(TEXT("CEnumConnectionPoints::Clone(%p)"), ppEnum); + HRESULT hr = m_IEnumConnectionPoints->Clone(ppEnum); + dbgprintf(TEXT("CEnumConnectionPoints:: -> %08X, pEnum"), hr, *ppEnum); + + if(SUCCEEDED(hr)) + *ppEnum = HookIEnumConnectionPoints(*ppEnum); + + return hr; + } + }; + + class CConnectionPoint: public IConnectionPoint + { + private: + LONG m_refCount; + IConnectionPoint * m_IConnectionPoint; + + public: + CConnectionPoint(IConnectionPoint * pIConnectionPoint): + m_refCount(1), + m_IConnectionPoint(pIConnectionPoint) + { } + + ~CConnectionPoint() { m_IConnectionPoint->Release(); } + + virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void ** ppvObject) + { + HRESULT hr = S_OK; + + dbgprintf(TEXT("CConnectionPoint::QueryInterface(%ls, %p)"), UUIDToString(riid).c_str(), ppvObject); + + if(riid == IID_IUnknown || riid == IID_IConnectionPoint) + *ppvObject = this; + else + { + *ppvObject = NULL; + hr = E_NOINTERFACE; + } + + dbgprintf(TEXT("CConnectionPoint::QueryInterface -> %08X, ppvObject = %p"), hr, *ppvObject); + return hr; + } + + virtual ULONG STDMETHODCALLTYPE AddRef(void) + { + return InterlockedIncrement(&m_refCount); + } + + virtual ULONG STDMETHODCALLTYPE Release(void) + { + LONG n = InterlockedDecrement(&m_refCount); + + if(n == 0) + delete this; + + return n; + } + + virtual HRESULT STDMETHODCALLTYPE GetConnectionInterface(IID * pIID) + { + dbgprintf(TEXT("CConnectionPoint::GetConnectionInterface(%p)"), pIID); + HRESULT hr = m_IConnectionPoint->GetConnectionInterface(pIID); + dbgprintf(TEXT("CConnectionPoint::GetConnectionInterface -> %08X, IID = %ls"), hr, UUIDToString(*pIID).c_str()); + return hr; + } + + virtual HRESULT STDMETHODCALLTYPE GetConnectionPointContainer(IConnectionPointContainer ** ppCPC) + { + dbgprintf(TEXT("CConnectionPoint::GetConnectionPointContainer(%p)"), ppCPC); + HRESULT hr = m_IConnectionPoint->GetConnectionPointContainer(ppCPC); + dbgprintf(TEXT("CConnectionPoint::GetConnectionPointContainer -> %08X, pCPC = %p"), hr, *ppCPC); + + if(SUCCEEDED(hr)) + *ppCPC = HookIConnectionPointContainer(*ppCPC); + + return hr; + } + + virtual HRESULT STDMETHODCALLTYPE Advise(IUnknown * pUnkSink, DWORD * pdwCookie) + { + dbgprintf(TEXT("CConnectionPoint::Advise(%p, %p)"), pUnkSink, pdwCookie); + HRESULT hr = m_IConnectionPoint->Advise(pUnkSink, pdwCookie); + dbgprintf(TEXT("CConnectionPoint::Advise -> %08X, dwCookie = %lu"), hr, *pdwCookie); + // TODO: hook sink + return hr; + } + + virtual HRESULT STDMETHODCALLTYPE Unadvise(DWORD dwCookie) + { + dbgprintf(TEXT("CConnectionPoint::Unadvise(%lu)"), dwCookie); + HRESULT hr = m_IConnectionPoint->Unadvise(dwCookie); + dbgprintf(TEXT("CConnectionPoint::Unadvise -> %08X"), hr); + return hr; + } + + virtual HRESULT STDMETHODCALLTYPE EnumConnections(IEnumConnections ** ppEnum) + { + dbgprintf(TEXT("CConnectionPoint::EnumConnections(%p)"), ppEnum); + HRESULT hr = m_IConnectionPoint->EnumConnections(ppEnum); + dbgprintf(TEXT("CConnectionPoint::EnumConnections -> %08X, pEnum = %p"), hr, *ppEnum); + + if(SUCCEEDED(hr)) + *ppEnum = HookIEnumConnections(*ppEnum); + + return hr; + } + }; + + class CEnumConnections: public IEnumConnections + { + private: + LONG m_refCount; + IEnumConnections * m_IEnumConnections; + + public: + CEnumConnections(IEnumConnections * pIEnumConnections): + m_refCount(1), + m_IEnumConnections(pIEnumConnections) + { } + + ~CEnumConnections() { m_IEnumConnections->Release(); } + + virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void ** ppvObject) + { + HRESULT hr = S_OK; + + dbgprintf(TEXT("CEnumConnections::QueryInterface(%ls, %p)"), UUIDToString(riid).c_str(), ppvObject); + + if(riid == IID_IUnknown || riid == IID_IEnumConnections) + *ppvObject = this; + else + { + *ppvObject = NULL; + hr = E_NOINTERFACE; + } + + dbgprintf(TEXT("CEnumConnections::QueryInterface -> %08X, ppvObject = %p"), hr, *ppvObject); + return hr; + } + + virtual ULONG STDMETHODCALLTYPE AddRef(void) + { + return InterlockedIncrement(&m_refCount); + } + + virtual ULONG STDMETHODCALLTYPE Release(void) + { + LONG n = InterlockedDecrement(&m_refCount); + + if(n == 0) + delete this; + + return n; + } + + virtual HRESULT STDMETHODCALLTYPE Next(ULONG cConnections, LPCONNECTDATA pCD, ULONG * pcFetched) + { + dbgprintf(TEXT("CEnumConnections::Next(%lu, %p, %p)"), cConnections, pCD, pcFetched); + HRESULT hr = m_IEnumConnections->Next(cConnections, pCD, pcFetched); + dbgprintf(TEXT("CEnumConnections:: -> %08X, CD = { pUnk = %p, dwCookie = %lu }, cFetched = %lu"), hr, pCD->pUnk, pCD->dwCookie, *pcFetched); + return hr; + } + + virtual HRESULT STDMETHODCALLTYPE Skip(ULONG cConnections) + { + dbgprintf(TEXT("CEnumConnections::Skip(%lu)"), cConnections); + HRESULT hr = m_IEnumConnections->Skip(cConnections); + dbgprintf(TEXT("CEnumConnections:: -> %08X"), hr); + return hr; + } + + virtual HRESULT STDMETHODCALLTYPE Reset(void) + { + dbgprintf(TEXT("CEnumConnections::Reset()")); + HRESULT hr = m_IEnumConnections->Reset(); + dbgprintf(TEXT("CEnumConnections:: -> %08X"), hr); + return hr; + } + + virtual HRESULT STDMETHODCALLTYPE Clone(IEnumConnections ** ppEnum) + { + dbgprintf(TEXT("CEnumConnections::Clone(%p)"), ppEnum); + HRESULT hr = m_IEnumConnections->Clone(ppEnum); + dbgprintf(TEXT("CEnumConnections:: -> %08X, pEnum"), hr, *ppEnum); + + if(SUCCEEDED(hr)) + *ppEnum = HookIEnumConnections(*ppEnum); + + return hr; + } + }; + + IConnectionPointContainer * HookIConnectionPointContainer(IConnectionPointContainer * p) + { + return new CConnectionPointContainer(p); + } + + IEnumConnectionPoints * HookIEnumConnectionPoints(IEnumConnectionPoints * p) + { + return new CEnumConnectionPoints(p); + } + + IConnectionPoint * HookIConnectionPoint(IConnectionPoint * p) + { + return new CConnectionPoint(p); + } + + IEnumConnections * HookIEnumConnections(IEnumConnections * p) + { + return new CEnumConnections(p); + } + + class CAdvancedSettings: public IMsRdpClientAdvancedSettings4 + { + private: + LONG m_refCount; + IUnknown * m_IUnknown; + IDispatch * m_IDispatch; + IMsTscAdvancedSettings * m_IMsTscAdvancedSettings; + IMsRdpClientAdvancedSettings * m_IMsRdpClientAdvancedSettings; + IMsRdpClientAdvancedSettings2 * m_IMsRdpClientAdvancedSettings2; + IMsRdpClientAdvancedSettings3 * m_IMsRdpClientAdvancedSettings3; + IMsRdpClientAdvancedSettings4 * m_IMsRdpClientAdvancedSettings4; + + IDispatch * getIDispatch() + { + assert(m_IDispatch); + return m_IDispatch; + } + + IMsTscAdvancedSettings * getIMsTscAdvancedSettings() + { + if(m_IMsTscAdvancedSettings) + return m_IMsTscAdvancedSettings; + else if(m_IMsRdpClientAdvancedSettings) + m_IMsTscAdvancedSettings = m_IMsRdpClientAdvancedSettings; + else if(m_IMsRdpClientAdvancedSettings2) + m_IMsTscAdvancedSettings = m_IMsRdpClientAdvancedSettings2; + else if(m_IMsRdpClientAdvancedSettings3) + m_IMsTscAdvancedSettings = m_IMsRdpClientAdvancedSettings3; + else if(m_IMsRdpClientAdvancedSettings4) + m_IMsTscAdvancedSettings = m_IMsRdpClientAdvancedSettings4; + + if(m_IMsTscAdvancedSettings) + { + m_IMsTscAdvancedSettings->AddRef(); + return m_IMsTscAdvancedSettings; + } + + m_IUnknown->QueryInterface(&m_IMsTscAdvancedSettings); + return m_IMsTscAdvancedSettings; + } + + IMsRdpClientAdvancedSettings * getIMsRdpClientAdvancedSettings() + { + if(m_IMsRdpClientAdvancedSettings) + return m_IMsRdpClientAdvancedSettings; + else if(m_IMsRdpClientAdvancedSettings2) + m_IMsRdpClientAdvancedSettings = m_IMsRdpClientAdvancedSettings2; + else if(m_IMsRdpClientAdvancedSettings3) + m_IMsRdpClientAdvancedSettings = m_IMsRdpClientAdvancedSettings3; + else if(m_IMsRdpClientAdvancedSettings4) + m_IMsRdpClientAdvancedSettings = m_IMsRdpClientAdvancedSettings4; + + if(m_IMsRdpClientAdvancedSettings) + { + m_IMsRdpClientAdvancedSettings->AddRef(); + return m_IMsRdpClientAdvancedSettings; + } + + m_IUnknown->QueryInterface(&m_IMsRdpClientAdvancedSettings); + return m_IMsRdpClientAdvancedSettings; + } + + IMsRdpClientAdvancedSettings2 * getIMsRdpClientAdvancedSettings2() + { + if(m_IMsRdpClientAdvancedSettings2) + return m_IMsRdpClientAdvancedSettings2; + else if(m_IMsRdpClientAdvancedSettings3) + m_IMsRdpClientAdvancedSettings2 = m_IMsRdpClientAdvancedSettings3; + else if(m_IMsRdpClientAdvancedSettings4) + m_IMsRdpClientAdvancedSettings2 = m_IMsRdpClientAdvancedSettings4; + + if(m_IMsRdpClientAdvancedSettings2) + { + m_IMsRdpClientAdvancedSettings2->AddRef(); + return m_IMsRdpClientAdvancedSettings2; + } + + m_IUnknown->QueryInterface(&m_IMsRdpClientAdvancedSettings2); + return m_IMsRdpClientAdvancedSettings2; + } + + IMsRdpClientAdvancedSettings3 * getIMsRdpClientAdvancedSettings3() + { + if(m_IMsRdpClientAdvancedSettings3) + return m_IMsRdpClientAdvancedSettings3; + else if(m_IMsRdpClientAdvancedSettings4) + m_IMsRdpClientAdvancedSettings3 = m_IMsRdpClientAdvancedSettings4; + + if(m_IMsRdpClientAdvancedSettings3) + { + m_IMsRdpClientAdvancedSettings3->AddRef(); + return m_IMsRdpClientAdvancedSettings3; + } + + m_IUnknown->QueryInterface(&m_IMsRdpClientAdvancedSettings3); + return m_IMsRdpClientAdvancedSettings3; + } + + IMsRdpClientAdvancedSettings4 * getIMsRdpClientAdvancedSettings4() + { + if(m_IMsRdpClientAdvancedSettings4) + return m_IMsRdpClientAdvancedSettings4; + + if(m_IMsRdpClientAdvancedSettings4) + { + m_IMsRdpClientAdvancedSettings4->AddRef(); + return m_IMsRdpClientAdvancedSettings4; + } + + m_IUnknown->QueryInterface(&m_IMsRdpClientAdvancedSettings4); + return m_IMsRdpClientAdvancedSettings4; + } + + ~CAdvancedSettings() + { + m_IUnknown->Release(); + m_IDispatch->Release(); + + if(m_IMsTscAdvancedSettings) + m_IMsTscAdvancedSettings->Release(); + + if(m_IMsRdpClientAdvancedSettings) + m_IMsRdpClientAdvancedSettings->Release(); + + if(m_IMsRdpClientAdvancedSettings2) + m_IMsRdpClientAdvancedSettings2->Release(); + + if(m_IMsRdpClientAdvancedSettings3) + m_IMsRdpClientAdvancedSettings3->Release(); + + if(m_IMsRdpClientAdvancedSettings4) + m_IMsRdpClientAdvancedSettings4->Release(); + } + + void Init(IMsTscAdvancedSettings * p) + { + m_IMsTscAdvancedSettings = p; + } + + void Init(IMsRdpClientAdvancedSettings * p) + { + m_IMsRdpClientAdvancedSettings = p; + } + + void Init(IMsRdpClientAdvancedSettings2 * p) + { + m_IMsRdpClientAdvancedSettings2 = p; + } + + void Init(IMsRdpClientAdvancedSettings3 * p) + { + m_IMsRdpClientAdvancedSettings3 = p; + } + + void Init(IMsRdpClientAdvancedSettings4 * p) + { + m_IMsRdpClientAdvancedSettings4 = p; + } + + public: + template CAdvancedSettings(Interface * p): + m_refCount(1), + m_IUnknown(p), + m_IDispatch(p), + m_IMsTscAdvancedSettings(NULL), + m_IMsRdpClientAdvancedSettings(NULL), + m_IMsRdpClientAdvancedSettings2(NULL), + m_IMsRdpClientAdvancedSettings3(NULL), + m_IMsRdpClientAdvancedSettings4(NULL) + { + assert(p); + p->AddRef(); + p->AddRef(); + Init(p); + } + + /* IUnknown */ + virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void ** ppvObject) + { + HRESULT hr; + IUnknown * pvObject; + + dbgprintf(TEXT("CAdvancedSettings::QueryInterface(%ls, %p)"), UUIDToString(riid).c_str(), ppvObject); + +#define QIBEGIN() \ + if(riid == IID_IUnknown) \ + { \ + hr = S_OK; \ + pvObject = (IUnknown *)(this); \ + } + +#define QI(I) \ + else if(riid == IID_ ## I) \ + { \ + if(m_ ## I) \ + { \ + m_ ## I->AddRef(); \ + hr = S_OK; \ + } \ + else \ + { \ + hr = m_IUnknown->QueryInterface(&m_ ## I); \ + } \ + \ + if(SUCCEEDED(hr)) \ + pvObject = static_cast(this); \ + } + +#define QIEND() \ + else \ + { \ + hr = E_NOINTERFACE; \ + pvObject = (IUnknown *)(this); \ + } + + QIBEGIN() + QI(IDispatch) + QI(IMsTscAdvancedSettings) + QI(IMsRdpClientAdvancedSettings) + QI(IMsRdpClientAdvancedSettings2) + QI(IMsRdpClientAdvancedSettings3) + QI(IMsRdpClientAdvancedSettings4) + QIEND() + +#undef QIBEGIN +#undef QIEND +#undef QI + + if(SUCCEEDED(hr)) + { + assert(pvObject); + pvObject->AddRef(); + } + else + { + assert(pvObject == NULL); + } + + *ppvObject = pvObject; + + dbgprintf(TEXT("CAdvancedSettings::QueryInterface -> %08X, ppvObject = %p"), hr, *ppvObject); + return hr; + } + + virtual ULONG STDMETHODCALLTYPE AddRef(void) + { + return InterlockedIncrement(&m_refCount); + } + + virtual ULONG STDMETHODCALLTYPE Release(void) + { + LONG n = InterlockedDecrement(&m_refCount); + + if(n == 0) + delete this; + + return n; + } + + /* IDispatch */ + /* + * p = get(); + dbgprintf(TEXT("CAdvancedSettings::()"), ); + HRESULT hr = p->(); + dbgprintf(TEXT("CAdvancedSettings:: -> %08X, "), hr, ); + return hr; + */ + virtual STDMETHODIMP IDispatch::GetTypeInfoCount(UINT * pctinfo) + { + IDispatch * pIDispatch = getIDispatch(); + dbgprintf(TEXT("CAdvancedSettings::GetTypeInfoCount(%p)"), pctinfo); + HRESULT hr = pIDispatch->GetTypeInfoCount(pctinfo); + dbgprintf(TEXT("CAdvancedSettings::GetTypeInfoCount -> %08X, ctinfo = %u"), hr, *pctinfo); + return hr; + } + + virtual STDMETHODIMP IDispatch::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo ** ppTInfo) + { + IDispatch * pIDispatch = getIDispatch(); + dbgprintf(TEXT("CAdvancedSettings::GetTypeInfo(%u, %lu, %p)"), iTInfo, lcid, ppTInfo); + HRESULT hr = pIDispatch->GetTypeInfo(iTInfo, lcid, ppTInfo); + dbgprintf(TEXT("CAdvancedSettings::GetTypeInfo -> %08X, pTInfo = %p"), hr, *ppTInfo); + return hr; + } + + virtual STDMETHODIMP IDispatch::GetIDsOfNames(REFIID riid, LPOLESTR * rgszNames, UINT cNames, LCID lcid, DISPID * rgDispId) + { + IDispatch * pIDispatch = getIDispatch(); + dbgprintf(TEXT("CAdvancedSettings::GetIDsOfNames(%ls, %ls, %d, %lu, %p)"), UUIDToString(riid).c_str(), *rgszNames, cNames, lcid, rgDispId); + HRESULT hr = pIDispatch->GetIDsOfNames(riid, rgszNames, cNames, lcid, rgDispId); + dbgprintf(TEXT("CAdvancedSettings::GetIDsOfNames -> %08X, rgDispId = %ld"), hr, *rgDispId); + return hr; + } + + virtual STDMETHODIMP IDispatch::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pDispParams, VARIANT * pVarResult, EXCEPINFO * pExcepInfo, UINT * puArgErr) + { + // TODO + IDispatch * pIDispatch = getIDispatch(); + dbgprintf(TEXT("CAdvancedSettings::Invoke()")/*, */); + HRESULT hr = pIDispatch->Invoke(dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); + dbgprintf(TEXT("CAdvancedSettings::Invoke -> %08X, "), hr/*, */); + return hr; + } + + /* IMsTscAdvancedSettings */ + virtual STDMETHODIMP IMsTscAdvancedSettings::put_Compress(long pcompress) + { + IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_Compress(%ld)"), pcompress); + HRESULT hr = pIMsTscAdvancedSettings->put_Compress(pcompress); + dbgprintf(TEXT("CAdvancedSettings::put_Compress -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::get_Compress(long * pcompress) + { + IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_Compress(%p)"), pcompress); + HRESULT hr = pIMsTscAdvancedSettings->get_Compress(pcompress); + dbgprintf(TEXT("CAdvancedSettings::get_Compress -> %08X, compress = %ld"), hr, *pcompress); + return hr; + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::put_BitmapPeristence(long pbitmapPeristence) + { + IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_BitmapPeristence(%ld)"), pbitmapPeristence); + HRESULT hr = pIMsTscAdvancedSettings->put_BitmapPeristence(pbitmapPeristence); + dbgprintf(TEXT("CAdvancedSettings::put_BitmapPeristence -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::get_BitmapPeristence(long * pbitmapPeristence) + { + IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_BitmapPeristence(%p)"), pbitmapPeristence); + HRESULT hr = pIMsTscAdvancedSettings->get_BitmapPeristence(pbitmapPeristence); + dbgprintf(TEXT("CAdvancedSettings::get_BitmapPeristence -> %08X, bitmapPeristence = %ld"), hr, *pbitmapPeristence); + return hr; + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::put_allowBackgroundInput(long pallowBackgroundInput) + { + IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_allowBackgroundInput(%ld)"), pallowBackgroundInput); + HRESULT hr = pIMsTscAdvancedSettings->put_allowBackgroundInput(pallowBackgroundInput); + dbgprintf(TEXT("CAdvancedSettings::put_allowBackgroundInput -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::get_allowBackgroundInput(long * pallowBackgroundInput) + { + IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_allowBackgroundInput(%p)"), pallowBackgroundInput); + HRESULT hr = pIMsTscAdvancedSettings->get_allowBackgroundInput(pallowBackgroundInput); + dbgprintf(TEXT("CAdvancedSettings::get_allowBackgroundInput -> %08X, allowBackgroundInput = %ld"), hr, *pallowBackgroundInput); + return hr; + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::put_KeyBoardLayoutStr(BSTR rhs) + { + IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_KeyBoardLayoutStr(%ls)"), rhs); + HRESULT hr = pIMsTscAdvancedSettings->put_KeyBoardLayoutStr(rhs); + dbgprintf(TEXT("CAdvancedSettings::put_KeyBoardLayoutStr -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::put_PluginDlls(BSTR rhs) + { + IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_PluginDlls(%ls)"), rhs); + HRESULT hr = pIMsTscAdvancedSettings->put_PluginDlls(rhs); + dbgprintf(TEXT("CAdvancedSettings::put_PluginDlls -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::put_IconFile(BSTR rhs) + { + IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_IconFile(%ls)"), rhs); + HRESULT hr = pIMsTscAdvancedSettings->put_IconFile(rhs); + dbgprintf(TEXT("CAdvancedSettings::put_IconFile -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::put_IconIndex(long rhs) + { + IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_IconIndex(%ld)"), rhs); + HRESULT hr = pIMsTscAdvancedSettings->put_IconIndex(rhs); + dbgprintf(TEXT("CAdvancedSettings::put_IconIndex -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::put_ContainerHandledFullScreen(long pContainerHandledFullScreen) + { + IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_ContainerHandledFullScreen(%ld)"), pContainerHandledFullScreen); + HRESULT hr = pIMsTscAdvancedSettings->put_ContainerHandledFullScreen(pContainerHandledFullScreen); + dbgprintf(TEXT("CAdvancedSettings::put_ContainerHandledFullScreen -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::get_ContainerHandledFullScreen(long * pContainerHandledFullScreen) + { + IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_ContainerHandledFullScreen(%p)"), pContainerHandledFullScreen); + HRESULT hr = pIMsTscAdvancedSettings->get_ContainerHandledFullScreen(pContainerHandledFullScreen); + dbgprintf(TEXT("CAdvancedSettings::get_ContainerHandledFullScreen -> %08X, ContainerHandledFullScreen = %ld"), hr, *pContainerHandledFullScreen); + return hr; + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::put_DisableRdpdr(long pDisableRdpdr) + { + IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_DisableRdpdr(%ld)"), pDisableRdpdr); + HRESULT hr = pIMsTscAdvancedSettings->put_DisableRdpdr(pDisableRdpdr); + dbgprintf(TEXT("CAdvancedSettings::put_DisableRdpdr -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::get_DisableRdpdr(long * pDisableRdpdr) + { + IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_DisableRdpdr(%p)"), pDisableRdpdr); + HRESULT hr = pIMsTscAdvancedSettings->get_DisableRdpdr(pDisableRdpdr); + dbgprintf(TEXT("CAdvancedSettings::get_DisableRdpdr -> %08X, DisableRdpdr = %ld"), hr, *pDisableRdpdr); + return hr; + } + + /* IMsRdpClientAdvancedSettings */ + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_SmoothScroll(long psmoothScroll) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_SmoothScroll(%ld)"), psmoothScroll); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_SmoothScroll(psmoothScroll); + dbgprintf(TEXT("CAdvancedSettings::put_SmoothScroll -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_SmoothScroll(long * psmoothScroll) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_SmoothScroll(%p)"), psmoothScroll); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_SmoothScroll(psmoothScroll); + dbgprintf(TEXT("CAdvancedSettings::get_SmoothScroll -> %08X, smoothScroll = %ld"), hr, *psmoothScroll); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_AcceleratorPassthrough(long pacceleratorPassthrough) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_AcceleratorPassthrough(%ld)"), pacceleratorPassthrough); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_AcceleratorPassthrough(pacceleratorPassthrough); + dbgprintf(TEXT("CAdvancedSettings::put_AcceleratorPassthrough -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_AcceleratorPassthrough(long * pacceleratorPassthrough) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_AcceleratorPassthrough(%p)"), pacceleratorPassthrough); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_AcceleratorPassthrough(pacceleratorPassthrough); + dbgprintf(TEXT("CAdvancedSettings::get_AcceleratorPassthrough -> %08X, acceleratorPassthrough = %ld"), hr, *pacceleratorPassthrough); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ShadowBitmap(long pshadowBitmap) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_ShadowBitmap(%ld)"), pshadowBitmap); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_ShadowBitmap(pshadowBitmap); + dbgprintf(TEXT("CAdvancedSettings::put_ShadowBitmap -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_ShadowBitmap(long * pshadowBitmap) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_ShadowBitmap(%p)"), pshadowBitmap); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_ShadowBitmap(pshadowBitmap); + dbgprintf(TEXT("CAdvancedSettings::get_ShadowBitmap -> %08X, shadowBitmap = %ld"), hr, *pshadowBitmap); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_TransportType(long ptransportType) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_TransportType(%ld)"), ptransportType); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_TransportType(ptransportType); + dbgprintf(TEXT("CAdvancedSettings::put_TransportType -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_TransportType(long * ptransportType) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_TransportType(%p)"), ptransportType); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_TransportType(ptransportType); + dbgprintf(TEXT("CAdvancedSettings::get_TransportType -> %08X, transportType = %ld"), hr, *ptransportType); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_SasSequence(long psasSequence) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_SasSequence(%ld)"), psasSequence); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_SasSequence(psasSequence); + dbgprintf(TEXT("CAdvancedSettings::put_SasSequence -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_SasSequence(long * psasSequence) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_SasSequence(%p)"), psasSequence); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_SasSequence(psasSequence); + dbgprintf(TEXT("CAdvancedSettings::get_SasSequence -> %08X, sasSequence = %ld"), hr, *psasSequence); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_EncryptionEnabled(long pencryptionEnabled) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_EncryptionEnabled(%ld)"), pencryptionEnabled); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_EncryptionEnabled(pencryptionEnabled); + dbgprintf(TEXT("CAdvancedSettings::put_EncryptionEnabled -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_EncryptionEnabled(long * pencryptionEnabled) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_EncryptionEnabled(%p)"), pencryptionEnabled); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_EncryptionEnabled(pencryptionEnabled); + dbgprintf(TEXT("CAdvancedSettings::get_EncryptionEnabled -> %08X, encryptionEnabled = %ld"), hr, *pencryptionEnabled); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_DedicatedTerminal(long pdedicatedTerminal) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_DedicatedTerminal(%ld)"), pdedicatedTerminal); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_DedicatedTerminal(pdedicatedTerminal); + dbgprintf(TEXT("CAdvancedSettings::put_DedicatedTerminal -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_DedicatedTerminal(long * pdedicatedTerminal) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_DedicatedTerminal(%p)"), pdedicatedTerminal); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_DedicatedTerminal(pdedicatedTerminal); + dbgprintf(TEXT("CAdvancedSettings::get_DedicatedTerminal -> %08X, dedicatedTerminal = %ld"), hr, *pdedicatedTerminal); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RDPPort(long prdpPort) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_RDPPort(%ld)"), prdpPort); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_RDPPort(prdpPort); + dbgprintf(TEXT("CAdvancedSettings::put_RDPPort -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RDPPort(long * prdpPort) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_RDPPort(%p)"), prdpPort); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_RDPPort(prdpPort); + dbgprintf(TEXT("CAdvancedSettings::get_RDPPort -> %08X, rdpPort = %ld"), hr, *prdpPort); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_EnableMouse(long penableMouse) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_EnableMouse(%ld)"), penableMouse); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_EnableMouse(penableMouse); + dbgprintf(TEXT("CAdvancedSettings::put_EnableMouse -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_EnableMouse(long * penableMouse) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_EnableMouse(%p)"), penableMouse); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_EnableMouse(penableMouse); + dbgprintf(TEXT("CAdvancedSettings::get_EnableMouse -> %08X, enableMouse = %ld"), hr, *penableMouse); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_DisableCtrlAltDel(long pdisableCtrlAltDel) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_DisableCtrlAltDel(%ld)"), pdisableCtrlAltDel); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_DisableCtrlAltDel(pdisableCtrlAltDel); + dbgprintf(TEXT("CAdvancedSettings::put_DisableCtrlAltDel -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_DisableCtrlAltDel(long * pdisableCtrlAltDel) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_DisableCtrlAltDel(%p)"), pdisableCtrlAltDel); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_DisableCtrlAltDel(pdisableCtrlAltDel); + dbgprintf(TEXT("CAdvancedSettings::get_DisableCtrlAltDel -> %08X, disableCtrlAltDel = %ld"), hr, *pdisableCtrlAltDel); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_EnableWindowsKey(long penableWindowsKey) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_EnableWindowsKey(%ld)"), penableWindowsKey); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_EnableWindowsKey(penableWindowsKey); + dbgprintf(TEXT("CAdvancedSettings::put_EnableWindowsKey -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_EnableWindowsKey(long * penableWindowsKey) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_EnableWindowsKey(%p)"), penableWindowsKey); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_EnableWindowsKey(penableWindowsKey); + dbgprintf(TEXT("CAdvancedSettings::get_EnableWindowsKey -> %08X, enableWindowsKey = %ld"), hr, *penableWindowsKey); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_DoubleClickDetect(long pdoubleClickDetect) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_DoubleClickDetect(%ld)"), pdoubleClickDetect); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_DoubleClickDetect(pdoubleClickDetect); + dbgprintf(TEXT("CAdvancedSettings::put_DoubleClickDetect -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_DoubleClickDetect(long * pdoubleClickDetect) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_DoubleClickDetect(%p)"), pdoubleClickDetect); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_DoubleClickDetect(pdoubleClickDetect); + dbgprintf(TEXT("CAdvancedSettings::get_DoubleClickDetect -> %08X, doubleClickDetect = %ld"), hr, *pdoubleClickDetect); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_MaximizeShell(long pmaximizeShell) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_MaximizeShell(%ld)"), pmaximizeShell); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_MaximizeShell(pmaximizeShell); + dbgprintf(TEXT("CAdvancedSettings::put_MaximizeShell -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_MaximizeShell(long * pmaximizeShell) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_MaximizeShell(%p)"), pmaximizeShell); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_MaximizeShell(pmaximizeShell); + dbgprintf(TEXT("CAdvancedSettings::get_MaximizeShell -> %08X, maximizeShell = %ld"), hr, *pmaximizeShell); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyFullScreen(long photKeyFullScreen) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_HotKeyFullScreen(%ld)"), photKeyFullScreen); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_HotKeyFullScreen(photKeyFullScreen); + dbgprintf(TEXT("CAdvancedSettings::put_HotKeyFullScreen -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyFullScreen(long * photKeyFullScreen) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_HotKeyFullScreen(%p)"), photKeyFullScreen); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_HotKeyFullScreen(photKeyFullScreen); + dbgprintf(TEXT("CAdvancedSettings::get_HotKeyFullScreen -> %08X, hotKeyFullScreen = %ld"), hr, *photKeyFullScreen); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyCtrlEsc(long photKeyCtrlEsc) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_HotKeyCtrlEsc(%ld)"), photKeyCtrlEsc); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_HotKeyCtrlEsc(photKeyCtrlEsc); + dbgprintf(TEXT("CAdvancedSettings::put_HotKeyCtrlEsc -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyCtrlEsc(long * photKeyCtrlEsc) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_HotKeyCtrlEsc(%p)"), photKeyCtrlEsc); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_HotKeyCtrlEsc(photKeyCtrlEsc); + dbgprintf(TEXT("CAdvancedSettings::get_HotKeyCtrlEsc -> %08X, hotKeyCtrlEsc = %ld"), hr, *photKeyCtrlEsc); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyAltEsc(long photKeyAltEsc) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_HotKeyAltEsc(%ld)"), photKeyAltEsc); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_HotKeyAltEsc(photKeyAltEsc); + dbgprintf(TEXT("CAdvancedSettings::put_HotKeyAltEsc -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyAltEsc(long * photKeyAltEsc) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_HotKeyAltEsc(%p)"), photKeyAltEsc); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_HotKeyAltEsc(photKeyAltEsc); + dbgprintf(TEXT("CAdvancedSettings::get_HotKeyAltEsc -> %08X, hotKeyAltEsc = %ld"), hr, *photKeyAltEsc); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyAltTab(long photKeyAltTab) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_HotKeyAltTab(%ld)"), photKeyAltTab); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_HotKeyAltTab(photKeyAltTab); + dbgprintf(TEXT("CAdvancedSettings::put_HotKeyAltTab -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyAltTab(long * photKeyAltTab) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_HotKeyAltTab(%p)"), photKeyAltTab); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_HotKeyAltTab(photKeyAltTab); + dbgprintf(TEXT("CAdvancedSettings::get_HotKeyAltTab -> %08X, hotKeyAltTab = %ld"), hr, *photKeyAltTab); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyAltShiftTab(long photKeyAltShiftTab) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_HotKeyAltShiftTab(%ld)"), photKeyAltShiftTab); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_HotKeyAltShiftTab(photKeyAltShiftTab); + dbgprintf(TEXT("CAdvancedSettings::put_HotKeyAltShiftTab -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyAltShiftTab(long * photKeyAltShiftTab) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_HotKeyAltShiftTab(%p)"), photKeyAltShiftTab); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_HotKeyAltShiftTab(photKeyAltShiftTab); + dbgprintf(TEXT("CAdvancedSettings::get_HotKeyAltShiftTab -> %08X, hotKeyAltShiftTab = %ld"), hr, *photKeyAltShiftTab); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyAltSpace(long photKeyAltSpace) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_HotKeyAltSpace(%ld)"), photKeyAltSpace); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_HotKeyAltSpace(photKeyAltSpace); + dbgprintf(TEXT("CAdvancedSettings::put_HotKeyAltSpace -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyAltSpace(long * photKeyAltSpace) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_HotKeyAltSpace(%p)"), photKeyAltSpace); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_HotKeyAltSpace(photKeyAltSpace); + dbgprintf(TEXT("CAdvancedSettings::get_HotKeyAltSpace -> %08X, hotKeyAltSpace = %ld"), hr, *photKeyAltSpace); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyCtrlAltDel(long photKeyCtrlAltDel) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_HotKeyCtrlAltDel(%ld)"), photKeyCtrlAltDel); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_HotKeyCtrlAltDel(photKeyCtrlAltDel); + dbgprintf(TEXT("CAdvancedSettings::put_HotKeyCtrlAltDel -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyCtrlAltDel(long * photKeyCtrlAltDel) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_HotKeyCtrlAltDel(%p)"), photKeyCtrlAltDel); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_HotKeyCtrlAltDel(photKeyCtrlAltDel); + dbgprintf(TEXT("CAdvancedSettings::get_HotKeyCtrlAltDel -> %08X, hotKeyCtrlAltDel = %ld"), hr, *photKeyCtrlAltDel); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_orderDrawThreshold(long porderDrawThreshold) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_orderDrawThreshold(%ld)"), porderDrawThreshold); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_orderDrawThreshold(porderDrawThreshold); + dbgprintf(TEXT("CAdvancedSettings::put_orderDrawThreshold -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_orderDrawThreshold(long * porderDrawThreshold) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_orderDrawThreshold(%p)"), porderDrawThreshold); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_orderDrawThreshold(porderDrawThreshold); + dbgprintf(TEXT("CAdvancedSettings::get_orderDrawThreshold -> %08X, orderDrawThreshold = %ld"), hr, *porderDrawThreshold); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapCacheSize(long pbitmapCacheSize) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_BitmapCacheSize(%ld)"), pbitmapCacheSize); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_BitmapCacheSize(pbitmapCacheSize); + dbgprintf(TEXT("CAdvancedSettings::put_BitmapCacheSize -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapCacheSize(long * pbitmapCacheSize) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_BitmapCacheSize(%p)"), pbitmapCacheSize); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_BitmapCacheSize(pbitmapCacheSize); + dbgprintf(TEXT("CAdvancedSettings::get_BitmapCacheSize -> %08X, bitmapCacheSize = %ld"), hr, *pbitmapCacheSize); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapVirtualCacheSize(long pbitmapVirtualCacheSize) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_BitmapVirtualCacheSize(%ld)"), pbitmapVirtualCacheSize); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_BitmapVirtualCacheSize(pbitmapVirtualCacheSize); + dbgprintf(TEXT("CAdvancedSettings::put_BitmapVirtualCacheSize -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapVirtualCacheSize(long * pbitmapVirtualCacheSize) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_BitmapVirtualCacheSize(%p)"), pbitmapVirtualCacheSize); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_BitmapVirtualCacheSize(pbitmapVirtualCacheSize); + dbgprintf(TEXT("CAdvancedSettings::get_BitmapVirtualCacheSize -> %08X, bitmapVirtualCacheSize = %ld"), hr, *pbitmapVirtualCacheSize); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ScaleBitmapCachesByBPP(long pbScale) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_ScaleBitmapCachesByBPP(%ld)"), pbScale); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_ScaleBitmapCachesByBPP(pbScale); + dbgprintf(TEXT("CAdvancedSettings::put_ScaleBitmapCachesByBPP -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_ScaleBitmapCachesByBPP(long * pbScale) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_ScaleBitmapCachesByBPP(%p)"), pbScale); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_ScaleBitmapCachesByBPP(pbScale); + dbgprintf(TEXT("CAdvancedSettings::get_ScaleBitmapCachesByBPP -> %08X, bScale = %ld"), hr, *pbScale); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_NumBitmapCaches(long pnumBitmapCaches) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_NumBitmapCaches(%ld)"), pnumBitmapCaches); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_NumBitmapCaches(pnumBitmapCaches); + dbgprintf(TEXT("CAdvancedSettings::put_NumBitmapCaches -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_NumBitmapCaches(long * pnumBitmapCaches) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_NumBitmapCaches(%p)"), pnumBitmapCaches); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_NumBitmapCaches(pnumBitmapCaches); + dbgprintf(TEXT("CAdvancedSettings::get_NumBitmapCaches -> %08X, numBitmapCaches = %ld"), hr, *pnumBitmapCaches); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_CachePersistenceActive(long pcachePersistenceActive) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_CachePersistenceActive(%ld)"), pcachePersistenceActive); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_CachePersistenceActive(pcachePersistenceActive); + dbgprintf(TEXT("CAdvancedSettings::put_CachePersistenceActive -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_CachePersistenceActive(long * pcachePersistenceActive) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_CachePersistenceActive(%p)"), pcachePersistenceActive); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_CachePersistenceActive(pcachePersistenceActive); + dbgprintf(TEXT("CAdvancedSettings::get_CachePersistenceActive -> %08X, cachePersistenceActive = %ld"), hr, *pcachePersistenceActive); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_PersistCacheDirectory(BSTR rhs) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_PersistCacheDirectory(%ls)"), rhs); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_PersistCacheDirectory(rhs); + dbgprintf(TEXT("CAdvancedSettings::put_PersistCacheDirectory -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_brushSupportLevel(long pbrushSupportLevel) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_brushSupportLevel(%ld)"), pbrushSupportLevel); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_brushSupportLevel(pbrushSupportLevel); + dbgprintf(TEXT("CAdvancedSettings::put_brushSupportLevel -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_brushSupportLevel(long * pbrushSupportLevel) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_brushSupportLevel(%p)"), pbrushSupportLevel); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_brushSupportLevel(pbrushSupportLevel); + dbgprintf(TEXT("CAdvancedSettings::get_brushSupportLevel -> %08X, brushSupportLevel = %ld"), hr, *pbrushSupportLevel); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_minInputSendInterval(long pminInputSendInterval) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_minInputSendInterval(%ld)"), pminInputSendInterval); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_minInputSendInterval(pminInputSendInterval); + dbgprintf(TEXT("CAdvancedSettings::put_minInputSendInterval -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_minInputSendInterval(long * pminInputSendInterval) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_minInputSendInterval(%p)"), pminInputSendInterval); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_minInputSendInterval(pminInputSendInterval); + dbgprintf(TEXT("CAdvancedSettings::get_minInputSendInterval -> %08X, minInputSendInterval = %ld"), hr, *pminInputSendInterval); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_InputEventsAtOnce(long pinputEventsAtOnce) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_InputEventsAtOnce(%ld)"), pinputEventsAtOnce); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_InputEventsAtOnce(pinputEventsAtOnce); + dbgprintf(TEXT("CAdvancedSettings::put_InputEventsAtOnce -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_InputEventsAtOnce(long * pinputEventsAtOnce) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_InputEventsAtOnce(%p)"), pinputEventsAtOnce); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_InputEventsAtOnce(pinputEventsAtOnce); + dbgprintf(TEXT("CAdvancedSettings::get_InputEventsAtOnce -> %08X, inputEventsAtOnce = %ld"), hr, *pinputEventsAtOnce); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_maxEventCount(long pmaxEventCount) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_maxEventCount(%ld)"), pmaxEventCount); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_maxEventCount(pmaxEventCount); + dbgprintf(TEXT("CAdvancedSettings::put_maxEventCount -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_maxEventCount(long * pmaxEventCount) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_maxEventCount(%p)"), pmaxEventCount); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_maxEventCount(pmaxEventCount); + dbgprintf(TEXT("CAdvancedSettings::get_maxEventCount -> %08X, maxEventCount = %ld"), hr, *pmaxEventCount); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_keepAliveInterval(long pkeepAliveInterval) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_keepAliveInterval(%ld)"), pkeepAliveInterval); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_keepAliveInterval(pkeepAliveInterval); + dbgprintf(TEXT("CAdvancedSettings::put_keepAliveInterval -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_keepAliveInterval(long * pkeepAliveInterval) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_keepAliveInterval(%p)"), pkeepAliveInterval); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_keepAliveInterval(pkeepAliveInterval); + dbgprintf(TEXT("CAdvancedSettings::get_keepAliveInterval -> %08X, keepAliveInterval = %ld"), hr, *pkeepAliveInterval); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_shutdownTimeout(long pshutdownTimeout) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_shutdownTimeout(%ld)"), pshutdownTimeout); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_shutdownTimeout(pshutdownTimeout); + dbgprintf(TEXT("CAdvancedSettings::put_shutdownTimeout -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_shutdownTimeout(long * pshutdownTimeout) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_shutdownTimeout(%p)"), pshutdownTimeout); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_shutdownTimeout(pshutdownTimeout); + dbgprintf(TEXT("CAdvancedSettings::get_shutdownTimeout -> %08X, shutdownTimeout = %ld"), hr, *pshutdownTimeout); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_overallConnectionTimeout(long poverallConnectionTimeout) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_overallConnectionTimeout(%ld)"), poverallConnectionTimeout); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_overallConnectionTimeout(poverallConnectionTimeout); + dbgprintf(TEXT("CAdvancedSettings::put_overallConnectionTimeout -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_overallConnectionTimeout(long * poverallConnectionTimeout) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_overallConnectionTimeout(%p)"), poverallConnectionTimeout); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_overallConnectionTimeout(poverallConnectionTimeout); + dbgprintf(TEXT("CAdvancedSettings::get_overallConnectionTimeout -> %08X, overallConnectionTimeout = %ld"), hr, *poverallConnectionTimeout); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_singleConnectionTimeout(long psingleConnectionTimeout) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_singleConnectionTimeout(%ld)"), psingleConnectionTimeout); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_singleConnectionTimeout(psingleConnectionTimeout); + dbgprintf(TEXT("CAdvancedSettings::put_singleConnectionTimeout -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_singleConnectionTimeout(long * psingleConnectionTimeout) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_singleConnectionTimeout(%p)"), psingleConnectionTimeout); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_singleConnectionTimeout(psingleConnectionTimeout); + dbgprintf(TEXT("CAdvancedSettings::get_singleConnectionTimeout -> %08X, singleConnectionTimeout = %ld"), hr, *psingleConnectionTimeout); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_KeyboardType(long pkeyboardType) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_KeyboardType(%ld)"), pkeyboardType); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_KeyboardType(pkeyboardType); + dbgprintf(TEXT("CAdvancedSettings::put_KeyboardType -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_KeyboardType(long * pkeyboardType) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_KeyboardType(%p)"), pkeyboardType); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_KeyboardType(pkeyboardType); + dbgprintf(TEXT("CAdvancedSettings::get_KeyboardType -> %08X, keyboardType = %ld"), hr, *pkeyboardType); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_KeyboardSubType(long pkeyboardSubType) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_KeyboardSubType(%ld)"), pkeyboardSubType); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_KeyboardSubType(pkeyboardSubType); + dbgprintf(TEXT("CAdvancedSettings::put_KeyboardSubType -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_KeyboardSubType(long * pkeyboardSubType) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_KeyboardSubType(%p)"), pkeyboardSubType); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_KeyboardSubType(pkeyboardSubType); + dbgprintf(TEXT("CAdvancedSettings::get_KeyboardSubType -> %08X, keyboardSubType = %ld"), hr, *pkeyboardSubType); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_KeyboardFunctionKey(long pkeyboardFunctionKey) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_KeyboardFunctionKey(%ld)"), pkeyboardFunctionKey); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_KeyboardFunctionKey(pkeyboardFunctionKey); + dbgprintf(TEXT("CAdvancedSettings::put_KeyboardFunctionKey -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_KeyboardFunctionKey(long * pkeyboardFunctionKey) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_KeyboardFunctionKey(%p)"), pkeyboardFunctionKey); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_KeyboardFunctionKey(pkeyboardFunctionKey); + dbgprintf(TEXT("CAdvancedSettings::get_KeyboardFunctionKey -> %08X, keyboardFunctionKey = %ld"), hr, *pkeyboardFunctionKey); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_WinceFixedPalette(long pwinceFixedPalette) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_WinceFixedPalette(%ld)"), pwinceFixedPalette); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_WinceFixedPalette(pwinceFixedPalette); + dbgprintf(TEXT("CAdvancedSettings::put_WinceFixedPalette -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_WinceFixedPalette(long * pwinceFixedPalette) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_WinceFixedPalette(%p)"), pwinceFixedPalette); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_WinceFixedPalette(pwinceFixedPalette); + dbgprintf(TEXT("CAdvancedSettings::get_WinceFixedPalette -> %08X, winceFixedPalette = %ld"), hr, *pwinceFixedPalette); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ConnectToServerConsole(VARIANT_BOOL pConnectToConsole) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_ConnectToServerConsole(%s)"), BooleanToString(pConnectToConsole)); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_ConnectToServerConsole(pConnectToConsole); + dbgprintf(TEXT("CAdvancedSettings::put_ConnectToServerConsole -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_ConnectToServerConsole(VARIANT_BOOL * pConnectToConsole) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_ConnectToServerConsole(%p)"), pConnectToConsole); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_ConnectToServerConsole(pConnectToConsole); + dbgprintf(TEXT("CAdvancedSettings::get_ConnectToServerConsole -> %08X, ConnectToConsole = %s"), hr, BooleanToString(*pConnectToConsole)); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapPersistence(long pbitmapPersistence) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_BitmapPersistence(%ld)"), pbitmapPersistence); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_BitmapPersistence(pbitmapPersistence); + dbgprintf(TEXT("CAdvancedSettings::put_BitmapPersistence -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapPersistence(long * pbitmapPersistence) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_BitmapPersistence(%p)"), pbitmapPersistence); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_BitmapPersistence(pbitmapPersistence); + dbgprintf(TEXT("CAdvancedSettings::get_BitmapPersistence -> %08X, bitmapPersistence = %ld"), hr, *pbitmapPersistence); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_MinutesToIdleTimeout(long pminutesToIdleTimeout) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_MinutesToIdleTimeout(%ld)"), pminutesToIdleTimeout); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_MinutesToIdleTimeout(pminutesToIdleTimeout); + dbgprintf(TEXT("CAdvancedSettings::put_MinutesToIdleTimeout -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_MinutesToIdleTimeout(long * pminutesToIdleTimeout) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_MinutesToIdleTimeout(%p)"), pminutesToIdleTimeout); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_MinutesToIdleTimeout(pminutesToIdleTimeout); + dbgprintf(TEXT("CAdvancedSettings::get_MinutesToIdleTimeout -> %08X, minutesToIdleTimeout = %ld"), hr, *pminutesToIdleTimeout); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_SmartSizing(VARIANT_BOOL pfSmartSizing) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_SmartSizing(%s)"), BooleanToString(pfSmartSizing)); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_SmartSizing(pfSmartSizing); + dbgprintf(TEXT("CAdvancedSettings::put_SmartSizing -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_SmartSizing(VARIANT_BOOL * pfSmartSizing) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_SmartSizing(%p)"), pfSmartSizing); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_SmartSizing(pfSmartSizing); + dbgprintf(TEXT("CAdvancedSettings::get_SmartSizing -> %08X, fSmartSizing = %s"), hr, BooleanToString(*pfSmartSizing)); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RdpdrLocalPrintingDocName(BSTR pLocalPrintingDocName) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_RdpdrLocalPrintingDocName(%ls)"), pLocalPrintingDocName); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_RdpdrLocalPrintingDocName(pLocalPrintingDocName); + dbgprintf(TEXT("CAdvancedSettings::put_RdpdrLocalPrintingDocName -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RdpdrLocalPrintingDocName(BSTR * pLocalPrintingDocName) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_RdpdrLocalPrintingDocName(%p)"), pLocalPrintingDocName); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_RdpdrLocalPrintingDocName(pLocalPrintingDocName); + dbgprintf(TEXT("CAdvancedSettings::get_RdpdrLocalPrintingDocName -> %08X, LocalPrintingDocName = %ls"), hr, *pLocalPrintingDocName); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RdpdrClipCleanTempDirString(BSTR clipCleanTempDirString) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_RdpdrClipCleanTempDirString(%ls)"), clipCleanTempDirString); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_RdpdrClipCleanTempDirString(clipCleanTempDirString); + dbgprintf(TEXT("CAdvancedSettings::put_RdpdrClipCleanTempDirString -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RdpdrClipCleanTempDirString(BSTR * clipCleanTempDirString) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_RdpdrClipCleanTempDirString(%p)"), clipCleanTempDirString); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_RdpdrClipCleanTempDirString(clipCleanTempDirString); + dbgprintf(TEXT("CAdvancedSettings::get_RdpdrClipCleanTempDirString -> %08X, clipCleanTempDirString = %ls"), hr, *clipCleanTempDirString); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RdpdrClipPasteInfoString(BSTR clipPasteInfoString) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_RdpdrClipPasteInfoString(%ls)"), clipPasteInfoString); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_RdpdrClipPasteInfoString(clipPasteInfoString); + dbgprintf(TEXT("CAdvancedSettings::put_RdpdrClipPasteInfoString -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RdpdrClipPasteInfoString(BSTR * clipPasteInfoString) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_RdpdrClipPasteInfoString(%p)"), clipPasteInfoString); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_RdpdrClipPasteInfoString(clipPasteInfoString); + dbgprintf(TEXT("CAdvancedSettings::get_RdpdrClipPasteInfoString -> %08X, clipPasteInfoString = %ls"), hr, *clipPasteInfoString); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ClearTextPassword(BSTR rhs) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_ClearTextPassword(%ls)"), rhs); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_ClearTextPassword(rhs); + dbgprintf(TEXT("CAdvancedSettings::put_ClearTextPassword -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_DisplayConnectionBar(VARIANT_BOOL pDisplayConnectionBar) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_DisplayConnectionBar(%s)"), BooleanToString(pDisplayConnectionBar)); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_DisplayConnectionBar(pDisplayConnectionBar); + dbgprintf(TEXT("CAdvancedSettings::put_DisplayConnectionBar -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_DisplayConnectionBar(VARIANT_BOOL * pDisplayConnectionBar) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_DisplayConnectionBar(%p)"), pDisplayConnectionBar); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_DisplayConnectionBar(pDisplayConnectionBar); + dbgprintf(TEXT("CAdvancedSettings::get_DisplayConnectionBar -> %08X, DisplayConnectionBar = %s"), hr, BooleanToString(*pDisplayConnectionBar)); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_PinConnectionBar(VARIANT_BOOL pPinConnectionBar) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_PinConnectionBar(%s)"), BooleanToString(pPinConnectionBar)); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_PinConnectionBar(pPinConnectionBar); + dbgprintf(TEXT("CAdvancedSettings::put_PinConnectionBar -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_PinConnectionBar(VARIANT_BOOL * pPinConnectionBar) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_PinConnectionBar(%p)"), pPinConnectionBar); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_PinConnectionBar(pPinConnectionBar); + dbgprintf(TEXT("CAdvancedSettings::get_PinConnectionBar -> %08X, PinConnectionBar = %s"), hr, BooleanToString(*pPinConnectionBar)); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_GrabFocusOnConnect(VARIANT_BOOL pfGrabFocusOnConnect) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_GrabFocusOnConnect(%s)"), BooleanToString(pfGrabFocusOnConnect)); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_GrabFocusOnConnect(pfGrabFocusOnConnect); + dbgprintf(TEXT("CAdvancedSettings::put_GrabFocusOnConnect -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_GrabFocusOnConnect(VARIANT_BOOL * pfGrabFocusOnConnect) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_GrabFocusOnConnect(%p)"), pfGrabFocusOnConnect); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_GrabFocusOnConnect(pfGrabFocusOnConnect); + dbgprintf(TEXT("CAdvancedSettings::get_GrabFocusOnConnect -> %08X, fGrabFocusOnConnect = %s"), hr, BooleanToString(*pfGrabFocusOnConnect)); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_LoadBalanceInfo(BSTR pLBInfo) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_LoadBalanceInfo(%ls)"), pLBInfo); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_LoadBalanceInfo(pLBInfo); + dbgprintf(TEXT("CAdvancedSettings::put_LoadBalanceInfo -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_LoadBalanceInfo(BSTR * pLBInfo) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_LoadBalanceInfo(%p)"), pLBInfo); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_LoadBalanceInfo(pLBInfo); + dbgprintf(TEXT("CAdvancedSettings::get_LoadBalanceInfo -> %08X, LBInfo = %ls"), hr, *pLBInfo); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RedirectDrives(VARIANT_BOOL pRedirectDrives) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_RedirectDrives(%s)"), BooleanToString(pRedirectDrives)); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_RedirectDrives(pRedirectDrives); + dbgprintf(TEXT("CAdvancedSettings::put_RedirectDrives -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RedirectDrives(VARIANT_BOOL * pRedirectDrives) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_RedirectDrives(%p)"), pRedirectDrives); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_RedirectDrives(pRedirectDrives); + dbgprintf(TEXT("CAdvancedSettings::get_RedirectDrives -> %08X, RedirectDrives = %s"), hr, BooleanToString(*pRedirectDrives)); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RedirectPrinters(VARIANT_BOOL pRedirectPrinters) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_RedirectPrinters(%s)"), BooleanToString(pRedirectPrinters)); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_RedirectPrinters(pRedirectPrinters); + dbgprintf(TEXT("CAdvancedSettings::put_RedirectPrinters -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RedirectPrinters(VARIANT_BOOL * pRedirectPrinters) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_RedirectPrinters(%p)"), pRedirectPrinters); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_RedirectPrinters(pRedirectPrinters); + dbgprintf(TEXT("CAdvancedSettings::get_RedirectPrinters -> %08X, RedirectPrinters = %s"), hr, BooleanToString(*pRedirectPrinters)); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RedirectPorts(VARIANT_BOOL pRedirectPorts) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_RedirectPorts(%s)"), BooleanToString(pRedirectPorts)); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_RedirectPorts(pRedirectPorts); + dbgprintf(TEXT("CAdvancedSettings::put_RedirectPorts -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RedirectPorts(VARIANT_BOOL * pRedirectPorts) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_RedirectPorts(%p)"), pRedirectPorts); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_RedirectPorts(pRedirectPorts); + dbgprintf(TEXT("CAdvancedSettings::get_RedirectPorts -> %08X, RedirectPorts = %s"), hr, BooleanToString(*pRedirectPorts)); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RedirectSmartCards(VARIANT_BOOL pRedirectSmartCards) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_RedirectSmartCards(%s)"), BooleanToString(pRedirectSmartCards)); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_RedirectSmartCards(pRedirectSmartCards); + dbgprintf(TEXT("CAdvancedSettings::put_RedirectSmartCards -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RedirectSmartCards(VARIANT_BOOL * pRedirectSmartCards) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_RedirectSmartCards(%p)"), pRedirectSmartCards); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_RedirectSmartCards(pRedirectSmartCards); + dbgprintf(TEXT("CAdvancedSettings::get_RedirectSmartCards -> %08X, RedirectSmartCards = %s"), hr, BooleanToString(*pRedirectSmartCards)); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapVirtualCache16BppSize(long pBitmapVirtualCache16BppSize) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_BitmapVirtualCache16BppSize(%ld)"), pBitmapVirtualCache16BppSize); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_BitmapVirtualCache16BppSize(pBitmapVirtualCache16BppSize); + dbgprintf(TEXT("CAdvancedSettings::put_BitmapVirtualCache16BppSize -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapVirtualCache16BppSize(long * pBitmapVirtualCache16BppSize) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_BitmapVirtualCache16BppSize(%p)"), pBitmapVirtualCache16BppSize); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_BitmapVirtualCache16BppSize(pBitmapVirtualCache16BppSize); + dbgprintf(TEXT("CAdvancedSettings::get_BitmapVirtualCache16BppSize -> %08X, BitmapVirtualCache16BppSize = %ld"), hr, *pBitmapVirtualCache16BppSize); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapVirtualCache24BppSize(long pBitmapVirtualCache24BppSize) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_BitmapVirtualCache24BppSize(%ld)"), pBitmapVirtualCache24BppSize); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_BitmapVirtualCache24BppSize(pBitmapVirtualCache24BppSize); + dbgprintf(TEXT("CAdvancedSettings::put_BitmapVirtualCache24BppSize -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapVirtualCache24BppSize(long * pBitmapVirtualCache24BppSize) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_BitmapVirtualCache24BppSize(%p)"), pBitmapVirtualCache24BppSize); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_BitmapVirtualCache24BppSize(pBitmapVirtualCache24BppSize); + dbgprintf(TEXT("CAdvancedSettings::get_BitmapVirtualCache24BppSize -> %08X, BitmapVirtualCache24BppSize = %ld"), hr, *pBitmapVirtualCache24BppSize); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_PerformanceFlags(long pDisableList) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_PerformanceFlags(%ld)"), pDisableList); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_PerformanceFlags(pDisableList); + dbgprintf(TEXT("CAdvancedSettings::put_PerformanceFlags -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_PerformanceFlags(long * pDisableList) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_PerformanceFlags(%p)"), pDisableList); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_PerformanceFlags(pDisableList); + dbgprintf(TEXT("CAdvancedSettings::get_PerformanceFlags -> %08X, DisableList = %ld"), hr, *pDisableList); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ConnectWithEndpoint(VARIANT * rhs) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_ConnectWithEndpoint(%s)"), VariantToString(*rhs).c_str()); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_ConnectWithEndpoint(rhs); + dbgprintf(TEXT("CAdvancedSettings::put_ConnectWithEndpoint -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_NotifyTSPublicKey(VARIANT_BOOL pfNotify) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::put_NotifyTSPublicKey(%s)"), BooleanToString(pfNotify)); + HRESULT hr = pIMsRdpClientAdvancedSettings->put_NotifyTSPublicKey(pfNotify); + dbgprintf(TEXT("CAdvancedSettings::put_NotifyTSPublicKey -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_NotifyTSPublicKey(VARIANT_BOOL * pfNotify) + { + IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings(); + dbgprintf(TEXT("CAdvancedSettings::get_NotifyTSPublicKey(%p)"), pfNotify); + HRESULT hr = pIMsRdpClientAdvancedSettings->get_NotifyTSPublicKey(pfNotify); + dbgprintf(TEXT("CAdvancedSettings::get_NotifyTSPublicKey -> %08X, fNotify = %s"), hr, BooleanToString(*pfNotify)); + return hr; + } + + /* IMsRdpClientAdvancedSettings2 */ + virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::get_CanAutoReconnect(VARIANT_BOOL * pfCanAutoReconnect) + { + IMsRdpClientAdvancedSettings2 * pIMsRdpClientAdvancedSettings2 = getIMsRdpClientAdvancedSettings2(); + dbgprintf(TEXT("CAdvancedSettings::get_CanAutoReconnect(%p)"), pfCanAutoReconnect); + HRESULT hr = pIMsRdpClientAdvancedSettings2->get_CanAutoReconnect(pfCanAutoReconnect); + dbgprintf(TEXT("CAdvancedSettings::get_CanAutoReconnect -> %08X, fCanAutoReconnect = %s"), hr, BooleanToString(*pfCanAutoReconnect)); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::put_EnableAutoReconnect(VARIANT_BOOL pfEnableAutoReconnect) + { + IMsRdpClientAdvancedSettings2 * pIMsRdpClientAdvancedSettings2 = getIMsRdpClientAdvancedSettings2(); + dbgprintf(TEXT("CAdvancedSettings::put_EnableAutoReconnect(%s)"), BooleanToString(pfEnableAutoReconnect)); + HRESULT hr = pIMsRdpClientAdvancedSettings2->put_EnableAutoReconnect(pfEnableAutoReconnect); + dbgprintf(TEXT("CAdvancedSettings::put_EnableAutoReconnect -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::get_EnableAutoReconnect(VARIANT_BOOL * pfEnableAutoReconnect) + { + IMsRdpClientAdvancedSettings2 * pIMsRdpClientAdvancedSettings2 = getIMsRdpClientAdvancedSettings2(); + dbgprintf(TEXT("CAdvancedSettings::get_EnableAutoReconnect(%p)"), pfEnableAutoReconnect); + HRESULT hr = pIMsRdpClientAdvancedSettings2->get_EnableAutoReconnect(pfEnableAutoReconnect); + dbgprintf(TEXT("CAdvancedSettings::get_EnableAutoReconnect -> %08X, fEnableAutoReconnect = %s"), hr, BooleanToString(*pfEnableAutoReconnect)); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::put_MaxReconnectAttempts(long pMaxReconnectAttempts) + { + IMsRdpClientAdvancedSettings2 * pIMsRdpClientAdvancedSettings2 = getIMsRdpClientAdvancedSettings2(); + dbgprintf(TEXT("CAdvancedSettings::put_MaxReconnectAttempts(%ld)"), pMaxReconnectAttempts); + HRESULT hr = pIMsRdpClientAdvancedSettings2->put_MaxReconnectAttempts(pMaxReconnectAttempts); + dbgprintf(TEXT("CAdvancedSettings::put_MaxReconnectAttempts -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::get_MaxReconnectAttempts(long * pMaxReconnectAttempts) + { + IMsRdpClientAdvancedSettings2 * pIMsRdpClientAdvancedSettings2 = getIMsRdpClientAdvancedSettings2(); + dbgprintf(TEXT("CAdvancedSettings::get_MaxReconnectAttempts(%p)"), pMaxReconnectAttempts); + HRESULT hr = pIMsRdpClientAdvancedSettings2->get_MaxReconnectAttempts(pMaxReconnectAttempts); + dbgprintf(TEXT("CAdvancedSettings::get_MaxReconnectAttempts -> %08X, MaxReconnectAttempts = %ld"), hr, *pMaxReconnectAttempts); + return hr; + } + + /* IMsRdpClientAdvancedSettings3 */ + virtual STDMETHODIMP IMsRdpClientAdvancedSettings3::put_ConnectionBarShowMinimizeButton(VARIANT_BOOL pfShowMinimize) + { + IMsRdpClientAdvancedSettings3 * pIMsRdpClientAdvancedSettings3 = getIMsRdpClientAdvancedSettings3(); + dbgprintf(TEXT("CAdvancedSettings::put_ConnectionBarShowMinimizeButton(%s)"), BooleanToString(pfShowMinimize)); + HRESULT hr = pIMsRdpClientAdvancedSettings3->put_ConnectionBarShowMinimizeButton(pfShowMinimize); + dbgprintf(TEXT("CAdvancedSettings::put_ConnectionBarShowMinimizeButton -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings3::get_ConnectionBarShowMinimizeButton(VARIANT_BOOL * pfShowMinimize) + { + IMsRdpClientAdvancedSettings3 * pIMsRdpClientAdvancedSettings3 = getIMsRdpClientAdvancedSettings3(); + dbgprintf(TEXT("CAdvancedSettings::get_ConnectionBarShowMinimizeButton(%p)"), pfShowMinimize); + HRESULT hr = pIMsRdpClientAdvancedSettings3->get_ConnectionBarShowMinimizeButton(pfShowMinimize); + dbgprintf(TEXT("CAdvancedSettings::get_ConnectionBarShowMinimizeButton -> %08X, fShowMinimize = %s"), hr, BooleanToString(*pfShowMinimize)); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings3::put_ConnectionBarShowRestoreButton(VARIANT_BOOL pfShowRestore) + { + IMsRdpClientAdvancedSettings3 * pIMsRdpClientAdvancedSettings3 = getIMsRdpClientAdvancedSettings3(); + dbgprintf(TEXT("CAdvancedSettings::put_ConnectionBarShowRestoreButton(%s)"), BooleanToString(pfShowRestore)); + HRESULT hr = pIMsRdpClientAdvancedSettings3->put_ConnectionBarShowRestoreButton(pfShowRestore); + dbgprintf(TEXT("CAdvancedSettings::put_ConnectionBarShowRestoreButton -> %08X"), hr); + return hr; + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings3::get_ConnectionBarShowRestoreButton(VARIANT_BOOL * pfShowRestore) + { + IMsRdpClientAdvancedSettings3 * pIMsRdpClientAdvancedSettings3 = getIMsRdpClientAdvancedSettings3(); + dbgprintf(TEXT("CAdvancedSettings::get_ConnectionBarShowRestoreButton(%p)"), pfShowRestore); + HRESULT hr = pIMsRdpClientAdvancedSettings3->get_ConnectionBarShowRestoreButton(pfShowRestore); + dbgprintf(TEXT("CAdvancedSettings::get_ConnectionBarShowRestoreButton -> %08X, fShowRestore = %s"), hr, BooleanToString(*pfShowRestore)); + return hr; + } + + /* IMsRdpClientAdvancedSettings4 */ + virtual STDMETHODIMP IMsRdpClientAdvancedSettings4::put_AuthenticationLevel(unsigned int puiAuthLevel) + { + IMsRdpClientAdvancedSettings4 * pIMsRdpClientAdvancedSettings4 = getIMsRdpClientAdvancedSettings4(); + dbgprintf(TEXT("CAdvancedSettings::put_AuthenticationLevel(%u)"), puiAuthLevel); + HRESULT hr = pIMsRdpClientAdvancedSettings4->put_AuthenticationLevel(puiAuthLevel); + dbgprintf(TEXT("CAdvancedSettings::put_AuthenticationLevel -> %08X"), hr); + return hr; + } + virtual STDMETHODIMP IMsRdpClientAdvancedSettings4::get_AuthenticationLevel(unsigned int * puiAuthLevel) + { + IMsRdpClientAdvancedSettings4 * pIMsRdpClientAdvancedSettings4 = getIMsRdpClientAdvancedSettings4(); + dbgprintf(TEXT("CAdvancedSettings::get_AuthenticationLevel(%p)"), puiAuthLevel); + HRESULT hr = pIMsRdpClientAdvancedSettings4->get_AuthenticationLevel(puiAuthLevel); + dbgprintf(TEXT("CAdvancedSettings::get_AuthenticationLevel -> %08X, uiAuthLevel = %ld"), hr, *puiAuthLevel); + return hr; + } + }; + class CoClass: /* Standard interfaces */ public IUnknown, @@ -575,9 +2649,153 @@ namespace return m_IMsRdpClientNonScriptable2; } - public: - CoClass(IUnknown * pUnknw): + private: + IUnknown * m_outer; + + HRESULT queryInterface(REFIID riid, void ** ppvObject) + { + HRESULT hr; + IUnknown * pvObject = NULL; + + dbgprintf(TEXT("IUnknown::QueryInterface(%ls, %p)"), UUIDToString(riid).c_str(), ppvObject); + +#define QIBEGIN() \ + if(riid == IID_IUnknown) \ + { \ + assert(0); \ + } + +#define QI(I) \ + else if(riid == IID_ ## I) \ + { \ + if(m_ ## I) \ + { \ + m_ ## I->AddRef(); \ + hr = S_OK; \ + } \ + else \ + { \ + hr = m_IUnknown->QueryInterface(&m_ ## I); \ + } \ + \ + if(SUCCEEDED(hr)) \ + pvObject = static_cast(this); \ + } + +#define QIEND() \ + else \ + { \ + hr = E_NOINTERFACE; \ + pvObject = NULL; \ + } + + QIBEGIN() + + /* Standard interfaces */ + QI(IDispatch) + QI(IConnectionPointContainer) + QI(IDataObject) + QI(IObjectSafety) + QI(IOleControl) + QI(IOleInPlaceActiveObject) + QI(IOleInPlaceObject) + QI(IOleObject) + QI(IOleWindow) + QI(IPersist) + QI(IPersistPropertyBag) + QI(IPersistStorage) + QI(IPersistStreamInit) + QI(IProvideClassInfo) + QI(IProvideClassInfo2) + QI(IQuickActivate) + QI(ISpecifyPropertyPages) + QI(IViewObject) + QI(IViewObject2) + + /* Terminal services client */ + QI(IMsRdpClient) + QI(IMsRdpClient2) + QI(IMsRdpClient3) + QI(IMsRdpClient4) + QI(IMsTscAx) + QI(IMsTscNonScriptable) + QI(IMsRdpClientNonScriptable) + QI(IMsRdpClientNonScriptable2) + QIEND() + +#undef QIBEGIN +#undef QIEND +#undef QI + + if(SUCCEEDED(hr)) + { + assert(pvObject); + pvObject->AddRef(); + } + else + { + assert(pvObject == NULL); + } + + *ppvObject = pvObject; + + dbgprintf(TEXT("IUnknown::QueryInterface -> %08X, ppvObject = %p"), hr, *ppvObject); + return hr; + } + + ULONG addRef() + { + return InterlockedIncrement(&m_refCount); + } + + ULONG release() + { + LONG n = InterlockedDecrement(&m_refCount); + + if(n == 0) + delete this; + + return n; + } + + friend class CoClassInner; + + class CoClassInner: public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void ** ppvObject) + { + if(riid == IID_IUnknown) + { + AddRef(); + *ppvObject = this; + return S_OK; + } + + return InnerToOuter(this)->queryInterface(riid, ppvObject); + } + + virtual ULONG STDMETHODCALLTYPE AddRef() + { + return InnerToOuter(this)->addRef(); + } + + virtual ULONG STDMETHODCALLTYPE Release() + { + return InnerToOuter(this)->release(); + } + } + m_inner; + + static CoClass * InnerToOuter(CoClassInner * inner) + { + return CONTAINING_RECORD(inner, CoClass, m_inner); + } + + private: + CoClass(IUnknown * pUnknw, IUnknown * pUnkOuter): m_refCount(1), + m_outer(pUnkOuter), m_IUnknown(pUnknw), m_IDispatch(NULL), m_IConnectionPointContainer(NULL), @@ -607,9 +2825,41 @@ namespace m_IMsRdpClientNonScriptable(NULL), m_IMsRdpClientNonScriptable2(NULL) { - m_IUnknown->AddRef(); + if(m_outer == NULL) + m_outer = &m_inner; } + public: + static HRESULT CreateInstance(IUnknown * pUnknw, IUnknown * pUnkOuter, REFIID riid, void ** ppvObject) + { + HRESULT hr = S_OK; + + if(pUnkOuter && riid != IID_IUnknown) + hr = CLASS_E_NOAGGREGATION; + else + { + CoClass * p = new CoClass(pUnknw, pUnkOuter); + + if(p == NULL) + hr = E_OUTOFMEMORY; + else + { + hr = p->m_inner.QueryInterface(riid, ppvObject); + + if(FAILED(hr)) + delete p; + else + p->m_inner.Release(); + } + } + + if(FAILED(hr)) + pUnknw->Release(); + + return hr; + } + + private: ~CoClass() { if(m_IUnknown) @@ -701,220 +2951,21 @@ namespace public: virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void ** ppvObject) { - HRESULT hr; - IUnknown * pvObject = NULL; - - dbgprintf(TEXT("IUnknown::QueryInterface(%ls, %p)"), UUIDToString(riid).c_str(), ppvObject); - -#define QIBEGIN() \ - if(riid == IID_IUnknown) \ - { \ - hr = S_OK; \ - pvObject = (IUnknown *)(this); \ - } - -#define QI(I) \ - else if(riid == IID_ ## I) \ - { \ - if(m_ ## I) \ - { \ - m_ ## I->AddRef(); \ - hr = S_OK; \ - } \ - else \ - { \ - hr = m_IUnknown->QueryInterface(&m_ ## I); \ - } \ - \ - if(SUCCEEDED(hr)) \ - pvObject = static_cast(this); \ - } - -#define QIEND() \ - else \ - { \ - hr = E_NOINTERFACE; \ - pvObject = NULL; \ - } - - QIBEGIN() - - /* Standard interfaces */ - QI(IDispatch) - QI(IConnectionPointContainer) - QI(IDataObject) - QI(IObjectSafety) - QI(IOleControl) - QI(IOleInPlaceActiveObject) - QI(IOleInPlaceObject) - QI(IOleObject) - QI(IOleWindow) - QI(IPersist) - QI(IPersistPropertyBag) - QI(IPersistStorage) - QI(IPersistStreamInit) - QI(IProvideClassInfo) - QI(IProvideClassInfo2) - QI(IQuickActivate) - QI(ISpecifyPropertyPages) - QI(IViewObject) - QI(IViewObject2) - - /* Terminal services client */ - QI(IMsRdpClient) - QI(IMsRdpClient2) - QI(IMsRdpClient3) - QI(IMsRdpClient4) - QI(IMsTscAx) - QI(IMsTscNonScriptable) - QI(IMsRdpClientNonScriptable) - QI(IMsRdpClientNonScriptable2) - QIEND() - -#undef QIBEGIN -#undef QIEND -#undef QI - - if(SUCCEEDED(hr)) - { - assert(pvObject); - pvObject->AddRef(); - } - else - { - assert(pvObject == NULL); - } - - *ppvObject = pvObject; - - dbgprintf(TEXT("IUnknown::QueryInterface -> %08X, ppvObject = %p"), hr, *ppvObject); - return hr; + return m_outer->QueryInterface(riid, ppvObject); } virtual ULONG STDMETHODCALLTYPE AddRef(void) { - return InterlockedIncrement(&m_refCount); + return m_outer->AddRef(); } virtual ULONG STDMETHODCALLTYPE Release(void) { - LONG n = InterlockedDecrement(&m_refCount); - - if(n == 0) - delete this; - - return n; + return m_outer->Release(); } /* IDispatch */ private: - static std::basic_string VariantToString(const VARIANT& var) - { - std::basic_ostringstream o; - - switch(var.vt & VT_TYPEMASK) - { - case VT_EMPTY: o << ""; break; - case VT_NULL: o << ""; break; - case VT_I2: o << "short"; break; - case VT_I4: o << "long"; break; - case VT_R4: o << "float"; break; - case VT_R8: o << "double"; break; - case VT_CY: o << "CURRENCY"; break; - case VT_DATE: o << "DATE"; break; - case VT_BSTR: o << "string"; break; - case VT_DISPATCH: o << "IDispatch *"; break; - case VT_ERROR: o << "SCODE"; break; - case VT_BOOL: o << "bool"; break; - case VT_VARIANT: o << "VARIANT *"; break; - case VT_UNKNOWN: o << "IUnknown *"; break; - case VT_DECIMAL: o << "DECIMAL"; break; - case VT_I1: o << "char"; break; - case VT_UI1: o << "unsigned char"; break; - case VT_UI2: o << "unsigned short"; break; - case VT_UI4: o << "unsigned long"; break; - case VT_I8: o << "long long"; break; - case VT_UI8: o << "unsigned long long"; break; - case VT_INT: o << "int"; break; - case VT_UINT: o << "unsigned int"; break; - case VT_VOID: o << "void"; break; - case VT_HRESULT: o << "HRESULT"; break; - case VT_PTR: o << "void *"; break; - case VT_SAFEARRAY: o << "SAFEARRAY *"; break; - case VT_LPSTR: o << "LPSTR"; break; - case VT_LPWSTR: o << "LPWSTR"; break; - case VT_RECORD: o << "struct { }"; break; - case VT_INT_PTR: o << "intptr_t"; break; - case VT_UINT_PTR: o << "uintptr_t"; break; - case VT_FILETIME: o << "FILETIME"; break; - default: o << "???"; break; - } - - if(var.vt & VT_ARRAY) - o << "[]"; - else if(var.vt & VT_BYREF) - o << " *"; - else - { - switch(var.vt & VT_TYPEMASK) - { - case VT_EMPTY: - case VT_NULL: - case VT_RECORD: - case VT_VOID: - - // TODO - case VT_CY: - case VT_DATE: - case VT_DECIMAL: - case VT_FILETIME: - break; - - default: - o << " = "; - } - - switch(var.vt & VT_TYPEMASK) - { - case VT_I2: o << var.iVal; break; - case VT_I4: o << var.lVal; break; - case VT_R4: o << var.fltVal; break; - case VT_R8: o << var.dblVal; break; - case VT_BSTR: o << std::wstring(var.bstrVal, var.bstrVal + SysStringLen(var.bstrVal)); break; - case VT_BOOL: o << var.boolVal ? "true" : "false"; break; - case VT_I1: o << int(var.cVal); break; - case VT_UI1: o << unsigned int(var.bVal); break; - case VT_UI2: o << var.uiVal; break; - case VT_UI4: o << var.ulVal; break; - case VT_I8: o << var.llVal; break; - case VT_UI8: o << var.ullVal; break; - case VT_INT: o << var.intVal; break; - case VT_UINT: o << var.uintVal; break; - case VT_LPSTR: o << LPSTR(var.byref); break; - case VT_LPWSTR: o << LPWSTR(var.byref); break; - case VT_INT_PTR: o << var.intVal; break; // BUGBUG - case VT_UINT_PTR: o << var.uintVal; break; // BUGBUG - - case VT_DISPATCH: - case VT_VARIANT: - case VT_UNKNOWN: - case VT_PTR: - case VT_SAFEARRAY: - case VT_RECORD: - o << var.byref; break; - - case VT_ERROR: - case VT_HRESULT: - o << std::hex << var.ulVal; break; - - default: - assert(0); - } - } - - return o.str(); - } - static void FreeExcepInfo(const EXCEPINFO& excepInfo) { if(excepInfo.bstrSource) @@ -1031,7 +3082,8 @@ namespace return hr; } - virtual HRESULT STDMETHODCALLTYPE Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pDispParams, VARIANT * pVarResult, EXCEPINFO * pExcepInfo, UINT * puArgErr) + + virtual HRESULT STDMETHODCALLTYPE Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pDispParams, VARIANT * pVarResult, EXCEPINFO * pExcepInfo, UINT * puArgErr) { IDispatch * pIDispatch = getIDispatch(); @@ -1082,9 +3134,12 @@ namespace { IConnectionPointContainer * pIConnectionPointContainer = getIConnectionPointContainer(); dbgprintf(TEXT("IConnectionPointContainer::EnumConnectionPoints(%p)"), ppEnum); - // TODO: hook enumerator HRESULT hr = pIConnectionPointContainer->EnumConnectionPoints(ppEnum); dbgprintf(TEXT("IConnectionPointContainer::EnumConnectionPoints -> %08X, pEnum = %p"), hr, *ppEnum); + + if(SUCCEEDED(hr)) + *ppEnum = HookIEnumConnectionPoints(*ppEnum); + return hr; } @@ -1092,9 +3147,12 @@ namespace { IConnectionPointContainer * pIConnectionPointContainer = getIConnectionPointContainer(); dbgprintf(TEXT("IConnectionPointContainer::FindConnectionPoint(%ls, %p)"), UUIDToString(riid).c_str(), ppCP); - // TODO: hook connection point HRESULT hr = pIConnectionPointContainer->FindConnectionPoint(riid, ppCP); dbgprintf(TEXT("IConnectionPointContainer::FindConnectionPoint -> %08X, pCP = %p"), hr, *ppCP); + + if(SUCCEEDED(hr)) + *ppCP = HookIConnectionPoint(*ppCP); + return hr; } @@ -1279,6 +3337,7 @@ namespace dbgprintf(TEXT("IDataObject::EnumFormatEtc(%lu, %p)"), dwDirection, ppenumFormatEtc); HRESULT hr = pIDataObject->EnumFormatEtc(dwDirection, ppenumFormatEtc); dbgprintf(TEXT("IDataObject::EnumFormatEtc -> %08X, penumFormatEtc = %p"), hr, *ppenumFormatEtc); + // TODO: hook return hr; } @@ -1288,6 +3347,7 @@ namespace dbgprintf(TEXT("IDataObject::DAdvise(%s, %lu, %p, %p)"), FormatEtcToString(*pformatetc).c_str(), advf, pAdvSink, pdwConnection); HRESULT hr = pIDataObject->DAdvise(pformatetc, advf, pAdvSink, pdwConnection); dbgprintf(TEXT("IDataObject::DAdvise -> %08X, dwConnection = %lu"), hr, *pdwConnection); + // TODO: hook return hr; } @@ -1306,6 +3366,7 @@ namespace dbgprintf(TEXT("IDataObject::EnumDAdvise(%p)"), ppenumAdvise); HRESULT hr = pIDataObject->EnumDAdvise(ppenumAdvise); dbgprintf(TEXT("IDataObject::EnumDAdvise -> %08X, penumAdvise = %p"), hr, *ppenumAdvise); + // TODO: hook return hr; } @@ -1319,7 +3380,8 @@ namespace dbgprintf(TEXT("IObjectSafety::GetInterfaceSafetyOptions -> %08X, dwSupportedOptions = %08X, dwEnabledOptions = %08X"), hr, *pdwSupportedOptions, *pdwEnabledOptions); return hr; } - virtual HRESULT STDMETHODCALLTYPE IObjectSafety::SetInterfaceSafetyOptions(REFIID riid, DWORD dwOptionSetMask, DWORD dwEnabledOptions) + + virtual HRESULT STDMETHODCALLTYPE IObjectSafety::SetInterfaceSafetyOptions(REFIID riid, DWORD dwOptionSetMask, DWORD dwEnabledOptions) { IObjectSafety * pIObjectSafety = getIObjectSafety(); dbgprintf(TEXT("IObjectSafety::SetInterfaceSafetyOptions(%ls, %08X, %08X)"), UUIDToString(riid).c_str(), dwOptionSetMask, dwEnabledOptions); @@ -1495,6 +3557,7 @@ namespace virtual HRESULT STDMETHODCALLTYPE ResizeBorder(LPCRECT prcBorder, IOleInPlaceUIWindow * pUIWindow, BOOL fFrameWindow) { + // TODO: hook pUIWindow IOleInPlaceActiveObject * pIOleInPlaceActiveObject = getIOleInPlaceActiveObject(); dbgprintf(TEXT("IOleInPlaceActiveObject::ResizeBorder(%s)"), RectToString(*prcBorder).c_str(), pUIWindow, BooleanToString(fFrameWindow)); HRESULT hr = pIOleInPlaceActiveObject->ResizeBorder(prcBorder, pUIWindow, fFrameWindow); @@ -1573,6 +3636,7 @@ namespace public: virtual HRESULT STDMETHODCALLTYPE SetClientSite(IOleClientSite * pClientSite) { + // TODO: hook pClientSite IOleObject * pIOleObject = getIOleObject(); dbgprintf(TEXT("IOleObject::SetClientSite(%p)"), pClientSite); HRESULT hr = pIOleObject->SetClientSite(pClientSite); @@ -1658,6 +3722,7 @@ namespace dbgprintf(TEXT("IOleObject::EnumVerbs(%p)"), ppEnumOleVerb); HRESULT hr = pIOleObject->EnumVerbs(ppEnumOleVerb); dbgprintf(TEXT("IOleObject::EnumVerbs -> %08X, pEnumOleVerb = %p"), hr, *ppEnumOleVerb); + // TODO: hook return hr; } @@ -1717,6 +3782,7 @@ namespace virtual HRESULT STDMETHODCALLTYPE Advise(IAdviseSink * pAdvSink, DWORD * pdwConnection) { + // TODO: hook pAdvSink IOleObject * pIOleObject = getIOleObject(); dbgprintf(TEXT("IOleObject::Advise(%p, %p)"), pAdvSink, pdwConnection); HRESULT hr = pIOleObject->Advise(pAdvSink, pdwConnection); @@ -1739,6 +3805,7 @@ namespace dbgprintf(TEXT("IOleObject::EnumAdvise(%p)"), ppenumAdvise); HRESULT hr = pIOleObject->EnumAdvise(ppenumAdvise); dbgprintf(TEXT("IOleObject::EnumAdvise -> %08X, penumAdvise = %p"), hr, *ppenumAdvise); + // TODO: hook return hr; } @@ -1778,12 +3845,13 @@ namespace IPersistPropertyBag * pIPersistPropertyBag = getIPersistPropertyBag(); dbgprintf(TEXT("IPersistPropertyBag::InitNew()")); HRESULT hr = pIPersistPropertyBag->InitNew(); - dbgprintf(TEXT("IPersistPropertyBag::InitNew -> %08X, "), hr); + dbgprintf(TEXT("IPersistPropertyBag::InitNew -> %08X"), hr); return hr; } virtual HRESULT STDMETHODCALLTYPE Load(IPropertyBag * pPropBag, IErrorLog * pErrorLog) { + // TODO: hook pPropBag, pErrorLog IPersistPropertyBag * pIPersistPropertyBag = getIPersistPropertyBag(); dbgprintf(TEXT("IPersistPropertyBag::Load(%p, %p)"), pPropBag, pErrorLog); HRESULT hr = pIPersistPropertyBag->Load(pPropBag, pErrorLog); @@ -1793,6 +3861,7 @@ namespace virtual HRESULT STDMETHODCALLTYPE Save(IPropertyBag * pPropBag, BOOL fClearDirty, BOOL fSaveAllProperties) { + // TODO: hook pPropBag IPersistPropertyBag * pIPersistPropertyBag = getIPersistPropertyBag(); dbgprintf(TEXT("IPersistPropertyBag::Save(%p, %s, %s)"), pPropBag, BooleanToString(fClearDirty), BooleanToString(fSaveAllProperties)); HRESULT hr = pIPersistPropertyBag->Save(pPropBag, fClearDirty, fSaveAllProperties); @@ -1807,7 +3876,7 @@ namespace IPersistStorage * pIPersistStorage = getIPersistStorage(); dbgprintf(TEXT("IPersistStorage::IsDirty()")); HRESULT hr = pIPersistStorage->IsDirty(); - dbgprintf(TEXT("IPersistStorage::IsDirty -> %08X, "), hr); + dbgprintf(TEXT("IPersistStorage::IsDirty -> %08X"), hr); return hr; } @@ -1899,7 +3968,7 @@ namespace IPersistStreamInit * pIPersistStreamInit = getIPersistStreamInit(); dbgprintf(TEXT("IPersistStreamInit::InitNew()")); HRESULT hr = pIPersistStreamInit->InitNew(); - dbgprintf(TEXT("IPersistStreamInit::InitNew -> %08X, "), hr); + dbgprintf(TEXT("IPersistStreamInit::InitNew -> %08X"), hr); return hr; } @@ -2115,7 +4184,7 @@ namespace IMsTscAx * pIMsTscAx = getIMsTscAx(); dbgprintf(TEXT("IMsTscAx::put_DisconnectedText(%ls)"), pDisconnectedText); HRESULT hr = pIMsTscAx->put_DisconnectedText(pDisconnectedText); - dbgprintf(TEXT("IMsTscAx::put_DisconnectedText -> %08X, "), hr); + dbgprintf(TEXT("IMsTscAx::put_DisconnectedText -> %08X"), hr); return hr; } @@ -2278,6 +4347,10 @@ namespace dbgprintf(TEXT("IMsTscAx::get_AdvancedSettings(%p)"), ppAdvSettings); HRESULT hr = pIMsTscAx->get_AdvancedSettings(ppAdvSettings); dbgprintf(TEXT("IMsTscAx::get_AdvancedSettings -> %08X, pAdvSettings = %p"), hr, *ppAdvSettings); + + if(SUCCEEDED(hr)) + *ppAdvSettings = new CAdvancedSettings(*ppAdvSettings); + return hr; } @@ -2290,7 +4363,7 @@ namespace return hr; } - virtual HRESULT __stdcall raw_Connect() + virtual HRESULT __stdcall Connect() { IMsTscAx * pIMsTscAx = getIMsTscAx(); dbgprintf(TEXT("IMsTscAx::Connect()")); @@ -2299,16 +4372,16 @@ namespace return hr; } - virtual HRESULT __stdcall raw_Disconnect() + virtual HRESULT __stdcall Disconnect() { IMsTscAx * pIMsTscAx = getIMsTscAx(); dbgprintf(TEXT("IMsTscAx::Disconnect()")); HRESULT hr = pIMsTscAx->Disconnect(); - dbgprintf(TEXT("IMsTscAx::Disconnect -> %08X, "), hr); + dbgprintf(TEXT("IMsTscAx::Disconnect -> %08X"), hr); return hr; } - virtual HRESULT __stdcall raw_CreateVirtualChannels(BSTR newVal) + virtual HRESULT __stdcall CreateVirtualChannels(BSTR newVal) { IMsTscAx * pIMsTscAx = getIMsTscAx(); dbgprintf(TEXT("IMsTscAx::CreateVirtualChannels(%ls)"), newVal); @@ -2317,7 +4390,7 @@ namespace return hr; } - virtual HRESULT __stdcall raw_SendOnVirtualChannel(BSTR chanName, BSTR ChanData) + virtual HRESULT __stdcall SendOnVirtualChannel(BSTR chanName, BSTR ChanData) { IMsTscAx * pIMsTscAx = getIMsTscAx(); dbgprintf(TEXT("IMsTscAx::SendOnVirtualChannel(%ls, %p)"), chanName, ChanData); @@ -2352,6 +4425,10 @@ namespace dbgprintf(TEXT("IMsRdpClient::get_AdvancedSettings2(%p)"), ppAdvSettings); HRESULT hr = pIMsRdpClient->get_AdvancedSettings2(ppAdvSettings); dbgprintf(TEXT("IMsRdpClient::get_AdvancedSettings2 -> %08X, pAdvSettings = %p"), hr, *ppAdvSettings); + + if(SUCCEEDED(hr)) + *ppAdvSettings = new CAdvancedSettings(*ppAdvSettings); + return hr; } @@ -2391,29 +4468,29 @@ namespace return hr; } - virtual HRESULT __stdcall raw_SetVirtualChannelOptions(BSTR chanName, long chanOptions) + virtual HRESULT __stdcall SetVirtualChannelOptions(BSTR chanName, long chanOptions) { IMsRdpClient * pIMsRdpClient = getIMsRdpClient(); dbgprintf(TEXT("IMsRdpClient::SetVirtualChannelOptions(%ls, %08X)"), chanName, chanOptions); - HRESULT hr = pIMsRdpClient->raw_SetVirtualChannelOptions(chanName, chanOptions); + HRESULT hr = pIMsRdpClient->SetVirtualChannelOptions(chanName, chanOptions); dbgprintf(TEXT("IMsRdpClient::SetVirtualChannelOptions -> %08X"), hr); return hr; } - virtual HRESULT __stdcall raw_GetVirtualChannelOptions(BSTR chanName, long * pChanOptions) + virtual HRESULT __stdcall GetVirtualChannelOptions(BSTR chanName, long * pChanOptions) { IMsRdpClient * pIMsRdpClient = getIMsRdpClient(); dbgprintf(TEXT("IMsRdpClient::GetVirtualChannelOptions(%ls, %p)"), chanName, pChanOptions); - HRESULT hr = pIMsRdpClient->raw_GetVirtualChannelOptions(chanName, pChanOptions); + HRESULT hr = pIMsRdpClient->GetVirtualChannelOptions(chanName, pChanOptions); dbgprintf(TEXT("IMsRdpClient::GetVirtualChannelOptions -> %08X, ChanOptions = %08X"), hr, *pChanOptions); return hr; } - virtual HRESULT __stdcall raw_RequestClose(ControlCloseStatus * pCloseStatus) + virtual HRESULT __stdcall RequestClose(ControlCloseStatus * pCloseStatus) { IMsRdpClient * pIMsRdpClient = getIMsRdpClient(); dbgprintf(TEXT("IMsRdpClient::RequestClose(%p)"), pCloseStatus); - HRESULT hr = pIMsRdpClient->raw_RequestClose(pCloseStatus); + HRESULT hr = pIMsRdpClient->RequestClose(pCloseStatus); dbgprintf(TEXT("IMsRdpClient::RequestClose -> %08X, CloseStatus = %ld"), hr, *pCloseStatus); return hr; } @@ -2426,6 +4503,10 @@ namespace dbgprintf(TEXT("IMsRdpClient2::get_AdvancedSettings3(%p)"), ppAdvSettings); HRESULT hr = pIMsRdpClient2->get_AdvancedSettings3(ppAdvSettings); dbgprintf(TEXT("IMsRdpClient2::get_AdvancedSettings3 -> %08X, pAdvSettings = %p"), hr, *ppAdvSettings); + + if(SUCCEEDED(hr)) + *ppAdvSettings = new CAdvancedSettings(*ppAdvSettings); + return hr; } @@ -2455,6 +4536,10 @@ namespace dbgprintf(TEXT("IMsRdpClient3::get_AdvancedSettings4(%p)"), ppAdvSettings); HRESULT hr = pIMsRdpClient3->get_AdvancedSettings4(ppAdvSettings); dbgprintf(TEXT("IMsRdpClient3::get_AdvancedSettings4 -> %08X, pAdvSettings = %p"), hr, *ppAdvSettings); + + if(SUCCEEDED(hr)) + *ppAdvSettings = new CAdvancedSettings(*ppAdvSettings); + return hr; } @@ -2466,6 +4551,10 @@ namespace dbgprintf(TEXT("IMsRdpClient4::get_AdvancedSettings5(%p)"), ppAdvSettings5); HRESULT hr = pIMsRdpClient4->get_AdvancedSettings5(ppAdvSettings5); dbgprintf(TEXT("IMsRdpClient4::get_AdvancedSettings5 -> %08X, pAdvSettings5 = %p"), hr, *ppAdvSettings5); + + if(SUCCEEDED(hr)) + *ppAdvSettings5 = new CAdvancedSettings(*ppAdvSettings5); + return hr; } @@ -2552,11 +4641,11 @@ namespace return hr; } - virtual HRESULT __stdcall raw_ResetPassword() + virtual HRESULT __stdcall ResetPassword() { IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable(); dbgprintf(TEXT("IMsTscNonScriptable::ResetPassword()")); - HRESULT hr = pIMsTscNonScriptable->raw_ResetPassword(); + HRESULT hr = pIMsTscNonScriptable->ResetPassword(); dbgprintf(TEXT("IMsTscNonScriptable::ResetPassword -> %08X"), hr); return hr; } @@ -2564,20 +4653,20 @@ namespace /* IMsRdpClientNonScriptable */ public: - virtual HRESULT __stdcall IMsRdpClientNonScriptable::raw_NotifyRedirectDeviceChange(UINT_PTR wParam, LONG_PTR lParam) + virtual HRESULT __stdcall IMsRdpClientNonScriptable::NotifyRedirectDeviceChange(UINT_PTR wParam, LONG_PTR lParam) { IMsRdpClientNonScriptable * pIMsRdpClientNonScriptable = getIMsRdpClientNonScriptable(); dbgprintf(TEXT("IMsRdpClientNonScriptable::NotifyRedirectDeviceChange(%p, %p)"), wParam, lParam); - HRESULT hr = pIMsRdpClientNonScriptable->raw_NotifyRedirectDeviceChange(wParam, lParam); + HRESULT hr = pIMsRdpClientNonScriptable->NotifyRedirectDeviceChange(wParam, lParam); dbgprintf(TEXT("IMsRdpClientNonScriptable::NotifyRedirectDeviceChange -> %08X"), hr); return hr; } - virtual HRESULT __stdcall IMsRdpClientNonScriptable::raw_SendKeys(long numKeys, VARIANT_BOOL * pbArrayKeyUp, long * plKeyData) // TBD + virtual HRESULT __stdcall IMsRdpClientNonScriptable::SendKeys(long numKeys, VARIANT_BOOL * pbArrayKeyUp, long * plKeyData) // TBD { IMsRdpClientNonScriptable * pIMsRdpClientNonScriptable = getIMsRdpClientNonScriptable(); dbgprintf(TEXT("IMsRdpClientNonScriptable::SendKeys(%ld, %p, %p)"), numKeys, pbArrayKeyUp, plKeyData); - HRESULT hr = pIMsRdpClientNonScriptable->raw_SendKeys(numKeys, pbArrayKeyUp, plKeyData); + HRESULT hr = pIMsRdpClientNonScriptable->SendKeys(numKeys, pbArrayKeyUp, plKeyData); dbgprintf(TEXT("IMsRdpClientNonScriptable::SendKeys -> %08X"), hr); return hr; } @@ -2756,32 +4845,9 @@ namespace { IClassFactory * pIClassFactory = getIClassFactory(); dbgprintf(TEXT("IClassFactory::CreateInstance(%p, %ls, %p)"), pUnkOuter, UUIDToString(riid).c_str(), ppvObject); - HRESULT hr = pIClassFactory->CreateInstance(pUnkOuter, riid, ppvObject); + HRESULT hr = pIClassFactory->CreateInstance(NULL, riid, ppvObject); dbgprintf(TEXT("IClassFactory::CreateInstance -> %08X, pvObject = %p"), hr, *ppvObject); - - IUnknown * pv = NULL; - - if(SUCCEEDED(hr)) - { - IUnknown * punk = (IUnknown *)*ppvObject; - - if(pUnkOuter) - hr = CLASS_E_NOAGGREGATION; - else - pv = new CoClass(punk); - - punk->Release(); - } - - if(pv) - { - hr = pv->QueryInterface(riid, ppvObject); - - if(FAILED(hr)) - pv->Release(); - } - - return hr; + return CoClass::CreateInstance((IUnknown *)*ppvObject, pUnkOuter, riid, ppvObject); } virtual HRESULT STDMETHODCALLTYPE LockServer(BOOL fLock) @@ -2817,32 +4883,9 @@ namespace { IClassFactory2 * pIClassFactory2 = getIClassFactory2(); dbgprintf(TEXT("IClassFactory2::CreateInstanceLic(%p, %p, %ls, %ls, %p)"), pUnkOuter, pUnkReserved, UUIDToString(riid).c_str(), bstrKey, ppvObj); - HRESULT hr = pIClassFactory2->CreateInstanceLic(pUnkOuter, pUnkReserved, riid, bstrKey, ppvObj); + HRESULT hr = pIClassFactory2->CreateInstanceLic(NULL, pUnkReserved, riid, bstrKey, ppvObj); dbgprintf(TEXT("IClassFactory2::CreateInstanceLic -> %08X, pvObj = %p"), hr, *ppvObj); - - IUnknown * pv = NULL; - - if(SUCCEEDED(hr)) - { - IUnknown * punk = (IUnknown *)*ppvObj; - - if(pUnkOuter) - hr = CLASS_E_NOAGGREGATION; - else - pv = new CoClass(punk); - - punk->Release(); - } - - if(pv) - { - hr = pv->QueryInterface(riid, ppvObj); - - if(FAILED(hr)) - pv->Release(); - } - - return hr; + return CoClass::CreateInstance((IUnknown *)*ppvObj, pUnkOuter, riid, ppvObj); } }; @@ -2900,7 +4943,6 @@ namespace return ul; } - } // EOF diff --git a/reactos/base/applications/tsclient/porting-tools/mstscax/stdafx.h b/reactos/base/applications/tsclient/porting-tools/mstscax/stdafx.h index f961e90a7bc..df5b57cc4d0 100644 --- a/reactos/base/applications/tsclient/porting-tools/mstscax/stdafx.h +++ b/reactos/base/applications/tsclient/porting-tools/mstscax/stdafx.h @@ -6,6 +6,8 @@ #include #include +#include +#include #define WIN32_LEAN_AND_MEAN #define STRICT @@ -15,12 +17,17 @@ #include #include +#include + #include -//#pragma warning(push) -//#pragma warning(disable:4192) -#import named_guids exclude("LONG_PTR", "UINT_PTR") - -//#pragma warning(pop) +#import "./rdesktop-core-tester.tlb" \ + exclude("LONG_PTR", "UINT_PTR", "wireHWND", "_RemotableHandle", "__MIDL_IWinTypes_0009") \ + named_guids \ + no_implementation \ + no_smart_pointers \ + raw_dispinterfaces \ + raw_interfaces_only \ + raw_native_types // EOF diff --git a/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/activex.cpp b/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/activex.cpp new file mode 100644 index 00000000000..2ecf786de3c --- /dev/null +++ b/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/activex.cpp @@ -0,0 +1,2155 @@ +#include "stdafx.h" + +namespace MSTSCLib +{ +#include "mstsclib_h.h" +}; + +#include "rdesktop/rdesktop.h" +#include "rdesktop/proto.h" + +namespace +{ +#ifdef _MSC_VER + extern "C" char __ImageBase; +#endif + + HMODULE GetCurrentModule() + { + return reinterpret_cast(&__ImageBase); + } +} + +#pragma warning(push) +#pragma warning(disable: 4584) + +class RdpClient: + /* COM basics */ + public IUnknown, + public IDispatch, + + /* ActiveX stuff */ + public IConnectionPointContainer, + public IDataObject, + public IObjectSafety, + public IOleControl, + public IOleInPlaceActiveObject, + public IOleInPlaceObject, + public IOleObject, + public IOleWindow, + public IPersist, + public IPersistPropertyBag, + public IPersistStorage, + public IPersistStreamInit, + public IProvideClassInfo, + public IProvideClassInfo2, + public IQuickActivate, + public IViewObject, + public IViewObject2, + + // NOTE: the original has a vestigial implementation of this, which we omit + // public ISpecifyPropertyPages, + + /* RDP client interface */ + public MSTSCLib::IMsRdpClient4, + public MSTSCLib::IMsRdpClientNonScriptable2, + + /* RDP client context */ + public RDPCLIENT +{ +private: + /* An endless amount of COM glue */ + volatile LONG * m_moduleRefCount; + IUnknown * m_punkOuter; + CLSID m_classId; + ITypeLib * m_typeLib; + ITypeInfo * m_dispTypeInfo; + LONG m_refCount; + + /* Inner IUnknown for aggregation support */ + class RdpClientInner: public IUnknown + { + public: + virtual STDMETHODIMP IUnknown::QueryInterface(REFIID riid, void ** ppvObject) + { + RdpClient * outerThis = InnerToOuter(this); + + using namespace MSTSCLib; + + IUnknown * pvObject = NULL; + + if(riid == IID_IUnknown) + pvObject = static_cast(this); // use of "this" is NOT an error! + else if(riid == IID_IConnectionPointContainer) + pvObject = static_cast(outerThis); + else if(riid == IID_IDataObject) + pvObject = static_cast(outerThis); + else if(riid == IID_IObjectSafety) + pvObject = static_cast(outerThis); + else if(riid == IID_IOleControl) + pvObject = static_cast(outerThis); + else if(riid == IID_IOleInPlaceActiveObject) + pvObject = static_cast(outerThis); + else if(riid == IID_IOleInPlaceObject) + pvObject = static_cast(outerThis); + else if(riid == IID_IOleObject) + pvObject = static_cast(outerThis); + else if(riid == IID_IOleWindow) + pvObject = static_cast(outerThis); + else if(riid == IID_IPersist) + pvObject = static_cast(outerThis); + else if(riid == IID_IPersistPropertyBag) + pvObject = static_cast(outerThis); + else if(riid == IID_IPersistStorage) + pvObject = static_cast(outerThis); + else if(riid == IID_IPersistStreamInit) + pvObject = static_cast(outerThis); + else if(riid == IID_IQuickActivate) + pvObject = static_cast(outerThis); + else if(riid == IID_IViewObject) + pvObject = static_cast(outerThis); + else if(riid == IID_IViewObject2) + pvObject = static_cast(outerThis); + else if(riid == IID_IMsTscAx) + pvObject = static_cast(outerThis); + else if(riid == IID_IMsRdpClient) + pvObject = static_cast(outerThis); + else if(riid == IID_IMsRdpClient2) + pvObject = static_cast(outerThis); + else if(riid == IID_IMsRdpClient3) + pvObject = static_cast(outerThis); + else if(riid == IID_IMsRdpClient4) + pvObject = static_cast(outerThis); + else if(riid == IID_IMsTscNonScriptable) + pvObject = static_cast(outerThis); + else if(riid == IID_IMsRdpClientNonScriptable) + pvObject = static_cast(outerThis); + else if(riid == IID_IMsRdpClientNonScriptable2) + pvObject = static_cast(outerThis); + + *ppvObject = pvObject; + + if(pvObject) + { + pvObject->AddRef(); + return S_OK; + } + + return E_NOINTERFACE; + } + + virtual STDMETHODIMP_(ULONG) IUnknown::AddRef() + { + return InnerToOuter(this)->addRef(); + } + + virtual STDMETHODIMP_(ULONG) IUnknown::Release() + { + return InnerToOuter(this)->release(); + } + + } + m_inner; + + // FIXME: (re)use fixed buffers for these + BSTR m_server; + BSTR m_domain; + BSTR m_userName; + BSTR m_disconnectedText; + BSTR m_connectingText; + BSTR m_fullScreenTitle; + + bool m_nonIdle; + bool m_connected; + bool m_startConnected; + + /* Reference counting */ + ULONG addRef() + { + return InterlockedIncrement(&m_refCount); + } + + ULONG release() + { + LONG n = InterlockedDecrement(&m_refCount); + + if(n == 0) + delete this; + + return n; + } + + /* Constructor */ + RdpClient(REFCLSID classId, IUnknown * punkOuter, LONG * moduleRefCount): + m_classId(classId), + m_punkOuter(punkOuter), + m_moduleRefCount(moduleRefCount) + { + if(m_punkOuter == NULL) + m_punkOuter = &m_inner; + + // TODO: initialize RDPCLIENT fields + } + + /* Destructor */ + ~RdpClient() + { + InterlockedDecrement(m_moduleRefCount); + } + + /* Helpers */ + static HRESULT SetStringProperty(BSTR& prop, BSTR newValue) + { + if(newValue == NULL) + return E_INVALIDARG; + + SysFreeString(prop); + + prop = SysAllocStringLen(newValue, SysStringLen(newValue)); + + if(prop == NULL) + return E_OUTOFMEMORY; + + return S_OK; + } + + static HRESULT GetStringProperty(BSTR& prop, BSTR * retVal) + { + *retVal = SysAllocStringLen(prop, SysStringLen(prop)); + + if(*retVal == NULL) + return E_OUTOFMEMORY; + + return S_OK; + } + + /* Advanced settings */ + friend class AdvancedSettings; + + class AdvancedSettings: public MSTSCLib::IMsRdpClientAdvancedSettings4 + { + private: + /* IDispatch type information */ + ITypeInfo * m_dispTypeInfo; + + HRESULT LoadDispTypeInfo() + { + if(m_dispTypeInfo) + return S_OK; + + HRESULT hr = InnerToOuter(this)->LoadTypeLibrary(); + + if(FAILED(hr)) + return hr; + + hr = InnerToOuter(this)->m_typeLib->GetTypeInfoOfGuid(MSTSCLib::IID_IMsRdpClientAdvancedSettings4, &m_dispTypeInfo); + + if(FAILED(hr)) + return hr; + + assert(m_dispTypeInfo); + return S_OK; + } + + HRESULT AcquireDispTypeInfo(ITypeInfo ** ppTI) + { + HRESULT hr = LoadDispTypeInfo(); + + if(FAILED(hr)) + return hr; + + m_dispTypeInfo->AddRef(); + *ppTI = m_dispTypeInfo; + return S_OK; + } + + public: + ~AdvancedSettings() + { + if(m_dispTypeInfo) + m_dispTypeInfo->Release(); + } + + /* IUnknown */ + virtual STDMETHODIMP IUnknown::QueryInterface(REFIID riid, void ** ppvObject) + { + using namespace MSTSCLib; + + if + ( + riid == IID_IUnknown || + riid == IID_IDispatch || + riid == IID_IMsTscAdvancedSettings || + riid == IID_IMsRdpClientAdvancedSettings || + riid == IID_IMsRdpClientAdvancedSettings2 || + riid == IID_IMsRdpClientAdvancedSettings3 || + riid == IID_IMsRdpClientAdvancedSettings4 + ) + { + *ppvObject = this; + InnerToOuter(this)->addRef(); + return S_OK; + } + else + { + *ppvObject = NULL; + return E_NOINTERFACE; + } + } + + virtual STDMETHODIMP_(ULONG) IUnknown::AddRef() + { + return InnerToOuter(this)->addRef(); + } + + virtual STDMETHODIMP_(ULONG) IUnknown::Release() + { + return InnerToOuter(this)->release(); + } + + /* IDispatch */ + virtual STDMETHODIMP IDispatch::GetTypeInfoCount(UINT * pctinfo) + { + *pctinfo = 1; + return S_OK; + } + + virtual STDMETHODIMP IDispatch::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo ** ppTInfo) + { + if(iTInfo != 0) + return DISP_E_BADINDEX; + + return AcquireDispTypeInfo(ppTInfo); + } + + virtual STDMETHODIMP IDispatch::GetIDsOfNames(REFIID riid, LPOLESTR * rgszNames, UINT cNames, LCID lcid, DISPID * rgDispId) + { + HRESULT hr = LoadDispTypeInfo(); + + if(FAILED(hr)) + return hr; + + return m_dispTypeInfo->GetIDsOfNames(rgszNames, cNames, rgDispId); + } + + virtual STDMETHODIMP IDispatch::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pDispParams, VARIANT * pVarResult, EXCEPINFO * pExcepInfo, UINT * puArgErr) + { + return m_dispTypeInfo->Invoke + ( + static_cast(this), + dispIdMember, + wFlags, + pDispParams, + pVarResult, + pExcepInfo, + puArgErr + ); + } + + /* IMsTscAdvancedSettings */ + virtual STDMETHODIMP IMsTscAdvancedSettings::put_Compress(long pcompress) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::get_Compress(long * pcompress) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::put_BitmapPeristence(long pbitmapPeristence) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::get_BitmapPeristence(long * pbitmapPeristence) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::put_allowBackgroundInput(long pallowBackgroundInput) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::get_allowBackgroundInput(long * pallowBackgroundInput) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::put_KeyBoardLayoutStr(BSTR rhs) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::put_PluginDlls(BSTR rhs) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::put_IconFile(BSTR rhs) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::put_IconIndex(long rhs) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::put_ContainerHandledFullScreen(long pContainerHandledFullScreen) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::get_ContainerHandledFullScreen(long * pContainerHandledFullScreen) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::put_DisableRdpdr(long pDisableRdpdr) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAdvancedSettings::get_DisableRdpdr(long * pDisableRdpdr) + { + return E_NOTIMPL; // TODO + } + + /* IMsRdpClientAdvancedSettings */ + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_SmoothScroll(long psmoothScroll) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_SmoothScroll(long * psmoothScroll) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_AcceleratorPassthrough(long pacceleratorPassthrough) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_AcceleratorPassthrough(long * pacceleratorPassthrough) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ShadowBitmap(long pshadowBitmap) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_ShadowBitmap(long * pshadowBitmap) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_TransportType(long ptransportType) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_TransportType(long * ptransportType) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_SasSequence(long psasSequence) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_SasSequence(long * psasSequence) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_EncryptionEnabled(long pencryptionEnabled) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_EncryptionEnabled(long * pencryptionEnabled) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_DedicatedTerminal(long pdedicatedTerminal) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_DedicatedTerminal(long * pdedicatedTerminal) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RDPPort(long prdpPort) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RDPPort(long * prdpPort) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_EnableMouse(long penableMouse) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_EnableMouse(long * penableMouse) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_DisableCtrlAltDel(long pdisableCtrlAltDel) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_DisableCtrlAltDel(long * pdisableCtrlAltDel) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_EnableWindowsKey(long penableWindowsKey) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_EnableWindowsKey(long * penableWindowsKey) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_DoubleClickDetect(long pdoubleClickDetect) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_DoubleClickDetect(long * pdoubleClickDetect) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_MaximizeShell(long pmaximizeShell) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_MaximizeShell(long * pmaximizeShell) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyFullScreen(long photKeyFullScreen) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyFullScreen(long * photKeyFullScreen) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyCtrlEsc(long photKeyCtrlEsc) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyCtrlEsc(long * photKeyCtrlEsc) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyAltEsc(long photKeyAltEsc) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyAltEsc(long * photKeyAltEsc) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyAltTab(long photKeyAltTab) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyAltTab(long * photKeyAltTab) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyAltShiftTab(long photKeyAltShiftTab) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyAltShiftTab(long * photKeyAltShiftTab) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyAltSpace(long photKeyAltSpace) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyAltSpace(long * photKeyAltSpace) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyCtrlAltDel(long photKeyCtrlAltDel) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyCtrlAltDel(long * photKeyCtrlAltDel) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_orderDrawThreshold(long porderDrawThreshold) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_orderDrawThreshold(long * porderDrawThreshold) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapCacheSize(long pbitmapCacheSize) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapCacheSize(long * pbitmapCacheSize) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapVirtualCacheSize(long pbitmapVirtualCacheSize) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapVirtualCacheSize(long * pbitmapVirtualCacheSize) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ScaleBitmapCachesByBPP(long pbScale) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_ScaleBitmapCachesByBPP(long * pbScale) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_NumBitmapCaches(long pnumBitmapCaches) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_NumBitmapCaches(long * pnumBitmapCaches) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_CachePersistenceActive(long pcachePersistenceActive) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_CachePersistenceActive(long * pcachePersistenceActive) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_PersistCacheDirectory(BSTR rhs) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_brushSupportLevel(long pbrushSupportLevel) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_brushSupportLevel(long * pbrushSupportLevel) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_minInputSendInterval(long pminInputSendInterval) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_minInputSendInterval(long * pminInputSendInterval) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_InputEventsAtOnce(long pinputEventsAtOnce) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_InputEventsAtOnce(long * pinputEventsAtOnce) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_maxEventCount(long pmaxEventCount) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_maxEventCount(long * pmaxEventCount) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_keepAliveInterval(long pkeepAliveInterval) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_keepAliveInterval(long * pkeepAliveInterval) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_shutdownTimeout(long pshutdownTimeout) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_shutdownTimeout(long * pshutdownTimeout) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_overallConnectionTimeout(long poverallConnectionTimeout) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_overallConnectionTimeout(long * poverallConnectionTimeout) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_singleConnectionTimeout(long psingleConnectionTimeout) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_singleConnectionTimeout(long * psingleConnectionTimeout) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_KeyboardType(long pkeyboardType) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_KeyboardType(long * pkeyboardType) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_KeyboardSubType(long pkeyboardSubType) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_KeyboardSubType(long * pkeyboardSubType) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_KeyboardFunctionKey(long pkeyboardFunctionKey) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_KeyboardFunctionKey(long * pkeyboardFunctionKey) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_WinceFixedPalette(long pwinceFixedPalette) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_WinceFixedPalette(long * pwinceFixedPalette) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ConnectToServerConsole(VARIANT_BOOL pConnectToConsole) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_ConnectToServerConsole(VARIANT_BOOL * pConnectToConsole) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapPersistence(long pbitmapPersistence) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapPersistence(long * pbitmapPersistence) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_MinutesToIdleTimeout(long pminutesToIdleTimeout) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_MinutesToIdleTimeout(long * pminutesToIdleTimeout) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_SmartSizing(VARIANT_BOOL pfSmartSizing) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_SmartSizing(VARIANT_BOOL * pfSmartSizing) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RdpdrLocalPrintingDocName(BSTR pLocalPrintingDocName) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RdpdrLocalPrintingDocName(BSTR * pLocalPrintingDocName) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RdpdrClipCleanTempDirString(BSTR clipCleanTempDirString) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RdpdrClipCleanTempDirString(BSTR * clipCleanTempDirString) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RdpdrClipPasteInfoString(BSTR clipPasteInfoString) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RdpdrClipPasteInfoString(BSTR * clipPasteInfoString) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ClearTextPassword(BSTR rhs) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_DisplayConnectionBar(VARIANT_BOOL pDisplayConnectionBar) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_DisplayConnectionBar(VARIANT_BOOL * pDisplayConnectionBar) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_PinConnectionBar(VARIANT_BOOL pPinConnectionBar) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_PinConnectionBar(VARIANT_BOOL * pPinConnectionBar) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_GrabFocusOnConnect(VARIANT_BOOL pfGrabFocusOnConnect) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_GrabFocusOnConnect(VARIANT_BOOL * pfGrabFocusOnConnect) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_LoadBalanceInfo(BSTR pLBInfo) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_LoadBalanceInfo(BSTR * pLBInfo) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RedirectDrives(VARIANT_BOOL pRedirectDrives) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RedirectDrives(VARIANT_BOOL * pRedirectDrives) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RedirectPrinters(VARIANT_BOOL pRedirectPrinters) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RedirectPrinters(VARIANT_BOOL * pRedirectPrinters) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RedirectPorts(VARIANT_BOOL pRedirectPorts) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RedirectPorts(VARIANT_BOOL * pRedirectPorts) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RedirectSmartCards(VARIANT_BOOL pRedirectSmartCards) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RedirectSmartCards(VARIANT_BOOL * pRedirectSmartCards) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapVirtualCache16BppSize(long pBitmapVirtualCache16BppSize) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapVirtualCache16BppSize(long * pBitmapVirtualCache16BppSize) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapVirtualCache24BppSize(long pBitmapVirtualCache24BppSize) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapVirtualCache24BppSize(long * pBitmapVirtualCache24BppSize) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_PerformanceFlags(long pDisableList) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_PerformanceFlags(long * pDisableList) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ConnectWithEndpoint(VARIANT * rhs) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_NotifyTSPublicKey(VARIANT_BOOL pfNotify) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_NotifyTSPublicKey(VARIANT_BOOL * pfNotify) + { + return E_NOTIMPL; // TODO + } + + /* IMsRdpClientAdvancedSettings2 */ + virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::get_CanAutoReconnect(VARIANT_BOOL * pfCanAutoReconnect) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::put_EnableAutoReconnect(VARIANT_BOOL pfEnableAutoReconnect) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::get_EnableAutoReconnect(VARIANT_BOOL * pfEnableAutoReconnect) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::put_MaxReconnectAttempts(long pMaxReconnectAttempts) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::get_MaxReconnectAttempts(long * pMaxReconnectAttempts) + { + return E_NOTIMPL; // TODO + } + + /* IMsRdpClientAdvancedSettings3 */ + virtual STDMETHODIMP IMsRdpClientAdvancedSettings3::put_ConnectionBarShowMinimizeButton(VARIANT_BOOL pfShowMinimize) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings3::get_ConnectionBarShowMinimizeButton(VARIANT_BOOL * pfShowMinimize) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings3::put_ConnectionBarShowRestoreButton(VARIANT_BOOL pfShowRestore) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings3::get_ConnectionBarShowRestoreButton(VARIANT_BOOL * pfShowRestore) + { + return E_NOTIMPL; // TODO + } + + /* IMsRdpClientAdvancedSettings4 */ + virtual STDMETHODIMP IMsRdpClientAdvancedSettings4::put_AuthenticationLevel(unsigned int puiAuthLevel) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientAdvancedSettings4::get_AuthenticationLevel(unsigned int * puiAuthLevel) + { + return E_NOTIMPL; // TODO + } + } + m_advancedSettings; + + template HRESULT GetAdvancedSettings(Interface ** ppAdvSettings) + { + addRef(); + *ppAdvSettings = &m_advancedSettings; + return S_OK; + } + + /* Secured settings */ + friend class SecuredSettings; + + class SecuredSettings: public MSTSCLib::IMsRdpClientSecuredSettings + { + private: + /* IDispatch type information */ + ITypeInfo * m_dispTypeInfo; + + HRESULT LoadDispTypeInfo() + { + if(m_dispTypeInfo) + return S_OK; + + HRESULT hr = InnerToOuter(this)->LoadTypeLibrary(); + + if(FAILED(hr)) + return hr; + + hr = InnerToOuter(this)->m_typeLib->GetTypeInfoOfGuid(MSTSCLib::IID_IMsRdpClientSecuredSettings, &m_dispTypeInfo); + + if(FAILED(hr)) + return hr; + + assert(m_dispTypeInfo); + return S_OK; + } + + HRESULT AcquireDispTypeInfo(ITypeInfo ** ppTI) + { + HRESULT hr = LoadDispTypeInfo(); + + if(FAILED(hr)) + return hr; + + m_dispTypeInfo->AddRef(); + *ppTI = m_dispTypeInfo; + return S_OK; + } + + + public: + ~SecuredSettings() + { + if(m_dispTypeInfo) + m_dispTypeInfo->Release(); + } + + /* IUnknown */ + virtual STDMETHODIMP IUnknown::QueryInterface(REFIID riid, void ** ppvObject) + { + using namespace MSTSCLib; + + if + ( + riid == IID_IUnknown || + riid == IID_IDispatch || + riid == IID_IMsTscSecuredSettings || + riid == IID_IMsRdpClientSecuredSettings + ) + { + *ppvObject = this; + InnerToOuter(this)->addRef(); + return S_OK; + } + else + { + *ppvObject = NULL; + return E_NOINTERFACE; + } + } + + virtual STDMETHODIMP_(ULONG) IUnknown::AddRef() + { + return InnerToOuter(this)->addRef(); + } + + virtual STDMETHODIMP_(ULONG) IUnknown::Release() + { + return InnerToOuter(this)->release(); + } + + /* IDispatch */ + virtual STDMETHODIMP IDispatch::GetTypeInfoCount(UINT * pctinfo) + { + *pctinfo = 1; + return S_OK; + } + + virtual STDMETHODIMP IDispatch::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo ** ppTInfo) + { + if(iTInfo != 0) + return DISP_E_BADINDEX; + + return AcquireDispTypeInfo(ppTInfo); + } + + virtual STDMETHODIMP IDispatch::GetIDsOfNames(REFIID riid, LPOLESTR * rgszNames, UINT cNames, LCID lcid, DISPID * rgDispId) + { + HRESULT hr = LoadDispTypeInfo(); + + if(FAILED(hr)) + return hr; + + return m_dispTypeInfo->GetIDsOfNames(rgszNames, cNames, rgDispId); + } + + virtual STDMETHODIMP IDispatch::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pDispParams, VARIANT * pVarResult, EXCEPINFO * pExcepInfo, UINT * puArgErr) + { + return m_dispTypeInfo->Invoke + ( + static_cast(this), + dispIdMember, + wFlags, + pDispParams, + pVarResult, + pExcepInfo, + puArgErr + ); + } + + /* IMsTscSecuredSettings */ + virtual STDMETHODIMP IMsTscSecuredSettings::put_StartProgram(BSTR pStartProgram) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscSecuredSettings::get_StartProgram(BSTR * pStartProgram) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscSecuredSettings::put_WorkDir(BSTR pWorkDir) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscSecuredSettings::get_WorkDir(BSTR * pWorkDir) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscSecuredSettings::put_FullScreen(long pfFullScreen) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscSecuredSettings::get_FullScreen(long * pfFullScreen) + { + return E_NOTIMPL; // TODO + } + + /* IMsRdpClientSecuredSettings */ + virtual STDMETHODIMP IMsRdpClientSecuredSettings::put_KeyboardHookMode(long pkeyboardHookMode) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientSecuredSettings::get_KeyboardHookMode(long * pkeyboardHookMode) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientSecuredSettings::put_AudioRedirectionMode(long pAudioRedirectionMode) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientSecuredSettings::get_AudioRedirectionMode(long * pAudioRedirectionMode) + { + return E_NOTIMPL; // TODO + } + } + m_securedSettings; + + /* Type library loading */ + HRESULT LoadTypeLibrary() + { + if(m_typeLib) + return S_OK; + + WCHAR szPath[MAX_PATH + 1]; + + if(GetModuleFileNameW(GetCurrentModule(), szPath, ARRAYSIZE(szPath) - 1) == 0) + return HRESULT_FROM_WIN32(GetLastError()); + + HRESULT hr = LoadTypeLibEx(szPath, REGKIND_NONE, &m_typeLib); + + if(FAILED(hr)) + return hr; + + assert(m_typeLib); + return S_OK; + } + + /* IDispatch type information */ + HRESULT LoadDispTypeInfo() + { + if(m_dispTypeInfo) + return S_OK; + + HRESULT hr = LoadTypeLibrary(); + + if(FAILED(hr)) + return hr; + + hr = m_typeLib->GetTypeInfoOfGuid(MSTSCLib::IID_IMsRdpClient4, &m_dispTypeInfo); + + if(FAILED(hr)) + return hr; + + assert(m_dispTypeInfo); + return S_OK; + } + + HRESULT AcquireDispTypeInfo(ITypeInfo ** ppTI) + { + HRESULT hr = LoadDispTypeInfo(); + + if(FAILED(hr)) + return hr; + + m_dispTypeInfo->AddRef(); + *ppTI = m_dispTypeInfo; + return S_OK; + } + +public: + /* Helpers for our various embedded children */ + static RdpClient * InnerToOuter(RdpClientInner * innerThis) + { + return CONTAINING_RECORD(innerThis, RdpClient, m_inner); + } + + static RdpClient * InnerToOuter(AdvancedSettings * innerThis) + { + return CONTAINING_RECORD(innerThis, RdpClient, m_advancedSettings); + } + + static RdpClient * InnerToOuter(SecuredSettings * innerThis) + { + return CONTAINING_RECORD(innerThis, RdpClient, m_securedSettings); + } + +public: + /* Class factory */ + static HRESULT CreateInstance(REFCLSID classId, IUnknown * punkOuter, LONG * moduleRefCount, IUnknown ** ppObj) + { + RdpClient * obj = new RdpClient(classId, punkOuter, moduleRefCount); + + if(obj == NULL) + return E_OUTOFMEMORY; + + *ppObj = &obj->m_inner; + return S_OK; + } + + /* IUnknown */ // DONE + /* + NOTE: this is the delegating implementation, to support aggregation. The actual + implementation is RdpClientInner, above + */ + virtual STDMETHODIMP IUnknown::QueryInterface(REFIID riid, void ** ppvObject) + { + return m_punkOuter->QueryInterface(riid, ppvObject); + } + + virtual STDMETHODIMP_(ULONG) IUnknown::AddRef() + { + return m_punkOuter->AddRef(); + } + + virtual STDMETHODIMP_(ULONG) IUnknown::Release() + { + return m_punkOuter->Release(); + } + + /* IDispatch */ // DONE + virtual STDMETHODIMP IDispatch::GetTypeInfoCount(UINT * pctinfo) + { + *pctinfo = 1; + return S_OK; + } + + virtual STDMETHODIMP IDispatch::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo ** ppTInfo) + { + if(iTInfo != 0) + return DISP_E_BADINDEX; + + return AcquireDispTypeInfo(ppTInfo); + } + + virtual STDMETHODIMP IDispatch::GetIDsOfNames(REFIID riid, LPOLESTR * rgszNames, UINT cNames, LCID lcid, DISPID * rgDispId) + { + HRESULT hr = LoadDispTypeInfo(); + + if(FAILED(hr)) + return hr; + + return m_dispTypeInfo->GetIDsOfNames(rgszNames, cNames, rgDispId); + } + + virtual STDMETHODIMP IDispatch::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pDispParams, VARIANT * pVarResult, EXCEPINFO * pExcepInfo, UINT * puArgErr) + { + HRESULT hr = LoadDispTypeInfo(); + + if(FAILED(hr)) + return hr; + + return m_dispTypeInfo->Invoke + ( + static_cast(this), + dispIdMember, + wFlags, + pDispParams, + pVarResult, + pExcepInfo, + puArgErr + ); + } + + /* IConnectionPointContainer */ // 0/2 + virtual STDMETHODIMP IConnectionPointContainer::EnumConnectionPoints(IEnumConnectionPoints ** ppEnum) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IConnectionPointContainer::FindConnectionPoint(REFIID riid, IConnectionPoint ** ppCP) + { + return E_NOTIMPL; + } + + /* IDataObject */ // 0/9 + virtual STDMETHODIMP IDataObject::GetData(FORMATETC * pformatetcIn, STGMEDIUM * pmedium) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IDataObject::GetDataHere(FORMATETC * pformatetc, STGMEDIUM * pmedium) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IDataObject::QueryGetData(FORMATETC * pformatetc) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IDataObject::GetCanonicalFormatEtc(FORMATETC * pformatectIn, FORMATETC * pformatetcOut) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IDataObject::SetData(FORMATETC * pformatetc, STGMEDIUM * pmedium, BOOL fRelease) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IDataObject::EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC ** ppenumFormatEtc) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IDataObject::DAdvise(FORMATETC * pformatetc, DWORD advf, IAdviseSink * pAdvSink, DWORD * pdwConnection) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IDataObject::DUnadvise(DWORD dwConnection) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IDataObject::EnumDAdvise(IEnumSTATDATA ** ppenumAdvise) + { + return E_NOTIMPL; + } + + /* IObjectSafety */ // 0/2 + virtual STDMETHODIMP IObjectSafety::GetInterfaceSafetyOptions(REFIID riid, DWORD * pdwSupportedOptions, DWORD * pdwEnabledOptions) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IObjectSafety::SetInterfaceSafetyOptions(REFIID riid, DWORD dwOptionSetMask, DWORD dwEnabledOptions) + { + return E_NOTIMPL; + } + + /* IOleControl */ // 0/4 + virtual STDMETHODIMP IOleControl::GetControlInfo(CONTROLINFO * pCI) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleControl::OnMnemonic(MSG * pMsg) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleControl::OnAmbientPropertyChange(DISPID dispID) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleControl::FreezeEvents(BOOL bFreeze) + { + return E_NOTIMPL; + } + + /* IOleInPlaceActiveObject */ // 0/5 + virtual STDMETHODIMP IOleInPlaceActiveObject::TranslateAccelerator(LPMSG lpmsg) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleInPlaceActiveObject::OnFrameWindowActivate(BOOL fActivate) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleInPlaceActiveObject::OnDocWindowActivate(BOOL fActivate) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleInPlaceActiveObject::ResizeBorder(LPCRECT prcBorder, IOleInPlaceUIWindow * pUIWindow, BOOL fFrameWindow) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleInPlaceActiveObject::EnableModeless(BOOL fEnable) + { + return E_NOTIMPL; + } + + /* IOleInPlaceObject */ // 0/4 + virtual STDMETHODIMP IOleInPlaceObject::InPlaceDeactivate() + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleInPlaceObject::UIDeactivate() + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleInPlaceObject::SetObjectRects(LPCRECT lprcPosRect, LPCRECT lprcClipRect) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleInPlaceObject::ReactivateAndUndo() + { + return E_NOTIMPL; + } + + /* IOleObject */ // 0/21 + virtual STDMETHODIMP IOleObject::SetClientSite(IOleClientSite * pClientSite) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleObject::GetClientSite(IOleClientSite ** ppClientSite) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleObject::SetHostNames(LPCOLESTR szContainerApp, LPCOLESTR szContainerObj) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleObject::Close(DWORD dwSaveOption) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleObject::SetMoniker(DWORD dwWhichMoniker, IMoniker * pmk) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleObject::GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker, IMoniker ** ppmk) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleObject::InitFromData(IDataObject * pDataObject, BOOL fCreation, DWORD dwReserved) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleObject::GetClipboardData(DWORD dwReserved, IDataObject ** ppDataObject) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleObject::DoVerb(LONG iVerb, LPMSG lpmsg, IOleClientSite * pActiveSite, LONG lindex, HWND hwndParent, LPCRECT lprcPosRect) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleObject::EnumVerbs(IEnumOLEVERB ** ppEnumOleVerb) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleObject::Update() + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleObject::IsUpToDate() + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleObject::GetUserClassID(CLSID * pClsid) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleObject::GetUserType(DWORD dwFormOfType, LPOLESTR * pszUserType) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleObject::SetExtent(DWORD dwDrawAspect, SIZEL * psizel) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleObject::GetExtent(DWORD dwDrawAspect, SIZEL * psizel) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleObject::Advise(IAdviseSink * pAdvSink, DWORD * pdwConnection) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleObject::Unadvise(DWORD dwConnection) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleObject::EnumAdvise(IEnumSTATDATA ** ppenumAdvise) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleObject::GetMiscStatus(DWORD dwAspect, DWORD * pdwStatus) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleObject::SetColorScheme(LOGPALETTE * pLogpal) + { + return E_NOTIMPL; + } + + /* IOleWindow */ // 0/2 + virtual STDMETHODIMP IOleWindow::GetWindow(HWND * phwnd) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IOleWindow::ContextSensitiveHelp(BOOL fEnterMode) + { + return E_NOTIMPL; + } + + /* IPersist */ // DONE + virtual STDMETHODIMP IPersist::GetClassID(CLSID * pClassID) + { + *pClassID = m_classId; + return S_OK; + } + + /* IPersistPropertyBag */ // 0/3 + virtual STDMETHODIMP IPersistPropertyBag::InitNew() + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IPersistPropertyBag::Load(IPropertyBag * pPropBag, IErrorLog * pErrorLog) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IPersistPropertyBag::Save(IPropertyBag * pPropBag, BOOL fClearDirty, BOOL fSaveAllProperties) + { + return E_NOTIMPL; + } + + /* IPersistStorage */ // 0/6 + virtual STDMETHODIMP IPersistStorage::IsDirty() + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IPersistStorage::InitNew(IStorage * pStg) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IPersistStorage::Load(IStorage * pStg) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IPersistStorage::Save(IStorage * pStgSave, BOOL fSameAsLoad) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IPersistStorage::SaveCompleted(IStorage * pStgNew) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IPersistStorage::HandsOffStorage() + { + return E_NOTIMPL; + } + + /* IPersistStreamInit */ // 0/5 + virtual STDMETHODIMP IPersistStreamInit::IsDirty() + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IPersistStreamInit::Load(LPSTREAM pStm) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IPersistStreamInit::Save(LPSTREAM pStm, BOOL fClearDirty) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IPersistStreamInit::GetSizeMax(ULARGE_INTEGER * pCbSize) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IPersistStreamInit::InitNew() + { + return E_NOTIMPL; + } + + /* IProvideClassInfo */ // DONE + virtual STDMETHODIMP IProvideClassInfo::GetClassInfo(ITypeInfo ** ppTI) + { + HRESULT hr = LoadTypeLibrary(); + + if(FAILED(hr)) + return hr; + + return m_typeLib->GetTypeInfoOfGuid(m_classId, ppTI); + } + + /* IProvideClassInfo2 */ // DONE + virtual STDMETHODIMP IProvideClassInfo2::GetGUID(DWORD dwGuidKind, GUID * pGUID) + { + if(dwGuidKind != GUIDKIND_DEFAULT_SOURCE_DISP_IID) + return E_INVALIDARG; + + *pGUID = MSTSCLib::DIID_IMsTscAxEvents; + return S_OK; + } + + /* IQuickActivate */ // 0/3 + virtual STDMETHODIMP IQuickActivate::QuickActivate(QACONTAINER * pQaContainer, QACONTROL * pQaControl) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IQuickActivate::SetContentExtent(LPSIZEL pSizel) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IQuickActivate::GetContentExtent(LPSIZEL pSizel) + { + return E_NOTIMPL; + } + + /* IViewObject */ // 0/6 + virtual STDMETHODIMP IViewObject::Draw(DWORD dwDrawAspect, LONG lindex, void * pvAspect, DVTARGETDEVICE * ptd, HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBounds, BOOL (STDMETHODCALLTYPE * pfnContinue)(ULONG_PTR dwContinue), ULONG_PTR dwContinue) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IViewObject::GetColorSet(DWORD dwDrawAspect, LONG lindex, void * pvAspect, DVTARGETDEVICE * ptd, HDC hicTargetDev, LOGPALETTE ** ppColorSet) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IViewObject::Freeze(DWORD dwDrawAspect, LONG lindex, void * pvAspect, DWORD * pdwFreeze) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IViewObject::Unfreeze(DWORD dwFreeze) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IViewObject::SetAdvise(DWORD aspects, DWORD advf, IAdviseSink * pAdvSink) + { + return E_NOTIMPL; + } + + virtual STDMETHODIMP IViewObject::GetAdvise(DWORD * pAspects, DWORD * pAdvf, IAdviseSink ** ppAdvSink) + { + return E_NOTIMPL; + } + + /* IViewObject2 */ // 0/1 + virtual STDMETHODIMP IViewObject2::GetExtent(DWORD dwDrawAspect, LONG lindex, DVTARGETDEVICE * ptd, LPSIZEL lpsizel) + { + return E_NOTIMPL; + } + + /* IMsTscAx */ // ??/30 + virtual STDMETHODIMP IMsTscAx::put_Server(BSTR pServer) + { + if(m_nonIdle) + return E_FAIL; + + return SetStringProperty(m_server, pServer); + } + + virtual STDMETHODIMP IMsTscAx::get_Server(BSTR * pServer) + { + return GetStringProperty(m_server, pServer); + } + + virtual STDMETHODIMP IMsTscAx::put_Domain(BSTR pDomain) + { + if(m_nonIdle) + return E_FAIL; + + return SetStringProperty(m_domain, pDomain); + } + + virtual STDMETHODIMP IMsTscAx::get_Domain(BSTR * pDomain) + { + return GetStringProperty(m_domain, pDomain); + } + + virtual STDMETHODIMP IMsTscAx::put_UserName(BSTR pUserName) + { + if(m_nonIdle) + return E_FAIL; + + return SetStringProperty(m_userName, pUserName); + } + + virtual STDMETHODIMP IMsTscAx::get_UserName(BSTR * pUserName) + { + return GetStringProperty(m_userName, pUserName); + } + + virtual STDMETHODIMP IMsTscAx::put_DisconnectedText(BSTR pDisconnectedText) + { + if(m_nonIdle) + return E_FAIL; + + return SetStringProperty(m_disconnectedText, pDisconnectedText); + } + + virtual STDMETHODIMP IMsTscAx::get_DisconnectedText(BSTR * pDisconnectedText) + { + return GetStringProperty(m_disconnectedText, pDisconnectedText); + } + + virtual STDMETHODIMP IMsTscAx::put_ConnectingText(BSTR pConnectingText) + { + if(m_nonIdle) + return E_FAIL; + + return SetStringProperty(m_connectingText, pConnectingText); + } + + virtual STDMETHODIMP IMsTscAx::get_ConnectingText(BSTR * pConnectingText) + { + return GetStringProperty(m_connectingText, pConnectingText); + } + + virtual STDMETHODIMP IMsTscAx::get_Connected(short * pIsConnected) + { + * pIsConnected = m_nonIdle; + return S_OK; + } + + virtual STDMETHODIMP IMsTscAx::put_DesktopWidth(long pVal) + { + if(m_nonIdle) + return E_FAIL; + + // TODO: validate + + width = pVal; + return S_OK; + } + + virtual STDMETHODIMP IMsTscAx::get_DesktopWidth(long * pVal) + { + * pVal = width; + return S_OK; + } + + virtual STDMETHODIMP IMsTscAx::put_DesktopHeight(long pVal) + { + if(m_nonIdle) + return E_FAIL; + + // TODO: validate + + height = pVal; + return S_OK; + } + + virtual STDMETHODIMP IMsTscAx::get_DesktopHeight(long * pVal) + { + * pVal = height; + return S_OK; + } + + virtual STDMETHODIMP IMsTscAx::put_StartConnected(long pfStartConnected) + { + // TODO: check that the object isn't running + m_startConnected = pfStartConnected != 0; + return S_OK; + } + + virtual STDMETHODIMP IMsTscAx::get_StartConnected(long * pfStartConnected) + { + * pfStartConnected = m_startConnected; + return S_OK; + } + + virtual STDMETHODIMP IMsTscAx::get_HorizontalScrollBarVisible(long * pfHScrollVisible) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAx::get_VerticalScrollBarVisible(long * pfVScrollVisible) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAx::put_FullScreenTitle(BSTR rhs) + { + return SetStringProperty(m_fullScreenTitle, rhs); + } + + virtual STDMETHODIMP IMsTscAx::get_CipherStrength(long * pCipherStrength) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAx::get_Version(BSTR * pVersion) + { + // EASY!!! + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAx::get_SecuredSettingsEnabled(long * pSecuredSettingsEnabled) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAx::get_SecuredSettings(MSTSCLib::IMsTscSecuredSettings ** ppSecuredSettings) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAx::get_AdvancedSettings(MSTSCLib::IMsTscAdvancedSettings ** ppAdvSettings) + { + return GetAdvancedSettings(ppAdvSettings); + } + + virtual STDMETHODIMP IMsTscAx::get_Debugger(MSTSCLib::IMsTscDebug ** ppDebugger) + { + // DO NOT IMPLEMENT + return E_NOTIMPL; + } + + virtual STDMETHODIMP IMsTscAx::Connect() + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAx::Disconnect() + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAx::CreateVirtualChannels(BSTR newVal) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscAx::SendOnVirtualChannel(BSTR chanName, BSTR ChanData) + { + return E_NOTIMPL; // TODO + } + + /* IMsRdpClient */ // 1/10 + virtual STDMETHODIMP IMsRdpClient::put_ColorDepth(long pcolorDepth) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClient::get_ColorDepth(long * pcolorDepth) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClient::get_AdvancedSettings2(MSTSCLib::IMsRdpClientAdvancedSettings ** ppAdvSettings) + { + return GetAdvancedSettings(ppAdvSettings); + } + + virtual STDMETHODIMP IMsRdpClient::get_SecuredSettings2(MSTSCLib::IMsRdpClientSecuredSettings ** ppSecuredSettings) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClient::get_ExtendedDisconnectReason(MSTSCLib::ExtendedDisconnectReasonCode * pExtendedDisconnectReason) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClient::put_FullScreen(VARIANT_BOOL pfFullScreen) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClient::get_FullScreen(VARIANT_BOOL * pfFullScreen) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClient::SetVirtualChannelOptions(BSTR chanName, long chanOptions) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClient::GetVirtualChannelOptions(BSTR chanName, long * pChanOptions) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClient::RequestClose(MSTSCLib::ControlCloseStatus * pCloseStatus) + { + return E_NOTIMPL; // TODO + } + + /* IMsRdpClient2 */ // 1/3 + virtual STDMETHODIMP IMsRdpClient2::get_AdvancedSettings3(MSTSCLib::IMsRdpClientAdvancedSettings2 ** ppAdvSettings) + { + return GetAdvancedSettings(ppAdvSettings); + } + + virtual STDMETHODIMP IMsRdpClient2::put_ConnectedStatusText(BSTR pConnectedStatusText) + { + // EASY!!! + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClient2::get_ConnectedStatusText(BSTR * pConnectedStatusText) + { + // EASY!!! + return E_NOTIMPL; // TODO + } + + /* IMsRdpClient3 */ // DONE + virtual STDMETHODIMP IMsRdpClient3::get_AdvancedSettings4(MSTSCLib::IMsRdpClientAdvancedSettings3 ** ppAdvSettings) + { + return GetAdvancedSettings(ppAdvSettings); + } + + /* IMsRdpClient4 */ // DONE + virtual STDMETHODIMP IMsRdpClient4::get_AdvancedSettings5(MSTSCLib::IMsRdpClientAdvancedSettings4 ** ppAdvSettings5) + { + return GetAdvancedSettings(ppAdvSettings5); + } + + /* IMsTscNonScriptable */ // 8/10 + virtual STDMETHODIMP IMsTscNonScriptable::put_ClearTextPassword(BSTR rhs) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsTscNonScriptable::put_PortablePassword(BSTR pPortablePass) + { + // OBSOLETE + return E_NOTIMPL; + } + + virtual STDMETHODIMP IMsTscNonScriptable::get_PortablePassword(BSTR * pPortablePass) + { + // OBSOLETE + return E_NOTIMPL; + } + + virtual STDMETHODIMP IMsTscNonScriptable::put_PortableSalt(BSTR pPortableSalt) + { + // OBSOLETE + return E_NOTIMPL; + } + + virtual STDMETHODIMP IMsTscNonScriptable::get_PortableSalt(BSTR * pPortableSalt) + { + // OBSOLETE + return E_NOTIMPL; + } + + virtual STDMETHODIMP IMsTscNonScriptable::put_BinaryPassword(BSTR pBinaryPassword) + { + // OBSOLETE + return E_NOTIMPL; + } + + virtual STDMETHODIMP IMsTscNonScriptable::get_BinaryPassword(BSTR * pBinaryPassword) + { + // OBSOLETE + return E_NOTIMPL; + } + + virtual STDMETHODIMP IMsTscNonScriptable::put_BinarySalt(BSTR pSalt) + { + // OBSOLETE + return E_NOTIMPL; + } + + virtual STDMETHODIMP IMsTscNonScriptable::get_BinarySalt(BSTR * pSalt) + { + // OBSOLETE + return E_NOTIMPL; + } + + virtual STDMETHODIMP IMsTscNonScriptable::ResetPassword() + { + return E_NOTIMPL; // TODO + } + + /* IMsRdpClientNonScriptable */ // 0/2 + virtual STDMETHODIMP IMsRdpClientNonScriptable::NotifyRedirectDeviceChange(MSTSCLib::UINT_PTR wParam, MSTSCLib::LONG_PTR lParam) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientNonScriptable::SendKeys(long numKeys, VARIANT_BOOL * pbArrayKeyUp, long * plKeyData) + { + // NOTE: the keys must be sent in a single, atomic sequence + // TODO: acquire the write lock + return E_NOTIMPL; // TODO + } + + /* IMsRdpClientNonScriptable2 */ // 0/2 + virtual STDMETHODIMP IMsRdpClientNonScriptable2::put_UIParentWindowHandle(HWND phwndUIParentWindowHandle) + { + return E_NOTIMPL; // TODO + } + + virtual STDMETHODIMP IMsRdpClientNonScriptable2::get_UIParentWindowHandle(HWND * phwndUIParentWindowHandle) + { + return E_NOTIMPL; // TODO + } + +}; + +#pragma warning(pop) + +// EOF diff --git a/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/mstsclib.idl b/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/mstsclib.idl new file mode 100644 index 00000000000..a70e6f6bc57 --- /dev/null +++ b/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/mstsclib.idl @@ -0,0 +1,772 @@ +[ + uuid(8C11EFA1-92C3-11D1-BC1E-00C04FA31489), + version(1.0) +] +library MSTSCLib +{ + importlib("stdole32.tlb"); + + dispinterface IMsTscAxEvents; + + interface IMsTscAx; + interface IMsRdpClient; + interface IMsRdpClient2; + interface IMsRdpClient3; + interface IMsRdpClient4; + + interface IMsTscNonScriptable; + interface IMsRdpClientNonScriptable; + interface IMsRdpClientNonScriptable2; + + interface IMsTscAdvancedSettings; + interface IMsRdpClientAdvancedSettings; + interface IMsRdpClientAdvancedSettings2; + interface IMsRdpClientAdvancedSettings3; + interface IMsRdpClientAdvancedSettings4; + + interface IMsTscSecuredSettings; + interface IMsRdpClientSecuredSettings; + + interface IMsTscDebug; + + typedef [public] + enum __MIDL___MIDL_itf_mstsax_0275_0001 { + autoReconnectContinueAutomatic = 0, + autoReconnectContinueStop = 1, + autoReconnectContinueManual = 2 + } AutoReconnectContinueState; + + typedef [public] + enum __MIDL_IMsRdpClient_0001 { + exDiscReasonNoInfo = 0, + exDiscReasonAPIInitiatedDisconnect = 1, + exDiscReasonAPIInitiatedLogoff = 2, + exDiscReasonServerIdleTimeout = 3, + exDiscReasonServerLogonTimeout = 4, + exDiscReasonReplacedByOtherConnection = 5, + exDiscReasonOutOfMemory = 6, + exDiscReasonServerDeniedConnection = 7, + exDiscReasonServerDeniedConnectionFips = 8, + exDiscReasonLicenseInternal = 256, + exDiscReasonLicenseNoLicenseServer = 257, + exDiscReasonLicenseNoLicense = 258, + exDiscReasonLicenseErrClientMsg = 259, + exDiscReasonLicenseHwidDoesntMatchLicense = 260, + exDiscReasonLicenseErrClientLicense = 261, + exDiscReasonLicenseCantFinishProtocol = 262, + exDiscReasonLicenseClientEndedProtocol = 263, + exDiscReasonLicenseErrClientEncryption = 264, + exDiscReasonLicenseCantUpgradeLicense = 265, + exDiscReasonLicenseNoRemoteConnections = 266, + exDiscReasonProtocolRangeStart = 4096, + exDiscReasonProtocolRangeEnd = 32767 + } ExtendedDisconnectReasonCode; + + typedef [public] + enum __MIDL_IMsRdpClient_0002 { + controlCloseCanProceed = 0, + controlCloseWaitForEvents = 1 + } ControlCloseStatus; + + typedef [public] + unsigned __int3264 UINT_PTR; + + typedef [public] + __int3264 LONG_PTR; + + [uuid(336D5562-EFA8-482E-8CB3-C5C0FC7A7DB6)] + dispinterface IMsTscAxEvents { + properties: + methods: + [id(0x00000001)] + void OnConnecting(); + [id(0x00000002)] + void OnConnected(); + [id(0x00000003)] + void OnLoginComplete(); + [id(0x00000004)] + void OnDisconnected([in] long discReason); + [id(0x00000005)] + void OnEnterFullScreenMode(); + [id(0x00000006)] + void OnLeaveFullScreenMode(); + [id(0x00000007)] + void OnChannelReceivedData( + [in] BSTR chanName, + [in] BSTR data); + [id(0x00000008)] + void OnRequestGoFullScreen(); + [id(0x00000009)] + void OnRequestLeaveFullScreen(); + [id(0x0000000a)] + void OnFatalError([in] long errorCode); + [id(0x0000000b)] + void OnWarning([in] long warningCode); + [id(0x0000000c)] + void OnRemoteDesktopSizeChange( + [in] long width, + [in] long height); + [id(0x0000000d)] + void OnIdleTimeoutNotification(); + [id(0x0000000e)] + void OnRequestContainerMinimize(); + [id(0x0000000f)] + void OnConfirmClose([out, retval] VARIANT_BOOL* pfAllowClose); + [id(0x00000010)] + void OnReceivedTSPublicKey( + [in] BSTR publicKey, + [out, retval] VARIANT_BOOL* pfContinueLogon); + [id(0x00000011)] + void OnAutoReconnecting( + [in] long disconnectReason, + [in] long attemptCount, + [out, retval] AutoReconnectContinueState* pArcContinueStatus); + [id(0x00000012)] + void OnAuthenticationWarningDisplayed(); + [id(0x00000013)] + void OnAuthenticationWarningDismissed(); + }; + [ + uuid(8C11EFAE-92C3-11D1-BC1E-00C04FA31489), + dual, + oleautomation + ] + interface IMsTscAx : IDispatch { + [id(0x00000001), propput] + HRESULT Server([in] BSTR pServer); + [id(0x00000001), propget] + HRESULT Server([out, retval] BSTR* pServer); + [id(0x00000002), propput] + HRESULT Domain([in] BSTR pDomain); + [id(0x00000002), propget] + HRESULT Domain([out, retval] BSTR* pDomain); + [id(0x00000003), propput] + HRESULT UserName([in] BSTR pUserName); + [id(0x00000003), propget] + HRESULT UserName([out, retval] BSTR* pUserName); + [id(0x00000004), propput] + HRESULT DisconnectedText([in] BSTR pDisconnectedText); + [id(0x00000004), propget] + HRESULT DisconnectedText([out, retval] BSTR* pDisconnectedText); + [id(0x00000005), propput] + HRESULT ConnectingText([in] BSTR pConnectingText); + [id(0x00000005), propget] + HRESULT ConnectingText([out, retval] BSTR* pConnectingText); + [id(0x00000006), propget] + HRESULT Connected([out, retval] short* pIsConnected); + [id(0x0000000c), propput] + HRESULT DesktopWidth([in] long pVal); + [id(0x0000000c), propget] + HRESULT DesktopWidth([out, retval] long* pVal); + [id(0x0000000d), propput] + HRESULT DesktopHeight([in] long pVal); + [id(0x0000000d), propget] + HRESULT DesktopHeight([out, retval] long* pVal); + [id(0x00000010), propput] + HRESULT StartConnected([in] long pfStartConnected); + [id(0x00000010), propget] + HRESULT StartConnected([out, retval] long* pfStartConnected); + [id(0x00000011), propget] + HRESULT HorizontalScrollBarVisible([out, retval] long* pfHScrollVisible); + [id(0x00000012), propget] + HRESULT VerticalScrollBarVisible([out, retval] long* pfVScrollVisible); + [id(0x00000013), propput] + HRESULT FullScreenTitle([in] BSTR rhs); + [id(0x00000014), propget] + HRESULT CipherStrength([out, retval] long* pCipherStrength); + [id(0x00000015), propget] + HRESULT Version([out, retval] BSTR* pVersion); + [id(0x00000016), propget] + HRESULT SecuredSettingsEnabled([out, retval] long* pSecuredSettingsEnabled); + [id(0x00000061), propget] + HRESULT SecuredSettings([out, retval] IMsTscSecuredSettings** ppSecuredSettings); + [id(0x00000062), propget] + HRESULT AdvancedSettings([out, retval] IMsTscAdvancedSettings** ppAdvSettings); + [id(0x00000063), propget, hidden] + HRESULT Debugger([out, retval] IMsTscDebug** ppDebugger); + [id(0x0000001e)] + HRESULT Connect(); + [id(0x0000001f)] + HRESULT Disconnect(); + [id(0x00000021)] + HRESULT CreateVirtualChannels([in] BSTR newVal); + [id(0x00000022)] + HRESULT SendOnVirtualChannel( + [in] BSTR chanName, + [in] BSTR ChanData); + }; + + [ + uuid(92B4A539-7115-4B7C-A5A9-E5D9EFC2780A), + dual, + oleautomation + ] + interface IMsRdpClient : IMsTscAx { + [id(0x00000064), propput] + HRESULT ColorDepth([in] long pcolorDepth); + [id(0x00000064), propget] + HRESULT ColorDepth([out, retval] long* pcolorDepth); + [id(0x00000065), propget] + HRESULT AdvancedSettings2([out, retval] IMsRdpClientAdvancedSettings** ppAdvSettings); + [id(0x00000066), propget] + HRESULT SecuredSettings2([out, retval] IMsRdpClientSecuredSettings** ppSecuredSettings); + [id(0x00000067), propget] + HRESULT ExtendedDisconnectReason([out, retval] ExtendedDisconnectReasonCode* pExtendedDisconnectReason); + [id(0x00000068), propput] + HRESULT FullScreen([in] VARIANT_BOOL pfFullScreen); + [id(0x00000068), propget] + HRESULT FullScreen([out, retval] VARIANT_BOOL* pfFullScreen); + [id(0x00000023)] + HRESULT SetVirtualChannelOptions( + [in] BSTR chanName, + [in] long chanOptions); + [id(0x00000024)] + HRESULT GetVirtualChannelOptions( + [in] BSTR chanName, + [out, retval] long* pChanOptions); + [id(0x00000025)] + HRESULT RequestClose([out, retval] ControlCloseStatus* pCloseStatus); + }; + + [ + uuid(E7E17DC4-3B71-4BA7-A8E6-281FFADCA28F), + dual, + oleautomation + ] + interface IMsRdpClient2 : IMsRdpClient { + [id(0x000000c8), propget] + HRESULT AdvancedSettings3([out, retval] IMsRdpClientAdvancedSettings2** ppAdvSettings); + [id(0x000000c9), propput] + HRESULT ConnectedStatusText([in] BSTR pConnectedStatusText); + [id(0x000000c9), propget] + HRESULT ConnectedStatusText([out, retval] BSTR* pConnectedStatusText); + }; + + [ + uuid(91B7CBC5-A72E-4FA0-9300-D647D7E897FF), + dual, + oleautomation + ] + interface IMsRdpClient3 : IMsRdpClient2 { + [id(0x0000012c), propget] + HRESULT AdvancedSettings4([out, retval] IMsRdpClientAdvancedSettings3** ppAdvSettings); + }; + + [ + uuid(095E0738-D97D-488B-B9F6-DD0E8D66C0DE), + dual, + oleautomation + ] + interface IMsRdpClient4 : IMsRdpClient3 { + [id(0x00000190), propget] + HRESULT AdvancedSettings5([out, retval] IMsRdpClientAdvancedSettings4** ppAdvSettings5); + }; + + [uuid(C1E6743A-41C1-4A74-832A-0DD06C1C7A0E)] + interface IMsTscNonScriptable : IUnknown { + [propput] + HRESULT __stdcall ClearTextPassword([in] BSTR rhs); + [propput] + HRESULT __stdcall PortablePassword([in] BSTR pPortablePass); + [propget] + HRESULT __stdcall PortablePassword([out, retval] BSTR* pPortablePass); + [propput] + HRESULT __stdcall PortableSalt([in] BSTR pPortableSalt); + [propget] + HRESULT __stdcall PortableSalt([out, retval] BSTR* pPortableSalt); + [propput] + HRESULT __stdcall BinaryPassword([in] BSTR pBinaryPassword); + [propget] + HRESULT __stdcall BinaryPassword([out, retval] BSTR* pBinaryPassword); + [propput] + HRESULT __stdcall BinarySalt([in] BSTR pSalt); + [propget] + HRESULT __stdcall BinarySalt([out, retval] BSTR* pSalt); + HRESULT __stdcall ResetPassword(); + }; + + [uuid(2F079C4C-87B2-4AFD-97AB-20CDB43038AE)] + interface IMsRdpClientNonScriptable : IMsTscNonScriptable { + HRESULT __stdcall NotifyRedirectDeviceChange( + [in] UINT_PTR wParam, + [in] LONG_PTR lParam); + HRESULT __stdcall SendKeys( + [in] long numKeys, + [in] VARIANT_BOOL* pbArrayKeyUp, + [in] long* plKeyData); + }; + + [uuid(17A5E535-4072-4FA4-AF32-C8D0D47345E9)] + interface IMsRdpClientNonScriptable2 : IMsRdpClientNonScriptable { + [propput] + HRESULT __stdcall UIParentWindowHandle([in] HWND phwndUIParentWindowHandle); + [propget] + HRESULT __stdcall UIParentWindowHandle([out, retval] HWND* phwndUIParentWindowHandle); + }; + + [ + uuid(809945CC-4B3B-4A92-A6B0-DBF9B5F2EF2D), + dual, + oleautomation + ] + interface IMsTscAdvancedSettings : IDispatch { + [id(0x00000079), propput] + HRESULT Compress([in] long pcompress); + [id(0x00000079), propget] + HRESULT Compress([out, retval] long* pcompress); + [id(0x0000007a), propput] + HRESULT BitmapPeristence([in] long pbitmapPeristence); + [id(0x0000007a), propget] + HRESULT BitmapPeristence([out, retval] long* pbitmapPeristence); + [id(0x000000a1), propput] + HRESULT allowBackgroundInput([in] long pallowBackgroundInput); + [id(0x000000a1), propget] + HRESULT allowBackgroundInput([out, retval] long* pallowBackgroundInput); + [id(0x000000a2), propput] + HRESULT KeyBoardLayoutStr([in] BSTR rhs); + [id(0x000000aa), propput] + HRESULT PluginDlls([in] BSTR rhs); + [id(0x000000ab), propput] + HRESULT IconFile([in] BSTR rhs); + [id(0x000000ac), propput] + HRESULT IconIndex([in] long rhs); + [id(0x000000ad), propput] + HRESULT ContainerHandledFullScreen([in] long pContainerHandledFullScreen); + [id(0x000000ad), propget] + HRESULT ContainerHandledFullScreen([out, retval] long* pContainerHandledFullScreen); + [id(0x000000ae), propput] + HRESULT DisableRdpdr([in] long pDisableRdpdr); + [id(0x000000ae), propget] + HRESULT DisableRdpdr([out, retval] long* pDisableRdpdr); + }; + + [ + uuid(3C65B4AB-12B3-465B-ACD4-B8DAD3BFF9E2), + dual, + oleautomation + ] + interface IMsRdpClientAdvancedSettings : IMsTscAdvancedSettings { + [id(0x00000065), propput] + HRESULT SmoothScroll([in] long psmoothScroll); + [id(0x00000065), propget] + HRESULT SmoothScroll([out, retval] long* psmoothScroll); + [id(0x00000066), propput] + HRESULT AcceleratorPassthrough([in] long pacceleratorPassthrough); + [id(0x00000066), propget] + HRESULT AcceleratorPassthrough([out, retval] long* pacceleratorPassthrough); + [id(0x00000067), propput] + HRESULT ShadowBitmap([in] long pshadowBitmap); + [id(0x00000067), propget] + HRESULT ShadowBitmap([out, retval] long* pshadowBitmap); + [id(0x00000068), propput] + HRESULT TransportType([in] long ptransportType); + [id(0x00000068), propget] + HRESULT TransportType([out, retval] long* ptransportType); + [id(0x00000069), propput] + HRESULT SasSequence([in] long psasSequence); + [id(0x00000069), propget] + HRESULT SasSequence([out, retval] long* psasSequence); + [id(0x0000006a), propput] + HRESULT EncryptionEnabled([in] long pencryptionEnabled); + [id(0x0000006a), propget] + HRESULT EncryptionEnabled([out, retval] long* pencryptionEnabled); + [id(0x0000006b), propput] + HRESULT DedicatedTerminal([in] long pdedicatedTerminal); + [id(0x0000006b), propget] + HRESULT DedicatedTerminal([out, retval] long* pdedicatedTerminal); + [id(0x0000006c), propput] + HRESULT RDPPort([in] long prdpPort); + [id(0x0000006c), propget] + HRESULT RDPPort([out, retval] long* prdpPort); + [id(0x0000006d), propput] + HRESULT EnableMouse([in] long penableMouse); + [id(0x0000006d), propget] + HRESULT EnableMouse([out, retval] long* penableMouse); + [id(0x0000006e), propput] + HRESULT DisableCtrlAltDel([in] long pdisableCtrlAltDel); + [id(0x0000006e), propget] + HRESULT DisableCtrlAltDel([out, retval] long* pdisableCtrlAltDel); + [id(0x0000006f), propput] + HRESULT EnableWindowsKey([in] long penableWindowsKey); + [id(0x0000006f), propget] + HRESULT EnableWindowsKey([out, retval] long* penableWindowsKey); + [id(0x00000070), propput] + HRESULT DoubleClickDetect([in] long pdoubleClickDetect); + [id(0x00000070), propget] + HRESULT DoubleClickDetect([out, retval] long* pdoubleClickDetect); + [id(0x00000071), propput] + HRESULT MaximizeShell([in] long pmaximizeShell); + [id(0x00000071), propget] + HRESULT MaximizeShell([out, retval] long* pmaximizeShell); + [id(0x00000072), propput] + HRESULT HotKeyFullScreen([in] long photKeyFullScreen); + [id(0x00000072), propget] + HRESULT HotKeyFullScreen([out, retval] long* photKeyFullScreen); + [id(0x00000073), propput] + HRESULT HotKeyCtrlEsc([in] long photKeyCtrlEsc); + [id(0x00000073), propget] + HRESULT HotKeyCtrlEsc([out, retval] long* photKeyCtrlEsc); + [id(0x00000074), propput] + HRESULT HotKeyAltEsc([in] long photKeyAltEsc); + [id(0x00000074), propget] + HRESULT HotKeyAltEsc([out, retval] long* photKeyAltEsc); + [id(0x00000075), propput] + HRESULT HotKeyAltTab([in] long photKeyAltTab); + [id(0x00000075), propget] + HRESULT HotKeyAltTab([out, retval] long* photKeyAltTab); + [id(0x00000076), propput] + HRESULT HotKeyAltShiftTab([in] long photKeyAltShiftTab); + [id(0x00000076), propget] + HRESULT HotKeyAltShiftTab([out, retval] long* photKeyAltShiftTab); + [id(0x00000077), propput] + HRESULT HotKeyAltSpace([in] long photKeyAltSpace); + [id(0x00000077), propget] + HRESULT HotKeyAltSpace([out, retval] long* photKeyAltSpace); + [id(0x00000078), propput] + HRESULT HotKeyCtrlAltDel([in] long photKeyCtrlAltDel); + [id(0x00000078), propget] + HRESULT HotKeyCtrlAltDel([out, retval] long* photKeyCtrlAltDel); + [id(0x0000007b), propput] + HRESULT orderDrawThreshold([in] long porderDrawThreshold); + [id(0x0000007b), propget] + HRESULT orderDrawThreshold([out, retval] long* porderDrawThreshold); + [id(0x0000007c), propput] + HRESULT BitmapCacheSize([in] long pbitmapCacheSize); + [id(0x0000007c), propget] + HRESULT BitmapCacheSize([out, retval] long* pbitmapCacheSize); + [id(0x0000007d), propput] + HRESULT BitmapVirtualCacheSize([in] long pbitmapVirtualCacheSize); + [id(0x0000007d), propget] + HRESULT BitmapVirtualCacheSize([out, retval] long* pbitmapVirtualCacheSize); + [id(0x000000af), propput] + HRESULT ScaleBitmapCachesByBPP([in] long pbScale); + [id(0x000000af), propget] + HRESULT ScaleBitmapCachesByBPP([out, retval] long* pbScale); + [id(0x0000007e), propput] + HRESULT NumBitmapCaches([in] long pnumBitmapCaches); + [id(0x0000007e), propget] + HRESULT NumBitmapCaches([out, retval] long* pnumBitmapCaches); + [id(0x0000007f), propput] + HRESULT CachePersistenceActive([in] long pcachePersistenceActive); + [id(0x0000007f), propget] + HRESULT CachePersistenceActive([out, retval] long* pcachePersistenceActive); + [id(0x0000008a), propput] + HRESULT PersistCacheDirectory([in] BSTR rhs); + [id(0x0000009c), propput] + HRESULT brushSupportLevel([in] long pbrushSupportLevel); + [id(0x0000009c), propget] + HRESULT brushSupportLevel([out, retval] long* pbrushSupportLevel); + [id(0x0000009d), propput] + HRESULT minInputSendInterval([in] long pminInputSendInterval); + [id(0x0000009d), propget] + HRESULT minInputSendInterval([out, retval] long* pminInputSendInterval); + [id(0x0000009e), propput] + HRESULT InputEventsAtOnce([in] long pinputEventsAtOnce); + [id(0x0000009e), propget] + HRESULT InputEventsAtOnce([out, retval] long* pinputEventsAtOnce); + [id(0x0000009f), propput] + HRESULT maxEventCount([in] long pmaxEventCount); + [id(0x0000009f), propget] + HRESULT maxEventCount([out, retval] long* pmaxEventCount); + [id(0x000000a0), propput] + HRESULT keepAliveInterval([in] long pkeepAliveInterval); + [id(0x000000a0), propget] + HRESULT keepAliveInterval([out, retval] long* pkeepAliveInterval); + [id(0x000000a3), propput] + HRESULT shutdownTimeout([in] long pshutdownTimeout); + [id(0x000000a3), propget] + HRESULT shutdownTimeout([out, retval] long* pshutdownTimeout); + [id(0x000000a4), propput] + HRESULT overallConnectionTimeout([in] long poverallConnectionTimeout); + [id(0x000000a4), propget] + HRESULT overallConnectionTimeout([out, retval] long* poverallConnectionTimeout); + [id(0x000000a5), propput] + HRESULT singleConnectionTimeout([in] long psingleConnectionTimeout); + [id(0x000000a5), propget] + HRESULT singleConnectionTimeout([out, retval] long* psingleConnectionTimeout); + [id(0x000000a6), propput] + HRESULT KeyboardType([in] long pkeyboardType); + [id(0x000000a6), propget] + HRESULT KeyboardType([out, retval] long* pkeyboardType); + [id(0x000000a7), propput] + HRESULT KeyboardSubType([in] long pkeyboardSubType); + [id(0x000000a7), propget] + HRESULT KeyboardSubType([out, retval] long* pkeyboardSubType); + [id(0x000000a8), propput] + HRESULT KeyboardFunctionKey([in] long pkeyboardFunctionKey); + [id(0x000000a8), propget] + HRESULT KeyboardFunctionKey([out, retval] long* pkeyboardFunctionKey); + [id(0x000000a9), propput] + HRESULT WinceFixedPalette([in] long pwinceFixedPalette); + [id(0x000000a9), propget] + HRESULT WinceFixedPalette([out, retval] long* pwinceFixedPalette); + [id(0x000000b2), propput] + HRESULT ConnectToServerConsole([in] VARIANT_BOOL pConnectToConsole); + [id(0x000000b2), propget] + HRESULT ConnectToServerConsole([out, retval] VARIANT_BOOL* pConnectToConsole); + [id(0x000000b6), propput] + HRESULT BitmapPersistence([in] long pbitmapPersistence); + [id(0x000000b6), propget] + HRESULT BitmapPersistence([out, retval] long* pbitmapPersistence); + [id(0x000000b7), propput] + HRESULT MinutesToIdleTimeout([in] long pminutesToIdleTimeout); + [id(0x000000b7), propget] + HRESULT MinutesToIdleTimeout([out, retval] long* pminutesToIdleTimeout); + [id(0x000000b8), propput] + HRESULT SmartSizing([in] VARIANT_BOOL pfSmartSizing); + [id(0x000000b8), propget] + HRESULT SmartSizing([out, retval] VARIANT_BOOL* pfSmartSizing); + [id(0x000000b9), propput] + HRESULT RdpdrLocalPrintingDocName([in] BSTR pLocalPrintingDocName); + [id(0x000000b9), propget] + HRESULT RdpdrLocalPrintingDocName([out, retval] BSTR* pLocalPrintingDocName); + [id(0x000000c9), propput] + HRESULT RdpdrClipCleanTempDirString([in] BSTR clipCleanTempDirString); + [id(0x000000c9), propget] + HRESULT RdpdrClipCleanTempDirString([out, retval] BSTR* clipCleanTempDirString); + [id(0x000000ca), propput] + HRESULT RdpdrClipPasteInfoString([in] BSTR clipPasteInfoString); + [id(0x000000ca), propget] + HRESULT RdpdrClipPasteInfoString([out, retval] BSTR* clipPasteInfoString); + [id(0x000000ba), propput] + HRESULT ClearTextPassword([in] BSTR rhs); + [id(0x000000bb), propput] + HRESULT DisplayConnectionBar([in] VARIANT_BOOL pDisplayConnectionBar); + [id(0x000000bb), propget] + HRESULT DisplayConnectionBar([out, retval] VARIANT_BOOL* pDisplayConnectionBar); + [id(0x000000bc), propput] + HRESULT PinConnectionBar([in] VARIANT_BOOL pPinConnectionBar); + [id(0x000000bc), propget] + HRESULT PinConnectionBar([out, retval] VARIANT_BOOL* pPinConnectionBar); + [id(0x000000bd), propput] + HRESULT GrabFocusOnConnect([in] VARIANT_BOOL pfGrabFocusOnConnect); + [id(0x000000bd), propget] + HRESULT GrabFocusOnConnect([out, retval] VARIANT_BOOL* pfGrabFocusOnConnect); + [id(0x000000be), propput] + HRESULT LoadBalanceInfo([in] BSTR pLBInfo); + [id(0x000000be), propget] + HRESULT LoadBalanceInfo([out, retval] BSTR* pLBInfo); + [id(0x000000bf), propput] + HRESULT RedirectDrives([in] VARIANT_BOOL pRedirectDrives); + [id(0x000000bf), propget] + HRESULT RedirectDrives([out, retval] VARIANT_BOOL* pRedirectDrives); + [id(0x000000c0), propput] + HRESULT RedirectPrinters([in] VARIANT_BOOL pRedirectPrinters); + [id(0x000000c0), propget] + HRESULT RedirectPrinters([out, retval] VARIANT_BOOL* pRedirectPrinters); + [id(0x000000c1), propput] + HRESULT RedirectPorts([in] VARIANT_BOOL pRedirectPorts); + [id(0x000000c1), propget] + HRESULT RedirectPorts([out, retval] VARIANT_BOOL* pRedirectPorts); + [id(0x000000c2), propput] + HRESULT RedirectSmartCards([in] VARIANT_BOOL pRedirectSmartCards); + [id(0x000000c2), propget] + HRESULT RedirectSmartCards([out, retval] VARIANT_BOOL* pRedirectSmartCards); + [id(0x000000c3), propput] + HRESULT BitmapVirtualCache16BppSize([in] long pBitmapVirtualCache16BppSize); + [id(0x000000c3), propget] + HRESULT BitmapVirtualCache16BppSize([out, retval] long* pBitmapVirtualCache16BppSize); + [id(0x000000c4), propput] + HRESULT BitmapVirtualCache24BppSize([in] long pBitmapVirtualCache24BppSize); + [id(0x000000c4), propget] + HRESULT BitmapVirtualCache24BppSize([out, retval] long* pBitmapVirtualCache24BppSize); + [id(0x000000c8), propput] + HRESULT PerformanceFlags([in] long pDisableList); + [id(0x000000c8), propget] + HRESULT PerformanceFlags([out, retval] long* pDisableList); + [id(0x000000cb), propput] + HRESULT ConnectWithEndpoint([in] VARIANT* rhs); + [id(0x000000cc), propput] + HRESULT NotifyTSPublicKey([in] VARIANT_BOOL pfNotify); + [id(0x000000cc), propget] + HRESULT NotifyTSPublicKey([out, retval] VARIANT_BOOL* pfNotify); + }; + + [ + uuid(9AC42117-2B76-4320-AA44-0E616AB8437B), + dual, + oleautomation + ] + interface IMsRdpClientAdvancedSettings2 : IMsRdpClientAdvancedSettings { + [id(0x000000cd), propget] + HRESULT CanAutoReconnect([out, retval] VARIANT_BOOL* pfCanAutoReconnect); + [id(0x000000ce), propput] + HRESULT EnableAutoReconnect([in] VARIANT_BOOL pfEnableAutoReconnect); + [id(0x000000ce), propget] + HRESULT EnableAutoReconnect([out, retval] VARIANT_BOOL* pfEnableAutoReconnect); + [id(0x000000cf), propput] + HRESULT MaxReconnectAttempts([in] long pMaxReconnectAttempts); + [id(0x000000cf), propget] + HRESULT MaxReconnectAttempts([out, retval] long* pMaxReconnectAttempts); + }; + + [ + uuid(19CD856B-C542-4C53-ACEE-F127E3BE1A59), + dual, + oleautomation + ] + interface IMsRdpClientAdvancedSettings3 : IMsRdpClientAdvancedSettings2 { + [id(0x000000d2), propput] + HRESULT ConnectionBarShowMinimizeButton([in] VARIANT_BOOL pfShowMinimize); + [id(0x000000d2), propget] + HRESULT ConnectionBarShowMinimizeButton([out, retval] VARIANT_BOOL* pfShowMinimize); + [id(0x000000d3), propput] + HRESULT ConnectionBarShowRestoreButton([in] VARIANT_BOOL pfShowRestore); + [id(0x000000d3), propget] + HRESULT ConnectionBarShowRestoreButton([out, retval] VARIANT_BOOL* pfShowRestore); + }; + + [ + uuid(FBA7F64E-7345-4405-AE50-FA4A763DC0DE), + dual, + oleautomation + ] + interface IMsRdpClientAdvancedSettings4 : IMsRdpClientAdvancedSettings3 { + [id(0x000000d4), propput] + HRESULT AuthenticationLevel([in] unsigned int puiAuthLevel); + [id(0x000000d4), propget] + HRESULT AuthenticationLevel([out, retval] unsigned int* puiAuthLevel); + }; + + [ + uuid(C9D65442-A0F9-45B2-8F73-D61D2DB8CBB6), + dual, + oleautomation + ] + interface IMsTscSecuredSettings : IDispatch { + [id(0x00000001), propput] + HRESULT StartProgram([in] BSTR pStartProgram); + [id(0x00000001), propget] + HRESULT StartProgram([out, retval] BSTR* pStartProgram); + [id(0x00000002), propput] + HRESULT WorkDir([in] BSTR pWorkDir); + [id(0x00000002), propget] + HRESULT WorkDir([out, retval] BSTR* pWorkDir); + [id(0x00000003), propput] + HRESULT FullScreen([in] long pfFullScreen); + [id(0x00000003), propget] + HRESULT FullScreen([out, retval] long* pfFullScreen); + }; + + [ + uuid(605BEFCF-39C1-45CC-A811-068FB7BE346D), + dual, + oleautomation + ] + interface IMsRdpClientSecuredSettings : IMsTscSecuredSettings { + [id(0x00000004), propput] + HRESULT KeyboardHookMode([in] long pkeyboardHookMode); + [id(0x00000004), propget] + HRESULT KeyboardHookMode([out, retval] long* pkeyboardHookMode); + [id(0x00000005), propput] + HRESULT AudioRedirectionMode([in] long pAudioRedirectionMode); + [id(0x00000005), propget] + HRESULT AudioRedirectionMode([out, retval] long* pAudioRedirectionMode); + }; + + [ + uuid(209D0EB9-6254-47B1-9033-A98DAE55BB27), + hidden, + dual, + oleautomation + ] + interface IMsTscDebug : IDispatch { + [id(0x000000c8), propput] + HRESULT HatchBitmapPDU([in] long phatchBitmapPDU); + [id(0x000000c8), propget] + HRESULT HatchBitmapPDU([out, retval] long* phatchBitmapPDU); + [id(0x000000c9), propput] + HRESULT HatchSSBOrder([in] long phatchSSBOrder); + [id(0x000000c9), propget] + HRESULT HatchSSBOrder([out, retval] long* phatchSSBOrder); + [id(0x000000ca), propput] + HRESULT HatchMembltOrder([in] long phatchMembltOrder); + [id(0x000000ca), propget] + HRESULT HatchMembltOrder([out, retval] long* phatchMembltOrder); + [id(0x000000cb), propput] + HRESULT HatchIndexPDU([in] long phatchIndexPDU); + [id(0x000000cb), propget] + HRESULT HatchIndexPDU([out, retval] long* phatchIndexPDU); + [id(0x000000cc), propput] + HRESULT LabelMemblt([in] long plabelMemblt); + [id(0x000000cc), propget] + HRESULT LabelMemblt([out, retval] long* plabelMemblt); + [id(0x000000cd), propput] + HRESULT BitmapCacheMonitor([in] long pbitmapCacheMonitor); + [id(0x000000cd), propget] + HRESULT BitmapCacheMonitor([out, retval] long* pbitmapCacheMonitor); + [id(0x000000ce), propput] + HRESULT MallocFailuresPercent([in] long pmallocFailuresPercent); + [id(0x000000ce), propget] + HRESULT MallocFailuresPercent([out, retval] long* pmallocFailuresPercent); + [id(0x000000cf), propput] + HRESULT MallocHugeFailuresPercent([in] long pmallocHugeFailuresPercent); + [id(0x000000cf), propget] + HRESULT MallocHugeFailuresPercent([out, retval] long* pmallocHugeFailuresPercent); + [id(0x000000d0), propput] + HRESULT NetThroughput([in] long NetThroughput); + [id(0x000000d0), propget] + HRESULT NetThroughput([out, retval] long* NetThroughput); + [id(0x000000d1), propput] + HRESULT CLXCmdLine([in] BSTR pCLXCmdLine); + [id(0x000000d1), propget] + HRESULT CLXCmdLine([out, retval] BSTR* pCLXCmdLine); + [id(0x000000d2), propput] + HRESULT CLXDll([in] BSTR pCLXDll); + [id(0x000000d2), propget] + HRESULT CLXDll([out, retval] BSTR* pCLXDll); + }; + + [uuid(A41A4187-5A86-4E26-B40A-856F9035D9CB)] + coclass MsTscAx { + interface IMsRdpClient; + [default] interface IMsTscAx; + [default, source] dispinterface IMsTscAxEvents; + interface IMsTscNonScriptable; + interface IMsRdpClientNonScriptable; + }; + + [uuid(7CACBD7B-0D99-468F-AC33-22E495C0AFE5)] + coclass MsRdpClient { + [default] interface IMsRdpClient; + interface IMsTscAx; + [default, source] dispinterface IMsTscAxEvents; + interface IMsTscNonScriptable; + interface IMsRdpClientNonScriptable; + }; + + [uuid(3523C2FB-4031-44E4-9A3B-F1E94986EE7F)] + coclass MsRdpClient2 { + [default] interface IMsRdpClient2; + interface IMsRdpClient; + interface IMsTscAx; + [default, source] dispinterface IMsTscAxEvents; + interface IMsTscNonScriptable; + interface IMsRdpClientNonScriptable; + }; + + [uuid(ACE575FD-1FCF-4074-9401-EBAB990FA9DE)] + coclass MsRdpClient3 { + [default] interface IMsRdpClient3; + interface IMsRdpClient2; + interface IMsRdpClient; + interface IMsTscAx; + [default, source] dispinterface IMsTscAxEvents; + interface IMsTscNonScriptable; + interface IMsRdpClientNonScriptable; + }; + + [uuid(6AE29350-321B-42BE-BBE5-12FB5270C0DE)] + coclass MsRdpClient4 { + [default] interface IMsRdpClient4; + interface IMsRdpClient3; + interface IMsRdpClient2; + interface IMsRdpClient; + interface IMsTscAx; + [default, source] dispinterface IMsTscAxEvents; + interface IMsTscNonScriptable; + interface IMsRdpClientNonScriptable; + interface IMsRdpClientNonScriptable2; + }; + +}; diff --git a/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/mstsclib.rc b/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/mstsclib.rc new file mode 100644 index 00000000000..7c05c2bc7f8 --- /dev/null +++ b/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/mstsclib.rc @@ -0,0 +1,9 @@ +#define TOSTRING_(X) # X +#define TOSTRING(X) TOSTRING_(X) + +LANGUAGE 0, 0 + +// NOTE: TYPELIB_PATH__ is defined on the command line (-D TYPELIB_PATH__=) +1 TYPELIB TOSTRING(TYPELIB_PATH__) + +// EOF diff --git a/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/mstsclib_h.h b/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/mstsclib_h.h new file mode 100644 index 00000000000..e781a99573b --- /dev/null +++ b/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/mstsclib_h.h @@ -0,0 +1,8946 @@ + + +/* this ALWAYS GENERATED file contains the definitions for the interfaces */ + + + /* File created by MIDL compiler version 7.00.0493 */ +/* at Mon Jul 31 17:27:49 2006 + */ +/* Compiler settings for .\mstsclib.idl: + Oicf, W1, Zp8, env=Win32 (32b run) + protocol : dce , ms_ext, c_ext, robust + error checks: allocation ref bounds_check enum stub_data + VC __declspec() decoration level: + __declspec(uuid()), __declspec(selectany), __declspec(novtable) + DECLSPEC_UUID(), MIDL_INTERFACE() +*/ +//@@MIDL_FILE_HEADING( ) + +#pragma warning( disable: 4049 ) /* more than 64k source lines */ + + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 475 +#endif + +#include "rpc.h" +#include "rpcndr.h" + +#ifndef __RPCNDR_H_VERSION__ +#error this stub requires an updated version of +#endif // __RPCNDR_H_VERSION__ + + +#ifndef __mstsclib_h_h__ +#define __mstsclib_h_h__ + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +/* Forward Declarations */ + +#ifndef __IMsTscAxEvents_FWD_DEFINED__ +#define __IMsTscAxEvents_FWD_DEFINED__ +typedef interface IMsTscAxEvents IMsTscAxEvents; +#endif /* __IMsTscAxEvents_FWD_DEFINED__ */ + + +#ifndef __IMsTscAx_FWD_DEFINED__ +#define __IMsTscAx_FWD_DEFINED__ +typedef interface IMsTscAx IMsTscAx; +#endif /* __IMsTscAx_FWD_DEFINED__ */ + + +#ifndef __IMsRdpClient_FWD_DEFINED__ +#define __IMsRdpClient_FWD_DEFINED__ +typedef interface IMsRdpClient IMsRdpClient; +#endif /* __IMsRdpClient_FWD_DEFINED__ */ + + +#ifndef __IMsRdpClient2_FWD_DEFINED__ +#define __IMsRdpClient2_FWD_DEFINED__ +typedef interface IMsRdpClient2 IMsRdpClient2; +#endif /* __IMsRdpClient2_FWD_DEFINED__ */ + + +#ifndef __IMsRdpClient3_FWD_DEFINED__ +#define __IMsRdpClient3_FWD_DEFINED__ +typedef interface IMsRdpClient3 IMsRdpClient3; +#endif /* __IMsRdpClient3_FWD_DEFINED__ */ + + +#ifndef __IMsRdpClient4_FWD_DEFINED__ +#define __IMsRdpClient4_FWD_DEFINED__ +typedef interface IMsRdpClient4 IMsRdpClient4; +#endif /* __IMsRdpClient4_FWD_DEFINED__ */ + + +#ifndef __IMsTscNonScriptable_FWD_DEFINED__ +#define __IMsTscNonScriptable_FWD_DEFINED__ +typedef interface IMsTscNonScriptable IMsTscNonScriptable; +#endif /* __IMsTscNonScriptable_FWD_DEFINED__ */ + + +#ifndef __IMsRdpClientNonScriptable_FWD_DEFINED__ +#define __IMsRdpClientNonScriptable_FWD_DEFINED__ +typedef interface IMsRdpClientNonScriptable IMsRdpClientNonScriptable; +#endif /* __IMsRdpClientNonScriptable_FWD_DEFINED__ */ + + +#ifndef __IMsRdpClientNonScriptable2_FWD_DEFINED__ +#define __IMsRdpClientNonScriptable2_FWD_DEFINED__ +typedef interface IMsRdpClientNonScriptable2 IMsRdpClientNonScriptable2; +#endif /* __IMsRdpClientNonScriptable2_FWD_DEFINED__ */ + + +#ifndef __IMsTscAdvancedSettings_FWD_DEFINED__ +#define __IMsTscAdvancedSettings_FWD_DEFINED__ +typedef interface IMsTscAdvancedSettings IMsTscAdvancedSettings; +#endif /* __IMsTscAdvancedSettings_FWD_DEFINED__ */ + + +#ifndef __IMsRdpClientAdvancedSettings_FWD_DEFINED__ +#define __IMsRdpClientAdvancedSettings_FWD_DEFINED__ +typedef interface IMsRdpClientAdvancedSettings IMsRdpClientAdvancedSettings; +#endif /* __IMsRdpClientAdvancedSettings_FWD_DEFINED__ */ + + +#ifndef __IMsRdpClientAdvancedSettings2_FWD_DEFINED__ +#define __IMsRdpClientAdvancedSettings2_FWD_DEFINED__ +typedef interface IMsRdpClientAdvancedSettings2 IMsRdpClientAdvancedSettings2; +#endif /* __IMsRdpClientAdvancedSettings2_FWD_DEFINED__ */ + + +#ifndef __IMsRdpClientAdvancedSettings3_FWD_DEFINED__ +#define __IMsRdpClientAdvancedSettings3_FWD_DEFINED__ +typedef interface IMsRdpClientAdvancedSettings3 IMsRdpClientAdvancedSettings3; +#endif /* __IMsRdpClientAdvancedSettings3_FWD_DEFINED__ */ + + +#ifndef __IMsRdpClientAdvancedSettings4_FWD_DEFINED__ +#define __IMsRdpClientAdvancedSettings4_FWD_DEFINED__ +typedef interface IMsRdpClientAdvancedSettings4 IMsRdpClientAdvancedSettings4; +#endif /* __IMsRdpClientAdvancedSettings4_FWD_DEFINED__ */ + + +#ifndef __IMsTscSecuredSettings_FWD_DEFINED__ +#define __IMsTscSecuredSettings_FWD_DEFINED__ +typedef interface IMsTscSecuredSettings IMsTscSecuredSettings; +#endif /* __IMsTscSecuredSettings_FWD_DEFINED__ */ + + +#ifndef __IMsRdpClientSecuredSettings_FWD_DEFINED__ +#define __IMsRdpClientSecuredSettings_FWD_DEFINED__ +typedef interface IMsRdpClientSecuredSettings IMsRdpClientSecuredSettings; +#endif /* __IMsRdpClientSecuredSettings_FWD_DEFINED__ */ + + +#ifndef __IMsTscDebug_FWD_DEFINED__ +#define __IMsTscDebug_FWD_DEFINED__ +typedef interface IMsTscDebug IMsTscDebug; +#endif /* __IMsTscDebug_FWD_DEFINED__ */ + + +#ifndef __MsTscAx_FWD_DEFINED__ +#define __MsTscAx_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class MsTscAx MsTscAx; +#else +typedef struct MsTscAx MsTscAx; +#endif /* __cplusplus */ + +#endif /* __MsTscAx_FWD_DEFINED__ */ + + +#ifndef __MsRdpClient_FWD_DEFINED__ +#define __MsRdpClient_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class MsRdpClient MsRdpClient; +#else +typedef struct MsRdpClient MsRdpClient; +#endif /* __cplusplus */ + +#endif /* __MsRdpClient_FWD_DEFINED__ */ + + +#ifndef __MsRdpClient2_FWD_DEFINED__ +#define __MsRdpClient2_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class MsRdpClient2 MsRdpClient2; +#else +typedef struct MsRdpClient2 MsRdpClient2; +#endif /* __cplusplus */ + +#endif /* __MsRdpClient2_FWD_DEFINED__ */ + + +#ifndef __MsRdpClient3_FWD_DEFINED__ +#define __MsRdpClient3_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class MsRdpClient3 MsRdpClient3; +#else +typedef struct MsRdpClient3 MsRdpClient3; +#endif /* __cplusplus */ + +#endif /* __MsRdpClient3_FWD_DEFINED__ */ + + +#ifndef __MsRdpClient4_FWD_DEFINED__ +#define __MsRdpClient4_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class MsRdpClient4 MsRdpClient4; +#else +typedef struct MsRdpClient4 MsRdpClient4; +#endif /* __cplusplus */ + +#endif /* __MsRdpClient4_FWD_DEFINED__ */ + + +#ifdef __cplusplus +extern "C"{ +#endif + + + +#ifndef __MSTSCLib_LIBRARY_DEFINED__ +#define __MSTSCLib_LIBRARY_DEFINED__ + +/* library MSTSCLib */ +/* [version][uuid] */ + + + + + + + + + + + + + + + + + + +typedef /* [public][public][public] */ +enum __MIDL___MIDL_itf_mstsax_0275_0001 + { autoReconnectContinueAutomatic = 0, + autoReconnectContinueStop = 1, + autoReconnectContinueManual = 2 + } AutoReconnectContinueState; + +typedef /* [public][public][public] */ +enum __MIDL_IMsRdpClient_0001 + { exDiscReasonNoInfo = 0, + exDiscReasonAPIInitiatedDisconnect = 1, + exDiscReasonAPIInitiatedLogoff = 2, + exDiscReasonServerIdleTimeout = 3, + exDiscReasonServerLogonTimeout = 4, + exDiscReasonReplacedByOtherConnection = 5, + exDiscReasonOutOfMemory = 6, + exDiscReasonServerDeniedConnection = 7, + exDiscReasonServerDeniedConnectionFips = 8, + exDiscReasonLicenseInternal = 256, + exDiscReasonLicenseNoLicenseServer = 257, + exDiscReasonLicenseNoLicense = 258, + exDiscReasonLicenseErrClientMsg = 259, + exDiscReasonLicenseHwidDoesntMatchLicense = 260, + exDiscReasonLicenseErrClientLicense = 261, + exDiscReasonLicenseCantFinishProtocol = 262, + exDiscReasonLicenseClientEndedProtocol = 263, + exDiscReasonLicenseErrClientEncryption = 264, + exDiscReasonLicenseCantUpgradeLicense = 265, + exDiscReasonLicenseNoRemoteConnections = 266, + exDiscReasonProtocolRangeStart = 4096, + exDiscReasonProtocolRangeEnd = 32767 + } ExtendedDisconnectReasonCode; + +typedef /* [public][public][public] */ +enum __MIDL_IMsRdpClient_0002 + { controlCloseCanProceed = 0, + controlCloseWaitForEvents = 1 + } ControlCloseStatus; + +typedef /* [custom][public] */ unsigned __int3264 UINT_PTR; + +typedef /* [custom][public] */ __int3264 LONG_PTR; + + +EXTERN_C const IID LIBID_MSTSCLib; + +#ifndef __IMsTscAxEvents_DISPINTERFACE_DEFINED__ +#define __IMsTscAxEvents_DISPINTERFACE_DEFINED__ + +/* dispinterface IMsTscAxEvents */ +/* [uuid] */ + + +EXTERN_C const IID DIID_IMsTscAxEvents; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("336D5562-EFA8-482E-8CB3-C5C0FC7A7DB6") + IMsTscAxEvents : public IDispatch + { + }; + +#else /* C style interface */ + + typedef struct IMsTscAxEventsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMsTscAxEvents * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ + __RPC__deref_out void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMsTscAxEvents * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMsTscAxEvents * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + IMsTscAxEvents * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + IMsTscAxEvents * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + IMsTscAxEvents * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [range][in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + IMsTscAxEvents * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + END_INTERFACE + } IMsTscAxEventsVtbl; + + interface IMsTscAxEvents + { + CONST_VTBL struct IMsTscAxEventsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMsTscAxEvents_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMsTscAxEvents_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMsTscAxEvents_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMsTscAxEvents_GetTypeInfoCount(This,pctinfo) \ + ( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) ) + +#define IMsTscAxEvents_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + ( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) ) + +#define IMsTscAxEvents_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + ( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ) + +#define IMsTscAxEvents_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + ( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + +#endif /* __IMsTscAxEvents_DISPINTERFACE_DEFINED__ */ + + +#ifndef __IMsTscAx_INTERFACE_DEFINED__ +#define __IMsTscAx_INTERFACE_DEFINED__ + +/* interface IMsTscAx */ +/* [object][oleautomation][dual][uuid] */ + + +EXTERN_C const IID IID_IMsTscAx; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8C11EFAE-92C3-11D1-BC1E-00C04FA31489") + IMsTscAx : public IDispatch + { + public: + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_Server( + /* [in] */ BSTR pServer) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Server( + /* [retval][out] */ BSTR *pServer) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_Domain( + /* [in] */ BSTR pDomain) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Domain( + /* [retval][out] */ BSTR *pDomain) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_UserName( + /* [in] */ BSTR pUserName) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_UserName( + /* [retval][out] */ BSTR *pUserName) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_DisconnectedText( + /* [in] */ BSTR pDisconnectedText) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_DisconnectedText( + /* [retval][out] */ BSTR *pDisconnectedText) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_ConnectingText( + /* [in] */ BSTR pConnectingText) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_ConnectingText( + /* [retval][out] */ BSTR *pConnectingText) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Connected( + /* [retval][out] */ short *pIsConnected) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_DesktopWidth( + /* [in] */ long pVal) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_DesktopWidth( + /* [retval][out] */ long *pVal) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_DesktopHeight( + /* [in] */ long pVal) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_DesktopHeight( + /* [retval][out] */ long *pVal) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_StartConnected( + /* [in] */ long pfStartConnected) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_StartConnected( + /* [retval][out] */ long *pfStartConnected) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_HorizontalScrollBarVisible( + /* [retval][out] */ long *pfHScrollVisible) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_VerticalScrollBarVisible( + /* [retval][out] */ long *pfVScrollVisible) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_FullScreenTitle( + /* [in] */ BSTR rhs) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_CipherStrength( + /* [retval][out] */ long *pCipherStrength) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Version( + /* [retval][out] */ BSTR *pVersion) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_SecuredSettingsEnabled( + /* [retval][out] */ long *pSecuredSettingsEnabled) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_SecuredSettings( + /* [retval][out] */ IMsTscSecuredSettings **ppSecuredSettings) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_AdvancedSettings( + /* [retval][out] */ IMsTscAdvancedSettings **ppAdvSettings) = 0; + + virtual /* [hidden][propget][id] */ HRESULT STDMETHODCALLTYPE get_Debugger( + /* [retval][out] */ IMsTscDebug **ppDebugger) = 0; + + virtual /* [id] */ HRESULT STDMETHODCALLTYPE Connect( void) = 0; + + virtual /* [id] */ HRESULT STDMETHODCALLTYPE Disconnect( void) = 0; + + virtual /* [id] */ HRESULT STDMETHODCALLTYPE CreateVirtualChannels( + /* [in] */ BSTR newVal) = 0; + + virtual /* [id] */ HRESULT STDMETHODCALLTYPE SendOnVirtualChannel( + /* [in] */ BSTR chanName, + /* [in] */ BSTR ChanData) = 0; + + }; + +#else /* C style interface */ + + typedef struct IMsTscAxVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMsTscAx * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ + __RPC__deref_out void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMsTscAx * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMsTscAx * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + IMsTscAx * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + IMsTscAx * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + IMsTscAx * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [range][in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + IMsTscAx * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Server )( + IMsTscAx * This, + /* [in] */ BSTR pServer); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Server )( + IMsTscAx * This, + /* [retval][out] */ BSTR *pServer); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Domain )( + IMsTscAx * This, + /* [in] */ BSTR pDomain); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Domain )( + IMsTscAx * This, + /* [retval][out] */ BSTR *pDomain); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_UserName )( + IMsTscAx * This, + /* [in] */ BSTR pUserName); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_UserName )( + IMsTscAx * This, + /* [retval][out] */ BSTR *pUserName); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DisconnectedText )( + IMsTscAx * This, + /* [in] */ BSTR pDisconnectedText); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DisconnectedText )( + IMsTscAx * This, + /* [retval][out] */ BSTR *pDisconnectedText); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ConnectingText )( + IMsTscAx * This, + /* [in] */ BSTR pConnectingText); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ConnectingText )( + IMsTscAx * This, + /* [retval][out] */ BSTR *pConnectingText); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Connected )( + IMsTscAx * This, + /* [retval][out] */ short *pIsConnected); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DesktopWidth )( + IMsTscAx * This, + /* [in] */ long pVal); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DesktopWidth )( + IMsTscAx * This, + /* [retval][out] */ long *pVal); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DesktopHeight )( + IMsTscAx * This, + /* [in] */ long pVal); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DesktopHeight )( + IMsTscAx * This, + /* [retval][out] */ long *pVal); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_StartConnected )( + IMsTscAx * This, + /* [in] */ long pfStartConnected); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_StartConnected )( + IMsTscAx * This, + /* [retval][out] */ long *pfStartConnected); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HorizontalScrollBarVisible )( + IMsTscAx * This, + /* [retval][out] */ long *pfHScrollVisible); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_VerticalScrollBarVisible )( + IMsTscAx * This, + /* [retval][out] */ long *pfVScrollVisible); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_FullScreenTitle )( + IMsTscAx * This, + /* [in] */ BSTR rhs); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_CipherStrength )( + IMsTscAx * This, + /* [retval][out] */ long *pCipherStrength); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Version )( + IMsTscAx * This, + /* [retval][out] */ BSTR *pVersion); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SecuredSettingsEnabled )( + IMsTscAx * This, + /* [retval][out] */ long *pSecuredSettingsEnabled); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SecuredSettings )( + IMsTscAx * This, + /* [retval][out] */ IMsTscSecuredSettings **ppSecuredSettings); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AdvancedSettings )( + IMsTscAx * This, + /* [retval][out] */ IMsTscAdvancedSettings **ppAdvSettings); + + /* [hidden][propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Debugger )( + IMsTscAx * This, + /* [retval][out] */ IMsTscDebug **ppDebugger); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *Connect )( + IMsTscAx * This); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *Disconnect )( + IMsTscAx * This); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *CreateVirtualChannels )( + IMsTscAx * This, + /* [in] */ BSTR newVal); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *SendOnVirtualChannel )( + IMsTscAx * This, + /* [in] */ BSTR chanName, + /* [in] */ BSTR ChanData); + + END_INTERFACE + } IMsTscAxVtbl; + + interface IMsTscAx + { + CONST_VTBL struct IMsTscAxVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMsTscAx_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMsTscAx_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMsTscAx_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMsTscAx_GetTypeInfoCount(This,pctinfo) \ + ( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) ) + +#define IMsTscAx_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + ( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) ) + +#define IMsTscAx_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + ( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ) + +#define IMsTscAx_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + ( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ) + + +#define IMsTscAx_put_Server(This,pServer) \ + ( (This)->lpVtbl -> put_Server(This,pServer) ) + +#define IMsTscAx_get_Server(This,pServer) \ + ( (This)->lpVtbl -> get_Server(This,pServer) ) + +#define IMsTscAx_put_Domain(This,pDomain) \ + ( (This)->lpVtbl -> put_Domain(This,pDomain) ) + +#define IMsTscAx_get_Domain(This,pDomain) \ + ( (This)->lpVtbl -> get_Domain(This,pDomain) ) + +#define IMsTscAx_put_UserName(This,pUserName) \ + ( (This)->lpVtbl -> put_UserName(This,pUserName) ) + +#define IMsTscAx_get_UserName(This,pUserName) \ + ( (This)->lpVtbl -> get_UserName(This,pUserName) ) + +#define IMsTscAx_put_DisconnectedText(This,pDisconnectedText) \ + ( (This)->lpVtbl -> put_DisconnectedText(This,pDisconnectedText) ) + +#define IMsTscAx_get_DisconnectedText(This,pDisconnectedText) \ + ( (This)->lpVtbl -> get_DisconnectedText(This,pDisconnectedText) ) + +#define IMsTscAx_put_ConnectingText(This,pConnectingText) \ + ( (This)->lpVtbl -> put_ConnectingText(This,pConnectingText) ) + +#define IMsTscAx_get_ConnectingText(This,pConnectingText) \ + ( (This)->lpVtbl -> get_ConnectingText(This,pConnectingText) ) + +#define IMsTscAx_get_Connected(This,pIsConnected) \ + ( (This)->lpVtbl -> get_Connected(This,pIsConnected) ) + +#define IMsTscAx_put_DesktopWidth(This,pVal) \ + ( (This)->lpVtbl -> put_DesktopWidth(This,pVal) ) + +#define IMsTscAx_get_DesktopWidth(This,pVal) \ + ( (This)->lpVtbl -> get_DesktopWidth(This,pVal) ) + +#define IMsTscAx_put_DesktopHeight(This,pVal) \ + ( (This)->lpVtbl -> put_DesktopHeight(This,pVal) ) + +#define IMsTscAx_get_DesktopHeight(This,pVal) \ + ( (This)->lpVtbl -> get_DesktopHeight(This,pVal) ) + +#define IMsTscAx_put_StartConnected(This,pfStartConnected) \ + ( (This)->lpVtbl -> put_StartConnected(This,pfStartConnected) ) + +#define IMsTscAx_get_StartConnected(This,pfStartConnected) \ + ( (This)->lpVtbl -> get_StartConnected(This,pfStartConnected) ) + +#define IMsTscAx_get_HorizontalScrollBarVisible(This,pfHScrollVisible) \ + ( (This)->lpVtbl -> get_HorizontalScrollBarVisible(This,pfHScrollVisible) ) + +#define IMsTscAx_get_VerticalScrollBarVisible(This,pfVScrollVisible) \ + ( (This)->lpVtbl -> get_VerticalScrollBarVisible(This,pfVScrollVisible) ) + +#define IMsTscAx_put_FullScreenTitle(This,rhs) \ + ( (This)->lpVtbl -> put_FullScreenTitle(This,rhs) ) + +#define IMsTscAx_get_CipherStrength(This,pCipherStrength) \ + ( (This)->lpVtbl -> get_CipherStrength(This,pCipherStrength) ) + +#define IMsTscAx_get_Version(This,pVersion) \ + ( (This)->lpVtbl -> get_Version(This,pVersion) ) + +#define IMsTscAx_get_SecuredSettingsEnabled(This,pSecuredSettingsEnabled) \ + ( (This)->lpVtbl -> get_SecuredSettingsEnabled(This,pSecuredSettingsEnabled) ) + +#define IMsTscAx_get_SecuredSettings(This,ppSecuredSettings) \ + ( (This)->lpVtbl -> get_SecuredSettings(This,ppSecuredSettings) ) + +#define IMsTscAx_get_AdvancedSettings(This,ppAdvSettings) \ + ( (This)->lpVtbl -> get_AdvancedSettings(This,ppAdvSettings) ) + +#define IMsTscAx_get_Debugger(This,ppDebugger) \ + ( (This)->lpVtbl -> get_Debugger(This,ppDebugger) ) + +#define IMsTscAx_Connect(This) \ + ( (This)->lpVtbl -> Connect(This) ) + +#define IMsTscAx_Disconnect(This) \ + ( (This)->lpVtbl -> Disconnect(This) ) + +#define IMsTscAx_CreateVirtualChannels(This,newVal) \ + ( (This)->lpVtbl -> CreateVirtualChannels(This,newVal) ) + +#define IMsTscAx_SendOnVirtualChannel(This,chanName,ChanData) \ + ( (This)->lpVtbl -> SendOnVirtualChannel(This,chanName,ChanData) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMsTscAx_INTERFACE_DEFINED__ */ + + +#ifndef __IMsRdpClient_INTERFACE_DEFINED__ +#define __IMsRdpClient_INTERFACE_DEFINED__ + +/* interface IMsRdpClient */ +/* [object][oleautomation][dual][uuid] */ + + +EXTERN_C const IID IID_IMsRdpClient; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("92B4A539-7115-4B7C-A5A9-E5D9EFC2780A") + IMsRdpClient : public IMsTscAx + { + public: + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_ColorDepth( + /* [in] */ long pcolorDepth) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_ColorDepth( + /* [retval][out] */ long *pcolorDepth) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_AdvancedSettings2( + /* [retval][out] */ IMsRdpClientAdvancedSettings **ppAdvSettings) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_SecuredSettings2( + /* [retval][out] */ IMsRdpClientSecuredSettings **ppSecuredSettings) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_ExtendedDisconnectReason( + /* [retval][out] */ ExtendedDisconnectReasonCode *pExtendedDisconnectReason) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_FullScreen( + /* [in] */ VARIANT_BOOL pfFullScreen) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_FullScreen( + /* [retval][out] */ VARIANT_BOOL *pfFullScreen) = 0; + + virtual /* [id] */ HRESULT STDMETHODCALLTYPE SetVirtualChannelOptions( + /* [in] */ BSTR chanName, + /* [in] */ long chanOptions) = 0; + + virtual /* [id] */ HRESULT STDMETHODCALLTYPE GetVirtualChannelOptions( + /* [in] */ BSTR chanName, + /* [retval][out] */ long *pChanOptions) = 0; + + virtual /* [id] */ HRESULT STDMETHODCALLTYPE RequestClose( + /* [retval][out] */ ControlCloseStatus *pCloseStatus) = 0; + + }; + +#else /* C style interface */ + + typedef struct IMsRdpClientVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMsRdpClient * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ + __RPC__deref_out void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMsRdpClient * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMsRdpClient * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + IMsRdpClient * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + IMsRdpClient * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + IMsRdpClient * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [range][in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + IMsRdpClient * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Server )( + IMsRdpClient * This, + /* [in] */ BSTR pServer); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Server )( + IMsRdpClient * This, + /* [retval][out] */ BSTR *pServer); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Domain )( + IMsRdpClient * This, + /* [in] */ BSTR pDomain); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Domain )( + IMsRdpClient * This, + /* [retval][out] */ BSTR *pDomain); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_UserName )( + IMsRdpClient * This, + /* [in] */ BSTR pUserName); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_UserName )( + IMsRdpClient * This, + /* [retval][out] */ BSTR *pUserName); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DisconnectedText )( + IMsRdpClient * This, + /* [in] */ BSTR pDisconnectedText); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DisconnectedText )( + IMsRdpClient * This, + /* [retval][out] */ BSTR *pDisconnectedText); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ConnectingText )( + IMsRdpClient * This, + /* [in] */ BSTR pConnectingText); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ConnectingText )( + IMsRdpClient * This, + /* [retval][out] */ BSTR *pConnectingText); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Connected )( + IMsRdpClient * This, + /* [retval][out] */ short *pIsConnected); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DesktopWidth )( + IMsRdpClient * This, + /* [in] */ long pVal); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DesktopWidth )( + IMsRdpClient * This, + /* [retval][out] */ long *pVal); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DesktopHeight )( + IMsRdpClient * This, + /* [in] */ long pVal); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DesktopHeight )( + IMsRdpClient * This, + /* [retval][out] */ long *pVal); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_StartConnected )( + IMsRdpClient * This, + /* [in] */ long pfStartConnected); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_StartConnected )( + IMsRdpClient * This, + /* [retval][out] */ long *pfStartConnected); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HorizontalScrollBarVisible )( + IMsRdpClient * This, + /* [retval][out] */ long *pfHScrollVisible); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_VerticalScrollBarVisible )( + IMsRdpClient * This, + /* [retval][out] */ long *pfVScrollVisible); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_FullScreenTitle )( + IMsRdpClient * This, + /* [in] */ BSTR rhs); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_CipherStrength )( + IMsRdpClient * This, + /* [retval][out] */ long *pCipherStrength); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Version )( + IMsRdpClient * This, + /* [retval][out] */ BSTR *pVersion); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SecuredSettingsEnabled )( + IMsRdpClient * This, + /* [retval][out] */ long *pSecuredSettingsEnabled); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SecuredSettings )( + IMsRdpClient * This, + /* [retval][out] */ IMsTscSecuredSettings **ppSecuredSettings); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AdvancedSettings )( + IMsRdpClient * This, + /* [retval][out] */ IMsTscAdvancedSettings **ppAdvSettings); + + /* [hidden][propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Debugger )( + IMsRdpClient * This, + /* [retval][out] */ IMsTscDebug **ppDebugger); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *Connect )( + IMsRdpClient * This); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *Disconnect )( + IMsRdpClient * This); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *CreateVirtualChannels )( + IMsRdpClient * This, + /* [in] */ BSTR newVal); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *SendOnVirtualChannel )( + IMsRdpClient * This, + /* [in] */ BSTR chanName, + /* [in] */ BSTR ChanData); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ColorDepth )( + IMsRdpClient * This, + /* [in] */ long pcolorDepth); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ColorDepth )( + IMsRdpClient * This, + /* [retval][out] */ long *pcolorDepth); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AdvancedSettings2 )( + IMsRdpClient * This, + /* [retval][out] */ IMsRdpClientAdvancedSettings **ppAdvSettings); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SecuredSettings2 )( + IMsRdpClient * This, + /* [retval][out] */ IMsRdpClientSecuredSettings **ppSecuredSettings); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ExtendedDisconnectReason )( + IMsRdpClient * This, + /* [retval][out] */ ExtendedDisconnectReasonCode *pExtendedDisconnectReason); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_FullScreen )( + IMsRdpClient * This, + /* [in] */ VARIANT_BOOL pfFullScreen); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_FullScreen )( + IMsRdpClient * This, + /* [retval][out] */ VARIANT_BOOL *pfFullScreen); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *SetVirtualChannelOptions )( + IMsRdpClient * This, + /* [in] */ BSTR chanName, + /* [in] */ long chanOptions); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *GetVirtualChannelOptions )( + IMsRdpClient * This, + /* [in] */ BSTR chanName, + /* [retval][out] */ long *pChanOptions); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *RequestClose )( + IMsRdpClient * This, + /* [retval][out] */ ControlCloseStatus *pCloseStatus); + + END_INTERFACE + } IMsRdpClientVtbl; + + interface IMsRdpClient + { + CONST_VTBL struct IMsRdpClientVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMsRdpClient_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMsRdpClient_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMsRdpClient_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMsRdpClient_GetTypeInfoCount(This,pctinfo) \ + ( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) ) + +#define IMsRdpClient_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + ( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) ) + +#define IMsRdpClient_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + ( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ) + +#define IMsRdpClient_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + ( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ) + + +#define IMsRdpClient_put_Server(This,pServer) \ + ( (This)->lpVtbl -> put_Server(This,pServer) ) + +#define IMsRdpClient_get_Server(This,pServer) \ + ( (This)->lpVtbl -> get_Server(This,pServer) ) + +#define IMsRdpClient_put_Domain(This,pDomain) \ + ( (This)->lpVtbl -> put_Domain(This,pDomain) ) + +#define IMsRdpClient_get_Domain(This,pDomain) \ + ( (This)->lpVtbl -> get_Domain(This,pDomain) ) + +#define IMsRdpClient_put_UserName(This,pUserName) \ + ( (This)->lpVtbl -> put_UserName(This,pUserName) ) + +#define IMsRdpClient_get_UserName(This,pUserName) \ + ( (This)->lpVtbl -> get_UserName(This,pUserName) ) + +#define IMsRdpClient_put_DisconnectedText(This,pDisconnectedText) \ + ( (This)->lpVtbl -> put_DisconnectedText(This,pDisconnectedText) ) + +#define IMsRdpClient_get_DisconnectedText(This,pDisconnectedText) \ + ( (This)->lpVtbl -> get_DisconnectedText(This,pDisconnectedText) ) + +#define IMsRdpClient_put_ConnectingText(This,pConnectingText) \ + ( (This)->lpVtbl -> put_ConnectingText(This,pConnectingText) ) + +#define IMsRdpClient_get_ConnectingText(This,pConnectingText) \ + ( (This)->lpVtbl -> get_ConnectingText(This,pConnectingText) ) + +#define IMsRdpClient_get_Connected(This,pIsConnected) \ + ( (This)->lpVtbl -> get_Connected(This,pIsConnected) ) + +#define IMsRdpClient_put_DesktopWidth(This,pVal) \ + ( (This)->lpVtbl -> put_DesktopWidth(This,pVal) ) + +#define IMsRdpClient_get_DesktopWidth(This,pVal) \ + ( (This)->lpVtbl -> get_DesktopWidth(This,pVal) ) + +#define IMsRdpClient_put_DesktopHeight(This,pVal) \ + ( (This)->lpVtbl -> put_DesktopHeight(This,pVal) ) + +#define IMsRdpClient_get_DesktopHeight(This,pVal) \ + ( (This)->lpVtbl -> get_DesktopHeight(This,pVal) ) + +#define IMsRdpClient_put_StartConnected(This,pfStartConnected) \ + ( (This)->lpVtbl -> put_StartConnected(This,pfStartConnected) ) + +#define IMsRdpClient_get_StartConnected(This,pfStartConnected) \ + ( (This)->lpVtbl -> get_StartConnected(This,pfStartConnected) ) + +#define IMsRdpClient_get_HorizontalScrollBarVisible(This,pfHScrollVisible) \ + ( (This)->lpVtbl -> get_HorizontalScrollBarVisible(This,pfHScrollVisible) ) + +#define IMsRdpClient_get_VerticalScrollBarVisible(This,pfVScrollVisible) \ + ( (This)->lpVtbl -> get_VerticalScrollBarVisible(This,pfVScrollVisible) ) + +#define IMsRdpClient_put_FullScreenTitle(This,rhs) \ + ( (This)->lpVtbl -> put_FullScreenTitle(This,rhs) ) + +#define IMsRdpClient_get_CipherStrength(This,pCipherStrength) \ + ( (This)->lpVtbl -> get_CipherStrength(This,pCipherStrength) ) + +#define IMsRdpClient_get_Version(This,pVersion) \ + ( (This)->lpVtbl -> get_Version(This,pVersion) ) + +#define IMsRdpClient_get_SecuredSettingsEnabled(This,pSecuredSettingsEnabled) \ + ( (This)->lpVtbl -> get_SecuredSettingsEnabled(This,pSecuredSettingsEnabled) ) + +#define IMsRdpClient_get_SecuredSettings(This,ppSecuredSettings) \ + ( (This)->lpVtbl -> get_SecuredSettings(This,ppSecuredSettings) ) + +#define IMsRdpClient_get_AdvancedSettings(This,ppAdvSettings) \ + ( (This)->lpVtbl -> get_AdvancedSettings(This,ppAdvSettings) ) + +#define IMsRdpClient_get_Debugger(This,ppDebugger) \ + ( (This)->lpVtbl -> get_Debugger(This,ppDebugger) ) + +#define IMsRdpClient_Connect(This) \ + ( (This)->lpVtbl -> Connect(This) ) + +#define IMsRdpClient_Disconnect(This) \ + ( (This)->lpVtbl -> Disconnect(This) ) + +#define IMsRdpClient_CreateVirtualChannels(This,newVal) \ + ( (This)->lpVtbl -> CreateVirtualChannels(This,newVal) ) + +#define IMsRdpClient_SendOnVirtualChannel(This,chanName,ChanData) \ + ( (This)->lpVtbl -> SendOnVirtualChannel(This,chanName,ChanData) ) + + +#define IMsRdpClient_put_ColorDepth(This,pcolorDepth) \ + ( (This)->lpVtbl -> put_ColorDepth(This,pcolorDepth) ) + +#define IMsRdpClient_get_ColorDepth(This,pcolorDepth) \ + ( (This)->lpVtbl -> get_ColorDepth(This,pcolorDepth) ) + +#define IMsRdpClient_get_AdvancedSettings2(This,ppAdvSettings) \ + ( (This)->lpVtbl -> get_AdvancedSettings2(This,ppAdvSettings) ) + +#define IMsRdpClient_get_SecuredSettings2(This,ppSecuredSettings) \ + ( (This)->lpVtbl -> get_SecuredSettings2(This,ppSecuredSettings) ) + +#define IMsRdpClient_get_ExtendedDisconnectReason(This,pExtendedDisconnectReason) \ + ( (This)->lpVtbl -> get_ExtendedDisconnectReason(This,pExtendedDisconnectReason) ) + +#define IMsRdpClient_put_FullScreen(This,pfFullScreen) \ + ( (This)->lpVtbl -> put_FullScreen(This,pfFullScreen) ) + +#define IMsRdpClient_get_FullScreen(This,pfFullScreen) \ + ( (This)->lpVtbl -> get_FullScreen(This,pfFullScreen) ) + +#define IMsRdpClient_SetVirtualChannelOptions(This,chanName,chanOptions) \ + ( (This)->lpVtbl -> SetVirtualChannelOptions(This,chanName,chanOptions) ) + +#define IMsRdpClient_GetVirtualChannelOptions(This,chanName,pChanOptions) \ + ( (This)->lpVtbl -> GetVirtualChannelOptions(This,chanName,pChanOptions) ) + +#define IMsRdpClient_RequestClose(This,pCloseStatus) \ + ( (This)->lpVtbl -> RequestClose(This,pCloseStatus) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMsRdpClient_INTERFACE_DEFINED__ */ + + +#ifndef __IMsRdpClient2_INTERFACE_DEFINED__ +#define __IMsRdpClient2_INTERFACE_DEFINED__ + +/* interface IMsRdpClient2 */ +/* [object][oleautomation][dual][uuid] */ + + +EXTERN_C const IID IID_IMsRdpClient2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("E7E17DC4-3B71-4BA7-A8E6-281FFADCA28F") + IMsRdpClient2 : public IMsRdpClient + { + public: + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_AdvancedSettings3( + /* [retval][out] */ IMsRdpClientAdvancedSettings2 **ppAdvSettings) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_ConnectedStatusText( + /* [in] */ BSTR pConnectedStatusText) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_ConnectedStatusText( + /* [retval][out] */ BSTR *pConnectedStatusText) = 0; + + }; + +#else /* C style interface */ + + typedef struct IMsRdpClient2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMsRdpClient2 * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ + __RPC__deref_out void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMsRdpClient2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMsRdpClient2 * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + IMsRdpClient2 * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + IMsRdpClient2 * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + IMsRdpClient2 * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [range][in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + IMsRdpClient2 * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Server )( + IMsRdpClient2 * This, + /* [in] */ BSTR pServer); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Server )( + IMsRdpClient2 * This, + /* [retval][out] */ BSTR *pServer); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Domain )( + IMsRdpClient2 * This, + /* [in] */ BSTR pDomain); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Domain )( + IMsRdpClient2 * This, + /* [retval][out] */ BSTR *pDomain); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_UserName )( + IMsRdpClient2 * This, + /* [in] */ BSTR pUserName); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_UserName )( + IMsRdpClient2 * This, + /* [retval][out] */ BSTR *pUserName); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DisconnectedText )( + IMsRdpClient2 * This, + /* [in] */ BSTR pDisconnectedText); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DisconnectedText )( + IMsRdpClient2 * This, + /* [retval][out] */ BSTR *pDisconnectedText); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ConnectingText )( + IMsRdpClient2 * This, + /* [in] */ BSTR pConnectingText); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ConnectingText )( + IMsRdpClient2 * This, + /* [retval][out] */ BSTR *pConnectingText); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Connected )( + IMsRdpClient2 * This, + /* [retval][out] */ short *pIsConnected); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DesktopWidth )( + IMsRdpClient2 * This, + /* [in] */ long pVal); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DesktopWidth )( + IMsRdpClient2 * This, + /* [retval][out] */ long *pVal); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DesktopHeight )( + IMsRdpClient2 * This, + /* [in] */ long pVal); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DesktopHeight )( + IMsRdpClient2 * This, + /* [retval][out] */ long *pVal); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_StartConnected )( + IMsRdpClient2 * This, + /* [in] */ long pfStartConnected); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_StartConnected )( + IMsRdpClient2 * This, + /* [retval][out] */ long *pfStartConnected); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HorizontalScrollBarVisible )( + IMsRdpClient2 * This, + /* [retval][out] */ long *pfHScrollVisible); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_VerticalScrollBarVisible )( + IMsRdpClient2 * This, + /* [retval][out] */ long *pfVScrollVisible); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_FullScreenTitle )( + IMsRdpClient2 * This, + /* [in] */ BSTR rhs); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_CipherStrength )( + IMsRdpClient2 * This, + /* [retval][out] */ long *pCipherStrength); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Version )( + IMsRdpClient2 * This, + /* [retval][out] */ BSTR *pVersion); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SecuredSettingsEnabled )( + IMsRdpClient2 * This, + /* [retval][out] */ long *pSecuredSettingsEnabled); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SecuredSettings )( + IMsRdpClient2 * This, + /* [retval][out] */ IMsTscSecuredSettings **ppSecuredSettings); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AdvancedSettings )( + IMsRdpClient2 * This, + /* [retval][out] */ IMsTscAdvancedSettings **ppAdvSettings); + + /* [hidden][propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Debugger )( + IMsRdpClient2 * This, + /* [retval][out] */ IMsTscDebug **ppDebugger); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *Connect )( + IMsRdpClient2 * This); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *Disconnect )( + IMsRdpClient2 * This); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *CreateVirtualChannels )( + IMsRdpClient2 * This, + /* [in] */ BSTR newVal); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *SendOnVirtualChannel )( + IMsRdpClient2 * This, + /* [in] */ BSTR chanName, + /* [in] */ BSTR ChanData); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ColorDepth )( + IMsRdpClient2 * This, + /* [in] */ long pcolorDepth); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ColorDepth )( + IMsRdpClient2 * This, + /* [retval][out] */ long *pcolorDepth); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AdvancedSettings2 )( + IMsRdpClient2 * This, + /* [retval][out] */ IMsRdpClientAdvancedSettings **ppAdvSettings); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SecuredSettings2 )( + IMsRdpClient2 * This, + /* [retval][out] */ IMsRdpClientSecuredSettings **ppSecuredSettings); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ExtendedDisconnectReason )( + IMsRdpClient2 * This, + /* [retval][out] */ ExtendedDisconnectReasonCode *pExtendedDisconnectReason); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_FullScreen )( + IMsRdpClient2 * This, + /* [in] */ VARIANT_BOOL pfFullScreen); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_FullScreen )( + IMsRdpClient2 * This, + /* [retval][out] */ VARIANT_BOOL *pfFullScreen); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *SetVirtualChannelOptions )( + IMsRdpClient2 * This, + /* [in] */ BSTR chanName, + /* [in] */ long chanOptions); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *GetVirtualChannelOptions )( + IMsRdpClient2 * This, + /* [in] */ BSTR chanName, + /* [retval][out] */ long *pChanOptions); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *RequestClose )( + IMsRdpClient2 * This, + /* [retval][out] */ ControlCloseStatus *pCloseStatus); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AdvancedSettings3 )( + IMsRdpClient2 * This, + /* [retval][out] */ IMsRdpClientAdvancedSettings2 **ppAdvSettings); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ConnectedStatusText )( + IMsRdpClient2 * This, + /* [in] */ BSTR pConnectedStatusText); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ConnectedStatusText )( + IMsRdpClient2 * This, + /* [retval][out] */ BSTR *pConnectedStatusText); + + END_INTERFACE + } IMsRdpClient2Vtbl; + + interface IMsRdpClient2 + { + CONST_VTBL struct IMsRdpClient2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMsRdpClient2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMsRdpClient2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMsRdpClient2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMsRdpClient2_GetTypeInfoCount(This,pctinfo) \ + ( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) ) + +#define IMsRdpClient2_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + ( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) ) + +#define IMsRdpClient2_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + ( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ) + +#define IMsRdpClient2_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + ( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ) + + +#define IMsRdpClient2_put_Server(This,pServer) \ + ( (This)->lpVtbl -> put_Server(This,pServer) ) + +#define IMsRdpClient2_get_Server(This,pServer) \ + ( (This)->lpVtbl -> get_Server(This,pServer) ) + +#define IMsRdpClient2_put_Domain(This,pDomain) \ + ( (This)->lpVtbl -> put_Domain(This,pDomain) ) + +#define IMsRdpClient2_get_Domain(This,pDomain) \ + ( (This)->lpVtbl -> get_Domain(This,pDomain) ) + +#define IMsRdpClient2_put_UserName(This,pUserName) \ + ( (This)->lpVtbl -> put_UserName(This,pUserName) ) + +#define IMsRdpClient2_get_UserName(This,pUserName) \ + ( (This)->lpVtbl -> get_UserName(This,pUserName) ) + +#define IMsRdpClient2_put_DisconnectedText(This,pDisconnectedText) \ + ( (This)->lpVtbl -> put_DisconnectedText(This,pDisconnectedText) ) + +#define IMsRdpClient2_get_DisconnectedText(This,pDisconnectedText) \ + ( (This)->lpVtbl -> get_DisconnectedText(This,pDisconnectedText) ) + +#define IMsRdpClient2_put_ConnectingText(This,pConnectingText) \ + ( (This)->lpVtbl -> put_ConnectingText(This,pConnectingText) ) + +#define IMsRdpClient2_get_ConnectingText(This,pConnectingText) \ + ( (This)->lpVtbl -> get_ConnectingText(This,pConnectingText) ) + +#define IMsRdpClient2_get_Connected(This,pIsConnected) \ + ( (This)->lpVtbl -> get_Connected(This,pIsConnected) ) + +#define IMsRdpClient2_put_DesktopWidth(This,pVal) \ + ( (This)->lpVtbl -> put_DesktopWidth(This,pVal) ) + +#define IMsRdpClient2_get_DesktopWidth(This,pVal) \ + ( (This)->lpVtbl -> get_DesktopWidth(This,pVal) ) + +#define IMsRdpClient2_put_DesktopHeight(This,pVal) \ + ( (This)->lpVtbl -> put_DesktopHeight(This,pVal) ) + +#define IMsRdpClient2_get_DesktopHeight(This,pVal) \ + ( (This)->lpVtbl -> get_DesktopHeight(This,pVal) ) + +#define IMsRdpClient2_put_StartConnected(This,pfStartConnected) \ + ( (This)->lpVtbl -> put_StartConnected(This,pfStartConnected) ) + +#define IMsRdpClient2_get_StartConnected(This,pfStartConnected) \ + ( (This)->lpVtbl -> get_StartConnected(This,pfStartConnected) ) + +#define IMsRdpClient2_get_HorizontalScrollBarVisible(This,pfHScrollVisible) \ + ( (This)->lpVtbl -> get_HorizontalScrollBarVisible(This,pfHScrollVisible) ) + +#define IMsRdpClient2_get_VerticalScrollBarVisible(This,pfVScrollVisible) \ + ( (This)->lpVtbl -> get_VerticalScrollBarVisible(This,pfVScrollVisible) ) + +#define IMsRdpClient2_put_FullScreenTitle(This,rhs) \ + ( (This)->lpVtbl -> put_FullScreenTitle(This,rhs) ) + +#define IMsRdpClient2_get_CipherStrength(This,pCipherStrength) \ + ( (This)->lpVtbl -> get_CipherStrength(This,pCipherStrength) ) + +#define IMsRdpClient2_get_Version(This,pVersion) \ + ( (This)->lpVtbl -> get_Version(This,pVersion) ) + +#define IMsRdpClient2_get_SecuredSettingsEnabled(This,pSecuredSettingsEnabled) \ + ( (This)->lpVtbl -> get_SecuredSettingsEnabled(This,pSecuredSettingsEnabled) ) + +#define IMsRdpClient2_get_SecuredSettings(This,ppSecuredSettings) \ + ( (This)->lpVtbl -> get_SecuredSettings(This,ppSecuredSettings) ) + +#define IMsRdpClient2_get_AdvancedSettings(This,ppAdvSettings) \ + ( (This)->lpVtbl -> get_AdvancedSettings(This,ppAdvSettings) ) + +#define IMsRdpClient2_get_Debugger(This,ppDebugger) \ + ( (This)->lpVtbl -> get_Debugger(This,ppDebugger) ) + +#define IMsRdpClient2_Connect(This) \ + ( (This)->lpVtbl -> Connect(This) ) + +#define IMsRdpClient2_Disconnect(This) \ + ( (This)->lpVtbl -> Disconnect(This) ) + +#define IMsRdpClient2_CreateVirtualChannels(This,newVal) \ + ( (This)->lpVtbl -> CreateVirtualChannels(This,newVal) ) + +#define IMsRdpClient2_SendOnVirtualChannel(This,chanName,ChanData) \ + ( (This)->lpVtbl -> SendOnVirtualChannel(This,chanName,ChanData) ) + + +#define IMsRdpClient2_put_ColorDepth(This,pcolorDepth) \ + ( (This)->lpVtbl -> put_ColorDepth(This,pcolorDepth) ) + +#define IMsRdpClient2_get_ColorDepth(This,pcolorDepth) \ + ( (This)->lpVtbl -> get_ColorDepth(This,pcolorDepth) ) + +#define IMsRdpClient2_get_AdvancedSettings2(This,ppAdvSettings) \ + ( (This)->lpVtbl -> get_AdvancedSettings2(This,ppAdvSettings) ) + +#define IMsRdpClient2_get_SecuredSettings2(This,ppSecuredSettings) \ + ( (This)->lpVtbl -> get_SecuredSettings2(This,ppSecuredSettings) ) + +#define IMsRdpClient2_get_ExtendedDisconnectReason(This,pExtendedDisconnectReason) \ + ( (This)->lpVtbl -> get_ExtendedDisconnectReason(This,pExtendedDisconnectReason) ) + +#define IMsRdpClient2_put_FullScreen(This,pfFullScreen) \ + ( (This)->lpVtbl -> put_FullScreen(This,pfFullScreen) ) + +#define IMsRdpClient2_get_FullScreen(This,pfFullScreen) \ + ( (This)->lpVtbl -> get_FullScreen(This,pfFullScreen) ) + +#define IMsRdpClient2_SetVirtualChannelOptions(This,chanName,chanOptions) \ + ( (This)->lpVtbl -> SetVirtualChannelOptions(This,chanName,chanOptions) ) + +#define IMsRdpClient2_GetVirtualChannelOptions(This,chanName,pChanOptions) \ + ( (This)->lpVtbl -> GetVirtualChannelOptions(This,chanName,pChanOptions) ) + +#define IMsRdpClient2_RequestClose(This,pCloseStatus) \ + ( (This)->lpVtbl -> RequestClose(This,pCloseStatus) ) + + +#define IMsRdpClient2_get_AdvancedSettings3(This,ppAdvSettings) \ + ( (This)->lpVtbl -> get_AdvancedSettings3(This,ppAdvSettings) ) + +#define IMsRdpClient2_put_ConnectedStatusText(This,pConnectedStatusText) \ + ( (This)->lpVtbl -> put_ConnectedStatusText(This,pConnectedStatusText) ) + +#define IMsRdpClient2_get_ConnectedStatusText(This,pConnectedStatusText) \ + ( (This)->lpVtbl -> get_ConnectedStatusText(This,pConnectedStatusText) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMsRdpClient2_INTERFACE_DEFINED__ */ + + +#ifndef __IMsRdpClient3_INTERFACE_DEFINED__ +#define __IMsRdpClient3_INTERFACE_DEFINED__ + +/* interface IMsRdpClient3 */ +/* [object][oleautomation][dual][uuid] */ + + +EXTERN_C const IID IID_IMsRdpClient3; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("91B7CBC5-A72E-4FA0-9300-D647D7E897FF") + IMsRdpClient3 : public IMsRdpClient2 + { + public: + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_AdvancedSettings4( + /* [retval][out] */ IMsRdpClientAdvancedSettings3 **ppAdvSettings) = 0; + + }; + +#else /* C style interface */ + + typedef struct IMsRdpClient3Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMsRdpClient3 * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ + __RPC__deref_out void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMsRdpClient3 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMsRdpClient3 * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + IMsRdpClient3 * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + IMsRdpClient3 * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + IMsRdpClient3 * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [range][in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + IMsRdpClient3 * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Server )( + IMsRdpClient3 * This, + /* [in] */ BSTR pServer); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Server )( + IMsRdpClient3 * This, + /* [retval][out] */ BSTR *pServer); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Domain )( + IMsRdpClient3 * This, + /* [in] */ BSTR pDomain); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Domain )( + IMsRdpClient3 * This, + /* [retval][out] */ BSTR *pDomain); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_UserName )( + IMsRdpClient3 * This, + /* [in] */ BSTR pUserName); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_UserName )( + IMsRdpClient3 * This, + /* [retval][out] */ BSTR *pUserName); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DisconnectedText )( + IMsRdpClient3 * This, + /* [in] */ BSTR pDisconnectedText); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DisconnectedText )( + IMsRdpClient3 * This, + /* [retval][out] */ BSTR *pDisconnectedText); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ConnectingText )( + IMsRdpClient3 * This, + /* [in] */ BSTR pConnectingText); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ConnectingText )( + IMsRdpClient3 * This, + /* [retval][out] */ BSTR *pConnectingText); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Connected )( + IMsRdpClient3 * This, + /* [retval][out] */ short *pIsConnected); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DesktopWidth )( + IMsRdpClient3 * This, + /* [in] */ long pVal); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DesktopWidth )( + IMsRdpClient3 * This, + /* [retval][out] */ long *pVal); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DesktopHeight )( + IMsRdpClient3 * This, + /* [in] */ long pVal); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DesktopHeight )( + IMsRdpClient3 * This, + /* [retval][out] */ long *pVal); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_StartConnected )( + IMsRdpClient3 * This, + /* [in] */ long pfStartConnected); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_StartConnected )( + IMsRdpClient3 * This, + /* [retval][out] */ long *pfStartConnected); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HorizontalScrollBarVisible )( + IMsRdpClient3 * This, + /* [retval][out] */ long *pfHScrollVisible); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_VerticalScrollBarVisible )( + IMsRdpClient3 * This, + /* [retval][out] */ long *pfVScrollVisible); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_FullScreenTitle )( + IMsRdpClient3 * This, + /* [in] */ BSTR rhs); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_CipherStrength )( + IMsRdpClient3 * This, + /* [retval][out] */ long *pCipherStrength); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Version )( + IMsRdpClient3 * This, + /* [retval][out] */ BSTR *pVersion); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SecuredSettingsEnabled )( + IMsRdpClient3 * This, + /* [retval][out] */ long *pSecuredSettingsEnabled); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SecuredSettings )( + IMsRdpClient3 * This, + /* [retval][out] */ IMsTscSecuredSettings **ppSecuredSettings); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AdvancedSettings )( + IMsRdpClient3 * This, + /* [retval][out] */ IMsTscAdvancedSettings **ppAdvSettings); + + /* [hidden][propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Debugger )( + IMsRdpClient3 * This, + /* [retval][out] */ IMsTscDebug **ppDebugger); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *Connect )( + IMsRdpClient3 * This); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *Disconnect )( + IMsRdpClient3 * This); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *CreateVirtualChannels )( + IMsRdpClient3 * This, + /* [in] */ BSTR newVal); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *SendOnVirtualChannel )( + IMsRdpClient3 * This, + /* [in] */ BSTR chanName, + /* [in] */ BSTR ChanData); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ColorDepth )( + IMsRdpClient3 * This, + /* [in] */ long pcolorDepth); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ColorDepth )( + IMsRdpClient3 * This, + /* [retval][out] */ long *pcolorDepth); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AdvancedSettings2 )( + IMsRdpClient3 * This, + /* [retval][out] */ IMsRdpClientAdvancedSettings **ppAdvSettings); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SecuredSettings2 )( + IMsRdpClient3 * This, + /* [retval][out] */ IMsRdpClientSecuredSettings **ppSecuredSettings); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ExtendedDisconnectReason )( + IMsRdpClient3 * This, + /* [retval][out] */ ExtendedDisconnectReasonCode *pExtendedDisconnectReason); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_FullScreen )( + IMsRdpClient3 * This, + /* [in] */ VARIANT_BOOL pfFullScreen); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_FullScreen )( + IMsRdpClient3 * This, + /* [retval][out] */ VARIANT_BOOL *pfFullScreen); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *SetVirtualChannelOptions )( + IMsRdpClient3 * This, + /* [in] */ BSTR chanName, + /* [in] */ long chanOptions); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *GetVirtualChannelOptions )( + IMsRdpClient3 * This, + /* [in] */ BSTR chanName, + /* [retval][out] */ long *pChanOptions); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *RequestClose )( + IMsRdpClient3 * This, + /* [retval][out] */ ControlCloseStatus *pCloseStatus); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AdvancedSettings3 )( + IMsRdpClient3 * This, + /* [retval][out] */ IMsRdpClientAdvancedSettings2 **ppAdvSettings); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ConnectedStatusText )( + IMsRdpClient3 * This, + /* [in] */ BSTR pConnectedStatusText); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ConnectedStatusText )( + IMsRdpClient3 * This, + /* [retval][out] */ BSTR *pConnectedStatusText); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AdvancedSettings4 )( + IMsRdpClient3 * This, + /* [retval][out] */ IMsRdpClientAdvancedSettings3 **ppAdvSettings); + + END_INTERFACE + } IMsRdpClient3Vtbl; + + interface IMsRdpClient3 + { + CONST_VTBL struct IMsRdpClient3Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMsRdpClient3_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMsRdpClient3_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMsRdpClient3_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMsRdpClient3_GetTypeInfoCount(This,pctinfo) \ + ( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) ) + +#define IMsRdpClient3_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + ( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) ) + +#define IMsRdpClient3_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + ( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ) + +#define IMsRdpClient3_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + ( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ) + + +#define IMsRdpClient3_put_Server(This,pServer) \ + ( (This)->lpVtbl -> put_Server(This,pServer) ) + +#define IMsRdpClient3_get_Server(This,pServer) \ + ( (This)->lpVtbl -> get_Server(This,pServer) ) + +#define IMsRdpClient3_put_Domain(This,pDomain) \ + ( (This)->lpVtbl -> put_Domain(This,pDomain) ) + +#define IMsRdpClient3_get_Domain(This,pDomain) \ + ( (This)->lpVtbl -> get_Domain(This,pDomain) ) + +#define IMsRdpClient3_put_UserName(This,pUserName) \ + ( (This)->lpVtbl -> put_UserName(This,pUserName) ) + +#define IMsRdpClient3_get_UserName(This,pUserName) \ + ( (This)->lpVtbl -> get_UserName(This,pUserName) ) + +#define IMsRdpClient3_put_DisconnectedText(This,pDisconnectedText) \ + ( (This)->lpVtbl -> put_DisconnectedText(This,pDisconnectedText) ) + +#define IMsRdpClient3_get_DisconnectedText(This,pDisconnectedText) \ + ( (This)->lpVtbl -> get_DisconnectedText(This,pDisconnectedText) ) + +#define IMsRdpClient3_put_ConnectingText(This,pConnectingText) \ + ( (This)->lpVtbl -> put_ConnectingText(This,pConnectingText) ) + +#define IMsRdpClient3_get_ConnectingText(This,pConnectingText) \ + ( (This)->lpVtbl -> get_ConnectingText(This,pConnectingText) ) + +#define IMsRdpClient3_get_Connected(This,pIsConnected) \ + ( (This)->lpVtbl -> get_Connected(This,pIsConnected) ) + +#define IMsRdpClient3_put_DesktopWidth(This,pVal) \ + ( (This)->lpVtbl -> put_DesktopWidth(This,pVal) ) + +#define IMsRdpClient3_get_DesktopWidth(This,pVal) \ + ( (This)->lpVtbl -> get_DesktopWidth(This,pVal) ) + +#define IMsRdpClient3_put_DesktopHeight(This,pVal) \ + ( (This)->lpVtbl -> put_DesktopHeight(This,pVal) ) + +#define IMsRdpClient3_get_DesktopHeight(This,pVal) \ + ( (This)->lpVtbl -> get_DesktopHeight(This,pVal) ) + +#define IMsRdpClient3_put_StartConnected(This,pfStartConnected) \ + ( (This)->lpVtbl -> put_StartConnected(This,pfStartConnected) ) + +#define IMsRdpClient3_get_StartConnected(This,pfStartConnected) \ + ( (This)->lpVtbl -> get_StartConnected(This,pfStartConnected) ) + +#define IMsRdpClient3_get_HorizontalScrollBarVisible(This,pfHScrollVisible) \ + ( (This)->lpVtbl -> get_HorizontalScrollBarVisible(This,pfHScrollVisible) ) + +#define IMsRdpClient3_get_VerticalScrollBarVisible(This,pfVScrollVisible) \ + ( (This)->lpVtbl -> get_VerticalScrollBarVisible(This,pfVScrollVisible) ) + +#define IMsRdpClient3_put_FullScreenTitle(This,rhs) \ + ( (This)->lpVtbl -> put_FullScreenTitle(This,rhs) ) + +#define IMsRdpClient3_get_CipherStrength(This,pCipherStrength) \ + ( (This)->lpVtbl -> get_CipherStrength(This,pCipherStrength) ) + +#define IMsRdpClient3_get_Version(This,pVersion) \ + ( (This)->lpVtbl -> get_Version(This,pVersion) ) + +#define IMsRdpClient3_get_SecuredSettingsEnabled(This,pSecuredSettingsEnabled) \ + ( (This)->lpVtbl -> get_SecuredSettingsEnabled(This,pSecuredSettingsEnabled) ) + +#define IMsRdpClient3_get_SecuredSettings(This,ppSecuredSettings) \ + ( (This)->lpVtbl -> get_SecuredSettings(This,ppSecuredSettings) ) + +#define IMsRdpClient3_get_AdvancedSettings(This,ppAdvSettings) \ + ( (This)->lpVtbl -> get_AdvancedSettings(This,ppAdvSettings) ) + +#define IMsRdpClient3_get_Debugger(This,ppDebugger) \ + ( (This)->lpVtbl -> get_Debugger(This,ppDebugger) ) + +#define IMsRdpClient3_Connect(This) \ + ( (This)->lpVtbl -> Connect(This) ) + +#define IMsRdpClient3_Disconnect(This) \ + ( (This)->lpVtbl -> Disconnect(This) ) + +#define IMsRdpClient3_CreateVirtualChannels(This,newVal) \ + ( (This)->lpVtbl -> CreateVirtualChannels(This,newVal) ) + +#define IMsRdpClient3_SendOnVirtualChannel(This,chanName,ChanData) \ + ( (This)->lpVtbl -> SendOnVirtualChannel(This,chanName,ChanData) ) + + +#define IMsRdpClient3_put_ColorDepth(This,pcolorDepth) \ + ( (This)->lpVtbl -> put_ColorDepth(This,pcolorDepth) ) + +#define IMsRdpClient3_get_ColorDepth(This,pcolorDepth) \ + ( (This)->lpVtbl -> get_ColorDepth(This,pcolorDepth) ) + +#define IMsRdpClient3_get_AdvancedSettings2(This,ppAdvSettings) \ + ( (This)->lpVtbl -> get_AdvancedSettings2(This,ppAdvSettings) ) + +#define IMsRdpClient3_get_SecuredSettings2(This,ppSecuredSettings) \ + ( (This)->lpVtbl -> get_SecuredSettings2(This,ppSecuredSettings) ) + +#define IMsRdpClient3_get_ExtendedDisconnectReason(This,pExtendedDisconnectReason) \ + ( (This)->lpVtbl -> get_ExtendedDisconnectReason(This,pExtendedDisconnectReason) ) + +#define IMsRdpClient3_put_FullScreen(This,pfFullScreen) \ + ( (This)->lpVtbl -> put_FullScreen(This,pfFullScreen) ) + +#define IMsRdpClient3_get_FullScreen(This,pfFullScreen) \ + ( (This)->lpVtbl -> get_FullScreen(This,pfFullScreen) ) + +#define IMsRdpClient3_SetVirtualChannelOptions(This,chanName,chanOptions) \ + ( (This)->lpVtbl -> SetVirtualChannelOptions(This,chanName,chanOptions) ) + +#define IMsRdpClient3_GetVirtualChannelOptions(This,chanName,pChanOptions) \ + ( (This)->lpVtbl -> GetVirtualChannelOptions(This,chanName,pChanOptions) ) + +#define IMsRdpClient3_RequestClose(This,pCloseStatus) \ + ( (This)->lpVtbl -> RequestClose(This,pCloseStatus) ) + + +#define IMsRdpClient3_get_AdvancedSettings3(This,ppAdvSettings) \ + ( (This)->lpVtbl -> get_AdvancedSettings3(This,ppAdvSettings) ) + +#define IMsRdpClient3_put_ConnectedStatusText(This,pConnectedStatusText) \ + ( (This)->lpVtbl -> put_ConnectedStatusText(This,pConnectedStatusText) ) + +#define IMsRdpClient3_get_ConnectedStatusText(This,pConnectedStatusText) \ + ( (This)->lpVtbl -> get_ConnectedStatusText(This,pConnectedStatusText) ) + + +#define IMsRdpClient3_get_AdvancedSettings4(This,ppAdvSettings) \ + ( (This)->lpVtbl -> get_AdvancedSettings4(This,ppAdvSettings) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMsRdpClient3_INTERFACE_DEFINED__ */ + + +#ifndef __IMsRdpClient4_INTERFACE_DEFINED__ +#define __IMsRdpClient4_INTERFACE_DEFINED__ + +/* interface IMsRdpClient4 */ +/* [object][oleautomation][dual][uuid] */ + + +EXTERN_C const IID IID_IMsRdpClient4; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("095E0738-D97D-488B-B9F6-DD0E8D66C0DE") + IMsRdpClient4 : public IMsRdpClient3 + { + public: + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_AdvancedSettings5( + /* [retval][out] */ IMsRdpClientAdvancedSettings4 **ppAdvSettings5) = 0; + + }; + +#else /* C style interface */ + + typedef struct IMsRdpClient4Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMsRdpClient4 * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ + __RPC__deref_out void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMsRdpClient4 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMsRdpClient4 * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + IMsRdpClient4 * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + IMsRdpClient4 * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + IMsRdpClient4 * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [range][in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + IMsRdpClient4 * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Server )( + IMsRdpClient4 * This, + /* [in] */ BSTR pServer); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Server )( + IMsRdpClient4 * This, + /* [retval][out] */ BSTR *pServer); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Domain )( + IMsRdpClient4 * This, + /* [in] */ BSTR pDomain); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Domain )( + IMsRdpClient4 * This, + /* [retval][out] */ BSTR *pDomain); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_UserName )( + IMsRdpClient4 * This, + /* [in] */ BSTR pUserName); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_UserName )( + IMsRdpClient4 * This, + /* [retval][out] */ BSTR *pUserName); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DisconnectedText )( + IMsRdpClient4 * This, + /* [in] */ BSTR pDisconnectedText); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DisconnectedText )( + IMsRdpClient4 * This, + /* [retval][out] */ BSTR *pDisconnectedText); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ConnectingText )( + IMsRdpClient4 * This, + /* [in] */ BSTR pConnectingText); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ConnectingText )( + IMsRdpClient4 * This, + /* [retval][out] */ BSTR *pConnectingText); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Connected )( + IMsRdpClient4 * This, + /* [retval][out] */ short *pIsConnected); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DesktopWidth )( + IMsRdpClient4 * This, + /* [in] */ long pVal); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DesktopWidth )( + IMsRdpClient4 * This, + /* [retval][out] */ long *pVal); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DesktopHeight )( + IMsRdpClient4 * This, + /* [in] */ long pVal); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DesktopHeight )( + IMsRdpClient4 * This, + /* [retval][out] */ long *pVal); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_StartConnected )( + IMsRdpClient4 * This, + /* [in] */ long pfStartConnected); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_StartConnected )( + IMsRdpClient4 * This, + /* [retval][out] */ long *pfStartConnected); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HorizontalScrollBarVisible )( + IMsRdpClient4 * This, + /* [retval][out] */ long *pfHScrollVisible); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_VerticalScrollBarVisible )( + IMsRdpClient4 * This, + /* [retval][out] */ long *pfVScrollVisible); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_FullScreenTitle )( + IMsRdpClient4 * This, + /* [in] */ BSTR rhs); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_CipherStrength )( + IMsRdpClient4 * This, + /* [retval][out] */ long *pCipherStrength); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Version )( + IMsRdpClient4 * This, + /* [retval][out] */ BSTR *pVersion); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SecuredSettingsEnabled )( + IMsRdpClient4 * This, + /* [retval][out] */ long *pSecuredSettingsEnabled); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SecuredSettings )( + IMsRdpClient4 * This, + /* [retval][out] */ IMsTscSecuredSettings **ppSecuredSettings); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AdvancedSettings )( + IMsRdpClient4 * This, + /* [retval][out] */ IMsTscAdvancedSettings **ppAdvSettings); + + /* [hidden][propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Debugger )( + IMsRdpClient4 * This, + /* [retval][out] */ IMsTscDebug **ppDebugger); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *Connect )( + IMsRdpClient4 * This); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *Disconnect )( + IMsRdpClient4 * This); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *CreateVirtualChannels )( + IMsRdpClient4 * This, + /* [in] */ BSTR newVal); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *SendOnVirtualChannel )( + IMsRdpClient4 * This, + /* [in] */ BSTR chanName, + /* [in] */ BSTR ChanData); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ColorDepth )( + IMsRdpClient4 * This, + /* [in] */ long pcolorDepth); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ColorDepth )( + IMsRdpClient4 * This, + /* [retval][out] */ long *pcolorDepth); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AdvancedSettings2 )( + IMsRdpClient4 * This, + /* [retval][out] */ IMsRdpClientAdvancedSettings **ppAdvSettings); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SecuredSettings2 )( + IMsRdpClient4 * This, + /* [retval][out] */ IMsRdpClientSecuredSettings **ppSecuredSettings); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ExtendedDisconnectReason )( + IMsRdpClient4 * This, + /* [retval][out] */ ExtendedDisconnectReasonCode *pExtendedDisconnectReason); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_FullScreen )( + IMsRdpClient4 * This, + /* [in] */ VARIANT_BOOL pfFullScreen); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_FullScreen )( + IMsRdpClient4 * This, + /* [retval][out] */ VARIANT_BOOL *pfFullScreen); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *SetVirtualChannelOptions )( + IMsRdpClient4 * This, + /* [in] */ BSTR chanName, + /* [in] */ long chanOptions); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *GetVirtualChannelOptions )( + IMsRdpClient4 * This, + /* [in] */ BSTR chanName, + /* [retval][out] */ long *pChanOptions); + + /* [id] */ HRESULT ( STDMETHODCALLTYPE *RequestClose )( + IMsRdpClient4 * This, + /* [retval][out] */ ControlCloseStatus *pCloseStatus); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AdvancedSettings3 )( + IMsRdpClient4 * This, + /* [retval][out] */ IMsRdpClientAdvancedSettings2 **ppAdvSettings); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ConnectedStatusText )( + IMsRdpClient4 * This, + /* [in] */ BSTR pConnectedStatusText); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ConnectedStatusText )( + IMsRdpClient4 * This, + /* [retval][out] */ BSTR *pConnectedStatusText); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AdvancedSettings4 )( + IMsRdpClient4 * This, + /* [retval][out] */ IMsRdpClientAdvancedSettings3 **ppAdvSettings); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AdvancedSettings5 )( + IMsRdpClient4 * This, + /* [retval][out] */ IMsRdpClientAdvancedSettings4 **ppAdvSettings5); + + END_INTERFACE + } IMsRdpClient4Vtbl; + + interface IMsRdpClient4 + { + CONST_VTBL struct IMsRdpClient4Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMsRdpClient4_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMsRdpClient4_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMsRdpClient4_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMsRdpClient4_GetTypeInfoCount(This,pctinfo) \ + ( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) ) + +#define IMsRdpClient4_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + ( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) ) + +#define IMsRdpClient4_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + ( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ) + +#define IMsRdpClient4_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + ( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ) + + +#define IMsRdpClient4_put_Server(This,pServer) \ + ( (This)->lpVtbl -> put_Server(This,pServer) ) + +#define IMsRdpClient4_get_Server(This,pServer) \ + ( (This)->lpVtbl -> get_Server(This,pServer) ) + +#define IMsRdpClient4_put_Domain(This,pDomain) \ + ( (This)->lpVtbl -> put_Domain(This,pDomain) ) + +#define IMsRdpClient4_get_Domain(This,pDomain) \ + ( (This)->lpVtbl -> get_Domain(This,pDomain) ) + +#define IMsRdpClient4_put_UserName(This,pUserName) \ + ( (This)->lpVtbl -> put_UserName(This,pUserName) ) + +#define IMsRdpClient4_get_UserName(This,pUserName) \ + ( (This)->lpVtbl -> get_UserName(This,pUserName) ) + +#define IMsRdpClient4_put_DisconnectedText(This,pDisconnectedText) \ + ( (This)->lpVtbl -> put_DisconnectedText(This,pDisconnectedText) ) + +#define IMsRdpClient4_get_DisconnectedText(This,pDisconnectedText) \ + ( (This)->lpVtbl -> get_DisconnectedText(This,pDisconnectedText) ) + +#define IMsRdpClient4_put_ConnectingText(This,pConnectingText) \ + ( (This)->lpVtbl -> put_ConnectingText(This,pConnectingText) ) + +#define IMsRdpClient4_get_ConnectingText(This,pConnectingText) \ + ( (This)->lpVtbl -> get_ConnectingText(This,pConnectingText) ) + +#define IMsRdpClient4_get_Connected(This,pIsConnected) \ + ( (This)->lpVtbl -> get_Connected(This,pIsConnected) ) + +#define IMsRdpClient4_put_DesktopWidth(This,pVal) \ + ( (This)->lpVtbl -> put_DesktopWidth(This,pVal) ) + +#define IMsRdpClient4_get_DesktopWidth(This,pVal) \ + ( (This)->lpVtbl -> get_DesktopWidth(This,pVal) ) + +#define IMsRdpClient4_put_DesktopHeight(This,pVal) \ + ( (This)->lpVtbl -> put_DesktopHeight(This,pVal) ) + +#define IMsRdpClient4_get_DesktopHeight(This,pVal) \ + ( (This)->lpVtbl -> get_DesktopHeight(This,pVal) ) + +#define IMsRdpClient4_put_StartConnected(This,pfStartConnected) \ + ( (This)->lpVtbl -> put_StartConnected(This,pfStartConnected) ) + +#define IMsRdpClient4_get_StartConnected(This,pfStartConnected) \ + ( (This)->lpVtbl -> get_StartConnected(This,pfStartConnected) ) + +#define IMsRdpClient4_get_HorizontalScrollBarVisible(This,pfHScrollVisible) \ + ( (This)->lpVtbl -> get_HorizontalScrollBarVisible(This,pfHScrollVisible) ) + +#define IMsRdpClient4_get_VerticalScrollBarVisible(This,pfVScrollVisible) \ + ( (This)->lpVtbl -> get_VerticalScrollBarVisible(This,pfVScrollVisible) ) + +#define IMsRdpClient4_put_FullScreenTitle(This,rhs) \ + ( (This)->lpVtbl -> put_FullScreenTitle(This,rhs) ) + +#define IMsRdpClient4_get_CipherStrength(This,pCipherStrength) \ + ( (This)->lpVtbl -> get_CipherStrength(This,pCipherStrength) ) + +#define IMsRdpClient4_get_Version(This,pVersion) \ + ( (This)->lpVtbl -> get_Version(This,pVersion) ) + +#define IMsRdpClient4_get_SecuredSettingsEnabled(This,pSecuredSettingsEnabled) \ + ( (This)->lpVtbl -> get_SecuredSettingsEnabled(This,pSecuredSettingsEnabled) ) + +#define IMsRdpClient4_get_SecuredSettings(This,ppSecuredSettings) \ + ( (This)->lpVtbl -> get_SecuredSettings(This,ppSecuredSettings) ) + +#define IMsRdpClient4_get_AdvancedSettings(This,ppAdvSettings) \ + ( (This)->lpVtbl -> get_AdvancedSettings(This,ppAdvSettings) ) + +#define IMsRdpClient4_get_Debugger(This,ppDebugger) \ + ( (This)->lpVtbl -> get_Debugger(This,ppDebugger) ) + +#define IMsRdpClient4_Connect(This) \ + ( (This)->lpVtbl -> Connect(This) ) + +#define IMsRdpClient4_Disconnect(This) \ + ( (This)->lpVtbl -> Disconnect(This) ) + +#define IMsRdpClient4_CreateVirtualChannels(This,newVal) \ + ( (This)->lpVtbl -> CreateVirtualChannels(This,newVal) ) + +#define IMsRdpClient4_SendOnVirtualChannel(This,chanName,ChanData) \ + ( (This)->lpVtbl -> SendOnVirtualChannel(This,chanName,ChanData) ) + + +#define IMsRdpClient4_put_ColorDepth(This,pcolorDepth) \ + ( (This)->lpVtbl -> put_ColorDepth(This,pcolorDepth) ) + +#define IMsRdpClient4_get_ColorDepth(This,pcolorDepth) \ + ( (This)->lpVtbl -> get_ColorDepth(This,pcolorDepth) ) + +#define IMsRdpClient4_get_AdvancedSettings2(This,ppAdvSettings) \ + ( (This)->lpVtbl -> get_AdvancedSettings2(This,ppAdvSettings) ) + +#define IMsRdpClient4_get_SecuredSettings2(This,ppSecuredSettings) \ + ( (This)->lpVtbl -> get_SecuredSettings2(This,ppSecuredSettings) ) + +#define IMsRdpClient4_get_ExtendedDisconnectReason(This,pExtendedDisconnectReason) \ + ( (This)->lpVtbl -> get_ExtendedDisconnectReason(This,pExtendedDisconnectReason) ) + +#define IMsRdpClient4_put_FullScreen(This,pfFullScreen) \ + ( (This)->lpVtbl -> put_FullScreen(This,pfFullScreen) ) + +#define IMsRdpClient4_get_FullScreen(This,pfFullScreen) \ + ( (This)->lpVtbl -> get_FullScreen(This,pfFullScreen) ) + +#define IMsRdpClient4_SetVirtualChannelOptions(This,chanName,chanOptions) \ + ( (This)->lpVtbl -> SetVirtualChannelOptions(This,chanName,chanOptions) ) + +#define IMsRdpClient4_GetVirtualChannelOptions(This,chanName,pChanOptions) \ + ( (This)->lpVtbl -> GetVirtualChannelOptions(This,chanName,pChanOptions) ) + +#define IMsRdpClient4_RequestClose(This,pCloseStatus) \ + ( (This)->lpVtbl -> RequestClose(This,pCloseStatus) ) + + +#define IMsRdpClient4_get_AdvancedSettings3(This,ppAdvSettings) \ + ( (This)->lpVtbl -> get_AdvancedSettings3(This,ppAdvSettings) ) + +#define IMsRdpClient4_put_ConnectedStatusText(This,pConnectedStatusText) \ + ( (This)->lpVtbl -> put_ConnectedStatusText(This,pConnectedStatusText) ) + +#define IMsRdpClient4_get_ConnectedStatusText(This,pConnectedStatusText) \ + ( (This)->lpVtbl -> get_ConnectedStatusText(This,pConnectedStatusText) ) + + +#define IMsRdpClient4_get_AdvancedSettings4(This,ppAdvSettings) \ + ( (This)->lpVtbl -> get_AdvancedSettings4(This,ppAdvSettings) ) + + +#define IMsRdpClient4_get_AdvancedSettings5(This,ppAdvSettings5) \ + ( (This)->lpVtbl -> get_AdvancedSettings5(This,ppAdvSettings5) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMsRdpClient4_INTERFACE_DEFINED__ */ + + +#ifndef __IMsTscNonScriptable_INTERFACE_DEFINED__ +#define __IMsTscNonScriptable_INTERFACE_DEFINED__ + +/* interface IMsTscNonScriptable */ +/* [object][uuid] */ + + +EXTERN_C const IID IID_IMsTscNonScriptable; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C1E6743A-41C1-4A74-832A-0DD06C1C7A0E") + IMsTscNonScriptable : public IUnknown + { + public: + virtual /* [propput] */ HRESULT __stdcall put_ClearTextPassword( + /* [in] */ BSTR rhs) = 0; + + virtual /* [propput] */ HRESULT __stdcall put_PortablePassword( + /* [in] */ BSTR pPortablePass) = 0; + + virtual /* [propget] */ HRESULT __stdcall get_PortablePassword( + /* [retval][out] */ BSTR *pPortablePass) = 0; + + virtual /* [propput] */ HRESULT __stdcall put_PortableSalt( + /* [in] */ BSTR pPortableSalt) = 0; + + virtual /* [propget] */ HRESULT __stdcall get_PortableSalt( + /* [retval][out] */ BSTR *pPortableSalt) = 0; + + virtual /* [propput] */ HRESULT __stdcall put_BinaryPassword( + /* [in] */ BSTR pBinaryPassword) = 0; + + virtual /* [propget] */ HRESULT __stdcall get_BinaryPassword( + /* [retval][out] */ BSTR *pBinaryPassword) = 0; + + virtual /* [propput] */ HRESULT __stdcall put_BinarySalt( + /* [in] */ BSTR pSalt) = 0; + + virtual /* [propget] */ HRESULT __stdcall get_BinarySalt( + /* [retval][out] */ BSTR *pSalt) = 0; + + virtual HRESULT __stdcall ResetPassword( void) = 0; + + }; + +#else /* C style interface */ + + typedef struct IMsTscNonScriptableVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMsTscNonScriptable * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ + __RPC__deref_out void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMsTscNonScriptable * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMsTscNonScriptable * This); + + /* [propput] */ HRESULT ( __stdcall *put_ClearTextPassword )( + IMsTscNonScriptable * This, + /* [in] */ BSTR rhs); + + /* [propput] */ HRESULT ( __stdcall *put_PortablePassword )( + IMsTscNonScriptable * This, + /* [in] */ BSTR pPortablePass); + + /* [propget] */ HRESULT ( __stdcall *get_PortablePassword )( + IMsTscNonScriptable * This, + /* [retval][out] */ BSTR *pPortablePass); + + /* [propput] */ HRESULT ( __stdcall *put_PortableSalt )( + IMsTscNonScriptable * This, + /* [in] */ BSTR pPortableSalt); + + /* [propget] */ HRESULT ( __stdcall *get_PortableSalt )( + IMsTscNonScriptable * This, + /* [retval][out] */ BSTR *pPortableSalt); + + /* [propput] */ HRESULT ( __stdcall *put_BinaryPassword )( + IMsTscNonScriptable * This, + /* [in] */ BSTR pBinaryPassword); + + /* [propget] */ HRESULT ( __stdcall *get_BinaryPassword )( + IMsTscNonScriptable * This, + /* [retval][out] */ BSTR *pBinaryPassword); + + /* [propput] */ HRESULT ( __stdcall *put_BinarySalt )( + IMsTscNonScriptable * This, + /* [in] */ BSTR pSalt); + + /* [propget] */ HRESULT ( __stdcall *get_BinarySalt )( + IMsTscNonScriptable * This, + /* [retval][out] */ BSTR *pSalt); + + HRESULT ( __stdcall *ResetPassword )( + IMsTscNonScriptable * This); + + END_INTERFACE + } IMsTscNonScriptableVtbl; + + interface IMsTscNonScriptable + { + CONST_VTBL struct IMsTscNonScriptableVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMsTscNonScriptable_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMsTscNonScriptable_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMsTscNonScriptable_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMsTscNonScriptable_put_ClearTextPassword(This,rhs) \ + ( (This)->lpVtbl -> put_ClearTextPassword(This,rhs) ) + +#define IMsTscNonScriptable_put_PortablePassword(This,pPortablePass) \ + ( (This)->lpVtbl -> put_PortablePassword(This,pPortablePass) ) + +#define IMsTscNonScriptable_get_PortablePassword(This,pPortablePass) \ + ( (This)->lpVtbl -> get_PortablePassword(This,pPortablePass) ) + +#define IMsTscNonScriptable_put_PortableSalt(This,pPortableSalt) \ + ( (This)->lpVtbl -> put_PortableSalt(This,pPortableSalt) ) + +#define IMsTscNonScriptable_get_PortableSalt(This,pPortableSalt) \ + ( (This)->lpVtbl -> get_PortableSalt(This,pPortableSalt) ) + +#define IMsTscNonScriptable_put_BinaryPassword(This,pBinaryPassword) \ + ( (This)->lpVtbl -> put_BinaryPassword(This,pBinaryPassword) ) + +#define IMsTscNonScriptable_get_BinaryPassword(This,pBinaryPassword) \ + ( (This)->lpVtbl -> get_BinaryPassword(This,pBinaryPassword) ) + +#define IMsTscNonScriptable_put_BinarySalt(This,pSalt) \ + ( (This)->lpVtbl -> put_BinarySalt(This,pSalt) ) + +#define IMsTscNonScriptable_get_BinarySalt(This,pSalt) \ + ( (This)->lpVtbl -> get_BinarySalt(This,pSalt) ) + +#define IMsTscNonScriptable_ResetPassword(This) \ + ( (This)->lpVtbl -> ResetPassword(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMsTscNonScriptable_INTERFACE_DEFINED__ */ + + +#ifndef __IMsRdpClientNonScriptable_INTERFACE_DEFINED__ +#define __IMsRdpClientNonScriptable_INTERFACE_DEFINED__ + +/* interface IMsRdpClientNonScriptable */ +/* [object][uuid] */ + + +EXTERN_C const IID IID_IMsRdpClientNonScriptable; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2F079C4C-87B2-4AFD-97AB-20CDB43038AE") + IMsRdpClientNonScriptable : public IMsTscNonScriptable + { + public: + virtual HRESULT __stdcall NotifyRedirectDeviceChange( + /* [in] */ UINT_PTR wParam, + /* [in] */ LONG_PTR lParam) = 0; + + virtual HRESULT __stdcall SendKeys( + /* [in] */ long numKeys, + /* [in] */ VARIANT_BOOL *pbArrayKeyUp, + /* [in] */ long *plKeyData) = 0; + + }; + +#else /* C style interface */ + + typedef struct IMsRdpClientNonScriptableVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMsRdpClientNonScriptable * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ + __RPC__deref_out void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMsRdpClientNonScriptable * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMsRdpClientNonScriptable * This); + + /* [propput] */ HRESULT ( __stdcall *put_ClearTextPassword )( + IMsRdpClientNonScriptable * This, + /* [in] */ BSTR rhs); + + /* [propput] */ HRESULT ( __stdcall *put_PortablePassword )( + IMsRdpClientNonScriptable * This, + /* [in] */ BSTR pPortablePass); + + /* [propget] */ HRESULT ( __stdcall *get_PortablePassword )( + IMsRdpClientNonScriptable * This, + /* [retval][out] */ BSTR *pPortablePass); + + /* [propput] */ HRESULT ( __stdcall *put_PortableSalt )( + IMsRdpClientNonScriptable * This, + /* [in] */ BSTR pPortableSalt); + + /* [propget] */ HRESULT ( __stdcall *get_PortableSalt )( + IMsRdpClientNonScriptable * This, + /* [retval][out] */ BSTR *pPortableSalt); + + /* [propput] */ HRESULT ( __stdcall *put_BinaryPassword )( + IMsRdpClientNonScriptable * This, + /* [in] */ BSTR pBinaryPassword); + + /* [propget] */ HRESULT ( __stdcall *get_BinaryPassword )( + IMsRdpClientNonScriptable * This, + /* [retval][out] */ BSTR *pBinaryPassword); + + /* [propput] */ HRESULT ( __stdcall *put_BinarySalt )( + IMsRdpClientNonScriptable * This, + /* [in] */ BSTR pSalt); + + /* [propget] */ HRESULT ( __stdcall *get_BinarySalt )( + IMsRdpClientNonScriptable * This, + /* [retval][out] */ BSTR *pSalt); + + HRESULT ( __stdcall *ResetPassword )( + IMsRdpClientNonScriptable * This); + + HRESULT ( __stdcall *NotifyRedirectDeviceChange )( + IMsRdpClientNonScriptable * This, + /* [in] */ UINT_PTR wParam, + /* [in] */ LONG_PTR lParam); + + HRESULT ( __stdcall *SendKeys )( + IMsRdpClientNonScriptable * This, + /* [in] */ long numKeys, + /* [in] */ VARIANT_BOOL *pbArrayKeyUp, + /* [in] */ long *plKeyData); + + END_INTERFACE + } IMsRdpClientNonScriptableVtbl; + + interface IMsRdpClientNonScriptable + { + CONST_VTBL struct IMsRdpClientNonScriptableVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMsRdpClientNonScriptable_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMsRdpClientNonScriptable_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMsRdpClientNonScriptable_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMsRdpClientNonScriptable_put_ClearTextPassword(This,rhs) \ + ( (This)->lpVtbl -> put_ClearTextPassword(This,rhs) ) + +#define IMsRdpClientNonScriptable_put_PortablePassword(This,pPortablePass) \ + ( (This)->lpVtbl -> put_PortablePassword(This,pPortablePass) ) + +#define IMsRdpClientNonScriptable_get_PortablePassword(This,pPortablePass) \ + ( (This)->lpVtbl -> get_PortablePassword(This,pPortablePass) ) + +#define IMsRdpClientNonScriptable_put_PortableSalt(This,pPortableSalt) \ + ( (This)->lpVtbl -> put_PortableSalt(This,pPortableSalt) ) + +#define IMsRdpClientNonScriptable_get_PortableSalt(This,pPortableSalt) \ + ( (This)->lpVtbl -> get_PortableSalt(This,pPortableSalt) ) + +#define IMsRdpClientNonScriptable_put_BinaryPassword(This,pBinaryPassword) \ + ( (This)->lpVtbl -> put_BinaryPassword(This,pBinaryPassword) ) + +#define IMsRdpClientNonScriptable_get_BinaryPassword(This,pBinaryPassword) \ + ( (This)->lpVtbl -> get_BinaryPassword(This,pBinaryPassword) ) + +#define IMsRdpClientNonScriptable_put_BinarySalt(This,pSalt) \ + ( (This)->lpVtbl -> put_BinarySalt(This,pSalt) ) + +#define IMsRdpClientNonScriptable_get_BinarySalt(This,pSalt) \ + ( (This)->lpVtbl -> get_BinarySalt(This,pSalt) ) + +#define IMsRdpClientNonScriptable_ResetPassword(This) \ + ( (This)->lpVtbl -> ResetPassword(This) ) + + +#define IMsRdpClientNonScriptable_NotifyRedirectDeviceChange(This,wParam,lParam) \ + ( (This)->lpVtbl -> NotifyRedirectDeviceChange(This,wParam,lParam) ) + +#define IMsRdpClientNonScriptable_SendKeys(This,numKeys,pbArrayKeyUp,plKeyData) \ + ( (This)->lpVtbl -> SendKeys(This,numKeys,pbArrayKeyUp,plKeyData) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMsRdpClientNonScriptable_INTERFACE_DEFINED__ */ + + +#ifndef __IMsRdpClientNonScriptable2_INTERFACE_DEFINED__ +#define __IMsRdpClientNonScriptable2_INTERFACE_DEFINED__ + +/* interface IMsRdpClientNonScriptable2 */ +/* [object][uuid] */ + + +EXTERN_C const IID IID_IMsRdpClientNonScriptable2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("17A5E535-4072-4FA4-AF32-C8D0D47345E9") + IMsRdpClientNonScriptable2 : public IMsRdpClientNonScriptable + { + public: + virtual /* [propput] */ HRESULT __stdcall put_UIParentWindowHandle( + /* [in] */ HWND phwndUIParentWindowHandle) = 0; + + virtual /* [propget] */ HRESULT __stdcall get_UIParentWindowHandle( + /* [retval][out] */ HWND *phwndUIParentWindowHandle) = 0; + + }; + +#else /* C style interface */ + + typedef struct IMsRdpClientNonScriptable2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMsRdpClientNonScriptable2 * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ + __RPC__deref_out void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMsRdpClientNonScriptable2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMsRdpClientNonScriptable2 * This); + + /* [propput] */ HRESULT ( __stdcall *put_ClearTextPassword )( + IMsRdpClientNonScriptable2 * This, + /* [in] */ BSTR rhs); + + /* [propput] */ HRESULT ( __stdcall *put_PortablePassword )( + IMsRdpClientNonScriptable2 * This, + /* [in] */ BSTR pPortablePass); + + /* [propget] */ HRESULT ( __stdcall *get_PortablePassword )( + IMsRdpClientNonScriptable2 * This, + /* [retval][out] */ BSTR *pPortablePass); + + /* [propput] */ HRESULT ( __stdcall *put_PortableSalt )( + IMsRdpClientNonScriptable2 * This, + /* [in] */ BSTR pPortableSalt); + + /* [propget] */ HRESULT ( __stdcall *get_PortableSalt )( + IMsRdpClientNonScriptable2 * This, + /* [retval][out] */ BSTR *pPortableSalt); + + /* [propput] */ HRESULT ( __stdcall *put_BinaryPassword )( + IMsRdpClientNonScriptable2 * This, + /* [in] */ BSTR pBinaryPassword); + + /* [propget] */ HRESULT ( __stdcall *get_BinaryPassword )( + IMsRdpClientNonScriptable2 * This, + /* [retval][out] */ BSTR *pBinaryPassword); + + /* [propput] */ HRESULT ( __stdcall *put_BinarySalt )( + IMsRdpClientNonScriptable2 * This, + /* [in] */ BSTR pSalt); + + /* [propget] */ HRESULT ( __stdcall *get_BinarySalt )( + IMsRdpClientNonScriptable2 * This, + /* [retval][out] */ BSTR *pSalt); + + HRESULT ( __stdcall *ResetPassword )( + IMsRdpClientNonScriptable2 * This); + + HRESULT ( __stdcall *NotifyRedirectDeviceChange )( + IMsRdpClientNonScriptable2 * This, + /* [in] */ UINT_PTR wParam, + /* [in] */ LONG_PTR lParam); + + HRESULT ( __stdcall *SendKeys )( + IMsRdpClientNonScriptable2 * This, + /* [in] */ long numKeys, + /* [in] */ VARIANT_BOOL *pbArrayKeyUp, + /* [in] */ long *plKeyData); + + /* [propput] */ HRESULT ( __stdcall *put_UIParentWindowHandle )( + IMsRdpClientNonScriptable2 * This, + /* [in] */ HWND phwndUIParentWindowHandle); + + /* [propget] */ HRESULT ( __stdcall *get_UIParentWindowHandle )( + IMsRdpClientNonScriptable2 * This, + /* [retval][out] */ HWND *phwndUIParentWindowHandle); + + END_INTERFACE + } IMsRdpClientNonScriptable2Vtbl; + + interface IMsRdpClientNonScriptable2 + { + CONST_VTBL struct IMsRdpClientNonScriptable2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMsRdpClientNonScriptable2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMsRdpClientNonScriptable2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMsRdpClientNonScriptable2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMsRdpClientNonScriptable2_put_ClearTextPassword(This,rhs) \ + ( (This)->lpVtbl -> put_ClearTextPassword(This,rhs) ) + +#define IMsRdpClientNonScriptable2_put_PortablePassword(This,pPortablePass) \ + ( (This)->lpVtbl -> put_PortablePassword(This,pPortablePass) ) + +#define IMsRdpClientNonScriptable2_get_PortablePassword(This,pPortablePass) \ + ( (This)->lpVtbl -> get_PortablePassword(This,pPortablePass) ) + +#define IMsRdpClientNonScriptable2_put_PortableSalt(This,pPortableSalt) \ + ( (This)->lpVtbl -> put_PortableSalt(This,pPortableSalt) ) + +#define IMsRdpClientNonScriptable2_get_PortableSalt(This,pPortableSalt) \ + ( (This)->lpVtbl -> get_PortableSalt(This,pPortableSalt) ) + +#define IMsRdpClientNonScriptable2_put_BinaryPassword(This,pBinaryPassword) \ + ( (This)->lpVtbl -> put_BinaryPassword(This,pBinaryPassword) ) + +#define IMsRdpClientNonScriptable2_get_BinaryPassword(This,pBinaryPassword) \ + ( (This)->lpVtbl -> get_BinaryPassword(This,pBinaryPassword) ) + +#define IMsRdpClientNonScriptable2_put_BinarySalt(This,pSalt) \ + ( (This)->lpVtbl -> put_BinarySalt(This,pSalt) ) + +#define IMsRdpClientNonScriptable2_get_BinarySalt(This,pSalt) \ + ( (This)->lpVtbl -> get_BinarySalt(This,pSalt) ) + +#define IMsRdpClientNonScriptable2_ResetPassword(This) \ + ( (This)->lpVtbl -> ResetPassword(This) ) + + +#define IMsRdpClientNonScriptable2_NotifyRedirectDeviceChange(This,wParam,lParam) \ + ( (This)->lpVtbl -> NotifyRedirectDeviceChange(This,wParam,lParam) ) + +#define IMsRdpClientNonScriptable2_SendKeys(This,numKeys,pbArrayKeyUp,plKeyData) \ + ( (This)->lpVtbl -> SendKeys(This,numKeys,pbArrayKeyUp,plKeyData) ) + + +#define IMsRdpClientNonScriptable2_put_UIParentWindowHandle(This,phwndUIParentWindowHandle) \ + ( (This)->lpVtbl -> put_UIParentWindowHandle(This,phwndUIParentWindowHandle) ) + +#define IMsRdpClientNonScriptable2_get_UIParentWindowHandle(This,phwndUIParentWindowHandle) \ + ( (This)->lpVtbl -> get_UIParentWindowHandle(This,phwndUIParentWindowHandle) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMsRdpClientNonScriptable2_INTERFACE_DEFINED__ */ + + +#ifndef __IMsTscAdvancedSettings_INTERFACE_DEFINED__ +#define __IMsTscAdvancedSettings_INTERFACE_DEFINED__ + +/* interface IMsTscAdvancedSettings */ +/* [object][oleautomation][dual][uuid] */ + + +EXTERN_C const IID IID_IMsTscAdvancedSettings; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("809945CC-4B3B-4A92-A6B0-DBF9B5F2EF2D") + IMsTscAdvancedSettings : public IDispatch + { + public: + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_Compress( + /* [in] */ long pcompress) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_Compress( + /* [retval][out] */ long *pcompress) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_BitmapPeristence( + /* [in] */ long pbitmapPeristence) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_BitmapPeristence( + /* [retval][out] */ long *pbitmapPeristence) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_allowBackgroundInput( + /* [in] */ long pallowBackgroundInput) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_allowBackgroundInput( + /* [retval][out] */ long *pallowBackgroundInput) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_KeyBoardLayoutStr( + /* [in] */ BSTR rhs) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_PluginDlls( + /* [in] */ BSTR rhs) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_IconFile( + /* [in] */ BSTR rhs) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_IconIndex( + /* [in] */ long rhs) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_ContainerHandledFullScreen( + /* [in] */ long pContainerHandledFullScreen) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_ContainerHandledFullScreen( + /* [retval][out] */ long *pContainerHandledFullScreen) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_DisableRdpdr( + /* [in] */ long pDisableRdpdr) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_DisableRdpdr( + /* [retval][out] */ long *pDisableRdpdr) = 0; + + }; + +#else /* C style interface */ + + typedef struct IMsTscAdvancedSettingsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMsTscAdvancedSettings * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ + __RPC__deref_out void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMsTscAdvancedSettings * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMsTscAdvancedSettings * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + IMsTscAdvancedSettings * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + IMsTscAdvancedSettings * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + IMsTscAdvancedSettings * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [range][in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + IMsTscAdvancedSettings * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Compress )( + IMsTscAdvancedSettings * This, + /* [in] */ long pcompress); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Compress )( + IMsTscAdvancedSettings * This, + /* [retval][out] */ long *pcompress); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapPeristence )( + IMsTscAdvancedSettings * This, + /* [in] */ long pbitmapPeristence); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapPeristence )( + IMsTscAdvancedSettings * This, + /* [retval][out] */ long *pbitmapPeristence); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_allowBackgroundInput )( + IMsTscAdvancedSettings * This, + /* [in] */ long pallowBackgroundInput); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_allowBackgroundInput )( + IMsTscAdvancedSettings * This, + /* [retval][out] */ long *pallowBackgroundInput); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_KeyBoardLayoutStr )( + IMsTscAdvancedSettings * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_PluginDlls )( + IMsTscAdvancedSettings * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_IconFile )( + IMsTscAdvancedSettings * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_IconIndex )( + IMsTscAdvancedSettings * This, + /* [in] */ long rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ContainerHandledFullScreen )( + IMsTscAdvancedSettings * This, + /* [in] */ long pContainerHandledFullScreen); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ContainerHandledFullScreen )( + IMsTscAdvancedSettings * This, + /* [retval][out] */ long *pContainerHandledFullScreen); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DisableRdpdr )( + IMsTscAdvancedSettings * This, + /* [in] */ long pDisableRdpdr); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DisableRdpdr )( + IMsTscAdvancedSettings * This, + /* [retval][out] */ long *pDisableRdpdr); + + END_INTERFACE + } IMsTscAdvancedSettingsVtbl; + + interface IMsTscAdvancedSettings + { + CONST_VTBL struct IMsTscAdvancedSettingsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMsTscAdvancedSettings_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMsTscAdvancedSettings_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMsTscAdvancedSettings_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMsTscAdvancedSettings_GetTypeInfoCount(This,pctinfo) \ + ( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) ) + +#define IMsTscAdvancedSettings_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + ( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) ) + +#define IMsTscAdvancedSettings_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + ( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ) + +#define IMsTscAdvancedSettings_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + ( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ) + + +#define IMsTscAdvancedSettings_put_Compress(This,pcompress) \ + ( (This)->lpVtbl -> put_Compress(This,pcompress) ) + +#define IMsTscAdvancedSettings_get_Compress(This,pcompress) \ + ( (This)->lpVtbl -> get_Compress(This,pcompress) ) + +#define IMsTscAdvancedSettings_put_BitmapPeristence(This,pbitmapPeristence) \ + ( (This)->lpVtbl -> put_BitmapPeristence(This,pbitmapPeristence) ) + +#define IMsTscAdvancedSettings_get_BitmapPeristence(This,pbitmapPeristence) \ + ( (This)->lpVtbl -> get_BitmapPeristence(This,pbitmapPeristence) ) + +#define IMsTscAdvancedSettings_put_allowBackgroundInput(This,pallowBackgroundInput) \ + ( (This)->lpVtbl -> put_allowBackgroundInput(This,pallowBackgroundInput) ) + +#define IMsTscAdvancedSettings_get_allowBackgroundInput(This,pallowBackgroundInput) \ + ( (This)->lpVtbl -> get_allowBackgroundInput(This,pallowBackgroundInput) ) + +#define IMsTscAdvancedSettings_put_KeyBoardLayoutStr(This,rhs) \ + ( (This)->lpVtbl -> put_KeyBoardLayoutStr(This,rhs) ) + +#define IMsTscAdvancedSettings_put_PluginDlls(This,rhs) \ + ( (This)->lpVtbl -> put_PluginDlls(This,rhs) ) + +#define IMsTscAdvancedSettings_put_IconFile(This,rhs) \ + ( (This)->lpVtbl -> put_IconFile(This,rhs) ) + +#define IMsTscAdvancedSettings_put_IconIndex(This,rhs) \ + ( (This)->lpVtbl -> put_IconIndex(This,rhs) ) + +#define IMsTscAdvancedSettings_put_ContainerHandledFullScreen(This,pContainerHandledFullScreen) \ + ( (This)->lpVtbl -> put_ContainerHandledFullScreen(This,pContainerHandledFullScreen) ) + +#define IMsTscAdvancedSettings_get_ContainerHandledFullScreen(This,pContainerHandledFullScreen) \ + ( (This)->lpVtbl -> get_ContainerHandledFullScreen(This,pContainerHandledFullScreen) ) + +#define IMsTscAdvancedSettings_put_DisableRdpdr(This,pDisableRdpdr) \ + ( (This)->lpVtbl -> put_DisableRdpdr(This,pDisableRdpdr) ) + +#define IMsTscAdvancedSettings_get_DisableRdpdr(This,pDisableRdpdr) \ + ( (This)->lpVtbl -> get_DisableRdpdr(This,pDisableRdpdr) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMsTscAdvancedSettings_INTERFACE_DEFINED__ */ + + +#ifndef __IMsRdpClientAdvancedSettings_INTERFACE_DEFINED__ +#define __IMsRdpClientAdvancedSettings_INTERFACE_DEFINED__ + +/* interface IMsRdpClientAdvancedSettings */ +/* [object][oleautomation][dual][uuid] */ + + +EXTERN_C const IID IID_IMsRdpClientAdvancedSettings; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3C65B4AB-12B3-465B-ACD4-B8DAD3BFF9E2") + IMsRdpClientAdvancedSettings : public IMsTscAdvancedSettings + { + public: + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_SmoothScroll( + /* [in] */ long psmoothScroll) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_SmoothScroll( + /* [retval][out] */ long *psmoothScroll) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_AcceleratorPassthrough( + /* [in] */ long pacceleratorPassthrough) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_AcceleratorPassthrough( + /* [retval][out] */ long *pacceleratorPassthrough) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_ShadowBitmap( + /* [in] */ long pshadowBitmap) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_ShadowBitmap( + /* [retval][out] */ long *pshadowBitmap) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_TransportType( + /* [in] */ long ptransportType) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_TransportType( + /* [retval][out] */ long *ptransportType) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_SasSequence( + /* [in] */ long psasSequence) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_SasSequence( + /* [retval][out] */ long *psasSequence) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_EncryptionEnabled( + /* [in] */ long pencryptionEnabled) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_EncryptionEnabled( + /* [retval][out] */ long *pencryptionEnabled) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_DedicatedTerminal( + /* [in] */ long pdedicatedTerminal) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_DedicatedTerminal( + /* [retval][out] */ long *pdedicatedTerminal) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_RDPPort( + /* [in] */ long prdpPort) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_RDPPort( + /* [retval][out] */ long *prdpPort) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_EnableMouse( + /* [in] */ long penableMouse) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_EnableMouse( + /* [retval][out] */ long *penableMouse) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_DisableCtrlAltDel( + /* [in] */ long pdisableCtrlAltDel) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_DisableCtrlAltDel( + /* [retval][out] */ long *pdisableCtrlAltDel) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_EnableWindowsKey( + /* [in] */ long penableWindowsKey) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_EnableWindowsKey( + /* [retval][out] */ long *penableWindowsKey) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_DoubleClickDetect( + /* [in] */ long pdoubleClickDetect) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_DoubleClickDetect( + /* [retval][out] */ long *pdoubleClickDetect) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_MaximizeShell( + /* [in] */ long pmaximizeShell) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_MaximizeShell( + /* [retval][out] */ long *pmaximizeShell) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_HotKeyFullScreen( + /* [in] */ long photKeyFullScreen) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_HotKeyFullScreen( + /* [retval][out] */ long *photKeyFullScreen) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_HotKeyCtrlEsc( + /* [in] */ long photKeyCtrlEsc) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_HotKeyCtrlEsc( + /* [retval][out] */ long *photKeyCtrlEsc) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_HotKeyAltEsc( + /* [in] */ long photKeyAltEsc) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_HotKeyAltEsc( + /* [retval][out] */ long *photKeyAltEsc) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_HotKeyAltTab( + /* [in] */ long photKeyAltTab) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_HotKeyAltTab( + /* [retval][out] */ long *photKeyAltTab) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_HotKeyAltShiftTab( + /* [in] */ long photKeyAltShiftTab) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_HotKeyAltShiftTab( + /* [retval][out] */ long *photKeyAltShiftTab) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_HotKeyAltSpace( + /* [in] */ long photKeyAltSpace) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_HotKeyAltSpace( + /* [retval][out] */ long *photKeyAltSpace) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_HotKeyCtrlAltDel( + /* [in] */ long photKeyCtrlAltDel) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_HotKeyCtrlAltDel( + /* [retval][out] */ long *photKeyCtrlAltDel) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_orderDrawThreshold( + /* [in] */ long porderDrawThreshold) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_orderDrawThreshold( + /* [retval][out] */ long *porderDrawThreshold) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_BitmapCacheSize( + /* [in] */ long pbitmapCacheSize) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_BitmapCacheSize( + /* [retval][out] */ long *pbitmapCacheSize) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_BitmapVirtualCacheSize( + /* [in] */ long pbitmapVirtualCacheSize) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_BitmapVirtualCacheSize( + /* [retval][out] */ long *pbitmapVirtualCacheSize) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_ScaleBitmapCachesByBPP( + /* [in] */ long pbScale) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_ScaleBitmapCachesByBPP( + /* [retval][out] */ long *pbScale) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_NumBitmapCaches( + /* [in] */ long pnumBitmapCaches) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_NumBitmapCaches( + /* [retval][out] */ long *pnumBitmapCaches) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_CachePersistenceActive( + /* [in] */ long pcachePersistenceActive) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_CachePersistenceActive( + /* [retval][out] */ long *pcachePersistenceActive) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_PersistCacheDirectory( + /* [in] */ BSTR rhs) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_brushSupportLevel( + /* [in] */ long pbrushSupportLevel) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_brushSupportLevel( + /* [retval][out] */ long *pbrushSupportLevel) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_minInputSendInterval( + /* [in] */ long pminInputSendInterval) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_minInputSendInterval( + /* [retval][out] */ long *pminInputSendInterval) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_InputEventsAtOnce( + /* [in] */ long pinputEventsAtOnce) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_InputEventsAtOnce( + /* [retval][out] */ long *pinputEventsAtOnce) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_maxEventCount( + /* [in] */ long pmaxEventCount) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_maxEventCount( + /* [retval][out] */ long *pmaxEventCount) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_keepAliveInterval( + /* [in] */ long pkeepAliveInterval) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_keepAliveInterval( + /* [retval][out] */ long *pkeepAliveInterval) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_shutdownTimeout( + /* [in] */ long pshutdownTimeout) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_shutdownTimeout( + /* [retval][out] */ long *pshutdownTimeout) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_overallConnectionTimeout( + /* [in] */ long poverallConnectionTimeout) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_overallConnectionTimeout( + /* [retval][out] */ long *poverallConnectionTimeout) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_singleConnectionTimeout( + /* [in] */ long psingleConnectionTimeout) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_singleConnectionTimeout( + /* [retval][out] */ long *psingleConnectionTimeout) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_KeyboardType( + /* [in] */ long pkeyboardType) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_KeyboardType( + /* [retval][out] */ long *pkeyboardType) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_KeyboardSubType( + /* [in] */ long pkeyboardSubType) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_KeyboardSubType( + /* [retval][out] */ long *pkeyboardSubType) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_KeyboardFunctionKey( + /* [in] */ long pkeyboardFunctionKey) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_KeyboardFunctionKey( + /* [retval][out] */ long *pkeyboardFunctionKey) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_WinceFixedPalette( + /* [in] */ long pwinceFixedPalette) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_WinceFixedPalette( + /* [retval][out] */ long *pwinceFixedPalette) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_ConnectToServerConsole( + /* [in] */ VARIANT_BOOL pConnectToConsole) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_ConnectToServerConsole( + /* [retval][out] */ VARIANT_BOOL *pConnectToConsole) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_BitmapPersistence( + /* [in] */ long pbitmapPersistence) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_BitmapPersistence( + /* [retval][out] */ long *pbitmapPersistence) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_MinutesToIdleTimeout( + /* [in] */ long pminutesToIdleTimeout) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_MinutesToIdleTimeout( + /* [retval][out] */ long *pminutesToIdleTimeout) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_SmartSizing( + /* [in] */ VARIANT_BOOL pfSmartSizing) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_SmartSizing( + /* [retval][out] */ VARIANT_BOOL *pfSmartSizing) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_RdpdrLocalPrintingDocName( + /* [in] */ BSTR pLocalPrintingDocName) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_RdpdrLocalPrintingDocName( + /* [retval][out] */ BSTR *pLocalPrintingDocName) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_RdpdrClipCleanTempDirString( + /* [in] */ BSTR clipCleanTempDirString) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_RdpdrClipCleanTempDirString( + /* [retval][out] */ BSTR *clipCleanTempDirString) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_RdpdrClipPasteInfoString( + /* [in] */ BSTR clipPasteInfoString) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_RdpdrClipPasteInfoString( + /* [retval][out] */ BSTR *clipPasteInfoString) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_ClearTextPassword( + /* [in] */ BSTR rhs) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_DisplayConnectionBar( + /* [in] */ VARIANT_BOOL pDisplayConnectionBar) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_DisplayConnectionBar( + /* [retval][out] */ VARIANT_BOOL *pDisplayConnectionBar) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_PinConnectionBar( + /* [in] */ VARIANT_BOOL pPinConnectionBar) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_PinConnectionBar( + /* [retval][out] */ VARIANT_BOOL *pPinConnectionBar) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_GrabFocusOnConnect( + /* [in] */ VARIANT_BOOL pfGrabFocusOnConnect) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_GrabFocusOnConnect( + /* [retval][out] */ VARIANT_BOOL *pfGrabFocusOnConnect) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_LoadBalanceInfo( + /* [in] */ BSTR pLBInfo) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_LoadBalanceInfo( + /* [retval][out] */ BSTR *pLBInfo) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_RedirectDrives( + /* [in] */ VARIANT_BOOL pRedirectDrives) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_RedirectDrives( + /* [retval][out] */ VARIANT_BOOL *pRedirectDrives) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_RedirectPrinters( + /* [in] */ VARIANT_BOOL pRedirectPrinters) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_RedirectPrinters( + /* [retval][out] */ VARIANT_BOOL *pRedirectPrinters) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_RedirectPorts( + /* [in] */ VARIANT_BOOL pRedirectPorts) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_RedirectPorts( + /* [retval][out] */ VARIANT_BOOL *pRedirectPorts) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_RedirectSmartCards( + /* [in] */ VARIANT_BOOL pRedirectSmartCards) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_RedirectSmartCards( + /* [retval][out] */ VARIANT_BOOL *pRedirectSmartCards) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_BitmapVirtualCache16BppSize( + /* [in] */ long pBitmapVirtualCache16BppSize) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_BitmapVirtualCache16BppSize( + /* [retval][out] */ long *pBitmapVirtualCache16BppSize) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_BitmapVirtualCache24BppSize( + /* [in] */ long pBitmapVirtualCache24BppSize) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_BitmapVirtualCache24BppSize( + /* [retval][out] */ long *pBitmapVirtualCache24BppSize) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_PerformanceFlags( + /* [in] */ long pDisableList) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_PerformanceFlags( + /* [retval][out] */ long *pDisableList) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_ConnectWithEndpoint( + /* [in] */ VARIANT *rhs) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_NotifyTSPublicKey( + /* [in] */ VARIANT_BOOL pfNotify) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_NotifyTSPublicKey( + /* [retval][out] */ VARIANT_BOOL *pfNotify) = 0; + + }; + +#else /* C style interface */ + + typedef struct IMsRdpClientAdvancedSettingsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ + __RPC__deref_out void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMsRdpClientAdvancedSettings * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMsRdpClientAdvancedSettings * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + IMsRdpClientAdvancedSettings * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [range][in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Compress )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pcompress); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Compress )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pcompress); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapPeristence )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pbitmapPeristence); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapPeristence )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pbitmapPeristence); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_allowBackgroundInput )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pallowBackgroundInput); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_allowBackgroundInput )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pallowBackgroundInput); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_KeyBoardLayoutStr )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_PluginDlls )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_IconFile )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_IconIndex )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ContainerHandledFullScreen )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pContainerHandledFullScreen); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ContainerHandledFullScreen )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pContainerHandledFullScreen); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DisableRdpdr )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pDisableRdpdr); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DisableRdpdr )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pDisableRdpdr); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_SmoothScroll )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long psmoothScroll); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SmoothScroll )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *psmoothScroll); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_AcceleratorPassthrough )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pacceleratorPassthrough); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AcceleratorPassthrough )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pacceleratorPassthrough); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ShadowBitmap )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pshadowBitmap); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ShadowBitmap )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pshadowBitmap); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_TransportType )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long ptransportType); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_TransportType )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *ptransportType); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_SasSequence )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long psasSequence); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SasSequence )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *psasSequence); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_EncryptionEnabled )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pencryptionEnabled); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_EncryptionEnabled )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pencryptionEnabled); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DedicatedTerminal )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pdedicatedTerminal); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DedicatedTerminal )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pdedicatedTerminal); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RDPPort )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long prdpPort); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RDPPort )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *prdpPort); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_EnableMouse )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long penableMouse); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_EnableMouse )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *penableMouse); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DisableCtrlAltDel )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pdisableCtrlAltDel); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DisableCtrlAltDel )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pdisableCtrlAltDel); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_EnableWindowsKey )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long penableWindowsKey); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_EnableWindowsKey )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *penableWindowsKey); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DoubleClickDetect )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pdoubleClickDetect); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DoubleClickDetect )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pdoubleClickDetect); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_MaximizeShell )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pmaximizeShell); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_MaximizeShell )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pmaximizeShell); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyFullScreen )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long photKeyFullScreen); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyFullScreen )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *photKeyFullScreen); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyCtrlEsc )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long photKeyCtrlEsc); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyCtrlEsc )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *photKeyCtrlEsc); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyAltEsc )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long photKeyAltEsc); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyAltEsc )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *photKeyAltEsc); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyAltTab )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long photKeyAltTab); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyAltTab )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *photKeyAltTab); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyAltShiftTab )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long photKeyAltShiftTab); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyAltShiftTab )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *photKeyAltShiftTab); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyAltSpace )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long photKeyAltSpace); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyAltSpace )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *photKeyAltSpace); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyCtrlAltDel )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long photKeyCtrlAltDel); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyCtrlAltDel )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *photKeyCtrlAltDel); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_orderDrawThreshold )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long porderDrawThreshold); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_orderDrawThreshold )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *porderDrawThreshold); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapCacheSize )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pbitmapCacheSize); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapCacheSize )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pbitmapCacheSize); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapVirtualCacheSize )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pbitmapVirtualCacheSize); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapVirtualCacheSize )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pbitmapVirtualCacheSize); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ScaleBitmapCachesByBPP )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pbScale); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ScaleBitmapCachesByBPP )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pbScale); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_NumBitmapCaches )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pnumBitmapCaches); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_NumBitmapCaches )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pnumBitmapCaches); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_CachePersistenceActive )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pcachePersistenceActive); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_CachePersistenceActive )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pcachePersistenceActive); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_PersistCacheDirectory )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_brushSupportLevel )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pbrushSupportLevel); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_brushSupportLevel )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pbrushSupportLevel); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_minInputSendInterval )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pminInputSendInterval); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_minInputSendInterval )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pminInputSendInterval); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_InputEventsAtOnce )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pinputEventsAtOnce); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_InputEventsAtOnce )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pinputEventsAtOnce); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_maxEventCount )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pmaxEventCount); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_maxEventCount )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pmaxEventCount); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_keepAliveInterval )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pkeepAliveInterval); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_keepAliveInterval )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pkeepAliveInterval); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_shutdownTimeout )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pshutdownTimeout); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_shutdownTimeout )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pshutdownTimeout); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_overallConnectionTimeout )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long poverallConnectionTimeout); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_overallConnectionTimeout )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *poverallConnectionTimeout); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_singleConnectionTimeout )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long psingleConnectionTimeout); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_singleConnectionTimeout )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *psingleConnectionTimeout); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_KeyboardType )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pkeyboardType); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_KeyboardType )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pkeyboardType); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_KeyboardSubType )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pkeyboardSubType); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_KeyboardSubType )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pkeyboardSubType); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_KeyboardFunctionKey )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pkeyboardFunctionKey); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_KeyboardFunctionKey )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pkeyboardFunctionKey); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_WinceFixedPalette )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pwinceFixedPalette); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_WinceFixedPalette )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pwinceFixedPalette); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ConnectToServerConsole )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ VARIANT_BOOL pConnectToConsole); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ConnectToServerConsole )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ VARIANT_BOOL *pConnectToConsole); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapPersistence )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pbitmapPersistence); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapPersistence )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pbitmapPersistence); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_MinutesToIdleTimeout )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pminutesToIdleTimeout); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_MinutesToIdleTimeout )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pminutesToIdleTimeout); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_SmartSizing )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ VARIANT_BOOL pfSmartSizing); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SmartSizing )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ VARIANT_BOOL *pfSmartSizing); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RdpdrLocalPrintingDocName )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ BSTR pLocalPrintingDocName); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RdpdrLocalPrintingDocName )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ BSTR *pLocalPrintingDocName); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RdpdrClipCleanTempDirString )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ BSTR clipCleanTempDirString); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RdpdrClipCleanTempDirString )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ BSTR *clipCleanTempDirString); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RdpdrClipPasteInfoString )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ BSTR clipPasteInfoString); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RdpdrClipPasteInfoString )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ BSTR *clipPasteInfoString); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ClearTextPassword )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DisplayConnectionBar )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ VARIANT_BOOL pDisplayConnectionBar); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DisplayConnectionBar )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ VARIANT_BOOL *pDisplayConnectionBar); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_PinConnectionBar )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ VARIANT_BOOL pPinConnectionBar); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_PinConnectionBar )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ VARIANT_BOOL *pPinConnectionBar); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_GrabFocusOnConnect )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ VARIANT_BOOL pfGrabFocusOnConnect); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_GrabFocusOnConnect )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ VARIANT_BOOL *pfGrabFocusOnConnect); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_LoadBalanceInfo )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ BSTR pLBInfo); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_LoadBalanceInfo )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ BSTR *pLBInfo); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RedirectDrives )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ VARIANT_BOOL pRedirectDrives); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RedirectDrives )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ VARIANT_BOOL *pRedirectDrives); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RedirectPrinters )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ VARIANT_BOOL pRedirectPrinters); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RedirectPrinters )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ VARIANT_BOOL *pRedirectPrinters); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RedirectPorts )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ VARIANT_BOOL pRedirectPorts); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RedirectPorts )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ VARIANT_BOOL *pRedirectPorts); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RedirectSmartCards )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ VARIANT_BOOL pRedirectSmartCards); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RedirectSmartCards )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ VARIANT_BOOL *pRedirectSmartCards); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapVirtualCache16BppSize )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pBitmapVirtualCache16BppSize); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapVirtualCache16BppSize )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pBitmapVirtualCache16BppSize); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapVirtualCache24BppSize )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pBitmapVirtualCache24BppSize); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapVirtualCache24BppSize )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pBitmapVirtualCache24BppSize); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_PerformanceFlags )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pDisableList); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_PerformanceFlags )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pDisableList); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ConnectWithEndpoint )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ VARIANT *rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_NotifyTSPublicKey )( + IMsRdpClientAdvancedSettings * This, + /* [in] */ VARIANT_BOOL pfNotify); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_NotifyTSPublicKey )( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ VARIANT_BOOL *pfNotify); + + END_INTERFACE + } IMsRdpClientAdvancedSettingsVtbl; + + interface IMsRdpClientAdvancedSettings + { + CONST_VTBL struct IMsRdpClientAdvancedSettingsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMsRdpClientAdvancedSettings_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMsRdpClientAdvancedSettings_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMsRdpClientAdvancedSettings_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMsRdpClientAdvancedSettings_GetTypeInfoCount(This,pctinfo) \ + ( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) ) + +#define IMsRdpClientAdvancedSettings_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + ( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) ) + +#define IMsRdpClientAdvancedSettings_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + ( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ) + +#define IMsRdpClientAdvancedSettings_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + ( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ) + + +#define IMsRdpClientAdvancedSettings_put_Compress(This,pcompress) \ + ( (This)->lpVtbl -> put_Compress(This,pcompress) ) + +#define IMsRdpClientAdvancedSettings_get_Compress(This,pcompress) \ + ( (This)->lpVtbl -> get_Compress(This,pcompress) ) + +#define IMsRdpClientAdvancedSettings_put_BitmapPeristence(This,pbitmapPeristence) \ + ( (This)->lpVtbl -> put_BitmapPeristence(This,pbitmapPeristence) ) + +#define IMsRdpClientAdvancedSettings_get_BitmapPeristence(This,pbitmapPeristence) \ + ( (This)->lpVtbl -> get_BitmapPeristence(This,pbitmapPeristence) ) + +#define IMsRdpClientAdvancedSettings_put_allowBackgroundInput(This,pallowBackgroundInput) \ + ( (This)->lpVtbl -> put_allowBackgroundInput(This,pallowBackgroundInput) ) + +#define IMsRdpClientAdvancedSettings_get_allowBackgroundInput(This,pallowBackgroundInput) \ + ( (This)->lpVtbl -> get_allowBackgroundInput(This,pallowBackgroundInput) ) + +#define IMsRdpClientAdvancedSettings_put_KeyBoardLayoutStr(This,rhs) \ + ( (This)->lpVtbl -> put_KeyBoardLayoutStr(This,rhs) ) + +#define IMsRdpClientAdvancedSettings_put_PluginDlls(This,rhs) \ + ( (This)->lpVtbl -> put_PluginDlls(This,rhs) ) + +#define IMsRdpClientAdvancedSettings_put_IconFile(This,rhs) \ + ( (This)->lpVtbl -> put_IconFile(This,rhs) ) + +#define IMsRdpClientAdvancedSettings_put_IconIndex(This,rhs) \ + ( (This)->lpVtbl -> put_IconIndex(This,rhs) ) + +#define IMsRdpClientAdvancedSettings_put_ContainerHandledFullScreen(This,pContainerHandledFullScreen) \ + ( (This)->lpVtbl -> put_ContainerHandledFullScreen(This,pContainerHandledFullScreen) ) + +#define IMsRdpClientAdvancedSettings_get_ContainerHandledFullScreen(This,pContainerHandledFullScreen) \ + ( (This)->lpVtbl -> get_ContainerHandledFullScreen(This,pContainerHandledFullScreen) ) + +#define IMsRdpClientAdvancedSettings_put_DisableRdpdr(This,pDisableRdpdr) \ + ( (This)->lpVtbl -> put_DisableRdpdr(This,pDisableRdpdr) ) + +#define IMsRdpClientAdvancedSettings_get_DisableRdpdr(This,pDisableRdpdr) \ + ( (This)->lpVtbl -> get_DisableRdpdr(This,pDisableRdpdr) ) + + +#define IMsRdpClientAdvancedSettings_put_SmoothScroll(This,psmoothScroll) \ + ( (This)->lpVtbl -> put_SmoothScroll(This,psmoothScroll) ) + +#define IMsRdpClientAdvancedSettings_get_SmoothScroll(This,psmoothScroll) \ + ( (This)->lpVtbl -> get_SmoothScroll(This,psmoothScroll) ) + +#define IMsRdpClientAdvancedSettings_put_AcceleratorPassthrough(This,pacceleratorPassthrough) \ + ( (This)->lpVtbl -> put_AcceleratorPassthrough(This,pacceleratorPassthrough) ) + +#define IMsRdpClientAdvancedSettings_get_AcceleratorPassthrough(This,pacceleratorPassthrough) \ + ( (This)->lpVtbl -> get_AcceleratorPassthrough(This,pacceleratorPassthrough) ) + +#define IMsRdpClientAdvancedSettings_put_ShadowBitmap(This,pshadowBitmap) \ + ( (This)->lpVtbl -> put_ShadowBitmap(This,pshadowBitmap) ) + +#define IMsRdpClientAdvancedSettings_get_ShadowBitmap(This,pshadowBitmap) \ + ( (This)->lpVtbl -> get_ShadowBitmap(This,pshadowBitmap) ) + +#define IMsRdpClientAdvancedSettings_put_TransportType(This,ptransportType) \ + ( (This)->lpVtbl -> put_TransportType(This,ptransportType) ) + +#define IMsRdpClientAdvancedSettings_get_TransportType(This,ptransportType) \ + ( (This)->lpVtbl -> get_TransportType(This,ptransportType) ) + +#define IMsRdpClientAdvancedSettings_put_SasSequence(This,psasSequence) \ + ( (This)->lpVtbl -> put_SasSequence(This,psasSequence) ) + +#define IMsRdpClientAdvancedSettings_get_SasSequence(This,psasSequence) \ + ( (This)->lpVtbl -> get_SasSequence(This,psasSequence) ) + +#define IMsRdpClientAdvancedSettings_put_EncryptionEnabled(This,pencryptionEnabled) \ + ( (This)->lpVtbl -> put_EncryptionEnabled(This,pencryptionEnabled) ) + +#define IMsRdpClientAdvancedSettings_get_EncryptionEnabled(This,pencryptionEnabled) \ + ( (This)->lpVtbl -> get_EncryptionEnabled(This,pencryptionEnabled) ) + +#define IMsRdpClientAdvancedSettings_put_DedicatedTerminal(This,pdedicatedTerminal) \ + ( (This)->lpVtbl -> put_DedicatedTerminal(This,pdedicatedTerminal) ) + +#define IMsRdpClientAdvancedSettings_get_DedicatedTerminal(This,pdedicatedTerminal) \ + ( (This)->lpVtbl -> get_DedicatedTerminal(This,pdedicatedTerminal) ) + +#define IMsRdpClientAdvancedSettings_put_RDPPort(This,prdpPort) \ + ( (This)->lpVtbl -> put_RDPPort(This,prdpPort) ) + +#define IMsRdpClientAdvancedSettings_get_RDPPort(This,prdpPort) \ + ( (This)->lpVtbl -> get_RDPPort(This,prdpPort) ) + +#define IMsRdpClientAdvancedSettings_put_EnableMouse(This,penableMouse) \ + ( (This)->lpVtbl -> put_EnableMouse(This,penableMouse) ) + +#define IMsRdpClientAdvancedSettings_get_EnableMouse(This,penableMouse) \ + ( (This)->lpVtbl -> get_EnableMouse(This,penableMouse) ) + +#define IMsRdpClientAdvancedSettings_put_DisableCtrlAltDel(This,pdisableCtrlAltDel) \ + ( (This)->lpVtbl -> put_DisableCtrlAltDel(This,pdisableCtrlAltDel) ) + +#define IMsRdpClientAdvancedSettings_get_DisableCtrlAltDel(This,pdisableCtrlAltDel) \ + ( (This)->lpVtbl -> get_DisableCtrlAltDel(This,pdisableCtrlAltDel) ) + +#define IMsRdpClientAdvancedSettings_put_EnableWindowsKey(This,penableWindowsKey) \ + ( (This)->lpVtbl -> put_EnableWindowsKey(This,penableWindowsKey) ) + +#define IMsRdpClientAdvancedSettings_get_EnableWindowsKey(This,penableWindowsKey) \ + ( (This)->lpVtbl -> get_EnableWindowsKey(This,penableWindowsKey) ) + +#define IMsRdpClientAdvancedSettings_put_DoubleClickDetect(This,pdoubleClickDetect) \ + ( (This)->lpVtbl -> put_DoubleClickDetect(This,pdoubleClickDetect) ) + +#define IMsRdpClientAdvancedSettings_get_DoubleClickDetect(This,pdoubleClickDetect) \ + ( (This)->lpVtbl -> get_DoubleClickDetect(This,pdoubleClickDetect) ) + +#define IMsRdpClientAdvancedSettings_put_MaximizeShell(This,pmaximizeShell) \ + ( (This)->lpVtbl -> put_MaximizeShell(This,pmaximizeShell) ) + +#define IMsRdpClientAdvancedSettings_get_MaximizeShell(This,pmaximizeShell) \ + ( (This)->lpVtbl -> get_MaximizeShell(This,pmaximizeShell) ) + +#define IMsRdpClientAdvancedSettings_put_HotKeyFullScreen(This,photKeyFullScreen) \ + ( (This)->lpVtbl -> put_HotKeyFullScreen(This,photKeyFullScreen) ) + +#define IMsRdpClientAdvancedSettings_get_HotKeyFullScreen(This,photKeyFullScreen) \ + ( (This)->lpVtbl -> get_HotKeyFullScreen(This,photKeyFullScreen) ) + +#define IMsRdpClientAdvancedSettings_put_HotKeyCtrlEsc(This,photKeyCtrlEsc) \ + ( (This)->lpVtbl -> put_HotKeyCtrlEsc(This,photKeyCtrlEsc) ) + +#define IMsRdpClientAdvancedSettings_get_HotKeyCtrlEsc(This,photKeyCtrlEsc) \ + ( (This)->lpVtbl -> get_HotKeyCtrlEsc(This,photKeyCtrlEsc) ) + +#define IMsRdpClientAdvancedSettings_put_HotKeyAltEsc(This,photKeyAltEsc) \ + ( (This)->lpVtbl -> put_HotKeyAltEsc(This,photKeyAltEsc) ) + +#define IMsRdpClientAdvancedSettings_get_HotKeyAltEsc(This,photKeyAltEsc) \ + ( (This)->lpVtbl -> get_HotKeyAltEsc(This,photKeyAltEsc) ) + +#define IMsRdpClientAdvancedSettings_put_HotKeyAltTab(This,photKeyAltTab) \ + ( (This)->lpVtbl -> put_HotKeyAltTab(This,photKeyAltTab) ) + +#define IMsRdpClientAdvancedSettings_get_HotKeyAltTab(This,photKeyAltTab) \ + ( (This)->lpVtbl -> get_HotKeyAltTab(This,photKeyAltTab) ) + +#define IMsRdpClientAdvancedSettings_put_HotKeyAltShiftTab(This,photKeyAltShiftTab) \ + ( (This)->lpVtbl -> put_HotKeyAltShiftTab(This,photKeyAltShiftTab) ) + +#define IMsRdpClientAdvancedSettings_get_HotKeyAltShiftTab(This,photKeyAltShiftTab) \ + ( (This)->lpVtbl -> get_HotKeyAltShiftTab(This,photKeyAltShiftTab) ) + +#define IMsRdpClientAdvancedSettings_put_HotKeyAltSpace(This,photKeyAltSpace) \ + ( (This)->lpVtbl -> put_HotKeyAltSpace(This,photKeyAltSpace) ) + +#define IMsRdpClientAdvancedSettings_get_HotKeyAltSpace(This,photKeyAltSpace) \ + ( (This)->lpVtbl -> get_HotKeyAltSpace(This,photKeyAltSpace) ) + +#define IMsRdpClientAdvancedSettings_put_HotKeyCtrlAltDel(This,photKeyCtrlAltDel) \ + ( (This)->lpVtbl -> put_HotKeyCtrlAltDel(This,photKeyCtrlAltDel) ) + +#define IMsRdpClientAdvancedSettings_get_HotKeyCtrlAltDel(This,photKeyCtrlAltDel) \ + ( (This)->lpVtbl -> get_HotKeyCtrlAltDel(This,photKeyCtrlAltDel) ) + +#define IMsRdpClientAdvancedSettings_put_orderDrawThreshold(This,porderDrawThreshold) \ + ( (This)->lpVtbl -> put_orderDrawThreshold(This,porderDrawThreshold) ) + +#define IMsRdpClientAdvancedSettings_get_orderDrawThreshold(This,porderDrawThreshold) \ + ( (This)->lpVtbl -> get_orderDrawThreshold(This,porderDrawThreshold) ) + +#define IMsRdpClientAdvancedSettings_put_BitmapCacheSize(This,pbitmapCacheSize) \ + ( (This)->lpVtbl -> put_BitmapCacheSize(This,pbitmapCacheSize) ) + +#define IMsRdpClientAdvancedSettings_get_BitmapCacheSize(This,pbitmapCacheSize) \ + ( (This)->lpVtbl -> get_BitmapCacheSize(This,pbitmapCacheSize) ) + +#define IMsRdpClientAdvancedSettings_put_BitmapVirtualCacheSize(This,pbitmapVirtualCacheSize) \ + ( (This)->lpVtbl -> put_BitmapVirtualCacheSize(This,pbitmapVirtualCacheSize) ) + +#define IMsRdpClientAdvancedSettings_get_BitmapVirtualCacheSize(This,pbitmapVirtualCacheSize) \ + ( (This)->lpVtbl -> get_BitmapVirtualCacheSize(This,pbitmapVirtualCacheSize) ) + +#define IMsRdpClientAdvancedSettings_put_ScaleBitmapCachesByBPP(This,pbScale) \ + ( (This)->lpVtbl -> put_ScaleBitmapCachesByBPP(This,pbScale) ) + +#define IMsRdpClientAdvancedSettings_get_ScaleBitmapCachesByBPP(This,pbScale) \ + ( (This)->lpVtbl -> get_ScaleBitmapCachesByBPP(This,pbScale) ) + +#define IMsRdpClientAdvancedSettings_put_NumBitmapCaches(This,pnumBitmapCaches) \ + ( (This)->lpVtbl -> put_NumBitmapCaches(This,pnumBitmapCaches) ) + +#define IMsRdpClientAdvancedSettings_get_NumBitmapCaches(This,pnumBitmapCaches) \ + ( (This)->lpVtbl -> get_NumBitmapCaches(This,pnumBitmapCaches) ) + +#define IMsRdpClientAdvancedSettings_put_CachePersistenceActive(This,pcachePersistenceActive) \ + ( (This)->lpVtbl -> put_CachePersistenceActive(This,pcachePersistenceActive) ) + +#define IMsRdpClientAdvancedSettings_get_CachePersistenceActive(This,pcachePersistenceActive) \ + ( (This)->lpVtbl -> get_CachePersistenceActive(This,pcachePersistenceActive) ) + +#define IMsRdpClientAdvancedSettings_put_PersistCacheDirectory(This,rhs) \ + ( (This)->lpVtbl -> put_PersistCacheDirectory(This,rhs) ) + +#define IMsRdpClientAdvancedSettings_put_brushSupportLevel(This,pbrushSupportLevel) \ + ( (This)->lpVtbl -> put_brushSupportLevel(This,pbrushSupportLevel) ) + +#define IMsRdpClientAdvancedSettings_get_brushSupportLevel(This,pbrushSupportLevel) \ + ( (This)->lpVtbl -> get_brushSupportLevel(This,pbrushSupportLevel) ) + +#define IMsRdpClientAdvancedSettings_put_minInputSendInterval(This,pminInputSendInterval) \ + ( (This)->lpVtbl -> put_minInputSendInterval(This,pminInputSendInterval) ) + +#define IMsRdpClientAdvancedSettings_get_minInputSendInterval(This,pminInputSendInterval) \ + ( (This)->lpVtbl -> get_minInputSendInterval(This,pminInputSendInterval) ) + +#define IMsRdpClientAdvancedSettings_put_InputEventsAtOnce(This,pinputEventsAtOnce) \ + ( (This)->lpVtbl -> put_InputEventsAtOnce(This,pinputEventsAtOnce) ) + +#define IMsRdpClientAdvancedSettings_get_InputEventsAtOnce(This,pinputEventsAtOnce) \ + ( (This)->lpVtbl -> get_InputEventsAtOnce(This,pinputEventsAtOnce) ) + +#define IMsRdpClientAdvancedSettings_put_maxEventCount(This,pmaxEventCount) \ + ( (This)->lpVtbl -> put_maxEventCount(This,pmaxEventCount) ) + +#define IMsRdpClientAdvancedSettings_get_maxEventCount(This,pmaxEventCount) \ + ( (This)->lpVtbl -> get_maxEventCount(This,pmaxEventCount) ) + +#define IMsRdpClientAdvancedSettings_put_keepAliveInterval(This,pkeepAliveInterval) \ + ( (This)->lpVtbl -> put_keepAliveInterval(This,pkeepAliveInterval) ) + +#define IMsRdpClientAdvancedSettings_get_keepAliveInterval(This,pkeepAliveInterval) \ + ( (This)->lpVtbl -> get_keepAliveInterval(This,pkeepAliveInterval) ) + +#define IMsRdpClientAdvancedSettings_put_shutdownTimeout(This,pshutdownTimeout) \ + ( (This)->lpVtbl -> put_shutdownTimeout(This,pshutdownTimeout) ) + +#define IMsRdpClientAdvancedSettings_get_shutdownTimeout(This,pshutdownTimeout) \ + ( (This)->lpVtbl -> get_shutdownTimeout(This,pshutdownTimeout) ) + +#define IMsRdpClientAdvancedSettings_put_overallConnectionTimeout(This,poverallConnectionTimeout) \ + ( (This)->lpVtbl -> put_overallConnectionTimeout(This,poverallConnectionTimeout) ) + +#define IMsRdpClientAdvancedSettings_get_overallConnectionTimeout(This,poverallConnectionTimeout) \ + ( (This)->lpVtbl -> get_overallConnectionTimeout(This,poverallConnectionTimeout) ) + +#define IMsRdpClientAdvancedSettings_put_singleConnectionTimeout(This,psingleConnectionTimeout) \ + ( (This)->lpVtbl -> put_singleConnectionTimeout(This,psingleConnectionTimeout) ) + +#define IMsRdpClientAdvancedSettings_get_singleConnectionTimeout(This,psingleConnectionTimeout) \ + ( (This)->lpVtbl -> get_singleConnectionTimeout(This,psingleConnectionTimeout) ) + +#define IMsRdpClientAdvancedSettings_put_KeyboardType(This,pkeyboardType) \ + ( (This)->lpVtbl -> put_KeyboardType(This,pkeyboardType) ) + +#define IMsRdpClientAdvancedSettings_get_KeyboardType(This,pkeyboardType) \ + ( (This)->lpVtbl -> get_KeyboardType(This,pkeyboardType) ) + +#define IMsRdpClientAdvancedSettings_put_KeyboardSubType(This,pkeyboardSubType) \ + ( (This)->lpVtbl -> put_KeyboardSubType(This,pkeyboardSubType) ) + +#define IMsRdpClientAdvancedSettings_get_KeyboardSubType(This,pkeyboardSubType) \ + ( (This)->lpVtbl -> get_KeyboardSubType(This,pkeyboardSubType) ) + +#define IMsRdpClientAdvancedSettings_put_KeyboardFunctionKey(This,pkeyboardFunctionKey) \ + ( (This)->lpVtbl -> put_KeyboardFunctionKey(This,pkeyboardFunctionKey) ) + +#define IMsRdpClientAdvancedSettings_get_KeyboardFunctionKey(This,pkeyboardFunctionKey) \ + ( (This)->lpVtbl -> get_KeyboardFunctionKey(This,pkeyboardFunctionKey) ) + +#define IMsRdpClientAdvancedSettings_put_WinceFixedPalette(This,pwinceFixedPalette) \ + ( (This)->lpVtbl -> put_WinceFixedPalette(This,pwinceFixedPalette) ) + +#define IMsRdpClientAdvancedSettings_get_WinceFixedPalette(This,pwinceFixedPalette) \ + ( (This)->lpVtbl -> get_WinceFixedPalette(This,pwinceFixedPalette) ) + +#define IMsRdpClientAdvancedSettings_put_ConnectToServerConsole(This,pConnectToConsole) \ + ( (This)->lpVtbl -> put_ConnectToServerConsole(This,pConnectToConsole) ) + +#define IMsRdpClientAdvancedSettings_get_ConnectToServerConsole(This,pConnectToConsole) \ + ( (This)->lpVtbl -> get_ConnectToServerConsole(This,pConnectToConsole) ) + +#define IMsRdpClientAdvancedSettings_put_BitmapPersistence(This,pbitmapPersistence) \ + ( (This)->lpVtbl -> put_BitmapPersistence(This,pbitmapPersistence) ) + +#define IMsRdpClientAdvancedSettings_get_BitmapPersistence(This,pbitmapPersistence) \ + ( (This)->lpVtbl -> get_BitmapPersistence(This,pbitmapPersistence) ) + +#define IMsRdpClientAdvancedSettings_put_MinutesToIdleTimeout(This,pminutesToIdleTimeout) \ + ( (This)->lpVtbl -> put_MinutesToIdleTimeout(This,pminutesToIdleTimeout) ) + +#define IMsRdpClientAdvancedSettings_get_MinutesToIdleTimeout(This,pminutesToIdleTimeout) \ + ( (This)->lpVtbl -> get_MinutesToIdleTimeout(This,pminutesToIdleTimeout) ) + +#define IMsRdpClientAdvancedSettings_put_SmartSizing(This,pfSmartSizing) \ + ( (This)->lpVtbl -> put_SmartSizing(This,pfSmartSizing) ) + +#define IMsRdpClientAdvancedSettings_get_SmartSizing(This,pfSmartSizing) \ + ( (This)->lpVtbl -> get_SmartSizing(This,pfSmartSizing) ) + +#define IMsRdpClientAdvancedSettings_put_RdpdrLocalPrintingDocName(This,pLocalPrintingDocName) \ + ( (This)->lpVtbl -> put_RdpdrLocalPrintingDocName(This,pLocalPrintingDocName) ) + +#define IMsRdpClientAdvancedSettings_get_RdpdrLocalPrintingDocName(This,pLocalPrintingDocName) \ + ( (This)->lpVtbl -> get_RdpdrLocalPrintingDocName(This,pLocalPrintingDocName) ) + +#define IMsRdpClientAdvancedSettings_put_RdpdrClipCleanTempDirString(This,clipCleanTempDirString) \ + ( (This)->lpVtbl -> put_RdpdrClipCleanTempDirString(This,clipCleanTempDirString) ) + +#define IMsRdpClientAdvancedSettings_get_RdpdrClipCleanTempDirString(This,clipCleanTempDirString) \ + ( (This)->lpVtbl -> get_RdpdrClipCleanTempDirString(This,clipCleanTempDirString) ) + +#define IMsRdpClientAdvancedSettings_put_RdpdrClipPasteInfoString(This,clipPasteInfoString) \ + ( (This)->lpVtbl -> put_RdpdrClipPasteInfoString(This,clipPasteInfoString) ) + +#define IMsRdpClientAdvancedSettings_get_RdpdrClipPasteInfoString(This,clipPasteInfoString) \ + ( (This)->lpVtbl -> get_RdpdrClipPasteInfoString(This,clipPasteInfoString) ) + +#define IMsRdpClientAdvancedSettings_put_ClearTextPassword(This,rhs) \ + ( (This)->lpVtbl -> put_ClearTextPassword(This,rhs) ) + +#define IMsRdpClientAdvancedSettings_put_DisplayConnectionBar(This,pDisplayConnectionBar) \ + ( (This)->lpVtbl -> put_DisplayConnectionBar(This,pDisplayConnectionBar) ) + +#define IMsRdpClientAdvancedSettings_get_DisplayConnectionBar(This,pDisplayConnectionBar) \ + ( (This)->lpVtbl -> get_DisplayConnectionBar(This,pDisplayConnectionBar) ) + +#define IMsRdpClientAdvancedSettings_put_PinConnectionBar(This,pPinConnectionBar) \ + ( (This)->lpVtbl -> put_PinConnectionBar(This,pPinConnectionBar) ) + +#define IMsRdpClientAdvancedSettings_get_PinConnectionBar(This,pPinConnectionBar) \ + ( (This)->lpVtbl -> get_PinConnectionBar(This,pPinConnectionBar) ) + +#define IMsRdpClientAdvancedSettings_put_GrabFocusOnConnect(This,pfGrabFocusOnConnect) \ + ( (This)->lpVtbl -> put_GrabFocusOnConnect(This,pfGrabFocusOnConnect) ) + +#define IMsRdpClientAdvancedSettings_get_GrabFocusOnConnect(This,pfGrabFocusOnConnect) \ + ( (This)->lpVtbl -> get_GrabFocusOnConnect(This,pfGrabFocusOnConnect) ) + +#define IMsRdpClientAdvancedSettings_put_LoadBalanceInfo(This,pLBInfo) \ + ( (This)->lpVtbl -> put_LoadBalanceInfo(This,pLBInfo) ) + +#define IMsRdpClientAdvancedSettings_get_LoadBalanceInfo(This,pLBInfo) \ + ( (This)->lpVtbl -> get_LoadBalanceInfo(This,pLBInfo) ) + +#define IMsRdpClientAdvancedSettings_put_RedirectDrives(This,pRedirectDrives) \ + ( (This)->lpVtbl -> put_RedirectDrives(This,pRedirectDrives) ) + +#define IMsRdpClientAdvancedSettings_get_RedirectDrives(This,pRedirectDrives) \ + ( (This)->lpVtbl -> get_RedirectDrives(This,pRedirectDrives) ) + +#define IMsRdpClientAdvancedSettings_put_RedirectPrinters(This,pRedirectPrinters) \ + ( (This)->lpVtbl -> put_RedirectPrinters(This,pRedirectPrinters) ) + +#define IMsRdpClientAdvancedSettings_get_RedirectPrinters(This,pRedirectPrinters) \ + ( (This)->lpVtbl -> get_RedirectPrinters(This,pRedirectPrinters) ) + +#define IMsRdpClientAdvancedSettings_put_RedirectPorts(This,pRedirectPorts) \ + ( (This)->lpVtbl -> put_RedirectPorts(This,pRedirectPorts) ) + +#define IMsRdpClientAdvancedSettings_get_RedirectPorts(This,pRedirectPorts) \ + ( (This)->lpVtbl -> get_RedirectPorts(This,pRedirectPorts) ) + +#define IMsRdpClientAdvancedSettings_put_RedirectSmartCards(This,pRedirectSmartCards) \ + ( (This)->lpVtbl -> put_RedirectSmartCards(This,pRedirectSmartCards) ) + +#define IMsRdpClientAdvancedSettings_get_RedirectSmartCards(This,pRedirectSmartCards) \ + ( (This)->lpVtbl -> get_RedirectSmartCards(This,pRedirectSmartCards) ) + +#define IMsRdpClientAdvancedSettings_put_BitmapVirtualCache16BppSize(This,pBitmapVirtualCache16BppSize) \ + ( (This)->lpVtbl -> put_BitmapVirtualCache16BppSize(This,pBitmapVirtualCache16BppSize) ) + +#define IMsRdpClientAdvancedSettings_get_BitmapVirtualCache16BppSize(This,pBitmapVirtualCache16BppSize) \ + ( (This)->lpVtbl -> get_BitmapVirtualCache16BppSize(This,pBitmapVirtualCache16BppSize) ) + +#define IMsRdpClientAdvancedSettings_put_BitmapVirtualCache24BppSize(This,pBitmapVirtualCache24BppSize) \ + ( (This)->lpVtbl -> put_BitmapVirtualCache24BppSize(This,pBitmapVirtualCache24BppSize) ) + +#define IMsRdpClientAdvancedSettings_get_BitmapVirtualCache24BppSize(This,pBitmapVirtualCache24BppSize) \ + ( (This)->lpVtbl -> get_BitmapVirtualCache24BppSize(This,pBitmapVirtualCache24BppSize) ) + +#define IMsRdpClientAdvancedSettings_put_PerformanceFlags(This,pDisableList) \ + ( (This)->lpVtbl -> put_PerformanceFlags(This,pDisableList) ) + +#define IMsRdpClientAdvancedSettings_get_PerformanceFlags(This,pDisableList) \ + ( (This)->lpVtbl -> get_PerformanceFlags(This,pDisableList) ) + +#define IMsRdpClientAdvancedSettings_put_ConnectWithEndpoint(This,rhs) \ + ( (This)->lpVtbl -> put_ConnectWithEndpoint(This,rhs) ) + +#define IMsRdpClientAdvancedSettings_put_NotifyTSPublicKey(This,pfNotify) \ + ( (This)->lpVtbl -> put_NotifyTSPublicKey(This,pfNotify) ) + +#define IMsRdpClientAdvancedSettings_get_NotifyTSPublicKey(This,pfNotify) \ + ( (This)->lpVtbl -> get_NotifyTSPublicKey(This,pfNotify) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [propget][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings_get_RedirectSmartCards_Proxy( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ VARIANT_BOOL *pRedirectSmartCards); + + +void __RPC_STUB IMsRdpClientAdvancedSettings_get_RedirectSmartCards_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [propput][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings_put_BitmapVirtualCache16BppSize_Proxy( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pBitmapVirtualCache16BppSize); + + +void __RPC_STUB IMsRdpClientAdvancedSettings_put_BitmapVirtualCache16BppSize_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [propget][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings_get_BitmapVirtualCache16BppSize_Proxy( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pBitmapVirtualCache16BppSize); + + +void __RPC_STUB IMsRdpClientAdvancedSettings_get_BitmapVirtualCache16BppSize_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [propput][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings_put_BitmapVirtualCache24BppSize_Proxy( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pBitmapVirtualCache24BppSize); + + +void __RPC_STUB IMsRdpClientAdvancedSettings_put_BitmapVirtualCache24BppSize_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [propget][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings_get_BitmapVirtualCache24BppSize_Proxy( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pBitmapVirtualCache24BppSize); + + +void __RPC_STUB IMsRdpClientAdvancedSettings_get_BitmapVirtualCache24BppSize_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [propput][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings_put_PerformanceFlags_Proxy( + IMsRdpClientAdvancedSettings * This, + /* [in] */ long pDisableList); + + +void __RPC_STUB IMsRdpClientAdvancedSettings_put_PerformanceFlags_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [propget][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings_get_PerformanceFlags_Proxy( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ long *pDisableList); + + +void __RPC_STUB IMsRdpClientAdvancedSettings_get_PerformanceFlags_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [propput][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings_put_ConnectWithEndpoint_Proxy( + IMsRdpClientAdvancedSettings * This, + /* [in] */ VARIANT *rhs); + + +void __RPC_STUB IMsRdpClientAdvancedSettings_put_ConnectWithEndpoint_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [propput][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings_put_NotifyTSPublicKey_Proxy( + IMsRdpClientAdvancedSettings * This, + /* [in] */ VARIANT_BOOL pfNotify); + + +void __RPC_STUB IMsRdpClientAdvancedSettings_put_NotifyTSPublicKey_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [propget][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings_get_NotifyTSPublicKey_Proxy( + IMsRdpClientAdvancedSettings * This, + /* [retval][out] */ VARIANT_BOOL *pfNotify); + + +void __RPC_STUB IMsRdpClientAdvancedSettings_get_NotifyTSPublicKey_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IMsRdpClientAdvancedSettings_INTERFACE_DEFINED__ */ + + +#ifndef __IMsRdpClientAdvancedSettings2_INTERFACE_DEFINED__ +#define __IMsRdpClientAdvancedSettings2_INTERFACE_DEFINED__ + +/* interface IMsRdpClientAdvancedSettings2 */ +/* [object][oleautomation][dual][uuid] */ + + +EXTERN_C const IID IID_IMsRdpClientAdvancedSettings2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("9AC42117-2B76-4320-AA44-0E616AB8437B") + IMsRdpClientAdvancedSettings2 : public IMsRdpClientAdvancedSettings + { + public: + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_CanAutoReconnect( + /* [retval][out] */ VARIANT_BOOL *pfCanAutoReconnect) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_EnableAutoReconnect( + /* [in] */ VARIANT_BOOL pfEnableAutoReconnect) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_EnableAutoReconnect( + /* [retval][out] */ VARIANT_BOOL *pfEnableAutoReconnect) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_MaxReconnectAttempts( + /* [in] */ long pMaxReconnectAttempts) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_MaxReconnectAttempts( + /* [retval][out] */ long *pMaxReconnectAttempts) = 0; + + }; + +#else /* C style interface */ + + typedef struct IMsRdpClientAdvancedSettings2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ + __RPC__deref_out void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMsRdpClientAdvancedSettings2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMsRdpClientAdvancedSettings2 * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + IMsRdpClientAdvancedSettings2 * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [range][in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Compress )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pcompress); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Compress )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pcompress); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapPeristence )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pbitmapPeristence); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapPeristence )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pbitmapPeristence); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_allowBackgroundInput )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pallowBackgroundInput); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_allowBackgroundInput )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pallowBackgroundInput); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_KeyBoardLayoutStr )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_PluginDlls )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_IconFile )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_IconIndex )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ContainerHandledFullScreen )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pContainerHandledFullScreen); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ContainerHandledFullScreen )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pContainerHandledFullScreen); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DisableRdpdr )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pDisableRdpdr); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DisableRdpdr )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pDisableRdpdr); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_SmoothScroll )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long psmoothScroll); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SmoothScroll )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *psmoothScroll); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_AcceleratorPassthrough )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pacceleratorPassthrough); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AcceleratorPassthrough )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pacceleratorPassthrough); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ShadowBitmap )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pshadowBitmap); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ShadowBitmap )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pshadowBitmap); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_TransportType )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long ptransportType); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_TransportType )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *ptransportType); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_SasSequence )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long psasSequence); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SasSequence )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *psasSequence); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_EncryptionEnabled )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pencryptionEnabled); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_EncryptionEnabled )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pencryptionEnabled); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DedicatedTerminal )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pdedicatedTerminal); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DedicatedTerminal )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pdedicatedTerminal); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RDPPort )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long prdpPort); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RDPPort )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *prdpPort); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_EnableMouse )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long penableMouse); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_EnableMouse )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *penableMouse); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DisableCtrlAltDel )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pdisableCtrlAltDel); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DisableCtrlAltDel )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pdisableCtrlAltDel); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_EnableWindowsKey )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long penableWindowsKey); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_EnableWindowsKey )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *penableWindowsKey); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DoubleClickDetect )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pdoubleClickDetect); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DoubleClickDetect )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pdoubleClickDetect); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_MaximizeShell )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pmaximizeShell); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_MaximizeShell )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pmaximizeShell); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyFullScreen )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long photKeyFullScreen); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyFullScreen )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *photKeyFullScreen); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyCtrlEsc )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long photKeyCtrlEsc); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyCtrlEsc )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *photKeyCtrlEsc); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyAltEsc )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long photKeyAltEsc); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyAltEsc )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *photKeyAltEsc); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyAltTab )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long photKeyAltTab); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyAltTab )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *photKeyAltTab); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyAltShiftTab )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long photKeyAltShiftTab); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyAltShiftTab )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *photKeyAltShiftTab); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyAltSpace )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long photKeyAltSpace); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyAltSpace )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *photKeyAltSpace); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyCtrlAltDel )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long photKeyCtrlAltDel); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyCtrlAltDel )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *photKeyCtrlAltDel); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_orderDrawThreshold )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long porderDrawThreshold); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_orderDrawThreshold )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *porderDrawThreshold); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapCacheSize )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pbitmapCacheSize); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapCacheSize )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pbitmapCacheSize); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapVirtualCacheSize )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pbitmapVirtualCacheSize); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapVirtualCacheSize )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pbitmapVirtualCacheSize); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ScaleBitmapCachesByBPP )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pbScale); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ScaleBitmapCachesByBPP )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pbScale); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_NumBitmapCaches )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pnumBitmapCaches); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_NumBitmapCaches )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pnumBitmapCaches); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_CachePersistenceActive )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pcachePersistenceActive); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_CachePersistenceActive )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pcachePersistenceActive); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_PersistCacheDirectory )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_brushSupportLevel )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pbrushSupportLevel); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_brushSupportLevel )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pbrushSupportLevel); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_minInputSendInterval )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pminInputSendInterval); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_minInputSendInterval )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pminInputSendInterval); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_InputEventsAtOnce )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pinputEventsAtOnce); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_InputEventsAtOnce )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pinputEventsAtOnce); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_maxEventCount )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pmaxEventCount); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_maxEventCount )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pmaxEventCount); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_keepAliveInterval )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pkeepAliveInterval); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_keepAliveInterval )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pkeepAliveInterval); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_shutdownTimeout )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pshutdownTimeout); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_shutdownTimeout )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pshutdownTimeout); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_overallConnectionTimeout )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long poverallConnectionTimeout); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_overallConnectionTimeout )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *poverallConnectionTimeout); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_singleConnectionTimeout )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long psingleConnectionTimeout); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_singleConnectionTimeout )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *psingleConnectionTimeout); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_KeyboardType )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pkeyboardType); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_KeyboardType )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pkeyboardType); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_KeyboardSubType )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pkeyboardSubType); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_KeyboardSubType )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pkeyboardSubType); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_KeyboardFunctionKey )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pkeyboardFunctionKey); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_KeyboardFunctionKey )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pkeyboardFunctionKey); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_WinceFixedPalette )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pwinceFixedPalette); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_WinceFixedPalette )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pwinceFixedPalette); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ConnectToServerConsole )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ VARIANT_BOOL pConnectToConsole); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ConnectToServerConsole )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ VARIANT_BOOL *pConnectToConsole); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapPersistence )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pbitmapPersistence); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapPersistence )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pbitmapPersistence); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_MinutesToIdleTimeout )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pminutesToIdleTimeout); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_MinutesToIdleTimeout )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pminutesToIdleTimeout); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_SmartSizing )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ VARIANT_BOOL pfSmartSizing); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SmartSizing )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ VARIANT_BOOL *pfSmartSizing); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RdpdrLocalPrintingDocName )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ BSTR pLocalPrintingDocName); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RdpdrLocalPrintingDocName )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ BSTR *pLocalPrintingDocName); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RdpdrClipCleanTempDirString )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ BSTR clipCleanTempDirString); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RdpdrClipCleanTempDirString )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ BSTR *clipCleanTempDirString); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RdpdrClipPasteInfoString )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ BSTR clipPasteInfoString); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RdpdrClipPasteInfoString )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ BSTR *clipPasteInfoString); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ClearTextPassword )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DisplayConnectionBar )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ VARIANT_BOOL pDisplayConnectionBar); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DisplayConnectionBar )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ VARIANT_BOOL *pDisplayConnectionBar); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_PinConnectionBar )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ VARIANT_BOOL pPinConnectionBar); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_PinConnectionBar )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ VARIANT_BOOL *pPinConnectionBar); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_GrabFocusOnConnect )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ VARIANT_BOOL pfGrabFocusOnConnect); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_GrabFocusOnConnect )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ VARIANT_BOOL *pfGrabFocusOnConnect); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_LoadBalanceInfo )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ BSTR pLBInfo); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_LoadBalanceInfo )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ BSTR *pLBInfo); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RedirectDrives )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ VARIANT_BOOL pRedirectDrives); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RedirectDrives )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ VARIANT_BOOL *pRedirectDrives); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RedirectPrinters )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ VARIANT_BOOL pRedirectPrinters); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RedirectPrinters )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ VARIANT_BOOL *pRedirectPrinters); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RedirectPorts )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ VARIANT_BOOL pRedirectPorts); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RedirectPorts )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ VARIANT_BOOL *pRedirectPorts); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RedirectSmartCards )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ VARIANT_BOOL pRedirectSmartCards); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RedirectSmartCards )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ VARIANT_BOOL *pRedirectSmartCards); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapVirtualCache16BppSize )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pBitmapVirtualCache16BppSize); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapVirtualCache16BppSize )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pBitmapVirtualCache16BppSize); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapVirtualCache24BppSize )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pBitmapVirtualCache24BppSize); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapVirtualCache24BppSize )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pBitmapVirtualCache24BppSize); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_PerformanceFlags )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pDisableList); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_PerformanceFlags )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pDisableList); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ConnectWithEndpoint )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ VARIANT *rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_NotifyTSPublicKey )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ VARIANT_BOOL pfNotify); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_NotifyTSPublicKey )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ VARIANT_BOOL *pfNotify); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_CanAutoReconnect )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ VARIANT_BOOL *pfCanAutoReconnect); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_EnableAutoReconnect )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ VARIANT_BOOL pfEnableAutoReconnect); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_EnableAutoReconnect )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ VARIANT_BOOL *pfEnableAutoReconnect); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_MaxReconnectAttempts )( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pMaxReconnectAttempts); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_MaxReconnectAttempts )( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pMaxReconnectAttempts); + + END_INTERFACE + } IMsRdpClientAdvancedSettings2Vtbl; + + interface IMsRdpClientAdvancedSettings2 + { + CONST_VTBL struct IMsRdpClientAdvancedSettings2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMsRdpClientAdvancedSettings2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMsRdpClientAdvancedSettings2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMsRdpClientAdvancedSettings2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMsRdpClientAdvancedSettings2_GetTypeInfoCount(This,pctinfo) \ + ( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) ) + +#define IMsRdpClientAdvancedSettings2_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + ( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) ) + +#define IMsRdpClientAdvancedSettings2_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + ( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ) + +#define IMsRdpClientAdvancedSettings2_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + ( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ) + + +#define IMsRdpClientAdvancedSettings2_put_Compress(This,pcompress) \ + ( (This)->lpVtbl -> put_Compress(This,pcompress) ) + +#define IMsRdpClientAdvancedSettings2_get_Compress(This,pcompress) \ + ( (This)->lpVtbl -> get_Compress(This,pcompress) ) + +#define IMsRdpClientAdvancedSettings2_put_BitmapPeristence(This,pbitmapPeristence) \ + ( (This)->lpVtbl -> put_BitmapPeristence(This,pbitmapPeristence) ) + +#define IMsRdpClientAdvancedSettings2_get_BitmapPeristence(This,pbitmapPeristence) \ + ( (This)->lpVtbl -> get_BitmapPeristence(This,pbitmapPeristence) ) + +#define IMsRdpClientAdvancedSettings2_put_allowBackgroundInput(This,pallowBackgroundInput) \ + ( (This)->lpVtbl -> put_allowBackgroundInput(This,pallowBackgroundInput) ) + +#define IMsRdpClientAdvancedSettings2_get_allowBackgroundInput(This,pallowBackgroundInput) \ + ( (This)->lpVtbl -> get_allowBackgroundInput(This,pallowBackgroundInput) ) + +#define IMsRdpClientAdvancedSettings2_put_KeyBoardLayoutStr(This,rhs) \ + ( (This)->lpVtbl -> put_KeyBoardLayoutStr(This,rhs) ) + +#define IMsRdpClientAdvancedSettings2_put_PluginDlls(This,rhs) \ + ( (This)->lpVtbl -> put_PluginDlls(This,rhs) ) + +#define IMsRdpClientAdvancedSettings2_put_IconFile(This,rhs) \ + ( (This)->lpVtbl -> put_IconFile(This,rhs) ) + +#define IMsRdpClientAdvancedSettings2_put_IconIndex(This,rhs) \ + ( (This)->lpVtbl -> put_IconIndex(This,rhs) ) + +#define IMsRdpClientAdvancedSettings2_put_ContainerHandledFullScreen(This,pContainerHandledFullScreen) \ + ( (This)->lpVtbl -> put_ContainerHandledFullScreen(This,pContainerHandledFullScreen) ) + +#define IMsRdpClientAdvancedSettings2_get_ContainerHandledFullScreen(This,pContainerHandledFullScreen) \ + ( (This)->lpVtbl -> get_ContainerHandledFullScreen(This,pContainerHandledFullScreen) ) + +#define IMsRdpClientAdvancedSettings2_put_DisableRdpdr(This,pDisableRdpdr) \ + ( (This)->lpVtbl -> put_DisableRdpdr(This,pDisableRdpdr) ) + +#define IMsRdpClientAdvancedSettings2_get_DisableRdpdr(This,pDisableRdpdr) \ + ( (This)->lpVtbl -> get_DisableRdpdr(This,pDisableRdpdr) ) + + +#define IMsRdpClientAdvancedSettings2_put_SmoothScroll(This,psmoothScroll) \ + ( (This)->lpVtbl -> put_SmoothScroll(This,psmoothScroll) ) + +#define IMsRdpClientAdvancedSettings2_get_SmoothScroll(This,psmoothScroll) \ + ( (This)->lpVtbl -> get_SmoothScroll(This,psmoothScroll) ) + +#define IMsRdpClientAdvancedSettings2_put_AcceleratorPassthrough(This,pacceleratorPassthrough) \ + ( (This)->lpVtbl -> put_AcceleratorPassthrough(This,pacceleratorPassthrough) ) + +#define IMsRdpClientAdvancedSettings2_get_AcceleratorPassthrough(This,pacceleratorPassthrough) \ + ( (This)->lpVtbl -> get_AcceleratorPassthrough(This,pacceleratorPassthrough) ) + +#define IMsRdpClientAdvancedSettings2_put_ShadowBitmap(This,pshadowBitmap) \ + ( (This)->lpVtbl -> put_ShadowBitmap(This,pshadowBitmap) ) + +#define IMsRdpClientAdvancedSettings2_get_ShadowBitmap(This,pshadowBitmap) \ + ( (This)->lpVtbl -> get_ShadowBitmap(This,pshadowBitmap) ) + +#define IMsRdpClientAdvancedSettings2_put_TransportType(This,ptransportType) \ + ( (This)->lpVtbl -> put_TransportType(This,ptransportType) ) + +#define IMsRdpClientAdvancedSettings2_get_TransportType(This,ptransportType) \ + ( (This)->lpVtbl -> get_TransportType(This,ptransportType) ) + +#define IMsRdpClientAdvancedSettings2_put_SasSequence(This,psasSequence) \ + ( (This)->lpVtbl -> put_SasSequence(This,psasSequence) ) + +#define IMsRdpClientAdvancedSettings2_get_SasSequence(This,psasSequence) \ + ( (This)->lpVtbl -> get_SasSequence(This,psasSequence) ) + +#define IMsRdpClientAdvancedSettings2_put_EncryptionEnabled(This,pencryptionEnabled) \ + ( (This)->lpVtbl -> put_EncryptionEnabled(This,pencryptionEnabled) ) + +#define IMsRdpClientAdvancedSettings2_get_EncryptionEnabled(This,pencryptionEnabled) \ + ( (This)->lpVtbl -> get_EncryptionEnabled(This,pencryptionEnabled) ) + +#define IMsRdpClientAdvancedSettings2_put_DedicatedTerminal(This,pdedicatedTerminal) \ + ( (This)->lpVtbl -> put_DedicatedTerminal(This,pdedicatedTerminal) ) + +#define IMsRdpClientAdvancedSettings2_get_DedicatedTerminal(This,pdedicatedTerminal) \ + ( (This)->lpVtbl -> get_DedicatedTerminal(This,pdedicatedTerminal) ) + +#define IMsRdpClientAdvancedSettings2_put_RDPPort(This,prdpPort) \ + ( (This)->lpVtbl -> put_RDPPort(This,prdpPort) ) + +#define IMsRdpClientAdvancedSettings2_get_RDPPort(This,prdpPort) \ + ( (This)->lpVtbl -> get_RDPPort(This,prdpPort) ) + +#define IMsRdpClientAdvancedSettings2_put_EnableMouse(This,penableMouse) \ + ( (This)->lpVtbl -> put_EnableMouse(This,penableMouse) ) + +#define IMsRdpClientAdvancedSettings2_get_EnableMouse(This,penableMouse) \ + ( (This)->lpVtbl -> get_EnableMouse(This,penableMouse) ) + +#define IMsRdpClientAdvancedSettings2_put_DisableCtrlAltDel(This,pdisableCtrlAltDel) \ + ( (This)->lpVtbl -> put_DisableCtrlAltDel(This,pdisableCtrlAltDel) ) + +#define IMsRdpClientAdvancedSettings2_get_DisableCtrlAltDel(This,pdisableCtrlAltDel) \ + ( (This)->lpVtbl -> get_DisableCtrlAltDel(This,pdisableCtrlAltDel) ) + +#define IMsRdpClientAdvancedSettings2_put_EnableWindowsKey(This,penableWindowsKey) \ + ( (This)->lpVtbl -> put_EnableWindowsKey(This,penableWindowsKey) ) + +#define IMsRdpClientAdvancedSettings2_get_EnableWindowsKey(This,penableWindowsKey) \ + ( (This)->lpVtbl -> get_EnableWindowsKey(This,penableWindowsKey) ) + +#define IMsRdpClientAdvancedSettings2_put_DoubleClickDetect(This,pdoubleClickDetect) \ + ( (This)->lpVtbl -> put_DoubleClickDetect(This,pdoubleClickDetect) ) + +#define IMsRdpClientAdvancedSettings2_get_DoubleClickDetect(This,pdoubleClickDetect) \ + ( (This)->lpVtbl -> get_DoubleClickDetect(This,pdoubleClickDetect) ) + +#define IMsRdpClientAdvancedSettings2_put_MaximizeShell(This,pmaximizeShell) \ + ( (This)->lpVtbl -> put_MaximizeShell(This,pmaximizeShell) ) + +#define IMsRdpClientAdvancedSettings2_get_MaximizeShell(This,pmaximizeShell) \ + ( (This)->lpVtbl -> get_MaximizeShell(This,pmaximizeShell) ) + +#define IMsRdpClientAdvancedSettings2_put_HotKeyFullScreen(This,photKeyFullScreen) \ + ( (This)->lpVtbl -> put_HotKeyFullScreen(This,photKeyFullScreen) ) + +#define IMsRdpClientAdvancedSettings2_get_HotKeyFullScreen(This,photKeyFullScreen) \ + ( (This)->lpVtbl -> get_HotKeyFullScreen(This,photKeyFullScreen) ) + +#define IMsRdpClientAdvancedSettings2_put_HotKeyCtrlEsc(This,photKeyCtrlEsc) \ + ( (This)->lpVtbl -> put_HotKeyCtrlEsc(This,photKeyCtrlEsc) ) + +#define IMsRdpClientAdvancedSettings2_get_HotKeyCtrlEsc(This,photKeyCtrlEsc) \ + ( (This)->lpVtbl -> get_HotKeyCtrlEsc(This,photKeyCtrlEsc) ) + +#define IMsRdpClientAdvancedSettings2_put_HotKeyAltEsc(This,photKeyAltEsc) \ + ( (This)->lpVtbl -> put_HotKeyAltEsc(This,photKeyAltEsc) ) + +#define IMsRdpClientAdvancedSettings2_get_HotKeyAltEsc(This,photKeyAltEsc) \ + ( (This)->lpVtbl -> get_HotKeyAltEsc(This,photKeyAltEsc) ) + +#define IMsRdpClientAdvancedSettings2_put_HotKeyAltTab(This,photKeyAltTab) \ + ( (This)->lpVtbl -> put_HotKeyAltTab(This,photKeyAltTab) ) + +#define IMsRdpClientAdvancedSettings2_get_HotKeyAltTab(This,photKeyAltTab) \ + ( (This)->lpVtbl -> get_HotKeyAltTab(This,photKeyAltTab) ) + +#define IMsRdpClientAdvancedSettings2_put_HotKeyAltShiftTab(This,photKeyAltShiftTab) \ + ( (This)->lpVtbl -> put_HotKeyAltShiftTab(This,photKeyAltShiftTab) ) + +#define IMsRdpClientAdvancedSettings2_get_HotKeyAltShiftTab(This,photKeyAltShiftTab) \ + ( (This)->lpVtbl -> get_HotKeyAltShiftTab(This,photKeyAltShiftTab) ) + +#define IMsRdpClientAdvancedSettings2_put_HotKeyAltSpace(This,photKeyAltSpace) \ + ( (This)->lpVtbl -> put_HotKeyAltSpace(This,photKeyAltSpace) ) + +#define IMsRdpClientAdvancedSettings2_get_HotKeyAltSpace(This,photKeyAltSpace) \ + ( (This)->lpVtbl -> get_HotKeyAltSpace(This,photKeyAltSpace) ) + +#define IMsRdpClientAdvancedSettings2_put_HotKeyCtrlAltDel(This,photKeyCtrlAltDel) \ + ( (This)->lpVtbl -> put_HotKeyCtrlAltDel(This,photKeyCtrlAltDel) ) + +#define IMsRdpClientAdvancedSettings2_get_HotKeyCtrlAltDel(This,photKeyCtrlAltDel) \ + ( (This)->lpVtbl -> get_HotKeyCtrlAltDel(This,photKeyCtrlAltDel) ) + +#define IMsRdpClientAdvancedSettings2_put_orderDrawThreshold(This,porderDrawThreshold) \ + ( (This)->lpVtbl -> put_orderDrawThreshold(This,porderDrawThreshold) ) + +#define IMsRdpClientAdvancedSettings2_get_orderDrawThreshold(This,porderDrawThreshold) \ + ( (This)->lpVtbl -> get_orderDrawThreshold(This,porderDrawThreshold) ) + +#define IMsRdpClientAdvancedSettings2_put_BitmapCacheSize(This,pbitmapCacheSize) \ + ( (This)->lpVtbl -> put_BitmapCacheSize(This,pbitmapCacheSize) ) + +#define IMsRdpClientAdvancedSettings2_get_BitmapCacheSize(This,pbitmapCacheSize) \ + ( (This)->lpVtbl -> get_BitmapCacheSize(This,pbitmapCacheSize) ) + +#define IMsRdpClientAdvancedSettings2_put_BitmapVirtualCacheSize(This,pbitmapVirtualCacheSize) \ + ( (This)->lpVtbl -> put_BitmapVirtualCacheSize(This,pbitmapVirtualCacheSize) ) + +#define IMsRdpClientAdvancedSettings2_get_BitmapVirtualCacheSize(This,pbitmapVirtualCacheSize) \ + ( (This)->lpVtbl -> get_BitmapVirtualCacheSize(This,pbitmapVirtualCacheSize) ) + +#define IMsRdpClientAdvancedSettings2_put_ScaleBitmapCachesByBPP(This,pbScale) \ + ( (This)->lpVtbl -> put_ScaleBitmapCachesByBPP(This,pbScale) ) + +#define IMsRdpClientAdvancedSettings2_get_ScaleBitmapCachesByBPP(This,pbScale) \ + ( (This)->lpVtbl -> get_ScaleBitmapCachesByBPP(This,pbScale) ) + +#define IMsRdpClientAdvancedSettings2_put_NumBitmapCaches(This,pnumBitmapCaches) \ + ( (This)->lpVtbl -> put_NumBitmapCaches(This,pnumBitmapCaches) ) + +#define IMsRdpClientAdvancedSettings2_get_NumBitmapCaches(This,pnumBitmapCaches) \ + ( (This)->lpVtbl -> get_NumBitmapCaches(This,pnumBitmapCaches) ) + +#define IMsRdpClientAdvancedSettings2_put_CachePersistenceActive(This,pcachePersistenceActive) \ + ( (This)->lpVtbl -> put_CachePersistenceActive(This,pcachePersistenceActive) ) + +#define IMsRdpClientAdvancedSettings2_get_CachePersistenceActive(This,pcachePersistenceActive) \ + ( (This)->lpVtbl -> get_CachePersistenceActive(This,pcachePersistenceActive) ) + +#define IMsRdpClientAdvancedSettings2_put_PersistCacheDirectory(This,rhs) \ + ( (This)->lpVtbl -> put_PersistCacheDirectory(This,rhs) ) + +#define IMsRdpClientAdvancedSettings2_put_brushSupportLevel(This,pbrushSupportLevel) \ + ( (This)->lpVtbl -> put_brushSupportLevel(This,pbrushSupportLevel) ) + +#define IMsRdpClientAdvancedSettings2_get_brushSupportLevel(This,pbrushSupportLevel) \ + ( (This)->lpVtbl -> get_brushSupportLevel(This,pbrushSupportLevel) ) + +#define IMsRdpClientAdvancedSettings2_put_minInputSendInterval(This,pminInputSendInterval) \ + ( (This)->lpVtbl -> put_minInputSendInterval(This,pminInputSendInterval) ) + +#define IMsRdpClientAdvancedSettings2_get_minInputSendInterval(This,pminInputSendInterval) \ + ( (This)->lpVtbl -> get_minInputSendInterval(This,pminInputSendInterval) ) + +#define IMsRdpClientAdvancedSettings2_put_InputEventsAtOnce(This,pinputEventsAtOnce) \ + ( (This)->lpVtbl -> put_InputEventsAtOnce(This,pinputEventsAtOnce) ) + +#define IMsRdpClientAdvancedSettings2_get_InputEventsAtOnce(This,pinputEventsAtOnce) \ + ( (This)->lpVtbl -> get_InputEventsAtOnce(This,pinputEventsAtOnce) ) + +#define IMsRdpClientAdvancedSettings2_put_maxEventCount(This,pmaxEventCount) \ + ( (This)->lpVtbl -> put_maxEventCount(This,pmaxEventCount) ) + +#define IMsRdpClientAdvancedSettings2_get_maxEventCount(This,pmaxEventCount) \ + ( (This)->lpVtbl -> get_maxEventCount(This,pmaxEventCount) ) + +#define IMsRdpClientAdvancedSettings2_put_keepAliveInterval(This,pkeepAliveInterval) \ + ( (This)->lpVtbl -> put_keepAliveInterval(This,pkeepAliveInterval) ) + +#define IMsRdpClientAdvancedSettings2_get_keepAliveInterval(This,pkeepAliveInterval) \ + ( (This)->lpVtbl -> get_keepAliveInterval(This,pkeepAliveInterval) ) + +#define IMsRdpClientAdvancedSettings2_put_shutdownTimeout(This,pshutdownTimeout) \ + ( (This)->lpVtbl -> put_shutdownTimeout(This,pshutdownTimeout) ) + +#define IMsRdpClientAdvancedSettings2_get_shutdownTimeout(This,pshutdownTimeout) \ + ( (This)->lpVtbl -> get_shutdownTimeout(This,pshutdownTimeout) ) + +#define IMsRdpClientAdvancedSettings2_put_overallConnectionTimeout(This,poverallConnectionTimeout) \ + ( (This)->lpVtbl -> put_overallConnectionTimeout(This,poverallConnectionTimeout) ) + +#define IMsRdpClientAdvancedSettings2_get_overallConnectionTimeout(This,poverallConnectionTimeout) \ + ( (This)->lpVtbl -> get_overallConnectionTimeout(This,poverallConnectionTimeout) ) + +#define IMsRdpClientAdvancedSettings2_put_singleConnectionTimeout(This,psingleConnectionTimeout) \ + ( (This)->lpVtbl -> put_singleConnectionTimeout(This,psingleConnectionTimeout) ) + +#define IMsRdpClientAdvancedSettings2_get_singleConnectionTimeout(This,psingleConnectionTimeout) \ + ( (This)->lpVtbl -> get_singleConnectionTimeout(This,psingleConnectionTimeout) ) + +#define IMsRdpClientAdvancedSettings2_put_KeyboardType(This,pkeyboardType) \ + ( (This)->lpVtbl -> put_KeyboardType(This,pkeyboardType) ) + +#define IMsRdpClientAdvancedSettings2_get_KeyboardType(This,pkeyboardType) \ + ( (This)->lpVtbl -> get_KeyboardType(This,pkeyboardType) ) + +#define IMsRdpClientAdvancedSettings2_put_KeyboardSubType(This,pkeyboardSubType) \ + ( (This)->lpVtbl -> put_KeyboardSubType(This,pkeyboardSubType) ) + +#define IMsRdpClientAdvancedSettings2_get_KeyboardSubType(This,pkeyboardSubType) \ + ( (This)->lpVtbl -> get_KeyboardSubType(This,pkeyboardSubType) ) + +#define IMsRdpClientAdvancedSettings2_put_KeyboardFunctionKey(This,pkeyboardFunctionKey) \ + ( (This)->lpVtbl -> put_KeyboardFunctionKey(This,pkeyboardFunctionKey) ) + +#define IMsRdpClientAdvancedSettings2_get_KeyboardFunctionKey(This,pkeyboardFunctionKey) \ + ( (This)->lpVtbl -> get_KeyboardFunctionKey(This,pkeyboardFunctionKey) ) + +#define IMsRdpClientAdvancedSettings2_put_WinceFixedPalette(This,pwinceFixedPalette) \ + ( (This)->lpVtbl -> put_WinceFixedPalette(This,pwinceFixedPalette) ) + +#define IMsRdpClientAdvancedSettings2_get_WinceFixedPalette(This,pwinceFixedPalette) \ + ( (This)->lpVtbl -> get_WinceFixedPalette(This,pwinceFixedPalette) ) + +#define IMsRdpClientAdvancedSettings2_put_ConnectToServerConsole(This,pConnectToConsole) \ + ( (This)->lpVtbl -> put_ConnectToServerConsole(This,pConnectToConsole) ) + +#define IMsRdpClientAdvancedSettings2_get_ConnectToServerConsole(This,pConnectToConsole) \ + ( (This)->lpVtbl -> get_ConnectToServerConsole(This,pConnectToConsole) ) + +#define IMsRdpClientAdvancedSettings2_put_BitmapPersistence(This,pbitmapPersistence) \ + ( (This)->lpVtbl -> put_BitmapPersistence(This,pbitmapPersistence) ) + +#define IMsRdpClientAdvancedSettings2_get_BitmapPersistence(This,pbitmapPersistence) \ + ( (This)->lpVtbl -> get_BitmapPersistence(This,pbitmapPersistence) ) + +#define IMsRdpClientAdvancedSettings2_put_MinutesToIdleTimeout(This,pminutesToIdleTimeout) \ + ( (This)->lpVtbl -> put_MinutesToIdleTimeout(This,pminutesToIdleTimeout) ) + +#define IMsRdpClientAdvancedSettings2_get_MinutesToIdleTimeout(This,pminutesToIdleTimeout) \ + ( (This)->lpVtbl -> get_MinutesToIdleTimeout(This,pminutesToIdleTimeout) ) + +#define IMsRdpClientAdvancedSettings2_put_SmartSizing(This,pfSmartSizing) \ + ( (This)->lpVtbl -> put_SmartSizing(This,pfSmartSizing) ) + +#define IMsRdpClientAdvancedSettings2_get_SmartSizing(This,pfSmartSizing) \ + ( (This)->lpVtbl -> get_SmartSizing(This,pfSmartSizing) ) + +#define IMsRdpClientAdvancedSettings2_put_RdpdrLocalPrintingDocName(This,pLocalPrintingDocName) \ + ( (This)->lpVtbl -> put_RdpdrLocalPrintingDocName(This,pLocalPrintingDocName) ) + +#define IMsRdpClientAdvancedSettings2_get_RdpdrLocalPrintingDocName(This,pLocalPrintingDocName) \ + ( (This)->lpVtbl -> get_RdpdrLocalPrintingDocName(This,pLocalPrintingDocName) ) + +#define IMsRdpClientAdvancedSettings2_put_RdpdrClipCleanTempDirString(This,clipCleanTempDirString) \ + ( (This)->lpVtbl -> put_RdpdrClipCleanTempDirString(This,clipCleanTempDirString) ) + +#define IMsRdpClientAdvancedSettings2_get_RdpdrClipCleanTempDirString(This,clipCleanTempDirString) \ + ( (This)->lpVtbl -> get_RdpdrClipCleanTempDirString(This,clipCleanTempDirString) ) + +#define IMsRdpClientAdvancedSettings2_put_RdpdrClipPasteInfoString(This,clipPasteInfoString) \ + ( (This)->lpVtbl -> put_RdpdrClipPasteInfoString(This,clipPasteInfoString) ) + +#define IMsRdpClientAdvancedSettings2_get_RdpdrClipPasteInfoString(This,clipPasteInfoString) \ + ( (This)->lpVtbl -> get_RdpdrClipPasteInfoString(This,clipPasteInfoString) ) + +#define IMsRdpClientAdvancedSettings2_put_ClearTextPassword(This,rhs) \ + ( (This)->lpVtbl -> put_ClearTextPassword(This,rhs) ) + +#define IMsRdpClientAdvancedSettings2_put_DisplayConnectionBar(This,pDisplayConnectionBar) \ + ( (This)->lpVtbl -> put_DisplayConnectionBar(This,pDisplayConnectionBar) ) + +#define IMsRdpClientAdvancedSettings2_get_DisplayConnectionBar(This,pDisplayConnectionBar) \ + ( (This)->lpVtbl -> get_DisplayConnectionBar(This,pDisplayConnectionBar) ) + +#define IMsRdpClientAdvancedSettings2_put_PinConnectionBar(This,pPinConnectionBar) \ + ( (This)->lpVtbl -> put_PinConnectionBar(This,pPinConnectionBar) ) + +#define IMsRdpClientAdvancedSettings2_get_PinConnectionBar(This,pPinConnectionBar) \ + ( (This)->lpVtbl -> get_PinConnectionBar(This,pPinConnectionBar) ) + +#define IMsRdpClientAdvancedSettings2_put_GrabFocusOnConnect(This,pfGrabFocusOnConnect) \ + ( (This)->lpVtbl -> put_GrabFocusOnConnect(This,pfGrabFocusOnConnect) ) + +#define IMsRdpClientAdvancedSettings2_get_GrabFocusOnConnect(This,pfGrabFocusOnConnect) \ + ( (This)->lpVtbl -> get_GrabFocusOnConnect(This,pfGrabFocusOnConnect) ) + +#define IMsRdpClientAdvancedSettings2_put_LoadBalanceInfo(This,pLBInfo) \ + ( (This)->lpVtbl -> put_LoadBalanceInfo(This,pLBInfo) ) + +#define IMsRdpClientAdvancedSettings2_get_LoadBalanceInfo(This,pLBInfo) \ + ( (This)->lpVtbl -> get_LoadBalanceInfo(This,pLBInfo) ) + +#define IMsRdpClientAdvancedSettings2_put_RedirectDrives(This,pRedirectDrives) \ + ( (This)->lpVtbl -> put_RedirectDrives(This,pRedirectDrives) ) + +#define IMsRdpClientAdvancedSettings2_get_RedirectDrives(This,pRedirectDrives) \ + ( (This)->lpVtbl -> get_RedirectDrives(This,pRedirectDrives) ) + +#define IMsRdpClientAdvancedSettings2_put_RedirectPrinters(This,pRedirectPrinters) \ + ( (This)->lpVtbl -> put_RedirectPrinters(This,pRedirectPrinters) ) + +#define IMsRdpClientAdvancedSettings2_get_RedirectPrinters(This,pRedirectPrinters) \ + ( (This)->lpVtbl -> get_RedirectPrinters(This,pRedirectPrinters) ) + +#define IMsRdpClientAdvancedSettings2_put_RedirectPorts(This,pRedirectPorts) \ + ( (This)->lpVtbl -> put_RedirectPorts(This,pRedirectPorts) ) + +#define IMsRdpClientAdvancedSettings2_get_RedirectPorts(This,pRedirectPorts) \ + ( (This)->lpVtbl -> get_RedirectPorts(This,pRedirectPorts) ) + +#define IMsRdpClientAdvancedSettings2_put_RedirectSmartCards(This,pRedirectSmartCards) \ + ( (This)->lpVtbl -> put_RedirectSmartCards(This,pRedirectSmartCards) ) + +#define IMsRdpClientAdvancedSettings2_get_RedirectSmartCards(This,pRedirectSmartCards) \ + ( (This)->lpVtbl -> get_RedirectSmartCards(This,pRedirectSmartCards) ) + +#define IMsRdpClientAdvancedSettings2_put_BitmapVirtualCache16BppSize(This,pBitmapVirtualCache16BppSize) \ + ( (This)->lpVtbl -> put_BitmapVirtualCache16BppSize(This,pBitmapVirtualCache16BppSize) ) + +#define IMsRdpClientAdvancedSettings2_get_BitmapVirtualCache16BppSize(This,pBitmapVirtualCache16BppSize) \ + ( (This)->lpVtbl -> get_BitmapVirtualCache16BppSize(This,pBitmapVirtualCache16BppSize) ) + +#define IMsRdpClientAdvancedSettings2_put_BitmapVirtualCache24BppSize(This,pBitmapVirtualCache24BppSize) \ + ( (This)->lpVtbl -> put_BitmapVirtualCache24BppSize(This,pBitmapVirtualCache24BppSize) ) + +#define IMsRdpClientAdvancedSettings2_get_BitmapVirtualCache24BppSize(This,pBitmapVirtualCache24BppSize) \ + ( (This)->lpVtbl -> get_BitmapVirtualCache24BppSize(This,pBitmapVirtualCache24BppSize) ) + +#define IMsRdpClientAdvancedSettings2_put_PerformanceFlags(This,pDisableList) \ + ( (This)->lpVtbl -> put_PerformanceFlags(This,pDisableList) ) + +#define IMsRdpClientAdvancedSettings2_get_PerformanceFlags(This,pDisableList) \ + ( (This)->lpVtbl -> get_PerformanceFlags(This,pDisableList) ) + +#define IMsRdpClientAdvancedSettings2_put_ConnectWithEndpoint(This,rhs) \ + ( (This)->lpVtbl -> put_ConnectWithEndpoint(This,rhs) ) + +#define IMsRdpClientAdvancedSettings2_put_NotifyTSPublicKey(This,pfNotify) \ + ( (This)->lpVtbl -> put_NotifyTSPublicKey(This,pfNotify) ) + +#define IMsRdpClientAdvancedSettings2_get_NotifyTSPublicKey(This,pfNotify) \ + ( (This)->lpVtbl -> get_NotifyTSPublicKey(This,pfNotify) ) + + +#define IMsRdpClientAdvancedSettings2_get_CanAutoReconnect(This,pfCanAutoReconnect) \ + ( (This)->lpVtbl -> get_CanAutoReconnect(This,pfCanAutoReconnect) ) + +#define IMsRdpClientAdvancedSettings2_put_EnableAutoReconnect(This,pfEnableAutoReconnect) \ + ( (This)->lpVtbl -> put_EnableAutoReconnect(This,pfEnableAutoReconnect) ) + +#define IMsRdpClientAdvancedSettings2_get_EnableAutoReconnect(This,pfEnableAutoReconnect) \ + ( (This)->lpVtbl -> get_EnableAutoReconnect(This,pfEnableAutoReconnect) ) + +#define IMsRdpClientAdvancedSettings2_put_MaxReconnectAttempts(This,pMaxReconnectAttempts) \ + ( (This)->lpVtbl -> put_MaxReconnectAttempts(This,pMaxReconnectAttempts) ) + +#define IMsRdpClientAdvancedSettings2_get_MaxReconnectAttempts(This,pMaxReconnectAttempts) \ + ( (This)->lpVtbl -> get_MaxReconnectAttempts(This,pMaxReconnectAttempts) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [propget][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings2_get_CanAutoReconnect_Proxy( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ VARIANT_BOOL *pfCanAutoReconnect); + + +void __RPC_STUB IMsRdpClientAdvancedSettings2_get_CanAutoReconnect_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [propput][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings2_put_EnableAutoReconnect_Proxy( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ VARIANT_BOOL pfEnableAutoReconnect); + + +void __RPC_STUB IMsRdpClientAdvancedSettings2_put_EnableAutoReconnect_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [propget][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings2_get_EnableAutoReconnect_Proxy( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ VARIANT_BOOL *pfEnableAutoReconnect); + + +void __RPC_STUB IMsRdpClientAdvancedSettings2_get_EnableAutoReconnect_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [propput][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings2_put_MaxReconnectAttempts_Proxy( + IMsRdpClientAdvancedSettings2 * This, + /* [in] */ long pMaxReconnectAttempts); + + +void __RPC_STUB IMsRdpClientAdvancedSettings2_put_MaxReconnectAttempts_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [propget][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings2_get_MaxReconnectAttempts_Proxy( + IMsRdpClientAdvancedSettings2 * This, + /* [retval][out] */ long *pMaxReconnectAttempts); + + +void __RPC_STUB IMsRdpClientAdvancedSettings2_get_MaxReconnectAttempts_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IMsRdpClientAdvancedSettings2_INTERFACE_DEFINED__ */ + + +#ifndef __IMsRdpClientAdvancedSettings3_INTERFACE_DEFINED__ +#define __IMsRdpClientAdvancedSettings3_INTERFACE_DEFINED__ + +/* interface IMsRdpClientAdvancedSettings3 */ +/* [object][oleautomation][dual][uuid] */ + + +EXTERN_C const IID IID_IMsRdpClientAdvancedSettings3; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("19CD856B-C542-4C53-ACEE-F127E3BE1A59") + IMsRdpClientAdvancedSettings3 : public IMsRdpClientAdvancedSettings2 + { + public: + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_ConnectionBarShowMinimizeButton( + /* [in] */ VARIANT_BOOL pfShowMinimize) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_ConnectionBarShowMinimizeButton( + /* [retval][out] */ VARIANT_BOOL *pfShowMinimize) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_ConnectionBarShowRestoreButton( + /* [in] */ VARIANT_BOOL pfShowRestore) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_ConnectionBarShowRestoreButton( + /* [retval][out] */ VARIANT_BOOL *pfShowRestore) = 0; + + }; + +#else /* C style interface */ + + typedef struct IMsRdpClientAdvancedSettings3Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ + __RPC__deref_out void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMsRdpClientAdvancedSettings3 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMsRdpClientAdvancedSettings3 * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + IMsRdpClientAdvancedSettings3 * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [range][in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Compress )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pcompress); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Compress )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pcompress); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapPeristence )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pbitmapPeristence); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapPeristence )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pbitmapPeristence); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_allowBackgroundInput )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pallowBackgroundInput); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_allowBackgroundInput )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pallowBackgroundInput); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_KeyBoardLayoutStr )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_PluginDlls )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_IconFile )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_IconIndex )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ContainerHandledFullScreen )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pContainerHandledFullScreen); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ContainerHandledFullScreen )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pContainerHandledFullScreen); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DisableRdpdr )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pDisableRdpdr); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DisableRdpdr )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pDisableRdpdr); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_SmoothScroll )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long psmoothScroll); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SmoothScroll )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *psmoothScroll); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_AcceleratorPassthrough )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pacceleratorPassthrough); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AcceleratorPassthrough )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pacceleratorPassthrough); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ShadowBitmap )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pshadowBitmap); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ShadowBitmap )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pshadowBitmap); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_TransportType )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long ptransportType); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_TransportType )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *ptransportType); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_SasSequence )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long psasSequence); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SasSequence )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *psasSequence); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_EncryptionEnabled )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pencryptionEnabled); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_EncryptionEnabled )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pencryptionEnabled); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DedicatedTerminal )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pdedicatedTerminal); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DedicatedTerminal )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pdedicatedTerminal); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RDPPort )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long prdpPort); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RDPPort )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *prdpPort); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_EnableMouse )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long penableMouse); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_EnableMouse )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *penableMouse); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DisableCtrlAltDel )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pdisableCtrlAltDel); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DisableCtrlAltDel )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pdisableCtrlAltDel); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_EnableWindowsKey )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long penableWindowsKey); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_EnableWindowsKey )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *penableWindowsKey); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DoubleClickDetect )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pdoubleClickDetect); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DoubleClickDetect )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pdoubleClickDetect); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_MaximizeShell )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pmaximizeShell); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_MaximizeShell )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pmaximizeShell); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyFullScreen )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long photKeyFullScreen); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyFullScreen )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *photKeyFullScreen); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyCtrlEsc )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long photKeyCtrlEsc); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyCtrlEsc )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *photKeyCtrlEsc); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyAltEsc )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long photKeyAltEsc); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyAltEsc )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *photKeyAltEsc); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyAltTab )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long photKeyAltTab); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyAltTab )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *photKeyAltTab); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyAltShiftTab )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long photKeyAltShiftTab); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyAltShiftTab )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *photKeyAltShiftTab); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyAltSpace )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long photKeyAltSpace); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyAltSpace )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *photKeyAltSpace); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyCtrlAltDel )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long photKeyCtrlAltDel); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyCtrlAltDel )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *photKeyCtrlAltDel); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_orderDrawThreshold )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long porderDrawThreshold); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_orderDrawThreshold )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *porderDrawThreshold); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapCacheSize )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pbitmapCacheSize); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapCacheSize )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pbitmapCacheSize); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapVirtualCacheSize )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pbitmapVirtualCacheSize); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapVirtualCacheSize )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pbitmapVirtualCacheSize); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ScaleBitmapCachesByBPP )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pbScale); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ScaleBitmapCachesByBPP )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pbScale); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_NumBitmapCaches )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pnumBitmapCaches); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_NumBitmapCaches )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pnumBitmapCaches); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_CachePersistenceActive )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pcachePersistenceActive); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_CachePersistenceActive )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pcachePersistenceActive); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_PersistCacheDirectory )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_brushSupportLevel )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pbrushSupportLevel); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_brushSupportLevel )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pbrushSupportLevel); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_minInputSendInterval )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pminInputSendInterval); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_minInputSendInterval )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pminInputSendInterval); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_InputEventsAtOnce )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pinputEventsAtOnce); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_InputEventsAtOnce )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pinputEventsAtOnce); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_maxEventCount )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pmaxEventCount); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_maxEventCount )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pmaxEventCount); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_keepAliveInterval )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pkeepAliveInterval); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_keepAliveInterval )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pkeepAliveInterval); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_shutdownTimeout )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pshutdownTimeout); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_shutdownTimeout )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pshutdownTimeout); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_overallConnectionTimeout )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long poverallConnectionTimeout); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_overallConnectionTimeout )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *poverallConnectionTimeout); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_singleConnectionTimeout )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long psingleConnectionTimeout); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_singleConnectionTimeout )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *psingleConnectionTimeout); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_KeyboardType )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pkeyboardType); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_KeyboardType )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pkeyboardType); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_KeyboardSubType )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pkeyboardSubType); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_KeyboardSubType )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pkeyboardSubType); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_KeyboardFunctionKey )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pkeyboardFunctionKey); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_KeyboardFunctionKey )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pkeyboardFunctionKey); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_WinceFixedPalette )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pwinceFixedPalette); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_WinceFixedPalette )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pwinceFixedPalette); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ConnectToServerConsole )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ VARIANT_BOOL pConnectToConsole); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ConnectToServerConsole )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ VARIANT_BOOL *pConnectToConsole); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapPersistence )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pbitmapPersistence); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapPersistence )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pbitmapPersistence); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_MinutesToIdleTimeout )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pminutesToIdleTimeout); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_MinutesToIdleTimeout )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pminutesToIdleTimeout); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_SmartSizing )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ VARIANT_BOOL pfSmartSizing); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SmartSizing )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ VARIANT_BOOL *pfSmartSizing); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RdpdrLocalPrintingDocName )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ BSTR pLocalPrintingDocName); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RdpdrLocalPrintingDocName )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ BSTR *pLocalPrintingDocName); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RdpdrClipCleanTempDirString )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ BSTR clipCleanTempDirString); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RdpdrClipCleanTempDirString )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ BSTR *clipCleanTempDirString); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RdpdrClipPasteInfoString )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ BSTR clipPasteInfoString); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RdpdrClipPasteInfoString )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ BSTR *clipPasteInfoString); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ClearTextPassword )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DisplayConnectionBar )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ VARIANT_BOOL pDisplayConnectionBar); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DisplayConnectionBar )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ VARIANT_BOOL *pDisplayConnectionBar); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_PinConnectionBar )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ VARIANT_BOOL pPinConnectionBar); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_PinConnectionBar )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ VARIANT_BOOL *pPinConnectionBar); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_GrabFocusOnConnect )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ VARIANT_BOOL pfGrabFocusOnConnect); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_GrabFocusOnConnect )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ VARIANT_BOOL *pfGrabFocusOnConnect); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_LoadBalanceInfo )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ BSTR pLBInfo); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_LoadBalanceInfo )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ BSTR *pLBInfo); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RedirectDrives )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ VARIANT_BOOL pRedirectDrives); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RedirectDrives )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ VARIANT_BOOL *pRedirectDrives); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RedirectPrinters )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ VARIANT_BOOL pRedirectPrinters); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RedirectPrinters )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ VARIANT_BOOL *pRedirectPrinters); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RedirectPorts )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ VARIANT_BOOL pRedirectPorts); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RedirectPorts )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ VARIANT_BOOL *pRedirectPorts); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RedirectSmartCards )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ VARIANT_BOOL pRedirectSmartCards); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RedirectSmartCards )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ VARIANT_BOOL *pRedirectSmartCards); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapVirtualCache16BppSize )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pBitmapVirtualCache16BppSize); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapVirtualCache16BppSize )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pBitmapVirtualCache16BppSize); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapVirtualCache24BppSize )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pBitmapVirtualCache24BppSize); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapVirtualCache24BppSize )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pBitmapVirtualCache24BppSize); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_PerformanceFlags )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pDisableList); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_PerformanceFlags )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pDisableList); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ConnectWithEndpoint )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ VARIANT *rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_NotifyTSPublicKey )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ VARIANT_BOOL pfNotify); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_NotifyTSPublicKey )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ VARIANT_BOOL *pfNotify); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_CanAutoReconnect )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ VARIANT_BOOL *pfCanAutoReconnect); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_EnableAutoReconnect )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ VARIANT_BOOL pfEnableAutoReconnect); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_EnableAutoReconnect )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ VARIANT_BOOL *pfEnableAutoReconnect); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_MaxReconnectAttempts )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ long pMaxReconnectAttempts); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_MaxReconnectAttempts )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ long *pMaxReconnectAttempts); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ConnectionBarShowMinimizeButton )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ VARIANT_BOOL pfShowMinimize); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ConnectionBarShowMinimizeButton )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ VARIANT_BOOL *pfShowMinimize); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ConnectionBarShowRestoreButton )( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ VARIANT_BOOL pfShowRestore); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ConnectionBarShowRestoreButton )( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ VARIANT_BOOL *pfShowRestore); + + END_INTERFACE + } IMsRdpClientAdvancedSettings3Vtbl; + + interface IMsRdpClientAdvancedSettings3 + { + CONST_VTBL struct IMsRdpClientAdvancedSettings3Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMsRdpClientAdvancedSettings3_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMsRdpClientAdvancedSettings3_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMsRdpClientAdvancedSettings3_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMsRdpClientAdvancedSettings3_GetTypeInfoCount(This,pctinfo) \ + ( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) ) + +#define IMsRdpClientAdvancedSettings3_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + ( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) ) + +#define IMsRdpClientAdvancedSettings3_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + ( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ) + +#define IMsRdpClientAdvancedSettings3_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + ( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ) + + +#define IMsRdpClientAdvancedSettings3_put_Compress(This,pcompress) \ + ( (This)->lpVtbl -> put_Compress(This,pcompress) ) + +#define IMsRdpClientAdvancedSettings3_get_Compress(This,pcompress) \ + ( (This)->lpVtbl -> get_Compress(This,pcompress) ) + +#define IMsRdpClientAdvancedSettings3_put_BitmapPeristence(This,pbitmapPeristence) \ + ( (This)->lpVtbl -> put_BitmapPeristence(This,pbitmapPeristence) ) + +#define IMsRdpClientAdvancedSettings3_get_BitmapPeristence(This,pbitmapPeristence) \ + ( (This)->lpVtbl -> get_BitmapPeristence(This,pbitmapPeristence) ) + +#define IMsRdpClientAdvancedSettings3_put_allowBackgroundInput(This,pallowBackgroundInput) \ + ( (This)->lpVtbl -> put_allowBackgroundInput(This,pallowBackgroundInput) ) + +#define IMsRdpClientAdvancedSettings3_get_allowBackgroundInput(This,pallowBackgroundInput) \ + ( (This)->lpVtbl -> get_allowBackgroundInput(This,pallowBackgroundInput) ) + +#define IMsRdpClientAdvancedSettings3_put_KeyBoardLayoutStr(This,rhs) \ + ( (This)->lpVtbl -> put_KeyBoardLayoutStr(This,rhs) ) + +#define IMsRdpClientAdvancedSettings3_put_PluginDlls(This,rhs) \ + ( (This)->lpVtbl -> put_PluginDlls(This,rhs) ) + +#define IMsRdpClientAdvancedSettings3_put_IconFile(This,rhs) \ + ( (This)->lpVtbl -> put_IconFile(This,rhs) ) + +#define IMsRdpClientAdvancedSettings3_put_IconIndex(This,rhs) \ + ( (This)->lpVtbl -> put_IconIndex(This,rhs) ) + +#define IMsRdpClientAdvancedSettings3_put_ContainerHandledFullScreen(This,pContainerHandledFullScreen) \ + ( (This)->lpVtbl -> put_ContainerHandledFullScreen(This,pContainerHandledFullScreen) ) + +#define IMsRdpClientAdvancedSettings3_get_ContainerHandledFullScreen(This,pContainerHandledFullScreen) \ + ( (This)->lpVtbl -> get_ContainerHandledFullScreen(This,pContainerHandledFullScreen) ) + +#define IMsRdpClientAdvancedSettings3_put_DisableRdpdr(This,pDisableRdpdr) \ + ( (This)->lpVtbl -> put_DisableRdpdr(This,pDisableRdpdr) ) + +#define IMsRdpClientAdvancedSettings3_get_DisableRdpdr(This,pDisableRdpdr) \ + ( (This)->lpVtbl -> get_DisableRdpdr(This,pDisableRdpdr) ) + + +#define IMsRdpClientAdvancedSettings3_put_SmoothScroll(This,psmoothScroll) \ + ( (This)->lpVtbl -> put_SmoothScroll(This,psmoothScroll) ) + +#define IMsRdpClientAdvancedSettings3_get_SmoothScroll(This,psmoothScroll) \ + ( (This)->lpVtbl -> get_SmoothScroll(This,psmoothScroll) ) + +#define IMsRdpClientAdvancedSettings3_put_AcceleratorPassthrough(This,pacceleratorPassthrough) \ + ( (This)->lpVtbl -> put_AcceleratorPassthrough(This,pacceleratorPassthrough) ) + +#define IMsRdpClientAdvancedSettings3_get_AcceleratorPassthrough(This,pacceleratorPassthrough) \ + ( (This)->lpVtbl -> get_AcceleratorPassthrough(This,pacceleratorPassthrough) ) + +#define IMsRdpClientAdvancedSettings3_put_ShadowBitmap(This,pshadowBitmap) \ + ( (This)->lpVtbl -> put_ShadowBitmap(This,pshadowBitmap) ) + +#define IMsRdpClientAdvancedSettings3_get_ShadowBitmap(This,pshadowBitmap) \ + ( (This)->lpVtbl -> get_ShadowBitmap(This,pshadowBitmap) ) + +#define IMsRdpClientAdvancedSettings3_put_TransportType(This,ptransportType) \ + ( (This)->lpVtbl -> put_TransportType(This,ptransportType) ) + +#define IMsRdpClientAdvancedSettings3_get_TransportType(This,ptransportType) \ + ( (This)->lpVtbl -> get_TransportType(This,ptransportType) ) + +#define IMsRdpClientAdvancedSettings3_put_SasSequence(This,psasSequence) \ + ( (This)->lpVtbl -> put_SasSequence(This,psasSequence) ) + +#define IMsRdpClientAdvancedSettings3_get_SasSequence(This,psasSequence) \ + ( (This)->lpVtbl -> get_SasSequence(This,psasSequence) ) + +#define IMsRdpClientAdvancedSettings3_put_EncryptionEnabled(This,pencryptionEnabled) \ + ( (This)->lpVtbl -> put_EncryptionEnabled(This,pencryptionEnabled) ) + +#define IMsRdpClientAdvancedSettings3_get_EncryptionEnabled(This,pencryptionEnabled) \ + ( (This)->lpVtbl -> get_EncryptionEnabled(This,pencryptionEnabled) ) + +#define IMsRdpClientAdvancedSettings3_put_DedicatedTerminal(This,pdedicatedTerminal) \ + ( (This)->lpVtbl -> put_DedicatedTerminal(This,pdedicatedTerminal) ) + +#define IMsRdpClientAdvancedSettings3_get_DedicatedTerminal(This,pdedicatedTerminal) \ + ( (This)->lpVtbl -> get_DedicatedTerminal(This,pdedicatedTerminal) ) + +#define IMsRdpClientAdvancedSettings3_put_RDPPort(This,prdpPort) \ + ( (This)->lpVtbl -> put_RDPPort(This,prdpPort) ) + +#define IMsRdpClientAdvancedSettings3_get_RDPPort(This,prdpPort) \ + ( (This)->lpVtbl -> get_RDPPort(This,prdpPort) ) + +#define IMsRdpClientAdvancedSettings3_put_EnableMouse(This,penableMouse) \ + ( (This)->lpVtbl -> put_EnableMouse(This,penableMouse) ) + +#define IMsRdpClientAdvancedSettings3_get_EnableMouse(This,penableMouse) \ + ( (This)->lpVtbl -> get_EnableMouse(This,penableMouse) ) + +#define IMsRdpClientAdvancedSettings3_put_DisableCtrlAltDel(This,pdisableCtrlAltDel) \ + ( (This)->lpVtbl -> put_DisableCtrlAltDel(This,pdisableCtrlAltDel) ) + +#define IMsRdpClientAdvancedSettings3_get_DisableCtrlAltDel(This,pdisableCtrlAltDel) \ + ( (This)->lpVtbl -> get_DisableCtrlAltDel(This,pdisableCtrlAltDel) ) + +#define IMsRdpClientAdvancedSettings3_put_EnableWindowsKey(This,penableWindowsKey) \ + ( (This)->lpVtbl -> put_EnableWindowsKey(This,penableWindowsKey) ) + +#define IMsRdpClientAdvancedSettings3_get_EnableWindowsKey(This,penableWindowsKey) \ + ( (This)->lpVtbl -> get_EnableWindowsKey(This,penableWindowsKey) ) + +#define IMsRdpClientAdvancedSettings3_put_DoubleClickDetect(This,pdoubleClickDetect) \ + ( (This)->lpVtbl -> put_DoubleClickDetect(This,pdoubleClickDetect) ) + +#define IMsRdpClientAdvancedSettings3_get_DoubleClickDetect(This,pdoubleClickDetect) \ + ( (This)->lpVtbl -> get_DoubleClickDetect(This,pdoubleClickDetect) ) + +#define IMsRdpClientAdvancedSettings3_put_MaximizeShell(This,pmaximizeShell) \ + ( (This)->lpVtbl -> put_MaximizeShell(This,pmaximizeShell) ) + +#define IMsRdpClientAdvancedSettings3_get_MaximizeShell(This,pmaximizeShell) \ + ( (This)->lpVtbl -> get_MaximizeShell(This,pmaximizeShell) ) + +#define IMsRdpClientAdvancedSettings3_put_HotKeyFullScreen(This,photKeyFullScreen) \ + ( (This)->lpVtbl -> put_HotKeyFullScreen(This,photKeyFullScreen) ) + +#define IMsRdpClientAdvancedSettings3_get_HotKeyFullScreen(This,photKeyFullScreen) \ + ( (This)->lpVtbl -> get_HotKeyFullScreen(This,photKeyFullScreen) ) + +#define IMsRdpClientAdvancedSettings3_put_HotKeyCtrlEsc(This,photKeyCtrlEsc) \ + ( (This)->lpVtbl -> put_HotKeyCtrlEsc(This,photKeyCtrlEsc) ) + +#define IMsRdpClientAdvancedSettings3_get_HotKeyCtrlEsc(This,photKeyCtrlEsc) \ + ( (This)->lpVtbl -> get_HotKeyCtrlEsc(This,photKeyCtrlEsc) ) + +#define IMsRdpClientAdvancedSettings3_put_HotKeyAltEsc(This,photKeyAltEsc) \ + ( (This)->lpVtbl -> put_HotKeyAltEsc(This,photKeyAltEsc) ) + +#define IMsRdpClientAdvancedSettings3_get_HotKeyAltEsc(This,photKeyAltEsc) \ + ( (This)->lpVtbl -> get_HotKeyAltEsc(This,photKeyAltEsc) ) + +#define IMsRdpClientAdvancedSettings3_put_HotKeyAltTab(This,photKeyAltTab) \ + ( (This)->lpVtbl -> put_HotKeyAltTab(This,photKeyAltTab) ) + +#define IMsRdpClientAdvancedSettings3_get_HotKeyAltTab(This,photKeyAltTab) \ + ( (This)->lpVtbl -> get_HotKeyAltTab(This,photKeyAltTab) ) + +#define IMsRdpClientAdvancedSettings3_put_HotKeyAltShiftTab(This,photKeyAltShiftTab) \ + ( (This)->lpVtbl -> put_HotKeyAltShiftTab(This,photKeyAltShiftTab) ) + +#define IMsRdpClientAdvancedSettings3_get_HotKeyAltShiftTab(This,photKeyAltShiftTab) \ + ( (This)->lpVtbl -> get_HotKeyAltShiftTab(This,photKeyAltShiftTab) ) + +#define IMsRdpClientAdvancedSettings3_put_HotKeyAltSpace(This,photKeyAltSpace) \ + ( (This)->lpVtbl -> put_HotKeyAltSpace(This,photKeyAltSpace) ) + +#define IMsRdpClientAdvancedSettings3_get_HotKeyAltSpace(This,photKeyAltSpace) \ + ( (This)->lpVtbl -> get_HotKeyAltSpace(This,photKeyAltSpace) ) + +#define IMsRdpClientAdvancedSettings3_put_HotKeyCtrlAltDel(This,photKeyCtrlAltDel) \ + ( (This)->lpVtbl -> put_HotKeyCtrlAltDel(This,photKeyCtrlAltDel) ) + +#define IMsRdpClientAdvancedSettings3_get_HotKeyCtrlAltDel(This,photKeyCtrlAltDel) \ + ( (This)->lpVtbl -> get_HotKeyCtrlAltDel(This,photKeyCtrlAltDel) ) + +#define IMsRdpClientAdvancedSettings3_put_orderDrawThreshold(This,porderDrawThreshold) \ + ( (This)->lpVtbl -> put_orderDrawThreshold(This,porderDrawThreshold) ) + +#define IMsRdpClientAdvancedSettings3_get_orderDrawThreshold(This,porderDrawThreshold) \ + ( (This)->lpVtbl -> get_orderDrawThreshold(This,porderDrawThreshold) ) + +#define IMsRdpClientAdvancedSettings3_put_BitmapCacheSize(This,pbitmapCacheSize) \ + ( (This)->lpVtbl -> put_BitmapCacheSize(This,pbitmapCacheSize) ) + +#define IMsRdpClientAdvancedSettings3_get_BitmapCacheSize(This,pbitmapCacheSize) \ + ( (This)->lpVtbl -> get_BitmapCacheSize(This,pbitmapCacheSize) ) + +#define IMsRdpClientAdvancedSettings3_put_BitmapVirtualCacheSize(This,pbitmapVirtualCacheSize) \ + ( (This)->lpVtbl -> put_BitmapVirtualCacheSize(This,pbitmapVirtualCacheSize) ) + +#define IMsRdpClientAdvancedSettings3_get_BitmapVirtualCacheSize(This,pbitmapVirtualCacheSize) \ + ( (This)->lpVtbl -> get_BitmapVirtualCacheSize(This,pbitmapVirtualCacheSize) ) + +#define IMsRdpClientAdvancedSettings3_put_ScaleBitmapCachesByBPP(This,pbScale) \ + ( (This)->lpVtbl -> put_ScaleBitmapCachesByBPP(This,pbScale) ) + +#define IMsRdpClientAdvancedSettings3_get_ScaleBitmapCachesByBPP(This,pbScale) \ + ( (This)->lpVtbl -> get_ScaleBitmapCachesByBPP(This,pbScale) ) + +#define IMsRdpClientAdvancedSettings3_put_NumBitmapCaches(This,pnumBitmapCaches) \ + ( (This)->lpVtbl -> put_NumBitmapCaches(This,pnumBitmapCaches) ) + +#define IMsRdpClientAdvancedSettings3_get_NumBitmapCaches(This,pnumBitmapCaches) \ + ( (This)->lpVtbl -> get_NumBitmapCaches(This,pnumBitmapCaches) ) + +#define IMsRdpClientAdvancedSettings3_put_CachePersistenceActive(This,pcachePersistenceActive) \ + ( (This)->lpVtbl -> put_CachePersistenceActive(This,pcachePersistenceActive) ) + +#define IMsRdpClientAdvancedSettings3_get_CachePersistenceActive(This,pcachePersistenceActive) \ + ( (This)->lpVtbl -> get_CachePersistenceActive(This,pcachePersistenceActive) ) + +#define IMsRdpClientAdvancedSettings3_put_PersistCacheDirectory(This,rhs) \ + ( (This)->lpVtbl -> put_PersistCacheDirectory(This,rhs) ) + +#define IMsRdpClientAdvancedSettings3_put_brushSupportLevel(This,pbrushSupportLevel) \ + ( (This)->lpVtbl -> put_brushSupportLevel(This,pbrushSupportLevel) ) + +#define IMsRdpClientAdvancedSettings3_get_brushSupportLevel(This,pbrushSupportLevel) \ + ( (This)->lpVtbl -> get_brushSupportLevel(This,pbrushSupportLevel) ) + +#define IMsRdpClientAdvancedSettings3_put_minInputSendInterval(This,pminInputSendInterval) \ + ( (This)->lpVtbl -> put_minInputSendInterval(This,pminInputSendInterval) ) + +#define IMsRdpClientAdvancedSettings3_get_minInputSendInterval(This,pminInputSendInterval) \ + ( (This)->lpVtbl -> get_minInputSendInterval(This,pminInputSendInterval) ) + +#define IMsRdpClientAdvancedSettings3_put_InputEventsAtOnce(This,pinputEventsAtOnce) \ + ( (This)->lpVtbl -> put_InputEventsAtOnce(This,pinputEventsAtOnce) ) + +#define IMsRdpClientAdvancedSettings3_get_InputEventsAtOnce(This,pinputEventsAtOnce) \ + ( (This)->lpVtbl -> get_InputEventsAtOnce(This,pinputEventsAtOnce) ) + +#define IMsRdpClientAdvancedSettings3_put_maxEventCount(This,pmaxEventCount) \ + ( (This)->lpVtbl -> put_maxEventCount(This,pmaxEventCount) ) + +#define IMsRdpClientAdvancedSettings3_get_maxEventCount(This,pmaxEventCount) \ + ( (This)->lpVtbl -> get_maxEventCount(This,pmaxEventCount) ) + +#define IMsRdpClientAdvancedSettings3_put_keepAliveInterval(This,pkeepAliveInterval) \ + ( (This)->lpVtbl -> put_keepAliveInterval(This,pkeepAliveInterval) ) + +#define IMsRdpClientAdvancedSettings3_get_keepAliveInterval(This,pkeepAliveInterval) \ + ( (This)->lpVtbl -> get_keepAliveInterval(This,pkeepAliveInterval) ) + +#define IMsRdpClientAdvancedSettings3_put_shutdownTimeout(This,pshutdownTimeout) \ + ( (This)->lpVtbl -> put_shutdownTimeout(This,pshutdownTimeout) ) + +#define IMsRdpClientAdvancedSettings3_get_shutdownTimeout(This,pshutdownTimeout) \ + ( (This)->lpVtbl -> get_shutdownTimeout(This,pshutdownTimeout) ) + +#define IMsRdpClientAdvancedSettings3_put_overallConnectionTimeout(This,poverallConnectionTimeout) \ + ( (This)->lpVtbl -> put_overallConnectionTimeout(This,poverallConnectionTimeout) ) + +#define IMsRdpClientAdvancedSettings3_get_overallConnectionTimeout(This,poverallConnectionTimeout) \ + ( (This)->lpVtbl -> get_overallConnectionTimeout(This,poverallConnectionTimeout) ) + +#define IMsRdpClientAdvancedSettings3_put_singleConnectionTimeout(This,psingleConnectionTimeout) \ + ( (This)->lpVtbl -> put_singleConnectionTimeout(This,psingleConnectionTimeout) ) + +#define IMsRdpClientAdvancedSettings3_get_singleConnectionTimeout(This,psingleConnectionTimeout) \ + ( (This)->lpVtbl -> get_singleConnectionTimeout(This,psingleConnectionTimeout) ) + +#define IMsRdpClientAdvancedSettings3_put_KeyboardType(This,pkeyboardType) \ + ( (This)->lpVtbl -> put_KeyboardType(This,pkeyboardType) ) + +#define IMsRdpClientAdvancedSettings3_get_KeyboardType(This,pkeyboardType) \ + ( (This)->lpVtbl -> get_KeyboardType(This,pkeyboardType) ) + +#define IMsRdpClientAdvancedSettings3_put_KeyboardSubType(This,pkeyboardSubType) \ + ( (This)->lpVtbl -> put_KeyboardSubType(This,pkeyboardSubType) ) + +#define IMsRdpClientAdvancedSettings3_get_KeyboardSubType(This,pkeyboardSubType) \ + ( (This)->lpVtbl -> get_KeyboardSubType(This,pkeyboardSubType) ) + +#define IMsRdpClientAdvancedSettings3_put_KeyboardFunctionKey(This,pkeyboardFunctionKey) \ + ( (This)->lpVtbl -> put_KeyboardFunctionKey(This,pkeyboardFunctionKey) ) + +#define IMsRdpClientAdvancedSettings3_get_KeyboardFunctionKey(This,pkeyboardFunctionKey) \ + ( (This)->lpVtbl -> get_KeyboardFunctionKey(This,pkeyboardFunctionKey) ) + +#define IMsRdpClientAdvancedSettings3_put_WinceFixedPalette(This,pwinceFixedPalette) \ + ( (This)->lpVtbl -> put_WinceFixedPalette(This,pwinceFixedPalette) ) + +#define IMsRdpClientAdvancedSettings3_get_WinceFixedPalette(This,pwinceFixedPalette) \ + ( (This)->lpVtbl -> get_WinceFixedPalette(This,pwinceFixedPalette) ) + +#define IMsRdpClientAdvancedSettings3_put_ConnectToServerConsole(This,pConnectToConsole) \ + ( (This)->lpVtbl -> put_ConnectToServerConsole(This,pConnectToConsole) ) + +#define IMsRdpClientAdvancedSettings3_get_ConnectToServerConsole(This,pConnectToConsole) \ + ( (This)->lpVtbl -> get_ConnectToServerConsole(This,pConnectToConsole) ) + +#define IMsRdpClientAdvancedSettings3_put_BitmapPersistence(This,pbitmapPersistence) \ + ( (This)->lpVtbl -> put_BitmapPersistence(This,pbitmapPersistence) ) + +#define IMsRdpClientAdvancedSettings3_get_BitmapPersistence(This,pbitmapPersistence) \ + ( (This)->lpVtbl -> get_BitmapPersistence(This,pbitmapPersistence) ) + +#define IMsRdpClientAdvancedSettings3_put_MinutesToIdleTimeout(This,pminutesToIdleTimeout) \ + ( (This)->lpVtbl -> put_MinutesToIdleTimeout(This,pminutesToIdleTimeout) ) + +#define IMsRdpClientAdvancedSettings3_get_MinutesToIdleTimeout(This,pminutesToIdleTimeout) \ + ( (This)->lpVtbl -> get_MinutesToIdleTimeout(This,pminutesToIdleTimeout) ) + +#define IMsRdpClientAdvancedSettings3_put_SmartSizing(This,pfSmartSizing) \ + ( (This)->lpVtbl -> put_SmartSizing(This,pfSmartSizing) ) + +#define IMsRdpClientAdvancedSettings3_get_SmartSizing(This,pfSmartSizing) \ + ( (This)->lpVtbl -> get_SmartSizing(This,pfSmartSizing) ) + +#define IMsRdpClientAdvancedSettings3_put_RdpdrLocalPrintingDocName(This,pLocalPrintingDocName) \ + ( (This)->lpVtbl -> put_RdpdrLocalPrintingDocName(This,pLocalPrintingDocName) ) + +#define IMsRdpClientAdvancedSettings3_get_RdpdrLocalPrintingDocName(This,pLocalPrintingDocName) \ + ( (This)->lpVtbl -> get_RdpdrLocalPrintingDocName(This,pLocalPrintingDocName) ) + +#define IMsRdpClientAdvancedSettings3_put_RdpdrClipCleanTempDirString(This,clipCleanTempDirString) \ + ( (This)->lpVtbl -> put_RdpdrClipCleanTempDirString(This,clipCleanTempDirString) ) + +#define IMsRdpClientAdvancedSettings3_get_RdpdrClipCleanTempDirString(This,clipCleanTempDirString) \ + ( (This)->lpVtbl -> get_RdpdrClipCleanTempDirString(This,clipCleanTempDirString) ) + +#define IMsRdpClientAdvancedSettings3_put_RdpdrClipPasteInfoString(This,clipPasteInfoString) \ + ( (This)->lpVtbl -> put_RdpdrClipPasteInfoString(This,clipPasteInfoString) ) + +#define IMsRdpClientAdvancedSettings3_get_RdpdrClipPasteInfoString(This,clipPasteInfoString) \ + ( (This)->lpVtbl -> get_RdpdrClipPasteInfoString(This,clipPasteInfoString) ) + +#define IMsRdpClientAdvancedSettings3_put_ClearTextPassword(This,rhs) \ + ( (This)->lpVtbl -> put_ClearTextPassword(This,rhs) ) + +#define IMsRdpClientAdvancedSettings3_put_DisplayConnectionBar(This,pDisplayConnectionBar) \ + ( (This)->lpVtbl -> put_DisplayConnectionBar(This,pDisplayConnectionBar) ) + +#define IMsRdpClientAdvancedSettings3_get_DisplayConnectionBar(This,pDisplayConnectionBar) \ + ( (This)->lpVtbl -> get_DisplayConnectionBar(This,pDisplayConnectionBar) ) + +#define IMsRdpClientAdvancedSettings3_put_PinConnectionBar(This,pPinConnectionBar) \ + ( (This)->lpVtbl -> put_PinConnectionBar(This,pPinConnectionBar) ) + +#define IMsRdpClientAdvancedSettings3_get_PinConnectionBar(This,pPinConnectionBar) \ + ( (This)->lpVtbl -> get_PinConnectionBar(This,pPinConnectionBar) ) + +#define IMsRdpClientAdvancedSettings3_put_GrabFocusOnConnect(This,pfGrabFocusOnConnect) \ + ( (This)->lpVtbl -> put_GrabFocusOnConnect(This,pfGrabFocusOnConnect) ) + +#define IMsRdpClientAdvancedSettings3_get_GrabFocusOnConnect(This,pfGrabFocusOnConnect) \ + ( (This)->lpVtbl -> get_GrabFocusOnConnect(This,pfGrabFocusOnConnect) ) + +#define IMsRdpClientAdvancedSettings3_put_LoadBalanceInfo(This,pLBInfo) \ + ( (This)->lpVtbl -> put_LoadBalanceInfo(This,pLBInfo) ) + +#define IMsRdpClientAdvancedSettings3_get_LoadBalanceInfo(This,pLBInfo) \ + ( (This)->lpVtbl -> get_LoadBalanceInfo(This,pLBInfo) ) + +#define IMsRdpClientAdvancedSettings3_put_RedirectDrives(This,pRedirectDrives) \ + ( (This)->lpVtbl -> put_RedirectDrives(This,pRedirectDrives) ) + +#define IMsRdpClientAdvancedSettings3_get_RedirectDrives(This,pRedirectDrives) \ + ( (This)->lpVtbl -> get_RedirectDrives(This,pRedirectDrives) ) + +#define IMsRdpClientAdvancedSettings3_put_RedirectPrinters(This,pRedirectPrinters) \ + ( (This)->lpVtbl -> put_RedirectPrinters(This,pRedirectPrinters) ) + +#define IMsRdpClientAdvancedSettings3_get_RedirectPrinters(This,pRedirectPrinters) \ + ( (This)->lpVtbl -> get_RedirectPrinters(This,pRedirectPrinters) ) + +#define IMsRdpClientAdvancedSettings3_put_RedirectPorts(This,pRedirectPorts) \ + ( (This)->lpVtbl -> put_RedirectPorts(This,pRedirectPorts) ) + +#define IMsRdpClientAdvancedSettings3_get_RedirectPorts(This,pRedirectPorts) \ + ( (This)->lpVtbl -> get_RedirectPorts(This,pRedirectPorts) ) + +#define IMsRdpClientAdvancedSettings3_put_RedirectSmartCards(This,pRedirectSmartCards) \ + ( (This)->lpVtbl -> put_RedirectSmartCards(This,pRedirectSmartCards) ) + +#define IMsRdpClientAdvancedSettings3_get_RedirectSmartCards(This,pRedirectSmartCards) \ + ( (This)->lpVtbl -> get_RedirectSmartCards(This,pRedirectSmartCards) ) + +#define IMsRdpClientAdvancedSettings3_put_BitmapVirtualCache16BppSize(This,pBitmapVirtualCache16BppSize) \ + ( (This)->lpVtbl -> put_BitmapVirtualCache16BppSize(This,pBitmapVirtualCache16BppSize) ) + +#define IMsRdpClientAdvancedSettings3_get_BitmapVirtualCache16BppSize(This,pBitmapVirtualCache16BppSize) \ + ( (This)->lpVtbl -> get_BitmapVirtualCache16BppSize(This,pBitmapVirtualCache16BppSize) ) + +#define IMsRdpClientAdvancedSettings3_put_BitmapVirtualCache24BppSize(This,pBitmapVirtualCache24BppSize) \ + ( (This)->lpVtbl -> put_BitmapVirtualCache24BppSize(This,pBitmapVirtualCache24BppSize) ) + +#define IMsRdpClientAdvancedSettings3_get_BitmapVirtualCache24BppSize(This,pBitmapVirtualCache24BppSize) \ + ( (This)->lpVtbl -> get_BitmapVirtualCache24BppSize(This,pBitmapVirtualCache24BppSize) ) + +#define IMsRdpClientAdvancedSettings3_put_PerformanceFlags(This,pDisableList) \ + ( (This)->lpVtbl -> put_PerformanceFlags(This,pDisableList) ) + +#define IMsRdpClientAdvancedSettings3_get_PerformanceFlags(This,pDisableList) \ + ( (This)->lpVtbl -> get_PerformanceFlags(This,pDisableList) ) + +#define IMsRdpClientAdvancedSettings3_put_ConnectWithEndpoint(This,rhs) \ + ( (This)->lpVtbl -> put_ConnectWithEndpoint(This,rhs) ) + +#define IMsRdpClientAdvancedSettings3_put_NotifyTSPublicKey(This,pfNotify) \ + ( (This)->lpVtbl -> put_NotifyTSPublicKey(This,pfNotify) ) + +#define IMsRdpClientAdvancedSettings3_get_NotifyTSPublicKey(This,pfNotify) \ + ( (This)->lpVtbl -> get_NotifyTSPublicKey(This,pfNotify) ) + + +#define IMsRdpClientAdvancedSettings3_get_CanAutoReconnect(This,pfCanAutoReconnect) \ + ( (This)->lpVtbl -> get_CanAutoReconnect(This,pfCanAutoReconnect) ) + +#define IMsRdpClientAdvancedSettings3_put_EnableAutoReconnect(This,pfEnableAutoReconnect) \ + ( (This)->lpVtbl -> put_EnableAutoReconnect(This,pfEnableAutoReconnect) ) + +#define IMsRdpClientAdvancedSettings3_get_EnableAutoReconnect(This,pfEnableAutoReconnect) \ + ( (This)->lpVtbl -> get_EnableAutoReconnect(This,pfEnableAutoReconnect) ) + +#define IMsRdpClientAdvancedSettings3_put_MaxReconnectAttempts(This,pMaxReconnectAttempts) \ + ( (This)->lpVtbl -> put_MaxReconnectAttempts(This,pMaxReconnectAttempts) ) + +#define IMsRdpClientAdvancedSettings3_get_MaxReconnectAttempts(This,pMaxReconnectAttempts) \ + ( (This)->lpVtbl -> get_MaxReconnectAttempts(This,pMaxReconnectAttempts) ) + + +#define IMsRdpClientAdvancedSettings3_put_ConnectionBarShowMinimizeButton(This,pfShowMinimize) \ + ( (This)->lpVtbl -> put_ConnectionBarShowMinimizeButton(This,pfShowMinimize) ) + +#define IMsRdpClientAdvancedSettings3_get_ConnectionBarShowMinimizeButton(This,pfShowMinimize) \ + ( (This)->lpVtbl -> get_ConnectionBarShowMinimizeButton(This,pfShowMinimize) ) + +#define IMsRdpClientAdvancedSettings3_put_ConnectionBarShowRestoreButton(This,pfShowRestore) \ + ( (This)->lpVtbl -> put_ConnectionBarShowRestoreButton(This,pfShowRestore) ) + +#define IMsRdpClientAdvancedSettings3_get_ConnectionBarShowRestoreButton(This,pfShowRestore) \ + ( (This)->lpVtbl -> get_ConnectionBarShowRestoreButton(This,pfShowRestore) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [propput][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings3_put_ConnectionBarShowMinimizeButton_Proxy( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ VARIANT_BOOL pfShowMinimize); + + +void __RPC_STUB IMsRdpClientAdvancedSettings3_put_ConnectionBarShowMinimizeButton_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [propget][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings3_get_ConnectionBarShowMinimizeButton_Proxy( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ VARIANT_BOOL *pfShowMinimize); + + +void __RPC_STUB IMsRdpClientAdvancedSettings3_get_ConnectionBarShowMinimizeButton_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [propput][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings3_put_ConnectionBarShowRestoreButton_Proxy( + IMsRdpClientAdvancedSettings3 * This, + /* [in] */ VARIANT_BOOL pfShowRestore); + + +void __RPC_STUB IMsRdpClientAdvancedSettings3_put_ConnectionBarShowRestoreButton_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [propget][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings3_get_ConnectionBarShowRestoreButton_Proxy( + IMsRdpClientAdvancedSettings3 * This, + /* [retval][out] */ VARIANT_BOOL *pfShowRestore); + + +void __RPC_STUB IMsRdpClientAdvancedSettings3_get_ConnectionBarShowRestoreButton_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IMsRdpClientAdvancedSettings3_INTERFACE_DEFINED__ */ + + +#ifndef __IMsRdpClientAdvancedSettings4_INTERFACE_DEFINED__ +#define __IMsRdpClientAdvancedSettings4_INTERFACE_DEFINED__ + +/* interface IMsRdpClientAdvancedSettings4 */ +/* [object][oleautomation][dual][uuid] */ + + +EXTERN_C const IID IID_IMsRdpClientAdvancedSettings4; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("FBA7F64E-7345-4405-AE50-FA4A763DC0DE") + IMsRdpClientAdvancedSettings4 : public IMsRdpClientAdvancedSettings3 + { + public: + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_AuthenticationLevel( + /* [in] */ unsigned int puiAuthLevel) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_AuthenticationLevel( + /* [retval][out] */ unsigned int *puiAuthLevel) = 0; + + }; + +#else /* C style interface */ + + typedef struct IMsRdpClientAdvancedSettings4Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ + __RPC__deref_out void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMsRdpClientAdvancedSettings4 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMsRdpClientAdvancedSettings4 * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + IMsRdpClientAdvancedSettings4 * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [range][in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Compress )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pcompress); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Compress )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pcompress); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapPeristence )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pbitmapPeristence); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapPeristence )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pbitmapPeristence); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_allowBackgroundInput )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pallowBackgroundInput); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_allowBackgroundInput )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pallowBackgroundInput); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_KeyBoardLayoutStr )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_PluginDlls )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_IconFile )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_IconIndex )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ContainerHandledFullScreen )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pContainerHandledFullScreen); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ContainerHandledFullScreen )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pContainerHandledFullScreen); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DisableRdpdr )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pDisableRdpdr); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DisableRdpdr )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pDisableRdpdr); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_SmoothScroll )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long psmoothScroll); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SmoothScroll )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *psmoothScroll); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_AcceleratorPassthrough )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pacceleratorPassthrough); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AcceleratorPassthrough )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pacceleratorPassthrough); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ShadowBitmap )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pshadowBitmap); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ShadowBitmap )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pshadowBitmap); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_TransportType )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long ptransportType); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_TransportType )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *ptransportType); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_SasSequence )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long psasSequence); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SasSequence )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *psasSequence); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_EncryptionEnabled )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pencryptionEnabled); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_EncryptionEnabled )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pencryptionEnabled); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DedicatedTerminal )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pdedicatedTerminal); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DedicatedTerminal )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pdedicatedTerminal); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RDPPort )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long prdpPort); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RDPPort )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *prdpPort); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_EnableMouse )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long penableMouse); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_EnableMouse )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *penableMouse); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DisableCtrlAltDel )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pdisableCtrlAltDel); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DisableCtrlAltDel )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pdisableCtrlAltDel); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_EnableWindowsKey )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long penableWindowsKey); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_EnableWindowsKey )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *penableWindowsKey); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DoubleClickDetect )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pdoubleClickDetect); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DoubleClickDetect )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pdoubleClickDetect); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_MaximizeShell )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pmaximizeShell); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_MaximizeShell )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pmaximizeShell); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyFullScreen )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long photKeyFullScreen); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyFullScreen )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *photKeyFullScreen); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyCtrlEsc )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long photKeyCtrlEsc); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyCtrlEsc )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *photKeyCtrlEsc); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyAltEsc )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long photKeyAltEsc); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyAltEsc )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *photKeyAltEsc); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyAltTab )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long photKeyAltTab); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyAltTab )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *photKeyAltTab); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyAltShiftTab )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long photKeyAltShiftTab); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyAltShiftTab )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *photKeyAltShiftTab); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyAltSpace )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long photKeyAltSpace); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyAltSpace )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *photKeyAltSpace); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HotKeyCtrlAltDel )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long photKeyCtrlAltDel); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HotKeyCtrlAltDel )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *photKeyCtrlAltDel); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_orderDrawThreshold )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long porderDrawThreshold); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_orderDrawThreshold )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *porderDrawThreshold); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapCacheSize )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pbitmapCacheSize); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapCacheSize )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pbitmapCacheSize); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapVirtualCacheSize )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pbitmapVirtualCacheSize); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapVirtualCacheSize )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pbitmapVirtualCacheSize); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ScaleBitmapCachesByBPP )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pbScale); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ScaleBitmapCachesByBPP )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pbScale); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_NumBitmapCaches )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pnumBitmapCaches); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_NumBitmapCaches )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pnumBitmapCaches); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_CachePersistenceActive )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pcachePersistenceActive); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_CachePersistenceActive )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pcachePersistenceActive); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_PersistCacheDirectory )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_brushSupportLevel )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pbrushSupportLevel); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_brushSupportLevel )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pbrushSupportLevel); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_minInputSendInterval )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pminInputSendInterval); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_minInputSendInterval )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pminInputSendInterval); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_InputEventsAtOnce )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pinputEventsAtOnce); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_InputEventsAtOnce )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pinputEventsAtOnce); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_maxEventCount )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pmaxEventCount); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_maxEventCount )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pmaxEventCount); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_keepAliveInterval )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pkeepAliveInterval); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_keepAliveInterval )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pkeepAliveInterval); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_shutdownTimeout )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pshutdownTimeout); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_shutdownTimeout )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pshutdownTimeout); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_overallConnectionTimeout )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long poverallConnectionTimeout); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_overallConnectionTimeout )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *poverallConnectionTimeout); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_singleConnectionTimeout )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long psingleConnectionTimeout); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_singleConnectionTimeout )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *psingleConnectionTimeout); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_KeyboardType )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pkeyboardType); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_KeyboardType )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pkeyboardType); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_KeyboardSubType )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pkeyboardSubType); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_KeyboardSubType )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pkeyboardSubType); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_KeyboardFunctionKey )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pkeyboardFunctionKey); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_KeyboardFunctionKey )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pkeyboardFunctionKey); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_WinceFixedPalette )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pwinceFixedPalette); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_WinceFixedPalette )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pwinceFixedPalette); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ConnectToServerConsole )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ VARIANT_BOOL pConnectToConsole); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ConnectToServerConsole )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ VARIANT_BOOL *pConnectToConsole); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapPersistence )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pbitmapPersistence); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapPersistence )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pbitmapPersistence); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_MinutesToIdleTimeout )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pminutesToIdleTimeout); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_MinutesToIdleTimeout )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pminutesToIdleTimeout); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_SmartSizing )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ VARIANT_BOOL pfSmartSizing); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_SmartSizing )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ VARIANT_BOOL *pfSmartSizing); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RdpdrLocalPrintingDocName )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ BSTR pLocalPrintingDocName); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RdpdrLocalPrintingDocName )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ BSTR *pLocalPrintingDocName); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RdpdrClipCleanTempDirString )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ BSTR clipCleanTempDirString); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RdpdrClipCleanTempDirString )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ BSTR *clipCleanTempDirString); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RdpdrClipPasteInfoString )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ BSTR clipPasteInfoString); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RdpdrClipPasteInfoString )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ BSTR *clipPasteInfoString); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ClearTextPassword )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ BSTR rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DisplayConnectionBar )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ VARIANT_BOOL pDisplayConnectionBar); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DisplayConnectionBar )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ VARIANT_BOOL *pDisplayConnectionBar); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_PinConnectionBar )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ VARIANT_BOOL pPinConnectionBar); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_PinConnectionBar )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ VARIANT_BOOL *pPinConnectionBar); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_GrabFocusOnConnect )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ VARIANT_BOOL pfGrabFocusOnConnect); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_GrabFocusOnConnect )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ VARIANT_BOOL *pfGrabFocusOnConnect); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_LoadBalanceInfo )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ BSTR pLBInfo); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_LoadBalanceInfo )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ BSTR *pLBInfo); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RedirectDrives )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ VARIANT_BOOL pRedirectDrives); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RedirectDrives )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ VARIANT_BOOL *pRedirectDrives); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RedirectPrinters )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ VARIANT_BOOL pRedirectPrinters); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RedirectPrinters )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ VARIANT_BOOL *pRedirectPrinters); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RedirectPorts )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ VARIANT_BOOL pRedirectPorts); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RedirectPorts )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ VARIANT_BOOL *pRedirectPorts); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RedirectSmartCards )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ VARIANT_BOOL pRedirectSmartCards); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RedirectSmartCards )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ VARIANT_BOOL *pRedirectSmartCards); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapVirtualCache16BppSize )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pBitmapVirtualCache16BppSize); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapVirtualCache16BppSize )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pBitmapVirtualCache16BppSize); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapVirtualCache24BppSize )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pBitmapVirtualCache24BppSize); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapVirtualCache24BppSize )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pBitmapVirtualCache24BppSize); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_PerformanceFlags )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pDisableList); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_PerformanceFlags )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pDisableList); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ConnectWithEndpoint )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ VARIANT *rhs); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_NotifyTSPublicKey )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ VARIANT_BOOL pfNotify); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_NotifyTSPublicKey )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ VARIANT_BOOL *pfNotify); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_CanAutoReconnect )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ VARIANT_BOOL *pfCanAutoReconnect); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_EnableAutoReconnect )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ VARIANT_BOOL pfEnableAutoReconnect); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_EnableAutoReconnect )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ VARIANT_BOOL *pfEnableAutoReconnect); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_MaxReconnectAttempts )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ long pMaxReconnectAttempts); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_MaxReconnectAttempts )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ long *pMaxReconnectAttempts); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ConnectionBarShowMinimizeButton )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ VARIANT_BOOL pfShowMinimize); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ConnectionBarShowMinimizeButton )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ VARIANT_BOOL *pfShowMinimize); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ConnectionBarShowRestoreButton )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ VARIANT_BOOL pfShowRestore); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ConnectionBarShowRestoreButton )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ VARIANT_BOOL *pfShowRestore); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_AuthenticationLevel )( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ unsigned int puiAuthLevel); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AuthenticationLevel )( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ unsigned int *puiAuthLevel); + + END_INTERFACE + } IMsRdpClientAdvancedSettings4Vtbl; + + interface IMsRdpClientAdvancedSettings4 + { + CONST_VTBL struct IMsRdpClientAdvancedSettings4Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMsRdpClientAdvancedSettings4_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMsRdpClientAdvancedSettings4_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMsRdpClientAdvancedSettings4_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMsRdpClientAdvancedSettings4_GetTypeInfoCount(This,pctinfo) \ + ( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) ) + +#define IMsRdpClientAdvancedSettings4_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + ( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) ) + +#define IMsRdpClientAdvancedSettings4_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + ( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ) + +#define IMsRdpClientAdvancedSettings4_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + ( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ) + + +#define IMsRdpClientAdvancedSettings4_put_Compress(This,pcompress) \ + ( (This)->lpVtbl -> put_Compress(This,pcompress) ) + +#define IMsRdpClientAdvancedSettings4_get_Compress(This,pcompress) \ + ( (This)->lpVtbl -> get_Compress(This,pcompress) ) + +#define IMsRdpClientAdvancedSettings4_put_BitmapPeristence(This,pbitmapPeristence) \ + ( (This)->lpVtbl -> put_BitmapPeristence(This,pbitmapPeristence) ) + +#define IMsRdpClientAdvancedSettings4_get_BitmapPeristence(This,pbitmapPeristence) \ + ( (This)->lpVtbl -> get_BitmapPeristence(This,pbitmapPeristence) ) + +#define IMsRdpClientAdvancedSettings4_put_allowBackgroundInput(This,pallowBackgroundInput) \ + ( (This)->lpVtbl -> put_allowBackgroundInput(This,pallowBackgroundInput) ) + +#define IMsRdpClientAdvancedSettings4_get_allowBackgroundInput(This,pallowBackgroundInput) \ + ( (This)->lpVtbl -> get_allowBackgroundInput(This,pallowBackgroundInput) ) + +#define IMsRdpClientAdvancedSettings4_put_KeyBoardLayoutStr(This,rhs) \ + ( (This)->lpVtbl -> put_KeyBoardLayoutStr(This,rhs) ) + +#define IMsRdpClientAdvancedSettings4_put_PluginDlls(This,rhs) \ + ( (This)->lpVtbl -> put_PluginDlls(This,rhs) ) + +#define IMsRdpClientAdvancedSettings4_put_IconFile(This,rhs) \ + ( (This)->lpVtbl -> put_IconFile(This,rhs) ) + +#define IMsRdpClientAdvancedSettings4_put_IconIndex(This,rhs) \ + ( (This)->lpVtbl -> put_IconIndex(This,rhs) ) + +#define IMsRdpClientAdvancedSettings4_put_ContainerHandledFullScreen(This,pContainerHandledFullScreen) \ + ( (This)->lpVtbl -> put_ContainerHandledFullScreen(This,pContainerHandledFullScreen) ) + +#define IMsRdpClientAdvancedSettings4_get_ContainerHandledFullScreen(This,pContainerHandledFullScreen) \ + ( (This)->lpVtbl -> get_ContainerHandledFullScreen(This,pContainerHandledFullScreen) ) + +#define IMsRdpClientAdvancedSettings4_put_DisableRdpdr(This,pDisableRdpdr) \ + ( (This)->lpVtbl -> put_DisableRdpdr(This,pDisableRdpdr) ) + +#define IMsRdpClientAdvancedSettings4_get_DisableRdpdr(This,pDisableRdpdr) \ + ( (This)->lpVtbl -> get_DisableRdpdr(This,pDisableRdpdr) ) + + +#define IMsRdpClientAdvancedSettings4_put_SmoothScroll(This,psmoothScroll) \ + ( (This)->lpVtbl -> put_SmoothScroll(This,psmoothScroll) ) + +#define IMsRdpClientAdvancedSettings4_get_SmoothScroll(This,psmoothScroll) \ + ( (This)->lpVtbl -> get_SmoothScroll(This,psmoothScroll) ) + +#define IMsRdpClientAdvancedSettings4_put_AcceleratorPassthrough(This,pacceleratorPassthrough) \ + ( (This)->lpVtbl -> put_AcceleratorPassthrough(This,pacceleratorPassthrough) ) + +#define IMsRdpClientAdvancedSettings4_get_AcceleratorPassthrough(This,pacceleratorPassthrough) \ + ( (This)->lpVtbl -> get_AcceleratorPassthrough(This,pacceleratorPassthrough) ) + +#define IMsRdpClientAdvancedSettings4_put_ShadowBitmap(This,pshadowBitmap) \ + ( (This)->lpVtbl -> put_ShadowBitmap(This,pshadowBitmap) ) + +#define IMsRdpClientAdvancedSettings4_get_ShadowBitmap(This,pshadowBitmap) \ + ( (This)->lpVtbl -> get_ShadowBitmap(This,pshadowBitmap) ) + +#define IMsRdpClientAdvancedSettings4_put_TransportType(This,ptransportType) \ + ( (This)->lpVtbl -> put_TransportType(This,ptransportType) ) + +#define IMsRdpClientAdvancedSettings4_get_TransportType(This,ptransportType) \ + ( (This)->lpVtbl -> get_TransportType(This,ptransportType) ) + +#define IMsRdpClientAdvancedSettings4_put_SasSequence(This,psasSequence) \ + ( (This)->lpVtbl -> put_SasSequence(This,psasSequence) ) + +#define IMsRdpClientAdvancedSettings4_get_SasSequence(This,psasSequence) \ + ( (This)->lpVtbl -> get_SasSequence(This,psasSequence) ) + +#define IMsRdpClientAdvancedSettings4_put_EncryptionEnabled(This,pencryptionEnabled) \ + ( (This)->lpVtbl -> put_EncryptionEnabled(This,pencryptionEnabled) ) + +#define IMsRdpClientAdvancedSettings4_get_EncryptionEnabled(This,pencryptionEnabled) \ + ( (This)->lpVtbl -> get_EncryptionEnabled(This,pencryptionEnabled) ) + +#define IMsRdpClientAdvancedSettings4_put_DedicatedTerminal(This,pdedicatedTerminal) \ + ( (This)->lpVtbl -> put_DedicatedTerminal(This,pdedicatedTerminal) ) + +#define IMsRdpClientAdvancedSettings4_get_DedicatedTerminal(This,pdedicatedTerminal) \ + ( (This)->lpVtbl -> get_DedicatedTerminal(This,pdedicatedTerminal) ) + +#define IMsRdpClientAdvancedSettings4_put_RDPPort(This,prdpPort) \ + ( (This)->lpVtbl -> put_RDPPort(This,prdpPort) ) + +#define IMsRdpClientAdvancedSettings4_get_RDPPort(This,prdpPort) \ + ( (This)->lpVtbl -> get_RDPPort(This,prdpPort) ) + +#define IMsRdpClientAdvancedSettings4_put_EnableMouse(This,penableMouse) \ + ( (This)->lpVtbl -> put_EnableMouse(This,penableMouse) ) + +#define IMsRdpClientAdvancedSettings4_get_EnableMouse(This,penableMouse) \ + ( (This)->lpVtbl -> get_EnableMouse(This,penableMouse) ) + +#define IMsRdpClientAdvancedSettings4_put_DisableCtrlAltDel(This,pdisableCtrlAltDel) \ + ( (This)->lpVtbl -> put_DisableCtrlAltDel(This,pdisableCtrlAltDel) ) + +#define IMsRdpClientAdvancedSettings4_get_DisableCtrlAltDel(This,pdisableCtrlAltDel) \ + ( (This)->lpVtbl -> get_DisableCtrlAltDel(This,pdisableCtrlAltDel) ) + +#define IMsRdpClientAdvancedSettings4_put_EnableWindowsKey(This,penableWindowsKey) \ + ( (This)->lpVtbl -> put_EnableWindowsKey(This,penableWindowsKey) ) + +#define IMsRdpClientAdvancedSettings4_get_EnableWindowsKey(This,penableWindowsKey) \ + ( (This)->lpVtbl -> get_EnableWindowsKey(This,penableWindowsKey) ) + +#define IMsRdpClientAdvancedSettings4_put_DoubleClickDetect(This,pdoubleClickDetect) \ + ( (This)->lpVtbl -> put_DoubleClickDetect(This,pdoubleClickDetect) ) + +#define IMsRdpClientAdvancedSettings4_get_DoubleClickDetect(This,pdoubleClickDetect) \ + ( (This)->lpVtbl -> get_DoubleClickDetect(This,pdoubleClickDetect) ) + +#define IMsRdpClientAdvancedSettings4_put_MaximizeShell(This,pmaximizeShell) \ + ( (This)->lpVtbl -> put_MaximizeShell(This,pmaximizeShell) ) + +#define IMsRdpClientAdvancedSettings4_get_MaximizeShell(This,pmaximizeShell) \ + ( (This)->lpVtbl -> get_MaximizeShell(This,pmaximizeShell) ) + +#define IMsRdpClientAdvancedSettings4_put_HotKeyFullScreen(This,photKeyFullScreen) \ + ( (This)->lpVtbl -> put_HotKeyFullScreen(This,photKeyFullScreen) ) + +#define IMsRdpClientAdvancedSettings4_get_HotKeyFullScreen(This,photKeyFullScreen) \ + ( (This)->lpVtbl -> get_HotKeyFullScreen(This,photKeyFullScreen) ) + +#define IMsRdpClientAdvancedSettings4_put_HotKeyCtrlEsc(This,photKeyCtrlEsc) \ + ( (This)->lpVtbl -> put_HotKeyCtrlEsc(This,photKeyCtrlEsc) ) + +#define IMsRdpClientAdvancedSettings4_get_HotKeyCtrlEsc(This,photKeyCtrlEsc) \ + ( (This)->lpVtbl -> get_HotKeyCtrlEsc(This,photKeyCtrlEsc) ) + +#define IMsRdpClientAdvancedSettings4_put_HotKeyAltEsc(This,photKeyAltEsc) \ + ( (This)->lpVtbl -> put_HotKeyAltEsc(This,photKeyAltEsc) ) + +#define IMsRdpClientAdvancedSettings4_get_HotKeyAltEsc(This,photKeyAltEsc) \ + ( (This)->lpVtbl -> get_HotKeyAltEsc(This,photKeyAltEsc) ) + +#define IMsRdpClientAdvancedSettings4_put_HotKeyAltTab(This,photKeyAltTab) \ + ( (This)->lpVtbl -> put_HotKeyAltTab(This,photKeyAltTab) ) + +#define IMsRdpClientAdvancedSettings4_get_HotKeyAltTab(This,photKeyAltTab) \ + ( (This)->lpVtbl -> get_HotKeyAltTab(This,photKeyAltTab) ) + +#define IMsRdpClientAdvancedSettings4_put_HotKeyAltShiftTab(This,photKeyAltShiftTab) \ + ( (This)->lpVtbl -> put_HotKeyAltShiftTab(This,photKeyAltShiftTab) ) + +#define IMsRdpClientAdvancedSettings4_get_HotKeyAltShiftTab(This,photKeyAltShiftTab) \ + ( (This)->lpVtbl -> get_HotKeyAltShiftTab(This,photKeyAltShiftTab) ) + +#define IMsRdpClientAdvancedSettings4_put_HotKeyAltSpace(This,photKeyAltSpace) \ + ( (This)->lpVtbl -> put_HotKeyAltSpace(This,photKeyAltSpace) ) + +#define IMsRdpClientAdvancedSettings4_get_HotKeyAltSpace(This,photKeyAltSpace) \ + ( (This)->lpVtbl -> get_HotKeyAltSpace(This,photKeyAltSpace) ) + +#define IMsRdpClientAdvancedSettings4_put_HotKeyCtrlAltDel(This,photKeyCtrlAltDel) \ + ( (This)->lpVtbl -> put_HotKeyCtrlAltDel(This,photKeyCtrlAltDel) ) + +#define IMsRdpClientAdvancedSettings4_get_HotKeyCtrlAltDel(This,photKeyCtrlAltDel) \ + ( (This)->lpVtbl -> get_HotKeyCtrlAltDel(This,photKeyCtrlAltDel) ) + +#define IMsRdpClientAdvancedSettings4_put_orderDrawThreshold(This,porderDrawThreshold) \ + ( (This)->lpVtbl -> put_orderDrawThreshold(This,porderDrawThreshold) ) + +#define IMsRdpClientAdvancedSettings4_get_orderDrawThreshold(This,porderDrawThreshold) \ + ( (This)->lpVtbl -> get_orderDrawThreshold(This,porderDrawThreshold) ) + +#define IMsRdpClientAdvancedSettings4_put_BitmapCacheSize(This,pbitmapCacheSize) \ + ( (This)->lpVtbl -> put_BitmapCacheSize(This,pbitmapCacheSize) ) + +#define IMsRdpClientAdvancedSettings4_get_BitmapCacheSize(This,pbitmapCacheSize) \ + ( (This)->lpVtbl -> get_BitmapCacheSize(This,pbitmapCacheSize) ) + +#define IMsRdpClientAdvancedSettings4_put_BitmapVirtualCacheSize(This,pbitmapVirtualCacheSize) \ + ( (This)->lpVtbl -> put_BitmapVirtualCacheSize(This,pbitmapVirtualCacheSize) ) + +#define IMsRdpClientAdvancedSettings4_get_BitmapVirtualCacheSize(This,pbitmapVirtualCacheSize) \ + ( (This)->lpVtbl -> get_BitmapVirtualCacheSize(This,pbitmapVirtualCacheSize) ) + +#define IMsRdpClientAdvancedSettings4_put_ScaleBitmapCachesByBPP(This,pbScale) \ + ( (This)->lpVtbl -> put_ScaleBitmapCachesByBPP(This,pbScale) ) + +#define IMsRdpClientAdvancedSettings4_get_ScaleBitmapCachesByBPP(This,pbScale) \ + ( (This)->lpVtbl -> get_ScaleBitmapCachesByBPP(This,pbScale) ) + +#define IMsRdpClientAdvancedSettings4_put_NumBitmapCaches(This,pnumBitmapCaches) \ + ( (This)->lpVtbl -> put_NumBitmapCaches(This,pnumBitmapCaches) ) + +#define IMsRdpClientAdvancedSettings4_get_NumBitmapCaches(This,pnumBitmapCaches) \ + ( (This)->lpVtbl -> get_NumBitmapCaches(This,pnumBitmapCaches) ) + +#define IMsRdpClientAdvancedSettings4_put_CachePersistenceActive(This,pcachePersistenceActive) \ + ( (This)->lpVtbl -> put_CachePersistenceActive(This,pcachePersistenceActive) ) + +#define IMsRdpClientAdvancedSettings4_get_CachePersistenceActive(This,pcachePersistenceActive) \ + ( (This)->lpVtbl -> get_CachePersistenceActive(This,pcachePersistenceActive) ) + +#define IMsRdpClientAdvancedSettings4_put_PersistCacheDirectory(This,rhs) \ + ( (This)->lpVtbl -> put_PersistCacheDirectory(This,rhs) ) + +#define IMsRdpClientAdvancedSettings4_put_brushSupportLevel(This,pbrushSupportLevel) \ + ( (This)->lpVtbl -> put_brushSupportLevel(This,pbrushSupportLevel) ) + +#define IMsRdpClientAdvancedSettings4_get_brushSupportLevel(This,pbrushSupportLevel) \ + ( (This)->lpVtbl -> get_brushSupportLevel(This,pbrushSupportLevel) ) + +#define IMsRdpClientAdvancedSettings4_put_minInputSendInterval(This,pminInputSendInterval) \ + ( (This)->lpVtbl -> put_minInputSendInterval(This,pminInputSendInterval) ) + +#define IMsRdpClientAdvancedSettings4_get_minInputSendInterval(This,pminInputSendInterval) \ + ( (This)->lpVtbl -> get_minInputSendInterval(This,pminInputSendInterval) ) + +#define IMsRdpClientAdvancedSettings4_put_InputEventsAtOnce(This,pinputEventsAtOnce) \ + ( (This)->lpVtbl -> put_InputEventsAtOnce(This,pinputEventsAtOnce) ) + +#define IMsRdpClientAdvancedSettings4_get_InputEventsAtOnce(This,pinputEventsAtOnce) \ + ( (This)->lpVtbl -> get_InputEventsAtOnce(This,pinputEventsAtOnce) ) + +#define IMsRdpClientAdvancedSettings4_put_maxEventCount(This,pmaxEventCount) \ + ( (This)->lpVtbl -> put_maxEventCount(This,pmaxEventCount) ) + +#define IMsRdpClientAdvancedSettings4_get_maxEventCount(This,pmaxEventCount) \ + ( (This)->lpVtbl -> get_maxEventCount(This,pmaxEventCount) ) + +#define IMsRdpClientAdvancedSettings4_put_keepAliveInterval(This,pkeepAliveInterval) \ + ( (This)->lpVtbl -> put_keepAliveInterval(This,pkeepAliveInterval) ) + +#define IMsRdpClientAdvancedSettings4_get_keepAliveInterval(This,pkeepAliveInterval) \ + ( (This)->lpVtbl -> get_keepAliveInterval(This,pkeepAliveInterval) ) + +#define IMsRdpClientAdvancedSettings4_put_shutdownTimeout(This,pshutdownTimeout) \ + ( (This)->lpVtbl -> put_shutdownTimeout(This,pshutdownTimeout) ) + +#define IMsRdpClientAdvancedSettings4_get_shutdownTimeout(This,pshutdownTimeout) \ + ( (This)->lpVtbl -> get_shutdownTimeout(This,pshutdownTimeout) ) + +#define IMsRdpClientAdvancedSettings4_put_overallConnectionTimeout(This,poverallConnectionTimeout) \ + ( (This)->lpVtbl -> put_overallConnectionTimeout(This,poverallConnectionTimeout) ) + +#define IMsRdpClientAdvancedSettings4_get_overallConnectionTimeout(This,poverallConnectionTimeout) \ + ( (This)->lpVtbl -> get_overallConnectionTimeout(This,poverallConnectionTimeout) ) + +#define IMsRdpClientAdvancedSettings4_put_singleConnectionTimeout(This,psingleConnectionTimeout) \ + ( (This)->lpVtbl -> put_singleConnectionTimeout(This,psingleConnectionTimeout) ) + +#define IMsRdpClientAdvancedSettings4_get_singleConnectionTimeout(This,psingleConnectionTimeout) \ + ( (This)->lpVtbl -> get_singleConnectionTimeout(This,psingleConnectionTimeout) ) + +#define IMsRdpClientAdvancedSettings4_put_KeyboardType(This,pkeyboardType) \ + ( (This)->lpVtbl -> put_KeyboardType(This,pkeyboardType) ) + +#define IMsRdpClientAdvancedSettings4_get_KeyboardType(This,pkeyboardType) \ + ( (This)->lpVtbl -> get_KeyboardType(This,pkeyboardType) ) + +#define IMsRdpClientAdvancedSettings4_put_KeyboardSubType(This,pkeyboardSubType) \ + ( (This)->lpVtbl -> put_KeyboardSubType(This,pkeyboardSubType) ) + +#define IMsRdpClientAdvancedSettings4_get_KeyboardSubType(This,pkeyboardSubType) \ + ( (This)->lpVtbl -> get_KeyboardSubType(This,pkeyboardSubType) ) + +#define IMsRdpClientAdvancedSettings4_put_KeyboardFunctionKey(This,pkeyboardFunctionKey) \ + ( (This)->lpVtbl -> put_KeyboardFunctionKey(This,pkeyboardFunctionKey) ) + +#define IMsRdpClientAdvancedSettings4_get_KeyboardFunctionKey(This,pkeyboardFunctionKey) \ + ( (This)->lpVtbl -> get_KeyboardFunctionKey(This,pkeyboardFunctionKey) ) + +#define IMsRdpClientAdvancedSettings4_put_WinceFixedPalette(This,pwinceFixedPalette) \ + ( (This)->lpVtbl -> put_WinceFixedPalette(This,pwinceFixedPalette) ) + +#define IMsRdpClientAdvancedSettings4_get_WinceFixedPalette(This,pwinceFixedPalette) \ + ( (This)->lpVtbl -> get_WinceFixedPalette(This,pwinceFixedPalette) ) + +#define IMsRdpClientAdvancedSettings4_put_ConnectToServerConsole(This,pConnectToConsole) \ + ( (This)->lpVtbl -> put_ConnectToServerConsole(This,pConnectToConsole) ) + +#define IMsRdpClientAdvancedSettings4_get_ConnectToServerConsole(This,pConnectToConsole) \ + ( (This)->lpVtbl -> get_ConnectToServerConsole(This,pConnectToConsole) ) + +#define IMsRdpClientAdvancedSettings4_put_BitmapPersistence(This,pbitmapPersistence) \ + ( (This)->lpVtbl -> put_BitmapPersistence(This,pbitmapPersistence) ) + +#define IMsRdpClientAdvancedSettings4_get_BitmapPersistence(This,pbitmapPersistence) \ + ( (This)->lpVtbl -> get_BitmapPersistence(This,pbitmapPersistence) ) + +#define IMsRdpClientAdvancedSettings4_put_MinutesToIdleTimeout(This,pminutesToIdleTimeout) \ + ( (This)->lpVtbl -> put_MinutesToIdleTimeout(This,pminutesToIdleTimeout) ) + +#define IMsRdpClientAdvancedSettings4_get_MinutesToIdleTimeout(This,pminutesToIdleTimeout) \ + ( (This)->lpVtbl -> get_MinutesToIdleTimeout(This,pminutesToIdleTimeout) ) + +#define IMsRdpClientAdvancedSettings4_put_SmartSizing(This,pfSmartSizing) \ + ( (This)->lpVtbl -> put_SmartSizing(This,pfSmartSizing) ) + +#define IMsRdpClientAdvancedSettings4_get_SmartSizing(This,pfSmartSizing) \ + ( (This)->lpVtbl -> get_SmartSizing(This,pfSmartSizing) ) + +#define IMsRdpClientAdvancedSettings4_put_RdpdrLocalPrintingDocName(This,pLocalPrintingDocName) \ + ( (This)->lpVtbl -> put_RdpdrLocalPrintingDocName(This,pLocalPrintingDocName) ) + +#define IMsRdpClientAdvancedSettings4_get_RdpdrLocalPrintingDocName(This,pLocalPrintingDocName) \ + ( (This)->lpVtbl -> get_RdpdrLocalPrintingDocName(This,pLocalPrintingDocName) ) + +#define IMsRdpClientAdvancedSettings4_put_RdpdrClipCleanTempDirString(This,clipCleanTempDirString) \ + ( (This)->lpVtbl -> put_RdpdrClipCleanTempDirString(This,clipCleanTempDirString) ) + +#define IMsRdpClientAdvancedSettings4_get_RdpdrClipCleanTempDirString(This,clipCleanTempDirString) \ + ( (This)->lpVtbl -> get_RdpdrClipCleanTempDirString(This,clipCleanTempDirString) ) + +#define IMsRdpClientAdvancedSettings4_put_RdpdrClipPasteInfoString(This,clipPasteInfoString) \ + ( (This)->lpVtbl -> put_RdpdrClipPasteInfoString(This,clipPasteInfoString) ) + +#define IMsRdpClientAdvancedSettings4_get_RdpdrClipPasteInfoString(This,clipPasteInfoString) \ + ( (This)->lpVtbl -> get_RdpdrClipPasteInfoString(This,clipPasteInfoString) ) + +#define IMsRdpClientAdvancedSettings4_put_ClearTextPassword(This,rhs) \ + ( (This)->lpVtbl -> put_ClearTextPassword(This,rhs) ) + +#define IMsRdpClientAdvancedSettings4_put_DisplayConnectionBar(This,pDisplayConnectionBar) \ + ( (This)->lpVtbl -> put_DisplayConnectionBar(This,pDisplayConnectionBar) ) + +#define IMsRdpClientAdvancedSettings4_get_DisplayConnectionBar(This,pDisplayConnectionBar) \ + ( (This)->lpVtbl -> get_DisplayConnectionBar(This,pDisplayConnectionBar) ) + +#define IMsRdpClientAdvancedSettings4_put_PinConnectionBar(This,pPinConnectionBar) \ + ( (This)->lpVtbl -> put_PinConnectionBar(This,pPinConnectionBar) ) + +#define IMsRdpClientAdvancedSettings4_get_PinConnectionBar(This,pPinConnectionBar) \ + ( (This)->lpVtbl -> get_PinConnectionBar(This,pPinConnectionBar) ) + +#define IMsRdpClientAdvancedSettings4_put_GrabFocusOnConnect(This,pfGrabFocusOnConnect) \ + ( (This)->lpVtbl -> put_GrabFocusOnConnect(This,pfGrabFocusOnConnect) ) + +#define IMsRdpClientAdvancedSettings4_get_GrabFocusOnConnect(This,pfGrabFocusOnConnect) \ + ( (This)->lpVtbl -> get_GrabFocusOnConnect(This,pfGrabFocusOnConnect) ) + +#define IMsRdpClientAdvancedSettings4_put_LoadBalanceInfo(This,pLBInfo) \ + ( (This)->lpVtbl -> put_LoadBalanceInfo(This,pLBInfo) ) + +#define IMsRdpClientAdvancedSettings4_get_LoadBalanceInfo(This,pLBInfo) \ + ( (This)->lpVtbl -> get_LoadBalanceInfo(This,pLBInfo) ) + +#define IMsRdpClientAdvancedSettings4_put_RedirectDrives(This,pRedirectDrives) \ + ( (This)->lpVtbl -> put_RedirectDrives(This,pRedirectDrives) ) + +#define IMsRdpClientAdvancedSettings4_get_RedirectDrives(This,pRedirectDrives) \ + ( (This)->lpVtbl -> get_RedirectDrives(This,pRedirectDrives) ) + +#define IMsRdpClientAdvancedSettings4_put_RedirectPrinters(This,pRedirectPrinters) \ + ( (This)->lpVtbl -> put_RedirectPrinters(This,pRedirectPrinters) ) + +#define IMsRdpClientAdvancedSettings4_get_RedirectPrinters(This,pRedirectPrinters) \ + ( (This)->lpVtbl -> get_RedirectPrinters(This,pRedirectPrinters) ) + +#define IMsRdpClientAdvancedSettings4_put_RedirectPorts(This,pRedirectPorts) \ + ( (This)->lpVtbl -> put_RedirectPorts(This,pRedirectPorts) ) + +#define IMsRdpClientAdvancedSettings4_get_RedirectPorts(This,pRedirectPorts) \ + ( (This)->lpVtbl -> get_RedirectPorts(This,pRedirectPorts) ) + +#define IMsRdpClientAdvancedSettings4_put_RedirectSmartCards(This,pRedirectSmartCards) \ + ( (This)->lpVtbl -> put_RedirectSmartCards(This,pRedirectSmartCards) ) + +#define IMsRdpClientAdvancedSettings4_get_RedirectSmartCards(This,pRedirectSmartCards) \ + ( (This)->lpVtbl -> get_RedirectSmartCards(This,pRedirectSmartCards) ) + +#define IMsRdpClientAdvancedSettings4_put_BitmapVirtualCache16BppSize(This,pBitmapVirtualCache16BppSize) \ + ( (This)->lpVtbl -> put_BitmapVirtualCache16BppSize(This,pBitmapVirtualCache16BppSize) ) + +#define IMsRdpClientAdvancedSettings4_get_BitmapVirtualCache16BppSize(This,pBitmapVirtualCache16BppSize) \ + ( (This)->lpVtbl -> get_BitmapVirtualCache16BppSize(This,pBitmapVirtualCache16BppSize) ) + +#define IMsRdpClientAdvancedSettings4_put_BitmapVirtualCache24BppSize(This,pBitmapVirtualCache24BppSize) \ + ( (This)->lpVtbl -> put_BitmapVirtualCache24BppSize(This,pBitmapVirtualCache24BppSize) ) + +#define IMsRdpClientAdvancedSettings4_get_BitmapVirtualCache24BppSize(This,pBitmapVirtualCache24BppSize) \ + ( (This)->lpVtbl -> get_BitmapVirtualCache24BppSize(This,pBitmapVirtualCache24BppSize) ) + +#define IMsRdpClientAdvancedSettings4_put_PerformanceFlags(This,pDisableList) \ + ( (This)->lpVtbl -> put_PerformanceFlags(This,pDisableList) ) + +#define IMsRdpClientAdvancedSettings4_get_PerformanceFlags(This,pDisableList) \ + ( (This)->lpVtbl -> get_PerformanceFlags(This,pDisableList) ) + +#define IMsRdpClientAdvancedSettings4_put_ConnectWithEndpoint(This,rhs) \ + ( (This)->lpVtbl -> put_ConnectWithEndpoint(This,rhs) ) + +#define IMsRdpClientAdvancedSettings4_put_NotifyTSPublicKey(This,pfNotify) \ + ( (This)->lpVtbl -> put_NotifyTSPublicKey(This,pfNotify) ) + +#define IMsRdpClientAdvancedSettings4_get_NotifyTSPublicKey(This,pfNotify) \ + ( (This)->lpVtbl -> get_NotifyTSPublicKey(This,pfNotify) ) + + +#define IMsRdpClientAdvancedSettings4_get_CanAutoReconnect(This,pfCanAutoReconnect) \ + ( (This)->lpVtbl -> get_CanAutoReconnect(This,pfCanAutoReconnect) ) + +#define IMsRdpClientAdvancedSettings4_put_EnableAutoReconnect(This,pfEnableAutoReconnect) \ + ( (This)->lpVtbl -> put_EnableAutoReconnect(This,pfEnableAutoReconnect) ) + +#define IMsRdpClientAdvancedSettings4_get_EnableAutoReconnect(This,pfEnableAutoReconnect) \ + ( (This)->lpVtbl -> get_EnableAutoReconnect(This,pfEnableAutoReconnect) ) + +#define IMsRdpClientAdvancedSettings4_put_MaxReconnectAttempts(This,pMaxReconnectAttempts) \ + ( (This)->lpVtbl -> put_MaxReconnectAttempts(This,pMaxReconnectAttempts) ) + +#define IMsRdpClientAdvancedSettings4_get_MaxReconnectAttempts(This,pMaxReconnectAttempts) \ + ( (This)->lpVtbl -> get_MaxReconnectAttempts(This,pMaxReconnectAttempts) ) + + +#define IMsRdpClientAdvancedSettings4_put_ConnectionBarShowMinimizeButton(This,pfShowMinimize) \ + ( (This)->lpVtbl -> put_ConnectionBarShowMinimizeButton(This,pfShowMinimize) ) + +#define IMsRdpClientAdvancedSettings4_get_ConnectionBarShowMinimizeButton(This,pfShowMinimize) \ + ( (This)->lpVtbl -> get_ConnectionBarShowMinimizeButton(This,pfShowMinimize) ) + +#define IMsRdpClientAdvancedSettings4_put_ConnectionBarShowRestoreButton(This,pfShowRestore) \ + ( (This)->lpVtbl -> put_ConnectionBarShowRestoreButton(This,pfShowRestore) ) + +#define IMsRdpClientAdvancedSettings4_get_ConnectionBarShowRestoreButton(This,pfShowRestore) \ + ( (This)->lpVtbl -> get_ConnectionBarShowRestoreButton(This,pfShowRestore) ) + + +#define IMsRdpClientAdvancedSettings4_put_AuthenticationLevel(This,puiAuthLevel) \ + ( (This)->lpVtbl -> put_AuthenticationLevel(This,puiAuthLevel) ) + +#define IMsRdpClientAdvancedSettings4_get_AuthenticationLevel(This,puiAuthLevel) \ + ( (This)->lpVtbl -> get_AuthenticationLevel(This,puiAuthLevel) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [propput][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings4_put_AuthenticationLevel_Proxy( + IMsRdpClientAdvancedSettings4 * This, + /* [in] */ unsigned int puiAuthLevel); + + +void __RPC_STUB IMsRdpClientAdvancedSettings4_put_AuthenticationLevel_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [propget][id] */ HRESULT STDMETHODCALLTYPE IMsRdpClientAdvancedSettings4_get_AuthenticationLevel_Proxy( + IMsRdpClientAdvancedSettings4 * This, + /* [retval][out] */ unsigned int *puiAuthLevel); + + +void __RPC_STUB IMsRdpClientAdvancedSettings4_get_AuthenticationLevel_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IMsRdpClientAdvancedSettings4_INTERFACE_DEFINED__ */ + + +#ifndef __IMsTscSecuredSettings_INTERFACE_DEFINED__ +#define __IMsTscSecuredSettings_INTERFACE_DEFINED__ + +/* interface IMsTscSecuredSettings */ +/* [object][oleautomation][dual][uuid] */ + + +EXTERN_C const IID IID_IMsTscSecuredSettings; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C9D65442-A0F9-45B2-8F73-D61D2DB8CBB6") + IMsTscSecuredSettings : public IDispatch + { + public: + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_StartProgram( + /* [in] */ BSTR pStartProgram) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_StartProgram( + /* [retval][out] */ BSTR *pStartProgram) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_WorkDir( + /* [in] */ BSTR pWorkDir) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_WorkDir( + /* [retval][out] */ BSTR *pWorkDir) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_FullScreen( + /* [in] */ long pfFullScreen) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_FullScreen( + /* [retval][out] */ long *pfFullScreen) = 0; + + }; + +#else /* C style interface */ + + typedef struct IMsTscSecuredSettingsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMsTscSecuredSettings * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ + __RPC__deref_out void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMsTscSecuredSettings * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMsTscSecuredSettings * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + IMsTscSecuredSettings * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + IMsTscSecuredSettings * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + IMsTscSecuredSettings * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [range][in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + IMsTscSecuredSettings * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_StartProgram )( + IMsTscSecuredSettings * This, + /* [in] */ BSTR pStartProgram); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_StartProgram )( + IMsTscSecuredSettings * This, + /* [retval][out] */ BSTR *pStartProgram); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_WorkDir )( + IMsTscSecuredSettings * This, + /* [in] */ BSTR pWorkDir); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_WorkDir )( + IMsTscSecuredSettings * This, + /* [retval][out] */ BSTR *pWorkDir); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_FullScreen )( + IMsTscSecuredSettings * This, + /* [in] */ long pfFullScreen); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_FullScreen )( + IMsTscSecuredSettings * This, + /* [retval][out] */ long *pfFullScreen); + + END_INTERFACE + } IMsTscSecuredSettingsVtbl; + + interface IMsTscSecuredSettings + { + CONST_VTBL struct IMsTscSecuredSettingsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMsTscSecuredSettings_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMsTscSecuredSettings_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMsTscSecuredSettings_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMsTscSecuredSettings_GetTypeInfoCount(This,pctinfo) \ + ( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) ) + +#define IMsTscSecuredSettings_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + ( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) ) + +#define IMsTscSecuredSettings_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + ( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ) + +#define IMsTscSecuredSettings_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + ( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ) + + +#define IMsTscSecuredSettings_put_StartProgram(This,pStartProgram) \ + ( (This)->lpVtbl -> put_StartProgram(This,pStartProgram) ) + +#define IMsTscSecuredSettings_get_StartProgram(This,pStartProgram) \ + ( (This)->lpVtbl -> get_StartProgram(This,pStartProgram) ) + +#define IMsTscSecuredSettings_put_WorkDir(This,pWorkDir) \ + ( (This)->lpVtbl -> put_WorkDir(This,pWorkDir) ) + +#define IMsTscSecuredSettings_get_WorkDir(This,pWorkDir) \ + ( (This)->lpVtbl -> get_WorkDir(This,pWorkDir) ) + +#define IMsTscSecuredSettings_put_FullScreen(This,pfFullScreen) \ + ( (This)->lpVtbl -> put_FullScreen(This,pfFullScreen) ) + +#define IMsTscSecuredSettings_get_FullScreen(This,pfFullScreen) \ + ( (This)->lpVtbl -> get_FullScreen(This,pfFullScreen) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMsTscSecuredSettings_INTERFACE_DEFINED__ */ + + +#ifndef __IMsRdpClientSecuredSettings_INTERFACE_DEFINED__ +#define __IMsRdpClientSecuredSettings_INTERFACE_DEFINED__ + +/* interface IMsRdpClientSecuredSettings */ +/* [object][oleautomation][dual][uuid] */ + + +EXTERN_C const IID IID_IMsRdpClientSecuredSettings; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("605BEFCF-39C1-45CC-A811-068FB7BE346D") + IMsRdpClientSecuredSettings : public IMsTscSecuredSettings + { + public: + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_KeyboardHookMode( + /* [in] */ long pkeyboardHookMode) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_KeyboardHookMode( + /* [retval][out] */ long *pkeyboardHookMode) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_AudioRedirectionMode( + /* [in] */ long pAudioRedirectionMode) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_AudioRedirectionMode( + /* [retval][out] */ long *pAudioRedirectionMode) = 0; + + }; + +#else /* C style interface */ + + typedef struct IMsRdpClientSecuredSettingsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMsRdpClientSecuredSettings * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ + __RPC__deref_out void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMsRdpClientSecuredSettings * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMsRdpClientSecuredSettings * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + IMsRdpClientSecuredSettings * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + IMsRdpClientSecuredSettings * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + IMsRdpClientSecuredSettings * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [range][in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + IMsRdpClientSecuredSettings * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_StartProgram )( + IMsRdpClientSecuredSettings * This, + /* [in] */ BSTR pStartProgram); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_StartProgram )( + IMsRdpClientSecuredSettings * This, + /* [retval][out] */ BSTR *pStartProgram); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_WorkDir )( + IMsRdpClientSecuredSettings * This, + /* [in] */ BSTR pWorkDir); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_WorkDir )( + IMsRdpClientSecuredSettings * This, + /* [retval][out] */ BSTR *pWorkDir); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_FullScreen )( + IMsRdpClientSecuredSettings * This, + /* [in] */ long pfFullScreen); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_FullScreen )( + IMsRdpClientSecuredSettings * This, + /* [retval][out] */ long *pfFullScreen); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_KeyboardHookMode )( + IMsRdpClientSecuredSettings * This, + /* [in] */ long pkeyboardHookMode); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_KeyboardHookMode )( + IMsRdpClientSecuredSettings * This, + /* [retval][out] */ long *pkeyboardHookMode); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_AudioRedirectionMode )( + IMsRdpClientSecuredSettings * This, + /* [in] */ long pAudioRedirectionMode); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_AudioRedirectionMode )( + IMsRdpClientSecuredSettings * This, + /* [retval][out] */ long *pAudioRedirectionMode); + + END_INTERFACE + } IMsRdpClientSecuredSettingsVtbl; + + interface IMsRdpClientSecuredSettings + { + CONST_VTBL struct IMsRdpClientSecuredSettingsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMsRdpClientSecuredSettings_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMsRdpClientSecuredSettings_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMsRdpClientSecuredSettings_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMsRdpClientSecuredSettings_GetTypeInfoCount(This,pctinfo) \ + ( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) ) + +#define IMsRdpClientSecuredSettings_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + ( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) ) + +#define IMsRdpClientSecuredSettings_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + ( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ) + +#define IMsRdpClientSecuredSettings_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + ( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ) + + +#define IMsRdpClientSecuredSettings_put_StartProgram(This,pStartProgram) \ + ( (This)->lpVtbl -> put_StartProgram(This,pStartProgram) ) + +#define IMsRdpClientSecuredSettings_get_StartProgram(This,pStartProgram) \ + ( (This)->lpVtbl -> get_StartProgram(This,pStartProgram) ) + +#define IMsRdpClientSecuredSettings_put_WorkDir(This,pWorkDir) \ + ( (This)->lpVtbl -> put_WorkDir(This,pWorkDir) ) + +#define IMsRdpClientSecuredSettings_get_WorkDir(This,pWorkDir) \ + ( (This)->lpVtbl -> get_WorkDir(This,pWorkDir) ) + +#define IMsRdpClientSecuredSettings_put_FullScreen(This,pfFullScreen) \ + ( (This)->lpVtbl -> put_FullScreen(This,pfFullScreen) ) + +#define IMsRdpClientSecuredSettings_get_FullScreen(This,pfFullScreen) \ + ( (This)->lpVtbl -> get_FullScreen(This,pfFullScreen) ) + + +#define IMsRdpClientSecuredSettings_put_KeyboardHookMode(This,pkeyboardHookMode) \ + ( (This)->lpVtbl -> put_KeyboardHookMode(This,pkeyboardHookMode) ) + +#define IMsRdpClientSecuredSettings_get_KeyboardHookMode(This,pkeyboardHookMode) \ + ( (This)->lpVtbl -> get_KeyboardHookMode(This,pkeyboardHookMode) ) + +#define IMsRdpClientSecuredSettings_put_AudioRedirectionMode(This,pAudioRedirectionMode) \ + ( (This)->lpVtbl -> put_AudioRedirectionMode(This,pAudioRedirectionMode) ) + +#define IMsRdpClientSecuredSettings_get_AudioRedirectionMode(This,pAudioRedirectionMode) \ + ( (This)->lpVtbl -> get_AudioRedirectionMode(This,pAudioRedirectionMode) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMsRdpClientSecuredSettings_INTERFACE_DEFINED__ */ + + +#ifndef __IMsTscDebug_INTERFACE_DEFINED__ +#define __IMsTscDebug_INTERFACE_DEFINED__ + +/* interface IMsTscDebug */ +/* [object][oleautomation][dual][hidden][uuid] */ + + +EXTERN_C const IID IID_IMsTscDebug; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("209D0EB9-6254-47B1-9033-A98DAE55BB27") + IMsTscDebug : public IDispatch + { + public: + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_HatchBitmapPDU( + /* [in] */ long phatchBitmapPDU) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_HatchBitmapPDU( + /* [retval][out] */ long *phatchBitmapPDU) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_HatchSSBOrder( + /* [in] */ long phatchSSBOrder) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_HatchSSBOrder( + /* [retval][out] */ long *phatchSSBOrder) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_HatchMembltOrder( + /* [in] */ long phatchMembltOrder) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_HatchMembltOrder( + /* [retval][out] */ long *phatchMembltOrder) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_HatchIndexPDU( + /* [in] */ long phatchIndexPDU) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_HatchIndexPDU( + /* [retval][out] */ long *phatchIndexPDU) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_LabelMemblt( + /* [in] */ long plabelMemblt) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_LabelMemblt( + /* [retval][out] */ long *plabelMemblt) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_BitmapCacheMonitor( + /* [in] */ long pbitmapCacheMonitor) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_BitmapCacheMonitor( + /* [retval][out] */ long *pbitmapCacheMonitor) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_MallocFailuresPercent( + /* [in] */ long pmallocFailuresPercent) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_MallocFailuresPercent( + /* [retval][out] */ long *pmallocFailuresPercent) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_MallocHugeFailuresPercent( + /* [in] */ long pmallocHugeFailuresPercent) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_MallocHugeFailuresPercent( + /* [retval][out] */ long *pmallocHugeFailuresPercent) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_NetThroughput( + /* [in] */ long NetThroughput) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_NetThroughput( + /* [retval][out] */ long *NetThroughput) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_CLXCmdLine( + /* [in] */ BSTR pCLXCmdLine) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_CLXCmdLine( + /* [retval][out] */ BSTR *pCLXCmdLine) = 0; + + virtual /* [propput][id] */ HRESULT STDMETHODCALLTYPE put_CLXDll( + /* [in] */ BSTR pCLXDll) = 0; + + virtual /* [propget][id] */ HRESULT STDMETHODCALLTYPE get_CLXDll( + /* [retval][out] */ BSTR *pCLXDll) = 0; + + }; + +#else /* C style interface */ + + typedef struct IMsTscDebugVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMsTscDebug * This, + /* [in] */ REFIID riid, + /* [iid_is][out] */ + __RPC__deref_out void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMsTscDebug * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMsTscDebug * This); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( + IMsTscDebug * This, + /* [out] */ UINT *pctinfo); + + HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( + IMsTscDebug * This, + /* [in] */ UINT iTInfo, + /* [in] */ LCID lcid, + /* [out] */ ITypeInfo **ppTInfo); + + HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( + IMsTscDebug * This, + /* [in] */ REFIID riid, + /* [size_is][in] */ LPOLESTR *rgszNames, + /* [range][in] */ UINT cNames, + /* [in] */ LCID lcid, + /* [size_is][out] */ DISPID *rgDispId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( + IMsTscDebug * This, + /* [in] */ DISPID dispIdMember, + /* [in] */ REFIID riid, + /* [in] */ LCID lcid, + /* [in] */ WORD wFlags, + /* [out][in] */ DISPPARAMS *pDispParams, + /* [out] */ VARIANT *pVarResult, + /* [out] */ EXCEPINFO *pExcepInfo, + /* [out] */ UINT *puArgErr); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HatchBitmapPDU )( + IMsTscDebug * This, + /* [in] */ long phatchBitmapPDU); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HatchBitmapPDU )( + IMsTscDebug * This, + /* [retval][out] */ long *phatchBitmapPDU); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HatchSSBOrder )( + IMsTscDebug * This, + /* [in] */ long phatchSSBOrder); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HatchSSBOrder )( + IMsTscDebug * This, + /* [retval][out] */ long *phatchSSBOrder); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HatchMembltOrder )( + IMsTscDebug * This, + /* [in] */ long phatchMembltOrder); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HatchMembltOrder )( + IMsTscDebug * This, + /* [retval][out] */ long *phatchMembltOrder); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_HatchIndexPDU )( + IMsTscDebug * This, + /* [in] */ long phatchIndexPDU); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_HatchIndexPDU )( + IMsTscDebug * This, + /* [retval][out] */ long *phatchIndexPDU); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_LabelMemblt )( + IMsTscDebug * This, + /* [in] */ long plabelMemblt); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_LabelMemblt )( + IMsTscDebug * This, + /* [retval][out] */ long *plabelMemblt); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BitmapCacheMonitor )( + IMsTscDebug * This, + /* [in] */ long pbitmapCacheMonitor); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BitmapCacheMonitor )( + IMsTscDebug * This, + /* [retval][out] */ long *pbitmapCacheMonitor); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_MallocFailuresPercent )( + IMsTscDebug * This, + /* [in] */ long pmallocFailuresPercent); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_MallocFailuresPercent )( + IMsTscDebug * This, + /* [retval][out] */ long *pmallocFailuresPercent); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_MallocHugeFailuresPercent )( + IMsTscDebug * This, + /* [in] */ long pmallocHugeFailuresPercent); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_MallocHugeFailuresPercent )( + IMsTscDebug * This, + /* [retval][out] */ long *pmallocHugeFailuresPercent); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_NetThroughput )( + IMsTscDebug * This, + /* [in] */ long NetThroughput); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_NetThroughput )( + IMsTscDebug * This, + /* [retval][out] */ long *NetThroughput); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_CLXCmdLine )( + IMsTscDebug * This, + /* [in] */ BSTR pCLXCmdLine); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_CLXCmdLine )( + IMsTscDebug * This, + /* [retval][out] */ BSTR *pCLXCmdLine); + + /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_CLXDll )( + IMsTscDebug * This, + /* [in] */ BSTR pCLXDll); + + /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_CLXDll )( + IMsTscDebug * This, + /* [retval][out] */ BSTR *pCLXDll); + + END_INTERFACE + } IMsTscDebugVtbl; + + interface IMsTscDebug + { + CONST_VTBL struct IMsTscDebugVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMsTscDebug_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMsTscDebug_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMsTscDebug_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMsTscDebug_GetTypeInfoCount(This,pctinfo) \ + ( (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo) ) + +#define IMsTscDebug_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \ + ( (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo) ) + +#define IMsTscDebug_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \ + ( (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) ) + +#define IMsTscDebug_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \ + ( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) ) + + +#define IMsTscDebug_put_HatchBitmapPDU(This,phatchBitmapPDU) \ + ( (This)->lpVtbl -> put_HatchBitmapPDU(This,phatchBitmapPDU) ) + +#define IMsTscDebug_get_HatchBitmapPDU(This,phatchBitmapPDU) \ + ( (This)->lpVtbl -> get_HatchBitmapPDU(This,phatchBitmapPDU) ) + +#define IMsTscDebug_put_HatchSSBOrder(This,phatchSSBOrder) \ + ( (This)->lpVtbl -> put_HatchSSBOrder(This,phatchSSBOrder) ) + +#define IMsTscDebug_get_HatchSSBOrder(This,phatchSSBOrder) \ + ( (This)->lpVtbl -> get_HatchSSBOrder(This,phatchSSBOrder) ) + +#define IMsTscDebug_put_HatchMembltOrder(This,phatchMembltOrder) \ + ( (This)->lpVtbl -> put_HatchMembltOrder(This,phatchMembltOrder) ) + +#define IMsTscDebug_get_HatchMembltOrder(This,phatchMembltOrder) \ + ( (This)->lpVtbl -> get_HatchMembltOrder(This,phatchMembltOrder) ) + +#define IMsTscDebug_put_HatchIndexPDU(This,phatchIndexPDU) \ + ( (This)->lpVtbl -> put_HatchIndexPDU(This,phatchIndexPDU) ) + +#define IMsTscDebug_get_HatchIndexPDU(This,phatchIndexPDU) \ + ( (This)->lpVtbl -> get_HatchIndexPDU(This,phatchIndexPDU) ) + +#define IMsTscDebug_put_LabelMemblt(This,plabelMemblt) \ + ( (This)->lpVtbl -> put_LabelMemblt(This,plabelMemblt) ) + +#define IMsTscDebug_get_LabelMemblt(This,plabelMemblt) \ + ( (This)->lpVtbl -> get_LabelMemblt(This,plabelMemblt) ) + +#define IMsTscDebug_put_BitmapCacheMonitor(This,pbitmapCacheMonitor) \ + ( (This)->lpVtbl -> put_BitmapCacheMonitor(This,pbitmapCacheMonitor) ) + +#define IMsTscDebug_get_BitmapCacheMonitor(This,pbitmapCacheMonitor) \ + ( (This)->lpVtbl -> get_BitmapCacheMonitor(This,pbitmapCacheMonitor) ) + +#define IMsTscDebug_put_MallocFailuresPercent(This,pmallocFailuresPercent) \ + ( (This)->lpVtbl -> put_MallocFailuresPercent(This,pmallocFailuresPercent) ) + +#define IMsTscDebug_get_MallocFailuresPercent(This,pmallocFailuresPercent) \ + ( (This)->lpVtbl -> get_MallocFailuresPercent(This,pmallocFailuresPercent) ) + +#define IMsTscDebug_put_MallocHugeFailuresPercent(This,pmallocHugeFailuresPercent) \ + ( (This)->lpVtbl -> put_MallocHugeFailuresPercent(This,pmallocHugeFailuresPercent) ) + +#define IMsTscDebug_get_MallocHugeFailuresPercent(This,pmallocHugeFailuresPercent) \ + ( (This)->lpVtbl -> get_MallocHugeFailuresPercent(This,pmallocHugeFailuresPercent) ) + +#define IMsTscDebug_put_NetThroughput(This,NetThroughput) \ + ( (This)->lpVtbl -> put_NetThroughput(This,NetThroughput) ) + +#define IMsTscDebug_get_NetThroughput(This,NetThroughput) \ + ( (This)->lpVtbl -> get_NetThroughput(This,NetThroughput) ) + +#define IMsTscDebug_put_CLXCmdLine(This,pCLXCmdLine) \ + ( (This)->lpVtbl -> put_CLXCmdLine(This,pCLXCmdLine) ) + +#define IMsTscDebug_get_CLXCmdLine(This,pCLXCmdLine) \ + ( (This)->lpVtbl -> get_CLXCmdLine(This,pCLXCmdLine) ) + +#define IMsTscDebug_put_CLXDll(This,pCLXDll) \ + ( (This)->lpVtbl -> put_CLXDll(This,pCLXDll) ) + +#define IMsTscDebug_get_CLXDll(This,pCLXDll) \ + ( (This)->lpVtbl -> get_CLXDll(This,pCLXDll) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMsTscDebug_INTERFACE_DEFINED__ */ + + +EXTERN_C const CLSID CLSID_MsTscAx; + +#ifdef __cplusplus + +class DECLSPEC_UUID("A41A4187-5A86-4E26-B40A-856F9035D9CB") +MsTscAx; +#endif + +EXTERN_C const CLSID CLSID_MsRdpClient; + +#ifdef __cplusplus + +class DECLSPEC_UUID("7CACBD7B-0D99-468F-AC33-22E495C0AFE5") +MsRdpClient; +#endif + +EXTERN_C const CLSID CLSID_MsRdpClient2; + +#ifdef __cplusplus + +class DECLSPEC_UUID("3523C2FB-4031-44E4-9A3B-F1E94986EE7F") +MsRdpClient2; +#endif + +EXTERN_C const CLSID CLSID_MsRdpClient3; + +#ifdef __cplusplus + +class DECLSPEC_UUID("ACE575FD-1FCF-4074-9401-EBAB990FA9DE") +MsRdpClient3; +#endif + +EXTERN_C const CLSID CLSID_MsRdpClient4; + +#ifdef __cplusplus + +class DECLSPEC_UUID("6AE29350-321B-42BE-BBE5-12FB5270C0DE") +MsRdpClient4; +#endif +#endif /* __MSTSCLib_LIBRARY_DEFINED__ */ + +/* Additional Prototypes for ALL interfaces */ + +/* end of Additional Prototypes */ + +#ifdef __cplusplus +} +#endif + +#endif + + diff --git a/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/mstsclib_i.c b/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/mstsclib_i.c new file mode 100644 index 00000000000..4d25399f08c --- /dev/null +++ b/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/mstsclib_i.c @@ -0,0 +1,145 @@ + + +/* this ALWAYS GENERATED file contains the IIDs and CLSIDs */ + +/* link this file in with the server and any clients */ + + + /* File created by MIDL compiler version 7.00.0493 */ +/* at Mon Jul 31 17:27:49 2006 + */ +/* Compiler settings for .\mstsclib.idl: + Oicf, W1, Zp8, env=Win32 (32b run) + protocol : dce , ms_ext, c_ext, robust + error checks: allocation ref bounds_check enum stub_data + VC __declspec() decoration level: + __declspec(uuid()), __declspec(selectany), __declspec(novtable) + DECLSPEC_UUID(), MIDL_INTERFACE() +*/ +//@@MIDL_FILE_HEADING( ) + +#pragma warning( disable: 4049 ) /* more than 64k source lines */ + + +#ifdef __cplusplus +extern "C"{ +#endif + + +#include +#include + +#ifdef _MIDL_USE_GUIDDEF_ + +#ifndef INITGUID +#define INITGUID +#include +#undef INITGUID +#else +#include +#endif + +#define MIDL_DEFINE_GUID(type,name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \ + DEFINE_GUID(name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) + +#else // !_MIDL_USE_GUIDDEF_ + +#ifndef __IID_DEFINED__ +#define __IID_DEFINED__ + +typedef struct _IID +{ + unsigned long x; + unsigned short s1; + unsigned short s2; + unsigned char c[8]; +} IID; + +#endif // __IID_DEFINED__ + +#ifndef CLSID_DEFINED +#define CLSID_DEFINED +typedef IID CLSID; +#endif // CLSID_DEFINED + +#define MIDL_DEFINE_GUID(type,name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \ + const type name = {l,w1,w2,{b1,b2,b3,b4,b5,b6,b7,b8}} + +#endif !_MIDL_USE_GUIDDEF_ + +MIDL_DEFINE_GUID(IID, LIBID_MSTSCLib,0x8C11EFA1,0x92C3,0x11D1,0xBC,0x1E,0x00,0xC0,0x4F,0xA3,0x14,0x89); + + +MIDL_DEFINE_GUID(IID, DIID_IMsTscAxEvents,0x336D5562,0xEFA8,0x482E,0x8C,0xB3,0xC5,0xC0,0xFC,0x7A,0x7D,0xB6); + + +MIDL_DEFINE_GUID(IID, IID_IMsTscAx,0x8C11EFAE,0x92C3,0x11D1,0xBC,0x1E,0x00,0xC0,0x4F,0xA3,0x14,0x89); + + +MIDL_DEFINE_GUID(IID, IID_IMsRdpClient,0x92B4A539,0x7115,0x4B7C,0xA5,0xA9,0xE5,0xD9,0xEF,0xC2,0x78,0x0A); + + +MIDL_DEFINE_GUID(IID, IID_IMsRdpClient2,0xE7E17DC4,0x3B71,0x4BA7,0xA8,0xE6,0x28,0x1F,0xFA,0xDC,0xA2,0x8F); + + +MIDL_DEFINE_GUID(IID, IID_IMsRdpClient3,0x91B7CBC5,0xA72E,0x4FA0,0x93,0x00,0xD6,0x47,0xD7,0xE8,0x97,0xFF); + + +MIDL_DEFINE_GUID(IID, IID_IMsRdpClient4,0x095E0738,0xD97D,0x488B,0xB9,0xF6,0xDD,0x0E,0x8D,0x66,0xC0,0xDE); + + +MIDL_DEFINE_GUID(IID, IID_IMsTscNonScriptable,0xC1E6743A,0x41C1,0x4A74,0x83,0x2A,0x0D,0xD0,0x6C,0x1C,0x7A,0x0E); + + +MIDL_DEFINE_GUID(IID, IID_IMsRdpClientNonScriptable,0x2F079C4C,0x87B2,0x4AFD,0x97,0xAB,0x20,0xCD,0xB4,0x30,0x38,0xAE); + + +MIDL_DEFINE_GUID(IID, IID_IMsRdpClientNonScriptable2,0x17A5E535,0x4072,0x4FA4,0xAF,0x32,0xC8,0xD0,0xD4,0x73,0x45,0xE9); + + +MIDL_DEFINE_GUID(IID, IID_IMsTscAdvancedSettings,0x809945CC,0x4B3B,0x4A92,0xA6,0xB0,0xDB,0xF9,0xB5,0xF2,0xEF,0x2D); + + +MIDL_DEFINE_GUID(IID, IID_IMsRdpClientAdvancedSettings,0x3C65B4AB,0x12B3,0x465B,0xAC,0xD4,0xB8,0xDA,0xD3,0xBF,0xF9,0xE2); + + +MIDL_DEFINE_GUID(IID, IID_IMsRdpClientAdvancedSettings2,0x9AC42117,0x2B76,0x4320,0xAA,0x44,0x0E,0x61,0x6A,0xB8,0x43,0x7B); + + +MIDL_DEFINE_GUID(IID, IID_IMsRdpClientAdvancedSettings3,0x19CD856B,0xC542,0x4C53,0xAC,0xEE,0xF1,0x27,0xE3,0xBE,0x1A,0x59); + + +MIDL_DEFINE_GUID(IID, IID_IMsRdpClientAdvancedSettings4,0xFBA7F64E,0x7345,0x4405,0xAE,0x50,0xFA,0x4A,0x76,0x3D,0xC0,0xDE); + + +MIDL_DEFINE_GUID(IID, IID_IMsTscSecuredSettings,0xC9D65442,0xA0F9,0x45B2,0x8F,0x73,0xD6,0x1D,0x2D,0xB8,0xCB,0xB6); + + +MIDL_DEFINE_GUID(IID, IID_IMsRdpClientSecuredSettings,0x605BEFCF,0x39C1,0x45CC,0xA8,0x11,0x06,0x8F,0xB7,0xBE,0x34,0x6D); + + +MIDL_DEFINE_GUID(IID, IID_IMsTscDebug,0x209D0EB9,0x6254,0x47B1,0x90,0x33,0xA9,0x8D,0xAE,0x55,0xBB,0x27); + + +MIDL_DEFINE_GUID(CLSID, CLSID_MsTscAx,0xA41A4187,0x5A86,0x4E26,0xB4,0x0A,0x85,0x6F,0x90,0x35,0xD9,0xCB); + + +MIDL_DEFINE_GUID(CLSID, CLSID_MsRdpClient,0x7CACBD7B,0x0D99,0x468F,0xAC,0x33,0x22,0xE4,0x95,0xC0,0xAF,0xE5); + + +MIDL_DEFINE_GUID(CLSID, CLSID_MsRdpClient2,0x3523C2FB,0x4031,0x44E4,0x9A,0x3B,0xF1,0xE9,0x49,0x86,0xEE,0x7F); + + +MIDL_DEFINE_GUID(CLSID, CLSID_MsRdpClient3,0xACE575FD,0x1FCF,0x4074,0x94,0x01,0xEB,0xAB,0x99,0x0F,0xA9,0xDE); + + +MIDL_DEFINE_GUID(CLSID, CLSID_MsRdpClient4,0x6AE29350,0x321B,0x42BE,0xBB,0xE5,0x12,0xFB,0x52,0x70,0xC0,0xDE); + +#undef MIDL_DEFINE_GUID + +#ifdef __cplusplus +} +#endif + + + diff --git a/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/rdesktop-core-tester.cpp b/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/rdesktop-core-tester.cpp index db22a583201..3827e176904 100644 --- a/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/rdesktop-core-tester.cpp +++ b/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/rdesktop-core-tester.cpp @@ -15,16 +15,6 @@ template T alignup(const T& X, const U& align) return aligndown(X + (align - 1), align); } -#ifdef _WIN64 -#else - -#undef InterlockedExchangePointer - -#define InterlockedExchangePointer(Target, Value) \ - LongToPtr(InterlockedExchange((LONG volatile *)(Target), PtrToLong(Value))) - -#endif - extern "C" { /* ==== BEGIN POOP ==== */ @@ -325,65 +315,6 @@ extern "C" HDC hdcBuffer; UINT wmZMouseWheel; -#if 0 - // NOTE: we don't really need these with rdesktop.c out of the picture - BOOL - ui_init(RDPCLIENT * This) - { - return 0; - } - - void - ui_deinit(RDPCLIENT * This) - { - } - - BOOL - ui_create_window(RDPCLIENT * This) - { - return 0; - } -#endif - - void - ui_resize_window(RDPCLIENT * This) - { - // TODO - } - -#if 0 - void - ui_destroy_window(RDPCLIENT * This) - { - } -#endif - - int - ui_select(RDPCLIENT * This, int rdp_socket) - { - return 1; // TODO: return 0 for user quit. Or just kill this silly function - } - - void - ui_move_pointer(RDPCLIENT * This, int x, int y) - { - POINT point; - point.x = x; - point.y = y; - - ClientToScreen(hwnd, &point); - SetCursorPos(point.x, point.y); - } - - HCURSOR hcursor; - - struct Bitmap - { - int width; - int height; - uint8 data[1]; - }; - static HBITMAP win32_create_dib(LONG width, LONG height, WORD bitcount, const BYTE * data) @@ -430,6 +361,7 @@ extern "C" uint8 * win32_convert_scanlines(int width, int height, int bitcount, int fromalign, int toalign, const uint8 * data, uint8 ** buffer) { + // TBD: profile & optimize the most common cases assert(width > 0); assert(height); assert(bitcount && bitcount <= 32); @@ -477,6 +409,31 @@ extern "C" return dibits; } + void + ui_resize_window(RDPCLIENT * This) + { + SetWindowPos(hwnd, NULL, 0, 0, This->width, This->height, SWP_ASYNCWINDOWPOS | SWP_NOACTIVATE | SWP_NOCOPYBITS | SWP_NOMOVE); + } + + int + ui_select(RDPCLIENT * This, int rdp_socket) + { + return 1; // TODO: return 0 for user quit. Or just kill this silly function + } + + void + ui_move_pointer(RDPCLIENT * This, int x, int y) + { + POINT point; + point.x = x; + point.y = y; + + ClientToScreen(hwnd, &point); + SetCursorPos(point.x, point.y); + } + + HCURSOR hcursor; + HBITMAP ui_create_bitmap(RDPCLIENT * This, int width, int height, uint8 * data) { @@ -706,44 +663,13 @@ extern "C" InvalidateRgn(hwnd, NULL, FALSE); } - void - ui_paint_bitmap(RDPCLIENT * This, int x, int y, int cx, int cy, int width, int height, uint8 * data) - { - GdiFlush(); - - int Bpp = This->server_depth / 8; - int fromstride = alignup(width * Bpp, 4); - int tostride = alignup(This->width * Bpp, 4); - int sizex = cx * Bpp; - - const uint8 * src = data; - uint8 * dst = (uint8 *)pBuffer + (This->height - y - cy) * tostride + x * Bpp; - - for(int i = 0; i < cy; ++ i) - { - memcpy(dst, src, sizex); - src += fromstride; - dst += tostride; - } - - win32_repaint_area(This, x, y, cx, cy); - } - - void - ui_destblt(RDPCLIENT * This, uint8 opcode, - /* dest */ int x, int y, int cx, int cy) - { - HGDIOBJ holdbrush = SelectObject(hdcBuffer, GetStockObject(BLACK_BRUSH)); - PatBlt(hdcBuffer, x, y, cx, cy, MAKELONG(0, opcode)); - SelectObject(hdcBuffer, holdbrush); - - win32_repaint_area(This, x, y, cx, cy); - } - static HBRUSH win32_create_brush(RDPCLIENT * This, BRUSH * brush, COLORREF fgcolour) { + if(brush == NULL) + return (HBRUSH)GetStockObject(NULL_BRUSH); + switch(brush->style) { case BS_SOLID: @@ -774,7 +700,7 @@ extern "C" uint16 pattern[8]; for(size_t i = 0; i < 8; ++ i) - pattern[7 - i] = brush->pattern[i]; + pattern[i] = brush->pattern[i]; HBITMAP hpattern = CreateBitmap(8, 8, 1, 1, pattern); HBRUSH hbr = CreatePatternBrush(hpattern); @@ -786,6 +712,45 @@ extern "C" } } + void + ui_paint_bitmap(RDPCLIENT * This, int x, int y, int cx, int cy, int width, int height, uint8 * data) + { + assert(This->server_depth >= 8); + assert(rcClip.left == 0 && rcClip.top == 0 && rcClip.right == This->width + 1 && rcClip.bottom == This->height + 1); + + GdiFlush(); + + // TBD: we can cache these values + int Bpp = alignup(This->server_depth, 8) / 8; + int tostride = alignup(This->width * Bpp, 4); + + int fromstride = alignup(width * Bpp, 4); + int sizex = cx * Bpp; + + const uint8 * src = data; + uint8 * dst = (uint8 *)pBuffer + (This->height - y - cy) * tostride + x * Bpp; + + for(int i = 0; i < cy; ++ i) + { + memcpy(dst, src, sizex); + src += fromstride; + dst += tostride; + } + + win32_repaint_area(This, x, y, cx, cy); + } + + void + ui_destblt(RDPCLIENT * This, uint8 opcode, + /* dest */ int x, int y, int cx, int cy) + { + int dcsave = SaveDC(hdcBuffer); + SelectObject(hdcBuffer, GetStockObject(BLACK_BRUSH)); + PatBlt(hdcBuffer, x, y, cx, cy, MAKELONG(0, opcode)); + RestoreDC(hdcBuffer, dcsave); + win32_repaint_area(This, x, y, cx, cy); + } + void ui_patblt(RDPCLIENT * This, uint8 opcode, /* dest */ int x, int y, int cx, int cy, @@ -793,17 +758,16 @@ extern "C" { HBRUSH hbr = win32_create_brush(This, brush, fgcolour); - int oldbkcolor = SetBkColor(hdcBuffer, bgcolour); - int oldtextcolor = SetTextColor(hdcBuffer, fgcolour); - POINT oldbrushorg; SetBrushOrgEx(hdcBuffer, brush->xorigin, brush->yorigin, &oldbrushorg); - HGDIOBJ holdbrush = SelectObject(hdcBuffer, hbr); + int dcsave = SaveDC(hdcBuffer); + + SetBkColor(hdcBuffer, bgcolour); + SetTextColor(hdcBuffer, fgcolour); + SetBrushOrgEx(hdcBuffer, brush->xorigin, brush->yorigin, NULL); + SelectObject(hdcBuffer, hbr); PatBlt(hdcBuffer, x, y, cx, cy, MAKELONG(0, opcode)); - SelectObject(hdcBuffer, holdbrush); - SetBrushOrgEx(hdcBuffer, oldbrushorg.x, oldbrushorg.y, NULL); - SetTextColor(hdcBuffer, oldtextcolor); - SetBkColor(hdcBuffer, oldbkcolor); + RestoreDC(hdcBuffer, dcsave); DeleteObject(hbr); @@ -841,6 +805,7 @@ extern "C" /* src */ HBITMAP src, int srcx, int srcy, /* brush */ BRUSH * brush, int bgcolour, int fgcolour) { + // TODO HDC hdcSrc = CreateCompatibleDC(hdcBuffer); HGDIOBJ hOld = SelectObject(hdcSrc, src); @@ -863,15 +828,15 @@ extern "C" { HPEN hpen = CreatePen(pen->style, pen->width, pen->colour); - int oldROP2 = SetROP2(hdcBuffer, opcode); - HGDIOBJ holdpen = SelectObject(hdcBuffer, hpen); - POINT oldpos; MoveToEx(hdcBuffer, startx, starty, &oldpos); + int dcsave = SaveDC(hdcBuffer); + + SetROP2(hdcBuffer, opcode); + SelectObject(hdcBuffer, hpen); + MoveToEx(hdcBuffer, startx, starty, NULL); LineTo(hdcBuffer, endx, endy); - MoveToEx(hdcBuffer, oldpos.x, oldpos.y, NULL); - SelectObject(hdcBuffer, holdpen); - SetROP2(hdcBuffer, oldROP2); + RestoreDC(hdcBuffer, dcsave); DeleteObject(hpen); @@ -910,14 +875,15 @@ extern "C" { HBRUSH hbr = CreateSolidBrush(colour); - HGDIOBJ holdbrush = SelectObject(hdcBuffer, hbr); - HGDIOBJ holdpen = SelectObject(hdcBuffer, GetStockObject(NULL_PEN)); + int dcsave = SaveDC(hdcBuffer); + + SelectObject(hdcBuffer, hbr); + SelectObject(hdcBuffer, GetStockObject(NULL_PEN)); Rectangle(hdcBuffer, x, y, x + cx + 1, y + cy + 1); - SelectObject(hdcBuffer, holdpen); - SelectObject(hdcBuffer, holdbrush); - + RestoreDC(hdcBuffer, dcsave); + DeleteObject(hbr); win32_repaint_area(This, x, y, cx, cy); @@ -931,17 +897,16 @@ extern "C" { HBRUSH hbr = win32_create_brush(This, brush, fgcolour); - int oldbkcolor = SetBkColor(hdcBuffer, bgcolour); - int oldtextcolor = SetTextColor(hdcBuffer, fgcolour); - int oldFillMode = SetPolyFillMode(hdcBuffer, fillmode); - HGDIOBJ holdbrush = SelectObject(hdcBuffer, hbr); + int dcsave = SaveDC(hdcBuffer); + + SetBkColor(hdcBuffer, bgcolour); + SetTextColor(hdcBuffer, fgcolour); + SetPolyFillMode(hdcBuffer, fillmode); + SelectObject(hdcBuffer, hbr); Polygon(hdcBuffer, point, npoints); - SelectObject(hdcBuffer, holdbrush); - SetPolyFillMode(hdcBuffer, oldFillMode); - SetTextColor(hdcBuffer, oldtextcolor); - SetBkColor(hdcBuffer, oldbkcolor); + RestoreDC(hdcBuffer, dcsave); win32_repaint_poly(This, point, npoints, 0); } @@ -962,13 +927,14 @@ extern "C" HPEN hpen = CreatePen(pen->style, pen->width, pen->colour); - int oldROP2 = SetROP2(hdcBuffer, opcode); - HGDIOBJ holdpen = SelectObject(hdcBuffer, hpen); + int dcsave = SaveDC(hdcBuffer); + + SetROP2(hdcBuffer, opcode); + SelectObject(hdcBuffer, hpen); Polyline(hdcBuffer, points, npoints); - SelectObject(hdcBuffer, holdpen); - SetROP2(hdcBuffer, oldROP2); + RestoreDC(hdcBuffer, dcsave); DeleteObject(hpen); @@ -981,33 +947,12 @@ extern "C" /* dest */ int x, int y, int cx, int cy, /* brush */ BRUSH * brush, int bgcolour, int fgcolour) { - switch(fillmode) - { - case 0: // outline - { - HPEN hpen = CreatePen(PS_SOLID, 1, fgcolour); - - int oldROP2 = SetROP2(hdcBuffer, opcode); - HGDIOBJ holdPen = SelectObject(hdcBuffer, hpen); - - Ellipse(hdcBuffer, x, y, x + cx, y + cy); - - SelectObject(hdcBuffer, holdPen); - SetROP2(hdcBuffer, oldROP2); - - DeleteObject(hpen); - } - - break; - - case 1: - // TODO - break; - } + // TODO win32_repaint_area(This, x, y, cx, cy); } + // TBD: optimize text drawing void ui_draw_glyph(RDPCLIENT * This, int mixmode, /* dest */ int x, int y, int cx, int cy, @@ -1018,6 +963,8 @@ extern "C" HDC hdcGlyph = CreateCompatibleDC(hdcBuffer); HGDIOBJ hOld = SelectObject(hdcGlyph, hbmGlyph); + int dcsave = SaveDC(hdcBuffer); + switch(mixmode) { case MIX_TRANSPARENT: @@ -1030,9 +977,8 @@ extern "C" This paints a transparent glyph in the specified color */ HBRUSH hbr = CreateSolidBrush(fgcolour); - HGDIOBJ holdbrush = SelectObject(hdcBuffer, hbr); + SelectObject(hdcBuffer, hbr); BitBlt(hdcBuffer, x, y, cx, cy, hdcGlyph, srcx, srcy, MAKELONG(0, 0xe2)); - SelectObject(hdcBuffer, holdbrush); DeleteObject(hbr); } @@ -1041,22 +987,23 @@ extern "C" case MIX_OPAQUE: { /* Curiously, glyphs are inverted (white-on-black) */ - int oldbkcolor = SetBkColor(hdcBuffer, fgcolour); - int oldtextcolor = SetTextColor(hdcBuffer, bgcolour); + SetBkColor(hdcBuffer, fgcolour); + SetTextColor(hdcBuffer, bgcolour); BitBlt(hdcBuffer, x, y, cx, cy, hdcGlyph, srcx, srcy, SRCCOPY); - SetTextColor(hdcBuffer, oldtextcolor); - SetBkColor(hdcBuffer, oldbkcolor); } break; } + RestoreDC(hdcBuffer, dcsave); + SelectObject(hdcGlyph, hOld); DeleteDC(hdcGlyph); win32_repaint_area(This, x, y, cx, cy); } + // TBD: a clean-up would be nice, too... #define DO_GLYPH(ttext,idx) \ {\ glyph = cache_get_font (This, font, ttext[idx]);\ @@ -1189,26 +1136,48 @@ extern "C" void ui_desktop_save(RDPCLIENT * This, uint32 offset, int x, int y, int cx, int cy) { - // TODO + GdiFlush(); + int Bpp = alignup(This->server_depth, 8) / 8; + int stride = alignup(This->width * Bpp, 4); + uint8 * data = (uint8 *)pBuffer + x * Bpp + (This->height - y - cy) * stride; + cache_put_desktop(This, offset * Bpp, cx, cy, stride, Bpp, data); } void ui_desktop_restore(RDPCLIENT * This, uint32 offset, int x, int y, int cx, int cy) { - // TODO - win32_repaint_whole(This); + // TBD: we can cache these values + int Bpp = alignup(This->server_depth, 8) / 8; + int tostride = alignup(This->width * Bpp, 4); + int fromstride = cx * Bpp; + + const uint8 * src = cache_get_desktop(This, offset, cx, cy, Bpp); + uint8 * dst = (uint8 *)pBuffer + x * Bpp + (This->height - y - cy) * tostride; + + GdiFlush(); + + for(int i = 0; i < cy; ++ i) + { + memcpy(dst, src, fromstride); + src += fromstride; + dst += tostride; + } + + win32_repaint_area(This, x, y, cx, cy); } + int nSavedDC; + void ui_begin_update(RDPCLIENT * This) { - // TODO? use a mutex to arbitrate access to the off-screen buffer? + nSavedDC = SaveDC(hdcBuffer); } void ui_end_update(RDPCLIENT * This) { - // TODO? use a mutex to arbitrate access to the off-screen buffer? + RestoreDC(hdcBuffer, nSavedDC); } }; @@ -1233,13 +1202,7 @@ mstsc_mousewheel(RDPCLIENT * This, int value, LPARAM lparam) static LRESULT CALLBACK -mstsc_WndProc -( - HWND hwnd, - UINT uMsg, - WPARAM wparam, - LPARAM lparam -) +mstsc_WndProc(HWND hwnd, UINT uMsg, WPARAM wparam, LPARAM lparam) { // BUGBUG: LongToPtr & PtrToLong will break on Win64 @@ -1396,8 +1359,8 @@ mstsc_ProtocolIOThread uint32 flags = RDP_LOGON_NORMAL | RDP_LOGON_COMPRESSION | RDP_LOGON_COMPRESSION2; - //rdp_connect(This, "10.0.0.3", flags, "", "", "", ""); - rdp_connect(This, "192.168.7.232", flags, "", "", "", ""); + rdp_connect(This, "10.0.0.3", flags, "", "", "", ""); + //rdp_connect(This, "192.168.7.232", flags, "", "", "", ""); hdcBuffer = CreateCompatibleDC(NULL); @@ -1420,8 +1383,8 @@ mstsc_ProtocolIOThread rcClip.left = 0; rcClip.top = 0; - rcClip.right = This->width; - rcClip.bottom = This->height; + rcClip.right = This->width + 1; + rcClip.bottom = This->height + 1; BOOL deactivated; uint32 ext_disc_reason; @@ -1433,6 +1396,142 @@ mstsc_ProtocolIOThread return 0; } +/* Virtual channel stuff */ +extern "C" void channel_process(RDPCLIENT * This, STREAM s, uint16 mcs_channel) +{ +} + +DWORD tlsIndex; + +typedef struct CHANNEL_HANDLE_ +{ + RDPCLIENT * client; + int channel; +} +CHANNEL_HANDLE; + +static +UINT +VCAPITYPE +VirtualChannelInit +( + LPVOID * ppInitHandle, + PCHANNEL_DEF pChannel, + INT channelCount, + ULONG versionRequested, + PCHANNEL_INIT_EVENT_FN pChannelInitEventProc +) +{ + if(channelCount <= 0) + return CHANNEL_RC_BAD_CHANNEL; + + if(ppInitHandle == NULL) + return CHANNEL_RC_BAD_INIT_HANDLE; + + if(pChannel == NULL) + return CHANNEL_RC_BAD_CHANNEL; + + if(pChannelInitEventProc == NULL) + return CHANNEL_RC_BAD_PROC; + + RDPCLIENT * This = (RDPCLIENT *)TlsGetValue(tlsIndex); + + if(This == NULL) + return CHANNEL_RC_NOT_IN_VIRTUALCHANNELENTRY; + + if(This->num_channels + channelCount > CHANNEL_MAX_COUNT) + return CHANNEL_RC_TOO_MANY_CHANNELS; + + for(INT i = 0; i < channelCount; ++ i) + { + if(strlen(pChannel[i].name) > CHANNEL_NAME_LEN) + return CHANNEL_RC_BAD_CHANNEL; + } + + memcpy(This->channel_defs + This->num_channels, pChannel, sizeof(*pChannel) * channelCount); + + for(INT i = 0; i < channelCount; ++ i) + { + pChannel[i].options |= CHANNEL_OPTION_INITIALIZED; + + int j = This->num_channels + i; + This->channel_data[j].opened = 0; + This->channel_data[j].pChannelInitEventProc = pChannelInitEventProc; + This->channel_data[j].pChannelOpenEventProc = NULL; + } + + This->num_channels += channelCount; + + *ppInitHandle = This; + + return CHANNEL_RC_OK; +} + +UINT +VCAPITYPE +VirtualChannelOpen +( + LPVOID pInitHandle, + LPDWORD pOpenHandle, + PCHAR pChannelName, + PCHANNEL_OPEN_EVENT_FN pChannelOpenEventProc +) +{ + if(pInitHandle == NULL) + return CHANNEL_RC_BAD_INIT_HANDLE; + + if(pOpenHandle == NULL) + return CHANNEL_RC_BAD_CHANNEL_HANDLE; + + if(pChannelName == NULL) + return CHANNEL_RC_UNKNOWN_CHANNEL_NAME; + + if(pChannelOpenEventProc == NULL) + return CHANNEL_RC_BAD_PROC; + + RDPCLIENT * This = (RDPCLIENT *)pInitHandle; + + for(unsigned i = 0; i < This->num_channels; ++ i) + { + if(strcmp(pChannelName, This->channel_defs[i].name) == 0) + { + if(This->channel_data[i].opened) + return CHANNEL_RC_ALREADY_OPEN; + + This->channel_data[i].opened = 1; + This->channel_data[i].pChannelOpenEventProc = pChannelOpenEventProc; + + // TODO: allocate a handle here + *pOpenHandle = 0; + + break; + } + } + + return CHANNEL_RC_OK; +} + +UINT VCAPITYPE VirtualChannelClose +( + DWORD openHandle +) +{ + // TODO: channel handle management + return CHANNEL_RC_BAD_CHANNEL_HANDLE; +} + +UINT VCAPITYPE VirtualChannelWrite +( + DWORD openHandle, + LPVOID pData, + ULONG dataLength, + LPVOID pUserData +) +{ + // TODO + return CHANNEL_RC_BAD_CHANNEL_HANDLE; +} + int wmain() { WSADATA wsd; @@ -1459,8 +1558,8 @@ int wmain() This->keyboard_type = 0x4; This->keyboard_subtype = 0x0; This->keyboard_functionkeys = 0xc; - This->width = 1024; - This->height = 768; + This->width = 800; + This->height = 600; This->server_depth = 24; This->bitmap_compression = True; This->sendmotion = True; @@ -1469,7 +1568,7 @@ int wmain() This->bitmap_cache_precache = True; This->encryption = True; This->packet_encryption = True; - This->desktop_save = False; // True; + This->desktop_save = True; This->polygon_ellipse_orders = False; // = True; This->fullscreen = False; This->grab_keyboard = True; diff --git a/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/rdesktop-core-tester.vcproj b/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/rdesktop-core-tester.vcproj index 84dc5cb1d98..e534bc2d71b 100644 --- a/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/rdesktop-core-tester.vcproj +++ b/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/rdesktop-core-tester.vcproj @@ -36,6 +36,7 @@ /> + + @@ -225,6 +231,66 @@ UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}" > + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/stdafx.h b/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/stdafx.h index 6afae88394d..ab4f2ce235f 100644 --- a/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/stdafx.h +++ b/reactos/base/applications/tsclient/porting-tools/rdesktop-core-tester/stdafx.h @@ -20,4 +20,9 @@ #include #include +#include +#include +#include +#include + // EOF diff --git a/reactos/base/applications/tsclient/rdesktop/bitmap.c b/reactos/base/applications/tsclient/rdesktop/bitmap.c index 26964b0f02e..5db5ddfb7a9 100644 --- a/reactos/base/applications/tsclient/rdesktop/bitmap.c +++ b/reactos/base/applications/tsclient/rdesktop/bitmap.c @@ -23,7 +23,7 @@ /* comment out #define BITMAP_SPEED_OVER_SIZE below for one slower function */ /* j@american-data.com */ -//#define BITMAP_SPEED_OVER_SIZE +#define BITMAP_SPEED_OVER_SIZE /* indent is confused by this file */ /* *INDENT-OFF* */ diff --git a/reactos/base/applications/tsclient/rdesktop/channels.c b/reactos/base/applications/tsclient/rdesktop/channels.c index bffb39c18ef..44bdd91a8eb 100644 --- a/reactos/base/applications/tsclient/rdesktop/channels.c +++ b/reactos/base/applications/tsclient/rdesktop/channels.c @@ -81,7 +81,7 @@ channel_send(RDPCLIENT * This, STREAM s, VCHANNEL * channel) /* first fragment sent in-place */ s_pop_layer(s, channel_hdr); - length = s->end - s->p - 8; + length = s->end - s->p - sizeof(CHANNEL_PDU_HEADER); DEBUG_CHANNEL(("channel_send, length = %d\n", length)); diff --git a/reactos/base/applications/tsclient/rdesktop/mcs.c b/reactos/base/applications/tsclient/rdesktop/mcs.c index 3bd64b48787..aadb5b1751a 100644 --- a/reactos/base/applications/tsclient/rdesktop/mcs.c +++ b/reactos/base/applications/tsclient/rdesktop/mcs.c @@ -397,7 +397,7 @@ mcs_connect(RDPCLIENT * This, char *server, STREAM mcs_data, char *username) for (i = 0; i < This->num_channels; i++) { - mcs_send_cjrq(This, This->channels[i].mcs_id); + mcs_send_cjrq(This, MCS_GLOBAL_CHANNEL + 1 + i); if (!mcs_recv_cjcf(This)) goto error; } @@ -438,7 +438,7 @@ mcs_reconnect(RDPCLIENT * This, char *server, STREAM mcs_data) for (i = 0; i < This->num_channels; i++) { - mcs_send_cjrq(This, This->channels[i].mcs_id); + mcs_send_cjrq(This, MCS_GLOBAL_CHANNEL + 1 + i); if (!mcs_recv_cjcf(This)) goto error; } diff --git a/reactos/base/applications/tsclient/rdesktop/rdesktop-core.vcproj b/reactos/base/applications/tsclient/rdesktop/rdesktop-core.vcproj index 5cad05a66b1..80dbfd2eebf 100644 --- a/reactos/base/applications/tsclient/rdesktop/rdesktop-core.vcproj +++ b/reactos/base/applications/tsclient/rdesktop/rdesktop-core.vcproj @@ -204,10 +204,6 @@ RelativePath=".\cache.c" > - - diff --git a/reactos/base/applications/tsclient/rdesktop/rdesktop.h b/reactos/base/applications/tsclient/rdesktop/rdesktop.h index 6f7aecbe2af..ce4ceb38b06 100644 --- a/reactos/base/applications/tsclient/rdesktop/rdesktop.h +++ b/reactos/base/applications/tsclient/rdesktop/rdesktop.h @@ -191,12 +191,20 @@ typedef struct _seamless_window } seamless_window; #endif +typedef struct CHANNEL_PRIVATE_ +{ + int opened; + PCHANNEL_INIT_EVENT_FN pChannelInitEventProc; + PCHANNEL_OPEN_EVENT_FN pChannelOpenEventProc; +} +CHANNEL_PRIVATE; + /* holds the whole state of the RDP client */ struct rdpclient { /* channels.c */ -#define MAX_CHANNELS 6 - VCHANNEL channels[MAX_CHANNELS]; + CHANNEL_DEF channel_defs[CHANNEL_MAX_COUNT]; + CHANNEL_PRIVATE channel_data[CHANNEL_MAX_COUNT]; unsigned int num_channels; /* licence.c */ diff --git a/reactos/base/applications/tsclient/rdesktop/secure.c b/reactos/base/applications/tsclient/rdesktop/secure.c index 2b938d3abeb..665f6fa7e1e 100644 --- a/reactos/base/applications/tsclient/rdesktop/secure.c +++ b/reactos/base/applications/tsclient/rdesktop/secure.c @@ -318,6 +318,8 @@ sec_init(RDPCLIENT * This, uint32 flags, int maxlen) } /* Transmit secure transport packet over specified channel */ + +// !!! we need a lock here !!! void sec_send_to_channel(RDPCLIENT * This, STREAM s, uint32 flags, uint16 channel) { @@ -333,8 +335,8 @@ sec_send_to_channel(RDPCLIENT * This, STREAM s, uint32 flags, uint16 channel) datalen = s->end - s->p - 8; #if WITH_DEBUG - //DEBUG(("Sending encrypted packet:\n")); - //hexdump(s->p + 8, datalen); + DEBUG(("Sending encrypted packet:\n")); + hexdump(s->p + 8, datalen); #endif sec_sign(s->p, 8, This->secure.sign_key, This->secure.rc4_key_len, s->p + 8, datalen); @@ -454,8 +456,8 @@ sec_out_mcs_data(RDPCLIENT * This, STREAM s) for (i = 0; i < This->num_channels; i++) { DEBUG_RDP5(("Requesting channel %s\n", This->channels[i].name)); - out_uint8a(s, This->channels[i].name, 8); - out_uint32_be(s, This->channels[i].flags); + out_uint8a(s, This->channel_defs[i].name, 8); + out_uint32_be(s, This->channel_defs[i].options); } } diff --git a/reactos/base/applications/tsclient/rdesktop/types.h b/reactos/base/applications/tsclient/rdesktop/types.h index 54a459639d1..306027e9933 100644 --- a/reactos/base/applications/tsclient/rdesktop/types.h +++ b/reactos/base/applications/tsclient/rdesktop/types.h @@ -132,12 +132,10 @@ typedef struct _key_translation } key_translation; -// TODO: semi-nuke, wrap CHANNEL_DEF typedef struct _VCHANNEL { + CHANNEL_DEF def; uint16 mcs_id; - char name[8]; - uint32 flags; struct stream in; void (*process) (RDPCLIENT *, STREAM); }