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