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