LCOV - code coverage report
Current view: top level - basic/source/uno - namecont.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 1618 0.0 %
Date: 2014-04-14 Functions: 0 116 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10