ucbhelper/source/provider/interactionrequest.cxx

   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
  21 /**************************************************************************
  22                                 TODO
  23  **************************************************************************
  24
  25  *************************************************************************/
  26 #include <ucbhelper/interactionrequest.hxx>
  27
  28 #include <osl/mutex.hxx>
  29 #include <osl/diagnose.h>
  30 #include <cppuhelper/typeprovider.hxx>
  31 #include <cppuhelper/queryinterface.hxx>
  32
  33 using namespace com::sun::star;
  34 using namespace ucbhelper;
  35
  36
  37
  38
  39 // InteractionRequest Implementation.
  40
  41
  42
  43
  44 namespace ucbhelper
  45 {
  46
  47 struct InteractionRequest_Impl
  48 {
  49     rtl::Reference< InteractionContinuation > m_xSelection;
  50     com::sun::star::uno::Any m_aRequest;
  51     com::sun::star::uno::Sequence<
  52         com::sun::star::uno::Reference<
  53             com::sun::star::task::XInteractionContinuation > > m_aContinuations;
  54
  55     InteractionRequest_Impl() {}
  56     InteractionRequest_Impl( const uno::Any & rRequest )
  57     : m_aRequest( rRequest ) {}
  58 };
  59
  60 }
  61
  62
  63 InteractionRequest::InteractionRequest()
  64 : m_pImpl( new InteractionRequest_Impl )
  65 {
  66 }
  67
  68
  69 InteractionRequest::InteractionRequest( const uno::Any & rRequest )
  70 : m_pImpl( new InteractionRequest_Impl( rRequest ) )
  71 {
  72 }
  73
  74
  75 // virtual
  76 InteractionRequest::~InteractionRequest()
  77 {
  78     delete m_pImpl;
  79 }
  80
  81
  82 void InteractionRequest::setRequest( const uno::Any & rRequest )
  83 {
  84     m_pImpl->m_aRequest = rRequest;
  85 }
  86
  87
  88 void InteractionRequest::setContinuations(
  89                 const uno::Sequence< uno::Reference<
  90                     task::XInteractionContinuation > > & rContinuations )
  91 {
  92     m_pImpl->m_aContinuations = rContinuations;
  93 }
  94
  95
  96 rtl::Reference< InteractionContinuation >
  97 InteractionRequest::getSelection() const
  98 {
  99     return m_pImpl->m_xSelection;
 100 }
 101
 102
 103 void InteractionRequest::setSelection(
 104                 const rtl::Reference< InteractionContinuation > & rxSelection )
 105 {
 106     m_pImpl->m_xSelection = rxSelection;
 107 }
 108
 109
 110
 111 // XInterface methods.
 112
 113
 114
 115 // virtual
 116 void SAL_CALL InteractionRequest::acquire()
 117     throw()
 118 {
 119     OWeakObject::acquire();
 120 }
 121
 122
 123 // virtual
 124 void SAL_CALL InteractionRequest::release()
 125     throw()
 126 {
 127     OWeakObject::release();
 128 }
 129
 130
 131 // virtual
 132 uno::Any SAL_CALL
 133 InteractionRequest::queryInterface( const uno::Type & rType )
 134     throw ( uno::RuntimeException, std::exception )
 135 {
 136     uno::Any aRet = cppu::queryInterface( rType,
 137                 static_cast< lang::XTypeProvider * >( this ),
 138                 static_cast< task::XInteractionRequest * >( this ) );
 139
 140     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
 141 }
 142
 143
 144
 145 // XTypeProvider methods.
 146
 147
 148
 149 // virtual
 150 uno::Sequence< sal_Int8 > SAL_CALL InteractionRequest::getImplementationId()
 151     throw( uno::RuntimeException, std::exception )
 152 {
 153     return css::uno::Sequence<sal_Int8>();
 154 }
 155
 156
 157 // virtual
 158 uno::Sequence< uno::Type > SAL_CALL InteractionRequest::getTypes()
 159     throw( uno::RuntimeException, std::exception )
 160 {
 161     static cppu::OTypeCollection* pCollection = 0;
 162       if ( !pCollection )
 163       {
 164         osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
 165         if ( !pCollection )
 166         {
 167             static cppu::OTypeCollection collection(
 168                 cppu::UnoType<lang::XTypeProvider>::get(),
 169                 cppu::UnoType<task::XInteractionRequest>::get() );
 170             pCollection = &collection;
 171         }
 172     }
 173     return (*pCollection).getTypes();
 174 }
 175
 176
 177
 178 // XInteractionRequest methods.
 179
 180
 181
 182 // virtual
 183 uno::Any SAL_CALL InteractionRequest::getRequest()
 184     throw( uno::RuntimeException, std::exception )
 185 {
 186     return m_pImpl->m_aRequest;
 187 }
 188
 189
 190 // virtual
 191 uno::Sequence< uno::Reference< task::XInteractionContinuation > > SAL_CALL
 192 InteractionRequest::getContinuations()
 193     throw( uno::RuntimeException, std::exception )
 194 {
 195     return m_pImpl->m_aContinuations;
 196 }
 197
 198
 199
 200
 201 // InteractionContinuation Implementation.
 202
 203
 204
 205
 206 namespace ucbhelper
 207 {
 208
 209 struct InteractionContinuation_Impl
 210 {
 211     InteractionRequest * m_pRequest;
 212
 213     InteractionContinuation_Impl( InteractionRequest * pRequest )
 214     : m_pRequest( pRequest ) {}
 215 };
 216
 217 }
 218
 219
 220 InteractionContinuation::InteractionContinuation(
 221                         InteractionRequest * pRequest )
 222 : m_pImpl( new InteractionContinuation_Impl( pRequest ) )
 223 {
 224 }
 225
 226
 227 // virtual
 228 InteractionContinuation::~InteractionContinuation()
 229 {
 230     delete m_pImpl;
 231 }
 232
 233
 234 void InteractionContinuation::recordSelection()
 235 {
 236     m_pImpl->m_pRequest->setSelection( this );
 237 }
 238
 239
 240
 241
 242 // InteractionAbort Implementation.
 243
 244
 245
 246
 247
 248
 249 // XInterface methods.
 250
 251
 252
 253 // virtual
 254 void SAL_CALL InteractionAbort::acquire()
 255     throw()
 256 {
 257     OWeakObject::acquire();
 258 }
 259
 260
 261 // virtual
 262 void SAL_CALL InteractionAbort::release()
 263     throw()
 264 {
 265     OWeakObject::release();
 266 }
 267
 268
 269 // virtual
 270 uno::Any SAL_CALL
 271 InteractionAbort::queryInterface( const uno::Type & rType )
 272     throw ( uno::RuntimeException, std::exception )
 273 {
 274     uno::Any aRet = cppu::queryInterface( rType,
 275                 static_cast< lang::XTypeProvider * >( this ),
 276                 static_cast< task::XInteractionContinuation * >( this ),
 277                 static_cast< task::XInteractionAbort * >( this ) );
 278
 279     return aRet.hasValue()
 280             ? aRet : InteractionContinuation::queryInterface( rType );
 281 }
 282
 283
 284
 285 // XTypeProvider methods.
 286
 287
 288
 289 // virtual
 290 uno::Sequence< sal_Int8 > SAL_CALL InteractionAbort::getImplementationId()
 291     throw( uno::RuntimeException, std::exception )
 292 {
 293     return css::uno::Sequence<sal_Int8>();
 294 }
 295
 296
 297 // virtual
 298 uno::Sequence< uno::Type > SAL_CALL InteractionAbort::getTypes()
 299     throw( uno::RuntimeException, std::exception )
 300 {
 301     static cppu::OTypeCollection* pCollection = 0;
 302       if ( !pCollection )
 303       {
 304         osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
 305         if ( !pCollection )
 306         {
 307             static cppu::OTypeCollection collection(
 308                 cppu::UnoType<lang::XTypeProvider>::get(),
 309                 cppu::UnoType<task::XInteractionAbort>::get() );
 310             pCollection = &collection;
 311         }
 312     }
 313     return (*pCollection).getTypes();
 314 }
 315
 316
 317
 318 // XInteractionContinuation methods.
 319
 320
 321
 322 // virtual
 323 void SAL_CALL InteractionAbort::select()
 324     throw( uno::RuntimeException, std::exception )
 325 {
 326     recordSelection();
 327 }
 328
 329
 330
 331
 332 // InteractionRetry Implementation.
 333
 334
 335
 336
 337
 338
 339 // XInterface methods.
 340
 341
 342
 343 // virtual
 344 void SAL_CALL InteractionRetry::acquire()
 345     throw()
 346 {
 347     OWeakObject::acquire();
 348 }
 349
 350
 351 // virtual
 352 void SAL_CALL InteractionRetry::release()
 353     throw()
 354 {
 355     OWeakObject::release();
 356 }
 357
 358
 359 // virtual
 360 uno::Any SAL_CALL
 361 InteractionRetry::queryInterface( const uno::Type & rType )
 362     throw ( uno::RuntimeException, std::exception )
 363 {
 364     uno::Any aRet = cppu::queryInterface( rType,
 365                 static_cast< lang::XTypeProvider * >( this ),
 366                 static_cast< task::XInteractionContinuation * >( this ),
 367                 static_cast< task::XInteractionRetry * >( this ) );
 368
 369     return aRet.hasValue()
 370             ? aRet : InteractionContinuation::queryInterface( rType );
 371 }
 372
 373
 374
 375 // XTypeProvider methods.
 376
 377
 378
 379 // virtual
 380 uno::Sequence< sal_Int8 > SAL_CALL InteractionRetry::getImplementationId()
 381     throw( uno::RuntimeException, std::exception )
 382 {
 383     return css::uno::Sequence<sal_Int8>();
 384 }
 385
 386
 387 // virtual
 388 uno::Sequence< uno::Type > SAL_CALL InteractionRetry::getTypes()
 389     throw( uno::RuntimeException, std::exception )
 390 {
 391     static cppu::OTypeCollection* pCollection = 0;
 392       if ( !pCollection )
 393       {
 394         osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
 395         if ( !pCollection )
 396         {
 397             static cppu::OTypeCollection collection(
 398                 cppu::UnoType<lang::XTypeProvider>::get(),
 399                 cppu::UnoType<task::XInteractionRetry>::get() );
 400             pCollection = &collection;
 401         }
 402     }
 403     return (*pCollection).getTypes();
 404 }
 405
 406
 407
 408 // XInteractionContinuation methods.
 409
 410
 411
 412 // virtual
 413 void SAL_CALL InteractionRetry::select()
 414     throw( uno::RuntimeException, std::exception )
 415 {
 416     recordSelection();
 417 }
 418
 419
 420
 421
 422 // InteractionApprove Implementation.
 423
 424
 425
 426
 427
 428
 429 // XInterface methods.
 430
 431
 432
 433 // virtual
 434 void SAL_CALL InteractionApprove::acquire()
 435     throw()
 436 {
 437     OWeakObject::acquire();
 438 }
 439
 440
 441 // virtual
 442 void SAL_CALL InteractionApprove::release()
 443     throw()
 444 {
 445     OWeakObject::release();
 446 }
 447
 448
 449 // virtual
 450 uno::Any SAL_CALL
 451 InteractionApprove::queryInterface( const uno::Type & rType )
 452     throw ( uno::RuntimeException, std::exception )
 453 {
 454     uno::Any aRet = cppu::queryInterface( rType,
 455                 static_cast< lang::XTypeProvider * >( this ),
 456                 static_cast< task::XInteractionContinuation * >( this ),
 457                 static_cast< task::XInteractionApprove * >( this ) );
 458
 459     return aRet.hasValue()
 460             ? aRet : InteractionContinuation::queryInterface( rType );
 461 }
 462
 463
 464
 465 // XTypeProvider methods.
 466
 467
 468
 469 // virtual
 470 uno::Sequence< sal_Int8 > SAL_CALL InteractionApprove::getImplementationId()
 471     throw( uno::RuntimeException, std::exception )
 472 {
 473     return css::uno::Sequence<sal_Int8>();
 474 }
 475
 476
 477 // virtual
 478 uno::Sequence< uno::Type > SAL_CALL InteractionApprove::getTypes()
 479     throw( uno::RuntimeException, std::exception )
 480 {
 481     static cppu::OTypeCollection* pCollection = 0;
 482       if ( !pCollection )
 483       {
 484         osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
 485         if ( !pCollection )
 486         {
 487             static cppu::OTypeCollection collection(
 488                 cppu::UnoType<lang::XTypeProvider>::get(),
 489                 cppu::UnoType<task::XInteractionApprove>::get() );
 490             pCollection = &collection;
 491         }
 492     }
 493     return (*pCollection).getTypes();
 494 }
 495
 496
 497
 498 // XInteractionContinuation methods.
 499
 500
 501
 502 // virtual
 503 void SAL_CALL InteractionApprove::select()
 504     throw( uno::RuntimeException, std::exception )
 505 {
 506     recordSelection();
 507 }
 508
 509
 510
 511
 512 // InteractionDisapprove Implementation.
 513
 514
 515
 516
 517
 518
 519 // XInterface methods.
 520
 521
 522
 523 // virtual
 524 void SAL_CALL InteractionDisapprove::acquire()
 525     throw()
 526 {
 527     OWeakObject::acquire();
 528 }
 529
 530
 531 // virtual
 532 void SAL_CALL InteractionDisapprove::release()
 533     throw()
 534 {
 535     OWeakObject::release();
 536 }
 537
 538
 539 // virtual
 540 uno::Any SAL_CALL
 541 InteractionDisapprove::queryInterface( const uno::Type & rType )
 542     throw ( uno::RuntimeException, std::exception )
 543 {
 544     uno::Any aRet = cppu::queryInterface( rType,
 545                 static_cast< lang::XTypeProvider * >( this ),
 546                 static_cast< task::XInteractionContinuation * >( this ),
 547                 static_cast< task::XInteractionDisapprove * >( this ) );
 548
 549     return aRet.hasValue()
 550             ? aRet : InteractionContinuation::queryInterface( rType );
 551 }
 552
 553
 554
 555 // XTypeProvider methods.
 556
 557
 558
 559 // virtual
 560 uno::Sequence< sal_Int8 > SAL_CALL InteractionDisapprove::getImplementationId()
 561     throw( uno::RuntimeException, std::exception )
 562 {
 563     return css::uno::Sequence<sal_Int8>();
 564 }
 565
 566
 567 // virtual
 568 uno::Sequence< uno::Type > SAL_CALL InteractionDisapprove::getTypes()
 569     throw( uno::RuntimeException, std::exception )
 570 {
 571     static cppu::OTypeCollection* pCollection = 0;
 572       if ( !pCollection )
 573       {
 574         osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
 575         if ( !pCollection )
 576         {
 577             static cppu::OTypeCollection collection(
 578                 cppu::UnoType<lang::XTypeProvider>::get(),
 579                 cppu::UnoType<task::XInteractionDisapprove>::get() );
 580             pCollection = &collection;
 581         }
 582     }
 583     return (*pCollection).getTypes();
 584 }
 585
 586
 587
 588 // XInteractionContinuation methods.
 589
 590
 591
 592 // virtual
 593 void SAL_CALL InteractionDisapprove::select()
 594     throw( uno::RuntimeException, std::exception )
 595 {
 596     recordSelection();
 597 }
 598
 599
 600
 601
 602 // InteractionSupplyAuthentication Implementation.
 603
 604
 605
 606
 607
 608
 609 // XInterface methods.
 610
 611
 612
 613 // virtual
 614 void SAL_CALL InteractionSupplyAuthentication::acquire()
 615     throw()
 616 {
 617     OWeakObject::acquire();
 618 }
 619
 620
 621 // virtual
 622 void SAL_CALL InteractionSupplyAuthentication::release()
 623     throw()
 624 {
 625     OWeakObject::release();
 626 }
 627
 628
 629 // virtual
 630 uno::Any SAL_CALL
 631 InteractionSupplyAuthentication::queryInterface( const uno::Type & rType )
 632     throw ( uno::RuntimeException, std::exception )
 633 {
 634     uno::Any aRet = cppu::queryInterface( rType,
 635             static_cast< lang::XTypeProvider * >( this ),
 636             static_cast< task::XInteractionContinuation * >( this ),
 637             static_cast< ucb::XInteractionSupplyAuthentication * >( this ),
 638             static_cast< ucb::XInteractionSupplyAuthentication2 * >( this ));
 639
 640     return aRet.hasValue()
 641             ? aRet : InteractionContinuation::queryInterface( rType );
 642 }
 643
 644
 645
 646 // XTypeProvider methods.
 647
 648
 649
 650 // virtual
 651 uno::Sequence< sal_Int8 > SAL_CALL
 652 InteractionSupplyAuthentication::getImplementationId()
 653     throw( uno::RuntimeException, std::exception )
 654 {
 655     return css::uno::Sequence<sal_Int8>();
 656 }
 657
 658
 659 // virtual
 660 uno::Sequence< uno::Type > SAL_CALL InteractionSupplyAuthentication::getTypes()
 661     throw( uno::RuntimeException, std::exception )
 662 {
 663     static cppu::OTypeCollection* pCollection = 0;
 664       if ( !pCollection )
 665       {
 666         osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
 667         if ( !pCollection )
 668         {
 669             static cppu::OTypeCollection collection(
 670                 cppu::UnoType<lang::XTypeProvider>::get(),
 671                 cppu::UnoType<ucb::XInteractionSupplyAuthentication2>::get() );
 672             pCollection = &collection;
 673         }
 674     }
 675     return (*pCollection).getTypes();
 676 }
 677
 678
 679
 680 // XInteractionContinuation methods.
 681
 682
 683
 684 // virtual
 685 void SAL_CALL InteractionSupplyAuthentication::select()
 686     throw( uno::RuntimeException, std::exception )
 687 {
 688     recordSelection();
 689 }
 690
 691
 692
 693 // XInteractionSupplyAuthentication methods.
 694
 695
 696
 697 // virtual
 698 sal_Bool SAL_CALL
 699 InteractionSupplyAuthentication::canSetRealm()
 700     throw( uno::RuntimeException, std::exception )
 701 {
 702     return m_bCanSetRealm;
 703 }
 704
 705
 706 // virtual
 707 void SAL_CALL
 708 InteractionSupplyAuthentication::setRealm( const OUString& Realm )
 709     throw( uno::RuntimeException, std::exception )
 710 {
 711     OSL_ENSURE( m_bCanSetPassword,
 712         "InteractionSupplyAuthentication::setRealm - Not supported!" );
 713
 714     if ( m_bCanSetRealm )
 715         m_aRealm = Realm;
 716 }
 717
 718
 719 // virtual
 720 sal_Bool SAL_CALL
 721 InteractionSupplyAuthentication::canSetUserName()
 722     throw( uno::RuntimeException, std::exception )
 723 {
 724     return m_bCanSetUserName;
 725 }
 726
 727
 728 // virtual
 729 void SAL_CALL
 730 InteractionSupplyAuthentication::setUserName( const OUString& UserName )
 731     throw( uno::RuntimeException, std::exception )
 732 {
 733     OSL_ENSURE( m_bCanSetUserName,
 734         "InteractionSupplyAuthentication::setUserName - Not supported!" );
 735
 736     if ( m_bCanSetUserName )
 737         m_aUserName = UserName;
 738 }
 739
 740
 741 // virtual
 742 sal_Bool SAL_CALL
 743 InteractionSupplyAuthentication::canSetPassword()
 744     throw( uno::RuntimeException, std::exception )
 745 {
 746     return m_bCanSetPassword;
 747 }
 748
 749
 750 // virtual
 751 void SAL_CALL
 752 InteractionSupplyAuthentication::setPassword( const OUString& Password )
 753     throw( uno::RuntimeException, std::exception )
 754 {
 755     OSL_ENSURE( m_bCanSetPassword,
 756         "InteractionSupplyAuthentication::setPassword - Not supported!" );
 757
 758     if ( m_bCanSetPassword )
 759         m_aPassword = Password;
 760 }
 761
 762
 763 // virtual
 764 uno::Sequence< ucb::RememberAuthentication > SAL_CALL
 765 InteractionSupplyAuthentication::getRememberPasswordModes(
 766                                     ucb::RememberAuthentication& Default )
 767     throw( uno::RuntimeException, std::exception )
 768 {
 769     Default = m_eDefaultRememberPasswordMode;
 770     return m_aRememberPasswordModes;
 771 }
 772
 773
 774 // virtual
 775 void SAL_CALL
 776 InteractionSupplyAuthentication::setRememberPassword(
 777                                     ucb::RememberAuthentication Remember )
 778     throw( uno::RuntimeException, std::exception )
 779 {
 780     m_eRememberPasswordMode = Remember;
 781 }
 782
 783
 784 // virtual
 785 sal_Bool SAL_CALL
 786 InteractionSupplyAuthentication::canSetAccount()
 787     throw( uno::RuntimeException, std::exception )
 788 {
 789     return m_bCanSetAccount;
 790 }
 791
 792
 793 // virtual
 794 void SAL_CALL
 795 InteractionSupplyAuthentication::setAccount( const OUString& Account )
 796     throw( uno::RuntimeException, std::exception )
 797 {
 798     OSL_ENSURE( m_bCanSetAccount,
 799         "InteractionSupplyAuthentication::setAccount - Not supported!" );
 800
 801     if ( m_bCanSetAccount )
 802         m_aAccount = Account;
 803 }
 804
 805
 806 // virtual
 807 uno::Sequence< ucb::RememberAuthentication > SAL_CALL
 808 InteractionSupplyAuthentication::getRememberAccountModes(
 809                                     ucb::RememberAuthentication& Default )
 810     throw( uno::RuntimeException, std::exception )
 811 {
 812     Default = m_eDefaultRememberAccountMode;
 813     return m_aRememberAccountModes;
 814 }
 815
 816
 817 // virtual
 818 void SAL_CALL InteractionSupplyAuthentication::setRememberAccount(
 819                                     ucb::RememberAuthentication Remember )
 820     throw( uno::RuntimeException, std::exception )
 821 {
 822     m_eRememberAccountMode = Remember;
 823 }
 824
 825
 826
 827 // XInteractionSupplyAuthentication2 methods.
 828
 829
 830
 831 // virtual
 832 sal_Bool SAL_CALL
 833 InteractionSupplyAuthentication::canUseSystemCredentials(
 834         sal_Bool& Default )
 835     throw ( uno::RuntimeException, std::exception )
 836 {
 837     Default = m_bDefaultUseSystemCredentials;
 838     return m_bCanUseSystemCredentials;
 839 }
 840
 841
 842 // virtual
 843 void SAL_CALL InteractionSupplyAuthentication::setUseSystemCredentials(
 844         sal_Bool UseSystemCredentials )
 845     throw ( uno::RuntimeException, std::exception )
 846 {
 847     if ( m_bCanUseSystemCredentials )
 848         m_bUseSystemCredentials = UseSystemCredentials;
 849 }
 850
 851
 852
 853
 854
 855 // InteractionReplaceExistingData Implementation.
 856
 857
 858
 859
 860
 861
 862 // XInterface methods.
 863
 864
 865
 866 // virtual
 867 void SAL_CALL InteractionReplaceExistingData::acquire()
 868     throw()
 869 {
 870     OWeakObject::acquire();
 871 }
 872
 873
 874 // virtual
 875 void SAL_CALL InteractionReplaceExistingData::release()
 876     throw()
 877 {
 878     OWeakObject::release();
 879 }
 880
 881
 882 // virtual
 883 uno::Any SAL_CALL
 884 InteractionReplaceExistingData::queryInterface( const uno::Type & rType )
 885     throw ( uno::RuntimeException, std::exception )
 886 {
 887     uno::Any aRet = cppu::queryInterface( rType,
 888                 static_cast< lang::XTypeProvider * >( this ),
 889                 static_cast< task::XInteractionContinuation * >( this ),
 890                 static_cast< ucb::XInteractionReplaceExistingData * >( this ) );
 891
 892     return aRet.hasValue()
 893             ? aRet : InteractionContinuation::queryInterface( rType );
 894 }
 895
 896
 897
 898 // XTypeProvider methods.
 899
 900
 901
 902 // virtual
 903 uno::Sequence< sal_Int8 > SAL_CALL
 904 InteractionReplaceExistingData::getImplementationId()
 905     throw( uno::RuntimeException, std::exception )
 906 {
 907     return css::uno::Sequence<sal_Int8>();
 908 }
 909
 910
 911 // virtual
 912 uno::Sequence< uno::Type > SAL_CALL InteractionReplaceExistingData::getTypes()
 913     throw( uno::RuntimeException, std::exception )
 914 {
 915     static cppu::OTypeCollection* pCollection = 0;
 916       if ( !pCollection )
 917       {
 918         osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
 919         if ( !pCollection )
 920         {
 921             static cppu::OTypeCollection collection(
 922                 cppu::UnoType<lang::XTypeProvider>::get(),
 923                 cppu::UnoType<ucb::XInteractionReplaceExistingData>::get() );
 924             pCollection = &collection;
 925         }
 926     }
 927     return (*pCollection).getTypes();
 928 }
 929
 930
 931
 932 // XInteractionContinuation methods.
 933
 934
 935
 936 // virtual
 937 void SAL_CALL InteractionReplaceExistingData::select()
 938     throw( uno::RuntimeException, std::exception )
 939 {
 940     recordSelection();
 941 }
 942
 943 // InteractionAuthFallback Implementation
 944
 945 // XInterface methods.
 946
 947 // virtual
 948 void SAL_CALL InteractionAuthFallback::acquire()
 949     throw()
 950 {
 951     OWeakObject::acquire();
 952 }
 953
 954 // virtual
 955 void SAL_CALL InteractionAuthFallback::release()
 956     throw()
 957 {
 958     OWeakObject::release();
 959 }
 960
 961 // virtual
 962 uno::Any SAL_CALL
 963 InteractionAuthFallback::queryInterface( const uno::Type & rType )
 964     throw ( uno::RuntimeException, std::exception )
 965 {
 966     uno::Any aRet = cppu::queryInterface( rType,
 967             static_cast< task::XInteractionContinuation * >( this ),
 968             static_cast< ucb::XInteractionAuthFallback * >( this ));
 969
 970     return aRet.hasValue()
 971             ? aRet : InteractionContinuation::queryInterface( rType );
 972 }
 973
 974 // XInteractionContinuation methods.
 975
 976 // virtual
 977 void SAL_CALL InteractionAuthFallback::select()
 978     throw( uno::RuntimeException, std::exception )
 979 {
 980     recordSelection();
 981 }
 982
 983 // XInteractionAuthFallback methods
 984
 985 // virtual
 986 void SAL_CALL InteractionAuthFallback::setCode( const OUString& code )
 987     throw ( uno::RuntimeException, std::exception )
 988 {
 989     m_aCode = code;
 990 }
 991
 992 // virtual
 993 OUString SAL_CALL InteractionAuthFallback::getCode( )
 994     throw ( uno::RuntimeException, std::exception )
 995 {
 996     return m_aCode;
 997 }
 998
 999 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */