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