ucb/source/core/ucbcmds.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 <osl/diagnose.h>
  27 #include <comphelper/processfactory.hxx>
  28 #include <cppuhelper/implbase1.hxx>
  29 #include <cppuhelper/exc_hlp.hxx>
  30 #include <rtl/ustring.h>
  31 #include <rtl/ustring.hxx>
  32 #include <com/sun/star/uno/XInterface.hpp>
  33 #include <com/sun/star/beans/PropertyState.hpp>
  34 #include <com/sun/star/beans/PropertyValue.hpp>
  35 #include <com/sun/star/container/XChild.hpp>
  36 #include <com/sun/star/beans/XPropertySetInfo.hpp>
  37 #include <com/sun/star/io/Pipe.hpp>
  38 #include <com/sun/star/io/XActiveDataSink.hpp>
  39 #include <com/sun/star/io/XOutputStream.hpp>
  40 #include <com/sun/star/io/XSeekable.hpp>
  41 #include <com/sun/star/sdbc/XRow.hpp>
  42 #include <com/sun/star/task/XInteractionHandler.hpp>
  43 #include <com/sun/star/ucb/CommandEnvironment.hpp>
  44 #include <com/sun/star/ucb/CommandFailedException.hpp>
  45 #include <com/sun/star/ucb/ContentInfoAttribute.hpp>
  46 #include <com/sun/star/ucb/GlobalTransferCommandArgument2.hpp>
  47 #include <com/sun/star/ucb/InsertCommandArgument2.hpp>
  48 #include <com/sun/star/ucb/InteractiveBadTransferURLException.hpp>
  49 #include <com/sun/star/ucb/NameClash.hpp>
  50 #include <com/sun/star/ucb/NameClashException.hpp>
  51 #include <com/sun/star/ucb/OpenCommandArgument2.hpp>
  52 #include <com/sun/star/ucb/OpenMode.hpp>
  53 #include <com/sun/star/ucb/TransferInfo2.hpp>
  54 #include <com/sun/star/ucb/UnsupportedNameClashException.hpp>
  55 #include <com/sun/star/ucb/XCommandInfo.hpp>
  56 #include <com/sun/star/ucb/XContentAccess.hpp>
  57 #include <com/sun/star/ucb/XContentCreator.hpp>
  58 #include <com/sun/star/ucb/XDynamicResultSet.hpp>
  59 #include <com/sun/star/uno/Any.hxx>
  60 #include <com/sun/star/uno/Sequence.hxx>
  61 #include <ucbhelper/cancelcommandexecution.hxx>
  62 #include <ucbhelper/simplenameclashresolverequest.hxx>
  63 #include "ucbcmds.hxx"
  64 #include "ucb.hxx"
  65
  66 using namespace com::sun::star;
  67
  68 namespace
  69 {
  70
  71
  72
  73 // struct TransferCommandContext.
  74
  75
  76
  77 struct TransferCommandContext
  78 {
  79     uno::Reference< uno::XComponentContext >     m_xContext;
  80     uno::Reference< ucb::XCommandProcessor >     xProcessor;
  81     uno::Reference< ucb::XCommandEnvironment >   xEnv;
  82     uno::Reference< ucb::XCommandEnvironment >   xOrigEnv;
  83     ucb::GlobalTransferCommandArgument2          aArg;
  84
  85     TransferCommandContext(
  86         const uno::Reference< uno::XComponentContext > & xContext,
  87         const uno::Reference< ucb::XCommandProcessor > & rxProcessor,
  88         const uno::Reference< ucb::XCommandEnvironment > & rxEnv,
  89         const uno::Reference< ucb::XCommandEnvironment > & rxOrigEnv,
  90         const ucb::GlobalTransferCommandArgument2 & rArg )
  91     : m_xContext( xContext ), xProcessor( rxProcessor ), xEnv( rxEnv ),
  92       xOrigEnv( rxOrigEnv ), aArg( rArg ) {}
  93 };
  94
  95
  96
  97 // class InteractionHandlerProxy.
  98
  99
 100
 101 class InteractionHandlerProxy :
 102     public cppu::WeakImplHelper1< task::XInteractionHandler >
 103 {
 104     uno::Reference< task::XInteractionHandler > m_xOrig;
 105
 106 public:
 107     InteractionHandlerProxy(
 108         const uno::Reference< task::XInteractionHandler > & xOrig )
 109     : m_xOrig( xOrig ) {}
 110
 111     // XInteractionHandler methods.
 112     virtual void SAL_CALL handle(
 113             const uno::Reference< task::XInteractionRequest >& Request )
 114         throw ( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 115 };
 116
 117
 118 // virtual
 119 void SAL_CALL InteractionHandlerProxy::handle(
 120             const uno::Reference< task::XInteractionRequest >& Request )
 121     throw ( uno::RuntimeException, std::exception )
 122 {
 123     if ( !m_xOrig.is() )
 124         return;
 125
 126     // Filter unwanted requests by just not handling them.
 127     uno::Any aRequest = Request->getRequest();
 128
 129     // "transfer"
 130     ucb::InteractiveBadTransferURLException aBadTransferURLEx;
 131     if ( aRequest >>= aBadTransferURLEx )
 132     {
 133         return;
 134     }
 135     else
 136     {
 137         // "transfer"
 138         ucb::UnsupportedNameClashException aUnsupportedNameClashEx;
 139         if ( aRequest >>= aUnsupportedNameClashEx )
 140         {
 141             if ( aUnsupportedNameClashEx.NameClash
 142                     != ucb::NameClash::ERROR )
 143                 return;
 144         }
 145         else
 146         {
 147             // "insert"
 148             ucb::NameClashException aNameClashEx;
 149             if ( aRequest >>= aNameClashEx )
 150             {
 151                 return;
 152             }
 153             else
 154             {
 155                 // "transfer"
 156                 ucb::UnsupportedCommandException aUnsupportedCommandEx;
 157                 if ( aRequest >>= aUnsupportedCommandEx )
 158                 {
 159                     return;
 160                 }
 161             }
 162         }
 163     }
 164
 165     // not filtered; let the original handler do the work.
 166     m_xOrig->handle( Request );
 167 }
 168
 169
 170
 171 // class ActiveDataSink.
 172
 173
 174
 175 class ActiveDataSink : public cppu::WeakImplHelper1< io::XActiveDataSink >
 176 {
 177     uno::Reference< io::XInputStream > m_xStream;
 178
 179 public:
 180     // XActiveDataSink methods.
 181     virtual void SAL_CALL setInputStream(
 182                         const uno::Reference< io::XInputStream >& aStream )
 183         throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 184     virtual uno::Reference< io::XInputStream > SAL_CALL getInputStream()
 185         throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 186 };
 187
 188
 189 // virtual
 190 void SAL_CALL ActiveDataSink::setInputStream(
 191                         const uno::Reference< io::XInputStream >& aStream )
 192     throw( uno::RuntimeException, std::exception )
 193 {
 194     m_xStream = aStream;
 195 }
 196
 197
 198 // virtual
 199 uno::Reference< io::XInputStream > SAL_CALL ActiveDataSink::getInputStream()
 200     throw( uno::RuntimeException, std::exception )
 201 {
 202     return m_xStream;
 203 }
 204
 205
 206
 207 // class CommandProcessorInfo.
 208
 209
 210
 211 class CommandProcessorInfo :
 212     public cppu::WeakImplHelper1< ucb::XCommandInfo >
 213 {
 214     uno::Sequence< ucb::CommandInfo > * m_pInfo;
 215
 216 public:
 217     CommandProcessorInfo();
 218     virtual ~CommandProcessorInfo();
 219
 220     // XCommandInfo methods
 221     virtual uno::Sequence< ucb::CommandInfo > SAL_CALL getCommands()
 222         throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 223     virtual ucb::CommandInfo SAL_CALL
 224     getCommandInfoByName( const OUString& Name )
 225         throw( ucb::UnsupportedCommandException, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 226     virtual ucb::CommandInfo SAL_CALL
 227     getCommandInfoByHandle( sal_Int32 Handle )
 228         throw( ucb::UnsupportedCommandException, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 229     virtual sal_Bool SAL_CALL hasCommandByName( const OUString& Name )
 230         throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 231     virtual sal_Bool SAL_CALL hasCommandByHandle( sal_Int32 Handle )
 232         throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 233 };
 234
 235
 236 CommandProcessorInfo::CommandProcessorInfo()
 237 {
 238     m_pInfo = new uno::Sequence< ucb::CommandInfo >( 2 );
 239
 240     (*m_pInfo)[ 0 ]
 241         = ucb::CommandInfo(
 242             OUString( GETCOMMANDINFO_NAME ), // Name
 243             GETCOMMANDINFO_HANDLE, // Handle
 244             getCppuVoidType() ); // ArgType
 245     (*m_pInfo)[ 1 ]
 246         = ucb::CommandInfo(
 247             OUString( GLOBALTRANSFER_NAME ), // Name
 248             GLOBALTRANSFER_HANDLE, // Handle
 249             cppu::UnoType<ucb::GlobalTransferCommandArgument>::get() ); // ArgType
 250     (*m_pInfo)[ 2 ]
 251         = ucb::CommandInfo(
 252             OUString( CHECKIN_NAME ), // Name
 253             CHECKIN_HANDLE, // Handle
 254             cppu::UnoType<ucb::CheckinArgument>::get() ); // ArgType
 255 }
 256
 257
 258 // virtual
 259 CommandProcessorInfo::~CommandProcessorInfo()
 260 {
 261     delete m_pInfo;
 262 }
 263
 264
 265 // virtual
 266 uno::Sequence< ucb::CommandInfo > SAL_CALL
 267 CommandProcessorInfo::getCommands()
 268     throw( uno::RuntimeException, std::exception )
 269 {
 270     return uno::Sequence< ucb::CommandInfo >( *m_pInfo );
 271 }
 272
 273
 274 // virtual
 275 ucb::CommandInfo SAL_CALL
 276 CommandProcessorInfo::getCommandInfoByName( const OUString& Name )
 277     throw( ucb::UnsupportedCommandException, uno::RuntimeException, std::exception )
 278 {
 279     for ( sal_Int32 n = 0; n < m_pInfo->getLength(); ++n )
 280     {
 281         if ( (*m_pInfo)[ n ].Name == Name )
 282             return ucb::CommandInfo( (*m_pInfo)[ n ] );
 283     }
 284
 285     throw ucb::UnsupportedCommandException();
 286 }
 287
 288
 289 // virtual
 290 ucb::CommandInfo SAL_CALL
 291 CommandProcessorInfo::getCommandInfoByHandle( sal_Int32 Handle )
 292     throw( ucb::UnsupportedCommandException, uno::RuntimeException, std::exception )
 293 {
 294     for ( sal_Int32 n = 0; n < m_pInfo->getLength(); ++n )
 295     {
 296         if ( (*m_pInfo)[ n ].Handle == Handle )
 297             return ucb::CommandInfo( (*m_pInfo)[ n ] );
 298     }
 299
 300     throw ucb::UnsupportedCommandException();
 301 }
 302
 303
 304 // virtual
 305 sal_Bool SAL_CALL CommandProcessorInfo::hasCommandByName(
 306                                                 const OUString& Name )
 307     throw( uno::RuntimeException, std::exception )
 308 {
 309     for ( sal_Int32 n = 0; n < m_pInfo->getLength(); ++n )
 310     {
 311         if ( (*m_pInfo)[ n ].Name == Name )
 312             return sal_True;
 313     }
 314
 315     return sal_False;
 316 }
 317
 318
 319 // virtual
 320 sal_Bool SAL_CALL CommandProcessorInfo::hasCommandByHandle( sal_Int32 Handle )
 321     throw( uno::RuntimeException, std::exception )
 322 {
 323     for ( sal_Int32 n = 0; n < m_pInfo->getLength(); ++n )
 324     {
 325         if ( (*m_pInfo)[ n ].Handle == Handle )
 326             return sal_True;
 327     }
 328
 329     return sal_False;
 330 }
 331
 332
 333
 334
 335
 336 OUString createDesiredName(
 337     const OUString & rSourceURL, const OUString & rNewTitle )
 338 {
 339     OUString aName( rNewTitle );
 340     if ( aName.isEmpty() )
 341     {
 342         // calculate name using source URL
 343
 344         // @@@ It's not guaranteed that slashes contained in the URL are
 345         // actually path separators. This depends on the fact whether the
 346         // URL is hierarchical. Only then the slashes are path separators.
 347         // Therefore this algorithm is not guaranteed to work! But, ATM
 348         // I don't know a better solution. It would have been better to
 349         // have a member for the clashing name in
 350         // UnsupportedNameClashException...
 351
 352         sal_Int32 nLastSlash = rSourceURL.lastIndexOf( '/' );
 353         bool bTrailingSlash = false;
 354         if ( nLastSlash == rSourceURL.getLength() - 1 )
 355         {
 356             nLastSlash = rSourceURL.lastIndexOf( '/', nLastSlash );
 357             bTrailingSlash = true;
 358         }
 359
 360         if ( nLastSlash != -1 )
 361         {
 362             if ( bTrailingSlash )
 363                 aName = rSourceURL.copy(
 364                             nLastSlash + 1,
 365                             rSourceURL.getLength() - nLastSlash - 2 );
 366             else
 367                 aName = rSourceURL.copy( nLastSlash + 1 );
 368         }
 369         else
 370         {
 371             aName = rSourceURL;
 372         }
 373
 374         // query, fragment present?
 375     sal_Int32  nPos = aName.indexOf( '?' );
 376     if ( nPos == -1 )
 377       nPos = aName.indexOf( '#' );
 378
 379     if ( nPos != -1 )
 380       aName = aName.copy( 0, nPos );
 381     }
 382     return OUString( aName );
 383 }
 384
 385 OUString createDesiredName(
 386     const ucb::GlobalTransferCommandArgument & rArg )
 387 {
 388     return createDesiredName( rArg.SourceURL, rArg.NewTitle );
 389 }
 390
 391 OUString createDesiredName(
 392     const ucb::TransferInfo & rArg )
 393 {
 394     return createDesiredName( rArg.SourceURL, rArg.NewTitle );
 395 }
 396
 397
 398 enum NameClashContinuation { NOT_HANDLED, ABORT, OVERWRITE, NEW_NAME, UNKNOWN };
 399
 400 NameClashContinuation interactiveNameClashResolve(
 401     const uno::Reference< ucb::XCommandEnvironment > & xEnv,
 402     const OUString & rTargetURL,
 403     const OUString & rClashingName,
 404     /* [out] */ uno::Any & rException,
 405     /* [out] */ OUString & rNewName )
 406 {
 407     rtl::Reference< ucbhelper::SimpleNameClashResolveRequest > xRequest(
 408         new ucbhelper::SimpleNameClashResolveRequest(
 409             rTargetURL,  // target folder URL
 410             rClashingName,   // clashing name
 411             OUString(), // no proposal for new name
 412             true /* bSupportsOverwriteData */ ) );
 413
 414     rException = xRequest->getRequest();
 415     if ( xEnv.is() )
 416     {
 417         uno::Reference< task::XInteractionHandler > xIH
 418             = xEnv->getInteractionHandler();
 419         if ( xIH.is() )
 420         {
 421
 422             xIH->handle( xRequest.get() );
 423
 424             rtl::Reference< ucbhelper::InteractionContinuation >
 425                 xSelection( xRequest->getSelection() );
 426
 427             if ( xSelection.is() )
 428             {
 429                 // Handler handled the request.
 430                 uno::Reference< task::XInteractionAbort > xAbort(
 431                     xSelection.get(), uno::UNO_QUERY );
 432                 if ( xAbort.is() )
 433                 {
 434                     // Abort.
 435                     return ABORT;
 436                 }
 437                 else
 438                 {
 439                     uno::Reference<
 440                         ucb::XInteractionReplaceExistingData >
 441                             xReplace(
 442                                 xSelection.get(), uno::UNO_QUERY );
 443                     if ( xReplace.is() )
 444                     {
 445                         // Try again: Replace existing data.
 446                         return OVERWRITE;
 447                     }
 448                     else
 449                     {
 450                         uno::Reference<
 451                             ucb::XInteractionSupplyName >
 452                                 xSupplyName(
 453                                     xSelection.get(), uno::UNO_QUERY );
 454                         if ( xSupplyName.is() )
 455                         {
 456                             // Try again: Use new name.
 457                             rNewName = xRequest->getNewName();
 458                             return NEW_NAME;
 459                         }
 460                         else
 461                         {
 462                             OSL_FAIL( "Unknown interaction continuation!" );
 463                             return UNKNOWN;
 464                         }
 465                     }
 466                 }
 467             }
 468         }
 469     }
 470     return NOT_HANDLED;
 471 }
 472
 473
 474 bool setTitle(
 475         const uno::Reference< ucb::XCommandProcessor > & xCommandProcessor,
 476         const uno::Reference< ucb::XCommandEnvironment > & xEnv,
 477         const OUString & rNewTitle )
 478     throw( uno::RuntimeException )
 479 {
 480     try
 481     {
 482         uno::Sequence< beans::PropertyValue > aPropValues( 1 );
 483         aPropValues[ 0 ].Name = "Title";
 484         aPropValues[ 0 ].Handle = -1;
 485         aPropValues[ 0 ].Value  = uno::makeAny( rNewTitle );
 486
 487         ucb::Command aSetPropsCommand(
 488             OUString(  "setPropertyValues"  ),
 489             -1,
 490             uno::makeAny( aPropValues ) );
 491
 492         uno::Any aResult
 493             = xCommandProcessor->execute( aSetPropsCommand, 0, xEnv );
 494
 495         uno::Sequence< uno::Any > aErrors;
 496         aResult >>= aErrors;
 497
 498         OSL_ENSURE( aErrors.getLength() == 1,
 499                     "getPropertyValues return value invalid!" );
 500
 501         if ( aErrors[ 0 ].hasValue() )
 502         {
 503             // error occurred.
 504             OSL_FAIL( "error setting Title property!" );
 505             return false;
 506         }
 507     }
 508     catch ( uno::RuntimeException const & )
 509     {
 510         throw;
 511     }
 512     catch ( uno::Exception const & )
 513     {
 514         return false;
 515     }
 516
 517     return true;
 518 }
 519
 520
 521 uno::Reference< ucb::XContent > createNew(
 522                     const TransferCommandContext & rContext,
 523                     const uno::Reference< ucb::XContent > & xTarget,
 524                     bool bSourceIsFolder,
 525                     bool bSourceIsDocument,
 526                     bool bSourceIsLink )
 527     throw( uno::Exception )
 528 {
 529
 530
 531     // (1) Obtain creatable types from target.
 532
 533
 534
 535     // First, try it using "CreatabeleContentsInfo" property and
 536     // "createNewContent" command -> the "new" way.
 537
 538     uno::Reference< ucb::XCommandProcessor > xCommandProcessorT(
 539                                                     xTarget, uno::UNO_QUERY );
 540     if ( !xCommandProcessorT.is() )
 541     {
 542         uno::Any aProps
 543             = uno::makeAny(beans::PropertyValue(
 544                                   OUString( "Folder"),
 545                                   -1,
 546                                   uno::makeAny(rContext.aArg.TargetURL),
 547                                   beans::PropertyState_DIRECT_VALUE));
 548         ucbhelper::cancelCommandExecution(
 549             ucb::IOErrorCode_CANT_CREATE,
 550             uno::Sequence< uno::Any >(&aProps, 1),
 551             rContext.xOrigEnv,
 552             OUString("Target is no XCommandProcessor!"),
 553             rContext.xProcessor );
 554         // Unreachable
 555     }
 556
 557     uno::Sequence< beans::Property > aPropsToObtain( 1 );
 558     aPropsToObtain[ 0 ].Name = "CreatableContentsInfo";
 559     aPropsToObtain[ 0 ].Handle = -1;
 560
 561     ucb::Command aGetPropsCommand(
 562             OUString("getPropertyValues"),
 563             -1,
 564             uno::makeAny( aPropsToObtain ) );
 565
 566     uno::Reference< sdbc::XRow > xRow;
 567     xCommandProcessorT->execute( aGetPropsCommand, 0, rContext.xEnv )  >>= xRow;
 568
 569     uno::Sequence< ucb::ContentInfo > aTypesInfo;
 570     bool bGotTypesInfo = false;
 571
 572     if ( xRow.is() )
 573     {
 574         uno::Any  aValue = xRow->getObject(
 575             1, uno::Reference< container::XNameAccess >() );
 576         if ( aValue.hasValue() && ( aValue >>= aTypesInfo ) )
 577         {
 578             bGotTypesInfo = true;
 579         }
 580     }
 581
 582     uno::Reference< ucb::XContentCreator > xCreator;
 583
 584     if ( !bGotTypesInfo )
 585     {
 586         // Second, try it using XContentCreator interface -> the "old" way (not
 587         // providing the chance to supply an XCommandEnvironment.
 588
 589         xCreator.set( xTarget, uno::UNO_QUERY );
 590
 591         if ( !xCreator.is() )
 592         {
 593             uno::Any aProps
 594                 = uno::makeAny(beans::PropertyValue(
 595                                   OUString( "Folder"),
 596                                   -1,
 597                                   uno::makeAny(rContext.aArg.TargetURL),
 598                                   beans::PropertyState_DIRECT_VALUE));
 599             ucbhelper::cancelCommandExecution(
 600                 ucb::IOErrorCode_CANT_CREATE,
 601                 uno::Sequence< uno::Any >(&aProps, 1),
 602                 rContext.xOrigEnv,
 603                 OUString("Target is no XContentCreator!"),
 604                 rContext.xProcessor );
 605             // Unreachable
 606         }
 607
 608         aTypesInfo  = xCreator->queryCreatableContentsInfo();
 609     }
 610
 611     sal_Int32 nCount = aTypesInfo.getLength();
 612     if ( !nCount )
 613     {
 614         uno::Any aProps
 615             = uno::makeAny(beans::PropertyValue(
 616                               OUString("Folder"),
 617                               -1,
 618                               uno::makeAny(rContext.aArg.TargetURL),
 619                               beans::PropertyState_DIRECT_VALUE));
 620         ucbhelper::cancelCommandExecution(
 621             ucb::IOErrorCode_CANT_CREATE,
 622             uno::Sequence< uno::Any >(&aProps, 1),
 623             rContext.xOrigEnv,
 624             OUString("No types creatable!"),
 625             rContext.xProcessor );
 626         // Unreachable
 627     }
 628
 629
 630
 631     // (2) Try to find a matching target type for the source object.
 632
 633
 634
 635     uno::Reference< ucb::XContent > xNew;
 636     for ( sal_Int32 n = 0; n < nCount; ++n )
 637     {
 638         sal_Int32 nAttribs = aTypesInfo[ n ].Attributes;
 639         bool  bMatch   = false;
 640
 641         if ( rContext.aArg.Operation == ucb::TransferCommandOperation_LINK )
 642         {
 643             // Create link
 644
 645             if ( nAttribs & ucb::ContentInfoAttribute::KIND_LINK )
 646             {
 647                 // Match!
 648                 bMatch = true;
 649             }
 650         }
 651         else if ( ( rContext.aArg.Operation
 652                         == ucb::TransferCommandOperation_COPY ) ||
 653                   ( rContext.aArg.Operation
 654                         == ucb::TransferCommandOperation_MOVE ) )
 655         {
 656             // Copy / Move
 657
 658             // Is source a link? Create link in target folder then.
 659             if ( bSourceIsLink )
 660             {
 661                 if ( nAttribs & ucb::ContentInfoAttribute::KIND_LINK )
 662                 {
 663                     // Match!
 664                     bMatch = true;
 665                 }
 666             }
 667             else
 668             {
 669                 // (not a and not b) or (a and b)
 670                 // not( a or b) or (a and b)
 671
 672                 if ( ( !!bSourceIsFolder ==
 673                         !!( nAttribs
 674                             & ucb::ContentInfoAttribute::KIND_FOLDER ) )
 675                      &&
 676                      ( !!bSourceIsDocument ==
 677                         !!( nAttribs
 678                             & ucb::ContentInfoAttribute::KIND_DOCUMENT ) )
 679                    )
 680                 {
 681                     // Match!
 682                     bMatch = true;
 683                 }
 684             }
 685         }
 686         else
 687         {
 688             ucbhelper::cancelCommandExecution(
 689                 uno::makeAny( lang::IllegalArgumentException(
 690                                         OUString( "Unknown transfer operation!" ),
 691                                         rContext.xProcessor,
 692                                         -1 ) ),
 693                               rContext.xOrigEnv );
 694             // Unreachable
 695         }
 696
 697         if ( bMatch )
 698         {
 699
 700
 701             // (3) Create a new, empty object of matched type.
 702
 703
 704
 705             if ( !xCreator.is() )
 706             {
 707                 // First, try it using "CreatabeleContentsInfo" property and
 708                 // "createNewContent" command -> the "new" way.
 709                 ucb::Command aCreateNewCommand(
 710                    OUString("createNewContent"),
 711                    -1,
 712                    uno::makeAny( aTypesInfo[ n ] ) );
 713
 714                 xCommandProcessorT->execute( aCreateNewCommand, 0, rContext.xEnv )
 715                     >>= xNew;
 716             }
 717             else
 718             {
 719                 // Second, try it using XContentCreator interface -> the "old"
 720                 // way (not providing the chance to supply an XCommandEnvironment.
 721
 722                 xNew = xCreator->createNewContent( aTypesInfo[ n ] );
 723             }
 724
 725             if ( !xNew.is() )
 726             {
 727                 uno::Any aProps
 728                     = uno::makeAny(
 729                              beans::PropertyValue(
 730                                  OUString( "Folder"),
 731                                  -1,
 732                                  uno::makeAny(rContext.aArg.TargetURL),
 733                                  beans::PropertyState_DIRECT_VALUE));
 734                 ucbhelper::cancelCommandExecution(
 735                     ucb::IOErrorCode_CANT_CREATE,
 736                     uno::Sequence< uno::Any >(&aProps, 1),
 737                     rContext.xOrigEnv,
 738                     OUString( "createNewContent failed!" ),
 739                     rContext.xProcessor );
 740                 // Unreachable
 741             }
 742             break; // escape from 'for' loop
 743         }
 744     } // for
 745
 746     return xNew;
 747 }
 748
 749
 750 void transferProperties(
 751     const TransferCommandContext & rContext,
 752     const uno::Reference< ucb::XCommandProcessor > & xCommandProcessorS,
 753     const uno::Reference< ucb::XCommandProcessor > & xCommandProcessorN )
 754         throw( uno::Exception )
 755 {
 756     ucb::Command aGetPropertySetInfoCommand(
 757                 OUString("getPropertySetInfo"),
 758                 -1,
 759                 uno::Any() );
 760
 761     uno::Reference< beans::XPropertySetInfo > xInfo;
 762     xCommandProcessorS->execute( aGetPropertySetInfoCommand, 0, rContext.xEnv )
 763         >>= xInfo;
 764
 765     if ( !xInfo.is() )
 766     {
 767         uno::Any aProps
 768             = uno::makeAny(beans::PropertyValue(
 769                                   OUString( "Uri"),
 770                                   -1,
 771                                   uno::makeAny(rContext.aArg.SourceURL),
 772                                   beans::PropertyState_DIRECT_VALUE));
 773         ucbhelper::cancelCommandExecution(
 774             ucb::IOErrorCode_CANT_READ,
 775             uno::Sequence< uno::Any >(&aProps, 1),
 776             rContext.xOrigEnv,
 777             OUString( "Unable to get propertyset info from source object!" ),
 778             rContext.xProcessor );
 779         // Unreachable
 780     }
 781
 782     uno::Sequence< beans::Property > aAllProps = xInfo->getProperties();
 783
 784     ucb::Command aGetPropsCommand1(
 785                 OUString("getPropertyValues"),
 786                 -1,
 787                 uno::makeAny( aAllProps ) );
 788
 789     uno::Reference< sdbc::XRow > xRow1;
 790     xCommandProcessorS->execute(
 791         aGetPropsCommand1, 0, rContext.xEnv ) >>= xRow1;
 792
 793     if ( !xRow1.is() )
 794     {
 795         uno::Any aProps
 796             = uno::makeAny(beans::PropertyValue(
 797                                   OUString( "Uri"),
 798                                   -1,
 799                                   uno::makeAny(rContext.aArg.SourceURL),
 800                                   beans::PropertyState_DIRECT_VALUE));
 801         ucbhelper::cancelCommandExecution(
 802             ucb::IOErrorCode_CANT_READ,
 803             uno::Sequence< uno::Any >(&aProps, 1),
 804             rContext.xOrigEnv,
 805             OUString( "Unable to get properties from source object!" ),
 806             rContext.xProcessor );
 807         // Unreachable
 808     }
 809
 810     // Assemble data structure for setPropertyValues command.
 811
 812     // Note: Make room for additional Title and TargetURL too. -> + 2
 813     uno::Sequence< beans::PropertyValue > aPropValues(
 814                                                 aAllProps.getLength() + 2 );
 815
 816     bool bHasTitle = rContext.aArg.NewTitle.isEmpty();
 817     bool bHasTargetURL = ( rContext.aArg.Operation
 818                                 != ucb::TransferCommandOperation_LINK );
 819
 820     sal_Int32 nWritePos = 0;
 821     for ( sal_Int32 m = 0; m < aAllProps.getLength(); ++m )
 822     {
 823         const beans::Property & rCurrProp = aAllProps[ m ];
 824         beans::PropertyValue & rCurrValue = aPropValues[ nWritePos ];
 825
 826         uno::Any aValue;
 827
 828         if ( rCurrProp.Name.equalsAscii( "Title" ) )
 829         {
 830             // Supply new title, if given.
 831             if ( !bHasTitle )
 832             {
 833                 bHasTitle = true;
 834                 aValue <<= rContext.aArg.NewTitle;
 835             }
 836         }
 837         else if ( rCurrProp.Name.equalsAscii( "TargetURL" ) )
 838         {
 839             // Supply source URL as link target for the new link to create.
 840             if ( !bHasTargetURL )
 841             {
 842                 bHasTargetURL = true;
 843                 aValue <<= rContext.aArg.SourceURL;
 844             }
 845         }
 846
 847         if ( !aValue.hasValue() )
 848         {
 849             try
 850             {
 851                 aValue = xRow1->getObject(
 852                             m + 1, uno::Reference< container::XNameAccess >() );
 853             }
 854             catch ( sdbc::SQLException const & )
 855             {
 856                 // Argh! But try to bring things to an end. Perhaps the
 857                 // mad property is not really important...
 858             }
 859         }
 860
 861         if ( aValue.hasValue() )
 862         {
 863             rCurrValue.Name   = rCurrProp.Name;
 864             rCurrValue.Handle = rCurrProp.Handle;
 865             rCurrValue.Value  = aValue;
 866 //          rCurrValue.State  =
 867
 868             nWritePos++;
 869         }
 870     }
 871
 872     // Title needed, but not set yet?
 873     if ( !bHasTitle && !rContext.aArg.NewTitle.isEmpty() )
 874     {
 875         aPropValues[ nWritePos ].Name = "Title";
 876         aPropValues[ nWritePos ].Handle = -1;
 877         aPropValues[ nWritePos ].Value <<= rContext.aArg.NewTitle;
 878
 879         nWritePos++;
 880     }
 881
 882     // TargetURL needed, but not set yet?
 883     if ( !bHasTargetURL && ( rContext.aArg.Operation
 884                                 == ucb::TransferCommandOperation_LINK ) )
 885     {
 886         aPropValues[ nWritePos ].Name = "TargetURL";
 887         aPropValues[ nWritePos ].Handle = -1;
 888         aPropValues[ nWritePos ].Value <<= rContext.aArg.SourceURL;
 889
 890         nWritePos++;
 891     }
 892
 893     aPropValues.realloc( nWritePos );
 894
 895     // Set properties at new object.
 896
 897     ucb::Command aSetPropsCommand(
 898                 OUString("setPropertyValues"),
 899                 -1,
 900                 uno::makeAny( aPropValues ) );
 901
 902     xCommandProcessorN->execute( aSetPropsCommand, 0, rContext.xEnv );
 903
 904     // @@@ What to do with source props that are not supported by the
 905     //     new object? addProperty ???
 906 }
 907
 908
 909 uno::Reference< io::XInputStream > getInputStream(
 910     const TransferCommandContext & rContext,
 911     const uno::Reference< ucb::XCommandProcessor > & xCommandProcessorS )
 912         throw( uno::Exception )
 913 {
 914     uno::Reference< io::XInputStream > xInputStream;
 915
 916
 917
 918     // (1) Try to get data as XInputStream via XActiveDataSink.
 919
 920
 921
 922     try
 923     {
 924         uno::Reference< io::XActiveDataSink > xSink = new ActiveDataSink;
 925
 926         ucb::OpenCommandArgument2 aArg;
 927         aArg.Mode       = ucb::OpenMode::DOCUMENT;
 928         aArg.Priority   = 0; // unused
 929         aArg.Sink       = xSink;
 930         aArg.Properties = uno::Sequence< beans::Property >( 0 ); // unused
 931
 932         ucb::Command aOpenCommand(
 933                                 OUString("open"),
 934                                 -1,
 935                                 uno::makeAny( aArg ) );
 936
 937         xCommandProcessorS->execute( aOpenCommand, 0, rContext.xEnv );
 938         xInputStream = xSink->getInputStream();
 939     }
 940     catch ( uno::RuntimeException const & )
 941     {
 942         throw;
 943     }
 944     catch ( uno::Exception const & )
 945     {
 946         // will be handled below.
 947     }
 948
 949     if ( !xInputStream.is() )
 950     {
 951
 952
 953         // (2) Try to get data via XOutputStream.
 954
 955
 956
 957         try
 958         {
 959             uno::Reference< io::XOutputStream > xOutputStream( io::Pipe::create(rContext.m_xContext), uno::UNO_QUERY_THROW );
 960
 961             ucb::OpenCommandArgument2 aArg;
 962             aArg.Mode       = ucb::OpenMode::DOCUMENT;
 963             aArg.Priority   = 0; // unused
 964             aArg.Sink       = xOutputStream;
 965             aArg.Properties = uno::Sequence< beans::Property >( 0 );
 966
 967             ucb::Command aOpenCommand(
 968                                 OUString("open"),
 969                                 -1,
 970                                 uno::makeAny( aArg ) );
 971
 972             xCommandProcessorS->execute( aOpenCommand, 0, rContext.xEnv );
 973
 974             xInputStream = uno::Reference< io::XInputStream >(
 975                                     xOutputStream, uno::UNO_QUERY );
 976         }
 977         catch ( uno::RuntimeException const & )
 978         {
 979             throw;
 980         }
 981         catch ( uno::Exception const & )
 982         {
 983             OSL_FAIL( "unable to get input stream from document!" );
 984         }
 985     }
 986
 987     return xInputStream;
 988 }
 989
 990
 991 uno::Reference< sdbc::XResultSet > getResultSet(
 992     const TransferCommandContext & rContext,
 993     const uno::Reference< ucb::XCommandProcessor > & xCommandProcessorS )
 994         throw( uno::Exception )
 995 {
 996     uno::Reference< sdbc::XResultSet > xResultSet;
 997
 998     uno::Sequence< beans::Property > aProps( 3 );
 999
1000     aProps[ 0 ].Name   = "IsFolder";
1001     aProps[ 0 ].Handle = -1; /* unknown */
1002     aProps[ 1 ].Name   = "IsDocument";
1003     aProps[ 1 ].Handle = -1; /* unknown */
1004     aProps[ 2 ].Name   = "TargetURL";
1005     aProps[ 2 ].Handle = -1; /* unknown */
1006
1007     ucb::OpenCommandArgument2 aArg;
1008     aArg.Mode       = ucb::OpenMode::ALL;
1009     aArg.Priority   = 0; // unused
1010     aArg.Sink       = 0;
1011     aArg.Properties = aProps;
1012
1013     ucb::Command aOpenCommand( OUString("open"),
1014                                      -1,
1015                                      uno::makeAny( aArg ) );
1016     try
1017     {
1018         uno::Reference< ucb::XDynamicResultSet > xSet;
1019         xCommandProcessorS->execute( aOpenCommand, 0, rContext.xEnv ) >>= xSet;
1020
1021         if ( xSet.is() )
1022             xResultSet = xSet->getStaticResultSet();
1023     }
1024     catch ( uno::RuntimeException const & )
1025     {
1026         throw;
1027     }
1028     catch ( uno::Exception const & )
1029     {
1030          OSL_FAIL( "unable to get result set from folder!" );
1031     }
1032
1033     return xResultSet;
1034 }
1035
1036
1037 void handleNameClashRename(
1038         const TransferCommandContext & rContext,
1039         const uno::Reference< ucb::XContent > & xNew,
1040         const uno::Reference<
1041             ucb::XCommandProcessor > & xCommandProcessorN,
1042         const uno::Reference<
1043             ucb::XCommandProcessor > & xCommandProcessorS,
1044         /* [inout] */ uno::Reference< io::XInputStream > & xInputStream )
1045     throw( uno::Exception )
1046 {
1047     sal_Int32 nTry = 0;
1048
1049     // Obtain old title.
1050     uno::Sequence< beans::Property > aProps( 1 );
1051     aProps[ 0 ].Name   = "Title";
1052     aProps[ 0 ].Handle = -1;
1053
1054     ucb::Command aGetPropsCommand(
1055             OUString("getPropertyValues"),
1056             -1,
1057             uno::makeAny( aProps ) );
1058
1059     uno::Reference< sdbc::XRow > xRow;
1060     xCommandProcessorN->execute( aGetPropsCommand, 0, rContext.xEnv )  >>= xRow;
1061
1062     if ( !xRow.is() )
1063     {
1064         uno::Any aProps2
1065             = uno::makeAny(
1066                      beans::PropertyValue(
1067                          OUString(  "Uri"  ),
1068                          -1,
1069                          uno::makeAny(
1070                              xNew->getIdentifier()->getContentIdentifier() ),
1071                          beans::PropertyState_DIRECT_VALUE ) );
1072         ucbhelper::cancelCommandExecution(
1073             ucb::IOErrorCode_CANT_READ,
1074             uno::Sequence< uno::Any >( &aProps2, 1 ),
1075             rContext.xOrigEnv,
1076             OUString( "Unable to get properties from new object!" ),
1077             rContext.xProcessor );
1078         // Unreachable
1079     }
1080
1081     OUString aOldTitle = xRow->getString( 1 );
1082     if ( aOldTitle.isEmpty() )
1083     {
1084         ucbhelper::cancelCommandExecution(
1085             uno::makeAny( beans::UnknownPropertyException(
1086                             OUString( "Unable to get property 'Title' from new object!" ),
1087                             rContext.xProcessor ) ),
1088             rContext.xOrigEnv );
1089         // Unreachable
1090     }
1091
1092     // Some pseudo-intelligence for not destroying file extensions.
1093     OUString aOldTitlePre;
1094     OUString aOldTitlePost;
1095     sal_Int32 nPos = aOldTitle.lastIndexOf( '.' );
1096     if ( nPos != -1 )
1097     {
1098         aOldTitlePre = aOldTitle.copy( 0, nPos );
1099         aOldTitlePost = aOldTitle.copy( nPos );
1100     }
1101     else
1102         aOldTitlePre = aOldTitle;
1103
1104     if ( nPos > 0 )
1105         aOldTitlePre += "_";
1106
1107     bool bContinue = true;
1108     do
1109     {
1110         nTry++;
1111
1112         OUString aNewTitle = aOldTitlePre;
1113         aNewTitle += OUString::number( nTry );
1114         aNewTitle += aOldTitlePost;
1115
1116         // Set new title
1117         setTitle( xCommandProcessorN, rContext.xEnv, aNewTitle );
1118
1119         // Retry inserting the content.
1120         try
1121         {
1122             // Previous try may have read from stream. Seek to begin (if
1123             // optional interface XSeekable is supported) or get a new stream.
1124             if ( xInputStream.is() )
1125             {
1126                 uno::Reference< io::XSeekable > xSeekable(
1127                     xInputStream, uno::UNO_QUERY );
1128                 if ( xSeekable.is() )
1129                 {
1130                     try
1131                     {
1132                         xSeekable->seek( 0 );
1133                     }
1134                     catch ( lang::IllegalArgumentException const & )
1135                     {
1136                         xInputStream.clear();
1137                     }
1138                     catch ( io::IOException const & )
1139                     {
1140                         xInputStream.clear();
1141                     }
1142                 }
1143                 else
1144                     xInputStream.clear();
1145
1146                 if ( !xInputStream.is() )
1147                 {
1148                     xInputStream
1149                         = getInputStream( rContext, xCommandProcessorS );
1150                     if ( !xInputStream.is() )
1151                     {
1152                         uno::Any aProps2
1153                             = uno::makeAny(
1154                                 beans::PropertyValue(
1155                                     OUString( "Uri"  ),
1156                                     -1,
1157                                     uno::makeAny(
1158                                         xNew->getIdentifier()->
1159                                             getContentIdentifier() ),
1160                                     beans::PropertyState_DIRECT_VALUE ) );
1161                         ucbhelper::cancelCommandExecution(
1162                             ucb::IOErrorCode_CANT_READ,
1163                             uno::Sequence< uno::Any >( &aProps2, 1 ),
1164                             rContext.xOrigEnv,
1165                             OUString( "Got no data stream from source!" ),
1166                             rContext.xProcessor );
1167                         // Unreachable
1168                     }
1169                 }
1170             }
1171
1172             ucb::InsertCommandArgument2 aArg;
1173             aArg.Data = xInputStream;
1174             aArg.ReplaceExisting = sal_False;
1175
1176             ucb::Command aInsertCommand(
1177                         OUString("insert"),
1178                         -1,
1179                         uno::makeAny( aArg ) );
1180
1181             xCommandProcessorN->execute( aInsertCommand, 0, rContext.xEnv );
1182
1183             // Success!
1184             bContinue = false;
1185         }
1186         catch ( uno::RuntimeException const & )
1187         {
1188             throw;
1189         }
1190         catch ( uno::Exception const & )
1191         {
1192         }
1193     }
1194     while ( bContinue && ( nTry < 50 ) );
1195
1196     if ( nTry == 50 )
1197     {
1198         ucbhelper::cancelCommandExecution(
1199             uno::makeAny(
1200                 ucb::UnsupportedNameClashException(
1201                     OUString( "Unable to resolve name clash!" ),
1202                     rContext.xProcessor,
1203                     ucb::NameClash::RENAME ) ),
1204             rContext.xOrigEnv );
1205         // Unreachable
1206     }
1207 }
1208
1209
1210 void globalTransfer_(
1211         const TransferCommandContext & rContext,
1212         const uno::Reference< ucb::XContent > & xSource,
1213         const uno::Reference< ucb::XContent > & xTarget,
1214         const uno::Reference< sdbc::XRow > & xSourceProps )
1215     throw( uno::Exception )
1216 {
1217     // IsFolder: property is required.
1218     bool bSourceIsFolder = xSourceProps->getBoolean( 1 );
1219     if ( !bSourceIsFolder && xSourceProps->wasNull() )
1220     {
1221         ucbhelper::cancelCommandExecution(
1222             uno::makeAny( beans::UnknownPropertyException(
1223                             OUString( "Unable to get property 'IsFolder' "
1224                                 "from source object!" ),
1225                             rContext.xProcessor ) ),
1226             rContext.xOrigEnv );
1227         // Unreachable
1228     }
1229
1230     // IsDocument: property is required.
1231     bool bSourceIsDocument = xSourceProps->getBoolean( 2 );
1232     if ( !bSourceIsDocument && xSourceProps->wasNull() )
1233     {
1234         ucbhelper::cancelCommandExecution(
1235             uno::makeAny( beans::UnknownPropertyException(
1236                             OUString( "Unable to get property 'IsDocument' "
1237                                 "from source object!" ),
1238                             rContext.xProcessor ) ),
1239             rContext.xOrigEnv );
1240         // Unreachable
1241     }
1242
1243     // TargetURL: property is optional.
1244     bool bSourceIsLink = !xSourceProps->getString( 3 ).isEmpty();
1245
1246
1247
1248     // (1) Try to find a matching target type for the source object and
1249     //     create a new, empty object of that type.
1250
1251
1252
1253     uno::Reference< ucb::XContent > xNew = createNew( rContext,
1254                                                       xTarget,
1255                                                       bSourceIsFolder,
1256                                                       bSourceIsDocument,
1257                                                       bSourceIsLink );
1258     if ( !xNew.is() )
1259     {
1260         uno::Any aProps
1261             = uno::makeAny(beans::PropertyValue(
1262                                   OUString( "Folder"),
1263                                   -1,
1264                                   uno::makeAny(rContext.aArg.TargetURL),
1265                                   beans::PropertyState_DIRECT_VALUE));
1266         ucbhelper::cancelCommandExecution(
1267             ucb::IOErrorCode_CANT_CREATE,
1268             uno::Sequence< uno::Any >(&aProps, 1),
1269             rContext.xOrigEnv,
1270             OUString( "No matching content type at target!" ),
1271             rContext.xProcessor );
1272         // Unreachable
1273     }
1274
1275
1276
1277     // (2) Transfer property values from source to new object.
1278
1279
1280
1281     uno::Reference< ucb::XCommandProcessor > xCommandProcessorN(
1282                                                     xNew, uno::UNO_QUERY );
1283     if ( !xCommandProcessorN.is() )
1284     {
1285         uno::Any aProps
1286             = uno::makeAny(beans::PropertyValue(
1287                                   OUString( "Uri"),
1288                                   -1,
1289                                   uno::makeAny(
1290                                       xNew->getIdentifier()->
1291                                                 getContentIdentifier()),
1292                                   beans::PropertyState_DIRECT_VALUE));
1293         ucbhelper::cancelCommandExecution(
1294             ucb::IOErrorCode_CANT_WRITE,
1295             uno::Sequence< uno::Any >(&aProps, 1),
1296             rContext.xOrigEnv,
1297             OUString( "New content is not a XCommandProcessor!" ),
1298             rContext.xProcessor );
1299         // Unreachable
1300     }
1301
1302     // Obtain all properties from source.
1303
1304     uno::Reference< ucb::XCommandProcessor > xCommandProcessorS(
1305                                                     xSource, uno::UNO_QUERY );
1306     if ( !xCommandProcessorS.is() )
1307     {
1308         uno::Any aProps
1309             = uno::makeAny(beans::PropertyValue(
1310                                   OUString( "Uri"),
1311                                   -1,
1312                                   uno::makeAny(rContext.aArg.SourceURL),
1313                                   beans::PropertyState_DIRECT_VALUE));
1314         ucbhelper::cancelCommandExecution(
1315             ucb::IOErrorCode_CANT_READ,
1316             uno::Sequence< uno::Any >(&aProps, 1),
1317             rContext.xOrigEnv,
1318             OUString( "Source content is not a XCommandProcessor!" ),
1319             rContext.xProcessor );
1320         // Unreachable
1321     }
1322
1323     transferProperties( rContext, xCommandProcessorS, xCommandProcessorN );
1324
1325
1326
1327     // (3) Try to obtain a data stream from source.
1328
1329
1330
1331     uno::Reference< io::XInputStream > xInputStream;
1332
1333     if ( bSourceIsDocument && ( rContext.aArg.Operation
1334                                 != ucb::TransferCommandOperation_LINK ) )
1335         xInputStream = getInputStream( rContext, xCommandProcessorS );
1336
1337
1338
1339     // (4) Try to obtain a resultset (children) from source.
1340
1341
1342
1343     uno::Reference< sdbc::XResultSet > xResultSet;
1344
1345     if ( bSourceIsFolder && ( rContext.aArg.Operation
1346                                 != ucb::TransferCommandOperation_LINK ) )
1347         xResultSet = getResultSet( rContext, xCommandProcessorS );
1348
1349
1350
1351     // (5) Insert (store) new content.
1352
1353
1354
1355     ucb::InsertCommandArgument2 aArg;
1356     aArg.Data = xInputStream;
1357     aArg.MimeType = rContext.aArg.MimeType;
1358     aArg.DocumentId = rContext.aArg.DocumentId;
1359
1360     switch ( rContext.aArg.NameClash )
1361     {
1362         case ucb::NameClash::OVERWRITE:
1363             aArg.ReplaceExisting = sal_True;
1364             break;
1365
1366         case ucb::NameClash::ERROR:
1367         case ucb::NameClash::RENAME:
1368         case ucb::NameClash::KEEP: // deprecated
1369         case ucb::NameClash::ASK:
1370             aArg.ReplaceExisting = sal_False;
1371             break;
1372
1373         default:
1374             aArg.ReplaceExisting = sal_False;
1375             OSL_FAIL( "Unknown nameclash directive!" );
1376             break;
1377     }
1378
1379     OUString aDesiredName = createDesiredName( rContext.aArg );
1380
1381     bool bRetry;
1382     do
1383     {
1384         bRetry = false;
1385
1386         try
1387         {
1388             ucb::Command aInsertCommand(
1389                                     OUString("insert"),
1390                                     -1,
1391                                     uno::makeAny( aArg ) );
1392
1393             xCommandProcessorN->execute( aInsertCommand, 0, rContext.xEnv );
1394         }
1395         catch ( ucb::UnsupportedNameClashException const & exc )
1396         {
1397             OSL_ENSURE( !aArg.ReplaceExisting,
1398                         "BUG: UnsupportedNameClashException not allowed here!" );
1399
1400             if (exc.NameClash != ucb::NameClash::ERROR) {
1401                 OSL_FAIL( "BUG: NameClash::ERROR expected!" );
1402             }
1403
1404             // No chance to solve name clashes, because I'm not able to detect
1405             // whether there is one.
1406             throw ucb::UnsupportedNameClashException(
1407                     OUString(
1408                         "Unable to resolve name clashes, no chance to detect "
1409                         "that there is one!" ),
1410                     rContext.xProcessor,
1411                     rContext.aArg.NameClash );
1412         }
1413         catch ( ucb::NameClashException const & )
1414         {
1415             // The 'insert' command throws a NameClashException if the parameter
1416             // ReplaceExisting of the command's argument was set to false and
1417             // there exists a resource with a clashing name in the target folder
1418             // of the operation.
1419
1420             // 'insert' command has no direct support for name clashes other
1421             // than ERROR ( ReplaceExisting == false ) and OVERWRITE
1422             // ( ReplaceExisting == true ). So we have to implement the
1423             // other name clash handling directives on top of the content.
1424
1425             // @@@ 'insert' command should be extended that it accepts a
1426             //     name clash handling directive, exactly like 'transfer' command.
1427
1428             switch ( rContext.aArg.NameClash )
1429             {
1430                 case ucb::NameClash::OVERWRITE:
1431                 {
1432                     ucbhelper::cancelCommandExecution(
1433                         uno::makeAny(
1434                             ucb::UnsupportedNameClashException(
1435                                 OUString(
1436                                     "BUG: insert + replace == true MUST NOT "
1437                                     "throw NameClashException." ),
1438                                 rContext.xProcessor,
1439                                 rContext.aArg.NameClash ) ),
1440                         rContext.xOrigEnv );
1441                     // Unreachable
1442                 }
1443
1444                 case ucb::NameClash::ERROR:
1445                     throw;
1446
1447                 case ucb::NameClash::RENAME:
1448                 {
1449                     // "invent" a new valid title.
1450                     handleNameClashRename( rContext,
1451                                            xNew,
1452                                            xCommandProcessorN,
1453                                            xCommandProcessorS,
1454                                            xInputStream );
1455                     break;
1456                 }
1457
1458                 case ucb::NameClash::ASK:
1459                     {
1460                         uno::Any aExc;
1461                         OUString aNewTitle;
1462                         NameClashContinuation eCont
1463                             = interactiveNameClashResolve(
1464                                 rContext.xOrigEnv, // always use original environment!
1465                                 rContext.aArg.TargetURL, // target folder URL
1466                                 aDesiredName,
1467                                 aExc,
1468                                 aNewTitle );
1469
1470                         switch ( eCont )
1471                         {
1472                             case NOT_HANDLED:
1473                                 // Not handled.
1474                                 cppu::throwException( aExc );
1475     //                            break;
1476
1477                             case UNKNOWN:
1478                                 // Handled, but not clear, how...
1479                                 // fall-thru intended.
1480
1481                             case ABORT:
1482                                 throw ucb::CommandFailedException(
1483                                     OUString(
1484                                             "abort requested via interaction "
1485                                             "handler"  ),
1486                                     uno::Reference< uno::XInterface >(),
1487                                     aExc );
1488     //                            break;
1489
1490                             case OVERWRITE:
1491                                 OSL_ENSURE( aArg.ReplaceExisting == sal_False,
1492                                             "Hu? ReplaceExisting already true?"
1493                                           );
1494                                 aArg.ReplaceExisting = sal_True;
1495                                 bRetry = true;
1496                                 break;
1497
1498                             case NEW_NAME:
1499                             {
1500                                 // set new name -> set "Title" property...
1501                                 if ( setTitle( xCommandProcessorN,
1502                                                rContext.xEnv,
1503                                                aNewTitle ) )
1504                                 {
1505                                     // remember suggested title...
1506                                     aDesiredName = aNewTitle;
1507
1508                                     // ... and try again.
1509                                     bRetry = true;
1510                                 }
1511                                 else
1512                                 {
1513                                     // error setting title. Abort.
1514                                     throw ucb::CommandFailedException(
1515                                         OUString( "error setting Title property!" ),
1516                                         uno::Reference< uno::XInterface >(),
1517                                         aExc );
1518                                 }
1519                                 break;
1520                             }
1521                         }
1522
1523                         OSL_ENSURE( bRetry, "bRetry must be true here!!!" );
1524                     }
1525                     break;
1526
1527                 case ucb::NameClash::KEEP: // deprecated
1528                 default:
1529                 {
1530                     ucbhelper::cancelCommandExecution(
1531                         uno::makeAny(
1532                             ucb::UnsupportedNameClashException(
1533                                 OUString(
1534                                         "default action, don't know how to "
1535                                         "handle name clash"  ),
1536                                 rContext.xProcessor,
1537                                 rContext.aArg.NameClash ) ),
1538                         rContext.xOrigEnv );
1539                     // Unreachable
1540                 }
1541             }
1542         }
1543     }
1544     while ( bRetry );
1545
1546
1547
1548     // (6) Process children of source.
1549
1550
1551
1552     if ( xResultSet.is() )
1553     {
1554         try
1555         {
1556             // Iterate over children...
1557
1558             uno::Reference< sdbc::XRow > xChildRow(
1559                                             xResultSet, uno::UNO_QUERY );
1560
1561             if ( !xChildRow.is() )
1562             {
1563                 uno::Any aProps
1564                     = uno::makeAny(
1565                              beans::PropertyValue(
1566                                  OUString( "Uri"),
1567                                  -1,
1568                                  uno::makeAny(rContext.aArg.SourceURL),
1569                                  beans::PropertyState_DIRECT_VALUE));
1570                 ucbhelper::cancelCommandExecution(
1571                     ucb::IOErrorCode_CANT_READ,
1572                     uno::Sequence< uno::Any >(&aProps, 1),
1573                     rContext.xOrigEnv,
1574                     OUString( "Unable to get properties from children of source!" ),
1575                     rContext.xProcessor );
1576                 // Unreachable
1577             }
1578
1579             uno::Reference< ucb::XContentAccess > xChildAccess(
1580                                                 xResultSet, uno::UNO_QUERY );
1581
1582             if ( !xChildAccess.is() )
1583             {
1584                 uno::Any aProps
1585                     = uno::makeAny(
1586                              beans::PropertyValue(
1587                                  OUString( "Uri"),
1588                                  -1,
1589                                  uno::makeAny(rContext.aArg.SourceURL),
1590                                  beans::PropertyState_DIRECT_VALUE));
1591                 ucbhelper::cancelCommandExecution(
1592                     ucb::IOErrorCode_CANT_READ,
1593                     uno::Sequence< uno::Any >(&aProps, 1),
1594                     rContext.xOrigEnv,
1595                     OUString( "Unable to get children of source!" ),
1596                     rContext.xProcessor );
1597                 // Unreachable
1598             }
1599
1600             if ( xResultSet->first() )
1601             {
1602                 ucb::GlobalTransferCommandArgument2 aTransArg(
1603                         rContext.aArg.Operation,
1604                         OUString(),              // SourceURL; filled later
1605                         xNew->getIdentifier()
1606                             ->getContentIdentifier(), // TargetURL
1607                         OUString(),              // NewTitle;
1608                         rContext.aArg.NameClash,
1609                         rContext.aArg.MimeType,
1610                         rContext.aArg.DocumentId);
1611
1612                 TransferCommandContext aSubCtx(
1613                         rContext.m_xContext,
1614                         rContext.xProcessor,
1615                         rContext.xEnv,
1616                         rContext.xOrigEnv,
1617                         aTransArg );
1618                 do
1619                 {
1620                     uno::Reference< ucb::XContent > xChild
1621                                         = xChildAccess->queryContent();
1622                     if ( xChild.is() )
1623                     {
1624                         // Recursion!
1625
1626                         aSubCtx.aArg.SourceURL
1627                             = xChild->getIdentifier()->getContentIdentifier();
1628
1629                         globalTransfer_( aSubCtx,
1630                                          xChild,
1631                                          xNew,
1632                                          xChildRow );
1633                     }
1634                 }
1635                 while ( xResultSet->next() );
1636             }
1637         }
1638         catch ( sdbc::SQLException const & )
1639         {
1640         }
1641     }
1642
1643     try {
1644         uno::Reference< ucb::XCommandProcessor > xcp(
1645             xTarget, uno::UNO_QUERY );
1646
1647         uno::Any aAny;
1648         uno::Reference< ucb::XCommandInfo > xci;
1649         if(xcp.is())
1650             aAny =
1651                 xcp->execute(
1652                     ucb::Command(
1653                         OUString("getCommandInfo"),
1654                         -1,
1655                         uno::Any()),
1656                     0,
1657                     rContext.xEnv );
1658
1659         const OUString cmdName("flush");
1660         if((aAny >>= xci) && xci->hasCommandByName(cmdName))
1661             xcp->execute(
1662                 ucb::Command(
1663                     cmdName,
1664                     -1,
1665                     uno::Any()) ,
1666                 0,
1667                 rContext.xEnv );
1668     }
1669     catch( uno::Exception const & )
1670     {
1671     }
1672 }
1673
1674 } /* namescpace */
1675
1676
1677
1678 // UniversalContentBroker implementation ( XCommandProcessor commands ).
1679
1680
1681
1682 uno::Reference< ucb::XCommandInfo >
1683 UniversalContentBroker::getCommandInfo()
1684 {
1685     return uno::Reference< ucb::XCommandInfo >( new CommandProcessorInfo() );
1686 }
1687
1688
1689 void UniversalContentBroker::globalTransfer(
1690             const ucb::GlobalTransferCommandArgument2 & rArg,
1691             const uno::Reference< ucb::XCommandEnvironment > & xEnv )
1692     throw( uno::Exception )
1693 {
1694     // Use own command environment with own interaction handler intercepting
1695     // some interaction requests that shall not be handled by the user-supplied
1696     // interaction handler.
1697     uno::Reference< ucb::XCommandEnvironment > xLocalEnv;
1698     if (xEnv.is())
1699     {
1700         xLocalEnv.set( ucb::CommandEnvironment::create(
1701                m_xContext,
1702                new InteractionHandlerProxy( xEnv->getInteractionHandler() ),
1703                xEnv->getProgressHandler() ) );
1704     }
1705
1706
1707
1708     // (1) Try to transfer the content using 'transfer' command.
1709
1710
1711
1712     uno::Reference< ucb::XContent > xTarget;
1713     uno::Reference< ucb::XContentIdentifier > xId
1714             = createContentIdentifier( rArg.TargetURL );
1715     if ( xId.is() )
1716     {
1717         try
1718         {
1719             xTarget = queryContent( xId );
1720         }
1721         catch ( ucb::IllegalIdentifierException const & )
1722         {
1723         }
1724     }
1725
1726     if ( !xTarget.is() )
1727     {
1728         uno::Any aProps
1729             = uno::makeAny(beans::PropertyValue(
1730                                   OUString( "Uri"),
1731                                   -1,
1732                                   uno::makeAny(rArg.TargetURL),
1733                                   beans::PropertyState_DIRECT_VALUE));
1734         ucbhelper::cancelCommandExecution(
1735             ucb::IOErrorCode_CANT_READ,
1736             uno::Sequence< uno::Any >(&aProps, 1),
1737             xEnv,
1738             OUString( "Can't instanciate target object!" ),
1739             this );
1740         // Unreachable
1741     }
1742
1743     if ( ( rArg.Operation == ucb::TransferCommandOperation_COPY ) ||
1744          ( rArg.Operation == ucb::TransferCommandOperation_MOVE ) )
1745     {
1746         uno::Reference< ucb::XCommandProcessor > xCommandProcessor(
1747                                                     xTarget, uno::UNO_QUERY );
1748         if ( !xCommandProcessor.is() )
1749         {
1750             uno::Any aProps
1751                 = uno::makeAny(
1752                          beans::PropertyValue(
1753                              OUString( "Uri"),
1754                              -1,
1755                              uno::makeAny(rArg.TargetURL),
1756                              beans::PropertyState_DIRECT_VALUE));
1757             ucbhelper::cancelCommandExecution(
1758                 ucb::IOErrorCode_CANT_READ,
1759                 uno::Sequence< uno::Any >(&aProps, 1),
1760                 xEnv,
1761                 OUString( "Target content is not a XCommandProcessor!" ),
1762                 this );
1763             // Unreachable
1764         }
1765
1766         ucb::TransferInfo2 aTransferArg(
1767             ( rArg.Operation
1768                 == ucb::TransferCommandOperation_MOVE ), // MoveData
1769             rArg.SourceURL,
1770             rArg.NewTitle,
1771             rArg.NameClash,
1772             rArg.MimeType );
1773
1774         bool bRetry;
1775         do
1776         {
1777             bRetry = false;
1778
1779             try
1780             {
1781                 ucb::Command aCommand(
1782                     OUString( "transfer" ), // Name
1783                     -1,                                           // Handle
1784                     uno::makeAny( aTransferArg ) );               // Argument
1785
1786                 xCommandProcessor->execute( aCommand, 0, xLocalEnv );
1787
1788                 // Command succeeded. We're done.
1789                 return;
1790             }
1791             catch ( ucb::InteractiveBadTransferURLException const & )
1792             {
1793                 // Source URL is not supported by target. Try to transfer
1794                 // the content "manually".
1795             }
1796             catch ( ucb::UnsupportedCommandException const & )
1797             {
1798                 // 'transfer' command is not supported by commandprocessor.
1799                 // Try to transfer manually.
1800             }
1801             catch ( ucb::UnsupportedNameClashException const & exc )
1802             {
1803                 OSL_ENSURE( aTransferArg.NameClash == exc.NameClash,
1804                             "nameclash mismatch!" );
1805                 if ( exc.NameClash == ucb::NameClash::ASK )
1806                 {
1807                     // Try to detect a name clash by invoking "transfer" with
1808                     // NameClash::ERROR.
1809                     try
1810                     {
1811                         ucb::TransferInfo2 aTransferArg1(
1812                             aTransferArg.MoveData,
1813                             aTransferArg.SourceURL,
1814                             aTransferArg.NewTitle,
1815                             ucb::NameClash::ERROR,
1816                             aTransferArg.MimeType );
1817
1818                         ucb::Command aCommand1(
1819                             OUString("transfer"),
1820                             -1,
1821                             uno::makeAny( aTransferArg1 ) );
1822
1823                         xCommandProcessor->execute( aCommand1, 0, xLocalEnv );
1824
1825                         // Command succeeded. We're done.
1826                         return;
1827                     }
1828                     catch ( ucb::UnsupportedNameClashException const & )
1829                     {
1830                         // No chance to solve name clashes, because I'm not
1831                         // able to detect whether there is one.
1832                         throw exc; // Not just 'throw;'!
1833                     }
1834                     catch ( ucb::NameClashException const & )
1835                     {
1836                         // There's a clash. Use interaction handler to solve it.
1837
1838                         uno::Any aExc;
1839                         OUString aNewTitle;
1840                         NameClashContinuation eCont
1841                             = interactiveNameClashResolve(
1842                                 xEnv, // always use original environment!
1843                                 rArg.TargetURL,  // target folder URL
1844                                 createDesiredName(
1845                                   aTransferArg ),   // clashing name
1846                                 aExc,
1847                                 aNewTitle );
1848
1849                         switch ( eCont )
1850                         {
1851                             case NOT_HANDLED:
1852                                 // Not handled.
1853                                 cppu::throwException( aExc );
1854 //                                break;
1855
1856                             case UNKNOWN:
1857                                 // Handled, but not clear, how...
1858                                 // fall-thru intended.
1859
1860                             case ABORT:
1861                                 throw ucb::CommandFailedException(
1862                                     OUString(
1863                                             "abort requested via interaction "
1864                                             "handler"  ),
1865                                     uno::Reference< uno::XInterface >(),
1866                                     aExc );
1867 //                                break;
1868
1869                             case OVERWRITE:
1870                                 aTransferArg.NameClash
1871                                     = ucb::NameClash::OVERWRITE;
1872                                 bRetry = true;
1873                                 break;
1874
1875                             case NEW_NAME:
1876                                 aTransferArg.NewTitle = aNewTitle;
1877                                 bRetry = true;
1878                                 break;
1879                         }
1880
1881                         OSL_ENSURE( bRetry, "bRetry must be true here!!!" );
1882                     }
1883                 }
1884                 else
1885                 {
1886                     throw;
1887                 }
1888             }
1889         }
1890         while ( bRetry );
1891     }
1892
1893
1894
1895     // (2) Try to transfer the content "manually".
1896
1897
1898
1899     uno::Reference< ucb::XContent > xSource;
1900     try
1901     {
1902         uno::Reference< ucb::XContentIdentifier > xId2
1903             = createContentIdentifier( rArg.SourceURL );
1904         if ( xId2.is() )
1905             xSource = queryContent( xId2 );
1906     }
1907     catch ( ucb::IllegalIdentifierException const & )
1908     {
1909         // Error handling via "if ( !xSource.is() )" below.
1910     }
1911
1912     if ( !xSource.is() )
1913     {
1914         uno::Any aProps
1915             = uno::makeAny(beans::PropertyValue(
1916                                   OUString( "Uri"),
1917                                   -1,
1918                                   uno::makeAny(rArg.SourceURL),
1919                                   beans::PropertyState_DIRECT_VALUE));
1920         ucbhelper::cancelCommandExecution(
1921             ucb::IOErrorCode_CANT_READ,
1922             uno::Sequence< uno::Any >(&aProps, 1),
1923             xEnv,
1924             OUString( "Can't instanciate source object!" ),
1925             this );
1926         // Unreachable
1927     }
1928
1929     uno::Reference< ucb::XCommandProcessor > xCommandProcessor(
1930                                                 xSource, uno::UNO_QUERY );
1931     if ( !xCommandProcessor.is() )
1932     {
1933         uno::Any aProps
1934             = uno::makeAny(beans::PropertyValue(
1935                                   OUString( "Uri"),
1936                                   -1,
1937                                   uno::makeAny(rArg.SourceURL),
1938                                   beans::PropertyState_DIRECT_VALUE));
1939         ucbhelper::cancelCommandExecution(
1940             ucb::IOErrorCode_CANT_READ,
1941             uno::Sequence< uno::Any >(&aProps, 1),
1942             xEnv,
1943             OUString( "Source content is not a XCommandProcessor!" ),
1944             this );
1945         // Unreachable
1946     }
1947
1948     // Obtain interesting property values from source...
1949
1950     uno::Sequence< beans::Property > aProps( 4 );
1951
1952     aProps[ 0 ].Name   = "IsFolder";
1953     aProps[ 0 ].Handle = -1; /* unknown */
1954     aProps[ 1 ].Name   = "IsDocument";
1955     aProps[ 1 ].Handle = -1; /* unknown */
1956     aProps[ 2 ].Name   = "TargetURL";
1957     aProps[ 2 ].Handle = -1; /* unknown */
1958     aProps[ 3 ].Name   = "BaseURI";
1959     aProps[ 3 ].Handle = -1; /* unknown */
1960
1961     ucb::Command aGetPropsCommand(
1962                 OUString("getPropertyValues"),
1963                 -1,
1964                 uno::makeAny( aProps ) );
1965
1966     uno::Reference< sdbc::XRow > xRow;
1967     xCommandProcessor->execute( aGetPropsCommand, 0, xLocalEnv ) >>= xRow;
1968
1969     if ( !xRow.is() )
1970     {
1971         uno::Any aProps2
1972             = uno::makeAny(beans::PropertyValue(
1973                                OUString( "Uri"),
1974                                   -1,
1975                                   uno::makeAny(rArg.SourceURL),
1976                                   beans::PropertyState_DIRECT_VALUE));
1977         ucbhelper::cancelCommandExecution(
1978             ucb::IOErrorCode_CANT_READ,
1979             uno::Sequence< uno::Any >(&aProps2, 1),
1980             xEnv,
1981             OUString( "Unable to get properties from source object!" ),
1982             this );
1983         // Unreachable
1984     }
1985
1986     TransferCommandContext aTransferCtx(
1987         m_xContext, this, xLocalEnv, xEnv, rArg );
1988
1989     if ( rArg.NewTitle.isEmpty() )
1990     {
1991         // BaseURI: property is optional.
1992         OUString aBaseURI( xRow->getString( 4 ) );
1993         if ( !aBaseURI.isEmpty() )
1994         {
1995             aTransferCtx.aArg.NewTitle
1996                 = createDesiredName( aBaseURI, OUString() );
1997         }
1998     }
1999
2000     // Do it!
2001     globalTransfer_( aTransferCtx, xSource, xTarget, xRow );
2002
2003
2004
2005     // (3) Delete source, if operation is MOVE.
2006
2007
2008
2009     if ( rArg.Operation == ucb::TransferCommandOperation_MOVE )
2010     {
2011         try
2012         {
2013             ucb::Command aCommand(
2014                 OUString("delete"), // Name
2015                 -1,                                         // Handle
2016                 uno::makeAny( true ) );     // Argument
2017
2018             xCommandProcessor->execute( aCommand, 0, xLocalEnv );
2019         }
2020         catch ( uno::Exception const & )
2021         {
2022             OSL_FAIL( "Cannot delete source object!" );
2023             throw;
2024         }
2025     }
2026 }
2027
2028 uno::Any UniversalContentBroker::checkIn( const ucb::CheckinArgument& rArg,
2029             const uno::Reference< ucb::XCommandEnvironment >& xEnv ) throw ( uno::Exception )
2030 {
2031     uno::Any aRet;
2032     // Use own command environment with own interaction handler intercepting
2033     // some interaction requests that shall not be handled by the user-supplied
2034     // interaction handler.
2035     uno::Reference< ucb::XCommandEnvironment > xLocalEnv;
2036     if (xEnv.is())
2037     {
2038         xLocalEnv.set( ucb::CommandEnvironment::create(
2039                m_xContext,
2040                new InteractionHandlerProxy( xEnv->getInteractionHandler() ),
2041                xEnv->getProgressHandler() ) );
2042     }
2043
2044     uno::Reference< ucb::XContent > xTarget;
2045     uno::Reference< ucb::XContentIdentifier > xId
2046             = createContentIdentifier( rArg.TargetURL );
2047     if ( xId.is() )
2048     {
2049         try
2050         {
2051             xTarget = queryContent( xId );
2052         }
2053         catch ( ucb::IllegalIdentifierException const & )
2054         {
2055         }
2056     }
2057
2058     if ( !xTarget.is() )
2059     {
2060         uno::Any aProps
2061             = uno::makeAny(beans::PropertyValue(
2062                                   OUString( "Uri" ), -1,
2063                                   uno::makeAny( rArg.TargetURL ),
2064                                   beans::PropertyState_DIRECT_VALUE ) );
2065         ucbhelper::cancelCommandExecution(
2066             ucb::IOErrorCode_CANT_READ,
2067             uno::Sequence< uno::Any >( &aProps, 1 ),
2068             xEnv,
2069             OUString( "Can't instanciate target object!" ),
2070             this );
2071         // Unreachable
2072     }
2073
2074     uno::Reference< ucb::XCommandProcessor > xCommandProcessor(
2075                                                 xTarget, uno::UNO_QUERY );
2076     if ( !xCommandProcessor.is() )
2077     {
2078         uno::Any aProps
2079             = uno::makeAny(
2080                      beans::PropertyValue(
2081                          OUString( "Uri" ), -1,
2082                          uno::makeAny( rArg.TargetURL ),
2083                          beans::PropertyState_DIRECT_VALUE ) );
2084         ucbhelper::cancelCommandExecution(
2085             ucb::IOErrorCode_CANT_READ,
2086             uno::Sequence< uno::Any >( &aProps, 1 ),
2087             xEnv,
2088             OUString( "Target content is not a XCommandProcessor!" ),
2089             this );
2090         // Unreachable
2091     }
2092
2093     try
2094     {
2095         ucb::Command aCommand(
2096             OUString( "checkin" ), -1,
2097             uno::makeAny( rArg ) );
2098
2099         aRet = xCommandProcessor->execute( aCommand, 0, xLocalEnv );
2100     }
2101     catch ( ucb::UnsupportedCommandException const & )
2102     {
2103         // 'checkin' command is not supported by commandprocessor:
2104         // ignore.
2105     }
2106     return aRet;
2107 }
2108
2109 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */