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