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