diff --git a/rosapps/applications/net/tsclient/MissTosca.sln b/rosapps/applications/net/tsclient/MissTosca.sln
new file mode 100644
index 00000000000..4156cc20bc3
--- /dev/null
+++ b/rosapps/applications/net/tsclient/MissTosca.sln
@@ -0,0 +1,38 @@
+
+Microsoft Visual Studio Solution File, Format Version 9.00
+# Visual C++ Express 2005
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "rdesktop-core", "rdesktop\rdesktop-core.vcproj", "{8620E9B2-9AF0-4F69-A5AF-C195D5F86372}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mstsc", "mstsc\mstsc.vcproj", "{1B415732-1F37-415F-957B-EA436301860D}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mstscax", "mstscax\mstscax.vcproj", "{2C217E9E-9D77-4D6A-9259-216FD56BA56F}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "rdesktop-core-tester", "porting-tools\rdesktop-core-tester\rdesktop-core-tester.vcproj", "{B172A623-E2BD-4E3F-86E6-620548FE255B}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Win32 = Debug|Win32
+ Release|Win32 = Release|Win32
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {8620E9B2-9AF0-4F69-A5AF-C195D5F86372}.Debug|Win32.ActiveCfg = Debug|Win32
+ {8620E9B2-9AF0-4F69-A5AF-C195D5F86372}.Debug|Win32.Build.0 = Debug|Win32
+ {8620E9B2-9AF0-4F69-A5AF-C195D5F86372}.Release|Win32.ActiveCfg = Release|Win32
+ {8620E9B2-9AF0-4F69-A5AF-C195D5F86372}.Release|Win32.Build.0 = Release|Win32
+ {1B415732-1F37-415F-957B-EA436301860D}.Debug|Win32.ActiveCfg = Debug|Win32
+ {1B415732-1F37-415F-957B-EA436301860D}.Debug|Win32.Build.0 = Debug|Win32
+ {1B415732-1F37-415F-957B-EA436301860D}.Release|Win32.ActiveCfg = Release|Win32
+ {1B415732-1F37-415F-957B-EA436301860D}.Release|Win32.Build.0 = Release|Win32
+ {2C217E9E-9D77-4D6A-9259-216FD56BA56F}.Debug|Win32.ActiveCfg = Debug|Win32
+ {2C217E9E-9D77-4D6A-9259-216FD56BA56F}.Debug|Win32.Build.0 = Debug|Win32
+ {2C217E9E-9D77-4D6A-9259-216FD56BA56F}.Release|Win32.ActiveCfg = Release|Win32
+ {2C217E9E-9D77-4D6A-9259-216FD56BA56F}.Release|Win32.Build.0 = Release|Win32
+ {B172A623-E2BD-4E3F-86E6-620548FE255B}.Debug|Win32.ActiveCfg = Debug|Win32
+ {B172A623-E2BD-4E3F-86E6-620548FE255B}.Debug|Win32.Build.0 = Debug|Win32
+ {B172A623-E2BD-4E3F-86E6-620548FE255B}.Release|Win32.ActiveCfg = Release|Win32
+ {B172A623-E2BD-4E3F-86E6-620548FE255B}.Release|Win32.Build.0 = Release|Win32
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
diff --git a/rosapps/applications/net/tsclient/mstsc/mstsc.cpp b/rosapps/applications/net/tsclient/mstsc/mstsc.cpp
new file mode 100644
index 00000000000..106d7296c01
--- /dev/null
+++ b/rosapps/applications/net/tsclient/mstsc/mstsc.cpp
@@ -0,0 +1,7 @@
+#include "stdafx.h"
+
+int _tmain(int argc, _TCHAR* argv[])
+{
+ return 0;
+}
+
diff --git a/rosapps/applications/net/tsclient/mstsc/mstsc.vcproj b/rosapps/applications/net/tsclient/mstsc/mstsc.vcproj
new file mode 100644
index 00000000000..a6d58a9cc1c
--- /dev/null
+++ b/rosapps/applications/net/tsclient/mstsc/mstsc.vcproj
@@ -0,0 +1,223 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/rosapps/applications/net/tsclient/mstsc/stdafx.cpp b/rosapps/applications/net/tsclient/mstsc/stdafx.cpp
new file mode 100644
index 00000000000..f7caa754005
--- /dev/null
+++ b/rosapps/applications/net/tsclient/mstsc/stdafx.cpp
@@ -0,0 +1,8 @@
+// stdafx.cpp : source file that includes just the standard includes
+// mstsc.pch will be the pre-compiled header
+// stdafx.obj will contain the pre-compiled type information
+
+#include "stdafx.h"
+
+// TODO: reference any additional headers you need in STDAFX.H
+// and not in this file
diff --git a/rosapps/applications/net/tsclient/mstsc/stdafx.h b/rosapps/applications/net/tsclient/mstsc/stdafx.h
new file mode 100644
index 00000000000..ddacb46d869
--- /dev/null
+++ b/rosapps/applications/net/tsclient/mstsc/stdafx.h
@@ -0,0 +1,15 @@
+// stdafx.h : include file for standard system include files,
+// or project specific include files that are used frequently, but
+// are changed infrequently
+//
+
+#pragma once
+
+
+#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
+#include
+#include
+
+
+
+// TODO: reference additional headers your program requires here
diff --git a/rosapps/applications/net/tsclient/mstscax/mstscax.cpp b/rosapps/applications/net/tsclient/mstscax/mstscax.cpp
new file mode 100644
index 00000000000..106d7296c01
--- /dev/null
+++ b/rosapps/applications/net/tsclient/mstscax/mstscax.cpp
@@ -0,0 +1,7 @@
+#include "stdafx.h"
+
+int _tmain(int argc, _TCHAR* argv[])
+{
+ return 0;
+}
+
diff --git a/rosapps/applications/net/tsclient/mstscax/mstscax.vcproj b/rosapps/applications/net/tsclient/mstscax/mstscax.vcproj
new file mode 100644
index 00000000000..7b3b3b0144f
--- /dev/null
+++ b/rosapps/applications/net/tsclient/mstscax/mstscax.vcproj
@@ -0,0 +1,223 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/rosapps/applications/net/tsclient/mstscax/stdafx.cpp b/rosapps/applications/net/tsclient/mstscax/stdafx.cpp
new file mode 100644
index 00000000000..9a99ced5d1d
--- /dev/null
+++ b/rosapps/applications/net/tsclient/mstscax/stdafx.cpp
@@ -0,0 +1,8 @@
+// stdafx.cpp : source file that includes just the standard includes
+// mstscax.pch will be the pre-compiled header
+// stdafx.obj will contain the pre-compiled type information
+
+#include "stdafx.h"
+
+// TODO: reference any additional headers you need in STDAFX.H
+// and not in this file
diff --git a/rosapps/applications/net/tsclient/mstscax/stdafx.h b/rosapps/applications/net/tsclient/mstscax/stdafx.h
new file mode 100644
index 00000000000..ddacb46d869
--- /dev/null
+++ b/rosapps/applications/net/tsclient/mstscax/stdafx.h
@@ -0,0 +1,15 @@
+// stdafx.h : include file for standard system include files,
+// or project specific include files that are used frequently, but
+// are changed infrequently
+//
+
+#pragma once
+
+
+#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
+#include
+#include
+
+
+
+// TODO: reference additional headers your program requires here
diff --git a/rosapps/applications/net/tsclient/porting-tools/mstscax/mstscax.cpp b/rosapps/applications/net/tsclient/porting-tools/mstscax/mstscax.cpp
new file mode 100644
index 00000000000..0f01f402370
--- /dev/null
+++ b/rosapps/applications/net/tsclient/porting-tools/mstscax/mstscax.cpp
@@ -0,0 +1,5011 @@
+#include "stdafx.h"
+
+namespace
+{
+ using namespace MSTSCLib;
+
+ typedef HRESULT (STDAPICALLTYPE * PFNDLLGETCLASSOBJECT)(IN REFCLSID rclsid, IN REFIID riid, OUT LPVOID FAR * ppv);
+ typedef HRESULT (STDAPICALLTYPE * PFNDLLCANUNLOADNOW)(void);
+ typedef ULONG (STDAPICALLTYPE * PFNDLLGETTSCCTLVER)(void);
+
+ PFNDLLGETCLASSOBJECT pfnDllGetClassObject = NULL;
+ PFNDLLCANUNLOADNOW pfnDllCanUnloadNow = NULL;
+ PFNDLLGETTSCCTLVER pfnDllGetTscCtlVer = NULL;
+
+ HMODULE hmMstscax = NULL;
+
+ extern "C" char __ImageBase;
+ static const HMODULE hmSelf = reinterpret_cast(&__ImageBase);
+
+ void init()
+ {
+ if(hmMstscax)
+ return;
+
+ 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("original\\mstscax.dll"));
+
+ hmMstscax = LoadLibrary(strPath.c_str());
+ pfnDllGetClassObject = (PFNDLLGETCLASSOBJECT)GetProcAddress(hmMstscax, "DllGetClassObject");
+ pfnDllCanUnloadNow = (PFNDLLCANUNLOADNOW)GetProcAddress(hmMstscax, "DllCanUnloadNow");
+ pfnDllGetTscCtlVer = (PFNDLLGETTSCCTLVER)GetProcAddress(hmMstscax, "DllGetTscCtlVer");
+ }
+
+ void dbgprintf(LPCTSTR fmt, ...)
+ {
+ TCHAR buf[0x1000];
+
+ va_list args;
+ va_start(args, fmt);
+ StringCbVPrintf(buf, sizeof(buf), fmt, args);
+ va_end(args);
+
+ StringCbCat(buf, sizeof(buf), TEXT("\n"));
+
+ OutputDebugString(buf);
+ }
+
+#if 0
+ const IID MsTscAxIIDs[] =
+ {
+ IID_IMsRdpClient,
+ IID_IMsTscAx,
+ //IID_IMsTscAxEvents,
+ IID_IMsTscNonScriptable,
+ IID_IMsRdpClientNonScriptable,
+ };
+
+ const IID MsRdpClient[] =
+ {
+ IID_IMsRdpClient,
+ IID_IMsTscAx,
+ //IID_IMsTscAxEvents,
+ IID_IMsTscNonScriptable,
+ IID_IMsRdpClientNonScriptable,
+ };
+
+ const IID MsRdpClient2[] =
+ {
+ IID_IMsRdpClient2,
+ IID_IMsRdpClient,
+ IID_IMsTscAx,
+ //IID_IMsTscAxEvents,
+ IID_IMsTscNonScriptable,
+ IID_IMsRdpClientNonScriptable,
+ };
+
+ const IID MsRdpClient3[] =
+ {
+ IID_IMsRdpClient3,
+ IID_IMsRdpClient2,
+ IID_IMsRdpClient,
+ IID_IMsTscAx,
+ //IID_IMsTscAxEvents,
+ IID_IMsTscNonScriptable,
+ IID_IMsRdpClientNonScriptable,
+ };
+
+ const IID MsRdpClient4[] =
+ {
+ IID_IMsRdpClient4,
+ IID_IMsRdpClient3,
+ IID_IMsRdpClient2,
+ IID_IMsRdpClient,
+ IID_IMsTscAx,
+ //IID_IMsTscAxEvents,
+ IID_IMsTscNonScriptable,
+ IID_IMsRdpClientNonScriptable,
+ IID_IMsRdpClientNonScriptable2,
+ };
+#endif
+
+ std::wstring UUIDToString(const UUID& uuid)
+ {
+ std::wstring s;
+ LPOLESTR str;
+ StringFromCLSID(uuid, &str);
+ s += str;
+ CoTaskMemFree(str);
+ return s;
+ }
+
+ std::wstring MonikerToString(IMoniker * pmk)
+ {
+ LPOLESTR pszName = NULL;
+
+ if(SUCCEEDED(pmk->GetDisplayName(NULL, NULL, &pszName)))
+ {
+ std::wstring s(pszName);
+ CoTaskMemFree(pszName);
+ return s;
+ }
+ else
+ return std::wstring(L"");
+ }
+
+ std::basic_string RectToString(const RECT& rc)
+ {
+ if(&rc == NULL)
+ return TEXT("");
+
+ std::basic_ostringstream o;
+ o << "{" << " left:" << rc.left << " top:" << rc.top << " right:" << rc.right << " bottom:" << rc.bottom << " }";
+ return o.str();
+ }
+
+ std::basic_string RectToString(const RECTL& rc)
+ {
+ if(&rc == NULL)
+ return TEXT("");
+
+ std::basic_ostringstream o;
+ o << "{" << " left:" << rc.left << " top:" << rc.top << " right:" << rc.right << " bottom:" << rc.bottom << " }";
+ return o.str();
+ }
+
+ std::basic_string SizeToString(const SIZE& sz)
+ {
+ if(&sz == NULL)
+ return TEXT("");
+
+ std::basic_ostringstream o;
+ o << "{ " << " cx:" << sz.cx << " cy:" << sz.cy << " }";
+ return o.str();
+ }
+
+ template LPCTSTR BooleanToString(const T& X)
+ {
+ 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;
+
+ case VT_EMPTY:
+ case VT_NULL:
+ case VT_VOID:
+ 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 = NULL; \
+ }
+
+ 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,
+ public IDispatch,
+ 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 ISpecifyPropertyPages,
+ public IViewObject,
+ public IViewObject2,
+
+ /* RDP client interfaces */
+ public IMsRdpClient4,
+ public IMsRdpClientNonScriptable2
+ {
+ private:
+ LONG m_refCount;
+
+ IUnknown * m_IUnknown;
+
+ IDispatch * m_IDispatch;
+ IConnectionPointContainer * m_IConnectionPointContainer;
+ IDataObject * m_IDataObject;
+ IObjectSafety * m_IObjectSafety;
+ IOleControl * m_IOleControl;
+ IOleInPlaceActiveObject * m_IOleInPlaceActiveObject;
+ IOleInPlaceObject * m_IOleInPlaceObject;
+ IOleObject * m_IOleObject;
+ IOleWindow * m_IOleWindow;
+ IPersist * m_IPersist;
+ IPersistPropertyBag * m_IPersistPropertyBag;
+ IPersistStorage * m_IPersistStorage;
+ IPersistStreamInit * m_IPersistStreamInit;
+ IProvideClassInfo * m_IProvideClassInfo;
+ IProvideClassInfo2 * m_IProvideClassInfo2;
+ IQuickActivate * m_IQuickActivate;
+ ISpecifyPropertyPages * m_ISpecifyPropertyPages;
+ IViewObject * m_IViewObject;
+ IViewObject2 * m_IViewObject2;
+
+ IMsRdpClient * m_IMsRdpClient;
+ IMsRdpClient2 * m_IMsRdpClient2;
+ IMsRdpClient3 * m_IMsRdpClient3;
+ IMsRdpClient4 * m_IMsRdpClient4;
+ IMsTscAx * m_IMsTscAx;
+ IMsTscNonScriptable * m_IMsTscNonScriptable;
+ IMsRdpClientNonScriptable * m_IMsRdpClientNonScriptable;
+ IMsRdpClientNonScriptable2 * m_IMsRdpClientNonScriptable2;
+
+ IDispatch * getIDispatch()
+ {
+ if(m_IDispatch)
+ return m_IDispatch;
+
+ if(m_IMsRdpClient)
+ m_IDispatch = m_IMsRdpClient;
+ else if(m_IMsRdpClient2)
+ m_IDispatch = m_IMsRdpClient2;
+ else if(m_IMsRdpClient3)
+ m_IDispatch = m_IMsRdpClient3;
+ else if(m_IMsRdpClient4)
+ m_IDispatch = m_IMsRdpClient4;
+ else if(m_IMsTscAx)
+ m_IDispatch = m_IMsTscAx;
+
+ if(m_IDispatch)
+ {
+ m_IDispatch->AddRef();
+ return m_IDispatch;
+ }
+
+ if(SUCCEEDED(m_IUnknown->QueryInterface(&m_IDispatch)))
+ return m_IDispatch;
+
+ return NULL;
+ }
+
+ IConnectionPointContainer * getIConnectionPointContainer()
+ {
+ if(m_IConnectionPointContainer)
+ return m_IConnectionPointContainer;
+
+ m_IUnknown->QueryInterface(&m_IConnectionPointContainer);
+ return m_IConnectionPointContainer;
+
+ }
+
+ IDataObject * getIDataObject()
+ {
+ if(m_IDataObject)
+ return m_IDataObject;
+
+ m_IUnknown->QueryInterface(&m_IDataObject);
+ return m_IDataObject;
+ }
+
+ IObjectSafety * getIObjectSafety()
+ {
+ if(m_IObjectSafety)
+ return m_IObjectSafety;
+
+ m_IUnknown->QueryInterface(&m_IObjectSafety);
+ return m_IObjectSafety;
+ }
+
+ IOleControl * getIOleControl()
+ {
+ if(m_IOleControl)
+ return m_IOleControl;
+
+ m_IUnknown->QueryInterface(&m_IOleControl);
+ return m_IOleControl;
+ }
+
+ IOleInPlaceActiveObject * getIOleInPlaceActiveObject()
+ {
+ if(m_IOleInPlaceActiveObject)
+ return m_IOleInPlaceActiveObject;
+
+ m_IUnknown->QueryInterface(&m_IOleInPlaceActiveObject);
+ return m_IOleInPlaceActiveObject;
+ }
+
+ IOleInPlaceObject * getIOleInPlaceObject()
+ {
+ if(m_IOleInPlaceObject)
+ return m_IOleInPlaceObject;
+
+ m_IUnknown->QueryInterface(&m_IOleInPlaceObject);
+ return m_IOleInPlaceObject;
+ }
+
+ IOleObject * getIOleObject()
+ {
+ if(m_IOleObject)
+ return m_IOleObject;
+
+ m_IUnknown->QueryInterface(&m_IOleObject);
+ return m_IOleObject;
+ }
+
+ IOleWindow * getIOleWindow()
+ {
+ if(m_IOleWindow)
+ return m_IOleWindow;
+
+ if(m_IOleInPlaceActiveObject)
+ m_IOleWindow = m_IOleInPlaceActiveObject;
+
+ if(m_IOleWindow)
+ {
+ m_IOleWindow->AddRef();
+ return m_IOleWindow;
+ }
+
+ m_IUnknown->QueryInterface(&m_IOleWindow);
+ return m_IOleWindow;
+ }
+
+ IPersist * getIPersist()
+ {
+ if(m_IPersist)
+ return m_IPersist;
+
+ if(m_IPersistPropertyBag)
+ m_IPersist = m_IPersistPropertyBag;
+ else if(m_IPersistStorage)
+ m_IPersist = m_IPersistStorage;
+ else if(m_IPersistStreamInit)
+ m_IPersist = m_IPersistStreamInit;
+
+ if(m_IPersist)
+ {
+ m_IPersist->AddRef();
+ return m_IPersist;
+ }
+
+ m_IUnknown->QueryInterface(&m_IPersist);
+ return m_IPersist;
+ }
+
+ IPersistPropertyBag * getIPersistPropertyBag()
+ {
+ if(m_IPersistPropertyBag)
+ return m_IPersistPropertyBag;
+
+ m_IUnknown->QueryInterface(&m_IPersistPropertyBag);
+ return m_IPersistPropertyBag;
+ }
+
+ IPersistStorage * getIPersistStorage()
+ {
+ if(m_IPersistStorage)
+ return m_IPersistStorage;
+
+ m_IUnknown->QueryInterface(&m_IPersistStorage);
+ return m_IPersistStorage;
+ }
+
+ IPersistStreamInit * getIPersistStreamInit()
+ {
+ if(m_IPersistStreamInit)
+ return m_IPersistStreamInit;
+
+ m_IUnknown->QueryInterface(&m_IPersistStreamInit);
+ return m_IPersistStreamInit;
+ }
+
+ IProvideClassInfo * getIProvideClassInfo()
+ {
+ if(m_IProvideClassInfo)
+ return m_IProvideClassInfo;
+
+ if(m_IProvideClassInfo2)
+ m_IProvideClassInfo = m_IProvideClassInfo2;
+
+ if(m_IProvideClassInfo)
+ {
+ m_IProvideClassInfo->AddRef();
+ return m_IProvideClassInfo;
+ }
+
+ m_IUnknown->QueryInterface(&m_IProvideClassInfo);
+ return m_IProvideClassInfo;
+ }
+
+ IProvideClassInfo2 * getIProvideClassInfo2()
+ {
+ if(m_IProvideClassInfo2)
+ return m_IProvideClassInfo2;
+
+ m_IUnknown->QueryInterface(&m_IProvideClassInfo2);
+ return m_IProvideClassInfo2;
+ }
+
+ IQuickActivate * getIQuickActivate()
+ {
+ if(m_IQuickActivate)
+ return m_IQuickActivate;
+
+ m_IUnknown->QueryInterface(&m_IQuickActivate);
+ return m_IQuickActivate;
+ }
+
+ ISpecifyPropertyPages * getISpecifyPropertyPages()
+ {
+ if(m_ISpecifyPropertyPages)
+ return m_ISpecifyPropertyPages;
+
+ m_IUnknown->QueryInterface(&m_ISpecifyPropertyPages);
+ return m_ISpecifyPropertyPages;
+ }
+
+ IViewObject * getIViewObject()
+ {
+ if(m_IViewObject)
+ return m_IViewObject;
+
+ if(m_IViewObject2)
+ m_IViewObject = m_IViewObject2;
+
+ if(m_IViewObject)
+ {
+ m_IViewObject->AddRef();
+ return m_IViewObject;
+ }
+
+ m_IUnknown->QueryInterface(&m_IViewObject);
+ return m_IViewObject;
+ }
+
+ IViewObject2 * getIViewObject2()
+ {
+ if(m_IViewObject2)
+ return m_IViewObject2;
+
+ m_IUnknown->QueryInterface(&m_IViewObject2);
+ return m_IViewObject2;
+ }
+
+ IMsRdpClient * getIMsRdpClient()
+ {
+ if(m_IMsRdpClient)
+ return m_IMsRdpClient;
+
+ if(m_IMsRdpClient2)
+ m_IMsRdpClient = m_IMsRdpClient2;
+ else if(m_IMsRdpClient3)
+ m_IMsRdpClient = m_IMsRdpClient3;
+ else if(m_IMsRdpClient4)
+ m_IMsRdpClient = m_IMsRdpClient4;
+
+ if(m_IMsRdpClient)
+ {
+ m_IMsRdpClient->AddRef();
+ return m_IMsRdpClient;
+ }
+
+ m_IUnknown->QueryInterface(&m_IMsRdpClient);
+ return m_IMsRdpClient;
+ }
+
+ IMsRdpClient2 * getIMsRdpClient2()
+ {
+ if(m_IMsRdpClient2)
+ return m_IMsRdpClient2;
+
+ if(m_IMsRdpClient3)
+ m_IMsRdpClient2 = m_IMsRdpClient3;
+ else if(m_IMsRdpClient4)
+ m_IMsRdpClient2 = m_IMsRdpClient4;
+
+ if(m_IMsRdpClient2)
+ {
+ m_IMsRdpClient2->AddRef();
+ return m_IMsRdpClient2;
+ }
+
+ m_IUnknown->QueryInterface(&m_IMsRdpClient2);
+ return m_IMsRdpClient2;
+ }
+
+ IMsRdpClient3 * getIMsRdpClient3()
+ {
+ if(m_IMsRdpClient3)
+ return m_IMsRdpClient3;
+
+ if(m_IMsRdpClient4)
+ m_IMsRdpClient3 = m_IMsRdpClient4;
+
+ if(m_IMsRdpClient3)
+ {
+ m_IMsRdpClient3->AddRef();
+ return m_IMsRdpClient3;
+ }
+
+ m_IUnknown->QueryInterface(&m_IMsRdpClient3);
+ return m_IMsRdpClient3;
+ }
+
+ IMsRdpClient4 * getIMsRdpClient4()
+ {
+ if(m_IMsRdpClient4)
+ return m_IMsRdpClient4;
+
+ m_IUnknown->QueryInterface(&m_IMsRdpClient4);
+ return m_IMsRdpClient4;
+ }
+
+ IMsTscAx * getIMsTscAx()
+ {
+ if(m_IMsTscAx)
+ return m_IMsTscAx;
+
+ if(m_IMsRdpClient)
+ m_IMsTscAx = m_IMsRdpClient;
+ else if(m_IMsRdpClient2)
+ m_IMsTscAx = m_IMsRdpClient2;
+ else if(m_IMsRdpClient3)
+ m_IMsTscAx = m_IMsRdpClient3;
+ else if(m_IMsRdpClient4)
+ m_IMsTscAx = m_IMsRdpClient4;
+
+ if(m_IMsTscAx)
+ {
+ m_IMsTscAx->AddRef();
+ return m_IMsTscAx;
+ }
+
+ m_IUnknown->QueryInterface(&m_IMsTscAx);
+ return m_IMsTscAx;
+ }
+
+ IMsTscNonScriptable * getIMsTscNonScriptable()
+ {
+ if(m_IMsTscNonScriptable)
+ return m_IMsTscNonScriptable;
+
+ if(m_IMsRdpClientNonScriptable)
+ m_IMsTscNonScriptable = m_IMsRdpClientNonScriptable;
+ else if(m_IMsRdpClientNonScriptable2)
+ m_IMsTscNonScriptable = m_IMsRdpClientNonScriptable2;
+
+ if(m_IMsTscNonScriptable)
+ {
+ m_IMsTscNonScriptable->AddRef();
+ return m_IMsTscNonScriptable;
+ }
+
+ m_IUnknown->QueryInterface(&m_IMsTscNonScriptable);
+ return m_IMsTscNonScriptable;
+ }
+
+ IMsRdpClientNonScriptable * getIMsRdpClientNonScriptable()
+ {
+ if(m_IMsRdpClientNonScriptable)
+ return m_IMsRdpClientNonScriptable;
+
+ if(m_IMsRdpClientNonScriptable2)
+ m_IMsRdpClientNonScriptable = m_IMsRdpClientNonScriptable2;
+
+ if(m_IMsRdpClientNonScriptable)
+ {
+ m_IMsRdpClientNonScriptable->AddRef();
+ return m_IMsRdpClientNonScriptable;
+ }
+
+ m_IUnknown->QueryInterface(&m_IMsRdpClientNonScriptable);
+ return m_IMsRdpClientNonScriptable;
+ }
+
+ IMsRdpClientNonScriptable2 * getIMsRdpClientNonScriptable2()
+ {
+ if(m_IMsRdpClientNonScriptable2)
+ return m_IMsRdpClientNonScriptable2;
+
+ m_IUnknown->QueryInterface(&m_IMsRdpClientNonScriptable2);
+ return m_IMsRdpClientNonScriptable2;
+ }
+
+ 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),
+ m_IDataObject(NULL),
+ m_IObjectSafety(NULL),
+ m_IOleControl(NULL),
+ m_IOleInPlaceActiveObject(NULL),
+ m_IOleInPlaceObject(NULL),
+ m_IOleObject(NULL),
+ m_IOleWindow(NULL),
+ m_IPersist(NULL),
+ m_IPersistPropertyBag(NULL),
+ m_IPersistStorage(NULL),
+ m_IPersistStreamInit(NULL),
+ m_IProvideClassInfo(NULL),
+ m_IProvideClassInfo2(NULL),
+ m_IQuickActivate(NULL),
+ m_ISpecifyPropertyPages(NULL),
+ m_IViewObject(NULL),
+ m_IViewObject2(NULL),
+ m_IMsRdpClient(NULL),
+ m_IMsRdpClient2(NULL),
+ m_IMsRdpClient3(NULL),
+ m_IMsRdpClient4(NULL),
+ m_IMsTscAx(NULL),
+ m_IMsTscNonScriptable(NULL),
+ m_IMsRdpClientNonScriptable(NULL),
+ m_IMsRdpClientNonScriptable2(NULL)
+ {
+ 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)
+ m_IUnknown->Release();
+
+ if(m_IDispatch)
+ m_IDispatch->Release();
+
+ if(m_IConnectionPointContainer)
+ m_IConnectionPointContainer->Release();
+
+ if(m_IDataObject)
+ m_IDataObject->Release();
+
+ if(m_IObjectSafety)
+ m_IObjectSafety->Release();
+
+ if(m_IOleControl)
+ m_IOleControl->Release();
+
+ if(m_IOleInPlaceActiveObject)
+ m_IOleInPlaceActiveObject->Release();
+
+ if(m_IOleInPlaceObject)
+ m_IOleInPlaceObject->Release();
+
+ if(m_IOleObject)
+ m_IOleObject->Release();
+
+ if(m_IOleWindow)
+ m_IOleWindow->Release();
+
+ if(m_IPersist)
+ m_IPersist->Release();
+
+ if(m_IPersistPropertyBag)
+ m_IPersistPropertyBag->Release();
+
+ if(m_IPersistStorage)
+ m_IPersistStorage->Release();
+
+ if(m_IPersistStreamInit)
+ m_IPersistStreamInit->Release();
+
+ if(m_IProvideClassInfo)
+ m_IProvideClassInfo->Release();
+
+ if(m_IProvideClassInfo2)
+ m_IProvideClassInfo2->Release();
+
+ if(m_IQuickActivate)
+ m_IQuickActivate->Release();
+
+ if(m_ISpecifyPropertyPages)
+ m_ISpecifyPropertyPages->Release();
+
+ if(m_IViewObject)
+ m_IViewObject->Release();
+
+ if(m_IViewObject2)
+ m_IViewObject2->Release();
+
+ if(m_IMsRdpClient)
+ m_IMsRdpClient->Release();
+
+ if(m_IMsRdpClient2)
+ m_IMsRdpClient2->Release();
+
+ if(m_IMsRdpClient3)
+ m_IMsRdpClient3->Release();
+
+ if(m_IMsRdpClient4)
+ m_IMsRdpClient4->Release();
+
+ if(m_IMsTscAx)
+ m_IMsTscAx->Release();
+
+ if(m_IMsTscNonScriptable)
+ m_IMsTscNonScriptable->Release();
+
+ if(m_IMsRdpClientNonScriptable)
+ m_IMsRdpClientNonScriptable->Release();
+
+ if(m_IMsRdpClientNonScriptable2)
+ m_IMsRdpClientNonScriptable2->Release();
+ }
+
+ /* IUnknown */
+ public:
+ virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void ** ppvObject)
+ {
+ return m_outer->QueryInterface(riid, ppvObject);
+ }
+
+ virtual ULONG STDMETHODCALLTYPE AddRef(void)
+ {
+ return m_outer->AddRef();
+ }
+
+ virtual ULONG STDMETHODCALLTYPE Release(void)
+ {
+ return m_outer->Release();
+ }
+
+ /* IDispatch */
+ private:
+ static void FreeExcepInfo(const EXCEPINFO& excepInfo)
+ {
+ if(excepInfo.bstrSource)
+ SysFreeString(excepInfo.bstrSource);
+
+ if(excepInfo.bstrDescription)
+ SysFreeString(excepInfo.bstrDescription);
+
+ if(excepInfo.bstrHelpFile)
+ SysFreeString(excepInfo.bstrHelpFile);
+ }
+
+ static std::basic_string ExcepInfoToString(const EXCEPINFO& excepInfo)
+ {
+ std::basic_ostringstream o;
+
+ o << "{";
+ o << " code: " << excepInfo.wCode << " from: " << std::basic_string(excepInfo.bstrSource, excepInfo.bstrSource + SysStringLen(excepInfo.bstrSource));
+
+ BSTR bstrDescription = NULL;
+
+ if(excepInfo.bstrDescription)
+ bstrDescription = excepInfo.bstrDescription;
+ else if(excepInfo.pfnDeferredFillIn)
+ {
+ EXCEPINFO excepInfoCopy = excepInfo;
+
+ if(SUCCEEDED(excepInfoCopy.pfnDeferredFillIn(&excepInfoCopy)) && excepInfoCopy.bstrDescription)
+ {
+ bstrDescription = excepInfoCopy.bstrDescription;
+ excepInfoCopy.bstrDescription = NULL;
+ }
+
+ if(excepInfoCopy.bstrSource == excepInfo.bstrSource)
+ excepInfoCopy.bstrSource = NULL;
+
+ if(excepInfoCopy.bstrHelpFile == excepInfo.bstrDescription)
+ excepInfoCopy.bstrDescription = NULL;
+
+ FreeExcepInfo(excepInfoCopy);
+ }
+
+ if(bstrDescription)
+ {
+ o << " msg: " << std::basic_string(bstrDescription, bstrDescription + SysStringLen(bstrDescription));
+
+ if(excepInfo.bstrDescription == NULL)
+ SysFreeString(bstrDescription);
+ }
+
+ o << " }";
+
+ return o.str().c_str();
+ }
+
+ public:
+ virtual HRESULT STDMETHODCALLTYPE GetTypeInfoCount(UINT * pctinfo)
+ {
+ IDispatch * pIDispatch = getIDispatch();
+ dbgprintf(TEXT("IDispatch::GetTypeInfoCount(%p)"), pctinfo);
+ HRESULT hr = pIDispatch->GetTypeInfoCount(pctinfo);
+ dbgprintf(TEXT("IDispatch::GetTypeInfoCount -> %08X, ctinfo = %lu"), hr, *pctinfo);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo ** ppTInfo)
+ {
+ IDispatch * pIDispatch = getIDispatch();
+ dbgprintf(TEXT("IDispatch::GetTypeInfo(%lu, %08X, %p)"), iTInfo, lcid, ppTInfo);
+ HRESULT hr = pIDispatch->GetTypeInfo(iTInfo, lcid, ppTInfo);
+ dbgprintf(TEXT("IDispatch::GetTypeInfo -> %08X, pTInfo = %p"), hr, *ppTInfo);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE GetIDsOfNames(REFIID riid, LPOLESTR * rgszNames, UINT cNames, LCID lcid, DISPID * rgDispId)
+ {
+ IDispatch * pIDispatch = getIDispatch();
+ std::wstring strtemp;
+
+ std::wostringstream strtempo;
+
+ strtemp.resize(0);
+ strtemp += L"[ ";
+
+ for(UINT i = 0; i < cNames; ++ i)
+ {
+ if(i)
+ strtemp += L", ";
+
+ strtemp += rgszNames[i];
+ }
+
+ strtemp += L" ]";
+
+ dbgprintf(TEXT("IDispatch::GetIDsOfNames(%ls, %ls, %lu, %08X, %p)"), UUIDToString(riid).c_str(), strtemp.c_str(), cNames, lcid, rgDispId);
+ HRESULT hr = pIDispatch->GetIDsOfNames(riid, rgszNames, cNames, lcid, rgDispId);
+
+ strtemp.resize(0);
+ strtempo.str(strtemp);
+
+ strtempo << L"[ ";
+
+ for(UINT i = 0; i < cNames; ++ i)
+ {
+ if(i)
+ strtempo << L", ";
+
+ strtempo << rgDispId[i];
+ }
+
+ strtempo << L" ]";
+
+ dbgprintf(TEXT("IDispatch::GetIDsOfNames -> %08X, rgDispId = %ls"), hr, strtempo.str().c_str());
+
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pDispParams, VARIANT * pVarResult, EXCEPINFO * pExcepInfo, UINT * puArgErr)
+ {
+ IDispatch * pIDispatch = getIDispatch();
+
+ std::basic_ostringstream strtempo;
+
+ strtempo << L"{";
+
+ for(unsigned int i = pDispParams->cArgs, j = pDispParams->cNamedArgs; j < pDispParams->cArgs; -- i, ++ j)
+ {
+ strtempo << L" ";
+ strtempo << VariantToString(pDispParams->rgvarg[i - 1]);
+ strtempo << L",";
+ }
+
+ for(unsigned int i = pDispParams->cArgs - pDispParams->cNamedArgs; i > 0; -- i)
+ {
+ strtempo << L" ";
+ strtempo << L"["; strtempo << pDispParams->rgdispidNamedArgs[i - 1]; strtempo << L"] => ";
+ strtempo << VariantToString(pDispParams->rgvarg[i - 1]);
+ strtempo << L",";
+ }
+
+ strtempo << L" }";
+
+ dbgprintf(TEXT("IDispatch::Invoke(%ld, %ls, %08X, %04X, %s, %p, %p, %p)"), dispIdMember, UUIDToString(riid).c_str(), lcid, wFlags, strtempo.str().c_str(), pVarResult, pExcepInfo, puArgErr);
+
+ VARIANT VarResult = { };
+ EXCEPINFO ExcepInfo = { };
+
+ if(pVarResult == NULL)
+ pVarResult = &VarResult;
+
+ if(pExcepInfo == NULL)
+ pExcepInfo = &ExcepInfo;
+
+ HRESULT hr = pIDispatch->Invoke(dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
+
+ dbgprintf(TEXT("IDispatch::Invoke -> %08X, returns %s, throws %s"), hr, VariantToString(*pVarResult).c_str(), ExcepInfoToString(*pExcepInfo).c_str());
+
+ FreeExcepInfo(ExcepInfo);
+
+ return hr;
+ }
+
+ /* IConnectionPointContainer */
+ public:
+ virtual HRESULT STDMETHODCALLTYPE EnumConnectionPoints(IEnumConnectionPoints ** ppEnum)
+ {
+ IConnectionPointContainer * pIConnectionPointContainer = getIConnectionPointContainer();
+ dbgprintf(TEXT("IConnectionPointContainer::EnumConnectionPoints(%p)"), ppEnum);
+ HRESULT hr = pIConnectionPointContainer->EnumConnectionPoints(ppEnum);
+ dbgprintf(TEXT("IConnectionPointContainer::EnumConnectionPoints -> %08X, pEnum = %p"), hr, *ppEnum);
+
+ if(SUCCEEDED(hr))
+ *ppEnum = HookIEnumConnectionPoints(*ppEnum);
+
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE FindConnectionPoint(REFIID riid, IConnectionPoint ** ppCP)
+ {
+ IConnectionPointContainer * pIConnectionPointContainer = getIConnectionPointContainer();
+ dbgprintf(TEXT("IConnectionPointContainer::FindConnectionPoint(%ls, %p)"), UUIDToString(riid).c_str(), ppCP);
+ HRESULT hr = pIConnectionPointContainer->FindConnectionPoint(riid, ppCP);
+ dbgprintf(TEXT("IConnectionPointContainer::FindConnectionPoint -> %08X, pCP = %p"), hr, *ppCP);
+
+ if(SUCCEEDED(hr))
+ *ppCP = HookIConnectionPoint(*ppCP);
+
+ return hr;
+ }
+
+ /* IDataObject */
+ private:
+ static std::basic_string TargetDeviceToString(const DVTARGETDEVICE& targetdev)
+ {
+ if(&targetdev == NULL)
+ return TEXT("");
+
+ std::basic_ostringstream o;
+
+ o << "{";
+ o << LPCWSTR(targetdev.tdData[targetdev.tdDriverNameOffset]);
+
+ if(targetdev.tdDeviceNameOffset)
+ {
+ o << ",";
+ o << LPCWSTR(targetdev.tdData[targetdev.tdDeviceNameOffset]);
+ }
+
+ if(targetdev.tdPortNameOffset)
+ {
+ o << ",";
+ o << LPCWSTR(targetdev.tdData[targetdev.tdPortNameOffset]);
+ }
+
+ o << " }";
+
+ return o.str();
+ }
+
+ static LPCTSTR AspectToString(DWORD aspect)
+ {
+ switch(aspect)
+ {
+ case DVASPECT_CONTENT: return TEXT("content");
+ case DVASPECT_THUMBNAIL: return TEXT("thumbnail");
+ case DVASPECT_ICON: return TEXT("icon");
+ case DVASPECT_DOCPRINT: return TEXT("printable");
+ default: return TEXT("");
+ }
+ }
+
+ static LPCTSTR TymedToString(DWORD tymed)
+ {
+ switch(tymed)
+ {
+ case TYMED_HGLOBAL: return TEXT("memory");
+ case TYMED_FILE: return TEXT("file");
+ case TYMED_ISTREAM: return TEXT("IStream");
+ case TYMED_ISTORAGE: return TEXT("IStorage");
+ case TYMED_GDI: return TEXT("bitmap");
+ case TYMED_MFPICT: return TEXT("metafile");
+ case TYMED_ENHMF: return TEXT("enhanced metafile");
+ case TYMED_NULL: return TEXT("");
+ default: return TEXT("");
+ }
+ }
+
+ static std::basic_string FormatEtcToString(const FORMATETC& formatetc)
+ {
+ std::basic_ostringstream o;
+
+ o << "{";
+
+ // cfFormat
+ o << " format: ";
+
+ switch(formatetc.cfFormat)
+ {
+ case CF_TEXT: o << "ANSI text"; break;
+ case CF_BITMAP: o << "bitmap"; break;
+ case CF_METAFILEPICT: o << "metafile"; break;
+ case CF_SYLK: o << "symlink"; break;
+ case CF_DIF: o << "DIF"; break;
+ case CF_TIFF: o << "TIFF"; break;
+ case CF_OEMTEXT: o << "OEM text"; break;
+ case CF_DIB: o << "DIBv4"; break;
+ case CF_PALETTE: o << "palette"; break;
+ case CF_PENDATA: o << "pen data"; break;
+ case CF_RIFF: o << "RIFF"; break;
+ case CF_WAVE: o << "WAV"; break;
+ case CF_UNICODETEXT: o << "Unicode text"; break;
+ case CF_ENHMETAFILE: o << "enhanced metafile"; break;
+ case CF_HDROP: o << "list of files"; break;
+ case CF_LOCALE: o << "LCID"; break;
+ case CF_DIBV5: o << "DIBv5"; break;
+ case CF_OWNERDISPLAY: o << ""; break;
+ case CF_DSPTEXT: o << ""; break;
+ case CF_DSPBITMAP: o << ""; break;
+ case CF_DSPMETAFILEPICT: o << ""; break;
+ case CF_DSPENHMETAFILE: o << ""; break;
+
+ default:
+ o << "<";
+
+ if(formatetc.cfFormat >= CF_PRIVATEFIRST && formatetc.cfFormat <= CF_PRIVATELAST)
+ o << "private";
+ else if(formatetc.cfFormat >= CF_GDIOBJFIRST && formatetc.cfFormat <= CF_GDIOBJLAST)
+ o << "GDI object";
+ else
+ o << "unknown";
+
+ o << " " << std::hex << formatetc.cfFormat << std::dec << ">";
+ }
+
+ // ptd
+ if(formatetc.ptd)
+ o << " device: " << TargetDeviceToString(*formatetc.ptd);
+
+ // dwAspect
+ o << " aspect: " << AspectToString(formatetc.dwAspect);
+
+ // lindex
+ if(formatetc.dwAspect == DVASPECT_CONTENT || formatetc.dwAspect == DVASPECT_DOCPRINT)
+ o << " page split: " << formatetc.lindex;
+
+ // tymed
+ o << " medium: " << TymedToString(formatetc.tymed);
+
+ return o.str();
+ }
+
+ static std::basic_string MediumToString(const STGMEDIUM& medium)
+ {
+ std::basic_ostringstream o;
+
+ o << "{ ";
+ o << TymedToString(medium.tymed);
+ o << " }";
+
+ return o.str();
+ }
+
+ public:
+ virtual HRESULT STDMETHODCALLTYPE GetData(FORMATETC * pformatetcIn, STGMEDIUM * pmedium)
+ {
+ IDataObject * pIDataObject = getIDataObject();
+ dbgprintf(TEXT("IDataObject::GetData(%s, %p)"), FormatEtcToString(*pformatetcIn).c_str(), pmedium);
+ HRESULT hr = pIDataObject->GetData(pformatetcIn, pmedium);
+ dbgprintf(TEXT("IDataObject::GetData -> %08X, %s"), hr, MediumToString(*pmedium).c_str());
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE GetDataHere(FORMATETC * pformatetc, STGMEDIUM * pmedium)
+ {
+ IDataObject * pIDataObject = getIDataObject();
+ dbgprintf(TEXT("IDataObject::GetDataHere(%s, %p)"), FormatEtcToString(*pformatetc).c_str(), pmedium);
+ HRESULT hr = pIDataObject->GetDataHere(pformatetc, pmedium);
+ dbgprintf(TEXT("IDataObject::GetDataHere -> %08X, medium = %s"), hr, MediumToString(*pmedium).c_str());
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE QueryGetData(FORMATETC * pformatetc)
+ {
+ IDataObject * pIDataObject = getIDataObject();
+ dbgprintf(TEXT("IDataObject::QueryGetData(%s)"), FormatEtcToString(*pformatetc).c_str());
+ HRESULT hr = pIDataObject->QueryGetData(pformatetc);
+ dbgprintf(TEXT("IDataObject::QueryGetData -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE GetCanonicalFormatEtc(FORMATETC * pformatectIn, FORMATETC * pformatetcOut)
+ {
+ IDataObject * pIDataObject = getIDataObject();
+ dbgprintf(TEXT("IDataObject::GetCanonicalFormatEtc(%s, %p)"), FormatEtcToString(*pformatectIn).c_str(), pformatetcOut);
+ HRESULT hr = pIDataObject->GetCanonicalFormatEtc(pformatectIn, pformatetcOut);
+ dbgprintf(TEXT("IDataObject::GetCanonicalFormatEtc -> %08X, formatetcOut = %s"), hr, FormatEtcToString(*pformatetcOut).c_str());
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE SetData(FORMATETC * pformatetc, STGMEDIUM * pmedium, BOOL fRelease)
+ {
+ IDataObject * pIDataObject = getIDataObject();
+ dbgprintf(TEXT("IDataObject::SetData(%s, %p, %s)"), FormatEtcToString(*pformatetc).c_str(), MediumToString(*pmedium).c_str(), fRelease ? TEXT("true") : TEXT("false"));
+ HRESULT hr = pIDataObject->SetData(pformatetc, pmedium, fRelease);
+ dbgprintf(TEXT("IDataObject::SetData -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC ** ppenumFormatEtc)
+ {
+ IDataObject * pIDataObject = getIDataObject();
+ 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;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE DAdvise(FORMATETC * pformatetc, DWORD advf, IAdviseSink * pAdvSink, DWORD * pdwConnection)
+ {
+ IDataObject * pIDataObject = getIDataObject();
+ 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;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE DUnadvise(DWORD dwConnection)
+ {
+ IDataObject * pIDataObject = getIDataObject();
+ dbgprintf(TEXT("IDataObject::DUnadvise(%lu)"), dwConnection);
+ HRESULT hr = pIDataObject->DUnadvise(dwConnection);
+ dbgprintf(TEXT("IDataObject::DUnadvise -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE EnumDAdvise(IEnumSTATDATA ** ppenumAdvise)
+ {
+ IDataObject * pIDataObject = getIDataObject();
+ dbgprintf(TEXT("IDataObject::EnumDAdvise(%p)"), ppenumAdvise);
+ HRESULT hr = pIDataObject->EnumDAdvise(ppenumAdvise);
+ dbgprintf(TEXT("IDataObject::EnumDAdvise -> %08X, penumAdvise = %p"), hr, *ppenumAdvise);
+ // TODO: hook
+ return hr;
+ }
+
+ /* IObjectSafety */
+ public:
+ virtual HRESULT STDMETHODCALLTYPE IObjectSafety::GetInterfaceSafetyOptions(REFIID riid, DWORD * pdwSupportedOptions, DWORD * pdwEnabledOptions)
+ {
+ IObjectSafety * pIObjectSafety = getIObjectSafety();
+ dbgprintf(TEXT("IObjectSafety::GetInterfaceSafetyOptions(%ls, %p, %p)"), UUIDToString(riid).c_str(), pdwSupportedOptions, pdwEnabledOptions);
+ HRESULT hr = pIObjectSafety->GetInterfaceSafetyOptions(riid, pdwSupportedOptions, pdwEnabledOptions);
+ 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)
+ {
+ IObjectSafety * pIObjectSafety = getIObjectSafety();
+ dbgprintf(TEXT("IObjectSafety::SetInterfaceSafetyOptions(%ls, %08X, %08X)"), UUIDToString(riid).c_str(), dwOptionSetMask, dwEnabledOptions);
+ HRESULT hr = pIObjectSafety->SetInterfaceSafetyOptions(riid, dwOptionSetMask, dwEnabledOptions);
+ dbgprintf(TEXT("IObjectSafety::SetInterfaceSafetyOptions -> %08X"), hr);
+ return hr;
+ }
+
+ /* IOleControl */
+ private:
+ std::basic_string ControlInfoToString(const CONTROLINFO& ci)
+ {
+ std::basic_ostringstream o;
+
+ int firstdone = 0;
+
+ o << "{ ";
+
+ if(ci.cAccel && ci.hAccel)
+ {
+ LPACCEL pAccel = static_cast(GlobalLock(ci.hAccel));
+
+ if(pAccel)
+ {
+ for(USHORT i = 0; i < ci.cAccel; ++ i)
+ {
+ if(i)
+ o << ", ";
+
+ if(pAccel[i].fVirt & FSHIFT)
+ o << "SHIFT + ";
+
+ if(pAccel[i].fVirt & FCONTROL)
+ o << "CONTROL + ";
+
+ if(pAccel[i].fVirt & FALT)
+ o << "ALT + ";
+
+ if(pAccel[i].fVirt & FVIRTKEY)
+ o << "";
+ else
+ o << wchar_t(pAccel[i].key);
+
+ o << " " << std::hex << pAccel[i].cmd << std::dec;
+ }
+
+ firstdone = ci.cAccel;
+
+ GlobalUnlock(pAccel);
+ }
+ }
+
+ if(ci.dwFlags & CTRLINFO_EATS_RETURN)
+ {
+ if(!firstdone)
+ {
+ o << ", ";
+ ++ firstdone;
+ }
+
+ o << "ENTER";
+ }
+
+ if(ci.dwFlags & CTRLINFO_EATS_ESCAPE)
+ {
+ if(!firstdone)
+ {
+ o << ", ";
+ ++ firstdone;
+ }
+
+ o << "ESC";
+ }
+
+ if(firstdone)
+ o << " ";
+
+ o << "}";
+
+ return o.str();
+ }
+
+ std::basic_string MnemonicToString(const MSG& msg)
+ {
+ std::basic_ostringstream o;
+
+ o << "[";
+
+ switch(msg.message)
+ {
+ case WM_SYSKEYDOWN:
+ o << "ALT + ";
+
+ case WM_KEYDOWN:
+ TCHAR sz[1024];
+ GetKeyNameText(LONG(msg.lParam), sz, ARRAYSIZE(sz));
+ o << sz;
+
+ default:
+ o << "";
+ }
+
+ o << "]";
+
+ return o.str();
+ }
+
+ public:
+ virtual HRESULT STDMETHODCALLTYPE GetControlInfo(CONTROLINFO * pCI)
+ {
+ IOleControl * pIOleControl = getIOleControl();
+ dbgprintf(TEXT("IOleControl::GetControlInfo(%p)"), pCI);
+ HRESULT hr = pIOleControl->GetControlInfo(pCI);
+ dbgprintf(TEXT("IOleControl::GetControlInfo -> %08X, %s"), hr, ControlInfoToString(*pCI).c_str());
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE OnMnemonic(MSG * pMsg)
+ {
+ IOleControl * pIOleControl = getIOleControl();
+ dbgprintf(TEXT("IOleControl::OnMnemonic(%s)"), MnemonicToString(*pMsg).c_str());
+ HRESULT hr = pIOleControl->OnMnemonic(pMsg);
+ dbgprintf(TEXT("IOleControl::OnMnemonic -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE OnAmbientPropertyChange(DISPID dispID)
+ {
+ IOleControl * pIOleControl = getIOleControl();
+ dbgprintf(TEXT("IOleControl::OnAmbientPropertyChange(%08X)"), dispID);
+ HRESULT hr = pIOleControl->OnAmbientPropertyChange(dispID);
+ dbgprintf(TEXT("IOleControl::OnAmbientPropertyChange -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE FreezeEvents(BOOL bFreeze)
+ {
+ IOleControl * pIOleControl = getIOleControl();
+ dbgprintf(TEXT("IOleControl::FreezeEvents(%s)"), BooleanToString(bFreeze));
+ HRESULT hr = pIOleControl->FreezeEvents(bFreeze);
+ dbgprintf(TEXT("IOleControl::FreezeEvents -> %08X"), hr);
+ return hr;
+ }
+
+ /* IOleInPlaceActiveObject */
+ public:
+ virtual HRESULT STDMETHODCALLTYPE TranslateAccelerator(LPMSG lpmsg)
+ {
+ IOleInPlaceActiveObject * pIOleInPlaceActiveObject = getIOleInPlaceActiveObject();
+ dbgprintf(TEXT("IOleInPlaceActiveObject::TranslateAccelerator(%s)"), MnemonicToString(*lpmsg).c_str());
+ HRESULT hr = pIOleInPlaceActiveObject->TranslateAccelerator(lpmsg);
+ dbgprintf(TEXT("IOleInPlaceActiveObject::TranslateAccelerator -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE OnFrameWindowActivate(BOOL fActivate)
+ {
+ IOleInPlaceActiveObject * pIOleInPlaceActiveObject = getIOleInPlaceActiveObject();
+ dbgprintf(TEXT("IOleInPlaceActiveObject::OnFrameWindowActivate(%s)"), BooleanToString(fActivate));
+ HRESULT hr = pIOleInPlaceActiveObject->OnFrameWindowActivate(fActivate);
+ dbgprintf(TEXT("IOleInPlaceActiveObject::OnFrameWindowActivate -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE OnDocWindowActivate(BOOL fActivate)
+ {
+ IOleInPlaceActiveObject * pIOleInPlaceActiveObject = getIOleInPlaceActiveObject();
+ dbgprintf(TEXT("IOleInPlaceActiveObject::OnDocWindowActivate(%s)"), BooleanToString(fActivate));
+ HRESULT hr = pIOleInPlaceActiveObject->OnDocWindowActivate(fActivate);
+ dbgprintf(TEXT("IOleInPlaceActiveObject::OnDocWindowActivate -> %08X"), hr);
+ return hr;
+ }
+
+ 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);
+ dbgprintf(TEXT("IOleInPlaceActiveObject::ResizeBorder -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE EnableModeless(BOOL fEnable)
+ {
+ IOleInPlaceActiveObject * pIOleInPlaceActiveObject = getIOleInPlaceActiveObject();
+ dbgprintf(TEXT("IOleInPlaceActiveObject::EnableModeless(%s)"), BooleanToString(fEnable));
+ HRESULT hr = pIOleInPlaceActiveObject->EnableModeless(fEnable);
+ dbgprintf(TEXT("IOleInPlaceActiveObject::EnableModeless -> %08X"), hr);
+ return hr;
+ }
+
+ /* IOleInPlaceObject */
+ public:
+ virtual HRESULT STDMETHODCALLTYPE InPlaceDeactivate(void)
+ {
+ IOleInPlaceObject * pIOleInPlaceObject = getIOleInPlaceObject();
+ dbgprintf(TEXT("IOleInPlaceObject::InPlaceDeactivate()"));
+ HRESULT hr = pIOleInPlaceObject->InPlaceDeactivate();
+ dbgprintf(TEXT("IOleInPlaceObject::InPlaceDeactivate -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE UIDeactivate(void)
+ {
+ IOleInPlaceObject * pIOleInPlaceObject = getIOleInPlaceObject();
+ dbgprintf(TEXT("IOleInPlaceObject::UIDeactivate()"));
+ HRESULT hr = pIOleInPlaceObject->UIDeactivate();
+ dbgprintf(TEXT("IOleInPlaceObject::UIDeactivate -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE SetObjectRects(LPCRECT lprcPosRect, LPCRECT lprcClipRect)
+ {
+ IOleInPlaceObject * pIOleInPlaceObject = getIOleInPlaceObject();
+ dbgprintf(TEXT("IOleInPlaceObject::SetObjectRects(%s, %s)"), RectToString(*lprcPosRect).c_str(), RectToString(*lprcClipRect).c_str());
+ HRESULT hr = pIOleInPlaceObject->SetObjectRects(lprcPosRect, lprcClipRect);
+ dbgprintf(TEXT("IOleInPlaceObject::SetObjectRects -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE ReactivateAndUndo(void)
+ {
+ IOleInPlaceObject * pIOleInPlaceObject = getIOleInPlaceObject();
+ dbgprintf(TEXT("IOleInPlaceObject::ReactivateAndUndo()"));
+ HRESULT hr = pIOleInPlaceObject->ReactivateAndUndo();
+ dbgprintf(TEXT("IOleInPlaceObject::ReactivateAndUndo -> %08X"), hr);
+ return hr;
+ }
+
+ /* IOleWindow */
+ public:
+ virtual HRESULT STDMETHODCALLTYPE GetWindow(HWND * phwnd)
+ {
+ IOleWindow * pIOleWindow = getIOleWindow();
+ dbgprintf(TEXT("IOleWindow::GetWindow(%p)"), phwnd);
+ HRESULT hr = pIOleWindow->GetWindow(phwnd);
+ dbgprintf(TEXT("IOleWindow::GetWindow -> %08X, hwnd = %X"), hr, *phwnd);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(BOOL fEnterMode)
+ {
+ IOleWindow * pIOleWindow = getIOleWindow();
+ dbgprintf(TEXT("IOleWindow::ContextSensitiveHelp(%s)"), BooleanToString(fEnterMode));
+ HRESULT hr = pIOleWindow->ContextSensitiveHelp(fEnterMode);
+ dbgprintf(TEXT("IOleWindow::ContextSensitiveHelp -> %08X"), hr);
+ return hr;
+ }
+
+ /* IOleObject */
+ public:
+ virtual HRESULT STDMETHODCALLTYPE SetClientSite(IOleClientSite * pClientSite)
+ {
+ // TODO: hook pClientSite
+ IOleObject * pIOleObject = getIOleObject();
+ dbgprintf(TEXT("IOleObject::SetClientSite(%p)"), pClientSite);
+ HRESULT hr = pIOleObject->SetClientSite(pClientSite);
+ dbgprintf(TEXT("IOleObject::SetClientSite -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE GetClientSite(IOleClientSite ** ppClientSite)
+ {
+ IOleObject * pIOleObject = getIOleObject();
+ dbgprintf(TEXT("IOleObject::GetClientSite(%s)"), ppClientSite);
+ HRESULT hr = pIOleObject->GetClientSite(ppClientSite);
+ dbgprintf(TEXT("IOleObject::GetClientSite -> %08X"), hr, ppClientSite);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE SetHostNames(LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
+ {
+ IOleObject * pIOleObject = getIOleObject();
+ dbgprintf(TEXT("IOleObject::SetHostNames(%ls, %ls)"), szContainerApp, szContainerObj);
+ HRESULT hr = pIOleObject->SetHostNames(szContainerApp, szContainerObj);
+ dbgprintf(TEXT("IOleObject::SetHostNames -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE Close(DWORD dwSaveOption)
+ {
+ IOleObject * pIOleObject = getIOleObject();
+ dbgprintf(TEXT("IOleObject::Close(%lu)"), dwSaveOption);
+ HRESULT hr = pIOleObject->Close(dwSaveOption);
+ dbgprintf(TEXT("IOleObject::Close -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE SetMoniker(DWORD dwWhichMoniker, IMoniker * pmk)
+ {
+ IOleObject * pIOleObject = getIOleObject();
+ dbgprintf(TEXT("IOleObject::SetMoniker(%lu, %p)"), dwWhichMoniker, MonikerToString(pmk).c_str());
+ HRESULT hr = pIOleObject->SetMoniker(dwWhichMoniker, pmk);
+ dbgprintf(TEXT("IOleObject::SetMoniker -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker, IMoniker ** ppmk)
+ {
+ IOleObject * pIOleObject = getIOleObject();
+ dbgprintf(TEXT("IOleObject::GetMoniker(%lu, %lu, %p)"), dwAssign, dwWhichMoniker, ppmk);
+ HRESULT hr = pIOleObject->GetMoniker(dwAssign, dwWhichMoniker, ppmk);
+ dbgprintf(TEXT("IOleObject::GetMoniker -> %08X, pmk = %s"), hr, SUCCEEDED(hr) ? MonikerToString(*ppmk).c_str() : TEXT(""));
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE InitFromData(IDataObject * pDataObject, BOOL fCreation, DWORD dwReserved)
+ {
+ IOleObject * pIOleObject = getIOleObject();
+ dbgprintf(TEXT("IOleObject::InitFromData(%p, %s, %lu)"), pDataObject, BooleanToString(fCreation), dwReserved);
+ HRESULT hr = pIOleObject->InitFromData(pDataObject, fCreation, dwReserved);
+ dbgprintf(TEXT("IOleObject::InitFromData -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE GetClipboardData(DWORD dwReserved, IDataObject ** ppDataObject)
+ {
+ IOleObject * pIOleObject = getIOleObject();
+ dbgprintf(TEXT("IOleObject::GetClipboardData(%lu, %p)"), dwReserved, ppDataObject);
+ HRESULT hr = pIOleObject->GetClipboardData(dwReserved, ppDataObject);
+ dbgprintf(TEXT("IOleObject::GetClipboardData -> %08X, pDataObject = %p"), hr, *ppDataObject);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE DoVerb(LONG iVerb, LPMSG lpmsg, IOleClientSite * pActiveSite, LONG lindex, HWND hwndParent, LPCRECT lprcPosRect)
+ {
+ IOleObject * pIOleObject = getIOleObject();
+ dbgprintf(TEXT("IOleObject::DoVerb(%ld, %p, %p, %ld, %p, %s)"), iVerb, lpmsg, pActiveSite, lindex, hwndParent, RectToString(*lprcPosRect).c_str());
+ HRESULT hr = pIOleObject->DoVerb(iVerb, lpmsg, pActiveSite, lindex, hwndParent, lprcPosRect);
+ dbgprintf(TEXT("IOleObject::DoVerb -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE EnumVerbs(IEnumOLEVERB ** ppEnumOleVerb)
+ {
+ IOleObject * pIOleObject = getIOleObject();
+ dbgprintf(TEXT("IOleObject::EnumVerbs(%p)"), ppEnumOleVerb);
+ HRESULT hr = pIOleObject->EnumVerbs(ppEnumOleVerb);
+ dbgprintf(TEXT("IOleObject::EnumVerbs -> %08X, pEnumOleVerb = %p"), hr, *ppEnumOleVerb);
+ // TODO: hook
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE Update(void)
+ {
+ IOleObject * pIOleObject = getIOleObject();
+ dbgprintf(TEXT("IOleObject::Update(%s)"));
+ HRESULT hr = pIOleObject->Update();
+ dbgprintf(TEXT("IOleObject::Update -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE IsUpToDate(void)
+ {
+ IOleObject * pIOleObject = getIOleObject();
+ dbgprintf(TEXT("IOleObject::IsUpToDate(%s)"));
+ HRESULT hr = pIOleObject->IsUpToDate();
+ dbgprintf(TEXT("IOleObject::IsUpToDate -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE GetUserClassID(CLSID * pClsid)
+ {
+ IOleObject * pIOleObject = getIOleObject();
+ dbgprintf(TEXT("IOleObject::GetUserClassID(%p)"), pClsid);
+ HRESULT hr = pIOleObject->GetUserClassID(pClsid);
+ dbgprintf(TEXT("IOleObject::GetUserClassID -> %08X, Clsid = %ls"), hr, UUIDToString(*pClsid).c_str());
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE GetUserType(DWORD dwFormOfType, LPOLESTR * pszUserType)
+ {
+ IOleObject * pIOleObject = getIOleObject();
+ dbgprintf(TEXT("IOleObject::GetUserType(%lu, %p)"), dwFormOfType, pszUserType);
+ HRESULT hr = pIOleObject->GetUserType(dwFormOfType, pszUserType);
+ dbgprintf(TEXT("IOleObject::GetUserType -> %08X, szUserType = %s"), hr, *pszUserType);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE SetExtent(DWORD dwDrawAspect, SIZEL * psizel)
+ {
+ IOleObject * pIOleObject = getIOleObject();
+ dbgprintf(TEXT("IOleObject::SetExtent(%lu, %s)"), dwDrawAspect, SizeToString(*psizel).c_str());
+ HRESULT hr = pIOleObject->SetExtent(dwDrawAspect, psizel);
+ dbgprintf(TEXT("IOleObject::SetExtent -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE GetExtent(DWORD dwDrawAspect, SIZEL * psizel)
+ {
+ IOleObject * pIOleObject = getIOleObject();
+ dbgprintf(TEXT("IOleObject::GetExtent(%lu, %p)"), dwDrawAspect, psizel);
+ HRESULT hr = pIOleObject->GetExtent(dwDrawAspect, psizel);
+ dbgprintf(TEXT("IOleObject::GetExtent -> %08X"), hr, SizeToString(*psizel).c_str());
+ return hr;
+ }
+
+ 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);
+ dbgprintf(TEXT("IOleObject::Advise -> %08X, dwConnection = %lu"), hr, *pdwConnection);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE Unadvise(DWORD dwConnection)
+ {
+ IOleObject * pIOleObject = getIOleObject();
+ dbgprintf(TEXT("IOleObject::Unadvise(%lu)"), dwConnection);
+ HRESULT hr = pIOleObject->Unadvise(dwConnection);
+ dbgprintf(TEXT("IOleObject::Unadvise -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE EnumAdvise(IEnumSTATDATA ** ppenumAdvise)
+ {
+ IOleObject * pIOleObject = getIOleObject();
+ dbgprintf(TEXT("IOleObject::EnumAdvise(%p)"), ppenumAdvise);
+ HRESULT hr = pIOleObject->EnumAdvise(ppenumAdvise);
+ dbgprintf(TEXT("IOleObject::EnumAdvise -> %08X, penumAdvise = %p"), hr, *ppenumAdvise);
+ // TODO: hook
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE GetMiscStatus(DWORD dwAspect, DWORD * pdwStatus)
+ {
+ IOleObject * pIOleObject = getIOleObject();
+ dbgprintf(TEXT("IOleObject::GetMiscStatus(%lu, %p)"), dwAspect, pdwStatus);
+ HRESULT hr = pIOleObject->GetMiscStatus(dwAspect, pdwStatus);
+ dbgprintf(TEXT("IOleObject::GetMiscStatus -> %08X, dwStatus = %08X"), hr, *pdwStatus);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE SetColorScheme(LOGPALETTE * pLogpal)
+ {
+ IOleObject * pIOleObject = getIOleObject();
+ dbgprintf(TEXT("IOleObject::SetColorScheme(%p)"), pLogpal);
+ HRESULT hr = pIOleObject->SetColorScheme(pLogpal);
+ dbgprintf(TEXT("IOleObject::SetColorScheme -> %08X"), hr);
+ return hr;
+ }
+
+ /* IPersist */
+ public:
+ virtual HRESULT STDMETHODCALLTYPE GetClassID(CLSID * pClassID)
+ {
+ IPersist * pIPersist = getIPersist();
+ dbgprintf(TEXT("IPersist::GetClassID(%p)"), pClassID);
+ HRESULT hr = pIPersist->GetClassID(pClassID);
+ dbgprintf(TEXT("IPersist::GetClassID -> %08X, ClassId = %ls"), hr, UUIDToString(*pClassID).c_str());
+ return hr;
+ }
+
+ /* IPersistPropertyBag */
+ public:
+ virtual HRESULT STDMETHODCALLTYPE InitNew(void)
+ {
+ IPersistPropertyBag * pIPersistPropertyBag = getIPersistPropertyBag();
+ dbgprintf(TEXT("IPersistPropertyBag::InitNew()"));
+ HRESULT hr = pIPersistPropertyBag->InitNew();
+ 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);
+ dbgprintf(TEXT("IPersistPropertyBag::Load -> %08X"), hr);
+ return hr;
+ }
+
+ 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);
+ dbgprintf(TEXT("IPersistPropertyBag::Save -> %08X"), hr);
+ return hr;
+ }
+
+ /* IPersistStorage */
+ public:
+ virtual HRESULT STDMETHODCALLTYPE IPersistStorage::IsDirty(void)
+ {
+ IPersistStorage * pIPersistStorage = getIPersistStorage();
+ dbgprintf(TEXT("IPersistStorage::IsDirty()"));
+ HRESULT hr = pIPersistStorage->IsDirty();
+ dbgprintf(TEXT("IPersistStorage::IsDirty -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE IPersistStorage::InitNew(IStorage * pStg)
+ {
+ IPersistStorage * pIPersistStorage = getIPersistStorage();
+ dbgprintf(TEXT("IPersistStorage::InitNew(%p)"), pStg);
+ HRESULT hr = pIPersistStorage->InitNew(pStg);
+ dbgprintf(TEXT("IPersistStorage::InitNew -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE IPersistStorage::Load(IStorage * pStg)
+ {
+ IPersistStorage * pIPersistStorage = getIPersistStorage();
+ dbgprintf(TEXT("IPersistStorage::Load(%p)"), pStg);
+ HRESULT hr = pIPersistStorage->Load(pStg);
+ dbgprintf(TEXT("IPersistStorage::Load -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE IPersistStorage::Save(IStorage * pStgSave, BOOL fSameAsLoad)
+ {
+ IPersistStorage * pIPersistStorage = getIPersistStorage();
+ dbgprintf(TEXT("IPersistStorage::Save(%p, %s)"), pStgSave, BooleanToString(fSameAsLoad));
+ HRESULT hr = pIPersistStorage->Save(pStgSave, fSameAsLoad);
+ dbgprintf(TEXT("IPersistStorage::Save -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE SaveCompleted(IStorage * pStgNew)
+ {
+ IPersistStorage * pIPersistStorage = getIPersistStorage();
+ dbgprintf(TEXT("IPersistStorage::SaveCompleted(%p)"), pStgNew);
+ HRESULT hr = pIPersistStorage->SaveCompleted(pStgNew);
+ dbgprintf(TEXT("IPersistStorage::SaveCompleted -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE HandsOffStorage(void)
+ {
+ IPersistStorage * pIPersistStorage = getIPersistStorage();
+ dbgprintf(TEXT("IPersistStorage::HandsOffStorage()"));
+ HRESULT hr = pIPersistStorage->HandsOffStorage();
+ dbgprintf(TEXT("IPersistStorage::HandsOffStorage -> %08X"), hr);
+ return hr;
+ }
+
+ /* IPersistStreamInit */
+ public:
+ virtual HRESULT STDMETHODCALLTYPE IPersistStreamInit::IsDirty(void)
+ {
+ IPersistStreamInit * pIPersistStreamInit = getIPersistStreamInit();
+ dbgprintf(TEXT("IPersistStreamInit::IsDirty()"));
+ HRESULT hr = pIPersistStreamInit->IsDirty();
+ dbgprintf(TEXT("IPersistStreamInit::IsDirty -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE IPersistStreamInit::Load(LPSTREAM pStm)
+ {
+ IPersistStreamInit * pIPersistStreamInit = getIPersistStreamInit();
+ dbgprintf(TEXT("IPersistStreamInit::Load(%p)"), pStm);
+ HRESULT hr = pIPersistStreamInit->Load(pStm);
+ dbgprintf(TEXT("IPersistStreamInit::Load -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE IPersistStreamInit::Save(LPSTREAM pStm, BOOL fClearDirty)
+ {
+ IPersistStreamInit * pIPersistStreamInit = getIPersistStreamInit();
+ dbgprintf(TEXT("IPersistStreamInit::Save(%p, %s)"), pStm, BooleanToString(fClearDirty));
+ HRESULT hr = pIPersistStreamInit->Save(pStm, fClearDirty);
+ dbgprintf(TEXT("IPersistStreamInit::Save -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE IPersistStreamInit::GetSizeMax(ULARGE_INTEGER * pCbSize)
+ {
+ IPersistStreamInit * pIPersistStreamInit = getIPersistStreamInit();
+ dbgprintf(TEXT("IPersistStreamInit::GetSizeMax(%p)"), pCbSize);
+ HRESULT hr = pIPersistStreamInit->GetSizeMax(pCbSize);
+ dbgprintf(TEXT("IPersistStreamInit::GetSizeMax -> %08X, CbSize = %llu"), hr, pCbSize->QuadPart);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE IPersistStreamInit::InitNew(void)
+ {
+ IPersistStreamInit * pIPersistStreamInit = getIPersistStreamInit();
+ dbgprintf(TEXT("IPersistStreamInit::InitNew()"));
+ HRESULT hr = pIPersistStreamInit->InitNew();
+ dbgprintf(TEXT("IPersistStreamInit::InitNew -> %08X"), hr);
+ return hr;
+ }
+
+ /* IProvideClassInfo */
+ public:
+ virtual HRESULT STDMETHODCALLTYPE GetClassInfo(ITypeInfo ** ppTI)
+ {
+ IProvideClassInfo * pIProvideClassInfo = getIProvideClassInfo();
+ dbgprintf(TEXT("IProvideClassInfo::GetClassInfo(%p)"), ppTI);
+ HRESULT hr = pIProvideClassInfo->GetClassInfo(ppTI);
+ dbgprintf(TEXT("IProvideClassInfo::GetClassInfo -> %08X, pTI = %p"), hr, *ppTI);
+ return hr;
+ }
+
+ /* IProvideClassInfo2 */
+ public:
+ virtual HRESULT STDMETHODCALLTYPE IProvideClassInfo2::GetGUID(DWORD dwGuidKind, GUID * pGUID)
+ {
+ IProvideClassInfo2 * pIProvideClassInfo2 = getIProvideClassInfo2();
+ dbgprintf(TEXT("IProvideClassInfo2::GetGUID(%lu, %p)"), dwGuidKind, pGUID);
+ HRESULT hr = pIProvideClassInfo2->GetGUID(dwGuidKind, pGUID);
+ dbgprintf(TEXT("IProvideClassInfo2::GetGUID -> %08X, GUID = %ls"), hr, UUIDToString(*pGUID).c_str());
+ return hr;
+ }
+
+ /* IQuickActivate */
+ public:
+ virtual HRESULT STDMETHODCALLTYPE IQuickActivate::QuickActivate(QACONTAINER * pQaContainer, QACONTROL * pQaControl) // TODO
+ {
+ IQuickActivate * pIQuickActivate = getIQuickActivate();
+
+ std::basic_stringstream o1;
+
+ o1 << "{ ";
+ o1 << "pClientSite = " << (void *)pQaContainer->pClientSite << ", ";
+ o1 << "pAdviseSink = " << (void *)pQaContainer->pAdviseSink << ", ";
+ o1 << "pPropertyNotifySink = " << (void *)pQaContainer->pPropertyNotifySink << ", ";
+ o1 << "pUnkEventSink = " << (void *)pQaContainer->pUnkEventSink << ", ";
+
+ o1 << std::hex;
+ o1 << "dwAmbientFlags = " << pQaContainer->dwAmbientFlags << ", ";
+ o1 << "colorFore = " << pQaContainer->colorFore << ", ";
+ o1 << "colorBack = " << pQaContainer->colorBack << ", ";
+ o1 << std::dec;
+
+ o1 << "pFont = " << (void *)pQaContainer->pFont << ", ";
+ o1 << "pUndoMgr = " << (void *)pQaContainer->pUndoMgr << ", ";
+
+ o1 << std::hex;
+ o1 << "dwAppearance = " << pQaContainer->dwAppearance << ", ";
+ o1 << "lcid = " << pQaContainer->lcid << ", ";
+ o1 << std::dec;
+
+ o1 << "hpal = " << (void *)pQaContainer->hpal << ", ";
+ o1 << "pBindHost = " << (void *)pQaContainer->pBindHost << ", ";
+ o1 << "pOleControlSite = " << (void *)pQaContainer->pOleControlSite << ", ";
+ o1 << "pServiceProvider = " << (void *)pQaContainer->pServiceProvider << ", ";
+ o1 << "}";
+
+ dbgprintf(TEXT("IQuickActivate::QuickActivate(%s, %p)"), o1.str().c_str(), pQaControl);
+
+ HRESULT hr = pIQuickActivate->QuickActivate(pQaContainer, pQaControl);
+
+ std::basic_stringstream o2;
+
+ o2 << "{ ";
+ o2 << std::hex;
+ o2 << "dwMiscStatus = " << pQaControl->dwMiscStatus << ", ";
+ o2 << "dwViewStatus = " << pQaControl->dwViewStatus << ", ";
+ o2 << "dwEventCookie = " << pQaControl->dwEventCookie << ", ";
+ o2 << "dwPropNotifyCookie = " << pQaControl->dwPropNotifyCookie << ", ";
+ o2 << "dwPointerActivationPolicy = " << pQaControl->dwPointerActivationPolicy << ", ";
+ o2 << std::dec;
+ o2 << "}";
+
+ dbgprintf(TEXT("IQuickActivate::QuickActivate -> %08X, QaControl = %s"), hr, o2.str().c_str());
+
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE IQuickActivate::SetContentExtent(LPSIZEL pSizel)
+ {
+ IQuickActivate * pIQuickActivate = getIQuickActivate();
+ dbgprintf(TEXT("IQuickActivate::SetContentExtent(%s)"), SizeToString(*pSizel).c_str());
+ HRESULT hr = pIQuickActivate->SetContentExtent(pSizel);
+ dbgprintf(TEXT("IQuickActivate::SetContentExtent -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE IQuickActivate::GetContentExtent(LPSIZEL pSizel)
+ {
+ IQuickActivate * pIQuickActivate = getIQuickActivate();
+ dbgprintf(TEXT("IQuickActivate::GetContentExtent(%p)"), pSizel);
+ HRESULT hr = pIQuickActivate->GetContentExtent(pSizel);
+ dbgprintf(TEXT("IQuickActivate::GetContentExtent -> %08X, Sizel = %s"), hr, SizeToString(*pSizel).c_str());
+ return hr;
+ }
+
+ /* ISpecifyPropertyPages */
+ private:
+ std::basic_string CauuidToString(const CAUUID& cauuid)
+ {
+ std::basic_ostringstream o;
+
+ o << "{";
+
+ for(ULONG i = 0; i < cauuid.cElems; ++ i)
+ {
+ if(i)
+ o << ", ";
+ else
+ o << " ";
+
+ o << UUIDToString(cauuid.pElems[i]);
+ }
+
+ o << " }";
+
+ return o.str();
+ }
+
+ public:
+ virtual HRESULT STDMETHODCALLTYPE ISpecifyPropertyPages::GetPages(CAUUID * pPages)
+ {
+ ISpecifyPropertyPages * pISpecifyPropertyPages = getISpecifyPropertyPages();
+ dbgprintf(TEXT("ISpecifyPropertyPages::GetPages(%p)"), pPages);
+ HRESULT hr = pISpecifyPropertyPages->GetPages(pPages);
+ dbgprintf(TEXT("ISpecifyPropertyPages::GetPages -> %08X, Pages = %s"), hr, CauuidToString(*pPages).c_str());
+ return hr;
+ }
+
+ /* IViewObject */
+ public:
+ virtual HRESULT STDMETHODCALLTYPE 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)
+ {
+ IViewObject * pIViewObject = getIViewObject();
+ dbgprintf(TEXT("IViewObject::Draw(%s, %ld, %p, %s, %p, %p, %s, %s, %p, %p)"), AspectToString(dwDrawAspect), lindex, pvAspect, TargetDeviceToString(*ptd).c_str(), hdcTargetDev, hdcDraw, RectToString(*lprcBounds).c_str(), RectToString(*lprcWBounds).c_str(), pfnContinue, dwContinue);
+ HRESULT hr = pIViewObject->Draw(dwDrawAspect, lindex, pvAspect, ptd, hdcTargetDev, hdcDraw, lprcBounds, lprcWBounds, pfnContinue, dwContinue);
+ dbgprintf(TEXT("IViewObject::Draw -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE IViewObject::GetColorSet(DWORD dwDrawAspect, LONG lindex, void * pvAspect, DVTARGETDEVICE * ptd, HDC hicTargetDev, LOGPALETTE ** ppColorSet)
+ {
+ IViewObject * pIViewObject = getIViewObject();
+ dbgprintf(TEXT("IViewObject::GetColorSet(%s, %ld, %p, %s, %p, %p)"), AspectToString(dwDrawAspect), lindex, pvAspect, TargetDeviceToString(*ptd).c_str(), hicTargetDev, ppColorSet);
+ HRESULT hr = pIViewObject->GetColorSet(dwDrawAspect, lindex, pvAspect, ptd, hicTargetDev, ppColorSet);
+ dbgprintf(TEXT("IViewObject::GetColorSet -> %08X, pColorSet = %p"), hr, *ppColorSet);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE IViewObject::Freeze(DWORD dwDrawAspect, LONG lindex, void * pvAspect, DWORD * pdwFreeze)
+ {
+ IViewObject * pIViewObject = getIViewObject();
+ dbgprintf(TEXT("IViewObject::Freeze(%s, %ld, %p, %p)"), AspectToString(dwDrawAspect), lindex, pvAspect, pdwFreeze);
+ HRESULT hr = pIViewObject->Freeze(dwDrawAspect, lindex, pvAspect, pdwFreeze);
+ dbgprintf(TEXT("IViewObject::Freeze -> %08X, dwFreeze = %08X"), hr, *pdwFreeze);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE IViewObject::Unfreeze(DWORD dwFreeze)
+ {
+ IViewObject * pIViewObject = getIViewObject();
+ dbgprintf(TEXT("IViewObject::Unfreeze(%08X)"), dwFreeze);
+ HRESULT hr = pIViewObject->Unfreeze(dwFreeze);
+ dbgprintf(TEXT("IViewObject::Unfreeze -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE IViewObject::SetAdvise(DWORD aspects, DWORD advf, IAdviseSink * pAdvSink)
+ {
+ IViewObject * pIViewObject = getIViewObject();
+ dbgprintf(TEXT("IViewObject::SetAdvise(%s, %08X, %p)"), AspectToString(aspects), advf, pAdvSink);
+ HRESULT hr = pIViewObject->SetAdvise(aspects, advf, pAdvSink);
+ dbgprintf(TEXT("IViewObject::SetAdvise -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE IViewObject::GetAdvise(DWORD * pAspects, DWORD * pAdvf, IAdviseSink ** ppAdvSink)
+ {
+ IViewObject * pIViewObject = getIViewObject();
+ dbgprintf(TEXT("IViewObject::GetAdvise(%p, %p, %p)"), pAspects, pAdvf, ppAdvSink);
+ HRESULT hr = pIViewObject->GetAdvise(pAspects, pAdvf, ppAdvSink);
+ dbgprintf(TEXT("IViewObject::GetAdvise -> %08X, aspects = %s, advf = %08X, pAdvSink %p"), hr, AspectToString(*pAspects), *pAdvf, *ppAdvSink);
+ return hr;
+ }
+
+ /* IViewObject2 */
+ public:
+ virtual HRESULT STDMETHODCALLTYPE IViewObject2::GetExtent(DWORD dwDrawAspect, LONG lindex, DVTARGETDEVICE * ptd, LPSIZEL lpsizel)
+ {
+ IViewObject2 * pIViewObject2 = getIViewObject2();
+ dbgprintf(TEXT("IViewObject2::GetExtent(%s, %ld, %s, %p)"), AspectToString(dwDrawAspect), lindex, TargetDeviceToString(*ptd).c_str(), lpsizel);
+ HRESULT hr = pIViewObject2->GetExtent(dwDrawAspect, lindex, ptd, lpsizel);
+ dbgprintf(TEXT("IViewObject2::GetExtent -> %08X, sizel = %s"), hr, SizeToString(*lpsizel).c_str());
+ return hr;
+ }
+
+ /* IMsTscAx */
+ public:
+ virtual HRESULT __stdcall put_Server(BSTR pServer)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::put_Server(%ls)"), pServer);
+ HRESULT hr = pIMsTscAx->put_Server(pServer);
+ dbgprintf(TEXT("IMsTscAx::put_Server -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_Server(BSTR * pServer)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::get_Server()"), pServer);
+ HRESULT hr = pIMsTscAx->get_Server(pServer);
+ dbgprintf(TEXT("IMsTscAx::get_Server -> %08X, server = %ls"), hr, *pServer);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall put_Domain(BSTR pDomain)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::put_Domain(%ls)"), pDomain);
+ HRESULT hr = pIMsTscAx->put_Domain(pDomain);
+ dbgprintf(TEXT("IMsTscAx::put_Domain -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_Domain(BSTR * pDomain)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::get_Domain(%p)"), pDomain);
+ HRESULT hr = pIMsTscAx->get_Domain(pDomain);
+ dbgprintf(TEXT("IMsTscAx::get_Domain -> %08X, Domain = %ls"), hr, *pDomain);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall put_UserName(BSTR pUserName)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::put_UserName(%ls)"), pUserName);
+ HRESULT hr = pIMsTscAx->put_UserName(pUserName);
+ dbgprintf(TEXT("IMsTscAx::put_UserName -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_UserName(BSTR * pUserName)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::get_UserName(%p)"), pUserName);
+ HRESULT hr = pIMsTscAx->get_UserName(pUserName);
+ dbgprintf(TEXT("IMsTscAx::get_UserName -> %08X, UserName = %ls"), hr, *pUserName);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall put_DisconnectedText(BSTR pDisconnectedText)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::put_DisconnectedText(%ls)"), pDisconnectedText);
+ HRESULT hr = pIMsTscAx->put_DisconnectedText(pDisconnectedText);
+ dbgprintf(TEXT("IMsTscAx::put_DisconnectedText -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_DisconnectedText(BSTR * pDisconnectedText)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::get_DisconnectedText(%p)"), pDisconnectedText);
+ HRESULT hr = pIMsTscAx->get_DisconnectedText(pDisconnectedText);
+ dbgprintf(TEXT("IMsTscAx::get_DisconnectedText -> %08X, DisconnectedText = %ls"), hr, *pDisconnectedText);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall put_ConnectingText(BSTR pConnectingText)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::put_ConnectingText(%ls)"), pConnectingText);
+ HRESULT hr = pIMsTscAx->put_ConnectingText(pConnectingText);
+ dbgprintf(TEXT("IMsTscAx::put_ConnectingText -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_ConnectingText(BSTR * pConnectingText)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::get_ConnectingText(%p)"), pConnectingText);
+ HRESULT hr = pIMsTscAx->get_ConnectingText(pConnectingText);
+ dbgprintf(TEXT("IMsTscAx::get_ConnectingText -> %08X, ConnectingText = %ls"), hr, *pConnectingText);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_Connected(short * pIsConnected)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::get_Connected(%p)"), pIsConnected);
+ HRESULT hr = pIMsTscAx->get_Connected(pIsConnected);
+ dbgprintf(TEXT("IMsTscAx::get_Connected -> %08X, IsConnected = %s"), hr, BooleanToString(*pIsConnected));
+ return hr;
+ }
+
+ virtual HRESULT __stdcall put_DesktopWidth(long pVal)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::put_DesktopWidth(%ld)"), pVal);
+ HRESULT hr = pIMsTscAx->put_DesktopWidth(pVal);
+ dbgprintf(TEXT("IMsTscAx::put_DesktopWidth -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_DesktopWidth(long * pVal)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::get_DesktopWidth(%p)"), pVal);
+ HRESULT hr = pIMsTscAx->get_DesktopWidth(pVal);
+ dbgprintf(TEXT("IMsTscAx::get_DesktopWidth -> %08X, Val = %lu"), hr, *pVal);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall put_DesktopHeight(long pVal)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::put_DesktopHeight(%ld)"), pVal);
+ HRESULT hr = pIMsTscAx->put_DesktopHeight(pVal);
+ dbgprintf(TEXT("IMsTscAx::put_DesktopHeight -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_DesktopHeight(long * pVal)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::get_DesktopHeight(%p)"), pVal);
+ HRESULT hr = pIMsTscAx->get_DesktopHeight(pVal);
+ dbgprintf(TEXT("IMsTscAx::get_DesktopHeight -> %08X, Val = %lu"), hr, *pVal);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall put_StartConnected(long pfStartConnected)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::put_StartConnected(%s)"), BooleanToString(pfStartConnected));
+ HRESULT hr = pIMsTscAx->put_StartConnected(pfStartConnected);
+ dbgprintf(TEXT("IMsTscAx::put_StartConnected -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_StartConnected(long * pfStartConnected)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::get_StartConnected(%p)"), pfStartConnected);
+ HRESULT hr = pIMsTscAx->get_StartConnected(pfStartConnected);
+ dbgprintf(TEXT("IMsTscAx::get_StartConnected -> %08X, fStartConnected = %s"), hr, BooleanToString(*pfStartConnected));
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_HorizontalScrollBarVisible(long * pfHScrollVisible)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::get_HorizontalScrollBarVisible(%p)"), pfHScrollVisible);
+ HRESULT hr = pIMsTscAx->get_HorizontalScrollBarVisible(pfHScrollVisible);
+ dbgprintf(TEXT("IMsTscAx::get_HorizontalScrollBarVisible -> %08X, fHScrollVisible = %s"), hr, BooleanToString(*pfHScrollVisible));
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_VerticalScrollBarVisible(long * pfVScrollVisible)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::get_VerticalScrollBarVisible(%p)"), pfVScrollVisible);
+ HRESULT hr = pIMsTscAx->get_VerticalScrollBarVisible(pfVScrollVisible);
+ dbgprintf(TEXT("IMsTscAx::get_VerticalScrollBarVisible -> %08X, fVScrollVisible"), hr, *pfVScrollVisible);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall put_FullScreenTitle(BSTR _arg1)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::put_FullScreenTitle(%ls)"), _arg1);
+ HRESULT hr = pIMsTscAx->put_FullScreenTitle(_arg1);
+ dbgprintf(TEXT("IMsTscAx::put_FullScreenTitle -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_CipherStrength(long * pCipherStrength)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::get_CipherStrength(%p)"), pCipherStrength);
+ HRESULT hr = pIMsTscAx->get_CipherStrength(pCipherStrength);
+ dbgprintf(TEXT("IMsTscAx::get_CipherStrength -> %08X, CipherStrength = %ld"), hr, *pCipherStrength);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_Version(BSTR * pVersion)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::get_Version(%p)"), pVersion);
+ HRESULT hr = pIMsTscAx->get_Version(pVersion);
+ dbgprintf(TEXT("IMsTscAx::get_Version -> %08X, Version = %ls"), hr, *pVersion);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_SecuredSettingsEnabled(long * pSecuredSettingsEnabled)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::get_SecuredSettingsEnabled(%p)"), pSecuredSettingsEnabled);
+ HRESULT hr = pIMsTscAx->get_SecuredSettingsEnabled(pSecuredSettingsEnabled);
+ dbgprintf(TEXT("IMsTscAx::get_SecuredSettingsEnabled -> %08X, SecuredSettingsEnabled = %s"), hr, BooleanToString(*pSecuredSettingsEnabled));
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_SecuredSettings(IMsTscSecuredSettings ** ppSecuredSettings)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::get_SecuredSettings(%p)"), ppSecuredSettings);
+ HRESULT hr = pIMsTscAx->get_SecuredSettings(ppSecuredSettings);
+ dbgprintf(TEXT("IMsTscAx::get_SecuredSettings -> %08X, pSecuredSettings = %p"), hr, *ppSecuredSettings);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_AdvancedSettings(IMsTscAdvancedSettings ** ppAdvSettings)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ 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;
+ }
+
+ virtual HRESULT __stdcall get_Debugger(IMsTscDebug ** ppDebugger)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::get_Debugger(%p)"), ppDebugger);
+ HRESULT hr = pIMsTscAx->get_Debugger(ppDebugger);
+ dbgprintf(TEXT("IMsTscAx::get_Debugger -> %08X, pDebugger = %p"), hr, *ppDebugger);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall Connect()
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::Connect()"));
+ HRESULT hr = pIMsTscAx->Connect();
+ dbgprintf(TEXT("IMsTscAx::Connect -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall Disconnect()
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::Disconnect()"));
+ HRESULT hr = pIMsTscAx->Disconnect();
+ dbgprintf(TEXT("IMsTscAx::Disconnect -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall CreateVirtualChannels(BSTR newVal)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::CreateVirtualChannels(%ls)"), newVal);
+ HRESULT hr = pIMsTscAx->CreateVirtualChannels(newVal);
+ dbgprintf(TEXT("IMsTscAx::CreateVirtualChannels -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall SendOnVirtualChannel(BSTR chanName, BSTR ChanData)
+ {
+ IMsTscAx * pIMsTscAx = getIMsTscAx();
+ dbgprintf(TEXT("IMsTscAx::SendOnVirtualChannel(%ls, %p)"), chanName, ChanData);
+ HRESULT hr = pIMsTscAx->SendOnVirtualChannel(chanName, ChanData);
+ dbgprintf(TEXT("IMsTscAx::SendOnVirtualChannel -> %08X"), hr);
+ return hr;
+ }
+
+ /* IMsRdpClient */
+ public:
+ virtual HRESULT __stdcall put_ColorDepth(long pcolorDepth)
+ {
+ IMsRdpClient * pIMsRdpClient = getIMsRdpClient();
+ dbgprintf(TEXT("IMsRdpClient::put_ColorDepth(%ld)"), pcolorDepth);
+ HRESULT hr = pIMsRdpClient->put_ColorDepth(pcolorDepth);
+ dbgprintf(TEXT("IMsRdpClient::put_ColorDepth -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_ColorDepth(long * pcolorDepth)
+ {
+ IMsRdpClient * pIMsRdpClient = getIMsRdpClient();
+ dbgprintf(TEXT("IMsRdpClient::get_ColorDepth(%p)"), pcolorDepth);
+ HRESULT hr = pIMsRdpClient->get_ColorDepth(pcolorDepth);
+ dbgprintf(TEXT("IMsRdpClient::get_ColorDepth -> %08X, colorDepth = %ld"), hr, *pcolorDepth);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_AdvancedSettings2(IMsRdpClientAdvancedSettings ** ppAdvSettings)
+ {
+ IMsRdpClient * pIMsRdpClient = getIMsRdpClient();
+ 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;
+ }
+
+ virtual HRESULT __stdcall get_SecuredSettings2(IMsRdpClientSecuredSettings ** ppSecuredSettings)
+ {
+ IMsRdpClient * pIMsRdpClient = getIMsRdpClient();
+ dbgprintf(TEXT("IMsRdpClient::get_SecuredSettings2(%p)"), ppSecuredSettings);
+ HRESULT hr = pIMsRdpClient->get_SecuredSettings2(ppSecuredSettings);
+ dbgprintf(TEXT("IMsRdpClient::get_SecuredSettings2 -> %08X, pSecuredSettings = %p"), hr, *ppSecuredSettings);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_ExtendedDisconnectReason(ExtendedDisconnectReasonCode * pExtendedDisconnectReason)
+ {
+ IMsRdpClient * pIMsRdpClient = getIMsRdpClient();
+ dbgprintf(TEXT("IMsRdpClient::get_ExtendedDisconnectReason(%p)"), pExtendedDisconnectReason);
+ HRESULT hr = pIMsRdpClient->get_ExtendedDisconnectReason(pExtendedDisconnectReason);
+ dbgprintf(TEXT("IMsRdpClient::get_ExtendedDisconnectReason -> %08X, ExtendedDisconnectReason = %u"), hr, *pExtendedDisconnectReason);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall put_FullScreen(VARIANT_BOOL pfFullScreen)
+ {
+ IMsRdpClient * pIMsRdpClient = getIMsRdpClient();
+ dbgprintf(TEXT("IMsRdpClient::put_FullScreen(%s)"), BooleanToString(pfFullScreen));
+ HRESULT hr = pIMsRdpClient->put_FullScreen(pfFullScreen);
+ dbgprintf(TEXT("IMsRdpClient::put_FullScreen -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_FullScreen(VARIANT_BOOL * pfFullScreen)
+ {
+ IMsRdpClient * pIMsRdpClient = getIMsRdpClient();
+ dbgprintf(TEXT("IMsRdpClient::get_FullScreen(%p)"), pfFullScreen);
+ HRESULT hr = pIMsRdpClient->get_FullScreen(pfFullScreen);
+ dbgprintf(TEXT("IMsRdpClient::get_FullScreen -> %08X, pfFullScreen = %s"), hr, BooleanToString(*pfFullScreen));
+ return hr;
+ }
+
+ virtual HRESULT __stdcall SetVirtualChannelOptions(BSTR chanName, long chanOptions)
+ {
+ IMsRdpClient * pIMsRdpClient = getIMsRdpClient();
+ dbgprintf(TEXT("IMsRdpClient::SetVirtualChannelOptions(%ls, %08X)"), chanName, chanOptions);
+ HRESULT hr = pIMsRdpClient->SetVirtualChannelOptions(chanName, chanOptions);
+ dbgprintf(TEXT("IMsRdpClient::SetVirtualChannelOptions -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall GetVirtualChannelOptions(BSTR chanName, long * pChanOptions)
+ {
+ IMsRdpClient * pIMsRdpClient = getIMsRdpClient();
+ dbgprintf(TEXT("IMsRdpClient::GetVirtualChannelOptions(%ls, %p)"), chanName, pChanOptions);
+ HRESULT hr = pIMsRdpClient->GetVirtualChannelOptions(chanName, pChanOptions);
+ dbgprintf(TEXT("IMsRdpClient::GetVirtualChannelOptions -> %08X, ChanOptions = %08X"), hr, *pChanOptions);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall RequestClose(ControlCloseStatus * pCloseStatus)
+ {
+ IMsRdpClient * pIMsRdpClient = getIMsRdpClient();
+ dbgprintf(TEXT("IMsRdpClient::RequestClose(%p)"), pCloseStatus);
+ HRESULT hr = pIMsRdpClient->RequestClose(pCloseStatus);
+ dbgprintf(TEXT("IMsRdpClient::RequestClose -> %08X, CloseStatus = %ld"), hr, *pCloseStatus);
+ return hr;
+ }
+
+ /* IMsRdpClient2 */
+ public:
+ virtual HRESULT __stdcall get_AdvancedSettings3(IMsRdpClientAdvancedSettings2 ** ppAdvSettings)
+ {
+ IMsRdpClient2 * pIMsRdpClient2 = getIMsRdpClient2();
+ 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;
+ }
+
+ virtual HRESULT __stdcall put_ConnectedStatusText(BSTR pConnectedStatusText)
+ {
+ IMsRdpClient2 * pIMsRdpClient2 = getIMsRdpClient2();
+ dbgprintf(TEXT("IMsRdpClient2::put_ConnectedStatusText(%ls)"), pConnectedStatusText);
+ HRESULT hr = pIMsRdpClient2->put_ConnectedStatusText(pConnectedStatusText);
+ dbgprintf(TEXT("IMsRdpClient2::put_ConnectedStatusText -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_ConnectedStatusText(BSTR * pConnectedStatusText)
+ {
+ IMsRdpClient2 * pIMsRdpClient2 = getIMsRdpClient2();
+ dbgprintf(TEXT("IMsRdpClient2::get_ConnectedStatusText(%p)"), pConnectedStatusText);
+ HRESULT hr = pIMsRdpClient2->get_ConnectedStatusText(pConnectedStatusText);
+ dbgprintf(TEXT("IMsRdpClient2::get_ConnectedStatusText -> %08X, ConnectedStatusText = %ls"), hr, *pConnectedStatusText);
+ return hr;
+ }
+
+ /* IMsRdpClient3 */
+ public:
+ virtual HRESULT __stdcall get_AdvancedSettings4(IMsRdpClientAdvancedSettings3 ** ppAdvSettings)
+ {
+ IMsRdpClient3 * pIMsRdpClient3 = getIMsRdpClient3();
+ 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;
+ }
+
+ /* IMsRdpClient4 */
+ public:
+ virtual HRESULT __stdcall get_AdvancedSettings5(IMsRdpClientAdvancedSettings4 ** ppAdvSettings5)
+ {
+ IMsRdpClient4 * pIMsRdpClient4 = getIMsRdpClient4();
+ 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;
+ }
+
+ /* IMsTscNonScriptable */
+ public:
+ virtual HRESULT __stdcall put_ClearTextPassword(BSTR _arg1)
+ {
+ IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable();
+ dbgprintf(TEXT("IMsTscNonScriptable::put_ClearTextPassword(%ls)"), _arg1);
+ HRESULT hr = pIMsTscNonScriptable->put_ClearTextPassword(_arg1);
+ dbgprintf(TEXT("IMsTscNonScriptable::put_ClearTextPassword -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall put_PortablePassword(BSTR pPortablePass)
+ {
+ IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable();
+ dbgprintf(TEXT("IMsTscNonScriptable::put_PortablePassword(%ls)"), pPortablePass);
+ HRESULT hr = pIMsTscNonScriptable->put_PortablePassword(pPortablePass);
+ dbgprintf(TEXT("IMsTscNonScriptable::put_PortablePassword -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_PortablePassword(BSTR * pPortablePass)
+ {
+ IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable();
+ dbgprintf(TEXT("IMsTscNonScriptable::get_PortablePassword(%p)"), pPortablePass);
+ HRESULT hr = pIMsTscNonScriptable->get_PortablePassword(pPortablePass);
+ dbgprintf(TEXT("IMsTscNonScriptable::get_PortablePassword -> %08X, PortablePass = %ls"), hr, *pPortablePass);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall put_PortableSalt(BSTR pPortableSalt)
+ {
+ IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable();
+ dbgprintf(TEXT("IMsTscNonScriptable::put_PortableSalt(%ls)"), pPortableSalt);
+ HRESULT hr = pIMsTscNonScriptable->put_PortableSalt(pPortableSalt);
+ dbgprintf(TEXT("IMsTscNonScriptable::put_PortableSalt -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_PortableSalt(BSTR * pPortableSalt)
+ {
+ IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable();
+ dbgprintf(TEXT("IMsTscNonScriptable::get_PortableSalt()"), pPortableSalt);
+ HRESULT hr = pIMsTscNonScriptable->get_PortableSalt(pPortableSalt);
+ dbgprintf(TEXT("IMsTscNonScriptable::get_PortableSalt -> %08X, PortableSalt = %ls"), hr, *pPortableSalt);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall put_BinaryPassword(BSTR pBinaryPassword)
+ {
+ IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable();
+ dbgprintf(TEXT("IMsTscNonScriptable::put_BinaryPassword(%p)"), pBinaryPassword);
+ HRESULT hr = pIMsTscNonScriptable->put_BinaryPassword(pBinaryPassword);
+ dbgprintf(TEXT("IMsTscNonScriptable::put_BinaryPassword -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_BinaryPassword(BSTR * pBinaryPassword)
+ {
+ IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable();
+ dbgprintf(TEXT("IMsTscNonScriptable::get_BinaryPassword()"), pBinaryPassword);
+ HRESULT hr = pIMsTscNonScriptable->get_BinaryPassword(pBinaryPassword);
+ dbgprintf(TEXT("IMsTscNonScriptable::get_BinaryPassword -> %08X, BinaryPassword = %ls"), hr, *pBinaryPassword);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall put_BinarySalt(BSTR pSalt)
+ {
+ IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable();
+ dbgprintf(TEXT("IMsTscNonScriptable::put_BinarySalt(%p)"), pSalt);
+ HRESULT hr = pIMsTscNonScriptable->put_BinarySalt(pSalt);
+ dbgprintf(TEXT("IMsTscNonScriptable::put_BinarySalt -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall get_BinarySalt(BSTR * pSalt)
+ {
+ IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable();
+ dbgprintf(TEXT("IMsTscNonScriptable::get_BinarySalt()"), pSalt);
+ HRESULT hr = pIMsTscNonScriptable->get_BinarySalt(pSalt);
+ dbgprintf(TEXT("IMsTscNonScriptable::get_BinarySalt -> %08X, pSalt = %ls"), hr, *pSalt);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall ResetPassword()
+ {
+ IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable();
+ dbgprintf(TEXT("IMsTscNonScriptable::ResetPassword()"));
+ HRESULT hr = pIMsTscNonScriptable->ResetPassword();
+ dbgprintf(TEXT("IMsTscNonScriptable::ResetPassword -> %08X"), hr);
+ return hr;
+ }
+
+
+ /* IMsRdpClientNonScriptable */
+ public:
+ 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->NotifyRedirectDeviceChange(wParam, lParam);
+ dbgprintf(TEXT("IMsRdpClientNonScriptable::NotifyRedirectDeviceChange -> %08X"), hr);
+ return hr;
+ }
+
+ 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->SendKeys(numKeys, pbArrayKeyUp, plKeyData);
+ dbgprintf(TEXT("IMsRdpClientNonScriptable::SendKeys -> %08X"), hr);
+ return hr;
+ }
+
+ /* IMsRdpClientNonScriptable2 */
+ public:
+ virtual HRESULT __stdcall IMsRdpClientNonScriptable2::put_UIParentWindowHandle(wireHWND phwndUIParentWindowHandle)
+ {
+ IMsRdpClientNonScriptable2 * pIMsRdpClientNonScriptable2 = getIMsRdpClientNonScriptable2();
+ dbgprintf(TEXT("IMsRdpClientNonScriptable2::put_UIParentWindowHandle(%p)"), phwndUIParentWindowHandle);
+ HRESULT hr = pIMsRdpClientNonScriptable2->put_UIParentWindowHandle(phwndUIParentWindowHandle);
+ dbgprintf(TEXT("IMsRdpClientNonScriptable2::put_UIParentWindowHandle -> %08X"), hr);
+ return hr;
+ }
+
+ virtual HRESULT __stdcall IMsRdpClientNonScriptable2::get_UIParentWindowHandle(wireHWND * phwndUIParentWindowHandle)
+ {
+ IMsRdpClientNonScriptable2 * pIMsRdpClientNonScriptable2 = getIMsRdpClientNonScriptable2();
+ dbgprintf(TEXT("IMsRdpClientNonScriptable2::get_UIParentWindowHandle(%p)"), phwndUIParentWindowHandle);
+ HRESULT hr = pIMsRdpClientNonScriptable2->get_UIParentWindowHandle(phwndUIParentWindowHandle);
+ dbgprintf(TEXT("IMsRdpClientNonScriptable2::get_UIParentWindowHandle -> %08X, hwndUIParentWindowHandle = %p"), hr, *phwndUIParentWindowHandle);
+ return hr;
+ }
+
+ /*
+ {
+ * p = m_;
+ dbgprintf(TEXT("::()"), );
+ HRESULT hr = p->();
+ dbgprintf(TEXT(":: -> %08X, "), hr, );
+ return hr;
+ }
+ */
+ };
+
+ class ClassFactory: public IClassFactory2
+ {
+ private:
+ LONG m_refCount;
+ IUnknown * m_IUnknown;
+ IClassFactory * m_IClassFactory;
+ IClassFactory2 * m_IClassFactory2;
+
+ IClassFactory * getIClassFactory()
+ {
+ if(m_IClassFactory)
+ return m_IClassFactory;
+
+ if(m_IClassFactory2)
+ m_IClassFactory = m_IClassFactory2;
+
+ if(m_IClassFactory)
+ {
+ m_IClassFactory->AddRef();
+ return m_IClassFactory;
+ }
+
+ m_IUnknown->QueryInterface(&m_IClassFactory);
+ return m_IClassFactory;
+ }
+
+ IClassFactory2 * getIClassFactory2()
+ {
+ if(m_IClassFactory2)
+ return m_IClassFactory2;
+
+ m_IUnknown->QueryInterface(&m_IClassFactory2);
+ return m_IClassFactory2;
+ }
+
+ public:
+ ClassFactory(IUnknown * pUnknwn):
+ m_refCount(1),
+ m_IUnknown(pUnknwn),
+ m_IClassFactory(NULL),
+ m_IClassFactory2(NULL)
+ {
+ m_IUnknown->AddRef();
+ }
+
+ ~ClassFactory()
+ {
+ if(m_IUnknown)
+ m_IUnknown->Release();
+
+ if(m_IClassFactory)
+ m_IClassFactory->Release();
+
+ if(m_IClassFactory2)
+ m_IClassFactory2->Release();
+ }
+
+ /* IUnknown */
+ 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()
+ QI(IClassFactory)
+ QI(IClassFactory2)
+ 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;
+ }
+
+ 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;
+ }
+
+ /* IClassFactory */
+ public:
+ virtual HRESULT STDMETHODCALLTYPE CreateInstance(IUnknown * pUnkOuter, REFIID riid, void ** ppvObject)
+ {
+ IClassFactory * pIClassFactory = getIClassFactory();
+ dbgprintf(TEXT("IClassFactory::CreateInstance(%p, %ls, %p)"), pUnkOuter, UUIDToString(riid).c_str(), ppvObject);
+ HRESULT hr = pIClassFactory->CreateInstance(NULL, riid, ppvObject);
+ dbgprintf(TEXT("IClassFactory::CreateInstance -> %08X, pvObject = %p"), hr, *ppvObject);
+ return CoClass::CreateInstance((IUnknown *)*ppvObject, pUnkOuter, riid, ppvObject);
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE LockServer(BOOL fLock)
+ {
+ IClassFactory * pIClassFactory = getIClassFactory();
+ dbgprintf(TEXT("IClassFactory::LockServer(%s)"), BooleanToString(fLock));
+ HRESULT hr = pIClassFactory->LockServer(fLock);
+ dbgprintf(TEXT("IClassFactory::LockServer -> %08X"), hr);
+ return hr;
+ }
+
+ /* IClassFactory2 */
+ public:
+ virtual HRESULT STDMETHODCALLTYPE GetLicInfo(LICINFO * pLicInfo)
+ {
+ IClassFactory2 * pIClassFactory2 = getIClassFactory2();
+ dbgprintf(TEXT("IClassFactory2::GetLicInfo(%p)"), pLicInfo);
+ HRESULT hr = pIClassFactory2->GetLicInfo(pLicInfo);
+ dbgprintf(TEXT("IClassFactory2::GetLicInfo -> %08X, LicInfo = %p"), hr, pLicInfo);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE RequestLicKey(DWORD dwReserved, BSTR * pBstrKey)
+ {
+ IClassFactory2 * pIClassFactory2 = getIClassFactory2();
+ dbgprintf(TEXT("IClassFactory2::RequestLicKey(%lu, %p)"), dwReserved, pBstrKey);
+ HRESULT hr = pIClassFactory2->RequestLicKey(dwReserved, pBstrKey);
+ dbgprintf(TEXT("IClassFactory2::RequestLicKey -> %08X, bstrKey = %ls"), hr, *pBstrKey);
+ return hr;
+ }
+
+ virtual HRESULT STDMETHODCALLTYPE CreateInstanceLic(IUnknown * pUnkOuter, IUnknown * pUnkReserved, REFIID riid, BSTR bstrKey, PVOID * ppvObj)
+ {
+ IClassFactory2 * pIClassFactory2 = getIClassFactory2();
+ dbgprintf(TEXT("IClassFactory2::CreateInstanceLic(%p, %p, %ls, %ls, %p)"), pUnkOuter, pUnkReserved, UUIDToString(riid).c_str(), bstrKey, ppvObj);
+ HRESULT hr = pIClassFactory2->CreateInstanceLic(NULL, pUnkReserved, riid, bstrKey, ppvObj);
+ dbgprintf(TEXT("IClassFactory2::CreateInstanceLic -> %08X, pvObj = %p"), hr, *ppvObj);
+ return CoClass::CreateInstance((IUnknown *)*ppvObj, pUnkOuter, riid, ppvObj);
+ }
+ };
+
+ STDAPI DllGetClassObject(IN REFCLSID rclsid, IN REFIID riid, OUT LPVOID * ppv)
+ {
+ init();
+
+ dbgprintf(TEXT("DllGetClassObject(%ls, %ls, %p)"), UUIDToString(rclsid).c_str(), UUIDToString(riid).c_str(), ppv);
+ HRESULT hr = pfnDllGetClassObject(rclsid, IID_IUnknown, ppv);
+ dbgprintf(TEXT("DllGetClassObject -> %08X, pv = %p"), hr, *ppv);
+
+ IUnknown * pv = NULL;
+
+ if(SUCCEEDED(hr))
+ {
+ IUnknown * punk = (IUnknown *)*ppv;
+
+ if(rclsid == CLSID_MsTscAx || rclsid == CLSID_MsRdpClient || rclsid == CLSID_MsRdpClient2 || rclsid == CLSID_MsRdpClient3 || rclsid == CLSID_MsRdpClient4)
+ pv = new ClassFactory(punk);
+ else
+ hr = CLASS_E_CLASSNOTAVAILABLE;
+
+ punk->Release();
+ }
+
+ if(pv)
+ {
+ hr = pv->QueryInterface(riid, ppv);
+
+ if(FAILED(hr))
+ pv->Release();
+ }
+
+ return hr;
+ }
+
+ STDAPI DllCanUnloadNow(void)
+ {
+ init();
+
+ dbgprintf(TEXT("DllCanUnloadNow()"));
+ HRESULT hr = pfnDllCanUnloadNow();
+ dbgprintf(TEXT("DllCanUnloadNow -> %08X"), hr);
+
+ return hr;
+ }
+
+ STDAPI_(ULONG) DllGetTscCtlVer(void)
+ {
+ init();
+
+ dbgprintf(TEXT("DllGetTscCtlVer()"));
+ ULONG ul = pfnDllGetTscCtlVer();
+ dbgprintf(TEXT("DllGetTscCtlVer-> %08X"), ul);
+
+ return ul;
+ }
+}
+
+// EOF
diff --git a/rosapps/applications/net/tsclient/porting-tools/mstscax/mstscax.def b/rosapps/applications/net/tsclient/porting-tools/mstscax/mstscax.def
new file mode 100644
index 00000000000..5da85892a99
--- /dev/null
+++ b/rosapps/applications/net/tsclient/porting-tools/mstscax/mstscax.def
@@ -0,0 +1,14 @@
+LIBRARY mstscax.dll
+
+EXPORTS
+ ; OLE inproc server
+ DllGetClassObject PRIVATE
+ DllCanUnloadNow PRIVATE
+
+ ; OLE self-registration
+ ; TODO
+
+ ; Private APIs
+ DllGetTscCtlVer
+
+; EOF
diff --git a/rosapps/applications/net/tsclient/porting-tools/mstscax/mstscax.sln b/rosapps/applications/net/tsclient/porting-tools/mstscax/mstscax.sln
new file mode 100644
index 00000000000..2abaf3db1b1
--- /dev/null
+++ b/rosapps/applications/net/tsclient/porting-tools/mstscax/mstscax.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 9.00
+# Visual C++ Express 2005
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mstscax", "mstscax.vcproj", "{933B2293-F12F-4B01-98B4-BF635B8B4F36}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Win32 = Debug|Win32
+ Release|Win32 = Release|Win32
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {933B2293-F12F-4B01-98B4-BF635B8B4F36}.Debug|Win32.ActiveCfg = Debug|Win32
+ {933B2293-F12F-4B01-98B4-BF635B8B4F36}.Debug|Win32.Build.0 = Debug|Win32
+ {933B2293-F12F-4B01-98B4-BF635B8B4F36}.Release|Win32.ActiveCfg = Release|Win32
+ {933B2293-F12F-4B01-98B4-BF635B8B4F36}.Release|Win32.Build.0 = Release|Win32
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
diff --git a/rosapps/applications/net/tsclient/porting-tools/mstscax/mstscax.vcproj b/rosapps/applications/net/tsclient/porting-tools/mstscax/mstscax.vcproj
new file mode 100644
index 00000000000..7e3def8edf7
--- /dev/null
+++ b/rosapps/applications/net/tsclient/porting-tools/mstscax/mstscax.vcproj
@@ -0,0 +1,229 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/rosapps/applications/net/tsclient/porting-tools/mstscax/stdafx.cpp b/rosapps/applications/net/tsclient/porting-tools/mstscax/stdafx.cpp
new file mode 100644
index 00000000000..fd4f341c7b2
--- /dev/null
+++ b/rosapps/applications/net/tsclient/porting-tools/mstscax/stdafx.cpp
@@ -0,0 +1 @@
+#include "stdafx.h"
diff --git a/rosapps/applications/net/tsclient/porting-tools/mstscax/stdafx.h b/rosapps/applications/net/tsclient/porting-tools/mstscax/stdafx.h
new file mode 100644
index 00000000000..9c317402891
--- /dev/null
+++ b/rosapps/applications/net/tsclient/porting-tools/mstscax/stdafx.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include
+#include
+#include
+
+#include
+#include
+#include
+#include
+
+#define WIN32_LEAN_AND_MEAN
+#define STRICT
+#define NOMINMAX
+
+#include
+#include
+#include
+
+#include
+
+#include
+
+#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/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/activex.cpp b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/activex.cpp
new file mode 100644
index 00000000000..80a03b6a379
--- /dev/null
+++ b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/activex.cpp
@@ -0,0 +1,6095 @@
+#include "stdafx.h"
+
+namespace MSTSCLib
+{
+#include "mstsclib_h.h"
+};
+
+namespace MSTSCLib_Redist
+{
+// extremely ew, but actually the cleanest way to import the alternate UUIDs
+#include "mstsclib_redist_i.c"
+};
+
+#include "rdesktop/rdesktop.h"
+#include "rdesktop/proto.h"
+
+namespace
+{
+#ifdef _MSC_VER
+extern "C" char __ImageBase;
+#endif
+
+HMODULE GetCurrentModule()
+{
+ return reinterpret_cast(&__ImageBase);
+}
+
+}
+
+namespace
+{
+
+LONG g_moduleRefCount = 0;
+
+void lockServer()
+{
+ InterlockedIncrement(&g_moduleRefCount);
+}
+
+void unlockServer()
+{
+ InterlockedDecrement(&g_moduleRefCount);
+}
+
+bool canUnloadServer()
+{
+ return g_moduleRefCount == 0;
+}
+
+}
+
+namespace
+{
+
+void FreeLpsz(LPSTR lpsz)
+{
+ if(lpsz)
+ delete[] lpsz;
+}
+
+LPSTR AllocLpsz(const CHAR * lpsz, size_t cb)
+{
+ LPSTR lpszNew = new CHAR[cb + 1];
+
+ if(lpszNew == NULL)
+ return NULL;
+
+ CopyMemory(lpszNew, lpsz, cb);
+ lpszNew[cb] = 0;
+
+ return lpszNew;
+}
+
+LPSTR AllocLpsz(const WCHAR * lpwsz, int cchIn)
+{
+ int cch = WideCharToMultiByte(CP_ACP, 0, lpwsz, cchIn, NULL, 0, NULL, NULL);
+
+ if(cch <= 0)
+ return NULL;
+
+ LPSTR lpsz = new CHAR[cch];
+
+ if(lpsz == NULL)
+ return NULL;
+
+ cch = WideCharToMultiByte(CP_ACP, 0, lpwsz, cchIn, lpsz, cch, NULL, NULL);
+
+ if(cch <= 0)
+ {
+ FreeLpsz(lpsz);
+ return NULL;
+ }
+
+ return lpsz;
+}
+
+LPSTR BstrToLpsz(BSTR bstr)
+{
+ return AllocLpsz(bstr, SysStringLen(bstr));
+}
+
+BSTR LpszToBstr(LPSTR lpsz)
+{
+ int cch = MultiByteToWideChar(CP_ACP, 0, lpsz, -1, NULL, 0);
+
+ if(cch <= 0)
+ return NULL;
+
+ BSTR bstr = SysAllocStringLen(NULL, cch);
+
+ if(bstr == NULL)
+ return NULL;
+
+ cch = MultiByteToWideChar(CP_ACP, 0, lpsz, -1, bstr, cch);
+
+ if(cch <= 0)
+ {
+ SysFreeString(bstr);
+ return NULL;
+ }
+
+ return bstr;
+}
+
+}
+
+namespace
+{
+
+template T aligndown(const T& X, const U& align)
+{
+ return X & ~(T(align) - 1);
+}
+
+template T alignup(const T& X, const U& align)
+{
+ return aligndown(X + (align - 1), align);
+}
+
+/* Convert between bitmap formats */
+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);
+ assert(fromalign <= toalign);
+ assert(data);
+ assert(buffer);
+
+ bool flipped = height < 0;
+
+ if(flipped)
+ height = - height;
+
+ int bytesperrow = alignup(width * bitcount, 8) / 8;
+ int fromstride = alignup(bytesperrow, fromalign);
+ int tostride = alignup(bytesperrow, toalign);
+ assert(fromstride <= tostride);
+
+ int datasize = tostride * height;
+
+ uint8 * dibits = new uint8[datasize];
+
+ const uint8 * src = data;
+ uint8 * dest = dibits;
+
+ const int pad = tostride - fromstride;
+
+ assert(pad < 4);
+ __assume(pad < 4);
+
+ if(flipped)
+ {
+ dest += (height - 1) * tostride;
+ tostride = - tostride;
+ }
+
+ for(int i = 0; i < height; ++ i)
+ {
+ memcpy(dest, src, fromstride);
+ memset(dest + fromstride, 0, pad);
+ src += fromstride;
+ dest += tostride;
+ }
+
+ *buffer = dibits;
+ return dibits;
+}
+
+/* Creates bitmaps */
+HBITMAP win32_create_dib(LONG width, LONG height, WORD bitcount, const BYTE * data)
+{
+ struct b_
+ {
+ BITMAPINFO bmi;
+ RGBQUAD colormap[256 - ARRAYSIZE(RTL_FIELD_TYPE(BITMAPINFO, bmiColors))];
+ }
+ b;
+
+ b.bmi.bmiHeader.biSize = sizeof(b.bmi.bmiHeader);
+ b.bmi.bmiHeader.biWidth = width;
+ b.bmi.bmiHeader.biHeight = height;
+ b.bmi.bmiHeader.biPlanes = 1;
+ b.bmi.bmiHeader.biBitCount = bitcount;
+ b.bmi.bmiHeader.biCompression = BI_RGB;
+ b.bmi.bmiHeader.biSizeImage = 0;
+ b.bmi.bmiHeader.biXPelsPerMeter = 0;
+ b.bmi.bmiHeader.biYPelsPerMeter = 0;
+
+ if(bitcount > 8)
+ {
+ b.bmi.bmiHeader.biClrUsed = 0;
+ b.bmi.bmiHeader.biClrImportant = 0;
+ }
+ else
+ {
+ b.bmi.bmiHeader.biClrUsed = 2 << bitcount;
+ b.bmi.bmiHeader.biClrImportant = 2 << bitcount;
+
+ // TODO: palette
+ }
+
+ // FIXME: beyond ugly
+ HDC hdc = CreateCompatibleDC(NULL);
+
+ if(hdc == NULL)
+ return NULL;
+
+ HBITMAP hbm = CreateDIBitmap(hdc, &b.bmi.bmiHeader, CBM_INIT, data, &b.bmi, DIB_RGB_COLORS);
+
+ if(hbm == NULL)
+ error("CreateDIBitmap %dx%dx%d failed\n", width, height, bitcount);
+
+ DeleteDC(hdc);
+ return hbm;
+}
+
+/* Creates brushes */
+HBRUSH win32_create_brush(BRUSH * brush, COLORREF fgcolour)
+{
+ if(brush == NULL)
+ return (HBRUSH)GetStockObject(NULL_BRUSH);
+
+ switch(brush->style)
+ {
+ case BS_SOLID:
+ case BS_NULL:
+ case BS_HATCHED:
+ case BS_PATTERN:
+ case BS_PATTERN8X8:
+ break;
+
+ default:
+ return NULL;
+ }
+
+ switch(brush->style)
+ {
+ case BS_SOLID:
+ return CreateSolidBrush(fgcolour);
+
+ case BS_HATCHED:
+ return CreateHatchBrush(brush->pattern[0], fgcolour);
+
+ case BS_NULL:
+ return (HBRUSH)GetStockObject(NULL_BRUSH);
+
+ case BS_PATTERN:
+ case BS_PATTERN8X8:
+ {
+ uint16 pattern[8];
+
+ for(size_t i = 0; i < 8; ++ i)
+ pattern[i] = brush->pattern[i];
+
+ HBITMAP hpattern = CreateBitmap(8, 8, 1, 1, pattern);
+ HBRUSH hbr = CreatePatternBrush(hpattern);
+ DeleteObject(hpattern);
+ return hbr;
+ }
+
+ DEFAULT_UNREACHABLE;
+ }
+}
+};
+
+/*
+ "sealed" can improve optimizations by asserting a class cannot be derived
+ from, optimizing out accesses to the v-table from inside the class
+*/
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+#define SEALED_ sealed
+#else
+#define SEALED_
+#endif
+
+
+/* Class that implements the RDP client GUI */
+class RdpClientUI
+{
+public:
+ // TODO: pass the client settings relevant to the GUI here
+ HRESULT Initialize(HWND hwndParent)
+ {
+ // TODO: create the various windows
+ // TODO: create display window thread
+ // TODO: create input thread
+ return E_FAIL;
+ }
+
+public:
+ static BOOL Startup()
+ {
+ WNDCLASSEX wcexUI = { sizeof(wcexUI) };
+ WNDCLASSEX wcexConsole = { sizeof(wcexConsole) };
+ WNDCLASSEX wcexDisplay = { sizeof(wcexDisplay) };
+ WNDCLASSEX wcexInput = { sizeof(wcexInput) };
+
+ HBRUSH nullBrush = (HBRUSH)GetStockObject(HOLLOW_BRUSH);
+
+ wcexUI.lpfnWndProc = NULL; // TODO
+ wcexUI.hInstance = GetCurrentModule();
+ wcexUI.hCursor = LoadCursor(NULL, IDC_ARROW);
+ wcexUI.hbrBackground = nullBrush;
+ wcexUI.lpszClassName = TEXT("MissTosca_UI");
+
+ wcexConsole.style = CS_VREDRAW | CS_HREDRAW;
+ wcexConsole.lpfnWndProc = NULL; // TODO
+ wcexConsole.hInstance = GetCurrentModule();
+ wcexConsole.hCursor = LoadCursor(NULL, IDC_ARROW);
+ wcexConsole.hbrBackground = nullBrush;
+ wcexConsole.lpszClassName = TEXT("MissTosca_Console");
+
+ wcexDisplay.style = CS_VREDRAW | CS_HREDRAW;
+ wcexDisplay.lpfnWndProc = NULL; // TODO
+ wcexDisplay.hInstance = GetCurrentModule();
+ wcexDisplay.hCursor = LoadCursor(NULL, IDC_ARROW);
+ wcexDisplay.hbrBackground = nullBrush;
+ wcexDisplay.lpszClassName = TEXT("MissTosca_Display");
+
+ wcexInput.style = CS_VREDRAW | CS_HREDRAW;
+ wcexInput.lpfnWndProc = NULL; // TODO
+ wcexInput.hInstance = GetCurrentModule();
+ wcexInput.hCursor = NULL;
+ wcexInput.hbrBackground = nullBrush;
+ wcexInput.lpszClassName = TEXT("MissTosca_Input");
+
+ return
+ RegisterClassEx(&wcexUI) &&
+ RegisterClassEx(&wcexConsole) &&
+ RegisterClassEx(&wcexDisplay) &&
+ RegisterClassEx(&wcexInput);
+ }
+
+ static void Shutdown()
+ {
+ // TODO
+ }
+
+ /*
+ This is the main UI window. It's the direct child of the control
+ window, it fills its whole extent and it contains the scrollbars.
+ When activated, it will move keyboard focus to the input window
+ */
+private:
+ HWND m_uiWindow;
+ LONG m_scrollHPos;
+ LONG m_scrollVPos;
+
+ LRESULT UIWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
+ {
+ switch(uMsg)
+ {
+ // Keep the keyboard focus on the input window
+ case WM_ACTIVATE:
+ switch(LOWORD(wParam))
+ {
+ case WA_INACTIVE:
+ break;
+
+ case WA_ACTIVE:
+ case WA_CLICKACTIVE:
+ if(!HIWORD(wParam))
+ SetFocus(m_inputWindow);
+ }
+
+ return 0;
+
+ // Resized: rearrange children windows, adjust scrollbars
+ case WM_SIZE:
+ {
+ if(IsIconic(m_uiWindow))
+ break;
+
+ RECT rcClient;
+ GetWindowRect(m_uiWindow, &rcClient);
+
+ if(m_smartSizing)
+ {
+ // we are not supposed to maintain aspect ratio. Container has to do that
+ m_consoleX = 0;
+ m_consoleY = 0;
+ m_consoleWidth = rcClient.right;
+ m_consoleHeight = rcClient.bottom;
+ }
+ else
+ {
+ // center horizontally, no horizontal scrollbar
+ if(rcClient.right >= m_consoleWidth)
+ m_consoleX = (m_consoleWidth - rcClient.right) / 2;
+
+ // center vertically, no vertical scrollbar
+ if(rcClient.bottom >= m_consoleHeight)
+ m_consoleY = (m_consoleHeight - rcClient.right) / 2;
+ }
+
+ SCROLLINFO scroll = { sizeof(scroll), SIF_ALL, 0 };
+
+ // update the horizontal scrollbar
+ scroll.nMax = m_consoleWidth;
+ scroll.nPage = rcClient.right;
+ scroll.nPos = 0 - m_consoleX;
+ SetScrollInfo(m_uiWindow, SB_HORZ, &scroll, TRUE);
+
+ // update the vertical scrollbar
+ scroll.nMax = m_consoleHeight;
+ scroll.nPage = rcClient.bottom;
+ scroll.nPos = 0 - m_consoleY;
+ SetScrollInfo(m_uiWindow, SB_VERT, &scroll, TRUE);
+
+ // move/resize the console window
+ MoveWindow(m_consoleWindow, m_consoleX, m_consoleY, m_consoleWidth, m_consoleHeight, TRUE);
+ }
+
+ return 0;
+
+ case WM_HSCROLL:
+ {
+ SCROLLINFO scroll = { sizeof(scroll), SIF_TRACKPOS };
+ GetScrollInfo(m_uiWindow, SB_HORZ, &scroll);
+ m_consoleX = - scroll.nTrackPos;
+ MoveWindow(m_consoleWindow, m_consoleX, m_consoleY, m_consoleWidth, m_consoleHeight, TRUE);
+ }
+
+ return 0;
+
+ case WM_VSCROLL:
+ {
+ SCROLLINFO scroll = { sizeof(scroll), SIF_TRACKPOS };
+ GetScrollInfo(m_uiWindow, SB_VERT, &scroll);
+ m_consoleY = - scroll.nTrackPos;
+ MoveWindow(m_consoleWindow, m_consoleX, m_consoleY, m_consoleWidth, m_consoleHeight, TRUE);
+ }
+
+ return 0;
+
+ default:
+ break;
+ }
+
+ return DefWindowProc(m_uiWindow, uMsg, wParam, lParam);
+ }
+
+ /*
+ This is the full-screen title bar. It's displayed at the top of the
+ main UI window while in full-screen mode, and it contains two toolbars
+ with the pin, minimize, restore and close buttons
+ */
+ HWND m_fullScreenBarWindow;
+
+ /*
+ This is the console window. It has the same extent as the display on
+ the remote computer, or it fills the UI window in smart resizing mode,
+ and it contains the input and display windows
+ */
+private:
+ HWND m_consoleWindow;
+ LONG m_consoleX;
+ LONG m_consoleY;
+ LONG m_consoleWidth;
+ LONG m_consoleHeight;
+ bool m_smartSizing;
+
+ LRESULT ConsoleWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
+ {
+ switch(uMsg)
+ {
+ case WM_SIZE:
+ {
+ RECT rcClient;
+ GetClientRect(m_consoleWindow, &rcClient);
+
+ MoveWindow(m_inputWindow, 0, 0, rcClient.right, rcClient.bottom, TRUE);
+ MoveWindow(m_displayWindow, 0, 0, rcClient.right, rcClient.bottom, TRUE);
+ }
+
+ return 0;
+
+ default:
+ break;
+ }
+
+ return DefWindowProc(m_consoleWindow, uMsg, wParam, lParam);
+ }
+
+ /*
+ This is the display window. It represents the virtual display of the
+ remote computer. It completely fills its parent, the console window,
+ and it runs in its own thread for performance reasons
+ */
+private:
+ HWND m_displayWindow;
+ LONG m_displayBufferWidth;
+ LONG m_displayBufferHeight;
+ HDC m_displayBuffer;
+ void * m_displayBufferRaw;
+ int m_displayBufferSave;
+ int m_displayBufferBitDepth;
+ int m_displayBufferByteDepth;
+ int m_displayBufferStride;
+ RECT m_displayBufferClip;
+ CRITICAL_SECTION m_displayBufferMutex;
+
+ LRESULT DisplayWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
+ {
+ switch(uMsg)
+ {
+ case WM_DESTROY:
+ PostQuitMessage(0);
+ return 0;
+
+ case WM_PRINTCLIENT:
+ if(wParam == 0)
+ break;
+
+ case WM_PAINT:
+ {
+ HDC hdc = (HDC)wParam;
+
+ EnterCriticalSection(&m_displayBufferMutex);
+
+ if(hdc)
+ {
+ RECT rc;
+ GetClientRect(m_displayWindow, &rc);
+ BitBlt(hdc, 0, 0, rc.right, rc.bottom, m_displayBuffer, 0, 0, SRCCOPY);
+ }
+ else
+ {
+ PAINTSTRUCT ps;
+ hdc = BeginPaint(m_displayWindow, &ps);
+
+ if(!m_smartSizing)
+ {
+ BitBlt
+ (
+ hdc,
+ ps.rcPaint.left,
+ ps.rcPaint.top,
+ ps.rcPaint.right - ps.rcPaint.left,
+ ps.rcPaint.bottom - ps.rcPaint.top,
+ m_displayBuffer,
+ ps.rcPaint.left,
+ ps.rcPaint.top,
+ SRCCOPY
+ );
+ }
+ else
+ {
+ // bleh. There has to be a better way
+ SetStretchBltMode(hdc, HALFTONE);
+
+ StretchBlt
+ (
+ hdc,
+ 0,
+ 0,
+ m_consoleWidth,
+ m_consoleHeight,
+ m_displayBuffer,
+ 0,
+ 0,
+ m_displayBufferWidth,
+ m_displayBufferHeight,
+ SRCCOPY
+ );
+ }
+
+ EndPaint(m_displayWindow, &ps);
+ }
+
+ LeaveCriticalSection(&m_displayBufferMutex);
+ }
+
+ return 0;
+
+ default:
+ break;
+ }
+
+ return DefWindowProc(m_displayWindow, uMsg, wParam, lParam);
+ }
+
+ /* Screen repainting */
+ void Display_RepaintRect(const RECT * lprc)
+ {
+ if(m_smartSizing)
+ return Display_RepaintAll();
+
+ RECT rcDamage;
+ IntersectRect(&rcDamage, lprc, &m_displayBufferClip);
+ InvalidateRect(m_displayWindow, &rcDamage, FALSE);
+ }
+
+ void Display_RepaintArea(int x, int y, int cx, int cy)
+ {
+ if(m_smartSizing)
+ return Display_RepaintAll();
+
+ RECT rcDamage;
+ rcDamage.left = x;
+ rcDamage.top = y;
+ rcDamage.right = x + cx;
+ rcDamage.bottom = y + cy;
+ Display_RepaintRect(&rcDamage);
+ }
+
+ void Display_RepaintPolygon(POINT * point, int npoints, int linewidth)
+ {
+ if(m_smartSizing)
+ return Display_RepaintAll();
+
+ RECT rcDamage;
+
+ rcDamage.left = MAXLONG;
+ rcDamage.top = MAXLONG;
+ rcDamage.right = 0;
+ rcDamage.bottom = 0;
+
+ for(int i = 0; i < npoints; ++ i)
+ {
+ if(point[i].x < rcDamage.left)
+ rcDamage.left = point[i].x;
+
+ if(point[i].y < rcDamage.top)
+ rcDamage.top = point[i].y;
+
+ if(point[i].x > rcDamage.right)
+ rcDamage.right = point[i].x;
+
+ if(point[i].y > rcDamage.bottom)
+ rcDamage.bottom = point[i].y;
+ }
+
+ InflateRect(&rcDamage, linewidth, linewidth);
+ Display_RepaintRect(&rcDamage);
+ }
+
+ void Display_RepaintAll()
+ {
+ InvalidateRgn(m_displayWindow, NULL, FALSE);
+ }
+
+public:
+ void Display_SetClip(int x, int y, int cx, int cy)
+ {
+ m_displayBufferClip.left = x;
+ m_displayBufferClip.top = y;
+ m_displayBufferClip.right = x + cx + 1;
+ m_displayBufferClip.bottom = y + cy + 1;
+
+ HRGN hrgn = CreateRectRgnIndirect(&m_displayBufferClip);
+ SelectClipRgn(m_displayBuffer, hrgn);
+ DeleteObject(hrgn);
+ }
+
+ void Display_ResetClip()
+ {
+ m_displayBufferClip.left = 0;
+ m_displayBufferClip.top = 0;
+ m_displayBufferClip.right = m_displayBufferWidth;
+ m_displayBufferClip.bottom = m_displayBufferHeight;
+ SelectClipRgn(m_displayBuffer, NULL);
+ }
+
+ void Display_PaintBitmap(int x, int y, int cx, int cy, int width, int height, uint8 * data)
+ {
+ GdiFlush();
+
+ int fromstride = alignup(width * m_displayBufferByteDepth, 4);
+ int sizex = cx * m_displayBufferByteDepth;
+
+ const uint8 * src = data;
+
+ uint8 * dst =
+ (uint8 *)m_displayBufferRaw +
+ (m_displayBufferHeight - y - cy) * m_displayBufferStride +
+ x * m_displayBufferByteDepth;
+
+ for(int i = 0; i < cy; ++ i)
+ {
+ memcpy(dst, src, sizex);
+ src += fromstride;
+ dst += m_displayBufferStride;
+ }
+
+ Display_RepaintArea(x, y, cx, cy);
+ }
+
+ void Display_DestBlt(uint8 opcode, int x, int y, int cx, int cy)
+ {
+ int dcsave = SaveDC(m_displayBuffer);
+ SelectObject(m_displayBuffer, GetStockObject(BLACK_BRUSH));
+ PatBlt(m_displayBuffer, x, y, cx, cy, MAKELONG(0, opcode));
+ RestoreDC(m_displayBuffer, dcsave);
+ Display_RepaintArea(x, y, cx, cy);
+ }
+
+ void Display_PatBlt(uint8 opcode, int x, int y, int cx, int cy, BRUSH * brush, int bgcolour, int fgcolour)
+ {
+ HBRUSH hbr = win32_create_brush(brush, fgcolour);
+
+ int dcsave = SaveDC(m_displayBuffer);
+
+ SetBkColor(m_displayBuffer, bgcolour);
+ SetTextColor(m_displayBuffer, fgcolour);
+ SetBrushOrgEx(m_displayBuffer, brush->xorigin, brush->yorigin, NULL);
+ SelectObject(m_displayBuffer, hbr);
+
+ PatBlt(m_displayBuffer, x, y, cx, cy, MAKELONG(0, opcode));
+
+ RestoreDC(m_displayBuffer, dcsave);
+
+ DeleteObject(hbr);
+
+ Display_RepaintArea(x, y, cx, cy);
+ }
+
+ void Display_ScreenBlt(uint8 opcode, int x, int y, int cx, int cy, int srcx, int srcy)
+ {
+ BitBlt(m_displayBuffer, x, y, cx, cy, m_displayBuffer, srcx, srcy, MAKELONG(0, opcode));
+ Display_RepaintArea(x, y, cx, cy);
+ }
+
+ void Display_MemBlt(uint8 opcode, int x, int y, int cx, int cy, HBITMAP src, int srcx, int srcy)
+ {
+ HDC hdcSrc = CreateCompatibleDC(m_displayBuffer);
+ HGDIOBJ hOld = SelectObject(hdcSrc, src);
+
+ BitBlt(m_displayBuffer, x, y, cx, cy, hdcSrc, srcx, srcy, MAKELONG(0, opcode));
+
+ SelectObject(hdcSrc, hOld);
+ DeleteDC(hdcSrc);
+
+ Display_RepaintArea(x, y, cx, cy);
+ }
+
+ void Display_TriBlt(uint8 opcode, int x, int y, int cx, int cy, HBITMAP src, int srcx, int srcy, BRUSH * brush, int bgcolour, int fgcolour)
+ {
+ // TODO
+ HDC hdcSrc = CreateCompatibleDC(m_displayBuffer);
+ HGDIOBJ hOld = SelectObject(hdcSrc, src);
+
+ //SELECT_BRUSH(brush, bgcolour, fgcolour);
+
+ BitBlt(m_displayBuffer, x, y, cx, cy, hdcSrc, srcx, srcy, MAKELONG(0, opcode));
+
+ //RESET_BRUSH();
+
+ SelectObject(hdcSrc, hOld);
+ DeleteDC(hdcSrc);
+
+ Display_RepaintArea(x, y, cx, cy);
+ }
+
+ void Display_Line(uint8 opcode, int startx, int starty, int endx, int endy, PEN * pen)
+ {
+ HPEN hpen = CreatePen(pen->style, pen->width, pen->colour);
+
+ int dcsave = SaveDC(m_displayBuffer);
+
+ SetROP2(m_displayBuffer, opcode);
+ SelectObject(m_displayBuffer, hpen);
+ MoveToEx(m_displayBuffer, startx, starty, NULL);
+
+ LineTo(m_displayBuffer, endx, endy);
+
+ RestoreDC(m_displayBuffer, dcsave);
+
+ DeleteObject(hpen);
+
+ RECT rcDamage;
+
+ if(startx < endx)
+ {
+ rcDamage.left = startx;
+ rcDamage.right = endx;
+ }
+ else
+ {
+ rcDamage.left = endx;
+ rcDamage.right = startx;
+ }
+
+ if(starty < endy)
+ {
+ rcDamage.top = starty;
+ rcDamage.bottom = endy;
+ }
+ else
+ {
+ rcDamage.top = endy;
+ rcDamage.bottom = starty;
+ }
+
+ InflateRect(&rcDamage, pen->width, pen->width);
+ Display_RepaintRect(&rcDamage);
+ }
+
+ void Display_Rect(int x, int y, int cx, int cy, int colour)
+ {
+ HBRUSH hbr = CreateSolidBrush(colour);
+
+ int dcsave = SaveDC(m_displayBuffer);
+
+ SelectObject(m_displayBuffer, hbr);
+ SelectObject(m_displayBuffer, GetStockObject(NULL_PEN));
+
+ Rectangle(m_displayBuffer, x, y, x + cx + 1, y + cy + 1);
+
+ RestoreDC(m_displayBuffer, dcsave);
+
+ DeleteObject(hbr);
+
+ Display_RepaintArea(x, y, cx, cy);
+ }
+
+ void Display_Polygon(uint8 opcode, uint8 fillmode, POINT * point, int npoints, BRUSH * brush, int bgcolour, int fgcolour)
+ {
+ HBRUSH hbr = win32_create_brush(brush, fgcolour);
+
+ int dcsave = SaveDC(m_displayBuffer);
+
+ SetBkColor(m_displayBuffer, bgcolour);
+ SetTextColor(m_displayBuffer, fgcolour);
+ SetPolyFillMode(m_displayBuffer, fillmode);
+ SelectObject(m_displayBuffer, hbr);
+
+ Polygon(m_displayBuffer, point, npoints);
+
+ RestoreDC(m_displayBuffer, dcsave);
+
+ Display_RepaintPolygon(point, npoints, 0);
+ }
+
+ void Display_Polyline(uint8 opcode, POINT * points, int npoints, PEN * pen)
+ {
+ POINT last = points[0];
+
+ for(int i = 1; i < npoints; ++ i)
+ {
+ points[i].x += last.x;
+ points[i].y += last.y;
+ last = points[i];
+ }
+
+ HPEN hpen = CreatePen(pen->style, pen->width, pen->colour);
+
+ int dcsave = SaveDC(m_displayBuffer);
+
+ SetROP2(m_displayBuffer, opcode);
+ SelectObject(m_displayBuffer, hpen);
+
+ Polyline(m_displayBuffer, points, npoints);
+
+ RestoreDC(m_displayBuffer, dcsave);
+
+ DeleteObject(hpen);
+
+ Display_RepaintPolygon(points, npoints, pen->width);
+ }
+
+ void Display_Ellypse(uint8 opcode, uint8 fillmode, int x, int y, int cx, int cy, BRUSH * brush, int bgcolour, int fgcolour)
+ {
+ // TODO
+
+ Display_RepaintArea(x, y, cx, cy);
+ }
+
+ // TBD: optimize text drawing
+ void Display_DrawGlyph(int mixmode, int x, int y, int cx, int cy, HGLYPH glyph, int srcx, int srcy, int bgcolour, int fgcolour)
+ {
+ HBITMAP hbmGlyph = (HBITMAP)glyph;
+ HDC hdcGlyph = CreateCompatibleDC(m_displayBuffer);
+ HGDIOBJ hOld = SelectObject(hdcGlyph, hbmGlyph);
+
+ int dcsave = SaveDC(m_displayBuffer);
+
+ switch(mixmode)
+ {
+ case MIX_TRANSPARENT:
+ {
+ /*
+ ROP is DSPDxax:
+ - where the glyph (S) is white, D is set to the foreground color (P)
+ - where the glyph (S) is black, D is left untouched
+
+ This paints a transparent glyph in the specified color
+ */
+ HBRUSH hbr = CreateSolidBrush(fgcolour);
+ SelectObject(m_displayBuffer, hbr);
+ BitBlt(m_displayBuffer, x, y, cx, cy, hdcGlyph, srcx, srcy, MAKELONG(0, 0xe2));
+ DeleteObject(hbr);
+ }
+
+ break;
+
+ case MIX_OPAQUE:
+ {
+ /* Curiously, glyphs are inverted (white-on-black) */
+ SetBkColor(m_displayBuffer, fgcolour);
+ SetTextColor(m_displayBuffer, bgcolour);
+ BitBlt(m_displayBuffer, x, y, cx, cy, hdcGlyph, srcx, srcy, SRCCOPY);
+ }
+
+ break;
+ }
+
+ RestoreDC(m_displayBuffer, dcsave);
+
+ SelectObject(hdcGlyph, hOld);
+ DeleteDC(hdcGlyph);
+
+ Display_RepaintArea(x, y, cx, cy);
+ }
+
+ void Display_DoGlyph(uint8 font, uint8 flags, int mixmode, int& x, int& y, int bgcolour, int fgcolour, const uint8 * ttext, int& idx)
+ {
+ FONTGLYPH * glyph;
+
+ glyph = cache_get_font(/*This*/NULL, font, ttext[idx]);
+
+ if(!(flags & TEXT2_IMPLICIT_X))
+ {
+ int xyoffset = ttext[++ idx];
+
+ if((xyoffset & 0x80))
+ {
+ if (flags & TEXT2_VERTICAL)
+ y += ttext[idx + 1] | (ttext[idx + 2] << 8);
+ else
+ x += ttext[idx + 1] | (ttext[idx + 2] << 8);
+
+ idx += 2;
+ }
+ else
+ {
+ if (flags & TEXT2_VERTICAL)
+ y += xyoffset;
+ else
+ x += xyoffset;
+ }
+ }
+
+ if(glyph)
+ {
+ Display_DrawGlyph
+ (
+ mixmode,
+ x + (short)glyph->offset,
+ y + (short)glyph->baseline,
+ glyph->width,
+ glyph->height,
+ glyph->pixmap,
+ 0,
+ 0,
+ bgcolour,
+ fgcolour
+ );
+
+ if(flags & TEXT2_IMPLICIT_X)
+ x += glyph->width;
+ }
+ }
+
+ void Display_DrawText
+ (
+ uint8 font,
+ uint8 flags,
+ uint8 opcode,
+ int mixmode,
+ int x,
+ int y,
+ int clipx,
+ int clipy,
+ int clipcx,
+ int clipcy,
+ int boxx,
+ int boxy,
+ int boxcx,
+ int boxcy,
+ BRUSH * brush,
+ int bgcolour,
+ int fgcolour,
+ uint8 * text,
+ uint8 length
+ )
+ {
+ int i, j;
+ DATABLOB *entry;
+
+ HBRUSH hbr = CreateSolidBrush(bgcolour);
+ HGDIOBJ holdbrush = SelectObject(m_displayBuffer, hbr);
+ HGDIOBJ holdpen = SelectObject(m_displayBuffer, GetStockObject(NULL_PEN));
+
+ if (boxcx > 1)
+ Rectangle(m_displayBuffer, boxx, boxy, boxx + boxcx + 1, boxy + boxcy + 1);
+ else if (mixmode == MIX_OPAQUE)
+ Rectangle(m_displayBuffer, clipx, clipy, clipx + clipcx + 1, clipy + clipcy + 1);
+
+ SelectObject(m_displayBuffer, holdpen);
+ SelectObject(m_displayBuffer, holdbrush);
+
+ DeleteObject(hbr);
+
+ if(boxcx > 1)
+ Display_RepaintArea(boxx, boxy, boxcx, boxcy);
+ else
+ Display_RepaintArea(clipx, clipy, clipcx, clipcy);
+
+ /* Paint text, character by character */
+ for (i = 0; i < length;)
+ {
+ switch (text[i])
+ {
+ case 0xff:
+ /* At least two bytes needs to follow */
+ if (i + 3 > length)
+ {
+ warning("Skipping short 0xff command:");
+ for (j = 0; j < length; j++)
+ fprintf(stderr, "%02x ", text[j]);
+ fprintf(stderr, "\n");
+ i = length = 0;
+ break;
+ }
+ cache_put_text(NULL /* TODO */, text[i + 1], text, text[i + 2]);
+ i += 3;
+ length -= i;
+ /* this will move pointer from start to first character after FF command */
+ text = &(text[i]);
+ i = 0;
+ break;
+
+ case 0xfe:
+ /* At least one byte needs to follow */
+ if (i + 2 > length)
+ {
+ warning("Skipping short 0xfe command:");
+ for (j = 0; j < length; j++)
+ fprintf(stderr, "%02x ", text[j]);
+ fprintf(stderr, "\n");
+ i = length = 0;
+ break;
+ }
+ entry = cache_get_text(/*This*/NULL, text[i + 1]);
+ if (entry->data != NULL)
+ {
+ if ((((uint8 *) (entry->data))[1] == 0)
+ && (!(flags & TEXT2_IMPLICIT_X)) && (i + 2 < length))
+ {
+ if (flags & TEXT2_VERTICAL)
+ y += text[i + 2];
+ else
+ x += text[i + 2];
+ }
+ for (j = 0; j < entry->size; j++)
+ Display_DoGlyph(font, flags, mixmode, x, y, bgcolour, fgcolour, ((uint8 *) (entry->data)), j);
+ }
+ if (i + 2 < length)
+ i += 3;
+ else
+ i += 2;
+ length -= i;
+ /* this will move pointer from start to first character after FE command */
+ text = &(text[i]);
+ i = 0;
+ break;
+
+ default:
+ Display_DoGlyph(font, flags, mixmode, x, y, bgcolour, fgcolour, text, i);
+ i++;
+ break;
+ }
+ }
+ }
+
+ void Display_SaveDesktop(uint32 offset, int x, int y, int cx, int cy)
+ {
+ GdiFlush();
+
+ uint8 * data =
+ (uint8 *)m_displayBufferRaw +
+ x * m_displayBufferByteDepth +
+ (m_displayBufferHeight - y - cy) * m_displayBufferStride;
+
+ cache_put_desktop
+ (
+ /*This*/NULL,
+ offset * m_displayBufferByteDepth,
+ cx,
+ cy,
+ m_displayBufferStride,
+ m_displayBufferByteDepth,
+ data
+ );
+ }
+
+ void Display_RestoreDesktop(uint32 offset, int x, int y, int cx, int cy)
+ {
+ int fromstride = cx * m_displayBufferByteDepth;
+
+ const uint8 * src = cache_get_desktop(/*This*/NULL, offset, cx, cy, m_displayBufferByteDepth);
+
+ uint8 * dst =
+ (uint8 *)m_displayBufferRaw +
+ x * m_displayBufferByteDepth +
+ (m_displayBufferHeight - y - cy) * m_displayBufferStride;
+
+ GdiFlush();
+
+ for(int i = 0; i < cy; ++ i)
+ {
+ memcpy(dst, src, fromstride);
+ src += fromstride;
+ dst += m_displayBufferStride;
+ }
+
+ Display_RepaintArea(x, y, cx, cy);
+ }
+
+
+ void Display_BeginUpdate()
+ {
+ EnterCriticalSection(&m_displayBufferMutex);
+ m_displayBufferSave = SaveDC(m_displayBuffer);
+ }
+
+ void Display_EndUpdate()
+ {
+ RestoreDC(m_displayBuffer, m_displayBufferSave);
+ LeaveCriticalSection(&m_displayBufferMutex);
+ }
+
+ /*
+ This is the input window. It receives the keyboard and mouse input from
+ the user, and it's the only window that can receive the keyboard focus.
+ It completely fills its parent, the console window, and it runs in its
+ own thread for performance reasons and because of technical reasons
+ involving keyboard hooks in full-screen mode
+ */
+ HWND m_inputWindow;
+ HCURSOR m_inputCursor;
+
+ LRESULT InputWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
+ {
+ switch(uMsg)
+ {
+ case WM_DESTROY:
+ PostQuitMessage(0);
+ return 0;
+
+ /* Keyboard stuff */
+ // TODO: we need a good way to post output cross-thread
+ case WM_SYSKEYDOWN:
+ case WM_KEYDOWN:
+ //rdp_send_input(This, GetMessageTime(), RDP_INPUT_SCANCODE, RDP_KEYPRESS | (lparam & 0x1000000 ? KBD_FLAG_EXT : 0), LOBYTE(HIWORD(lparam)), 0);
+ break;
+
+ case WM_SYSKEYUP:
+ case WM_KEYUP:
+ //rdp_send_input(This, GetMessageTime(), RDP_INPUT_SCANCODE, RDP_KEYRELEASE | (lparam & 0x1000000 ? KBD_FLAG_EXT : 0), LOBYTE(HIWORD(lparam)), 0);
+ break;
+
+ /* Mouse stuff */
+ // Cursor shape
+ case WM_SETCURSOR:
+ if(LOWORD(lParam) == HTCLIENT)
+ {
+ SetCursor(m_inputCursor);
+ return TRUE;
+ }
+
+ break;
+
+ // Movement
+ case WM_MOUSEMOVE:
+ //rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_MOVE, LOWORD(lparam), HIWORD(lparam));
+ break;
+
+ // Buttons
+ // TODO: X buttons
+ case WM_LBUTTONDOWN:
+ //rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON1 | MOUSE_FLAG_DOWN, LOWORD(lparam), HIWORD(lparam));
+ break;
+
+ case WM_RBUTTONDOWN:
+ //rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON2 | MOUSE_FLAG_DOWN, LOWORD(lparam), HIWORD(lparam));
+ break;
+
+ case WM_MBUTTONDOWN:
+ //rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON3 | MOUSE_FLAG_DOWN, LOWORD(lparam), HIWORD(lparam));
+ break;
+
+ case WM_LBUTTONUP:
+ //rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON1, LOWORD(lparam), HIWORD(lparam));
+ break;
+
+ case WM_RBUTTONUP:
+ //rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON2, LOWORD(lparam), HIWORD(lparam));
+ break;
+
+ case WM_MBUTTONUP:
+ //rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON3, LOWORD(lparam), HIWORD(lparam));
+ break;
+
+ // Wheel
+ case WM_MOUSEWHEEL:
+ //mstsc_mousewheel(This, (SHORT)HIWORD(wparam), lparam);
+ break;
+ }
+
+ return DefWindowProc(m_inputWindow, uMsg, wParam, lParam);
+ }
+
+public:
+};
+
+#pragma warning(push)
+#pragma warning(disable: 4584)
+
+/* The ActiveX control */
+class RdpClient SEALED_:
+ /* 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, non-functional implementation of this, which we omit
+ // ISpecifyPropertyPages
+
+ // Hidden interfaces, not available through QueryInterface
+ public IConnectionPoint,
+
+ /* RDP client interface */
+ public MSTSCLib::IMsRdpClient4,
+ public MSTSCLib::IMsRdpClientNonScriptable2
+
+ // NOTE: implemented by inner classes due to requiring distinct IDispatch implementations
+ // IMsRdpClientAdvancedSettings4
+ // IMsRdpClientSecuredSettings
+{
+private:
+ /* An endless amount of COM glue */
+ // Reference counting
+ LONG m_refCount;
+
+#ifdef _DEBUG
+ DWORD m_apartmentThreadId;
+
+ bool InsideApartment() const
+ {
+ return GetCurrentThreadId() == m_apartmentThreadId;
+ }
+#endif
+
+ // Aggregation support
+ IUnknown * m_punkOuter;
+
+ class RdpClientInner: public IUnknown
+ {
+ private:
+ RdpClient * Outer()
+ {
+ return InnerToOuter(this);
+ }
+
+ public:
+ virtual STDMETHODIMP IUnknown::QueryInterface(REFIID riid, void ** ppvObject)
+ {
+ return Outer()->queryInterface(riid, ppvObject);
+ }
+
+ virtual STDMETHODIMP_(ULONG) IUnknown::AddRef()
+ {
+ return Outer()->addRef();
+ }
+
+ virtual STDMETHODIMP_(ULONG) IUnknown::Release()
+ {
+ return Outer()->release();
+ }
+
+ }
+ m_inner;
+
+ // Persistence support
+ CLSID m_classId;
+
+ // Late binding support
+ unsigned m_typeLibIndex;
+ ITypeLib * m_typeLib;
+ ITypeInfo * m_dispTypeInfo;
+
+ // Event sinks
+ size_t m_EventSinksCount;
+
+ union
+ {
+ MSTSCLib::IMsTscAxEvents * m_EventSinksStatic[1];
+ MSTSCLib::IMsTscAxEvents ** m_EventSinks;
+ };
+
+ // OLE control glue
+ HWND m_controlWindow;
+ IOleClientSite * m_clientSite;
+ IOleInPlaceSite * m_inPlaceSite;
+ IOleAdviseHolder * m_adviseHolder;
+ LONG m_freezeEvents;
+ bool m_uiActive;
+
+ // UrlMon security
+ DWORD m_SafetyOptions;
+
+ bool IsSafeForScripting() const
+ {
+ return m_SafetyOptions & INTERFACESAFE_FOR_UNTRUSTED_CALLER;
+ }
+
+ /* Glue to interface to rdesktop-core */
+ RdpClientUI * m_clientUI;
+ RDPCLIENT m_protocolState;
+ HANDLE m_protocolThread;
+ HANDLE m_protocolThreadWaitingReconnection;
+ bool m_reconnectAborted;
+ bool m_actuallyConnected;
+ bool m_loggedIn;
+
+ /* Properties */
+ // Storage fields
+ // NOTE: keep sorted by alignment (pointers and handles, integers, enumerations, booleans)
+ BSTR m_Domain;
+ BSTR m_UserName;
+ BSTR m_DisconnectedText;
+ BSTR m_ConnectingText;
+ BSTR m_FullScreenTitle;
+ BSTR m_StartProgram;
+ BSTR m_WorkDir;
+ BSTR m_ConnectedStatusText;
+ BSTR m_ClearTextPassword; // FIXME! dangerous, shouldn't store in cleartext!
+ BSTR m_RdpdrLocalPrintingDocName;
+ BSTR m_RdpdrClipCleanTempDirString;
+ BSTR m_RdpdrClipPasteInfoString;
+ BSTR m_KeyboardLayoutString;
+ LPSTR m_Server;
+ LPSTR m_LoadBalanceInfo;
+ // TODO: plugin DLLs
+ HWND m_UIParentWindowHandle;
+ long m_DesktopWidth;
+ long m_DesktopHeight;
+ long m_StartConnected;
+ long m_ColorDepth;
+ long m_KeyboardHookMode;
+ long m_AudioRedirectionMode;
+ long m_TransportType;
+ long m_SasSequence;
+ long m_RDPPort;
+ long m_HotKeyFullScreen;
+ long m_HotKeyAltEsc;
+ long m_HotKeyAltShiftTab;
+ long m_HotKeyAltSpace;
+ long m_HotKeyAltTab;
+ long m_HotKeyCtrlAltDel;
+ long m_HotKeyCtrlEsc;
+ long m_orderDrawThresold;
+ long m_BitmapCacheSize;
+ long m_BitmapVirtualCacheSize;
+ long m_NumBitmapCaches;
+ long m_brushSupportLevel;
+ long m_minInputSendInterval;
+ long m_InputEventsAtOnce;
+ long m_maxEventCount;
+ long m_keepAliveInternal;
+ long m_shutdownTimeout;
+ long m_overallConnectionTimeout;
+ long m_singleConnectionTimeout;
+ long m_MinutesToIdleTimeout;
+ long m_BitmapVirtualCache16BppSize;
+ long m_BitmapVirtualCache24BppSize;
+ long m_PerformanceFlags;
+ long m_MaxReconnectAttempts;
+ unsigned int m_AuthenticationLevel;
+
+ MSTSCLib::ExtendedDisconnectReasonCode m_ExtendedDisconnectReason;
+
+ bool m_Connected;
+ bool m_Compress;
+ bool m_BitmapPersistence;
+ bool m_allowBackgroundInput;
+ bool m_ContainerHandledFullScreen;
+ bool m_DisableRdpdr;
+ bool m_SecuredSettingsEnabled;
+ bool m_FullScreen;
+ bool m_AcceleratorPassthrough;
+ bool m_ShadowBitmap;
+ bool m_EncryptionEnabled;
+ bool m_DedicatedTerminal;
+ bool m_DisableCtrlAltDel;
+ bool m_EnableWindowsKey;
+ bool m_DoubleClickDetect;
+ bool m_MaximizeShell;
+ bool m_ScaleBitmapCachesByBpp;
+ bool m_CachePersistenceActive;
+ bool m_ConnectToServerConsole;
+ bool m_SmartSizing; // FIXME: this can be set while the control is connected
+ bool m_DisplayConnectionBar;
+ bool m_PinConnectionBar;
+ bool m_GrabFocusOnConnect;
+ bool m_RedirectDrives;
+ bool m_RedirectPrinters;
+ bool m_RedirectPorts;
+ bool m_RedirectSmartCards;
+ bool m_NotifyTSPublicKey;
+ bool m_CanAutoReconnect;
+ bool m_EnableAutoReconnect;
+ bool m_ConnectionBarShowMinimizeButton;
+ bool m_ConnectionBarShowRestoreButton;
+
+ // Generic getters/setters
+ HRESULT GetProperty(BSTR& prop, BSTR * retVal) const
+ {
+ assert(InsideApartment());
+
+ if(retVal == NULL)
+ return E_POINTER;
+
+ *retVal = SysAllocStringLen(prop, SysStringLen(prop));
+
+ if(*retVal == NULL)
+ return E_OUTOFMEMORY;
+
+ return S_OK;
+ }
+
+ HRESULT GetProperty(LPSTR& prop, BSTR * retVal) const
+ {
+ assert(InsideApartment());
+
+ if(retVal == NULL)
+ return E_POINTER;
+
+ *retVal = LpszToBstr(prop);
+
+ if(*retVal == NULL)
+ return E_OUTOFMEMORY;
+
+ return S_OK;
+ }
+
+ HRESULT SetProperty(BSTR& prop, BSTR newValue)
+ {
+ assert(InsideApartment());
+
+ if(m_Connected)
+ return E_FAIL;
+
+ SysFreeString(prop);
+
+ UINT len = SysStringLen(newValue);
+
+ if(len)
+ {
+ // no embedded NULs, please
+ if(len != lstrlenW(newValue))
+ return E_INVALIDARG;
+
+ prop = SysAllocStringLen(newValue, len);
+
+ if(prop == NULL)
+ return E_OUTOFMEMORY;
+ }
+ else
+ prop = NULL;
+
+ return S_OK;
+ }
+
+ HRESULT ReplaceProperty(BSTR& prop, BSTR newValue)
+ {
+ assert(InsideApartment());
+ assert((prop == NULL && newValue == NULL) || prop != newValue);
+
+ SysFreeString(prop);
+ prop = newValue;
+ return S_OK;
+ }
+
+ HRESULT SetProperty(LPSTR& prop, BSTR newValue)
+ {
+ assert(InsideApartment());
+
+ if(m_Connected)
+ return E_FAIL;
+
+ delete[] prop;
+
+ if(SysStringLen(newValue))
+ {
+ prop = BstrToLpsz(newValue);
+
+ if(prop == NULL)
+ return E_OUTOFMEMORY;
+ }
+ else
+ prop = NULL;
+
+ return S_OK;
+ }
+
+ HRESULT ReplaceProperty(LPSTR& prop, LPSTR newValue)
+ {
+ assert(InsideApartment());
+ assert((prop == NULL && newValue == NULL) || prop != newValue);
+
+ if(prop)
+ delete[] prop;
+
+ prop = newValue;
+ return S_OK;
+ }
+
+ template HRESULT SetProperty(bool& prop, const Type& newValue)
+ {
+ assert(InsideApartment());
+
+ if(m_Connected)
+ return E_FAIL;
+
+ prop = !!newValue;
+ return S_OK;
+ }
+
+ template HRESULT SetProperty(Type& prop, const Type& newValue)
+ {
+ assert(InsideApartment());
+
+ if(m_Connected)
+ return E_FAIL;
+
+ prop = newValue;
+ return S_OK;
+ }
+
+ template HRESULT GetProperty(const bool& prop, Type * retVal) const
+ {
+ assert(InsideApartment());
+
+ if(retVal == NULL)
+ return E_POINTER;
+
+ *retVal = prop ? VARIANT_TRUE : VARIANT_FALSE;
+ return S_OK;
+ }
+
+ template HRESULT GetProperty(const Type& prop, Type * retVal) const
+ {
+ assert(InsideApartment());
+
+ if(retVal == NULL)
+ return E_POINTER;
+
+ *retVal = prop;
+ return S_OK;
+ }
+
+ /* Events */
+ MSTSCLib::IMsTscAxEvents ** GetSinks() const
+ {
+ if(m_EventSinksCount > 1)
+ return m_EventSinks;
+ else
+ return const_cast(m_EventSinksStatic);
+ }
+
+ // Event freezing
+ void UnfreezeEvents()
+ {
+ // Just in case
+ }
+
+ // Generic event riser & helpers
+ void InvokeSinks(DISPID eventId, VARIANTARG rgvarg[], unsigned int cArgs, VARIANTARG * retval)
+ {
+ assert(InsideApartment());
+
+ DISPPARAMS params;
+
+ params.rgvarg = rgvarg;
+ params.rgdispidNamedArgs = NULL;
+ params.cArgs = cArgs;
+ params.cNamedArgs = 0;
+
+ MSTSCLib::IMsTscAxEvents ** sinks = GetSinks();
+
+ for(size_t i = 0; i < m_EventSinksCount; ++ i)
+ sinks[i]->Invoke(eventId, IID_NULL, 0, DISPATCH_METHOD, ¶ms, retval, NULL, NULL);
+ }
+
+ typedef void (RdpClient::* AsyncEventCallback)
+ (
+ DISPID eventId,
+ VARIANTARG * rgvarg,
+ unsigned int cArgs,
+ VARIANTARG * retVal
+ );
+
+ void CleanupEventArgumentsCallback
+ (
+ DISPID eventId,
+ VARIANTARG * rgvarg,
+ unsigned int cArgs,
+ VARIANTARG * retVal
+ )
+ {
+ assert((rgvarg == NULL) == (cArgs == 0));
+
+ for(unsigned int i = 0; i < cArgs; ++ i)
+ VariantClear(&rgvarg[i]);
+
+ if(retVal)
+ VariantClear(retVal);
+ }
+
+ // synchronous call from inside the apartment that owns the object
+ void FireEventInsideApartment
+ (
+ DISPID eventId,
+ VARIANTARG * rgvarg = NULL,
+ unsigned int cArgs = 0,
+ VARIANTARG * retval = NULL,
+ AsyncEventCallback callback = NULL
+ )
+ {
+ assert(InsideApartment());
+
+ if(retval == NULL && callback)
+ {
+ VARIANTARG localRetval = { };
+ retval = &localRetval;
+ }
+
+ InvokeSinks(eventId, rgvarg, cArgs, retval);
+
+ if(callback)
+ (this->*callback)(eventId, rgvarg, cArgs, retval);
+ }
+
+ struct EventArguments
+ {
+ DISPID eventId;
+ VARIANTARG * rgvarg;
+ unsigned int cArgs;
+ VARIANTARG * retval;
+ AsyncEventCallback callback;
+ };
+
+ struct RedirectArguments
+ {
+ uint32 flags;
+ uint32 server_len;
+ wchar_t * server;
+ uint32 cookie_len;
+ char * cookie;
+ uint32 username_len;
+ wchar_t * username;
+ uint32 domain_len;
+ wchar_t * domain;
+ uint32 password_len;
+ wchar_t * password;
+ };
+
+ enum
+ {
+ RDPC_WM_ = WM_USER,
+ RDPC_WM_SYNC_EVENT,
+ RDPC_WM_ASYNC_EVENT,
+ RDPC_WM_DISCONNECT,
+ RDPC_WM_REQUEST_CLOSE,
+ RDPC_WM_REDIRECT,
+ };
+
+ static VOID CALLBACK DisconnectAPC(ULONG_PTR)
+ {
+ // no need to do anything. The interruption will be enough
+ }
+
+ bool HandleEvent(UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT& result)
+ {
+ result = 0;
+
+ switch(uMsg)
+ {
+ /* Regular event to be dispatched to the container's sink */
+ case RDPC_WM_SYNC_EVENT:
+ assert(InSendMessage());
+
+ case RDPC_WM_ASYNC_EVENT:
+ {
+ const EventArguments * eventArgs = reinterpret_cast(lParam);
+ assert(eventArgs);
+
+ FireEventInsideApartment
+ (
+ eventArgs->eventId,
+ eventArgs->rgvarg,
+ eventArgs->cArgs,
+ eventArgs->retval,
+ eventArgs->callback
+ );
+
+ if(uMsg == RDPC_WM_ASYNC_EVENT)
+ delete eventArgs;
+ }
+
+ break;
+
+ /* The protocol thread is about to die: prepare for disconnection */
+ case RDPC_WM_DISCONNECT:
+ {
+ assert(m_Connected);
+ assert(InsideApartment());
+ assert(InSendMessage());
+
+ // Unblock the protocol thread and wait for it to terminate
+ ReplyMessage(0);
+ JoinProtocolThread();
+
+ // Finish disconnecting
+ PerformDisconnect(static_cast(wParam));
+ }
+
+ break;
+
+ case RDPC_WM_REDIRECT:
+ {
+ assert(InSendMessage());
+ assert(lParam);
+ assert(m_Connected);
+ assert(m_protocolState.redirect);
+
+ RedirectArguments * redirectArgs = reinterpret_cast(lParam);
+
+ // BUGBUG: this is extremely messy and more prone to out-of-memory than it should be
+ LPSTR lpszNewServer = NULL;
+ LPSTR lpszNewCookie = NULL;
+ BSTR strNewUsername = NULL;
+ BSTR strNewDomain = NULL;
+ BSTR strNewPassword = NULL;
+ HRESULT hr = S_OK;
+
+ for(;;)
+ {
+ // Allocate the new properties
+ hr = E_OUTOFMEMORY;
+
+ // FIXME: convert the hostname to Punycode, not the ANSI codepage
+ lpszNewServer = AllocLpsz(redirectArgs->server, redirectArgs->server_len / sizeof(OLECHAR));
+
+ if(lpszNewServer == NULL && redirectArgs->server_len)
+ break;
+
+ lpszNewCookie = AllocLpsz(redirectArgs->cookie, redirectArgs->cookie_len);
+
+ if(lpszNewCookie == NULL && redirectArgs->cookie_len)
+ break;
+
+ strNewUsername = SysAllocStringLen(redirectArgs->username, redirectArgs->username_len / sizeof(OLECHAR));
+
+ if(strNewUsername == NULL && redirectArgs->username_len)
+ break;
+
+ strNewDomain = SysAllocStringLen(redirectArgs->domain, redirectArgs->domain_len / sizeof(OLECHAR));
+
+ if(strNewDomain == NULL && redirectArgs->domain_len)
+ break;
+
+ strNewPassword = SysAllocStringLen(redirectArgs->password, redirectArgs->password_len / sizeof(OLECHAR));
+
+ if(strNewPassword == NULL && redirectArgs->password_len)
+ break;
+
+ hr = S_OK;
+ break;
+ }
+
+ // Success
+ if(SUCCEEDED(hr))
+ {
+ // set the new properties
+ ReplaceProperty(m_Server, lpszNewServer);
+ ReplaceProperty(m_LoadBalanceInfo, lpszNewCookie);
+ ReplaceProperty(m_UserName, strNewUsername);
+ ReplaceProperty(m_Domain, strNewDomain);
+ ReplaceProperty(m_ClearTextPassword, strNewPassword);
+ }
+ // Failure
+ else
+ {
+ // free the buffers
+ FreeLpsz(lpszNewServer);
+ FreeLpsz(lpszNewCookie);
+ SysFreeString(strNewUsername);
+ SysFreeString(strNewDomain);
+ SysFreeString(strNewPassword);
+
+ // signal the error
+ m_protocolState.disconnect_reason = 262;
+ m_protocolState.redirect = False;
+ result = -1;
+ }
+ }
+
+ break;
+
+ // BUGBUG: this could potentially disconnect an unrelated connection established later...
+ case RDPC_WM_REQUEST_CLOSE:
+ {
+ assert(!InSendMessage());
+
+ if(m_Connected)
+ {
+ // Ask confirmation to the container in case we are logged in
+ if(m_loggedIn && !FireConfirmClose())
+ break;
+
+ // For reentrancy (OnConfirmClose could deviously call Disconnect)
+ if(m_protocolThread == NULL)
+ break;
+
+ // Terminate the protocol thread. It will fire the Disconnected event on exit
+ TerminateProtocolThread();
+ }
+ }
+
+ break;
+
+ default:
+ return false;
+ }
+
+ // If the calling thread is blocked, unblock it ASAP
+ if(InSendMessage())
+ ReplyMessage(result);
+
+ return true;
+ }
+
+ // synchronous call from outside the apartment
+ void FireEventOutsideApartment
+ (
+ DISPID eventId,
+ VARIANTARG * rgvarg = NULL,
+ unsigned int cArgs = 0,
+ VARIANTARG * retval = NULL,
+ AsyncEventCallback callback = NULL
+ )
+ {
+ assert(!InsideApartment());
+ EventArguments syncEvent = { eventId, rgvarg, cArgs, retval, callback };
+ SendMessage(m_controlWindow, RDPC_WM_SYNC_EVENT, 0, reinterpret_cast(&syncEvent));
+ }
+
+ // asynchronous call from outside the apartment
+ HRESULT FireEventOutsideApartmentAsync
+ (
+ DISPID eventId,
+ VARIANTARG * rgvarg = NULL,
+ unsigned int cArgs = 0,
+ VARIANTARG * retval = NULL,
+ AsyncEventCallback callback = NULL
+ )
+ {
+ assert(!InsideApartment());
+
+ EventArguments * asyncEvent = new EventArguments();
+
+ if(asyncEvent == NULL)
+ return E_OUTOFMEMORY;
+
+ asyncEvent->eventId = eventId;
+ asyncEvent->rgvarg = rgvarg;
+ asyncEvent->cArgs = cArgs;
+ asyncEvent->retval = NULL;
+
+ if(!PostMessage(m_controlWindow, RDPC_WM_ASYNC_EVENT, 0, reinterpret_cast(asyncEvent)))
+ {
+ delete asyncEvent;
+ return HRESULT_FROM_WIN32(GetLastError());
+ }
+
+ return S_OK;
+ }
+
+ // Specific events
+ void FireConnecting()
+ {
+ // Source: protocol
+ FireEventOutsideApartment(1);
+ }
+
+ void FireConnected()
+ {
+ // Source: protocol
+ FireEventOutsideApartment(2);
+ }
+
+ void FireLoginComplete()
+ {
+ // Source: protocol
+ FireEventOutsideApartment(3);
+ }
+
+ void FireDisconnected(long reason)
+ {
+ // Source: protocol. Special handling
+ SendMessage(m_controlWindow, RDPC_WM_DISCONNECT, reason, 0);
+ }
+
+ void FireEnterFullScreenMode()
+ {
+ // Source: UI window
+ FireEventInsideApartment(5);
+ }
+
+ void FireLeaveFullScreenMode()
+ {
+ // Source: UI window
+ FireEventInsideApartment(6);
+ }
+
+ HRESULT FireChannelReceivedData(char (& chanName)[CHANNEL_NAME_LEN + 1], void * chanData, unsigned int chanDataSize)
+ {
+ // BUGBUG: what to do when we run out of memory?
+
+ OLECHAR wchanName[ARRAYSIZE(chanName)];
+ std::copy(chanName + 0, chanName + ARRAYSIZE(chanName), wchanName);
+
+ BSTR bstrChanName = SysAllocString(wchanName);
+
+ if(bstrChanName == NULL)
+ return E_OUTOFMEMORY;
+
+ BSTR bstrChanData = SysAllocStringByteLen(NULL, chanDataSize);
+
+ if(bstrChanData == NULL)
+ {
+ SysFreeString(bstrChanName);
+ return E_OUTOFMEMORY;
+ }
+
+ CopyMemory(bstrChanData, chanData, chanDataSize);
+
+ VARIANTARG args[2] = { };
+
+ args[1].vt = VT_BSTR;
+ args[1].bstrVal = bstrChanName;
+
+ args[0].vt = VT_BSTR;
+ args[0].bstrVal = bstrChanData;
+
+ // Source: protocol
+ HRESULT hr = FireEventOutsideApartmentAsync(7, args, ARRAYSIZE(args), NULL, &RdpClient::CleanupEventArgumentsCallback);
+
+ if(FAILED(hr))
+ CleanupEventArgumentsCallback(7, args, ARRAYSIZE(args), NULL);
+
+ return hr;
+ }
+
+ void FireRequestGoFullScreen()
+ {
+ // Source: UI window
+ FireEventInsideApartment(8);
+ }
+
+ void FireRequestLeaveFullScreen()
+ {
+ // Source: UI window
+ FireEventInsideApartment(9);
+ }
+
+ void FireFatalError(long errorCode)
+ {
+ VARIANTARG arg = { };
+
+ arg.vt = VT_I4;
+ arg.lVal = errorCode;
+
+ // Source: protocol
+ FireEventOutsideApartment(10, &arg, 1);
+ }
+
+ void FireFatalErrorFromApartment(long errorCode)
+ {
+ VARIANTARG arg = { };
+
+ arg.vt = VT_I4;
+ arg.lVal = errorCode;
+
+ // Source: control
+ FireEventInsideApartment(10, &arg, 1);
+ }
+
+ void FireWarning(long warningCode)
+ {
+ VARIANTARG arg = { };
+
+ arg.vt = VT_I4;
+ arg.lVal = warningCode;
+
+ // Source: protocol
+ FireEventOutsideApartment(11, &arg, 1);
+ }
+
+ void FireRemoteDesktopSizeChange(long width, long height)
+ {
+ VARIANTARG args[2] = { };
+
+ args[1].vt = VT_I4;
+ args[1].lVal = width;
+
+ args[0].vt = VT_I4;
+ args[0].lVal = height;
+
+ // Source: UI window
+ FireEventInsideApartment(12, args, ARRAYSIZE(args));
+ }
+
+ void FireIdleTimeoutNotification()
+ {
+ // Source: input thread
+ FireEventOutsideApartment(13);
+ }
+
+ void FireRequestContainerMinimize()
+ {
+ // Source: UI window
+ FireEventInsideApartment(14);
+ }
+
+ bool FireConfirmClose()
+ {
+ VARIANTARG retval = { };
+ VARIANT_BOOL allowClose = VARIANT_TRUE;
+
+ retval.vt = VT_BYREF | VT_BOOL;
+ retval.pboolVal = &allowClose;
+
+ // Source: control
+ FireEventInsideApartment(15, NULL, 0, &retval);
+
+ return allowClose != VARIANT_FALSE;
+ }
+
+ HRESULT FireReceivedTSPublicKey(void * publicKey, unsigned int publicKeyLength)
+ {
+ assert(m_Connected);
+
+ if(!m_NotifyTSPublicKey)
+ return S_OK;
+
+ BSTR bstrPublicKey = SysAllocStringByteLen(NULL, publicKeyLength);
+
+ if(bstrPublicKey == NULL)
+ return E_OUTOFMEMORY;
+
+ CopyMemory(bstrPublicKey, publicKey, publicKeyLength);
+
+ VARIANT_BOOL continueLogon = VARIANT_TRUE;
+ VARIANTARG arg = { };
+ VARIANTARG retval = { };
+
+ arg.vt = VT_BSTR;
+ arg.bstrVal = bstrPublicKey;
+
+ retval.vt = VT_BYREF | VT_BOOL;
+ retval.pboolVal = &continueLogon;
+
+ // Source: protocol
+ FireEventOutsideApartment(16, &arg, 1, &retval);
+
+ return continueLogon ? S_OK : S_FALSE;
+ }
+
+ LONG FireAutoReconnecting(long disconnectReason, long attemptCount)
+ {
+ LONG continueStatus = MSTSCLib::autoReconnectContinueAutomatic;
+ VARIANTARG args[2] = { };
+ VARIANTARG retval = { };
+
+ args[1].vt = VT_I4;
+ args[1].lVal = disconnectReason;
+
+ args[0].vt = VT_I4;
+ args[0].lVal = attemptCount;
+
+ retval.vt = VT_BYREF | VT_I4;
+ retval.plVal = &continueStatus;
+
+ // Source: protocol
+ FireEventOutsideApartment(17, args, ARRAYSIZE(args), &retval);
+
+ return continueStatus;
+ }
+
+ void FireAuthenticationWarningDisplayed()
+ {
+ // Source: protocol
+ FireEventOutsideApartment(18);
+ }
+
+ void FireAuthenticationWarningDismissed()
+ {
+ // Source: protocol
+ FireEventOutsideApartment(19);
+ }
+
+ /* Actual IUnknown implementation */
+ HRESULT queryInterface(REFIID riid, void ** ppvObject)
+ {
+ IUnknown * pvObject = NULL;
+
+ using namespace MSTSCLib;
+
+ if(riid == IID_IUnknown)
+ pvObject = static_cast(&m_inner);
+ else if(riid == IID_IConnectionPointContainer)
+ pvObject = static_cast(this);
+ else if(riid == IID_IDataObject)
+ pvObject = static_cast(this);
+ else if(riid == IID_IObjectSafety)
+ pvObject = static_cast(this);
+ else if(riid == IID_IOleControl)
+ pvObject = static_cast(this);
+ else if(riid == IID_IOleInPlaceActiveObject)
+ pvObject = static_cast(this);
+ else if(riid == IID_IOleInPlaceObject)
+ pvObject = static_cast(this);
+ else if(riid == IID_IOleObject)
+ pvObject = static_cast(this);
+ else if(riid == IID_IOleWindow)
+ pvObject = static_cast(this);
+ else if(riid == IID_IPersist)
+ pvObject = static_cast(this);
+ else if(riid == IID_IPersistPropertyBag)
+ pvObject = static_cast(this);
+ else if(riid == IID_IPersistStorage)
+ pvObject = static_cast(this);
+ else if(riid == IID_IPersistStreamInit)
+ pvObject = static_cast(this);
+ else if(riid == IID_IQuickActivate)
+ pvObject = static_cast(this);
+ else if(riid == IID_IViewObject)
+ pvObject = static_cast(this);
+ else if(riid == IID_IViewObject2)
+ pvObject = static_cast(this);
+ else if(riid == IID_IMsTscAx || riid == MSTSCLib_Redist::IID_IMsTscAx)
+ pvObject = static_cast(this);
+ else if(riid == IID_IMsRdpClient)
+ pvObject = static_cast(this);
+ else if(riid == IID_IMsRdpClient2)
+ pvObject = static_cast(this);
+ else if(riid == IID_IMsRdpClient3)
+ pvObject = static_cast(this);
+ else if(riid == IID_IMsRdpClient4)
+ pvObject = static_cast(this);
+ else if(riid == IID_IMsTscNonScriptable)
+ pvObject = static_cast(this);
+ else if(riid == IID_IMsRdpClientNonScriptable)
+ pvObject = static_cast(this);
+ else if(riid == IID_IMsRdpClientNonScriptable2)
+ pvObject = static_cast(this);
+
+ *ppvObject = pvObject;
+
+ if(pvObject)
+ {
+ pvObject->AddRef();
+ return S_OK;
+ }
+
+ return E_NOINTERFACE;
+ }
+
+ ULONG addRef()
+ {
+ return InterlockedIncrement(&m_refCount);
+ }
+
+ ULONG release()
+ {
+ LONG n = InterlockedDecrement(&m_refCount);
+
+ if(n == 0)
+ delete this;
+
+ return n;
+ }
+
+ /* Constructor */
+ RdpClient(REFCLSID classId, unsigned libIndex, IUnknown * punkOuter):
+ // COM/OLE internals
+ m_refCount(0),
+ m_punkOuter(punkOuter),
+ m_classId(classId),
+ m_typeLibIndex(libIndex),
+ m_typeLib(),
+ m_dispTypeInfo(),
+ m_controlWindow(NULL),
+ m_clientSite(),
+ m_inPlaceSite(),
+ m_adviseHolder(),
+ m_freezeEvents(0),
+ m_uiActive(false),
+ m_SafetyOptions(),
+
+#ifdef _DEBUG
+ m_apartmentThreadId(GetCurrentThreadId()),
+#endif
+
+ // rdesktop-core interface
+ m_protocolState(),
+ m_protocolThread(),
+
+ // Properties
+ m_Server(),
+ m_Domain(),
+ m_UserName(),
+ m_DisconnectedText(),
+ m_ConnectingText(),
+ m_FullScreenTitle(),
+ m_StartProgram(),
+ m_WorkDir(),
+ m_LoadBalanceInfo(),
+ m_ConnectedStatusText(),
+ m_ClearTextPassword(),
+ m_RdpdrLocalPrintingDocName(),
+ m_RdpdrClipCleanTempDirString(),
+ m_RdpdrClipPasteInfoString(),
+ m_UIParentWindowHandle(),
+ m_DesktopWidth(),
+ m_DesktopHeight(),
+ m_StartConnected(),
+ m_ColorDepth(16),
+ m_KeyboardHookMode(2),
+ m_AudioRedirectionMode(0),
+ m_TransportType(1), // BUGBUG: ??? what's this ???
+ m_SasSequence(0xAA03), // BUGBUG: ??? what's this ???
+ m_RDPPort(3389),
+ m_HotKeyFullScreen(VK_CANCEL),
+ m_HotKeyAltEsc(VK_INSERT),
+ m_HotKeyAltShiftTab(VK_NEXT),
+ m_HotKeyAltSpace(VK_DELETE),
+ m_HotKeyAltTab(VK_PRIOR),
+ m_HotKeyCtrlAltDel(VK_END),
+ m_HotKeyCtrlEsc(VK_HOME),
+ m_orderDrawThresold(0),
+ m_BitmapCacheSize(1500),
+ m_BitmapVirtualCacheSize(10),
+ m_brushSupportLevel(),
+ m_minInputSendInterval(),
+ m_InputEventsAtOnce(),
+ m_maxEventCount(),
+ m_keepAliveInternal(0),
+ m_shutdownTimeout(10),
+ m_overallConnectionTimeout(120),
+ m_singleConnectionTimeout(30),
+ m_MinutesToIdleTimeout(0),
+ m_BitmapVirtualCache16BppSize(20),
+ m_BitmapVirtualCache24BppSize(30),
+ m_PerformanceFlags(),
+ m_MaxReconnectAttempts(20),
+ m_AuthenticationLevel(0),
+ m_ExtendedDisconnectReason(MSTSCLib::exDiscReasonNoInfo),
+ m_Connected(false),
+ m_Compress(true),
+ m_BitmapPersistence(true),
+ m_allowBackgroundInput(false),
+ m_ContainerHandledFullScreen(false),
+ m_DisableRdpdr(false),
+ m_SecuredSettingsEnabled(true),
+ m_FullScreen(false),
+ m_AcceleratorPassthrough(true),
+ m_ShadowBitmap(true),
+ m_EncryptionEnabled(true),
+ m_DedicatedTerminal(false),
+ m_DisableCtrlAltDel(true),
+ m_EnableWindowsKey(true),
+ m_DoubleClickDetect(false),
+ m_MaximizeShell(true),
+ m_ScaleBitmapCachesByBpp(false),
+ m_CachePersistenceActive(false),
+ m_ConnectToServerConsole(false),
+ m_SmartSizing(false),
+ m_DisplayConnectionBar(true),
+ m_PinConnectionBar(true),
+ m_GrabFocusOnConnect(true),
+ m_RedirectDrives(false),
+ m_RedirectPrinters(false),
+ m_RedirectPorts(false),
+ m_RedirectSmartCards(false),
+ m_NotifyTSPublicKey(false),
+ m_CanAutoReconnect(false),
+ m_EnableAutoReconnect(true),
+ m_ConnectionBarShowMinimizeButton(true),
+ m_ConnectionBarShowRestoreButton(true)
+ {
+ if(m_punkOuter == NULL)
+ m_punkOuter = &m_inner;
+ }
+
+ /* Destructor */
+ ~RdpClient()
+ {
+ assert(m_refCount == 0);
+
+ if(m_Connected)
+ {
+ // Terminate the protocol thread
+ TerminateProtocolThread();
+
+ // Dispatch the RDPC_WM_DISCONNECT message sent by the dying thread
+ MSG msg;
+ PeekMessage(&msg, m_controlWindow, 0, 0, PM_NOREMOVE);
+
+ assert(!m_Connected);
+ }
+
+ DestroyControlWindow();
+
+ if(m_typeLib)
+ m_typeLib->Release();
+
+ if(m_dispTypeInfo)
+ m_dispTypeInfo->Release();
+
+ MSTSCLib::IMsTscAxEvents ** sinks = GetSinks();
+
+ for(size_t i = 0; i < m_EventSinksCount; ++ i)
+ sinks[i]->Release();
+
+ if(m_EventSinksCount > 1)
+ delete[] m_EventSinks;
+
+ if(m_clientSite)
+ m_clientSite->Release();
+
+ if(m_inPlaceSite)
+ m_inPlaceSite->Release();
+
+ if(m_adviseHolder)
+ m_adviseHolder->Release();
+
+ SysFreeString(m_Domain);
+ SysFreeString(m_UserName);
+ SysFreeString(m_DisconnectedText);
+ SysFreeString(m_DisconnectedText);
+ SysFreeString(m_FullScreenTitle);
+ SysFreeString(m_StartProgram);
+ SysFreeString(m_WorkDir);
+ SysFreeString(m_ConnectedStatusText);
+ SysFreeString(m_ClearTextPassword);
+ SysFreeString(m_RdpdrLocalPrintingDocName);
+ SysFreeString(m_RdpdrClipCleanTempDirString);
+ SysFreeString(m_RdpdrClipPasteInfoString);
+
+ FreeLpsz(m_LoadBalanceInfo);
+ FreeLpsz(m_Server);
+
+ unlockServer();
+ }
+
+ /* Advanced settings wrapper */
+ friend class AdvancedSettings;
+
+ class AdvancedSettings SEALED_: public MSTSCLib::IMsRdpClientAdvancedSettings4
+ {
+ private:
+ RdpClient * Outer()
+ {
+ return InnerToOuter(this);
+ }
+
+ const RdpClient * Outer() const
+ {
+ return InnerToOuter(this);
+ }
+
+ /* IDispatch type information */
+ ITypeInfo * m_dispTypeInfo;
+
+ HRESULT LoadDispTypeInfo()
+ {
+ if(m_dispTypeInfo)
+ return S_OK;
+
+ HRESULT hr = Outer()->LoadTypeLibrary();
+
+ if(FAILED(hr))
+ return hr;
+
+ assert(MSTSCLib::IID_IMsRdpClientAdvancedSettings4 == MSTSCLib_Redist::IID_IMsRdpClientAdvancedSettings4);
+
+ hr = Outer()->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;
+ Outer()->addRef();
+ return S_OK;
+ }
+ else
+ {
+ *ppvObject = NULL;
+ return E_NOINTERFACE;
+ }
+ }
+
+ virtual STDMETHODIMP_(ULONG) IUnknown::AddRef()
+ {
+ return Outer()->addRef();
+ }
+
+ virtual STDMETHODIMP_(ULONG) IUnknown::Release()
+ {
+ return Outer()->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 Outer()->SetProperty(Outer()->m_Compress, pcompress);
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::get_Compress(long * pcompress) const
+ {
+ return Outer()->GetProperty(Outer()->m_Compress, pcompress);
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::put_BitmapPeristence(long pbitmapPeristence)
+ {
+ return Outer()->SetProperty(Outer()->m_BitmapPersistence, pbitmapPeristence);
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::get_BitmapPeristence(long * pbitmapPeristence) const
+ {
+ return Outer()->GetProperty(Outer()->m_BitmapPersistence, pbitmapPeristence);
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::put_allowBackgroundInput(long pallowBackgroundInput)
+ {
+ if(Outer()->IsSafeForScripting())
+ return S_FALSE;
+
+ return Outer()->SetProperty(Outer()->m_allowBackgroundInput, pallowBackgroundInput);
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::get_allowBackgroundInput(long * pallowBackgroundInput) const
+ {
+ return Outer()->GetProperty(Outer()->m_allowBackgroundInput, pallowBackgroundInput);
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::put_KeyBoardLayoutStr(BSTR rhs)
+ {
+ return Outer()->SetProperty(Outer()->m_KeyboardLayoutString, rhs);
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::put_PluginDlls(BSTR rhs)
+ {
+ // TODO: split rhs into an array
+
+ // Control marked safe for scripting: only allow filenames
+ if(Outer()->IsSafeForScripting())
+ {
+ // TODO: validate entries
+ // TODO: replace each entry with a full path based on the Virtual Channel DLL path
+ }
+
+ return E_NOTIMPL; // TODO
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::put_IconFile(BSTR rhs)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::put_IconIndex(long rhs)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::put_ContainerHandledFullScreen(long pContainerHandledFullScreen)
+ {
+ if(Outer()->IsSafeForScripting())
+ return S_FALSE;
+
+ return Outer()->SetProperty(Outer()->m_ContainerHandledFullScreen, pContainerHandledFullScreen);
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::get_ContainerHandledFullScreen(long * pContainerHandledFullScreen) const
+ {
+ return Outer()->GetProperty(Outer()->m_ContainerHandledFullScreen, pContainerHandledFullScreen);
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::put_DisableRdpdr(long pDisableRdpdr)
+ {
+ return Outer()->SetProperty(Outer()->m_DisableRdpdr, pDisableRdpdr);
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::get_DisableRdpdr(long * pDisableRdpdr) const
+ {
+ return Outer()->GetProperty(Outer()->m_DisableRdpdr, pDisableRdpdr);
+ }
+
+ /* IMsRdpClientAdvancedSettings */
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_SmoothScroll(long psmoothScroll)
+ {
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_SmoothScroll(long * psmoothScroll) const
+ {
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_AcceleratorPassthrough(long pacceleratorPassthrough)
+ {
+ return Outer()->SetProperty(Outer()->m_AcceleratorPassthrough, pacceleratorPassthrough);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_AcceleratorPassthrough(long * pacceleratorPassthrough) const
+ {
+ return Outer()->GetProperty(Outer()->m_AcceleratorPassthrough, pacceleratorPassthrough);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ShadowBitmap(long pshadowBitmap)
+ {
+ return Outer()->SetProperty(Outer()->m_ShadowBitmap, pshadowBitmap);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_ShadowBitmap(long * pshadowBitmap) const
+ {
+ return Outer()->GetProperty(Outer()->m_ShadowBitmap, pshadowBitmap);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_TransportType(long ptransportType)
+ {
+ // Reserved
+ return Outer()->SetProperty(Outer()->m_TransportType, ptransportType);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_TransportType(long * ptransportType) const
+ {
+ // Reserved
+ return Outer()->GetProperty(Outer()->m_TransportType, ptransportType);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_SasSequence(long psasSequence)
+ {
+ // Reserved
+ return Outer()->SetProperty(Outer()->m_SasSequence, psasSequence);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_SasSequence(long * psasSequence) const
+ {
+ // Reserved
+ return Outer()->GetProperty(Outer()->m_SasSequence, psasSequence);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_EncryptionEnabled(long pencryptionEnabled)
+ {
+ return Outer()->SetProperty(Outer()->m_EncryptionEnabled, pencryptionEnabled);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_EncryptionEnabled(long * pencryptionEnabled) const
+ {
+ return Outer()->GetProperty(Outer()->m_EncryptionEnabled, pencryptionEnabled);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_DedicatedTerminal(long pdedicatedTerminal)
+ {
+ return Outer()->SetProperty(Outer()->m_DedicatedTerminal, pdedicatedTerminal);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_DedicatedTerminal(long * pdedicatedTerminal) const
+ {
+ return Outer()->GetProperty(Outer()->m_DedicatedTerminal, pdedicatedTerminal);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RDPPort(long prdpPort)
+ {
+ if(prdpPort == 0 || prdpPort > 65535)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_RDPPort, prdpPort);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RDPPort(long * prdpPort) const
+ {
+ return Outer()->GetProperty(Outer()->m_RDPPort, prdpPort);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_EnableMouse(long penableMouse)
+ {
+ return S_FALSE; // TBD? implement?
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_EnableMouse(long * penableMouse) const
+ {
+ return S_FALSE; // TBD? implement?
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_DisableCtrlAltDel(long pdisableCtrlAltDel)
+ {
+ return Outer()->SetProperty(Outer()->m_DisableCtrlAltDel, pdisableCtrlAltDel);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_DisableCtrlAltDel(long * pdisableCtrlAltDel) const
+ {
+ return Outer()->GetProperty(Outer()->m_DisableCtrlAltDel, pdisableCtrlAltDel);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_EnableWindowsKey(long penableWindowsKey)
+ {
+ return Outer()->SetProperty(Outer()->m_EnableWindowsKey, penableWindowsKey);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_EnableWindowsKey(long * penableWindowsKey) const
+ {
+ return Outer()->GetProperty(Outer()->m_EnableWindowsKey, penableWindowsKey);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_DoubleClickDetect(long pdoubleClickDetect)
+ {
+ return Outer()->SetProperty(Outer()->m_DoubleClickDetect, pdoubleClickDetect);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_DoubleClickDetect(long * pdoubleClickDetect) const
+ {
+ return Outer()->GetProperty(Outer()->m_DoubleClickDetect, pdoubleClickDetect);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_MaximizeShell(long pmaximizeShell)
+ {
+ return Outer()->SetProperty(Outer()->m_MaximizeShell, pmaximizeShell);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_MaximizeShell(long * pmaximizeShell) const
+ {
+ return Outer()->GetProperty(Outer()->m_MaximizeShell, pmaximizeShell);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyFullScreen(long photKeyFullScreen)
+ {
+ return Outer()->SetProperty(Outer()->m_HotKeyFullScreen, photKeyFullScreen);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyFullScreen(long * photKeyFullScreen) const
+ {
+ return Outer()->GetProperty(Outer()->m_HotKeyFullScreen, photKeyFullScreen);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyCtrlEsc(long photKeyCtrlEsc)
+ {
+ return Outer()->SetProperty(Outer()->m_HotKeyCtrlEsc, photKeyCtrlEsc);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyCtrlEsc(long * photKeyCtrlEsc) const
+ {
+ return Outer()->GetProperty(Outer()->m_HotKeyCtrlEsc, photKeyCtrlEsc);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyAltEsc(long photKeyAltEsc)
+ {
+ return Outer()->SetProperty(Outer()->m_HotKeyAltEsc, photKeyAltEsc);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyAltEsc(long * photKeyAltEsc) const
+ {
+ return Outer()->GetProperty(Outer()->m_HotKeyAltEsc, photKeyAltEsc);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyAltTab(long photKeyAltTab)
+ {
+ return Outer()->SetProperty(Outer()->m_HotKeyAltTab, photKeyAltTab);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyAltTab(long * photKeyAltTab) const
+ {
+ return Outer()->GetProperty(Outer()->m_HotKeyAltTab, photKeyAltTab);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyAltShiftTab(long photKeyAltShiftTab)
+ {
+ return Outer()->SetProperty(Outer()->m_HotKeyAltShiftTab, photKeyAltShiftTab);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyAltShiftTab(long * photKeyAltShiftTab) const
+ {
+ return Outer()->GetProperty(Outer()->m_HotKeyAltShiftTab, photKeyAltShiftTab);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyAltSpace(long photKeyAltSpace)
+ {
+ return Outer()->SetProperty(Outer()->m_HotKeyAltSpace, photKeyAltSpace);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyAltSpace(long * photKeyAltSpace) const
+ {
+ return Outer()->GetProperty(Outer()->m_HotKeyAltSpace, photKeyAltSpace);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyCtrlAltDel(long photKeyCtrlAltDel)
+ {
+ return Outer()->SetProperty(Outer()->m_HotKeyCtrlAltDel, photKeyCtrlAltDel);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyCtrlAltDel(long * photKeyCtrlAltDel) const
+ {
+ return Outer()->GetProperty(Outer()->m_HotKeyCtrlAltDel, photKeyCtrlAltDel);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_orderDrawThreshold(long porderDrawThreshold)
+ {
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_orderDrawThreshold(long * porderDrawThreshold) const
+ {
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapCacheSize(long pbitmapCacheSize)
+ {
+ // NOTE: the upper bound of "32" for a field with a default value of 1500 seems to be a bug
+ if(pbitmapCacheSize < 0 || pbitmapCacheSize > 32)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_BitmapCacheSize, pbitmapCacheSize);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapCacheSize(long * pbitmapCacheSize) const
+ {
+ return Outer()->GetProperty(Outer()->m_BitmapCacheSize, pbitmapCacheSize);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapVirtualCacheSize(long pbitmapVirtualCacheSize)
+ {
+ if(pbitmapVirtualCacheSize < 0 || pbitmapVirtualCacheSize > 32)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_BitmapVirtualCacheSize, pbitmapVirtualCacheSize);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapVirtualCacheSize(long * pbitmapVirtualCacheSize) const
+ {
+ return Outer()->GetProperty(Outer()->m_BitmapVirtualCacheSize, pbitmapVirtualCacheSize);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ScaleBitmapCachesByBPP(long pbScale)
+ {
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_ScaleBitmapCachesByBPP(long * pbScale) const
+ {
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_NumBitmapCaches(long pnumBitmapCaches)
+ {
+ return Outer()->SetProperty(Outer()->m_NumBitmapCaches, pnumBitmapCaches);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_NumBitmapCaches(long * pnumBitmapCaches) const
+ {
+ return Outer()->GetProperty(Outer()->m_NumBitmapCaches, pnumBitmapCaches);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_CachePersistenceActive(long pcachePersistenceActive)
+ {
+ return Outer()->SetProperty(Outer()->m_CachePersistenceActive, pcachePersistenceActive);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_CachePersistenceActive(long * pcachePersistenceActive) const
+ {
+ return Outer()->GetProperty(Outer()->m_CachePersistenceActive, pcachePersistenceActive);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_PersistCacheDirectory(BSTR rhs)
+ {
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_brushSupportLevel(long pbrushSupportLevel)
+ {
+ return Outer()->SetProperty(Outer()->m_brushSupportLevel, pbrushSupportLevel);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_brushSupportLevel(long * pbrushSupportLevel) const
+ {
+ return Outer()->GetProperty(Outer()->m_brushSupportLevel, pbrushSupportLevel);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_minInputSendInterval(long pminInputSendInterval)
+ {
+ // TODO
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_minInputSendInterval(long * pminInputSendInterval) const
+ {
+ // TODO
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_InputEventsAtOnce(long pinputEventsAtOnce)
+ {
+ // TODO
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_InputEventsAtOnce(long * pinputEventsAtOnce) const
+ {
+ // TODO
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_maxEventCount(long pmaxEventCount)
+ {
+ // TODO
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_maxEventCount(long * pmaxEventCount) const
+ {
+ // TODO
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_keepAliveInterval(long pkeepAliveInterval)
+ {
+ if(pkeepAliveInterval && pkeepAliveInterval < 10)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_keepAliveInternal, pkeepAliveInterval);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_keepAliveInterval(long * pkeepAliveInterval) const
+ {
+ return Outer()->GetProperty(Outer()->m_keepAliveInternal, pkeepAliveInterval);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_shutdownTimeout(long pshutdownTimeout)
+ {
+ if(pshutdownTimeout >= 600)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_shutdownTimeout, pshutdownTimeout);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_shutdownTimeout(long * pshutdownTimeout) const
+ {
+ return Outer()->GetProperty(Outer()->m_shutdownTimeout, pshutdownTimeout);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_overallConnectionTimeout(long poverallConnectionTimeout)
+ {
+ if(poverallConnectionTimeout < 0 || poverallConnectionTimeout >= 600)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_overallConnectionTimeout, poverallConnectionTimeout);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_overallConnectionTimeout(long * poverallConnectionTimeout) const
+ {
+ return Outer()->GetProperty(Outer()->m_overallConnectionTimeout, poverallConnectionTimeout);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_singleConnectionTimeout(long psingleConnectionTimeout)
+ {
+ if(psingleConnectionTimeout >= 600)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_singleConnectionTimeout, psingleConnectionTimeout);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_singleConnectionTimeout(long * psingleConnectionTimeout) const
+ {
+ return Outer()->GetProperty(Outer()->m_singleConnectionTimeout, psingleConnectionTimeout);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_KeyboardType(long pkeyboardType)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_KeyboardType(long * pkeyboardType) const
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_KeyboardSubType(long pkeyboardSubType)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_KeyboardSubType(long * pkeyboardSubType) const
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_KeyboardFunctionKey(long pkeyboardFunctionKey)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_KeyboardFunctionKey(long * pkeyboardFunctionKey) const
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_WinceFixedPalette(long pwinceFixedPalette)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_WinceFixedPalette(long * pwinceFixedPalette) const
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ConnectToServerConsole(VARIANT_BOOL pConnectToConsole)
+ {
+ return Outer()->SetProperty(Outer()->m_ConnectToServerConsole, pConnectToConsole);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_ConnectToServerConsole(VARIANT_BOOL * pConnectToConsole) const
+ {
+ return Outer()->GetProperty(Outer()->m_ConnectToServerConsole, pConnectToConsole);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapPersistence(long pbitmapPersistence)
+ {
+ return put_BitmapPeristence(pbitmapPersistence);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapPersistence(long * pbitmapPersistence) const
+ {
+ return get_BitmapPeristence(pbitmapPersistence);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_MinutesToIdleTimeout(long pminutesToIdleTimeout)
+ {
+ if(pminutesToIdleTimeout > 240)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_MinutesToIdleTimeout, pminutesToIdleTimeout);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_MinutesToIdleTimeout(long * pminutesToIdleTimeout) const
+ {
+ return Outer()->GetProperty(Outer()->m_MinutesToIdleTimeout, pminutesToIdleTimeout);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_SmartSizing(VARIANT_BOOL pfSmartSizing)
+ {
+ return Outer()->SetProperty(Outer()->m_SmartSizing, pfSmartSizing);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_SmartSizing(VARIANT_BOOL * pfSmartSizing) const
+ {
+ return Outer()->GetProperty(Outer()->m_SmartSizing, pfSmartSizing);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RdpdrLocalPrintingDocName(BSTR pLocalPrintingDocName)
+ {
+ return Outer()->SetProperty(Outer()->m_RdpdrLocalPrintingDocName, pLocalPrintingDocName);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RdpdrLocalPrintingDocName(BSTR * pLocalPrintingDocName) const
+ {
+ return Outer()->GetProperty(Outer()->m_RdpdrLocalPrintingDocName, pLocalPrintingDocName);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RdpdrClipCleanTempDirString(BSTR clipCleanTempDirString)
+ {
+ return Outer()->SetProperty(Outer()->m_RdpdrClipCleanTempDirString, clipCleanTempDirString);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RdpdrClipCleanTempDirString(BSTR * clipCleanTempDirString) const
+ {
+ return Outer()->GetProperty(Outer()->m_RdpdrClipCleanTempDirString, clipCleanTempDirString);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RdpdrClipPasteInfoString(BSTR clipPasteInfoString)
+ {
+ return Outer()->SetProperty(Outer()->m_RdpdrClipPasteInfoString, clipPasteInfoString);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RdpdrClipPasteInfoString(BSTR * clipPasteInfoString) const
+ {
+ return Outer()->GetProperty(Outer()->m_RdpdrClipPasteInfoString, clipPasteInfoString);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ClearTextPassword(BSTR rhs)
+ {
+ return Outer()->put_ClearTextPassword(rhs);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_DisplayConnectionBar(VARIANT_BOOL pDisplayConnectionBar)
+ {
+ if(!pDisplayConnectionBar && Outer()->IsSafeForScripting())
+ return E_FAIL;
+
+ return Outer()->SetProperty(Outer()->m_DisplayConnectionBar, pDisplayConnectionBar);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_DisplayConnectionBar(VARIANT_BOOL * pDisplayConnectionBar) const
+ {
+ return Outer()->GetProperty(Outer()->m_DisplayConnectionBar, pDisplayConnectionBar);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_PinConnectionBar(VARIANT_BOOL pPinConnectionBar)
+ {
+ if(Outer()->IsSafeForScripting())
+ return E_NOTIMPL;
+
+ return Outer()->SetProperty(Outer()->m_PinConnectionBar, pPinConnectionBar);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_PinConnectionBar(VARIANT_BOOL * pPinConnectionBar) const
+ {
+ return Outer()->GetProperty(Outer()->m_PinConnectionBar, pPinConnectionBar);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_GrabFocusOnConnect(VARIANT_BOOL pfGrabFocusOnConnect)
+ {
+ return Outer()->SetProperty(Outer()->m_GrabFocusOnConnect, pfGrabFocusOnConnect);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_GrabFocusOnConnect(VARIANT_BOOL * pfGrabFocusOnConnect) const
+ {
+ return Outer()->GetProperty(Outer()->m_GrabFocusOnConnect, pfGrabFocusOnConnect);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_LoadBalanceInfo(BSTR pLBInfo)
+ {
+ return Outer()->SetProperty(Outer()->m_LoadBalanceInfo, pLBInfo);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_LoadBalanceInfo(BSTR * pLBInfo) const
+ {
+ return Outer()->GetProperty(Outer()->m_LoadBalanceInfo, pLBInfo);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RedirectDrives(VARIANT_BOOL pRedirectDrives)
+ {
+ return Outer()->SetProperty(Outer()->m_RedirectDrives, pRedirectDrives);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RedirectDrives(VARIANT_BOOL * pRedirectDrives) const
+ {
+ return Outer()->GetProperty(Outer()->m_RedirectDrives, pRedirectDrives);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RedirectPrinters(VARIANT_BOOL pRedirectPrinters)
+ {
+ return Outer()->SetProperty(Outer()->m_RedirectPrinters, pRedirectPrinters);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RedirectPrinters(VARIANT_BOOL * pRedirectPrinters) const
+ {
+ return Outer()->GetProperty(Outer()->m_RedirectPrinters, pRedirectPrinters);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RedirectPorts(VARIANT_BOOL pRedirectPorts)
+ {
+ return Outer()->SetProperty(Outer()->m_RedirectPorts, pRedirectPorts);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RedirectPorts(VARIANT_BOOL * pRedirectPorts) const
+ {
+ return Outer()->GetProperty(Outer()->m_RedirectPorts, pRedirectPorts);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RedirectSmartCards(VARIANT_BOOL pRedirectSmartCards)
+ {
+ return Outer()->SetProperty(Outer()->m_RedirectSmartCards, pRedirectSmartCards);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RedirectSmartCards(VARIANT_BOOL * pRedirectSmartCards) const
+ {
+ return Outer()->GetProperty(Outer()->m_RedirectSmartCards, pRedirectSmartCards);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapVirtualCache16BppSize(long pBitmapVirtualCache16BppSize)
+ {
+ if(pBitmapVirtualCache16BppSize < 0 || pBitmapVirtualCache16BppSize > 32)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_BitmapVirtualCache16BppSize, pBitmapVirtualCache16BppSize);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapVirtualCache16BppSize(long * pBitmapVirtualCache16BppSize) const
+ {
+ return Outer()->GetProperty(Outer()->m_BitmapVirtualCache16BppSize, pBitmapVirtualCache16BppSize);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapVirtualCache24BppSize(long pBitmapVirtualCache24BppSize)
+ {
+ if(pBitmapVirtualCache24BppSize < 0 || pBitmapVirtualCache24BppSize > 32)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_BitmapVirtualCache24BppSize, pBitmapVirtualCache24BppSize);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapVirtualCache24BppSize(long * pBitmapVirtualCache24BppSize) const
+ {
+ return Outer()->GetProperty(Outer()->m_BitmapVirtualCache24BppSize, pBitmapVirtualCache24BppSize);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_PerformanceFlags(long pDisableList)
+ {
+ return Outer()->SetProperty(Outer()->m_PerformanceFlags, pDisableList);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_PerformanceFlags(long * pDisableList) const
+ {
+ return Outer()->GetProperty(Outer()->m_PerformanceFlags, pDisableList);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ConnectWithEndpoint(VARIANT * rhs)
+ {
+ // TBD? the Microsoft client implements this, but what does it mean?
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_NotifyTSPublicKey(VARIANT_BOOL pfNotify)
+ {
+ return Outer()->SetProperty(Outer()->m_NotifyTSPublicKey, pfNotify);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_NotifyTSPublicKey(VARIANT_BOOL * pfNotify) const
+ {
+ return Outer()->GetProperty(Outer()->m_NotifyTSPublicKey, pfNotify);
+ }
+
+ /* IMsRdpClientAdvancedSettings2 */
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::get_CanAutoReconnect(VARIANT_BOOL * pfCanAutoReconnect) const
+ {
+ return E_NOTIMPL; // TODO
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::put_EnableAutoReconnect(VARIANT_BOOL pfEnableAutoReconnect)
+ {
+ return Outer()->SetProperty(Outer()->m_EnableAutoReconnect, pfEnableAutoReconnect);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::get_EnableAutoReconnect(VARIANT_BOOL * pfEnableAutoReconnect) const
+ {
+ return Outer()->GetProperty(Outer()->m_EnableAutoReconnect, pfEnableAutoReconnect);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::put_MaxReconnectAttempts(long pMaxReconnectAttempts)
+ {
+ if(pMaxReconnectAttempts < 0 || pMaxReconnectAttempts > 200)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_MaxReconnectAttempts, pMaxReconnectAttempts);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::get_MaxReconnectAttempts(long * pMaxReconnectAttempts) const
+ {
+ return Outer()->GetProperty(Outer()->m_MaxReconnectAttempts, pMaxReconnectAttempts);
+ }
+
+ /* IMsRdpClientAdvancedSettings3 */
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings3::put_ConnectionBarShowMinimizeButton(VARIANT_BOOL pfShowMinimize)
+ {
+ return Outer()->SetProperty(Outer()->m_ConnectionBarShowMinimizeButton, pfShowMinimize);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings3::get_ConnectionBarShowMinimizeButton(VARIANT_BOOL * pfShowMinimize) const
+ {
+ return Outer()->GetProperty(Outer()->m_ConnectionBarShowMinimizeButton, pfShowMinimize);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings3::put_ConnectionBarShowRestoreButton(VARIANT_BOOL pfShowRestore)
+ {
+ return Outer()->SetProperty(Outer()->m_ConnectionBarShowRestoreButton, pfShowRestore);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings3::get_ConnectionBarShowRestoreButton(VARIANT_BOOL * pfShowRestore) const
+ {
+ return Outer()->GetProperty(Outer()->m_ConnectionBarShowRestoreButton, pfShowRestore);
+ }
+
+ /* IMsRdpClientAdvancedSettings4 */
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings4::put_AuthenticationLevel(unsigned int puiAuthLevel)
+ {
+ // TODO: this isn't implemented in rdesktop yet...
+ return Outer()->SetProperty(Outer()->m_AuthenticationLevel, puiAuthLevel);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings4::get_AuthenticationLevel(unsigned int * puiAuthLevel) const
+ {
+ return Outer()->GetProperty(Outer()->m_AuthenticationLevel, puiAuthLevel);
+ }
+ }
+ m_advancedSettings;
+
+ template HRESULT GetAdvancedSettings(Interface ** ppAdvSettings)
+ {
+ addRef();
+ *ppAdvSettings = &m_advancedSettings;
+ return S_OK;
+ }
+
+ /* Secured settings wrapper */
+ friend class SecuredSettings;
+
+ class SecuredSettings SEALED_: public MSTSCLib::IMsRdpClientSecuredSettings
+ {
+ private:
+ RdpClient * Outer()
+ {
+ return InnerToOuter(this);
+ }
+
+ const RdpClient * Outer() const
+ {
+ return InnerToOuter(this);
+ }
+
+ /* IDispatch type information */
+ ITypeInfo * m_dispTypeInfo;
+
+ HRESULT LoadDispTypeInfo()
+ {
+ if(m_dispTypeInfo)
+ return S_OK;
+
+ HRESULT hr = Outer()->LoadTypeLibrary();
+
+ if(FAILED(hr))
+ return hr;
+
+ assert(MSTSCLib::IID_IMsRdpClientSecuredSettings == MSTSCLib_Redist::IID_IMsRdpClientSecuredSettings);
+
+ hr = Outer()->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;
+ Outer()->addRef();
+ return S_OK;
+ }
+ else
+ {
+ *ppvObject = NULL;
+ return E_NOINTERFACE;
+ }
+ }
+
+ virtual STDMETHODIMP_(ULONG) IUnknown::AddRef()
+ {
+ return Outer()->addRef();
+ }
+
+ virtual STDMETHODIMP_(ULONG) IUnknown::Release()
+ {
+ return Outer()->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 Outer()->SetProperty(Outer()->m_StartProgram, pStartProgram);
+ }
+
+ virtual STDMETHODIMP IMsTscSecuredSettings::get_StartProgram(BSTR * pStartProgram) const
+ {
+ return Outer()->GetProperty(Outer()->m_StartProgram, pStartProgram);
+ }
+
+ virtual STDMETHODIMP IMsTscSecuredSettings::put_WorkDir(BSTR pWorkDir)
+ {
+ return Outer()->SetProperty(Outer()->m_WorkDir, pWorkDir);
+ }
+
+ virtual STDMETHODIMP IMsTscSecuredSettings::get_WorkDir(BSTR * pWorkDir) const
+ {
+ return Outer()->GetProperty(Outer()->m_WorkDir, pWorkDir);
+ }
+
+ virtual STDMETHODIMP IMsTscSecuredSettings::put_FullScreen(long pfFullScreen)
+ {
+ return Outer()->put_FullScreen(!!pfFullScreen);
+ }
+
+ virtual STDMETHODIMP IMsTscSecuredSettings::get_FullScreen(long * pfFullScreen) const
+ {
+ return Outer()->GetProperty(Outer()->m_FullScreen, pfFullScreen);
+ }
+
+ /* IMsRdpClientSecuredSettings */
+ virtual STDMETHODIMP IMsRdpClientSecuredSettings::put_KeyboardHookMode(long pkeyboardHookMode)
+ {
+ if(pkeyboardHookMode < 0 || pkeyboardHookMode > 2)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_KeyboardHookMode, pkeyboardHookMode);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientSecuredSettings::get_KeyboardHookMode(long * pkeyboardHookMode) const
+ {
+ return Outer()->GetProperty(Outer()->m_KeyboardHookMode, pkeyboardHookMode);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientSecuredSettings::put_AudioRedirectionMode(long pAudioRedirectionMode)
+ {
+ if(pAudioRedirectionMode < 0 || pAudioRedirectionMode > 2)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_AudioRedirectionMode, pAudioRedirectionMode);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientSecuredSettings::get_AudioRedirectionMode(long * pAudioRedirectionMode) const
+ {
+ return Outer()->GetProperty(Outer()->m_AudioRedirectionMode, pAudioRedirectionMode);
+ }
+ }
+ m_securedSettings;
+
+ template HRESULT GetSecuredSettings(Interface ** ppSecuredSettings)
+ {
+ if(!m_SecuredSettingsEnabled)
+ return E_FAIL;
+
+ addRef();
+ *ppSecuredSettings = &m_securedSettings;
+ return S_OK;
+ }
+
+ /* Type library loading */
+ HRESULT LoadTypeLibrary()
+ {
+ if(m_typeLib)
+ return S_OK;
+
+ // Get the DLL name of the ActiveX control
+ WCHAR szPath[MAX_PATH + 1];
+ DWORD cchPathLen = GetModuleFileNameW(GetCurrentModule(), szPath, ARRAYSIZE(szPath) - 1);
+
+ if(cchPathLen == 0)
+ return HRESULT_FROM_WIN32(GetLastError());
+
+ if(cchPathLen > ((ARRAYSIZE(szPath) - 1) - 2))
+ return E_FAIL;
+
+ // Append the resource id of the type library
+ assert(m_typeLibIndex < 10);
+
+ szPath[cchPathLen + 0] = L'\\';
+ szPath[cchPathLen + 1] = static_cast(L'0' + m_typeLibIndex);
+ szPath[cchPathLen + 2] = 0;
+
+ // Load the type library
+ 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;
+
+ assert(MSTSCLib::IID_IMsRdpClient4 == MSTSCLib_Redist::IID_IMsRdpClient4);
+
+ 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);
+ }
+
+ static RdpClient * InnerToOuter(RDPCLIENT * innerThis)
+ {
+ return CONTAINING_RECORD(innerThis, RdpClient, m_protocolState);
+ }
+
+ static const RdpClient * InnerToOuter(const RdpClientInner * innerThis)
+ {
+ return CONTAINING_RECORD(innerThis, RdpClient, m_inner);
+ }
+
+ static const RdpClient * InnerToOuter(const AdvancedSettings * innerThis)
+ {
+ return CONTAINING_RECORD(innerThis, RdpClient, m_advancedSettings);
+ }
+
+ static const RdpClient * InnerToOuter(const SecuredSettings * innerThis)
+ {
+ return CONTAINING_RECORD(innerThis, RdpClient, m_securedSettings);
+ }
+
+ static const RdpClient * InnerToOuter(const RDPCLIENT * innerThis)
+ {
+ return CONTAINING_RECORD(innerThis, RdpClient, m_protocolState);
+ }
+
+ RdpClientUI * GetUI() const
+ {
+ assert(m_clientUI);
+ return m_clientUI;
+ }
+
+ /* Glue for rdesktop-core */
+public:
+ static bool OnPublicKey(RDPCLIENT * This, unsigned char * key, unsigned int key_size)
+ {
+ return InnerToOuter(This)->OnPublicKey(key, key_size);
+ }
+
+ static void OnLogon(RDPCLIENT * This)
+ {
+ return InnerToOuter(This)->OnLogon();
+ }
+
+ static bool OnRedirect
+ (
+ RDPCLIENT * This,
+ uint32 flags,
+ uint32 server_len,
+ wchar_t * server,
+ uint32 cookie_len,
+ char * cookie,
+ uint32 username_len,
+ wchar_t * username,
+ uint32 domain_len,
+ wchar_t * domain,
+ uint32 password_len,
+ wchar_t * password
+ )
+ {
+ return InnerToOuter(This)->OnRedirect
+ (
+ flags,
+ server_len,
+ server,
+ cookie_len,
+ cookie,
+ username_len,
+ username,
+ domain_len,
+ domain,
+ password_len,
+ password
+ );
+ }
+
+private:
+ bool OnPublicKey(unsigned char * key, unsigned int key_size)
+ {
+ HRESULT hr = FireReceivedTSPublicKey(key, key_size);
+
+ if(FAILED(hr))
+ {
+ m_protocolState.disconnect_reason = 262;
+ return false;
+ }
+
+ return hr == S_OK;
+ }
+
+ void OnLogon()
+ {
+ m_loggedIn = true;
+ FireLoginComplete();
+ }
+
+ bool OnRedirect
+ (
+ uint32 flags,
+ uint32 server_len,
+ wchar_t * server,
+ uint32 cookie_len,
+ char * cookie,
+ uint32 username_len,
+ wchar_t * username,
+ uint32 domain_len,
+ wchar_t * domain,
+ uint32 password_len,
+ wchar_t * password
+ )
+ {
+ assert(m_Connected);
+ assert(!InsideApartment());
+ assert(IsWindow(m_controlWindow));
+
+ RedirectArguments redirectArgs =
+ {
+ flags,
+ server_len,
+ server,
+ cookie_len,
+ cookie,
+ username_len,
+ username,
+ domain_len,
+ domain,
+ password_len,
+ password
+ };
+
+ return SendMessage(m_controlWindow, RDPC_WM_REDIRECT, 0, reinterpret_cast(&redirectArgs)) == 0;
+ }
+
+private:
+ static DWORD WINAPI ProtocolLoopThreadProc(LPVOID lpParam)
+ {
+ static_cast(lpParam)->ProtocolLoop();
+ return 0;
+ }
+
+ static VOID CALLBACK ConnectionTimerAPC(LPVOID, DWORD, DWORD)
+ {
+ }
+
+ // FIXME: various potential inconsistencies due to lack of detailed documentation of expected semantics
+ void ProtocolLoop()
+ {
+ HANDLE waitingReconnection = NULL;
+
+ // Retrieve the local hostname to be passed to the server
+ WCHAR hostname[MAX_COMPUTERNAME_LENGTH + 1];
+ DWORD hostnameLen = ARRAYSIZE(hostname);
+
+ if(!GetComputerNameW(hostname, &hostnameLen))
+ hostname[0] = 0;
+
+ // Set some connection flags
+ uint32 flags = RDP_LOGON_NORMAL;
+
+ if(m_Compress)
+ flags |= RDP_LOGON_COMPRESSION | RDP_LOGON_COMPRESSION2;
+
+ if(m_AudioRedirectionMode == 1)
+ flags |= RDP_LOGON_LEAVE_AUDIO;
+
+ if(m_ClearTextPassword)
+ flags |= RDP_LOGON_AUTO;
+
+ // Notify the container that the connection process is beginning now
+ FireConnecting();
+
+ // Set the overall connection timer, if a timeout is set
+ // BUGBUG: the timeout semantics are ambiguous and have been most probably misinterpreted
+ HANDLE overallConnectionTimer = NULL;
+ LARGE_INTEGER overallTimeout;
+
+ if(m_overallConnectionTimeout)
+ {
+ overallTimeout.QuadPart = - ((m_overallConnectionTimeout * 1000 * 1000 * 1000) / 100);
+
+ overallConnectionTimer = CreateWaitableTimer(NULL, FALSE, NULL);
+
+ if(overallConnectionTimer == NULL)
+ goto l_Disconnect;
+ }
+
+ if(overallConnectionTimer)
+ SetWaitableTimer(overallConnectionTimer, &overallTimeout, 0, ConnectionTimerAPC, NULL, FALSE);
+
+ // Initial connection
+ BOOL disconnected = rdp_connect
+ (
+ &m_protocolState,
+ m_Server,
+ flags,
+ m_UserName,
+ m_Domain,
+ m_ClearTextPassword,
+ m_StartProgram,
+ m_WorkDir,
+ hostname,
+ m_LoadBalanceInfo
+ );
+
+ if(overallConnectionTimer)
+ CancelWaitableTimer(overallConnectionTimer);
+
+ if(disconnected)
+ goto l_Disconnect;
+
+ // TODO: set the disconnect reason for every instance in which we abort the loop
+ for(;;)
+ {
+ BOOL deactivated = False;
+ uint32 extendedDisconnectReason = 0;
+
+ m_actuallyConnected = true;
+
+ // Notify the container of the successful connection
+ FireConnected();
+
+ // Main protocol loop
+ m_loggedIn = false;
+ rdp_main_loop(&m_protocolState, &deactivated, &extendedDisconnectReason);
+ rdp_disconnect(&m_protocolState);
+
+ m_actuallyConnected = false;
+
+ // Redirection
+ // BUGBUG: redirection is very messy and probably this implementation is not "canonical"
+ if(m_protocolState.redirect)
+ {
+ m_protocolState.redirect = False;
+ rdp_reset_state(&m_protocolState);
+
+ // TODO: reset connection parameters
+ // This has to be done in the main thread, so use SendMessage on the control window
+
+ flags |= RDP_LOGON_AUTO;
+
+ // retry
+ continue;
+ }
+
+ // Disconnection
+ m_ExtendedDisconnectReason = static_cast(extendedDisconnectReason);
+
+ // Clean disconnection
+ if(deactivated)
+ break;
+
+ BOOL success;
+
+ long autoReconnections = 0;
+ long totalReconnections = 0;
+
+ // Reconnection
+ // BUGBUG: reconnection semantics may not be entirely accurate
+ do
+ {
+ ++ totalReconnections;
+
+ // ask the container whether we should reconnect
+ long reconnectMode = FireAutoReconnecting(m_protocolState.disconnect_reason, totalReconnections);
+
+ // do not reconnect
+ if(reconnectMode == MSTSCLib::autoReconnectContinueStop)
+ goto l_Disconnect;
+
+ // the container will reconnect or abort manually
+ if(reconnectMode == MSTSCLib::autoReconnectContinueManual)
+ {
+ assert(!m_reconnectAborted);
+ assert(m_protocolThreadWaitingReconnection == NULL);
+
+ if(waitingReconnection == NULL)
+ {
+ waitingReconnection = CreateEvent(NULL, TRUE, FALSE, NULL);
+
+ if(waitingReconnection == NULL)
+ // TODO: fatal error
+ goto l_Disconnect;
+ }
+
+ m_protocolThreadWaitingReconnection = waitingReconnection;
+
+ WaitForSingleObject(waitingReconnection, INFINITE);
+
+ m_protocolThreadWaitingReconnection = NULL;
+
+ if(m_reconnectAborted)
+ {
+ // FIXME? do we set the disconnection status here?
+ goto l_Disconnect;
+ }
+ }
+ // reconnect automatically
+ else
+ {
+ // automatic reconnection is disabled
+ if(m_EnableAutoReconnect)
+ break;
+
+ // too many consecutive automatic reconnections
+ if(autoReconnections == m_MaxReconnectAttempts)
+ break;
+
+ ++ autoReconnections;
+ }
+
+ if(overallConnectionTimer)
+ SetWaitableTimer(overallConnectionTimer, &overallTimeout, 0, ConnectionTimerAPC, NULL, FALSE);
+
+ // Reconnection
+ success = rdp_reconnect
+ (
+ &m_protocolState,
+ m_Server,
+ flags,
+ m_UserName,
+ m_Domain,
+ m_ClearTextPassword,
+ m_StartProgram,
+ m_WorkDir,
+ hostname,
+ m_LoadBalanceInfo
+ );
+
+ if(overallConnectionTimer)
+ CancelWaitableTimer(overallConnectionTimer);
+ }
+ while(!success);
+ }
+
+l_Disconnect:
+ // Disconnected
+ FireDisconnected(m_protocolState.disconnect_reason);
+
+ if(overallConnectionTimer)
+ CloseHandle(overallConnectionTimer);
+ }
+
+ void JoinProtocolThread()
+ {
+ assert(m_protocolThread);
+ WaitForSingleObject(m_protocolThread, INFINITE);
+ CloseHandle(m_protocolThread);
+ m_protocolThread = NULL;
+ }
+
+ void TerminateProtocolThread()
+ {
+ assert(m_protocolThread);
+
+ // wake it up if it's waiting for a manual reconnection
+ if(m_protocolThreadWaitingReconnection)
+ {
+ assert(!m_reconnectAborted);
+ m_reconnectAborted = true;
+ SetEvent(m_protocolThreadWaitingReconnection);
+ }
+ // otherwise, attempt to interrupt any current blocking operation
+ else
+ {
+ // shutdown(m_protocolState.tcp.sock, SD_BOTH); // TBD: maybe in the future?
+ QueueUserAPC(DisconnectAPC, m_protocolThread, 0);
+ }
+
+ assert(m_protocolThreadWaitingReconnection == NULL);
+ }
+
+ void PerformDisconnect(long reason)
+ {
+ assert(InsideApartment());
+ assert(m_Connected);
+
+ // TODO: notify virtual channels
+
+ // TODO: do any other disconnection work here...
+
+ // Put the control in the disconnected state
+ m_Connected = false;
+ m_loggedIn = false;
+
+ // Notify the container
+ VARIANTARG arg = { };
+
+ arg.vt = VT_I4;
+ arg.lVal = reason;
+
+ FireEventInsideApartment(4, &arg, 1);
+ }
+
+public:
+ /* Startup initialization */
+ static BOOL Startup()
+ {
+ if(!RdpClientUI::Startup())
+ return FALSE;
+
+ WNDCLASSEX wcex = { sizeof(wcex) };
+
+ wcex.style = CS_HREDRAW | CS_VREDRAW;
+ wcex.lpfnWndProc = ControlWindowProc;
+ wcex.hInstance = GetCurrentModule();
+ wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
+ wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
+ wcex.lpszClassName = TEXT("MissTosca_Control");
+
+ return RegisterClassEx(&wcex);
+ }
+
+ static void Shutdown()
+ {
+ UnregisterClass(TEXT("MissTosca_Control"), GetCurrentModule());
+ }
+
+ /* Class factory */
+ static HRESULT CreateInstance(REFCLSID rclsid, unsigned libIndex, IUnknown * punkOuter, REFIID riid, void ** ppObj)
+ {
+ RdpClient * obj = new RdpClient(rclsid, libIndex, punkOuter);
+
+ if(obj == NULL)
+ return E_OUTOFMEMORY;
+
+ HRESULT hr = obj->m_inner.QueryInterface(riid, ppObj);
+
+ if(FAILED(hr))
+ {
+ delete obj;
+ return hr;
+ }
+
+ assert(obj->m_refCount == 1);
+ assert(*ppObj != NULL);
+
+ return S_OK;
+ }
+
+private:
+ /* Connection point enumerator */
+ class CEnumConnectionPoints: public IEnumConnectionPoints
+ {
+ private:
+ LONG m_refCount;
+ IConnectionPoint * m_cp;
+ bool m_done;
+
+ public:
+ CEnumConnectionPoints(IConnectionPoint * cp): m_refCount(1), m_cp(cp), m_done(false)
+ {
+ assert(m_cp);
+ m_cp->AddRef();
+ }
+
+ CEnumConnectionPoints(const CEnumConnectionPoints& ecp): m_refCount(1), m_cp(ecp.m_cp), m_done(ecp.m_done)
+ {
+ assert(m_cp);
+ m_cp->AddRef();
+ }
+
+ ~CEnumConnectionPoints()
+ {
+ assert(m_cp);
+ m_cp->Release();
+ }
+
+ virtual STDMETHODIMP QueryInterface(REFIID riid, void ** ppvObject)
+ {
+ if(riid == IID_IUnknown || riid == IID_IEnumConnectionPoints)
+ {
+ *ppvObject = this;
+ return S_OK;
+ }
+ else
+ {
+ *ppvObject = NULL;
+ return E_NOINTERFACE;
+ }
+ }
+
+ virtual STDMETHODIMP_(ULONG) AddRef()
+ {
+ return InterlockedIncrement(&m_refCount);
+ }
+
+ virtual STDMETHODIMP_(ULONG) Release()
+ {
+ LONG n = InterlockedDecrement(&m_refCount);
+
+ if(n == 0)
+ delete this;
+
+ return n;
+ }
+
+ virtual STDMETHODIMP Next(ULONG cConnections, LPCONNECTIONPOINT * ppCP, ULONG * pcFetched)
+ {
+ if(cConnections == 0 || m_done)
+ return S_FALSE;
+
+ m_done = true;
+ m_cp->AddRef();
+ *ppCP = m_cp;
+ *pcFetched = 1;
+
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP Skip(ULONG cConnections)
+ {
+ if(cConnections == 0)
+ return S_OK;
+
+ if(cConnections == 1 && !m_done)
+ {
+ m_done = true;
+ return S_OK;
+ }
+
+ assert(cConnections > 1 || m_done);
+
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP Reset()
+ {
+ m_done = false;
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP Clone(IEnumConnectionPoints ** ppEnum)
+ {
+ if(ppEnum == NULL)
+ return E_POINTER;
+
+ *ppEnum = new CEnumConnectionPoints(*this);
+
+ if(*ppEnum == NULL)
+ return E_OUTOFMEMORY;
+
+ return S_OK;
+ }
+ };
+
+ /* Pay no attention, ActiveX glue... */
+ LRESULT ControlWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
+ {
+ switch(uMsg)
+ {
+ case WM_SIZE:
+ {
+ // TODO: resize UI
+ }
+
+ return 0;
+
+ case WM_PAINT:
+ {
+ LPCWSTR text = NULL;
+
+ if(!m_Connected)
+ text = m_DisconnectedText;
+ else if(m_actuallyConnected)
+ text = m_ConnectedStatusText;
+ else
+ text = m_ConnectingText;
+
+ RECT clientRect;
+ GetClientRect(m_controlWindow, &clientRect);
+
+ PAINTSTRUCT ps;
+ HDC hdc = BeginPaint(m_controlWindow, &ps);
+
+ SetBkColor(hdc, GetSysColor(COLOR_WINDOW));
+ SetTextColor(hdc, GetSysColor(COLOR_WINDOWTEXT));
+ SelectObject(hdc, GetStockObject(SYSTEM_FONT));
+
+ RECT textRect = clientRect;
+
+ DrawTextW
+ (
+ hdc,
+ text,
+ -1,
+ &textRect,
+ DT_CENTER | DT_EDITCONTROL | DT_END_ELLIPSIS | DT_NOPREFIX | DT_WORDBREAK | DT_CALCRECT
+ );
+
+ if(textRect.right > clientRect.right)
+ textRect.right = clientRect.right;
+
+ if(textRect.bottom > clientRect.bottom)
+ textRect.bottom = clientRect.bottom;
+
+ textRect.left = (clientRect.right - textRect.right) / 2;
+ textRect.right += textRect.left;
+ textRect.top = (clientRect.bottom - textRect.bottom) / 2;
+ textRect.bottom += textRect.top;
+
+ DrawTextW
+ (
+ hdc,
+ text,
+ -1,
+ &textRect,
+ DT_CENTER | DT_EDITCONTROL | DT_END_ELLIPSIS | DT_NOPREFIX | DT_WORDBREAK
+ );
+
+ EndPaint(m_controlWindow, &ps);
+ }
+
+ return 0;
+
+ default:
+ {
+ LRESULT result;
+
+ if(HandleEvent(uMsg, wParam, lParam, result))
+ return result;
+ }
+
+ break;
+ }
+
+ return DefWindowProc(m_controlWindow, uMsg, wParam, lParam);
+ }
+
+ static LRESULT CALLBACK ControlWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+ {
+ if(uMsg == WM_CREATE)
+ {
+ SetWindowLongPtr
+ (
+ hwnd,
+ GWLP_USERDATA,
+ (LONG_PTR)reinterpret_cast(lParam)->lpCreateParams
+ );
+ }
+
+ RdpClient * Self = reinterpret_cast(GetWindowLongPtr(hwnd, GWLP_USERDATA));
+ assert(Self);
+
+ return Self->ControlWindowProc(uMsg, wParam, lParam);
+ }
+
+ HRESULT CreateControlWindow(HWND hwndParent)
+ {
+ m_controlWindow = CreateWindow
+ (
+ TEXT("MissTosca_Control"),
+ NULL,
+ WS_CHILD | WS_CLIPCHILDREN,
+ CW_USEDEFAULT,
+ CW_USEDEFAULT,
+ CW_USEDEFAULT,
+ CW_USEDEFAULT,
+ hwndParent,
+ NULL,
+ GetCurrentModule(),
+ this
+ );
+
+ if(m_controlWindow == NULL)
+ return HRESULT_FROM_WIN32(GetLastError());
+
+ m_UIParentWindowHandle = m_controlWindow;
+ return S_OK;
+ }
+
+ HRESULT DestroyControlWindow()
+ {
+ if(m_controlWindow == NULL)
+ return S_FALSE;
+
+ HWND controlWindow = NULL;
+ std::swap(controlWindow, m_controlWindow);
+ DestroyWindow(controlWindow);
+ return S_OK;
+ }
+
+ HRESULT Activate(LONG iVerb, IOleClientSite * pActiveSite, HWND hwndParent, LPCRECT lprcPosRect)
+ {
+ if(pActiveSite == NULL)
+ pActiveSite = m_clientSite;
+
+ if(pActiveSite == NULL)
+ return E_FAIL;
+
+ // TODO: store this until we are closed or deactivated
+ IOleInPlaceSite * site;
+
+ HRESULT hr = pActiveSite->QueryInterface(&site);
+
+ if(FAILED(hr))
+ return hr;
+
+ IOleInPlaceFrame * frame = NULL;
+ IOleInPlaceUIWindow * uiWindow = NULL;
+
+ for(;;)
+ {
+ hr = site->CanInPlaceActivate();
+
+ if(hr == S_FALSE)
+ hr = E_FAIL;
+
+ if(FAILED(hr))
+ break;
+
+ site->OnInPlaceActivate();
+
+ if(hwndParent == NULL)
+ {
+ hr = site->GetWindow(&hwndParent);
+
+ if(FAILED(hr))
+ break;
+ }
+
+ RECT rcPos;
+ RECT rcClip;
+ OLEINPLACEFRAMEINFO frameInfo = { sizeof(frameInfo) };
+
+ site->GetWindowContext(&frame, &uiWindow, &rcPos, &rcClip, &frameInfo);
+
+ if(lprcPosRect == NULL)
+ lprcPosRect = &rcPos;
+
+ if(m_controlWindow)
+ ShowWindow(m_controlWindow, SW_SHOW);
+ else
+ {
+ hr = CreateControlWindow(hwndParent);
+
+ if(FAILED(hr))
+ break;
+ }
+
+ SetObjectRects(lprcPosRect, &rcClip);
+
+ // UI activation
+ if((iVerb == OLEIVERB_PRIMARY || iVerb == OLEIVERB_UIACTIVATE) && !m_uiActive)
+ {
+ m_uiActive = true;
+
+ hr = site->OnUIActivate();
+
+ if(FAILED(hr))
+ break;
+
+ SetWindowPos
+ (
+ m_controlWindow,
+ NULL,
+ lprcPosRect->left,
+ lprcPosRect->top,
+ lprcPosRect->right - lprcPosRect->left,
+ lprcPosRect->bottom - lprcPosRect->top,
+ SWP_SHOWWINDOW
+ );
+
+ if(frame)
+ {
+ frame->SetActiveObject(this, NULL);
+ frame->SetBorderSpace(NULL);
+ }
+
+ if(uiWindow)
+ {
+ uiWindow->SetActiveObject(this, NULL);
+ uiWindow->SetBorderSpace(NULL);
+ }
+ }
+
+ break;
+ }
+
+ if(uiWindow)
+ uiWindow->Release();
+
+ if(frame)
+ frame->Release();
+
+ site->Release();
+
+ if(SUCCEEDED(hr))
+ pActiveSite->ShowObject();
+
+ return hr;
+ }
+
+public:
+ /* IUnknown */
+ /*
+ 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 */
+ 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
+ );
+ }
+
+ /* IConnectionPoint */
+ virtual STDMETHODIMP GetConnectionInterface(IID * pIID)
+ {
+ if(pIID == NULL)
+ return E_POINTER;
+
+ *pIID = MSTSCLib::DIID_IMsTscAxEvents;
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP GetConnectionPointContainer(IConnectionPointContainer ** ppCPC)
+ {
+ if(ppCPC == NULL)
+ return E_POINTER;
+
+ addRef();
+ *ppCPC = this;
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP Advise(IUnknown * pUnkSink, DWORD * pdwCookie)
+ {
+ MSTSCLib::IMsTscAxEvents * sink;
+
+ if(FAILED(pUnkSink->QueryInterface(&sink)))
+ return CONNECT_E_CANNOTCONNECT;
+
+ MSTSCLib::IMsTscAxEvents ** sinks = GetSinks();
+ DWORD cookie = 0;
+
+ if(m_EventSinksCount)
+ {
+ bool found = false;
+
+ for(size_t i = 0; i < m_EventSinksCount; ++ i)
+ {
+ found = (sinks[i] == NULL);
+
+ if(found)
+ {
+ cookie = static_cast(i);
+ break;
+ }
+ }
+
+ if(!found)
+ {
+ MSTSCLib::IMsTscAxEvents ** newSinks = new MSTSCLib::IMsTscAxEvents *[m_EventSinksCount + 1];
+
+ if(newSinks == NULL)
+ {
+ sink->Release();
+ return E_OUTOFMEMORY;
+ }
+
+ std::copy(sinks, sinks + m_EventSinksCount, newSinks);
+
+ m_EventSinks = newSinks;
+ sinks = newSinks;
+
+ cookie = static_cast(m_EventSinksCount);
+ }
+ }
+
+ sinks[cookie] = sink;
+ *pdwCookie = cookie;
+
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP Unadvise(DWORD dwCookie)
+ {
+ MSTSCLib::IMsTscAxEvents ** sinks = GetSinks();
+
+ if(dwCookie >= m_EventSinksCount || sinks[dwCookie] == NULL)
+ return CONNECT_E_NOCONNECTION;
+
+ sinks[dwCookie]->Release();
+ sinks[dwCookie] = NULL;
+
+ // BUGBUG: the array currently grows forever. Trim it whenever possible
+
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP EnumConnections(IEnumConnections ** ppEnum)
+ {
+ // I see no real value in this
+ return E_NOTIMPL;
+ }
+
+ /* IConnectionPointContainer */
+ virtual STDMETHODIMP IConnectionPointContainer::EnumConnectionPoints(IEnumConnectionPoints ** ppEnum)
+ {
+ *ppEnum = new CEnumConnectionPoints(this);
+
+ if(*ppEnum == NULL)
+ return E_OUTOFMEMORY;
+
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IConnectionPointContainer::FindConnectionPoint(REFIID riid, IConnectionPoint ** ppCP)
+ {
+ if(riid != MSTSCLib::DIID_IMsTscAxEvents)
+ return CONNECT_E_NOCONNECTION;
+
+ addRef();
+ *ppCP = this;
+
+ return S_OK;
+ }
+
+ /* 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 */
+ virtual STDMETHODIMP IObjectSafety::GetInterfaceSafetyOptions(REFIID riid, DWORD * pdwSupportedOptions, DWORD * pdwEnabledOptions)
+ {
+ if(pdwSupportedOptions == NULL || pdwEnabledOptions == NULL)
+ return E_POINTER;
+
+ if(riid != IID_IDispatch)
+ return E_NOINTERFACE;
+
+ *pdwSupportedOptions = INTERFACESAFE_FOR_UNTRUSTED_CALLER;
+ *pdwEnabledOptions = m_SafetyOptions;
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IObjectSafety::SetInterfaceSafetyOptions(REFIID riid, DWORD dwOptionSetMask, DWORD dwEnabledOptions)
+ {
+ if(riid != IID_IDispatch)
+ return E_NOINTERFACE;
+
+ m_SafetyOptions = dwEnabledOptions & (dwOptionSetMask & INTERFACESAFE_FOR_UNTRUSTED_CALLER);
+ return S_OK;
+ }
+
+ /* IOleControl */ // 3/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 S_OK;
+ }
+
+ virtual STDMETHODIMP IOleControl::FreezeEvents(BOOL bFreeze)
+ {
+ if(bFreeze)
+ InterlockedIncrement(&m_freezeEvents);
+ else if(InterlockedDecrement(&m_freezeEvents) == 0)
+ UnfreezeEvents();
+
+ return S_OK;
+ }
+
+ /* IOleInPlaceActiveObject */ // 3/5
+ virtual STDMETHODIMP IOleInPlaceActiveObject::TranslateAccelerator(LPMSG lpmsg)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IOleInPlaceActiveObject::OnFrameWindowActivate(BOOL fActivate)
+ {
+ // TODO
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IOleInPlaceActiveObject::OnDocWindowActivate(BOOL fActivate)
+ {
+ // TODO
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IOleInPlaceActiveObject::ResizeBorder(LPCRECT prcBorder, IOleInPlaceUIWindow * pUIWindow, BOOL fFrameWindow)
+ {
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IOleInPlaceActiveObject::EnableModeless(BOOL fEnable)
+ {
+ return S_OK;
+ }
+
+ /* IOleInPlaceObject */ // 1/4
+ virtual STDMETHODIMP IOleInPlaceObject::InPlaceDeactivate()
+ {
+ // TODO: UIDeactivate, destroy window, inplacesite->OnInPlaceDeactivate
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IOleInPlaceObject::UIDeactivate()
+ {
+ // TODO
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IOleInPlaceObject::SetObjectRects(LPCRECT lprcPosRect, LPCRECT lprcClipRect)
+ {
+ if(m_controlWindow == NULL)
+ return E_FAIL;
+
+ MoveWindow
+ (
+ m_controlWindow,
+ lprcPosRect->left,
+ lprcPosRect->top,
+ lprcPosRect->right - lprcPosRect->left,
+ lprcPosRect->bottom - lprcPosRect->top,
+ TRUE
+ );
+
+ SetWindowRgn(m_controlWindow, CreateRectRgnIndirect(lprcClipRect), TRUE);
+
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IOleInPlaceObject::ReactivateAndUndo()
+ {
+ return E_NOTIMPL;
+ }
+
+ /* IOleObject */ // 18/21
+ virtual STDMETHODIMP IOleObject::SetClientSite(IOleClientSite * pClientSite)
+ {
+ if(m_clientSite)
+ m_clientSite->Release();
+
+ m_clientSite = pClientSite;
+
+ if(m_clientSite)
+ m_clientSite->AddRef();
+
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IOleObject::GetClientSite(IOleClientSite ** ppClientSite)
+ {
+ if(ppClientSite == NULL)
+ return E_POINTER;
+
+ if(m_clientSite)
+ m_clientSite->AddRef();
+
+ *ppClientSite = m_clientSite;
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IOleObject::SetHostNames(LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
+ {
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IOleObject::Close(DWORD dwSaveOption)
+ {
+ // TODO: deactivate, destroy window, release in-place site, release advise sink
+ return E_NOTIMPL; // TODO
+ }
+
+ 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)
+ {
+ HRESULT hr;
+
+ switch(iVerb)
+ {
+ case OLEIVERB_PRIMARY:
+ case OLEIVERB_SHOW:
+ case OLEIVERB_UIACTIVATE:
+ case OLEIVERB_INPLACEACTIVATE:
+ hr = S_OK;
+ break;
+
+ default:
+ if(iVerb > 0)
+ hr = OLEOBJ_S_INVALIDVERB;
+ else
+ hr = E_NOTIMPL;
+ }
+
+ if(FAILED(hr))
+ return hr;
+
+ HRESULT hrActivate = Activate(iVerb, pActiveSite, hwndParent, lprcPosRect);
+
+ if(FAILED(hrActivate))
+ hr = hrActivate;
+
+ return hr;
+ }
+
+ virtual STDMETHODIMP IOleObject::EnumVerbs(IEnumOLEVERB ** ppEnumOleVerb)
+ {
+ return OleRegEnumVerbs(m_classId, ppEnumOleVerb);
+ }
+
+ virtual STDMETHODIMP IOleObject::Update()
+ {
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IOleObject::IsUpToDate()
+ {
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IOleObject::GetUserClassID(CLSID * pClsid)
+ {
+ *pClsid = m_classId;
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IOleObject::GetUserType(DWORD dwFormOfType, LPOLESTR * pszUserType)
+ {
+ return OleRegGetUserType(m_classId, dwFormOfType, pszUserType);
+ }
+
+ virtual STDMETHODIMP IOleObject::SetExtent(DWORD dwDrawAspect, SIZEL * psizel)
+ {
+ // TODO: resize
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IOleObject::GetExtent(DWORD dwDrawAspect, SIZEL * psizel)
+ {
+ // TODO: return size
+ return E_NOTIMPL;
+ }
+
+ HRESULT NeedAdviseHolder()
+ {
+ if(m_adviseHolder)
+ return S_OK;
+
+ return CreateOleAdviseHolder(&m_adviseHolder);
+ }
+
+ virtual STDMETHODIMP IOleObject::Advise(IAdviseSink * pAdvSink, DWORD * pdwConnection)
+ {
+ HRESULT hr = NeedAdviseHolder();
+
+ if(FAILED(hr))
+ return hr;
+
+ return m_adviseHolder->Advise(pAdvSink, pdwConnection);
+ }
+
+ virtual STDMETHODIMP IOleObject::Unadvise(DWORD dwConnection)
+ {
+ HRESULT hr = NeedAdviseHolder();
+
+ if(FAILED(hr))
+ return hr;
+
+ return m_adviseHolder->Unadvise(dwConnection);
+ }
+
+ virtual STDMETHODIMP IOleObject::EnumAdvise(IEnumSTATDATA ** ppenumAdvise)
+ {
+ HRESULT hr = NeedAdviseHolder();
+
+ if(FAILED(hr))
+ return hr;
+
+ return m_adviseHolder->EnumAdvise(ppenumAdvise);
+ }
+
+ virtual STDMETHODIMP IOleObject::GetMiscStatus(DWORD dwAspect, DWORD * pdwStatus)
+ {
+ return OleRegGetMiscStatus(m_classId, dwAspect, pdwStatus);
+ }
+
+ virtual STDMETHODIMP IOleObject::SetColorScheme(LOGPALETTE * pLogpal)
+ {
+ return E_NOTIMPL;
+ }
+
+ /* IOleWindow */
+ virtual STDMETHODIMP IOleWindow::GetWindow(HWND * phwnd)
+ {
+ if(phwnd == NULL)
+ return E_POINTER;
+
+ if(m_controlWindow == NULL)
+ return E_FAIL;
+
+ *phwnd = m_controlWindow;
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IOleWindow::ContextSensitiveHelp(BOOL fEnterMode)
+ {
+ return E_NOTIMPL;
+ }
+
+ /* IPersist */
+ 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 */
+ virtual STDMETHODIMP IProvideClassInfo::GetClassInfo(ITypeInfo ** ppTI)
+ {
+ HRESULT hr = LoadTypeLibrary();
+
+ if(FAILED(hr))
+ return hr;
+
+ return m_typeLib->GetTypeInfoOfGuid(m_classId, ppTI);
+ }
+
+ /* IProvideClassInfo2 */
+ 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 */
+ virtual STDMETHODIMP IQuickActivate::QuickActivate(QACONTAINER * pQaContainer, QACONTROL * pQaControl)
+ {
+ if(pQaContainer == NULL || pQaControl == NULL)
+ return E_POINTER;
+
+ if(pQaContainer->cbSize < sizeof(*pQaContainer) || pQaControl->cbSize < sizeof(*pQaControl))
+ return E_INVALIDARG;
+
+ ULONG cb = pQaControl->cbSize;
+ ZeroMemory(pQaControl, cb);
+ pQaControl->cbSize = cb;
+
+ SetClientSite(pQaContainer->pClientSite);
+
+ if(pQaContainer->pAdviseSink)
+ SetAdvise(DVASPECT_CONTENT, 0, pQaContainer->pAdviseSink);
+
+ if(pQaContainer->pUnkEventSink)
+ Advise(pQaContainer->pUnkEventSink, &pQaControl->dwEventCookie);
+
+ GetMiscStatus(DVASPECT_CONTENT, &pQaControl->dwMiscStatus);
+
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IQuickActivate::SetContentExtent(LPSIZEL pSizel)
+ {
+ return SetExtent(DVASPECT_CONTENT, pSizel);
+ }
+
+ virtual STDMETHODIMP IQuickActivate::GetContentExtent(LPSIZEL pSizel)
+ {
+ return GetExtent(DVASPECT_CONTENT, pSizel);
+ }
+
+ /* IViewObject */ // 3/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; // TODO
+ }
+
+ 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; // TODO
+ }
+
+ virtual STDMETHODIMP IViewObject::GetAdvise(DWORD * pAspects, DWORD * pAdvf, IAdviseSink ** ppAdvSink)
+ {
+ return E_NOTIMPL; // TODO
+ }
+
+ /* IViewObject2 */ // 0/1
+ virtual STDMETHODIMP IViewObject2::GetExtent(DWORD dwDrawAspect, LONG lindex, DVTARGETDEVICE * ptd, LPSIZEL lpsizel)
+ {
+ return E_NOTIMPL; // TODO
+ }
+
+ /* IMsTscAx */ // 23/30
+ virtual STDMETHODIMP IMsTscAx::put_Server(BSTR pServer)
+ {
+ // FIXME: convert the hostname to Punycode, not the ANSI codepage
+ return SetProperty(m_Server, pServer);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_Server(BSTR * pServer) const
+ {
+ return GetProperty(m_Server, pServer);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::put_Domain(BSTR pDomain)
+ {
+ return SetProperty(m_Domain, pDomain);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_Domain(BSTR * pDomain) const
+ {
+ return GetProperty(m_Domain, pDomain);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::put_UserName(BSTR pUserName)
+ {
+ return SetProperty(m_UserName, pUserName);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_UserName(BSTR * pUserName) const
+ {
+ return GetProperty(m_UserName, pUserName);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::put_DisconnectedText(BSTR pDisconnectedText)
+ {
+ return SetProperty(m_DisconnectedText, pDisconnectedText);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_DisconnectedText(BSTR * pDisconnectedText) const
+ {
+ return GetProperty(m_DisconnectedText, pDisconnectedText);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::put_ConnectingText(BSTR pConnectingText)
+ {
+ return SetProperty(m_ConnectingText, pConnectingText);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_ConnectingText(BSTR * pConnectingText) const
+ {
+ return GetProperty(m_ConnectingText, pConnectingText);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_Connected(short * pIsConnected) const
+ {
+ return GetProperty(m_Connected, pIsConnected);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::put_DesktopWidth(long pVal)
+ {
+ if(pVal < 200 || pVal > 1600)
+ return E_INVALIDARG;
+
+ return SetProperty(m_DesktopWidth, pVal);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_DesktopWidth(long * pVal) const
+ {
+ return GetProperty(m_DesktopWidth, pVal);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::put_DesktopHeight(long pVal)
+ {
+ if(pVal < 200 || pVal > 1200)
+ return E_INVALIDARG;
+
+ return SetProperty(m_DesktopHeight, pVal);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_DesktopHeight(long * pVal) const
+ {
+ return GetProperty(m_DesktopHeight, pVal);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::put_StartConnected(long pfStartConnected)
+ {
+ return SetProperty(m_StartConnected, pfStartConnected);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_StartConnected(long * pfStartConnected) const
+ {
+ return GetProperty(m_StartConnected, pfStartConnected);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_HorizontalScrollBarVisible(long * pfHScrollVisible) const
+ {
+ return E_NOTIMPL; // TODO
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_VerticalScrollBarVisible(long * pfVScrollVisible) const
+ {
+ return E_NOTIMPL; // TODO
+ }
+
+ virtual STDMETHODIMP IMsTscAx::put_FullScreenTitle(BSTR rhs)
+ {
+ // TODO
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_CipherStrength(long * pCipherStrength) const
+ {
+ if(pCipherStrength == NULL)
+ return E_INVALIDARG;
+
+ *pCipherStrength = 128; // BUGBUG: a later version may change this. Use a compile-time constant
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_Version(BSTR * pVersion) const
+ {
+ if(pVersion == NULL)
+ return E_INVALIDARG;
+
+ BSTR version = SysAllocString(L"5.2.3790.1830"); // BUGBUG: don't use hardcoded string
+
+ if(version == NULL)
+ return E_OUTOFMEMORY;
+
+ *pVersion = version;
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_SecuredSettingsEnabled(long * pSecuredSettingsEnabled) const
+ {
+ // TODO: initialize m_SecuredSettingsEnabled as soon as we have an OLE client site
+ return GetProperty(m_SecuredSettingsEnabled, pSecuredSettingsEnabled);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_SecuredSettings(MSTSCLib::IMsTscSecuredSettings ** ppSecuredSettings) const
+ {
+ return GetSecuredSettings(ppSecuredSettings);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_AdvancedSettings(MSTSCLib::IMsTscAdvancedSettings ** ppAdvSettings) const
+ {
+ return GetAdvancedSettings(ppAdvSettings);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_Debugger(MSTSCLib::IMsTscDebug ** ppDebugger) const
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscAx::Connect()
+ {
+ if(m_Connected)
+ {
+ // Protocol thread waiting for a manual reconnection: wake it up
+ if(m_protocolThreadWaitingReconnection)
+ {
+ SetEvent(m_protocolThreadWaitingReconnection);
+ return S_OK;
+ }
+
+ return E_FAIL;
+ }
+
+ m_Connected = true;
+
+ HRESULT hr;
+
+ if(m_controlWindow == NULL)
+ {
+ hr = CreateControlWindow(NULL);
+
+ if(FAILED(hr))
+ return hr;
+ }
+
+ for(;;)
+ {
+ // TODO: initialize plugin DLLs/channels
+
+ m_clientUI = new RdpClientUI();
+
+ if(m_clientUI == NULL)
+ {
+ hr = E_OUTOFMEMORY;
+ break;
+ }
+
+ m_clientUI->Initialize(m_controlWindow);
+
+ m_protocolState.licence_username = BstrToLpsz(m_UserName);
+
+ if(m_protocolState.licence_username == NULL)
+ {
+ hr = E_OUTOFMEMORY;
+ break;
+ }
+
+ DWORD dwSize = ARRAYSIZE(m_protocolState.licence_hostname);
+
+ if(!GetComputerNameA(m_protocolState.licence_hostname, &dwSize))
+ {
+ hr = HRESULT_FROM_WIN32(GetLastError());
+ break;
+ }
+
+ // Keyboard layout
+ // BUGBUG: not too sure about the semantics
+ long keyboardLayout = -1;
+ WCHAR * endPtr = NULL;
+
+ if(m_KeyboardLayoutString)
+ keyboardLayout = wcstol(m_KeyboardLayoutString, &endPtr, 0);
+
+ // no keyboard layout specified or invalid keyboard layout: use current keyboard layout
+ if(endPtr == NULL || *endPtr == 0 || keyboardLayout == -1)
+ keyboardLayout = PtrToLong(GetKeyboardLayout(0)); // FIXME? use LOWORD()?
+
+ m_protocolState.keylayout = keyboardLayout;
+
+ // in case of failure, assume English (US)
+ if(m_protocolState.keylayout == 0)
+ m_protocolState.keylayout = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US);
+
+ // Physical keyboard information
+ m_protocolState.keyboard_type = GetKeyboardType(0);
+ m_protocolState.keyboard_subtype = GetKeyboardType(1);
+ m_protocolState.keyboard_functionkeys = GetKeyboardType(2);
+
+ // in case of failure, assume an IBM Enhanced keyboard with 12 function keys
+ if(m_protocolState.keyboard_type == 0 || m_protocolState.keyboard_functionkeys == 0)
+ {
+ m_protocolState.keyboard_type = 4;
+ m_protocolState.keyboard_subtype = 0;
+ m_protocolState.keyboard_functionkeys = 12;
+ }
+
+ // More initialization
+ m_protocolState.width = m_DesktopWidth;
+ m_protocolState.height = m_DesktopHeight;
+ m_protocolState.server_depth = m_ColorDepth;
+ m_protocolState.bitmap_compression = m_Compress ? TRUE : FALSE;
+ m_protocolState.bitmap_cache = True; // TODO
+ m_protocolState.bitmap_cache_persist_enable = False; // TODO
+ m_protocolState.bitmap_cache_precache = True; // FIXME?
+ m_protocolState.encryption = m_EncryptionEnabled ? TRUE : FALSE; // TBD: detect automatically
+ m_protocolState.packet_encryption = m_EncryptionEnabled ? TRUE : FALSE;
+ m_protocolState.desktop_save = True; // FIXME? tie to bitmap cache setting?
+ m_protocolState.polygon_ellipse_orders = True;
+ m_protocolState.use_rdp5 = True; // TBD: detect automatically
+ m_protocolState.console_session = m_ConnectToServerConsole ? TRUE : FALSE;
+ m_protocolState.rdp5_performanceflags = m_PerformanceFlags;
+ m_protocolState.tcp_port_rdp = m_RDPPort;
+ m_protocolState.rdp.current_status = 1;
+
+ // TODO: cache tuning based on the provided parameters
+
+ m_protocolState.cache.bmpcache_lru[0] = -1;
+ m_protocolState.cache.bmpcache_lru[1] = -1;
+ m_protocolState.cache.bmpcache_lru[2] = -1;
+ m_protocolState.cache.bmpcache_mru[0] = -1;
+ m_protocolState.cache.bmpcache_mru[1] = -1;
+ m_protocolState.cache.bmpcache_mru[2] = -1;
+
+ DWORD dwIgnore;
+ m_protocolThread = CreateThread(NULL, 0, ProtocolLoopThreadProc, this, 0, &dwIgnore);
+
+ hr = S_OK;
+ break;
+ }
+
+ if(FAILED(hr))
+ m_Connected = false;
+
+ return hr;
+ }
+
+ virtual STDMETHODIMP IMsTscAx::Disconnect()
+ {
+ if(!m_Connected)
+ return E_FAIL;
+
+ // Terminate the protocol thread. On exit, it will fire the Disconnected event
+ TerminateProtocolThread();
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IMsTscAx::CreateVirtualChannels(BSTR newVal)
+ {
+ UINT strLength = SysStringLen(newVal);
+
+ if(strLength < 1 || strLength > 300)
+ return E_INVALIDARG;
+
+ return E_NOTIMPL; // TODO
+ }
+
+ virtual STDMETHODIMP IMsTscAx::SendOnVirtualChannel(BSTR chanName, BSTR ChanData)
+ {
+ return E_NOTIMPL; // TODO
+ }
+
+ /* IMsRdpClient */ // 6/10
+ virtual STDMETHODIMP IMsRdpClient::put_ColorDepth(long pcolorDepth)
+ {
+ switch(pcolorDepth)
+ {
+ case 8:
+ case 15:
+ case 16:
+ case 24:
+ case 32:
+ break;
+
+ default:
+ return E_INVALIDARG;
+ }
+
+ return SetProperty(m_ColorDepth, pcolorDepth);
+ }
+
+ virtual STDMETHODIMP IMsRdpClient::get_ColorDepth(long * pcolorDepth) const
+ {
+ return GetProperty(m_ColorDepth, pcolorDepth);
+ }
+
+ virtual STDMETHODIMP IMsRdpClient::get_AdvancedSettings2(MSTSCLib::IMsRdpClientAdvancedSettings ** ppAdvSettings) const
+ {
+ return GetAdvancedSettings(ppAdvSettings);
+ }
+
+ virtual STDMETHODIMP IMsRdpClient::get_SecuredSettings2(MSTSCLib::IMsRdpClientSecuredSettings ** ppSecuredSettings) const
+ {
+ return GetSecuredSettings(ppSecuredSettings);
+ }
+
+ virtual STDMETHODIMP IMsRdpClient::get_ExtendedDisconnectReason(MSTSCLib::ExtendedDisconnectReasonCode * pExtendedDisconnectReason) const
+ {
+ return GetProperty(m_ExtendedDisconnectReason, pExtendedDisconnectReason);
+ }
+
+ virtual STDMETHODIMP IMsRdpClient::put_FullScreen(VARIANT_BOOL pfFullScreen)
+ {
+ if(!m_Connected)
+ return E_FAIL;
+
+ if(pfFullScreen && !m_SecuredSettingsEnabled)
+ return E_FAIL;
+
+ // TODO
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsRdpClient::get_FullScreen(VARIANT_BOOL * pfFullScreen) const
+ {
+ return GetProperty(m_FullScreen, pfFullScreen);
+ }
+
+ 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)
+ {
+ if(pCloseStatus == NULL)
+ return E_POINTER;
+
+ if(!m_Connected)
+ {
+ *pCloseStatus = MSTSCLib::controlCloseCanProceed;
+ return S_OK;
+ }
+
+ *pCloseStatus = MSTSCLib::controlCloseWaitForEvents;
+
+ if(!PostMessage(m_controlWindow, RDPC_WM_REQUEST_CLOSE, 0, 0))
+ return HRESULT_FROM_WIN32(GetLastError());
+
+ return S_OK;
+ }
+
+ /* IMsRdpClient2 */
+ virtual STDMETHODIMP IMsRdpClient2::get_AdvancedSettings3(MSTSCLib::IMsRdpClientAdvancedSettings2 ** ppAdvSettings) const
+ {
+ return GetAdvancedSettings(ppAdvSettings);
+ }
+
+ virtual STDMETHODIMP IMsRdpClient2::put_ConnectedStatusText(BSTR pConnectedStatusText)
+ {
+ return SetProperty(m_ConnectedStatusText, pConnectedStatusText);
+ }
+
+ virtual STDMETHODIMP IMsRdpClient2::get_ConnectedStatusText(BSTR * pConnectedStatusText) const
+ {
+ return GetProperty(m_ConnectedStatusText, pConnectedStatusText);
+ }
+
+ /* IMsRdpClient3 */
+ virtual STDMETHODIMP IMsRdpClient3::get_AdvancedSettings4(MSTSCLib::IMsRdpClientAdvancedSettings3 ** ppAdvSettings) const
+ {
+ return GetAdvancedSettings(ppAdvSettings);
+ }
+
+ /* IMsRdpClient4 */
+ virtual STDMETHODIMP IMsRdpClient4::get_AdvancedSettings5(MSTSCLib::IMsRdpClientAdvancedSettings4 ** ppAdvSettings5) const
+ {
+ return GetAdvancedSettings(ppAdvSettings5);
+ }
+
+ /* IMsTscNonScriptable */
+ virtual STDMETHODIMP IMsTscNonScriptable::put_ClearTextPassword(BSTR rhs)
+ {
+ return SetProperty(m_ClearTextPassword, rhs);
+ }
+
+ virtual STDMETHODIMP IMsTscNonScriptable::put_PortablePassword(BSTR pPortablePass)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscNonScriptable::get_PortablePassword(BSTR * pPortablePass) const
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscNonScriptable::put_PortableSalt(BSTR pPortableSalt)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscNonScriptable::get_PortableSalt(BSTR * pPortableSalt) const
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscNonScriptable::put_BinaryPassword(BSTR pBinaryPassword)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscNonScriptable::get_BinaryPassword(BSTR * pBinaryPassword) const
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscNonScriptable::put_BinarySalt(BSTR pSalt)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscNonScriptable::get_BinarySalt(BSTR * pSalt) const
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscNonScriptable::ResetPassword()
+ {
+ return SetProperty(m_ClearTextPassword, NULL);
+ }
+
+ /* 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 */
+ virtual STDMETHODIMP IMsRdpClientNonScriptable2::put_UIParentWindowHandle(HWND phwndUIParentWindowHandle)
+ {
+ return SetProperty(m_UIParentWindowHandle, phwndUIParentWindowHandle);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientNonScriptable2::get_UIParentWindowHandle(HWND * phwndUIParentWindowHandle) const
+ {
+ return GetProperty(m_UIParentWindowHandle, phwndUIParentWindowHandle);
+ }
+};
+
+#pragma warning(pop)
+
+/* More glue to interface to the rdesktop code */
+extern "C"
+{
+
+/* Orders */
+/* support routines */
+void ui_begin_update(RDPCLIENT * This)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_BeginUpdate();
+}
+
+void ui_end_update(RDPCLIENT * This)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_EndUpdate();
+}
+
+void ui_set_clip(RDPCLIENT * This, int x, int y, int cx, int cy)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_SetClip(x, y, cx, cy);
+}
+
+void ui_reset_clip(RDPCLIENT * This)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_ResetClip();
+}
+
+/* blits */
+void ui_destblt(RDPCLIENT * This, uint8 opcode, int x, int y, int cx, int cy)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_DestBlt(opcode, x, y, cx, cy);
+}
+
+void ui_memblt(RDPCLIENT * This, uint8 opcode, int x, int y, int cx, int cy, HBITMAP src, int srcx, int srcy)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_MemBlt(opcode, x, y, cx, cy, src, srcx, srcy);
+}
+
+void ui_patblt(RDPCLIENT * This, uint8 opcode, int x, int y, int cx, int cy, BRUSH * brush, int bgcolour, int fgcolour)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_PatBlt(opcode, x, y, cx, cy, brush, bgcolour, fgcolour);
+}
+
+void ui_screenblt(RDPCLIENT * This, uint8 opcode, int x, int y, int cx, int cy, int srcx, int srcy)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_ScreenBlt(opcode, x, y, cx, cy, srcx, srcy);
+}
+
+void ui_triblt(RDPCLIENT * This, uint8 opcode, int x, int y, int cx, int cy, HBITMAP src, int srcx, int srcy, BRUSH * brush, int bgcolour, int fgcolour)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_TriBlt(opcode, x, y, cx, cy, src, srcx, srcy, brush, bgcolour, fgcolour);
+}
+
+void ui_paint_bitmap(RDPCLIENT * This, int x, int y, int cx, int cy, int width, int height, uint8 * data)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_PaintBitmap(x, y, cx, cy, width, height, data);
+}
+
+/* shapes */
+void ui_ellipse(RDPCLIENT * This, uint8 opcode, uint8 fillmode, int x, int y, int cx, int cy, BRUSH * brush, int bgcolour, int fgcolour)
+{
+ // TODO
+// RdpClient::InnerToOuter(This)->GetUI()->Display_Ellipse(opcode, fillmode, x, y, cx, cy, brush, bgcolour, fgcolour);
+}
+
+void ui_line(RDPCLIENT * This, uint8 opcode, int startx, int starty, int endx, int endy, PEN * pen)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_Line(opcode, startx, starty, endx, endy, pen);
+}
+
+void ui_polygon(RDPCLIENT * This, uint8 opcode, uint8 fillmode, POINT * point, int npoints, BRUSH * brush, int bgcolour, int fgcolour)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_Polygon(opcode, fillmode, point, npoints, brush, bgcolour, fgcolour);
+}
+
+void ui_polyline(RDPCLIENT * This, uint8 opcode, POINT * points, int npoints, PEN * pen)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_Polyline(opcode, points, npoints, pen);
+}
+
+void ui_rect(RDPCLIENT * This, int x, int y, int cx, int cy, int colour)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_Rect(x, y, cx, cy, colour);
+}
+
+/* text */
+void ui_draw_text
+(
+ RDPCLIENT * This,
+ uint8 font,
+ uint8 flags,
+ uint8 opcode,
+ int mixmode,
+ int x,
+ int y,
+ int clipx,
+ int clipy,
+ int clipcx,
+ int clipcy,
+ int boxx,
+ int boxy,
+ int boxcx,
+ int boxcy,
+ BRUSH * brush,
+ int bgcolour,
+ int fgcolour,
+ uint8 * text,
+ uint8 length
+)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_DrawText
+ (
+ font,
+ flags,
+ opcode,
+ mixmode,
+ x,
+ y,
+ clipx,
+ clipy,
+ clipcx,
+ clipcy,
+ boxx,
+ boxy,
+ boxcx,
+ boxcy,
+ brush,
+ bgcolour,
+ fgcolour,
+ text,
+ length
+ );
+}
+
+/* desktop save/restore */
+void ui_desktop_save(RDPCLIENT * This, uint32 offset, int x, int y, int cx, int cy)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_SaveDesktop(offset, x, y, cx, cy);
+}
+
+void ui_desktop_restore(RDPCLIENT * This, uint32 offset, int x, int y, int cx, int cy)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_RestoreDesktop(offset, x, y, cx, cy);
+}
+
+/* Resources */
+/* bitmaps */
+HBITMAP ui_create_bitmap(RDPCLIENT * This, int width, int height, uint8 * data)
+{
+ return win32_create_dib(width, height, This->server_depth, data);
+}
+
+void ui_destroy_bitmap(RDPCLIENT *, HBITMAP bmp)
+{
+ DeleteObject(bmp);
+}
+
+/* palettes */
+HCOLOURMAP ui_create_colourmap(RDPCLIENT *, COLOURMAP * colours)
+{
+ return NULL;
+}
+
+void ui_set_colourmap(RDPCLIENT * This, HCOLOURMAP map)
+{
+ // TODO
+}
+
+/* cursors */
+HCURSOR ui_create_cursor(RDPCLIENT * This, unsigned int x, unsigned int y, int width, int height, uint8 * andmask, uint8 * xormask)
+{
+ uint8 * andbuf = NULL;
+ uint8 * xorbuf = NULL;
+
+ uint8 * andbits = win32_convert_scanlines(width, - height, 1, 2, 4, andmask, &andbuf);
+ uint8 * xorbits = win32_convert_scanlines(width, height, 24, 2, 4, xormask, &xorbuf);
+
+ HBITMAP hbmMask = CreateBitmap(width, height, 1, 1, andbits);
+ HBITMAP hbmColor = win32_create_dib(width, height, 24, xorbits);
+
+ ICONINFO iconinfo;
+ iconinfo.fIcon = FALSE;
+ iconinfo.xHotspot = x;
+ iconinfo.yHotspot = y;
+ iconinfo.hbmMask = hbmMask;
+ iconinfo.hbmColor = hbmColor;
+
+ HICON icon = CreateIconIndirect(&iconinfo);
+
+ if(icon == NULL)
+ error("CreateIconIndirect %dx%d failed\n", width, height);
+
+ if(andbuf)
+ delete[] andbuf;
+
+ if(xorbuf)
+ delete[] xorbuf;
+
+ DeleteObject(hbmMask);
+ DeleteObject(hbmColor);
+
+ return icon;
+}
+
+void ui_destroy_cursor(RDPCLIENT *, HCURSOR cursor)
+{
+ DestroyIcon(cursor);
+}
+
+/* glyphs */
+HGLYPH ui_create_glyph(RDPCLIENT * This, int width, int height, const uint8 * data)
+{
+ uint8 * databuf = NULL;
+ uint8 * databits = win32_convert_scanlines(width, height, 1, 1, 2, data, &databuf);
+
+ HBITMAP hbm = CreateBitmap(width, height, 1, 1, databits);
+
+ if(databuf)
+ delete[] databuf;
+
+ const uint8 * p = data;
+ int stride = alignup(alignup(width, 8) / 8, 1);
+
+#ifdef _DEBUG
+ printf("glyph %p\n", hbm);
+
+ for(int i = 0; i < height; ++ i, p += stride)
+ {
+ for(int j = 0; j < width; ++ j)
+ {
+ int B = p[j / 8];
+ int b = 8 - j % 8 - 1;
+
+ if(B & (1 << b))
+ fputs("##", stdout);
+ else
+ fputs("..", stdout);
+ }
+
+ fputc('\n', stdout);
+ }
+
+ fputc('\n', stdout);
+#endif
+
+ return hbm;
+}
+
+void ui_destroy_glyph(RDPCLIENT *, HGLYPH glyph)
+{
+ DeleteObject(glyph);
+}
+
+/* Input window */
+void ui_move_pointer(RDPCLIENT * This, int x, int y)
+{
+ // TODO
+}
+
+void ui_set_cursor(RDPCLIENT * This, HCURSOR cursor)
+{
+ // TODO
+}
+
+void ui_set_null_cursor(RDPCLIENT * This)
+{
+ // TODO
+}
+
+/* Miscellaneous */
+void ui_resize_window(RDPCLIENT * This)
+{
+}
+
+void ui_bell(RDPCLIENT *)
+{
+ MessageBeep(0);
+}
+
+int ui_select(RDPCLIENT * This, SOCKET rdp_socket)
+{
+ return SleepEx(0, TRUE) == WAIT_IO_COMPLETION;
+}
+
+/* Events */
+BOOL event_pubkey(RDPCLIENT * This, unsigned char * key, unsigned int key_size)
+{
+ if(!RdpClient::OnPublicKey(This, key, key_size))
+ return FALSE;
+ else
+ return TRUE;
+}
+
+void event_logon(RDPCLIENT * This)
+{
+ RdpClient::OnLogon(This);
+}
+
+BOOL event_redirect(RDPCLIENT * This, uint32 flags, uint32 server_len, wchar_t * server, uint32 cookie_len, char * cookie, uint32 username_len, wchar_t * username, uint32 domain_len, wchar_t * domain, uint32 password_len, wchar_t * password)
+{
+ if
+ (
+ !RdpClient::OnRedirect
+ (
+ This,
+ flags,
+ server_len,
+ server,
+ cookie_len,
+ cookie,
+ username_len,
+ username,
+ domain_len,
+ domain,
+ password_len,
+ password
+ )
+ )
+ return FALSE;
+ else
+ return TRUE;
+}
+
+}
+
+class ClassFactory: public IClassFactory
+{
+private:
+ LONG m_refCount;
+ CLSID m_classId;
+ unsigned m_libIndex;
+
+public:
+ ClassFactory(REFCLSID rclsid, unsigned libIndex):
+ m_refCount(1),
+ m_classId(rclsid)
+ {
+ lockServer();
+ }
+
+ ~ClassFactory()
+ {
+ unlockServer();
+ }
+
+ virtual STDMETHODIMP QueryInterface(REFIID riid, void ** ppvObject)
+ {
+ if(riid == IID_IUnknown || riid == IID_IClassFactory)
+ {
+ *ppvObject = this;
+ return S_OK;
+ }
+ else
+ {
+ *ppvObject = NULL;
+ return E_NOINTERFACE;
+ }
+ }
+
+ virtual STDMETHODIMP_(ULONG) AddRef()
+ {
+ return InterlockedIncrement(&m_refCount);
+ }
+
+ virtual STDMETHODIMP_(ULONG) Release()
+ {
+ LONG n = InterlockedDecrement(&m_refCount);
+
+ if(n == 0)
+ delete this;
+
+ return n;
+ }
+
+ virtual STDMETHODIMP CreateInstance(IUnknown * pUnkOuter, REFIID riid, void ** ppvObject)
+ {
+ if(pUnkOuter && riid != IID_IUnknown)
+ return CLASS_E_NOAGGREGATION;
+
+ return RdpClient::CreateInstance(m_classId, m_libIndex, pUnkOuter, riid, ppvObject);
+ }
+
+ virtual STDMETHODIMP LockServer(BOOL fLock)
+ {
+ if(fLock)
+ lockServer();
+ else
+ unlockServer();
+
+ return S_OK;
+ }
+};
+
+extern "C"
+{
+
+STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID * ppv)
+{
+ unsigned libindex;
+
+ if
+ (
+ rclsid == MSTSCLib::CLSID_MsTscAx ||
+ rclsid == MSTSCLib::CLSID_MsRdpClient ||
+ rclsid == MSTSCLib::CLSID_MsRdpClient2 ||
+ rclsid == MSTSCLib::CLSID_MsRdpClient3 ||
+ rclsid == MSTSCLib::CLSID_MsRdpClient4
+ )
+ libindex = 1;
+ else if
+ (
+ rclsid == MSTSCLib_Redist::CLSID_MsTscAx ||
+ rclsid == MSTSCLib_Redist::CLSID_MsRdpClient ||
+ rclsid == MSTSCLib_Redist::CLSID_MsRdpClient2 ||
+ rclsid == MSTSCLib_Redist::CLSID_MsRdpClient3 // ||
+ // rclsid != MSTSCLib::CLSID_MsRdpClient4
+ )
+ libindex = 2;
+ else
+ return CLASS_E_CLASSNOTAVAILABLE;
+
+ ClassFactory * p = new ClassFactory(rclsid, libindex);
+
+ if(p == NULL)
+ return E_OUTOFMEMORY;
+
+ HRESULT hr = p->QueryInterface(riid, ppv);
+
+ p->Release();
+
+ if(FAILED(hr))
+ return hr;
+
+ return S_OK;
+}
+
+STDAPI DllCanUnloadNow(void)
+{
+ return canUnloadServer() ? S_OK : S_FALSE;
+}
+
+STDAPI_(ULONG) DllGetTscCtlVer(void)
+{
+ // BUGBUG: don't hardcode this
+ return 0x05020ECE; // 5.2.3790
+}
+
+DWORD WINAPI DllMain(HINSTANCE hInstance, DWORD fdwReason, LPVOID lpvReserved)
+{
+ assert(hInstance == GetCurrentModule());
+
+ switch(fdwReason)
+ {
+ case DLL_PROCESS_ATTACH:
+ {
+ DisableThreadLibraryCalls(hInstance);
+
+ if(!RdpClient::Startup())
+ return FALSE;
+ }
+
+ break;
+
+ case DLL_PROCESS_DETACH:
+ {
+ // Process is terminating, no need to clean up
+ if(lpvReserved)
+ break;
+
+ RdpClient::Shutdown();
+ }
+
+ break;
+ }
+
+ return TRUE;
+}
+
+}
+
+// EOF
diff --git a/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib.idl b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib.idl
new file mode 100644
index 00000000000..9c78f8575f9
--- /dev/null
+++ b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib.idl
@@ -0,0 +1,561 @@
+[
+#ifdef MSTSCLIB_REDIST_
+ uuid(AF586AAE-B62A-420E-B796-294E7EE64C70),
+#else
+ uuid(8C11EFA1-92C3-11D1-BC1E-00C04FA31489),
+#endif
+ 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();
+ };
+
+ [
+#ifdef MSTSCLIB_REDIST_
+ uuid(327BB5CD-834E-4400-AEF2-B30E15E5D682),
+#else
+ uuid(8C11EFAE-92C3-11D1-BC1E-00C04FA31489),
+#endif
+ 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 ClearTextPassword([in] BSTR rhs);
+ [propput] HRESULT PortablePassword([in] BSTR pPortablePass);
+ [propget] HRESULT PortablePassword([out, retval] BSTR * pPortablePass);
+ [propput] HRESULT PortableSalt([in] BSTR pPortableSalt);
+ [propget] HRESULT PortableSalt([out, retval] BSTR * pPortableSalt);
+ [propput] HRESULT BinaryPassword([in] BSTR pBinaryPassword);
+ [propget] HRESULT BinaryPassword([out, retval] BSTR * pBinaryPassword);
+ [propput] HRESULT BinarySalt([in] BSTR pSalt);
+ [propget] HRESULT BinarySalt([out, retval] BSTR * pSalt);
+ HRESULT ResetPassword();
+ };
+
+ [uuid(2F079C4C-87B2-4AFD-97AB-20CDB43038AE)]
+ interface IMsRdpClientNonScriptable: IMsTscNonScriptable
+ {
+ HRESULT NotifyRedirectDeviceChange([in] UINT_PTR wParam, [in] LONG_PTR lParam);
+ HRESULT SendKeys([in] long numKeys, [in] VARIANT_BOOL * pbArrayKeyUp, [in] long * plKeyData);
+ };
+
+ [uuid(17A5E535-4072-4FA4-AF32-C8D0D47345E9)]
+ interface IMsRdpClientNonScriptable2: IMsRdpClientNonScriptable
+ {
+ [propput] HRESULT UIParentWindowHandle([in] HWND phwndUIParentWindowHandle);
+ [propget] HRESULT 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);
+ };
+
+ [
+#ifdef MSTSCLIB_REDIST_
+ uuid(1FB464C8-09BB-4017-A2F5-EB742F04392F)
+#else
+ uuid(A41A4187-5A86-4E26-B40A-856F9035D9CB)
+#endif
+ ]
+ coclass MsTscAx
+ {
+ interface IMsRdpClient;
+ [default] interface IMsTscAx;
+ [default, source] dispinterface IMsTscAxEvents;
+ interface IMsTscNonScriptable;
+ interface IMsRdpClientNonScriptable;
+ };
+
+ [
+#ifdef MSTSCLIB_REDIST_
+ uuid(791FA017-2DE3-492E-ACC5-53C67A2B94D0)
+#else
+ uuid(7CACBD7B-0D99-468F-AC33-22E495C0AFE5)
+#endif
+ ]
+ coclass MsRdpClient
+ {
+ [default] interface IMsRdpClient;
+ interface IMsTscAx;
+ [default, source] dispinterface IMsTscAxEvents;
+ interface IMsTscNonScriptable;
+ interface IMsRdpClientNonScriptable;
+ };
+
+ [
+#ifdef MSTSCLIB_REDIST_
+ uuid(9059F30F-4EB1-4BD2-9FDC-36F43A218F4A)
+#else
+ uuid(3523C2FB-4031-44E4-9A3B-F1E94986EE7F)
+#endif
+ ]
+ coclass MsRdpClient2
+ {
+ [default] interface IMsRdpClient2;
+ interface IMsRdpClient;
+ interface IMsTscAx;
+ [default, source] dispinterface IMsTscAxEvents;
+ interface IMsTscNonScriptable;
+ interface IMsRdpClientNonScriptable;
+ };
+
+ [
+#ifdef MSTSCLIB_REDIST_
+ uuid(7584C670-2274-4EFB-B00B-D6AABA6D3850)
+#else
+ uuid(ACE575FD-1FCF-4074-9401-EBAB990FA9DE)
+#endif
+ ]
+ 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;
+ };
+
+};
+
+// EOF
diff --git a/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib.rc b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib.rc
new file mode 100644
index 00000000000..fa268c7e9ea
--- /dev/null
+++ b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib.rc
@@ -0,0 +1,3 @@
+#define TYPELIB_RESOURCEID__ 1
+#include "./typelib.rh"
+// EOF
diff --git a/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib_h.h b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib_h.h
new file mode 100644
index 00000000000..2685131f18a
--- /dev/null
+++ b/rosapps/applications/net/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 Sun Aug 13 16:46:06 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 STDMETHODCALLTYPE put_ClearTextPassword(
+ /* [in] */ BSTR rhs) = 0;
+
+ virtual /* [propput] */ HRESULT STDMETHODCALLTYPE put_PortablePassword(
+ /* [in] */ BSTR pPortablePass) = 0;
+
+ virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_PortablePassword(
+ /* [retval][out] */ BSTR *pPortablePass) = 0;
+
+ virtual /* [propput] */ HRESULT STDMETHODCALLTYPE put_PortableSalt(
+ /* [in] */ BSTR pPortableSalt) = 0;
+
+ virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_PortableSalt(
+ /* [retval][out] */ BSTR *pPortableSalt) = 0;
+
+ virtual /* [propput] */ HRESULT STDMETHODCALLTYPE put_BinaryPassword(
+ /* [in] */ BSTR pBinaryPassword) = 0;
+
+ virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_BinaryPassword(
+ /* [retval][out] */ BSTR *pBinaryPassword) = 0;
+
+ virtual /* [propput] */ HRESULT STDMETHODCALLTYPE put_BinarySalt(
+ /* [in] */ BSTR pSalt) = 0;
+
+ virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_BinarySalt(
+ /* [retval][out] */ BSTR *pSalt) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE 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 ( STDMETHODCALLTYPE *put_ClearTextPassword )(
+ IMsTscNonScriptable * This,
+ /* [in] */ BSTR rhs);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_PortablePassword )(
+ IMsTscNonScriptable * This,
+ /* [in] */ BSTR pPortablePass);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_PortablePassword )(
+ IMsTscNonScriptable * This,
+ /* [retval][out] */ BSTR *pPortablePass);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_PortableSalt )(
+ IMsTscNonScriptable * This,
+ /* [in] */ BSTR pPortableSalt);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_PortableSalt )(
+ IMsTscNonScriptable * This,
+ /* [retval][out] */ BSTR *pPortableSalt);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_BinaryPassword )(
+ IMsTscNonScriptable * This,
+ /* [in] */ BSTR pBinaryPassword);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_BinaryPassword )(
+ IMsTscNonScriptable * This,
+ /* [retval][out] */ BSTR *pBinaryPassword);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_BinarySalt )(
+ IMsTscNonScriptable * This,
+ /* [in] */ BSTR pSalt);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_BinarySalt )(
+ IMsTscNonScriptable * This,
+ /* [retval][out] */ BSTR *pSalt);
+
+ HRESULT ( STDMETHODCALLTYPE *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 STDMETHODCALLTYPE NotifyRedirectDeviceChange(
+ /* [in] */ UINT_PTR wParam,
+ /* [in] */ LONG_PTR lParam) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE 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 ( STDMETHODCALLTYPE *put_ClearTextPassword )(
+ IMsRdpClientNonScriptable * This,
+ /* [in] */ BSTR rhs);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_PortablePassword )(
+ IMsRdpClientNonScriptable * This,
+ /* [in] */ BSTR pPortablePass);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_PortablePassword )(
+ IMsRdpClientNonScriptable * This,
+ /* [retval][out] */ BSTR *pPortablePass);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_PortableSalt )(
+ IMsRdpClientNonScriptable * This,
+ /* [in] */ BSTR pPortableSalt);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_PortableSalt )(
+ IMsRdpClientNonScriptable * This,
+ /* [retval][out] */ BSTR *pPortableSalt);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_BinaryPassword )(
+ IMsRdpClientNonScriptable * This,
+ /* [in] */ BSTR pBinaryPassword);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_BinaryPassword )(
+ IMsRdpClientNonScriptable * This,
+ /* [retval][out] */ BSTR *pBinaryPassword);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_BinarySalt )(
+ IMsRdpClientNonScriptable * This,
+ /* [in] */ BSTR pSalt);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_BinarySalt )(
+ IMsRdpClientNonScriptable * This,
+ /* [retval][out] */ BSTR *pSalt);
+
+ HRESULT ( STDMETHODCALLTYPE *ResetPassword )(
+ IMsRdpClientNonScriptable * This);
+
+ HRESULT ( STDMETHODCALLTYPE *NotifyRedirectDeviceChange )(
+ IMsRdpClientNonScriptable * This,
+ /* [in] */ UINT_PTR wParam,
+ /* [in] */ LONG_PTR lParam);
+
+ HRESULT ( STDMETHODCALLTYPE *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 STDMETHODCALLTYPE put_UIParentWindowHandle(
+ /* [in] */ HWND phwndUIParentWindowHandle) = 0;
+
+ virtual /* [propget] */ HRESULT STDMETHODCALLTYPE 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 ( STDMETHODCALLTYPE *put_ClearTextPassword )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [in] */ BSTR rhs);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_PortablePassword )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [in] */ BSTR pPortablePass);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_PortablePassword )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [retval][out] */ BSTR *pPortablePass);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_PortableSalt )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [in] */ BSTR pPortableSalt);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_PortableSalt )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [retval][out] */ BSTR *pPortableSalt);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_BinaryPassword )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [in] */ BSTR pBinaryPassword);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_BinaryPassword )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [retval][out] */ BSTR *pBinaryPassword);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_BinarySalt )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [in] */ BSTR pSalt);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_BinarySalt )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [retval][out] */ BSTR *pSalt);
+
+ HRESULT ( STDMETHODCALLTYPE *ResetPassword )(
+ IMsRdpClientNonScriptable2 * This);
+
+ HRESULT ( STDMETHODCALLTYPE *NotifyRedirectDeviceChange )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [in] */ UINT_PTR wParam,
+ /* [in] */ LONG_PTR lParam);
+
+ HRESULT ( STDMETHODCALLTYPE *SendKeys )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [in] */ long numKeys,
+ /* [in] */ VARIANT_BOOL *pbArrayKeyUp,
+ /* [in] */ long *plKeyData);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_UIParentWindowHandle )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [in] */ HWND phwndUIParentWindowHandle);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *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/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib_i.c b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib_i.c
new file mode 100644
index 00000000000..b66a1a51b68
--- /dev/null
+++ b/rosapps/applications/net/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 Sun Aug 13 16:46:06 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/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib_redist.idl b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib_redist.idl
new file mode 100644
index 00000000000..8a2421bc5e5
--- /dev/null
+++ b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib_redist.idl
@@ -0,0 +1,3 @@
+#define MSTSCLIB_REDIST_
+#include "./mstsclib.idl"
+// EOF
diff --git a/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib_redist.rc b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib_redist.rc
new file mode 100644
index 00000000000..3cbb8ee6746
--- /dev/null
+++ b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib_redist.rc
@@ -0,0 +1,3 @@
+#define TYPELIB_RESOURCEID__ 2
+#include "./typelib.rh"
+// EOF
diff --git a/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib_redist_h.h b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib_redist_h.h
new file mode 100644
index 00000000000..3ee3213df53
--- /dev/null
+++ b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib_redist_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 Sun Aug 13 16:46:05 2006
+ */
+/* Compiler settings for .\mstsclib_redist.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_redist_h_h__
+#define __mstsclib_redist_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("327BB5CD-834E-4400-AEF2-B30E15E5D682")
+ 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 STDMETHODCALLTYPE put_ClearTextPassword(
+ /* [in] */ BSTR rhs) = 0;
+
+ virtual /* [propput] */ HRESULT STDMETHODCALLTYPE put_PortablePassword(
+ /* [in] */ BSTR pPortablePass) = 0;
+
+ virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_PortablePassword(
+ /* [retval][out] */ BSTR *pPortablePass) = 0;
+
+ virtual /* [propput] */ HRESULT STDMETHODCALLTYPE put_PortableSalt(
+ /* [in] */ BSTR pPortableSalt) = 0;
+
+ virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_PortableSalt(
+ /* [retval][out] */ BSTR *pPortableSalt) = 0;
+
+ virtual /* [propput] */ HRESULT STDMETHODCALLTYPE put_BinaryPassword(
+ /* [in] */ BSTR pBinaryPassword) = 0;
+
+ virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_BinaryPassword(
+ /* [retval][out] */ BSTR *pBinaryPassword) = 0;
+
+ virtual /* [propput] */ HRESULT STDMETHODCALLTYPE put_BinarySalt(
+ /* [in] */ BSTR pSalt) = 0;
+
+ virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_BinarySalt(
+ /* [retval][out] */ BSTR *pSalt) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE 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 ( STDMETHODCALLTYPE *put_ClearTextPassword )(
+ IMsTscNonScriptable * This,
+ /* [in] */ BSTR rhs);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_PortablePassword )(
+ IMsTscNonScriptable * This,
+ /* [in] */ BSTR pPortablePass);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_PortablePassword )(
+ IMsTscNonScriptable * This,
+ /* [retval][out] */ BSTR *pPortablePass);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_PortableSalt )(
+ IMsTscNonScriptable * This,
+ /* [in] */ BSTR pPortableSalt);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_PortableSalt )(
+ IMsTscNonScriptable * This,
+ /* [retval][out] */ BSTR *pPortableSalt);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_BinaryPassword )(
+ IMsTscNonScriptable * This,
+ /* [in] */ BSTR pBinaryPassword);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_BinaryPassword )(
+ IMsTscNonScriptable * This,
+ /* [retval][out] */ BSTR *pBinaryPassword);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_BinarySalt )(
+ IMsTscNonScriptable * This,
+ /* [in] */ BSTR pSalt);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_BinarySalt )(
+ IMsTscNonScriptable * This,
+ /* [retval][out] */ BSTR *pSalt);
+
+ HRESULT ( STDMETHODCALLTYPE *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 STDMETHODCALLTYPE NotifyRedirectDeviceChange(
+ /* [in] */ UINT_PTR wParam,
+ /* [in] */ LONG_PTR lParam) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE 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 ( STDMETHODCALLTYPE *put_ClearTextPassword )(
+ IMsRdpClientNonScriptable * This,
+ /* [in] */ BSTR rhs);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_PortablePassword )(
+ IMsRdpClientNonScriptable * This,
+ /* [in] */ BSTR pPortablePass);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_PortablePassword )(
+ IMsRdpClientNonScriptable * This,
+ /* [retval][out] */ BSTR *pPortablePass);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_PortableSalt )(
+ IMsRdpClientNonScriptable * This,
+ /* [in] */ BSTR pPortableSalt);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_PortableSalt )(
+ IMsRdpClientNonScriptable * This,
+ /* [retval][out] */ BSTR *pPortableSalt);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_BinaryPassword )(
+ IMsRdpClientNonScriptable * This,
+ /* [in] */ BSTR pBinaryPassword);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_BinaryPassword )(
+ IMsRdpClientNonScriptable * This,
+ /* [retval][out] */ BSTR *pBinaryPassword);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_BinarySalt )(
+ IMsRdpClientNonScriptable * This,
+ /* [in] */ BSTR pSalt);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_BinarySalt )(
+ IMsRdpClientNonScriptable * This,
+ /* [retval][out] */ BSTR *pSalt);
+
+ HRESULT ( STDMETHODCALLTYPE *ResetPassword )(
+ IMsRdpClientNonScriptable * This);
+
+ HRESULT ( STDMETHODCALLTYPE *NotifyRedirectDeviceChange )(
+ IMsRdpClientNonScriptable * This,
+ /* [in] */ UINT_PTR wParam,
+ /* [in] */ LONG_PTR lParam);
+
+ HRESULT ( STDMETHODCALLTYPE *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 STDMETHODCALLTYPE put_UIParentWindowHandle(
+ /* [in] */ HWND phwndUIParentWindowHandle) = 0;
+
+ virtual /* [propget] */ HRESULT STDMETHODCALLTYPE 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 ( STDMETHODCALLTYPE *put_ClearTextPassword )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [in] */ BSTR rhs);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_PortablePassword )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [in] */ BSTR pPortablePass);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_PortablePassword )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [retval][out] */ BSTR *pPortablePass);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_PortableSalt )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [in] */ BSTR pPortableSalt);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_PortableSalt )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [retval][out] */ BSTR *pPortableSalt);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_BinaryPassword )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [in] */ BSTR pBinaryPassword);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_BinaryPassword )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [retval][out] */ BSTR *pBinaryPassword);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_BinarySalt )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [in] */ BSTR pSalt);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *get_BinarySalt )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [retval][out] */ BSTR *pSalt);
+
+ HRESULT ( STDMETHODCALLTYPE *ResetPassword )(
+ IMsRdpClientNonScriptable2 * This);
+
+ HRESULT ( STDMETHODCALLTYPE *NotifyRedirectDeviceChange )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [in] */ UINT_PTR wParam,
+ /* [in] */ LONG_PTR lParam);
+
+ HRESULT ( STDMETHODCALLTYPE *SendKeys )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [in] */ long numKeys,
+ /* [in] */ VARIANT_BOOL *pbArrayKeyUp,
+ /* [in] */ long *plKeyData);
+
+ /* [propput] */ HRESULT ( STDMETHODCALLTYPE *put_UIParentWindowHandle )(
+ IMsRdpClientNonScriptable2 * This,
+ /* [in] */ HWND phwndUIParentWindowHandle);
+
+ /* [propget] */ HRESULT ( STDMETHODCALLTYPE *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("1FB464C8-09BB-4017-A2F5-EB742F04392F")
+MsTscAx;
+#endif
+
+EXTERN_C const CLSID CLSID_MsRdpClient;
+
+#ifdef __cplusplus
+
+class DECLSPEC_UUID("791FA017-2DE3-492E-ACC5-53C67A2B94D0")
+MsRdpClient;
+#endif
+
+EXTERN_C const CLSID CLSID_MsRdpClient2;
+
+#ifdef __cplusplus
+
+class DECLSPEC_UUID("9059F30F-4EB1-4BD2-9FDC-36F43A218F4A")
+MsRdpClient2;
+#endif
+
+EXTERN_C const CLSID CLSID_MsRdpClient3;
+
+#ifdef __cplusplus
+
+class DECLSPEC_UUID("7584C670-2274-4EFB-B00B-D6AABA6D3850")
+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/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib_redist_i.c b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib_redist_i.c
new file mode 100644
index 00000000000..eb8092fc8e4
--- /dev/null
+++ b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/mstsclib_redist_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 Sun Aug 13 16:46:05 2006
+ */
+/* Compiler settings for .\mstsclib_redist.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,0xAF586AAE,0xB62A,0x420E,0xB7,0x96,0x29,0x4E,0x7E,0xE6,0x4C,0x70);
+
+
+MIDL_DEFINE_GUID(IID, DIID_IMsTscAxEvents,0x336D5562,0xEFA8,0x482E,0x8C,0xB3,0xC5,0xC0,0xFC,0x7A,0x7D,0xB6);
+
+
+MIDL_DEFINE_GUID(IID, IID_IMsTscAx,0x327BB5CD,0x834E,0x4400,0xAE,0xF2,0xB3,0x0E,0x15,0xE5,0xD6,0x82);
+
+
+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,0x1FB464C8,0x09BB,0x4017,0xA2,0xF5,0xEB,0x74,0x2F,0x04,0x39,0x2F);
+
+
+MIDL_DEFINE_GUID(CLSID, CLSID_MsRdpClient,0x791FA017,0x2DE3,0x492E,0xAC,0xC5,0x53,0xC6,0x7A,0x2B,0x94,0xD0);
+
+
+MIDL_DEFINE_GUID(CLSID, CLSID_MsRdpClient2,0x9059F30F,0x4EB1,0x4BD2,0x9F,0xDC,0x36,0xF4,0x3A,0x21,0x8F,0x4A);
+
+
+MIDL_DEFINE_GUID(CLSID, CLSID_MsRdpClient3,0x7584C670,0x2274,0x4EFB,0xB0,0x0B,0xD6,0xAA,0xBA,0x6D,0x38,0x50);
+
+
+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/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/rdesktop-core-tester.cpp b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/rdesktop-core-tester.cpp
new file mode 100644
index 00000000000..29992767db0
--- /dev/null
+++ b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/rdesktop-core-tester.cpp
@@ -0,0 +1,653 @@
+#include "stdafx.h"
+
+#include
+
+#include "rdesktop/rdesktop.h"
+#include "rdesktop/proto.h"
+
+extern "C"
+{
+ /* ==== BEGIN POOP ==== */
+ // Temporary implementations of stuff we totally positively need to make the Real Thing happy
+ /* produce a hex dump */
+ void
+ hexdump(unsigned char *p, unsigned int len)
+ {
+ unsigned char *line = p;
+ int i, thisline;
+ unsigned int offset = 0;
+
+ while (offset < len)
+ {
+ printf("%04x ", offset);
+ thisline = len - offset;
+ if (thisline > 16)
+ thisline = 16;
+
+ for (i = 0; i < thisline; i++)
+ printf("%02x ", line[i]);
+
+ for (; i < 16; i++)
+ printf(" ");
+
+ for (i = 0; i < thisline; i++)
+ printf("%c", (line[i] >= 0x20 && line[i] < 0x7f) ? line[i] : '.');
+
+ printf("\n");
+ offset += thisline;
+ line += thisline;
+ }
+ }
+
+ void generate_random(uint8 * random)
+ {
+ memcpy(random, "12345678901234567890123456789012", 32);
+ }
+
+ /* report an error */
+ void
+ error(char *format, ...)
+ {
+ va_list ap;
+
+ fprintf(stderr, "ERROR: ");
+
+ va_start(ap, format);
+ vfprintf(stderr, format, ap);
+ va_end(ap);
+ }
+
+ /* report a warning */
+ void
+ warning(char *format, ...)
+ {
+ va_list ap;
+
+ fprintf(stderr, "WARNING: ");
+
+ va_start(ap, format);
+ vfprintf(stderr, format, ap);
+ va_end(ap);
+ }
+
+ /* report an unimplemented protocol feature */
+ void
+ unimpl(char *format, ...)
+ {
+ va_list ap;
+
+ fprintf(stderr, "NOT IMPLEMENTED: ");
+
+ va_start(ap, format);
+ vfprintf(stderr, format, ap);
+ va_end(ap);
+ }
+
+ /* Create the bitmap cache directory */
+ BOOL
+ rd_pstcache_mkdir(void)
+ {
+ char *home;
+ char bmpcache_dir[256];
+
+ home = getenv("HOME");
+
+ if (home == NULL)
+ return False;
+
+ sprintf(bmpcache_dir, "%s/%s", home, ".rdesktop");
+
+ if ((_mkdir(bmpcache_dir) == -1) && errno != EEXIST)
+ {
+ perror(bmpcache_dir);
+ return False;
+ }
+
+ sprintf(bmpcache_dir, "%s/%s", home, ".rdesktop/cache");
+
+ if ((_mkdir(bmpcache_dir) == -1) && errno != EEXIST)
+ {
+ perror(bmpcache_dir);
+ return False;
+ }
+
+ return True;
+ }
+
+ /* open a file in the .rdesktop directory */
+ int
+ rd_open_file(char *filename)
+ {
+ char *home;
+ char fn[256];
+ int fd;
+
+ home = getenv("HOME");
+ if (home == NULL)
+ return -1;
+ sprintf(fn, "%s/.rdesktop/%s", home, filename);
+ fd = _open(fn, _O_RDWR | _O_CREAT, 0);
+ if (fd == -1)
+ perror(fn);
+ return fd;
+ }
+
+ /* close file */
+ void
+ rd_close_file(int fd)
+ {
+ _close(fd);
+ }
+
+ /* read from file*/
+ int
+ rd_read_file(int fd, void *ptr, int len)
+ {
+ return _read(fd, ptr, len);
+ }
+
+ /* write to file */
+ int
+ rd_write_file(int fd, void *ptr, int len)
+ {
+ return _write(fd, ptr, len);
+ }
+
+ /* move file pointer */
+ int
+ rd_lseek_file(int fd, int offset)
+ {
+ return _lseek(fd, offset, SEEK_SET);
+ }
+
+ /* do a write lock on a file */
+ BOOL
+ rd_lock_file(int fd, int start, int len)
+ {
+ // TODOOO...
+ return False;
+ }
+
+ int
+ load_licence(RDPCLIENT * This, unsigned char **data)
+ {
+ return -1;
+ }
+
+ void
+ save_licence(RDPCLIENT * This, unsigned char *data, int length)
+ {
+ }
+
+ /* ==== END POOP ==== */
+
+ /* ==== UI ==== */
+ // Globals are totally teh evil, but cut me some slack here
+ HWND hwnd;
+ HBITMAP hbmBuffer;
+ PVOID pBuffer;
+ HDC hdcBuffer;
+ UINT wmZMouseWheel;
+
+};
+
+static
+void
+mstsc_mousewheel(RDPCLIENT * This, int value, LPARAM lparam)
+{
+ uint16 button;
+
+ if(value < 0)
+ button = MOUSE_FLAG_BUTTON5;
+ else
+ button = MOUSE_FLAG_BUTTON4;
+
+ if(value < 0)
+ value = - value;
+
+ for(int click = 0; click < value; click += WHEEL_DELTA)
+ rdp_send_input(This, GetTickCount(), RDP_INPUT_MOUSE, button | MOUSE_FLAG_DOWN, LOWORD(lparam), HIWORD(lparam));
+}
+
+static
+LRESULT
+CALLBACK
+mstsc_WndProc(HWND hwnd, UINT uMsg, WPARAM wparam, LPARAM lparam)
+{
+ // BUGBUG: LongToPtr & PtrToLong will break on Win64
+
+ RDPCLIENT * This = reinterpret_cast(LongToPtr(GetWindowLongPtr(hwnd, GWLP_USERDATA)));
+
+ switch(uMsg)
+ {
+ case WM_CLOSE:
+ DestroyWindow(hwnd);
+ break;
+
+ // FIXME: temporary
+ case WM_DESTROY:
+ PostQuitMessage(0);
+ break;
+
+ /* Initialization */
+ case WM_CREATE:
+ This = static_cast(reinterpret_cast(lparam)->lpCreateParams);
+ SetWindowLongPtr(hwnd, GWLP_USERDATA, PtrToLong(This));
+ break;
+
+ /* Painting */
+ case WM_PRINTCLIENT:
+ if(wparam == 0)
+ break;
+
+ case WM_PAINT:
+ {
+ HDC hdc = (HDC)wparam;
+
+ // A DC was provided: print the whole client area into it
+ if(hdc)
+ {
+ RECT rc;
+ GetClientRect(hwnd, &rc);
+ BitBlt(hdc, 0, 0, rc.right, rc.bottom, hdcBuffer, 0, 0, SRCCOPY);
+ }
+ // Otherwise, we're refreshing to screen
+ else
+ {
+ PAINTSTRUCT ps;
+ hdc = BeginPaint(hwnd, &ps);
+
+ BitBlt
+ (
+ hdc,
+ ps.rcPaint.left,
+ ps.rcPaint.top,
+ ps.rcPaint.right - ps.rcPaint.left,
+ ps.rcPaint.bottom - ps.rcPaint.top,
+ hdcBuffer,
+ ps.rcPaint.left,
+ ps.rcPaint.top,
+ SRCCOPY
+ );
+
+ EndPaint(hwnd, &ps);
+ }
+ }
+
+ break;
+
+ /* Keyboard stuff */
+ case WM_SYSKEYDOWN:
+ case WM_KEYDOWN:
+ rdp_send_input(This, GetMessageTime(), RDP_INPUT_SCANCODE, RDP_KEYPRESS | (lparam & 0x1000000 ? KBD_FLAG_EXT : 0), LOBYTE(HIWORD(lparam)), 0);
+ break;
+
+ case WM_SYSKEYUP:
+ case WM_KEYUP:
+ rdp_send_input(This, GetMessageTime(), RDP_INPUT_SCANCODE, RDP_KEYRELEASE | (lparam & 0x1000000 ? KBD_FLAG_EXT : 0), LOBYTE(HIWORD(lparam)), 0);
+ break;
+
+ /* Mouse stuff */
+ // Cursor shape
+ case WM_SETCURSOR:
+ if(LOWORD(lparam) == HTCLIENT)
+ {
+ //SetCursor(hcursor);
+ return TRUE;
+ }
+
+ break;
+
+ // Movement
+ case WM_MOUSEMOVE:
+ //if(This->sendmotion || wparam & (MK_LBUTTON | MK_RBUTTON | MK_MBUTTON | MK_XBUTTON1 | MK_XBUTTON2))
+ rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_MOVE, LOWORD(lparam), HIWORD(lparam));
+
+ break;
+
+ // Buttons
+ // TODO: X buttons
+ case WM_LBUTTONDOWN:
+ rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON1 | MOUSE_FLAG_DOWN, LOWORD(lparam), HIWORD(lparam));
+ break;
+
+ case WM_RBUTTONDOWN:
+ rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON2 | MOUSE_FLAG_DOWN, LOWORD(lparam), HIWORD(lparam));
+ break;
+
+ case WM_MBUTTONDOWN:
+ rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON3 | MOUSE_FLAG_DOWN, LOWORD(lparam), HIWORD(lparam));
+ break;
+
+ case WM_LBUTTONUP:
+ rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON1, LOWORD(lparam), HIWORD(lparam));
+ break;
+
+ case WM_RBUTTONUP:
+ rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON2, LOWORD(lparam), HIWORD(lparam));
+ break;
+
+ case WM_MBUTTONUP:
+ rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON3, LOWORD(lparam), HIWORD(lparam));
+ break;
+
+ // Wheel
+ case WM_MOUSEWHEEL:
+ mstsc_mousewheel(This, (SHORT)HIWORD(wparam), lparam);
+ break;
+
+ default:
+ /* Registered messages */
+ // Z-Mouse wheel support - you know, just in case
+ if(uMsg == wmZMouseWheel)
+ {
+ mstsc_mousewheel(This, (int)wparam, lparam);
+ break;
+ }
+
+ /* Unhandled messages */
+ return DefWindowProc(hwnd, uMsg, wparam, lparam);
+ }
+
+ return 0;
+}
+
+static
+DWORD
+WINAPI
+mstsc_ProtocolIOThread
+(
+ LPVOID lpArgument
+)
+{
+ RDPCLIENT * This = static_cast(lpArgument);
+
+ WCHAR hostname[MAX_COMPUTERNAME_LENGTH + 1];
+ DWORD dw = ARRAYSIZE(hostname);
+ GetComputerNameW(hostname, &dw);
+
+ uint32 flags = RDP_LOGON_NORMAL | RDP_LOGON_COMPRESSION | RDP_LOGON_COMPRESSION2;
+
+ rdp_connect(This, "10.0.0.3", flags, L"Administrator", L"", L"", L"", L"", hostname, "");
+ //rdp_connect(This, "192.168.7.232", flags, "", "", "", "");
+
+ hdcBuffer = CreateCompatibleDC(NULL);
+
+ BITMAPINFO bmi;
+ bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
+ bmi.bmiHeader.biWidth = This->width;
+ bmi.bmiHeader.biHeight = This->height;
+ bmi.bmiHeader.biPlanes = 1;
+ bmi.bmiHeader.biBitCount = This->server_depth;
+ bmi.bmiHeader.biCompression = BI_RGB;
+ bmi.bmiHeader.biSizeImage = 0;
+ bmi.bmiHeader.biXPelsPerMeter = 0;
+ bmi.bmiHeader.biYPelsPerMeter = 0;
+ bmi.bmiHeader.biClrUsed = 0; // TODO! palette displays
+ bmi.bmiHeader.biClrImportant = 0; // TODO! palette displays
+
+ hbmBuffer = CreateDIBSection(hdcBuffer, &bmi, DIB_RGB_COLORS, &pBuffer, NULL, 0);
+
+ SelectObject(hdcBuffer, hbmBuffer);
+
+#if 0
+ rcClip.left = 0;
+ rcClip.top = 0;
+ rcClip.right = This->width + 1;
+ rcClip.bottom = This->height + 1;
+#endif
+
+ BOOL deactivated;
+ uint32 ext_disc_reason;
+
+ rdp_main_loop(This, &deactivated, &ext_disc_reason);
+ // TODO: handle redirection
+ // EVENT: OnDisconnect
+
+ SendMessage(hwnd, WM_CLOSE, 0, 0);
+
+ 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);
+
+#if 0 // TODO
+ 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;
+ }
+#endif
+
+ 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;
+
+#if 0 // TODO
+ 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;
+ }
+ }
+#endif
+
+ 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;
+ WSAStartup(MAKEWORD(2, 2), &wsd);
+
+ static RDPCLIENT This_; // NOTE: this is HUGE and would overflow the stack!
+ ZeroMemory(&This_, sizeof(This_));
+
+ RDPCLIENT * This = &This_;
+
+ /*
+ Threading model for MissTosca:
+ - main thread is the GUI thread. Message loop maintained by caller
+ - protocol I/O is handled in an I/O thread (or thread pool)
+ - extra threads maintained by virtual channel handlers. Virtual channel writes are thread-neutral
+
+ How we handle drawing: at the moment just an off-screen buffer we dump on-screen when asked to.
+ Still considering how to draw on-screen directly and *then* buffering off-screen (for example,
+ when running inside another remote session)
+ */
+
+ // FIXME: keyboard mess
+ This->keylayout = 0x409;
+ This->keyboard_type = 0x4;
+ This->keyboard_subtype = 0x0;
+ This->keyboard_functionkeys = 0xc;
+ This->width = 800;
+ This->height = 600;
+ This->server_depth = 24;
+ This->bitmap_compression = True;
+ //This->sendmotion = True;
+ This->bitmap_cache = True;
+ This->bitmap_cache_persist_enable = False;
+ This->bitmap_cache_precache = True;
+ This->encryption = True;
+ This->packet_encryption = True;
+ This->desktop_save = True;
+ This->polygon_ellipse_orders = False; // = True;
+ //This->fullscreen = False;
+ //This->grab_keyboard = True;
+ //This->hide_decorations = False;
+ This->use_rdp5 = True;
+ //This->rdpclip = True;
+ This->console_session = False;
+ //This->numlock_sync = False;
+ //This->seamless_rdp = False;
+ This->rdp5_performanceflags = RDP5_NO_WALLPAPER | RDP5_NO_FULLWINDOWDRAG | RDP5_NO_MENUANIMATIONS;
+ This->tcp_port_rdp = TCP_PORT_RDP;
+
+#define NOT_SET -1
+ This->cache.bmpcache_lru[0] = NOT_SET;
+ This->cache.bmpcache_lru[1] = NOT_SET;
+ This->cache.bmpcache_lru[2] = NOT_SET;
+ This->cache.bmpcache_mru[0] = NOT_SET;
+ This->cache.bmpcache_mru[1] = NOT_SET;
+ This->cache.bmpcache_mru[2] = NOT_SET;
+
+ This->rdp.current_status = 1;
+
+ //hcursor = NULL;
+
+ WNDCLASS wc;
+ ZeroMemory(&wc, sizeof(wc));
+
+ wc.lpfnWndProc = mstsc_WndProc;
+ wc.hbrBackground = static_cast(GetStockObject(HOLLOW_BRUSH));
+ wc.lpszClassName = TEXT("MissTosca_Desktop");
+
+ wmZMouseWheel = RegisterWindowMessage(MSH_MOUSEWHEEL);
+
+ ATOM a = RegisterClass(&wc);
+
+ hwnd = CreateWindow
+ (
+ MAKEINTATOM(a),
+ NULL,
+ WS_POPUP | WS_VISIBLE,
+ CW_USEDEFAULT,
+ CW_USEDEFAULT,
+ This->width,
+ This->height,
+ NULL,
+ NULL,
+ NULL,
+ This
+ );
+
+ // The righ time to start the protocol thread
+ DWORD dwThreadId;
+ HANDLE hThread = CreateThread(NULL, 0, mstsc_ProtocolIOThread, This, 0, &dwThreadId);
+
+ // Your standard, garden variety message loop
+ MSG msg;
+
+ while(GetMessage(&msg, NULL, 0, 0))
+ {
+ TranslateMessage(&msg);
+ DispatchMessage(&msg);
+ }
+}
+
+// EOF
diff --git a/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/rdesktop-core-tester.vcproj b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/rdesktop-core-tester.vcproj
new file mode 100644
index 00000000000..3e91425b3b5
--- /dev/null
+++ b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/rdesktop-core-tester.vcproj
@@ -0,0 +1,377 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/stdafx.cpp b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/stdafx.cpp
new file mode 100644
index 00000000000..1e9dbf2c515
--- /dev/null
+++ b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/stdafx.cpp
@@ -0,0 +1,3 @@
+#include "stdafx.h"
+
+// EOF
diff --git a/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/stdafx.h b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/stdafx.h
new file mode 100644
index 00000000000..87956e633cb
--- /dev/null
+++ b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/stdafx.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#define _CRT_SECURE_NO_DEPRECATE
+#define _SECURE_SCL 0
+
+#include
+#include
+
+#include
+#include
+#include
+#include
+
+#include
+#include
+#include
+#include
+#include
+
+#define WIN32_LEAN_AND_MEAN
+#include
+#include
+
+#include
+#include
+#include
+#include
+#include
+
+#include
+
+// EOF
diff --git a/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/typelib.rh b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/typelib.rh
new file mode 100644
index 00000000000..e14a7da2c05
--- /dev/null
+++ b/rosapps/applications/net/tsclient/porting-tools/rdesktop-core-tester/typelib.rh
@@ -0,0 +1,21 @@
+#define TOSTRING_(X) #X
+#define TOSTRING(X) TOSTRING_(X)
+
+LANGUAGE 0, 0
+
+#ifndef TYPELIB_PATH__
+#error TYPELIB_PATH__ not defined
+#endif
+
+#ifndef TYPELIB_RESOURCEID__
+#error TYPELIB_RESOURCEID__ not defined
+#endif
+
+/*
+ NOTE:
+ TYPELIB_PATH__ is defined on the command line (-D TYPELIB_PATH__=)
+ TYPELIB_RESOURCEID__ is defined before this file is included
+*/
+TYPELIB_RESOURCEID__ TYPELIB TOSTRING(TYPELIB_PATH__)
+
+// EOF
diff --git a/rosapps/applications/net/tsclient/rdesktop/COPYING b/rosapps/applications/net/tsclient/rdesktop/COPYING
new file mode 100644
index 00000000000..416ee71e5ba
--- /dev/null
+++ b/rosapps/applications/net/tsclient/rdesktop/COPYING
@@ -0,0 +1,346 @@
+This software is released under the GNU General Public License
+(reproduced below) with the additional exemption that compiling,
+linking, and/or using OpenSSL together with this software is
+allowed.
+
+---
+
+ GNU GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users. This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it. (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.) You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+ To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have. You must make sure that they, too, receive or can get the
+source code. And you must show them these terms so they know their
+rights.
+
+ We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+ Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary. To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ GNU GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License. The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language. (Hereinafter, translation is included without limitation in
+the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+ 1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+ 2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) You must cause the modified files to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ b) You must cause any work that you distribute or publish, that in
+ whole or in part contains or is derived from the Program or any
+ part thereof, to be licensed as a whole at no charge to all third
+ parties under the terms of this License.
+
+ c) If the modified program normally reads commands interactively
+ when run, you must cause it, when started running for such
+ interactive use in the most ordinary way, to print or display an
+ announcement including an appropriate copyright notice and a
+ notice that there is no warranty (or else, saying that you provide
+ a warranty) and that users may redistribute the program under
+ these conditions, and telling the user how to view a copy of this
+ License. (Exception: if the Program itself is interactive but
+ does not normally print such an announcement, your work based on
+ the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+ a) Accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of Sections
+ 1 and 2 above on a medium customarily used for software interchange; or,
+
+ b) Accompany it with a written offer, valid for at least three
+ years, to give any third party, for a charge no more than your
+ cost of physically performing source distribution, a complete
+ machine-readable copy of the corresponding source code, to be
+ distributed under the terms of Sections 1 and 2 above on a medium
+ customarily used for software interchange; or,
+
+ c) Accompany it with the information you received as to the offer
+ to distribute corresponding source code. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form with such
+ an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it. For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable. However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License. Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+ 5. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Program or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+ 6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+ 7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all. For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded. In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+ 9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation. If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+ 10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission. For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this. Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+ NO WARRANTY
+
+ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+
+ Copyright (C)
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+ Gnomovision version 69, Copyright (C) year name of author
+ Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+ `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+ , 1 April 1989
+ Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs. If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library. If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
diff --git a/rosapps/applications/net/tsclient/rdesktop/Makefile.in b/rosapps/applications/net/tsclient/rdesktop/Makefile.in
new file mode 100644
index 00000000000..17d5522fac3
--- /dev/null
+++ b/rosapps/applications/net/tsclient/rdesktop/Makefile.in
@@ -0,0 +1,158 @@
+#
+# rdesktop: A Remote Desktop Protocol client
+# Makefile.in
+# Copyright (C) Matthew Chapman 1999-2005
+#
+
+prefix = @prefix@
+exec_prefix = @exec_prefix@
+bindir = @bindir@
+mandir = @mandir@
+datadir = @datadir@
+
+VERSION = @PACKAGE_VERSION@
+KEYMAP_PATH = $(datadir)/rdesktop/keymaps/
+
+CC = @CC@
+INSTALL = @INSTALL@
+CFLAGS = @CFLAGS@ @X_CFLAGS@ @DEFS@ -DKEYMAP_PATH=\"$(KEYMAP_PATH)\"
+LDFLAGS = @LDFLAGS@ @LIBS@ @X_LIBS@ @X_EXTRA_LIBS@
+STRIP = @STRIP@
+
+TARGETS = rdesktop @RDP2VNCTARGET@
+VNCINC = @VNCINC@
+LDVNC = @LDVNC@
+VNCLINK = @VNCLINK@
+SOUNDOBJ = @SOUNDOBJ@
+
+RDPOBJ = tcp.o iso.o mcs.o secure.o licence.o rdp.o orders.o bitmap.o cache.o rdp5.o channels.o rdpdr.o serial.o printer.o disk.o parallel.o printercache.o mppc.o pstcache.o lspci.o seamless.o
+X11OBJ = rdesktop.o xwin.o xkeymap.o ewmhints.o xclip.o cliprdr.o
+VNCOBJ = vnc/rdp2vnc.o vnc/vnc.o vnc/xkeymap.o vnc/x11stubs.o
+
+.PHONY: all
+all: $(TARGETS)
+
+rdesktop: $(X11OBJ) $(SOUNDOBJ) $(RDPOBJ)
+ $(CC) $(CFLAGS) -o rdesktop $(X11OBJ) $(SOUNDOBJ) $(RDPOBJ) $(LDFLAGS) -lX11
+
+rdp2vnc: $(VNCOBJ) $(SOUNDOBJ) $(RDPOBJ)
+ $(VNCLINK) $(CFLAGS) -o rdp2vnc $(VNCOBJ) $(SOUNDOBJ) $(RDPOBJ) $(LDFLAGS) $(LDVNC)
+
+vnc/rdp2vnc.o: rdesktop.c
+ $(CC) $(CFLAGS) $(VNCINC) -DRDP2VNC -o vnc/rdp2vnc.o -c rdesktop.c
+
+vnc/vnc.o: vnc/vnc.c
+ $(CC) $(CFLAGS) $(VNCINC) -DRDP2VNC -o vnc/vnc.o -c vnc/vnc.c
+
+vnc/xkeymap.o: xkeymap.c
+ $(CC) $(CFLAGS) $(VNCINC) -DRDP2VNC -o vnc/xkeymap.o -c xkeymap.c
+
+vnc/x11stubs.o: vnc/x11stubs.c
+ $(CC) $(CFLAGS) $(VNCINC) -o vnc/x11stubs.o -c vnc/x11stubs.c
+
+.PHONY: install
+install: installbin installkeymaps installman
+
+.PHONY: installbin
+installbin: rdesktop
+ mkdir -p $(DESTDIR)$(bindir)
+ $(INSTALL) rdesktop $(DESTDIR)$(bindir)
+ $(STRIP) $(DESTDIR)$(bindir)/rdesktop
+ chmod 755 $(DESTDIR)$(bindir)/rdesktop
+
+.PHONY: installman
+installman: doc/rdesktop.1
+ mkdir -p $(DESTDIR)$(mandir)/man1
+ cp doc/rdesktop.1 $(DESTDIR)$(mandir)/man1
+ chmod 644 $(DESTDIR)$(mandir)/man1/rdesktop.1
+
+.PHONY: installkeymaps
+installkeymaps:
+ mkdir -p $(DESTDIR)$(KEYMAP_PATH)
+# Prevent copying the CVS directory
+ cp keymaps/?? keymaps/??-?? $(DESTDIR)$(KEYMAP_PATH)
+ cp keymaps/common $(DESTDIR)$(KEYMAP_PATH)
+ cp keymaps/modifiers $(DESTDIR)$(KEYMAP_PATH)
+ chmod 644 $(DESTDIR)$(KEYMAP_PATH)/*
+
+.PHONY: proto
+proto:
+ cat proto.head > proto.h
+ cproto -DMAKE_PROTO \
+ bitmap.c cache.c channels.c cliprdr.c disk.c mppc.c ewmhints.c \
+ iso.c licence.c mcs.c orders.c parallel.c printer.c printercache.c \
+ pstcache.c rdesktop.c rdp5.c rdp.c rdpdr.c rdpsnd.c rdpsnd_oss.c \
+ secure.c serial.c tcp.c xclip.c xkeymap.c xwin.c lspci.c seamless.c >> proto.h
+ cat proto.tail >> proto.h
+
+.PHONY: clean
+clean:
+ rm -f *.o *~ vnc/*.o vnc/*~ rdesktop rdp2vnc
+
+.PHONY: distclean
+distclean: clean
+ rm -rf autom4te.cache config.log config.status Makefile
+
+.PHONY: dist
+dist: rdesktop-$(VERSION).tar.gz
+
+rdesktop-$(VERSION).tar.gz: Makefile configure
+ mkdir -p /tmp/rdesktop-make-dist-dir
+ ln -sf `pwd` /tmp/rdesktop-make-dist-dir/rdesktop-$(VERSION)
+ (cd /tmp/rdesktop-make-dist-dir; \
+ tar zcvf rdesktop-$(VERSION)/rdesktop-$(VERSION).tar.gz \
+ rdesktop-$(VERSION)/COPYING \
+ rdesktop-$(VERSION)/README \
+ rdesktop-$(VERSION)/configure \
+ rdesktop-$(VERSION)/configure.ac \
+ rdesktop-$(VERSION)/config.sub \
+ rdesktop-$(VERSION)/config.guess \
+ rdesktop-$(VERSION)/bootstrap \
+ rdesktop-$(VERSION)/install-sh \
+ rdesktop-$(VERSION)/Makefile.in \
+ rdesktop-$(VERSION)/rdesktop.spec \
+ rdesktop-$(VERSION)/*.c \
+ rdesktop-$(VERSION)/*.h \
+ rdesktop-$(VERSION)/proto.head \
+ rdesktop-$(VERSION)/proto.tail \
+ rdesktop-$(VERSION)/keymaps/?? \
+ rdesktop-$(VERSION)/keymaps/??-?? \
+ rdesktop-$(VERSION)/keymaps/common \
+ rdesktop-$(VERSION)/keymaps/modifiers \
+ rdesktop-$(VERSION)/keymaps/convert-map \
+ rdesktop-$(VERSION)/doc/HACKING \
+ rdesktop-$(VERSION)/doc/AUTHORS \
+ rdesktop-$(VERSION)/doc/TODO \
+ rdesktop-$(VERSION)/doc/ChangeLog \
+ rdesktop-$(VERSION)/doc/keymapping.txt \
+ rdesktop-$(VERSION)/doc/keymap-names.txt \
+ rdesktop-$(VERSION)/doc/ipv6.txt \
+ rdesktop-$(VERSION)/doc/licensing.txt \
+ rdesktop-$(VERSION)/doc/patches.txt \
+ rdesktop-$(VERSION)/doc/redirection.txt \
+ rdesktop-$(VERSION)/doc/rdesktop.1 )
+ rm -rf /tmp/rdesktop-make-dist-dir
+
+.PHONY: dist-noversion
+dist-noversion: rdesktop.tar.gz
+
+rdesktop.tar.gz: rdesktop-$(VERSION).tar.gz
+ mkdir -p /tmp/rdesktop-make-dist-dir
+ tar zxvf $< -C /tmp/rdesktop-make-dist-dir
+ mv /tmp/rdesktop-make-dist-dir/rdesktop-$(VERSION) /tmp/rdesktop-make-dist-dir/rdesktop
+ ls /tmp/rdesktop-make-dist-dir/rdesktop
+ tar zcvf $@ -C /tmp/rdesktop-make-dist-dir rdesktop
+ rm -rf /tmp/rdesktop-make-dist-dir
+
+Makefile: Makefile.in configure
+ ./config.status
+
+configure: configure.ac
+ ./bootstrap
+
+.SUFFIXES:
+.SUFFIXES: .c .o
+
+.c.o:
+ $(CC) $(CFLAGS) -o $@ -c $<
+
diff --git a/rosapps/applications/net/tsclient/rdesktop/README b/rosapps/applications/net/tsclient/rdesktop/README
new file mode 100644
index 00000000000..d554582ba6d
--- /dev/null
+++ b/rosapps/applications/net/tsclient/rdesktop/README
@@ -0,0 +1,32 @@
+===========================================
+rdesktop: A Remote Desktop Protocol client.
+===========================================
+
+rdesktop is a client for Microsoft Windows NT Terminal Server, Windows 2000
+Terminal Services, Windows 2003 Terminal Services/Remote Desktop, Windows XP
+Remote Desktop, and possibly other Terminal Services products.
+rdesktop currently implements the RDP version 4 and 5 protocols.
+
+Installation
+------------
+rdesktop uses a typical GNU-style build procedure:
+
+ % ./configure [options]
+ % make
+ % make install
+
+where documentation for [options] can be found by running "./configure --help".
+Usually no options are necessary. The default is to install under /usr/local,
+this can be changed with --prefix=directory.
+
+Invocation
+----------
+
+ % rdesktop [options] server
+
+where server is the name of the Terminal Services machine. Note: if you
+receive "Connection refused", this probably means that the server does not have
+Terminal Services enabled, or there is a firewall blocking access.
+
+The rdesktop manual page lists the possible options ("man rdesktop").
+
diff --git a/rosapps/applications/net/tsclient/rdesktop/bitmap.c b/rosapps/applications/net/tsclient/rdesktop/bitmap.c
new file mode 100644
index 00000000000..d23a77c7c15
--- /dev/null
+++ b/rosapps/applications/net/tsclient/rdesktop/bitmap.c
@@ -0,0 +1,1112 @@
+/* -*- c-basic-offset: 8 -*-
+ rdesktop: A Remote Desktop Protocol client.
+ Bitmap decompression routines
+ Copyright (C) Matthew Chapman 1999-2005
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+/* three seperate function for speed when decompressing the bitmaps */
+/* when modifing one function make the change in the others */
+/* comment out #define BITMAP_SPEED_OVER_SIZE below for one slower function */
+/* j@american-data.com */
+
+#define BITMAP_SPEED_OVER_SIZE
+
+/* indent is confused by this file */
+/* *INDENT-OFF* */
+
+#include "rdesktop.h"
+
+#define CVAL(p) (*(p++))
+#ifdef NEED_ALIGN
+#ifdef L_ENDIAN
+#define CVAL2(p, v) { v = (*(p++)); v |= (*(p++)) << 8; }
+#else
+#define CVAL2(p, v) { v = (*(p++)) << 8; v |= (*(p++)); }
+#endif /* L_ENDIAN */
+#else
+#define CVAL2(p, v) { v = (*((uint16*)p)); p += 2; }
+#endif /* NEED_ALIGN */
+
+#define UNROLL8(exp) { exp exp exp exp exp exp exp exp }
+
+#define REPEAT(statement) \
+{ \
+ while((count & ~0x7) && ((x+8) < width)) \
+ UNROLL8( statement; count--; x++; ); \
+ \
+ while((count > 0) && (x < width)) \
+ { \
+ statement; \
+ count--; \
+ x++; \
+ } \
+}
+
+#define MASK_UPDATE() \
+{ \
+ mixmask <<= 1; \
+ if (mixmask == 0) \
+ { \
+ mask = fom_mask ? fom_mask : CVAL(input); \
+ mixmask = 1; \
+ } \
+}
+
+#ifdef BITMAP_SPEED_OVER_SIZE
+
+/* 1 byte bitmap decompress */
+static BOOL
+bitmap_decompress1(uint8 * output, int width, int height, uint8 * input, int size)
+{
+ uint8 *end = input + size;
+ uint8 *prevline = NULL;
+ int opcode, count, offset, isfillormix;
+ int lastopcode = -1, insertmix = False, bicolour = False;
+ uint8 code;
+ uint8 colour1 = 0, colour2 = 0;
+ uint8 mixmask, mask = 0;
+ uint8 mix = 0xff;
+ int fom_mask = 0;
+#if 0
+ uint8 *line = NULL;
+ int x = width;
+#else
+ uint8 *line = output;
+ int x = 0;
+ int y = 0;
+#endif
+
+ while (input < end)
+ {
+ fom_mask = 0;
+ code = CVAL(input);
+ opcode = code >> 4;
+ /* Handle different opcode forms */
+ switch (opcode)
+ {
+ case 0xc:
+ case 0xd:
+ case 0xe:
+ opcode -= 6;
+ count = code & 0xf;
+ offset = 16;
+ break;
+ case 0xf:
+ opcode = code & 0xf;
+ if (opcode < 9)
+ {
+ count = CVAL(input);
+ count |= CVAL(input) << 8;
+ }
+ else
+ {
+ count = (opcode < 0xb) ? 8 : 1;
+ }
+ offset = 0;
+ break;
+ default:
+ opcode >>= 1;
+ count = code & 0x1f;
+ offset = 32;
+ break;
+ }
+ /* Handle strange cases for counts */
+ if (offset != 0)
+ {
+ isfillormix = ((opcode == 2) || (opcode == 7));
+ if (count == 0)
+ {
+ if (isfillormix)
+ count = CVAL(input) + 1;
+ else
+ count = CVAL(input) + offset;
+ }
+ else if (isfillormix)
+ {
+ count <<= 3;
+ }
+ }
+ /* Read preliminary data */
+ switch (opcode)
+ {
+ case 0: /* Fill */
+ if ((lastopcode == opcode) && !((x == width) && (prevline == NULL)))
+ insertmix = True;
+ break;
+ case 8: /* Bicolour */
+ colour1 = CVAL(input);
+ case 3: /* Colour */
+ colour2 = CVAL(input);
+ break;
+ case 6: /* SetMix/Mix */
+ case 7: /* SetMix/FillOrMix */
+ mix = CVAL(input);
+ opcode -= 5;
+ break;
+ case 9: /* FillOrMix_1 */
+ mask = 0x03;
+ opcode = 0x02;
+ fom_mask = 3;
+ break;
+ case 0x0a: /* FillOrMix_2 */
+ mask = 0x05;
+ opcode = 0x02;
+ fom_mask = 5;
+ break;
+ }
+ lastopcode = opcode;
+ mixmask = 0;
+ /* Output body */
+ while (count > 0)
+ {
+ if (x >= width)
+ {
+#if 0
+ if (height <= 0)
+#else
+ if (y >= height)
+#endif
+ return False;
+ x = 0;
+
+#if 0
+ height--;
+#else
+ y ++;
+#endif
+
+ prevline = line;
+
+#if 0
+ line = output + height * width;
+#else
+ line = output + y * width;
+#endif
+ }
+ switch (opcode)
+ {
+ case 0: /* Fill */
+ if (insertmix)
+ {
+ if (prevline == NULL)
+ line[x] = mix;
+ else
+ line[x] = prevline[x] ^ mix;
+ insertmix = False;
+ count--;
+ x++;
+ }
+ if (prevline == NULL)
+ {
+ REPEAT(line[x] = 0)
+ }
+ else
+ {
+ REPEAT(line[x] = prevline[x])
+ }
+ break;
+ case 1: /* Mix */
+ if (prevline == NULL)
+ {
+ REPEAT(line[x] = mix)
+ }
+ else
+ {
+ REPEAT(line[x] = prevline[x] ^ mix)
+ }
+ break;
+ case 2: /* Fill or Mix */
+ if (prevline == NULL)
+ {
+ REPEAT
+ (
+ MASK_UPDATE();
+ if (mask & mixmask)
+ line[x] = mix;
+ else
+ line[x] = 0;
+ )
+ }
+ else
+ {
+ REPEAT
+ (
+ MASK_UPDATE();
+ if (mask & mixmask)
+ line[x] = prevline[x] ^ mix;
+ else
+ line[x] = prevline[x];
+ )
+ }
+ break;
+ case 3: /* Colour */
+ REPEAT(line[x] = colour2)
+ break;
+ case 4: /* Copy */
+ REPEAT(line[x] = CVAL(input))
+ break;
+ case 8: /* Bicolour */
+ REPEAT
+ (
+ if (bicolour)
+ {
+ line[x] = colour2;
+ bicolour = False;
+ }
+ else
+ {
+ line[x] = colour1;
+ bicolour = True; count++;
+ }
+ )
+ break;
+ case 0xd: /* White */
+ REPEAT(line[x] = 0xff)
+ break;
+ case 0xe: /* Black */
+ REPEAT(line[x] = 0)
+ break;
+ default:
+ unimpl("bitmap opcode 0x%x\n", opcode);
+ return False;
+ }
+ }
+ }
+ return True;
+}
+
+/* 2 byte bitmap decompress */
+static BOOL
+bitmap_decompress2(uint8 * output, int width, int height, uint8 * input, int size)
+{
+ uint8 *end = input + size;
+ uint16 *prevline = NULL;
+ int opcode, count, offset, isfillormix;
+ int lastopcode = -1, insertmix = False, bicolour = False;
+ uint8 code;
+ uint16 colour1 = 0, colour2 = 0;
+ uint8 mixmask, mask = 0;
+ uint16 mix = 0xffff;
+ int fom_mask = 0;
+#if 0
+ uint8 *line = NULL;
+ int x = width;
+#else
+ uint8 *line = output;
+ int x = 0;
+ int y = 0;
+#endif
+
+ while (input < end)
+ {
+ fom_mask = 0;
+ code = CVAL(input);
+ opcode = code >> 4;
+ /* Handle different opcode forms */
+ switch (opcode)
+ {
+ case 0xc:
+ case 0xd:
+ case 0xe:
+ opcode -= 6;
+ count = code & 0xf;
+ offset = 16;
+ break;
+ case 0xf:
+ opcode = code & 0xf;
+ if (opcode < 9)
+ {
+ count = CVAL(input);
+ count |= CVAL(input) << 8;
+ }
+ else
+ {
+ count = (opcode < 0xb) ? 8 : 1;
+ }
+ offset = 0;
+ break;
+ default:
+ opcode >>= 1;
+ count = code & 0x1f;
+ offset = 32;
+ break;
+ }
+ /* Handle strange cases for counts */
+ if (offset != 0)
+ {
+ isfillormix = ((opcode == 2) || (opcode == 7));
+ if (count == 0)
+ {
+ if (isfillormix)
+ count = CVAL(input) + 1;
+ else
+ count = CVAL(input) + offset;
+ }
+ else if (isfillormix)
+ {
+ count <<= 3;
+ }
+ }
+ /* Read preliminary data */
+ switch (opcode)
+ {
+ case 0: /* Fill */
+ if ((lastopcode == opcode) && !((x == width) && (prevline == NULL)))
+ insertmix = True;
+ break;
+ case 8: /* Bicolour */
+ CVAL2(input, colour1);
+ case 3: /* Colour */
+ CVAL2(input, colour2);
+ break;
+ case 6: /* SetMix/Mix */
+ case 7: /* SetMix/FillOrMix */
+ CVAL2(input, mix);
+ opcode -= 5;
+ break;
+ case 9: /* FillOrMix_1 */
+ mask = 0x03;
+ opcode = 0x02;
+ fom_mask = 3;
+ break;
+ case 0x0a: /* FillOrMix_2 */
+ mask = 0x05;
+ opcode = 0x02;
+ fom_mask = 5;
+ break;
+ }
+ lastopcode = opcode;
+ mixmask = 0;
+ /* Output body */
+ while (count > 0)
+ {
+ if (x >= width)
+ {
+#if 0
+ if (height <= 0)
+#else
+ if (y >= height)
+#endif
+ return False;
+ x = 0;
+
+#if 0
+ height--;
+#else
+ y ++;
+#endif
+
+ prevline = line;
+
+#if 0
+ line = ((uint16 *) output) + height * width;
+#else
+ line = ((uint16 *) output) + y * width;
+#endif
+ }
+ switch (opcode)
+ {
+ case 0: /* Fill */
+ if (insertmix)
+ {
+ if (prevline == NULL)
+ line[x] = mix;
+ else
+ line[x] = prevline[x] ^ mix;
+ insertmix = False;
+ count--;
+ x++;
+ }
+ if (prevline == NULL)
+ {
+ REPEAT(line[x] = 0)
+ }
+ else
+ {
+ REPEAT(line[x] = prevline[x])
+ }
+ break;
+ case 1: /* Mix */
+ if (prevline == NULL)
+ {
+ REPEAT(line[x] = mix)
+ }
+ else
+ {
+ REPEAT(line[x] = prevline[x] ^ mix)
+ }
+ break;
+ case 2: /* Fill or Mix */
+ if (prevline == NULL)
+ {
+ REPEAT
+ (
+ MASK_UPDATE();
+ if (mask & mixmask)
+ line[x] = mix;
+ else
+ line[x] = 0;
+ )
+ }
+ else
+ {
+ REPEAT
+ (
+ MASK_UPDATE();
+ if (mask & mixmask)
+ line[x] = prevline[x] ^ mix;
+ else
+ line[x] = prevline[x];
+ )
+ }
+ break;
+ case 3: /* Colour */
+ REPEAT(line[x] = colour2)
+ break;
+ case 4: /* Copy */
+ REPEAT(CVAL2(input, line[x]))
+ break;
+ case 8: /* Bicolour */
+ REPEAT
+ (
+ if (bicolour)
+ {
+ line[x] = colour2;
+ bicolour = False;
+ }
+ else
+ {
+ line[x] = colour1;
+ bicolour = True;
+ count++;
+ }
+ )
+ break;
+ case 0xd: /* White */
+ REPEAT(line[x] = 0xffff)
+ break;
+ case 0xe: /* Black */
+ REPEAT(line[x] = 0)
+ break;
+ default:
+ unimpl("bitmap opcode 0x%x\n", opcode);
+ return False;
+ }
+ }
+ }
+ return True;
+}
+
+/* 3 byte bitmap decompress */
+static BOOL
+bitmap_decompress3(uint8 * output, int width, int height, uint8 * input, int size)
+{
+ uint8 *end = input + size;
+ uint8 *prevline = NULL;
+ int opcode, count, offset, isfillormix;
+ int lastopcode = -1, insertmix = False, bicolour = False;
+ uint8 code;
+ uint8 colour1[3] = {0, 0, 0}, colour2[3] = {0, 0, 0};
+ uint8 mixmask, mask = 0;
+ uint8 mix[3] = {0xff, 0xff, 0xff};
+ int fom_mask = 0;
+#if 0
+ uint8 *line = NULL;
+ int x = width;
+#else
+ uint8 *line = output;
+ int x = 0;
+ int y = 0;
+#endif
+
+ while (input < end)
+ {
+ fom_mask = 0;
+ code = CVAL(input);
+ opcode = code >> 4;
+ /* Handle different opcode forms */
+ switch (opcode)
+ {
+ case 0xc:
+ case 0xd:
+ case 0xe:
+ opcode -= 6;
+ count = code & 0xf;
+ offset = 16;
+ break;
+ case 0xf:
+ opcode = code & 0xf;
+ if (opcode < 9)
+ {
+ count = CVAL(input);
+ count |= CVAL(input) << 8;
+ }
+ else
+ {
+ count = (opcode <
+ 0xb) ? 8 : 1;
+ }
+ offset = 0;
+ break;
+ default:
+ opcode >>= 1;
+ count = code & 0x1f;
+ offset = 32;
+ break;
+ }
+ /* Handle strange cases for counts */
+ if (offset != 0)
+ {
+ isfillormix = ((opcode == 2) || (opcode == 7));
+ if (count == 0)
+ {
+ if (isfillormix)
+ count = CVAL(input) + 1;
+ else
+ count = CVAL(input) + offset;
+ }
+ else if (isfillormix)
+ {
+ count <<= 3;
+ }
+ }
+ /* Read preliminary data */
+ switch (opcode)
+ {
+ case 0: /* Fill */
+ if ((lastopcode == opcode) && !((x == width) && (prevline == NULL)))
+ insertmix = True;
+ break;
+ case 8: /* Bicolour */
+ colour1[0] = CVAL(input);
+ colour1[1] = CVAL(input);
+ colour1[2] = CVAL(input);
+ case 3: /* Colour */
+ colour2[0] = CVAL(input);
+ colour2[1] = CVAL(input);
+ colour2[2] = CVAL(input);
+ break;
+ case 6: /* SetMix/Mix */
+ case 7: /* SetMix/FillOrMix */
+ mix[0] = CVAL(input);
+ mix[1] = CVAL(input);
+ mix[2] = CVAL(input);
+ opcode -= 5;
+ break;
+ case 9: /* FillOrMix_1 */
+ mask = 0x03;
+ opcode = 0x02;
+ fom_mask = 3;
+ break;
+ case 0x0a: /* FillOrMix_2 */
+ mask = 0x05;
+ opcode = 0x02;
+ fom_mask = 5;
+ break;
+ }
+ lastopcode = opcode;
+ mixmask = 0;
+ /* Output body */
+ while (count > 0)
+ {
+ if (x >= width)
+ {
+#if 0
+ if (height <= 0)
+#else
+ if (y >= height)
+#endif
+ return False;
+ x = 0;
+
+#if 0
+ height--;
+#else
+ y ++;
+#endif
+
+ prevline = line;
+
+#if 0
+ line = output + height * (width * 3);
+#else
+ line = output + y * (width * 3);
+#endif
+ }
+ switch (opcode)
+ {
+ case 0: /* Fill */
+ if (insertmix)
+ {
+ if (prevline == NULL)
+ {
+ line[x * 3] = mix[0];
+ line[x * 3 + 1] = mix[1];
+ line[x * 3 + 2] = mix[2];
+ }
+ else
+ {
+ line[x * 3] =
+ prevline[x * 3] ^ mix[0];
+ line[x * 3 + 1] =
+ prevline[x * 3 + 1] ^ mix[1];
+ line[x * 3 + 2] =
+ prevline[x * 3 + 2] ^ mix[2];
+ }
+ insertmix = False;
+ count--;
+ x++;
+ }
+ if (prevline == NULL)
+ {
+ REPEAT
+ (
+ line[x * 3] = 0;
+ line[x * 3 + 1] = 0;
+ line[x * 3 + 2] = 0;
+ )
+ }
+ else
+ {
+ REPEAT
+ (
+ line[x * 3] = prevline[x * 3];
+ line[x * 3 + 1] = prevline[x * 3 + 1];
+ line[x * 3 + 2] = prevline[x * 3 + 2];
+ )
+ }
+ break;
+ case 1: /* Mix */
+ if (prevline == NULL)
+ {
+ REPEAT
+ (
+ line[x * 3] = mix[0];
+ line[x * 3 + 1] = mix[1];
+ line[x * 3 + 2] = mix[2];
+ )
+ }
+ else
+ {
+ REPEAT
+ (
+ line[x * 3] =
+ prevline[x * 3] ^ mix[0];
+ line[x * 3 + 1] =
+ prevline[x * 3 + 1] ^ mix[1];
+ line[x * 3 + 2] =
+ prevline[x * 3 + 2] ^ mix[2];
+ )
+ }
+ break;
+ case 2: /* Fill or Mix */
+ if (prevline == NULL)
+ {
+ REPEAT
+ (
+ MASK_UPDATE();
+ if (mask & mixmask)
+ {
+ line[x * 3] = mix[0];
+ line[x * 3 + 1] = mix[1];
+ line[x * 3 + 2] = mix[2];
+ }
+ else
+ {
+ line[x * 3] = 0;
+ line[x * 3 + 1] = 0;
+ line[x * 3 + 2] = 0;
+ }
+ )
+ }
+ else
+ {
+ REPEAT
+ (
+ MASK_UPDATE();
+ if (mask & mixmask)
+ {
+ line[x * 3] =
+ prevline[x * 3] ^ mix [0];
+ line[x * 3 + 1] =
+ prevline[x * 3 + 1] ^ mix [1];
+ line[x * 3 + 2] =
+ prevline[x * 3 + 2] ^ mix [2];
+ }
+ else
+ {
+ line[x * 3] =
+ prevline[x * 3];
+ line[x * 3 + 1] =
+ prevline[x * 3 + 1];
+ line[x * 3 + 2] =
+ prevline[x * 3 + 2];
+ }
+ )
+ }
+ break;
+ case 3: /* Colour */
+ REPEAT
+ (
+ line[x * 3] = colour2 [0];
+ line[x * 3 + 1] = colour2 [1];
+ line[x * 3 + 2] = colour2 [2];
+ )
+ break;
+ case 4: /* Copy */
+ REPEAT
+ (
+ line[x * 3] = CVAL(input);
+ line[x * 3 + 1] = CVAL(input);
+ line[x * 3 + 2] = CVAL(input);
+ )
+ break;
+ case 8: /* Bicolour */
+ REPEAT
+ (
+ if (bicolour)
+ {
+ line[x * 3] = colour2[0];
+ line[x * 3 + 1] = colour2[1];
+ line[x * 3 + 2] = colour2[2];
+ bicolour = False;
+ }
+ else
+ {
+ line[x * 3] = colour1[0];
+ line[x * 3 + 1] = colour1[1];
+ line[x * 3 + 2] = colour1[2];
+ bicolour = True;
+ count++;
+ }
+ )
+ break;
+ case 0xd: /* White */
+ REPEAT
+ (
+ line[x * 3] = 0xff;
+ line[x * 3 + 1] = 0xff;
+ line[x * 3 + 2] = 0xff;
+ )
+ break;
+ case 0xe: /* Black */
+ REPEAT
+ (
+ line[x * 3] = 0;
+ line[x * 3 + 1] = 0;
+ line[x * 3 + 2] = 0;
+ )
+ break;
+ default:
+ unimpl("bitmap opcode 0x%x\n", opcode);
+ return False;
+ }
+ }
+ }
+ return True;
+}
+
+#else
+
+static uint32
+cvalx(uint8 **input, int Bpp)
+{
+ uint32 rv = 0;
+ memcpy(&rv, *input, Bpp);
+ *input += Bpp;
+ return rv;
+}
+
+static void
+setli(uint8 *input, int offset, uint32 value, int Bpp)
+{
+ input += offset * Bpp;
+ memcpy(input, &value, Bpp);
+}
+
+static uint32
+getli(uint8 *input, int offset, int Bpp)
+{
+ uint32 rv = 0;
+ input += offset * Bpp;
+ memcpy(&rv, input, Bpp);
+ return rv;
+}
+
+static BOOL
+bitmap_decompressx(uint8 *output, int width, int height, uint8 *input, int size, int Bpp)
+{
+ uint8 *end = input + size;
+ uint8 *prevline = NULL;
+ int opcode, count, offset, isfillormix;
+ int lastopcode = -1, insertmix = False, bicolour = False;
+ uint8 code;
+ uint32 colour1 = 0, colour2 = 0;
+ uint8 mixmask, mask = 0;
+ uint32 mix = 0xffffffff;
+ int fom_mask = 0;
+#if 0
+ uint8 *line = NULL;
+ int x = width;
+#else
+ uint8 *line = output;
+ int x = 0;
+ int y = 0;
+#endif
+
+ while (input < end)
+ {
+ fom_mask = 0;
+ code = CVAL(input);
+ opcode = code >> 4;
+
+ /* Handle different opcode forms */
+ switch (opcode)
+ {
+ case 0xc:
+ case 0xd:
+ case 0xe:
+ opcode -= 6;
+ count = code & 0xf;
+ offset = 16;
+ break;
+
+ case 0xf:
+ opcode = code & 0xf;
+ if (opcode < 9)
+ {
+ count = CVAL(input);
+ count |= CVAL(input) << 8;
+ }
+ else
+ {
+ count = (opcode < 0xb) ? 8 : 1;
+ }
+ offset = 0;
+ break;
+
+ default:
+ opcode >>= 1;
+ count = code & 0x1f;
+ offset = 32;
+ break;
+ }
+
+ /* Handle strange cases for counts */
+ if (offset != 0)
+ {
+ isfillormix = ((opcode == 2) || (opcode == 7));
+
+ if (count == 0)
+ {
+ if (isfillormix)
+ count = CVAL(input) + 1;
+ else
+ count = CVAL(input) + offset;
+ }
+ else if (isfillormix)
+ {
+ count <<= 3;
+ }
+ }
+
+ /* Read preliminary data */
+ switch (opcode)
+ {
+ case 0: /* Fill */
+ if ((lastopcode == opcode) && !((x == width) && (prevline == NULL)))
+ insertmix = True;
+ break;
+ case 8: /* Bicolour */
+ colour1 = cvalx(&input, Bpp);
+ case 3: /* Colour */
+ colour2 = cvalx(&input, Bpp);
+ break;
+ case 6: /* SetMix/Mix */
+ case 7: /* SetMix/FillOrMix */
+ mix = cvalx(&input, Bpp);
+ opcode -= 5;
+ break;
+ case 9: /* FillOrMix_1 */
+ mask = 0x03;
+ opcode = 0x02;
+ fom_mask = 3;
+ break;
+ case 0x0a: /* FillOrMix_2 */
+ mask = 0x05;
+ opcode = 0x02;
+ fom_mask = 5;
+ break;
+
+ }
+
+ lastopcode = opcode;
+ mixmask = 0;
+
+ /* Output body */
+ while (count > 0)
+ {
+ if (x >= width)
+ {
+#if 0
+ if (height <= 0)
+#else
+ if (y >= height)
+#endif
+ return False;
+
+ x = 0;
+
+#if 0
+ height--;
+#else
+ y ++;
+#endif
+
+ prevline = line;
+
+#if 0
+ line = output + height * width * Bpp;
+#else
+ line = output + y * width * Bpp;
+#endif
+ }
+
+ switch (opcode)
+ {
+ case 0: /* Fill */
+ if (insertmix)
+ {
+ if (prevline == NULL)
+ setli(line, x, mix, Bpp);
+ else
+ setli(line, x,
+ getli(prevline, x, Bpp) ^ mix, Bpp);
+
+ insertmix = False;
+ count--;
+ x++;
+ }
+
+ if (prevline == NULL)
+ {
+ REPEAT(setli(line, x, 0, Bpp))}
+ else
+ {
+ REPEAT(setli
+ (line, x, getli(prevline, x, Bpp), Bpp));
+ }
+ break;
+
+ case 1: /* Mix */
+ if (prevline == NULL)
+ {
+ REPEAT(setli(line, x, mix, Bpp));
+ }
+ else
+ {
+ REPEAT(setli
+ (line, x, getli(prevline, x, Bpp) ^ mix,
+ Bpp));
+ }
+ break;
+
+ case 2: /* Fill or Mix */
+ if (prevline == NULL)
+ {
+ REPEAT(MASK_UPDATE();
+ if (mask & mixmask) setli(line, x, mix, Bpp);
+ else
+ setli(line, x, 0, Bpp););
+ }
+ else
+ {
+ REPEAT(MASK_UPDATE();
+ if (mask & mixmask)
+ setli(line, x, getli(prevline, x, Bpp) ^ mix,
+ Bpp);
+ else
+ setli(line, x, getli(prevline, x, Bpp),
+ Bpp););
+ }
+ break;
+
+ case 3: /* Colour */
+ REPEAT(setli(line, x, colour2, Bpp));
+ break;
+
+ case 4: /* Copy */
+ REPEAT(setli(line, x, cvalx(&input, Bpp), Bpp));
+ break;
+
+ case 8: /* Bicolour */
+ REPEAT(if (bicolour)
+ {
+ setli(line, x, colour2, Bpp); bicolour = False;}
+ else
+ {
+ setli(line, x, colour1, Bpp); bicolour = True;
+ count++;}
+ );
+ break;
+
+ case 0xd: /* White */
+ REPEAT(setli(line, x, 0xffffffff, Bpp));
+ break;
+
+ case 0xe: /* Black */
+ REPEAT(setli(line, x, 0, Bpp));
+ break;
+
+ default:
+ unimpl("bitmap opcode 0x%x\n", opcode);
+ return False;
+ }
+ }
+ }
+
+ return True;
+}
+
+#endif
+
+/* main decompress function */
+BOOL
+bitmap_decompress(uint8 * output, int width, int height, uint8 * input, int size, int Bpp)
+{
+#ifdef BITMAP_SPEED_OVER_SIZE
+ BOOL rv = False;
+ switch (Bpp)
+ {
+ case 1:
+ rv = bitmap_decompress1(output, width, height, input, size);
+ break;
+ case 2:
+ rv = bitmap_decompress2(output, width, height, input, size);
+ break;
+ case 3:
+ rv = bitmap_decompress3(output, width, height, input, size);
+ break;
+ }
+#else
+ BOOL rv;
+ rv = bitmap_decompressx(output, width, height, input, size, Bpp);
+#endif
+ return rv;
+}
+
+/* *INDENT-ON* */
diff --git a/rosapps/applications/net/tsclient/rdesktop/bootstrap b/rosapps/applications/net/tsclient/rdesktop/bootstrap
new file mode 100644
index 00000000000..73979144b4b
--- /dev/null
+++ b/rosapps/applications/net/tsclient/rdesktop/bootstrap
@@ -0,0 +1,3 @@
+#!/bin/sh
+rm -rf autom4te.cache
+autoreconf -i
diff --git a/rosapps/applications/net/tsclient/rdesktop/cache.c b/rosapps/applications/net/tsclient/rdesktop/cache.c
new file mode 100644
index 00000000000..dd0bb491755
--- /dev/null
+++ b/rosapps/applications/net/tsclient/rdesktop/cache.c
@@ -0,0 +1,414 @@
+/* -*- c-basic-offset: 8 -*-
+ rdesktop: A Remote Desktop Protocol client.
+ Cache routines
+ Copyright (C) Matthew Chapman 1999-2005
+ Copyright (C) Jeroen Meijer 2005
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "rdesktop.h"
+
+#undef IS_SET // !!!FIXME!!!
+
+/* BITMAP CACHE */
+#define NUM_ELEMENTS(array) (sizeof(array) / sizeof(array[0]))
+#define IS_PERSISTENT(id) (This->pstcache_fd[id] > 0)
+#define TO_TOP -1
+#define NOT_SET -1
+#define IS_SET(idx) (idx >= 0)
+
+/*
+ * TODO: Test for optimal value of BUMP_COUNT. TO_TOP gives lowest cpu utilisation but using
+ * a positive value will hopefully result in less frequently used bitmaps having a greater chance
+ * of being evicted from the cache, and therby reducing the need to load bitmaps from disk.
+ * (Jeroen)
+ */
+#define BUMP_COUNT 40
+
+/* Setup the bitmap cache lru/mru linked list */
+void
+cache_rebuild_bmpcache_linked_list(RDPCLIENT * This, uint8 id, sint16 * idx, int count)
+{
+ int n = count, c = 0;
+ sint16 n_idx;
+
+ /* find top, skip evicted bitmaps */
+ while (--n >= 0 && This->cache.bmpcache[id][idx[n]].bitmap == NULL);
+ if (n < 0)
+ {
+ This->cache.bmpcache_mru[id] = This->cache.bmpcache_lru[id] = NOT_SET;
+ return;
+ }
+
+ This->cache.bmpcache_mru[id] = idx[n];
+ This->cache.bmpcache[id][idx[n]].next = NOT_SET;
+ n_idx = idx[n];
+ c++;
+
+ /* link list */
+ while (n >= 0)
+ {
+ /* skip evicted bitmaps */
+ while (--n >= 0 && This->cache.bmpcache[id][idx[n]].bitmap == NULL);
+
+ if (n < 0)
+ break;
+
+ This->cache.bmpcache[id][n_idx].previous = idx[n];
+ This->cache.bmpcache[id][idx[n]].next = n_idx;
+ n_idx = idx[n];
+ c++;
+ }
+
+ This->cache.bmpcache[id][n_idx].previous = NOT_SET;
+ This->cache.bmpcache_lru[id] = n_idx;
+
+ if (c != This->cache.bmpcache_count[id])
+ {
+ error("Oops. %d in bitmap cache linked list, %d in ui cache...\n", c,
+ This->cache.bmpcache_count[id]);
+ exit(1);
+ }
+}
+
+/* Move a bitmap to a new position in the linked list. */
+void
+cache_bump_bitmap(RDPCLIENT * This, uint8 id, uint16 idx, int bump)
+{
+ int p_idx, n_idx, n;
+
+ if (!IS_PERSISTENT(id))
+ return;
+
+ if (This->cache.bmpcache_mru[id] == idx)
+ return;
+
+ DEBUG_RDP5(("bump bitmap: id=%d, idx=%d, bump=%d\n", id, idx, bump));
+
+ n_idx = This->cache.bmpcache[id][idx].next;
+ p_idx = This->cache.bmpcache[id][idx].previous;
+
+ if (IS_SET(n_idx))
+ {
+ /* remove */
+ --This->cache.bmpcache_count[id];
+ if (IS_SET(p_idx))
+ This->cache.bmpcache[id][p_idx].next = n_idx;
+ else
+ This->cache.bmpcache_lru[id] = n_idx;
+ if (IS_SET(n_idx))
+ This->cache.bmpcache[id][n_idx].previous = p_idx;
+ else
+ This->cache.bmpcache_mru[id] = p_idx;
+ }
+ else
+ {
+ p_idx = NOT_SET;
+ n_idx = This->cache.bmpcache_lru[id];
+ }
+
+ if (bump >= 0)
+ {
+ for (n = 0; n < bump && IS_SET(n_idx); n++)
+ {
+ p_idx = n_idx;
+ n_idx = This->cache.bmpcache[id][p_idx].next;
+ }
+ }
+ else
+ {
+ p_idx = This->cache.bmpcache_mru[id];
+ n_idx = NOT_SET;
+ }
+
+ /* insert */
+ ++This->cache.bmpcache_count[id];
+ This->cache.bmpcache[id][idx].previous = p_idx;
+ This->cache.bmpcache[id][idx].next = n_idx;
+
+ if (p_idx >= 0)
+ This->cache.bmpcache[id][p_idx].next = idx;
+ else
+ This->cache.bmpcache_lru[id] = idx;
+
+ if (n_idx >= 0)
+ This->cache.bmpcache[id][n_idx].previous = idx;
+ else
+ This->cache.bmpcache_mru[id] = idx;
+}
+
+/* Evict the least-recently used bitmap from the cache */
+void
+cache_evict_bitmap(RDPCLIENT * This, uint8 id)
+{
+ uint16 idx;
+ int n_idx;
+
+ if (!IS_PERSISTENT(id))
+ return;
+
+ idx = This->cache.bmpcache_lru[id];
+ n_idx = This->cache.bmpcache[id][idx].next;
+ DEBUG_RDP5(("evict bitmap: id=%d idx=%d n_idx=%d bmp=0x%x\n", id, idx, n_idx,
+ This->cache.bmpcache[id][idx].bitmap));
+
+ ui_destroy_bitmap(This, This->cache.bmpcache[id][idx].bitmap);
+ --This->cache.bmpcache_count[id];
+ This->cache.bmpcache[id][idx].bitmap = 0;
+
+ This->cache.bmpcache_lru[id] = n_idx;
+ This->cache.bmpcache[id][n_idx].previous = NOT_SET;
+
+ pstcache_touch_bitmap(This, id, idx, 0);
+}
+
+/* Retrieve a bitmap from the cache */
+HBITMAP
+cache_get_bitmap(RDPCLIENT * This, uint8 id, uint16 idx)
+{
+ if ((id < NUM_ELEMENTS(This->cache.bmpcache)) && (idx < NUM_ELEMENTS(This->cache.bmpcache[0])))
+ {
+ if (This->cache.bmpcache[id][idx].bitmap || pstcache_load_bitmap(This, id, idx))
+ {
+ if (IS_PERSISTENT(id))
+ cache_bump_bitmap(This, id, idx, BUMP_COUNT);
+
+ return This->cache.bmpcache[id][idx].bitmap;
+ }
+ }
+ else if ((id < NUM_ELEMENTS(This->cache.volatile_bc)) && (idx == 0x7fff))
+ {
+ return This->cache.volatile_bc[id];
+ }
+
+ error("get bitmap %d:%d\n", id, idx);
+ return NULL;
+}
+
+/* Store a bitmap in the cache */
+void
+cache_put_bitmap(RDPCLIENT * This, uint8 id, uint16 idx, HBITMAP bitmap)
+{
+ HBITMAP old;
+
+ if ((id < NUM_ELEMENTS(This->cache.bmpcache)) && (idx < NUM_ELEMENTS(This->cache.bmpcache[0])))
+ {
+ old = This->cache.bmpcache[id][idx].bitmap;
+ if (old != NULL)
+ ui_destroy_bitmap(This, old);
+ This->cache.bmpcache[id][idx].bitmap = bitmap;
+
+ if (IS_PERSISTENT(id))
+ {
+ if (old == NULL)
+ This->cache.bmpcache[id][idx].previous = This->cache.bmpcache[id][idx].next = NOT_SET;
+
+ cache_bump_bitmap(This, id, idx, TO_TOP);
+ if (This->cache.bmpcache_count[id] > BMPCACHE2_C2_CELLS)
+ cache_evict_bitmap(This, id);
+ }
+ }
+ else if ((id < NUM_ELEMENTS(This->cache.volatile_bc)) && (idx == 0x7fff))
+ {
+ old = This->cache.volatile_bc[id];
+ if (old != NULL)
+ ui_destroy_bitmap(This, old);
+ This->cache.volatile_bc[id] = bitmap;
+ }
+ else
+ {
+ error("put bitmap %d:%d\n", id, idx);
+ }
+}
+
+/* Updates the persistent bitmap cache MRU information on exit */
+void
+cache_save_state(RDPCLIENT * This)
+{
+ uint32 id = 0, t = 0;
+ int idx;
+
+ for (id = 0; id < NUM_ELEMENTS(This->cache.bmpcache); id++)
+ if (IS_PERSISTENT(id))
+ {
+ DEBUG_RDP5(("Saving cache state for bitmap cache %d...", id));
+ idx = This->cache.bmpcache_lru[id];
+ while (idx >= 0)
+ {
+ pstcache_touch_bitmap(This, id, idx, ++t);
+ idx = This->cache.bmpcache[id][idx].next;
+ }
+ DEBUG_RDP5((" %d stamps written.\n", t));
+ }
+}
+
+
+/* FONT CACHE */
+/* Retrieve a glyph from the font cache */
+FONTGLYPH *
+cache_get_font(RDPCLIENT * This, uint8 font, uint16 character)
+{
+ FONTGLYPH *glyph;
+
+ if ((font < NUM_ELEMENTS(This->cache.fontcache)) && (character < NUM_ELEMENTS(This->cache.fontcache[0])))
+ {
+ glyph = &This->cache.fontcache[font][character];
+ if (glyph->pixmap != NULL)
+ return glyph;
+ }
+
+ error("get font %d:%d\n", font, character);
+ return NULL;
+}
+
+/* Store a glyph in the font cache */
+void
+cache_put_font(RDPCLIENT * This, uint8 font, uint16 character, uint16 offset,
+ uint16 baseline, uint16 width, uint16 height, HGLYPH pixmap)
+{
+ FONTGLYPH *glyph;
+
+ if ((font < NUM_ELEMENTS(This->cache.fontcache)) && (character < NUM_ELEMENTS(This->cache.fontcache[0])))
+ {
+ glyph = &This->cache.fontcache[font][character];
+ if (glyph->pixmap != NULL)
+ ui_destroy_glyph(This, glyph->pixmap);
+
+ glyph->offset = offset;
+ glyph->baseline = baseline;
+ glyph->width = width;
+ glyph->height = height;
+ glyph->pixmap = pixmap;
+ }
+ else
+ {
+ error("put font %d:%d\n", font, character);
+ }
+}
+
+
+/* TEXT CACHE */
+/* Retrieve a text item from the cache */
+DATABLOB *
+cache_get_text(RDPCLIENT * This, uint8 cache_id)
+{
+ DATABLOB *text;
+
+ text = &This->cache.textcache[cache_id];
+ return text;
+}
+
+/* Store a text item in the cache */
+void
+cache_put_text(RDPCLIENT * This, uint8 cache_id, void *data, int length)
+{
+ DATABLOB *text;
+ void * p = malloc(length);
+
+ if(p == NULL)
+ return;
+
+ text = &This->cache.textcache[cache_id];
+ if (text->data != NULL)
+ free(text->data);
+ text->data = p;
+ text->size = length;
+ memcpy(text->data, data, length);
+}
+
+
+/* DESKTOP CACHE */
+/* Retrieve desktop data from the cache */
+uint8 *
+cache_get_desktop(RDPCLIENT * This, uint32 offset, int cx, int cy, int bytes_per_pixel)
+{
+ int length = cx * cy * bytes_per_pixel;
+
+ if (offset > sizeof(This->cache.deskcache))
+ offset = 0;
+
+ if ((offset + length) <= sizeof(This->cache.deskcache))
+ {
+ return &This->cache.deskcache[offset];
+ }
+
+ error("get desktop %d:%d\n", offset, length);
+ return NULL;
+}
+
+/* Store desktop data in the cache */
+void
+cache_put_desktop(RDPCLIENT * This, uint32 offset, int cx, int cy, int scanline, int bytes_per_pixel, uint8 * data)
+{
+ int length = cx * cy * bytes_per_pixel;
+
+ if (offset > sizeof(This->cache.deskcache))
+ offset = 0;
+
+ if ((offset + length) <= sizeof(This->cache.deskcache))
+ {
+ cx *= bytes_per_pixel;
+ while (cy--)
+ {
+ memcpy(&This->cache.deskcache[offset], data, cx);
+ data += scanline;
+ offset += cx;
+ }
+ }
+ else
+ {
+ error("put desktop %d:%d\n", offset, length);
+ }
+}
+
+
+/* CURSOR CACHE */
+/* Retrieve cursor from cache */
+HCURSOR
+cache_get_cursor(RDPCLIENT * This, uint16 cache_idx)
+{
+ HCURSOR cursor;
+
+ if (cache_idx < NUM_ELEMENTS(This->cache.cursorcache))
+ {
+ cursor = This->cache.cursorcache[cache_idx];
+ if (cursor != NULL)
+ return cursor;
+ }
+
+ error("get cursor %d\n", cache_idx);
+ return NULL;
+}
+
+/* Store cursor in cache */
+void
+cache_put_cursor(RDPCLIENT * This, uint16 cache_idx, HCURSOR cursor)
+{
+ HCURSOR old;
+
+ if (cache_idx < NUM_ELEMENTS(This->cache.cursorcache))
+ {
+ old = This->cache.cursorcache[cache_idx];
+ if (old != NULL)
+ ui_destroy_cursor(This, old);
+
+ This->cache.cursorcache[cache_idx] = cursor;
+ }
+ else
+ {
+ error("put cursor %d\n", cache_idx);
+ }
+}
diff --git a/rosapps/applications/net/tsclient/rdesktop/channels.c b/rosapps/applications/net/tsclient/rdesktop/channels.c
new file mode 100644
index 00000000000..5c1f1bc696d
--- /dev/null
+++ b/rosapps/applications/net/tsclient/rdesktop/channels.c
@@ -0,0 +1,177 @@
+/* -*- c-basic-offset: 8 -*-
+ rdesktop: A Remote Desktop Protocol client.
+ Protocol services - Virtual channels
+ Copyright (C) Erik Forsberg 2003
+ Copyright (C) Matthew Chapman 2003-2005
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "rdesktop.h"
+
+// FIXME: header mess
+#if 0
+#define CHANNEL_CHUNK_LENGTH 1600
+#define CHANNEL_FLAG_FIRST 0x01
+#define CHANNEL_FLAG_LAST 0x02
+#define CHANNEL_FLAG_SHOW_PROTOCOL 0x10
+#endif
+
+/* FIXME: We should use the information in TAG_SRV_CHANNELS to map RDP5
+ channels to MCS channels.
+
+ The format of TAG_SRV_CHANNELS seems to be
+
+ global_channel_no (uint16le)
+ number_of_other_channels (uint16le)
+ ..followed by uint16les for the other channels.
+*/
+
+VCHANNEL *
+channel_register(RDPCLIENT * This, char *name, uint32 flags, void (*callback) (RDPCLIENT *, STREAM))
+{
+ VCHANNEL *channel;
+
+ if (!This->use_rdp5)
+ return NULL;
+
+ if (This->num_channels >= MAX_CHANNELS)
+ {
+ error("Channel table full, increase MAX_CHANNELS\n");
+ return NULL;
+ }
+
+ channel = &This->channels[This->num_channels];
+ channel->mcs_id = MCS_GLOBAL_CHANNEL + 1 + This->num_channels;
+ strncpy(channel->name, name, 8);
+ channel->flags = flags;
+ channel->process = callback;
+ This->num_channels++;
+ return channel;
+}
+
+STREAM
+channel_init(RDPCLIENT * This, VCHANNEL * channel, uint32 length)
+{
+ STREAM s;
+
+ s = sec_init(This, This->encryption ? SEC_ENCRYPT : 0, length + 8);
+ s_push_layer(s, channel_hdr, 8);
+ return s;
+}
+
+void
+channel_send(RDPCLIENT * This, STREAM s, VCHANNEL * channel)
+{
+ uint32 length, flags;
+ uint32 thislength, remaining;
+ uint8 *data;
+
+ /* first fragment sent in-place */
+ s_pop_layer(s, channel_hdr);
+ length = s->end - s->p - sizeof(CHANNEL_PDU_HEADER);
+
+ DEBUG_CHANNEL(("channel_send, length = %d\n", length));
+
+ thislength = MIN(length, CHANNEL_CHUNK_LENGTH);
+/* Note: In the original clipboard implementation, this number was
+ 1592, not 1600. However, I don't remember the reason and 1600 seems
+ to work so.. This applies only to *this* length, not the length of
+ continuation or ending packets. */
+ remaining = length - thislength;
+ flags = (remaining == 0) ? CHANNEL_FLAG_FIRST | CHANNEL_FLAG_LAST : CHANNEL_FLAG_FIRST;
+ if (channel->flags & CHANNEL_OPTION_SHOW_PROTOCOL)
+ flags |= CHANNEL_FLAG_SHOW_PROTOCOL;
+
+ out_uint32_le(s, length);
+ out_uint32_le(s, flags);
+ data = s->end = s->p + thislength;
+ DEBUG_CHANNEL(("Sending %d bytes with FLAG_FIRST\n", thislength));
+ sec_send_to_channel(This, s, This->encryption ? SEC_ENCRYPT : 0, channel->mcs_id);
+
+ /* subsequent segments copied (otherwise would have to generate headers backwards) */
+ while (remaining > 0)
+ {
+ thislength = MIN(remaining, CHANNEL_CHUNK_LENGTH);
+ remaining -= thislength;
+ flags = (remaining == 0) ? CHANNEL_FLAG_LAST : 0;
+ if (channel->flags & CHANNEL_OPTION_SHOW_PROTOCOL)
+ flags |= CHANNEL_FLAG_SHOW_PROTOCOL;
+
+ DEBUG_CHANNEL(("Sending %d bytes with flags %d\n", thislength, flags));
+
+ s = sec_init(This, This->encryption ? SEC_ENCRYPT : 0, thislength + 8);
+ out_uint32_le(s, length);
+ out_uint32_le(s, flags);
+ out_uint8p(s, data, thislength);
+ s_mark_end(s);
+ sec_send_to_channel(This, s, This->encryption ? SEC_ENCRYPT : 0, channel->mcs_id);
+
+ data += thislength;
+ }
+}
+
+void
+channel_process(RDPCLIENT * This, STREAM s, uint16 mcs_channel)
+{
+ uint32 length, flags;
+ uint32 thislength;
+ VCHANNEL *channel = NULL;
+ unsigned int i;
+ STREAM in;
+
+ for (i = 0; i < This->num_channels; i++)
+ {
+ channel = &This->channels[i];
+ if (channel->mcs_id == mcs_channel)
+ break;
+ }
+
+ if (i >= This->num_channels)
+ return;
+
+ in_uint32_le(s, length);
+ in_uint32_le(s, flags);
+ if ((flags & CHANNEL_FLAG_FIRST) && (flags & CHANNEL_FLAG_LAST))
+ {
+ /* single fragment - pass straight up */
+ channel->process(This, s);
+ }
+ else
+ {
+ /* add fragment to defragmentation buffer */
+ in = &channel->in;
+ if (flags & CHANNEL_FLAG_FIRST)
+ {
+ if (length > in->size)
+ {
+ in->data = (uint8 *) xrealloc(in->data, length);
+ in->size = length;
+ }
+ in->p = in->data;
+ }
+
+ thislength = MIN(s->end - s->p, in->data + in->size - in->p);
+ memcpy(in->p, s->p, thislength);
+ in->p += thislength;
+
+ if (flags & CHANNEL_FLAG_LAST)
+ {
+ in->end = in->p;
+ in->p = in->data;
+ channel->process(This, in);
+ }
+ }
+}
diff --git a/rosapps/applications/net/tsclient/rdesktop/cliprdr.c b/rosapps/applications/net/tsclient/rdesktop/cliprdr.c
new file mode 100644
index 00000000000..01ef9055b14
--- /dev/null
+++ b/rosapps/applications/net/tsclient/rdesktop/cliprdr.c
@@ -0,0 +1,182 @@
+/* -*- c-basic-offset: 8 -*-
+ rdesktop: A Remote Desktop Protocol client.
+ Protocol services - Clipboard functions
+ Copyright (C) Erik Forsberg 2003
+ Copyright (C) Matthew Chapman 2003
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "rdesktop.h"
+
+#define CLIPRDR_CONNECT 1
+#define CLIPRDR_FORMAT_ANNOUNCE 2
+#define CLIPRDR_FORMAT_ACK 3
+#define CLIPRDR_DATA_REQUEST 4
+#define CLIPRDR_DATA_RESPONSE 5
+
+#define CLIPRDR_REQUEST 0
+#define CLIPRDR_RESPONSE 1
+#define CLIPRDR_ERROR 2
+
+static void
+cliprdr_send_packet(RDPCLIENT * This, uint16 type, uint16 status, uint8 * data, uint32 length)
+{
+ STREAM s;
+
+ DEBUG_CLIPBOARD(("CLIPRDR send: type=%d, status=%d, length=%d\n", type, status, length));
+
+ s = channel_init(This, This->cliprdr.channel, length + 12);
+ out_uint16_le(s, type);
+ out_uint16_le(s, status);
+ out_uint32_le(s, length);
+ out_uint8p(s, data, length);
+ out_uint32(s, 0); /* pad? */
+ s_mark_end(s);
+ channel_send(This, s, This->cliprdr.channel);
+}
+
+/* Helper which announces our readiness to supply clipboard data
+ in a single format (such as CF_TEXT) to the RDP side.
+ To announce more than one format at a time, use
+ cliprdr_send_native_format_announce.
+ */
+void
+cliprdr_send_simple_native_format_announce(RDPCLIENT * This, uint32 format)
+{
+ uint8 buffer[36];
+
+ DEBUG_CLIPBOARD(("cliprdr_send_simple_native_format_announce\n"));
+
+ buf_out_uint32(buffer, format);
+ memset(buffer + 4, 0, sizeof(buffer) - 4); /* description */
+ cliprdr_send_native_format_announce(This, buffer, sizeof(buffer));
+}
+
+/* Announces our readiness to supply clipboard data in multiple
+ formats, each denoted by a 36-byte format descriptor of
+ [ uint32 format + 32-byte description ].
+ */
+void
+cliprdr_send_native_format_announce(RDPCLIENT * This, uint8 * formats_data, uint32 formats_data_length)
+{
+ DEBUG_CLIPBOARD(("cliprdr_send_native_format_announce\n"));
+
+ cliprdr_send_packet(This, CLIPRDR_FORMAT_ANNOUNCE, CLIPRDR_REQUEST, formats_data,
+ formats_data_length);
+
+ if (formats_data != This->cliprdr.last_formats)
+ {
+ if (This->cliprdr.last_formats)
+ xfree(This->cliprdr.last_formats);
+
+ This->cliprdr.last_formats = xmalloc(formats_data_length);
+ memcpy(This->cliprdr.last_formats, formats_data, formats_data_length);
+ This->cliprdr.last_formats_length = formats_data_length;
+ }
+}
+
+void
+cliprdr_send_data_request(RDPCLIENT * This, uint32 format)
+{
+ uint8 buffer[4];
+
+ DEBUG_CLIPBOARD(("cliprdr_send_data_request\n"));
+ buf_out_uint32(buffer, format);
+ cliprdr_send_packet(This, CLIPRDR_DATA_REQUEST, CLIPRDR_REQUEST, buffer, sizeof(buffer));
+}
+
+void
+cliprdr_send_data(RDPCLIENT * This, uint8 * data, uint32 length)
+{
+ DEBUG_CLIPBOARD(("cliprdr_send_data\n"));
+ cliprdr_send_packet(This, CLIPRDR_DATA_RESPONSE, CLIPRDR_RESPONSE, data, length);
+}
+
+static void
+cliprdr_process(RDPCLIENT * This, STREAM s)
+{
+ uint16 type, status;
+ uint32 length, format;
+ uint8 *data;
+
+ in_uint16_le(s, type);
+ in_uint16_le(s, status);
+ in_uint32_le(s, length);
+ data = s->p;
+
+ DEBUG_CLIPBOARD(("CLIPRDR recv: type=%d, status=%d, length=%d\n", type, status, length));
+
+ if (status == CLIPRDR_ERROR)
+ {
+ switch (type)
+ {
+ case CLIPRDR_FORMAT_ACK:
+ /* FIXME: We seem to get this when we send an announce while the server is
+ still processing a paste. Try sending another announce. */
+ cliprdr_send_native_format_announce(This, This->cliprdr.last_formats,
+ This->cliprdr.last_formats_length);
+ break;
+ case CLIPRDR_DATA_RESPONSE:
+ ui_clip_request_failed(This);
+ break;
+ default:
+ DEBUG_CLIPBOARD(("CLIPRDR error (type=%d)\n", type));
+ }
+
+ return;
+ }
+
+ switch (type)
+ {
+ case CLIPRDR_CONNECT:
+ ui_clip_sync(This);
+ break;
+ case CLIPRDR_FORMAT_ANNOUNCE:
+ ui_clip_format_announce(This, data, length);
+ cliprdr_send_packet(This, CLIPRDR_FORMAT_ACK, CLIPRDR_RESPONSE, NULL, 0);
+ return;
+ case CLIPRDR_FORMAT_ACK:
+ break;
+ case CLIPRDR_DATA_REQUEST:
+ in_uint32_le(s, format);
+ ui_clip_request_data(This, format);
+ break;
+ case CLIPRDR_DATA_RESPONSE:
+ ui_clip_handle_data(This, data, length);
+ break;
+ case 7: /* TODO: W2K3 SP1 sends this on connect with a value of 1 */
+ break;
+ default:
+ unimpl("CLIPRDR packet type %d\n", type);
+ }
+}
+
+void
+cliprdr_set_mode(RDPCLIENT * This, const char *optarg)
+{
+ ui_clip_set_mode(This, optarg);
+}
+
+BOOL
+cliprdr_init(RDPCLIENT * This)
+{
+ This->cliprdr.channel =
+ channel_register(This, "cliprdr",
+ CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP |
+ CHANNEL_OPTION_COMPRESS_RDP | CHANNEL_OPTION_SHOW_PROTOCOL,
+ cliprdr_process);
+ return (This->cliprdr.channel != NULL);
+}
diff --git a/rosapps/applications/net/tsclient/rdesktop/config.guess b/rosapps/applications/net/tsclient/rdesktop/config.guess
new file mode 100644
index 00000000000..2fc3acce2ea
--- /dev/null
+++ b/rosapps/applications/net/tsclient/rdesktop/config.guess
@@ -0,0 +1,1411 @@
+#! /bin/sh
+# Attempt to guess a canonical system name.
+# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+# 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+
+timestamp='2003-06-17'
+
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# Originally written by Per Bothner .
+# Please send patches to . Submit a context
+# diff and a properly formatted ChangeLog entry.
+#
+# This script attempts to guess a canonical system name similar to
+# config.sub. If it succeeds, it prints the system name on stdout, and
+# exits with 0. Otherwise, it exits with 1.
+#
+# The plan is that this can be called by configure scripts if you
+# don't specify an explicit build system type.
+
+me=`echo "$0" | sed -e 's,.*/,,'`
+
+usage="\
+Usage: $0 [OPTION]
+
+Output the configuration name of the system \`$me' is run on.
+
+Operation modes:
+ -h, --help print this help, then exit
+ -t, --time-stamp print date of last modification, then exit
+ -v, --version print version number, then exit
+
+Report bugs and patches to ."
+
+version="\
+GNU config.guess ($timestamp)
+
+Originally written by Per Bothner.
+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
+Free Software Foundation, Inc.
+
+This is free software; see the source for copying conditions. There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+
+help="
+Try \`$me --help' for more information."
+
+# Parse command line
+while test $# -gt 0 ; do
+ case $1 in
+ --time-stamp | --time* | -t )
+ echo "$timestamp" ; exit 0 ;;
+ --version | -v )
+ echo "$version" ; exit 0 ;;
+ --help | --h* | -h )
+ echo "$usage"; exit 0 ;;
+ -- ) # Stop option processing
+ shift; break ;;
+ - ) # Use stdin as input.
+ break ;;
+ -* )
+ echo "$me: invalid option $1$help" >&2
+ exit 1 ;;
+ * )
+ break ;;
+ esac
+done
+
+if test $# != 0; then
+ echo "$me: too many arguments$help" >&2
+ exit 1
+fi
+
+trap 'exit 1' 1 2 15
+
+# CC_FOR_BUILD -- compiler used by this script. Note that the use of a
+# compiler to aid in system detection is discouraged as it requires
+# temporary files to be created and, as you can see below, it is a
+# headache to deal with in a portable fashion.
+
+# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
+# use `HOST_CC' if defined, but it is deprecated.
+
+# Portable tmp directory creation inspired by the Autoconf team.
+
+set_cc_for_build='
+trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
+trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
+: ${TMPDIR=/tmp} ;
+ { tmp=`(umask 077 && mktemp -d -q "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
+ { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
+ { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
+ { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
+dummy=$tmp/dummy ;
+tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
+case $CC_FOR_BUILD,$HOST_CC,$CC in
+ ,,) echo "int x;" > $dummy.c ;
+ for c in cc gcc c89 c99 ; do
+ if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then
+ CC_FOR_BUILD="$c"; break ;
+ fi ;
+ done ;
+ if test x"$CC_FOR_BUILD" = x ; then
+ CC_FOR_BUILD=no_compiler_found ;
+ fi
+ ;;
+ ,,*) CC_FOR_BUILD=$CC ;;
+ ,*,*) CC_FOR_BUILD=$HOST_CC ;;
+esac ;'
+
+# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
+# (ghazi@noc.rutgers.edu 1994-08-24)
+if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
+ PATH=$PATH:/.attbin ; export PATH
+fi
+
+UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
+UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
+UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown
+UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
+
+## for Red Hat Linux
+if test -f /etc/redhat-release ; then
+ VENDOR=redhat ;
+else
+ VENDOR= ;
+fi
+
+# Note: order is significant - the case branches are not exclusive.
+
+case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
+ *:NetBSD:*:*)
+ # NetBSD (nbsd) targets should (where applicable) match one or
+ # more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*,
+ # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently
+ # switched to ELF, *-*-netbsd* would select the old
+ # object file format. This provides both forward
+ # compatibility and a consistent mechanism for selecting the
+ # object file format.
+ #
+ # Note: NetBSD doesn't particularly care about the vendor
+ # portion of the name. We always set it to "unknown".
+ sysctl="sysctl -n hw.machine_arch"
+ UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \
+ /usr/sbin/$sysctl 2>/dev/null || echo unknown)`
+ case "${UNAME_MACHINE_ARCH}" in
+ armeb) machine=armeb-unknown ;;
+ arm*) machine=arm-unknown ;;
+ sh3el) machine=shl-unknown ;;
+ sh3eb) machine=sh-unknown ;;
+ *) machine=${UNAME_MACHINE_ARCH}-unknown ;;
+ esac
+ # The Operating System including object format, if it has switched
+ # to ELF recently, or will in the future.
+ case "${UNAME_MACHINE_ARCH}" in
+ arm*|i386|m68k|ns32k|sh3*|sparc|vax)
+ eval $set_cc_for_build
+ if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
+ | grep __ELF__ >/dev/null
+ then
+ # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
+ # Return netbsd for either. FIX?
+ os=netbsd
+ else
+ os=netbsdelf
+ fi
+ ;;
+ *)
+ os=netbsd
+ ;;
+ esac
+ # The OS release
+ # Debian GNU/NetBSD machines have a different userland, and
+ # thus, need a distinct triplet. However, they do not need
+ # kernel version information, so it can be replaced with a
+ # suitable tag, in the style of linux-gnu.
+ case "${UNAME_VERSION}" in
+ Debian*)
+ release='-gnu'
+ ;;
+ *)
+ release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
+ ;;
+ esac
+ # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
+ # contains redundant information, the shorter form:
+ # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
+ echo "${machine}-${os}${release}"
+ exit 0 ;;
+ amiga:OpenBSD:*:*)
+ echo m68k-unknown-openbsd${UNAME_RELEASE}
+ exit 0 ;;
+ arc:OpenBSD:*:*)
+ echo mipsel-unknown-openbsd${UNAME_RELEASE}
+ exit 0 ;;
+ hp300:OpenBSD:*:*)
+ echo m68k-unknown-openbsd${UNAME_RELEASE}
+ exit 0 ;;
+ mac68k:OpenBSD:*:*)
+ echo m68k-unknown-openbsd${UNAME_RELEASE}
+ exit 0 ;;
+ macppc:OpenBSD:*:*)
+ echo powerpc-unknown-openbsd${UNAME_RELEASE}
+ exit 0 ;;
+ mvme68k:OpenBSD:*:*)
+ echo m68k-unknown-openbsd${UNAME_RELEASE}
+ exit 0 ;;
+ mvme88k:OpenBSD:*:*)
+ echo m88k-unknown-openbsd${UNAME_RELEASE}
+ exit 0 ;;
+ mvmeppc:OpenBSD:*:*)
+ echo powerpc-unknown-openbsd${UNAME_RELEASE}
+ exit 0 ;;
+ pmax:OpenBSD:*:*)
+ echo mipsel-unknown-openbsd${UNAME_RELEASE}
+ exit 0 ;;
+ sgi:OpenBSD:*:*)
+ echo mipseb-unknown-openbsd${UNAME_RELEASE}
+ exit 0 ;;
+ sun3:OpenBSD:*:*)
+ echo m68k-unknown-openbsd${UNAME_RELEASE}
+ exit 0 ;;
+ wgrisc:OpenBSD:*:*)
+ echo mipsel-unknown-openbsd${UNAME_RELEASE}
+ exit 0 ;;
+ *:OpenBSD:*:*)
+ echo ${UNAME_MACHINE}-unknown-openbsd${UNAME_RELEASE}
+ exit 0 ;;
+ alpha:OSF1:*:*)
+ if test $UNAME_RELEASE = "V4.0"; then
+ UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
+ fi
+ # According to Compaq, /usr/sbin/psrinfo has been available on
+ # OSF/1 and Tru64 systems produced since 1995. I hope that
+ # covers most systems running today. This code pipes the CPU
+ # types through head -n 1, so we only detect the type of CPU 0.
+ ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1`
+ case "$ALPHA_CPU_TYPE" in
+ "EV4 (21064)")
+ UNAME_MACHINE="alpha" ;;
+ "EV4.5 (21064)")
+ UNAME_MACHINE="alpha" ;;
+ "LCA4 (21066/21068)")
+ UNAME_MACHINE="alpha" ;;
+ "EV5 (21164)")
+ UNAME_MACHINE="alphaev5" ;;
+ "EV5.6 (21164A)")
+ UNAME_MACHINE="alphaev56" ;;
+ "EV5.6 (21164PC)")
+ UNAME_MACHINE="alphapca56" ;;
+ "EV5.7 (21164PC)")
+ UNAME_MACHINE="alphapca57" ;;
+ "EV6 (21264)")
+ UNAME_MACHINE="alphaev6" ;;
+ "EV6.7 (21264A)")
+ UNAME_MACHINE="alphaev67" ;;
+ "EV6.8CB (21264C)")
+ UNAME_MACHINE="alphaev68" ;;
+ "EV6.8AL (21264B)")
+ UNAME_MACHINE="alphaev68" ;;
+ "EV6.8CX (21264D)")
+ UNAME_MACHINE="alphaev68" ;;
+ "EV6.9A (21264/EV69A)")
+ UNAME_MACHINE="alphaev69" ;;
+ "EV7 (21364)")
+ UNAME_MACHINE="alphaev7" ;;
+ "EV7.9 (21364A)")
+ UNAME_MACHINE="alphaev79" ;;
+ esac
+ # A Vn.n version is a released version.
+ # A Tn.n version is a released field test version.
+ # A Xn.n version is an unreleased experimental baselevel.
+ # 1.2 uses "1.2" for uname -r.
+ echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[VTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
+ exit 0 ;;
+ Alpha*:OpenVMS:*:*)
+ echo alpha-hp-vms
+ exit 0 ;;
+ Alpha\ *:Windows_NT*:*)
+ # How do we know it's Interix rather than the generic POSIX subsystem?
+ # Should we change UNAME_MACHINE based on the output of uname instead
+ # of the specific Alpha model?
+ echo alpha-pc-interix
+ exit 0 ;;
+ 21064:Windows_NT:50:3)
+ echo alpha-dec-winnt3.5
+ exit 0 ;;
+ Amiga*:UNIX_System_V:4.0:*)
+ echo m68k-unknown-sysv4
+ exit 0;;
+ *:[Aa]miga[Oo][Ss]:*:*)
+ echo ${UNAME_MACHINE}-unknown-amigaos
+ exit 0 ;;
+ *:[Mm]orph[Oo][Ss]:*:*)
+ echo ${UNAME_MACHINE}-unknown-morphos
+ exit 0 ;;
+ *:OS/390:*:*)
+ echo i370-ibm-openedition
+ exit 0 ;;
+ arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
+ echo arm-acorn-riscix${UNAME_RELEASE}
+ exit 0;;
+ SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
+ echo hppa1.1-hitachi-hiuxmpp
+ exit 0;;
+ Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
+ # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
+ if test "`(/bin/universe) 2>/dev/null`" = att ; then
+ echo pyramid-pyramid-sysv3
+ else
+ echo pyramid-pyramid-bsd
+ fi
+ exit 0 ;;
+ NILE*:*:*:dcosx)
+ echo pyramid-pyramid-svr4
+ exit 0 ;;
+ DRS?6000:unix:4.0:6*)
+ echo sparc-icl-nx6
+ exit 0 ;;
+ DRS?6000:UNIX_SV:4.2*:7*)
+ case `/usr/bin/uname -p` in
+ sparc) echo sparc-icl-nx7 && exit 0 ;;
+ esac ;;
+ sun4H:SunOS:5.*:*)
+ echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+ exit 0 ;;
+ sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
+ echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+ exit 0 ;;
+ i86pc:SunOS:5.*:*)
+ echo i386-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+ exit 0 ;;
+ sun4*:SunOS:6*:*)
+ # According to config.sub, this is the proper way to canonicalize
+ # SunOS6. Hard to guess exactly what SunOS6 will be like, but
+ # it's likely to be more like Solaris than SunOS4.
+ echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+ exit 0 ;;
+ sun4*:SunOS:*:*)
+ case "`/usr/bin/arch -k`" in
+ Series*|S4*)
+ UNAME_RELEASE=`uname -v`
+ ;;
+ esac
+ # Japanese Language versions have a version number like `4.1.3-JL'.
+ echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'`
+ exit 0 ;;
+ sun3*:SunOS:*:*)
+ echo m68k-sun-sunos${UNAME_RELEASE}
+ exit 0 ;;
+ sun*:*:4.2BSD:*)
+ UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
+ test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3
+ case "`/bin/arch`" in
+ sun3)
+ echo m68k-sun-sunos${UNAME_RELEASE}
+ ;;
+ sun4)
+ echo sparc-sun-sunos${UNAME_RELEASE}
+ ;;
+ esac
+ exit 0 ;;
+ aushp:SunOS:*:*)
+ echo sparc-auspex-sunos${UNAME_RELEASE}
+ exit 0 ;;
+ # The situation for MiNT is a little confusing. The machine name
+ # can be virtually everything (everything which is not
+ # "atarist" or "atariste" at least should have a processor
+ # > m68000). The system name ranges from "MiNT" over "FreeMiNT"
+ # to the lowercase version "mint" (or "freemint"). Finally
+ # the system name "TOS" denotes a system which is actually not
+ # MiNT. But MiNT is downward compatible to TOS, so this should
+ # be no problem.
+ atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
+ echo m68k-atari-mint${UNAME_RELEASE}
+ exit 0 ;;
+ atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
+ echo m68k-atari-mint${UNAME_RELEASE}
+ exit 0 ;;
+ *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
+ echo m68k-atari-mint${UNAME_RELEASE}
+ exit 0 ;;
+ milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
+ echo m68k-milan-mint${UNAME_RELEASE}
+ exit 0 ;;
+ hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
+ echo m68k-hades-mint${UNAME_RELEASE}
+ exit 0 ;;
+ *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
+ echo m68k-unknown-mint${UNAME_RELEASE}
+ exit 0 ;;
+ powerpc:machten:*:*)
+ echo powerpc-apple-machten${UNAME_RELEASE}
+ exit 0 ;;
+ RISC*:Mach:*:*)
+ echo mips-dec-mach_bsd4.3
+ exit 0 ;;
+ RISC*:ULTRIX:*:*)
+ echo mips-dec-ultrix${UNAME_RELEASE}
+ exit 0 ;;
+ VAX*:ULTRIX*:*:*)
+ echo vax-dec-ultrix${UNAME_RELEASE}
+ exit 0 ;;
+ 2020:CLIX:*:* | 2430:CLIX:*:*)
+ echo clipper-intergraph-clix${UNAME_RELEASE}
+ exit 0 ;;
+ mips:*:*:UMIPS | mips:*:*:RISCos)
+ eval $set_cc_for_build
+ sed 's/^ //' << EOF >$dummy.c
+#ifdef __cplusplus
+#include /* for printf() prototype */
+ int main (int argc, char *argv[]) {
+#else
+ int main (argc, argv) int argc; char *argv[]; {
+#endif
+ #if defined (host_mips) && defined (MIPSEB)
+ #if defined (SYSTYPE_SYSV)
+ printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0);
+ #endif
+ #if defined (SYSTYPE_SVR4)
+ printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0);
+ #endif
+ #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
+ printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0);
+ #endif
+ #endif
+ exit (-1);
+ }
+EOF
+ $CC_FOR_BUILD -o $dummy $dummy.c \
+ && $dummy `echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` \
+ && exit 0
+ echo mips-mips-riscos${UNAME_RELEASE}
+ exit 0 ;;
+ Motorola:PowerMAX_OS:*:*)
+ echo powerpc-motorola-powermax
+ exit 0 ;;
+ Motorola:*:4.3:PL8-*)
+ echo powerpc-harris-powermax
+ exit 0 ;;
+ Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
+ echo powerpc-harris-powermax
+ exit 0 ;;
+ Night_Hawk:Power_UNIX:*:*)
+ echo powerpc-harris-powerunix
+ exit 0 ;;
+ m88k:CX/UX:7*:*)
+ echo m88k-harris-cxux7
+ exit 0 ;;
+ m88k:*:4*:R4*)
+ echo m88k-motorola-sysv4
+ exit 0 ;;
+ m88k:*:3*:R3*)
+ echo m88k-motorola-sysv3
+ exit 0 ;;
+ AViiON:dgux:*:*)
+ # DG/UX returns AViiON for all architectures
+ UNAME_PROCESSOR=`/usr/bin/uname -p`
+ if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ]
+ then
+ if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \
+ [ ${TARGET_BINARY_INTERFACE}x = x ]
+ then
+ echo m88k-dg-dgux${UNAME_RELEASE}
+ else
+ echo m88k-dg-dguxbcs${UNAME_RELEASE}
+ fi
+ else
+ echo i586-dg-dgux${UNAME_RELEASE}
+ fi
+ exit 0 ;;
+ M88*:DolphinOS:*:*) # DolphinOS (SVR3)
+ echo m88k-dolphin-sysv3
+ exit 0 ;;
+ M88*:*:R3*:*)
+ # Delta 88k system running SVR3
+ echo m88k-motorola-sysv3
+ exit 0 ;;
+ XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
+ echo m88k-tektronix-sysv3
+ exit 0 ;;
+ Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
+ echo m68k-tektronix-bsd
+ exit 0 ;;
+ *:IRIX*:*:*)
+ echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`
+ exit 0 ;;
+ ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
+ echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id
+ exit 0 ;; # Note that: echo "'`uname -s`'" gives 'AIX '
+ i*86:AIX:*:*)
+ echo i386-ibm-aix
+ exit 0 ;;
+ ia64:AIX:*:*)
+ if [ -x /usr/bin/oslevel ] ; then
+ IBM_REV=`/usr/bin/oslevel`
+ else
+ IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
+ fi
+ echo ${UNAME_MACHINE}-ibm-aix${IBM_REV}
+ exit 0 ;;
+ *:AIX:2:3)
+ if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
+ eval $set_cc_for_build
+ sed 's/^ //' << EOF >$dummy.c
+ #include
+
+ main()
+ {
+ if (!__power_pc())
+ exit(1);
+ puts("powerpc-ibm-aix3.2.5");
+ exit(0);
+ }
+EOF
+ $CC_FOR_BUILD -o $dummy $dummy.c && $dummy && exit 0
+ echo rs6000-ibm-aix3.2.5
+ elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
+ echo rs6000-ibm-aix3.2.4
+ else
+ echo rs6000-ibm-aix3.2
+ fi
+ exit 0 ;;
+ *:AIX:*:[45])
+ IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
+ if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then
+ IBM_ARCH=rs6000
+ else
+ IBM_ARCH=powerpc
+ fi
+ if [ -x /usr/bin/oslevel ] ; then
+ IBM_REV=`/usr/bin/oslevel`
+ else
+ IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
+ fi
+ echo ${IBM_ARCH}-ibm-aix${IBM_REV}
+ exit 0 ;;
+ *:AIX:*:*)
+ echo rs6000-ibm-aix
+ exit 0 ;;
+ ibmrt:4.4BSD:*|romp-ibm:BSD:*)
+ echo romp-ibm-bsd4.4
+ exit 0 ;;
+ ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and
+ echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to
+ exit 0 ;; # report: romp-ibm BSD 4.3
+ *:BOSX:*:*)
+ echo rs6000-bull-bosx
+ exit 0 ;;
+ DPX/2?00:B.O.S.:*:*)
+ echo m68k-bull-sysv3
+ exit 0 ;;
+ 9000/[34]??:4.3bsd:1.*:*)
+ echo m68k-hp-bsd
+ exit 0 ;;
+ hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
+ echo m68k-hp-bsd4.4
+ exit 0 ;;
+ 9000/[34678]??:HP-UX:*:*)
+ HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
+ case "${UNAME_MACHINE}" in
+ 9000/31? ) HP_ARCH=m68000 ;;
+ 9000/[34]?? ) HP_ARCH=m68k ;;
+ 9000/[678][0-9][0-9])
+ if [ -x /usr/bin/getconf ]; then
+ sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
+ sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
+ case "${sc_cpu_version}" in
+ 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0
+ 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1
+ 532) # CPU_PA_RISC2_0
+ case "${sc_kernel_bits}" in
+ 32) HP_ARCH="hppa2.0n" ;;
+ 64) HP_ARCH="hppa2.0w" ;;
+ '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20
+ esac ;;
+ esac
+ fi
+ if [ "${HP_ARCH}" = "" ]; then
+ eval $set_cc_for_build
+ sed 's/^ //' << EOF >$dummy.c
+
+ #define _HPUX_SOURCE
+ #include
+ #include
+
+ int main ()
+ {
+ #if defined(_SC_KERNEL_BITS)
+ long bits = sysconf(_SC_KERNEL_BITS);
+ #endif
+ long cpu = sysconf (_SC_CPU_VERSION);
+
+ switch (cpu)
+ {
+ case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
+ case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
+ case CPU_PA_RISC2_0:
+ #if defined(_SC_KERNEL_BITS)
+ switch (bits)
+ {
+ case 64: puts ("hppa2.0w"); break;
+ case 32: puts ("hppa2.0n"); break;
+ default: puts ("hppa2.0"); break;
+ } break;
+ #else /* !defined(_SC_KERNEL_BITS) */
+ puts ("hppa2.0"); break;
+ #endif
+ default: puts ("hppa1.0"); break;
+ }
+ exit (0);
+ }
+EOF
+ (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy`
+ test -z "$HP_ARCH" && HP_ARCH=hppa
+ fi ;;
+ esac
+ if [ ${HP_ARCH} = "hppa2.0w" ]
+ then
+ # avoid double evaluation of $set_cc_for_build
+ test -n "$CC_FOR_BUILD" || eval $set_cc_for_build
+ if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E -) | grep __LP64__ >/dev/null
+ then
+ HP_ARCH="hppa2.0w"
+ else
+ HP_ARCH="hppa64"
+ fi
+ fi
+ echo ${HP_ARCH}-hp-hpux${HPUX_REV}
+ exit 0 ;;
+ ia64:HP-UX:*:*)
+ HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
+ echo ia64-hp-hpux${HPUX_REV}
+ exit 0 ;;
+ 3050*:HI-UX:*:*)
+ eval $set_cc_for_build
+ sed 's/^ //' << EOF >$dummy.c
+ #include
+ int
+ main ()
+ {
+ long cpu = sysconf (_SC_CPU_VERSION);
+ /* The order matters, because CPU_IS_HP_MC68K erroneously returns
+ true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct
+ results, however. */
+ if (CPU_IS_PA_RISC (cpu))
+ {
+ switch (cpu)
+ {
+ case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
+ case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
+ case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
+ default: puts ("hppa-hitachi-hiuxwe2"); break;
+ }
+ }
+ else if (CPU_IS_HP_MC68K (cpu))
+ puts ("m68k-hitachi-hiuxwe2");
+ else puts ("unknown-hitachi-hiuxwe2");
+ exit (0);
+ }
+EOF
+ $CC_FOR_BUILD -o $dummy $dummy.c && $dummy && exit 0
+ echo unknown-hitachi-hiuxwe2
+ exit 0 ;;
+ 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* )
+ echo hppa1.1-hp-bsd
+ exit 0 ;;
+ 9000/8??:4.3bsd:*:*)
+ echo hppa1.0-hp-bsd
+ exit 0 ;;
+ *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
+ echo hppa1.0-hp-mpeix
+ exit 0 ;;
+ hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )
+ echo hppa1.1-hp-osf
+ exit 0 ;;
+ hp8??:OSF1:*:*)
+ echo hppa1.0-hp-osf
+ exit 0 ;;
+ i*86:OSF1:*:*)
+ if [ -x /usr/sbin/sysversion ] ; then
+ echo ${UNAME_MACHINE}-unknown-osf1mk
+ else
+ echo ${UNAME_MACHINE}-unknown-osf1
+ fi
+ exit 0 ;;
+ parisc*:Lites*:*:*)
+ echo hppa1.1-hp-lites
+ exit 0 ;;
+ C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
+ echo c1-convex-bsd
+ exit 0 ;;
+ C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
+ if getsysinfo -f scalar_acc
+ then echo c32-convex-bsd
+ else echo c2-convex-bsd
+ fi
+ exit 0 ;;
+ C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
+ echo c34-convex-bsd
+ exit 0 ;;
+ C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
+ echo c38-convex-bsd
+ exit 0 ;;
+ C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
+ echo c4-convex-bsd
+ exit 0 ;;
+ CRAY*Y-MP:*:*:*)
+ echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+ exit 0 ;;
+ CRAY*[A-Z]90:*:*:*)
+ echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
+ | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
+ -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
+ -e 's/\.[^.]*$/.X/'
+ exit 0 ;;
+ CRAY*TS:*:*:*)
+ echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+ exit 0 ;;
+ CRAY*T3E:*:*:*)
+ echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+ exit 0 ;;
+ CRAY*SV1:*:*:*)
+ echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+ exit 0 ;;
+ *:UNICOS/mp:*:*)
+ echo nv1-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+ exit 0 ;;
+ F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
+ FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
+ FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
+ FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
+ echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+ exit 0 ;;
+ i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
+ echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
+ exit 0 ;;
+ sparc*:BSD/OS:*:*)
+ echo sparc-unknown-bsdi${UNAME_RELEASE}
+ exit 0 ;;
+ *:BSD/OS:*:*)
+ echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
+ exit 0 ;;
+ *:FreeBSD:*:*|*:GNU/FreeBSD:*:*)
+ # Determine whether the default compiler uses glibc.
+ eval $set_cc_for_build
+ sed 's/^ //' << EOF >$dummy.c
+ #include
+ #if __GLIBC__ >= 2
+ LIBC=gnu
+ #else
+ LIBC=
+ #endif
+EOF
+ eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^LIBC=`
+ echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`${LIBC:+-$LIBC}
+ exit 0 ;;
+ i*:CYGWIN*:*)
+ echo ${UNAME_MACHINE}-pc-cygwin
+ exit 0 ;;
+ i*:MINGW*:*)
+ echo ${UNAME_MACHINE}-pc-mingw32
+ exit 0 ;;
+ i*:PW*:*)
+ echo ${UNAME_MACHINE}-pc-pw32
+ exit 0 ;;
+ x86:Interix*:[34]*)
+ echo i586-pc-interix${UNAME_RELEASE}|sed -e 's/\..*//'
+ exit 0 ;;
+ [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*)
+ echo i${UNAME_MACHINE}-pc-mks
+ exit 0 ;;
+ i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
+ # How do we know it's Interix rather than the generic POSIX subsystem?
+ # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
+ # UNAME_MACHINE based on the output of uname instead of i386?
+ echo i586-pc-interix
+ exit 0 ;;
+ i*:UWIN*:*)
+ echo ${UNAME_MACHINE}-pc-uwin
+ exit 0 ;;
+ p*:CYGWIN*:*)
+ echo powerpcle-unknown-cygwin
+ exit 0 ;;
+ prep*:SunOS:5.*:*)
+ echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+ exit 0 ;;
+ *:GNU:*:*)
+ echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
+ exit 0 ;;
+ i*86:Minix:*:*)
+ echo ${UNAME_MACHINE}-pc-minix
+ exit 0 ;;
+ arm*:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-gnu
+ exit 0 ;;
+ cris:Linux:*:*)
+ echo cris-axis-linux-gnu
+ exit 0 ;;
+ ia64:Linux:*:*)
+ echo ${UNAME_MACHINE}-${VENDOR:-unknown}-linux-gnu
+ exit 0 ;;
+ m68*:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-gnu
+ exit 0 ;;
+ mips:Linux:*:*)
+ eval $set_cc_for_build
+ sed 's/^ //' << EOF >$dummy.c
+ #undef CPU
+ #undef mips
+ #undef mipsel
+ #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
+ CPU=mipsel
+ #else
+ #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
+ CPU=mips
+ #else
+ CPU=
+ #endif
+ #endif
+EOF
+ eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^CPU=`
+ test x"${CPU}" != x && echo "${CPU}-unknown-linux-gnu" && exit 0
+ ;;
+ mips64:Linux:*:*)
+ eval $set_cc_for_build
+ sed 's/^ //' << EOF >$dummy.c
+ #undef CPU
+ #undef mips64
+ #undef mips64el
+ #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
+ CPU=mips64el
+ #else
+ #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
+ CPU=mips64
+ #else
+ CPU=
+ #endif
+ #endif
+EOF
+ eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^CPU=`
+ test x"${CPU}" != x && echo "${CPU}-unknown-linux-gnu" && exit 0
+ ;;
+ ppc:Linux:*:*)
+ echo powerpc-${VENDOR:-unknown}-linux-gnu
+ exit 0 ;;
+ ppc64:Linux:*:*)
+ echo powerpc64-${VENDOR:-unknown}-linux-gnu
+ exit 0 ;;
+ alpha:Linux:*:*)
+ case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
+ EV5) UNAME_MACHINE=alphaev5 ;;
+ EV56) UNAME_MACHINE=alphaev56 ;;
+ PCA56) UNAME_MACHINE=alphapca56 ;;
+ PCA57) UNAME_MACHINE=alphapca56 ;;
+ EV6) UNAME_MACHINE=alphaev6 ;;
+ EV67) UNAME_MACHINE=alphaev67 ;;
+ EV68*) UNAME_MACHINE=alphaev68 ;;
+ esac
+ objdump --private-headers /bin/sh | grep ld.so.1 >/dev/null
+ if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi
+ echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC}
+ exit 0 ;;
+ parisc:Linux:*:* | hppa:Linux:*:*)
+ # Look for CPU level
+ case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
+ PA7*) echo hppa1.1-unknown-linux-gnu ;;
+ PA8*) echo hppa2.0-unknown-linux-gnu ;;
+ *) echo hppa-unknown-linux-gnu ;;
+ esac
+ exit 0 ;;
+ parisc64:Linux:*:* | hppa64:Linux:*:*)
+ echo hppa64-unknown-linux-gnu
+ exit 0 ;;
+ s390:Linux:*:* | s390x:Linux:*:*)
+ echo ${UNAME_MACHINE}-${VENDOR:-ibm}-linux-gnu
+ exit 0 ;;
+ sh64*:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-gnu
+ exit 0 ;;
+ sh*:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-gnu
+ exit 0 ;;
+ sparc:Linux:*:* | sparc64:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-gnu
+ exit 0 ;;
+ x86_64:Linux:*:*)
+ echo x86_64-${VENDOR:-unknown}-linux-gnu
+ exit 0 ;;
+ i*86:Linux:*:*)
+ # The BFD linker knows what the default object file format is, so
+ # first see if it will tell us. cd to the root directory to prevent
+ # problems with other programs or directories called `ld' in the path.
+ # Set LC_ALL=C to ensure ld outputs messages in English.
+ ld_supported_targets=`cd /; LC_ALL=C ld --help 2>&1 \
+ | sed -ne '/supported targets:/!d
+ s/[ ][ ]*/ /g
+ s/.*supported targets: *//
+ s/ .*//
+ p'`
+ case "$ld_supported_targets" in
+ elf32-i386)
+ TENTATIVE="${UNAME_MACHINE}-pc-linux-gnu"
+ ;;
+ a.out-i386-linux)
+ echo "${UNAME_MACHINE}-pc-linux-gnuaout"
+ exit 0 ;;
+ coff-i386)
+ echo "${UNAME_MACHINE}-pc-linux-gnucoff"
+ exit 0 ;;
+ "")
+ # Either a pre-BFD a.out linker (linux-gnuoldld) or
+ # one that does not give us useful --help.
+ echo "${UNAME_MACHINE}-pc-linux-gnuoldld"
+ exit 0 ;;
+ esac
+ # Determine whether the default compiler is a.out or elf
+ eval $set_cc_for_build
+ sed 's/^ //' << EOF >$dummy.c
+ #include
+ #ifdef __ELF__
+ # ifdef __GLIBC__
+ # if __GLIBC__ >= 2
+ LIBC=gnu
+ # else
+ LIBC=gnulibc1
+ # endif
+ # else
+ LIBC=gnulibc1
+ # endif
+ #else
+ #ifdef __INTEL_COMPILER
+ LIBC=gnu
+ #else
+ LIBC=gnuaout
+ #endif
+ #endif
+EOF
+ eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^LIBC=`
+ test x"${LIBC}" != x && echo "${UNAME_MACHINE}-${VENDOR:-pc}-linux-${LIBC}" && exit 0
+ test x"${TENTATIVE}" != x && echo "${TENTATIVE}" && exit 0
+ ;;
+ i*86:DYNIX/ptx:4*:*)
+ # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
+ # earlier versions are messed up and put the nodename in both
+ # sysname and nodename.
+ echo i386-sequent-sysv4
+ exit 0 ;;
+ i*86:UNIX_SV:4.2MP:2.*)
+ # Unixware is an offshoot of SVR4, but it has its own version
+ # number series starting with 2...
+ # I am not positive that other SVR4 systems won't match this,
+ # I just have to hope. -- rms.
+ # Use sysv4.2uw... so that sysv4* matches it.
+ echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
+ exit 0 ;;
+ i*86:OS/2:*:*)
+ # If we were able to find `uname', then EMX Unix compatibility
+ # is probably installed.
+ echo ${UNAME_MACHINE}-pc-os2-emx
+ exit 0 ;;
+ i*86:XTS-300:*:STOP)
+ echo ${UNAME_MACHINE}-unknown-stop
+ exit 0 ;;
+ i*86:atheos:*:*)
+ echo ${UNAME_MACHINE}-unknown-atheos
+ exit 0 ;;
+ i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.0*:*)
+ echo i386-unknown-lynxos${UNAME_RELEASE}
+ exit 0 ;;
+ i*86:*DOS:*:*)
+ echo ${UNAME_MACHINE}-pc-msdosdjgpp
+ exit 0 ;;
+ i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*)
+ UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`
+ if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
+ echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
+ else
+ echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
+ fi
+ exit 0 ;;
+ i*86:*:5:[78]*)
+ case `/bin/uname -X | grep "^Machine"` in
+ *486*) UNAME_MACHINE=i486 ;;
+ *Pentium) UNAME_MACHINE=i586 ;;
+ *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
+ esac
+ echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
+ exit 0 ;;
+ i*86:*:3.2:*)
+ if test -f /usr/options/cb.name; then
+ UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then
+ UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
+ (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
+ (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
+ && UNAME_MACHINE=i586
+ (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
+ && UNAME_MACHINE=i686
+ (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
+ && UNAME_MACHINE=i686
+ echo ${UNAME_MACHINE}-pc-sco$UNAME_REL
+ else
+ echo ${UNAME_MACHINE}-pc-sysv32
+ fi
+ exit 0 ;;
+ pc:*:*:*)
+ # Left here for compatibility:
+ # uname -m prints for DJGPP always 'pc', but it prints nothing about
+ # the processor, so we play safe by assuming i386.
+ echo i386-pc-msdosdjgpp
+ exit 0 ;;
+ Intel:Mach:3*:*)
+ echo i386-pc-mach3
+ exit 0 ;;
+ paragon:*:*:*)
+ echo i860-intel-osf1
+ exit 0 ;;
+ i860:*:4.*:*) # i860-SVR4
+ if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
+ echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
+ else # Add other i860-SVR4 vendors below as they are discovered.
+ echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4
+ fi
+ exit 0 ;;
+ mini*:CTIX:SYS*5:*)
+ # "miniframe"
+ echo m68010-convergent-sysv
+ exit 0 ;;
+ mc68k:UNIX:SYSTEM5:3.51m)
+ echo m68k-convergent-sysv
+ exit 0 ;;
+ M680?0:D-NIX:5.3:*)
+ echo m68k-diab-dnix
+ exit 0 ;;
+ M68*:*:R3V[567]*:*)
+ test -r /sysV68 && echo 'm68k-motorola-sysv' && exit 0 ;;
+ 3[34]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0)
+ OS_REL=''
+ test -r /etc/.relid \
+ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
+ /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+ && echo i486-ncr-sysv4.3${OS_REL} && exit 0
+ /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+ && echo i586-ncr-sysv4.3${OS_REL} && exit 0 ;;
+ 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
+ /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+ && echo i486-ncr-sysv4 && exit 0 ;;
+ m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
+ echo m68k-unknown-lynxos${UNAME_RELEASE}
+ exit 0 ;;
+ mc68030:UNIX_System_V:4.*:*)
+ echo m68k-atari-sysv4
+ exit 0 ;;
+ TSUNAMI:LynxOS:2.*:*)
+ echo sparc-unknown-lynxos${UNAME_RELEASE}
+ exit 0 ;;
+ rs6000:LynxOS:2.*:*)
+ echo rs6000-unknown-lynxos${UNAME_RELEASE}
+ exit 0 ;;
+ PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.0*:*)
+ echo powerpc-unknown-lynxos${UNAME_RELEASE}
+ exit 0 ;;
+ SM[BE]S:UNIX_SV:*:*)
+ echo mips-dde-sysv${UNAME_RELEASE}
+ exit 0 ;;
+ RM*:ReliantUNIX-*:*:*)
+ echo mips-sni-sysv4
+ exit 0 ;;
+ RM*:SINIX-*:*:*)
+ echo mips-sni-sysv4
+ exit 0 ;;
+ *:SINIX-*:*:*)
+ if uname -p 2>/dev/null >/dev/null ; then
+ UNAME_MACHINE=`(uname -p) 2>/dev/null`
+ echo ${UNAME_MACHINE}-sni-sysv4
+ else
+ echo ns32k-sni-sysv
+ fi
+ exit 0 ;;
+ PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
+ # says
+ echo i586-unisys-sysv4
+ exit 0 ;;
+ *:UNIX_System_V:4*:FTX*)
+ # From Gerald Hewes .
+ # How about differentiating between stratus architectures? -djm
+ echo hppa1.1-stratus-sysv4
+ exit 0 ;;
+ *:*:*:FTX*)
+ # From seanf@swdc.stratus.com.
+ echo i860-stratus-sysv4
+ exit 0 ;;
+ *:VOS:*:*)
+ # From Paul.Green@stratus.com.
+ echo hppa1.1-stratus-vos
+ exit 0 ;;
+ mc68*:A/UX:*:*)
+ echo m68k-apple-aux${UNAME_RELEASE}
+ exit 0 ;;
+ news*:NEWS-OS:6*:*)
+ echo mips-sony-newsos6
+ exit 0 ;;
+ R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
+ if [ -d /usr/nec ]; then
+ echo mips-nec-sysv${UNAME_RELEASE}
+ else
+ echo mips-unknown-sysv${UNAME_RELEASE}
+ fi
+ exit 0 ;;
+ BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only.
+ echo powerpc-be-beos
+ exit 0 ;;
+ BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only.
+ echo powerpc-apple-beos
+ exit 0 ;;
+ BePC:BeOS:*:*) # BeOS running on Intel PC compatible.
+ echo i586-pc-beos
+ exit 0 ;;
+ SX-4:SUPER-UX:*:*)
+ echo sx4-nec-superux${UNAME_RELEASE}
+ exit 0 ;;
+ SX-5:SUPER-UX:*:*)
+ echo sx5-nec-superux${UNAME_RELEASE}
+ exit 0 ;;
+ SX-6:SUPER-UX:*:*)
+ echo sx6-nec-superux${UNAME_RELEASE}
+ exit 0 ;;
+ Power*:Rhapsody:*:*)
+ echo powerpc-apple-rhapsody${UNAME_RELEASE}
+ exit 0 ;;
+ *:Rhapsody:*:*)
+ echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
+ exit 0 ;;
+ *:Darwin:*:*)
+ case `uname -p` in
+ *86) UNAME_PROCESSOR=i686 ;;
+ powerpc) UNAME_PROCESSOR=powerpc ;;
+ esac
+ echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}
+ exit 0 ;;
+ *:procnto*:*:* | *:QNX:[0123456789]*:*)
+ UNAME_PROCESSOR=`uname -p`
+ if test "$UNAME_PROCESSOR" = "x86"; then
+ UNAME_PROCESSOR=i386
+ UNAME_MACHINE=pc
+ fi
+ echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE}
+ exit 0 ;;
+ *:QNX:*:4*)
+ echo i386-pc-qnx
+ exit 0 ;;
+ NSR-[DGKLNPTVW]:NONSTOP_KERNEL:*:*)
+ echo nsr-tandem-nsk${UNAME_RELEASE}
+ exit 0 ;;
+ *:NonStop-UX:*:*)
+ echo mips-compaq-nonstopux
+ exit 0 ;;
+ BS2000:POSIX*:*:*)
+ echo bs2000-siemens-sysv
+ exit 0 ;;
+ DS/*:UNIX_System_V:*:*)
+ echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}
+ exit 0 ;;
+ *:Plan9:*:*)
+ # "uname -m" is not consistent, so use $cputype instead. 386
+ # is converted to i386 for consistency with other x86
+ # operating systems.
+ if test "$cputype" = "386"; then
+ UNAME_MACHINE=i386
+ else
+ UNAME_MACHINE="$cputype"
+ fi
+ echo ${UNAME_MACHINE}-unknown-plan9
+ exit 0 ;;
+ *:TOPS-10:*:*)
+ echo pdp10-unknown-tops10
+ exit 0 ;;
+ *:TENEX:*:*)
+ echo pdp10-unknown-tenex
+ exit 0 ;;
+ KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
+ echo pdp10-dec-tops20
+ exit 0 ;;
+ XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
+ echo pdp10-xkl-tops20
+ exit 0 ;;
+ *:TOPS-20:*:*)
+ echo pdp10-unknown-tops20
+ exit 0 ;;
+ *:ITS:*:*)
+ echo pdp10-unknown-its
+ exit 0 ;;
+ SEI:*:*:SEIUX)
+ echo mips-sei-seiux${UNAME_RELEASE}
+ exit 0 ;;
+esac
+
+#echo '(No uname command or uname output not recognized.)' 1>&2
+#echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2
+
+eval $set_cc_for_build
+cat >$dummy.c <
+# include
+#endif
+main ()
+{
+#if defined (sony)
+#if defined (MIPSEB)
+ /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed,
+ I don't know.... */
+ printf ("mips-sony-bsd\n"); exit (0);
+#else
+#include
+ printf ("m68k-sony-newsos%s\n",
+#ifdef NEWSOS4
+ "4"
+#else
+ ""
+#endif
+ ); exit (0);
+#endif
+#endif
+
+#if defined (__arm) && defined (__acorn) && defined (__unix)
+ printf ("arm-acorn-riscix"); exit (0);
+#endif
+
+#if defined (hp300) && !defined (hpux)
+ printf ("m68k-hp-bsd\n"); exit (0);
+#endif
+
+#if defined (NeXT)
+#if !defined (__ARCHITECTURE__)
+#define __ARCHITECTURE__ "m68k"
+#endif
+ int version;
+ version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;
+ if (version < 4)
+ printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);
+ else
+ printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);
+ exit (0);
+#endif
+
+#if defined (MULTIMAX) || defined (n16)
+#if defined (UMAXV)
+ printf ("ns32k-encore-sysv\n"); exit (0);
+#else
+#if defined (CMU)
+ printf ("ns32k-encore-mach\n"); exit (0);
+#else
+ printf ("ns32k-encore-bsd\n"); exit (0);
+#endif
+#endif
+#endif
+
+#if defined (__386BSD__)
+ printf ("i386-pc-bsd\n"); exit (0);
+#endif
+
+#if defined (sequent)
+#if defined (i386)
+ printf ("i386-sequent-dynix\n"); exit (0);
+#endif
+#if defined (ns32000)
+ printf ("ns32k-sequent-dynix\n"); exit (0);
+#endif
+#endif
+
+#if defined (_SEQUENT_)
+ struct utsname un;
+
+ uname(&un);
+
+ if (strncmp(un.version, "V2", 2) == 0) {
+ printf ("i386-sequent-ptx2\n"); exit (0);
+ }
+ if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */
+ printf ("i386-sequent-ptx1\n"); exit (0);
+ }
+ printf ("i386-sequent-ptx\n"); exit (0);
+
+#endif
+
+#if defined (vax)
+# if !defined (ultrix)
+# include
+# if defined (BSD)
+# if BSD == 43
+ printf ("vax-dec-bsd4.3\n"); exit (0);
+# else
+# if BSD == 199006
+ printf ("vax-dec-bsd4.3reno\n"); exit (0);
+# else
+ printf ("vax-dec-bsd\n"); exit (0);
+# endif
+# endif
+# else
+ printf ("vax-dec-bsd\n"); exit (0);
+# endif
+# else
+ printf ("vax-dec-ultrix\n"); exit (0);
+# endif
+#endif
+
+#if defined (alliant) && defined (i860)
+ printf ("i860-alliant-bsd\n"); exit (0);
+#endif
+
+ exit (1);
+}
+EOF
+
+$CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && $dummy && exit 0
+
+# Apollos put the system type in the environment.
+
+test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit 0; }
+
+# Convex versions that predate uname can use getsysinfo(1)
+
+if [ -x /usr/convex/getsysinfo ]
+then
+ case `getsysinfo -f cpu_type` in
+ c1*)
+ echo c1-convex-bsd
+ exit 0 ;;
+ c2*)
+ if getsysinfo -f scalar_acc
+ then echo c32-convex-bsd
+ else echo c2-convex-bsd
+ fi
+ exit 0 ;;
+ c34*)
+ echo c34-convex-bsd
+ exit 0 ;;
+ c38*)
+ echo c38-convex-bsd
+ exit 0 ;;
+ c4*)
+ echo c4-convex-bsd
+ exit 0 ;;
+ esac
+fi
+
+cat >&2 < in order to provide the needed
+information to handle your system.
+
+config.guess timestamp = $timestamp
+
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
+/bin/uname -X = `(/bin/uname -X) 2>/dev/null`
+
+hostinfo = `(hostinfo) 2>/dev/null`
+/bin/universe = `(/bin/universe) 2>/dev/null`
+/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null`
+/bin/arch = `(/bin/arch) 2>/dev/null`
+/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
+
+UNAME_MACHINE = ${UNAME_MACHINE}
+UNAME_RELEASE = ${UNAME_RELEASE}
+UNAME_SYSTEM = ${UNAME_SYSTEM}
+UNAME_VERSION = ${UNAME_VERSION}
+EOF
+
+exit 1
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:
diff --git a/rosapps/applications/net/tsclient/rdesktop/config.sub b/rosapps/applications/net/tsclient/rdesktop/config.sub
new file mode 100644
index 00000000000..7cee3d6ec7f
--- /dev/null
+++ b/rosapps/applications/net/tsclient/rdesktop/config.sub
@@ -0,0 +1,1500 @@
+#! /bin/sh
+# Configuration validation subroutine script.
+# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+# 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+
+timestamp='2003-06-18'
+
+# This file is (in principle) common to ALL GNU software.
+# The presence of a machine in this file suggests that SOME GNU software
+# can handle that machine. It does not imply ALL GNU software can.
+#
+# This file is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# Please send patches to . Submit a context
+# diff and a properly formatted ChangeLog entry.
+#
+# Configuration subroutine to validate and canonicalize a configuration type.
+# Supply the specified configuration type as an argument.
+# If it is invalid, we print an error message on stderr and exit with code 1.
+# Otherwise, we print the canonical config type on stdout and succeed.
+
+# This file is supposed to be the same for all GNU packages
+# and recognize all the CPU types, system types and aliases
+# that are meaningful with *any* GNU software.
+# Each package is responsible for reporting which valid configurations
+# it does not support. The user should be able to distinguish
+# a failure to support a valid configuration from a meaningless
+# configuration.
+
+# The goal of this file is to map all the various variations of a given
+# machine specification into a single specification in the form:
+# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
+# or in some cases, the newer four-part form:
+# CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
+# It is wrong to echo any other type of specification.
+
+me=`echo "$0" | sed -e 's,.*/,,'`
+
+usage="\
+Usage: $0 [OPTION] CPU-MFR-OPSYS
+ $0 [OPTION] ALIAS
+
+Canonicalize a configuration name.
+
+Operation modes:
+ -h, --help print this help, then exit
+ -t, --time-stamp print date of last modification, then exit
+ -v, --version print version number, then exit
+
+Report bugs and patches to ."
+
+version="\
+GNU config.sub ($timestamp)
+
+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
+Free Software Foundation, Inc.
+
+This is free software; see the source for copying conditions. There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+
+help="
+Try \`$me --help' for more information."
+
+# Parse command line
+while test $# -gt 0 ; do
+ case $1 in
+ --time-stamp | --time* | -t )
+ echo "$timestamp" ; exit 0 ;;
+ --version | -v )
+ echo "$version" ; exit 0 ;;
+ --help | --h* | -h )
+ echo "$usage"; exit 0 ;;
+ -- ) # Stop option processing
+ shift; break ;;
+ - ) # Use stdin as input.
+ break ;;
+ -* )
+ echo "$me: invalid option $1$help"
+ exit 1 ;;
+
+ *local*)
+ # First pass through any local machine types.
+ echo $1
+ exit 0;;
+
+ * )
+ break ;;
+ esac
+done
+
+case $# in
+ 0) echo "$me: missing argument$help" >&2
+ exit 1;;
+ 1) ;;
+ *) echo "$me: too many arguments$help" >&2
+ exit 1;;
+esac
+
+# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
+# Here we must recognize all the valid KERNEL-OS combinations.
+maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
+case $maybe_os in
+ nto-qnx* | linux-gnu* | freebsd*-gnu* | netbsd*-gnu* | storm-chaos* | os2-emx* | rtmk-nova*)
+ os=-$maybe_os
+ basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
+ ;;
+ *)
+ basic_machine=`echo $1 | sed 's/-[^-]*$//'`
+ if [ $basic_machine != $1 ]
+ then os=`echo $1 | sed 's/.*-/-/'`
+ else os=; fi
+ ;;
+esac
+
+### Let's recognize common machines as not being operating systems so
+### that things like config.sub decstation-3100 work. We also
+### recognize some manufacturers as not being operating systems, so we
+### can provide default operating systems below.
+case $os in
+ -sun*os*)
+ # Prevent following clause from handling this invalid input.
+ ;;
+ -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
+ -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
+ -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \
+ -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
+ -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
+ -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
+ -apple | -axis)
+ os=
+ basic_machine=$1
+ ;;
+ -sim | -cisco | -oki | -wec | -winbond)
+ os=
+ basic_machine=$1
+ ;;
+ -scout)
+ ;;
+ -wrs)
+ os=-vxworks
+ basic_machine=$1
+ ;;
+ -chorusos*)
+ os=-chorusos
+ basic_machine=$1
+ ;;
+ -chorusrdb)
+ os=-chorusrdb
+ basic_machine=$1
+ ;;
+ -hiux*)
+ os=-hiuxwe2
+ ;;
+ -sco5)
+ os=-sco3.2v5
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -sco4)
+ os=-sco3.2v4
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -sco3.2.[4-9]*)
+ os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -sco3.2v[4-9]*)
+ # Don't forget version if it is 3.2v4 or newer.
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -sco*)
+ os=-sco3.2v2
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -udk*)
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -isc)
+ os=-isc2.2
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -clix*)
+ basic_machine=clipper-intergraph
+ ;;
+ -isc*)
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -lynx*)
+ os=-lynxos
+ ;;
+ -ptx*)
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'`
+ ;;
+ -windowsnt*)
+ os=`echo $os | sed -e 's/windowsnt/winnt/'`
+ ;;
+ -psos*)
+ os=-psos
+ ;;
+ -mint | -mint[0-9]*)
+ basic_machine=m68k-atari
+ os=-mint
+ ;;
+esac
+
+# Decode aliases for certain CPU-COMPANY combinations.
+case $basic_machine in
+ # Recognize the basic CPU types without company name.
+ # Some are omitted here because they have special meanings below.
+ 1750a | 580 \
+ | a29k \
+ | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
+ | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
+ | arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr \
+ | c4x | clipper \
+ | d10v | d30v | dlx | dsp16xx \
+ | fr30 | frv \
+ | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
+ | i370 | i860 | i960 | ia64 \
+ | ip2k \
+ | m32r | m68000 | m68k | m88k | mcore \
+ | mips | mipsbe | mipseb | mipsel | mipsle \
+ | mips16 \
+ | mips64 | mips64el \
+ | mips64vr | mips64vrel \
+ | mips64orion | mips64orionel \
+ | mips64vr4100 | mips64vr4100el \
+ | mips64vr4300 | mips64vr4300el \
+ | mips64vr5000 | mips64vr5000el \
+ | mipsisa32 | mipsisa32el \
+ | mipsisa32r2 | mipsisa32r2el \
+ | mipsisa64 | mipsisa64el \
+ | mipsisa64sb1 | mipsisa64sb1el \
+ | mipsisa64sr71k | mipsisa64sr71kel \
+ | mipstx39 | mipstx39el \
+ | mn10200 | mn10300 \
+ | msp430 \
+ | ns16k | ns32k \
+ | openrisc | or32 \
+ | pdp10 | pdp11 | pj | pjl \
+ | powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \
+ | pyramid \
+ | s390 | s390x \
+ | sh | sh[1234] | sh[23]e | sh[34]eb | shbe | shle | sh[1234]le | sh3ele \
+ | sh64 | sh64le \
+ | sparc | sparc64 | sparc86x | sparclet | sparclite | sparcv9 | sparcv9b \
+ | strongarm \
+ | tahoe | thumb | tic4x | tic80 | tron \
+ | v850 | v850e \
+ | we32k \
+ | x86 | xscale | xstormy16 | xtensa \
+ | z8k)
+ basic_machine=$basic_machine-unknown
+ ;;
+ m6811 | m68hc11 | m6812 | m68hc12)
+ # Motorola 68HC11/12.
+ basic_machine=$basic_machine-unknown
+ os=-none
+ ;;
+ m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k)
+ ;;
+
+ # We use `pc' rather than `unknown'
+ # because (1) that's what they normally are, and
+ # (2) the word "unknown" tends to confuse beginning users.
+ i*86 | x86_64)
+ basic_machine=$basic_machine-pc
+ ;;
+ # Object if more than one company name word.
+ *-*-*)
+ echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+ exit 1
+ ;;
+ # Recognize the basic CPU types with company name.
+ 580-* \
+ | a29k-* \
+ | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
+ | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
+ | alphapca5[67]-* | alpha64pca5[67]-* | arc-* \
+ | arm-* | armbe-* | armle-* | armeb-* | armv*-* \
+ | avr-* \
+ | bs2000-* \
+ | c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \
+ | clipper-* | cydra-* \
+ | d10v-* | d30v-* | dlx-* \
+ | elxsi-* \
+ | f30[01]-* | f700-* | fr30-* | frv-* | fx80-* \
+ | h8300-* | h8500-* \
+ | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
+ | i*86-* | i860-* | i960-* | ia64-* \
+ | ip2k-* \
+ | m32r-* \
+ | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
+ | m88110-* | m88k-* | mcore-* \
+ | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
+ | mips16-* \
+ | mips64-* | mips64el-* \
+ | mips64vr-* | mips64vrel-* \
+ | mips64orion-* | mips64orionel-* \
+ | mips64vr4100-* | mips64vr4100el-* \
+ | mips64vr4300-* | mips64vr4300el-* \
+ | mips64vr5000-* | mips64vr5000el-* \
+ | mipsisa32-* | mipsisa32el-* \
+ | mipsisa32r2-* | mipsisa32r2el-* \
+ | mipsisa64-* | mipsisa64el-* \
+ | mipsisa64sb1-* | mipsisa64sb1el-* \
+ | mipsisa64sr71k-* | mipsisa64sr71kel-* \
+ | mipstx39-* | mipstx39el-* \
+ | msp430-* \
+ | none-* | np1-* | nv1-* | ns16k-* | ns32k-* \
+ | orion-* \
+ | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
+ | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \
+ | pyramid-* \
+ | romp-* | rs6000-* \
+ | s390-* | s390x-* \
+ | sh-* | sh[1234]-* | sh[23]e-* | sh[34]eb-* | shbe-* \
+ | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
+ | sparc-* | sparc64-* | sparc86x-* | sparclet-* | sparclite-* \
+ | sparcv9-* | sparcv9b-* | strongarm-* | sv1-* | sx?-* \
+ | tahoe-* | thumb-* \
+ | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
+ | tron-* \
+ | v850-* | v850e-* | vax-* \
+ | we32k-* \
+ | x86-* | x86_64-* | xps100-* | xscale-* | xstormy16-* \
+ | xtensa-* \
+ | ymp-* \
+ | z8k-*)
+ ;;
+ # Recognize the various machine names and aliases which stand
+ # for a CPU type and a company and sometimes even an OS.
+ 386bsd)
+ basic_machine=i386-unknown
+ os=-bsd
+ ;;
+ 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
+ basic_machine=m68000-att
+ ;;
+ 3b*)
+ basic_machine=we32k-att
+ ;;
+ a29khif)
+ basic_machine=a29k-amd
+ os=-udi
+ ;;
+ adobe68k)
+ basic_machine=m68010-adobe
+ os=-scout
+ ;;
+ alliant | fx80)
+ basic_machine=fx80-alliant
+ ;;
+ altos | altos3068)
+ basic_machine=m68k-altos
+ ;;
+ am29k)
+ basic_machine=a29k-none
+ os=-bsd
+ ;;
+ amd64)
+ basic_machine=x86_64-pc
+ ;;
+ amdahl)
+ basic_machine=580-amdahl
+ os=-sysv
+ ;;
+ amiga | amiga-*)
+ basic_machine=m68k-unknown
+ ;;
+ amigaos | amigados)
+ basic_machine=m68k-unknown
+ os=-amigaos
+ ;;
+ amigaunix | amix)
+ basic_machine=m68k-unknown
+ os=-sysv4
+ ;;
+ apollo68)
+ basic_machine=m68k-apollo
+ os=-sysv
+ ;;
+ apollo68bsd)
+ basic_machine=m68k-apollo
+ os=-bsd
+ ;;
+ aux)
+ basic_machine=m68k-apple
+ os=-aux
+ ;;
+ balance)
+ basic_machine=ns32k-sequent
+ os=-dynix
+ ;;
+ c90)
+ basic_machine=c90-cray
+ os=-unicos
+ ;;
+ convex-c1)
+ basic_machine=c1-convex
+ os=-bsd
+ ;;
+ convex-c2)
+ basic_machine=c2-convex
+ os=-bsd
+ ;;
+ convex-c32)
+ basic_machine=c32-convex
+ os=-bsd
+ ;;
+ convex-c34)
+ basic_machine=c34-convex
+ os=-bsd
+ ;;
+ convex-c38)
+ basic_machine=c38-convex
+ os=-bsd
+ ;;
+ cray | j90)
+ basic_machine=j90-cray
+ os=-unicos
+ ;;
+ crds | unos)
+ basic_machine=m68k-crds
+ ;;
+ cris | cris-* | etrax*)
+ basic_machine=cris-axis
+ ;;
+ da30 | da30-*)
+ basic_machine=m68k-da30
+ ;;
+ decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
+ basic_machine=mips-dec
+ ;;
+ decsystem10* | dec10*)
+ basic_machine=pdp10-dec
+ os=-tops10
+ ;;
+ decsystem20* | dec20*)
+ basic_machine=pdp10-dec
+ os=-tops20
+ ;;
+ delta | 3300 | motorola-3300 | motorola-delta \
+ | 3300-motorola | delta-motorola)
+ basic_machine=m68k-motorola
+ ;;
+ delta88)
+ basic_machine=m88k-motorola
+ os=-sysv3
+ ;;
+ dpx20 | dpx20-*)
+ basic_machine=rs6000-bull
+ os=-bosx
+ ;;
+ dpx2* | dpx2*-bull)
+ basic_machine=m68k-bull
+ os=-sysv3
+ ;;
+ ebmon29k)
+ basic_machine=a29k-amd
+ os=-ebmon
+ ;;
+ elxsi)
+ basic_machine=elxsi-elxsi
+ os=-bsd
+ ;;
+ encore | umax | mmax)
+ basic_machine=ns32k-encore
+ ;;
+ es1800 | OSE68k | ose68k | ose | OSE)
+ basic_machine=m68k-ericsson
+ os=-ose
+ ;;
+ fx2800)
+ basic_machine=i860-alliant
+ ;;
+ genix)
+ basic_machine=ns32k-ns
+ ;;
+ gmicro)
+ basic_machine=tron-gmicro
+ os=-sysv
+ ;;
+ go32)
+ basic_machine=i386-pc
+ os=-go32
+ ;;
+ h3050r* | hiux*)
+ basic_machine=hppa1.1-hitachi
+ os=-hiuxwe2
+ ;;
+ h8300hms)
+ basic_machine=h8300-hitachi
+ os=-hms
+ ;;
+ h8300xray)
+ basic_machine=h8300-hitachi
+ os=-xray
+ ;;
+ h8500hms)
+ basic_machine=h8500-hitachi
+ os=-hms
+ ;;
+ harris)
+ basic_machine=m88k-harris
+ os=-sysv3
+ ;;
+ hp300-*)
+ basic_machine=m68k-hp
+ ;;
+ hp300bsd)
+ basic_machine=m68k-hp
+ os=-bsd
+ ;;
+ hp300hpux)
+ basic_machine=m68k-hp
+ os=-hpux
+ ;;
+ hp3k9[0-9][0-9] | hp9[0-9][0-9])
+ basic_machine=hppa1.0-hp
+ ;;
+ hp9k2[0-9][0-9] | hp9k31[0-9])
+ basic_machine=m68000-hp
+ ;;
+ hp9k3[2-9][0-9])
+ basic_machine=m68k-hp
+ ;;
+ hp9k6[0-9][0-9] | hp6[0-9][0-9])
+ basic_machine=hppa1.0-hp
+ ;;
+ hp9k7[0-79][0-9] | hp7[0-79][0-9])
+ basic_machine=hppa1.1-hp
+ ;;
+ hp9k78[0-9] | hp78[0-9])
+ # FIXME: really hppa2.0-hp
+ basic_machine=hppa1.1-hp
+ ;;
+ hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
+ # FIXME: really hppa2.0-hp
+ basic_machine=hppa1.1-hp
+ ;;
+ hp9k8[0-9][13679] | hp8[0-9][13679])
+ basic_machine=hppa1.1-hp
+ ;;
+ hp9k8[0-9][0-9] | hp8[0-9][0-9])
+ basic_machine=hppa1.0-hp
+ ;;
+ hppa-next)
+ os=-nextstep3
+ ;;
+ hppaosf)
+ basic_machine=hppa1.1-hp
+ os=-osf
+ ;;
+ hppro)
+ basic_machine=hppa1.1-hp
+ os=-proelf
+ ;;
+ i370-ibm* | ibm*)
+ basic_machine=i370-ibm
+ ;;
+# I'm not sure what "Sysv32" means. Should this be sysv3.2?
+ i*86v32)
+ basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+ os=-sysv32
+ ;;
+ i*86v4*)
+ basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+ os=-sysv4
+ ;;
+ i*86v)
+ basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+ os=-sysv
+ ;;
+ i*86sol2)
+ basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+ os=-solaris2
+ ;;
+ i386mach)
+ basic_machine=i386-mach
+ os=-mach
+ ;;
+ i386-vsta | vsta)
+ basic_machine=i386-unknown
+ os=-vsta
+ ;;
+ iris | iris4d)
+ basic_machine=mips-sgi
+ case $os in
+ -irix*)
+ ;;
+ *)
+ os=-irix4
+ ;;
+ esac
+ ;;
+ isi68 | isi)
+ basic_machine=m68k-isi
+ os=-sysv
+ ;;
+ m88k-omron*)
+ basic_machine=m88k-omron
+ ;;
+ magnum | m3230)
+ basic_machine=mips-mips
+ os=-sysv
+ ;;
+ merlin)
+ basic_machine=ns32k-utek
+ os=-sysv
+ ;;
+ mingw32)
+ basic_machine=i386-pc
+ os=-mingw32
+ ;;
+ miniframe)
+ basic_machine=m68000-convergent
+ ;;
+ *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)
+ basic_machine=m68k-atari
+ os=-mint
+ ;;
+ mips3*-*)
+ basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`
+ ;;
+ mips3*)
+ basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown
+ ;;
+ mmix*)
+ basic_machine=mmix-knuth
+ os=-mmixware
+ ;;
+ monitor)
+ basic_machine=m68k-rom68k
+ os=-coff
+ ;;
+ morphos)
+ basic_machine=powerpc-unknown
+ os=-morphos
+ ;;
+ msdos)
+ basic_machine=i386-pc
+ os=-msdos
+ ;;
+ mvs)
+ basic_machine=i370-ibm
+ os=-mvs
+ ;;
+ ncr3000)
+ basic_machine=i486-ncr
+ os=-sysv4
+ ;;
+ netbsd386)
+ basic_machine=i386-unknown
+ os=-netbsd
+ ;;
+ netwinder)
+ basic_machine=armv4l-rebel
+ os=-linux
+ ;;
+ news | news700 | news800 | news900)
+ basic_machine=m68k-sony
+ os=-newsos
+ ;;
+ news1000)
+ basic_machine=m68030-sony
+ os=-newsos
+ ;;
+ news-3600 | risc-news)
+ basic_machine=mips-sony
+ os=-newsos
+ ;;
+ necv70)
+ basic_machine=v70-nec
+ os=-sysv
+ ;;
+ next | m*-next )
+ basic_machine=m68k-next
+ case $os in
+ -nextstep* )
+ ;;
+ -ns2*)
+ os=-nextstep2
+ ;;
+ *)
+ os=-nextstep3
+ ;;
+ esac
+ ;;
+ nh3000)
+ basic_machine=m68k-harris
+ os=-cxux
+ ;;
+ nh[45]000)
+ basic_machine=m88k-harris
+ os=-cxux
+ ;;
+ nindy960)
+ basic_machine=i960-intel
+ os=-nindy
+ ;;
+ mon960)
+ basic_machine=i960-intel
+ os=-mon960
+ ;;
+ nonstopux)
+ basic_machine=mips-compaq
+ os=-nonstopux
+ ;;
+ np1)
+ basic_machine=np1-gould
+ ;;
+ nv1)
+ basic_machine=nv1-cray
+ os=-unicosmp
+ ;;
+ nsr-tandem)
+ basic_machine=nsr-tandem
+ ;;
+ op50n-* | op60c-*)
+ basic_machine=hppa1.1-oki
+ os=-proelf
+ ;;
+ or32 | or32-*)
+ basic_machine=or32-unknown
+ os=-coff
+ ;;
+ OSE68000 | ose68000)
+ basic_machine=m68000-ericsson
+ os=-ose
+ ;;
+ os68k)
+ basic_machine=m68k-none
+ os=-os68k
+ ;;
+ pa-hitachi)
+ basic_machine=hppa1.1-hitachi
+ os=-hiuxwe2
+ ;;
+ paragon)
+ basic_machine=i860-intel
+ os=-osf
+ ;;
+ pbd)
+ basic_machine=sparc-tti
+ ;;
+ pbb)
+ basic_machine=m68k-tti
+ ;;
+ pc532 | pc532-*)
+ basic_machine=ns32k-pc532
+ ;;
+ pentium | p5 | k5 | k6 | nexgen | viac3)
+ basic_machine=i586-pc
+ ;;
+ pentiumpro | p6 | 6x86 | athlon | athlon_*)
+ basic_machine=i686-pc
+ ;;
+ pentiumii | pentium2 | pentiumiii | pentium3)
+ basic_machine=i686-pc
+ ;;
+ pentium4)
+ basic_machine=i786-pc
+ ;;
+ pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
+ basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ pentiumpro-* | p6-* | 6x86-* | athlon-*)
+ basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
+ basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ pentium4-*)
+ basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ pn)
+ basic_machine=pn-gould
+ ;;
+ power) basic_machine=power-ibm
+ ;;
+ ppc) basic_machine=powerpc-unknown
+ ;;
+ ppc-*) basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ ppcle | powerpclittle | ppc-le | powerpc-little)
+ basic_machine=powerpcle-unknown
+ ;;
+ ppcle-* | powerpclittle-*)
+ basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ ppc64) basic_machine=powerpc64-unknown
+ ;;
+ ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ ppc64le | powerpc64little | ppc64-le | powerpc64-little)
+ basic_machine=powerpc64le-unknown
+ ;;
+ ppc64le-* | powerpc64little-*)
+ basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ ps2)
+ basic_machine=i386-ibm
+ ;;
+ pw32)
+ basic_machine=i586-unknown
+ os=-pw32
+ ;;
+ rom68k)
+ basic_machine=m68k-rom68k
+ os=-coff
+ ;;
+ rm[46]00)
+ basic_machine=mips-siemens
+ ;;
+ rtpc | rtpc-*)
+ basic_machine=romp-ibm
+ ;;
+ sa29200)
+ basic_machine=a29k-amd
+ os=-udi
+ ;;
+ sb1)
+ basic_machine=mipsisa64sb1-unknown
+ ;;
+ sb1el)
+ basic_machine=mipsisa64sb1el-unknown
+ ;;
+ sei)
+ basic_machine=mips-sei
+ os=-seiux
+ ;;
+ sequent)
+ basic_machine=i386-sequent
+ ;;
+ sh)
+ basic_machine=sh-hitachi
+ os=-hms
+ ;;
+ sh64)
+ basic_machine=sh64-unknown
+ ;;
+ sparclite-wrs | simso-wrs)
+ basic_machine=sparclite-wrs
+ os=-vxworks
+ ;;
+ sps7)
+ basic_machine=m68k-bull
+ os=-sysv2
+ ;;
+ spur)
+ basic_machine=spur-unknown
+ ;;
+ st2000)
+ basic_machine=m68k-tandem
+ ;;
+ stratus)
+ basic_machine=i860-stratus
+ os=-sysv4
+ ;;
+ sun2)
+ basic_machine=m68000-sun
+ ;;
+ sun2os3)
+ basic_machine=m68000-sun
+ os=-sunos3
+ ;;
+ sun2os4)
+ basic_machine=m68000-sun
+ os=-sunos4
+ ;;
+ sun3os3)
+ basic_machine=m68k-sun
+ os=-sunos3
+ ;;
+ sun3os4)
+ basic_machine=m68k-sun
+ os=-sunos4
+ ;;
+ sun4os3)
+ basic_machine=sparc-sun
+ os=-sunos3
+ ;;
+ sun4os4)
+ basic_machine=sparc-sun
+ os=-sunos4
+ ;;
+ sun4sol2)
+ basic_machine=sparc-sun
+ os=-solaris2
+ ;;
+ sun3 | sun3-*)
+ basic_machine=m68k-sun
+ ;;
+ sun4)
+ basic_machine=sparc-sun
+ ;;
+ sun386 | sun386i | roadrunner)
+ basic_machine=i386-sun
+ ;;
+ sv1)
+ basic_machine=sv1-cray
+ os=-unicos
+ ;;
+ symmetry)
+ basic_machine=i386-sequent
+ os=-dynix
+ ;;
+ t3e)
+ basic_machine=alphaev5-cray
+ os=-unicos
+ ;;
+ t90)
+ basic_machine=t90-cray
+ os=-unicos
+ ;;
+ tic54x | c54x*)
+ basic_machine=tic54x-unknown
+ os=-coff
+ ;;
+ tic55x | c55x*)
+ basic_machine=tic55x-unknown
+ os=-coff
+ ;;
+ tic6x | c6x*)
+ basic_machine=tic6x-unknown
+ os=-coff
+ ;;
+ tx39)
+ basic_machine=mipstx39-unknown
+ ;;
+ tx39el)
+ basic_machine=mipstx39el-unknown
+ ;;
+ toad1)
+ basic_machine=pdp10-xkl
+ os=-tops20
+ ;;
+ tower | tower-32)
+ basic_machine=m68k-ncr
+ ;;
+ udi29k)
+ basic_machine=a29k-amd
+ os=-udi
+ ;;
+ ultra3)
+ basic_machine=a29k-nyu
+ os=-sym1
+ ;;
+ v810 | necv810)
+ basic_machine=v810-nec
+ os=-none
+ ;;
+ vaxv)
+ basic_machine=vax-dec
+ os=-sysv
+ ;;
+ vms)
+ basic_machine=vax-dec
+ os=-vms
+ ;;
+ vpp*|vx|vx-*)
+ basic_machine=f301-fujitsu
+ ;;
+ vxworks960)
+ basic_machine=i960-wrs
+ os=-vxworks
+ ;;
+ vxworks68)
+ basic_machine=m68k-wrs
+ os=-vxworks
+ ;;
+ vxworks29k)
+ basic_machine=a29k-wrs
+ os=-vxworks
+ ;;
+ w65*)
+ basic_machine=w65-wdc
+ os=-none
+ ;;
+ w89k-*)
+ basic_machine=hppa1.1-winbond
+ os=-proelf
+ ;;
+ xps | xps100)
+ basic_machine=xps100-honeywell
+ ;;
+ ymp)
+ basic_machine=ymp-cray
+ os=-unicos
+ ;;
+ z8k-*-coff)
+ basic_machine=z8k-unknown
+ os=-sim
+ ;;
+ none)
+ basic_machine=none-none
+ os=-none
+ ;;
+
+# Here we handle the default manufacturer of certain CPU types. It is in
+# some cases the only manufacturer, in others, it is the most popular.
+ w89k)
+ basic_machine=hppa1.1-winbond
+ ;;
+ op50n)
+ basic_machine=hppa1.1-oki
+ ;;
+ op60c)
+ basic_machine=hppa1.1-oki
+ ;;
+ romp)
+ basic_machine=romp-ibm
+ ;;
+ rs6000)
+ basic_machine=rs6000-ibm
+ ;;
+ vax)
+ basic_machine=vax-dec
+ ;;
+ pdp10)
+ # there are many clones, so DEC is not a safe bet
+ basic_machine=pdp10-unknown
+ ;;
+ pdp11)
+ basic_machine=pdp11-dec
+ ;;
+ we32k)
+ basic_machine=we32k-att
+ ;;
+ sh3 | sh4 | sh[34]eb | sh[1234]le | sh[23]ele)
+ basic_machine=sh-unknown
+ ;;
+ sh64)
+ basic_machine=sh64-unknown
+ ;;
+ sparc | sparcv9 | sparcv9b)
+ basic_machine=sparc-sun
+ ;;
+ cydra)
+ basic_machine=cydra-cydrome
+ ;;
+ orion)
+ basic_machine=orion-highlevel
+ ;;
+ orion105)
+ basic_machine=clipper-highlevel
+ ;;
+ mac | mpw | mac-mpw)
+ basic_machine=m68k-apple
+ ;;
+ pmac | pmac-mpw)
+ basic_machine=powerpc-apple
+ ;;
+ *-unknown)
+ # Make sure to match an already-canonicalized machine name.
+ ;;
+ *)
+ echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+ exit 1
+ ;;
+esac
+
+# Here we canonicalize certain aliases for manufacturers.
+case $basic_machine in
+ *-digital*)
+ basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'`
+ ;;
+ *-commodore*)
+ basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'`
+ ;;
+ *)
+ ;;
+esac
+
+# Decode manufacturer-specific aliases for certain operating systems.
+
+if [ x"$os" != x"" ]
+then
+case $os in
+ # First match some system type aliases
+ # that might get confused with valid system types.
+ # -solaris* is a basic system type, with this one exception.
+ -solaris1 | -solaris1.*)
+ os=`echo $os | sed -e 's|solaris1|sunos4|'`
+ ;;
+ -solaris)
+ os=-solaris2
+ ;;
+ -svr4*)
+ os=-sysv4
+ ;;
+ -unixware*)
+ os=-sysv4.2uw
+ ;;
+ -gnu/linux*)
+ os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
+ ;;
+ # First accept the basic system types.
+ # The portable systems comes first.
+ # Each alternative MUST END IN A *, to match a version number.
+ # -sysv* is not here because it comes later, after sysvr4.
+ -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
+ | -*vms* | -sco* | -esix* | -isc* | -aix* | -sunos | -sunos[34]*\
+ | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \
+ | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
+ | -aos* \
+ | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
+ | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
+ | -hiux* | -386bsd* | -netbsd* | -openbsd* | -freebsd* | -riscix* \
+ | -lynxos* | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
+ | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
+ | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
+ | -chorusos* | -chorusrdb* \
+ | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
+ | -mingw32* | -linux-gnu* | -uxpv* | -beos* | -mpeix* | -udk* \
+ | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \
+ | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
+ | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
+ | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
+ | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
+ | -powermax* | -dnix* | -nx6 | -nx7 | -sei*)
+ # Remember, each alternative MUST END IN *, to match a version number.
+ ;;
+ -qnx*)
+ case $basic_machine in
+ x86-* | i*86-*)
+ ;;
+ *)
+ os=-nto$os
+ ;;
+ esac
+ ;;
+ -nto-qnx*)
+ ;;
+ -nto*)
+ os=`echo $os | sed -e 's|nto|nto-qnx|'`
+ ;;
+ -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \
+ | -windows* | -osx | -abug | -netware* | -os9* | -beos* \
+ | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)
+ ;;
+ -mac*)
+ os=`echo $os | sed -e 's|mac|macos|'`
+ ;;
+ -linux*)
+ os=`echo $os | sed -e 's|linux|linux-gnu|'`
+ ;;
+ -sunos5*)
+ os=`echo $os | sed -e 's|sunos5|solaris2|'`
+ ;;
+ -sunos6*)
+ os=`echo $os | sed -e 's|sunos6|solaris3|'`
+ ;;
+ -opened*)
+ os=-openedition
+ ;;
+ -wince*)
+ os=-wince
+ ;;
+ -osfrose*)
+ os=-osfrose
+ ;;
+ -osf*)
+ os=-osf
+ ;;
+ -utek*)
+ os=-bsd
+ ;;
+ -dynix*)
+ os=-bsd
+ ;;
+ -acis*)
+ os=-aos
+ ;;
+ -atheos*)
+ os=-atheos
+ ;;
+ -386bsd)
+ os=-bsd
+ ;;
+ -ctix* | -uts*)
+ os=-sysv
+ ;;
+ -nova*)
+ os=-rtmk-nova
+ ;;
+ -ns2 )
+ os=-nextstep2
+ ;;
+ -nsk*)
+ os=-nsk
+ ;;
+ # Preserve the version number of sinix5.
+ -sinix5.*)
+ os=`echo $os | sed -e 's|sinix|sysv|'`
+ ;;
+ -sinix*)
+ os=-sysv4
+ ;;
+ -triton*)
+ os=-sysv3
+ ;;
+ -oss*)
+ os=-sysv3
+ ;;
+ -svr4)
+ os=-sysv4
+ ;;
+ -svr3)
+ os=-sysv3
+ ;;
+ -sysvr4)
+ os=-sysv4
+ ;;
+ # This must come after -sysvr4.
+ -sysv*)
+ ;;
+ -ose*)
+ os=-ose
+ ;;
+ -es1800*)
+ os=-ose
+ ;;
+ -xenix)
+ os=-xenix
+ ;;
+ -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+ os=-mint
+ ;;
+ -aros*)
+ os=-aros
+ ;;
+ -kaos*)
+ os=-kaos
+ ;;
+ -none)
+ ;;
+ *)
+ # Get rid of the `-' at the beginning of $os.
+ os=`echo $os | sed 's/[^-]*-//'`
+ echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2
+ exit 1
+ ;;
+esac
+else
+
+# Here we handle the default operating systems that come with various machines.
+# The value should be what the vendor currently ships out the door with their
+# machine or put another way, the most popular os provided with the machine.
+
+# Note that if you're going to try to match "-MANUFACTURER" here (say,
+# "-sun"), then you have to tell the case statement up towards the top
+# that MANUFACTURER isn't an operating system. Otherwise, code above
+# will signal an error saying that MANUFACTURER isn't an operating
+# system, and we'll never get to this point.
+
+case $basic_machine in
+ *-acorn)
+ os=-riscix1.2
+ ;;
+ arm*-rebel)
+ os=-linux
+ ;;
+ arm*-semi)
+ os=-aout
+ ;;
+ c4x-* | tic4x-*)
+ os=-coff
+ ;;
+ # This must come before the *-dec entry.
+ pdp10-*)
+ os=-tops20
+ ;;
+ pdp11-*)
+ os=-none
+ ;;
+ *-dec | vax-*)
+ os=-ultrix4.2
+ ;;
+ m68*-apollo)
+ os=-domain
+ ;;
+ i386-sun)
+ os=-sunos4.0.2
+ ;;
+ m68000-sun)
+ os=-sunos3
+ # This also exists in the configure program, but was not the
+ # default.
+ # os=-sunos4
+ ;;
+ m68*-cisco)
+ os=-aout
+ ;;
+ mips*-cisco)
+ os=-elf
+ ;;
+ mips*-*)
+ os=-elf
+ ;;
+ or32-*)
+ os=-coff
+ ;;
+ *-tti) # must be before sparc entry or we get the wrong os.
+ os=-sysv3
+ ;;
+ sparc-* | *-sun)
+ os=-sunos4.1.1
+ ;;
+ *-be)
+ os=-beos
+ ;;
+ *-ibm)
+ os=-aix
+ ;;
+ *-wec)
+ os=-proelf
+ ;;
+ *-winbond)
+ os=-proelf
+ ;;
+ *-oki)
+ os=-proelf
+ ;;
+ *-hp)
+ os=-hpux
+ ;;
+ *-hitachi)
+ os=-hiux
+ ;;
+ i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
+ os=-sysv
+ ;;
+ *-cbm)
+ os=-amigaos
+ ;;
+ *-dg)
+ os=-dgux
+ ;;
+ *-dolphin)
+ os=-sysv3
+ ;;
+ m68k-ccur)
+ os=-rtu
+ ;;
+ m88k-omron*)
+ os=-luna
+ ;;
+ *-next )
+ os=-nextstep
+ ;;
+ *-sequent)
+ os=-ptx
+ ;;
+ *-crds)
+ os=-unos
+ ;;
+ *-ns)
+ os=-genix
+ ;;
+ i370-*)
+ os=-mvs
+ ;;
+ *-next)
+ os=-nextstep3
+ ;;
+ *-gould)
+ os=-sysv
+ ;;
+ *-highlevel)
+ os=-bsd
+ ;;
+ *-encore)
+ os=-bsd
+ ;;
+ *-sgi)
+ os=-irix
+ ;;
+ *-siemens)
+ os=-sysv4
+ ;;
+ *-masscomp)
+ os=-rtu
+ ;;
+ f30[01]-fujitsu | f700-fujitsu)
+ os=-uxpv
+ ;;
+ *-rom68k)
+ os=-coff
+ ;;
+ *-*bug)
+ os=-coff
+ ;;
+ *-apple)
+ os=-macos
+ ;;
+ *-atari*)
+ os=-mint
+ ;;
+ *)
+ os=-none
+ ;;
+esac
+fi
+
+# Here we handle the case where we know the os, and the CPU type, but not the
+# manufacturer. We pick the logical manufacturer.
+vendor=unknown
+case $basic_machine in
+ *-unknown)
+ case $os in
+ -riscix*)
+ vendor=acorn
+ ;;
+ -sunos*)
+ vendor=sun
+ ;;
+ -aix*)
+ vendor=ibm
+ ;;
+ -beos*)
+ vendor=be
+ ;;
+ -hpux*)
+ vendor=hp
+ ;;
+ -mpeix*)
+ vendor=hp
+ ;;
+ -hiux*)
+ vendor=hitachi
+ ;;
+ -unos*)
+ vendor=crds
+ ;;
+ -dgux*)
+ vendor=dg
+ ;;
+ -luna*)
+ vendor=omron
+ ;;
+ -genix*)
+ vendor=ns
+ ;;
+ -mvs* | -opened*)
+ vendor=ibm
+ ;;
+ -ptx*)
+ vendor=sequent
+ ;;
+ -vxsim* | -vxworks* | -windiss*)
+ vendor=wrs
+ ;;
+ -aux*)
+ vendor=apple
+ ;;
+ -hms*)
+ vendor=hitachi
+ ;;
+ -mpw* | -macos*)
+ vendor=apple
+ ;;
+ -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+ vendor=atari
+ ;;
+ -vos*)
+ vendor=stratus
+ ;;
+ esac
+ basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
+ ;;
+esac
+
+echo $basic_machine$os
+exit 0
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:
diff --git a/rosapps/applications/net/tsclient/rdesktop/configure.ac b/rosapps/applications/net/tsclient/rdesktop/configure.ac
new file mode 100644
index 00000000000..34a4e79c211
--- /dev/null
+++ b/rosapps/applications/net/tsclient/rdesktop/configure.ac
@@ -0,0 +1,727 @@
+AC_INIT(rdesktop, 1.4.1)
+
+AC_CONFIG_SRCDIR([rdesktop.c])
+
+AC_PROG_CC
+if test "$GCC" = yes; then
+ CFLAGS="$CFLAGS -Wall"
+fi
+
+AC_PROG_INSTALL
+AC_LANG_C
+AC_HEADER_STDC
+AC_C_BIGENDIAN([AC_DEFINE(B_ENDIAN)], [AC_DEFINE(L_ENDIAN)])
+AC_PATH_XTRA
+
+AC_SEARCH_LIBS(socket, socket)
+AC_SEARCH_LIBS(inet_aton, resolv)
+
+AC_CHECK_HEADER(sys/select.h, AC_DEFINE(HAVE_SYS_SELECT_H))
+AC_CHECK_HEADER(sys/modem.h, AC_DEFINE(HAVE_SYS_MODEM_H))
+AC_CHECK_HEADER(sys/filio.h, AC_DEFINE(HAVE_SYS_FILIO_H))
+AC_CHECK_HEADER(sys/strtio.h, AC_DEFINE(HAVE_SYS_STRTIO_H))
+AC_CHECK_HEADER(locale.h, AC_DEFINE(HAVE_LOCALE_H))
+AC_CHECK_HEADER(langinfo.h, AC_DEFINE(HAVE_LANGINFO_H))
+
+AC_CHECK_TOOL(STRIP, strip, :)
+
+rpath=""
+
+#
+# OpenSSL detection borrowed from stunnel
+#
+checkssldir() { :
+ if test -f "$1/include/openssl/ssl.h"; then
+ ssldir="$1"
+ return 0
+ fi
+ return 1
+}
+AC_MSG_CHECKING([for OpenSSL directory])
+AC_ARG_WITH(openssl,
+ [ --with-openssl=DIR look for OpenSSL at DIR/include, DIR/lib],
+ [
+ dnl Check the specified location only
+ checkssldir "$withval"
+ ],
+ [
+ dnl Search default locations of OpenSSL library
+ for maindir in /usr/local /usr/lib /usr/pkg /usr /var/ssl /opt; do
+ for dir in $maindir $maindir/openssl $maindir/ssl; do
+ checkssldir $dir && break 2
+ done
+ done
+ ]
+)
+if test -z "$ssldir"; then
+ AC_MSG_RESULT([Not found])
+ echo
+ echo "Couldn't find your OpenSSL library installation dir"
+ echo "Use --with-openssl option to fix this problem"
+ echo
+ exit 1
+fi
+AC_MSG_RESULT([$ssldir])
+AC_SUBST(ssldir)
+AC_DEFINE_UNQUOTED(ssldir, "$ssldir")
+
+dnl Add OpenSSL includes and libraries
+CFLAGS="$CFLAGS -I$ssldir/include"
+AC_ARG_ENABLE(static-openssl,
+ [ --enable-static-openssl link OpenSSL statically],
+ [
+LIBS="$LIBS $ssldir/lib/libcrypto.a"
+ ],
+ [
+LIBS="$LIBS -L$ssldir/lib -lcrypto"
+rpath="$rpath:$ssldir/lib"
+ ])
+
+
+#
+# Alignment
+#
+AC_MSG_CHECKING([if architecture needs alignment])
+AC_TRY_RUN([
+#include
+#include
+int main(int argc, char **argv)
+{
+ unsigned char test[8] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88 };
+ signal(SIGBUS, exit);
+ signal(SIGABRT, exit);
+ signal(SIGSEGV, exit);
+ if (*((unsigned int *)(test + 1)) != 0x55443322 && *((unsigned int *)(test + 1)) != 0x22334455) {
+ return 1;
+ }
+ return 0;
+}],
+ [AC_MSG_RESULT(no)],
+ [AC_MSG_RESULT(yes)
+ AC_DEFINE(NEED_ALIGN)],
+ [AC_MSG_RESULT(assuming yes)
+ AC_DEFINE(NEED_ALIGN)])
+
+
+#
+# EGD
+#
+AC_ARG_WITH(egd-socket,
+ [ --with-egd-socket=PATH look for Entropy Gathering Daemon socket at PATH],
+ [EGD_SOCKET="$withval"],
+ [EGD_SOCKET="/var/run/egd-pool"]
+)
+AC_DEFINE_UNQUOTED(EGD_SOCKET, "$EGD_SOCKET")
+
+
+#
+# rdp2vnc
+#
+vncserverconfig=libvncserver-config
+AC_ARG_WITH(libvncserver-config,
+ [ --with-libvncserver-config=CMD use CMD as libvncserver-config],
+ [vncserverconfig="$withval"]
+)
+AC_ARG_WITH(libvncserver,
+ [ --with-libvncserver make rdp2vnc],
+ [
+ VNCINC=`$vncserverconfig --cflags`
+ AC_SUBST(VNCINC)
+ LDVNC=`$vncserverconfig --libs`
+ AC_SUBST(LDVNC)
+ VNCLINK=`$vncserverconfig --link`
+ AC_SUBST(VNCLINK)
+ RDP2VNCTARGET="rdp2vnc"
+ AC_SUBST(RDP2VNCTARGET)
+ ]
+)
+
+#
+# sound
+#
+AC_ARG_WITH(libao,
+ [ --with-libao=DIR look for libao at DIR/include, DIR/lib],
+ [
+ CFLAGS="$CFLAGS -I$withval/include"
+ CPPFLAGS="$CPPFLAGS -I$withval/include"
+ LIBS="$LIBS -L$withval/lib"
+ rpath="$rpath:$withval/lib"
+ ]
+)
+
+sound="yes"
+AC_ARG_WITH(sound,
+ [ --with-sound select sound system ("oss", "sgi", "sun" or "libao") ],
+ [
+ sound="$withval"
+ ])
+if test "$sound" = yes; then
+ AC_CHECK_HEADER(ao/ao.h, [sound=libao])
+ AC_CHECK_HEADER(sys/soundcard.h, [sound=oss])
+ AC_CHECK_HEADER(dmedia/audio.h, [sound=sgi])
+ AC_CHECK_HEADER(sys/audioio.h, [sound=sun])
+fi
+if test "$sound" = no; then
+ break
+elif test "$sound" = oss; then
+ SOUNDOBJ="rdpsnd.o rdpsnd_oss.o"
+ AC_DEFINE(WITH_RDPSND)
+elif test "$sound" = sgi; then
+ SOUNDOBJ="rdpsnd.o rdpsnd_sgi.o"
+ LDFLAGS="$LDFLAGS -laudio"
+ AC_DEFINE(WITH_RDPSND)
+elif test "$sound" = sun; then
+ SOUNDOBJ="rdpsnd.o rdpsnd_sun.o"
+ AC_DEFINE(WITH_RDPSND)
+elif test "$sound" = libao; then
+ SOUNDOBJ="rdpsnd.o rdpsnd_libao.o"
+ LDFLAGS="$LDFLAGS -lao"
+ AC_DEFINE(WITH_RDPSND)
+else
+ AC_MSG_WARN([sound support disabled])
+ AC_MSG_WARN([Currently supported systems are Open Sound System (oss), SGI AL (sgi), Sun/BSD (sun) and libao])
+fi
+AC_SUBST(SOUNDOBJ)
+
+#
+# dirfd
+#
+dnl Find out how to get the file descriptor associated with an open DIR*.
+dnl From Jim Meyering
+
+AC_DEFUN([UTILS_FUNC_DIRFD],
+[
+
+ AC_HEADER_DIRENT
+ dirfd_headers='
+#if HAVE_DIRENT_H
+# include
+#else /* not HAVE_DIRENT_H */
+# define dirent direct
+# if HAVE_SYS_NDIR_H
+# include
+# endif /* HAVE_SYS_NDIR_H */
+# if HAVE_SYS_DIR_H
+# include
+# endif /* HAVE_SYS_DIR_H */
+# if HAVE_NDIR_H
+# include
+# endif /* HAVE_NDIR_H */
+#endif /* HAVE_DIRENT_H */
+'
+ AC_CHECK_FUNCS(dirfd)
+ AC_CHECK_DECLS([dirfd], , , $dirfd_headers)
+
+ AC_CACHE_CHECK([whether dirfd is a macro],
+ jm_cv_func_dirfd_macro,
+ [AC_EGREP_CPP([dirent_header_defines_dirfd], [$dirfd_headers
+#ifdef dirfd
+ dirent_header_defines_dirfd
+#endif],
+ jm_cv_func_dirfd_macro=yes,
+ jm_cv_func_dirfd_macro=no)])
+
+ # Use the replacement only if we have no function, macro,
+ # or declaration with that name.
+ if test $ac_cv_func_dirfd,$ac_cv_have_decl_dirfd,$jm_cv_func_dirfd_macro \
+ = no,no,no; then
+ AC_REPLACE_FUNCS([dirfd])
+ AC_CACHE_CHECK(
+ [how to get the file descriptor associated with an open DIR*],
+ gl_cv_sys_dir_fd_member_name,
+ [
+ dirfd_save_CFLAGS=$CFLAGS
+ for ac_expr in d_fd dd_fd; do
+
+ CFLAGS="$CFLAGS -DDIR_FD_MEMBER_NAME=$ac_expr"
+ AC_TRY_COMPILE(
+ [$dirfd_headers
+ ],
+ [DIR *dir_p = opendir("."); (void) dir_p->DIR_FD_MEMBER_NAME;],
+ dir_fd_found=yes
+ )
+ CFLAGS=$dirfd_save_CFLAGS
+ test "$dir_fd_found" = yes && break
+ done
+ test "$dir_fd_found" = yes || ac_expr=no_such_member
+
+ gl_cv_sys_dir_fd_member_name=$ac_expr
+ ]
+ )
+ if test $gl_cv_sys_dir_fd_member_name != no_such_member; then
+ AC_DEFINE_UNQUOTED(DIR_FD_MEMBER_NAME,
+ $gl_cv_sys_dir_fd_member_name,
+ [the name of the file descriptor member of DIR])
+ fi
+ AH_VERBATIM(DIR_TO_FD,
+ [#ifdef DIR_FD_MEMBER_NAME
+# define DIR_TO_FD(Dir_p) ((Dir_p)->DIR_FD_MEMBER_NAME)
+#else
+# define DIR_TO_FD(Dir_p) -1
+#endif
+]
+ )
+ fi
+])
+
+UTILS_FUNC_DIRFD
+
+#
+# iconv
+#
+
+dnl This macros shamelessly stolen from
+dnl http://gcc.gnu.org/ml/gcc-bugs/2001-06/msg01398.html.
+dnl Written by Bruno Haible.
+
+AC_DEFUN([UTILS_FUNC_ICONV],
+[
+ dnl Some systems have iconv in libc, some have it in libiconv (OSF/1 and
+ dnl those with the standalone portable GNU libiconv installed).
+
+ AC_ARG_WITH([libiconv-prefix],
+[ --with-libiconv-prefix=DIR search for libiconv in DIR/include and DIR/lib], [
+ for dir in `echo "$withval" | tr : ' '`; do
+ if test -d $dir/include; then CPPFLAGS="$CPPFLAGS -I$dir/include"; fi
+ if test -d $dir/lib; then LDFLAGS="$LDFLAGS -L$dir/lib"; fi
+ done
+ ])
+ AC_CHECK_HEADER(iconv.h, AC_DEFINE(HAVE_ICONV_H))
+
+ AC_CACHE_CHECK(for iconv, am_cv_func_iconv, [
+ am_cv_func_iconv="no, consider installing GNU libiconv"
+ am_cv_lib_iconv=no
+ AC_TRY_LINK([#include
+#include ],
+ [iconv_t cd = iconv_open("","");
+ iconv(cd,NULL,NULL,NULL,NULL);
+ iconv_close(cd);],
+ am_cv_func_iconv=yes)
+ if test "$am_cv_func_iconv" != yes; then
+ am_save_LIBS="$LIBS"
+ LIBS="$LIBS -liconv"
+ AC_TRY_LINK([#include
+#include ],
+ [iconv_t cd = iconv_open("","");
+ iconv(cd,NULL,NULL,NULL,NULL);
+ iconv_close(cd);],
+ am_cv_lib_iconv=yes
+ am_cv_func_iconv=yes)
+ LIBS="$am_save_LIBS"
+ fi
+ ])
+ if test "$am_cv_func_iconv" = yes; then
+ AC_DEFINE(HAVE_ICONV, 1, [Define if you have the iconv() function.])
+ AC_MSG_CHECKING([for iconv declaration])
+ AC_CACHE_VAL(am_cv_proto_iconv, [
+ AC_TRY_COMPILE([
+#include
+#include
+extern
+#ifdef __cplusplus
+"C"
+#endif
+#if defined(__STDC__) || defined(__cplusplus)
+size_t iconv (iconv_t cd, char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);
+#else
+size_t iconv();
+#endif
+], [], am_cv_proto_iconv_arg1="", am_cv_proto_iconv_arg1="const")
+ am_cv_proto_iconv="extern size_t iconv (iconv_t cd, $am_cv_proto_iconv_arg1 char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);"])
+ am_cv_proto_iconv=`echo "[$]am_cv_proto_iconv" | tr -s ' ' | sed -e 's/( /(/'`
+ AC_MSG_RESULT([$]{ac_t:-
+ }[$]am_cv_proto_iconv)
+ AC_DEFINE_UNQUOTED(ICONV_CONST, $am_cv_proto_iconv_arg1,
+ [Define as const if the declaration of iconv() needs const.])
+ fi
+ LIBICONV=
+ if test "$am_cv_lib_iconv" = yes; then
+ LIBICONV="-liconv"
+ fi
+ AC_SUBST(LIBICONV)
+])
+
+UTILS_FUNC_ICONV
+LIBS="$LIBS $LIBICONV"
+
+#
+# socklen_t
+# from curl
+
+dnl Check for socklen_t: historically on BSD it is an int, and in
+dnl POSIX 1g it is a type of its own, but some platforms use different
+dnl types for the argument to getsockopt, getpeername, etc. So we
+dnl have to test to find something that will work.
+AC_DEFUN([TYPE_SOCKLEN_T],
+[
+ AC_CHECK_TYPE([socklen_t], ,[
+ AC_MSG_CHECKING([for socklen_t equivalent])
+ AC_CACHE_VAL([socklen_t_equiv],
+ [
+ # Systems have either "struct sockaddr *" or
+ # "void *" as the second argument to getpeername
+ socklen_t_equiv=
+ for arg2 in "struct sockaddr" void; do
+ for t in int size_t unsigned long "unsigned long"; do
+ AC_TRY_COMPILE([
+ #include
+ #include
+
+ int getpeername (int, $arg2 *, $t *);
+ ],[
+ $t len;
+ getpeername(0,0,&len);
+ ],[
+ socklen_t_equiv="$t"
+ break
+ ])
+ done
+ done
+
+ if test "x$socklen_t_equiv" = x; then
+ AC_MSG_ERROR([Cannot find a type to use in place of socklen_t])
+ fi
+ ])
+ AC_MSG_RESULT($socklen_t_equiv)
+ AC_DEFINE_UNQUOTED(socklen_t, $socklen_t_equiv,
+ [type to use in place of socklen_t if not defined])],
+ [#include
+#include ])
+])
+
+TYPE_SOCKLEN_T
+
+#
+# statfs stuff
+#
+AC_CHECK_HEADERS(sys/vfs.h)
+AC_CHECK_HEADERS(sys/statvfs.h)
+AC_CHECK_HEADERS(sys/statfs.h)
+AC_CHECK_HEADERS(sys/param.h)
+
+mount_includes="\
+ $ac_includes_default
+ #if HAVE_SYS_PARAM_H
+ # include
+ #endif
+ "
+
+AC_CHECK_HEADERS(sys/mount.h,,,[$mount_includes])
+
+#################################################
+# these tests are taken from the GNU fileutils package
+AC_CHECKING(how to get filesystem space usage)
+space=no
+
+# Test for statvfs64.
+if test $space = no; then
+ # SVR4
+ AC_CACHE_CHECK([statvfs64 function (SVR4)], fu_cv_sys_stat_statvfs64,
+ [AC_TRY_RUN([
+#if defined(HAVE_UNISTD_H)
+#include
+#endif
+#include
+#include
+ main ()
+ {
+ struct statvfs64 fsd;
+ exit (statvfs64 (".", &fsd));
+ }],
+ fu_cv_sys_stat_statvfs64=yes,
+ fu_cv_sys_stat_statvfs64=no,
+ fu_cv_sys_stat_statvfs64=cross)])
+ if test $fu_cv_sys_stat_statvfs64 = yes; then
+ space=yes
+ AC_DEFINE(STAT_STATVFS64,1,[Whether statvfs64() is available])
+ fi
+fi
+
+# Perform only the link test since it seems there are no variants of the
+# statvfs function. This check is more than just AC_CHECK_FUNCS(statvfs)
+# because that got a false positive on SCO OSR5. Adding the declaration
+# of a `struct statvfs' causes this test to fail (as it should) on such
+# systems. That system is reported to work fine with STAT_STATFS4 which
+# is what it gets when this test fails.
+if test $space = no; then
+ # SVR4
+ AC_CACHE_CHECK([statvfs function (SVR4)], fu_cv_sys_stat_statvfs,
+ [AC_TRY_LINK([#include
+#include ],
+ [struct statvfs fsd; statvfs (0, &fsd);],
+ fu_cv_sys_stat_statvfs=yes,
+ fu_cv_sys_stat_statvfs=no)])
+ if test $fu_cv_sys_stat_statvfs = yes; then
+ space=yes
+ AC_DEFINE(STAT_STATVFS,1,[Whether statvfs() is available])
+ fi
+fi
+
+if test $space = no; then
+ # DEC Alpha running OSF/1
+ AC_MSG_CHECKING([for 3-argument statfs function (DEC OSF/1)])
+ AC_CACHE_VAL(fu_cv_sys_stat_statfs3_osf1,
+ [AC_TRY_RUN([
+#include
+#include
+#include
+ main ()
+ {
+ struct statfs fsd;
+ fsd.f_fsize = 0;
+ exit (statfs (".", &fsd, sizeof (struct statfs)));
+ }],
+ fu_cv_sys_stat_statfs3_osf1=yes,
+ fu_cv_sys_stat_statfs3_osf1=no,
+ fu_cv_sys_stat_statfs3_osf1=no)])
+
+
+#C_MSG_RESULT($fu_cv_sys_stat_statfs3_osf1)
+ if test $fu_cv_sys_stat_statfs3_osf1 = yes; then
+ space=yes
+ AC_DEFINE(STAT_STATFS3_OSF1,1,[Whether statfs requires 3 arguments])
+ fi
+fi
+
+if test $space = no; then
+# AIX
+ AC_MSG_CHECKING([for two-argument statfs with statfs.bsize dnl
+member (AIX, 4.3BSD)])
+ AC_CACHE_VAL(fu_cv_sys_stat_statfs2_bsize,
+ [AC_TRY_RUN([
+#ifdef HAVE_SYS_PARAM_H
+#include
+#endif
+#ifdef HAVE_SYS_MOUNT_H
+#include
+#endif
+#ifdef HAVE_SYS_VFS_H
+#include
+#endif
+ main ()
+ {
+ struct statfs fsd;
+ fsd.f_bsize = 0;
+ exit (statfs (".", &fsd));
+ }],
+ fu_cv_sys_stat_statfs2_bsize=yes,
+ fu_cv_sys_stat_statfs2_bsize=no,
+ fu_cv_sys_stat_statfs2_bsize=no)])
+ AC_MSG_RESULT($fu_cv_sys_stat_statfs2_bsize)
+ if test $fu_cv_sys_stat_statfs2_bsize = yes; then
+ space=yes
+ AC_DEFINE(STAT_STATFS2_BSIZE,1,[Whether statfs requires two arguments and struct statfs has bsize property])
+ fi
+fi
+
+if test $space = no; then
+# SVR3
+ AC_MSG_CHECKING([for four-argument statfs (AIX-3.2.5, SVR3)])
+ AC_CACHE_VAL(fu_cv_sys_stat_statfs4,
+ [AC_TRY_RUN([#include
+#include
+ main ()
+ {
+ struct statfs fsd;
+ exit (statfs (".", &fsd, sizeof fsd, 0));
+ }],
+ fu_cv_sys_stat_statfs4=yes,
+ fu_cv_sys_stat_statfs4=no,
+ fu_cv_sys_stat_statfs4=no)])
+ AC_MSG_RESULT($fu_cv_sys_stat_statfs4)
+ if test $fu_cv_sys_stat_statfs4 = yes; then
+ space=yes
+ AC_DEFINE(STAT_STATFS4,1,[Whether statfs requires 4 arguments])
+ fi
+fi
+
+if test $space = no; then
+# 4.4BSD and NetBSD
+ AC_MSG_CHECKING([for two-argument statfs with statfs.fsize dnl
+member (4.4BSD and NetBSD)])
+ AC_CACHE_VAL(fu_cv_sys_stat_statfs2_fsize,
+ [AC_TRY_RUN([#include
+#ifdef HAVE_SYS_PARAM_H
+#include
+#endif
+#ifdef HAVE_SYS_MOUNT_H
+#include
+#endif
+ main ()
+ {
+ struct statfs fsd;
+ fsd.f_fsize = 0;
+ exit (statfs (".", &fsd));
+ }],
+ fu_cv_sys_stat_statfs2_fsize=yes,
+ fu_cv_sys_stat_statfs2_fsize=no,
+ fu_cv_sys_stat_statfs2_fsize=no)])
+ AC_MSG_RESULT($fu_cv_sys_stat_statfs2_fsize)
+ if test $fu_cv_sys_stat_statfs2_fsize = yes; then
+ space=yes
+ AC_DEFINE(STAT_STATFS2_FSIZE,1,[Whether statfs requires 2 arguments and struct statfs has fsize])
+ fi
+fi
+
+if test $space = no; then
+ # Ultrix
+ AC_MSG_CHECKING([for two-argument statfs with struct fs_data (Ultrix)])
+ AC_CACHE_VAL(fu_cv_sys_stat_fs_data,
+ [AC_TRY_RUN([#include
+#ifdef HAVE_SYS_PARAM_H
+#include
+#endif
+#ifdef HAVE_SYS_MOUNT_H
+#include
+#endif
+#ifdef HAVE_SYS_FS_TYPES_H
+#include
+#endif
+ main ()
+ {
+ struct fs_data fsd;
+ /* Ultrix's statfs returns 1 for success,
+ 0 for not mounted, -1 for failure. */
+ exit (statfs (".", &fsd) != 1);
+ }],
+ fu_cv_sys_stat_fs_data=yes,
+ fu_cv_sys_stat_fs_data=no,
+ fu_cv_sys_stat_fs_data=no)])
+ AC_MSG_RESULT($fu_cv_sys_stat_fs_data)
+ if test $fu_cv_sys_stat_fs_data = yes; then
+ space=yes
+ AC_DEFINE(STAT_STATFS2_FS_DATA,1,[Whether statfs requires 2 arguments and struct fs_data is available])
+ fi
+fi
+
+ statxfs_includes="\
+$ac_includes_default
+#if HAVE_SYS_STATVFS_H
+# include
+#endif
+#if HAVE_SYS_VFS_H
+# include
+#endif
+#if !HAVE_SYS_STATVFS_H && !HAVE_SYS_VFS_H
+# if HAVE_SYS_MOUNT_H && HAVE_SYS_PARAM_H
+/* NetBSD 1.5.2 needs these, for the declaration of struct statfs. */
+# include
+# include
+# elif HAVE_NETINET_IN_H && HAVE_NFS_NFS_CLNT_H && HAVE_NFS_VFS_H
+/* Ultrix 4.4 needs these for the declaration of struct statfs. */
+# include
+# include
+# include
+# endif
+#endif
+"
+
+AC_CHECK_MEMBERS([struct statfs.f_namemax],,,[$statxfs_includes])
+AC_CHECK_MEMBERS([struct statvfs.f_namemax],,,[$statxfs_includes])
+AC_CHECK_MEMBERS([struct statfs.f_namelen],,,[$statxfs_includes])
+AC_CHECK_MEMBERS([struct statvfs.f_namelen],,,[$statxfs_includes])
+
+#
+# Large file support
+#
+AC_SYS_LARGEFILE
+
+#
+# mntent
+#
+AC_CHECK_HEADER(mntent.h, AC_DEFINE(HAVE_MNTENT_H))
+AC_CHECK_FUNCS(setmntent)
+
+#
+# IPv6
+#
+AC_ARG_WITH(ipv6,
+ [ --with-ipv6 enable IPv6-support],
+ [
+ if test $withval != "no";
+ then
+ AC_DEFINE(IPv6,1)
+ fi
+ ])
+
+
+#
+# debugging
+#
+AC_ARG_WITH(debug,
+ [ --with-debug enable protocol debugging output],
+ [
+ if test $withval != "no";
+ then
+ AC_DEFINE(WITH_DEBUG,1)
+ fi
+ ])
+
+AC_ARG_WITH(debug-kbd,
+ [ --with-debug-kbd enable debugging of keyboard handling],
+ [
+ if test $withval != "no";
+ then
+ AC_DEFINE(WITH_DEBUG_KBD,1)
+ fi
+ ])
+
+AC_ARG_WITH(debug-rdp5,
+ [ --with-debug-rdp5 enable debugging of RDP5 code],
+ [
+ if test $withval != "no";
+ then
+ AC_DEFINE(WITH_DEBUG_RDP5,1)
+ fi
+ ])
+
+AC_ARG_WITH(debug-clipboard,
+ [ --with-debug-clipboard enable debugging of clipboard code],
+ [
+ if test $withval != "no";
+ then
+ AC_DEFINE(WITH_DEBUG_CLIPBOARD,1)
+ fi
+ ])
+
+AC_ARG_WITH(debug-channel,
+ [ --with-debug-channel enable debugging of virtual channel code],
+ [
+ if test $withval != "no";
+ then
+ AC_DEFINE(WITH_DEBUG_CHANNEL,1)
+ fi
+ ])
+
+
+#
+# target-specific stuff
+#
+# strip leading colon from rpath
+rpath=`echo $rpath |sed 's/^://'`
+AC_CANONICAL_HOST
+case "$host" in
+*-*-solaris*)
+ LDFLAGS="$LDFLAGS -R$rpath"
+ ;;
+*-dec-osf*)
+ LDFLAGS="$LDFLAGS -Wl,-rpath,$rpath"
+ ;;
+*-*-hpux*)
+ CFLAGS="$CFLAGS -D_XOPEN_SOURCE_EXTENDED"
+ ;;
+*-*-irix6.5*)
+ LIBS="$LIBS -L$ssldir/lib32 -lcrypto"
+ CFLAGS="$CFLAGS -D__SGI_IRIX__"
+ ;;
+esac
+
+
+AC_OUTPUT(Makefile)
+
+dnl Local Variables:
+dnl comment-start: "dnl "
+dnl comment-end: ""
+dnl comment-start-skip: "\\bdnl\\b\\s *"
+dnl compile-command: "autoconf"
+dnl End:
diff --git a/rosapps/applications/net/tsclient/rdesktop/constants.h b/rosapps/applications/net/tsclient/rdesktop/constants.h
new file mode 100644
index 00000000000..fe940cca3c1
--- /dev/null
+++ b/rosapps/applications/net/tsclient/rdesktop/constants.h
@@ -0,0 +1,430 @@
+/*
+ rdesktop: A Remote Desktop Protocol client.
+ Miscellaneous protocol constants
+ Copyright (C) Matthew Chapman 1999-2005
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+/* TCP port for Remote Desktop Protocol */
+#define TCP_PORT_RDP 3389
+
+#define DEFAULT_CODEPAGE "UTF-8"
+#define WINDOWS_CODEPAGE "UTF-16LE"
+
+/* ISO PDU codes */
+enum ISO_PDU_CODE
+{
+ ISO_PDU_CR = 0xE0, /* Connection Request */
+ ISO_PDU_CC = 0xD0, /* Connection Confirm */
+ ISO_PDU_DR = 0x80, /* Disconnect Request */
+ ISO_PDU_DT = 0xF0, /* Data */
+ ISO_PDU_ER = 0x70 /* Error */
+};
+
+/* MCS PDU codes */
+enum MCS_PDU_TYPE
+{
+ MCS_EDRQ = 1, /* Erect Domain Request */
+ MCS_DPUM = 8, /* Disconnect Provider Ultimatum */
+ MCS_AURQ = 10, /* Attach User Request */
+ MCS_AUCF = 11, /* Attach User Confirm */
+ MCS_CJRQ = 14, /* Channel Join Request */
+ MCS_CJCF = 15, /* Channel Join Confirm */
+ MCS_SDRQ = 25, /* Send Data Request */
+ MCS_SDIN = 26 /* Send Data Indication */
+};
+
+#define MCS_CONNECT_INITIAL 0x7f65
+#define MCS_CONNECT_RESPONSE 0x7f66
+
+#define BER_TAG_BOOLEAN 1
+#define BER_TAG_INTEGER 2
+#define BER_TAG_OCTET_STRING 4
+#define BER_TAG_RESULT 10
+#define MCS_TAG_DOMAIN_PARAMS 0x30
+
+#define MCS_GLOBAL_CHANNEL 1003
+#define MCS_USERCHANNEL_BASE 1001
+
+/* RDP secure transport constants */
+#define SEC_RANDOM_SIZE 32
+#define SEC_MODULUS_SIZE 64
+#define SEC_MAX_MODULUS_SIZE 256
+#define SEC_PADDING_SIZE 8
+#define SEC_EXPONENT_SIZE 4
+
+#define SEC_CLIENT_RANDOM 0x0001
+#define SEC_ENCRYPT 0x0008
+#define SEC_LOGON_INFO 0x0040
+#define SEC_LICENCE_NEG 0x0080
+#define SEC_REDIRECT_ENCRYPT 0x0C00
+
+#define SEC_TAG_SRV_INFO 0x0c01
+#define SEC_TAG_SRV_CRYPT 0x0c02
+#define SEC_TAG_SRV_CHANNELS 0x0c03
+
+#define SEC_TAG_CLI_INFO 0xc001
+#define SEC_TAG_CLI_CRYPT 0xc002
+#define SEC_TAG_CLI_CHANNELS 0xc003
+#define SEC_TAG_CLI_4 0xc004
+
+#define SEC_TAG_PUBKEY 0x0006
+#define SEC_TAG_KEYSIG 0x0008
+
+#define SEC_RSA_MAGIC 0x31415352 /* RSA1 */
+
+/* RDP licensing constants */
+#define LICENCE_TOKEN_SIZE 10
+#define LICENCE_HWID_SIZE 20
+#define LICENCE_SIGNATURE_SIZE 16
+
+#define LICENCE_TAG_DEMAND 0x01
+#define LICENCE_TAG_AUTHREQ 0x02
+#define LICENCE_TAG_ISSUE 0x03
+#define LICENCE_TAG_REISSUE 0x04
+#define LICENCE_TAG_PRESENT 0x12
+#define LICENCE_TAG_REQUEST 0x13
+#define LICENCE_TAG_AUTHRESP 0x15
+#define LICENCE_TAG_RESULT 0xff
+
+#define LICENCE_TAG_USER 0x000f
+#define LICENCE_TAG_HOST 0x0010
+
+/* RDP PDU codes */
+enum RDP_PDU_TYPE
+{
+ RDP_PDU_DEMAND_ACTIVE = 1,
+ RDP_PDU_CONFIRM_ACTIVE = 3,
+ RDP_PDU_REDIRECT = 4, /* MS Server 2003 Session Redirect */
+ RDP_PDU_DEACTIVATE = 6,
+ RDP_PDU_DATA = 7
+};
+
+enum RDP_DATA_PDU_TYPE
+{
+ RDP_DATA_PDU_UPDATE = 2,
+ RDP_DATA_PDU_CONTROL = 20,
+ RDP_DATA_PDU_POINTER = 27,
+ RDP_DATA_PDU_INPUT = 28,
+ RDP_DATA_PDU_SYNCHRONISE = 31,
+ RDP_DATA_PDU_BELL = 34,
+ RDP_DATA_PDU_CLIENT_WINDOW_STATUS = 35,
+ RDP_DATA_PDU_LOGON = 38,
+ RDP_DATA_PDU_FONT2 = 39,
+ RDP_DATA_PDU_KEYBOARD_INDICATORS = 41,
+ RDP_DATA_PDU_DISCONNECT = 47
+};
+
+enum RDP_CONTROL_PDU_TYPE
+{
+ RDP_CTL_REQUEST_CONTROL = 1,
+ RDP_CTL_GRANT_CONTROL = 2,
+ RDP_CTL_DETACH = 3,
+ RDP_CTL_COOPERATE = 4
+};
+
+enum RDP_UPDATE_PDU_TYPE
+{
+ RDP_UPDATE_ORDERS = 0,
+ RDP_UPDATE_BITMAP = 1,
+ RDP_UPDATE_PALETTE = 2,
+ RDP_UPDATE_SYNCHRONIZE = 3
+};
+
+enum RDP_POINTER_PDU_TYPE
+{
+ RDP_POINTER_SYSTEM = 1,
+ RDP_POINTER_MOVE = 3,
+ RDP_POINTER_COLOR = 6,
+ RDP_POINTER_CACHED = 7
+};
+
+enum RDP_SYSTEM_POINTER_TYPE
+{
+ RDP_NULL_POINTER = 0,
+ RDP_DEFAULT_POINTER = 0x7F00
+};
+
+enum RDP_INPUT_DEVICE
+{
+ RDP_INPUT_SYNCHRONIZE = 0,
+ RDP_INPUT_CODEPOINT = 1,
+ RDP_INPUT_VIRTKEY = 2,
+ RDP_INPUT_SCANCODE = 4,
+ RDP_INPUT_MOUSE = 0x8001
+};
+
+/* Device flags */
+#define KBD_FLAG_RIGHT 0x0001
+#define KBD_FLAG_EXT 0x0100
+#define KBD_FLAG_QUIET 0x1000
+#define KBD_FLAG_DOWN 0x4000
+#define KBD_FLAG_UP 0x8000
+
+/* These are for synchronization; not for keystrokes */
+#define KBD_FLAG_SCROLL 0x0001
+#define KBD_FLAG_NUMLOCK 0x0002
+#define KBD_FLAG_CAPITAL 0x0004
+
+/* See T.128 */
+#define RDP_KEYPRESS 0
+#define RDP_KEYRELEASE (KBD_FLAG_DOWN | KBD_FLAG_UP)
+
+#define MOUSE_FLAG_MOVE 0x0800
+#define MOUSE_FLAG_BUTTON1 0x1000
+#define MOUSE_FLAG_BUTTON2 0x2000
+#define MOUSE_FLAG_BUTTON3 0x4000
+#define MOUSE_FLAG_BUTTON4 0x0280
+#define MOUSE_FLAG_BUTTON5 0x0380
+#define MOUSE_FLAG_DOWN 0x8000
+
+/* Raster operation masks */
+#define ROP2_S(rop3) (rop3 & 0xf)
+#define ROP2_P(rop3) ((rop3 & 0x3) | ((rop3 & 0x30) >> 2))
+
+#define ROP2_COPY 0xc
+#define ROP2_XOR 0x6
+#define ROP2_AND 0x8
+#define ROP2_NXOR 0x9
+#define ROP2_OR 0xe
+
+#define MIX_TRANSPARENT 0
+#define MIX_OPAQUE 1
+
+#define TEXT2_VERTICAL 0x04
+#define TEXT2_IMPLICIT_X 0x20
+
+#define ALTERNATE 1
+#define WINDING 2
+
+/* RDP bitmap cache (version 2) constants */
+#define BMPCACHE2_C0_CELLS 0x78
+#define BMPCACHE2_C1_CELLS 0x78
+#define BMPCACHE2_C2_CELLS 0x150
+#define BMPCACHE2_NUM_PSTCELLS 0x9f6
+
+#define PDU_FLAG_FIRST 0x01
+#define PDU_FLAG_LAST 0x02
+
+/* RDP capabilities */
+#define RDP_CAPSET_GENERAL 1 /* Maps to generalCapabilitySet in T.128 page 138 */
+#define RDP_CAPLEN_GENERAL 0x18
+#define OS_MAJOR_TYPE_UNIX 4
+#define OS_MINOR_TYPE_XSERVER 7
+
+#define RDP_CAPSET_BITMAP 2
+#define RDP_CAPLEN_BITMAP 0x1C
+
+#define RDP_CAPSET_ORDER 3
+#define RDP_CAPLEN_ORDER 0x58
+#define ORDER_CAP_NEGOTIATE 2
+#define ORDER_CAP_NOSUPPORT 4
+
+#define RDP_CAPSET_BMPCACHE 4
+#define RDP_CAPLEN_BMPCACHE 0x28
+
+#define RDP_CAPSET_CONTROL 5
+#define RDP_CAPLEN_CONTROL 0x0C
+
+#define RDP_CAPSET_ACTIVATE 7
+#define RDP_CAPLEN_ACTIVATE 0x0C
+
+#define RDP_CAPSET_POINTER 8
+#define RDP_CAPLEN_POINTER 0x08
+
+#define RDP_CAPSET_SHARE 9
+#define RDP_CAPLEN_SHARE 0x08
+
+#define RDP_CAPSET_COLCACHE 10
+#define RDP_CAPLEN_COLCACHE 0x08
+
+#define RDP_CAPSET_BMPCACHE2 19
+#define RDP_CAPLEN_BMPCACHE2 0x28
+#define BMPCACHE2_FLAG_PERSIST ((uint32)1<<31)
+
+#define RDP_SOURCE "MSTSC"
+
+/* Logon flags */
+#define RDP_LOGON_AUTO 0x0008
+#define RDP_LOGON_NORMAL 0x0033
+#define RDP_LOGON_COMPRESSION 0x0080 /* mppc compression with 8kB histroy buffer */
+#define RDP_LOGON_BLOB 0x0100
+#define RDP_LOGON_COMPRESSION2 0x0200 /* rdp5 mppc compression with 64kB history buffer */
+#define RDP_LOGON_LEAVE_AUDIO 0x2000
+
+#define RDP5_DISABLE_NOTHING 0x00
+#define RDP5_NO_WALLPAPER 0x01
+#define RDP5_NO_FULLWINDOWDRAG 0x02
+#define RDP5_NO_MENUANIMATIONS 0x04
+#define RDP5_NO_THEMING 0x08
+#define RDP5_NO_CURSOR_SHADOW 0x20
+#define RDP5_NO_CURSORSETTINGS 0x40 /* disables cursor blinking */
+
+/* compression types */
+#define RDP_MPPC_BIG 0x01
+#define RDP_MPPC_COMPRESSED 0x20
+#define RDP_MPPC_RESET 0x40
+#define RDP_MPPC_FLUSH 0x80
+#define RDP_MPPC_DICT_SIZE 65536
+
+#define RDP5_COMPRESSED 0x80
+
+/* Keymap flags */
+#define MapRightShiftMask (1<<0)
+#define MapLeftShiftMask (1<<1)
+#define MapShiftMask (MapRightShiftMask | MapLeftShiftMask)
+
+#define MapRightAltMask (1<<2)
+#define MapLeftAltMask (1<<3)
+#define MapAltGrMask MapRightAltMask
+
+#define MapRightCtrlMask (1<<4)
+#define MapLeftCtrlMask (1<<5)
+#define MapCtrlMask (MapRightCtrlMask | MapLeftCtrlMask)
+
+#define MapRightWinMask (1<<6)
+#define MapLeftWinMask (1<<7)
+#define MapWinMask (MapRightWinMask | MapLeftWinMask)
+
+#define MapNumLockMask (1<<8)
+#define MapCapsLockMask (1<<9)
+
+#define MapLocalStateMask (1<<10)
+
+#define MapInhibitMask (1<<11)
+
+#define MASK_ADD_BITS(var, mask) (var |= mask)
+#define MASK_REMOVE_BITS(var, mask) (var &= ~mask)
+#define MASK_HAS_BITS(var, mask) ((var & mask)>0)
+#define MASK_CHANGE_BIT(var, mask, active) (var = ((var & ~mask) | (active ? mask : 0)))
+
+/* Clipboard constants, "borrowed" from GCC system headers in
+ the w32 cross compiler */
+
+#if 0
+#define CF_TEXT 1
+#define CF_BITMAP 2
+#define CF_METAFILEPICT 3
+#define CF_SYLK 4
+#define CF_DIF 5
+#define CF_TIFF 6
+#define CF_OEMTEXT 7
+#define CF_DIB 8
+#define CF_PALETTE 9
+#define CF_PENDATA 10
+#define CF_RIFF 11
+#define CF_WAVE 12
+#define CF_UNICODETEXT 13
+#define CF_ENHMETAFILE 14
+#define CF_HDROP 15
+#define CF_LOCALE 16
+#define CF_MAX 17
+#define CF_OWNERDISPLAY 128
+#define CF_DSPTEXT 129
+#define CF_DSPBITMAP 130
+#define CF_DSPMETAFILEPICT 131
+#define CF_DSPENHMETAFILE 142
+#define CF_PRIVATEFIRST 512
+#define CF_PRIVATELAST 767
+#define CF_GDIOBJFIRST 768
+#define CF_GDIOBJLAST 1023
+
+/* Sound format constants */
+#define WAVE_FORMAT_PCM 1
+#define WAVE_FORMAT_ADPCM 2
+#define WAVE_FORMAT_ALAW 6
+#define WAVE_FORMAT_MULAW 7
+
+/* Virtual channel options */
+#define CHANNEL_OPTION_INITIALIZED 0x80000000
+#define CHANNEL_OPTION_ENCRYPT_RDP 0x40000000
+#define CHANNEL_OPTION_COMPRESS_RDP 0x00800000
+#define CHANNEL_OPTION_SHOW_PROTOCOL 0x00200000
+
+/* NT status codes for RDPDR */
+#define STATUS_SUCCESS 0x00000000
+#define STATUS_NOT_IMPLEMENTED 0x00000001
+#define STATUS_PENDING 0x00000103
+
+#define STATUS_NO_MORE_FILES 0x80000006
+#define STATUS_DEVICE_PAPER_EMPTY 0x8000000e
+#define STATUS_DEVICE_POWERED_OFF 0x8000000f
+#define STATUS_DEVICE_OFF_LINE 0x80000010
+#define STATUS_DEVICE_BUSY 0x80000011
+
+#define STATUS_INVALID_HANDLE 0xc0000008
+#define STATUS_INVALID_PARAMETER 0xc000000d
+#define STATUS_NO_SUCH_FILE 0xc000000f
+#define STATUS_INVALID_DEVICE_REQUEST 0xc0000010
+#define STATUS_ACCESS_DENIED 0xc0000022
+#define STATUS_OBJECT_NAME_COLLISION 0xc0000035
+#define STATUS_DISK_FULL 0xc000007f
+#define STATUS_FILE_IS_A_DIRECTORY 0xc00000ba
+#define STATUS_NOT_SUPPORTED 0xc00000bb
+#define STATUS_TIMEOUT 0xc0000102
+#define STATUS_NOTIFY_ENUM_DIR 0xc000010c
+#define STATUS_CANCELLED 0xc0000120
+
+/* RDPDR constants */
+#define RDPDR_MAX_DEVICES 0x10
+#define DEVICE_TYPE_SERIAL 0x01
+#define DEVICE_TYPE_PARALLEL 0x02
+#define DEVICE_TYPE_PRINTER 0x04
+#define DEVICE_TYPE_DISK 0x08
+#define DEVICE_TYPE_SCARD 0x20
+
+#define FILE_DIRECTORY_FILE 0x00000001
+#define FILE_NON_DIRECTORY_FILE 0x00000040
+#define FILE_COMPLETE_IF_OPLOCKED 0x00000100
+#define FILE_DELETE_ON_CLOSE 0x00001000
+#define FILE_OPEN_FOR_FREE_SPACE_QUERY 0x00800000
+
+/* RDP5 disconnect PDU */
+#define exDiscReasonNoInfo 0x0000
+#define exDiscReasonAPIInitiatedDisconnect 0x0001
+#define exDiscReasonAPIInitiatedLogoff 0x0002
+#define exDiscReasonServerIdleTimeout 0x0003
+#define exDiscReasonServerLogonTimeout 0x0004
+#define exDiscReasonReplacedByOtherConnection 0x0005
+#define exDiscReasonOutOfMemory 0x0006
+#define exDiscReasonServerDeniedConnection 0x0007
+#define exDiscReasonServerDeniedConnectionFips 0x0008
+#define exDiscReasonLicenseInternal 0x0100
+#define exDiscReasonLicenseNoLicenseServer 0x0101
+#define exDiscReasonLicenseNoLicense 0x0102
+#define exDiscReasonLicenseErrClientMsg 0x0103
+#define exDiscReasonLicenseHwidDoesntMatchLicense 0x0104
+#define exDiscReasonLicenseErrClientLicense 0x0105
+#define exDiscReasonLicenseCantFinishProtocol 0x0106
+#define exDiscReasonLicenseClientEndedProtocol 0x0107
+#define exDiscReasonLicenseErrClientEncryption 0x0108
+#define exDiscReasonLicenseCantUpgradeLicense 0x0109
+#define exDiscReasonLicenseNoRemoteConnections 0x010a
+#endif
+
+#if 0
+/* SeamlessRDP constants */
+#define SEAMLESSRDP_NOTYETMAPPED -1
+#define SEAMLESSRDP_NORMAL 0
+#define SEAMLESSRDP_MINIMIZED 1
+#define SEAMLESSRDP_MAXIMIZED 2
+#define SEAMLESSRDP_POSITION_TIMER 200000
+
+#define SEAMLESSRDP_CREATE_MODAL 0x0001
+
+#define SEAMLESSRDP_HELLO_RECONNECT 0x0001
+#define SEAMLESSRDP_HELLO_HIDDEN 0x0002
+#endif
diff --git a/rosapps/applications/net/tsclient/rdesktop/disk.c b/rosapps/applications/net/tsclient/rdesktop/disk.c
new file mode 100644
index 00000000000..22f4114291e
--- /dev/null
+++ b/rosapps/applications/net/tsclient/rdesktop/disk.c
@@ -0,0 +1,1246 @@
+/* -*- c-basic-offset: 8 -*-
+ rdesktop: A Remote Desktop Protocol client.
+ Disk Redirection
+ Copyright (C) Jeroen Meijer 2003
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "disk.h"
+
+#include
+#include
+#include
+#include /* open, close */
+#include /* opendir, closedir, readdir */
+#include
+#include /* errno */
+#include
+
+#include
+#include /* ctime */
+
+#if (defined(HAVE_DIRFD) || (HAVE_DECL_DIRFD == 1))
+#define DIRFD(a) (dirfd(a))
+#else
+#define DIRFD(a) ((a)->DIR_FD_MEMBER_NAME)
+#endif
+
+/* TODO: Fix mntent-handling for solaris
+ * #include */
+#if (defined(HAVE_MNTENT_H) && defined(HAVE_SETMNTENT))
+#include
+#define MNTENT_PATH "/etc/mtab"
+#define USE_SETMNTENT
+#endif
+
+#ifdef HAVE_SYS_VFS_H
+#include
+#endif
+
+#ifdef HAVE_SYS_STATVFS_H
+#include
+#endif
+
+#ifdef HAVE_SYS_STATFS_H
+#include
+#endif
+
+#ifdef HAVE_SYS_PARAM_H
+#include
+#endif
+
+#ifdef HAVE_SYS_MOUNT_H
+#include
+#endif
+
+#include "rdesktop.h"
+
+#ifdef STAT_STATFS3_OSF1
+#define STATFS_FN(path, buf) (statfs(path,buf,sizeof(buf)))
+#define STATFS_T statfs
+#define USE_STATFS
+#endif
+
+#ifdef STAT_STATVFS
+#define STATFS_FN(path, buf) (statvfs(path,buf))
+#define STATFS_T statvfs
+#define USE_STATVFS
+#endif
+
+#ifdef STAT_STATVFS64
+#define STATFS_FN(path, buf) (statvfs64(path,buf))
+#define STATFS_T statvfs64
+#define USE_STATVFS
+#endif
+
+#if (defined(STAT_STATFS2_FS_DATA) || defined(STAT_STATFS2_BSIZE) || defined(STAT_STATFS2_FSIZE))
+#define STATFS_FN(path, buf) (statfs(path,buf))
+#define STATFS_T statfs
+#define USE_STATFS
+#endif
+
+#ifdef STAT_STATFS4
+#define STATFS_FN(path, buf) (statfs(path,buf,sizeof(buf),0))
+#define STATFS_T statfs
+#define USE_STATFS
+#endif
+
+#if ((defined(USE_STATFS) && defined(HAVE_STRUCT_STATFS_F_NAMEMAX)) || (defined(USE_STATVFS) && defined(HAVE_STRUCT_STATVFS_F_NAMEMAX)))
+#define F_NAMELEN(buf) ((buf).f_namemax)
+#endif
+
+#if ((defined(USE_STATFS) && defined(HAVE_STRUCT_STATFS_F_NAMELEN)) || (defined(USE_STATVFS) && defined(HAVE_STRUCT_STATVFS_F_NAMELEN)))
+#define F_NAMELEN(buf) ((buf).f_namelen)
+#endif
+
+#ifndef F_NAMELEN
+#define F_NAMELEN(buf) (255)
+#endif
+
+/* Dummy statfs fallback */
+#ifndef STATFS_T
+struct dummy_statfs_t
+{
+ long f_bfree;
+ long f_bsize;
+ long f_blocks;
+ int f_namelen;
+ int f_namemax;
+};
+
+static int
+dummy_statfs(struct dummy_statfs_t *buf)
+{
+ buf->f_blocks = 262144;
+ buf->f_bfree = 131072;
+ buf->f_bsize = 512;
+ buf->f_namelen = 255;
+ buf->f_namemax = 255;
+
+ return 0;
+}
+
+#define STATFS_T dummy_statfs_t
+#define STATFS_FN(path,buf) (dummy_statfs(buf))
+#endif
+
+typedef struct
+{
+ char name[PATH_MAX];
+ char label[PATH_MAX];
+ unsigned long serial;
+ char type[PATH_MAX];
+} FsInfoType;
+
+static NTSTATUS NotifyInfo(RDPCLIENT * This, NTHANDLE handle, uint32 info_class, NOTIFY * p);
+
+static time_t
+get_create_time(struct stat *st)
+{
+ time_t ret, ret1;
+
+ ret = MIN(st->st_ctime, st->st_mtime);
+ ret1 = MIN(ret, st->st_atime);
+
+ if (ret1 != (time_t) 0)
+ return ret1;
+
+ return ret;
+}
+
+/* Convert seconds since 1970 to a filetime */
+static void
+seconds_since_1970_to_filetime(time_t seconds, uint32 * high, uint32 * low)
+{
+ unsigned long long ticks;
+
+ ticks = (seconds + 11644473600LL) * 10000000;
+ *low = (uint32) ticks;
+ *high = (uint32) (ticks >> 32);
+}
+
+/* Convert seconds since 1970 back to filetime */
+static time_t
+convert_1970_to_filetime(uint32 high, uint32 low)
+{
+ unsigned long long ticks;
+ time_t val;
+
+ ticks = low + (((unsigned long long) high) << 32);
+ ticks /= 10000000;
+ ticks -= 11644473600LL;
+
+ val = (time_t) ticks;
+ return (val);
+
+}
+
+/* A wrapper for ftruncate which supports growing files, even if the
+ native ftruncate doesn't. This is needed on Linux FAT filesystems,
+ for example. */
+static int
+ftruncate_growable(int fd, off_t length)
+{
+ int ret;
+ off_t pos;
+ static const char zero = 0;
+
+ /* Try the simple method first */
+ if ((ret = ftruncate(fd, length)) != -1)
+ {
+ return ret;
+ }
+
+ /*
+ * Some kind of error. Perhaps we were trying to grow. Retry
+ * in a safe way.
+ */
+
+ /* Get current position */
+ if ((pos = lseek(fd, 0, SEEK_CUR)) == -1)
+ {
+ perror("lseek");
+ return -1;
+ }
+
+ /* Seek to new size */
+ if (lseek(fd, length, SEEK_SET) == -1)
+ {
+ perror("lseek");
+ return -1;
+ }
+
+ /* Write a zero */
+ if (write(fd, &zero, 1) == -1)
+ {
+ perror("write");
+ return -1;
+ }
+
+ /* Truncate. This shouldn't fail. */
+ if (ftruncate(fd, length) == -1)
+ {
+ perror("ftruncate");
+ return -1;
+ }
+
+ /* Restore position */
+ if (lseek(fd, pos, SEEK_SET) == -1)
+ {
+ perror("lseek");
+ return -1;
+ }
+
+ return 0;
+}
+
+/* Just like open(2), but if a open with O_EXCL fails, retry with
+ GUARDED semantics. This might be necessary because some filesystems
+ (such as NFS filesystems mounted from a unfsd server) doesn't
+ support O_EXCL. GUARDED semantics are subject to race conditions,
+ but we can live with that.
+*/
+static int
+open_weak_exclusive(const char *pathname, int flags, mode_t mode)
+{
+ int ret;
+ struct stat statbuf;
+
+ ret = open(pathname, flags, mode);
+ if (ret != -1 || !(flags & O_EXCL))
+ {
+ /* Success, or not using O_EXCL */
+ return ret;
+ }
+
+ /* An error occured, and we are using O_EXCL. In case the FS
+ doesn't support O_EXCL, some kind of error will be
+ returned. Unfortunately, we don't know which one. Linux
+ 2.6.8 seems to return 524, but I cannot find a documented
+ #define for this case. So, we'll return only on errors that
+ we know aren't related to O_EXCL. */
+ switch (errno)
+ {
+ case EACCES:
+ case EEXIST:
+ case EINTR:
+ case EISDIR:
+ case ELOOP:
+ case ENAMETOOLONG:
+ case ENOENT:
+ case ENOTDIR:
+ return ret;
+ }
+
+ /* Retry with GUARDED semantics */
+ if (stat(pathname, &statbuf) != -1)
+ {
+ /* File exists */
+ errno = EEXIST;
+ return -1;
+ }
+ else
+ {
+ return open(pathname, flags & ~O_EXCL, mode);
+ }
+}
+
+/* Enumeration of devices from rdesktop.c */
+/* returns numer of units found and initialized. */
+/* optarg looks like ':h=/mnt/floppy,b=/mnt/usbdevice1' */
+/* when it arrives to this function. */
+int
+disk_enum_devices(RDPCLIENT * This, uint32 * id, char *optarg)
+{
+ char *pos = optarg;
+ char *pos2;
+ int count = 0;
+
+ /* skip the first colon */
+ optarg++;
+ while ((pos = next_arg(optarg, ',')) && *id < RDPDR_MAX_DEVICES)
+ {
+ pos2 = next_arg(optarg, '=');
+
+ strncpy(This->rdpdr_device[*id].name, optarg, sizeof(This->rdpdr_device[*id].name) - 1);
+ if (strlen(optarg) > (sizeof(This->rdpdr_device[*id].name) - 1))
+ fprintf(stderr, "share name %s truncated to %s\n", optarg,
+ This->rdpdr_device[*id].name);
+
+ This->rdpdr_device[*id].local_path = (char *) xmalloc(strlen(pos2) + 1);
+ strcpy(This->rdpdr_device[*id].local_path, pos2);
+ This->rdpdr_device[*id].device_type = DEVICE_TYPE_DISK;
+ count++;
+ (*id)++;
+
+ optarg = pos;
+ }
+ return count;
+}
+
+/* Opens or creates a file or directory */
+static NTSTATUS
+disk_create(RDPCLIENT * This, uint32 device_id, uint32 accessmask, uint32 sharemode, uint32 create_disposition,
+ uint32 flags_and_attributes, char *filename, NTHANDLE * phandle)
+{
+ NTHANDLE handle;
+ DIR *dirp;
+ int flags, mode;
+ char path[PATH_MAX];
+ struct stat filestat;
+
+ handle = 0;
+ dirp = NULL;
+ flags = 0;
+ mode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
+
+ if (*filename && filename[strlen(filename) - 1] == '/')
+ filename[strlen(filename) - 1] = 0;
+ sprintf(path, "%s%s", This->rdpdr_device[device_id].local_path, filename);
+
+ switch (create_disposition)
+ {
+ case CREATE_ALWAYS:
+
+ /* Delete existing file/link. */
+ unlink(path);
+ flags |= O_CREAT;
+ break;
+
+ case CREATE_NEW:
+
+ /* If the file already exists, then fail. */
+ flags |= O_CREAT | O_EXCL;
+ break;
+
+ case OPEN_ALWAYS:
+
+ /* Create if not already exists. */
+ flags |= O_CREAT;
+ break;
+
+ case OPEN_EXISTING:
+
+ /* Default behaviour */
+ break;
+
+ case TRUNCATE_EXISTING:
+
+ /* If the file does not exist, then fail. */
+ flags |= O_TRUNC;
+ break;
+ }
+
+ /*printf("Open: \"%s\" flags: %X, accessmask: %X sharemode: %X create disp: %X\n", path, flags_and_attributes, accessmask, sharemode, create_disposition); */
+
+ /* Get information about file and set that flag ourselfs */
+ if ((stat(path, &filestat) == 0) && (S_ISDIR(filestat.st_mode)))
+ {
+ if (flags_and_attributes & FILE_NON_DIRECTORY_FILE)
+ return STATUS_FILE_IS_A_DIRECTORY;
+ else
+ flags_and_attributes |= FILE_DIRECTORY_FILE;
+ }
+
+ if (flags_and_attributes & FILE_DIRECTORY_FILE)
+ {
+ if (flags & O_CREAT)
+ {
+ mkdir(path, mode);
+ }
+
+ dirp = opendir(path);
+ if (!dirp)
+ {
+ switch (errno)
+ {
+ case EACCES:
+
+ return STATUS_ACCESS_DENIED;
+
+ case ENOENT:
+
+ return STATUS_NO_SUCH_FILE;
+
+ default:
+
+ perror("opendir");
+ return STATUS_NO_SUCH_FILE;
+ }
+ }
+ handle = DIRFD(dirp);
+ }
+ else
+ {
+
+ if (accessmask & GENERIC_ALL
+ || (accessmask & GENERIC_READ && accessmask & GENERIC_WRITE))
+ {
+ flags |= O_RDWR;
+ }
+ else if ((accessmask & GENERIC_WRITE) && !(accessmask & GENERIC_READ))
+ {
+ flags |= O_WRONLY;
+ }
+ else
+ {
+ flags |= O_RDONLY;
+ }
+
+ handle = open_weak_exclusive(path, flags, mode);
+ if (handle == -1)
+ {
+ switch (errno)
+ {
+ case EISDIR:
+
+ return STATUS_FILE_IS_A_DIRECTORY;
+
+ case EACCES:
+
+ return STATUS_ACCESS_DENIED;
+
+ case ENOENT:
+
+ return STATUS_NO_SUCH_FILE;
+ case EEXIST:
+
+ return STATUS_OBJECT_NAME_COLLISION;
+ default:
+
+ perror("open");
+ return STATUS_NO_SUCH_FILE;
+ }
+ }
+
+ /* all read and writes of files should be non blocking */
+ if (fcntl(handle, F_SETFL, O_NONBLOCK) == -1)
+ perror("fcntl");
+ }
+
+ if (handle >= MAX_OPEN_FILES)
+ {
+ error("Maximum number of open files (%s) reached. Increase MAX_OPEN_FILES!\n",
+ handle);
+ exit(1);
+ }
+
+ if (dirp)
+ This->fileinfo[handle].pdir = dirp;
+ else
+ This->fileinfo[handle].pdir = NULL;
+
+ This->fileinfo[handle].device_id = device_id;
+ This->fileinfo[handle].flags_and_attributes = flags_and_attributes;
+ This->fileinfo[handle].accessmask = accessmask;
+ strncpy(This->fileinfo[handle].path, path, PATH_MAX - 1);
+ This->fileinfo[handle].delete_on_close = False;
+ This->notify_stamp = True;
+
+ *phandle = handle;
+ return STATUS_SUCCESS;
+}
+
+static NTSTATUS
+disk_close(RDPCLIENT * This, NTHANDLE handle)
+{
+ struct fileinfo *pfinfo;
+
+ pfinfo = &(This->fileinfo[handle]);
+
+ This->notify_stamp = True;
+
+ rdpdr_abort_io(This, handle, 0, STATUS_CANCELLED);
+
+ if (pfinfo->pdir)
+ {
+ if (closedir(pfinfo->pdir) < 0)
+ {
+ perror("closedir");
+ return STATUS_INVALID_HANDLE;
+ }
+
+ if (pfinfo->delete_on_close)
+ if (rmdir(pfinfo->path) < 0)
+ {
+ perror(pfinfo->path);
+ return STATUS_ACCESS_DENIED;
+ }
+ pfinfo->delete_on_close = False;
+ }
+ else
+ {
+ if (close(handle) < 0)
+ {
+ perror("close");
+ return STATUS_INVALID_HANDLE;
+ }
+ if (pfinfo->delete_on_close)
+ if (unlink(pfinfo->path) < 0)
+ {
+ perror(pfinfo->path);
+ return STATUS_ACCESS_DENIED;
+ }
+
+ pfinfo->delete_on_close = False;
+ }
+
+ return STATUS_SUCCESS;
+}
+
+static NTSTATUS
+disk_read(RDPCLIENT * This, NTHANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result)
+{
+ int n;
+
+#if 0
+ /* browsing dir ???? */
+ /* each request is 24 bytes */
+ if (This->fileinfo[handle].flags_and_attributes & FILE_DIRECTORY_FILE)
+ {
+ *result = 0;
+ return STATUS_SUCCESS;
+ }
+#endif
+
+ lseek(handle, offset, SEEK_SET);
+
+ n = read(handle, data, length);
+
+ if (n < 0)
+ {
+ *result = 0;
+ switch (errno)
+ {
+ case EISDIR:
+ /* Implement 24 Byte directory read ??
+ with STATUS_NOT_IMPLEMENTED server doesn't read again */
+ /* return STATUS_FILE_IS_A_DIRECTORY; */
+ return STATUS_NOT_IMPLEMENTED;
+ default:
+ perror("read");
+ return STATUS_INVALID_PARAMETER;
+ }
+ }
+
+ *result = n;
+
+ return STATUS_SUCCESS;
+}
+
+static NTSTATUS
+disk_write(RDPCLIENT * This, NTHANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result)
+{
+ int n;
+
+ lseek(handle, offset, SEEK_SET);
+
+ n = write(handle, data, length);
+
+ if (n < 0)
+ {
+ perror("write");
+ *result = 0;
+ switch (errno)
+ {
+ case ENOSPC:
+ return STATUS_DISK_FULL;
+ default:
+ return STATUS_ACCESS_DENIED;
+ }
+ }
+
+ *result = n;
+
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS
+disk_query_information(RDPCLIENT * This, NTHANDLE handle, uint32 info_class, STREAM out)
+{
+ uint32 file_attributes, ft_high, ft_low;
+ struct stat filestat;
+ char *path, *filename;
+
+ path = This->fileinfo[handle].path;
+
+ /* Get information about file */
+ if (fstat(handle, &filestat) != 0)
+ {
+ perror("stat");
+ out_uint8(out, 0);
+ return STATUS_ACCESS_DENIED;
+ }
+
+ /* Set file attributes */
+ file_attributes = 0;
+ if (S_ISDIR(filestat.st_mode))
+ file_attributes |= FILE_ATTRIBUTE_DIRECTORY;
+
+ filename = 1 + strrchr(path, '/');
+ if (filename && filename[0] == '.')
+ file_attributes |= FILE_ATTRIBUTE_HIDDEN;
+
+ if (!file_attributes)
+ file_attributes |= FILE_ATTRIBUTE_NORMAL;
+
+ if (!(filestat.st_mode & S_IWUSR))
+ file_attributes |= FILE_ATTRIBUTE_READONLY;
+
+ /* Return requested data */
+ switch (info_class)
+ {
+ case FileBasicInformation:
+ seconds_since_1970_to_filetime(get_create_time(&filestat), &ft_high,
+ &ft_low);
+ out_uint32_le(out, ft_low); /* create_access_time */
+ out_uint32_le(out, ft_high);
+
+ seconds_since_1970_to_filetime(filestat.st_atime, &ft_high, &ft_low);
+ out_uint32_le(out, ft_low); /* last_access_time */
+ out_uint32_le(out, ft_high);
+
+ seconds_since_1970_to_filetime(filestat.st_mtime, &ft_high, &ft_low);
+ out_uint32_le(out, ft_low); /* last_write_time */
+ out_uint32_le(out, ft_high);
+
+ seconds_since_1970_to_filetime(filestat.st_ctime, &ft_high, &ft_low);
+ out_uint32_le(out, ft_low); /* last_change_time */
+ out_uint32_le(out, ft_high);
+
+ out_uint32_le(out, file_attributes);
+ break;
+
+ case FileStandardInformation:
+
+ out_uint32_le(out, filestat.st_size); /* Allocation size */
+ out_uint32_le(out, 0);
+ out_uint32_le(out, filestat.st_size); /* End of file */
+ out_uint32_le(out, 0);
+ out_uint32_le(out, filestat.st_nlink); /* Number of links */
+ out_uint8(out, 0); /* Delete pending */
+ out_uint8(out, S_ISDIR(filestat.st_mode) ? 1 : 0); /* Directory */
+ break;
+
+ case FileObjectIdInformation:
+
+ out_uint32_le(out, file_attributes); /* File Attributes */
+ out_uint32_le(out, 0); /* Reparse Tag */
+ break;
+
+ default:
+
+ unimpl("IRP Query (File) Information class: 0x%x\n", info_class);
+ return STATUS_INVALID_PARAMETER;
+ }
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS
+disk_set_information(RDPCLIENT * This, NTHANDLE handle, uint32 info_class, STREAM in, STREAM out)
+{
+ uint32 length, file_attributes, ft_high, ft_low, delete_on_close;
+ char newname[PATH_MAX], fullpath[PATH_MAX];
+ struct fileinfo *pfinfo;
+ int mode;
+ struct stat filestat;
+ time_t write_time, change_time, access_time, mod_time;
+ struct utimbuf tvs;
+ struct STATFS_T stat_fs;
+
+ pfinfo = &(This->fileinfo[handle]);
+ This->notify_stamp = True;
+
+ switch (info_class)
+ {
+ case FileBasicInformation:
+ write_time = change_time = access_time = 0;
+
+ in_uint8s(in, 4); /* Handle of root dir? */
+ in_uint8s(in, 24); /* unknown */
+
+ /* CreationTime */
+ in_uint32_le(in, ft_low);
+ in_uint32_le(in, ft_high);
+
+ /* AccessTime */
+ in_uint32_le(in, ft_low);
+ in_uint32_le(in, ft_high);
+ if (ft_low || ft_high)
+ access_time = convert_1970_to_filetime(ft_high, ft_low);
+
+ /* WriteTime */
+ in_uint32_le(in, ft_low);
+ in_uint32_le(in, ft_high);
+ if (ft_low || ft_high)
+ write_time = convert_1970_to_filetime(ft_high, ft_low);
+
+ /* ChangeTime */
+ in_uint32_le(in, ft_low);
+ in_uint32_le(in, ft_high);
+ if (ft_low || ft_high)
+ change_time = convert_1970_to_filetime(ft_high, ft_low);
+
+ in_uint32_le(in, file_attributes);
+
+ if (fstat(handle, &filestat))
+ return STATUS_ACCESS_DENIED;
+
+ tvs.modtime = filestat.st_mtime;
+ tvs.actime = filestat.st_atime;
+ if (access_time)
+ tvs.actime = access_time;
+
+
+ if (write_time || change_time)
+ mod_time = MIN(write_time, change_time);
+ else
+ mod_time = write_time ? write_time : change_time;
+
+ if (mod_time)
+ tvs.modtime = mod_time;
+
+
+ if (access_time || write_time || change_time)
+ {
+#if WITH_DEBUG_RDP5
+ printf("FileBasicInformation access time %s",
+ ctime(&tvs.actime));
+ printf("FileBasicInformation modification time %s",
+ ctime(&tvs.modtime));
+#endif
+ if (utime(pfinfo->path, &tvs) && errno != EPERM)
+ return STATUS_ACCESS_DENIED;
+ }
+
+ if (!file_attributes)
+ break; /* not valid */
+
+ mode = filestat.st_mode;
+
+ if (file_attributes & FILE_ATTRIBUTE_READONLY)
+ mode &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
+ else
+ mode |= S_IWUSR;
+
+ mode &= 0777;
+#if WITH_DEBUG_RDP5
+ printf("FileBasicInformation set access mode 0%o", mode);
+#endif
+
+ if (fchmod(handle, mode))
+ return STATUS_ACCESS_DENIED;
+
+ break;
+
+ case FileRenameInformation:
+
+ in_uint8s(in, 4); /* Handle of root dir? */
+ in_uint8s(in, 0x1a); /* unknown */
+ in_uint32_le(in, length);
+
+ if (length && (length / 2) < 256)
+ {
+ rdp_in_unistr(This, in, newname, length);
+ convert_to_unix_filename(newname);
+ }
+ else
+ {
+ return STATUS_INVALID_PARAMETER;
+ }
+
+ sprintf(fullpath, "%s%s", This->rdpdr_device[pfinfo->device_id].local_path,
+ newname);
+
+ if (rename(pfinfo->path, fullpath) != 0)
+ {
+ perror("rename");
+ return STATUS_ACCESS_DENIED;
+ }
+ break;
+
+ case FileDispositionInformation:
+ /* As far as I understand it, the correct
+ thing to do here is to *schedule* a delete,
+ so it will be deleted when the file is
+ closed. Subsequent
+ FileDispositionInformation requests with
+ DeleteFile set to FALSE should unschedule
+ the delete. See
+ http://www.osronline.com/article.cfm?article=245. */
+
+ in_uint32_le(in, delete_on_close);
+
+ if (delete_on_close ||
+ (pfinfo->
+ accessmask & (FILE_DELETE_ON_CLOSE | FILE_COMPLETE_IF_OPLOCKED)))
+ {
+ pfinfo->delete_on_close = True;
+ }
+
+ break;
+
+ case FileAllocationInformation:
+ /* Fall through to FileEndOfFileInformation,
+ which uses ftrunc. This is like Samba with
+ "strict allocation = false", and means that
+ we won't detect out-of-quota errors, for
+ example. */
+
+ case FileEndOfFileInformation:
+ in_uint8s(in, 28); /* unknown */
+ in_uint32_le(in, length); /* file size */
+
+ /* prevents start of writing if not enough space left on device */
+ if (STATFS_FN(This->rdpdr_device[pfinfo->device_id].local_path, &stat_fs) == 0)
+ if (stat_fs.f_bfree * stat_fs.f_bsize < length)
+ return STATUS_DISK_FULL;
+
+ if (ftruncate_growable(handle, length) != 0)
+ {
+ return STATUS_DISK_FULL;
+ }
+
+ break;
+ default:
+
+ unimpl("IRP Set File Information class: 0x%x\n", info_class);
+ return STATUS_INVALID_PARAMETER;
+ }
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS
+disk_check_notify(RDPCLIENT * This, NTHANDLE handle)
+{
+ struct fileinfo *pfinfo;
+ NTSTATUS status = STATUS_PENDING;
+
+ NOTIFY notify;
+
+ pfinfo = &(This->fileinfo[handle]);
+ if (!pfinfo->pdir)
+ return STATUS_INVALID_DEVICE_REQUEST;
+
+
+
+ status = NotifyInfo(This, handle, pfinfo->info_class, ¬ify);
+
+ if (status != STATUS_PENDING)
+ return status;
+
+ if (memcmp(&pfinfo->notify, ¬ify, sizeof(NOTIFY)))
+ {
+ /*printf("disk_check_notify found changed event\n"); */
+ memcpy(&pfinfo->notify, ¬ify, sizeof(NOTIFY));
+ status = STATUS_NOTIFY_ENUM_DIR;
+ }
+
+ return status;
+
+
+}
+
+NTSTATUS
+disk_create_notify(RDPCLIENT * This, NTHANDLE handle, uint32 info_class)
+{
+
+ struct fileinfo *pfinfo;
+ NTSTATUS ret = STATUS_PENDING;
+
+ /* printf("start disk_create_notify info_class %X\n", info_class); */
+
+ pfinfo = &(This->fileinfo[handle]);
+ pfinfo->info_class = info_class;
+
+ ret = NotifyInfo(This, handle, info_class, &pfinfo->notify);
+
+ if (info_class & 0x1000)
+ { /* ???? */
+ if (ret == STATUS_PENDING)
+ return STATUS_SUCCESS;
+ }
+
+ /* printf("disk_create_notify: num_entries %d\n", pfinfo->notify.num_entries); */
+
+
+ return ret;
+
+}
+
+static NTSTATUS
+NotifyInfo(RDPCLIENT * This, NTHANDLE handle, uint32 info_class, NOTIFY * p)
+{
+ struct fileinfo *pfinfo;
+ struct stat buf;
+ struct dirent *dp;
+ char *fullname;
+ DIR *dpr;
+
+ pfinfo = &(This->fileinfo[handle]);
+ if (fstat(handle, &buf) < 0)
+ {
+ perror("NotifyInfo");
+ return STATUS_ACCESS_DENIED;
+ }
+ p->modify_time = buf.st_mtime;
+ p->status_time = buf.st_ctime;
+ p->num_entries = 0;
+ p->total_time = 0;
+
+
+ dpr = opendir(pfinfo->path);
+ if (!dpr)
+ {
+ perror("NotifyInfo");
+ return STATUS_ACCESS_DENIED;
+ }
+
+
+ while ((dp = readdir(dpr)))
+ {
+ if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
+ continue;
+ p->num_entries++;
+ fullname = (char *) xmalloc(strlen(pfinfo->path) + strlen(dp->d_name) + 2);
+ sprintf(fullname, "%s/%s", pfinfo->path, dp->d_name);
+
+ if (!stat(fullname, &buf))
+ {
+ p->total_time += (buf.st_mtime + buf.st_ctime);
+ }
+
+ xfree(fullname);
+ }
+ closedir(dpr);
+
+ return STATUS_PENDING;
+}
+
+static FsInfoType *
+FsVolumeInfo(char *fpath)
+{
+
+ static FsInfoType info;
+#ifdef USE_SETMNTENT
+ FILE *fdfs;
+ struct mntent *e;
+#endif
+
+ /* initialize */
+ memset(&info, 0, sizeof(info));
+ strcpy(info.label, "RDESKTOP");
+ strcpy(info.type, "RDPFS");
+
+#ifdef USE_SETMNTENT
+ fdfs = setmntent(MNTENT_PATH, "r");
+ if (!fdfs)
+ return &info;
+
+ while ((e = getmntent(fdfs)))
+ {
+ if (str_startswith(e->mnt_dir, fpath))
+ {
+ strcpy(info.type, e->mnt_type);
+ strcpy(info.name, e->mnt_fsname);
+ if (strstr(e->mnt_opts, "vfat") || strstr(e->mnt_opts, "iso9660"))
+ {
+ int fd = open(e->mnt_fsname, O_RDONLY);
+ if (fd >= 0)
+ {
+ unsigned char buf[512];
+ memset(buf, 0, sizeof(buf));
+ if (strstr(e->mnt_opts, "vfat"))
+ /*FAT*/
+ {
+ strcpy(info.type, "vfat");
+ read(fd, buf, sizeof(buf));
+ info.serial =
+ (buf[42] << 24) + (buf[41] << 16) +
+ (buf[40] << 8) + buf[39];
+ strncpy(info.label, buf + 43, 10);
+ info.label[10] = '\0';
+ }
+ else if (lseek(fd, 32767, SEEK_SET) >= 0) /* ISO9660 */
+ {
+ read(fd, buf, sizeof(buf));
+ strncpy(info.label, buf + 41, 32);
+ info.label[32] = '\0';
+ /* info.Serial = (buf[128]<<24)+(buf[127]<<16)+(buf[126]<<8)+buf[125]; */
+ }
+ close(fd);
+ }
+ }
+ }
+ }
+ endmntent(fdfs);
+#else
+ /* initialize */
+ memset(&info, 0, sizeof(info));
+ strcpy(info.label, "RDESKTOP");
+ strcpy(info.type, "RDPFS");
+
+#endif
+ return &info;
+}
+
+
+NTSTATUS
+disk_query_volume_information(RDPCLIENT * This, NTHANDLE handle, uint32 info_class, STREAM out)
+{
+ struct STATFS_T stat_fs;
+ struct fileinfo *pfinfo;
+ FsInfoType *fsinfo;
+
+ pfinfo = &(This->fileinfo[handle]);
+
+ if (STATFS_FN(pfinfo->path, &stat_fs) != 0)
+ {
+ perror("statfs");
+ return STATUS_ACCESS_DENIED;
+ }
+
+ fsinfo = FsVolumeInfo(pfinfo->path);
+
+ switch (info_class)
+ {
+ case FileFsVolumeInformation:
+
+ out_uint32_le(out, 0); /* volume creation time low */
+ out_uint32_le(out, 0); /* volume creation time high */
+ out_uint32_le(out, fsinfo->serial); /* serial */
+
+ out_uint32_le(out, 2 * strlen(fsinfo->label)); /* length of string */
+
+ out_uint8(out, 0); /* support objects? */
+ rdp_out_unistr(This, out, fsinfo->label, 2 * strlen(fsinfo->label) - 2);
+ break;
+
+ case FileFsSizeInformation:
+
+ out_uint32_le(out, stat_fs.f_blocks); /* Total allocation units low */
+ out_uint32_le(out, 0); /* Total allocation high units */
+ out_uint32_le(out, stat_fs.f_bfree); /* Available allocation units */
+ out_uint32_le(out, 0); /* Available allowcation units */
+ out_uint32_le(out, stat_fs.f_bsize / 0x200); /* Sectors per allocation unit */
+ out_uint32_le(out, 0x200); /* Bytes per sector */
+ break;
+
+ case FileFsAttributeInformation:
+
+ out_uint32_le(out, FS_CASE_SENSITIVE | FS_CASE_IS_PRESERVED); /* fs attributes */
+ out_uint32_le(out, F_NAMELEN(stat_fs)); /* max length of filename */
+
+ out_uint32_le(out, 2 * strlen(fsinfo->type)); /* length of fs_type */
+ rdp_out_unistr(This, out, fsinfo->type, 2 * strlen(fsinfo->type) - 2);
+ break;
+
+ case FileFsLabelInformation:
+ case FileFsDeviceInformation:
+ case FileFsControlInformation:
+ case FileFsFullSizeInformation:
+ case FileFsObjectIdInformation:
+ case FileFsMaximumInformation:
+
+ default:
+
+ unimpl("IRP Query Volume Information class: 0x%x\n", info_class);
+ return STATUS_INVALID_PARAMETER;
+ }
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS
+disk_query_directory(RDPCLIENT * This, NTHANDLE handle, uint32 info_class, char *pattern, STREAM out)
+{
+ uint32 file_attributes, ft_low, ft_high;
+ char *dirname, fullpath[PATH_MAX];
+ DIR *pdir;
+ struct dirent *pdirent;
+ struct stat fstat;
+ struct fileinfo *pfinfo;
+
+ pfinfo = &(This->fileinfo[handle]);
+ pdir = pfinfo->pdir;
+ dirname = pfinfo->path;
+ file_attributes = 0;
+
+ switch (info_class)
+ {
+ case FileBothDirectoryInformation:
+
+ /* If a search pattern is received, remember this pattern, and restart search */
+ if (pattern[0] != 0)
+ {
+ strncpy(pfinfo->pattern, 1 + strrchr(pattern, '/'), PATH_MAX - 1);
+ rewinddir(pdir);
+ }
+
+ /* find next dirent matching pattern */
+ pdirent = readdir(pdir);
+ while (pdirent && fnmatch(pfinfo->pattern, pdirent->d_name, 0) != 0)
+ pdirent = readdir(pdir);
+
+ if (pdirent == NULL)
+ return STATUS_NO_MORE_FILES;
+
+ /* Get information for directory entry */
+ sprintf(fullpath, "%s/%s", dirname, pdirent->d_name);
+
+ if (stat(fullpath, &fstat))
+ {
+ switch (errno)
+ {
+ case ENOENT:
+ case ELOOP:
+ case EACCES:
+ /* These are non-fatal errors. */
+ memset(&fstat, 0, sizeof(fstat));
+ break;
+ default:
+ /* Fatal error. By returning STATUS_NO_SUCH_FILE,
+ the directory list operation will be aborted */
+ perror(fullpath);
+ out_uint8(out, 0);
+ return STATUS_NO_SUCH_FILE;
+ }
+ }
+
+ if (S_ISDIR(fstat.st_mode))
+ file_attributes |= FILE_ATTRIBUTE_DIRECTORY;
+ if (pdirent->d_name[0] == '.')
+ file_attributes |= FILE_ATTRIBUTE_HIDDEN;
+ if (!file_attributes)
+ file_attributes |= FILE_ATTRIBUTE_NORMAL;
+ if (!(fstat.st_mode & S_IWUSR))
+ file_attributes |= FILE_ATTRIBUTE_READONLY;
+
+ /* Return requested information */
+ out_uint8s(out, 8); /* unknown zero */
+
+ seconds_since_1970_to_filetime(get_create_time(&fstat), &ft_high, &ft_low);
+ out_uint32_le(out, ft_low); /* create time */
+ out_uint32_le(out, ft_high);
+
+ seconds_since_1970_to_filetime(fstat.st_atime, &ft_high, &ft_low);
+ out_uint32_le(out, ft_low); /* last_access_time */
+ out_uint32_le(out, ft_high);
+
+ seconds_since_1970_to_filetime(fstat.st_mtime, &ft_high, &ft_low);
+ out_uint32_le(out, ft_low); /* last_write_time */
+ out_uint32_le(out, ft_high);
+
+ seconds_since_1970_to_filetime(fstat.st_ctime, &ft_high, &ft_low);
+ out_uint32_le(out, ft_low); /* change_write_time */
+ out_uint32_le(out, ft_high);
+
+ out_uint32_le(out, fstat.st_size); /* filesize low */
+ out_uint32_le(out, 0); /* filesize high */
+ out_uint32_le(out, fstat.st_size); /* filesize low */
+ out_uint32_le(out, 0); /* filesize high */
+ out_uint32_le(out, file_attributes);
+ out_uint8(out, 2 * strlen(pdirent->d_name) + 2); /* unicode length */
+ out_uint8s(out, 7); /* pad? */
+ out_uint8(out, 0); /* 8.3 file length */
+ out_uint8s(out, 2 * 12); /* 8.3 unicode length */
+ rdp_out_unistr(This, out, pdirent->d_name, 2 * strlen(pdirent->d_name));
+ break;
+
+ default:
+ /* FIXME: Support FileDirectoryInformation,
+ FileFullDirectoryInformation, and
+ FileNamesInformation */
+
+ unimpl("IRP Query Directory sub: 0x%x\n", info_class);
+ return STATUS_INVALID_PARAMETER;
+ }
+
+ return STATUS_SUCCESS;
+}
+
+
+
+static NTSTATUS
+disk_device_control(RDPCLIENT * This, NTHANDLE handle, uint32 request, STREAM in, STREAM out)
+{
+ if (((request >> 16) != 20) || ((request >> 16) != 9))
+ return STATUS_INVALID_PARAMETER;
+
+ /* extract operation */
+ request >>= 2;
+ request &= 0xfff;
+
+ printf("DISK IOCTL %d\n", request);
+
+ switch (request)
+ {
+ case 25: /* ? */
+ case 42: /* ? */
+ default:
+ unimpl("DISK IOCTL %d\n", request);
+ return STATUS_INVALID_PARAMETER;
+ }
+
+ return STATUS_SUCCESS;
+}
+
+DEVICE_FNS disk_fns = {
+ disk_create,
+ disk_close,
+ disk_read,
+ disk_write,
+ disk_device_control /* device_control */
+};
diff --git a/rosapps/applications/net/tsclient/rdesktop/disk.h b/rosapps/applications/net/tsclient/rdesktop/disk.h
new file mode 100644
index 00000000000..447ebb59798
--- /dev/null
+++ b/rosapps/applications/net/tsclient/rdesktop/disk.h
@@ -0,0 +1,139 @@
+/*
+ rdesktop: A Remote Desktop Protocol client.
+ Disk Redirection definitions
+ Copyright (C) Jeroen Meijer 2003
+ Copyright (C) Peter Astrand 2004
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#define FILE_ATTRIBUTE_READONLY 0x00000001
+#define FILE_ATTRIBUTE_HIDDEN 0x00000002
+#define FILE_ATTRIBUTE_SYSTEM 0x00000004
+#define FILE_ATTRIBUTE_DIRECTORY 0x00000010
+#define FILE_ATTRIBUTE_ARCHIVE 0x00000020
+#define FILE_ATTRIBUTE_DEVICE 0x00000040
+#define FILE_ATTRIBUTE_UNKNOWNXXX0 0x00000060 /* ??? ACTION i.e. 0x860 == compress this file ? */
+#define FILE_ATTRIBUTE_NORMAL 0x00000080
+#define FILE_ATTRIBUTE_TEMPORARY 0x00000100
+#define FILE_ATTRIBUTE_SPARSE_FILE 0x00000200
+#define FILE_ATTRIBUTE_REPARSE_POINT 0x00000400
+#define FILE_ATTRIBUTE_COMPRESSED 0x00000800
+#define FILE_ATTRIBUTE_OFFLINE 0x00001000
+#define FILE_ATTRIBUTE_NOT_CONTENT_INDEXED 0x00002000
+#define FILE_ATTRIBUTE_ENCRYPTED 0x00004000
+
+#define FILE_FLAG_OPEN_NO_RECALL 0x00100000
+#define FILE_FLAG_OPEN_REPARSE_POINT 0x00200000
+#define FILE_FLAG_POSIX_SEMANTICS 0x01000000
+#define FILE_FLAG_BACKUP_SEMANTICS 0x02000000 /* sometimes used to create a directory */
+#define FILE_FLAG_DELETE_ON_CLOSE 0x04000000
+#define FILE_FLAG_SEQUENTIAL_SCAN 0x08000000
+#define FILE_FLAG_RANDOM_ACCESS 0x10000000
+#define FILE_FLAG_NO_BUFFERING 0x20000000
+#define FILE_FLAG_OVERLAPPED 0x40000000
+#define FILE_FLAG_WRITE_THROUGH 0x80000000
+
+#define FILE_SHARE_READ 0x01
+#define FILE_SHARE_WRITE 0x02
+#define FILE_SHARE_DELETE 0x04
+
+#define FILE_BASIC_INFORMATION 0x04
+#define FILE_STANDARD_INFORMATION 0x05
+
+#define FS_CASE_SENSITIVE 0x00000001
+#define FS_CASE_IS_PRESERVED 0x00000002
+#define FS_UNICODE_STORED_ON_DISK 0x00000004
+#define FS_PERSISTENT_ACLS 0x00000008
+#define FS_FILE_COMPRESSION 0x00000010
+#define FS_VOLUME_QUOTAS 0x00000020
+#define FS_SUPPORTS_SPARSE_FILES 0x00000040
+#define FS_SUPPORTS_REPARSE_POINTS 0x00000080
+#define FS_SUPPORTS_REMOTE_STORAGE 0X00000100
+#define FS_VOL_IS_COMPRESSED 0x00008000
+#define FILE_READ_ONLY_VOLUME 0x00080000
+
+#define OPEN_EXISTING 1
+#define CREATE_NEW 2
+#define OPEN_ALWAYS 3
+#define TRUNCATE_EXISTING 4
+#define CREATE_ALWAYS 5
+
+#define GENERIC_READ 0x80000000
+#define GENERIC_WRITE 0x40000000
+#define GENERIC_EXECUTE 0x20000000
+#define GENERIC_ALL 0x10000000
+
+#define ERROR_FILE_NOT_FOUND 2L
+#define ERROR_ALREADY_EXISTS 183L
+
+typedef enum _FILE_INFORMATION_CLASS
+{
+ FileDirectoryInformation = 1,
+ FileFullDirectoryInformation,
+ FileBothDirectoryInformation,
+ FileBasicInformation,
+ FileStandardInformation,
+ FileInternalInformation,
+ FileEaInformation,
+ FileAccessInformation,
+ FileNameInformation,
+ FileRenameInformation,
+ FileLinkInformation,
+ FileNamesInformation,
+ FileDispositionInformation,
+ FilePositionInformation,
+ FileFullEaInformation,
+ FileModeInformation,
+ FileAlignmentInformation,
+ FileAllInformation,
+ FileAllocationInformation,
+ FileEndOfFileInformation,
+ FileAlternateNameInformation,
+ FileStreamInformation,
+ FilePipeInformation,
+ FilePipeLocalInformation,
+ FilePipeRemoteInformation,
+ FileMailslotQueryInformation,
+ FileMailslotSetInformation,
+ FileCompressionInformation,
+ FileCopyOnWriteInformation,
+ FileCompletionInformation,
+ FileMoveClusterInformation,
+ FileOleClassIdInformation,
+ FileOleStateBitsInformation,
+ FileNetworkOpenInformation,
+ FileObjectIdInformation,
+ FileOleAllInformation,
+ FileOleDirectoryInformation,
+ FileContentIndexInformation,
+ FileInheritContentIndexInformation,
+ FileOleInformation,
+ FileMaximumInformation
+} FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
+
+typedef enum _FSINFOCLASS
+{
+ FileFsVolumeInformation = 1,
+ FileFsLabelInformation,
+ FileFsSizeInformation,
+ FileFsDeviceInformation,
+ FileFsAttributeInformation,
+ FileFsControlInformation,
+ FileFsFullSizeInformation,
+ FileFsObjectIdInformation,
+ FileFsDriverPathInformation,
+ FileFsMaximumInformation
+} FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS;
diff --git a/rosapps/applications/net/tsclient/rdesktop/doc/AUTHORS b/rosapps/applications/net/tsclient/rdesktop/doc/AUTHORS
new file mode 100644
index 00000000000..a0824584e49
--- /dev/null
+++ b/rosapps/applications/net/tsclient/rdesktop/doc/AUTHORS
@@ -0,0 +1,14 @@
+This is an attempt at a list of people who have made significant
+contributions to the code. If you have been unintentionally omitted
+please let one of the team members know.
+
+Matt Chapman
+Peter Kallden
+Hugo Trippaers
+Jay Sorg
+Peter Åstrand
+Michal Mihalik
+Norbert Federa