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