1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
|
// tDispatch.cpp: implementation of the tDispatch class.
//
//////////////////////////////////////////////////////////////////////
#include "tDispatch.h"
#include "tOleHandler.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
/*
* tDispatch::tDispatch
* tDispatch::~tDispatch
*
* Parameters (Constructor):
* pTen PCTenant of the tenant we're in.
* pUnkOuter LPUNKNOWN to which we delegate.
*/
tDispatch::tDispatch(tOleHandler *pTen, LPUNKNOWN pUnkOuter)
{
m_cRef=0;
m_pTen=pTen;
m_pUnkOuter=pUnkOuter;
return;
}
tDispatch::~tDispatch(void)
{
return;
}
/*
* tDispatch::QueryInterface
* tDispatch::AddRef
* tDispatch::Release
*/
STDMETHODIMP tDispatch::QueryInterface(REFIID riid, PPVOID ppv)
{
return m_pUnkOuter->QueryInterface(riid, ppv);
}
STDMETHODIMP_(ULONG) tDispatch::AddRef(void)
{
++m_cRef;
return m_pUnkOuter->AddRef();
}
STDMETHODIMP_(ULONG) tDispatch::Release(void)
{
m_cRef--;
return m_pUnkOuter->Release();
}
/*
* tDispatch::GetTypeInfoCount
* tDispatch::GetTypeInfo
* tDispatch::GetIDsOfNames
*
* Unimplemented members, not needed for ambient properties.
*/
STDMETHODIMP tDispatch::GetTypeInfoCount(UINT *pctInfo)
{
*pctInfo=0;
return NOERROR;
}
STDMETHODIMP tDispatch::GetTypeInfo(UINT itinfo
, LCID lcid, ITypeInfo **pptInfo)
{
*pptInfo=NULL;
return ResultFromScode(E_NOTIMPL);
}
STDMETHODIMP tDispatch::GetIDsOfNames(REFIID riid
, OLECHAR **rgszNames, UINT cNames, LCID lcid, DISPID *rgDispID)
{
*rgszNames=NULL;
*rgDispID=NULL;
return ResultFromScode(E_NOTIMPL);
}
/*
* tDispatch::Invoke
*
* Purpose:
* Calls a method in the dispatch interface or manipulates a
* property.
*
* Parameters:
* dispIDMember DISPID of the method or property of interest.
* riid REFIID reserved, must be NULL.
* lcid LCID of the locale.
* wFlags USHORT describing the context of the invocation.
* pDispParams DISPPARAMS * to the array of arguments.
* pVarResult VARIANT * in which to store the result. Is
* NULL if the caller is not interested.
* pExcepInfo EXCEPINFO * to exception information.
* puArgErr UINT * in which to store the index of an
* invalid parameter if DISP_E_TYPEMISMATCH
* is returned.
*
* Return Value:
* HRESULT NOERROR or a general error code.
*/
STDMETHODIMP tDispatch::Invoke(DISPID dispIDMember, REFIID riid
, LCID lcid, unsigned short wFlags, DISPPARAMS *pDispParams
, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
{
HRESULT hr;
VARIANT varResult;
if (IID_NULL!=riid)
return ResultFromScode(E_INVALIDARG);
/*
* We ignore lcid in this function. A multilingual application
* might use it to determine the meaning of certain parameters
* or perhaps as an indication of how to format data like
* time, date, and currency or any other language or locale-
* sensitive data.
*/
/*
* Variable handling: since ambient properties is just a
* collection of singular read-only values, we don't have to
* worry about input parameters.
*/
/*
* If the caller is not interested in the return value, then
* pVarResult is NULL. But since we're dealing with ambient
* properties, there should always be an interest. In any case,
* if we're given a NULL, we'll point it to a dummy structure so
* the rest of the code can assume that pVarResult is non-NULL.
*/
if(NULL==pVarResult)
pVarResult=&varResult;
VariantInit(pVarResult);
//The most common case is boolean, use as an initial type
V_VT(pVarResult)=VT_BOOL;
/*
* Process the requested ambient property. Anything but a
* request for a property is invalid, so we can check that
* before looking at the specific ID. We can only get away
* with this because all properties are read-only.
*/
if (!(DISPATCH_PROPERTYGET & wFlags))
return ResultFromScode(DISP_E_MEMBERNOTFOUND);
hr=NOERROR;
switch (dispIDMember)
{
case DISPID_AMBIENT_BACKCOLOR:
V_I4(pVarResult)=m_pTen->m_ambientProp.getBackColor();
V_VT(pVarResult)=VT_I4;
break;
case DISPID_AMBIENT_FORECOLOR:
V_I4(pVarResult)=m_pTen->m_ambientProp.getForeColor();
V_VT(pVarResult)=VT_I4;
break;
case DISPID_AMBIENT_FONT:
/*
* If we failed to create the font, act like we
* don't support it.
*/
if (!m_pTen->m_ambientProp.has_font())
return ResultFromScode(DISP_E_MEMBERNOTFOUND);
//The correct type is an IFontDisp pointer
V_DISPATCH(pVarResult)=m_pTen->m_ambientProp.getFontRef();
V_VT(pVarResult)=VT_FONT;
break;
case DISPID_AMBIENT_LOCALEID:
V_I4(pVarResult)=m_pTen->m_ambientProp.getLCID();
V_VT(pVarResult)=VT_I4;
break;
case DISPID_AMBIENT_USERMODE:
V_BOOL(pVarResult)=!m_pTen->m_ambientProp.getDesignMode();
V_VT(pVarResult) = VT_BOOL;
break;
case DISPID_AMBIENT_UIDEAD:
//V_BOOL(pVarResult)=m_pTen->m_ambientProp.getUIDead();
V_BOOL(pVarResult)=FALSE;
V_VT(pVarResult) = VT_BOOL;
break;
case DISPID_AMBIENT_SUPPORTSMNEMONICS:
V_BOOL(pVarResult)=TRUE;
break;
case DISPID_AMBIENT_SHOWGRABHANDLES:
//V_BOOL(pVarResult)=m_pTen->m_ambientProp.m_fHatchHandles;
V_BOOL(pVarResult)=FALSE;
V_VT(pVarResult) = VT_BOOL;
break;
case DISPID_AMBIENT_SHOWHATCHING:
// V_BOOL(pVarResult)=m_pTen->m_ambientProp.m_fHatchHandles;
V_BOOL(pVarResult)=FALSE;
V_VT(pVarResult) = VT_BOOL;
break;
default:
hr=ResultFromScode(DISP_E_MEMBERNOTFOUND);
break;
}
return hr;
}
|
