1*b1cdbd2cSJim Jagielski /**************************************************************
2*b1cdbd2cSJim Jagielski *
3*b1cdbd2cSJim Jagielski * Licensed to the Apache Software Foundation (ASF) under one
4*b1cdbd2cSJim Jagielski * or more contributor license agreements. See the NOTICE file
5*b1cdbd2cSJim Jagielski * distributed with this work for additional information
6*b1cdbd2cSJim Jagielski * regarding copyright ownership. The ASF licenses this file
7*b1cdbd2cSJim Jagielski * to you under the Apache License, Version 2.0 (the
8*b1cdbd2cSJim Jagielski * "License"); you may not use this file except in compliance
9*b1cdbd2cSJim Jagielski * with the License. You may obtain a copy of the License at
10*b1cdbd2cSJim Jagielski *
11*b1cdbd2cSJim Jagielski * http://www.apache.org/licenses/LICENSE-2.0
12*b1cdbd2cSJim Jagielski *
13*b1cdbd2cSJim Jagielski * Unless required by applicable law or agreed to in writing,
14*b1cdbd2cSJim Jagielski * software distributed under the License is distributed on an
15*b1cdbd2cSJim Jagielski * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*b1cdbd2cSJim Jagielski * KIND, either express or implied. See the License for the
17*b1cdbd2cSJim Jagielski * specific language governing permissions and limitations
18*b1cdbd2cSJim Jagielski * under the License.
19*b1cdbd2cSJim Jagielski *
20*b1cdbd2cSJim Jagielski *************************************************************/
21*b1cdbd2cSJim Jagielski
22*b1cdbd2cSJim Jagielski
23*b1cdbd2cSJim Jagielski #include "stdafx.h"
24*b1cdbd2cSJim Jagielski //#include "AxTestComponents.h"
25*b1cdbd2cSJim Jagielski #include "Basic.h"
26*b1cdbd2cSJim Jagielski
27*b1cdbd2cSJim Jagielski
28*b1cdbd2cSJim Jagielski
29*b1cdbd2cSJim Jagielski /////////////////////////////////////////////////////////////////////////////
30*b1cdbd2cSJim Jagielski // CBasic
CBasic()31*b1cdbd2cSJim Jagielski CBasic::CBasic(): m_cPrpByte(0),m_nPrpShort(0),m_lPrpLong(0),m_fPrpFloat(0), m_dPrpDouble(0),m_PrpArray(0),
32*b1cdbd2cSJim Jagielski m_safearray(NULL), m_bool(VARIANT_FALSE),
33*b1cdbd2cSJim Jagielski m_arByte(0), m_arShort(0), m_arLong(0), m_arString(0), m_arVariant(0), m_arFloat(0),
34*b1cdbd2cSJim Jagielski m_arDouble(0), m_arObject(0), m_arByteDim2(0), m_date(0.), m_scode(0)
35*b1cdbd2cSJim Jagielski
36*b1cdbd2cSJim Jagielski {
37*b1cdbd2cSJim Jagielski memset(&m_cy, 0, sizeof(CY));
38*b1cdbd2cSJim Jagielski memset(&m_decimal, 0, sizeof(DECIMAL));
39*b1cdbd2cSJim Jagielski }
40*b1cdbd2cSJim Jagielski
~CBasic()41*b1cdbd2cSJim Jagielski CBasic::~CBasic()
42*b1cdbd2cSJim Jagielski {
43*b1cdbd2cSJim Jagielski SafeArrayDestroy(m_safearray);
44*b1cdbd2cSJim Jagielski SafeArrayDestroy(m_arByte);
45*b1cdbd2cSJim Jagielski SafeArrayDestroy(m_arShort);
46*b1cdbd2cSJim Jagielski SafeArrayDestroy(m_arLong);
47*b1cdbd2cSJim Jagielski SafeArrayDestroy(m_arString);
48*b1cdbd2cSJim Jagielski SafeArrayDestroy(m_arVariant);
49*b1cdbd2cSJim Jagielski SafeArrayDestroy(m_arFloat);
50*b1cdbd2cSJim Jagielski SafeArrayDestroy(m_arDouble);
51*b1cdbd2cSJim Jagielski SafeArrayDestroy(m_arObject);
52*b1cdbd2cSJim Jagielski SafeArrayDestroy(m_arByteDim2);
53*b1cdbd2cSJim Jagielski
54*b1cdbd2cSJim Jagielski }
inBool(VARIANT_BOOL val)55*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inBool(VARIANT_BOOL val)
56*b1cdbd2cSJim Jagielski {
57*b1cdbd2cSJim Jagielski m_bool = val;
58*b1cdbd2cSJim Jagielski return S_OK;
59*b1cdbd2cSJim Jagielski }
inByte(unsigned char val)60*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inByte(unsigned char val)
61*b1cdbd2cSJim Jagielski {
62*b1cdbd2cSJim Jagielski m_byte = val;
63*b1cdbd2cSJim Jagielski return S_OK;
64*b1cdbd2cSJim Jagielski }
65*b1cdbd2cSJim Jagielski
inShort(short val)66*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inShort(short val)
67*b1cdbd2cSJim Jagielski {
68*b1cdbd2cSJim Jagielski m_short = val;
69*b1cdbd2cSJim Jagielski return S_OK;
70*b1cdbd2cSJim Jagielski }
71*b1cdbd2cSJim Jagielski
inLong(long val)72*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inLong(long val)
73*b1cdbd2cSJim Jagielski {
74*b1cdbd2cSJim Jagielski m_long = val;
75*b1cdbd2cSJim Jagielski return S_OK;
76*b1cdbd2cSJim Jagielski }
77*b1cdbd2cSJim Jagielski
inString(BSTR val)78*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inString(BSTR val)
79*b1cdbd2cSJim Jagielski {
80*b1cdbd2cSJim Jagielski m_bstr = val;
81*b1cdbd2cSJim Jagielski return S_OK;
82*b1cdbd2cSJim Jagielski }
83*b1cdbd2cSJim Jagielski
inFloat(float val)84*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inFloat(float val)
85*b1cdbd2cSJim Jagielski {
86*b1cdbd2cSJim Jagielski m_float = val;
87*b1cdbd2cSJim Jagielski return S_OK;
88*b1cdbd2cSJim Jagielski }
89*b1cdbd2cSJim Jagielski
inDouble(double val)90*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inDouble(double val)
91*b1cdbd2cSJim Jagielski {
92*b1cdbd2cSJim Jagielski m_double = val;
93*b1cdbd2cSJim Jagielski
94*b1cdbd2cSJim Jagielski CComVariant varDest;
95*b1cdbd2cSJim Jagielski CComVariant varSource(val);
96*b1cdbd2cSJim Jagielski HRESULT hr = VariantChangeType(&varDest, &varSource, 0, VT_BSTR);
97*b1cdbd2cSJim Jagielski return S_OK;
98*b1cdbd2cSJim Jagielski }
99*b1cdbd2cSJim Jagielski
inVariant(VARIANT val)100*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inVariant(VARIANT val)
101*b1cdbd2cSJim Jagielski {
102*b1cdbd2cSJim Jagielski m_var1 = val;
103*b1cdbd2cSJim Jagielski return S_OK;
104*b1cdbd2cSJim Jagielski }
105*b1cdbd2cSJim Jagielski
inArray(LPSAFEARRAY val)106*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inArray(LPSAFEARRAY val)
107*b1cdbd2cSJim Jagielski {
108*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
109*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayDestroy(m_safearray)))
110*b1cdbd2cSJim Jagielski return hr;
111*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(val, &m_safearray)))
112*b1cdbd2cSJim Jagielski return hr;
113*b1cdbd2cSJim Jagielski return S_OK;
114*b1cdbd2cSJim Jagielski }
115*b1cdbd2cSJim Jagielski
inObject(IDispatch * val)116*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inObject(IDispatch *val)
117*b1cdbd2cSJim Jagielski {
118*b1cdbd2cSJim Jagielski m_obj = val;
119*b1cdbd2cSJim Jagielski return S_OK;
120*b1cdbd2cSJim Jagielski }
121*b1cdbd2cSJim Jagielski
inoutBool(VARIANT_BOOL * val)122*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutBool(VARIANT_BOOL* val)
123*b1cdbd2cSJim Jagielski {
124*b1cdbd2cSJim Jagielski VARIANT_BOOL aBool = *val;
125*b1cdbd2cSJim Jagielski *val = m_bool;
126*b1cdbd2cSJim Jagielski m_bool = aBool;
127*b1cdbd2cSJim Jagielski return S_OK;
128*b1cdbd2cSJim Jagielski }
129*b1cdbd2cSJim Jagielski
130*b1cdbd2cSJim Jagielski
inoutByte(unsigned char * val)131*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutByte(unsigned char* val)
132*b1cdbd2cSJim Jagielski {
133*b1cdbd2cSJim Jagielski unsigned char aByte = *val;
134*b1cdbd2cSJim Jagielski *val = m_byte;
135*b1cdbd2cSJim Jagielski m_byte = aByte;
136*b1cdbd2cSJim Jagielski return S_OK;
137*b1cdbd2cSJim Jagielski }
138*b1cdbd2cSJim Jagielski
inoutShort(short * val)139*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutShort(short *val)
140*b1cdbd2cSJim Jagielski {
141*b1cdbd2cSJim Jagielski short aShort = *val;
142*b1cdbd2cSJim Jagielski *val = m_short;
143*b1cdbd2cSJim Jagielski m_short = aShort;
144*b1cdbd2cSJim Jagielski return S_OK;
145*b1cdbd2cSJim Jagielski }
146*b1cdbd2cSJim Jagielski
inoutLong(long * val)147*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutLong(long *val)
148*b1cdbd2cSJim Jagielski {
149*b1cdbd2cSJim Jagielski long aLong = *val;
150*b1cdbd2cSJim Jagielski *val = m_long;
151*b1cdbd2cSJim Jagielski m_long = aLong;
152*b1cdbd2cSJim Jagielski return S_OK;
153*b1cdbd2cSJim Jagielski }
154*b1cdbd2cSJim Jagielski
inoutString(BSTR * val)155*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutString(BSTR *val)
156*b1cdbd2cSJim Jagielski {
157*b1cdbd2cSJim Jagielski CComBSTR aStr = *val;
158*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
159*b1cdbd2cSJim Jagielski if (FAILED( hr = m_bstr.CopyTo(val)))
160*b1cdbd2cSJim Jagielski return hr;
161*b1cdbd2cSJim Jagielski m_bstr = aStr;
162*b1cdbd2cSJim Jagielski return S_OK;
163*b1cdbd2cSJim Jagielski }
164*b1cdbd2cSJim Jagielski
inoutFloat(float * val)165*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutFloat(float *val)
166*b1cdbd2cSJim Jagielski {
167*b1cdbd2cSJim Jagielski float aFloat = *val;
168*b1cdbd2cSJim Jagielski *val = m_float;
169*b1cdbd2cSJim Jagielski m_float = aFloat;
170*b1cdbd2cSJim Jagielski return S_OK;
171*b1cdbd2cSJim Jagielski }
172*b1cdbd2cSJim Jagielski
inoutDouble(double * val)173*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutDouble(double *val)
174*b1cdbd2cSJim Jagielski {
175*b1cdbd2cSJim Jagielski double aDouble = *val;
176*b1cdbd2cSJim Jagielski *val = m_double;
177*b1cdbd2cSJim Jagielski m_double = aDouble;
178*b1cdbd2cSJim Jagielski return S_OK;
179*b1cdbd2cSJim Jagielski }
180*b1cdbd2cSJim Jagielski
inoutVariant(VARIANT * val)181*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutVariant(VARIANT *val)
182*b1cdbd2cSJim Jagielski {
183*b1cdbd2cSJim Jagielski CComVariant aVar = *val;
184*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
185*b1cdbd2cSJim Jagielski if (FAILED(hr = VariantCopy(val, &m_var1)))
186*b1cdbd2cSJim Jagielski return hr;
187*b1cdbd2cSJim Jagielski m_var1 = aVar;
188*b1cdbd2cSJim Jagielski return S_OK;
189*b1cdbd2cSJim Jagielski }
190*b1cdbd2cSJim Jagielski
191*b1cdbd2cSJim Jagielski /* The array contains VARIANT according to IDL.
192*b1cdbd2cSJim Jagielski If the VARIANTs contain strings then we append "out" to each string.
193*b1cdbd2cSJim Jagielski */
inoutArray(LPSAFEARRAY * val)194*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutArray(LPSAFEARRAY *val)
195*b1cdbd2cSJim Jagielski {
196*b1cdbd2cSJim Jagielski SAFEARRAY* aAr = NULL;
197*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
198*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(*val, &aAr)))
199*b1cdbd2cSJim Jagielski return hr;
200*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(m_safearray, val)))
201*b1cdbd2cSJim Jagielski return hr;
202*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(aAr, & m_safearray)))
203*b1cdbd2cSJim Jagielski return hr;
204*b1cdbd2cSJim Jagielski return S_OK;
205*b1cdbd2cSJim Jagielski }
206*b1cdbd2cSJim Jagielski
inoutObject(IDispatch ** val)207*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutObject(IDispatch **val)
208*b1cdbd2cSJim Jagielski {
209*b1cdbd2cSJim Jagielski CComPtr<IDispatch> disp = *val;
210*b1cdbd2cSJim Jagielski if (*val)
211*b1cdbd2cSJim Jagielski (*val)->Release();
212*b1cdbd2cSJim Jagielski *val = m_obj;
213*b1cdbd2cSJim Jagielski if (*val)
214*b1cdbd2cSJim Jagielski (*val)->AddRef();
215*b1cdbd2cSJim Jagielski m_obj = disp;
216*b1cdbd2cSJim Jagielski return S_OK;
217*b1cdbd2cSJim Jagielski }
218*b1cdbd2cSJim Jagielski
219*b1cdbd2cSJim Jagielski
outBool(VARIANT_BOOL * val)220*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outBool(VARIANT_BOOL* val)
221*b1cdbd2cSJim Jagielski {
222*b1cdbd2cSJim Jagielski *val = m_bool;
223*b1cdbd2cSJim Jagielski return S_OK;
224*b1cdbd2cSJim Jagielski }
225*b1cdbd2cSJim Jagielski
outByte(unsigned char * val)226*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outByte(unsigned char *val)
227*b1cdbd2cSJim Jagielski {
228*b1cdbd2cSJim Jagielski *val= m_byte;
229*b1cdbd2cSJim Jagielski return S_OK;
230*b1cdbd2cSJim Jagielski }
231*b1cdbd2cSJim Jagielski
outShort(short * val)232*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outShort(short *val)
233*b1cdbd2cSJim Jagielski {
234*b1cdbd2cSJim Jagielski *val= m_short;
235*b1cdbd2cSJim Jagielski return S_OK;
236*b1cdbd2cSJim Jagielski }
237*b1cdbd2cSJim Jagielski
outLong(long * val)238*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outLong(long *val)
239*b1cdbd2cSJim Jagielski {
240*b1cdbd2cSJim Jagielski *val= m_long;
241*b1cdbd2cSJim Jagielski return S_OK;
242*b1cdbd2cSJim Jagielski }
243*b1cdbd2cSJim Jagielski
outString(BSTR * val)244*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outString(BSTR *val)
245*b1cdbd2cSJim Jagielski {
246*b1cdbd2cSJim Jagielski *val= SysAllocString(m_bstr);
247*b1cdbd2cSJim Jagielski return S_OK;
248*b1cdbd2cSJim Jagielski }
249*b1cdbd2cSJim Jagielski
outFloat(float * val)250*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outFloat(float *val)
251*b1cdbd2cSJim Jagielski {
252*b1cdbd2cSJim Jagielski *val= m_float;
253*b1cdbd2cSJim Jagielski return S_OK;
254*b1cdbd2cSJim Jagielski }
255*b1cdbd2cSJim Jagielski
outDouble(double * val)256*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outDouble(double *val)
257*b1cdbd2cSJim Jagielski {
258*b1cdbd2cSJim Jagielski *val= m_double;
259*b1cdbd2cSJim Jagielski return S_OK;
260*b1cdbd2cSJim Jagielski }
261*b1cdbd2cSJim Jagielski
outVariant(VARIANT * val)262*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outVariant(VARIANT *val)
263*b1cdbd2cSJim Jagielski {
264*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
265*b1cdbd2cSJim Jagielski if (FAILED(hr = VariantCopy(val, &m_var1)))
266*b1cdbd2cSJim Jagielski return hr;
267*b1cdbd2cSJim Jagielski return S_OK;
268*b1cdbd2cSJim Jagielski }
269*b1cdbd2cSJim Jagielski
outArray(LPSAFEARRAY * val)270*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outArray(LPSAFEARRAY *val)
271*b1cdbd2cSJim Jagielski {
272*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
273*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(m_safearray, val)))
274*b1cdbd2cSJim Jagielski return false;
275*b1cdbd2cSJim Jagielski return S_OK;
276*b1cdbd2cSJim Jagielski }
277*b1cdbd2cSJim Jagielski
outObject(IDispatch ** val)278*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outObject(IDispatch* *val)
279*b1cdbd2cSJim Jagielski {
280*b1cdbd2cSJim Jagielski *val = m_obj;
281*b1cdbd2cSJim Jagielski if (m_obj)
282*b1cdbd2cSJim Jagielski (*val)->AddRef();
283*b1cdbd2cSJim Jagielski
284*b1cdbd2cSJim Jagielski return S_OK;
285*b1cdbd2cSJim Jagielski }
286*b1cdbd2cSJim Jagielski
287*b1cdbd2cSJim Jagielski
get_prpBool(VARIANT_BOOL * pVal)288*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prpBool(VARIANT_BOOL* pVal)
289*b1cdbd2cSJim Jagielski {
290*b1cdbd2cSJim Jagielski if (!pVal) return E_POINTER;
291*b1cdbd2cSJim Jagielski *pVal = m_bool;
292*b1cdbd2cSJim Jagielski return S_OK;
293*b1cdbd2cSJim Jagielski }
294*b1cdbd2cSJim Jagielski
put_prpBool(VARIANT_BOOL val)295*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::put_prpBool(VARIANT_BOOL val)
296*b1cdbd2cSJim Jagielski {
297*b1cdbd2cSJim Jagielski m_bool = val;
298*b1cdbd2cSJim Jagielski return S_OK;
299*b1cdbd2cSJim Jagielski }
300*b1cdbd2cSJim Jagielski
301*b1cdbd2cSJim Jagielski
get_prpByte(unsigned char * pVal)302*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prpByte(unsigned char *pVal)
303*b1cdbd2cSJim Jagielski {
304*b1cdbd2cSJim Jagielski if( !pVal)
305*b1cdbd2cSJim Jagielski return E_POINTER;
306*b1cdbd2cSJim Jagielski *pVal= m_cPrpByte;
307*b1cdbd2cSJim Jagielski return S_OK;
308*b1cdbd2cSJim Jagielski }
309*b1cdbd2cSJim Jagielski
put_prpByte(unsigned char newVal)310*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::put_prpByte(unsigned char newVal)
311*b1cdbd2cSJim Jagielski {
312*b1cdbd2cSJim Jagielski m_cPrpByte= newVal;
313*b1cdbd2cSJim Jagielski return S_OK;
314*b1cdbd2cSJim Jagielski }
315*b1cdbd2cSJim Jagielski
get_prpShort(short * pVal)316*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prpShort(short *pVal)
317*b1cdbd2cSJim Jagielski {
318*b1cdbd2cSJim Jagielski if( !pVal)
319*b1cdbd2cSJim Jagielski return E_POINTER;
320*b1cdbd2cSJim Jagielski *pVal= m_nPrpShort;
321*b1cdbd2cSJim Jagielski return S_OK;
322*b1cdbd2cSJim Jagielski }
323*b1cdbd2cSJim Jagielski
put_prpShort(short newVal)324*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::put_prpShort(short newVal)
325*b1cdbd2cSJim Jagielski {
326*b1cdbd2cSJim Jagielski m_nPrpShort= newVal;
327*b1cdbd2cSJim Jagielski return S_OK;
328*b1cdbd2cSJim Jagielski }
329*b1cdbd2cSJim Jagielski
get_prpLong(long * pVal)330*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prpLong(long *pVal)
331*b1cdbd2cSJim Jagielski {
332*b1cdbd2cSJim Jagielski if( !pVal)
333*b1cdbd2cSJim Jagielski return E_POINTER;
334*b1cdbd2cSJim Jagielski *pVal= m_lPrpLong;
335*b1cdbd2cSJim Jagielski return S_OK;
336*b1cdbd2cSJim Jagielski }
337*b1cdbd2cSJim Jagielski
put_prpLong(long newVal)338*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::put_prpLong(long newVal)
339*b1cdbd2cSJim Jagielski {
340*b1cdbd2cSJim Jagielski m_lPrpLong= newVal;
341*b1cdbd2cSJim Jagielski return S_OK;
342*b1cdbd2cSJim Jagielski }
343*b1cdbd2cSJim Jagielski
get_prpString(BSTR * pVal)344*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prpString(BSTR *pVal)
345*b1cdbd2cSJim Jagielski {
346*b1cdbd2cSJim Jagielski if( !pVal)
347*b1cdbd2cSJim Jagielski return E_POINTER;
348*b1cdbd2cSJim Jagielski m_bstrPrpString.CopyTo( pVal );
349*b1cdbd2cSJim Jagielski return S_OK;
350*b1cdbd2cSJim Jagielski }
351*b1cdbd2cSJim Jagielski
put_prpString(BSTR newVal)352*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::put_prpString(BSTR newVal)
353*b1cdbd2cSJim Jagielski {
354*b1cdbd2cSJim Jagielski m_bstrPrpString= newVal;
355*b1cdbd2cSJim Jagielski return S_OK;
356*b1cdbd2cSJim Jagielski }
357*b1cdbd2cSJim Jagielski
get_prpFloat(float * pVal)358*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prpFloat(float *pVal)
359*b1cdbd2cSJim Jagielski {
360*b1cdbd2cSJim Jagielski if( !pVal)
361*b1cdbd2cSJim Jagielski return E_POINTER;
362*b1cdbd2cSJim Jagielski *pVal= m_fPrpFloat;
363*b1cdbd2cSJim Jagielski return S_OK;
364*b1cdbd2cSJim Jagielski }
365*b1cdbd2cSJim Jagielski
put_prpFloat(float newVal)366*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::put_prpFloat(float newVal)
367*b1cdbd2cSJim Jagielski {
368*b1cdbd2cSJim Jagielski m_fPrpFloat= newVal;
369*b1cdbd2cSJim Jagielski return S_OK;
370*b1cdbd2cSJim Jagielski }
371*b1cdbd2cSJim Jagielski
get_prpDouble(double * pVal)372*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prpDouble(double *pVal)
373*b1cdbd2cSJim Jagielski {
374*b1cdbd2cSJim Jagielski if( !pVal)
375*b1cdbd2cSJim Jagielski return E_POINTER;
376*b1cdbd2cSJim Jagielski *pVal= m_dPrpDouble;
377*b1cdbd2cSJim Jagielski return S_OK;
378*b1cdbd2cSJim Jagielski }
379*b1cdbd2cSJim Jagielski
put_prpDouble(double newVal)380*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::put_prpDouble(double newVal)
381*b1cdbd2cSJim Jagielski {
382*b1cdbd2cSJim Jagielski m_dPrpDouble= newVal;
383*b1cdbd2cSJim Jagielski return S_OK;
384*b1cdbd2cSJim Jagielski }
385*b1cdbd2cSJim Jagielski
get_prpVariant(VARIANT * pVal)386*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prpVariant(VARIANT *pVal)
387*b1cdbd2cSJim Jagielski {
388*b1cdbd2cSJim Jagielski if( !pVal)
389*b1cdbd2cSJim Jagielski return E_POINTER;
390*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
391*b1cdbd2cSJim Jagielski if (FAILED(hr = VariantCopy( pVal, &m_PropVariant)))
392*b1cdbd2cSJim Jagielski return hr;
393*b1cdbd2cSJim Jagielski return hr;
394*b1cdbd2cSJim Jagielski }
395*b1cdbd2cSJim Jagielski
put_prpVariant(VARIANT newVal)396*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::put_prpVariant(VARIANT newVal)
397*b1cdbd2cSJim Jagielski {
398*b1cdbd2cSJim Jagielski m_PropVariant= newVal;
399*b1cdbd2cSJim Jagielski return S_OK;
400*b1cdbd2cSJim Jagielski }
401*b1cdbd2cSJim Jagielski
get_prpArray(LPSAFEARRAY * pVal)402*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prpArray(LPSAFEARRAY *pVal)
403*b1cdbd2cSJim Jagielski {
404*b1cdbd2cSJim Jagielski if( !pVal)
405*b1cdbd2cSJim Jagielski return E_POINTER;
406*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
407*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy( m_PrpArray, pVal)))
408*b1cdbd2cSJim Jagielski return hr;
409*b1cdbd2cSJim Jagielski return hr;
410*b1cdbd2cSJim Jagielski }
411*b1cdbd2cSJim Jagielski
put_prpArray(LPSAFEARRAY newVal)412*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::put_prpArray(LPSAFEARRAY newVal)
413*b1cdbd2cSJim Jagielski {
414*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
415*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayDestroy( m_PrpArray)))
416*b1cdbd2cSJim Jagielski return hr;
417*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy( newVal, &m_PrpArray)))
418*b1cdbd2cSJim Jagielski return hr;
419*b1cdbd2cSJim Jagielski return hr;
420*b1cdbd2cSJim Jagielski }
421*b1cdbd2cSJim Jagielski
get_prpObject(IDispatch ** pVal)422*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prpObject(IDispatch **pVal)
423*b1cdbd2cSJim Jagielski {
424*b1cdbd2cSJim Jagielski if( !pVal)
425*b1cdbd2cSJim Jagielski return E_POINTER;
426*b1cdbd2cSJim Jagielski *pVal= m_PrpObject;
427*b1cdbd2cSJim Jagielski if( *pVal != NULL)
428*b1cdbd2cSJim Jagielski (*pVal)->AddRef();
429*b1cdbd2cSJim Jagielski return S_OK;
430*b1cdbd2cSJim Jagielski }
431*b1cdbd2cSJim Jagielski
put_prpObject(IDispatch * newVal)432*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::put_prpObject(IDispatch *newVal)
433*b1cdbd2cSJim Jagielski {
434*b1cdbd2cSJim Jagielski m_PrpObject= newVal;
435*b1cdbd2cSJim Jagielski return S_OK;
436*b1cdbd2cSJim Jagielski }
437*b1cdbd2cSJim Jagielski
mixed1(unsigned char * aChar,float * aFloat,VARIANT * aVar)438*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::mixed1(
439*b1cdbd2cSJim Jagielski /* [out][in] */ unsigned char *aChar,
440*b1cdbd2cSJim Jagielski /* [out][in] */ float *aFloat,
441*b1cdbd2cSJim Jagielski /* [out][in] */ VARIANT *aVar)
442*b1cdbd2cSJim Jagielski
443*b1cdbd2cSJim Jagielski {
444*b1cdbd2cSJim Jagielski HRESULT hr= S_OK;
445*b1cdbd2cSJim Jagielski inoutByte(aChar);
446*b1cdbd2cSJim Jagielski inoutFloat(aFloat);
447*b1cdbd2cSJim Jagielski inoutVariant(aVar);
448*b1cdbd2cSJim Jagielski return hr;
449*b1cdbd2cSJim Jagielski }
450*b1cdbd2cSJim Jagielski
451*b1cdbd2cSJim Jagielski
452*b1cdbd2cSJim Jagielski
453*b1cdbd2cSJim Jagielski
454*b1cdbd2cSJim Jagielski // VT_UI1
455*b1cdbd2cSJim Jagielski
inSequenceLong(LPSAFEARRAY val)456*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inSequenceLong(LPSAFEARRAY val)
457*b1cdbd2cSJim Jagielski {
458*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
459*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayDestroy(m_arLong)))
460*b1cdbd2cSJim Jagielski return hr;
461*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(val, & m_arLong)))
462*b1cdbd2cSJim Jagielski return hr;
463*b1cdbd2cSJim Jagielski return hr;
464*b1cdbd2cSJim Jagielski }
465*b1cdbd2cSJim Jagielski
inSequenceByte(LPSAFEARRAY val)466*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inSequenceByte( LPSAFEARRAY val)
467*b1cdbd2cSJim Jagielski {
468*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
469*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayDestroy(m_arByte)))
470*b1cdbd2cSJim Jagielski return hr;
471*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(val, & m_arByte)))
472*b1cdbd2cSJim Jagielski return hr;
473*b1cdbd2cSJim Jagielski return hr;
474*b1cdbd2cSJim Jagielski }
475*b1cdbd2cSJim Jagielski
inSequenceShort(LPSAFEARRAY val)476*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inSequenceShort(LPSAFEARRAY val)
477*b1cdbd2cSJim Jagielski {
478*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
479*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayDestroy(m_arShort)))
480*b1cdbd2cSJim Jagielski return hr;
481*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(val, & m_arShort)))
482*b1cdbd2cSJim Jagielski return hr;
483*b1cdbd2cSJim Jagielski return hr;
484*b1cdbd2cSJim Jagielski }
485*b1cdbd2cSJim Jagielski
inSequenceString(LPSAFEARRAY val)486*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inSequenceString(LPSAFEARRAY val)
487*b1cdbd2cSJim Jagielski {
488*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
489*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayDestroy(m_arString)))
490*b1cdbd2cSJim Jagielski return hr;
491*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(val, & m_arString)))
492*b1cdbd2cSJim Jagielski return hr;
493*b1cdbd2cSJim Jagielski return hr;
494*b1cdbd2cSJim Jagielski }
495*b1cdbd2cSJim Jagielski
inSequenceFloat(LPSAFEARRAY val)496*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inSequenceFloat(LPSAFEARRAY val)
497*b1cdbd2cSJim Jagielski {
498*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
499*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayDestroy(m_arFloat)))
500*b1cdbd2cSJim Jagielski return hr;
501*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(val, & m_arFloat)))
502*b1cdbd2cSJim Jagielski return hr;
503*b1cdbd2cSJim Jagielski return hr;
504*b1cdbd2cSJim Jagielski }
505*b1cdbd2cSJim Jagielski
inSequenceDouble(LPSAFEARRAY val)506*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inSequenceDouble(LPSAFEARRAY val)
507*b1cdbd2cSJim Jagielski {
508*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
509*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayDestroy(m_arDouble)))
510*b1cdbd2cSJim Jagielski return hr;
511*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(val, & m_arDouble)))
512*b1cdbd2cSJim Jagielski return hr;
513*b1cdbd2cSJim Jagielski return hr;
514*b1cdbd2cSJim Jagielski }
515*b1cdbd2cSJim Jagielski
inSequenceObject(LPSAFEARRAY val)516*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inSequenceObject(LPSAFEARRAY val)
517*b1cdbd2cSJim Jagielski {
518*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
519*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayDestroy(m_arObject)))
520*b1cdbd2cSJim Jagielski return hr;
521*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(val, & m_arObject)))
522*b1cdbd2cSJim Jagielski return hr;
523*b1cdbd2cSJim Jagielski return hr;
524*b1cdbd2cSJim Jagielski }
525*b1cdbd2cSJim Jagielski
printArray(LPSAFEARRAY val,BSTR message,VARTYPE type)526*b1cdbd2cSJim Jagielski void CBasic::printArray( LPSAFEARRAY val, BSTR message, VARTYPE type)
527*b1cdbd2cSJim Jagielski {
528*b1cdbd2cSJim Jagielski
529*b1cdbd2cSJim Jagielski HRESULT hr= S_OK;
530*b1cdbd2cSJim Jagielski USES_CONVERSION;
531*b1cdbd2cSJim Jagielski long lbound=0;
532*b1cdbd2cSJim Jagielski long ubound= 0;
533*b1cdbd2cSJim Jagielski hr= SafeArrayGetLBound( val, 1, &lbound);
534*b1cdbd2cSJim Jagielski hr= SafeArrayGetUBound( val, 1, &ubound);
535*b1cdbd2cSJim Jagielski long length= ubound - lbound +1;
536*b1cdbd2cSJim Jagielski
537*b1cdbd2cSJim Jagielski CComVariant varElement;
538*b1cdbd2cSJim Jagielski char buf[1024];
539*b1cdbd2cSJim Jagielski sprintf( buf,"%s", W2A(message));
540*b1cdbd2cSJim Jagielski
541*b1cdbd2cSJim Jagielski for( long i= 0; i < length ; i++)
542*b1cdbd2cSJim Jagielski {
543*b1cdbd2cSJim Jagielski char tmp[1024];
544*b1cdbd2cSJim Jagielski long data=0;
545*b1cdbd2cSJim Jagielski CComVariant var;
546*b1cdbd2cSJim Jagielski switch( type)
547*b1cdbd2cSJim Jagielski {
548*b1cdbd2cSJim Jagielski case VT_UI1:
549*b1cdbd2cSJim Jagielski case VT_I2:
550*b1cdbd2cSJim Jagielski case VT_I4:
551*b1cdbd2cSJim Jagielski case VT_ERROR:
552*b1cdbd2cSJim Jagielski hr= SafeArrayGetElement( val, &i, (void*)&data);
553*b1cdbd2cSJim Jagielski sprintf( tmp, "%d \n", *(long*)&data);
554*b1cdbd2cSJim Jagielski break;
555*b1cdbd2cSJim Jagielski case VT_BSTR:
556*b1cdbd2cSJim Jagielski hr= SafeArrayGetElement( val, &i, (void*)&data);
557*b1cdbd2cSJim Jagielski sprintf( tmp, "%S \n", (BSTR)data);
558*b1cdbd2cSJim Jagielski break;
559*b1cdbd2cSJim Jagielski case VT_VARIANT:
560*b1cdbd2cSJim Jagielski hr= SafeArrayGetElement( val, &i, &var);
561*b1cdbd2cSJim Jagielski sprintf( tmp, "%x \n", var.byref);
562*b1cdbd2cSJim Jagielski break;
563*b1cdbd2cSJim Jagielski case VT_R4:
564*b1cdbd2cSJim Jagielski hr= SafeArrayGetElement( val, &i, (void*)&data);
565*b1cdbd2cSJim Jagielski sprintf( tmp, "%f \n", *(float*) &data);
566*b1cdbd2cSJim Jagielski break;
567*b1cdbd2cSJim Jagielski case VT_R8: ;
568*b1cdbd2cSJim Jagielski hr= SafeArrayGetElement( val, &i, (void*)&data);
569*b1cdbd2cSJim Jagielski sprintf( tmp, "%f \n", *(double*) &data);
570*b1cdbd2cSJim Jagielski break;
571*b1cdbd2cSJim Jagielski case VT_DISPATCH:
572*b1cdbd2cSJim Jagielski // we assume the objects are instances of this component and have the
573*b1cdbd2cSJim Jagielski // property prpString set.
574*b1cdbd2cSJim Jagielski hr= SafeArrayGetElement( val, &i, (void*)&data);
575*b1cdbd2cSJim Jagielski IDispatch* pdisp= ( IDispatch*) data;
576*b1cdbd2cSJim Jagielski CComDispatchDriver driver( pdisp);
577*b1cdbd2cSJim Jagielski CComVariant var;
578*b1cdbd2cSJim Jagielski if( pdisp)
579*b1cdbd2cSJim Jagielski {
580*b1cdbd2cSJim Jagielski driver.GetPropertyByName(L"prpString", &var);
581*b1cdbd2cSJim Jagielski sprintf( tmp, "%x : %S \n", *(long*)&data, var.bstrVal);
582*b1cdbd2cSJim Jagielski }
583*b1cdbd2cSJim Jagielski else
584*b1cdbd2cSJim Jagielski sprintf( tmp, "%x\n", *(long*)&data);
585*b1cdbd2cSJim Jagielski }
586*b1cdbd2cSJim Jagielski
587*b1cdbd2cSJim Jagielski strcat( buf, tmp);
588*b1cdbd2cSJim Jagielski }
589*b1cdbd2cSJim Jagielski MessageBox( NULL, _T(A2T(buf)), _T("AxTestComponents.Basic"), MB_OK);
590*b1cdbd2cSJim Jagielski
591*b1cdbd2cSJim Jagielski }
592*b1cdbd2cSJim Jagielski // V_ERROR OLECHAR VARIANT VT_UI1
593*b1cdbd2cSJim Jagielski
outSequenceByte(LPSAFEARRAY * val)594*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outSequenceByte(LPSAFEARRAY* val)
595*b1cdbd2cSJim Jagielski {
596*b1cdbd2cSJim Jagielski HRESULT hr= S_OK;
597*b1cdbd2cSJim Jagielski hr = SafeArrayCopy(m_arByte, val);
598*b1cdbd2cSJim Jagielski return hr;
599*b1cdbd2cSJim Jagielski }
600*b1cdbd2cSJim Jagielski
outSequenceShort(LPSAFEARRAY * val)601*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outSequenceShort(LPSAFEARRAY* val)
602*b1cdbd2cSJim Jagielski {
603*b1cdbd2cSJim Jagielski HRESULT hr= S_OK;
604*b1cdbd2cSJim Jagielski hr = SafeArrayCopy(m_arShort, val);
605*b1cdbd2cSJim Jagielski return hr;
606*b1cdbd2cSJim Jagielski }
607*b1cdbd2cSJim Jagielski
outSequenceLong(LPSAFEARRAY * val)608*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outSequenceLong(LPSAFEARRAY* val)
609*b1cdbd2cSJim Jagielski {
610*b1cdbd2cSJim Jagielski HRESULT hr= S_OK;
611*b1cdbd2cSJim Jagielski hr = SafeArrayCopy(m_arLong, val);
612*b1cdbd2cSJim Jagielski return hr;
613*b1cdbd2cSJim Jagielski }
614*b1cdbd2cSJim Jagielski
outSequenceString(LPSAFEARRAY * val)615*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outSequenceString(LPSAFEARRAY* val)
616*b1cdbd2cSJim Jagielski {
617*b1cdbd2cSJim Jagielski HRESULT hr= S_OK;
618*b1cdbd2cSJim Jagielski hr = SafeArrayCopy(m_arString, val);
619*b1cdbd2cSJim Jagielski return hr;
620*b1cdbd2cSJim Jagielski }
621*b1cdbd2cSJim Jagielski
outSequenceFloat(LPSAFEARRAY * val)622*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outSequenceFloat(LPSAFEARRAY* val)
623*b1cdbd2cSJim Jagielski {
624*b1cdbd2cSJim Jagielski HRESULT hr= S_OK;
625*b1cdbd2cSJim Jagielski hr = SafeArrayCopy(m_arFloat, val);
626*b1cdbd2cSJim Jagielski return hr;
627*b1cdbd2cSJim Jagielski }
628*b1cdbd2cSJim Jagielski
outSequenceDouble(LPSAFEARRAY * val)629*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outSequenceDouble(LPSAFEARRAY* val)
630*b1cdbd2cSJim Jagielski {
631*b1cdbd2cSJim Jagielski HRESULT hr= S_OK;
632*b1cdbd2cSJim Jagielski hr = SafeArrayCopy(m_arDouble, val);
633*b1cdbd2cSJim Jagielski return hr;
634*b1cdbd2cSJim Jagielski }
635*b1cdbd2cSJim Jagielski
outSequenceObject(LPSAFEARRAY * val)636*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outSequenceObject(LPSAFEARRAY* val)
637*b1cdbd2cSJim Jagielski {
638*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
639*b1cdbd2cSJim Jagielski hr = SafeArrayCopy(m_arObject, val);
640*b1cdbd2cSJim Jagielski return S_OK;
641*b1cdbd2cSJim Jagielski }
642*b1cdbd2cSJim Jagielski
inoutSequenceByte(LPSAFEARRAY * val)643*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutSequenceByte(LPSAFEARRAY* val)
644*b1cdbd2cSJim Jagielski {
645*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
646*b1cdbd2cSJim Jagielski SAFEARRAY *arTemp = NULL;
647*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(*val, &arTemp)))
648*b1cdbd2cSJim Jagielski return hr;
649*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(m_arByte, val)))
650*b1cdbd2cSJim Jagielski return hr;
651*b1cdbd2cSJim Jagielski m_arByte = arTemp;
652*b1cdbd2cSJim Jagielski return hr;
653*b1cdbd2cSJim Jagielski }
654*b1cdbd2cSJim Jagielski
inoutSequenceShort(LPSAFEARRAY * val)655*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutSequenceShort(LPSAFEARRAY* val)
656*b1cdbd2cSJim Jagielski {
657*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
658*b1cdbd2cSJim Jagielski SAFEARRAY *arTemp = NULL;
659*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(*val, &arTemp)))
660*b1cdbd2cSJim Jagielski return hr;
661*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(m_arShort, val)))
662*b1cdbd2cSJim Jagielski return hr;
663*b1cdbd2cSJim Jagielski m_arShort = arTemp;
664*b1cdbd2cSJim Jagielski return hr;
665*b1cdbd2cSJim Jagielski }
666*b1cdbd2cSJim Jagielski
inoutSequenceLong(LPSAFEARRAY * val)667*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutSequenceLong(LPSAFEARRAY* val)
668*b1cdbd2cSJim Jagielski {
669*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
670*b1cdbd2cSJim Jagielski SAFEARRAY *arTemp = NULL;
671*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(*val, &arTemp)))
672*b1cdbd2cSJim Jagielski return hr;
673*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(m_arLong, val)))
674*b1cdbd2cSJim Jagielski return hr;
675*b1cdbd2cSJim Jagielski m_arLong = arTemp;
676*b1cdbd2cSJim Jagielski return hr;
677*b1cdbd2cSJim Jagielski }
678*b1cdbd2cSJim Jagielski
inoutSequenceString(LPSAFEARRAY * val)679*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutSequenceString(LPSAFEARRAY* val)
680*b1cdbd2cSJim Jagielski {
681*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
682*b1cdbd2cSJim Jagielski SAFEARRAY *arTemp = NULL;
683*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(*val, &arTemp)))
684*b1cdbd2cSJim Jagielski return hr;
685*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(m_arString, val)))
686*b1cdbd2cSJim Jagielski return hr;
687*b1cdbd2cSJim Jagielski m_arString = arTemp;
688*b1cdbd2cSJim Jagielski return hr;
689*b1cdbd2cSJim Jagielski }
690*b1cdbd2cSJim Jagielski
inoutSequenceFloat(LPSAFEARRAY * val)691*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutSequenceFloat(LPSAFEARRAY* val)
692*b1cdbd2cSJim Jagielski {
693*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
694*b1cdbd2cSJim Jagielski SAFEARRAY *arTemp = NULL;
695*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(*val, &arTemp)))
696*b1cdbd2cSJim Jagielski return hr;
697*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(m_arFloat, val)))
698*b1cdbd2cSJim Jagielski return hr;
699*b1cdbd2cSJim Jagielski m_arFloat = arTemp;
700*b1cdbd2cSJim Jagielski return hr;
701*b1cdbd2cSJim Jagielski }
702*b1cdbd2cSJim Jagielski
inoutSequenceDouble(LPSAFEARRAY * val)703*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutSequenceDouble(LPSAFEARRAY* val)
704*b1cdbd2cSJim Jagielski {
705*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
706*b1cdbd2cSJim Jagielski SAFEARRAY *arTemp = NULL;
707*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(*val, &arTemp)))
708*b1cdbd2cSJim Jagielski return hr;
709*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(m_arDouble, val)))
710*b1cdbd2cSJim Jagielski return hr;
711*b1cdbd2cSJim Jagielski m_arDouble = arTemp;
712*b1cdbd2cSJim Jagielski return hr;
713*b1cdbd2cSJim Jagielski }
714*b1cdbd2cSJim Jagielski
inoutSequenceObject(LPSAFEARRAY * val)715*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutSequenceObject(LPSAFEARRAY* val)
716*b1cdbd2cSJim Jagielski {
717*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
718*b1cdbd2cSJim Jagielski SAFEARRAY *arTemp = NULL;
719*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(*val, &arTemp)))
720*b1cdbd2cSJim Jagielski return hr;
721*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(m_arObject, val)))
722*b1cdbd2cSJim Jagielski return hr;
723*b1cdbd2cSJim Jagielski m_arObject = arTemp;
724*b1cdbd2cSJim Jagielski return hr;
725*b1cdbd2cSJim Jagielski }
726*b1cdbd2cSJim Jagielski
727*b1cdbd2cSJim Jagielski // 2-dimensional Array
inMulDimArrayLong(LPSAFEARRAY val)728*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inMulDimArrayLong(LPSAFEARRAY val)
729*b1cdbd2cSJim Jagielski {
730*b1cdbd2cSJim Jagielski printMulArray( val, VT_I4);
731*b1cdbd2cSJim Jagielski return S_OK;
732*b1cdbd2cSJim Jagielski }
733*b1cdbd2cSJim Jagielski // 2-dimensional Array
inMulDimArrayVariant(LPSAFEARRAY val)734*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inMulDimArrayVariant(LPSAFEARRAY val)
735*b1cdbd2cSJim Jagielski {
736*b1cdbd2cSJim Jagielski printMulArray( val, VT_VARIANT);
737*b1cdbd2cSJim Jagielski return S_OK;
738*b1cdbd2cSJim Jagielski }
739*b1cdbd2cSJim Jagielski // 3-dimensional Array
inMulDimArrayLong2(LPSAFEARRAY val)740*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inMulDimArrayLong2(LPSAFEARRAY val)
741*b1cdbd2cSJim Jagielski {
742*b1cdbd2cSJim Jagielski printMulArray( val, VT_I4);
743*b1cdbd2cSJim Jagielski return S_OK;
744*b1cdbd2cSJim Jagielski }
745*b1cdbd2cSJim Jagielski // 3-dimensional Array
inMulDimArrayVariant2(LPSAFEARRAY val)746*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inMulDimArrayVariant2(LPSAFEARRAY val)
747*b1cdbd2cSJim Jagielski {
748*b1cdbd2cSJim Jagielski return S_OK;
749*b1cdbd2cSJim Jagielski }
750*b1cdbd2cSJim Jagielski
751*b1cdbd2cSJim Jagielski
inMulDimArrayByte(LPSAFEARRAY val)752*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inMulDimArrayByte(LPSAFEARRAY val)
753*b1cdbd2cSJim Jagielski {
754*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
755*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayDestroy(m_arByteDim2)))
756*b1cdbd2cSJim Jagielski return hr;
757*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(val, & m_arByteDim2)))
758*b1cdbd2cSJim Jagielski return hr;
759*b1cdbd2cSJim Jagielski return hr;
760*b1cdbd2cSJim Jagielski }
761*b1cdbd2cSJim Jagielski // 3-dimensionales array
inMulDimArrayByte2(LPSAFEARRAY val)762*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inMulDimArrayByte2(LPSAFEARRAY val)
763*b1cdbd2cSJim Jagielski {
764*b1cdbd2cSJim Jagielski
765*b1cdbd2cSJim Jagielski // TODO: Add your implementation code here
766*b1cdbd2cSJim Jagielski //printMulArray( val, VT_UI1);
767*b1cdbd2cSJim Jagielski return S_OK;
768*b1cdbd2cSJim Jagielski }
769*b1cdbd2cSJim Jagielski
770*b1cdbd2cSJim Jagielski // supports 2 and 3 dimensionals SAFEARRAY with elements of long or VARIANT
printMulArray(SAFEARRAY * val,VARTYPE type)771*b1cdbd2cSJim Jagielski void CBasic::printMulArray( SAFEARRAY* val, VARTYPE type)
772*b1cdbd2cSJim Jagielski {
773*b1cdbd2cSJim Jagielski HRESULT hr= S_OK;
774*b1cdbd2cSJim Jagielski UINT dims= SafeArrayGetDim( val);
775*b1cdbd2cSJim Jagielski long lbound1;
776*b1cdbd2cSJim Jagielski long ubound1;
777*b1cdbd2cSJim Jagielski long lbound2;
778*b1cdbd2cSJim Jagielski long ubound2;
779*b1cdbd2cSJim Jagielski long lbound3;
780*b1cdbd2cSJim Jagielski long ubound3;
781*b1cdbd2cSJim Jagielski long length1;
782*b1cdbd2cSJim Jagielski long length2;
783*b1cdbd2cSJim Jagielski long length3;
784*b1cdbd2cSJim Jagielski
785*b1cdbd2cSJim Jagielski char buff[4096];
786*b1cdbd2cSJim Jagielski buff[0]=0;
787*b1cdbd2cSJim Jagielski
788*b1cdbd2cSJim Jagielski if( dims == 2)
789*b1cdbd2cSJim Jagielski {
790*b1cdbd2cSJim Jagielski hr= SafeArrayGetLBound( val, 1, &lbound1);
791*b1cdbd2cSJim Jagielski hr= SafeArrayGetUBound( val, 1, &ubound1);
792*b1cdbd2cSJim Jagielski length1= ubound1 - lbound1 +1;
793*b1cdbd2cSJim Jagielski
794*b1cdbd2cSJim Jagielski hr= SafeArrayGetLBound( val, 2, &lbound2);
795*b1cdbd2cSJim Jagielski hr= SafeArrayGetUBound( val, 2, &ubound2);
796*b1cdbd2cSJim Jagielski length2= ubound2 - lbound2 + 1;
797*b1cdbd2cSJim Jagielski char tmpBuf[1024];
798*b1cdbd2cSJim Jagielski tmpBuf[0]=0;
799*b1cdbd2cSJim Jagielski long index[2];
800*b1cdbd2cSJim Jagielski for( long i= 0; i< length2; i++)
801*b1cdbd2cSJim Jagielski {
802*b1cdbd2cSJim Jagielski for( long j= 0; j<length1; j++)
803*b1cdbd2cSJim Jagielski {
804*b1cdbd2cSJim Jagielski index[0]= j;
805*b1cdbd2cSJim Jagielski index[1]= i;
806*b1cdbd2cSJim Jagielski long longVal;
807*b1cdbd2cSJim Jagielski CComVariant var;
808*b1cdbd2cSJim Jagielski switch( type)
809*b1cdbd2cSJim Jagielski {
810*b1cdbd2cSJim Jagielski case VT_I4:
811*b1cdbd2cSJim Jagielski hr= SafeArrayGetElement( val, index, &longVal);
812*b1cdbd2cSJim Jagielski sprintf( tmpBuf, "(%d,%d): %d\n", index[1], index[0], longVal);
813*b1cdbd2cSJim Jagielski break;
814*b1cdbd2cSJim Jagielski case VT_UI1:
815*b1cdbd2cSJim Jagielski hr= SafeArrayGetElement( val, index, &longVal);
816*b1cdbd2cSJim Jagielski sprintf( tmpBuf, "(%d,%d): %d\n", index[1], index[0], (unsigned char)longVal);
817*b1cdbd2cSJim Jagielski break;
818*b1cdbd2cSJim Jagielski case VT_VARIANT:
819*b1cdbd2cSJim Jagielski hr= SafeArrayGetElement( val, index, &var );
820*b1cdbd2cSJim Jagielski sprintf( tmpBuf, "(%d,%d): %d (vartype %d)\n", index[1], index[0], var.byref, var.vt);
821*b1cdbd2cSJim Jagielski break;
822*b1cdbd2cSJim Jagielski }
823*b1cdbd2cSJim Jagielski strcat( buff,tmpBuf);
824*b1cdbd2cSJim Jagielski }
825*b1cdbd2cSJim Jagielski
826*b1cdbd2cSJim Jagielski }
827*b1cdbd2cSJim Jagielski
828*b1cdbd2cSJim Jagielski
829*b1cdbd2cSJim Jagielski }
830*b1cdbd2cSJim Jagielski else if( dims == 3 )
831*b1cdbd2cSJim Jagielski {
832*b1cdbd2cSJim Jagielski hr= SafeArrayGetLBound( val, 1, &lbound1);
833*b1cdbd2cSJim Jagielski hr= SafeArrayGetUBound( val, 1, &ubound1);
834*b1cdbd2cSJim Jagielski length1= ubound1 - lbound1 +1;
835*b1cdbd2cSJim Jagielski
836*b1cdbd2cSJim Jagielski hr= SafeArrayGetLBound( val, 2, &lbound2);
837*b1cdbd2cSJim Jagielski hr= SafeArrayGetUBound( val, 2, &ubound2);
838*b1cdbd2cSJim Jagielski length2= ubound2 - lbound2 + 1;
839*b1cdbd2cSJim Jagielski
840*b1cdbd2cSJim Jagielski hr= SafeArrayGetLBound( val, 3, &lbound3);
841*b1cdbd2cSJim Jagielski hr= SafeArrayGetUBound( val, 3, &ubound3);
842*b1cdbd2cSJim Jagielski length3= ubound3 - lbound3 +1;
843*b1cdbd2cSJim Jagielski char tmpBuf[1024];
844*b1cdbd2cSJim Jagielski tmpBuf[0]=0;
845*b1cdbd2cSJim Jagielski long index[3];
846*b1cdbd2cSJim Jagielski for( long i= 0; i< length3; i++)
847*b1cdbd2cSJim Jagielski {
848*b1cdbd2cSJim Jagielski for( long j= 0; j<length2; j++)
849*b1cdbd2cSJim Jagielski {
850*b1cdbd2cSJim Jagielski for( long k= 0; k<length1; k++)
851*b1cdbd2cSJim Jagielski {
852*b1cdbd2cSJim Jagielski index[0]= k;
853*b1cdbd2cSJim Jagielski index[1]= j;
854*b1cdbd2cSJim Jagielski index[2]= i;
855*b1cdbd2cSJim Jagielski long longVal;
856*b1cdbd2cSJim Jagielski CComVariant var;
857*b1cdbd2cSJim Jagielski switch( type)
858*b1cdbd2cSJim Jagielski {
859*b1cdbd2cSJim Jagielski case VT_I4:
860*b1cdbd2cSJim Jagielski hr= SafeArrayGetElement( val, index, &longVal);
861*b1cdbd2cSJim Jagielski sprintf( tmpBuf, "(%d,%d,%d): %d\n", index[2], index[1], index[0], longVal);
862*b1cdbd2cSJim Jagielski break;
863*b1cdbd2cSJim Jagielski case VT_UI1:
864*b1cdbd2cSJim Jagielski hr= SafeArrayGetElement( val, index, &longVal);
865*b1cdbd2cSJim Jagielski sprintf( tmpBuf, "(%d,%d,%d): %d\n", index[2], index[1], index[0], (unsigned char)longVal);
866*b1cdbd2cSJim Jagielski break;
867*b1cdbd2cSJim Jagielski
868*b1cdbd2cSJim Jagielski case VT_VARIANT:
869*b1cdbd2cSJim Jagielski hr= SafeArrayGetElement( val, index, &var );
870*b1cdbd2cSJim Jagielski sprintf( tmpBuf, "(%d,%d,%d): %d (vartype %d)\n", index[2], index[1], index[0], var.byref, var.vt);
871*b1cdbd2cSJim Jagielski break;
872*b1cdbd2cSJim Jagielski }
873*b1cdbd2cSJim Jagielski strcat( buff,tmpBuf);
874*b1cdbd2cSJim Jagielski }
875*b1cdbd2cSJim Jagielski }
876*b1cdbd2cSJim Jagielski
877*b1cdbd2cSJim Jagielski }
878*b1cdbd2cSJim Jagielski
879*b1cdbd2cSJim Jagielski }
880*b1cdbd2cSJim Jagielski
881*b1cdbd2cSJim Jagielski MessageBox( NULL, A2T( buff), _T("AxTestControl.Basic"), MB_OK);
882*b1cdbd2cSJim Jagielski
883*b1cdbd2cSJim Jagielski
884*b1cdbd2cSJim Jagielski }
885*b1cdbd2cSJim Jagielski
886*b1cdbd2cSJim Jagielski
887*b1cdbd2cSJim Jagielski
888*b1cdbd2cSJim Jagielski
outMore(long * val1,long * val2)889*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outMore(long* val1, long* val2)
890*b1cdbd2cSJim Jagielski {
891*b1cdbd2cSJim Jagielski // TODO: Add your implementation code here
892*b1cdbd2cSJim Jagielski *val1= 111;
893*b1cdbd2cSJim Jagielski *val2= 112;
894*b1cdbd2cSJim Jagielski return S_OK;
895*b1cdbd2cSJim Jagielski }
896*b1cdbd2cSJim Jagielski // If an optional parameter was not provided then the respective member will
897*b1cdbd2cSJim Jagielski // not be set
optional1(long val1,VARIANT * val2)898*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::optional1(/*[in]*/ long val1, /*[in, optional]*/ VARIANT* val2)
899*b1cdbd2cSJim Jagielski {
900*b1cdbd2cSJim Jagielski m_long = val1;
901*b1cdbd2cSJim Jagielski if (val2->vt != VT_ERROR)
902*b1cdbd2cSJim Jagielski m_var1 = *val2;
903*b1cdbd2cSJim Jagielski return S_OK;
904*b1cdbd2cSJim Jagielski }
905*b1cdbd2cSJim Jagielski
optional2(long * val1,VARIANT * val2)906*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::optional2(/*[out]*/ long* val1,/*[out, optional]*/ VARIANT* val2)
907*b1cdbd2cSJim Jagielski {
908*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
909*b1cdbd2cSJim Jagielski *val1 = m_long;
910*b1cdbd2cSJim Jagielski
911*b1cdbd2cSJim Jagielski if (val2->vt != VT_ERROR)
912*b1cdbd2cSJim Jagielski hr = VariantCopy(val2, & m_var1);
913*b1cdbd2cSJim Jagielski return hr;
914*b1cdbd2cSJim Jagielski }
915*b1cdbd2cSJim Jagielski
optional3(VARIANT * val1,VARIANT * val2)916*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::optional3(/*[in, optional]*/ VARIANT* val1,/*[in, optional]*/ VARIANT* val2)
917*b1cdbd2cSJim Jagielski {
918*b1cdbd2cSJim Jagielski //if (val1->vt != VT_ERROR)
919*b1cdbd2cSJim Jagielski m_var1 = *val1;
920*b1cdbd2cSJim Jagielski
921*b1cdbd2cSJim Jagielski //if (val2->vt != VT_ERROR)
922*b1cdbd2cSJim Jagielski m_var2 = *val2;
923*b1cdbd2cSJim Jagielski return S_OK;
924*b1cdbd2cSJim Jagielski }
925*b1cdbd2cSJim Jagielski
optional4(VARIANT * val1,VARIANT * val2)926*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::optional4(/*[in, out, optional]*/ VARIANT* val1,
927*b1cdbd2cSJim Jagielski /*[in, out, optional]*/ VARIANT* val2)
928*b1cdbd2cSJim Jagielski {
929*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
930*b1cdbd2cSJim Jagielski //return the previously set in values
931*b1cdbd2cSJim Jagielski if (val1->vt != VT_ERROR)
932*b1cdbd2cSJim Jagielski {
933*b1cdbd2cSJim Jagielski CComVariant var1(*val1);
934*b1cdbd2cSJim Jagielski if (FAILED(hr = VariantCopy(val1, & m_var1)))
935*b1cdbd2cSJim Jagielski return hr;
936*b1cdbd2cSJim Jagielski m_var1 = var1;
937*b1cdbd2cSJim Jagielski }
938*b1cdbd2cSJim Jagielski if (val2->vt != VT_ERROR)
939*b1cdbd2cSJim Jagielski {
940*b1cdbd2cSJim Jagielski CComVariant var2(*val2);
941*b1cdbd2cSJim Jagielski if (FAILED(hr = VariantCopy(val2, & m_var2)))
942*b1cdbd2cSJim Jagielski return hr;
943*b1cdbd2cSJim Jagielski m_var2 = var2;
944*b1cdbd2cSJim Jagielski }
945*b1cdbd2cSJim Jagielski return hr;
946*b1cdbd2cSJim Jagielski }
947*b1cdbd2cSJim Jagielski
optional5(VARIANT * val1,VARIANT * val2)948*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::optional5(/*[out, optional]*/ VARIANT* val1,
949*b1cdbd2cSJim Jagielski /*[out, optional]*/ VARIANT* val2)
950*b1cdbd2cSJim Jagielski {
951*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
952*b1cdbd2cSJim Jagielski if (FAILED(hr = VariantCopy(val1, &m_var1)))
953*b1cdbd2cSJim Jagielski return hr;
954*b1cdbd2cSJim Jagielski if (FAILED(hr = VariantCopy(val2, &m_var2)))
955*b1cdbd2cSJim Jagielski return hr;
956*b1cdbd2cSJim Jagielski return hr;
957*b1cdbd2cSJim Jagielski }
958*b1cdbd2cSJim Jagielski
defaultvalue1(long val1,double * val2,VARIANT * val4)959*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::defaultvalue1(/*[in, defaultvalue(10)]*/ long val1,
960*b1cdbd2cSJim Jagielski /*[in, defaultvalue(3.14)]*/ double* val2,
961*b1cdbd2cSJim Jagielski // /*[in, defaultvalue(10)]*/ VARIANT val3,
962*b1cdbd2cSJim Jagielski /*[in, defaultvalue(100)]*/ VARIANT* val4)
963*b1cdbd2cSJim Jagielski {
964*b1cdbd2cSJim Jagielski m_long = val1;
965*b1cdbd2cSJim Jagielski m_double = *val2;
966*b1cdbd2cSJim Jagielski // m_var1 = val3;
967*b1cdbd2cSJim Jagielski m_var2 = *val4;
968*b1cdbd2cSJim Jagielski return S_OK;
969*b1cdbd2cSJim Jagielski }
defaultvalue2(long * val1,double * val2,VARIANT * val4)970*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::defaultvalue2(/*[in, out, defaultvalue(10)]*/ long* val1,
971*b1cdbd2cSJim Jagielski /*[in, out, defaultvalue(3.14)]*/ double* val2,
972*b1cdbd2cSJim Jagielski // /*[in, out, defaultvalue(10)]*/ VARIANT* val3,
973*b1cdbd2cSJim Jagielski /*[in, out, defaultvalue(100)]*/ VARIANT* val4)
974*b1cdbd2cSJim Jagielski {
975*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
976*b1cdbd2cSJim Jagielski long aLong = *val1;
977*b1cdbd2cSJim Jagielski double aDouble = *val2;
978*b1cdbd2cSJim Jagielski // CComVariant var1(*val3);
979*b1cdbd2cSJim Jagielski CComVariant var2(*val4);
980*b1cdbd2cSJim Jagielski *val1 = m_long;
981*b1cdbd2cSJim Jagielski *val2 = m_double;
982*b1cdbd2cSJim Jagielski //if (FAILED(hr = VariantCopy(val3, &m_var1)))
983*b1cdbd2cSJim Jagielski // return hr;
984*b1cdbd2cSJim Jagielski if (FAILED(hr = VariantCopy(val4, &m_var2)))
985*b1cdbd2cSJim Jagielski return hr;
986*b1cdbd2cSJim Jagielski m_long = aLong;
987*b1cdbd2cSJim Jagielski m_double = aDouble;
988*b1cdbd2cSJim Jagielski // m_var1 = var1;
989*b1cdbd2cSJim Jagielski m_var2 = var2;
990*b1cdbd2cSJim Jagielski return hr;
991*b1cdbd2cSJim Jagielski }
992*b1cdbd2cSJim Jagielski /* val2 contains the variable argument list. If no such arguments are supplied
993*b1cdbd2cSJim Jagielski then the safearray is invalid. SafeArrayCopy then returns E_INVALIDARG
994*b1cdbd2cSJim Jagielski */
varargfunc1(long val1,LPSAFEARRAY val2)995*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::varargfunc1(/*[in]*/ long val1,/*[in]*/ LPSAFEARRAY val2)
996*b1cdbd2cSJim Jagielski {
997*b1cdbd2cSJim Jagielski m_long = val1;
998*b1cdbd2cSJim Jagielski
999*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
1000*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayDestroy(m_safearray)))
1001*b1cdbd2cSJim Jagielski return hr;
1002*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(val2, & m_safearray)))
1003*b1cdbd2cSJim Jagielski {
1004*b1cdbd2cSJim Jagielski if (hr != E_INVALIDARG)
1005*b1cdbd2cSJim Jagielski return hr;
1006*b1cdbd2cSJim Jagielski }
1007*b1cdbd2cSJim Jagielski return S_OK;
1008*b1cdbd2cSJim Jagielski }
1009*b1cdbd2cSJim Jagielski
varargfunc2(long * val1,SAFEARRAY ** val2)1010*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::varargfunc2(/*[out]*/ long* val1, /*[out]*/ SAFEARRAY ** val2)
1011*b1cdbd2cSJim Jagielski {
1012*b1cdbd2cSJim Jagielski *val1 = m_long;
1013*b1cdbd2cSJim Jagielski HRESULT hr = SafeArrayCopy(m_safearray, val2);
1014*b1cdbd2cSJim Jagielski return hr;
1015*b1cdbd2cSJim Jagielski }
1016*b1cdbd2cSJim Jagielski
inSequenceByteDim2(LPSAFEARRAY val)1017*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inSequenceByteDim2(LPSAFEARRAY val)
1018*b1cdbd2cSJim Jagielski {
1019*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
1020*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayDestroy(m_arByteDim2)))
1021*b1cdbd2cSJim Jagielski return hr;
1022*b1cdbd2cSJim Jagielski if (FAILED(hr = SafeArrayCopy(val, & m_arByteDim2)))
1023*b1cdbd2cSJim Jagielski return hr;
1024*b1cdbd2cSJim Jagielski return hr;
1025*b1cdbd2cSJim Jagielski }
1026*b1cdbd2cSJim Jagielski
1027*b1cdbd2cSJim Jagielski
inCurrency(CY val)1028*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inCurrency(CY val)
1029*b1cdbd2cSJim Jagielski {
1030*b1cdbd2cSJim Jagielski m_cy = val;
1031*b1cdbd2cSJim Jagielski return S_OK;
1032*b1cdbd2cSJim Jagielski }
1033*b1cdbd2cSJim Jagielski
outCurrency(CY * val)1034*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outCurrency(CY* val)
1035*b1cdbd2cSJim Jagielski {
1036*b1cdbd2cSJim Jagielski *val = m_cy;
1037*b1cdbd2cSJim Jagielski return S_OK;
1038*b1cdbd2cSJim Jagielski }
1039*b1cdbd2cSJim Jagielski
inoutCurrency(CY * val)1040*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutCurrency(CY* val)
1041*b1cdbd2cSJim Jagielski {
1042*b1cdbd2cSJim Jagielski CY tmp = *val;
1043*b1cdbd2cSJim Jagielski *val = m_cy;
1044*b1cdbd2cSJim Jagielski m_cy = tmp;
1045*b1cdbd2cSJim Jagielski return S_OK;
1046*b1cdbd2cSJim Jagielski }
1047*b1cdbd2cSJim Jagielski
inDate(DATE val)1048*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inDate(DATE val)
1049*b1cdbd2cSJim Jagielski {
1050*b1cdbd2cSJim Jagielski m_date = val;
1051*b1cdbd2cSJim Jagielski return S_OK;
1052*b1cdbd2cSJim Jagielski }
1053*b1cdbd2cSJim Jagielski
outDate(DATE * val)1054*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outDate(DATE* val)
1055*b1cdbd2cSJim Jagielski {
1056*b1cdbd2cSJim Jagielski *val = m_date;
1057*b1cdbd2cSJim Jagielski return S_OK;
1058*b1cdbd2cSJim Jagielski }
1059*b1cdbd2cSJim Jagielski
inoutDate(DATE * val)1060*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutDate(DATE* val)
1061*b1cdbd2cSJim Jagielski {
1062*b1cdbd2cSJim Jagielski DATE tmp = *val;
1063*b1cdbd2cSJim Jagielski *val = m_date;
1064*b1cdbd2cSJim Jagielski m_date = tmp;
1065*b1cdbd2cSJim Jagielski return S_OK;
1066*b1cdbd2cSJim Jagielski }
1067*b1cdbd2cSJim Jagielski
get_prpCurrency(CY * pVal)1068*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prpCurrency(CY* pVal)
1069*b1cdbd2cSJim Jagielski {
1070*b1cdbd2cSJim Jagielski *pVal = m_cy;
1071*b1cdbd2cSJim Jagielski return S_OK;
1072*b1cdbd2cSJim Jagielski }
1073*b1cdbd2cSJim Jagielski
put_prpCurrency(CY newVal)1074*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::put_prpCurrency(CY newVal)
1075*b1cdbd2cSJim Jagielski {
1076*b1cdbd2cSJim Jagielski m_cy = newVal;
1077*b1cdbd2cSJim Jagielski return S_OK;
1078*b1cdbd2cSJim Jagielski }
1079*b1cdbd2cSJim Jagielski
get_prpDate(DATE * pVal)1080*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prpDate(DATE* pVal)
1081*b1cdbd2cSJim Jagielski {
1082*b1cdbd2cSJim Jagielski *pVal = m_date;
1083*b1cdbd2cSJim Jagielski return S_OK;
1084*b1cdbd2cSJim Jagielski }
1085*b1cdbd2cSJim Jagielski
put_prpDate(DATE newVal)1086*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::put_prpDate(DATE newVal)
1087*b1cdbd2cSJim Jagielski {
1088*b1cdbd2cSJim Jagielski m_date = newVal;
1089*b1cdbd2cSJim Jagielski return S_OK;
1090*b1cdbd2cSJim Jagielski }
1091*b1cdbd2cSJim Jagielski
1092*b1cdbd2cSJim Jagielski //VT_I4 DECIMAL_NEG //tagVARIANT DISPATCH_PROPERTYPUT
inDecimal(DECIMAL val)1093*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inDecimal(DECIMAL val)
1094*b1cdbd2cSJim Jagielski {
1095*b1cdbd2cSJim Jagielski m_decimal = val;
1096*b1cdbd2cSJim Jagielski return S_OK;
1097*b1cdbd2cSJim Jagielski }
1098*b1cdbd2cSJim Jagielski
outDecimal(DECIMAL * val)1099*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outDecimal(DECIMAL* val)
1100*b1cdbd2cSJim Jagielski {
1101*b1cdbd2cSJim Jagielski * val = m_decimal;
1102*b1cdbd2cSJim Jagielski return S_OK;
1103*b1cdbd2cSJim Jagielski }
1104*b1cdbd2cSJim Jagielski
inoutDecimal(DECIMAL * val)1105*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutDecimal(DECIMAL* val)
1106*b1cdbd2cSJim Jagielski {
1107*b1cdbd2cSJim Jagielski DECIMAL tmp;
1108*b1cdbd2cSJim Jagielski tmp = * val;
1109*b1cdbd2cSJim Jagielski * val = m_decimal;
1110*b1cdbd2cSJim Jagielski m_decimal = tmp;
1111*b1cdbd2cSJim Jagielski return S_OK;
1112*b1cdbd2cSJim Jagielski }
1113*b1cdbd2cSJim Jagielski
get_prpDecimal(DECIMAL * pVal)1114*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prpDecimal(DECIMAL* pVal)
1115*b1cdbd2cSJim Jagielski {
1116*b1cdbd2cSJim Jagielski * pVal = m_decimal;
1117*b1cdbd2cSJim Jagielski return S_OK;
1118*b1cdbd2cSJim Jagielski }
1119*b1cdbd2cSJim Jagielski
put_prpDecimal(DECIMAL newVal)1120*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::put_prpDecimal(DECIMAL newVal)
1121*b1cdbd2cSJim Jagielski {
1122*b1cdbd2cSJim Jagielski m_decimal = newVal;
1123*b1cdbd2cSJim Jagielski return S_OK;
1124*b1cdbd2cSJim Jagielski }
1125*b1cdbd2cSJim Jagielski
inSCode(SCODE val)1126*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inSCode(SCODE val)
1127*b1cdbd2cSJim Jagielski {
1128*b1cdbd2cSJim Jagielski m_scode = val;
1129*b1cdbd2cSJim Jagielski return S_OK;
1130*b1cdbd2cSJim Jagielski }
1131*b1cdbd2cSJim Jagielski
outScode(SCODE * val)1132*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outScode(SCODE* val)
1133*b1cdbd2cSJim Jagielski {
1134*b1cdbd2cSJim Jagielski * val = m_scode;
1135*b1cdbd2cSJim Jagielski return S_OK;
1136*b1cdbd2cSJim Jagielski }
1137*b1cdbd2cSJim Jagielski
inoutSCode(SCODE * val)1138*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutSCode(SCODE* val)
1139*b1cdbd2cSJim Jagielski {
1140*b1cdbd2cSJim Jagielski SCODE tmp = *val;
1141*b1cdbd2cSJim Jagielski * val = m_scode;
1142*b1cdbd2cSJim Jagielski m_scode = tmp;
1143*b1cdbd2cSJim Jagielski return S_OK;
1144*b1cdbd2cSJim Jagielski }
1145*b1cdbd2cSJim Jagielski
get_prpSCode(SCODE * pVal)1146*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prpSCode(SCODE* pVal)
1147*b1cdbd2cSJim Jagielski {
1148*b1cdbd2cSJim Jagielski * pVal = m_scode;
1149*b1cdbd2cSJim Jagielski return S_OK;
1150*b1cdbd2cSJim Jagielski }
1151*b1cdbd2cSJim Jagielski
put_prpSCode(SCODE newVal)1152*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::put_prpSCode(SCODE newVal)
1153*b1cdbd2cSJim Jagielski {
1154*b1cdbd2cSJim Jagielski m_scode = newVal;
1155*b1cdbd2cSJim Jagielski return S_OK;
1156*b1cdbd2cSJim Jagielski }
1157*b1cdbd2cSJim Jagielski
inrefLong(LONG * val)1158*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inrefLong(LONG* val)
1159*b1cdbd2cSJim Jagielski {
1160*b1cdbd2cSJim Jagielski m_long = * val;
1161*b1cdbd2cSJim Jagielski return S_OK;
1162*b1cdbd2cSJim Jagielski }
1163*b1cdbd2cSJim Jagielski
inrefVariant(VARIANT * val)1164*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inrefVariant(VARIANT* val)
1165*b1cdbd2cSJim Jagielski {
1166*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
1167*b1cdbd2cSJim Jagielski if (FAILED(hr = VariantCopy( & m_var1, val)))
1168*b1cdbd2cSJim Jagielski return hr;
1169*b1cdbd2cSJim Jagielski return S_OK;
1170*b1cdbd2cSJim Jagielski }
1171*b1cdbd2cSJim Jagielski
inrefDecimal(DECIMAL * val)1172*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inrefDecimal(DECIMAL* val)
1173*b1cdbd2cSJim Jagielski {
1174*b1cdbd2cSJim Jagielski m_decimal = * val;
1175*b1cdbd2cSJim Jagielski return S_OK;
1176*b1cdbd2cSJim Jagielski }
1177*b1cdbd2cSJim Jagielski
get_prpRefLong(long * pVal)1178*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prpRefLong(long* pVal)
1179*b1cdbd2cSJim Jagielski {
1180*b1cdbd2cSJim Jagielski *pVal = m_long;
1181*b1cdbd2cSJim Jagielski return S_OK;
1182*b1cdbd2cSJim Jagielski }
1183*b1cdbd2cSJim Jagielski
putref_prpRefLong(long * newVal)1184*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::putref_prpRefLong(long* newVal)
1185*b1cdbd2cSJim Jagielski {
1186*b1cdbd2cSJim Jagielski m_long = * newVal;
1187*b1cdbd2cSJim Jagielski return S_OK;
1188*b1cdbd2cSJim Jagielski }
1189*b1cdbd2cSJim Jagielski
get_prprefVariant(VARIANT * pVal)1190*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prprefVariant(VARIANT* pVal)
1191*b1cdbd2cSJim Jagielski {
1192*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
1193*b1cdbd2cSJim Jagielski hr = VariantCopy(pVal, & m_var1);
1194*b1cdbd2cSJim Jagielski return hr;
1195*b1cdbd2cSJim Jagielski }
1196*b1cdbd2cSJim Jagielski
putref_prprefVariant(VARIANT * newVal)1197*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::putref_prprefVariant(VARIANT* newVal)
1198*b1cdbd2cSJim Jagielski {
1199*b1cdbd2cSJim Jagielski m_var1 = * newVal;
1200*b1cdbd2cSJim Jagielski return S_OK;
1201*b1cdbd2cSJim Jagielski }
1202*b1cdbd2cSJim Jagielski
get_prprefDecimal(DECIMAL * pVal)1203*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prprefDecimal(DECIMAL* pVal)
1204*b1cdbd2cSJim Jagielski {
1205*b1cdbd2cSJim Jagielski * pVal = m_decimal;
1206*b1cdbd2cSJim Jagielski return S_OK;
1207*b1cdbd2cSJim Jagielski }
1208*b1cdbd2cSJim Jagielski
putref_prprefDecimal(DECIMAL * newVal)1209*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::putref_prprefDecimal(DECIMAL* newVal)
1210*b1cdbd2cSJim Jagielski {
1211*b1cdbd2cSJim Jagielski m_decimal = *newVal;
1212*b1cdbd2cSJim Jagielski return S_OK;
1213*b1cdbd2cSJim Jagielski }
1214*b1cdbd2cSJim Jagielski
1215*b1cdbd2cSJim Jagielski
optional6(VARIANT * val1,VARIANT * val2,VARIANT * val3,VARIANT * val4)1216*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::optional6(VARIANT* val1, VARIANT* val2, VARIANT* val3, VARIANT* val4)
1217*b1cdbd2cSJim Jagielski {
1218*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
1219*b1cdbd2cSJim Jagielski if (FAILED(hr = m_var1.Copy(val1)))
1220*b1cdbd2cSJim Jagielski return hr;
1221*b1cdbd2cSJim Jagielski if (FAILED(hr = m_var2.Copy(val2)))
1222*b1cdbd2cSJim Jagielski return hr;
1223*b1cdbd2cSJim Jagielski if (FAILED(hr = m_var3.Copy(val3)))
1224*b1cdbd2cSJim Jagielski return hr;
1225*b1cdbd2cSJim Jagielski if (FAILED(hr = m_var4.Copy(val4)))
1226*b1cdbd2cSJim Jagielski return hr;
1227*b1cdbd2cSJim Jagielski return S_OK;
1228*b1cdbd2cSJim Jagielski }
1229*b1cdbd2cSJim Jagielski
optional7(VARIANT * val1,VARIANT * val2,VARIANT * val3,VARIANT * val4)1230*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::optional7(VARIANT* val1, VARIANT* val2, VARIANT* val3, VARIANT* val4)
1231*b1cdbd2cSJim Jagielski {
1232*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
1233*b1cdbd2cSJim Jagielski if (FAILED(hr = VariantCopy(val1, & m_var1)))
1234*b1cdbd2cSJim Jagielski return hr;
1235*b1cdbd2cSJim Jagielski if (FAILED(hr = VariantCopy(val2, & m_var2)))
1236*b1cdbd2cSJim Jagielski return hr;
1237*b1cdbd2cSJim Jagielski if (FAILED(hr = VariantCopy(val3, & m_var3)))
1238*b1cdbd2cSJim Jagielski return hr;
1239*b1cdbd2cSJim Jagielski if (FAILED(hr = VariantCopy(val4, & m_var4)))
1240*b1cdbd2cSJim Jagielski return hr;
1241*b1cdbd2cSJim Jagielski
1242*b1cdbd2cSJim Jagielski return S_OK;
1243*b1cdbd2cSJim Jagielski }
1244*b1cdbd2cSJim Jagielski
get_prpMultiArg1(VARIANT * val1,VARIANT * val2,VARIANT * pVal)1245*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prpMultiArg1(VARIANT* val1, VARIANT* val2, VARIANT* pVal)
1246*b1cdbd2cSJim Jagielski {
1247*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
1248*b1cdbd2cSJim Jagielski CComVariant tmp1(*val1);
1249*b1cdbd2cSJim Jagielski CComVariant tmp2(*val2);
1250*b1cdbd2cSJim Jagielski
1251*b1cdbd2cSJim Jagielski if (FAILED(hr = VariantCopy(val1, & m_var1)))
1252*b1cdbd2cSJim Jagielski return hr;
1253*b1cdbd2cSJim Jagielski if (FAILED(hr = VariantCopy(val2, & m_var2)))
1254*b1cdbd2cSJim Jagielski return hr;
1255*b1cdbd2cSJim Jagielski m_var1 = tmp1;
1256*b1cdbd2cSJim Jagielski m_var2 = tmp2;
1257*b1cdbd2cSJim Jagielski if (FAILED(hr = VariantCopy(pVal, & m_var3)))
1258*b1cdbd2cSJim Jagielski return hr;
1259*b1cdbd2cSJim Jagielski return S_OK;
1260*b1cdbd2cSJim Jagielski }
1261*b1cdbd2cSJim Jagielski
put_prpMultiArg1(VARIANT * val1,VARIANT * val2,VARIANT * newVal)1262*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::put_prpMultiArg1(VARIANT* val1, VARIANT* val2, VARIANT* newVal)
1263*b1cdbd2cSJim Jagielski {
1264*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
1265*b1cdbd2cSJim Jagielski CComVariant tmp1( * val1);
1266*b1cdbd2cSJim Jagielski CComVariant tmp2( * val2);
1267*b1cdbd2cSJim Jagielski
1268*b1cdbd2cSJim Jagielski if (FAILED(hr = VariantCopy(val1, & m_var1)))
1269*b1cdbd2cSJim Jagielski return hr;
1270*b1cdbd2cSJim Jagielski if (FAILED(hr = VariantCopy(val2, & m_var2)))
1271*b1cdbd2cSJim Jagielski return hr;
1272*b1cdbd2cSJim Jagielski m_var1 = tmp1;
1273*b1cdbd2cSJim Jagielski m_var2 = tmp2;
1274*b1cdbd2cSJim Jagielski
1275*b1cdbd2cSJim Jagielski m_var3 = *newVal;
1276*b1cdbd2cSJim Jagielski return S_OK;
1277*b1cdbd2cSJim Jagielski }
1278*b1cdbd2cSJim Jagielski
1279*b1cdbd2cSJim Jagielski // tagVARIANT DISPATCH_PROPERTYPUT DISPID_PROPERTYPUT VARIANTARG LOCALE_USER_DEFAULT
1280*b1cdbd2cSJim Jagielski
get_prpMultiArg2(VARIANT val1,VARIANT * pVal)1281*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prpMultiArg2(VARIANT val1, VARIANT* pVal)
1282*b1cdbd2cSJim Jagielski {
1283*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
1284*b1cdbd2cSJim Jagielski m_var1 = val1;
1285*b1cdbd2cSJim Jagielski
1286*b1cdbd2cSJim Jagielski if (FAILED(hr = VariantCopy(pVal, & m_var2)))
1287*b1cdbd2cSJim Jagielski return hr;
1288*b1cdbd2cSJim Jagielski return S_OK;
1289*b1cdbd2cSJim Jagielski }
1290*b1cdbd2cSJim Jagielski
put_prpMultiArg2(VARIANT val1,VARIANT newVal)1291*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::put_prpMultiArg2(VARIANT val1, VARIANT newVal)
1292*b1cdbd2cSJim Jagielski {
1293*b1cdbd2cSJim Jagielski m_var1 = val1;
1294*b1cdbd2cSJim Jagielski m_var2 = newVal;
1295*b1cdbd2cSJim Jagielski return S_OK;
1296*b1cdbd2cSJim Jagielski }
1297*b1cdbd2cSJim Jagielski
1298*b1cdbd2cSJim Jagielski // returns the values set by prpMultiArg2
prpMultiArg2GetValues(VARIANT * val1,VARIANT * valProperty)1299*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::prpMultiArg2GetValues(VARIANT* val1, VARIANT* valProperty)
1300*b1cdbd2cSJim Jagielski {
1301*b1cdbd2cSJim Jagielski HRESULT hr = S_OK;
1302*b1cdbd2cSJim Jagielski if (FAILED(VariantCopy(val1, & m_var1)))
1303*b1cdbd2cSJim Jagielski return hr;
1304*b1cdbd2cSJim Jagielski if (FAILED(VariantCopy(valProperty, & m_var2)))
1305*b1cdbd2cSJim Jagielski return hr;
1306*b1cdbd2cSJim Jagielski return S_OK;
1307*b1cdbd2cSJim Jagielski }
1308*b1cdbd2cSJim Jagielski
get_prpMultiArg3(LONG * val1,LONG * pVal)1309*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prpMultiArg3(LONG* val1, LONG* pVal)
1310*b1cdbd2cSJim Jagielski {
1311*b1cdbd2cSJim Jagielski long aLong = *val1;
1312*b1cdbd2cSJim Jagielski *val1 = m_long;
1313*b1cdbd2cSJim Jagielski m_long = aLong;
1314*b1cdbd2cSJim Jagielski
1315*b1cdbd2cSJim Jagielski * pVal = m_long2;
1316*b1cdbd2cSJim Jagielski return S_OK;
1317*b1cdbd2cSJim Jagielski }
1318*b1cdbd2cSJim Jagielski
put_prpMultiArg3(LONG * val1,LONG newVal)1319*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::put_prpMultiArg3(LONG* val1, LONG newVal)
1320*b1cdbd2cSJim Jagielski {
1321*b1cdbd2cSJim Jagielski long aLong = *val1;
1322*b1cdbd2cSJim Jagielski *val1 = m_long;
1323*b1cdbd2cSJim Jagielski m_long = aLong;
1324*b1cdbd2cSJim Jagielski
1325*b1cdbd2cSJim Jagielski m_long2 = newVal;
1326*b1cdbd2cSJim Jagielski return S_OK;
1327*b1cdbd2cSJim Jagielski }
1328*b1cdbd2cSJim Jagielski
inUnknown(IUnknown * val)1329*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inUnknown(IUnknown* val)
1330*b1cdbd2cSJim Jagielski {
1331*b1cdbd2cSJim Jagielski m_unknown = val;
1332*b1cdbd2cSJim Jagielski
1333*b1cdbd2cSJim Jagielski return S_OK;
1334*b1cdbd2cSJim Jagielski }
1335*b1cdbd2cSJim Jagielski
outUnknown(IUnknown ** val)1336*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::outUnknown(IUnknown** val)
1337*b1cdbd2cSJim Jagielski {
1338*b1cdbd2cSJim Jagielski m_unknown.CopyTo(val);
1339*b1cdbd2cSJim Jagielski return S_OK;
1340*b1cdbd2cSJim Jagielski }
1341*b1cdbd2cSJim Jagielski
inoutUnknown(IUnknown ** val)1342*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::inoutUnknown(IUnknown** val)
1343*b1cdbd2cSJim Jagielski {
1344*b1cdbd2cSJim Jagielski CComPtr<IUnknown> tmp = *val;
1345*b1cdbd2cSJim Jagielski m_unknown.CopyTo(val);
1346*b1cdbd2cSJim Jagielski m_unknown = tmp;
1347*b1cdbd2cSJim Jagielski return S_OK;
1348*b1cdbd2cSJim Jagielski }
1349*b1cdbd2cSJim Jagielski
get_prpUnknown(IUnknown ** pVal)1350*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::get_prpUnknown(IUnknown** pVal)
1351*b1cdbd2cSJim Jagielski {
1352*b1cdbd2cSJim Jagielski m_prpUnknown.CopyTo(pVal);
1353*b1cdbd2cSJim Jagielski return S_OK;
1354*b1cdbd2cSJim Jagielski }
1355*b1cdbd2cSJim Jagielski
put_prpUnknown(IUnknown * newVal)1356*b1cdbd2cSJim Jagielski STDMETHODIMP CBasic::put_prpUnknown(IUnknown* newVal)
1357*b1cdbd2cSJim Jagielski {
1358*b1cdbd2cSJim Jagielski m_prpUnknown = newVal;
1359*b1cdbd2cSJim Jagielski return S_OK;
1360*b1cdbd2cSJim Jagielski }
1361