basic/source/uno/namecont.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: namecont.cxx,v $
  10  * $Revision: 1.18 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_basic.hxx"
  33 #include <com/sun/star/container/XNameContainer.hpp>
  34 #include <com/sun/star/container/XContainer.hpp>
  35 #include <com/sun/star/embed/ElementModes.hpp>
  36 #include <com/sun/star/embed/XTransactedObject.hpp>
  37 #include <com/sun/star/lang/XServiceInfo.hpp>
  38 #include <vcl/svapp.hxx>
  39 #include <vos/mutex.hxx>
  40 #ifndef __RSC //autogen
  41 #include <tools/errinf.hxx>
  42 #endif
  43 #include <osl/mutex.hxx>
  44 #include <vos/diagnose.hxx>
  45 #include <rtl/uri.hxx>
  46 #include <rtl/strbuf.hxx>
  47 #include <comphelper/processfactory.hxx>
  48 #ifndef INCLUDED_COMPHELPER_ANYTOSTRING_HXX
  49 #include <comphelper/anytostring.hxx>
  50 #endif
  51
  52 #include "namecont.hxx"
  53 #include <basic/basicmanagerrepository.hxx>
  54 #include <tools/diagnose_ex.h>
  55 #include <tools/urlobj.hxx>
  56 #include <unotools/streamwrap.hxx>
  57 #include <svtools/pathoptions.hxx>
  58 #include <svtools/sfxecode.hxx>
  59 #include <svtools/ehdl.hxx>
  60 #include <basic/basmgr.hxx>
  61 #include <com/sun/star/xml/sax/XExtendedDocumentHandler.hpp>
  62 #include <com/sun/star/xml/sax/XParser.hpp>
  63 #include <com/sun/star/xml/sax/InputSource.hpp>
  64 #include <com/sun/star/io/XOutputStream.hpp>
  65 #include <com/sun/star/io/XInputStream.hpp>
  66 #include <com/sun/star/io/XActiveDataSource.hpp>
  67 #include <com/sun/star/beans/XPropertySet.hpp>
  68 #include <com/sun/star/uno/DeploymentException.hpp>
  69 #include <com/sun/star/lang/DisposedException.hpp>
  70 #include <com/sun/star/script/LibraryNotLoadedException.hpp>
  71 #include "com/sun/star/deployment/thePackageManagerFactory.hpp"
  72 #include <comphelper/storagehelper.hxx>
  73 #ifndef _RTL_USTRING_HXX_
  74 #include <comphelper/anytostring.hxx>
  75 #endif
  76 #include <cppuhelper/exc_hlp.hxx>
  77 #include <basic/sbmod.hxx>
  78
  79 #ifndef _COM_SUN_STAR_SCRIPT_MODULEINFO_HPP_
  80 #include <com/sun/star/script/ModuleInfo.hpp>
  81 #endif
  82
  83 namespace basic
  84 {
  85
  86 using namespace com::sun::star::document;
  87 using namespace com::sun::star::container;
  88 using namespace com::sun::star::uno;
  89 using namespace com::sun::star::lang;
  90 using namespace com::sun::star::io;
  91 using namespace com::sun::star::ucb;
  92 using namespace com::sun::star::script;
  93 using namespace com::sun::star::beans;
  94 using namespace com::sun::star::xml::sax;
  95 using namespace com::sun::star::util;
  96 using namespace com::sun::star::task;
  97 using namespace com::sun::star::embed;
  98 using namespace com::sun::star::frame;
  99 using namespace com::sun::star::deployment;
 100 using namespace com::sun::star;
 101 using namespace cppu;
 102 using namespace rtl;
 103 using namespace osl;
 104
 105 using com::sun::star::uno::Reference;
 106
 107 // #i34411: Flag for error handling during migration
 108 static bool GbMigrationSuppressErrors = false;
 109
 110 //============================================================================
 111 // Implementation class NameContainer
 112
 113 // Methods XElementAccess
 114 Type NameContainer::getElementType()
 115     throw(RuntimeException)
 116 {
 117     return mType;
 118 }
 119
 120 sal_Bool NameContainer::hasElements()
 121     throw(RuntimeException)
 122 {
 123     sal_Bool bRet = (mnElementCount > 0);
 124     return bRet;
 125 }
 126
 127 // Methods XNameAccess
 128 Any NameContainer::getByName( const OUString& aName )
 129     throw(NoSuchElementException, WrappedTargetException, RuntimeException)
 130 {
 131     NameContainerNameMap::iterator aIt = mHashMap.find( aName );
 132     if( aIt == mHashMap.end() )
 133     {
 134         throw NoSuchElementException();
 135     }
 136     sal_Int32 iHashResult = (*aIt).second;
 137     Any aRetAny = mValues.getConstArray()[ iHashResult ];
 138     return aRetAny;
 139 }
 140
 141 Sequence< OUString > NameContainer::getElementNames()
 142     throw(RuntimeException)
 143 {
 144     return mNames;
 145 }
 146
 147 sal_Bool NameContainer::hasByName( const OUString& aName )
 148     throw(RuntimeException)
 149 {
 150     NameContainerNameMap::iterator aIt = mHashMap.find( aName );
 151     sal_Bool bRet = ( aIt != mHashMap.end() );
 152     return bRet;
 153 }
 154
 155
 156 // Methods XNameReplace
 157 void NameContainer::replaceByName( const OUString& aName, const Any& aElement )
 158     throw(IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException)
 159 {
 160     Type aAnyType = aElement.getValueType();
 161     if( mType != aAnyType && aAnyType != getCppuType( static_cast< ModuleInfo* >( NULL ) ) )
 162         throw IllegalArgumentException();
 163
 164     NameContainerNameMap::iterator aIt = mHashMap.find( aName );
 165     if( aIt == mHashMap.end() )
 166     {
 167         throw NoSuchElementException();
 168     }
 169     sal_Int32 iHashResult = (*aIt).second;
 170     Any aOldElement = mValues.getConstArray()[ iHashResult ];
 171     mValues.getArray()[ iHashResult ] = aElement;
 172
 173
 174     // Fire event
 175     ContainerEvent aEvent;
 176     aEvent.Source = mpxEventSource;
 177     aEvent.Accessor <<= aName;
 178     aEvent.Element = aElement;
 179     aEvent.ReplacedElement = aOldElement;
 180
 181     OInterfaceIteratorHelper aIterator( maListenerContainer );
 182     while( aIterator.hasMoreElements() )
 183     {
 184         Reference< XInterface > xIface = aIterator.next();
 185         Reference< XContainerListener > xListener( xIface, UNO_QUERY );
 186         try
 187         {
 188             xListener->elementReplaced( aEvent );
 189         }
 190         catch(RuntimeException&)
 191         {
 192             aIterator.remove();
 193         }
 194     }
 195 }
 196
 197
 198 // Methods XNameContainer
 199 void NameContainer::insertByName( const OUString& aName, const Any& aElement )
 200     throw(IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException)
 201 {
 202     Type aAnyType = aElement.getValueType();
 203     if( mType != aAnyType && aAnyType != getCppuType( static_cast< ModuleInfo* >( NULL ) ) )
 204         throw IllegalArgumentException();
 205
 206     NameContainerNameMap::iterator aIt = mHashMap.find( aName );
 207     if( aIt != mHashMap.end() )
 208     {
 209         throw ElementExistException();
 210     }
 211
 212     sal_Int32 nCount = mNames.getLength();
 213     mNames.realloc( nCount + 1 );
 214     mValues.realloc( nCount + 1 );
 215     mNames.getArray()[ nCount ] = aName;
 216     mValues.getArray()[ nCount ] = aElement;
 217
 218     mHashMap[ aName ] = nCount;
 219     mnElementCount++;
 220
 221
 222     // Fire event
 223     ContainerEvent aEvent;
 224     aEvent.Source = mpxEventSource;
 225     aEvent.Accessor <<= aName;
 226     aEvent.Element = aElement;
 227
 228     OInterfaceIteratorHelper aIterator( maListenerContainer );
 229     while( aIterator.hasMoreElements() )
 230     {
 231         Reference< XInterface > xIface = aIterator.next();
 232         Reference< XContainerListener > xListener( xIface, UNO_QUERY );
 233         try
 234         {
 235             xListener->elementInserted( aEvent );
 236         }
 237         catch(RuntimeException&)
 238         {
 239             aIterator.remove();
 240         }
 241     }
 242 }
 243
 244 void NameContainer::removeByName( const OUString& Name )
 245     throw(NoSuchElementException, WrappedTargetException, RuntimeException)
 246 {
 247     NameContainerNameMap::iterator aIt = mHashMap.find( Name );
 248     if( aIt == mHashMap.end() )
 249     {
 250         throw NoSuchElementException();
 251     }
 252
 253     sal_Int32 iHashResult = (*aIt).second;
 254     Any aOldElement = mValues.getConstArray()[ iHashResult ];
 255     mHashMap.erase( aIt );
 256     sal_Int32 iLast = mNames.getLength() - 1;
 257     if( iLast != iHashResult )
 258     {
 259         OUString* pNames = mNames.getArray();
 260         Any* pValues = mValues.getArray();
 261         pNames[ iHashResult ] = pNames[ iLast ];
 262         pValues[ iHashResult ] = pValues[ iLast ];
 263         mHashMap[ pNames[ iHashResult ] ] = iHashResult;
 264     }
 265     mNames.realloc( iLast );
 266     mValues.realloc( iLast );
 267     mnElementCount--;
 268
 269
 270     // Fire event
 271     ContainerEvent aEvent;
 272     aEvent.Source = mpxEventSource;
 273     aEvent.Accessor <<= Name;
 274     aEvent.Element = aOldElement;
 275
 276     OInterfaceIteratorHelper aIterator( maListenerContainer );
 277     while( aIterator.hasMoreElements() )
 278     {
 279         Reference< XInterface > xIface = aIterator.next();
 280         Reference< XContainerListener > xListener( xIface, UNO_QUERY );
 281         try
 282         {
 283             xListener->elementRemoved( aEvent );
 284         }
 285         catch(RuntimeException&)
 286         {
 287             aIterator.remove();
 288         }
 289     }
 290 }
 291
 292
 293 // Methods XContainer
 294 void SAL_CALL NameContainer::addContainerListener( const Reference< XContainerListener >& xListener )
 295     throw (RuntimeException)
 296 {
 297     if( !xListener.is() )
 298         throw RuntimeException();
 299     Reference< XInterface > xIface( xListener, UNO_QUERY );
 300     maListenerContainer.addInterface( xIface );
 301 }
 302
 303 void SAL_CALL NameContainer::removeContainerListener( const Reference< XContainerListener >& xListener )
 304     throw (RuntimeException)
 305 {
 306     if( !xListener.is() )
 307         throw RuntimeException();
 308     Reference< XInterface > xIface( xListener, UNO_QUERY );
 309     maListenerContainer.removeInterface( xIface );
 310 }
 311
 312 //============================================================================
 313 // ModifiableHelper
 314
 315 void ModifiableHelper::setModified( sal_Bool _bModified )
 316 {
 317     if ( _bModified == mbModified )
 318         return;
 319     mbModified = _bModified;
 320
 321     if ( m_aModifyListeners.getLength() == 0 )
 322         return;
 323
 324     EventObject aModifyEvent( m_rEventSource );
 325     m_aModifyListeners.notifyEach( &XModifyListener::modified, aModifyEvent );
 326 }
 327
 328 //============================================================================
 329
 330 // Implementation class SfxLibraryContainer
 331 DBG_NAME( SfxLibraryContainer )
 332
 333 // Ctor
 334 SfxLibraryContainer::SfxLibraryContainer( void )
 335     : LibraryContainerHelper( maMutex )
 336     , maModifiable( *this, maMutex )
 337     , maNameContainer( getCppuType( (Reference< XNameAccess >*) NULL ) )
 338     , mbOldInfoFormat( sal_False )
 339     , mbOasis2OOoFormat( sal_False )
 340     , mpBasMgr( NULL )
 341     , mbOwnBasMgr( sal_False )
 342 {
 343     DBG_CTOR( SfxLibraryContainer, NULL );
 344
 345     mxMSF = comphelper::getProcessServiceFactory();
 346     if( !mxMSF.is() )
 347     {
 348         OSL_ENSURE( 0, "### couln't get ProcessServiceFactory\n" );
 349     }
 350
 351     mxSFI = Reference< XSimpleFileAccess >( mxMSF->createInstance
 352         ( OUString::createFromAscii( "com.sun.star.ucb.SimpleFileAccess" ) ), UNO_QUERY );
 353     if( !mxSFI.is() )
 354     {
 355         OSL_ENSURE( 0, "### couln't create SimpleFileAccess component\n" );
 356     }
 357
 358     mxStringSubstitution = Reference< XStringSubstitution >( mxMSF->createInstance
 359         ( OUString::createFromAscii( "com.sun.star.util.PathSubstitution" ) ), UNO_QUERY );
 360     if( !mxStringSubstitution.is() )
 361     {
 362         OSL_ENSURE( 0, "### couln't create PathSubstitution component\n" );
 363     }
 364 }
 365
 366 SfxLibraryContainer::~SfxLibraryContainer()
 367 {
 368     if( mbOwnBasMgr )
 369         BasicManager::LegacyDeleteBasicManager( mpBasMgr );
 370     DBG_DTOR( SfxLibraryContainer, NULL );
 371 }
 372
 373 void SfxLibraryContainer::checkDisposed() const
 374 {
 375     if ( isDisposed() )
 376         throw DisposedException( ::rtl::OUString(), *const_cast< SfxLibraryContainer* >( this ) );
 377 }
 378
 379 void SfxLibraryContainer::enterMethod()
 380 {
 381     maMutex.acquire();
 382     checkDisposed();
 383 }
 384
 385 void SfxLibraryContainer::leaveMethod()
 386 {
 387     maMutex.release();
 388 }
 389
 390 BasicManager* SfxLibraryContainer::getBasicManager( void )
 391 {
 392     if ( mpBasMgr )
 393         return mpBasMgr;
 394
 395     Reference< XModel > xDocument( mxOwnerDocument.get(), UNO_QUERY );
 396     OSL_ENSURE( xDocument.is(), "SfxLibraryContainer::getBasicManager: cannot obtain a BasicManager without document!" );
 397     if ( xDocument.is() )
 398         mpBasMgr = BasicManagerRepository::getDocumentBasicManager( xDocument );
 399
 400     return mpBasMgr;
 401 }
 402
 403 // Methods XStorageBasedLibraryContainer
 404 Reference< XStorage > SAL_CALL SfxLibraryContainer::getRootStorage() throw (RuntimeException)
 405 {
 406     LibraryContainerMethodGuard aGuard( *this );
 407     return mxStorage;
 408 }
 409
 410 void SAL_CALL SfxLibraryContainer::setRootStorage( const Reference< XStorage >& _rxRootStorage ) throw (IllegalArgumentException, RuntimeException)
 411 {
 412     LibraryContainerMethodGuard aGuard( *this );
 413     if ( !_rxRootStorage.is() )
 414         throw IllegalArgumentException();
 415
 416     mxStorage = _rxRootStorage;
 417     onNewRootStorage();
 418 }
 419
 420 void SAL_CALL SfxLibraryContainer::storeLibrariesToStorage( const Reference< XStorage >& _rxRootStorage ) throw (IllegalArgumentException, WrappedTargetException, RuntimeException)
 421 {
 422     LibraryContainerMethodGuard aGuard( *this );
 423     if ( !_rxRootStorage.is() )
 424         throw IllegalArgumentException();
 425
 426     try
 427     {
 428         storeLibraries_Impl( _rxRootStorage, sal_True );
 429     }
 430     catch( const Exception& )
 431     {
 432         throw WrappedTargetException( ::rtl::OUString(), *this, ::cppu::getCaughtException() );
 433     }
 434 }
 435
 436
 437 // Methods XModifiable
 438 sal_Bool SfxLibraryContainer::isModified() throw (RuntimeException)
 439 {
 440     LibraryContainerMethodGuard aGuard( *this );
 441     if ( maModifiable.isModified() )
 442         return sal_True;
 443
 444     // the library container is not modified, go through the libraries and check whether they are modified
 445     Sequence< OUString > aNames = maNameContainer.getElementNames();
 446     const OUString* pNames = aNames.getConstArray();
 447     sal_Int32 nNameCount = aNames.getLength();
 448
 449     for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
 450     {
 451         OUString aName = pNames[ i ];
 452         SfxLibrary* pImplLib = getImplLib( aName );
 453         if( pImplLib->isModified() )
 454         {
 455             if ( aName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Standard") ) ) )
 456             {
 457                 // this is a workaround that has to be implemented because
 458                 // empty standard library should stay marked as modified
 459                 // but should not be treated as modified while it is empty
 460                 if ( pImplLib->hasElements() )
 461                     return sal_True;
 462             }
 463             else
 464                 return sal_True;
 465         }
 466     }
 467
 468     return sal_False;
 469 }
 470
 471 void SAL_CALL SfxLibraryContainer::setModified( sal_Bool _bModified ) throw (PropertyVetoException, RuntimeException)
 472 {
 473     LibraryContainerMethodGuard aGuard( *this );
 474     maModifiable.setModified( _bModified );
 475 }
 476
 477 void SAL_CALL SfxLibraryContainer::addModifyListener( const Reference< XModifyListener >& _rxListener ) throw (RuntimeException)
 478 {
 479     LibraryContainerMethodGuard aGuard( *this );
 480     maModifiable.addModifyListener( _rxListener );
 481 }
 482
 483 void SAL_CALL SfxLibraryContainer::removeModifyListener( const Reference< XModifyListener >& _rxListener ) throw (RuntimeException)
 484 {
 485     LibraryContainerMethodGuard aGuard( *this );
 486     maModifiable.removeModifyListener( _rxListener );
 487 }
 488
 489 // Methods XPersistentLibraryContainer
 490 Any SAL_CALL SfxLibraryContainer::getRootLocation() throw (RuntimeException)
 491 {
 492     LibraryContainerMethodGuard aGuard( *this );
 493     return makeAny( getRootStorage() );
 494 }
 495
 496 ::rtl::OUString SAL_CALL SfxLibraryContainer::getContainerLocationName() throw (RuntimeException)
 497 {
 498     LibraryContainerMethodGuard aGuard( *this );
 499     return maLibrariesDir;
 500 }
 501
 502 void SAL_CALL SfxLibraryContainer::storeLibraries(  ) throw (WrappedTargetException, RuntimeException)
 503 {
 504     LibraryContainerMethodGuard aGuard( *this );
 505     try
 506     {
 507         storeLibraries_Impl( mxStorage, mxStorage.is()  );
 508         // we need to store *all* libraries if and only if we are based on a storage:
 509         // in this case, storeLibraries_Impl will remove the source storage, after loading
 510         // all libraries, so we need to force them to be stored, again
 511     }
 512     catch( const Exception& )
 513     {
 514         throw WrappedTargetException( ::rtl::OUString(), *this, ::cppu::getCaughtException() );
 515     }
 516 }
 517
 518 static void checkAndCopyFileImpl( const INetURLObject& rSourceFolderInetObj,
 519                                   const INetURLObject& rTargetFolderInetObj,
 520                                   const OUString& rCheckFileName,
 521                                   const OUString& rCheckExtension,
 522                                   Reference< XSimpleFileAccess > xSFI )
 523 {
 524     INetURLObject aTargetFolderInetObj( rTargetFolderInetObj );
 525     aTargetFolderInetObj.insertName( rCheckFileName, sal_True, INetURLObject::LAST_SEGMENT,
 526                                      sal_True, INetURLObject::ENCODE_ALL );
 527     aTargetFolderInetObj.setExtension( rCheckExtension );
 528     OUString aTargetFile = aTargetFolderInetObj.GetMainURL( INetURLObject::NO_DECODE );
 529     if( !xSFI->exists( aTargetFile ) )
 530     {
 531         INetURLObject aSourceFolderInetObj( rSourceFolderInetObj );
 532         aSourceFolderInetObj.insertName( rCheckFileName, sal_True, INetURLObject::LAST_SEGMENT,
 533                                          sal_True, INetURLObject::ENCODE_ALL );
 534         aSourceFolderInetObj.setExtension( rCheckExtension );
 535         OUString aSourceFile = aSourceFolderInetObj.GetMainURL( INetURLObject::NO_DECODE );
 536         xSFI->copy( aSourceFile, aTargetFile );
 537     }
 538 }
 539
 540 static void createVariableURL( OUString& rStr, const OUString& rLibName,
 541                                const OUString& rInfoFileName, bool bUser )
 542 {
 543     if( bUser )
 544         rStr = OUString::createFromAscii( "$(USER)/basic/" );
 545     else
 546         rStr = OUString::createFromAscii( "$(INST)/share/basic/" );
 547
 548     rStr += rLibName;
 549     rStr += OUString::createFromAscii( "/" );
 550     rStr += rInfoFileName;
 551     rStr += OUString::createFromAscii( ".xlb/" );
 552 }
 553
 554 sal_Bool SfxLibraryContainer::init( const OUString& rInitialDocumentURL, const uno::Reference< embed::XStorage >& rxInitialStorage )
 555 {
 556     // this might be called from within the ctor, and the impl_init might (indirectly) create
 557     // an UNO reference to ourself.
 558     // Ensure that we're not destroyed while we're in here
 559     osl_incrementInterlockedCount( &m_refCount );
 560     sal_Bool bSuccess = init_Impl( rInitialDocumentURL, rxInitialStorage );
 561     osl_decrementInterlockedCount( &m_refCount );
 562
 563     return bSuccess;
 564 }
 565
 566 sal_Bool SfxLibraryContainer::init_Impl(
 567     const OUString& rInitialDocumentURL, const uno::Reference< embed::XStorage >& rxInitialStorage )
 568 {
 569     uno::Reference< embed::XStorage > xStorage = rxInitialStorage;
 570
 571     maInitialDocumentURL = rInitialDocumentURL;
 572     maInfoFileName = OUString::createFromAscii( getInfoFileName() );
 573     maOldInfoFileName = OUString::createFromAscii( getOldInfoFileName() );
 574     maLibElementFileExtension = OUString::createFromAscii( getLibElementFileExtension() );
 575     maLibrariesDir = OUString::createFromAscii( getLibrariesDir() );
 576
 577     meInitMode = DEFAULT;
 578     INetURLObject aInitUrlInetObj( maInitialDocumentURL );
 579     OUString aInitFileName = aInitUrlInetObj.GetMainURL( INetURLObject::NO_DECODE );
 580     if( aInitFileName.getLength() )
 581     {
 582         // We need a BasicManager to avoid problems
 583         StarBASIC* pBas = new StarBASIC();
 584         mpBasMgr = new BasicManager( pBas );
 585         mbOwnBasMgr = sal_True;
 586
 587         OUString aExtension = aInitUrlInetObj.getExtension();
 588         if( aExtension.compareToAscii( "xlc" ) == COMPARE_EQUAL )
 589         {
 590             meInitMode = CONTAINER_INIT_FILE;
 591             INetURLObject aLibPathInetObj( aInitUrlInetObj );
 592             aLibPathInetObj.removeSegment();
 593             maLibraryPath = aLibPathInetObj.GetMainURL( INetURLObject::NO_DECODE );
 594         }
 595         else if( aExtension.compareToAscii( "xlb" ) == COMPARE_EQUAL )
 596         {
 597             meInitMode = LIBRARY_INIT_FILE;
 598             uno::Reference< embed::XStorage > xDummyStor;
 599             ::xmlscript::LibDescriptor aLibDesc;
 600             sal_Bool bReadIndexFile = implLoadLibraryIndexFile( NULL, aLibDesc, xDummyStor, aInitFileName );
 601                return bReadIndexFile;
 602         }
 603         else
 604         {
 605             // Decide between old and new document
 606             sal_Bool bOldStorage = SotStorage::IsOLEStorage( aInitFileName );
 607             if ( bOldStorage )
 608             {
 609                 meInitMode = OLD_BASIC_STORAGE;
 610                 importFromOldStorage( aInitFileName );
 611                 return sal_True;
 612             }
 613             else
 614             {
 615                 meInitMode = OFFICE_DOCUMENT;
 616                 try
 617                 {
 618                     xStorage = ::comphelper::OStorageHelper::GetStorageFromURL( aInitFileName, embed::ElementModes::READ );
 619                 }
 620                 catch ( uno::Exception& )
 621                 {
 622                     // TODO: error handling
 623                 }
 624             }
 625         }
 626     }
 627     else
 628     {
 629         // Default pathes
 630         maLibraryPath = SvtPathOptions().GetBasicPath();
 631     }
 632
 633     Reference< XParser > xParser( mxMSF->createInstance(
 634         OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.xml.sax.Parser") ) ), UNO_QUERY );
 635     if( !xParser.is() )
 636     {
 637         OSL_ENSURE( 0, "### couln't create sax parser component\n" );
 638         return sal_False;
 639     }
 640
 641     uno::Reference< io::XInputStream > xInput;
 642
 643     mxStorage = xStorage;
 644     sal_Bool bStorage = mxStorage.is();
 645
 646
 647     // #110009: Scope to force the StorageRefs to be destructed and
 648     // so the streams to be closed before the preload operation
 649     {
 650     // #110009
 651
 652     uno::Reference< embed::XStorage > xLibrariesStor;
 653     String aFileName;
 654
 655     int nPassCount = 1;
 656     if( !bStorage && meInitMode == DEFAULT )
 657         nPassCount = 2;
 658     for( int nPass = 0 ; nPass < nPassCount ; nPass++ )
 659     {
 660         if( bStorage )
 661         {
 662             OSL_ENSURE( meInitMode == DEFAULT || meInitMode == OFFICE_DOCUMENT,
 663                 "### Wrong InitMode for document\n" );
 664             try
 665             {
 666                 uno::Reference< io::XStream > xStream;
 667                 xLibrariesStor = xStorage->openStorageElement( maLibrariesDir, embed::ElementModes::READ );
 668                 //if ( !xLibrariesStor.is() )
 669                     // TODO: the method must either return a storage or throw an exception
 670                     //throw uno::RuntimeException();
 671
 672                 if ( xLibrariesStor.is() )
 673                 {
 674                     aFileName = maInfoFileName;
 675                     aFileName += String( RTL_CONSTASCII_USTRINGPARAM("-lc.xml") );
 676
 677                     try
 678                     {
 679                         xStream = xLibrariesStor->openStreamElement( aFileName, embed::ElementModes::READ );
 680                     }
 681                     catch( uno::Exception& )
 682                     {}
 683
 684                     if( !xStream.is() )
 685                     {
 686                         mbOldInfoFormat = true;
 687
 688                         // Check old version
 689                         aFileName = maOldInfoFileName;
 690                         aFileName += String( RTL_CONSTASCII_USTRINGPARAM(".xml") );
 691
 692                         try
 693                         {
 694                             xStream = xLibrariesStor->openStreamElement( aFileName, embed::ElementModes::READ );
 695                         }
 696                         catch( uno::Exception& )
 697                         {}
 698
 699                         if( !xStream.is() )
 700                         {
 701                             // Check for EA2 document version with wrong extensions
 702                             aFileName = maOldInfoFileName;
 703                             aFileName += String( RTL_CONSTASCII_USTRINGPARAM(".xli") );
 704                             xStream = xLibrariesStor->openStreamElement( aFileName, embed::ElementModes::READ );
 705                         }
 706                     }
 707                 }
 708
 709                 if ( xStream.is() )
 710                     xInput = xStream->getInputStream();
 711             }
 712             catch( uno::Exception& )
 713             {
 714                 // TODO: error handling?
 715             }
 716         }
 717         else
 718         {
 719             INetURLObject* pLibInfoInetObj = NULL;
 720             if( meInitMode == CONTAINER_INIT_FILE )
 721             {
 722                 aFileName = aInitFileName;
 723             }
 724             else
 725             {
 726                 if( nPass == 1 )
 727                     pLibInfoInetObj = new INetURLObject( String(maLibraryPath).GetToken(0) );
 728                 else
 729                     pLibInfoInetObj = new INetURLObject( String(maLibraryPath).GetToken(1) );
 730                 pLibInfoInetObj->insertName( maInfoFileName, sal_True, INetURLObject::LAST_SEGMENT, sal_True, INetURLObject::ENCODE_ALL );
 731                 pLibInfoInetObj->setExtension( OUString( RTL_CONSTASCII_USTRINGPARAM("xlc") ) );
 732                 aFileName = pLibInfoInetObj->GetMainURL( INetURLObject::NO_DECODE );
 733             }
 734
 735             try
 736             {
 737                 xInput = mxSFI->openFileRead( aFileName );
 738             }
 739             catch( Exception& )
 740             {
 741                 xInput.clear();
 742                 if( nPass == 0 )
 743                 {
 744                     SfxErrorContext aEc( ERRCTX_SFX_LOADBASIC, aFileName );
 745                     ULONG nErrorCode = ERRCODE_IO_GENERAL;
 746                     ErrorHandler::HandleError( nErrorCode );
 747                 }
 748             }
 749
 750             // Old variant?
 751             if( !xInput.is() && nPass == 0 )
 752             {
 753                 INetURLObject aLibInfoInetObj( String(maLibraryPath).GetToken(1) );
 754                 aLibInfoInetObj.insertName( maOldInfoFileName, sal_True, INetURLObject::LAST_SEGMENT, sal_True, INetURLObject::ENCODE_ALL );
 755                 aLibInfoInetObj.setExtension( OUString( RTL_CONSTASCII_USTRINGPARAM("xli") ) );
 756                 aFileName = aLibInfoInetObj.GetMainURL( INetURLObject::NO_DECODE );
 757
 758                 try
 759                 {
 760                     xInput = mxSFI->openFileRead( aFileName );
 761                     mbOldInfoFormat = true;
 762                 }
 763                 catch( Exception& )
 764                 {
 765                     xInput.clear();
 766                     SfxErrorContext aEc( ERRCTX_SFX_LOADBASIC, aFileName );
 767                     ULONG nErrorCode = ERRCODE_IO_GENERAL;
 768                     ErrorHandler::HandleError( nErrorCode );
 769                 }
 770             }
 771
 772             delete pLibInfoInetObj;
 773         }
 774
 775         if( xInput.is() )
 776         {
 777             InputSource source;
 778             source.aInputStream = xInput;
 779             source.sSystemId    = aFileName;
 780
 781             // start parsing
 782             ::xmlscript::LibDescriptorArray* pLibArray = new ::xmlscript::LibDescriptorArray();
 783
 784             try
 785             {
 786                 xParser->setDocumentHandler( ::xmlscript::importLibraryContainer( pLibArray ) );
 787                 xParser->parseStream( source );
 788             }
 789             catch ( xml::sax::SAXException& e )
 790             {
 791                 (void) e; // avoid warning
 792                 OSL_ENSURE( 0, OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US ).getStr() );
 793                 return sal_False;
 794             }
 795             catch ( io::IOException& e )
 796             {
 797                 (void) e; // avoid warning
 798                 OSL_ENSURE( 0, OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US ).getStr() );
 799                 return sal_False;
 800             }
 801
 802             sal_Int32 nLibCount = pLibArray->mnLibCount;
 803             for( sal_Int32 i = 0 ; i < nLibCount ; i++ )
 804             {
 805                 ::xmlscript::LibDescriptor& rLib = pLibArray->mpLibs[i];
 806
 807                 // Check storage URL
 808                 OUString aStorageURL = rLib.aStorageURL;
 809                 if( !bStorage && !aStorageURL.getLength() && nPass == 0 )
 810                 {
 811                     String aLibraryPath;
 812                     if( meInitMode == CONTAINER_INIT_FILE )
 813                         aLibraryPath = maLibraryPath;
 814                     else
 815                         aLibraryPath = String(maLibraryPath).GetToken(1);
 816                     INetURLObject aInetObj( aLibraryPath );
 817
 818                     aInetObj.insertName( rLib.aName, sal_True, INetURLObject::LAST_SEGMENT,
 819                         sal_True, INetURLObject::ENCODE_ALL );
 820                     OUString aLibDirPath = aInetObj.GetMainURL( INetURLObject::NO_DECODE );
 821                     if( mxSFI->isFolder( aLibDirPath ) )
 822                     {
 823                         createVariableURL( rLib.aStorageURL, rLib.aName, maInfoFileName, true );
 824                         maModifiable.setModified( sal_True );
 825                     }
 826                     else if( rLib.bLink )
 827                     {
 828                         // Check "share" path
 829                         INetURLObject aShareInetObj( String(maLibraryPath).GetToken(0) );
 830                         aShareInetObj.insertName( rLib.aName, sal_True, INetURLObject::LAST_SEGMENT,
 831                             sal_True, INetURLObject::ENCODE_ALL );
 832                         OUString aShareLibDirPath = aShareInetObj.GetMainURL( INetURLObject::NO_DECODE );
 833                         if( mxSFI->isFolder( aShareLibDirPath ) )
 834                         {
 835                             createVariableURL( rLib.aStorageURL, rLib.aName, maInfoFileName, false );
 836                             maModifiable.setModified( sal_True );
 837                         }
 838                         else
 839                         {
 840                             // #i25537: Ignore lib if library folder does not really exist
 841                             continue;
 842                         }
 843                     }
 844                 }
 845
 846                 OUString aLibName = rLib.aName;
 847
 848                 // If the same library name is used by the shared and the
 849                 // user lib container index files the user file wins
 850                 if( nPass == 1 && hasByName( aLibName ) )
 851                     continue;
 852
 853                 SfxLibrary* pImplLib;
 854                 if( rLib.bLink )
 855                 {
 856                     Reference< XNameAccess > xLib =
 857                         createLibraryLink( aLibName, rLib.aStorageURL, rLib.bReadOnly );
 858                     pImplLib = static_cast< SfxLibrary* >( xLib.get() );
 859                 }
 860                 else
 861                 {
 862                     Reference< XNameContainer > xLib = createLibrary( aLibName );
 863                     pImplLib = static_cast< SfxLibrary* >( xLib.get() );
 864                     pImplLib->mbLoaded = sal_False;
 865                     pImplLib->mbReadOnly = rLib.bReadOnly;
 866                     if( !bStorage )
 867                         checkStorageURL( rLib.aStorageURL, pImplLib->maLibInfoFileURL,
 868                             pImplLib->maStorageURL, pImplLib->maUnexpandedStorageURL );
 869                 }
 870                 maModifiable.setModified( sal_False );
 871
 872                 // Read library info files
 873                 if( !mbOldInfoFormat )
 874                 {
 875                     uno::Reference< embed::XStorage > xLibraryStor;
 876                       if( !pImplLib->mbInitialised && bStorage )
 877                     {
 878                         try {
 879                             xLibraryStor = xLibrariesStor->openStorageElement( rLib.aName,
 880                                                                                 embed::ElementModes::READ );
 881                         }
 882                         catch( uno::Exception& )
 883                         {
 884                         #if OSL_DEBUG_LEVEL > 0
 885                             Any aError( ::cppu::getCaughtException() );
 886                             ::rtl::OStringBuffer aMessage;
 887                             aMessage.append( "couln't open sub storage for library '" );
 888                             aMessage.append( ::rtl::OUStringToOString( rLib.aName, osl_getThreadTextEncoding() ) );
 889                             aMessage.append( "'.\n\nException:" );
 890                             aMessage.append( ::rtl::OUStringToOString( ::comphelper::anyToString( aError ), osl_getThreadTextEncoding() ) );
 891                             OSL_ENSURE( false, aMessage.makeStringAndClear().getStr() );
 892                         #endif
 893                         }
 894                     }
 895
 896                     // Link is already initialised in createLibraryLink()
 897                     if( !pImplLib->mbInitialised && (!bStorage || xLibraryStor.is()) )
 898                     {
 899                         OUString aIndexFileName;
 900                         sal_Bool bLoaded = implLoadLibraryIndexFile( pImplLib, rLib, xLibraryStor, aIndexFileName );
 901                         if( bLoaded && aLibName != rLib.aName )
 902                         {
 903                             OSL_ENSURE( 0, "Different library names in library"
 904                                 " container and library info files!\n" );
 905                         }
 906                         if( GbMigrationSuppressErrors && !bLoaded )
 907                             removeLibrary( aLibName );
 908                     }
 909                 }
 910                 else if( !bStorage )
 911                 {
 912                     // Write new index file immediately because otherwise
 913                     // the library elements will be lost when storing into
 914                     // the new info format
 915                     uno::Reference< embed::XStorage > xTmpStorage;
 916                     implStoreLibraryIndexFile( pImplLib, rLib, xTmpStorage );
 917                 }
 918
 919                 implImportLibDescriptor( pImplLib, rLib );
 920
 921                 if( nPass == 1 )
 922                 {
 923                     pImplLib->mbSharedIndexFile = sal_True;
 924                     pImplLib->mbReadOnly = sal_True;
 925                 }
 926             }
 927
 928             // Keep flag for documents to force writing the new index files
 929             if( !bStorage )
 930                 mbOldInfoFormat = sal_False;
 931
 932             delete pLibArray;
 933         }
 934         // Only in the first pass it's an error when no index file is found
 935         else if( nPass == 0 )
 936         {
 937             return sal_False;
 938         }
 939     }
 940
 941     // #110009: END Scope to force the StorageRefs to be destructed
 942     }
 943     // #110009
 944
 945     if( !bStorage && meInitMode == DEFAULT )
 946         implScanExtensions();
 947
 948     // #110009 Preload?
 949     {
 950         Sequence< OUString > aNames = maNameContainer.getElementNames();
 951         const OUString* pNames = aNames.getConstArray();
 952         sal_Int32 nNameCount = aNames.getLength();
 953         for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
 954         {
 955             OUString aName = pNames[ i ];
 956             SfxLibrary* pImplLib = getImplLib( aName );
 957             if( pImplLib->mbPreload )
 958                 loadLibrary( aName );
 959         }
 960     }
 961
 962     // #118803# upgrade installation 7.0 -> 8.0
 963     if( meInitMode == DEFAULT )
 964     {
 965         INetURLObject aUserBasicInetObj( String(maLibraryPath).GetToken(1) );
 966         OUString aStandardStr( RTL_CONSTASCII_USTRINGPARAM("Standard") );
 967
 968         static char strPrevFolderName_1[] = "__basic_80";
 969         static char strPrevFolderName_2[] = "__basic_80_2";
 970         INetURLObject aPrevUserBasicInetObj_1( aUserBasicInetObj );
 971         aPrevUserBasicInetObj_1.removeSegment();
 972         INetURLObject aPrevUserBasicInetObj_2 = aPrevUserBasicInetObj_1;
 973         aPrevUserBasicInetObj_1.Append( strPrevFolderName_1 );
 974         aPrevUserBasicInetObj_2.Append( strPrevFolderName_2 );
 975
 976         // #i93163
 977         bool bCleanUp = false;
 978         try
 979         {
 980             INetURLObject aPrevUserBasicInetObj = aPrevUserBasicInetObj_1;
 981             String aPrevFolder = aPrevUserBasicInetObj.GetMainURL( INetURLObject::NO_DECODE );
 982             bool bSecondTime = false;
 983             if( mxSFI->isFolder( aPrevFolder ) )
 984             {
 985                 // #110101 Check if Standard folder exists and is complete
 986                 INetURLObject aUserBasicStandardInetObj( aUserBasicInetObj );
 987                 aUserBasicStandardInetObj.insertName( aStandardStr, sal_True, INetURLObject::LAST_SEGMENT,
 988                                                       sal_True, INetURLObject::ENCODE_ALL );
 989                 INetURLObject aPrevUserBasicStandardInetObj( aPrevUserBasicInetObj );
 990                 aPrevUserBasicStandardInetObj.insertName( aStandardStr, sal_True, INetURLObject::LAST_SEGMENT,
 991                                                         sal_True, INetURLObject::ENCODE_ALL );
 992                 OUString aPrevStandardFolder = aPrevUserBasicStandardInetObj.GetMainURL( INetURLObject::NO_DECODE );
 993                 if( mxSFI->isFolder( aPrevStandardFolder ) )
 994                 {
 995                     OUString aXlbExtension( OUString( RTL_CONSTASCII_USTRINGPARAM("xlb") ) );
 996                     OUString aCheckFileName;
 997
 998                     // Check if script.xlb exists
 999                     aCheckFileName = OUString( RTL_CONSTASCII_USTRINGPARAM("script") );
1000                     checkAndCopyFileImpl( aUserBasicStandardInetObj,
1001                                           aPrevUserBasicStandardInetObj,
1002                                           aCheckFileName, aXlbExtension, mxSFI );
1003
1004                     // Check if dialog.xlb exists
1005                     aCheckFileName = OUString( RTL_CONSTASCII_USTRINGPARAM("dialog") );
1006                     checkAndCopyFileImpl( aUserBasicStandardInetObj,
1007                                           aPrevUserBasicStandardInetObj,
1008                                           aCheckFileName, aXlbExtension, mxSFI );
1009
1010                     // Check if module1.xba exists
1011                     OUString aXbaExtension( OUString( RTL_CONSTASCII_USTRINGPARAM("xba") ) );
1012                     aCheckFileName = OUString( RTL_CONSTASCII_USTRINGPARAM("Module1") );
1013                     checkAndCopyFileImpl( aUserBasicStandardInetObj,
1014                                           aPrevUserBasicStandardInetObj,
1015                                           aCheckFileName, aXbaExtension, mxSFI );
1016                 }
1017                 else
1018                 {
1019                     String aStandardFolder = aUserBasicStandardInetObj.GetMainURL( INetURLObject::NO_DECODE );
1020                     mxSFI->copy( aStandardFolder, aPrevStandardFolder );
1021                 }
1022
1023                 String aPrevCopyToFolder = aPrevUserBasicInetObj_2.GetMainURL( INetURLObject::NO_DECODE );
1024                 mxSFI->copy( aPrevFolder, aPrevCopyToFolder );
1025             }
1026             else
1027             {
1028                 bSecondTime = true;
1029                 aPrevUserBasicInetObj = aPrevUserBasicInetObj_2;
1030                 aPrevFolder = aPrevUserBasicInetObj.GetMainURL( INetURLObject::NO_DECODE );
1031             }
1032             if( mxSFI->isFolder( aPrevFolder ) )
1033             {
1034                 SfxLibraryContainer* pPrevCont = createInstanceImpl();
1035                 Reference< XInterface > xRef = static_cast< XInterface* >( static_cast< OWeakObject* >(pPrevCont) );
1036
1037                 // Rename previous basic folder to make storage URLs correct during initialisation
1038                 String aFolderUserBasic = aUserBasicInetObj.GetMainURL( INetURLObject::NO_DECODE );
1039                 INetURLObject aUserBasicTmpInetObj( aUserBasicInetObj );
1040                 aUserBasicTmpInetObj.removeSegment();
1041                 aUserBasicTmpInetObj.Append( "__basic_tmp" );
1042                 String aFolderTmp = aUserBasicTmpInetObj.GetMainURL( INetURLObject::NO_DECODE );
1043
1044                 mxSFI->move( aFolderUserBasic, aFolderTmp );
1045                 try
1046                 {
1047                     mxSFI->move( aPrevFolder, aFolderUserBasic );
1048                 }
1049                 catch( Exception& )
1050                 {
1051                     // Move back user/basic folder
1052                     try
1053                     {
1054                            mxSFI->kill( aFolderUserBasic );
1055                     }
1056                     catch( Exception& )
1057                     {}
1058                     mxSFI->move( aFolderTmp, aFolderUserBasic );
1059                     throw;
1060                 }
1061
1062                 INetURLObject aPrevUserBasicLibInfoInetObj( aUserBasicInetObj );
1063                 aPrevUserBasicLibInfoInetObj.insertName( maInfoFileName, sal_True, INetURLObject::LAST_SEGMENT,
1064                                                     sal_True, INetURLObject::ENCODE_ALL );
1065                 aPrevUserBasicLibInfoInetObj.setExtension( OUString( RTL_CONSTASCII_USTRINGPARAM("xlc") ) );
1066                 OUString aLibInfoFileName = aPrevUserBasicLibInfoInetObj.GetMainURL( INetURLObject::NO_DECODE );
1067                 Sequence<Any> aInitSeq( 1 );
1068                 aInitSeq.getArray()[0] <<= aLibInfoFileName;
1069                 GbMigrationSuppressErrors = true;
1070                 pPrevCont->initialize( aInitSeq );
1071                 GbMigrationSuppressErrors = false;
1072
1073                 // Rename folders back
1074                 mxSFI->move( aFolderUserBasic, aPrevFolder );
1075                 mxSFI->move( aFolderTmp, aFolderUserBasic );
1076
1077                 OUString aUserSearchStr   = OUString::createFromAscii( "vnd.sun.star.expand:$UNO_USER_PACKAGES_CACHE" );
1078                 OUString aSharedSearchStr = OUString::createFromAscii( "vnd.sun.star.expand:$UNO_SHARED_PACKAGES_CACHE" );
1079                 OUString aInstSearchStr   = OUString::createFromAscii( "$(INST)" );
1080
1081                 Sequence< OUString > aNames = pPrevCont->getElementNames();
1082                 const OUString* pNames = aNames.getConstArray();
1083                 sal_Int32 nNameCount = aNames.getLength();
1084
1085                 for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
1086                 {
1087                     OUString aLibName = pNames[ i ];
1088                     if( hasByName( aLibName ) )
1089                     {
1090                         if( aLibName == aStandardStr )
1091                         {
1092                             SfxLibrary* pImplLib = getImplLib( aStandardStr );
1093                             INetURLObject aStandardFolderInetObj( pImplLib->maStorageURL );
1094                             String aStandardFolder = pImplLib->maStorageURL;
1095                             mxSFI->kill( aStandardFolder );
1096                         }
1097                         else
1098                         {
1099                             continue;
1100                         }
1101                     }
1102
1103                     SfxLibrary* pImplLib = pPrevCont->getImplLib( aLibName );
1104                     if( pImplLib->mbLink )
1105                     {
1106                         OUString aStorageURL = pImplLib->maUnexpandedStorageURL;
1107                         bool bCreateLink = true;
1108                         if( aStorageURL.indexOf( aUserSearchStr   ) != -1 ||
1109                             aStorageURL.indexOf( aSharedSearchStr ) != -1 ||
1110                             aStorageURL.indexOf( aInstSearchStr   ) != -1 )
1111                         {
1112                             bCreateLink = false;
1113                         }
1114                         if( bCreateLink )
1115                             createLibraryLink( aLibName, pImplLib->maStorageURL, pImplLib->mbReadOnly );
1116                     }
1117                     else
1118                     {
1119                         // Move folder if not already done
1120                         INetURLObject aUserBasicLibFolderInetObj( aUserBasicInetObj );
1121                         aUserBasicLibFolderInetObj.Append( aLibName );
1122                         String aLibFolder = aUserBasicLibFolderInetObj.GetMainURL( INetURLObject::NO_DECODE );
1123
1124                         INetURLObject aPrevUserBasicLibFolderInetObj( aPrevUserBasicInetObj );
1125                         aPrevUserBasicLibFolderInetObj.Append( aLibName );
1126                         String aPrevLibFolder = aPrevUserBasicLibFolderInetObj.GetMainURL( INetURLObject::NO_DECODE );
1127
1128                         if( mxSFI->isFolder( aPrevLibFolder ) && !mxSFI->isFolder( aLibFolder ) )
1129                             mxSFI->move( aPrevLibFolder, aLibFolder );
1130
1131                         if( aLibName == aStandardStr )
1132                                maNameContainer.removeByName( aLibName );
1133
1134                         // Create library
1135                         Reference< XNameContainer > xLib = createLibrary( aLibName );
1136                            SfxLibrary* pNewLib = static_cast< SfxLibrary* >( xLib.get() );
1137                         pNewLib->mbLoaded = false;
1138                         pNewLib->implSetModified( sal_False );
1139                         checkStorageURL( aLibFolder, pNewLib->maLibInfoFileURL,
1140                             pNewLib->maStorageURL, pNewLib->maUnexpandedStorageURL );
1141
1142                         uno::Reference< embed::XStorage > xDummyStor;
1143                         ::xmlscript::LibDescriptor aLibDesc;
1144                         /*sal_Bool bReadIndexFile =*/ implLoadLibraryIndexFile
1145                             ( pNewLib, aLibDesc, xDummyStor, pNewLib->maLibInfoFileURL );
1146                         implImportLibDescriptor( pNewLib, aLibDesc );
1147                     }
1148                 }
1149                 mxSFI->kill( aPrevFolder );
1150             }
1151         }
1152         catch( Exception& )
1153         {
1154             bCleanUp = true;
1155         }
1156
1157         // #i93163
1158         if( bCleanUp )
1159         {
1160             DBG_ERROR( "Upgrade of Basic installation failed somehow" );
1161
1162             static char strErrorSavFolderName[] = "__basic_80_err";
1163             INetURLObject aPrevUserBasicInetObj_Err( aUserBasicInetObj );
1164             aPrevUserBasicInetObj_Err.removeSegment();
1165             aPrevUserBasicInetObj_Err.Append( strErrorSavFolderName );
1166             String aPrevFolder_Err = aPrevUserBasicInetObj_Err.GetMainURL( INetURLObject::NO_DECODE );
1167
1168             bool bSaved = false;
1169             try
1170             {
1171                 String aPrevFolder_1 = aPrevUserBasicInetObj_1.GetMainURL( INetURLObject::NO_DECODE );
1172                 if( mxSFI->isFolder( aPrevFolder_1 ) )
1173                 {
1174                     mxSFI->move( aPrevFolder_1, aPrevFolder_Err );
1175                     bSaved = true;
1176                 }
1177             }
1178             catch( Exception& )
1179             {}
1180             try
1181             {
1182                 String aPrevFolder_2 = aPrevUserBasicInetObj_2.GetMainURL( INetURLObject::NO_DECODE );
1183                 if( !bSaved && mxSFI->isFolder( aPrevFolder_2 ) )
1184                     mxSFI->move( aPrevFolder_2, aPrevFolder_Err );
1185                 else
1186                     mxSFI->kill( aPrevFolder_2 );
1187             }
1188             catch( Exception& )
1189             {}
1190         }
1191     }
1192
1193     return sal_True;
1194 }
1195
1196 void SfxLibraryContainer::implScanExtensions( void )
1197 {
1198     ScriptExtensionIterator aScriptIt;
1199     rtl::OUString aLibURL;
1200
1201     bool bPureDialogLib = false;
1202     while( (aLibURL = aScriptIt.nextBasicOrDialogLibrary( bPureDialogLib )).getLength() > 0 )
1203     {
1204         if( bPureDialogLib && maInfoFileName.equalsAscii( "script" ) )
1205             continue;
1206
1207         // Extract lib name
1208         sal_Int32 nLen = aLibURL.getLength();
1209         sal_Int32 indexLastSlash = aLibURL.lastIndexOf( '/' );
1210         sal_Int32 nReduceCopy = 0;
1211         if( indexLastSlash == nLen - 1 )
1212         {
1213             nReduceCopy = 1;
1214             indexLastSlash = aLibURL.lastIndexOf( '/', nLen - 1 );
1215         }
1216
1217         OUString aLibName = aLibURL.copy( indexLastSlash + 1, nLen - indexLastSlash - nReduceCopy - 1 );
1218
1219         // If a library of the same exists the existing library wins
1220         if( hasByName( aLibName ) )
1221             continue;
1222
1223         // Add index file to URL
1224         OUString aIndexFileURL = aLibURL;
1225         if( nReduceCopy == 0 )
1226             aIndexFileURL += OUString::createFromAscii( "/" );
1227         aIndexFileURL += maInfoFileName;
1228         aIndexFileURL += OUString::createFromAscii( ".xlb" );
1229
1230         // Create link
1231         const bool bReadOnly = false;
1232         Reference< XNameAccess > xLib =
1233             createLibraryLink( aLibName, aIndexFileURL, bReadOnly );
1234     }
1235 }
1236
1237 // Handle maLibInfoFileURL and maStorageURL correctly
1238 void SfxLibraryContainer::checkStorageURL( const OUString& aSourceURL,
1239     OUString& aLibInfoFileURL, OUString& aStorageURL, OUString& aUnexpandedStorageURL )
1240 {
1241     OUString aExpandedSourceURL = expand_url( aSourceURL );
1242     if( aExpandedSourceURL != aSourceURL )
1243         aUnexpandedStorageURL = aSourceURL;
1244
1245     INetURLObject aInetObj( aExpandedSourceURL );
1246     OUString aExtension = aInetObj.getExtension();
1247     if( aExtension.compareToAscii( "xlb" ) == COMPARE_EQUAL )
1248     {
1249         // URL to xlb file
1250         aLibInfoFileURL = aExpandedSourceURL;
1251         aInetObj.removeSegment();
1252         aStorageURL = aInetObj.GetMainURL( INetURLObject::NO_DECODE );
1253     }
1254     else
1255     {
1256         // URL to library folder
1257         aStorageURL = aExpandedSourceURL;
1258         aInetObj.insertName( maInfoFileName, sal_True, INetURLObject::LAST_SEGMENT, sal_True, INetURLObject::ENCODE_ALL );
1259         aInetObj.setExtension( OUString( RTL_CONSTASCII_USTRINGPARAM("xlb") ) );
1260         aLibInfoFileURL = aInetObj.GetMainURL( INetURLObject::NO_DECODE );
1261     }
1262 }
1263
1264 SfxLibrary* SfxLibraryContainer::getImplLib( const String& rLibraryName )
1265 {
1266     Any aLibAny = maNameContainer.getByName( rLibraryName ) ;
1267     Reference< XNameAccess > xNameAccess;
1268     aLibAny >>= xNameAccess;
1269     SfxLibrary* pImplLib = static_cast< SfxLibrary* >( xNameAccess.get() );
1270     return pImplLib;
1271 }
1272
1273
1274 // Storing with password encryption
1275
1276 // Empty implementation, avoids unneccesary implementation in dlgcont.cxx
1277 sal_Bool SfxLibraryContainer::implStorePasswordLibrary(
1278     SfxLibrary*,
1279     const OUString&,
1280     const uno::Reference< embed::XStorage >&, const uno::Reference< task::XInteractionHandler >&  )
1281 {
1282     return sal_False;
1283 }
1284
1285 sal_Bool SfxLibraryContainer::implStorePasswordLibrary(
1286     SfxLibrary* /*pLib*/,
1287     const ::rtl::OUString& /*aName*/,
1288     const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& /*xStorage*/,
1289     const ::rtl::OUString& /*aTargetURL*/,
1290     const Reference< XSimpleFileAccess > /*xToUseSFI*/,
1291     const uno::Reference< task::XInteractionHandler >&  )
1292 {
1293     return sal_False;
1294 }
1295
1296 sal_Bool SfxLibraryContainer::implLoadPasswordLibrary(
1297     SfxLibrary* /*pLib*/,
1298     const OUString& /*Name*/,
1299     sal_Bool /*bVerifyPasswordOnly*/ )
1300 throw(WrappedTargetException, RuntimeException)
1301 {
1302     return sal_True;
1303 }
1304
1305
1306
1307 #define EXPAND_PROTOCOL "vnd.sun.star.expand"
1308 #define OUSTR(x) ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(x) )
1309
1310 OUString SfxLibraryContainer::createAppLibraryFolder
1311     ( SfxLibrary* pLib, const OUString& aName )
1312 {
1313     OUString aLibDirPath = pLib->maStorageURL;
1314     if( !aLibDirPath.getLength() )
1315     {
1316         INetURLObject aInetObj( String(maLibraryPath).GetToken(1) );
1317         aInetObj.insertName( aName, sal_True, INetURLObject::LAST_SEGMENT, sal_True, INetURLObject::ENCODE_ALL );
1318         checkStorageURL( aInetObj.GetMainURL( INetURLObject::NO_DECODE ), pLib->maLibInfoFileURL,
1319             pLib->maStorageURL, pLib->maUnexpandedStorageURL );
1320         aLibDirPath = pLib->maStorageURL;
1321     }
1322
1323     if( !mxSFI->isFolder( aLibDirPath ) )
1324     {
1325         try
1326         {
1327             mxSFI->createFolder( aLibDirPath );
1328         }
1329         catch( Exception& )
1330         {}
1331     }
1332
1333     return aLibDirPath;
1334 }
1335
1336 // Storing
1337 void SfxLibraryContainer::implStoreLibrary( SfxLibrary* pLib,
1338     const OUString& aName, const uno::Reference< embed::XStorage >& xStorage )
1339 {
1340     OUString aDummyLocation;
1341     Reference< XSimpleFileAccess > xDummySFA;
1342     Reference< XInteractionHandler > xDummyHandler;
1343     implStoreLibrary( pLib, aName, xStorage, aDummyLocation, xDummySFA, xDummyHandler );
1344 }
1345
1346 // New variant for library export
1347 void SfxLibraryContainer::implStoreLibrary( SfxLibrary* pLib,
1348     const OUString& aName, const uno::Reference< embed::XStorage >& xStorage,
1349     const ::rtl::OUString& aTargetURL, Reference< XSimpleFileAccess > xToUseSFI,
1350     const Reference< XInteractionHandler >& xHandler )
1351 {
1352     sal_Bool bLink = pLib->mbLink;
1353     sal_Bool bStorage = xStorage.is() && !bLink;
1354
1355     Sequence< OUString > aElementNames = pLib->getElementNames();
1356     sal_Int32 nNameCount = aElementNames.getLength();
1357     const OUString* pNames = aElementNames.getConstArray();
1358
1359     if( bStorage )
1360     {
1361         for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
1362         {
1363             OUString aElementName = pNames[ i ];
1364
1365             OUString aStreamName = aElementName;
1366             aStreamName += String( RTL_CONSTASCII_USTRINGPARAM(".xml") );
1367
1368             Any aElement = pLib->getByName( aElementName );
1369             if( !isLibraryElementValid( aElement ) )
1370             {
1371             #if OSL_DEBUG_LEVEL > 0
1372                 ::rtl::OStringBuffer aMessage;
1373                 aMessage.append( "invalid library element '" );
1374                 aMessage.append( ::rtl::OUStringToOString( aElementName, osl_getThreadTextEncoding() ) );
1375                 aMessage.append( "'." );
1376                 OSL_ENSURE( false, aMessage.makeStringAndClear().getStr() );
1377             #endif
1378                 continue;
1379             }
1380             try {
1381                 uno::Reference< io::XStream > xElementStream = xStorage->openStreamElement(
1382                                                                     aStreamName,
1383                                                                     embed::ElementModes::READWRITE );
1384                 //if ( !xElementStream.is() )
1385                 //    throw uno::RuntimeException(); // TODO: method must either return the stream or throw an exception
1386
1387                 String aPropName( String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM("MediaType") ) );
1388                 OUString aMime( RTL_CONSTASCII_USTRINGPARAM("text/xml") );
1389
1390                 uno::Reference< beans::XPropertySet > xProps( xElementStream, uno::UNO_QUERY );
1391                 OSL_ENSURE( xProps.is(), "The StorageStream must implement XPropertySet interface!\n" );
1392                 //if ( !xProps.is() ) //TODO
1393                 //    throw uno::RuntimeException();
1394
1395                 if ( xProps.is() )
1396                 {
1397                     xProps->setPropertyValue( aPropName, uno::makeAny( aMime ) );
1398
1399                     // #87671 Allow encryption
1400 //REMOVE                                aPropName = String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM("Encrypted") );
1401                     aPropName = String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "UseCommonStoragePasswordEncryption" ) );
1402                     xProps->setPropertyValue( aPropName, uno::makeAny( sal_True ) );
1403
1404                     Reference< XOutputStream > xOutput = xElementStream->getOutputStream();
1405                     writeLibraryElement( aElement, aElementName, xOutput );
1406                     // writeLibraryElement closes the stream
1407                     // xOutput->closeOutput();
1408                 }
1409             }
1410             catch( uno::Exception& )
1411             {
1412                 OSL_ENSURE( sal_False, "Problem during storing of library!\n" );
1413                 // TODO: error handling?
1414             }
1415         }
1416
1417         pLib->storeResourcesToStorage( xStorage );
1418     }
1419     else
1420     {
1421         // Export?
1422         bool bExport = aTargetURL.getLength();
1423         try
1424         {
1425             Reference< XSimpleFileAccess > xSFI = mxSFI;
1426             if( xToUseSFI.is() )
1427                 xSFI = xToUseSFI;
1428
1429             OUString aLibDirPath;
1430             if( bExport )
1431             {
1432                 INetURLObject aInetObj( aTargetURL );
1433                 aInetObj.insertName( aName, sal_True, INetURLObject::LAST_SEGMENT, sal_True, INetURLObject::ENCODE_ALL );
1434                 aLibDirPath = aInetObj.GetMainURL( INetURLObject::NO_DECODE );
1435
1436                 if( !xSFI->isFolder( aLibDirPath ) )
1437                     xSFI->createFolder( aLibDirPath );
1438
1439                 pLib->storeResourcesToURL( aLibDirPath, xHandler );
1440             }
1441             else
1442             {
1443                 aLibDirPath = createAppLibraryFolder( pLib, aName );
1444                 pLib->storeResources();
1445             }
1446
1447             for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
1448             {
1449                 OUString aElementName = pNames[ i ];
1450
1451                 INetURLObject aElementInetObj( aLibDirPath );
1452                 aElementInetObj.insertName( aElementName, sal_False,
1453                     INetURLObject::LAST_SEGMENT, sal_True, INetURLObject::ENCODE_ALL );
1454                 aElementInetObj.setExtension( maLibElementFileExtension );
1455                 String aElementPath( aElementInetObj.GetMainURL( INetURLObject::NO_DECODE ) );
1456
1457                 Any aElement = pLib->getByName( aElementName );
1458                 if( !isLibraryElementValid( aElement ) )
1459                 {
1460                 #if OSL_DEBUG_LEVEL > 0
1461                     ::rtl::OStringBuffer aMessage;
1462                     aMessage.append( "invalid library element '" );
1463                     aMessage.append( ::rtl::OUStringToOString( aElementName, osl_getThreadTextEncoding() ) );
1464                     aMessage.append( "'." );
1465                     OSL_ENSURE( false, aMessage.makeStringAndClear().getStr() );
1466                 #endif
1467                     continue;
1468                 }
1469
1470                 // TODO: Check modified
1471                 try
1472                 {
1473                     if( xSFI->exists( aElementPath ) )
1474                         xSFI->kill( aElementPath );
1475                     Reference< XOutputStream > xOutput = xSFI->openFileWrite( aElementPath );
1476                     writeLibraryElement( aElement, aElementName, xOutput );
1477                     xOutput->closeOutput();
1478                 }
1479                 catch( Exception& )
1480                 {
1481                     if( bExport )
1482                         throw;
1483
1484                     SfxErrorContext aEc( ERRCTX_SFX_SAVEDOC, aElementPath );
1485                     ULONG nErrorCode = ERRCODE_IO_GENERAL;
1486                     ErrorHandler::HandleError( nErrorCode );
1487                 }
1488             }
1489         }
1490         catch( Exception& )
1491         {
1492             if( bExport )
1493                 throw;
1494         }
1495     }
1496 }
1497
1498 void SfxLibraryContainer::implStoreLibraryIndexFile( SfxLibrary* pLib,
1499     const ::xmlscript::LibDescriptor& rLib, const uno::Reference< embed::XStorage >& xStorage )
1500 {
1501     OUString aDummyLocation;
1502     Reference< XSimpleFileAccess > xDummySFA;
1503     implStoreLibraryIndexFile( pLib, rLib, xStorage, aDummyLocation, xDummySFA );
1504 }
1505
1506 // New variant for library export
1507 void SfxLibraryContainer::implStoreLibraryIndexFile( SfxLibrary* pLib,
1508     const ::xmlscript::LibDescriptor& rLib, const uno::Reference< embed::XStorage >& xStorage,
1509     const ::rtl::OUString& aTargetURL, Reference< XSimpleFileAccess > xToUseSFI )
1510 {
1511     // Create sax writer
1512     Reference< XExtendedDocumentHandler > xHandler(
1513         mxMSF->createInstance(
1514             OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.xml.sax.Writer") ) ), UNO_QUERY );
1515     if( !xHandler.is() )
1516     {
1517         OSL_ENSURE( 0, "### couln't create sax-writer component\n" );
1518         return;
1519     }
1520
1521     sal_Bool bLink = pLib->mbLink;
1522     sal_Bool bStorage = xStorage.is() && !bLink;
1523
1524     // Write info file
1525     uno::Reference< io::XOutputStream > xOut;
1526     uno::Reference< io::XStream > xInfoStream;
1527     if( bStorage )
1528     {
1529         OUString aStreamName( maInfoFileName );
1530         aStreamName += String( RTL_CONSTASCII_USTRINGPARAM("-lb.xml") );
1531
1532         try {
1533             xInfoStream = xStorage->openStreamElement( aStreamName, embed::ElementModes::READWRITE );
1534             OSL_ENSURE( xInfoStream.is(), "No stream!\n" );
1535             uno::Reference< beans::XPropertySet > xProps( xInfoStream, uno::UNO_QUERY );
1536             //if ( !xProps.is() )
1537             //    throw uno::RuntimeException(); // TODO
1538
1539             if ( xProps.is() )
1540             {
1541                 String aPropName( String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM("MediaType") ) );
1542                 OUString aMime( RTL_CONSTASCII_USTRINGPARAM("text/xml") );
1543                 xProps->setPropertyValue( aPropName, uno::makeAny( aMime ) );
1544
1545                 // #87671 Allow encryption
1546 //REMOVE                        aPropName = String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM("Encrypted") );
1547                 aPropName = String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "UseCommonStoragePasswordEncryption" ) );
1548                 xProps->setPropertyValue( aPropName, uno::makeAny( sal_True ) );
1549
1550                 xOut = xInfoStream->getOutputStream();
1551             }
1552         }
1553         catch( uno::Exception& )
1554         {
1555             OSL_ENSURE( sal_False, "Problem during storing of library index file!\n" );
1556             // TODO: error handling?
1557         }
1558     }
1559     else
1560     {
1561         // Export?
1562         bool bExport = aTargetURL.getLength();
1563         Reference< XSimpleFileAccess > xSFI = mxSFI;
1564         if( xToUseSFI.is() )
1565             xSFI = xToUseSFI;
1566
1567         OUString aLibInfoPath;
1568         if( bExport )
1569         {
1570             INetURLObject aInetObj( aTargetURL );
1571             aInetObj.insertName( rLib.aName, sal_True, INetURLObject::LAST_SEGMENT, sal_True, INetURLObject::ENCODE_ALL );
1572             OUString aLibDirPath = aInetObj.GetMainURL( INetURLObject::NO_DECODE );
1573             if( !xSFI->isFolder( aLibDirPath ) )
1574                 xSFI->createFolder( aLibDirPath );
1575
1576             aInetObj.insertName( maInfoFileName, sal_True, INetURLObject::LAST_SEGMENT, sal_True, INetURLObject::ENCODE_ALL );
1577             aInetObj.setExtension( OUString( RTL_CONSTASCII_USTRINGPARAM("xlb") ) );
1578             aLibInfoPath = aInetObj.GetMainURL( INetURLObject::NO_DECODE );
1579         }
1580         else
1581         {
1582             createAppLibraryFolder( pLib, rLib.aName );
1583             aLibInfoPath = pLib->maLibInfoFileURL;
1584         }
1585
1586         try
1587         {
1588             if( xSFI->exists( aLibInfoPath ) )
1589                 xSFI->kill( aLibInfoPath );
1590             xOut = xSFI->openFileWrite( aLibInfoPath );
1591         }
1592         catch( Exception& )
1593         {
1594             if( bExport )
1595                 throw;
1596
1597             SfxErrorContext aEc( ERRCTX_SFX_SAVEDOC, aLibInfoPath );
1598             ULONG nErrorCode = ERRCODE_IO_GENERAL;
1599             ErrorHandler::HandleError( nErrorCode );
1600         }
1601     }
1602     if( !xOut.is() )
1603     {
1604         OSL_ENSURE( 0, "### couln't open output stream\n" );
1605         return;
1606     }
1607
1608     Reference< XActiveDataSource > xSource( xHandler, UNO_QUERY );
1609     xSource->setOutputStream( xOut );
1610
1611     xmlscript::exportLibrary( xHandler, rLib );
1612 }
1613
1614
1615 sal_Bool SfxLibraryContainer::implLoadLibraryIndexFile(  SfxLibrary* pLib,
1616     ::xmlscript::LibDescriptor& rLib, const uno::Reference< embed::XStorage >& xStorage, const OUString& aIndexFileName )
1617 {
1618     Reference< XParser > xParser( mxMSF->createInstance(
1619         OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.xml.sax.Parser") ) ), UNO_QUERY );
1620     if( !xParser.is() )
1621     {
1622         OSL_ENSURE( 0, "### couln't create sax parser component\n" );
1623         return sal_False;
1624     }
1625
1626     sal_Bool bLink = sal_False;
1627     sal_Bool bStorage = sal_False;
1628     if( pLib )
1629     {
1630         bLink = pLib->mbLink;
1631         bStorage = xStorage.is() && !bLink;
1632     }
1633
1634     // Read info file
1635     uno::Reference< io::XInputStream > xInput;
1636     String aLibInfoPath;
1637     if( bStorage )
1638     {
1639         aLibInfoPath = maInfoFileName;
1640         aLibInfoPath += String( RTL_CONSTASCII_USTRINGPARAM("-lb.xml") );
1641
1642         try {
1643             uno::Reference< io::XStream > xInfoStream =
1644                         xStorage->openStreamElement( aLibInfoPath, embed::ElementModes::READ );
1645             xInput = xInfoStream->getInputStream();
1646         }
1647         catch( uno::Exception& )
1648         {}
1649     }
1650     else
1651     {
1652         // Create Input stream
1653         //String aLibInfoPath; // attention: THIS PROBLEM MUST BE REVIEWED BY SCRIPTING OWNER!!!
1654
1655         if( pLib )
1656         {
1657             createAppLibraryFolder( pLib, rLib.aName );
1658             aLibInfoPath = pLib->maLibInfoFileURL;
1659         }
1660         else
1661             aLibInfoPath = aIndexFileName;
1662
1663         try
1664         {
1665             xInput = mxSFI->openFileRead( aLibInfoPath );
1666         }
1667         catch( Exception& )
1668         {
1669             xInput.clear();
1670             if( !GbMigrationSuppressErrors )
1671             {
1672                 SfxErrorContext aEc( ERRCTX_SFX_LOADBASIC, aLibInfoPath );
1673                 ULONG nErrorCode = ERRCODE_IO_GENERAL;
1674                 ErrorHandler::HandleError( nErrorCode );
1675             }
1676         }
1677     }
1678     if( !xInput.is() )
1679     {
1680         // OSL_ENSURE( 0, "### couln't open input stream\n" );
1681         return sal_False;
1682     }
1683
1684     InputSource source;
1685     source.aInputStream = xInput;
1686     source.sSystemId    = aLibInfoPath;
1687
1688     // start parsing
1689     try {
1690         xParser->setDocumentHandler( ::xmlscript::importLibrary( rLib ) );
1691         xParser->parseStream( source );
1692     }
1693     catch( Exception& )
1694     {
1695         // throw WrappedTargetException( OUString::createFromAscii( "parsing error!\n" ),
1696         //                                                              Reference< XInterface >(),
1697         //                                                              makeAny( e ) );
1698         OSL_ENSURE( 0, "Parsing error\n" );
1699         SfxErrorContext aEc( ERRCTX_SFX_LOADBASIC, aLibInfoPath );
1700         ULONG nErrorCode = ERRCODE_IO_GENERAL;
1701         ErrorHandler::HandleError( nErrorCode );
1702         return sal_False;
1703     }
1704
1705     if( !pLib )
1706     {
1707         Reference< XNameContainer > xLib = createLibrary( rLib.aName );
1708         pLib = static_cast< SfxLibrary* >( xLib.get() );
1709         pLib->mbLoaded = sal_False;
1710         rLib.aStorageURL = aIndexFileName;
1711         checkStorageURL( rLib.aStorageURL, pLib->maLibInfoFileURL, pLib->maStorageURL,
1712             pLib->maUnexpandedStorageURL );
1713
1714         implImportLibDescriptor( pLib, rLib );
1715     }
1716
1717     return sal_True;
1718 }
1719
1720 void SfxLibraryContainer::implImportLibDescriptor
1721     ( SfxLibrary* pLib, ::xmlscript::LibDescriptor& rLib )
1722 {
1723     if( !pLib->mbInitialised )
1724     {
1725         sal_Int32 nElementCount = rLib.aElementNames.getLength();
1726         const OUString* pElementNames = rLib.aElementNames.getConstArray();
1727         Any aDummyElement = createEmptyLibraryElement();
1728         for( sal_Int32 i = 0 ; i < nElementCount ; i++ )
1729         {
1730             pLib->maNameContainer.insertByName( pElementNames[i], aDummyElement );
1731         }
1732         pLib->mbPasswordProtected = rLib.bPasswordProtected;
1733         pLib->mbReadOnly = rLib.bReadOnly;
1734         pLib->mbPreload  = rLib.bPreload;
1735         pLib->implSetModified( sal_False );
1736
1737         pLib->mbInitialised = sal_True;
1738     }
1739 }
1740
1741
1742 // Methods of new XLibraryStorage interface?
1743 void SfxLibraryContainer::storeLibraries_Impl( const uno::Reference< embed::XStorage >& xStorage, sal_Bool bComplete )
1744 {
1745     const Sequence< OUString > aNames = maNameContainer.getElementNames();
1746     sal_Int32 nNameCount = aNames.getLength();
1747     const OUString* pName = aNames.getConstArray();
1748     const OUString* pNamesEnd = aNames.getConstArray() + nNameCount;
1749
1750     // Don't count libs from shared index file
1751     sal_Int32 nLibsToSave = nNameCount;
1752     for( ; pName != pNamesEnd; ++pName )
1753     {
1754         SfxLibrary* pImplLib = getImplLib( *pName );
1755         if( pImplLib->mbSharedIndexFile || pImplLib->mbExtension )
1756             nLibsToSave--;
1757     }
1758     if( !nLibsToSave )
1759         return;
1760
1761     ::xmlscript::LibDescriptorArray* pLibArray = new ::xmlscript::LibDescriptorArray( nLibsToSave );
1762
1763     // Write to storage?
1764     sal_Bool bStorage = xStorage.is();
1765     uno::Reference< embed::XStorage > xLibrariesStor;
1766     uno::Reference< embed::XStorage > xSourceLibrariesStor;
1767     if( bStorage )
1768     {
1769         // when we save to our root storage, ensure the libs are all loaded. Else the below cleaning
1770         // of the target storage will loose them.
1771         if ( xStorage == mxStorage )
1772         {
1773             pName = aNames.getConstArray();
1774             for ( ; pName != pNamesEnd; ++pName )
1775             {
1776                 if ( !isLibraryLoaded( *pName ) )
1777                     loadLibrary( *pName );
1778             }
1779         }
1780
1781         // first of all, clean the target library storage, since the storing procedure must do overwrite
1782         try
1783         {
1784             if ( xStorage->hasByName( maLibrariesDir ) )
1785                 xStorage->removeElement( maLibrariesDir );
1786         }
1787         catch( const uno::Exception& )
1788         {
1789             DBG_UNHANDLED_EXCEPTION();
1790             return;
1791         }
1792
1793         // Don't write if only empty standard lib exists
1794         if ( ( nNameCount == 1 ) && ( aNames[0].equalsAscii( "Standard" ) ) )
1795         {
1796             Any aLibAny = maNameContainer.getByName( aNames[0] );
1797             Reference< XNameAccess > xNameAccess;
1798             aLibAny >>= xNameAccess;
1799             if ( !xNameAccess->hasElements() )
1800                 return;
1801         }
1802
1803         try {
1804             xLibrariesStor.set( xStorage->openStorageElement( maLibrariesDir, embed::ElementModes::READWRITE ), UNO_QUERY_THROW );
1805         }
1806         catch( uno::Exception& )
1807         {
1808         #if OSL_DEBUG_LEVEL > 0
1809             Any aError( ::cppu::getCaughtException() );
1810             ::rtl::OStringBuffer aMessage;
1811             aMessage.append( "couln't open source library storage.\n\nException:" );
1812             aMessage.append( ::rtl::OUStringToOString( ::comphelper::anyToString( aError ), osl_getThreadTextEncoding() ) );
1813             OSL_ENSURE( false, aMessage.makeStringAndClear().getStr() );
1814         #endif
1815             return;
1816         }
1817
1818         try
1819         {
1820             if ( ( mxStorage != xStorage ) && ( mxStorage->hasByName( maLibrariesDir ) ) )
1821                 xSourceLibrariesStor = mxStorage->openStorageElement( maLibrariesDir, embed::ElementModes::READ );
1822         }
1823         catch( const uno::Exception& )
1824         {
1825             DBG_UNHANDLED_EXCEPTION();
1826         }
1827     }
1828
1829     int iArray = 0;
1830     pName = aNames.getConstArray();
1831     ::xmlscript::LibDescriptor aLibDescriptorForExtensionLibs;
1832     for( ; pName != pNamesEnd; ++pName )
1833     {
1834         SfxLibrary* pImplLib = getImplLib( *pName );
1835         if( pImplLib->mbSharedIndexFile )
1836             continue;
1837         bool bExtensionLib = pImplLib->mbExtension;
1838         ::xmlscript::LibDescriptor& rLib = bExtensionLib ?
1839             aLibDescriptorForExtensionLibs : pLibArray->mpLibs[iArray];
1840         if( !bExtensionLib )
1841             iArray++;
1842         rLib.aName = *pName;
1843
1844         rLib.bLink = pImplLib->mbLink;
1845         if( !bStorage || pImplLib->mbLink )
1846         {
1847             rLib.aStorageURL = ( pImplLib->maUnexpandedStorageURL.getLength() ) ?
1848                 pImplLib->maUnexpandedStorageURL : pImplLib->maLibInfoFileURL;
1849         }
1850         rLib.bReadOnly = pImplLib->mbReadOnly;
1851         rLib.bPreload = pImplLib->mbPreload;
1852         rLib.bPasswordProtected = pImplLib->mbPasswordProtected;
1853         rLib.aElementNames = pImplLib->getElementNames();
1854
1855         if( pImplLib->implIsModified() || bComplete )
1856         {
1857             // Can we copy the storage?
1858             if( !mbOldInfoFormat && !pImplLib->implIsModified() && !mbOasis2OOoFormat && xSourceLibrariesStor.is() )
1859             {
1860                 try {
1861                     xSourceLibrariesStor->copyElementTo( rLib.aName, xLibrariesStor, rLib.aName );
1862                 } catch( uno::Exception& )
1863                 {
1864                     DBG_UNHANDLED_EXCEPTION();
1865                     // TODO: error handling?
1866                 }
1867             }
1868             else
1869             {
1870                 uno::Reference< embed::XStorage > xLibraryStor;
1871                 if( bStorage )
1872                 {
1873                     try
1874                     {
1875                         xLibraryStor = xLibrariesStor->openStorageElement(
1876                                                                         rLib.aName,
1877                                                                         embed::ElementModes::READWRITE );
1878                     }
1879                     catch( uno::Exception& )
1880                     {
1881                     #if OSL_DEBUG_LEVEL > 0
1882                         Any aError( ::cppu::getCaughtException() );
1883                         ::rtl::OStringBuffer aMessage;
1884                         aMessage.append( "couln't create sub storage for library '" );
1885                         aMessage.append( ::rtl::OUStringToOString( rLib.aName, osl_getThreadTextEncoding() ) );
1886                         aMessage.append( "'.\n\nException:" );
1887                         aMessage.append( ::rtl::OUStringToOString( ::comphelper::anyToString( aError ), osl_getThreadTextEncoding() ) );
1888                         OSL_ENSURE( false, aMessage.makeStringAndClear().getStr() );
1889                     #endif
1890                         return;
1891                     }
1892                 }
1893
1894                 // Maybe lib is not loaded?!
1895                 if( bComplete )
1896                     loadLibrary( rLib.aName );
1897
1898                 if( pImplLib->mbPasswordProtected )
1899                     implStorePasswordLibrary( pImplLib, rLib.aName, xLibraryStor, uno::Reference< task::XInteractionHandler >() );
1900                     // TODO: Check return value
1901                 else
1902                     implStoreLibrary( pImplLib, rLib.aName, xLibraryStor );
1903
1904                 implStoreLibraryIndexFile( pImplLib, rLib, xLibraryStor );
1905                 if( bStorage )
1906                 {
1907                     try {
1908                         uno::Reference< embed::XTransactedObject > xTransact( xLibraryStor, uno::UNO_QUERY_THROW );
1909                         xTransact->commit();
1910                     }
1911                     catch( uno::Exception& )
1912                     {
1913                         DBG_UNHANDLED_EXCEPTION();
1914                         // TODO: error handling
1915                     }
1916                 }
1917             }
1918
1919             maModifiable.setModified( sal_True );
1920             pImplLib->implSetModified( sal_False );
1921         }
1922
1923         // For container info ReadOnly refers to mbReadOnlyLink
1924         rLib.bReadOnly = pImplLib->mbReadOnlyLink;
1925     }
1926
1927     if( !mbOldInfoFormat && !maModifiable.isModified() )
1928         return;
1929     maModifiable.setModified( sal_False );
1930     mbOldInfoFormat = sal_False;
1931
1932     // Write library container info
1933     // Create sax writer
1934     Reference< XExtendedDocumentHandler > xHandler(
1935         mxMSF->createInstance(
1936             OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.xml.sax.Writer") ) ), UNO_QUERY );
1937     if( !xHandler.is() )
1938     {
1939         OSL_ENSURE( 0, "### couln't create sax-writer component\n" );
1940         return;
1941     }
1942
1943     // Write info file
1944     uno::Reference< io::XOutputStream > xOut;
1945     uno::Reference< io::XStream > xInfoStream;
1946     if( bStorage )
1947     {
1948         OUString aStreamName( maInfoFileName );
1949         aStreamName += String( RTL_CONSTASCII_USTRINGPARAM("-lc.xml") );
1950
1951         try {
1952             xInfoStream = xLibrariesStor->openStreamElement( aStreamName, embed::ElementModes::READWRITE );
1953             uno::Reference< beans::XPropertySet > xProps( xInfoStream, uno::UNO_QUERY );
1954             OSL_ENSURE ( xProps.is(), "The stream must implement XPropertySet!\n" );
1955             if ( !xProps.is() )
1956                 throw uno::RuntimeException();
1957
1958             String aPropName( String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM("MediaType") ) );
1959             OUString aMime( RTL_CONSTASCII_USTRINGPARAM("text/xml") );
1960             xProps->setPropertyValue( aPropName, uno::makeAny( aMime ) );
1961
1962             // #87671 Allow encryption
1963             aPropName = String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM("UseCommonStoragePasswordEncryption") );
1964             xProps->setPropertyValue( aPropName, uno::makeAny( sal_True ) );
1965
1966             xOut = xInfoStream->getOutputStream();
1967         }
1968         catch( uno::Exception& )
1969         {
1970             ULONG nErrorCode = ERRCODE_IO_GENERAL;
1971             ErrorHandler::HandleError( nErrorCode );
1972         }
1973     }
1974     else
1975     {
1976         // Create Output stream
1977         INetURLObject aLibInfoInetObj( String(maLibraryPath).GetToken(1) );
1978         aLibInfoInetObj.insertName( maInfoFileName, sal_True, INetURLObject::LAST_SEGMENT, sal_True, INetURLObject::ENCODE_ALL );
1979         aLibInfoInetObj.setExtension( OUString( RTL_CONSTASCII_USTRINGPARAM("xlc") ) );
1980         String aLibInfoPath( aLibInfoInetObj.GetMainURL( INetURLObject::NO_DECODE ) );
1981
1982         try
1983         {
1984             if( mxSFI->exists( aLibInfoPath ) )
1985                 mxSFI->kill( aLibInfoPath );
1986             xOut = mxSFI->openFileWrite( aLibInfoPath );
1987         }
1988         catch( Exception& )
1989         {
1990             xOut.clear();
1991             SfxErrorContext aEc( ERRCTX_SFX_SAVEDOC, aLibInfoPath );
1992             ULONG nErrorCode = ERRCODE_IO_GENERAL;
1993             ErrorHandler::HandleError( nErrorCode );
1994         }
1995
1996     }
1997     if( !xOut.is() )
1998     {
1999         OSL_ENSURE( 0, "### couln't open output stream\n" );
2000         return;
2001     }
2002
2003     Reference< XActiveDataSource > xSource( xHandler, UNO_QUERY );
2004     xSource->setOutputStream( xOut );
2005
2006     try
2007     {
2008         xmlscript::exportLibraryContainer( xHandler, pLibArray );
2009         if ( bStorage )
2010         {
2011             uno::Reference< embed::XTransactedObject > xTransact( xLibrariesStor, uno::UNO_QUERY );
2012             OSL_ENSURE( xTransact.is(), "The storage must implement XTransactedObject!\n" );
2013             if ( !xTransact.is() )
2014                 throw uno::RuntimeException();
2015
2016             xTransact->commit();
2017         }
2018     }
2019     catch( uno::Exception& )
2020     {
2021         OSL_ENSURE( sal_False, "Problem during storing of libraries!\n" );
2022         ULONG nErrorCode = ERRCODE_IO_GENERAL;
2023         ErrorHandler::HandleError( nErrorCode );
2024     }
2025
2026     delete pLibArray;
2027 }
2028
2029
2030 // Methods XElementAccess
2031 Type SAL_CALL SfxLibraryContainer::getElementType()
2032     throw(RuntimeException)
2033 {
2034     LibraryContainerMethodGuard aGuard( *this );
2035     return maNameContainer.getElementType();
2036 }
2037
2038 sal_Bool SfxLibraryContainer::hasElements()
2039     throw(RuntimeException)
2040 {
2041     LibraryContainerMethodGuard aGuard( *this );
2042     sal_Bool bRet = maNameContainer.hasElements();
2043     return bRet;
2044 }
2045
2046 // Methods XNameAccess
2047 Any SfxLibraryContainer::getByName( const OUString& aName )
2048     throw(NoSuchElementException, WrappedTargetException, RuntimeException)
2049 {
2050     LibraryContainerMethodGuard aGuard( *this );
2051     Any aRetAny = maNameContainer.getByName( aName ) ;
2052     return aRetAny;
2053 }
2054
2055 Sequence< OUString > SfxLibraryContainer::getElementNames()
2056     throw(RuntimeException)
2057 {
2058     LibraryContainerMethodGuard aGuard( *this );
2059     return maNameContainer.getElementNames();
2060 }
2061
2062 sal_Bool SfxLibraryContainer::hasByName( const OUString& aName )
2063     throw(RuntimeException)
2064 {
2065     LibraryContainerMethodGuard aGuard( *this );
2066     return maNameContainer.hasByName( aName ) ;
2067 }
2068
2069 // Methods XLibraryContainer
2070 Reference< XNameContainer > SAL_CALL SfxLibraryContainer::createLibrary( const OUString& Name )
2071         throw(IllegalArgumentException, ElementExistException, RuntimeException)
2072 {
2073     LibraryContainerMethodGuard aGuard( *this );
2074     SfxLibrary* pNewLib = implCreateLibrary( Name );
2075     pNewLib->maLibElementFileExtension = maLibElementFileExtension;
2076
2077     createVariableURL( pNewLib->maUnexpandedStorageURL, Name, maInfoFileName, true );
2078
2079     Reference< XNameAccess > xNameAccess = static_cast< XNameAccess* >( pNewLib );
2080     Any aElement;
2081     aElement <<= xNameAccess;
2082     maNameContainer.insertByName( Name, aElement );
2083     maModifiable.setModified( sal_True );
2084     Reference< XNameContainer > xRet( xNameAccess, UNO_QUERY );
2085     return xRet;
2086 }
2087
2088 Reference< XNameAccess > SAL_CALL SfxLibraryContainer::createLibraryLink
2089     ( const OUString& Name, const OUString& StorageURL, sal_Bool ReadOnly )
2090         throw(IllegalArgumentException, ElementExistException, RuntimeException)
2091 {
2092     LibraryContainerMethodGuard aGuard( *this );
2093     // TODO: Check other reasons to force ReadOnly status
2094     //if( !ReadOnly )
2095     //{
2096     //}
2097
2098     OUString aLibInfoFileURL;
2099     OUString aLibDirURL;
2100     OUString aUnexpandedStorageURL;
2101     checkStorageURL( StorageURL, aLibInfoFileURL, aLibDirURL, aUnexpandedStorageURL );
2102
2103
2104     SfxLibrary* pNewLib = implCreateLibraryLink( Name, aLibInfoFileURL, aLibDirURL, ReadOnly );
2105     pNewLib->maLibElementFileExtension = maLibElementFileExtension;
2106     pNewLib->maUnexpandedStorageURL = aUnexpandedStorageURL;
2107
2108     OUString aInitFileName;
2109     uno::Reference< embed::XStorage > xDummyStor;
2110     ::xmlscript::LibDescriptor aLibDesc;
2111     /*sal_Bool bReadIndexFile = */implLoadLibraryIndexFile( pNewLib, aLibDesc, xDummyStor, aInitFileName );
2112     implImportLibDescriptor( pNewLib, aLibDesc );
2113
2114     Reference< XNameAccess > xRet = static_cast< XNameAccess* >( pNewLib );
2115     Any aElement;
2116     aElement <<= xRet;
2117     maNameContainer.insertByName( Name, aElement );
2118     maModifiable.setModified( sal_True );
2119
2120     OUString aUserSearchStr   = OUString::createFromAscii( "vnd.sun.star.expand:$UNO_USER_PACKAGES_CACHE" );
2121     OUString aSharedSearchStr = OUString::createFromAscii( "vnd.sun.star.expand:$UNO_SHARED_PACKAGES_CACHE" );
2122     if( StorageURL.indexOf( aUserSearchStr ) != -1 )
2123     {
2124         pNewLib->mbExtension = sal_True;
2125     }
2126     else if( StorageURL.indexOf( aSharedSearchStr ) != -1 )
2127     {
2128         pNewLib->mbExtension = sal_True;
2129         pNewLib->mbReadOnly = sal_True;
2130     }
2131
2132     return xRet;
2133 }
2134
2135 void SAL_CALL SfxLibraryContainer::removeLibrary( const OUString& Name )
2136     throw(NoSuchElementException, WrappedTargetException, RuntimeException)
2137 {
2138     LibraryContainerMethodGuard aGuard( *this );
2139     // Get and hold library before removing
2140     Any aLibAny = maNameContainer.getByName( Name ) ;
2141     Reference< XNameAccess > xNameAccess;
2142     aLibAny >>= xNameAccess;
2143     SfxLibrary* pImplLib = static_cast< SfxLibrary* >( xNameAccess.get() );
2144     if( pImplLib->mbReadOnly && !pImplLib->mbLink )
2145         throw IllegalArgumentException();
2146
2147     // Remove from container
2148     maNameContainer.removeByName( Name );
2149     maModifiable.setModified( sal_True );
2150
2151     // Delete library files, but not for linked libraries
2152     if( !pImplLib->mbLink )
2153     {
2154         if( mxStorage.is() )
2155             return;
2156         if( xNameAccess->hasElements() )
2157         {
2158             Sequence< OUString > aNames = pImplLib->getElementNames();
2159             sal_Int32 nNameCount = aNames.getLength();
2160             const OUString* pNames = aNames.getConstArray();
2161             for( sal_Int32 i = 0 ; i < nNameCount ; ++i, ++pNames )
2162             {
2163                 pImplLib->removeElementWithoutChecks( *pNames, SfxLibrary::LibraryContainerAccess() );
2164             }
2165         }
2166
2167         // Delete index file
2168         createAppLibraryFolder( pImplLib, Name );
2169         String aLibInfoPath = pImplLib->maLibInfoFileURL;
2170         try
2171         {
2172             if( mxSFI->exists( aLibInfoPath ) )
2173                 mxSFI->kill( aLibInfoPath );
2174         }
2175         catch( Exception& ) {}
2176
2177         // Delete folder if empty
2178         INetURLObject aInetObj( String(maLibraryPath).GetToken(1) );
2179         aInetObj.insertName( Name, sal_True, INetURLObject::LAST_SEGMENT,
2180             sal_True, INetURLObject::ENCODE_ALL );
2181         OUString aLibDirPath = aInetObj.GetMainURL( INetURLObject::NO_DECODE );
2182
2183         try
2184         {
2185             if( mxSFI->isFolder( aLibDirPath ) )
2186             {
2187                 Sequence< OUString > aContentSeq = mxSFI->getFolderContents( aLibDirPath, true );
2188                 sal_Int32 nCount = aContentSeq.getLength();
2189                 if( !nCount )
2190                     mxSFI->kill( aLibDirPath );
2191             }
2192         }
2193         catch( Exception& )
2194         {
2195         }
2196     }
2197 }
2198
2199 sal_Bool SAL_CALL SfxLibraryContainer::isLibraryLoaded( const OUString& Name )
2200     throw(NoSuchElementException, RuntimeException)
2201 {
2202     LibraryContainerMethodGuard aGuard( *this );
2203     SfxLibrary* pImplLib = getImplLib( Name );
2204     sal_Bool bRet = pImplLib->mbLoaded;
2205     return bRet;
2206 }
2207
2208
2209 void SAL_CALL SfxLibraryContainer::loadLibrary( const OUString& Name )
2210     throw(NoSuchElementException, WrappedTargetException, RuntimeException)
2211 {
2212     LibraryContainerMethodGuard aGuard( *this );
2213     Any aLibAny = maNameContainer.getByName( Name ) ;
2214     Reference< XNameAccess > xNameAccess;
2215     aLibAny >>= xNameAccess;
2216     SfxLibrary* pImplLib = static_cast< SfxLibrary* >( xNameAccess.get() );
2217
2218     sal_Bool bLoaded = pImplLib->mbLoaded;
2219     pImplLib->mbLoaded = sal_True;
2220     if( !bLoaded && xNameAccess->hasElements() )
2221     {
2222         if( pImplLib->mbPasswordProtected )
2223         {
2224             implLoadPasswordLibrary( pImplLib, Name );
2225             return;
2226         }
2227
2228         sal_Bool bLink = pImplLib->mbLink;
2229         sal_Bool bStorage = mxStorage.is() && !bLink;
2230
2231         uno::Reference< embed::XStorage > xLibrariesStor;
2232         uno::Reference< embed::XStorage > xLibraryStor;
2233         if( bStorage )
2234         {
2235             try {
2236                 xLibrariesStor = mxStorage->openStorageElement( maLibrariesDir, embed::ElementModes::READ );
2237                 OSL_ENSURE( xLibrariesStor.is(), "The method must either throw exception or return a storage!\n" );
2238                 if ( !xLibrariesStor.is() )
2239                     throw uno::RuntimeException();
2240
2241                 xLibraryStor = xLibrariesStor->openStorageElement( Name, embed::ElementModes::READ );
2242                 OSL_ENSURE( xLibraryStor.is(), "The method must either throw exception or return a storage!\n" );
2243                 if ( !xLibrariesStor.is() )
2244                     throw uno::RuntimeException();
2245             }
2246             catch( uno::Exception& )
2247             {
2248             #if OSL_DEBUG_LEVEL > 0
2249                 Any aError( ::cppu::getCaughtException() );
2250                 ::rtl::OStringBuffer aMessage;
2251                 aMessage.append( "couln't open sub storage for library '" );
2252                 aMessage.append( ::rtl::OUStringToOString( Name, osl_getThreadTextEncoding() ) );
2253                 aMessage.append( "'.\n\nException:" );
2254                 aMessage.append( ::rtl::OUStringToOString( ::comphelper::anyToString( aError ), osl_getThreadTextEncoding() ) );
2255                 OSL_ENSURE( false, aMessage.makeStringAndClear().getStr() );
2256             #endif
2257                 return;
2258             }
2259         }
2260
2261         Sequence< OUString > aNames = pImplLib->getElementNames();
2262         sal_Int32 nNameCount = aNames.getLength();
2263         const OUString* pNames = aNames.getConstArray();
2264         for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
2265         {
2266             OUString aElementName = pNames[ i ];
2267
2268             OUString aFile;
2269             uno::Reference< io::XInputStream > xInStream;
2270
2271             if( bStorage )
2272             {
2273                 uno::Reference< io::XStream > xElementStream;
2274
2275                 aFile = aElementName;
2276                 aFile += String( RTL_CONSTASCII_USTRINGPARAM(".xml") );
2277
2278                 try {
2279                     xElementStream = xLibraryStor->openStreamElement( aFile, embed::ElementModes::READ );
2280                 } catch( uno::Exception& )
2281                 {}
2282
2283                 if( !xElementStream.is() )
2284                 {
2285                     // Check for EA2 document version with wrong extensions
2286                     aFile = aElementName;
2287                     aFile += String( RTL_CONSTASCII_USTRINGPARAM(".") );
2288                     aFile += maLibElementFileExtension;
2289                     try {
2290                         xElementStream = xLibraryStor->openStreamElement( aFile, embed::ElementModes::READ );
2291                     } catch( uno::Exception& )
2292                     {}
2293                 }
2294
2295                 if ( xElementStream.is() )
2296                     xInStream = xElementStream->getInputStream();
2297
2298                 if ( !xInStream.is() )
2299                 {
2300                 #if OSL_DEBUG_LEVEL > 0
2301                     ::rtl::OStringBuffer aMessage;
2302                     aMessage.append( "couln't open library element stream - attempted to open library '" );
2303                     aMessage.append( ::rtl::OUStringToOString( Name, osl_getThreadTextEncoding() ) );
2304                     aMessage.append( "'." );
2305                     OSL_ENSURE( false, aMessage.makeStringAndClear().getStr() );
2306                 #endif
2307                     return;
2308                 }
2309             }
2310             else
2311             {
2312                 String aLibDirPath = pImplLib->maStorageURL;
2313                 INetURLObject aElementInetObj( aLibDirPath );
2314                 aElementInetObj.insertName( aElementName, sal_False,
2315                     INetURLObject::LAST_SEGMENT, sal_True, INetURLObject::ENCODE_ALL );
2316                 aElementInetObj.setExtension( maLibElementFileExtension );
2317                 aFile = aElementInetObj.GetMainURL( INetURLObject::NO_DECODE );
2318             }
2319
2320             Any aAny = importLibraryElement( aFile, xInStream );
2321             if( pImplLib->hasByName( aElementName ) )
2322             {
2323                 if( aAny.hasValue() )
2324                     pImplLib->maNameContainer.replaceByName( aElementName, aAny );
2325             }
2326             else
2327             {
2328                 pImplLib->maNameContainer.insertByName( aElementName, aAny );
2329             }
2330         }
2331
2332         pImplLib->implSetModified( sal_False );
2333     }
2334 }
2335
2336 // Methods XLibraryContainer2
2337 sal_Bool SAL_CALL SfxLibraryContainer::isLibraryLink( const OUString& Name )
2338     throw (NoSuchElementException, RuntimeException)
2339 {
2340     LibraryContainerMethodGuard aGuard( *this );
2341     SfxLibrary* pImplLib = getImplLib( Name );
2342     sal_Bool bRet = pImplLib->mbLink;
2343     return bRet;
2344 }
2345
2346 OUString SAL_CALL SfxLibraryContainer::getLibraryLinkURL( const OUString& Name )
2347     throw (IllegalArgumentException, NoSuchElementException, RuntimeException)
2348 {
2349     LibraryContainerMethodGuard aGuard( *this );
2350     SfxLibrary* pImplLib = getImplLib( Name );
2351     sal_Bool bLink = pImplLib->mbLink;
2352     if( !bLink )
2353         throw IllegalArgumentException();
2354     OUString aRetStr = pImplLib->maLibInfoFileURL;
2355     return aRetStr;
2356 }
2357
2358 sal_Bool SAL_CALL SfxLibraryContainer::isLibraryReadOnly( const OUString& Name )
2359     throw (NoSuchElementException, RuntimeException)
2360 {
2361     LibraryContainerMethodGuard aGuard( *this );
2362     SfxLibrary* pImplLib = getImplLib( Name );
2363     sal_Bool bRet = pImplLib->mbReadOnly || (pImplLib->mbLink && pImplLib->mbReadOnlyLink);
2364     return bRet;
2365 }
2366
2367 void SAL_CALL SfxLibraryContainer::setLibraryReadOnly( const OUString& Name, sal_Bool bReadOnly )
2368     throw (NoSuchElementException, RuntimeException)
2369 {
2370     LibraryContainerMethodGuard aGuard( *this );
2371     SfxLibrary* pImplLib = getImplLib( Name );
2372     if( pImplLib->mbLink )
2373     {
2374         if( pImplLib->mbReadOnlyLink != bReadOnly )
2375         {
2376             pImplLib->mbReadOnlyLink = bReadOnly;
2377             pImplLib->implSetModified( sal_True );
2378             maModifiable.setModified( sal_True );
2379         }
2380     }
2381     else
2382     {
2383         if( pImplLib->mbReadOnly != bReadOnly )
2384         {
2385             pImplLib->mbReadOnly = bReadOnly;
2386             pImplLib->implSetModified( sal_True );
2387         }
2388     }
2389 }
2390
2391 void SAL_CALL SfxLibraryContainer::renameLibrary( const OUString& Name, const OUString& NewName )
2392     throw (NoSuchElementException, ElementExistException, RuntimeException)
2393 {
2394     LibraryContainerMethodGuard aGuard( *this );
2395     if( maNameContainer.hasByName( NewName ) )
2396         throw ElementExistException();
2397
2398     // Get and hold library before removing
2399     Any aLibAny = maNameContainer.getByName( Name ) ;
2400
2401     // #i24094 Maybe lib is not loaded!
2402     Reference< XNameAccess > xNameAccess;
2403     aLibAny >>= xNameAccess;
2404     SfxLibrary* pImplLib = static_cast< SfxLibrary* >( xNameAccess.get() );
2405     if( pImplLib->mbPasswordProtected && !pImplLib->mbPasswordVerified )
2406         return;         // Lib with unverified password cannot be renamed
2407     loadLibrary( Name );
2408
2409     // Remove from container
2410     maNameContainer.removeByName( Name );
2411     maModifiable.setModified( sal_True );
2412
2413     // Rename library folder, but not for linked libraries
2414     bool bMovedSuccessful = true;
2415
2416     // Rename files
2417     sal_Bool bStorage = mxStorage.is();
2418     if( !bStorage && !pImplLib->mbLink )
2419     {
2420         bMovedSuccessful = false;
2421
2422         OUString aLibDirPath = pImplLib->maStorageURL;
2423
2424         INetURLObject aDestInetObj( String(maLibraryPath).GetToken(1) );
2425         aDestInetObj.insertName( NewName, sal_True, INetURLObject::LAST_SEGMENT,
2426             sal_True, INetURLObject::ENCODE_ALL );
2427         OUString aDestDirPath = aDestInetObj.GetMainURL( INetURLObject::NO_DECODE );
2428
2429         // Store new URL
2430         OUString aLibInfoFileURL = pImplLib->maLibInfoFileURL;
2431         checkStorageURL( aDestDirPath, pImplLib->maLibInfoFileURL, pImplLib->maStorageURL,
2432             pImplLib->maUnexpandedStorageURL );
2433
2434         try
2435         {
2436             if( mxSFI->isFolder( aLibDirPath ) )
2437             {
2438                 if( !mxSFI->isFolder( aDestDirPath ) )
2439                     mxSFI->createFolder( aDestDirPath );
2440
2441                 // Move index file
2442                 try
2443                 {
2444                     if( mxSFI->exists( pImplLib->maLibInfoFileURL ) )
2445                         mxSFI->kill( pImplLib->maLibInfoFileURL );
2446                     mxSFI->move( aLibInfoFileURL, pImplLib->maLibInfoFileURL );
2447                 }
2448                 catch( Exception& )
2449                 {
2450                 }
2451
2452                 Sequence< OUString > aElementNames = xNameAccess->getElementNames();
2453                 sal_Int32 nNameCount = aElementNames.getLength();
2454                 const OUString* pNames = aElementNames.getConstArray();
2455                 for( sal_Int32 i = 0 ; i < nNameCount ; i++ )
2456                 {
2457                     OUString aElementName = pNames[ i ];
2458
2459                     INetURLObject aElementInetObj( aLibDirPath );
2460                     aElementInetObj.insertName( aElementName, sal_False,
2461                         INetURLObject::LAST_SEGMENT, sal_True, INetURLObject::ENCODE_ALL );
2462                     aElementInetObj.setExtension( maLibElementFileExtension );
2463                     String aElementPath( aElementInetObj.GetMainURL( INetURLObject::NO_DECODE ) );
2464
2465                     INetURLObject aElementDestInetObj( aDestDirPath );
2466                     aElementDestInetObj.insertName( aElementName, sal_False,
2467                         INetURLObject::LAST_SEGMENT, sal_True, INetURLObject::ENCODE_ALL );
2468                     aElementDestInetObj.setExtension( maLibElementFileExtension );
2469                     String aDestElementPath( aElementDestInetObj.GetMainURL( INetURLObject::NO_DECODE ) );
2470
2471                     try
2472                     {
2473                         if( mxSFI->exists( aDestElementPath ) )
2474                             mxSFI->kill( aDestElementPath );
2475                         mxSFI->move( aElementPath, aDestElementPath );
2476                     }
2477                     catch( Exception& )
2478                     {
2479                     }
2480                 }
2481                 pImplLib->storeResourcesAsURL( aDestDirPath, NewName );
2482
2483                 // Delete folder if empty
2484                 Sequence< OUString > aContentSeq = mxSFI->getFolderContents( aLibDirPath, true );
2485                 sal_Int32 nCount = aContentSeq.getLength();
2486                 if( !nCount )
2487                 {
2488                        mxSFI->kill( aLibDirPath );
2489                 }
2490
2491                 bMovedSuccessful = true;
2492                 pImplLib->implSetModified( sal_True );
2493             }
2494         }
2495         catch( Exception& )
2496         {
2497             // Restore old library
2498             maNameContainer.insertByName( Name, aLibAny ) ;
2499         }
2500     }
2501
2502     if( bStorage && !pImplLib->mbLink )
2503         pImplLib->implSetModified( sal_True );
2504
2505     if( bMovedSuccessful )
2506            maNameContainer.insertByName( NewName, aLibAny ) ;
2507
2508 }
2509
2510
2511 // Methods XInitialization
2512 void SAL_CALL SfxLibraryContainer::initialize( const Sequence< Any >& _rArguments )
2513     throw (Exception, RuntimeException)
2514 {
2515     LibraryContainerMethodGuard aGuard( *this );
2516     sal_Int32 nArgCount = _rArguments.getLength();
2517     if ( nArgCount == 1 )
2518     {
2519         OUString sInitialDocumentURL;
2520         Reference< XStorageBasedDocument > xDocument;
2521         if ( _rArguments[0] >>= sInitialDocumentURL )
2522         {
2523             initializeFromDocumentURL( sInitialDocumentURL );
2524             return;
2525         }
2526
2527         if ( _rArguments[0] >>= xDocument )
2528         {
2529             initializeFromDocument( xDocument );
2530             return;
2531         }
2532     }
2533
2534     throw IllegalArgumentException();
2535 }
2536
2537 void SAL_CALL SfxLibraryContainer::initializeFromDocumentURL( const ::rtl::OUString& _rInitialDocumentURL )
2538 {
2539     init( _rInitialDocumentURL, NULL );
2540 }
2541
2542 void SAL_CALL SfxLibraryContainer::initializeFromDocument( const Reference< XStorageBasedDocument >& _rxDocument )
2543 {
2544     // check whether this is a valid OfficeDocument, and obtain the document's root storage
2545     Reference< XStorage > xDocStorage;
2546     try
2547     {
2548         Reference< XServiceInfo > xSI( _rxDocument, UNO_QUERY_THROW );
2549         if ( xSI->supportsService( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.document.OfficeDocument" ) ) ) )
2550             xDocStorage.set( _rxDocument->getDocumentStorage(), UNO_QUERY_THROW );
2551
2552         Reference< XModel > xDocument( _rxDocument, UNO_QUERY_THROW );
2553         Reference< XComponent > xDocComponent( _rxDocument, UNO_QUERY_THROW );
2554
2555         mxOwnerDocument = xDocument;
2556         startComponentListening( xDocComponent );
2557     }
2558     catch( const Exception& ) { }
2559
2560     if ( !xDocStorage.is() )
2561         throw IllegalArgumentException();
2562
2563     init( OUString(), xDocStorage );
2564 }
2565
2566 // OEventListenerAdapter
2567 void SfxLibraryContainer::_disposing( const EventObject& _rSource )
2568 {
2569 #if OSL_DEBUG_LEVEL > 0
2570     Reference< XModel > xDocument( mxOwnerDocument.get(), UNO_QUERY );
2571     OSL_ENSURE( ( xDocument == _rSource.Source ) && xDocument.is(), "SfxLibraryContainer::_disposing: where does this come from?" );
2572 #else
2573     (void)_rSource;
2574 #endif
2575     dispose();
2576 }
2577
2578 // OComponentHelper
2579 void SAL_CALL SfxLibraryContainer::disposing()
2580 {
2581     stopAllComponentListening();
2582     mxOwnerDocument = WeakReference< XModel >();
2583 }
2584
2585 // Methods XLibraryContainerPassword
2586 sal_Bool SAL_CALL SfxLibraryContainer::isLibraryPasswordProtected( const OUString& )
2587     throw (NoSuchElementException, RuntimeException)
2588 {
2589     LibraryContainerMethodGuard aGuard( *this );
2590     return sal_False;
2591 }
2592
2593 sal_Bool SAL_CALL SfxLibraryContainer::isLibraryPasswordVerified( const OUString& )
2594     throw (IllegalArgumentException, NoSuchElementException, RuntimeException)
2595 {
2596     LibraryContainerMethodGuard aGuard( *this );
2597     throw IllegalArgumentException();
2598 }
2599
2600 sal_Bool SAL_CALL SfxLibraryContainer::verifyLibraryPassword
2601     ( const OUString&, const OUString& )
2602         throw (IllegalArgumentException, NoSuchElementException, RuntimeException)
2603 {
2604     LibraryContainerMethodGuard aGuard( *this );
2605     throw IllegalArgumentException();
2606 }
2607
2608 void SAL_CALL SfxLibraryContainer::changeLibraryPassword(
2609     const OUString&, const OUString&, const OUString& )
2610         throw (IllegalArgumentException, NoSuchElementException, RuntimeException)
2611 {
2612     LibraryContainerMethodGuard aGuard( *this );
2613     throw IllegalArgumentException();
2614 }
2615
2616 // Methods XContainer
2617 void SAL_CALL SfxLibraryContainer::addContainerListener( const Reference< XContainerListener >& xListener )
2618     throw (RuntimeException)
2619 {
2620     LibraryContainerMethodGuard aGuard( *this );
2621     maNameContainer.setEventSource( static_cast< XInterface* >( (OWeakObject*)this ) );
2622     maNameContainer.addContainerListener( xListener );
2623 }
2624
2625 void SAL_CALL SfxLibraryContainer::removeContainerListener( const Reference< XContainerListener >& xListener )
2626     throw (RuntimeException)
2627 {
2628     LibraryContainerMethodGuard aGuard( *this );
2629     maNameContainer.removeContainerListener( xListener );
2630 }
2631
2632 // Methods XLibraryContainerExport
2633 void SAL_CALL SfxLibraryContainer::exportLibrary( const OUString& Name, const OUString& URL,
2634     const Reference< XInteractionHandler >& Handler )
2635         throw ( uno::Exception, NoSuchElementException, RuntimeException)
2636 {
2637     LibraryContainerMethodGuard aGuard( *this );
2638     SfxLibrary* pImplLib = getImplLib( Name );
2639
2640     Reference< XSimpleFileAccess > xToUseSFI;
2641     if( Handler.is() )
2642     {
2643         xToUseSFI = Reference< XSimpleFileAccess >( mxMSF->createInstance
2644             ( OUString::createFromAscii( "com.sun.star.ucb.SimpleFileAccess" ) ), UNO_QUERY );
2645         if( xToUseSFI.is() )
2646             xToUseSFI->setInteractionHandler( Handler );
2647     }
2648
2649     // Maybe lib is not loaded?!
2650     loadLibrary( Name );
2651
2652     uno::Reference< ::com::sun::star::embed::XStorage > xDummyStor;
2653     if( pImplLib->mbPasswordProtected )
2654         implStorePasswordLibrary( pImplLib, Name, xDummyStor, URL, xToUseSFI, Handler );
2655     else
2656         implStoreLibrary( pImplLib, Name, xDummyStor, URL, xToUseSFI, Handler );
2657
2658     ::xmlscript::LibDescriptor aLibDesc;
2659     aLibDesc.aName = Name;
2660     aLibDesc.bLink = false;                             // Link status gets lost?
2661     aLibDesc.bReadOnly = pImplLib->mbReadOnly;
2662     aLibDesc.bPreload = false;                  // Preload status gets lost?
2663     aLibDesc.bPasswordProtected = pImplLib->mbPasswordProtected;
2664     aLibDesc.aElementNames = pImplLib->getElementNames();
2665
2666     implStoreLibraryIndexFile( pImplLib, aLibDesc, xDummyStor, URL, xToUseSFI );
2667 }
2668
2669 OUString SfxLibraryContainer::expand_url( const OUString& url )
2670     throw(::com::sun::star::uno::RuntimeException)
2671 {
2672     if (0 == url.compareToAscii( RTL_CONSTASCII_STRINGPARAM(EXPAND_PROTOCOL ":") ))
2673     {
2674         if( !mxMacroExpander.is() )
2675         {
2676             Reference< XPropertySet > xProps( mxMSF, UNO_QUERY );
2677             OSL_ASSERT( xProps.is() );
2678             if( xProps.is() )
2679             {
2680                 Reference< XComponentContext > xContext;
2681                 xProps->getPropertyValue(
2682                     OUString( RTL_CONSTASCII_USTRINGPARAM("DefaultContext") ) ) >>= xContext;
2683                 OSL_ASSERT( xContext.is() );
2684                 if( xContext.is() )
2685                 {
2686                     Reference< util::XMacroExpander > xExpander;
2687                     xContext->getValueByName(
2688                         OUSTR("/singletons/com.sun.star.util.theMacroExpander") ) >>= xExpander;
2689                     if(! xExpander.is())
2690                     {
2691                         throw uno::DeploymentException(
2692                             OUSTR("no macro expander singleton available!"), Reference< XInterface >() );
2693                     }
2694                     MutexGuard guard( Mutex::getGlobalMutex() );
2695                     if( !mxMacroExpander.is() )
2696                     {
2697                         mxMacroExpander = xExpander;
2698                     }
2699                 }
2700             }
2701         }
2702
2703         if( !mxMacroExpander.is() )
2704             return url;
2705
2706         // cut protocol
2707         OUString macro( url.copy( sizeof (EXPAND_PROTOCOL ":") -1 ) );
2708         // decode uric class chars
2709         macro = Uri::decode( macro, rtl_UriDecodeWithCharset, RTL_TEXTENCODING_UTF8 );
2710         // expand macro string
2711         OUString ret( mxMacroExpander->expandMacros( macro ) );
2712         return ret;
2713     }
2714     else if( mxStringSubstitution.is() )
2715     {
2716         OUString ret( mxStringSubstitution->substituteVariables( url, false ) );
2717         return ret;
2718     }
2719     else
2720     {
2721         return url;
2722     }
2723 }
2724
2725 ::sal_Bool SAL_CALL SfxLibraryContainer::getVBACompatModeOn() throw (RuntimeException)
2726 {
2727         sal_Bool bVBACompat = sal_False;
2728         BasicManager* pBasMgr = getBasicManager();
2729         if( pBasMgr )
2730         {
2731                 // get the standard library
2732                 String aLibName( RTL_CONSTASCII_USTRINGPARAM( "Standard" ) );
2733
2734                 if ( pBasMgr->GetName().Len() )
2735                     aLibName = pBasMgr->GetName();
2736
2737                 StarBASIC* pBasic = pBasMgr->GetLib( aLibName );
2738                 if( pBasic )
2739                         bVBACompat = pBasic->isVBAEnabled();
2740         }
2741
2742         return bVBACompat;
2743 }
2744
2745 void SAL_CALL SfxLibraryContainer::setVBACompatModeOn( ::sal_Bool _vbacompatmodeon ) throw (RuntimeException)
2746 {
2747         BasicManager* pBasMgr = getBasicManager();
2748         if( pBasMgr )
2749         {
2750                 // get the standard library
2751                 String aLibName( RTL_CONSTASCII_USTRINGPARAM( "Standard" ) );
2752                 StarBASIC* pBasic = pBasMgr->GetLib( aLibName );
2753                 if( pBasic )
2754                         pBasic->SetVBAEnabled( _vbacompatmodeon );
2755         }
2756 }
2757
2758 // Methods XServiceInfo
2759 ::sal_Bool SAL_CALL SfxLibraryContainer::supportsService( const ::rtl::OUString& _rServiceName )
2760     throw (RuntimeException)
2761 {
2762     LibraryContainerMethodGuard aGuard( *this );
2763     Sequence< OUString > aSupportedServices( getSupportedServiceNames() );
2764     const OUString* pSupportedServices = aSupportedServices.getConstArray();
2765     for ( sal_Int32 i=0; i<aSupportedServices.getLength(); ++i, ++pSupportedServices )
2766         if ( *pSupportedServices == _rServiceName )
2767             return sal_True;
2768     return sal_False;
2769 }
2770
2771 //============================================================================
2772
2773 // Implementation class SfxLibrary
2774
2775 // Ctor
2776 SfxLibrary::SfxLibrary( ModifiableHelper& _rModifiable, const Type& aType,
2777     const Reference< XMultiServiceFactory >& xMSF, const Reference< XSimpleFileAccess >& xSFI )
2778         : OComponentHelper( m_aMutex )
2779         , mxMSF( xMSF )
2780         , mxSFI( xSFI )
2781         , mrModifiable( _rModifiable )
2782         , maNameContainer( aType )
2783         , mbLoaded( sal_True )
2784         , mbIsModified( sal_True )
2785         , mbInitialised( sal_False )
2786         , mbLink( sal_False )
2787         , mbReadOnly( sal_False )
2788         , mbReadOnlyLink( sal_False )
2789         , mbPreload( sal_False )
2790         , mbPasswordProtected( sal_False )
2791         , mbPasswordVerified( sal_False )
2792         , mbDoc50Password( sal_False )
2793         , mbSharedIndexFile( sal_False )
2794         , mbExtension( sal_False )
2795 {
2796 }
2797
2798 SfxLibrary::SfxLibrary( ModifiableHelper& _rModifiable, const Type& aType,
2799     const Reference< XMultiServiceFactory >& xMSF, const Reference< XSimpleFileAccess >& xSFI,
2800     const OUString& aLibInfoFileURL, const OUString& aStorageURL, sal_Bool ReadOnly )
2801         : OComponentHelper( m_aMutex )
2802         , mxMSF( xMSF )
2803         , mxSFI( xSFI )
2804         , mrModifiable( _rModifiable )
2805         , maNameContainer( aType )
2806         , mbLoaded( sal_False )
2807         , mbIsModified( sal_True )
2808         , mbInitialised( sal_False )
2809         , maLibInfoFileURL( aLibInfoFileURL )
2810         , maStorageURL( aStorageURL )
2811         , mbLink( sal_True )
2812         , mbReadOnly( sal_False )
2813         , mbReadOnlyLink( ReadOnly )
2814         , mbPreload( sal_False )
2815         , mbPasswordProtected( sal_False )
2816         , mbPasswordVerified( sal_False )
2817         , mbDoc50Password( sal_False )
2818         , mbSharedIndexFile( sal_False )
2819         , mbExtension( sal_False )
2820 {
2821 }
2822
2823 void SfxLibrary::implSetModified( sal_Bool _bIsModified )
2824 {
2825     if ( mbIsModified == _bIsModified )
2826         return;
2827     mbIsModified = _bIsModified;
2828     if ( mbIsModified )
2829         mrModifiable.setModified( sal_True );
2830 }
2831
2832 // Methods XInterface
2833 Any SAL_CALL SfxLibrary::queryInterface( const Type& rType )
2834     throw( RuntimeException )
2835 {
2836     Any aRet;
2837
2838     /*
2839     if( mbReadOnly )
2840     {
2841         aRet = Any( ::cppu::queryInterface( rType,
2842             static_cast< XContainer * >( this ),
2843             static_cast< XNameAccess * >( this ) ) );
2844     }
2845     else
2846     {
2847     */
2848         aRet = Any( ::cppu::queryInterface( rType,
2849             static_cast< XContainer * >( this ),
2850             static_cast< XNameContainer * >( this ),
2851             static_cast< XNameAccess * >( this ) ) );
2852     //}
2853     if( !aRet.hasValue() )
2854         aRet = OComponentHelper::queryInterface( rType );
2855     return aRet;
2856 }
2857
2858 // Methods XElementAccess
2859 Type SfxLibrary::getElementType()
2860     throw(RuntimeException)
2861 {
2862     return maNameContainer.getElementType();
2863 }
2864
2865 sal_Bool SfxLibrary::hasElements()
2866     throw(RuntimeException)
2867 {
2868     sal_Bool bRet = maNameContainer.hasElements();
2869     return bRet;
2870 }
2871
2872 // Methods XNameAccess
2873 Any SfxLibrary::getByName( const OUString& aName )
2874     throw(NoSuchElementException, WrappedTargetException, RuntimeException)
2875 {
2876     impl_checkLoaded();
2877
2878     Any aRetAny = maNameContainer.getByName( aName ) ;
2879     return aRetAny;
2880 }
2881
2882 Sequence< OUString > SfxLibrary::getElementNames()
2883     throw(RuntimeException)
2884 {
2885     return maNameContainer.getElementNames();
2886 }
2887
2888 sal_Bool SfxLibrary::hasByName( const OUString& aName )
2889     throw(RuntimeException)
2890 {
2891     sal_Bool bRet = maNameContainer.hasByName( aName );
2892     return bRet;
2893 }
2894
2895 void SfxLibrary::impl_checkReadOnly()
2896 {
2897     if( mbReadOnly || (mbLink && mbReadOnlyLink) )
2898         throw IllegalArgumentException(
2899             ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Library is readonly." ) ),
2900             // TODO: resource
2901             *this, 0
2902         );
2903 }
2904
2905 void SfxLibrary::impl_checkLoaded()
2906 {
2907     if ( !mbLoaded )
2908         throw WrappedTargetException(
2909             ::rtl::OUString(),
2910             *this,
2911             makeAny( LibraryNotLoadedException(
2912                 ::rtl::OUString(),
2913                 *this
2914             ) )
2915         );
2916 }
2917
2918 // Methods XNameReplace
2919 void SfxLibrary::replaceByName( const OUString& aName, const Any& aElement )
2920     throw(IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException)
2921 {
2922     impl_checkReadOnly();
2923     impl_checkLoaded();
2924
2925     OSL_ENSURE( isLibraryElementValid( aElement ), "SfxLibrary::replaceByName: replacing element is invalid!" );
2926
2927     maNameContainer.replaceByName( aName, aElement );
2928     implSetModified( sal_True );
2929 }
2930
2931
2932 // Methods XNameContainer
2933 void SfxLibrary::insertByName( const OUString& aName, const Any& aElement )
2934     throw(IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException)
2935 {
2936     impl_checkReadOnly();
2937     impl_checkLoaded();
2938
2939     OSL_ENSURE( isLibraryElementValid( aElement ), "SfxLibrary::insertByName: to-be-inserted element is invalid!" );
2940
2941     maNameContainer.insertByName( aName, aElement );
2942     implSetModified( sal_True );
2943 }
2944
2945 void SfxLibrary::impl_removeWithoutChecks( const ::rtl::OUString& _rElementName )
2946 {
2947     maNameContainer.removeByName( _rElementName );
2948     implSetModified( sal_True );
2949
2950     // Remove element file
2951     if( maStorageURL.getLength() )
2952     {
2953         INetURLObject aElementInetObj( maStorageURL );
2954         aElementInetObj.insertName( _rElementName, sal_False,
2955             INetURLObject::LAST_SEGMENT, sal_True, INetURLObject::ENCODE_ALL );
2956         aElementInetObj.setExtension( maLibElementFileExtension );
2957         OUString aFile = aElementInetObj.GetMainURL( INetURLObject::NO_DECODE );
2958
2959         try
2960         {
2961             if( mxSFI->exists( aFile ) )
2962                 mxSFI->kill( aFile );
2963         }
2964         catch( Exception& )
2965         {
2966             DBG_UNHANDLED_EXCEPTION();
2967         }
2968     }
2969 }
2970
2971 void SfxLibrary::removeByName( const OUString& Name )
2972     throw(NoSuchElementException, WrappedTargetException, RuntimeException)
2973 {
2974     impl_checkReadOnly();
2975     impl_checkLoaded();
2976     impl_removeWithoutChecks( Name );
2977 }
2978
2979 // XTypeProvider
2980 Sequence< Type > SfxLibrary::getTypes()
2981     throw( RuntimeException )
2982 {
2983     static OTypeCollection * s_pTypes_NameContainer = 0;
2984     {
2985         if( !s_pTypes_NameContainer )
2986         {
2987             MutexGuard aGuard( Mutex::getGlobalMutex() );
2988             if( !s_pTypes_NameContainer )
2989             {
2990                 static OTypeCollection s_aTypes_NameContainer(
2991                     ::getCppuType( (const Reference< XNameContainer > *)0 ),
2992                     ::getCppuType( (const Reference< XContainer > *)0 ),
2993                     OComponentHelper::getTypes() );
2994                 s_pTypes_NameContainer = &s_aTypes_NameContainer;
2995             }
2996         }
2997         return s_pTypes_NameContainer->getTypes();
2998     }
2999 }
3000
3001
3002 Sequence< sal_Int8 > SfxLibrary::getImplementationId()
3003     throw( RuntimeException )
3004 {
3005     static OImplementationId * s_pId_NameContainer = 0;
3006     {
3007         if( !s_pId_NameContainer )
3008         {
3009             MutexGuard aGuard( Mutex::getGlobalMutex() );
3010             if( !s_pId_NameContainer )
3011             {
3012                 static OImplementationId s_aId_NameContainer;
3013                 s_pId_NameContainer = &s_aId_NameContainer;
3014             }
3015         }
3016         return s_pId_NameContainer->getImplementationId();
3017     }
3018 }
3019
3020
3021 //============================================================================
3022
3023 // Methods XContainer
3024 void SAL_CALL SfxLibrary::addContainerListener( const Reference< XContainerListener >& xListener )
3025     throw (RuntimeException)
3026 {
3027     maNameContainer.setEventSource( static_cast< XInterface* >( (OWeakObject*)this ) );
3028     maNameContainer.addContainerListener( xListener );
3029 }
3030
3031 void SAL_CALL SfxLibrary::removeContainerListener( const Reference< XContainerListener >& xListener )
3032     throw (RuntimeException)
3033 {
3034     maNameContainer.removeContainerListener( xListener );
3035 }
3036
3037
3038 //============================================================================
3039 // Implementation class ScriptExtensionIterator
3040
3041 static rtl::OUString aBasicLibMediaType( rtl::OUString::createFromAscii( "application/vnd.sun.star.basic-library" ) );
3042 static rtl::OUString aDialogLibMediaType( rtl::OUString::createFromAscii( "application/vnd.sun.star.dialog-library" ) );
3043
3044 ScriptExtensionIterator::ScriptExtensionIterator( void )
3045     : m_eState( USER_EXTENSIONS )
3046     , m_bUserPackagesLoaded( false )
3047     , m_bSharedPackagesLoaded( false )
3048     , m_iUserPackage( 0 )
3049     , m_iSharedPackage( 0 )
3050     , m_pScriptSubPackageIterator( NULL )
3051 {
3052     Reference< XMultiServiceFactory > xFactory = comphelper::getProcessServiceFactory();
3053     Reference< XPropertySet > xProps( xFactory, UNO_QUERY );
3054     OSL_ASSERT( xProps.is() );
3055     if (xProps.is())
3056     {
3057         xProps->getPropertyValue(
3058             ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("DefaultContext") ) ) >>= m_xContext;
3059         OSL_ASSERT( m_xContext.is() );
3060     }
3061     if( !m_xContext.is() )
3062     {
3063         throw RuntimeException(
3064             ::rtl::OUString::createFromAscii( "ScriptExtensionIterator::init(), no XComponentContext" ),
3065             Reference< XInterface >() );
3066     }
3067 }
3068
3069 rtl::OUString ScriptExtensionIterator::nextBasicOrDialogLibrary( bool& rbPureDialogLib )
3070 {
3071     rtl::OUString aRetLib;
3072
3073     while( !aRetLib.getLength() && m_eState != END_REACHED )
3074     {
3075         switch( m_eState )
3076         {
3077             case USER_EXTENSIONS:
3078             {
3079                 Reference< deployment::XPackage > xScriptPackage =
3080                     implGetNextUserScriptPackage( rbPureDialogLib );
3081                 if( !xScriptPackage.is() )
3082                     break;
3083
3084                 aRetLib = xScriptPackage->getURL();
3085                 break;
3086             }
3087
3088             case SHARED_EXTENSIONS:
3089             {
3090                 Reference< deployment::XPackage > xScriptPackage =
3091                     implGetNextSharedScriptPackage( rbPureDialogLib );
3092                 if( !xScriptPackage.is() )
3093                     break;
3094
3095                 aRetLib = xScriptPackage->getURL();
3096                 break;
3097             }
3098             case END_REACHED:
3099                 VOS_ENSURE( false, "ScriptExtensionIterator::nextBasicOrDialogLibrary(): Invalid case END_REACHED" );
3100                 break;
3101         }
3102     }
3103
3104     return aRetLib;
3105 }
3106
3107 ScriptSubPackageIterator::ScriptSubPackageIterator( Reference< deployment::XPackage > xMainPackage )
3108     : m_xMainPackage( xMainPackage )
3109     , m_bIsValid( false )
3110     , m_bIsBundle( false )
3111     , m_nSubPkgCount( 0 )
3112     , m_iNextSubPkg( 0 )
3113 {
3114     Reference< deployment::XPackage > xScriptPackage;
3115     if( !m_xMainPackage.is() )
3116         return;
3117
3118     // Check if parent package is registered
3119     beans::Optional< beans::Ambiguous<sal_Bool> > option( m_xMainPackage->isRegistered
3120         ( Reference<task::XAbortChannel>(), Reference<ucb::XCommandEnvironment>() ) );
3121     bool bRegistered = false;
3122     if( option.IsPresent )
3123     {
3124         beans::Ambiguous<sal_Bool> const & reg = option.Value;
3125         if( !reg.IsAmbiguous && reg.Value )
3126             bRegistered = true;
3127     }
3128     if( bRegistered )
3129     {
3130         m_bIsValid = true;
3131         if( m_xMainPackage->isBundle() )
3132         {
3133             m_bIsBundle = true;
3134             m_aSubPkgSeq = m_xMainPackage->getBundle
3135                 ( Reference<task::XAbortChannel>(), Reference<ucb::XCommandEnvironment>() );
3136             m_nSubPkgCount = m_aSubPkgSeq.getLength();
3137         }
3138     }
3139 }
3140
3141 Reference< deployment::XPackage > ScriptSubPackageIterator::getNextScriptSubPackage
3142     ( bool& rbPureDialogLib )
3143 {
3144     rbPureDialogLib = false;
3145
3146     Reference< deployment::XPackage > xScriptPackage;
3147     if( !m_bIsValid )
3148         return xScriptPackage;
3149
3150     if( m_bIsBundle )
3151     {
3152         const Reference< deployment::XPackage >* pSeq = m_aSubPkgSeq.getConstArray();
3153         sal_Int32 iPkg;
3154         for( iPkg = m_iNextSubPkg ; iPkg < m_nSubPkgCount ; ++iPkg )
3155         {
3156             const Reference< deployment::XPackage > xSubPkg = pSeq[ iPkg ];
3157             xScriptPackage = implDetectScriptPackage( xSubPkg, rbPureDialogLib );
3158             if( xScriptPackage.is() )
3159                 break;
3160         }
3161         m_iNextSubPkg = iPkg + 1;
3162     }
3163     else
3164     {
3165         xScriptPackage = implDetectScriptPackage( m_xMainPackage, rbPureDialogLib );
3166         m_bIsValid = false;             // No more script packages
3167     }
3168
3169     return xScriptPackage;
3170 }
3171
3172 Reference< deployment::XPackage > ScriptSubPackageIterator::implDetectScriptPackage
3173     ( const Reference< deployment::XPackage > xPackage, bool& rbPureDialogLib )
3174 {
3175     Reference< deployment::XPackage > xScriptPackage;
3176
3177     if( xPackage.is() )
3178     {
3179         const Reference< deployment::XPackageTypeInfo > xPackageTypeInfo = xPackage->getPackageType();
3180         rtl::OUString aMediaType = xPackageTypeInfo->getMediaType();
3181         if( aMediaType.equals( aBasicLibMediaType ) )
3182         {
3183             xScriptPackage = xPackage;
3184         }
3185         else if( aMediaType.equals( aDialogLibMediaType ) )
3186         {
3187             rbPureDialogLib = true;
3188             xScriptPackage = xPackage;
3189         }
3190     }
3191
3192     return xScriptPackage;
3193 }
3194
3195 Reference< deployment::XPackage > ScriptExtensionIterator::implGetScriptPackageFromPackage
3196     ( const Reference< deployment::XPackage > xPackage, bool& rbPureDialogLib )
3197 {
3198     rbPureDialogLib = false;
3199
3200     Reference< deployment::XPackage > xScriptPackage;
3201     if( !xPackage.is() )
3202         return xScriptPackage;
3203
3204     // Check if parent package is registered
3205     beans::Optional< beans::Ambiguous<sal_Bool> > option( xPackage->isRegistered
3206         ( Reference<task::XAbortChannel>(), Reference<ucb::XCommandEnvironment>() ) );
3207     bool bRegistered = false;
3208     if( option.IsPresent )
3209     {
3210         beans::Ambiguous<sal_Bool> const & reg = option.Value;
3211         if( !reg.IsAmbiguous && reg.Value )
3212             bRegistered = true;
3213     }
3214     if( bRegistered )
3215     {
3216         if( xPackage->isBundle() )
3217         {
3218             Sequence< Reference< deployment::XPackage > > aPkgSeq = xPackage->getBundle
3219                 ( Reference<task::XAbortChannel>(), Reference<ucb::XCommandEnvironment>() );
3220             sal_Int32 nPkgCount = aPkgSeq.getLength();
3221             const Reference< deployment::XPackage >* pSeq = aPkgSeq.getConstArray();
3222             for( sal_Int32 iPkg = 0 ; iPkg < nPkgCount ; ++iPkg )
3223             {
3224                 const Reference< deployment::XPackage > xSubPkg = pSeq[ iPkg ];
3225                 const Reference< deployment::XPackageTypeInfo > xPackageTypeInfo = xSubPkg->getPackageType();
3226                 rtl::OUString aMediaType = xPackageTypeInfo->getMediaType();
3227                 if( aMediaType.equals( aBasicLibMediaType ) )
3228                 {
3229                     xScriptPackage = xSubPkg;
3230                     break;
3231                 }
3232                 else if( aMediaType.equals( aDialogLibMediaType ) )
3233                 {
3234                     rbPureDialogLib = true;
3235                     xScriptPackage = xSubPkg;
3236                     break;
3237                 }
3238             }
3239         }
3240         else
3241         {
3242             const Reference< deployment::XPackageTypeInfo > xPackageTypeInfo = xPackage->getPackageType();
3243             rtl::OUString aMediaType = xPackageTypeInfo->getMediaType();
3244             if( aMediaType.equals( aBasicLibMediaType ) )
3245             {
3246                 xScriptPackage = xPackage;
3247             }
3248             else if( aMediaType.equals( aDialogLibMediaType ) )
3249             {
3250                 rbPureDialogLib = true;
3251                 xScriptPackage = xPackage;
3252             }
3253         }
3254     }
3255
3256     return xScriptPackage;
3257 }
3258
3259 Reference< deployment::XPackage > ScriptExtensionIterator::implGetNextUserScriptPackage
3260     ( bool& rbPureDialogLib )
3261 {
3262     Reference< deployment::XPackage > xScriptPackage;
3263
3264     if( !m_bUserPackagesLoaded )
3265     {
3266         try
3267         {
3268             Reference< XPackageManager > xUserManager =
3269                 thePackageManagerFactory::get( m_xContext )->getPackageManager( rtl::OUString::createFromAscii("user") );
3270             m_aUserPackagesSeq = xUserManager->getDeployedPackages
3271                 ( Reference< task::XAbortChannel >(), Reference< ucb::XCommandEnvironment >() );
3272         }
3273         catch( com::sun::star::uno::DeploymentException& )
3274         {
3275             // Special Office installations may not contain deployment code
3276             m_eState = END_REACHED;
3277             return xScriptPackage;
3278         }
3279
3280         m_bUserPackagesLoaded = true;
3281     }
3282
3283     if( m_iUserPackage == m_aUserPackagesSeq.getLength() )
3284     {
3285         m_eState = SHARED_EXTENSIONS;           // Later: SHARED_MODULE
3286     }
3287     else
3288     {
3289         if( m_pScriptSubPackageIterator == NULL )
3290         {
3291             const Reference< deployment::XPackage >* pUserPackages = m_aUserPackagesSeq.getConstArray();
3292             Reference< deployment::XPackage > xPackage = pUserPackages[ m_iUserPackage ];
3293             VOS_ENSURE( xPackage.is(), "ScriptExtensionIterator::implGetNextUserScriptPackage(): Invalid package" );
3294             m_pScriptSubPackageIterator = new ScriptSubPackageIterator( xPackage );
3295         }
3296
3297         if( m_pScriptSubPackageIterator != NULL )
3298         {
3299             xScriptPackage = m_pScriptSubPackageIterator->getNextScriptSubPackage( rbPureDialogLib );
3300             if( !xScriptPackage.is() )
3301             {
3302                 delete m_pScriptSubPackageIterator;
3303                 m_pScriptSubPackageIterator = NULL;
3304                 m_iUserPackage++;
3305             }
3306         }
3307     }
3308
3309     return xScriptPackage;
3310 }
3311
3312 Reference< deployment::XPackage > ScriptExtensionIterator::implGetNextSharedScriptPackage
3313     ( bool& rbPureDialogLib )
3314 {
3315     Reference< deployment::XPackage > xScriptPackage;
3316
3317     if( !m_bSharedPackagesLoaded )
3318     {
3319         try
3320         {
3321             Reference< XPackageManager > xSharedManager =
3322                 thePackageManagerFactory::get( m_xContext )->getPackageManager( rtl::OUString::createFromAscii("shared") );
3323             m_aSharedPackagesSeq = xSharedManager->getDeployedPackages
3324                 ( Reference< task::XAbortChannel >(), Reference< ucb::XCommandEnvironment >() );
3325         }
3326         catch( com::sun::star::uno::DeploymentException& )
3327         {
3328             // Special Office installations may not contain deployment code
3329             return xScriptPackage;
3330         }
3331
3332         m_bSharedPackagesLoaded = true;
3333     }
3334
3335     if( m_iSharedPackage == m_aSharedPackagesSeq.getLength() )
3336     {
3337         m_eState = END_REACHED;
3338     }
3339     else
3340     {
3341         if( m_pScriptSubPackageIterator == NULL )
3342         {
3343             const Reference< deployment::XPackage >* pSharedPackages = m_aSharedPackagesSeq.getConstArray();
3344             Reference< deployment::XPackage > xPackage = pSharedPackages[ m_iSharedPackage ];
3345             VOS_ENSURE( xPackage.is(), "ScriptExtensionIterator::implGetNextSharedScriptPackage(): Invalid package" );
3346             m_pScriptSubPackageIterator = new ScriptSubPackageIterator( xPackage );
3347         }
3348
3349         if( m_pScriptSubPackageIterator != NULL )
3350         {
3351             xScriptPackage = m_pScriptSubPackageIterator->getNextScriptSubPackage( rbPureDialogLib );
3352             if( !xScriptPackage.is() )
3353             {
3354                 delete m_pScriptSubPackageIterator;
3355                 m_pScriptSubPackageIterator = NULL;
3356                 m_iSharedPackage++;
3357             }
3358         }
3359     }
3360
3361     return xScriptPackage;
3362 }
3363
3364 }   // namespace basic