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