ReactOS 0.4.15-dev-7788-g1ad9096
mstscax.cpp
Go to the documentation of this file.
1#include "stdafx.h"
2
3namespace
4{
5 using namespace MSTSCLib;
6
10
14
16
17 extern "C" char __ImageBase;
18 static const HMODULE hmSelf = reinterpret_cast<HMODULE>(&__ImageBase);
19
20 void init()
21 {
22 if(hmMstscax)
23 return;
24
25 TCHAR szFileName[MAX_PATH + 1];
26 GetModuleFileName(hmSelf, szFileName, MAX_PATH);
27
28 std::basic_string<TCHAR> strFileName(&szFileName[0]);
29 std::reverse_iterator<std::basic_string<TCHAR>::const_iterator > begin(strFileName.end());
30 std::reverse_iterator<std::basic_string<TCHAR>::const_iterator > end(strFileName.begin());
31 std::basic_string<TCHAR>::const_iterator endPath = std::find(begin, end, TEXT('\\')).base();
32
33 std::basic_string<TCHAR> strPath(strFileName.begin(), endPath);
34 strPath.append(TEXT("original\\mstscax.dll"));
35
36 hmMstscax = LoadLibrary(strPath.c_str());
40 }
41
43 {
44 TCHAR buf[0x1000];
45
48 StringCbVPrintf(buf, sizeof(buf), fmt, args);
49 va_end(args);
50
51 StringCbCat(buf, sizeof(buf), TEXT("\n"));
52
54 }
55
56#if 0
57 const IID MsTscAxIIDs[] =
58 {
61 //IID_IMsTscAxEvents,
64 };
65
66 const IID MsRdpClient[] =
67 {
70 //IID_IMsTscAxEvents,
73 };
74
75 const IID MsRdpClient2[] =
76 {
80 //IID_IMsTscAxEvents,
83 };
84
85 const IID MsRdpClient3[] =
86 {
91 //IID_IMsTscAxEvents,
94 };
95
96 const IID MsRdpClient4[] =
97 {
103 //IID_IMsTscAxEvents,
107 };
108#endif
109
110 std::wstring UUIDToString(const UUID& uuid)
111 {
112 std::wstring s;
115 s += str;
117 return s;
118 }
119
120 std::wstring MonikerToString(IMoniker * pmk)
121 {
122 LPOLESTR pszName = NULL;
123
124 if(SUCCEEDED(pmk->GetDisplayName(NULL, NULL, &pszName)))
125 {
126 std::wstring s(pszName);
127 CoTaskMemFree(pszName);
128 return s;
129 }
130 else
131 return std::wstring(L"<error>");
132 }
133
134 std::basic_string<TCHAR> RectToString(const RECT& rc)
135 {
136 if(&rc == NULL)
137 return TEXT("<null>");
138
139 std::basic_ostringstream<TCHAR> o;
140 o << "{" << " left:" << rc.left << " top:" << rc.top << " right:" << rc.right << " bottom:" << rc.bottom << " }";
141 return o.str();
142 }
143
144 std::basic_string<TCHAR> RectToString(const RECTL& rc)
145 {
146 if(&rc == NULL)
147 return TEXT("<null>");
148
149 std::basic_ostringstream<TCHAR> o;
150 o << "{" << " left:" << rc.left << " top:" << rc.top << " right:" << rc.right << " bottom:" << rc.bottom << " }";
151 return o.str();
152 }
153
154 std::basic_string<TCHAR> SizeToString(const SIZE& sz)
155 {
156 if(&sz == NULL)
157 return TEXT("<null>");
158
159 std::basic_ostringstream<TCHAR> o;
160 o << "{ " << " cx:" << sz.cx << " cy:" << sz.cy << " }";
161 return o.str();
162 }
163
164 template<class T> LPCTSTR BooleanToString(const T& X)
165 {
166 return X ? TEXT("true") : TEXT("false");
167 }
168
169 std::basic_string<TCHAR> VariantToString(const VARIANT& var)
170 {
171 std::basic_ostringstream<TCHAR> o;
172
173 switch(var.vt & VT_TYPEMASK)
174 {
175 case VT_EMPTY: o << "<empty>"; break;
176 case VT_NULL: o << "<null>"; break;
177 case VT_I2: o << "short"; break;
178 case VT_I4: o << "long"; break;
179 case VT_R4: o << "float"; break;
180 case VT_R8: o << "double"; break;
181 case VT_CY: o << "CURRENCY"; break;
182 case VT_DATE: o << "DATE"; break;
183 case VT_BSTR: o << "string"; break;
184 case VT_DISPATCH: o << "IDispatch *"; break;
185 case VT_ERROR: o << "SCODE"; break;
186 case VT_BOOL: o << "bool"; break;
187 case VT_VARIANT: o << "VARIANT *"; break;
188 case VT_UNKNOWN: o << "IUnknown *"; break;
189 case VT_DECIMAL: o << "DECIMAL"; break;
190 case VT_I1: o << "char"; break;
191 case VT_UI1: o << "unsigned char"; break;
192 case VT_UI2: o << "unsigned short"; break;
193 case VT_UI4: o << "unsigned long"; break;
194 case VT_I8: o << "long long"; break;
195 case VT_UI8: o << "unsigned long long"; break;
196 case VT_INT: o << "int"; break;
197 case VT_UINT: o << "unsigned int"; break;
198 case VT_VOID: o << "void"; break;
199 case VT_HRESULT: o << "HRESULT"; break;
200 case VT_PTR: o << "void *"; break;
201 case VT_SAFEARRAY: o << "SAFEARRAY *"; break;
202 case VT_LPSTR: o << "LPSTR"; break;
203 case VT_LPWSTR: o << "LPWSTR"; break;
204 case VT_RECORD: o << "struct { }"; break;
205 case VT_INT_PTR: o << "intptr_t"; break;
206 case VT_UINT_PTR: o << "uintptr_t"; break;
207 case VT_FILETIME: o << "FILETIME"; break;
208 default: o << "???"; break;
209 }
210
211 if(var.vt & VT_ARRAY)
212 o << "[]";
213 else if(var.vt & VT_BYREF)
214 o << " *";
215 else
216 {
217 switch(var.vt & VT_TYPEMASK)
218 {
219 case VT_EMPTY:
220 case VT_NULL:
221 case VT_RECORD:
222 case VT_VOID:
223
224 // TODO
225 case VT_CY:
226 case VT_DATE:
227 case VT_DECIMAL:
228 case VT_FILETIME:
229 break;
230
231 default:
232 o << " = ";
233 }
234
235 switch(var.vt & VT_TYPEMASK)
236 {
237 case VT_I2: o << var.iVal; break;
238 case VT_I4: o << var.lVal; break;
239 case VT_R4: o << var.fltVal; break;
240 case VT_R8: o << var.dblVal; break;
241 case VT_BSTR: o << std::wstring(var.bstrVal, var.bstrVal + SysStringLen(var.bstrVal)); break;
242 case VT_BOOL: o << var.boolVal ? "true" : "false"; break;
243 case VT_I1: o << int(var.cVal); break;
244 case VT_UI1: o << unsigned int(var.bVal); break;
245 case VT_UI2: o << var.uiVal; break;
246 case VT_UI4: o << var.ulVal; break;
247 case VT_I8: o << var.llVal; break;
248 case VT_UI8: o << var.ullVal; break;
249 case VT_INT: o << var.intVal; break;
250 case VT_UINT: o << var.uintVal; break;
251 case VT_LPSTR: o << LPSTR(var.byref); break;
252 case VT_LPWSTR: o << LPWSTR(var.byref); break;
253 case VT_INT_PTR: o << var.intVal; break; // BUGBUG
254 case VT_UINT_PTR: o << var.uintVal; break; // BUGBUG
255
256 case VT_DISPATCH:
257 case VT_VARIANT:
258 case VT_UNKNOWN:
259 case VT_PTR:
260 case VT_SAFEARRAY:
261 case VT_RECORD:
262 o << var.byref; break;
263
264 case VT_ERROR:
265 case VT_HRESULT:
266 o << std::hex << var.ulVal; break;
267
268 case VT_EMPTY:
269 case VT_NULL:
270 case VT_VOID:
271 break;
272
273 default:
274 assert(0);
275 }
276 }
277
278 return o.str();
279 }
280
281#pragma warning(disable:4584)
282
287
289 {
290 private:
293
294 public:
296 m_refCount(1),
297 m_IConnectionPointContainer(pIConnectionPointContainer)
298 { }
299
300 ~CConnectionPointContainer() { m_IConnectionPointContainer->Release(); }
301
303 {
304 HRESULT hr = S_OK;
305
306 dbgprintf(TEXT("CConnectionPointContainer::QueryInterface(%ls, %p)"), UUIDToString(riid).c_str(), ppvObject);
307
309 *ppvObject = this;
310 else
311 {
312 *ppvObject = NULL;
314 }
315
316 dbgprintf(TEXT("CConnectionPointContainer::QueryInterface -> %08X, ppvObject = %p"), hr, *ppvObject);
317 return hr;
318 }
319
321 {
322 return InterlockedIncrement(&m_refCount);
323 }
324
326 {
327 LONG n = InterlockedDecrement(&m_refCount);
328
329 if(n == 0)
330 delete this;
331
332 return n;
333 }
334
336 {
337 dbgprintf(TEXT("CConnectionPointContainer::EnumConnectionPoints(%p)"), ppEnum);
338 HRESULT hr = m_IConnectionPointContainer->EnumConnectionPoints(ppEnum);
339 dbgprintf(TEXT("CConnectionPointContainer::EnumConnectionPoints -> %08X, pEnum = %p"), hr, *ppEnum);
340
341 if(SUCCEEDED(hr))
342 *ppEnum = HookIEnumConnectionPoints(*ppEnum);
343
344 return hr;
345 }
346
348 {
349 dbgprintf(TEXT("CConnectionPointContainer::FindConnectionPoint(%ls, %p)"), UUIDToString(riid).c_str(), ppCP);
350 HRESULT hr = m_IConnectionPointContainer->FindConnectionPoint(riid, ppCP);
351 dbgprintf(TEXT("CConnectionPointContainer::FindConnectionPoint -> %08X, pCP = %p"), hr, *ppCP);
352
353 if(SUCCEEDED(hr))
354 *ppCP = HookIConnectionPoint(*ppCP);
355
356 return hr;
357 }
358 };
359
361 {
362 private:
365
366 public:
368 m_refCount(1),
369 m_IEnumConnectionPoints(pIEnumConnectionPoints)
370 { }
371
372 ~CEnumConnectionPoints() { m_IEnumConnectionPoints->Release(); }
373
375 {
376 HRESULT hr = S_OK;
377
378 dbgprintf(TEXT("CEnumConnectionPoints::QueryInterface(%ls, %p)"), UUIDToString(riid).c_str(), ppvObject);
379
381 *ppvObject = this;
382 else
383 {
384 *ppvObject = NULL;
386 }
387
388 dbgprintf(TEXT("CEnumConnectionPoints::QueryInterface -> %08X, ppvObject = %p"), hr, *ppvObject);
389 return hr;
390 }
391
393 {
394 return InterlockedIncrement(&m_refCount);
395 }
396
398 {
399 LONG n = InterlockedDecrement(&m_refCount);
400
401 if(n == 0)
402 delete this;
403
404 return n;
405 }
406
407 virtual HRESULT STDMETHODCALLTYPE Next(ULONG cConnections, LPCONNECTIONPOINT * ppCP, ULONG * pcFetched)
408 {
409 dbgprintf(TEXT("CEnumConnectionPoints::Next(%lu, %p, %p)"), cConnections, ppCP, pcFetched);
410 HRESULT hr = m_IEnumConnectionPoints->Next(cConnections, ppCP, pcFetched);
411 dbgprintf(TEXT("CEnumConnectionPoints:: -> %08X, pCP = %p, cFetched = %lu"), hr, *ppCP, *pcFetched);
412
413 if(SUCCEEDED(hr))
414 *ppCP = HookIConnectionPoint(*ppCP);
415
416 return hr;
417 }
418
419 virtual HRESULT STDMETHODCALLTYPE Skip(ULONG cConnections)
420 {
421 dbgprintf(TEXT("CEnumConnectionPoints::Skip(%lu)"), cConnections);
422 HRESULT hr = m_IEnumConnectionPoints->Skip(cConnections);
423 dbgprintf(TEXT("CEnumConnectionPoints:: -> %08X"), hr);
424 return hr;
425 }
426
428 {
429 dbgprintf(TEXT("CEnumConnectionPoints::Reset()"));
430 HRESULT hr = m_IEnumConnectionPoints->Reset();
431 dbgprintf(TEXT("CEnumConnectionPoints:: -> %08X"), hr);
432 return hr;
433 }
434
436 {
437 dbgprintf(TEXT("CEnumConnectionPoints::Clone(%p)"), ppEnum);
438 HRESULT hr = m_IEnumConnectionPoints->Clone(ppEnum);
439 dbgprintf(TEXT("CEnumConnectionPoints:: -> %08X, pEnum"), hr, *ppEnum);
440
441 if(SUCCEEDED(hr))
442 *ppEnum = HookIEnumConnectionPoints(*ppEnum);
443
444 return hr;
445 }
446 };
447
449 {
450 private:
453
454 public:
455 CConnectionPoint(IConnectionPoint * pIConnectionPoint):
456 m_refCount(1),
457 m_IConnectionPoint(pIConnectionPoint)
458 { }
459
460 ~CConnectionPoint() { m_IConnectionPoint->Release(); }
461
463 {
464 HRESULT hr = S_OK;
465
466 dbgprintf(TEXT("CConnectionPoint::QueryInterface(%ls, %p)"), UUIDToString(riid).c_str(), ppvObject);
467
469 *ppvObject = this;
470 else
471 {
472 *ppvObject = NULL;
474 }
475
476 dbgprintf(TEXT("CConnectionPoint::QueryInterface -> %08X, ppvObject = %p"), hr, *ppvObject);
477 return hr;
478 }
479
481 {
482 return InterlockedIncrement(&m_refCount);
483 }
484
486 {
487 LONG n = InterlockedDecrement(&m_refCount);
488
489 if(n == 0)
490 delete this;
491
492 return n;
493 }
494
496 {
497 dbgprintf(TEXT("CConnectionPoint::GetConnectionInterface(%p)"), pIID);
498 HRESULT hr = m_IConnectionPoint->GetConnectionInterface(pIID);
499 dbgprintf(TEXT("CConnectionPoint::GetConnectionInterface -> %08X, IID = %ls"), hr, UUIDToString(*pIID).c_str());
500 return hr;
501 }
502
504 {
505 dbgprintf(TEXT("CConnectionPoint::GetConnectionPointContainer(%p)"), ppCPC);
506 HRESULT hr = m_IConnectionPoint->GetConnectionPointContainer(ppCPC);
507 dbgprintf(TEXT("CConnectionPoint::GetConnectionPointContainer -> %08X, pCPC = %p"), hr, *ppCPC);
508
509 if(SUCCEEDED(hr))
510 *ppCPC = HookIConnectionPointContainer(*ppCPC);
511
512 return hr;
513 }
514
515 virtual HRESULT STDMETHODCALLTYPE Advise(IUnknown * pUnkSink, DWORD * pdwCookie)
516 {
517 dbgprintf(TEXT("CConnectionPoint::Advise(%p, %p)"), pUnkSink, pdwCookie);
518 HRESULT hr = m_IConnectionPoint->Advise(pUnkSink, pdwCookie);
519 dbgprintf(TEXT("CConnectionPoint::Advise -> %08X, dwCookie = %lu"), hr, *pdwCookie);
520 // TODO: hook sink
521 return hr;
522 }
523
525 {
526 dbgprintf(TEXT("CConnectionPoint::Unadvise(%lu)"), dwCookie);
527 HRESULT hr = m_IConnectionPoint->Unadvise(dwCookie);
528 dbgprintf(TEXT("CConnectionPoint::Unadvise -> %08X"), hr);
529 return hr;
530 }
531
533 {
534 dbgprintf(TEXT("CConnectionPoint::EnumConnections(%p)"), ppEnum);
535 HRESULT hr = m_IConnectionPoint->EnumConnections(ppEnum);
536 dbgprintf(TEXT("CConnectionPoint::EnumConnections -> %08X, pEnum = %p"), hr, *ppEnum);
537
538 if(SUCCEEDED(hr))
539 *ppEnum = HookIEnumConnections(*ppEnum);
540
541 return hr;
542 }
543 };
544
546 {
547 private:
550
551 public:
552 CEnumConnections(IEnumConnections * pIEnumConnections):
553 m_refCount(1),
554 m_IEnumConnections(pIEnumConnections)
555 { }
556
557 ~CEnumConnections() { m_IEnumConnections->Release(); }
558
560 {
561 HRESULT hr = S_OK;
562
563 dbgprintf(TEXT("CEnumConnections::QueryInterface(%ls, %p)"), UUIDToString(riid).c_str(), ppvObject);
564
566 *ppvObject = this;
567 else
568 {
569 *ppvObject = NULL;
571 }
572
573 dbgprintf(TEXT("CEnumConnections::QueryInterface -> %08X, ppvObject = %p"), hr, *ppvObject);
574 return hr;
575 }
576
578 {
579 return InterlockedIncrement(&m_refCount);
580 }
581
583 {
584 LONG n = InterlockedDecrement(&m_refCount);
585
586 if(n == 0)
587 delete this;
588
589 return n;
590 }
591
592 virtual HRESULT STDMETHODCALLTYPE Next(ULONG cConnections, LPCONNECTDATA pCD, ULONG * pcFetched)
593 {
594 dbgprintf(TEXT("CEnumConnections::Next(%lu, %p, %p)"), cConnections, pCD, pcFetched);
595 HRESULT hr = m_IEnumConnections->Next(cConnections, pCD, pcFetched);
596 dbgprintf(TEXT("CEnumConnections:: -> %08X, CD = { pUnk = %p, dwCookie = %lu }, cFetched = %lu"), hr, pCD->pUnk, pCD->dwCookie, *pcFetched);
597 return hr;
598 }
599
600 virtual HRESULT STDMETHODCALLTYPE Skip(ULONG cConnections)
601 {
602 dbgprintf(TEXT("CEnumConnections::Skip(%lu)"), cConnections);
603 HRESULT hr = m_IEnumConnections->Skip(cConnections);
604 dbgprintf(TEXT("CEnumConnections:: -> %08X"), hr);
605 return hr;
606 }
607
609 {
610 dbgprintf(TEXT("CEnumConnections::Reset()"));
611 HRESULT hr = m_IEnumConnections->Reset();
612 dbgprintf(TEXT("CEnumConnections:: -> %08X"), hr);
613 return hr;
614 }
615
617 {
618 dbgprintf(TEXT("CEnumConnections::Clone(%p)"), ppEnum);
619 HRESULT hr = m_IEnumConnections->Clone(ppEnum);
620 dbgprintf(TEXT("CEnumConnections:: -> %08X, pEnum"), hr, *ppEnum);
621
622 if(SUCCEEDED(hr))
623 *ppEnum = HookIEnumConnections(*ppEnum);
624
625 return hr;
626 }
627 };
628
630 {
631 return new CConnectionPointContainer(p);
632 }
633
635 {
636 return new CEnumConnectionPoints(p);
637 }
638
640 {
641 return new CConnectionPoint(p);
642 }
643
645 {
646 return new CEnumConnections(p);
647 }
648
650 {
651 private:
660
662 {
663 assert(m_IDispatch);
664 return m_IDispatch;
665 }
666
668 {
669 if(m_IMsTscAdvancedSettings)
670 return m_IMsTscAdvancedSettings;
671 else if(m_IMsRdpClientAdvancedSettings)
672 m_IMsTscAdvancedSettings = m_IMsRdpClientAdvancedSettings;
673 else if(m_IMsRdpClientAdvancedSettings2)
674 m_IMsTscAdvancedSettings = m_IMsRdpClientAdvancedSettings2;
675 else if(m_IMsRdpClientAdvancedSettings3)
676 m_IMsTscAdvancedSettings = m_IMsRdpClientAdvancedSettings3;
677 else if(m_IMsRdpClientAdvancedSettings4)
678 m_IMsTscAdvancedSettings = m_IMsRdpClientAdvancedSettings4;
679
680 if(m_IMsTscAdvancedSettings)
681 {
682 m_IMsTscAdvancedSettings->AddRef();
683 return m_IMsTscAdvancedSettings;
684 }
685
686 m_IUnknown->QueryInterface(&m_IMsTscAdvancedSettings);
687 return m_IMsTscAdvancedSettings;
688 }
689
691 {
692 if(m_IMsRdpClientAdvancedSettings)
693 return m_IMsRdpClientAdvancedSettings;
694 else if(m_IMsRdpClientAdvancedSettings2)
695 m_IMsRdpClientAdvancedSettings = m_IMsRdpClientAdvancedSettings2;
696 else if(m_IMsRdpClientAdvancedSettings3)
697 m_IMsRdpClientAdvancedSettings = m_IMsRdpClientAdvancedSettings3;
698 else if(m_IMsRdpClientAdvancedSettings4)
699 m_IMsRdpClientAdvancedSettings = m_IMsRdpClientAdvancedSettings4;
700
701 if(m_IMsRdpClientAdvancedSettings)
702 {
703 m_IMsRdpClientAdvancedSettings->AddRef();
704 return m_IMsRdpClientAdvancedSettings;
705 }
706
707 m_IUnknown->QueryInterface(&m_IMsRdpClientAdvancedSettings);
708 return m_IMsRdpClientAdvancedSettings;
709 }
710
712 {
713 if(m_IMsRdpClientAdvancedSettings2)
714 return m_IMsRdpClientAdvancedSettings2;
715 else if(m_IMsRdpClientAdvancedSettings3)
716 m_IMsRdpClientAdvancedSettings2 = m_IMsRdpClientAdvancedSettings3;
717 else if(m_IMsRdpClientAdvancedSettings4)
718 m_IMsRdpClientAdvancedSettings2 = m_IMsRdpClientAdvancedSettings4;
719
720 if(m_IMsRdpClientAdvancedSettings2)
721 {
722 m_IMsRdpClientAdvancedSettings2->AddRef();
723 return m_IMsRdpClientAdvancedSettings2;
724 }
725
726 m_IUnknown->QueryInterface(&m_IMsRdpClientAdvancedSettings2);
727 return m_IMsRdpClientAdvancedSettings2;
728 }
729
731 {
732 if(m_IMsRdpClientAdvancedSettings3)
733 return m_IMsRdpClientAdvancedSettings3;
734 else if(m_IMsRdpClientAdvancedSettings4)
735 m_IMsRdpClientAdvancedSettings3 = m_IMsRdpClientAdvancedSettings4;
736
737 if(m_IMsRdpClientAdvancedSettings3)
738 {
739 m_IMsRdpClientAdvancedSettings3->AddRef();
740 return m_IMsRdpClientAdvancedSettings3;
741 }
742
743 m_IUnknown->QueryInterface(&m_IMsRdpClientAdvancedSettings3);
744 return m_IMsRdpClientAdvancedSettings3;
745 }
746
748 {
749 if(m_IMsRdpClientAdvancedSettings4)
750 return m_IMsRdpClientAdvancedSettings4;
751
752 if(m_IMsRdpClientAdvancedSettings4)
753 {
754 m_IMsRdpClientAdvancedSettings4->AddRef();
755 return m_IMsRdpClientAdvancedSettings4;
756 }
757
758 m_IUnknown->QueryInterface(&m_IMsRdpClientAdvancedSettings4);
759 return m_IMsRdpClientAdvancedSettings4;
760 }
761
763 {
764 m_IUnknown->Release();
765 m_IDispatch->Release();
766
767 if(m_IMsTscAdvancedSettings)
768 m_IMsTscAdvancedSettings->Release();
769
770 if(m_IMsRdpClientAdvancedSettings)
771 m_IMsRdpClientAdvancedSettings->Release();
772
773 if(m_IMsRdpClientAdvancedSettings2)
774 m_IMsRdpClientAdvancedSettings2->Release();
775
776 if(m_IMsRdpClientAdvancedSettings3)
777 m_IMsRdpClientAdvancedSettings3->Release();
778
779 if(m_IMsRdpClientAdvancedSettings4)
780 m_IMsRdpClientAdvancedSettings4->Release();
781 }
782
784 {
785 m_IMsTscAdvancedSettings = p;
786 }
787
789 {
790 m_IMsRdpClientAdvancedSettings = p;
791 }
792
794 {
795 m_IMsRdpClientAdvancedSettings2 = p;
796 }
797
799 {
800 m_IMsRdpClientAdvancedSettings3 = p;
801 }
802
804 {
805 m_IMsRdpClientAdvancedSettings4 = p;
806 }
807
808 public:
809 template<class Interface> CAdvancedSettings(Interface * p):
810 m_refCount(1),
811 m_IUnknown(p),
812 m_IDispatch(p),
813 m_IMsTscAdvancedSettings(NULL),
814 m_IMsRdpClientAdvancedSettings(NULL),
815 m_IMsRdpClientAdvancedSettings2(NULL),
816 m_IMsRdpClientAdvancedSettings3(NULL),
817 m_IMsRdpClientAdvancedSettings4(NULL)
818 {
819 assert(p);
820 p->AddRef();
821 p->AddRef();
822 Init(p);
823 }
824
825 /* IUnknown */
827 {
828 HRESULT hr;
829 IUnknown * pvObject;
830
831 dbgprintf(TEXT("CAdvancedSettings::QueryInterface(%ls, %p)"), UUIDToString(riid).c_str(), ppvObject);
832
833#define QIBEGIN() \
834 if(riid == IID_IUnknown) \
835 { \
836 hr = S_OK; \
837 pvObject = (IUnknown *)(this); \
838 }
839
840#define QI(I) \
841 else if(riid == IID_ ## I) \
842 { \
843 if(m_ ## I) \
844 { \
845 m_ ## I->AddRef(); \
846 hr = S_OK; \
847 } \
848 else \
849 { \
850 hr = m_IUnknown->QueryInterface(&m_ ## I); \
851 } \
852 \
853 if(SUCCEEDED(hr)) \
854 pvObject = static_cast<I *>(this); \
855 }
856
857#define QIEND() \
858 else \
859 { \
860 hr = E_NOINTERFACE; \
861 pvObject = NULL; \
862 }
863
864 QIBEGIN()
871 QIEND()
872
873#undef QIBEGIN
874#undef QIEND
875#undef QI
876
877 if(SUCCEEDED(hr))
878 {
879 assert(pvObject);
880 pvObject->AddRef();
881 }
882 else
883 {
884 assert(pvObject == NULL);
885 }
886
887 *ppvObject = pvObject;
888
889 dbgprintf(TEXT("CAdvancedSettings::QueryInterface -> %08X, ppvObject = %p"), hr, *ppvObject);
890 return hr;
891 }
892
894 {
895 return InterlockedIncrement(&m_refCount);
896 }
897
899 {
900 LONG n = InterlockedDecrement(&m_refCount);
901
902 if(n == 0)
903 delete this;
904
905 return n;
906 }
907
908 /* IDispatch */
909 /*
910 * p = get();
911 dbgprintf(TEXT("CAdvancedSettings::()"), );
912 HRESULT hr = p->();
913 dbgprintf(TEXT("CAdvancedSettings:: -> %08X, "), hr, );
914 return hr;
915 */
917 {
918 IDispatch * pIDispatch = getIDispatch();
919 dbgprintf(TEXT("CAdvancedSettings::GetTypeInfoCount(%p)"), pctinfo);
920 HRESULT hr = pIDispatch->GetTypeInfoCount(pctinfo);
921 dbgprintf(TEXT("CAdvancedSettings::GetTypeInfoCount -> %08X, ctinfo = %u"), hr, *pctinfo);
922 return hr;
923 }
924
925 virtual STDMETHODIMP IDispatch::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo ** ppTInfo)
926 {
927 IDispatch * pIDispatch = getIDispatch();
928 dbgprintf(TEXT("CAdvancedSettings::GetTypeInfo(%u, %lu, %p)"), iTInfo, lcid, ppTInfo);
929 HRESULT hr = pIDispatch->GetTypeInfo(iTInfo, lcid, ppTInfo);
930 dbgprintf(TEXT("CAdvancedSettings::GetTypeInfo -> %08X, pTInfo = %p"), hr, *ppTInfo);
931 return hr;
932 }
933
934 virtual STDMETHODIMP IDispatch::GetIDsOfNames(REFIID riid, LPOLESTR * rgszNames, UINT cNames, LCID lcid, DISPID * rgDispId)
935 {
936 IDispatch * pIDispatch = getIDispatch();
937 dbgprintf(TEXT("CAdvancedSettings::GetIDsOfNames(%ls, %ls, %d, %lu, %p)"), UUIDToString(riid).c_str(), *rgszNames, cNames, lcid, rgDispId);
938 HRESULT hr = pIDispatch->GetIDsOfNames(riid, rgszNames, cNames, lcid, rgDispId);
939 dbgprintf(TEXT("CAdvancedSettings::GetIDsOfNames -> %08X, rgDispId = %ld"), hr, *rgDispId);
940 return hr;
941 }
942
943 virtual STDMETHODIMP IDispatch::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pDispParams, VARIANT * pVarResult, EXCEPINFO * pExcepInfo, UINT * puArgErr)
944 {
945 // TODO
946 IDispatch * pIDispatch = getIDispatch();
947 dbgprintf(TEXT("CAdvancedSettings::Invoke()")/*, */);
948 HRESULT hr = pIDispatch->Invoke(dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
949 dbgprintf(TEXT("CAdvancedSettings::Invoke -> %08X, "), hr/*, */);
950 return hr;
951 }
952
953 /* IMsTscAdvancedSettings */
954 virtual STDMETHODIMP IMsTscAdvancedSettings::put_Compress(long pcompress)
955 {
956 IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings();
957 dbgprintf(TEXT("CAdvancedSettings::put_Compress(%ld)"), pcompress);
958 HRESULT hr = pIMsTscAdvancedSettings->put_Compress(pcompress);
959 dbgprintf(TEXT("CAdvancedSettings::put_Compress -> %08X"), hr);
960 return hr;
961 }
962
963 virtual STDMETHODIMP IMsTscAdvancedSettings::get_Compress(long * pcompress)
964 {
965 IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings();
966 dbgprintf(TEXT("CAdvancedSettings::get_Compress(%p)"), pcompress);
967 HRESULT hr = pIMsTscAdvancedSettings->get_Compress(pcompress);
968 dbgprintf(TEXT("CAdvancedSettings::get_Compress -> %08X, compress = %ld"), hr, *pcompress);
969 return hr;
970 }
971
972 virtual STDMETHODIMP IMsTscAdvancedSettings::put_BitmapPeristence(long pbitmapPeristence)
973 {
974 IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings();
975 dbgprintf(TEXT("CAdvancedSettings::put_BitmapPeristence(%ld)"), pbitmapPeristence);
976 HRESULT hr = pIMsTscAdvancedSettings->put_BitmapPeristence(pbitmapPeristence);
977 dbgprintf(TEXT("CAdvancedSettings::put_BitmapPeristence -> %08X"), hr);
978 return hr;
979 }
980
981 virtual STDMETHODIMP IMsTscAdvancedSettings::get_BitmapPeristence(long * pbitmapPeristence)
982 {
983 IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings();
984 dbgprintf(TEXT("CAdvancedSettings::get_BitmapPeristence(%p)"), pbitmapPeristence);
985 HRESULT hr = pIMsTscAdvancedSettings->get_BitmapPeristence(pbitmapPeristence);
986 dbgprintf(TEXT("CAdvancedSettings::get_BitmapPeristence -> %08X, bitmapPeristence = %ld"), hr, *pbitmapPeristence);
987 return hr;
988 }
989
990 virtual STDMETHODIMP IMsTscAdvancedSettings::put_allowBackgroundInput(long pallowBackgroundInput)
991 {
992 IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings();
993 dbgprintf(TEXT("CAdvancedSettings::put_allowBackgroundInput(%ld)"), pallowBackgroundInput);
994 HRESULT hr = pIMsTscAdvancedSettings->put_allowBackgroundInput(pallowBackgroundInput);
995 dbgprintf(TEXT("CAdvancedSettings::put_allowBackgroundInput -> %08X"), hr);
996 return hr;
997 }
998
999 virtual STDMETHODIMP IMsTscAdvancedSettings::get_allowBackgroundInput(long * pallowBackgroundInput)
1000 {
1001 IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings();
1002 dbgprintf(TEXT("CAdvancedSettings::get_allowBackgroundInput(%p)"), pallowBackgroundInput);
1003 HRESULT hr = pIMsTscAdvancedSettings->get_allowBackgroundInput(pallowBackgroundInput);
1004 dbgprintf(TEXT("CAdvancedSettings::get_allowBackgroundInput -> %08X, allowBackgroundInput = %ld"), hr, *pallowBackgroundInput);
1005 return hr;
1006 }
1007
1008 virtual STDMETHODIMP IMsTscAdvancedSettings::put_KeyBoardLayoutStr(BSTR rhs)
1009 {
1010 IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings();
1011 dbgprintf(TEXT("CAdvancedSettings::put_KeyBoardLayoutStr(%ls)"), rhs);
1012 HRESULT hr = pIMsTscAdvancedSettings->put_KeyBoardLayoutStr(rhs);
1013 dbgprintf(TEXT("CAdvancedSettings::put_KeyBoardLayoutStr -> %08X"), hr);
1014 return hr;
1015 }
1016
1017 virtual STDMETHODIMP IMsTscAdvancedSettings::put_PluginDlls(BSTR rhs)
1018 {
1019 IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings();
1020 dbgprintf(TEXT("CAdvancedSettings::put_PluginDlls(%ls)"), rhs);
1021 HRESULT hr = pIMsTscAdvancedSettings->put_PluginDlls(rhs);
1022 dbgprintf(TEXT("CAdvancedSettings::put_PluginDlls -> %08X"), hr);
1023 return hr;
1024 }
1025
1026 virtual STDMETHODIMP IMsTscAdvancedSettings::put_IconFile(BSTR rhs)
1027 {
1028 IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings();
1029 dbgprintf(TEXT("CAdvancedSettings::put_IconFile(%ls)"), rhs);
1030 HRESULT hr = pIMsTscAdvancedSettings->put_IconFile(rhs);
1031 dbgprintf(TEXT("CAdvancedSettings::put_IconFile -> %08X"), hr);
1032 return hr;
1033 }
1034
1035 virtual STDMETHODIMP IMsTscAdvancedSettings::put_IconIndex(long rhs)
1036 {
1037 IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings();
1038 dbgprintf(TEXT("CAdvancedSettings::put_IconIndex(%ld)"), rhs);
1039 HRESULT hr = pIMsTscAdvancedSettings->put_IconIndex(rhs);
1040 dbgprintf(TEXT("CAdvancedSettings::put_IconIndex -> %08X"), hr);
1041 return hr;
1042 }
1043
1044 virtual STDMETHODIMP IMsTscAdvancedSettings::put_ContainerHandledFullScreen(long pContainerHandledFullScreen)
1045 {
1046 IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings();
1047 dbgprintf(TEXT("CAdvancedSettings::put_ContainerHandledFullScreen(%ld)"), pContainerHandledFullScreen);
1048 HRESULT hr = pIMsTscAdvancedSettings->put_ContainerHandledFullScreen(pContainerHandledFullScreen);
1049 dbgprintf(TEXT("CAdvancedSettings::put_ContainerHandledFullScreen -> %08X"), hr);
1050 return hr;
1051 }
1052
1053 virtual STDMETHODIMP IMsTscAdvancedSettings::get_ContainerHandledFullScreen(long * pContainerHandledFullScreen)
1054 {
1055 IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings();
1056 dbgprintf(TEXT("CAdvancedSettings::get_ContainerHandledFullScreen(%p)"), pContainerHandledFullScreen);
1057 HRESULT hr = pIMsTscAdvancedSettings->get_ContainerHandledFullScreen(pContainerHandledFullScreen);
1058 dbgprintf(TEXT("CAdvancedSettings::get_ContainerHandledFullScreen -> %08X, ContainerHandledFullScreen = %ld"), hr, *pContainerHandledFullScreen);
1059 return hr;
1060 }
1061
1062 virtual STDMETHODIMP IMsTscAdvancedSettings::put_DisableRdpdr(long pDisableRdpdr)
1063 {
1064 IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings();
1065 dbgprintf(TEXT("CAdvancedSettings::put_DisableRdpdr(%ld)"), pDisableRdpdr);
1066 HRESULT hr = pIMsTscAdvancedSettings->put_DisableRdpdr(pDisableRdpdr);
1067 dbgprintf(TEXT("CAdvancedSettings::put_DisableRdpdr -> %08X"), hr);
1068 return hr;
1069 }
1070
1071 virtual STDMETHODIMP IMsTscAdvancedSettings::get_DisableRdpdr(long * pDisableRdpdr)
1072 {
1073 IMsTscAdvancedSettings * pIMsTscAdvancedSettings = getIMsTscAdvancedSettings();
1074 dbgprintf(TEXT("CAdvancedSettings::get_DisableRdpdr(%p)"), pDisableRdpdr);
1075 HRESULT hr = pIMsTscAdvancedSettings->get_DisableRdpdr(pDisableRdpdr);
1076 dbgprintf(TEXT("CAdvancedSettings::get_DisableRdpdr -> %08X, DisableRdpdr = %ld"), hr, *pDisableRdpdr);
1077 return hr;
1078 }
1079
1080 /* IMsRdpClientAdvancedSettings */
1081 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_SmoothScroll(long psmoothScroll)
1082 {
1083 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1084 dbgprintf(TEXT("CAdvancedSettings::put_SmoothScroll(%ld)"), psmoothScroll);
1085 HRESULT hr = pIMsRdpClientAdvancedSettings->put_SmoothScroll(psmoothScroll);
1086 dbgprintf(TEXT("CAdvancedSettings::put_SmoothScroll -> %08X"), hr);
1087 return hr;
1088 }
1089
1090 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_SmoothScroll(long * psmoothScroll)
1091 {
1092 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1093 dbgprintf(TEXT("CAdvancedSettings::get_SmoothScroll(%p)"), psmoothScroll);
1094 HRESULT hr = pIMsRdpClientAdvancedSettings->get_SmoothScroll(psmoothScroll);
1095 dbgprintf(TEXT("CAdvancedSettings::get_SmoothScroll -> %08X, smoothScroll = %ld"), hr, *psmoothScroll);
1096 return hr;
1097 }
1098
1099 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_AcceleratorPassthrough(long pacceleratorPassthrough)
1100 {
1101 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1102 dbgprintf(TEXT("CAdvancedSettings::put_AcceleratorPassthrough(%ld)"), pacceleratorPassthrough);
1103 HRESULT hr = pIMsRdpClientAdvancedSettings->put_AcceleratorPassthrough(pacceleratorPassthrough);
1104 dbgprintf(TEXT("CAdvancedSettings::put_AcceleratorPassthrough -> %08X"), hr);
1105 return hr;
1106 }
1107
1108 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_AcceleratorPassthrough(long * pacceleratorPassthrough)
1109 {
1110 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1111 dbgprintf(TEXT("CAdvancedSettings::get_AcceleratorPassthrough(%p)"), pacceleratorPassthrough);
1112 HRESULT hr = pIMsRdpClientAdvancedSettings->get_AcceleratorPassthrough(pacceleratorPassthrough);
1113 dbgprintf(TEXT("CAdvancedSettings::get_AcceleratorPassthrough -> %08X, acceleratorPassthrough = %ld"), hr, *pacceleratorPassthrough);
1114 return hr;
1115 }
1116
1117 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ShadowBitmap(long pshadowBitmap)
1118 {
1119 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1120 dbgprintf(TEXT("CAdvancedSettings::put_ShadowBitmap(%ld)"), pshadowBitmap);
1121 HRESULT hr = pIMsRdpClientAdvancedSettings->put_ShadowBitmap(pshadowBitmap);
1122 dbgprintf(TEXT("CAdvancedSettings::put_ShadowBitmap -> %08X"), hr);
1123 return hr;
1124 }
1125
1126 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_ShadowBitmap(long * pshadowBitmap)
1127 {
1128 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1129 dbgprintf(TEXT("CAdvancedSettings::get_ShadowBitmap(%p)"), pshadowBitmap);
1130 HRESULT hr = pIMsRdpClientAdvancedSettings->get_ShadowBitmap(pshadowBitmap);
1131 dbgprintf(TEXT("CAdvancedSettings::get_ShadowBitmap -> %08X, shadowBitmap = %ld"), hr, *pshadowBitmap);
1132 return hr;
1133 }
1134
1135 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_TransportType(long ptransportType)
1136 {
1137 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1138 dbgprintf(TEXT("CAdvancedSettings::put_TransportType(%ld)"), ptransportType);
1139 HRESULT hr = pIMsRdpClientAdvancedSettings->put_TransportType(ptransportType);
1140 dbgprintf(TEXT("CAdvancedSettings::put_TransportType -> %08X"), hr);
1141 return hr;
1142 }
1143
1144 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_TransportType(long * ptransportType)
1145 {
1146 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1147 dbgprintf(TEXT("CAdvancedSettings::get_TransportType(%p)"), ptransportType);
1148 HRESULT hr = pIMsRdpClientAdvancedSettings->get_TransportType(ptransportType);
1149 dbgprintf(TEXT("CAdvancedSettings::get_TransportType -> %08X, transportType = %ld"), hr, *ptransportType);
1150 return hr;
1151 }
1152
1153 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_SasSequence(long psasSequence)
1154 {
1155 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1156 dbgprintf(TEXT("CAdvancedSettings::put_SasSequence(%ld)"), psasSequence);
1157 HRESULT hr = pIMsRdpClientAdvancedSettings->put_SasSequence(psasSequence);
1158 dbgprintf(TEXT("CAdvancedSettings::put_SasSequence -> %08X"), hr);
1159 return hr;
1160 }
1161
1162 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_SasSequence(long * psasSequence)
1163 {
1164 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1165 dbgprintf(TEXT("CAdvancedSettings::get_SasSequence(%p)"), psasSequence);
1166 HRESULT hr = pIMsRdpClientAdvancedSettings->get_SasSequence(psasSequence);
1167 dbgprintf(TEXT("CAdvancedSettings::get_SasSequence -> %08X, sasSequence = %ld"), hr, *psasSequence);
1168 return hr;
1169 }
1170
1171 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_EncryptionEnabled(long pencryptionEnabled)
1172 {
1173 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1174 dbgprintf(TEXT("CAdvancedSettings::put_EncryptionEnabled(%ld)"), pencryptionEnabled);
1175 HRESULT hr = pIMsRdpClientAdvancedSettings->put_EncryptionEnabled(pencryptionEnabled);
1176 dbgprintf(TEXT("CAdvancedSettings::put_EncryptionEnabled -> %08X"), hr);
1177 return hr;
1178 }
1179
1180 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_EncryptionEnabled(long * pencryptionEnabled)
1181 {
1182 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1183 dbgprintf(TEXT("CAdvancedSettings::get_EncryptionEnabled(%p)"), pencryptionEnabled);
1184 HRESULT hr = pIMsRdpClientAdvancedSettings->get_EncryptionEnabled(pencryptionEnabled);
1185 dbgprintf(TEXT("CAdvancedSettings::get_EncryptionEnabled -> %08X, encryptionEnabled = %ld"), hr, *pencryptionEnabled);
1186 return hr;
1187 }
1188
1189 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_DedicatedTerminal(long pdedicatedTerminal)
1190 {
1191 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1192 dbgprintf(TEXT("CAdvancedSettings::put_DedicatedTerminal(%ld)"), pdedicatedTerminal);
1193 HRESULT hr = pIMsRdpClientAdvancedSettings->put_DedicatedTerminal(pdedicatedTerminal);
1194 dbgprintf(TEXT("CAdvancedSettings::put_DedicatedTerminal -> %08X"), hr);
1195 return hr;
1196 }
1197
1198 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_DedicatedTerminal(long * pdedicatedTerminal)
1199 {
1200 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1201 dbgprintf(TEXT("CAdvancedSettings::get_DedicatedTerminal(%p)"), pdedicatedTerminal);
1202 HRESULT hr = pIMsRdpClientAdvancedSettings->get_DedicatedTerminal(pdedicatedTerminal);
1203 dbgprintf(TEXT("CAdvancedSettings::get_DedicatedTerminal -> %08X, dedicatedTerminal = %ld"), hr, *pdedicatedTerminal);
1204 return hr;
1205 }
1206
1207 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RDPPort(long prdpPort)
1208 {
1209 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1210 dbgprintf(TEXT("CAdvancedSettings::put_RDPPort(%ld)"), prdpPort);
1211 HRESULT hr = pIMsRdpClientAdvancedSettings->put_RDPPort(prdpPort);
1212 dbgprintf(TEXT("CAdvancedSettings::put_RDPPort -> %08X"), hr);
1213 return hr;
1214 }
1215
1216 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RDPPort(long * prdpPort)
1217 {
1218 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1219 dbgprintf(TEXT("CAdvancedSettings::get_RDPPort(%p)"), prdpPort);
1220 HRESULT hr = pIMsRdpClientAdvancedSettings->get_RDPPort(prdpPort);
1221 dbgprintf(TEXT("CAdvancedSettings::get_RDPPort -> %08X, rdpPort = %ld"), hr, *prdpPort);
1222 return hr;
1223 }
1224
1225 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_EnableMouse(long penableMouse)
1226 {
1227 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1228 dbgprintf(TEXT("CAdvancedSettings::put_EnableMouse(%ld)"), penableMouse);
1229 HRESULT hr = pIMsRdpClientAdvancedSettings->put_EnableMouse(penableMouse);
1230 dbgprintf(TEXT("CAdvancedSettings::put_EnableMouse -> %08X"), hr);
1231 return hr;
1232 }
1233
1234 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_EnableMouse(long * penableMouse)
1235 {
1236 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1237 dbgprintf(TEXT("CAdvancedSettings::get_EnableMouse(%p)"), penableMouse);
1238 HRESULT hr = pIMsRdpClientAdvancedSettings->get_EnableMouse(penableMouse);
1239 dbgprintf(TEXT("CAdvancedSettings::get_EnableMouse -> %08X, enableMouse = %ld"), hr, *penableMouse);
1240 return hr;
1241 }
1242
1243 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_DisableCtrlAltDel(long pdisableCtrlAltDel)
1244 {
1245 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1246 dbgprintf(TEXT("CAdvancedSettings::put_DisableCtrlAltDel(%ld)"), pdisableCtrlAltDel);
1247 HRESULT hr = pIMsRdpClientAdvancedSettings->put_DisableCtrlAltDel(pdisableCtrlAltDel);
1248 dbgprintf(TEXT("CAdvancedSettings::put_DisableCtrlAltDel -> %08X"), hr);
1249 return hr;
1250 }
1251
1252 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_DisableCtrlAltDel(long * pdisableCtrlAltDel)
1253 {
1254 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1255 dbgprintf(TEXT("CAdvancedSettings::get_DisableCtrlAltDel(%p)"), pdisableCtrlAltDel);
1256 HRESULT hr = pIMsRdpClientAdvancedSettings->get_DisableCtrlAltDel(pdisableCtrlAltDel);
1257 dbgprintf(TEXT("CAdvancedSettings::get_DisableCtrlAltDel -> %08X, disableCtrlAltDel = %ld"), hr, *pdisableCtrlAltDel);
1258 return hr;
1259 }
1260
1261 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_EnableWindowsKey(long penableWindowsKey)
1262 {
1263 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1264 dbgprintf(TEXT("CAdvancedSettings::put_EnableWindowsKey(%ld)"), penableWindowsKey);
1265 HRESULT hr = pIMsRdpClientAdvancedSettings->put_EnableWindowsKey(penableWindowsKey);
1266 dbgprintf(TEXT("CAdvancedSettings::put_EnableWindowsKey -> %08X"), hr);
1267 return hr;
1268 }
1269
1270 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_EnableWindowsKey(long * penableWindowsKey)
1271 {
1272 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1273 dbgprintf(TEXT("CAdvancedSettings::get_EnableWindowsKey(%p)"), penableWindowsKey);
1274 HRESULT hr = pIMsRdpClientAdvancedSettings->get_EnableWindowsKey(penableWindowsKey);
1275 dbgprintf(TEXT("CAdvancedSettings::get_EnableWindowsKey -> %08X, enableWindowsKey = %ld"), hr, *penableWindowsKey);
1276 return hr;
1277 }
1278
1279 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_DoubleClickDetect(long pdoubleClickDetect)
1280 {
1281 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1282 dbgprintf(TEXT("CAdvancedSettings::put_DoubleClickDetect(%ld)"), pdoubleClickDetect);
1283 HRESULT hr = pIMsRdpClientAdvancedSettings->put_DoubleClickDetect(pdoubleClickDetect);
1284 dbgprintf(TEXT("CAdvancedSettings::put_DoubleClickDetect -> %08X"), hr);
1285 return hr;
1286 }
1287
1288 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_DoubleClickDetect(long * pdoubleClickDetect)
1289 {
1290 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1291 dbgprintf(TEXT("CAdvancedSettings::get_DoubleClickDetect(%p)"), pdoubleClickDetect);
1292 HRESULT hr = pIMsRdpClientAdvancedSettings->get_DoubleClickDetect(pdoubleClickDetect);
1293 dbgprintf(TEXT("CAdvancedSettings::get_DoubleClickDetect -> %08X, doubleClickDetect = %ld"), hr, *pdoubleClickDetect);
1294 return hr;
1295 }
1296
1297 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_MaximizeShell(long pmaximizeShell)
1298 {
1299 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1300 dbgprintf(TEXT("CAdvancedSettings::put_MaximizeShell(%ld)"), pmaximizeShell);
1301 HRESULT hr = pIMsRdpClientAdvancedSettings->put_MaximizeShell(pmaximizeShell);
1302 dbgprintf(TEXT("CAdvancedSettings::put_MaximizeShell -> %08X"), hr);
1303 return hr;
1304 }
1305
1306 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_MaximizeShell(long * pmaximizeShell)
1307 {
1308 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1309 dbgprintf(TEXT("CAdvancedSettings::get_MaximizeShell(%p)"), pmaximizeShell);
1310 HRESULT hr = pIMsRdpClientAdvancedSettings->get_MaximizeShell(pmaximizeShell);
1311 dbgprintf(TEXT("CAdvancedSettings::get_MaximizeShell -> %08X, maximizeShell = %ld"), hr, *pmaximizeShell);
1312 return hr;
1313 }
1314
1315 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyFullScreen(long photKeyFullScreen)
1316 {
1317 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1318 dbgprintf(TEXT("CAdvancedSettings::put_HotKeyFullScreen(%ld)"), photKeyFullScreen);
1319 HRESULT hr = pIMsRdpClientAdvancedSettings->put_HotKeyFullScreen(photKeyFullScreen);
1320 dbgprintf(TEXT("CAdvancedSettings::put_HotKeyFullScreen -> %08X"), hr);
1321 return hr;
1322 }
1323
1324 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyFullScreen(long * photKeyFullScreen)
1325 {
1326 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1327 dbgprintf(TEXT("CAdvancedSettings::get_HotKeyFullScreen(%p)"), photKeyFullScreen);
1328 HRESULT hr = pIMsRdpClientAdvancedSettings->get_HotKeyFullScreen(photKeyFullScreen);
1329 dbgprintf(TEXT("CAdvancedSettings::get_HotKeyFullScreen -> %08X, hotKeyFullScreen = %ld"), hr, *photKeyFullScreen);
1330 return hr;
1331 }
1332
1333 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyCtrlEsc(long photKeyCtrlEsc)
1334 {
1335 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1336 dbgprintf(TEXT("CAdvancedSettings::put_HotKeyCtrlEsc(%ld)"), photKeyCtrlEsc);
1337 HRESULT hr = pIMsRdpClientAdvancedSettings->put_HotKeyCtrlEsc(photKeyCtrlEsc);
1338 dbgprintf(TEXT("CAdvancedSettings::put_HotKeyCtrlEsc -> %08X"), hr);
1339 return hr;
1340 }
1341
1342 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyCtrlEsc(long * photKeyCtrlEsc)
1343 {
1344 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1345 dbgprintf(TEXT("CAdvancedSettings::get_HotKeyCtrlEsc(%p)"), photKeyCtrlEsc);
1346 HRESULT hr = pIMsRdpClientAdvancedSettings->get_HotKeyCtrlEsc(photKeyCtrlEsc);
1347 dbgprintf(TEXT("CAdvancedSettings::get_HotKeyCtrlEsc -> %08X, hotKeyCtrlEsc = %ld"), hr, *photKeyCtrlEsc);
1348 return hr;
1349 }
1350
1351 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyAltEsc(long photKeyAltEsc)
1352 {
1353 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1354 dbgprintf(TEXT("CAdvancedSettings::put_HotKeyAltEsc(%ld)"), photKeyAltEsc);
1355 HRESULT hr = pIMsRdpClientAdvancedSettings->put_HotKeyAltEsc(photKeyAltEsc);
1356 dbgprintf(TEXT("CAdvancedSettings::put_HotKeyAltEsc -> %08X"), hr);
1357 return hr;
1358 }
1359
1360 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyAltEsc(long * photKeyAltEsc)
1361 {
1362 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1363 dbgprintf(TEXT("CAdvancedSettings::get_HotKeyAltEsc(%p)"), photKeyAltEsc);
1364 HRESULT hr = pIMsRdpClientAdvancedSettings->get_HotKeyAltEsc(photKeyAltEsc);
1365 dbgprintf(TEXT("CAdvancedSettings::get_HotKeyAltEsc -> %08X, hotKeyAltEsc = %ld"), hr, *photKeyAltEsc);
1366 return hr;
1367 }
1368
1369 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyAltTab(long photKeyAltTab)
1370 {
1371 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1372 dbgprintf(TEXT("CAdvancedSettings::put_HotKeyAltTab(%ld)"), photKeyAltTab);
1373 HRESULT hr = pIMsRdpClientAdvancedSettings->put_HotKeyAltTab(photKeyAltTab);
1374 dbgprintf(TEXT("CAdvancedSettings::put_HotKeyAltTab -> %08X"), hr);
1375 return hr;
1376 }
1377
1378 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyAltTab(long * photKeyAltTab)
1379 {
1380 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1381 dbgprintf(TEXT("CAdvancedSettings::get_HotKeyAltTab(%p)"), photKeyAltTab);
1382 HRESULT hr = pIMsRdpClientAdvancedSettings->get_HotKeyAltTab(photKeyAltTab);
1383 dbgprintf(TEXT("CAdvancedSettings::get_HotKeyAltTab -> %08X, hotKeyAltTab = %ld"), hr, *photKeyAltTab);
1384 return hr;
1385 }
1386
1387 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyAltShiftTab(long photKeyAltShiftTab)
1388 {
1389 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1390 dbgprintf(TEXT("CAdvancedSettings::put_HotKeyAltShiftTab(%ld)"), photKeyAltShiftTab);
1391 HRESULT hr = pIMsRdpClientAdvancedSettings->put_HotKeyAltShiftTab(photKeyAltShiftTab);
1392 dbgprintf(TEXT("CAdvancedSettings::put_HotKeyAltShiftTab -> %08X"), hr);
1393 return hr;
1394 }
1395
1396 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyAltShiftTab(long * photKeyAltShiftTab)
1397 {
1398 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1399 dbgprintf(TEXT("CAdvancedSettings::get_HotKeyAltShiftTab(%p)"), photKeyAltShiftTab);
1400 HRESULT hr = pIMsRdpClientAdvancedSettings->get_HotKeyAltShiftTab(photKeyAltShiftTab);
1401 dbgprintf(TEXT("CAdvancedSettings::get_HotKeyAltShiftTab -> %08X, hotKeyAltShiftTab = %ld"), hr, *photKeyAltShiftTab);
1402 return hr;
1403 }
1404
1405 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyAltSpace(long photKeyAltSpace)
1406 {
1407 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1408 dbgprintf(TEXT("CAdvancedSettings::put_HotKeyAltSpace(%ld)"), photKeyAltSpace);
1409 HRESULT hr = pIMsRdpClientAdvancedSettings->put_HotKeyAltSpace(photKeyAltSpace);
1410 dbgprintf(TEXT("CAdvancedSettings::put_HotKeyAltSpace -> %08X"), hr);
1411 return hr;
1412 }
1413
1414 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyAltSpace(long * photKeyAltSpace)
1415 {
1416 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1417 dbgprintf(TEXT("CAdvancedSettings::get_HotKeyAltSpace(%p)"), photKeyAltSpace);
1418 HRESULT hr = pIMsRdpClientAdvancedSettings->get_HotKeyAltSpace(photKeyAltSpace);
1419 dbgprintf(TEXT("CAdvancedSettings::get_HotKeyAltSpace -> %08X, hotKeyAltSpace = %ld"), hr, *photKeyAltSpace);
1420 return hr;
1421 }
1422
1423 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyCtrlAltDel(long photKeyCtrlAltDel)
1424 {
1425 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1426 dbgprintf(TEXT("CAdvancedSettings::put_HotKeyCtrlAltDel(%ld)"), photKeyCtrlAltDel);
1427 HRESULT hr = pIMsRdpClientAdvancedSettings->put_HotKeyCtrlAltDel(photKeyCtrlAltDel);
1428 dbgprintf(TEXT("CAdvancedSettings::put_HotKeyCtrlAltDel -> %08X"), hr);
1429 return hr;
1430 }
1431
1432 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyCtrlAltDel(long * photKeyCtrlAltDel)
1433 {
1434 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1435 dbgprintf(TEXT("CAdvancedSettings::get_HotKeyCtrlAltDel(%p)"), photKeyCtrlAltDel);
1436 HRESULT hr = pIMsRdpClientAdvancedSettings->get_HotKeyCtrlAltDel(photKeyCtrlAltDel);
1437 dbgprintf(TEXT("CAdvancedSettings::get_HotKeyCtrlAltDel -> %08X, hotKeyCtrlAltDel = %ld"), hr, *photKeyCtrlAltDel);
1438 return hr;
1439 }
1440
1441 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_orderDrawThreshold(long porderDrawThreshold)
1442 {
1443 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1444 dbgprintf(TEXT("CAdvancedSettings::put_orderDrawThreshold(%ld)"), porderDrawThreshold);
1445 HRESULT hr = pIMsRdpClientAdvancedSettings->put_orderDrawThreshold(porderDrawThreshold);
1446 dbgprintf(TEXT("CAdvancedSettings::put_orderDrawThreshold -> %08X"), hr);
1447 return hr;
1448 }
1449
1450 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_orderDrawThreshold(long * porderDrawThreshold)
1451 {
1452 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1453 dbgprintf(TEXT("CAdvancedSettings::get_orderDrawThreshold(%p)"), porderDrawThreshold);
1454 HRESULT hr = pIMsRdpClientAdvancedSettings->get_orderDrawThreshold(porderDrawThreshold);
1455 dbgprintf(TEXT("CAdvancedSettings::get_orderDrawThreshold -> %08X, orderDrawThreshold = %ld"), hr, *porderDrawThreshold);
1456 return hr;
1457 }
1458
1459 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapCacheSize(long pbitmapCacheSize)
1460 {
1461 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1462 dbgprintf(TEXT("CAdvancedSettings::put_BitmapCacheSize(%ld)"), pbitmapCacheSize);
1463 HRESULT hr = pIMsRdpClientAdvancedSettings->put_BitmapCacheSize(pbitmapCacheSize);
1464 dbgprintf(TEXT("CAdvancedSettings::put_BitmapCacheSize -> %08X"), hr);
1465 return hr;
1466 }
1467
1468 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapCacheSize(long * pbitmapCacheSize)
1469 {
1470 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1471 dbgprintf(TEXT("CAdvancedSettings::get_BitmapCacheSize(%p)"), pbitmapCacheSize);
1472 HRESULT hr = pIMsRdpClientAdvancedSettings->get_BitmapCacheSize(pbitmapCacheSize);
1473 dbgprintf(TEXT("CAdvancedSettings::get_BitmapCacheSize -> %08X, bitmapCacheSize = %ld"), hr, *pbitmapCacheSize);
1474 return hr;
1475 }
1476
1477 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapVirtualCacheSize(long pbitmapVirtualCacheSize)
1478 {
1479 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1480 dbgprintf(TEXT("CAdvancedSettings::put_BitmapVirtualCacheSize(%ld)"), pbitmapVirtualCacheSize);
1481 HRESULT hr = pIMsRdpClientAdvancedSettings->put_BitmapVirtualCacheSize(pbitmapVirtualCacheSize);
1482 dbgprintf(TEXT("CAdvancedSettings::put_BitmapVirtualCacheSize -> %08X"), hr);
1483 return hr;
1484 }
1485
1486 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapVirtualCacheSize(long * pbitmapVirtualCacheSize)
1487 {
1488 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1489 dbgprintf(TEXT("CAdvancedSettings::get_BitmapVirtualCacheSize(%p)"), pbitmapVirtualCacheSize);
1490 HRESULT hr = pIMsRdpClientAdvancedSettings->get_BitmapVirtualCacheSize(pbitmapVirtualCacheSize);
1491 dbgprintf(TEXT("CAdvancedSettings::get_BitmapVirtualCacheSize -> %08X, bitmapVirtualCacheSize = %ld"), hr, *pbitmapVirtualCacheSize);
1492 return hr;
1493 }
1494
1495 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ScaleBitmapCachesByBPP(long pbScale)
1496 {
1497 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1498 dbgprintf(TEXT("CAdvancedSettings::put_ScaleBitmapCachesByBPP(%ld)"), pbScale);
1499 HRESULT hr = pIMsRdpClientAdvancedSettings->put_ScaleBitmapCachesByBPP(pbScale);
1500 dbgprintf(TEXT("CAdvancedSettings::put_ScaleBitmapCachesByBPP -> %08X"), hr);
1501 return hr;
1502 }
1503
1504 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_ScaleBitmapCachesByBPP(long * pbScale)
1505 {
1506 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1507 dbgprintf(TEXT("CAdvancedSettings::get_ScaleBitmapCachesByBPP(%p)"), pbScale);
1508 HRESULT hr = pIMsRdpClientAdvancedSettings->get_ScaleBitmapCachesByBPP(pbScale);
1509 dbgprintf(TEXT("CAdvancedSettings::get_ScaleBitmapCachesByBPP -> %08X, bScale = %ld"), hr, *pbScale);
1510 return hr;
1511 }
1512
1513 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_NumBitmapCaches(long pnumBitmapCaches)
1514 {
1515 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1516 dbgprintf(TEXT("CAdvancedSettings::put_NumBitmapCaches(%ld)"), pnumBitmapCaches);
1517 HRESULT hr = pIMsRdpClientAdvancedSettings->put_NumBitmapCaches(pnumBitmapCaches);
1518 dbgprintf(TEXT("CAdvancedSettings::put_NumBitmapCaches -> %08X"), hr);
1519 return hr;
1520 }
1521
1522 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_NumBitmapCaches(long * pnumBitmapCaches)
1523 {
1524 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1525 dbgprintf(TEXT("CAdvancedSettings::get_NumBitmapCaches(%p)"), pnumBitmapCaches);
1526 HRESULT hr = pIMsRdpClientAdvancedSettings->get_NumBitmapCaches(pnumBitmapCaches);
1527 dbgprintf(TEXT("CAdvancedSettings::get_NumBitmapCaches -> %08X, numBitmapCaches = %ld"), hr, *pnumBitmapCaches);
1528 return hr;
1529 }
1530
1531 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_CachePersistenceActive(long pcachePersistenceActive)
1532 {
1533 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1534 dbgprintf(TEXT("CAdvancedSettings::put_CachePersistenceActive(%ld)"), pcachePersistenceActive);
1535 HRESULT hr = pIMsRdpClientAdvancedSettings->put_CachePersistenceActive(pcachePersistenceActive);
1536 dbgprintf(TEXT("CAdvancedSettings::put_CachePersistenceActive -> %08X"), hr);
1537 return hr;
1538 }
1539
1540 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_CachePersistenceActive(long * pcachePersistenceActive)
1541 {
1542 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1543 dbgprintf(TEXT("CAdvancedSettings::get_CachePersistenceActive(%p)"), pcachePersistenceActive);
1544 HRESULT hr = pIMsRdpClientAdvancedSettings->get_CachePersistenceActive(pcachePersistenceActive);
1545 dbgprintf(TEXT("CAdvancedSettings::get_CachePersistenceActive -> %08X, cachePersistenceActive = %ld"), hr, *pcachePersistenceActive);
1546 return hr;
1547 }
1548
1549 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_PersistCacheDirectory(BSTR rhs)
1550 {
1551 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1552 dbgprintf(TEXT("CAdvancedSettings::put_PersistCacheDirectory(%ls)"), rhs);
1553 HRESULT hr = pIMsRdpClientAdvancedSettings->put_PersistCacheDirectory(rhs);
1554 dbgprintf(TEXT("CAdvancedSettings::put_PersistCacheDirectory -> %08X"), hr);
1555 return hr;
1556 }
1557
1558 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_brushSupportLevel(long pbrushSupportLevel)
1559 {
1560 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1561 dbgprintf(TEXT("CAdvancedSettings::put_brushSupportLevel(%ld)"), pbrushSupportLevel);
1562 HRESULT hr = pIMsRdpClientAdvancedSettings->put_brushSupportLevel(pbrushSupportLevel);
1563 dbgprintf(TEXT("CAdvancedSettings::put_brushSupportLevel -> %08X"), hr);
1564 return hr;
1565 }
1566
1567 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_brushSupportLevel(long * pbrushSupportLevel)
1568 {
1569 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1570 dbgprintf(TEXT("CAdvancedSettings::get_brushSupportLevel(%p)"), pbrushSupportLevel);
1571 HRESULT hr = pIMsRdpClientAdvancedSettings->get_brushSupportLevel(pbrushSupportLevel);
1572 dbgprintf(TEXT("CAdvancedSettings::get_brushSupportLevel -> %08X, brushSupportLevel = %ld"), hr, *pbrushSupportLevel);
1573 return hr;
1574 }
1575
1576 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_minInputSendInterval(long pminInputSendInterval)
1577 {
1578 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1579 dbgprintf(TEXT("CAdvancedSettings::put_minInputSendInterval(%ld)"), pminInputSendInterval);
1580 HRESULT hr = pIMsRdpClientAdvancedSettings->put_minInputSendInterval(pminInputSendInterval);
1581 dbgprintf(TEXT("CAdvancedSettings::put_minInputSendInterval -> %08X"), hr);
1582 return hr;
1583 }
1584
1585 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_minInputSendInterval(long * pminInputSendInterval)
1586 {
1587 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1588 dbgprintf(TEXT("CAdvancedSettings::get_minInputSendInterval(%p)"), pminInputSendInterval);
1589 HRESULT hr = pIMsRdpClientAdvancedSettings->get_minInputSendInterval(pminInputSendInterval);
1590 dbgprintf(TEXT("CAdvancedSettings::get_minInputSendInterval -> %08X, minInputSendInterval = %ld"), hr, *pminInputSendInterval);
1591 return hr;
1592 }
1593
1594 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_InputEventsAtOnce(long pinputEventsAtOnce)
1595 {
1596 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1597 dbgprintf(TEXT("CAdvancedSettings::put_InputEventsAtOnce(%ld)"), pinputEventsAtOnce);
1598 HRESULT hr = pIMsRdpClientAdvancedSettings->put_InputEventsAtOnce(pinputEventsAtOnce);
1599 dbgprintf(TEXT("CAdvancedSettings::put_InputEventsAtOnce -> %08X"), hr);
1600 return hr;
1601 }
1602
1603 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_InputEventsAtOnce(long * pinputEventsAtOnce)
1604 {
1605 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1606 dbgprintf(TEXT("CAdvancedSettings::get_InputEventsAtOnce(%p)"), pinputEventsAtOnce);
1607 HRESULT hr = pIMsRdpClientAdvancedSettings->get_InputEventsAtOnce(pinputEventsAtOnce);
1608 dbgprintf(TEXT("CAdvancedSettings::get_InputEventsAtOnce -> %08X, inputEventsAtOnce = %ld"), hr, *pinputEventsAtOnce);
1609 return hr;
1610 }
1611
1612 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_maxEventCount(long pmaxEventCount)
1613 {
1614 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1615 dbgprintf(TEXT("CAdvancedSettings::put_maxEventCount(%ld)"), pmaxEventCount);
1616 HRESULT hr = pIMsRdpClientAdvancedSettings->put_maxEventCount(pmaxEventCount);
1617 dbgprintf(TEXT("CAdvancedSettings::put_maxEventCount -> %08X"), hr);
1618 return hr;
1619 }
1620
1621 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_maxEventCount(long * pmaxEventCount)
1622 {
1623 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1624 dbgprintf(TEXT("CAdvancedSettings::get_maxEventCount(%p)"), pmaxEventCount);
1625 HRESULT hr = pIMsRdpClientAdvancedSettings->get_maxEventCount(pmaxEventCount);
1626 dbgprintf(TEXT("CAdvancedSettings::get_maxEventCount -> %08X, maxEventCount = %ld"), hr, *pmaxEventCount);
1627 return hr;
1628 }
1629
1630 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_keepAliveInterval(long pkeepAliveInterval)
1631 {
1632 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1633 dbgprintf(TEXT("CAdvancedSettings::put_keepAliveInterval(%ld)"), pkeepAliveInterval);
1634 HRESULT hr = pIMsRdpClientAdvancedSettings->put_keepAliveInterval(pkeepAliveInterval);
1635 dbgprintf(TEXT("CAdvancedSettings::put_keepAliveInterval -> %08X"), hr);
1636 return hr;
1637 }
1638
1639 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_keepAliveInterval(long * pkeepAliveInterval)
1640 {
1641 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1642 dbgprintf(TEXT("CAdvancedSettings::get_keepAliveInterval(%p)"), pkeepAliveInterval);
1643 HRESULT hr = pIMsRdpClientAdvancedSettings->get_keepAliveInterval(pkeepAliveInterval);
1644 dbgprintf(TEXT("CAdvancedSettings::get_keepAliveInterval -> %08X, keepAliveInterval = %ld"), hr, *pkeepAliveInterval);
1645 return hr;
1646 }
1647
1648 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_shutdownTimeout(long pshutdownTimeout)
1649 {
1650 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1651 dbgprintf(TEXT("CAdvancedSettings::put_shutdownTimeout(%ld)"), pshutdownTimeout);
1652 HRESULT hr = pIMsRdpClientAdvancedSettings->put_shutdownTimeout(pshutdownTimeout);
1653 dbgprintf(TEXT("CAdvancedSettings::put_shutdownTimeout -> %08X"), hr);
1654 return hr;
1655 }
1656
1657 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_shutdownTimeout(long * pshutdownTimeout)
1658 {
1659 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1660 dbgprintf(TEXT("CAdvancedSettings::get_shutdownTimeout(%p)"), pshutdownTimeout);
1661 HRESULT hr = pIMsRdpClientAdvancedSettings->get_shutdownTimeout(pshutdownTimeout);
1662 dbgprintf(TEXT("CAdvancedSettings::get_shutdownTimeout -> %08X, shutdownTimeout = %ld"), hr, *pshutdownTimeout);
1663 return hr;
1664 }
1665
1666 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_overallConnectionTimeout(long poverallConnectionTimeout)
1667 {
1668 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1669 dbgprintf(TEXT("CAdvancedSettings::put_overallConnectionTimeout(%ld)"), poverallConnectionTimeout);
1670 HRESULT hr = pIMsRdpClientAdvancedSettings->put_overallConnectionTimeout(poverallConnectionTimeout);
1671 dbgprintf(TEXT("CAdvancedSettings::put_overallConnectionTimeout -> %08X"), hr);
1672 return hr;
1673 }
1674
1675 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_overallConnectionTimeout(long * poverallConnectionTimeout)
1676 {
1677 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1678 dbgprintf(TEXT("CAdvancedSettings::get_overallConnectionTimeout(%p)"), poverallConnectionTimeout);
1679 HRESULT hr = pIMsRdpClientAdvancedSettings->get_overallConnectionTimeout(poverallConnectionTimeout);
1680 dbgprintf(TEXT("CAdvancedSettings::get_overallConnectionTimeout -> %08X, overallConnectionTimeout = %ld"), hr, *poverallConnectionTimeout);
1681 return hr;
1682 }
1683
1684 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_singleConnectionTimeout(long psingleConnectionTimeout)
1685 {
1686 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1687 dbgprintf(TEXT("CAdvancedSettings::put_singleConnectionTimeout(%ld)"), psingleConnectionTimeout);
1688 HRESULT hr = pIMsRdpClientAdvancedSettings->put_singleConnectionTimeout(psingleConnectionTimeout);
1689 dbgprintf(TEXT("CAdvancedSettings::put_singleConnectionTimeout -> %08X"), hr);
1690 return hr;
1691 }
1692
1693 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_singleConnectionTimeout(long * psingleConnectionTimeout)
1694 {
1695 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1696 dbgprintf(TEXT("CAdvancedSettings::get_singleConnectionTimeout(%p)"), psingleConnectionTimeout);
1697 HRESULT hr = pIMsRdpClientAdvancedSettings->get_singleConnectionTimeout(psingleConnectionTimeout);
1698 dbgprintf(TEXT("CAdvancedSettings::get_singleConnectionTimeout -> %08X, singleConnectionTimeout = %ld"), hr, *psingleConnectionTimeout);
1699 return hr;
1700 }
1701
1702 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_KeyboardType(long pkeyboardType)
1703 {
1704 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1705 dbgprintf(TEXT("CAdvancedSettings::put_KeyboardType(%ld)"), pkeyboardType);
1706 HRESULT hr = pIMsRdpClientAdvancedSettings->put_KeyboardType(pkeyboardType);
1707 dbgprintf(TEXT("CAdvancedSettings::put_KeyboardType -> %08X"), hr);
1708 return hr;
1709 }
1710
1711 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_KeyboardType(long * pkeyboardType)
1712 {
1713 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1714 dbgprintf(TEXT("CAdvancedSettings::get_KeyboardType(%p)"), pkeyboardType);
1715 HRESULT hr = pIMsRdpClientAdvancedSettings->get_KeyboardType(pkeyboardType);
1716 dbgprintf(TEXT("CAdvancedSettings::get_KeyboardType -> %08X, keyboardType = %ld"), hr, *pkeyboardType);
1717 return hr;
1718 }
1719
1720 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_KeyboardSubType(long pkeyboardSubType)
1721 {
1722 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1723 dbgprintf(TEXT("CAdvancedSettings::put_KeyboardSubType(%ld)"), pkeyboardSubType);
1724 HRESULT hr = pIMsRdpClientAdvancedSettings->put_KeyboardSubType(pkeyboardSubType);
1725 dbgprintf(TEXT("CAdvancedSettings::put_KeyboardSubType -> %08X"), hr);
1726 return hr;
1727 }
1728
1729 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_KeyboardSubType(long * pkeyboardSubType)
1730 {
1731 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1732 dbgprintf(TEXT("CAdvancedSettings::get_KeyboardSubType(%p)"), pkeyboardSubType);
1733 HRESULT hr = pIMsRdpClientAdvancedSettings->get_KeyboardSubType(pkeyboardSubType);
1734 dbgprintf(TEXT("CAdvancedSettings::get_KeyboardSubType -> %08X, keyboardSubType = %ld"), hr, *pkeyboardSubType);
1735 return hr;
1736 }
1737
1738 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_KeyboardFunctionKey(long pkeyboardFunctionKey)
1739 {
1740 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1741 dbgprintf(TEXT("CAdvancedSettings::put_KeyboardFunctionKey(%ld)"), pkeyboardFunctionKey);
1742 HRESULT hr = pIMsRdpClientAdvancedSettings->put_KeyboardFunctionKey(pkeyboardFunctionKey);
1743 dbgprintf(TEXT("CAdvancedSettings::put_KeyboardFunctionKey -> %08X"), hr);
1744 return hr;
1745 }
1746
1747 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_KeyboardFunctionKey(long * pkeyboardFunctionKey)
1748 {
1749 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1750 dbgprintf(TEXT("CAdvancedSettings::get_KeyboardFunctionKey(%p)"), pkeyboardFunctionKey);
1751 HRESULT hr = pIMsRdpClientAdvancedSettings->get_KeyboardFunctionKey(pkeyboardFunctionKey);
1752 dbgprintf(TEXT("CAdvancedSettings::get_KeyboardFunctionKey -> %08X, keyboardFunctionKey = %ld"), hr, *pkeyboardFunctionKey);
1753 return hr;
1754 }
1755
1756 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_WinceFixedPalette(long pwinceFixedPalette)
1757 {
1758 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1759 dbgprintf(TEXT("CAdvancedSettings::put_WinceFixedPalette(%ld)"), pwinceFixedPalette);
1760 HRESULT hr = pIMsRdpClientAdvancedSettings->put_WinceFixedPalette(pwinceFixedPalette);
1761 dbgprintf(TEXT("CAdvancedSettings::put_WinceFixedPalette -> %08X"), hr);
1762 return hr;
1763 }
1764
1765 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_WinceFixedPalette(long * pwinceFixedPalette)
1766 {
1767 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1768 dbgprintf(TEXT("CAdvancedSettings::get_WinceFixedPalette(%p)"), pwinceFixedPalette);
1769 HRESULT hr = pIMsRdpClientAdvancedSettings->get_WinceFixedPalette(pwinceFixedPalette);
1770 dbgprintf(TEXT("CAdvancedSettings::get_WinceFixedPalette -> %08X, winceFixedPalette = %ld"), hr, *pwinceFixedPalette);
1771 return hr;
1772 }
1773
1774 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ConnectToServerConsole(VARIANT_BOOL pConnectToConsole)
1775 {
1776 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1777 dbgprintf(TEXT("CAdvancedSettings::put_ConnectToServerConsole(%s)"), BooleanToString(pConnectToConsole));
1778 HRESULT hr = pIMsRdpClientAdvancedSettings->put_ConnectToServerConsole(pConnectToConsole);
1779 dbgprintf(TEXT("CAdvancedSettings::put_ConnectToServerConsole -> %08X"), hr);
1780 return hr;
1781 }
1782
1783 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_ConnectToServerConsole(VARIANT_BOOL * pConnectToConsole)
1784 {
1785 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1786 dbgprintf(TEXT("CAdvancedSettings::get_ConnectToServerConsole(%p)"), pConnectToConsole);
1787 HRESULT hr = pIMsRdpClientAdvancedSettings->get_ConnectToServerConsole(pConnectToConsole);
1788 dbgprintf(TEXT("CAdvancedSettings::get_ConnectToServerConsole -> %08X, ConnectToConsole = %s"), hr, BooleanToString(*pConnectToConsole));
1789 return hr;
1790 }
1791
1792 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapPersistence(long pbitmapPersistence)
1793 {
1794 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1795 dbgprintf(TEXT("CAdvancedSettings::put_BitmapPersistence(%ld)"), pbitmapPersistence);
1796 HRESULT hr = pIMsRdpClientAdvancedSettings->put_BitmapPersistence(pbitmapPersistence);
1797 dbgprintf(TEXT("CAdvancedSettings::put_BitmapPersistence -> %08X"), hr);
1798 return hr;
1799 }
1800
1801 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapPersistence(long * pbitmapPersistence)
1802 {
1803 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1804 dbgprintf(TEXT("CAdvancedSettings::get_BitmapPersistence(%p)"), pbitmapPersistence);
1805 HRESULT hr = pIMsRdpClientAdvancedSettings->get_BitmapPersistence(pbitmapPersistence);
1806 dbgprintf(TEXT("CAdvancedSettings::get_BitmapPersistence -> %08X, bitmapPersistence = %ld"), hr, *pbitmapPersistence);
1807 return hr;
1808 }
1809
1810 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_MinutesToIdleTimeout(long pminutesToIdleTimeout)
1811 {
1812 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1813 dbgprintf(TEXT("CAdvancedSettings::put_MinutesToIdleTimeout(%ld)"), pminutesToIdleTimeout);
1814 HRESULT hr = pIMsRdpClientAdvancedSettings->put_MinutesToIdleTimeout(pminutesToIdleTimeout);
1815 dbgprintf(TEXT("CAdvancedSettings::put_MinutesToIdleTimeout -> %08X"), hr);
1816 return hr;
1817 }
1818
1819 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_MinutesToIdleTimeout(long * pminutesToIdleTimeout)
1820 {
1821 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1822 dbgprintf(TEXT("CAdvancedSettings::get_MinutesToIdleTimeout(%p)"), pminutesToIdleTimeout);
1823 HRESULT hr = pIMsRdpClientAdvancedSettings->get_MinutesToIdleTimeout(pminutesToIdleTimeout);
1824 dbgprintf(TEXT("CAdvancedSettings::get_MinutesToIdleTimeout -> %08X, minutesToIdleTimeout = %ld"), hr, *pminutesToIdleTimeout);
1825 return hr;
1826 }
1827
1828 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_SmartSizing(VARIANT_BOOL pfSmartSizing)
1829 {
1830 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1831 dbgprintf(TEXT("CAdvancedSettings::put_SmartSizing(%s)"), BooleanToString(pfSmartSizing));
1832 HRESULT hr = pIMsRdpClientAdvancedSettings->put_SmartSizing(pfSmartSizing);
1833 dbgprintf(TEXT("CAdvancedSettings::put_SmartSizing -> %08X"), hr);
1834 return hr;
1835 }
1836
1837 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_SmartSizing(VARIANT_BOOL * pfSmartSizing)
1838 {
1839 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1840 dbgprintf(TEXT("CAdvancedSettings::get_SmartSizing(%p)"), pfSmartSizing);
1841 HRESULT hr = pIMsRdpClientAdvancedSettings->get_SmartSizing(pfSmartSizing);
1842 dbgprintf(TEXT("CAdvancedSettings::get_SmartSizing -> %08X, fSmartSizing = %s"), hr, BooleanToString(*pfSmartSizing));
1843 return hr;
1844 }
1845
1846 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RdpdrLocalPrintingDocName(BSTR pLocalPrintingDocName)
1847 {
1848 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1849 dbgprintf(TEXT("CAdvancedSettings::put_RdpdrLocalPrintingDocName(%ls)"), pLocalPrintingDocName);
1850 HRESULT hr = pIMsRdpClientAdvancedSettings->put_RdpdrLocalPrintingDocName(pLocalPrintingDocName);
1851 dbgprintf(TEXT("CAdvancedSettings::put_RdpdrLocalPrintingDocName -> %08X"), hr);
1852 return hr;
1853 }
1854
1855 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RdpdrLocalPrintingDocName(BSTR * pLocalPrintingDocName)
1856 {
1857 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1858 dbgprintf(TEXT("CAdvancedSettings::get_RdpdrLocalPrintingDocName(%p)"), pLocalPrintingDocName);
1859 HRESULT hr = pIMsRdpClientAdvancedSettings->get_RdpdrLocalPrintingDocName(pLocalPrintingDocName);
1860 dbgprintf(TEXT("CAdvancedSettings::get_RdpdrLocalPrintingDocName -> %08X, LocalPrintingDocName = %ls"), hr, *pLocalPrintingDocName);
1861 return hr;
1862 }
1863
1864 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RdpdrClipCleanTempDirString(BSTR clipCleanTempDirString)
1865 {
1866 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1867 dbgprintf(TEXT("CAdvancedSettings::put_RdpdrClipCleanTempDirString(%ls)"), clipCleanTempDirString);
1868 HRESULT hr = pIMsRdpClientAdvancedSettings->put_RdpdrClipCleanTempDirString(clipCleanTempDirString);
1869 dbgprintf(TEXT("CAdvancedSettings::put_RdpdrClipCleanTempDirString -> %08X"), hr);
1870 return hr;
1871 }
1872
1873 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RdpdrClipCleanTempDirString(BSTR * clipCleanTempDirString)
1874 {
1875 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1876 dbgprintf(TEXT("CAdvancedSettings::get_RdpdrClipCleanTempDirString(%p)"), clipCleanTempDirString);
1877 HRESULT hr = pIMsRdpClientAdvancedSettings->get_RdpdrClipCleanTempDirString(clipCleanTempDirString);
1878 dbgprintf(TEXT("CAdvancedSettings::get_RdpdrClipCleanTempDirString -> %08X, clipCleanTempDirString = %ls"), hr, *clipCleanTempDirString);
1879 return hr;
1880 }
1881
1882 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RdpdrClipPasteInfoString(BSTR clipPasteInfoString)
1883 {
1884 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1885 dbgprintf(TEXT("CAdvancedSettings::put_RdpdrClipPasteInfoString(%ls)"), clipPasteInfoString);
1886 HRESULT hr = pIMsRdpClientAdvancedSettings->put_RdpdrClipPasteInfoString(clipPasteInfoString);
1887 dbgprintf(TEXT("CAdvancedSettings::put_RdpdrClipPasteInfoString -> %08X"), hr);
1888 return hr;
1889 }
1890
1891 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RdpdrClipPasteInfoString(BSTR * clipPasteInfoString)
1892 {
1893 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1894 dbgprintf(TEXT("CAdvancedSettings::get_RdpdrClipPasteInfoString(%p)"), clipPasteInfoString);
1895 HRESULT hr = pIMsRdpClientAdvancedSettings->get_RdpdrClipPasteInfoString(clipPasteInfoString);
1896 dbgprintf(TEXT("CAdvancedSettings::get_RdpdrClipPasteInfoString -> %08X, clipPasteInfoString = %ls"), hr, *clipPasteInfoString);
1897 return hr;
1898 }
1899
1900 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ClearTextPassword(BSTR rhs)
1901 {
1902 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1903 dbgprintf(TEXT("CAdvancedSettings::put_ClearTextPassword(%ls)"), rhs);
1904 HRESULT hr = pIMsRdpClientAdvancedSettings->put_ClearTextPassword(rhs);
1905 dbgprintf(TEXT("CAdvancedSettings::put_ClearTextPassword -> %08X"), hr);
1906 return hr;
1907 }
1908
1909 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_DisplayConnectionBar(VARIANT_BOOL pDisplayConnectionBar)
1910 {
1911 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1912 dbgprintf(TEXT("CAdvancedSettings::put_DisplayConnectionBar(%s)"), BooleanToString(pDisplayConnectionBar));
1913 HRESULT hr = pIMsRdpClientAdvancedSettings->put_DisplayConnectionBar(pDisplayConnectionBar);
1914 dbgprintf(TEXT("CAdvancedSettings::put_DisplayConnectionBar -> %08X"), hr);
1915 return hr;
1916 }
1917
1918 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_DisplayConnectionBar(VARIANT_BOOL * pDisplayConnectionBar)
1919 {
1920 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1921 dbgprintf(TEXT("CAdvancedSettings::get_DisplayConnectionBar(%p)"), pDisplayConnectionBar);
1922 HRESULT hr = pIMsRdpClientAdvancedSettings->get_DisplayConnectionBar(pDisplayConnectionBar);
1923 dbgprintf(TEXT("CAdvancedSettings::get_DisplayConnectionBar -> %08X, DisplayConnectionBar = %s"), hr, BooleanToString(*pDisplayConnectionBar));
1924 return hr;
1925 }
1926
1927 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_PinConnectionBar(VARIANT_BOOL pPinConnectionBar)
1928 {
1929 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1930 dbgprintf(TEXT("CAdvancedSettings::put_PinConnectionBar(%s)"), BooleanToString(pPinConnectionBar));
1931 HRESULT hr = pIMsRdpClientAdvancedSettings->put_PinConnectionBar(pPinConnectionBar);
1932 dbgprintf(TEXT("CAdvancedSettings::put_PinConnectionBar -> %08X"), hr);
1933 return hr;
1934 }
1935
1936 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_PinConnectionBar(VARIANT_BOOL * pPinConnectionBar)
1937 {
1938 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1939 dbgprintf(TEXT("CAdvancedSettings::get_PinConnectionBar(%p)"), pPinConnectionBar);
1940 HRESULT hr = pIMsRdpClientAdvancedSettings->get_PinConnectionBar(pPinConnectionBar);
1941 dbgprintf(TEXT("CAdvancedSettings::get_PinConnectionBar -> %08X, PinConnectionBar = %s"), hr, BooleanToString(*pPinConnectionBar));
1942 return hr;
1943 }
1944
1945 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_GrabFocusOnConnect(VARIANT_BOOL pfGrabFocusOnConnect)
1946 {
1947 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1948 dbgprintf(TEXT("CAdvancedSettings::put_GrabFocusOnConnect(%s)"), BooleanToString(pfGrabFocusOnConnect));
1949 HRESULT hr = pIMsRdpClientAdvancedSettings->put_GrabFocusOnConnect(pfGrabFocusOnConnect);
1950 dbgprintf(TEXT("CAdvancedSettings::put_GrabFocusOnConnect -> %08X"), hr);
1951 return hr;
1952 }
1953
1954 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_GrabFocusOnConnect(VARIANT_BOOL * pfGrabFocusOnConnect)
1955 {
1956 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1957 dbgprintf(TEXT("CAdvancedSettings::get_GrabFocusOnConnect(%p)"), pfGrabFocusOnConnect);
1958 HRESULT hr = pIMsRdpClientAdvancedSettings->get_GrabFocusOnConnect(pfGrabFocusOnConnect);
1959 dbgprintf(TEXT("CAdvancedSettings::get_GrabFocusOnConnect -> %08X, fGrabFocusOnConnect = %s"), hr, BooleanToString(*pfGrabFocusOnConnect));
1960 return hr;
1961 }
1962
1963 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_LoadBalanceInfo(BSTR pLBInfo)
1964 {
1965 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1966 dbgprintf(TEXT("CAdvancedSettings::put_LoadBalanceInfo(%ls)"), pLBInfo);
1967 HRESULT hr = pIMsRdpClientAdvancedSettings->put_LoadBalanceInfo(pLBInfo);
1968 dbgprintf(TEXT("CAdvancedSettings::put_LoadBalanceInfo -> %08X"), hr);
1969 return hr;
1970 }
1971
1972 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_LoadBalanceInfo(BSTR * pLBInfo)
1973 {
1974 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1975 dbgprintf(TEXT("CAdvancedSettings::get_LoadBalanceInfo(%p)"), pLBInfo);
1976 HRESULT hr = pIMsRdpClientAdvancedSettings->get_LoadBalanceInfo(pLBInfo);
1977 dbgprintf(TEXT("CAdvancedSettings::get_LoadBalanceInfo -> %08X, LBInfo = %ls"), hr, *pLBInfo);
1978 return hr;
1979 }
1980
1981 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RedirectDrives(VARIANT_BOOL pRedirectDrives)
1982 {
1983 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1984 dbgprintf(TEXT("CAdvancedSettings::put_RedirectDrives(%s)"), BooleanToString(pRedirectDrives));
1985 HRESULT hr = pIMsRdpClientAdvancedSettings->put_RedirectDrives(pRedirectDrives);
1986 dbgprintf(TEXT("CAdvancedSettings::put_RedirectDrives -> %08X"), hr);
1987 return hr;
1988 }
1989
1990 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RedirectDrives(VARIANT_BOOL * pRedirectDrives)
1991 {
1992 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
1993 dbgprintf(TEXT("CAdvancedSettings::get_RedirectDrives(%p)"), pRedirectDrives);
1994 HRESULT hr = pIMsRdpClientAdvancedSettings->get_RedirectDrives(pRedirectDrives);
1995 dbgprintf(TEXT("CAdvancedSettings::get_RedirectDrives -> %08X, RedirectDrives = %s"), hr, BooleanToString(*pRedirectDrives));
1996 return hr;
1997 }
1998
1999 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RedirectPrinters(VARIANT_BOOL pRedirectPrinters)
2000 {
2001 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
2002 dbgprintf(TEXT("CAdvancedSettings::put_RedirectPrinters(%s)"), BooleanToString(pRedirectPrinters));
2003 HRESULT hr = pIMsRdpClientAdvancedSettings->put_RedirectPrinters(pRedirectPrinters);
2004 dbgprintf(TEXT("CAdvancedSettings::put_RedirectPrinters -> %08X"), hr);
2005 return hr;
2006 }
2007
2008 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RedirectPrinters(VARIANT_BOOL * pRedirectPrinters)
2009 {
2010 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
2011 dbgprintf(TEXT("CAdvancedSettings::get_RedirectPrinters(%p)"), pRedirectPrinters);
2012 HRESULT hr = pIMsRdpClientAdvancedSettings->get_RedirectPrinters(pRedirectPrinters);
2013 dbgprintf(TEXT("CAdvancedSettings::get_RedirectPrinters -> %08X, RedirectPrinters = %s"), hr, BooleanToString(*pRedirectPrinters));
2014 return hr;
2015 }
2016
2017 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RedirectPorts(VARIANT_BOOL pRedirectPorts)
2018 {
2019 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
2020 dbgprintf(TEXT("CAdvancedSettings::put_RedirectPorts(%s)"), BooleanToString(pRedirectPorts));
2021 HRESULT hr = pIMsRdpClientAdvancedSettings->put_RedirectPorts(pRedirectPorts);
2022 dbgprintf(TEXT("CAdvancedSettings::put_RedirectPorts -> %08X"), hr);
2023 return hr;
2024 }
2025
2026 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RedirectPorts(VARIANT_BOOL * pRedirectPorts)
2027 {
2028 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
2029 dbgprintf(TEXT("CAdvancedSettings::get_RedirectPorts(%p)"), pRedirectPorts);
2030 HRESULT hr = pIMsRdpClientAdvancedSettings->get_RedirectPorts(pRedirectPorts);
2031 dbgprintf(TEXT("CAdvancedSettings::get_RedirectPorts -> %08X, RedirectPorts = %s"), hr, BooleanToString(*pRedirectPorts));
2032 return hr;
2033 }
2034
2035 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RedirectSmartCards(VARIANT_BOOL pRedirectSmartCards)
2036 {
2037 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
2038 dbgprintf(TEXT("CAdvancedSettings::put_RedirectSmartCards(%s)"), BooleanToString(pRedirectSmartCards));
2039 HRESULT hr = pIMsRdpClientAdvancedSettings->put_RedirectSmartCards(pRedirectSmartCards);
2040 dbgprintf(TEXT("CAdvancedSettings::put_RedirectSmartCards -> %08X"), hr);
2041 return hr;
2042 }
2043
2044 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RedirectSmartCards(VARIANT_BOOL * pRedirectSmartCards)
2045 {
2046 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
2047 dbgprintf(TEXT("CAdvancedSettings::get_RedirectSmartCards(%p)"), pRedirectSmartCards);
2048 HRESULT hr = pIMsRdpClientAdvancedSettings->get_RedirectSmartCards(pRedirectSmartCards);
2049 dbgprintf(TEXT("CAdvancedSettings::get_RedirectSmartCards -> %08X, RedirectSmartCards = %s"), hr, BooleanToString(*pRedirectSmartCards));
2050 return hr;
2051 }
2052
2053 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapVirtualCache16BppSize(long pBitmapVirtualCache16BppSize)
2054 {
2055 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
2056 dbgprintf(TEXT("CAdvancedSettings::put_BitmapVirtualCache16BppSize(%ld)"), pBitmapVirtualCache16BppSize);
2057 HRESULT hr = pIMsRdpClientAdvancedSettings->put_BitmapVirtualCache16BppSize(pBitmapVirtualCache16BppSize);
2058 dbgprintf(TEXT("CAdvancedSettings::put_BitmapVirtualCache16BppSize -> %08X"), hr);
2059 return hr;
2060 }
2061
2062 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapVirtualCache16BppSize(long * pBitmapVirtualCache16BppSize)
2063 {
2064 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
2065 dbgprintf(TEXT("CAdvancedSettings::get_BitmapVirtualCache16BppSize(%p)"), pBitmapVirtualCache16BppSize);
2066 HRESULT hr = pIMsRdpClientAdvancedSettings->get_BitmapVirtualCache16BppSize(pBitmapVirtualCache16BppSize);
2067 dbgprintf(TEXT("CAdvancedSettings::get_BitmapVirtualCache16BppSize -> %08X, BitmapVirtualCache16BppSize = %ld"), hr, *pBitmapVirtualCache16BppSize);
2068 return hr;
2069 }
2070
2071 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapVirtualCache24BppSize(long pBitmapVirtualCache24BppSize)
2072 {
2073 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
2074 dbgprintf(TEXT("CAdvancedSettings::put_BitmapVirtualCache24BppSize(%ld)"), pBitmapVirtualCache24BppSize);
2075 HRESULT hr = pIMsRdpClientAdvancedSettings->put_BitmapVirtualCache24BppSize(pBitmapVirtualCache24BppSize);
2076 dbgprintf(TEXT("CAdvancedSettings::put_BitmapVirtualCache24BppSize -> %08X"), hr);
2077 return hr;
2078 }
2079
2080 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapVirtualCache24BppSize(long * pBitmapVirtualCache24BppSize)
2081 {
2082 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
2083 dbgprintf(TEXT("CAdvancedSettings::get_BitmapVirtualCache24BppSize(%p)"), pBitmapVirtualCache24BppSize);
2084 HRESULT hr = pIMsRdpClientAdvancedSettings->get_BitmapVirtualCache24BppSize(pBitmapVirtualCache24BppSize);
2085 dbgprintf(TEXT("CAdvancedSettings::get_BitmapVirtualCache24BppSize -> %08X, BitmapVirtualCache24BppSize = %ld"), hr, *pBitmapVirtualCache24BppSize);
2086 return hr;
2087 }
2088
2089 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_PerformanceFlags(long pDisableList)
2090 {
2091 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
2092 dbgprintf(TEXT("CAdvancedSettings::put_PerformanceFlags(%ld)"), pDisableList);
2093 HRESULT hr = pIMsRdpClientAdvancedSettings->put_PerformanceFlags(pDisableList);
2094 dbgprintf(TEXT("CAdvancedSettings::put_PerformanceFlags -> %08X"), hr);
2095 return hr;
2096 }
2097
2098 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_PerformanceFlags(long * pDisableList)
2099 {
2100 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
2101 dbgprintf(TEXT("CAdvancedSettings::get_PerformanceFlags(%p)"), pDisableList);
2102 HRESULT hr = pIMsRdpClientAdvancedSettings->get_PerformanceFlags(pDisableList);
2103 dbgprintf(TEXT("CAdvancedSettings::get_PerformanceFlags -> %08X, DisableList = %ld"), hr, *pDisableList);
2104 return hr;
2105 }
2106
2107 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ConnectWithEndpoint(VARIANT * rhs)
2108 {
2109 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
2110 dbgprintf(TEXT("CAdvancedSettings::put_ConnectWithEndpoint(%s)"), VariantToString(*rhs).c_str());
2111 HRESULT hr = pIMsRdpClientAdvancedSettings->put_ConnectWithEndpoint(rhs);
2112 dbgprintf(TEXT("CAdvancedSettings::put_ConnectWithEndpoint -> %08X"), hr);
2113 return hr;
2114 }
2115
2116 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_NotifyTSPublicKey(VARIANT_BOOL pfNotify)
2117 {
2118 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
2119 dbgprintf(TEXT("CAdvancedSettings::put_NotifyTSPublicKey(%s)"), BooleanToString(pfNotify));
2120 HRESULT hr = pIMsRdpClientAdvancedSettings->put_NotifyTSPublicKey(pfNotify);
2121 dbgprintf(TEXT("CAdvancedSettings::put_NotifyTSPublicKey -> %08X"), hr);
2122 return hr;
2123 }
2124
2125 virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_NotifyTSPublicKey(VARIANT_BOOL * pfNotify)
2126 {
2127 IMsRdpClientAdvancedSettings * pIMsRdpClientAdvancedSettings = getIMsRdpClientAdvancedSettings();
2128 dbgprintf(TEXT("CAdvancedSettings::get_NotifyTSPublicKey(%p)"), pfNotify);
2129 HRESULT hr = pIMsRdpClientAdvancedSettings->get_NotifyTSPublicKey(pfNotify);
2130 dbgprintf(TEXT("CAdvancedSettings::get_NotifyTSPublicKey -> %08X, fNotify = %s"), hr, BooleanToString(*pfNotify));
2131 return hr;
2132 }
2133
2134 /* IMsRdpClientAdvancedSettings2 */
2135 virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::get_CanAutoReconnect(VARIANT_BOOL * pfCanAutoReconnect)
2136 {
2137 IMsRdpClientAdvancedSettings2 * pIMsRdpClientAdvancedSettings2 = getIMsRdpClientAdvancedSettings2();
2138 dbgprintf(TEXT("CAdvancedSettings::get_CanAutoReconnect(%p)"), pfCanAutoReconnect);
2139 HRESULT hr = pIMsRdpClientAdvancedSettings2->get_CanAutoReconnect(pfCanAutoReconnect);
2140 dbgprintf(TEXT("CAdvancedSettings::get_CanAutoReconnect -> %08X, fCanAutoReconnect = %s"), hr, BooleanToString(*pfCanAutoReconnect));
2141 return hr;
2142 }
2143
2144 virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::put_EnableAutoReconnect(VARIANT_BOOL pfEnableAutoReconnect)
2145 {
2146 IMsRdpClientAdvancedSettings2 * pIMsRdpClientAdvancedSettings2 = getIMsRdpClientAdvancedSettings2();
2147 dbgprintf(TEXT("CAdvancedSettings::put_EnableAutoReconnect(%s)"), BooleanToString(pfEnableAutoReconnect));
2148 HRESULT hr = pIMsRdpClientAdvancedSettings2->put_EnableAutoReconnect(pfEnableAutoReconnect);
2149 dbgprintf(TEXT("CAdvancedSettings::put_EnableAutoReconnect -> %08X"), hr);
2150 return hr;
2151 }
2152
2153 virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::get_EnableAutoReconnect(VARIANT_BOOL * pfEnableAutoReconnect)
2154 {
2155 IMsRdpClientAdvancedSettings2 * pIMsRdpClientAdvancedSettings2 = getIMsRdpClientAdvancedSettings2();
2156 dbgprintf(TEXT("CAdvancedSettings::get_EnableAutoReconnect(%p)"), pfEnableAutoReconnect);
2157 HRESULT hr = pIMsRdpClientAdvancedSettings2->get_EnableAutoReconnect(pfEnableAutoReconnect);
2158 dbgprintf(TEXT("CAdvancedSettings::get_EnableAutoReconnect -> %08X, fEnableAutoReconnect = %s"), hr, BooleanToString(*pfEnableAutoReconnect));
2159 return hr;
2160 }
2161
2162 virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::put_MaxReconnectAttempts(long pMaxReconnectAttempts)
2163 {
2164 IMsRdpClientAdvancedSettings2 * pIMsRdpClientAdvancedSettings2 = getIMsRdpClientAdvancedSettings2();
2165 dbgprintf(TEXT("CAdvancedSettings::put_MaxReconnectAttempts(%ld)"), pMaxReconnectAttempts);
2166 HRESULT hr = pIMsRdpClientAdvancedSettings2->put_MaxReconnectAttempts(pMaxReconnectAttempts);
2167 dbgprintf(TEXT("CAdvancedSettings::put_MaxReconnectAttempts -> %08X"), hr);
2168 return hr;
2169 }
2170
2171 virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::get_MaxReconnectAttempts(long * pMaxReconnectAttempts)
2172 {
2173 IMsRdpClientAdvancedSettings2 * pIMsRdpClientAdvancedSettings2 = getIMsRdpClientAdvancedSettings2();
2174 dbgprintf(TEXT("CAdvancedSettings::get_MaxReconnectAttempts(%p)"), pMaxReconnectAttempts);
2175 HRESULT hr = pIMsRdpClientAdvancedSettings2->get_MaxReconnectAttempts(pMaxReconnectAttempts);
2176 dbgprintf(TEXT("CAdvancedSettings::get_MaxReconnectAttempts -> %08X, MaxReconnectAttempts = %ld"), hr, *pMaxReconnectAttempts);
2177 return hr;
2178 }
2179
2180 /* IMsRdpClientAdvancedSettings3 */
2181 virtual STDMETHODIMP IMsRdpClientAdvancedSettings3::put_ConnectionBarShowMinimizeButton(VARIANT_BOOL pfShowMinimize)
2182 {
2183 IMsRdpClientAdvancedSettings3 * pIMsRdpClientAdvancedSettings3 = getIMsRdpClientAdvancedSettings3();
2184 dbgprintf(TEXT("CAdvancedSettings::put_ConnectionBarShowMinimizeButton(%s)"), BooleanToString(pfShowMinimize));
2185 HRESULT hr = pIMsRdpClientAdvancedSettings3->put_ConnectionBarShowMinimizeButton(pfShowMinimize);
2186 dbgprintf(TEXT("CAdvancedSettings::put_ConnectionBarShowMinimizeButton -> %08X"), hr);
2187 return hr;
2188 }
2189
2190 virtual STDMETHODIMP IMsRdpClientAdvancedSettings3::get_ConnectionBarShowMinimizeButton(VARIANT_BOOL * pfShowMinimize)
2191 {
2192 IMsRdpClientAdvancedSettings3 * pIMsRdpClientAdvancedSettings3 = getIMsRdpClientAdvancedSettings3();
2193 dbgprintf(TEXT("CAdvancedSettings::get_ConnectionBarShowMinimizeButton(%p)"), pfShowMinimize);
2194 HRESULT hr = pIMsRdpClientAdvancedSettings3->get_ConnectionBarShowMinimizeButton(pfShowMinimize);
2195 dbgprintf(TEXT("CAdvancedSettings::get_ConnectionBarShowMinimizeButton -> %08X, fShowMinimize = %s"), hr, BooleanToString(*pfShowMinimize));
2196 return hr;
2197 }
2198
2199 virtual STDMETHODIMP IMsRdpClientAdvancedSettings3::put_ConnectionBarShowRestoreButton(VARIANT_BOOL pfShowRestore)
2200 {
2201 IMsRdpClientAdvancedSettings3 * pIMsRdpClientAdvancedSettings3 = getIMsRdpClientAdvancedSettings3();
2202 dbgprintf(TEXT("CAdvancedSettings::put_ConnectionBarShowRestoreButton(%s)"), BooleanToString(pfShowRestore));
2203 HRESULT hr = pIMsRdpClientAdvancedSettings3->put_ConnectionBarShowRestoreButton(pfShowRestore);
2204 dbgprintf(TEXT("CAdvancedSettings::put_ConnectionBarShowRestoreButton -> %08X"), hr);
2205 return hr;
2206 }
2207
2208 virtual STDMETHODIMP IMsRdpClientAdvancedSettings3::get_ConnectionBarShowRestoreButton(VARIANT_BOOL * pfShowRestore)
2209 {
2210 IMsRdpClientAdvancedSettings3 * pIMsRdpClientAdvancedSettings3 = getIMsRdpClientAdvancedSettings3();
2211 dbgprintf(TEXT("CAdvancedSettings::get_ConnectionBarShowRestoreButton(%p)"), pfShowRestore);
2212 HRESULT hr = pIMsRdpClientAdvancedSettings3->get_ConnectionBarShowRestoreButton(pfShowRestore);
2213 dbgprintf(TEXT("CAdvancedSettings::get_ConnectionBarShowRestoreButton -> %08X, fShowRestore = %s"), hr, BooleanToString(*pfShowRestore));
2214 return hr;
2215 }
2216
2217 /* IMsRdpClientAdvancedSettings4 */
2218 virtual STDMETHODIMP IMsRdpClientAdvancedSettings4::put_AuthenticationLevel(unsigned int puiAuthLevel)
2219 {
2220 IMsRdpClientAdvancedSettings4 * pIMsRdpClientAdvancedSettings4 = getIMsRdpClientAdvancedSettings4();
2221 dbgprintf(TEXT("CAdvancedSettings::put_AuthenticationLevel(%u)"), puiAuthLevel);
2222 HRESULT hr = pIMsRdpClientAdvancedSettings4->put_AuthenticationLevel(puiAuthLevel);
2223 dbgprintf(TEXT("CAdvancedSettings::put_AuthenticationLevel -> %08X"), hr);
2224 return hr;
2225 }
2226 virtual STDMETHODIMP IMsRdpClientAdvancedSettings4::get_AuthenticationLevel(unsigned int * puiAuthLevel)
2227 {
2228 IMsRdpClientAdvancedSettings4 * pIMsRdpClientAdvancedSettings4 = getIMsRdpClientAdvancedSettings4();
2229 dbgprintf(TEXT("CAdvancedSettings::get_AuthenticationLevel(%p)"), puiAuthLevel);
2230 HRESULT hr = pIMsRdpClientAdvancedSettings4->get_AuthenticationLevel(puiAuthLevel);
2231 dbgprintf(TEXT("CAdvancedSettings::get_AuthenticationLevel -> %08X, uiAuthLevel = %ld"), hr, *puiAuthLevel);
2232 return hr;
2233 }
2234 };
2235
2236 class CoClass:
2237 /* Standard interfaces */
2238 public IUnknown,
2239 public IDispatch,
2241 public IDataObject,
2242 public IObjectSafety,
2243 public IOleControl,
2245 public IOleInPlaceObject,
2246 public IOleObject,
2247 public IOleWindow,
2248 public IPersist,
2249 public IPersistPropertyBag,
2250 public IPersistStorage,
2251 public IPersistStreamInit,
2252 public IProvideClassInfo,
2253 public IProvideClassInfo2,
2254 public IQuickActivate,
2255 public ISpecifyPropertyPages,
2256 public IViewObject,
2257 public IViewObject2,
2258
2259 /* RDP client interfaces */
2260 public IMsRdpClient4,
2262 {
2263 private:
2265
2267
2287
2296
2298 {
2299 if(m_IDispatch)
2300 return m_IDispatch;
2301
2302 if(m_IMsRdpClient)
2303 m_IDispatch = m_IMsRdpClient;
2304 else if(m_IMsRdpClient2)
2305 m_IDispatch = m_IMsRdpClient2;
2306 else if(m_IMsRdpClient3)
2307 m_IDispatch = m_IMsRdpClient3;
2308 else if(m_IMsRdpClient4)
2309 m_IDispatch = m_IMsRdpClient4;
2310 else if(m_IMsTscAx)
2311 m_IDispatch = m_IMsTscAx;
2312
2313 if(m_IDispatch)
2314 {
2315 m_IDispatch->AddRef();
2316 return m_IDispatch;
2317 }
2318
2319 if(SUCCEEDED(m_IUnknown->QueryInterface(&m_IDispatch)))
2320 return m_IDispatch;
2321
2322 return NULL;
2323 }
2324
2326 {
2327 if(m_IConnectionPointContainer)
2328 return m_IConnectionPointContainer;
2329
2330 m_IUnknown->QueryInterface(&m_IConnectionPointContainer);
2331 return m_IConnectionPointContainer;
2332
2333 }
2334
2336 {
2337 if(m_IDataObject)
2338 return m_IDataObject;
2339
2340 m_IUnknown->QueryInterface(&m_IDataObject);
2341 return m_IDataObject;
2342 }
2343
2345 {
2346 if(m_IObjectSafety)
2347 return m_IObjectSafety;
2348
2349 m_IUnknown->QueryInterface(&m_IObjectSafety);
2350 return m_IObjectSafety;
2351 }
2352
2354 {
2355 if(m_IOleControl)
2356 return m_IOleControl;
2357
2358 m_IUnknown->QueryInterface(&m_IOleControl);
2359 return m_IOleControl;
2360 }
2361
2363 {
2364 if(m_IOleInPlaceActiveObject)
2365 return m_IOleInPlaceActiveObject;
2366
2367 m_IUnknown->QueryInterface(&m_IOleInPlaceActiveObject);
2368 return m_IOleInPlaceActiveObject;
2369 }
2370
2372 {
2373 if(m_IOleInPlaceObject)
2374 return m_IOleInPlaceObject;
2375
2376 m_IUnknown->QueryInterface(&m_IOleInPlaceObject);
2377 return m_IOleInPlaceObject;
2378 }
2379
2381 {
2382 if(m_IOleObject)
2383 return m_IOleObject;
2384
2385 m_IUnknown->QueryInterface(&m_IOleObject);
2386 return m_IOleObject;
2387 }
2388
2390 {
2391 if(m_IOleWindow)
2392 return m_IOleWindow;
2393
2394 if(m_IOleInPlaceActiveObject)
2395 m_IOleWindow = m_IOleInPlaceActiveObject;
2396
2397 if(m_IOleWindow)
2398 {
2399 m_IOleWindow->AddRef();
2400 return m_IOleWindow;
2401 }
2402
2403 m_IUnknown->QueryInterface(&m_IOleWindow);
2404 return m_IOleWindow;
2405 }
2406
2408 {
2409 if(m_IPersist)
2410 return m_IPersist;
2411
2412 if(m_IPersistPropertyBag)
2413 m_IPersist = m_IPersistPropertyBag;
2414 else if(m_IPersistStorage)
2415 m_IPersist = m_IPersistStorage;
2416 else if(m_IPersistStreamInit)
2417 m_IPersist = m_IPersistStreamInit;
2418
2419 if(m_IPersist)
2420 {
2421 m_IPersist->AddRef();
2422 return m_IPersist;
2423 }
2424
2425 m_IUnknown->QueryInterface(&m_IPersist);
2426 return m_IPersist;
2427 }
2428
2430 {
2431 if(m_IPersistPropertyBag)
2432 return m_IPersistPropertyBag;
2433
2434 m_IUnknown->QueryInterface(&m_IPersistPropertyBag);
2435 return m_IPersistPropertyBag;
2436 }
2437
2439 {
2440 if(m_IPersistStorage)
2441 return m_IPersistStorage;
2442
2443 m_IUnknown->QueryInterface(&m_IPersistStorage);
2444 return m_IPersistStorage;
2445 }
2446
2448 {
2449 if(m_IPersistStreamInit)
2450 return m_IPersistStreamInit;
2451
2452 m_IUnknown->QueryInterface(&m_IPersistStreamInit);
2453 return m_IPersistStreamInit;
2454 }
2455
2457 {
2458 if(m_IProvideClassInfo)
2459 return m_IProvideClassInfo;
2460
2461 if(m_IProvideClassInfo2)
2462 m_IProvideClassInfo = m_IProvideClassInfo2;
2463
2464 if(m_IProvideClassInfo)
2465 {
2466 m_IProvideClassInfo->AddRef();
2467 return m_IProvideClassInfo;
2468 }
2469
2470 m_IUnknown->QueryInterface(&m_IProvideClassInfo);
2471 return m_IProvideClassInfo;
2472 }
2473
2475 {
2476 if(m_IProvideClassInfo2)
2477 return m_IProvideClassInfo2;
2478
2479 m_IUnknown->QueryInterface(&m_IProvideClassInfo2);
2480 return m_IProvideClassInfo2;
2481 }
2482
2484 {
2485 if(m_IQuickActivate)
2486 return m_IQuickActivate;
2487
2488 m_IUnknown->QueryInterface(&m_IQuickActivate);
2489 return m_IQuickActivate;
2490 }
2491
2493 {
2494 if(m_ISpecifyPropertyPages)
2495 return m_ISpecifyPropertyPages;
2496
2497 m_IUnknown->QueryInterface(&m_ISpecifyPropertyPages);
2498 return m_ISpecifyPropertyPages;
2499 }
2500
2502 {
2503 if(m_IViewObject)
2504 return m_IViewObject;
2505
2506 if(m_IViewObject2)
2507 m_IViewObject = m_IViewObject2;
2508
2509 if(m_IViewObject)
2510 {
2511 m_IViewObject->AddRef();
2512 return m_IViewObject;
2513 }
2514
2515 m_IUnknown->QueryInterface(&m_IViewObject);
2516 return m_IViewObject;
2517 }
2518
2520 {
2521 if(m_IViewObject2)
2522 return m_IViewObject2;
2523
2524 m_IUnknown->QueryInterface(&m_IViewObject2);
2525 return m_IViewObject2;
2526 }
2527
2529 {
2530 if(m_IMsRdpClient)
2531 return m_IMsRdpClient;
2532
2533 if(m_IMsRdpClient2)
2534 m_IMsRdpClient = m_IMsRdpClient2;
2535 else if(m_IMsRdpClient3)
2536 m_IMsRdpClient = m_IMsRdpClient3;
2537 else if(m_IMsRdpClient4)
2538 m_IMsRdpClient = m_IMsRdpClient4;
2539
2540 if(m_IMsRdpClient)
2541 {
2542 m_IMsRdpClient->AddRef();
2543 return m_IMsRdpClient;
2544 }
2545
2546 m_IUnknown->QueryInterface(&m_IMsRdpClient);
2547 return m_IMsRdpClient;
2548 }
2549
2551 {
2552 if(m_IMsRdpClient2)
2553 return m_IMsRdpClient2;
2554
2555 if(m_IMsRdpClient3)
2556 m_IMsRdpClient2 = m_IMsRdpClient3;
2557 else if(m_IMsRdpClient4)
2558 m_IMsRdpClient2 = m_IMsRdpClient4;
2559
2560 if(m_IMsRdpClient2)
2561 {
2562 m_IMsRdpClient2->AddRef();
2563 return m_IMsRdpClient2;
2564 }
2565
2566 m_IUnknown->QueryInterface(&m_IMsRdpClient2);
2567 return m_IMsRdpClient2;
2568 }
2569
2571 {
2572 if(m_IMsRdpClient3)
2573 return m_IMsRdpClient3;
2574
2575 if(m_IMsRdpClient4)
2576 m_IMsRdpClient3 = m_IMsRdpClient4;
2577
2578 if(m_IMsRdpClient3)
2579 {
2580 m_IMsRdpClient3->AddRef();
2581 return m_IMsRdpClient3;
2582 }
2583
2584 m_IUnknown->QueryInterface(&m_IMsRdpClient3);
2585 return m_IMsRdpClient3;
2586 }
2587
2589 {
2590 if(m_IMsRdpClient4)
2591 return m_IMsRdpClient4;
2592
2593 m_IUnknown->QueryInterface(&m_IMsRdpClient4);
2594 return m_IMsRdpClient4;
2595 }
2596
2598 {
2599 if(m_IMsTscAx)
2600 return m_IMsTscAx;
2601
2602 if(m_IMsRdpClient)
2603 m_IMsTscAx = m_IMsRdpClient;
2604 else if(m_IMsRdpClient2)
2605 m_IMsTscAx = m_IMsRdpClient2;
2606 else if(m_IMsRdpClient3)
2607 m_IMsTscAx = m_IMsRdpClient3;
2608 else if(m_IMsRdpClient4)
2609 m_IMsTscAx = m_IMsRdpClient4;
2610
2611 if(m_IMsTscAx)
2612 {
2613 m_IMsTscAx->AddRef();
2614 return m_IMsTscAx;
2615 }
2616
2617 m_IUnknown->QueryInterface(&m_IMsTscAx);
2618 return m_IMsTscAx;
2619 }
2620
2622 {
2623 if(m_IMsTscNonScriptable)
2624 return m_IMsTscNonScriptable;
2625
2626 if(m_IMsRdpClientNonScriptable)
2627 m_IMsTscNonScriptable = m_IMsRdpClientNonScriptable;
2628 else if(m_IMsRdpClientNonScriptable2)
2629 m_IMsTscNonScriptable = m_IMsRdpClientNonScriptable2;
2630
2631 if(m_IMsTscNonScriptable)
2632 {
2633 m_IMsTscNonScriptable->AddRef();
2634 return m_IMsTscNonScriptable;
2635 }
2636
2637 m_IUnknown->QueryInterface(&m_IMsTscNonScriptable);
2638 return m_IMsTscNonScriptable;
2639 }
2640
2642 {
2643 if(m_IMsRdpClientNonScriptable)
2644 return m_IMsRdpClientNonScriptable;
2645
2646 if(m_IMsRdpClientNonScriptable2)
2647 m_IMsRdpClientNonScriptable = m_IMsRdpClientNonScriptable2;
2648
2649 if(m_IMsRdpClientNonScriptable)
2650 {
2651 m_IMsRdpClientNonScriptable->AddRef();
2652 return m_IMsRdpClientNonScriptable;
2653 }
2654
2655 m_IUnknown->QueryInterface(&m_IMsRdpClientNonScriptable);
2656 return m_IMsRdpClientNonScriptable;
2657 }
2658
2660 {
2661 if(m_IMsRdpClientNonScriptable2)
2662 return m_IMsRdpClientNonScriptable2;
2663
2664 m_IUnknown->QueryInterface(&m_IMsRdpClientNonScriptable2);
2665 return m_IMsRdpClientNonScriptable2;
2666 }
2667
2668 private:
2670
2672 {
2673 HRESULT hr;
2674 IUnknown * pvObject = NULL;
2675
2676 dbgprintf(TEXT("IUnknown::QueryInterface(%ls, %p)"), UUIDToString(riid).c_str(), ppvObject);
2677
2678#define QIBEGIN() \
2679 if(riid == IID_IUnknown) \
2680 { \
2681 assert(0); \
2682 }
2683
2684#define QI(I) \
2685 else if(riid == IID_ ## I) \
2686 { \
2687 if(m_ ## I) \
2688 { \
2689 m_ ## I->AddRef(); \
2690 hr = S_OK; \
2691 } \
2692 else \
2693 { \
2694 hr = m_IUnknown->QueryInterface(&m_ ## I); \
2695 } \
2696 \
2697 if(SUCCEEDED(hr)) \
2698 pvObject = static_cast<I *>(this); \
2699 }
2700
2701#define QIEND() \
2702 else \
2703 { \
2704 hr = E_NOINTERFACE; \
2705 pvObject = NULL; \
2706 }
2707
2708 QIBEGIN()
2709
2710 /* Standard interfaces */
2711 QI(IDispatch)
2718 QI(IOleObject)
2719 QI(IOleWindow)
2720 QI(IPersist)
2730
2731 /* Terminal services client */
2736 QI(IMsTscAx)
2740 QIEND()
2741
2742#undef QIBEGIN
2743#undef QIEND
2744#undef QI
2745
2746 if(SUCCEEDED(hr))
2747 {
2748 assert(pvObject);
2749 pvObject->AddRef();
2750 }
2751 else
2752 {
2753 assert(pvObject == NULL);
2754 }
2755
2756 *ppvObject = pvObject;
2757
2758 dbgprintf(TEXT("IUnknown::QueryInterface -> %08X, ppvObject = %p"), hr, *ppvObject);
2759 return hr;
2760 }
2761
2763 {
2764 return InterlockedIncrement(&m_refCount);
2765 }
2766
2768 {
2769 LONG n = InterlockedDecrement(&m_refCount);
2770
2771 if(n == 0)
2772 delete this;
2773
2774 return n;
2775 }
2776
2777 friend class CoClassInner;
2778
2780 {
2781 public:
2783 {
2784 if(riid == IID_IUnknown)
2785 {
2786 AddRef();
2787 *ppvObject = this;
2788 return S_OK;
2789 }
2790
2791 return InnerToOuter(this)->queryInterface(riid, ppvObject);
2792 }
2793
2795 {
2796 return InnerToOuter(this)->addRef();
2797 }
2798
2800 {
2801 return InnerToOuter(this)->release();
2802 }
2803 }
2805
2807 {
2808 return CONTAINING_RECORD(inner, CoClass, m_inner);
2809 }
2810
2811 private:
2812 CoClass(IUnknown * pUnknw, IUnknown * pUnkOuter):
2813 m_refCount(1),
2814 m_outer(pUnkOuter),
2815 m_IUnknown(pUnknw),
2816 m_IDispatch(NULL),
2817 m_IConnectionPointContainer(NULL),
2818 m_IDataObject(NULL),
2819 m_IObjectSafety(NULL),
2820 m_IOleControl(NULL),
2821 m_IOleInPlaceActiveObject(NULL),
2822 m_IOleInPlaceObject(NULL),
2823 m_IOleObject(NULL),
2824 m_IOleWindow(NULL),
2825 m_IPersist(NULL),
2826 m_IPersistPropertyBag(NULL),
2827 m_IPersistStorage(NULL),
2828 m_IPersistStreamInit(NULL),
2829 m_IProvideClassInfo(NULL),
2830 m_IProvideClassInfo2(NULL),
2831 m_IQuickActivate(NULL),
2832 m_ISpecifyPropertyPages(NULL),
2833 m_IViewObject(NULL),
2834 m_IViewObject2(NULL),
2835 m_IMsRdpClient(NULL),
2836 m_IMsRdpClient2(NULL),
2837 m_IMsRdpClient3(NULL),
2838 m_IMsRdpClient4(NULL),
2839 m_IMsTscAx(NULL),
2840 m_IMsTscNonScriptable(NULL),
2841 m_IMsRdpClientNonScriptable(NULL),
2842 m_IMsRdpClientNonScriptable2(NULL)
2843 {
2844 if(m_outer == NULL)
2845 m_outer = &m_inner;
2846 }
2847
2848 public:
2849 static HRESULT CreateInstance(IUnknown * pUnknw, IUnknown * pUnkOuter, REFIID riid, void ** ppvObject)
2850 {
2851 HRESULT hr = S_OK;
2852
2853 if(pUnkOuter && riid != IID_IUnknown)
2855 else
2856 {
2857 CoClass * p = new CoClass(pUnknw, pUnkOuter);
2858
2859 if(p == NULL)
2860 hr = E_OUTOFMEMORY;
2861 else
2862 {
2863 hr = p->m_inner.QueryInterface(riid, ppvObject);
2864
2865 if(FAILED(hr))
2866 delete p;
2867 else
2868 p->m_inner.Release();
2869 }
2870 }
2871
2872 if(FAILED(hr))
2873 pUnknw->Release();
2874
2875 return hr;
2876 }
2877
2878 private:
2880 {
2881 if(m_IUnknown)
2882 m_IUnknown->Release();
2883
2884 if(m_IDispatch)
2885 m_IDispatch->Release();
2886
2887 if(m_IConnectionPointContainer)
2888 m_IConnectionPointContainer->Release();
2889
2890 if(m_IDataObject)
2891 m_IDataObject->Release();
2892
2893 if(m_IObjectSafety)
2894 m_IObjectSafety->Release();
2895
2896 if(m_IOleControl)
2897 m_IOleControl->Release();
2898
2899 if(m_IOleInPlaceActiveObject)
2900 m_IOleInPlaceActiveObject->Release();
2901
2902 if(m_IOleInPlaceObject)
2903 m_IOleInPlaceObject->Release();
2904
2905 if(m_IOleObject)
2906 m_IOleObject->Release();
2907
2908 if(m_IOleWindow)
2909 m_IOleWindow->Release();
2910
2911 if(m_IPersist)
2912 m_IPersist->Release();
2913
2914 if(m_IPersistPropertyBag)
2915 m_IPersistPropertyBag->Release();
2916
2917 if(m_IPersistStorage)
2918 m_IPersistStorage->Release();
2919
2920 if(m_IPersistStreamInit)
2921 m_IPersistStreamInit->Release();
2922
2923 if(m_IProvideClassInfo)
2924 m_IProvideClassInfo->Release();
2925
2926 if(m_IProvideClassInfo2)
2927 m_IProvideClassInfo2->Release();
2928
2929 if(m_IQuickActivate)
2930 m_IQuickActivate->Release();
2931
2932 if(m_ISpecifyPropertyPages)
2933 m_ISpecifyPropertyPages->Release();
2934
2935 if(m_IViewObject)
2936 m_IViewObject->Release();
2937
2938 if(m_IViewObject2)
2939 m_IViewObject2->Release();
2940
2941 if(m_IMsRdpClient)
2942 m_IMsRdpClient->Release();
2943
2944 if(m_IMsRdpClient2)
2945 m_IMsRdpClient2->Release();
2946
2947 if(m_IMsRdpClient3)
2948 m_IMsRdpClient3->Release();
2949
2950 if(m_IMsRdpClient4)
2951 m_IMsRdpClient4->Release();
2952
2953 if(m_IMsTscAx)
2954 m_IMsTscAx->Release();
2955
2956 if(m_IMsTscNonScriptable)
2957 m_IMsTscNonScriptable->Release();
2958
2959 if(m_IMsRdpClientNonScriptable)
2960 m_IMsRdpClientNonScriptable->Release();
2961
2962 if(m_IMsRdpClientNonScriptable2)
2963 m_IMsRdpClientNonScriptable2->Release();
2964 }
2965
2966 /* IUnknown */
2967 public:
2969 {
2970 return m_outer->QueryInterface(riid, ppvObject);
2971 }
2972
2974 {
2975 return m_outer->AddRef();
2976 }
2977
2979 {
2980 return m_outer->Release();
2981 }
2982
2983 /* IDispatch */
2984 private:
2985 static void FreeExcepInfo(const EXCEPINFO& excepInfo)
2986 {
2987 if(excepInfo.bstrSource)
2988 SysFreeString(excepInfo.bstrSource);
2989
2990 if(excepInfo.bstrDescription)
2991 SysFreeString(excepInfo.bstrDescription);
2992
2993 if(excepInfo.bstrHelpFile)
2994 SysFreeString(excepInfo.bstrHelpFile);
2995 }
2996
2997 static std::basic_string<TCHAR> ExcepInfoToString(const EXCEPINFO& excepInfo)
2998 {
2999 std::basic_ostringstream<TCHAR> o;
3000
3001 o << "{";
3002 o << " code: " << excepInfo.wCode << " from: " << std::basic_string<OLECHAR>(excepInfo.bstrSource, excepInfo.bstrSource + SysStringLen(excepInfo.bstrSource));
3003
3004 BSTR bstrDescription = NULL;
3005
3006 if(excepInfo.bstrDescription)
3007 bstrDescription = excepInfo.bstrDescription;
3008 else if(excepInfo.pfnDeferredFillIn)
3009 {
3010 EXCEPINFO excepInfoCopy = excepInfo;
3011
3012 if(SUCCEEDED(excepInfoCopy.pfnDeferredFillIn(&excepInfoCopy)) && excepInfoCopy.bstrDescription)
3013 {
3014 bstrDescription = excepInfoCopy.bstrDescription;
3015 excepInfoCopy.bstrDescription = NULL;
3016 }
3017
3018 if(excepInfoCopy.bstrSource == excepInfo.bstrSource)
3019 excepInfoCopy.bstrSource = NULL;
3020
3021 if(excepInfoCopy.bstrHelpFile == excepInfo.bstrDescription)
3022 excepInfoCopy.bstrDescription = NULL;
3023
3024 FreeExcepInfo(excepInfoCopy);
3025 }
3026
3027 if(bstrDescription)
3028 {
3029 o << " msg: " << std::basic_string<OLECHAR>(bstrDescription, bstrDescription + SysStringLen(bstrDescription));
3030
3031 if(excepInfo.bstrDescription == NULL)
3032 SysFreeString(bstrDescription);
3033 }
3034
3035 o << " }";
3036
3037 return o.str().c_str();
3038 }
3039
3040 public:
3042 {
3043 IDispatch * pIDispatch = getIDispatch();
3044 dbgprintf(TEXT("IDispatch::GetTypeInfoCount(%p)"), pctinfo);
3045 HRESULT hr = pIDispatch->GetTypeInfoCount(pctinfo);
3046 dbgprintf(TEXT("IDispatch::GetTypeInfoCount -> %08X, ctinfo = %lu"), hr, *pctinfo);
3047 return hr;
3048 }
3049
3050 virtual HRESULT STDMETHODCALLTYPE GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo ** ppTInfo)
3051 {
3052 IDispatch * pIDispatch = getIDispatch();
3053 dbgprintf(TEXT("IDispatch::GetTypeInfo(%lu, %08X, %p)"), iTInfo, lcid, ppTInfo);
3054 HRESULT hr = pIDispatch->GetTypeInfo(iTInfo, lcid, ppTInfo);
3055 dbgprintf(TEXT("IDispatch::GetTypeInfo -> %08X, pTInfo = %p"), hr, *ppTInfo);
3056 return hr;
3057 }
3058
3059 virtual HRESULT STDMETHODCALLTYPE GetIDsOfNames(REFIID riid, LPOLESTR * rgszNames, UINT cNames, LCID lcid, DISPID * rgDispId)
3060 {
3061 IDispatch * pIDispatch = getIDispatch();
3062 std::wstring strtemp;
3063
3064 std::wostringstream strtempo;
3065
3066 strtemp.resize(0);
3067 strtemp += L"[ ";
3068
3069 for(UINT i = 0; i < cNames; ++ i)
3070 {
3071 if(i)
3072 strtemp += L", ";
3073
3074 strtemp += rgszNames[i];
3075 }
3076
3077 strtemp += L" ]";
3078
3079 dbgprintf(TEXT("IDispatch::GetIDsOfNames(%ls, %ls, %lu, %08X, %p)"), UUIDToString(riid).c_str(), strtemp.c_str(), cNames, lcid, rgDispId);
3080 HRESULT hr = pIDispatch->GetIDsOfNames(riid, rgszNames, cNames, lcid, rgDispId);
3081
3082 strtemp.resize(0);
3083 strtempo.str(strtemp);
3084
3085 strtempo << L"[ ";
3086
3087 for(UINT i = 0; i < cNames; ++ i)
3088 {
3089 if(i)
3090 strtempo << L", ";
3091
3092 strtempo << rgDispId[i];
3093 }
3094
3095 strtempo << L" ]";
3096
3097 dbgprintf(TEXT("IDispatch::GetIDsOfNames -> %08X, rgDispId = %ls"), hr, strtempo.str().c_str());
3098
3099 return hr;
3100 }
3101
3102 virtual HRESULT STDMETHODCALLTYPE Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pDispParams, VARIANT * pVarResult, EXCEPINFO * pExcepInfo, UINT * puArgErr)
3103 {
3104 IDispatch * pIDispatch = getIDispatch();
3105
3106 std::basic_ostringstream<TCHAR> strtempo;
3107
3108 strtempo << L"{";
3109
3110 for(unsigned int i = pDispParams->cArgs, j = pDispParams->cNamedArgs; j < pDispParams->cArgs; -- i, ++ j)
3111 {
3112 strtempo << L" ";
3113 strtempo << VariantToString(pDispParams->rgvarg[i - 1]);
3114 strtempo << L",";
3115 }
3116
3117 for(unsigned int i = pDispParams->cArgs - pDispParams->cNamedArgs; i > 0; -- i)
3118 {
3119 strtempo << L" ";
3120 strtempo << L"["; strtempo << pDispParams->rgdispidNamedArgs[i - 1]; strtempo << L"] => ";
3121 strtempo << VariantToString(pDispParams->rgvarg[i - 1]);
3122 strtempo << L",";
3123 }
3124
3125 strtempo << L" }";
3126
3127 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);
3128
3129 VARIANT VarResult = { };
3130 EXCEPINFO ExcepInfo = { };
3131
3132 if(pVarResult == NULL)
3133 pVarResult = &VarResult;
3134
3135 if(pExcepInfo == NULL)
3136 pExcepInfo = &ExcepInfo;
3137
3138 HRESULT hr = pIDispatch->Invoke(dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
3139
3140 dbgprintf(TEXT("IDispatch::Invoke -> %08X, returns %s, throws %s"), hr, VariantToString(*pVarResult).c_str(), ExcepInfoToString(*pExcepInfo).c_str());
3141
3142 FreeExcepInfo(ExcepInfo);
3143
3144 return hr;
3145 }
3146
3147 /* IConnectionPointContainer */
3148 public:
3150 {
3151 IConnectionPointContainer * pIConnectionPointContainer = getIConnectionPointContainer();
3152 dbgprintf(TEXT("IConnectionPointContainer::EnumConnectionPoints(%p)"), ppEnum);
3153 HRESULT hr = pIConnectionPointContainer->EnumConnectionPoints(ppEnum);
3154 dbgprintf(TEXT("IConnectionPointContainer::EnumConnectionPoints -> %08X, pEnum = %p"), hr, *ppEnum);
3155
3156 if(SUCCEEDED(hr))
3157 *ppEnum = HookIEnumConnectionPoints(*ppEnum);
3158
3159 return hr;
3160 }
3161
3163 {
3164 IConnectionPointContainer * pIConnectionPointContainer = getIConnectionPointContainer();
3165 dbgprintf(TEXT("IConnectionPointContainer::FindConnectionPoint(%ls, %p)"), UUIDToString(riid).c_str(), ppCP);
3166 HRESULT hr = pIConnectionPointContainer->FindConnectionPoint(riid, ppCP);
3167 dbgprintf(TEXT("IConnectionPointContainer::FindConnectionPoint -> %08X, pCP = %p"), hr, *ppCP);
3168
3169 if(SUCCEEDED(hr))
3170 *ppCP = HookIConnectionPoint(*ppCP);
3171
3172 return hr;
3173 }
3174
3175 /* IDataObject */
3176 private:
3177 static std::basic_string<TCHAR> TargetDeviceToString(const DVTARGETDEVICE& targetdev)
3178 {
3179 if(&targetdev == NULL)
3180 return TEXT("<null>");
3181
3182 std::basic_ostringstream<TCHAR> o;
3183
3184 o << "{";
3185 o << LPCWSTR(targetdev.tdData[targetdev.tdDriverNameOffset]);
3186
3187 if(targetdev.tdDeviceNameOffset)
3188 {
3189 o << ",";
3190 o << LPCWSTR(targetdev.tdData[targetdev.tdDeviceNameOffset]);
3191 }
3192
3193 if(targetdev.tdPortNameOffset)
3194 {
3195 o << ",";
3196 o << LPCWSTR(targetdev.tdData[targetdev.tdPortNameOffset]);
3197 }
3198
3199 o << " }";
3200
3201 return o.str();
3202 }
3203
3205 {
3206 switch(aspect)
3207 {
3208 case DVASPECT_CONTENT: return TEXT("content");
3209 case DVASPECT_THUMBNAIL: return TEXT("thumbnail");
3210 case DVASPECT_ICON: return TEXT("icon");
3211 case DVASPECT_DOCPRINT: return TEXT("printable");
3212 default: return TEXT("<unknown>");
3213 }
3214 }
3215
3217 {
3218 switch(tymed)
3219 {
3220 case TYMED_HGLOBAL: return TEXT("memory");
3221 case TYMED_FILE: return TEXT("file");
3222 case TYMED_ISTREAM: return TEXT("IStream");
3223 case TYMED_ISTORAGE: return TEXT("IStorage");
3224 case TYMED_GDI: return TEXT("bitmap");
3225 case TYMED_MFPICT: return TEXT("metafile");
3226 case TYMED_ENHMF: return TEXT("enhanced metafile");
3227 case TYMED_NULL: return TEXT("<no data>");
3228 default: return TEXT("<unknown>");
3229 }
3230 }
3231
3232 static std::basic_string<TCHAR> FormatEtcToString(const FORMATETC& formatetc)
3233 {
3234 std::basic_ostringstream<TCHAR> o;
3235
3236 o << "{";
3237
3238 // cfFormat
3239 o << " format: ";
3240
3241 switch(formatetc.cfFormat)
3242 {
3243 case CF_TEXT: o << "ANSI text"; break;
3244 case CF_BITMAP: o << "bitmap"; break;
3245 case CF_METAFILEPICT: o << "metafile"; break;
3246 case CF_SYLK: o << "symlink"; break;
3247 case CF_DIF: o << "DIF"; break;
3248 case CF_TIFF: o << "TIFF"; break;
3249 case CF_OEMTEXT: o << "OEM text"; break;
3250 case CF_DIB: o << "DIBv4"; break;
3251 case CF_PALETTE: o << "palette"; break;
3252 case CF_PENDATA: o << "pen data"; break;
3253 case CF_RIFF: o << "RIFF"; break;
3254 case CF_WAVE: o << "WAV"; break;
3255 case CF_UNICODETEXT: o << "Unicode text"; break;
3256 case CF_ENHMETAFILE: o << "enhanced metafile"; break;
3257 case CF_HDROP: o << "list of files"; break;
3258 case CF_LOCALE: o << "LCID"; break;
3259 case CF_DIBV5: o << "DIBv5"; break;
3260 case CF_OWNERDISPLAY: o << "<owner displayed>"; break;
3261 case CF_DSPTEXT: o << "<display text>"; break;
3262 case CF_DSPBITMAP: o << "<display bitmap>"; break;
3263 case CF_DSPMETAFILEPICT: o << "<display metafile>"; break;
3264 case CF_DSPENHMETAFILE: o << "<display enhanced metafile>"; break;
3265
3266 default:
3267 o << "<";
3268
3269 if(formatetc.cfFormat >= CF_PRIVATEFIRST && formatetc.cfFormat <= CF_PRIVATELAST)
3270 o << "private";
3271 else if(formatetc.cfFormat >= CF_GDIOBJFIRST && formatetc.cfFormat <= CF_GDIOBJLAST)
3272 o << "GDI object";
3273 else
3274 o << "unknown";
3275
3276 o << " " << std::hex << formatetc.cfFormat << std::dec << ">";
3277 }
3278
3279 // ptd
3280 if(formatetc.ptd)
3281 o << " device: " << TargetDeviceToString(*formatetc.ptd);
3282
3283 // dwAspect
3284 o << " aspect: " << AspectToString(formatetc.dwAspect);
3285
3286 // lindex
3287 if(formatetc.dwAspect == DVASPECT_CONTENT || formatetc.dwAspect == DVASPECT_DOCPRINT)
3288 o << " page split: " << formatetc.lindex;
3289
3290 // tymed
3291 o << " medium: " << TymedToString(formatetc.tymed);
3292
3293 return o.str();
3294 }
3295
3296 static std::basic_string<TCHAR> MediumToString(const STGMEDIUM& medium)
3297 {
3298 std::basic_ostringstream<TCHAR> o;
3299
3300 o << "{ ";
3301 o << TymedToString(medium.tymed);
3302 o << " }";
3303
3304 return o.str();
3305 }
3306
3307 public:
3308 virtual HRESULT STDMETHODCALLTYPE GetData(FORMATETC * pformatetcIn, STGMEDIUM * pmedium)
3309 {
3310 IDataObject * pIDataObject = getIDataObject();
3311 dbgprintf(TEXT("IDataObject::GetData(%s, %p)"), FormatEtcToString(*pformatetcIn).c_str(), pmedium);
3312 HRESULT hr = pIDataObject->GetData(pformatetcIn, pmedium);
3313 dbgprintf(TEXT("IDataObject::GetData -> %08X, %s"), hr, MediumToString(*pmedium).c_str());
3314 return hr;
3315 }
3316
3317 virtual HRESULT STDMETHODCALLTYPE GetDataHere(FORMATETC * pformatetc, STGMEDIUM * pmedium)
3318 {
3319 IDataObject * pIDataObject = getIDataObject();
3320 dbgprintf(TEXT("IDataObject::GetDataHere(%s, %p)"), FormatEtcToString(*pformatetc).c_str(), pmedium);
3321 HRESULT hr = pIDataObject->GetDataHere(pformatetc, pmedium);
3322 dbgprintf(TEXT("IDataObject::GetDataHere -> %08X, medium = %s"), hr, MediumToString(*pmedium).c_str());
3323 return hr;
3324 }
3325
3326 virtual HRESULT STDMETHODCALLTYPE QueryGetData(FORMATETC * pformatetc)
3327 {
3328 IDataObject * pIDataObject = getIDataObject();
3329 dbgprintf(TEXT("IDataObject::QueryGetData(%s)"), FormatEtcToString(*pformatetc).c_str());
3330 HRESULT hr = pIDataObject->QueryGetData(pformatetc);
3331 dbgprintf(TEXT("IDataObject::QueryGetData -> %08X"), hr);
3332 return hr;
3333 }
3334
3335 virtual HRESULT STDMETHODCALLTYPE GetCanonicalFormatEtc(FORMATETC * pformatectIn, FORMATETC * pformatetcOut)
3336 {
3337 IDataObject * pIDataObject = getIDataObject();
3338 dbgprintf(TEXT("IDataObject::GetCanonicalFormatEtc(%s, %p)"), FormatEtcToString(*pformatectIn).c_str(), pformatetcOut);
3339 HRESULT hr = pIDataObject->GetCanonicalFormatEtc(pformatectIn, pformatetcOut);
3340 dbgprintf(TEXT("IDataObject::GetCanonicalFormatEtc -> %08X, formatetcOut = %s"), hr, FormatEtcToString(*pformatetcOut).c_str());
3341 return hr;
3342 }
3343
3344 virtual HRESULT STDMETHODCALLTYPE SetData(FORMATETC * pformatetc, STGMEDIUM * pmedium, BOOL fRelease)
3345 {
3346 IDataObject * pIDataObject = getIDataObject();
3347 dbgprintf(TEXT("IDataObject::SetData(%s, %p, %s)"), FormatEtcToString(*pformatetc).c_str(), MediumToString(*pmedium).c_str(), fRelease ? TEXT("true") : TEXT("false"));
3348 HRESULT hr = pIDataObject->SetData(pformatetc, pmedium, fRelease);
3349 dbgprintf(TEXT("IDataObject::SetData -> %08X"), hr);
3350 return hr;
3351 }
3352
3353 virtual HRESULT STDMETHODCALLTYPE EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC ** ppenumFormatEtc)
3354 {
3355 IDataObject * pIDataObject = getIDataObject();
3356 dbgprintf(TEXT("IDataObject::EnumFormatEtc(%lu, %p)"), dwDirection, ppenumFormatEtc);
3357 HRESULT hr = pIDataObject->EnumFormatEtc(dwDirection, ppenumFormatEtc);
3358 dbgprintf(TEXT("IDataObject::EnumFormatEtc -> %08X, penumFormatEtc = %p"), hr, *ppenumFormatEtc);
3359 // TODO: hook
3360 return hr;
3361 }
3362
3363 virtual HRESULT STDMETHODCALLTYPE DAdvise(FORMATETC * pformatetc, DWORD advf, IAdviseSink * pAdvSink, DWORD * pdwConnection)
3364 {
3365 IDataObject * pIDataObject = getIDataObject();
3366 dbgprintf(TEXT("IDataObject::DAdvise(%s, %lu, %p, %p)"), FormatEtcToString(*pformatetc).c_str(), advf, pAdvSink, pdwConnection);
3367 HRESULT hr = pIDataObject->DAdvise(pformatetc, advf, pAdvSink, pdwConnection);
3368 dbgprintf(TEXT("IDataObject::DAdvise -> %08X, dwConnection = %lu"), hr, *pdwConnection);
3369 // TODO: hook
3370 return hr;
3371 }
3372
3374 {
3375 IDataObject * pIDataObject = getIDataObject();
3376 dbgprintf(TEXT("IDataObject::DUnadvise(%lu)"), dwConnection);
3377 HRESULT hr = pIDataObject->DUnadvise(dwConnection);
3378 dbgprintf(TEXT("IDataObject::DUnadvise -> %08X"), hr);
3379 return hr;
3380 }
3381
3383 {
3384 IDataObject * pIDataObject = getIDataObject();
3385 dbgprintf(TEXT("IDataObject::EnumDAdvise(%p)"), ppenumAdvise);
3386 HRESULT hr = pIDataObject->EnumDAdvise(ppenumAdvise);
3387 dbgprintf(TEXT("IDataObject::EnumDAdvise -> %08X, penumAdvise = %p"), hr, *ppenumAdvise);
3388 // TODO: hook
3389 return hr;
3390 }
3391
3392 /* IObjectSafety */
3393 public:
3394 virtual HRESULT STDMETHODCALLTYPE IObjectSafety::GetInterfaceSafetyOptions(REFIID riid, DWORD * pdwSupportedOptions, DWORD * pdwEnabledOptions)
3395 {
3396 IObjectSafety * pIObjectSafety = getIObjectSafety();
3397 dbgprintf(TEXT("IObjectSafety::GetInterfaceSafetyOptions(%ls, %p, %p)"), UUIDToString(riid).c_str(), pdwSupportedOptions, pdwEnabledOptions);
3398 HRESULT hr = pIObjectSafety->GetInterfaceSafetyOptions(riid, pdwSupportedOptions, pdwEnabledOptions);
3399 dbgprintf(TEXT("IObjectSafety::GetInterfaceSafetyOptions -> %08X, dwSupportedOptions = %08X, dwEnabledOptions = %08X"), hr, *pdwSupportedOptions, *pdwEnabledOptions);
3400 return hr;
3401 }
3402
3404 {
3405 IObjectSafety * pIObjectSafety = getIObjectSafety();
3406 dbgprintf(TEXT("IObjectSafety::SetInterfaceSafetyOptions(%ls, %08X, %08X)"), UUIDToString(riid).c_str(), dwOptionSetMask, dwEnabledOptions);
3407 HRESULT hr = pIObjectSafety->SetInterfaceSafetyOptions(riid, dwOptionSetMask, dwEnabledOptions);
3408 dbgprintf(TEXT("IObjectSafety::SetInterfaceSafetyOptions -> %08X"), hr);
3409 return hr;
3410 }
3411
3412 /* IOleControl */
3413 private:
3414 std::basic_string<TCHAR> ControlInfoToString(const CONTROLINFO& ci)
3415 {
3416 std::basic_ostringstream<TCHAR> o;
3417
3418 int firstdone = 0;
3419
3420 o << "{ ";
3421
3422 if(ci.cAccel && ci.hAccel)
3423 {
3424 LPACCEL pAccel = static_cast<LPACCEL>(GlobalLock(ci.hAccel));
3425
3426 if(pAccel)
3427 {
3428 for(USHORT i = 0; i < ci.cAccel; ++ i)
3429 {
3430 if(i)
3431 o << ", ";
3432
3433 if(pAccel[i].fVirt & FSHIFT)
3434 o << "SHIFT + ";
3435
3436 if(pAccel[i].fVirt & FCONTROL)
3437 o << "CONTROL + ";
3438
3439 if(pAccel[i].fVirt & FALT)
3440 o << "ALT + ";
3441
3442 if(pAccel[i].fVirt & FVIRTKEY)
3443 o << "<vkey:" << std::hex << pAccel[i].key << std::dec << ">";
3444 else
3445 o << wchar_t(pAccel[i].key);
3446
3447 o << " " << std::hex << pAccel[i].cmd << std::dec;
3448 }
3449
3450 firstdone = ci.cAccel;
3451
3452 GlobalUnlock(pAccel);
3453 }
3454 }
3455
3456 if(ci.dwFlags & CTRLINFO_EATS_RETURN)
3457 {
3458 if(!firstdone)
3459 {
3460 o << ", ";
3461 ++ firstdone;
3462 }
3463
3464 o << "ENTER";
3465 }
3466
3467 if(ci.dwFlags & CTRLINFO_EATS_ESCAPE)
3468 {
3469 if(!firstdone)
3470 {
3471 o << ", ";
3472 ++ firstdone;
3473 }
3474
3475 o << "ESC";
3476 }
3477
3478 if(firstdone)
3479 o << " ";
3480
3481 o << "}";
3482
3483 return o.str();
3484 }
3485
3486 std::basic_string<TCHAR> MnemonicToString(const MSG& msg)
3487 {
3488 std::basic_ostringstream<TCHAR> o;
3489
3490 o << "[";
3491
3492 switch(msg.message)
3493 {
3494 case WM_SYSKEYDOWN:
3495 o << "ALT + ";
3496
3497 case WM_KEYDOWN:
3498 TCHAR sz[1024];
3499 GetKeyNameText(LONG(msg.lParam), sz, ARRAYSIZE(sz));
3500 o << sz;
3501
3502 default:
3503 o << "<unknown message " << std::hex << msg.message << std::dec << ">";
3504 }
3505
3506 o << "]";
3507
3508 return o.str();
3509 }
3510
3511 public:
3513 {
3514 IOleControl * pIOleControl = getIOleControl();
3515 dbgprintf(TEXT("IOleControl::GetControlInfo(%p)"), pCI);
3516 HRESULT hr = pIOleControl->GetControlInfo(pCI);
3517 dbgprintf(TEXT("IOleControl::GetControlInfo -> %08X, %s"), hr, ControlInfoToString(*pCI).c_str());
3518 return hr;
3519 }
3520
3522 {
3523 IOleControl * pIOleControl = getIOleControl();
3524 dbgprintf(TEXT("IOleControl::OnMnemonic(%s)"), MnemonicToString(*pMsg).c_str());
3525 HRESULT hr = pIOleControl->OnMnemonic(pMsg);
3526 dbgprintf(TEXT("IOleControl::OnMnemonic -> %08X"), hr);
3527 return hr;
3528 }
3529
3531 {
3532 IOleControl * pIOleControl = getIOleControl();
3533 dbgprintf(TEXT("IOleControl::OnAmbientPropertyChange(%08X)"), dispID);
3534 HRESULT hr = pIOleControl->OnAmbientPropertyChange(dispID);
3535 dbgprintf(TEXT("IOleControl::OnAmbientPropertyChange -> %08X"), hr);
3536 return hr;
3537 }
3538
3540 {
3541 IOleControl * pIOleControl = getIOleControl();
3542 dbgprintf(TEXT("IOleControl::FreezeEvents(%s)"), BooleanToString(bFreeze));
3543 HRESULT hr = pIOleControl->FreezeEvents(bFreeze);
3544 dbgprintf(TEXT("IOleControl::FreezeEvents -> %08X"), hr);
3545 return hr;
3546 }
3547
3548 /* IOleInPlaceActiveObject */
3549 public:
3551 {
3552 IOleInPlaceActiveObject * pIOleInPlaceActiveObject = getIOleInPlaceActiveObject();
3553 dbgprintf(TEXT("IOleInPlaceActiveObject::TranslateAccelerator(%s)"), MnemonicToString(*lpmsg).c_str());
3554 HRESULT hr = pIOleInPlaceActiveObject->TranslateAccelerator(lpmsg);
3555 dbgprintf(TEXT("IOleInPlaceActiveObject::TranslateAccelerator -> %08X"), hr);
3556 return hr;
3557 }
3558
3560 {
3561 IOleInPlaceActiveObject * pIOleInPlaceActiveObject = getIOleInPlaceActiveObject();
3562 dbgprintf(TEXT("IOleInPlaceActiveObject::OnFrameWindowActivate(%s)"), BooleanToString(fActivate));
3563 HRESULT hr = pIOleInPlaceActiveObject->OnFrameWindowActivate(fActivate);
3564 dbgprintf(TEXT("IOleInPlaceActiveObject::OnFrameWindowActivate -> %08X"), hr);
3565 return hr;
3566 }
3567
3569 {
3570 IOleInPlaceActiveObject * pIOleInPlaceActiveObject = getIOleInPlaceActiveObject();
3571 dbgprintf(TEXT("IOleInPlaceActiveObject::OnDocWindowActivate(%s)"), BooleanToString(fActivate));
3572 HRESULT hr = pIOleInPlaceActiveObject->OnDocWindowActivate(fActivate);
3573 dbgprintf(TEXT("IOleInPlaceActiveObject::OnDocWindowActivate -> %08X"), hr);
3574 return hr;
3575 }
3576
3577 virtual HRESULT STDMETHODCALLTYPE ResizeBorder(LPCRECT prcBorder, IOleInPlaceUIWindow * pUIWindow, BOOL fFrameWindow)
3578 {
3579 // TODO: hook pUIWindow
3580 IOleInPlaceActiveObject * pIOleInPlaceActiveObject = getIOleInPlaceActiveObject();
3581 dbgprintf(TEXT("IOleInPlaceActiveObject::ResizeBorder(%s)"), RectToString(*prcBorder).c_str(), pUIWindow, BooleanToString(fFrameWindow));
3582 HRESULT hr = pIOleInPlaceActiveObject->ResizeBorder(prcBorder, pUIWindow, fFrameWindow);
3583 dbgprintf(TEXT("IOleInPlaceActiveObject::ResizeBorder -> %08X"), hr);
3584 return hr;
3585 }
3586
3588 {
3589 IOleInPlaceActiveObject * pIOleInPlaceActiveObject = getIOleInPlaceActiveObject();
3590 dbgprintf(TEXT("IOleInPlaceActiveObject::EnableModeless(%s)"), BooleanToString(fEnable));
3591 HRESULT hr = pIOleInPlaceActiveObject->EnableModeless(fEnable);
3592 dbgprintf(TEXT("IOleInPlaceActiveObject::EnableModeless -> %08X"), hr);
3593 return hr;
3594 }
3595
3596 /* IOleInPlaceObject */
3597 public:
3599 {
3600 IOleInPlaceObject * pIOleInPlaceObject = getIOleInPlaceObject();
3601 dbgprintf(TEXT("IOleInPlaceObject::InPlaceDeactivate()"));
3602 HRESULT hr = pIOleInPlaceObject->InPlaceDeactivate();
3603 dbgprintf(TEXT("IOleInPlaceObject::InPlaceDeactivate -> %08X"), hr);
3604 return hr;
3605 }
3606
3608 {
3609 IOleInPlaceObject * pIOleInPlaceObject = getIOleInPlaceObject();
3610 dbgprintf(TEXT("IOleInPlaceObject::UIDeactivate()"));
3611 HRESULT hr = pIOleInPlaceObject->UIDeactivate();
3612 dbgprintf(TEXT("IOleInPlaceObject::UIDeactivate -> %08X"), hr);
3613 return hr;
3614 }
3615
3616 virtual HRESULT STDMETHODCALLTYPE SetObjectRects(LPCRECT lprcPosRect, LPCRECT lprcClipRect)
3617 {
3618 IOleInPlaceObject * pIOleInPlaceObject = getIOleInPlaceObject();
3619 dbgprintf(TEXT("IOleInPlaceObject::SetObjectRects(%s, %s)"), RectToString(*lprcPosRect).c_str(), RectToString(*lprcClipRect).c_str());
3620 HRESULT hr = pIOleInPlaceObject->SetObjectRects(lprcPosRect, lprcClipRect);
3621 dbgprintf(TEXT("IOleInPlaceObject::SetObjectRects -> %08X"), hr);
3622 return hr;
3623 }
3624
3626 {
3627 IOleInPlaceObject * pIOleInPlaceObject = getIOleInPlaceObject();
3628 dbgprintf(TEXT("IOleInPlaceObject::ReactivateAndUndo()"));
3629 HRESULT hr = pIOleInPlaceObject->ReactivateAndUndo();
3630 dbgprintf(TEXT("IOleInPlaceObject::ReactivateAndUndo -> %08X"), hr);
3631 return hr;
3632 }
3633
3634 /* IOleWindow */
3635 public:
3637 {
3638 IOleWindow * pIOleWindow = getIOleWindow();
3639 dbgprintf(TEXT("IOleWindow::GetWindow(%p)"), phwnd);
3640 HRESULT hr = pIOleWindow->GetWindow(phwnd);
3641 dbgprintf(TEXT("IOleWindow::GetWindow -> %08X, hwnd = %X"), hr, *phwnd);
3642 return hr;
3643 }
3644
3646 {
3647 IOleWindow * pIOleWindow = getIOleWindow();
3648 dbgprintf(TEXT("IOleWindow::ContextSensitiveHelp(%s)"), BooleanToString(fEnterMode));
3649 HRESULT hr = pIOleWindow->ContextSensitiveHelp(fEnterMode);
3650 dbgprintf(TEXT("IOleWindow::ContextSensitiveHelp -> %08X"), hr);
3651 return hr;
3652 }
3653
3654 /* IOleObject */
3655 public:
3657 {
3658 // TODO: hook pClientSite
3659 IOleObject * pIOleObject = getIOleObject();
3660 dbgprintf(TEXT("IOleObject::SetClientSite(%p)"), pClientSite);
3661 HRESULT hr = pIOleObject->SetClientSite(pClientSite);
3662 dbgprintf(TEXT("IOleObject::SetClientSite -> %08X"), hr);
3663 return hr;
3664 }
3665
3667 {
3668 IOleObject * pIOleObject = getIOleObject();
3669 dbgprintf(TEXT("IOleObject::GetClientSite(%s)"), ppClientSite);
3670 HRESULT hr = pIOleObject->GetClientSite(ppClientSite);
3671 dbgprintf(TEXT("IOleObject::GetClientSite -> %08X"), hr, ppClientSite);
3672 return hr;
3673 }
3674
3675 virtual HRESULT STDMETHODCALLTYPE SetHostNames(LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
3676 {
3677 IOleObject * pIOleObject = getIOleObject();
3678 dbgprintf(TEXT("IOleObject::SetHostNames(%ls, %ls)"), szContainerApp, szContainerObj);
3679 HRESULT hr = pIOleObject->SetHostNames(szContainerApp, szContainerObj);
3680 dbgprintf(TEXT("IOleObject::SetHostNames -> %08X"), hr);
3681 return hr;
3682 }
3683
3684 virtual HRESULT STDMETHODCALLTYPE Close(DWORD dwSaveOption)
3685 {
3686 IOleObject * pIOleObject = getIOleObject();
3687 dbgprintf(TEXT("IOleObject::Close(%lu)"), dwSaveOption);
3688 HRESULT hr = pIOleObject->Close(dwSaveOption);
3689 dbgprintf(TEXT("IOleObject::Close -> %08X"), hr);
3690 return hr;
3691 }
3692
3693 virtual HRESULT STDMETHODCALLTYPE SetMoniker(DWORD dwWhichMoniker, IMoniker * pmk)
3694 {
3695 IOleObject * pIOleObject = getIOleObject();
3696 dbgprintf(TEXT("IOleObject::SetMoniker(%lu, %p)"), dwWhichMoniker, MonikerToString(pmk).c_str());
3697 HRESULT hr = pIOleObject->SetMoniker(dwWhichMoniker, pmk);
3698 dbgprintf(TEXT("IOleObject::SetMoniker -> %08X"), hr);
3699 return hr;
3700 }
3701
3702 virtual HRESULT STDMETHODCALLTYPE GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker, IMoniker ** ppmk)
3703 {
3704 IOleObject * pIOleObject = getIOleObject();
3705 dbgprintf(TEXT("IOleObject::GetMoniker(%lu, %lu, %p)"), dwAssign, dwWhichMoniker, ppmk);
3706 HRESULT hr = pIOleObject->GetMoniker(dwAssign, dwWhichMoniker, ppmk);
3707 dbgprintf(TEXT("IOleObject::GetMoniker -> %08X, pmk = %s"), hr, SUCCEEDED(hr) ? MonikerToString(*ppmk).c_str() : TEXT("<null>"));
3708 return hr;
3709 }
3710
3712 {
3713 IOleObject * pIOleObject = getIOleObject();
3714 dbgprintf(TEXT("IOleObject::InitFromData(%p, %s, %lu)"), pDataObject, BooleanToString(fCreation), dwReserved);
3715 HRESULT hr = pIOleObject->InitFromData(pDataObject, fCreation, dwReserved);
3716 dbgprintf(TEXT("IOleObject::InitFromData -> %08X"), hr);
3717 return hr;
3718 }
3719
3721 {
3722 IOleObject * pIOleObject = getIOleObject();
3723 dbgprintf(TEXT("IOleObject::GetClipboardData(%lu, %p)"), dwReserved, ppDataObject);
3724 HRESULT hr = pIOleObject->GetClipboardData(dwReserved, ppDataObject);
3725 dbgprintf(TEXT("IOleObject::GetClipboardData -> %08X, pDataObject = %p"), hr, *ppDataObject);
3726 return hr;
3727 }
3728
3729 virtual HRESULT STDMETHODCALLTYPE DoVerb(LONG iVerb, LPMSG lpmsg, IOleClientSite * pActiveSite, LONG lindex, HWND hwndParent, LPCRECT lprcPosRect)
3730 {
3731 IOleObject * pIOleObject = getIOleObject();
3732 dbgprintf(TEXT("IOleObject::DoVerb(%ld, %p, %p, %ld, %p, %s)"), iVerb, lpmsg, pActiveSite, lindex, hwndParent, RectToString(*lprcPosRect).c_str());
3733 HRESULT hr = pIOleObject->DoVerb(iVerb, lpmsg, pActiveSite, lindex, hwndParent, lprcPosRect);
3734 dbgprintf(TEXT("IOleObject::DoVerb -> %08X"), hr);
3735 return hr;
3736 }
3737
3739 {
3740 IOleObject * pIOleObject = getIOleObject();
3741 dbgprintf(TEXT("IOleObject::EnumVerbs(%p)"), ppEnumOleVerb);
3742 HRESULT hr = pIOleObject->EnumVerbs(ppEnumOleVerb);
3743 dbgprintf(TEXT("IOleObject::EnumVerbs -> %08X, pEnumOleVerb = %p"), hr, *ppEnumOleVerb);
3744 // TODO: hook
3745 return hr;
3746 }
3747
3749 {
3750 IOleObject * pIOleObject = getIOleObject();
3751 dbgprintf(TEXT("IOleObject::Update(%s)"));
3752 HRESULT hr = pIOleObject->Update();
3753 dbgprintf(TEXT("IOleObject::Update -> %08X"), hr);
3754 return hr;
3755 }
3756
3758 {
3759 IOleObject * pIOleObject = getIOleObject();
3760 dbgprintf(TEXT("IOleObject::IsUpToDate(%s)"));
3761 HRESULT hr = pIOleObject->IsUpToDate();
3762 dbgprintf(TEXT("IOleObject::IsUpToDate -> %08X"), hr);
3763 return hr;
3764 }
3765
3767 {
3768 IOleObject * pIOleObject = getIOleObject();
3769 dbgprintf(TEXT("IOleObject::GetUserClassID(%p)"), pClsid);
3770 HRESULT hr = pIOleObject->GetUserClassID(pClsid);
3771 dbgprintf(TEXT("IOleObject::GetUserClassID -> %08X, Clsid = %ls"), hr, UUIDToString(*pClsid).c_str());
3772 return hr;
3773 }
3774
3775 virtual HRESULT STDMETHODCALLTYPE GetUserType(DWORD dwFormOfType, LPOLESTR * pszUserType)
3776 {
3777 IOleObject * pIOleObject = getIOleObject();
3778 dbgprintf(TEXT("IOleObject::GetUserType(%lu, %p)"), dwFormOfType, pszUserType);
3779 HRESULT hr = pIOleObject->GetUserType(dwFormOfType, pszUserType);
3780 dbgprintf(TEXT("IOleObject::GetUserType -> %08X, szUserType = %s"), hr, *pszUserType);
3781 return hr;
3782 }
3783
3784 virtual HRESULT STDMETHODCALLTYPE SetExtent(DWORD dwDrawAspect, SIZEL * psizel)
3785 {
3786 IOleObject * pIOleObject = getIOleObject();
3787 dbgprintf(TEXT("IOleObject::SetExtent(%lu, %s)"), dwDrawAspect, SizeToString(*psizel).c_str());
3788 HRESULT hr = pIOleObject->SetExtent(dwDrawAspect, psizel);
3789 dbgprintf(TEXT("IOleObject::SetExtent -> %08X"), hr);
3790 return hr;
3791 }
3792
3793 virtual HRESULT STDMETHODCALLTYPE GetExtent(DWORD dwDrawAspect, SIZEL * psizel)
3794 {
3795 IOleObject * pIOleObject = getIOleObject();
3796 dbgprintf(TEXT("IOleObject::GetExtent(%lu, %p)"), dwDrawAspect, psizel);
3797 HRESULT hr = pIOleObject->GetExtent(dwDrawAspect, psizel);
3798 dbgprintf(TEXT("IOleObject::GetExtent -> %08X"), hr, SizeToString(*psizel).c_str());
3799 return hr;
3800 }
3801
3802 virtual HRESULT STDMETHODCALLTYPE Advise(IAdviseSink * pAdvSink, DWORD * pdwConnection)
3803 {
3804 // TODO: hook pAdvSink
3805 IOleObject * pIOleObject = getIOleObject();
3806 dbgprintf(TEXT("IOleObject::Advise(%p, %p)"), pAdvSink, pdwConnection);
3807 HRESULT hr = pIOleObject->Advise(pAdvSink, pdwConnection);
3808 dbgprintf(TEXT("IOleObject::Advise -> %08X, dwConnection = %lu"), hr, *pdwConnection);
3809 return hr;
3810 }
3811
3813 {
3814 IOleObject * pIOleObject = getIOleObject();
3815 dbgprintf(TEXT("IOleObject::Unadvise(%lu)"), dwConnection);
3816 HRESULT hr = pIOleObject->Unadvise(dwConnection);
3817 dbgprintf(TEXT("IOleObject::Unadvise -> %08X"), hr);
3818 return hr;
3819 }
3820
3822 {
3823 IOleObject * pIOleObject = getIOleObject();
3824 dbgprintf(TEXT("IOleObject::EnumAdvise(%p)"), ppenumAdvise);
3825 HRESULT hr = pIOleObject->EnumAdvise(ppenumAdvise);
3826 dbgprintf(TEXT("IOleObject::EnumAdvise -> %08X, penumAdvise = %p"), hr, *ppenumAdvise);
3827 // TODO: hook
3828 return hr;
3829 }
3830
3831 virtual HRESULT STDMETHODCALLTYPE GetMiscStatus(DWORD dwAspect, DWORD * pdwStatus)
3832 {
3833 IOleObject * pIOleObject = getIOleObject();
3834 dbgprintf(TEXT("IOleObject::GetMiscStatus(%lu, %p)"), dwAspect, pdwStatus);
3835 HRESULT hr = pIOleObject->GetMiscStatus(dwAspect, pdwStatus);
3836 dbgprintf(TEXT("IOleObject::GetMiscStatus -> %08X, dwStatus = %08X"), hr, *pdwStatus);
3837 return hr;
3838 }
3839
3841 {
3842 IOleObject * pIOleObject = getIOleObject();
3843 dbgprintf(TEXT("IOleObject::SetColorScheme(%p)"), pLogpal);
3844 HRESULT hr = pIOleObject->SetColorScheme(pLogpal);
3845 dbgprintf(TEXT("IOleObject::SetColorScheme -> %08X"), hr);
3846 return hr;
3847 }
3848
3849 /* IPersist */
3850 public:
3852 {
3853 IPersist * pIPersist = getIPersist();
3854 dbgprintf(TEXT("IPersist::GetClassID(%p)"), pClassID);
3855 HRESULT hr = pIPersist->GetClassID(pClassID);
3856 dbgprintf(TEXT("IPersist::GetClassID -> %08X, ClassId = %ls"), hr, UUIDToString(*pClassID).c_str());
3857 return hr;
3858 }
3859
3860 /* IPersistPropertyBag */
3861 public:
3863 {
3864 IPersistPropertyBag * pIPersistPropertyBag = getIPersistPropertyBag();
3865 dbgprintf(TEXT("IPersistPropertyBag::InitNew()"));
3866 HRESULT hr = pIPersistPropertyBag->InitNew();
3867 dbgprintf(TEXT("IPersistPropertyBag::InitNew -> %08X"), hr);
3868 return hr;
3869 }
3870
3871 virtual HRESULT STDMETHODCALLTYPE Load(IPropertyBag * pPropBag, IErrorLog * pErrorLog)
3872 {
3873 // TODO: hook pPropBag, pErrorLog
3874 IPersistPropertyBag * pIPersistPropertyBag = getIPersistPropertyBag();
3875 dbgprintf(TEXT("IPersistPropertyBag::Load(%p, %p)"), pPropBag, pErrorLog);
3876 HRESULT hr = pIPersistPropertyBag->Load(pPropBag, pErrorLog);
3877 dbgprintf(TEXT("IPersistPropertyBag::Load -> %08X"), hr);
3878 return hr;
3879 }
3880
3881 virtual HRESULT STDMETHODCALLTYPE Save(IPropertyBag * pPropBag, BOOL fClearDirty, BOOL fSaveAllProperties)
3882 {
3883 // TODO: hook pPropBag
3884 IPersistPropertyBag * pIPersistPropertyBag = getIPersistPropertyBag();
3885 dbgprintf(TEXT("IPersistPropertyBag::Save(%p, %s, %s)"), pPropBag, BooleanToString(fClearDirty), BooleanToString(fSaveAllProperties));
3886 HRESULT hr = pIPersistPropertyBag->Save(pPropBag, fClearDirty, fSaveAllProperties);
3887 dbgprintf(TEXT("IPersistPropertyBag::Save -> %08X"), hr);
3888 return hr;
3889 }
3890
3891 /* IPersistStorage */
3892 public:
3894 {
3895 IPersistStorage * pIPersistStorage = getIPersistStorage();
3896 dbgprintf(TEXT("IPersistStorage::IsDirty()"));
3897 HRESULT hr = pIPersistStorage->IsDirty();
3898 dbgprintf(TEXT("IPersistStorage::IsDirty -> %08X"), hr);
3899 return hr;
3900 }
3901
3903 {
3904 IPersistStorage * pIPersistStorage = getIPersistStorage();
3905 dbgprintf(TEXT("IPersistStorage::InitNew(%p)"), pStg);
3906 HRESULT hr = pIPersistStorage->InitNew(pStg);
3907 dbgprintf(TEXT("IPersistStorage::InitNew -> %08X"), hr);
3908 return hr;
3909 }
3910
3912 {
3913 IPersistStorage * pIPersistStorage = getIPersistStorage();
3914 dbgprintf(TEXT("IPersistStorage::Load(%p)"), pStg);
3915 HRESULT hr = pIPersistStorage->Load(pStg);
3916 dbgprintf(TEXT("IPersistStorage::Load -> %08X"), hr);
3917 return hr;
3918 }
3919
3921 {
3922 IPersistStorage * pIPersistStorage = getIPersistStorage();
3923 dbgprintf(TEXT("IPersistStorage::Save(%p, %s)"), pStgSave, BooleanToString(fSameAsLoad));
3924 HRESULT hr = pIPersistStorage->Save(pStgSave, fSameAsLoad);
3925 dbgprintf(TEXT("IPersistStorage::Save -> %08X"), hr);
3926 return hr;
3927 }
3928
3930 {
3931 IPersistStorage * pIPersistStorage = getIPersistStorage();
3932 dbgprintf(TEXT("IPersistStorage::SaveCompleted(%p)"), pStgNew);
3933 HRESULT hr = pIPersistStorage->SaveCompleted(pStgNew);
3934 dbgprintf(TEXT("IPersistStorage::SaveCompleted -> %08X"), hr);
3935 return hr;
3936 }
3937
3939 {
3940 IPersistStorage * pIPersistStorage = getIPersistStorage();
3941 dbgprintf(TEXT("IPersistStorage::HandsOffStorage()"));
3942 HRESULT hr = pIPersistStorage->HandsOffStorage();
3943 dbgprintf(TEXT("IPersistStorage::HandsOffStorage -> %08X"), hr);
3944 return hr;
3945 }
3946
3947 /* IPersistStreamInit */
3948 public:
3950 {
3951 IPersistStreamInit * pIPersistStreamInit = getIPersistStreamInit();
3952 dbgprintf(TEXT("IPersistStreamInit::IsDirty()"));
3953 HRESULT hr = pIPersistStreamInit->IsDirty();
3954 dbgprintf(TEXT("IPersistStreamInit::IsDirty -> %08X"), hr);
3955 return hr;
3956 }
3957
3959 {
3960 IPersistStreamInit * pIPersistStreamInit = getIPersistStreamInit();
3961 dbgprintf(TEXT("IPersistStreamInit::Load(%p)"), pStm);
3962 HRESULT hr = pIPersistStreamInit->Load(pStm);
3963 dbgprintf(TEXT("IPersistStreamInit::Load -> %08X"), hr);
3964 return hr;
3965 }
3966
3968 {
3969 IPersistStreamInit * pIPersistStreamInit = getIPersistStreamInit();
3970 dbgprintf(TEXT("IPersistStreamInit::Save(%p, %s)"), pStm, BooleanToString(fClearDirty));
3971 HRESULT hr = pIPersistStreamInit->Save(pStm, fClearDirty);
3972 dbgprintf(TEXT("IPersistStreamInit::Save -> %08X"), hr);
3973 return hr;
3974 }
3975
3977 {
3978 IPersistStreamInit * pIPersistStreamInit = getIPersistStreamInit();
3979 dbgprintf(TEXT("IPersistStreamInit::GetSizeMax(%p)"), pCbSize);
3980 HRESULT hr = pIPersistStreamInit->GetSizeMax(pCbSize);
3981 dbgprintf(TEXT("IPersistStreamInit::GetSizeMax -> %08X, CbSize = %llu"), hr, pCbSize->QuadPart);
3982 return hr;
3983 }
3984
3986 {
3987 IPersistStreamInit * pIPersistStreamInit = getIPersistStreamInit();
3988 dbgprintf(TEXT("IPersistStreamInit::InitNew()"));
3989 HRESULT hr = pIPersistStreamInit->InitNew();
3990 dbgprintf(TEXT("IPersistStreamInit::InitNew -> %08X"), hr);
3991 return hr;
3992 }
3993
3994 /* IProvideClassInfo */
3995 public:
3997 {
3998 IProvideClassInfo * pIProvideClassInfo = getIProvideClassInfo();
3999 dbgprintf(TEXT("IProvideClassInfo::GetClassInfo(%p)"), ppTI);
4000 HRESULT hr = pIProvideClassInfo->GetClassInfo(ppTI);
4001 dbgprintf(TEXT("IProvideClassInfo::GetClassInfo -> %08X, pTI = %p"), hr, *ppTI);
4002 return hr;
4003 }
4004
4005 /* IProvideClassInfo2 */
4006 public:
4008 {
4009 IProvideClassInfo2 * pIProvideClassInfo2 = getIProvideClassInfo2();
4010 dbgprintf(TEXT("IProvideClassInfo2::GetGUID(%lu, %p)"), dwGuidKind, pGUID);
4011 HRESULT hr = pIProvideClassInfo2->GetGUID(dwGuidKind, pGUID);
4012 dbgprintf(TEXT("IProvideClassInfo2::GetGUID -> %08X, GUID = %ls"), hr, UUIDToString(*pGUID).c_str());
4013 return hr;
4014 }
4015
4016 /* IQuickActivate */
4017 public:
4019 {
4020 IQuickActivate * pIQuickActivate = getIQuickActivate();
4021
4022 std::basic_stringstream<TCHAR> o1;
4023
4024 o1 << "{ ";
4025 o1 << "pClientSite = " << (void *)pQaContainer->pClientSite << ", ";
4026 o1 << "pAdviseSink = " << (void *)pQaContainer->pAdviseSink << ", ";
4027 o1 << "pPropertyNotifySink = " << (void *)pQaContainer->pPropertyNotifySink << ", ";
4028 o1 << "pUnkEventSink = " << (void *)pQaContainer->pUnkEventSink << ", ";
4029
4030 o1 << std::hex;
4031 o1 << "dwAmbientFlags = " << pQaContainer->dwAmbientFlags << ", ";
4032 o1 << "colorFore = " << pQaContainer->colorFore << ", ";
4033 o1 << "colorBack = " << pQaContainer->colorBack << ", ";
4034 o1 << std::dec;
4035
4036 o1 << "pFont = " << (void *)pQaContainer->pFont << ", ";
4037 o1 << "pUndoMgr = " << (void *)pQaContainer->pUndoMgr << ", ";
4038
4039 o1 << std::hex;
4040 o1 << "dwAppearance = " << pQaContainer->dwAppearance << ", ";
4041 o1 << "lcid = " << pQaContainer->lcid << ", ";
4042 o1 << std::dec;
4043
4044 o1 << "hpal = " << (void *)pQaContainer->hpal << ", ";
4045 o1 << "pBindHost = " << (void *)pQaContainer->pBindHost << ", ";
4046 o1 << "pOleControlSite = " << (void *)pQaContainer->pOleControlSite << ", ";
4047 o1 << "pServiceProvider = " << (void *)pQaContainer->pServiceProvider << ", ";
4048 o1 << "}";
4049
4050 dbgprintf(TEXT("IQuickActivate::QuickActivate(%s, %p)"), o1.str().c_str(), pQaControl);
4051
4052 HRESULT hr = pIQuickActivate->QuickActivate(pQaContainer, pQaControl);
4053
4054 std::basic_stringstream<TCHAR> o2;
4055
4056 o2 << "{ ";
4057 o2 << std::hex;
4058 o2 << "dwMiscStatus = " << pQaControl->dwMiscStatus << ", ";
4059 o2 << "dwViewStatus = " << pQaControl->dwViewStatus << ", ";
4060 o2 << "dwEventCookie = " << pQaControl->dwEventCookie << ", ";
4061 o2 << "dwPropNotifyCookie = " << pQaControl->dwPropNotifyCookie << ", ";
4062 o2 << "dwPointerActivationPolicy = " << pQaControl->dwPointerActivationPolicy << ", ";
4063 o2 << std::dec;
4064 o2 << "}";
4065
4066 dbgprintf(TEXT("IQuickActivate::QuickActivate -> %08X, QaControl = %s"), hr, o2.str().c_str());
4067
4068 return hr;
4069 }
4070
4072 {
4073 IQuickActivate * pIQuickActivate = getIQuickActivate();
4074 dbgprintf(TEXT("IQuickActivate::SetContentExtent(%s)"), SizeToString(*pSizel).c_str());
4075 HRESULT hr = pIQuickActivate->SetContentExtent(pSizel);
4076 dbgprintf(TEXT("IQuickActivate::SetContentExtent -> %08X"), hr);
4077 return hr;
4078 }
4079
4081 {
4082 IQuickActivate * pIQuickActivate = getIQuickActivate();
4083 dbgprintf(TEXT("IQuickActivate::GetContentExtent(%p)"), pSizel);
4084 HRESULT hr = pIQuickActivate->GetContentExtent(pSizel);
4085 dbgprintf(TEXT("IQuickActivate::GetContentExtent -> %08X, Sizel = %s"), hr, SizeToString(*pSizel).c_str());
4086 return hr;
4087 }
4088
4089 /* ISpecifyPropertyPages */
4090 private:
4091 std::basic_string<TCHAR> CauuidToString(const CAUUID& cauuid)
4092 {
4093 std::basic_ostringstream<TCHAR> o;
4094
4095 o << "{";
4096
4097 for(ULONG i = 0; i < cauuid.cElems; ++ i)
4098 {
4099 if(i)
4100 o << ", ";
4101 else
4102 o << " ";
4103
4104 o << UUIDToString(cauuid.pElems[i]);
4105 }
4106
4107 o << " }";
4108
4109 return o.str();
4110 }
4111
4112 public:
4114 {
4115 ISpecifyPropertyPages * pISpecifyPropertyPages = getISpecifyPropertyPages();
4116 dbgprintf(TEXT("ISpecifyPropertyPages::GetPages(%p)"), pPages);
4117 HRESULT hr = pISpecifyPropertyPages->GetPages(pPages);
4118 dbgprintf(TEXT("ISpecifyPropertyPages::GetPages -> %08X, Pages = %s"), hr, CauuidToString(*pPages).c_str());
4119 return hr;
4120 }
4121
4122 /* IViewObject */
4123 public:
4124 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)
4125 {
4126 IViewObject * pIViewObject = getIViewObject();
4127 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);
4128 HRESULT hr = pIViewObject->Draw(dwDrawAspect, lindex, pvAspect, ptd, hdcTargetDev, hdcDraw, lprcBounds, lprcWBounds, pfnContinue, dwContinue);
4129 dbgprintf(TEXT("IViewObject::Draw -> %08X"), hr);
4130 return hr;
4131 }
4132
4133 virtual HRESULT STDMETHODCALLTYPE IViewObject::GetColorSet(DWORD dwDrawAspect, LONG lindex, void * pvAspect, DVTARGETDEVICE * ptd, HDC hicTargetDev, LOGPALETTE ** ppColorSet)
4134 {
4135 IViewObject * pIViewObject = getIViewObject();
4136 dbgprintf(TEXT("IViewObject::GetColorSet(%s, %ld, %p, %s, %p, %p)"), AspectToString(dwDrawAspect), lindex, pvAspect, TargetDeviceToString(*ptd).c_str(), hicTargetDev, ppColorSet);
4137 HRESULT hr = pIViewObject->GetColorSet(dwDrawAspect, lindex, pvAspect, ptd, hicTargetDev, ppColorSet);
4138 dbgprintf(TEXT("IViewObject::GetColorSet -> %08X, pColorSet = %p"), hr, *ppColorSet);
4139 return hr;
4140 }
4141
4142 virtual HRESULT STDMETHODCALLTYPE IViewObject::Freeze(DWORD dwDrawAspect, LONG lindex, void * pvAspect, DWORD * pdwFreeze)
4143 {
4144 IViewObject * pIViewObject = getIViewObject();
4145 dbgprintf(TEXT("IViewObject::Freeze(%s, %ld, %p, %p)"), AspectToString(dwDrawAspect), lindex, pvAspect, pdwFreeze);
4146 HRESULT hr = pIViewObject->Freeze(dwDrawAspect, lindex, pvAspect, pdwFreeze);
4147 dbgprintf(TEXT("IViewObject::Freeze -> %08X, dwFreeze = %08X"), hr, *pdwFreeze);
4148 return hr;
4149 }
4150
4152 {
4153 IViewObject * pIViewObject = getIViewObject();
4154 dbgprintf(TEXT("IViewObject::Unfreeze(%08X)"), dwFreeze);
4155 HRESULT hr = pIViewObject->Unfreeze(dwFreeze);
4156 dbgprintf(TEXT("IViewObject::Unfreeze -> %08X"), hr);
4157 return hr;
4158 }
4159
4161 {
4162 IViewObject * pIViewObject = getIViewObject();
4163 dbgprintf(TEXT("IViewObject::SetAdvise(%s, %08X, %p)"), AspectToString(aspects), advf, pAdvSink);
4164 HRESULT hr = pIViewObject->SetAdvise(aspects, advf, pAdvSink);
4165 dbgprintf(TEXT("IViewObject::SetAdvise -> %08X"), hr);
4166 return hr;
4167 }
4168
4169 virtual HRESULT STDMETHODCALLTYPE IViewObject::GetAdvise(DWORD * pAspects, DWORD * pAdvf, IAdviseSink ** ppAdvSink)
4170 {
4171 IViewObject * pIViewObject = getIViewObject();
4172 dbgprintf(TEXT("IViewObject::GetAdvise(%p, %p, %p)"), pAspects, pAdvf, ppAdvSink);
4173 HRESULT hr = pIViewObject->GetAdvise(pAspects, pAdvf, ppAdvSink);
4174 dbgprintf(TEXT("IViewObject::GetAdvise -> %08X, aspects = %s, advf = %08X, pAdvSink %p"), hr, AspectToString(*pAspects), *pAdvf, *ppAdvSink);
4175 return hr;
4176 }
4177
4178 /* IViewObject2 */
4179 public:
4180 virtual HRESULT STDMETHODCALLTYPE IViewObject2::GetExtent(DWORD dwDrawAspect, LONG lindex, DVTARGETDEVICE * ptd, LPSIZEL lpsizel)
4181 {
4182 IViewObject2 * pIViewObject2 = getIViewObject2();
4183 dbgprintf(TEXT("IViewObject2::GetExtent(%s, %ld, %s, %p)"), AspectToString(dwDrawAspect), lindex, TargetDeviceToString(*ptd).c_str(), lpsizel);
4184 HRESULT hr = pIViewObject2->GetExtent(dwDrawAspect, lindex, ptd, lpsizel);
4185 dbgprintf(TEXT("IViewObject2::GetExtent -> %08X, sizel = %s"), hr, SizeToString(*lpsizel).c_str());
4186 return hr;
4187 }
4188
4189 /* IMsTscAx */
4190 public:
4192 {
4193 IMsTscAx * pIMsTscAx = getIMsTscAx();
4194 dbgprintf(TEXT("IMsTscAx::put_Server(%ls)"), pServer);
4195 HRESULT hr = pIMsTscAx->put_Server(pServer);
4196 dbgprintf(TEXT("IMsTscAx::put_Server -> %08X"), hr);
4197 return hr;
4198 }
4199
4201 {
4202 IMsTscAx * pIMsTscAx = getIMsTscAx();
4203 dbgprintf(TEXT("IMsTscAx::get_Server()"), pServer);
4204 HRESULT hr = pIMsTscAx->get_Server(pServer);
4205 dbgprintf(TEXT("IMsTscAx::get_Server -> %08X, server = %ls"), hr, *pServer);
4206 return hr;
4207 }
4208
4210 {
4211 IMsTscAx * pIMsTscAx = getIMsTscAx();
4212 dbgprintf(TEXT("IMsTscAx::put_Domain(%ls)"), pDomain);
4213 HRESULT hr = pIMsTscAx->put_Domain(pDomain);
4214 dbgprintf(TEXT("IMsTscAx::put_Domain -> %08X"), hr);
4215 return hr;
4216 }
4217
4219 {
4220 IMsTscAx * pIMsTscAx = getIMsTscAx();
4221 dbgprintf(TEXT("IMsTscAx::get_Domain(%p)"), pDomain);
4222 HRESULT hr = pIMsTscAx->get_Domain(pDomain);
4223 dbgprintf(TEXT("IMsTscAx::get_Domain -> %08X, Domain = %ls"), hr, *pDomain);
4224 return hr;
4225 }
4226
4228 {
4229 IMsTscAx * pIMsTscAx = getIMsTscAx();
4230 dbgprintf(TEXT("IMsTscAx::put_UserName(%ls)"), pUserName);
4231 HRESULT hr = pIMsTscAx->put_UserName(pUserName);
4232 dbgprintf(TEXT("IMsTscAx::put_UserName -> %08X"), hr);
4233 return hr;
4234 }
4235
4237 {
4238 IMsTscAx * pIMsTscAx = getIMsTscAx();
4239 dbgprintf(TEXT("IMsTscAx::get_UserName(%p)"), pUserName);
4240 HRESULT hr = pIMsTscAx->get_UserName(pUserName);
4241 dbgprintf(TEXT("IMsTscAx::get_UserName -> %08X, UserName = %ls"), hr, *pUserName);
4242 return hr;
4243 }
4244
4245 virtual HRESULT __stdcall put_DisconnectedText(BSTR pDisconnectedText)
4246 {
4247 IMsTscAx * pIMsTscAx = getIMsTscAx();
4248 dbgprintf(TEXT("IMsTscAx::put_DisconnectedText(%ls)"), pDisconnectedText);
4249 HRESULT hr = pIMsTscAx->put_DisconnectedText(pDisconnectedText);
4250 dbgprintf(TEXT("IMsTscAx::put_DisconnectedText -> %08X"), hr);
4251 return hr;
4252 }
4253
4254 virtual HRESULT __stdcall get_DisconnectedText(BSTR * pDisconnectedText)
4255 {
4256 IMsTscAx * pIMsTscAx = getIMsTscAx();
4257 dbgprintf(TEXT("IMsTscAx::get_DisconnectedText(%p)"), pDisconnectedText);
4258 HRESULT hr = pIMsTscAx->get_DisconnectedText(pDisconnectedText);
4259 dbgprintf(TEXT("IMsTscAx::get_DisconnectedText -> %08X, DisconnectedText = %ls"), hr, *pDisconnectedText);
4260 return hr;
4261 }
4262
4263 virtual HRESULT __stdcall put_ConnectingText(BSTR pConnectingText)
4264 {
4265 IMsTscAx * pIMsTscAx = getIMsTscAx();
4266 dbgprintf(TEXT("IMsTscAx::put_ConnectingText(%ls)"), pConnectingText);
4267 HRESULT hr = pIMsTscAx->put_ConnectingText(pConnectingText);
4268 dbgprintf(TEXT("IMsTscAx::put_ConnectingText -> %08X"), hr);
4269 return hr;
4270 }
4271
4272 virtual HRESULT __stdcall get_ConnectingText(BSTR * pConnectingText)
4273 {
4274 IMsTscAx * pIMsTscAx = getIMsTscAx();
4275 dbgprintf(TEXT("IMsTscAx::get_ConnectingText(%p)"), pConnectingText);
4276 HRESULT hr = pIMsTscAx->get_ConnectingText(pConnectingText);
4277 dbgprintf(TEXT("IMsTscAx::get_ConnectingText -> %08X, ConnectingText = %ls"), hr, *pConnectingText);
4278 return hr;
4279 }
4280
4281 virtual HRESULT __stdcall get_Connected(short * pIsConnected)
4282 {
4283 IMsTscAx * pIMsTscAx = getIMsTscAx();
4284 dbgprintf(TEXT("IMsTscAx::get_Connected(%p)"), pIsConnected);
4285 HRESULT hr = pIMsTscAx->get_Connected(pIsConnected);
4286 dbgprintf(TEXT("IMsTscAx::get_Connected -> %08X, IsConnected = %s"), hr, BooleanToString(*pIsConnected));
4287 return hr;
4288 }
4289
4291 {
4292 IMsTscAx * pIMsTscAx = getIMsTscAx();
4293 dbgprintf(TEXT("IMsTscAx::put_DesktopWidth(%ld)"), pVal);
4294 HRESULT hr = pIMsTscAx->put_DesktopWidth(pVal);
4295 dbgprintf(TEXT("IMsTscAx::put_DesktopWidth -> %08X"), hr);
4296 return hr;
4297 }
4298
4300 {
4301 IMsTscAx * pIMsTscAx = getIMsTscAx();
4302 dbgprintf(TEXT("IMsTscAx::get_DesktopWidth(%p)"), pVal);
4303 HRESULT hr = pIMsTscAx->get_DesktopWidth(pVal);
4304 dbgprintf(TEXT("IMsTscAx::get_DesktopWidth -> %08X, Val = %lu"), hr, *pVal);
4305 return hr;
4306 }
4307
4309 {
4310 IMsTscAx * pIMsTscAx = getIMsTscAx();
4311 dbgprintf(TEXT("IMsTscAx::put_DesktopHeight(%ld)"), pVal);
4312 HRESULT hr = pIMsTscAx->put_DesktopHeight(pVal);
4313 dbgprintf(TEXT("IMsTscAx::put_DesktopHeight -> %08X"), hr);
4314 return hr;
4315 }
4316
4318 {
4319 IMsTscAx * pIMsTscAx = getIMsTscAx();
4320 dbgprintf(TEXT("IMsTscAx::get_DesktopHeight(%p)"), pVal);
4321 HRESULT hr = pIMsTscAx->get_DesktopHeight(pVal);
4322 dbgprintf(TEXT("IMsTscAx::get_DesktopHeight -> %08X, Val = %lu"), hr, *pVal);
4323 return hr;
4324 }
4325
4326 virtual HRESULT __stdcall put_StartConnected(long pfStartConnected)
4327 {
4328 IMsTscAx * pIMsTscAx = getIMsTscAx();
4329 dbgprintf(TEXT("IMsTscAx::put_StartConnected(%s)"), BooleanToString(pfStartConnected));
4330 HRESULT hr = pIMsTscAx->put_StartConnected(pfStartConnected);
4331 dbgprintf(TEXT("IMsTscAx::put_StartConnected -> %08X"), hr);
4332 return hr;
4333 }
4334
4335 virtual HRESULT __stdcall get_StartConnected(long * pfStartConnected)
4336 {
4337 IMsTscAx * pIMsTscAx = getIMsTscAx();
4338 dbgprintf(TEXT("IMsTscAx::get_StartConnected(%p)"), pfStartConnected);
4339 HRESULT hr = pIMsTscAx->get_StartConnected(pfStartConnected);
4340 dbgprintf(TEXT("IMsTscAx::get_StartConnected -> %08X, fStartConnected = %s"), hr, BooleanToString(*pfStartConnected));
4341 return hr;
4342 }
4343
4344 virtual HRESULT __stdcall get_HorizontalScrollBarVisible(long * pfHScrollVisible)
4345 {
4346 IMsTscAx * pIMsTscAx = getIMsTscAx();
4347 dbgprintf(TEXT("IMsTscAx::get_HorizontalScrollBarVisible(%p)"), pfHScrollVisible);
4348 HRESULT hr = pIMsTscAx->get_HorizontalScrollBarVisible(pfHScrollVisible);
4349 dbgprintf(TEXT("IMsTscAx::get_HorizontalScrollBarVisible -> %08X, fHScrollVisible = %s"), hr, BooleanToString(*pfHScrollVisible));
4350 return hr;
4351 }
4352
4353 virtual HRESULT __stdcall get_VerticalScrollBarVisible(long * pfVScrollVisible)
4354 {
4355 IMsTscAx * pIMsTscAx = getIMsTscAx();
4356 dbgprintf(TEXT("IMsTscAx::get_VerticalScrollBarVisible(%p)"), pfVScrollVisible);
4357 HRESULT hr = pIMsTscAx->get_VerticalScrollBarVisible(pfVScrollVisible);
4358 dbgprintf(TEXT("IMsTscAx::get_VerticalScrollBarVisible -> %08X, fVScrollVisible"), hr, *pfVScrollVisible);
4359 return hr;
4360 }
4361
4363 {
4364 IMsTscAx * pIMsTscAx = getIMsTscAx();
4365 dbgprintf(TEXT("IMsTscAx::put_FullScreenTitle(%ls)"), _arg1);
4366 HRESULT hr = pIMsTscAx->put_FullScreenTitle(_arg1);
4367 dbgprintf(TEXT("IMsTscAx::put_FullScreenTitle -> %08X"), hr);
4368 return hr;
4369 }
4370
4371 virtual HRESULT __stdcall get_CipherStrength(long * pCipherStrength)
4372 {
4373 IMsTscAx * pIMsTscAx = getIMsTscAx();
4374 dbgprintf(TEXT("IMsTscAx::get_CipherStrength(%p)"), pCipherStrength);
4375 HRESULT hr = pIMsTscAx->get_CipherStrength(pCipherStrength);
4376 dbgprintf(TEXT("IMsTscAx::get_CipherStrength -> %08X, CipherStrength = %ld"), hr, *pCipherStrength);
4377 return hr;
4378 }
4379
4380 virtual HRESULT __stdcall get_Version(BSTR * pVersion)
4381 {
4382 IMsTscAx * pIMsTscAx = getIMsTscAx();
4383 dbgprintf(TEXT("IMsTscAx::get_Version(%p)"), pVersion);
4384 HRESULT hr = pIMsTscAx->get_Version(pVersion);
4385 dbgprintf(TEXT("IMsTscAx::get_Version -> %08X, Version = %ls"), hr, *pVersion);
4386 return hr;
4387 }
4388
4389 virtual HRESULT __stdcall get_SecuredSettingsEnabled(long * pSecuredSettingsEnabled)
4390 {
4391 IMsTscAx * pIMsTscAx = getIMsTscAx();
4392 dbgprintf(TEXT("IMsTscAx::get_SecuredSettingsEnabled(%p)"), pSecuredSettingsEnabled);
4393 HRESULT hr = pIMsTscAx->get_SecuredSettingsEnabled(pSecuredSettingsEnabled);
4394 dbgprintf(TEXT("IMsTscAx::get_SecuredSettingsEnabled -> %08X, SecuredSettingsEnabled = %s"), hr, BooleanToString(*pSecuredSettingsEnabled));
4395 return hr;
4396 }
4397
4399 {
4400 IMsTscAx * pIMsTscAx = getIMsTscAx();
4401 dbgprintf(TEXT("IMsTscAx::get_SecuredSettings(%p)"), ppSecuredSettings);
4402 HRESULT hr = pIMsTscAx->get_SecuredSettings(ppSecuredSettings);
4403 dbgprintf(TEXT("IMsTscAx::get_SecuredSettings -> %08X, pSecuredSettings = %p"), hr, *ppSecuredSettings);
4404 return hr;
4405 }
4406
4408 {
4409 IMsTscAx * pIMsTscAx = getIMsTscAx();
4410 dbgprintf(TEXT("IMsTscAx::get_AdvancedSettings(%p)"), ppAdvSettings);
4411 HRESULT hr = pIMsTscAx->get_AdvancedSettings(ppAdvSettings);
4412 dbgprintf(TEXT("IMsTscAx::get_AdvancedSettings -> %08X, pAdvSettings = %p"), hr, *ppAdvSettings);
4413
4414 if(SUCCEEDED(hr))
4415 *ppAdvSettings = new CAdvancedSettings(*ppAdvSettings);
4416
4417 return hr;
4418 }
4419
4421 {
4422 IMsTscAx * pIMsTscAx = getIMsTscAx();
4423 dbgprintf(TEXT("IMsTscAx::get_Debugger(%p)"), ppDebugger);
4424 HRESULT hr = pIMsTscAx->get_Debugger(ppDebugger);
4425 dbgprintf(TEXT("IMsTscAx::get_Debugger -> %08X, pDebugger = %p"), hr, *ppDebugger);
4426 return hr;
4427 }
4428
4430 {
4431 IMsTscAx * pIMsTscAx = getIMsTscAx();
4432 dbgprintf(TEXT("IMsTscAx::Connect()"));
4433 HRESULT hr = pIMsTscAx->Connect();
4434 dbgprintf(TEXT("IMsTscAx::Connect -> %08X"), hr);
4435 return hr;
4436 }
4437
4439 {
4440 IMsTscAx * pIMsTscAx = getIMsTscAx();
4441 dbgprintf(TEXT("IMsTscAx::Disconnect()"));
4442 HRESULT hr = pIMsTscAx->Disconnect();
4443 dbgprintf(TEXT("IMsTscAx::Disconnect -> %08X"), hr);
4444 return hr;
4445 }
4446
4448 {
4449 IMsTscAx * pIMsTscAx = getIMsTscAx();
4450 dbgprintf(TEXT("IMsTscAx::CreateVirtualChannels(%ls)"), newVal);
4451 HRESULT hr = pIMsTscAx->CreateVirtualChannels(newVal);
4452 dbgprintf(TEXT("IMsTscAx::CreateVirtualChannels -> %08X"), hr);
4453 return hr;
4454 }
4455
4456 virtual HRESULT __stdcall SendOnVirtualChannel(BSTR chanName, BSTR ChanData)
4457 {
4458 IMsTscAx * pIMsTscAx = getIMsTscAx();
4459 dbgprintf(TEXT("IMsTscAx::SendOnVirtualChannel(%ls, %p)"), chanName, ChanData);
4460 HRESULT hr = pIMsTscAx->SendOnVirtualChannel(chanName, ChanData);
4461 dbgprintf(TEXT("IMsTscAx::SendOnVirtualChannel -> %08X"), hr);
4462 return hr;
4463 }
4464
4465 /* IMsRdpClient */
4466 public:
4467 virtual HRESULT __stdcall put_ColorDepth(long pcolorDepth)
4468 {
4469 IMsRdpClient * pIMsRdpClient = getIMsRdpClient();
4470 dbgprintf(TEXT("IMsRdpClient::put_ColorDepth(%ld)"), pcolorDepth);
4471 HRESULT hr = pIMsRdpClient->put_ColorDepth(pcolorDepth);
4472 dbgprintf(TEXT("IMsRdpClient::put_ColorDepth -> %08X"), hr);
4473 return hr;
4474 }
4475
4476 virtual HRESULT __stdcall get_ColorDepth(long * pcolorDepth)
4477 {
4478 IMsRdpClient * pIMsRdpClient = getIMsRdpClient();
4479 dbgprintf(TEXT("IMsRdpClient::get_ColorDepth(%p)"), pcolorDepth);
4480 HRESULT hr = pIMsRdpClient->get_ColorDepth(pcolorDepth);
4481 dbgprintf(TEXT("IMsRdpClient::get_ColorDepth -> %08X, colorDepth = %ld"), hr, *pcolorDepth);
4482 return hr;
4483 }
4484
4486 {
4487 IMsRdpClient * pIMsRdpClient = getIMsRdpClient();
4488 dbgprintf(TEXT("IMsRdpClient::get_AdvancedSettings2(%p)"), ppAdvSettings);
4489 HRESULT hr = pIMsRdpClient->get_AdvancedSettings2(ppAdvSettings);
4490 dbgprintf(TEXT("IMsRdpClient::get_AdvancedSettings2 -> %08X, pAdvSettings = %p"), hr, *ppAdvSettings);
4491
4492 if(SUCCEEDED(hr))
4493 *ppAdvSettings = new CAdvancedSettings(*ppAdvSettings);
4494
4495 return hr;
4496 }
4497
4499 {
4500 IMsRdpClient * pIMsRdpClient = getIMsRdpClient();
4501 dbgprintf(TEXT("IMsRdpClient::get_SecuredSettings2(%p)"), ppSecuredSettings);
4502 HRESULT hr = pIMsRdpClient->get_SecuredSettings2(ppSecuredSettings);
4503 dbgprintf(TEXT("IMsRdpClient::get_SecuredSettings2 -> %08X, pSecuredSettings = %p"), hr, *ppSecuredSettings);
4504 return hr;
4505 }
4506
4508 {
4509 IMsRdpClient * pIMsRdpClient = getIMsRdpClient();
4510 dbgprintf(TEXT("IMsRdpClient::get_ExtendedDisconnectReason(%p)"), pExtendedDisconnectReason);
4511 HRESULT hr = pIMsRdpClient->get_ExtendedDisconnectReason(pExtendedDisconnectReason);
4512 dbgprintf(TEXT("IMsRdpClient::get_ExtendedDisconnectReason -> %08X, ExtendedDisconnectReason = %u"), hr, *pExtendedDisconnectReason);
4513 return hr;
4514 }
4515
4517 {
4518 IMsRdpClient * pIMsRdpClient = getIMsRdpClient();
4519 dbgprintf(TEXT("IMsRdpClient::put_FullScreen(%s)"), BooleanToString(pfFullScreen));
4520 HRESULT hr = pIMsRdpClient->put_FullScreen(pfFullScreen);
4521 dbgprintf(TEXT("IMsRdpClient::put_FullScreen -> %08X"), hr);
4522 return hr;
4523 }
4524
4526 {
4527 IMsRdpClient * pIMsRdpClient = getIMsRdpClient();
4528 dbgprintf(TEXT("IMsRdpClient::get_FullScreen(%p)"), pfFullScreen);
4529 HRESULT hr = pIMsRdpClient->get_FullScreen(pfFullScreen);
4530 dbgprintf(TEXT("IMsRdpClient::get_FullScreen -> %08X, pfFullScreen = %s"), hr, BooleanToString(*pfFullScreen));
4531 return hr;
4532 }
4533
4534 virtual HRESULT __stdcall SetVirtualChannelOptions(BSTR chanName, long chanOptions)
4535 {
4536 IMsRdpClient * pIMsRdpClient = getIMsRdpClient();
4537 dbgprintf(TEXT("IMsRdpClient::SetVirtualChannelOptions(%ls, %08X)"), chanName, chanOptions);
4538 HRESULT hr = pIMsRdpClient->SetVirtualChannelOptions(chanName, chanOptions);
4539 dbgprintf(TEXT("IMsRdpClient::SetVirtualChannelOptions -> %08X"), hr);
4540 return hr;
4541 }
4542
4543 virtual HRESULT __stdcall GetVirtualChannelOptions(BSTR chanName, long * pChanOptions)
4544 {
4545 IMsRdpClient * pIMsRdpClient = getIMsRdpClient();
4546 dbgprintf(TEXT("IMsRdpClient::GetVirtualChannelOptions(%ls, %p)"), chanName, pChanOptions);
4547 HRESULT hr = pIMsRdpClient->GetVirtualChannelOptions(chanName, pChanOptions);
4548 dbgprintf(TEXT("IMsRdpClient::GetVirtualChannelOptions -> %08X, ChanOptions = %08X"), hr, *pChanOptions);
4549 return hr;
4550 }
4551
4553 {
4554 IMsRdpClient * pIMsRdpClient = getIMsRdpClient();
4555 dbgprintf(TEXT("IMsRdpClient::RequestClose(%p)"), pCloseStatus);
4556 HRESULT hr = pIMsRdpClient->RequestClose(pCloseStatus);
4557 dbgprintf(TEXT("IMsRdpClient::RequestClose -> %08X, CloseStatus = %ld"), hr, *pCloseStatus);
4558 return hr;
4559 }
4560
4561 /* IMsRdpClient2 */
4562 public:
4564 {
4565 IMsRdpClient2 * pIMsRdpClient2 = getIMsRdpClient2();
4566 dbgprintf(TEXT("IMsRdpClient2::get_AdvancedSettings3(%p)"), ppAdvSettings);
4567 HRESULT hr = pIMsRdpClient2->get_AdvancedSettings3(ppAdvSettings);
4568 dbgprintf(TEXT("IMsRdpClient2::get_AdvancedSettings3 -> %08X, pAdvSettings = %p"), hr, *ppAdvSettings);
4569
4570 if(SUCCEEDED(hr))
4571 *ppAdvSettings = new CAdvancedSettings(*ppAdvSettings);
4572
4573 return hr;
4574 }
4575
4576 virtual HRESULT __stdcall put_ConnectedStatusText(BSTR pConnectedStatusText)
4577 {
4578 IMsRdpClient2 * pIMsRdpClient2 = getIMsRdpClient2();
4579 dbgprintf(TEXT("IMsRdpClient2::put_ConnectedStatusText(%ls)"), pConnectedStatusText);
4580 HRESULT hr = pIMsRdpClient2->put_ConnectedStatusText(pConnectedStatusText);
4581 dbgprintf(TEXT("IMsRdpClient2::put_ConnectedStatusText -> %08X"), hr);
4582 return hr;
4583 }
4584
4585 virtual HRESULT __stdcall get_ConnectedStatusText(BSTR * pConnectedStatusText)
4586 {
4587 IMsRdpClient2 * pIMsRdpClient2 = getIMsRdpClient2();
4588 dbgprintf(TEXT("IMsRdpClient2::get_ConnectedStatusText(%p)"), pConnectedStatusText);
4589 HRESULT hr = pIMsRdpClient2->get_ConnectedStatusText(pConnectedStatusText);
4590 dbgprintf(TEXT("IMsRdpClient2::get_ConnectedStatusText -> %08X, ConnectedStatusText = %ls"), hr, *pConnectedStatusText);
4591 return hr;
4592 }
4593
4594 /* IMsRdpClient3 */
4595 public:
4597 {
4598 IMsRdpClient3 * pIMsRdpClient3 = getIMsRdpClient3();
4599 dbgprintf(TEXT("IMsRdpClient3::get_AdvancedSettings4(%p)"), ppAdvSettings);
4600 HRESULT hr = pIMsRdpClient3->get_AdvancedSettings4(ppAdvSettings);
4601 dbgprintf(TEXT("IMsRdpClient3::get_AdvancedSettings4 -> %08X, pAdvSettings = %p"), hr, *ppAdvSettings);
4602
4603 if(SUCCEEDED(hr))
4604 *ppAdvSettings = new CAdvancedSettings(*ppAdvSettings);
4605
4606 return hr;
4607 }
4608
4609 /* IMsRdpClient4 */
4610 public:
4612 {
4613 IMsRdpClient4 * pIMsRdpClient4 = getIMsRdpClient4();
4614 dbgprintf(TEXT("IMsRdpClient4::get_AdvancedSettings5(%p)"), ppAdvSettings5);
4615 HRESULT hr = pIMsRdpClient4->get_AdvancedSettings5(ppAdvSettings5);
4616 dbgprintf(TEXT("IMsRdpClient4::get_AdvancedSettings5 -> %08X, pAdvSettings5 = %p"), hr, *ppAdvSettings5);
4617
4618 if(SUCCEEDED(hr))
4619 *ppAdvSettings5 = new CAdvancedSettings(*ppAdvSettings5);
4620
4621 return hr;
4622 }
4623
4624 /* IMsTscNonScriptable */
4625 public:
4627 {
4628 IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable();
4629 dbgprintf(TEXT("IMsTscNonScriptable::put_ClearTextPassword(%ls)"), _arg1);
4630 HRESULT hr = pIMsTscNonScriptable->put_ClearTextPassword(_arg1);
4631 dbgprintf(TEXT("IMsTscNonScriptable::put_ClearTextPassword -> %08X"), hr);
4632 return hr;
4633 }
4634
4636 {
4637 IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable();
4638 dbgprintf(TEXT("IMsTscNonScriptable::put_PortablePassword(%ls)"), pPortablePass);
4639 HRESULT hr = pIMsTscNonScriptable->put_PortablePassword(pPortablePass);
4640 dbgprintf(TEXT("IMsTscNonScriptable::put_PortablePassword -> %08X"), hr);
4641 return hr;
4642 }
4643
4645 {
4646 IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable();
4647 dbgprintf(TEXT("IMsTscNonScriptable::get_PortablePassword(%p)"), pPortablePass);
4648 HRESULT hr = pIMsTscNonScriptable->get_PortablePassword(pPortablePass);
4649 dbgprintf(TEXT("IMsTscNonScriptable::get_PortablePassword -> %08X, PortablePass = %ls"), hr, *pPortablePass);
4650 return hr;
4651 }
4652
4654 {
4655 IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable();
4656 dbgprintf(TEXT("IMsTscNonScriptable::put_PortableSalt(%ls)"), pPortableSalt);
4657 HRESULT hr = pIMsTscNonScriptable->put_PortableSalt(pPortableSalt);
4658 dbgprintf(TEXT("IMsTscNonScriptable::put_PortableSalt -> %08X"), hr);
4659 return hr;
4660 }
4661
4662 virtual HRESULT __stdcall get_PortableSalt(BSTR * pPortableSalt)
4663 {
4664 IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable();
4665 dbgprintf(TEXT("IMsTscNonScriptable::get_PortableSalt()"), pPortableSalt);
4666 HRESULT hr = pIMsTscNonScriptable->get_PortableSalt(pPortableSalt);
4667 dbgprintf(TEXT("IMsTscNonScriptable::get_PortableSalt -> %08X, PortableSalt = %ls"), hr, *pPortableSalt);
4668 return hr;
4669 }
4670
4671 virtual HRESULT __stdcall put_BinaryPassword(BSTR pBinaryPassword)
4672 {
4673 IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable();
4674 dbgprintf(TEXT("IMsTscNonScriptable::put_BinaryPassword(%p)"), pBinaryPassword);
4675 HRESULT hr = pIMsTscNonScriptable->put_BinaryPassword(pBinaryPassword);
4676 dbgprintf(TEXT("IMsTscNonScriptable::put_BinaryPassword -> %08X"), hr);
4677 return hr;
4678 }
4679
4680 virtual HRESULT __stdcall get_BinaryPassword(BSTR * pBinaryPassword)
4681 {
4682 IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable();
4683 dbgprintf(TEXT("IMsTscNonScriptable::get_BinaryPassword()"), pBinaryPassword);
4684 HRESULT hr = pIMsTscNonScriptable->get_BinaryPassword(pBinaryPassword);
4685 dbgprintf(TEXT("IMsTscNonScriptable::get_BinaryPassword -> %08X, BinaryPassword = %ls"), hr, *pBinaryPassword);
4686 return hr;
4687 }
4688
4690 {
4691 IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable();
4692 dbgprintf(TEXT("IMsTscNonScriptable::put_BinarySalt(%p)"), pSalt);
4693 HRESULT hr = pIMsTscNonScriptable->put_BinarySalt(pSalt);
4694 dbgprintf(TEXT("IMsTscNonScriptable::put_BinarySalt -> %08X"), hr);
4695 return hr;
4696 }
4697
4699 {
4700 IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable();
4701 dbgprintf(TEXT("IMsTscNonScriptable::get_BinarySalt()"), pSalt);
4702 HRESULT hr = pIMsTscNonScriptable->get_BinarySalt(pSalt);
4703 dbgprintf(TEXT("IMsTscNonScriptable::get_BinarySalt -> %08X, pSalt = %ls"), hr, *pSalt);
4704 return hr;
4705 }
4706
4708 {
4709 IMsTscNonScriptable * pIMsTscNonScriptable = getIMsTscNonScriptable();
4710 dbgprintf(TEXT("IMsTscNonScriptable::ResetPassword()"));
4711 HRESULT hr = pIMsTscNonScriptable->ResetPassword();
4712 dbgprintf(TEXT("IMsTscNonScriptable::ResetPassword -> %08X"), hr);
4713 return hr;
4714 }
4715
4716
4717 /* IMsRdpClientNonScriptable */
4718 public:
4719 virtual HRESULT __stdcall IMsRdpClientNonScriptable::NotifyRedirectDeviceChange(UINT_PTR wParam, LONG_PTR lParam)
4720 {
4721 IMsRdpClientNonScriptable * pIMsRdpClientNonScriptable = getIMsRdpClientNonScriptable();
4722 dbgprintf(TEXT("IMsRdpClientNonScriptable::NotifyRedirectDeviceChange(%p, %p)"), wParam, lParam);
4723 HRESULT hr = pIMsRdpClientNonScriptable->NotifyRedirectDeviceChange(wParam, lParam);
4724 dbgprintf(TEXT("IMsRdpClientNonScriptable::NotifyRedirectDeviceChange -> %08X"), hr);
4725 return hr;
4726 }
4727
4728 virtual HRESULT __stdcall IMsRdpClientNonScriptable::SendKeys(long numKeys, VARIANT_BOOL * pbArrayKeyUp, long * plKeyData) // TBD
4729 {
4730 IMsRdpClientNonScriptable * pIMsRdpClientNonScriptable = getIMsRdpClientNonScriptable();
4731 dbgprintf(TEXT("IMsRdpClientNonScriptable::SendKeys(%ld, %p, %p)"), numKeys, pbArrayKeyUp, plKeyData);
4732 HRESULT hr = pIMsRdpClientNonScriptable->SendKeys(numKeys, pbArrayKeyUp, plKeyData);
4733 dbgprintf(TEXT("IMsRdpClientNonScriptable::SendKeys -> %08X"), hr);
4734 return hr;
4735 }
4736
4737 /* IMsRdpClientNonScriptable2 */
4738 public:
4739 virtual HRESULT __stdcall IMsRdpClientNonScriptable2::put_UIParentWindowHandle(wireHWND phwndUIParentWindowHandle)
4740 {
4741 IMsRdpClientNonScriptable2 * pIMsRdpClientNonScriptable2 = getIMsRdpClientNonScriptable2();
4742 dbgprintf(TEXT("IMsRdpClientNonScriptable2::put_UIParentWindowHandle(%p)"), phwndUIParentWindowHandle);
4743 HRESULT hr = pIMsRdpClientNonScriptable2->put_UIParentWindowHandle(phwndUIParentWindowHandle);
4744 dbgprintf(TEXT("IMsRdpClientNonScriptable2::put_UIParentWindowHandle -> %08X"), hr);
4745 return hr;
4746 }
4747
4748 virtual HRESULT __stdcall IMsRdpClientNonScriptable2::get_UIParentWindowHandle(wireHWND * phwndUIParentWindowHandle)
4749 {
4750 IMsRdpClientNonScriptable2 * pIMsRdpClientNonScriptable2 = getIMsRdpClientNonScriptable2();
4751 dbgprintf(TEXT("IMsRdpClientNonScriptable2::get_UIParentWindowHandle(%p)"), phwndUIParentWindowHandle);
4752 HRESULT hr = pIMsRdpClientNonScriptable2->get_UIParentWindowHandle(phwndUIParentWindowHandle);
4753 dbgprintf(TEXT("IMsRdpClientNonScriptable2::get_UIParentWindowHandle -> %08X, hwndUIParentWindowHandle = %p"), hr, *phwndUIParentWindowHandle);
4754 return hr;
4755 }
4756
4757 /*
4758 {
4759 * p = m_;
4760 dbgprintf(TEXT("::()"), );
4761 HRESULT hr = p->();
4762 dbgprintf(TEXT(":: -> %08X, "), hr, );
4763 return hr;
4764 }
4765 */
4766 };
4767
4769 {
4770 private:
4775
4777 {
4778 if(m_IClassFactory)
4779 return m_IClassFactory;
4780
4781 if(m_IClassFactory2)
4782 m_IClassFactory = m_IClassFactory2;
4783
4784 if(m_IClassFactory)
4785 {
4786 m_IClassFactory->AddRef();
4787 return m_IClassFactory;
4788 }
4789
4790 m_IUnknown->QueryInterface(&m_IClassFactory);
4791 return m_IClassFactory;
4792 }
4793
4795 {
4796 if(m_IClassFactory2)
4797 return m_IClassFactory2;
4798
4799 m_IUnknown->QueryInterface(&m_IClassFactory2);
4800 return m_IClassFactory2;
4801 }
4802
4803 public:
4805 m_refCount(1),
4806 m_IUnknown(pUnknwn),
4807 m_IClassFactory(NULL),
4808 m_IClassFactory2(NULL)
4809 {
4810 m_IUnknown->AddRef();
4811 }
4812
4814 {
4815 if(m_IUnknown)
4816 m_IUnknown->Release();
4817
4818 if(m_IClassFactory)
4819 m_IClassFactory->Release();
4820
4821 if(m_IClassFactory2)
4822 m_IClassFactory2->Release();
4823 }
4824
4825 /* IUnknown */
4826 public:
4828 {
4829 HRESULT hr;
4830 IUnknown * pvObject = NULL;
4831
4832 dbgprintf(TEXT("IUnknown::QueryInterface(%ls, %p)"), UUIDToString(riid).c_str(), ppvObject);
4833
4834#define QIBEGIN() \
4835 if(riid == IID_IUnknown) \
4836 { \
4837 hr = S_OK; \
4838 pvObject = (IUnknown *)(this); \
4839 }
4840
4841#define QI(I) \
4842 else if(riid == IID_ ## I) \
4843 { \
4844 if(m_ ## I) \
4845 { \
4846 m_ ## I->AddRef(); \
4847 hr = S_OK; \
4848 } \
4849 else \
4850 { \
4851 hr = m_IUnknown->QueryInterface(&m_ ## I); \
4852 } \
4853 \
4854 if(SUCCEEDED(hr)) \
4855 pvObject = static_cast<I *>(this); \
4856 }
4857
4858#define QIEND() \
4859 else \
4860 { \
4861 hr = E_NOINTERFACE; \
4862 pvObject = NULL; \
4863 }
4864
4865 QIBEGIN()
4868 QIEND()
4869
4870#undef QIBEGIN
4871#undef QIEND
4872#undef QI
4873
4874 if(SUCCEEDED(hr))
4875 {
4876 assert(pvObject);
4877 pvObject->AddRef();
4878 }
4879 else
4880 {
4881 assert(pvObject == NULL);
4882 }
4883
4884 *ppvObject = pvObject;
4885
4886 dbgprintf(TEXT("IUnknown::QueryInterface -> %08X, ppvObject = %p"), hr, *ppvObject);
4887 return hr;
4888 }
4889
4891 {
4893 }
4894
4896 {
4898
4899 if(n == 0)
4900 delete this;
4901
4902 return n;
4903 }
4904
4905 /* IClassFactory */
4906 public:
4908 {
4909 IClassFactory * pIClassFactory = getIClassFactory();
4910 dbgprintf(TEXT("IClassFactory::CreateInstance(%p, %ls, %p)"), pUnkOuter, UUIDToString(riid).c_str(), ppvObject);
4911 HRESULT hr = pIClassFactory->CreateInstance(NULL, riid, ppvObject);
4912 dbgprintf(TEXT("IClassFactory::CreateInstance -> %08X, pvObject = %p"), hr, *ppvObject);
4913 return CoClass::CreateInstance((IUnknown *)*ppvObject, pUnkOuter, riid, ppvObject);
4914 }
4915
4917 {
4918 IClassFactory * pIClassFactory = getIClassFactory();
4919 dbgprintf(TEXT("IClassFactory::LockServer(%s)"), BooleanToString(fLock));
4920 HRESULT hr = pIClassFactory->LockServer(fLock);
4921 dbgprintf(TEXT("IClassFactory::LockServer -> %08X"), hr);
4922 return hr;
4923 }
4924
4925 /* IClassFactory2 */
4926 public:
4928 {
4929 IClassFactory2 * pIClassFactory2 = getIClassFactory2();
4930 dbgprintf(TEXT("IClassFactory2::GetLicInfo(%p)"), pLicInfo);
4931 HRESULT hr = pIClassFactory2->GetLicInfo(pLicInfo);
4932 dbgprintf(TEXT("IClassFactory2::GetLicInfo -> %08X, LicInfo = %p"), hr, pLicInfo);
4933 return hr;
4934 }
4935
4937 {
4938 IClassFactory2 * pIClassFactory2 = getIClassFactory2();
4939 dbgprintf(TEXT("IClassFactory2::RequestLicKey(%lu, %p)"), dwReserved, pBstrKey);
4940 HRESULT hr = pIClassFactory2->RequestLicKey(dwReserved, pBstrKey);
4941 dbgprintf(TEXT("IClassFactory2::RequestLicKey -> %08X, bstrKey = %ls"), hr, *pBstrKey);
4942 return hr;
4943 }
4944
4946 {
4947 IClassFactory2 * pIClassFactory2 = getIClassFactory2();
4948 dbgprintf(TEXT("IClassFactory2::CreateInstanceLic(%p, %p, %ls, %ls, %p)"), pUnkOuter, pUnkReserved, UUIDToString(riid).c_str(), bstrKey, ppvObj);
4949 HRESULT hr = pIClassFactory2->CreateInstanceLic(NULL, pUnkReserved, riid, bstrKey, ppvObj);
4950 dbgprintf(TEXT("IClassFactory2::CreateInstanceLic -> %08X, pvObj = %p"), hr, *ppvObj);
4951 return CoClass::CreateInstance((IUnknown *)*ppvObj, pUnkOuter, riid, ppvObj);
4952 }
4953 };
4954
4956 {
4957 init();
4958
4959 dbgprintf(TEXT("DllGetClassObject(%ls, %ls, %p)"), UUIDToString(rclsid).c_str(), UUIDToString(riid).c_str(), ppv);
4961 dbgprintf(TEXT("DllGetClassObject -> %08X, pv = %p"), hr, *ppv);
4962
4963 IUnknown * pv = NULL;
4964
4965 if(SUCCEEDED(hr))
4966 {
4967 IUnknown * punk = (IUnknown *)*ppv;
4968
4969 if(rclsid == CLSID_MsTscAx || rclsid == CLSID_MsRdpClient || rclsid == CLSID_MsRdpClient2 || rclsid == CLSID_MsRdpClient3 || rclsid == CLSID_MsRdpClient4)
4970 pv = new ClassFactory(punk);
4971 else
4973
4974 punk->Release();
4975 }
4976
4977 if(pv)
4978 {
4979 hr = pv->QueryInterface(riid, ppv);
4980
4981 if(FAILED(hr))
4982 pv->Release();
4983 }
4984
4985 return hr;
4986 }
4987
4989 {
4990 init();
4991
4992 dbgprintf(TEXT("DllCanUnloadNow()"));
4994 dbgprintf(TEXT("DllCanUnloadNow -> %08X"), hr);
4995
4996 return hr;
4997 }
4998
4999 STDAPI_(ULONG) DllGetTscCtlVer(void)
5000 {
5001 init();
5002
5003 dbgprintf(TEXT("DllGetTscCtlVer()"));
5005 dbgprintf(TEXT("DllGetTscCtlVer-> %08X"), ul);
5006
5007 return ul;
5008 }
5009}
5010
5011// EOF
static LPWSTR pUserName
char * va_list
Definition: acmsvcex.h:78
#define va_end(ap)
Definition: acmsvcex.h:90
#define va_start(ap, A)
Definition: acmsvcex.h:91
#define InterlockedIncrement
Definition: armddk.h:53
#define InterlockedDecrement
Definition: armddk.h:52
#define msg(x)
Definition: auth_time.c:54
#define CF_UNICODETEXT
Definition: constants.h:408
#define CF_METAFILEPICT
Definition: constants.h:398
#define CF_BITMAP
Definition: constants.h:397
#define CF_PRIVATELAST
Definition: constants.h:419
#define CF_PALETTE
Definition: constants.h:404
#define CF_DSPENHMETAFILE
Definition: constants.h:417
#define CF_OWNERDISPLAY
Definition: constants.h:413
#define CF_PENDATA
Definition: constants.h:405
#define CF_WAVE
Definition: constants.h:407
#define CF_DSPMETAFILEPICT
Definition: constants.h:416
#define CF_HDROP
Definition: constants.h:410
#define CF_LOCALE
Definition: constants.h:411
#define CF_DIF
Definition: constants.h:400
#define CF_DSPBITMAP
Definition: constants.h:415
#define CF_ENHMETAFILE
Definition: constants.h:409
#define CF_SYLK
Definition: constants.h:399
#define CF_TEXT
Definition: constants.h:396
#define CF_GDIOBJFIRST
Definition: constants.h:420
#define CF_TIFF
Definition: constants.h:401
#define CF_DSPTEXT
Definition: constants.h:414
#define CF_PRIVATEFIRST
Definition: constants.h:418
#define CF_DIB
Definition: constants.h:403
#define CF_RIFF
Definition: constants.h:406
#define CF_GDIOBJLAST
Definition: constants.h:421
#define CF_OEMTEXT
Definition: constants.h:402
#define STDAPI_(t)
Definition: basetyps.h:42
#define STDAPI
Definition: basetyps.h:41
#define STDMETHODIMP
Definition: basetyps.h:43
const GUID IID_IUnknown
#define STDMETHODCALLTYPE
Definition: bdasup.h:9
void Init(IMsTscAdvancedSettings *p)
Definition: mstscax.cpp:783
void Init(IMsRdpClientAdvancedSettings *p)
Definition: mstscax.cpp:788
IMsTscAdvancedSettings * getIMsTscAdvancedSettings()
Definition: mstscax.cpp:667
virtual ULONG STDMETHODCALLTYPE AddRef(void)
Definition: mstscax.cpp:893
IMsRdpClientAdvancedSettings3 * m_IMsRdpClientAdvancedSettings3
Definition: mstscax.cpp:658
IMsRdpClientAdvancedSettings * getIMsRdpClientAdvancedSettings()
Definition: mstscax.cpp:690
virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject)
Definition: mstscax.cpp:826
IMsRdpClientAdvancedSettings2 * getIMsRdpClientAdvancedSettings2()
Definition: mstscax.cpp:711
IMsRdpClientAdvancedSettings3 * getIMsRdpClientAdvancedSettings3()
Definition: mstscax.cpp:730
IMsRdpClientAdvancedSettings4 * m_IMsRdpClientAdvancedSettings4
Definition: mstscax.cpp:659
void Init(IMsRdpClientAdvancedSettings4 *p)
Definition: mstscax.cpp:803
IMsRdpClientAdvancedSettings * m_IMsRdpClientAdvancedSettings
Definition: mstscax.cpp:656
IMsRdpClientAdvancedSettings2 * m_IMsRdpClientAdvancedSettings2
Definition: mstscax.cpp:657
virtual ULONG STDMETHODCALLTYPE Release(void)
Definition: mstscax.cpp:898
IMsRdpClientAdvancedSettings4 * getIMsRdpClientAdvancedSettings4()
Definition: mstscax.cpp:747
void Init(IMsRdpClientAdvancedSettings3 *p)
Definition: mstscax.cpp:798
void Init(IMsRdpClientAdvancedSettings2 *p)
Definition: mstscax.cpp:793
CConnectionPointContainer(IConnectionPointContainer *pIConnectionPointContainer)
Definition: mstscax.cpp:295
virtual ULONG STDMETHODCALLTYPE Release(void)
Definition: mstscax.cpp:325
virtual ULONG STDMETHODCALLTYPE AddRef(void)
Definition: mstscax.cpp:320
virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject)
Definition: mstscax.cpp:302
virtual HRESULT STDMETHODCALLTYPE FindConnectionPoint(REFIID riid, IConnectionPoint **ppCP)
Definition: mstscax.cpp:347
virtual HRESULT STDMETHODCALLTYPE EnumConnectionPoints(IEnumConnectionPoints **ppEnum)
Definition: mstscax.cpp:335
virtual HRESULT STDMETHODCALLTYPE Unadvise(DWORD dwCookie)
Definition: mstscax.cpp:524
virtual ULONG STDMETHODCALLTYPE Release(void)
Definition: mstscax.cpp:485
virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject)
Definition: mstscax.cpp:462
virtual HRESULT STDMETHODCALLTYPE EnumConnections(IEnumConnections **ppEnum)
Definition: mstscax.cpp:532
CConnectionPoint(IConnectionPoint *pIConnectionPoint)
Definition: mstscax.cpp:455
virtual HRESULT STDMETHODCALLTYPE GetConnectionPointContainer(IConnectionPointContainer **ppCPC)
Definition: mstscax.cpp:503
virtual HRESULT STDMETHODCALLTYPE GetConnectionInterface(IID *pIID)
Definition: mstscax.cpp:495
virtual HRESULT STDMETHODCALLTYPE Advise(IUnknown *pUnkSink, DWORD *pdwCookie)
Definition: mstscax.cpp:515
virtual ULONG STDMETHODCALLTYPE AddRef(void)
Definition: mstscax.cpp:480
virtual HRESULT STDMETHODCALLTYPE Next(ULONG cConnections, LPCONNECTIONPOINT *ppCP, ULONG *pcFetched)
Definition: mstscax.cpp:407
virtual HRESULT STDMETHODCALLTYPE Reset(void)
Definition: mstscax.cpp:427
virtual HRESULT STDMETHODCALLTYPE Skip(ULONG cConnections)
Definition: mstscax.cpp:419
CEnumConnectionPoints(IEnumConnectionPoints *pIEnumConnectionPoints)
Definition: mstscax.cpp:367
virtual HRESULT STDMETHODCALLTYPE Clone(IEnumConnectionPoints **ppEnum)
Definition: mstscax.cpp:435
virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject)
Definition: mstscax.cpp:374
virtual ULONG STDMETHODCALLTYPE Release(void)
Definition: mstscax.cpp:397
virtual ULONG STDMETHODCALLTYPE AddRef(void)
Definition: mstscax.cpp:392
virtual HRESULT STDMETHODCALLTYPE Clone(IEnumConnections **ppEnum)
Definition: mstscax.cpp:616
CEnumConnections(IEnumConnections *pIEnumConnections)
Definition: mstscax.cpp:552
virtual HRESULT STDMETHODCALLTYPE Reset(void)
Definition: mstscax.cpp:608
virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject)
Definition: mstscax.cpp:559
virtual HRESULT STDMETHODCALLTYPE Skip(ULONG cConnections)
Definition: mstscax.cpp:600
virtual ULONG STDMETHODCALLTYPE AddRef(void)
Definition: mstscax.cpp:577
virtual HRESULT STDMETHODCALLTYPE Next(ULONG cConnections, LPCONNECTDATA pCD, ULONG *pcFetched)
Definition: mstscax.cpp:592
virtual ULONG STDMETHODCALLTYPE Release(void)
Definition: mstscax.cpp:582
virtual ULONG STDMETHODCALLTYPE Release(void)
Definition: mstscax.cpp:4895
virtual ULONG STDMETHODCALLTYPE AddRef(void)
Definition: mstscax.cpp:4890
virtual HRESULT STDMETHODCALLTYPE CreateInstance(IUnknown *pUnkOuter, REFIID riid, void **ppvObject)
Definition: mstscax.cpp:4907
virtual HRESULT STDMETHODCALLTYPE GetLicInfo(LICINFO *pLicInfo)
Definition: mstscax.cpp:4927
virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject)
Definition: mstscax.cpp:4827
virtual HRESULT STDMETHODCALLTYPE CreateInstanceLic(IUnknown *pUnkOuter, IUnknown *pUnkReserved, REFIID riid, BSTR bstrKey, PVOID *ppvObj)
Definition: mstscax.cpp:4945
virtual HRESULT STDMETHODCALLTYPE LockServer(BOOL fLock)
Definition: mstscax.cpp:4916
virtual HRESULT STDMETHODCALLTYPE RequestLicKey(DWORD dwReserved, BSTR *pBstrKey)
Definition: mstscax.cpp:4936
virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject)
Definition: mstscax.cpp:2782
virtual HRESULT __stdcall get_Debugger(IMsTscDebug **ppDebugger)
Definition: mstscax.cpp:4420
CoClass(IUnknown *pUnknw, IUnknown *pUnkOuter)
Definition: mstscax.cpp:2812
virtual HRESULT __stdcall get_Domain(BSTR *pDomain)
Definition: mstscax.cpp:4218
IConnectionPointContainer * getIConnectionPointContainer()
Definition: mstscax.cpp:2325
static std::basic_string< TCHAR > MediumToString(const STGMEDIUM &medium)
Definition: mstscax.cpp:3296
virtual HRESULT STDMETHODCALLTYPE SetObjectRects(LPCRECT lprcPosRect, LPCRECT lprcClipRect)
Definition: mstscax.cpp:3616
virtual HRESULT STDMETHODCALLTYPE ReactivateAndUndo(void)
Definition: mstscax.cpp:3625
virtual HRESULT __stdcall Disconnect()
Definition: mstscax.cpp:4438
static void FreeExcepInfo(const EXCEPINFO &excepInfo)
Definition: mstscax.cpp:2985
virtual HRESULT __stdcall get_DesktopWidth(long *pVal)
Definition: mstscax.cpp:4299
virtual HRESULT __stdcall put_Server(BSTR pServer)
Definition: mstscax.cpp:4191
virtual HRESULT STDMETHODCALLTYPE EnumVerbs(IEnumOLEVERB **ppEnumOleVerb)
Definition: mstscax.cpp:3738
IProvideClassInfo2 * m_IProvideClassInfo2
Definition: mstscax.cpp:2282
virtual HRESULT STDMETHODCALLTYPE SetExtent(DWORD dwDrawAspect, SIZEL *psizel)
Definition: mstscax.cpp:3784
virtual HRESULT STDMETHODCALLTYPE EnumConnectionPoints(IEnumConnectionPoints **ppEnum)
Definition: mstscax.cpp:3149
virtual HRESULT STDMETHODCALLTYPE DUnadvise(DWORD dwConnection)
Definition: mstscax.cpp:3373
virtual HRESULT __stdcall put_DesktopHeight(long pVal)
Definition: mstscax.cpp:4308
virtual HRESULT __stdcall put_ColorDepth(long pcolorDepth)
Definition: mstscax.cpp:4467
IOleInPlaceActiveObject * m_IOleInPlaceActiveObject
Definition: mstscax.cpp:2273
virtual HRESULT __stdcall get_FullScreen(VARIANT_BOOL *pfFullScreen)
Definition: mstscax.cpp:4525
virtual HRESULT __stdcall get_CipherStrength(long *pCipherStrength)
Definition: mstscax.cpp:4371
virtual HRESULT __stdcall get_ExtendedDisconnectReason(ExtendedDisconnectReasonCode *pExtendedDisconnectReason)
Definition: mstscax.cpp:4507
virtual HRESULT __stdcall RequestClose(ControlCloseStatus *pCloseStatus)
Definition: mstscax.cpp:4552
virtual HRESULT __stdcall get_AdvancedSettings5(IMsRdpClientAdvancedSettings4 **ppAdvSettings5)
Definition: mstscax.cpp:4611
IConnectionPointContainer * m_IConnectionPointContainer
Definition: mstscax.cpp:2269
virtual HRESULT __stdcall get_Connected(short *pIsConnected)
Definition: mstscax.cpp:4281
virtual HRESULT STDMETHODCALLTYPE DAdvise(FORMATETC *pformatetc, DWORD advf, IAdviseSink *pAdvSink, DWORD *pdwConnection)
Definition: mstscax.cpp:3363
IOleInPlaceActiveObject * getIOleInPlaceActiveObject()
Definition: mstscax.cpp:2362
IProvideClassInfo2 * getIProvideClassInfo2()
Definition: mstscax.cpp:2474
virtual ULONG STDMETHODCALLTYPE AddRef(void)
Definition: mstscax.cpp:2973
virtual HRESULT __stdcall get_AdvancedSettings(IMsTscAdvancedSettings **ppAdvSettings)
Definition: mstscax.cpp:4407
virtual ULONG STDMETHODCALLTYPE Release(void)
Definition: mstscax.cpp:2978
virtual HRESULT __stdcall get_PortablePassword(BSTR *pPortablePass)
Definition: mstscax.cpp:4644
virtual HRESULT STDMETHODCALLTYPE GetData(FORMATETC *pformatetcIn, STGMEDIUM *pmedium)
Definition: mstscax.cpp:3308
static std::basic_string< TCHAR > ExcepInfoToString(const EXCEPINFO &excepInfo)
Definition: mstscax.cpp:2997
IOleInPlaceObject * getIOleInPlaceObject()
Definition: mstscax.cpp:2371
virtual HRESULT __stdcall put_PortableSalt(BSTR pPortableSalt)
Definition: mstscax.cpp:4653
virtual HRESULT STDMETHODCALLTYPE Unadvise(DWORD dwConnection)
Definition: mstscax.cpp:3812
virtual HRESULT STDMETHODCALLTYPE QueryGetData(FORMATETC *pformatetc)
Definition: mstscax.cpp:3326
virtual HRESULT STDMETHODCALLTYPE GetDataHere(FORMATETC *pformatetc, STGMEDIUM *pmedium)
Definition: mstscax.cpp:3317
virtual HRESULT STDMETHODCALLTYPE SetMoniker(DWORD dwWhichMoniker, IMoniker *pmk)
Definition: mstscax.cpp:3693
virtual HRESULT __stdcall get_UserName(BSTR *pUserName)
Definition: mstscax.cpp:4236
virtual HRESULT __stdcall put_FullScreenTitle(BSTR _arg1)
Definition: mstscax.cpp:4362
virtual HRESULT STDMETHODCALLTYPE DoVerb(LONG iVerb, LPMSG lpmsg, IOleClientSite *pActiveSite, LONG lindex, HWND hwndParent, LPCRECT lprcPosRect)
Definition: mstscax.cpp:3729
virtual HRESULT STDMETHODCALLTYPE HandsOffStorage(void)
Definition: mstscax.cpp:3938
virtual HRESULT __stdcall SendOnVirtualChannel(BSTR chanName, BSTR ChanData)
Definition: mstscax.cpp:4456
virtual HRESULT STDMETHODCALLTYPE GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: mstscax.cpp:3050
virtual HRESULT __stdcall put_DisconnectedText(BSTR pDisconnectedText)
Definition: mstscax.cpp:4245
virtual HRESULT __stdcall get_Version(BSTR *pVersion)
Definition: mstscax.cpp:4380
std::basic_string< TCHAR > MnemonicToString(const MSG &msg)
Definition: mstscax.cpp:3486
virtual HRESULT STDMETHODCALLTYPE GetClassInfo(ITypeInfo **ppTI)
Definition: mstscax.cpp:3996
ISpecifyPropertyPages * m_ISpecifyPropertyPages
Definition: mstscax.cpp:2284
virtual HRESULT STDMETHODCALLTYPE OnFrameWindowActivate(BOOL fActivate)
Definition: mstscax.cpp:3559
virtual HRESULT STDMETHODCALLTYPE GetMiscStatus(DWORD dwAspect, DWORD *pdwStatus)
Definition: mstscax.cpp:3831
virtual HRESULT STDMETHODCALLTYPE Update(void)
Definition: mstscax.cpp:3748
virtual HRESULT __stdcall GetVirtualChannelOptions(BSTR chanName, long *pChanOptions)
Definition: mstscax.cpp:4543
static std::basic_string< TCHAR > FormatEtcToString(const FORMATETC &formatetc)
Definition: mstscax.cpp:3232
virtual HRESULT STDMETHODCALLTYPE EnumAdvise(IEnumSTATDATA **ppenumAdvise)
Definition: mstscax.cpp:3821
virtual HRESULT __stdcall CreateVirtualChannels(BSTR newVal)
Definition: mstscax.cpp:4447
virtual HRESULT STDMETHODCALLTYPE GetControlInfo(CONTROLINFO *pCI)
Definition: mstscax.cpp:3512
virtual HRESULT __stdcall get_BinaryPassword(BSTR *pBinaryPassword)
Definition: mstscax.cpp:4680
static CoClass * InnerToOuter(CoClassInner *inner)
Definition: mstscax.cpp:2806
virtual HRESULT __stdcall SetVirtualChannelOptions(BSTR chanName, long chanOptions)
Definition: mstscax.cpp:4534
virtual HRESULT STDMETHODCALLTYPE Advise(IAdviseSink *pAdvSink, DWORD *pdwConnection)
Definition: mstscax.cpp:3802
virtual HRESULT STDMETHODCALLTYPE IsUpToDate(void)
Definition: mstscax.cpp:3757
virtual HRESULT __stdcall put_Domain(BSTR pDomain)
Definition: mstscax.cpp:4209
virtual HRESULT __stdcall get_PortableSalt(BSTR *pPortableSalt)
Definition: mstscax.cpp:4662
virtual HRESULT STDMETHODCALLTYPE SaveCompleted(IStorage *pStgNew)
Definition: mstscax.cpp:3929
virtual HRESULT __stdcall get_HorizontalScrollBarVisible(long *pfHScrollVisible)
Definition: mstscax.cpp:4344
virtual HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(BOOL fEnterMode)
Definition: mstscax.cpp:3645
virtual HRESULT STDMETHODCALLTYPE GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: mstscax.cpp:3059
virtual HRESULT STDMETHODCALLTYPE InPlaceDeactivate(void)
Definition: mstscax.cpp:3598
virtual HRESULT STDMETHODCALLTYPE OnAmbientPropertyChange(DISPID dispID)
Definition: mstscax.cpp:3530
IMsTscNonScriptable * getIMsTscNonScriptable()
Definition: mstscax.cpp:2621
virtual HRESULT __stdcall put_StartConnected(long pfStartConnected)
Definition: mstscax.cpp:4326
static std::basic_string< TCHAR > TargetDeviceToString(const DVTARGETDEVICE &targetdev)
Definition: mstscax.cpp:3177
static LPCTSTR TymedToString(DWORD tymed)
Definition: mstscax.cpp:3216
virtual HRESULT STDMETHODCALLTYPE UIDeactivate(void)
Definition: mstscax.cpp:3607
virtual HRESULT STDMETHODCALLTYPE GetUserType(DWORD dwFormOfType, LPOLESTR *pszUserType)
Definition: mstscax.cpp:3775
virtual HRESULT __stdcall put_BinarySalt(BSTR pSalt)
Definition: mstscax.cpp:4689
virtual HRESULT STDMETHODCALLTYPE GetUserClassID(CLSID *pClsid)
Definition: mstscax.cpp:3766
virtual HRESULT STDMETHODCALLTYPE EnumDAdvise(IEnumSTATDATA **ppenumAdvise)
Definition: mstscax.cpp:3382
virtual HRESULT __stdcall get_Server(BSTR *pServer)
Definition: mstscax.cpp:4200
virtual HRESULT __stdcall put_UserName(BSTR pUserName)
Definition: mstscax.cpp:4227
virtual HRESULT STDMETHODCALLTYPE SetHostNames(LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
Definition: mstscax.cpp:3675
virtual HRESULT STDMETHODCALLTYPE GetWindow(HWND *phwnd)
Definition: mstscax.cpp:3636
virtual HRESULT __stdcall get_VerticalScrollBarVisible(long *pfVScrollVisible)
Definition: mstscax.cpp:4353
std::basic_string< TCHAR > CauuidToString(const CAUUID &cauuid)
Definition: mstscax.cpp:4091
virtual HRESULT STDMETHODCALLTYPE Load(IPropertyBag *pPropBag, IErrorLog *pErrorLog)
Definition: mstscax.cpp:3871
virtual HRESULT STDMETHODCALLTYPE ResizeBorder(LPCRECT prcBorder, IOleInPlaceUIWindow *pUIWindow, BOOL fFrameWindow)
Definition: mstscax.cpp:3577
virtual HRESULT STDMETHODCALLTYPE SetData(FORMATETC *pformatetc, STGMEDIUM *pmedium, BOOL fRelease)
Definition: mstscax.cpp:3344
virtual HRESULT __stdcall Connect()
Definition: mstscax.cpp:4429
IMsRdpClientNonScriptable2 * getIMsRdpClientNonScriptable2()
Definition: mstscax.cpp:2659
virtual HRESULT STDMETHODCALLTYPE FreezeEvents(BOOL bFreeze)
Definition: mstscax.cpp:3539
virtual HRESULT STDMETHODCALLTYPE GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk)
Definition: mstscax.cpp:3702
virtual HRESULT __stdcall put_DesktopWidth(long pVal)
Definition: mstscax.cpp:4290
anonymous_namespace{mstscax.cpp}::CoClass::CoClassInner m_inner
IMsRdpClientNonScriptable * getIMsRdpClientNonScriptable()
Definition: mstscax.cpp:2641
std::basic_string< TCHAR > ControlInfoToString(const CONTROLINFO &ci)
Definition: mstscax.cpp:3414
virtual HRESULT __stdcall get_SecuredSettings2(IMsRdpClientSecuredSettings **ppSecuredSettings)
Definition: mstscax.cpp:4498
virtual HRESULT __stdcall get_BinarySalt(BSTR *pSalt)
Definition: mstscax.cpp:4698
virtual HRESULT __stdcall get_AdvancedSettings2(IMsRdpClientAdvancedSettings **ppAdvSettings)
Definition: mstscax.cpp:4485
virtual HRESULT STDMETHODCALLTYPE GetClipboardData(DWORD dwReserved, IDataObject **ppDataObject)
Definition: mstscax.cpp:3720
virtual HRESULT STDMETHODCALLTYPE Close(DWORD dwSaveOption)
Definition: mstscax.cpp:3684
virtual HRESULT STDMETHODCALLTYPE FindConnectionPoint(REFIID riid, IConnectionPoint **ppCP)
Definition: mstscax.cpp:3162
virtual HRESULT __stdcall put_BinaryPassword(BSTR pBinaryPassword)
Definition: mstscax.cpp:4671
virtual HRESULT STDMETHODCALLTYPE Save(IPropertyBag *pPropBag, BOOL fClearDirty, BOOL fSaveAllProperties)
Definition: mstscax.cpp:3881
virtual HRESULT STDMETHODCALLTYPE InitNew(void)
Definition: mstscax.cpp:3862
virtual HRESULT STDMETHODCALLTYPE EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppenumFormatEtc)
Definition: mstscax.cpp:3353
IMsRdpClientNonScriptable * m_IMsRdpClientNonScriptable
Definition: mstscax.cpp:2294
HRESULT queryInterface(REFIID riid, void **ppvObject)
Definition: mstscax.cpp:2671
virtual HRESULT STDMETHODCALLTYPE Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
Definition: mstscax.cpp:3102
virtual HRESULT STDMETHODCALLTYPE GetClassID(CLSID *pClassID)
Definition: mstscax.cpp:3851
virtual HRESULT STDMETHODCALLTYPE InitFromData(IDataObject *pDataObject, BOOL fCreation, DWORD dwReserved)
Definition: mstscax.cpp:3711
virtual HRESULT __stdcall get_SecuredSettingsEnabled(long *pSecuredSettingsEnabled)
Definition: mstscax.cpp:4389
virtual HRESULT __stdcall put_ConnectedStatusText(BSTR pConnectedStatusText)
Definition: mstscax.cpp:4576
virtual HRESULT STDMETHODCALLTYPE OnDocWindowActivate(BOOL fActivate)
Definition: mstscax.cpp:3568
virtual HRESULT __stdcall ResetPassword()
Definition: mstscax.cpp:4707
IMsTscNonScriptable * m_IMsTscNonScriptable
Definition: mstscax.cpp:2293
virtual HRESULT __stdcall get_ConnectingText(BSTR *pConnectingText)
Definition: mstscax.cpp:4272
virtual HRESULT STDMETHODCALLTYPE OnMnemonic(MSG *pMsg)
Definition: mstscax.cpp:3521
static HRESULT CreateInstance(IUnknown *pUnknw, IUnknown *pUnkOuter, REFIID riid, void **ppvObject)
Definition: mstscax.cpp:2849
virtual HRESULT __stdcall put_ClearTextPassword(BSTR _arg1)
Definition: mstscax.cpp:4626
virtual HRESULT __stdcall get_StartConnected(long *pfStartConnected)
Definition: mstscax.cpp:4335
virtual HRESULT __stdcall get_DesktopHeight(long *pVal)
Definition: mstscax.cpp:4317
virtual HRESULT STDMETHODCALLTYPE GetCanonicalFormatEtc(FORMATETC *pformatectIn, FORMATETC *pformatetcOut)
Definition: mstscax.cpp:3335
virtual HRESULT __stdcall get_AdvancedSettings4(IMsRdpClientAdvancedSettings3 **ppAdvSettings)
Definition: mstscax.cpp:4596
virtual HRESULT STDMETHODCALLTYPE SetColorScheme(LOGPALETTE *pLogpal)
Definition: mstscax.cpp:3840
static LPCTSTR AspectToString(DWORD aspect)
Definition: mstscax.cpp:3204
virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject)
Definition: mstscax.cpp:2968
virtual HRESULT STDMETHODCALLTYPE TranslateAccelerator(LPMSG lpmsg)
Definition: mstscax.cpp:3550
virtual HRESULT STDMETHODCALLTYPE GetClientSite(IOleClientSite **ppClientSite)
Definition: mstscax.cpp:3666
virtual HRESULT STDMETHODCALLTYPE SetClientSite(IOleClientSite *pClientSite)
Definition: mstscax.cpp:3656
virtual HRESULT __stdcall get_SecuredSettings(IMsTscSecuredSettings **ppSecuredSettings)
Definition: mstscax.cpp:4398
virtual HRESULT __stdcall get_DisconnectedText(BSTR *pDisconnectedText)
Definition: mstscax.cpp:4254
IMsRdpClientNonScriptable2 * m_IMsRdpClientNonScriptable2
Definition: mstscax.cpp:2295
ISpecifyPropertyPages * getISpecifyPropertyPages()
Definition: mstscax.cpp:2492
virtual HRESULT __stdcall put_ConnectingText(BSTR pConnectingText)
Definition: mstscax.cpp:4263
virtual HRESULT STDMETHODCALLTYPE GetExtent(DWORD dwDrawAspect, SIZEL *psizel)
Definition: mstscax.cpp:3793
virtual HRESULT __stdcall put_FullScreen(VARIANT_BOOL pfFullScreen)
Definition: mstscax.cpp:4516
IProvideClassInfo * getIProvideClassInfo()
Definition: mstscax.cpp:2456
virtual HRESULT __stdcall get_ColorDepth(long *pcolorDepth)
Definition: mstscax.cpp:4476
virtual HRESULT __stdcall get_AdvancedSettings3(IMsRdpClientAdvancedSettings2 **ppAdvSettings)
Definition: mstscax.cpp:4563
virtual HRESULT STDMETHODCALLTYPE GetTypeInfoCount(UINT *pctinfo)
Definition: mstscax.cpp:3041
virtual HRESULT __stdcall put_PortablePassword(BSTR pPortablePass)
Definition: mstscax.cpp:4635
IPersistStreamInit * getIPersistStreamInit()
Definition: mstscax.cpp:2447
IPersistStreamInit * m_IPersistStreamInit
Definition: mstscax.cpp:2280
IPersistPropertyBag * getIPersistPropertyBag()
Definition: mstscax.cpp:2429
virtual HRESULT __stdcall get_ConnectedStatusText(BSTR *pConnectedStatusText)
Definition: mstscax.cpp:4585
virtual HRESULT STDMETHODCALLTYPE EnableModeless(BOOL fEnable)
Definition: mstscax.cpp:3587
IPersistPropertyBag * m_IPersistPropertyBag
Definition: mstscax.cpp:2278
WPARAM wParam
Definition: combotst.c:138
LPARAM lParam
Definition: combotst.c:139
static HWND hwndParent
Definition: cryptui.c:300
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define NULL
Definition: types.h:112
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
#define GetProcAddress(x, y)
Definition: compat.h:753
OLECHAR * BSTR
Definition: compat.h:2293
#define MAX_PATH
Definition: compat.h:34
short VARIANT_BOOL
Definition: compat.h:2290
@ VT_UI8
Definition: compat.h:2315
@ VT_BSTR
Definition: compat.h:2303
@ VT_VOID
Definition: compat.h:2318
@ VT_INT
Definition: compat.h:2316
@ VT_LPSTR
Definition: compat.h:2324
@ VT_R4
Definition: compat.h:2299
@ VT_UINT_PTR
Definition: compat.h:2328
@ VT_NULL
Definition: compat.h:2296
@ VT_UNKNOWN
Definition: compat.h:2308
@ VT_TYPEMASK
Definition: compat.h:2346
@ VT_BYREF
Definition: compat.h:2342
@ VT_PTR
Definition: compat.h:2320
@ VT_UI2
Definition: compat.h:2312
@ VT_DECIMAL
Definition: compat.h:2309
@ VT_ERROR
Definition: compat.h:2305
@ VT_ARRAY
Definition: compat.h:2341
@ VT_SAFEARRAY
Definition: compat.h:2321
@ VT_LPWSTR
Definition: compat.h:2325
@ VT_R8
Definition: compat.h:2300
@ VT_CY
Definition: compat.h:2301
@ VT_VARIANT
Definition: compat.h:2307
@ VT_I8
Definition: compat.h:2314
@ VT_I1
Definition: compat.h:2310
@ VT_I4
Definition: compat.h:2298
@ VT_HRESULT
Definition: compat.h:2319
@ VT_FILETIME
Definition: compat.h:2329
@ VT_INT_PTR
Definition: compat.h:2327
@ VT_DATE
Definition: compat.h:2302
@ VT_BOOL
Definition: compat.h:2306
@ VT_I2
Definition: compat.h:2297
@ VT_UI4
Definition: compat.h:2313
@ VT_UINT
Definition: compat.h:2317
@ VT_EMPTY
Definition: compat.h:2295
@ VT_RECORD
Definition: compat.h:2326
@ VT_DISPATCH
Definition: compat.h:2304
@ VT_UI1
Definition: compat.h:2311
#define FAR
Definition: zlib.h:34
HRESULT WINAPI StringFromCLSID(REFCLSID id, LPOLESTR *idstr)
Definition: compobj.c:2412
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
#define assert(x)
Definition: debug.h:53
#define STDAPICALLTYPE
Definition: guid.c:3
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
GLdouble s
Definition: gl.h:2039
GLuint GLuint end
Definition: gl.h:1545
GLdouble n
Definition: glext.h:7729
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLfloat GLfloat p
Definition: glext.h:8902
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
LPVOID NTAPI GlobalLock(HGLOBAL hMem)
Definition: heapmem.c:755
BOOL NTAPI GlobalUnlock(HGLOBAL hMem)
Definition: heapmem.c:1190
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:442
REFIID riid
Definition: atlbase.h:39
REFIID LPVOID * ppv
Definition: atlbase.h:39
HRESULT GetLicInfo([out] LICINFO *pLicInfo)
HRESULT CreateInstanceLic([in] IUnknown *pUnkOuter, [in] IUnknown *pUnkReserved, [in] REFIID riid, [in] BSTR bstrKey, [out, iid_is(riid)] PVOID *ppvObj)
HRESULT RequestLicKey([in] DWORD dwReserved, [out] BSTR *pBstrKey)
HRESULT CreateInstance([in, unique] IUnknown *pUnkOuter, [in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
HRESULT LockServer([in] BOOL fLock)
HRESULT EnumConnectionPoints([out] IEnumConnectionPoints **ppEnum)
HRESULT FindConnectionPoint([in] REFIID riid, [out] IConnectionPoint **ppCP)
HRESULT Unadvise([in] DWORD dwCookie)
HRESULT EnumConnections([out] IEnumConnections **ppEnum)
HRESULT Advise([in] IUnknown *pUnkSink, [out] DWORD *pdwCookie)
HRESULT GetConnectionInterface([out] IID *pIID)
HRESULT GetConnectionPointContainer([out] IConnectionPointContainer **ppCPC)
HRESULT GetDataHere([in, unique] FORMATETC *pformatetc, [in, out] STGMEDIUM *pmedium)
HRESULT DUnadvise([in] DWORD dwConnection)
HRESULT SetData([in, unique] FORMATETC *pformatetc, [in, unique] STGMEDIUM *pmedium, [in] BOOL fRelease)
HRESULT DAdvise([in] FORMATETC *pformatetc, [in] DWORD advf, [in, unique] IAdviseSink *pAdvSink, [out] DWORD *pdwConnection)
HRESULT GetData([in, unique] FORMATETC *pformatetcIn, [out] STGMEDIUM *pmedium)
HRESULT QueryGetData([in, unique] FORMATETC *pformatetc)
HRESULT GetCanonicalFormatEtc([in, unique] FORMATETC *pformatectIn, [out] FORMATETC *pformatetcOut)
HRESULT EnumFormatEtc([in] DWORD dwDirection, [out] IEnumFORMATETC **ppenumFormatEtc)
HRESULT EnumDAdvise([out] IEnumSTATDATA **ppenumAdvise)
HRESULT GetTypeInfoCount([out] UINT *pctinfo)
HRESULT GetTypeInfo([in] UINT iTInfo, [in] LCID lcid, [out] ITypeInfo **ppTInfo)
HRESULT Invoke([in] DISPID dispIdMember, [in] REFIID riid, [in] LCID lcid, [in] WORD wFlags, [in, out] DISPPARAMS *pDispParams, [out] VARIANT *pVarResult, [out] EXCEPINFO *pExcepInfo, [out] UINT *puArgErr)
HRESULT GetIDsOfNames([in] REFIID riid, [in, size_is(cNames)] LPOLESTR *rgszNames, [in] UINT cNames, [in] LCID lcid, [out, size_is(cNames)] DISPID *rgDispId)
HRESULT Clone([out] IEnumConnectionPoints **ppEnum)
HRESULT Skip([in] ULONG cConnections)
HRESULT Next([in] ULONG cConnections, [out, size_is(cConnections), length_is(*pcFetched)] LPCONNECTIONPOINT *ppCP, [out] ULONG *pcFetched)
HRESULT Clone([out] IEnumConnections **ppEnum)
HRESULT Next([in] ULONG cConnections, [out, size_is(cConnections), length_is(*pcFetched)] LPCONNECTDATA rgcd, [out] ULONG *pcFetched)
HRESULT Skip([in] ULONG cConnections)
HRESULT GetDisplayName([in, unique] IBindCtx *pbc, [in, unique] IMoniker *pmkToLeft, [out] LPOLESTR *ppszDisplayName)
HRESULT GetInterfaceSafetyOptions([in] REFIID riid, [out] DWORD *pdwSupportedOptions, [out] DWORD *pdwEnabledOptions)
HRESULT SetInterfaceSafetyOptions([in] REFIID riid, [in] DWORD dwOptionSetMask, [in] DWORD dwEnabledOptions)
HRESULT FreezeEvents([in] BOOL bFreeze)
HRESULT OnAmbientPropertyChange([in] DISPID dispID)
HRESULT OnMnemonic([in] MSG *pMsg)
HRESULT GetControlInfo([out] CONTROLINFO *pCI)
HRESULT ResizeBorder([in] LPCRECT prcBorder, [in, unique] IOleInPlaceUIWindow *pUIWindow, [in] BOOL fFrameWindow)
HRESULT TranslateAccelerator([in] LPMSG lpmsg)
HRESULT OnDocWindowActivate([in] BOOL fActivate)
HRESULT EnableModeless([in] BOOL fEnable)
HRESULT OnFrameWindowActivate([in] BOOL fActivate)
HRESULT InPlaceDeactivate()
HRESULT SetObjectRects([in] LPCRECT lprcPosRect, [in] LPCRECT lprcClipRect)
HRESULT UIDeactivate()
HRESULT ReactivateAndUndo()
HRESULT SetMoniker([in] DWORD dwWhichMoniker, [in, unique] IMoniker *pmk)
HRESULT SetExtent([in] DWORD dwDrawAspect, [in] SIZEL *psizel)
HRESULT GetUserType([in] DWORD dwFormOfType, [out] LPOLESTR *pszUserType)
HRESULT SetHostNames([in] LPCOLESTR szContainerApp, [in, unique] LPCOLESTR szContainerObj)
HRESULT IsUpToDate()
HRESULT GetMiscStatus([in] DWORD dwAspect, [out] DWORD *pdwStatus)
HRESULT GetUserClassID([out] CLSID *pClsid)
HRESULT GetClipboardData([in] DWORD dwReserved, [out] IDataObject **ppDataObject)
HRESULT GetClientSite([out] IOleClientSite **ppClientSite)
HRESULT GetExtent([in] DWORD dwDrawAspect, [out] SIZEL *psizel)
HRESULT EnumVerbs([out] IEnumOLEVERB **ppEnumOleVerb)
HRESULT SetClientSite([in, unique] IOleClientSite *pClientSite)
HRESULT GetMoniker([in] DWORD dwAssign, [in] DWORD dwWhichMoniker, [out] IMoniker **ppmk)
HRESULT Close([in] DWORD dwSaveOption)
HRESULT EnumAdvise([out] IEnumSTATDATA **ppenumAdvise)
HRESULT Update()
HRESULT Unadvise([in] DWORD dwConnection)
HRESULT InitFromData([in, unique] IDataObject *pDataObject, [in] BOOL fCreation, [in] DWORD dwReserved)
HRESULT DoVerb([in] LONG iVerb, [in, unique] LPMSG lpmsg, [in, unique] IOleClientSite *pActiveSite, [in] LONG lindex, [in] HWND hwndParent, [in, unique] LPCRECT lprcPosRect)
HRESULT Advise([in, unique] IAdviseSink *pAdvSink, [out] DWORD *pdwConnection)
HRESULT SetColorScheme([in] LOGPALETTE *pLogpal)
HRESULT GetWindow([out] HWND *phwnd)
HRESULT ContextSensitiveHelp([in] BOOL fEnterMode)
HRESULT Load([in] IPropertyBag *pPropBag, [in] IErrorLog *pErrorLog)
HRESULT Save([in] IPropertyBag *pPropBag, [in] BOOL fClearDirty, [in] BOOL fSaveAllProperties)
HRESULT HandsOffStorage()
HRESULT IsDirty()
HRESULT Save([in, unique] IStorage *pStgSave, [in] BOOL fSameAsLoad)
HRESULT SaveCompleted([in, unique] IStorage *pStgNew)
HRESULT InitNew([in, unique] IStorage *pStg)
HRESULT Load([in, unique] IStorage *pStg)
HRESULT Save([in] LPSTREAM pStm, [in] BOOL fClearDirty)
HRESULT Load([in] LPSTREAM pStm)
HRESULT GetSizeMax([out] ULARGE_INTEGER *pcbSize)
HRESULT GetClassID([out] CLSID *pClassID)
HRESULT GetGUID([in] DWORD dwGuidKind, [out] GUID *pGUID)
HRESULT GetClassInfo([out] ITypeInfo **ppTI)
HRESULT QuickActivate([in] QACONTAINER *pQaContainer, [in, out] QACONTROL *pQaControl)
HRESULT SetContentExtent([in] LPSIZEL pSizel)
HRESULT GetContentExtent([out] LPSIZEL pSizel)
HRESULT GetPages([out] CAUUID *pPages)
ULONG AddRef()
HRESULT QueryInterface([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
ULONG Release()
HRESULT GetExtent([in] DWORD dwDrawAspect, [in] LONG lindex, [in, unique] DVTARGETDEVICE *ptd, [out] LPSIZEL lpsizel)
HRESULT GetColorSet([in] DWORD dwDrawAspect, [in] LONG lindex, [in, unique] void *pvAspect, [in, unique] DVTARGETDEVICE *ptd, [in] HDC hicTargetDev, [out] LOGPALETTE **ppColorSet)
HRESULT Freeze([in] DWORD dwDrawAspect, [in] LONG lindex, [in, unique] void *pvAspect, [out] DWORD *pdwFreeze)
HRESULT Draw([in] DWORD dwDrawAspect, [in] LONG lindex, [in, unique] void *pvAspect, [in, unique] DVTARGETDEVICE *ptd, [in] HDC hdcTargetDev, [in] HDC hdcDraw, [in] LPCRECTL lprcBounds, [in, unique] LPCRECTL lprcWBounds, [in] BOOL(*pfnContinue)(ULONG_PTR dwContinue), [in] ULONG_PTR dwContinue)
HRESULT Unfreeze([in] DWORD dwFreeze)
HRESULT SetAdvise([in] DWORD aspects, [in] DWORD advf, [in, unique] IAdviseSink *pAdvSink)
HRESULT GetAdvise([out, unique] DWORD *pAspects, [out, unique] DWORD *pAdvf, [out] IAdviseSink **ppAdvSink)
HRESULT SendKeys([in] long numKeys, [in] VARIANT_BOOL *pbArrayKeyUp, [in] long *plKeyData)
HRESULT NotifyRedirectDeviceChange([in] UINT_PTR wParam, [in] LONG_PTR lParam)
HRESULT SetVirtualChannelOptions([in] BSTR chanName, [in] long chanOptions)
HRESULT RequestClose([out, retval] ControlCloseStatus *pCloseStatus)
HRESULT GetVirtualChannelOptions([in] BSTR chanName, [out, retval] long *pChanOptions)
HRESULT CreateVirtualChannels([in] BSTR newVal)
HRESULT SendOnVirtualChannel([in] BSTR chanName, [in] BSTR ChanData)
HRESULT Disconnect()
Definition: msctf.idl:550
#define S_OK
Definition: intsafe.h:52
#define SUCCEEDED(hr)
Definition: intsafe.h:50
#define FAILED(hr)
Definition: intsafe.h:51
#define TEXT(s)
Definition: k32.h:26
#define T
Definition: mbstring.h:31
static HDC
Definition: imagelist.c:92
const char * var
Definition: shader.c:5666
static IUnknown * pUnkReserved
Definition: asmenum.c:33
static LPOLESTR
Definition: stg_prop.c:27
static ULONG WINAPI AddRef(IStream *iface)
Definition: clist.c:90
static VARIANTARG static DISPID
Definition: ordinal.c:52
static DWORD tymed
Definition: url.c:174
EXTERN_C const IID IID_IMsRdpClientNonScriptable2
Definition: mstsclib_h.h:2845
EXTERN_C const IID IID_IMsRdpClient4
Definition: mstsclib_h.h:2079
EXTERN_C const IID IID_IMsTscAx
Definition: mstsclib_h.h:395
EXTERN_C const IID IID_IMsRdpClientNonScriptable
Definition: mstsclib_h.h:2680
EXTERN_C const CLSID CLSID_MsRdpClient
Definition: mstsclib_h.h:8903
EXTERN_C const IID IID_IMsRdpClient2
Definition: mstsclib_h.h:1229
EXTERN_C const CLSID CLSID_MsRdpClient4
Definition: mstsclib_h.h:8927
EXTERN_C const IID IID_IMsRdpClient3
Definition: mstsclib_h.h:1653
EXTERN_C const CLSID CLSID_MsRdpClient3
Definition: mstsclib_h.h:8919
EXTERN_C const IID IID_IMsRdpClient
Definition: mstsclib_h.h:804
struct MsRdpClient3 MsRdpClient3
Definition: mstsclib_h.h:188
EXTERN_C const CLSID CLSID_MsRdpClient2
Definition: mstsclib_h.h:8911
EXTERN_C const CLSID CLSID_MsTscAx
Definition: mstsclib_h.h:8895
EXTERN_C const IID IID_IMsTscNonScriptable
Definition: mstsclib_h.h:2513
struct MsRdpClient2 MsRdpClient2
Definition: mstsclib_h.h:176
struct MsRdpClient4 MsRdpClient4
Definition: mstsclib_h.h:200
struct MsRdpClient MsRdpClient
Definition: mstsclib_h.h:164
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED _In_opt_ LPTRANSMIT_FILE_BUFFERS _In_ DWORD dwReserved
Definition: mswsock.h:95
__int3264 LONG_PTR
Definition: mstsclib.idl:79
unsigned __int3264 UINT_PTR
Definition: mstsclib.idl:78
enum MSTSCLib::__MIDL_IMsRdpClient_0001 ExtendedDisconnectReasonCode
enum MSTSCLib::__MIDL_IMsRdpClient_0002 ControlCloseStatus
HRESULT(STDAPICALLTYPE * PFNDLLCANUNLOADNOW)(void)
Definition: mstscax.cpp:8
PFNDLLGETCLASSOBJECT pfnDllGetClassObject
Definition: mstscax.cpp:11
HRESULT(STDAPICALLTYPE * PFNDLLGETCLASSOBJECT)(IN REFCLSID rclsid, IN REFIID riid, OUT LPVOID FAR *ppv)
Definition: mstscax.cpp:7
IConnectionPointContainer * HookIConnectionPointContainer(IConnectionPointContainer *p)
Definition: mstscax.cpp:629
std::basic_string< TCHAR > VariantToString(const VARIANT &var)
Definition: mstscax.cpp:169
void dbgprintf(LPCTSTR fmt,...)
Definition: mstscax.cpp:42
LPCTSTR BooleanToString(const T &X)
Definition: mstscax.cpp:164
std::wstring UUIDToString(const UUID &uuid)
Definition: mstscax.cpp:110
IEnumConnections * HookIEnumConnections(IEnumConnections *p)
Definition: mstscax.cpp:644
PFNDLLGETTSCCTLVER pfnDllGetTscCtlVer
Definition: mstscax.cpp:13
PFNDLLCANUNLOADNOW pfnDllCanUnloadNow
Definition: mstscax.cpp:12
std::basic_string< TCHAR > SizeToString(const SIZE &sz)
Definition: mstscax.cpp:154
IConnectionPoint * HookIConnectionPoint(IConnectionPoint *p)
Definition: mstscax.cpp:639
std::wstring MonikerToString(IMoniker *pmk)
Definition: mstscax.cpp:120
std::basic_string< TCHAR > RectToString(const RECT &rc)
Definition: mstscax.cpp:134
static const HMODULE hmSelf
Definition: mstscax.cpp:18
ULONG(STDAPICALLTYPE * PFNDLLGETTSCCTLVER)(void)
Definition: mstscax.cpp:9
STDAPI DllGetClassObject(IN REFCLSID rclsid, IN REFIID riid, OUT LPVOID *ppv)
Definition: mstscax.cpp:4955
IEnumConnectionPoints * HookIEnumConnectionPoints(IEnumConnectionPoints *p)
Definition: mstscax.cpp:634
unsigned int UINT
Definition: ndis.h:50
#define L(x)
Definition: ntvdm.h:50
interface IStream * LPSTREAM
Definition: objfwd.h:10
UINT WINAPI SysStringLen(BSTR str)
Definition: oleaut.c:196
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
Definition: oleaut.c:271
const GUID IID_IEnumConnections
const GUID IID_IConnectionPointContainer
const GUID IID_IConnectionPoint
const GUID IID_IEnumConnectionPoints
long LONG
Definition: pedump.c:60
unsigned short USHORT
Definition: pedump.c:61
#define QIEND()
#define QIBEGIN()
#define QI(I)
#define REFIID
Definition: guiddef.h:118
#define REFCLSID
Definition: guiddef.h:117
const WCHAR * str
DWORD LCID
Definition: nls.h:13
#define args
Definition: format.c:66
HRESULT hr
Definition: shlfolder.c:183
#define StringCbCat
Definition: strsafe.h:334
#define StringCbVPrintf
Definition: strsafe.h:499
LONG m_refCount
Definition: activex.cpp:5943
IOleClientSite * pClientSite
Definition: ocidl.idl:1294
IServiceProvider * pServiceProvider
Definition: ocidl.idl:1308
IOleControlSite * pOleControlSite
Definition: ocidl.idl:1307
IAdviseSinkEx * pAdviseSink
Definition: ocidl.idl:1295
IPropertyNotifySink * pPropertyNotifySink
Definition: ocidl.idl:1296
IOleUndoManager * pUndoMgr
Definition: ocidl.idl:1302
long bottom
Definition: polytest.cpp:53
long right
Definition: polytest.cpp:53
long top
Definition: polytest.cpp:53
long left
Definition: polytest.cpp:53
LONG cx
Definition: kdterminal.h:27
LONG cy
Definition: kdterminal.h:28
ULONGLONG QuadPart
Definition: ms-dtyp.idl:185
Definition: match.c:390
Definition: dsound.c:943
Definition: copy.c:22
WORD cmd
Definition: winuser.h:2925
WORD key
Definition: winuser.h:2924
LONG right
Definition: windef.h:308
LONG bottom
Definition: windef.h:309
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
#define wchar_t
Definition: wchar.h:102
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1829
#define __stdcall
Definition: typedefs.h:25
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define IN
Definition: typedefs.h:39
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
#define OUT
Definition: typedefs.h:40
_Must_inspect_result_ _In_ WDFDEVICE _In_ LPCGUID _Out_ PINTERFACE Interface
Definition: wdffdo.h:465
#define LoadLibrary
Definition: winbase.h:3797
#define OutputDebugString
Definition: winbase.h:3825
#define GetModuleFileName
Definition: winbase.h:3766
_In_ DWORD _Out_ _In_ WORD wFlags
Definition: wincon.h:531
_In_ void _In_ PCCERT_CONTEXT _In_opt_ LPFILETIME _In_ DWORD _In_ DWORD _Outptr_opt_ void ** ppvObject
Definition: wincrypt.h:6082
#define HRESULT
Definition: msvc.h:7
#define E_NOINTERFACE
Definition: winerror.h:2364
#define CLASS_E_NOAGGREGATION
Definition: winerror.h:2662
#define CLASS_E_CLASSNOTAVAILABLE
Definition: winerror.h:2663
#define FVIRTKEY
Definition: winuser.h:24
#define FSHIFT
Definition: winuser.h:23
#define FCONTROL
Definition: winuser.h:21
#define WM_KEYDOWN
Definition: winuser.h:1715
#define FALT
Definition: winuser.h:20
#define WM_SYSKEYDOWN
Definition: winuser.h:1719
#define GetKeyNameText
Definition: winuser.h:5787
static clock_t begin
Definition: xmllint.c:458
char TCHAR
Definition: xmlstorage.h:189
char * LPSTR
Definition: xmlstorage.h:182
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const CHAR * LPCTSTR
Definition: xmlstorage.h:193
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185