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 <rtl/ref.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 // InteractionRequest Implementation.
  38
  39
  40 namespace ucbhelper
  41 {
  42
  43 struct InteractionRequest_Impl
  44 {
  45     rtl::Reference< InteractionContinuation > m_xSelection;
  46     css::uno::Any m_aRequest;
  47     css::uno::Sequence<
  48         css::uno::Reference<
  49             css::task::XInteractionContinuation > > m_aContinuations;
  50
  51     InteractionRequest_Impl() {}
  52     explicit InteractionRequest_Impl( const uno::Any & rRequest )
  53     : m_aRequest( rRequest ) {}
  54 };
  55
  56 }
  57
  58
  59 InteractionRequest::InteractionRequest()
  60 : m_pImpl( new InteractionRequest_Impl )
  61 {
  62 }
  63
  64
  65 InteractionRequest::InteractionRequest( const uno::Any & rRequest )
  66 : m_pImpl( new InteractionRequest_Impl( rRequest ) )
  67 {
  68 }
  69
  70
  71 // virtual
  72 InteractionRequest::~InteractionRequest()
  73 {
  74 }
  75
  76
  77 void InteractionRequest::setRequest( const uno::Any & rRequest )
  78 {
  79     m_pImpl->m_aRequest = rRequest;
  80 }
  81
  82
  83 void InteractionRequest::setContinuations(
  84                 const uno::Sequence< uno::Reference<
  85                     task::XInteractionContinuation > > & rContinuations )
  86 {
  87     m_pImpl->m_aContinuations = rContinuations;
  88 }
  89
  90
  91 rtl::Reference< InteractionContinuation > const &
  92 InteractionRequest::getSelection() const
  93 {
  94     return m_pImpl->m_xSelection;
  95 }
  96
  97
  98 void InteractionRequest::setSelection(
  99                 const rtl::Reference< InteractionContinuation > & rxSelection )
 100 {
 101     m_pImpl->m_xSelection = rxSelection;
 102 }
 103
 104
 105 // XInterface methods.
 106
 107
 108 // virtual
 109 void SAL_CALL InteractionRequest::acquire()
 110     throw()
 111 {
 112     OWeakObject::acquire();
 113 }
 114
 115
 116 // virtual
 117 void SAL_CALL InteractionRequest::release()
 118     throw()
 119 {
 120     OWeakObject::release();
 121 }
 122
 123
 124 // virtual
 125 uno::Any SAL_CALL
 126 InteractionRequest::queryInterface( const uno::Type & rType )
 127 {
 128     uno::Any aRet = cppu::queryInterface( rType,
 129                 static_cast< lang::XTypeProvider * >( this ),
 130                 static_cast< task::XInteractionRequest * >( this ) );
 131
 132     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
 133 }
 134
 135
 136 // XTypeProvider methods.
 137
 138
 139 // virtual
 140 uno::Sequence< sal_Int8 > SAL_CALL InteractionRequest::getImplementationId()
 141 {
 142     return css::uno::Sequence<sal_Int8>();
 143 }
 144
 145
 146 // virtual
 147 uno::Sequence< uno::Type > SAL_CALL InteractionRequest::getTypes()
 148 {
 149     static cppu::OTypeCollection s_aCollection(
 150                 cppu::UnoType<lang::XTypeProvider>::get(),
 151                 cppu::UnoType<task::XInteractionRequest>::get() );
 152
 153     return s_aCollection.getTypes();
 154 }
 155
 156
 157 // XInteractionRequest methods.
 158
 159
 160 // virtual
 161 uno::Any SAL_CALL InteractionRequest::getRequest()
 162 {
 163     return m_pImpl->m_aRequest;
 164 }
 165
 166
 167 // virtual
 168 uno::Sequence< uno::Reference< task::XInteractionContinuation > > SAL_CALL
 169 InteractionRequest::getContinuations()
 170 {
 171     return m_pImpl->m_aContinuations;
 172 }
 173
 174
 175 // InteractionContinuation Implementation.
 176
 177
 178 InteractionContinuation::InteractionContinuation(
 179                         InteractionRequest * pRequest )
 180 : m_pRequest( pRequest )
 181 {
 182 }
 183
 184
 185 // virtual
 186 InteractionContinuation::~InteractionContinuation()
 187 {
 188 }
 189
 190
 191 void InteractionContinuation::recordSelection()
 192 {
 193     m_pRequest->setSelection( this );
 194 }
 195
 196
 197 // InteractionAbort Implementation.
 198
 199
 200 // XInterface methods.
 201
 202
 203 // virtual
 204 void SAL_CALL InteractionAbort::acquire()
 205     throw()
 206 {
 207     OWeakObject::acquire();
 208 }
 209
 210
 211 // virtual
 212 void SAL_CALL InteractionAbort::release()
 213     throw()
 214 {
 215     OWeakObject::release();
 216 }
 217
 218
 219 // virtual
 220 uno::Any SAL_CALL
 221 InteractionAbort::queryInterface( const uno::Type & rType )
 222 {
 223     uno::Any aRet = cppu::queryInterface( rType,
 224                 static_cast< lang::XTypeProvider * >( this ),
 225                 static_cast< task::XInteractionContinuation * >( this ),
 226                 static_cast< task::XInteractionAbort * >( this ) );
 227
 228     return aRet.hasValue()
 229             ? aRet : InteractionContinuation::queryInterface( rType );
 230 }
 231
 232
 233 // XTypeProvider methods.
 234
 235
 236 // virtual
 237 uno::Sequence< sal_Int8 > SAL_CALL InteractionAbort::getImplementationId()
 238 {
 239     return css::uno::Sequence<sal_Int8>();
 240 }
 241
 242
 243 // virtual
 244 uno::Sequence< uno::Type > SAL_CALL InteractionAbort::getTypes()
 245 {
 246     static cppu::OTypeCollection s_aCollection(
 247                 cppu::UnoType<lang::XTypeProvider>::get(),
 248                 cppu::UnoType<task::XInteractionAbort>::get() );
 249
 250     return s_aCollection.getTypes();
 251 }
 252
 253
 254 // XInteractionContinuation methods.
 255
 256
 257 // virtual
 258 void SAL_CALL InteractionAbort::select()
 259 {
 260     recordSelection();
 261 }
 262
 263
 264 // InteractionRetry Implementation.
 265
 266
 267 // XInterface methods.
 268
 269
 270 // virtual
 271 void SAL_CALL InteractionRetry::acquire()
 272     throw()
 273 {
 274     OWeakObject::acquire();
 275 }
 276
 277
 278 // virtual
 279 void SAL_CALL InteractionRetry::release()
 280     throw()
 281 {
 282     OWeakObject::release();
 283 }
 284
 285
 286 // virtual
 287 uno::Any SAL_CALL
 288 InteractionRetry::queryInterface( const uno::Type & rType )
 289 {
 290     uno::Any aRet = cppu::queryInterface( rType,
 291                 static_cast< lang::XTypeProvider * >( this ),
 292                 static_cast< task::XInteractionContinuation * >( this ),
 293                 static_cast< task::XInteractionRetry * >( this ) );
 294
 295     return aRet.hasValue()
 296             ? aRet : InteractionContinuation::queryInterface( rType );
 297 }
 298
 299
 300 // XTypeProvider methods.
 301
 302
 303 // virtual
 304 uno::Sequence< sal_Int8 > SAL_CALL InteractionRetry::getImplementationId()
 305 {
 306     return css::uno::Sequence<sal_Int8>();
 307 }
 308
 309
 310 // virtual
 311 uno::Sequence< uno::Type > SAL_CALL InteractionRetry::getTypes()
 312 {
 313     static cppu::OTypeCollection s_aCollection(
 314                 cppu::UnoType<lang::XTypeProvider>::get(),
 315                 cppu::UnoType<task::XInteractionRetry>::get() );
 316
 317     return s_aCollection.getTypes();
 318 }
 319
 320
 321 // XInteractionContinuation methods.
 322
 323
 324 // virtual
 325 void SAL_CALL InteractionRetry::select()
 326 {
 327     recordSelection();
 328 }
 329
 330
 331 // InteractionApprove Implementation.
 332
 333
 334 // XInterface methods.
 335
 336
 337 // virtual
 338 void SAL_CALL InteractionApprove::acquire()
 339     throw()
 340 {
 341     OWeakObject::acquire();
 342 }
 343
 344
 345 // virtual
 346 void SAL_CALL InteractionApprove::release()
 347     throw()
 348 {
 349     OWeakObject::release();
 350 }
 351
 352
 353 // virtual
 354 uno::Any SAL_CALL
 355 InteractionApprove::queryInterface( const uno::Type & rType )
 356 {
 357     uno::Any aRet = cppu::queryInterface( rType,
 358                 static_cast< lang::XTypeProvider * >( this ),
 359                 static_cast< task::XInteractionContinuation * >( this ),
 360                 static_cast< task::XInteractionApprove * >( this ) );
 361
 362     return aRet.hasValue()
 363             ? aRet : InteractionContinuation::queryInterface( rType );
 364 }
 365
 366
 367 // XTypeProvider methods.
 368
 369
 370 // virtual
 371 uno::Sequence< sal_Int8 > SAL_CALL InteractionApprove::getImplementationId()
 372 {
 373     return css::uno::Sequence<sal_Int8>();
 374 }
 375
 376
 377 // virtual
 378 uno::Sequence< uno::Type > SAL_CALL InteractionApprove::getTypes()
 379 {
 380     static cppu::OTypeCollection s_aCollection(
 381                 cppu::UnoType<lang::XTypeProvider>::get(),
 382                 cppu::UnoType<task::XInteractionApprove>::get() );
 383
 384     return s_aCollection.getTypes();
 385 }
 386
 387
 388 // XInteractionContinuation methods.
 389
 390
 391 // virtual
 392 void SAL_CALL InteractionApprove::select()
 393 {
 394     recordSelection();
 395 }
 396
 397
 398 // InteractionDisapprove Implementation.
 399
 400
 401 // XInterface methods.
 402
 403
 404 // virtual
 405 void SAL_CALL InteractionDisapprove::acquire()
 406     throw()
 407 {
 408     OWeakObject::acquire();
 409 }
 410
 411
 412 // virtual
 413 void SAL_CALL InteractionDisapprove::release()
 414     throw()
 415 {
 416     OWeakObject::release();
 417 }
 418
 419
 420 // virtual
 421 uno::Any SAL_CALL
 422 InteractionDisapprove::queryInterface( const uno::Type & rType )
 423 {
 424     uno::Any aRet = cppu::queryInterface( rType,
 425                 static_cast< lang::XTypeProvider * >( this ),
 426                 static_cast< task::XInteractionContinuation * >( this ),
 427                 static_cast< task::XInteractionDisapprove * >( this ) );
 428
 429     return aRet.hasValue()
 430             ? aRet : InteractionContinuation::queryInterface( rType );
 431 }
 432
 433
 434 // XTypeProvider methods.
 435
 436
 437 // virtual
 438 uno::Sequence< sal_Int8 > SAL_CALL InteractionDisapprove::getImplementationId()
 439 {
 440     return css::uno::Sequence<sal_Int8>();
 441 }
 442
 443
 444 // virtual
 445 uno::Sequence< uno::Type > SAL_CALL InteractionDisapprove::getTypes()
 446 {
 447     static cppu::OTypeCollection s_aCollection(
 448                 cppu::UnoType<lang::XTypeProvider>::get(),
 449                 cppu::UnoType<task::XInteractionDisapprove>::get() );
 450
 451     return s_aCollection.getTypes();
 452 }
 453
 454
 455 // XInteractionContinuation methods.
 456
 457
 458 // virtual
 459 void SAL_CALL InteractionDisapprove::select()
 460 {
 461     recordSelection();
 462 }
 463
 464
 465 // InteractionSupplyAuthentication Implementation.
 466
 467
 468 // XInterface methods.
 469
 470
 471 // virtual
 472 void SAL_CALL InteractionSupplyAuthentication::acquire()
 473     throw()
 474 {
 475     OWeakObject::acquire();
 476 }
 477
 478
 479 // virtual
 480 void SAL_CALL InteractionSupplyAuthentication::release()
 481     throw()
 482 {
 483     OWeakObject::release();
 484 }
 485
 486
 487 // virtual
 488 uno::Any SAL_CALL
 489 InteractionSupplyAuthentication::queryInterface( const uno::Type & rType )
 490 {
 491     uno::Any aRet = cppu::queryInterface( rType,
 492             static_cast< lang::XTypeProvider * >( this ),
 493             static_cast< task::XInteractionContinuation * >( this ),
 494             static_cast< ucb::XInteractionSupplyAuthentication * >( this ),
 495             static_cast< ucb::XInteractionSupplyAuthentication2 * >( this ));
 496
 497     return aRet.hasValue()
 498             ? aRet : InteractionContinuation::queryInterface( rType );
 499 }
 500
 501
 502 // XTypeProvider methods.
 503
 504
 505 // virtual
 506 uno::Sequence< sal_Int8 > SAL_CALL
 507 InteractionSupplyAuthentication::getImplementationId()
 508 {
 509     return css::uno::Sequence<sal_Int8>();
 510 }
 511
 512
 513 // virtual
 514 uno::Sequence< uno::Type > SAL_CALL InteractionSupplyAuthentication::getTypes()
 515 {
 516     static cppu::OTypeCollection s_aCollection(
 517                 cppu::UnoType<lang::XTypeProvider>::get(),
 518                 cppu::UnoType<ucb::XInteractionSupplyAuthentication2>::get() );
 519
 520     return s_aCollection.getTypes();
 521 }
 522
 523
 524 // XInteractionContinuation methods.
 525
 526
 527 // virtual
 528 void SAL_CALL InteractionSupplyAuthentication::select()
 529 {
 530     recordSelection();
 531 }
 532
 533
 534 // XInteractionSupplyAuthentication methods.
 535
 536
 537 // virtual
 538 sal_Bool SAL_CALL
 539 InteractionSupplyAuthentication::canSetRealm()
 540 {
 541     return m_bCanSetRealm;
 542 }
 543
 544
 545 // virtual
 546 void SAL_CALL
 547 InteractionSupplyAuthentication::setRealm( const OUString& Realm )
 548 {
 549     OSL_ENSURE( m_bCanSetPassword,
 550         "InteractionSupplyAuthentication::setRealm - Not supported!" );
 551
 552     if ( m_bCanSetRealm )
 553         m_aRealm = Realm;
 554 }
 555
 556
 557 // virtual
 558 sal_Bool SAL_CALL
 559 InteractionSupplyAuthentication::canSetUserName()
 560 {
 561     return m_bCanSetUserName;
 562 }
 563
 564
 565 // virtual
 566 void SAL_CALL
 567 InteractionSupplyAuthentication::setUserName( const OUString& UserName )
 568 {
 569     OSL_ENSURE( m_bCanSetUserName,
 570         "InteractionSupplyAuthentication::setUserName - Not supported!" );
 571
 572     if ( m_bCanSetUserName )
 573         m_aUserName = UserName;
 574 }
 575
 576
 577 // virtual
 578 sal_Bool SAL_CALL
 579 InteractionSupplyAuthentication::canSetPassword()
 580 {
 581     return m_bCanSetPassword;
 582 }
 583
 584
 585 // virtual
 586 void SAL_CALL
 587 InteractionSupplyAuthentication::setPassword( const OUString& Password )
 588 {
 589     OSL_ENSURE( m_bCanSetPassword,
 590         "InteractionSupplyAuthentication::setPassword - Not supported!" );
 591
 592     if ( m_bCanSetPassword )
 593         m_aPassword = Password;
 594 }
 595
 596
 597 // virtual
 598 uno::Sequence< ucb::RememberAuthentication > SAL_CALL
 599 InteractionSupplyAuthentication::getRememberPasswordModes(
 600                                     ucb::RememberAuthentication& Default )
 601 {
 602     Default = m_eDefaultRememberPasswordMode;
 603     return m_aRememberPasswordModes;
 604 }
 605
 606
 607 // virtual
 608 void SAL_CALL
 609 InteractionSupplyAuthentication::setRememberPassword(
 610                                     ucb::RememberAuthentication Remember )
 611 {
 612     m_eRememberPasswordMode = Remember;
 613 }
 614
 615
 616 // virtual
 617 sal_Bool SAL_CALL
 618 InteractionSupplyAuthentication::canSetAccount()
 619 {
 620     return m_bCanSetAccount;
 621 }
 622
 623
 624 // virtual
 625 void SAL_CALL
 626 InteractionSupplyAuthentication::setAccount( const OUString& Account )
 627 {
 628     OSL_ENSURE( m_bCanSetAccount,
 629         "InteractionSupplyAuthentication::setAccount - Not supported!" );
 630
 631     if ( m_bCanSetAccount )
 632         m_aAccount = Account;
 633 }
 634
 635
 636 // virtual
 637 uno::Sequence< ucb::RememberAuthentication > SAL_CALL
 638 InteractionSupplyAuthentication::getRememberAccountModes(
 639                                     ucb::RememberAuthentication& Default )
 640 {
 641     Default = m_eDefaultRememberAccountMode;
 642     return m_aRememberAccountModes;
 643 }
 644
 645
 646 // virtual
 647 void SAL_CALL InteractionSupplyAuthentication::setRememberAccount(
 648                                     ucb::RememberAuthentication )
 649 {
 650 }
 651
 652
 653 // XInteractionSupplyAuthentication2 methods.
 654
 655
 656 // virtual
 657 sal_Bool SAL_CALL
 658 InteractionSupplyAuthentication::canUseSystemCredentials(
 659         sal_Bool& Default )
 660 {
 661     Default = false;
 662     return m_bCanUseSystemCredentials;
 663 }
 664
 665
 666 // virtual
 667 void SAL_CALL InteractionSupplyAuthentication::setUseSystemCredentials(
 668         sal_Bool UseSystemCredentials )
 669 {
 670     if ( m_bCanUseSystemCredentials )
 671         m_bUseSystemCredentials = UseSystemCredentials;
 672 }
 673
 674
 675 // InteractionReplaceExistingData Implementation.
 676
 677
 678 // XInterface methods.
 679
 680
 681 // virtual
 682 void SAL_CALL InteractionReplaceExistingData::acquire()
 683     throw()
 684 {
 685     OWeakObject::acquire();
 686 }
 687
 688
 689 // virtual
 690 void SAL_CALL InteractionReplaceExistingData::release()
 691     throw()
 692 {
 693     OWeakObject::release();
 694 }
 695
 696
 697 // virtual
 698 uno::Any SAL_CALL
 699 InteractionReplaceExistingData::queryInterface( const uno::Type & rType )
 700 {
 701     uno::Any aRet = cppu::queryInterface( rType,
 702                 static_cast< lang::XTypeProvider * >( this ),
 703                 static_cast< task::XInteractionContinuation * >( this ),
 704                 static_cast< ucb::XInteractionReplaceExistingData * >( this ) );
 705
 706     return aRet.hasValue()
 707             ? aRet : InteractionContinuation::queryInterface( rType );
 708 }
 709
 710
 711 // XTypeProvider methods.
 712
 713
 714 // virtual
 715 uno::Sequence< sal_Int8 > SAL_CALL
 716 InteractionReplaceExistingData::getImplementationId()
 717 {
 718     return css::uno::Sequence<sal_Int8>();
 719 }
 720
 721
 722 // virtual
 723 uno::Sequence< uno::Type > SAL_CALL InteractionReplaceExistingData::getTypes()
 724 {
 725     static cppu::OTypeCollection s_aCollection(
 726                 cppu::UnoType<lang::XTypeProvider>::get(),
 727                 cppu::UnoType<ucb::XInteractionReplaceExistingData>::get() );
 728
 729     return s_aCollection.getTypes();
 730 }
 731
 732
 733 // XInteractionContinuation methods.
 734
 735
 736 // virtual
 737 void SAL_CALL InteractionReplaceExistingData::select()
 738 {
 739     recordSelection();
 740 }
 741
 742 // InteractionAuthFallback Implementation
 743
 744 // XInterface methods.
 745
 746 // virtual
 747 void SAL_CALL InteractionAuthFallback::acquire()
 748     throw()
 749 {
 750     OWeakObject::acquire();
 751 }
 752
 753 // virtual
 754 void SAL_CALL InteractionAuthFallback::release()
 755     throw()
 756 {
 757     OWeakObject::release();
 758 }
 759
 760 // virtual
 761 uno::Any SAL_CALL
 762 InteractionAuthFallback::queryInterface( const uno::Type & rType )
 763 {
 764     uno::Any aRet = cppu::queryInterface( rType,
 765             static_cast< task::XInteractionContinuation * >( this ),
 766             static_cast< ucb::XInteractionAuthFallback * >( this ));
 767
 768     return aRet.hasValue()
 769             ? aRet : InteractionContinuation::queryInterface( rType );
 770 }
 771
 772 // XInteractionContinuation methods.
 773
 774 // virtual
 775 void SAL_CALL InteractionAuthFallback::select()
 776 {
 777     recordSelection();
 778 }
 779
 780 // XInteractionAuthFallback methods
 781
 782 // virtual
 783 void SAL_CALL InteractionAuthFallback::setCode( const OUString& code )
 784 {
 785     m_aCode = code;
 786 }
 787
 788 const OUString& InteractionAuthFallback::getCode() const
 789 {
 790     return m_aCode;
 791 }
 792
 793 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */