ucb/source/ucp/file/bc.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 <rtl/uri.hxx>
  21 #include <rtl/ustrbuf.hxx>
  22 #include <osl/file.hxx>
  23
  24 #include "osl/diagnose.h"
  25 #include <com/sun/star/ucb/OpenMode.hpp>
  26 #include <com/sun/star/beans/PropertyAttribute.hpp>
  27 #include <com/sun/star/ucb/XProgressHandler.hpp>
  28 #include <com/sun/star/task/XInteractionHandler.hpp>
  29 #include <com/sun/star/io/XActiveDataStreamer.hpp>
  30 #include <com/sun/star/io/XOutputStream.hpp>
  31 #include <com/sun/star/ucb/NumberedSortingInfo.hpp>
  32 #include <com/sun/star/io/XActiveDataSink.hpp>
  33 #include <com/sun/star/beans/PropertyChangeEvent.hpp>
  34 #include <com/sun/star/beans/PropertySetInfoChange.hpp>
  35 #include <com/sun/star/ucb/ContentAction.hpp>
  36 #include <com/sun/star/ucb/NameClash.hpp>
  37 #include "filglob.hxx"
  38 #include "filid.hxx"
  39 #include "filrow.hxx"
  40 #include "bc.hxx"
  41 #include "prov.hxx"
  42 #include "filerror.hxx"
  43 #include "filinsreq.hxx"
  44
  45
  46 using namespace fileaccess;
  47 using namespace com::sun::star;
  48 using namespace com::sun::star::uno;
  49 using namespace com::sun::star::ucb;
  50
  51 // PropertyListeners
  52
  53
  54 typedef cppu::OMultiTypeInterfaceContainerHelperVar< OUString,hashOUString,equalOUString >
  55 PropertyListeners_impl;
  56
  57 class fileaccess::PropertyListeners
  58     : public PropertyListeners_impl
  59 {
  60 public:
  61     PropertyListeners( ::osl::Mutex& aMutex )
  62         : PropertyListeners_impl( aMutex )
  63     {
  64     }
  65 };
  66
  67
  68 /****************************************************************************************/
  69 /*                                                                                      */
  70 /*                    BaseContent                                                       */
  71 /*                                                                                      */
  72 /****************************************************************************************/
  73
  74 ////////////////////////////////////////////////////////////////////////////////
  75 // Private Constructor for just inserted Contents
  76
  77 BaseContent::BaseContent( shell* pMyShell,
  78                           const OUString& parentName,
  79                           sal_Bool bFolder )
  80     : m_pMyShell( pMyShell ),
  81       m_xContentIdentifier( 0 ),
  82       m_aUncPath( parentName ),
  83       m_bFolder( bFolder ),
  84       m_nState( JustInserted ),
  85       m_pDisposeEventListeners( 0 ),
  86       m_pContentEventListeners( 0 ),
  87       m_pPropertySetInfoChangeListeners( 0 ),
  88       m_pPropertyListener( 0 )
  89 {
  90     m_pMyShell->m_pProvider->acquire();
  91     // No registering, since we have no name
  92 }
  93
  94
  95 ////////////////////////////////////////////////////////////////////////////////
  96 // Constructor for full featured Contents
  97
  98 BaseContent::BaseContent( shell* pMyShell,
  99                           const Reference< XContentIdentifier >& xContentIdentifier,
 100                           const OUString& aUncPath )
 101     : m_pMyShell( pMyShell ),
 102       m_xContentIdentifier( xContentIdentifier ),
 103       m_aUncPath( aUncPath ),
 104       m_bFolder( false ),
 105       m_nState( FullFeatured ),
 106       m_pDisposeEventListeners( 0 ),
 107       m_pContentEventListeners( 0 ),
 108       m_pPropertySetInfoChangeListeners( 0 ),
 109       m_pPropertyListener( 0 )
 110 {
 111     m_pMyShell->m_pProvider->acquire();
 112     m_pMyShell->registerNotifier( m_aUncPath,this );
 113     m_pMyShell->insertDefaultProperties( m_aUncPath );
 114 }
 115
 116
 117 BaseContent::~BaseContent( )
 118 {
 119     if( ( m_nState & FullFeatured ) || ( m_nState & Deleted ) )
 120     {
 121         m_pMyShell->deregisterNotifier( m_aUncPath,this );
 122     }
 123     m_pMyShell->m_pProvider->release();
 124
 125     delete m_pDisposeEventListeners;
 126     delete m_pContentEventListeners;
 127     delete m_pPropertyListener;
 128     delete m_pPropertySetInfoChangeListeners;
 129 }
 130
 131
 132 //////////////////////////////////////////////////////////////////////////
 133 // XInterface
 134 //////////////////////////////////////////////////////////////////////////
 135
 136 void SAL_CALL
 137 BaseContent::acquire( void )
 138     throw()
 139 {
 140     OWeakObject::acquire();
 141 }
 142
 143
 144 void SAL_CALL
 145 BaseContent::release( void )
 146     throw()
 147 {
 148     OWeakObject::release();
 149 }
 150
 151
 152 Any SAL_CALL
 153 BaseContent::queryInterface( const Type& rType )
 154     throw( RuntimeException )
 155 {
 156     Any aRet = cppu::queryInterface( rType,
 157                                      (static_cast< lang::XComponent* >(this)),
 158                                      (static_cast< lang::XTypeProvider* >(this)),
 159                                      (static_cast< lang::XServiceInfo* >(this)),
 160                                      (static_cast< XCommandProcessor* >(this)),
 161                                      (static_cast< container::XChild* >(this)),
 162                                      (static_cast< beans::XPropertiesChangeNotifier* >(this)),
 163                                      (static_cast< beans::XPropertyContainer* >(this)),
 164                                      (static_cast< XContentCreator* >(this)),
 165                                      (static_cast< beans::XPropertySetInfoChangeNotifier* >(this)),
 166                                      (static_cast< XContent* >(this)) );
 167     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
 168 }
 169
 170
 171
 172
 173 //////////////////////////////////////////////////////////////////////////////////////////
 174 // XComponent
 175 ////////////////////////////////////////////////////////////////////////////////////////
 176
 177 void SAL_CALL
 178 BaseContent::addEventListener( const Reference< lang::XEventListener >& Listener )
 179     throw( RuntimeException )
 180 {
 181     osl::MutexGuard aGuard( m_aMutex );
 182
 183     if ( ! m_pDisposeEventListeners )
 184         m_pDisposeEventListeners =
 185             new cppu::OInterfaceContainerHelper( m_aEventListenerMutex );
 186
 187     m_pDisposeEventListeners->addInterface( Listener );
 188 }
 189
 190
 191 void SAL_CALL
 192 BaseContent::removeEventListener( const Reference< lang::XEventListener >& Listener )
 193     throw( RuntimeException )
 194 {
 195     osl::MutexGuard aGuard( m_aMutex );
 196
 197     if ( m_pDisposeEventListeners )
 198         m_pDisposeEventListeners->removeInterface( Listener );
 199 }
 200
 201
 202 void SAL_CALL
 203 BaseContent::dispose()
 204     throw( RuntimeException )
 205 {
 206     lang::EventObject aEvt;
 207     cppu::OInterfaceContainerHelper* pDisposeEventListeners;
 208     cppu::OInterfaceContainerHelper* pContentEventListeners;
 209     cppu::OInterfaceContainerHelper* pPropertySetInfoChangeListeners;
 210     PropertyListeners* pPropertyListener;
 211
 212     {
 213         osl::MutexGuard aGuard( m_aMutex );
 214         aEvt.Source = static_cast< XContent* >( this );
 215
 216
 217         pDisposeEventListeners =
 218             m_pDisposeEventListeners, m_pDisposeEventListeners = 0;
 219
 220         pContentEventListeners =
 221             m_pContentEventListeners, m_pContentEventListeners = 0;
 222
 223         pPropertySetInfoChangeListeners =
 224             m_pPropertySetInfoChangeListeners,
 225             m_pPropertySetInfoChangeListeners = 0;
 226
 227         pPropertyListener =
 228             m_pPropertyListener, m_pPropertyListener = 0;
 229     }
 230
 231     if ( pDisposeEventListeners && pDisposeEventListeners->getLength() )
 232         pDisposeEventListeners->disposeAndClear( aEvt );
 233
 234     if ( pContentEventListeners && pContentEventListeners->getLength() )
 235         pContentEventListeners->disposeAndClear( aEvt );
 236
 237     if( pPropertyListener )
 238         pPropertyListener->disposeAndClear( aEvt );
 239
 240     if( pPropertySetInfoChangeListeners )
 241         pPropertySetInfoChangeListeners->disposeAndClear( aEvt );
 242
 243     delete pDisposeEventListeners;
 244     delete pContentEventListeners;
 245     delete pPropertyListener;
 246     delete pPropertySetInfoChangeListeners;
 247 }
 248
 249
 250
 251 //////////////////////////////////////////////////////////////////////////////////////////
 252 //  XServiceInfo
 253 //////////////////////////////////////////////////////////////////////////////////////////
 254
 255 OUString SAL_CALL
 256 BaseContent::getImplementationName()
 257     throw( RuntimeException)
 258 {
 259     return OUString("com.sun.star.comp.ucb.FileContent");
 260 }
 261
 262
 263
 264 sal_Bool SAL_CALL
 265 BaseContent::supportsService( const OUString& ServiceName )
 266     throw( RuntimeException)
 267 {
 268     if ( ServiceName == "com.sun.star.ucb.FileContent" )
 269         return true;
 270     else
 271         return false;
 272 }
 273
 274
 275
 276 Sequence< OUString > SAL_CALL
 277 BaseContent::getSupportedServiceNames()
 278     throw( RuntimeException )
 279 {
 280     Sequence< OUString > ret( 1 );
 281     ret[0] = "com.sun.star.ucb.FileContent";
 282     return ret;
 283 }
 284
 285
 286
 287 //////////////////////////////////////////////////////////////////////////////////////////
 288 //  XTypeProvider
 289 //////////////////////////////////////////////////////////////////////////////////////////
 290
 291 XTYPEPROVIDER_IMPL_10( BaseContent,
 292                        lang::XComponent,
 293                        lang::XTypeProvider,
 294                        lang::XServiceInfo,
 295                        XCommandProcessor,
 296                        XContentCreator,
 297                        XContent,
 298                        container::XChild,
 299                        beans::XPropertiesChangeNotifier,
 300                        beans::XPropertyContainer,
 301                        beans::XPropertySetInfoChangeNotifier )
 302
 303
 304 //////////////////////////////////////////////////////////////////////////////////////////
 305 //  XCommandProcessor
 306 //////////////////////////////////////////////////////////////////////////////////////////
 307
 308 sal_Int32 SAL_CALL
 309 BaseContent::createCommandIdentifier( void )
 310     throw( RuntimeException )
 311 {
 312     return m_pMyShell->getCommandId();
 313 }
 314
 315
 316 void SAL_CALL
 317 BaseContent::abort( sal_Int32 CommandId )
 318     throw( RuntimeException )
 319 {
 320     m_pMyShell->abort( CommandId );
 321 }
 322
 323
 324 Any SAL_CALL
 325 BaseContent::execute( const Command& aCommand,
 326                       sal_Int32 CommandId,
 327                       const Reference< XCommandEnvironment >& Environment )
 328     throw( Exception,
 329            CommandAbortedException,
 330            RuntimeException )
 331 {
 332     if( ! CommandId )
 333         // A Command with commandid zero cannot be aborted
 334         CommandId = createCommandIdentifier();
 335
 336     m_pMyShell->startTask( CommandId,
 337                            Environment );
 338
 339     Any aAny;
 340
 341     if (aCommand.Name == "getPropertySetInfo")  // No exceptions
 342     {
 343         aAny <<= getPropertySetInfo( CommandId );
 344     }
 345     else if (aCommand.Name == "getCommandInfo")  // no exceptions
 346     {
 347         aAny <<= getCommandInfo();
 348     }
 349     else if ( aCommand.Name == "setPropertyValues" )
 350     {
 351         Sequence< beans::PropertyValue > sPropertyValues;
 352
 353         if( ! ( aCommand.Argument >>= sPropertyValues ) )
 354             m_pMyShell->installError( CommandId,
 355                                       TASKHANDLING_WRONG_SETPROPERTYVALUES_ARGUMENT );
 356         else
 357             aAny <<= setPropertyValues( CommandId,sPropertyValues );  // calls endTask by itself
 358     }
 359     else if ( aCommand.Name == "getPropertyValues" )
 360     {
 361         Sequence< beans::Property > ListOfRequestedProperties;
 362
 363         if( ! ( aCommand.Argument >>= ListOfRequestedProperties ) )
 364             m_pMyShell->installError( CommandId,
 365                                       TASKHANDLING_WRONG_GETPROPERTYVALUES_ARGUMENT );
 366         else
 367             aAny <<= getPropertyValues( CommandId,
 368                                         ListOfRequestedProperties );
 369     }
 370     else if ( aCommand.Name == "open" )
 371     {
 372         OpenCommandArgument2 aOpenArgument;
 373         if( ! ( aCommand.Argument >>= aOpenArgument ) )
 374             m_pMyShell->installError( CommandId,
 375                                       TASKHANDLING_WRONG_OPEN_ARGUMENT );
 376         else
 377         {
 378             Reference< XDynamicResultSet > result = open( CommandId,aOpenArgument );
 379             if( result.is() )
 380                 aAny <<= result;
 381         }
 382     }
 383     else if ( aCommand.Name == "delete" )
 384     {
 385         if( ! aCommand.Argument.has< sal_Bool >() )
 386             m_pMyShell->installError( CommandId,
 387                                       TASKHANDLING_WRONG_DELETE_ARGUMENT );
 388         else
 389             deleteContent( CommandId );
 390     }
 391     else if ( aCommand.Name == "transfer" )
 392     {
 393         TransferInfo aTransferInfo;
 394         if( ! ( aCommand.Argument >>= aTransferInfo ) )
 395             m_pMyShell->installError( CommandId,
 396                                       TASKHANDLING_WRONG_TRANSFER_ARGUMENT );
 397         else
 398             transfer( CommandId, aTransferInfo );
 399     }
 400     else if ( aCommand.Name == "insert" )
 401     {
 402         InsertCommandArgument aInsertArgument;
 403         if( ! ( aCommand.Argument >>= aInsertArgument ) )
 404             m_pMyShell->installError( CommandId,
 405                                       TASKHANDLING_WRONG_INSERT_ARGUMENT );
 406         else
 407             insert( CommandId,aInsertArgument );
 408     }
 409     else if ( aCommand.Name == "getCasePreservingURL" )
 410     {
 411         Sequence< beans::Property > seq(1);
 412         seq[0] = beans::Property(
 413             OUString("CasePreservingURL"),
 414             -1,
 415             getCppuType( static_cast< sal_Bool* >(0) ),
 416             0 );
 417         Reference< sdbc::XRow > xRow = getPropertyValues( CommandId,seq );
 418         OUString CasePreservingURL = xRow->getString(1);
 419         if(!xRow->wasNull())
 420             aAny <<= CasePreservingURL;
 421     }
 422     else if ( aCommand.Name == "createNewContent" )
 423     {
 424         ucb::ContentInfo aArg;
 425         if ( !( aCommand.Argument >>= aArg ) )
 426             m_pMyShell->installError( CommandId,
 427                                       TASKHANDLING_WRONG_CREATENEWCONTENT_ARGUMENT );
 428         else
 429             aAny <<= createNewContent( aArg );
 430     }
 431     else
 432         m_pMyShell->installError( CommandId,
 433                                   TASKHANDLER_UNSUPPORTED_COMMAND );
 434
 435
 436     // This is the only function allowed to throw an exception
 437     endTask( CommandId );
 438
 439     return aAny;
 440 }
 441
 442
 443
 444 void SAL_CALL
 445 BaseContent::addPropertiesChangeListener(
 446     const Sequence< OUString >& PropertyNames,
 447     const Reference< beans::XPropertiesChangeListener >& Listener )
 448     throw( RuntimeException )
 449 {
 450     if( ! Listener.is() )
 451         return;
 452
 453     osl::MutexGuard aGuard( m_aMutex );
 454
 455     if( ! m_pPropertyListener )
 456         m_pPropertyListener = new PropertyListeners( m_aEventListenerMutex );
 457
 458
 459     if( PropertyNames.getLength() == 0 )
 460         m_pPropertyListener->addInterface( OUString(),Listener );
 461     else
 462     {
 463         Reference< beans::XPropertySetInfo > xProp = m_pMyShell->info_p( m_aUncPath );
 464         for( sal_Int32 i = 0; i < PropertyNames.getLength(); ++i )
 465             if( xProp->hasPropertyByName( PropertyNames[i] ) )
 466                 m_pPropertyListener->addInterface( PropertyNames[i],Listener );
 467     }
 468 }
 469
 470
 471 void SAL_CALL
 472 BaseContent::removePropertiesChangeListener( const Sequence< OUString >& PropertyNames,
 473                                              const Reference< beans::XPropertiesChangeListener >& Listener )
 474     throw( RuntimeException )
 475 {
 476     if( ! Listener.is() )
 477         return;
 478
 479     osl::MutexGuard aGuard( m_aMutex );
 480
 481     if( ! m_pPropertyListener )
 482         return;
 483
 484     for( sal_Int32 i = 0; i < PropertyNames.getLength(); ++i )
 485         m_pPropertyListener->removeInterface( PropertyNames[i],Listener );
 486
 487     m_pPropertyListener->removeInterface( OUString(), Listener );
 488 }
 489
 490
 491 /////////////////////////////////////////////////////////////////////////////////////////
 492 // XContent
 493 /////////////////////////////////////////////////////////////////////////////////////////
 494
 495 Reference< ucb::XContentIdentifier > SAL_CALL
 496 BaseContent::getIdentifier()
 497     throw( RuntimeException )
 498 {
 499     return m_xContentIdentifier;
 500 }
 501
 502
 503 OUString SAL_CALL
 504 BaseContent::getContentType()
 505     throw( RuntimeException )
 506 {
 507     if( !( m_nState & Deleted ) )
 508     {
 509         if( m_nState & JustInserted )
 510         {
 511             if ( m_bFolder )
 512                 return m_pMyShell->FolderContentType;
 513             else
 514                 return m_pMyShell->FileContentType;
 515         }
 516         else
 517         {
 518             try
 519             {
 520                 // Who am I ?
 521                 Sequence< beans::Property > seq(1);
 522                 seq[0] = beans::Property( OUString("IsDocument"),
 523                                           -1,
 524                                           getCppuType( static_cast< sal_Bool* >(0) ),
 525                                           0 );
 526                 Reference< sdbc::XRow > xRow = getPropertyValues( -1,seq );
 527                 sal_Bool IsDocument = xRow->getBoolean( 1 );
 528
 529                 if ( !xRow->wasNull() )
 530                 {
 531                     if ( IsDocument )
 532                         return m_pMyShell->FileContentType;
 533                     else
 534                         return m_pMyShell->FolderContentType;
 535                 }
 536                 else
 537                 {
 538                     OSL_FAIL( "BaseContent::getContentType - Property value was null!" );
 539                 }
 540             }
 541             catch (const sdbc::SQLException&)
 542             {
 543                 OSL_FAIL( "BaseContent::getContentType - Caught SQLException!" );
 544             }
 545         }
 546     }
 547
 548     return OUString();
 549 }
 550
 551
 552
 553 void SAL_CALL
 554 BaseContent::addContentEventListener(
 555     const Reference< XContentEventListener >& Listener )
 556     throw( RuntimeException )
 557 {
 558     osl::MutexGuard aGuard( m_aMutex );
 559
 560     if ( ! m_pContentEventListeners )
 561         m_pContentEventListeners =
 562             new cppu::OInterfaceContainerHelper( m_aEventListenerMutex );
 563
 564
 565     m_pContentEventListeners->addInterface( Listener );
 566 }
 567
 568
 569 void SAL_CALL
 570 BaseContent::removeContentEventListener(
 571     const Reference< XContentEventListener >& Listener )
 572     throw( RuntimeException )
 573 {
 574     osl::MutexGuard aGuard( m_aMutex );
 575
 576     if ( m_pContentEventListeners )
 577         m_pContentEventListeners->removeInterface( Listener );
 578 }
 579
 580
 581
 582 ////////////////////////////////////////////////////////////////////////////////
 583 // XPropertyContainer
 584 ////////////////////////////////////////////////////////////////////////////////
 585
 586
 587 void SAL_CALL
 588 BaseContent::addProperty(
 589     const OUString& Name,
 590     sal_Int16 Attributes,
 591     const Any& DefaultValue )
 592     throw( beans::PropertyExistException,
 593            beans::IllegalTypeException,
 594            lang::IllegalArgumentException,
 595            RuntimeException)
 596 {
 597     if( ( m_nState & JustInserted ) || ( m_nState & Deleted ) || Name.isEmpty() )
 598     {
 599         throw lang::IllegalArgumentException( OUString(  OSL_LOG_PREFIX  ), uno::Reference< uno::XInterface >(), 0 );
 600     }
 601
 602     m_pMyShell->associate( m_aUncPath,Name,DefaultValue,Attributes );
 603 }
 604
 605
 606 void SAL_CALL
 607 BaseContent::removeProperty(
 608     const OUString& Name )
 609     throw( beans::UnknownPropertyException,
 610            beans::NotRemoveableException,
 611            RuntimeException)
 612 {
 613
 614     if( m_nState & Deleted )
 615         throw beans::UnknownPropertyException( OUString(  OSL_LOG_PREFIX  ), uno::Reference< uno::XInterface >() );
 616
 617     m_pMyShell->deassociate( m_aUncPath, Name );
 618 }
 619
 620 ////////////////////////////////////////////////////////////////////////////////
 621 // XContentCreator
 622 ////////////////////////////////////////////////////////////////////////////////
 623
 624 Sequence< ContentInfo > SAL_CALL
 625 BaseContent::queryCreatableContentsInfo(
 626     void )
 627     throw( RuntimeException )
 628 {
 629     return m_pMyShell->queryCreatableContentsInfo();
 630 }
 631
 632
 633 Reference< XContent > SAL_CALL
 634 BaseContent::createNewContent(
 635     const ContentInfo& Info )
 636     throw( RuntimeException )
 637 {
 638     // Check type.
 639     if ( Info.Type.isEmpty() )
 640         return Reference< XContent >();
 641
 642     sal_Bool bFolder
 643         = ( Info.Type.compareTo( m_pMyShell->FolderContentType ) == 0 );
 644     if ( !bFolder )
 645     {
 646         if ( Info.Type.compareTo( m_pMyShell->FileContentType ) != 0 )
 647         {
 648             // Neither folder nor file to create!
 649             return Reference< XContent >();
 650         }
 651     }
 652
 653     // Who am I ?
 654     sal_Bool IsDocument = false;
 655
 656     try
 657     {
 658         Sequence< beans::Property > seq(1);
 659         seq[0] = beans::Property( OUString("IsDocument"),
 660                                   -1,
 661                                   getCppuType( static_cast< sal_Bool* >(0) ),
 662                                   0 );
 663         Reference< sdbc::XRow > xRow = getPropertyValues( -1,seq );
 664         IsDocument = xRow->getBoolean( 1 );
 665
 666         if ( xRow->wasNull() )
 667         {
 668             IsDocument = false;
 669 //              OSL_FAIL( //                          "BaseContent::createNewContent - Property value was null!" );
 670 //              return Reference< XContent >();
 671         }
 672     }
 673     catch (const sdbc::SQLException&)
 674     {
 675         OSL_FAIL( "BaseContent::createNewContent - Caught SQLException!" );
 676         return Reference< XContent >();
 677     }
 678
 679     OUString dstUncPath;
 680
 681     if( IsDocument )
 682     {
 683         // KSO: Why is a document a XContentCreator? This is quite unusual.
 684         dstUncPath = getParentName( m_aUncPath );
 685     }
 686     else
 687         dstUncPath = m_aUncPath;
 688
 689     BaseContent* p = new BaseContent( m_pMyShell, dstUncPath, bFolder );
 690     return Reference< XContent >( p );
 691 }
 692
 693
 694 ////////////////////////////////////////////////////////////////////////////////
 695 // XPropertySetInfoChangeNotifier
 696 ////////////////////////////////////////////////////////////////////////////////
 697
 698
 699 void SAL_CALL
 700 BaseContent::addPropertySetInfoChangeListener(
 701     const Reference< beans::XPropertySetInfoChangeListener >& Listener )
 702     throw( RuntimeException )
 703 {
 704     osl::MutexGuard aGuard( m_aMutex );
 705     if( ! m_pPropertySetInfoChangeListeners )
 706         m_pPropertySetInfoChangeListeners = new cppu::OInterfaceContainerHelper( m_aEventListenerMutex );
 707
 708     m_pPropertySetInfoChangeListeners->addInterface( Listener );
 709 }
 710
 711
 712 void SAL_CALL
 713 BaseContent::removePropertySetInfoChangeListener(
 714     const Reference< beans::XPropertySetInfoChangeListener >& Listener )
 715     throw( RuntimeException )
 716 {
 717     osl::MutexGuard aGuard( m_aMutex );
 718
 719     if( m_pPropertySetInfoChangeListeners )
 720         m_pPropertySetInfoChangeListeners->removeInterface( Listener );
 721 }
 722
 723
 724 ////////////////////////////////////////////////////////////////////////////////
 725 // XChild
 726 ////////////////////////////////////////////////////////////////////////////////
 727
 728 Reference< XInterface > SAL_CALL
 729 BaseContent::getParent(
 730     void )
 731     throw( RuntimeException )
 732 {
 733     OUString ParentUnq = getParentName( m_aUncPath );
 734     OUString ParentUrl;
 735
 736
 737     sal_Bool err = m_pMyShell->getUrlFromUnq( ParentUnq, ParentUrl );
 738     if( err )
 739         return Reference< XInterface >( 0 );
 740
 741     FileContentIdentifier* p = new FileContentIdentifier( m_pMyShell,ParentUnq );
 742     Reference< XContentIdentifier > Identifier( p );
 743
 744     try
 745     {
 746         return m_pMyShell->m_pProvider->queryContent( Identifier );
 747     }
 748     catch (const IllegalIdentifierException&)
 749     {
 750         return Reference< XInterface >();
 751     }
 752 }
 753
 754
 755 void SAL_CALL
 756 BaseContent::setParent(
 757     const Reference< XInterface >& )
 758     throw( lang::NoSupportException,
 759            RuntimeException)
 760 {
 761     throw lang::NoSupportException( OUString(  OSL_LOG_PREFIX  ), uno::Reference< uno::XInterface >() );
 762 }
 763
 764
 765 //////////////////////////////////////////////////////////////////////////////////////////
 766 // Private Methods
 767 //////////////////////////////////////////////////////////////////////////////////////////
 768
 769
 770 Reference< XCommandInfo > SAL_CALL
 771 BaseContent::getCommandInfo()
 772     throw( RuntimeException )
 773 {
 774     if( m_nState & Deleted )
 775         return Reference< XCommandInfo >();
 776
 777     return m_pMyShell->info_c();
 778 }
 779
 780
 781 Reference< beans::XPropertySetInfo > SAL_CALL
 782 BaseContent::getPropertySetInfo(
 783     sal_Int32 )
 784     throw( RuntimeException )
 785 {
 786     if( m_nState & Deleted )
 787         return Reference< beans::XPropertySetInfo >();
 788
 789     return m_pMyShell->info_p( m_aUncPath );
 790 }
 791
 792
 793
 794
 795 Reference< sdbc::XRow > SAL_CALL
 796 BaseContent::getPropertyValues(
 797     sal_Int32 nMyCommandIdentifier,
 798     const Sequence< beans::Property >& PropertySet )
 799     throw( RuntimeException )
 800 {
 801     sal_Int32 nProps = PropertySet.getLength();
 802     if ( !nProps )
 803         return Reference< sdbc::XRow >();
 804
 805     if( m_nState & Deleted )
 806     {
 807         Sequence< Any > aValues( nProps );
 808         return Reference< sdbc::XRow >( new XRow_impl( m_pMyShell, aValues ) );
 809     }
 810
 811     if( m_nState & JustInserted )
 812     {
 813         Sequence< Any > aValues( nProps );
 814         Any* pValues = aValues.getArray();
 815
 816         const beans::Property* pProps = PropertySet.getConstArray();
 817
 818         for ( sal_Int32 n = 0; n < nProps; ++n )
 819         {
 820             const beans::Property& rProp = pProps[ n ];
 821             Any& rValue = pValues[ n ];
 822
 823             if ( rProp.Name == "ContentType" )
 824             {
 825                 rValue <<= m_bFolder ? m_pMyShell->FolderContentType
 826                     : m_pMyShell->FileContentType;
 827             }
 828             else if ( rProp.Name == "IsFolder" )
 829             {
 830                 rValue <<= m_bFolder;
 831             }
 832             else if ( rProp.Name == "IsDocument" )
 833             {
 834                 rValue <<= sal_Bool( !m_bFolder );
 835             }
 836         }
 837
 838         return Reference< sdbc::XRow >(
 839             new XRow_impl( m_pMyShell, aValues ) );
 840     }
 841
 842     return m_pMyShell->getv( nMyCommandIdentifier,
 843                              m_aUncPath,
 844                              PropertySet );
 845 }
 846
 847
 848 Sequence< Any > SAL_CALL
 849 BaseContent::setPropertyValues(
 850     sal_Int32 nMyCommandIdentifier,
 851     const Sequence< beans::PropertyValue >& Values )
 852     throw()
 853 {
 854     if( m_nState & Deleted )
 855     {   //  To do
 856         return Sequence< Any >( Values.getLength() );
 857     }
 858
 859     const OUString Title("Title");
 860
 861     // Special handling for files which have to be inserted
 862     if( m_nState & JustInserted )
 863     {
 864         for( sal_Int32 i = 0; i < Values.getLength(); ++i )
 865         {
 866             if( Values[i].Name == Title )
 867             {
 868                 OUString NewTitle;
 869                 if( Values[i].Value >>= NewTitle )
 870                 {
 871                     if ( m_nState & NameForInsertionSet )
 872                     {
 873                         // User wants to set another Title before "insert".
 874                         // m_aUncPath contains previous own URI.
 875
 876                         sal_Int32 nLastSlash = m_aUncPath.lastIndexOf( '/' );
 877                         bool bTrailingSlash = false;
 878                         if ( nLastSlash == m_aUncPath.getLength() - 1 )
 879                         {
 880                             bTrailingSlash = true;
 881                             nLastSlash
 882                                 = m_aUncPath.lastIndexOf( '/', nLastSlash );
 883                         }
 884
 885                         OSL_ENSURE( nLastSlash != -1,
 886                                     "BaseContent::setPropertyValues: "
 887                                     "Invalid URL!" );
 888
 889                         OUStringBuffer aBuf(
 890                             m_aUncPath.copy( 0, nLastSlash + 1 ) );
 891
 892                         if ( !NewTitle.isEmpty() )
 893                         {
 894                             aBuf.append( NewTitle );
 895                             if ( bTrailingSlash )
 896                                 aBuf.append( '/' );
 897                         }
 898                         else
 899                         {
 900                             m_nState &= ~NameForInsertionSet;
 901                         }
 902
 903                         m_aUncPath = aBuf.makeStringAndClear();
 904                     }
 905                     else
 906                     {
 907                         if ( !NewTitle.isEmpty() )
 908                         {
 909                             // Initial Title before "insert".
 910                             // m_aUncPath contains parent's URI.
 911
 912                             if( !m_aUncPath.endsWith( "/" ) )
 913                                 m_aUncPath += "/";
 914
 915                             m_aUncPath += rtl::Uri::encode( NewTitle,
 916                                                             rtl_UriCharClassPchar,
 917                                                             rtl_UriEncodeIgnoreEscapes,
 918                                                             RTL_TEXTENCODING_UTF8 );
 919                             m_nState |= NameForInsertionSet;
 920                         }
 921                     }
 922                 }
 923             }
 924         }
 925
 926         return Sequence< Any >( Values.getLength() );
 927     }
 928     else
 929     {
 930         Sequence< Any > ret = m_pMyShell->setv( m_aUncPath,  // Does not handle Title
 931                                                 Values );
 932
 933         // Special handling Title: Setting Title is equivalent to a renaming of the underlying file
 934         for( sal_Int32 i = 0; i < Values.getLength(); ++i )
 935         {
 936             if( Values[i].Name != Title )
 937                 continue;                  // handled by setv
 938
 939             OUString NewTitle;
 940             if( !( Values[i].Value >>= NewTitle ) )
 941             {
 942                 ret[i] <<= beans::IllegalTypeException( OUString(  OSL_LOG_PREFIX  ), uno::Reference< uno::XInterface >() );
 943                 break;
 944             }
 945             else if( NewTitle.isEmpty() )
 946             {
 947                 ret[i] <<= lang::IllegalArgumentException( OUString(  OSL_LOG_PREFIX  ), uno::Reference< uno::XInterface >(), 0 );
 948                 break;
 949             }
 950
 951
 952             OUString aDstName = getParentName( m_aUncPath );
 953             if( !aDstName.endsWith("/") )
 954                 aDstName += "/";
 955
 956             aDstName += rtl::Uri::encode( NewTitle,
 957                                           rtl_UriCharClassPchar,
 958                                           rtl_UriEncodeIgnoreEscapes,
 959                                           RTL_TEXTENCODING_UTF8 );
 960
 961             m_pMyShell->move( nMyCommandIdentifier,     // move notifies the children also;
 962                               m_aUncPath,
 963                               aDstName,
 964                               NameClash::KEEP );
 965
 966             try
 967             {
 968                 endTask( nMyCommandIdentifier );
 969             }
 970             catch(const Exception& e)
 971             {
 972                 ret[i] <<= e;
 973             }
 974
 975             // NameChanges come back trough a ContentEvent
 976             break; // only handling Title
 977         } // end for
 978
 979         return ret;
 980     }
 981 }
 982
 983
 984
 985 Reference< XDynamicResultSet > SAL_CALL
 986 BaseContent::open(
 987     sal_Int32 nMyCommandIdentifier,
 988     const OpenCommandArgument2& aCommandArgument )
 989     throw()
 990 {
 991     Reference< XDynamicResultSet > retValue( 0 );
 992
 993     if( ( m_nState & Deleted ) )
 994     {
 995         m_pMyShell->installError( nMyCommandIdentifier,
 996                                   TASKHANDLING_DELETED_STATE_IN_OPEN_COMMAND );
 997     }
 998     else if( m_nState & JustInserted )
 999     {
1000         m_pMyShell->installError( nMyCommandIdentifier,
1001                                   TASKHANDLING_INSERTED_STATE_IN_OPEN_COMMAND );
1002     }
1003     else
1004     {
1005         if( aCommandArgument.Mode == OpenMode::DOCUMENT ||
1006             aCommandArgument.Mode == OpenMode::DOCUMENT_SHARE_DENY_NONE )
1007
1008         {
1009             Reference< io::XOutputStream > outputStream( aCommandArgument.Sink,UNO_QUERY );
1010             if( outputStream.is() )
1011             {
1012                 m_pMyShell->page( nMyCommandIdentifier,
1013                                   m_aUncPath,
1014                                   outputStream );
1015             }
1016
1017             sal_Bool bLock = ( aCommandArgument.Mode != OpenMode::DOCUMENT_SHARE_DENY_NONE );
1018
1019             Reference< io::XActiveDataSink > activeDataSink( aCommandArgument.Sink,UNO_QUERY );
1020             if( activeDataSink.is() )
1021             {
1022                 activeDataSink->setInputStream( m_pMyShell->open( nMyCommandIdentifier,
1023                                                                   m_aUncPath,
1024                                                                   bLock ) );
1025             }
1026
1027             Reference< io::XActiveDataStreamer > activeDataStreamer( aCommandArgument.Sink,UNO_QUERY );
1028             if( activeDataStreamer.is() )
1029             {
1030                 activeDataStreamer->setStream( m_pMyShell->open_rw( nMyCommandIdentifier,
1031                                                                     m_aUncPath,
1032                                                                     bLock ) );
1033             }
1034         }
1035         else if ( aCommandArgument.Mode == OpenMode::ALL        ||
1036                   aCommandArgument.Mode == OpenMode::FOLDERS    ||
1037                   aCommandArgument.Mode == OpenMode::DOCUMENTS )
1038         {
1039             retValue = m_pMyShell->ls( nMyCommandIdentifier,
1040                                        m_aUncPath,
1041                                        aCommandArgument.Mode,
1042                                        aCommandArgument.Properties,
1043                                        aCommandArgument.SortingInfo );
1044         }
1045 //          else if(  aCommandArgument.Mode ==
1046 //                    OpenMode::DOCUMENT_SHARE_DENY_NONE  ||
1047 //                    aCommandArgument.Mode ==
1048 //                    OpenMode::DOCUMENT_SHARE_DENY_WRITE )
1049 //              m_pMyShell->installError( nMyCommandIdentifier,
1050 //                                        TASKHANDLING_UNSUPPORTED_OPEN_MODE,
1051 //                                        aCommandArgument.Mode);
1052         else
1053             m_pMyShell->installError( nMyCommandIdentifier,
1054                                       TASKHANDLING_UNSUPPORTED_OPEN_MODE,
1055                                       aCommandArgument.Mode);
1056     }
1057
1058     return retValue;
1059 }
1060
1061
1062
1063 void SAL_CALL
1064 BaseContent::deleteContent( sal_Int32 nMyCommandIdentifier )
1065     throw()
1066 {
1067     if( m_nState & Deleted )
1068         return;
1069
1070     if( m_pMyShell->remove( nMyCommandIdentifier,m_aUncPath ) )
1071     {
1072         osl::MutexGuard aGuard( m_aMutex );
1073         m_nState |= Deleted;
1074     }
1075 }
1076
1077
1078
1079 void SAL_CALL
1080 BaseContent::transfer( sal_Int32 nMyCommandIdentifier,
1081                        const TransferInfo& aTransferInfo )
1082     throw()
1083 {
1084     if( m_nState & Deleted )
1085         return;
1086
1087     if( !aTransferInfo.SourceURL.startsWith( "file:" ) )
1088     {
1089         m_pMyShell->installError( nMyCommandIdentifier,
1090                                   TASKHANDLING_TRANSFER_INVALIDSCHEME );
1091         return;
1092     }
1093
1094     OUString srcUnc;
1095     if( m_pMyShell->getUnqFromUrl( aTransferInfo.SourceURL,srcUnc ) )
1096     {
1097         m_pMyShell->installError( nMyCommandIdentifier,
1098                                   TASKHANDLING_TRANSFER_INVALIDURL );
1099         return;
1100     }
1101
1102     OUString srcUncPath = srcUnc;
1103
1104     // Determine the new title !
1105     OUString NewTitle;
1106     if( !aTransferInfo.NewTitle.isEmpty() )
1107         NewTitle = rtl::Uri::encode( aTransferInfo.NewTitle,
1108                                      rtl_UriCharClassPchar,
1109                                      rtl_UriEncodeIgnoreEscapes,
1110                                      RTL_TEXTENCODING_UTF8 );
1111     else
1112         NewTitle = srcUncPath.copy( 1 + srcUncPath.lastIndexOf( '/' ) );
1113
1114     // Is destination a document or a folder ?
1115     Sequence< beans::Property > seq(1);
1116     seq[0] = beans::Property( OUString("IsDocument"),
1117                               -1,
1118                               getCppuType( static_cast< sal_Bool* >(0) ),
1119                               0 );
1120     Reference< sdbc::XRow > xRow = getPropertyValues( nMyCommandIdentifier,seq );
1121     sal_Bool IsDocument = xRow->getBoolean( 1 );
1122     if( xRow->wasNull() )
1123     {   // Destination file type could not be determined
1124         m_pMyShell->installError( nMyCommandIdentifier,
1125                                   TASKHANDLING_TRANSFER_DESTFILETYPE );
1126         return;
1127     }
1128
1129     OUString dstUncPath;
1130     if( IsDocument )
1131     {   // as sibling
1132         sal_Int32 lastSlash = m_aUncPath.lastIndexOf( '/' );
1133         dstUncPath = m_aUncPath.copy(0,lastSlash );
1134     }
1135     else
1136         // as child
1137         dstUncPath = m_aUncPath;
1138
1139     dstUncPath += ( OUString("/") + NewTitle );
1140
1141     sal_Int32 NameClash = aTransferInfo.NameClash;
1142
1143     if( aTransferInfo.MoveData )
1144         m_pMyShell->move( nMyCommandIdentifier,srcUncPath,dstUncPath,NameClash );
1145     else
1146         m_pMyShell->copy( nMyCommandIdentifier,srcUncPath,dstUncPath,NameClash );
1147 }
1148
1149
1150
1151
1152 void SAL_CALL BaseContent::insert( sal_Int32 nMyCommandIdentifier,
1153                                    const InsertCommandArgument& aInsertArgument )
1154     throw()
1155 {
1156     if( m_nState & FullFeatured )
1157     {
1158         m_pMyShell->write( nMyCommandIdentifier,
1159                            m_aUncPath,
1160                            aInsertArgument.ReplaceExisting,
1161                            aInsertArgument.Data );
1162         return;
1163     }
1164
1165     if( ! ( m_nState & JustInserted ) )
1166     {
1167         m_pMyShell->installError( nMyCommandIdentifier,
1168                                   TASKHANDLING_NOFRESHINSERT_IN_INSERT_COMMAND );
1169         return;
1170     }
1171
1172     // Inserts the content, which has the flag m_bIsFresh
1173
1174     if( ! (m_nState & NameForInsertionSet) )
1175     {
1176         m_pMyShell->installError( nMyCommandIdentifier,
1177                                   TASKHANDLING_NONAMESET_INSERT_COMMAND );
1178         return;
1179     }
1180
1181     // Inserting a document or a file?
1182     sal_Bool bDocument = false;
1183
1184     Sequence< beans::Property > seq(1);
1185     seq[0] = beans::Property( OUString("IsDocument"),
1186                               -1,
1187                               getCppuType( static_cast< sal_Bool* >(0) ),
1188                               0 );
1189
1190     Reference< sdbc::XRow > xRow = getPropertyValues( -1,seq );
1191
1192     bool contentTypeSet = true;  // is set to false, if contentType not set
1193     try
1194     {
1195         bDocument = xRow->getBoolean( 1 );
1196         if( xRow->wasNull() )
1197             contentTypeSet = false;
1198
1199     }
1200     catch (const sdbc::SQLException&)
1201     {
1202         OSL_FAIL( "BaseContent::insert - Caught SQLException!" );
1203         contentTypeSet = false;
1204     }
1205
1206     if( ! contentTypeSet )
1207     {
1208         m_pMyShell->installError( nMyCommandIdentifier,
1209                                   TASKHANDLING_NOCONTENTTYPE_INSERT_COMMAND );
1210         return;
1211     }
1212
1213
1214     sal_Bool success = false;
1215     if( bDocument )
1216         success = m_pMyShell->mkfil( nMyCommandIdentifier,
1217                                      m_aUncPath,
1218                                      aInsertArgument.ReplaceExisting,
1219                                      aInsertArgument.Data );
1220     else
1221     {
1222         while( ! success )
1223         {
1224             success = m_pMyShell->mkdir( nMyCommandIdentifier,
1225                                          m_aUncPath,
1226                                          aInsertArgument.ReplaceExisting );
1227             if( success )
1228                 break;
1229
1230             XInteractionRequestImpl *aRequestImpl =
1231                 new XInteractionRequestImpl(
1232                     rtl::Uri::decode(
1233                         getTitle(m_aUncPath),
1234                         rtl_UriDecodeWithCharset,
1235                         RTL_TEXTENCODING_UTF8),
1236                     (cppu::OWeakObject*)this,
1237                     m_pMyShell,nMyCommandIdentifier);
1238             uno::Reference< task::XInteractionRequest > aReq( aRequestImpl );
1239
1240             m_pMyShell->handleTask( nMyCommandIdentifier,aReq );
1241             if(  aRequestImpl->aborted() ||
1242                  aRequestImpl->newName().isEmpty() )
1243                 // means aborting
1244                 break;
1245
1246             // determine new uncpath
1247             m_pMyShell->clearError( nMyCommandIdentifier );
1248             m_aUncPath = getParentName( m_aUncPath );
1249             if( !m_aUncPath.endsWith( "/" ) )
1250                 m_aUncPath += "/";
1251
1252             m_aUncPath += rtl::Uri::encode( aRequestImpl->newName(),
1253                                             rtl_UriCharClassPchar,
1254                                             rtl_UriEncodeIgnoreEscapes,
1255                                             RTL_TEXTENCODING_UTF8 );
1256         }
1257     }
1258
1259     if ( ! success )
1260         return;
1261
1262     FileContentIdentifier* p = new FileContentIdentifier( m_pMyShell,m_aUncPath );
1263     m_xContentIdentifier = Reference< XContentIdentifier >( p );
1264
1265     m_pMyShell->registerNotifier( m_aUncPath,this );
1266     m_pMyShell->insertDefaultProperties( m_aUncPath );
1267
1268     osl::MutexGuard aGuard( m_aMutex );
1269     m_nState = FullFeatured;
1270 }
1271
1272
1273
1274 void SAL_CALL BaseContent::endTask( sal_Int32 CommandId )
1275 {
1276     // This is the only function allowed to throw an exception
1277     m_pMyShell->endTask( CommandId,m_aUncPath,this );
1278 }
1279
1280
1281
1282 ContentEventNotifier*
1283 BaseContent::cDEL( void )
1284 {
1285     osl::MutexGuard aGuard( m_aMutex );
1286
1287     m_nState |= Deleted;
1288
1289     ContentEventNotifier* p;
1290     if( m_pContentEventListeners )
1291         p = new ContentEventNotifier( m_pMyShell,
1292                                       this,
1293                                       m_xContentIdentifier,
1294                                       m_pContentEventListeners->getElements() );
1295     else
1296         p = 0;
1297
1298     return p;
1299 }
1300
1301
1302 ContentEventNotifier*
1303 BaseContent::cEXC( const OUString aNewName )
1304 {
1305     osl::MutexGuard aGuard( m_aMutex );
1306
1307     Reference< XContentIdentifier > xOldRef = m_xContentIdentifier;
1308     m_aUncPath = aNewName;
1309     FileContentIdentifier* pp = new FileContentIdentifier( m_pMyShell,aNewName );
1310     m_xContentIdentifier = Reference< XContentIdentifier >( pp );
1311
1312     ContentEventNotifier* p = 0;
1313     if( m_pContentEventListeners )
1314         p = new ContentEventNotifier( m_pMyShell,
1315                                       this,
1316                                       m_xContentIdentifier,
1317                                       xOldRef,
1318                                       m_pContentEventListeners->getElements() );
1319
1320     return p;
1321 }
1322
1323
1324 ContentEventNotifier*
1325 BaseContent::cCEL( void )
1326 {
1327     osl::MutexGuard aGuard( m_aMutex );
1328     ContentEventNotifier* p = 0;
1329     if( m_pContentEventListeners )
1330         p = new ContentEventNotifier( m_pMyShell,
1331                                       this,
1332                                       m_xContentIdentifier,
1333                                       m_pContentEventListeners->getElements() );
1334
1335     return p;
1336 }
1337
1338 PropertySetInfoChangeNotifier*
1339 BaseContent::cPSL( void )
1340 {
1341     osl::MutexGuard aGuard( m_aMutex );
1342     PropertySetInfoChangeNotifier* p = 0;
1343     if( m_pPropertySetInfoChangeListeners  )
1344         p = new PropertySetInfoChangeNotifier( this,
1345                                                m_xContentIdentifier,
1346                                                m_pPropertySetInfoChangeListeners->getElements() );
1347
1348     return p;
1349 }
1350
1351
1352
1353 PropertyChangeNotifier*
1354 BaseContent::cPCL( void )
1355 {
1356     osl::MutexGuard aGuard( m_aMutex );
1357
1358     Sequence< OUString > seqNames;
1359
1360     if( m_pPropertyListener )
1361         seqNames = m_pPropertyListener->getContainedTypes();
1362
1363     PropertyChangeNotifier* p = 0;
1364
1365     sal_Int32 length = seqNames.getLength();
1366
1367     if( length )
1368     {
1369         ListenerMap* listener = new ListenerMap();
1370         for( sal_Int32 i = 0; i < length; ++i )
1371         {
1372             (*listener)[seqNames[i]] = m_pPropertyListener->getContainer( seqNames[i] )->getElements();
1373         }
1374
1375         p = new PropertyChangeNotifier( this,
1376                                         m_xContentIdentifier,
1377                                         listener );
1378     }
1379
1380     return p;
1381 }
1382
1383
1384 OUString BaseContent::getKey( void )
1385 {
1386     return m_aUncPath;
1387 }
1388
1389 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */