svl/source/fsstor/fsstorage.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 <com/sun/star/beans/PropertyValue.hpp>
  21 #include <com/sun/star/embed/ElementModes.hpp>
  22 #include <com/sun/star/embed/XTransactedObject.hpp>
  23 #include <com/sun/star/ucb/NameClash.hpp>
  24 #include <com/sun/star/ucb/UniversalContentBroker.hpp>
  25 #include <com/sun/star/ucb/XProgressHandler.hpp>
  26 #include <com/sun/star/ucb/XContentAccess.hpp>
  27 #include <com/sun/star/ucb/SimpleFileAccess.hpp>
  28
  29 #include <com/sun/star/ucb/InteractiveIOException.hpp>
  30 #include <com/sun/star/ucb/IOErrorCode.hpp>
  31 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
  32 #include <com/sun/star/container/XEnumerationAccess.hpp>
  33 #include <com/sun/star/container/XNamed.hpp>
  34 #include <com/sun/star/util/XChangesBatch.hpp>
  35 #include <com/sun/star/util/XCloneable.hpp>
  36 #include <com/sun/star/lang/XUnoTunnel.hpp>
  37 #include <com/sun/star/lang/XComponent.hpp>
  38 #include <com/sun/star/lang/DisposedException.hpp>
  39 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  40 #include <com/sun/star/io/IOException.hpp>
  41 #include <com/sun/star/io/XTruncate.hpp>
  42 #include <com/sun/star/io/TempFile.hpp>
  43 #include <com/sun/star/sdbc/XResultSet.hpp>
  44 #include <com/sun/star/sdbc/XRow.hpp>
  45
  46
  47 #include <comphelper/processfactory.hxx>
  48 #include <comphelper/storagehelper.hxx>
  49 #include <cppuhelper/typeprovider.hxx>
  50 #include <cppuhelper/exc_hlp.hxx>
  51
  52 #include <tools/urlobj.hxx>
  53 #include <unotools/ucbhelper.hxx>
  54 #include <unotools/ucbstreamhelper.hxx>
  55 #include <unotools/streamwrap.hxx>
  56 #include <ucbhelper/fileidentifierconverter.hxx>
  57 #include <ucbhelper/content.hxx>
  58
  59 #include "fsstorage.hxx"
  60 #include "oinputstreamcontainer.hxx"
  61 #include "ostreamcontainer.hxx"
  62
  63 using namespace ::com::sun::star;
  64
  65 //=========================================================
  66
  67 // TODO: move to a standard helper
  68 sal_Bool isLocalFile_Impl( OUString aURL )
  69 {
  70     OUString aSystemPath;
  71
  72     try
  73     {
  74         aSystemPath = ::ucbhelper::getSystemPathFromFileURL(
  75             ucb::UniversalContentBroker::create(
  76                 comphelper::getProcessComponentContext() ),
  77             aURL );
  78     }
  79     catch ( uno::Exception& )
  80     {
  81     }
  82
  83     return ( !aSystemPath.isEmpty() );
  84 }
  85
  86
  87 //=========================================================
  88
  89 struct FSStorage_Impl
  90 {
  91     OUString m_aURL;
  92
  93     ::ucbhelper::Content* m_pContent;
  94     sal_Int32 m_nMode;
  95
  96     ::cppu::OInterfaceContainerHelper* m_pListenersContainer; // list of listeners
  97     ::cppu::OTypeCollection* m_pTypeCollection;
  98
  99     uno::Reference< lang::XMultiServiceFactory > m_xFactory;
 100
 101
 102     FSStorage_Impl( const OUString& aURL, sal_Int32 nMode, uno::Reference< lang::XMultiServiceFactory > xFactory )
 103     : m_aURL( aURL )
 104     , m_pContent( NULL )
 105     , m_nMode( nMode )
 106     , m_pListenersContainer( NULL )
 107     , m_pTypeCollection( NULL )
 108     , m_xFactory( xFactory )
 109     {
 110         OSL_ENSURE( !m_aURL.isEmpty(), "The URL must not be empty" );
 111     }
 112
 113     FSStorage_Impl( const ::ucbhelper::Content& aContent, sal_Int32 nMode, uno::Reference< lang::XMultiServiceFactory > xFactory )
 114     : m_aURL( aContent.getURL() )
 115     , m_pContent( new ::ucbhelper::Content( aContent ) )
 116     , m_nMode( nMode )
 117     , m_pListenersContainer( NULL )
 118     , m_pTypeCollection( NULL )
 119     , m_xFactory( xFactory )
 120     {
 121         OSL_ENSURE( !m_aURL.isEmpty(), "The URL must not be empty" );
 122     }
 123
 124     ~FSStorage_Impl();
 125 };
 126
 127 //=========================================================
 128
 129 FSStorage_Impl::~FSStorage_Impl()
 130 {
 131     if ( m_pListenersContainer )
 132         delete m_pListenersContainer;
 133     if ( m_pTypeCollection )
 134         delete m_pTypeCollection;
 135     if ( m_pContent )
 136         delete m_pContent;
 137 }
 138
 139 //=====================================================
 140 // FSStorage implementation
 141 //=====================================================
 142
 143 //-----------------------------------------------
 144 FSStorage::FSStorage( const ::ucbhelper::Content& aContent,
 145                     sal_Int32 nMode,
 146                     uno::Reference< lang::XMultiServiceFactory > xFactory )
 147 : m_pImpl( new FSStorage_Impl( aContent, nMode, xFactory ) )
 148 {
 149     // TODO: use properties
 150     if ( !xFactory.is() )
 151         throw uno::RuntimeException();
 152
 153     GetContent();
 154 }
 155
 156 //-----------------------------------------------
 157 FSStorage::~FSStorage()
 158 {
 159     {
 160         ::osl::MutexGuard aGuard( m_aMutex );
 161         m_refCount++; // to call dispose
 162         try {
 163             dispose();
 164         }
 165         catch( uno::RuntimeException& )
 166         {}
 167     }
 168 }
 169
 170 //-----------------------------------------------
 171 sal_Bool FSStorage::MakeFolderNoUI( const OUString& rFolder )
 172 {
 173     INetURLObject aURL( rFolder );
 174     OUString aTitle = aURL.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DECODE_WITH_CHARSET );
 175     aURL.removeSegment();
 176     ::ucbhelper::Content aParent;
 177     ::ucbhelper::Content aResultContent;
 178
 179        if ( ::ucbhelper::Content::create( aURL.GetMainURL( INetURLObject::NO_DECODE ),
 180                                  uno::Reference< ucb::XCommandEnvironment >(),
 181                                  comphelper::getProcessComponentContext(),
 182                                  aParent ) )
 183         return ::utl::UCBContentHelper::MakeFolder( aParent, aTitle, aResultContent, sal_False );
 184
 185     return sal_False;
 186 }
 187
 188 //-----------------------------------------------
 189 ::ucbhelper::Content* FSStorage::GetContent()
 190 {
 191     ::osl::MutexGuard aGuard( m_aMutex );
 192     if ( !m_pImpl->m_pContent )
 193     {
 194         uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
 195
 196         try
 197         {
 198             m_pImpl->m_pContent = new ::ucbhelper::Content( m_pImpl->m_aURL, xDummyEnv, comphelper::getProcessComponentContext() );
 199         }
 200         catch( uno::Exception& )
 201         {
 202         }
 203     }
 204
 205     return m_pImpl->m_pContent;
 206 }
 207
 208 //-----------------------------------------------
 209 void FSStorage::CopyStreamToSubStream( const OUString& aSourceURL,
 210                                         const uno::Reference< embed::XStorage >& xDest,
 211                                         const OUString& aNewEntryName )
 212 {
 213     if ( !xDest.is() )
 214         throw uno::RuntimeException();
 215
 216     uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
 217     ::ucbhelper::Content aSourceContent( aSourceURL, xDummyEnv, comphelper::getProcessComponentContext() );
 218     uno::Reference< io::XInputStream > xSourceInput = aSourceContent.openStream();
 219
 220     if ( !xSourceInput.is() )
 221         throw io::IOException(); // TODO: error handling
 222
 223     uno::Reference< io::XStream > xSubStream = xDest->openStreamElement(
 224                                                 aNewEntryName,
 225                                                 embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE );
 226     if ( !xSubStream.is() )
 227         throw uno::RuntimeException();
 228
 229     uno::Reference< io::XOutputStream > xDestOutput = xSubStream->getOutputStream();
 230     if ( !xDestOutput.is() )
 231         throw uno::RuntimeException();
 232
 233     ::comphelper::OStorageHelper::CopyInputToOutput( xSourceInput, xDestOutput );
 234     xDestOutput->closeOutput();
 235 }
 236
 237 //-----------------------------------------------
 238 void FSStorage::CopyContentToStorage_Impl( ::ucbhelper::Content* pContent, const uno::Reference< embed::XStorage >& xDest )
 239 {
 240     if ( !pContent )
 241         throw uno::RuntimeException();
 242
 243     // get list of contents of the Content
 244     // create cursor for access to children
 245     uno::Sequence< OUString > aProps( 2 );
 246     OUString* pProps = aProps.getArray();
 247     pProps[0] = OUString("TargetURL");
 248     pProps[1] = OUString("IsFolder");
 249     ::ucbhelper::ResultSetInclude eInclude = ::ucbhelper::INCLUDE_FOLDERS_AND_DOCUMENTS;
 250
 251     try
 252     {
 253         uno::Reference< sdbc::XResultSet > xResultSet = pContent->createCursor( aProps, eInclude );
 254         uno::Reference< ucb::XContentAccess > xContentAccess( xResultSet, uno::UNO_QUERY );
 255         uno::Reference< sdbc::XRow > xRow( xResultSet, uno::UNO_QUERY );
 256         if ( xResultSet.is() )
 257         {
 258             // go through the list: insert files as streams, insert folders as substorages using recursion
 259             while ( xResultSet->next() )
 260             {
 261                 OUString aSourceURL( xRow->getString( 1 ) );
 262                 sal_Bool bIsFolder( xRow->getBoolean(2) );
 263
 264                 // TODO/LATER: not sure whether the entry name must be encoded
 265                 OUString aNewEntryName( INetURLObject( aSourceURL ).getName( INetURLObject::LAST_SEGMENT,
 266                                                                                     true,
 267                                                                                     INetURLObject::NO_DECODE ) );
 268                 if ( bIsFolder )
 269                 {
 270                     uno::Reference< embed::XStorage > xSubStorage = xDest->openStorageElement( aNewEntryName,
 271                                                                                                 embed::ElementModes::READWRITE );
 272                     if ( !xSubStorage.is() )
 273                         throw uno::RuntimeException();
 274
 275                     uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
 276                     ::ucbhelper::Content aSourceContent( aSourceURL, xDummyEnv, comphelper::getProcessComponentContext() );
 277                     CopyContentToStorage_Impl( &aSourceContent, xSubStorage );
 278                 }
 279                 else
 280                 {
 281                     CopyStreamToSubStream( aSourceURL, xDest, aNewEntryName );
 282                 }
 283             }
 284         }
 285
 286         uno::Reference< embed::XTransactedObject > xTransact( xDest, uno::UNO_QUERY );
 287         if ( xTransact.is() )
 288             xTransact->commit();
 289     }
 290     catch( ucb::InteractiveIOException& r )
 291     {
 292         if ( r.Code == ucb::IOErrorCode_NOT_EXISTING )
 293             OSL_FAIL( "The folder does not exist!\n" );
 294         else
 295             throw;
 296     }
 297 }
 298
 299 //____________________________________________________________________________________________________
 300 //  XInterface
 301 //____________________________________________________________________________________________________
 302
 303 //-----------------------------------------------
 304 uno::Any SAL_CALL FSStorage::queryInterface( const uno::Type& rType )
 305         throw( uno::RuntimeException )
 306 {
 307     uno::Any aReturn;
 308     aReturn <<= ::cppu::queryInterface
 309                 (   rType
 310                 ,   static_cast<lang::XTypeProvider*> ( this )
 311                 ,   static_cast<embed::XStorage*> ( this )
 312                 ,   static_cast<embed::XHierarchicalStorageAccess*> ( this )
 313                 ,   static_cast<container::XNameAccess*> ( this )
 314                 ,   static_cast<container::XElementAccess*> ( this )
 315                 ,   static_cast<lang::XComponent*> ( this )
 316                 ,   static_cast<beans::XPropertySet*> ( this ) );
 317
 318     if ( aReturn.hasValue() == sal_True )
 319         return aReturn ;
 320
 321     return OWeakObject::queryInterface( rType );
 322 }
 323
 324 //-----------------------------------------------
 325 void SAL_CALL FSStorage::acquire() throw()
 326 {
 327     OWeakObject::acquire();
 328 }
 329
 330 //-----------------------------------------------
 331 void SAL_CALL FSStorage::release() throw()
 332 {
 333     OWeakObject::release();
 334 }
 335
 336 //____________________________________________________________________________________________________
 337 //  XTypeProvider
 338 //____________________________________________________________________________________________________
 339
 340 //-----------------------------------------------
 341 uno::Sequence< uno::Type > SAL_CALL FSStorage::getTypes()
 342         throw( uno::RuntimeException )
 343 {
 344     if ( m_pImpl->m_pTypeCollection == NULL )
 345     {
 346         ::osl::MutexGuard aGuard( m_aMutex );
 347
 348         if ( m_pImpl->m_pTypeCollection == NULL )
 349         {
 350             m_pImpl->m_pTypeCollection = new ::cppu::OTypeCollection
 351                                 (   ::getCppuType( ( const uno::Reference< lang::XTypeProvider >* )NULL )
 352                                 ,   ::getCppuType( ( const uno::Reference< embed::XStorage >* )NULL )
 353                                 ,   ::getCppuType( ( const uno::Reference< embed::XHierarchicalStorageAccess >* )NULL )
 354                                 ,   ::getCppuType( ( const uno::Reference< beans::XPropertySet >* )NULL ) );
 355         }
 356     }
 357
 358     return m_pImpl->m_pTypeCollection->getTypes() ;
 359 }
 360
 361 //-----------------------------------------------
 362 uno::Sequence< sal_Int8 > SAL_CALL FSStorage::getImplementationId()
 363         throw( uno::RuntimeException )
 364 {
 365     static ::cppu::OImplementationId* pID = NULL ;
 366
 367     if ( pID == NULL )
 368     {
 369         ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() ) ;
 370
 371         if ( pID == NULL )
 372         {
 373             static ::cppu::OImplementationId aID( sal_False ) ;
 374             pID = &aID ;
 375         }
 376     }
 377
 378     return pID->getImplementationId() ;
 379
 380 }
 381
 382 //____________________________________________________________________________________________________
 383 //  XStorage
 384 //____________________________________________________________________________________________________
 385
 386 //-----------------------------------------------
 387 void SAL_CALL FSStorage::copyToStorage( const uno::Reference< embed::XStorage >& xDest )
 388         throw ( embed::InvalidStorageException,
 389                 io::IOException,
 390                 lang::IllegalArgumentException,
 391                 embed::StorageWrappedTargetException,
 392                 uno::RuntimeException )
 393 {
 394     ::osl::MutexGuard aGuard( m_aMutex );
 395
 396     if ( !m_pImpl )
 397         throw lang::DisposedException();
 398
 399     if ( !xDest.is() || xDest == uno::Reference< uno::XInterface >( static_cast< OWeakObject*> ( this ), uno::UNO_QUERY ) )
 400         throw lang::IllegalArgumentException(); // TODO:
 401
 402     if ( !GetContent() )
 403         throw io::IOException(); // TODO: error handling
 404
 405     try
 406     {
 407         CopyContentToStorage_Impl( GetContent(), xDest );
 408     }
 409     catch( embed::InvalidStorageException& )
 410     {
 411         throw;
 412     }
 413     catch( lang::IllegalArgumentException& )
 414     {
 415         throw;
 416     }
 417     catch( embed::StorageWrappedTargetException& )
 418     {
 419         throw;
 420     }
 421     catch( io::IOException& )
 422     {
 423         throw;
 424     }
 425     catch( uno::RuntimeException& )
 426     {
 427         throw;
 428     }
 429     catch( uno::Exception& )
 430     {
 431           uno::Any aCaught( ::cppu::getCaughtException() );
 432         throw embed::StorageWrappedTargetException( OUString("Can't copy raw stream"),
 433                                                  uno::Reference< io::XInputStream >(),
 434                                                  aCaught );
 435     }
 436 }
 437
 438 //-----------------------------------------------
 439 uno::Reference< io::XStream > SAL_CALL FSStorage::openStreamElement(
 440     const OUString& aStreamName, sal_Int32 nOpenMode )
 441         throw ( embed::InvalidStorageException,
 442                 lang::IllegalArgumentException,
 443                 packages::WrongPasswordException,
 444                 io::IOException,
 445                 embed::StorageWrappedTargetException,
 446                 uno::RuntimeException )
 447 {
 448     ::osl::MutexGuard aGuard( m_aMutex );
 449
 450     if ( !m_pImpl )
 451         throw lang::DisposedException();
 452
 453     if ( !GetContent() )
 454         throw io::IOException(); // TODO: error handling
 455
 456     // TODO/LATER: may need possibility to create folder if it was removed, since the folder can not be locked
 457     INetURLObject aFileURL( m_pImpl->m_aURL );
 458     aFileURL.Append( aStreamName );
 459
 460     if ( ::utl::UCBContentHelper::IsFolder( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 461         throw io::IOException();
 462
 463     if ( ( nOpenMode & embed::ElementModes::NOCREATE )
 464       && !::utl::UCBContentHelper::IsDocument( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 465         throw io::IOException(); // TODO:
 466
 467     uno::Reference< ucb::XCommandEnvironment > xDummyEnv; // TODO: provide InteractionHandler if any
 468     uno::Reference< io::XStream > xResult;
 469     try
 470     {
 471         if ( nOpenMode & embed::ElementModes::WRITE )
 472         {
 473             if ( isLocalFile_Impl( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 474             {
 475                 uno::Reference<ucb::XSimpleFileAccess3> xSimpleFileAccess(
 476                     ucb::SimpleFileAccess::create(
 477                         comphelper::getComponentContext(m_pImpl->m_xFactory) ) );
 478                 xResult = xSimpleFileAccess->openFileReadWrite( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) );
 479             }
 480             else
 481             {
 482                 // TODO: test whether it really works for http and fwp
 483                 SvStream* pStream = ::utl::UcbStreamHelper::CreateStream( aFileURL.GetMainURL( INetURLObject::NO_DECODE ),
 484                                                                           STREAM_STD_WRITE );
 485                 if ( pStream )
 486                 {
 487                     if ( !pStream->GetError() )
 488                         xResult = uno::Reference < io::XStream >( new ::utl::OStreamWrapper( *pStream ) );
 489                     else
 490                         delete pStream;
 491                 }
 492             }
 493
 494             if ( !xResult.is() )
 495                 throw io::IOException();
 496
 497             if ( ( nOpenMode & embed::ElementModes::TRUNCATE ) )
 498             {
 499                 uno::Reference< io::XTruncate > xTrunc( xResult->getOutputStream(), uno::UNO_QUERY_THROW );
 500                 xTrunc->truncate();
 501             }
 502         }
 503         else
 504         {
 505             if ( ( nOpenMode & embed::ElementModes::TRUNCATE )
 506               || !::utl::UCBContentHelper::IsDocument( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 507                 throw io::IOException(); // TODO: access denied
 508
 509             ::ucbhelper::Content aResultContent( aFileURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv, comphelper::getProcessComponentContext() );
 510             uno::Reference< io::XInputStream > xInStream = aResultContent.openStream();
 511             xResult = static_cast< io::XStream* >( new OFSInputStreamContainer( xInStream ) );
 512         }
 513     }
 514     catch( embed::InvalidStorageException& )
 515     {
 516         throw;
 517     }
 518     catch( lang::IllegalArgumentException& )
 519     {
 520         throw;
 521     }
 522     catch( packages::WrongPasswordException& )
 523     {
 524         throw;
 525     }
 526     catch( embed::StorageWrappedTargetException& )
 527     {
 528         throw;
 529     }
 530     catch( io::IOException& )
 531     {
 532         throw;
 533     }
 534     catch( uno::RuntimeException& )
 535     {
 536         throw;
 537     }
 538     catch( uno::Exception& )
 539     {
 540           uno::Any aCaught( ::cppu::getCaughtException() );
 541         throw embed::StorageWrappedTargetException( OUString("Can't copy raw stream"),
 542                                                  uno::Reference< io::XInputStream >(),
 543                                                  aCaught );
 544     }
 545
 546     return xResult;
 547 }
 548
 549 //-----------------------------------------------
 550 uno::Reference< io::XStream > SAL_CALL FSStorage::openEncryptedStreamElement(
 551     const OUString&, sal_Int32, const OUString& )
 552         throw ( embed::InvalidStorageException,
 553                 lang::IllegalArgumentException,
 554                 packages::NoEncryptionException,
 555                 packages::WrongPasswordException,
 556                 io::IOException,
 557                 embed::StorageWrappedTargetException,
 558                 uno::RuntimeException )
 559 {
 560     throw packages::NoEncryptionException();
 561 }
 562
 563 //-----------------------------------------------
 564 uno::Reference< embed::XStorage > SAL_CALL FSStorage::openStorageElement(
 565             const OUString& aStorName, sal_Int32 nStorageMode )
 566         throw ( embed::InvalidStorageException,
 567                 lang::IllegalArgumentException,
 568                 io::IOException,
 569                 embed::StorageWrappedTargetException,
 570                 uno::RuntimeException )
 571 {
 572     ::osl::MutexGuard aGuard( m_aMutex );
 573
 574     if ( !m_pImpl )
 575         throw lang::DisposedException();
 576
 577     if ( !GetContent() )
 578         throw io::IOException(); // TODO: error handling
 579
 580     if ( ( nStorageMode & embed::ElementModes::WRITE )
 581       && !( m_pImpl->m_nMode & embed::ElementModes::WRITE ) )
 582           throw io::IOException(); // TODO: error handling
 583
 584     // TODO/LATER: may need possibility to create folder if it was removed, since the folder can not be locked
 585     INetURLObject aFolderURL( m_pImpl->m_aURL );
 586     aFolderURL.Append( aStorName );
 587
 588     sal_Bool bFolderExists = ::utl::UCBContentHelper::IsFolder( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) );
 589     if ( !bFolderExists && ::utl::UCBContentHelper::IsDocument( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 590         throw io::IOException(); // TODO:
 591
 592     if ( ( nStorageMode & embed::ElementModes::NOCREATE ) && !bFolderExists )
 593         throw io::IOException(); // TODO:
 594
 595     uno::Reference< ucb::XCommandEnvironment > xDummyEnv; // TODO: provide InteractionHandler if any
 596     uno::Reference< embed::XStorage > xResult;
 597     try
 598     {
 599         if ( nStorageMode & embed::ElementModes::WRITE )
 600         {
 601             if ( ( nStorageMode & embed::ElementModes::TRUNCATE ) && bFolderExists )
 602             {
 603                 ::utl::UCBContentHelper::Kill( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) );
 604                 bFolderExists =
 605                     MakeFolderNoUI( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) ); // TODO: not atomic :(
 606             }
 607             else if ( !bFolderExists )
 608             {
 609                 bFolderExists =
 610                     MakeFolderNoUI( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) ); // TODO: not atomic :(
 611             }
 612         }
 613         else if ( ( nStorageMode & embed::ElementModes::TRUNCATE ) )
 614             throw io::IOException(); // TODO: access denied
 615
 616         if ( !bFolderExists )
 617             throw io::IOException(); // there is no such folder
 618
 619         ::ucbhelper::Content aResultContent( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv, comphelper::getProcessComponentContext() );
 620         xResult = uno::Reference< embed::XStorage >(
 621                             static_cast< OWeakObject* >( new FSStorage( aResultContent,
 622                                                                         nStorageMode,
 623                                                                         m_pImpl->m_xFactory ) ),
 624                             uno::UNO_QUERY );
 625     }
 626     catch( embed::InvalidStorageException& )
 627     {
 628         throw;
 629     }
 630     catch( lang::IllegalArgumentException& )
 631     {
 632         throw;
 633     }
 634     catch( embed::StorageWrappedTargetException& )
 635     {
 636         throw;
 637     }
 638     catch( io::IOException& )
 639     {
 640         throw;
 641     }
 642     catch( uno::RuntimeException& )
 643     {
 644         throw;
 645     }
 646     catch( uno::Exception& )
 647     {
 648           uno::Any aCaught( ::cppu::getCaughtException() );
 649         throw embed::StorageWrappedTargetException( OUString("Can't copy raw stream"),
 650                                                  uno::Reference< io::XInputStream >(),
 651                                                  aCaught );
 652     }
 653
 654     return xResult;
 655 }
 656
 657 //-----------------------------------------------
 658 uno::Reference< io::XStream > SAL_CALL FSStorage::cloneStreamElement( const OUString& aStreamName )
 659         throw ( embed::InvalidStorageException,
 660                 lang::IllegalArgumentException,
 661                 packages::WrongPasswordException,
 662                 io::IOException,
 663                 embed::StorageWrappedTargetException,
 664                 uno::RuntimeException )
 665 {
 666     ::osl::MutexGuard aGuard( m_aMutex );
 667
 668     if ( !m_pImpl )
 669         throw lang::DisposedException();
 670
 671     if ( !GetContent() )
 672         throw io::IOException(); // TODO: error handling
 673
 674     // TODO/LATER: may need possibility to create folder if it was removed, since the folder can not be locked
 675     INetURLObject aFileURL( m_pImpl->m_aURL );
 676     aFileURL.Append( aStreamName );
 677
 678     uno::Reference < io::XStream > xTempResult;
 679     try
 680     {
 681         uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
 682         ::ucbhelper::Content aResultContent( aFileURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv, comphelper::getProcessComponentContext() );
 683         uno::Reference< io::XInputStream > xInStream = aResultContent.openStream();
 684
 685         xTempResult = uno::Reference < io::XStream >(
 686                     io::TempFile::create(comphelper::getComponentContext(m_pImpl->m_xFactory)),
 687                     uno::UNO_QUERY_THROW );
 688         uno::Reference < io::XOutputStream > xTempOut = xTempResult->getOutputStream();
 689         uno::Reference < io::XInputStream > xTempIn = xTempResult->getInputStream();
 690
 691         if ( !xTempOut.is() || !xTempIn.is() )
 692             throw io::IOException();
 693
 694         ::comphelper::OStorageHelper::CopyInputToOutput( xInStream, xTempOut );
 695         xTempOut->closeOutput();
 696     }
 697     catch( embed::InvalidStorageException& )
 698     {
 699         throw;
 700     }
 701     catch( lang::IllegalArgumentException& )
 702     {
 703         throw;
 704     }
 705     catch( packages::WrongPasswordException& )
 706     {
 707         throw;
 708     }
 709     catch( io::IOException& )
 710     {
 711         throw;
 712     }
 713     catch( embed::StorageWrappedTargetException& )
 714     {
 715         throw;
 716     }
 717     catch( uno::RuntimeException& )
 718     {
 719         throw;
 720     }
 721     catch( uno::Exception& )
 722     {
 723           uno::Any aCaught( ::cppu::getCaughtException() );
 724         throw embed::StorageWrappedTargetException( OUString("Can't copy raw stream"),
 725                                                  uno::Reference< io::XInputStream >(),
 726                                                  aCaught );
 727     }
 728
 729     return xTempResult;
 730 }
 731
 732 //-----------------------------------------------
 733 uno::Reference< io::XStream > SAL_CALL FSStorage::cloneEncryptedStreamElement(
 734     const OUString&,
 735     const OUString& )
 736         throw ( embed::InvalidStorageException,
 737                 lang::IllegalArgumentException,
 738                 packages::NoEncryptionException,
 739                 packages::WrongPasswordException,
 740                 io::IOException,
 741                 embed::StorageWrappedTargetException,
 742                 uno::RuntimeException )
 743 {
 744     throw packages::NoEncryptionException();
 745 }
 746
 747 //-----------------------------------------------
 748 void SAL_CALL FSStorage::copyLastCommitTo(
 749             const uno::Reference< embed::XStorage >& xTargetStorage )
 750         throw ( embed::InvalidStorageException,
 751                 lang::IllegalArgumentException,
 752                 io::IOException,
 753                 embed::StorageWrappedTargetException,
 754                 uno::RuntimeException )
 755 {
 756     copyToStorage( xTargetStorage );
 757 }
 758
 759 //-----------------------------------------------
 760 void SAL_CALL FSStorage::copyStorageElementLastCommitTo(
 761             const OUString& aStorName,
 762             const uno::Reference< embed::XStorage >& xTargetStorage )
 763         throw ( embed::InvalidStorageException,
 764                 lang::IllegalArgumentException,
 765                 io::IOException,
 766                 embed::StorageWrappedTargetException,
 767                 uno::RuntimeException )
 768 {
 769     ::osl::MutexGuard aGuard( m_aMutex );
 770
 771     if ( !m_pImpl )
 772         throw lang::DisposedException();
 773
 774     uno::Reference< embed::XStorage > xSourceStor( openStorageElement( aStorName, embed::ElementModes::READ ),
 775                                                     uno::UNO_QUERY_THROW );
 776     xSourceStor->copyToStorage( xTargetStorage );
 777 }
 778
 779 //-----------------------------------------------
 780 sal_Bool SAL_CALL FSStorage::isStreamElement( const OUString& aElementName )
 781         throw ( embed::InvalidStorageException,
 782                 lang::IllegalArgumentException,
 783                 container::NoSuchElementException,
 784                 uno::RuntimeException )
 785 {
 786     ::osl::MutexGuard aGuard( m_aMutex );
 787
 788     if ( !m_pImpl )
 789         throw lang::DisposedException();
 790
 791     if ( !GetContent() )
 792         throw embed::InvalidStorageException(); // TODO: error handling
 793
 794     INetURLObject aURL( m_pImpl->m_aURL );
 795     aURL.Append( aElementName );
 796
 797     return !::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
 798 }
 799
 800 //-----------------------------------------------
 801 sal_Bool SAL_CALL FSStorage::isStorageElement( const OUString& aElementName )
 802         throw ( embed::InvalidStorageException,
 803                 lang::IllegalArgumentException,
 804                 container::NoSuchElementException,
 805                 uno::RuntimeException )
 806 {
 807     ::osl::MutexGuard aGuard( m_aMutex );
 808
 809     if ( !m_pImpl )
 810         throw lang::DisposedException();
 811
 812     if ( !GetContent() )
 813         throw embed::InvalidStorageException(); // TODO: error handling
 814
 815     INetURLObject aURL( m_pImpl->m_aURL );
 816     aURL.Append( aElementName );
 817
 818     return ::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
 819 }
 820
 821 //-----------------------------------------------
 822 void SAL_CALL FSStorage::removeElement( const OUString& aElementName )
 823         throw ( embed::InvalidStorageException,
 824                 lang::IllegalArgumentException,
 825                 container::NoSuchElementException,
 826                 io::IOException,
 827                 embed::StorageWrappedTargetException,
 828                 uno::RuntimeException )
 829 {
 830     ::osl::MutexGuard aGuard( m_aMutex );
 831
 832     if ( !m_pImpl )
 833         throw lang::DisposedException();
 834
 835     if ( !GetContent() )
 836         throw io::IOException(); // TODO: error handling
 837
 838     INetURLObject aURL( m_pImpl->m_aURL );
 839     aURL.Append( aElementName );
 840
 841     if ( !::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) )
 842       && !::utl::UCBContentHelper::IsDocument( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 843         throw container::NoSuchElementException(); // TODO:
 844
 845     ::utl::UCBContentHelper::Kill( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
 846 }
 847
 848 //-----------------------------------------------
 849 void SAL_CALL FSStorage::renameElement( const OUString& aElementName, const OUString& aNewName )
 850         throw ( embed::InvalidStorageException,
 851                 lang::IllegalArgumentException,
 852                 container::NoSuchElementException,
 853                 container::ElementExistException,
 854                 io::IOException,
 855                 embed::StorageWrappedTargetException,
 856                 uno::RuntimeException )
 857 {
 858     ::osl::MutexGuard aGuard( m_aMutex );
 859
 860     if ( !m_pImpl )
 861         throw lang::DisposedException();
 862
 863     if ( !GetContent() )
 864         throw io::IOException(); // TODO: error handling
 865
 866     INetURLObject aOldURL( m_pImpl->m_aURL );
 867     aOldURL.Append( aElementName );
 868
 869     INetURLObject aNewURL( m_pImpl->m_aURL );
 870     aNewURL.Append( aNewName );
 871
 872     if ( !::utl::UCBContentHelper::IsFolder( aOldURL.GetMainURL( INetURLObject::NO_DECODE ) )
 873       && !::utl::UCBContentHelper::IsDocument( aOldURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 874         throw container::NoSuchElementException(); // TODO:
 875
 876     if ( ::utl::UCBContentHelper::IsFolder( aNewURL.GetMainURL( INetURLObject::NO_DECODE ) )
 877       || ::utl::UCBContentHelper::IsDocument( aNewURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 878           throw container::ElementExistException(); // TODO:
 879
 880     try
 881     {
 882         uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
 883         ::ucbhelper::Content aSourceContent( aOldURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv, comphelper::getProcessComponentContext() );
 884
 885         if ( !GetContent()->transferContent( aSourceContent,
 886                                             ::ucbhelper::InsertOperation_MOVE,
 887                                             aNewName,
 888                                             ucb::NameClash::ERROR ) )
 889             throw io::IOException(); // TODO: error handling
 890     }
 891     catch( embed::InvalidStorageException& )
 892     {
 893         throw;
 894     }
 895     catch( lang::IllegalArgumentException& )
 896     {
 897         throw;
 898     }
 899     catch( container::NoSuchElementException& )
 900     {
 901         throw;
 902     }
 903     catch( container::ElementExistException& )
 904     {
 905         throw;
 906     }
 907     catch( io::IOException& )
 908     {
 909         throw;
 910     }
 911     catch( embed::StorageWrappedTargetException& )
 912     {
 913         throw;
 914     }
 915     catch( uno::RuntimeException& )
 916     {
 917         throw;
 918     }
 919     catch( uno::Exception& )
 920     {
 921           uno::Any aCaught( ::cppu::getCaughtException() );
 922         throw embed::StorageWrappedTargetException( OUString("Can't copy raw stream"),
 923                                                  uno::Reference< io::XInputStream >(),
 924                                                  aCaught );
 925     }
 926 }
 927
 928 //-----------------------------------------------
 929 void SAL_CALL FSStorage::copyElementTo( const OUString& aElementName,
 930                                         const uno::Reference< embed::XStorage >& xDest,
 931                                         const OUString& aNewName )
 932         throw ( embed::InvalidStorageException,
 933                 lang::IllegalArgumentException,
 934                 container::NoSuchElementException,
 935                 container::ElementExistException,
 936                 io::IOException,
 937                 embed::StorageWrappedTargetException,
 938                 uno::RuntimeException )
 939 {
 940     ::osl::MutexGuard aGuard( m_aMutex );
 941
 942     if ( !m_pImpl )
 943         throw lang::DisposedException();
 944
 945     if ( !xDest.is() )
 946         throw uno::RuntimeException();
 947
 948     if ( !GetContent() )
 949         throw io::IOException(); // TODO: error handling
 950
 951     INetURLObject aOwnURL( m_pImpl->m_aURL );
 952     aOwnURL.Append( aElementName );
 953
 954     if ( xDest->hasByName( aNewName ) )
 955           throw container::ElementExistException(); // TODO:
 956
 957     try
 958     {
 959         uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
 960         if ( ::utl::UCBContentHelper::IsFolder( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 961         {
 962             ::ucbhelper::Content aSourceContent( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv, comphelper::getProcessComponentContext() );
 963             uno::Reference< embed::XStorage > xDestSubStor(
 964                                     xDest->openStorageElement( aNewName, embed::ElementModes::READWRITE ),
 965                                     uno::UNO_QUERY_THROW );
 966
 967             CopyContentToStorage_Impl( &aSourceContent, xDestSubStor );
 968         }
 969         else if ( ::utl::UCBContentHelper::IsDocument( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
 970         {
 971             CopyStreamToSubStream( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ), xDest, aNewName );
 972         }
 973         else
 974             throw container::NoSuchElementException(); // TODO:
 975     }
 976     catch( embed::InvalidStorageException& )
 977     {
 978         throw;
 979     }
 980     catch( lang::IllegalArgumentException& )
 981     {
 982         throw;
 983     }
 984     catch( container::NoSuchElementException& )
 985     {
 986         throw;
 987     }
 988     catch( container::ElementExistException& )
 989     {
 990         throw;
 991     }
 992     catch( embed::StorageWrappedTargetException& )
 993     {
 994         throw;
 995     }
 996     catch( io::IOException& )
 997     {
 998         throw;
 999     }
1000     catch( uno::RuntimeException& )
1001     {
1002         throw;
1003     }
1004     catch( uno::Exception& )
1005     {
1006           uno::Any aCaught( ::cppu::getCaughtException() );
1007         throw embed::StorageWrappedTargetException( OUString("Can't copy raw stream"),
1008                                                  uno::Reference< io::XInputStream >(),
1009                                                  aCaught );
1010     }
1011 }
1012
1013 //-----------------------------------------------
1014 void SAL_CALL FSStorage::moveElementTo( const OUString& aElementName,
1015                                         const uno::Reference< embed::XStorage >& xDest,
1016                                         const OUString& aNewName )
1017         throw ( embed::InvalidStorageException,
1018                 lang::IllegalArgumentException,
1019                 container::NoSuchElementException,
1020                 container::ElementExistException,
1021                 io::IOException,
1022                 embed::StorageWrappedTargetException,
1023                 uno::RuntimeException )
1024 {
1025     ::osl::MutexGuard aGuard( m_aMutex );
1026     copyElementTo( aElementName, xDest, aNewName );
1027
1028     INetURLObject aOwnURL( m_pImpl->m_aURL );
1029     aOwnURL.Append( aElementName );
1030     if ( !::utl::UCBContentHelper::Kill( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
1031         throw io::IOException(); // TODO: error handling
1032 }
1033
1034 //____________________________________________________________________________________________________
1035 //  XNameAccess
1036 //____________________________________________________________________________________________________
1037
1038 //-----------------------------------------------
1039 uno::Any SAL_CALL FSStorage::getByName( const OUString& aName )
1040         throw ( container::NoSuchElementException,
1041                 lang::WrappedTargetException,
1042                 uno::RuntimeException )
1043 {
1044     ::osl::MutexGuard aGuard( m_aMutex );
1045
1046     if ( !m_pImpl )
1047         throw lang::DisposedException();
1048
1049     if ( !GetContent() )
1050         throw io::IOException(); // TODO: error handling
1051
1052     if ( aName.isEmpty() )
1053         throw lang::IllegalArgumentException();
1054
1055     INetURLObject aURL( m_pImpl->m_aURL );
1056     aURL.Append( aName );
1057
1058     uno::Any aResult;
1059     try
1060     {
1061         if ( ::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
1062         {
1063             aResult <<= openStorageElement( aName, embed::ElementModes::READ );
1064         }
1065         else if ( ::utl::UCBContentHelper::IsDocument( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
1066         {
1067             aResult <<= openStreamElement( aName, embed::ElementModes::READ );
1068         }
1069         else
1070             throw container::NoSuchElementException(); // TODO:
1071     }
1072     catch( container::NoSuchElementException& )
1073     {
1074         throw;
1075     }
1076     catch( lang::WrappedTargetException& )
1077     {
1078         throw;
1079     }
1080     catch( uno::RuntimeException& )
1081     {
1082         throw;
1083     }
1084     catch ( uno::Exception& )
1085     {
1086            uno::Any aCaught( ::cppu::getCaughtException() );
1087         throw lang::WrappedTargetException( OUString("Can not open element!\n"),
1088                                             uno::Reference< uno::XInterface >(  static_cast< OWeakObject* >( this ),
1089                                                                                 uno::UNO_QUERY ),
1090                                             aCaught );
1091     }
1092
1093     return aResult;
1094 }
1095
1096
1097 //-----------------------------------------------
1098 uno::Sequence< OUString > SAL_CALL FSStorage::getElementNames()
1099         throw ( uno::RuntimeException )
1100 {
1101     ::osl::MutexGuard aGuard( m_aMutex );
1102
1103     if ( !m_pImpl )
1104         throw lang::DisposedException();
1105
1106     if ( !GetContent() )
1107         throw io::IOException(); // TODO: error handling
1108
1109     uno::Sequence< OUString > aProps( 1 );
1110     OUString* pProps = aProps.getArray();
1111     pProps[0] = OUString("Title");
1112     ::ucbhelper::ResultSetInclude eInclude = ::ucbhelper::INCLUDE_FOLDERS_AND_DOCUMENTS;
1113
1114     uno::Sequence< OUString > aResult;
1115     sal_Int32 nSize = 0;
1116
1117     try
1118     {
1119         uno::Reference< sdbc::XResultSet > xResultSet = GetContent()->createCursor( aProps, eInclude );
1120         uno::Reference< ucb::XContentAccess > xContentAccess( xResultSet, uno::UNO_QUERY );
1121         uno::Reference< sdbc::XRow > xRow( xResultSet, uno::UNO_QUERY );
1122         if ( xResultSet.is() )
1123         {
1124             // go through the list
1125             while ( xResultSet->next() )
1126             {
1127                 OUString aName( xRow->getString( 1 ) );
1128                 aResult.realloc( ++nSize );
1129                 aResult[nSize-1] = aName;
1130             }
1131         }
1132     }
1133     catch( const ucb::InteractiveIOException& r )
1134     {
1135         if ( r.Code == ucb::IOErrorCode_NOT_EXISTING )
1136             OSL_FAIL( "The folder does not exist!\n" );
1137         else
1138         {
1139                uno::Any aCaught( ::cppu::getCaughtException() );
1140             throw lang::WrappedTargetRuntimeException( OUString("Can not open storage!\n"),
1141                                             uno::Reference< uno::XInterface >(  static_cast< OWeakObject* >( this ),
1142                                                                                 uno::UNO_QUERY ),
1143                                             aCaught );
1144         }
1145     }
1146     catch( uno::RuntimeException& )
1147     {
1148         throw;
1149     }
1150     catch ( uno::Exception& )
1151     {
1152            uno::Any aCaught( ::cppu::getCaughtException() );
1153         throw lang::WrappedTargetRuntimeException( OUString("Can not open storage!\n"),
1154                                             uno::Reference< uno::XInterface >(  static_cast< OWeakObject* >( this ),
1155                                                                                 uno::UNO_QUERY ),
1156                                             aCaught );
1157     }
1158
1159     return aResult;
1160 }
1161
1162
1163 //-----------------------------------------------
1164 sal_Bool SAL_CALL FSStorage::hasByName( const OUString& aName )
1165         throw ( uno::RuntimeException )
1166 {
1167     ::osl::MutexGuard aGuard( m_aMutex );
1168
1169     if ( !m_pImpl )
1170         throw lang::DisposedException();
1171
1172     try
1173     {
1174         if ( !GetContent() )
1175             throw io::IOException(); // TODO: error handling
1176
1177         if ( aName.isEmpty() )
1178             throw lang::IllegalArgumentException();
1179     }
1180     catch( uno::RuntimeException& )
1181     {
1182         throw;
1183     }
1184     catch ( uno::Exception& )
1185     {
1186            uno::Any aCaught( ::cppu::getCaughtException() );
1187         throw lang::WrappedTargetRuntimeException( OUString("Can not open storage!\n"),
1188                                             uno::Reference< uno::XInterface >(  static_cast< OWeakObject* >( this ),
1189                                                                                 uno::UNO_QUERY ),
1190                                             aCaught );
1191     }
1192
1193     INetURLObject aURL( m_pImpl->m_aURL );
1194     aURL.Append( aName );
1195
1196     return ( ::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) )
1197       || ::utl::UCBContentHelper::IsDocument( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) );
1198 }
1199
1200 //-----------------------------------------------
1201 uno::Type SAL_CALL FSStorage::getElementType()
1202         throw ( uno::RuntimeException )
1203 {
1204     ::osl::MutexGuard aGuard( m_aMutex );
1205
1206     if ( !m_pImpl )
1207         throw lang::DisposedException();
1208
1209     // it is a multitype container
1210     return uno::Type();
1211 }
1212
1213 //-----------------------------------------------
1214 sal_Bool SAL_CALL FSStorage::hasElements()
1215         throw ( uno::RuntimeException )
1216 {
1217     ::osl::MutexGuard aGuard( m_aMutex );
1218
1219     if ( !m_pImpl )
1220         throw lang::DisposedException();
1221
1222     if ( !GetContent() )
1223         throw io::IOException(); // TODO: error handling
1224
1225     uno::Sequence< OUString > aProps( 1 );
1226     aProps[0] = OUString("TargetURL");
1227     ::ucbhelper::ResultSetInclude eInclude = ::ucbhelper::INCLUDE_FOLDERS_AND_DOCUMENTS;
1228
1229     try
1230     {
1231         uno::Reference< sdbc::XResultSet > xResultSet = GetContent()->createCursor( aProps, eInclude );
1232         return ( xResultSet.is() && xResultSet->next() );
1233     }
1234     catch( uno::Exception& )
1235     {
1236         throw uno::RuntimeException();
1237     }
1238 }
1239
1240
1241 //____________________________________________________________________________________________________
1242 //  XDisposable
1243 //____________________________________________________________________________________________________
1244
1245 //-----------------------------------------------
1246 void SAL_CALL FSStorage::dispose()
1247         throw ( uno::RuntimeException )
1248 {
1249     ::osl::MutexGuard aGuard( m_aMutex );
1250
1251     if ( !m_pImpl )
1252         throw lang::DisposedException();
1253
1254     if ( m_pImpl->m_pListenersContainer )
1255     {
1256            lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >(this) );
1257         m_pImpl->m_pListenersContainer->disposeAndClear( aSource );
1258     }
1259
1260     delete m_pImpl;
1261     m_pImpl = NULL;
1262 }
1263
1264 //-----------------------------------------------
1265 void SAL_CALL FSStorage::addEventListener(
1266             const uno::Reference< lang::XEventListener >& xListener )
1267         throw ( uno::RuntimeException )
1268 {
1269     ::osl::MutexGuard aGuard( m_aMutex );
1270
1271     if ( !m_pImpl )
1272         throw lang::DisposedException();
1273
1274     if ( !m_pImpl->m_pListenersContainer )
1275         m_pImpl->m_pListenersContainer = new ::cppu::OInterfaceContainerHelper( m_aMutex );
1276
1277     m_pImpl->m_pListenersContainer->addInterface( xListener );
1278 }
1279
1280 //-----------------------------------------------
1281 void SAL_CALL FSStorage::removeEventListener(
1282             const uno::Reference< lang::XEventListener >& xListener )
1283         throw ( uno::RuntimeException )
1284 {
1285     ::osl::MutexGuard aGuard( m_aMutex );
1286
1287     if ( !m_pImpl )
1288         throw lang::DisposedException();
1289
1290     if ( m_pImpl->m_pListenersContainer )
1291         m_pImpl->m_pListenersContainer->removeInterface( xListener );
1292 }
1293
1294 //____________________________________________________________________________________________________
1295 //  XPropertySet
1296 //____________________________________________________________________________________________________
1297
1298 //-----------------------------------------------
1299 uno::Reference< beans::XPropertySetInfo > SAL_CALL FSStorage::getPropertySetInfo()
1300         throw ( uno::RuntimeException )
1301 {
1302     ::osl::MutexGuard aGuard( m_aMutex );
1303
1304     if ( !m_pImpl )
1305         throw lang::DisposedException();
1306
1307     //TODO:
1308     return uno::Reference< beans::XPropertySetInfo >();
1309 }
1310
1311
1312 //-----------------------------------------------
1313 void SAL_CALL FSStorage::setPropertyValue( const OUString& aPropertyName, const uno::Any& )
1314         throw ( beans::UnknownPropertyException,
1315                 beans::PropertyVetoException,
1316                 lang::IllegalArgumentException,
1317                 lang::WrappedTargetException,
1318                 uno::RuntimeException )
1319 {
1320     ::osl::MutexGuard aGuard( m_aMutex );
1321
1322     if ( !m_pImpl )
1323         throw lang::DisposedException();
1324
1325     if ( aPropertyName == "URL" || aPropertyName == "OpenMode" )
1326         throw beans::PropertyVetoException(); // TODO
1327     else
1328         throw beans::UnknownPropertyException(); // TODO
1329 }
1330
1331
1332 //-----------------------------------------------
1333 uno::Any SAL_CALL FSStorage::getPropertyValue( const OUString& aPropertyName )
1334         throw ( beans::UnknownPropertyException,
1335                 lang::WrappedTargetException,
1336                 uno::RuntimeException )
1337 {
1338     ::osl::MutexGuard aGuard( m_aMutex );
1339
1340     if ( !m_pImpl )
1341         throw lang::DisposedException();
1342
1343     if ( aPropertyName == "URL" )
1344         return uno::makeAny( m_pImpl->m_aURL );
1345     else if ( aPropertyName == "OpenMode" )
1346         return uno::makeAny( m_pImpl->m_nMode );
1347
1348     throw beans::UnknownPropertyException(); // TODO
1349 }
1350
1351
1352 //-----------------------------------------------
1353 void SAL_CALL FSStorage::addPropertyChangeListener(
1354             const OUString& /*aPropertyName*/,
1355             const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/ )
1356         throw ( beans::UnknownPropertyException,
1357                 lang::WrappedTargetException,
1358                 uno::RuntimeException )
1359 {
1360     ::osl::MutexGuard aGuard( m_aMutex );
1361
1362     if ( !m_pImpl )
1363         throw lang::DisposedException();
1364
1365     //TODO:
1366 }
1367
1368
1369 //-----------------------------------------------
1370 void SAL_CALL FSStorage::removePropertyChangeListener(
1371             const OUString& /*aPropertyName*/,
1372             const uno::Reference< beans::XPropertyChangeListener >& /*aListener*/ )
1373         throw ( beans::UnknownPropertyException,
1374                 lang::WrappedTargetException,
1375                 uno::RuntimeException )
1376 {
1377     ::osl::MutexGuard aGuard( m_aMutex );
1378
1379     if ( !m_pImpl )
1380         throw lang::DisposedException();
1381
1382     //TODO:
1383 }
1384
1385
1386 //-----------------------------------------------
1387 void SAL_CALL FSStorage::addVetoableChangeListener(
1388             const OUString& /*PropertyName*/,
1389             const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
1390         throw ( beans::UnknownPropertyException,
1391                 lang::WrappedTargetException,
1392                 uno::RuntimeException )
1393 {
1394     ::osl::MutexGuard aGuard( m_aMutex );
1395
1396     if ( !m_pImpl )
1397         throw lang::DisposedException();
1398
1399     //TODO:
1400 }
1401
1402
1403 //-----------------------------------------------
1404 void SAL_CALL FSStorage::removeVetoableChangeListener(
1405             const OUString& /*PropertyName*/,
1406             const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
1407         throw ( beans::UnknownPropertyException,
1408                 lang::WrappedTargetException,
1409                 uno::RuntimeException )
1410 {
1411     ::osl::MutexGuard aGuard( m_aMutex );
1412
1413     if ( !m_pImpl )
1414         throw lang::DisposedException();
1415
1416     //TODO:
1417 }
1418
1419 //____________________________________________________________________________________________________
1420 //  XHierarchicalStorageAccess
1421 //____________________________________________________________________________________________________
1422 //-----------------------------------------------
1423 uno::Reference< embed::XExtendedStorageStream > SAL_CALL FSStorage::openStreamElementByHierarchicalName( const OUString& sStreamPath, ::sal_Int32 nOpenMode )
1424         throw ( embed::InvalidStorageException,
1425                 lang::IllegalArgumentException,
1426                 packages::WrongPasswordException,
1427                 io::IOException,
1428                 embed::StorageWrappedTargetException,
1429                 uno::RuntimeException )
1430 {
1431     ::osl::MutexGuard aGuard( m_aMutex );
1432
1433     if ( !m_pImpl )
1434         throw lang::DisposedException();
1435
1436     if ( sStreamPath.toChar() == '/' )
1437         throw lang::IllegalArgumentException();
1438
1439     if ( !GetContent() )
1440         throw io::IOException(); // TODO: error handling
1441
1442     INetURLObject aBaseURL( m_pImpl->m_aURL );
1443     if ( !aBaseURL.setFinalSlash() )
1444         throw uno::RuntimeException();
1445
1446     INetURLObject aFileURL = INetURLObject::GetAbsURL(
1447                 aBaseURL.GetMainURL( INetURLObject::NO_DECODE ),
1448                 sStreamPath );
1449
1450     if ( ::utl::UCBContentHelper::IsFolder( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
1451         throw io::IOException();
1452
1453     if ( ( nOpenMode & embed::ElementModes::NOCREATE )
1454       && !::utl::UCBContentHelper::IsDocument( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
1455         throw io::IOException(); // TODO:
1456
1457     uno::Reference< ucb::XCommandEnvironment > xDummyEnv; // TODO: provide InteractionHandler if any
1458     uno::Reference< io::XStream > xResult;
1459     try
1460     {
1461         if ( nOpenMode & embed::ElementModes::WRITE )
1462         {
1463             if ( isLocalFile_Impl( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
1464             {
1465                 uno::Reference<ucb::XSimpleFileAccess3> xSimpleFileAccess(
1466                     ucb::SimpleFileAccess::create(
1467                         comphelper::getComponentContext(m_pImpl->m_xFactory) ) );
1468                 uno::Reference< io::XStream > xStream =
1469                     xSimpleFileAccess->openFileReadWrite( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) );
1470
1471                 xResult = static_cast< io::XStream* >( new OFSStreamContainer( xStream ) );
1472             }
1473             else
1474             {
1475                 // TODO: test whether it really works for http and fwp
1476                 SvStream* pStream = ::utl::UcbStreamHelper::CreateStream( aFileURL.GetMainURL( INetURLObject::NO_DECODE ),
1477                                                                           STREAM_STD_WRITE );
1478                 if ( pStream )
1479                 {
1480                     if ( !pStream->GetError() )
1481                     {
1482                         uno::Reference< io::XStream > xStream =
1483                             uno::Reference < io::XStream >( new ::utl::OStreamWrapper( *pStream ) );
1484                         xResult = static_cast< io::XStream* >( new OFSStreamContainer( xStream ) );
1485                     }
1486                     else
1487                         delete pStream;
1488                 }
1489             }
1490
1491             if ( !xResult.is() )
1492                 throw io::IOException();
1493
1494             if ( ( nOpenMode & embed::ElementModes::TRUNCATE ) )
1495             {
1496                 uno::Reference< io::XTruncate > xTrunc( xResult->getOutputStream(), uno::UNO_QUERY_THROW );
1497                 xTrunc->truncate();
1498             }
1499         }
1500         else
1501         {
1502             if ( ( nOpenMode & embed::ElementModes::TRUNCATE )
1503               || !::utl::UCBContentHelper::IsDocument( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
1504                 throw io::IOException(); // TODO: access denied
1505
1506             ::ucbhelper::Content aResultContent( aFileURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv, comphelper::getProcessComponentContext() );
1507             uno::Reference< io::XInputStream > xInStream = aResultContent.openStream();
1508             xResult = static_cast< io::XStream* >( new OFSInputStreamContainer( xInStream ) );
1509         }
1510     }
1511     catch( embed::InvalidStorageException& )
1512     {
1513         throw;
1514     }
1515     catch( lang::IllegalArgumentException& )
1516     {
1517         throw;
1518     }
1519     catch( packages::WrongPasswordException& )
1520     {
1521         throw;
1522     }
1523     catch( embed::StorageWrappedTargetException& )
1524     {
1525         throw;
1526     }
1527     catch( io::IOException& )
1528     {
1529         throw;
1530     }
1531     catch( uno::RuntimeException& )
1532     {
1533         throw;
1534     }
1535     catch( uno::Exception& )
1536     {
1537           uno::Any aCaught( ::cppu::getCaughtException() );
1538         throw embed::StorageWrappedTargetException( OUString("Can't copy raw stream"),
1539                                                  uno::Reference< io::XInputStream >(),
1540                                                  aCaught );
1541     }
1542
1543     return uno::Reference< embed::XExtendedStorageStream >( xResult, uno::UNO_QUERY_THROW );
1544 }
1545
1546 //-----------------------------------------------
1547 uno::Reference< embed::XExtendedStorageStream > SAL_CALL FSStorage::openEncryptedStreamElementByHierarchicalName( const OUString& /*sStreamName*/, ::sal_Int32 /*nOpenMode*/, const OUString& /*sPassword*/ )
1548         throw ( embed::InvalidStorageException,
1549                 lang::IllegalArgumentException,
1550                 packages::NoEncryptionException,
1551                 packages::WrongPasswordException,
1552                 io::IOException,
1553                 embed::StorageWrappedTargetException,
1554                 uno::RuntimeException )
1555 {
1556     throw packages::NoEncryptionException();
1557 }
1558
1559 //-----------------------------------------------
1560 void SAL_CALL FSStorage::removeStreamElementByHierarchicalName( const OUString& sStreamPath )
1561         throw ( embed::InvalidStorageException,
1562                 lang::IllegalArgumentException,
1563                 container::NoSuchElementException,
1564                 io::IOException,
1565                 embed::StorageWrappedTargetException,
1566                 uno::RuntimeException )
1567 {
1568     ::osl::MutexGuard aGuard( m_aMutex );
1569
1570     if ( !m_pImpl )
1571         throw lang::DisposedException();
1572
1573     if ( !GetContent() )
1574         throw io::IOException(); // TODO: error handling
1575
1576     // TODO/LATER: may need possibility to create folder if it was removed, since the folder can not be locked
1577     INetURLObject aBaseURL( m_pImpl->m_aURL );
1578     if ( !aBaseURL.setFinalSlash() )
1579         throw uno::RuntimeException();
1580
1581     INetURLObject aFileURL = INetURLObject::GetAbsURL(
1582                 aBaseURL.GetMainURL( INetURLObject::NO_DECODE ),
1583                 sStreamPath );
1584
1585     if ( !::utl::UCBContentHelper::IsDocument( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
1586     {
1587         if ( ::utl::UCBContentHelper::IsFolder( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
1588             throw lang::IllegalArgumentException();
1589         else
1590             throw container::NoSuchElementException(); // TODO:
1591     }
1592
1593     if ( !::utl::UCBContentHelper::Kill( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
1594         throw io::IOException(); // TODO: error handling
1595 }
1596
1597
1598 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */