ucbhelper/source/client/content.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 #include <sal/config.h>
  21
  22 #include <cassert>
  23
  24 #include <osl/diagnose.h>
  25 #include <osl/mutex.hxx>
  26 #include <sal/log.hxx>
  27 #include <salhelper/simplereferenceobject.hxx>
  28 #include <cppuhelper/weak.hxx>
  29 #include <cppuhelper/queryinterface.hxx>
  30
  31 #include <cppuhelper/implbase.hxx>
  32 #include <com/sun/star/ucb/CheckinArgument.hpp>
  33 #include <com/sun/star/ucb/ContentCreationError.hpp>
  34 #include <com/sun/star/ucb/ContentCreationException.hpp>
  35 #include <com/sun/star/ucb/IllegalIdentifierException.hpp>
  36 #include <com/sun/star/ucb/XCommandInfo.hpp>
  37 #include <com/sun/star/ucb/XCommandProcessor.hpp>
  38 #include <com/sun/star/ucb/Command.hpp>
  39 #include <com/sun/star/ucb/ContentAction.hpp>
  40 #include <com/sun/star/ucb/OpenCommandArgument2.hpp>
  41 #include <com/sun/star/ucb/InsertCommandArgument.hpp>
  42 #include <com/sun/star/ucb/GlobalTransferCommandArgument2.hpp>
  43 #include <com/sun/star/ucb/OpenMode.hpp>
  44 #include <com/sun/star/ucb/XContentCreator.hpp>
  45 #include <com/sun/star/ucb/XContentEventListener.hpp>
  46 #include <com/sun/star/ucb/XDynamicResultSet.hpp>
  47 #include <com/sun/star/ucb/SortedDynamicResultSetFactory.hpp>
  48 #include <com/sun/star/ucb/UniversalContentBroker.hpp>
  49 #include <com/sun/star/ucb/XUniversalContentBroker.hpp>
  50 #include <com/sun/star/beans/XPropertySetInfo.hpp>
  51 #include <com/sun/star/beans/Property.hpp>
  52 #include <com/sun/star/beans/PropertyValue.hpp>
  53 #include <com/sun/star/sdbc/XRow.hpp>
  54 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  55 #include <com/sun/star/beans/UnknownPropertyException.hpp>
  56 #include <ucbhelper/content.hxx>
  57 #include <ucbhelper/activedatasink.hxx>
  58 #include <ucbhelper/activedatastreamer.hxx>
  59 #include <ucbhelper/cancelcommandexecution.hxx>
  60
  61 namespace com::sun::star::ucb { class XCommandEnvironment; }
  62 namespace com::sun::star::ucb { class XContentProvider; }
  63 namespace com::sun::star::sdbc { class XResultSet; }
  64
  65 using namespace com::sun::star::container;
  66 using namespace com::sun::star::beans;
  67 using namespace com::sun::star::io;
  68 using namespace com::sun::star::lang;
  69 using namespace com::sun::star::sdbc;
  70 using namespace com::sun::star::task;
  71 using namespace com::sun::star::ucb;
  72 using namespace com::sun::star::uno;
  73
  74 namespace ucbhelper
  75 {
  76
  77 class EmptyInputStream : public ::cppu::WeakImplHelper< XInputStream >
  78 {
  79 public:
  80     virtual sal_Int32 SAL_CALL readBytes(
  81         Sequence< sal_Int8 > & data, sal_Int32 nBytesToRead ) override;
  82     virtual sal_Int32 SAL_CALL readSomeBytes(
  83         Sequence< sal_Int8 > & data, sal_Int32 nMaxBytesToRead ) override;
  84     virtual void SAL_CALL skipBytes( sal_Int32 nBytesToSkip ) override;
  85     virtual sal_Int32 SAL_CALL available() override;
  86     virtual void SAL_CALL closeInput() override;
  87 };
  88
  89 sal_Int32 EmptyInputStream::readBytes(
  90     Sequence< sal_Int8 > & data, sal_Int32 )
  91 {
  92     data.realloc( 0 );
  93     return 0;
  94 }
  95
  96 sal_Int32 EmptyInputStream::readSomeBytes(
  97     Sequence< sal_Int8 > & data, sal_Int32 )
  98 {
  99     data.realloc( 0 );
 100     return 0;
 101 }
 102
 103 void EmptyInputStream::skipBytes( sal_Int32 )
 104 {
 105 }
 106
 107 sal_Int32 EmptyInputStream::available()
 108 {
 109     return 0;
 110 }
 111
 112 void EmptyInputStream::closeInput()
 113 {
 114 }
 115
 116
 117 // class ContentEventListener_Impl.
 118
 119
 120 class ContentEventListener_Impl : public cppu::OWeakObject,
 121                                       public XContentEventListener
 122 {
 123     Content_Impl& m_rContent;
 124
 125 public:
 126     explicit ContentEventListener_Impl( Content_Impl& rContent )
 127         : m_rContent( rContent ) {}
 128
 129     // XInterface
 130     virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type & rType ) override;
 131     virtual void SAL_CALL acquire()
 132         throw() override;
 133     virtual void SAL_CALL release()
 134         throw() override;
 135
 136     // XContentEventListener
 137     virtual void SAL_CALL contentEvent( const ContentEvent& evt ) override;
 138
 139     // XEventListener ( base of XContentEventListener )
 140     virtual void SAL_CALL disposing( const EventObject& Source ) override;
 141 };
 142
 143
 144 // class Content_Impl.
 145
 146
 147 class Content_Impl : public salhelper::SimpleReferenceObject
 148 {
 149 friend class ContentEventListener_Impl;
 150
 151     mutable OUString               m_aURL;
 152     Reference< XComponentContext >      m_xCtx;
 153     Reference< XContent >               m_xContent;
 154     Reference< XCommandProcessor >          m_xCommandProcessor;
 155     Reference< XCommandEnvironment >    m_xEnv;
 156     Reference< XContentEventListener >  m_xContentEventListener;
 157     mutable osl::Mutex                  m_aMutex;
 158
 159 private:
 160     void reinit( const Reference< XContent >& xContent );
 161     void disposing(const EventObject& Source);
 162
 163 public:
 164     Content_Impl() {};
 165     Content_Impl( const Reference< XComponentContext >& rCtx,
 166                   const Reference< XContent >& rContent,
 167                   const Reference< XCommandEnvironment >& rEnv );
 168
 169     virtual ~Content_Impl() override;
 170
 171     const OUString&           getURL() const;
 172     Reference< XContent >          getContent();
 173     Reference< XCommandProcessor > getCommandProcessor();
 174     Reference< XComponentContext > const & getComponentContext() const
 175     { assert(m_xCtx.is()); return m_xCtx; }
 176
 177     Any  executeCommand( const Command& rCommand );
 178
 179     inline const Reference< XCommandEnvironment >& getEnvironment() const;
 180     inline void setEnvironment(
 181                         const Reference< XCommandEnvironment >& xNewEnv );
 182
 183     void inserted();
 184 };
 185
 186
 187 // Helpers.
 188
 189 /// @throws ContentCreationException
 190 /// @throws RuntimeException
 191 static void ensureContentProviderForURL( const Reference< XUniversalContentBroker >& rBroker,
 192                                          const OUString & rURL )
 193 {
 194     Reference< XContentProvider > xProv
 195         = rBroker->queryContentProvider( rURL );
 196     if ( !xProv.is() )
 197     {
 198         throw ContentCreationException(
 199             "No Content Provider available for URL: " + rURL,
 200             Reference< XInterface >(),
 201             ContentCreationError_NO_CONTENT_PROVIDER );
 202     }
 203 }
 204
 205 /// @throws ContentCreationException
 206 /// @throws RuntimeException
 207 static Reference< XContentIdentifier > getContentIdentifierThrow(
 208                                     const Reference< XUniversalContentBroker > & rBroker,
 209                                     const OUString & rURL)
 210 {
 211     Reference< XContentIdentifier > xId
 212         = rBroker->createContentIdentifier( rURL );
 213
 214     if (!xId.is())
 215     {
 216         ensureContentProviderForURL( rBroker, rURL );
 217
 218         throw ContentCreationException(
 219             "Unable to create Content Identifier!",
 220             Reference< XInterface >(),
 221             ContentCreationError_IDENTIFIER_CREATION_FAILED );
 222     }
 223
 224     return xId;
 225 }
 226
 227 /// @throws RuntimeException
 228 static Reference< XContentIdentifier > getContentIdentifierNoThrow(
 229                                     const Reference< XUniversalContentBroker > & rBroker,
 230                                     const OUString & rURL)
 231 {
 232     return rBroker->createContentIdentifier(rURL);
 233 }
 234
 235 /// @throws ContentCreationException
 236 /// @throws RuntimeException
 237 static Reference< XContent > getContentThrow(
 238                                     const Reference< XUniversalContentBroker > & rBroker,
 239                                     const Reference< XContentIdentifier > & xId)
 240 {
 241     Reference< XContent > xContent;
 242     OUString msg;
 243     try
 244     {
 245         xContent = rBroker->queryContent( xId );
 246     }
 247     catch ( IllegalIdentifierException const & e )
 248     {
 249         msg = e.Message;
 250         // handled below.
 251     }
 252
 253     if ( !xContent.is() )
 254     {
 255         ensureContentProviderForURL( rBroker, xId->getContentIdentifier() );
 256
 257         throw ContentCreationException(
 258             "Unable to create Content for <" + xId->getContentIdentifier() + ">: " + msg,
 259             Reference< XInterface >(),
 260             ContentCreationError_CONTENT_CREATION_FAILED );
 261     }
 262
 263     return xContent;
 264 }
 265
 266 /// @throws RuntimeException
 267 static Reference< XContent > getContentNoThrow(
 268                                     const Reference< XUniversalContentBroker > & rBroker,
 269                                     const Reference< XContentIdentifier > & xId)
 270 {
 271     Reference< XContent > xContent;
 272     try
 273     {
 274         xContent = rBroker->queryContent( xId );
 275     }
 276     catch ( IllegalIdentifierException const & e )
 277     {
 278         SAL_WARN("ucbhelper", "getContentNoThrow: " << e);
 279     }
 280
 281     return xContent;
 282 }
 283
 284
 285 // Content Implementation.
 286
 287
 288 Content::Content()
 289 : m_xImpl( new Content_Impl )
 290 {
 291 }
 292
 293
 294 Content::Content( const OUString& rURL,
 295                   const Reference< XCommandEnvironment >& rEnv,
 296                   const Reference< XComponentContext >& rCtx )
 297 {
 298     Reference< XUniversalContentBroker > pBroker(
 299         UniversalContentBroker::create( rCtx ) );
 300
 301     Reference< XContentIdentifier > xId
 302         = getContentIdentifierThrow(pBroker, rURL);
 303
 304     Reference< XContent > xContent = getContentThrow(pBroker, xId);
 305
 306     m_xImpl = new Content_Impl( rCtx, xContent, rEnv );
 307 }
 308
 309
 310 Content::Content( const Reference< XContent >& rContent,
 311                   const Reference< XCommandEnvironment >& rEnv,
 312                   const Reference< XComponentContext >& rCtx )
 313 {
 314     m_xImpl = new Content_Impl( rCtx, rContent, rEnv );
 315 }
 316
 317
 318 Content::Content( const Content& rOther )
 319 {
 320     m_xImpl = rOther.m_xImpl;
 321 }
 322
 323 Content::Content( Content&& rOther ) noexcept
 324 {
 325     m_xImpl = std::move(rOther.m_xImpl);
 326 }
 327
 328 // static
 329 bool Content::create( const OUString& rURL,
 330                           const Reference< XCommandEnvironment >& rEnv,
 331                           const Reference< XComponentContext >& rCtx,
 332                           Content& rContent )
 333 {
 334     Reference< XUniversalContentBroker > pBroker(
 335         UniversalContentBroker::create( rCtx ) );
 336
 337     Reference< XContentIdentifier > xId
 338         = getContentIdentifierNoThrow(pBroker, rURL);
 339     if ( !xId.is() )
 340         return false;
 341
 342     Reference< XContent > xContent = getContentNoThrow(pBroker, xId);
 343     if ( !xContent.is() )
 344         return false;
 345
 346     rContent.m_xImpl
 347         = new Content_Impl( rCtx, xContent, rEnv );
 348
 349     return true;
 350 }
 351
 352
 353 Content::~Content()
 354 {
 355 }
 356
 357
 358 Content& Content::operator=( const Content& rOther )
 359 {
 360     m_xImpl = rOther.m_xImpl;
 361     return *this;
 362 }
 363
 364 Content& Content::operator=( Content&& rOther ) noexcept
 365 {
 366     m_xImpl = std::move(rOther.m_xImpl);
 367     return *this;
 368 }
 369
 370 Reference< XContent > Content::get() const
 371 {
 372     return m_xImpl->getContent();
 373 }
 374
 375
 376 const OUString& Content::getURL() const
 377 {
 378     return m_xImpl->getURL();
 379 }
 380
 381
 382 const Reference< XCommandEnvironment >& Content::getCommandEnvironment() const
 383 {
 384     return m_xImpl->getEnvironment();
 385 }
 386
 387
 388 void Content::setCommandEnvironment(
 389                         const Reference< XCommandEnvironment >& xNewEnv )
 390 {
 391     m_xImpl->setEnvironment( xNewEnv );
 392 }
 393
 394
 395 Reference< XCommandInfo > Content::getCommands()
 396 {
 397     Command aCommand;
 398     aCommand.Name     = "getCommandInfo";
 399     aCommand.Handle   = -1; // n/a
 400     aCommand.Argument = Any();
 401
 402     Any aResult = m_xImpl->executeCommand( aCommand );
 403
 404     Reference< XCommandInfo > xInfo;
 405     aResult >>= xInfo;
 406     return xInfo;
 407 }
 408
 409
 410 Reference< XPropertySetInfo > Content::getProperties()
 411 {
 412     Command aCommand;
 413     aCommand.Name     = "getPropertySetInfo";
 414     aCommand.Handle   = -1; // n/a
 415     aCommand.Argument = Any();
 416
 417     Any aResult = m_xImpl->executeCommand( aCommand );
 418
 419     Reference< XPropertySetInfo > xInfo;
 420     aResult >>= xInfo;
 421     return xInfo;
 422 }
 423
 424
 425 Any Content::getPropertyValue( const OUString& rPropertyName )
 426 {
 427     Sequence<OUString> aNames { rPropertyName };
 428
 429     Sequence< Any > aRet = getPropertyValues( aNames );
 430     return aRet.getConstArray()[ 0 ];
 431 }
 432
 433
 434 Any Content::setPropertyValue( const OUString& rName,
 435                                 const Any& rValue )
 436 {
 437     Sequence<OUString> aNames { rName };
 438
 439     Sequence< Any > aValues( 1 );
 440     aValues.getArray()[ 0 ] = rValue;
 441
 442     Sequence< Any > aErrors = setPropertyValues( aNames, aValues );
 443     return aErrors.getConstArray()[ 0 ];
 444 }
 445
 446
 447 Sequence< Any > Content::getPropertyValues(
 448                             const Sequence< OUString >& rPropertyNames )
 449 {
 450     Reference< XRow > xRow = getPropertyValuesInterface( rPropertyNames );
 451
 452     sal_Int32 nCount = rPropertyNames.getLength();
 453     Sequence< Any > aValues( nCount );
 454
 455     if ( xRow.is() )
 456     {
 457         Any* pValues = aValues.getArray();
 458
 459         for ( sal_Int32 n = 0; n < nCount; ++n )
 460             pValues[ n ] = xRow->getObject( n + 1, Reference< XNameAccess >() );
 461     }
 462
 463     return aValues;
 464 }
 465
 466
 467 Reference< XRow > Content::getPropertyValuesInterface(
 468                             const Sequence< OUString >& rPropertyNames )
 469 {
 470     sal_Int32 nCount = rPropertyNames.getLength();
 471     Sequence< Property > aProps( nCount );
 472     Property* pProps = aProps.getArray();
 473
 474     const OUString* pNames  = rPropertyNames.getConstArray();
 475
 476     for ( sal_Int32 n = 0; n< nCount; ++n )
 477     {
 478         Property& rProp = pProps[ n ];
 479
 480         rProp.Name       = pNames[ n ];
 481         rProp.Handle     = -1; // n/a
 482 //        rProp.Type       =
 483 //        rProp.Attributes = ;
 484     }
 485
 486     Command aCommand;
 487     aCommand.Name     = "getPropertyValues";
 488     aCommand.Handle   = -1; // n/a
 489     aCommand.Argument <<= aProps;
 490
 491     Any aResult = m_xImpl->executeCommand( aCommand );
 492
 493     Reference< XRow > xRow;
 494     aResult >>= xRow;
 495     return xRow;
 496 }
 497
 498
 499 Sequence< Any > Content::setPropertyValues(
 500                             const Sequence< OUString >& rPropertyNames,
 501                                 const Sequence< Any >& rValues )
 502 {
 503     if ( rPropertyNames.getLength() != rValues.getLength() )
 504     {
 505         ucbhelper::cancelCommandExecution(
 506             makeAny( IllegalArgumentException(
 507                         "Length of property names sequence and value "
 508                         "sequence are unequal!",
 509                         get(),
 510                         -1 ) ),
 511             m_xImpl->getEnvironment() );
 512         // Unreachable
 513     }
 514
 515     sal_Int32 nCount = rValues.getLength();
 516     Sequence< PropertyValue > aProps( nCount );
 517     PropertyValue* pProps = aProps.getArray();
 518
 519     const OUString* pNames  = rPropertyNames.getConstArray();
 520     const Any* pValues = rValues.getConstArray();
 521
 522     for ( sal_Int32 n = 0; n< nCount; ++n )
 523     {
 524         PropertyValue& rProp = pProps[ n ];
 525
 526         rProp.Name   = pNames[ n ];
 527         rProp.Handle = -1; // n/a
 528         rProp.Value  = pValues[ n ];
 529 //        rProp.State  = ;
 530     }
 531
 532     Command aCommand;
 533     aCommand.Name     = "setPropertyValues";
 534     aCommand.Handle   = -1; // n/a
 535     aCommand.Argument <<= aProps;
 536
 537     Any aResult = m_xImpl->executeCommand( aCommand );
 538
 539     Sequence< Any > aErrors;
 540     aResult >>= aErrors;
 541     return aErrors;
 542 }
 543
 544
 545 Any Content::executeCommand( const OUString& rCommandName,
 546                              const Any& rCommandArgument )
 547 {
 548     Command aCommand;
 549     aCommand.Name     = rCommandName;
 550     aCommand.Handle   = -1; // n/a
 551     aCommand.Argument = rCommandArgument;
 552
 553     return m_xImpl->executeCommand( aCommand );
 554 }
 555
 556
 557 Any Content::createCursorAny( const Sequence< OUString >& rPropertyNames,
 558                               ResultSetInclude eMode )
 559 {
 560     sal_Int32 nCount = rPropertyNames.getLength();
 561     Sequence< Property > aProps( nCount );
 562     Property* pProps = aProps.getArray();
 563     const OUString* pNames = rPropertyNames.getConstArray();
 564     for ( sal_Int32 n = 0; n < nCount; ++n )
 565     {
 566         Property& rProp = pProps[ n ];
 567         rProp.Name   = pNames[ n ];
 568         rProp.Handle = -1; // n/a
 569     }
 570
 571     OpenCommandArgument2 aArg;
 572     aArg.Mode       = ( eMode == INCLUDE_FOLDERS_ONLY )
 573                         ? OpenMode::FOLDERS
 574                         : ( eMode == INCLUDE_DOCUMENTS_ONLY )
 575                             ? OpenMode::DOCUMENTS : OpenMode::ALL;
 576     aArg.Priority   = 0; // unused
 577     aArg.Sink.clear(); // unused
 578     aArg.Properties = aProps;
 579
 580     Command aCommand;
 581     aCommand.Name     = "open";
 582     aCommand.Handle   = -1; // n/a
 583     aCommand.Argument <<= aArg;
 584
 585     return m_xImpl->executeCommand( aCommand );
 586 }
 587
 588
 589 Reference< XResultSet > Content::createCursor(
 590                             const Sequence< OUString >& rPropertyNames,
 591                             ResultSetInclude eMode )
 592 {
 593     Any aCursorAny = createCursorAny( rPropertyNames, eMode );
 594
 595     Reference< XDynamicResultSet > xDynSet;
 596     Reference< XResultSet > aResult;
 597
 598     aCursorAny >>= xDynSet;
 599     if ( xDynSet.is() )
 600         aResult = xDynSet->getStaticResultSet();
 601
 602     OSL_ENSURE( aResult.is(), "Content::createCursor - no cursor!" );
 603
 604     if ( !aResult.is() )
 605     {
 606         // Former, the open command directly returned a XResultSet.
 607         aCursorAny >>= aResult;
 608
 609         OSL_ENSURE( !aResult.is(),
 610                     "Content::createCursor - open-Command must "
 611                     "return a Reference< XDynnamicResultSet >!" );
 612     }
 613
 614     return aResult;
 615 }
 616
 617
 618 Reference< XDynamicResultSet > Content::createDynamicCursor(
 619                             const Sequence< OUString >& rPropertyNames,
 620                             ResultSetInclude eMode )
 621 {
 622     Reference< XDynamicResultSet > aResult;
 623     createCursorAny( rPropertyNames, eMode ) >>= aResult;
 624
 625     OSL_ENSURE( aResult.is(), "Content::createDynamicCursor - no cursor!" );
 626
 627     return aResult;
 628 }
 629
 630
 631 Reference< XResultSet > Content::createSortedCursor(
 632                             const Sequence< OUString >& rPropertyNames,
 633                             const Sequence< NumberedSortingInfo >& rSortInfo,
 634                             const Reference< XAnyCompareFactory >& rAnyCompareFactory,
 635                             ResultSetInclude eMode )
 636 {
 637     Reference< XResultSet > aResult;
 638     Reference< XDynamicResultSet > aDynSet;
 639
 640     Any aCursorAny = createCursorAny( rPropertyNames, eMode );
 641
 642     aCursorAny >>= aDynSet;
 643
 644     if( aDynSet.is() )
 645     {
 646         Reference< XDynamicResultSet > aDynResult;
 647
 648         if( m_xImpl->getComponentContext().is() )
 649         {
 650             Reference< XSortedDynamicResultSetFactory > aSortFactory =
 651                                 SortedDynamicResultSetFactory::create( m_xImpl->getComponentContext());
 652
 653             aDynResult = aSortFactory->createSortedDynamicResultSet( aDynSet,
 654                                                               rSortInfo,
 655                                                               rAnyCompareFactory );
 656         }
 657
 658         OSL_ENSURE( aDynResult.is(), "Content::createSortedCursor - no sorted cursor!" );
 659
 660         if( aDynResult.is() )
 661             aResult = aDynResult->getStaticResultSet();
 662         else
 663             aResult = aDynSet->getStaticResultSet();
 664     }
 665
 666     OSL_ENSURE( aResult.is(), "Content::createSortedCursor - no cursor!" );
 667
 668     if ( !aResult.is() )
 669     {
 670         // Former, the open command directly returned a XResultSet.
 671         aCursorAny >>= aResult;
 672
 673         OSL_ENSURE( !aResult.is(),
 674                     "Content::createCursor - open-Command must "
 675                     "return a Reference< XDynnamicResultSet >!" );
 676     }
 677
 678     return aResult;
 679 }
 680
 681
 682 Reference< XInputStream > Content::openStream()
 683 {
 684     if ( !isDocument() )
 685         return Reference< XInputStream >();
 686
 687     Reference< XActiveDataSink > xSink = new ActiveDataSink;
 688
 689     OpenCommandArgument2 aArg;
 690     aArg.Mode       = OpenMode::DOCUMENT;
 691     aArg.Priority   = 0; // unused
 692     aArg.Sink       = xSink;
 693     aArg.Properties = Sequence< Property >( 0 ); // unused
 694
 695     Command aCommand;
 696     aCommand.Name     = "open";
 697     aCommand.Handle   = -1; // n/a
 698     aCommand.Argument <<= aArg;
 699
 700     m_xImpl->executeCommand( aCommand );
 701
 702     return xSink->getInputStream();
 703 }
 704
 705
 706 Reference< XInputStream > Content::openStreamNoLock()
 707 {
 708     if ( !isDocument() )
 709         return Reference< XInputStream >();
 710
 711     Reference< XActiveDataSink > xSink = new ActiveDataSink;
 712
 713     OpenCommandArgument2 aArg;
 714     aArg.Mode       = OpenMode::DOCUMENT_SHARE_DENY_NONE;
 715     aArg.Priority   = 0; // unused
 716     aArg.Sink       = xSink;
 717     aArg.Properties = Sequence< Property >( 0 ); // unused
 718
 719     Command aCommand;
 720     aCommand.Name     = "open";
 721     aCommand.Handle   = -1; // n/a
 722     aCommand.Argument <<= aArg;
 723
 724     m_xImpl->executeCommand( aCommand );
 725
 726     return xSink->getInputStream();
 727 }
 728
 729
 730 Reference< XStream > Content::openWriteableStream()
 731 {
 732     if ( !isDocument() )
 733         return Reference< XStream >();
 734
 735     Reference< XActiveDataStreamer > xStreamer = new ActiveDataStreamer;
 736
 737     OpenCommandArgument2 aArg;
 738     aArg.Mode       = OpenMode::DOCUMENT;
 739     aArg.Priority   = 0; // unused
 740     aArg.Sink       = xStreamer;
 741     aArg.Properties = Sequence< Property >( 0 ); // unused
 742
 743     Command aCommand;
 744     aCommand.Name     = "open";
 745     aCommand.Handle   = -1; // n/a
 746     aCommand.Argument <<= aArg;
 747
 748     m_xImpl->executeCommand( aCommand );
 749
 750     return xStreamer->getStream();
 751 }
 752
 753
 754 Reference< XStream > Content::openWriteableStreamNoLock()
 755 {
 756     if ( !isDocument() )
 757         return Reference< XStream >();
 758
 759     Reference< XActiveDataStreamer > xStreamer = new ActiveDataStreamer;
 760
 761     OpenCommandArgument2 aArg;
 762     aArg.Mode       = OpenMode::DOCUMENT_SHARE_DENY_NONE;
 763     aArg.Priority   = 0; // unused
 764     aArg.Sink       = xStreamer;
 765     aArg.Properties = Sequence< Property >( 0 ); // unused
 766
 767     Command aCommand;
 768     aCommand.Name     = "open";
 769     aCommand.Handle   = -1; // n/a
 770     aCommand.Argument <<= aArg;
 771
 772     m_xImpl->executeCommand( aCommand );
 773
 774     return xStreamer->getStream();
 775 }
 776
 777
 778 bool Content::openStream( const Reference< XActiveDataSink >& rSink )
 779 {
 780     if ( !isDocument() )
 781         return false;
 782
 783     OpenCommandArgument2 aArg;
 784     aArg.Mode       = OpenMode::DOCUMENT;
 785     aArg.Priority   = 0; // unused
 786     aArg.Sink       = rSink;
 787     aArg.Properties = Sequence< Property >( 0 ); // unused
 788
 789     Command aCommand;
 790     aCommand.Name     = "open";
 791     aCommand.Handle   = -1; // n/a
 792     aCommand.Argument <<= aArg;
 793
 794     m_xImpl->executeCommand( aCommand );
 795
 796     return true;
 797 }
 798
 799
 800 bool Content::openStream( const Reference< XOutputStream >& rStream )
 801 {
 802     if ( !isDocument() )
 803         return false;
 804
 805     OpenCommandArgument2 aArg;
 806     aArg.Mode       = OpenMode::DOCUMENT;
 807     aArg.Priority   = 0; // unused
 808     aArg.Sink       = rStream;
 809     aArg.Properties = Sequence< Property >( 0 ); // unused
 810
 811     Command aCommand;
 812     aCommand.Name     = "open";
 813     aCommand.Handle   = -1; // n/a
 814     aCommand.Argument <<= aArg;
 815
 816     m_xImpl->executeCommand( aCommand );
 817
 818     return true;
 819 }
 820
 821
 822 void Content::writeStream( const Reference< XInputStream >& rStream,
 823                            bool bReplaceExisting )
 824 {
 825     InsertCommandArgument aArg;
 826     aArg.Data            = rStream.is() ? rStream : new EmptyInputStream;
 827     aArg.ReplaceExisting = bReplaceExisting;
 828
 829     Command aCommand;
 830     aCommand.Name     = "insert";
 831     aCommand.Handle   = -1; // n/a
 832     aCommand.Argument <<= aArg;
 833
 834     m_xImpl->executeCommand( aCommand );
 835
 836     m_xImpl->inserted();
 837 }
 838
 839
 840 Sequence< ContentInfo > Content::queryCreatableContentsInfo()
 841 {
 842     // First, try it using "CreatableContentsInfo" property -> the "new" way.
 843     Sequence< ContentInfo > aInfo;
 844     if ( getPropertyValue(
 845              "CreatableContentsInfo" )
 846          >>= aInfo )
 847         return aInfo;
 848
 849     // Second, try it using XContentCreator interface -> the "old" way (not
 850     // providing the chance to supply an XCommandEnvironment.
 851     Reference< XContentCreator > xCreator( m_xImpl->getContent(), UNO_QUERY );
 852     if ( xCreator.is() )
 853         aInfo = xCreator->queryCreatableContentsInfo();
 854
 855     return aInfo;
 856 }
 857
 858
 859 bool Content::insertNewContent( const OUString& rContentType,
 860                                     const Sequence< OUString >&
 861                                         rPropertyNames,
 862                                     const Sequence< Any >& rPropertyValues,
 863                                     Content& rNewContent )
 864 {
 865     return insertNewContent( rContentType,
 866                              rPropertyNames,
 867                              rPropertyValues,
 868                              new EmptyInputStream,
 869                              rNewContent );
 870 }
 871
 872
 873 bool Content::insertNewContent( const OUString& rContentType,
 874                                     const Sequence< OUString >&
 875                                         rPropertyNames,
 876                                     const Sequence< Any >& rPropertyValues,
 877                                     const Reference< XInputStream >& rData,
 878                                     Content& rNewContent )
 879 {
 880     if ( rContentType.isEmpty() )
 881         return false;
 882
 883     // First, try it using "createNewContent" command -> the "new" way.
 884     ContentInfo aInfo;
 885     aInfo.Type = rContentType;
 886     aInfo.Attributes = 0;
 887
 888     Command aCommand;
 889     aCommand.Name     = "createNewContent";
 890     aCommand.Handle   = -1; // n/a
 891     aCommand.Argument <<= aInfo;
 892
 893     Reference< XContent > xNew;
 894     try
 895     {
 896         m_xImpl->executeCommand( aCommand ) >>= xNew;
 897     }
 898     catch ( RuntimeException const & )
 899     {
 900         throw;
 901     }
 902     catch ( Exception const & )
 903     {
 904     }
 905
 906     if ( !xNew.is() )
 907     {
 908         // Second, try it using XContentCreator interface -> the "old"
 909         // way (not providing the chance to supply an XCommandEnvironment.
 910         Reference< XContentCreator > xCreator( m_xImpl->getContent(), UNO_QUERY );
 911
 912         if ( !xCreator.is() )
 913             return false;
 914
 915         xNew = xCreator->createNewContent( aInfo );
 916
 917         if ( !xNew.is() )
 918             return false;
 919     }
 920
 921     Content aNewContent(
 922         xNew, m_xImpl->getEnvironment(), m_xImpl->getComponentContext() );
 923     aNewContent.setPropertyValues( rPropertyNames, rPropertyValues );
 924     aNewContent.executeCommand( "insert",
 925                                 makeAny(
 926                                     InsertCommandArgument(
 927                                         rData.is() ? rData : new EmptyInputStream,
 928                                         false /* ReplaceExisting */ ) ) );
 929     aNewContent.m_xImpl->inserted();
 930
 931     rNewContent = aNewContent;
 932     return true;
 933 }
 934
 935
 936 void Content::transferContent( const Content& rSourceContent,
 937                                    InsertOperation eOperation,
 938                                    const OUString & rTitle,
 939                                    const sal_Int32 nNameClashAction,
 940                                    const OUString & rMimeType,
 941                                    bool bMajorVersion,
 942                                    const OUString & rVersionComment,
 943                                    OUString* pResultURL,
 944                                    const OUString & rDocumentId ) const
 945 {
 946     Reference< XUniversalContentBroker > pBroker(
 947         UniversalContentBroker::create( m_xImpl->getComponentContext() ) );
 948
 949     // Execute command "globalTransfer" at UCB.
 950
 951     TransferCommandOperation eTransOp = TransferCommandOperation();
 952     OUString sCommand( "globalTransfer" );
 953     bool bCheckIn = false;
 954     switch ( eOperation )
 955     {
 956         case InsertOperation::Copy:
 957             eTransOp = TransferCommandOperation_COPY;
 958             break;
 959
 960         case InsertOperation::Move:
 961             eTransOp = TransferCommandOperation_MOVE;
 962             break;
 963
 964         case InsertOperation::Checkin:
 965             eTransOp = TransferCommandOperation_COPY;
 966             sCommand = "checkin";
 967             bCheckIn = true;
 968             break;
 969     }
 970     Command aCommand;
 971     aCommand.Name     = sCommand;
 972     aCommand.Handle   = -1; // n/a
 973
 974     if ( !bCheckIn )
 975     {
 976         GlobalTransferCommandArgument2 aTransferArg(
 977                                             eTransOp,
 978                                             rSourceContent.getURL(), // SourceURL
 979                                             getURL(),   // TargetFolderURL,
 980                                             rTitle,
 981                                             nNameClashAction,
 982                                             rMimeType,
 983                                             rDocumentId );
 984         aCommand.Argument <<= aTransferArg;
 985     }
 986     else
 987     {
 988         CheckinArgument aCheckinArg( bMajorVersion, rVersionComment,
 989                 rSourceContent.getURL(), getURL(), rTitle, rMimeType );
 990         aCommand.Argument <<= aCheckinArg;
 991     }
 992
 993     Any aRet = pBroker->execute( aCommand, 0, m_xImpl->getEnvironment() );
 994     if ( pResultURL != nullptr )
 995         aRet >>= *pResultURL;
 996 }
 997
 998
 999 bool Content::isFolder()
1000 {
1001     bool bFolder = false;
1002     if ( getPropertyValue("IsFolder")
1003         >>= bFolder )
1004         return bFolder;
1005
1006     ucbhelper::cancelCommandExecution(
1007          makeAny( UnknownPropertyException(
1008                     "Unable to retrieve value of property 'IsFolder'!",
1009                     get() ) ),
1010          m_xImpl->getEnvironment() );
1011
1012 #if !(defined(_MSC_VER) && defined(ENABLE_LTO))
1013     // Unreachable - cancelCommandExecution always throws an exception.
1014     // But some compilers complain...
1015     return false;
1016 #endif
1017 }
1018
1019
1020 SAL_WNOUNREACHABLE_CODE_PUSH
1021
1022 bool Content::isDocument()
1023 {
1024     bool bDoc = false;
1025     if ( getPropertyValue("IsDocument")
1026         >>= bDoc )
1027         return bDoc;
1028
1029     ucbhelper::cancelCommandExecution(
1030          makeAny( UnknownPropertyException(
1031                     "Unable to retrieve value of property 'IsDocument'!",
1032                     get() ) ),
1033          m_xImpl->getEnvironment() );
1034
1035     // Unreachable - cancelCommandExecution always throws an exception,
1036     // But some compilers complain...
1037     return false;
1038 }
1039
1040 SAL_WNOUNREACHABLE_CODE_POP
1041
1042 void Content::lock()
1043 {
1044     Command aCommand;
1045     aCommand.Name     = "lock";
1046     aCommand.Handle   = -1; // n/a
1047
1048     m_xImpl->executeCommand( aCommand );
1049
1050 }
1051
1052 void Content::unlock()
1053 {
1054
1055     Command aCommand;
1056     aCommand.Name     = "unlock";
1057     aCommand.Handle   = -1; // n/a
1058
1059     m_xImpl->executeCommand( aCommand );
1060
1061 }
1062
1063
1064 // Content_Impl Implementation.
1065
1066
1067 Content_Impl::Content_Impl( const Reference< XComponentContext >& rCtx,
1068                             const Reference< XContent >& rContent,
1069                             const Reference< XCommandEnvironment >& rEnv )
1070 : m_xCtx( rCtx ),
1071   m_xContent( rContent ),
1072   m_xEnv( rEnv )
1073 {
1074     assert(rCtx.is());
1075     if ( m_xContent.is() )
1076     {
1077         m_xContentEventListener = new ContentEventListener_Impl( *this );
1078         m_xContent->addContentEventListener( m_xContentEventListener );
1079
1080 #if OSL_DEBUG_LEVEL > 0
1081         // Only done on demand in product version for performance reasons,
1082         // but a nice debug helper.
1083         getURL();
1084 #endif
1085     }
1086 }
1087
1088
1089 void Content_Impl::reinit( const Reference< XContent >& xContent )
1090 {
1091     osl::MutexGuard aGuard( m_aMutex );
1092
1093     m_xCommandProcessor = nullptr;
1094
1095     // #92581# - Don't reset m_aURL!!!
1096
1097     if ( m_xContent.is() )
1098     {
1099         try
1100         {
1101             m_xContent->removeContentEventListener( m_xContentEventListener );
1102         }
1103         catch ( RuntimeException const & )
1104         {
1105         }
1106     }
1107
1108     if ( xContent.is() )
1109     {
1110         m_xContent = xContent;
1111         m_xContent->addContentEventListener( m_xContentEventListener );
1112
1113 #if OSL_DEBUG_LEVEL > 0
1114         // Only done on demand in product version for performance reasons,
1115         // but a nice debug helper.
1116         getURL();
1117 #endif
1118     }
1119     else
1120     {
1121         // We need m_xContent's URL in order to be able to create the
1122         // content object again if demanded ( --> Content_Impl::getContent() )
1123         getURL();
1124
1125         m_xContent = nullptr;
1126     }
1127 }
1128
1129
1130 // virtual
1131 Content_Impl::~Content_Impl()
1132 {
1133     if ( m_xContent.is() )
1134     {
1135         try
1136         {
1137             m_xContent->removeContentEventListener( m_xContentEventListener );
1138         }
1139         catch ( RuntimeException const & )
1140         {
1141         }
1142     }
1143 }
1144
1145
1146 void Content_Impl::disposing( const EventObject& Source )
1147 {
1148     Reference<XContent> xContent;
1149
1150     {
1151         osl::MutexGuard aGuard( m_aMutex );
1152         if(Source.Source != m_xContent)
1153             return;
1154
1155         xContent = m_xContent;
1156
1157         m_aURL.clear();
1158         m_xCommandProcessor = nullptr;
1159         m_xContent = nullptr;
1160     }
1161
1162     if ( xContent.is() )
1163     {
1164         try
1165         {
1166             xContent->removeContentEventListener( m_xContentEventListener );
1167         }
1168         catch ( RuntimeException const & )
1169         {
1170         }
1171     }
1172 }
1173
1174
1175 const OUString& Content_Impl::getURL() const
1176 {
1177     if ( m_aURL.isEmpty() && m_xContent.is() )
1178     {
1179         osl::MutexGuard aGuard( m_aMutex );
1180
1181         if ( m_aURL.isEmpty() && m_xContent.is() )
1182         {
1183             Reference< XContentIdentifier > xId = m_xContent->getIdentifier();
1184             if ( xId.is() )
1185                 m_aURL = xId->getContentIdentifier();
1186         }
1187     }
1188
1189     return m_aURL;
1190 }
1191
1192
1193 Reference< XContent > Content_Impl::getContent()
1194 {
1195     if ( !m_xContent.is() && !m_aURL.isEmpty() )
1196     {
1197         osl::MutexGuard aGuard( m_aMutex );
1198
1199         if ( !m_xContent.is() && !m_aURL.isEmpty() )
1200         {
1201             Reference< XUniversalContentBroker > pBroker(
1202                 UniversalContentBroker::create( getComponentContext() ) );
1203
1204             OSL_ENSURE( pBroker->queryContentProviders().hasElements(),
1205                         "Content Broker not configured (no providers)!" );
1206
1207             Reference< XContentIdentifier > xId
1208                 = pBroker->createContentIdentifier( m_aURL );
1209
1210             OSL_ENSURE( xId.is(), "No Content Identifier!" );
1211
1212             if ( xId.is() )
1213             {
1214                 try
1215                 {
1216                     m_xContent = pBroker->queryContent( xId );
1217                 }
1218                 catch ( IllegalIdentifierException const & )
1219                 {
1220                 }
1221
1222                 if ( m_xContent.is() )
1223                     m_xContent->addContentEventListener(
1224                         m_xContentEventListener );
1225             }
1226         }
1227     }
1228
1229     return m_xContent;
1230 }
1231
1232
1233 Reference< XCommandProcessor > Content_Impl::getCommandProcessor()
1234 {
1235     if ( !m_xCommandProcessor.is() )
1236     {
1237         osl::MutexGuard aGuard( m_aMutex );
1238
1239         if ( !m_xCommandProcessor.is() )
1240             m_xCommandProcessor.set( getContent(), UNO_QUERY );
1241     }
1242
1243     return m_xCommandProcessor;
1244 }
1245
1246
1247 Any Content_Impl::executeCommand( const Command& rCommand )
1248 {
1249     Reference< XCommandProcessor > xProc = getCommandProcessor();
1250     if ( !xProc.is() )
1251         return Any();
1252
1253     // Execute command
1254     return xProc->execute( rCommand, 0, m_xEnv );
1255 }
1256
1257
1258 inline const Reference< XCommandEnvironment >&
1259                                         Content_Impl::getEnvironment() const
1260 {
1261     return m_xEnv;
1262 }
1263
1264
1265 inline void Content_Impl::setEnvironment(
1266                         const Reference< XCommandEnvironment >& xNewEnv )
1267 {
1268     osl::MutexGuard aGuard( m_aMutex );
1269     m_xEnv = xNewEnv;
1270 }
1271
1272
1273 void Content_Impl::inserted()
1274 {
1275     // URL might have changed during 'insert' => recalculate in next getURL()
1276     osl::MutexGuard aGuard( m_aMutex );
1277     m_aURL.clear();
1278 }
1279
1280
1281 // ContentEventListener_Impl Implementation.
1282
1283
1284 // XInterface methods.
1285
1286 void SAL_CALL ContentEventListener_Impl::acquire()
1287     throw()
1288 {
1289     OWeakObject::acquire();
1290 }
1291
1292 void SAL_CALL ContentEventListener_Impl::release()
1293     throw()
1294 {
1295     OWeakObject::release();
1296 }
1297
1298 css::uno::Any SAL_CALL ContentEventListener_Impl::queryInterface( const css::uno::Type & rType )
1299 {
1300     css::uno::Any aRet = cppu::queryInterface( rType,
1301                                                static_cast< XContentEventListener* >(this),
1302                                                static_cast< XEventListener* >(this)
1303                                                );
1304     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
1305 }
1306
1307 // XContentEventListener methods.
1308
1309
1310 // virtual
1311 void SAL_CALL ContentEventListener_Impl::contentEvent( const ContentEvent& evt )
1312 {
1313     if ( evt.Source == m_rContent.m_xContent )
1314     {
1315         switch ( evt.Action )
1316         {
1317             case ContentAction::DELETED:
1318                 m_rContent.reinit( Reference< XContent >() );
1319                 break;
1320
1321             case ContentAction::EXCHANGED:
1322                 m_rContent.reinit( evt.Content );
1323                 break;
1324
1325             default:
1326                 break;
1327         }
1328     }
1329 }
1330
1331
1332 // XEventListenr methods.
1333
1334
1335 // virtual
1336 void SAL_CALL ContentEventListener_Impl::disposing( const EventObject& Source )
1337 {
1338     m_rContent.disposing(Source);
1339 }
1340
1341 } /* namespace ucbhelper */
1342
1343 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */