| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_basic.hxx" | |
| #include <basic/basicmanagerrepository.hxx> | |
| #include <basic/basmgr.hxx> | |
| #include "scriptcont.hxx" | |
| #include "dlgcont.hxx" | |
| #include <basic/sbuno.hxx> | |
| #include "sbintern.hxx" | |
| /** === begin UNO includes === **/ | |
| #include <com/sun/star/beans/XPropertySet.hpp> | |
| #include <com/sun/star/document/XStorageBasedDocument.hpp> | |
| #include <com/sun/star/document/XEmbeddedScripts.hpp> | |
| /** === end UNO includes === **/ | |
| #include <svtools/ehdl.hxx> | |
| #include <svtools/sfxecode.hxx> | |
| #include <unotools/pathoptions.hxx> | |
| #include <svl/smplhint.hxx> | |
| #include <vcl/svapp.hxx> | |
| #include <tools/debug.hxx> | |
| #include <tools/diagnose_ex.h> | |
| #include <tools/urlobj.hxx> | |
| #include <comphelper/stl_types.hxx> | |
| #include <comphelper/processfactory.hxx> | |
| #include <comphelper/documentinfo.hxx> | |
| #include <unotools/eventlisteneradapter.hxx> | |
| #ifndef INCLUDED_OSL_DOUBLECHECKEDLOCKING_H | |
| #include <rtl/instance.hxx> | |
| #endif | |
| #include <map> | |
| //........................................................................ | |
| namespace basic | |
| { | |
| //........................................................................ | |
| /** === begin UNO using === **/ | |
| using ::com::sun::star::uno::Reference; | |
| using ::com::sun::star::frame::XModel; | |
| using ::com::sun::star::uno::XInterface; | |
| using ::com::sun::star::uno::UNO_QUERY; | |
| using ::com::sun::star::embed::XStorage; | |
| using ::com::sun::star::script::XPersistentLibraryContainer; | |
| using ::com::sun::star::uno::Any; | |
| using ::com::sun::star::lang::XMultiServiceFactory; | |
| using ::com::sun::star::uno::UNO_QUERY_THROW; | |
| using ::com::sun::star::beans::XPropertySet; | |
| using ::com::sun::star::uno::Exception; | |
| using ::com::sun::star::document::XStorageBasedDocument; | |
| using ::com::sun::star::lang::XComponent; | |
| using ::com::sun::star::document::XEmbeddedScripts; | |
| /** === end UNO using === **/ | |
| typedef BasicManager* BasicManagerPointer; | |
| typedef ::std::map< Reference< XInterface >, BasicManagerPointer, ::comphelper::OInterfaceCompare< XInterface > > BasicManagerStore; | |
| typedef ::std::vector< BasicManagerCreationListener* > CreationListeners; | |
| //==================================================================== | |
| //= BasicManagerCleaner | |
| //==================================================================== | |
| /// is the only instance which is allowed to delete a BasicManager instance | |
| class BasicManagerCleaner | |
| { | |
| public: | |
| static void deleteBasicManager( BasicManager*& _rpManager ) | |
| { | |
| delete _rpManager; | |
| _rpManager = NULL; | |
| } | |
| }; | |
| //==================================================================== | |
| //= ImplRepository | |
| //==================================================================== | |
| class ImplRepository : public ::utl::OEventListenerAdapter, public SfxListener | |
| { | |
| private: | |
| friend struct CreateImplRepository; | |
| ImplRepository(); | |
| private: | |
| ::osl::Mutex m_aMutex; | |
| BasicManagerStore m_aStore; | |
| CreationListeners m_aCreationListeners; | |
| public: | |
| static ImplRepository& Instance(); | |
| BasicManager* getDocumentBasicManager( const Reference< XModel >& _rxDocumentModel ); | |
| BasicManager* getApplicationBasicManager( bool _bCreate ); | |
| void setApplicationBasicManager( BasicManager* _pBasicManager ); | |
| void registerCreationListener( BasicManagerCreationListener& _rListener ); | |
| void revokeCreationListener( BasicManagerCreationListener& _rListener ); | |
| private: | |
| /** retrieves the location at which the BasicManager for the given model | |
| is stored. | |
| If previously, the BasicManager for this model has never been requested, | |
| then the model is added to the map, with an initial NULL BasicManager. | |
| @param _rxDocumentModel | |
| the model whose BasicManager's location is to be retrieved. Must not be <NULL/>. | |
| @precond | |
| our mutex is locked | |
| */ | |
| BasicManagerPointer& | |
| impl_getLocationForModel( const Reference< XModel >& _rxDocumentModel ); | |
| /** creates a new BasicManager instance for the given model | |
| @param _out_rpBasicManager | |
| reference to the pointer variable that will hold the new | |
| BasicManager. | |
| @param _rxDocumentModel | |
| the model whose BasicManager will be created. Must not be <NULL/>. | |
| */ | |
| void impl_createManagerForModel( | |
| BasicManagerPointer& _out_rpBasicManager, | |
| const Reference< XModel >& _rxDocumentModel ); | |
| /** creates the application-wide BasicManager | |
| */ | |
| BasicManagerPointer impl_createApplicationBasicManager(); | |
| /** notifies all listeners which expressed interest in the creation of BasicManager instances. | |
| */ | |
| void impl_notifyCreationListeners( | |
| const Reference< XModel >& _rxDocumentModel, | |
| BasicManager& _rManager | |
| ); | |
| /** retrieves the current storage of a given document | |
| @param _rxDocument | |
| the document whose storage is to be retrieved. | |
| @param _out_rStorage | |
| takes the storage upon successful return. Note that this might be <NULL/> even | |
| if <TRUE/> is returned. In this case, the document has not yet been saved. | |
| @return | |
| <TRUE/> if the storage could be successfully retrieved (in which case | |
| <arg>_out_rStorage</arg> might or might not be <NULL/>), <FALSE/> otherwise. | |
| In the latter case, processing this document should stop. | |
| */ | |
| bool impl_getDocumentStorage_nothrow( const Reference< XModel >& _rxDocument, Reference< XStorage >& _out_rStorage ); | |
| /** retrieves the containers for Basic and Dialog libraries for a given document | |
| @param _rxDocument | |
| the document whose containers are to be retrieved. | |
| @param _out_rxBasicLibraries | |
| takes the basic library container upon successful return | |
| @param _out_rxDialogLibraries | |
| takes the dialog library container upon successful return | |
| @return | |
| <TRUE/> if and only if both containers exist, and could successfully be retrieved | |
| */ | |
| bool impl_getDocumentLibraryContainers_nothrow( | |
| const Reference< XModel >& _rxDocument, | |
| Reference< XPersistentLibraryContainer >& _out_rxBasicLibraries, | |
| Reference< XPersistentLibraryContainer >& _out_rxDialogLibraries | |
| ); | |
| /** initializes the given library containers, which belong to a document | |
| */ | |
| void impl_initDocLibraryContainers_nothrow( | |
| const Reference< XPersistentLibraryContainer >& _rxBasicLibraries, | |
| const Reference< XPersistentLibraryContainer >& _rxDialogLibraries | |
| ); | |
| // OEventListenerAdapter overridables | |
| virtual void _disposing( const ::com::sun::star::lang::EventObject& _rSource ); | |
| // SfxListener overridables | |
| virtual void Notify( SfxBroadcaster& _rBC, const SfxHint& _rHint ); | |
| /** removes the Model/BasicManager pair given by iterator from our store | |
| */ | |
| void impl_removeFromRepository( BasicManagerStore::iterator _pos ); | |
| private: | |
| StarBASIC* impl_getDefaultAppBasicLibrary(); | |
| }; | |
| //==================================================================== | |
| //= CreateImplRepository | |
| //==================================================================== | |
| struct CreateImplRepository | |
| { | |
| ImplRepository* operator()() | |
| { | |
| static ImplRepository* pRepository = new ImplRepository; | |
| return pRepository; | |
| } | |
| }; | |
| //==================================================================== | |
| //= ImplRepository | |
| //==================================================================== | |
| //-------------------------------------------------------------------- | |
| ImplRepository::ImplRepository() | |
| { | |
| } | |
| //-------------------------------------------------------------------- | |
| ImplRepository& ImplRepository::Instance() | |
| { | |
| return *rtl_Instance< ImplRepository, CreateImplRepository, ::osl::MutexGuard, ::osl::GetGlobalMutex >:: | |
| create( CreateImplRepository(), ::osl::GetGlobalMutex() ); | |
| } | |
| //-------------------------------------------------------------------- | |
| BasicManager* ImplRepository::getDocumentBasicManager( const Reference< XModel >& _rxDocumentModel ) | |
| { | |
| ::osl::MutexGuard aGuard( m_aMutex ); | |
| /* #163556# (DR) - This function may be called recursively while | |
| constructing the Basic manager and loading the Basic storage. By | |
| passing the map entry received from impl_getLocationForModel() to | |
| the function impl_createManagerForModel(), the new Basic manager | |
| will be put immediately into the map of existing Basic managers, | |
| thus a recursive call of this function will find and return it | |
| without creating another instance. | |
| */ | |
| BasicManagerPointer& pBasicManager = impl_getLocationForModel( _rxDocumentModel ); | |
| if ( pBasicManager == NULL ) | |
| impl_createManagerForModel( pBasicManager, _rxDocumentModel ); | |
| return pBasicManager; | |
| } | |
| //-------------------------------------------------------------------- | |
| BasicManager* ImplRepository::getApplicationBasicManager( bool _bCreate ) | |
| { | |
| ::osl::MutexGuard aGuard( m_aMutex ); | |
| BasicManager* pAppManager = GetSbData()->pAppBasMgr; | |
| if ( ( pAppManager == NULL ) && _bCreate ) | |
| pAppManager = impl_createApplicationBasicManager(); | |
| return pAppManager; | |
| } | |
| //-------------------------------------------------------------------- | |
| void ImplRepository::setApplicationBasicManager( BasicManager* _pBasicManager ) | |
| { | |
| ::osl::MutexGuard aGuard( m_aMutex ); | |
| BasicManager* pPreviousManager = getApplicationBasicManager( false ); | |
| BasicManagerCleaner::deleteBasicManager( pPreviousManager ); | |
| GetSbData()->pAppBasMgr = _pBasicManager; | |
| } | |
| //-------------------------------------------------------------------- | |
| BasicManager* ImplRepository::impl_createApplicationBasicManager() | |
| { | |
| ::osl::MutexGuard aGuard( m_aMutex ); | |
| OSL_PRECOND( getApplicationBasicManager( false ) == NULL, "ImplRepository::impl_createApplicationBasicManager: there already is one!" ); | |
| // Determine Directory | |
| SvtPathOptions aPathCFG; | |
| String aAppBasicDir( aPathCFG.GetBasicPath() ); | |
| if ( !aAppBasicDir.Len() ) | |
| aPathCFG.SetBasicPath( String::CreateFromAscii("$(prog)") ); | |
| // #58293# soffice.new search only in user dir => first dir | |
| String aAppFirstBasicDir = aAppBasicDir.GetToken(1); | |
| // Create basic and load it | |
| // MT: #47347# AppBasicDir is now a PATH | |
| INetURLObject aAppBasic( SvtPathOptions().SubstituteVariable( String::CreateFromAscii("$(progurl)") ) ); | |
| aAppBasic.insertName( Application::GetAppName() ); | |
| BasicManager* pBasicManager = new BasicManager( new StarBASIC, &aAppBasicDir ); | |
| setApplicationBasicManager( pBasicManager ); | |
| // Als Destination das erste Dir im Pfad: | |
| String aFileName( aAppBasic.getName() ); | |
| aAppBasic = INetURLObject( aAppBasicDir.GetToken(1) ); | |
| DBG_ASSERT( aAppBasic.GetProtocol() != INET_PROT_NOT_VALID, "Invalid URL!" ); | |
| aAppBasic.insertName( aFileName ); | |
| pBasicManager->SetStorageName( aAppBasic.PathToFileName() ); | |
| // Basic container | |
| SfxScriptLibraryContainer* pBasicCont = new SfxScriptLibraryContainer( Reference< XStorage >() ); | |
| Reference< XPersistentLibraryContainer > xBasicCont( pBasicCont ); | |
| pBasicCont->setBasicManager( pBasicManager ); | |
| // Dialog container | |
| SfxDialogLibraryContainer* pDialogCont = new SfxDialogLibraryContainer( Reference< XStorage >() ); | |
| Reference< XPersistentLibraryContainer > xDialogCont( pDialogCont ); | |
| LibraryContainerInfo aInfo( xBasicCont, xDialogCont, static_cast< OldBasicPassword* >( pBasicCont ) ); | |
| pBasicManager->SetLibraryContainerInfo( aInfo ); | |
| // global constants | |
| // StarDesktop | |
| Reference< XMultiServiceFactory > xSMgr = ::comphelper::getProcessServiceFactory(); | |
| pBasicManager->SetGlobalUNOConstant( | |
| "StarDesktop", | |
| makeAny( xSMgr->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.frame.Desktop" ) ) ) ) | |
| ); | |
| // (BasicLibraries and DialogLibraries have automatically been added in SetLibraryContainerInfo) | |
| // notify | |
| impl_notifyCreationListeners( NULL, *pBasicManager ); | |
| // outta here | |
| return pBasicManager; | |
| } | |
| //-------------------------------------------------------------------- | |
| void ImplRepository::registerCreationListener( BasicManagerCreationListener& _rListener ) | |
| { | |
| ::osl::MutexGuard aGuard( m_aMutex ); | |
| m_aCreationListeners.push_back( &_rListener ); | |
| } | |
| //-------------------------------------------------------------------- | |
| void ImplRepository::revokeCreationListener( BasicManagerCreationListener& _rListener ) | |
| { | |
| ::osl::MutexGuard aGuard( m_aMutex ); | |
| CreationListeners::iterator pos = ::std::find( m_aCreationListeners.begin(), m_aCreationListeners.end(), &_rListener ); | |
| if ( pos != m_aCreationListeners.end() ) | |
| m_aCreationListeners.erase( pos ); | |
| else { | |
| DBG_ERROR( "ImplRepository::revokeCreationListener: listener is not registered!" ); | |
| } | |
| } | |
| //-------------------------------------------------------------------- | |
| void ImplRepository::impl_notifyCreationListeners( const Reference< XModel >& _rxDocumentModel, BasicManager& _rManager ) | |
| { | |
| for ( CreationListeners::const_iterator loop = m_aCreationListeners.begin(); | |
| loop != m_aCreationListeners.end(); | |
| ++loop | |
| ) | |
| { | |
| (*loop)->onBasicManagerCreated( _rxDocumentModel, _rManager ); | |
| } | |
| } | |
| //-------------------------------------------------------------------- | |
| StarBASIC* ImplRepository::impl_getDefaultAppBasicLibrary() | |
| { | |
| BasicManager* pAppManager = getApplicationBasicManager( true ); | |
| StarBASIC* pAppBasic = pAppManager ? pAppManager->GetLib(0) : NULL; | |
| DBG_ASSERT( pAppBasic != NULL, "impl_getApplicationBasic: unable to determine the default application's Basic library!" ); | |
| return pAppBasic; | |
| } | |
| //-------------------------------------------------------------------- | |
| BasicManagerPointer& ImplRepository::impl_getLocationForModel( const Reference< XModel >& _rxDocumentModel ) | |
| { | |
| Reference< XInterface > xNormalized( _rxDocumentModel, UNO_QUERY ); | |
| DBG_ASSERT( xNormalized.is(), "ImplRepository::impl_getLocationForModel: invalid model!" ); | |
| BasicManagerPointer& location = m_aStore[ xNormalized ]; | |
| return location; | |
| } | |
| //-------------------------------------------------------------------- | |
| void ImplRepository::impl_initDocLibraryContainers_nothrow( const Reference< XPersistentLibraryContainer >& _rxBasicLibraries, const Reference< XPersistentLibraryContainer >& _rxDialogLibraries ) | |
| { | |
| OSL_PRECOND( _rxBasicLibraries.is() && _rxDialogLibraries.is(), | |
| "ImplRepository::impl_initDocLibraryContainers_nothrow: illegal library containers, this will crash!" ); | |
| try | |
| { | |
| // ensure there's a standard library in the basic container | |
| ::rtl::OUString aStdLibName( RTL_CONSTASCII_USTRINGPARAM( "Standard" ) ); | |
| if ( !_rxBasicLibraries->hasByName( aStdLibName ) ) | |
| _rxBasicLibraries->createLibrary( aStdLibName ); | |
| // as well as in the dialog container | |
| if ( !_rxDialogLibraries->hasByName( aStdLibName ) ) | |
| _rxDialogLibraries->createLibrary( aStdLibName ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| } | |
| //-------------------------------------------------------------------- | |
| void ImplRepository::impl_createManagerForModel( BasicManagerPointer& _out_rpBasicManager, const Reference< XModel >& _rxDocumentModel ) | |
| { | |
| StarBASIC* pAppBasic = impl_getDefaultAppBasicLibrary(); | |
| _out_rpBasicManager = 0; | |
| Reference< XStorage > xStorage; | |
| if ( !impl_getDocumentStorage_nothrow( _rxDocumentModel, xStorage ) ) | |
| // the document is not able to provide the storage it is based on. | |
| return; | |
| Reference< XPersistentLibraryContainer > xBasicLibs; | |
| Reference< XPersistentLibraryContainer > xDialogLibs; | |
| if ( !impl_getDocumentLibraryContainers_nothrow( _rxDocumentModel, xBasicLibs, xDialogLibs ) ) | |
| // the document does not have BasicLibraries and DialogLibraries | |
| return; | |
| if ( xStorage.is() ) | |
| { | |
| // load BASIC-manager | |
| SfxErrorContext aErrContext( ERRCTX_SFX_LOADBASIC, | |
| ::comphelper::DocumentInfo::getDocumentTitle( _rxDocumentModel ) ); | |
| String aAppBasicDir = SvtPathOptions().GetBasicPath(); | |
| // Storage and BaseURL are only needed by binary documents! | |
| SotStorageRef xDummyStor = new SotStorage( ::rtl::OUString() ); | |
| _out_rpBasicManager = new BasicManager( *xDummyStor, String() /* TODO/LATER: xStorage */, | |
| pAppBasic, | |
| &aAppBasicDir, sal_True ); | |
| if ( _out_rpBasicManager->HasErrors() ) | |
| { | |
| // handle errors | |
| BasicError* pErr = _out_rpBasicManager->GetFirstError(); | |
| while ( pErr ) | |
| { | |
| // show message to user | |
| if ( ERRCODE_BUTTON_CANCEL == ErrorHandler::HandleError( pErr->GetErrorId() ) ) | |
| { | |
| // user wants to break loading of BASIC-manager | |
| BasicManagerCleaner::deleteBasicManager( _out_rpBasicManager ); | |
| xStorage.clear(); | |
| break; | |
| } | |
| pErr = _out_rpBasicManager->GetNextError(); | |
| } | |
| } | |
| } | |
| // not loaded? | |
| if ( !xStorage.is() ) | |
| { | |
| // create new BASIC-manager | |
| StarBASIC* pBasic = new StarBASIC( pAppBasic ); | |
| pBasic->SetFlag( SBX_EXTSEARCH ); | |
| _out_rpBasicManager = new BasicManager( pBasic, NULL, sal_True ); | |
| } | |
| // knit the containers with the BasicManager | |
| LibraryContainerInfo aInfo( xBasicLibs, xDialogLibs, dynamic_cast< OldBasicPassword* >( xBasicLibs.get() ) ); | |
| OSL_ENSURE( aInfo.mpOldBasicPassword, "ImplRepository::impl_createManagerForModel: wrong BasicLibraries implementation!" ); | |
| _out_rpBasicManager->SetLibraryContainerInfo( aInfo ); | |
| //pBasicCont->setBasicManager( _out_rpBasicManager ); | |
| // that's not needed anymore today. The containers will retrieve their associated | |
| // BasicManager from the BasicManagerRepository, when needed. | |
| // initialize the containers | |
| impl_initDocLibraryContainers_nothrow( xBasicLibs, xDialogLibs ); | |
| // damit auch Dialoge etc. 'qualifiziert' angesprochen werden k"onnen | |
| _out_rpBasicManager->GetLib(0)->SetParent( pAppBasic ); | |
| // global properties in the document's Basic | |
| _out_rpBasicManager->SetGlobalUNOConstant( "ThisComponent", makeAny( _rxDocumentModel ) ); | |
| // notify | |
| impl_notifyCreationListeners( _rxDocumentModel, *_out_rpBasicManager ); | |
| // register as listener for this model being disposed/closed | |
| Reference< XComponent > xDocumentComponent( _rxDocumentModel, UNO_QUERY ); | |
| OSL_ENSURE( xDocumentComponent.is(), "ImplRepository::impl_createManagerForModel: the document must be an XComponent!" ); | |
| startComponentListening( xDocumentComponent ); | |
| // register as listener for the BasicManager being destroyed | |
| StartListening( *_out_rpBasicManager ); | |
| // #i104876: Library container must not be modified just after | |
| // creation. This happens as side effect when creating default | |
| // "Standard" libraries and needs to be corrected here | |
| xBasicLibs->setModified( sal_False ); | |
| xDialogLibs->setModified( sal_False ); | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ImplRepository::impl_getDocumentStorage_nothrow( const Reference< XModel >& _rxDocument, Reference< XStorage >& _out_rStorage ) | |
| { | |
| _out_rStorage.clear(); | |
| try | |
| { | |
| Reference< XStorageBasedDocument > xStorDoc( _rxDocument, UNO_QUERY_THROW ); | |
| _out_rStorage.set( xStorDoc->getDocumentStorage() ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| return false; | |
| } | |
| return true; | |
| } | |
| //-------------------------------------------------------------------- | |
| bool ImplRepository::impl_getDocumentLibraryContainers_nothrow( const Reference< XModel >& _rxDocument, | |
| Reference< XPersistentLibraryContainer >& _out_rxBasicLibraries, Reference< XPersistentLibraryContainer >& _out_rxDialogLibraries ) | |
| { | |
| _out_rxBasicLibraries.clear(); | |
| _out_rxDialogLibraries.clear(); | |
| try | |
| { | |
| Reference< XEmbeddedScripts > xScripts( _rxDocument, UNO_QUERY_THROW ); | |
| _out_rxBasicLibraries.set( xScripts->getBasicLibraries(), UNO_QUERY_THROW ); | |
| _out_rxDialogLibraries.set( xScripts->getDialogLibraries(), UNO_QUERY_THROW ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| return _out_rxBasicLibraries.is() && _out_rxDialogLibraries.is(); | |
| } | |
| //-------------------------------------------------------------------- | |
| void ImplRepository::impl_removeFromRepository( BasicManagerStore::iterator _pos ) | |
| { | |
| OSL_PRECOND( _pos != m_aStore.end(), "ImplRepository::impl_removeFromRepository: invalid position!" ); | |
| BasicManager* pManager = _pos->second; | |
| // *first* remove from map (else Notify won't work properly) | |
| m_aStore.erase( _pos ); | |
| // *then* delete the BasicManager | |
| EndListening( *pManager ); | |
| BasicManagerCleaner::deleteBasicManager( pManager ); | |
| } | |
| //-------------------------------------------------------------------- | |
| void ImplRepository::_disposing( const ::com::sun::star::lang::EventObject& _rSource ) | |
| { | |
| ::osl::MutexGuard aGuard( m_aMutex ); | |
| Reference< XInterface > xNormalizedSource( _rSource.Source, UNO_QUERY ); | |
| #if OSL_DEBUG_LEVEL > 0 | |
| bool bFound = false; | |
| #endif | |
| for ( BasicManagerStore::iterator loop = m_aStore.begin(); | |
| loop != m_aStore.end(); | |
| ++loop | |
| ) | |
| { | |
| if ( loop->first.get() == xNormalizedSource.get() ) | |
| { | |
| impl_removeFromRepository( loop ); | |
| #if OSL_DEBUG_LEVEL > 0 | |
| bFound = true; | |
| #endif | |
| break; | |
| } | |
| } | |
| OSL_ENSURE( bFound, "ImplRepository::_disposing: where does this come from?" ); | |
| } | |
| //-------------------------------------------------------------------- | |
| void ImplRepository::Notify( SfxBroadcaster& _rBC, const SfxHint& _rHint ) | |
| { | |
| const SfxSimpleHint* pSimpleHint = dynamic_cast< const SfxSimpleHint* >( &_rHint ); | |
| if ( !pSimpleHint || ( pSimpleHint->GetId() != SFX_HINT_DYING ) ) | |
| // not interested in | |
| return; | |
| BasicManager* pManager = dynamic_cast< BasicManager* >( &_rBC ); | |
| OSL_ENSURE( pManager, "ImplRepository::Notify: where does this come from?" ); | |
| for ( BasicManagerStore::iterator loop = m_aStore.begin(); | |
| loop != m_aStore.end(); | |
| ++loop | |
| ) | |
| { | |
| if ( loop->second == pManager ) | |
| { | |
| // a BasicManager which is still in our repository is being deleted. | |
| // That's bad, since by definition, we *own* all instances in our | |
| // repository. | |
| OSL_ENSURE( false, "ImplRepository::Notify: nobody should tamper with the managers, except ourself!" ); | |
| m_aStore.erase( loop ); | |
| break; | |
| } | |
| } | |
| } | |
| //==================================================================== | |
| //= BasicManagerRepository | |
| //==================================================================== | |
| //-------------------------------------------------------------------- | |
| BasicManager* BasicManagerRepository::getDocumentBasicManager( const Reference< XModel >& _rxDocumentModel ) | |
| { | |
| return ImplRepository::Instance().getDocumentBasicManager( _rxDocumentModel ); | |
| } | |
| //-------------------------------------------------------------------- | |
| BasicManager* BasicManagerRepository::getApplicationBasicManager( bool _bCreate ) | |
| { | |
| return ImplRepository::Instance().getApplicationBasicManager( _bCreate ); | |
| } | |
| //-------------------------------------------------------------------- | |
| void BasicManagerRepository::resetApplicationBasicManager() | |
| { | |
| return ImplRepository::Instance().setApplicationBasicManager( NULL ); | |
| } | |
| //-------------------------------------------------------------------- | |
| void BasicManagerRepository::registerCreationListener( BasicManagerCreationListener& _rListener ) | |
| { | |
| ImplRepository::Instance().registerCreationListener( _rListener ); | |
| } | |
| //-------------------------------------------------------------------- | |
| void BasicManagerRepository::revokeCreationListener( BasicManagerCreationListener& _rListener ) | |
| { | |
| ImplRepository::Instance().revokeCreationListener( _rListener ); | |
| } | |
| //........................................................................ | |
| } // namespace basic | |
| //........................................................................ |