extensions/test/ole/AxTestComponents/Basic.cpp

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